u-boot中添加mtdparts支持以及Linux的分区设置

简介

作者：彭东林

邮箱：pengdonglin137@163.com

 

u-boot版本：u-boot-2015.04

Linux版本：Linux-3.14

硬件平台：tq2440， 内存：64M   NandFlash: 256MB

 

下面我们分两部分，u-boot和kernel，首先介绍u-boot中是如何支持mtdparts的，然后简单分析Linux内核设置分区的两种方式：

方式一

    在平台代码中写死，然后在初始化NandFlash的时候设置。

方式二

    在u-boot中设置，这个比较灵活，u-boot将分区信息（形如：mtdparts=xxx）添加到bootargs中，kernel在启动的时候会解析mtdparts。

u-boot中支持mtdparts命令

转载自：http://w3sun.blog.163.com/blog/static/1859535342012058369333/

分区方法

     1)MTD层的分区

     2)通过U-boot传递给内核的命令行中的mtdparts=...

     3)其他可以让内核知道分区信息的任何办法，（内核默认的命令参数）

下面说到mtdparts，及它的用法：

   mtdparts

   mtdparts=fc000000.nor_flash:1920k(linux),128k(fdt),20M(ramdisk),4M(jffs2),38272k(user),256k(env),384k(uboot)要想这个参数起作用，

内核中的mtd驱动必须要支持，即内核配置时需要选上

       Device Drivers  --->

            Memory Technology Device (MTD) support  --->

                Command line partition table parsing

mtdparts的格式如下：

    mtdparts=<mtddef>[;<mtddef]

    <mtddef>  := <mtd-id>:<partdef>[,<partdef>]

    <partdef> := <size>[@offset][<name>][ro]

    <mtd-id>  := unique id used in mapping driver/device

    <size>    := standard linux memsize OR "-" to denote all remaining space

    <name>    := (NAME)

因此你在使用的时候需要按照下面的格式来设置：

     mtdparts=mtd-id:<size1>@<offset1>(<name1>),<size2>@<offset2>(<name2>)

这有几个需要注意的地方：

      a.mtd-id 必须要跟你当前平台的flash的mtd-id一致，不然整个mtdparts会失效 怎样获取到当前平台的flash的mtd-id？在bootargs参数列表中，可以指定当前flash的mtd-id，指定 mtdid

s:nand0=gen_nand.1，前面的nand0则表示第一个flash

      b.size在设置的时候可以为实际的size(xxM,xxk,xx)，也可以为'-'这表示剩余的所有空间。相

关信息可以查看drivers/mtd/cmdlinepart.c中的注释找到相关描述。

       U-boot环境变量有两个，他们分别是： bootcmd 和bootargs。

至于在我们自己的at91sam9263ek板子上为了实现mtdparts分区命令的支持需要在U-boot

-2010.06/include/configs/at91sam9263ek.h中添加相关的宏定义：

#define CONFIG_CMD_MTDPARTS

#define CONFIG_MTD_DEVICE

#define CONFIG_MTD_PARTITIONS

加入MTD分区信息：

#define MTDIDS_DEFAULT "nand0=atmel_nand"

#define MTDPARTS_DEFAULT            "mtdparts=atmel_nand:15M@0(cramfs)," \

                                    "15M(jffs2)," \

                                    "30M(yaffs2)," \

                                    "-(user)"

保存后退出，回到根目录，重新make

[root@localhost u-boot-2010.06]#make at91sam9263ek_dataflash_cs0_config

[root@localhost u-boot-2010.06]#make all

将重新编译的u-boot.bin烧到dataflash中，使用mtdparts查看分区：

U-Boot> mtdparts

device nand0 <atmel_nand>, # parts = 4

#: name               size           offset         mask_flags

0: cramfs             0x00f00000     0x00000000     0

1: jffs2              0x00f00000     0x00f00000     0

2: yaffs2             0x01e00000     0x01e00000     0

3: user               0x04400000     0x03c00000     0

active partition: nand0,0 - (cramfs) 0x00f00000 @ 0x00000000

defaults:

mtdids : nand0=atmel_nand

mtdparts: mtdparts=atmel_nand:15M@0(cramfs),15M(jffs2),30M(yaffs2),-(user)

        重新设置分区：

U-Boot> setenv mtdparts mtdparts=atmel_nand:30M@0(a),30M(b),-(c)

U-Boot> save

Saving Environment to dataflash...

U-Boot> mtdparts

device nand0 <atmel_nand>, # parts = 3

#: name               size           offset         mask_flags

0: a                  0x01e00000     0x00000000     0

1: b                  0x01e00000     0x01e00000     0

2: c                  0x04400000     0x03c00000     0

active partition: nand0,0 - (a) 0x01e00000 @ 0x00000000

defaults:

mtdids : nand0=atmel_nand

mtdparts: mtdparts=atmel_nand:15M@0(cramfs),15M(jffs2),30M(yaffs2),-(user)

        可以看到，我们可以手动设置分区了。最后还要恢复默认。

U-Boot>mtdparts default

 

Kernel中设置分区

相关的内核代码我已经上传到csdn上了，使用git管理，分支是transplant_to_tq2440

git clone git@code.csdn.net:pengdonglin137/linux-3-14-y.git

在此之前我们先看看NandFlash是如何初始化的。

这里采用platform_device和platform_driver架构。

1. platform_device的注册

在arch/arm/mach-s3c24xx/mach-tq2440.c中:

static struct platform_device *tq2440_devices[] __initdata = {
                ......
    &s3c_device_nand,
};

static void __init tq2440_machine_init(void)
{
               ......
    s3c_nand_set_platdata(&tq2440_nand_info);
    platform_add_devices(tq2440_devices, ARRAY_SIZE(tq2440_devices));
                ......
}

MACHINE_START(TQ2440, "TQ2440")
                ........
    .init_machine    = tq2440_machine_init,
                ......
MACHINE_END

第5行是nand控制器的platform_device;

第10行platform_add_device会将s3c_device_nand注册到系统中;

第9行设置的就是分区相关的信息

/* NAND parititon */

static struct mtd_partition tq2440_nand_part[] = {
    [0] = {
        .name    = "Boot",
        .offset = 0,
        .size    = SZ_2M,
    },
    [1] = {
        .name    = "Kernel",
        .offset    = SZ_2M,
        .size    = SZ_1M * 3,
    },
    [2] = {
        .name    = "Rootfs",
        .offset = SZ_1M * 5,
        .size    = MTDPART_SIZ_FULL,
    }
};

static struct s3c2410_nand_set tq2440_nand_sets[] = {
    [0] = {
        .name        = "NAND",
        .nr_chips    = 1,
        .nr_partitions    = ARRAY_SIZE(tq2440_nand_part),
        .partitions    = tq2440_nand_part,
    },
};

/* choose a set of timings which should suit most 512Mbit
 * chips and beyond.
*/

static struct s3c2410_platform_nand tq2440_nand_info = {
    .tacls        = 10,
    .twrph0        = 25,
    .twrph1        = 10,
    .nr_sets    = ARRAY_SIZE(tq2440_nand_sets),
    .sets        = tq2440_nand_sets,
};

第3行的结构体tq2440_nand_part就是分区信息，容易看出，这里一共分了3个区，分别是Boot、Kernel和Rootfs:

Boot (2MB)

Kernel (3MB)

Rootfs (剩余)

然后将这个分区表存放到了第21行的tq2440_nand_set的元素[0]中，分区表的名字”NAND”，注意这里的名字很重要，将来u-boot中传入的mtdparts中的mtd-id一致。tq2440_nand_sets的每一个元素存放一张分区表；

第34行的结构体tq2440_nand_info中的tacls/twrph0/twrph1用于控制Nand控制器读写NandFlash时的时序参数。

s3c_device_nand是在文件arch/arm/plat-samsung/devs.c

/* NAND */

#ifdef CONFIG_S3C_DEV_NAND
static struct resource s3c_nand_resource[] = {
    [0] = DEFINE_RES_MEM(S3C_PA_NAND, SZ_1M),
};

struct platform_device s3c_device_nand = {
    .name        = "s3c2410-nand",
    .id        = -1,
    .num_resources    = ARRAY_SIZE(s3c_nand_resource),
    .resource    = s3c_nand_resource,
};

/*
 * s3c_nand_copy_set() - copy nand set data
 * @set: The new structure, directly copied from the old.
 *
 * Copy all the fields from the NAND set field from what is probably __initdata
 * to new kernel memory. The code returns 0 if the copy happened correctly or
 * an error code for the calling function to display.
 *
 * Note, we currently do not try and look to see if we've already copied the
 * data in a previous set.
 */
static int __init s3c_nand_copy_set(struct s3c2410_nand_set *set)
{
    void *ptr;
    int size;

    size = sizeof(struct mtd_partition) * set->nr_partitions;
    if (size) {
        ptr = kmemdup(set->partitions, size, GFP_KERNEL);
        set->partitions = ptr;

        if (!ptr)
            return -ENOMEM;
    }

    if (set->nr_map && set->nr_chips) {
        size = sizeof(int) * set->nr_chips;
        ptr = kmemdup(set->nr_map, size, GFP_KERNEL);
        set->nr_map = ptr;

        if (!ptr)
            return -ENOMEM;
    }

    if (set->ecc_layout) {
        ptr = kmemdup(set->ecc_layout,
                  sizeof(struct nand_ecclayout), GFP_KERNEL);
        set->ecc_layout = ptr;

        if (!ptr)
            return -ENOMEM;
    }

    return 0;
}

void __init s3c_nand_set_platdata(struct s3c2410_platform_nand *nand)
{
    struct s3c2410_platform_nand *npd;
    int size;
    int ret;

    /* note, if we get a failure in allocation, we simply drop out of the
     * function. If there is so little memory available at initialisation
     * time then there is little chance the system is going to run.
     */

    npd = s3c_set_platdata(nand, sizeof(struct s3c2410_platform_nand),
                &s3c_device_nand);
    if (!npd)
        return;

    /* now see if we need to copy any of the nand set data */

    size = sizeof(struct s3c2410_nand_set) * npd->nr_sets;
    if (size) {
        struct s3c2410_nand_set *from = npd->sets;
        struct s3c2410_nand_set *to;
        int i;

        to = kmemdup(from, size, GFP_KERNEL);
        npd->sets = to;    /* set, even if we failed */

        if (!to) {
            printk(KERN_ERR "%s: no memory for sets\n", __func__);
            return;
        }

        for (i = 0; i < npd->nr_sets; i++) {
            ret = s3c_nand_copy_set(to);
            if (ret) {
                printk(KERN_ERR "%s: failed to copy set %d\n",
                __func__, i);
                return;
            }
            to++;
        }
    }
}
#endif /* CONFIG_S3C_DEV_NAND */

第72行将nand(也就是tq2440_nand_info)的副本存放到s3c_device_nand的dev.platform_data中，然后将nand的副本首地址npd返回；

第79行到第100行将tq2440_nand_info的分区信息拷贝一份，赋值给npd的sets成员；

2. platform_driver的注册

文件：drivers/mtd/nand/s3c2410.c

/* driver device registration */

static struct platform_device_id s3c24xx_driver_ids[] = {
    {
        .name        = "s3c2410-nand",
        .driver_data    = TYPE_S3C2410,
    }, {
        .name        = "s3c2440-nand",
        .driver_data    = TYPE_S3C2440,
    }, {
        .name        = "s3c2412-nand",
        .driver_data    = TYPE_S3C2412,
    }, {
        .name        = "s3c6400-nand",
        .driver_data    = TYPE_S3C2412, /* compatible with 2412 */
    },
    { }
};

MODULE_DEVICE_TABLE(platform, s3c24xx_driver_ids);

static struct platform_driver s3c24xx_nand_driver = {
    .probe        = s3c24xx_nand_probe,
    .remove        = s3c24xx_nand_remove,
    .suspend    = s3c24xx_nand_suspend,
    .resume        = s3c24xx_nand_resume,
    .id_table    = s3c24xx_driver_ids,
    .driver        = {
        .name    = "s3c24xx-nand",
        .owner    = THIS_MODULE,
    },
};

module_platform_driver(s3c24xx_nand_driver);

当注册s3c24xx_nand_driver的时候，由于s3c24xx_driver_ids中的”s3c2410-nand”与s3c_device_nand的name一致，因此函数s3c24xx_nand_probe被执行。

下面我们简要分析函数s3c24xx_nand_probe的实现：

/* s3c24xx_nand_probe
 *
 * called by device layer when it finds a device matching
 * one our driver can handled. This code checks to see if
 * it can allocate all necessary resources then calls the
 * nand layer to look for devices
*/
static int s3c24xx_nand_probe(struct platform_device *pdev)
{
    struct s3c2410_platform_nand *plat = to_nand_plat(pdev);
    enum s3c_cpu_type cpu_type;
    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;

    cpu_type = platform_get_device_id(pdev)->driver_data;

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

    info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
    if (info == NULL) {
        err = -ENOMEM;
        goto exit_error;
    }

    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 = devm_clk_get(&pdev->dev, "nand");
    if (IS_ERR(info->clk)) {
        dev_err(&pdev->dev, "failed to get clock\n");
        err = -ENOENT;
        goto exit_error;
    }

    s3c2410_nand_clk_set_state(info, CLOCK_ENABLE);

    /* allocate and map the resource */

    /* currently we assume we have the one resource */
    res = pdev->resource;
    size = resource_size(res);

    info->device    = &pdev->dev;
    info->platform    = plat;
    info->cpu_type    = cpu_type;

    info->regs = devm_ioremap_resource(&pdev->dev, res);
    if (IS_ERR(info->regs)) {
        err = PTR_ERR(info->regs);
        goto exit_error;
    }

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

    /* initialise the hardware */

    err = s3c2410_nand_inithw(info);
    if (err != 0)
        goto exit_error;

    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 = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
    if (info->mtds == NULL) {
        err = -ENOMEM;
        goto exit_error;
    }

    /* 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);

        s3c2410_nand_init_chip(info, nmtd, sets);

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

        if (nmtd->scan_res == 0) {
            s3c2410_nand_update_chip(info, nmtd);
            nand_scan_tail(&nmtd->mtd);
            s3c2410_nand_add_partition(info, nmtd, sets);
        }

        if (sets != NULL)
            sets++;
    }

    err = s3c2410_nand_cpufreq_register(info);
    if (err < 0) {
        dev_err(&pdev->dev, "failed to init cpufreq support\n");
        goto exit_error;
    }

    if (allow_clk_suspend(info)) {
        dev_info(&pdev->dev, "clock idle support enabled\n");
        s3c2410_nand_clk_set_state(info, CLOCK_SUSPEND);
    }

    pr_debug("initialised ok\n");
    return 0;

 exit_error:
    s3c24xx_nand_remove(pdev);

    if (err == 0)
        err = -EINVAL;
    return err;
}

第10行，获得tq2440_nand_info,其实是它的副本；

第21行，cpu_type是TYPE_S3C2410；

第38行，获得nand控制器的时钟；

第45行，使能nand控制器的时钟；

第67行，初始化nand控制器；

第72行，nr_sets的值是1；

第93行，根据cpu_type的设置初始化一些函数指针，如读函数、写函数以及片选函数；

第95行，读取NandFlash的ID，以及容量、规格（如pagesize），成功返回0；

第100行，设置一些关于ecc的信息；

第101行，设置一些关于oob读写的信息；

下面重点分析第102行的函数：s3c2410_nand_add_partition

static int s3c2410_nand_add_partition(struct s3c2410_nand_info *info,
                      struct s3c2410_nand_mtd *mtd,
                      struct s3c2410_nand_set *set)
{
    if (set) {
        mtd->mtd.name = set->name;

        return mtd_device_parse_register(&mtd->mtd, NULL, NULL,
                     set->partitions, set->nr_partitions);
    }

    return -ENODEV;
}

第6行的set->name就是”Nand”

第9行的set->partitions中存放的是分区表，set->nr_partitions存放的是这个分区表的包含的分区个数

int mtd_device_parse_register(struct mtd_info *mtd, const char * const *types,
                  struct mtd_part_parser_data *parser_data,
                  const struct mtd_partition *parts,
                  int nr_parts)
{
    int err;
    struct mtd_partition *real_parts;

    err = parse_mtd_partitions(mtd, types, &real_parts, parser_data);
    if (err <= 0 && nr_parts && parts) {
        real_parts = kmemdup(parts, sizeof(*parts) * nr_parts,
                     GFP_KERNEL);
        if (!real_parts)
            err = -ENOMEM;
        else
            err = nr_parts;
    }

    if (err > 0) {
        err = add_mtd_partitions(mtd, real_parts, err);
        kfree(real_parts);
    } else if (err == 0) {
        err = add_mtd_device(mtd);
        if (err == 1)
            err = -ENODEV;
    }

    return err;
}

第9行，parse_mtd_partitions用于解析命令行中设置的分区，如果命令行中没有设置mtdparts，那么返回0，如果设置了，并且解析没问题，那么返回大于零的数（也就是解析到的分区的个数），否则返回小于零的数。  

如果没有设置mtdparts或者解析失败，那么real_parts就来自代码中写好的分区。然后，调用add_mtd_partitions添加分区。

下面我们看一下parse_mtd_partitions的实现：

int parse_mtd_partitions(struct mtd_info *master, const char *const *types,
             struct mtd_partition **pparts,
             struct mtd_part_parser_data *data)
{
    struct mtd_part_parser *parser;
    int ret = 0;

    if (!types)
        types = default_mtd_part_types;

    for ( ; ret <= 0 && *types; types++) {
        parser = get_partition_parser(*types);
        if (!parser && !request_module("%s", *types))
            parser = get_partition_parser(*types);
        if (!parser)
            continue;
        ret = (*parser->parse_fn)(master, pparts, data);
        put_partition_parser(parser);
        if (ret > 0) {
            printk(KERN_NOTICE "%d %s partitions found on MTD device %s\n",
                   ret, parser->name, master->name);
            break;
        }
    }
    return ret;
}

传入参数types是NULL，所以types赋值为default_mtd_part_types，即

static const char * const default_mtd_part_types[] = {
    "cmdlinepart",
    "ofpart",
    NULL
};

然后将”cmdlinepart”传递给函数get_partition_parser，这个函数返回名为”cmdlinepart”的解析器，然后在第17行调用这个解析器的解析函数，给pparts赋值，并返回分区个数。get_partition_parser的实现很简单：

static struct mtd_part_parser *get_partition_parser(const char *name)
{
    struct mtd_part_parser *p, *ret = NULL;

    spin_lock(&part_parser_lock);

    list_for_each_entry(p, &part_parsers, list)
        if (!strcmp(p->name, name) && try_module_get(p->owner)) {
            ret = p;
            break;
        }

    spin_unlock(&part_parser_lock);

    return ret;
}

第7行遍历part_parsers，所有的解析器都存放在链表part_parsers中，然后比较解析器的name。那么接下来就需要看part_parsers的成员的来源。

名为”cmdlinepart”的解析器是在文件drivers/mtd/cmdlinepart.c中注册的，需要配置内核，将这个文件编译进内核。

Device Drivers  --->

    <*> Memory Technology Device (MTD) support  --->

       <*>   Command line partition table parsing

假设u-boot传入的bootargs的值是：

noinitrd root=/dev/mtdblock3 rootfstype=yaffs2  init=/linuxrc console=ttySAC0,115200n mtdparts=tq2440-0:1m@0(spl)ro,1m(u-boot)ro,3m(kernel)ro,-(rootfs)

其中，根据经验，内核中一定会有类似 __setup(“mtdparts=”, xxx)的结果，其实就在文件cmdlinepart.c中：

static int __init mtdpart_setup(char *s)
{
    cmdline = s;
    return 1;
}

__setup("mtdparts=", mtdpart_setup);

所以当遇到“mtdparts=tq2440-0:1m@0(spl)ro,1m(u-boot)ro,3m(kernel)ro,-(rootfs)”时，函数mtdpart_setup就会被调用，并将mtdparts的值作为参数，所以cmdline就指向”tq2440-0:1m@0(spl)ro,1m(u-boot)ro,3m(kernel)ro,-(rootfs)”.

下面是解析器的注册：

static struct mtd_part_parser cmdline_parser = {
    .owner = THIS_MODULE,
    .parse_fn = parse_cmdline_partitions,
    .name = "cmdlinepart",
};

static int __init cmdline_parser_init(void)
{
    if (mtdparts)
        mtdpart_setup(mtdparts);
    register_mtd_parser(&cmdline_parser);
    return 0;
}

module_init(cmdline_parser_init);

第11行调用了注册函数

第3行就是解析器的解析函数，他负责解析cmdline，并给pparts赋值。

static int parse_cmdline_partitions(struct mtd_info *master,
                    struct mtd_partition **pparts,
                    struct mtd_part_parser_data *data)
{
    unsigned long long offset;
    int i, err;
    struct cmdline_mtd_partition *part;
    const char *mtd_id = master->name;

    /* parse command line */
    if (!cmdline_parsed) {
        err = mtdpart_setup_real(cmdline);
        if (err)
            return err;
    }

    /*
     * Search for the partition definition matching master->name.
     * If master->name is not set, stop at first partition definition.
     */
    for (part = partitions; part; part = part->next) {
        if ((!mtd_id) || (!strcmp(part->mtd_id, mtd_id)))
            break;
    }

    if (!part)
        return 0;

    for (i = 0, offset = 0; i < part->num_parts; i++) {
        if (part->parts[i].offset == OFFSET_CONTINUOUS)
            part->parts[i].offset = offset;
        else
            offset = part->parts[i].offset;

        if (part->parts[i].size == SIZE_REMAINING)
            part->parts[i].size = master->size - offset;

        if (offset + part->parts[i].size > master->size) {
            printk(KERN_WARNING ERRP
                   "%s: partitioning exceeds flash size, truncating\n",
                   part->mtd_id);
            part->parts[i].size = master->size - offset;
        }
        offset += part->parts[i].size;

        if (part->parts[i].size == 0) {
            printk(KERN_WARNING ERRP
                   "%s: skipping zero sized partition\n",
                   part->mtd_id);
            part->num_parts--;
            memmove(&part->parts[i], &part->parts[i + 1],
                sizeof(*part->parts) * (part->num_parts - i));
            i--;
        }
    }

    *pparts = kmemdup(part->parts, sizeof(*part->parts) * part->num_parts,
              GFP_KERNEL);
    if (!*pparts)
        return -ENOMEM;

    return part->num_parts;
}

第8行，将master->name的值赋值给mtd_id，根据上面的代码可以知道，master->id就是”Nand”；

第12行，解析cmdline，并构造相关的结构体，解析出来的分区添加到链表partitions中，对于我们的例子：

tq2440-0:1m@0(spl)ro,1m(u-boot)ro,3m(kernel)ro,-(rootfs)

一共有4个分区：

分区表名字： tq2440-0

分区1：spl   0x0 --- 0x100000  只读

分区2：u-boot 0x100000 --- 0x200000 只读

分区3：kernel 0x200000 --- 0x500000 只读

分区4：rootfs 0x500000 --- 0x10000000

第21行到24行，比较从mtdparts中解析到的mtd_id与master->id，如果不相等，最终第26行的part就是NULL，返回零。否则，将解析到的分区表存放到pparts中，并返回分区个数。

解析完分区表后，紧接着就调用了函数add_mtd_partitions，这个函数完成了分区的设置。有兴趣可以分析一下这个函数的实现，他的参数real_parts可以来自mtdparts，也可以来自平台代码。

代码先分析到这里，接下来说一下如果要支持mtdparts，需要注意的一些问题：

1. 分区表的名字要一致

如，我们的例子是 mtdparts=tq2440-0:1m@0(spl)ro,1m(u-boot)ro,3m(kernel)ro,-(rootfs)，这里mtd_id的值是tq2440-0，那么在kernel的平台代码中也必须有一个名为tq2440-0的分区表，平台代码中的那张分区表可以为空，因为如果mtdparts中已经有了，就不会解析平台代码中设置的分区表，但是分区表的名字还是要匹配的。kernel中默认的分区表的名字是“Nand”：

static struct s3c2410_nand_set tq2440_nand_sets[] = {
    [0] = {
        .name        = "NAND",
        .nr_chips    = 1,
        .nr_partitions    = ARRAY_SIZE(tq2440_nand_part),
        .partitions    = tq2440_nand_part,
    },
};

所以， 为了保持一致，可以修改这里的name，改成如下所示：

static struct s3c2410_nand_set tq2440_nand_sets[] = {
    [0] = {
        .name        = "tq2440-0",
        .nr_chips    = 1,
        .nr_partitions    = ARRAY_SIZE(tq2440_nand_part),
        .partitions    = tq2440_nand_part,
    },
};

可以将mtdparts设置的值与平台代码汇总

2. mtdparts的设置

mtdparts=tq2440-0:1m@0(spl)ro,1m(u-boot)ro,3m(kernel)ro,-(rootfs)

等价于

mtdparts=tq2440-0:1m(spl)ro,1m(u-boot)ro,3m(kernel)ro,-(rootfs)

 

 

完。