第19章Flash设备驱动之Linux Flash驱动结构

本章重点

Flash 在嵌入式系统中必不可少，Flash是 BootLoader、Linux 内核和文件系统的最佳载体。在 Linux 内核中，引入 MTD（内存技术设备）层为 NOR Flash 和NAND Flash 设备提供统一的接口，使得 Flash 驱动的设计工作大为简化。

1、 Linux Flash 驱动的结构，主要讲解MTD 系统的层次结构和接口。

2、讲解NOR Flash 和 NAND Flash 驱动的设计方法，给出设计模板。

3、以 S3C6410 外围 NOR Flash 和 NAND Flash 为实例讲解NOR Flash 和 NAND Flash 驱动的设计。

4、如何在 Flash 上建立 cramfs、jffs/jffs2、yaffs/yaffs2 及ubifs 文件系统。

19.1 Linux Flash驱动结构

19.1.1 Linux MTD 系统层次

在 Linux 系统中，提供 MTD（MemoryTechnology Device，内存技术设备）系统来建立Flash 针对 Linux 的统一、抽象的接口。MTD 将文件系统与底层的 Flash 存储器进行隔离，使Flash 驱动工程师无须关心 Flash 作为字符设备和块设备与 Linux 内核的接口。

如图 19.1 所示，在引入 MTD 后，Linux系统中的 Flash 设备驱动及接口可分为 4 层，从上到下依次是：设备节点、MTD 设备层、MTD 原始设备层和硬件驱动层，这 4 层的作用如下。

图19.1 Linux MTD 系统

1、硬件驱动层：Flash 硬件驱动层负责 Flash 硬件设备的读、写、擦除，Linux MTD 设备的NOR Flash 芯片驱动位于 drivers/mtd/chips 子目录下，NAND 型 Flash 的驱动程序则位于drivers/mtd/nand 子目录下。

2、MTD 原始设备层：MTD 原始设备层由两部分组成，一部分是 MTD 原始设备的通用代码，另一部分是各个特定的 Flash 的数据，例如分区。

3、MTD 设备层：基于 MTD 原始设备，Linux 系统可以定义出 MTD 的块设备（主设备号31）和字符设备（设备号 90），构成 MTD 设备层。MTD 字符设备的定义在 mtdchar.c中实现，通过注册一系列 file_operation 函数（lseek、open、close、read、write、ioctl）可实现对 MTD 设备的读写和控制。MTD 块设备定义了一个描述 MTD 块设备的结构 mtdblk_dev，并声明一个名为 mtdblks 的指针数组，这数组中的每一个 mtdblk_dev

和 mtd_table 中的每一个 mtd_info 一一对应。

4、设备节点：通过 mknod 在/dev 子目录下建立 MTD 字符设备节点（主设备号为 90）和 MTD块设备节点（主设备号为31），用户通过访问此设备节点即可访问MTD 字符设备和块设备。

19.1.2 Linux MTD 系统接口

如图 19.2 所示，在引入 MTD 后，底层 Flash 驱动直接与 MTD 原始设备层交互，利用其提供的接口注册设备和分区。

图19.2 底层 Flash 驱动

描述 MTD 原始设备的数据结构是 mtd_info，定义了大量关于 MTD 的数据和操作函数，如代码清单 19.1 所示。mtd_info 是表示 MTD 原始设备的结构体，每个分区也被认为是一个 mtd_info，例如，如果有两个MTD 原始设备，每个上有 3 个分区，在系统中就有 6 个 mtd_info 结构体，这些 mtd_info 的指针被存放在名为 mtd_table 的数组里。

代码清单 19.1 mtd_info 结构体

include/linux/mtd/mtd.h

struct mtd_info {
u_char type;/* 内存技术的类型 */
u_int32_t flags;/*标志位*/
u_int32_t size; /*mtd 设备的大小*/

/* "Major" erase size for the device. Naïve users may take this
* to be the only erase size available, or may use the more detailed
* information below if they desire
*/
u_int32_t erasesize;/*主要的擦除块大小*/
/* Minimal writable flash unit size. In case of NOR flash it is 1 (even
* though individual bits can be cleared), in case of NAND flash it is
* one NAND page (or half, or one-fourths of it), in case of ECC-ed NOR
* it is of ECC block size, etc. It is illegal to have writesize = 0.
* Any driver registering a struct mtd_info must ensure a writesize of
* 1 or larger.
*/
u_int32_t writesize;/*最小的可写单元的字节数*/

u_int32_t oobsize; /* OOB 字节数*/
u_int32_t oobavail; /*可用的 OOB 字节数*/

// Kernel-only stuff starts here.
char *name;
int index;

/* ecc layout structure pointer - read only ! */
struct nand_ecclayout *ecclayout;/*ECC 布局结构体指针*/

/* Data for variable erase regions. If numeraseregions is zero,
* it means that the whole device has erasesize as given above.
*/
int numeraseregions;
struct mtd_erase_region_info *eraseregions;

int (*erase) (struct mtd_info *mtd, struct erase_info *instr);

/* This stuff for eXecute-In-Place */
int (*point) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char **mtdbuf);

/* We probably shouldn't allow XIP if the unpoint isn't a NULL */
void (*unpoint) (struct mtd_info *mtd, u_char * addr, loff_t from, size_t len);

int (*read) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
int (*write) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf);

int (*read_oob) (struct mtd_info *mtd, loff_t from, struct mtd_oob_ops *ops);
int (*write_oob) (struct mtd_info *mtd, loff_t to, struct mtd_oob_ops *ops);

/*
* Methods to access the protection register area, present in some
* flash devices. The user data is one time programmable but the
* factory data is read only.
*/
int (*get_fact_prot_info) (struct mtd_info *mtd, struct otp_info *buf, size_t len);
int (*read_fact_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
int (*get_user_prot_info) (struct mtd_info *mtd, struct otp_info *buf, size_t len);
int (*read_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
int (*write_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf);
int (*lock_user_prot_reg) (struct mtd_info *mtd, loff_t from, size_t len);

/* kvec-based read/write methods.
NB: The 'count' parameter is the number of _vectors_, each of
which contains an (ofs, len) tuple.
*/
int (*writev) (struct mtd_info *mtd, const struct kvec *vecs, unsigned long count, loff_t to, size_t *retlen);

/* Sync */
void (*sync) (struct mtd_info *mtd);

/* Chip-supported device locking */
int (*lock) (struct mtd_info *mtd, loff_t ofs, size_t len);
int (*unlock) (struct mtd_info *mtd, loff_t ofs, size_t len);

/* Power Management functions */
int (*suspend) (struct mtd_info *mtd);
void (*resume) (struct mtd_info *mtd);

/* Bad block management functions */
int (*block_isbad) (struct mtd_info *mtd, loff_t ofs);
int (*block_markbad) (struct mtd_info *mtd, loff_t ofs);

struct notifier_block reboot_notifier; /* default mode before reboot */

/* ECC status information */
struct mtd_ecc_stats ecc_stats;
/* Subpage shift (NAND) */
int subpage_sft;

void *priv;

struct module *owner;
int usecount;

/* If the driver is something smart, like UBI, it may need to maintain
* its own reference counting. The below functions are only for driver.
* The driver may register its callbacks. These callbacks are not
* supposed to be called by MTD users */
int (*get_device) (struct mtd_info *mtd);
void (*put_device) (struct mtd_info *mtd);

};

mtd_info 的 type 字段给出底层物理设备的类型，包括 MTD_RAM、MTD_ROM、MTD_NORFLASH、MTD_NANDFLASH 等。

flags 字段标志可以是 MTD_WRITEABLE、MTD_BIT_WRITEABLE、MTD_NO_ERASE、
MTD_POWERUP_LOCK 等的组合。针对 ROM 而言，不具有上述任何属性，因此 MTD_CAP_ROM定义为 0；MTD_CAP_RAM 是 MTD_WRITEABLE、MTD_BIT_WRITEABLE、MTD_NO_ERASE的组合；MTD_CAP_NORFLASH 是 MTD_WRITEABLE、MTD_BIT_WRITEABLE 的组合，对

MTD_CAP_NANDFLASH 则仅意味着 MTD_WRITEABLE。

mtd_info 中的 read()、write()、read_oob()、write_oob()、erase()是 MTD 设备驱动要实现的主要函数，在 NOR 和 NAND 的驱动代码中几乎看不到 mtd_info 的成员函数，这是因为 Linux 在 MTD 的下层实现了针对 NORFlash 和 NAND Flash 的通用的 mtd_info 成员函数。

某些内存技术支持带外数据（OOB），例如，NAND Flash 每 512 字节就会有 16 个字节的“额外数据”，用于存放纠错码或文件系统元数据。这是因为，所有 Flash 器件都受“位翻转”现象的困扰，而 NAND 发生的概率比 NOR 大，因此 NAND 厂商推荐在使用 NAND 的时候最好要使用ECC（Error Checking and Correcting）。mtd_info 的 ecclayout 类型即是描述 OOB 区域中 ECC 字节的布局情况。

Flash 驱动中使用如下两个函数注册和注销 MTD 设备：

include/linux/mtd/mtd.h

int add_mtd_device(struct mtd_info *mtd);

int del_mtd_device (struct mtd_info *mtd);

drivers/mtd/mtdcore.c

/**
* add_mtd_device - register an MTD device
* @mtd: pointer to new MTD device info structure
*
* Add a device to the list of MTD devices present in the system, and
* notify each currently active MTD 'user' of its arrival. Returns
* zero on success or 1 on failure, which currently will only happen
* if the number of present devices exceeds MAX_MTD_DEVICES (i.e. 16)
*/

int add_mtd_device(struct mtd_info *mtd)
{
int i;

BUG_ON(mtd->writesize == 0);
mutex_lock(&mtd_table_mutex);

for (i=0; i < MAX_MTD_DEVICES; i++)
if (!mtd_table[i]) {
struct list_head *this;

mtd_table[i] = mtd;
mtd->index = i;
mtd->usecount = 0;

/* Some chips always power up locked. Unlock them now */
if ((mtd->flags & MTD_WRITEABLE)
&& (mtd->flags & MTD_STUPID_LOCK) && mtd->unlock) {
if (mtd->unlock(mtd, 0, mtd->size))
printk(KERN_WARNING "%s: unlock failed, "
"writes may not work\n",
mtd->name);
}

DEBUG(0, "mtd: Giving out device %d to %s\n",i, mtd->name);
/* No need to get a refcount on the module containing
the notifier, since we hold the mtd_table_mutex */
list_for_each(this, &mtd_notifiers) {
struct mtd_notifier *not = list_entry(this, struct mtd_notifier, list);// 获取指向该结构体的指针
not->add(mtd);
}

mutex_unlock(&mtd_table_mutex);
/* We _know_ we aren't being removed, because
our caller is still holding us here. So none
of this try_ nonsense, and no bitching about it
either. :) */
__module_get(THIS_MODULE);
return 0;
}

mutex_unlock(&mtd_table_mutex);
return 1;

}

/**
* del_mtd_device - unregister an MTD device
* @mtd: pointer to MTD device info structure
*
* Remove a device from the list of MTD devices present in the system,
* and notify each currently active MTD 'user' of its departure.
* Returns zero on success or 1 on failure, which currently will happen
* if the requested device does not appear to be present in the list.
*/

int del_mtd_device (struct mtd_info *mtd)
{
int ret;

mutex_lock(&mtd_table_mutex);

if (mtd_table[mtd->index] != mtd) {
ret = -ENODEV;
} else if (mtd->usecount) {
printk(KERN_NOTICE "Removing MTD device #%d (%s) with use count %d\n",
mtd->index, mtd->name, mtd->usecount);
ret = -EBUSY;
} else {
struct list_head *this;

/* No need to get a refcount on the module containing
the notifier, since we hold the mtd_table_mutex */
list_for_each(this, &mtd_notifiers) {
struct mtd_notifier *not = list_entry(this, struct mtd_notifier, list);//获取指向该结构体的指针
not->remove(mtd);
}

mtd_table[mtd->index] = NULL;
module_put(THIS_MODULE);
ret = 0;
}

mutex_unlock(&mtd_table_mutex);
return ret;

}

代码清单 19.2 所示的 mtd_part 结构体用于表示分区，其 mtd_info 结构体成员用于描述该分区，它会被加入到 mtd_table中，其大部分成员由其主分区 mtd_part→master 决定，各种函数也指向主分区的相应函数。

代码清单 19.2 mtd_part 结构体

drivers/mtd/mtdpart.c

struct mtd_part {
struct mtd_info mtd;/*分区的信息（大部分由其 master 决定）*/
struct mtd_info *master;/*该分区的主分区*/
u_int32_t offset;/*该分区的偏移地址*/
int index;/*分区号*/
struct list_head list;
int registered;

};

mtd_partition 会在 MTD 原始设备层调用 add_mtd_partions()时传递分区信息用，这个结构体的定义如代码清单 19.3 所示。

代码清单 19.3 mtd_partition 结构体

include/linux/mtd/partitions.h

/*
* Partition definition structure:
*
* An array of struct partition is passed along with a MTD object to
* add_mtd_partitions() to create them.
*
* For each partition, these fields are available:
* name: string that will be used to label the partition's MTD device.
* size: the partition size; if defined as MTDPART_SIZ_FULL, the partition
* will extend to the end of the master MTD device.
* offset: absolute starting position within the master MTD device; if
* defined as MTDPART_OFS_APPEND, the partition will start where the
* previous one ended; if MTDPART_OFS_NXTBLK, at the next erase block.
* mask_flags: contains flags that have to be masked (removed) from the
* master MTD flag set for the corresponding MTD partition.
* For example, to force a read-only partition, simply adding
* MTD_WRITEABLE to the mask_flags will do the trick.
*
* Note: writeable partitions require their size and offset be
* erasesize aligned (e.g. use MTDPART_OFS_NEXTBLK).
*/

struct mtd_partition {
char *name; /* 标识字符串 */
u_int32_t size; /* 分区大小 */
u_int32_t offset; /* 主 MTD 空间内的偏移*/
u_int32_t mask_flags; /* 掩码标志 */
struct nand_ecclayout *ecclayout; /* out of band layout for this partition (NAND only)*/
struct mtd_info **mtdp; /* pointer to store the MTD object */

};

Flash 驱动中使用如下两个函数注册和注销分区：

include/linux/mtd/partitions.h

int add_mtd_partitions(struct mtd_info *, const struct mtd_partition *, int);

int del_mtd_partitions(struct mtd _ info *master);

drivers/mtd/mtdpart.c

int add_mtd_partitions(struct mtd_info *master,
const struct mtd_partition *parts,
int nbparts)
{
struct mtd_part *slave;
u_int32_t cur_offset = 0;
int i;

printk (KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name);

for (i = 0; i < nbparts; i++) {

/* allocate the partition structure */
slave = kzalloc (sizeof(*slave), GFP_KERNEL);
if (!slave) {
printk ("memory allocation error while creating partitions for \"%s\"\n",
master->name);
del_mtd_partitions(master);
return -ENOMEM;
}
list_add(&slave->list, &mtd_partitions);

/* set up the MTD object for this partition */
slave->mtd.type = master->type;
slave->mtd.flags = master->flags & ~parts[i].mask_flags;
slave->mtd.size = parts[i].size;
slave->mtd.writesize = master->writesize;
slave->mtd.oobsize = master->oobsize;
slave->mtd.oobavail = master->oobavail;
slave->mtd.subpage_sft = master->subpage_sft;

slave->mtd.name = parts[i].name;
slave->mtd.owner = master->owner;

slave->mtd.read = part_read;
slave->mtd.write = part_write;

if(master->point && master->unpoint){
slave->mtd.point = part_point;
slave->mtd.unpoint = part_unpoint;
}

if (master->read_oob)
slave->mtd.read_oob = part_read_oob;
if (master->write_oob)
slave->mtd.write_oob = part_write_oob;
if(master->read_user_prot_reg)
slave->mtd.read_user_prot_reg = part_read_user_prot_reg;
if(master->read_fact_prot_reg)
slave->mtd.read_fact_prot_reg = part_read_fact_prot_reg;
if(master->write_user_prot_reg)
slave->mtd.write_user_prot_reg = part_write_user_prot_reg;
if(master->lock_user_prot_reg)
slave->mtd.lock_user_prot_reg = part_lock_user_prot_reg;
if(master->get_user_prot_info)
slave->mtd.get_user_prot_info = part_get_user_prot_info;
if(master->get_fact_prot_info)
slave->mtd.get_fact_prot_info = part_get_fact_prot_info;
if (master->sync)
slave->mtd.sync = part_sync;
if (!i && master->suspend && master->resume) {
slave->mtd.suspend = part_suspend;
slave->mtd.resume = part_resume;
}
if (master->writev)
slave->mtd.writev = part_writev;
if (master->lock)
slave->mtd.lock = part_lock;
if (master->unlock)
slave->mtd.unlock = part_unlock;
if (master->block_isbad)
slave->mtd.block_isbad = part_block_isbad;
if (master->block_markbad)
slave->mtd.block_markbad = part_block_markbad;
slave->mtd.erase = part_erase;
slave->master = master;
slave->offset = parts[i].offset;
slave->index = i;

if (slave->offset == MTDPART_OFS_APPEND)
slave->offset = cur_offset;
if (slave->offset == MTDPART_OFS_NXTBLK) {
slave->offset = cur_offset;
if ((cur_offset % master->erasesize) != 0) {
/* Round up to next erasesize */
slave->offset = ((cur_offset / master->erasesize) + 1) * master->erasesize;
printk(KERN_NOTICE "Moving partition %d: "
"0x%08x -> 0x%08x\n", i,
cur_offset, slave->offset);
}
}
if (slave->mtd.size == MTDPART_SIZ_FULL)
slave->mtd.size = master->size - slave->offset;
cur_offset = slave->offset + slave->mtd.size;

printk (KERN_NOTICE "0x%08x-0x%08x : \"%s\"\n", slave->offset,
slave->offset + slave->mtd.size, slave->mtd.name);

/* let's do some sanity checks */
if (slave->offset >= master->size) {
/* let's register it anyway to preserve ordering */
slave->offset = 0;
slave->mtd.size = 0;
printk ("mtd: partition \"%s\" is out of reach -- disabled\n",
parts[i].name);
}
if (slave->offset + slave->mtd.size > master->size) {
slave->mtd.size = master->size - slave->offset;
printk ("mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#x\n",
parts[i].name, master->name, slave->mtd.size);
}
if (master->numeraseregions>1) {
/* Deal with variable erase size stuff */
int i;
struct mtd_erase_region_info *regions = master->eraseregions;

/* Find the first erase regions which is part of this partition. */
for (i=0; i < master->numeraseregions && slave->offset >= regions[i].offset; i++)
;

for (i--; i < master->numeraseregions && slave->offset + slave->mtd.size > regions[i].offset; i++) {
if (slave->mtd.erasesize < regions[i].erasesize) {
slave->mtd.erasesize = regions[i].erasesize;
}
}
} else {
/* Single erase size */
slave->mtd.erasesize = master->erasesize;
}

if ((slave->mtd.flags & MTD_WRITEABLE) &&
(slave->offset % slave->mtd.erasesize)) {
/* Doesn't start on a boundary of major erase size */
/* FIXME: Let it be writable if it is on a boundary of _minor_ erase size though */
slave->mtd.flags &= ~MTD_WRITEABLE;
printk ("mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
parts[i].name);
}
if ((slave->mtd.flags & MTD_WRITEABLE) &&
(slave->mtd.size % slave->mtd.erasesize)) {
slave->mtd.flags &= ~MTD_WRITEABLE;
printk ("mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
parts[i].name);
}

slave->mtd.ecclayout = master->ecclayout;
if (master->block_isbad) {
uint32_t offs = 0;

while(offs < slave->mtd.size) {
if (master->block_isbad(master,
offs + slave->offset))
slave->mtd.ecc_stats.badblocks++;
offs += slave->mtd.erasesize;
}
}

if(parts[i].mtdp)
{ /* store the object pointer (caller may or may not register it */
*parts[i].mtdp = &slave->mtd;
slave->registered = 0;
}
else
{
/* register our partition */
add_mtd_device(&slave->mtd);
slave->registered = 1;
}
}

return 0;

}

int del_mtd_partitions(struct mtd_info *master)
{
struct list_head *node;
struct mtd_part *slave;

for (node = mtd_partitions.next;
node != &mtd_partitions;
node = node->next) {
slave = list_entry(node, struct mtd_part, list);
if (slave->master == master) {
struct list_head *prev = node->prev;
__list_del(prev, node->next);
if(slave->registered)
del_mtd_device(&slave->mtd);
kfree(slave);
node = prev;
}
}

return 0;

}

分析：

第19章Flash设备驱动之Linux Flash驱动结构

猜你喜欢