qu'est-ce que Linux Mtd

Sous Linux, mtd fait référence à « périphérique technologique de mémoire » et est un sous-système du périphérique de stockage. Linux a introduit le système MTD pour fournir une interface unifiée pour les appareils NOR FLASH et NAND FLASH. Les périphériques MTD peuvent généralement être divisés en quatre couches : le nœud de périphérique, la couche de périphérique MTD, la couche de périphérique d'origine MTD et la couche de pilote matériel.

L'environnement d'exploitation de ce tutoriel : système linux5.9.8, ordinateur Dell G3.

Qu'est-ce que Linux MTD ?

MTD signifie « Memory Technology Device », qui signifie « périphérique de technologie de mémoire » et est un sous-système de périphériques de stockage Linux.

Dans le noyau Linux, la couche MTD est introduite pour fournir une interface unifiée pour les appareils NOR FLASH et NAND FLASH. MTD isole le système de fichiers de la mémoire FLASH sous-jacente.

Le but de la conception de ce système MTD est de fournir une couche d'abstraction et une interface pour les périphériques de mémoire, de sorte que les concepteurs de pilotes matériels n'aient qu'à fournir la lecture/écriture/effacement la plus simple des périphériques matériels sous-jacents. vous n'avez pas besoin de vous soucier de la façon dont les données sont représentées aux utilisateurs de couche supérieure, car le sous-système du périphérique de stockage MTD l'a fait pour vous.

MTD framework

Le périphérique MTD de Linux se trouve sous drivers/mtd/.

Le contenu du fichier MTD est le suivant :

Les appareils MTD peuvent généralement être divisés en quatre couches

De haut en bas : le nœud de périphérique, la couche de périphérique MTD, la couche de périphérique d'origine MTD et la couche de pilote matériel.

1.cmdlinepart.c

Lorsque la table de partition mtd est transmise à Linux par u-boot via le paramètre cmd, le noyau Linux n'a pas besoin d'enregistrer et d'ajouter mtdparts, et n'a besoin que de définir le option de partition en ligne de commande dans MTD Activez-la simplement. Pour utiliser cette méthode, u-boot doit prendre en charge MTD et les paramètres de partition mtd transmis doivent répondre aux exigences de format.

Dossier 2.devices

Lorsque nous avons un périphérique spi flash et que nous souhaitons utiliser mtd pour le gérer, nous le plaçons généralement dans le dossier devices, tel que m25p80.c sous le dossier devices est un exemple typique de spi flash appareil.

3.chips/nand/onenand dossier

le pilote flash nand se trouve sous le dossier nand

le pilote flash onenand se trouve sous le dossier onenand

nor flash est assez compliqué, et il se trouvera sous ce qui suit ; fichiers :

puces : pilote universel d'interface cfi/jedec

périphériques : ni pilote flash sous-jacent (spi flash)

cartes : ni fonctions liées aux relations de mappage flash

4. Fichier principal

mtdchar.c : caractère MTD. interface de périphérique Implémentation pertinente, numéro de périphérique 31 ;

mtdblock.c : implémentation liée à l'interface de périphérique de bloc MTD, numéro de périphérique 90, ; mise en œuvre.

5.ubi

La couche de support des fichiers ubifs. Lorsque vous utilisez le système de fichiers ubifs, vous devez sélectionner Activer UBI dans les pilotes de périphérique -> Prise en charge des périphériques de technologie de mémoire (MTD) -> Sélectionnez la prise en charge du système de fichiers UBIFS dans Systèmes de fichiers -> Systèmes de fichiers divers.

Implémentation de la table de partition MTD

Pendant le processus de démarrage, vous pouvez souvent voir des informations similaires aux suivantes depuis la console,

0x000000000000-0x000000100000 : "Bootloade"
0x000000100000-0x000002000000 : "Kernel"
0x000002000000-0x000003000000 : "User"
0x000003000000-0x000008000000 : "File System"

C'est la forme de représentation la plus intuitive que MTD nous offre, nous montrant les différentes partitions de la mémoire. La structure des partitions du module, mais comment ces partitions sont-elles implémentées ? Il existe plusieurs façons d'implémenter la table de partition, qui sont expliquées ci-dessous :

Remarque : La condition préalable à l'implémentation de la table de partition est que le pilote de périphérique MTD ait réussi, sinon il n'y aura pas de partition dont parler même si le pilote ne réussit pas.

1. Ajout au noyau

L'ajout au noyau est une méthode plus couramment utilisée. Elle devrait être trouvée dans n'importe quel livre de transplantation de pilotes. L'essentiel est d'ajouter mtd_partition dans le périphérique de la plate-forme. Ce qui suit. Informations, je ne les décrirai pas trop ici

struct mtd_partition s3c_nand_part[] = {
    {
        .name       = "Bootloader",
        .offset     = 0,
        .size       = (1 * SZ_1M),
        .mask_flags = MTD_CAP_NANDFLASH,
    },
    {
        .name       = "Kernel",
        .offset     = (1 * SZ_1M),
        .size       = (31 * SZ_1M) ,
        .mask_flags = MTD_CAP_NANDFLASH,
    },
    {
        .name       = "User",
        .offset     = (32 * SZ_1M),
        .size       = (16 * SZ_1M) ,
    },
    {
        .name       = "File System",
        .offset     = (48 * SZ_1M),
        .size       = (96 * SZ_1M),
    }
};

static struct s3c_nand_set s3c_nand_sets[] = {
    [0] = {
        .name       = "nand",
        .nr_chips   = 1,
        .nr_partitions  = ARRAY_SIZE(s3c_nand_part),
        .partitions = ok6410_nand_part,
    },
};

static struct s3c_platform_nand s3c_nand_info = {
    .tacls      = 25,
    .twrph0     = 55,
    .twrph1     = 40,
    .nr_sets    = ARRAY_SIZE(s3c_nand_sets),
    .sets       = ok6410_nand_sets,
};

static void __init s3c_machine_init(void)
{
    s3c_nand_set_platdata(&s3c_nand_info); 
}

Parce que notre pilote MTD est terminé lorsque le périphérique et le pilote correspondent, la fonction d'interface de sonde dans le pilote sera appelée. add_mtd_partitions(s3c_mtd, sets dans la fonction de sonde ->partitions, sets->nr_partitions);Ajout de tables de partition.

2.u-boot transfert de paramètres

add_mtd_partitions(s3c_mtd, sets->partitions, sets->nr_partitions);实现分区表的添加。

2.u-boot传参

在u-boot下可以通过添加mtdparts信息到bootargs中，u-boot启动后会将bootargs中的信息传送给kernel,，kernel在启动的时候会解析bootargs中mtdparts的部分，这边举个例子：

mtdparts=nand.0:1M(Bootloader)ro,31M(Kernel)ro,16M(User),96M(File System)

Sous u-boot, vous pouvez ajouter des informations mtdparts aux bootargs Après le démarrage de u-boot, il transférera les informations contenues dans bootargs au noyau, et le noyau les analysera lorsque. ça démarre. La partie mtdparts de bootargs, voici un exemple :

mtdparts=nand.0:1M(Bootloader)ro,31M(Kernel)ro,16M(User),96M(File System)</code. >, Pour un format mtdparts plus spécifique, veuillez vous référer aux informations pertinentes. 🎜🎜Pour que le noyau puisse analyser les informations mtdparts, nous devons activer l'option d'analyse de la table de partition de ligne de commande des pilotes de périphérique -> 🎜<p>在内核中添加分区表的时候，我们是在平台设备里面加入mtd_partition信息。这边通过u-boot传参则取消平台设备里面的partition信息，那我们需要怎样解析u-boot的传过来的mtdparts呢。</p><p>u-boot传参过来后，cmdlinepart.c中会将这些参数解析好，存在里面<code>LIST_HEAD(part_parsers)链表里面，然后我们在驱动的probe函数中，通过调用mtd_device_parse_register(mtd, probe_types,&ppdata, NULL, 0);函数。

mtd_device_parse_register()函数位于drivers/mtd/mtdcore.c 中，内容如下：

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;
}

可以看到该函数会先执行parse_mtd_partitions(mtd, types, &real_parts, parser_data);函数，后面还是通过add_mtd_partitions()函数来实现分区表的添加。

parse_mtd_partitions()函数位于drivers/mtd/mtdpart.c中，内容如下：

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;
}

进入parse_mtd_partitions()函数会先判断types的类型，如果为空则给默认值，types的类型一般就两种，如下：

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

第一个"cmdlinepart"即u-boot传参的方式，第二个"ofpart"即下面要讲到的使用dts传参的方式，判断完类型后，就通过get_partition_parser去解析part_parsers链表里面的数据，这样就完成u-boot参数的解析。

3.dts传参

在Linux3.14以后的linux版本中，加入一个新的知识DTS(Device tree)，dts其实就是为了解决ARM Linux中的冗余代码，在Linux2.6版本的arch/arm/plat.xxx和arch/arm/mach.xxx中充斥着大量的垃圾代码，采用Device Tree后，许多硬件的细节可以直接透过它传递给Linux，而不再需要在kernel中进行大量的冗余编码，关于dts可以自行查阅资料。

dts传参的原理其实和u-boot一样，区别在于：u-boot的时候是通过cmdlinepart.c文件实现分区信息写入LIST_HEAD(part_parsers)链表，dts则是用过ofpart.c文件实现分区信息写入LIST_HEAD(part_parsers)链表，所以同样要把ofpart.c文件的宏打开，在调用mtd_device_parse_register(mtd, probe_types,&ppdata, NULL, 0);函数的时候types要设置成ofpart。

如果去对比Linux2.6版本和Linux3.14版本，会发现drivers/mtd/ofpart.c和drivers/mtd/mtdpart.c文件有所不同，Linux3.8版本里面多了Device tree这一部分的内容，感兴趣的可以自己深究下。

这边举个dts的例子：

 pinctrl-0 = <&s3c_nand_flash>;
    ranges = <0 0 0x000000000000 0x000008000000>;   /* CS0: NAND */
    nand@0,0 {
        partition@1 {
            label = "Bootloader";
            reg = <0x000000000000 0x000000100000>;
        };
        partition@2 {
            label = "Kernel";
            reg = <0x000000100000 0x000002000000>;
        };
        partition@3 {
            label = "User";
            reg = <0x000002000000 0x000003000000>;
        };
        partition@4 {
            label = "File System";
            reg = <0x000003000000 0x000008000000>;
        };
    };

Linux mtd system的分析就到这边，有感悟时会持续会更新。

相关推荐：《Linux视频教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!