libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/fujitsu/mb9x/mb9bf506r/drivers/nand.c

664 lines
17 KiB
C
Raw Blame History

/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* 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_ssize_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_ssize_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, int 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(void)
{
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
View Git Blame Copy Permalink