|
|
@@ -1,667 +1,667 @@
|
|
|
-/*
|
|
|
- * File : nand.h
|
|
|
- * This file is part of RT-Thread RTOS
|
|
|
- * COPYRIGHT (C) 2006, RT-Thread Development Team
|
|
|
- *
|
|
|
- * The license and distribution terms for this file may be
|
|
|
- * found in the file LICENSE in this distribution or at
|
|
|
- * http://www.rt-thread.org/license/LICENSE
|
|
|
- *
|
|
|
- * Change Logs:
|
|
|
- * Date Author Notes
|
|
|
- * 2011-05-25 Bernard first version
|
|
|
- */
|
|
|
-
|
|
|
-#include "nand.h"
|
|
|
-#include "mb9bf506r.h"
|
|
|
-
|
|
|
-/*
|
|
|
- * NandFlash driver for SamSung K9F5608
|
|
|
- * 32M x 8bit
|
|
|
- */
|
|
|
-#define PAGE_SIZE 512
|
|
|
-#define PAGE_PER_BLOCK 32
|
|
|
-#define BLOCK_NUM 2048
|
|
|
-
|
|
|
-/* device driver debug trace */
|
|
|
-/* #define NAND_DEBUG */
|
|
|
-#ifdef NAND_DEBUG
|
|
|
-#define trace_log rt_kprintf
|
|
|
-#else
|
|
|
-#define trace_log(...)
|
|
|
-#endif
|
|
|
-
|
|
|
-/*
|
|
|
- * OOB,
|
|
|
- * when block has been erased, OOB is 0xff.
|
|
|
- * when block has been written, OOB is 0x00.
|
|
|
- */
|
|
|
-struct rt_device_nand
|
|
|
-{
|
|
|
- struct rt_device parent; /* which is inherited from rt_device */
|
|
|
-
|
|
|
- rt_uint16_t block_num; /* total block number in device */
|
|
|
- rt_uint16_t page_per_block; /* pages in one block */
|
|
|
- rt_uint16_t page_size; /* page size */
|
|
|
-
|
|
|
- /* this buffer which used as to save data before erase block */
|
|
|
- rt_uint8_t block_buffer[PAGE_SIZE * PAGE_PER_BLOCK];
|
|
|
-};
|
|
|
-static struct rt_device_nand _nand;
|
|
|
-
|
|
|
-/* Flash operation definition */
|
|
|
-#define NF_CMD(cmd) {*(volatile unsigned char*)(NF_FLASH_BASE_ADDR+NF_CMD_OFFSET) = (unsigned char)(cmd);}
|
|
|
-#define NF_ADDR(addr) {*(volatile unsigned char*)(NF_FLASH_BASE_ADDR+NF_ADDR_OFFSET)= (unsigned char)(addr);}
|
|
|
-#define NF_RDDATA() (*(volatile unsigned char*)(NF_FLASH_BASE_ADDR+NF_DATA_OFFSET))
|
|
|
-#define NF_WRDATA(data) {*(volatile unsigned char*)(NF_FLASH_BASE_ADDR+NF_DATA_OFFSET)= (unsigned char)(data);}
|
|
|
-#define NF_CLR_ALE() {*(volatile unsigned char*)(NF_FLASH_BASE_ADDR+NF_ALE_OFFSET) = (unsigned char)0;}
|
|
|
-
|
|
|
-/* Flash Control IO definition */
|
|
|
-#define NF_OE_H() {IO_NF_PDOR |= NF_EN;}
|
|
|
-#define NF_OE_L() {IO_NF_PDOR &= ~NF_EN;}
|
|
|
-
|
|
|
-#define NF_DATA_OUT() {IO_NF_PDOR &= ~NF_DATA_DIR;}
|
|
|
-#define NF_DATA_IN() {IO_NF_PDOR |= NF_DATA_DIR;}
|
|
|
-
|
|
|
-static unsigned char NF_ReadStatus(void);
|
|
|
-static void Wait(unsigned int cnt);
|
|
|
-static void NF_Reset(void);
|
|
|
-
|
|
|
-static void Wait(unsigned int cnt)
|
|
|
-{
|
|
|
- while(cnt--);
|
|
|
-}
|
|
|
-
|
|
|
-static void NF_Reset(void)
|
|
|
-{
|
|
|
- NF_OE_L();
|
|
|
- NF_DATA_OUT();
|
|
|
- NF_CMD(NAND_CMD_RESET);
|
|
|
- NF_OE_H();
|
|
|
-
|
|
|
- Wait(10000); /* wait for Trst */
|
|
|
-}
|
|
|
-
|
|
|
-static unsigned char NF_ReadStatus(void)
|
|
|
-{
|
|
|
- unsigned int timeout=0;
|
|
|
- NF_DATA_OUT();
|
|
|
- NF_CMD(NAND_CMD_STATUS);
|
|
|
- NF_DATA_IN();
|
|
|
-
|
|
|
- while(!(NF_RDDATA() & 0x40))
|
|
|
- {
|
|
|
- timeout++;
|
|
|
- if(timeout == 0x00080000)
|
|
|
- return FLASH_NG;
|
|
|
- }
|
|
|
- if(NF_RDDATA() & 0x01)return FLASH_NG;
|
|
|
-
|
|
|
- return FLASH_OK;
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * @ Funciton: NF_Init
|
|
|
- * Parameter: None
|
|
|
- * Return: None
|
|
|
- */
|
|
|
-static void NF_Init(void)
|
|
|
-{
|
|
|
- FM3_GPIO->PFR5 |= (0x7ff); /* D0-D5, CS7, ALE, CLE, WEX, REX */
|
|
|
- FM3_GPIO->PFR3 |= (0x3); /* D6-D7 */
|
|
|
- FM3_GPIO->EPFR10 |= (1<<13 /* CS enable */
|
|
|
- |1<<6 /* ALE, CLE, WEX, REX enable */
|
|
|
- |1<<0); /* D0-D7 enable */
|
|
|
- FM3_EXBUS->AREA7 = 0x001f00e0; /* Select CS7 area, 32Mbyte size */
|
|
|
- FM3_EXBUS->MODE7 |= (1<<4); /* Nand Flash mode turn on, set 8 bit width */
|
|
|
-
|
|
|
- IO_NF_PFR = IO_NF_PFR & ~(NF_EN|NF_DATA_DIR);
|
|
|
- IO_NF_DDR = IO_NF_DDR | (NF_EN|NF_DATA_DIR);
|
|
|
- IO_NF_PDOR = IO_NF_PDOR | (NF_EN | NF_DATA_DIR); /* disable Flash operation */
|
|
|
-
|
|
|
- /*Reset NAND*/
|
|
|
- NF_Reset();
|
|
|
-}
|
|
|
-
|
|
|
-static void NF_UnInit(void)
|
|
|
-{
|
|
|
- FM3_GPIO->PFR5 &= ~(0x7ff); /* disable D0-D5, CS7, ALE, CLE, WEX, REX */
|
|
|
- FM3_GPIO->PFR3 &= ~(0x3); /* disable D6-D7 */
|
|
|
- FM3_GPIO->EPFR10 &= ~(1<<13 /* disable CS enable */
|
|
|
- |1<<6 /* disable ALE, CLE, WEX, REX enable */
|
|
|
- |1<<0); /* disable D0-D7 enable */
|
|
|
- FM3_EXBUS->MODE7 &= ~(1<<4);
|
|
|
- IO_NF_PFR = IO_NF_PFR & ~(NF_EN|NF_DATA_DIR);
|
|
|
- IO_NF_DDR = IO_NF_DDR | (NF_EN|NF_DATA_DIR);
|
|
|
- IO_NF_PDOR = IO_NF_PDOR | (NF_EN | NF_DATA_DIR); /* disable Flash operation */
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * @ Funciton: NF_ReadPage
|
|
|
- * Parameter: block (max: 2048)
|
|
|
- * page (max:32)
|
|
|
- * buffer: pointer to data buffer
|
|
|
- * Return: 0: Flash Operation OK
|
|
|
- * 1: Flash Operation NG
|
|
|
- */
|
|
|
-int NF_ReadPage(unsigned int block, unsigned int page, unsigned char *buffer,
|
|
|
- unsigned char *oob)
|
|
|
-{
|
|
|
- unsigned int blockPage,i;
|
|
|
-
|
|
|
- NF_Init();
|
|
|
- blockPage=(block<<5)+page; /* 1 block=32 page */
|
|
|
- NF_OE_L();
|
|
|
- NF_DATA_OUT();
|
|
|
- if (buffer != RT_NULL)
|
|
|
- {
|
|
|
- volatile unsigned char ch;
|
|
|
-
|
|
|
- NF_CMD(NAND_CMD_READ0); /* send read data */
|
|
|
-
|
|
|
- NF_ADDR(0);
|
|
|
- NF_ADDR(blockPage & 0xff);
|
|
|
- NF_ADDR((blockPage>>8) & 0xff); /* send 3 byte address */
|
|
|
- NF_CLR_ALE();
|
|
|
- NF_DATA_IN();
|
|
|
-
|
|
|
- Wait(500);
|
|
|
-
|
|
|
- for(i=0;i<512;i++) /* read 512 bytes data */
|
|
|
- buffer[i] = NF_RDDATA();
|
|
|
- for(i=0;i<16;i++) /* read 16 bytes oob */
|
|
|
- if (oob != RT_NULL)
|
|
|
- oob[i] = NF_RDDATA();
|
|
|
- else
|
|
|
- ch = NF_RDDATA();
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- NF_CMD(NAND_CMD_READOOB); /* send read data */
|
|
|
-
|
|
|
- NF_ADDR(0);
|
|
|
- NF_ADDR(blockPage & 0xff);
|
|
|
- NF_ADDR((blockPage>>8) & 0xff); /* send 3 byte address */
|
|
|
- NF_CLR_ALE();
|
|
|
- NF_DATA_IN();
|
|
|
-
|
|
|
- Wait(500);
|
|
|
-
|
|
|
- for (i=0; i<16; i++) /* read 16 bytes oob */
|
|
|
- oob[i] = NF_RDDATA();
|
|
|
- }
|
|
|
-
|
|
|
- NF_OE_H();
|
|
|
- NF_UnInit();
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * @ Funciton: NF_EraseBlock
|
|
|
- * Parameter: block (max: 2048)
|
|
|
- * Return: 0: Flash Operation OK
|
|
|
- * 1: Flash Operation NG
|
|
|
- */
|
|
|
-int NF_EraseBlock(unsigned int block)
|
|
|
-{
|
|
|
- rt_uint32_t blockPage;
|
|
|
-
|
|
|
- trace_log("Erase block %d: ", block);
|
|
|
-
|
|
|
- NF_Init();
|
|
|
- blockPage = (block << 5);
|
|
|
- NF_OE_L();
|
|
|
- NF_DATA_OUT();
|
|
|
- NF_CMD(NAND_CMD_ERASE1); /* send erase command */
|
|
|
- NF_ADDR(blockPage & 0xff);
|
|
|
- NF_ADDR((blockPage >> 8) & 0xff);
|
|
|
- NF_CMD(NAND_CMD_ERASE2); /* start erase */
|
|
|
-
|
|
|
- if(NF_ReadStatus())
|
|
|
- {
|
|
|
- NF_Reset();
|
|
|
- NF_OE_H();
|
|
|
- NF_UnInit();
|
|
|
- trace_log("Failed\n");
|
|
|
- rt_kprintf("erase block failed\n");
|
|
|
-
|
|
|
- return FLASH_NG;
|
|
|
- }
|
|
|
-
|
|
|
- NF_OE_H();
|
|
|
- NF_UnInit();
|
|
|
-
|
|
|
- trace_log("OK\n");
|
|
|
-
|
|
|
- return FLASH_OK;
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * @ Funciton: NF_WritePage
|
|
|
- * Parameter: block (max: 2048)
|
|
|
- * page (max:32)
|
|
|
- * buffer: pointer to data buffer
|
|
|
- * Return: 0: Flash Operation OK
|
|
|
- * 1: Flash Operation NG
|
|
|
- */
|
|
|
-int NF_WritePage(unsigned block, unsigned page, const rt_uint8_t *buffer)
|
|
|
-{
|
|
|
- unsigned int blockPage,i;
|
|
|
- unsigned char se[16] = {0};
|
|
|
- unsigned char data;
|
|
|
-
|
|
|
- blockPage = (block<<5)+page;
|
|
|
- NF_Init();
|
|
|
- NF_OE_L();
|
|
|
- NF_DATA_OUT();
|
|
|
- NF_CMD(0x00); /* set programming area */
|
|
|
- NF_CMD(NAND_CMD_SEQIN); /* send write command */
|
|
|
- NF_ADDR(0);
|
|
|
- NF_ADDR(blockPage & 0xff);
|
|
|
- NF_ADDR((blockPage>>8) & 0xff);
|
|
|
- NF_CLR_ALE();
|
|
|
-
|
|
|
- for(i=0;i<512;i++) NF_WRDATA(buffer[i]); /* write data */
|
|
|
- for(i=0;i<16;i++) NF_WRDATA(se[i]); /* dummy write */
|
|
|
-
|
|
|
- NF_CMD(NAND_CMD_PAGEPROG); /* start programming */
|
|
|
-
|
|
|
- if(NF_ReadStatus())
|
|
|
- {
|
|
|
- NF_Reset();
|
|
|
- NF_OE_H();
|
|
|
- NF_UnInit();
|
|
|
-
|
|
|
- trace_log("write failed\n");
|
|
|
- return FLASH_NG;
|
|
|
- }
|
|
|
-
|
|
|
- /* verify the write data */
|
|
|
- NF_DATA_OUT();
|
|
|
- NF_CMD(NAND_CMD_READ0); /* send read command */
|
|
|
- NF_ADDR(0);
|
|
|
- NF_ADDR(blockPage & 0xff);
|
|
|
- NF_ADDR((blockPage>>8) & 0xff);
|
|
|
- NF_CLR_ALE();
|
|
|
- NF_DATA_IN();
|
|
|
-
|
|
|
- Wait(500);
|
|
|
- for(i=0; i<512; i++)
|
|
|
- {
|
|
|
- data=NF_RDDATA(); /* verify 1-512 byte */
|
|
|
- if(data != buffer[i])
|
|
|
- {
|
|
|
- trace_log("block %d, page %d\n", block , page);
|
|
|
- trace_log("write data failed[%d]: %02x %02x\n", i, data, buffer[i]);
|
|
|
-
|
|
|
- NF_Reset();
|
|
|
- NF_OE_H();
|
|
|
- NF_UnInit();
|
|
|
- return FLASH_NG;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- for(i=0; i<16; i++)
|
|
|
- {
|
|
|
- data=NF_RDDATA(); /* verify 16 byte dummy data */
|
|
|
- if(data != se[i])
|
|
|
- {
|
|
|
- trace_log("block %d, page %d\n", block , page);
|
|
|
- trace_log("write oob failed[%d]: %02x %02x\n", i, data, se[i]);
|
|
|
- NF_Reset();
|
|
|
- NF_OE_H();
|
|
|
- NF_UnInit();
|
|
|
- return FLASH_NG;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- NF_OE_H();
|
|
|
- NF_UnInit();
|
|
|
- return FLASH_OK;
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * @ Funciton: NF_ReadID
|
|
|
- * Parameter: id: pointer to device ID
|
|
|
- * Return: None
|
|
|
- */
|
|
|
-void NF_ReadID(unsigned char *id)
|
|
|
-{
|
|
|
- unsigned char maker_code;
|
|
|
- NF_Init();
|
|
|
- NF_OE_L();
|
|
|
- NF_DATA_OUT();
|
|
|
- NF_CMD(NAND_CMD_READID);
|
|
|
- NF_ADDR(0x00);
|
|
|
- NF_CLR_ALE();
|
|
|
- Wait(10);
|
|
|
- NF_DATA_IN();
|
|
|
- maker_code = NF_RDDATA();
|
|
|
- maker_code = maker_code;
|
|
|
- *id = NF_RDDATA();
|
|
|
- NF_OE_H();
|
|
|
- NF_UnInit();
|
|
|
-}
|
|
|
-
|
|
|
-static rt_err_t rt_nand_init (rt_device_t dev)
|
|
|
-{
|
|
|
- /* empty implementation */
|
|
|
- return RT_EOK;
|
|
|
-}
|
|
|
-
|
|
|
-static rt_err_t rt_nand_open(rt_device_t dev, rt_uint16_t oflag)
|
|
|
-{
|
|
|
- /* empty implementation */
|
|
|
- return RT_EOK;
|
|
|
-}
|
|
|
-
|
|
|
-static rt_err_t rt_nand_close(rt_device_t dev)
|
|
|
-{
|
|
|
- /* empty implementation */
|
|
|
- return RT_EOK;
|
|
|
-}
|
|
|
-
|
|
|
-/* nand device read */
|
|
|
-static rt_size_t rt_nand_read (rt_device_t dev, rt_off_t pos, void* buffer,
|
|
|
- rt_size_t size)
|
|
|
-{
|
|
|
- rt_ubase_t block; /* block of position */
|
|
|
- rt_ubase_t page, index; /* page in block of position */
|
|
|
- rt_uint8_t *page_ptr, oob[16];
|
|
|
- struct rt_device_nand *nand;
|
|
|
-
|
|
|
- /* get nand device */
|
|
|
- nand = (struct rt_device_nand*) dev;
|
|
|
- RT_ASSERT(nand != RT_NULL);
|
|
|
-
|
|
|
- /* get block and page */
|
|
|
- block = pos / nand->page_per_block;
|
|
|
- page = pos % nand->page_per_block;
|
|
|
-
|
|
|
- trace_log("nand read: position %d, block %d, page %d, size %d\n",
|
|
|
- pos, block, page, size);
|
|
|
-
|
|
|
- /* set page buffer pointer */
|
|
|
- page_ptr = (rt_uint8_t*) buffer;
|
|
|
- for (index = 0; index < size; index ++)
|
|
|
- {
|
|
|
- NF_ReadPage(block, page + index, page_ptr, oob);
|
|
|
- page_ptr += nand->page_size;
|
|
|
-
|
|
|
- if (page + index > nand->page_per_block)
|
|
|
- {
|
|
|
- block += 1;
|
|
|
- page = 0;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /* return read size (count of block) */
|
|
|
- return size;
|
|
|
-}
|
|
|
-
|
|
|
-/*
|
|
|
- * write pages by erase block first
|
|
|
- * @param nand the nand device driver
|
|
|
- * @param block the block of page
|
|
|
- * @param page the page
|
|
|
- * @param buffer the data buffer to be written
|
|
|
- * @param pages the number of pages to be written
|
|
|
- */
|
|
|
-static int rt_nand_eraseblock_writepage(struct rt_device_nand* nand,
|
|
|
- rt_ubase_t block, rt_ubase_t page,
|
|
|
- const rt_uint8_t *buffer, rt_ubase_t pages)
|
|
|
-{
|
|
|
- rt_ubase_t index;
|
|
|
- rt_uint32_t page_status;
|
|
|
- rt_uint8_t *page_ptr, oob[16];
|
|
|
-
|
|
|
- /* set page status */
|
|
|
- page_status = 0;
|
|
|
-
|
|
|
- /* read each page in block */
|
|
|
- page_ptr = nand->block_buffer;
|
|
|
- for (index = 0; index < nand->page_per_block; index ++)
|
|
|
- {
|
|
|
- NF_ReadPage(block, index, page_ptr, oob);
|
|
|
- if (!oob[0])
|
|
|
- page_status |= (1 << index);
|
|
|
- page_ptr += nand->page_size;
|
|
|
- }
|
|
|
-
|
|
|
- /* erase block */
|
|
|
- NF_EraseBlock(block);
|
|
|
-
|
|
|
- page_ptr = &(nand->block_buffer[page * nand->page_size]);
|
|
|
- /* merge buffer to page buffer */
|
|
|
- for (index = 0; index < pages; index ++)
|
|
|
- {
|
|
|
- rt_memcpy(page_ptr, buffer, nand->page_size);
|
|
|
-
|
|
|
- /* set page status */
|
|
|
- page_status |= (1 << (page + index));
|
|
|
-
|
|
|
- /* move to next page */
|
|
|
- page_ptr += nand->page_size;
|
|
|
- buffer += nand->page_size;
|
|
|
- }
|
|
|
-
|
|
|
- /* write to flash */
|
|
|
- page_ptr = nand->block_buffer;
|
|
|
- for (index = 0; index < nand->page_per_block; index ++)
|
|
|
- {
|
|
|
- if (page_status & (1 << index))
|
|
|
- NF_WritePage(block, index, page_ptr);
|
|
|
-
|
|
|
- /* move to next page */
|
|
|
- page_ptr += nand->page_size;
|
|
|
- }
|
|
|
-
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-/* nand device write */
|
|
|
-static rt_size_t rt_nand_write (rt_device_t dev, rt_off_t pos,
|
|
|
- const void* buffer, rt_size_t size)
|
|
|
-{
|
|
|
- rt_ubase_t block, page;
|
|
|
- rt_uint8_t oob[16];
|
|
|
- struct rt_device_nand *nand;
|
|
|
-
|
|
|
- nand = (struct rt_device_nand*) dev;
|
|
|
- RT_ASSERT(nand != RT_NULL);
|
|
|
-
|
|
|
- /* get block and page */
|
|
|
- block = pos / nand->page_per_block;
|
|
|
- page = pos % nand->page_per_block;
|
|
|
-
|
|
|
- trace_log("nand write: position %d, block %d, page %d, size %d\n",
|
|
|
- pos, block, page, size);
|
|
|
-
|
|
|
- if (size == 1)
|
|
|
- {
|
|
|
- /* write one page */
|
|
|
-
|
|
|
- /* read oob to get page status */
|
|
|
- NF_ReadPage(block, page, RT_NULL, oob);
|
|
|
- if (oob[0])
|
|
|
- NF_WritePage(block, page, buffer);
|
|
|
- else
|
|
|
- /* erase block and then write page */
|
|
|
- rt_nand_eraseblock_writepage(nand, block, page, buffer, 1);
|
|
|
- }
|
|
|
- else if (size > 1)
|
|
|
- {
|
|
|
- rt_ubase_t index;
|
|
|
- rt_ubase_t need_erase_block;
|
|
|
- const rt_uint8_t *page_ptr;
|
|
|
- rt_ubase_t chunk_pages, pages;
|
|
|
-
|
|
|
- pages = size;
|
|
|
- page_ptr = (const rt_uint8_t*) buffer;
|
|
|
- do
|
|
|
- {
|
|
|
- need_erase_block = 0;
|
|
|
- /* calculate pages in current chunk */
|
|
|
- if (pages > nand->page_per_block - page)
|
|
|
- chunk_pages = nand->page_per_block - page;
|
|
|
- else
|
|
|
- chunk_pages = pages;
|
|
|
-
|
|
|
- /* get page status in current block */
|
|
|
- for (index = page; index < page + chunk_pages; index ++)
|
|
|
- {
|
|
|
- NF_ReadPage(block, index, RT_NULL, oob);
|
|
|
- if (!oob[0])
|
|
|
- {
|
|
|
- /* this page has data, need erase this block firstly */
|
|
|
- need_erase_block = 1;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (need_erase_block)
|
|
|
- {
|
|
|
- /* erase block and then write it */
|
|
|
- rt_nand_eraseblock_writepage(nand, block, page, page_ptr, chunk_pages);
|
|
|
- page_ptr += chunk_pages * nand->page_size;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- /* write pages directly */
|
|
|
- for (index = page; index < page + chunk_pages; index ++)
|
|
|
- {
|
|
|
- NF_WritePage(block, index, page_ptr);
|
|
|
- page_ptr += nand->page_size;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- pages -= chunk_pages;
|
|
|
- page = 0; block ++; /* move to next block */
|
|
|
- }
|
|
|
- while (pages);
|
|
|
- }
|
|
|
-
|
|
|
- return size;
|
|
|
-}
|
|
|
-
|
|
|
-static rt_err_t rt_nand_control (rt_device_t dev, rt_uint8_t cmd, void *args)
|
|
|
-{
|
|
|
- struct rt_device_nand *nand;
|
|
|
-
|
|
|
- nand = (struct rt_device_nand*) dev;
|
|
|
- RT_ASSERT(dev != RT_NULL);
|
|
|
-
|
|
|
- switch (cmd)
|
|
|
- {
|
|
|
- case RT_DEVICE_CTRL_BLK_GETGEOME:
|
|
|
- {
|
|
|
- struct rt_device_blk_geometry *geometry;
|
|
|
-
|
|
|
- geometry = (struct rt_device_blk_geometry *)args;
|
|
|
- if (geometry == RT_NULL) return -RT_ERROR;
|
|
|
-
|
|
|
- geometry->bytes_per_sector = nand->page_size;
|
|
|
- geometry->block_size = nand->page_size * nand->page_per_block;
|
|
|
- geometry->sector_count = nand->block_num * nand->page_per_block;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- return RT_EOK;
|
|
|
-}
|
|
|
-
|
|
|
-void rt_hw_nand_init(void)
|
|
|
-{
|
|
|
- /* initialize nand flash structure */
|
|
|
- _nand.block_num = BLOCK_NUM;
|
|
|
- _nand.page_per_block = PAGE_PER_BLOCK;
|
|
|
- _nand.page_size = PAGE_SIZE;
|
|
|
-
|
|
|
- rt_memset(_nand.block_buffer, 0, sizeof(_nand.block_buffer));
|
|
|
-
|
|
|
- _nand.parent.type = RT_Device_Class_MTD;
|
|
|
- _nand.parent.rx_indicate = RT_NULL;
|
|
|
- _nand.parent.tx_complete = RT_NULL;
|
|
|
- _nand.parent.init = rt_nand_init;
|
|
|
- _nand.parent.open = rt_nand_open;
|
|
|
- _nand.parent.close = rt_nand_close;
|
|
|
- _nand.parent.read = rt_nand_read;
|
|
|
- _nand.parent.write = rt_nand_write;
|
|
|
- _nand.parent.control = rt_nand_control;
|
|
|
-
|
|
|
- /* register a MTD device */
|
|
|
- rt_device_register(&(_nand.parent), "nand", RT_DEVICE_FLAG_RDWR);
|
|
|
-}
|
|
|
-
|
|
|
-#ifdef NAND_DEBUG
|
|
|
-#include <finsh.h>
|
|
|
-unsigned char nand_buffer[512];
|
|
|
-unsigned char nand_oob[16];
|
|
|
-
|
|
|
-void dump_mem(unsigned char* buffer, int length)
|
|
|
-{
|
|
|
- int i;
|
|
|
-
|
|
|
- if (length > 64) length = 64;
|
|
|
- for (i = 0; i < length; i ++)
|
|
|
- {
|
|
|
- rt_kprintf("%02x ", *buffer++);
|
|
|
- if (((i+1) % 16) == 0)
|
|
|
- rt_kprintf("\n");
|
|
|
- }
|
|
|
- rt_kprintf("\n");
|
|
|
-}
|
|
|
-
|
|
|
-void nand_read(int block, int page)
|
|
|
-{
|
|
|
- rt_kprintf("read block %d, page %d\n", block, page);
|
|
|
-
|
|
|
- NF_ReadPage(block, page, nand_buffer, nand_oob);
|
|
|
- rt_kprintf("page data:\n");
|
|
|
- dump_mem(nand_buffer, 512);
|
|
|
- rt_kprintf("oob data:\n");
|
|
|
- dump_mem(nand_oob, 16);
|
|
|
-}
|
|
|
-FINSH_FUNCTION_EXPORT_ALIAS(nand_read, read_page, read page[block/page]);
|
|
|
-
|
|
|
-void nand_write(int block, int page)
|
|
|
-{
|
|
|
- int i;
|
|
|
- for (i = 0; i < 512; i ++)
|
|
|
- nand_buffer[i] = i;
|
|
|
-
|
|
|
- NF_WritePage(block, page, nand_buffer);
|
|
|
-}
|
|
|
-FINSH_FUNCTION_EXPORT_ALIAS(nand_write, write_page, write page[block/page]);
|
|
|
-
|
|
|
-void nand_erase(int block)
|
|
|
-{
|
|
|
- NF_EraseBlock(block);
|
|
|
-}
|
|
|
-FINSH_FUNCTION_EXPORT_ALIAS(nand_erase, erase_block, erase block[block]);
|
|
|
-
|
|
|
-void nand_readoob(int block, int page)
|
|
|
-{
|
|
|
- rt_kprintf("read oob on block %d, page %d\n", block, page);
|
|
|
-
|
|
|
- NF_ReadPage(block, page, RT_NULL, (unsigned char*)nand_oob);
|
|
|
- rt_kprintf("oob data:\n");
|
|
|
- dump_mem(nand_oob, 16);
|
|
|
-}
|
|
|
-FINSH_FUNCTION_EXPORT_ALIAS(nand_readoob, readoob, read oob[block/page]);
|
|
|
-
|
|
|
-void nand_erase_chip()
|
|
|
-{
|
|
|
- int i;
|
|
|
- unsigned char id;
|
|
|
-
|
|
|
- NF_ReadID(&id);
|
|
|
- rt_kprintf("id: %02x\n", id);
|
|
|
-
|
|
|
- for (i = 0; i < 2048; i ++)
|
|
|
- {
|
|
|
- NF_EraseBlock(i);
|
|
|
- }
|
|
|
-}
|
|
|
-FINSH_FUNCTION_EXPORT_ALIAS(nand_erase_chip, erase_chip, erase whole chip);
|
|
|
-#endif
|
|
|
+/*
|
|
|
+ * File : nand.h
|
|
|
+ * This file is part of RT-Thread RTOS
|
|
|
+ * COPYRIGHT (C) 2006, RT-Thread Development Team
|
|
|
+ *
|
|
|
+ * The license and distribution terms for this file may be
|
|
|
+ * found in the file LICENSE in this distribution or at
|
|
|
+ * http://www.rt-thread.org/license/LICENSE
|
|
|
+ *
|
|
|
+ * Change Logs:
|
|
|
+ * Date Author Notes
|
|
|
+ * 2011-05-25 Bernard first version
|
|
|
+ */
|
|
|
+
|
|
|
+#include "nand.h"
|
|
|
+#include "mb9bf506r.h"
|
|
|
+
|
|
|
+/*
|
|
|
+ * NandFlash driver for SamSung K9F5608
|
|
|
+ * 32M x 8bit
|
|
|
+ */
|
|
|
+#define PAGE_SIZE 512
|
|
|
+#define PAGE_PER_BLOCK 32
|
|
|
+#define BLOCK_NUM 2048
|
|
|
+
|
|
|
+/* device driver debug trace */
|
|
|
+/* #define NAND_DEBUG */
|
|
|
+#ifdef NAND_DEBUG
|
|
|
+#define trace_log rt_kprintf
|
|
|
+#else
|
|
|
+#define trace_log(...)
|
|
|
+#endif
|
|
|
+
|
|
|
+/*
|
|
|
+ * OOB,
|
|
|
+ * when block has been erased, OOB is 0xff.
|
|
|
+ * when block has been written, OOB is 0x00.
|
|
|
+ */
|
|
|
+struct rt_device_nand
|
|
|
+{
|
|
|
+ struct rt_device parent; /* which is inherited from rt_device */
|
|
|
+
|
|
|
+ rt_uint16_t block_num; /* total block number in device */
|
|
|
+ rt_uint16_t page_per_block; /* pages in one block */
|
|
|
+ rt_uint16_t page_size; /* page size */
|
|
|
+
|
|
|
+ /* this buffer which used as to save data before erase block */
|
|
|
+ rt_uint8_t block_buffer[PAGE_SIZE * PAGE_PER_BLOCK];
|
|
|
+};
|
|
|
+static struct rt_device_nand _nand;
|
|
|
+
|
|
|
+/* Flash operation definition */
|
|
|
+#define NF_CMD(cmd) {*(volatile unsigned char*)(NF_FLASH_BASE_ADDR+NF_CMD_OFFSET) = (unsigned char)(cmd);}
|
|
|
+#define NF_ADDR(addr) {*(volatile unsigned char*)(NF_FLASH_BASE_ADDR+NF_ADDR_OFFSET)= (unsigned char)(addr);}
|
|
|
+#define NF_RDDATA() (*(volatile unsigned char*)(NF_FLASH_BASE_ADDR+NF_DATA_OFFSET))
|
|
|
+#define NF_WRDATA(data) {*(volatile unsigned char*)(NF_FLASH_BASE_ADDR+NF_DATA_OFFSET)= (unsigned char)(data);}
|
|
|
+#define NF_CLR_ALE() {*(volatile unsigned char*)(NF_FLASH_BASE_ADDR+NF_ALE_OFFSET) = (unsigned char)0;}
|
|
|
+
|
|
|
+/* Flash Control IO definition */
|
|
|
+#define NF_OE_H() {IO_NF_PDOR |= NF_EN;}
|
|
|
+#define NF_OE_L() {IO_NF_PDOR &= ~NF_EN;}
|
|
|
+
|
|
|
+#define NF_DATA_OUT() {IO_NF_PDOR &= ~NF_DATA_DIR;}
|
|
|
+#define NF_DATA_IN() {IO_NF_PDOR |= NF_DATA_DIR;}
|
|
|
+
|
|
|
+static unsigned char NF_ReadStatus(void);
|
|
|
+static void Wait(unsigned int cnt);
|
|
|
+static void NF_Reset(void);
|
|
|
+
|
|
|
+static void Wait(unsigned int cnt)
|
|
|
+{
|
|
|
+ while(cnt--);
|
|
|
+}
|
|
|
+
|
|
|
+static void NF_Reset(void)
|
|
|
+{
|
|
|
+ NF_OE_L();
|
|
|
+ NF_DATA_OUT();
|
|
|
+ NF_CMD(NAND_CMD_RESET);
|
|
|
+ NF_OE_H();
|
|
|
+
|
|
|
+ Wait(10000); /* wait for Trst */
|
|
|
+}
|
|
|
+
|
|
|
+static unsigned char NF_ReadStatus(void)
|
|
|
+{
|
|
|
+ unsigned int timeout=0;
|
|
|
+ NF_DATA_OUT();
|
|
|
+ NF_CMD(NAND_CMD_STATUS);
|
|
|
+ NF_DATA_IN();
|
|
|
+
|
|
|
+ while(!(NF_RDDATA() & 0x40))
|
|
|
+ {
|
|
|
+ timeout++;
|
|
|
+ if(timeout == 0x00080000)
|
|
|
+ return FLASH_NG;
|
|
|
+ }
|
|
|
+ if(NF_RDDATA() & 0x01)return FLASH_NG;
|
|
|
+
|
|
|
+ return FLASH_OK;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ * @ Funciton: NF_Init
|
|
|
+ * Parameter: None
|
|
|
+ * Return: None
|
|
|
+ */
|
|
|
+static void NF_Init(void)
|
|
|
+{
|
|
|
+ FM3_GPIO->PFR5 |= (0x7ff); /* D0-D5, CS7, ALE, CLE, WEX, REX */
|
|
|
+ FM3_GPIO->PFR3 |= (0x3); /* D6-D7 */
|
|
|
+ FM3_GPIO->EPFR10 |= (1<<13 /* CS enable */
|
|
|
+ |1<<6 /* ALE, CLE, WEX, REX enable */
|
|
|
+ |1<<0); /* D0-D7 enable */
|
|
|
+ FM3_EXBUS->AREA7 = 0x001f00e0; /* Select CS7 area, 32Mbyte size */
|
|
|
+ FM3_EXBUS->MODE7 |= (1<<4); /* Nand Flash mode turn on, set 8 bit width */
|
|
|
+
|
|
|
+ IO_NF_PFR = IO_NF_PFR & ~(NF_EN|NF_DATA_DIR);
|
|
|
+ IO_NF_DDR = IO_NF_DDR | (NF_EN|NF_DATA_DIR);
|
|
|
+ IO_NF_PDOR = IO_NF_PDOR | (NF_EN | NF_DATA_DIR); /* disable Flash operation */
|
|
|
+
|
|
|
+ /*Reset NAND*/
|
|
|
+ NF_Reset();
|
|
|
+}
|
|
|
+
|
|
|
+static void NF_UnInit(void)
|
|
|
+{
|
|
|
+ FM3_GPIO->PFR5 &= ~(0x7ff); /* disable D0-D5, CS7, ALE, CLE, WEX, REX */
|
|
|
+ FM3_GPIO->PFR3 &= ~(0x3); /* disable D6-D7 */
|
|
|
+ FM3_GPIO->EPFR10 &= ~(1<<13 /* disable CS enable */
|
|
|
+ |1<<6 /* disable ALE, CLE, WEX, REX enable */
|
|
|
+ |1<<0); /* disable D0-D7 enable */
|
|
|
+ FM3_EXBUS->MODE7 &= ~(1<<4);
|
|
|
+ IO_NF_PFR = IO_NF_PFR & ~(NF_EN|NF_DATA_DIR);
|
|
|
+ IO_NF_DDR = IO_NF_DDR | (NF_EN|NF_DATA_DIR);
|
|
|
+ IO_NF_PDOR = IO_NF_PDOR | (NF_EN | NF_DATA_DIR); /* disable Flash operation */
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ * @ Funciton: NF_ReadPage
|
|
|
+ * Parameter: block (max: 2048)
|
|
|
+ * page (max:32)
|
|
|
+ * buffer: pointer to data buffer
|
|
|
+ * Return: 0: Flash Operation OK
|
|
|
+ * 1: Flash Operation NG
|
|
|
+ */
|
|
|
+int NF_ReadPage(unsigned int block, unsigned int page, unsigned char *buffer,
|
|
|
+ unsigned char *oob)
|
|
|
+{
|
|
|
+ unsigned int blockPage,i;
|
|
|
+
|
|
|
+ NF_Init();
|
|
|
+ blockPage=(block<<5)+page; /* 1 block=32 page */
|
|
|
+ NF_OE_L();
|
|
|
+ NF_DATA_OUT();
|
|
|
+ if (buffer != RT_NULL)
|
|
|
+ {
|
|
|
+ volatile unsigned char ch;
|
|
|
+
|
|
|
+ NF_CMD(NAND_CMD_READ0); /* send read data */
|
|
|
+
|
|
|
+ NF_ADDR(0);
|
|
|
+ NF_ADDR(blockPage & 0xff);
|
|
|
+ NF_ADDR((blockPage>>8) & 0xff); /* send 3 byte address */
|
|
|
+ NF_CLR_ALE();
|
|
|
+ NF_DATA_IN();
|
|
|
+
|
|
|
+ Wait(500);
|
|
|
+
|
|
|
+ for(i=0;i<512;i++) /* read 512 bytes data */
|
|
|
+ buffer[i] = NF_RDDATA();
|
|
|
+ for(i=0;i<16;i++) /* read 16 bytes oob */
|
|
|
+ if (oob != RT_NULL)
|
|
|
+ oob[i] = NF_RDDATA();
|
|
|
+ else
|
|
|
+ ch = NF_RDDATA();
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ NF_CMD(NAND_CMD_READOOB); /* send read data */
|
|
|
+
|
|
|
+ NF_ADDR(0);
|
|
|
+ NF_ADDR(blockPage & 0xff);
|
|
|
+ NF_ADDR((blockPage>>8) & 0xff); /* send 3 byte address */
|
|
|
+ NF_CLR_ALE();
|
|
|
+ NF_DATA_IN();
|
|
|
+
|
|
|
+ Wait(500);
|
|
|
+
|
|
|
+ for (i=0; i<16; i++) /* read 16 bytes oob */
|
|
|
+ oob[i] = NF_RDDATA();
|
|
|
+ }
|
|
|
+
|
|
|
+ NF_OE_H();
|
|
|
+ NF_UnInit();
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ * @ Funciton: NF_EraseBlock
|
|
|
+ * Parameter: block (max: 2048)
|
|
|
+ * Return: 0: Flash Operation OK
|
|
|
+ * 1: Flash Operation NG
|
|
|
+ */
|
|
|
+int NF_EraseBlock(unsigned int block)
|
|
|
+{
|
|
|
+ rt_uint32_t blockPage;
|
|
|
+
|
|
|
+ trace_log("Erase block %d: ", block);
|
|
|
+
|
|
|
+ NF_Init();
|
|
|
+ blockPage = (block << 5);
|
|
|
+ NF_OE_L();
|
|
|
+ NF_DATA_OUT();
|
|
|
+ NF_CMD(NAND_CMD_ERASE1); /* send erase command */
|
|
|
+ NF_ADDR(blockPage & 0xff);
|
|
|
+ NF_ADDR((blockPage >> 8) & 0xff);
|
|
|
+ NF_CMD(NAND_CMD_ERASE2); /* start erase */
|
|
|
+
|
|
|
+ if(NF_ReadStatus())
|
|
|
+ {
|
|
|
+ NF_Reset();
|
|
|
+ NF_OE_H();
|
|
|
+ NF_UnInit();
|
|
|
+ trace_log("Failed\n");
|
|
|
+ rt_kprintf("erase block failed\n");
|
|
|
+
|
|
|
+ return FLASH_NG;
|
|
|
+ }
|
|
|
+
|
|
|
+ NF_OE_H();
|
|
|
+ NF_UnInit();
|
|
|
+
|
|
|
+ trace_log("OK\n");
|
|
|
+
|
|
|
+ return FLASH_OK;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ * @ Funciton: NF_WritePage
|
|
|
+ * Parameter: block (max: 2048)
|
|
|
+ * page (max:32)
|
|
|
+ * buffer: pointer to data buffer
|
|
|
+ * Return: 0: Flash Operation OK
|
|
|
+ * 1: Flash Operation NG
|
|
|
+ */
|
|
|
+int NF_WritePage(unsigned block, unsigned page, const rt_uint8_t *buffer)
|
|
|
+{
|
|
|
+ unsigned int blockPage,i;
|
|
|
+ unsigned char se[16] = {0};
|
|
|
+ unsigned char data;
|
|
|
+
|
|
|
+ blockPage = (block<<5)+page;
|
|
|
+ NF_Init();
|
|
|
+ NF_OE_L();
|
|
|
+ NF_DATA_OUT();
|
|
|
+ NF_CMD(0x00); /* set programming area */
|
|
|
+ NF_CMD(NAND_CMD_SEQIN); /* send write command */
|
|
|
+ NF_ADDR(0);
|
|
|
+ NF_ADDR(blockPage & 0xff);
|
|
|
+ NF_ADDR((blockPage>>8) & 0xff);
|
|
|
+ NF_CLR_ALE();
|
|
|
+
|
|
|
+ for(i=0;i<512;i++) NF_WRDATA(buffer[i]); /* write data */
|
|
|
+ for(i=0;i<16;i++) NF_WRDATA(se[i]); /* dummy write */
|
|
|
+
|
|
|
+ NF_CMD(NAND_CMD_PAGEPROG); /* start programming */
|
|
|
+
|
|
|
+ if(NF_ReadStatus())
|
|
|
+ {
|
|
|
+ NF_Reset();
|
|
|
+ NF_OE_H();
|
|
|
+ NF_UnInit();
|
|
|
+
|
|
|
+ trace_log("write failed\n");
|
|
|
+ return FLASH_NG;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* verify the write data */
|
|
|
+ NF_DATA_OUT();
|
|
|
+ NF_CMD(NAND_CMD_READ0); /* send read command */
|
|
|
+ NF_ADDR(0);
|
|
|
+ NF_ADDR(blockPage & 0xff);
|
|
|
+ NF_ADDR((blockPage>>8) & 0xff);
|
|
|
+ NF_CLR_ALE();
|
|
|
+ NF_DATA_IN();
|
|
|
+
|
|
|
+ Wait(500);
|
|
|
+ for(i=0; i<512; i++)
|
|
|
+ {
|
|
|
+ data=NF_RDDATA(); /* verify 1-512 byte */
|
|
|
+ if(data != buffer[i])
|
|
|
+ {
|
|
|
+ trace_log("block %d, page %d\n", block , page);
|
|
|
+ trace_log("write data failed[%d]: %02x %02x\n", i, data, buffer[i]);
|
|
|
+
|
|
|
+ NF_Reset();
|
|
|
+ NF_OE_H();
|
|
|
+ NF_UnInit();
|
|
|
+ return FLASH_NG;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ for(i=0; i<16; i++)
|
|
|
+ {
|
|
|
+ data=NF_RDDATA(); /* verify 16 byte dummy data */
|
|
|
+ if(data != se[i])
|
|
|
+ {
|
|
|
+ trace_log("block %d, page %d\n", block , page);
|
|
|
+ trace_log("write oob failed[%d]: %02x %02x\n", i, data, se[i]);
|
|
|
+ NF_Reset();
|
|
|
+ NF_OE_H();
|
|
|
+ NF_UnInit();
|
|
|
+ return FLASH_NG;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ NF_OE_H();
|
|
|
+ NF_UnInit();
|
|
|
+ return FLASH_OK;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ * @ Funciton: NF_ReadID
|
|
|
+ * Parameter: id: pointer to device ID
|
|
|
+ * Return: None
|
|
|
+ */
|
|
|
+void NF_ReadID(unsigned char *id)
|
|
|
+{
|
|
|
+ unsigned char maker_code;
|
|
|
+ NF_Init();
|
|
|
+ NF_OE_L();
|
|
|
+ NF_DATA_OUT();
|
|
|
+ NF_CMD(NAND_CMD_READID);
|
|
|
+ NF_ADDR(0x00);
|
|
|
+ NF_CLR_ALE();
|
|
|
+ Wait(10);
|
|
|
+ NF_DATA_IN();
|
|
|
+ maker_code = NF_RDDATA();
|
|
|
+ maker_code = maker_code;
|
|
|
+ *id = NF_RDDATA();
|
|
|
+ NF_OE_H();
|
|
|
+ NF_UnInit();
|
|
|
+}
|
|
|
+
|
|
|
+static rt_err_t rt_nand_init (rt_device_t dev)
|
|
|
+{
|
|
|
+ /* empty implementation */
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+
|
|
|
+static rt_err_t rt_nand_open(rt_device_t dev, rt_uint16_t oflag)
|
|
|
+{
|
|
|
+ /* empty implementation */
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+
|
|
|
+static rt_err_t rt_nand_close(rt_device_t dev)
|
|
|
+{
|
|
|
+ /* empty implementation */
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+
|
|
|
+/* nand device read */
|
|
|
+static rt_size_t rt_nand_read (rt_device_t dev, rt_off_t pos, void* buffer,
|
|
|
+ rt_size_t size)
|
|
|
+{
|
|
|
+ rt_ubase_t block; /* block of position */
|
|
|
+ rt_ubase_t page, index; /* page in block of position */
|
|
|
+ rt_uint8_t *page_ptr, oob[16];
|
|
|
+ struct rt_device_nand *nand;
|
|
|
+
|
|
|
+ /* get nand device */
|
|
|
+ nand = (struct rt_device_nand*) dev;
|
|
|
+ RT_ASSERT(nand != RT_NULL);
|
|
|
+
|
|
|
+ /* get block and page */
|
|
|
+ block = pos / nand->page_per_block;
|
|
|
+ page = pos % nand->page_per_block;
|
|
|
+
|
|
|
+ trace_log("nand read: position %d, block %d, page %d, size %d\n",
|
|
|
+ pos, block, page, size);
|
|
|
+
|
|
|
+ /* set page buffer pointer */
|
|
|
+ page_ptr = (rt_uint8_t*) buffer;
|
|
|
+ for (index = 0; index < size; index ++)
|
|
|
+ {
|
|
|
+ NF_ReadPage(block, page + index, page_ptr, oob);
|
|
|
+ page_ptr += nand->page_size;
|
|
|
+
|
|
|
+ if (page + index > nand->page_per_block)
|
|
|
+ {
|
|
|
+ block += 1;
|
|
|
+ page = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /* return read size (count of block) */
|
|
|
+ return size;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ * write pages by erase block first
|
|
|
+ * @param nand the nand device driver
|
|
|
+ * @param block the block of page
|
|
|
+ * @param page the page
|
|
|
+ * @param buffer the data buffer to be written
|
|
|
+ * @param pages the number of pages to be written
|
|
|
+ */
|
|
|
+static int rt_nand_eraseblock_writepage(struct rt_device_nand* nand,
|
|
|
+ rt_ubase_t block, rt_ubase_t page,
|
|
|
+ const rt_uint8_t *buffer, rt_ubase_t pages)
|
|
|
+{
|
|
|
+ rt_ubase_t index;
|
|
|
+ rt_uint32_t page_status;
|
|
|
+ rt_uint8_t *page_ptr, oob[16];
|
|
|
+
|
|
|
+ /* set page status */
|
|
|
+ page_status = 0;
|
|
|
+
|
|
|
+ /* read each page in block */
|
|
|
+ page_ptr = nand->block_buffer;
|
|
|
+ for (index = 0; index < nand->page_per_block; index ++)
|
|
|
+ {
|
|
|
+ NF_ReadPage(block, index, page_ptr, oob);
|
|
|
+ if (!oob[0])
|
|
|
+ page_status |= (1 << index);
|
|
|
+ page_ptr += nand->page_size;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* erase block */
|
|
|
+ NF_EraseBlock(block);
|
|
|
+
|
|
|
+ page_ptr = &(nand->block_buffer[page * nand->page_size]);
|
|
|
+ /* merge buffer to page buffer */
|
|
|
+ for (index = 0; index < pages; index ++)
|
|
|
+ {
|
|
|
+ rt_memcpy(page_ptr, buffer, nand->page_size);
|
|
|
+
|
|
|
+ /* set page status */
|
|
|
+ page_status |= (1 << (page + index));
|
|
|
+
|
|
|
+ /* move to next page */
|
|
|
+ page_ptr += nand->page_size;
|
|
|
+ buffer += nand->page_size;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* write to flash */
|
|
|
+ page_ptr = nand->block_buffer;
|
|
|
+ for (index = 0; index < nand->page_per_block; index ++)
|
|
|
+ {
|
|
|
+ if (page_status & (1 << index))
|
|
|
+ NF_WritePage(block, index, page_ptr);
|
|
|
+
|
|
|
+ /* move to next page */
|
|
|
+ page_ptr += nand->page_size;
|
|
|
+ }
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/* nand device write */
|
|
|
+static rt_size_t rt_nand_write (rt_device_t dev, rt_off_t pos,
|
|
|
+ const void* buffer, rt_size_t size)
|
|
|
+{
|
|
|
+ rt_ubase_t block, page;
|
|
|
+ rt_uint8_t oob[16];
|
|
|
+ struct rt_device_nand *nand;
|
|
|
+
|
|
|
+ nand = (struct rt_device_nand*) dev;
|
|
|
+ RT_ASSERT(nand != RT_NULL);
|
|
|
+
|
|
|
+ /* get block and page */
|
|
|
+ block = pos / nand->page_per_block;
|
|
|
+ page = pos % nand->page_per_block;
|
|
|
+
|
|
|
+ trace_log("nand write: position %d, block %d, page %d, size %d\n",
|
|
|
+ pos, block, page, size);
|
|
|
+
|
|
|
+ if (size == 1)
|
|
|
+ {
|
|
|
+ /* write one page */
|
|
|
+
|
|
|
+ /* read oob to get page status */
|
|
|
+ NF_ReadPage(block, page, RT_NULL, oob);
|
|
|
+ if (oob[0])
|
|
|
+ NF_WritePage(block, page, buffer);
|
|
|
+ else
|
|
|
+ /* erase block and then write page */
|
|
|
+ rt_nand_eraseblock_writepage(nand, block, page, buffer, 1);
|
|
|
+ }
|
|
|
+ else if (size > 1)
|
|
|
+ {
|
|
|
+ rt_ubase_t index;
|
|
|
+ rt_ubase_t need_erase_block;
|
|
|
+ const rt_uint8_t *page_ptr;
|
|
|
+ rt_ubase_t chunk_pages, pages;
|
|
|
+
|
|
|
+ pages = size;
|
|
|
+ page_ptr = (const rt_uint8_t*) buffer;
|
|
|
+ do
|
|
|
+ {
|
|
|
+ need_erase_block = 0;
|
|
|
+ /* calculate pages in current chunk */
|
|
|
+ if (pages > nand->page_per_block - page)
|
|
|
+ chunk_pages = nand->page_per_block - page;
|
|
|
+ else
|
|
|
+ chunk_pages = pages;
|
|
|
+
|
|
|
+ /* get page status in current block */
|
|
|
+ for (index = page; index < page + chunk_pages; index ++)
|
|
|
+ {
|
|
|
+ NF_ReadPage(block, index, RT_NULL, oob);
|
|
|
+ if (!oob[0])
|
|
|
+ {
|
|
|
+ /* this page has data, need erase this block firstly */
|
|
|
+ need_erase_block = 1;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (need_erase_block)
|
|
|
+ {
|
|
|
+ /* erase block and then write it */
|
|
|
+ rt_nand_eraseblock_writepage(nand, block, page, page_ptr, chunk_pages);
|
|
|
+ page_ptr += chunk_pages * nand->page_size;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ /* write pages directly */
|
|
|
+ for (index = page; index < page + chunk_pages; index ++)
|
|
|
+ {
|
|
|
+ NF_WritePage(block, index, page_ptr);
|
|
|
+ page_ptr += nand->page_size;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ pages -= chunk_pages;
|
|
|
+ page = 0; block ++; /* move to next block */
|
|
|
+ }
|
|
|
+ while (pages);
|
|
|
+ }
|
|
|
+
|
|
|
+ return size;
|
|
|
+}
|
|
|
+
|
|
|
+static rt_err_t rt_nand_control (rt_device_t dev, rt_uint8_t cmd, void *args)
|
|
|
+{
|
|
|
+ struct rt_device_nand *nand;
|
|
|
+
|
|
|
+ nand = (struct rt_device_nand*) dev;
|
|
|
+ RT_ASSERT(dev != RT_NULL);
|
|
|
+
|
|
|
+ switch (cmd)
|
|
|
+ {
|
|
|
+ case RT_DEVICE_CTRL_BLK_GETGEOME:
|
|
|
+ {
|
|
|
+ struct rt_device_blk_geometry *geometry;
|
|
|
+
|
|
|
+ geometry = (struct rt_device_blk_geometry *)args;
|
|
|
+ if (geometry == RT_NULL) return -RT_ERROR;
|
|
|
+
|
|
|
+ geometry->bytes_per_sector = nand->page_size;
|
|
|
+ geometry->block_size = nand->page_size * nand->page_per_block;
|
|
|
+ geometry->sector_count = nand->block_num * nand->page_per_block;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ return RT_EOK;
|
|
|
+}
|
|
|
+
|
|
|
+void rt_hw_nand_init(void)
|
|
|
+{
|
|
|
+ /* initialize nand flash structure */
|
|
|
+ _nand.block_num = BLOCK_NUM;
|
|
|
+ _nand.page_per_block = PAGE_PER_BLOCK;
|
|
|
+ _nand.page_size = PAGE_SIZE;
|
|
|
+
|
|
|
+ rt_memset(_nand.block_buffer, 0, sizeof(_nand.block_buffer));
|
|
|
+
|
|
|
+ _nand.parent.type = RT_Device_Class_MTD;
|
|
|
+ _nand.parent.rx_indicate = RT_NULL;
|
|
|
+ _nand.parent.tx_complete = RT_NULL;
|
|
|
+ _nand.parent.init = rt_nand_init;
|
|
|
+ _nand.parent.open = rt_nand_open;
|
|
|
+ _nand.parent.close = rt_nand_close;
|
|
|
+ _nand.parent.read = rt_nand_read;
|
|
|
+ _nand.parent.write = rt_nand_write;
|
|
|
+ _nand.parent.control = rt_nand_control;
|
|
|
+
|
|
|
+ /* register a MTD device */
|
|
|
+ rt_device_register(&(_nand.parent), "nand", RT_DEVICE_FLAG_RDWR);
|
|
|
+}
|
|
|
+
|
|
|
+#ifdef NAND_DEBUG
|
|
|
+#include <finsh.h>
|
|
|
+unsigned char nand_buffer[512];
|
|
|
+unsigned char nand_oob[16];
|
|
|
+
|
|
|
+void dump_mem(unsigned char* buffer, int length)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+
|
|
|
+ if (length > 64) length = 64;
|
|
|
+ for (i = 0; i < length; i ++)
|
|
|
+ {
|
|
|
+ rt_kprintf("%02x ", *buffer++);
|
|
|
+ if (((i+1) % 16) == 0)
|
|
|
+ rt_kprintf("\n");
|
|
|
+ }
|
|
|
+ rt_kprintf("\n");
|
|
|
+}
|
|
|
+
|
|
|
+void nand_read(int block, int page)
|
|
|
+{
|
|
|
+ rt_kprintf("read block %d, page %d\n", block, page);
|
|
|
+
|
|
|
+ NF_ReadPage(block, page, nand_buffer, nand_oob);
|
|
|
+ rt_kprintf("page data:\n");
|
|
|
+ dump_mem(nand_buffer, 512);
|
|
|
+ rt_kprintf("oob data:\n");
|
|
|
+ dump_mem(nand_oob, 16);
|
|
|
+}
|
|
|
+FINSH_FUNCTION_EXPORT_ALIAS(nand_read, read_page, read page[block/page]);
|
|
|
+
|
|
|
+void nand_write(int block, int page)
|
|
|
+{
|
|
|
+ int i;
|
|
|
+ for (i = 0; i < 512; i ++)
|
|
|
+ nand_buffer[i] = i;
|
|
|
+
|
|
|
+ NF_WritePage(block, page, nand_buffer);
|
|
|
+}
|
|
|
+FINSH_FUNCTION_EXPORT_ALIAS(nand_write, write_page, write page[block/page]);
|
|
|
+
|
|
|
+void nand_erase(int block)
|
|
|
+{
|
|
|
+ NF_EraseBlock(block);
|
|
|
+}
|
|
|
+FINSH_FUNCTION_EXPORT_ALIAS(nand_erase, erase_block, erase block[block]);
|
|
|
+
|
|
|
+void nand_readoob(int block, int page)
|
|
|
+{
|
|
|
+ rt_kprintf("read oob on block %d, page %d\n", block, page);
|
|
|
+
|
|
|
+ NF_ReadPage(block, page, RT_NULL, (unsigned char*)nand_oob);
|
|
|
+ rt_kprintf("oob data:\n");
|
|
|
+ dump_mem(nand_oob, 16);
|
|
|
+}
|
|
|
+FINSH_FUNCTION_EXPORT_ALIAS(nand_readoob, readoob, read oob[block/page]);
|
|
|
+
|
|
|
+void nand_erase_chip()
|
|
|
+{
|
|
|
+ int i;
|
|
|
+ unsigned char id;
|
|
|
+
|
|
|
+ NF_ReadID(&id);
|
|
|
+ rt_kprintf("id: %02x\n", id);
|
|
|
+
|
|
|
+ for (i = 0; i < 2048; i ++)
|
|
|
+ {
|
|
|
+ NF_EraseBlock(i);
|
|
|
+ }
|
|
|
+}
|
|
|
+FINSH_FUNCTION_EXPORT_ALIAS(nand_erase_chip, erase_chip, erase whole chip);
|
|
|
+#endif
|
bernard.xiong@gmail.com