// SPDX-License-Identifier: GPL-2.0-or-later

/***************************************************************************
 *   Copyright (C) 2017 by Texas Instruments, Inc.                         *
 ***************************************************************************/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "imp.h"
#include "cc3220sf.h"
#include <helper/binarybuffer.h>
#include <helper/time_support.h>
#include <target/algorithm.h>
#include <target/armv7m.h>

#define FLASH_TIMEOUT 5000

struct cc3220sf_bank {
	bool probed;
	struct armv7m_algorithm armv7m_info;
};

/* Flash helper algorithm for CC3220SF */
static const uint8_t cc3220sf_algo[] = {
#include "../../../contrib/loaders/flash/cc3220sf/cc3220sf.inc"
};

static int cc3220sf_mass_erase(struct flash_bank *bank)
{
	struct target *target = bank->target;
	bool done;
	long long start_ms;
	long long elapsed_ms;
	uint32_t value;

	int retval = ERROR_OK;

	if (target->state != TARGET_HALTED) {
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	/* Set starting address to erase to zero */
	retval = target_write_u32(target, FMA_REGISTER_ADDR, 0);
	if (retval != ERROR_OK)
		return retval;

	/* Write the MERASE bit of the FMC register */
	retval = target_write_u32(target, FMC_REGISTER_ADDR, FMC_MERASE_VALUE);
	if (retval != ERROR_OK)
		return retval;

	/* Poll the MERASE bit until the mass erase is complete */
	done = false;
	start_ms = timeval_ms();
	while (!done) {
		retval = target_read_u32(target, FMC_REGISTER_ADDR, &value);
		if (retval != ERROR_OK)
			return retval;

		if ((value & FMC_MERASE_BIT) == 0) {
			/* Bit clears when mass erase is finished */
			done = true;
		} else {
			elapsed_ms = timeval_ms() - start_ms;
			if (elapsed_ms > 500)
				keep_alive();
			if (elapsed_ms > FLASH_TIMEOUT)
				break;
		}
	}

	if (!done) {
		/* Mass erase timed out waiting for confirmation */
		return ERROR_FAIL;
	}

	return retval;
}

FLASH_BANK_COMMAND_HANDLER(cc3220sf_flash_bank_command)
{
	struct cc3220sf_bank *cc3220sf_bank;

	if (CMD_ARGC < 6)
		return ERROR_COMMAND_SYNTAX_ERROR;

	cc3220sf_bank = malloc(sizeof(struct cc3220sf_bank));
	if (!cc3220sf_bank)
		return ERROR_FAIL;

	/* Initialize private flash information */
	cc3220sf_bank->probed = false;

	/* Finish initialization of flash bank */
	bank->driver_priv = cc3220sf_bank;

	return ERROR_OK;
}

static int cc3220sf_erase(struct flash_bank *bank, unsigned int first,
		unsigned int last)
{
	struct target *target = bank->target;
	bool done;
	long long start_ms;
	long long elapsed_ms;
	uint32_t address;
	uint32_t value;

	int retval = ERROR_OK;

	if (target->state != TARGET_HALTED) {
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	/* Do a mass erase if user requested all sectors of flash */
	if ((first == 0) && (last == (bank->num_sectors - 1))) {
		/* Request mass erase of flash */
		return cc3220sf_mass_erase(bank);
	}

	/* Erase requested sectors one by one */
	for (unsigned int i = first; i <= last; i++) {

		/* Determine address of sector to erase */
		address = FLASH_BASE_ADDR + i * FLASH_SECTOR_SIZE;

		/* Set starting address to erase */
		retval = target_write_u32(target, FMA_REGISTER_ADDR, address);
		if (retval != ERROR_OK)
			return retval;

		/* Write the ERASE bit of the FMC register */
		retval = target_write_u32(target, FMC_REGISTER_ADDR, FMC_ERASE_VALUE);
		if (retval != ERROR_OK)
			return retval;

		/* Poll the ERASE bit until the erase is complete */
		done = false;
		start_ms = timeval_ms();
		while (!done) {
			retval = target_read_u32(target, FMC_REGISTER_ADDR, &value);
			if (retval != ERROR_OK)
				return retval;

			if ((value & FMC_ERASE_BIT) == 0) {
				/* Bit clears when mass erase is finished */
				done = true;
			} else {
				elapsed_ms = timeval_ms() - start_ms;
				if (elapsed_ms > 500)
					keep_alive();
				if (elapsed_ms > FLASH_TIMEOUT)
					break;
			}
		}

		if (!done) {
			/* Sector erase timed out waiting for confirmation */
			return ERROR_FAIL;
		}
	}

	return retval;
}

static int cc3220sf_write(struct flash_bank *bank, const uint8_t *buffer,
	uint32_t offset, uint32_t count)
{
	struct target *target = bank->target;
	struct cc3220sf_bank *cc3220sf_bank = bank->driver_priv;
	struct working_area *algo_working_area;
	struct working_area *buffer_working_area;
	struct reg_param reg_params[3];
	uint32_t algo_base_address;
	uint32_t algo_buffer_address;
	uint32_t algo_buffer_size;
	uint32_t address;
	uint32_t remaining;
	uint32_t words;
	uint32_t result;

	int retval = ERROR_OK;

	if (target->state != TARGET_HALTED) {
		LOG_ERROR("Target not halted");
		return ERROR_TARGET_NOT_HALTED;
	}

	/* Obtain working area to use for flash helper algorithm */
	retval = target_alloc_working_area(target, sizeof(cc3220sf_algo),
				&algo_working_area);
	if (retval != ERROR_OK)
		return retval;

	/* Obtain working area to use for flash buffer */
	retval = target_alloc_working_area(target,
				target_get_working_area_avail(target), &buffer_working_area);
	if (retval != ERROR_OK) {
		target_free_working_area(target, algo_working_area);
		return retval;
	}

	algo_base_address = algo_working_area->address;
	algo_buffer_address = buffer_working_area->address;
	algo_buffer_size = buffer_working_area->size;

	/* Make sure buffer size is a multiple of 32 word (0x80 byte) chunks */
	/* (algo runs more efficiently if it operates on 32 words at a time) */
	if (algo_buffer_size > 0x80)
		algo_buffer_size &= ~0x7f;

	/* Write flash helper algorithm into target memory */
	retval = target_write_buffer(target, algo_base_address,
				sizeof(cc3220sf_algo), cc3220sf_algo);
	if (retval != ERROR_OK) {
		target_free_working_area(target, algo_working_area);
		target_free_working_area(target, buffer_working_area);
		return retval;
	}

	/* Initialize the ARMv7m specific info to run the algorithm */
	cc3220sf_bank->armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
	cc3220sf_bank->armv7m_info.core_mode = ARM_MODE_THREAD;

	/* Initialize register params for flash helper algorithm */
	init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
	init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
	init_reg_param(&reg_params[2], "r2", 32, PARAM_IN_OUT);

	/* Prepare to write to flash */
	address = FLASH_BASE_ADDR + offset;
	remaining = count;

	/* The flash hardware can only write complete words to flash. If
	 * an unaligned address is passed in, we must do a read-modify-write
	 * on a word with enough bytes to align the rest of the buffer. And
	 * if less than a whole word remains at the end, we must also do a
	 * read-modify-write on a final word to finish up.
	 */

	/* Do one word write to align address on 32-bit boundary if needed */
	if (0 != (address & 0x3)) {
		uint8_t head[4];

		/* Get starting offset for data to write (will be 1 to 3) */
		uint32_t head_offset = address & 0x03;

		/* Get the aligned address to write this first word to */
		uint32_t head_address = address & 0xfffffffc;

		/* Retrieve what is already in flash at the head address */
		retval = target_read_buffer(target, head_address, sizeof(head), head);

		if (retval == ERROR_OK) {
			/* Substitute in the new data to write */
			while ((remaining > 0) && (head_offset < 4)) {
				head[head_offset] = *buffer;
				head_offset++;
				address++;
				buffer++;
				remaining--;
			}
		}

		if (retval == ERROR_OK) {
			/* Helper parameters are passed in registers R0-R2 */
			/* Set start of data buffer, address to write to, and word count */
			buf_set_u32(reg_params[0].value, 0, 32, algo_buffer_address);
			buf_set_u32(reg_params[1].value, 0, 32, head_address);
			buf_set_u32(reg_params[2].value, 0, 32, 1);

			/* Write head value into buffer to flash */
			retval = target_write_buffer(target, algo_buffer_address,
						sizeof(head), head);
		}

		if (retval == ERROR_OK) {
			/* Execute the flash helper algorithm */
			retval = target_run_algorithm(target, 0, NULL, 3, reg_params,
						algo_base_address, 0, FLASH_TIMEOUT,
						&cc3220sf_bank->armv7m_info);
			if (retval != ERROR_OK)
				LOG_ERROR("cc3220sf: Flash algorithm failed to run");

			/* Check that the head value was written to flash */
			result = buf_get_u32(reg_params[2].value, 0, 32);
			if (result != 0) {
				retval = ERROR_FAIL;
				LOG_ERROR("cc3220sf: Flash operation failed");
			}
		}
	}

	/* Check if there's data at end of buffer that isn't a full word */
	uint32_t tail_count = remaining & 0x03;
	/* Adjust remaining so it is a multiple of whole words */
	remaining -= tail_count;

	while ((retval == ERROR_OK) && (remaining > 0)) {
		/* Set start of data buffer and address to write to */
		buf_set_u32(reg_params[0].value, 0, 32, algo_buffer_address);
		buf_set_u32(reg_params[1].value, 0, 32, address);

		/* Download data to write into memory buffer */
		if (remaining >= algo_buffer_size) {
			/* Fill up buffer with data to flash */
			retval = target_write_buffer(target, algo_buffer_address,
						algo_buffer_size, buffer);
			if (retval != ERROR_OK)
				break;

			/* Count to write is in 32-bit words */
			words = algo_buffer_size / 4;

			/* Bump variables to next data */
			address += algo_buffer_size;
			buffer += algo_buffer_size;
			remaining -= algo_buffer_size;
		} else {
			/* Fill buffer with what's left of the data */
			retval = target_write_buffer(target, algo_buffer_address,
						remaining, buffer);
			if (retval != ERROR_OK)
				break;

			/* Calculate the final word count to write */
			words = remaining / 4;
			if (0 != (remaining % 4))
				words++;

			/* Bump variables to any final data */
			address += remaining;
			buffer += remaining;
			remaining = 0;
		}

		/* Set number of words to write */
		buf_set_u32(reg_params[2].value, 0, 32, words);

		/* Execute the flash helper algorithm */
		retval = target_run_algorithm(target, 0, NULL, 3, reg_params,
					algo_base_address, 0, FLASH_TIMEOUT,
					&cc3220sf_bank->armv7m_info);
		if (retval != ERROR_OK) {
			LOG_ERROR("cc3220sf: Flash algorithm failed to run");
			break;
		}

		/* Check that all words were written to flash */
		result = buf_get_u32(reg_params[2].value, 0, 32);
		if (result != 0) {
			retval = ERROR_FAIL;
			LOG_ERROR("cc3220sf: Flash operation failed");
			break;
		}

		keep_alive();
	}

	/* Do one word write for any final bytes less than a full word */
	if ((retval == ERROR_OK) && (tail_count != 0)) {
		uint8_t tail[4];

		/* Set starting byte offset for data to write */
		uint32_t tail_offset = 0;

		/* Retrieve what is already in flash at the tail address */
		retval = target_read_buffer(target, address, sizeof(tail), tail);

		if (retval == ERROR_OK) {
			/* Substitute in the new data to write */
			while (tail_count > 0) {
				tail[tail_offset] = *buffer;
				tail_offset++;
				buffer++;
				tail_count--;
			}
		}

		if (retval == ERROR_OK) {
			/* Set start of data buffer, address to write to, and word count */
			buf_set_u32(reg_params[0].value, 0, 32, algo_buffer_address);
			buf_set_u32(reg_params[1].value, 0, 32, address);
			buf_set_u32(reg_params[2].value, 0, 32, 1);

			/* Write tail value into buffer to flash */
			retval = target_write_buffer(target, algo_buffer_address,
						sizeof(tail), tail);
		}

		if (retval == ERROR_OK) {
			/* Execute the flash helper algorithm */
			retval = target_run_algorithm(target, 0, NULL, 3, reg_params,
						algo_base_address, 0, FLASH_TIMEOUT,
						&cc3220sf_bank->armv7m_info);
			if (retval != ERROR_OK)
				LOG_ERROR("cc3220sf: Flash algorithm failed to run");

			/* Check that the tail was written to flash */
			result = buf_get_u32(reg_params[2].value, 0, 32);
			if (result != 0) {
				retval = ERROR_FAIL;
				LOG_ERROR("cc3220sf: Flash operation failed");
			}
		}
	}

	/* Free resources  */
	destroy_reg_param(&reg_params[0]);
	destroy_reg_param(&reg_params[1]);
	destroy_reg_param(&reg_params[2]);
	target_free_working_area(target, algo_working_area);
	target_free_working_area(target, buffer_working_area);

	return retval;
}

static int cc3220sf_probe(struct flash_bank *bank)
{
	struct cc3220sf_bank *cc3220sf_bank = bank->driver_priv;

	uint32_t base;
	uint32_t size;
	unsigned int num_sectors;

	base = FLASH_BASE_ADDR;
	size = FLASH_NUM_SECTORS * FLASH_SECTOR_SIZE;
	num_sectors = FLASH_NUM_SECTORS;

	free(bank->sectors);

	bank->sectors = malloc(sizeof(struct flash_sector) * num_sectors);
	if (!bank->sectors)
		return ERROR_FAIL;

	bank->base = base;
	bank->size = size;
	bank->write_start_alignment = 0;
	bank->write_end_alignment = 0;
	bank->num_sectors = num_sectors;

	for (unsigned int i = 0; i < num_sectors; i++) {
		bank->sectors[i].offset = i * FLASH_SECTOR_SIZE;
		bank->sectors[i].size = FLASH_SECTOR_SIZE;
		bank->sectors[i].is_erased = -1;
		bank->sectors[i].is_protected = 0;
	}

	/* We've successfully recorded the stats on this flash bank */
	cc3220sf_bank->probed = true;

	/* If we fall through to here, then all went well */

	return ERROR_OK;
}

static int cc3220sf_auto_probe(struct flash_bank *bank)
{
	struct cc3220sf_bank *cc3220sf_bank = bank->driver_priv;

	int retval = ERROR_OK;

	if (!cc3220sf_bank->probed)
		retval = cc3220sf_probe(bank);

	return retval;
}

static int cc3220sf_info(struct flash_bank *bank, struct command_invocation *cmd)
{
	command_print_sameline(cmd, "CC3220SF with 1MB internal flash\n");
	return ERROR_OK;
}

const struct flash_driver cc3220sf_flash = {
	.name = "cc3220sf",
	.flash_bank_command = cc3220sf_flash_bank_command,
	.erase = cc3220sf_erase,
	.write = cc3220sf_write,
	.read = default_flash_read,
	.probe = cc3220sf_probe,
	.auto_probe = cc3220sf_auto_probe,
	.erase_check = default_flash_blank_check,
	.info = cc3220sf_info,
	.free_driver_priv = default_flash_free_driver_priv,
};
