3 * - By John Hodge (thePowersGang)
\r
6 * - PCI Enumeration and Arbitration
\r
10 #include <modules.h>
\r
12 #include <fs_devfs.h>
\r
13 #include <drv_pci.h>
\r
14 #include <drv_pci_int.h>
\r
15 #include <virtual_pci.h>
\r
17 #define USE_PORT_BITMAP 0
\r
18 #define LIST_DEVICES 1
\r
19 #define PCI_MAX_BUSSES 8
\r
21 // === STRUCTURES ===
\r
22 typedef struct sPCIDevice
\r
24 Uint16 bus, slot, fcn;
\r
25 Uint16 vendor, device;
\r
26 Uint32 class; // Class:Subclass:ProgIf
\r
28 Uint32 ConfigCache[256/4];
\r
33 // === CONSTANTS ===
\r
34 #define SPACE_STEP 5
\r
35 #define MAX_RESERVED_PORT 0xD00
\r
37 // === PROTOTYPES ===
\r
38 int PCI_Install(char **Arguments);
\r
39 int PCI_ScanBus(int ID, int bFill);
\r
41 int PCI_int_ReadDirRoot(tVFS_Node *node, int pos, char Dest[FILENAME_MAX]);
\r
42 tVFS_Node *PCI_int_FindDirRoot(tVFS_Node *node, const char *filename);
\r
43 Uint32 PCI_int_GetBusAddr(Uint16 Bus, Uint16 Slot, Uint16 Fcn, Uint8 Offset);
\r
44 size_t PCI_int_ReadDevice(tVFS_Node *node, off_t Offset, size_t Length, void *buffer);
\r
45 int PCI_int_EnumDevice(Uint16 bus, Uint16 dev, Uint16 fcn, tPCIDevice *info);
\r
48 MODULE_DEFINE(0, 0x0100, PCI, PCI_Install, NULL, NULL);
\r
49 int giPCI_BusCount = 1;
\r
50 Uint8 gaPCI_BusNumbers[PCI_MAX_BUSSES];
\r
51 int giPCI_InodeHandle = -1;
\r
52 int giPCI_DeviceCount = 0;
\r
53 tPCIDevice *gPCI_Devices = NULL;
\r
54 tVFS_NodeType gPCI_RootNodeType = {
\r
55 .TypeName = "PCI Root Node",
\r
56 .ReadDir = PCI_int_ReadDirRoot,
\r
57 .FindDir = PCI_int_FindDirRoot
\r
59 tVFS_NodeType gPCI_DevNodeType = {
\r
60 .TypeName = "PCI Dev Node",
\r
61 .Read = PCI_int_ReadDevice
\r
63 tDevFS_Driver gPCI_DriverStruct = {
\r
66 .Flags = VFS_FFLAG_DIRECTORY,
\r
69 .ACLs = &gVFS_ACL_EveryoneRX,
\r
70 .Type = &gPCI_RootNodeType
\r
74 Uint32 *gaPCI_PortBitmap = NULL;
\r
76 Uint32 gaPCI_BusBitmap[256/32];
\r
80 * \brief Scan the PCI Bus for devices
\r
81 * \param Arguments Boot-time parameters
\r
83 int PCI_Install(char **Arguments)
\r
90 gaPCI_PortBitmap = malloc( 1 << 13 );
\r
91 if( !gaPCI_PortBitmap ) {
\r
92 Log_Error("PCI", "Unable to allocate %i bytes for bitmap", 1 << 13);
\r
93 return MODULE_ERR_MALLOC;
\r
95 memset( gaPCI_PortBitmap, 0, 1 << 13 );
\r
97 for( i = 0; i < MAX_RESERVED_PORT / 32; i ++ )
\r
98 gaPCI_PortBitmap[i] = -1;
\r
99 for( i = 0; i < MAX_RESERVED_PORT % 32; i ++ )
\r
100 gaPCI_PortBitmap[MAX_RESERVED_PORT / 32] = 1 << i;
\r
103 // Scan Bus (Bus 0, Don't fill gPCI_Devices)
\r
104 giPCI_DeviceCount = 0;
\r
105 giPCI_BusCount = 1;
\r
106 gaPCI_BusNumbers[0] = 0;
\r
107 for( bus = 0; bus < giPCI_BusCount; bus ++ )
\r
109 ret = PCI_ScanBus(gaPCI_BusNumbers[bus], 0);
\r
110 if(ret != MODULE_ERR_OK) return ret;
\r
113 // - Add VPCI Devices
\r
114 giPCI_DeviceCount += giVPCI_DeviceCount;
\r
116 if(giPCI_DeviceCount == 0) {
\r
117 Log_Notice("PCI", "No devices were found");
\r
118 return MODULE_ERR_NOTNEEDED;
\r
121 // Allocate device buffer
\r
122 tmpPtr = malloc(giPCI_DeviceCount * sizeof(tPCIDevice));
\r
123 if(tmpPtr == NULL) {
\r
124 Log_Warning("PCI", "Malloc ERROR");
\r
125 return MODULE_ERR_MALLOC;
\r
127 gPCI_Devices = tmpPtr;
\r
129 Log_Log("PCI", "%i devices, filling structure", giPCI_DeviceCount);
\r
132 giPCI_DeviceCount = 0;
\r
133 giPCI_BusCount = 1;
\r
134 memset(gaPCI_BusBitmap, 0, sizeof(gaPCI_BusBitmap));
\r
135 // Rescan, filling the PCI device array
\r
136 for( bus = 0; bus < giPCI_BusCount; bus ++ )
\r
138 PCI_ScanBus(gaPCI_BusNumbers[bus], 1);
\r
140 // Insert VPCI Devices
\r
141 for( int i = 0; i < giVPCI_DeviceCount; i ++ )
\r
143 tPCIDevice *devinfo = &gPCI_Devices[giPCI_DeviceCount];
\r
148 devinfo->vendor = gaVPCI_Devices[i].Vendor;
\r
149 devinfo->device = gaVPCI_Devices[i].Device;
\r
150 devinfo->revision = gaVPCI_Devices[i].Class & 0xFF;
\r
151 devinfo->class = gaVPCI_Devices[i].Class >> 8;
\r
152 snprintf(devinfo->Name, sizeof(devinfo->Name), "%02x.%02x:%x", 0xFF, i, 0);
\r
154 for(int j = 0; j < 256/4; j ++ )
\r
155 devinfo->ConfigCache[i] = VPCI_Read(&gaVPCI_Devices[i], j*4, 4);
\r
157 memset(&devinfo->Node, 0, sizeof(devinfo->Node));
\r
158 devinfo->Node.Inode = giPCI_DeviceCount;
\r
159 devinfo->Node.Size = 256;
\r
160 devinfo->Node.NumACLs = 1;
\r
161 devinfo->Node.ACLs = &gVFS_ACL_EveryoneRO;
\r
162 devinfo->Node.Type = &gPCI_DevNodeType;
\r
164 giPCI_DeviceCount ++;
\r
167 // Complete Driver Structure
\r
168 gPCI_DriverStruct.RootNode.Size = giPCI_DeviceCount;
\r
170 // And add to DevFS
\r
171 DevFS_AddDevice(&gPCI_DriverStruct);
\r
173 return MODULE_ERR_OK;
\r
177 * \brief Scans a specific PCI Bus
\r
178 * \param BusID PCI Bus ID to scan
\r
179 * \param bFill Fill the \a gPCI_Devices array?
\r
181 int PCI_ScanBus(int BusID, int bFill)
\r
184 tPCIDevice devInfo;
\r
186 if( gaPCI_BusBitmap[BusID/32] & (1 << (BusID%32)) )
\r
187 return MODULE_ERR_OK;
\r
189 gaPCI_BusBitmap[BusID/32] |= (1 << (BusID%32));
\r
191 for( dev = 0; dev < 32; dev++ ) // 32 Devices per bus
\r
193 for( fcn = 0; fcn < 8; fcn++ ) // Max 8 functions per device
\r
195 // Check if the device/function exists
\r
196 if(!PCI_int_EnumDevice(BusID, dev, fcn, &devInfo))
\r
201 Log_Log("PCI", "Device %i,%i:%i %06x => 0x%04x:0x%04x Rev %i",
\r
202 BusID, dev, fcn, devInfo.class,
\r
203 devInfo.vendor, devInfo.device, devInfo.revision);
\r
207 devInfo.Node.Inode = giPCI_DeviceCount;
\r
208 memcpy(&gPCI_Devices[giPCI_DeviceCount], &devInfo, sizeof(tPCIDevice));
\r
210 giPCI_DeviceCount ++;
\r
212 switch(devInfo.ConfigCache[3] & 0x007F0000)
\r
214 case 0x00: // Normal device
\r
216 case 0x01: // PCI-PCI Bridge
\r
218 // TODO: Add to list of busses?
\r
219 Uint8 sec = (devInfo.ConfigCache[6] & 0x0000FF00) >> 8;
\r
222 Uint8 pri = (devInfo.ConfigCache[6] & 0x000000FF) >> 0;
\r
223 Log_Log("PCI", "- PCI-PCI Bridge %02x=>%02x", pri, sec);
\r
226 gaPCI_BusNumbers[giPCI_BusCount++] = sec;
\r
229 case 0x02: // PCI-CardBus Bridge
\r
233 // If bit 8 of the Header Type register is set, there are sub-functions
\r
234 if(fcn == 0 && !(devInfo.ConfigCache[3] & 0x00800000) )
\r
239 return MODULE_ERR_OK;
\r
243 * \brief Read from Root of PCI Driver
\r
245 int PCI_int_ReadDirRoot(tVFS_Node *Node, int Pos, char Dest[FILENAME_MAX])
\r
247 ENTER("pNode iPos", Node, Pos);
\r
248 if(Pos < 0 || Pos >= giPCI_DeviceCount) {
\r
249 LEAVE_RET('i', -EINVAL);
\r
252 LOG("Name = %s", gPCI_Devices[Pos].Name);
\r
253 strncpy(Dest, gPCI_Devices[Pos].Name, FILENAME_MAX);
\r
258 tVFS_Node *PCI_int_FindDirRoot(tVFS_Node *node, const char *filename)
\r
263 for(i=0;i<giPCI_DeviceCount;i++)
\r
265 int cmp = strcmp(gPCI_Devices[i].Name, filename);
\r
266 if( cmp > 0 ) // Sorted list
\r
269 return &gPCI_Devices[i].Node;
\r
277 * \brief Read the PCI configuration space of a device
\r
279 size_t PCI_int_ReadDevice(tVFS_Node *node, off_t pos, size_t length, void *buffer)
\r
281 if( pos + length > 256 ) return 0;
\r
285 (char*)gPCI_Devices[node->Inode].ConfigCache + pos,
\r
291 // --- Kernel Code Interface ---
\r
293 * \brief Counts the devices with the specified codes
\r
294 * \param vendor Vendor ID
\r
295 * \param device Device ID
\r
297 int PCI_CountDevices(Uint16 vendor, Uint16 device)
\r
300 for(i=0;i<giPCI_DeviceCount;i++)
\r
302 if(gPCI_Devices[i].vendor != vendor) continue;
\r
303 if(gPCI_Devices[i].device != device) continue;
\r
310 * \brief Gets the ID of the specified PCI device
\r
311 * \param vendor Vendor ID
\r
312 * \param device Device ID
\r
313 * \param idx Number of matching entry wanted
\r
315 tPCIDev PCI_GetDevice(Uint16 vendor, Uint16 device, int idx)
\r
318 for( i = 0; i < giPCI_DeviceCount; i ++ )
\r
320 if(gPCI_Devices[i].vendor != vendor) continue;
\r
321 if(gPCI_Devices[i].device != device) continue;
\r
322 if(j == idx) return i;
\r
329 * \brief Gets the ID of a device by it's class code
\r
330 * \param class Class Code
\r
331 * \param mask Mask for class comparison
\r
332 * \param prev ID of previous device (-1 for no previous)
\r
334 tPCIDev PCI_GetDeviceByClass(Uint32 class, Uint32 mask, tPCIDev prev)
\r
337 // Check if prev is negative (meaning get first)
\r
338 if(prev < 0) i = 0;
\r
341 for( ; i < giPCI_DeviceCount; i++ )
\r
343 if((gPCI_Devices[i].class & mask) == class)
\r
349 int PCI_GetDeviceInfo(tPCIDev ID, Uint16 *Vendor, Uint16 *Device, Uint32 *Class)
\r
351 tPCIDevice *dev = &gPCI_Devices[ID];
\r
352 if(ID < 0 || ID >= giPCI_DeviceCount) return 1;
\r
354 if(Vendor) *Vendor = dev->vendor;
\r
355 if(Device) *Device = dev->device;
\r
356 if(Class) *Class = dev->class;
\r
360 int PCI_GetDeviceVersion(tPCIDev ID, Uint8 *Revision)
\r
362 tPCIDevice *dev = &gPCI_Devices[ID];
\r
363 if(ID < 0 || ID >= giPCI_DeviceCount) return 1;
\r
365 if(Revision) *Revision = dev->revision;
\r
369 int PCI_GetDeviceSubsys(tPCIDev ID, Uint16 *SubsystemVendor, Uint16 *SubsystemID)
\r
371 tPCIDevice *dev = &gPCI_Devices[ID];
\r
372 if(ID < 0 || ID >= giPCI_DeviceCount) return 1;
\r
374 if(SubsystemVendor) *SubsystemVendor = dev->ConfigCache[0x2c/4] & 0xFFFF;
\r
375 if(SubsystemID) *SubsystemID = dev->ConfigCache[0x2c/4] >> 16;
\r
380 Uint32 PCI_int_GetBusAddr(Uint16 Bus, Uint16 Slot, Uint16 Fcn, Uint8 Offset)
\r
386 return ((Uint32)Bus << 16) | (Slot << 11) | (Fcn << 8) | (Offset & 0xFC);
\r
389 Uint32 PCI_ConfigRead(tPCIDev ID, int Offset, int Size)
\r
392 Uint32 dword, addr;
\r
394 if( ID < 0 || ID >= giPCI_DeviceCount ) return 0;
\r
395 if( Offset < 0 || Offset > 256 ) return 0;
\r
397 // TODO: Should I support non-aligned reads?
\r
398 if( Offset & (Size - 1) ) return 0;
\r
400 dev = &gPCI_Devices[ID];
\r
401 // Detect VPCI devices
\r
402 if( dev->bus == -1 ) {
\r
403 return VPCI_Read(&gaVPCI_Devices[dev->slot], Offset, Size);
\r
406 addr = PCI_int_GetBusAddr(dev->bus, dev->slot, dev->fcn, Offset);
\r
408 dword = PCI_CfgReadDWord(addr);
\r
409 gPCI_Devices[ID].ConfigCache[Offset/4] = dword;
\r
412 case 1: return (dword >> (8 * (Offset&3))) & 0xFF;
\r
413 case 2: return (dword >> (8 * (Offset&2))) & 0xFFFF;
\r
414 case 4: return dword;
\r
420 void PCI_ConfigWrite(tPCIDev ID, int Offset, int Size, Uint32 Value)
\r
423 Uint32 dword, addr;
\r
426 if( ID < 0 || ID >= giPCI_DeviceCount ) return ;
\r
427 if( Offset < 0 || Offset > 256 ) return ;
\r
429 dev = &gPCI_Devices[ID];
\r
431 // Detect VPCI devices
\r
432 if( dev->bus == -1 ) {
\r
433 VPCI_Write(&gaVPCI_Devices[dev->slot], Offset, Size, Value);
\r
437 addr = PCI_int_GetBusAddr(dev->bus, dev->slot, dev->fcn, Offset);
\r
440 dword = PCI_CfgReadDWord(addr);
\r
444 shift = (Offset&3)*8;
\r
445 dword &= ~(0xFF << shift);
\r
446 dword |= Value << shift;
\r
449 shift = (Offset&2)*8;
\r
450 dword &= ~(0xFFFF << shift);
\r
451 dword |= Value << shift;
\r
459 PCI_CfgWriteDWord(addr, dword);
\r
463 * \brief Get the IRQ assigned to a device
\r
465 Uint8 PCI_GetIRQ(tPCIDev id)
\r
467 if(id < 0 || id >= giPCI_DeviceCount)
\r
469 return gPCI_Devices[id].ConfigCache[15] & 0xFF;
\r
470 //return PCI_CfgReadByte( gPCI_Devices[id].bus, gPCI_Devices[id].slot, gPCI_Devices[id].fcn, 0x3C);
\r
474 * \brief Read the a BAR (base address register) from the PCI config space
\r
476 Uint32 PCI_GetBAR(tPCIDev id, int BARNum)
\r
478 if(id < 0 || id >= giPCI_DeviceCount)
\r
480 if(BARNum < 0 || BARNum >= 6)
\r
482 return gPCI_Devices[id].ConfigCache[4+BARNum];
\r
486 * \brief Get device information for a slot/function
\r
488 int PCI_int_EnumDevice(Uint16 bus, Uint16 slot, Uint16 fcn, tPCIDevice *info)
\r
490 Uint32 vendor_dev, tmp;
\r
493 addr = PCI_int_GetBusAddr(bus, slot, fcn, 0);
\r
495 vendor_dev = PCI_CfgReadDWord( addr );
\r
496 if((vendor_dev & 0xFFFF) == 0xFFFF) // Invalid Device
\r
503 // Read configuration
\r
504 info->ConfigCache[0] = vendor_dev;
\r
505 for( i = 1, addr += 4; i < 256/4; i ++, addr += 4 )
\r
507 info->ConfigCache[i] = PCI_CfgReadDWord(addr);
\r
510 info->vendor = vendor_dev & 0xFFFF;
\r
511 info->device = vendor_dev >> 16;
\r
512 tmp = info->ConfigCache[2];
\r
513 info->revision = tmp & 0xFF;
\r
514 info->class = tmp >> 8;
\r
516 // #if LIST_DEVICES
\r
517 // Log("BAR0 0x%08x BAR1 0x%08x BAR2 0x%08x", info->ConfigCache[4], info->ConfigCache[5], info->ConfigCache[6]);
\r
518 // Log("BAR3 0x%08x BAR4 0x%08x BAR5 0x%08x", info->ConfigCache[7], info->ConfigCache[8], info->ConfigCache[9]);
\r
519 // Log("Class: 0x%06x", info->class);
\r
523 snprintf(info->Name, 8, "%02x.%02x:%x", bus, slot, fcn);
\r
526 memset( &info->Node, 0, sizeof(tVFS_Node) );
\r
527 info->Node.Size = 256;
\r
529 info->Node.NumACLs = 1;
\r
530 info->Node.ACLs = &gVFS_ACL_EveryoneRO;
\r
532 info->Node.Type = &gPCI_DevNodeType;
\r
539 EXPORT(PCI_CountDevices);
\r
540 EXPORT(PCI_GetDevice);
\r
541 EXPORT(PCI_GetDeviceByClass);
\r
542 EXPORT(PCI_GetDeviceInfo);
\r
543 EXPORT(PCI_GetDeviceVersion);
\r
544 EXPORT(PCI_GetDeviceSubsys);
\r
545 //EXPORT(PCI_AssignPort);
\r
546 EXPORT(PCI_GetBAR);
\r
547 EXPORT(PCI_GetIRQ);
\r