一、Linux 设备驱动介绍及开发环境搭建

Linux 设备驱动介绍及开发环境搭建的完整攻略

一、Linux 设备驱动介绍

Linux 设备驱动是 Linux 操作系统中的一个重要组成部分，它负责管理硬件设备和操作系统之间的通信。Linux 设备驱动通常由内核模块和用户空间应用程序组成，内核模块负责与硬件设备进行通信，用户空间应用程序则负责与用户进行交互。

Linux 设备驱动的开发需要掌握 C 语言和 Linux 操作系统的基本知识，同时需要了解硬件设备的工作原理和通信协议。

二、开发环境搭建

1. 安装 Linux 操作系统

首先需要安装 Linux 操作系统，可以选择 Ubuntu、CentOS 等常见的 Linux 发行版。安装完成后，需要更新系统并安装必要的开发工具，如 gcc、make 等。

2. 安装 Linux 内核源码

Linux 设备驱动的开发需要使用 Linux 内核源码，可以从官网下载最新版本的内核源码并解压缩到本地。

3. 编写设备驱动程序

编写设备驱动程序需要使用 C 语言和 Linux 内核 API，可以使用任何文本编辑器编写代码。编写完成后，需要使用 make 命令编译代码并生成内核模块。

4. 加载内核模块

加载内核模块需要使用 insmod 命令，可以将内核模块加载到内核中并启动设备驱动程序。加载完成后，可以使用 dmesg 命令查看设备驱动程序的输出信息。

5. 卸载内核模块

卸载内核模块需要使用 rmmod 命令，可以将内核模块从内核中卸载并停止设备驱动程序的运行。

三、示例说明

1. 编写简单的字符设备驱动程序

下面是一个简单的字符设备驱动程序的示例：

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>

MODULE_LICENSE("Dual BSD/GPL");

static int major = 0;
static int minor = 0;
static dev_t devno;
static struct cdev cdev;

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

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

static ssize_t my_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
{
    printk(KERN_INFO "my_read\n");
    return 0;
}

static ssize_t my_write(struct file *file, const char __user *buf, size_t count, loff_t *offset)
{
    printk(KERN_INFO "my_write\n");
    return count;
}

static struct file_operations my_fops = {
    .owner = THIS_MODULE,
    .open = my_open,
    .release = my_release,
    .read = my_read,
    .write = my_write,
};

static int __init my_init(void)
{
    int ret;

    ret = alloc_chrdev_region(&devno, minor, 1, "my_dev");
    if (ret < 0) {
        printk(KERN_ERR "alloc_chrdev_region failed\n");
        return ret;
    }

    major = MAJOR(devno);
    cdev_init(&cdev, &my_fops);
    cdev_add(&cdev, devno, 1);

    printk(KERN_INFO "my_init\n");
    return 0;
}

static void __exit my_exit(void)
{
    cdev_del(&cdev);
    unregister_chrdev_region(devno, 1);

    printk(KERN_INFO "my_exit\n");
}

module_init(my_init);
module_exit(my_exit);

在上述示例中，我们定义了一个字符设备驱动程序，包括设备的打开、关闭、读取和写入操作。在初始化函数中，我们使用 alloc_chrdev_region 函数分配设备号，并使用 cdev_init 和 cdev_add 函数注册设备驱动程序。在退出函数中，我们使用 cdev_del 和 unregister_chrdev_region 函数注销设备驱动程序。

2. 编写简单的块设备驱动程序

下面是一个简单的块设备驱动程序的示例：

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/blkdev.h>

MODULE_LICENSE("Dual BSD/GPL");

#define MY_BLKDEV_NAME "my_blkdev"
#define MY_BLKDEV_SIZE (1024 * 1024)
#define MY_BLKDEV_SECTOR_SIZE 512

static int major = 0;
static int minor = 0;
static dev_t devno;
static struct cdev cdev;
static struct request_queue *queue;
static struct gendisk *disk;

static int my_open(struct block_device *bdev, fmode_t mode)
{
    printk(KERN_INFO "my_open\n");
    return 0;
}

static void my_release(struct gendisk *disk, fmode_t mode)
{
    printk(KERN_INFO "my_release\n");
}

static int my_getgeo(struct block_device *bdev, struct hd_geometry *geo)
{
    printk(KERN_INFO "my_getgeo\n");
    return 0;
}

static struct block_device_operations my_blkdev_ops = {
    .owner = THIS_MODULE,
    .open = my_open,
    .release = my_release,
    .getgeo = my_getgeo,
};

static void my_request(struct request_queue *q)
{
    struct request *req;

    while ((req = blk_fetch_request(q)) != NULL) {
        if (req->cmd_type != REQ_TYPE_FS) {
            printk(KERN_ERR "my_request: req->cmd_type != REQ_TYPE_FS\n");
            __blk_end_request_all(req, -EIO);
            continue;
        }

        if (blk_rq_pos(req) + blk_rq_cur_sectors(req) > MY_BLKDEV_SIZE / MY_BLKDEV_SECTOR_SIZE) {
            printk(KERN_ERR "my_request: blk_rq_pos(req) + blk_rq_cur_sectors(req) > MY_BLKDEV_SIZE / MY_BLKDEV_SECTOR_SIZE\n");
            __blk_end_request_all(req, -EIO);
            continue;
        }

        switch (rq_data_dir(req)) {
        case READ:
            printk(KERN_INFO "my_request: READ\n");
            break;
        case WRITE:
            printk(KERN_INFO "my_request: WRITE\n");
            break;
        default:
            printk(KERN_ERR "my_request: rq_data_dir(req) error\n");
            __blk_end_request_all(req, -EIO);
            continue;
        }

        __blk_end_request_all(req, 0);
    }
}

static int __init my_init(void)
{
    int ret;

    ret = alloc_chrdev_region(&devno, minor, 1, MY_BLKDEV_NAME);
    if (ret < 0) {
        printk(KERN_ERR "alloc_chrdev_region failed\n");
        return ret;
    }

    major = MAJOR(devno);
    cdev_init(&cdev, NULL);
    cdev_add(&cdev, devno, 1);

    queue = blk_init_queue(my_request, NULL);
    if (queue == NULL) {
        printk(KERN_ERR "blk_init_queue failed\n");
        goto err_blk_init_queue;
    }

    blk_queue_logical_block_size(queue, MY_BLKDEV_SECTOR_SIZE);

    disk = alloc_disk(1);
    if (disk == NULL) {
        printk(KERN_ERR "alloc_disk failed\n");
        goto err_alloc_disk;
    }

    disk->major = major;
    disk->first_minor = minor;
    disk->fops = &my_blkdev_ops;
    disk->queue = queue;
    sprintf(disk->disk_name, MY_BLKDEV_NAME);
    set_capacity(disk, MY_BLKDEV_SIZE / MY_BLKDEV_SECTOR_SIZE);
    add_disk(disk);

    printk(KERN_INFO "my_init\n");
    return 0;

err_alloc_disk:
    blk_cleanup_queue(queue);
err_blk_init_queue:
    cdev_del(&cdev);
    unregister_chrdev_region(devno, 1);
    return -ENOMEM;
}

static void __exit my_exit(void)
{
    del_gendisk(disk);
    put_disk(disk);
    blk_cleanup_queue(queue);
    cdev_del(&cdev);
    unregister_chrdev_region(devno, 1);

    printk(KERN_INFO "my_exit\n");
}

module_init(my_init);
module_exit(my_exit);

在上述示例中，我们定义了一个块设备驱动程序，包括设备的打开、关闭、读取和写入操作。在初始化函数中，我们使用 alloc_chrdev_region 函数分配设备号，并使用 cdev_init 和 cdev_add 函数注册设备驱动程序。我们还使用 blk_init_queue 函数初始化请求队列，并使用 alloc_disk 函数分配磁盘结构体。在退出函数中，我们使用 del_gendisk、put_disk 和 blk_cleanup_queue 函数注销设备驱动程序。