字符设备驱动程序

最新推荐文章于 2018-11-12 11:25:41 发布

upupwhy

最新推荐文章于 2018-11-12 11:25:41 发布

阅读量807

点赞数

分类专栏： linux设备驱动

本文链接：https://blog.csdn.net/wosiwozaiwhy/article/details/39931659

版权

linux设备驱动专栏收录该内容

6 篇文章 0 订阅

订阅专栏

Linux下的设备驱动程序被组织为一组完成不同任务的函数的集合，通过这些函数使得linux的设备操作犹如文件一般。在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作，如open()、close()、read()、write() 等。

字符设备是3大类设备（字符设备、块设备、网络设备）中较简单的一类设备，其驱动程序中完成的主要工作是初始化、添加和删除cdev结构体，申请和释放设备号，以及填充file_operation结构体中操作函数，并实现file_operations结构体中的read()、write()、ioctl()等重要函数。如图所示为cdev结构体、file_operations和用户空间调用驱动的关系。

下面我们来假设一个非常简单的虚拟字符设备：这个设备中只有一个4个字节的全局变量int global_var，而这个设备的名字叫做"globalvar"。对"globalvar"设备的读写等操作即是对其中全局变量global_var的操作。

驱动程序是内核的一部分，因此我们需要给其添加模块初始化函数，该函数用来完成对所控设备的初始化工作，并调用register_chrdev_region() 函数注册字符设备：
static int __init globalvar_init(void)
{
if (register_chrdev_region(devno, DEVICE_SUM, "globalvar"))

　{

　　//…注册失败

　}

　else

　{

　　//…注册成功

　}
}

其中，register_chrdev函数中的参数MAJOR_NUM为主设备号, "globalvar"为设备名，globalvar_fops为包含基本函数入口点的结构体，类型为file_operations。当globalvar模块被加载时，globalvar_init被执行，它将调用内核函数register_chrdev，把驱动程序的基本入口点指针存放在内核的字符设备地址表中，在用户进程对该设备执行系统调用时提供入口地址。

与模块初始化函数对应的就是模块卸载函数，需要调用register_chrdev()的"反函数" unregister_chrdev()：

static void __exit globalvar_exit(void)

{

　if (unregister_chrdev(MAJOR_NUM, " globalvar "))

　{

　　//…卸载失败

　}

　else

　{

　　//…卸载成功

　}

随着内核不断增加新的功能，file_operations结构体已逐渐变得越来越大，但是大多数的驱动程序只是利用了其中的一部分。对于字符设备来说，要提供的主要入口有：open()、release()、read()、write()、ioctl()、llseek()、poll()等。

open()函数　对设备特殊文件进行open()系统调用时，将调用驱动程序的open() 函数：

int (*open)(struct inode * ,struct file *);

其中参数inode为设备特殊文件的inode (索引结点) 结构的指针，参数file是指向这一设备的文件结构的指针。open()的主要任务是确定硬件处在就绪状态、验证次设备号的合法性(次设备号可以用 MINOR(inode-> i - rdev) 取得)、控制使用设备的进程数、根据执行情况返回状态码(0表示成功，负数表示存在错误)等；

release()函数　当最后一个打开设备的用户进程执行close ()系统调用时，内核将调用驱动程序的release() 函数：

void (*release) (struct inode * ,struct file *) ;

release 函数的主要任务是清理未结束的输入/输出操作、释放资源、用户自定义排他标志的复位等。

read()函数　当对设备特殊文件进行read() 系统调用时，将调用驱动程序read()函数：
ssize_t (*read) (struct file *, char *, size_t, loff_t *);

用来从设备中读取数据。当该函数指针被赋为NULL 值时，将导致read 系统调用出错并返回-EINVAL（"Invalid argument，非法参数"）。函数返回非负值表示成功读取的字节数（返回值为"signed size"数据类型，通常就是目标平台上的固有整数类型）。

globalvar_read函数中内核空间与用户空间的内存交互需要借助第2节所介绍的函数：

static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off)

{

　…

　copy_to_user(buf, &global_var, sizeof(int));

　…

}

write( ) 函数　当设备特殊文件进行write()系统调用时，将调用驱动程序的write()函数：

ssize_t (*write) (struct file *, const char *, size_t, loff_t *);

向设备发送数据。如果没有这个函数，write 系统调用会向调用程序返回一个-EINVAL。如果返回值非负，则表示成功写入的字节数。

globalvar_write函数中内核空间与用户空间的内存交互需要借助第2节所介绍的函数：

static ssize_t globalvar_write(struct file *filp, const char *buf, size_t len, loff_t　*off)

{

…

copy_from_user(&global_var, buf, sizeof(int));

…

}

ioctl() 函数　该函数是特殊的控制函数，可以通过它向设备传递控制信息或从设备取得状态信息，函数原型为：

int (*ioctl) (struct inode * ,struct file * ,unsigned int ,unsigned long);

unsigned int参数为设备驱动程序要执行的命令的代码，由用户自定义，unsigned long参数为相应的命令提供参数，类型可以是整型、指针等。如果设备不提供ioctl 入口点，则对于任何内核未预先定义的请求，ioctl 系统调用将返回错误（-ENOTTY，"No such ioctl fordevice，该设备无此ioctl 命令"）。如果该设备方法返回一个非负值，那么该值会被返回给调用程序以表示调用成功。

llseek()函数该函数用来修改文件的当前读写位置，并将新位置作为（正的）返回值返回，原型为：

loff_t (*llseek) (struct file *, loff_t, int);

poll()函数 poll方法是poll和select这两个系统调用的后端实现，用来查询设备是否可读或可写，或是否处于某种特殊状态，原型为：
unsigned int (*poll) (struct file *, struct poll_table_struct *);

我们将在"设备的阻塞与非阻塞操作"一节对该函数进行更深入的介绍。

设备"globalvar"的驱动程序的这些函数应分别命名为globalvar_open、 globalvar_ release、globalvar_read、globalvar_write、gobalvar_ioctl，因此设备"globalvar"的基本入口点结构变量gobalvar_fops 赋值如下：

struct file_operations globalvar_fops = {

　read: globalvar_read,

　write: globalvar_write,

};

上述代码中对globalvar_fops的初始化方法并不是标准C所支持的，属于GNU扩展语法。

完整的globalvar.c文件源代码如下：

globalvar.c

/*
 * globalvar.c -- A simple virtual char device driver
 */
#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
#include <linux/slab.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("leander");

#define MINIOR_NUM 0
#define DEVICE_SUM 1
#define MAJOR_NUM 251 /* major device number */
#define MINOR_NUM 0 /* minor device number */

static int globalvar_open(struct inode *inode, struct file *filp);
static int globalvar_release(struct inode *, struct file *filp);
static ssize_t globalvar_read(struct file*, char*, size_t, loff_t*);
static ssize_t globalvar_write(struct file*, const char*, size_t, loff_t*);

/* the major device number */
static int globalvar_major = MAJOR_NUM;
static int globalvar_minor = MINOR_NUM;

/* init the file_operations structure */
struct file_operations globalvar_fops =
{
	.owner = THIS_MODULE,
	.open = globalvar_open,
	.release = globalvar_release,
	.read = globalvar_read,
	.write = globalvar_write,
};

/* define a cdev device */
struct cdev *cdev;

static int global_var = 0; /* global var */

/* module init */
static int __init globalvar_init(void)
{
	int ret = 0;
	dev_t devno = MKDEV(MAJOR_NUM, MINOR_NUM);
	cdev = cdev_alloc();	//申请内存

	/* register the device driver */
	/*ret = alloc_chrdev_region(MAJOR_NUM, "globalvar", &globalvar_fops);*/
	if(register_chrdev_region(devno, DEVICE_SUM, "globalvar"))
	{
		/* register fail, so use automatic allocate */
		if(alloc_chrdev_region(&devno, globalvar_minor, DEVICE_SUM, "globalvar"))
			printk("globalvar register failure.\n");
		globalvar_major = MAJOR(devno);
    }
	else
	{
		/*
		* cdev_init should be use if use the way of static statement.
		* struct cdev cdev;
		* cdev_init(&cdev, &globalvar_fops);
		* cdev.owner = THIS_MODULE;
		*
		* if using dymatic allocation.
		* struct cdev *cdev;
		* cdev = cdev_alloc();
		* cdev->owner = THIS_MODULE;
		* cdev->ops = &globalvar_fops;
		*/
		
		cdev->owner = THIS_MODULE;
		cdev->ops = &globalvar_fops;
		if ((ret = cdev_add(cdev, devno, 1)))
			printk(KERN_NOTICE "Error %d adding globalvar.\n", ret);
		else
		printk("globalvar register success.\n");
	}
	
	return ret;
}

/* module exit */
static void __exit globalvar_exit(void)
{
	dev_t devno = MKDEV(globalvar_major, 0);

	/* remove cdev from kernel */
	cdev_del(cdev);

	/* unregister the device driver */
	unregister_chrdev_region(devno, 1);

	/* free the dev structure */
	if(cdev)
		kfree(cdev);
	cdev = NULL;
}

/* open device */
static int globalvar_open(struct inode *inode, struct file *filp)
{
	int ret = 0;
	printk("open success.\n");
	return ret;
}

/* release device */
static int globalvar_release(struct inode *inode, struct file *filp)
{
	printk("release success.\n");
	return 0;
}

/* read device */
static ssize_t globalvar_read(struct file *filp, char *buf, size_t len, loff_t *off)
{
	printk("reading...\n");
	if(copy_to_user(buf, &global_var, sizeof(int)))
	{
		return -EFAULT;
	}
	return sizeof(int);
}

/* write device */
static ssize_t globalvar_write(struct file *filp, const char *buf, size_t len, loff_t *off)
{
	printk("writing...\n");
	if(copy_from_user(&global_var, buf, sizeof(int)))
	{
		return -EFAULT;
	}
	return sizeof(int);
}

/* module register */
module_init(globalvar_init);
module_exit(globalvar_exit);

Makefile文件

module=globalvar

ifneq ($(KERNELRELEASE),)
	obj-m := ${module}.o
else
	KERNELDIR ?= /back-end-team/wanghongyan3/data/work/svn_7783
PWD := $(shell pwd)
default:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clean:
	rm -f *.o *.ko *.mod.c *~
insmod:
	sudo insmod ${module}.ko
	dmesg | tail
rmmod:
	sudo rmmod ${module}
	dmesg | tail
endif

编译运行条件：

（1）设置好交叉编译链，每次用的时候都要export（设置环境变量）

（2）装好内核源码，

（3）Makefile文件中的KERNELDIR ?= 要设置成内核源码的位置
编译代码，运行：

insmod globalvar.ko加载globalvar模块。

　　接着我们运行：mknod /dev/globalvar c 251 0
创建设备节点，用户进程通过/dev/globalvar这个路径就可以访问到这个全局变量虚拟设备了。

mknod 是创建设备节点命令
insmod 是加载内核模块的命令
编译后的内核模块xxxxx.ko 使用insmod加载，然后再/dev 下创建设备节点或者叫设备文件（使用的命令就是mknod）。
cat/proc/devices  是查看内核使用的主设备号

当你加载驱动模块的时候，他会运行驱动中的初始化函数，然后会分配设备的主次设备号。并向内核注册这个设备和驱动。
如果驱动模块中有实现自动生成当前设备文件节点的代码。那么会使用和热插拔相关的代码脚本，自动在dev下面生成对应的设备文件。如果没有，你只能自己手动来生成这个设备文件。
当然最终都要运行mknode命令，它会根据你传进去的主次设备号和类型。在内核维护的设备和驱动列表中寻找你在驱动模块中注册的设备和驱动。如果找到了，会生成相关的文件节点，并在节点内部存下相关驱动的信息，其中会有一些vfs相关的知识，当你打开或者读写文件节点的时候，最终会调用到你注册的驱动中相关的驱动函数。

test.c

/*
 * test.c -- a test file for globalvar reading and writing
 */

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

int main(void)
{
	printf("start\n");
    int fd, num;
	int rf=0;
    /*打开"/dev/globalvar"*/
    fd = open("/dev/globalvar", O_RDWR, S_IRUSR | S_IWUSR);
	printf("fd=%d\n",fd);
    if (fd != -1 )
    {
        /*初次读globalvar*/
        rf= read(fd, &num, sizeof(int));
		if(rf<0)
		{
			printf("read error [%d]\n",rf);
		}
		else
		{
			printf("The globalvar is %d\n", num);
		}
        

        /*写globalvar*/
        printf("Please input the num written to globalvar\n");
        scanf("%d", &num);
        write(fd, &num, sizeof(int));

        /*再次读globalvar*/
        read(fd, &num, sizeof(int));
        printf("The globalvar is %d\n", num);

        /*关闭"/dev/globalvar"*/
        close(fd);
    }
    else
    {
        /* if not sudo, maybe come here */
        printf("Device open failure\n");
    }

    return 0;
}

Makefile文件

CC=/back-end-team/wanghongyan3/data/work/chaintool/Marvell_toolchain_201301/armv7-marvell-linux-gnueabi-softfp_i686/bin/arm-marvell-linux-gnueabi-gcc
CFLAGS= -Wall

globalvartest:test.c
	$(CC) $(CFLAGS) -o $@ $<
clean:
	rm -f *.o
	rm -f globalvartest

　运行

./globalvartest

可以发现"globalvar"设备可以正确的读写。

测试程序退出后，输入 rmmod cglobalvar.ko 卸载驱动模块
输入 rm -rf /dev/globalvar 删除 /dev/目录下的 globalvar设备

upupwhy

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
字符设备驱动程序

/* * gobalvar.c -- A simple virtual char device driver */#include #include #include #include #include #include MODULE_LICENSE("GPL");MODULE_AUTHOR("leander");#define MINIOR_NUM 0
复制链接

扫一扫