Linux设备驱动开发学习笔记

dongp

只读了几章ldd,先总结一下

1. 
   
2. Linux设备驱动开发学习笔记
   
3. 内核版本:2.6.x
   
4. 
   
5.   
   
6.   Major and Minor Numbers
   
7. 内核通过major号来识别设备,下面的命令列出的是系统上所连接的设备及其major number,第一列就是设备的major number.
   
8. $ cat /proc/devices
   
9. Character devices:
   
10.   1 mem
    
11.   4 /dev/vc/0
    
12.   4 tty
    
13.   5 /dev/tty
    
14.   5 /dev/console
    
15.   5 /dev/ptmx
    
16.   7 vcs
    
17. 10 misc
    
18. 13 input
    
19. 14 sound
    
20. 116 alsa
    
21. 128 ptm
    
22. 136 pts
    
23. 180 usb
    
24. 195 nvidia
    
25. 226 drm
    
26. 254 devfs
    
27. 
    
28. Block devices:
    
29.   3 ide0
    
30. 22 ide1
    
31. $ls -l /dev
    
32. ..............
    
33. crw-------  1 root root 119,   0 Apr 24 11:34 vmnet0
    
34. crw-------  1 root root 119,   1 Apr 24 11:34 vmnet1
    
35. crw-------  1 root root 119,   2 Apr 24 11:34 vmnet2
    
36. crw-------  1 root root 119,   3 Apr 24 11:34 vmnet3
    
37. crw-------  1 root root 119,   4 Apr 24 11:34 vmnet4
    
38. crw-------  1 root root 119,   5 Apr 24 11:34 vmnet5
    
39. crw-------  1 root root 119,   6 Apr 24 11:34 vmnet6
    
40. crw-------  1 root root 119,   7 Apr 24 11:34 vmnet7
    
41. crw-------  1 root root 119,   8 Apr 24 11:34 vmnet8
    
42. ..............
    
43. 可以看到他们的major number 是119,但他们的minor number不同.分别是0~8.
    
44. 内核只关心major number,而minor number 是由设备驱动来区别的.
    
45. 内核内部,类型dev_t存储着设备号,且定义了一组宏来维护它.
    
46.         MKDEV(int major,int minor);//return dev_t
    
47.         MAJOR( dev_t dev);
    
48.         MINOR (dev_t dev);
    
49. 比如,我们用mknod建立一个新的设备文件
    
50.         #mknod /dev/newchr c 50 0
    
51. 建立/dev/newchr设备文件,类型是c(char,字符型),major number 是50,minor number 是0.mknod的用法可以用man来查看.
    
52. 在内核内部,我们用上面的宏来维护:
    
53.         dev_t mydev;
    
54.         mydev=MKDEV(50,0);
    
55. 我们也可以由mydev得到major 和minor number.
    
56.         int major,minor;
    
57.         major=MAJOR(mydev);
    
58.         minor=MINOR(mydev);
    
59. 
    
60. 
    
61.   注册设备号
    
62. 我们定义好major和minor number 后就可以在内核中注册一个设备了.注册一个字符设备需要用到下面几个函数:
    
63.         int register_chrdev_region(dev_t first,unsigned int count,
    
64.                                                 char *name);
    
65. first是你要注册的设备号范围的开始(其中minor号一般设置为0),count是你所申请的连续设备号的总数.name是设备的名称.它会在/proc/devices中出现.
    
66.         int alloc_chrdev_region(dev_t *dev,unsigned int firstminor,
    
67.                                 unsigned int count,char *name);
    
68. 这个函数是用来动态分配设备号的.有余开发者不知道所要用的major号是多少,便让内核动态分配一个.参数dev是个output-only参数.
    
69.         void unregister_chrdev_region(dev_t first,unsigned int count);
    
70. 一般在模块清除函数中调用.
    
71. 
    
72. 重要的数据结构
    
73. 正如你所想象的,注册只是第一步,后面还有更重要的部分,其中一个就是我们一开始提到的如何实现open/read/write/ioctl等用户接口.
    
74. 首先看一下几个重要的数据结构:
    
75.         file_operations,file,inode
    
76. <linux/fs.h>中定义了这三个结构.
    
77. struct file_operations {
    
78.         struct module *owner;
    
79.         loff_t (*llseek) (struct file *, loff_t, int);
    
80.         ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    
81.         ssize_t (*aio_read) (struct kiocb *, char __user *, size_t, loff_t);
    
82.         ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    
83.         ssize_t (*aio_write) (struct kiocb *, const char __user *, size_t, loff_t);
    
84.         int (*readdir) (struct file *, void *, filldir_t);
    
85.         unsigned int (*poll) (struct file *, struct poll_table_struct *);
    
86.         int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
    
87.         int (*mmap) (struct file *, struct vm_area_struct *);
    
88.         int (*open) (struct inode *, struct file *);
    
89.         int (*flush) (struct file *);
    
90.         int (*release) (struct inode *, struct file *);
    
91.         int (*fsync) (struct file *, struct dentry *, int datasync);
    
92.         int (*aio_fsync) (struct kiocb *, int datasync);
    
93.         int (*fasync) (int, struct file *, int);
    
94.         int (*lock) (struct file *, int, struct file_lock *);
    
95.         ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *);
    
96.         ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);
    
97.         ssize_t (*sendfile) (struct file *, loff_t *, size_t, read_actor_t, void *);
    
98.         ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
    
99.         unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
    
100.         int (*check_flags)(int);
     
101.         int (*dir_notify)(struct file *filp, unsigned long arg);
     
102. }
     
103. file_operations结构定义了一组函数指针,每一个打开的文件(用struct file表示)和他自己的一组函数(包含在一个叫f_op的域中,它指向一个struct file_operations结构)相联系.这些操作都是来实现系统调用的,所以才被命名为open,read,等等.对于那些不需要的功能(比如你的设备不需要write功能,即不需要向设备写数据),可以给write指针付NULL.
     
104. 
     
105. struct file {
     
106.         struct list_head        f_list;
     
107.         struct dentry           *f_dentry;
     
108.         struct vfsmount         *f_vfsmnt;
     
109.         struct file_operations  *f_op;
     
110.         atomic_t                f_count;
     
111.         unsigned int            f_flags;
     
112.         mode_t                  f_mode;
     
113.         int                     f_error;
     
114.         loff_t                  f_pos;
     
115.         struct fown_struct      f_owner;
     
116.         unsigned int            f_uid, f_gid;
     
117.         struct file_ra_state    f_ra;
     
118. 
     
119.         unsigned long           f_version;
     
120.         void                    *f_security;
     
121. 
     
122.         /* needed for tty driver, and maybe others */
     
123.         void                    *private_data;
     
124. 
     
125. #ifdef CONFIG_EPOLL
     
126.         /* Used by fs/eventpoll.c to link all the hooks to this file */
     
127.         struct list_head        f_ep_links;
     
128.         spinlock_t              f_ep_lock;
     
129. #endif /* #ifdef CONFIG_EPOLL */
     
130.         struct address_space    *f_mapping;
     
131. };
     
132. 每个打开的文件对应一个struct file.它在被打开时由内核创建,并传给它所有可以操作该文件的函数,到文件被关闭时才被删除.
     
133. 
     
134. The inode Structure.
     
135. Inode结构是用来在内核内部表示文件的.同一个文件可以被打开好多次,所以可以对应很多struct file,但是只对应一个struct inode.该结构里面包含了很多信息,但是,驱动开发者只关心里面两个重要的域:
     
136.         dev_t i_rdev;//含有真正的设备号
     
137.         struct cdev *i_cdev;//struct cdev是内核内部表示字符设备的结构.
     
138. 
     
139. 注册字符设备
     
140. 
     
141. <linux/cdev.h>
     
142. 可以有两种方法注册
     
143.         struct cdev *my_cdev=cdev_alloc();
     
144.         my_cdev->ops=&my_fops;
     
145. 或
     
146.         void cdev_init(struct cdev *cdev,struct file_operations *fops);
     
147. 
     
148. 注册完后还要通知内核一声,通过调用
     
149.         int cdev_add(struct cdev *dev,dev_t num,unsigned int count);
     
150. count 一般是 1.
     
151. 
     
152. 删除字符设备,调用
     
153.         void cdev_del(struct cdev *dev);
     
154. 
     
155. 
     
156. 说了那么多,现在可以来个例子了.
     
157. #include <linux/kernel.h>
     
158. #include <linux/fs.h>
     
159. #include <linux/module.h>
     
160. #include <asm/uaccess.h>
     
161. #include <linux/cdev.h>
     
162. #include <asm/uaccess.h>
     
163. 
     
164. 
     
165. #define DP_MAJOR 50
     
166. #define DP_MINOR 0
     
167. static int char_read(struct file *filp,char __user *buffer,size_t,loff_t *);
     
168. static int char_open(struct inode *,struct file *);
     
169. static int char_write(struct file *filp,const char __user *buffer,size_t ,loff_t*);
     
170. static int char_release(struct inode *,struct file *);
     
171. static char *arr,*p;
     
172. static int chropen;
     
173. struct cdev *my_cdev;
     
174. static int len;
     
175. struct file_operations Fops = {
     
176.         .read = char_read,
     
177.         .write = char_write,
     
178.         .open = char_open,
     
179.         .release = char_release,        /* a.k.a. close */
     
180. };
     
181. static int __init char_init(void)
     
182. {
     
183.         printk(KERN_ALERT"Initing......\n");
     
184.         dev_t dev;
     
185.         dev=MKDEV(DP_MAJOR,DP_MINOR);
     
186.         my_cdev = cdev_alloc( );
     
187.         arr=kmalloc(1024,GFP_KERNEL);
     
188.         if(arr==NULL){
     
189.                 printk(KERN_ALERT"kmalloc error\n");
     
190.         }
     
191.         sprintf(arr,"Hello,Pid=%d\n",current->pid);
     
192.         if(my_cdev==NULL){
     
193.                 return -1;
     
194.         }
     
195.         if(register_chrdev_region(dev,10,"dpchr")<0){
     
196.                 printk(KERN_ALERT"Register char dev error\n");
     
197.                 return -1;
     
198.         }
     
199.         chropen=0;
     
200.         len=0;
     
201.         my_cdev->ops = &Fops;
     
202.         cdev_init(my_cdev,&Fops);
     
203.         cdev_add(my_cdev,dev,1);
     
204. 
     
205.         return 0;
     
206. }
     
207. 
     
208. static int char_open(struct inode *inode,struct file *file)
     
209. {
     
210.         if(chropen==0)
     
211.                 chropen++;
     
212.         else{
     
213.                 printk(KERN_ALERT"Another process open the char device\n");
     
214.                 return -1;
     
215.         }
     
216.         p=arr;
     
217.         try_module_get(THIS_MODULE);
     
218.         return 0;
     
219. }
     
220. 
     
221. static int char_release(struct inode *inode,struct file *file)
     
222. {
     
223.         chropen--;
     
224.         module_put(THIS_MODULE);
     
225.         return 0;
     
226. }
     
227. 
     
228. static int char_read(struct file *filp,char __user *buffer,size_t length,loff_t *offset)
     
229. {
     
230.         int i=0;
     
231.         if(*p=='\0')
     
232.                 return 0;
     
233.         while(length&&*p){
     
234.                 put_user(*(p++),buffer++);
     
235.                 length--;
     
236.                 i++;
     
237.         }
     
238.         return i;
     
239. }
     
240. 
     
241. static int char_write(struct file *filp,const char __user  *buffer,size_t length,loff_t *offset)
     
242. {
     
243. 
     
244.         int i;
     
245.         for(i=0;i<length&&i<1024;i++)
     
246.                 get_user(p[i],buffer+i);
     
247. 
     
248.         p[i]=0;
     
249.         len=i;
     
250.         return i;
     
251. }
     
252.        
     
253. 
     
254. static void module_close()
     
255. {
     
256.         len=0;
     
257.         printk(KERN_ALERT"Unloading..........\n");
     
258.         kfree(arr);
     
259.         unregister_chrdev_region(MKDEV(DP_MAJOR,DP_MINOR),10);
     
260.         cdev_del(my_cdev);
     
261. }
     
262. 
     
263. module_init(char_init);
     
264. module_exit(module_close);
     
265. 
     
266. 需要注意的是,用户调用read/write时返回的值便是我们实现的函数(char_read,char_write)返回的值,所以我们不能随便的返回一个值(比如,0,用户的read/write返回0,所以会认为出错了,然后并没有出错,只是我们返回了一个错误的值而已.
     
267. 
     
268. 
     
269. 参考资料
     
270. 内核模块的编程http://www.tldp.org/LDP/lkmpg/2.6/html/index.html
     
271. Linux Device Driver 3rd Edition
     
272. Linux Kernel Development 2nd Edition
     

复制代码

huyongzs

既然是两种字符设备注册方法

可以有两种方法注册
        struct cdev *my_cdev=cdev_alloc();
        my_cdev->ops=&my_fops;
或
        void cdev_init(struct cdev *cdev,struct file_operations *fops);

为什么例子两种注册方法都用了？

my_cdev = cdev_alloc( );

cdev_init(my_cdev,&Fops);