在qemu中增加pci设备并用linux驱动验证

声明本文主要针对x86架构进行说明。

使用的qemu版本是：qemu-kvm-1.2.0-rc2

1)PCI结构简介

每个PCI设备都有一个配置空间和若干个地址空间，按照固定的顺序放置CPI的各种配置参数。关于详细的介绍可以在网上搜索相关的资料。

下面是在busybox下lspci -mk的输出内容说明：

[plain]  view plain copy print ?

1. 00:00.0 "Class 0600" "8086" "1237" "1af4" "1100"  
2. 00:01.0 "Class 0601" "8086" "7000" "1af4" "1100"  
3. 00:01.1 "Class 0101" "8086" "7010" "1af4" "1100" "ata_piix"  
4. 00:01.3 "Class 0680" "8086" "7113" "1af4" "1100"  
5. 00:02.0 "Class 0300" "1013" "00b8" "1af4" "1100"  
6. 00:03.0 "Class 0200" "10ec" "8139" "1af4" "1100" "8139cp"  
7. 00:04.0 "Class 0604" "1011" "0026" "0000" "0000"  
8. 01:00.0 "Class 3542" "1234"         "5678"      "6872"          "8952"  
9.     class_id    vendor_id   device_id   subsystem_vendor_id subsystem_id  

2）qemu的桥

在qemu中桥，总线，设备都会对应一个设备结构。最开始的初始化硬件的函数是pc_init1，在这里调用函数i440fx_init创建一个pci_bus,并且和isa_bus关联起来，（qemu模拟的还是pci-isa桥），然后再基于pci_bus创建一系列的设备。

3）pci设备创建

先看下一个pci设备的结构是怎样的：

[cpp]  view plain copy print ?

1. static TypeInfo mem_pci_info = {  
2.     .name = "mem_pci",  
3.     .parent = TYPE_PCI_DEVICE,  
4.     .instance_size = sizeof(PCIMEMPCIState),  
5.     .class_init = mem_pci_class_init,          /// pci 设备的初始化函数  
6. };  

[cpp]  view plain copy print ?

1. static void mem_pci_register_types(void)  
2. {  
3.     type_register_static(&mem_pci_info);          /// 注册设备结构  
4. }  

在函数mem_pci_class_init里面为PCIDeviceClass的init数据成员赋值mem_pci_init

[cpp]  view plain copy print ?

1. static int mem_pci_init(PCIDevice *dev)  
2. {  
3.     PCIMEMPCIState *pci = DO_UPCAST(PCIMEMPCIState, pci_dev, dev);  
4.     MEMPCIState *s = &pci->state;  
5.   
6.     pci->mem_pci_base    = (uint32_t)malloc(PCI_MEM_SIZE);                            
7.     memory_region_init_io(&s->mem, &mem_pci_ops, pci, "mem-pci", PCI_MEM_SIZE);        /// 注册一个MemoryRegion结构体，并分配一个                                                                                   ///MemoryRegionOps数据成员，这样  
8.     pci_register_bar(dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->mem);                  ///给pci设备注册一个bar类型是mem。  
9.   
10.     return 0;  
11. }  

由于本文需要让 linux内核的pci驱动 跟  qemu模拟的pci设备  之间实现通信，注意仅仅是实现数据流的传送。如果操作pci设备空间用qemu提供的api函数 cpu_inb ，那么会导致qemu把通信的数据当作操作设备的命令来执行。所以这里申请了一块内存并用mem_pci_base来指向申请的内存。

当以后需要对这块内存读写操作的时候就可以直接读写这块内存:

[cpp]  view plain copy print ?

1. static void mem_pci_write(void *opaque, target_phys_addr_t addr,  
2.                              uint64_t value, unsigned int size)  
3. {  
4.         void    *pci_mem_addr;  
5.         int     temp,region_size;  
6.     byte    buff[8];  
7.   
8.     pci_mem_addr    = ((PCIMEMPCIState *)opaque)->mem_pci_base;  
9.     pci_mem_addr    = ((char *)pci_mem_addr) + addr;  
10.   
11.     switch (size) {  
12.             case 1:  
13.             sprintf(buff,"%02llx",value);  
14.             sscanf(buff,"%x",&temp);  
15.             *((byte*)pci_mem_addr)  = (byte)temp;  
16.             break;  
17.     }  
18. }  

具体的qemu端pci设备 mem_pci.c 实现方式如下所示：

[cpp]  view plain copy print ?

1. /* 
2.  * QEMU memory pci emulation (PCI to ISA bridge) 
3.  * 
4.  */  
5.   
6. #include "pci.h"  
7. #include "pc.h"  
8. #include "i8254.h"  
9. #include "pcspk.h"  
10. #include "hw.h"  
11.   
12.   
13. #define MEM_PCI_VENDOR_ID   0x1234  
14. #define MEM_PCI_DEVICE_ID   0x5678  
15. #define MEM_PCI_REVISION_ID 0x73  
16.   
17. #define PCI_MEM_SIZE        0x00000010  
18.   
19. typedef struct MEMPCIState {  
20.     MemoryRegion mem;  
21. } MEMPCIState;  
22.   
23. typedef struct PCIMEMPCIState {  
24.     PCIDevice pci_dev;  
25.     uint32_t mem_pci_base;  
26.     MEMPCIState state;  
27. } PCIMEMPCIState;  
28.   
29. static const VMStateDescription vmstate_mem_pci = {  
30.     .name = "mem_pci",  
31.     .version_id = 0,  
32.     .minimum_version_id = 0,  
33.     .fields = (VMStateField[]) {  
34.         VMSTATE_PCI_DEVICE(pci_dev, PCIMEMPCIState),  
35.         VMSTATE_END_OF_LIST()  
36.     },  
37. };  
38.   
39.   
40. typedef unsigned char  byte;  
41. typedef unsigned short int uint16;  
42. typedef unsigned int    uint32;  
43.   
44.   
45. static void mem_pci_write(void *opaque, target_phys_addr_t addr,  
46.                              uint64_t value, unsigned int size)  
47. {  
48.         void    *pci_mem_addr;  
49.         int     temp,region_size;  
50.     byte    buff[8];  
51.       
52.     pci_mem_addr    = ((PCIMEMPCIState *)opaque)->mem_pci_base;  
53.     pci_mem_addr    = ((char *)pci_mem_addr) + addr;  
54.     region_size = (int)memory_region_size( &((PCIMEMPCIState *)opaque)->state.mem);  
55.   
56.     if(addr > region_size)  
57.         return ;  
58.     fprintf(stderr,"%x\n",pci_mem_addr);  
59.     switch (size) {  
60.             case 1:  
61.             sprintf(buff,"%02llx",value);  
62.             sscanf(buff,"%x",&temp);  
63.             *((byte*)pci_mem_addr)  = (byte)temp;  
64.             break;  
65.             case 2:  
66.             sprintf(buff,"%04llx",value);  
67.             sscanf(buff,"%x",&temp);  
68.             *((uint16*)pci_mem_addr)= (uint16)temp;  
69.             break;  
70.             case 4:  
71.             sprintf(buff,"%08llx",value);  
72.             sscanf(buff,"%x",&temp);                  
73.             *((uint32*)pci_mem_addr)= (uint32)temp;  
74.             break;  
75.     }  
76.     fprintf(stderr,"%x\n",temp);  
77. }  
78.   
79. static uint64_t mem_pci_read(void *opaque, target_phys_addr_t addr,  
80.                                 unsigned int size)  
81. {  
82.     void    *pci_mem_addr;  
83.     int     temp,region_size;  
84.     byte    buff[8];  
85.     pci_mem_addr    = ((PCIMEMPCIState *)opaque)->mem_pci_base;  
86.     pci_mem_addr    = ((char *)pci_mem_addr) + addr;  
87.     region_size = memory_region_size(&((PCIMEMPCIState *)opaque)->state.mem);      
88.   
89.     if(addr > region_size)  
90.         return 0;  
91.     switch (size) {  
92.         case 1:  
93.             temp = *((byte *)pci_mem_addr);  
94.             return ((byte)temp);  
95.         case 2:  
96.             temp = *((uint16 *)pci_mem_addr);  
97.             return ((uint16)temp);  
98.         case 4:  
99.             temp = *((uint32 *)pci_mem_addr);  
100.             return ((uint32)temp);  
101.     }  
102.         //fprintf(stderr,"%d",temp);  
103. }  
104.   
105. static const MemoryRegionOps mem_pci_ops = {  
106.     .read = mem_pci_read,  
107.     .write = mem_pci_write,  
108.     .endianness = DEVICE_LITTLE_ENDIAN,  
109. };  
110.   
111.   
112. static Property mem_pci_properties[] = {  
113.     DEFINE_PROP_HEX32("membase", PCIMEMPCIState, mem_pci_base, 0xc0000000),  
114.     DEFINE_PROP_END_OF_LIST()  
115. };  
116.   
117.   
118. static int mem_pci_init(PCIDevice *dev)  
119. {  
120.     PCIMEMPCIState *pci = DO_UPCAST(PCIMEMPCIState, pci_dev, dev);  
121.     MEMPCIState *s = &pci->state;  
122.   
123.     pci->mem_pci_base    = (uint32_t)malloc(PCI_MEM_SIZE);  
124.     memory_region_init_io(&s->mem, &mem_pci_ops, pci, "mem-pci", PCI_MEM_SIZE);  
125.     pci_register_bar(dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->mem);  
126.   
127.     return 0;  
128. }  
129.   
130. static void mem_pci_class_init(ObjectClass *klass, void *data)  
131. {  
132.     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);  
133.     DeviceClass *dc = DEVICE_CLASS(klass);  
134.   
135.     k->init = mem_pci_init;  
136.     k->vendor_id = MEM_PCI_VENDOR_ID;  
137.     k->device_id = MEM_PCI_DEVICE_ID;  
138.     k->revision  = MEM_PCI_REVISION_ID;  
139.   
140.     dc->vmsd = &vmstate_mem_pci;  
141.     dc->props = mem_pci_properties;  
142. }  
143.   
144. static TypeInfo mem_pci_info = {  
145.     .name = "mem_pci",  
146.     .parent = TYPE_PCI_DEVICE,  
147.     .instance_size = sizeof(PCIMEMPCIState),  
148.     .class_init = mem_pci_class_init,  
149. };  
150.   
151. static void mem_pci_register_types(void)  
152. {  
153.     type_register_static(&mem_pci_info);  
154. }  
155.   
156. type_init(mem_pci_register_types)  

在文件hw/pc_piix.c 函数pc_init1里面增加创建设备的代码：

[cpp]  view plain copy print ?

1. pc_cmos_init(below_4g_mem_size, above_4g_mem_size, boot_device,  
2.              floppy, idebus[0], idebus[1], rtc_state);  
3.   
4. pci_create_simple_multifunction(pci_bus, -1,true ,"mem_pci");  
5.   
6. if (pci_enabled && usb_enabled) {  
7.     pci_create_simple(pci_bus, piix3_devfn + 2, "piix3-usb-uhci");  
8. }  

把源文件mem_pci.c放在hw目录下，在文件hw/Makefile.objs 增加如下代码：

[plain]  view plain copy print ?

1. hw-obj-y                  += mem_pci.o  

然后编译。

linux内核一端需要有一个pci驱动来驱动这个我们模拟的pci设备，这里仅仅是一个简单的pci设备驱动，关于其框架不多说了，网上有很多教程。直接给出代码吧：

（注意对比这个驱动代码和上面的设备代码相同的地方）

[cpp]  view plain copy print ?

1. #include <linux/kernel.h>  
2. #include <linux/module.h>  
3. #include <linux/pci.h>  
4. #include <linux/init.h>  
5.   
6.   
7. #define MEM_PCI_VENDOR_ID       0x1234  
8. #define MEM_PCI_DEVICE_ID       0x5678        
9. #define MEM_PCI_REVISION_ID     0x73  
10.   
11. typedef unsigned char  byte;  
12. typedef unsigned short int uint16;  
13. typedef unsigned int    uint32;  
14.   
15. static struct pci_device_id ids[] = {  
16.     { PCI_DEVICE(MEM_PCI_VENDOR_ID, MEM_PCI_DEVICE_ID), },  
17.     { 0, }  
18. };  
19. MODULE_DEVICE_TABLE(pci, ids);  
20.   
21. static unsigned char skel_get_revision(struct pci_dev *dev)  
22. {  
23.     u8 revision;  
24.   
25.     pci_read_config_byte(dev, PCI_REVISION_ID, &revision);  
26.     return revision;  
27. }  
28.   
29.   
30. //return 0 means success  
31. static int probe(struct pci_dev *dev, const struct pci_device_id *id)  
32. {  
33.         /* Do probing type stuff here.   
34.          * Like calling request_region(); 
35.          */   
36.     unsigned char revision_id;  
37.     int bar ;  
38.   
39.     if (skel_get_revision(dev) != MEM_PCI_REVISION_ID)  
40.         return 1;  
41.   
42.         pci_enable_device(dev);  
43.   
44.     bar = 1;  
45.     resource_size_t start = pci_resource_start(dev, bar);  
46.     resource_size_t len = pci_resource_len(dev, bar);  
47.     unsigned long flags = pci_resource_flags(dev, bar);  
48.   
49.     void __iomem * addressio = pci_iomap(dev,bar,len);  
50.     *(byte *)addressio = 0x57;  
51.     iowrite8(0x89,addressio + 8);  
52.     printk("%x\n",ioread8(addressio + 8));  
53.     printk("%x\n",*(byte *)addressio);  
54.   
55.     return 0;  
56. }  
57.   
58. static void remove(struct pci_dev *dev)  
59. {  
60.     /* clean up any allocated resources and stuff here. 
61.     * like call release_region(); 
62.     */  
63.     pci_disable_device(dev);  
64. }  
65.   
66. static struct pci_driver pci_driver = {  
67.     .name = "mem_pci",  
68.     .id_table = ids,  
69.     .probe = probe,  
70.     .remove = remove,  
71. };  
72.   
73. static int __init mem_pci_init(void)  
74. {  
75.     return pci_register_driver(&pci_driver);  
76. }  
77.   
78. static void __exit mem_pci_exit(void)  
79. {  
80.     pci_unregister_driver(&pci_driver);  
81. }  
82.   
83. MODULE_LICENSE("GPL");  
84. MODULE_AUTHOR("gudujian");    
85.   
86. module_init(mem_pci_init);  
87. module_exit(mem_pci_exit);  

上面的驱动程序在pci设备的首字节写了一个字符0x57.在第8个字节写了一个字符0x89.并读出来：

上面只是实现了一个简单的字节读写功能，有兴趣的可以参考我以前的文章 http://blog.csdn.net/xsckernel/article/details/8159568 把pci驱动实现成一个字符驱动。

本文部分参考文章：

http://blog.csdn.net/yearn520/article/details/6576875

http://blog.csdn.net/yearn520/article/details/6577988