Linux驱动入门-最简单字符设备驱动

已于 2024-07-01 22:00:22 修改
阅读量716 收藏 5
点赞数 6
分类专栏： Linux字符驱动 文章标签： linux
于 2024-07-01 21:59:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ITQWQ/article/details/140111029
版权

一、字符设备驱动概念

1. 什么是字符设备驱动？

字符设备是 Linux 驱动中最基本的一类设备驱动，按字节流进行读写操作，数据读写有先后顺序。常见的字符设备包括LED灯、按键、IIC、SPI、LCD等。字符设备驱动就是为这些设备编写的驱动程序。

2. Linux应用程序如何调用驱动程序

在 Linux 中，一切皆为文件，驱动加载成功后，会在 /dev 目录下生成一个相应的文件，应用程序通过操作该文件即可实现对硬件的操作。例如 /dev/led 是一个 LED 灯的驱动文件，应用程序可以使用 open 函数打开文件 /dev/led，使用 close 函数关闭文件 /dev/led。要点亮或关闭 LED，可以使用 write 函数向该驱动写入数据；要获取 LED 状态，可以使用 read 函数从驱动读取状态。

3. 系统调用与驱动函数

应用程序运行在用户空间，驱动运行在内核空间，用户空间不能直接操作内核空间。因此，通过系统调用的方式实现用户空间与内核空间的交互。每个系统调用在驱动中都有对应的驱动函数。驱动程序中的 file_operations 结构体定义了这些操作函数：

struct file_operations {
    struct module *owner;
    loff_t (*llseek) (struct file *, loff_t, int);
    ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
    ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
    int (*open) (struct inode *, struct file *);
    int (*release) (struct inode *, struct file *);
    // 其他函数省略
};

4. file_operations 结构体常用函数

  • owner: 指向拥有该结构体的模块的指针，一般设置为 THIS_MODULE。
  • read: 用于读取设备文件。
  • write: 用于向设备文件写入数据。
  • open: 用于打开设备文件。
  • release: 用于释放（关闭）设备文件。

二、字符设备驱动开发步骤

1. 驱动模块的加载和卸载

Linux 驱动有两种运行方式：编译进内核或编译成模块。模块的加载和卸载注册函数如下：

module_init(xxx_init); // 注册模块加载函数
module_exit(xxx_exit); // 注册模块卸载函数

驱动模块加载和卸载模板：

static int __init xxx_init(void) {
    // 入口函数的具体内容
    return 0;
}

static void __exit xxx_deinit(void) {
    // 出口函数的具体内容
}

module_init(xxx_init);
module_exit(xxx_deinit);

2. 添加LICENSE和作者信息

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Author Name");

3. 示例程序

3.1 编写 hello_driver.c
#include <linux/module.h>

static int __init hello_driver_init(void) {
    printk("hello_driver_init\n");
    return 0;
}

static void __exit hello_driver_cleanup(void) {
    printk("hello_driver_cleanup\n");
}

module_init(hello_driver_init);
module_exit(hello_driver_cleanup);
MODULE_LICENSE("GPL");
3.2 编写 Makefile
KERNELDIR := /lib/modules/$(shell uname -r)/build
CURRENT_PATH := $(shell pwd)
obj-m := hello_driver.o

build: kernel_modules

kernel_modules:
    $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules

clean:
    $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
3.3 编译、加载、卸载模块
make
sudo insmod hello_driver.ko
lsmod | grep hello_driver
dmesg | grep hello_driver
sudo rmmod hello_driver

4. 字符设备注册与注销

字符设备的注册和注销函数原型：

static inline int register_chrdev(unsigned int major, const char *name, const struct file_operations *fops);
static inline void unregister_chrdev(unsigned int major, const char *name);

设备号的定义和操作：

#define MINORBITS 20
#define MINORMASK ((1U << MINORBITS) - 1)
#define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS))
#define MINOR(dev) ((unsigned int) ((dev) & MINORMASK))
#define MKDEV(ma, mi) (((ma) << MINORBITS) | (mi))

5. 内核空间与用户空间数据交互

unsigned long copy_to_user(void *dst, const void *src, unsigned long len);
unsigned long copy_from_user(void *to, const void *from, unsigned long n);

6. 示例程序：注册字符设备

6.1 hello_driver.c 内容
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>

#define CHRDEVBASE_MAJOR 200
static char kernel_buffer[1024];

static int hello_open(struct inode *inode, struct file *file) {
    printk("hello_open\n");
    return 0;
}

static int hello_release(struct inode *inode, struct file *file) {
    printk("hello_release\n");
    return 0;
}

static ssize_t hello_read(struct file *file, char __user *buffer, size_t size, loff_t *ppos) {
    printk("hello_read: size=%zu\n", size);
    copy_to_user(buffer, kernel_buffer, size);
    return size;
}

static ssize_t hello_write(struct file *file, const char __user *buffer, size_t size, loff_t *ppos) {
    printk("hello_write: size=%zu\n", size);
    copy_from_user(kernel_buffer, buffer, size);
    return size;
}

static const struct file_operations hello_fops = {
    .owner = THIS_MODULE,
    .open = hello_open,
    .release = hello_release,
    .read = hello_read,
    .write = hello_write,
};

static int __init hello_init(void) {
    int ret = register_chrdev(CHRDEVBASE_MAJOR, "hello", &hello_fops);
    if (ret < 0) {
        printk("register_chrdev failed\n");
        return ret;
    }
    printk("hello_init\n");
    return 0;
}

static void __exit hello_cleanup(void) {
    unregister_chrdev(CHRDEVBASE_MAJOR, "hello");
    printk("hello_cleanup\n");
}

module_init(hello_init);
module_exit(hello_cleanup);
MODULE_LICENSE("GPL");
6.2 test_app.c 内容
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define BUFFER_SIZE 1024

int main(int argc, char *argv[]) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <device> <read/write>\n", argv[0]);
        return 1;
    }

    int fd = open(argv[1], O_RDWR);
    if (fd < 0) {
        perror("open");
        return 1;
    }

    char buffer[BUFFER_SIZE];
    if (strcmp(argv[2], "read") == 0) {
        ssize_t ret = read(fd, buffer, BUFFER_SIZE);
        if (ret < 0) {
            perror("read");
            close(fd);
            return 1;
        }
        printf("Read from kernel: %s\n", buffer);
    } else if (strcmp(argv[2], "write") == 0) {
        printf("Enter data to write: ");
        fgets(buffer, BUFFER_SIZE, stdin);
        ssize_t ret = write(fd, buffer, strlen(buffer));
        if (ret < 0) {
            perror("write");
            close(fd);
            return 1;
        }
    } else {
        fprintf(stderr, "Invalid operation: %s\n", argv[2]);
    }

    close(fd);
    return 0;
}
6.3 Makefile 内容
KERNELDIR := /lib/modules/$(shell uname -r)/build
CURRENT_PATH := $(shell pwd)
obj-m := hello_driver.o

build: kernel_modules

kernel_modules:
    $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
    gcc -o test_app test_app.c

clean:
    $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
    rm -f test_app

7. 自动创建设备节点

7.1 创建和删除类
struct class *class_create(struct module *owner, const char *name);
void class_destroy(struct class *cls);
7.2 创建设备
struct device *device_create(struct class *class, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...);
void device_destroy(struct class *class, dev_t devt);
8. 示例程序：自动创建设备节点
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>

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

static char kernel_buffer[1024];

static int hello_open(struct inode *inode, struct file *file) {
    printk("hello_open\n");
    return 0;
}

static int hello_release(struct inode *inode, struct file *file) {
    printk("hello_release\n");
    return 0;
}

static ssize_t hello_read(struct file *file, char __user *buffer, size_t size, loff_t *ppos) {
    printk("hello_read: size=%zu\n", size);
    copy_to_user(buffer, kernel_buffer, size);
    return size;
}

static ssize_t hello_write(struct file *file, const char __user *buffer, size_t size, loff_t *ppos) {
    printk("hello_write: size=%zu\n", size);
    copy_from_user(kernel_buffer, buffer, size);
    return size;
}

static const struct file_operations hello_fops = {
    .owner = THIS_MODULE,
    .open = hello_open,
    .release = hello_release,
    .read = hello_read,
    .write = hello_write,
};

static int __init hello_init(void) {
    int ret;
    printk("hello_init\n");
    ret = alloc_chrdev_region(&hello_devid, 0, 1, "hello");
    if (ret < 0) {
        printk("alloc_chrdev_region failed\n");
        return ret;
    }
    cdev_init(&hello_cdev, &hello_fops);
    ret = cdev_add(&hello_cdev, hello_devid, 1);
    if (ret < 0) {
        unregister_chrdev_region(hello_devid, 1);
        printk("cdev_add failed\n");
        return ret;
    }
    hello_class = class_create(THIS_MODULE, "hello_class");
    device_create(hello_class, NULL, hello_devid, NULL, "hello"); // /dev/hello
    return 0;
}

static void __exit hello_cleanup(void) {
    printk("hello_cleanup\n");
    device_destroy(hello_class, hello_devid);
    class_destroy(hello_class);
    cdev_del(&hello_cdev);
    unregister_chrdev_region(hello_devid, 1);
}

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

总结

这篇博文详细介绍了 Linux 字符设备驱动开发的基本概念、步骤和示例程序。希望通过实践操作，大家能够更好地理解和掌握字符设备驱动开发的核心知识和技巧。

琢瑜
关注
专栏目录
嵌入式 Linux 驱动开发入门 概述
yifeng_ifeng的专栏
03-23 265
Linux 驱动开发学习，主要是学习各种Linux 驱动框架，典型的如字符设备驱动框架，I2C驱动框架，SPI驱动框架，GPIO驱动框架等。这里涉及的各种概念比较多，如内核模块，设备树，总线，设备与驱动等等。好多的概念在各种驱动框架中都能发现。本人在学习Linux 驱动开发过程中，发现好多书籍在讲解Linux 驱动开发的某个概念时，经常是把局部信息讲的很细，但是并没有从更高层次或者说是从架构级别来讲解这个概念。
简单linux字符设备驱动程序与编程小技巧
02-16
简单linux字符设备驱动程序与编程小技巧 代码分析请看http://blog.csdn.net/jiebaoabcabc/article/details/19242621 http://blog.csdn.net/jiebaoabcabc/article/details/19283859
[Linux驱动开发二]最简单的字符设备
10-29
最简单的字符设备
20、字符设备驱动（模拟）
最新发布
Linux系统开发
10-11 599
代表当前终端设备;：串行端口设备，常用于 RS-232 串口通信;：伪终端设备，用于终端模拟，例如远程登录的终端（SSH);​ 应用程序：open()、read()、write()、close()等系统调用API​ ||​ 设备文件： 设备文件作为二者之间的桥梁​ ||​ 内核： 系统调用进入内核​ ||​ 驱动程序： 驱动程序中的open()close()read()release()等​ ||
Linux设备驱动入门(一)
david0919的专栏
11-05 355
用来防止用户程序直接访问内核中关键性数据结构和硬件设备是驱动程序的主要目的之一，所以，一个设计精良的驱动通常应该隐藏了硬件的复杂性和多变性。例如，一个程序写数据到磁盘时，只需要打开一个文件并执行写命令即可，而不必了解磁盘中的每个扇区的大小是512字节或者是1024字节，细节性的问题则交由驱动程序处理。此外，驱动程序还可以隐藏硬件的多变性(可能来自于不同厂家，甚至同一厂家不同型号)并给用户提供一个统一的访问接口。这也是Unix/Linux信条之一“一切皆文件”的赖以存在的基础。 1、可加载模块(loadabl
linux设备驱动程序：简单字符设备驱动
m0_74282605的博客
07-01 876
分为3类：字符设备、块设备、网络设备。使用驱动程序：1、：是指只能一个字节一个字节读写的设备，不能随机读取设备内存中的某一数据，读取数据需要按照先后数据。字符设备是面向流的设备，常见的字符设备有鼠标、键盘、串口、控制台和LED设备等。2、：是指可以从设备的任意位置读取一定长度数据的设备。块设备包括硬盘、磁盘、U盘和SD卡等。每一个字符设备或块设备都在/dev目录下对应一个设备文件。linux用户程序通过设备文件（或称设备节点）来使用驱动程序操作字符设备和块设备。
Linux 字符设备驱动
haigand的专栏
04-29 338
https://www.cnblogs.com/cainiaoaixuexi/p/3684641.html http://www.cnblogs.com/qlee/archive/2011/07/27/2118406.html
Linux驱动——字符设备驱动
Linux驱动开发工程师，熟悉Linux/Android底层驱动、TP、显示、IIC、网络等通用外设调试适配，Linux上层应用开发，熟悉瑞芯微、全志、恩智浦等平台。
04-08 2843
1.使用什么工具来写驱动代码：安装source insight工具（1）找到软件提示把工具安装激活（2）把Linux内核代码解压到windows目录中（3）打开工具添加查看的项目第一个对话框：第一个文本框：输入工程名字第二个文本框：路径(默认)第二个对话框： 在项目源码位置，选择 Linux内核代码位置 点击OK 第三个对话框： 选择需要查看的Linux内核代码的包含的源码文件（要查看的内核目录）需要添加的目录：driver/iicinclude。
Linux-字符设备驱动
m0_47033179的博客
08-07 1760
该文章参考了很多资料和博主，以及自己的一些体会，放在这里仅供参考学习，大家共同进步若出现侵权，请告知博主本人，本人会立即删除相应的文章和代码，读写是分先后顺序的。
linux 设备驱动（一）——字符设备驱动
qq_27094347的博客
11-15 4858
linux 设备驱动一、概述1.1 设备驱动介绍二、字符设备驱动2.1. 字符设备驱动简介2.2. LCD驱动 一、概述 1.1 设备驱动介绍 二、字符设备驱动 2.1. 字符设备驱动简介 2.2. LCD驱动 感谢阅读，祝君成功！ -by aiziyou ...
Linux字符设备驱动
ljl113的博客
10-02 1043
具体就是：内核虽然可以访问用户空间的缓冲区，但在访问之前会检查其合法性，通过。file_operations 结构体中的成员函数是字符设备驱动程序设计的主体内容，这些函数实际会被应用程序调用Linux系统调用如open()/read()/write()/close()等时，最终被内核调用。调用register_chrdev()不能指定次设备号，那么函数内部会在内核中连续注册256个次设备号，也就是所有的次设备号都会被占用，而在大多数情况下都不会用到这么多次设备号，所以会造成极大的资源浪费。
专题资料（2021-2022年）Linux设备驱动程序设计入门.doc
07-19
【Linux设备驱动程序设计入门】 Linux设备驱动程序是操作系统与硬件设备之间的桥梁，它们负责管理和控制硬件设备，使之能够按照操作系统的要求工作。在Linux系统中，设备驱动属于内核的一部分，因此编写驱动需要对...
Linux驱动入门（一）字符设备驱动基础
JT同学的博客
08-20 5853
Linux驱动入门（一）字符设备驱动基础 Linux驱动入门系列 Linux驱动入门（一）字符设备驱动基础 Linux驱动入门（二）Led驱动 Linux驱动入门（三）轮询实现按键驱动 Linux驱动入门（四）中断实现按键驱动 Linux驱动入门（五）poll机制实现按键驱动 Linux驱动入门（六）使用定时器防按键抖动 文章目录Linux驱动入门（一）字符设备驱动基础一、驱动简介二、字符设备驱动...
Linux驱动开发入门：字符设备、块设备与网络接口
本文将深入探讨Linux驱动程序的作用、设备类型、编程注意事项以及构建和运行驱动模块的基本步骤。 Linux驱动程序的主要职责是为硬件设备提供一个抽象的接口，使得应用程序可以通过标准的系统调用来与硬件交互，而...
linux字符设备驱动
cqxcool66的博客
04-26 1315
MAJOR(dev_t dev) //从设备号中获取主设备号 MINOR(dev_t dev) //从设备号中获取次设备号 MKDEV(int major, int minor) //用主设备号和次设备号生成设备号 旧版字符设备注册： 实际上对申请设备号、申请设备内存、初始化cdev、系统注册步骤的集合。 #include <linux/fs.h> register_chrdev(unsigned int major, const char *name,const struct.
linux设备驱动之字符设备驱动
markzhy的博客
05-24 313
结构中的成员指向驱动中的函数,这些函数实现一个特别的操作, 对于不支持的操作保留为NULL。这个结构体是字符设备当中最重要的结构体之一，file_operations 结构体中的成员函数指针是字符设备驱动程序设计的主体内容，这些函数实际上在应用程序进行Linux 的 open()、read()、write()、close()、seek()、ioctl()等系统调用时最终被调用。在字符设备驱动模块加载函数中应该实现设备号的申请和cdev 结构的注册，而在卸载函数中应该实现设备号的释放与cdev结构的注销。
Linux设备驱动-字符驱动
zwg的博客
07-16 558
应用程序的主要作用与实现方法 三个作用：与内存进行IO交互（比如读写文件）；输出信息到外设（如点灯）；从外设读入信息（如识别键盘按键）。应用程序一般提供三个标准的接口函数来实现这三个功能：open、write、read，这三个接口函数的具体实现在标准C语言库中。C语言库和应用程序都属于用户空间的东西。 open负责打开一个文件，write负责往打开的文件里写入信息，read负责从打开的文件里读取信息。（注意：Linux中一切皆是文件，内存和外设也是，所以这个打开的文件可以是内存也可以是具体的外设，比如我op
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值