Smart210学习记录-------Linux设备驱动结构

　　

cdev结构体

1 struct cdev {
2 struct kobject kobj; /* 内嵌的 kobject 对象 */
3 struct module *owner; /*所属模块*/
4 struct file_operations *ops; /*文件操作结构体*/
5 struct list_head list;

6    dev_t dev;           /*设备号*/

7 unsigned int count; 
8 }; 

1.struct file_operations {
2 struct module *owner;
3 /* 拥有该结构的模块的指针，一般为 THIS_MODULES */
4 loff_t(*llseek)(struct file *, loff_t, int);
5 /* 用来修改文件当前的读写位置 */
6 ssize_t(*read)(struct file *, char _ _user *, size_t, loff_t*);
7 /* 从设备中同步读取数据 */
8 ssize_t(*write)(struct file *, const char _ _user *, size_t, loff_t*);
9 /* 向设备发送数据*/
10 ssize_t(*aio_read)(struct kiocb *, char _ _user *, size_t, loff_t);
11 /* 初始化一个异步的读取操作*/
12 ssize_t(*aio_write)(struct kiocb *, const char _ _user *, size_t, loff_t);
13 /* 初始化一个异步的写入操作*/
14 int(*readdir)(struct file *, void *, filldir_t);
15 /* 仅用于读取目录，对于设备文件，该字段为 NULL */
16 unsigned int(*poll)(struct file *, struct poll_table_struct*);
17 /* 轮询函数，判断目前是否可以进行非阻塞的读取或写入*/
18 int(*ioctl)(struct inode *, struct file *, unsigned int, unsigned long);
19 /* 执行设备 I/O 控制命令*/
20 long(*unlocked_ioctl)(struct file *, unsigned int, unsigned long);
21 /* 不使用 BLK 的文件系统，将使用此种函数指针代替 ioctl */
22 long(*compat_ioctl)(struct file *, unsigned int, unsigned long);
23 /* 在 64 位系统上，32 位的 ioctl 调用，将使用此函数指针代替*/
24 int(*mmap)(struct file *, struct vm_area_struct*);
25 /* 用于请求将设备内存映射到进程地址空间*/
26 int(*open)(struct inode *, struct file*);
27 /* 打开 */
28 int(*flush)(struct file*);
29 int(*release)(struct inode *, struct file*);
30 /* 关闭*/
31 int (*fsync) (struct file *, struct dentry *, int datasync);
32 /* 刷新待处理的数据*/
33 int(*aio_fsync)(struct kiocb *, int datasync);
34 /* 异步 fsync */
35 int(*fasync)(int, struct file *, int);
36 /* 通知设备 FASYNC 标志发生变化*/
37 int(*lock)(struct file *, int, struct file_lock*);
38 ssize_t(*sendpage)(struct file *, struct page *, int, size_t, loff_t *, int);
39 /* 通常为 NULL */
40 unsigned long(*get_unmapped_area)(struct file *,unsigned long, unsigned long,
41 unsigned long, unsigned long);
42 /* 在当前进程地址空间找到一个未映射的内存段 */
43 int(*check_flags)(int);
44 /* 允许模块检查传递给 fcntl(F_SETEL...)调用的标志 */
45 int(*dir_notify)(struct file *filp, unsigned long arg);
46 /* 对文件系统有效，驱动程序不必实现*/
47 int(*flock)(struct file *, int, struct file_lock*);
48 ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t,
49 unsigned int); /* 由 VFS 调用，将管道数据粘接到文件 */
50 ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t,
51 unsigned int); /* 由 VFS 调用，将文件数据粘接到管道 */
52 int (*setlease)(struct file *, long, struct file_lock **);
53 };

Linux 2.6 内核提供了一组函数用于操作 cdev 结构体：
void cdev_init(struct cdev *, struct file_operations *); 用于初始化 cdev 的成员，并建立 cdev 和 file_operations 之间的连接
struct cdev *cdev_alloc(void); cdev_alloc()函数用于动态申请一个 cdev 内存
void cdev_put(struct cdev *p);
int cdev_add(struct cdev *, dev_t, unsigned); cdev_add()函数和 cdev_del()函数分别向系统添加和删除一个 cdev，完成字符设备的注册和注
销。对 cdev_add()的调用通常发生在字符设备驱动模块加载函数中，而对 cdev_del()函数的调用则
通常发生在字符设备驱动模块卸载函数中。
void cdev_del(struct cdev *);

cdev 结构体的 dev_t 成员定义了设备号，为 32 位，其中 12 位主设备号，20 位次设备号。使
用下列宏可以从 dev_t 获得主设备号和次设备号：
MAJOR(dev_t dev)
MINOR(dev_t dev)
而使用下列宏则可以通过主设备号和次设备号生成 dev_t：
MKDEV(int major, int minor)

分配和释放设备号
int register_chrdev_region(dev_t from, unsigned count, const char *name);
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name);

void unregister_chrdev_region(dev_t from, unsigned count);

Linux字符设备的组成

1  /* 设备结构体 
2  struct xxx_dev_t { 
3      struct cdev cdev; 
4    ... 
5  } xxx_dev; 
6  /* 设备驱动模块加载函数 
7  static int _ _init xxx_init(void) 
8  { 
9    ... 
10   cdev_init(&xxx_dev.cdev, &xxx_fops); /* 初始化 cdev */ 
11   xxx_dev.cdev.owner = THIS_MODULE; 
12   /* 获取字符设备号*/ 
13   if (xxx_major) { 
14       register_chrdev_region(xxx_dev_no, 1, DEV_NAME); 
15   } else { 
16       alloc_chrdev_region(&xxx_dev_no, 0, 1, DEV_NAME); 
17   } 
18    
19   ret = cdev_add(&xxx_dev.cdev, xxx_dev_no, 1); /* 注册设备*/ 
20   ... 
21 } 
22 /*设备驱动模块卸载函数*/ 
23 static void _ _exit xxx_exit(void) 
24 { 
25    unregister_chrdev_region(xxx_dev_no, 1); /* 释放占用的设备号*/ 
26    cdev_del(&xxx_dev.cdev); /* 注销设备*/ 
27   ... 
28 } 
29 module_init(xxx_init);
30 module_exit(xxx_exit);

字符设备驱动的 file_operations 结构体中成员函数

1   /* 读设备*/ 
2   ssize_t xxx_read(struct file *filp, char __user *buf, size_t count, 
3       loff_t*f_pos) 
4   { 
5       ... 
6       copy_to_user(buf, ..., ...); 
7       ... 
8   } 
9   /* 写设备*/ 
10  ssize_t xxx_write(struct file *filp, const char __user *buf, size_t count, 
11      loff_t *f_pos) 
12  { 
13      ... 
14      copy_from_user(..., buf, ...); 
15      ... 
16  } 
17  /* ioctl 函数 */ 
18  int xxx_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, 
19      unsigned long arg) 
20  { 
21      ... 
22      switch (cmd) { 
23      case XXX_CMD1: 
24            ... 
25            break; 
26      case XXX_CMD2: 
27            ... 
28            break; 
29      default: 
30            /* 不能支持的命令 */ 
31            return  - ENOTTY; 
32      } 
33      return 0; 
34  } 

设备驱动的读函数中，filp 是文件结构体指针，buf 是用户空间内存的地址，该地址在内核空
间不能直接读写，count 是要读的字节数，f_pos 是读的位置相对于文件开头的偏移。
写函数同理
由于内核空间与用户空间的内存不能直接互访，因此借助了函数 copy_from_user()完成用户空间
到内核空间的拷贝，以及copy_to_user()完成内核空间到用户空间的拷贝，见代码第6行和第14行。
完成内核空间和用户空间内存拷贝的 copy_from_user()和 copy_to_user()的原型分别为：
unsigned long copy_from_user(void *to, const void __user *from, unsigned long count);
unsigned long copy_to_user(void __user *to, const void *from, unsigned long count);
上述函数均返回不能被复制的字节数，因此，如果完全复制成功，返回值为 0。

在字符设备驱动中，需要定义一个 file_operations 的实例，并将具体设备驱动的函数赋值给
file_operations 的成员，例如：
1 struct file_operations xxx_fops = {
2 .owner = THIS_MODULE,
3 .read = xxx_read,
4 .write = xxx_write,
5 .ioctl = xxx_ioctl,
6 ...
7  }

来自《linux设备驱动开发详解》