mtd子系统

àì夳堔傛蜴生んèń 2023-10-18 21:15 42阅读 0赞

原文网址：[mtd子系统\_IT利刃出鞘的博客-CSDN博客][mtd_IT_-CSDN]

**内核版本：linux-4.9.37**

## linux的mtd概述 ##

### 简介 ###

MTD(memory technology device内存技术设备)是用于访问memory设备（ROM、flash）的Linux的子系统。MTD的主要目的是为了使新的memory设备的驱动更加简单，  
为此它在硬件和上层之间提供了一个抽象的接口。MTD的所有源代码在/drivers/mtd子目录下。将CFI接口的MTD设备分为四层（从设备节点直到底层硬件驱动），这四层从上到下依次是：设备节点、MTD设备层、MTD原始设备层和硬件驱动层。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70][]

**一、Flash硬件驱动层**  
硬件驱动层负责在init时驱动Flash硬件，Linux MTD设备的NOR Flash芯片驱动遵循CFI接口标准，其驱动程序位于drivers/mtd/chips子目录下。  
NAND型Flash的驱动程序则位于/drivers/mtd/nand子目录下。  
**二、MTD原始设备**  
原始设备层有两部分组成，一部分是MTD原始设备的通用代码，另一部分是各个特定的Flash的数据，例如分区。  
用于描述 MTD原始设备的数据结构是 mtd\_info，这其中定义了大量的关于 MTD的数据和操作函数。  
mtd\_idr（mtdcore.c=>static DEFINE\_IDR(mtd\_idr)）是所有MTD原始设备的列表，所有mtd设备通过i = idr\_alloc(&mtd\_idr, mtd, 0, 0, GFP\_KERNEL)等类似操作与mtd\_idr建立连接。  
mtd\_part（mtdpart.c）是用于表示MTD原始设备分区的结构，其中包含了mtd\_info，因为每一个分区都是被看成一个MTD原始设备加在mtd\_idr中的，  
mtd\_part.mtd中的大部分数据都从该分区的主分区mtd\_part->master中获得（add\_mtd\_partitions）。  
在drivers/mtd/maps/子目录下存放的是特定的flash的数据，每一个文件都描述了一块板子上的flash。其中调用add\_mtd\_device()、del\_mtd\_device()建立/删除mtd\_info结构  
并将其加入/删除mtd\_idr（或者调用add\_mtd\_partition()、del\_mtd\_partition()（mtdpart.c）建立/删除mtd\_part结构并将mtd\_part.mtd\_info加入/删除mtd\_idr 中）。  
**三、MTD设备层**  
基于MTD原始设备，linux系统可以定义出MTD的块设备（主设备号31）和字符设备（主设备号90）。  
MTD字符设备的定义在mtdchar.c中实现，注册一系列file operation函数（lseek、open、close、read、write）。  
MTD块设备的定义在mtdblock.c（其调用mtd\_blkdevs.c的函数），在mtd\_blkdevs.c=> add\_mtd\_blktrans\_dev函数中，  
以mtd\_blkdevs.c=> block\_device\_operations mtd\_block\_ops为ops，以mtdblock.c=>mtd\_blktrans\_ops mtdblock\_tr的.name和.major注册块设备、生成块设备节点。

**四、设备节点**

通过mknod在/dev子目录下建立MTD字符设备节点（主设备号为90）和MTD块设备节点（主设备号为31），通过访问此设备节点即可访问MTD字符设备和块设备。  
/dev/mtdN是字符设备节点，/dev/mtdblockN是块设备节点。  
**/dev/mtdN和/dev/mtdblockN的关系和区别**：  
1.它们是对同一分区的不同的描述方法  
2.生成节点的方法  
字符节点是mtdchar.c注册生成的，支持open,read,write,ioctl等。flash\_erase, nanddump等都是对字符节点，通过read,write,ioctl等执行。见分层调用流程  
块设备节点对应mtdblock.c和mtd\_blkdevs.c，是Flash驱动中用add\_mtd\_partitions()添加MTD设备分区，而生成的对应的块设备。  
MTD块设备驱动程序可以让flash器件伪装成块设备，实际上它通过把整块的erase block放到ram里面进行访问，然后再更新到flash，用户可以在这个块设备上创建通常的文件系统。  
对于MTD块设备，MTD设备层是不提供ioctl的实现方法的，不能使用nandwrite,flash\_eraseall,flash\_erase等工具去对/dev/mtdblockN去进行操作。  
3.mtd-utils工具只能用与/dev/mtdN的MTD字符设备。mount、umount命令只对/dev/mtdblockN的MTD块设备有效。

**五、根文件系统**

在Bootloader中将JFFS（或JFFS2）的文件系统映像jffs.image（或jffs2.img）烧到flash的某一个分区中，在/arch/arm/mach-your/arch.c文件的your\_fixup函数中  
将该分区作为根文件系统挂载。

**六、文件系统**

内核启动后，通过mount 命令可以将flash中的其余分区作为文件系统挂载到mountpoint上。

### **mtd的字符设备和块设备的命名规则** ###

Table 7-1. MTD /dev entries, corresponding MTD user modules, and relevant device major numbers

<table> 
 <tbody> 
 <tr> 
 <td style="width:158.55pt;"> /dev entry </td> 
 <td style="width:158.55pt;"> Accessible MTD user module </td> 
 <td style="width:158.55pt;"> Device type </td> 
 <td style="width:158.55pt;"> Major number </td> 
 </tr> 
 <tr> 
 <td style="width:158.55pt;"> mtdN </td> 
 <td style="width:158.55pt;"> char device </td> 
 <td style="width:158.55pt;"> char </td> 
 <td style="width:158.55pt;"> 90 </td> 
 </tr> 
 <tr> 
 <td style="width:158.55pt;"> mtdrN </td> 
 <td style="width:158.55pt;"> char device </td> 
 <td style="width:158.55pt;"> char </td> 
 <td style="width:158.55pt;"> 90 </td> 
 </tr> 
 <tr> 
 <td style="width:158.55pt;"> mtdblockN </td> 
 <td style="width:158.55pt;"> block device, read-only block device, JFFS, and JFFS2 </td> 
 <td style="width:158.55pt;"> block </td> 
 <td style="width:158.55pt;"> 31 </td> 
 </tr> 
 <tr> 
 <td style="width:158.55pt;"> nftlLN </td> 
 <td style="width:158.55pt;"> NFTL </td> 
 <td style="width:158.55pt;"> block </td> 
 <td style="width:158.55pt;"> 93 </td> 
 </tr> 
 <tr> 
 <td style="width:158.55pt;"> ftlLN </td> 
 <td style="width:158.55pt;"> FTL </td> 
 <td style="width:158.55pt;"> block </td> 
 <td style="width:158.55pt;"> 44 </td> 
 </tr> 
 </tbody> 
</table>

Table 7-2. MTD /dev entries, minor numbers, and naming schemes

<table> 
 <tbody> 
 <tr> 
 <td style="width:211.4pt;"> /dev entry </td> 
 <td style="width:211.4pt;"> Minor number range </td> 
 <td style="width:211.4pt;"> Naming scheme </td> 
 </tr> 
 <tr> 
 <td style="width:211.4pt;"> mtdN </td> 
 <td style="width:211.4pt;"> 0 to 32 per increments of 2 </td> 
 <td style="width:211.4pt;"> N&nbsp;= minor / 2 </td> 
 </tr> 
 <tr> 
 <td style="width:211.4pt;"> mtdrN </td> 
 <td style="width:211.4pt;"> 1 to 33 per increments of 2 </td> 
 <td style="width:211.4pt;"> N&nbsp;= (minor – 1) / 2 </td> 
 </tr> 
 <tr> 
 <td style="width:211.4pt;"> mtdblockN </td> 
 <td style="width:211.4pt;"> 0 to 16 per increments of 1 </td> 
 <td style="width:211.4pt;"> N&nbsp;= minor </td> 
 </tr> 
 <tr> 
 <td style="width:211.4pt;"> nftlLN </td> 
 <td style="width:211.4pt;"> 0 to 255 per sets of 16 </td> 
 <td style="width:211.4pt;"> L&nbsp;= set;<a rel="nofollow">[2]</a>&nbsp;N&nbsp;= minor – (set – 1) x 16;&nbsp;N&nbsp;is not appended to entry name if its value is zero. </td> 
 </tr> 
 <tr> 
 <td style="width:211.4pt;"> ftlLN </td> 
 <td style="width:211.4pt;"> 0 to 255 per sets of 16 </td> 
 <td style="width:211.4pt;"> Same as NFTL. </td> 
 </tr> 
 </tbody> 
</table>

### mtd工具 ###

mtd-utils可以编译出很多mtd相关工具，例如：mkfs,flash\_erase,ubiformat,nanddump,mtdinfo  
下载地址： [mtd官网][mtd] [mtd-utils下载地址][mtd-utils] [mtd-utils版本差异][mtd-utils 1]

## 分层注册函数 ##

![分层注册函数图片][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 1]

mtd\_blkdevs.c的struct mtd\_notifier blktrans\_notifier的list成员 会添加到 mtdcore.c的 链表头mtd\_nitifier  
mtdblock.c的struct mtd\_blktrans\_ops mtdblock\_tr的list成员 会添加到 mtd\_blkdevs.c的 链表头blktrans\_majors

1.add\_mtd\_partations()和add\_mtd\_devices()区别：  
add\_mtd\_partations()：  
有多个(即定义了struct partition\_info) 时使用此函数。  
此函数先调用allocate\_partition按照分区信息进行分区，再调用add\_mtd\_devices()  
add\_mtd\_devices()：  
只有一个分区时使用。  
注：  
可以直接使用mtd\_device\_register()  
第一个参数是主分区（描述整个设备）  
第二个参数是struct partition\_info的parts首地址  
第三个参数是struct partition\_info的parts\_num成员  
2.注册函数区别  
调用关系如下，详细见代码流程  
mtd\_device\_register  
add\_mtd\_partations  
add\_mtd\_devices  
mtd子系统详细分层  
若将mtd子系统详细分层，则如下图所示。

![详细分层图片][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 2]

## 字符节点分层调用流程 ##

示例：nanddump -p -c -l 0x800 /dev/mtd8

### open ###

open(“/dev/mtd8”...) = 3  
mtdchar\_open(struct inode \*inode, struct file \*file) //mtdchar.c  
int minor = iminor(inode);  
int devnum = minor >> 1;  
struct mtd\_info \*mtd;  
struct mtd\_file\_info \*mfi;

mtd = get\_mtd\_device(NULL, devnum);  
struct mtd\_info \*ret = NULL  
ret = idr\_find(&mtd\_idr, num);  
\_\_get\_mtd\_device(ret);  
return ret;

mfi = kzalloc(sizeof(\*mfi), GFP\_KERNEL);  
mfi->mtd = mtd;  
file->private\_data = mfi;

ioctl

ioctl(3, MIXER\_READ(18) or ECCGETSTATS, ...)  
struct mtd\_file\_info \*mfi = file->private\_data;  
struct mtd\_info \*mtd = mfi->mtd;

检查坏块：MEMSETBADBLOCK  
擦除：MEMERASE、MEMERASE64

### 擦除 ###

mtd\_erase(mtd, erase); //mtdcore.c 
mtd->\_erase(mtd, instr) //nand\_base.c=>nand\_scan\_tail中指定的 
nand\_erase(mtd, instr); //nand\_base.c 
nand\_erase\_nand(mtd, instr, 0) //nand\_base.c 
chip->select\_chip(mtd, chipnr); //控制器驱动或nand\_base.c=>nand\_scan\_ident中指定 
nand\_block\_checkbad(mtd, ((loff\_t) page) << chip->page\_shift, allowbbt) //若是坏块，则不擦除 
if (!chip->bbt) //否则 return nand\_isbad\_bbt(mtd, ofs, allowbbt); nand\_bbt.c 
chip->block\_bad(mtd, ofs); //nand\_base.c=> nand\_scan\_ident=> nand\_set\_defaults 
nand\_block\_bad(mtd, ofs) //nand\_base.c 
如果(chip->bbt\_options & NAND\_BBT\_SCANLASTPAGE) 
ofs += mtd->erasesize - mtd->writesize; 
chip->cmdfunc(mtd, NAND\_CMD\_READOOB, chip->badblockpos, page); 
bad = chip->read\_byte(mtd); 
res = bad != 0xFF; 
如果(chip->bbt\_options & NAND\_BBT\_SCAN2NDPAGE) 
会再读下一页的bb数据 
return res; 
chip->erase(mtd, page & chip->pagemask) //nand\_base.c=> nand\_get\_flash\_type中指定 
single\_erase(mtd, page & chip->pagemask) 
//控制器驱动或nand\_base.c=>nand\_scan\_ident中指定 
chip->cmdfunc(mtd, NAND\_CMD\_ERASE1, -1, page); 
发送页地址 
chip->cmdfunc(mtd, NAND\_CMD\_ERASE2, -1, -1);

### 读 ###

read(3, ...) //应用层

mtdchar\_read(struct file \*file, char \_\_user \*buf, size\_t count, loff\_t \*ppos) //mtdchar.c  
//一般走switch的默认路径  
struct mtd\_file\_info \*mfi = file->private\_data;  
struct mtd\_info \*mtd = mfi->mtd;  
ret = mtd\_read(mtd, \*ppos, len, &retlen, kbuf); //mtdcore.c  
ret\_code = mtd->\_read(mtd, from, len, retlen, buf); //mtdpart.c=> allocate\_partition指定  
part\_read(mtd, from, len, retlen, buf); //mtdpart.c  
stats = part->master->ecc\_stats;  
res = part->master->\_read(part->master, from + part->offset, len, retlen, buf);  
//nand\_base.c=>nand\_scan\_tail指定  
nand\_read(mtd, from, len, retlen, buf) //nand\_base.c  
ops.mode = MTD\_OPS\_PLACE\_OOB;  
ret = nand\_do\_read\_ops(mtd, from, &ops); //nand\_base.c  
uint8\_t \*oob;  
unsigned int max\_bitflips = 0;  
oob = ops->oobbuf;  
ecc\_failures = mtd->ecc\_stats.failed;  
chip->select\_chip(mtd, chipnr);  
//**控制器驱动**或nand\_base.c=>nand\_scan\_ident => nand\_set\_defaults  
chip->cmdfunc(mtd, NAND\_CMD\_READ0, 0x00, page);  
//**控制器驱动**或nand\_base.c=>nand\_scan\_ident => nand\_set\_defaults  
**发送地址、读命令**   
如果ops->mode是MTD\_OPS\_RAW  
ret = chip->ecc.read\_page\_raw(mtd, chip, bufpoi,  
oob\_required, page);  
//nand\_base.c=>nand\_scan\_tail函数中设置  
若没对齐 且 chip->options有NAND\_SUBPAGE\_READ 且  
ops->oobbuf是NULL  
ret = chip->ecc.read\_subpage(mtd, chip, col,  
bytes, bufpoi, page);  
其他 //一般走此分支  
ret = chip->ecc.read\_page(mtd, chip, bufpoi, oob\_required, page);

ret = chip->ecc.read\_page(mtd, chip, bufpoi, oob\_required, page);  
//nand\_base.c=> nand\_scan\_tail指定  
nand\_read\_page\_raw(mtd, chip, bufpoi, oob\_required, page)  
//nand\_base.c //**此函数返回值一定为0**  
chip->read\_buf(mtd, buf, mtd->writesize);  
//**控制器驱动**或nand\_base.c=>nand\_scan\_ident =>  
//nand\_set\_defaults指定  
**只是把host->buf数据拷贝到buf**  
hisi\_fmc\_read\_buf(struct mtd\_info \*mtd,  
uint8\_t \*buf, int len)  
如果读失败了：mtd->ecc\_stats.failed++;  
设置ECC纠正的位数：mtd->ecc\_stats.corrected += ..

max\_bitflips = max\_t(unsigned int, max\_bitflips, ret); 
if(oob) 
oob = nand\_transfer\_oob(mtd, oob, ops, toread); 
//如果ecc出错了，重传 
if (mtd->ecc\_stats.failed - ecc\_failures) 
//如果还有剩余尝试次数，重传 
if (retry\_mode + 1 < chip->read\_retries)\{ 
mtd->ecc\_stats.failed = ecc\_failures; 
goto read\_retry; 
\}else\{ 
ecc\_fail = true; 
\} 
\} 
 
if (ret < 0) 
return ret;

if (ecc\_fail)  
return -EBADMSG;

return max\_bitflips; 
 return ret; 
if ((mtd\_is\_eccerr(res))) 
mtd->ecc\_stats.failed += part->master->ecc\_stats.failed - stats.failed; 
else 
mtd->ecc\_stats.corrected += part->master->ecc\_stats.corrected - stats.corrected; 
return res; 
若ret\_code < 0，直接返回 
若mtd->ecc\_strength == 0，直接返回0 
若ret\_code大于mtd->bitflip\_threshold 
返回-EUCLEAN 
否则 
返回0 
 如果读出错（ret != 0） 
ret = mtd\_is\_bitflip\_or\_eccerr(ret) //mtd.h 
return mtd\_is\_bitflip(err) || mtd\_is\_eccerr(err) 
如果err是-EUCLEAN，是位反转（但被校正过来了）；如果err是-EBADMSG，是ECC错误 
如果ret == 0或者错误类型是位反转或ecc错误，拷贝数据给用户

### 写 ###

write(3, ...) //应用层  
mtdchar\_write(struct file \*file, const char \_\_user \*buf, size\_t count, loff\_t \*ppos) //mtdchar.c  
//默认走default流程  
mtd\_write(mtd, \*ppos, len, &retlen, kbuf); //mtdcore.c  
mtd->\_write(mtd, to, len, retlen, buf); //mtdpart.c=> allocate\_partition指定  
part\_write(mtd, to, len, retlen, buf); //mtdpart.c  
part->master->\_write(part->master, to + part->offset, len, retlen, buf);  
//nand\_base.c=>nand\_scan\_tail指定  
nand\_write(mtd, to, len, retlen, buf); //nand\_base.c  
ops.mode = MTD\_OPS\_PLACE\_OOB;  
nand\_do\_write\_ops(mtd, to, &ops); //nand\_base.c  
chip->select\_chip(mtd, chipnr);  
//**控制器驱动**或nand\_base.c=>nand\_scan\_ident => nand\_set\_defaults中指定  
chip->write\_page(mtd, chip, column, ..., (ops->mode == MTD\_OPS\_RAW))  
//控制器驱动或**nand\_base.c=>nand\_scan\_tail**指定  
nand\_write\_page //nand\_base.c  
chip->cmdfunc(mtd, NAND\_CMD\_SEQIN, 0x00, page);  
设置写的地址  
如果是raw,走chip->ecc.write\_page\_raw;  
如果支持subpage，走chip->ecc.write\_subpage；  
其他：（一般走此分支）  
chip->ecc.write\_page(mtd, chip, buf, oob\_required, page);  
//nand\_base.c=>nand\_scan\_tail指定  
nand\_write\_page\_raw(mtd, chip, buf, oob\_required, page); //nand\_base.c  
chip->write\_buf(mtd, buf, mtd->writesize);  
//**控制器驱动**或nand\_base.c=>nand\_scan\_ident => nand\_set\_defaults  
 **只是将数据复制到host->buffer**  
chip->cmdfunc(mtd, NAND\_CMD\_PAGEPROG, -1, -1);  
//**控制器驱动**或nand\_base.c=>nand\_scan\_ident => nand\_set\_defaults指定  
**执行烧写命令**

## 控制器驱动probe流程 ##

### 代码流程 ###

hifmc100\_nand\_os.c （drivers/mtd/nand/hifmc100\_nand）  
hisi\_nand\_os\_probe(struct platform\_device \*pltdev)  
struct hik\_nand\_host \*host  
struct nand\_chip \*nand\_chip;  
struct mtd\_info \*mtd;  
struct device \*dev = &pdev->dev;  
struct device\_node \*np = dev->of\_node;  
dma\_addr\_t dma\_handle;  
host = devm\_kzalloc(dev, sizeof(\*host), GFP\_KERNEL);  
pdev->dev.driver\_data = host  
nand\_chip = &host->chip;  
mtd = nand\_to\_mtd(nand\_chip); //即：mtd = &(nand\_chip->mtd)  
host->mtd = mtd;  
nand\_set\_controller\_data(nand\_chip, host); //nand\_chip->priv = host  
nand\_set\_flash\_node(nand\_chip, np); //nand\_chip->mtd.dev.of\_node = pdev->dev.of\_node  
host->buffer = dma\_alloc\_coherent(dev, HIKFMC\_BUFFER\_LEN, &dma\_handle, GFP\_KERNEL)  
host->phy\_buffer = dma\_handle;  
设置nand\_chip的函数及变量  
//读写选中芯片等函数，ecc模式等  
nand\_chip->cmdfunc = hik\_fmc\_cmdfunc;  
nand\_chip->select\_chip = hik\_fmc\_select\_chip;  
nand\_chip->read\_byte = hik\_fmc\_read\_byte;  
nand\_chip->read\_buf = hik\_fmc\_read\_buf;  
...  
//nand\_chip->options在nand.h中有所有宏  
nand\_chip->options = NAND\_SKIP\_BBTSCAN | NAND\_BROKEN\_XD | NAND\_SCAN\_SILENT\_NODEV;  
nand\_chip->ecc.mode = NAND\_ECC\_NONE;

//一般情况下，会调用nans\_scan函数，nand\_scan会调用nand\_scan\_ident和nand\_scan\_tail  
nand\_scan\_ident(mtd, 1, NULL); //nand\_base.c  
//设置默认的读写等函数  
nand\_set\_defaults(chip, chip->options & NAND\_BUSWIDTH\_16);  
如果没设置chip的函数，则设置默认函数，对默认函数的设置如下。  
（默认函数是drivers/mtd/nand/nand\_base.c中的）  
chip->read\_byte = busw ? nand\_read\_byte16 : nand\_read\_byte;  
chip->block\_bad = nand\_block\_bad;  
chip->write\_buf = busw ? nand\_write\_buf16 : nand\_write\_buf  
...  
// 这几个函数是一定会用到的，若不使用默认函数，则需要自己指定：  
// select\_chip, cmdfunc, read\_byte, read\_buf, write\_buf, dev\_ready  
// chip->erase是强制设为默认函数的，见下边nand\_get\_type函数

//获得nand flash基本信息赋值到struct nand\_flash\_dev结构体成员  
type = nand\_get\_flash\_type(mtd, chip, &nand\_maf\_id, &nand\_dev\_id, table);  
chip->erase = single\_erase; //nand\_base.c  
chip->options |= type->options;  
打印flash相关信息：Manufacturer ID、Chip ID、SLC或者MLC、块大小、页大小、OOB大小等  
chip->badblockbits = 8;  
chip->erase = single\_erase;  
hisifmc\_host\_init(host); //初始化fpu,spi,fmc控制器  
hisifmc\_chipinfo\_init(host); //控制器端的ECC模式、page大小等设置  
nand\_scan\_tail(mtd); //nand\_base.c  
struct nand\_chip \*chip = mtd->priv;  
struct nand\_ecc\_ctrl \*ecc = &chip->ecc;  
分配并设置chip->buffer  
//设置内部oob buffer的位置（page data之后）  
chip->oob\_poi = chip->buffers->databuf + mtd->writesize;  
mtd\_set\_ooblayout(mtd, &nand\_ooblayout\_lp\_hamming\_ops);  
根据chip->ecc.mode设置chip->ecc的读写等函数成员、chip->ecc的size、bytes、strength成员  
如果mode为NAND\_ECC\_NONE，则强制设置上述成员  
ecc->read\_page = nand\_read\_page\_raw; //nand\_base.c  
ecc->write\_page = nand\_write\_page\_raw;  
ecc->size = mtd->writesize;  
ecc->bytes = 0;  
ecc->strength = 0;  
...  
ecc->steps = mtd->writesize / ecc->size;  
ecc->total = ecc->steps \* ecc->bytes;  
设置chip->subpagesize等  
设置mtd的读写等函数、type、ecc信息等  
mtd->\_erase = nand\_erase; //nand\_base.c  
mtd->\_read = nand\_read;  
mtd->\_write = nand\_write;  
...  
创建坏块表  
mtd->priv = nand\_chip;  
ptn\_info = get\_partition\_info(host->mtd); //获取分区信息  
if (ptn\_info) \{  
nr\_parts = ptn\_info->parts\_num;  
parts = ptn\_info->parts;  
\}  
解析分区，然后注册mtd设备。找到一个分区就分配分区  
mtd\_device\_register(host->mtd, parts, nr\_parts); //include/linux/mtd/mtd.h  
//传进来第1个参数名为master，第2个为parts，第3个为nr\_parts  
mtd\_device\_parse\_register(master, NULL, NULL, parts, nr\_parts) //mtdcore.c实现  
//第一个参数是主分区（描述整个设备）  
parse\_mtd\_partitions(mtd, types, &parsed, parser\_data) //mtdpart.c实现  
mtd\_add\_device\_partitions(mtd, &parsed) //mtdcore.c实现  
int nbparts = parts->nr\_parts;  
if (nbparts == 0 || IS\_ENABLED(CONFIG\_MTD\_PARTITIONED\_MASTER)) \{  
ret = add\_mtd\_device(mtd);  
mtd->dev.type = &mtd\_devtype;  
mtd->dev.class = &mtd\_class;  
device\_register(&mtd->dev);  
device\_create(&mtd\_class, mtd->dev.parent, MTD\_DEVT(i) + 1,  
NULL, "mtd%dro", i);  
\}

if (nbparts > 0) \{ 
ret = add\_mtd\_partitions(mtd, real\_parts, nbparts); //mtdpart.c实现 
struct mtd\_part \*slave; 
printk("Creating %d MTD partitions on \\"%s\\":\\n", nbparts, master->name); 
for (i = 0; i < nbparts; i++) \{ 
slave = allocate\_partition(master, parts + i, i, cur\_offset); 
struct mtd\_part \*slave; 
slave = kzalloc(sizeof(\*slave), GFP\_KERNEL); 
//设置slave的mtd\_info成员mtd。mtd的变量成员基本都来自于master， 
// 函数成员基本都来自mtdpart.c 
slave->mtd.type = master->type; 
slave->mtd.\_read = part\_read; 
slave->master = master; 
//打印本分区的区间和名称 
printk("0x%012llx-0x%012llx : \\"%s\\"\\n", 
(unsigned long long)slave->offset, 
(unsigned long long)(slave->offset + slave->mtd.size), 
slave->mtd.name); 
如果master->\_block\_isbad已经被设置 
uint64\_t offs = 0; 
while (offs < slave->mtd.size) \{ 
//如果是被保留的块，则bbt 
if (mtd\_block\_isreserved(master, offs + slave->offset)) 
slave->mtd.ecc\_stats.bbtblocks++; 
else if (mtd\_block\_isbad(master, offs + slave->offset)) 
slave->mtd.ecc\_stats.badblocks++; 
offs += slave->mtd.erasesize; 
list\_add(&slave->list, &mtd\_partitions); 
add\_mtd\_device(&slave->mtd); //mtdcore.c 
i = idr\_alloc(&mtd\_idr, mtd, 0, 0, GFP\_KERNEL) 
//调用到的地方： register\_mtd\_blktrans=> mtd\_for\_each\_device， 
// 其调用idr\_get\_next(&mtd\_idr, &i) 
mtd->index = i; 
 
mtd->dev.type = &mtd\_devtype; 
mtd->dev.class = &mtd\_class; 
mtd->dev.devt = MTD\_DEVT(i); 
dev\_set\_name(&mtd->dev, "mtd%d", i); 
dev\_set\_drvdata(&mtd->dev, mtd); 
// 在/dev下创建mtd%d节点。 
device\_register(&mtd->dev); 
// 在/dev下创建mtd %dro节点。 
device\_create(&mtd\_class, mtd->dev.parent, MTD\_DEVT(i) + 1, NULL, 
"mtd%dro", i); 
list\_for\_each\_entry(not, &mtd\_notifiers, list) 
not->add(mtd); //见核心层流程 
if (ret && IS\_ENABLED(CONFIG\_MTD\_PARTITIONED\_MASTER)) 
del\_mtd\_device(mtd); 
return ret; 
\}

### 结构体关系图 ###

probe函数确定的结构体关系图如下

![结构体关系图][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 3]

## 核心层流程 ##

### 字符设备 ###

mtdcore.c (drivers/mtd) 
class\_register(&mtd\_class); 
mtd\_bdi\_init(&mtd\_bdi, "mtd"); //mtdcore.c 
proc\_mtd = proc\_create("mtd", 0, NULL, &mtd\_proc\_ops); 
init\_mtdchar(); //mtdchar.c (drivers/mtd) 
\_\_register\_chrdev(MTD\_CHAR\_MAJOR, 0, 1 << MINORBITS, "mtd", &mtd\_fops); 
//mtdcore.c => add\_mtd\_device中会创建设备节点/dev/mtdN，对应mtd\_fops （mtdchar.c定义）

### 块设备 ###

mtdblock.c (drivers/mtd) //此文件的init函数调用register\_mtd\_blktrans

static struct mtd\_blktrans\_ops mtdblock\_tr = \{  
.name = "mtdblock",  
.major = MTD\_BLOCK\_MAJOR, //MTD\_BLOCK\_MAJOR = 31  
.part\_bits = 0,  
.blksize = 512,  
...  
.writesect = mtdblock\_writesect,  
.add\_mtd = mtdblock\_add\_mtd,  
.owner = THIS\_MODULE,  
// struct list\_head devs;  
\};

register\_mtd\_blktrans(&mtdblock\_tr) //mtd\_blkdevs.c实现，它定义static LIST\_HEAD(blktrans\_majors);  
//如果是在注册第一个设备类型，则注册notifier。  
if (!blktrans\_notifier.list.next) //static struct mtd\_notifier blktrans\_notifier (mtd\_blkdev.c)  
register\_mtd\_user(&blktrans\_notifier); //mtdcore.c  
list\_add(&blktrans\_notifier->list, &mtd\_notifiers); //static LIST\_HEAD(mtd\_notifiers) (mtdcore.c)  
mtd\_for\_each\_device(mtd) //此mtd与mtd\_idr关联：static DEFINE\_IDR(mtd\_idr); //mtdcore.c  
//add\_mtd\_device里边，把每个mtd设备关联到了mtd\_idr  
//对于mtd\_idr上的每个设备(mtd)，调用blktrans\_notifier->add，会调用blktrans\_majors链表头上每  
//个成员(tr)的add\_mtd函数(以tr和mtd为参数)。  
new->add(mtd);  
  
register\_blkdev(mtdblock\_tr->major, mtdblock\_tr->name) //注册块设备

list\_add(&mtdblock\_tr->list, &blktrans\_majors); //把本tr挂到blktrans\_majors链表头上 
mtd\_for\_each\_device(mtd) 
if (mtd->type != MTD\_ABSENT) 
mtdblock\_tr->add\_mtd(mtdblock\_tr, mtd); 
mtdblock\_add\_mtd 
struct gendisk \*gd; 
struct mtdblk\_dev \*dev = kzalloc(sizeof(\*dev), GFP\_KERNEL); 
dev->mbd.mtd = mtd; 
dev->mbd.devnum = mtd->index; 
dev->mbd.size = mtd->size >> 9; 
dev->mbd.tr = mtdblock\_tr; 
add\_mtd\_blktrans\_dev(&dev->mbd) //mtd\_blkdevs.c 
//传进来的参数名字为new 
struct mtd\_blktrans\_ops \*tr = new->tr; //tr = new->tr = mtdblock\_tr 
struct mtd\_blktrans\_dev \*d; 
list\_for\_each\_entry(d, &tr->devs, list) \{ 
//第一次执行时，tr->devs上没有成员，直接跳出本循环 
//如果不是第一次执行 
//如果d->devnum == new->devnum，说明此号已经被使用，直接return -EBUSY 
//如果d->devnum > new->devnum，说明已经添加过了，直接跳出到added标号 
//如果执行到这里，说明d->devnum < new->devnum 
list\_add\_tail(&new->list, &tr->devs); 
 
gd = alloc\_disk(1 << tr->part\_bits); 
 
new->disk = gd; 
gd->private\_data = new; 
gd->major = tr->major; 
gd->first\_minor = (new->devnum) << tr->part\_bits; 
gd->fops = &mtd\_block\_ops; 
//设置gd->dist\_name为/dev/mtdblockN 
snprintf(gd->disk\_name, sizeof(gd->disk\_name), "%s%d", tr->name, new->devnum); 
/\* Create the request queue \*/ 
new->rq = blk\_init\_queue(mtd\_blktrans\_request, &new->queue\_lock); 
new->rq->queuedata = new; 
 
gd->queue = new->rq; 
 
new->wq = alloc\_workqueue("%s%d", 0, 0, tr->name, new->mtd->index); 
device\_add\_disk(&new->mtd->dev, gd); //genhd.c (drivers/block) 
//传进来的第二个参数名为disk 
disk->major = MAJOR(devt); 
disk->first\_minor = MINOR(devt); 
register\_disk(parent, disk); 
struct device \*ddev = disk\_to\_dev(disk); 
dev\_set\_name(ddev, "%s", disk->disk\_name); 
device\_add(ddev)

## /sys/class/mtd的相关成员 ##

mtd的相关信息可以在/sys/class/mtd/mtdN下直接cat得到，对应相应分区的mtd\_info结构体  
dev： 主设备号和次设备号  
name: 分区的名字。（自己定义的分区表（partition\_info）的分区的名字）  
type: 设备类型。如：nand,nor。对应MTD\_NORFLASH、MTD\_NANDFLASH等（可参考mtd-abi.h）。  
size: 本分区总大小。10进制的  
erasesize: 擦除大小。10进制的，一般是一个块大小。  
writesize: 写大小。10进制的，一般是一个页大小。  
subpagesize: 子页大小。10进制的。  
oobsize: oob大小。10进制的。  
numeraseregions: 可变擦除区域数量。如果是0，则表示整个设备的擦除大小都是erasesize  
flags: MTD\_WRITEABLE,MTD\_NO\_ERASE等(可参考mtd-abi.h)

## 常用函数 ##

nand.h中有一些常用函数：nand\_set\_flash\_node、nand\_get\_flash\_node、mtd\_to\_nand、nand\_to\_mtd、nand\_get\_controller\_data、nand\_set\_controller\_data  
它们实现如下：  
static inline void nand\_set\_flash\_node(struct nand\_chip \*chip, struct device\_node \*np)  
\{  
mtd\_set\_of\_node(&chip->mtd, np);  
\}

static inline struct device\_node \*nand\_get\_flash\_node(struct nand\_chip \*chip)  
\{  
return mtd\_get\_of\_node(&chip->mtd);  
\}

static inline struct nand\_chip \*mtd\_to\_nand(struct mtd\_info \*mtd)  
\{  
return container\_of(mtd, struct nand\_chip, mtd);  
\}

static inline struct mtd\_info \*nand\_to\_mtd(struct nand\_chip \*chip)  
\{  
return &chip->mtd;  
\}

static inline void \*nand\_get\_controller\_data(struct nand\_chip \*chip)  
\{  
return chip->priv;  
\}

static inline void nand\_set\_controller\_data(struct nand\_chip \*chip, void \*priv)  
\{  
chip->priv = priv;  
\}

[mtd_IT_-CSDN]: https://knife.blog.csdn.net/article/details/95209148
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190709164635596.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc=,size_16,color_FFFFFF,t_70
[mtd]: http://www.linux-mtd.infradead.org/index.html
[mtd-utils]: http://ftp//ftp.infradead.org/pub/mtd-utils/
[mtd-utils 1]: http://git.infradead.org/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20190709164957883.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20190709165311719.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20190709170029562.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaXlpbmcwY2FuZ2xhbmc=,size_16,color_FFFFFF,t_70