Subversion Repositories Kolibri OS

Rev

Rev 3764 | Rev 5271 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1.  
  2. #include <linux/kernel.h>
  3. #include <linux/types.h>
  4. #include <linux/export.h>
  5. #include <linux/mutex.h>
  6. #include <linux/mod_devicetable.h>
  7. #include <errno-base.h>
  8. #include <pci.h>
  9. #include <syscall.h>
  10.  
  11. static inline __attribute__((const))
  12. bool is_power_of_2(unsigned long n)
  13. {
  14.     return (n != 0 && ((n & (n - 1)) == 0));
  15. }
  16.  
  17. extern int pci_scan_filter(u32_t id, u32_t busnr, u32_t devfn);
  18.  
  19. static LIST_HEAD(devices);
  20.  
  21. /* PCI control bits.  Shares IORESOURCE_BITS with above PCI ROM.  */
  22. #define IORESOURCE_PCI_FIXED            (1<<4)  /* Do not move resource */
  23.  
  24. #define LEGACY_IO_RESOURCE      (IORESOURCE_IO | IORESOURCE_PCI_FIXED)
  25.  
  26. /*
  27.  * Translate the low bits of the PCI base
  28.  * to the resource type
  29.  */
  30. static inline unsigned int pci_calc_resource_flags(unsigned int flags)
  31. {
  32.     if (flags & PCI_BASE_ADDRESS_SPACE_IO)
  33.         return IORESOURCE_IO;
  34.  
  35.     if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
  36.         return IORESOURCE_MEM | IORESOURCE_PREFETCH;
  37.  
  38.     return IORESOURCE_MEM;
  39. }
  40.  
  41.  
  42. static u32_t pci_size(u32_t base, u32_t maxbase, u32_t mask)
  43. {
  44.     u32_t size = mask & maxbase;      /* Find the significant bits */
  45.  
  46.     if (!size)
  47.         return 0;
  48.  
  49.     /* Get the lowest of them to find the decode size, and
  50.        from that the extent.  */
  51.     size = (size & ~(size-1)) - 1;
  52.  
  53.     /* base == maxbase can be valid only if the BAR has
  54.        already been programmed with all 1s.  */
  55.     if (base == maxbase && ((base | size) & mask) != mask)
  56.         return 0;
  57.  
  58.     return size;
  59. }
  60.  
  61. static u64_t pci_size64(u64_t base, u64_t maxbase, u64_t mask)
  62. {
  63.     u64_t size = mask & maxbase;      /* Find the significant bits */
  64.  
  65.     if (!size)
  66.         return 0;
  67.  
  68.     /* Get the lowest of them to find the decode size, and
  69.        from that the extent.  */
  70.     size = (size & ~(size-1)) - 1;
  71.  
  72.     /* base == maxbase can be valid only if the BAR has
  73.        already been programmed with all 1s.  */
  74.     if (base == maxbase && ((base | size) & mask) != mask)
  75.         return 0;
  76.  
  77.     return size;
  78. }
  79.  
  80. static inline int is_64bit_memory(u32_t mask)
  81. {
  82.     if ((mask & (PCI_BASE_ADDRESS_SPACE|PCI_BASE_ADDRESS_MEM_TYPE_MASK)) ==
  83.         (PCI_BASE_ADDRESS_SPACE_MEMORY|PCI_BASE_ADDRESS_MEM_TYPE_64))
  84.         return 1;
  85.     return 0;
  86. }
  87.  
  88. static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
  89. {
  90.     u32_t  pos, reg, next;
  91.     u32_t  l, sz;
  92.     struct resource *res;
  93.  
  94.     for(pos=0; pos < howmany; pos = next)
  95.     {
  96.         u64_t  l64;
  97.         u64_t  sz64;
  98.         u32_t  raw_sz;
  99.  
  100.         next = pos + 1;
  101.  
  102.         res  = &dev->resource[pos];
  103.  
  104.         reg = PCI_BASE_ADDRESS_0 + (pos << 2);
  105.         l = PciRead32(dev->busnr, dev->devfn, reg);
  106.         PciWrite32(dev->busnr, dev->devfn, reg, ~0);
  107.         sz = PciRead32(dev->busnr, dev->devfn, reg);
  108.         PciWrite32(dev->busnr, dev->devfn, reg, l);
  109.  
  110.         if (!sz || sz == 0xffffffff)
  111.             continue;
  112.  
  113.         if (l == 0xffffffff)
  114.             l = 0;
  115.  
  116.         raw_sz = sz;
  117.         if ((l & PCI_BASE_ADDRESS_SPACE) ==
  118.                         PCI_BASE_ADDRESS_SPACE_MEMORY)
  119.         {
  120.             sz = pci_size(l, sz, (u32_t)PCI_BASE_ADDRESS_MEM_MASK);
  121.             /*
  122.              * For 64bit prefetchable memory sz could be 0, if the
  123.              * real size is bigger than 4G, so we need to check
  124.              * szhi for that.
  125.              */
  126.             if (!is_64bit_memory(l) && !sz)
  127.                     continue;
  128.             res->start = l & PCI_BASE_ADDRESS_MEM_MASK;
  129.             res->flags |= l & ~PCI_BASE_ADDRESS_MEM_MASK;
  130.         }
  131.         else {
  132.             sz = pci_size(l, sz, PCI_BASE_ADDRESS_IO_MASK & 0xffff);
  133.             if (!sz)
  134.                 continue;
  135.             res->start = l & PCI_BASE_ADDRESS_IO_MASK;
  136.             res->flags |= l & ~PCI_BASE_ADDRESS_IO_MASK;
  137.         }
  138.         res->end = res->start + (unsigned long) sz;
  139.         res->flags |= pci_calc_resource_flags(l);
  140.         if (is_64bit_memory(l))
  141.         {
  142.             u32_t szhi, lhi;
  143.  
  144.             lhi = PciRead32(dev->busnr, dev->devfn, reg+4);
  145.             PciWrite32(dev->busnr, dev->devfn, reg+4, ~0);
  146.             szhi = PciRead32(dev->busnr, dev->devfn, reg+4);
  147.             PciWrite32(dev->busnr, dev->devfn, reg+4, lhi);
  148.             sz64 = ((u64_t)szhi << 32) | raw_sz;
  149.             l64 = ((u64_t)lhi << 32) | l;
  150.             sz64 = pci_size64(l64, sz64, PCI_BASE_ADDRESS_MEM_MASK);
  151.             next++;
  152.  
  153. #if BITS_PER_LONG == 64
  154.             if (!sz64) {
  155.                 res->start = 0;
  156.                 res->end = 0;
  157.                 res->flags = 0;
  158.                 continue;
  159.             }
  160.             res->start = l64 & PCI_BASE_ADDRESS_MEM_MASK;
  161.             res->end = res->start + sz64;
  162. #else
  163.             if (sz64 > 0x100000000ULL) {
  164.                 printk(KERN_ERR "PCI: Unable to handle 64-bit "
  165.                                 "BAR for device %s\n", pci_name(dev));
  166.                 res->start = 0;
  167.                 res->flags = 0;
  168.             }
  169.             else if (lhi)
  170.             {
  171.                 /* 64-bit wide address, treat as disabled */
  172.                 PciWrite32(dev->busnr, dev->devfn, reg,
  173.                         l & ~(u32_t)PCI_BASE_ADDRESS_MEM_MASK);
  174.                 PciWrite32(dev->busnr, dev->devfn, reg+4, 0);
  175.                 res->start = 0;
  176.                 res->end = sz;
  177.             }
  178. #endif
  179.         }
  180.     }
  181.  
  182.     if ( rom )
  183.     {
  184.         dev->rom_base_reg = rom;
  185.         res = &dev->resource[PCI_ROM_RESOURCE];
  186.  
  187.         l = PciRead32(dev->busnr, dev->devfn, rom);
  188.         PciWrite32(dev->busnr, dev->devfn, rom, ~PCI_ROM_ADDRESS_ENABLE);
  189.         sz = PciRead32(dev->busnr, dev->devfn, rom);
  190.         PciWrite32(dev->busnr, dev->devfn, rom, l);
  191.  
  192.         if (l == 0xffffffff)
  193.             l = 0;
  194.  
  195.         if (sz && sz != 0xffffffff)
  196.         {
  197.             sz = pci_size(l, sz, (u32_t)PCI_ROM_ADDRESS_MASK);
  198.  
  199.             if (sz)
  200.             {
  201.                 res->flags = (l & IORESOURCE_ROM_ENABLE) |
  202.                                   IORESOURCE_MEM | IORESOURCE_PREFETCH |
  203.                                   IORESOURCE_READONLY | IORESOURCE_CACHEABLE;
  204.                 res->start = l & PCI_ROM_ADDRESS_MASK;
  205.                 res->end = res->start + (unsigned long) sz;
  206.             }
  207.         }
  208.     }
  209. }
  210.  
  211. static void pci_read_irq(struct pci_dev *dev)
  212. {
  213.     u8_t irq;
  214.  
  215.     irq = PciRead8(dev->busnr, dev->devfn, PCI_INTERRUPT_PIN);
  216.     dev->pin = irq;
  217.     if (irq)
  218.         irq = PciRead8(dev->busnr, dev->devfn, PCI_INTERRUPT_LINE);
  219.     dev->irq = irq;
  220. };
  221.  
  222.  
  223. int pci_setup_device(struct pci_dev *dev)
  224. {
  225.     u32_t  class;
  226.  
  227.     class = PciRead32(dev->busnr, dev->devfn, PCI_CLASS_REVISION);
  228.     dev->revision = class & 0xff;
  229.     class >>= 8;                                /* upper 3 bytes */
  230.     dev->class = class;
  231.  
  232.     /* "Unknown power state" */
  233. //    dev->current_state = PCI_UNKNOWN;
  234.  
  235.     /* Early fixups, before probing the BARs */
  236.  //   pci_fixup_device(pci_fixup_early, dev);
  237.     class = dev->class >> 8;
  238.  
  239.     switch (dev->hdr_type)
  240.     {
  241.         case PCI_HEADER_TYPE_NORMAL:                /* standard header */
  242.             if (class == PCI_CLASS_BRIDGE_PCI)
  243.                 goto bad;
  244.             pci_read_irq(dev);
  245.             pci_read_bases(dev, 6, PCI_ROM_ADDRESS);
  246.             dev->subsystem_vendor = PciRead16(dev->busnr, dev->devfn,PCI_SUBSYSTEM_VENDOR_ID);
  247.             dev->subsystem_device = PciRead16(dev->busnr, dev->devfn, PCI_SUBSYSTEM_ID);
  248.  
  249.             /*
  250.              *      Do the ugly legacy mode stuff here rather than broken chip
  251.              *      quirk code. Legacy mode ATA controllers have fixed
  252.              *      addresses. These are not always echoed in BAR0-3, and
  253.              *      BAR0-3 in a few cases contain junk!
  254.              */
  255.             if (class == PCI_CLASS_STORAGE_IDE)
  256.             {
  257.                 u8_t progif;
  258.  
  259.                 progif = PciRead8(dev->busnr, dev->devfn,PCI_CLASS_PROG);
  260.                 if ((progif & 1) == 0)
  261.                 {
  262.                     dev->resource[0].start = 0x1F0;
  263.                     dev->resource[0].end = 0x1F7;
  264.                     dev->resource[0].flags = LEGACY_IO_RESOURCE;
  265.                     dev->resource[1].start = 0x3F6;
  266.                     dev->resource[1].end = 0x3F6;
  267.                     dev->resource[1].flags = LEGACY_IO_RESOURCE;
  268.                 }
  269.                 if ((progif & 4) == 0)
  270.                 {
  271.                     dev->resource[2].start = 0x170;
  272.                     dev->resource[2].end = 0x177;
  273.                     dev->resource[2].flags = LEGACY_IO_RESOURCE;
  274.                     dev->resource[3].start = 0x376;
  275.                     dev->resource[3].end = 0x376;
  276.                     dev->resource[3].flags = LEGACY_IO_RESOURCE;
  277.                 };
  278.             }
  279.             break;
  280.  
  281.         case PCI_HEADER_TYPE_BRIDGE:                /* bridge header */
  282.                 if (class != PCI_CLASS_BRIDGE_PCI)
  283.                         goto bad;
  284.                 /* The PCI-to-PCI bridge spec requires that subtractive
  285.                    decoding (i.e. transparent) bridge must have programming
  286.                    interface code of 0x01. */
  287.                 pci_read_irq(dev);
  288.                 dev->transparent = ((dev->class & 0xff) == 1);
  289.                 pci_read_bases(dev, 2, PCI_ROM_ADDRESS1);
  290.                 break;
  291.  
  292.         case PCI_HEADER_TYPE_CARDBUS:               /* CardBus bridge header */
  293.                 if (class != PCI_CLASS_BRIDGE_CARDBUS)
  294.                         goto bad;
  295.                 pci_read_irq(dev);
  296.                 pci_read_bases(dev, 1, 0);
  297.                 dev->subsystem_vendor = PciRead16(dev->busnr,
  298.                                                   dev->devfn,
  299.                                                   PCI_CB_SUBSYSTEM_VENDOR_ID);
  300.  
  301.                 dev->subsystem_device = PciRead16(dev->busnr,
  302.                                                   dev->devfn,
  303.                                                   PCI_CB_SUBSYSTEM_ID);
  304.                 break;
  305.  
  306.         default:                                    /* unknown header */
  307.                 printk(KERN_ERR "PCI: device %s has unknown header type %02x, ignoring.\n",
  308.                         pci_name(dev), dev->hdr_type);
  309.                 return -1;
  310.  
  311.         bad:
  312.                 printk(KERN_ERR "PCI: %s: class %x doesn't match header type %02x. Ignoring class.\n",
  313.                        pci_name(dev), class, dev->hdr_type);
  314.                 dev->class = PCI_CLASS_NOT_DEFINED;
  315.     }
  316.  
  317.     /* We found a fine healthy device, go go go... */
  318.  
  319.     return 0;
  320. };
  321.  
  322. static pci_dev_t* pci_scan_device(u32_t busnr, int devfn)
  323. {
  324.     pci_dev_t  *dev;
  325.  
  326.     u32_t   id;
  327.     u8_t    hdr;
  328.  
  329.     int     timeout = 10;
  330.  
  331.     id = PciRead32(busnr, devfn, PCI_VENDOR_ID);
  332.  
  333.     /* some broken boards return 0 or ~0 if a slot is empty: */
  334.     if (id == 0xffffffff || id == 0x00000000 ||
  335.         id == 0x0000ffff || id == 0xffff0000)
  336.         return NULL;
  337.  
  338.     while (id == 0xffff0001)
  339.     {
  340.  
  341.         delay(timeout/10);
  342.         timeout *= 2;
  343.  
  344.         id = PciRead32(busnr, devfn, PCI_VENDOR_ID);
  345.  
  346.         /* Card hasn't responded in 60 seconds?  Must be stuck. */
  347.         if (timeout > 60 * 100)
  348.         {
  349.             printk(KERN_WARNING "Device %04x:%02x:%02x.%d not "
  350.                    "responding\n", busnr,PCI_SLOT(devfn),PCI_FUNC(devfn));
  351.             return NULL;
  352.         }
  353.     };
  354.  
  355.     if( pci_scan_filter(id, busnr, devfn) == 0)
  356.         return NULL;
  357.  
  358.     hdr = PciRead8(busnr, devfn, PCI_HEADER_TYPE);
  359.  
  360.     dev = (pci_dev_t*)kzalloc(sizeof(pci_dev_t), 0);
  361.     if(unlikely(dev == NULL))
  362.         return NULL;
  363.  
  364.     INIT_LIST_HEAD(&dev->link);
  365.  
  366.  
  367.     dev->pci_dev.busnr    = busnr;
  368.     dev->pci_dev.devfn    = devfn;
  369.     dev->pci_dev.hdr_type = hdr & 0x7f;
  370.     dev->pci_dev.multifunction    = !!(hdr & 0x80);
  371.     dev->pci_dev.vendor   = id & 0xffff;
  372.     dev->pci_dev.device   = (id >> 16) & 0xffff;
  373.  
  374.     pci_setup_device(&dev->pci_dev);
  375.  
  376.     return dev;
  377.  
  378. };
  379.  
  380.  
  381.  
  382.  
  383. int pci_scan_slot(u32_t bus, int devfn)
  384. {
  385.     int  func, nr = 0;
  386.  
  387.     for (func = 0; func < 8; func++, devfn++)
  388.     {
  389.         pci_dev_t  *dev;
  390.  
  391.         dev = pci_scan_device(bus, devfn);
  392.         if( dev )
  393.         {
  394.             list_add(&dev->link, &devices);
  395.  
  396.             nr++;
  397.  
  398.             /*
  399.              * If this is a single function device,
  400.              * don't scan past the first function.
  401.              */
  402.             if (!dev->pci_dev.multifunction)
  403.             {
  404.                 if (func > 0) {
  405.                     dev->pci_dev.multifunction = 1;
  406.                 }
  407.                 else {
  408.                     break;
  409.                 }
  410.              }
  411.         }
  412.         else {
  413.             if (func == 0)
  414.                 break;
  415.         }
  416.     };
  417.  
  418.     return nr;
  419. };
  420.  
  421. #define PCI_FIND_CAP_TTL    48
  422.  
  423. static int __pci_find_next_cap_ttl(unsigned int bus, unsigned int devfn,
  424.                    u8 pos, int cap, int *ttl)
  425. {
  426.     u8 id;
  427.  
  428.     while ((*ttl)--) {
  429.         pos = PciRead8(bus, devfn, pos);
  430.         if (pos < 0x40)
  431.             break;
  432.         pos &= ~3;
  433.         id = PciRead8(bus, devfn, pos + PCI_CAP_LIST_ID);
  434.         if (id == 0xff)
  435.             break;
  436.         if (id == cap)
  437.             return pos;
  438.         pos += PCI_CAP_LIST_NEXT;
  439.     }
  440.     return 0;
  441. }
  442.  
  443. static int __pci_find_next_cap(unsigned int bus, unsigned int devfn,
  444.                    u8 pos, int cap)
  445. {
  446.     int ttl = PCI_FIND_CAP_TTL;
  447.  
  448.     return __pci_find_next_cap_ttl(bus, devfn, pos, cap, &ttl);
  449. }
  450.  
  451. static int __pci_bus_find_cap_start(unsigned int bus,
  452.                     unsigned int devfn, u8 hdr_type)
  453. {
  454.     u16 status;
  455.  
  456.     status = PciRead16(bus, devfn, PCI_STATUS);
  457.     if (!(status & PCI_STATUS_CAP_LIST))
  458.         return 0;
  459.  
  460.     switch (hdr_type) {
  461.     case PCI_HEADER_TYPE_NORMAL:
  462.     case PCI_HEADER_TYPE_BRIDGE:
  463.         return PCI_CAPABILITY_LIST;
  464.     case PCI_HEADER_TYPE_CARDBUS:
  465.         return PCI_CB_CAPABILITY_LIST;
  466.     default:
  467.         return 0;
  468.     }
  469.  
  470.     return 0;
  471. }
  472.  
  473.  
  474. int pci_find_capability(struct pci_dev *dev, int cap)
  475. {
  476.     int pos;
  477.  
  478.     pos = __pci_bus_find_cap_start(dev->busnr, dev->devfn, dev->hdr_type);
  479.     if (pos)
  480.         pos = __pci_find_next_cap(dev->busnr, dev->devfn, pos, cap);
  481.  
  482.     return pos;
  483. }
  484.  
  485.  
  486.  
  487.  
  488. int enum_pci_devices()
  489. {
  490.     pci_dev_t  *dev;
  491.     u32_t       last_bus;
  492.     u32_t       bus = 0 , devfn = 0;
  493.  
  494.  
  495.     last_bus = PciApi(1);
  496.  
  497.  
  498.     if( unlikely(last_bus == -1))
  499.         return -1;
  500.  
  501.     for(;bus <= last_bus; bus++)
  502.     {
  503.         for (devfn = 0; devfn < 0x100; devfn += 8)
  504.             pci_scan_slot(bus, devfn);
  505.  
  506.  
  507.     }
  508.     for(dev = (pci_dev_t*)devices.next;
  509.         &dev->link != &devices;
  510.         dev = (pci_dev_t*)dev->link.next)
  511.     {
  512.         dbgprintf("PCI device %x:%x bus:%x devfn:%x\n",
  513.                 dev->pci_dev.vendor,
  514.                 dev->pci_dev.device,
  515.                 dev->pci_dev.busnr,
  516.                 dev->pci_dev.devfn);
  517.  
  518.     }
  519.     return 0;
  520. }
  521.  
  522. const struct pci_device_id* find_pci_device(pci_dev_t* pdev, const struct pci_device_id *idlist)
  523. {
  524.     pci_dev_t *dev;
  525.     const struct pci_device_id *ent;
  526.  
  527.     for(dev = (pci_dev_t*)devices.next;
  528.         &dev->link != &devices;
  529.         dev = (pci_dev_t*)dev->link.next)
  530.     {
  531.         if( dev->pci_dev.vendor != idlist->vendor )
  532.             continue;
  533.  
  534.         for(ent = idlist; ent->vendor != 0; ent++)
  535.         {
  536.             if(unlikely(ent->device == dev->pci_dev.device))
  537.             {
  538.                 pdev->pci_dev = dev->pci_dev;
  539.                 return  ent;
  540.             }
  541.         };
  542.     }
  543.  
  544.     return NULL;
  545. };
  546.  
  547. struct pci_dev *
  548. pci_get_device(unsigned int vendor, unsigned int device, struct pci_dev *from)
  549. {
  550.     pci_dev_t *dev;
  551.  
  552.     dev = (pci_dev_t*)devices.next;
  553.  
  554.     if(from != NULL)
  555.     {
  556.         for(; &dev->link != &devices;
  557.             dev = (pci_dev_t*)dev->link.next)
  558.         {
  559.             if( &dev->pci_dev == from)
  560.             {
  561.                 dev = (pci_dev_t*)dev->link.next;
  562.                 break;
  563.             };
  564.         }
  565.     };
  566.  
  567.     for(; &dev->link != &devices;
  568.         dev = (pci_dev_t*)dev->link.next)
  569.     {
  570.         if( dev->pci_dev.vendor != vendor )
  571.                 continue;
  572.  
  573.         if(dev->pci_dev.device == device)
  574.         {
  575.             return &dev->pci_dev;
  576.         }
  577.     }
  578.     return NULL;
  579. };
  580.  
  581.  
  582. struct pci_dev * pci_get_bus_and_slot(unsigned int bus, unsigned int devfn)
  583. {
  584.     pci_dev_t *dev;
  585.  
  586.     for(dev = (pci_dev_t*)devices.next;
  587.         &dev->link != &devices;
  588.         dev = (pci_dev_t*)dev->link.next)
  589.     {
  590.         if ( dev->pci_dev.busnr == bus && dev->pci_dev.devfn == devfn)
  591.             return &dev->pci_dev;
  592.     }
  593.     return NULL;
  594. }
  595.  
  596. struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from)
  597. {
  598.     pci_dev_t *dev;
  599.  
  600.     dev = (pci_dev_t*)devices.next;
  601.  
  602.     if(from != NULL)
  603.     {
  604.         for(; &dev->link != &devices;
  605.             dev = (pci_dev_t*)dev->link.next)
  606.         {
  607.             if( &dev->pci_dev == from)
  608.             {
  609.                 dev = (pci_dev_t*)dev->link.next;
  610.                 break;
  611.             };
  612.         }
  613.     };
  614.  
  615.     for(; &dev->link != &devices;
  616.         dev = (pci_dev_t*)dev->link.next)
  617.     {
  618.         if( dev->pci_dev.class == class)
  619.         {
  620.             return &dev->pci_dev;
  621.         }
  622.     }
  623.  
  624.    return NULL;
  625. }
  626.  
  627.  
  628. #define PIO_OFFSET      0x10000UL
  629. #define PIO_MASK        0x0ffffUL
  630. #define PIO_RESERVED    0x40000UL
  631.  
  632. #define IO_COND(addr, is_pio, is_mmio) do {            \
  633.     unsigned long port = (unsigned long __force)addr;  \
  634.     if (port >= PIO_RESERVED) {                        \
  635.         is_mmio;                                       \
  636.     } else if (port > PIO_OFFSET) {                    \
  637.         port &= PIO_MASK;                              \
  638.         is_pio;                                        \
  639.     };                                                 \
  640. } while (0)
  641.  
  642. /* Create a virtual mapping cookie for an IO port range */
  643. void __iomem *ioport_map(unsigned long port, unsigned int nr)
  644. {
  645.     if (port > PIO_MASK)
  646.         return NULL;
  647.     return (void __iomem *) (unsigned long) (port + PIO_OFFSET);
  648. }
  649.  
  650. void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen)
  651. {
  652.     resource_size_t start = pci_resource_start(dev, bar);
  653.     resource_size_t len = pci_resource_len(dev, bar);
  654.     unsigned long flags = pci_resource_flags(dev, bar);
  655.  
  656.     if (!len || !start)
  657.         return NULL;
  658.     if (maxlen && len > maxlen)
  659.         len = maxlen;
  660.     if (flags & IORESOURCE_IO)
  661.         return ioport_map(start, len);
  662.     if (flags & IORESOURCE_MEM) {
  663.         return ioremap(start, len);
  664.     }
  665.     /* What? */
  666.     return NULL;
  667. }
  668.  
  669. void pci_iounmap(struct pci_dev *dev, void __iomem * addr)
  670. {
  671.     IO_COND(addr, /* nothing */, iounmap(addr));
  672. }
  673.  
  674.  
  675. struct pci_bus_region {
  676.     resource_size_t start;
  677.     resource_size_t end;
  678. };
  679.  
  680. static inline void
  681. pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
  682.                          struct resource *res)
  683. {
  684.     region->start = res->start;
  685.     region->end = res->end;
  686. }
  687.  
  688.  
  689. int pci_enable_rom(struct pci_dev *pdev)
  690. {
  691.     struct resource *res = pdev->resource + PCI_ROM_RESOURCE;
  692.     struct pci_bus_region region;
  693.     u32 rom_addr;
  694.  
  695.     if (!res->flags)
  696.             return -1;
  697.  
  698.     pcibios_resource_to_bus(pdev, &region, res);
  699.     pci_read_config_dword(pdev, pdev->rom_base_reg, &rom_addr);
  700.     rom_addr &= ~PCI_ROM_ADDRESS_MASK;
  701.     rom_addr |= region.start | PCI_ROM_ADDRESS_ENABLE;
  702.     pci_write_config_dword(pdev, pdev->rom_base_reg, rom_addr);
  703.     return 0;
  704. }
  705.  
  706. void pci_disable_rom(struct pci_dev *pdev)
  707. {
  708.     u32 rom_addr;
  709.     pci_read_config_dword(pdev, pdev->rom_base_reg, &rom_addr);
  710.     rom_addr &= ~PCI_ROM_ADDRESS_ENABLE;
  711.     pci_write_config_dword(pdev, pdev->rom_base_reg, rom_addr);
  712. }
  713.  
  714. /**
  715.  * pci_get_rom_size - obtain the actual size of the ROM image
  716.  * @pdev: target PCI device
  717.  * @rom: kernel virtual pointer to image of ROM
  718.  * @size: size of PCI window
  719.  *  return: size of actual ROM image
  720.  *
  721.  * Determine the actual length of the ROM image.
  722.  * The PCI window size could be much larger than the
  723.  * actual image size.
  724.  */
  725. size_t pci_get_rom_size(struct pci_dev *pdev, void __iomem *rom, size_t size)
  726. {
  727.         void __iomem *image;
  728.         int last_image;
  729.  
  730.         image = rom;
  731.         do {
  732.                 void __iomem *pds;
  733.                 /* Standard PCI ROMs start out with these bytes 55 AA */
  734.                 if (readb(image) != 0x55) {
  735.                         dev_err(&pdev->dev, "Invalid ROM contents\n");
  736.                         break;
  737.             }
  738.                 if (readb(image + 1) != 0xAA)
  739.                         break;
  740.                 /* get the PCI data structure and check its signature */
  741.                 pds = image + readw(image + 24);
  742.                 if (readb(pds) != 'P')
  743.                         break;
  744.                 if (readb(pds + 1) != 'C')
  745.                         break;
  746.                 if (readb(pds + 2) != 'I')
  747.                         break;
  748.                 if (readb(pds + 3) != 'R')
  749.                         break;
  750.                 last_image = readb(pds + 21) & 0x80;
  751.                 /* this length is reliable */
  752.                 image += readw(pds + 16) * 512;
  753.         } while (!last_image);
  754.  
  755.         /* never return a size larger than the PCI resource window */
  756.         /* there are known ROMs that get the size wrong */
  757.         return min((size_t)(image - rom), size);
  758. }
  759.  
  760.  
  761. /**
  762.  * pci_map_rom - map a PCI ROM to kernel space
  763.  * @pdev: pointer to pci device struct
  764.  * @size: pointer to receive size of pci window over ROM
  765.  *
  766.  * Return: kernel virtual pointer to image of ROM
  767.  *
  768.  * Map a PCI ROM into kernel space. If ROM is boot video ROM,
  769.  * the shadow BIOS copy will be returned instead of the
  770.  * actual ROM.
  771.  */
  772. void __iomem *pci_map_rom(struct pci_dev *pdev, size_t *size)
  773. {
  774.     struct resource *res = &pdev->resource[PCI_ROM_RESOURCE];
  775.     loff_t start;
  776.     void __iomem *rom;
  777.  
  778. //    ENTER();
  779.  
  780. //    dbgprintf("resource start %x end %x flags %x\n",
  781. //               res->start, res->end, res->flags);
  782.     /*
  783.      * IORESOURCE_ROM_SHADOW set on x86, x86_64 and IA64 supports legacy
  784.      * memory map if the VGA enable bit of the Bridge Control register is
  785.      * set for embedded VGA.
  786.      */
  787.  
  788.     start = (loff_t)0xC0000;
  789.     *size = 0x20000; /* cover C000:0 through E000:0 */
  790.  
  791. #if 0
  792.  
  793.     if (res->flags & IORESOURCE_ROM_SHADOW) {
  794.         /* primary video rom always starts here */
  795.         start = (loff_t)0xC0000;
  796.         *size = 0x20000; /* cover C000:0 through E000:0 */
  797.     } else {
  798.                 if (res->flags &
  799.                         (IORESOURCE_ROM_COPY | IORESOURCE_ROM_BIOS_COPY)) {
  800.             *size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
  801.              return (void __iomem *)(unsigned long)
  802.              pci_resource_start(pdev, PCI_ROM_RESOURCE);
  803.         } else {
  804.                 /* assign the ROM an address if it doesn't have one */
  805. //                        if (res->parent == NULL &&
  806. //                            pci_assign_resource(pdev,PCI_ROM_RESOURCE))
  807.                      return NULL;
  808. //                        start = pci_resource_start(pdev, PCI_ROM_RESOURCE);
  809. //                        *size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
  810. //                        if (*size == 0)
  811. //                                return NULL;
  812.  
  813.              /* Enable ROM space decodes */
  814. //                        if (pci_enable_rom(pdev))
  815. //                                return NULL;
  816.         }
  817.     }
  818. #endif
  819.  
  820.     rom = ioremap(start, *size);
  821.     if (!rom) {
  822.             /* restore enable if ioremap fails */
  823.             if (!(res->flags & (IORESOURCE_ROM_ENABLE |
  824.                                 IORESOURCE_ROM_SHADOW |
  825.                                 IORESOURCE_ROM_COPY)))
  826.                     pci_disable_rom(pdev);
  827.             return NULL;
  828.     }
  829.  
  830.     /*
  831.      * Try to find the true size of the ROM since sometimes the PCI window
  832.      * size is much larger than the actual size of the ROM.
  833.      * True size is important if the ROM is going to be copied.
  834.      */
  835.     *size = pci_get_rom_size(pdev, rom, *size);
  836. //    LEAVE();
  837.     return rom;
  838. }
  839.  
  840. void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom)
  841. {
  842.     struct resource *res = &pdev->resource[PCI_ROM_RESOURCE];
  843.  
  844.     if (res->flags & (IORESOURCE_ROM_COPY | IORESOURCE_ROM_BIOS_COPY))
  845.             return;
  846.  
  847.     iounmap(rom);
  848.  
  849.     /* Disable again before continuing, leave enabled if pci=rom */
  850.     if (!(res->flags & (IORESOURCE_ROM_ENABLE | IORESOURCE_ROM_SHADOW)))
  851.             pci_disable_rom(pdev);
  852. }
  853.  
  854. static void __pci_set_master(struct pci_dev *dev, bool enable)
  855. {
  856.     u16 old_cmd, cmd;
  857.  
  858.     pci_read_config_word(dev, PCI_COMMAND, &old_cmd);
  859.     if (enable)
  860.         cmd = old_cmd | PCI_COMMAND_MASTER;
  861.     else
  862.         cmd = old_cmd & ~PCI_COMMAND_MASTER;
  863.     if (cmd != old_cmd) {
  864.         pci_write_config_word(dev, PCI_COMMAND, cmd);
  865.         }
  866.     dev->is_busmaster = enable;
  867. }
  868.  
  869.  
  870. /* pci_set_master - enables bus-mastering for device dev
  871.  * @dev: the PCI device to enable
  872.  *
  873.  * Enables bus-mastering on the device and calls pcibios_set_master()
  874.  * to do the needed arch specific settings.
  875.  */
  876. void pci_set_master(struct pci_dev *dev)
  877. {
  878.         __pci_set_master(dev, true);
  879. //        pcibios_set_master(dev);
  880. }
  881.  
  882. /**
  883.  * pci_clear_master - disables bus-mastering for device dev
  884.  * @dev: the PCI device to disable
  885.  */
  886. void pci_clear_master(struct pci_dev *dev)
  887. {
  888.         __pci_set_master(dev, false);
  889. }
  890.  
  891.  
  892. static inline int pcie_cap_version(const struct pci_dev *dev)
  893. {
  894.     return dev->pcie_flags_reg & PCI_EXP_FLAGS_VERS;
  895. }
  896.  
  897. static inline bool pcie_cap_has_devctl(const struct pci_dev *dev)
  898. {
  899.     return true;
  900. }
  901.  
  902. static inline bool pcie_cap_has_lnkctl(const struct pci_dev *dev)
  903. {
  904.     int type = pci_pcie_type(dev);
  905.  
  906.     return pcie_cap_version(dev) > 1 ||
  907.            type == PCI_EXP_TYPE_ROOT_PORT ||
  908.            type == PCI_EXP_TYPE_ENDPOINT ||
  909.            type == PCI_EXP_TYPE_LEG_END;
  910. }
  911.  
  912. static inline bool pcie_cap_has_sltctl(const struct pci_dev *dev)
  913. {
  914.     int type = pci_pcie_type(dev);
  915.  
  916.     return pcie_cap_version(dev) > 1 ||
  917.            type == PCI_EXP_TYPE_ROOT_PORT ||
  918.            (type == PCI_EXP_TYPE_DOWNSTREAM &&
  919.         dev->pcie_flags_reg & PCI_EXP_FLAGS_SLOT);
  920. }
  921.  
  922. static inline bool pcie_cap_has_rtctl(const struct pci_dev *dev)
  923. {
  924.     int type = pci_pcie_type(dev);
  925.  
  926.     return pcie_cap_version(dev) > 1 ||
  927.            type == PCI_EXP_TYPE_ROOT_PORT ||
  928.            type == PCI_EXP_TYPE_RC_EC;
  929. }
  930.  
  931. static bool pcie_capability_reg_implemented(struct pci_dev *dev, int pos)
  932. {
  933.     if (!pci_is_pcie(dev))
  934.         return false;
  935.  
  936.     switch (pos) {
  937.     case PCI_EXP_FLAGS_TYPE:
  938.         return true;
  939.     case PCI_EXP_DEVCAP:
  940.     case PCI_EXP_DEVCTL:
  941.     case PCI_EXP_DEVSTA:
  942.         return pcie_cap_has_devctl(dev);
  943.     case PCI_EXP_LNKCAP:
  944.     case PCI_EXP_LNKCTL:
  945.     case PCI_EXP_LNKSTA:
  946.         return pcie_cap_has_lnkctl(dev);
  947.     case PCI_EXP_SLTCAP:
  948.     case PCI_EXP_SLTCTL:
  949.     case PCI_EXP_SLTSTA:
  950.         return pcie_cap_has_sltctl(dev);
  951.     case PCI_EXP_RTCTL:
  952.     case PCI_EXP_RTCAP:
  953.     case PCI_EXP_RTSTA:
  954.         return pcie_cap_has_rtctl(dev);
  955.     case PCI_EXP_DEVCAP2:
  956.     case PCI_EXP_DEVCTL2:
  957.     case PCI_EXP_LNKCAP2:
  958.     case PCI_EXP_LNKCTL2:
  959.     case PCI_EXP_LNKSTA2:
  960.         return pcie_cap_version(dev) > 1;
  961.     default:
  962.         return false;
  963.     }
  964. }
  965.  
  966. /*
  967.  * Note that these accessor functions are only for the "PCI Express
  968.  * Capability" (see PCIe spec r3.0, sec 7.8).  They do not apply to the
  969.  * other "PCI Express Extended Capabilities" (AER, VC, ACS, MFVC, etc.)
  970.  */
  971. int pcie_capability_read_word(struct pci_dev *dev, int pos, u16 *val)
  972. {
  973.     int ret;
  974.  
  975.     *val = 0;
  976.     if (pos & 1)
  977.         return -EINVAL;
  978.  
  979.     if (pcie_capability_reg_implemented(dev, pos)) {
  980.         ret = pci_read_config_word(dev, pci_pcie_cap(dev) + pos, val);
  981.         /*
  982.          * Reset *val to 0 if pci_read_config_word() fails, it may
  983.          * have been written as 0xFFFF if hardware error happens
  984.          * during pci_read_config_word().
  985.          */
  986.         if (ret)
  987.             *val = 0;
  988.         return ret;
  989.     }
  990.  
  991.     /*
  992.      * For Functions that do not implement the Slot Capabilities,
  993.      * Slot Status, and Slot Control registers, these spaces must
  994.      * be hardwired to 0b, with the exception of the Presence Detect
  995.      * State bit in the Slot Status register of Downstream Ports,
  996.      * which must be hardwired to 1b.  (PCIe Base Spec 3.0, sec 7.8)
  997.      */
  998.     if (pci_is_pcie(dev) && pos == PCI_EXP_SLTSTA &&
  999.          pci_pcie_type(dev) == PCI_EXP_TYPE_DOWNSTREAM) {
  1000.         *val = PCI_EXP_SLTSTA_PDS;
  1001.     }
  1002.  
  1003.     return 0;
  1004. }
  1005. EXPORT_SYMBOL(pcie_capability_read_word);
  1006.  
  1007. int pcie_capability_read_dword(struct pci_dev *dev, int pos, u32 *val)
  1008. {
  1009.     int ret;
  1010.  
  1011.     *val = 0;
  1012.     if (pos & 3)
  1013.         return -EINVAL;
  1014.  
  1015.     if (pcie_capability_reg_implemented(dev, pos)) {
  1016.         ret = pci_read_config_dword(dev, pci_pcie_cap(dev) + pos, val);
  1017.         /*
  1018.          * Reset *val to 0 if pci_read_config_dword() fails, it may
  1019.          * have been written as 0xFFFFFFFF if hardware error happens
  1020.          * during pci_read_config_dword().
  1021.          */
  1022.         if (ret)
  1023.             *val = 0;
  1024.         return ret;
  1025.     }
  1026.  
  1027.     if (pci_is_pcie(dev) && pos == PCI_EXP_SLTCTL &&
  1028.          pci_pcie_type(dev) == PCI_EXP_TYPE_DOWNSTREAM) {
  1029.         *val = PCI_EXP_SLTSTA_PDS;
  1030.     }
  1031.  
  1032.     return 0;
  1033. }
  1034. EXPORT_SYMBOL(pcie_capability_read_dword);
  1035.  
  1036. int pcie_capability_write_word(struct pci_dev *dev, int pos, u16 val)
  1037. {
  1038.     if (pos & 1)
  1039.         return -EINVAL;
  1040.  
  1041.     if (!pcie_capability_reg_implemented(dev, pos))
  1042.         return 0;
  1043.  
  1044.     return pci_write_config_word(dev, pci_pcie_cap(dev) + pos, val);
  1045. }
  1046. EXPORT_SYMBOL(pcie_capability_write_word);
  1047.  
  1048. int pcie_capability_write_dword(struct pci_dev *dev, int pos, u32 val)
  1049. {
  1050.     if (pos & 3)
  1051.         return -EINVAL;
  1052.  
  1053.     if (!pcie_capability_reg_implemented(dev, pos))
  1054.         return 0;
  1055.  
  1056.     return pci_write_config_dword(dev, pci_pcie_cap(dev) + pos, val);
  1057. }
  1058. EXPORT_SYMBOL(pcie_capability_write_dword);
  1059.  
  1060. int pcie_capability_clear_and_set_word(struct pci_dev *dev, int pos,
  1061.                                        u16 clear, u16 set)
  1062. {
  1063.         int ret;
  1064.         u16 val;
  1065.  
  1066.         ret = pcie_capability_read_word(dev, pos, &val);
  1067.         if (!ret) {
  1068.                 val &= ~clear;
  1069.                 val |= set;
  1070.                 ret = pcie_capability_write_word(dev, pos, val);
  1071.         }
  1072.  
  1073.         return ret;
  1074. }
  1075.  
  1076.  
  1077.  
  1078. int pcie_get_readrq(struct pci_dev *dev)
  1079. {
  1080.         u16 ctl;
  1081.  
  1082.         pcie_capability_read_word(dev, PCI_EXP_DEVCTL, &ctl);
  1083.  
  1084.         return 128 << ((ctl & PCI_EXP_DEVCTL_READRQ) >> 12);
  1085. }
  1086. EXPORT_SYMBOL(pcie_get_readrq);
  1087.  
  1088. /**
  1089.  * pcie_set_readrq - set PCI Express maximum memory read request
  1090.  * @dev: PCI device to query
  1091.  * @rq: maximum memory read count in bytes
  1092.  *    valid values are 128, 256, 512, 1024, 2048, 4096
  1093.  *
  1094.  * If possible sets maximum memory read request in bytes
  1095.  */
  1096. int pcie_set_readrq(struct pci_dev *dev, int rq)
  1097. {
  1098.         u16 v;
  1099.  
  1100.         if (rq < 128 || rq > 4096 || !is_power_of_2(rq))
  1101.                 return -EINVAL;
  1102.  
  1103.         v = (ffs(rq) - 8) << 12;
  1104.  
  1105.         return pcie_capability_clear_and_set_word(dev, PCI_EXP_DEVCTL,
  1106.                                                   PCI_EXP_DEVCTL_READRQ, v);
  1107. }
  1108.  
  1109.