Linux 字符设备驱动结构（一）

一、字符设备基础知识

1、设备驱动分类

      linux系统将设备分为3类：字符设备、块设备、网络设备。使用驱动程序：

 

字符设备：是指只能一个字节一个字节读写的设备，不能随机读取设备内存中的某一数据，读取数据需要按照先后数据。字符设备是面向流的设备，常见的字符设备有鼠标、键盘、串口、控制台和LED设备等。

块设备：是指可以从设备的任意位置读取一定长度数据的设备。块设备包括硬盘、磁盘、U盘和SD卡等。

每一个字符设备或块设备都在/dev目录下对应一个设备文件。linux用户程序通过设备文件（或称设备节点）来使用驱动程序操作字符设备和块设备。

 

2、字符设备、字符设备驱动与用户空间访问该设备的程序三者之间的关系

     如图，在Linux内核中：

a -- 使用cdev结构体来描述字符设备;

b -- 通过其成员dev_t来定义设备号（分为主、次设备号）以确定字符设备的唯一性;

c -- 通过其成员file_operations来定义字符设备驱动提供给VFS的接口函数，如常见的open()、read()、write()等;

 

     在Linux字符设备驱动中:

a -- 模块加载函数通过 register_chrdev_region( ) 或 alloc_chrdev_region( )来静态或者动态获取设备号;

b -- 通过 cdev_init( ) 建立cdev与 file_operations之间的连接，通过 cdev_add( ) 向系统添加一个cdev以完成注册;

c -- 模块卸载函数通过cdev_del( )来注销cdev，通过 unregister_chrdev_region( )来释放设备号;

     用户空间访问该设备的程序:

a -- 通过Linux系统调用，如open( )、read( )、write( )，来“调用”file_operations来定义字符设备驱动提供给VFS的接口函数;

 

3、字符设备驱动模型

 

二、cdev 结构体解析

      在Linux内核中，使用cdev结构体来描述一个字符设备，cdev结构体的定义如下：

 

1. <include/linux/cdev.h>

2.  

3. struct cdev {

4. struct kobject kobj; //内嵌的内核对象.

5. struct module *owner; //该字符设备所在的内核模块的对象指针.

6. const struct file_operations *ops; //该结构描述了字符设备所能实现的方法，是极为关键的一个结构体.

7. struct list_head list; //用来将已经向内核注册的所有字符设备形成链表.

8. dev_t dev; //字符设备的设备号，由主设备号和次设备号构成.

9. unsigned int count; //隶属于同一主设备号的次设备号的个数.

10. };

内核给出的操作struct cdev结构的接口主要有以下几个:

 

a -- void cdev_init(struct cdev *, const struct file_operations *);

其源代码如代码清单如下：

 

1. void cdev_init(struct cdev *cdev, const struct file_operations *fops)

2. {

3. memset(cdev, 0, sizeof *cdev);

4. INIT_LIST_HEAD(&cdev->list);

5. kobject_init(&cdev->kobj, &ktype_cdev_default);

6. cdev->ops = fops;

7. }

      该函数主要对struct cdev结构体做初始化，最重要的就是建立cdev 和 file_operations之间的连接：

 

(1) 将整个结构体清零；

(2) 初始化list成员使其指向自身；

(3) 初始化kobj成员；

(4) 初始化ops成员；

 b --struct cdev *cdev_alloc(void);

     该函数主要分配一个struct cdev结构，动态申请一个cdev内存，并做了cdev_init中所做的前面3步初始化工作(第四步初始化工作需要在调用cdev_alloc后，显式的做初始化即: .ops=xxx_ops).

其源代码清单如下：

 

1. struct cdev *cdev_alloc(void)

2. {

3. struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);

4. if (p) {

5. INIT_LIST_HEAD(&p->list);

6. kobject_init(&p->kobj, &ktype_cdev_dynamic);

7. }

8. return p;

9. }

     在上面的两个初始化的函数中，我们没有看到关于owner成员、dev成员、count成员的初始化；其实，owner成员的存在体现了驱动程序与内核模块间的亲密关系，struct module是内核对于一个模块的抽象，该成员在字符设备中可以体现该设备隶属于哪个模块，在驱动程序的编写中一般由用户显式的初始化 .owner = THIS_MODULE, 该成员可以防止设备的方法正在被使用时，设备所在模块被卸载。而dev成员和count成员则在cdev_add中才会赋上有效的值。

 
c -- int cdev_add(struct cdev *p, dev_t dev, unsigned count);

       该函数向内核注册一个struct cdev结构，即正式通知内核由struct cdev *p代表的字符设备已经可以使用了。

当然这里还需提供两个参数：

(1)第一个设备号 dev，

(2)和该设备关联的设备编号的数量。

这两个参数直接赋值给struct cdev 的dev成员和count成员。

 

d -- void cdev_del(struct cdev *p)；

     该函数向内核注销一个struct cdev结构，即正式通知内核由struct cdev *p代表的字符设备已经不可以使用了。

     从上述的接口讨论中，我们发现对于struct cdev的初始化和注册的过程中，我们需要提供几个东西

(1) struct file_operations结构指针；

(2) dev设备号；

(3) count次设备号个数。

但是我们依旧不明白这几个值到底代表着什么，而我们又该如何去构造这些值！

 

 

三、设备号相应操作

1 -- 主设备号和次设备号（二者一起为设备号）：

      一个字符设备或块设备都有一个主设备号和一个次设备号。主设备号用来标识与设备文件相连的驱动程序，用来反映设备类型。次设备号被驱动程序用来辨别操作的是哪个设备，用来区分同类型的设备。

　　linux内核中，设备号用dev_t来描述，2.6.28中定义如下：

　　typedef u_long dev_t;

　　在32位机中是4个字节，高12位表示主设备号，低20位表示次设备号。

内核也为我们提供了几个方便操作的宏实现dev_t：

1) -- 从设备号中提取major和minor

MAJOR(dev_t dev);　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 

MINOR(dev_t dev);

2) -- 通过major和minor构建设备号

MKDEV(int major,int minor);

注：这只是构建设备号。并未注册，需要调用 register_chrdev_region 静态申请；

 

1. //宏定义：

2. #define MINORBITS 20

3. #define MINORMASK ((1U << MINORBITS) - 1)

4. #define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))

5. #define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))

6. #define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi))</span>

 

2、分配设备号（两种方法）：

a -- 静态申请：

int register_chrdev_region(dev_t from, unsigned count, const char *name)；

其源代码清单如下：

1. int register_chrdev_region(dev_t from, unsigned count, const char *name)

2. {

3. struct char_device_struct *cd;

4. dev_t to = from + count;

5. dev_t n, next;

6.  

7. for (n = from; n < to; n = next) {

8. next = MKDEV(MAJOR(n)+1, 0);

9. if (next > to)

10. next = to;

11. cd = __register_chrdev_region(MAJOR(n), MINOR(n),

12. next - n, name);

13. if (IS_ERR(cd))

14. goto fail;

15. }

16. return 0;

17. fail:

18. to = n;

19. for (n = from; n < to; n = next) {

20. next = MKDEV(MAJOR(n)+1, 0);

21. kfree(__unregister_chrdev_region(MAJOR(n), MINOR(n), next - n));

22. }

23. return PTR_ERR(cd);

24. }

b -- 动态分配：

int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name)；

其源代码清单如下：

 

1. int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,

2. const char *name)

3. {

4. struct char_device_struct *cd;

5. cd = __register_chrdev_region(0, baseminor, count, name);

6. if (IS_ERR(cd))

7. return PTR_ERR(cd);

8. *dev = MKDEV(cd->major, cd->baseminor);

9. return 0;

10. }

可以看到二者都是调用了__register_chrdev_region 函数，其源代码如下：

1. static struct char_device_struct *

2. __register_chrdev_region(unsigned int major, unsigned int baseminor,

3. int minorct, const char *name)

4. {

5. struct char_device_struct *cd, **cp;

6. int ret = 0;

7. int i;

8.  

9. cd = kzalloc(sizeof(struct char_device_struct), GFP_KERNEL);

10. if (cd == NULL)

11. return ERR_PTR(-ENOMEM);

12.  

13. mutex_lock(&chrdevs_lock);

14.  

15. /* temporary */

16. if (major == 0) {

17. for (i = ARRAY_SIZE(chrdevs)-1; i > 0; i--) {

18. if (chrdevs[i] == NULL)

19. break;

20. }

21.  

22. if (i == 0) {

23. ret = -EBUSY;

24. goto out;

25. }

26. major = i;

27. ret = major;

28. }

29.  

30. cd->major = major;

31. cd->baseminor = baseminor;

32. cd->minorct = minorct;

33. strlcpy(cd->name, name, sizeof(cd->name));

34.  

35. i = major_to_index(major);

36.  

37. for (cp = &chrdevs[i]; *cp; cp = &(*cp)->next)

38. if ((*cp)->major > major ||

39. ((*cp)->major == major &&

40. (((*cp)->baseminor >= baseminor) ||

41. ((*cp)->baseminor + (*cp)->minorct > baseminor))))

42. break;

43.  

44. /* Check for overlapping minor ranges. */

45. if (*cp && (*cp)->major == major) {

46. int old_min = (*cp)->baseminor;

47. int old_max = (*cp)->baseminor + (*cp)->minorct - 1;

48. int new_min = baseminor;

49. int new_max = baseminor + minorct - 1;

50.  

51. /* New driver overlaps from the left. */

52. if (new_max >= old_min && new_max <= old_max) {

53. ret = -EBUSY;

54. goto out;

55. }

56.  

57. /* New driver overlaps from the right. */

58. if (new_min <= old_max && new_min >= old_min) {

59. ret = -EBUSY;

60. goto out;

61. }

62. }

63.  

64. cd->next = *cp;

65. *cp = cd;

66. mutex_unlock(&chrdevs_lock);

67. return cd;

68. out:

69. mutex_unlock(&chrdevs_lock);

70. kfree(cd);

71. return ERR_PTR(ret);

72. }

 通过这个函数可以看出 register_chrdev_region和 alloc_chrdev_region 的区别，register_chrdev_region直接将Major 注册进入，而 alloc_chrdev_region从Major = 0 开始，逐个查找设备号，直到找到一个闲置的设备号，并将其注册进去；

 

二者应用可以简单总结如下：

                                     register_chrdev_region                                                alloc_chrdev_region 

 

devno = MKDEV(major,minor);     ret = register_chrdev_region(devno, 1, "hello");      cdev_init(&cdev,&hello_ops);     ret = cdev_add(&cdev,devno,1);

alloc_chrdev_region(&devno, minor, 1, "hello");     major = MAJOR(devno);     cdev_init(&cdev,&hello_ops);     ret = cdev_add(&cdev,devno,1)

register_chrdev(major,"hello",&hello

     可以看到，除了前面两个函数，还加了一个register_chrdev 函数，可以发现这个函数的应用非常简单，只要一句就可以搞定前面函数所做之事；

下面分析一下register_chrdev 函数，其源代码定义如下：

 

1. static inline int register_chrdev(unsigned int major, const char *name,

2. const struct file_operations *fops)

3. {

4. return __register_chrdev(major, 0, 256, name, fops);

5. }

调用了 __register_chrdev(major, 0, 256, name, fops) 函数：

1. int __register_chrdev(unsigned int major, unsigned int baseminor,

2. unsigned int count, const char *name,

3. const struct file_operations *fops)

4. {

5. struct char_device_struct *cd;

6. struct cdev *cdev;

7. int err = -ENOMEM;

8.  

9. cd = __register_chrdev_region(major, baseminor, count, name);

10. if (IS_ERR(cd))

11. return PTR_ERR(cd);

12.  

13. cdev = cdev_alloc();

14. if (!cdev)

15. goto out2;

16.  

17. cdev->owner = fops->owner;

18. cdev->ops = fops;

19. kobject_set_name(&cdev->kobj, "%s", name);

20.  

21. err = cdev_add(cdev, MKDEV(cd->major, baseminor), count);

22. if (err)

23. goto out;

24.  

25. cd->cdev = cdev;

26.  

27. return major ? 0 : cd->major;

28. out:

29. kobject_put(&cdev->kobj);

30. out2:

31. kfree(__unregister_chrdev_region(cd->major, baseminor, count));

32. return err;

33. }

可以看到这个函数不只帮我们注册了设备号，还帮我们做了cdev 的初始化以及cdev 的注册；
 

 

3、注销设备号：

void unregister_chrdev_region(dev_t from, unsigned count)；

 

4、创建设备文件：

     利用cat /proc/devices查看申请到的设备名，设备号。

1）使用mknod手工创建：mknod filename type major minor

2）自动创建设备节点:

    利用udev（mdev）来实现设备文件的自动创建，首先应保证支持udev（mdev），由busybox配置。在驱动初始化代码里调用class_create为该设备创建一个class，再为每个设备调用device_create创建对应的设备。

    详细解析见：Linux 字符设备驱动开发 （二）—— 自动创建设备节点

 

下面看一个实例,练习一下上面的操作：

hello.c

1. #include <linux/module.h>

2. #include <linux/fs.h>

3. #include <linux/cdev.h>

4. static int major = 250;

5. static int minor = 0;

6. static dev_t devno;

7. static struct cdev cdev;

8. static int hello_open (struct inode *inode, struct file *filep)

9. {

10. printk("hello_open \n");

11. return 0;

12. }

13. static struct file_operations hello_ops=

14. {

15. .open = hello_open,

16. };

17.  

18. static int hello_init(void)

19. {

20. int ret;

21. printk("hello_init");

22. devno = MKDEV(major,minor);

23. ret = register_chrdev_region(devno, 1, "hello");

24. if(ret < 0)

25. {

26. printk("register_chrdev_region fail \n");

27. return ret;

28. }

29. cdev_init(&cdev,&hello_ops);

30. ret = cdev_add(&cdev,devno,1);

31. if(ret < 0)

32. {

33. printk("cdev_add fail \n");

34. return ret;

35. }

36. return 0;

37. }

38. static void hello_exit(void)

39. {

40. cdev_del(&cdev);

41. unregister_chrdev_region(devno,1);

42. printk("hello_exit \n");

43. }

44. MODULE_LICENSE("GPL");

45. module_init(hello_init);

46. module_exit(hello_exit);

测试程序 test.c

1. #include <sys/types.h>

2. #include <sys/stat.h>

3. #include <fcntl.h>

4. #include <stdio.h>

5.  

6. main()

7. {

8. int fd;

9.  

10. fd = open("/dev/hello",O_RDWR);

11. if(fd<0)

12. {

13. perror("open fail \n");

14. return ;

15. }

16.  

17. close(fd);

18. }

makefile:

1. ifneq ($(KERNELRELEASE),)

2. obj-m:=hello.o

3. $(info "2nd")

4. else

5. KDIR := /lib/modules/$(shell uname -r)/build

6. PWD:=$(shell pwd)

7. all:

8. $(info "1st")

9. make -C $(KDIR) M=$(PWD) modules

10. clean:

11. rm -f *.ko *.o *.symvers *.mod.c *.mod.o *.order

12. endif

 

编译成功后，使用 insmod 命令加载：

然后用cat /proc/devices 查看，会发现设备号已经申请成功；