xitong
- 浏览: 6189018 次
-
文章分类
最新评论
-
vb2005xu：
这样你跑一个1000试试,卡不死你
PHP实现斐波那契数列 -
ykbj117：
你们知道刘绍华么？就是北邮的一个教授，专门研究WebRTC的资 ...
WebRTC体系结构 -
huangbye：
其实这也没什么卵用！
thinkphp自定义标签,view直接标签连接数据 -
cofftech：
opencv源码：http://www.eyesourceco ...
opencv资料和文档 -
langke93：
wangzhengyi_nopass.key这个怎么生成没写
nginx搭建https服务器
MTD 设备驱动 和 NAND Flash 驱动程序分析。
硬件环境： 飞凌OK6410，256MB DDR，2GB NAND Flash、 NAND Flash 型号：K9G8G08U9A 、 分析源码：Linux 2.6.36.2 内核源码。
一、 MTD 设备驱动。
1、先来简单介绍一下MTD
在Linux 系统中， 提供了MTD（Memory Technology Device , 内存技术设备）系统来建立 Flash 针对 Linux 的系统、抽象的接口， MTD 将文件系统与 底层的Flash
存储器进行了隔离， 使 Flash 驱动工程师 无需关心Flash 作为字符设备和 块 设备与 LInux内核的接口。
2、在引入MTD 后Linux 系统中的Flash 设备及接口可分为4层, 从上到下依次是：设备节点、MTD 设备层、MTD原始设备层 和 硬件驱动层。 这 4 层的作用定义如下：
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 中实现，MTD 块设备则是定义在一个描述MTD 块设备的结构 mtdblk_dev ，并声明了一个名为 mtdblks 的指针数组，这个数组 中的每个mtdblk_dev
和 mtd_table 中的每一个mtd_info 一一对应。
4->设备节点： 通过mknod 在/dev 子目录下建立MTD字符设备节点 和 块设备节点，用户通过访问此此设备节点即可访问 MTD 字符设备和块设备。
3、分析Linux MTD 系统接口 mtd_info 结构体代码分析 此结构体定义在 ./include/linux/mtd/mtd.h 中
关键词词解析：
XIP ：XIPeXecute In Place，即芯片内执行，指应用程序可以直接在flash闪存内运行，不必再把代码读到系统RAM中。flash内执行
是指nor flash 不需要初始化，可以直接在flash内执行代码。但往往只执行部分代码，比如初始化RAM.
OOB ：Out Of Brower 传输层协议使用带外数据(out-of-band,OOB)来发送一些重要的数据,如果通信一方有重要的数据需要通知对方时,协议能够将这些数据
快速地发送到对方.为了发送这些数据
iovec-base : iovec 结构体基础。struct iovec定义了一个向量元素。通常，这个结构用作一个多元素的数组。对于每一个传输的元素，指针成员iov_base指向
一个缓冲区，这个缓冲区是存放的是readv所接收的数据或是writev将要发送的数据。成员iov_len在各种情况下分别确定了接收的最大长度以及实际写入的长度。
Sync : 函数， 函数说明：此函数负责将系统缓冲区的内容写回磁盘，以确保数据同步。
struct mtd_info {
u_char type; // 内存技术的类型
uint32_t flags; // 标志位
uint64_t size; // Total size of the MTD 、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
*/
uint32_t erasesize; // 主要的擦除块大小 erase size of main block
/* 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.
*/
uint32_t writesize; // 最小的可写单元的字节数
uint32_t oobsize; // Amount of OOB data per block (e.g. 16) OOB 字节数
uint32_t oobavail; // Available OOB bytes per block 可用OBB 字节数
/*
* If erasesize is a power of 2 then the shift is stored in
* erasesize_shift otherwise erasesize_shift is zero. Ditto writesize.
*/
unsigned int erasesize_shift;
unsigned int writesize_shift;
/* Masks based on erasesize_shift and writesize_shift */
unsigned int erasesize_mask;
unsigned int writesize_mask;
// Kernel-only stuff starts here.
const 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; // 不同的erasesize 的区域 数目通常是1
struct mtd_erase_region_info *eraseregions;
/*
* Erase is an asynchronous operation. Device drivers are supposed
* to call instr->callback() whenever the operation completes, even
* if it completes with a failure.
* Callers are supposed to pass a callback function and wait for it
* to be called before writing to the block.
*/
int (*erase) (struct mtd_info *mtd, struct erase_info *instr);
/* This stuff for eXecute-In-Place */
/* phys is optional and may be set to NULL */
int (*point) (struct mtd_info *mtd, loff_t from, size_t len, // 针对 eXecute-In- Place
size_t *retlen, void **virt, resource_size_t *phys);
/* We probably shouldn't allow XIP if the unpoint isn't a NULL */
void (*unpoint) (struct mtd_info *mtd, loff_t from, size_t len); // 如果unpoint 为空，不允许 XIP
/* Allow NOMMU mmap() to directly map the device (if not NULL)
* - return the address to which the offset maps
* - return -ENOSYS to indicate refusal to do the mapping
*/
unsigned long (*get_unmapped_area) (struct mtd_info *mtd,
unsigned long len,
unsigned long offset,
unsigned long flags);
/* Backing device capabilities for this device
* - provides mmap capabilities
*/
struct backing_dev_info *backing_dev_info;
int (*read) (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf); // 读 flash
int (*write) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf); // 写 flash
/* In blackbox flight recorder like scenarios we want to make successful
writes in interrupt context. panic_write() is only intended to be
called when its known the kernel is about to panic and we need the
write to succeed. Since the kernel is not going to be running for much
longer, this function can break locks and delay to ensure the write
succeeds (but not sleep). */
int (*panic_write) (struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf); // Kernel panic 时序读写
int (*read_oob) (struct mtd_info *mtd, loff_t from, // 读 out-of-band
struct mtd_oob_ops *ops);
int (*write_oob) (struct mtd_info *mtd, loff_t to, // 写 out-of-band
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); // iovec-based 读写函数
/* Sync */
void (*sync) (struct mtd_info *mtd); // Sync
/* Chip-supported device locking */
int (*lock) (struct mtd_info *mtd, loff_t ofs, uint64_t len); // 设备锁
int (*unlock) (struct mtd_info *mtd, loff_t ofs, uint64_t len);
int (*is_locked) (struct mtd_info *mtd, loff_t ofs, uint64_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;
struct device dev;
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 中的 read(). write(). read_oob(). write_oob(). erase() 是 MTD 设备驱动主要实现的函数。在在后面我将要介绍的nand flahs 驱动中几乎看不到mtd_info
的成员函数（也就是说这些函数对于Flash 芯片来说是透明的），这是因为在Linux MTD 下层实现了针对 NOR、NAND Flsh 的同游mtd_info 成员函数。
Flash 驱动中使用如下两个函数来注册 和注销MTD 设备：
int add_mtd_device(struct mtd_info *mtd);
int del_mtd_device (struct mtd_info *mtd)
4、mtd_part 结构体分析 此结构定义在 ../drivers/mtd/mtdpart.c 中
struct mtd_part {
struct mtd_info mtd; // 分区的信息（大部分由其 master 决定）
struct mtd_info *master; // 该分区的主分区
uint64_t offset; // 分区的偏移地址
struct list_head list; // 分区号
};
mtd_part 结构体由于表示分区，它在mtd_info 结构体成员用于描述该分区， 它会被加入到 mtd_table （定义为 struct mtd_info *mtd_table[MAX_MTD_DEVICES]）中，
其大部分成员有 mtd_part—> 决定，各种函数也指向主分区的相应函数。
5、mtd_partition 结构体分析 该结构体定义在 include/linux/mtd/partitions.h 中
struct mtd_partition {
char *name; /* identifier string */ // 标识字符串
uint64_t size; /* partition size */ // 分区大小
uint64_t offset; /* offset within the master MTD space */ // 主MTD空间内的偏移量
uint32_t mask_flags; /* master MTD flags to mask out for this partition */ // 掩码标志
struct nand_ecclayout *ecclayout; /* out of band layout for this partition (NAND only)*/
};
mtd_partttion 会在MTD 原始设备层调用 add_mtd_partitons() 时传递分区信息，并通过下面两个函数进行注册和注销 分区：
int add_mtd_partitions( struct mtd_info *master, struct mtd_partition *parts, int nbparts); int del_mtd_partitions (struct mtd_info *master);add_mtd_partitions() 会对每一个新建立的分区建立一个新的 mtd_part 结构体，将其加入 mtd_partitions 中，并调用 add_mtd_device () 将此分区作为 MTD 设备加入 mtd_tabe。
第二、NAND Flash 驱动程序分析：
Linux 内核在 MTD的下层实现了通用NAND 驱动（主要通过 drivers/mtd/nand/nand_base.c 文件实现），因此芯片级的驱动不再需要实现 mtd_info 中的： read(), write() ,
read_oob(), write_oob 等成员函数，而主体 转移到了 nand_chip 数据结构。
关键词解析：
ALE：地址锁存使能(Address Latch Enable, ALE)：当ALE为高时，在WE#信号的上升沿，地址被锁存到NAND地址寄存器中。
CLE：指令锁存使能(Command Latch Enable, CLE):
当CLE为高时，在WE#信号的上升沿，指令被锁存到NAND指令寄存器中。
BSP：Board Support Package
1、nand_chip 结构体分析 该结构体定义在 ./include/linux/mtd/nand.h
struct nand_chip {
void __iomem *IO_ADDR_R; // 读 8 位 I/O 线地址，由主板决定
void __iomem *IO_ADDR_W; // 写 8 为 I/O 线地址，由主板决定
uint8_t (*read_byte)(struct mtd_info *mtd);
u16 (*read_word)(struct mtd_info *mtd);
void (*write_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
void (*read_buf)(struct mtd_info *mtd, uint8_t *buf, int len);
int (*verify_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
void (*select_chip)(struct mtd_info *mtd, int chip); // 片选芯片
int (*block_bad)(struct mtd_info *mtd, loff_t ofs, int getchip); // 是否为坏块
int (*block_markbad)(struct mtd_info *mtd, loff_t ofs); // 标记坏块
void (*cmd_ctrl)(struct mtd_info *mtd, int dat,
unsigned int ctrl); // 控制 AEL/CLE/nCE, 也用于写命令 和 地址
int (*dev_ready)(struct mtd_info *mtd); // 设备就绪
void (*cmdfunc)(struct mtd_info *mtd, unsigned command, int column, int page_addr);
int (*waitfunc)(struct mtd_info *mtd, struct nand_chip *this);
void (*erase_cmd)(struct mtd_info *mtd, int page);
int (*scan_bbt)(struct mtd_info *mtd);
int (*errstat)(struct mtd_info *mtd, struct nand_chip *this, int state, int status, int page);
int (*write_page)(struct mtd_info *mtd, struct nand_chip *chip,
const uint8_t *buf, int page, int cached, int raw);
int chip_delay;
unsigned int options;
int page_shift;
int phys_erase_shift;
int bbt_erase_shift;
int chip_shift;
int numchips;
uint64_t chipsize;
int pagemask;
int pagebuf;
int subpagesize;
uint8_t cellinfo;
int badblockpos;
int badblockbits;
flstate_t state;
uint8_t *oob_poi;
struct nand_hw_control *controller;
struct nand_ecclayout *ecclayout;
struct nand_ecc_ctrl ecc;
struct nand_buffers *buffers;
struct nand_hw_control hwcontrol;
struct mtd_oob_ops ops;
uint8_t *bbt;
struct nand_bbt_descr *bbt_td;
struct nand_bbt_descr *bbt_md;
struct nand_bbt_descr *badblock_pattern;
void *priv;
};
MTD 使用 nand_chip 数据结构表示一个NAND Flash 芯片，这个结构体中包含了关于 NAND Flash 的地址信息、读写方法、ECC模式、硬件控制等一系列底层机制。
2、S3C6410 nand_chip 初始化 与 NAND 探测
S3C6410 的 NAND 驱动以 platform 驱动的形式存在，在执行probe() 时，初始化nand_chip 实例并运行 nand_scan 扫描 NAND 设备， 最后调用 add_mtd_partitions() 添加主板中定义的分区表，nand_chip 是nanf flash 驱动的核心数据结构，这个结构体重的成员直接对应这 NAND Flash 的底层操作，针对具体情况的NAND 控制器情况
分析 s3c_nand_probe 函数体对 S3C6410 nand_chip 的初始化和注册： 该文件定义在 drivers/mtd/nand/s3c_nand.c 中，而在基础内核2.6.36.2 中的这个文件为s3c2410.c
所以如果你想在 Linux 2.6.36.2 的内核对 S3C6410 nand flash 控制器进行支持的话，s3c_nand.c 这个文件需要自己添加。
static int s3c_nand_probe(struct platform_device *pdev, enum s3c_cpu_type cpu_type)
{
struct s3c2410_platform_nand *plat = pdev->dev.platform_data;
struct s3c2410_nand_set *sets;
struct nand_chip *nand;
struct resource *res;
int err = 0;
int ret = 0;
int nr_sets;
int i, j, size;
#if defined(CONFIG_MTD_NAND_S3C_HWECC)
struct nand_flash_dev *type = NULL;
u_char tmp;
u_char dev_id;
#endif
/* get the clock source and enable it */
s3c_nand.clk = clk_get(&pdev->dev, "nand");
if (IS_ERR(s3c_nand.clk)) {
dev_err(&pdev->dev, "failed to get clock");
err = -ENOENT;
goto exit_error;
}
clk_enable(s3c_nand.clk);
/* allocate and map the resource */
/* currently we assume we have the one resource */
res = pdev->resource;
size = res->end - res->start + 1;
s3c_nand.area = request_mem_region(res->start, size, pdev->name);
if (s3c_nand.area == NULL) {
dev_err(&pdev->dev, "cannot reserve register region\n");
err = -ENOENT;
goto exit_error;
}
s3c_nand.cpu_type = cpu_type;
s3c_nand.device = &pdev->dev;
s3c_nand.regs = ioremap(res->start, size);
s3c_nand.platform = plat;
if (s3c_nand.regs == NULL) {
dev_err(&pdev->dev, "cannot reserve register region\n");
err = -EIO;
goto exit_error;
}
sets = (plat != NULL) ? plat->sets : NULL;
nr_sets = (plat != NULL) ? plat->nr_sets : 1;
s3c_nand.mtd_count = nr_sets;
/* allocate memory for MTD device structure and private data */
s3c_mtd = kmalloc(sizeof(struct mtd_info) + sizeof(struct nand_chip), GFP_KERNEL);
if (!s3c_mtd) {
printk("Unable to allocate NAND MTD dev structure.\n");
return -ENOMEM;
}
/* Get pointer to private data */
nand = (struct nand_chip *) (&s3c_mtd[1]);
/* Initialize structures */
memset((char *) s3c_mtd, 0, sizeof(struct mtd_info));
memset((char *) nand, 0, sizeof(struct nand_chip));
/* Link the private data with the MTD structure */
s3c_mtd->priv = nand;
for (i = 0; i < sets->nr_chips; i++) {
nand->IO_ADDR_R = (char *)(s3c_nand.regs + S3C_NFDATA); // 初始化 IO_ADDR_R
nand->IO_ADDR_W = (char *)(s3c_nand.regs + S3C_NFDATA); // 初始化 IO_ADDR_W
nand->cmd_ctrl = s3c_nand_hwcontrol; // 初始化 cmd_crtl()
nand->dev_ready = s3c_nand_device_ready; // 初始化 dev_read()
nand->scan_bbt = s3c_nand_scan_bbt; // 初始化 scan_bbt()
nand->options = 0;
#if defined(CONFIG_MTD_NAND_S3C_CACHEDPROG)
nand->options |= NAND_CACHEPRG;
#endif
#if defined(CONFIG_MTD_NAND_S3C_HWECC)
nand->ecc.mode = NAND_ECC_HW;
nand->ecc.hwctl = s3c_nand_enable_hwecc;
nand->ecc.calculate = s3c_nand_calculate_ecc;
nand->ecc.correct = s3c_nand_correct_data;
s3c_nand_hwcontrol(0, NAND_CMD_READID, NAND_NCE | NAND_CLE | NAND_CTRL_CHANGE);
s3c_nand_hwcontrol(0, 0x00, NAND_CTRL_CHANGE | NAND_NCE | NAND_ALE);
s3c_nand_hwcontrol(0, 0x00, NAND_NCE | NAND_ALE);
s3c_nand_hwcontrol(0, NAND_CMD_NONE, NAND_NCE | NAND_CTRL_CHANGE);
s3c_nand_device_ready(0);
tmp = readb(nand->IO_ADDR_R); /* Maf. ID */ // 制造商ID
dev_id = tmp = readb(nand->IO_ADDR_R); /* Device ID */ // 设备ID
for (j = 0; nand_flash_ids[j].name != NULL; j++) {
if (tmp == nand_flash_ids[j].id) {
type = &nand_flash_ids[j];
break;
}
}
if (!type) {
printk("Unknown NAND Device.\n");
goto exit_error;
}
nand->cellinfo = readb(nand->IO_ADDR_R); /* the 3rd byte */ // 第3个字节
tmp = readb(nand->IO_ADDR_R); /* the 4th byte */ // 第4个字节
if (!type->pagesize) {
if (((nand->cellinfo >> 2) & 0x3) == 0) {
nand_type = S3C_NAND_TYPE_MLC_4BIT;
nand->options |= NAND_NO_SUBPAGE_WRITE; /* NOP = 1 if MLC */
nand->ecc.read_page = s3c_nand_read_page_4bit;
nand->ecc.write_page = s3c_nand_write_page_4bit;
nand->ecc.size = 512;
nand->ecc.bytes = 8; /* really 7 bytes */
if ((1024 << (tmp & 0x3)) > 512) {
nand->ecc.layout = &s3c_nand_oob_mlc_64;
} else {
nand->ecc.layout = &s3c_nand_oob_16;
}
/*
nand_type = S3C_NAND_TYPE_SLC;
nand->ecc.size = 512;
nand->ecc.bytes = 4;
if ((1024 << (tmp & 0x3)) > 512) {
nand->ecc.read_page = s3c_nand_read_page_1bit;
nand->ecc.write_page = s3c_nand_write_page_1bit;
nand->ecc.read_oob = s3c_nand_read_oob_1bit;
nand->ecc.write_oob = s3c_nand_write_oob_1bit;
nand->ecc.layout = &s3c_nand_oob_64;
} else {
nand->ecc.layout = &s3c_nand_oob_16;
}
*/
} else {
nand_type = S3C_NAND_TYPE_MLC_4BIT;
nand->options |= NAND_NO_SUBPAGE_WRITE; /* NOP = 1 if MLC */
nand->ecc.read_page = s3c_nand_read_page_4bit;
nand->ecc.write_page = s3c_nand_write_page_4bit;
nand->ecc.size = 512;
nand->ecc.bytes = 8; /* really 7 bytes */
nand->ecc.layout = &s3c_nand_oob_mlc_64;
if(dev_id == 0xd5)
{
printk("dev_id == 0xd5 select s3c_nand_oob_mlc_128\n");
nand_type = S3C_NAND_TYPE_MLC_8BIT;
nand->ecc.read_page = s3c_nand_read_page_8bit;
nand->ecc.write_page = s3c_nand_write_page_8bit;
nand->ecc.size = 512;
nand->ecc.bytes = 13; /* really 7 bytes */
nand->ecc.layout = &s3c_nand_oob_mlc_128_8bit;
}
}
} else {
nand_type = S3C_NAND_TYPE_SLC;
nand->ecc.size = 512;
nand->cellinfo = 0;
nand->ecc.bytes = 4;
nand->ecc.layout = &s3c_nand_oob_16;
}
printk("S3C NAND Driver is using hardware ECC.\n");
#else
nand->ecc.mode = NAND_ECC_SOFT;
printk("S3C NAND Driver is using software ECC.\n");
#endif
if (nand_scan(s3c_mtd, 1)) {
ret = -ENXIO;
goto exit_error;
}
/* Register the partitions */
add_mtd_partitions(s3c_mtd, sets->partitions, sets->nr_partitions); // 注册分区信息
}
pr_debug("initialized ok\n");
return 0;
exit_error:
kfree(s3c_mtd);
return ret;
}
drivers/mtd/nand/s3c_nand.c 是一个platform 驱动， 加入我们需要移植 OK6410 的 NAND Flash 驱动这要在 OK6410 的BSP（板级支持包）中田间针对 NAND 的 platform 设备和 分区信息即可，也就是在 arch/arm/mach-s3c64xx/mach-smdk6410.c 中添加这些信息，就可以将上面的NAND Flash 驱动移植成功。
参考文献：设备驱动开发详解（第2版） 华清远见 宋宝华著
NAND Flash驱动移植方法、可以参考我的上篇博文：http://blog.csdn.net/acanoe/article/details/7516341
将这篇博文和上一篇博文一起来阅读，理解 NAND Flash驱动就能容易些了。
分享到：
发表评论
相关推荐
Linux MTD 下获取Nand flash 各个参数的过程的详细解析
MTD说明 Flash底层驱动设计 nand底层驱动设计
nandflash 驱动源代码，利用ARM 7，开发环境ADS1.2
MTD原始设备MTD原始设备与FLASH硬件驱动的对话与FLASH硬件驱动的对话
本文档详细分析了nand flash做为字符设备的驱动流程，对nand flash的应用开发有非常大的帮助。
Linux内核MTD驱动程序与SD卡驱动程序.doc
MTD技术设备驱动框架,深入分析linux MTD技术设备的原理，列出直观框架图
再从Flash硬件机制开始，介绍到Nand Flash的常见的物理特性，且深入介绍了Nand Flash的一些高级功能，然后开始介绍Linux下面和Nand Flash相关的软件架构MTD的相关知识，最后介绍了在Linux的MTD驱动框架下，...
Vxworks下nand flash驱动程序。MTD驱动。
本文主要介绍了Nand Flash的各种硬件背景知识，以及Linux框架下的MTD等软件背景知识，最后介绍了在Linux的MTD驱动框架下，如何实现Nand Flash的驱动。
Linux MTD下获取Nand flash各个参数的过程的详细解析
本文主要介绍了Nand Flash的一些背景知识，以及详尽分析了nand_base.c中的nand_get_flash_type函数每一步骤的作用。
2.3.1 Nand Flash相关规范 – ONFI和LBA 32 2.3.1.1 ONFI是什么 32 2.3.1.2 LBA规范是什么 35 2.3.1.3 为何会有ONFI和LBA 36 2.3.1.4 ONFI和LBA的区别和联系 36 2.3.2 内存技术设备，MTD（Memory Technology Device...
linux在TQ2440上移植2--Nandflash驱动，MTD分区----经典
硬件驱动层linux MTD 设备的驱动程序，根据不同的 MTD 设备他们存放在不同目录，如 NAND FLASH 驱 动 存 放 在 /driver/mtd/
nandflash k9g808u0a在pxa270的驱动,由于pxa270没有nandflash接口，所以通过pc card接口进行模拟
基于MTD的NAND驱动开发,通用的东西，大家看看吧！
MTD驱动分析