LPC1788 nand驱动

#ifndef __NANDFLASH_H_
#define __NANDFLASH_H_

#include "common.h"
#include "debugserial.h"
#include "delay.h"

//nand flash 使用cs1
//reday/busy  p2.21
//ale p5.1
//cle p5.0
//we  p4.25
//oe  p4.24 
//ce  p4.27


//命令地址
#define K9F1G_CLE   ((volatile uint8_t *)0x92000000)    //命令锁存使能地址
#define K9F1G_ALE    ((volatile uint8_t *)0x91000000)    //地址锁存使能地址
#define K9F1G_DATA  ((volatile uint8_t *)0x90000000)    //数据地址

//nand 命令列表
#define K9FXX_READ_1                0x00    //读数据第一个周期命令
#define K9FXX_READ_2                0x30    //读数据第二个周期命令
#define K9FXX_READ_COPYBACK_1        0x00    //读取数据用于copyback
#define K9FXX_READ_COPYBACK_2        0x35    //copy back指令2
#define K9FXX_READ_ID               0x90    //读取ID
#define K9FXX_RESET                 0xFF    //复位
#define K9FXX_BLOCK_PROGRAM_1       0x80    //页编程第一周期指令
#define K9FXX_BLOCK_PROGRAM_2       0x10    //页编程第二周期地址
#define K9FXX_BLOCK_ERASE_1         0x60    //块擦除第一周期命令
#define K9FXX_BLOCK_ERASE_2         0xD0    //块擦除第二周期命令
#define K9FXX_READ_STATUS           0x70    //读状态 70H

//芯片ID
#define K9FXX_ID                    0xF1009540    /* Byte 3 and 2 only */

//nand状态
#define K9FXX_BUSY                  (1 << 6)
#define K9FXX_OK                    (1 << 0)

//相关定义
#define NANDFLASH_BASE_ADDR            0x00000000    //起始地址

#define NANDFLASH_NUMOF_BLOCK        1024        //nand一共拥有的块数量

#define NANDFLASH_RW_PAGE_SIZE        2048        // 每页2048个存储字节

#define NANDFLASH_SPARE_SIZE        64             //每页64个spare的备用空间(用于页数据的ECC校验和存放)

#define NANDFLASH_PAGE_PER_BLOCK    64            //一个块的中page数量

#define NANDFLASH_PAGE_FSIZE        (NANDFLASH_RW_PAGE_SIZE + NANDFLASH_SPARE_SIZE)//每一页的实际大小(byte)

#define NANDFLASH_BLOCK_RWSIZE    (NANDFLASH_RW_PAGE_SIZE * NANDFLASH_PAGE_PER_BLOCK)//每一页可读取的空间

#define NANDFLASH_BLOCK_FSIZE    (NANDFLASH_PAGE_FSIZE * NANDFLASH_PAGE_PER_BLOCK)//实际上每一页的空间

//可读取空间 = 2048(一页存储字节)*64(页数量)*1024(块数量) = 128MB
//实际空间 = (2048+64)*64 * 1024 = 132 MB
#define NANDFLASH_INVALIDBLOCK_CHECK_COLUMM            (2048)//支持块校验数

#define NAND_WAIT_BUSY_MAX_TIME                        100            //MS 等待响应时间


void nand_init(void);

void nand_reset(void);

u8 nand_wait_ready(void);

u32 nand_read_id(void);

u8 nand_read_status(u32 cmd);

u8 nand_block_erase(u32 block_num);

u8 nand_page_program(u32 blocknum,u32 pagenum,u8* buffer);

u8 nand_check(void);

u8 nand_page_read(u32 pagenum,u32 blocknum,u8* buffer);

u32 nand_page_read_from_begin(u32 block,u32 page,u8* buffer);

u32 nand_page_read_from_addr(u32 blocknum,u32 pagenum,u32 addrinpage,u8* buffer,u32 readsize);

u32 nand_read_form_addr(u32 addrInWholeNand,u8* buffer,u32 size);





#endif












#include "nandflash.h"

/*********************************************************************//**
 * 获取相应的io配置寄存器指针
 **********************************************************************/
static u32 * PIN_GetPointer(u8 portnum, u8 pinnum)
{
    u32 *pPIN = NULL;
    pPIN = (u32 *)(LPC_IOCON_BASE + ((portnum * 32 + pinnum)*sizeof(u32)));
    return pPIN;
}

/*********************************************************************//**
 *配置IO口功能
 **********************************************************************/
static void PINSEL_ConfigPin ( u8 portnum, u8 pinnum, u8 funcnum)
{
    u32 *pPIN = NULL;
    pPIN = PIN_GetPointer(portnum, pinnum);
    *pPIN &= 0x00000007;//Clear function bits
    *pPIN |= funcnum;
}

//初始化nand接口,主要是初始化IO口以及初始化EMC外设
void nand_init()
{
    LPC_SC->SCS |= (1<<0);//emc地址不移位
    //打开emc时钟与端口时钟
    LPC_SC->PCONP |= (1<<15)|(1<<11);//打开时钟
    LPC_SC->EMCDLYCTL   = 0x00001010;//延时时间初始化
    LPC_EMC->Control     = 0x00000001;//emc使能
    LPC_EMC->Config      = 0x00000000;//emc配置清零,小端模式
    
   //我们选用的nand使用的外部引脚主要有
   //P3.0-P3.7 P5.0 P5.1 P4.24 P4.25 P4.31 P2.21 
   //配置IO寄存器    
    //d0--d7
    PINSEL_ConfigPin(3,0,1);
    PINSEL_ConfigPin(3,1,1);
    PINSEL_ConfigPin(3,2,1);
    PINSEL_ConfigPin(3,3,1);
    PINSEL_ConfigPin(3,4,1);
    PINSEL_ConfigPin(3,5,1);
    PINSEL_ConfigPin(3,6,1);
    PINSEL_ConfigPin(3,7,1);
    //cle ale
    PINSEL_ConfigPin(5,0,1);
    PINSEL_ConfigPin(5,1,1);
    
    PINSEL_ConfigPin(4,24,1);//OE
    PINSEL_ConfigPin(4,25,1);//WE
    PINSEL_ConfigPin(4,31,1);//CS1
    
    //初始化忙引脚为输入模式
    PINSEL_ConfigPin(2,21,0);
    P2dir(21) = 0;

    LPC_EMC->Control = (1<<0)|(1<<1);//使能emc并复位存储器映射
    LPC_EMC->StaticConfig1 &= ~(3<<0);    //设置总线宽度八位
    LPC_EMC->StaticConfig1 |= (1<<7);    //设置读写有效电平,读为低电平
    LPC_EMC->StaticWaitWen1 &= ~(7<<0);
    LPC_EMC->StaticWaitWen1 |= (2<<0);//设置片选到写使能的延时时间
    LPC_EMC->StaticWaitOen1 &= ~(7<<0);
    LPC_EMC->StaticWaitOen1 |= (2<<0);//设置片选到输出使能的延时
    LPC_EMC->StaticWaitWr1 &= ~(0x1f<<0);
    LPC_EMC->StaticWaitWr1 |= (0x1f<<0);//设置片选到写入的延时
    LPC_EMC->StaticWaitPage1 &= ~(0x1f<<0);
    LPC_EMC->StaticWaitPage1 |= (0x1f<<0);//设置读模式顺序存取延时
    LPC_EMC->StaticWaitRd1 &= ~(0x1f<<0);
    LPC_EMC->StaticWaitRd1 |= (0x1f<<0);//设置片选到读取的延时
    LPC_EMC->StaticWaitTurn1 &= ~(0x1f<<0);
    LPC_EMC->StaticWaitTurn1 |= (0x1f<<0);//设置总线周转周期
    
    DelayMs(2);
}

//nand复位
void nand_reset()
{
    volatile u8 *pCLE;

    /* Reset NAND FLASH  through NAND FLASH command */
    pCLE = K9F1G_CLE;
    *pCLE = K9FXX_RESET;

    DelayMs(2);
    return;
}

//等待nand不忙
u8 nand_wait_ready()
{
    u8 waitTime = 0;
    while(P2in(21) == 1)        /* 等待他为高,说明我们的操作正在进行 */
    {
        waitTime++;
        DelayUs(1);
        if(waitTime > NAND_WAIT_BUSY_MAX_TIME)
            return 1;
        
    }
    waitTime = 0;
    while(!(P2in(21) == 1))    /* 等待他为低,说明操作已经完成 */
    {
        waitTime++;
        DelayUs(1);
        if(waitTime > NAND_WAIT_BUSY_MAX_TIME)
            return 1;
        
    }
    return 0;
}

//读取nand id
u32 nand_read_id()
{
    u8 b, c, d, e;
    volatile u8 *pCLE;
    volatile u8 *pALE;
    volatile u8 *pDATA;

    pCLE  = K9F1G_CLE;
    pALE  = K9F1G_ALE;
    pDATA = K9F1G_DATA;

    *pCLE = K9FXX_READ_ID;
    *pALE = 0;

    b = *pDATA;//伪读取 无效
    b = *pDATA;
    c = *pDATA;
    d = *pDATA;
    e = *pDATA;
    
    return ((b << 24) | (c << 16) | (d << 8) | e);
}

//读取nand状态
u8 nand_read_status(u32 cmd)
{
    volatile u8 *pCLE;
    volatile u8 *pDATA;
    u8 waitTime = 0;    //等待时间
    u8 StatusData;

    pCLE  = K9F1G_CLE;
    pDATA = K9F1G_DATA;

    *pCLE = K9FXX_READ_STATUS;

    while ( (*pDATA & 0xC0) != 0xC0 )    //等待芯片ready并且无保护(失败应当有错误处理,暂时没做)
    {
        waitTime++;
        DelayUs(1);
        if(waitTime > NAND_WAIT_BUSY_MAX_TIME)
            return 1;
        
    }
    StatusData = *pDATA;

    switch (cmd)
    {
        case K9FXX_BLOCK_PROGRAM_1://编程或擦除的第二个指令
        case K9FXX_BLOCK_ERASE_1:
              if (StatusData & 0x01)    /* Erase/Program failure(1) or pass(0) */
                return 1;
              else
                return 0;
            
        case K9FXX_READ_1:                /* bit 5 and 6, Read busy(0) or ready(1) */
              return 0;
        default:
              break;
    }

    return(1);
}

//块擦除nand
u8 nand_block_erase(u32 block_num)
{
    volatile u8 *pCLE;
    volatile u8 *pALE;
    u32 rowAddr;

    pCLE  = K9F1G_CLE;
    pALE  = K9F1G_ALE;

    //计算地址
    rowAddr = (NANDFLASH_BASE_ADDR + block_num * NANDFLASH_BLOCK_FSIZE);//得到块基地址
    rowAddr = rowAddr - (rowAddr % NANDFLASH_BLOCK_FSIZE);//得到块偏移地址(页地址)

    *pCLE = K9FXX_BLOCK_ERASE_1;

    *pALE = (u8)(rowAddr & 0x00FF);            /* column address low */

    *pALE = (u8)((rowAddr & 0xFF00) >> 8);    /* column address high */

    *pCLE = K9FXX_BLOCK_ERASE_2;//擦除数据

    nand_wait_ready();

    return(nand_read_status(K9FXX_BLOCK_ERASE_1));
}

//每次至少写入2048字节 nand指定页编程 注意,编程之前需要先擦除的
u8 nand_page_program(u32 blocknum,u32 pagenum,u8* buffer)
{
    volatile u8 *pCLE;
    volatile u8 *pALE;
    volatile u8 *pDATA;
    u32 i, curAddr, curColumm;

    pCLE  = K9F1G_CLE;
    pALE  = K9F1G_ALE;
    pDATA = K9F1G_DATA;

    curAddr = NANDFLASH_BASE_ADDR + blocknum * NANDFLASH_BLOCK_FSIZE
                                + pagenum * NANDFLASH_PAGE_FSIZE;

    curColumm = curAddr % NANDFLASH_PAGE_FSIZE;
    curAddr -= curColumm;//得到具体地址

    *pCLE = K9FXX_BLOCK_PROGRAM_1;//编程命令1

    *pALE =  (u8)(curColumm & 0x000000FF);        /* column address low */

    *pALE = (u8)((curColumm & 0x00000F00) >> 8);    /* column address high */

    *pALE = (u8)((curAddr & 0x00FF0000) >> 16);    /* row address low */

    *pALE = (u8)((curAddr & 0xFF000000) >> 24);    /* row address high */

    //Not write to spare area for the NandFlash valid block checking
    for ( i = 0; i < NANDFLASH_RW_PAGE_SIZE; i++ )
    {
        *pDATA = *buffer++;
    }

    *pCLE = K9FXX_BLOCK_PROGRAM_2;//编程命令2

    nand_wait_ready();

    return( nand_read_status( K9FXX_BLOCK_PROGRAM_1 ) );//读取编程结果
}


//nand读取任意地址(慎用) 这个地址包含了附加数据地址 返回实际读取数据量
u32 nand_read_form_addr(u32 addrInWholeNand,u8* buffer,u32 size)
{
    volatile u8 *pCLE;
    volatile u8 *pALE;
    volatile u8 *pDATA;
    u32 i, curColumm, curRow;

    i = 0;

    pCLE  = K9F1G_CLE;
    pALE  = K9F1G_ALE;
    pDATA = K9F1G_DATA;

    curColumm = addrInWholeNand % NANDFLASH_PAGE_FSIZE;
    curRow = addrInWholeNand - curColumm;

    *pCLE = K9FXX_READ_1;

    *pALE = (u8)(curColumm & 0x000000FF);            /* column address low */

    *pALE = (u8)((curColumm & 0x00000F00) >> 8);        /* column address high */

    *pALE = (u8)((curRow & 0x00FF0000) >> 16);    /* row address low */

    *pALE = (u8)((curRow & 0xFF000000) >> 24);    /* row address high */

    *pCLE = K9FXX_READ_2;

    nand_wait_ready();

    for ( i = 0; i < (NANDFLASH_PAGE_FSIZE - curColumm); i++ )
    {
        *buffer = *pDATA;

        buffer++;
        if((i + 1) >= size)
            break;
    }
    return i;
}


//nand读取指定页数据,数据长度不能大于2048-addrinpage
u32 nand_page_read_from_addr(u32 blocknum,u32 pagenum,u32 addrinpage,u8* buffer,u32 readsize)
{
    u32 curAddr = 0;

    curAddr += NANDFLASH_BASE_ADDR + blocknum * NANDFLASH_BLOCK_FSIZE;

    curAddr += pagenum * NANDFLASH_PAGE_FSIZE;

    curAddr += addrinpage;

    return (nand_read_form_addr(curAddr, buffer, readsize));
}

//nand读取指定的页码全部数据,数据数量为 2048+32
u32 nand_page_read_from_begin(u32 block,u32 page,u8* buffer)
{
    return (nand_page_read_from_addr(block, page, 0, buffer, NANDFLASH_PAGE_FSIZE));
}

//nand读取指定页吗全部数据
u8 nand_page_read(u32 blocknum,u32 pagenum,u8* buffer)
{
    return (nand_page_read_from_begin(blocknum,pagenum,buffer) != 0);
}



//nand检查,每次检查每个bloak的前两个page,检查最后一个字节是不是0xff
u8 nand_check(void)
{
    u32 invailedBlock = 0;
    u8 temp = 0;
    u16 i = 0;
    for(i = 0; i < NANDFLASH_NUMOF_BLOCK;i++)
    {
        nand_page_read_from_addr(i,0,2048,&temp,1);
        if(temp == 0xff)
        {
            invailedBlock++;
            continue;
        }
        nand_page_read_from_addr(i,1,2048,&temp,1);
        if(temp == 0xff)
        {
            invailedBlock++;
        }
    }
    return (u8)invailedBlock;
}