在Linux系統上編寫驅動程序，說簡單也簡單，說難也難。難在于對算法的編寫和設備的控制方面，是比較讓人頭疼的；說它簡單是因為在Linux下已經有一套驅動開發的模式，編寫的時候只需要按照這個模式寫就可以了，而這個模式就是它事先定義好的一些結構體，在驅動編寫的時候，只要對這些結構體根據設備的需求進行適當的填充，就實現了驅動的編寫。

首先在Linux下，視一切事物皆為文件，它同樣把驅動設備也看成是文件，對于簡單的文件操作，無非就是open/close/read/write，在Linux對于文件的操作有一個關鍵的數據結構：file_operation，它的定義在源碼目錄下的include/linux/fs.h中，內容如下：

[cpp]view plaincopy

1.structfile_operations{

2.structmodule*owner;

3.loff_t(*llseek)(structfile*,loff_t,int);

4.ssize_t(*read)(structfile*,char__user*,size_t,loff_t*);

5.ssize_t(*write)(structfile*,constchar__user*,size_t,loff_t*);

6.ssize_t(*aio_read)(structkiocb*,conststructiovec*,unsignedlong,loff_t);

7.ssize_t(*aio_write)(structkiocb*,conststructiovec*,unsignedlong,loff_t);

8.int(*readdir)(structfile*,void*,filldir_t);

9.unsignedint(*poll)(structfile*,structpoll_table_struct*);

10.int(*ioctl)(structinode*,structfile*,unsignedint,unsignedlong);

11.long(*unlocked_ioctl)(structfile*,unsignedint,unsignedlong);

12.long(*compat_ioctl)(structfile*,unsignedint,unsignedlong);

13.int(*mmap)(structfile*,structvm_area_struct*);

14.int(*open)(structinode*,structfile*);

15.int(*flush)(structfile*,fl_owner_tid);

16.int(*release)(structinode*,structfile*);

17.int(*fsync)(structfile*,intdatasync);

18.int(*aio_fsync)(structkiocb*,intdatasync);

19.int(*fasync)(int,structfile*,int);

20.int(*lock)(structfile*,int,structfile_lock*);

21.ssize_t(*sendpage)(structfile*,structpage*,int,size_t,loff_t*,int);

22.unsignedlong(*get_unmapped_area)(structfile*,unsignedlong,unsignedlong,unsignedlong,unsignedlong);

23.int(*check_flags)(int);

24.int(*flock)(structfile*,int,structfile_lock*);

25.ssize_t(*splice_write)(structpipe_inode_info*,structfile*,loff_t*,size_t,unsignedint);

26.ssize_t(*splice_read)(structfile*,loff_t*,structpipe_inode_info*,size_t,unsignedint);

27.int(*setlease)(structfile*,long,structfile_lock**);

28.};

對于這個結構體中的元素來說，大家可以看到每個函數名前都有一個“*”，所以它們都是指向函數的指針。目前我們只需要關心

ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);

ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);

int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);

int (*open) (struct inode *, struct file *);

int (*release) (struct inode *, struct file *);

這幾條，因為這篇文章就叫簡單驅動。就是讀（read）、寫（write）、控制（ioctl）、打開（open）、卸載（release）。這個結構體在驅動中的作用就是把系統調用和驅動程序關聯起來，它本身就是一系列指針的集合，每一個都對應一個系統調用。

但是畢竟file_operation是針對文件定義的一個結構體，所以在寫驅動時，其中有一些元素是用不到的，所以在2.6版本引入了一個針對驅動的結構體框架：platform，它是通過結構體platform_device來描述設備，用platform_driver描述設備驅動，它們都在源代碼目錄下的include/linux/platform_device.h中定義，內容如下：

[cpp]view plaincopy

1.structplatform_device{

2.constchar*name;

3.intid;

4.structdevicedev;

5.u32num_resources;

6.structresource*resource;

7.conststructplatform_device_id*id_entry;

8./*archspecificadditions*/

9.structpdev_archdataarchdata;

10.};

11.structplatform_driver{

12.int(*probe)(structplatform_device*);

13.int(*remove)(structplatform_device*);

14.void(*shutdown)(structplatform_device*);

15.int(*suspend)(structplatform_device*,pm_message_tstate);

16.int(*resume)(structplatform_device*);

17.structdevice_driverdriver;

18.conststructplatform_device_id*id_table;

19.};

對于第一個結構體來說，它的作用就是給一個設備進行登記作用，相當于設備的身份證，要有姓名，身份證號，還有你的住址，當然其他一些東西就直接從舊身份證上copy過來，這就是其中的struct device dev，這是傳統設備的一個封裝，基本就是copy的意思了。對于第二個結構體，因為Linux源代碼都是C語言編寫的，對于這里它是利用結構體和函數指針，來實現了C語言中沒有的“類”這一種結構，使得驅動模型成為一個面向對象的結構。對于其中的struct device_driver driver，它是描述設備驅動的基本數據結構，它是在源代碼目錄下的include/linux/device.h中定義的，內容如下：

[cpp]view plaincopy

1.structdevice_driver{

2.constchar*name;

3.structbus_type*bus;

4.structmodule*owner;

5.constchar*mod_name;/*usedforbuilt-inmodules*/

6.boolsuppress_bind_attrs;/*disablesbind/unbindviasysfs*/

7.#ifdefined(CONFIG_OF)

8.conststructof_device_id*of_match_table;

9.#endif

10.int(*probe)(structdevice*dev);

11.int(*remove)(structdevice*dev);

12.void(*shutdown)(structdevice*dev);

13.int(*suspend)(structdevice*dev,pm_message_tstate);

14.int(*resume)(structdevice*dev);

15.conststructattribute_group**groups;

16.conststructdev_pm_ops*pm;

17.structdriver_private*p;

18.};

依然全部都是以指針的形式定義的所有元素，對于驅動這一塊來說，每一項肯定都是需要一個函數來實現的，如果不把它們集合起來，是很難管理的，而且很容易找不到，而且對于不同的驅動設備，它的每一個功能的函數名必定是不一樣的，那么我們在開發的時候，需要用到這些函數的時候，就會很不方便，不可能在使用的時候去查找對應的源代碼吧，所以就要進行一個封裝，對于函數的封裝，在C語言中一個對好的辦法就是在結構體中使用指向函數的指針，這種方法其實我們在平時的程序開發中也可以使用，原則就是體現出一個“類”的感覺，就是面向對象的思想。

在Linux系統中，設備可以大致分為3類：字符設備、塊設備和網絡設備，而每種設備中又分為不同的子系統，由于具有自身的一些特殊性質，所以有不能歸到某個已經存在的子類中，所以可以說是便于管理，也可以說是為了達到同一種定義模式，所以linux系統把這些子系統歸為一個新類：misc ，以結構體miscdevice描述，在源代碼目錄下的include/linux/miscdevice.h中定義，內容如下：

[cpp]view plaincopy

1.structmiscdevice{

2.intminor;

3.constchar*name;

4.conststructfile_operations*fops;

5.structlist_headlist;

6.structdevice*parent;

7.structdevice*this_device;

8.constchar*nodename;

9.mode_tmode;

10.};

對于這些設備，它們都擁有一個共同主設備號10，所以它們是以次設備號來區分的，對于它里面的元素，大應該很眼熟吧，而且還有一個我們更熟悉的list_head的元素，這里也可以應證我之前說的list_head就是一個橋梁的說法了。

其實對于上面介紹的結構體，里面的元素的作用基本可以見名思意了，所以不用贅述了。其實寫一個驅動模塊就是填充上述的結構體，根據設備的功能和用途寫相應的函數，然后對應到結構體中的指針，然后再寫一個入口一個出口（就是模塊編程中的init和exit）就可以了，一般情況下入口程序就是在注冊platform_device和platform_driver（當然，這樣說是針對以platform模式編寫驅動程序）。