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