ARM-Linux驱动--MTD驱动分析(三)-电子工程世界

分享到: 微博; QQ; 微信; LinkedIn

主机：Gentoo Linux 11.2 with linux kernel 3.0.6

硬件平台：FL2440（S3C2440）with linux kernel 2.6.35

本文分析MTD设备的分区管理机制

分区管理实际上是将一个MTD设备分成几个分区，将其作为单独的MTD原始设备进行管理。

1、分区的结构体描述结构体mtd_part

/* Our partition node structure */
//分区结构信息
struct mtd_part {
struct mtd_info mtd;//mtd_info数据结构，会被加入mtd_table中
struct mtd_info *master;//该分区的主分区
uint64_t offset;//该分区的偏移地址
struct list_head list;
};

2、分区链表mtd_partitions

/* Our partition linked list */
//声明mtd_partitions链表
static LIST_HEAD(mtd_partitions);

3、add_mtd_partitions函数

/*
* This function, given a master MTD object and a partition table, creates
* and registers slave MTD objects which are bound to the master according to
* the partition definitions.
*
* We don't register the master, or expect the caller to have done so,
* for reasons of data integrity.
*/
//根据一个MTD主设备和分区表，创建新的主设备下的副设备并记录到分区表中
//这里我们不将注射被注册到分区表中，只注册副设备到到分区表中
int add_mtd_partitions(struct mtd_info *master,
const struct mtd_partition *parts,
int nbparts)
{
struct mtd_part *slave;
uint64_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++) {//对每一个分区调用add_one_partition函数更新分区表
slave = add_one_partition(master, parts + i, i, cur_offset);
if (!slave)
return -ENOMEM;
cur_offset = slave->offset + slave->mtd.size;
}
return 0;
}
EXPORT_SYMBOL(add_mtd_partitions);

而add_one_partition函数实现如下：

//创建一个分区
static struct mtd_part *add_one_partition(struct mtd_info *master,
const struct mtd_partition *part, int partno,
uint64_t cur_offset)
{
struct mtd_part *slave;
/* allocate the partition structure */
slave = kzalloc(sizeof(*slave), GFP_KERNEL);//分配内存
if (!slave) {
printk(KERN_ERR"memory allocation error while creating partitions for \"%s\"\n",
master->name);
del_mtd_partitions(master);
return NULL;
}
list_add(&slave->list, &mtd_partitions);//将原始设备表添加到分区表中
/* set up the MTD object for this partition */
//大部分根据master相应的信息设置MTD分区slave的信息
slave->mtd.type = master->type;
slave->mtd.flags = master->flags & ~part->mask_flags;
slave->mtd.size = part->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 = part->name;
slave->mtd.owner = master->owner;
slave->mtd.backing_dev_info = master->backing_dev_info;
/* NOTE: we don't arrange MTDs as a tree; it'd be error-prone
* to have the same data be in two different partitions.
*/
slave->mtd.dev.parent = master->dev.parent;
slave->mtd.read = part_read;
slave->mtd.write = part_write;
if (master->panic_write)
slave->mtd.panic_write = part_panic_write;
if (master->point && master->unpoint) {
slave->mtd.point = part_point;
slave->mtd.unpoint = part_unpoint;
}
if (master->get_unmapped_area)
slave->mtd.get_unmapped_area = part_get_unmapped_area;
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 (!partno && !master->dev.class && 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 = part->offset;
if (slave->offset == MTDPART_OFS_APPEND)
slave->offset = cur_offset;
if (slave->offset == MTDPART_OFS_NXTBLK) {
slave->offset = cur_offset;
if (mtd_mod_by_eb(cur_offset, master) != 0) {
/* Round up to next erasesize */
slave->offset = (mtd_div_by_eb(cur_offset, master) + 1) * master->erasesize;
printk(KERN_NOTICE "Moving partition %d: "
"0x%012llx -> 0x%012llx\n", partno,
(unsigned long long)cur_offset, (unsigned long long)slave->offset);
}
}
if (slave->mtd.size == MTDPART_SIZ_FULL)
slave->mtd.size = master->size - slave->offset;
printk(KERN_NOTICE "0x%012llx-0x%012llx : \"%s\"\n", (unsigned long long)slave->offset,
(unsigned long long)(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(KERN_ERR"mtd: partition \"%s\" is out of reach -- disabled\n",
part->name);
goto out_register;
}
if (slave->offset + slave->mtd.size > master->size) {
slave->mtd.size = master->size - slave->offset;
printk(KERN_WARNING"mtd: partition \"%s\" extends beyond the end of device \"%s\" -- size truncated to %#llx\n",
part->name, master->name, (unsigned long long)slave->mtd.size);
}
if (master->numeraseregions > 1) {
/* Deal with variable erase size stuff */
int i, max = master->numeraseregions;
u64 end = slave->offset + slave->mtd.size;
struct mtd_erase_region_info *regions = master->eraseregions;
/* Find the first erase regions which is part of this
* partition. */
for (i = 0; i < max && regions[i].offset <= slave->offset; i++)
;
/* The loop searched for the region _behind_ the first one */
if (i > 0)
i--;
/* Pick biggest erasesize */
for (; i < max && regions[i].offset < end; i++) {
if (slave->mtd.erasesize < regions[i].erasesize) {
slave->mtd.erasesize = regions[i].erasesize;
}
}
BUG_ON(slave->mtd.erasesize == 0);
} else {
/* Single erase size */
slave->mtd.erasesize = master->erasesize;
}
if ((slave->mtd.flags & MTD_WRITEABLE) &&
mtd_mod_by_eb(slave->offset, &slave->mtd)) {
/* 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(KERN_WARNING"mtd: partition \"%s\" doesn't start on an erase block boundary -- force read-only\n",
part->name);
}
if ((slave->mtd.flags & MTD_WRITEABLE) &&
mtd_mod_by_eb(slave->mtd.size, &slave->mtd)) {
slave->mtd.flags &= ~MTD_WRITEABLE;
printk(KERN_WARNING"mtd: partition \"%s\" doesn't end on an erase block -- force read-only\n",
part->name);
}
slave->mtd.ecclayout = master->ecclayout;
if (master->block_isbad) {
uint64_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;
}
}
out_register:
/* register our partition */
//最后调用add_mtd_device根据该设备的mtd_info信息添加设备链表，将其作为一个独立的MTD原始设备
add_mtd_device(&slave->mtd);
return slave;
}

4、del_mtd_partition函数

/*
* This function unregisters and destroy all slave MTD objects which are
* attached to the given master MTD object.
*/
//将一个主设备下的所有副设备删除
int del_mtd_partitions(struct mtd_info *master)
{
struct mtd_part *slave, *next;
list_for_each_entry_safe(slave, next, &mtd_partitions, list)//遍历mtd_partitions链表，查找到指定的主设备
if (slave->master == master) {
list_del(&slave->list);//将主设备下的附属设备删除
del_mtd_device(&slave->mtd);//调用del_mtd_device函数将每个设备从MTD原始设备表中删除
kfree(slave);//释放内存
}
return 0;
}
EXPORT_SYMBOL(del_mtd_partitions);

5、其他的分区管理函数

/*
* MTD methods which simply translate the effective address and pass through
* to the _real_ device.
*/
//读取某个分区的指定数据
static int part_read(struct mtd_info *mtd, loff_t from, size_t len,
size_t *retlen, u_char *buf)
{
struct mtd_part *part = PART(mtd);
struct mtd_ecc_stats stats;
int res;
stats = part->master->ecc_stats;
if (from >= mtd->size)
len = 0;
else if (from + len > mtd->size)
len = mtd->size - from;
res = part->master->read(part->master, from + part->offset,
len, retlen, buf);
if (unlikely(res)) {
if (res == -EUCLEAN)
mtd->ecc_stats.corrected += part->master->ecc_stats.corrected - stats.corrected;
if (res == -EBADMSG)
mtd->ecc_stats.failed += part->master->ecc_stats.failed - stats.failed;
}
return res;
}
static int part_point(struct mtd_info *mtd, loff_t from, size_t len,
size_t *retlen, void **virt, resource_size_t *phys)
{
struct mtd_part *part = PART(mtd);
if (from >= mtd->size)
len = 0;
else if (from + len > mtd->size)
len = mtd->size - from;
return part->master->point (part->master, from + part->offset,
len, retlen, virt, phys);
}
static void part_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
{
struct mtd_part *part = PART(mtd);
part->master->unpoint(part->master, from + part->offset, len);
}
//获取空闲的内存驱动
static unsigned long part_get_unmapped_area(struct mtd_info *mtd,
unsigned long len,
unsigned long offset,
unsigned long flags)
{
struct mtd_part *part = PART(mtd);
offset += part->offset;
return part->master->get_unmapped_area(part->master, len, offset,
flags);
}
static int part_read_oob(struct mtd_info *mtd, loff_t from,
struct mtd_oob_ops *ops)
{
struct mtd_part *part = PART(mtd);
int res;
if (from >= mtd->size)
return -EINVAL;
if (ops->datbuf && from + ops->len > mtd->size)
return -EINVAL;
res = part->master->read_oob(part->master, from + part->offset, ops);
if (unlikely(res)) {
if (res == -EUCLEAN)
mtd->ecc_stats.corrected++;
if (res == -EBADMSG)
mtd->ecc_stats.failed++;
}
return res;
}
static int part_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
size_t len, size_t *retlen, u_char *buf)
{
struct mtd_part *part = PART(mtd);
return part->master->read_user_prot_reg(part->master, from,
len, retlen, buf);
}
static int part_get_user_prot_info(struct mtd_info *mtd,
struct otp_info *buf, size_t len)
{
struct mtd_part *part = PART(mtd);
return part->master->get_user_prot_info(part->master, buf, len);
}
static int part_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
size_t len, size_t *retlen, u_char *buf)
{
struct mtd_part *part = PART(mtd);
return part->master->read_fact_prot_reg(part->master, from,
len, retlen, buf);
}
static int part_get_fact_prot_info(struct mtd_info *mtd, struct otp_info *buf,
size_t len)
{
struct mtd_part *part = PART(mtd);
return part->master->get_fact_prot_info(part->master, buf, len);
}
//分区写函数
static int part_write(struct mtd_info *mtd, loff_t to, size_t len,
size_t *retlen, const u_char *buf)
{
struct mtd_part *part = PART(mtd);
if (!(mtd->flags & MTD_WRITEABLE))
return -EROFS;
if (to >= mtd->size)
len = 0;
else if (to + len > mtd->size)
len = mtd->size - to;
return part->master->write(part->master, to + part->offset,
len, retlen, buf);
}
static int part_panic_write(struct mtd_info *mtd, loff_t to, size_t len,
size_t *retlen, const u_char *buf)
{
struct mtd_part *part = PART(mtd);
if (!(mtd->flags & MTD_WRITEABLE))
return -EROFS;
if (to >= mtd->size)
len = 0;
else if (to + len > mtd->size)
len = mtd->size - to;
return part->master->panic_write(part->master, to + part->offset,
len, retlen, buf);
}
static int part_write_oob(struct mtd_info *mtd, loff_t to,
struct mtd_oob_ops *ops)
{
struct mtd_part *part = PART(mtd);
if (!(mtd->flags & MTD_WRITEABLE))
return -EROFS;
if (to >= mtd->size)
return -EINVAL;
if (ops->datbuf && to + ops->len > mtd->size)
return -EINVAL;
return part->master->write_oob(part->master, to + part->offset, ops);
}
static int part_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
size_t len, size_t *retlen, u_char *buf)
{
struct mtd_part *part = PART(mtd);
return part->master->write_user_prot_reg(part->master, from,
len, retlen, buf);
}
static int part_lock_user_prot_reg(struct mtd_info *mtd, loff_t from,
size_t len)
{
struct mtd_part *part = PART(mtd);
return part->master->lock_user_prot_reg(part->master, from, len);
}
static int part_writev(struct mtd_info *mtd, const struct kvec *vecs,
unsigned long count, loff_t to, size_t *retlen)
{
struct mtd_part *part = PART(mtd);
if (!(mtd->flags & MTD_WRITEABLE))
return -EROFS;
return part->master->writev(part->master, vecs, count,
to + part->offset, retlen);
}
static int part_erase(struct mtd_info *mtd, struct erase_info *instr)
{
struct mtd_part *part = PART(mtd);
int ret;
if (!(mtd->flags & MTD_WRITEABLE))
return -EROFS;
if (instr->addr >= mtd->size)
return -EINVAL;
instr->addr += part->offset;
ret = part->master->erase(part->master, instr);
if (ret) {
if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
instr->fail_addr -= part->offset;
instr->addr -= part->offset;
}
return ret;
}
void mtd_erase_callback(struct erase_info *instr)
{
if (instr->mtd->erase == part_erase) {
struct mtd_part *part = PART(instr->mtd);
if (instr->fail_addr != MTD_FAIL_ADDR_UNKNOWN)
instr->fail_addr -= part->offset;
instr->addr -= part->offset;
}
if (instr->callback)
instr->callback(instr);
}
EXPORT_SYMBOL_GPL(mtd_erase_callback);
static int part_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
{
struct mtd_part *part = PART(mtd);
if ((len + ofs) > mtd->size)
return -EINVAL;
return part->master->lock(part->master, ofs + part->offset, len);
}
static int part_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
{
struct mtd_part *part = PART(mtd);
if ((len + ofs) > mtd->size)
return -EINVAL;
return part->master->unlock(part->master, ofs + part->offset, len);
}
//分区同步函数
static void part_sync(struct mtd_info *mtd)
{
struct mtd_part *part = PART(mtd);
part->master->sync(part->master);
}
//支持电源管理的功能函数
static int part_suspend(struct mtd_info *mtd)
{
struct mtd_part *part = PART(mtd);
return part->master->suspend(part->master);
}
static void part_resume(struct mtd_info *mtd)
{
struct mtd_part *part = PART(mtd);
part->master->resume(part->master);
}
static int part_block_isbad(struct mtd_info *mtd, loff_t ofs)
{
struct mtd_part *part = PART(mtd);
if (ofs >= mtd->size)
return -EINVAL;
ofs += part->offset;
return part->master->block_isbad(part->master, ofs);
}
//标记设备地址坏块
static int part_block_markbad(struct mtd_info *mtd, loff_t ofs)
{
struct mtd_part *part = PART(mtd);
int res;
if (!(mtd->flags & MTD_WRITEABLE))
return -EROFS;
if (ofs >= mtd->size)
return -EINVAL;
ofs += part->offset;
res = part->master->block_markbad(part->master, ofs);
if (!res)
mtd->ecc_stats.badblocks++;
return res;
}

下篇分析具体的MTD设备，字符设备和块设备，待续........

关键字：ARM-Linux驱动 MTD 驱动分析引用地址：ARM-Linux驱动--MTD驱动分析(三)

上一篇：ARM-Linux驱动移植--Linux下烧写工具DNW和USB驱动安装
下一篇：ARM-Linux驱动--MTD驱动分析(二)

推荐阅读最新更新时间：2024-03-16 14:51

S3C2440 (4.3寸)LCD驱动程序之层次分析（十六）

在上一节LCD层次分析时，得出写个LCD驱动入口函数，需要以下4步： 1）分配一个fb_info结构体：framebuffer_alloc（）； 2）设置fb_info； 3）设置硬件相关的操作； 4）使能LCD，并注册fb_info：register_framebuffer（）；本节需要用到的函数：函数dma_alloc_writecombine（）：（分配显存） void * dma_alloc_writecombine(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp);//分配DMA缓存区给现存 //返回值为：申请到

[单片机]

S3C2440 (4.3寸)LCD<font color='red'>驱动</font>程序之层次<font color='red'>分析</font>（十六）

Mini2440 DM9000 驱动分析（二）

在真正的开始分析dm9000 driver的probe之前，首先来看看dm9000 驱动中几个十分重要的结构 1、dm9000_driver static struct platform_driver dm9000_driver = { .driver = { .name = dm9000 , .owner = THIS_MODULE, .pm = &dm9000_drv_pm_ops, }, .probe = dm9000_probe, .remove = __devexit_p(dm9000_drv_remove), }; dm9000_driver是platform_driver结构体变量，其中

[单片机]

基于S3c2440的I2C驱动与测试程序追踪交叉分析

VMware虚拟机+Fedora10，硬件平台TQ2440，内核2.6.30.4 对应的驱动程序豁然开朗，然后自己添加了一些dev_dbg后，对于不理解的地方也有了一定的参考提示，记录下来与大家分享。测试程序如下： /*i2c_test.c * hongtao_liu */ #include #include #include #include #include #include #include #include #define I2C_RETRIES 0x0701 #define I2C_ TI MEOUT 0x0702 #define I2C_RDWR 0x0707 /*********定义struct i

[单片机]

1W大功率LED驱动电源电路分析

　　大功率发光二极管比日光灯具有更高的发光效率和使用寿命。人们应根据实际使用方式另外加装散热器。目前，国产3W发白光的LED零售价为15元，但由于3W大功率LED质量还不够可靠，暂不宜使用。5W大功率LED只有进口货，每只售价高达60元，仅适用于特殊要求的灯光工程之中，最适合人们家里作照明用的就是国产1W发光二极管。　　鉴于大功率发光二极管工作电压仅为3V，通过全桥整流将220V交流电变成直流电，在全桥上的电压降约为1.8V，只驱动一只发光二极管工作的电能利用效率仅为60%。必须把3只以上发光二极管串联起来工作，才能使总的电能利用效率超过80%。　　根据3基色合成白光原理，将红、绿、蓝3只1W大功率发光二极管串联起来工作

[电源管理]

1W大功率LED<font color='red'>驱动</font>电源电路<font color='red'>分析</font>

电驱动关键技术分析电驱动系统结构及原理

电机驱动低速高扭、扭矩波动小，因此悬置布置时不用追求高的解耦率，重点考虑限位、抗扭作用; 从外特性上对比来看，电机驱动相比内燃机驱动，扭矩响应速度快、峰值扭矩作用区间宽，在特殊路况下容易出现动态冲击事件，产品的耐久、强度需要特殊考虑; 传统车工作转速区间比较集中，而新能源车相对较宽，需要在很宽的转速范围内考虑共振等NVH问题。

[嵌入式]

电<font color='red'>驱动</font>关键技术<font color='red'>分析</font> 电<font color='red'>驱动</font>系统结构及原理

电动汽车驱动方式优缺点技术分析

电动汽车相对传统汽车具有能量转换效率高、噪声小、零排放等优点，同时由于电动机的带载性和宽调速特性，可去掉离合器和变速箱等机械装置，使结构简化，维护、保养方便。在当今能源、环境双重问题的推动下，世界主要汽车生产国都以前所未有的力度发展电动汽车产业，科研人员对电动汽车的研发也获得了绝佳机遇。因此，电动汽车正在开创汽车产业的新格局，它将成为汽车工业发展的主要方向。驱动电机作为电动汽车的核心部件，其好坏对电动汽车的动力性、经济性、安全性都有重要影响。但汽车驱动电机有别于其它工业电机，电机驱动系统不仅受汽车结构尺寸的影响，同时还要满足复杂工况下的运行条件。因此，除了要求驱动电机效率高、质量小、功率密度大、尺寸小、可靠性好及成本低的特点

[嵌入式]

电动汽车<font color='red'>驱动</font>方式优缺点技术<font color='red'>分析</font>

MapPtrToProcess 用法 WINCE驱动分析3

以使用下面的应用程序代码测试这个driver，使用evc编译。 #include windows.h #include Windev.h #include stdio.h #include "objbase.h" #include "initguid.h" #include "foo.h" //char data1 ; int WinMain(void) { HANDLE hnd; COPY_STRUCT cs ; int i; //static char data1 ; auto char data1 ; auto char

[嵌入式]

Teledyne LeCroy 发布电机驱动分析仪

在8通道、12bit高精度示波器上的针对三相电机驱动的功率分析能力 Chestnut Ridge, NY, February 4, 2015 -力科（Teledyne LeCroy）发布了MDA800系列电机驱动分析仪（MDA），该设备将三相功率分析仪的静态（稳态）计算能力，独特的动态三相电源和电机的机械分析功能与高带宽（1 GHz）的控制系统结合为一台仪器。电机驱动器分析仪（MDA）搭载于HDO8000示波器平台上。该平台标配8个输入通道（16个数字通道可选），拥有12位垂直分辨率，2.5 GS/ s的实时采样率，高达1 GHz的带宽和高达250 Mpts的单通道采集存储。拥有一整套完整的串行触

[测试测量]