Linux驱动编写、Udev自动创建节点、编写驱动测试程序

最新推荐文章于 2022-09-08 16:36:51 发布

Hello_xzy_Word

最新推荐文章于 2022-09-08 16:36:51 发布

阅读量406

点赞数

文章标签： Linux 驱动测试驱动 udev

本文链接：https://blog.csdn.net/qq_39514033/article/details/88876306

版权

1、编写驱动 globalmem.c

/*
 * A globalmem driver as an example of char device drivers
 *
 * The initial developer of the original code is Barry Song
 * <author@linuxdriver.cn>. All Rights Reserved.
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <linux/device.h>
#define GLOBALMEM_SIZE	0x1000	/*全局内存最大4K字节*/
#define MEM_CLEAR 0x1  /*清0全局内存*/
#define GLOBALMEM_MAJOR 250    /*预设的globalmem的主设备号*/

static struct class *myclass;

static int globalmem_major = GLOBALMEM_MAJOR;
/*globalmem设备结构体*/
struct globalmem_dev {
	struct cdev cdev; /*cdev结构体*/
	unsigned char mem[GLOBALMEM_SIZE]; /*全局内存*/
};

struct globalmem_dev *globalmem_devp; /*设备结构体指针*/
/*文件打开函数*/
int globalmem_open(struct inode *inode, struct file *filp)
{
	/*将设备结构体指针赋值给文件私有数据指针*/
	filp->private_data = globalmem_devp;
	printk(KERN_INFO "open.......\n");
	return 0;
}
/*文件释放函数*/
int globalmem_release(struct inode *inode, struct file *filp)
{
	printk(KERN_INFO "release...\n");
	return 0;
}

/* ioctl设备控制函数 */
static int globalmem_ioctl(struct inode *inodep, struct file *filp, unsigned
	int cmd, unsigned long arg)
{
	struct globalmem_dev *dev = filp->private_data;/*获得设备结构体指针*/

	switch (cmd) {
	case MEM_CLEAR:
		memset(dev->mem, 0, GLOBALMEM_SIZE);
		printk(KERN_INFO "globalmem is set to zero\n");
		break;

	default:
		return  - EINVAL;
	}

	return 0;
}

/*读函数*/
static ssize_t globalmem_read(struct file *filp, char __user *buf, size_t size,
	loff_t *ppos)
{
	unsigned long p =  *ppos;
	unsigned int count = size;
	int ret = 0;
	struct globalmem_dev *dev = filp->private_data; /*获得设备结构体指针*/

	/*分析和获取有效的写长度*/
	if (p >= GLOBALMEM_SIZE)
		return 0;
	if (count > GLOBALMEM_SIZE - p)
		count = GLOBALMEM_SIZE - p;

	/*内核空间->用户空间*/
	if (copy_to_user(buf,dev->mem + p,count)) {
		ret =  - EFAULT;
	} else {
		*ppos += count;
		ret = count;

		printk(KERN_INFO "read %u bytes(s) from %lu\n", count, p);
	}

	return ret;
}

/*写函数*/
static ssize_t globalmem_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;
	struct globalmem_dev *dev = filp->private_data; /*获得设备结构体指针*/

	/*分析和获取有效的写长度*/
	if (p >= GLOBALMEM_SIZE)
		return 0;
	if (count > GLOBALMEM_SIZE - p)
		count = GLOBALMEM_SIZE - p;

	/*用户空间->内核空间*/
	if (copy_from_user(dev->mem + p,buf,count))
		ret =  - EFAULT;
	else {
		*ppos += count;
		ret = count;

		printk(KERN_INFO "written %u bytes(s) from %lu\n", count, p);
	}

	return ret;
}

/* seek文件定位函数 */
static loff_t globalmem_llseek(struct file *filp, loff_t offset, int orig)
{
	loff_t ret = 0;
	switch (orig) {
	case 0:   /*相对文件开始位置偏移*/
		if (offset < 0)	{
			ret =  - EINVAL;
			break;
		}
		if ((unsigned int)offset > GLOBALMEM_SIZE) {
			ret =  - EINVAL;
			break;
		}
		filp->f_pos = (unsigned int)offset;
		ret = filp->f_pos;
		break;
	case 1:   /*相对文件当前位置偏移*/
		if ((filp->f_pos + offset) > GLOBALMEM_SIZE) {
			ret =  - EINVAL;
			break;
		}
		if ((filp->f_pos + offset) < 0) {
			ret =  - EINVAL;
			break;
		}
		filp->f_pos += offset;
		ret = filp->f_pos;
		break;
	default:
		ret =  - EINVAL;
		break;
	}
	printk(KERN_INFO "seek........\n");
	return ret;
}

/*文件操作结构体*/
static const struct file_operations globalmem_fops = {
	.owner = THIS_MODULE,
	.llseek = globalmem_llseek,
	.read = globalmem_read,
	.write = globalmem_write,
	.ioctl = globalmem_ioctl,
	.open = globalmem_open,
	.release = globalmem_release,
};

/*初始化并注册cdev*/
static void globalmem_setup_cdev(struct globalmem_dev *dev, int index)
{
	int err, devno = MKDEV(globalmem_major, index);

	cdev_init(&dev->cdev, &globalmem_fops);
	dev->cdev.owner = THIS_MODULE;
	err = cdev_add(&dev->cdev, devno, 1);
	if (err)
		printk(KERN_NOTICE "Error %d adding LED%d", err, index);
	printk(KERN_INFO "chu shi hua bin zhu ce\n");
}

/*设备驱动模块加载函数*/
int globalmem_init(void)
{
	int result;
	dev_t devno = MKDEV(globalmem_major, 0);

	/* 申请设备号*/
	if (globalmem_major)
		result = register_chrdev_region(devno,1,"globalmem");
	else { /* 动态申请设备号 */
		result = alloc_chrdev_region(&devno,0,1,"globalmem");
		globalmem_major = MAJOR(devno);
	}
	if (result < 0)
		return result;
	/* 动态申请设备结构体的内存*/
	globalmem_devp = kmalloc(sizeof(struct globalmem_dev), GFP_KERNEL);
	if (!globalmem_devp) {    /*申请失败*/
		result =  - ENOMEM;
		goto fail_malloc;
	}

	memset(globalmem_devp, 0, sizeof(struct globalmem_dev));

	globalmem_setup_cdev(globalmem_devp, 0);
	printk(KERN_INFO "jia zai ......\n");
	
	myclass = class_create(THIS_MODULE,"globalmem");
	class_device_create(myclass,NULL,devno,NULL,"globalmem");
	printk(KERN_INFO "chaung jian jie dian......\n");
	
	return 0;

fail_malloc:
	unregister_chrdev_region(devno, 1);
	return result;
}

/*模块卸载函数*/
void globalmem_exit(void)
{
	cdev_del(&globalmem_devp->cdev);   /*注销cdev*/
	kfree(globalmem_devp);     /*释放设备结构体内存*/
	
	class_device_destroy(myclass,MKDEV(globalmem_major, 0));
	class_destroy(myclass);
	printk(KERN_INFO "shan chu jie dian ......\n");
	
	unregister_chrdev_region(MKDEV(globalmem_major, 0), 1); /*释放设备号*/
	
	printk(KERN_INFO "xie zai ......\n");
}

MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
MODULE_LICENSE("Dual BSD/GPL");

module_param(globalmem_major, int, S_IRUGO);

module_init(globalmem_init);
module_exit(globalmem_exit);

2、编写Makefile

ifeq ($(KERNELRELEASE),)

KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD :=$(shell pwd)

modules:
        $(MAKE) -C $(KERNELDIR) M=$(PWD) modules

modules_install:
        $(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install
clean:
        rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions Module* modules*

.PHONY: modules modules_install clean
else
        obj-m :=globalmem.o
endif
~

3、编写驱动测试程序

test_globalmen.c

#include<stdio.h>
int main()
{
        FILE *file;
        char read;
        file = fopen("/dev/globalmem","r+");
        if (file == NULL)
        {
                printf("open file failed!\n");
                return 0;
        }
        fprintf(file,"hello world!");
        fseek(file,0,0);
        read = fgetc(file);
        while (read!=EOF)
        {
                printf("%c", read);
                read = fgetc(file);
        }
        printf("\n");
        fclose(file);
        return 0;
}

4、编译内核、编译驱动测试程序、加载内核

在终端输入命令 lsmod 查看加载进内核的所有驱动：

在终端输入命令 dmesg 查看内核打印出来的信息：

回头看看globalmem.c的代码，再看看输出的信息，你就能知道驱动加载进内核时执行了哪些函数。

进入设备文件 (/dev) 发现节点globalmem已经自动创建好了：

5、测试内核

执行驱动测试程序：

在终端输入dmesg查看驱动程序执行过程中内核打印出来的信息：

通过这些信息再解和globalmem.c的代码应该就能知道驱动程序执行时调用了驱动中的哪些函数了，驱动测试程序和驱动程序中的函数对应关系如下：

你可以试着把/dev目录下的节点globalmen删掉，然后执行设备驱动程序看看。（这能加深你对节点、驱动、程序之间关系的理解）

6、卸载内核

输入 rmmod globalmem卸载驱动：

输入dmesg查看卸载驱动时的内核信息：

输入lsmod查看当前加载进内核的驱动：

进入/dev查看当前的节点：

Hello_xzy_Word

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Linux驱动编写、Udev自动创建节点、编写驱动测试程序

1、编写驱动 globalmem.c/* * A globalmem driver as an example of char device drivers * * The initial developer of the original code is Barry Song * <author@linuxdriver.cn>. All Rights Reserved...
复制链接

扫一扫