#include "mik32_hal_pcc.h"
#include "mik32_hal_gpio.h"
#include "mik32_hal_spifi_w25.h"

/*
 * Программа демонстрирует переход из FLASH в RAM и обратно
 * FLASH (QPI+XIP) -> RAM (write_flash) RAM -> FLASH (QPI+XIP)
 * Сначала переводим микросхему W25Q64 в режим работы с периферией,
 * затем переводим ее в режим работы с командами и проверяем
 * успешность перехода чтением JDEC ID (0x60), пробуем
 * стереть последний сектор флеши и затем в первую страницу последнего
 * сектора записываем тестовые данные, затем снова возвращаем режим QPI+XIP
 * и возвращаемся к первоначальной работе из флеш.
 * Все переходы сопровождаются миганием светодиодов.
 * Результат записи во флеш можно увидеть в отладчике по адресу 0х801FF000
 * после возвращения в режим работы с памятью
 */

void SystemClock_Config();
void GPIO_Init();
void flash_write_page_qpi(void);
int SPIFI_WaitIntrqTimeout(uint32_t timeout);
uint32_t  get_flash_usage_end(void);
bool is_sector_free(uint32_t sector_address);
uint8_t read_sreg_1(void);
bool w25q_is_busy(uint32_t timeout);
void write_enable(void);
void w25q_sector_erase(uint32_t address);
void page_program(unsigned int ByteAddress, uint8_t data[], int byte_count);
bool write_to_last_sector(uint8_t *data);


#define TIMEOUT            100000

#define FLASH_TOTAL_SIZE   (2 * 1024 * 1024)
#define FLASH_BASE_ADDRESS 0x80000000
#define SECTOR_SIZE 4096
#define PAGE_SIZE 256

volatile uint8_t jedec_id_qpi[3] = {0};

extern uint32_t __DATA_IMAGE_END__;
extern uint32_t __TEXT_END__;


int main()
{
    SystemClock_Config();
    GPIO_Init();

    flash_write_page_qpi();

    while (1)
    {
    	// если мы попали сюда, значит мы успешно поработали с FLASH
    	// из RAM и снова вернулись к работе программы из FLASH
    	// и в отладчике теперь можно просмотреть результат записи
        HAL_GPIO_TogglePin(GPIO_0, GPIO_PIN_9 | GPIO_PIN_10);
        HAL_DelayMs(700);
    }
}

void SystemClock_Config(void)
{
    PCC_InitTypeDef PCC_OscInit = {0};

    PCC_OscInit.OscillatorEnable = PCC_OSCILLATORTYPE_ALL;
    PCC_OscInit.FreqMon.OscillatorSystem = PCC_OSCILLATORTYPE_OSC32M;
    PCC_OscInit.FreqMon.ForceOscSys = PCC_FORCE_OSC_SYS_UNFIXED;
    PCC_OscInit.FreqMon.Force32KClk = PCC_FREQ_MONITOR_SOURCE_OSC32K;
    PCC_OscInit.AHBDivider = 0;
    PCC_OscInit.APBMDivider = 0;
    PCC_OscInit.APBPDivider = 0;
    PCC_OscInit.HSI32MCalibrationValue = 128;
    PCC_OscInit.LSI32KCalibrationValue = 8;
    PCC_OscInit.RTCClockSelection = PCC_RTC_CLOCK_SOURCE_AUTO;
    PCC_OscInit.RTCClockCPUSelection = PCC_CPU_RTC_CLOCK_SOURCE_OSC32K;
    HAL_PCC_Config(&PCC_OscInit);
}

void GPIO_Init()
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    __HAL_PCC_GPIO_0_CLK_ENABLE();

    GPIO_InitStruct.Pin = GPIO_PIN_9 | GPIO_PIN_10;
    GPIO_InitStruct.Mode = HAL_GPIO_MODE_GPIO_OUTPUT;
    GPIO_InitStruct.Pull = HAL_GPIO_PULL_NONE;
    
    HAL_GPIO_Init(GPIO_0, &GPIO_InitStruct);
}


void __attribute__((used, section(".ram_text"))) flash_write_page_qpi(void)
{
  // мы сейчас с флеш точно работаем XIP + QPI, но перешли в ОЗУ и теперь нужно уйти из XIP,
  // т.е работали в режиме памяти, для этого надо перейти в режим периферии
  // сначала делаем сброс текущей команды работы в режиме памяти

	SPIFI_CONFIG->STAT = SPIFI_CONFIG_STAT_RESET_M;

	//выводим QPI из "без команд" в режим "с командами"
    const uint32_t cmd_chip_qpi_w_cmd =
		SPIFI_DIRECTION_INPUT |
		SPIFI_CONFIG_CMD_INTLEN(1) |
		SPIFI_CONFIG_CMD_FIELDFORM(SPIFI_FIELDFORM_ALL_PARALLEL) |
		SPIFI_CONFIG_CMD_FRAMEFORM(SPIFI_FRAMEFORM_3ADDR) |  /* нет кода операции, 3 адреса  */
		SPIFI_CONFIG_CMD_OPCODE(0xEB);

	SPIFI_CONFIG->ADDR  = 0;
	SPIFI_CONFIG->IDATA = 0;
	SPIFI_CONFIG->CMD   = cmd_chip_qpi_w_cmd;
	if(SPIFI_WaitIntrqTimeout(TIMEOUT) != 0){
            SPIFI_CONFIG->STAT |= SPIFI_CONFIG_STAT_INTRQ_M; //  команда выполнена, выставлен IRQ, сбросим IRQ
	     }
	else {
		asm("nop"); // таймаут, что-то пошло не так
       }

	// контрольная проверка принимает ли флеш команды или нет, для этого пробуем прочитать JDEC ID
    const uint32_t cmd_jedec_qpi =
	    SPIFI_DIRECTION_INPUT |
	    SPIFI_CONFIG_CMD_INTLEN(0) |
	    SPIFI_CONFIG_CMD_FIELDFORM(SPIFI_FIELDFORM_ALL_PARALLEL) |
	    SPIFI_CONFIG_CMD_FRAMEFORM(SPIFI_FRAMEFORM_OPCODE) |
	    SPIFI_CONFIG_CMD_OPCODE(0x9F);

    SPIFI_CONFIG->ADDR  = 0;
    SPIFI_CONFIG->IDATA = 0;
    SPIFI_CONFIG->CMD   = cmd_jedec_qpi | SPIFI_CONFIG_CMD_DATALEN(3);
    if(SPIFI_WaitIntrqTimeout(TIMEOUT) != 0){
		 SPIFI_CONFIG->STAT |= SPIFI_CONFIG_STAT_INTRQ_M; // сбросим IRQ
		}
	else {
		asm("nop"); // таймаут, что-то пошло не так
		  }

	  for (int i = 0; i < 3; i++)
	     jedec_id_qpi[i] =  SPIFI_CONFIG->DATA8;

	  // если успешно прочитали JDEC ID, то поморгаем вразнобой
	  if(jedec_id_qpi[1] == 0x60){
		  for(int i=0; i<16; i++)
		      {
		  	     GPIO_0->OUTPUT ^= 1<<9;
		  	     for(int i=0; i<500000; i++)
		  	        {
		  	   	       asm("nop");
		  	        }
		  	     GPIO_0->OUTPUT ^= 1<<10;
		  	     for(int i=0; i<500000; i++)
		  	        {
		  	     	   asm("nop");
		  	        }
		  	    }
	       }
	  for(int i=0; i<500000; i++){
	  	    	   asm("nop");
	  	         }

	//***** пробуем стереть и записать первую страницу последнего сектора ******

	uint8_t my_data[PAGE_SIZE];
	// формируем данные для записи
	for(int i=0; i<PAGE_SIZE; i++)
		my_data[i] = i;

	if (write_to_last_sector(my_data)) {
	     // стирание и запись прошли успешно
	   }

	//*************************************************************************

    //вернем назад QPI из режима "с командами" в режим "без команд"
    const uint32_t cmd_chip_qpi_wo_cmd =
		SPIFI_DIRECTION_INPUT |
		SPIFI_CONFIG_CMD_INTLEN(1) |
		SPIFI_CONFIG_CMD_FIELDFORM(SPIFI_FIELDFORM_ALL_PARALLEL) |
		SPIFI_CONFIG_CMD_FRAMEFORM(SPIFI_FRAMEFORM_OPCODE_3ADDR) |  /* есть код операции, 3 адреса  */
		SPIFI_CONFIG_CMD_OPCODE(0xEB);

	SPIFI_CONFIG->ADDR  = 0;
	SPIFI_CONFIG->IDATA = 0x20;
	SPIFI_CONFIG->CMD  = cmd_chip_qpi_wo_cmd;
	if(SPIFI_WaitIntrqTimeout(TIMEOUT) != 0){
			  SPIFI_CONFIG->STAT |= SPIFI_CONFIG_STAT_INTRQ_M; //  команда выполнена, выставлен IRQ, сбросим IRQ
		 }
	else {
		asm("nop"); // таймаут, что-то пошло не так
		 }

     // а теперь вернем SPIFI в режим работы с памятью
	 // настройки кэш не трогаем, они не изменились

     const uint32_t mcmd_chip_qpi_wo_cmd =
		SPIFI_DIRECTION_INPUT |
		SPIFI_CONFIG_CMD_INTLEN(1) |
		SPIFI_CONFIG_CMD_FIELDFORM(SPIFI_FIELDFORM_ALL_PARALLEL) |
		SPIFI_CONFIG_CMD_FRAMEFORM(SPIFI_FRAMEFORM_3ADDR) |  /* нет кода операции, 3 адреса  */
		SPIFI_CONFIG_CMD_OPCODE(0xEB);

    SPIFI_CONFIG->ADDR  = 0;
    SPIFI_CONFIG->IDATA = 0x20;
    SPIFI_CONFIG->MCMD  = mcmd_chip_qpi_wo_cmd;
    if(SPIFI_WaitIntrqTimeout(TIMEOUT) != 0){
	   SPIFI_CONFIG->STAT |= SPIFI_CONFIG_STAT_INTRQ_M; //  команда выполнена, выставлен IRQ, сбросим IRQ
    }
    else {
	     asm("nop"); // таймаут, что-то пошло не так
    }

    // поморгали перед выходом из ОЗУ, если настройки правильные,
    // то после этого мы вернемся к работе программы из флеш
    GPIO_0->OUTPUT ^= 1<<9 | 1<<10;
    for(int i=0; i<16; i++)
     {
	    GPIO_0->OUTPUT ^= 1<<9 | 1<<10;
	    for(int i=0; i<500000; i++){
		   asm("nop");
		 }
	 }
}

//*****************************************************************************
// Получить конец используемой флеш-памяти
__attribute__((used, section(".ram_text")))
uint32_t  get_flash_usage_end(void) {
    // Используем максимальный адрес между концом кода и концом данных
    uint32_t code_end = (uint32_t)&__TEXT_END__;
    uint32_t data_end = (uint32_t)&__DATA_IMAGE_END__;
    return (code_end > data_end) ? code_end : data_end;
}

//*****************************************************************************
// Проверить, свободен ли сектор
__attribute__((used, section(".ram_text")))
bool is_sector_free(uint32_t sector_address) {
    // Сектор свободен, если он находится за пределами используемой памяти
    uint32_t usage_end = get_flash_usage_end();
    return (sector_address >= usage_end);
}

//*****************************************************************************
__attribute__((used, section(".ram_text")))
uint8_t read_sreg_1(void)
{
    static uint8_t read_sreg = 0;

    const uint32_t cmd_read_sreg1 =
		SPIFI_DIRECTION_INPUT |
		SPIFI_CONFIG_CMD_INTLEN(0) |
		SPIFI_CONFIG_CMD_FIELDFORM(SPIFI_FIELDFORM_ALL_PARALLEL) |
		SPIFI_CONFIG_CMD_FRAMEFORM(SPIFI_FRAMEFORM_OPCODE) |
		SPIFI_CONFIG_CMD_OPCODE(0x05);

	SPIFI_CONFIG->CMD   = cmd_read_sreg1 | SPIFI_CONFIG_CMD_DATALEN(1);
	if(SPIFI_WaitIntrqTimeout(TIMEOUT) != 0){
		 SPIFI_CONFIG->STAT |= SPIFI_CONFIG_STAT_INTRQ_M; // сбросим IRQ
		}
	else {
		asm("nop"); // таймаут, что-то пошло не так
		return 0;
	 }

    read_sreg = SPIFI_CONFIG->DATA8;
    return read_sreg;

}

//*****************************************************************************
__attribute__((used, section(".ram_text")))
bool w25q_is_busy(uint32_t timeout){

 while (timeout-- != 0)
	{
		if ((read_sreg_1() & 1) == 0)
		{
			asm("nop");
			return 0;
		}
	}
	return 1;
}

//*****************************************************************************
__attribute__((used, section(".ram_text")))
void write_enable(void)
{
 	const uint32_t cmd_write_enable =
	    SPIFI_DIRECTION_INPUT |
	    SPIFI_CONFIG_CMD_INTLEN(0) |
	    SPIFI_CONFIG_CMD_FIELDFORM(SPIFI_FIELDFORM_ALL_PARALLEL) |
	    SPIFI_CONFIG_CMD_FRAMEFORM(SPIFI_FRAMEFORM_OPCODE) |
	    SPIFI_CONFIG_CMD_OPCODE(0x06);

    SPIFI_CONFIG->STAT |= SPIFI_CONFIG_STAT_INTRQ_M;
    SPIFI_CONFIG->CMD = cmd_write_enable;
    if(SPIFI_WaitIntrqTimeout(TIMEOUT) == 0)
    {
         return;
    }
}

//*****************************************************************************
__attribute__((used, section(".ram_text")))
void w25q_sector_erase(uint32_t address){

	write_enable();

	const uint32_t cmd_sector_erase_4k =
	    SPIFI_DIRECTION_INPUT |
	    SPIFI_CONFIG_CMD_INTLEN(0) |
	    SPIFI_CONFIG_CMD_FIELDFORM(SPIFI_FIELDFORM_ALL_PARALLEL) |
	    SPIFI_CONFIG_CMD_FRAMEFORM(SPIFI_FRAMEFORM_OPCODE_3ADDR) |
	    SPIFI_CONFIG_CMD_OPCODE(0x20);

	 SPIFI_CONFIG->STAT |= SPIFI_CONFIG_STAT_INTRQ_M;
	 SPIFI_CONFIG->ADDR = address;
	 SPIFI_CONFIG->CMD = cmd_sector_erase_4k;
	 if(SPIFI_WaitIntrqTimeout(TIMEOUT) == 0)
	   {
	       return;
	   }
}

//*****************************************************************************
__attribute__((used, section(".ram_text")))
void page_program(unsigned int ByteAddress, uint8_t data[], int byte_count)  {

    if(byte_count > 256)
    {
       return;
    }

 	SPIFI_CONFIG->STAT |= SPIFI_CONFIG_STAT_INTRQ_M;
    SPIFI_CONFIG->ADDR = ByteAddress;
    SPIFI_CONFIG->IDATA = 0x00;

    const uint32_t cmd_page_program =
        SPIFI_DIRECTION_OUTPUT |
        SPIFI_CONFIG_CMD_INTLEN(0) |
        SPIFI_CONFIG_CMD_FIELDFORM(SPIFI_FIELDFORM_ALL_PARALLEL) |
        SPIFI_CONFIG_CMD_FRAMEFORM(SPIFI_FRAMEFORM_OPCODE_3ADDR) |
        SPIFI_CONFIG_CMD_OPCODE(0x02);
    SPIFI_CONFIG->CMD  = cmd_page_program | SPIFI_CONFIG_CMD_DATALEN(byte_count);

    for(int i = 0; i < byte_count; i++)
    {
        SPIFI_CONFIG->DATA8 = data[i];
    }

    SPIFI_CONFIG->STAT |= SPIFI_CONFIG_STAT_INTRQ_M;
}

//*****************************************************************************
__attribute__((used, section(".ram_text")))
bool write_to_last_sector(uint8_t *data){
	// Определяем адрес последнего сектора
	uint32_t last_sector_address = FLASH_BASE_ADDRESS + FLASH_TOTAL_SIZE - SECTOR_SIZE;

	// Проверяем, свободен ли сектор
	if (!is_sector_free(last_sector_address)) {
		// Сектор занят - нельзя использовать
		return 0;
	}

	// Стираем сектор (это необходимо перед записью)
	w25q_sector_erase(last_sector_address);
	if(w25q_is_busy(TIMEOUT) == 1){
		return 0;
	  }

	write_enable();
	page_program(last_sector_address, data, PAGE_SIZE);
	if(w25q_is_busy(TIMEOUT) == 1){
			return 0;
		}

 return 1;
}

//*****************************************************************************
int __attribute__((used, section(".ram_text")))	SPIFI_WaitIntrqTimeout(uint32_t timeout)
	{
	    while (timeout-- > 0)
	    {
	        if((SPIFI_CONFIG->STAT & SPIFI_CONFIG_STAT_INTRQ_M) != 0)
	        {
	            return 1;
	        }
	    }
	    return 0;
	}

//*****************************************************************************