字符设备控制技术

设备控制理论

控制理论-作用

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

设备控制-应用函数

在用户空间，使用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