MTD源代码分析(三)

abc19842008

关注

转载最新推荐文章于 2026-03-10 00:11:18 发布 3.6k 阅读 AI 写同款· GEO 优化 ›

Linux MTD层的研究（Nandflash）花了点时间学习Linux MTD层，下面简单总结一下！以下是MTD层的结构图 MTD层实现了文件系统与Flash之间的桥梁，下面就粗略说明字符型MTD驱动与下层驱动的关系。分析对象：/drivers/mtdchar.c 字符型mtd设备字符设备中定义了mtd_fops字符类的文件指针操作函数，完成字符设备读写与打开等功能。 1. static int mtd 阅读详情

mtdchar.c

MTD字符设备的文件

notifier

MTD字符设备的notifier

static struct mtd_notifier notifier = {

add: mtd_notify_add,

remove: mtd_notify_remove,

};

mtd_lseek

格式：

static loff_t mtd_lseek (struct file *file, loff_t offset, int orig)

注释：

无

功能：

置MTD字符设备的指针

说明：

无

参数：

file：MTD字符设备文件

offset：偏移

orig：设置方式

成功：返回当前指针位置

设置方式无效：返回-EINVAL

调用：

无

被调用：

注册进mtd_fops结构

源代码：

{

struct mtd_info *mtd=(struct mtd_info *)file->private_data;

switch (orig) {

case 0:

/* SEEK_SET */

file->f_pos = offset;

break;

case 1:

/* SEEK_CUR */

file->f_pos += offset;

break;

case 2:

/* SEEK_END */

file->f_pos =mtd->size + offset;

break;

default:

return -EINVAL;

}

if (file->f_pos < 0)

file->f_pos = 0;

else if (file->f_pos >= mtd->size)

file->f_pos = mtd->size - 1;

return file->f_pos;

}

mtd_open

格式：

static int mtd_open(struct inode *inode, struct file *file)

注释：

无

功能：

打开一个MTD字符设备

说明：

devnum=minor>>2（参看Documentations/devices.txt），

进行安全性检查，

调用get_mtd_device获取MTD设备，并将file->private_data指向它

参数：

inode：FIXME

file：是系统提供给MTD字符设备用于传递参数的file结构，此函数中它的private_data

成员被指向原始设备层的MTD设备

成功：返回0

失败：返回错误码

调用：

get_mtd_device()获得原始设备层的MTD设备

被调用：

注册进mtd_fops结构

源代码：

{

int minor = MINOR(inode->i_rdev);

int devnum = minor >> 1;

struct mtd_info *mtd;

DEBUG(MTD_DEBUG_LEVEL0, "MTD_open/n");

if (devnum >= MAX_MTD_DEVICES)

return -ENODEV;

/* You can't open the RO devices RW */

if ((file->f_mode & 2) && (minor & 1))

return -EACCES;

mtd = get_mtd_device(NULL, devnum);

if (!mtd)

return -ENODEV;

if (MTD_ABSENT == mtd->type) {

put_mtd_device(mtd);

return -ENODEV;

}

file->private_data = mtd;

/* You can't open it RW if it's not a writeable device */

if ((file->f_mode & 2) && !(mtd->flags & MTD_WRITEABLE)) {

put_mtd_device(mtd);

return -EACCES;

}

return 0;

} /* mtd_open */

mtd_close

格式：

static int mtd_close(struct inode *inode, struct file *file)

注释：

无

功能：

关闭一个MTD字符设备

说明：

调用mtd_info->sync()同步MTD设备，

调用put_mtd_device()返还MTD设备

参数：

inode：FIXME

file：无用

返回0

调用：

mtd_info->sync()同步MTD设备

put_mtd_device()返还MTD设备

被调用：

被注册进mtd_fops结构

源代码：

{

struct mtd_info *mtd;

DEBUG(MTD_DEBUG_LEVEL0, "MTD_close/n");

mtd = (struct mtd_info *)file->private_data;

if (mtd->sync)

mtd->sync(mtd);

put_mtd_device(mtd);

return 0;

} /* mtd_close */

MAX_KMALLOC_SIZE

/* FIXME: This _really_ needs to die. In 2.5, we should lock the

userspace buffer down and use it directly with readv/writev.

#define MAX_KMALLOC_SIZE 0x20000

mtd_read

格式：

static ssize_t mtd_read(struct file *file, char *buf, size_t count,loff_t *ppos)

注释：

无

功能：

MTD字符设备的写操作

说明：

当count>0时{

裁减本次操作大小len至min(MAX_KMALLOC_SIZE,count)，

申请一块大小为MAX_KMALLOC_SIZE的内核空间kbuf，

调用mtd_info->read将MTD设备中的数据读入kbuf，

将kbuf中的数据拷贝到用户空间buf，

count自减

释放kbuf

}

参数：

file：系统给MTD字符设备驱动程序用于传递参数的file结构，此函数通过file得到下

层的MTD设备

buf：用户空间的指针，用于存放读取的数据

count：被读数据的长度

ppos：被读数据在MTD设备中的位置

成功：返回实际读取数据的长度

失败：返回错误码

调用：

mtd_info->read()用于从MTD设备中读取数据

被调用：

被注册进mtd_fops结构

源代码：

{

struct mtd_info *mtd = (struct mtd_info *)file->private_data;

size_t retlen=0;

size_t total_retlen=0;

int ret=0;

int len;

char *kbuf;

DEBUG(MTD_DEBUG_LEVEL0,"MTD_read/n");

if (*ppos + count > mtd->size)

count = mtd->size - *ppos;

if (!count)

return 0;

/* FIXME: Use kiovec in 2.5 to lock down the user's buffers

and pass them directly to the MTD functions */

while (count) {

if (count > MAX_KMALLOC_SIZE)

len = MAX_KMALLOC_SIZE;

else

len = count;

kbuf=kmalloc(len,GFP_KERNEL);

if (!kbuf)

return -ENOMEM;

ret = MTD_READ(mtd, *ppos, len, &retlen, kbuf);

if (!ret) {

*ppos += retlen;

if (copy_to_user(buf, kbuf, retlen)) {

kfree(kbuf);

return -EFAULT;

}

else

total_retlen += retlen;

count -= retlen;

buf += retlen;

}

else {

kfree(kbuf);

return ret;

}

kfree(kbuf);

}

return total_retlen;

} /* mtd_read */

mtd_write

格式：

static ssize_t mtd_write(struct file *file, const char *buf, size_t count,loff_t *ppos)

注释：

无

功能：

对MTD字符设备的写操作

说明：

当count>0时{

裁减本次操作大小len至min(MAX_KMALLOC_SIZE,count)，

申请一块大小为MAX_KMALLOC_SIZE的内核空间kbuf，

将用户空间buf中的数据拷贝到kbuf，

调用mtd_info->write将kbuf中的数据读入MTD设备，

count自减

释放kbuf

}

参数：

file：系统给MTD字符设备驱动程序用于传递参数的file结构，此函数通过file得到下

层的MTD设备

buf：用户空间的指针，用于存放将要写入的数据

count：被写数据的长度

ppos：数据被写入MTD设备中的位置

成功：返回实际读取数据的长度

失败：返回错误码

调用：

mtd_info->write用于写入MTD设备

被调用：

被注册进mtd_fops结构

源代码：

{

struct mtd_info *mtd = (struct mtd_info *)file->private_data;

char *kbuf;

size_t retlen;

size_t total_retlen=0;

int ret=0;

int len;

DEBUG(MTD_DEBUG_LEVEL0,"MTD_write/n");

if (*ppos == mtd->size)

return -ENOSPC;

if (*ppos + count > mtd->size)

count = mtd->size - *ppos;

if (!count)

return 0;

while (count) {

if (count > MAX_KMALLOC_SIZE)

len = MAX_KMALLOC_SIZE;

else

len = count;

kbuf=kmalloc(len,GFP_KERNEL);

if (!kbuf) {

printk("kmalloc is null/n");

return -ENOMEM;

}

if (copy_from_user(kbuf, buf, len)) {

kfree(kbuf);

return -EFAULT;

}

ret = (*(mtd->write))(mtd, *ppos, len, &retlen, kbuf);

if (!ret) {

*ppos += retlen;

total_retlen += retlen;

count -= retlen;

buf += retlen;

}

else {

kfree(kbuf);

return ret;

}

kfree(kbuf);

}

return total_retlen;

} /* mtd_write */

mtd_erase_callback

格式：

static void mtd_erase_callback (struct erase_info *instr)

注释：

无

功能：

唤醒进程

说明：

在擦除进行完后被调用

参数：

instr：进行的擦除的erase_info结构

无

调用：

wake_up()

被调用：

在mtd_ioctl中被赋给erase_info->callback

源代码：

{

wake_up((wait_queue_head_t *)instr->priv);

}

mtd_ioctl

格式：

static int mtd_ioctl(struct inode *inode, struct file *file, u_int cmd, u_long arg)

注释：

无

功能：

MTD字符设备的IO控制

说明：

根据cmd分别处理

参数：

inode：FIXME

file：传递参数的结构

cmd：IO控制的命令

arg：IO控制的参数

成功：返回0

失败：返回错误码

调用：

无

被调用：

注册进mtd_fops结构

源代码：

{

struct mtd_info *mtd = (struct mtd_info *)file->private_data;

int ret = 0;

u_long size;

DEBUG(MTD_DEBUG_LEVEL0, "MTD_ioctl/n");

size = (cmd & IOCSIZE_MASK) >> IOCSIZE_SHIFT;

if (cmd & IOC_IN) {

ret = verify_area(VERIFY_READ, (char *)arg, size);

if (ret) return ret;

}

if (cmd & IOC_OUT) {

ret = verify_area(VERIFY_WRITE, (char *)arg, size);

if (ret) return ret;

}

switch (cmd) {

case MEMGETREGIONCOUNT:

if (copy_to_user((int *) arg, &(mtd->numeraseregions), sizeof(int)))

return -EFAULT;

break;

case MEMGETREGIONINFO:

{

struct region_info_user ur;

if (copy_from_user( &ur,

(struct region_info_user *)arg,

sizeof(struct region_info_user))) {

return -EFAULT;

}

if (ur.regionindex >= mtd->numeraseregions)

return -EINVAL;

if (copy_to_user((struct mtd_erase_region_info *) arg,

&(mtd->eraseregions[ur.regionindex]),

sizeof(struct mtd_erase_region_info)))

return -EFAULT;

break;

}

case MEMGETINFO:

if (copy_to_user((struct mtd_info *)arg, mtd,

sizeof(struct mtd_info_user)))

return -EFAULT;

break;

case MEMERASE:

{

struct erase_info *erase=kmalloc(sizeof(struct erase_info),GFP_KERNEL);

if (!erase)

ret = -ENOMEM;

else {

wait_queue_head_t waitq;

DECLARE_WAITQUEUE(wait, current);

init_waitqueue_head(&waitq);

memset (erase,0,sizeof(struct erase_info));

if (copy_from_user(&erase->addr, (u_long *)arg,

2 * sizeof(u_long))) {

kfree(erase);

return -EFAULT;

}

erase->mtd = mtd;

erase->callback = mtd_erase_callback;

erase->priv = (unsigned long)&waitq;

FIXME: Allow INTERRUPTIBLE. Which means

not having the wait_queue head on the stack.

If the wq_head is on the stack, and we

leave because we got interrupted, then the

wq_head is no longer there when the

callback routine tries to wake us up.

ret = mtd->erase(mtd, erase);

if (!ret) {

set_current_state(TASK_UNINTERRUPTIBLE);

add_wait_queue(&waitq, &wait);

if (erase->state != MTD_ERASE_DONE &&

erase->state != MTD_ERASE_FAILED)

schedule();

remove_wait_queue(&waitq, &wait);

set_current_state(TASK_RUNNING);

ret = (erase->state == MTD_ERASE_FAILED)?-EIO:0;

}

kfree(erase);

}

break;

}

case MEMWRITEOOB:

{

struct mtd_oob_buf buf;

void *databuf;

ssize_t retlen;

if (copy_from_user(&buf, (struct mtd_oob_buf *)arg, sizeof(struct mtd_oob_buf)))

return -EFAULT;

if (buf.length > 0x4096)

return -EINVAL;

if (!mtd->write_oob)

ret = -EOPNOTSUPP;

else

ret = verify_area(VERIFY_READ, (char *)buf.ptr, buf.length);

if (ret)

return ret;

databuf = kmalloc(buf.length, GFP_KERNEL);

if (!databuf)

return -ENOMEM;

if (copy_from_user(databuf, buf.ptr, buf.length)) {

kfree(databuf);

return -EFAULT;

}

ret = (mtd->write_oob)(mtd, buf.start, buf.length, &retlen, databuf);

if (copy_to_user((void *)arg + sizeof(u_int32_t), &retlen, sizeof(u_int32_t)))

ret = -EFAULT;

kfree(databuf);

break;

}

case MEMREADOOB:

{

struct mtd_oob_buf buf;

void *databuf;

ssize_t retlen;

if (copy_from_user(&buf, (struct mtd_oob_buf *)arg, sizeof(struct mtd_oob_buf)))

return -EFAULT;

if (buf.length > 0x4096)

return -EINVAL;

if (!mtd->read_oob)

ret = -EOPNOTSUPP;

else

ret = verify_area(VERIFY_WRITE, (char *)buf.ptr, buf.length);

if (ret)

return ret;

databuf = kmalloc(buf.length, GFP_KERNEL);

if (!databuf)

return -ENOMEM;

ret = (mtd->read_oob)(mtd, buf.start, buf.length, &retlen, databuf);

if (copy_to_user((void *)arg + sizeof(u_int32_t), &retlen, sizeof(u_int32_t)))

ret = -EFAULT;

else if (retlen && copy_to_user(buf.ptr, databuf, retlen))

ret = -EFAULT;

kfree(databuf);

break;

}

case MEMLOCK:

{

unsigned long adrs[2];

if (copy_from_user(adrs ,(void *)arg, 2* sizeof(unsigned long)))

return -EFAULT;

if (!mtd->lock)

ret = -EOPNOTSUPP;

else

ret = mtd->lock(mtd, adrs[0], adrs[1]);

break;

}

case MEMUNLOCK:

{

unsigned long adrs[2];

if (copy_from_user(adrs, (void *)arg, 2* sizeof(unsigned long)))

return -EFAULT;

if (!mtd->unlock)

ret = -EOPNOTSUPP;

else

ret = mtd->unlock(mtd, adrs[0], adrs[1]);

break;

}

default:

DEBUG(MTD_DEBUG_LEVEL0, "Invalid ioctl %x (MEMGETINFO = %x)/n", cmd, MEMGETINFO);

ret = -ENOTTY;

}

return ret;

} /* memory_ioctl */

mtd_fops

MTD字符设备的操作函数结构

static struct file_operations mtd_fops = {

owner: THIS_MODULE,

llseek: mtd_lseek, /* lseek */

read: mtd_read, /* read */

write: mtd_write, /* write */

ioctl: mtd_ioctl, /* ioctl */

open: mtd_open, /* open */

release: mtd_close, /* release */

};

init_mtdchar

格式：

static int __init init_mtdchar(void)

注释：

无

功能：

初始化一个MTD字符设备（设备层）

说明：

如果定义了CONFIG_DEVFS_FS{

调用devfs_register_chrdev()注册MTD字符设备

调用register_mtd_user()将设备层MTD字符设备的notifier注册进原始设备层

}

否则调用register_chrdev()注册MTD字符设备

参数：

无

成功：返回0

注册失败：返回-EAGAIN

调用：

devfs_register_chrdev()或register_chrdev()注册字符设备

被调用：

__init

module_init

源代码：

{

#ifdef CONFIG_DEVFS_FS

if (devfs_register_chrdev(MTD_CHAR_MAJOR, "mtd", &mtd_fops))

{

printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices./n",

MTD_CHAR_MAJOR);

return -EAGAIN;

}

devfs_dir_handle = devfs_mk_dir(NULL, "mtd", NULL);

register_mtd_user(&notifier);

#else

if (register_chrdev(MTD_CHAR_MAJOR, "mtd", &mtd_fops))

{

printk(KERN_NOTICE "Can't allocate major number %d for Memory Technology Devices./n",

MTD_CHAR_MAJOR);

return -EAGAIN;

}

#endif

return 0;

}

cleanup_mtdchar

格式：

static void __exit cleanup_mtdchar(void)

注释：

无

功能：

清除MTD字符设备

说明：

如果定义了CONFIG_DEVFS_FS{

调用unregister_mtd_user()注销MTD字符设备的notifier,

调用devfs_unregister_chrdev()注销MTD字符设备

}

否则调用unregister_chrdev()注销MTD字符设备

参数：

无

调用：

unregister_chrdev()或devfs_unregister_chrdev()注销字符设备

被调用：

__exit

module_exit

源代码：

{

#ifdef CONFIG_DEVFS_FS

unregister_mtd_user(&notifier);

devfs_unregister(devfs_dir_handle);

devfs_unregister_chrdev(MTD_CHAR_MAJOR, "mtd");

#else

unregister_chrdev(MTD_CHAR_MAJOR, "mtd");

#endif

}

收录于

linux驱动

标签

#代码分析 #struct #file #user #callback

详细图解MTD驱动分析存储器技术设备（英语：Memory Technology Device，缩写为 MTD），是Linux系统中设备文件系统的一个类型，主要用于闪存类驱动，是一种闪存转换层（Flash Translation Layer，FTL）。创造MTD子系统的主要目的是提供一个介于闪存硬件驱动程序与高级应用程序之间的抽象层，使新的memory设备的驱动更加简单。MTD的所有源代码在/drivers/mtd子阅读详情

MTD源代码分析(三)

mtdchar.c

相关推荐