Linux 驱动入门（1）—— hello驱动

企业开发 2024-11-01 21:55:58 阅读次数: 0

目录

前言

一、编译替换内核和设备树

二、驱动入门知识

三、编写最简单的 Hello 驱动

1. 整体框架流程图

2. 编写第一个Hello程序

3. 编写第二个Hello程序（改进第一个）

4. 编写第三个Hello程序（改进第二个）

前言

在这里主要记录学习韦东山老师Linux驱动课程的笔记，韦东山老师的驱动课程讲的非常好，想要学习驱动的小伙伴可以去b站学习他的课程。

一、编译替换内核和设备树

在编译驱动程序之前要先编译内核，原因有三点：

  • 驱动程序要用到内核文件
  • 编译驱动时用的内核、开发板上运行到内核，要一致
  • 更换板子上的内核后，板子上的其他驱动也要更换

编译内核步骤看我之前写过的文章，编译替换内核_设备树_驱动_IMX6ULL-CSDN博客

二、驱动入门知识

1.首先我们通常都是在Linux的终端上打开一个可执行文件，然后可执行文件就会执行程序。那么这个可执行文件做了什么呢？

2.可执行文件先是在应用层读取程序，其中会有很多库函数，库函数是属于内核之中。而内核又会往下调用驱动层程序。最终驱动层控制具体硬件。

  • 其实应用程序到库是比较容易理解的，比如我们刚学习C语言的时候，使用了printf，scanf等等这些函数。而这些函数就在库中。
  • 库可以和系统内核相连接，具体怎么实现的我也不太清楚。
  • 我们写了一个驱动程序，就需要告诉内核，这个过程叫做注册。我们注册了驱动之后，内核里面就会有这个驱动程序的信息，然后上层应用就可以调用。

3.所以我们只需要知道，咱们需要编写两个程序，一个是驱动层的，一个是应用层的，最后驱动层需要注册进入内核，应用层才能够使用。其他的先不要管。

4.我们在应用层调用read函数，对应驱动层的read函数。write函数和write函数对应。open函数和open函数对应。close函数和release函数对应（这个为什么不一样我们也不用管）。

5.我们对 Linux 应用程序对驱动程序的调用流程有一个简单了解之后，我得知道整个程序编写流程应该怎么做。至于流程为什么是这样的，我们记住即可。因为这些都是人规定的，如果之后学的深了再进行深究也不迟，现在我们主要是入门。

三、编写最简单的 Hello 驱动

1. 整体框架流程图

​

编写驱动主要为以下七个步骤：

  1. 确定主设备号，也可以让内核分配
  2. 定义自己的 file_operations 结构体
  3. 实现对应的 drv_open/drv_read/drv_write 等函数，填入 file operations 结构体
  4. 把 file_operations 结构体告诉内核: register_chrdev
  5. 谁来注册驱动程序啊? 得有一个入口函数:安装驱动程序时，就会去调用这个入口函数
  6. 有入口函数就应该有出口函数: 卸载驱动程序时，出口函数调用unregister_chrdev
  7. 其他完善:提供设备信息，自动创建设备节点: class_create,device_create

我们可以进入内核驱动目录查看别人如何写：

cd ~/100ask_imx6ull-sdk/Linux-4.9.88/drivers/char/
grep "register_chrdev" -nwr
  • -n 选项表示输出匹配行的行号。
  • -w 选项表示只匹配整个单词，而不是字符串的一部分。
  • -r 选项表示递归搜索子目录。

2. 编写第一个Hello程序

第一个Hello程序实现：实现调用流程

01_hello_drv目录下创建三个文件，分别是hello_drv.c，hello_test.c，Makefile

hello_drv.c：

#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);
   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");

  1. module_init(hello_init);：这行代码声明了一个名为hello_init的函数，该函数在模块被加载时会被调用。这个函数通常用于初始化模块所需的资源，如分配内存、注册设备等。

  2. module_exit(hello_exit);：这行代码声明了一个名为hello_exit的函数，该函数在模块被卸载时会被调用。这个函数通常用于释放模块所占用的资源，如释放内存、注销设备等。

  3. MODULE_LICENSE("GPL");：这行代码指定了模块的许可证为GNU通用公共许可证（GPL）。这意味着其他人可以自由地使用、修改和分发这个模块，但必须遵循GPL许可协议的规定。

  4. register_chrdev第一个参数默认为0时，系统自动分配设备号。

hello_test.c：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

/* 写: ./hello_test /dev/xxx zgl666
 * 读: ./hello_test /dev/xxx
 */
int main(int argc, char **argv)
{
    int fd;
    int len;
    char buf[100];

    if (argc < 2)
    {
        printf("Usage: \n");
        printf("%s <dev> [string]\n", argv[0]);
        return -1;
    }

    // open
    fd = open(argv[1], O_RDWR);
    if (fd < 0)
    {
        printf("can not open file %s\n", argv[1]);
        return -1;
    }

    if (argc == 3)
    {
        // write
        len = write(fd, argv[2], strlen(argv[2])+1);
        printf("write ret = %d\n", len);
    }
    else
    {
        // read
        len = read(fd, buf, 100);
        buf[99] = '\0';
        printf("read str : %s\n", buf);
    }

    // close
    close(fd);
    return 0;
}
  • <表示不可以省略> 
  • [ 表示可以省略（读或写）]

Makefile：


# 1. 使用不同的开发板内核时, 一定要修改KERN_DIR
# 2. KERN_DIR中的内核要事先配置、编译, 为了能编译内核, 要先设置下列环境变量:
# 2.1 ARCH,          比如: export ARCH=arm64
# 2.2 CROSS_COMPILE, 比如: export CROSS_COMPILE=aarch64-linux-gnu-
# 2.3 PATH,          比如: export PATH=$PATH:/home/book/100ask_roc-rk3399-pc/ToolChain-6.3.1/gcc-linaro-6.3.1-2017.05-x86_64_aarch64-linux-gnu/bin 
# 注意: 不同的开发板不同的编译器上述3个环境变量不一定相同,
#       请参考各开发板的高级用户使用手册

KERN_DIR = /home/book/100ask_imx6ull-sdk/Linux-4.9.88

all:
	make -C $(KERN_DIR) M=`pwd` modules 
	$(CROSS_COMPILE)gcc -o hello_test hello_test.c 

clean:
	make -C $(KERN_DIR) M=`pwd` modules clean
	rm -rf modules.order
	rm -f hello_test

obj-m	+= hello_drv.o

在Ubuntu输入以下命令：可以生成代码链接文件，方便用vscode查阅代码

bear make

批量修改：将"cc"改为"arm-buildroot-linux-gnueabihf-gcc"

​

​

开发板操作：

insmod hello_drv.ko
cat /proc/devices
mknod  /dev/zgl c 240 0
./hello_test /dev/zgl  zgl666
./hello_test /dev/zgl
rmmod hello_drv
  • insmod hello_drv.ko用于将名为hello_drv.ko的内核模块插入到运行中的内核中。
  • cat /proc/devices 查看设备号
  • mknod /dev/zgl c 240 0用于创建一个名为/dev/zgl的字符设备文件。其中，c表示字符设备类型，240是主设备号，0是次设备号。
  • rmmod hello_drv用于从内核中卸载一个动态加载的内核模块。

    在使用Linux系统时，内核模块是可加载和卸载的，这使得系统可以根据需要动态地增加或减少功能。rmmod命令就是用来卸载已经不再需要的内核模块，以释放其占用的资源。

    在这个例子中，hello_drv是要被卸载的内核模块的名称。执行rmmod hello_drv命令后，模块hello_drv将被从内核中移除，如果操作成功，不会有任何输出信息。

    需要注意的是，rmmod命令只能卸载未被使用的模块。如果一个模块当前正在被使用（例如有进程打开了该模块提供的设备文件），则无法通过rmmod命令卸载。可以使用lsmod命令查看当前已加载的模块以及它们的使用情况。

    另外，如果想要在卸载模块时同时删除与其相关的文件，可以使用rmmod -r命令。这通常用于模块的调试和开发过程中。

​

​

3. 编写第二个Hello程序（改进第一个）

第二个Hello程序实现：相比于第一个，第二个可以进行收发数据，自动创建设备，结束时销毁。

目录改成：02_hello_drv_transfer_data

hello_drv.c：

#include "asm/cacheflush.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 int major;
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)
{
    major = register_chrdev(0, "100ask_hello", &hello_drv);

	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, MKDEV(major, 0), NULL, "zgl");  /* /dev/zgl */

   return 0;
}


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

    class_destroy(hello_class);

    unregister_chrdev(major, "100ask_hello");
}


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

hello_test.c：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

/* 写: ./hello_test /dev/xxx 100ask
 * 读: ./hello_test /dev/xxx
 */
int main(int argc, char **argv)
{
    int fd;
    int len;
    char buf[100];

    if (argc < 2)
    {
        printf("Usage: \n");
        printf("%s <dev> [string]\n", argv[0]);
        return -1;
    }

    // open
    fd = open(argv[1], O_RDWR);
    if (fd < 0)
    {
        printf("can not open file %s\n", argv[1]);
        return -1;
    }

    if (argc == 3)
    {
        // write
        len = write(fd, argv[2], strlen(argv[2])+1);
        printf("write ret = %d\n", len);
    }
    else
    {
        // read
        len = read(fd, buf, 100);
        buf[99] = '\0';
        printf("read str : %s\n", buf);
    }

    // close
    close(fd);
    return 0;
}

上电开发板，可以看到自动创建设备/dev/zgl，不需要我们手动创建：

​

4. 编写第三个Hello程序（改进第二个）

第三个Hello程序实现：相比于第二个，第三个可以用于动态分配一组字符设备号，自行规定分配的设备号的数量，了解一下即可，常用的还是第二种。

目录改成：03_hello_drv_cdev

hello_drv.c：

#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, "zgl");  /* /dev/zgl */
 
    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");

alloc_chrdev_region(&dev, 0, 2, "hello")是Linux内核编程中的一个函数调用，用于动态分配一组字符设备号。

参数解释：

  • &dev：这是一个指向unsigned int类型的指针，用于存储分配的设备号范围的起始值。
  • 0：这是要分配的第一个设备号。
  • 2：这是要分配的设备号的数量。在这个例子中，它将分配从0到1的两个设备号。
  • "hello"：这是设备的名称，通常用于在/proc/devices文件中标识设备。

hello_test.c：

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

/* 写: ./hello_test /dev/xxx 100ask
 * 读: ./hello_test /dev/xxx
 */
int main(int argc, char **argv)
{
    int fd;
    int len;
    char buf[100];

    if (argc < 2)
    {
        printf("Usage: \n");
        printf("%s <dev> [string]\n", argv[0]);
        return -1;
    }

    // open
    fd = open(argv[1], O_RDWR);
    if (fd < 0)
    {
        printf("can not open file %s\n", argv[1]);
        return -1;
    }

    if (argc == 3)
    {
        // write
        len = write(fd, argv[2], strlen(argv[2])+1);
        printf("write ret = %d\n", len);
    }
    else
    {
        // read
        len = read(fd, buf, 100);
        buf[99] = '\0';
        printf("read str : %s\n", buf);
    }

    // close
    close(fd);
    return 0;
}

猜你喜欢

转载自blog.csdn.net/m0_74712453/article/details/140208323
今日推荐
周排行
5、常用控件01 TextView与EditText ，事件监听
【aardio】回车换行符
CSS 功能简介
dubbo-admin 下载and安装
移动端手机调试的方法
Luogu P3150 pb的游戏
机器学习经典书籍
数据结构 - 栈（数组模拟栈操作）
Qt如何将消息在2个没有关系的类中从一个类发送到另一个类中
C++ 标准库类型之vector类型
每日归档
更多
2025-01-05(0)
2025-01-04(0)
2025-01-03(0)
2025-01-02(0)
2025-01-01(0)
2024-12-31(0)
2024-12-30(0)
2024-12-29(0)
2024-12-28(0)
2024-12-27(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022