字符设备控制技术

设备控制理论

控制理论-作用

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

设备控制-应用函数

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

int ioctl(int fd, unsigned long cmd, ...)
fd：要控制的设备文件描述符
cmd：发送给设备的控制命令
...：第三个参数为可选参数，存在是否依赖于控制命令

当应用程序使用ioctl函数调用时，驱动程序将由如下函数来响应：

long (*unlocked_ioctl)(struct file *filp, unsigned int cmd, unsigned long arg)
参数cmd：通过应用函数ioctl传递下来的命令

设备控制实现

控制实现-定义命令

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

* Type（类型/幻数）：表明这是属于哪个设备的命令。

* Number（序号）：用来区分同一设备的不同命令。

* Direction：参数传送的方向，可能的值是_IOC_NONE(没有数据传输)，_IOC_READ，_IOC_ERITE（向设备写入参数）

* Size：参数长度

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

_IO(type,nr)  不带参数的命令
_IOR(type, nr, datatype)  从设备中读参数的命令
_IOW(type, nr, datatype)  向设备写入参数的命令
例如：
#define MEM_MAGIC 'm'   //定义幻数,一个字符即8位
#define MEM_SET _IOW(MEM_MAGIC, 0, int)

设备控制-实现操作

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

/* memdev.h */

#define MEM_MAGIC 'm'
#define MEM_RESTART _IO(MEM_MAGIC,0)
#define MEM_SET _IOW(MEM_MAGIC,1,int)

/* memdev.c */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include "memdev.h"

struct cdev mdev; /* 静态分配设备描述结构 */
dev_t devnum; /* 设备号 */
int dev1_regs[5];
int dev2_regs[5];

loff_t mem_lseek(struct file *file, loff_t offset, int whence)
{
	loff_t new_pos = 0;
	switch (whence) 
	{
		case SEEK_SET:
			new_pos = 0+offset;
			break;
		case SEEK_CUR:
			new_pos = file->f_pos+offset;
			break;
		case SEEK_END:
			new_pos = 5*sizeof(int)+offset;
			break;
	}
	file->f_pos = new_pos;
	return new_pos;
}

ssize_t mem_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
	int *reg_base = file->private_data;
	copy_to_user(buf, reg_base+(*ppos), size);
	file->f_pos += size;
	return size;
}

ssize_t mem_write(struct file *file, const char __user *buf, size_t size, loff_t *ppos)
{
	int *reg_base = file->private_data;
	copy_from_user(reg_base+(*ppos), buf, size);
	file->f_pos += size;
	return size;
}

int mem_open(struct inode *node, struct file *file)
{
	int num = MINOR(node->i_rdev); /* 次设备号 */
	if(num == 0)
	{
		file->private_data = dev1_regs;
	}
	if(num == 1)
	{
		file->private_data = dev2_regs;
	}
	return 0;
}

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

long mem_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	switch (cmd)
	{
		case MEM_RESTART:
			printk(KERN_WARNING"restart device\n");
			return 0;
		case MEM_SET:
			printk(KERN_WARNING"arg is %ld\n",arg);
			return 0;
		default:
			return -EINVAL;
	}
}

struct file_operations memfops = 
{
	.llseek = mem_lseek,
	.read = mem_read,
	.write = mem_write,
	.open = mem_open,
	.release = mem_close,
	.unlocked_ioctl = mem_ioctl
};

int memdev_init(void)
{
	cdev_init(&mdev, &memfops); /* 描述结构-初始化 */
	alloc_chrdev_region(&devnum, 0, 2, "memdev"); /* 动态分配设备号 */
	cdev_add(&mdev, devnum, 2); /* 描述结构-注册 */
	return 0;
}

void memdev_exit(void)
{
	cdev_del(&mdev);
	unregister_chrdev_region(devnum, 2);
}

MODULE_LICENSE("GPL");

module_init(memdev_init);
module_exit(memdev_exit);

/* mem_ctl */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include "memdev.h"

int main()
{
	int fd;
	
	fd = open("/dev/memdev0",O_RDWR);
	
	ioctl(fd,MEM_SET,115200);
	ioctl(fd,MEM_RESTART);
	
	return 0;
}

[root@localhost lesson]# arm-linux-gcc -static mem_ctl.c -o mem_ctl
[root@localhost lesson]# cp mem_ctl /root/rootfs/
[root@localhost lesson]# cp memdev.ko /root/rootfs/

# cat /proc/devices 
# mknod /dev/memdev0 c 252 0
# ./mem_ctl 
arg is 115200
restart device