linux 驱动程序开发_linux驱动程序开发

2024-07-10 11:41:29

linux 驱动程序开发是一个值得探讨的话题，它涉及到许多方面的知识和技能。我将尽力为您解答相关问题。

1.Linux驱动开发前为什么要配置编译内核？

2.如何写linux pci设备驱动程序

3.linux驱动开发主要要开发哪些驱动

4.做linux下的驱动开发,需要掌握哪些技能和知识点?有没具体的要求列一下.谢谢各位

5.linux驱动工程师有前途吗linux驱动工程师

6.怎样编写Linux设备驱动程序？

linux 驱动程序开发_linux驱动程序开发

Linux驱动开发前为什么要配置编译内核？

编译前当然要配置一下内核啊，make menuconfig ，生成默认配置文件 .config ，这个文件是设置 cpu 体系，及很多驱动选项的，你没配置这个，怎么可能编译那

前面那个说 linux 和微软竞争是扯淡的那位，我只能说你根本不懂内核编译，无知

新下载的内核都是没有默认 .config 需要你找到一个默认的config 文件，比如 arch/arm/configs/ 下是 arm cpu 很多的默认配置，当然你也可以把你以前的 config 文件拷贝到新内核目录下。

.config 是配置编译内核的最初步骤，你要编译驱动程序，就必须要了解这个，多上网查下资料

然后重新编译

如何写linux pci设备驱动程序

第1章嵌入式Linux系统开发概述

1.1嵌入式系统概述

1.1.1你身边的嵌入式系统

1.1.2什么是嵌入式系统

1.1.3嵌入式系统的发展

1.1.4嵌入式系统市场规模

1.1.5嵌入式系统发展趋势和面临的挑战

1.2嵌入式操作系统

1.2.1嵌入式操作系统的特点

1.2.2嵌入式操作系统发展概述

1.2.3Linux操作系统特点

1.2.4嵌入式Linux系统的特点

1.2.5国外嵌入式Linux发展现状

1.2.6国内嵌入式Linux发展现状

1.3ARM处理器平台介绍

1.3.1嵌入式处理器特点与分类

1.3.2ARM处理器介绍

1.3.3ARM体系结构

1.4嵌入式Linux的体系结构分析

1.4.1嵌入式系统的体系结构

1.4.2硬件抽象层的Linux

1.5基本编辑器vi的使用

1.5.1进入和退出vi

1.5.2vi的基本编辑命令

1.5.3vi的高级编辑命令

1.6高级编辑器Emacs的使用

1.6.1Emacs的启动与退出

1.6.2Emacs的基本操作

1.6.3Emacs的高级命令

1.7编译器GCC的使用

1.7.1GCC简介

1.7.2GCC的编译过程

1.7.3GCC的常用模式

7.4GCC的常用选项

1.7.5GCC的警告功能

1.8调试器GDB的使用

1.8.1GDB的调试过程

1.8.2GDB的基本命令

1.8.3GDB的高级命令

1.9Make工程管理器

1.9.1Make管理器简介

1.9.2Makefile的描述规则

1.9.3一个简单示例

1.9.4Make如何工作

1.9.5指定变量

1.9.6自动推导规则

1.9.7另类风格的Makefile

1.9.8清除工作目录过程文件

1.10本章小结

第2章嵌入式Linux内核分析与移植

2.1Linux内核版本

2.1.1日新月异的Linux内核版本

2.1.2Linux2.4内核特性

2.1.3Linux2.6内核针对嵌入式系统的改进

2.2Linux操作系统内核结构分析

2.2.1Linux核心源程序的文件组织结构

2.2.2Linux的内核组成

2.2.3Linux内核进程管理工作机制

2.2.4Linux内存管理工作机制

2.2.5Linux虚拟文件系统工作机制

2.2.6进程间通信

2.3搭建嵌入式Linux系统开发环境

2.3.1嵌入式平台介绍

2.3.2嵌入式Linux系统的组成及设计步骤

2.3.3嵌入式Linux开发工具链

2.4Linux内核配置基础

2.4.1Linux内核所支持的配置方式

2.4.2makemenuconfig配置方法

2.4.3Linux2.4内核配置文件config .in介绍

2.4.4Linux2.6内核Kconfig文件的用法

2.4.5Kconfig文件配置实例

2.5Linux内核配置选项

2.5.1Generalsetup

2.5.2Loadablemodulesupport

2.5.3Processortypeandfeatures

2.5.4Networkingsupport

2.5.5DeviceDrivers

2.6Linux内核编译基础

2.6.1Linux内核编译基本步骤

2.6.2Rules.make文件用法

2.6.3Makefile配置文件的用法

2.6.4配置、编译Linux内核命令说明

2.6.5Linux内核配置编译实例

2.7Linux内核移植

2.7.1Bootloader简介

2.7.2引导程序原理

2.7.3内核移植及代码分析

2.7.4VIVI结构分析

2.7.5VIVI移植实现

2.8本章小结

第3章Linux设备驱动程序开发概述

3.1Linux系统设备概述

3.1.1字符设备

3.1.2块设备

3.1.3网络设备

3.1.4Linux设备驱动程序的共性

3.2设备驱动程序的概念

3.3设备驱动程序与内核的接口

3.4内核为驱动程序提供的支持

3.4.1内存分配函数

3.4.2DMA

3.4.3I/O端口

3.4.4打印函数

3.5主要数据结构

3.5.1structdevicestruct

3.5.2structfileoperations

3.5.3structinode

3.6模块化的概念

3.7内存管理问题

3.7.1Linux内核对内存的管理方法

3.7.2kmalloc()和kfree()

3.7.3面向页的分配技术

3.7.4vmalloc()和相关函数

3.8中断响应和处理

3.8.1中断处理机制

3.8.2中断处理的数据结构

3.8.3中断处理中的3个重要概念

3.8.4申请和释放中断

3.8.5自动检测中断号

3.8.6快/慢速中断处理

3.8.7实现中断处理程序

3.8.8驱动程序下半部的设计

3.8.9安装共享的处理程序

3.9I/O端口

3.10DMA处理

3.11时间流

3.11.1时钟的申请与释放

3.11.2实现延迟

3.11.3任务队列

3.12编写、编译和调试

3.13本章小结

第4章Linux字符设备驱动程序开发

4.1Linux字符设备驱动程序结构

4.2字符设备驱动的相似点

4.3主设备号和次设备号

4.4字符设备驱动程序的组成

4.5字符驱动程序模型

4.6可靠性机制

4.7文件操作

4.8字符设备驱动程序中用到的主要数据结构

4.9字符设备的注册和注销

4.10使用内存和读写I/O端口

4.11字符设备驱动程序中用到的主要函数

4.12chardevxxx设备的驱动程序设计

4.13Linux2.6内核下的字符设备驱动介绍

4.13.1cdev结构体

4.13.2分配和释放设备号

4.13.3file_operations结构体

4.13.4字符设备驱动模块加载与卸载函数

4.13.5字符设备驱动的file_operations结构体中成员

4.14globalmem设备驱动

4.14.1头文件、宏及设备结构体

4.14.2加载与卸载设备驱动

4.14.3读写函数

4.14.4seek函数

4.14.5globalmem的ioctl()函数

4.14.6ioctl()命令

4.14.7预定义命令

4.14.8使用文件私有数据

4.14.9globalmem驱动在用户空间的验证

4.15本章小结

第5章基于DSP的PCI图像采集卡驱动程序

5.1PCI总线介绍

5.1.1PCI总线概述

5.1.2PCI局部总线概述

5.1.3PCI局部总线的特点

5.1.4PCI总线信号

5.1.5PCI总线命令

5.1.6PCI总线配置空间

5.1.7PCI总线配置过程

5.1.8PCI总线的传输控制

5.2DSP图像卡的PCI接口设计

5.2.1系统结构介绍

5.2.2PCI2040的基本特点

5.2.3PCI2040芯片的功能单元

5.2.4PCI2040配置流程

5.2.5PCI总线与DSP的接口实现

5.2.6串行E2PROM的初始化

5.3DSP图像卡驱动程序实例分析

5.3.1主要的数据结构

5.3.2驱动程序流程

5.3.3初始化设备模块

5.3.4打开设备模块

5.3.5数据读写和控制信息模块

5.3.6中断处理模块

5.3.7释放设备模块

5.3.8卸载设备模块

5.4本章小结

第6章音频接口设计与Linux驱动程序

6.1嵌入式音频系统简介

6.1.1S3C2410微处理器简介

6.1.2S3C2410微处理器的结构框图及其特性

6.1.3系统设计概述

6.1.4系统时钟电路

6.1.5S3C2410存储控制器介绍

6.1.6SDRAM电路

6.1.7Flash缓冲电路设计

6.1.8NORFlash电路

6.1.9NANDFlash接口电路

6.1.10IIS数字音频电路

6.1.11串口电路

6.1.12JTAG接口电路

6.1.13LCD和触摸屏接口电路

6.2UDA1341TS芯片设备驱动程序设计

6.2.1UDA1341TS芯片介绍

6.2.2驱动程序中file_operations数据结构

6.2.3驱动程序的加载和卸载

6.3SOUND驱动的实现

6.3.1SOUND设备的打开和释放

6.3.2定义SOUND设备的读写函数

6.3.3SOUND设备的控制操作处理

6.3.4SOUND设备驱动程序的其他部分

6.3.5Mixer驱动的实现

6.4本章小结

第7章显示设备接口设计与Linux驱动程序

7.1嵌入式显示系统简介

7.2显示驱动的基础与原理

7.2.1时序信号

7.2.2TFTLCD的驱动技术

7.2.3TFTLCD驱动电路

7.2.4像素值的属性

7.2.5像素深度、像素值与颜色的映射关系

7.2.6像素值与显示内存的映射关系

7.2.7调色板的原理

7.2.8调色板的作用

7.2.9彩色LCD显示驱动的原理

7.3软、硬件平台简介

7.3.1硬件开发平台

7.3.2软件平台

7.3.3软件开发环境

7.4基于PXA255的显示功能的硬件实现

7.4.1PXA255处理器介绍

7.4.2PXA255的LCD控制器的特点

7.4.3LCD控制器的使用

7.4.4LCD控制寄存器配置

7.4.5设定DMA通道

7.4.6Sony彩屏的特性

7.4.7LCD与处理器的硬件连接方案

7.5显示驱动开发介绍

7.5.1显示驱动与字符设备的关系

7.5.2显示驱动的发展

7.5.3当前显示驱动的不足

7.6基于PXA255的显示驱动的实现

7.6.1显示驱动的系统分析

7.6.2驱动上层文件的功能

7.6.3驱动底层文件的功能

7.6.4驱动程序底层文件实现的基础

7.7基于PXA255的显示功能的软件方案

7.7.1上层文件的实现

7.7.2底层文件的实现方案

7.7.3驱动底层文件的实现

7.7.4针对XScale架构中其余处理器的移植

7.8本章小结

第8章ARMLinux块设备驱动程序开发

8.1块设备驱动程序开发概述

8.1.1块设备特点

8.1.2块设备基于缓冲区的数据交换

8.1.3块设备读写请求

8.1.4块设备驱动程序模型

8.1.5基于内存的块设备驱动程序

8.2Linux块设备驱动结构

8.2.1block_device_operations结构体

8.2.2gendisk结构体

8.2.3request与bio结构体

8.3块设备驱动主要函数

8.3.1块设备驱动程序的注册与注销

8.3.2Linux块设备驱动模块加载与卸载

8.3.3块设备的打开与释放

8.3.4块设备驱动的ioctl函数

8.3.5块设备驱动I/O请求处理

8.4RAMDISK驱动开发实例

8.4.1RAMDISK的硬件原理

8.4.2RAMDISK驱动模块加载与卸载

8.4.3RAMDISK设备驱动block_device_operations及成员函数

8.5IDE硬盘设备驱动开发实例

8.5.1IDE硬盘设备原理

8.5.2IDE硬盘设备驱动block_device_operations及成员函数

8.5.3IDE硬盘设备驱动I/O请求处理

8.5.4在内核中增加对新系统IDE设备的支持

8.6本章小结

第9章嵌入式Linux网络设备驱动程序开发

9.1嵌入式以太网基础知识

9.1.1以太网技术及其嵌入式应用

9.1.2嵌入式系统中主要处理的网络协议

9.1.3ARP（AddressResolutionProtocol）地址解析协议

9.1.4IP（InternetProtocol）网际协议

9.1.5TCP（TransferControlProtocol）传输控制协议

9.1.6UDP（UserDatagramProtocol）用户数据包协议

9.2基于CS8900A芯片的设备驱动设计

9.2.1CS8900A芯片结构

9.2.2CS8900A芯片特性

9.2.3CS8900A芯片工作原理

9.2.4CS8900A芯片工作模式

9.2.5网络设备驱动程序基本结构

9.3基于Linux的网络设备驱动开发常用的数据结构

9.3.1数据结构structnet_device

9.3.2数据结构structsk_buff393

9.4网络驱动程序的实现模式及系统调用方法

9.4.1网络驱动程序的实现模式与模块化

9.4.2内存获取与释放

9.4.3链路状态改变系统调用

9.4.4与网络层交互数据包的函数

9.5网络驱动程序的基本方法

9.5.1网络驱动程序的结构

9.5.2初始化（Initialize）

9.5.3打开（open）

9.5.4关闭（close）

9.5.5发送（hard_start_xmit）

9.5.6接收（reception）

9.5.7中断处理（interrupt）

9.5.8硬件帧头（hard_header）

9.5.9地址解析（XARP）

9.5.10参数设置和统计数据

9.5.11多播（set_multicast_list）

9.6本章小结

第10章嵌入式LinuxUSB驱动程序设计基础

10.1USB总线协议背景知识

10.1.1USB协议的产生

10.1.2USB的特点

10.1.3USB的广泛应用

10.1.4USB在嵌入式设备中的应用

10.1.5计算机常用外部总线比较

10.2USB总线技术介绍

10.2.1USB系统拓扑结构

10.2.2USB总线逻辑结构

10.2.3USB总线特性介绍

10.2.4USB总线电气机械特性

10.2.5USB的即插即用特性

10.2.6鲁棒性的实现

10.2.7USB电源管理

10.2.8总线通道

10.2.9传输协议

10.2.10传输类型

10.2.11设备框架

10.2.12USB主机协议

10.3LinuxUSB子系统结构

10.3.1文件系统

10.3.2Linux中USB子系统的软件结构及实现

10.3.3LinuxUSB内核的主要数据结构

10.3.4USB内核函数接口分析

10.4本章小结

第11章USB接口系统软件设计

11.1USB系统软件设计概述

11.1.1主机端设备驱动程序

11.1.2主机控制器驱动程序

11.1.3设备端驱动程序

11.1.4数据管道和数据块结构

11.2USB设备端软件的开发

11.2.1USB设备通用模块的软件开发

11.2.2USB设备协议模块的软件开发

11.2.3控制端点处理程序

11.2.4协议层程序

11.3USB主机端软件开发

11.3.1Linux内核对USB规范的支持

11.3.2USB时序

11.3.3主机控制器驱动程序设计

11.3.4主机控制器的初始化和管理

11.3.5传输执行和资源调度

11.3.6主机控制器的中断处理

11.3.7虚拟根集线器

11.3.8主机控制器驱动程序的任务

11.3.9URB在驱动软件中运作

11.3.10主机端设备驱动程序

11.4本章小结

第12章OTG驱动功能模块的设计与实现

12.1OTG概述

12.1.1OTG特性简介

12.1.2A设备事件

12.1.3B设备事件

12.1.4状态机

12.1.5SRP

12.1.6HNP

12.2设备模块的设计与实现

12.2.1USB设备的状态

12.2.2OTG驱动功能模块的设计

12.2.3ISP1761结构

12.2.4HAL的设计和实现

12.2.5HCD的设计和实现

12.2.6USBD接口模块

12.2.7ISP1761读写操作模块

12.2.8HCD初始化模块

12.2.9中断管理模块

12.2.10根集线器模块

12.2.11数据传输模块

12.2.12设备模块的设计和实现

12.2.13OTGFSM的设计和实现

12.3本章小结

linux驱动开发主要要开发哪些驱动

Linux下PCI设备驱动开发

1. 关键数据结构

PCI设备上有三种地址空间：PCI的I/O空间、PCI的存储空间和PCI的配置空间。CPU可以访问PCI设备上的所有地址空间，其中I/O空间和存储空间提供给设备驱动程序使用，而配置空间则由Linux内核中的PCI初始化代码使用。内核在启动时负责对所有PCI设备进行初始化，配置好所有的PCI设备，包括中断号以及I/O基址，并在文件/proc/pci中列出所有找到的PCI设备，以及这些设备的参数和属性。

Linux驱动程序通常使用结构（struct）来表示一种设备，而结构体中的变量则代表某一具体设备，该变量存放了与该设备相关的所有信息。好的驱动程序都应该能驱动多个同种设备，每个设备之间用次设备号进行区分，如果采用结构数据来代表所有能由该驱动程序驱动的设备，那么就可以简单地使用数组下标来表示次设备号。

在PCI驱动程序中，下面几个关键数据结构起着非常核心的作用：

pci_driver

这个数据结构在文件include/linux/pci.h里，这是Linux内核版本2.4之后为新型的PCI设备驱动程序所添加的，其中最主要的是用于识别设备的id_table结构，以及用于检测设备的函数probe( )和卸载设备的函数remove( )：

struct pci_driver {

struct list_head node;

char *name;

const struct pci_device_id *id_table;

int (*probe) (struct pci_dev *dev, const struct pci_device_id *id);

void (*remove) (struct pci_dev *dev);

int (*save_state) (struct pci_dev *dev, u32 state);

int (*suspend)(struct pci_dev *dev, u32 state);

int (*resume) (struct pci_dev *dev);

int (*enable_wake) (struct pci_dev *dev, u32 state, int enable);

};

pci_dev

这个数据结构也在文件include/linux/pci.h里，它详细描述了一个PCI设备几乎所有的

硬件信息，包括厂商ID、设备ID、各种资源等：

struct pci_dev {

struct list_head global_list;

struct list_head bus_list;

struct pci_bus *bus;

struct pci_bus *subordinate;

void *sysdata;

struct proc_dir_entry *procent;

unsigned int devfn;

unsigned short vendor;

unsigned short device;

unsigned short subsystem_vendor;

unsigned short subsystem_device;

unsigned int class;

u8 hdr_type;

u8 rom_base_reg;

struct pci_driver *driver;

void *driver_data;

u64 dma_mask;

u32 current_state;

unsigned short vendor_compatible[DEVICE_COUNT_COMPATIBLE];

unsigned short device_compatible[DEVICE_COUNT_COMPATIBLE];

unsigned int irq;

struct resource resource[DEVICE_COUNT_RESOURCE];

struct resource dma_resource[DEVICE_COUNT_DMA];

struct resource irq_resource[DEVICE_COUNT_IRQ];

char name[80];

char slot_name[8];

int active;

int ro;

unsigned short regs;

int (*prepare)(struct pci_dev *dev);

int (*activate)(struct pci_dev *dev);

int (*deactivate)(struct pci_dev *dev);

};

2. 基本框架

在用模块方式实现PCI设备驱动程序时，通常至少要实现以下几个部分：初始化设备模块、设备打开模块、数据读写和控制模块、中断处理模块、设备释放模块、设备卸载模块。下面给出一个典型的PCI设备驱动程序的基本框架，从中不难体会到这几个关键模块是如何组织起来的。

/* 指明该驱动程序适用于哪一些PCI设备 */

static struct pci_device_id demo_pci_tbl [] __initdata = {

{PCI_VENDOR_ID_DEMO, PCI_DEVICE_ID_DEMO,

PCI_ANY_ID, PCI_ANY_ID, 0, 0, DEMO},

{0,}

};

/* 对特定PCI设备进行描述的数据结构 */

struct demo_card {

unsigned int magic;

/* 使用链表保存所有同类的PCI设备 */

struct demo_card *next;

/* ... */

}

/* 中断处理模块 */

static void demo_interrupt(int irq, void *dev_id, struct pt_regs *regs)

{

/* ... */

}

/* 设备文件操作接口 */

static struct file_operations demo_fops = {

owner: THIS_MODULE, /* demo_fops所属的设备模块 */

read: demo_read, /* 读设备操作*/

write: demo_write, /* 写设备操作*/

ioctl: demo_ioctl, /* 控制设备操作*/

mmap: demo_mmap, /* 内存重映射操作*/

open: demo_open, /* 打开设备操作*/

release: demo_release /* 释放设备操作*/

/* ... */

};

/* 设备模块信息 */

static struct pci_driver demo_pci_driver = {

name: demo_MODULE_NAME, /* 设备模块名称 */

id_table: demo_pci_tbl, /* 能够驱动的设备列表 */

probe: demo_probe, /* 查找并初始化设备 */

remove: demo_remove /* 卸载设备模块 */

/* ... */

};

static int __init demo_init_module (void)

{

/* ... */

}

static void __exit demo_cleanup_module (void)

{

pci_unregister_driver(&demo_pci_driver);

}

/* 加载驱动程序模块入口 */

module_init(demo_init_module);

/* 卸载驱动程序模块入口 */

module_exit(demo_cleanup_module);

上面这段代码给出了一个典型的PCI设备驱动程序的框架，是一种相对固定的模式。需要注意的是，同加载和卸载模块相关的函数或数据结构都要在前面加上__init、__exit等标志符，以使同普通函数区分开来。构造出这样一个框架之后，接下去的工作就是如何完成框架内的各个功能模块了。

3. 初始化设备模块

在Linux系统下，想要完成对一个PCI设备的初始化，需要完成以下工作：

检查PCI总线是否被Linux内核支持；

检查设备是否插在总线插槽上，如果在的话则保存它所占用的插槽的位置等信息。

读出配置头中的信息提供给驱动程序使用。

当Linux内核启动并完成对所有PCI设备进行扫描、登录和分配资源等初始化操作的同时，会建立起系统中所有PCI设备的拓扑结构，此后当PCI驱动程序需要对设备进行初始化时，一般都会调用如下的代码：

static int __init demo_init_module (void)

{

/* 检查系统是否支持PCI总线 */

if (!pci_present())

return -ENODEV;

/* 注册硬件驱动程序 */

if (!pci_register_driver(&demo_pci_driver)) {

pci_unregister_driver(&demo_pci_driver);

return -ENODEV;

}

/* ... */

return 0;

}

驱动程序首先调用函数pci_present( )检查PCI总线是否已经被Linux内核支持，如果系统支持PCI总线结构，这个函数的返回值为0，如果驱动程序在调用这个函数时得到了一个非0的返回值，那么驱动程序就必须得中止自己的任务了。在2.4以前的内核中，需要手工调用pci_find_device( )函数来查找PCI设备，但在2.4以后更好的办法是调用pci_register_driver( )函数来注册PCI设备的驱动程序，此时需要提供一个pci_driver结构，在该结构中给出的probe探测例程将负责完成对硬件的检测工作。

static int __init demo_probe(struct pci_dev *pci_dev, const struct

pci_device_id *pci_id)

{

struct demo_card *card;

/* 启动PCI设备 */

if (pci_enable_device(pci_dev))

return -EIO;

/* 设备DMA标识 */

if (pci_set_dma_mask(pci_dev, DEMO_DMA_MASK)) {

return -ENODEV;

}

/* 在内核空间中动态申请内存 */

if ((card = kmalloc(sizeof(struct demo_card), GFP_KERNEL)) == NULL) {

printk(KERN_ERR "pci_demo: out of memory\n");

return -ENOMEM;

}

memset(card, 0, sizeof(*card));

/* 读取PCI配置信息 */

card->iobase = pci_resource_start (pci_dev, 1);

card->pci_dev = pci_dev;

card->pci_id = pci_id->device;

card->irq = pci_dev->irq;

card->next = devs;

card->magic = DEMO_CARD_MAGIC;

/* 设置成总线主DMA模式 */

pci_set_master(pci_dev);

/* 申请I/O资源 */

request_region(card->iobase, 64, card_names[pci_id->driver_data]);

return 0;

}

4. 打开设备模块

在这个模块里主要实现申请中断、检查读写模式以及申请对设备的控制权等。在申请控制权的时候，非阻塞方式遇忙返回，否则进程主动接受调度，进入睡眠状态，等待其它进程释放对设备的控制权。

static int demo_open(struct inode *inode, struct file *file)

{

/* 申请中断，注册中断处理程序 */

request_irq(card->irq, &demo_interrupt, SA_SHIRQ,

card_names[pci_id->driver_data], card)) {

/* 检查读写模式 */

if(file->f_mode & FMODE_READ) {

/* ... */

}

if(file->f_mode & FMODE_WRITE) {

/* ... */

}

/* 申请对设备的控制权 */

down(&card->open_sem);

while(card->open_mode & file->f_mode) {

if (file->f_flags & O_NONBLOCK) {

/* NONBLOCK模式，返回-EBUSY */

up(&card->open_sem);

return -EBUSY;

} else {

/* 等待调度，获得控制权 */

card->open_mode |= f_mode & (FMODE_READ | FMODE_WRITE);

up(&card->open_sem);

/* 设备打开计数增1 */

MOD_INC_USE_COUNT;

/* ... */

}

5. 数据读写和控制信息模块

PCI设备驱动程序可以通过demo_fops 结构中的函数demo_ioctl( )，向应用程序提供对硬件进行控制的接口。例如，通过它可以从I/O寄存器里读取一个数据，并传送到用户空间里：

static int demo_ioctl(struct inode *inode, struct file *file, unsigned int

cmd, unsigned long arg)

{

/* ... */

switch(cmd) {

case DEMO_RDATA:

/* 从I/O端口读取4字节的数据 */

val = inl(card->iobae + 0x10);

/* 将读取的数据传输到用户空间 */

return 0;

}

/* ... */

}

事实上，在demo_fops里还可以实现诸如demo_read( )、demo_mmap( )等操作，Linux内核源码中的driver目录里提供了许多设备驱动程序的源代码，找那里可以找到类似的例子。在对资源的访问方式上，除了有I/O指令以外，还有对外设I/O内存的访问。对这些内存的操作一方面可以通过把I/O内存重新映射后作为普通内存进行操作，另一方面也可以通过总线主DMA（Bus Master DMA）的方式让设备把数据通过DMA传送到系统内存中。

6. 中断处理模块

PC的中断资源比较有限，只有0~15的中断号，因此大部分外部设备都是以共享的形式申请中断号的。当中断发生的时候，中断处理程序首先负责对中断进行识别，然后再做进一步的处理。

static void demo_interrupt(int irq, void *dev_id, struct pt_regs *regs)

{

struct demo_card *card = (struct demo_card *)dev_id;

u32 status;

spin_lock(&card->lock);

/* 识别中断 */

status = inl(card->iobase + GLOB_STA);

if(!(status & INT_MASK))

{

spin_unlock(&card->lock);

return; /* not for us */

}

/* 告诉设备已经收到中断 */

outl(status & INT_MASK, card->iobase + GLOB_STA);

spin_unlock(&card->lock);

/* 其它进一步的处理，如更新DMA缓冲区指针等 */

}

7. 释放设备模块

释放设备模块主要负责释放对设备的控制权，释放占用的内存和中断等，所做的事情正好与打开设备模块相反：

static int demo_release(struct inode *inode, struct file *file)

{

/* ... */

/* 释放对设备的控制权 */

card->open_mode &= (FMODE_READ | FMODE_WRITE);

/* 唤醒其它等待获取控制权的进程 */

wake_up(&card->open_wait);

up(&card->open_sem);

/* 释放中断 */

free_irq(card->irq, card);

/* 设备打开计数增1 */

MOD_DEC_USE_COUNT;

/* ... */

}

8. 卸载设备模块

卸载设备模块与初始化设备模块是相对应的，实现起来相对比较简单，主要是调用函数pci_unregister_driver( )从Linux内核中注销设备驱动程序：

static void __exit demo_cleanup_module (void)

{

pci_unregister_driver(&demo_pci_driver);

}

小结

PCI总线不仅是目前应用广泛的计算机总线标准，而且是一种兼容性最强、功能最全的计算机总线。而Linux作为一种新的操作系统，其发展前景是无法估量的，同时也为PCI总线与各种新型设备互连成为可能。由于Linux源码开放，因此给连接到PCI总线上的任何设备编写驱动程序变得相对容易。本文介绍如何编译Linux下的PCI驱动程序，针对的内核版本是2.4。

做linux下的驱动开发,需要掌握哪些技能和知识点?有没具体的要求列一下.谢谢各位

您好：做嵌入式应用的话一般的编程就可以了。那么嵌入式驱动开发与内核开发的话就需要学习多个方面的知识。我就把这方面的要求给你交流一下：

（一家之言啊，自己多年从事嵌入式开发的一点感悟）

嵌入式驱动开发需要了解的知识大概有以下几类：

1 嵌入式操作系统驱动框架。每一个操作系统都有自己的构架，应该了解驱动在整个系统中的具体位置与构建驱动程序的主要事项

2 总线知识，比如PCI、USB总线。

3 芯片知识。驱动其实就是对设备上一些寄存器的配置、CPU与设备本身的通讯以及对不同命令的处理

4 要做好驱动，必须对所使用的CPU体系结构有一个比较深刻的认识

5 C++基本用不上，主要是C和汇编。

6 做驱动最好要懂内核调试（比如说linux）

linux驱动工程师有前途吗linux驱动工程师

.您要驱动什么东西？抛开Linux系统的约束，您对要驱动的东西是如何工作的、如何去编程驱动它了解吗？是一点不了解？半知半解？一般了解？还是熟知？精通？如果对要驱动的东西都不了解，或者纯粹就想泛泛地学习Linux驱动编程，估计收获不会很大。

2.做过多线程编程吗？为什么要多线程？深刻理会了多线程中如何访问临界资源，如何使用mutex,semaphore？多个线程工作起来，怎么控制它们像我们几个人一起协作干活那样，该各干各的，又该相互通知与配合呢？

3.如果把操作系统比作一个大的执行程序，那么驱动程序就相当于以动态链接库形式提供的“插件”。您有没有做过“插件”式的应用程序？没做过也没关系，您认真思考一下这样的问题：您要做一个控制小车的程序，您这个程序功能很牛X，您希望无论是张家的小车，还是李家的小车都能被您控制，无奈您手头上只有牛家的小车，但你明白，张家、李家的小车功能和你牛家的差不多，控制也就那些事，就是目前不知道具体该如何控制。您得想个法子，留好接口，尽可能保证以后张家、李家的小车都可以被你的程序控制——这时候，你的程序该怎么设计结构比较好呢？

4.CPU在时钟脉冲“PIA-PIA”的节奏下都在干些什么？无论是X86或是ARM，要做驱动，对这个还是得有点基本的了解。

5.保护模式，虚拟内存，大致的道理明白吗？这个得知道。咱们现在大多数的处理器都有cache，cache干啥用？对DMA会有些什么不良影响？这个如果要搞DMA（例如PCI设备驱动）需要明白。

6.按楼上的兄弟说的，找本LDD学习

7.总的来说，设备驱动程序干的是驱动硬件的活，但它的编写更需要注重软件的思路、结构和方法。前面说的写小车控制程序能一定程度上说明这个问题。当然，听起来好像有点难，但是干起来还是挺爽的，没有想的那么复杂

怎样编写Linux设备驱动程序？

Linux内核和驱动开发工程师的发展前景怎么样？

我亲身体验，我之前是做数控系统开发的，做了有七八年，有x86的产品也有arm的产品，x86的linux相对开发驱动的地方不多，arm上比较多，存储，显示的，usb的，各种总线的，音频的，网络的，很多地方只要有订制需求都要改。驱动开门槛比较高，主要会软件还得了解些硬件知识，硬件的原理图，设备的数据手册，工作特性都要会，入门难但是一旦入门了就跟其他的一样做多了就熟悉了。之前公司是linux+qt，今年离职了进了一家安卓开发的公司，现在还在做安卓的驱动开发，感觉大同小异，只是硬件平台变了，开发的内容仍是没变。驱动这一块，人比较少，相对待遇也会好一些，现在我也不知道未来会不会随着年龄越大，会被淘汰掉，但是linux本身的应用范围是挺广的，而且作为一个成功的开源项目，只要社会有需求，后面应该还是会被广泛应用，至于个人就看自己的能力和精力了!

嵌入式LINUX驱动工程师的待遇怎么样？

一般，工作经验在1-2年的嵌入式工程师薪水，基本会在5000-8000元的范围，而随着工作年限的增加，薪资水平也会有较明显的提高。3年工作经验的1-2万，基本不成问题。我有一个大学同学2013年在华清远见学习过嵌入式开发，现在工资都上万了！就看你自己怎么想

嵌入式工程师与后端开发哪个难

嵌入式工程师与后端开发相比还是嵌入式工程师比较难。嵌入式驱动工程师：编写和移植各种芯片驱动(如音频芯片)，优化硬件设备驱动(如温湿度传感器)，得精通各种硬件接口协议(如I2C协议)、系统调度、信号量、锁机制等等，开发难度最大。

该类开发者一般是软硬件综合型人才，一般的嵌入式驱动工程师指LINUX上的驱动开发工程师，需要精通Linux驱动框架(platform框架、input子系统框架等)，结合芯片本身去编写驱动，驱动的好坏很大程度上决定一个产品的好坏。

业界对驱动人才的定义是三年才算入门，可见此门槛之高。

Linux是Unix操作系统的一种变种，在Linux下编写驱动程序的原理和思想完全类似于其他的Unix系统，但它dos或window环境下的驱动程序有很大的区别。在Linux环境下设计驱动程序，思想简洁，操作方便，功能也很强大，但是支持函数少，只能依赖kernel中的函数，有些常用的操作要自己来编写，而且调试也不方便。本人这几周来为实验室自行研制的一块多媒体卡编制了驱动程序，获得了一些经验，愿与Linux fans共享

一、Linux device driver 的概念系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口。设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。设备驱动程序是内核的一部分，它完成以下的功能：

1.对设备初始化和释放。

2.把数据从内核传送到硬件和从硬件读取数据。

3.读取应用程序传送给设备文件的数据和回送应用程序请求的数据。

4.检测和处理设备出现的错误。

二、实例剖析我们来写一个最简单的字符设备驱动程序。虽然它什么也不做，但是通过它可以了解Linux的设备驱动程序的工作原理。

好了，今天关于“linux 驱动程序开发”的话题就讲到这里了。希望大家能够通过我的讲解对“linux 驱动程序开发”有更全面、深入的了解，并且能够在今后的学习中更好地运用所学知识。