Linux驱动-字符设备驱动hello

已于 2023-08-22 16:29:24 修改
阅读量82 收藏
点赞数
分类专栏： 嵌入式 文章标签： linux
于 2023-08-22 16:16:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fb1103/article/details/132428450
版权

写在前面：文章中的代码及截图，基本来自韦东山老师的课程。

<1>最简单的字符设备驱动：

#include <linux/mm.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mman.h>
#include <linux/random.h>
#include <linux/init.h>
#include <linux/raw.h>
#include <linux/tty.h>
#include <linux/capability.h>
#include <linux/ptrace.h>
#include <linux/device.h>
#include <linux/highmem.h>
#include <linux/backing-dev.h>
#include <linux/shmem_fs.h>
#include <linux/splice.h>
#include <linux/pfn.h>
#include <linux/export.h>
#include <linux/io.h>
#include <linux/uio.h>

#include <linux/uaccess.h>

//头文件的来源：抄其他调用这个函数的文件


static int major;

static int hello_open (struct inode *node, struct file *filp)
{
    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return 0;
}
static ssize_t hello_read (struct file *filp, char __user *buf, size_t size, loff_t *offset)
{
    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return size;
}

static ssize_t hello_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{
    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return size;
}

static int hello_release (struct inode *node, struct file *filp)
{
    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return 0;
}

/* 1. create file_operations */
static const struct file_operations hello_drv = {
    .owner      = THIS_MODULE,
	.read		= hello_read,
	.write		= hello_write,
	.open		= hello_open,
    .release    = hello_release,
};


/* 2. register_chrdev */

/* 3. entry function */
static int hello_init(void)
{
   major = register_chrdev(0, "100ask_hello", &hello_drv);//0：动态分配主设备号
   return 0;
}


/* 4. exit function */
static void hello_exit(void)
{
    unregister_chrdev(major, "100ask_hello");
}


module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

<2>APP和driver如何交互数据：

在这里插入图片描述在这里插入图片描述

<3>自动创建设备节点

如果不自动创建设备节点，需要使用手动创建；

自动创建设备节点的步骤：
（1）创建类：
在这里插入图片描述
（2）创建类之后，在类下面创建设备
在这里插入图片描述

<4> 字符设备的另一种创建方法

#include "asm-generic/errno-base.h"
#include "asm/cacheflush.h"
#include "linux/cdev.h"
#include "linux/fs.h"
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mman.h>
#include <linux/random.h>
#include <linux/init.h>
#include <linux/raw.h>
#include <linux/tty.h>
#include <linux/capability.h>
#include <linux/ptrace.h>
#include <linux/device.h>
#include <linux/highmem.h>
#include <linux/backing-dev.h>
#include <linux/shmem_fs.h>
#include <linux/splice.h>
#include <linux/pfn.h>
#include <linux/export.h>
#include <linux/io.h>
#include <linux/uio.h>

#include <linux/uaccess.h>


static struct class *hello_class;
static struct cdev hello_cdev;
static dev_t dev;

static unsigned char hello_buf[100];

static int hello_open (struct inode *node, struct file *filp)
{
    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return 0;
}
static ssize_t hello_read (struct file *filp, char __user *buf, size_t size, loff_t *offset)
{
    unsigned long len = size > 100 ? 100 : size;

    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);

    copy_to_user(buf, hello_buf, len);

    return len;
}

static ssize_t hello_write(struct file *filp, const char __user *buf, size_t size, loff_t *offset)
{
    unsigned long len = size > 100 ? 100 : size;

    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    copy_from_user(hello_buf, buf, len);

    return len;
}

static int hello_release (struct inode *node, struct file *filp)
{
    printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
    return 0;
}

/* 1. create file_operations */
static const struct file_operations hello_drv = {
    .owner      = THIS_MODULE,
	.read		= hello_read,
	.write		= hello_write,
	.open		= hello_open,
    .release    = hello_release,
};


/* 2. register_chrdev */

/* 3. entry function */
static int hello_init(void)
{
    int ret;

    // register_chrdev

	ret = alloc_chrdev_region(&dev, 0, 2, "hello");
	if (ret < 0) {
		printk(KERN_ERR "alloc_chrdev_region() failed for hello\n");
		return -EINVAL;
	}

    cdev_init(&hello_cdev, &hello_drv);

    ret = cdev_add(&hello_cdev, dev, 2);
	if (ret)
    {
		printk(KERN_ERR "cdev_add() failed for hello\n");
		return -EINVAL;
    }
		
	hello_class = class_create(THIS_MODULE, "hello_class");
	if (IS_ERR(hello_class)) {
		printk("failed to allocate class\n");
		return PTR_ERR(hello_class);
	}

    device_create(hello_class, NULL, dev, NULL, "hello");  /* /dev/hello */

   return 0;
}


/* 4. exit function */
static void hello_exit(void)
{
    device_destroy(hello_class, dev);

    class_destroy(hello_class);

    //unregister_chrdev(major, "100ask_hello");
    cdev_del(&hello_cdev);
    unregister_chrdev_region(dev, 2);
}


module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

注意到：这两种方法都有创建class和device。
在这里插入图片描述

<5>总线设备模型platform-分离字符设备驱动

分为：hello_drv.c 和 hello_dev.c
虚拟总线：platform_bus：两边分别是xxx_drv.c（驱动相关）和xxx_dev.c（设备相关）

从匹配的platform_device里得到版本信息，设置版本信息。

xxx_drv.c（驱动相关）：

#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/device.h>
#include <linux/ioctl.h>
#include <linux/ctype.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/uaccess.h>
#include <linux/compat.h>
#include <linux/platform_device.h>

/* 参考: drivers\char\ppdev.c 
 *       drivers\char\ipmi\ipmi_powernv.c
 */

static char hello_buf[100] = "ver2";

static int hello_open(struct inode *inode, struct file *file)
{
	printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
	return 0;
}

/* APP : read(fd, buffer, len) */
static ssize_t hello_read(struct file *file, char __user *buf, size_t count,
		       loff_t *ppos)
{
	int err;
	if (count > 100)
		count = 100;
	err = copy_to_user(buf, hello_buf, count);
	return count;
}

static int hello_release(struct inode *inode, struct file *file)
{
	printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
	return 0;
}

/* 分配/设置/注册 file_operations结构体 */
static const struct file_operations hello_fops = {
	.owner		= THIS_MODULE,
	.read		= hello_read,
	.open		= hello_open,
	.release	= hello_release,
};


static int hello_probe(struct platform_device *pdev)
{
	int err;
	int len;

	/* 从匹配的platform_device里得到版本信息
	 * 用来设置: hello_buf
	 */
	len = strlen(pdev->resource[0].name) + 1;
	if (len > 100)
		len = 100;
	strncpy(hello_buf, pdev->resource[0].name, len);
	hello_buf[len - 1] = '\0';
	
	err = register_chrdev(88, "100ask_hello_drv", &hello_fops);
	printk("register_chrdev ret = %d\n", err);
	return err;
}

static int hello_remove(struct platform_device *pdev)
{
	unregister_chrdev(88, "100ask_hello_drv");
	return 0;
}

/* 分配/设置/注册一个 platform_driver */
static struct platform_driver hello_driver = {
	.driver = {
		.name		= "100ask_hello",
	},
	.probe	= hello_probe,
	.remove	= hello_remove,
};

int hello_init(void)
{
	int err;
	err = platform_driver_register(&hello_driver);	
	return err;
}

//int init_module(void) __attribute__((alias("hello_init")));

void hello_exit(void)
{
	platform_driver_unregister(&hello_driver);	
}

module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

xxx_dev.c（设备相关）：

#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/device.h>
#include <linux/ioctl.h>
#include <linux/ctype.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/uaccess.h>
#include <linux/compat.h>
#include <linux/platform_device.h>


/* 参考 :drivers/char/ipmi/ipmi_msghandler.c  */

static struct resource hello_resources[] = {
	{
		.name	= "ver123",
		.start	= 0,
		.end	= 3,
		.flags	= IORESOURCE_MEM,
	}, 
};


static void	hello_dev_release(struct device *dev)
{
}

/* 分配/设置/注册 platform_device */
static struct platform_device hello_device = {
	.name			= "100ask_hello",
	.id			= -1,
	.dev = {
		.release = hello_dev_release,
	},
	.num_resources		= ARRAY_SIZE(hello_resources),
	.resource		= hello_resources,
};

int hello_dev_init(void)
{
	int err;
	err = platform_device_register(&hello_device);	
	return err;
}

//int init_module(void) __attribute__((alias("hello_init")));

void hello_dev_exit(void)
{
	platform_device_unregister(&hello_device);	
}


module_init(hello_dev_init);
module_exit(hello_dev_exit);
MODULE_LICENSE("GPL");

在这里插入图片描述

<6> 设备树——字符设备驱动（需要手动创建设备结点）

（1）修改设备树
（2）xxx_driver.c中的
在这里插入图片描述
从设备树读取版本信息：
在这里插入图片描述
在这里插入图片描述将设备树转化为platform_dev;
在这里插入图片描述

xxx_drv.c（驱动相关）：

#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/device.h>
#include <linux/ioctl.h>
#include <linux/ctype.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/uaccess.h>
#include <linux/compat.h>
#include <linux/platform_device.h>
#include <linux/of.h>

/* 参考: drivers\char\ppdev.c 
 *       drivers\char\ipmi\ipmi_powernv.c
 */

static char hello_buf[100] = "ver2";

static int hello_open(struct inode *inode, struct file *file)
{
	printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
	return 0;
}

/* APP : read(fd, buffer, len) */
static ssize_t hello_read(struct file *file, char __user *buf, size_t count,
		       loff_t *ppos)
{
	int err;
	if (count > 100)
		count = 100;
	err = copy_to_user(buf, hello_buf, count);
	return count;
}

static int hello_release(struct inode *inode, struct file *file)
{
	printk("%s %s %d\n", __FILE__, __FUNCTION__, __LINE__);
	return 0;
}

/* 分配/设置/注册 file_operations结构体 */
static const struct file_operations hello_fops = {
	.owner		= THIS_MODULE,
	.read		= hello_read,
	.open		= hello_open,
	.release	= hello_release,
};


static int hello_probe(struct platform_device *pdev)
{
	int err;
	int len;
	const char *vers; /* vers is a pointer, point to "const char"  */

	/* 从匹配的platform_device里得到版本信息
	 * 用来设置: hello_buf
	 */

	err = of_property_read_string_index(pdev->dev.of_node, "version",
				      0, &vers);

	if (err)
	{
		vers = "no version";
	}

	len = strlen(vers) + 1;
	if (len > 100)
		len = 100;
	strncpy(hello_buf, vers, len);
	hello_buf[len - 1] = '\0';
	
	err = register_chrdev(88, "100ask_hello_drv", &hello_fops);
	printk("register_chrdev ret = %d\n", err);
	return err;
}

static int hello_remove(struct platform_device *pdev)
{
	unregister_chrdev(88, "100ask_hello_drv");
	return 0;
}

static const struct of_device_id hello_dt_ids[] = {
	{ .compatible = "100ask,hello", },
	{ /* sentinel */ }
};


/* 分配/设置/注册一个 platform_driver */
static struct platform_driver hello_driver = {
	.driver = {
		.name		    = "100ask_hello",
		.of_match_table = hello_dt_ids,	
	},
	.probe	= hello_probe,
	.remove	= hello_remove,
};

int hello_init(void)
{
	int err;
	err = platform_driver_register(&hello_driver);	
	return err;
}

//int init_module(void) __attribute__((alias("hello_init")));

void hello_exit(void)
{
	platform_driver_unregister(&hello_driver);	
}

module_init(hello_init);
module_exit(hello_exit);
MODULE_LICENSE("GPL");

右边：是设备树，本质上将设备树转化为dev


/* arch/arm/boot/dts/100ask_imx6ull-14x14.dts */

/ {
    model = "Freescale i.MX6 ULL 14x14 EVK Board";
    compatible = "fsl,imx6ull-14x14-evk", "fsl,imx6ull";

    hello {
       compatible = "100ask,hello";
       version = "ver123456";
    };

<7>设备树-自动创建设备结点

这一节本质上是在<6>的基础上加入<3>的两个函数；
在这里插入图片描述

ddl又来了
关注
专栏目录
linux字符设备驱动程序——hello_world
m0_74282605的博客
07-03 241
在这一系列的文章中，我将介绍怎么去编写linux设备驱动程序，linux内核支持将设备驱动程序编译进内核和运行时加载进内核两种方式，在这一系列文章中，主要讨论编译可加载模块,一般开发者会将设备驱动程序编译成可加载模块，在linux运行时动态加载进内核，以实现对应设备的驱动。如果没有相应的鼠标驱动程序，电脑并不知道鼠标的接口以什么协议将数据传输过来，也不知道怎么解析相应的数据，所以当然电脑上的光标不会跟随鼠标的移动而移动，归根结底，鼠标的移动和电脑上光标的移动是两者间数据同步的结果。
Linux设备驱动-创建字符设备
Leo-夜空的博客
08-11 642
字符设备驱动程序，内容主要包括初始化、添加、删除cedv，申请和释放设备号，以及填充file_operations的操作函数
通过GPIO子系统编写LED驱动，应用程序控制LED灯亮灭
2302_76472078的博客
06-20 98
【代码】通过GPIO子系统编写LED驱动，应用程序控制LED灯亮灭。
linux 驱动基础 - 一、字符设备
sty01z的博客
06-24 1566
该结构体是系统调用与驱动连接的桥梁，当我们在应用层使用 open 函数打开一个设备的时候，内核会创建一个 file 结构并关联 file_operations 中的一组函数，最终会调用到驱动中关联的 file_operations 结构体实例中 open 函数。实际上并没用到所有的 12 位，在老式内核中主设备号的范围为 0-255。向系统删除一个cdev，完成字符设备的卸载，对 cdev_del 的调用通常发生在字符设备驱动模块卸载函数中，当 cdev_del 被调用后对应的cdev结构就不应被访问了。
Linux驱动入门-最简单字符设备驱动
ITQWQ的博客
07-01 574
字符设备是 Linux 驱动中最基本的一类设备驱动，按字节流进行读写操作，数据读写有先后顺序。常见的字符设备包括LED灯、按键、IIC、SPI、LCD等。字符设备驱动就是为这些设备编写的驱动程序。这篇博文详细介绍了 Linux 字符设备驱动开发的基本概念、步骤和示例程序。希望通过实践操作，大家能够更好地理解和掌握字符设备驱动开发的核心知识和技巧。
【Linux驱动】字符设备驱动
Julian的博客
12-18 990
字符设备是 Linux 驱动中最基本的一类设备驱动，字符设备就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。比如我们最常见的点灯、按键、IIC、SPI，LCD 等等都是字符设备，这些设备的驱动就叫做字符设备驱动。编写一个驱动程序的时候需要调用上层驱动函数的时候需要调用底层实现，并且底层需要留给上层接口，并暴露出去。Linux内核文件中有一个叫做。#endif上层程序使用open。
Linux驱动——字符设备驱动
Linux驱动开发工程师，熟悉Linux/Android底层驱动、TP、显示、IIC、网络等通用外设调试适配，Linux上层应用开发，主要集中在瑞芯微和全志平台。
04-08 2712
1.使用什么工具来写驱动代码：安装source insight工具（1）找到软件提示把工具安装激活（2）把Linux内核代码解压到windows目录中（3）打开工具添加查看的项目第一个对话框：第一个文本框：输入工程名字第二个文本框：路径(默认)第二个对话框： 在项目源码位置，选择 Linux内核代码位置 点击OK 第三个对话框： 选择需要查看的Linux内核代码的包含的源码文件（要查看的内核目录）需要添加的目录：driver/iicinclude。
嵌入式驱动初级-字符设备驱动基础
weixin_44681745的博客
11-25 1385
字符设备驱动
Linux驱动---字符设备注册-更简单的方式
qq_49079545的博客
07-29 428
1、字符设备驱动编写步骤 2、更简单的注册 static int register_chrdev(unsigned int major, const char *name, const struct file_operations *fops) static void unregister_chrdev(unsigned int major, const char *name) 3、编写实例： 驱动函数 #include <linux/hdreg.h> #include <l
Linux驱动开发---杂项设备
智小星的博客
12-09 1726
一、基本概念 Linux设备驱动类型： 字符设备：字符设备是能够像字节流一样被访问的设备。 一般说来对硬件设备 IO 的操作可以归结为字符设备。 常见的字符设备有 led、 蜂鸣器、 串口、 键盘等； 块设备：块设备室通过内存缓冲区访问， 可以随机存取的设备， 一般性的理解就是存储介质类的设备。常见的字符设备有 U 盘、 TF 卡、 eMMC、 电脑硬盘、 光盘等等； 网络设备：可以和其它主机交换数据的设备。常见的以太网设备、WIFI、蓝牙等。 杂项设备： 杂项设备是字符设备的一种，可以自动生.
Linux字符设备驱动模板 hello_driver.tar.gz
04-03
Linux字符设备驱动模板， （1）分配一个file_operation结构体； （2）设置file_operation结构体； （3）注册 cdev （4）入口（模块加载）； （5） 出口（卸载函数）；
Linux字符设备驱动实验代码
01-08
简单的字符设备的驱动程序，并对所编写的设备驱动程序进行测试，了解Linux操作系统如何管理字符设备。由于网上许多资源不完整，本资源整合了许多内容。包括驱动程序memdev.c，memdev.h，app-mem.c，MakeFile文件。...
Linux增加字符设备驱动实验
05-11
本实验旨在帮助你理解如何为Linux添加一个新的字符设备驱动，以实现简单的"Hello World"输出。以下是关于这个实验的详细过程和相关知识点。 1. **字符设备驱动概述**： - 字符设备驱动是针对一次性读写或流式传输...
linux 网络序
CodeHouse的博客
09-30 350
在将ip字符串转网络序存储时。根据整形二进制显示判断。
Linux 再入门整理：详解 /etc/fstab 文件
最新发布
一只奋斗的猪
10-01 652
`/etc/fstab` 文件是 Linux 系统中用于定义和管理文件系统的挂载信息的配置文件。它的作用是告诉系统在启动时，应该如何自动挂载各种文件系统。挂载是 Linux 操作系统中一种将存储设备与目录树关联的操作。通过挂载，存储设备中的文件可以通过目录访问。
在 Kali Linux 中安装 Impacket
weixin_44023460的博客
09-30 187
在安装 Impacket 之前，你需要确保安装了 Python 和一些必要的依赖。通常，Kali 已经预装了 Python。步骤 3：克隆 Impacket 仓库。步骤 4：进入 Impacket 目录。如果你看到帮助信息，说明安装成功。步骤 5：安装 Impacket。
Linux的基本指令（2）
shylyly_的博客
10-01 732
Linux的基本指令（2） man nano cp mv which 自制指令 alias echo cat tac > >> < more less head tail |（管道）
Linux 安装redis主从模式+哨兵模式3台节点
一千个读者就有一千个哈姆雷特
09-27 402
Linux 安装redis主从模式+哨兵模式3台节点
linux 源代码编译
Lxn2zh的博客
09-27 1342
有时候会在linux上下载源码包，然后进行编译成可执行的文件，这个过程需要经过configure、make、make install、make clean四个步骤。configure 为这个程序在当前的操作系统环境下选择合适的编译器和环境参数来编译该代码。make install 将已编译好的可执行文件安装到操作系统指定或默认的安装目录下。make 对程序代码进行编译操作，会将源码编译成可执行的目标文件。make clean 删除编译时临时产生的目录或文件。
Linux字符设备驱动详解：cdev与设备号
1. 字符驱动模型 字符驱动模型的核心是`struct cdev`结构体。这个结构体包含了设备驱动的基本信息，如与内核对象`kobject`的关联、所属模块`struct module`、设备操作函数集`const struct file_operations *ops`、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值