ioctl--字符设备的控制技术【转】

本文转载自：http://blog.csdn.net/coding__madman/article/details/51356313

字符设备的控制

1. 字符设备控制理论

1.1 作用

大部分驱动程序除了需要提供读写设备的能力外，还需要具备控制设备的能力。比如：改变波特率

1.2 应用程序接口

在用户空间，使用ioctl系统调用来控制设备，原型如下：

int  ioctl(int fd, unsigned long cmd, ...)

fd: 要控制的设备文件描述符

cmd: 发送给设备的控制命令

...: 第三个参数是可选的参数，存在与否依赖于控制命令（第二个参数）

1.3 设备驱动方法

2. 字符设备控制实现

2.1 定义命令

命令其实质而言就是一个整数，但为了让这个整数具备更好的可读性，我们通常会把这个整数分为几个段，类             型（8位），序号， 参数传送方向，参数长度

type(类型/幻数)：表明这是属于哪个设备的命令

number(序号)：用来区分同一设备的不同命令

direction: 参数传送的方向，可能的值是_IOC_NONE(没有数据传输)，_IOC_READ, _IOC_WRITE(向设备读写           参数)

size : 参数长度

Linux系统提供了下面的宏来帮助定义命令：

* _IO(type, nr) : 不带参数的命令

*_IOR(type, nr, datatype) : 从设备中读取参数的命令

*_IOW(type, nr, datatype) : 向设备写入参数的命令

例如：

#define MEM_MAGIC  'm' //定义幻数

#define MEM_SET  _IOW(MEM_MAGIC, 0, int)

2.2 实现设备方法

unlocked_ioctl函数的实现通常是根据命令执行的一个switch语句。但是，当命令号不能匹配任何一个设备所支           持的命令时， 返回 -EINVAL

编程模型：

switch cmd:

case  命令A：

//执行A所对应的操作

case  命令B：

//执行B对应的操作

defaule:

return -EINVAL;

实例代码分析来实现ioctl:

这里的memdev.c还是接着上篇的基础上改的

1. #include <linux/module.h>
2. #include <linux/types.h>
3. #include <linux/fs.h>
4. #include <linux/errno.h>
5. #include <linux/init.h>
6. #include <linux/cdev.h>
7. #include <asm/uaccess.h>
8. #include <linux/slab.h>
9. #include "memdev.h"
10. int dev1_registers[5];
11. int dev2_registers[5];
12. struct cdev cdev;
13. dev_t devno;
14. /*文件打开函数*/
15. int mem_open(struct inode *inode, struct file *filp)
16. {
17. /*获取次设备号*/
18. int num = MINOR(inode->i_rdev);
19. if (num==0)
20. filp->private_data = dev1_registers;
21. else if(num == 1)
22. filp->private_data = dev2_registers;
23. else
24. return -ENODEV;  //无效的次设备号
25. return 0;
26. }
27. /*文件释放函数*/
28. int mem_release(struct inode *inode, struct file *filp)
29. {
30. return 0;
31. }
32. /*读函数*/
33. static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
34. {
35. unsigned long p =  *ppos;
36. unsigned int count = size;
37. int ret = 0;
38. int *register_addr = filp->private_data; /*获取设备的寄存器基地址*/
39. /*判断读位置是否有效*/
40. if (p >= 5*sizeof(int))
41. return 0;
42. if (count > 5*sizeof(int) - p)
43. count = 5*sizeof(int) - p;
44. /*读数据到用户空间*/
45. if (copy_to_user(buf, register_addr+p, count))
46. {
47. ret = -EFAULT;
48. }
49. else
50. {
51. *ppos += count;
52. ret = count;
53. }
54. return ret;
55. }
56. /*写函数*/
57. static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
58. {
59. unsigned long p =  *ppos;
60. unsigned int count = size;
61. int ret = 0;
62. int *register_addr = filp->private_data; /*获取设备的寄存器地址*/
63. /*分析和获取有效的写长度*/
64. if (p >= 5*sizeof(int))
65. return 0;
66. if (count > 5*sizeof(int) - p)
67. count = 5*sizeof(int) - p;
68. /*从用户空间写入数据*/
69. if (copy_from_user(register_addr + p, buf, count))
70. ret = -EFAULT;
71. else
72. {
73. *ppos += count;
74. ret = count;
75. }
76. return ret;
77. }
78. /* seek文件定位函数 */
79. static loff_t mem_llseek(struct file *filp, loff_t offset, int whence)
80. {
81. loff_t newpos;
82. switch(whence) {
83. case SEEK_SET:
84. newpos = offset;
85. break;
86. case SEEK_CUR:
87. newpos = filp->f_pos + offset;
88. break;
89. case SEEK_END:
90. newpos = 5*sizeof(int)-1 + offset;
91. break;
92. default:
93. return -EINVAL;
94. }
95. if ((newpos<0) || (newpos>5*sizeof(int)))
96. return -EINVAL;
97. filp->f_pos = newpos;
98. return newpos;
99. }
100. <span style="color:#ff0000;">//设备控制函数
101. long mem_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
102. {
103. switch(cmd)
104. {
105. case MEM_RESTART: //假如这里传入的是重启的命令
106. printk(KERN_WARNING"restart device!\n");//这里通过虚拟设备来模拟
107. return 0;
108. case MEM_SET: //如果传入的是设置参数命令
109. printk(KERN_WARNING"arg is : %d\n", arg);//打印出传入的参数
110. return 0;
111. default:
112. return -EINVAL;//其他的打印错误
113. }
114. return 0;
115. }</span>
116. /*文件操作结构体*/
117. static const struct file_operations mem_fops =
118. {
119. .llseek = mem_llseek,
120. .read = mem_read,
121. .write = mem_write,
122. .open = mem_open,
123. .release = mem_release,
124. <span style="color:#ff0000;">.unlocked_ioctl = mem_ioctl,</span>
125. };
126. /*设备驱动模块加载函数*/
127. static int memdev_init(void)
128. {
129. /*初始化cdev结构*/
130. cdev_init(&cdev, &mem_fops);
131. /* 注册字符设备 */
132. alloc_chrdev_region(&devno, 0, 2, "memdev");
133. cdev_add(&cdev, devno, 2);
134. //printk(KERN_WARNING"Hello Memdev!\n");
135. printk("Hello Memdev!\n");
136. }
137. /*模块卸载函数*/
138. static void memdev_exit(void)
139. {
140. cdev_del(&cdev);   /*注销设备*/
141. unregister_chrdev_region(devno, 2); /*释放设备号*/
142. printk(KERN_WARNING"exit Memdev!\n");
143. }
144. MODULE_LICENSE("GPL");
145. module_init(memdev_init);
146. module_exit(memdev_exit);

memdev.h

1. #define MEM_MAGIC 'm' //定义一个幻数，而长度正好和ASC码长度一样为8位，所以这里定义个字符
2. #define MEM_RESTART _IO(MEM_MAGIC, 0)   //第一个命令是重启的命令,重启的命令不带参数 第一命令这里序号定义成0
3. #define MEM_SET  _IOW(MEM_MAGIC, 1, int) //设置参数命令 序号为1， 类型为int

测试应用程序mem_ctl.c

1. #include<sys/types.h>
2. #include<sys/stat.h>
3. #include<fcntl.h>
4. #include<sys/ioctl.h>
5. #include "memdev.h"
6. int main()
7. {
8. int fd;
9. fd = open("/dev/memdev0", O_RDWR);//可读可写打开文件
10. ioctl(fd, MEM_SET, 115200);//第一个参数fd，第二个是我们要发送的命令，第三个是要传入的参数
11. ioctl(fd, MEM_RESTART);//重启
12. close(fd);
13. }

Makefile

1. obj-m := memdev.o
2. KDIR := /home/kernel/linux-ok6410
3. all:
4. make -C $(KDIR) M=$(PWD) modules CROSS_COMPILE=arm-linux- ARCH=arm
5. clean:
6. rm -f *.ko *.o *.mod.o *.mod.c *.symvers *.bak *.order

这里ioctl函数原型可以查看内核源码Fs.h(/include/linux目录下)文件

然后这次采用静态编译mem_ctl.c文件 arm-linux-gcc -static -o memctl (这里采用静态编译上面博文有说道)

由于挂载了整个rootfs目录，这里编译产生的文件会同步到我的开发板

安装设备驱动模块，然后cat /proc/device 查看设备驱动程序的主设备号

然后创建设备文件，这样我们的应用程序就可以通过这个设备文件来访问设备了（当然这里我们的设备是虚拟出来的字符设备，不过麻雀虽小五脏俱全）

mknod memdev0 c 252 0 (执行该命令)

memdevo是我们给字符设备取的名字， 252是该字符设备的设备号，

这里可以看到/dev目录下就会产生memdev0这个设备文件了，运行mem_clt应用程序

至此ioctl字符设备的控制就OVER了！