驅動程序如何定義設備

❶ 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,
};

❼ 試圖連接一個與驅動程序中指定的設備不同的設備。檢查驅動程序設置和設備。

你好！試圖連接一個與驅動程序中指定的設備不同的設備 說明你的機器主板變改過了，需要用軟體刷才行！

❽ 試圖連接一個與驅動程序中指定的設備不同的設備。檢查驅動程序設置和設備。 這個問題想請教下怎麼修復

只要你首先自己知道要安裝的設備名稱就行，也就是設備名字。