接着看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(¬ifier); /*這裏就是註冊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,
};
當用戶層open我們的mtd設備時, 會調用blktrans_open函數.