#include "bsp/bsp_driver.h"

#if defined (GD32F30X_HD) || defined (GD32F30X_XD) || defined (GD32F30X_CL)
#define FMC_FLAG_PGERR  FMC_FLAG_BANK0_PGERR
#define FMC_FLAG_PGAERR  FMC_FLAG_BANK0_PGERR
#define FMC_FLAG_WPERR  FMC_FLAG_BANK0_WPERR
#define FMC_FLAG_END  FMC_FLAG_BANK0_END
#endif


static void _fmc_write_data(uint32_t addr, uint8_t *data, int len);
static void _fmc_read_data(uint32_t addr, uint8_t *data, int len);
static void _fmc_erase_addr(uint32_t addr, int len);
static void _fmc_read_data(uint32_t addr, uint8_t *data, int len);
static void _fmc_erase_write_data(uint32_t addr, uint8_t *data, int len);

static uint32_t _sn_addr(void);
static uint32_t _data_addr(int index);
static uint32_t _maigc_addr(void);


void fmc_write_sn(uint8_t *sn, int len){
	_fmc_erase_write_data(_sn_addr(), sn, len);
}

void fmc_read_sn(uint8_t *sn, int len){
	_fmc_read_data(_sn_addr(), sn, len);
}

void fmc_write_data(int index, uint8_t *data, int len){
	_fmc_erase_write_data(_data_addr(index), data, len);
}

void fmc_read_data(int index, uint8_t *data, int len){
	_fmc_read_data(_data_addr(index), data, len);
}

static __inline__ void _fmc_flag_clear(void) {
	flash_flag_clear(FLASH_OBF_FLAG | FLASH_ODF_FLAG | FLASH_PRGMERR_FLAG | FLASH_EPPERR_FLAG);
}


void fmc_write_magic(uint32_t magic){
	uint32_t address = _maigc_addr();
	uint32_t length, checksum, value;

	value = REG32(address + 8);
	if (magic == value) {
		return;
	}

	length = REG32(address);
	checksum = REG32(address + 4);

	flash_unlock();

	if (value != 0xFFFFFFFF) {
		_fmc_flag_clear();
		flash_sector_erase(address);

		_fmc_flag_clear();
		flash_word_program(address, length);

		_fmc_flag_clear();
		flash_word_program(address + 4, checksum);
	}

	if (magic != 0xFFFFFFFF) {
		_fmc_flag_clear();
		flash_word_program(address + 8, magic);
	}

	flash_lock();
}

uint32_t fmc_read_magic(void){
	uint32_t magic = 0x5555aaaa;
	_fmc_read_data(_maigc_addr(), (uint8_t *)&magic, sizeof(magic));
	return magic;
}

//if flash is lager than 256k, we just use the 256k
static uint32_t __inline__ _flash_capatity(void){
	uint32_t capacity;
	capacity = (REG32(0x1FFFF7E0) & 0xFFFF) << 10;
	if (capacity > (256 * 1024)){
		capacity =  256 * 1024;
	}
	return capacity;
}

static uint32_t _sn_addr(void){
	return 0x08000000 + (_flash_capatity() - one_page_size * sn_page_index);
}

static uint32_t _data_addr(int index){
	return 0x08000000 + (_flash_capatity() - one_page_size * index);
}

static uint32_t _maigc_addr(void){
	return 0x08000000 + (_flash_capatity() - one_page_size * magic_page_index);
}

static void _fmc_read_data(uint32_t addr, uint8_t *data, int len){
	int i = 0;
	for (i = 0; i < len; i++){
		data[i] = REG8(addr + i);
	}
}

uint32_t fmc_get_addr(int page) {
	return 0x08000000 + (_flash_capatity() - one_page_size * page);
}

extern void wdog_reload(void);
static void _fmc_erase_addr(uint32_t addr, int len){
	flash_unlock();
	uint32_t pages = len/one_page_size + (((len % one_page_size) > 0)?1:0);
	for (int i = 0; i < pages; i++){
		_fmc_flag_clear();
		flash_sector_erase(addr + i * one_page_size);
		wdog_reload();
	}
	flash_lock();
}

static void _fmc_write_data(uint32_t addr, uint8_t *data, int len){
	flash_unlock();
	int total_words = len / 4;
	uint32_t *p_u32_data = (uint32_t *)data;
	int i;
	for (i = 0; i < total_words; i++){
		_fmc_flag_clear();
		flash_word_program(addr, p_u32_data[i]);
		data += 4;
		addr += 4;
	}

	int remain_len = len - total_words * 4;
	if (remain_len > 0){
		uint32_t words = 0;
		for (int i = 0; i < remain_len; i++){
			words |= data[i] << (8*i);
		}
		_fmc_flag_clear();
		flash_word_program(addr, words);
	}
	flash_lock();
}


static void _fmc_erase_write_data(uint32_t addr, uint8_t *data, int len){
	_fmc_erase_addr(addr, len);
	_fmc_write_data(addr, data, len);
}