MTD学习报告004_mtd: partition is out of reach -- disabled-优快云博客

本文链接：https://blog.youkuaiyun.com/aaronychen/article/details/3984165

接着看s3c2410_nand_add_partition(), 这是重点,

Drivers/mtd/nand/s3c2410.c:

static int s3c2410_nand_add_partition(struct s3c2410_nand_info *info,

struct s3c2410_nand_mtd *mtd,

struct s3c2410_nand_set *set)

{

if (set == NULL)

return add_mtd_device(&mtd->mtd);

if (set->nr_partitions > 0 && set->partitions != NULL) {

return add_mtd_partitions(&mtd->mtd,

set->partitions,

set->nr_partitions);

}

return add_mtd_device(&mtd->mtd);

}

由上面的分析可知, 这里调的是add_mtd_partitions().

这个函数相对也比较长, 我们一段段的看.

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

/*为每个partition初始化*/

/*这里的mtd就是面向应用层的那个了*/

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

/* allocate the partition structure */

/*每个partition都有个专门的对象来代表它们*/

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

if (!slave) {

printk ("memory allocation error while creating partitions for /"%s/"/n",

master->name);

del_mtd_partitions(master);

return -ENOMEM;

}

memset(slave, 0, sizeof(*slave));

list_add(&slave->list, &mtd_partitions); /*每个partition都添加到partition列表中去*/

/* set up the MTD object for this partition */

/*初始化每个partition的各种属性,包括回调函数*/

slave->mtd.type = master->type;

slave->mtd.flags = master->flags & ~parts[i].mask_flags;

slave->mtd.size = parts[i].size; /*该partition的大小,可参考前面的分区信息*/

slave->mtd.oobblock = master->oobblock;

slave->mtd.oobsize = master->oobsize;

slave->mtd.ecctype = master->ecctype;

slave->mtd.eccsize = master->eccsize;

slave->mtd.name = parts[i].name; /*该partition的名字,可参考前面的分区信息*/

slave->mtd.bank_size = master->bank_size;

slave->mtd.owner = master->owner;

/*初始化对该partition的各种操作函数*/

slave->mtd.read = part_read; /*对该partition的读函数*/

slave->mtd.write = part_write; /*对该partition的写函数*/

if(master->point && master->unpoint){

slave->mtd.point = part_point;

slave->mtd.unpoint = part_unpoint;

}

if (master->read_ecc)

slave->mtd.read_ecc = part_read_ecc;

if (master->write_ecc)

slave->mtd.write_ecc = part_write_ecc;

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->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->readv)

slave->mtd.readv = part_readv;

if (master->writev_ecc)

slave->mtd.writev_ecc = part_writev_ecc;

if (master->readv_ecc)

slave->mtd.readv_ecc = part_readv_ecc;

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;

……..

}

接着看剩下的代码:

Drivers/mtd/mtdpart.c:

int add_mtd_partitions(struct mtd_info *master,

const struct mtd_partition *parts,

int nbparts)

{

…….

/*初始化其他一些参数*/

slave->master = master; //这里的master就是上面分析的那个

/*该partition在整个设备上的offset,可参看前面的partition的分区信息, 以后对该partition的操作都是在这段区域内进行的*/

slave->offset = parts[i].offset;

slave->index = i;

if (slave->offset == MTDPART_OFS_APPEND)

slave->offset = cur_offset;

if (slave->offset == MTDPART_OFS_NXTBLK) {

u_int32_t emask = master->erasesize-1;

slave->offset = (cur_offset + emask) & ~emask;

if (slave->offset != cur_offset) {

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

}

/*调整partition大小, 因为有时候可能我们分区的时候出错了*/

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;

}

/*初始化partition的各种属性*/

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

}

/* copy oobinfo from master */

memcpy(&slave->mtd.oobinfo, &master->oobinfo, sizeof(slave->mtd.oobinfo));

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); /*最后把MTD注册进系统*/

slave->registered = 1;

}

return 0;

}

OK, 这个函数主要就是为每个partition分配一个代表该partition的对象MTD(即面向上层应用的那个MTD), 并把该mtd注册进系统中去, 即让上层应用能看到并使用这个设备.

下面我们在看add_mtd_device()

Drivers/mtd/mtdcore.c:

int add_mtd_device(struct mtd_info *mtd)

{

int i;

down(&mtd_table_mutex);

for (i=0; i < MAX_MTD_DEVICES; i++)

if (!mtd_table[i]) { /*获取列表中的一个空闲项*/

struct list_head *this;

/*把我们的mtd保存在该列表项中去*/

mtd_table[i] = mtd;

mtd->index = i;

mtd->usecount = 0;

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

/*通知每个notifier有一个mtd设备注册了*/

list_for_each(this, &mtd_notifiers) {

struct mtd_notifier *not = list_entry(this, struct mtd_notifier, list);

not->add(mtd); /*调notify的add回调函数*/

}

up(&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;

}

up(&mtd_table_mutex);

return 1;

}

mtd_table[]保存了系统中存在的mtd设备的一个列表, 这个函数就是把代表一个partition的MTD保存到系统的一个全局MTD列表中去, 并调用每个notifier的add回调函数, 以通知他们有个MTD设备注册了.

好的,接下来就是要讲解notifier的回调函数了, 还记得notifier是在什么时候注册的吗? 呵呵, mtdchar, mtdblock在初始化的时候都有注册notifier, 我们在回顾下:

Drivers/mtd/mtdchar.c:

static struct mtd_notifier notifier = { /*mtdchar 的notifier*/

.add = mtd_notify_add,

.remove = mtd_notify_remove,

};

static inline void mtdchar_devfs_init(void)

{

devfs_mk_dir("mtd");

register_mtd_user(&notifier); /*这里就是注册notifier*/

}

同样在看mtdblock:

Drivers/mtd/mtd_blkdevs.c:

static struct mtd_notifier blktrans_notifier = {

.add = blktrans_notify_add,

.remove = blktrans_notify_remove,

};

int register_mtd_blktrans(struct mtd_blktrans_ops *tr)

{

int ret, i;

/* Register the notifier if/when the first device type is

registered, to prevent the link/init ordering from fucking

us over. */

if (!blktrans_notifier.list.next)

register_mtd_user(&blktrans_notifier); /*这里就是注册notifier*/

…..

}

下面我们就以block为例讲解.

Drivers/mtd/mtd_blkdevs.c:

static void blktrans_notify_add(struct mtd_info *mtd)

{

struct list_head *this;

if (mtd->type == MTD_ABSENT)

return;

list_for_each(this, &blktrans_majors) {

struct mtd_blktrans_ops *tr = list_entry(this, struct mtd_blktrans_ops, list);

tr->add_mtd(tr, mtd); /*干事实的函数*/

}

这个函数只是一个幌子, 真正干实事的是tr->add_mtd(tr, mtd); mtd_blktrans_ops对象也是在mtdblock初始化的时候设置好的, 具体请看前面的分析, 这里就是调用mtdblock_add_mtd:

Drivers/mtd/mtdblock.c:

static void mtdblock_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)

{

/*分配一个代表MTD block的设备*/

struct mtd_blktrans_dev *dev = kmalloc(sizeof(*dev), GFP_KERNEL);

if (!dev)

return;

memset(dev, 0, sizeof(*dev));

/*初始化这个设备*/

dev->mtd = mtd;

dev->devnum = mtd->index;

dev->blksize = 512;

dev->size = mtd->size >> 9;

dev->tr = tr;

if (!(mtd->flags & MTD_WRITEABLE))

dev->readonly = 1;

add_mtd_blktrans_dev(dev); /*添加到系统中去*/

}

核心函数还是add_mtd_blktrans_dev, 我们接着看:

Drivers/mtd/mtd_blkdevs.c:

int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)

{

struct mtd_blktrans_ops *tr = new->tr;

struct list_head *this;

int last_devnum = -1;

struct gendisk *gd;

if (!down_trylock(&mtd_table_mutex)) {

up(&mtd_table_mutex);

BUG();

}

/*首先是为新设备获取设备号*/

list_for_each(this, &tr->devs) {

struct mtd_blktrans_dev *d = list_entry(this, struct mtd_blktrans_dev, list);

if (new->devnum == -1) {

/* Use first free number */

if (d->devnum != last_devnum+1) {

/* Found a free devnum. Plug it in here */

new->devnum = last_devnum+1;

list_add_tail(&new->list, &d->list);

goto added;

}

} else if (d->devnum == new->devnum) {

/* Required number taken */

return -EBUSY;

} else if (d->devnum > new->devnum) {

/* Required number was free */

list_add_tail(&new->list, &d->list);

goto added;

}

last_devnum = d->devnum;

}

if (new->devnum == -1)

new->devnum = last_devnum+1;

if ((new->devnum << tr->part_bits) > 256) {

return -EBUSY;

}

init_MUTEX(&new->sem);

list_add_tail(&new->list, &tr->devs); /*把该设备链入tr中去*/

added:

if (!tr->writesect)

new->readonly = 1;

/*以下是block驱动方面的东西了*/

gd = alloc_disk(1 << tr->part_bits); /*为block设备分配对象,*/

if (!gd) {

list_del(&new->list);

return -ENOMEM;

}

gd->major = tr->major; /*主设备号*/

gd->first_minor = (new->devnum) << tr->part_bits; /*次设备号*/

gd->fops = &mtd_blktrans_ops; /*设备操作集*/

snprintf(gd->disk_name, sizeof(gd->disk_name),

"%s%c", tr->name, (tr->part_bits?'a':'0') + new->devnum);

snprintf(gd->devfs_name, sizeof(gd->devfs_name),

"%s/%c", tr->name, (tr->part_bits?'a':'0') + new->devnum);

/* 2.5 has capacity in units of 512 bytes while still

having BLOCK_SIZE_BITS set to 10. Just to keep us amused. */

set_capacity(gd, (new->size * new->blksize) >> 9);

gd->private_data = new;

new->blkcore_priv = gd;

gd->queue = tr->blkcore_priv->rq;

if (new->readonly)

set_disk_ro(gd, 1);

add_disk(gd); /*把block设备添加入系统, 创建设备文件*/

return 0;

}

这个函数涉及到了block驱动的编写, 可参考相关文档, 该函数主要就是完成mtd block设备的上层设备文件的创建及和具体的设备操作函数集关联起来.

Drivers/mtd/mtd_blkdevs.c:

struct block_device_operations mtd_blktrans_ops = {

.owner = THIS_MODULE,

.open = blktrans_open,

.release = blktrans_release,

.ioctl = blktrans_ioctl,

};