*/:~$ ls -l /dev/

total 0

brw-rw---- 1 root disk 7, 0 3月 25 10:34 loop0

brw-rw---- 1 root disk 7, 1 3月 25 10:34 loop1

brw-rw---- 1 root disk 7, 2 3月 25 10:34 loop2

crw-rw-rw- 1 root tty 5, 0 3月 25 12:48 tty

crw--w---- 1 root tty 4, 0 3月 25 10:34 tty0

crw-rw---- 1 root tty 4, 1 3月 25 10:34 tty1

crw--w---- 1 root tty 4, 10 3月 25 10:34 tty10

其中b代表塊設備，c代表字符設備。對於普通文件來說，ls -l會列出文件的長度，而對於設備文件來說，上面的7,5,4等代表的是對應設備的主設備號，而後面的0,1,2,10等則是對應設備的次設備號。那麽主設備號和次設備號分別代表什麽意義呢？一般情況下，可以這樣理解，主設備號標識設備對應的驅動程序，也就是說1個主設備號對應一個驅動程序。當然，現在也有多個驅動程序共享主設備號的情況。而次設備號有內核使用，用於確定/dev下的設備文件對應的具體設備。舉一個例子，虛擬控制臺和串口終端有驅動程序4管理，而不同的終端分別有不同的次設備號。

1.1、設備編號的表達

在內核中，dev_t用來保存設備編號，包括主設備號和次設備號。在2.6的內核版本種，dev_t是一個32位的數，其中12位用來表示主設備號，其余20位用來標識次設備號。 通過dev_t獲取主設備號和次設備號使用下面的宏： MAJOR(dev_t dev); MINOR(dev_t dev); 相反，通過主設備號和次設備號轉換為dev_t類型使用： MKDEV(int major, int minor);

1.2、分配和釋放設備編號

在構建一個字符設備之前，驅動程序首先要獲得一個或者多個設備編號，這類似一個營業執照，有了營業執照才在內核中正常工作營業。完成此工作的函數是： [cpp] view plain copy

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

first是要分配的設備編號範圍的起始值。count是連續設備的編號的個數。name是和該設備編號範圍關聯的設備名稱，他將出現在/proc/devices和sysfs中。此函數成功返回0，失敗返回負的錯誤碼。此函數是在已知主設備號的情況下使用，在未知主設備號的情況下，我們使用下面的函數： [cpp] view plain copy

1. int alloc_chrdev_region(dev_t *dev, unsigned int firstminor, unsigned int count, const char *name);

dev用於輸出申請到的設備編號，firstminor要使用的第一個此設備編號。 在不使用時需要釋放這些設備編號，已提供其他設備程序使用： [cpp] view plain copy

1. void unregister_chrdev_region(dev_t dev, unsigned int count);

此函數多在模塊的清除函數中調用。 分配到設備編號之後，我們只是拿到了營業執照，雖說現在已經準備的差不多了,但是我們只是從內核中申請到了設備號,應用程序還是不能對此設備作任何事情,我們需要一個簡單的函數來把設備編號和此設備能實現的功能連接起來,這樣我們的模塊才能提供具體的功能.這個操作很簡單，稍後就會提到，在此之前先介紹幾個重要的數據結構。

2、重要的數據結構

註冊設備編號僅僅是完成一個字符設備驅動的第一步。下面介紹大部分驅動都會包含的三個重要的內核的數據結構。

2.1、文件操作file_operations

file_operations是第一個重要的結構，定義在 <linux/fs.h>, 是一個函數指針的集合，設備所能提供的功能大部分都由此結構提供。這些操作也是設備相關的系統調用的具體實現。此結構的具體實現如下所示： [cpp] view plain copy

1. struct file_operations {
2. //它是一個指向擁有這個結構的模塊的指針. 這個成員用來在它的操作還在被使用時阻止模塊被卸載. 幾乎所有時間中, 它被簡單初始化為 THIS_MODULE
3. struct module *owner;
4. loff_t (*llseek) (struct file *, loff_t, int);
5. ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
6. ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
7. ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
8. ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
9. ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
10. ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
11. int (*iterate) (struct file *, struct dir_context *);
12. unsigned int (*poll) (struct file *, struct poll_table_struct *);
13. long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
14. long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
15. int (*mmap) (struct file *, struct vm_area_struct *);
16. int (*open) (struct inode *, struct file *);
17. int (*flush) (struct file *, fl_owner_t id);
18. int (*release) (struct inode *, struct file *);
19. int (*fsync) (struct file *, loff_t, loff_t, int datasync);
20. int (*aio_fsync) (struct kiocb *, int datasync);
21. int (*fasync) (int, struct file *, int);
22. int (*lock) (struct file *, int, struct file_lock *);
23. ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
24. unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
25. int (*check_flags)(int);
26. int (*flock) (struct file *, int, struct file_lock *);
27. ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
28. ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
29. int (*setlease)(struct file *, long, struct file_lock **);
30. long (*fallocate)(struct file *file, int mode, loff_t offset,
31. loff_t len);
32. int (*show_fdinfo)(struct seq_file *m, struct file *f);
33. };

需要說明的是這裏面的函數在驅動中不用全部實現，不支持的操作留置為NULL。

2.2、文件結構struct file

struct file, 定義於 <linux/fs.h>, 是設備驅動中第二個最重要的數據結構。文件結構代表一個打開的文件. (它不特定給設備驅動; 系統中每個打開的文件有一個關聯的 struct file 在內核空間). 它由內核在 open 時創建, 並傳遞給在文件上操作的任何函數, 直到最後的關閉. 在文件的所有實例都關閉後, 內核釋放這個數據結構。file結構的詳細可參考fs.h，這裏列出來幾個重要的成員。

• struct file_operations *f_op：就是上面剛剛介紹的文件操作的集合結構。
• mode_t f_mode：文件模式確定文件是可讀的或者是可寫的(或者都是), 通過位 FMODE_READ 和 FMODE_WRITE. 你可能想在你的 open 或者 ioctl 函數中檢查這個成員的讀寫許可, 但是你不需要檢查讀寫許可, 因為內核在調用你的方法之前檢查. 當文件還沒有為那種存取而打開時讀或寫的企圖被拒絕, 驅動甚至不知道這個情況
• loff_t f_pos：當前讀寫位置. loff_t 在所有平臺都是 64 位。驅動可以讀這個值, 如果它需要知道文件中的當前位置, 但是正常地不應該改變它。
• unsigned int f_flags：這些是文件標誌, 例如 O_RDONLY, O_NONBLOCK, 和 O_SYNC. 驅動應當檢查 O_NONBLOCK 標誌來看是否是請求非阻塞操作。
• void *private_data：open 系統調用設置這個指針為 NULL, 在為驅動調用 open 方法之前. 你可自由使用這個成員或者忽略它; 你可以使用這個成員來指向分配的數據, 但是接著你必須記住在內核銷毀文件結構之前, 在 release 方法中釋放那個內存. private_data 是一個有用的資源, 在系統調用間保留狀態信息, 我們大部分例子模塊都使用它

2.3、inode 結構

inode 結構由內核在內部用來表示文件. 因此, 它和代表打開文件描述符的文件結構是不同的. 可能有代表單個文件的多個打開描述符的許多文件結構, 但是它們都指向一個單個 inode 結構。

inode 結構包含大量關於文件的信息。但對於驅動程序編寫來說一般不用關心，暫且不說。

3、字符設備的註冊

內核在內部使用類型 struct cdev 的結構來代表字符設備. 在內核調用你的設備操作前, 你編寫分配並註冊一個或幾個這些結構。

有 2 種方法來分配和初始化一個這些結構. 如果你想在運行時獲得一個獨立的 cdev 結構, 你可以為此使用這樣的代碼:

[cpp] view plain copy

1. struct cdev *my_cdev = cdev_alloc();
2. my_cdev->ops = &my_fops;

更多的情況是把cdv結構嵌入到你自己封裝的設備結構中，這時需要使用下面的方法來分配和初始化： [cpp] view plain copy

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

後面的例子程序就是這麽做的。一旦 cdev 結構建立, 最後的步驟是把它告訴內核： [cpp] view plain copy

1. int cdev_add(struct cdev *dev, dev_t num, unsigned int count)

這裏, dev 是 cdev 結構, num 是這個設備響應的第一個設備號, count 是應當關聯到設備的設備號的數目. 常常 count 是 1。

從系統去除一個字符設備, 調用:

[cpp] view plain copy

1. void cdev_del(struct cdev *dev);

4、一個簡單的字符設備

上面大致介紹了實現一個字符設備所要做的工作，下面就來一個真實的例子來總結上面介紹的內容。源碼中的關鍵地方已經作了註釋。 [cpp] view plain copy

1. #include <linux/module.h>
2. #include <linux/types.h>
3. #include <linux/fs.h>
4. #include <linux/errno.h>
5. #include <linux/mm.h>
6. #include <linux/sched.h>
7. #include <linux/init.h>
8. #include <linux/cdev.h>
9. #include <asm/io.h>
10. #include <asm/uaccess.h>
11. #include <linux/timer.h>
12. #include <asm/atomic.h>
13. #include <linux/slab.h>
14. #include <linux/device.h>
16. #define CDEVDEMO_MAJOR 255 /*預設cdevdemo的主設備號*/
18. static int cdevdemo_major = CDEVDEMO_MAJOR;
20. /*設備結構體,此結構體可以封裝設備相關的一些信息等
21. 信號量等也可以封裝在此結構中，後續的設備模塊一般都
22. 應該封裝一個這樣的結構體，但此結構體中必須包含某些
23. 成員，對於字符設備來說，我們必須包含struct cdev cdev*/
24. struct cdevdemo_dev
25. {
26. struct cdev cdev;
27. };
29. struct cdevdemo_dev *cdevdemo_devp; /*設備結構體指針*/
31. /*文件打開函數，上層對此設備調用open時會執行*/
32. int cdevdemo_open(struct inode *inode, struct file *filp)
33. {
34. printk(KERN_NOTICE "======== cdevdemo_open ");
35. return 0;
36. }
38. /*文件釋放，上層對此設備調用close時會執行*/
39. int cdevdemo_release(struct inode *inode, struct file *filp)
40. {
41. printk(KERN_NOTICE "======== cdevdemo_release ");
42. return 0;
43. }
45. /*文件的讀操作，上層對此設備調用read時會執行*/
46. static ssize_t cdevdemo_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
47. {
48. printk(KERN_NOTICE "======== cdevdemo_read ");
49. }
51. /* 文件操作結構體，文中已經講過這個結構*/
52. static const struct file_operations cdevdemo_fops =
53. {
54. .owner = THIS_MODULE,
55. .open = cdevdemo_open,
56. .release = cdevdemo_release,
57. .read = cdevdemo_read,
58. };
60. /*初始化並註冊cdev*/
61. static void cdevdemo_setup_cdev(struct cdevdemo_dev *dev, int index)
62. {
63. printk(KERN_NOTICE "======== cdevdemo_setup_cdev 1");
64. int err, devno = MKDEV(cdevdemo_major, index);
65. printk(KERN_NOTICE "======== cdevdemo_setup_cdev 2");
67. /*初始化一個字符設備，設備所支持的操作在cdevdemo_fops中*/
68. cdev_init(&dev->cdev, &cdevdemo_fops);
69. printk(KERN_NOTICE "======== cdevdemo_setup_cdev 3");
70. dev->cdev.owner = THIS_MODULE;
71. dev->cdev.ops = &cdevdemo_fops;
72. printk(KERN_NOTICE "======== cdevdemo_setup_cdev 4");
73. err = cdev_add(&dev->cdev, devno, 1);
74. printk(KERN_NOTICE "======== cdevdemo_setup_cdev 5");
75. if(err)
76. {
77. printk(KERN_NOTICE "Error %d add cdevdemo %d", err, index);
78. }
79. }
81. int cdevdemo_init(void)
82. {
83. printk(KERN_NOTICE "======== cdevdemo_init ");
84. int ret;
85. dev_t devno = MKDEV(cdevdemo_major, 0);
87. struct class *cdevdemo_class;
88. /*申請設備號，如果申請失敗采用動態申請方式*/
89. if(cdevdemo_major)
90. {
91. printk(KERN_NOTICE "======== cdevdemo_init 1");
92. ret = register_chrdev_region(devno, 1, "cdevdemo");
93. }else
94. {
95. printk(KERN_NOTICE "======== cdevdemo_init 2");
96. ret = alloc_chrdev_region(&devno,0,1,"cdevdemo");
97. cdevdemo_major = MAJOR(devno);
98. }
99. if(ret < 0)
100. {
101. printk(KERN_NOTICE "======== cdevdemo_init 3");
102. return ret;
103. }
104. /*動態申請設備結構體內存*/
105. cdevdemo_devp = kmalloc(sizeof(struct cdevdemo_dev), GFP_KERNEL);
106. if(!cdevdemo_devp) /*申請失敗*/
107. {
108. ret = -ENOMEM;
109. printk(KERN_NOTICE "Error add cdevdemo");
110. goto fail_malloc;
111. }
113. memset(cdevdemo_devp,0,sizeof(struct cdevdemo_dev));
114. printk(KERN_NOTICE "======== cdevdemo_init 3");
115. cdevdemo_setup_cdev(cdevdemo_devp, 0);
117. /*下面兩行是創建了一個總線類型，會在/sys/class下生成cdevdemo目錄
118. 這裏的還有一個主要作用是執行device_create後會在/dev/下自動生成
119. cdevdemo設備節點。而如果不調用此函數，如果想通過設備節點訪問設備
120. 需要手動mknod來創建設備節點後再訪問。*/
121. cdevdemo_class = class_create(THIS_MODULE, "cdevdemo");
122. device_create(cdevdemo_class, NULL, MKDEV(cdevdemo_major, 0), NULL, "cdevdemo");
124. printk(KERN_NOTICE "======== cdevdemo_init 4");
125. return 0;
127. fail_malloc:
128. unregister_chrdev_region(devno,1);
129. }
131. void cdevdemo_exit(void) /*模塊卸載*/
132. {
133. printk(KERN_NOTICE "End cdevdemo");
134. cdev_del(&cdevdemo_devp->cdev); /*註銷cdev*/
135. kfree(cdevdemo_devp); /*釋放設備結構體內存*/
136. unregister_chrdev_region(MKDEV(cdevdemo_major,0),1); //釋放設備號
137. }
139. MODULE_LICENSE("Dual BSD/GPL");
140. module_param(cdevdemo_major, int, S_IRUGO);
141. module_init(cdevdemo_init);
142. module_exit(cdevdemo_exit);

Makefile文件如下： [plain] view plain copy

1. ifneq ($(KERNELRELEASE),)
2. obj-m := cdevdemo.o
3. else
4. KERNELDIR ?= /lib/modules/$(shell uname -r)/build
5. PWD := $(shell pwd)
6. default:
7. $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
8. endif
10. clean:
11. rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions modules.order Module.symvers

溫馨提示：測試環境為Linux ubuntu 3.16.0-33-generic。

5、總結

本篇主要介紹了簡單字符設備的編寫與實現以及其中的關鍵點。下一篇會主要講解下驅動的一些常用的調試技巧。

linux設備驅動第三篇：寫一個簡單的字符設備驅動