3种字符设备驱动编程

目录

1 杂项字符设备

核心结构体

操作函数

杂项字符设备注册应用

2 早期经典方式注册

操作函数

经典设备注册应用

3 Linux2.6字符设备

核心结构体

操作函数

Linux2.6设备注册应用

---

 Linux系统借鉴了面向对象的思想来管理设备驱动，每一类设备都会有定义一个特定的结构体来描述它，这个结构体包含了设备的基本信息，以及操作设备方法（函数指针）所以，编写程序实际上就是实现核心结构体，然后把这个结构体注册到内核中。

       驱动程序就是向下控制硬件，向上提供接口,这里的向上提供的接口最终对应到应用层有三种方式：设备文件，/proc，/sys，其中最常用的就是使用设备文件，设备文件有三种形式：

1. 字符设备：以字节为单位进行顺序访问的设备。（如：串口、RTC、LCD屏.....）
2. 块设备：以块为单位读写的设备。（emmc、flash、sd等存储设备）
3. 网络设备：面向数据包的发送和接收数据。（有线/无线网卡）

而Linux设备中用的最多的就是字符设备。在目前的内核版本中，存在三种流行的字符设备编程模块：

        1、杂项设备驱动模型

        2、早期经典标准字符设备驱动模型

        3、Linux2.6标准字符设备驱动模型

注：安装杂项设备会自动在/dev目录生成设备文件而早期经典标准字符设备驱动模型和Linux2.6标准字符设备驱动模型不会自定生成设备文件

1 杂项字符设备

        在学习杂项字符设备之前，先了解设备号这个概念，设备号分为主设备号和次设备号。主设备号：就是用来标识一类设备(类似于班级号)；次设备号：就是用来标识一类设备当中的那一个设备(班级里学生的学号)。

杂项字符设备主要学习一个结构体和两个函数。

核心结构体

参数miscdevice 头文件路径：#include <linux/miscdevice.h>

struct miscdevice  {
	int minor;         //次设备号
	const char *name;  //设备名字，/dev/下的设备名
	  const struct file_operations *fops;//文件操作方法集合指针 (linux-3.2.2\include\linux\ fs.h)
	//以下是内核使用，用户不需要关注
	struct list_head list;
	struct device *parent;
	struct device *this_device;
	const char *nodename;
	mode_t mode;
};

操作函数

int misc_register(struct miscdevice *misc); //注册函数
//功能：向内核注册一个杂项字符设备
//参数：misc已经实现好minor,name,fop,三个成员的struct miscdevice结构变量的地址
//返回：0：注册成功，<0:失败，返回失败错误码
int misc_deregister(struct miscdevice *misc);//注销函数
//功能：注销一个已经注册到内核中杂项字符设备
//参数：misc已经注册的struct miscdevice结构变量的地址
//返回：0：注册成功，<0:失败，返回失败错误码

杂项字符设备注册应用

        写3个文件，1是内核层的驱动文件hello.c，2是用户层文件app.c，3是Makefile文件，实现LED闪烁的功能。注：调用一次misc_register注册函数，只会占用一个次设备号，杂项设备主设备号固定为10，次设备号变化返回为 0-254,写255代表自动分配次设备号。会自动生成设备文件。

1 内核层：hello.c

//**************内核层代码 hello.c**************
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
unsigned int  *base = NULL;
//LED灯控制寄存器基地址
#define GPM4CON 	*((volatile unsigned int *)(base))    
//LED灯数据寄存器基地址
#define GPM4DAT 	*((volatile unsigned int *)(base +1))
int led_open (struct inode *inode, struct file *fp)
{
	printk("hello open is ok\n");
	GPM4DAT &=~(0XF<<0); //点亮LED灯
	return 0;
}

int  led_close (struct inode *inode, struct file *fp)
{
	printk("hello close is ok\n");
	GPM4DAT |=(0XF<<0); //关闭小灯
	return 0;
}
struct file_operations hello_fops = {//文件操作方法集合
	.owner = THIS_MODULE,/*模块引用，任何时候都赋值THIS_MODULE */ 
	.open = led_open,
	.release = led_close,
};
//初始化杂项字符设备控制结构体
struct miscdevice  misc = {
	.minor = 255,/*可以直接指定，一般为255表示系统自动分配*/
	.name = "led",
	.fops = &hello_fops,
};
static int __init led_init(void)
{
	int ret;
	ret = misc_register(&misc);//注册设备
	if(ret <0)
	{
		printk("misc register error!\n");
		return -1;
	}
	printk("misc register sucess!\n");
    //地址映射
	base =(unsigned int  *) ioremap(0x110002e0, 0x16);
	GPM4CON &=~(0XFFFF<<0);//配置端口
	GPM4CON |= (0X1111<<0);
	GPM4DAT |= (0XF<<0);//默认关闭LED灯
	return 0;
}
static void __exit led_exit(void)
{
	iounmap(base);//取消地址映射
	misc_deregister(&misc);//注销设备
	printk("misc register exit\n");
}
module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");

2 用户层：app.c

#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include<unistd.h>
int fd;
int main()
{
	while(1)
	{
		fd=open("/dev/led",O_RDWR);
		sleep(2);
		close(fd);
		sleep(2);
	}
	return 0;
}

3 编写Makefile文件

obj-m += led.o
KDIR:=/root/work/linux-3.5 
all:
	make -C $(KDIR) M=$(PWD) modules
	arm-linux-gcc -o app app.c
clean:
	rm -f *.ko *.o *.mod.o *.mod.c *.symvers *.markers *.order app

4 在开发板的超级终端加载模块，运行用户程序

insmod led.ko   //加载LED模块
lsmod           //查看已挂载的模块
./app           //运行用户程序
//这里LED就闪烁起来了

2 早期经典方式注册

        早期版本的设备注册使用函数register_chrdev()，操作成功返回值为0。在关闭设备时，通常需要解除原先的设备注册，使用函数unregister_chrdev()。其中主设备号和次设备号不能大于255。杂项设备核心结构不存在一个核心结构；

        设备号：主设备号： 0~255 （ 10 是给杂项设备使用）次设备号： 0~255， 当传递 255 时候表示自动分配次设备号。特征：安装后， 不会自动创建/dev/设备文件节点， 需要手动使用 mknod 命令创建。

mknod /dev/xxx c 主设备号 次设备号

        调用一个 register_chrdev 注册后， 256 个次设备号就都被占用完了。也就是说一个主设备号只能使用 register_chrdev 函数注册一次。

操作函数

头文件：#include <linux/fs.h>

int register_chrdev(unsigned int major,const char *name,const struct file_operations *fops);
/*功能：注册一个早期经典标准字符设备
参数：major主设备号，0~255(10除外)，这类驱动注册的主设备号不能和其他的驱动相同，否则会失败，所以，当不确定哪一个号可以的时候，只能由内核自动分配，当major传递0的时候表示由内核自动分配一个可以的主设备号。
name:设备名，不需要和/dev 下对应节点名相同，注册后，这个名字会出现在/proc/device文件中的。(可以 cat /proc/device 查看)。
fops:文件操作方法指针
返回值：当 major =0:成功：返回所分配的主设备号，失败：返回负数。
		当 major >0:成功：返回0 				  失败：返回负数。*/
void unregister_chrdev(unsigned int major,const char *name );
/*功能：注销一个已经存在标准字符设备
参数：major :主设备号：name: 设备名，使用register_chrdev注册的设备名
返回： 无*/

经典设备注册应用

1 内核层：register_chrdev.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
static int major = 0;
int hello_open(struct inode *inode, struct file *fp)
{
	printk("hello_open ok\n");
	return 0;
}
ssize_t hello_read(struct file *fp, char __user *buf, size_t size, loff_t *offset)
{
	printk("hello_read ok\n");
	return 0;
}
ssize_t hello_write(struct file *fp, const char __user *buf, size_t size, loff_t *offset)
{
	printk("hello_write ok\n");
	return 0;
}
int hello_close(struct inode *inode, struct file *fp)
{
	printk("hello_close ok\n");
	return 0;

}
struct file_operations my_fops = 
 {
	.owner=THIS_MODULE,
	.open = hello_open,
	.read = hello_read,
	.write = hello_write,
	.release = hello_close,
}; 
static int __init hello_register_init(void)
{
	
	major = register_chrdev(0, "hello_chrdev",&my_fops);
	if(major < 0)
	{
			printk("register chrdev error\n");
			return -1;
	}
	printk("register chrdev ok\n");
	printk("major = %d\n",major);
	
	return 0;
}
static void __exit hello_registet_exit(void)
{
	 unregister_chrdev(major,"hello_chrdev");
}
module_init(hello_register_init);
module_exit(hello_registet_exit);
MODULE_LICENSE("GPL");

2 用户层：app.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main()
{
	int fp;
	fp =open(argv[1], O_RDWR);
	if(fp < 0)
	{
		printf("open error\n");
		return -1;
	}
	write(fp,NULL,0);
	read(fp,NULL,0);
	close(fp);
	return 0;
}

3 Makefile文件

obj-m += register_chrdev.o
KDIR:=/root/work/linux-3.5 
all:
	make -C $(KDIR) M=$(PWD) modules
	arm-linux-gcc -o app app.c
clean:
	rm -f *.ko *.o *.mod.o *.mod.c *.symvers *.markers *.order app

4  手动创建设备节点文件，加载模块，运行用户程序

//在开发板的终端串口中执行
mknod /dev/led c 250 0  //创建设备节点
insmod led.ko           //加载模块
./app led               //运行用户程序

3 Linux2.6字符设备

        使用 dev_t 来表示一个设备号， dev_t 实际上是一个 u32 类型。 其中高 12 位是主设备号，低20 位是次设备号。主设备号： dev_t 高 12 位， 2^12=4K （ 10 是给杂项设备使用）,次设备号： dev_t 低 20 位， 2^20=1M

核心结构体

//Linux2.6标准字符设备核心结构：cdev
#include <linux/cdev.h>
struct cdev {
	struct kobject kobj;
	struct module *owner;
	const struct file_operations *ops; //设备文件操作方法
	struct list_head list;
	dev_t dev;                     //32位设备号：包括主和次
	unsigned int count;			  //占用多少个连用的设备号
};
//必须实现的成员：
//	ops:文件操作方法指针
//	dev:起始设备号(包含主设备号和次设备号)，dev_t实际上是一个 u32类型
//	count:本设备要占用次设备号的数量(连续的),从dev中的次设备号开始。

注：安装后，不会自动创建/dev/设备文件节点，需要手动使用mkond命令创建
       mknod /dev/xxx c 主设备号 次设备号，调用一次cdev_add注册后，指定数量的次号被占用完了，数量可以自己指定，一个主设备可以使用cdev_add函数注册多次.

合成设备号：MKDEV(ma,mi):ma:主设备号; mi:次设备号

分解设备号：MAJOR(dev): 从设备号dev中分解出主设备号

                      MINOR(dev)：从设备号dev中分解出次设备号

操作函数

含自动创建设备节点相关函数。

//1、静态设备号申请函数   头文件：
#include <linux/fs.h>
int register_chrdev_region(dev_t from, unsigned count, const char *name);
//功能：申请一个设备号范围
//参数：from：起始设备号(主，次)；count:连续的次设备号数量；
//name:设备名，不需要和/dev/的设备文件名相同
//返回值：0：成功；失败：返回负数

//1、动态设备号申请函数  头文件：
#include <linux/fs.h>
int alloc_chrdev_region(dev_t *dev,unsigned baseminor,unsigned count,const char *name);
//功能： 申请一个设备号范围
//参数： dev:存放分配到的第一个设备(包含主次设备号)；baseminor:要分配起始次设备号；count:连续的次设备号数量；name:设备名，不需要和/dev/的设备文件名相同
//返回值：0：成功；失败：返回负数
 
//2、设备号释放函数：头文件：
#include <linux/fs.h>
void unregister_chrdev_region(dev_t from,unsigned int count);
//功能：释放一个设备号范围
//参数：from:起始设备号(主，次)(包含主次设备号)；count:连续的次设备号数量
//返回值：无

//3、核心结构分配函数：头文件：
#include <linux/cdev.h>
struct cdev *cdev_alloc(void);
//功能：在堆空间中分配一个核心结构，注意，不使用的时候用kfree函数释放；
//参数：无
//返回值：返回分配到struct cdev结构空间首地址 
//说明：用完记得释放，否则会造成内存泄漏。

//4、核心结构初始化函数：头文件：
#include <linux/cdev.h>
void cdev_init(struct cdev *cdev,const struct file_operations *fops);
//功能：初始化核心结构,具体做的是清零核心结构,初始化核心结构体的list,kobj,ops成员
//参数：cdev:需要初始化的核心结构体指针；fops:文件操作方法结构指针
//返回值：无
//说明：写这种驱动模型时候，不需要在定义struct cdev结构变量初始化，因为调用cdev_init函数时候会把它清0，定义时候的初始无效

//5、设备注册函数：头文件：
#include <linux/cdev.h>
int cdev_add(struct cdev *p,dev_t dev,unsigned count);
//功能：注册一个cdev结构
//参数：p：已经初始化的核心结构指针；dev:起始设备号(包含主次设备号)；
//count：连续次设备号数量
//返回值： 成功：返回0；失败 ：返回负数

//6、设备注销函数：头文件：
#include <linux/cdev.h>
void cdev_del(struct cdev *p);
//功能：注销一个cdev结构
//参数：p：前面注册的struct cdev结构指针
//值：无

//**********自动创建设备节点相关函数**********
//1、自动创建节点函数：头文件 
#include<linux/device.h>
struct device *device_create(
struct class *cls, // 设备的类 类指针 让那个类来管理
struct device *parent, // NULL
dev_t devt,      // 主设备号和次设备号的组合32位，主12位，次20位
void *drvdata,   // NULL,设备私有数据
const char *fmt, … /*可以格式化的 fmt:/dev/下的节点名*/
);

//2、创建class类：头文件
#include<linux/device.h>
class_create(ower,name);
//这个函数返回的是指针  
//owner:类的所有者，固定是THIS_MODULE
//name；类名,随便,能有含义最好,不是/dev/下设备的名字,这个名字决定了/sys/class/name。  当创建一个class后会在/sys/class/目录生成一个名为name的目录.

Linux2.6设备注册应用

内核层：linux26_class.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/ioport.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <linux/io.h>

static int major = 250;
static int minor = 0;
static dev_t devno;
static  struct cdev cdev;
static struct class *cls;
static struct device *tst_device;

static int hello_open(struct inode *inode, struct file *file)//打开（open）
{
	printk("hello_open\n");
	return 0;
}
static int hello_release(struct inode *inode, struct file *file)//关闭（close）
{
	printk("hello_release\n");
	return 0;
}

struct file_operations hello_ops ={
	.owner		= THIS_MODULE,
	.open		= hello_open,        //open();
	.release	       = hello_release,    //close();
};

static int hello_init(void)//初始化
{
	int ret;
	devno = MKDEV(major,minor);
	ret = register_chrdev_region(devno, 1, "hello");//静态申请
	if(ret<0)
	{
		
		if(alloc_chrdev_region(&devno, 0, 1, "hello"))//动态申请
		{
			printk("fail \n");
			return ret;
		}
	}
	cls = class_create(THIS_MODULE, "mycls");
	tst_device = device_create(cls, NULL, devno, NULL, "my_device");
	printk("hello_init()\n");
	printk("major = %d \n",MAJOR(devno));
	
	cdev_init(&cdev, &hello_ops);//初始化
	ret = cdev_add(&cdev, devno, 1);//注册
	if(ret<0)
	{
		unregister_chrdev_region(devno, 1);//注销设备号
		return ret;
	}
	return 0;
}
static void hello_exit(void)
{
	printk("hello_exit()\n");
	device_destroy(cls, devno);
	class_destroy(cls);
	cdev_del(&cdev);//注销cdev结构空间
	unregister_chrdev_region(devno,1);//释放设备号
}
MODULE_LICENSE("GPL");
module_init(hello_init);
module_exit(hello_exit);

用户层:test.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
int main()
{
	int fd;
	int ret;
	int red;
	char buf[1024]={0};
	fd = open("/dev/my_device",O_RDWR);
	if(fd < 0)
	{
		printf("open error\n");
		return -1;
	}
#if 0
	ret = read(fd,buf,sizeof(buf));
	if(ret < 0)
	{
		printf("read error\n");
		return -1;
	}
	red = write(fd,buf,sizeof(buf));
	if(red < 0)
	{
		printf("write error\n");
		return -1;
	}
#endif
	close(fd);
	return 0;
}

Makefile

KERN_DIR = /root/tiny4412/linux-3.5
all:
	make -C $(KERN_DIR) M=`pwd` modules
	arm-linux-gcc test.c -o test
clean:
	make -C $(KERN_DIR) M=`pwd` modules clean
	rm -rf modules.order *o test
obj-m += linux26_class.o