第8讲 Linux字符设备驱动程序举例

Linux设备驱动程序接口

§1. Linux驱动程序接口系统调用是操作系统内核与应用程序之间的接口，设备驱动程序则是操作系统内核与机器硬件的接口。

几乎所有的系统操作最终映射到物理设备，除了CPU、内存和少数其它设备，所有的设备控制操作都由该设备特殊的可执行代码实现，此代码就是设备驱动程序。

操作系统内核需要访问两类主要设备:字符设备和块设备。

与此相关主要有两类设备驱动程序，字符设备驱动程序和块设备驱动程序。

Linux（也是所有UNIX）的基本原理之一是：系统试图使它对所有各类设备的输入、输出看起来就好象对普通文件的输入、输出一样。

设备驱动程序本身具有文件的外部特征，它们都能使用象open（），close（），read（），write（）等系统调用。

为使设备的存取能象文件一样处理，所有设备在目录中应有对应的文件名称，才可使用有关系统调用。

通常Linux驱动程序接口分为如下四层：1).应用程序进程与内核的接口；2).内核与文件系统的接口；3).文件系统与设备驱动程序的接口；4).设备驱动程序与硬件设备的接口。

§2. 驱动程序文件操作数据结构每个驱动程序都有一个file-operation的数据结构，包含指向驱动程序内部函数的指针。

file-operation的数据结构为：struct file-operation {int （*lseek）（）；int （*read）（）；int （*write）（）；int （*readdir）（）；int （*select）（）；int （*ioctl）（）；int （*mmap）（）；int （*open）（）；int （*close）（）；int （*release）（）；int （*fsync）（）；int （*fasync）（）；int （*check-media-change）（）；int （*revalidate）（）；}内核中有两个表，一个用于字符设备驱动程序，一个用于块设备驱动程序。

Linux设备驱动程序原理及框架-内核模块入门篇

Linux设备驱动程序原理及框架-内核模块入门篇内核模块介绍应用层加载模块操作过程内核如何支持可安装模块内核提供的接口及作用模块实例内核模块内核模块介绍Linux采用的是整体式的内核结构，这种结构采用的是整体式的内核结构，采用的是整体式的内核结构的内核一般不能动态的增加新的功能。

为此，的内核一般不能动态的增加新的功能。

为此，Linux提供了一种全新的机制，叫(可安装) 提供了一种全新的机制，可安装) 提供了一种全新的机制模块” )。

利用这个机制“模块”(module)。

利用这个机制，可以)。

利用这个机制，根据需要，根据需要，在不必对内核重新编译链接的条件将可安装模块动态的插入运行中的内核，下，将可安装模块动态的插入运行中的内核，成为内核的一个有机组成部分；成为内核的一个有机组成部分；或者从内核移走已经安装的模块。

正是这种机制，走已经安装的模块。

正是这种机制，使得内核的内存映像保持最小，的内存映像保持最小，但却具有很大的灵活性和可扩充性。

和可扩充性。

内核模块内核模块介绍可安装模块是可以在系统运行时动态地安装和卸载的内核软件。

严格来说，卸载的内核软件。

严格来说，这种软件的作用并不限于设备驱动，并不限于设备驱动，例如有些文件系统就是以可安装模块的形式实现的。

但是，另一方面，可安装模块的形式实现的。

但是，另一方面，它主要用来实现设备驱动程序或者与设备驱动密切相关的部分(如文件系统等)。

密切相关的部分(如文件系统等)。

课程内容内核模块介绍应用层加载模块操作过程内核如何支持可安装模块内核提供的接口及作用模块实例内核模块应用层加载模块操作过程内核引导的过程中，会识别出所有已经安装的硬件设备，内核引导的过程中，会识别出所有已经安装的硬件设备，并且创建好该系统中的硬件设备的列表树：文件系统。

且创建好该系统中的硬件设备的列表树：/sys 文件系统。

(udev 服务就是通过读取该文件系统内容来创建必要的设备文件的。

)。

LinuxI2C驱动--用户态驱动简单示例

LinuxI2C驱动--⽤户态驱动简单⽰例1. Linux内核⽀持I2C通⽤设备驱动（⽤户态驱动：由应⽤层实现对硬件的控制可以称之为⽤户态驱动），实现⽂件位于drivers/i2c/i2c-dev.c，设备⽂件为/dev/i2c-02. I2C通⽤设备驱动以字符设备注册进内核的static const struct file_operations i2cdev_fops = {.owner = THIS_MODULE,.llseek = no_llseek,.read = i2cdev_read,.write = i2cdev_write,.unlocked_ioctl = i2cdev_ioctl,.open = i2cdev_open,.release = i2cdev_release,};res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);3. 对设备⽂件进⾏读写时，可以调⽤read、write或者ioctl等⽅法，他们都是通过调⽤函数i2c_transfer来实现对I2C设备的操作的int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num){int ret;/* REVISIT the fault reporting model here is weak:** - When we get an error after receiving N bytes from a slave,* there is no way to report "N".** - When we get a NAK after transmitting N bytes to a slave,* there is no way to report "N" ... or to let the master* continue executing the rest of this combined message, if* that's the appropriate response.** - When for example "num" is two and we successfully complete* the first message but get an error part way through the* second, it's unclear whether that should be reported as* one (discarding status on the second message) or errno* (discarding status on the first one).*/if (adap->algo->master_xfer) {#ifdef DEBUGfor (ret = 0; ret < num; ret++) {dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, ""len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)'R' : 'W', msgs[ret].addr, msgs[ret].len,(msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");}#endifif (in_atomic() || irqs_disabled()) {ret = mutex_trylock(&adap->bus_lock);if (!ret)/* I2C activity is ongoing. */return -EAGAIN;} else {mutex_lock_nested(&adap->bus_lock, adap->level);}ret = adap->algo->master_xfer(adap,msgs,num);mutex_unlock(&adap->bus_lock);return ret;} else {dev_dbg(&adap->dev, "I2C level transfers not supported\n");return -EOPNOTSUPP;}}4. i2c_transfer通过代码可以看出，i2c_transfer 通过调⽤相应的 adapter 的 master_xfer ⽅法实现的，⽽ master_xfer 主要是根据 struct i2c_msg 类型的msgs来进⾏处理的。

实验二：字符设备驱动实验

实验二：字符设备驱动实验一、实验目的通过本实验的学习，了解Linux操作系统中的字符设备驱动程序结构，并能编写简单的字符设备的驱动程序以及对所编写的设备驱动程序进行测试，最终了解Linux操作系统如何管理字符设备。

二、准备知识字符设备驱动程序主要包括初始化字符设备、字符设备的I/O调用和中断服务程序。

在字符设备驱动程序的file_operations结构中，需要定义字符设备的基本入口点。

open()函数；release()函数read()函数write()函数ioctl()函数select()函数。

另外，注册字符设备驱动程序的函数为register_chrdev()。

register_chrdev() 原型如下：int register_chrdev(unsigned int major, //主设备号const char *name, //设备名称struct file_operations *ops)； //指向设备操作函数指针其中major是设备驱动程序向系统申请的主设备号。

如果major为0，则系统为该驱动程序动态分配一个空闲的主设备号。

name是设备名称，ops是指向设备操作函数的指针。

注销字符设备驱动程序的函数是unregister_chrdev(),原型如下：int unregister_chrdev(unsigned int major,const char *name);字符设备注册后，必须在文件系统中为其创建一个设备文件。

该设备文件可以在/dev目录中创建，每个设备文件代表一个具体的设备。

使用mknod命令来创建设备文件。

创建设备文件时需要使用设备的主设备号和从设备号作为参数。

阅读教材相关章节知识，了解字符设备的驱动程序结构。

三、实验内容根据教材提供的实例。

编写一个简单的字符设备驱动程序。

要求该字符设备包括open()、write()、read()、ioctl()和release()五个基本操作，并编写一个测试程序来测试所编写的字符设备驱动程序。

linux字符驱动框架（用户态的read，write，poll是怎么操作驱动的）

linux字符驱动框架（⽤户态的read，write，poll是怎么操作驱动的）前⾔这篇⽂章是通过对⼀个简单字符设备驱动的操作来解释，⽤户态的读写操作是怎么映射到具体设备的。

因为针对不同版本的linux内核，驱动的接⼝函数⼀直有变化，这贴出我测试的系统信息：root@ubuntu:~/share/dev/cdev-2# cat /etc/os-release |grep -i verVERSION="16.04.5 LTS (Xenial Xerus)"VERSION_ID="16.04"VERSION_CODENAME=xenialroot@ubuntu:~/share/dev/cdev-2#root@ubuntu:~/share/dev/cdev-2# uname -r4.15.0-33-generic字符驱动这⾥给出了⼀个不怎么标准的驱动，定义了⼀个结构体 struct dev，其中buffer成员模拟驱动的寄存器。

由wr，rd作为读写指针，len作为缓存buffer的长度。

具体步骤如下：1. 定义 init 函数，exit函数，这是在 insmod，rmmod时候调⽤的。

2. 定义驱动打开函数open，这是在⽤户态打开设备时候调⽤的。

3. 定义release函数，这是在⽤户态关闭设备时候⽤到的。

4. 定义read，write，poll函数，并挂接到 file_operations结构体中，所有⽤户态的read，write，poll都会最终调到这些函数。

chardev.c/*参考：深⼊浅出linux设备驱动开发*/#include <linux/module.h>#include <linux/init.h>#include <linux/fs.h>#include <linux/uaccess.h>#include <linux/wait.h>#include <linux/semaphore.h>#include <linux/sched.h>#include <linux/cdev.h>#include <linux/types.h>#include <linux/kdev_t.h>#include <linux/device.h>#include <linux/poll.h>#define MAXNUM 100#define MAJOR_NUM 400 //主设备号 ,没有被使⽤struct dev{struct cdev devm; //字符设备struct semaphore sem;int flag;poll_table* table;wait_queue_head_t outq;//等待队列,实现阻塞操作char buffer[MAXNUM+1]; //字符缓冲区char *rd,*wr,*end; //读,写,尾指针}globalvar;static struct class *my_class;int major=MAJOR_NUM;static ssize_t globalvar_read(struct file *,char *,size_t ,loff_t *);static ssize_t globalvar_write(struct file *,const char *,size_t ,loff_t *);static int globalvar_open(struct inode *inode,struct file *filp);static int globalvar_release(struct inode *inode,struct file *filp);static unsigned int globalvar_poll(struct file* filp, poll_table* wait);/*结构体file_operations在头⽂件 linux/fs.h中定义，⽤来存储驱动内核模块提供的对设备进⾏各种操作的函数的指针。

字符设备驱动（1）驱动代码完整源码：charButtons.c

字符设备驱动（1）驱动代码完整源码：charButtons.c 内核版本：Linux3.0.8开发板：基于三星S5PV210处理器的Tiny210开发板驱动名称：charButtons.c驱动描述：按键触发中断，中断处理程序执⾏相应的简单LED点亮操作⽅案1注册字符设备使⽤新的接⼝实现（需要好⼏个函数来实现。

貌似更复杂）⽅案2注册字符设备使⽤⽼的接⼝实现（貌似⽼接⼝更简单）/*****************************************************************************简述：简单字符型驱动程序，⼿动静态分配设备号，⼿动创建设备节点******************************************************************************/#include <linux/module.h>#include <linux/moduleparam.h>#include <linux/cdev.h>#include <linux/fs.h>#include <linux/wait.h>#include <linux/poll.h>#include <linux/sched.h>#include <linux/irq.h>#include <asm/irq.h>#include <linux/interrupt.h>#include <mach/map.h>#include <mach/gpio.h>#include <mach/regs-gpio.h>#include <plat/gpio-cfg.h>#include <linux/slab.h>#define DEVICE_NAME "buttons"struct button_desc {int gpio;int number;char *name;};struct led_desc {int gpio;int number;char *name;};static struct button_desc buttons[] = {{ S5PV210_GPH2(0), 0, "KEY0" },{ S5PV210_GPH2(1), 1, "KEY1" },{ S5PV210_GPH2(2), 2, "KEY2" },{ S5PV210_GPH2(3), 3, "KEY3" },{ S5PV210_GPH3(0), 4, "KEY4" },{ S5PV210_GPH3(1), 5, "KEY5" },{ S5PV210_GPH3(2), 6, "KEY6" },{ S5PV210_GPH3(3), 7, "KEY7" },};static struct led_desc leds[] = {{S5PV210_GPJ2(0),1,"LED1"},{S5PV210_GPJ2(1),2,"LED2"},{S5PV210_GPJ2(2),3,"LED3"},{S5PV210_GPJ2(3),4,"LED4"},};#define OK (0)#define ERROR (-1)struct gpio_chip *chip;struct cdev *gDev;struct file_operations *gFile;dev_t devNum;unsigned int subDevNum = 1;//要申请的次设备号个数int reg_major = 234;int reg_minor = 0;static irqreturn_t button_interrupt(int irq, void *dev_id){struct button_desc *bdata = (struct button_desc *)dev_id;int down;unsigned tmp;tmp = gpio_get_value(bdata->gpio);/* active low */down = !tmp;printk("KEY %d: %08x\n", bdata->number, down);if(bdata->number < 4){gpio_set_value(leds[bdata->number].gpio,0);printk("LED %d: On \n",leds[bdata->number].number);}else{gpio_set_value(leds[(bdata->number) - 4].gpio,1);printk("LED %d: OFF \n",leds[(bdata->number)-4].number); }return IRQ_HANDLED;}int butsOpen(struct inode *p, struct file *f){int irq;int i;int err = 0;printk(KERN_EMERG"butsOpen\r\n");for (i = 0; i < ARRAY_SIZE(buttons); i++) {if (!buttons[i].gpio)continue;irq = gpio_to_irq(buttons[i].gpio);// irq = IRQ_EINT(16)+i =160+i "S5PV210_GPH2(i)"//irq = IRQ_EINT(24)+i =168+i "S5PV210_GPH3(i)"err = request_irq(irq, button_interrupt, IRQ_TYPE_EDGE_BOTH,buttons[i].name, (void *)&buttons[i]);if (err)break;}for(i = 0; i<ARRAY_SIZE(leds);i++){if(!leds[i].gpio)continue;gpio_direction_output(leds[i].gpio,1);}if (err) {i--;for (; i >= 0; i--) {if (!buttons[i].gpio)continue;irq = gpio_to_irq(buttons[i].gpio);disable_irq(irq);free_irq(irq, (void *)&buttons[i]);}return -EBUSY;}return0;}int charDrvInit(void){devNum = MKDEV(reg_major, reg_minor);printk(KERN_EMERG"devNum is %d\r\n", devNum);if(OK == register_chrdev_region(devNum, subDevNum, DEVICE_NAME)) {printk(KERN_EMERG"register_chrdev_region ok\r\n");}else{printk(KERN_EMERG"register_chrdev_region error\r\n");return ERROR;}/*if(OK == alloc_chrdev_region(&devNum, subDevNum, subDevNum,"test")) {printk(KERN_EMERG"register_chrdev_region ok\r\n");}else{printk(KERN_EMERG"register_chrdev_region error\r\n");return ERROR;}*/gDev = kzalloc(sizeof(struct cdev), GFP_KERNEL);gFile = kzalloc(sizeof(struct file_operations), GFP_KERNEL);gFile->open = butsOpen;//注册设备函数到file_operations结构体gFile//gDev->owner = THIS_MODULE;gFile->owner = THIS_MODULE;cdev_init(gDev, gFile);//在cdev结构体中添加指针指向file_operations结构体gFilecdev_add(gDev, devNum, 3);//建⽴设备号与cdev结构体联系printk(KERN_EMERG"button driver initial done...\r\n");return0;}void __exit charDrvExit(void){int i,irq;cdev_del(gDev);unregister_chrdev_region(devNum, subDevNum);for (i = 0; i < ARRAY_SIZE(buttons); i++) {if (!buttons[i].gpio)continue;irq = gpio_to_irq(buttons[i].gpio);disable_irq(irq);free_irq(irq, (void *)&buttons[i]);}return;}module_init(charDrvInit);//执⾏insmod时会执⾏此⾏代码并调⽤charDrvInit，驱动开始module_exit(charDrvExit);//执⾏rmmod时，结束MODULE_LICENSE("GPL");代码实现⽅案1/*****************************************************************************简述：简单字符型驱动程序，⼿动静态分配设备号，⼿动创建设备节点******************************************************************************/#include <linux/module.h>#include <linux/fs.h>#include <mach/gpio.h>#include <linux/irq.h>#include <linux/kdev_t.h>#include <linux/interrupt.h>#include <linux/init.h>#define DEVICE_NAME "leds"struct button_desc {int gpio;int number;char *name;};struct led_desc {int gpio;int number;char *name;};static struct button_desc buttons[] = {{ S5PV210_GPH2(0), 0, "KEY0" },{ S5PV210_GPH2(1), 1, "KEY1" },{ S5PV210_GPH2(2), 2, "KEY2" },{ S5PV210_GPH2(3), 3, "KEY3" },{ S5PV210_GPH3(0), 4, "KEY4" },{ S5PV210_GPH3(1), 5, "KEY5" },{ S5PV210_GPH3(2), 6, "KEY6" },{ S5PV210_GPH3(3), 7, "KEY7" },};static struct led_desc leds[] = {{S5PV210_GPJ2(0),1,"LED1"},{S5PV210_GPJ2(1),2,"LED2"},{S5PV210_GPJ2(2),3,"LED3"},{S5PV210_GPJ2(3),4,"LED4"},};#define OK (0)#define ERROR (-1)dev_t devNum;unsigned int subDevNum = 1;//要申请的次设备号个数int reg_major = 234;int reg_minor = 0;static irqreturn_t button_interrupt(int irq, void *dev_id){struct button_desc *bdata = (struct button_desc *)dev_id;int down;unsigned tmp;tmp = gpio_get_value(bdata->gpio);/* active low */down = !tmp;printk("KEY %d: %08x\n", bdata->number, down);if(bdata->number < 4){gpio_set_value(leds[bdata->number].gpio,0);printk("LED %d: On \n",leds[bdata->number].number);}else{gpio_set_value(leds[(bdata->number) - 4].gpio,1);printk("LED %d: OFF \n",leds[(bdata->number)-4].number); }return IRQ_HANDLED;}int butsOpen(struct inode *p, struct file *f){int irq;int i;int err = 0;printk(KERN_EMERG"butsOpen\r\n");for (i = 0; i < ARRAY_SIZE(buttons); i++) {if (!buttons[i].gpio)continue;irq = gpio_to_irq(buttons[i].gpio);// irq = IRQ_EINT(16)+i =160+i "S5PV210_GPH2(i)"//irq = IRQ_EINT(24)+i =168+i "S5PV210_GPH3(i)"err = request_irq(irq, button_interrupt, IRQ_TYPE_EDGE_FALLING, buttons[i].name, (void *)&buttons[i]);if (err)break;}for(i = 0; i<ARRAY_SIZE(leds);i++){if(!leds[i].gpio)continue;gpio_direction_output(leds[i].gpio,1);}if (err) {i--;for (; i >= 0; i--) {if (!buttons[i].gpio)continue;irq = gpio_to_irq(buttons[i].gpio);disable_irq(irq);free_irq(irq, (void *)&buttons[i]);}return -EBUSY;}return0;}static const struct file_operations gFile ={.owner = THIS_MODULE,.open = butsOpen,};int charDrvInit(void){devNum = MKDEV(reg_major, reg_minor);printk(KERN_EMERG"devNum is %d\r\n", devNum);if(OK == register_chrdev(reg_major, DEVICE_NAME, &gFile)){printk(KERN_EMERG "register_chrdev_region ok\r\n");}else{printk(KERN_EMERG"register_chrdev_region error\r\n");return ERROR;}printk(KERN_EMERG "button driver initial done...\r\n");return0;}void __exit charDrvExit(void){int i,irq;unregister_chrdev(reg_major, DEVICE_NAME);for (i = 0; i < ARRAY_SIZE(buttons); i++) {if (!buttons[i].gpio)continue;irq = gpio_to_irq(buttons[i].gpio);disable_irq(irq);free_irq(irq, (void *)&buttons[i]);}return;}module_init(charDrvInit);//执⾏insmod时会执⾏此⾏代码并调⽤charDrvInit，驱动开始module_exit(charDrvExit);//执⾏rmmod时，结束MODULE_LICENSE("GPL");MODULE_AUTHOR("LiuB");代码实现⽅案2函数修饰符__init，本质上是⼀个宏定义，在内核源代码中定义：#define __init __section(.init.text) __cold notrace作⽤就是，将被它修饰的函数放⼊.init.text段中去。

linux驱动面试题

linux驱动面试题Linux驱动是指在Linux操作系统中，用于控制与硬件之间的交互和通信的软件模块。

在Linux的工作环境中，驱动程序起着至关重要的作用。

如果你准备参加Linux驱动的面试，以下是一些常见的Linux驱动面试题，希望可以对你有所帮助。

一、简述Linux驱动的作用和功能。

Linux驱动是一种软件模块，用来控制硬件设备与操作系统之间的通信和交互。

它负责将输入/输出请求传递给硬件设备，并处理来自硬件设备的中断和事件。

Linux驱动的功能包括设备初始化和配置、数据传输和处理以及错误处理等。

二、请简要介绍Linux驱动程序的加载过程。

当系统启动时，Linux内核首先会加载核心模块和驱动程序模块。

驱动程序模块是以目标硬件设备为基础的，它们包含了与设备通信所需的函数和数据结构。

一般情况下，系统会根据硬件设备信息自动加载对应的驱动程序模块。

加载驱动程序模块需要通过insmod或modprobe命令进行，这些命令可以在启动时自动执行。

三、请简述Linux驱动程序的实现方式。

Linux驱动程序的实现方式包括内核空间驱动和用户空间驱动。

内核空间驱动是指驱动程序运行在内核空间，直接与硬件设备进行交互。

用户空间驱动是指驱动程序运行在用户空间，通过系统调用和内核模块实现与硬件设备的通信。

内核空间驱动的优势是性能更好，但需要对内核进行编译和加载，而用户空间驱动的优势是开发更加容易，但性能会稍差。

四、请介绍Linux驱动程序中常用的数据结构和函数。

在Linux驱动程序中，常用的数据结构有file结构体、inode结构体和cdev结构体等。

file结构体用于表示一个打开的设备文件，可以通过它传递与设备相关的信息。

inode结构体用于表示一个文件的元数据信息，包括文件的权限、大小和创建时间等。

cdev结构体用于表示一个字符设备，包含了设备文件的操作函数和设备号等信息。

常用的函数包括register_chrdev、unregister_chrdev、request_irq和release_irq等。

第八章 Linux下MTD驱动

8.3 MTD NAND Flash驱动
nand_chip结构体（2）
int (*dev_ready)(struct mtd_info *mtd); void (*cmdfunc)(struct mtd_info *mtd, unsigned command, int column, int page_addr); //命令处理函数 int (*waitfunc)(struct mtd_info *mtd, struct nand_chip *this); void (*erase_cmd)(struct mtd_info *mtd, int page); int (*scan_bbt)(struct mtd_info *mtd); //扫描坏块 int (*errstat)(struct mtd_info *mtd, struct nand_chip *this, int state, int status, int page); int (*write_page)(struct mtd_info *mtd, struct nand_chip *chip, const uint8_t *buf, int page, int cached, int raw); int chip_delay; unsigned intoptions; int page_shift; int phys_erase_shift; int bbt_erase_shift; int chip_shift; int numchips; 下页继续
map_info结构体主要成员
char *name; unsigned long size; unsigned long phys; #define NO_XIP (-1UL) void __iomem *virt; /*虚拟地址*/ void *cached; int bankwidth; /* 总线宽度*/ #ifdef CONFIG_MTD_COMPLEX_MAPPINGS map_word (*read)(struct map_info *, unsigned long); void (*copy_from)(struct map_info *, void *, unsigned long, ssize_t); void (*write)(struct map_info *, const map_word, unsigned long); void (*copy_to)(struct map_info *, unsigned long, const void *, ssize_t); #endif /*缓冲的虚拟地址*/ void (*inval_cache)(struct map_info *, unsigned long, ssize_t); void (*set_vpp)(struct map_info *, int); unsigned long map_priv_1; unsigned long map_priv_2; void *fldrv_priv; struct mtd_chip_driver *fldrv;

Linux ——Driver

第一章驱动程序基本框架星期二, 06/08/2010 - 00:21— william前言不管是Windows还是Linux，驱动程序都扮演着重要的角色。

应用程序只能通过驱动程序才能同硬件设备或系统内核通讯。

Linux内核对不同的系统定义了标准的接口（API），应用程序就是通过这些标准的接口来操作内核和硬件。

驱动可以被编译的内核中（build-in），也可以做为内核模块（Module）存在于内核的外面，需要的时候动态插入到内核中运行。

就像你学习操作系统概念时所了解的那样，Linux内核也分为几个大的部分：进程管理、内存管理、文件系统、设备控制、网络系统等，参考图1-1。

图1-1 Linux系统（来源：O‟Reilly Media, LDD3）这里就不对Linux系统内核的各个部分做过多的介绍了，在后面的学习中你就会逐渐地对这些概念有个更深入的了解。

其实Linux内核的精髓远不止这些，对于一个Linux内核的爱好者或开发者来说，最好详细的浏览内核源代码，订阅Linux内核相关的邮件列表，或是登陆Linux开发社区。

更多的信息，请登陆Linux内核官方网站：一个简单的驱动下面我们来编写第一个驱动程序，它很简单，在运行时会输出…Hello World‟消息。

// hello.c#include <linux/init.h>#include <linux/module.h>#include <linux/kernel.h>static int __init hello_init(void){printk(KERN_ALERT "Hello World！\n");return 0;}static void __exit hello_exit(void){printk(KERN_ALERT "Goodbye World！\n");}module_init(hello_init);module_exit(hello_exit);MODULE_LICENSE("GPL");这就是一个简单的驱动程序，它什么也没做，仅仅是输出一些信息，不过对于我们来说这已经足够了。

Linux字符设备驱动开发方法与应用实例

并行接口。因为驱动的设备是ＬＤ光二极管，里不Ｅ发这能使用并Ｓｆ机的驱动程序。ＴＰ
￣ｌａ０ｒｅ）ｌｅｄ和ｗｉ（：ｒｔ调用等；还包含对用户发出的控制请求
的响应，比如启动或关闭设备等。由于用户发出的Ｉ功／Ｏ能调用和控制请求是在确定的时间内发生，以它是同所步事件，执行的先后顺序上看，在中断程序的后面从它
Ｐ￣的并口控制卡经常使用的２／并口基地址ｃＪＬ个ＩＯ是０３８ｘ７，ｘ７和０２８在并口通信中使用的电平信号是标
准的ＴＬＴ电平：伏和５我们要把驱动程序的下部分０伏。
被执行，所以把它称为驱动程序的下半部。
ＦＩＮＡＮＣＩＡＬｃｏＭＰＵＴＥ
驱动程序的代码按照执行时间是否确定，可将其分为
同步执行和异步执行的代码。Ｌｎｘ在ｉｕ内核中把同步执
行的代码称为驱动程序的下半部，把异步执行的代码
个十字路口的交通灯。
由微机接口技术可知，口的最小配置由一些８并位的端口组成。到输出端口的数据，现为２脚Ｄ插写表５型
一
捅到时间队列，这将使用Ｌｎｘｉ的定时器报时，ｕ即每秒中
断ｌ０。０次
些总结，也编写了一个应用实例，细讨论了与操作详
系统的软件接口部分，为那些想将其他系统下的驱动程序移植￣ＬｎｘＪｌｉｕ下的人员提供参考。该文参￣Ｌｎｘ２４ｉ一．ｕ的内核源代码提供有关数据结构和函数。

设备驱动程序-案例一

c:字符设备主设备号 b:块设备 1 root root 1, 1 root root 1, 1 root root 1, 1 root root 1, 1 root root 1, 1 root root 1, 1 root root 1, 1 root root 1, 1 root root 5, 1 root root 5, 1 root root 5, 1 root root 2 root root 1 root root 1 root root 1 root root 1 root root 4, 1 root root 4, 1 root root 4, 1 root root 4, 1 root root 4, 数字集成电路设计与系统应用专业 1 root root
file_operations是一个结构体类型，定义在include/linux/fs.h中。上述代码定义了一个file_operations类型的结构体spioc_fops，并将其中的一些成员赋了初值。由于spioc_fops是一个静态变量，所以其他成员的初值是“零”。
结构体spioc_fops将作为一个参数在注册一个设备驱动程序时传递给内核。内核使用设备链表维护各种注册的设备。不同类型的设备使用不同的链表。
ioctl()函数用于控制驱动程序本身的一些特性和参数，如设定驱动程序使用的缓冲区的大小，设定串行通讯的速率等。数字集成电路设计与系统应用专业
11
static int spioc_open(struct inode *inode, struct file *filp) { /* 这里是open函数的代码 */ return ret; } static int spioc_close(struct inode *inode, struct file *filp) { /* 这里是close函数的代码 */ return ret; }

嵌入式Linux操作系统设备驱动程序设计与实现

＿
ｔｗｉ）ｔｃｆｅ，ｃｎｔｈｒｓｅｔｏ＿；（ｒｅ（ｒｔｌｔｓｕｏｓｃａｉ — ，ｌｆｔ）ｉｚｆ
ｉｔｅｄｉｓｒｃｏｅ，ｓｕｔｌ＊ｖｉ，ｆｌｉｔ；ｎ（ａｄｒｔｕｔｎｄ十ｔｃｅ，ｏｄｉｌｒ）ｒｉｒｆｉｄ
摘要：主要阐述了嵌入式Ｌｕｉｘ设备驱动程序的概念，归纳嵌入式Ｌｕｎｉｘ设备驱动程序的共性，讨嵌入式Ｌｕｎ探ｉｘ设备ｎ驱动程序具体开发流程以及驱动程序的关键代码，总结嵌入式Ｌｕ设备驱动程序开发的主导思想。ｉｘｎ关键词：嵌入式系统；Ｌｎｘｉ；设备驱动程序；内核ｕ
ｌｆｔｌｅｋ（ｒｃｆｅ，ｌｆｔｎ）ｏｔ（ｌｅ）ｔｔｌｓｓｕｏｉｆ，ｉｔ；
＿
ｓｉｅｔｒａ）ｔｃｆｅ，ｃａ，ｓｅｔｏｃｓｚ（ｅｄ（ｒｔｌｓｕｈｒｉ，１＿；ｉｚ）
＿
ｓｉｅｓｚ
ｉ（ｓｅＯｓｕｔｎｄｔｃｆｅ，ｉ，ｓｌｔａｌ）ｎｅｃ（ｒｃｉｏｅ，ｓｕｔｌｔｌｔｒｎｅｃｂｅ；ｉｔｅｔ
ｉ（ｉｔ）ｔｃｉｄｔｃｆｅ，ｕｓｎｄｉ，ｕｓｅｎｏ１（ｒｔｎｅ，ｓｕｔｉｎｉｅｔｎｉｄｔｃｓｕｏｒｌｇｎｎｇｉ）ｎ；ｔ
｛ａ：１ｄｉｅｒａ，ｒｄｒｒｅｄｅ０ｖ＿
ｗｒｅＩｒｖｒｗｒｔ，ｉ：Ｏｄｉｅｔｉｅ

linux网络设备驱动

网络设备驱动
struct net_device 全局信息结构 net_device 的第一部分是由下面成员组成: char name[IFNAMSIZ]; 设备名子. 如果名子由驱动设置, 包含一个 %d 格式串, register_netdev 用一个数替换它来形成一个唯一的名子; 分配的编号从 0 开始. unsigned long state; 设备状态. 这个成员包括几个标志. 驱动正常情况下不直接操作这些标志; 相反, 提供了一套实用函数. struct net_device *next; 全局列表中指向下一个设备的指针. 这个成员驱动不能动. int (*init)(struct net_device *dev); 一个初始化函数. 如果设置了这个指针, 这个函数被 register_netdev 调用来完成对 net_device 结构的初始化. 大部分现代的网络驱动不再使用这个函数; 相反, 初始化在注册接口前进行.
网络设备驱动
struct net_device接口信息
unsigned char addr_len; unsigned char broadcast[MAX_ADDR_LEN]; unsigned char dev_addr[MAX_ADDR_LEN]; 硬件 (MAC) 地址长度和设备硬件地址. 以太网地址长度是 6 个字节( 我们指的是接口板的硬件 ID ), 广播地址由 6 个 0xff 字节组成; ether_setup 安排成正确的值. 设备地址, 另外, 必须以特定于设备的方式从接口板读出, 驱动应当将它拷贝到 dev_addr. 硬件地址用来产生正确的以太网头
void *priv;
Байду номын сангаас

linux中编译驱动的方法

linux中编译驱动的方法
在Linux中编译驱动的方法通常涉及以下步骤：
1. 编写驱动代码：首先，您需要编写适用于Linux内核的驱动代码。

这通常是在内核源代码树之外编写的。

驱动代码通常以C语言编写，并遵循内核编程约定。

2. 获取内核源代码：为了编译驱动，您需要获得Linux内核的源代码。

您可以从Linux官方网站或镜像站点下载内核源代码。

3. 配置内核：在编译驱动之前，您需要配置内核以包含您的驱动。

这可以通过运行`make menuconfig`命令来完成。

在配置菜单中，您可以选择要编译的驱动以及相关的内核选项。

4. 编译驱动：一旦您配置了内核并选择了要编译的驱动，您可以使用`make`命令来编译驱动。

这将在内核源代码目录下生成可执行文件或模块文件。

5. 加载和测试驱动：一旦驱动被编译，您可以将其加载到Linux 内核中以进行测试。

您可以使用`insmod`命令将模块加载到内核，然后使用`dmesg`命令检查内核日志以查看驱动是否正确加载。

这些是基本的步骤，但具体的步骤可能会因您的环境和需求而有所不同。

在编译和加载驱动时，请确保您具有适当的权限和知识，因为这可能需要管理员权限，并且错误的操作可能会导致系统不稳定或损坏。

Linux设备驱动开发详解-第6章字符设备驱动（一）-globalmem

Linux设备驱动开发详解-第6章字符设备驱动（⼀）-globalmem1 驱动程序设计之前奏 (2)1.1 应⽤程序、库、内核、驱动程序的关系 (2)1.2 设备类型 (2)1.3 设备⽂件 (2)1.4 主设备号和从设备号 (2)1.5 驱动程序与应⽤程序的区别 (3)1.6 ⽤户态与内核态 (3)1.7 Linux驱动程序功能 (3)2 字符设备驱动程序框架 (3)2.1 file_operations结构体 (4)2.2 驱动程序初始化和退出 (5)2.3 将驱动程序模块注册到内核 (5)2.4 应⽤字符设备驱动程序 (5)3 globalmem虚拟设备实例描述 (6)3.1 头⽂件、宏及设备结构体 (6)3.2 加载与卸载设备驱动 (6)3.3 读写函数 (8)3.4 seek()函数 (9)3.5 ioctl()函数 (10)3.6 globalmem完整实例 (12)4 测试应⽤程序 (17)4.1 应⽤程序接⼝函数 (17)4.2 应⽤程序 (18)5 实验步骤 (19)5.1 编译加载globalmem 模块 (19)5.2 编译测试应⽤程序 (20)6 扩展 (21)1 驱动程序设计之前奏㈠应⽤程序、库、内核、驱动程序的关系㈡设备类型㈢设备⽂件㈣主设备号与从设备号㈤驱动程序与应⽤程序的区别㈥⽤户态与内核态㈦Linux驱动程序功能1.1 应⽤程序、库、内核、驱动程序的关系■应⽤程序调⽤应⽤程序函数库完成功能■应⽤程序以⽂件形式访问各种资源■应⽤程序函数库部分函数直接完成功能部分函数通过系统调⽤由内核完成■内核处理系统调⽤，调⽤设备驱动程序■设备驱动直接与硬件通信1.2 设备类型■字符设备对字符设备发出读/写请求时，实际的硬件I/O操作⼀般紧接着发⽣■块设备块设备与之相反，它利⽤系统内存作为缓冲区■⽹络设备⽹络设备是⼀类特殊的设备，它不像字符设备或块设备那样通过对应的设备⽂件节点访问，也不能直接通过read或write进⾏数据访问请求1.3 设备⽂件■设备类型、主从设备号是内核与设备驱动程序通信时使⽤的■应⽤程序使⽤设备⽂件节点访问对应设备■每个主从设备号确定的设备都对应⼀个⽂件节点■每个设备⽂件都有其⽂件属性（c或者b）■每个设备⽂件都有2个设备号（后⾯详述）主设备号：⽤于标识驱动程序从设备号：⽤于标识同⼀驱动程序的不同硬件■设备⽂件的主设备号必须与设备驱动程序在登记时申请的主设备号⼀致■系统调⽤是内核与应⽤程序之间的接⼝■设备驱动程序是内核与硬件之间的接⼝1.4 主设备号和从设备号■在设备管理中，除了设备类型外，内核还需要⼀对被称为主从设备号的参数，才能唯⼀标识⼀个设备■主设备号相同的设备使⽤相同的驱动程序■从设备号⽤于区分具体设备的实例例：PC的IDE设备，主设备号⽤于标识该硬盘，从设备号⽤于标识每个分区■在/dev⽬录下使⽤ll命令（ls -l）可以查看各个设备的设备类型、主从设备号等■cat /proc/devices可以查看系统中所有设备对应的主设备号1.5 驱动程序与应⽤程序的区别■应⽤程序以main开始■驱动程序没有main，它以⼀个模块初始化函数作为⼊⼝■应⽤程序从头到尾执⾏⼀个任务■驱动程序完成初始化之后不再运⾏，等待系统调⽤■应⽤程序可以使⽤GLIBC等标准C函数库■驱动程序不能使⽤标准C库1.6 ⽤户态与内核态■驱动程序是内核的⼀部分，⼯作在内核态■应⽤程序⼯作在⽤户态■数据空间访问问题★⽆法通过指针直接将⼆者的数据地址进⾏传递★系统提供⼀系列函数帮助完成数据空间转换get_userput_usercopy_from_usercopy_to_user1.7 Linux驱动程序功能■对设备初始化和释放■把数据从内核传送到硬件和从硬件读取数据■读取应⽤程序传送给设备⽂件的数据和回送应⽤程序请求的数据■检测和处理设备出现的错误2 字符设备驱动程序框架①Linux各种设备驱动程序都是以模块的形式存在的，驱动程序同样遵循模块编程的各项原则②字符设备是最基本、最常⽤的设备，其本质就是将千差万别的各种硬件设备采⽤⼀个统⼀的接⼝封装起来，屏蔽了不同设备之间使⽤上的差异性，简化了应⽤层对硬件的操作③字符设备将各底层硬件设备封装成统⼀的结构体，并采⽤相同的函数操作，如下等：open/close/read/write/ioctl④添加⼀个字符设备驱动程序，实际上是给上述操作添加对应的代码⑤Linux对所有的硬件操作统⼀做以下抽象抽象file_operations结构体规定了驱动程序向应⽤程序提供的操作接⼝struct file_operations ext2_file_operations ={.llseek = generic_file_llseek,.read = generic_file_read,.write = generic_file_write,.aio_read = generic_file_aio_read,.aio_write = generic_file_aio_write,.ioctl = ext2_ioctl,.mmap = generic_file_mmap,.open = generic_file_open,.release = ext2_release_file,.fsync = ext2_sync_file,.readv = generic_file_readv,.writev = generic_file_writev,.sendfile = generic_file_sendfile,};⑥⽤户态与内核态数据的交互⽤户应⽤程序与驱动程序分属于不同的进程空间，因此⼆者之间的数据应当采⽤以下函数进⾏交换long copy_to_user(kernel_buffer, user_buffer,n)//从内核空间拷贝n字节数据到⽤户空间copy_from_user(kernel_buffer, user_buffer,n)//从⽤户空间拷贝n字节数据到内核空间put_user(kernel_value, user_buffer)//从内核空间拷贝⼀数据变量到⽤户空间get_user(kernel_value, user_buffer)//从⽤户空间拷贝⼀数据变量到内核空间（内核空间数据可是任意类型）2.1 file_operations结构体⑴write函数■从应⽤程序接收数据送到硬件ssize_t (*write)(struct file*, const char __user *, size_t, loff_t*);⑵read函数■从硬件读取数据并交给应⽤程序ssize_t (*read)(struct file *, char __user *, size_t, loff_t*); /// 从设备中同步读取数据⑶ioctl函数■为应⽤程序提供对硬件⾏为的相关配置int (*ioctl)(struct inode *, struct file *, unsigned int, unsigned long);⑷open函数■当应⽤程序打开设备时对设备进⾏初始化■使⽤MOD_INC_USE_COUNT增加驱动程序的使⽤次数,当模块使⽤次数不为0时，禁⽌卸载模块Int (*open)(struct inode *, struct file*);⑸release函数■当应⽤程序关闭设备时处理设备的关闭操作■使⽤MOD_DEC_USE_COUNT减少驱动程序的使⽤次数，配合open使⽤，来对模块使⽤次数进⾏计数int (*release)(struct inode *, struct file*);⑹⑻⑻⑼⑽2.2 驱动程序初始化和退出①驱动程序初始化函数■Linux在加载内核模块时会调⽤初始化函数■在初始化函数中⾸先进⾏资源申请等⼯作■使⽤register_chrdev向内核注册驱动程序②驱动程序退出函数■Linux在卸载内核模块时会调⽤退出函数■释放驱动程序使⽤的资源■使⽤unregister_chrdev从内核中卸载驱动程序2.3 将驱动程序模块注册到内核内核需要知道模块的初始化函数和退出函数，才能将模块放⼊⾃⼰的管理队列中①module_init()向内核声明当前模块的初始化函数②module_exit()向内核声明当前模块的退出函数2.4 应⽤字符设备驱动程序㈠加载驱动程序■insmod 内核模块⽂件名■cat /proc/devices 查看当前系统中所有设备驱动程序及其主设备号㈡⼿动建⽴设备⽂件■设备⽂件⼀般建⽴/dev⽬录下■mknod ⽂件路径c [主设备号] [从设备号]㈢应⽤程序接⼝函数■编写应⽤层测试程序■可以使⽤标准C的⽂件操作函数来完成①int open(const char *path, int oflag,…);★打开名为path的⽂件或设备★成功打开后返回⽂件句柄★常⽤oflag：O_RDONLY, O_WRONLY, O_RDWR②int close(int fd);★关闭之前被打开的⽂件或设备★成功关闭返回0，否则返回错误代号③ssize_t read(int fd, void *buffer, size_t count)★从已经打开的⽂件或设备中读取数据★buffer表⽰应⽤程序缓冲区★count表⽰应⽤程序希望读取的数据长度★成功读取后返回读取的字节数，否则返回-1④ssize_t write(int fd, void *buffer, size_t count）;★向已经打开的⽂件或设备中写⼊数据★buffer表⽰应⽤程序缓冲区★count表⽰应⽤程序希望写⼊的数据长度★成功写⼊后返回写⼊的字节数，否则返回-1④int ioctl(int fd, unsigned int cmd, unsigned long arg);★向驱动程序发送控制命令★cmd：⽤来定义⽤户向驱动分配的命令例如G PF驱动中：设置指定管脚的⾼低电平、输⼊输出特性等为了规范化及错误检查常⽤_IO宏合成该命令：_IO(MAGIC, num) ★arg：配置命令参数配合cmd命令完成指定功能3 globalmem虚拟设备实例描述3.1 头⽂件、宏及设备结构体在globalmem字符设备驱动中，应包含它要使⽤的头⽂件，并定义globalmem设备结构体及相关宏。

linux驱动开发流程

linux驱动开发流程Linux驱动开发流程。

Linux驱动开发是一项复杂而又重要的工作，它涉及到操作系统内核的底层编程和硬件设备的交互。

在进行Linux驱动开发时，需要按照一定的流程来进行，以确保驱动程序的稳定性和可靠性。

下面将介绍一般的Linux驱动开发流程，希望能够对初学者有所帮助。

1. 硬件设备了解。

在进行Linux驱动开发之前，首先需要对要开发的硬件设备有一个全面的了解。

需要了解硬件设备的型号、接口、工作原理等信息，以便于后续的驱动程序编写和调试工作。

2. 硬件设备驱动框架选择。

针对不同的硬件设备，可以选择不同的驱动框架进行开发。

常用的驱动框架包括字符设备驱动、块设备驱动、网络设备驱动等。

根据硬件设备的特点和需求，选择合适的驱动框架进行开发。

3. 编写驱动程序。

在选择好驱动框架之后，就可以开始编写驱动程序了。

驱动程序是连接硬件设备和操作系统内核的桥梁，需要按照一定的规范和接口来进行编写。

在编写驱动程序时，需要考虑到硬件设备的特性和操作系统的要求，确保驱动程序能够正确地控制硬件设备。

4. 调试和测试。

编写完驱动程序后，需要进行调试和测试工作。

通过调试和测试，可以发现驱动程序中的bug和问题，及时进行修复和优化。

调试和测试是保证驱动程序稳定性和可靠性的重要环节，需要认真对待。

5. 集成到内核。

当驱动程序经过调试和测试后，可以将其集成到Linux内核中。

在将驱动程序集成到内核时，需要按照内核的规范和流程来进行，确保驱动程序能够正确地被内核加载和使用。

6. 发布和维护。

最后，当驱动程序集成到内核后，可以进行发布和维护工作。

发布驱动程序时，需要提供清晰的文档和说明，以便其他开发者能够正确地使用和理解驱动程序。

同时，还需要对驱动程序进行定期的维护和更新，以适应不断变化的硬件设备和内核版本。

总结。

通过以上的介绍，我们可以看到Linux驱动开发流程是一个系统而又复杂的过程。

需要对硬件设备有深入的了解，选择合适的驱动框架，编写稳定可靠的驱动程序，并经过严格的调试和测试，最终将其集成到内核并进行发布和维护。

嵌入式Linux设备驱动程序开发ppt课件

.
10.1 嵌入式Linux驱动程序开发基础
② int schedule_work(struct work_struct *work) ③int schedule_delayed_work(struct work_struct *work, unsigned long delay) ④void flush_scheduled_work(void)
Linux将设备按照功能特性划分为三种类型：字符设备，块设备和网络设备。 10.1.2 最简单的内核模块 1．helloworld模块源代码 2．模块的编译 3．模块的加载和卸载
.
10.1 嵌入式Linux驱动程序开发基础
10.2 嵌入式Linux设备驱动重要技术 10.2.1 内存与I/O端口（1）内核空间和用户空间（2）内核中内存分配内核中获取内存的几种方式如下。 ①通过伙伴算法分配大片物理内存 ②通过slab缓冲区分配小片物理内存 ③非连续内存区分配 ④高端内存映射 ⑤固定线性地址映射
.
10.1 嵌入式Linux驱动程序开发基础
1.原子操作原子操作主要用于实现资源计数，很多引用计数(refcnt)就是通过原子操作实现的。
原子类型定义如下： typedef struct { volatile int counter; } atomic_t; 原子操作通常用于实现资源的引用计数 2.信号量
信号量在创建时需要设置一个初始值. 3.读写信号量
读写信号量有两种实现:
一种是通用的，不依赖于硬件架构一种是架构相关的
.
10.1 嵌入式Linux驱动程序开发基础
读写信号量的相关API有： DECLARE_RWSEM(name) 该宏声明一个读写信号量name并对其进行初始化。 void init_rwsem(struct rw_semaphore *sem); 该函数对读写信号量sem进行初始化。 void down_read(struct rw_semaphore *sem);

linux字符设备驱动框架

linux字符设备驱动框架linux 字符设备驱动框架1.一、字符设备结构2.1.内核内部使用struct cdev结构来表示字符设备。

在内核调用设备的操作之前，必须分配并注册一个或多个struct cdev。

3.struct cdev {4.struct kobject kobj;//每个 cdev 都是一个 kobject5.struct module *owner;//指向实现驱动的模块6.const struct file_operations *ops;//操纵这个字符设备文件的方法7.struct list_head list;//与cdev对应的字符设备文件的inode->i_devices 的链表头8.dev_t dev;//起始设备编号9.unsigned int count;//设备范围号大小10.};11.12.2.内核中所有已分配的字符设备编号都记录在一个名为chrdevs 散列表里。

该散列表中的每一个元素是一个char_device_struct 结构，它的定义如下：13.static struct char_device_struct {14.struct char_device_struct *next;//指向散列冲突链表中的下一个元素的指针15.unsigned int major;//主设备号16.unsigned int baseminor;//起始次设备号17.int minorct;//设备编号的范围大小18.char name[64];//处理该设备编号范围内的设备驱动的名称19.struct file_operations *fops;//没有使用20.struct cdev *cdev;//指向字符设备驱动程序描述符的指针21.}*chrdevs[CHRDEV_MAJOR_HASH_SIZE];22.注意，内核并不是为每一个字符设备编号定义一个char_device_struct 结构，而是为一组对应同一个字符设备驱动的设备编号范围定义一个char_device_struct 结构。

精选嵌入式LINUX设备驱动程序课件

设备的控制操作
对设备的控制操作可通过文件操作数据结构中的ioctl()函数来完成。控制操作与具体的设备有密切关系，需要根据设备实际情况进行具体分析。
设备的轮询和中断处理
轮询方式对于不支持中断的硬件设备，读写时需要轮流查询设备的状态，以便决定随后的数据操作。如果轮询处理方式的驱动程序被链接到内核，则意味着查询过程中，内核一直处于闲置状态。解决办法是使用内核定时器，进行定期查询。
主设备号与次设备号
次设备号用于标识使用同一设备驱动程序的不同硬件，并仅由设备驱动程序解释当应用程序操作某个设备文件时，Linux内核根据其主设备号调用相应的驱动程序，并从用户态进入内核态驱动程序判断次设备号，并完成相应的硬件操作。
用户空间和内核空间
Linux运行在2种模式下内核模式用户模式内核模式对应内核空间，而用户模式对应用户空间。驱动程序作为内核的一部分，它对应内核空间，应用程序不能直接访问其数据，
帧缓冲设备驱动程序
LCD分类
LCD可由为液晶照明的方式有两种：传送式和反射式传送式屏幕要使用外加光源照明，称为背光（backlight），照明光源要安装在LCD的背后。传送式LCD在正常光线及暗光线下，显示效果都很好，但在户外，尤其在日光下，很难辩清显示内容。反射式屏幕，则不需要外加照明电源，使用周围环境的光线（或在某些笔记本中，使用前部照明系统的光线）。这样，反射式屏幕就没有背光，所以，此种屏幕在户外或光线充足的室内，才会有出色的显示效果，但在一般室内光线下，这种显示屏的显示效果就不及背光传送式的。
文件操作结构体的主要函数
open: 用于打开文件设备release: 在关闭文件的调用read: 用于从设备中读取数据write: 向设备发送数据poll: 查询设备是否可读或可写ioctl: 提供执行设备特定命令的方法fasync: 用于设备的异步通知操作