一、Linux device driver的概念

系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口。设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。设备驱动程序是内核的一部分，它完成以下的功能:

1、对设备初始化和释放；

2、把数据从内核传送到硬件和从硬件读取数据；

3、读取应用程序传送给设备文件的数据和回送应用程序请求的数据；

4、检测和处理设备出现的错误。

在linux操作系统下有三类主要的设备文件类型，一是字符设备，二是块设备，三是网络设备。字符设备和块设备的主要区别是：在对字符设备发出读/写请求时，实际的硬件I/O一般就紧接着发生了，块设备则不然，它利用一块系统内存作缓冲区，当用户进程对设备请求能满足用户的要求，就返回请求的数据，如果不能，就调用请求函数来进行实际的I/O操作。块设备是主要针对磁盘等慢速设备设计的，以免耗费过多的CPU时间来等待。

0 z" f  T9 e+ N; J  I$ ~& G

已经提到，用户进程是通过设备文件来与实际的硬件打交道。每个设备文件都都有其文件属性(c/b)，表示是字符设备还是块设备?另外每个文件都有两个设备号，第一个是主设备号，标识驱动程序，第二个是从设备号，标识使用同一个设备驱动程序的不同的硬件设备，比如有两个软盘，就可以用从设备号来区分他们。设备文件的的主设备号必须与设备驱动程序在登记时申请的主设备号一致，否则用户进程将无法访问到驱动程序。

+ G0 C5 u$ D) N5 Z; \4 V

最后必须提到的是，在用户进程调用驱动程序时，系统进入核心态，这时不再是抢先式调度。也就是说，系统必须在你的驱动程序的子函数返回后才能进行其他的工作。如果你的驱动程序陷入死循环，不幸的是你只有重新启动机器了，然后就是漫长的fsck。

( E5 @: j- D1 Z& s; T9 P2 S1 A

二、实例剖析

  l9 ]' |1 f! u2 u% z% I1 T

我们来写一个最简单的字符设备驱动程序。虽然它什么也不做，但是通过它可以了解Linux的设备驱动程序的工作原理。把下面的C代码输入机器，你就会获得一个真正的设备驱动程序。

由于用户进程是通过设备文件同硬件打交道，对设备文件的操作方式不外乎就是一些系统调用，如 open，read，write，close…， 注意，不是fopen， fread，但是如何把系统调用和驱动程序关联起来呢?这需要了解一个非常关键的数据结构：

1. 
   
2. struct file_operations {
   1 O) d$ s8 @: v& Z4 ~% t
3. int (*seek) (struct inode * ，struct file *， off_t ，int);
   " R; _+ D6 T/ Q2 H. R3 a% ?$ Q
4. int (*read) (struct inode * ，struct file *， char ，int);
   
5. int (*write) (struct inode * ，struct file *， off_t ，int);
   
6. int (*readdir) (struct inode * ，struct file *， struct dirent * ，int); int (*select) (struct inode * ，struct file *， int ，select_table *);
   5 T8 x$ @, s* I' O4 S2 Y
7. int (*ioctl) (struct inode * ，struct file *， unsined int ，unsigned long);
   4 w5 e, H* Z- |% W, x
8. int (*mmap) (struct inode * ，struct file *， struct vm_area_struct *);
   5 X+ m+ ~' {$ X+ y4 h" W* b
9. int (*open) (struct inode * ，struct file *);
   
10. int (*release) (struct inode * ，struct file *);
    ( E- G# f. o( {' N
11. int (*fsync) (struct inode * ，struct file *);
    
12. int (*fasync) (struct inode * ，struct file *，int);
    ; j; n& I' a4 N. N8 Z5 o$ O1 Y
13. int (*check_media_change) (struct inode * ，struct file *);
    
14. int (*revalidate) (dev_t dev);
    ' ^% v/ C; M, ]# @$ t& v# y
15. }

复制代码

这个结构的每一个成员的名字都对应着一个系统调用。用户进程利用系统调用在对设备文件进行诸如read/write操作时，系统调用通过设备文件的主设备号找到相应的设备驱动程序，然后读取这个数据结构相应的函数指针，接着把控制权交给该函数。这是linux的设备驱动程序工作的基本原理。既然是这样，则编写设备驱动程序的主要工作就是编写子函数，并填充file_operations的各个域。

) E( K, `8 a. ]0 m& a: e

下面就开始写子程序：

1. 
   
2. #include <linux/types.h> 基本的类型定义
   - P8 j' |4 Q4 e5 ^2 ]5 b
3. #include <linux/fs.h> 文件系统使用相关的头文件
     w, R/ n+ s  Q! \
4. #include <linux/mm.h>
   8 {3 o9 q& P8 S) p. c- C& f
5. #include <linux/errno.h>
   
6. #include <asm/segment.h>
   
7. unsigned int test_major = 0;
   
8. static int read_test(struct inode *inode，struct file *file，char *buf，int count)
   
9. {
   
10. int left; 用户空间和内核空间
    8 A/ V+ m; q9 w! m
11. if (verify_area(VERIFY_WRITE，buf，count) == -EFAULT )
    
12. return -EFAULT;
    
13. for(left = count ; left > 0 ; left--)
    1 u' v$ c! t# Q" t7 h" B% u1 [  y$ k- Q
14. {
    
15. __put_user(1，buf，1);
    
16. buf++;
    / ~9 v; J; A: m. P
17. }
    3 ^% L$ z  _# i% C+ e; x9 ?
18. return count;
      x& O5 P' s# Q, ^, ~! m5 z. X- d
19. }

复制代码

) l1 \# u- Q+ C

这个函数是为read调用准备的。当调用read时，read_test()被调用，它把用户的缓冲区全部写1。buf 是read调用的一个参数。它是用户进程空间的一个地址。但是在read_test被调用时，系统进入核心态。所以不能使用buf这个地址，必须用__put_user()，这是kernel提供的一个函数，用于向用户传送数据。另外还有很多类似功能的函数。请参考，在向用户空间拷贝数据之前，必须验证buf是否可用。这就用到函数verify_area。为了验证BUF是否可以用。

1. 
   ( k: C; ]; T- _* y. i
2. static int write_test(struct inode *inode，struct file *file，const char *buf，int count)
   
3. {
   
4. return count;
   5 i4 v1 M2 A1 y) Q6 F: B
5. }
   ' i, F- o, V/ l6 Y  S+ Q$ ~
6. static int open_test(struct inode *inode，struct file *file )
   
7. {
   9 D, s% W5 K7 Q! Q. @9 j
8. MOD_INC_USE_COUNT; 模块计数加以，表示当前内核有个设备加载内核当中去
   . k9 v% t! e7 s% P  {) E- e
9. return 0;
   2 g3 L. @5 ]8 x( Z* K& P
10. }
    ! r( Z. D' h& ]# X. C
11. static void release_test(struct inode *inode，struct file *file )
    - j7 U4 l6 l3 P8 g* @
12. {
    0 n* n) Z$ I  M' i4 Q3 Z) z
13. MOD_DEC_USE_COUNT;
    . C9 p- O: _0 c0 H( v
14. }

复制代码

6 k) \! o/ e: A- F2 E+ ^

这几个函数都是空操作。实际调用发生时什么也不做，他们仅仅为下面的结构提供函数指针。

1. 
   7 m  B7 I$ N# t! a4 K8 ^
2. struct file_operations test_fops = {?
   / ]3 c# F6 t) m' C' ~
3. read_test，
   
4. write_test，
   
5. open_test，
   
6. release_test，
   
7. };

复制代码

设备驱动程序的主体可以说是写好了。现在要把驱动程序嵌入内核。驱动程序可以按照两种方式编译。一种是编译进kernel，另一种是编译成模块(modules)，如果编译进内核的话，会增加内核的大小，还要改动内核的源文件，而且不能动态的卸载，不利于调试，所以推荐使用模块方式。

1. 
   
2. int init_module(void)
   
3. {
   9 T# n  Q# X/ _- v
4. int result;
   
5. result = register_chrdev(0， "test"， &test_fops); 对设备操作的整个接口
   ( k: U9 ^+ q0 l5 }, F1 j
6. if (result < 0) {
   + M+ D3 Z3 v$ @) x0 r
7. printk(KERN_INFO "test: can't get major number\n");
   4 x* s! J$ Y; y) ^
8. return result;
   
9. }
   
10. if (test_major == 0) test_major = result; /* dynamic */
    7 f. \; ^$ Y2 V; \" `7 A3 C
11. return 0;
    ( _) ]% E8 o8 [. P8 P1 v( i
12. }

复制代码

在用insmod命令将编译好的模块调入内存时，init_module 函数被调用。在这里，init_module只做了一件事，就是向系统的字符设备表登记了一个字符设备。register_chrdev需要三个参数，参数一是希望获得的设备号，如果是零的话，系统将选择一个没有被占用的设备号返回。参数二是设备文件名，参数三用来登记驱动程序实际执行操作的函数的指针。

/ O  ?  s" d  ~

如果登记成功，返回设备的主设备号，不成功，返回一个负值。

1. 
   8 b  S3 w' b5 v) S, g3 `" c3 V
2. void cleanup_module(void)
   
3. {
   % l, w! Z* }. S  k3 i
4. unregister_chrdev(test_major，"test");
   % c, X4 H! E3 d1 V% ?' J
5. }

复制代码

在用rmmod卸载模块时，cleanup_module函数被调用，它释放字符设备test在系统字符设备表中占有的表项。

2 M+ c! J. s) K4 R1 ^3 k9 k7 A1 G

一个极其简单的字符设备可以说写好了，文件名就叫test.c吧。

下面编译 :

4 a  j$ H: d$ v7 v4 }, t

$ gcc -O2 -DMODULE -D__KERNEL__ -c test.c –c表示输出制定名，自动生成.o文件

得到文件test.o就是一个设备驱动程序。

如果设备驱动程序有多个文件，把每个文件按上面的命令行编译，然后

ld ?-r ?file1.o ?file2.o ?-o ?modulename。

* ]6 P% `. I, P7 i& x+ z" _/ ?

驱动程序已经编译好了，现在把它安装到系统中去。

$ insmod ?–f ?test.o

如果安装成功，在/proc/devices文件中就可以看到设备test，并可以看到它的主设备号。要卸载的话，运行 :

$ rmmod test

下一步要创建设备文件。

mknod /dev/test c major minor

c 是指字符设备，major是主设备号，就是在/proc/devices里看到的。

用shell命令

3 T. `7 c8 Y4 Z4 }

$ cat /proc/devices

就可以获得主设备号，可以把上面的命令行加入你的shell script中去。

minor是从设备号，设置成0就可以了。

我们现在可以通过设备文件来访问我们的驱动程序。写一个小小的测试程序。

1. 
   
2. #include <stdio.h>
   
3. #include <sys/types.h>
   
4. #include <sys/stat.h>
   ( V0 s- G8 R0 z& r  s0 ?
5. #include <fcntl.h>
   
6. main()
   1 p1 ]( g, R$ x& ~
7. {
   
8. int testdev;
   
9. int i;
   3 h6 t  Z+ L* T+ }" s  _1 O
10. char buf[10];
    
11. testdev = open("/dev/test"，O_RDWR);
    
12. if ( testdev == -1 ) {
    
13. printf("Cann't open file \n");
    
14. exit(0);
    
15. }
    
16. read(testdev，buf，10);
    
17. for (i = 0; i < 10;i++)
    ! g$ X7 U( A0 s3 d/ E
18. printf("%d\n"，buf[i]);
    
19. close(testdev);
    0 k8 W- N0 A( h$ H
20. }

复制代码

编译运行，看看是不是打印出全1 ？

/ ]' H/ E6 r9 H) _0 V% }) d6 c% J$ c" `

以上只是一个简单的演示。真正实用的驱动程序要复杂的多，要处理如中断，DMA，I/O port等问题。这些才是真正的难点。上述给出了一个简单的字符设备驱动编写的框架和原理，更为复杂的编写需要去认真研究LINUX内核的运行机制和具体的设备运行的机制等等。希望大家好好掌握LINUX设备驱动程序编写的方法。