Linux内核中的设备驱动详解引言设备驱动是Linux内核中的重要组成部分它负责管理硬件设备与内核之间的通信。设备驱动为应用程序提供了访问硬件设备的接口使得应用程序可以无需了解硬件的具体实现细节。本文将深入探讨Linux内核中的设备驱动机制包括其原理、实现和应用。设备驱动的基本概念1. 设备驱动的定义设备驱动是一种软件它负责管理硬件设备与操作系统之间的通信。2. 设备驱动的类型字符设备按字节流访问的设备如串口、终端等块设备按块访问的设备如硬盘、U盘等网络设备网络通信设备如网卡等杂项设备无法归类的设备3. 设备驱动的架构应用层 ↓ 系统调用层 ↓ 设备驱动层 ↓ 硬件层设备驱动的实现1. 字符设备驱动#include linux/cdev.h #include linux/fs.h static dev_t dev_num; static struct cdev my_cdev; // 打开设备 static int my_open(struct inode *inode, struct file *file) { // 实现打开操作 return 0; } // 读取设备 static ssize_t my_read(struct file *file, char __user *buf, size_t count, loff_t *pos) { // 实现读取操作 return count; } // 写入设备 static ssize_t my_write(struct file *file, const char __user *buf, size_t count, loff_t *pos) { // 实现写入操作 return count; } // 释放设备 static int my_release(struct inode *inode, struct file *file) { // 实现释放操作 return 0; } // 文件操作结构 static struct file_operations my_fops { .owner THIS_MODULE, .open my_open, .read my_read, .write my_write, .release my_release, }; // 模块初始化 static int __init my_init(void) { // 分配设备号 alloc_chrdev_region(dev_num, 0, 1, my_device); // 初始化字符设备 cdev_init(my_cdev, my_fops); my_cdev.owner THIS_MODULE; // 添加字符设备 cdev_add(my_cdev, dev_num, 1); return 0; } // 模块退出 static void __exit my_exit(void) { // 移除字符设备 cdev_del(my_cdev); // 释放设备号 unregister_chrdev_region(dev_num, 1); } module_init(my_init); module_exit(my_exit); MODULE_LICENSE(GPL); MODULE_AUTHOR(Your Name); MODULE_DESCRIPTION(A simple character device driver);2. 块设备驱动#include linux/genhd.h #include linux/blkdev.h static int major_num; static struct gendisk *my_disk; static struct request_queue *my_queue; // 处理请求 static void my_request(struct request_queue *q) { struct request *req; req blk_fetch_request(q); while (req ! NULL) { // 处理请求 blk_end_request_all(req, 0); req blk_fetch_request(q); } } // 模块初始化 static int __init my_init(void) { // 分配主设备号 major_num register_blkdev(0, my_block); // 分配磁盘结构 my_disk alloc_disk(1); my_disk-major major_num; my_disk-first_minor 0; sprintf(my_disk-disk_name, myblock); my_disk-fops my_fops; // 创建请求队列 my_queue blk_init_queue(my_request, NULL); my_disk-queue my_queue; // 添加磁盘 add_disk(my_disk); return 0; } // 模块退出 static void __exit my_exit(void) { // 移除磁盘 del_gendisk(my_disk); put_disk(my_disk); // 释放请求队列 blk_cleanup_queue(my_queue); // 释放主设备号 unregister_blkdev(major_num, my_block); } module_init(my_init); module_exit(my_exit); MODULE_LICENSE(GPL); MODULE_AUTHOR(Your Name); MODULE_DESCRIPTION(A simple block device driver);3. 网络设备驱动#include linux/netdevice.h static struct net_device *my_netdev; // 打开网络设备 static int my_netdev_open(struct net_device *dev) { // 启用设备 netif_start_queue(dev); return 0; } // 关闭网络设备 static int my_netdev_stop(struct net_device *dev) { // 禁用设备 netif_stop_queue(dev); return 0; } // 发送网络数据包 static netdev_tx_t my_netdev_start_xmit(struct sk_buff *skb, struct net_device *dev) { // 发送数据包 dev_kfree_skb(skb); return NETDEV_TX_OK; } // 网络设备操作 static struct net_device_ops my_netdev_ops { .ndo_open my_netdev_open, .ndo_stop my_netdev_stop, .ndo_start_xmit my_netdev_start_xmit, }; // 模块初始化 static int __init my_init(void) { // 分配网络设备 my_netdev alloc_netdev(0, myeth%d, NET_NAME_UNKNOWN, ether_setup); // 设置设备操作 my_netdev-netdev_ops my_netdev_ops; // 注册网络设备 register_netdev(my_netdev); return 0; } // 模块退出 static void __exit my_exit(void) { // 注销网络设备 unregister_netdev(my_netdev); free_netdev(my_netdev); } module_init(my_init); module_exit(my_exit); MODULE_LICENSE(GPL); MODULE_AUTHOR(Your Name); MODULE_DESCRIPTION(A simple network device driver);设备驱动的注册与管理1. 设备号管理# 查看设备号 cat /proc/devices # 创建设备节点 mknod /dev/my_device c major minor # 查看设备节点 ls -l /dev/my_device2. 模块管理# 加载模块 insmod my_driver.ko # 查看模块 lsmod | grep my_driver # 查看模块信息 modinfo my_driver.ko # 卸载模块 rmmod my_driver3. 设备驱动的调试# 查看内核日志 dmesg | tail # 启用调试信息 echo 8 /proc/sys/kernel/printk # 使用ftrace trace-cmd record -e function_graph modprobe my_driver trace-cmd report设备驱动的高级特性1. 设备树// 设备树节点 /* my_device { compatible my,device; reg 0x10000000 0x1000; interrupts 10; }; */ // 设备树匹配 static const struct of_device_id my_of_match[] { { .compatible my,device, }, { }, }; MODULE_DEVICE_TABLE(of, my_of_match); // 平台驱动 static struct platform_driver my_driver { .probe my_probe, .remove my_remove, .driver { .name my_device, .of_match_table my_of_match, }, };2. 电源管理// 电源管理操作 static int my_suspend(struct device *dev) { // 实现挂起操作 return 0; } static int my_resume(struct device *dev) { // 实现恢复操作 return 0; } static const struct dev_pm_ops my_pm_ops { .suspend my_suspend, .resume my_resume, }; // 设置电源管理操作 static struct platform_driver my_driver { // 其他字段... .driver { // 其他字段... .pm my_pm_ops, }, };3. 异步通知// 异步通知 static struct fasync_struct *my_fasync; // 实现fasync操作 static int my_fasync(int fd, struct file *file, int on) { return fasync_helper(fd, file, on, my_fasync); } // 发送信号 static void send_signal(void) { kill_fasync(my_fasync, SIGIO, POLL_IN); } // 文件操作结构 static struct file_operations my_fops { // 其他操作... .fasync my_fasync, };设备驱动的性能优化1. 中断处理// 中断处理 static irqreturn_t my_irq_handler(int irq, void *dev_id) { // 快速处理 schedule_work(my_work); return IRQ_HANDLED; } // 工作队列 static struct work_struct my_work; static void my_work_handler(struct work_struct *work) { // 耗时处理 } // 初始化工作队列 INIT_WORK(my_work, my_work_handler); // 注册中断 request_irq(irq, my_irq_handler, IRQF_SHARED, my_device, dev_id);2. DMA传输// DMA缓冲区分配 static void *dma_buf; static dma_addr_t dma_addr; dma_buf dma_alloc_coherent(dev, size, dma_addr, GFP_KERNEL); // DMA传输 dmaengine_submit(tx); dma_async_issue_pending(chan); // 等待传输完成 dma_sync_single_for_cpu(dev, dma_addr, size, DMA_FROM_DEVICE); // 释放DMA缓冲区 dma_free_coherent(dev, size, dma_buf, dma_addr);3. 内存映射// 内存映射 static int my_mmap(struct file *file, struct vm_area_struct *vma) { vma-vm_flags | VM_IO; vma-vm_flags | VM_DONTEXPAND; vma-vm_flags | VM_DONTDUMP; if (io_remap_pfn_range(vma, vma-vm_start, pfn, vma-vm_end - vma-vm_start, vma-vm_page_prot)) { return -EAGAIN; } return 0; } // 文件操作结构 static struct file_operations my_fops { // 其他操作... .mmap my_mmap, };实际案例分析1. 字符设备驱动#include linux/module.h #include linux/fs.h #include linux/cdev.h #include linux/uaccess.h static dev_t dev_num; static struct cdev my_cdev; static char buffer[256]; static int my_open(struct inode *inode, struct file *file) { printk(KERN_INFO Device opened\n); return 0; } static ssize_t my_read(struct file *file, char __user *buf, size_t count, loff_t *pos) { if (*pos sizeof(buffer)) return 0; if (*pos count sizeof(buffer)) count sizeof(buffer) - *pos; if (copy_to_user(buf, buffer *pos, count)) return -EFAULT; *pos count; return count; } static ssize_t my_write(struct file *file, const char __user *buf, size_t count, loff_t *pos) { if (*pos sizeof(buffer)) return 0; if (*pos count sizeof(buffer)) count sizeof(buffer) - *pos; if (copy_from_user(buffer *pos, buf, count)) return -EFAULT; *pos count; return count; } static int my_release(struct inode *inode, struct file *file) { printk(KERN_INFO Device closed\n); return 0; } static struct file_operations my_fops { .owner THIS_MODULE, .open my_open, .read my_read, .write my_write, .release my_release, }; static int __init my_init(void) { if (alloc_chrdev_region(dev_num, 0, 1, my_device) 0) { printk(KERN_ERR Failed to allocate device number\n); return -1; } cdev_init(my_cdev, my_fops); my_cdev.owner THIS_MODULE; if (cdev_add(my_cdev, dev_num, 1) 0) { printk(KERN_ERR Failed to add device\n); unregister_chrdev_region(dev_num, 1); return -1; } printk(KERN_INFO Device driver loaded\n); return 0; } static void __exit my_exit(void) { cdev_del(my_cdev); unregister_chrdev_region(dev_num, 1); printk(KERN_INFO Device driver unloaded\n); } module_init(my_init); module_exit(my_exit); MODULE_LICENSE(GPL); MODULE_AUTHOR(Your Name); MODULE_DESCRIPTION(A simple character device driver);2. 网络设备驱动#include linux/module.h #include linux/netdevice.h #include linux/etherdevice.h static struct net_device *my_netdev; static int my_netdev_open(struct net_device *dev) { netif_start_queue(dev); printk(KERN_INFO Network device opened\n); return 0; } static int my_netdev_stop(struct net_device *dev) { netif_stop_queue(dev); printk(KERN_INFO Network device stopped\n); return 0; } static netdev_tx_t my_netdev_start_xmit(struct sk_buff *skb, struct net_device *dev) { dev-stats.tx_packets; dev-stats.tx_bytes skb-len; dev_kfree_skb(skb); return NETDEV_TX_OK; } static struct net_device_ops my_netdev_ops { .ndo_open my_netdev_open, .ndo_stop my_netdev_stop, .ndo_start_xmit my_netdev_start_xmit, }; static void my_netdev_setup(struct net_device *dev) { ether_setup(dev); dev-netdev_ops my_netdev_ops; eth_hw_addr_random(dev); dev-mtu 1500; dev-flags | IFF_NOARP; } static int __init my_init(void) { my_netdev alloc_netdev(0, myeth%d, NET_NAME_UNKNOWN, my_netdev_setup); if (!my_netdev) { printk(KERN_ERR Failed to allocate network device\n); return -ENOMEM; } if (register_netdev(my_netdev) 0) { printk(KERN_ERR Failed to register network device\n); free_netdev(my_netdev); return -1; } printk(KERN_INFO Network device driver loaded\n); return 0; } static void __exit my_exit(void) { unregister_netdev(my_netdev); free_netdev(my_netdev); printk(KERN_INFO Network device driver unloaded\n); } module_init(my_init); module_exit(my_exit); MODULE_LICENSE(GPL); MODULE_AUTHOR(Your Name); MODULE_DESCRIPTION(A simple network device driver);3. 设备驱动调试#!/bin/bash # 编译驱动 make # 加载驱动 insmod my_driver.ko # 创建设备节点 mknod /dev/my_device c $(grep my_device /proc/devices | awk {print $1}) 0 # 测试设备 echo Hello, World! /dev/my_device cat /dev/my_device # 查看内核日志 dmesg | tail # 卸载驱动 rmmod my_driver结论设备驱动是Linux内核中的重要组成部分它负责管理硬件设备与内核之间的通信。设备驱动为应用程序提供了访问硬件设备的接口使得应用程序可以无需了解硬件的具体实现细节。理解设备驱动的原理和实现对于系统编程、硬件开发和故障处理都有重要意义。随着硬件技术的不断发展设备驱动的复杂性也在不断增加成为现代操作系统设计的关键部分。