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

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

第三个参数不表示一个变数目的参数，而是一个类型可选的参数。第三个参数依赖于控制命令。一些命令不用参数，一些用一个整数值，一些使用指针

1、ioctl函数定义命令

在编写ioctl代码之前，首先需要定义命令。为了防止对错误的设备使用正确的命令，命令号应该在系统范围内事唯一的

ioctl命令编码被划分为几个段，include/asm/ioctl.h中定义了这些字段：类型(幻数)，基数，传送方向，参数大小等。Documentation/ioctl-number.txt文件中罗列了再内核中已经使用了的幻数。

定义ioctl命令的正确方法是使用4个位段，这个列表中介绍的符号定义在中：

Type：

幻数(类型)：表明哪个设备的命令，在参考了ioctl-number.txt之后选出，8位宽。

Number：

序号，表明设备命令中的第几个，8位宽

内核提供了下列宏来帮助定义命令号，如下

_IO(type, nr)：没有参数的命令

_IOR(type, nr, datatype)：从驱动中读数据

_IOW(type, nr, datatype)：写数据到驱动

_IOWR(type, nr, datatype)：双向传送，type和number作为参数被传递

2、ioctl函数的实现

分三个技术环节：

1、返回值

ioctl函数的实现通常是根据命令执行的一个switch语句。但是当命令不能匹配任何一个设备所支持的命令时，通常返回-EINVAL(“非法参数”)

2、参数使用

如果是一个整数，可以直接使用。如果是指针，我们必须确保这个用户地址是有效的，因此使用前需进行正确的检查

使用int access_ok(int type, const void *addr, unsigned long size)来检查一个指针地址是否可以访问

第一个参数是VERIFY_READ或者是VERIFY_WRITE，用来表明读用户内存还是写用户内存。addr参数时要操作的用户内存地址，size是操作的长度。如果ioctl需要从用户空间读一个整数，那么size = sizeof(int)。如果需要同时读和写，则使用VERIFY_WRITE。

access_ok返回一个布尔值：1是成功(存取没问题)和0是失败(存取有问题)，如果该函数返回失败，则ioctl应当返回-EFAULT，如：

if(_IOC_DIR(cmd) & _IOC_READ)// 为什么_IOC_READ对应VERIFY_WRITE？？？

err = !access_ok(VERIFY_WRITE, (void  __user *)arg, _IOC_SIZE(cmd));

else if(_IOC_DIR(cmd) & _IOC_WRITE)

err = ! access_ok(VERIFY_READ, (void  __user *)arg, _IOC_SIZE(cmd));

if(err)

return –EFAULT

在access_ok检测通过后，驱动可以使用cope_from_user和cope_to_user等函数进行参数传递了

3、命令操作

switch(cmd)

{

case MEMDEV_IOCPRINT:

printk("/n/n");

break;

case MEMDEV_IOCGETDATA:

ioarg = 1101;

ret = __put_user(ioarg, (int *)arg);

break;

case MEMDEV_IOCSETDATA:

ret = __get_user(ioarg, (int *)arg);

printk("/n/n",ioarg);

break;

default:

return -ENOTTY;

}

实例分析，源码如下(最好先看《第一个嵌入式Linux的驱动程序》中的源码)

memdev.h:

#ifndef _MEMDEV_H_

#define _MEMDEV_H_

#include

#ifndef MEMDEV_MAJOR

#define MEMDEV_MAJOR 0

#endif

#ifndef MEMDEV_NR_DEVS

#define MEMDEV_NR_DEVS 3

#endif

#ifndef MEMDEV_SIZE

#define MEMDEV_SIZE 4096

#endif

typedef struct Mem_Dev {

char *data;

struct Mem_Dev *next;

unsigned long size;

} Mem_Dev;

#define MEMDEV_IOC_MAGIC  'k'

#define MEMDEV_IOCPRINT   _IO(MEMDEV_IOC_MAGIC, 1)

#define MEMDEV_IOCGETDATA _IOR(MEMDEV_IOC_MAGIC, 2, int)

#define MEMDEV_IOCSETDATA _IOW(MEMDEV_IOC_MAGIC, 3, int)

#define MEMDEV_IOC_MAXNR 3

#endif

memdev.c:

#ifndef __KERNEL__

#  define __KERNEL__

#endif

#ifndef MODULE

#  define MODULE

#endif

//#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include "memdev.h"

MODULE_LICENSE("GPL");

Mem_Dev *mem_devices;

int memdev_major = MEMDEV_MAJOR;

int memdev_open(struct inode *inode, struct file *filp)

{

Mem_Dev *dev;

int num = MINOR(inode->i_rdev);

dev = (Mem_Dev *)filp->private_data;

if (!dev)

{

if (num >= MEMDEV_NR_DEVS)

return -ENODEV;

dev = &mem_devices[num];

filp->private_data = dev;

}

//MOD_INC_USE_COUNT;

return 0;

}

int memdev_release(struct inode *inode, struct file *filp)

{

//MOD_DEC_USE_COUNT;

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 -ENOTTY;

if (_IOC_NR(cmd) > MEMDEV_IOC_MAXNR)

return -ENOTTY;

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("/n/n");

break;

case MEMDEV_IOCGETDATA:

ioarg = 1101;

ret = __put_user(ioarg, (int *)arg);

break;

case MEMDEV_IOCSETDATA:

ret = __get_user(ioarg, (int *)arg);

printk("/n/n",ioarg);

break;

default:

return -ENOTTY;

}

return ret;

}

struct file_operations memdev_fops = {

ioctl:      memdev_ioctl,

open:       memdev_open,

release:    memdev_release,

};

void memdev_cleanup_module(void)

{

int i;

unregister_chrdev(memdev_major, "memdev");

if (mem_devices)

{

for (i=0; i

kfree(mem_devices[i].data);

kfree(mem_devices);

}

}

int memdev_init_module(void)

{

int result, i;

//SET_MODULE_OWNER(&memdev_fops);

result = register_chrdev(memdev_major, "memdev", &memdev_fops);

if (result < 0)

{

printk(KERN_WARNING "mem: can't get major %d/n",memdev_major);

return result;

}

if (memdev_major == 0)

memdev_major = result;

mem_devices = kmalloc(MEMDEV_NR_DEVS * sizeof(Mem_Dev), GFP_KERNEL);

if (!mem_devices)

{

result = -ENOMEM;

goto fail;

}

memset(mem_devices, 0, MEMDEV_NR_DEVS * sizeof(Mem_Dev));

for (i=0; i < MEMDEV_NR_DEVS; i++)

{

mem_devices[i].size = MEMDEV_SIZE;

mem_devices[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);

memset(mem_devices[i].data, 0, MEMDEV_SIZE);

}

return 0;

fail:

memdev_cleanup_module();

return result;

}

module_init(memdev_init_module);

module_exit(memdev_cleanup_mo

app-ioctl.c:

#include

#include

#include

#include

#include "memdev.h"

int main()

{

int fd = 0;

int cmd;

int arg = 0;

char Buf[4096];

fd = open("/dev/memdev0",O_RDWR);

if (fd < 0)

{

printf("Open Dev Mem0 Error!/n");

return -1;

}

printf("/n");

cmd = MEMDEV_IOCPRINT;

if (ioctl(fd, cmd, &arg) < 0)

{

printf("Call cmd MEMDEV_IOCPRINT fail/n");

return -1;

}

printf("/n");

cmd = MEMDEV_IOCSETDATA;

arg = 2007;

if (ioctl(fd, cmd, &arg) < 0)

{

printf("Call cmd MEMDEV_IOCSETDATA fail/n");

return -1;

}

printf("/n");

cmd = MEMDEV_IOCGETDATA;

if (ioctl(fd, cmd, &arg) < 0)

{

printf("Call cmd MEMDEV_IOCGETDATA fail/n");

return -1;

}

printf("/n/n",arg);

close(fd);

return 0;

}

Makefile和《第一个嵌入式Linux的驱动程序》中的Makefile一样。

编译后下载到开发板上进行测试(参照《第一个嵌入式Linux的驱动程序》)……