S3C24XX NAND Driver, (c) 2004 Simtec Electronics
s3c2440-nand s3c2440-nand: Tacls=3, 30ns Twrph0=7 70ns, Twrph1=3 30ns
NAND device: Manufacturer ID: 0xec, Chip ID: 0xda (Samsung NAND 256MiB 3,3V 8-bit)
Scanning device for bad blocks
Bad eraseblock 256 at 0x02000000
Bad eraseblock 257 at 0x02020000
Bad eraseblock 319 at 0x027e0000
Bad eraseblock 606 at 0x04bc0000
Bad eraseblock 608 at 0x04c00000
Creating 4 MTD partitions on "NAND 256MiB 3,3V 8-bit":
0x00000000-0x00040000 : "bootloader"
0x00040000-0x00060000 : "params"
0x00060000-0x00260000 : "kernel"
0x00260000-0x10000000 : "root"

搜"S3C24XX NAND Driver"
　　S3c2410.c (drivers\mtd\nand)

s3c2410_nand_inithw
s3c2410_nand_init_chip
nand_scan  // drivers/mtd/nand/nand_base.c 根据nand_chip的底层操作函数识别NAND FLASH，构造mtd_info
    nand_scan_ident
        nand_set_defaults
            if (!chip->select_chip)
                chip->select_chip = nand_select_chip; // 默认值不适用

            if (chip->cmdfunc == NULL)
                chip->cmdfunc = nand_command;
                                    chip->cmd_ctrl(mtd, command, ctrl);
            if (!chip->read_byte)
                chip->read_byte = nand_read_byte;
                                    readb(chip->IO_ADDR_R);
            if (chip->waitfunc == NULL)
                chip->waitfunc = nand_wait;
                                    chip->dev_ready
        
        
        nand_get_flash_type
            chip->select_chip(mtd, 0);
            chip->cmdfunc(mtd, NAND_CMD_READID, 0x00, -1);
            *maf_id = chip->read_byte(mtd);
            dev_id = chip->read_byte(mtd);
    nand_scan_tail
            mtd->erase = nand_erase;
            mtd->read = nand_read;
            mtd->write = nand_write;
s3c2410_nand_add_partition
    add_mtd_partitions
        add_mtd_device
            list_for_each(this, &mtd_notifiers) { // 问. mtd_notifiers在哪设置
                                                  // 答. drivers/mtd/mtdchar.c,mtd_blkdev.c调用register_mtd_user
                struct mtd_notifier *not = list_entry(this, struct mtd_notifier, list);
                not->add(mtd);
                // mtd_notify_add  和 blktrans_notify_add
                先看字符设备的mtd_notify_add
                        class_device_create
                        class_device_create
                再看块设备的blktrans_notify_add
                    list_for_each(this, &blktrans_majors) { // 问. blktrans_majors在哪设置
                                                            // 答. drivers\mtd\mdblock.c或mtdblock_ro.c   register_mtd_blktrans
                        struct mtd_blktrans_ops *tr = list_entry(this, struct mtd_blktrans_ops, list);              
                        tr->add_mtd(tr, mtd);
                                mtdblock_add_mtd (drivers\mtd\mdblock.c)
                                    add_mtd_blktrans_dev
                                        alloc_disk
                                        gd->queue = tr->blkcore_priv->rq; // tr->blkcore_priv->rq = blk_init_queue(mtd_blktrans_request, &tr->blkcore_priv->queue_lock);
                                        add_disk            

/*
* drivers\mtd\nand\s3c2410.c
* drivers\mtd\nand\at91_nand.c
*/

#include <linux/module.h>
#include <linux/types.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/ioport.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/clk.h>

#include <linux/mtd/mtd.h>
#include <linux/mtd/nand.h>
#include <linux/mtd/nand_ecc.h>
#include <linux/mtd/partitions.h>

#include <asm/io.h>

#include <asm/arch/regs-nand.h>
#include <asm/arch/nand.h>

struct nand_chip *s3c_nand;
struct mtd_info *s3c_mtd;
struct clk *clk;
struct s3c_nand_regs{
    unsigned long nfconf;
    unsigned long nfcont;
    unsigned long nfcmd;
    unsigned long nfaddr;
    unsigned long nfdata;
    unsigned long nfeccd0;
    unsigned long nfeccd1;
    unsigned long nfeccd;
    unsigned long nfstat;
    unsigned long nfestat0;
    unsigned long nfestat1;
    unsigned long nfeecc0;
    unsigned long nfeecc1;
    unsigned long nfsecc;
    unsigned long nfsblk;
    unsigned long nfeblk;
};

static struct mtd_partition s3c_nand_parts[] = {
    [0] = {
        .name   = "bootloader",
        .size   = 0x00040000,
        .offset= 0,
    },
    [1] = {
        .name   = "params",
        .offset = MTDPART_OFS_APPEND,
        .size   = 0x00020000,
    },
    [2] = {
        .name   = "kernel",
        .offset = MTDPART_OFS_APPEND,
        .size   = 0x00200000,    
    },
    [3] = {
        .name   = "root",
        .offset = MTDPART_OFS_APPEND,
        .size   = MTDPART_SIZ_FULL,
    }

};

static volatile struct s3c_nand_regs *nand_regs;

static void s3c2440_select_chip(struct mtd_info *mtd, int chipnr )
{
    if(chipnr == -1 )
    {
        /* 取消选中 */
        nand_regs->nfcont |= (1<<1); 
    }
    else
    {
        /* 选中 NFCONT^1 设置为1 */
        nand_regs->nfcont &= ~(1<<1);
    }
}

static void s3c2440_nand_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
{

    if (cmd == NAND_CMD_NONE)
        return;

    if (ctrl & NAND_CLE)
    {
        /* 发命令 */
        nand_regs->nfcmd = cmd;
    }
    else
    {
        /* 发地址 */
        nand_regs->nfaddr = cmd;
    }
}

static int s3c2440_dev_ready(struct mtd_info *mtd)
{
    /*  */
    return (nand_regs->nfstat & (1<<0));
}

static int s3c_nand_init(void)
{
    /* 分配一个nand_chip结构体 */
    s3c_nand = kzalloc(sizeof(struct nand_chip), GFP_KERNEL);
    
    nand_regs = ioremap(0x4e000000,sizeof(struct s3c_nand_regs));
    
    clk = clk_get(NULL,"nand");
    clk_enable(clk);
    /* 设置 */
    s3c_nand->select_chip = s3c2440_select_chip;
    s3c_nand->cmd_ctrl = s3c2440_nand_cmd_ctrl;
    s3c_nand->IO_ADDR_R = (void *)&nand_regs->nfdata;
    s3c_nand->IO_ADDR_W = (void *)&nand_regs->nfdata;
    s3c_nand->dev_ready = s3c2440_dev_ready;
    s3c_nand->ecc.mode  = NAND_ECC_SOFT;

    /* 硬件相关的操作:根据nand Flash的手册设置时间参数 */
    /* HCLK = 100MHz */
    /* TACLS: 发出cle/ale之后多长时间才发出nWE信号 */
    /* TWRPHO： nWE的脉冲宽度 */
    nand_regs->nfconf = (1<<8);
    nand_regs->nfcont = 0x03;
    
    /* 使用：nand_scan */
    s3c_mtd = kzalloc( sizeof(struct mtd_info), GFP_KERNEL );
    s3c_mtd->owner = THIS_MODULE;
    s3c_mtd->priv = s3c_nand;
    nand_scan(s3c_mtd,1); /* 扫描识别 */

    /* add_mtd_partitions */
    add_mtd_partitions(s3c_mtd,s3c_nand_parts,4);
    
    //add_mtd_device(s3c_mtd);  //整个flash只有一个分区的话可以用这个
    return 0;
}

static void s3c_nand_exit(void)
{
    del_mtd_partitions(s3c_mtd);
    kfree(s3c_mtd);
    iounmap(nand_regs);
    kfree(s3c_nand);

}

module_init(s3c_nand_init);
module_exit(s3c_nand_exit);
MODULE_LICENSE("GPL");