02-编写单个字节设备模块的驱动套路

最新推荐文章于 2024-08-09 16:57:45 发布
最新推荐文章于 2024-08-09 16:57:45 发布
阅读量195 收藏 1
点赞数 1
分类专栏： Linux内核模块开发套路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011522841/article/details/110221443
版权

 

目录

 

1.单字节设备和多字节设备的区别

2.单字节设备(LED设备驱动)的驱动套路

2.1 头文件

2.2 定义设备驱动相关的变量

2.3 编写file operations 相关操作的函数

2.3.1 open函数

2.3.2 release函数

2.3.3 write函数

2.3.4 read函数

2.3.5 填充file operations结构体

2.4 模块的初始化和卸载

2.4.1 模块的初始化

2.4.2 模块的卸载

2.5 声明

2.6完整代码如下：

3.Makefile编写

4.测试验证

4.1 测试文件编写led_test.c

5.一张图总结

1.单字节设备和多字节设备的区别

对于Linux设备而言，一共有3种设备，即字符设备、块设备和网络设备。

首先我们先来说说单个字节设备属于哪一类的设备，就字符设备而言，有分为单字节和多字节设备。顾名思义：单字节设备：就是最大只能对设备进行读取或者写入一个字节的数据，常见的有：led设备、按键设备，这种设备只会呈现出两种状态。而多字节设备：可以写入或者读取多个字节的，常见的有存储设备。

今天的话，主要是针对单字节设备(以LED设备为例)进行分析。

先说明一下开发环境：

Ubuntu 16.04

不涉及任何硬件的相关操作(如果有读者，想要移植到arm-linux开发板上运行，则需要在对应的函数上增加相关硬件操作，以及修改Makefile的编译器即可)

按照上一篇文章的套路，继续来分析一下：

2.单字节设备(LED设备驱动)的驱动套路

2.1 头文件

#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/cdev.h> //使用的是cdev
#include <linux/uaccess.h> //copy_to_user copy_from_user
#include <linux/slab.h>
//如果要涉及硬件，请包含相关头文件

2.2 定义设备驱动相关的变量

#define LED_MAJOR       0 /*采用动态的方式创建*/
#define DEVICE_NAME     "my_led" //设备的名称


static int led_major = LED_MAJOR;

/*led设备结构体*/
typedef struct LED_CDEV
{
    struct cdev cdev;//定义一个cdev结构体
    unsigned char led_value;/*led 的值，属于私有数据*/
}led_cdev_t;

static led_cdev_t *g_led_cdv;

2.3 编写file operations 相关操作的函数

2.3.1 open函数

/*打开设备*/
static int led_dev_open(struct inode *inode,struct file *filep)
{
    printk(KERN_INFO"%s\r\n",__FUNCTION__);
    filep->private_data = g_led_cdv;
    //如果涉及到硬件操作，在这里申请gpio资源即可
    return 0;
}

2.3.2 release函数

/*文件释放*/
static int led_dev_release(struct inode *inode,struct file *filep)
{
    printk(KERN_INFO"%s\r\n",__FUNCTION__);
    //如果涉及到硬件相关操作，在这里释放掉gpio资源即可
    return 0;
}

2.3.3 write函数

/*写函数*/
static ssize_t led_status_write(struct file *filep,const char __user *buf,
                                size_t size,loff_t *ppos)
{
    printk(KERN_INFO"%s\r\n",__FUNCTION__);
    int ret = 0;
    led_cdev_t *dev = filep->private_data;
    
    if(copy_from_user(&dev->led_value,buf,1))//从用户空间拷贝数据到内核空间
    {
        ret = -EFAULT;
    }
    else
    {
        printk(KERN_INFO"write:dev->led_value=%d\r\n",dev->led_value);
        //涉及到硬件，直接在这里操作即可
        ret = 1;
    }
    return ret;
}

使用copy_from_user()可以向内核传递一个数据块，如果只需要传递一个char、short、或者int类型的数据，其实也可以使用get_user()函数

它们函数原型如下所示：

/*
    to   :  内核空间缓冲区地址
    from :  用户空间地址
    n    :  数据字节数
    返回值: 不能被复制的字节数，返回 0 表示全部复制成功

*/
static inline unsigned long __must_check copy_from_user(void *to, const void __user *from, unsigned long n);


/*
    x  : 内核空间的数据
    p  : 用户空间的指针
    获取成功，返回 0，否则返回-EFAULT
*/
int get_user(x, p);

2.3.4 read函数

static ssize_t led_status_read(struct file *filep,char __user *buf,size_t size,
                              loff_t *ppos)
{
    printk(KERN_INFO"%s\r\n",__FUNCTION__);
    int ret = 0;
    led_cdev_t *dev = filep->private_data;/*获得设备结构体指针*/
    
   
    if(copy_to_user(buf,&dev->led_value,1)) /*内核空间到用户空间拷贝*/
    {
        ret = -EFAULT;
    }
    else
    {
        printk(KERN_INFO"read:dev->led_value=%d\r\n",dev->led_value);
        //涉及到硬件的操作，直接在这里操作即可
        ret = 1;/*返回具体的个数*/
    }
    return ret;
}

使用copy_to_user()可以向用户空间传递一个数据块，如果只需要传递一个char、short、或者int类型的数据，其实也可以使用put_user()函数

它们函数原型如下所示：

/*
    to   :  内核空间缓冲区地址
    from :  用户空间地址
    n    :  数据字节数
    返回值: 不能被复制的字节数，返回 0 表示全部复制成功

*/
static inline unsigned long __must_check copy_to_user(void *to, const void __user *from, unsigned long n);


/*
    x   : 内核空间的数据
    p   : 用户空间的指针。
    ret : 传递成功，返回 0，否则返回-EFAULT
*/
int put_user(x,p);

2.3.5 填充file operations结构体

/*填充file operations 结构体*/
static const struct file_operations led_dev_fops = 
{
    .owner      = THIS_MODULE,
    .open       = led_dev_open,
    .release    = led_dev_release,
    .read       = led_status_read,
    .write      = led_status_write
};

2.4 模块的初始化和卸载

2.4.1 模块的初始化

/*设备驱动模块加载函数*/
static int __init led_module_init(void)
{
    printk(KERN_INFO"%s\r\n",__FUNCTION__);
    
    int result = 0;
    dev_t dev_no = MKDEV(led_major,0);
    
    /*1.申请设备号*/
    if(led_major)
    {
        result = register_chrdev_region(dev_no,1,DEVICE_NAME);
    }
    else
    {
        /*动态申请设备号*/
        result = alloc_chrdev_region(&dev_no,0,1,DEVICE_NAME);
        led_major = MAJOR(dev_no);
    }
    
    if(result < 0)
    {
        return result;
    }
    
    /*2.动态申请设备结构体的内存*/
    g_led_cdv = kmalloc(sizeof(led_cdev_t),GFP_KERNEL);
    
    if(!g_led_cdv)
    {
        /*申请失败*/
        result = -ENOMEM;
        goto fail_malloc;
    }
    /*初始化并注册cdev*/
    cdev_init(&g_led_cdv->cdev,&led_dev_fops);/*初始化*/
    result = cdev_add(&g_led_cdv->cdev,dev_no,1);/*注册*/
    if(result)
    {
        printk(KERN_INFO"Error to add led cdev");
    }
    return 0;
    
    fail_malloc:
    unregister_chrdev_region(dev_no,1);
    return result;
}

module_init(led_module_init);

2.4.2 模块的卸载

需要按照相反的顺序进行模块的卸载

cdev_add                 =====> cdev_del

kmalloc                     =====> kfree

alloc_chrdev_region =====> unregister_chrdev_region

static void __exit led_module_exit(void)
{
    printk(KERN_INFO"%s\r\n",__FUNCTION__);
    /*按照相反的顺序卸载*/
    cdev_del(&g_led_cdv->cdev);
    kfree(g_led_cdv);
    unregister_chrdev_region(MKDEV(led_major,0),1);/*释放设备号*/
}

module_exit(led_module_exit);

2.5 声明

MODULE_LICENSE("GPL");
MODULE_AUTHOR("wxb");
MODULE_DESCRIPTION("this is a led drivers!");

2.6完整代码如下：

#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/cdev.h>
#include <linux/uaccess.h> //copy_to_user copy_from_user
#include <linux/slab.h>



#define LED_MAJOR       0 /*采用动态的方式创建*/
#define DEVICE_NAME     "my_led"


static int led_major = LED_MAJOR;

/*led设备结构体*/
typedef struct LED_CDEV
{
    struct cdev cdev;
    unsigned char led_value;/*led*/
}led_cdev_t;

static led_cdev_t *g_led_cdv;
//1.file operations 函数相关实现
/*1.1 打开设备*/
static int led_dev_open(struct inode *inode,struct file *filep)
{
    printk(KERN_INFO"%s\r\n",__FUNCTION__);
    filep->private_data = g_led_cdv;
    return 0;
}
/*1.2 文件释放*/
static int led_dev_release(struct inode *inode,struct file *filep)
{
    printk(KERN_INFO"%s\r\n",__FUNCTION__);
    return 0;
}
/*1.3 读函数*/
static ssize_t led_status_read(struct file *filep,char __user *buf,size_t size,
                               loff_t *ppos)
{
    printk(KERN_INFO"%s\r\n",__FUNCTION__);
    int ret = 0;
    led_cdev_t *dev = filep->private_data;/*获得设备结构体指针*/
    
    /*内核空间到用户空间拷贝*/
    if(copy_to_user(buf,&dev->led_value,1))
    {
        ret = -EFAULT;
    }
    else
    {
        printk(KERN_INFO"read:dev->led_value=%d\r\n",dev->led_value);
        ret = 1;/*返回具体的个数*/
    }
    return ret;
}
/*1.4 写函数*/
static ssize_t led_status_write(struct file *filep,const char __user *buf,
                                size_t size,loff_t *ppos)
{
    printk(KERN_INFO"%s\r\n",__FUNCTION__);
    int ret = 0;
    led_cdev_t *dev = filep->private_data;
    
    if(copy_from_user(&dev->led_value,buf,1))
    {
        ret = -EFAULT;
    }
    else
    {
        printk(KERN_INFO"write:dev->led_value=%d\r\n",dev->led_value);
        ret = 1;
    }
    return ret;
}
/*1.5 填充file operations 结构体*/
static const struct file_operations led_dev_fops = 
{
    .owner      = THIS_MODULE,
    .open       = led_dev_open,
    .release    = led_dev_release,
    .read       = led_status_read,
    .write      = led_status_write
};

/*2 注册和卸载*/
/*2.1 设备驱动模块加载函数*/
static int __init led_module_init(void)
{
    printk(KERN_INFO"%s\r\n",__FUNCTION__);
    
    int result = 0;
    dev_t dev_no = MKDEV(led_major,0);//MKDEV是将主设备号和次设备号转换成dev_t类型的一个内核函数。
    
    /*1.申请设备号*/
    if(led_major)
    {
        result = register_chrdev_region(dev_no,1,DEVICE_NAME);
    }
    else
    {
        /*动态申请设备号*/
        result = alloc_chrdev_region(&dev_no,0,1,DEVICE_NAME);
        led_major = MAJOR(dev_no);
    }
    
    if(result < 0)
    {
        return result;
    }
    
    /*2.动态申请设备结构体的内存*/
    g_led_cdv = kmalloc(sizeof(led_cdev_t),GFP_KERNEL);
    
    if(!g_led_cdv)
    {
        /*申请失败*/
        result = -ENOMEM;
        goto fail_malloc;
    }
    /*初始化并注册cdev*/
    cdev_init(&g_led_cdv->cdev,&led_dev_fops);/*初始化*/
    result = cdev_add(&g_led_cdv->cdev,dev_no,1);/*注册*/
    if(result)
    {
        printk(KERN_INFO"Error to add led cdev");
    }
    return 0;
    
    fail_malloc:
    unregister_chrdev_region(dev_no,1);
    return result;
}

/*2.2 模块卸载函数*/
static void __exit led_module_exit(void)
{
    printk(KERN_INFO"%s\r\n",__FUNCTION__);
    /*按照相反的顺序卸载*/
    cdev_del(&g_led_cdv->cdev);
    kfree(g_led_cdv);
    unregister_chrdev_region(MKDEV(led_major,0),1);/*释放设备号*/
}

/*2.3 卸载和加载*/
module_init(led_module_init);
module_exit(led_module_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("wxb");
MODULE_DESCRIPTION("this is a led drivers!");

3.Makefile编写

KERN_VER = $(shell uname -r)
#Linux
KERN_DIR = /lib/modules/$(KERN_VER)/build  

#ARM-Linux 的源码路径
#KERN_DIR = /home/wxb/study/arm_linux/linux-2.6.35.3  
obj-m += led.o

all:
	make -C $(KERN_DIR) M=`pwd` modules
clean:
	rm -r -f *.ko *.mod.c *.mod.o *.o *.order *.symvers
.PHONY:clean

4.测试验证

4.1 测试文件编写led_test.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <fcntl.h>

#define DEV_NAME "/dev/my_led"

int main(int argc, char *argv[])
{
    int i;
    int fd = 0;
    unsigned char ch = 1;
    
    fd = open (DEV_NAME, O_RDWR);
    if (fd < 0) 
    {
        perror("Open "DEV_NAME" Failed!\n");
        exit(1);
    }
    /*先写入一个字节数据*/
    i = write(fd, &ch, 1);
    if (!i) 
    {
        perror("write "DEV_NAME" Failed!\n");
        exit(1);
    }
    /*然后再读出来*/
    i = read(fd, &ch, 1);
    if (!i) 
    {
        perror("read "DEV_NAME" Failed!\n");
        exit(1);
    }
    else
    {
        printf("read data is %d\r\n",ch);
    }
    /*关闭文件*/
    close(fd);
    return 0;
}

编译得到可执行文件

gcc led_test.c -o led_test

使用make生成模块

make

然后查看设备号

cat /proc/devices

根据该设备的设备号创建一个设备节点

mknod /dev/my_led c 243 0    # c代表char,243与查看的主设备号要一致，0代表第1个从设备

创建完节点之后，我们可以在/dev/的目录下发现该设备

ls /dev/

最后执行命令

./led_test

可得到如下打印信息。

5.一张图总结

玩转物联网
关注
专栏目录
Android App性能优化总结
程序员光剑
08-03 1182
1.1 为什么写这个系列Android系统作为当前最流行的移动设备操作系统，其广泛应用、高速迭代以及庞大的市场份额都对其性能提出了极高的要求。性能优化也成为企业应对快速发展和海量用户的第一道防线。因此，对于Android平台上应用性能的优化，不仅仅局限于单个应用，而是整个移动终端系统的关键。1.2 本系列的主要内容本系列将从系统层面到应用层面，通过系统架构、应用设计模式、运行机制等方面，全方位探讨Android平台上应用性能优化的实践经验。Android系统架构设计及启动流程分析。
OS- -I/O之I/O软件原理及层次结构
wolfGuiDao的博客
08-03 1259
OS- -I/O之I/O软件原理及层次结构 文章目录OS- -I/O之I/O软件原理及层次结构一、I/O软件原理1.I/O软件目标设备独立性错误处理同步和异步传输缓冲共享和独占2.使用程序控制I/O3.使用中断驱动I/O4.使用DMA的I/O二、I/O层次结构1.中断处理程序2.设备驱动程序3.与设备无关的I/O软件缓冲错误处理设备驱动程序统一接口分配和释放设备无关的块4.用户空间的I/O软件 一、I/O软件原理 1.I/O软件目标 设备独立性 现在让我们转向对I/O软件的研究，I/O软件设计一个很重要
《LINUX设备驱动程序》第4章（调试技术）学习笔记
Harric
09-10 1293
第  4 章  调试技术 内核中的调试支持 开发的内核应当激活的配置选项. 除特别指出外, 所有的这些选项都在menu config的 "kernel hacking" 菜单. 注意有些选项不是所有体系架构都支持其中的选项. CONFIG_DEBUG_KERNEL 这个选项只是使其他调试选项可用; CONFIG_DEBUG_SLAB 这个重要的选项打开了内核内存分配函数的几类检查;
深入linux设备驱动程序内核机制(第四章) 读书笔记
随风
06-09 2837
第四章 互斥与同步     本文欢迎大家转载     原文出自: http://blog.csdn.net/dyron 4.1 并发的来源     并发, 是指可能导致对共享资源的访问出现竞争状态的若干执行路径, 不一定是指严格的时间意义上的并发执行     linux系统下并发的来源主要有:     . 中断处理路径     当系统正在执行当前进程时, 发生中断,
Linux字符设备驱动开发
最新发布
Chinalihuanyu的博客
08-09 1296
字符设备就是一个一个字节，按照字节流进行读写操作的设备，读写数据是分先后顺序的。Linux里面一切皆文件，驱动设备表现就是一个/dev/下的文件，如/dev/led，应用程序调用open函数打开一个设备的时候，比如led。应用程序通过write函数向/dev/led写数据。关闭设备close。编写驱动的时候，需要编写驱动的open、close、write函数。字符设备驱动struct file_operations。写驱动的时候要考虑应用开发的便利性。驱动分框架，要按照驱动框架来编写。
Linux设备驱动程序（第三版）第四章示例驱动程序
lgc1990的博客
09-19 187
Linux设备驱动程序（第三版） 作者科波特(Corbet, j.)书本的示例代码比较零乱，而且网站上给的示例代码是旧版或者是比较完整的代码，且没有单独成章。初学者学习起来比较困难，所以笔者分享一下在学习过程中调试过的模块，供有需要的读者参阅。由于侧重书本每章的知识，所以模块仅反映每章的知识点，不是一个全面的驱动模块，但对学习驱动的编写可能比看书本本身网站提供的代码会更有侧重点。仅仅是每一章相对前一章增加一些代码，而不是一个全面的代码。希望能够交流学习。也可以通过 https://gitee.com/san
Linux设备驱动程序笔记(4)
aaron_xxy的博客
12-20 227
第四章 并发和竞态 • 并发及其管理 大部分竞态可通过使用内核的并发控制原语，并应用几个基本的原理来避免。第一个规则是，只要可能，就应该避免资源的共享，这种思想的明显应用就是避免使用全局变量。但硬件资源本质上就是共享的，软件资源经常需要对其他执行线程可用。全局变量并不是共享数据的唯一途径，只要我们的代码将一个指针传递给了内核的其他部分，一个新的共享就可能建立。在单个执行线程之外共享硬件...
Nginx架构及配置详解
企业实战系列集 ●●● https://ximenjianxue.blog.csdn.net
09-10 5322
概述 Nginx采用C进行编写，是俄罗斯程序员开发的一款轻量级的可构建Web 服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器的软件， Nginx服务器是一个高性能的HTTP和反向代理web服务器，同时也可提供了IMAP/POP3/SMTP服务。nginx常用作跑静态和做负载反向代理，动态php交给apache处理，因后者比较稳定，jsp交给tomcat、resin或jboss。n......
操作系统之输入输出（I/O）
weixin_50866517的博客
04-28 3040
操作系统之输入输出I/O设备块设备块设备的缺点字符设备设备控制器内存映射I/O内存映射I/O的优点和缺点直接内存访问DMA工作原理重温中断精确中断和不精确中断I/O软件原理I/O软件目标设备独立性错误处理同步和异步传输缓冲共享和独立使用程序控制I/O使用中断驱动I/O使用DMA的I/OI/O层次结构中断处理程序设备驱动程序与设备无关的I/O软件用户空间的I/O软件盘盘硬件磁盘臂调度算法错误处理稳定存储器时钟时钟硬件时钟软件软定时器 我们之前的文章提到了操作系统的三个抽象，它们分别是进程、地址空间和文件，除
C语言写的pascal编译器,编译原理课程设计———Simple PASCAL编译器的设计与实现...
weixin_39724287的博客
05-18 901
设计并实现一个简单Pascal语言的编译器。主要包括几个模块：词法分析模块-------------------2020/05/29 备注： 本菜鸟只实现了这一个模块----------------------------------------链接：https://pan.baidu.com/s/1Z2-O-3S4q0CFMfeI5uIzfg 提取码：256x ---------------...
字符设备
ss0429的专栏
03-19 989
from here：字符设备http://blog.163.com/sunshine_linting/blog/static/44893323201181102957282/   字符设备是一种按字节来访问的设备，字符驱动则负责驱动字符设备，这样的驱动通常实现 open, close, read和 write 系统调用。 块设备 在大部分的 Unix 系统, 块设备不能按字节处理数
Linux字符驱动程序的基本结构与函数
Quartz's Blog
10-16 535
基本的函数与结构函数//驱动注册，注销函数 module_init(void (*func)); module_exit(void (*func)); 了两个函数，将会在执行insmod和rmmod时对传入的函数进行回调。//打开文件 int open(const char *pathname, int flags, mode_t mode);//读取文件到buf int read(int fd,
Linux设备驱动程序学习 高级字符驱动程序操作［阻塞型I/O和非阻塞I/O]【转】
weixin_33827965的博客
12-21 138
转自：http://blog.csdn.net/jacobywu/article/details/7475432阻塞型I/O和非阻塞I/O 阻塞：休眠 非阻塞：异步通知 一 休眠 安全地进入休眠的两条规则： （1） 永远不要在原子上下文中进入休眠，即当驱动在持有一个自旋锁、seqlock或者 RCU锁时不能睡眠；关闭中断也不能睡眠。持有一个信号量时休眠是合法的，但你应当...
Linux设备驱动程序——高级字符驱动程序操作（阻塞型I/O）
holly的专栏
01-19 524
阻塞型I/O
字符设备和块设备的区别
respectableking的博客
10-07 1045
1.字符设备是一种按照字节来访问的设备 2.在大部分Unix中，块设备不能按照字节处理数据，只能一次传输一个或者多个512个字节（或者更大的2次幂的数）的整块数据    而在Linux中允许块设备访问任意字节的数据 3.块设备可以随机访问（不按照顺序）数据，字符设备按照字节流的方式有序的访问数据
字节设备注册的驱动开发(基于汇编语言）
weixin_43878062的博客
05-11 480
CSDN话题挑战赛第1期 活动详情地址：第1期话题PK赛 参赛话题：汇编知识分享 话题描述：我们的计算机知识就像一座金字塔，底层是数学，上面是数字电路，然后是汇编，再往上是操作系统、网络，数据库、高级编程语言、框架等等…我们不可能精通这个金子塔的每一层， 但是想走的更远就必须要了解这个金字塔的底层。因此，学习汇编并不是为了用汇编在应用层设计程序，而是为了深刻理解机器运行程序的机理。就像对于人来说不能没有常识一样，尽管常识不能直接挣钱吃饭，但它影响谈吐，影响你的判断力和决断力，决定着你接受新事物和新知识的程.
Linux设备驱动基础知识
m0_73003084的博客
11-04 1199
Linux设备驱动基础知识 分层思想 字符设备驱动 块设备驱动 网络设备驱动 驱动与内核 驱动安全性问题 拷贝读写文件 mmap mmap函数
驱动怎么学
xaioqinjie的博客
01-12 670
1、什么是驱动？ 2、模块化设计：微内核和宏内核 3、linux设备驱动分类 4、驱动程序的安全性要求 5、驱动应该这么学
Linux字符设备驱动开发：mydriver模块详解
"这篇文档是关于Linux字符设备驱动程序的编写教程，主要涉及如何创建一个名为`mydriver`的简单驱动程序，该程序以可加载模块的形式存在，避免了重新编译内核的需求。驱动程序的核心功能包括打开、关闭、读取和写入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值