path: root/bsp/CME_M7/StdPeriph_Driver/src/cmem7_flash.c

/**
    *****************************************************************************
    * @file     cmem7_flash.c
    *
    * @brief    CMEM7 flash controller source file
    *
    *
    * @version  V1.0
    * @date     3. September 2013
    *
    * @note
    *
    *****************************************************************************
    * @attention
    *
    * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
    * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
    * TIME. AS A RESULT, CAPITAL-MICRO SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
    * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
    * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
    * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
    *
    * <h2><center>&copy; COPYRIGHT 2013 Capital-micro </center></h2>
    *****************************************************************************
    */

#include "cmem7_flash.h"

typedef struct {
  union {
    uint16_t  STATUS;                         /*!< status register                     */

    struct {
      uint16_t  WIP:  1;                      /*!< in writting                         */
      uint16_t  WEL:  1;                      /*!< write enable                        */
      uint16_t  BP:  5;                       /*!< protection region                   */
      uint16_t  SRP:  2;                      /*!< protection mode                     */
      uint16_t  QE:  1;                       /*!< Quad mode                           */
    } STATUS_b;                               /*!< BitSize                             */
  } INNER;
} FLASH_INNER_STATUS;


#define NS_IN_A_SECOND                            (1000000000)

#define FLASH_MAX_SIZE                            0x800000
#define FLASH_PAGE_SIZE                           0x100
#define FLASH_SECTOR_SIZE                         0x001000
#define FLASH_BLOCK_32K_SIZE                      0x008000
#define FLASH_BLOCK_64K_SIZE                      0x010000

#define FLASH_CMD_RD_INNER_STATUS_LOW             0x05
#define FLASH_CMD_RD_INNER_STATUS_HIGH            0x35

#define FLASH_CMD_WR_WRITE_ENABLE                 0x06
#define FLASH_CMD_WR_WRITE_DISABLE                0x04

#define FLASH_CME_WR_STATUS_REG                   0x01

#define FLASH_CME_ERASE_SECTOR                    0x20
#define FLASH_CME_ERASE_BLOCK_32K                 0x52
#define FLASH_CME_ERASE_BLOCK_64K                 0xD8
#define FLASH_CME_ERASE_CHIP                      0xC7

#define FLASH_CME_WR_ENTER_DEEP_PD                0xB9
#define FLASH_CME_WR_EXIT_DEEP_PD                 0xAB

#define FLASH_CME_RD_NORMAL                       0x03
#define FLASH_CME_RD_FAST                         0x0B
#define FLASH_CME_RD_FAST_DUAL                    0x3B
#define FLASH_CME_RD_FAST_QUAD                    0x6B

#define FLASH_CME_WR                              0x02

typedef void (*WAIT)(void);
static WAIT wait;

static void flash_setClock(uint8_t dividor) {
    dividor = (dividor < 2) ? 2 : dividor;
    NOR_FLASH->CTRL0_b.DIV = dividor / 2 - 1;
}

static void flash_cleanOperation() {
    NOR_FLASH->TRIGGER_b.OP_CLEAN = TRUE;
    while (NOR_FLASH->STATUS_b.BUSY);

    NOR_FLASH->TRIGGER_b.OP_CLEAN = FALSE;
    while (NOR_FLASH->STATUS_b.BUSY);
}

static uint8_t flash_ReadInnerStatusLow() {
    NOR_FLASH->CTRL0_b.RW_BYTE_CNT = 1;
    NOR_FLASH->CTRL1_b.CMD = FLASH_CMD_RD_INNER_STATUS_LOW;
    NOR_FLASH->TRIGGER_b.OP_START = TRUE;

    while (NOR_FLASH->STATUS_b.BUSY);

    return (uint8_t)NOR_FLASH->DATA;
}

static uint8_t flash_ReadInnerStatusHigh() {
  NOR_FLASH->CTRL0_b.RW_BYTE_CNT = 1;
    NOR_FLASH->CTRL1_b.CMD = FLASH_CMD_RD_INNER_STATUS_HIGH;
    NOR_FLASH->TRIGGER_b.OP_START = TRUE;

    while (NOR_FLASH->STATUS_b.BUSY);

    return (uint8_t)NOR_FLASH->DATA;
}

//static void flash_WaitInWritting() {
void flash_WaitInWritting(void) {
    FLASH_INNER_STATUS s;

    while (NOR_FLASH->STATUS_b.BUSY);

    do {
        s.INNER.STATUS = flash_ReadInnerStatusLow();
        if (!s.INNER.STATUS_b.WIP) {
            break;
        }

        if (wait) {
            (*wait)();
        }
    } while (1);
}

static void flash_WriteWriteEnable(BOOL enable) {
  NOR_FLASH->CTRL0_b.RW_BYTE_CNT = 0;
    NOR_FLASH->CTRL1_b.CMD =
      enable ? FLASH_CMD_WR_WRITE_ENABLE : FLASH_CMD_WR_WRITE_DISABLE;

    NOR_FLASH->TRIGGER_b.OP_START = TRUE;

    flash_WaitInWritting();
}

static void flash_WriteStatusReg(FLASH_INNER_STATUS *s) {
  uint16_t tmp = s->INNER.STATUS;

    NOR_FLASH->CTRL0_b.RW_BYTE_CNT = 2;
    NOR_FLASH->CTRL1_b.CMD = FLASH_CME_WR_STATUS_REG;
    NOR_FLASH->DATA = ((tmp << 8) | (tmp >> 8)) << 16;
    NOR_FLASH->TRIGGER_b.OP_START = TRUE;

    flash_WaitInWritting();
}

static void flash_Erase(uint8_t cmd, uint32_t addr) {
    NOR_FLASH->CTRL0_b.RW_BYTE_CNT = 0;
    NOR_FLASH->CTRL1_b.CMD = cmd;
    NOR_FLASH->CTRL1_b.ADDRESS = addr;
    NOR_FLASH->TRIGGER_b.OP_START = TRUE;

    flash_WaitInWritting();
}

static void flash_WriteDeepPowerDownEnable(BOOL enable) {
  NOR_FLASH->CTRL0_b.RW_BYTE_CNT = 0;
    NOR_FLASH->CTRL1_b.CMD =
      enable ? FLASH_CME_WR_ENTER_DEEP_PD : FLASH_CME_WR_EXIT_DEEP_PD;

    NOR_FLASH->TRIGGER_b.OP_START = TRUE;

    flash_WaitInWritting();
}

static void flash_RwReq(uint8_t cmd, uint32_t addr, uint16_t size) {
    NOR_FLASH->CTRL0_b.RW_BYTE_CNT = size;
    NOR_FLASH->CTRL1_b.CMD = cmd;
    NOR_FLASH->CTRL1_b.ADDRESS = addr;

    NOR_FLASH->TRIGGER_b.OP_START = TRUE;
}

//static void flash_WaitReadFifoNotEmpty() {
void flash_WaitReadFifoNotEmpty(void) {
    while (NOR_FLASH->STATUS_b.RD_FIFO_EMPTY) {
        if (wait) {
            (*wait)();
        }
    }
}

//static uint16_t flash_ReadFifo(uint16_t size, uint8_t* data) {
uint16_t flash_ReadFifo(uint16_t size, uint8_t* data) {
    uint16_t count = 0;

    while (!NOR_FLASH->STATUS_b.RD_FIFO_EMPTY && size != 0) {
    uint32_t d =    NOR_FLASH->DATA;
        if (size > 3) {
            *(data + count++) = d >> 24;
            *(data + count++) = (d & 0x00FF0000) >> 16;
            *(data + count++) = (d & 0x0000FF00) >> 8;
            *(data + count++) = (d & 0x000000FF);
            size -= 4;
        } else if (size == 3) {
            *(data + count++) = (d & 0x00FF0000) >> 16;
            *(data + count++) = (d & 0x0000FF00) >> 8;
            *(data + count++) = (d & 0x000000FF);
            size -= 3;
        } else if (size == 2) {
            *(data + count++) = (d & 0x0000FF00) >> 8;
            *(data + count++) = (d & 0x000000FF);
            size -= 2;
        } else if (size == 1) {
            *(data + count++) = (d & 0x000000FF);
            size -= 1;
        }
    }

    return count;
}

static uint16_t flash_WriteFifo(uint16_t size, uint8_t* data) {
    uint16_t count = 0;

    while (!NOR_FLASH->STATUS_b.WR_FIFO_FULL && size != 0) {
        uint32_t d = 0;

        if (size > 3) {
            d = *(data + count++) << 24;
            d |= *(data + count++) << 16;
            d |= *(data + count++) << 8;
            d |= *(data + count++);
            size -= 4;
        } else if (size == 3) {
            d = *(data + count++) << 24;
            d |= *(data + count++) << 16;
            d |= *(data + count++) << 8;
            size -= 3;
        } else if (size == 2) {
            d = *(data + count++) << 24;
            d |= *(data + count++) << 16;
            size -= 2;
        } else if (size == 1) {
            d = *(data + count++) << 24;
            size -= 1;
        }

        NOR_FLASH->DATA = d;
    }

    return count;
}

static uint16_t flash_WritePage(uint32_t addr, uint16_t size, uint8_t* data) {
    uint16_t actualSize, retSize;

    flash_WriteWriteEnable(TRUE);

    actualSize = FLASH_PAGE_SIZE - (addr & (FLASH_PAGE_SIZE - 1));
    actualSize = (size > actualSize) ? actualSize : size;
  retSize = actualSize;

    flash_RwReq(FLASH_CME_WR, addr, actualSize);

    while (actualSize != 0) {
        uint8_t count = flash_WriteFifo(actualSize, data);

        actualSize -= count;
        data += count;
    }

    flash_WaitInWritting();

    return retSize;
}

void FLASH_Init(FLASH_InitTypeDef* init) {
    FLASH_INNER_STATUS s;

    assert_param(init);
    assert_param(IS_FLASH_PROTECT_MODE(init->FLASH_ProtectMode));
    assert_param(IS_FLASH_PROTECT_REGION(init->FLASH_ProtectRegion));

    wait = init->FLASH_Wait;
    flash_setClock(init->FLASH_ClockDividor);

    flash_cleanOperation();

    flash_WaitInWritting();

    s.INNER.STATUS = flash_ReadInnerStatusLow();
    s.INNER.STATUS |= ((uint16_t)flash_ReadInnerStatusHigh()) << 8;
    s.INNER.STATUS_b.BP = init->FLASH_ProtectRegion;
    s.INNER.STATUS_b.SRP = init->FLASH_ProtectMode;
    s.INNER.STATUS_b.QE = init->FLASH_QuadEnable;

    flash_WriteWriteEnable(TRUE);
    flash_WriteStatusReg(&s);
}

void FLASH_GetStatus(uint8_t* ProtectMode, uint8_t* ProtectRegion, BOOL* QuadEnable) {
    FLASH_INNER_STATUS s;

    assert_param(ProtectMode);
    assert_param(ProtectRegion);
    assert_param(QuadEnable);

    flash_WaitInWritting();

    s.INNER.STATUS = flash_ReadInnerStatusLow();
    s.INNER.STATUS |= ((uint16_t)flash_ReadInnerStatusHigh()) << 8;
    *ProtectRegion = s.INNER.STATUS_b.BP;
    *ProtectMode = s.INNER.STATUS_b.SRP;
    *QuadEnable = (s.INNER.STATUS_b.QE == 1) ?  TRUE : FALSE;
}

void FLASH_EraseSector(uint32_t addr) {
    flash_WaitInWritting();
    flash_WriteWriteEnable(TRUE);

    addr = (addr << 8) >> 8;
    addr = addr / FLASH_SECTOR_SIZE * FLASH_SECTOR_SIZE;
    flash_Erase(FLASH_CME_ERASE_SECTOR, addr);
}

void FLASH_Erase32kBlock(uint32_t addr) {
    flash_WaitInWritting();
    flash_WriteWriteEnable(TRUE);

    addr = (addr << 8) >> 8;
    addr = addr / FLASH_BLOCK_32K_SIZE * FLASH_BLOCK_32K_SIZE;
    flash_Erase(FLASH_CME_ERASE_BLOCK_32K, addr);
}

void FLASH_Erase64kBlock(uint32_t addr) {
    flash_WaitInWritting();
    flash_WriteWriteEnable(TRUE);

    addr = (addr << 8) >> 8;
    addr = addr / FLASH_BLOCK_64K_SIZE * FLASH_BLOCK_64K_SIZE;
    flash_Erase(FLASH_CME_ERASE_BLOCK_64K, addr);
}

void FLASH_EraseChip(void) {
    flash_WaitInWritting();
    flash_WriteWriteEnable(TRUE);
    flash_Erase(FLASH_CME_ERASE_CHIP, 0x0);
}

void FLASH_EnableDeepPowerDown(BOOL enable) {
    flash_WaitInWritting();
    flash_WriteWriteEnable(TRUE);
    flash_WriteDeepPowerDownEnable(enable);
}

void FLASH_Read(uint8_t ReadMode, uint32_t addr, uint16_t size, uint8_t* data) {
    uint8_t cmd;

    assert_param(IS_FLASH_READ_MODE(ReadMode));
    assert_param(addr + size <= FLASH_MAX_SIZE);
    assert_param(data);

    if (size == 0) {
        return ;
    }

    flash_WaitInWritting();

    if (ReadMode == FLASH_READ_MODE_NORMAL) {
        cmd = FLASH_CME_RD_NORMAL;
    } else if (ReadMode == FLASH_READ_MODE_FAST) {
        cmd = FLASH_CME_RD_FAST;
    } else if (ReadMode == FLASH_READ_MODE_FAST_DUAL) {
        cmd = FLASH_CME_RD_FAST_DUAL;
    } else {
        cmd = FLASH_CME_RD_FAST_QUAD;
    }

    flash_RwReq(cmd, addr, size);

  while (size > 0) {
        uint16_t count = 0;

    flash_WaitReadFifoNotEmpty();

      count = flash_ReadFifo(size, data);
        size -= count;
        data += count;
    }
}

void FLASH_Write(uint32_t addr, uint16_t size, uint8_t* data) {
    assert_param(addr + size <= FLASH_MAX_SIZE);
    assert_param(data);

    flash_WaitInWritting();

    while (size > 0) {
      uint16_t count = flash_WritePage(addr, size, data);

        addr += count;
        size -= count;
        data += count;
    }
}