lib/generic.c

   1 /*
   2  *      The PCI Library -- Generic Direct Access Functions
   3  *
   4  *      Copyright (c) 1997--2022 Martin Mares <mj@ucw.cz>
   5  *
   6  *      Can be freely distributed and used under the terms of the GNU GPL.
   7  */
   8
   9 #include <string.h>
  10
  11 #include "internal.h"
  12
  13 void
  14 pci_generic_scan_bus(struct pci_access *a, byte *busmap, int bus)
  15 {
  16   int dev, multi, ht;
  17   struct pci_dev *t;
  18
  19   a->debug("Scanning bus %02x for devices...\n", bus);
  20   if (busmap[bus])
  21     {
  22       a->warning("Bus %02x seen twice (firmware bug). Ignored.", bus);
  23       return;
  24     }
  25   busmap[bus] = 1;
  26   t = pci_alloc_dev(a);
  27   t->bus = bus;
  28   for (dev=0; dev<32; dev++)
  29     {
  30       t->dev = dev;
  31       multi = 0;
  32       for (t->func=0; !t->func || multi && t->func<8; t->func++)
  33         {
  34           u32 vd = pci_read_long(t, PCI_VENDOR_ID);
  35           struct pci_dev *d;
  36
  37           if (!vd || vd == 0xffffffff)
  38             continue;
  39           ht = pci_read_byte(t, PCI_HEADER_TYPE);
  40           if (!t->func)
  41             multi = ht & 0x80;
  42           ht &= 0x7f;
  43           d = pci_alloc_dev(a);
  44           d->bus = t->bus;
  45           d->dev = t->dev;
  46           d->func = t->func;
  47           d->vendor_id = vd & 0xffff;
  48           d->device_id = vd >> 16U;
  49           d->known_fields = PCI_FILL_IDENT;
  50           d->hdrtype = ht;
  51           pci_link_dev(a, d);
  52           switch (ht)
  53             {
  54             case PCI_HEADER_TYPE_NORMAL:
  55               break;
  56             case PCI_HEADER_TYPE_BRIDGE:
  57             case PCI_HEADER_TYPE_CARDBUS:
  58               pci_generic_scan_bus(a, busmap, pci_read_byte(t, PCI_SECONDARY_BUS));
  59               break;
  60             default:
  61               a->debug("Device %04x:%02x:%02x.%d has unknown header type %02x.\n", d->domain, d->bus, d->dev, d->func, ht);
  62             }
  63         }
  64     }
  65   pci_free_dev(t);
  66 }
  67
  68 void
  69 pci_generic_scan(struct pci_access *a)
  70 {
  71   byte busmap[256];
  72
  73   memset(busmap, 0, sizeof(busmap));
  74   pci_generic_scan_bus(a, busmap, 0);
  75 }
  76
  77 static int
  78 get_hdr_type(struct pci_dev *d)
  79 {
  80   if (d->hdrtype < 0)
  81     d->hdrtype = pci_read_byte(d, PCI_HEADER_TYPE) & 0x7f;
  82   return d->hdrtype;
  83 }
  84
  85 void
  86 pci_generic_fill_info(struct pci_dev *d, unsigned int flags)
  87 {
  88   struct pci_access *a = d->access;
  89   struct pci_cap *cap;
  90
  91   if (want_fill(d, flags, PCI_FILL_IDENT))
  92     {
  93       d->vendor_id = pci_read_word(d, PCI_VENDOR_ID);
  94       d->device_id = pci_read_word(d, PCI_DEVICE_ID);
  95     }
  96
  97   if (want_fill(d, flags, PCI_FILL_CLASS))
  98     d->device_class = pci_read_word(d, PCI_CLASS_DEVICE);
  99
 100   if (want_fill(d, flags, PCI_FILL_CLASS_EXT))
 101     {
 102       d->prog_if = pci_read_byte(d, PCI_CLASS_PROG);
 103       d->rev_id = pci_read_byte(d, PCI_REVISION_ID);
 104     }
 105
 106   if (want_fill(d, flags, PCI_FILL_SUBSYS))
 107     {
 108       switch (get_hdr_type(d))
 109         {
 110         case PCI_HEADER_TYPE_NORMAL:
 111           d->subsys_vendor_id = pci_read_word(d, PCI_SUBSYSTEM_VENDOR_ID);
 112           d->subsys_id = pci_read_word(d, PCI_SUBSYSTEM_ID);
 113           break;
 114         case PCI_HEADER_TYPE_BRIDGE:
 115           cap = pci_find_cap(d, PCI_CAP_ID_SSVID, PCI_CAP_NORMAL);
 116           if (cap)
 117             {
 118               d->subsys_vendor_id = pci_read_word(d, cap->addr + PCI_SSVID_VENDOR);
 119               d->subsys_id = pci_read_word(d, cap->addr + PCI_SSVID_DEVICE);
 120             }
 121           break;
 122         case PCI_HEADER_TYPE_CARDBUS:
 123           d->subsys_vendor_id = pci_read_word(d, PCI_CB_SUBSYSTEM_VENDOR_ID);
 124           d->subsys_id = pci_read_word(d, PCI_CB_SUBSYSTEM_ID);
 125           break;
 126         default:
 127           clear_fill(d, PCI_FILL_SUBSYS);
 128         }
 129     }
 130
 131   if (want_fill(d, flags, PCI_FILL_IRQ))
 132     d->irq = pci_read_byte(d, PCI_INTERRUPT_LINE);
 133
 134   if (want_fill(d, flags, PCI_FILL_BASES))
 135     {
 136       int cnt = 0, i;
 137       memset(d->base_addr, 0, sizeof(d->base_addr));
 138       switch (get_hdr_type(d))
 139         {
 140         case PCI_HEADER_TYPE_NORMAL:
 141           cnt = 6;
 142           break;
 143         case PCI_HEADER_TYPE_BRIDGE:
 144           cnt = 2;
 145           break;
 146         case PCI_HEADER_TYPE_CARDBUS:
 147           cnt = 1;
 148           break;
 149         }
 150       if (cnt)
 151         {
 152           for (i=0; i<cnt; i++)
 153             {
 154               u32 x = pci_read_long(d, PCI_BASE_ADDRESS_0 + i*4);
 155               if (!x || x == (u32) ~0)
 156                 continue;
 157               if ((x & PCI_BASE_ADDRESS_SPACE) == PCI_BASE_ADDRESS_SPACE_IO)
 158                 d->base_addr[i] = x;
 159               else
 160                 {
 161                   if ((x & PCI_BASE_ADDRESS_MEM_TYPE_MASK) != PCI_BASE_ADDRESS_MEM_TYPE_64)
 162                     d->base_addr[i] = x;
 163                   else if (i >= cnt-1)
 164                     a->warning("%04x:%02x:%02x.%d: Invalid 64-bit address seen for BAR %d.", d->domain, d->bus, d->dev, d->func, i);
 165                   else
 166                     {
 167                       u32 y = pci_read_long(d, PCI_BASE_ADDRESS_0 + (++i)*4);
 168 #ifdef PCI_HAVE_64BIT_ADDRESS
 169                       d->base_addr[i-1] = x | (((pciaddr_t) y) << 32);
 170 #else
 171                       if (y)
 172                         a->warning("%04x:%02x:%02x.%d 64-bit device address ignored.", d->domain, d->bus, d->dev, d->func);
 173                       else
 174                         d->base_addr[i-1] = x;
 175 #endif
 176                     }
 177                 }
 178             }
 179         }
 180     }
 181
 182   if (want_fill(d, flags, PCI_FILL_ROM_BASE))
 183     {
 184       int reg = 0;
 185       d->rom_base_addr = 0;
 186       switch (get_hdr_type(d))
 187         {
 188         case PCI_HEADER_TYPE_NORMAL:
 189           reg = PCI_ROM_ADDRESS;
 190           break;
 191         case PCI_HEADER_TYPE_BRIDGE:
 192           reg = PCI_ROM_ADDRESS1;
 193           break;
 194         }
 195       if (reg)
 196         {
 197           u32 u = pci_read_long(d, reg);
 198           if (u != 0xffffffff)
 199             d->rom_base_addr = u;
 200         }
 201     }
 202
 203   pci_scan_caps(d, flags);
 204 }
 205
 206 static int
 207 pci_generic_block_op(struct pci_dev *d, int pos, byte *buf, int len,
 208                  int (*r)(struct pci_dev *d, int pos, byte *buf, int len))
 209 {
 210   if ((pos & 1) && len >= 1)
 211     {
 212       if (!r(d, pos, buf, 1))
 213         return 0;
 214       pos++; buf++; len--;
 215     }
 216   if ((pos & 3) && len >= 2)
 217     {
 218       if (!r(d, pos, buf, 2))
 219         return 0;
 220       pos += 2; buf += 2; len -= 2;
 221     }
 222   while (len >= 4)
 223     {
 224       if (!r(d, pos, buf, 4))
 225         return 0;
 226       pos += 4; buf += 4; len -= 4;
 227     }
 228   if (len >= 2)
 229     {
 230       if (!r(d, pos, buf, 2))
 231         return 0;
 232       pos += 2; buf += 2; len -= 2;
 233     }
 234   if (len && !r(d, pos, buf, 1))
 235     return 0;
 236   return 1;
 237 }
 238
 239 int
 240 pci_generic_block_read(struct pci_dev *d, int pos, byte *buf, int len)
 241 {
 242   return pci_generic_block_op(d, pos, buf, len, d->access->methods->read);
 243 }
 244
 245 int
 246 pci_generic_block_write(struct pci_dev *d, int pos, byte *buf, int len)
 247 {
 248   return pci_generic_block_op(d, pos, buf, len, d->access->methods->write);
 249 }