2410上NAND的初始化及驱动流程

一 NAND设备及资源的定义和注册

我们通过MACHINE_START定义了smdk2410的machine_desc对象,这个对象里面有个init_machine的函数指针, 这里指向smdk_machine_init(), 我们的NAND设备就是在这个函数里注册到系统的.

void __init smdk_machine_init(void)

{

   ….

   s3c_device_nand.dev.platform_data = &smdk_nand_info;

   platform_add_device(smdk_devs, ARRAY_SIZE(smdk_devs));  //这里就把设备注册到系统里去了

   …

}

Static struct platform_device __initdata *smdk_devs[] =

{

   &s3c_device_nand,    //这样在上面的函数里我们的nand设备就注册好了.

   ...   

}

其他设备我们也可以在这里注册进系统.

struct platform_device s3c_device_nand =

{

   .name = “s3c2410-nand”,  /*名字很重要*/

   .id = -1,

   . num_resources = ARRAY_SIZE(s3c_nand_resource),

   .resource = s3c_nand_resource,  //这个是NAND占用的资源.

};

Static struct s3c2410_platform_nand smdk_nand_info = {

     .tacks = 20,      /*在datasheet上有描述*/

     .twrph0 = 60,    /*在datasheet上有描述*/

     .twrph1 = 20,    /*在datasheet上有描述*/

     .nr_sets = ARRAY_SIZE(smdk_nand_sets),

     .sets = smdk_nand_sets 

}

static struct s3c2410_nand_set smdk_nand_sets[] = {

    [0] = {

        .name       = "NAND",

        .nr_chips   = 1,

        .nr_partitions  = ARRAY_SIZE(smdk_default_nand_part),

        .partitions = smdk_default_nand_part,   /*nand的分区信息*/

    },

};

/*分区信息, 我们可以在这里修改分区内容*/

static struct mtd_partition smdk_default_nand_part[] = {

    [0] = {

        .name   = "Boot Agent",

        .size   = SZ_16K,

        .offset = 0,

    },

    [1] = {

        .name   = "S3C2410 flash partition 1",

        .offset = 0,

        .size   = SZ_2M,

    },

    [2] = {

        .name   = "S3C2410 flash partition 2",

        .offset = SZ_4M,

        .size   = SZ_4M,

    },

    [3] = {

        .name   = "S3C2410 flash partition 3",

        .offset = SZ_8M,

        .size   = SZ_2M,

    },

    [4] = {

        .name   = "S3C2410 flash partition 4",

        .offset = SZ_1M * 10,

        .size   = SZ_4M,

    },

    [5] = {

        .name   = "S3C2410 flash partition 5",

        .offset = SZ_1M * 14,

        .size   = SZ_1M * 10,

    },

    [6] = {

        .name   = "S3C2410 flash partition 6",

        .offset = SZ_1M * 24,

        .size   = SZ_1M * 24,

    },

    [7] = {

        .name   = "S3C2410 flash partition 7",

        .offset = SZ_1M * 48,

        .size   = SZ_16M,

    }

};

这样NAND设备(连同设备的详细信息)就注册进了系统, 以后在nand的驱动注册后就会probe到并使用这里定义的资源信息.

 

二 NAND驱动流程

   2410的驱动实现在driver/mtd/nand/S3c2410.c里

   首先和其他驱动一样先通过module_init(), module_exit()注册一个初始化/卸载函数,

module_init(s3c2410_nand_init);

module_exit(s3c2410_nand_exit);

系统初始化时该函数被调用

 static int __init s3c2410_nand_init(void)

{

    printk("S3C24XX NAND Driver, (c) 2004 Simtec Electronics/n");

 

    platform_driver_register(&s3c2412_nand_driver);  /*注册nand驱动*/

    platform_driver_register(&s3c2440_nand_driver);  /*注册nand驱动*/

    return platform_driver_register(&s3c2410_nand_driver);  /*注册nand驱动*/

}

从上面可以看到我们注册了3个驱动程序, 但在系统probe时它只会匹配到s3c2410_nand_driver的驱动, 因为各个驱动的名字是不一样的, 而系统是安名字来probe的.

static struct platform_driver s3c2410_nand_driver = {

    .probe      = s3c2410_nand_probe,

    .remove     = s3c2410_nand_remove,

    .suspend    = s3c24xx_nand_suspend,

    .resume     = s3c24xx_nand_resume,

    .driver     = {

        .name   = "s3c2410-nand",  /*这里的名字一定要与设备定义的名字相同*/

        .owner  = THIS_MODULE,

    },

};

当系统probe到我们刚才注册的nand设备后即调用s3c2410_nand_probe函数

static int s3c2410_nand_probe(struct platform_device *dev)

{

    return s3c24xx_nand_probe(dev, TYPE_S3C2410);

}

static int s3c24xx_nand_probe(struct platform_device *pdev, /*nand设备,前面已经列出*/

                              enum s3c_cpu_type cpu_type /*TYPE_S3C2410*/)

{

    struct s3c2410_platform_nand *plat = to_nand_plat(pdev);/*对照前面列出的设备定义来看*/

    struct s3c2410_nand_info *info;

    struct s3c2410_nand_mtd *nmtd;

    struct s3c2410_nand_set *sets;

    struct resource *res;

    int err = 0;

    int size;

    int nr_sets;

    int setno;

 

    pr_debug("s3c2410_nand_probe(%p)/n", pdev);

 

/*该变量用来保存nand详细信息,以后访问nand信息都将从这个变量里得到*/

    info = kmalloc(sizeof(*info), GFP_KERNEL);

if (info == NULL) {

        dev_err(&pdev->dev, "no memory for flash info/n");

        err = -ENOMEM;

        goto exit_error;

    }

 

    memzero(info, sizeof(*info));

    platform_set_drvdata(pdev, info);

 

    spin_lock_init(&info->controller.lock);  /*自选锁初始化*/

    init_waitqueue_head(&info->controller.wq);  /*等待队列初始化*/

 

    /* get the clock source and enable it */

    info->clk = clk_get(&pdev->dev, "nand");  /*获取用于nand的clock(nand也要时钟信号的哦)*/

    if (IS_ERR(info->clk)) {

        dev_err(&pdev->dev, "failed to get clock");

        err = -ENOENT;

        goto exit_error;

    }

 

    clk_enable(info->clk); /*使能该clock,实际上就是设置CLKCON的第四位(详见2410datasheet)*/

 

    /* allocate and map the resource */

    /* currently we assume we have the one resource */

    res  = pdev->resource;  /*nand资源,见前面的定义*/

    size = res->end - res->start + 1;

 

     /*

* 请求指定的memory区域(实际上是nand的寄存器区域), 这是物理内存, 实际上只是检测该区域

* 是否空闲的

*/

    info->area = request_mem_region(res->start, size, pdev->name);

 

    if (info->area == NULL) {

        dev_err(&pdev->dev, "cannot reserve register region/n");

        err = -ENOENT;

        goto exit_error;

    }

 

    /*保存nand信息*/

    info->device     = &pdev->dev;

    info->platform   = plat;

/*虚实地址映射,以后程序里就可以直接访问nand的寄存器了*/

    info->regs       = ioremap(res->start, size); 

    info->cpu_type   = cpu_type;

 

    if (info->regs == NULL) {

        dev_err(&pdev->dev, "cannot reserve register region/n");

        err = -EIO;

        goto exit_error;

    }

 

    dev_dbg(&pdev->dev, "mapped registers at %p/n", info->regs);

 

    /* initialise the hardware */

 

    err = s3c2410_nand_inithw(info, pdev);  /*初始化nand硬件设备*/

    if (err != 0)

        goto exit_error;

 

    /*接下来是MTD方面的初始化*/

    sets = (plat != NULL) ? plat->sets : NULL;

    nr_sets = (plat != NULL) ? plat->nr_sets : 1;

 

    info->mtd_count = nr_sets;

 

    /* allocate our information */

    size = nr_sets * sizeof(*info->mtds);

    info->mtds = kmalloc(size, GFP_KERNEL);

    if (info->mtds == NULL) {

        dev_err(&pdev->dev, "failed to allocate mtd storage/n");

        err = -ENOMEM;

        goto exit_error;

    }

 

    memzero(info->mtds, size);

 

    /* initialise all possible chips */

 

    nmtd = info->mtds;

 

    for (setno = 0; setno < nr_sets; setno++, nmtd++) {

        pr_debug("initialising set %d (%p, info %p)/n", setno, nmtd, info);

        

         /*初始化nand chip实例*/

        s3c2410_nand_init_chip(info, nmtd, sets);

       

        /*初始化mtd及相关信息,详情可参考MTD的源码*/

        nmtd->scan_res = nand_scan(&nmtd->mtd, (sets) ? sets->nr_chips : 1) ;

 

        if (nmtd->scan_res == 0) {

            s3c2410_nand_add_partition(info, nmtd, sets);  /*添加分区,详情参看MTD*/

        }

 

        if (sets != NULL)

            sets++;

    }

 

    if (allow_clk_stop(info)) {

        dev_info(&pdev->dev, "clock idle support enabled/n");

        clk_disable(info->clk);

    }

 

    pr_debug("initialised ok/n");

    return 0;

 

 exit_error:

    s3c2410_nand_remove(pdev);

 

    if (err == 0)

        err = -EINVAL;

    return err;

}

这个函数是最关键的, 要要给nand设备进行很多初始化的工作,并保存nand的所有详细信息,便于以后使用, 详细功能已在函数里描述了. clock方面的内容会有专门的文章讲解

/* nand控制器的初始化 */

static int s3c2410_nand_inithw(struct s3c2410_nand_info *info,

                   struct platform_device *pdev)

{

    struct s3c2410_platform_nand *plat = to_nand_plat(pdev);

    unsigned long clkrate = clk_get_rate(info->clk); /*nand时钟主频*/

    int tacls_max = (info->cpu_type == TYPE_S3C2412) ? 8 : 4;

    int tacls, twrph0, twrph1;

    unsigned long cfg = 0;

 

    /* calculate the timing information for the controller */

 

    clkrate /= 1000;   /* turn clock into kHz for ease of use */

 

    /*计算各时钟频率, 这些时钟参数可参考2410的datasheet*/

    if (plat != NULL) {

        tacls = s3c_nand_calc_rate(plat->tacls, clkrate, tacls_max);

        twrph0 = s3c_nand_calc_rate(plat->twrph0, clkrate, 8);

        twrph1 = s3c_nand_calc_rate(plat->twrph1, clkrate, 8);

    } else {

        /* default timings */

        tacls = tacls_max;

        twrph0 = 8;

        twrph1 = 8;

    }

 

    if (tacls < 0 || twrph0 < 0 || twrph1 < 0) {

        dev_err(info->device, "cannot get suitable timings/n");

        return -EINVAL;

    }

 

    dev_info(info->device, "Tacls=%d, %dns Twrph0=%d %dns, Twrph1=%d %dns/n",

           tacls, to_ns(tacls, clkrate), twrph0, to_ns(twrph0, clkrate), twrph1, to_ns(twrph1, clkrate));

 

    switch (info->cpu_type) {

    case TYPE_S3C2410:

        cfg = S3C2410_NFCONF_EN;  /*使能*/

        cfg |= S3C2410_NFCONF_TACLS(tacls - 1);

        cfg |= S3C2410_NFCONF_TWRPH0(twrph0 - 1);

        cfg |= S3C2410_NFCONF_TWRPH1(twrph1 - 1);

        break;

 

    case TYPE_S3C2440:

    case TYPE_S3C2412:

        cfg = S3C2440_NFCONF_TACLS(tacls - 1);

        cfg |= S3C2440_NFCONF_TWRPH0(twrph0 - 1);

        cfg |= S3C2440_NFCONF_TWRPH1(twrph1 - 1);

 

        /* enable the controller and de-assert nFCE */

 

        writel(S3C2440_NFCONT_ENABLE, info->regs + S3C2440_NFCONT);

    }

 

    dev_dbg(info->device, "NF_CONF is 0x%lx/n", cfg);

 

    /*把使能参数,时钟参数设到寄存器NFCONF里*/

    writel(cfg, info->regs + S3C2410_NFCONF);  

    return 0;

}

/*

* 为每个nand chip初始化一个实例.

* 比较简单,就是初始化各种参数和函数指针,以后会用到

*/

static void s3c2410_nand_init_chip(struct s3c2410_nand_info *info,

                   struct s3c2410_nand_mtd *nmtd,

                   struct s3c2410_nand_set *set)

{

    struct nand_chip *chip = &nmtd->chip;

    void __iomem *regs = info->regs;

   

    chip->write_buf    = s3c2410_nand_write_buf;

    chip->read_buf     = s3c2410_nand_read_buf;

    chip->select_chip  = s3c2410_nand_select_chip;

    chip->chip_delay   = 50;

    chip->priv     = nmtd;

    chip->options      = 0;

    chip->controller   = &info->controller;

 

    switch (info->cpu_type) {

    case TYPE_S3C2410:

        chip->IO_ADDR_W = regs + S3C2410_NFDATA;

        info->sel_reg   = regs + S3C2410_NFCONF;

        info->sel_bit   = S3C2410_NFCONF_nFCE;

        chip->cmd_ctrl  = s3c2410_nand_hwcontrol;

        chip->dev_ready = s3c2410_nand_devready;

        break;

 

    case TYPE_S3C2440:

        chip->IO_ADDR_W = regs + S3C2440_NFDATA;

        info->sel_reg   = regs + S3C2440_NFCONT;

        info->sel_bit   = S3C2440_NFCONT_nFCE;

        chip->cmd_ctrl  = s3c2440_nand_hwcontrol;

        chip->dev_ready = s3c2440_nand_devready;

        break;

 

    case TYPE_S3C2412:

        chip->IO_ADDR_W = regs + S3C2440_NFDATA;

        info->sel_reg   = regs + S3C2440_NFCONT;

        info->sel_bit   = S3C2412_NFCONT_nFCE0;

        chip->cmd_ctrl  = s3c2440_nand_hwcontrol;

        chip->dev_ready = s3c2412_nand_devready;

 

        if (readl(regs + S3C2410_NFCONF) & S3C2412_NFCONF_NANDBOOT)

            dev_info(info->device, "System booted from NAND/n");

 

        break;

    }

 

    chip->IO_ADDR_R = chip->IO_ADDR_W;

 

    nmtd->info     = info;

    nmtd->mtd.priv     = chip;

    nmtd->mtd.owner    = THIS_MODULE;

    nmtd->set      = set;

 

    if (hardware_ecc) {

        chip->ecc.calculate = s3c2410_nand_calculate_ecc;

        chip->ecc.correct   = s3c2410_nand_correct_data;

        chip->ecc.mode      = NAND_ECC_HW;

        chip->ecc.size      = 512;

        chip->ecc.bytes     = 3;

        chip->ecc.layout    = &nand_hw_eccoob;

 

        switch (info->cpu_type) {

        case TYPE_S3C2410:

            chip->ecc.hwctl     = s3c2410_nand_enable_hwecc;

            chip->ecc.calculate = s3c2410_nand_calculate_ecc;

            break;

 

        case TYPE_S3C2412:

        case TYPE_S3C2440:

            chip->ecc.hwctl     = s3c2440_nand_enable_hwecc;

            chip->ecc.calculate = s3c2440_nand_calculate_ecc;

            break;

 

        }

    } else {

        chip->ecc.mode      = NAND_ECC_SOFT;

    }

}

Nand驱动剩下的就是实现上面这个函数里初始化的各个函数指针了.而这些函数就是实实在在的对nand硬件的操作了, 大家可以对照着2410的nand部分的datasheet来看这些代码