linux设备驱动之ioctl控制

http://www.cnblogs.com/geneil/archive/2011/12/04/2275372.html

linux设备驱动之ioctl控制

大部分驱动除了具有读写的能力之外，还需要具有对硬件控制的能力。

用户空间：ioctl

用户程序使用ioctl系统调用来控制设备。用户程序只是通过命令码告诉驱动程序想做什么，至于怎么解释这些命令和怎么实现这些命令，这都是驱动程序要做的事情。 
- 函数原型：int ioctl(int fd, unsigned long cmd, …); 
- 参数解析： 
1. fd：打开的文件描述符 
2. cmd：控制命令码 
3. …：可选参数，具体内容依赖于cmd

驱动程序：ioctl

函数原型：

int (*ioctl)(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg);

参数解析：

1. inode和filp两个指针对应于应用程序传递的文件描述符fd，和传递open方法的参数一样。
2. cmd：由用户空间直接不经修改的传递给驱动程序
3. arg：可选参数

核心操作：命令码

在ioctl中命令码是唯一联系用户程序和驱动程序的途径 
在驱动程序中的ioctl函数体内，有一个switch{case}结构，每一个case对应一个命令码，做出一些相应的操作。程序员要做的就是实现这些操作。

在Linux内核中，是这样定义一个命令码：

设备类型	序列号	方向	数据尺寸
8 bit	8 bit	2 bit	8~14 bit

定义命令

命令码很不直观，因此内核提供了一些宏来帮助定义命令码，这些宏可以根据便于理解的字符串生成命令码， 
或者从命令码得到一些可以理解的字符串来标明这个命令对应的设备类型，设备序列号，数据传输方向和数据传输尺寸。 
如下宏：

//type是设备类型，nr是序列号，datatype是数据类型，比如int
_IO(type, nr)//没有参数的命令,常用来打印信息
_IOR(type, nr, datatype)//从驱动中读数据
_IOW(type, nr, datatype)//向驱动写数据
_IOWR(type, nr, datatype)//读写数据，双向传输
   
   
1
2
3
4
5
   
   
1
2
3
4
5

定义命令例子：

#define MEM_IOC_MAGIC     'm'     //设备类型
#define MEM_IOCSET     _IOW(MEM_IOC_MAGIC, 0, int)  //向驱动写数据
#define MEM_IOCGET     _IOR(MEM_IOC_MAGIC, 1, int)   //从驱动读数据
   
   
1
2
3
   
   
1
2
3

实现命令

实现命令包括三个技术环节： 
- 返回值：当switch语句的命令不能匹配任何一个设备支持的命令时，通常返回-EINVAL（非法参数） 
- 参数使用： 
<1>用户程序使用ioctl(int fd, unsigned long cmd, …)的时候，三个点..就是要传递的参数 
<2>驱动程序通过int (*ioctl)(struct inode, struct file *filp, unsigned int cmd, unsigned long arg)中的arg传递； 
<3>如果arg是一个整数，可以直接使用。如果是指针，必须确保这个用户地址有效，因此使用之前必须进行检查。 
内部有检测，不需要我们检测的：copy_from_user, copy_to_user, get_user, put_user 
需要我们检测的：__get_user, __put_user 
检测使用函数access_ok() 
函数原型：static inline int access_ok(int type, const void *addr, unsigned long size) 
- 参数解析 
1. type：用来表明是读用户空间VERIFY_READ还是写用户内存VERIFY_WRITE 
2. addr：要操作的用户地址 
3. size：操作的长度。如果ioctl需要从用户空间读一个整数，那么size参数就等于sizeof(int) 
- 返回值：返回一个布尔值：1代表成功，存取没问题。0代表失败，ioctl返回-EFAULT

命令操作

switch(cmd) 
{ 
case: 
………… 
}

ioctl实例分析

memdev.h

#ifndef _MEMDEV_H_
#define _MEMDEV_H_

#include<linux/ioctl.h>

#ifndef MEMDEV_MAJOR
#define MEMDEV_MAJOR 0     //预设主设备号
#endif

#ifndef MEMDEV_NR_DEVS
#define MEMDEV_NR_DEVS 2     //设备数
#endif

#ifndef MEMDEV_SIZE
#define MEMDEV_SIZE 4096
#endif

struct mem_dev
{
     char *data;
     unsigned long size;
};

#define MEMDEV_IOC_MAGIC 'k'
#define MEMDEV_IOCPRINT     _IO(MEMDEV_IOC_MAGIC, 1)
#define MEMDEV_IOCGET     _IOR(MEMDEV_IOC_MAGIC, 2, int)
#define MEMDEV_IOCPUT     _IOW(MEMDEV_IOC_MAGIC, 3，int)

#define MEMDEV_IOC_MAXNR     3

#endif     /*_MEMDEV_H_*/
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

memdev.c

#include<linux/module.h>
#include<linux/types.h>
#include<linux/fs.h>
#include<linux/errno.h>
#include<linux/mm.h>
#include<linux/sched.h>
#include<linux/init.h>
#include<linux/init.h>
#include<linux/cdev.h>
#include<asm/io.h>
#include<asm/system.h>
#include<asm/uaccess.h>

#include"memdev.h"

static int mem_major = MEMDEV_MAJOR;

module_param(mem_major, int, S_IRUGO);

struct mem_dev *mem_devp;

struct cdev cdev;

int mem_open(struct inode *inode, struct file *filp)
{
     struct mem_dev *dev;

     int num = MINOR(inode->i_rdev);

     if(num >= MEMDEV_NR_DEVS)
          return -ENODEV;
     dev = &mem_devp[num];

     filp->private_data = dev;

     return 0;
}

int mem_release(struct inode *inode, struct file *filp)
{
     return 0;
}

int memdev_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
{
     int err = 0;
     int ret = 0;
     int ioarg = 0;

     if(_IOC_TYPE(cmd) != MEMDEV_IOC_MAGIC)
          return -EINVAL;
     if(_IOC_NR(cmd) > MEMDEV_IOC_MAXNR)
          return -EINVAL;

     if(_IOC_DIR(cmd) & _IOC_READ)
          err = !access_ok(VERIFY_WRITE, (void*)arg, -IOC_SIZE(cmd));
     else if(_IOC_DIR(cmd) & _IOC_WRITE)
          err = !access_ok(VERIFY_READ, (void*)arg, -IOC_SIZE(cmd));
     if(err)
          return -EFAULT;

     switch(cmd)
          {
               case MEMDEV_IOCPRINT:
                    printk("<------CMD MEMDEV_IOCPRINT Done------>\n\n");
                    break;
               case MEMDEV_IOCGET:
                    ioarg = 1101;
                    ret = __put_user(ioarg, (int *)arg);
                    break;
               case MEMDEV_IOCPUT:
                    ret = __get_user(ioarg, (int *)arg);
                    printk("<------In Kernel MEMDEV_IOCPUT ioarg = %d------\n\n>", ioarg);
                    break;
               default:
                    return -EINVAL;
          }
     return ret;
}

static const struct file_operations mem_fops =
{
     .owner = THIS_MODULE,
     .open = mem_open,
     .release = mem_release,
     .ioctl = memdev_ioctl,
};

static int memdev_init(void)
{
     int result;
     int i;

     dev_t devno = MKDEV(mem_major, 0);

     if(mem_major)
          result = register_chrdev_region(devno, 2, "memdev");
     else
          {
               result = alloc_chrdev_region(&devno, 2, "memdev");
               mem_major = MAJOR(devno);
          }
     if(result < 0)
          return result;

     cdev_init(&cdev, &mem_fops);

     cdev.owner = THIS_MODULE;

     cdev.ops = &mem_fops;

     cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);

     mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev), GFP_KERNEL);
     if(!mem_devp)
          {
               result = -ENOMEM;
               goto fail_malloc;
          }

     memset(mem_devp, 0, sizeof(struct mem_dev));

     for(i = 0; i < MEMDEV_NR_DEVS; i++)
          {
               mem_devp[i].size = MEMDEV_SIZE;
               mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);
               memset(mem_devp[i].data, 0, MEMDEV_SIZE);
          }

     return 0;

     fail_malloc;

     unregister_chrdev_region(devno, 1);

     return result;
}

static void memdev_exit(void)
{
     cdev_del(&cdev);
     kfree(mem_devp);
     unregister_chrdev_region(MKDEV(mem_major, 0), 2);
}

MODULE_AUTHOR("CuiTing Lin");
MODULE_LICENSE("GPL");

module_init(memdev_init);
module_exit(exit);
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

app_memdev.c

#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

#include"memdev.h"

int main()
{
     int fd = 0;
     int cmd;
     char buf[4096];

     fd = open("dev/memdev0", O_RDWR);
     if(fd < 0)
          {
               printf("open dev mem0 error!\n");
               return -1;
          }

     printf("<----CALL MEMDEV_IOCPRINT----->\n");
     cmd = MEMDEV_IOCPRINT;
     if(ioctl(fd, cmd, &arg) < 0)
          {
               printf("call cmd MEMDEV_IOCPRINT falied\n");
               return -1;
          }

     printf("<----call MEMDEV_IOCPUT----->\n");
     cmd = MEMDEV_IOCPUT;
     arg = 2007;
     if(ioctl(fd, cmd, &arg) < 0)
          {
               printf("call cmd MEMDEV_IOCPUT falied\n");
               return -1;
          }

     printf("<----call MEMDEV_IOCGET----->\n");
     cmd = MEMDEV_IOCGET;
     if(ioctl(fd, cmd, &arg) < 0)
          {
               printf("call cmd MEMDEV_IOCGET falied\n");
               return -1;
          }

     printf("<-----In User Space MEMDEV_IOCGET Get Data is %d----->\n\n", arg);

     close(fd);

     return 0;
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51