Subversion Repositories Kolibri OS

Rev

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