我的物联网之路——Linux驱动——字符设备操作

日期	变更记录
2021-11-18	创建

前言

转眼间很快，大四的实训生活就剩一个半月了，好好努力，好好加油
虽然我明白写这个驱动啥意思，但是老师再补了个test让我并不李姐

设备号作用

主设备号用来标识利用的驱动程序，次设备号用来标识该驱动下的设备

主次设备号

内核中如何描述设备号
struct dev_t dev (一个结构体，其中高12位为主设备号，低20位为次设备号)
如何从dev中分解出主设备号
MAJOR(dev_t dev);
如何从dev中分解出次设备号
MINOR(dev_t dev);
如何构造设备号
dev_t MKDEV(unsigned int major,unsigned int minor);

分配设备号

主动分配(动态)

result = alloc_chrdev_region(&dev,devminor,1,"globalmen");
优点：简单，易于推广
缺点：无法在安装驱动前创建设备文件，因为还没有分配到主设备号

手动分配(静态)

//1 获得设备号
dev = MKDEV(devmajor,devminor);
//2 分配设备编号
result =register_chrdev_region(dev,1,"globalmen");
优点：简单
缺点：广泛使用时容易导致设备号冲突

注销设备号

unregister_chrdev_region(MKDEV(devmajor,devminor),1);

创建/注销驱动的过程

创建：
1、申请设备号
2、向内核注册设备
3、创建设备文件
注销：
1、注销设备文件
2、向内核注销设备
3、注销设备号

Example

globalmen.c(驱动)

//globalmen 在内存里面拿一段空间出来给用户空操作
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/uaccess.h>
// 调试信息输出宏开关
#define  PDEBUG
#ifdef  PDEBUG
#define DPRINTK  printk
#else
#define DPRINTK( x... ) //注意:宏带可变参数是linux c 的语法。
#endif

#define GLOBALMEN_MAJOR 222
//主设备号
#define GLOBALMEN_MINOR 0
// 次设备号
static int devmajor = GLOBALMEN_MAJOR;
static int devminor = GLOBALMEN_MINOR;
//全局变量大小
#define GLOBALMEN_SIZE 1024
// 表示当前设备的结构体
struct globalmen_dev{
	// 字符设备
	struct cdev globalmen_cdev;
	//内存大小
	unsigned char men[GLOBALMEN_SIZE];
};
// 定义当前设备的结构体指针，来表示当前设备
struct globalmen_dev *globalmen_p;
// 创建设备文件的类
struct class *globalmen_class;

//移动文件指针函数
static loff_t globalmen_llseek(struct file *filep , loff_t offset , int orig)
{
	switch(orig)
	{
		case 0:
			if(orig < 0)
				return -1;
			if(offset > GLOBALMEN_SIZE)
				return -1;
			filep->f_pos = offset;
			return filep->f_pos;
			break;
		case 1:
			if(filep->f_pos + offset < 0)
				return -1;
			if(filep->f_pos + offset > GLOBALMEN_SIZE)
				return -1;
			filep->f_pos += offset;
			break;
	}
	return 0;
}
// 打开设备函数
static int globalmen_open(struct inode *inodep , struct file *filep)
{
	filep->private_data = globalmen_p;
	DPRINTK("open success /r/n");
	return 0; 
}
// 关闭文件
static int globalmen_release(struct inode *inodep , struct file *filep)
{ 
	DPRINTK("release success /r/n");
	return 0;
}
//	读文件
static ssize_t globalmen_read(struct file *filep , char __user *buf,size_t size , loff_t *ppos)
{
	struct globalmen_dev *devp = filep->private_data;
	unsigned long ret;
	if(*ppos > GLOBALMEN_SIZE)
	{
		return -1;
	}
	else
	{
		if(size > GLOBALMEN_SIZE - *ppos)
		{
			size = GLOBALMEN_SIZE - *ppos;
		}
		ret = copy_to_user(buf,devp->men + *ppos,size);
		*ppos  = *ppos + size;
		return size;
	}
}
// 写文件
static ssize_t globalmen_write(struct file *filep ,const char __user *buf,size_t size, loff_t *ppos)
{
	struct globalmen_dev *devp = filep->private_data;
	unsigned long ret;
	ret = copy_from_user(devp->men+*ppos, buf ,size);
	if(*ppos > GLOBALMEN_SIZE)
	{
		return -1;
	}
	else
	{
		if(size > GLOBALMEN_SIZE - *ppos)
		{
			size = GLOBALMEN_SIZE - *ppos;
		}
		ret = copy_from_user(devp->men + *ppos,buf,size);
		*ppos  = *ppos + size;
		return size;
	}
}
// 文件控制函数
static long globalmen_ioctl(struct file *filep,unsigned int cmd , unsigned long arg)
{
	struct globalmen_dev *devp = filep->private_data;
	int ret;
	switch(cmd)
	{
		case 0:
			memset(devp->men,0,GLOBALMEN_SIZE);
			ret = 0;
			break;
		case 1:
			memset(devp->men,1,GLOBALMEN_SIZE);
			ret = 1;
			break;
		default:
			ret = -1;
			break; 
	}
	return ret;
}
// 关联文件操作
struct file_operations fops = 
{
// 文件操作
	.owner = THIS_MODULE,
	.llseek = globalmen_llseek,
	.read = globalmen_read,
	.write = globalmen_write,
	.unlocked_ioctl = globalmen_ioctl,
	.open = globalmen_open,
	.release = globalmen_release,
};


static int __init globalmen_init(void)
{
	int result;
	dev_t dev ;
	//1申请设备号
	if(GLOBALMEN_MAJOR)
	{
		// 手动分配设备号
		//1 获得设备号
		dev = MKDEV(devmajor,devminor);
		//2 分配设备编号
		result = register_chrdev_region(dev,1,"globalmen");
	}
	else
	{
	// 自动分配设备号
		result = alloc_chrdev_region(&dev,devminor,1,"globalmen");
		devmajor = MAJOR(dev);
	}
	if(result < 0 )
	{
		DPRINTK("dev error \r\n ");
		return -1;
	}	
	DPRINTK("dev success \r\n ");
	//2向内核注册设备
	globalmen_p = (struct globalmen_dev *)kmalloc(sizeof(struct globalmen_dev),GFP_KERNEL);
	if(globalmen_p == NULL)
	{
		DPRINTK("kmalloc error \r\n ");
		goto reg_1;
	}
	// 空间清零
	memset(globalmen_p,0,sizeof(struct globalmen_dev));
	//	关联设备与操作函数
	cdev_init(&(globalmen_p->globalmen_cdev),&fops);
	// 	向内核添加设备
	result = cdev_add(&(globalmen_p->globalmen_cdev),dev,1);	
	if(result < 0 )
	{
		DPRINTK("cdev_add error \r\n ");
		goto reg_2;
	}	
	//3创建设备文件
	struct class *globalmen_class;
	globalmen_class = class_create(THIS_MODULE,"globalmen_class");
	if(IS_ERR(globalmen_class))
	{
		DPRINTK("class_create error \r\n");
		goto reg_3;
	}
	result = device_create(globalmen_class,NULL,MKDEV(devmajor,0),NULL,"globalmen_xx");
	if(result < 0 )
	{
		DPRINTK("device_create error \r\n ");
		goto reg_4;
	}
	return 1;
reg_4:
	class_destroy(globalmen_class);
reg_3:
	cdev_del(&(globalmen_p->globalmen_cdev));
reg_2:
	kfree(globalmen_p);
reg_1:
	unregister_chrdev_region(MKDEV(devmajor,devminor),1);
	return 0;
}
void __exit globalmen_exit(void)
{
	//1
	device_destroy(globalmen_class,MKDEV(devmajor,devminor)); 
	class_destroy(globalmen_class);
	cdev_del(&(globalmen_p->globalmen_cdev));
	kfree(globalmen_p);
	//2
	//3注销设备
	unregister_chrdev_region(MKDEV(devmajor,devminor),1);
}

MODULE_AUTHOR("zhbk");
MODULE_VERSION("v1.0");
MODULE_LICENSE("Dual BSD/GPL");
module_init(globalmen_init);
module_exit(globalmen_exit);

test.c(执行函数)

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

int main(int argc,char *argv[])
{
	int fd,size;
	fd = open("/dev/gloabmen_xx",O_RDWR);
#if 1
	size = write(fd,"hello",strlen("hello"));
	if(size)
	{
		printf("wirte success ! ");
	}
#endif
	//lseek();
	//read(xsx,buf,20);
}