本节主要看全局变量和局部变量，程序越来越长，可以跳开查看。

全局变量在程序开始定义赋值的话，存放在Data块，Data块可以通过静态反汇编获得。
局部变量定义在函数内部，使用的时候需要类似sub     esp,10h，开辟空间存放

需要掌握：
静态反汇编工具
变量存放地点
sub

简单了解：
读取全局变量的方法：1，获取全局变量存放地址。2，偏移量与实际内存地址关系。

不需了解：
w32asm反汇编以后，需要复制其中内容的，先保存为alf文件，再用文本读取程序打开。

所用程序：bz4

#include <ntddk.h>

ULONG au1,au2;
ULONG au3 = 7;
ULONG au4 = 9;

ULONG MyAdd1(ULONG u1,ULONG u2)
{
   return u1+u2;

}
 
ULONG MyAdd2(ULONG u1,ULONG u2)
{
   ULONG u3;
   u3 = u1+u2;
   return u3;  
  

}

ULONG MyAdd3(ULONG u1,ULONG u2)
{
   ULONG u3,u4,u5,u6;
   u3 = u1+u2;
   u4 = u3+u1;
   u5 = u1;
   u6 = u1+u3;
   return u3+u4+u5+u6;  
  

}

VOID DriverUnload(PDRIVER_OBJECT driver)
{
 
 DbgPrint("unload…\r\n");
}

NTSTATUS DriverEntry(PDRIVER_OBJECT driver, PUNICODE_STRING reg_path)
{
 ULONG x1 = 5;
 ULONG x2 = 8;
 ULONG x3 ;
 
 
#if DBG
       _asm int 3
#endif
 
 
 au1 = MyAdd1(x1,x2);  //使用自定义函数，反汇编看看结果
 
 DbgPrint("au1 Result:%d\n!",au1);
 
 au2 = MyAdd2(x1,x2);  //使用自定义函数，反汇编看看结果
 
 DbgPrint("au2 Result:%d\n!",au2);
 
 x3 = MyAdd3(x1,x2);  //使用自定义函数，反汇编看看结果
 
 DbgPrint("Result:%d\n!",x3);
 
 DbgPrint("au3 Result:%d\n!",au3);
 DbgPrint("au4 Result:%d\n!",au4);
 
 driver->DriverUnload = DriverUnload;
 return STATUS_SUCCESS;
}

接下来要用w32asm和windbg反汇编，看其中对应关系，都是从55F到5B1，显然一一对应，只是前面地址有偏移。
我们知道，Data Offset是Data数据段，存放的是全局变量。本程序全局变量是：
ULONG au3 = 7;
ULONG au4 = 9;
显然我们dd 00000700是看不到数据的，要dd f84f7700，等我们运行起来的时候，看看是不是

w32asm反汇编：

Code Offset = 00000480, Code Size = 00000200
Data Offset = 00000700, Data Size = 00000080
...............

:0001055F 52                      push edx

* Possible StringData Ref from Code Obj ->"au1 Result:%d
!"
                                  |
:00010560 6850060100              push 00010650

* Reference To: ntoskrnl.DbgPrint, Ord:0030h
                                  |
:00010565 E888000000              Call 000105F2
:0001056A 83C408                  add esp, 00000008
:0001056D 8B45FC                  mov eax, dword ptr [ebp-04]
:00010570 50                      push eax
:00010571 8B4DF8                  mov ecx, dword ptr [ebp-08]
:00010574 51                      push ecx
:00010575 E836FFFFFF              call 000104B0
:0001057A A310070100              mov dword ptr [00010710], eax
:0001057F 8B1510070100            mov edx, dword ptr [00010710]
:00010585 52                      push edx
:00010586 6840060100              push 00010640

* Reference To: ntoskrnl.DbgPrint, Ord:0030h
                                  |
:0001058B E862000000              Call 000105F2
:00010590 83C408                  add esp, 00000008
:00010593 8B45FC                  mov eax, dword ptr [ebp-04]
:00010596 50                      push eax
:00010597 8B4DF8                  mov ecx, dword ptr [ebp-08]
:0001059A 51                      push ecx
:0001059B E830FFFFFF              call 000104D0
:000105A0 8945F4                  mov dword ptr [ebp-0C], eax
:000105A3 8B55F4                  mov edx, dword ptr [ebp-0C]
:000105A6 52                      push edx

* Possible StringData Ref from Code Obj ->"Result:%d
!"
                                  |
:000105A7 6830060100              push 00010630

* Reference To: ntoskrnl.DbgPrint, Ord:0030h
                                  |
:000105AC E841000000              Call 000105F2
:000105B1 83C408                  add esp, 00000008

主函数中主要反汇编代码，也就是调用几个自定义函数的部分：

   57 f84f755f 52              push    edx
   57 f84f7560 6850764ff8      push    offset bz4! ?? ::FNODOBFM::`string' (f84f7650)
   57 f84f7565 e888000000      call    bz4!DbgPrint (f84f75f2)
   57 f84f756a 83c408          add     esp,8
   59 f84f756d 8b45fc          mov     eax,dword ptr [ebp-4]
   59 f84f7570 50              push    eax
   59 f84f7571 8b4df8          mov     ecx,dword ptr [ebp-8]
   59 f84f7574 51              push    ecx
   59 f84f7575 e836ffffff      call    bz4!MyAdd2 (f84f74b0)
   59 f84f757a a310774ff8      mov     dword ptr [bz4!au2 (f84f7710)],eax
   61 f84f757f 8b1510774ff8    mov     edx,dword ptr [bz4!au2 (f84f7710)]
   61 f84f7585 52              push    edx
   61 f84f7586 6840764ff8      push    offset bz4! ?? ::FNODOBFM::`string' (f84f7640)
   61 f84f758b e862000000      call    bz4!DbgPrint (f84f75f2)
   61 f84f7590 83c408          add     esp,8
   63 f84f7593 8b45fc          mov     eax,dword ptr [ebp-4]
   63 f84f7596 50              push    eax
   63 f84f7597 8b4df8          mov     ecx,dword ptr [ebp-8]
   63 f84f759a 51              push    ecx
   63 f84f759b e830ffffff      call    bz4!MyAdd3 (f84f74d0)
   63 f84f75a0 8945f4          mov     dword ptr [ebp-0Ch],eax
   65 f84f75a3 8b55f4          mov     edx,dword ptr [ebp-0Ch]
   65 f84f75a6 52              push    edx
   65 f84f75a7 6830764ff8      push    offset bz4! ?? ::FNODOBFM::`string' (f84f7630)
   65 f84f75ac e841000000      call    bz4!DbgPrint (f84f75f2)
   65 f84f75b1 83c408          add     esp,8

三个自定义函数

kd> uf bz4!myadd1
bz4!MyAdd1 [d:\mydriver\bz4\bz4.c @ 9]:
    9 f84f7490 8bff            mov     edi,edi
    9 f84f7492 55              push    ebp
    9 f84f7493 8bec            mov     ebp,esp
   10 f84f7495 8b4508          mov     eax,dword ptr [ebp+8]
   10 f84f7498 03450c          add     eax,dword ptr [ebp+0Ch]
   12 f84f749b 5d              pop     ebp
   12 f84f749c c20800          ret     8
kd> uf bz4!myadd2
bz4!MyAdd2 [d:\mydriver\bz4\bz4.c @ 15]:
   15 f84f74b0 8bff            mov     edi,edi
   15 f84f74b2 55              push    ebp
   15 f84f74b3 8bec            mov     ebp,esp
   15 f84f74b5 51              push    ecx
   17 f84f74b6 8b4508          mov     eax,dword ptr [ebp+8]
   17 f84f74b9 03450c          add     eax,dword ptr [ebp+0Ch]
   17 f84f74bc 8945fc          mov     dword ptr [ebp-4],eax
   18 f84f74bf 8b45fc          mov     eax,dword ptr [ebp-4]
   21 f84f74c2 8be5            mov     esp,ebp
   21 f84f74c4 5d              pop     ebp
   21 f84f74c5 c20800          ret     8
kd> uf bz4!myadd3
bz4!MyAdd3 [d:\mydriver\bz4\bz4.c @ 24]:
   24 f84f74d0 8bff            mov     edi,edi
   24 f84f74d2 55              push    ebp
   24 f84f74d3 8bec            mov     ebp,esp
   24 f84f74d5 83ec10          sub     esp,10h
   26 f84f74d8 8b4508          mov     eax,dword ptr [ebp+8]
   26 f84f74db 03450c          add     eax,dword ptr [ebp+0Ch]
   26 f84f74de 8945f8          mov     dword ptr [ebp-8],eax
   27 f84f74e1 8b4df8          mov     ecx,dword ptr [ebp-8]
   27 f84f74e4 034d08          add     ecx,dword ptr [ebp+8]
   27 f84f74e7 894dfc          mov     dword ptr [ebp-4],ecx
   28 f84f74ea 8b5508          mov     edx,dword ptr [ebp+8]
   28 f84f74ed 8955f0          mov     dword ptr [ebp-10h],edx
   29 f84f74f0 8b4508          mov     eax,dword ptr [ebp+8]
   29 f84f74f3 0345f8          add     eax,dword ptr [ebp-8]
   29 f84f74f6 8945f4          mov     dword ptr [ebp-0Ch],eax
   30 f84f74f9 8b45f8          mov     eax,dword ptr [ebp-8]
   30 f84f74fc 0345fc          add     eax,dword ptr [ebp-4]
   30 f84f74ff 0345f0          add     eax,dword ptr [ebp-10h]
   30 f84f7502 0345f4          add     eax,dword ptr [ebp-0Ch]
   33 f84f7505 8be5            mov     esp,ebp
   33 f84f7507 5d              pop     ebp
   33 f84f7508 c20800          ret     8

///////////////////////////////////////////

//终于等到分析了
先看下全局变量 ：
ULONG au3 = 7;
ULONG au4 = 9;

看程序中Data存放的:

kd> dd f84f7700
f84f7700  00000007 00000009 f84de439 07b21bc6

没错，以后要查看全局变量的值，先反汇编，获得Data的偏移量，dd 地址 就可以看见了。

/////////////////////

kd> uf bz4!myadd3
bz4!MyAdd3 [d:\mydriver\bz4\bz4.c @ 24]:
.......
   24 f84f74d5 83ec10          sub     esp,10h
.......
   局部变量开辟空间。
  
 
 好了，简单赋值，调用就玩到这里，接下来是..... 

2004 年 3 月 09 日

PCI是一种广泛采用的总线标准，它提供了许多优于其它总线标准（如EISA）的新特性，目前已经成为计算机系统中应用最为广泛，并且最为通用的总线标准。Linux的内核能较好地支持PCI总线，本文以Intel 386体系结构为主，探讨了在Linux下开发PCI设备驱动程序的基本框架。

一、PCI总线系统体系结构

PCI是外围设备互连（Peripheral Component Interconnect）的简称，作为一种通用的总线接口标准，它在目前的计算机系统中得到了非常广泛的应用。PCI提供了一组完整的总线接口规范，其目的是描述如何将计算机系统中的外围设备以一种结构化和可控化的方式连接在一起，同时它还刻画了外围设备在连接时的电气特性和行为规约，并且详细定义了计算机系统中的各个不同部件之间应该如何正确地进行交互。

无论是在基于Intel芯片的PC机中，或是在基于Alpha芯片的工作站上，PCI毫无疑问都是目前使用最广泛的一种总线接口标准。同旧式的ISA总线不同，PCI将计算机系统中的总线子系统与存储子系统完全地分开，CPU通过一块称为PCI桥（PCI-Bridge）的设备来完成同总线子系统的交互，如图1所示。

由于使用了更高的时钟频率，因此PCI总线能够获得比ISA总线更好的整体性能。PCI总线的时钟频率一般在25MHz到33MHz范围内，有些甚至能够达到66MHz或者133MHz，而在64位系统中则最高能达到266MHz。尽管目前PCI设备大多采用32位数据总线，但PCI规范中已经给出了64位的扩展实现，从而使PCI总线能够更好地实现平台无关性，现在PCI总线已经能够用于IA-32、Alpha、PowerPC、SPARC64和IA-64等体系结构中。

PCI总线具有三个非常显著的优点，使得它能够完成最终取代ISA总线这一历史使命：

• 在计算机和外设间传输数据时具有更好的性能；
• 能够尽量独立于具体的平台；
• 可以很方便地实现即插即用。

图2是一个典型的基于PCI总线的计算机系统逻辑示意图，系统的各个部分通过PCI总线和PCI-PCI桥连接在一起。从图中不难看出，CPU和RAM需要通过PCI桥连接到PCI总线0（即主PCI总线），而具有PCI接口的显卡则可以直接连接到主PCI总线上。PCI-PCI桥是一个特殊的PCI设备，它负责将PCI总线0和PCI总线1（即从PCI主线）连接在一起，通常PCI总线1称为PCI-PCI桥的下游（downstream），而PCI总线0则称为PCI-PCI桥的上游（upstream）。图中连接到从PCI总线上的是SCSI卡和以太网卡。为了兼容旧的ISA总线标准，PCI总线还可以通过PCI-ISA桥来连接ISA总线，从而能够支持以前的ISA设备。图中ISA总线上连接着一个多功能I/O控制器，用于控制键盘、鼠标和软驱。

在此我只对PCI总线系统体系结构作了概括性介绍，如果读者想进一步了解，David A Rusling在The Linux Kernel（http://tldp.org/LDP/tlk/dd/pci.html）中对Linux的PCI子系统有比较详细的介绍。

回页首

二、Linux驱动程序框架

Linux将所有外部设备看成是一类特殊文件，称之为“设备文件”，如果说系统调用是Linux内核和应用程序之间的接口，那么设备驱动程序则可以看成是Linux内核与外部设备之间的接口。设备驱动程序向应用程序屏蔽了硬件在实现上的细节，使得应用程序可以像操作普通文件一样来操作外部设备。

1. 字符设备和块设备

Linux抽象了对硬件的处理，所有的硬件设备都可以像普通文件一样来看待：它们可以使用和操作文件相同的、标准的系统调用接口来完成打开、关闭、读写和I/O控制操作，而驱动程序的主要任务也就是要实现这些系统调用函数。Linux系统中的所有硬件设备都使用一个特殊的设备文件来表示，例如，系统中的第一个IDE硬盘使用/dev/hda表示。每个设备文件对应有两个设备号：一个是主设备号，标识该设备的种类，也标识了该设备所使用的驱动程序；另一个是次设备号，标识使用同一设备驱动程序的不同硬件设备。设备文件的主设备号必须与设备驱动程序在登录该设备时申请的主设备号一致，否则用户进程将无法访问到设备驱动程序。

在Linux操作系统下有两类主要的设备文件：一类是字符设备，另一类则是块设备。字符设备是以字节为单位逐个进行I/O操作的设备，在对字符设备发出读写请求时，实际的硬件I/O紧接着就发生了，一般来说字符设备中的缓存是可有可无的，而且也不支持随机访问。块设备则是利用一块系统内存作为缓冲区，当用户进程对设备进行读写请求时，驱动程序先查看缓冲区中的内容，如果缓冲区中的数据能满足用户的要求就返回相应的数据，否则就调用相应的请求函数来进行实际的I/O操作。块设备主要是针对磁盘等慢速设备设计的，其目的是避免耗费过多的CPU时间来等待操作的完成。一般说来，PCI卡通常都属于字符设备。

所有已经注册（即已经加载了驱动程序）的硬件设备的主设备号可以从/proc/devices文件中得到。使用mknod命令可以创建指定类型的设备文件，同时为其分配相应的主设备号和次设备号。例如，下面的命令：

[root@gary root]# mknod /dev/lp0 c 6 0

将建立一个主设备号为6，次设备号为0的字符设备文件/dev/lp0。当应用程序对某个设备文件进行系统调用时，Linux内核会根据该设备文件的设备类型和主设备号调用相应的驱动程序，并从用户态进入到核心态，再由驱动程序判断该设备的次设备号，最终完成对相应硬件的操作。

2. 设备驱动程序接口

Linux中的I/O子系统向内核中的其他部分提供了一个统一的标准设备接口，这是通过include/linux/fs.h中的数据结构file_operations来完成的：

struct file_operations { struct module *owner; loff_t (*llseek) (struct file *, loff_t, int); ssize_t (*read) (struct file *, char *, size_t, loff_t *); ssize_t (*write) (struct file *, const char *, size_t, loff_t *); int (*readdir) (struct file *, void *, filldir_t); unsigned int (*poll) (struct file *, struct poll_table_struct *); int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long); int (*mmap) (struct file *, struct vm_area_struct *); int (*open) (struct inode *, struct file *); int (*flush) (struct file *); int (*release) (struct inode *, struct file *); int (*fsync) (struct file *, struct dentry *, int datasync); int (*fasync) (int, struct file *, int); int (*lock) (struct file *, int, struct file_lock *); ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *); ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *); ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int); unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long); };

当应用程序对设备文件进行诸如open、close、read、write等操作时，Linux内核将通过file_operations结构访问驱动程序提供的函数。例如，当应用程序对设备文件执行读操作时，内核将调用file_operations结构中的read函数。

2. 设备驱动程序模块

Linux下的设备驱动程序可以按照两种方式进行编译，一种是直接静态编译成内核的一部分，另一种则是编译成可以动态加载的模块。如果编译进内核的话，会增加内核的大小，还要改动内核的源文件，而且不能动态地卸载，不利于调试，所有推荐使用模块方式。

从本质上来讲，模块也是内核的一部分，它不同于普通的应用程序，不能调用位于用户态下的C或者C++库函数，而只能调用Linux内核提供的函数，在/proc/ksyms中可以查看到内核提供的所有函数。

在以模块方式编写驱动程序时，要实现两个必不可少的函数init_module( )和cleanup_module( )，而且至少要包含<linux/krernel.h>和<linux/module.h>两个头文件。在用gcc编译内核模块时，需要加上-DMODULE -D__KERNEL__ -DLINUX这几个参数，编译生成的模块（一般为.o文件）可以使用命令insmod载入Linux内核，从而成为内核的一个组成部分，此时内核会调用模块中的函数init_module( )。当不需要该模块时，可以使用rmmod命令进行卸载，此进内核会调用模块中的函数cleanup_module( )。任何时候都可以使用命令来lsmod查看目前已经加载的模块以及正在使用该模块的用户数。

3. 设备驱动程序结构

了解设备驱动程序的基本结构（或者称为框架），对开发人员而言是非常重要的，Linux的设备驱动程序大致可以分为如下几个部分：驱动程序的注册与注销、设备的打开与释放、设备的读写操作、设备的控制操作、设备的中断和轮询处理。

• 驱动程序的注册与注销

  向系统增加一个驱动程序意味着要赋予它一个主设备号，这可以通过在驱动程序的初始化过程中调用register_chrdev( )或者register_blkdev( )来完成。而在关闭字符设备或者块设备时，则需要通过调用unregister_chrdev( )或unregister_blkdev( )从内核中注销设备，同时释放占用的主设备号。

• 设备的打开与释放

  打开设备是通过调用file_operations结构中的函数open( )来完成的，它是驱动程序用来为今后的操作完成初始化准备工作的。在大部分驱动程序中，open( )通常需要完成下列工作：

  1. 检查设备相关错误，如设备尚未准备好等。
  2. 如果是第一次打开，则初始化硬件设备。
  3. 识别次设备号，如果有必要则更新读写操作的当前位置指针f_ops。
  4. 分配和填写要放在file->private_data里的数据结构。
  5. 使用计数增1。

  释放设备是通过调用file_operations结构中的函数release( )来完成的，这个设备方法有时也被称为close( )，它的作用正好与open( )相反，通常要完成下列工作：

  1. 使用计数减1。
  2. 释放在file->private_data中分配的内存。
  3. 如果使用计算为0，则关闭设备。
• 设备的读写操作

  字符设备的读写操作相对比较简单，直接使用函数read( )和write( )就可以了。但如果是块设备的话，则需要调用函数block_read( )和block_write( )来进行数据读写，这两个函数将向设备请求表中增加读写请求，以便Linux内核可以对请求顺序进行优化。由于是对内存缓冲区而不是直接对设备进行操作的，因此能很大程度上加快读写速度。如果内存缓冲区中没有所要读入的数据，或者需要执行写操作将数据写入设备，那么就要执行真正的数据传输，这是通过调用数据结构blk_dev_struct中的函数request_fn( )来完成的。

• 设备的控制操作

  除了读写操作外，应用程序有时还需要对设备进行控制，这可以通过设备驱动程序中的函数ioctl( )来完成。ioctl( )的用法与具体设备密切关联，因此需要根据设备的实际情况进行具体分析。

• 设备的中断和轮询处理
  

  对于不支持中断的硬件设备，读写时需要轮流查询设备状态，以便决定是否继续进行数据传输。如果设备支持中断，则可以按中断方式进行操作。

回页首

三、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。

参考资料

• David A Rusling在 The Linux Kernel中对Linux的PCI子系统进行了比较详细的介绍。
  
  
• Linux PCI-HOWTO是了解Linux下PCI设备的最好读物。
  
  
• 毛德操，胡希明，Linux内核源代码情景分析，杭州：浙江大学出版社，2001
  
  
• Alessandro Rubini,，Linux Device Drivers（2nd Edition） USA：O’Reilly，2001
  
  
• Tomshanley，DonAderson，PCI系统结构（第四版），北京：电子工业出版社，2000
  

关于作者

		肖文鹏，北京理工大学计算机系的一名硕士研究生，主要从事操作系统和分布式计算环境的研究，喜爱Linux和Python。你可以通过 xiaowp@263.net与他取得联系。

 
.word ((B0_Tacs<<13)+(B0_Tcos<<11)+(B0_Tacc<<8)+(B0_Tcoh<<6)+(B0_Tah<<4)+(B0_Tacp<<2)+(B0_PMC)) 
.word ((B1_Tacs<<13)+(B1_Tcos<<11)+(B1_Tacc<<8)+(B1_Tcoh<<6)+(B1_Tah<<4)+(B1_Tacp<<2)+(B1_PMC)) 
.word ((B2_Tacs<<13)+(B2_Tcos<<11)+(B2_Tacc<<8)+(B2_Tcoh<<6)+(B2_Tah<<4)+(B2_Tacp<<2)+(B2_PMC)) 
.word ((B3_Tacs<<13)+(B3_Tcos<<11)+(B3_Tacc<<8)+(B3_Tcoh<<6)+(B3_Tah<<4)+(B3_Tacp<<2)+(B3_PMC)) 
.word ((B4_Tacs<<13)+(B4_Tcos<<11)+(B4_Tacc<<8)+(B4_Tcoh<<6)+(B4_Tah<<4)+(B4_Tacp<<2)+(B4_PMC)) 
.word ((B5_Tacs<<13)+(B5_Tcos<<11)+(B5_Tacc<<8)+(B5_Tcoh<<6)+(B5_Tah<<4)+(B5_Tacp<<2)+(B5_PMC)) 
.word ((B6_MT<<15)+(B6_Trcd<<2)+(B6_SCAN)) 
.word ((B7_MT<<15)+(B7_Trcd<<2)+(B7_SCAN)) 
.word ((REFEN<<23)+(TREFMD<<22)+(Trp<<20)+(Trc<<18)+(Tchr<<16)+REFCNT) 
.word 0xB2 /* REFRESH Control Register */ 
.word 0x30 /* BANKSIZE Register : Burst Mode */ 
.word 0x30 /* SDRAM Mode Register */ 
.align 2 
.global call_main //调用main函数,函数参数都为0 
call_main: 
ldr sp,STACK_START 
mov fp,#0 /* no previous frame, so fp=0*/ 
mov a1, #0 /* set argc to 0*/ 
mov a2, #0 /* set argv to NUL*/ 
bl main /* call main*/ 
STACK_START: 
.word STACK_BASE 
undefined_instruction: 
software_interrupt: 
prefetch_abort: 
data_abort: 
not_used: 
irq: 
fiq: 

2410init.c file 
int main(int argc,char **argv) 
{ 
u32 test = 0; 
void (*theKERNEL)(int zero, int arch, unsigned long params_addr) = (void (*)(int, int, unsigned long))RAM_COMPRESSED_KERNEL 
_BASE; //压缩后的IMAGE地址 
int i,k=0; 
// downPt=(RAM_COMPRESSED_KERNEL_BASE); 
chkBs=(_RAM_STARTADDRESS);//SDRAM开始的地方 
// fromPt=(FLASH_LINUXKERNEL); 
MMU_EnableICache(); 
ChangeClockDivider(1,1); // 1:2:4 
ChangeMPllValue(M_MDIV,M_PDIV,M_SDIV); //Fin=12MHz FCLK=200MHz 
Port_Init();//设置I/O端口,在使用com口前,必须调用这个函数,否则通信芯片根本得不到数据 
Uart_Init(PCLK, 115200);//PCLK使用默认的200000,拨特率115200 
/*******************(检查ram空间)*******************/ 
Uart_SendString("ntLinux S3C2410 Nor BOOTLOADERn"); 
Uart_SendString("ntChecking SDRAM 2410loader.c...n"); 
for(;chkBs<0x33FA0140;chkBs=chkBs+0x4,test++)// 

/*******************(copy linux KERNEL)*******************/ 
Uart_SendString("tLoading KERNEL IMAGE from FLASH... n "); 
Uart_SendString("tand copy KERNEL IMAGE to SDRAM at 0x31000000n"); 
Uart_SendString("ttby LEIJUN DONG dongleijun4000@hotmail.com n"); 
for(k = 0;k < 196608;k++,downPt += 1,fromPt += 1)//3*1024*1024/32linux KERNEL des,src,length=3M 
* (u32 *)downPt = * (u32 *)fromPt; 
/*******************(load RAMDISK)*******************/ 
Uart_SendString("ttloading COMPRESSED RAMDISK...n"); 
downPt=(RAM_COMPRESSED_RAMDISK_BASE); 
fromPt=(FLASH_RAMDISK_BASE); 
for(k = 0;k < 196608;k++,downPt += 1,fromPt += 1)//3*1024*1024/32linux KERNEL des,src,length=3M 
* (u32 *)downPt = * (u32 *)fromPt; 
/******jffs2文件系统,在开发中如果用不到FLASH,这段也可以不要********/ 
Uart_SendString("ttloading jffs2...n"); 
downPt=(RAM_JFFS2); 
fromPt=(FLASH_JFFS2); 
for(k = 0;k < (1024*1024/32);k++,downPt += 1,fromPt += 1) 
* (u32 *)downPt = * (u32 *)fromPt; 
Uart_SendString( "Load Success...Run...n "); 
/*******************(setup param)*******************/ 
setup_start_tag();//开始设置启动参数 
setup_memory_tags();//内存印象 
setup_commandline_tag("console=ttyS0,115200n8");//启动命令行 
setup_initrd2_tag();//root device 
setup_RAMDISK_tag();//ramdisk image 
setup_end_tag(); 
/*关I-cache */ 
asm ("mrc p15, 0, %0, c1, c0, 0": "=r" (i)); 
i &= ~0x1000; 
asm ("mcr p15, 0, %0, c1, c0, 0": : "r" (i)); 
/* flush I-cache */ 
asm ("mcr p15, 0, %0, c7, c5, 0": : "r" (i)); 

/*******************END*******************/ 
error: 
Uart_SendString("nnPanic SDRAM check error!n"); 
return 0; 
} 
static void setup_start_tag(void) 
{ 
params = (struct tag *)RAM_BOOT_PARAMS;//启动参数开始的地址 
params->hdr.tag = ATAG_CORE; 
params->hdr.size = tag_size(tag_core); 
params->u.core.flags = 0; 
params->u.core.pagesize = 0; 
params->u.core.rootdev = 0; 
params = tag_next(params); 
} 
static void setup_memory_tags(void) 
{ 
int i; 
for(i = 0; i < NUM_MEM_AREAS; i++) { 
if(memory_map[i].used) { 
params->hdr.tag = ATAG_MEM; 
params->hdr.size = tag_size(tag_mem32); 
params->u.mem.start = memory_map[i].start; 
params->u.mem.size = memory_map[i].len; 
params = tag_next(params); 
} 
} 
} 
static void setup_commandline_tag(char *commandline) 
{ 
int i = 0; 
/* skip non-existent command lines so the kernel will still 
* use its default command line. 
*/ 
params->hdr.tag = ATAG_CMDLINE; 
params->hdr.size = 8; 
//console=ttyS0,115200n8 
strcpy(params->u.cmdline.cmdline, p); 
params = tag_next(params); 
} 
static void setup_initrd2_tag(void) 
{ 
/* an ATAG_INITRD node tells the kernel where the compressed 
* ramdisk can be found. ATAG_RDIMG is a better name, actually. 
*/ 
params->hdr.tag = ATAG_INITRD2; 
params->hdr.size = tag_size(tag_initrd); 
params->u.initrd.start = RAM_COMPRESSED_RAMDISK_BASE; 
params->u.initrd.size = 2047;//k byte 
params = tag_next(params); 
} 
static void setup_ramdisk_tag(void) 
{ 
/* an ATAG_RAMDISK node tells the kernel how large the 
* decompressed ramdisk will become. 
*/ 
params->hdr.tag = ATAG_RAMDISK; 
params->hdr.size = tag_size(tag_ramdisk); 
params->u.ramdisk.start = RAM_DECOMPRESSED_RAMDISK_BASE; 
params->u.ramdisk.size = 7.8*1024; //k byte 
params->u.ramdisk.flags = 1; // automatically load ramdisk 
params = tag_next(params); 
} 
static void setup_end_tag(void) 
{ 
params->hdr.tag = ATAG_NONE; 
params->hdr.size = 0; 
} void Uart_Init(int pclk,int baud)//串口是很重要的 
{ 
int i; 
if(pclk == 0) 
pclk = PCLK; 
rUFCON0 = 0x0; //UART channel 0 FIFO control register, FIFO dISAble 
rUMCON0 = 0x0; //UART chaneel 0 MODEM control register, AFC dISAble 
//UART0 
rULCON0 = 0x3; //Line control register : Normal,No parity,1 stop,8 bits 
下面这段samsung好象写的不太对,但是我按照Normal,No parity,1 stop,8 bits算出来的确是0x245 
// [10] [9] [8] [7] [6] [5] [4] [3:2] [1:0] 
// Clock Sel, Tx Int, Rx Int, Rx Time Out, Rx err, Loop-back, Send break, Transmit Mode, Receive Mode 
// 0 1 0 , 0 1 0 0 , 01 01 
// PCLK Level Pulse DISAble Generate Normal Normal Interrupt or Polling 
rUCON0 = 0x245; // Control register 
rUBRDIV0=( (int)(PCLK/16./ baud) -1 ); //Baud rate divisior register 0 
delay(10); 
} 

如何用摄像头做一个时时监控的系统呢？也就是说有一台网络专用临控服务器，其它客户机通过网络影像监控软件或浏览器来进行时时监控摄像头所在位置，所发生的一切。我没有弄过专业类的视频监控，也不知道他们用的是什么专业的设备，也不知道他们有什么功能。我所理解的网络监控服务器应用如下内容：

＊ 时时监控功能：时时监控摄像头所监视的范围；
＊ 数据流采集功能：时时采集监控数据流，以备将来查找相关影像资料做准备；
＊ 照片抓取功能：比如每隔5分钟抓取一张照片；
＊  时间戳功能；
＊ 数据备份功能（附加）；

2、Linux 用摄像头（WebCam）做网络监视服务器所需条件和要达到的目的；

我们首先定义一下我们用摄像头（WebCam）来做网络时时临控系统所需的条件和要达到的目的；

2.1 所需要的软件环境和硬件设备；

首先：得有一个摄像头（WebCam），并且是 能被 Linux 所支持的摄像头，请参考： 《摄像头（WebCam）在Linux操作系统中的驱动方法 》

其次：软件环境，我们用 Spcaserv来架设；

第三：网络环境，我们得有一个网络环境，比如我来测试我所做的网络监视系统是否成功，至少在局域网内有两台机器吧，虽然一台也能做，但至于网络的其它计算机是否能看得到，如果机器太少，我们无从得知；

2.2 所要达到的目的；

＊ 时间监控：能跨平台，所有的系统都无障碍查看监视；
＊ 数据采集：可在服务器端进行，但要运行在桌面环境下；在Linux 客户端中进行；由于软件限制，只能这样说了；

3、Linux 用摄像头（WebCam）的驱动方法；

请参考： 《摄像头（WebCam）在Linux操作系统中的驱动方法 》

4、在 Linux 中用 Spcaserv架设网络监控服务器；

4.1 下载软件 Spcaview；

下载地址： http://mxhaard.free.fr/spca50x/Download> ，我下载的是目前这个版本： spcaview-20051212.tar.gz

spcaview-20051212.tar.gz软件包包含一组工具；

＊ Spcaview 工具是用来纪录数据流，也能用来播放数据；也能做为网络监视客户端用；
＊ Spcaserv 是流媒体服务器，我们就是用这个工具来做监控服务器；
＊ Spcacat 简单图片的抓取工具，不能用于网络监视客户端 ；

4.2 Spcaview 软件包的安装；

依赖关系；

此软件依赖 libsdl，要先安装它才行，下载地址：http://www.libsdl.org ，我下载的是：SDL-1.2.10.tar.gz

http://www.libsdl.org/download-1.2.php

安装SpcaView 软件包：

配置可执行程序的路径：

可执行的工具被安装到 /usr/local/bin目录中，所以我们还要配置一下用户的环境变量PATH 。配置命令执行路径，在当前用户家目录下的.bashrc文件中加入下面的一行；

然后运行如下命令；

关于路径的配置，请参考：《Linux 命令及可执行程序路径的设置》 ；《关于Linux 文件系统中路径的理解》

4.3 Spcaserv 服务器的配置和运行；

4.31 Spcaserv 服务器的运行；

Spcaserv 运行方法如下；

参数说明：

-h      查看帮助；
-d      /dev/videoX       指定摄像头设备，比如 /dev/video0
-g      use read method for grab instead mmap
-f           影像格式，默认为YUV420P，fourcc I420
jpg JPEG                fourcc MJPG
yuv YUV420P             fourcc I420
r16 RGB565 16bits       fourcc RGB2
r24 RGB 24bits          fourcc RGB3
r32 RGB 32bits          fourcc RGB4
-v RAW data             fourcc RAWD
-s      设置分辨率，宽x高  ，比如  320x240，或 640x480，或160x120;
-w      指定服务器的网络地址或端口，比如 192.168.1.3:8888

4.32 Spcaserv 运行示例；

我在 192.168.1.3 这台机器做为网络监控服务器，并且指定服务器运行在 8888端口上；并且客户端监视时所显示的画面是 320x240的分辨率；

4.33 配置HTTPD服务器，以便客户端能在浏览器下查看；

首先：安装和配置HTTPD服务器；

至于HTTPD服务器在Linux常用的就是Apache服务器，您可以通过您所用的发行版提供的软件包来安装，也可以自行编译安装，在 LinuxSir.Org 的网络讨论区的置顶帖子中有很多这样的帖子；安装好HTTPD服务器后，要把服务器启动起来。

在 Fedora 或Redhat 中，如果是用其所提供的 RPM包安装的，要用如下方法启动；

其次：复制SpcaView 软件包解压目录下的 http-java-applet 目录到WEB服务器的家目录下；

比如Fedora的HTTPD服务器的默认家目录是 /var/www/html，我以我的机器来说明了，所以我要做如下的工作；

第三： 进入/var/www/html/webcam 目录制作视频首页；

您可以用查看index.htm文件内容，可以自己改一改，也就是把洋文改成中文；根据自己的情况自己看着办吧；

5、 网络客户端监控工具介绍；

对于客户端网络监控，能跨平台的客户端只有通过浏览器了，这是最方便的方法；另外在Linux中有 Spcaview工具可用；现一一介绍；

5.1 通过浏览器监控；

5.11 安装JRE，以让浏览器支持JAVA程序；

我们可以通过浏览器来监控，利用浏览器监控可以跨平台监视，这样无论Linux、Windows、还是MacOS，或者是BSD及其它UNIX系统，只要有图形界面的浏览器，在桌面环境下就可以对摄像头（WebCam） 所“控制”的范围进行监控。

由于服务器端的WEB页面包括JAVA控件，所以您得安装 JAVA环境。要让浏览器支持JAVA插件。

在 Linux 中，您可以参考：《JRE 安装和配置，以适合JAVA程序运行所具备的环境》

在Windows中，点鼠标就可以完成操作，不再介绍了；

5.12 浏览器监控示例（跨平台）；

http://192.168.1.3/webcam/index.htm