Changeset 679 for GPL/trunk/lib32/pci.c

Timestamp:

Mar 18, 2021, 8:57:36 PM (4 years ago)

Author:

David Azarewicz

Message:

Merge changes from Paul's uniaud32next branch.

Location:

GPL/trunk

Files:

• . (modified) (1 prop)
• lib32/pci.c (modified) (17 diffs)

GPL/trunk/lib32/pci.c

@@ -25 +25 @@
  *
  */
-
+#define CONFIG_PM
 #include "linux.h"
 #include <linux/init.h>
 #include <linux/poll.h>
+#include <linux/dma-mapping.h>
 #include <asm/uaccess.h>
 #include <asm/hardirq.h>
@@ -183 +184 @@
         memset((void near *)pcidev, 0, sizeof(struct pci_dev));
 
-        pcidev->_class = ulTmp2;
+        pcidev->class = ulTmp2;
         pcidev->vendor = detectedId & 0xffff;
         pcidev->device = detectedId >> 16;
@@ -201 +202 @@
         pcidev->sibling = NULL;
         pcidev->next = NULL;
-        pcidev->dma_mask = 0xFFFFFFFF;
+        pcidev->dma_mask = 0xffffffff;
+        pcidev->dev.dma_mask = &pcidev->dma_mask;
+        pcidev->dev.coherent_dma_mask = 0xffffffffull;
 
         // Subsystem ID
         pci_read_config_word(pcidev, PCI_SUBSYSTEM_VENDOR_ID, &pcidev->subsystem_vendor);
         pci_read_config_word(pcidev, PCI_SUBSYSTEM_ID, &pcidev->subsystem_device);
+
+        // revision
+        pci_read_config_byte(pcidev, PCI_REVISION_ID, &pcidev->revision);
 
         // I/O  and MEM
@@ -296 +302 @@
   if(a->flags & IORESOURCE_MEM) {
     if(RMRequestMem(/*hResMgr,*/ start, n) == FALSE) {
-      printk("RMRequestIO failed for io %x, length %x\n", start, n);
+      printk("RMRequestIO failed for mem %x length %x\n", start, n);
       return NULL;
     }
@@ -302 +308 @@
   else if(a->flags & IORESOURCE_IO) {
     if(RMRequestIO(/*hResMgr,*/ start, n) == FALSE) {
-      printk("RMRequestIO failed for io %x, length %x\n", start, n);
+      printk("RMRequestIO failed for io %x length %x\n", start, n);
       return NULL;
     }
@@ -477 +483 @@
   struct pci_dev *pcidev;
   struct pci_device_id IdTable;
+  USHORT usVendor, usDevice;
   int iAdapter = 0;
 
@@ -499 +506 @@
     int iTableIx;
 
-    rprintf(("pci_register_driver: query_device found %x %x:%x class=%x checking %s",
-      ulLast, pcidev->vendor, pcidev->device, pcidev->_class, driver->name));
+    rprintf((__func__": query_device found %x %04x:%04x class=%x checking %s",
+      ulLast, pcidev->vendor, pcidev->device, pcidev->class, driver->name));
+
+    usVendor = 0;
+    usDevice = 0;
 
     for( iTableIx = 0; driver->id_table[iTableIx].vendor; iTableIx++)
@@ -506 +516 @@
       struct pci_device_id const *pDriverId = &driver->id_table[iTableIx];
 
-      if ( (pDriverId->class) && ((pcidev->_class & pDriverId->class_mask) != pDriverId->class) ) continue;
+      if ( (pDriverId->class) && ((pcidev->class & pDriverId->class_mask) != pDriverId->class) ) continue;
       if (pDriverId->vendor != pcidev->vendor) continue;
       if ( (pDriverId->device != PCI_ANY_ID) && (pDriverId->device != pcidev->device) ) continue;
 
-      rprintf(("pci_register_driver: matched %d %x:%x/%x with %x:%x/%x %x (%s)", iTableIx,
-        pcidev->vendor, pcidev->device, pcidev->_class,
+      /* skip a duplicate device that could be matched by both and exact match and a class match */
+      if (usVendor == pcidev->vendor && usDevice == pcidev->device) continue;
+      usVendor = pcidev->vendor;
+      usDevice = pcidev->device;
+
+      rprintf((__func__": matched %d %x:%x/%x with %x:%x/%x %x (%s)", iTableIx,
+        pcidev->vendor, pcidev->device, pcidev->class,
         pDriverId->vendor, pDriverId->device, pDriverId->class, pDriverId->class_mask, driver->name));
 
       if ((iAdapterNumber >= 0) && (iAdapter < iAdapterNumber))
       {
+        rprintf((__func__": AdapterNumber=%x skipping Adapter=%x", iAdapterNumber, iAdapter));
         iAdapter++;
         continue;
       }
 
-      RMInit();
       if (driver->probe(pcidev, pDriverId) == 0)
       {
@@ -527 +542 @@
 
         // create adapter
-        RMDone((pcidev->device << 16) | pcidev->vendor, &pcidev->hAdapter, &pcidev->hDevice);
+        RMCreateAdapterU32((pcidev->device << 16) | pcidev->vendor, &pcidev->hAdapter, ulLast, iNumCards);
+
         iNumCards++;
         pcidev = NULL; /* we need a new slot */
         break;
       }
-      RMDone(0, 0, 0);
+      // release resources which were possibly allocated during probe() 
+      RMDeallocRes();
     } /* for id_table loop */
 
@@ -647 +664 @@
     //try not to exhaust low memory (< 16mb) so allocate from the high region first
     //if that doesn't satisfy the dma mask requirement, then get it from the low
-    //regino anyway
+    //region anyway
     if(hwdev->dma_mask > 0x00ffffff) {
       order = __compat_get_order(size);
@@ -666 +683 @@
     ret = (void *)__get_free_pages(gfp, __compat_get_order(size));
   }
-
   if (ret != NULL) {
     memset(ret, 0, size);
@@ -672 +688 @@
   }
   return ret;
+}
+
+#if 0
+void *pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
+                      dma_addr_t *dma_handle)
+ {
+         return dma_alloc_coherent(hwdev == NULL ? NULL : &hwdev->dev, size, dma_handle, GFP_ATOMIC);
+ }
+#endif
+#if 0
+void *dma_alloc_coherent(struct device *dev, size_t size,
+                                dma_addr_t *dma_handle, gfp_t gfp)
+{
+  void *ret = NULL;
+  int order;
+
+  dprintf(("dma_alloc_coherent %d mask %x", size, (dev) ? dev->dma_mask : 0));
+  if (dev == NULL || *dev->dma_mask != 0xffffffff) {
+  dprintf(("dma_alloc_coherent"));
+    //try not to exhaust low memory (< 16mb) so allocate from the high region first
+    //if that doesn't satisfy the dma mask requirement, then get it from the low
+    //region anyway
+    if(*dev->dma_mask > 0x00ffffff) {
+  dprintf(("dma_alloc_coherent2"));
+      order = __compat_get_order(size);
+      ret = (void *)__get_free_pages(gfp|GFP_DMAHIGHMEM, order);
+      *dma_handle = virt_to_bus(ret);
+      if(*dma_handle > *dev->dma_mask) {
+  dprintf(("dma_alloc_coherent3"));
+        free_pages((unsigned long)ret, __compat_get_order(size));
+        //be sure and allocate below 16 mb
+        gfp |= GFP_DMA;
+        ret = NULL;
+      }
+  dprintf(("dma_alloc_coherent3a"));
+    }
+    else { //must always allocate below 16 mb
+  dprintf(("dma_alloc_coherent4"));
+      gfp |= GFP_DMA;
+    }
+  }
+  if(ret == NULL) {
+  dprintf(("dma_alloc_coherent5"));
+    ret = (void *)__get_free_pages(gfp, __compat_get_order(size));
+  }
+
+  if (ret != NULL) {
+    memset(ret, 0, size);
+    *dma_handle = virt_to_bus(ret);
+  }
+  return ret;
+
+}
+#endif
+
+int dma_supported(struct device *dev, u64 mask)
+{
+  return 1;
+}
+
+int dma_set_coherent_mask(struct device *dev, u64 mask)
+{
+        /*
+         * Truncate the mask to the actually supported dma_addr_t width to
+         * avoid generating unsupportable addresses.
+         */
+        mask = (dma_addr_t)mask;
+
+        if (!dma_supported(dev, mask))
+                return -EIO;
+
+        dev->coherent_dma_mask = mask;
+        return 0;
+}
+
+int dma_set_mask(struct device *dev, u64 mask)
+{
+        /*
+         * Truncate the mask to the actually supported dma_addr_t width to
+         * avoid generating unsupportable addresses.
+         */
+        mask = (dma_addr_t)mask;
+
+        if (!dev->dma_mask || !dma_supported(dev, mask))
+                return -EIO;
+
+        *dev->dma_mask = mask;
+        return 0;
 }
 
@@ -888 +992 @@
 }
 
-const struct pci_device_id * pci_match_device(const struct pci_device_id *ids, struct pci_dev *dev)
+const struct pci_device_id * pci_match_id(const struct pci_device_id *ids, struct pci_dev *dev)
 {
   u16 subsystem_vendor, subsystem_device;
@@ -900 +1004 @@
       (ids->subvendor == PCI_ANY_ID || ids->subvendor == subsystem_vendor) &&
       (ids->subdevice == PCI_ANY_ID || ids->subdevice == subsystem_device) &&
-      !((ids->class ^ dev->_class) & ids->class_mask))
+      !((ids->class ^ dev->class) & ids->class_mask))
       return ids;
     ids++;
@@ -981 +1085 @@
     if(pci_devices[i].devfn)
     {
-      RMSetHandles(pci_devices[i].hAdapter, pci_devices[i].hDevice); /* DAZ - dirty hack */
+      RMSetHandles(pci_devices[i].hAdapter); /* DAZ - dirty hack */
       driver = pci_devices[i].pcidriver;
       if(driver && driver->resume) {
@@ -1004 +1108 @@
     if(pci_devices[i].devfn)
     {
-      RMSetHandles(pci_devices[i].hAdapter, pci_devices[i].hDevice); /* DAZ - dirty hack */
+      RMSetHandles(pci_devices[i].hAdapter); /* DAZ - dirty hack */
       driver = pci_devices[i].pcidriver;
       if(driver && driver->suspend) {
@@ -1040 +1144 @@
 #endif
 
+/**
+ * pci_status_get_and_clear_errors - return and clear error bits in PCI_STATUS
+ * @pdev: the PCI device
+ *
+ * Returns error bits set in PCI_STATUS and clears them.
+ */
+int pci_status_get_and_clear_errors(struct pci_dev *pdev)
+{
+        u16 status;
+        int ret;
+
+        ret = pci_read_config_word(pdev, PCI_STATUS, &status);
+        if (ret != PCIBIOS_SUCCESSFUL)
+                return -EIO;
+
+        status &= PCI_STATUS_ERROR_BITS;
+        if (status)
+                pci_write_config_word(pdev, PCI_STATUS, status);
+
+        return status;
+}
+