Linux字符设备驱动程序开发(3)-字符设备控制

1 设备控制理论

1.1 控制理论-作用

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

1.2 设备控制-应用函数

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

int ioctl(int fd,unsigned long cmd,...)
//fd: 要控制的设备文件描述符
//cmd: 发送给设备的控制命令
//…: 第3个参数是可选的参数，存在与否是依赖于控制命令(第 2 个参数 )。比如命令是设置波特率，第三个参数就应该是波特率的数字了；但如果命令是重启，则不需要第三个参数。

1.3 设备控制-驱动函数

当应用程序使用ioctl系统调用时，驱动程序将由如下函数来响应：
2.6.36 之前的内核：long (*ioctl) (struct inode* node ,struct file* filp, unsigned int cmd,unsigned long arg)
2.6.36之后的内核：long (*unlocked_ioctl) (struct file *filp, unsigned int cmd, unsigned long arg)
- 参数cmd：通过应用函数ioctl传递下来的命令
所以在驱动开发的设计中，需要根据如下的方法，首先确定应用程序中使用了那么系统调用比如read、write、open，这些系统调用在内核中应该使用哪个函数，比如说sys_read、sys_write，然后再思考怎么样实现对应的设备方法。（系统调用--->内核函数--->设备方法）

2 设备控制实现

2.1 控制实现-定义命令

命令从其实质而言就是一个整数，但为了让这个整数具备更好的可读性，我们通常会把这个整数分为几个段：类型（8位），序号，参数传送方向，参数长度。
- Type(类型/幻数)：表明这是属于哪个设备的命令。
- Number( )序号 ，用来区分同一设备的不同命令
- Direction：参数传送的方向，可能的值是 _IOC_NONE(没有数据传输), _IOC_READ, _IOC_WRITE（向设备写入参数）
- Size：参数长度

2.2 设备控制-定义命令

Linux系统提供了下面的宏来帮助定义命令:
- _IO(type,nr)：不带参数的命令
- _IOR(type,nr,datatype)：从设备中读参数的命令，datatype代表参数类型
- _IOW(type,nr,datatype)：向设备写入参数的命令
比如：
#define MEM_MAGIC ‘m’ //定义幻数，用字符来代替8位的数值
#define MEM_SET _IOW(MEM_MAGIC, 0, int) // 定义一个往设备中写入数据的命令

2.2 设备控制-实现操作

unlocked_ioctl函数的实现通常是根据命令执行的一个switch语句。但是，当命令号不能匹配任何一个设备所支持的命令时，返回-EINVAL。
- 编程模型：
- Switch cmd
- Case 命令A：
- //执行A对应的操作
- Case 命令B：
- //执行B对应的操作
- Default:
- // return -EINVAL

3 动手实践

实现字符设备控制

mem_ctl.h

#define MEM_MAGIC 'm'                     // 设备幻数

#define MEM_RESTART _IO(MEM_MAGIC, 0)         // 重启命令

#define MEM_SET _IOW(MEM_MAGIC, 1, int)   // 向设备写入参数的命令

mem_ctl.c

#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;	
}

memdev.c

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

int dev1_registers[5];
int dev2_registers[5];

struct cdev cdev; 
dev_t devno;

/*文件打开函数*/
int mem_open(struct inode *inode, struct file *filp)
{
	/*获取次设备号*/
	int num = MINOR(inode->i_rdev);
    
	if (num==0)
		filp->private_data = dev1_registers;
	else if(num == 1)
		filp->private_data = dev2_registers;
	else
		return -ENODEV;  //无效的次设备号
    
	return 0; 
}

/*文件释放函数*/
int mem_release(struct inode *inode, struct file *filp)
{
	return 0;
}

/*读函数*/
static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
	unsigned long p =  *ppos;
	unsigned int count = size;
	int ret = 0;
	int *register_addr = filp->private_data; /*获取设备的寄存器基地址*/

	/*判断读位置是否有效*/
	if (p >= 5*sizeof(int))
		return 0;
	if (count > 5*sizeof(int) - p)
		count = 5*sizeof(int) - p;

	/*读数据到用户空间*/
	if (copy_to_user(buf, register_addr+p, count))
	{
		ret = -EFAULT;
	}
	else
	{
		*ppos += count;
		ret = count;
	}

	return ret;
}

/*写函数*/
static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
{
	unsigned long p =  *ppos;
	unsigned int count = size;
	int ret = 0;
	int *register_addr = filp->private_data; /*获取设备的寄存器地址*/
  
	/*分析和获取有效的写长度*/
	if (p >= 5*sizeof(int))
		return 0;
	if (count > 5*sizeof(int) - p)
		count = 5*sizeof(int) - p;
    
	/*从用户空间写入数据*/
	if (copy_from_user(register_addr + p, buf, count))
		ret = -EFAULT;
	else
	{
		*ppos += count;
		ret = count;
	}

	return ret;
}

/* seek文件定位函数 */
static loff_t mem_llseek(struct file *filp, loff_t offset, int whence)
{ 
	loff_t newpos;

	switch(whence) 
	{
		case SEEK_SET: 
		newpos = offset;
		break;

		case SEEK_CUR: 
		newpos = filp->f_pos + offset;
		break;

		case SEEK_END: 
		newpos = 5*sizeof(int)-1 + offset;
		break;

		default: 
		return -EINVAL;
}
	if ((newpos<0) || (newpos>5*sizeof(int)))
		return -EINVAL;
    	
	filp->f_pos = newpos;
	return newpos;
}

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

/*文件操作结构体*/
static const struct file_operations mem_fops =
{
	.llseek = mem_llseek,
	.read = mem_read,
	.write = mem_write,
	.open = mem_open,
	.release = mem_release,
	.unlocked_ioctl = mem_ioctl,
};

/*设备驱动模块加载函数*/
static int memdev_init(void)
{
	/*初始化cdev结构*/
	cdev_init(&cdev, &mem_fops);
  
	/* 注册字符设备 */
	alloc_chrdev_region(&devno, 0, 2, "memdev");
	cdev_add(&cdev, devno, 2);

	return 0;
}

/*模块卸载函数*/
static void memdev_exit(void)
{
	cdev_del(&cdev);   /*注销设备*/
	unregister_chrdev_region(devno, 2); /*释放设备号*/
}

MODULE_LICENSE("GPL");

module_init(memdev_init);
module_exit(memdev_exit);

运行结果

Linux字符设备驱动程序开发(3)-字符设备控制

猜你喜欢