RT-Thread下移植添加nand-flash驱动

1：版本

使用的版本上v3.1.4中移除了mtd的相关代码，如果需要添加就从v3.1.3中获取。
由于我要移植yaffs所以需要这个框架

2:注册函数

//mtd.c
/*
 * Register MTD driver
 *
 * @parts partion description
 * @np number of partitions
 * @return number of unregistered partitions
 *
*/
int rt_mtd_register(rt_mtd_t *master, const struct mtd_part *parts, int np)
{
    int ret;
    rt_mtd_t *slave;

    master->master = master;
    master->parent.type = RT_Device_Class_MTD;

    if (np > 0)
    {
        master->offset = parts->offset;
        master->size = parts->size;

        ret = rt_device_register((rt_device_t)master, parts->name, 0);
        if (ret != 0)
            goto _out;

        np --;
        parts ++;
    }

    while (np > 0)
    {
        slave = mtd_part_alloc(master, parts);
        if (!slave)
            break;
        ret = rt_device_register((rt_device_t)slave, parts->name, 0);
        if (ret)
            break;
        parts ++;
        np --;
    }

_out:
    return np;
}

这个函数会注册一个mtd设备
所以要对
rt_mtd_t *master
const struct mtd_part *parts
int np
进行赋值

typedef struct mtd_info
{
    struct rt_device parent;  

    const struct mtd_ops *ops; //集体的操作函数，看下个图

    uint16_t oob_size;
    uint16_t sector_size;   /* Minimal writable flash unit size */
    uint32_t block_size:28; /* Erase size for the device */
    uint32_t type:4;

    size_t size;    /* Total size of the MTD */
    loff_t offset;  /* At which this MTD starts, from the beginning of the MEMORY */
    struct mtd_info *master;

    void *priv;
}rt_mtd_t;

这个具体的函数指针，要对这样指针进行赋值具体的函数，如果设备注册成功的话。调用设备里的读写函数就是调用这里的指向的函数。

struct mtd_ops
{
    int(*erase)(rt_mtd_t *mtd, loff_t addr, size_t len);    /* return 0 if success */
    int(*read) (rt_mtd_t *mtd, loff_t from, struct mtd_io_desc *ops); /* return 0 if success */
    int(*write) (rt_mtd_t *mtd, loff_t to, struct mtd_io_desc *ops);  /* return 0 if success */
    int(*isbad) (rt_mtd_t *mtd, uint32_t block);    /* return 1 if bad, 0 not bad */
    int(*markbad) (rt_mtd_t *mtd, uint32_t block);  /* return 0 if success */
};

这个结构体：由设备的名字，起始位置，大小。

struct mtd_part
{
    const char *name;           /* name of the MTD partion */
    loff_t offset;              /* start addr of partion */
    size_t size;                /* size of partion */
};

3：赋值

在Rt-thread下自带的文件mtdnand.c中已经对操作函数进行赋值:

//mtdnand.c

static const struct mtd_ops _ops =
{
    nand_erase,
    nand_read,
    nand_write,
    nand_block_isbad,
    nand_block_markbad,
};

int rt_mtd_nand_init(rt_nand_t *nand, int blk_size, int page_size, int oob_size)
{
    uint8_t *buf;

    buf = rt_malloc(oob_size * 3);
    if (buf == RT_NULL)
        return -ENOMEM;

    nand->oob_poi = buf;
    buf += oob_size;
    nand->buffers.ecccalc = buf;
    buf += oob_size;
    nand->buffers.ecccode = buf;
    nand->pagebuf = 0; /* alloc when unaligen access */

    nand->pages_pb = blk_size / page_size;
    nand->ecc._step = page_size / nand->ecc.stepsize;
    nand->page_size = page_size;
    nand->oobsize = oob_size;

    nand->parent.type = MTD_TYPE_NAND;
    nand->parent.ops = &_ops;
    nand->parent.sector_size = page_size;
    nand->parent.block_size = blk_size;
    nand->parent.oob_size = oob_size;

    switch (nand->ecc.mode)
    {
    case NAND_ECCM_NONE:
    {
        nand->read_page = nand_read_page_raw;
        nand->write_page = nand_write_page_raw;
    }break;
    case NAND_ECCM_HW:
    {
        nand->read_page = nand_read_page_hwecc;
        nand->write_page = nand_write_page_hwecc;
    }break;
    default:
    {
        rt_free(buf);
        return -1;
    }
    }

    return 0;
}

用其中的擦除为例nand_erase

static int nand_erase(rt_mtd_t *mtd, loff_t addr, size_t size)
{
    rt_nand_t *chip;
    int status;
    int page;
    uint32_t blksize;

    chip = MTDTONAND(mtd);
    blksize = mtd->block_size;
    page = addr / chip->page_size;

    while (size >= blksize)
    {
        status = chip->ops->cmdfunc(chip, NAND_CMD_BLK_ERASE, page, 0);
        if (status & NAND_STATUS_FAIL)
        {
            break;
        }
        size -= blksize;
        page += chip->pages_pb;
    }

    return size;
}

其中由status = chip->ops->cmdfunc(chip, NAND_CMD_BLK_ERASE, page, 0); 表示通过这个语句可以经行具体的命令的操作。这里就操作到的底层的驱动。这个需要实现。这个函数在下面这个结构体中的const struct nand_ops *ops;

typedef struct nand_chip
{
    rt_mtd_t parent;
    /* driver must init these */
    const struct nand_ops *ops;
    struct nand_ecc ecc;
    const struct mtd_oob_region *freelayout;

    /* driver do not touch */
    struct nand_buffers buffers;
    uint8_t *oob_poi;
    uint8_t *pagebuf;
    uint32_t size;
    uint16_t oobsize;
    uint8_t pages_pb;
    uint16_t page_size;
    int(*read_page)(struct nand_chip *chip, uint8_t *buf, int oob_required, int page);
    int(*write_page)(struct nand_chip *chip, const uint8_t *buf, int oob_required, int page);
}rt_nand_t;

struct nand_ops
{
    int(*cmdfunc)(rt_nand_t *nand, int cmd, int page, int offset); /* send nand operation cmd, return Status bits(0 success),
                                                                      if nand is busy please wait in low driver */
    int(*read_buf)(rt_nand_t *nand, uint8_t *buf, int len);        /* read data from nand chip's page buffer */
    int(*write_buf)(rt_nand_t *nand, const  uint8_t *buf, int len);/* write data to nand chip's page buffer */
    int(*isbad)(rt_nand_t *nand, uint32_t blk);   /* if NULL OOB[0] used as bad mark(not 0xff is bad) */
    int(*markbad)(rt_nand_t *nand, uint32_t blk); /* if NULL OOB[0] used as bad mark(set to 0x00) */
};

4：底层驱动

所以我们在这里建立新的文件对应自己的nand-flash驱动，对上面的函数和结构体进行赋值
并进行初始化flash控制器的操作

static const struct nand_ops nuc970_nand_ops =
{
	nuc977_nand_cmdfunc,
    nuc977_nand_read_buf,
    nuc977_nand_write_buf,
    nuc977_nand_isbad,
	nuc977_nand_markbad
 
};
/* nandflash confg */

int nuc970_fmi_nand_init(void)
{
	char *name = "nand1";
	rt_uint32_t eBCHAlgo;
	rt_nand_t *nand	= &nand_chip[0];
	
	nand->ops = &nuc970_nand_ops;
	nand->oobsize = PAGE_OOB_SIZE;
	
    /* initial NAND controller */
    outpw(REG_CLK_HCLKEN, (inpw(REG_CLK_HCLKEN) | 0x300000));

    /* select NAND function pins */
    if (inpw(REG_SYS_PWRON) & 0x08000000)
    {
        /* Set GPI1~15 for NAND */
        outpw(REG_SYS_GPI_MFPL, 0x55555550);
        outpw(REG_SYS_GPI_MFPH, 0x55555555);
    }
    else
    {
        /* Set GPC0~14 for NAND */
        outpw(REG_SYS_GPC_MFPL, 0x55555555);
        outpw(REG_SYS_GPC_MFPH, 0x05555555);
    }

    // Enable SM_EN
    outpw(REG_FMI_CTL, NAND_EN);
    outpw(REG_NANDTMCTL, 0x20305);

    // Enable SM_CS0
    outpw(REG_NANDCTL, (inpw(REG_NANDCTL)&(~0x06000000))|0x04000000);
    outpw(REG_NANDECTL, 0x1); /* un-lock write protect */

    // NAND Reset
    outpw(REG_NANDCTL, inpw(REG_NANDCTL) | 0x1);    // software reset
    while (inpw(REG_NANDCTL) & 0x1);

    /* Detect NAND chips */
    /* first scan to find the device and get the page size */
//	if (nand_scan_ident(&(nuc970_nand->mtd), 1, NULL)) {
//        rt_kprintf("NAND Flash not found !\n");
//        return -1;
//    }
	
    //Set PSize bits of SMCSR register to select NAND card page size
    switch (PAGE_PAGE_SIZE) {
        case 2048:
            outpw(REG_NANDCTL, (inpw(REG_NANDCTL)&(~0x30000)) + 0x10000);
            eBCHAlgo = 0; /* T4 */
           // nuc970_layout_oob_table ( &nuc970_nand_oob, mtd->oobsize, g_i32ParityNum[1][nuc970_nand->eBCHAlgo] );
            break;

        case 4096:
            outpw(REG_NANDCTL, (inpw(REG_NANDCTL)&(~0x30000)) + 0x20000);
            eBCHAlgo = 1; /* T8 */
            //nuc970_layout_oob_table ( &nuc970_nand_oob, mtd->oobsize, g_i32ParityNum[2][nuc970_nand->eBCHAlgo] );
            break;

        case 8192:
            outpw(REG_NANDCTL, (inpw(REG_NANDCTL)&(~0x30000)) + 0x30000);
            eBCHAlgo = 2; /* T12 */
            //nuc970_layout_oob_table ( &nuc970_nand_oob, mtd->oobsize, g_i32ParityNum[3][nuc970_nand->eBCHAlgo] );
            break;

        /* Not support now. */
        case 512:

        default:
            rt_kprintf("NUC970 NAND CONTROLLER IS NOT SUPPORT THE PAGE SIZE. (%d, %d)\n", 2048, 64 );
    }
	
    // Redundant area size
    outpw(REG_NANDRACTL, PAGE_OOB_SIZE);

    // Protect redundant 3 bytes
    // because we need to implement write_oob function to partial data to oob available area.
    // Please note we skip 4 bytes
    outpw(REG_NANDCTL, inpw(REG_NANDCTL) | 0x100);

    // To read/write the ECC parity codes automatically from/to NAND Flash after data area field written.
    outpw(REG_NANDCTL, inpw(REG_NANDCTL) | 0x10);
    // Set BCH algorithm
    outpw(REG_NANDCTL, (inpw(REG_NANDCTL) & (~0x007C0000)) | g_i32BCHAlgoIdx[eBCHAlgo]);
    // Enable H/W ECC, ECC parity check enable bit during read page
    outpw(REG_NANDCTL, inpw(REG_NANDCTL) | 0x00800080);

	rt_mtd_nand_init(nand, PAGE_BLOCK_SIZE, PAGE_PAGE_SIZE, PAGE_OOB_SIZE);
	rt_mtd_register(&(nand->parent), &parts, 1);
    return 0;
}

void nuc970_nand_mtd_init(void)
{

	nuc970_fmi_nand_init();
	nuc970_nand_read_id();
	
}
INIT_DEVICE_EXPORT(nuc970_nand_mtd_init);

5：总结

mtd.c提供了注册函数。mtdnand.c 实现内部的操作函数，但是到底层的具体操作没有实现。再加上自己的驱动文件，来实现底层操作来供mtdnand.c 来使用

这样就能注册MTD的设备