linuxpci

1. 如何寫linux pci設備驅動程序

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設備驅動程序的基本框架，從中不難體會到這幾個關鍵模塊是如何組織起來的。
/* 指明該驅動程序適用於哪一些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_mole (void)
{
/* ... */
}
static void __exit demo_cleanup_mole (void)
{
pci_unregister_driver(&demo_pci_driver);
}
/* 載入驅動程序模塊入口 */
mole_init(demo_init_mole);
/* 卸載驅動程序模塊入口 */
mole_exit(demo_cleanup_mole);
上面這段代碼給出了一個典型的PCI設備驅動程序的框架，是一種相對固定的模式。需要注意的是，同載入和卸載模塊相關的函數或數據結構都要在前面加上__init、__exit等標志符，以使同普通函數區分開來。構造出這樣一個框架之後，接下去的工作就是如何完成框架內的各個功能模塊了。
3. 初始化設備模塊
在Linux系統下，想要完成對一個PCI設備的初始化，需要完成以下工作：
檢查PCI匯流排是否被Linux內核支持；
檢查設備是否插在匯流排插槽上，如果在的話則保存它所佔用的插槽的位置等信息。
讀出配置頭中的信息提供給驅動程序使用。
當Linux內核啟動並完成對所有PCI設備進行掃描、登錄和分配資源等初始化操作的同時，會建立起系統中所有PCI設備的拓撲結構，此後當PCI驅動程序需要對設備進行初始化時，一般都會調用如下的代碼：
static int __init demo_init_mole (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. 打開設備模塊
在這個模塊里主要實現申請中斷、檢查讀寫模式以及申請對設備的控制權等。在申請控制權的時候，非阻塞方式遇忙返回，否則進程主動接受調度，進入睡眠狀態，等待其它進程釋放對設備的控制權。
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_mole (void)
{
pci_unregister_driver(&demo_pci_driver);
}
小結
PCI匯流排不僅是目前應用廣泛的計算機匯流排標准，而且是一種兼容性最強、功能最全的計算機匯流排。而Linux作為一種新的操作系統，其發展前景是無法估量的，同時也為PCI匯流排與各種新型設備互連成為可能。由於Linux源碼開放，因此給連接到PCI匯流排上的任何設備編寫驅動程序變得相對容易。本文介紹如何編譯Linux下的PCI驅動程序，針對的內核版本是2.4。

2. 如何讓linux重新枚舉pci設備

在Linux下，lspci可以枚舉所有PCI設備。它是通過讀取PCI配置空間（PCI Configuration Space）信息來實現PCI設備的枚舉的。這里，我通過兩種方式來簡單的模擬一下lspci的功能。一種是通過PCI匯流排的CF8和CFC埠來枚舉(參考PCI匯流排規范)；另一種是利用proc filesystem。

方法一：這種方法需要對埠進行操作，在Linux下，普通應用程序沒有許可權讀寫I/O 埠，需要通過iopl或ioperm來提升許可權，我的代碼裡面使用iopl。


[cpp] view plainprint?
/*
* Enum all pci device via the PCI config register(CF8 and CFC).
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/io.h>

#define PCI_MAX_BUS 255 /* 8 bits (0 ~ 255) */
#define PCI_MAX_DEV 31 /* 5 bits (0 ~ 31) */
#define PCI_MAX_FUN 7 /* 3 bits (0 ~ 7) */

#define CONFIG_ADDRESS 0xCF8
#define CONFIG_DATA 0xCFC

#define PCICFG_REG_VID 0x00 /* Vendor id, 2 bytes */
#define PCICFG_REG_DID 0x02 /* Device id, 2 bytes */
#define PCICFG_REG_CMD 0x04 /* Command register, 2 bytes */
#define PCICFG_REG_STAT 0x06 /* Status register, 2 bytes */
#define PCICFG_REG_RID 0x08 /* Revision id, 1 byte */


void list_pci_devices()
{
unsigned int bus, dev, fun;
unsigned int addr, data;

//printf("BB:DD:FF VID:DID\n");


for (bus = 0; bus <= PCI_MAX_BUS; bus++) {
for (dev = 0; dev <= PCI_MAX_DEV; dev++) {
for (fun = 0; fun <= PCI_MAX_FUN; fun++) {
addr = 0x80000000L | (bus<<16) | (dev<<11) | (fun<<8);
outl(addr, CONFIG_ADDRESS);
data = inl(CONFIG_DATA);

/* Identify vendor ID */
if ((data != 0xFFFFFFFF) && (data != 0)) {
printf("%02X:%02X:%02X ", bus, dev, fun);
printf("%04X:%04X", data&0xFFFF, data>>16);
addr = 0x80000000L | (bus<<16) | (dev<<11) | (fun<<8) | PCICFG_REG_RID;
outl(addr, CONFIG_ADDRESS);
data = inl(CONFIG_DATA);
if (data&0xFF) {
printf(" (rev %02X)\n", data&0xFF);
} else {
printf("\n");
}
}
} end func
} // end device
} // end bus
}


int main()
{
int ret;

/* Enable r/w permission of all 65536 ports */
ret = iopl(3);
if (ret < 0) {
perror("iopl set error");
return 1;
}

list_pci_devices();

/* Disable r/w permission of all 65536 ports */
ret = iopl(0);
if (ret < 0) {
perror("iopl set error");
return 1;
}

return 0;
}

方法二：這種方法需不需要對埠進行操作，而是利用Linux procfs來實現對PCI 配置空間的訪問。

[cpp] view plainprint?
/*
* Enum all pci device via /proc/bus/pci/.
*/
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>

#define PCI_MAX_BUS 255 /* 8 bits (0 ~ 255) */
#define PCI_MAX_DEV 31 /* 5 bits (0 ~ 31) */
#define PCI_MAX_FUN 7 /* 3 bits (0 ~ 7) */

/*
* PCI Configuration Header offsets
*/
#define PCICFG_REG_VID 0x00 /* Vendor id, 2 bytes */
#define PCICFG_REG_DID 0x02 /* Device id, 2 bytes */
#define PCICFG_REG_CMD 0x04 /* Command register, 2 bytes */
#define PCICFG_REG_STAT 0x06 /* Status register, 2 bytes */
#define PCICFG_REG_RID 0x08 /* Revision id, 1 byte */
#define PCICFG_REG_PROG_INTF 0x09 /* Programming interface code, 1 byte */
#define PCICFG_REG_SUBCLASS 0x0A /* Sub-class code, 1 byte */
#define PCICFG_REG_BASCLASS 0x0B /* Base class code, 1 byte */
#define PCICFG_REG_CACHE_LINESZ 0x0C /* Cache line size, 1 byte */
#define PCICFG_REG_LATENCY_TIMER 0x0D /* Latency timer, 1 byte */
#define PCICFG_REG_HEADER_TYPE 0x0E /* Header type, 1 byte */
#define PCICFG_REG_BIST 0x0F /* Builtin self test, 1 byte */
#define PCICFG_REG_BAR0 0x10 /* Base addr register 0, 4 bytes */
#define PCICFG_REG_BAR1 0x14 /* Base addr register 1, 4 bytes */
#define PCICFG_REG_BAR2 0x18 /* Base addr register 2, 4 bytes */
#define PCICFG_REG_BAR3 0x1C /* Base addr register 3, 4 bytes */
#define PCICFG_REG_BAR4 0x20 /* Base addr register 4, 4 bytes */
#define PCICFG_REG_BAR5 0x24 /* Base addr register 5, 4 bytes */
#define PCICFG_REG_CIS 0x28 /* Cardbus CIS Pointer */
#define PCICFG_REG_SVID 0x2C /* Subsystem Vendor ID, 2 bytes */
#define PCICFG_REG_SDID 0x2E /* Subsystem ID, 2 bytes */
#define PCICFG_REG_ROMBAR 0x30 /* ROM base register, 4 bytes */
#define PCICFG_REG_CAPPTR 0x34 /* Capabilities pointer, 1 byte */
#define PCICFG_REG_INT_LINE 0x3C /* Interrupt line, 1 byte */
#define PCICFG_REG_INT_PIN 0x3D /* Interrupt pin, 1 byte */
#define PCICFG_REG_MIN_GNT 0x3E /* Minimum grant, 1 byte */
#define PCICFG_REG_MAX_LAT 0x3F /* Maximum lat, 1 byte */


void list_pci_devices()
{
unsigned int bus, dev, fun;

//printf("BB:DD:FF VID:DID(RID)\n");


for (bus = 0; bus <= PCI_MAX_BUS; bus++) {
for (dev = 0; dev <= PCI_MAX_DEV; dev++) {
for (fun = 0; fun <= PCI_MAX_FUN; fun++) {
char proc_name[64];
int cfg_handle;
uint32_t data;
uint16_t vid, did;
uint8_t rid;

snprintf(proc_name, sizeof(proc_name),
"/proc/bus/pci/%02x/%02x.%x", bus, dev, fun);
cfg_handle = open(proc_name, O_RDWR);
if (cfg_handle <= 0)
continue;

lseek(cfg_handle, PCICFG_REG_VID, SEEK_SET);
read(cfg_handle, &data, sizeof(data));

/* Identify vendor ID */
if ((data != 0xFFFFFFFF) && (data != 0)) {
lseek(cfg_handle, PCICFG_REG_RID, SEEK_SET);
read(cfg_handle, &rid, sizeof(rid));
vid = data&0xFFFF;
did = data>>16;

printf("%02X:%02X:%02X", bus, dev, fun);
if (rid > 0) {
printf(" %04X:%04X (rev %02X)\n", vid, did, rid);
} else {
printf(" %04X:%04X\n", vid, did);
}
}
} // end func
} // end device
} // end bus
}

int main(int argc, char **argv)
{
list_pci_devices();

return 0;
}


這兩種方法各有優缺點，第一種方法方便移植到其他OS，第二種就只適用於Linux。但是，第一種方法需要對I/O port進行直接操作。第二種就不需要。

注意：執行這兩段代碼時，需要超級用戶（root） 許可權。

補充：今天在枚舉 Westmere-EP Processor（Intel Xeon Processor 5500 Series（Nehalem-EP））的 IMC（Integrated Memory Controller）時發現一個問題。lspci無法枚舉到IMC設備。Westmere-EP 是 Intel 新的處理器架構。和以往的CPU不一樣，它把Memory Controller集成到了CPU裡面。IMC控制器被映射到了PCI匯流排上，Bus Number 是0xFE~0xFF，procfs（/proc/bus/pci/）下沒有這幾個設備。但是，通過 CF8/CFC 埠可以枚舉到這些設備。
3. 這段代碼是在驅動中可以用來查找特定的pci device，並且返回一個pci_dev的結構體變數。通過這樣一個struct變數，內核提供的介面函數可以直接套用，如pci_read_config_word()，pci_write_config_word()等。
[cpp] view plainprint?
void list_pci_device()
{
struct pci_dev *dev;
struct pci_bus *bus,*childbus;

list_for_each_entry(bus, &pci_root_buses, node) { //globle pci_root_buses in pci.h
list_for_each_entry(dev, &bus->devices, bus_list) { // for bus 0
printk("%02X:%02X:%02X %04X:%04X\n",dev->bus->number,dev->devfn >> 3, dev->devfn & 0x07,dev->vendor,dev->device);
}
list_for_each_entry(childbus, &bus->children,node) { // for bus 1,2,3,...
list_for_each_entry(dev, &childbus->devices, bus_list) {
printk("%02X:%02X:%02X %04X:%04X\n",dev->bus->number,dev->devfn >> 3, dev->devfn & 0x07,dev->vendor,dev->device);
}
}
}