ONFI规范，即Open Nand Flash Interface specification。

ONFI是Intel主导的，其他一些厂家（Hynix，Micron，Numonyx，Phison ，SanDisk，Sony，Spansion等）参与制定的，统一了Nand Flash的操作接口。

所谓操作接口，就是那些对Nand Flash操作的命令等内容。

而所谓统一，意思是之前那些Nand Flash的操作命令等，都是各自为政，虽然大多数常见的Nand Flash的操作，比如page read的命令是0x00,0x30，page write的命令是0x80,0x10等，但是有些命令相关的内容，很特别且很重要的一个例子就是，每个厂家的Nand Flash的read id的命令，虽然都是0x90，但是读取出来的几个字节的含义，每个厂家定义的都不太一样。

因此，才有统一Nand Flash的操作接口这一说。

ONFI规范，官网可以下载的到：

http://onfi.org/specifications/

比如：

ONFI 2.2 Spec

http://onfi.org/wp-content/uploads/2009/02/ONFI%202_2%20Gold.pdf

ONFI规范中定义的Nand Flash的命令集合为：

图 1.13. ONFI中的Nand Flash的命令集合

可以看到，其中常见的一些命令，比如

等等命令，都是和普通的Nand Flash的命令是一样的，而额外多出一些命令，比如Read Unique ID（0xED）等命令，是之前某些Nand Flash命令所不具有的。

如此，定义了Nand Flash的操作的命令的集合以及发送对应命令所遵循的时序等内容。

LBA Nand Flash，Logical Block Address，逻辑块寻址的Nand Flash，是Nand Flash大厂之一的Toshiba，自己独立设计出来的新一代的Nand Flash的规范。

之所以叫做逻辑块寻址，是相对于之前常见的，普通的Nand Flash的物理块的寻址来说的。常见的Nand Flash，如果要读取和写入数据，所用的对应的地址是对应的：block地址+block内的Page地址+Page内的偏移量 = 绝对的物理地址，

此物理块寻址，相对来说有个缺点，那就是，由于之前提到的Nand Flash会出现使用过程中出现坏块，所以，遇到这样的坏块，首先坏块管理要去将此坏块标记，然后将坏块的数据拷贝到另一个好的block中，再继续访问新的block。

而且数据读写过程中，还要有对应的ECC校验，很多情况下，也都是软件来实现这部分的工作，即使是硬件的ECC校验，也要写少量的软件，去操作对应寄存器，读取ECC校验的结果，当然别忘了，还有对应的负载平衡等工作。

如此的这类的坏块管理工作，对于软件来说，很是繁重，而且整个系统实现起来也不是很容易，所以，才催生了一个想法，是否可以把ECC校验，负载平衡，坏块管理，全部都放到硬件实现上，而对于软件来说，我都不关心，只关心有多少个Block供我使用，用于数据读写。

针对于此需求，Toshiba推出了LBA逻辑块寻址的Nand Flash，在Nand Flash存储芯片之外，加了对应一个硬件控制权Controller，实现了上述的坏块管理，ECC校验，负载平衡等工作，这样使得人家想要用你LBA的Nand Flash的人，去开发对应的软件来驱动LBA Nand Flash工作，相对要做的事情，就少了很多，相对来说就是减轻了软件系统集成方面的工作，提高了开发效率，缩短了产品上市周期。

LBA Nand，最早放出对应的样片（sample）是在2006年8月。

网上找到一个LBA Nand Flash的简介：

http://www.toshiba-components.com/prpdf/5678E.pdf

现早已经量产，偶在之前开发过程中，就用过其某款LBA的Nand Flash。

目前网上还找不到免费的LBA的规范。除非你搞开发，和Toshiba签订NDA协议后，才可以拿到对应的specification。

关于Toshiba LBA Nand规范，在此多说一点（参考附录中：lba-core.c）：

LBA Nand分为PNP，VFP和MDP三种分区：

在解释为何会有ONFI和LBA之前，先来个背景介绍：

目前Nand Flash的厂家有Samsung，Toshiba，Intel， Hynix，Micron，Numonyx，Phison ，SanDisk，Sony，Spansion等。

总的来说，ONFI在对于旧的Nand Flash的兼容上，都是相对类似的。

关于nand flash，由于各个厂家的read id读出的内容的定义，都不同，导致，对于读出的id，分别要用不同的解析方法，下面这段代码，是我之前写的，本来打算自己写信去推荐到Linux MTD内核源码的，不过后来由于没搞懂具体申请流程，就放弃了。不过，后来，看到Linux的MTD部分更新了，加了和下面类似的做法。

此处只是为了记录下来，也算给感兴趣的人一个参考吧。

文件：\linux-2.6.28.4\drivers\mtd\nand\nand_base.c

/*
 * Get the flash and manufacturer id and lookup if the type is supported
 */
static struct nand_flash_dev *nand_get_flash_type(struct mtd_info *mtd,
                          struct nand_chip *chip,
                          int busw, int *maf_id)
{
... ...
    chip->chipsize = (uint64_t)type->chipsize << 20;

    /* 针对不同的MLC和SLC的nand flash，添加了不同的解析其ID的方法 */
    /* Newer devices have all the information in additional id bytes */
    if (!type->pagesize) {
        int erase_bits, page_base, block_base, old_50nm, new_40nm;
        uint8_t id3rd, id4th, id5th, id6th, id7th;

        /* The 3rd id byte holds MLC / multichip data */
        chip->cellinfo = id3rd = chip->read_byte(mtd);
        /* The 4th id byte is the important one */
        id4th = chip->read_byte(mtd);
        id5th = chip->read_byte(mtd);
        id6th = chip->read_byte(mtd);
        id7th = chip->read_byte(mtd);
        /* printk(KERN_INFO " (ID:%02x %02x %02x %02x %02x %02x %02x) ",
            id1st, id2nd, id3rd, id4th, id5th, id6th, id7th); */

        if (nand_is_mlc(chip->cellinfo)) {
            /*
             * MLC:
             * 50nm has 5 bytes ID, further read ID will periodically output
             * 40nm has 6 bytes ID
             */

            /*
             * the 4th byte is not the same meaning for different manufature
            */
            if (NAND_MFR_SAMSUNG == *maf_id) {
                /* samsung MLC chip has several type ID meanings:
                (1)50nm serials, such as K9GAG08U0M
                (2)40nm serials, such as K9LBG08UXD
                */

                /* old 50nm chip will periodically output if read further ID */
                old_50nm = (id1st == id6th) && (id2nd == id7th);
                /* is 40nm or newer */
                new_40nm = id6th & 0x07;
                if ((!old_50nm) && new_40nm) {
                    /*
                     * Samsang
                     * follow algorithm accordding to datasheets of:
                     * K9LBG08UXD_1.3 (40nm), 
                     * ID(hex): EC D7 D5 29 38 41
                     * this algorithm is suitable for new chip than 50nm
                     * such as K9GAG08u0D, 
                     * ID(hex): EC D5 94 29 B4 41
                     */

                    int bit236;

                    /* Calc pagesize, bit0,bit1: page size */
                    page_base = (1 << 11);  /* 2KB */
                    mtd->writesize = page_base * (1 << (id4th & BIT01));
                    block_base = (1 << 17); /* 128 KB */
                    /* Calc block size, bit4,bit5,bit7: block size */
                    erase_bits = (id4th >> 4) & BIT01; /* get bit4,bit5 */
                    erase_bits |= (id4th >> 5) & BIT(2); /* get bit7 and combine them */
                    mtd->erasesize = block_base * (1 << erase_bits);
                    /* Calc oobsize, bit2,bit3,bit6: oob size */
                    bit236 = (id4th >> 2) & BIT01; /* get bit2,bit3 */
                    bit236 |= (id4th >> 4) & BIT(2); /* get bit6 and combine them */
                    switch (bit236) {
                    case 0x01:
                        mtd->oobsize = 128;
                        break;
                    case 0x02:
                        mtd->oobsize = 218;
                        break;
                    default:
                        /* others reserved */
                        break;
                    }
                }
                else {
                    /*
                     * Samsang
                     * follow algorithm accordding to datasheets of:
                     * K9GAG08U0M (50nm)
                     * this algorithm is suitable for old 50nm chip
                     */

                    goto slc_algorithm;
                }
            }
            else if (NAND_MFR_TOSHIBA == *maf_id) {
                /*
                 * Toshiba
                 * follow algorithm guess from ID of TC58NVG3D1DTG00:
                 * Toshiba MLC TC58NVG3D1DTG00 1GB 8bit 1chip
                 * 4K+218 512K+27K 3.3V, (ID:98 D3 94 BA 64 13 42)
                 */
                int bit23;

                /* Calc pagesize, bit0,bit1: page size */
                page_base = (1 << 10);  /* 1KB */
                mtd->writesize = page_base * (1 << (id4th & BIT01));
                block_base = (1 << 16); /* 64 KB */
                /* Calc block size, bit4,bit5: block size */
                erase_bits = (id4th >> 4) & BIT01; /* get bit4,bit5 */
                mtd->erasesize = block_base * (1 << erase_bits);
                /* Calc oobsize, use spare/redundant area bit */
                bit23 = (id4th >> 2) & BIT01; /* get bit2,bit3 */
                switch (bit23) {
                case 0x01:
                    mtd->oobsize = 128;
                    break;
                case 0x02:
                    mtd->oobsize = 218;
                    break;
                default:
                    /* others reserved */
                    break;
                }
                /* Get buswidth information: x8 or x16 */
                busw = ((id4th >> 6) & BIT(0)) ? NAND_BUSWIDTH_16 : 0;
            }
            else if (NAND_MFR_MICRON == *maf_id) {
                /*
                 * Micron
                 * follow algorithm accordding to datasheets of:
                 * 29F32G08CBAAA
                 */
                int spare_area_size_bit;

                /* Calc pagesize, bit0,bit1: page size */
                page_base = (1 << 10);  /* 1KB */
                mtd->writesize = page_base * (1 << (id4th & 0x03));
                block_base = (1 << 16); /* 64 KB */
                /* Calc block size, bit4,bit5: block size */
                erase_bits = (id4th >> 4) & BIT01; /* get bit4,bit5 */
                mtd->erasesize = block_base * (1 << erase_bits);
                /* Calc oobsize, use spare/redundant area bit */
                spare_area_size_bit = (id4th >> 2) & BIT(0);
                if (spare_area_size_bit) /* special oob */
                    mtd->oobsize = 218;
                else /* normal */
                    mtd->oobsize = mtd->writesize / NAND_PAGE_OOB_RATIO;
                /* Get buswidth information: x8 or x16 */
                busw = ((id4th >> 6) & BIT(0)) ? NAND_BUSWIDTH_16 : 0;
            }
            else {
                /*
                 * Others
                 * FIXME: update follow algrithm,
                 * according to different manufacture's chip's datasheet
                 */

                goto slc_algorithm;
            }       
        }
        else {
            /*
             * SLC, only has 4 bytes ID, further read will output periodically, such as:
             * Hynix : HY27UG084G2M, only has 4 byte ID,
             * following read ID is periodically same as the 1st ~ 4th byte,
             * for HY27UG084G2M is : 0xAD 0xDC 0x80 0x15 0xAD 0xDC 0x80 0x15 ..... 
            */
slc_algorithm:
            /* Calc pagesize, bit0,bit1: page size */
            page_base = (1 << 10);  /* 1KB */
            mtd->writesize = page_base * (1 << (id4th & BIT01));
            block_base = (1 << 16); /* 64 KB */
            /* Calc block size, bit4,bit5: block size */
            erase_bits = (id4th >> 4) & BIT01; /* get bit4,bit5 */
            mtd->erasesize = block_base * (1 << erase_bits);
            /* Calc oobsize, use fixed ratio */
            mtd->oobsize = mtd->writesize / NAND_PAGE_OOB_RATIO;
            /* Get buswidth information: x8 or x16 */
            busw = ((id4th >> 6) & BIT(0)) ? NAND_BUSWIDTH_16 : 0;
        }
    } else {
        /*
         * Old devices have chip data hardcoded in the device id table
         */
        mtd->erasesize = type->erasesize;
        mtd->writesize = type->pagesize;
        mtd->oobsize = mtd->writesize / NAND_PAGE_OOB_RATIO;
        busw = type->options & NAND_BUSWIDTH_16;
    }
    
    /*
    * 以上内容，主要是更加不同厂家的nand flash的datasheet，一点点总结出来的算法。
    * 最新的Linux的MTD部分，已经添加了类似如上部分的代码。此处贴出来，仅供参考。
    */
    
    /*
     * Check, if buswidth is correct. Hardware drivers should set
     * chip correct !
     */
    if (busw != (chip->options & NAND_BUSWIDTH_16)) {
        printk(KERN_INFO "NAND device: Manufacturer ID:"
               " 0x%02x, Chip ID: 0x%02x (%s %s)\n", *maf_id,
               dev_id, nand_manuf_ids[maf_idx].name, mtd->name);
        printk(KERN_WARNING "NAND bus width %d instead %d bit\n",
               (chip->options & NAND_BUSWIDTH_16) ? 16 : 8,
               busw ? 16 : 8);
        return ERR_PTR(-EINVAL);
    }
... ...
}