Changeset 2021 for Whitix

Timestamp:

04/02/09 21:22:06 (3 years ago)

Author:

mwhitworth

Message:

Register PCI as a bus type, add attributes, fix PCI resource detection code.

Files:

• Whitix/trunk/devices/pci/pci_core.c (modified) (16 diffs)

Whitix/trunk/devices/pci/pci_core.c

@@ -24 +24 @@
 #include <slab.h>
 
+#include <devices/bus.h>
+
 LIST_HEAD(pciBusList);
 struct Cache* pciDeviceCache;
@@ -106 +108 @@
 }
 
-char* classes[]=
+static char* classes[]=
 {
         "Unclassified device",
@@ -128 +130 @@
 };
 
-#define PCI_WRITE_TEST  0xFFFFFFFF
-#define PCI_BAR_BASE    0x10
+static int PciConvertResFlags(int flags)
+{
+        if (flags & PCI_RESOURCE_IO)
+                return RESOURCE_IO;
+                
+        return RESOURCE_MEM;
+}
 
 int PciDeviceProbe(struct PciDevice* device)
@@ -140 +147 @@
         for (i=0; i<6; i++)
         {
+                unsigned long flags;
+                
                 PciReadConfigDword(device, PCI_BAR_BASE + (i << 2), &v);
         
@@ -152 +161 @@
                 if (v == PCI_WRITE_TEST)
                         v = 0;
+                        
+                flags = v & 0xF;
+                v &= ~0xF;
                 
                 size &= 0xFFFFFFF0;
-                                                        
+                size = (size & ~(size-1)) - 1;
+                                                                                                                
                 /* Parse the base address register. */
-                device->spaces[i] = v;
+                device->spaces[i].start = v;
+                device->spaces[i].len = size;
+                device->spaces[i].flags = PciConvertResFlags(flags);
         }
 
@@ -188 +203 @@
         deviceId=(WORD)v;
 
+        if (vendorId == 0xFFFF && deviceId == 0x0001)
+        {
+                KePrint("TODO: Need to retry read.\n");
+        }
+
         /* No device here if the vendor ID is invalid. */
         if (PCI_VENDOR_INVALID(vendorId))
                 return NULL;
 
-        /* Read in the header type to find out if it is a multi-function device.
-         * If it isn't, there's no point allocating a device structure for it. */
+        /* Read in the header type to find out if it is a multi-function device. */
         PciRead(bus->index, dev, func, 0x0E, 1, &v);
         deviceType=(BYTE)v;
 
-        if (func && !(deviceType & 0x80))
+#if 0
+        if (!func && !(deviceType & 0x80))
                 return NULL;
+#endif
 
         /* Allocate the device. */
@@ -213 +234 @@
         device->func=func;
 
-        PciReadConfigByte(device, 0x0B, &device->devClass);
-        PciReadConfigByte(device, 0x0A, &device->subClass);
-        
+        /* Once we have the basic device information set up, we can use the
+         * PciReadConfig* functions. */
+        PciReadConfigDword(device, 0x08, &device->devClass);
+        
+        /* Shift out the revision id. */
+        device->devClass >>= 8;
+                
         switch (deviceType & 0x7F)
         {
@@ -223 +248 @@
 
                 case 1:
-                        KePrint("PCI to PCI bridge\n");
                         break;
 
@@ -229 +253 @@
                         break;
         }
+        
+        device->headerType = (deviceType & 0x7F);
 
         return device;
 }
+
+struct IcAttribute pciBusAttrs[] =
+{
+        IC_INT(struct PciDevice, vendorId, IC_READ),
+        IC_INT(struct PciDevice, deviceId, IC_READ),
+        IC_INT(struct PciDevice, devClass, IC_READ),
+        IC_END(),
+};
+
+struct KeBusType pciBusType=
+{
+        .name = "Pci",
+//      .match = PciDeviceMatch,
+
+        /* Used when adding a bus entry. */
+        .busEntryAttrs = pciBusAttrs,
+        .busEntryOffset = OffsetOf(struct PciDevice, entry),
+};
 
 int PciScanBus(int index)
@@ -239 +283 @@
         struct PciDevice* device;
 
+        PreemptDisable();
+
         /* Allocate the bus. */
         bus=(struct PciBus*)MemCacheAlloc(pciBusCache);
@@ -244 +290 @@
         if (!bus)
                 return -ENOMEM;
+
+        KeBusRegister(&pciBusType, &bus->bus, index);
 
         INIT_LIST_HEAD(&bus->deviceList);
         ListAddTail(&bus->next, &pciBusList);
         bus->index=index;
+
+        PreemptEnable();
 
         /* Populate its device list. */
@@ -253 +303 @@
                 for (func=0; func<8; func++)
                 {
-                        device=PciProbe(bus, dev, func);
+                        device = PciProbe(bus, dev, func);
 
                         if (device)
+                        {
                                 ListAddTail(&device->next, &bus->deviceList);
+                                
+                                /* FIXME: Create and register device, add to bus list of devices. */
+                                KeBusEntryRegister(&bus->bus, &device->entry, "%d.%d", dev, func);
+                        }
                 }
-
-        return 0;
+                
+        /* Scan all the child bridges. */
+        ListForEachEntry(device, &bus->deviceList, next)
+        {
+                if (device->headerType == 1)
+                {
+                        DWORD bus;
+                        
+                        PciReadConfigDword(device, PCI_PRIMARY_BUS, &bus);
+                                                                        
+                        //PciScanBus(busNumber);
+                }
+        }
+                
+        KeBusStart(&bus->bus);
+
+        return 0;
+}
+
+/* FIXME: Need to get KeObject from IcFs? */    
+int PciFollowDriverLink(struct KeFsEntry** dest, struct KeFsEntry* src)
+{
+        struct KeObject* object = NULL; /* Doesn't work. */
+        struct KeBusEntry* entry = ContainerOf(object, struct KeBusEntry, object);
+        struct PciDevice* device = ContainerOf(entry, struct PciDevice, entry);
+                
+        /* If this is true, the symbolic link should not have been created in the
+         * first place. */
+        if (!device->driver || !device->driver->module)
+                return -ENOENT;
+                
+        *dest = ModuleGetIcDir(device->driver->module);
+        
+        return 0;
+}
+
+void PciLinkDriver(struct PciDevice* device, struct PciDriver* driver)
+{
+        device->driver = driver;
+        
+        IcFsAddSoftLink(device->entry.object.dir, "driver", PciFollowDriverLink);
 }
 
@@ -275 +369 @@
                         (currId->deviceId == device->deviceId || currId->deviceId == PCI_ID_ANY) &&
                         (currId->subVendor == device->subVendor || currId->subVendor == PCI_ID_ANY) &&
-                        (currId->subDevice == device->subDevice || currId->subDevice == PCI_ID_ANY) /*&&
-                        ((currId->class ^ device->devClass) & currId->classMask)*/)
+                        (currId->subDevice == device->subDevice || currId->subDevice == PCI_ID_ANY) &&
+                        !((currId->class ^ device->devClass) & currId->classMask))
                 {
-                        device->driver = driver;
-                        
                         /* Matched! Start up the device. */
                         ret = driver->initOne(device, currId);
                         
-                        if (ret)
-                                device->driver = NULL;
+                        if (!ret)
+                                PciLinkDriver(device, driver);
                                 
                         return ret;
@@ -298 +390 @@
 {
         struct PciDevice* curr;
-
+                
         ListForEachEntry(curr, &bus->deviceList, next)
         {
                 int ret;
+                
+                /* If we've already attached a driver to this device, don't bother
+                 * scanning it again.
+                 */
+                if (curr->driver)
+                        continue;
 
                 ret=PciAttachDriverOne(bus, curr, driver);
@@ -340 +438 @@
 int PciInit()
 {
+        struct Thread* thread;
         int type=PciCheckConfig();      
 
@@ -370 +469 @@
         }
 
-        /* Scan the first bus initially. We may scan other buses as a result. */
+        KeBusTypeRegister(&pciBusType);
+        
         PciScanBus(0);
 
-        /* Add devices to IcFs */
-
         return 0;
 }