Linux的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設備驅動程序的基本框架，從中不難體會到這幾個關鍵模塊是如何組織起來的。
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,}
};
struct demo_card {
? ? unsigned int magic;
? ?
? ? 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, ?
? ? 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)
{
? ?
? ? 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;
? ?
? ? if (pci_enable_device(pci_dev))
? ? ? ? return -EIO;
? ?
? ? 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));
? ?
? ? 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;
? ? ? ?
? ? pci_set_master(pci_dev);
? ?
? ? 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) {
? ? ? ? ? ?
? ? ? ? ? ? up(&card->open_sem);
? ? ? ? ? ? return -EBUSY;
? ? ? ? } else {
? ? ? ? ? ?
? ? ? ? ? ? card->open_mode |= f_mode & (FMODE_READ | FMODE_WRITE);
? ? ? ? ? ? up(&card->open_sem);
? ? ? ? ? ?
? ? ? ? ? ? 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:
? ? ? ? ? ?
? ? ? ? ? ? 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; ?
? ? }
? ?
? ? outl(status & INT_MASK, card->iobase + GLOB_STA);
? ? spin_unlock(&card->lock); ? ?
? ?
}
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); ? ?
? ?
? ? MOD_DEC_USE_COUNT; ? ?
? ? ?
}
8. 卸載設備模塊
卸載設備模塊與初始化設備模塊是相對應的，實現起來相對比較簡單，主要是調用函數pci_unregister_driver( )從Linux內核中注銷設備驅動程序：?
static void __exit demo_cleanup_module (void)
{
? ? pci_unregister_driver(&demo_pci_driver);
}
三、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.?打開設備模塊
在這個模塊里主要實現申請中斷、檢查讀寫模式以及申請對設備的控制權等。在申請控制權的時候，非阻塞方式遇忙返回，否則進程主動接受調度，進入睡眠狀態，等待其它進程釋放對設備的控制權。
<script type="text/javascript"><!-- google_ad_client = "pub-2299987709779770"; google_ad_width = 468; google_ad_height = 60; google_ad_format = "468x60_as"; google_ad_type = "image"; google_ad_channel =""; google_color_border = "FFFFFF"; google_color_bg = "FFFFFF"; google_color_link = "0000FF"; google_color_url = "008000"; google_color_text = "000000"; //--></script><script type="text/javascript" src="http://pagead2.googlesyndication.com/pagead/show_ads.js"> </script>
| 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。
在LINUX的時鐘中斷中涉及至二個全局變量一個是xtime,它是timeval數據結構變量，另一個則是jiffies，首先看timeval結構
struct timeval
{
??? time_t tv_sec; /***second***/
??? susecond_t tv_usec;/***microsecond***/
}
到底microsecond是毫秒還是微秒？？
1秒＝1000毫秒（3個零），1秒＝1000 000微秒（6個零），1秒＝1000 000 000納秒（9個零），1秒＝1000 000 000 000皮秒（12個零）。
秒用s表現，毫秒用ms,微秒用us表示，納秒用ns表示，皮秒用ps表示，他們的分級單位是千，即每次3個零。
混淆的原因找到了，由于毫秒用ms表示，所以我老是以為microsecond是毫秒，所以就把tv_usec理解錯了。
microsecond查詞霸也是微秒的意思（microsecond！=ms，microsecond==us），看來單位的表示迷惑了我，也迷惑了大多數人，請朋友們牢記這里，非常重要。
xtime是從cmos電路中取得的時間，一般是從某一歷史時刻開始到現在的時間，也就是為了取得我們操作系統上顯示的日期。這個就是所謂的“實時時鐘”，它的精確度是微秒。
jiffies是記錄著從電腦開機到現在總共的時鐘中斷次數。在linux內核中jiffies遠比xtime重要，那么他取決于系統的頻率，單位是Hz，這里不得不說一下頻率的單位，1MHz＝1000，000Hz（6個零），1KHz=1000Hz（3個零）.
頻率是周期的倒數，一般是一秒鐘中斷產生的次數，所以，假如我們需要知道系統的精確的時間單位時，需要換算了，假如我們系統的頻率是200Mhz,那么一次中斷的間隔是1秒/200,000，000Hz=0.000 000 005秒看一下上面我們的時間單位，對照一下小數點后面是9個零，所以理論上我們系統的精確度是5納秒。LINUX系統時鐘頻率是一個常數HZ來決定的，通常HZ＝100，那么他的精度度就是10ms（毫秒）。也就是說每10ms一次中斷。所以一般來說Linux的精確度是10毫秒。
硬件給內核提供一個系統定時器用以計算和管理時間，內核通過編程預設系統定時器的頻率，即節拍率（tick rate),每一個周期稱作一個tick(節拍）。Linux內核從2.5版內核開始把頻率從100調高到1000，時間單位 jiffies 有多長？
"在 Linux 2.6 中，系統時鐘每 1 毫秒中斷一次（時鐘頻率，用 HZ 宏表示，定義為 1000，即每秒中斷 1000 次，2.4 中定義為 100，很多應用程序也仍然沿用 100 的時鐘頻率），這個時間單位稱為一個 jiffie。"
"jiffies 與絕對時間之間的轉換, 用兩個宏來完成兩種時間單位的互換：JIFFIES_TO_NS()、NS_TO_JIFFIES()"
（當然帶來了很多優點，也有一些缺點）.
硬件給內核提供一個系統定時器用以計算和管理時間，內核通過編程預設系統定時器的頻率，即節拍率（tick rate),每一個周期稱作一個tick(節拍）。Linux內核從2.5版內核開始把頻率從100調高到1000（當然帶來了很多優點，也有一些缺點）.
?? jiffies是內核中的一個全局變量，用來記錄自系統啟動一來產生的節拍數。譬如，如果計算系統運行了多長時間，可以用 jiffies/tick rate 來計算。jiffies定義在文件<linux/jiffies.h>中：
extern unsigned long volatile jiffies;
??? 可以利用jiffies設置超時等，譬如：
unsigned long timeout = jiffies + tick_rate * 2; // 2秒鐘后超時
???
??? if(time_before(jiffies, timeout){
?????? // 還沒有超時
??? }
??? else{
?????? // 已經超時
??? }
??
???
內核提供了四個宏來比較節拍計數，這些宏定義在文件<linux/jiffies.h>中：
??? time_before(unknown, known)
??? time_after(unknown, known)
??? time_before_eq(unknown, known)
??? time_after_eq(unknown, known)
??? 比較的時候用這些宏可以避免jiffies由于過大造成的回繞問題。
??? 除了系統定時器外，還有一個與時間有關的時鐘：實時時鐘（RTC），這是一個硬件時鐘，用來持久存放系統時間，系統關閉后靠主板上的微型電池保持計時。系統啟動時，內核通過讀取RTC來初始化Wall Time,并存放在xtime變量中，這是RTC最主要的作用。
?????? ///網絡相關函數內容詳解//
?
1.linux HZ
Linux核心幾個重要跟時間有關的名詞或變數，以下將介紹HZ、tick與jiffies。
HZ
Linux核心每隔固定周期會發出timer interrupt (IRQ 0)，HZ是用來定義每一秒有幾次timer interrupts。舉例來說，HZ為1000，代表每秒有1000次timer interrupts。 HZ可在編譯核心時設定，如下所示(以核心版本2.6.20-15為例)：
desktop:~$ cd /usr/src/linux
desktop:/usr/src/linux$ make menuconfig
Processor type and features? ??Timer frequency (250 HZ)?
其中HZ可設定100? ?250? 300或1000
小實驗
觀察/proc/interrupt的timer中斷次數，并于一秒后再次觀察其值。理論上，兩者應該相差250左右。
adrian@adrian-desktop:~$ cat /proc/interrupts | grep timer && sleep 1 && cat /proc/interrupts | grep timer
0: 9309306 IO-APIC-edge timer
0: 9309562 IO-APIC-edge timer
上面四個欄位分別為中斷號碼、CPU中斷次數、PIC與裝置名稱。
要檢查系統上HZ的值是什么，就執行命令
cat kernel/.config | grep '^CONFIG_HZ='
2.Tick
Tick是HZ的倒數，意即timer interrupt每發生一次中斷的時間。如HZ為250時，tick為4毫秒(millisecond)。
3.Jiffies
Jiffies為Linux核心變數(unsigned long)，它被用來記錄系統自開機以來，已經過了多少tick。每發生一次timer interrupt，Jiffies變數會被加一。值得注意的是，Jiffies于系統開機時，并非初始化成零，而是被設為-300*HZ (arch/i386/kernel/time.c)，即代表系統于開機五分鐘后，jiffies便會溢位。那溢位怎么辦?事實上，Linux核心定義幾個macro(timer_after、time_after_eq、time_before與time_before_eq)，即便是溢位，也能借由這幾個macro正確地取得jiffies的內容。
另外，80x86架構定義一個與jiffies相關的變數jiffies_64 ，此變數64位元，要等到此變數溢位可能要好幾百萬年。因此要等到溢位這刻發生應該很難吧。
3.1 jiffies及其溢出
全局變量jiffies取值為自操作系統啟動以來的時鐘滴答的數目，在頭文件<linux/sched.h>中定義，數據類型為unsigned long volatile (32位無符號長整型)。
jiffies轉換為秒可采用公式：(jiffies/HZ)計算，
將秒轉換為jiffies可采用公式：(seconds*HZ)計算。
當時鐘中斷發生時，jiffies 值就加1。因此連續累加一年又四個多月后就會溢出(假定HZ=100，1個jiffies等于1/100秒，jiffies可記錄的最大秒數為 (2^32 -1)/100=42949672.95秒，約合497天或1.38年)，即當取值到達最大值時繼續加1，就變為了0。
3.4 ?Linux內核如何來防止jiffies溢出
Linux內核中提供了以下四個宏，可有效解決由于jiffies溢出而造成程序邏輯出錯的情況。下面是從Linux Kernel 2.6.7版本中摘取出來的代碼：
/*
* These inlines deal with timer wrapping correctly. You are
* strongly encouraged to use them
* 1. Because people otherwise forget
* 2. Because if the timer wrap changes in future you won't have to
* alter your driver code.
*
* time_after(a,b) returns true if the time a is after time b.
*
* Do this with "<0" and ">=0" to only test the sign of the result. A
* good compiler would generate better code (and a really good compiler
* wouldn't care). Gcc is currently neither.
*/
#define time_after(a,b) \
(typecheck(unsigned long, a) && \
typecheck(unsigned long, b) && \
((long)(b) - (long)(a) < 0))
#define time_before(a,b) time_after(b,a)
#define time_after_eq(a,b) \
(typecheck(unsigned long, a) && \
typecheck(unsigned long, b) && \
((long)(a) - (long)(b) >= 0))
#define time_before_eq(a,b) time_after_eq(b,a)
在宏time_after中，首先確保兩個輸入參數a和b的數據類型為unsigned long，然后才執行實際的比較。
8. 結論
系統中采用jiffies來計算時間，但由于jiffies溢出可能造成時間比較的錯誤，因而強烈建議在編碼中使用 time_after等宏來比較時間先后關系，這些宏可以放心使用。
內核時鐘：
內核使用硬件提供的不同時鐘來提供依賴于時間的服務，如busy-waiting（浪費CPU周期）和sleep-waiting（放棄CPU）
5.HZ and Jiffies
????? jiffies記錄了系統啟動后的滴答數，常用的函數：time_before()、 time_after()、time_after_eq()、time_before_eq()。因為jiffies隨時鐘滴答變化，不能用編譯器優化它，應取volatile值。
????? 32位jiffies變量會在50天后溢出，太小，因此內核提供變量jiffies_64來hold 64位jiffies。該64位的低32位即為jiffies，在32位機上需要兩天指令來賦值64位數據，不是原子的，因此內核提供函數 get_jiffies_64()。
6.Long Delays
??? busy-wait：timebefore(),使CPU忙等待；sleep-wait：shedule_timeout(截至時間)；無論在內核空間還是用戶空間，都沒有比HZ更精確的控制了，因為時間片都是根據滴答更新的，而且即使定義了您的進程在超過指定時間后運行，調度器也可能根據優先級選擇其他進程執行。
??? sleep-wait()：wait_event_timeout()用于在滿足某個條件或超時后重新執行，msleep()睡眠指定的ms后重新進入就緒隊列，這些長延遲僅適用于進程上下文，在中斷上下文中不能睡眠也不能長時間busy-waiting。
內核提供了timer API來在一定時間后執行某個函數：
#include <linux/timer.h>
struct timer_list my_timer;
init_timer(&my_timer);??????????? /* Also see setup_timer() */
my_timer.expire = jiffies + n*HZ; /* n is the timeout in number??????????????????????????????????? of seconds */
my_timer.function = timer_func;?? /* Function to execute
???????????????????????????????????? after n seconds */
my_timer.data = func_parameter;?? /* Parameter to be passed?????????????????????????????????? to timer_func */
add_timer(&my_timer);???????????? ???/*Start the timer*/
如果您想周期性執行上述代碼，那么把它們加入timer_func()函數。您使用mod_timer()來改變my_timer的超時值，del_timer()來刪掉my_timer，用timer_pending()查看是否my_timer處于掛起狀態。
??? 用戶空間函數clock_settime()和clock_gettime()用于獲取內核時鐘服務。用戶應用程序使用setitimer()和getitimer()來控制alarm信號的傳遞當指定超時發生后。
8.Real Time Clock
???? RTC時鐘track絕對時間。RTC電池常超過computer生存期。可以用RTC完成以下功能：（1）讀或設置絕對時鐘，并在clock updates時產生中斷；（2）以2HZ到8192HZ來產生周期性中斷；（3）設置alarms。
?? ?jiffies僅是相對于系統啟動的相對時間，如果想獲取absolute time或wall time，則需要使用RTC，內核用變量xtime來記錄，當系統啟動時，讀取RTC并記錄在xtime中，當系統halt時，則將wall time寫回RTC，函數do_gettimeofday()來讀取wall time。
#include <linux/time.h>
static struct timeval curr_time;
do_gettimeofday(&curr_time);
my_timestamp = cpu_to_le32(curr_time.tv_sec); /* Record timestamp */
??? 用戶空間獲取wall time的函數：time()返回calendar time或從00：00：00 on January 1，1970的秒數；（2）localtime()：返回calendar time in broken-down format；（3）mktime()：與 localtime()相反；（4）gettimeofday()以microsecond 精確度返回calendar時間。
??? 另外一個獲取RTC的方法是通過字符設備/dev/rtc，一個時刻僅允許一個處理器訪問它。
9.時鐘和定時器
時鐘和定時器對Linux內核來說十分重要。首先，內核要管理系統的運行時間(uptime)和當前墻上時間(wall time)， 即當前實際時間。其次，內核中大量的活動由時間驅動。
9.1實時時鐘
??? 內核必須借助硬件來實現時間管理。實時時鐘是用來持久存放系統時間的設備，它通過主板電池供電，所以即便在關閉計算機系統之后，實時時鐘仍然能繼續工作。
??? 系統啟動時，內核讀取實時時鐘，將所讀的時間存放在變量xtime中作為墻上時間(wall time)，xtime保存著從1970年1月1日0:00到當前時刻所經歷的秒數。雖然在Intel x86機器上，內核會周期性地將當前時間存回實時時鐘中，但應該明確，實時時鐘的主要作用就是在啟動時初始化墻上時間xtime。
9.2系統定時器與動態定時器
??? 周期性發生的事件都是由系統定時器驅動。在X86體系結構上，系統定時器通常是一種可編程硬件芯片，其產生的中斷就是時鐘中斷。時鐘中斷對應的處理程序負責更新系統時間和執行周期性運行的任務。系統定時器的頻率稱為節拍率(tick rate)，在內核中表示為HZ。
??? 以X86為例，在2.4之前的內核中其大小為100； 從內核2.6開始，HZ = 1000， 也就是說每秒時鐘中斷發生1000次。這一變化使得系統定時器的精度(resolution)由10ms提高到1ms，這大大提高了系統對于時間驅動事件調度的精確性。過于頻繁的時鐘中斷不可避免地增加了系統開銷。
??? 與系統定時器相對的是動態定時器，它是調度事件(執行調度程序)在未來某個時刻發生的時機。內核可以動態地創建或銷毀動態定時器。
??? 系統定時器及其中斷處理程序是內核管理機制的中樞，下面是一些利用系統定時器周期執行的工作(中斷處理程序所做的工作):
??? (1) 更新系統運行時間(uptime)
??? (2) 更新當前墻上時間(wall time)
??? (3) 在對稱多處理器系統(SMP)上，均衡調度各處理器上的運行隊列
??? (4) 檢查當前進程是否用完了時間片(time slice)，如果用盡，則進行重新調度
??? (5) 運行超時的動態定時器
??? (6) 更新資源耗盡和處理器時間的統計值
??? 內核動態定時器依賴于系統時鐘中斷，因為只有在系統時鐘中斷發生后內核才會去檢查當前是否有超時的動態定時器。
---------------------------------------------------------
?? ?X86體系結構中，內核2.6.X的HZ = 1000， 即系統時鐘中斷執行粒度為1ms，這意味著系統中周期事情最快為1ms執行一次，而不可能有更高的精度。動態定時器隨時都可能超時，但由于只有在系統時鐘中斷到來時內核才會檢查執行超時的動態定時器，所以動態定時器的平均誤差大約為半個系統時鐘周期(即0.5ms).
總結
以上是生活随笔為你收集整理的Linux的PCI驱动介绍（入门）的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Ruby 之Gem kaminari
- 下一篇： Linux PCI驱动编写