【详解】如何编写Linux下Nand Flash驱动
版本: 1.7
作者：crifan
邮箱: green-waste(At)https://www.doczj.com/doc/4113432593.html,
版本历史
目录
1 正文之前 (5)
1.1 目的 (5)
1.2 目标读者和阅读此文的前提 (5)
1.3 说明 (5)
1.4 声明 (5)
2 编写驱动之前要了解的知识 (6)
2.1 一些相关的名词的解释 (6)
2.1.1 Non-V olatile Memory非易失性存储器 (6)
2.1.2 OTP（One Time Programmable）一次性可编程存储器 (6)
2.1.3 NDA（None-Disclosure Agreement） (6)
2.1.4 Datasheet数据手册和Specification规范 (6)
2.1.5 Nand Flash相关的一些名词解释 (7)
2.1.5.1 （Bad）Block Management（坏）块管理 (7)
2.1.5.2 Wear-Levelling负载平衡 (7)
2.1.5.3 ECC（Error Correction Code）错误校验（代码） (7)
2.2 硬件特性 (8)
2.2.1 什么是Flash (8)
2.2.1.1 Flash的硬件实现机制 (8)
2.2.2 什么是Nand Flash (8)
2.2.2.1 Nand Flash和Nor Flash的区别 (9)
2.2.2.2 Nand Flash的详细分类 (10)
2.2.3 SLC和MLC的实现机制 (10)
2.2.3.1 SLC（Single Level Cell） (10)
2.2.3.2 MLC（Multi Level Cell） (10)
2.2.3.3 关于如何识别SLC还是MLC (10)
2.2.4 Nand Flash数据存储单元的整体架构 (11)
2.2.5 Nand Flash的物理存储单元的阵列组织结构 (12)
2.2.5.1 Block块 (12)
2.2.5.2 Page页 (12)
2.2.5.3 oob / Redundant Area / Spare Area (12)
2.2.6 Flash名称的由来 (13)
2.2.7 Flash相对于普通设备的特殊性 (13)
2.2.8 Nand Flash引脚(Pin)的说明 (14)
2.2.8.1 为何需要ALE和CLE (15)
2.2.8.2 Nand Flash只有8个I/O引脚的好处 (15)
2.2.8.2.1 减少外围连线： (15)
2.2.8.2.2 提高系统的可扩展性 (16)
2.2.9 Nand flash的一些典型(typical)的特性 (16)
2.2.10 Nand Flash控制器与Nand Flash芯片 (16)
2.2.11 Nand Flash中的特殊硬件结构 (16)
2.2.12 Nand Flash中的坏块(Bad Block) (17)
2.2.12.1 坏块的分类 (17)
2.2.12.2 坏块的标记 (17)
2.2.12.3 坏块的管理 (18)
2.2.12.4 坏块的比例 (18)
2.2.13 Nand Flash中页的访问顺序 (18)
2.2.14 常见的Nand Flash的操作 (18)
2.2.14.1 页编程（Page Program）注意事项 (19)
2.2.14.2 读（Read）操作过程详解 (20)
2.2.14.2.1 需要使用何种命令 (20)
2.2.14.2.2 发送命令前的准备工作以及时序图各个信号的具体含义 (20)
2.2.14.2.3 如何计算出我们要传入的行地址和列地址 (22)
2.2.14.2.4 读操作过程的解释 (25)
2.2.15 Nand Flash的一些高级特性 (26)
2.2.15.1 Nand Flash的Unique ID (26)
2.2.15.1.1 什么是Unique ID唯一性标识 (26)
2.2.15.1.2 不同Nand Flash厂商的对Unique ID的不同的实现方法 (26)
2.2.15.1.2.1 Toshiba东芝的Nand的Unique ID (26)
2.2.15.1.2.2 读取Toshiba的Nand的Unique ID (27)
2.2.15.1.3 Samsung三星的Nand的Unique ID (27)
2.2.15.1.3.1 读取Samsung的Nand的Unique ID (28)
2.2.15.1.4 遵循ONFI规范的厂商的Nand的Unique ID (28)
2.2.15.1.4.1 读取遵循ONFI的厂商的Nand的Unique ID (29)
2.2.15.2 片选无关(CE don’t-care)技术 (30)
2.2.15.3 带EDC的拷回操作以及Sector的定义（Copy-Back Operation with
EDC & Sector Definition for EDC） (31)
2.2.15.4 多片同时编程(Simultaneously Program Multi Plane) (31)
2.2.15.5 交错页编程（Interleave Page Program） (32)
2.2.15.6 随机输出页内数据（Random Data Output In a Page） (32)
2.3 软件方面 (32)
2.3.1 Nand Flash相关规范– ONFI和LBA (32)
2.3.1.1 ONFI是什么 (32)
2.3.1.1.1 ONFI Block Abstracted NAND (34)
2.3.1.1.2 ONFI的好处 (35)
2.3.1.2 LBA规范是什么 (35)
2.3.1.3 为何会有ONFI和LBA (36)
2.3.1.3.1 技术层面的解释 (36)
2.3.1.3.2 现实层面的解释 (36)
2.3.1.4 ONFI和LBA的区别和联系 (36)
2.3.1.4.1 ONFI和LBA的区别 (36)
2.3.1.4.2 ONFI和LBA的联系 (36)
2.3.2 内存技术设备，MTD（Memory Technology Device） (36)
2.3.2.1 Linux MTD中检测不同类型Nand Flash的ID部分的代码 (37)
2.3.3 读操作的硬件到软件的映射 (42)
2.3.4 Nand flash驱动工作原理 (47)
3 Linux下Nand Flash驱动编写步骤简介 (49)
3.1 对于驱动框架部分 (49)
3.2 对于Nand Flash底层操作实现部分 (49)
4 引用文章 (52)
图表
图表 1 典型的Flash内存单元的物理结构 (8)
图表 2 Nand Flash 和Nor Flash的区别 (9)
图表 3 Nand Flash 第3个ID的含义 (11)
图表 4 Nand Flash物理存储单元的阵列组织结构 (12)
图表 5 Flash和普通设备相比所具有的特殊性 (13)
图表 6 Nand Flash引脚功能说明 (14)
图表7 Nand Flash引脚功能的中文说明 (15)
图表8 Nand Flash读写时的数据流向 (17)
图表9 Nand Flash K9K8G08U0A的命令集合 (19)
图表10 Nand Flash数据读取操作的时序图 (21)
图表11 Nand Flash的地址周期组成 (22)
图表12 Toshiba的Unique ID (27)
图表13 ONFI的参数页数据结构定义 (29)
图表14 ONFI中Unique ID的结构 (30)
图表15 ONFI中Read Unique ID命令的时序图 (30)
图表16 ONFI中的Nand Flash的命令集合 (34)
图表17 MTD设备和硬盘设备之间的区别 (37)
图表18 Nand Flash数据读取操作的时序图 (43)
缩略词
1正文之前
1.1目的
本文的主要目的是，看了之后，你应该对Nand Flash的硬件特性以及对应的Linux下软件平台有了基本的认识，进一步地，对如何实现Linux下的Nand Flash的驱动，知道要做哪些事情了，以及大概是如何实现的。这样，如果有了对应的开发环境，你就可以自己去实现Nand Flash的驱动了。
不过额外提示一句的是，写出代码，并不代表你就完全搞懂了整个系统的流程。而且已经写好的代码，很可能有bug，要你不断地调试，通过调试，你才会对整个系统以及Nand Flash 的方方面面有个更深入的了解的。
而且，你会发现，为了写驱动那点代码之前，却要弄懂太多的东西，包括硬件的工作原理，软件的协议规范，软件的逻辑架构等等，最后才能去实现你的驱动，所以有人会说，你写驱动不是很简单嘛，不就是写那几行代码吗，对此，一个经典的回答就是，对于整个写驱动的工作的价值算作100元的话，写代码值1块钱，但是知道怎么写，值99块钱。^_^
1.2目标读者和阅读此文的前提
正因为此文目的是让你搞懂如何在Linux下面实现Nand Flash的驱动，所以，目标读者就是，希望对Nand Flash硬件知识有一定了解，和想要在Linux下面实现Nand Flash驱动的读者。而阅读此文的前提，是要有一些基本的软硬件基础知识，和了解如何在v2.6内核之后Linux 的下面开发驱动的流程。有了这些知识，再看本文，然后你才能清楚真正要去实现Nand Flash 的驱动，是如何下手。
1.3说明
本文的逻辑是，先介绍Nand Flash的一些基本的硬件知识，然后详细分析Nand Flash的Read 操作的具体的流程，清楚硬件实现的逻辑，接着介绍软件平台，即Linux下面和Nand Flash 相关的内容，这样，硬件和软件都清楚是怎么回事了，然后再介绍如何去在Linux的架构下，实现Nand Flash驱动。
之前写的版本，虽然前面关于Nand Flash的内容介绍的比较详细，但是后面关于相关的MTD 知识，尤其是Linux的MTD的架构和如何实现具体的Nand的Flash的操作等部分的内容，写的很简略，导致有些读者看了后，觉得是，关于如何写驱动，和没说差不多，呵呵。
因此，现在继续更新，将更详细的解释，如何从硬件Nand Flash的规范，一步步映射到具体的软件实现的过程，这样，使得读者更明白其中的内在逻辑，然后接着再介绍如何在理解了软硬件各自的所具有的功能，以及Linux的MTD系统，已经帮你实现了哪些功能，然后才会更加明白，余下的要实现的软件部分，就是你所要实现的Linux下的Nand Flash的驱动部分了。
1.4声明
关于此贴版权问题，欢迎转载，但是希望注明联系方式，至少其他人看到被转帖的内容，如果有疑问，建议和意见，可以及时与笔者沟通：green-waste (at) https://www.doczj.com/doc/4113432593.html,。
2编写驱动之前要了解的知识
2.1一些相关的名词的解释
2.1.1Non-Volatile Memory非易失性存储器
NV （RAM）Memory，断电数据也不会丢失的存储器，比如Nand Flash，Nor Flash，硬盘等等。于此相对的是，断电了数据会丢失的存储器，比如DRAM等。
2.1.2OTP（One Time Programmable）一次性可编程存储
器
OTP，一种非易失性存储器，但是只允许一次性写入数据，写入（或称烧写）数据之后，就不能修改了。
OTP的好处或者说用途是，常用于写入一些和芯片相关的一些特定数据，用于加密的一些数据等。
与一次性写入数据的OTP相对应的是，像Nand Flash，硬盘等存储器，可以被多次写入数据。只要硬盘这类的存储器没坏，你高兴写入几次就写入几次，而OTP就只能写入一次，就没法再修改里面的数据了。
2.1.3NDA（None-Disclosure Agreement）
NDA，中文可以翻译为，非公开协议，保密协议。
说白了，还是一种协议，常用于这种情况：
某家厂商的某种技术或资料，是保密的，不希望公开的。
但是呢，如果你要用他家的芯片啊之类的东西，在开发过程中，又必须得到对应的技术和资料，才能开发产品，所以，他就会要求和你签订这样的NDA协议，意思就是，你可以用我的技术和资料，但是你不能公开给（我未授权的）其他人。如果非法泄露我的机密技术，那我肯定要走法律程序控告你，之类的。
2.1.4Datasheet数据手册和Specification规范
英文datasheet，中文一般翻译为数据手册。
指的是对应某个硬件，多为芯片，的功能说明，定义了如何操作该硬件，达到你要的功能，这其中主要包括芯片中的相关寄存器的定义，如何发送命令，发送什么命令，以此来操作此硬件等等。
而英文Specification，引文常缩写为Spec.，中文一般翻译为规范。
多指某个组织（盈利的或非盈利的），定义了一些规矩，如果你要用某种东西，在计算机领域，常常指的是某硬件和相关的软件协议，就要按照此规矩来操作，人家这个组织呢，保证你只要实现了此规范，设备就能按照你所期望的运行，能够实现对应的功能，而你的芯片实现了此规范，就叫做，是和此规范兼容（compatible）的。
2.1.5Nand Flash相关的一些名词解释
2.1.5.1（Bad）Block Management（坏）块管理
Nand Flash由于其物理特性，只有有限的擦写次数，超过那个次数，基本上就是坏了。在使用过程中，有些Nand Flash的block会出现被用坏了，当发现了，要及时将此block标注为坏块，不再使用。
于此相关的管理工作，属于Nand Flash的坏块管理的一部分工作。
2.1.5.2Wear-Levelling负载平衡
Nand Flash的block的管理，还包括负载平衡。
正是由于Nand Flash的block，都是有一定寿命限制的，所以如果你每次都往同一个block 擦除然后写入数据，那么那个block就很容易被用坏了，所以我们要去管理一下，将这么多次的对同一个block的操作，平均分布到其他一些block上面，使得在block的使用上，相对较平均，这样相对来说，可以更能充分利用Nand Flash。
关于wear-leveling这个词，再简单解释一下，wear就是穿（衣服）等，用（东西）导致磨损，而leveling就是使得均衡，所以放在一起就是，使得对于Nand Flash的那么多的block 的使用磨损，相对均衡一些，以此延长Nand Flash的使用寿命或者说更加充分利用Nand Flash。
2.1.5.3ECC（Error Correction Code）错误校验（代码）
Nand Flash物理特性上使得其数据读写过程中会发生一定几率的错误，所以要有个对应的错误检测和纠正的机制，于是才有此ECC，用于数据错误的检测与纠正。Nand Flash的ECC，常见的算法有海明码和BCH，这类算法的实现，可以是软件也可以是硬件。不同系统，根据自己的需求，采用对应的软件或者是硬件。
相对来说，硬件实现这类ECC算法，肯定要比软件速度要快，但是多加了对应的硬件部分，所以成本相对要高些。如果系统对于性能要求不是很高，那么可以采用软件实现这类ECC 算法，但是由于增加了数据读取和写入前后要做的数据错误检测和纠错，所以性能相对要降低一些，即Nand Flash的读取和写入速度相对会有所影响。
其中，Linux中的软件实现ECC算法，即NAND_ECC_SOFT模式，就是用的对应的海明码。而对于目前常见的MLC的Nand Flash来说，由于容量比较大，动辄2GB，4GB，8GB等，常用BCH算法。BCH算法，相对来说，算法比较复杂。
笔者由于水平有限，目前仍未完全搞懂BCH算法的原理。
BCH算法，通常是由对应的Nand Flash的Controller中，包含对应的硬件BCH ECC模块，实现了BCH算法，而作为软件方面，需要在读取数据后，写入数据之前，分别操作对应BCH 相关的寄存器，设置成BCH模式，然后读取对应的BCH状态寄存器，得知是否有错误，和生成的BCH校验码，用于写入。
其具体代码是如何操作这些寄存器的，由于是和具体的硬件，具体的nand flash的controller 不同而不同，无法用同一的代码。如果你是nand flash驱动开发者，自然会得到对应的起nand flash的controller部分的datasheet，按照手册说明，去操作即可。
不过，额外说明一下的是，关于BCH算法，往往是要从专门的做软件算法的厂家购买的，但是Micron之前在网上放出一个免费版本的BCH算法。
想要下载此免费的BCH算法，可以在这里找到地址：
【下载】4 bits纠错的BCH源代码（常用于MLC nand Flash的ECC算法）
https://www.doczj.com/doc/4113432593.html,/serial_story/blog/item/c4e826d8988aa13932fa1cc6.html
2.2硬件特性
2.2.1什么是Flash
Flash全名叫做Flash Memory，从名字就能看出，是种数据存储设备，存储设备有很多类，Flash属于非易失性存储设备(Non-volatile Memory Device)，与此相对应的是易失性存储设备(V olatile Memory Device)。关于什么是非易失性/易失性，从名字中就可以看出，非易失性就是不容易丢失，数据存储在这类设备中，即使断电了，也不会丢失，这类设备，除了Flash，还有其他比较常见的入硬盘，ROM等，与此相对的，易失性就是断电了，数据就丢失了，比如大家常用的内存，不论是以前的SDRAM，DDR SDRAM，还是现在的DDR2，DDR3等，都是断电后，数据就没了。
2.2.1.1Flash的硬件实现机制
Flash的内部存储是MOSFET，里面有个悬浮门(Floating Gate)，是真正存储数据的单元。
在Flash之前，紫外线可擦除(uv-erasable)的EPROM，就已经采用了Floating Gate存储数据这一技术了。
图表 1 典型的Flash内存单元的物理结构
数据在Flash内存单元中是以电荷(electrical charge) 形式存储的。存储电荷的多少，取决于图中的外部门（external gate）所被施加的电压，其控制了是向存储单元中冲入电荷还是使其释放电荷。而数据的表示，以所存储的电荷的电压是否超过一个特定的阈值Vth来表示，因此，Flash的存储单元的默认值，不是0（其他常见的存储设备，比如硬盘灯，默认值为0），而是1，而如果将电荷释放掉，电压降低到一定程度，表述数字0。
2.2.2什么是Nand Flash
Flash主要分两种，Nand Flash和nor flash。
关于Nand Flash和Nor Flash的区别，参见【附录5】。
不过，关于两者区别，除了那个解释之外，这里再多解释解释：
1.Nor的成本相对高，容量相对小，比如常见的只有128KB，256KB，1MB，2MB等等，优点是读写数据时候，不容易出错。所以在应用领域方面，Nor Flash比较适合应用于存储少量的代码。
2.Nand flash成本相对低，说白了就是便宜，缺点是使用中数据读写容易出错，所以一般都需要有对应的软件或者硬件的数据校验算法，统称为ECC。但优点是，相对来说容量比较大，现在常见的Nand Flash都是1GB，2GB，更大的8GB的都有了，相对来说，价格便宜，因此适合用来存储大量的数据。其在嵌入式系统中的作用，相当于PC上的硬盘，用于存储
大量数据。
所以，一个常见的应用组合就是，用小容量的Nor Flash存储启动代码，比如uboot，用大容量的Nand Flash做整个系统和用户数据的存储。
而一般的嵌入式平台的启动流程也就是，系统从装有启动代码的Nor Flash启动后，初始化对应的硬件，包括SDRAM等，然后将Nand Flash上的Linux 内核读取到内存中，做好该做的事情后，就跳转到SDRAM中去执行内核了，然后内核解压（如果是压缩内核的话，否则就直接运行了）后，开始运行，在Linux内核启动最后，去Nand Flash上，挂载根文件，比如jffs2，yaffs2等，挂载完成，运行初始化脚本，启动consle交互，才运行你通过console 和内核交互。至此完成整个系统启动过程。
而Nor Flash就分别存放的是Uboot，Nand Flash存放的是Linux的内核镜像和根文件系统，以及余下的空间分成一个数据区。
2.2.2.1Nand Flash和Nor Flash的区别
Nor flash，有类似于dram之类的地址总线，因此可以直接和CPU相连，CPU可以直接通过地址总线对nor flash进行访问，而Nand Flash没有这类的总线，只有IO接口，只能通过IO 接口发送命令和地址，对Nand Flash内部数据进行访问。相比之下，nor flash就像是并行访问，Nand Flash就是串行访问，所以相对来说，前者的速度更快些。
但是由于物理制程/制造方面的原因，导致nor 和nand在一些具体操作方面的特性不同：
图表 2 Nand Flash 和Nor Flash的区别
（1）理论上是可以的，而且也是有人验证过可以的，只不过由于Nand Flash的物理特性，不能完全保证所读取的数据/代码是正确的，实际上，很少这么用而已。因为，如果真是要用到Nand Flash做XIP，那么除了读出速度慢之外，还要保证有数据的校验，以保证读出来的，将要执行的代码/数据，是正确的。否则，系统很容易就跑飞了。。。
2.2.2.2Nand Flash的详细分类
Nand Flash，按照硬件类型，可以分为
（1）Bare NAND chips：裸片，单独的Nand Flash芯片
（2）SmartMediaCards：=裸片+一层薄塑料，常用于数码相机和MP3播放器中。之所以称smart，是由于其软件smart，而不是硬件本身有啥smart之处。
（3）DiskOnChip：裸片+glue logic，glue logic=硬件ECC产生器+用于静态的nand 芯片控制的寄存器+直接访问一小片地址窗口，那块地址中包含了引导代码的stub桩，其可以从Nand Flash中拷贝真正的引导代码。
2.2.3SLC和MLC的实现机制
Nand Flash按照内部存储数据单元的电压的不同层次，也就是单个内存单元中，是存储1位数据，还是多位数据，可以分为SLC和MLC。
2.2.
3.1SLC（Single Level Cell）
单个存储单元，只存储一位数据，表示1或0。
就是上面介绍的，对于数据的表示，单个存储单元中内部所存储电荷的电压，和某个特定的阈值电压Vth，相比，如果大于此Vth值，就是表示1，反之，小于Vth，就表示0.
对于Nand Flash的数据的写入1，就是控制External Gate去充电，使得存储的电荷够多，超过阈值Vth，就表示1了。而对于写入0，就是将其放电，电荷减少到小于Vth，就表示0了。
关于为何Nand Flash不能从0变成1，我的理解是，物理上来说，是可以实现每一位的，从0变成1的，但是实际上，对于实际的物理实现，出于效率的考虑，如果对于，每一个存储单元都能单独控制，即，0变成1就是，对每一个存储单元单独去充电，所需要的硬件实现就很复杂和昂贵，同时，所进行对块擦除的操作，也就无法实现之前所说的的，Flash的速度，即一闪而过的速度了，也就失去了Flash的众多特性了。
2.2.
3.2MLC（Multi Level Cell）
与SLC相对应的，就是单个存储单元，可以存储多个位，比如2位，4位等。其实现机制，说起来比较简单，就是通过控制内部电荷的多少，分成多个阈值，通过控制里面的电荷多少，而达到我们所需要的存储成不同的数据。比如，假设输入电压是Vin＝4V（实际没有这样的电压，此处只是为了举例方便），那么，可以设计出2的2次方＝4个阈值，1/4 的Vin＝1V，2/4的Vin＝2V，3/4的Vin＝3V，Vin＝4V，分别表示2位数据00，01，10，11，对于写入数据，就是充电，通过控制内部的电荷的多少，对应表示不同的数据。
对于读取，则是通过对应的内部的电流（与Vth成反比），然后通过一系列解码电路完成读取，解析出所存储的数据。这些具体的物理实现，都是有足够精确的设备和技术，才能实现精确的数据写入和读出的。
单个存储单元可以存储2位数据的，称作2的2次方＝4 Level Cell，而不是2 Level Cell，关于这点，之前看Nand flash的数据手册（datasheet）的时候，差点搞晕了。
同理，对于新出的单个存储单元可以存储4位数据的，称作2的4次方＝16 Level Cell。
2.2.
3.3关于如何识别SLC还是MLC
Nand Flash设计中，有个命令叫做Read ID，读取ID，意思是读取芯片的ID，就像大家的身份证一样，这里读取的ID中，是读取好几个字节，一般最少是4个，新的芯片，支持5个甚至更多，从这些字节中，可以解析出很多相关的信息，比如此Nand Flash内部是几个
芯片（chip）所组成的，每个chip包含了几片（Plane），每一片中的页大小，块大小，等等。在这些信息中，其中有一个，就是识别此flash是SLC还是MLC。下面这个就是最常见的Nand Flash的datasheet中所规定的，第3个字节，3rd byte，所表示的信息，其中就有SLC/MLC 的识别信息：
图表 3 Nand Flash 第3个ID的含义
2.2.4Nand Flash数据存储单元的整体架构
简单说就是，常见的Nand Flash，内部只有一个chip，每个chip只有一个plane。
而有些复杂的，容量更大的Nand Flash，内部有多个chip，每个chip有多个plane。这类的Nand Flash，往往也有更加高级的功能，比如下面要介绍的Multi Plane Program和Interleave Page Program等。
概念上，由大到小来说，就是：
Nand Flash -> Chip -> Plane -> Block -> Page -> oob
比如，型号为K9K8G08U0A这个芯片（chip），内部有两个K9F4G08U0A，每个K9F4G08U0A 包含了2个Plane，每个Plane是1Gb，所以K9F4G08U0A的大小是1Gb×2＝2Gb＝256MB，因此，K9K8G08U0A内部有2个K9F4G08U0A，即4个Plane，总大小是4×256MB＝1GB。而型号是K9WAG08U1A的Nand Flash，内部包含了2个K9K8G08U0A，所以，总容量是K9K8G08U0A的两倍＝1GB×2＝2GB，类似地K9NBG08U5A，内部包含了4个K9K8G08U0A，总大小就是4×1GB＝4GB。
【注意】
上面所说的block，page等Nand Flash的物理上的组织结构，是在chip的基础上来说的，但是软件编程的时候，除非你要用到Multi Plane Program和Interleave Page Program等，一般很少区分内部有几个chip以及每个chip有几个plane，而最关心的只是Nand Flash的总体容
量size有多大，比如是1GB还是2GB等等。
下面详细介绍一下，Nand Flash的一个chip内部的硬件逻辑组织结构。
2.2.5Nand Flash的物理存储单元的阵列组织结构
Nand Flash的内部组织结构，此处还是用图来解释，比较容易理解：
图表 4 Nand Flash物理存储单元的阵列组织结构
上图是K9K8G08U0A的datasheet中的描述。
简单解释就是:
2.2.5.1Block块
一个Nand Flash（的chip，芯片）由很多个块（Block）组成，块的大小一般是128KB，256KB，512KB，此处是128KB。其他的小于128KB的，比如64KB，一般都是下面将要介绍到的small block的Nand Flash。
块Block，是Nand Flash的擦除操作的基本/最小单位。
2.2.5.2Page页
每个块里面又包含了很多页（page）。每个页的大小，对于现在常见的Nand Flash多数是2KB，最新的Nand Flash的是4KB、8KB等，这类的页大小大于2KB的Nand Flash，被称作big block的Nand Flash，对应的发读写命令地址，一共5个周期(cycle)，而老的Nand Flash，页大小是256B，512B，这类的Nand Flash被称作small block，地址周期只有4个。
页Page，是读写操作的基本单位。
不过，也有例外的是，有些Nand Flash支持subpage（1/2页或1/4页）子页的读写操作，不过一般很少见。
2.2.5.3oob / Redundant Area / Spare Area
每一个页，对应还有一块区域，叫做空闲区域（spare area）/冗余区域（redundant area），而Linux系统中，一般叫做OOB（Out Of Band），这个区域，是最初基于Nand Flash的硬件特性：数据在读写时候相对容易错误，所以为了保证数据的正确性，必须要有对应的检测和纠错机制，此机制被叫做EDC(Error Detection Code)/ECC（Error Code Correction, 或者Error Checking and Correcting），所以设计了多余的区域，用于放置数据的校验值。
Oob的读写操作，一般是随着页的操作一起完成的，即读写页的时候，对应地就读写了oob。
关于oob具体用途，总结起来有：
标记是否是坏快
存储ECC数据
存储一些和文件系统相关的数据。如jffs2就会用到这些空间存储一些特定信息，而yaffs2文件系统，会在oob中，存放很多和自己文件系统相关的信息。
2.2.6Flash名称的由来
Flash的擦除操作是以block块为单位的，与此相对应的是其他很多存储设备，是以bit位为最小读取/写入的单位，Flash是一次性地擦除整个块：在发送一个擦除命令后，一次性地将一个block，常见的块的大小是128KB/256KB。。，全部擦除为1，也就是里面的内容全部都是0xFF了，由于是一下子就擦除了，相对来说，擦除用的时间很短，可以用一闪而过来形容，所以，叫做Flash Memory。所以一般将Flash翻译为（快速）闪存。
2.2.7Flash相对于普通设备的特殊性
根据上面提到过的，Flash最小操作单位，相对于普通存储设备，就显得有些特殊。
因为一般存储设备，比如硬盘或内存，读取和写入都是以位（bit）为单位，读取一个bit的值，将某个值写入对应的地址的位，都是可以按位操作的。
但是Flash由于物理特性，使得内部存储的数据，只能从1变成0，这点，这点可以从前面的内部实现机制了解到，对于最初始值，都是1，所以是0xFFFFFFFF，而数据的写入，即是将对应的变成0，而将数据的擦出掉，就是统一地，以block为单位，全部一起充电，所有位，都变成初始的1，而不是像普通存储设备那样，每一个位去擦除为0。而数据的写入，就是电荷放电的过程，代表的数据也从1变为了0.
所以，总结一下Flash的特殊性如下：
图表 5 Flash和普通设备相比所具有的特殊性
注：
①之所以将写操作叫做编程，是因为flash是从之前的EPROM、EEPROM等继承发展而来，而之前的EEPROM，往里面写入数据，就叫做编程Program，之所以这么称呼，是因为其对数据的写入，是需要用电去擦除/写入的，所以叫做编程。
②对于目前常见的页大小是2K/4K的Nand Flash，其块的大小有128KB/256KB/512KB等。而对于Nor Flash，常见的块大小有64K/32K等。
③在写数据之前，要先擦除，内部就都变成0xFF了，然后才能写入数据，也就是将对应的位由1变成0。
2.2.8Nand Flash引脚(Pin)的说明
图表 6 Nand Flash引脚功能说明
上图是常见的Nand Flash所拥有的引脚（Pin）所对应的功能，简单翻译如下：
图表7 Nand Flash引脚功能的中文说明
【小常识】
在数据手册中，你常会看到，对于一个引脚定义，有些字母上面带一横杠的，那是说明此引脚/信号是低电平有效，比如你上面看到的RE头上有个横线，就是说明，此RE是低电平有效，此外，为了书写方便，在字母后面加“＃”，也是表示低电平有效，比如我上面写的CE ＃；如果字母头上啥都没有，就是默认的高电平有效，比如上面的CLE，就是高电平有效。
2.2.8.1为何需要ALE和CLE
硬件上，有了电源的Vcc和接地的Vss等引脚，很好理解，但是为何还要有ALE和CLE这样的引脚，为何设计这么多的命令,把整个系统搞这么复杂，关于这点，最后终于想明白了：设计命令锁存使能(Command Latch Enable, CLE) 和地址锁存使能(Address Latch Enable，ALE)，那是因为，Nand Flash就8个I/O，而且是复用的，也就是，可以传数据，也可以传地址，也可以传命令，为了区分你当前传入的到底是啥，所以，先要用发一个CLE（或ALE）命令，告诉Nand Flash的控制器一声，我下面要传的是命令（或地址），这样，里面才能根据传入的内容，进行对应的动作。否则,Nand Flash内部,怎么知道你传入的是数据,还是地址,还是命令,也就无法实现正确的操作了.
2.2.8.2Nand Flash只有8个I/O引脚的好处
在Nand Flash的硬件设计中，你会发现很多个引脚。关于硬件上为何设计这样的引脚，而不是直接像其他存储设备，比如普通的RAM，直接是一对数据线引出来，多么方便和好理解啊。
关于这样设计的好处：
2.2.8.2.1减少外围连线：
相对于并口(Parellel)的Nor Flash的48或52个引脚来说，的确是大大减小了引脚数目，这样封装后的芯片体积，就小很多。现在芯片在向体积更小，功能更强，功耗更低发展，减小芯片体积，就是很大的优势。同时，减少芯片接口，也意味着使用此芯片的相关的外围电路
会更简化，避免了繁琐的硬件连线。
2.2.8.2.2提高系统的可扩展性
因为没有像其他设备一样用物理大小对应的完全数目的addr引脚，在芯片内部换了芯片的大小等的改动，对于用全部的地址addr的引脚，那么就会引起这些引脚数目的增加，比如容量扩大一倍，地址空间/寻址空间扩大一倍，所以，地址线数目/addr引脚数目，就要多加一个，而对于统一用8个I/O的引脚的Nand Flash，由于对外提供的都是统一的8个引脚，内部的芯片大小的变化或者其他的变化，对于外部使用者(比如编写Nand Flash驱动的人)来说，不需要关心，只是保证新的芯片，还是遵循同样的接口，同样的时序，同样的命令，就可以了。这样就提高了系统的扩展性。
说白了，对于旧的Nand Flash所实现的驱动，这些软件工作，在换新的硬件的Nand Flash 的情况下，仍然可以工作，或者是通过极少的修改，就同样可以工作，使得软硬件兼容性大大提高。
2.2.9Nand flash的一些典型(typical)的特性
1. 页擦除时间是200us，有些慢的有800us。
2. 块擦除时间是1.5ms.
3. 页数据读取到数据寄存器的时间一般是20us。
4. 串行访问（Serial access）读取一个数据的时间是25ns，而一些旧的Nand Flash是30ns，甚至是50ns。
5. 输入输出端口是地址和数据以及命令一起multiplex复用的。
6. Nand Flash的编程/擦除的寿命：即，最多允许的擦除的次数。
以前老的Nand Flash，编程/擦除时间比较短，比如K9G8G08U0M，才5K次，而后来的多数也只有10K=1万次，而现在很多新的Nand Flash，技术提高了，比如，Micron的MT29F1GxxABB，Numonyx的NAND04G-B2D/NAND08G-BxC，都可以达到100K，也就是10万次的编程/擦除，达到和接近于之前常见的Nor Flash，几乎是同样的使用寿命了。7. 封装形式：48引脚的TSOP1封装或52引脚的ULGA封装
2.2.10Nand Flash控制器与Nand Flash芯片
关于Nand Flash的控制器Controller和Nand Flash芯片chip之间的关系，觉得有必要解释一下：
首先，我们要知道的是，我们写驱动，是写Nand Flash 控制器的驱动，而不是Nand Flash 芯片的驱动，因为独立的Nand Flash芯片，一般来说，是很少直接拿来用的，多数都是硬件上有对应的硬件的Nand Flash的控制器，去操作和控制Nand Flash，包括提供时钟信号，提供硬件ECC校验等等功能，我们所写的驱动软件，是去操作Nand Flash的控制器，然后由控制器去操作Nand Flash芯片，实现我们所要的功能。
2.2.11Nand Flash中的特殊硬件结构
由于Nand Flash相对其他常见设备来说，比较特殊，所以，特殊的设备，就有特殊的设计，就对应某些特殊的硬件特性，就有必要解释解释：
页寄存器（Page Register）：由于Nand Flash读取和编程操作来说，一般最小单位是页，所以Nand Flash在硬件设计时候，就考虑到这一特性，对于每一片（Plane），都有一个对应的区域专门用于存放，将要写入到物理存储单元中去的或者刚从存储单元中读取出来的，一页的数据，这个数据缓存区，本质上就是一个缓存buffer，但是只是此处datasheet里面把其叫
做页寄存器page register而已，实际将其理解为页缓存，更贴切原意。
而正是因为有些人不了解此内部结构，才容易产生之前遇到的某人的误解，以为内存里面的数据，通过Nand Flash的FIFO，写入到Nand Flash里面去，就以为立刻实现了实际数据写入到物理存储单元中了，而实际上只是写到了这个页缓存中，只有当你再发送了对应的编程第二阶段的确认命令，即0x10，之后，实际的编程动作才开始，才开始把页缓存中的数据，一点点写到物理存储单元中去。
所以，简单总结一下就是，对于数据的流向，实际是经过了如下步骤：
图表8 Nand Flash读写时的数据流向
2.2.12Nand Flash中的坏块(Bad Block)
Nand Flash中，一个块中含有1个或多个位是坏的，就称为其为坏块Bad Block。
坏块的稳定性是无法保证的，也就是说，不能保证你写入的数据是对的，或者写入对了，读出来也不一定对的。与此对应的正常的块，肯定是写入读出都是正常的。
2.2.12.1坏块的分类
坏块有两种：
（1）出厂时就有存在的坏块：
一种是出厂的时候，也就是，你买到的新的，还没用过的Nand Flash，就可以包含了坏块。此类出厂时就有的坏块，被称作factory (masked) bad block或initial bad/invalid block，在出厂之前，就会做对应的标记，标为坏块。
（2）使用过程中产生的坏块：
第二类叫做在使用过程中产生的，由于使用过程时间长了，在擦块除的时候，出错了，说明此块坏了，也要在程序运行过程中，发现，并且标记成坏块的。具体标记的位置，和上面一样。这类块叫做worn-out bad block。即用坏了的块。
2.2.12.2坏块的标记
具体标记的地方是，对于现在常见的页大小为2K的Nand Flash，是块中第一个页的oob起始位置（关于什么是页和oob，下面会有详细解释）的第1个字节（旧的小页面，pagesize 是512B甚至256B的Nand Flash，坏块标记是第6个字节），如果不是0xFF，就说明是坏块。相对应的是，所有正常的块，好的块，里面所有数据都是0xFF的。
不过，对于现在新出的有些Nand Flash，很多标记方式，有些变化，有的变成该坏块的第一个页或者第二个页，也有的是，倒数最后一个或倒数第二个页，用于标记坏块的。
具体的信息，请参考对应的Nand Flash的数据手册，其中会有说明。
对于坏块的标记，本质上，也只是对应的flash上的某些字节的数据是非0xFF而已，所以，只要是数据，就是可以读取和写入的。也就意味着，可以写入其他值，也就把这个坏块标记信息破坏了。对于出厂时的坏块，一般是不建议将标记好的信息擦除掉的。
uboot中有个命令是“nand scrub”就可以将块中所有的内容都擦除了，包括坏块标记，不论是出厂时的，还是后来使用过程中出现而新标记的。一般来说，不建议用这个。
不过，在实际的驱动编程开发过程中，为了方便起见，我倒是经常用，其实也没啥大碍，呵呵。不过呢，其实最好的做法是，用“nand erase”只擦除好的块，对于已经标记坏块的块，不要轻易擦除掉，否则就很难区分哪些是出厂时就坏的，哪些是后来使用过程中用坏的了。
2.2.12.3坏块的管理
对于坏块的管理，在Linux系统中，叫做坏块管理（BBM，Bad Block Management），对应的会有一个表去记录好块，坏块的信息，以及坏块是出厂就有的，还是后来使用产生的，这个表叫做坏块表（BBT，Bad Block Table）。在Linux 内核MTD架构下的Nand Flash驱动，和Uboot中Nand Flash驱动中，在加载完驱动之后，如果你没有加入参数主动要求跳过坏块扫描的话，那么都会去主动扫描坏块，建立必要的BBT的，以备后面坏块管理所使用。
2.2.12.4坏块的比例
而关于好块和坏块，Nand Flash在出厂的时候，会做出保证：
1.关于好的，可以使用的块的数目达到一定的数目，比如三星的K9G8G08U0M，整个flash 一共有4096个块，出厂的时候，保证好的块至少大于3996个，也就是意思是，你新买到这个型号的Nand Flash，最坏的可能，有3096－3996＝100个坏块。不过，事实上，现在出厂时的坏块，比较少，绝大多数，都是使用时间长了，在使用过程中出现的。
2.保证第一个块是好的，并且一般相对来说比较耐用。做此保证的主要原因是，很多Nand Flash坏块管理方法中，就是将第一个块，用来存储上面提到的BBT，否则，都是出错几率一样的块，那么也就不太好管理了，连放BBT的地方，都不好找了，^_^。
一般来说，不同型号的Nand Flash的数据手册中，也会提到，自己的这个Nand Flash，最多允许多少个坏块。就比如上面提到的，三星的K9G8G08U0M，最多有100个坏块。
2.2.13Nand Flash中页的访问顺序
在一个块内，对每一个页进行编程的话，必须是顺序的，而不能是随机的。比如，一个块中有128个页，那么你只能先对page0编程，再对page1编程，。。。。，而不能随机的，比如先对page3，再page1，page2.，page0，page4，。。。
2.2.14常见的Nand Flash的操作
要实现对Nand Flash的操作，比如读取一页的数据，写入一页的数据等，都要发送对应的命令，而且要符合硬件的规定，如图：
图表9 Nand Flash K9K8G08U0A的命令集合
从上图可以看到，如果要实现读一个页的数据，就要发送Read的命令，而且是分两个周期（Cycle），即分两次发送对应的命令，第一次是0x00h,第二次是0x30h，而两次命令中间，需要发送对应的你所要读取的页的地址，关于此部分详细内容，留待后表。
对应地，其他常见的一些操作，比如写一个页的数据(Page Program)，就是先发送0x80h,然后发生要写入的地址，再发送0x10h。
【提示】
对于不同厂家的不同型号的Nand Flash 的基本操作，即读页数据Read Page，写页数据（对页进行编程）Page Program，擦除整个块的数据Erase Block等操作，所用的命令都是一样的，但是针对一些Nand Flash的高级的一些特性，比如交错页编程（Interleave Page Program），多片同时编程(Simultaneously Program Multi Plane)等，所用的命令，未必一样，不过对于同一厂家的Nand Flash的芯片，那一般来说，都是统一的。
关于一些常见的操作，比如读一个页的Read操作和写一个页的Page Program，下面开始更深入的介绍。
2.2.14.1页编程（Page Program）注意事项
Nand flash的写操作叫做编程Program，编程，一般情况下，是以页为单位的。
有的Nand Flash，比如K9K8G08U0A，支持部分页编程（Partial Page Program），但是有一些限制：在同一个页内的，连续的部分页的编程，不能超过4次。
一般情况下，都是以页为单位进行编程操作的，很少使用到部分页编程。
关于这个部分页编程，本来是一个页的写操作，却用两个命令或更多的命令去实现，看起来是操作多余，效率不高，但是实际上，有其特殊考虑：
至少对于块擦除来说，开始的命令0x60是擦除设置命令(erase setup comman)，然后传入要擦除的块地址，然后再传入擦除确认命令（erase confirm command）0xD0，以开始擦除的操作。
这种完成单个操作要分两步发送命令的设计，即先开始设置，再最后确认的命令方式，是为
了避免由于外部由于无意的/未预料而产生的噪音，比如，由于某种噪音，而产生了0x60命令，此时，即使被Nand Flash误认为是擦除操作，但是没有之后的确认操作0xD0，Nand Flash 就不会去擦除数据，这样使得数据更安全，不会由于噪音而误操作。
2.2.14.2读（Read）操作过程详解
下面以最简单的read操作为例，解释如何理解时序图，以及将时序图中的要求，转化为代码。
解释时序图之前，让我们先要搞清楚，我们要做的事情：
从Nand Flash的某个页Page里面，读取我们要的数据。
要实现此功能，会涉及到几部分的知识，即使我们不太懂Nand Flash的细节，但是通过前面的基本知识的介绍，那么以我们的常识，至少很容易想到的就是，需要用到哪些命令，怎么发这些命令，怎么计算所需要的地址，怎么读取我们要的数据等等。
下面就一步步的解释，需要做什么，以及如何去做：
2.2.14.2.1需要使用何种命令
首先，是要了解，对于读取数据，要用什么命令：
根据前面关于Nand Flash的命令集合介绍，我们知道，要读取数据，要用到Read命令，该命令需要2个周期，第一个周期发0x00，第二个周期发0x30。
2.2.14.2.2发送命令前的准备工作以及时序图各个信号的具体含义
知道了用何命令后，再去了解如何发送这些命令。
【小常识】
在开始解释前，关于”使能”这个词要罗嗦一下，以防有些读者和我以前一样，在听这类词语的时候，属于初次接触，或者接触不多的，就很容易被搞得一头雾水的（虽然该词汇对于某些专业人士说是属于最基本的词汇了，囧）。
使能（Enable），是指使其（某个信号）有效，使其生效的意思，“使其”“能够”怎么怎么样。。。。比如，上面图中的CLE线号，是高电平有效，如果此时将其设为高电平，我们就叫做，将CLE使能，也就是使其生效的意思。
linux驱动开发的经典书籍 结构、操作系统、体系结构、编译原理、计算机网络你全修过 我想大概可以分为4个阶段，水平从低到高 从安装使用=>linux常用命令=>linux系统编程=>内核开发阅读内核源码 其中学习linux常用命令时就要学会自己编译内核，优化系统，调整参数 安装和常用命令书太多了，找本稍微详细点的就ok，其间需要学会正则表达式 系统编程推荐《高级unix环境编程》，黑话叫APUE 还有《unix网络编程》 这时候大概还需要看资料理解elf文件格式，连接器和加载器，cmu的一本教材中文名为《深入理解计算机系统》比较好 内核开发阅读内核源码阶段，从写驱动入手逐渐深入linux内核开发 参考书如下《linux device drivers》，黑话叫ldd 《linux kernel development》，黑话叫lkd 《understading the linux kernel》，黑话叫utlk 《linux源码情景分析》 这四本书为搞内核的必读书籍 最后，第三阶段和第四阶段最重动手，空言无益，光看书也不罩，不动手那些东西理解不了 学习linux/unix编程方法的建议 建议学习路径： 首先先学学编辑器，vim, emacs什么的都行。 然后学make file文件，只要知道一点就行，这样就可以准备编程序了。 然后看看《C程序设计语言》K&R，这样呢，基本上就可以进行一般的编程了，顺便找本数据结构的书来看。 如果想学习UNIX/LINUX的编程，《APUE》绝对经典的教材，加深一下功底，学习《UNP》的第二卷。这样基本上系统方面的就可以掌握了。 然后再看Douglus E. Comer的《用TCP/IP进行网际互连》第一卷，学习一下网络的知识，再看《UNP》的第一卷，不仅学习网络编程，而且对系统编程的一些常用的技巧就很熟悉了，如果继续网络编程，建议看《TCP/IP进行网际互连》的第三卷，里面有很多关于应用
linux驱动程序的编写 一、实验目的 1.掌握linux驱动程序的编写方法 2.掌握驱动程序动态模块的调试方法 3.掌握驱动程序填加到内核的方法 二、实验内容 1. 学习linux驱动程序的编写流程 2. 学习驱动程序动态模块的调试方法 3. 学习驱动程序填加到内核的流程 三、实验设备 PentiumII以上的PC机，LINUX操作系统，EL-ARM860实验箱 四、linux的驱动程序的编写 嵌入式应用对成本和实时性比较敏感，而对linux的应用主要体现在对硬件的驱动程序的编写和上层应用程序的开发上。 嵌入式linux驱动程序的基本结构和标准Linux的结构基本一致，也支持模块化模式，所以，大部分驱动程序编成模块化形式，而且，要求可以在不同的体系结构上安装。linux是可以支持模块化模式的，但由于嵌入式应用是针对具体的应用，所以，一般不采用该模式，而是把驱动程序直接编译进内核之中。但是这种模式是调试驱动模块的极佳方法。 系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口。设备驱动程序为应用程序屏蔽了硬件的细节,这样在应用程序看来,硬件设备只是一个设备文件,应用程序可以像操作普通文件一样对硬件设备进行操作。同时,设备驱动程序是内核的一部分,它完成以下的功能:对设备初始化和释放;把数据从内核传送到硬件和从硬件读取数据;读取应用程序传送给设备文件的数据和回送应用程序请求的数据;检测和处理设备出现的错误。在linux操作系统下有字符设备和块设备，网络设备三类主要的设备文件类型。 字符设备和块设备的主要区别是:在对字符设备发出读写请求时,实际的硬件I/O一般就紧接着发生了;块设备利用一块系统内存作为缓冲区,当用户进程对设备请求满足用户要求时,就返回请求的数据。块设备是主要针对磁盘等慢速设备设计的,以免耗费过多的CPU时间来等待。 1 字符设备驱动结构 Linux字符设备驱动的关键数据结构是cdev和file_operations结构体。
Linux驱动程序工作原理简介 一、linux驱动程序的数据结构 (1) 二、设备节点如何产生？ (2) 三、应用程序是如何访问设备驱动程序的？ (2) 四、为什么要有设备文件系统？ (3) 五、设备文件系统如何实现？ (4) 六、如何使用设备文件系统？ (4) 七、具体设备驱动程序分析 (5) 1、驱动程序初始化时，要注册设备节点，创建子设备文件 (5) 2、驱动程序卸载时要注销设备节点，删除设备文件 (7) 参考书目 (8) 一、linux驱动程序的数据结构 设备驱动程序实质上是提供一组供应用程序操作设备的接口函数。 各种设备由于功能不同，驱动程序提供的函数接口也不相同，但linux为了能够统一管理，规定了linux下设备驱动程序必须使用统一的接口函数file_operations 。 所以，一种设备的驱动程序主要内容就是提供这样的一组file_operations 接口函数。 那么，linux是如何管理种类繁多的设备驱动程序呢？ linux下设备大体分为块设备和字符设备两类。 内核中用2个全局数组存放这2类驱动程序。 #define MAX_CHRDEV 255 #define MAX_BLKDEV 255 struct device_struct { const char * name; struct file_operations * fops; }; static struct device_struct chrdevs[MAX_CHRDEV]; static struct { const char *name; struct block_device_operations *bdops; } blkdevs[MAX_BLKDEV]; //此处说明一下，struct block_device_operations是块设备驱动程序内部的接口函数，上层文件系统还是通过struct file_operations访问的。
Linux设备驱动程序设计实例2007-03-03 23:09 Linux系统中，设备驱动程序是操作系统内核的重要组成部分，在与硬件设备之间 建立了标准的抽象接口。通过这个接口，用户可以像处理普通文件一样，对硬件设 备进行打开(open)、关闭(close)、读写(read/write)等操作。通过分析和设计设 备驱动程序，可以深入理解Linux系统和进行系统开发。本文通过一个简单的例子 来说明设备驱动程序的设计。 1、程序清单 //MyDev.c 2000年2月7日编写 #ifndef __KERNEL__ #define __KERNEL__//按内核模块编译 #endif #ifndef MODULE #define MODULE//设备驱动程序模块编译 #endif #define DEVICE_NAME "MyDev" #define OPENSPK 1 #define CLOSESPK 2 //必要的头文件 #include
---简介 Linux下的MISC简单字符设备驱动虽然使用简单，但却不灵活。 只能建立主设备号为10的设备文件。字符设备比较容易理解，同时也能够满足大多数简 单的硬件设备,字符设备通过文件系统中的名字来读取。这些名字就是文件系统中的特 殊文件或者称为设备文件、文件系统的简单结点，一般位于/dev/目录下使用ls进行查 看会显示以C开头证明这是字符设备文件crw--w---- 1 root tty 4, 0 4月 14 11:05 tty0。 第一个数字是主设备号，第二个数字是次设备号。 ---分配和释放设备编号 1)在建立字符设备驱动时首先要获取设备号，为此目的的必要的函数是 register_chrdev_region,在linux/fs.h中声明：int register_chrdev_region(dev_t first, unsigned int count, char *name);first是你想 要分配的起始设备编号，first的次编号通常是0，count是你请求的连续设备编号的 总数。count如果太大会溢出到下一个主设备号中。name是设备的名字，他会出现在 /proc/devices 和sysfs中。操作成功返回0，如果失败会返回一个负的错误码。 2)如果明确知道设备号可用那么上一个方法可行，否则我们可以使用内核动态分配的设 备号int alloc_chrdev_region(dev_t *dev, unsigned int firstminor,unsigned int count, char *name);dev是个只输出的参数，firstminor请求的第一个要用的次编号， count和name的作用如上1)对于新驱动，最好的方法是进行动态分配 3)释放设备号，void unregister_chrdev_region(dev_t first unsigned int count); ---文件操作file_operations结构体，内部连接了多个设备具体操作函数。该变量内部 的函数指针指向驱动程序中的具体操作，没有对应动作的指针设置为NULL。 1)fops的第一个成员是struct module *owner 通常都是设置成THIS_MODULE。 linux/module.h中定义的宏。用来在他的操作还在被使用时阻止模块被卸载。 2)loff_t (*llseek) (struct file *, loff_t, int);该方法用以改变文件中的当前读/ 写位置 返回新位置。 3)ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);该函数用 以从设备文件 中读取数据，读取成功返回读取的字节数。
本人此刻还不是什么驱动工程师，连入门都谈不上，但我坚信在未来的3-5年我肯定能成为我想像中的人，因为我马上就要进入这一行工作了。写下这个日志来记录我是怎么最后成为我想像中的人才的，呵呵。 《Linux驱动工程师》这个东西是我在大二的时候看到有一篇讲如何学习嵌入式的，点击这里下载PDF，里面讲到嵌入式分为四层：硬件，驱动，系统，应用程序;还说linux驱动最难然后工资也最高就冲着他这句话我就决定我大学毕业的时候要去做这个linux驱动工程师，随后我就先后买了51单片机，ARM7,ARM9还有一大堆的视频教程准备来进行学习。我还跟我旁边那个哈工大哥们说：“我们学校像我这样的人很少，你们学校呢？”他说：“太少了，不过我们学校都是做这种板子卖的人比较多！”。行，你们牛！即使是买了这些东西，从大二到现在都快毕业了但感觉还是没有入门。回想一下我都学过什么啊：1：自己在ARM9上写bootloader(主要锻炼了三方面的知识：C语言应该写了有近万行的代码，ARM9的外设的基本操作方法如UART,LCD,TOUCH,SD,USB,ETHERNET...，makefile);2:移植和学习linux驱动。下面我说一下我学习Linux驱动的一个思路这也是我在面试的时候自我介绍中最重要的部分；1：硬件知识学习Linux驱动首先得了解这个驱动对应的硬件的一些基本原理和操作方法比如LCD你得了解它的场同步，行同步，像素时钟，一个像素的表示模式，还有就是这个LCD是怎么把图像显示在屏幕上的。如果是USB,SD卡就得了解相关协议。可以通过spec（协议）、datasheet来了解，这就是传说中的Linux驱动开发三件宝之二，还有一个就是linux相关源码。2：了解linux驱动框架linux下的每一类驱动差不多都是一个比较完善的子系统，比如FLASH的驱动它就属于MTD子系统从上到下分为四层：设备节点层，设备层，原始设备层，最下面的与具体硬件相关的硬件驱动层，通常要我们自己来实现就是最下面这个与具体硬件相关那部分代码。3：了解这个驱动的数据流。这个过程与第二个过程紧密相关，如果了解了驱动的框架差不多这个过程也算了解了。比如flash.在/dev/目录下有对应flash的字符设备文件和块设备文件，用户对这些文件进行读、写、ioctl操作，其间通过层层的函数调用最终将调用到最下面的硬件驱动层对硬件进行操作。了解这个过程我相信在调试驱动的时候是很有帮助。3：分析与硬件相关通常需要我们实现的那部分源代码。4：三板子上将驱动调试出来。每次调试都会出问题，但我买的板子提供的资料比较全调试过程中遇到的问题都比较浅显，即使是浅显的问题也要把它记录下来。(这个是我上次在华为面试的时候，那个人问我你调试驱动遇到过什么问题吗？你是如何解决的。当时我学习还没有到调试驱动这一步，所以那次面试也惨败收场)。 好像说了这么多，还没有进入正题《工作的选择》。在年前去了龙芯，实习2.8K，转正3.5k，环境还是不错，经理很好，头儿也很帅都是中科院的硕士。不过去了两周我就没去了身边的人都不太理解，我也一度有过后悔的时候，从龙芯出来应该是1月6号，也就是从那个时候开始我就没有再找工作，转而学习linux驱动。一直到上周日。上周日的晚上我就开始投简历一开始要找linux驱动，在智联里面输入linux驱动出来500来个职位，点开一看没有一个自己符合要求的，差不多都要3-5年经验本科，有时候好不容易有个实习的关键字在里面，一看要求硕士，严重打击了我的信心，哎不管了随便投，最后又投了一下嵌入式关键字的职位。最后就瞎申请，看看职位要求差不多就申请。周一来了，这周一共来了6个面试，创下了我求职以来的历史新高。周一下午面了一家感觉还不错不过到现在也没有给我一个通知，估计当时我要了4500把他给要跑了，这家是做测量的不是Linux驱动，差不多是把ARM当单片机用。周二上午一家也是要招linux驱动面了估计不到二分钟，他
参考： 韦东山视频第10课第一节内核启动流程分析之编译体验 第11课第三节构建根文件系统之busybox 第11课第四节构建根文件系统之构建根文件系统韦东山书籍《嵌入式linux应用开发完全手册》 其他《linux设备驱动程序》第三版 平台： JZ2440、mini2440或TQ2440 交叉网线和miniUSB PC机（windows系统和Vmware下的ubuntu12.04） 一、交叉编译环境的选型 具体的安装交叉编译工具，网上很多资料都有，我的那篇《arm-linux- gcc交叉环境相关知识》也有介绍，这里我只是想提示大家：构建跟文件系统中所用到的lib库一定要是本系统Ubuntu中的交叉编译环境arm-linux- gcc中的。即如果电脑ubuntu中的交叉编译环境为arm-linux-
二、主机、开发板和虚拟机要三者互通 w IP v2.0》一文中有详细的操作步骤，不再赘述。 linux 2.6.22.6_jz2440.patch组合而来，具体操作： 1. 解压缩内核和其补丁包 tar xjvf linux-2.6.22.6.tar.bz2 # 解压内核 tar xjvf linux-2.6.22.6_jz2440.tar.bz2 # 解压补丁
cd linux_2.6.22.6 patch –p1 < ../linux-2.6.22.6_jz2440.patch 3. 配置 在内核目录下执行make 2410_defconfig生成配置菜单，至于怎么配置，《嵌入式linux应用开发完全手册》有详细介绍。 4. 生成uImage make uImage 四、移植busybox 在我们的根文件系统中的/bin和/sbin目录下有各种命令的应用程序，而这些程序在嵌入式系统中都是通过busybox来构建的，每一个命令实际上都是一个指向bu sybox的链接,busybox通过传入的参数来决定进行何种命令操作。 1）配置busybox 解压busybox-1.7.0,然后进入该目录，使用make menuconfig进行配置。这里我们这配置两项 一是在编译选项选择动态库编译，当然你也可以选择静态，不过那样构建的根文件系统会比动态编译的的大。 ->Busybox Settings ->Build Options
1 什么是驱动 a)裸板驱动 b)有系统驱动linux 将驱动封装了一套框架（每个驱动） c)大量和硬件无关的代码已写好只需要编程实现和硬件相关的代码 d)难点：框架的理解代码的理解 e)需要三方面的知识： i.硬件相关的知识 1.电路原理图 2.芯片的数据手册 3.总线协议rs232 i2c等 ii.内核的知识 1.内核驱动属于内核的一部分，它运行在内核态需要对内核知识有了解 2.内存管理 3.解决竞争状态（如上锁） 4.。。。 iii.驱动框架的知识 1.内核中已经实现了大量硬件驱动完成了驱动的框架编程只需要根据硬 件进行添加 2 搭建linux驱动开发工具 a)安装交叉编译环境 i.arm-linux-gcc uboot PATH b)移植uboot c)移植内核 d)制作根文件系统然后通过nfs方式让开发板可以加载 3 内核驱动开发的基本知识 a)如何学驱动编程？ i.最好的老师就是内核源码（没有man 功能） 1.要是用某个函数就去查看某个函数的定义注释 2.查看内核中其他模块儿时如何使用该函数的 3.专业书籍： a)内核开发：linux内核的设计与实现机械工程出版社 b)驱动开发：圣经级别的-LDD3：LINUX DEVICE c)操作性别叫强的：精通linux设备驱动程序开发
关于linux内核： 1）linux内核中所使用的函数都是自身实现的它肯定不会调用c库中的函数 2）linux中代码绝大多数代码时gun c语言完成的不是标准c语言可以理解为标c的扩展版和少部分汇编 需要注意的问题： 1）内核态不能做浮点数运算 2）用户空间的每个进程都有独立的0-3G的虚拟空间 多个进程共享同一个内核 内核使用的地址空间为3G-4G 3）每个线程有独立的栈空间 4 写一个最简单的内核模块儿（因为驱动时内核的一个模块套路都一样） a)几个宏 i.__FUNCTION__:展开为所在函数的名称 ii.__LINE__:展开为printk所在的行号 iii.__DATE__:展开为编译程序的日期 b)通用头文件 i.#include
Linux设备驱动程序简介 Linux是Unix操作系统的一种变种，在Linux下编写驱动程序的原理和思想完全类似于其他的Unix系统，但它dos或window环境下的驱动程序有很大的区别。在Linux环境下设计驱动程序，思想简洁，操作方便，功能也很强大，但是支持函数少，只能依赖kernel 中的函数，有些常用的操作要自己来编写，而且调试也不方便。本人这几周来为实验室自行研制的一块多媒体卡编制了驱动程序，获得了一些经验，愿与Linux fans共享，有不当之处，请予指正。 以下的一些文字主要来源于khg，johnsonm的Write linux device driver，Brennan's Guide to Inline Assembly，The Linux A-Z，还有清华BBS上的有关device driver的一些资料. 这些资料有的已经过时，有的还有一些错误，我依据自己的试验结果进行了修正. 一、Linux device driver 的概念 系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口.设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作.设备驱动程序是内核的一部分，它完成以下的功能: 1.对设备初始化和释放. 2.把数据从内核传送到硬件和从硬件读取数据. 3.读取应用程序传送给设备文件的数据和回送应用程序请求的数据. 4.检测和处理设备出现的错误. 在Linux操作系统下有两类主要的设备文件类型，一种是字符设备，另一种是块设备.字符设备和块设备的主要区别是:在对字符设备发出读/写请求时，实际的硬件I/O一般就紧接着发生了，块设备则不然，它利用一块系统内存作缓冲区，当用户进程对设备请求能满足用户的要求，就返回请求的数据，如果不能，就调用请求函数来进行实际的I/O操作.块设备是主要针对磁盘等慢速设备设计的，以免耗费过多的CPU时间来等待. 已经提到，用户进程是通过设备文件来与实际的硬件打交道.每个设备文件都都有其文件属性(c/b)，表示是字符设备还蔤强樯璞?另外每个文件都有两个设备号，第一个是主设备号，标识驱动程序，第二个是从设备号，标识使用同一个设备驱动程序的不同的硬件设备，比如有两个软盘，就可以用从设备号来区分他们.设备文件的的主设备号必须与设备驱动程序在登记时申请的主设备号一致，否则用户进程将无法访问到驱动程序. 最后必须提到的是，在用户进程调用驱动程序时，系统进入核心态，这时不再是抢先式调度.也就是说，系统必须在你的驱动程序的子函数返回后才能进行其他的工作.如果你的驱动程序陷入死循环，不幸的是你只有重新启动机器了，然后就是漫长的fsck. 读/写时，它首先察看缓冲区的内容，如果缓冲区的数据 如何编写Linux操作系统下的设备驱动程序 二、实例剖析 我们来写一个最简单的字符设备驱动程序。虽然它什么也不做，但是通过它可以了解Linux的设备驱动程序的工作原理.把下面的C代码输入机器，你就会获得一个真正的设备驱动程序.不过我的kernel是2.0.34，在低版本的kernel上可能会出现问题，我还没测试过. [code]#define __NO_VERSION__
Linux设备驱动程序学习（18）－USB 驱动程序（三） (2009-07-14 11:45) 分类：Linux设备驱动程序 USB urb （USB request block） 内核使用2.6.29.4 USB 设备驱动代码通过urb和所有的 USB 设备通讯。urb用 struct urb 结构描述（include/linux/usb.h ）。 urb以一种异步的方式同一个特定USB设备的特定端点发送或接受数据。一个USB 设备驱动可根据驱动的需要，分配多个 urb 给一个端点或重用单个 urb 给多个不同的端点。设备中的每个端点都处理一个 urb 队列, 所以多个 urb 可在队列清空之前被发送到相同的端点。 一个 urb 的典型生命循环如下: （1）被创建； （2）被分配给一个特定 USB 设备的特定端点； （3）被提交给 USB 核心； （4）被 USB 核心提交给特定设备的特定 USB 主机控制器驱动； （5）被 USB 主机控制器驱动处理, 并传送到设备； （6）以上操作完成后，USB主机控制器驱动通知 USB 设备驱动。 urb 也可被提交它的驱动在任何时间取消；如果设备被移除，urb 可以被USB 核心取消。urb 被动态创建并包含一个内部引用计数，使它们可以在最后一个用户释放它们时被自动释放。 struct urb
struct list_head urb_list;/* list head for use by the urb's * current owner */ struct list_head anchor_list;/* the URB may be anchored */ struct usb_anchor *anchor; struct usb_device *dev;/* 指向这个 urb 要发送的目标 struct usb_device 的指针,这个变量必须在这个 urb 被发送到 USB 核心之前被USB 驱动初始化.*/ struct usb_host_endpoint *ep;/* (internal) pointer to endpoint */ unsigned int pipe;/* 这个 urb 所要发送到的特定struct usb_device 的端点消息,这个变量必须在这个 urb 被发送到 USB 核心之前被 USB 驱动初始化.必须由下面的函数生成*/ int status;/*当 urb开始由 USB 核心处理或处理结束, 这个变量被设置为 urb 的当前状态. USB 驱动可安全访问这个变量的唯一时间是在 urb 结束处理例程函数中. 这个限制是为防止竞态. 对于等时 urb, 在这个变量中成功值(0)只表示这个 urb 是否已被去链. 为获得等时 urb 的详细状态, 应当检查 iso_frame_desc 变量. */ unsigned int transfer_flags;/* 传输设置*/ void*transfer_buffer;/* 指向用于发送数据到设备(OUT urb)或者从设备接收数据(IN urb)的缓冲区指针。为了主机控制器驱动正确访问这个缓冲, 它必须使用 kmalloc 调用来创建, 不是在堆栈或者静态内存中。对控制端点, 这个缓冲区用于数据中转*/ dma_addr_t transfer_dma;/* 用于以 DMA 方式传送数据到 USB 设备的缓冲区*/ int transfer_buffer_length;/* transfer_buffer 或者 transfer_dma 变量指向的缓冲区大小。如果这是 0, 传送缓冲没有被 USB 核心所使用。对于一个 OUT 端点, 如果这个端点大小比这个变量指定的值小, 对这个USB 设备的传输将被分成更小的块，以正确地传送数据。这种大的传送以连续的 USB 帧进行。在一个 urb 中提交一个大块数据, 并且使 USB 主机控制器去划分为更小的块, 比以连续地顺序发送小缓冲的速度快得多*/
本讲主要概述Linux设备驱动框架、驱动程序的配置文件及常用的加载驱动程序的方法；并且介绍Red Hat Linux安装程序是如何加载驱动的，通过了解这个过程，我们可以自己将驱动程序放到引导盘中；安装完系统后，使用kudzu自动配置硬件程序。 Linux设备驱动概述 1. 内核和驱动模块 操作系统是通过各种驱动程序来驾驭硬件设备，它为用户屏蔽了各种各样的设备，驱动硬件是操作系统最基本的功能，并且提供统一的操作方式。正如我们查看屏幕上的文档时,不用去管到底使用nVIDIA芯片，还是ATI芯片的显示卡，只需知道输入命令后，需要的文字就显示在屏幕上。硬件驱动程序是操作系统最基本的组成部分，在Linux内核源程序中也占有较高的比例。 Linux内核中采用可加载的模块化设计（LKMs ，Loadable Kernel Modules），一般情况下编译的Linux内核是支持可插入式模块的，也就是将最基本的核心代码编译在内核中，其它的代码可以选择是在内核中，或者编译为内核的模块文件。 如果需要某种功能，比如需要访问一个NTFS分区，就加载相应的NTFS模块。这种设计可以使内核文件不至于太大，但是又可以支持很多的功能，必要时动态地加载。这是一种跟微内核设计不太一样，但却是切实可行的内核设计方案。 我们常见的驱动程序就是作为内核模块动态加载的，比如声卡驱动和网卡驱动等，而Linux最基础的驱动，如CPU、PCI总线、TCP/IP协议、APM（高级电源管理）、VFS等驱动程序则编译在内核文件中。有时也把内核模块就叫做驱动程序，只不过驱动的内容不一定是硬件罢了，比如ext3文件系统的驱动。 理解这一点很重要。因此，加载驱动时就是加载内核模块。下面来看一下有关模块的命令，在加载驱动程序要用到它们：lsmod、modprob、insmod、rmmod、modinfo。 lsmod
如何编写Linux设备驱动程序 Linux是Unix操作系统的一种变种，在Linux下编写驱动程序的原理和思想完全类似于其他的Unix系统，但它dos或window环境下的驱动程序有很大的区别。在Linux环境下设计驱动程序，思想简洁，操作方便，功能也很强大，但是支持函数少，只能依赖kernel中的函数，有些常用的操作要自己来编写，而且调试也不方便。 以下的一些文字主要来源于khg，johnsonm的Write linux device driver，Brennan's Guide to Inline Assembly，The Linux A-Z，还有清华BBS上的有关device driver的一些资料。 一、Linux device driver 的概念 系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口。设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。设备驱动程序是内核的一部分，它完成以下的功能: 1。对设备初始化和释放。 2。把数据从内核传送到硬件和从硬件读取数据。 3。读取应用程序传送给设备文件的数据和回送应用程序请求的数据。 4。检测和处理设备出现的错误。 在Linux操作系统下有三类主要的设备文件类型，一是字符设备，二是块设备，三是网络设备。字符设备和块设备的主要区别是:在对字符设备发出读/写请求时，实际的硬件I/O一般就紧接着发生了，块设备则不然，它利用一块系统内存作缓冲区，当用户进程对设备请求能满足用户的要求，就返回请求的数据，如果不能，就调用请求函数来进行实际的I/O操作。块设备是主要针对磁盘等慢速设备设计的，以免耗费过多的CPU时间来等待。 已经提到，用户进程是通过设备文件来与实际的硬件打交道。每个设备文件都都有其文件属性(c/b)，表示是字符设备还是块设备?另外每个文件都有两个设备号，第一个是主设备号，标识驱动程序，第二个是从设备号，标识使用同一个设备驱动程序的不同的硬件设备，比如有两个软盘，就可以用从设备号来区分他
怎样写linux下的USB设备驱动程序 发布时间：2007年11月19日 引言 随着人们生活水平的提高，我们用到的USB设备也越来越多，但是Linux在硬件配置上仍然没有做到完全即插即用，对于Linux怎样配置和使用他们，也越来越成为困扰我们的一大问题；本文的目地是使大家了解怎样编制USB设备驱动，为更好地配置和使用USB设备提供方便；对于希望开发Linux系统下USB设备驱动的人员，也可作为进一步学习USB驱动的大体架构进而编写出特殊USB设备的驱动程序。 USB基础知识 USB是英文Universal Serial Bus的缩写，意为通用串行总线。USB最初是为了替代许多不同的低速总线（包括并行、串行和键盘连接）而设计的，它以单一类型的总线连接各种不同的类型的设备。USB的发展已经超越了这些低速的连接方式，它现在可以支持几乎所有可以连接到PC上的设备。最新的USB规范修订了理论上高达480Mbps的高速连接。Linux内核支持两种主要类型的USB驱动程序：宿主系统上的驱动程序和设备上的驱动程序，从宿主的观点来看（一个普通的宿主也就是一个PC机），宿主系统的USB设备驱动程序控制插入其中的USB设备，而USB设备的驱动程序控制该设备如何作为一个USB设备和主机通信。本文将详细介绍运行于PC机上的USB系统是如何运作的。并同时用USB驱动程序的框架程序当例子作详细的说明，我们在此文中不讨论USB器件的驱动程序。 USB驱动程序基础 在动手写USB驱动程序这前，让我们先看看写的USB驱动程序在内核中的结构，如下图： USB驱动程序存在于不同的内核子系统和USB硬件控制器之间，USB核心为USB驱动程序提供了一个用于访问和控制USB硬件的接口，而不必考虑系统当前存在的各种不同类型的USB硬件控制器。USB是一个非常复杂的设备，linux内核为我们提供了一个称为USB的核心的子系统来处理大部分的复杂性，USB
收稿日期:2005-09-22 作者简介:朱华生(1965-),男,江西临川人,副教授. 文章编号:1006-4869(2005)04-0051-03 基于Linux 系统的HHARM9电机驱动程序设计 朱华生,胡凯利 (南昌工程学院计算机科学与技术系,江西南昌330099) 摘 要:对嵌入式Linux 操作系统驱动程序的组成进行分析,讨论了驱动程序的基本框架,以HHARM9电机控制为实例,详细论述了电机驱动程序的实现过程. 关键词:嵌入式;Linux;驱动程序 中图分类号:TP316 文献标识码:A Linux System -Based Design of HHARM 9Electromotor Driver ZHU Hua -sheng,HU Ka-i li (Department of Computer and Science,Nanchang Institute of Technology,Nanchang 330099,China) Abstract:The paper analyses the composition of driver in embedded linux system,disuses its basic frame of driver,and illustrales the process of driver design of HHARM9electromotor in detail. Key words:Embedded;Linux; driver 嵌入式Linux 操作系统因具有免费、开放源代码、强大的网络功能等 特点,在嵌入式产品中得到越来越广泛的应用.基于Linux 操作系统的嵌入 式产品结构[1]如图1所示.本文主要探讨嵌入式系统驱动程序的设计. 1 嵌入式Linux 操作系统驱动程序简介 1)驱动程序和应用程序的区别 驱动程序的设计和应用程序的设计有很大的区别[2].首先,驱动程序 的设计要对硬件的结构、信号的工作流程十分清楚,而在应用程序的设计 中,一般不需要了解这些.其次,应用程序一般有一个main 函数,从头到尾 执行一个任务;驱动程序却不同,它没有main 函数,通过使用宏module _init(初始化函数名),将初始化函数加入内核全局初始化函数列表中,在内核初始化时执行驱动的初始化函数,从而完成驱动的初始化和注册,之后驱动便停止等待被应用软件调用.应用程序可以和GLIB C 库连接,因此可以包含标准的头文件,比如
字符设备驱动程序 实验报告 院系名称： 学生姓名： 学号： 专业名称： 班级： 年月日至时间： 年月日
实验题目字符设备驱动程序 一、实验目的 通过编写一个简单的C语言字符设备驱动程序，来加深对上次的内存管理实验的复习，以及对本次学习的字符设备驱动的应用。 二、实验内容 编写一个字符设备驱动程序，以内核模块的形式插入内核，编译方法与内核编译方法一致。创建设备节点，然后通过编写一个测试程序，输出“hello world！”。 三、实验步骤 ①用C语言编写一个字符设备驱动程序； ②编译，链接，将程序插入内核模块中； ③创建设备节点，编写测试程序，运行输出“hello world”。 四、调试以及运行过程 因为用的是学校的电脑，在运行时，就出现错误。开始是怎么都插不进去模块。最后发现原来是makefile文件开始用小写，后来改成Makefile,，竟然对了。虽然最后显示内核模块插入了，但是无法进行编译，总是显示，无法正常运行。最后，把代码拷进同学电脑里，对了。才发现，有时要相信自己，换一个位置去试，就会发现惊喜。 五、心得体会 对于程序，我们要多练，才能懂得其真正的用处在哪里。没有编写程序运行前只知道一点皮毛，真正操作后才会受益匪浅。通过编写字符设备驱动程序，我知道了当我们不会写代码时，可以先试着把别人的类似代码敲一遍，然后找出那种属于自己的感觉，理解清楚别人的思想，然后根据需要编写属于自己的代码。 六、源代码 1.字符设备驱动程序 #include
ARM-uClinux下编写加载驱动程序详细过程 本文主要介绍在uClinux下，通过加载模块的方式调试IO控制蜂鸣器的驱动程序。实验过程与上篇文章所讲的过程基本相似，更多注重细节及注意事项。 本文适合学习ARM—Linux的初学者。 //================================================================== 硬件平台：MagicARM2200教学试验开发平台（LPC2290） Linux version 2.4.24，gcc version 2.95.3 电路连接：P0.7——蜂鸣器，低电平发声。 实验条件：uClinux内核已经下载到开发板上，能够正常运行；与宿主机相连的网络、串口连接正常。 //================================================================== 编写蜂鸣器的驱动程序相对来说容易实现，不需要处理中断等繁琐的过程，本文以蜂鸣器的驱动程序为例，详细说明模块化驱动程序设计的主要过程和注意事项。 一、编写驱动程序 驱动程序的编写与上文所说的编写过程基本相同，这里再详细说明一下。 //========================================== //蜂鸣器驱动程序：beep.c文件 //------------------------------------------------------------------- #include
远见品质
Linux内核与C代码
v Linux内核庞大，结构复杂
? 对Linux 2.4内核的统计：1万个文件，4百万行代码 ? 对Linux 2.6内核的统计：1.5万个文件，6百万行代码
v Linux内核的主体使用GNU C，在ANSI C
上进行了扩充
? Linux内核必须由gcc编译编译 ? gcc和Linux内核版本并行发展，对于版本的依赖性强 ? Linux 2.6内核建议使用gcc 3.3以上版本，C99编程风格
v 内核代码中使用的一些编程技巧，在通常
的应用程序中很少遇到
v 学好Linux、首先要学好C语言
《基于Ｌｉｎｕｘ的驱动开发》ＰＤＦ课件
远见品质
linux 2.4 的内核目录结构
/arch /arch /drivers /drivers /kernel /kernel /lib /lib /boot /boot
/arm /arm
/alpha /alpha
/m68k /m68k /kernel /kernel /lib /mm /lib /mm
/mach-s3c2410 /mach-s3c2410
/Documentation /Documentation /ipc /ipc /fs /fs Linux2.4.x Linux2.4.x /include /include /mm /mm /init /init /net /net /scripts /scripts /asm-arm /asm-arm /arch-s3c2410 /arch-s3c2410 /linux /linux /proc-armv /proc-armv /net /net
《基于Ｌｉｎｕｘ的驱动开发》ＰＤＦ课件