驱动程序如何定义设备

❶ Windows 如何在安装过程中确定最适合的设备驱动程序进行安装

本文介绍的过程用于 在安装期间为设备选择最适合的设备驱动程序。

当您运行 Windows 安装程序时，用于某个特定设备的设备驱动程序或 .inf 文件可能有多组。安装程序和即插即用功能都试图为要安装的设备选择最适合的设备驱动程序，以解决这些冲突。

注意：本文介绍的过程仅用于在安装程序的图形用户界面 (GUI) 阶段或安装程序运行完毕后所安装的设备。在安装程序的文本模式部分执行的大容量存储控制器检测和设备驱动程序选择使用的是另一个过程。
更多信息
有关大容量存储控制器检测过程的更多信息，请单击下面的文章编号，以查看 Microsoft 知识库中相应的文章：
220845 在 Windows 安装期间添加第三方或更新的驱动程序

即插即用功能将尝试对硬件的即插即用标识 (ID)（在对设备进行枚举以后由设备固件或系统 BIOS 返回）与 .inf 文件中任何匹配的即插即用 ID 进行比较，以找到兼容的设备驱动程序。

即插即用功能可以搜索所有 .inf 文件，以便为特定设备找到最适合的设备驱动程序进行安装。该功能在找到第一个匹配项后并不停止搜索，而是继续搜索即插即用搜索路径中列出的所有 .inf 文件，搜索路径在以下注册表项中定义：
HKEY-LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion
DevicePath:Reg_Expand_SZ:%Systemroot%\Inf

注意：默认情况下，上述注册表位置仅包含这一个项，但如果您执行无人参与安装并在无人参与应答文件中使用了OemPnpDriversPath = 参数，则可能会向此注册表项附加其他路径。

安装程序会为在 .inf 文件中包含匹配项的兼容设备驱动程序生成一个列表，并对找到的每个驱动程序都指定一个“等级”。等级范围为从“0”到“0xFFFF”，其中 0 代表最适合的可能匹配项，而 0xFFFF 代表最不适合的可能匹配项。等级最低的设备驱动程序将被视为最适合的可能匹配项，并且是要安装的设备驱动程序。

设备驱动程序的等级分为以下范围：
0x0 到 0xfff：设备硬件 ID 与 .inf 文件中列出的硬件 ID 匹配。
0x1000 到 0x1fff：设备硬件 ID 与 .inf 文件中的一个兼容 ID 匹配。
0x2000 到 0x2fff：一个设备兼容 ID 与 .inf 文件中的硬件 ID 匹配。
0x3000 到 0x3fff：一个设备兼容 ID 与 .inf 文件中的兼容 ID 匹配。
0xFFFF：最不适合的匹配项。
在 Windows XP 和 Windows Server 2003 中，还存在其他设备驱动程序等级范围：
0x8000 到 0x8FFF：不受信任的硬件 ID 匹配项
0x9000 到 0x9FFF：不受信任的兼容 ID 匹配项
如果 .inf 文件未经过数字签名，或者 Model 节名称未包含 Windows NT 特定的修饰（设备可安装在 Windows NT、Windows 95 或 Windows 98 上，但它在这些操作系统上不具有特定的项），则这些 .inf 文件将处于不受信任的范围。

如果安装程序确定某一设备驱动程序是不受信任的，它可以将该设备驱动程序的等级更改为前面所提到的适当范围。
处于 0x0 到 0xfff 范围的设备驱动程序等级称为“硬件 ID 匹配”，因为它们在硬件 ID 之间匹配。这些等级还被视为最适合的匹配项，而任何其他等级都将被列为“兼容”，这是因为在生成设备驱动程序等级时至少有一个兼容 ID。类别安装程序和辅助安装程序也会影响设备驱动程序的选择。如果这些安装程序确定设备驱动程序无法支持设备，或更改了设备驱动程序的等级，则它们会将该设备驱动程序标记为“无效”。

但是，如果两个设备驱动程序都具有最低的等级，安装程序将使用最新的设备驱动程序。如果一个设备驱动程序已经过签名，而另一个未经过签名，则将向未签名的设备驱动程序的日期赋予 0xFFFFFFFF 值，同时选择并安装已签名的设备驱动程序。

可能还会提供 OEM 提供的设备驱动程序，但可能不会选择和使用该程序。即使制造商提供了更新后的设备驱动程序，它也可能只是作为兼容的设备驱动程序编写的，因而会获得较高的等级并产生较差的匹配结果。安装程序在选择设备驱动程序匹配项时，不会考虑 OEM 提供的设备是否已经过数字签名。如果未经签名的设备驱动程序具有较低的等级，且匹配度优于任何其他内置设备驱动程序，则安装程序会选择并安装该设备驱动程序。

运行安装程序时，如果在任何 .inf 文件中均未找到匹配项，则会推迟设备安装，且该设备可能会在设备管理器中成为未知设备。引入新设备（安装过程之外）后，如果未在计算机中的任何 .inf 文件中找到匹配项，您可能会收到“找到了新的硬件”提示，并会被要求提供设备驱动程序。

例如，您在计算机上安装了 PCI 视频适配器，其即插即用 ID 显示在两个不同的 .inf 文件（Nv3_disp.inf 和 Nv4_disp.inf）中。这两个设备驱动程序文件均未经过数字签名，因此它们的日期都将被赋值为 0xFFFFFFFF。在此示例中，这两个文件位于以下 D:\Drivers\Video1 和 D:\Drivers\Video2 文件夹中。

注册表中的当前 Devicepath= 具有 %Systemroot%\Inf、%Systemdrive%\Drivers\Video1 和 %Systemdrive%\Drivers\Video2 项。

注意：%Systemroot% 为 D:\Winnt，%Systemdrive% 为 D:

安装程序和即插即用功能将搜索在上述路径中找到的所有 .inf 文件，并记录找到的任何匹配项。如果安装程序或即插即用功能找到了多个匹配项，则将使用最适合的匹配项。

以下摘自 Setupapi.log 文件的内容详细介绍了上述过程。在此示例中，安装程序的日志记录模式已设置为详细模式。有关进行此项设置的方法，请参见以下文章：

243996 如何在 Windows 2000 GUI 模式安装期间启用详细日志记录

如果安装程序运行正常，您将不会在 Setupapi.log 文件中看到如此多的详细信息。

当设备受到查询时，它将返回硬件 ID 和兼容 ID 的列表。并非所有设备都会返回多个 ID，但在多数情况下，它们确实如此。在此示例中，视频卡将返回以下 ID：
Searching for hardware IDs:
Pci\Ven_10de&dev_0028&subsys_5a001092&rev_11,
Pci\Ven_10de&dev_0028&subsys_5a001092,
Pci\Ven_10de&dev_0028&cc_030000,
Pci\Ven_10de&dev_0028&cc_0300
Searching for compatible IDs:
Pci\Ven_10de&dev_0028&rev_11,
Pci\Ven_10de&dev_0028,
Pci\Ven_10de&cc_030000,
Pci\Ven_10de&cc_0300,
Pci\Ven_10de,pci\cc_030000,
Pci\Cc_0300
Enumerating files D:\Winnt\Inf\*.inf
@ 07:11:59.191 : Opened PNF of "D:\Winnt\Inf\1394.inf".
@ 07:11:59.191 : Opened PNF of "D:\Winnt\Inf\accessor.inf".
@ 07:11:59.191 : Opened PNF of "D:\Winnt\Inf\acpi.inf".
@ 07:11:59.191 : Opened PNF of "D:\Winnt\Inf\adm_mult.inf".
@ 07:11:59.191 : Opened PNF of "D:\Winnt\Inf\adm_port.inf".
@ 07:11:59.207 : Opened PNF of "D:\Winnt\Inf\agtinst.inf".
.
.
.
Enumerating files D:\Drivers\Video1\*.inf
@ 07:12:00.660 : Opened PNF of "D:\Drivers\Video1\NV4_DISP.inf".
@ 07:12:00.660 : The file (D:\Drivers\Video1\NV4_DISP.inf) is not digitally
signed, ignoring driver date.
@ 07:12:00.660 :Found Pci\VEN_10DE&DEV_0028 in
D:\Drivers\Video1\NV4_DISP.inf; Device: NVIDIA RIVA TNT2; Driver: NVIDIA
RIVA TNT2; Provider: NVIDIA; Mfg: NVIDIA; Section: nv4
@ 07:12:00.660 : Decorated section name: nv4
Enumerating files D:\Drivers\Video2\*.inf
@ 07:12:00.660 : Opened PNF of "D:\Drivers\Video2\NV3_DISP.inf".
@ 07:12:00.675 : The file (D:\Drivers\Video2\NV3_DISP.inf) is not digitally
signed, ignoring driver date.
@ 07:12:00.675 : Found PCI\VEN_10DE&DEV_0028 in
D:\Drivers\Video2\NV3_DISP.inf; Device: NVIDIA RIVA TNT2; Driver: NVIDIA
RIVA TNT2; Provider: NVIDIA; Mfg: NVIDIA; Section: nv4
@ 07:12:00.675 : Decorated section name: nv4
@ 07:12:01.706 : Device install function: DIF_SELECTBESTCOMPATDRV.
@ 07:12:01.706 : Executing class installer.
@ 07:12:01.894 : Completed class installer.
@ 07:12:01.894 : Executing default installer.
@ 07:12:01.894 : Selected driver installs from section nv4 in D:\Drivers\Video1\Nv4_disp.inf.
@ 07:12:01.894 : Changed class GUID of device to {4D36E968-E325-11CE-BFC1-08002BE10318}.
@ 07:12:01.894 : Set selected driver.
@ 07:12:01.894 : Selected best compatible driver.
@ 07:12:01.894 : Completed default installer.
@ 07:12:06.565 : Device install function: DIF_ALLOW_INSTALL.
@ 07:12:06.565 : Executing class installer.
@ 07:12:06.565 : Completed class installer.
@ 07:12:06.581 : Device install function:DIF_INSTALLDEVICEFILES.
@ 07:12:06.581 : Executing class installer.
@ 07:12:06.581 : Completed class installer.
@ 07:12:06.581 : Executing default installer.

在该示例输出中，安装程序使用 D:\Drivers\Video1\Nv4_disp.inf 文件选择设备驱动程序并加以安装，因为安装程序发现该设备驱动程序是最适合的匹配项。

若要轻易找到已安装的设备及安装该设备时使用的 .inf 文件，请在 Windows 记事本中打开 %Systemroot%\Setupapi.log 文件，对即插即用安装的设备搜索 DIF_SelectBestCompatDrv，而对手动安装的设备搜索 DIF_SelectDevice。

❷ 如何编写一个简单的linux内核模块和设备驱动程序

如何编写Linux设备驱动程序
回想学习Linux操作系统已经有近一年的时间了，前前后后，零零碎碎的一路学习过来，也该试着写的东西了。也算是给自己能留下一点记忆和回忆吧！由于完全是自学的，以下内容若有不当之处，还请大家多指教。
Linux是Unix操作系统的一种变种，在Linux下编写驱动程序的原理和思想完全类似于其他的Unix系统，但它dos或window环境下的驱动程序有很大的区别。在Linux环境下设计驱动程序，思想简洁，操作方便，功能也很强大，但是支持函数少，只能依赖kernel中的函数，有些常用的操作要自己来编写，而且调试也不方便。
以下的一些文字主要来源于khg，johnsonm的Write linux device driver，Brennan's Guide to Inline Assembly，The Linux a-z，还有清华bbs上的有关device driver的一些资料。
一、Linux device driver 的概念
系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口。设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。设备驱动程序是内核的一部分，它完成以下的功能:
1、对设备初始化和释放。
2、把数据从内核传送到硬件和从硬件读取数据。
3、读取应用程序传送给设备文件的数据和回送应用程序请求的数据。
4、检测和处理设备出现的错误。
在Linux操作系统下有三类主要的设备文件类型，一是字符设备，二是块设备，三是网络设备。字符设备和块设备的主要区别是:在对字符设备发出读/写请求时，实际的硬件I/O一般就紧接着发生了，块设备则不然，它利用一块系统内存作缓冲区，当用户进程对设备请求能满足用户的要求，就返回请求的数据，如果不能，就调用请求函数来进行实际的I/O操作。块设备是主要针对磁盘等慢速设备设计的，以免耗费过多的CPU时间来等待。
已经提到，用户进程是通过设备文件来与实际的硬件打交道。每个设备文件都都有其文件属性(c/b)，表示是字符设备还是块设备?另外每个文件都有两个设备号，第一个是主设备号，标识驱动程序，第二个是从设备号，标识使用同一个设备驱动程序的不同的硬件设备，比如有两个软盘，就可以用从设备号来区分他们。设备文件的的主设备号必须与设备驱动程序在登记时申请的主设备号一致，否则用户进程将无法访问到驱动程序。
最后必须提到的是，在用户进程调用驱动程序时，系统进入核心态，这时不再是抢先式调度。也就是说，系统必须在你的驱动程序的子函数返回后才能进行其他的工作。如果你的驱动程序陷入死循环，不幸的是你只有重新启动机器了，然后就是漫长的fsck。
读/写时，它首先察看缓冲区的内容，如果缓冲区的数据未被处理，则先处理其中的内容。
如何编写Linux操作系统下的设备驱动程序

二、实例剖析
我们来写一个最简单的字符设备驱动程序。虽然它什么也不做，但是通过它可以了解Linux的设备驱动程序的工作原理。把下面的C代码输入机器，你就会获得一个真正的设备驱动程序。
#define __NO_VERSION__
#include <linux/moles.h>
#include <linux/version.h>
char kernel_version [] = UTS_RELEASE;
这一段定义了一些版本信息，虽然用处不是很大，但也必不可少。Johnsonm说所有的驱动程序的开头都要包含<linux/config.h>，一般来讲最好使用。
由于用户进程是通过设备文件同硬件打交道，对设备文件的操作方式不外乎就是一些系统调用，如 open，read，write，close…， 注意，不是fopen， fread，但是如何把系统调用和驱动程序关联起来呢?这需要了解一个非常关键的数据结构：
struct file_operations
{
int (*seek) (struct inode * ，struct file *， off_t ，int);
int (*read) (struct inode * ，struct file *， char ，int);
int (*write) (struct inode * ，struct file *， off_t ，int);
int (*readdir) (struct inode * ，struct file *， struct dirent * ，int);
int (*select) (struct inode * ，struct file *， int ，select_table *);
int (*ioctl) (struct inode * ，struct file *， unsined int ，unsigned long);
int (*mmap) (struct inode * ，struct file *， struct vm_area_struct *);
int (*open) (struct inode * ，struct file *);
int (*release) (struct inode * ，struct file *);
int (*fsync) (struct inode * ，struct file *);
int (*fasync) (struct inode * ，struct file *，int);
int (*check_media_change) (struct inode * ，struct file *);
int (*revalidate) (dev_t dev);
}

这个结构的每一个成员的名字都对应着一个系统调用。用户进程利用系统调用在对设备文件进行诸如read/write操作时，系统调用通过设备文件的主设备号找到相应的设备驱动程序，然后读取这个数据结构相应的函数指针，接着把控制权交给该函数。这是linux的设备驱动程序工作的基本原理。既然是这样，则编写设备驱动程序的主要工作就是编写子函数，并填充file_operations的各个域。
下面就开始写子程序。
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include<linux/config.h>
#include <linux/errno.h>
#include <asm/segment.h>
unsigned int test_major = 0;
static int read_test(struct inode *node，struct file *file，char *buf，int count)
{
int left;
if (verify_area(VERIFY_WRITE，buf，count) == -EFAULT )
return -EFAULT;
for(left = count ; left > 0 ; left--)
{
__put_user(1，buf，1);
buf++;
}
return count;
}

这个函数是为read调用准备的。当调用read时，read_test()被调用，它把用户的缓冲区全部写1。buf 是read调用的一个参数。它是用户进程空间的一个地址。但是在read_test被调用时，系统进入核心态。所以不能使用buf这个地址，必须用__put_user()，这是kernel提供的一个函数，用于向用户传送数据。另外还有很多类似功能的函数。请参考robert著的《Linux内核设计与实现》（第二版）。然而，在向用户空间拷贝数据之前，必须验证buf是否可用。这就用到函数verify_area。
static int write_tibet(struct inode *inode，struct file *file，const char *buf，int count)
{
return count;
}
static int open_tibet(struct inode *inode，struct file *file )
{
MOD_INC_USE_COUNT;
return 0;
}
static void release_tibet(struct inode *inode，struct file *file )
{
MOD_DEC_USE_COUNT;
}

这几个函数都是空操作。实际调用发生时什么也不做，他们仅仅为下面的结构提供函数指针。
struct file_operations test_fops = {
NULL，
read_test，
write_test，
NULL， /* test_readdir */
NULL，
NULL， /* test_ioctl */
NULL， /* test_mmap */
open_test，
release_test，
NULL， /* test_fsync */
NULL， /* test_fasync */
/* nothing more， fill with NULLs */
};
这样，设备驱动程序的主体可以说是写好了。现在要把驱动程序嵌入内核。驱动程序可以按照两种方式编译。一种是编译进kernel，另一种是编译成模块(moles)，如果编译进内核的话，会增加内核的大小，还要改动内核的源文件，而且不能动态的卸载，不利于调试，所以推荐使用模块方式。
int init_mole(void)
{
int result;
result = register_chrdev(0， "test"， &test_fops);
if (result < 0) {
printk(KERN_INFO "test: can't get major number\n");
return result;
}
if (test_major == 0) test_major = result; /* dynamic */
return 0;
}

在用insmod命令将编译好的模块调入内存时，init_mole 函数被调用。在这里，init_mole只做了一件事，就是向系统的字符设备表登记了一个字符设备。register_chrdev需要三个参数，参数一是希望获得的设备号，如果是零的话，系统将选择一个没有被占用的设备号返回。参数二是设备文件名，参数三用来登记驱动程序实际执行操作的函数的指针。
如果登记成功，返回设备的主设备号，不成功，返回一个负值。
void cleanup_mole(void)
{
unregister_chrdev(test_major，"test");
}
在用rmmod卸载模块时，cleanup_mole函数被调用，它释放字符设备test在系统字符设备表中占有的表项。
一个极其简单的字符设备可以说写好了，文件名就叫test.c吧。
下面编译 :
$ gcc -O2 -DMODULE -D__KERNEL__ -c test.c
得到文件test.o就是一个设备驱动程序。
如果设备驱动程序有多个文件，把每个文件按上面的命令行编译，然后
ld -r file1.o file2.o -o molename。
驱动程序已经编译好了，现在把它安装到系统中去。
$ insmod –f test.o
如果安装成功，在/proc/devices文件中就可以看到设备test，并可以看到它的主设备号。要卸载的话，运行 :
$ rmmod test
下一步要创建设备文件。
mknod /dev/test c major minor
c 是指字符设备，major是主设备号，就是在/proc/devices里看到的。
用shell命令
$ cat /proc/devices
就可以获得主设备号，可以把上面的命令行加入你的shell script中去。
minor是从设备号，设置成0就可以了。
我们现在可以通过设备文件来访问我们的驱动程序。写一个小小的测试程序。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
main()
{
int testdev;
int i;
char buf[10];
testdev = open("/dev/test"，O_RDWR);
if ( testdev == -1 )
{
printf("Cann't open file \n");
exit(0);
}
read(testdev，buf，10);
for (i = 0; i < 10;i++)
printf("%d\n"，buf[i]);
close(testdev);
}

编译运行，看看是不是打印出全1 ？
以上只是一个简单的演示。真正实用的驱动程序要复杂的多，要处理如中断，dma，I/O port等问题。这些才是真正的难点。请看下节，实际情况的处理。
如何编写Linux操作系统下的设备驱动程序
三、设备驱动程序中的一些具体问题
1。 I/O Port。
和硬件打交道离不开I/O Port，老的isa设备经常是占用实际的I/O端口，在linux下，操作系统没有对I/O口屏蔽，也就是说，任何驱动程序都可对任意的I/O口操作，这样就很容易引起混乱。每个驱动程序应该自己避免误用端口。
有两个重要的kernel函数可以保证驱动程序做到这一点。
1）check_region(int io_port， int off_set)
这个函数察看系统的I/O表，看是否有别的驱动程序占用某一段I/O口。
参数1：I/O端口的基地址，
参数2：I/O端口占用的范围。
返回值：0 没有占用， 非0，已经被占用。
2）request_region(int io_port， int off_set，char *devname)
如果这段I/O端口没有被占用，在我们的驱动程序中就可以使用它。在使用之前，必须向系统登记，以防止被其他程序占用。登记后，在/proc/ioports文件中可以看到你登记的I/O口。
参数1：io端口的基地址。
参数2：io端口占用的范围。
参数3：使用这段io地址的设备名。
在对I/O口登记后，就可以放心地用inb()， outb()之类的函来访问了。
在一些pci设备中，I/O端口被映射到一段内存中去，要访问这些端口就相当于访问一段内存。经常性的，我们要获得一块内存的物理地址。

2。内存操作
在设备驱动程序中动态开辟内存，不是用malloc，而是kmalloc，或者用get_free_pages直接申请页。释放内存用的是kfree，或free_pages。 请注意，kmalloc等函数返回的是物理地址！
注意，kmalloc最大只能开辟128k-16，16个字节是被页描述符结构占用了。
内存映射的I/O口，寄存器或者是硬件设备的ram(如显存)一般占用F0000000以上的地址空间。在驱动程序中不能直接访问，要通过kernel函数vremap获得重新映射以后的地址。
另外，很多硬件需要一块比较大的连续内存用作dma传送。这块程序需要一直驻留在内存，不能被交换到文件中去。但是kmalloc最多只能开辟128k的内存。
这可以通过牺牲一些系统内存的方法来解决。

3。中断处理
同处理I/O端口一样，要使用一个中断，必须先向系统登记。
int request_irq(unsigned int irq ，void(*handle)(int，void *，struct pt_regs *)，
unsigned int long flags， const char *device);
irq: 是要申请的中断。
handle：中断处理函数指针。
flags：SA_INTERRUPT 请求一个快速中断，0 正常中断。
device：设备名。

如果登记成功，返回0，这时在/proc/interrupts文件中可以看你请求的中断。
4。一些常见的问题。
对硬件操作，有时时序很重要（关于时序的具体问题就要参考具体的设备芯片手册啦！比如网卡芯片RTL8139）。但是如果用C语言写一些低级的硬件操作的话，gcc往往会对你的程序进行优化，这样时序会发生错误。如果用汇编写呢，gcc同样会对汇编代码进行优化，除非用volatile关键字修饰。最保险的办法是禁止优化。这当然只能对一部分你自己编写的代码。如果对所有的代码都不优化，你会发现驱动程序根本无法装载。这是因为在编译驱动程序时要用到gcc的一些扩展特性，而这些扩展特性必须在加了优化选项之后才能体现出来。
写在后面：学习Linux确实不是一件容易的事情，因为要付出很多精力，也必须具备很好的C语言基础；但是，学习Linux也是一件非常有趣的事情，它里面包含了许多高手的智慧和“幽默”，这些都需要自己亲自动手才能体会到，O(∩_∩)O~哈哈！

❸ 如何编写Linux设备驱动程序

如何编写Linux设备驱动程序
回想学习Linux操作系统已经有近一年的时间了，前前后后，零零碎碎的一路学习过来，也该试着写的东西了。也算是给自己能留下一点记忆和回忆吧！由于完全是自学的，以下内容若有不当之处，还请大家多指教。
Linux是Unix操作系统的一种变种，在Linux下编写驱动程序的原理和思想完全类似于其他的Unix系统，但它dos或window环境下的驱动程序有很大的区别。在Linux环境下设计驱动程序，思想简洁，操作方便，功能也很强大，但是支持函数少，只能依赖kernel中的函数，有些常用的操作要自己来编写，而且调试也不方便。
以下的一些文字主要来源于khg，johnsonm的Write linux device driver，Brennan's Guide to Inline Assembly，The Linux A-Z，还有清华BBS上的有关device driver的一些资料。
一、Linux device driver 的概念
系统调用是操作系统内核和应用程序之间的接口，设备驱动程序是操作系统内核和机器硬件之间的接口。设备驱动程序为应用程序屏蔽了硬件的细节，这样在应用程序看来，硬件设备只是一个设备文件，应用程序可以象操作普通文件一样对硬件设备进行操作。设备驱动程序是内核的一部分，它完成以下的功能:
1、对设备初始化和释放。
2、把数据从内核传送到硬件和从硬件读取数据。
3、读取应用程序传送给设备文件的数据和回送应用程序请求的数据。
4、检测和处理设备出现的错误。
在Linux操作系统下有三类主要的设备文件类型，一是字符设备，二是块设备，三是网络设备。字符设备和块设备的主要区别是:在对字符设备发出读/写请求时，实际的硬件I/O一般就紧接着发生了，块设备则不然，它利用一块系统内存作缓冲区，当用户进程对设备请求能满足用户的要求，就返回请求的数据，如果不能，就调用请求函数来进行实际的I/O操作。块设备是主要针对磁盘等慢速设备设计的，以免耗费过多的CPU时间来等待。
已经提到，用户进程是通过设备文件来与实际的硬件打交道。每个设备文件都都有其文件属性(c/b)，表示是字符设备还是块设备?另外每个文件都有两个设备号，第一个是主设备号，标识驱动程序，第二个是从设备号，标识使用同一个设备驱动程序的不同的硬件设备，比如有两个软盘，就可以用从设备号来区分他们。设备文件的的主设备号必须与设备驱动程序在登记时申请的主设备号一致，否则用户进程将无法访问到驱动程序。
最后必须提到的是，在用户进程调用驱动程序时，系统进入核心态，这时不再是抢先式调度。也就是说，系统必须在你的驱动程序的子函数返回后才能进行其他的工作。如果你的驱动程序陷入死循环，不幸的是你只有重新启动机器了，然后就是漫长的fsck。
读/写时，它首先察看缓冲区的内容，如果缓冲区的数据未被处理，则先处理其中的内容。
如何编写Linux操作系统下的设备驱动程序

二、实例剖析
我们来写一个最简单的字符设备驱动程序。虽然它什么也不做，但是通过它可以了解Linux的设备驱动程序的工作原理。把下面的C代码输入机器，你就会获得一个真正的设备驱动程序。
#define __NO_VERSION__
#include <linux/moles.h>
#include <linux/version.h>
char kernel_version [] = UTS_RELEASE;
这一段定义了一些版本信息，虽然用处不是很大，但也必不可少。Johnsonm说所有的驱动程序的开头都要包含<linux/config.h>，一般来讲最好使用。
由于用户进程是通过设备文件同硬件打交道，对设备文件的操作方式不外乎就是一些系统调用，如 open，read，write，close…， 注意，不是fopen， fread，但是如何把系统调用和驱动程序关联起来呢?这需要了解一个非常关键的数据结构：
struct file_operations
{
int (*seek) (struct inode * ，struct file *， off_t ，int);
int (*read) (struct inode * ，struct file *， char ，int);
int (*write) (struct inode * ，struct file *， off_t ，int);
int (*readdir) (struct inode * ，struct file *， struct dirent * ，int);
int (*select) (struct inode * ，struct file *， int ，select_table *);
int (*ioctl) (struct inode * ，struct file *， unsined int ，unsigned long);
int (*mmap) (struct inode * ，struct file *， struct vm_area_struct *);
int (*open) (struct inode * ，struct file *);
int (*release) (struct inode * ，struct file *);
int (*fsync) (struct inode * ，struct file *);
int (*fasync) (struct inode * ，struct file *，int);
int (*check_media_change) (struct inode * ，struct file *);
int (*revalidate) (dev_t dev);
}

这个结构的每一个成员的名字都对应着一个系统调用。用户进程利用系统调用在对设备文件进行诸如read/write操作时，系统调用通过设备文件的主设备号找到相应的设备驱动程序，然后读取这个数据结构相应的函数指针，接着把控制权交给该函数。这是linux的设备驱动程序工作的基本原理。既然是这样，则编写设备驱动程序的主要工作就是编写子函数，并填充file_operations的各个域。
下面就开始写子程序。
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include<linux/config.h>
#include <linux/errno.h>
#include <asm/segment.h>
unsigned int test_major = 0;
static int read_test(struct inode *node，struct file *file，char *buf，int count)
{
int left;
if (verify_area(VERIFY_WRITE，buf，count) == -EFAULT )
return -EFAULT;
for(left = count ; left > 0 ; left--)
{
__put_user(1，buf，1);
buf++;
}
return count;
}

这个函数是为read调用准备的。当调用read时，read_test()被调用，它把用户的缓冲区全部写1。buf 是read调用的一个参数。它是用户进程空间的一个地址。但是在read_test被调用时，系统进入核心态。所以不能使用buf这个地址，必须用__put_user()，这是kernel提供的一个函数，用于向用户传送数据。另外还有很多类似功能的函数。请参考Robert著的《Linux内核设计与实现》（第二版）。然而，在向用户空间拷贝数据之前，必须验证buf是否可用。这就用到函数verify_area。
static int write_tibet(struct inode *inode，struct file *file，const char *buf，int count)
{
return count;
}
static int open_tibet(struct inode *inode，struct file *file )
{
MOD_INC_USE_COUNT;
return 0;
}
static void release_tibet(struct inode *inode，struct file *file )
{
MOD_DEC_USE_COUNT;
}

这几个函数都是空操作。实际调用发生时什么也不做，他们仅仅为下面的结构提供函数指针。
struct file_operations test_fops = {
NULL，
read_test，
write_test，
NULL， /* test_readdir */
NULL，
NULL， /* test_ioctl */
NULL， /* test_mmap */
open_test，
release_test，
NULL， /* test_fsync */
NULL， /* test_fasync */
/* nothing more， fill with NULLs */
};
这样，设备驱动程序的主体可以说是写好了。现在要把驱动程序嵌入内核。驱动程序可以按照两种方式编译。一种是编译进kernel，另一种是编译成模块(moles)，如果编译进内核的话，会增加内核的大小，还要改动内核的源文件，而且不能动态的卸载，不利于调试，所以推荐使用模块方式。
int init_mole(void)
{
int result;
result = register_chrdev(0， "test"， &test_fops);
if (result < 0) {
printk(KERN_INFO "test: can't get major number\n");
return result;
}
if (test_major == 0) test_major = result; /* dynamic */
return 0;
}

在用insmod命令将编译好的模块调入内存时，init_mole 函数被调用。在这里，init_mole只做了一件事，就是向系统的字符设备表登记了一个字符设备。register_chrdev需要三个参数，参数一是希望获得的设备号，如果是零的话，系统将选择一个没有被占用的设备号返回。参数二是设备文件名，参数三用来登记驱动程序实际执行操作的函数的指针。
如果登记成功，返回设备的主设备号，不成功，返回一个负值。
void cleanup_mole(void)
{
unregister_chrdev(test_major，"test");
}
在用rmmod卸载模块时，cleanup_mole函数被调用，它释放字符设备test在系统字符设备表中占有的表项。
一个极其简单的字符设备可以说写好了，文件名就叫test.c吧。
下面编译 :
$ gcc -O2 -DMODULE -D__KERNEL__ -c test.c
得到文件test.o就是一个设备驱动程序。
如果设备驱动程序有多个文件，把每个文件按上面的命令行编译，然后
ld -r file1.o file2.o -o molename。
驱动程序已经编译好了，现在把它安装到系统中去。
$ insmod –f test.o
如果安装成功，在/proc/devices文件中就可以看到设备test，并可以看到它的主设备号。要卸载的话，运行 :
$ rmmod test
下一步要创建设备文件。
mknod /dev/test c major minor
c 是指字符设备，major是主设备号，就是在/proc/devices里看到的。
用shell命令
$ cat /proc/devices
就可以获得主设备号，可以把上面的命令行加入你的shell script中去。
minor是从设备号，设置成0就可以了。
我们现在可以通过设备文件来访问我们的驱动程序。写一个小小的测试程序。
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
main()
{
int testdev;
int i;
char buf[10];
testdev = open("/dev/test"，O_RDWR);
if ( testdev == -1 )
{
printf("Cann't open file \n");
exit(0);
}
read(testdev，buf，10);
for (i = 0; i < 10;i++)
printf("%d\n"，buf[i]);
close(testdev);
}

编译运行，看看是不是打印出全1 ？
以上只是一个简单的演示。真正实用的驱动程序要复杂的多，要处理如中断，DMA，I/O port等问题。这些才是真正的难点。请看下节，实际情况的处理。
如何编写Linux操作系统下的设备驱动程序
三、设备驱动程序中的一些具体问题
1。 I/O Port。
和硬件打交道离不开I/O Port，老的ISA设备经常是占用实际的I/O端口，在linux下，操作系统没有对I/O口屏蔽，也就是说，任何驱动程序都可对任意的I/O口操作，这样就很容易引起混乱。每个驱动程序应该自己避免误用端口。
有两个重要的kernel函数可以保证驱动程序做到这一点。
1）check_region(int io_port， int off_set)
这个函数察看系统的I/O表，看是否有别的驱动程序占用某一段I/O口。
参数1：I/O端口的基地址，
参数2：I/O端口占用的范围。
返回值：0 没有占用， 非0，已经被占用。
2）request_region(int io_port， int off_set，char *devname)
如果这段I/O端口没有被占用，在我们的驱动程序中就可以使用它。在使用之前，必须向系统登记，以防止被其他程序占用。登记后，在/proc/ioports文件中可以看到你登记的I/O口。
参数1：io端口的基地址。
参数2：io端口占用的范围。
参数3：使用这段io地址的设备名。
在对I/O口登记后，就可以放心地用inb()， outb()之类的函来访问了。
在一些pci设备中，I/O端口被映射到一段内存中去，要访问这些端口就相当于访问一段内存。经常性的，我们要获得一块内存的物理地址。

2。内存操作
在设备驱动程序中动态开辟内存，不是用malloc，而是kmalloc，或者用get_free_pages直接申请页。释放内存用的是kfree，或free_pages。 请注意，kmalloc等函数返回的是物理地址！
注意，kmalloc最大只能开辟128k-16，16个字节是被页描述符结构占用了。
内存映射的I/O口，寄存器或者是硬件设备的RAM(如显存)一般占用F0000000以上的地址空间。在驱动程序中不能直接访问，要通过kernel函数vremap获得重新映射以后的地址。
另外，很多硬件需要一块比较大的连续内存用作DMA传送。这块程序需要一直驻留在内存，不能被交换到文件中去。但是kmalloc最多只能开辟128k的内存。
这可以通过牺牲一些系统内存的方法来解决。

3。中断处理
同处理I/O端口一样，要使用一个中断，必须先向系统登记。
int request_irq(unsigned int irq ，void(*handle)(int，void *，struct pt_regs *)，
unsigned int long flags， const char *device);
irq: 是要申请的中断。
handle：中断处理函数指针。
flags：SA_INTERRUPT 请求一个快速中断，0 正常中断。
device：设备名。

如果登记成功，返回0，这时在/proc/interrupts文件中可以看你请求的中断。
4。一些常见的问题。
对硬件操作，有时时序很重要（关于时序的具体问题就要参考具体的设备芯片手册啦！比如网卡芯片RTL8139）。但是如果用C语言写一些低级的硬件操作的话，gcc往往会对你的程序进行优化，这样时序会发生错误。如果用汇编写呢，gcc同样会对汇编代码进行优化，除非用volatile关键字修饰。最保险的办法是禁止优化。这当然只能对一部分你自己编写的代码。如果对所有的代码都不优化，你会发现驱动程序根本无法装载。这是因为在编译驱动程序时要用到gcc的一些扩展特性，而这些扩展特性必须在加了优化选项之后才能体现出来。
写在后面：学习Linux确实不是一件容易的事情，因为要付出很多精力，也必须具备很好的C语言基础；但是，学习Linux也是一件非常有趣的事情，它里面包含了许多高手的智慧和“幽默”，这些都需要自己亲自动手才能体会到，O(∩_∩)O~哈哈！

❹ 如何编写驱动程序

代码：

#include&lt;linux/mole.h&gt;

#include&lt;linux/kernel.h&gt;

#include&lt;asm/io.h&gt;

#include&lt;linux/miscdevice.h&gt;

#include&lt;linux/fs.h&gt;

#include&lt;asm/uaccess.h&gt;

//流水灯代码

#define GPM4CON 0x110002e0

#define GPM4DAT 0x110002e4

static unsigned long*ledcon=NULL;

static unsigned long*leddat=NULL;

//自定义write文件操作(不自定义的话，内核有默认的一套文件操作函数)

static ssize_t test_write(struct file*filp,const char __user*buff,size_t count,loff_t*offset)

{

int value=0;

int ret=0;

ret=_from_user(&value,buff,4);

//底层驱动只定义基本操作动作，不定义功能

if(value==1)

{

*leddat|=0x0f;

*leddat&=0xfe;

}

if(value==2)

{

*leddat|=0x0f;

*leddat&=0xfd;

}

if(value==3)

{

*leddat|=0x0f;

*leddat&=0xfb;

}

if(value==4)

{

*leddat|=0x0f;

*leddat&=0xf7;

}

return 0;

}

//文件操作结构体初始化

static struct file_operations g_tfops={

.owner=THIS_MODULE,

.write=test_write,

};

//杂设备信息结构体初始化

static struct miscdevice g_tmisc={

.minor=MISC_DYNAMIC_MINOR,

.name="test_led",

.fops=&g_tfops,

};

//驱动入口函数杂设备初始化

static int __init test_misc_init(void)

{

//IO地址空间映射到内核的虚拟地址空间

ledcon=ioremap(GPM4CON,4);

leddat=ioremap(GPM4DAT,4);

//初始化led

*ledcon&=0xffff0000;

*ledcon|=0x00001111;

*leddat|=0x0f;

//杂设备注册函数

misc_register(&g_tmisc);

return 0;

}

//驱动出口函数

static void __exit test_misc_exit(void)

{

//释放地址映射

iounmap(ledcon);

iounmap(leddat);

}

//指定模块的出入口函数

mole_init(test_misc_init);

mole_exit(test_misc_exit);

MODULE_LICENSE("GPL");

(4)驱动程序如何定义设备扩展阅读：

include用法：

#include命令预处理命令的一种，预处理命令可以将别的源代码内容插入到所指定的位置；可以标识出只有在特定条件下才会被编译的某一段程序代码；可以定义类似标识符功能的宏，在编译时，预处理器会用别的文本取代该宏。

插入头文件的内容

#include命令告诉预处理器将指定头文件的内容插入到预处理器命令的相应位置。有两种方式可以指定插入头文件：

1、#include&lt;文件名&gt;

2、#include"文件名"

如果需要包含标准库头文件或者实现版本所提供的头文件，应该使用第一种格式。如下例所示：

#include&lt;math.h&gt;//一些数学函数的原型，以及相关的类型和宏

如果需要包含针对程序所开发的源文件，则应该使用第二种格式。

采用#include命令所插入的文件，通常文件扩展名是.h，文件包括函数原型、宏定义和类型定义。只要使用#include命令，这些定义就可被任何源文件使用。如下例所示：

#include"myproject.h"//用在当前项目中的函数原型、类型定义和宏

你可以在#include命令中使用宏。如果使用宏，该宏的取代结果必须确保生成正确的#include命令。例1展示了这样的#include命令。

【例1】在#include命令中的宏

#ifdef _DEBUG_

#define MY_HEADER"myProject_dbg.h"

#else

#define MY_HEADER"myProject.h"

#endif

#include MY_HEADER

当上述程序代码进入预处理时，如果_DEBUG_宏已被定义，那么预处理器会插入myProject_dbg.h的内容；如果还没定义，则插入myProject.h的内容。

❺ 组态软件的设备驱动是怎么实现的

关于工控组态软件中设备驱动程序的思考
在工控组态软件的开发过程中，如何将大量不同的外部设备接入到系统中，是一个非常重要也是非常麻烦的事情；在系统发布后，此项工作基本上就成了软件维护工作的同义词。
将外部设备接入到系统的难度在于：
1、 部设备厂家众多，种类繁杂，数据交换方式多种多样，处理方法各不相同。
2、 外部设备必须与系统主程序分开，不能够每增加一个外部设备就得重新编译整个系统。
3、 外部设备接入系统的方法和接口必须向用户公开，但又不能公开整个系统。
4、 外部设备接入系统的方法必须简单，必须支持多种编程语言。
归纳起来，外部设备与系统的数据交换方式有如下几种：
1、 过RS232、RS485、RS422、MODEM等串行通讯设备进行通讯（如GE PLC）。
2、 通过PCI、ISA等方式（如研华的812PG模拟量采集卡）。
3、 现场总线网络（如Lonworks网络）。
4、 以太网络。
5、 USB接口。
6、 DDE方式。
7、 OPC方式。
8、 窗口消息方式（如某些电力系统的五防接口）。
9、 等等。
现在流行的解决办法有如下几种：
1、 一台数据处理前置机，前置机与系统主机之机通过系统内定标准的方式，方式公开，在前置机实现不同外部数据的标准化。
2、 通过硬件的规约转换器实现（但仅用在诸如串行设备和现场总线等方面）。
3、 为每一种外部设备编制通讯管理程序，将外部数据标准化并通过标准的网络通讯规约传入系统。
4、 以C语言格式提供标准的DLL访问方式，在DLL中将外部数据标准化。
5、 以COM方式编程，提供标准的访问接口。
6、 提供OPC接口。
本人在主持开发电力工控组态软件的过程中，选用的是第3种解决办法，即通过为每一种外部设备编制通讯管理程序，将外部数据标准化并通过标准的网络通讯规约传入系统。当时选用此方法的原因是：
1、 单机与网络环境下的编程一致性。
2、 编程简单，给用户提供基于Winsocket的标准规约，以及编程例子，用户只需按照规约要求向系统传送数据即可。
3、 程序实现的语言无关，只要提供Winsocket编程即可。
系统推出至今，效果良好，但在系统维护的过程中，也发现一些问题：
1、 每一种外部设备的管理程序都是一个单独的执行程序，当外挂的外部设备种类比较多时，系统的任务栏比较杂乱。
2、 在用户不熟悉系统时，会关闭某些外部设备管理程序，会误运行外部设备管理程序。
4、 外部接口通讯管理程序的实现不够规范，用户的发挥余地太大，反而无所适从。
5、 外部接口通讯管理程序的编程工作量相对较大，而且必须将相当部分的精力放在界面的编制上。
由于种种原因，本人在软件的升级开发中，决定放弃这种方法，转而使用基于COM的编程方式，采用类似插件的方法来实现外部设备的接入，初步设想如下：
1、 从理论上分析，采用OPC的方法也许最符合工控组态软件的发展方向。但是，工控组态软件的开发重点是为不同行业提供通用软件平台，并给用户更多的二次开发能力。本人主持开发的软件不完全是一个组态软件，它只是吸取了组态软件的思想，也决定解决组态软件的许多不足。因为本软件的应用领域是电力系统、水力系统，这两个行业的软件有许多可以归纳的特征。不必象组态软件那样一切从零开始。而OPC也只是组态软件的产生物，许多复杂的数据结构用它处理不太方便（不是不能处理）。
2、 COM是现在软件的发展方向，DCOM和COM可以无缝地结合，使得软件不需修改即可在单机或网络环境下使用。采取统一接口的方式也为用户提供了固定、简单的编程模式。并可实现用户可选择的编程语言无关性。
3、 在系统中对外部设备的定义如下：
计算机一[本地]
外部设备种类一
外部设备一
外部设备二
外部设备三
外部设备种类二
外部设备一
外部设备二
外部设备三
外部设备种类三
外部设备一
外部设备二
外部设备三
计算机二
外部设备种类一
外部设备一
外部设备二
外部设备三
计算机三
……
提供一个针对每一种外部设备的标准访问接口（是每一种，也就是说每一种外部设备有多个外部设备），定义如下：
属性Opened： 外部设备是否已打开
函数Open： 启动外部设备的处理，该函数启动一个循环处理接收和发送的线程
函数Close： 停止外部设备的处理
函数WriteData： 向外部设备写入数据，在数据中包括了写入的地址（因为同一种外设有多个），参数是Variant数组。
事件OnReadData： 当外部设备有数据时产生，并由主程序接收该数据，参数是Variant数组。采用事件而不是函数的原因是保证实时性。
函数SetPara： 设置针对每一种外设的特殊参数设置，而通用设置在主程序中完成。
函数SetDeviceNum： 设置每一种外设的数量。
函数SetDevicePara： 设置针对每一个外设和特殊参数设置，而通用设置在主程序中完成。
4、 主系统处理流程如下：
外设编程时：
为每一种外设编制程序，都实现上述的接口，外部设备程序以Active动态库（DLL）提供。
配置系统时：
从许多已编制的外设程序中选择所需的，配置参数（可能要调用SetPara、SetDeviceNum、SetDevcePara等函数），并形成外设信息文件（不是注册表，因为所有信息可能要复制到另外的计算机上重复使用）。
系统启动时：
从信息文件中读出需要打开的的外部设备动态库，调用Open函数。
系统退出时：
将每个已打开的外设通过Close关闭。
系统运行时：
当接收到系统需要向外设发送数据的消息时，查找对应的外设模块，调用WriteData。当接收到外设OnReadData消息时，处理外设数据。
本人正在为此作前期准备工作，也尝试了一些实验，取得了一些经验，发现了一些问题，希望与各位交流：
1、 在只知道某DLL的程序名时（没有独立的类库文件），如何在运行状态下（不是编译时）判断它是否是支持接口的动态库，是否支持本接口（名为IdeviceAccess）？
2、 在只知道某DLL的程序名时，如何在运行状态下动态地建立它的对象接口，并访问它？
3、 您对此问题有什么高见（不一定是这两个技术细节问题）？

❻ 怎样写linux下的USB设备驱动程序

USB驱动程序基础
在动手写USB驱动程序这前，让我们先看看写的USB驱动程序在内核中的结构，如下图：

USB通信最基本的形式是通过端点（USB端点分中断、批量、等时、控制四种，每种用途不同），USB端点只能往一个方向传送数据，从主机到设备或者从设备到主机，端点可以看作是单向的管道（pipe）。所以我们可以这样认为：设备通常具有一个或者更多的配置，配置经常具有一个或者更多的接口，接口通常具有一个或者更多的设置，接口没有或具有一个以上的端点。驱动程序把驱动程序对象注册到USB子系统中，稍后再使用制造商和设备标识来判断是否已经安装了硬件。USB核心使用一个列表（是一个包含制造商ID和设备号ID的一个结构体）来判断对于一个设备该使用哪一个驱动程序，热插拨脚本使用它来确定当一个特定的设备插入到系统时该自动装载哪一个驱动程序。
上面我们简要说明了驱动程序的基本理论，在写一个设备驱动程序之前，我们还要了解以下两个概念：模块和设备文件。
模块：是在内核空间运行的程序，实际上是一种目标对象文件，没有链接，不能独立运行，但是可以装载到系统中作为内核的一部分运行，从而可以动态扩充内核的功能。模块最主要的用处就是用来实现设备驱动程序。Linux下对于一个硬件的驱动，可以有两种方式：直接加载到内核代码中，启动内核时就会驱动此硬件设备。另一种就是以模块方式，编译生成一个.ko文件(在2.4以下内核中是用.o作模块文件，我们以2.6的内核为准，以下同)。当应用程序需要时再加载到内核空间运行。所以我们所说的一个硬件的驱动程序，通常指的就是一个驱动模块。
设备文件：对于一个设备，它可以在/dev下面存在一个对应的逻辑设备节点，这个节点以文件的形式存在，但它不是普通意义上的文件，它是设备文件，更确切的说，它是设备节点。这个节点是通过mknod命令建立的，其中指定了主设备号和次设备号。主设备号表明了某一类设备，一般对应着确定的驱动程序；次设备号一般是区分不同属性，例如不同的使用方法，不同的位置，不同的操作。这个设备号是从/proc/devices文件中获得的，所以一般是先有驱动程序在内核中，才有设备节点在目录中。这个设备号（特指主设备号）的主要作用，就是声明设备所使用的驱动程序。驱动程序和设备号是一一对应的，当你打开一个设备文件时，操作系统就已经知道这个设备所对应的驱动程序。对于一个硬件，Linux是这样来进行驱动的：首先，我们必须提供一个.ko的驱动模块文件。我们要使用这个驱动程序，首先要加载它，我们可以用insmod
xxx.ko，这样驱动就会根据自己的类型（字符设备类型或块设备类型，例如鼠标就是字符设备而硬盘就是块设备）向系统注册，注册成功系统会反馈一个主设备号，这个主设备号就是系统对它的唯一标识。驱动就是根据此主设备号来创建一个一般放置在/dev目录下的设备文件。在我们要访问此硬件时，就可以对设备文件通过open、read、write、close等命令进行。而驱动就会接收到相应的read、write操作而根据自己的模块中的相应函数进行操作了。

USB驱动程序实践
了解了上述理论后，我们就可以动手写驱动程序，如果你基本功好，而且写过linux下的硬件驱动，USB的硬件驱动和pci_driver很类似，那么写USB的驱动就比较简单了，如果你只是大体了解了linux的硬件驱动，那也不要紧，因为在linux的内核源码中有一个框架程序可以拿来借用一下，这个框架程序在/usr/src/~（你的内核版本，以下同）/drivers/usb下，文件名为usb-skeleton.c。写一个USB的驱动程序最基本的要做四件事：驱动程序要支持的设备、注册USB驱动程序、探测和断开、提交和控制urb（USB请求块）（当然也可以不用urb来传输数据，下文我们会说到）。
驱动程序支持的设备：有一个结构体struct
usb_device_id，这个结构体提供了一列不同类型的该驱动程序支持的USB设备，对于一个只控制一个特定的USB设备的驱动程序来说，struct
usb_device_id表被定义为：
/* 驱动程序支持的设备列表 */
static struct usb_device_id
skel_table [] = {
{ USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID)
},
{ } /* 终止入口 */
};
MODULE_DEVICE_TABLE (usb,
skel_table);
对于PC驱动程序，MODULE_DEVICE_TABLE是必需的，而且usb必需为该宏的第一个值，而USB_SKEL_VENDOR_ID和USB_SKEL_PRODUCT_ID就是这个特殊设备的制造商和产品的ID了，我们在程序中把定义的值改为我们这款USB的，如：
/*
定义制造商和产品的ID号 */
#define USB_SKEL_VENDOR_ID 0x1234
#define
USB_SKEL_PRODUCT_ID
0x2345
这两个值可以通过命令lsusb，当然你得先把USB设备先插到主机上了。或者查看厂商的USB设备的手册也能得到，在我机器上运行lsusb是这样的结果：
Bus
004 Device 001: ID 0000:0000
Bus 003 Device 002: ID 1234:2345 Abc Corp.

Bus 002 Device 001: ID 0000:0000
Bus 001 Device 001: ID
0000:0000
得到这两个值后把它定义到程序里就可以了。
注册USB驱动程序：所有的USB驱动程序都必须创建的结构体是struct
usb_driver。这个结构体必须由USB驱动程序来填写，包括许多回调函数和变量，它们向USB核心代码描述USB驱动程序。创建一个有效的struct
usb_driver结构体，只须要初始化五个字段就可以了，在框架程序中是这样的：
static struct usb_driver skel_driver
= {
.owner = THIS_MODULE,
.name = "skeleton",

.probe = skel_probe,
.disconnect = skel_disconnect,

.id_table = skel_table,
};

❼ 试图连接一个与驱动程序中指定的设备不同的设备。检查驱动程序设置和设备。

你好！试图连接一个与驱动程序中指定的设备不同的设备 说明你的机器主板变改过了，需要用软件刷才行！

❽ 试图连接一个与驱动程序中指定的设备不同的设备。检查驱动程序设置和设备。 这个问题想请教下怎么修复

只要你首先自己知道要安装的设备名称就行，也就是设备名字。