linux大數據驅動

⑴ linux網路設備驅動的具體結構

Linux網路設備驅動程序的體系結構從上到下可以劃分為4層，依次為網路協議介面層、網路設備介面層、提供實際功能的設備驅動功能層以及網路設備與媒介層，這4層的作用如下所示：
1）網路協議介面層向網路層協議提供統一的數據包收發介面，不論上層協議是ARP，還是IP，都通過dev_queue_xmit() 函數發送數據，並通過netif rx ()函數接收數據。這一層的存在使得上層協議獨立於具體的設備。
2）網路設備介面層向協議介面層提供統一的用於描述具體網路設備屬性和操作的結構體net device,該結構體是設備驅動功能層中各函數的容器。實際上，網路設備介面層從宏觀上規劃了具體操作硬體的設備驅動功能層的結構。
3）設備驅動功能層的各函數是網路設備介面層net_device數據結構的具體成員，是驅使網路設備硬體完成相應動作的程序，它通過hard_start_ xmit ()函數啟動發送操作，並通過網路設備上的中斷觸發接收操作。
4）網路設備與媒介層是完成數據包發送和接收的物理實體，包括網路適配器和具體的傳輸媒介，網路適配器被設備驅動功能層中的函數在物理上驅動。對於Linux系統而言，網路設備和媒介都可以是虛擬的。

⑵ linux USB驅動資料

《LINUX設備驅動程序》

USB骨架程序（usb-skeleton），是驅動程序的基礎，通過對它源碼的學習和理解，可以使我們迅速地了解USB驅動架構，迅速地開發我們自己的USB硬體的驅動。
前言
在上篇《Linux下的硬體驅動--USB設備（上）（驅動配製部分）》中，我們知道了在Linux下如何去使用一些最常見的USB設備。但對於做系統設計的程序員來說，這是遠遠不夠的，我們還需要具有驅動程序的閱讀、修改和開發能力。在此下篇中，就是要通過簡單的USB驅動的例子，隨您一起進入 USB驅動開發的世界。
USB驅動開發
在掌握了USB設備的配置後，對於程序員，我們就可以嘗試進行一些簡單的USB驅動的修改和開發了。這一段落，我們會講解一個最基礎USB框架的基礎上，做兩個小的USB驅動的例子。
USB骨架
在Linux kernel源碼目錄中driver/usb/usb-skeleton.c為我們提供了一個最基礎的USB驅動程序。我們稱為USB骨架。通過它我們僅需要修改極少的部分，就可以完成一個USB設備的驅動。我們的USB驅動開發也是從她開始的。
那些linux下不支持的USB設備幾乎都是生產廠商特定的產品。如果生產廠商在他們的產品中使用自己定義的協議，他們就需要為此設備創建特定的驅動程序。當然我們知道，有些生產廠商公開他們的USB協議，並幫助Linux驅動程序的開發，然而有些生產廠商卻根本不公開他們的USB協議。因為每一個不同的協議都會產生一個新的驅動程序，所以就有了這個通用的USB驅動骨架程序， 它是以pci 骨架為模板的。
如果你准備寫一個linux驅動程序，首先要熟悉USB協議規范。USB主頁上有它的幫助。一些比較典型的驅動可以在上面發現，同時還介紹了USB urbs的概念，而這個是usb驅動程序中最基本的。
Linux USB 驅動程序需要做的第一件事情就是在Linux USB 子系統里注冊，並提供一些相關信息，例如這個驅動程序支持那種設備，當被支持的設備從系統插入或拔出時，會有哪些動作。所有這些信息都傳送到USB 子系統中，在usb骨架驅動程序中是這樣來表示的：
static struct usb_driver skel_driver = {
name: "skeleton",
probe: skel_probe,
disconnect: skel_disconnect,
fops: &skel_fops,
minor: USB_SKEL_MINOR_BASE,
id_table: skel_table,
};
變數name是一個字元串，它對驅動程序進行描述。probe 和disconnect 是函數指針，當設備與在id_table 中變數信息匹配時，此函數被調用。
fops和minor變數是可選的。大多usb驅動程序鉤住另外一個驅動系統，例如SCSI，網路或者tty子系統。這些驅動程序在其他驅動系統中注冊，同時任何用戶空間的交互操作通過那些介面提供，比如我們把SCSI設備驅動作為我們USB驅動所鉤住的另外一個驅動系統，那麼我們此USB設備的 read、write等操作，就相應按SCSI設備的read、write函數進行訪問。但是對於掃描儀等驅動程序來說，並沒有一個匹配的驅動系統可以使用，那我們就要自己處理與用戶空間的read、write等交互函數。Usb子系統提供一種方法去注冊一個次設備號和file_operations函數指針，這樣就可以與用戶空間實現方便地交互。

⑶ Linux驅動程序的工作原理

由於你的問題太長我只好轉載別人的手打的太累不好意思~~~
Linux是Unix***作系統的一種變種,在Linux下編寫驅動程序的原理和

思想完全類似於其他的Unix系統,但它dos或window環境下的驅動程序有很大的

區別.在Linux環境下設計驅動程序,思想簡潔,***作方便,功芤埠芮看?但是

支持函數少,只能依賴kernel中的函數,有些常用的***作要自己來編寫,而且調

試也不方便.本人這幾周來為實驗室自行研製的一塊多媒體卡編制了驅動程序,

獲得了一些經驗,願與Linux fans共享,有不當之處,請予指正.

以下的一些文字主要來源於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.//hehe

(請看下節,實例剖析)

讀/寫時,它首先察看緩沖區的內容,如果緩沖區的數據

如何編寫Linux***作系統下的設備驅動程序

Roy G

二.實例剖析

我們來寫一個最簡單的字元設備驅動程序.雖然它什麼也不做,但是通過它

可以了解Linux的設備驅動程序的工作原理.把下面的C代碼輸入機器,你就會

獲得一個真正的設備驅動程序.不過我的kernel是2.0.34,在低版本的kernel

上可能會出現問題,我還沒測試過.//xixi

#define __NO_VERSION__

#include

#include

char kernel_version [] = UTS_RELEASE;

這一段定義了一些版本信息,雖然用處不是很大,但也必不可少.Johnsonm說所

有的驅動程序的開頭都要包含,但我看倒是未必.

由於用戶進程是通過設備文件同硬體打交道,對設備文件的***作方式不外乎就

是一些系統調用,如 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

#include

#include

#include

#include

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提供的一個函數,用於向用戶傳送數據.另外還有很多類似功能的

函數.請參考.在向用戶空間拷貝數據之前,必須驗證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 ");

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 | awk "\$2=="test" {print \$1}"

就可以獲得主設備號，可以把上面的命令行加入你的shell script中去。

minor是從設備號，設置成0就可以了。

我們現在可以通過設備文件來訪問我們的驅動程序。寫一個小小的測試程序。

#include

#include

#include

#include

main()

{

int testdev;

int i;

char buf[10];

testdev = open("/dev/test",O_RDWR);

if ( testdev == -1 )

{

printf("Cann't open file ");

exit(0);

}

read(testdev,buf,10);

for (i = 0; i < 10;i++)

printf("%d ",buf);

close(testdev);

}

編譯運行，看看是不是列印出全1 ？

以上只是一個簡單的演示。真正實用的驅動程序要復雜的多，要處理如中斷，

DMA，I/O port等問題。這些才是真正的難點。請看下節，實際情況的處理。

如何編寫Linux***作系統下的設備驅動程序

Roy G

三 設備驅動程序中的一些具體問題。

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：io埠的基地址，

參數2：io埠佔用的范圍。

返回值：0 沒有佔用， 非0，已經被佔用。

2）request_region(int io_port, int off_set,char *devname)

如果這段I/O埠沒有被佔用，在我們的驅動程序中就可以使用它。在使用

之前，必須向系統登記，以防止被其他程序佔用。登記後，在/proc/ioports

文件中可以看到你登記的io口。

參數1：io埠的基地址。

參數2：io埠佔用的范圍。

參數3：使用這段io地址的設備名。

在對I/O口登記後，就可以放心地用inb(), outb()之類的函來訪問了。

在一些pci設備中，I/O埠被映射到一段內存中去，要訪問這些埠就相當

於訪問一段內存。經常性的，我們要獲得一塊內存的物理地址。在dos環境下，

（之所以不說是dos***作系統是因為我認為DOS根本就不是一個***作系統，它實

在是太簡單，太不安全了）只要用段：偏移就可以了。在window95中，95ddk

提供了一個vmm 調用 _MapLinearToPhys,用以把線性地址轉化為物理地址。但

在Linux中是怎樣做的呢？

2 內存***作

在設備驅動程序中動態開辟內存，不是用malloc，而是kmalloc，或者用

get_free_pages直接申請頁。釋放內存用的是kfree，或free_pages. 請注意，

kmalloc等函數返回的是物理地址！而malloc等返回的是線性地址！關於

kmalloc返回的是物理地址這一點本人有點不太明白：既然從線性地址到物理

地址的轉換是由386cpu硬體完成的，那樣匯編指令的***作數應該是線性地址，

驅動程序同樣也不能直接使用物理地址而是線性地址。但是事實上kmalloc

返回的確實是物理地址，而且也可以直接通過它訪問實際的RAM，我想這樣可

以由兩種解釋，一種是在核心態禁止分頁，但是這好像不太現實；另一種是

linux的頁目錄和頁表項設計得正好使得物理地址等同於線性地址。我的想法

不知對不對，還請高手指教。

言歸正傳，要注意kmalloc最大隻能開辟128k-16，16個位元組是被頁描述符

結構佔用了。kmalloc用法參見khg.

內存映射的I/O口，寄存器或者是硬體設備的RAM(如顯存)一般佔用F0000000

以上的地址空間。在驅動程序中不能直接訪問，要通過kernel函數vremap獲得

重新映射以後的地址。

另外，很多硬體需要一塊比較大的連續內存用作DMA傳送。這塊內存需要一直

駐留在內存，不能被交換到文件中去。但是kmalloc最多隻能開辟128k的內存。

這可以通過犧牲一些系統內存的方法來解決。

具體做法是：比如說你的機器由32M的內存，在lilo.conf的啟動參數中加上

mem=30M，這樣linux就認為你的機器只有30M的內存，剩下的2M內存在vremap

之後就可以為DMA所用了。

請記住，用vremap映射後的內存，不用時應用unremap釋放，否則會浪費頁表。

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一些常見的問題。

對硬體***作，有時時序很重要。但是如果用C語言寫一些低級的硬體***作

的話，gcc往往會對你的程序進行優化，這樣時序就錯掉了。如果用匯編寫呢，

gcc同樣會對匯編代碼進行優化，除非你用volatile關鍵字修飾。最保險的

辦法是禁止優化。這當然只能對一部分你自己編寫的代碼。如果對所有的代碼

都不優化，你會發現驅動程序根本無法裝載。這是因為在編譯驅動程序時要

用到gcc的一些擴展特性，而這些擴展特性必須在加了優化選項之後才能體現

出來。

關於kernel的調試工具，我現在還沒有發現有合適的。有誰知道請告訴我，

不勝感激。我一直都在printk列印調試信息，倒也還湊合。

關於設備驅動程序還有很多內容，如等待/喚醒機制，塊設備的編寫等。

我還不是很明白，不敢亂說。

⑷ linux如何安裝驅動

在Intel網站直接下載的Linux驅動是e1000-5.2.52.tar.gz(版本可能會有改變),這個壓縮包裡面沒有編譯好的.o的文件,需要在Linux系統下編譯之後才能使用，
因為網卡需要編譯，所以要先確認將內核源文件安裝好，下面是關於內核源文件的安裝
● Linux下添加內核源文件
1． 用rpm –qa|grep kernel-source查看是否安裝了這個包；
如果返回結果中有kernel-source-xxx(其中xxx為當前redhat的內核版本，如rhel3為2.4.21-4EL), 即已經 安裝。如無返回結果則需要安裝kernel-source包。到安裝光碟中找到kernel-source-xxx.i386.rpm,用下面命令安裝此rpm包：
2．如果安裝了用rpm -V kernel-source校驗是否有文件丟失,如果沒有輸出，表示文件完整；
3．如果有丟失用rpm -ivh --force kernel-source-xxxx...把包重新安裝一下；
這個kernel-source包，在您的RH安裝光碟中，在Redhat/RPMS中，如果以前沒有安裝過這個包，那麼用rpm -ivh kernel-source-xxxx...來安裝，如果安裝過，需要覆蓋安裝，使用rpm -ivh --force kernel-source-xxxx...這個命令強制安裝。
註：AS 4 開始，沒有kernel-source這個包了，取而代之的是kernel-dev這個包，檢查這個包有沒有安裝的方法同上
● 驅動安裝步驟:
1. 把這個tar文件拷貝到用戶自己定義的目錄中,例如:
/home/username/e1000 or /usr/local/src/e1000
2. 用tar命令解這個壓縮包:
tar zxf e1000-5.2.52.tar.gz
3. 切換到驅動的src目錄下:
cd e1000-5.2.52/src/
4. 編譯這個驅動模塊:
make
然後安裝這個模塊
make install
這個二進制元將被安裝到如下位置:
/lib/moles//kernel/drivers/net/e1000.o
以上的路徑是默認的安裝位置,在某些linux版本中可能是其他位置,具體信息可以查看在驅動的 tar壓縮包中的ldistrib.txt文件.
5. 安裝模塊:
insmod e1000 （2.6以上的版本最好使用全路徑安裝 P insmod /lib/moles//kernel/drivers/net/e1000/e1000.ko）
6. 設定網卡IP地址：
ifconfig ethx <IP_address> x是網卡介面的號
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
若多個網卡的晶元相同可以cp ifcfg-eth0 ifcfg-eth1~~~~~~
修改下裡面的drive名稱就OK
!!!!!!!!!!!!!!!!!!!
在網卡的編譯中很可能不能進行下去～這個原因除了kernel的開發包沒有安裝外還可能是由於開發環境不完全所引起的！
這時就需要你講開發環境安裝完成，最簡單的辦法就是通過 sysconfig-config-packet 安裝gcc
安裝完成後繼續執行 make ；make install

了解更多開源相關，去LUPA社區看看吧

⑸ linux驅動程序結構框架及工作原理分別是什麼

一、Linux device driver 的概念x0dx0ax0dx0a系統調用是操作系統內核和應用程序之間的介面，設備驅動程序是操作系統內核和機器硬體之間的介面。設備驅動程序為應用程序屏蔽了硬體的細節，這樣在應用程序看來，硬體設備只是一個設備文件，應用程序可以象操作普通文件一樣對硬體設備進行操作。設備驅動程序是內核的一部分，它完成以下的功能:x0dx0ax0dx0a1、對設備初始化和釋放；x0dx0ax0dx0a2、把數據從內核傳送到硬體和從硬體讀取數據；x0dx0ax0dx0a3、讀取應用程序傳送給設備文件的數據和回送應用程序請求的數據；x0dx0ax0dx0a4、檢測和處理設備出現的錯誤。x0dx0ax0dx0a在Linux操作系統下有三類主要的設備文件類型，一是字元設備，二是塊設備，三是網路設備。字元設備和塊設備的主要區別是:在對字元設備發出讀/寫請求時，實際的硬體I/O一般就緊接著發生了，塊設備則不然，它利用一塊系統內存作緩沖區，當用戶進程對設備請求能滿足用戶的要求，就返回請求的數據，如果不能，就調用請求函數來進行實際的I/O操作。塊設備是主要針對磁碟等慢速設備設計的，以免耗費過多的CPU時間來等待。x0dx0ax0dx0a已經提到，用戶進程是通過設備文件來與實際的硬體打交道。每個設備文件都都有其文件屬性(c/b)，表示是字元設備還是塊設備?另外每個文件都有兩個設備號，第一個是主設備號，標識驅動程序，第二個是從設備號，標識使用同一個設備驅動程序的不同的硬體設備，比如有兩個軟盤，就可以用從設備號來區分他們。設備文件的的主設備號必須與設備驅動程序在登記時申請的主設備號一致，否則用戶進程將無法訪問到驅動程序。x0dx0ax0dx0a最後必須提到的是，在用戶進程調用驅動程序時，系統進入核心態，這時不再是搶先式調度。也就是說，系統必須在你的驅動程序的子函數返回後才能進行其他的工作。如果你的驅動程序陷入死循環，不幸的是你只有重新啟動機器了，然後就是漫長的fsck。x0dx0ax0dx0a二、實例剖析x0dx0ax0dx0a我們來寫一個最簡單的字元設備驅動程序。雖然它什麼也不做，但是通過它可以了解Linux的設備驅動程序的工作原理。把下面的C代碼輸入機器，你就會獲得一個真正的設備驅動程序。x0dx0ax0dx0a由於用戶進程是通過設備文件同硬體打交道，對設備文件的操作方式不外乎就是一些系統調用，如 open，read，write，close?， 注意，不是fopen， fread，但是如何把系統調用和驅動程序關聯起來呢?這需要了解一個非常關鍵的數據結構：x0dx0ax0dx0aSTruct file_operatiONs {x0dx0ax0dx0aint (*seek) (struct inode * ，struct file *， off_t ，int);x0dx0ax0dx0aint (*read) (struct inode * ，struct file *， char ，int);x0dx0ax0dx0aint (*write) (struct inode * ，struct file *， off_t ，int);x0dx0ax0dx0aint (*readdir) (struct inode * ，struct file *， struct dirent * ，int);x0dx0ax0dx0aint (*select) (struct inode * ，struct file *， int ，select_table *);x0dx0ax0dx0aint (*ioctl) (struct inode * ，struct file *， unsined int ，unsigned long);x0dx0ax0dx0aint (*mmap) (struct inode * ，struct file *， struct vm_area_struct *);x0dx0ax0dx0aint (*open) (struct inode * ，struct file *);x0dx0ax0dx0aint (*release) (struct inode * ，struct file *);x0dx0ax0dx0aint (*fsync) (struct inode * ，struct file *);x0dx0ax0dx0aint (*fasync) (struct inode * ，struct file *，int);x0dx0ax0dx0aint (*check_media_change) (struct inode * ，struct file *);x0dx0ax0dx0aint (*revalidate) (dev_t dev);x0dx0ax0dx0a}x0dx0ax0dx0a這個結構的每一個成員的名字都對應著一個系統調用。用戶進程利用系統調用在對設備文件進行諸如read/write操作時，系統調用通過設備文件的主設備號找到相應的設備驅動程序，然後讀取這個數據結構相應的函數指針，接著把控制權交給該函數。這是linux的設備驅動程序工作的基本原理。既然是這樣，則編寫設備驅動程序的主要工作就是編寫子函數，並填充file_operations的各個域。x0dx0ax0dx0a下面就開始寫子程序。x0dx0ax0dx0a#include 基本的類型定義x0dx0ax0dx0a#include 文件系統使用相關的頭文件x0dx0ax0dx0a#include x0dx0ax0dx0a#include x0dx0ax0dx0a#include x0dx0ax0dx0aunsigned int test_major = 0;x0dx0ax0dx0astatic int read_test(struct inode *inode，struct file *file，char *buf，int count)x0dx0ax0dx0a{x0dx0ax0dx0aint left; 用戶空間和內核空間x0dx0ax0dx0aif (verify_area(VERIFY_WRITE，buf，count) == -EFAULT )x0dx0ax0dx0areturn -EFAULT;x0dx0ax0dx0afor(left = count ; left > 0 ; left--)x0dx0ax0dx0a{x0dx0ax0dx0a__put_user(1，buf，1);x0dx0ax0dx0abuf++;x0dx0ax0dx0a}x0dx0ax0dx0areturn count;x0dx0ax0dx0a}x0dx0ax0dx0a這個函數是為read調用准備的。當調用read時，read_test()被調用，它把用戶的緩沖區全部寫1。buf 是read調用的一個參數。它是用戶進程空間的一個地址。但是在read_test被調用時，系統進入核心態。所以不能使用buf這個地址，必須用__put_user()，這是kernel提供的一個函數，用於向用戶傳送數據。另外還有很多類似功能的函數。請參考，在向用戶空間拷貝數據之前，必須驗證buf是否可用。這就用到函數verify_area。為了驗證BUF是否可以用。x0dx0ax0dx0astatic int write_test(struct inode *inode，struct file *file，const char *buf，int count)x0dx0ax0dx0a{x0dx0ax0dx0areturn count;x0dx0ax0dx0a}x0dx0ax0dx0astatic int open_test(struct inode *inode，struct file *file )x0dx0ax0dx0a{x0dx0ax0dx0aMOD_INC_USE_COUNT; 模塊計數加以，表示當前內核有個設備載入內核當中去x0dx0ax0dx0areturn 0;x0dx0ax0dx0a}x0dx0ax0dx0astatic void release_test(struct inode *inode，struct file *file )x0dx0ax0dx0a{x0dx0ax0dx0aMOD_DEC_USE_COUNT;x0dx0ax0dx0a}x0dx0ax0dx0a這幾個函數都是空操作。實際調用發生時什麼也不做，他們僅僅為下面的結構提供函數指針。x0dx0ax0dx0astruct file_operations test_fops = {?x0dx0ax0dx0aread_test，x0dx0ax0dx0awrite_test，x0dx0ax0dx0aopen_test，x0dx0ax0dx0arelease_test，x0dx0ax0dx0a};x0dx0ax0dx0a設備驅動程序的主體可以說是寫好了。現在要把驅動程序嵌入內核。驅動程序可以按照兩種方式編譯。一種是編譯進kernel，另一種是編譯成模塊(moles)，如果編譯進內核的話，會增加內核的大小，還要改動內核的源文件，而且不能動態的卸載，不利於調試，所以推薦使用模塊方式。x0dx0ax0dx0aint init_mole(void)x0dx0ax0dx0a{x0dx0ax0dx0aint result;x0dx0ax0dx0aresult = register_chrdev(0， "test"， &test_fops); 對設備操作的整個介面x0dx0ax0dx0aif (result < 0) {x0dx0ax0dx0aprintk(KERN_INFO "test: can't get major number\n");x0dx0ax0dx0areturn result;x0dx0ax0dx0a}x0dx0ax0dx0aif (test_major == 0) test_major = result; /* dynamic */x0dx0ax0dx0areturn 0;x0dx0ax0dx0a}x0dx0ax0dx0a在用insmod命令將編譯好的模塊調入內存時，init_mole 函數被調用。在這里，init_mole只做了一件事，就是向系統的字元設備表登記了一個字元設備。register_chrdev需要三個參數，參數一是希望獲得的設備號，如果是零的話，系統將選擇一個沒有被佔用的設備號返回。參數二是設備文件名，參數三用來登記驅動程序實際執行操作的函數的指針。x0dx0ax0dx0a如果登記成功，返回設備的主設備號，不成功，返回一個負值。x0dx0ax0dx0avoid cleanup_mole(void)x0dx0ax0dx0a{x0dx0ax0dx0aunregister_chrdev(test_major，"test");x0dx0ax0dx0a}x0dx0ax0dx0a在用rmmod卸載模塊時，cleanup_mole函數被調用，它釋放字元設備test在系統字元設備表中佔有的表項。x0dx0ax0dx0a一個極其簡單的字元設備可以說寫好了，文件名就叫test.c吧。x0dx0ax0dx0a下面編譯 :x0dx0ax0dx0a$ gcc -O2 -DMODULE -D__KERNEL__ -c test.c _c表示輸出制定名，自動生成.o文件x0dx0ax0dx0a得到文件test.o就是一個設備驅動程序。x0dx0ax0dx0a如果設備驅動程序有多個文件，把每個文件按上面的命令行編譯，然後x0dx0ax0dx0ald ?-r ?file1.o ?file2.o ?-o ?molename。x0dx0ax0dx0a驅動程序已經編譯好了，現在把它安裝到系統中去。x0dx0ax0dx0a$ insmod ?_f ?test.ox0dx0ax0dx0a如果安裝成功，在/proc/devices文件中就可以看到設備test，並可以看到它的主設備號。要卸載的話，運行 :x0dx0ax0dx0a$ rmmod testx0dx0ax0dx0a下一步要創建設備文件。x0dx0ax0dx0amknod /dev/test c major minorx0dx0ax0dx0ac 是指字元設備，major是主設備號，就是在/proc/devices里看到的。x0dx0ax0dx0a用shell命令x0dx0ax0dx0a$ cat /proc/devicesx0dx0ax0dx0a就可以獲得主設備號，可以把上面的命令行加入你的shell script中去。x0dx0ax0dx0aminor是從設備號，設置成0就可以了。x0dx0ax0dx0a我們現在可以通過設備文件來訪問我們的驅動程序。寫一個小小的測試程序。x0dx0ax0dx0a#include x0dx0ax0dx0a#include x0dx0ax0dx0a#include x0dx0ax0dx0a#include x0dx0ax0dx0amain()x0dx0ax0dx0a{x0dx0ax0dx0aint testdev;x0dx0ax0dx0aint i;x0dx0ax0dx0achar buf[10];x0dx0ax0dx0atestdev = open("/dev/test"，O_RDWR);x0dx0ax0dx0aif ( testdev == -1 )x0dx0ax0dx0a{x0dx0ax0dx0aprintf("Cann't open file \n");x0dx0ax0dx0aexit(0);x0dx0ax0dx0a}x0dx0ax0dx0aread(testdev，buf，10);x0dx0ax0dx0afor (i = 0; i < 10;i++)x0dx0ax0dx0aprintf("%d\n"，buf[i]);x0dx0ax0dx0aclose(testdev);x0dx0ax0dx0a}x0dx0ax0dx0a編譯運行，看看是不是列印出全1 x0dx0ax0dx0a以上只是一個簡單的演示。真正實用的驅動程序要復雜的多，要處理如中斷，DMA，I/O port等問題。這些才是真正的難點。上述給出了一個簡單的字元設備驅動編寫的框架和原理，更為復雜的編寫需要去認真研究LINUX內核的運行機制和具體的設備運行的機制等等。希望大家好好掌握LINUX設備驅動程序編寫的方法。

⑹ 如何系統的學習Linux驅動開發

在學習之前一直對驅動開發非常的陌生，感覺有點神秘。不知道驅動開發和普通的程序開發究竟有什麼不同；它的基本框架又是什麼樣的；他的開發環境有什麼特殊的地方；以及怎麼寫編寫一個簡單的字元設備驅動前編譯載入，下面我就對這些問題一個一個的介紹。

一、驅動的基本框架

1．那麼究竟什麼是驅動程序，它有什麼用呢:

l驅動是硬體設備與應用程序之間的一個中間軟體層

l它使得某個特定硬體能夠響應一個定義良好的內部編程介面，同時完全隱蔽了設備的工作細節

l用戶通過一組與具體設備無關的標准化的調用來完成相應的操作

l驅動程序的任務就是把這些標准化的系統調用映射到具體設備對於實際硬體的特定操作上

l驅動程序是內核的一部分，可以使用中斷、DMA等操作

l驅動程序在用戶態和內核態之間傳遞數據

2．Linux驅動的基本框架

3．Linux下設備驅動程序的一般可以分為以下三類

1)字元設備

a)所有能夠象位元組流一樣訪問的設備都通過字元設備來實現

b)它們被映射為文件系統中的節點，通常在/dev/目錄下面

c)一般要包含open read write close等系統調用的實現

2)塊設備

d)通常是指諸如磁碟、內存、Flash等可以容納文件系統的存儲設備。

e)塊設備也是通過文件系統來訪問，與字元設備的區別是：內核管理數據的方式不同

f)它允許象字元設備一樣以位元組流的方式來訪問，也可一次傳遞任意多的位元組。

3)網路介面設備

g)通常它指的是硬體設備，但有時也可能是一個軟體設備(如回環介面loopback)，它們由內核中網路子系統驅動，負責發送和接收數據包。

h)它們的數據傳送往往不是面向流的，因此很難將它們映射到一個文件系統的節點上。

二、怎麼搭建一個驅動的開發環境

因為驅動是要編譯進內核,在啟動內核時就會驅動此硬體設備；或者編譯生成一個.o文件,當應用程序需要時再動態載入進內核空間運行。因此編譯任何一個驅動程序都要鏈接到內核的源碼樹。所以搭建環境的第一步當然是建內核源碼樹

1.怎麼建內核源碼樹

a)首先看你的系統有沒有源碼樹，在你的/lib/ moles目錄下會有內核信息，比如我當前的系統里有兩個版本：

#ls /lib/ moles

2.6.15-rc72.6.21-1.3194.fc7

查看其源碼位置:

## ll /lib/moles/2.6.15-rc7/build

lrwxrwxrwx 1 root root 27 2008-04-28 19:19 /lib/moles/2.6.15-rc7/build -> /root/xkli/linux-2.6.15-rc7

發現build是一個鏈接文件，其所對應的目錄就是源碼樹的目錄。但現在這里目標目錄已經是無效的了。所以得自己重新下載

b)下載並編譯源碼樹

有很多網站上可以下載，但官方網址是：

http://www.kernel.org/pub/linux/kernel/v2.6/

下載完後當然就是解壓編譯了

# tar –xzvf linux-2.6.16.54.tar.gz

#cd linux-2.6.16.54

## make menuconfig (配置內核各選項,如果沒有配置就無法下一步編譯，這里可以不要改任何東西)

#make

…

如果編譯沒有出錯。那麼恭喜你。你的開發環境已經搭建好了

三、了解驅動的基本知識

1.設備號

1)什麼是設備號呢？我們進系統根據現有的設備來講解就清楚了：

#ls -l /dev/

crwxrwxrwx 1 root root1,3 2009-05-11 16:36 null

crw------- 1 root root4,0 2009-05-11 16:35 systty

crw-rw-rw- 1 root tty5,0 2009-05-11 16:36 tty

crw-rw---- 1 root tty4,0 2009-05-11 16:35 tty0

在日期前面的兩個數（如第一列就是1,3）就是表示的設備號，第一個是主設備號，第二個是從設備號

2)設備號有什麼用呢？

l傳統上,主編號標識設備相連的驅動.例如, /dev/null和/dev/zero都由驅動1來管理,而虛擬控制台和串口終端都由驅動4管理

l次編號被內核用來決定引用哪個設備.依據你的驅動是如何編寫的自己區別

3)設備號結構類型以及申請方式

l在內核中, dev_t類型(在中定義)用來持有設備編號,對於2.6.0內核, dev_t是32位的量, 12位用作主編號, 20位用作次編號.

l能獲得一個dev_t的主或者次編號方式：

MAJOR(dev_t dev); //主要

MINOR(dev_t dev);//次要

l但是如果你有主次編號,需要將其轉換為一個dev_t,使用: MKDEV(int major, int minor);

4)怎麼在程序中分配和釋放設備號

在建立一個字元驅動時需要做的第一件事是獲取一個或多個設備編號來使用.可以達到此功能的函數有兩個：

l一個是你自己事先知道設備號的

register_chrdev_region,在中聲明:

int register_chrdev_region(dev_t first, unsigned int count, char *name);

first是你要分配的起始設備編號. first的次編號部分常常是0,count是你請求的連續設備編號的總數. name是應當連接到這個編號范圍的設備的名子;它會出現在/proc/devices和sysfs中.

l第二個是動態動態分配設備編號

int alloc_chrdev_region(dev_t *dev, unsigned int firstminor, unsigned int count, char *name);

使用這個函數, dev是一個只輸出的參數,它在函數成功完成時持有你的分配范圍的第一個數. fisetminor應當是請求的第一個要用的次編號;它常常是0. count和name參數如同給request_chrdev_region的一樣.

5)設備編號的釋放使用

不管你是採用哪些方式分配的設備號。使用之後肯定是要釋放的，其方式如下：

void unregister_chrdev_region(dev_t first, unsigned int count);

6)

2.驅動程序的二個最重要數據結構

1)file_operation

倒如字元設備scull的一般定義如下：
struct file_operations scull_fops = {
.owner = THIS_MODULE,
.llseek = scull_llseek,
.read = scull_read,
.write = scull_write,
.ioctl = scull_ioctl,
.open = scull_open,
.release = scull_release,
};

file_operation也稱為設備驅動程序介面

定義在,是一個函數指針的集合.每個打開文件(內部用一個file結構來代表)與它自身的函數集合相關連(通過包含一個稱為f_op的成員,它指向一個file_operations結構).這些操作大部分負責實現系統調用,因此,命名為open, read,等等

2)File

定義位於include/fs.h

struct file結構與驅動相關的成員

lmode_t f_mode標識文件的讀寫許可權

lloff_t f_pos當前讀寫位置

lunsigned int_f_flag文件標志，主要進行阻塞/非阻塞型操作時檢查

lstruct file_operation * f_op文件操作的結構指針

lvoid * private_data驅動程序一般將它指向已經分配的數據

lstruct dentry* f_dentry文件對應的目錄項結構

3.字元設備注冊

1)內核在內部使用類型struct cdev的結構來代表字元設備.在內核調用你的設備操作前,必須編寫分配並注冊一個或幾個這些結構.有2種方法來分配和初始化一個這些結構.

l如果你想在運行時獲得一個獨立的cdev結構,可以這樣使用:

struct cdev *my_cdev = cdev_alloc();

my_cdev->ops = &my_fops;

l如果想將cdev結構嵌入一個你自己的設備特定的結構;你應當初始化你已經分配的結構,使用:

void cdev_init(struct cdev *cdev, struct file_operations *fops);

2)一旦cdev結構建立,最後的步驟是把它告訴內核,調用:

int cdev_add(struct cdev *dev, dev_t num, unsigned int count);

說明：dev是cdev結構, num是這個設備響應的第一個設備號, count是應當關聯到設備的設備號的數目.常常count是1,但是有多個設備號對應於一個特定的設備的情形.

3)為從系統去除一個字元設備,調用:

void cdev_del(struct cdev *dev);

4.open和release