lspci.c

   1 /*
   2  *      The PCI Utilities -- List All PCI Devices
   3  *
   4  *      Copyright (c) 1997--2008 Martin Mares <mj@ucw.cz>
   5  *
   6  *      Can be freely distributed and used under the terms of the GNU GPL.
   7  */
   8
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include <stdlib.h>
  12 #include <stdarg.h>
  13 #include <unistd.h>
  14
  15 #define PCIUTILS_LSPCI
  16 #include "pciutils.h"
  17
  18 /* Options */
  19
  20 static int verbose;                     /* Show detailed information */
  21 static int opt_buscentric;              /* Show bus addresses/IRQ's instead of CPU-visible ones */
  22 static int opt_hex;                     /* Show contents of config space as hexadecimal numbers */
  23 static struct pci_filter filter;        /* Device filter */
  24 static int opt_tree;                    /* Show bus tree */
  25 static int opt_machine;                 /* Generate machine-readable output */
  26 static int opt_map_mode;                /* Bus mapping mode enabled */
  27 static int opt_domains;                 /* Show domain numbers (0=disabled, 1=auto-detected, 2=requested) */
  28 static int opt_kernel;                  /* Show kernel drivers */
  29 static int opt_query_dns;               /* Query the DNS (0=disabled, 1=enabled, 2=refresh cache) */
  30 static int opt_query_all;               /* Query the DNS for all entries */
  31 static char *opt_pcimap;                /* Override path to Linux modules.pcimap */
  32
  33 const char program_name[] = "lspci";
  34
  35 static char options[] = "nvbxs:d:ti:mgp:qkMDQ" GENERIC_OPTIONS ;
  36
  37 static char help_msg[] =
  38 "Usage: lspci [<switches>]\n"
  39 "\n"
  40 "Basic display modes:\n"
  41 "-mm\t\tProduce machine-readable output (single -m for an obsolete format)\n"
  42 "-t\t\tShow bus tree\n"
  43 "\n"
  44 "Display options:\n"
  45 "-v\t\tBe verbose (-vv for very verbose)\n"
  46 #ifdef PCI_OS_LINUX
  47 "-k\t\tShow kernel drivers handling each device\n"
  48 #endif
  49 "-x\t\tShow hex-dump of the standard part of the config space\n"
  50 "-xxx\t\tShow hex-dump of the whole config space (dangerous; root only)\n"
  51 "-xxxx\t\tShow hex-dump of the 4096-byte extended config space (root only)\n"
  52 "-b\t\tBus-centric view (addresses and IRQ's as seen by the bus)\n"
  53 "-D\t\tAlways show domain numbers\n"
  54 "\n"
  55 "Resolving of device ID's to names:\n"
  56 "-n\t\tShow numeric ID's\n"
  57 "-nn\t\tShow both textual and numeric ID's (names & numbers)\n"
  58 #ifdef PCI_USE_DNS
  59 "-q\t\tQuery the PCI ID database for unknown ID's via DNS\n"
  60 "-qq\t\tAs above, but re-query locally cached entries\n"
  61 "-Q\t\tQuery the PCI ID database for all ID's via DNS\n"
  62 #endif
  63 "\n"
  64 "Selection of devices:\n"
  65 "-s [[[[<domain>]:]<bus>]:][<slot>][.[<func>]]\tShow only devices in selected slots\n"
  66 "-d [<vendor>]:[<device>]\t\t\tShow only devices with specified ID's\n"
  67 "\n"
  68 "Other options:\n"
  69 "-i <file>\tUse specified ID database instead of %s\n"
  70 #ifdef PCI_OS_LINUX
  71 "-p <file>\tLook up kernel modules in a given file instead of default modules.pcimap\n"
  72 #endif
  73 "-M\t\tEnable `bus mapping' mode (dangerous; root only)\n"
  74 "\n"
  75 "PCI access options:\n"
  76 GENERIC_HELP
  77 ;
  78
  79 /*** Communication with libpci ***/
  80
  81 static struct pci_access *pacc;
  82
  83 /*
  84  *  If we aren't being compiled by GCC, use xmalloc() instead of alloca().
  85  *  This increases our memory footprint, but only slightly since we don't
  86  *  use alloca() much.
  87  */
  88 #if defined (__FreeBSD__) || defined (__NetBSD__) || defined (__OpenBSD__) || defined (__DragonFly__)
  89 /* alloca() is defined in stdlib.h */
  90 #elif defined(__GNUC__) && !defined(PCI_OS_WINDOWS)
  91 #include <alloca.h>
  92 #else
  93 #undef alloca
  94 #define alloca xmalloc
  95 #endif
  96
  97 /*** Our view of the PCI bus ***/
  98
  99 struct device {
 100   struct device *next;
 101   struct pci_dev *dev;
 102   unsigned int config_cached, config_bufsize;
 103   byte *config;                         /* Cached configuration space data */
 104   byte *present;                        /* Maps which configuration bytes are present */
 105 };
 106
 107 static struct device *first_dev;
 108 static int seen_errors;
 109
 110 static int
 111 config_fetch(struct device *d, unsigned int pos, unsigned int len)
 112 {
 113   unsigned int end = pos+len;
 114   int result;
 115
 116   while (pos < d->config_bufsize && len && d->present[pos])
 117     pos++, len--;
 118   while (pos+len <= d->config_bufsize && len && d->present[pos+len-1])
 119     len--;
 120   if (!len)
 121     return 1;
 122
 123   if (end > d->config_bufsize)
 124     {
 125       int orig_size = d->config_bufsize;
 126       while (end > d->config_bufsize)
 127         d->config_bufsize *= 2;
 128       d->config = xrealloc(d->config, d->config_bufsize);
 129       d->present = xrealloc(d->present, d->config_bufsize);
 130       memset(d->present + orig_size, 0, d->config_bufsize - orig_size);
 131     }
 132   result = pci_read_block(d->dev, pos, d->config + pos, len);
 133   if (result)
 134     memset(d->present + pos, 1, len);
 135   return result;
 136 }
 137
 138 static struct device *
 139 scan_device(struct pci_dev *p)
 140 {
 141   struct device *d;
 142
 143   if (p->domain && !opt_domains)
 144     opt_domains = 1;
 145   if (!pci_filter_match(&filter, p))
 146     return NULL;
 147   d = xmalloc(sizeof(struct device));
 148   memset(d, 0, sizeof(*d));
 149   d->dev = p;
 150   d->config_cached = d->config_bufsize = 64;
 151   d->config = xmalloc(64);
 152   d->present = xmalloc(64);
 153   memset(d->present, 1, 64);
 154   if (!pci_read_block(p, 0, d->config, 64))
 155     {
 156       fprintf(stderr, "lspci: Unable to read the standard configuration space header of device %04x:%02x:%02x.%d\n",
 157               p->domain, p->bus, p->dev, p->func);
 158       seen_errors++;
 159       return NULL;
 160     }
 161   if ((d->config[PCI_HEADER_TYPE] & 0x7f) == PCI_HEADER_TYPE_CARDBUS)
 162     {
 163       /* For cardbus bridges, we need to fetch 64 bytes more to get the
 164        * full standard header... */
 165       if (config_fetch(d, 64, 64))
 166         d->config_cached += 64;
 167     }
 168   pci_setup_cache(p, d->config, d->config_cached);
 169   pci_fill_info(p, PCI_FILL_IDENT | PCI_FILL_CLASS | PCI_FILL_IRQ | PCI_FILL_BASES | PCI_FILL_ROM_BASE | PCI_FILL_SIZES);
 170   return d;
 171 }
 172
 173 static void
 174 scan_devices(void)
 175 {
 176   struct device *d;
 177   struct pci_dev *p;
 178
 179   pci_scan_bus(pacc);
 180   for(p=pacc->devices; p; p=p->next)
 181     if (d = scan_device(p))
 182       {
 183         d->next = first_dev;
 184         first_dev = d;
 185       }
 186 }
 187
 188 /*** Config space accesses ***/
 189
 190 static void
 191 check_conf_range(struct device *d, unsigned int pos, unsigned int len)
 192 {
 193   while (len)
 194     if (!d->present[pos])
 195       die("Internal bug: Accessing non-read configuration byte at position %x", pos);
 196     else
 197       pos++, len--;
 198 }
 199
 200 static inline byte
 201 get_conf_byte(struct device *d, unsigned int pos)
 202 {
 203   check_conf_range(d, pos, 1);
 204   return d->config[pos];
 205 }
 206
 207 static word
 208 get_conf_word(struct device *d, unsigned int pos)
 209 {
 210   check_conf_range(d, pos, 2);
 211   return d->config[pos] | (d->config[pos+1] << 8);
 212 }
 213
 214 static u32
 215 get_conf_long(struct device *d, unsigned int pos)
 216 {
 217   check_conf_range(d, pos, 4);
 218   return d->config[pos] |
 219     (d->config[pos+1] << 8) |
 220     (d->config[pos+2] << 16) |
 221     (d->config[pos+3] << 24);
 222 }
 223
 224 /*** Sorting ***/
 225
 226 static int
 227 compare_them(const void *A, const void *B)
 228 {
 229   const struct pci_dev *a = (*(const struct device **)A)->dev;
 230   const struct pci_dev *b = (*(const struct device **)B)->dev;
 231
 232   if (a->domain < b->domain)
 233     return -1;
 234   if (a->domain > b->domain)
 235     return 1;
 236   if (a->bus < b->bus)
 237     return -1;
 238   if (a->bus > b->bus)
 239     return 1;
 240   if (a->dev < b->dev)
 241     return -1;
 242   if (a->dev > b->dev)
 243     return 1;
 244   if (a->func < b->func)
 245     return -1;
 246   if (a->func > b->func)
 247     return 1;
 248   return 0;
 249 }
 250
 251 static void
 252 sort_them(void)
 253 {
 254   struct device **index, **h, **last_dev;
 255   int cnt;
 256   struct device *d;
 257
 258   cnt = 0;
 259   for(d=first_dev; d; d=d->next)
 260     cnt++;
 261   h = index = alloca(sizeof(struct device *) * cnt);
 262   for(d=first_dev; d; d=d->next)
 263     *h++ = d;
 264   qsort(index, cnt, sizeof(struct device *), compare_them);
 265   last_dev = &first_dev;
 266   h = index;
 267   while (cnt--)
 268     {
 269       *last_dev = *h;
 270       last_dev = &(*h)->next;
 271       h++;
 272     }
 273   *last_dev = NULL;
 274 }
 275
 276 /*** Normal output ***/
 277
 278 #define FLAG(x,y) ((x & y) ? '+' : '-')
 279
 280 static void
 281 show_slot_name(struct device *d)
 282 {
 283   struct pci_dev *p = d->dev;
 284
 285   if (!opt_machine ? opt_domains : (p->domain || opt_domains >= 2))
 286     printf("%04x:", p->domain);
 287   printf("%02x:%02x.%d", p->bus, p->dev, p->func);
 288 }
 289
 290 static void
 291 get_subid(struct device *d, word *subvp, word *subdp)
 292 {
 293   byte htype = get_conf_byte(d, PCI_HEADER_TYPE) & 0x7f;
 294
 295   if (htype == PCI_HEADER_TYPE_NORMAL)
 296     {
 297       *subvp = get_conf_word(d, PCI_SUBSYSTEM_VENDOR_ID);
 298       *subdp = get_conf_word(d, PCI_SUBSYSTEM_ID);
 299     }
 300   else if (htype == PCI_HEADER_TYPE_CARDBUS && d->config_cached >= 128)
 301     {
 302       *subvp = get_conf_word(d, PCI_CB_SUBSYSTEM_VENDOR_ID);
 303       *subdp = get_conf_word(d, PCI_CB_SUBSYSTEM_ID);
 304     }
 305   else
 306     *subvp = *subdp = 0xffff;
 307 }
 308
 309 static void
 310 show_terse(struct device *d)
 311 {
 312   int c;
 313   struct pci_dev *p = d->dev;
 314   char classbuf[128], devbuf[128];
 315
 316   show_slot_name(d);
 317   printf(" %s: %s",
 318          pci_lookup_name(pacc, classbuf, sizeof(classbuf),
 319                          PCI_LOOKUP_CLASS,
 320                          p->device_class),
 321          pci_lookup_name(pacc, devbuf, sizeof(devbuf),
 322                          PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE,
 323                          p->vendor_id, p->device_id));
 324   if (c = get_conf_byte(d, PCI_REVISION_ID))
 325     printf(" (rev %02x)", c);
 326   if (verbose)
 327     {
 328       char *x;
 329       c = get_conf_byte(d, PCI_CLASS_PROG);
 330       x = pci_lookup_name(pacc, devbuf, sizeof(devbuf),
 331                           PCI_LOOKUP_PROGIF | PCI_LOOKUP_NO_NUMBERS,
 332                           p->device_class, c);
 333       if (c || x)
 334         {
 335           printf(" (prog-if %02x", c);
 336           if (x)
 337             printf(" [%s]", x);
 338           putchar(')');
 339         }
 340     }
 341   putchar('\n');
 342
 343   if (verbose || opt_kernel)
 344     {
 345       word subsys_v, subsys_d;
 346       char ssnamebuf[256];
 347
 348       get_subid(d, &subsys_v, &subsys_d);
 349       if (subsys_v && subsys_v != 0xffff)
 350         printf("\tSubsystem: %s\n",
 351                 pci_lookup_name(pacc, ssnamebuf, sizeof(ssnamebuf),
 352                         PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE,
 353                         p->vendor_id, p->device_id, subsys_v, subsys_d));
 354     }
 355 }
 356
 357 /*** Capabilities ***/
 358
 359 static void
 360 cap_pm(struct device *d, int where, int cap)
 361 {
 362   int t, b;
 363   static int pm_aux_current[8] = { 0, 55, 100, 160, 220, 270, 320, 375 };
 364
 365   printf("Power Management version %d\n", cap & PCI_PM_CAP_VER_MASK);
 366   if (verbose < 2)
 367     return;
 368   printf("\t\tFlags: PMEClk%c DSI%c D1%c D2%c AuxCurrent=%dmA PME(D0%c,D1%c,D2%c,D3hot%c,D3cold%c)\n",
 369          FLAG(cap, PCI_PM_CAP_PME_CLOCK),
 370          FLAG(cap, PCI_PM_CAP_DSI),
 371          FLAG(cap, PCI_PM_CAP_D1),
 372          FLAG(cap, PCI_PM_CAP_D2),
 373          pm_aux_current[(cap >> 6) & 7],
 374          FLAG(cap, PCI_PM_CAP_PME_D0),
 375          FLAG(cap, PCI_PM_CAP_PME_D1),
 376          FLAG(cap, PCI_PM_CAP_PME_D2),
 377          FLAG(cap, PCI_PM_CAP_PME_D3_HOT),
 378          FLAG(cap, PCI_PM_CAP_PME_D3_COLD));
 379   if (!config_fetch(d, where + PCI_PM_CTRL, PCI_PM_SIZEOF - PCI_PM_CTRL))
 380     return;
 381   t = get_conf_word(d, where + PCI_PM_CTRL);
 382   printf("\t\tStatus: D%d PME-Enable%c DSel=%d DScale=%d PME%c\n",
 383          t & PCI_PM_CTRL_STATE_MASK,
 384          FLAG(t, PCI_PM_CTRL_PME_ENABLE),
 385          (t & PCI_PM_CTRL_DATA_SEL_MASK) >> 9,
 386          (t & PCI_PM_CTRL_DATA_SCALE_MASK) >> 13,
 387          FLAG(t, PCI_PM_CTRL_PME_STATUS));
 388   b = get_conf_byte(d, where + PCI_PM_PPB_EXTENSIONS);
 389   if (b)
 390     printf("\t\tBridge: PM%c B3%c\n",
 391            FLAG(t, PCI_PM_BPCC_ENABLE),
 392            FLAG(~t, PCI_PM_PPB_B2_B3));
 393 }
 394
 395 static void
 396 format_agp_rate(int rate, char *buf, int agp3)
 397 {
 398   char *c = buf;
 399   int i;
 400
 401   for(i=0; i<=2; i++)
 402     if (rate & (1 << i))
 403       {
 404         if (c != buf)
 405           *c++ = ',';
 406         c += sprintf(c, "x%d", 1 << (i + 2*agp3));
 407       }
 408   if (c != buf)
 409     *c = 0;
 410   else
 411     strcpy(buf, "<none>");
 412 }
 413
 414 static void
 415 cap_agp(struct device *d, int where, int cap)
 416 {
 417   u32 t;
 418   char rate[16];
 419   int ver, rev;
 420   int agp3 = 0;
 421
 422   ver = (cap >> 4) & 0x0f;
 423   rev = cap & 0x0f;
 424   printf("AGP version %x.%x\n", ver, rev);
 425   if (verbose < 2)
 426     return;
 427   if (!config_fetch(d, where + PCI_AGP_STATUS, PCI_AGP_SIZEOF - PCI_AGP_STATUS))
 428     return;
 429   t = get_conf_long(d, where + PCI_AGP_STATUS);
 430   if (ver >= 3 && (t & PCI_AGP_STATUS_AGP3))
 431     agp3 = 1;
 432   format_agp_rate(t & 7, rate, agp3);
 433   printf("\t\tStatus: RQ=%d Iso%c ArqSz=%d Cal=%d SBA%c ITACoh%c GART64%c HTrans%c 64bit%c FW%c AGP3%c Rate=%s\n",
 434          ((t & PCI_AGP_STATUS_RQ_MASK) >> 24U) + 1,
 435          FLAG(t, PCI_AGP_STATUS_ISOCH),
 436          ((t & PCI_AGP_STATUS_ARQSZ_MASK) >> 13),
 437          ((t & PCI_AGP_STATUS_CAL_MASK) >> 10),
 438          FLAG(t, PCI_AGP_STATUS_SBA),
 439          FLAG(t, PCI_AGP_STATUS_ITA_COH),
 440          FLAG(t, PCI_AGP_STATUS_GART64),
 441          FLAG(t, PCI_AGP_STATUS_HTRANS),
 442          FLAG(t, PCI_AGP_STATUS_64BIT),
 443          FLAG(t, PCI_AGP_STATUS_FW),
 444          FLAG(t, PCI_AGP_STATUS_AGP3),
 445          rate);
 446   t = get_conf_long(d, where + PCI_AGP_COMMAND);
 447   format_agp_rate(t & 7, rate, agp3);
 448   printf("\t\tCommand: RQ=%d ArqSz=%d Cal=%d SBA%c AGP%c GART64%c 64bit%c FW%c Rate=%s\n",
 449          ((t & PCI_AGP_COMMAND_RQ_MASK) >> 24U) + 1,
 450          ((t & PCI_AGP_COMMAND_ARQSZ_MASK) >> 13),
 451          ((t & PCI_AGP_COMMAND_CAL_MASK) >> 10),
 452          FLAG(t, PCI_AGP_COMMAND_SBA),
 453          FLAG(t, PCI_AGP_COMMAND_AGP),
 454          FLAG(t, PCI_AGP_COMMAND_GART64),
 455          FLAG(t, PCI_AGP_COMMAND_64BIT),
 456          FLAG(t, PCI_AGP_COMMAND_FW),
 457          rate);
 458 }
 459
 460 static void
 461 cap_pcix_nobridge(struct device *d, int where)
 462 {
 463   u16 command;
 464   u32 status;
 465   static const byte max_outstanding[8] = { 1, 2, 3, 4, 8, 12, 16, 32 };
 466
 467   printf("PCI-X non-bridge device\n");
 468
 469   if (verbose < 2)
 470     return;
 471
 472   if (!config_fetch(d, where + PCI_PCIX_STATUS, 4))
 473     return;
 474
 475   command = get_conf_word(d, where + PCI_PCIX_COMMAND);
 476   status = get_conf_long(d, where + PCI_PCIX_STATUS);
 477   printf("\t\tCommand: DPERE%c ERO%c RBC=%d OST=%d\n",
 478          FLAG(command, PCI_PCIX_COMMAND_DPERE),
 479          FLAG(command, PCI_PCIX_COMMAND_ERO),
 480          1 << (9 + ((command & PCI_PCIX_COMMAND_MAX_MEM_READ_BYTE_COUNT) >> 2U)),
 481          max_outstanding[(command & PCI_PCIX_COMMAND_MAX_OUTSTANDING_SPLIT_TRANS) >> 4U]);
 482   printf("\t\tStatus: Dev=%02x:%02x.%d 64bit%c 133MHz%c SCD%c USC%c DC=%s DMMRBC=%u DMOST=%u DMCRS=%u RSCEM%c 266MHz%c 533MHz%c\n",
 483          ((status >> 8) & 0xff),
 484          ((status >> 3) & 0x1f),
 485          (status & PCI_PCIX_STATUS_FUNCTION),
 486          FLAG(status, PCI_PCIX_STATUS_64BIT),
 487          FLAG(status, PCI_PCIX_STATUS_133MHZ),
 488          FLAG(status, PCI_PCIX_STATUS_SC_DISCARDED),
 489          FLAG(status, PCI_PCIX_STATUS_UNEXPECTED_SC),
 490          ((status & PCI_PCIX_STATUS_DEVICE_COMPLEXITY) ? "bridge" : "simple"),
 491          1 << (9 + ((status >> 21) & 3U)),
 492          max_outstanding[(status >> 23) & 7U],
 493          1 << (3 + ((status >> 26) & 7U)),
 494          FLAG(status, PCI_PCIX_STATUS_RCVD_SC_ERR_MESS),
 495          FLAG(status, PCI_PCIX_STATUS_266MHZ),
 496          FLAG(status, PCI_PCIX_STATUS_533MHZ));
 497 }
 498
 499 static void
 500 cap_pcix_bridge(struct device *d, int where)
 501 {
 502   static const char * const sec_clock_freq[8] = { "conv", "66MHz", "100MHz", "133MHz", "?4", "?5", "?6", "?7" };
 503   u16 secstatus;
 504   u32 status, upstcr, downstcr;
 505
 506   printf("PCI-X bridge device\n");
 507
 508   if (verbose < 2)
 509     return;
 510
 511   if (!config_fetch(d, where + PCI_PCIX_BRIDGE_STATUS, 12))
 512     return;
 513
 514   secstatus = get_conf_word(d, where + PCI_PCIX_BRIDGE_SEC_STATUS);
 515   printf("\t\tSecondary Status: 64bit%c 133MHz%c SCD%c USC%c SCO%c SRD%c Freq=%s\n",
 516          FLAG(secstatus, PCI_PCIX_BRIDGE_SEC_STATUS_64BIT),
 517          FLAG(secstatus, PCI_PCIX_BRIDGE_SEC_STATUS_133MHZ),
 518          FLAG(secstatus, PCI_PCIX_BRIDGE_SEC_STATUS_SC_DISCARDED),
 519          FLAG(secstatus, PCI_PCIX_BRIDGE_SEC_STATUS_UNEXPECTED_SC),
 520          FLAG(secstatus, PCI_PCIX_BRIDGE_SEC_STATUS_SC_OVERRUN),
 521          FLAG(secstatus, PCI_PCIX_BRIDGE_SEC_STATUS_SPLIT_REQUEST_DELAYED),
 522          sec_clock_freq[(secstatus >> 6) & 7]);
 523   status = get_conf_long(d, where + PCI_PCIX_BRIDGE_STATUS);
 524   printf("\t\tStatus: Dev=%02x:%02x.%d 64bit%c 133MHz%c SCD%c USC%c SCO%c SRD%c\n",
 525          ((status >> 8) & 0xff),
 526          ((status >> 3) & 0x1f),
 527          (status & PCI_PCIX_BRIDGE_STATUS_FUNCTION),
 528          FLAG(status, PCI_PCIX_BRIDGE_STATUS_64BIT),
 529          FLAG(status, PCI_PCIX_BRIDGE_STATUS_133MHZ),
 530          FLAG(status, PCI_PCIX_BRIDGE_STATUS_SC_DISCARDED),
 531          FLAG(status, PCI_PCIX_BRIDGE_STATUS_UNEXPECTED_SC),
 532          FLAG(status, PCI_PCIX_BRIDGE_STATUS_SC_OVERRUN),
 533          FLAG(status, PCI_PCIX_BRIDGE_STATUS_SPLIT_REQUEST_DELAYED));
 534   upstcr = get_conf_long(d, where + PCI_PCIX_BRIDGE_UPSTREAM_SPLIT_TRANS_CTRL);
 535   printf("\t\tUpstream: Capacity=%u CommitmentLimit=%u\n",
 536          (upstcr & PCI_PCIX_BRIDGE_STR_CAPACITY),
 537          (upstcr >> 16) & 0xffff);
 538   downstcr = get_conf_long(d, where + PCI_PCIX_BRIDGE_DOWNSTREAM_SPLIT_TRANS_CTRL);
 539   printf("\t\tDownstream: Capacity=%u CommitmentLimit=%u\n",
 540          (downstcr & PCI_PCIX_BRIDGE_STR_CAPACITY),
 541          (downstcr >> 16) & 0xffff);
 542 }
 543
 544 static void
 545 cap_pcix(struct device *d, int where)
 546 {
 547   switch (get_conf_byte(d, PCI_HEADER_TYPE) & 0x7f)
 548     {
 549     case PCI_HEADER_TYPE_NORMAL:
 550       cap_pcix_nobridge(d, where);
 551       break;
 552     case PCI_HEADER_TYPE_BRIDGE:
 553       cap_pcix_bridge(d, where);
 554       break;
 555     }
 556 }
 557
 558 static inline char *
 559 ht_link_width(unsigned width)
 560 {
 561   static char * const widths[8] = { "8bit", "16bit", "[2]", "32bit", "2bit", "4bit", "[6]", "N/C" };
 562   return widths[width];
 563 }
 564
 565 static inline char *
 566 ht_link_freq(unsigned freq)
 567 {
 568   static char * const freqs[16] = { "200MHz", "300MHz", "400MHz", "500MHz", "600MHz", "800MHz", "1.0GHz", "1.2GHz",
 569                                     "1.4GHz", "1.6GHz", "[a]", "[b]", "[c]", "[d]", "[e]", "Vend" };
 570   return freqs[freq];
 571 }
 572
 573 static void
 574 cap_ht_pri(struct device *d, int where, int cmd)
 575 {
 576   u16 lctr0, lcnf0, lctr1, lcnf1, eh;
 577   u8 rid, lfrer0, lfcap0, ftr, lfrer1, lfcap1, mbu, mlu, bn;
 578   char *fmt;
 579
 580   printf("HyperTransport: Slave or Primary Interface\n");
 581   if (verbose < 2)
 582     return;
 583
 584   if (!config_fetch(d, where + PCI_HT_PRI_LCTR0, PCI_HT_PRI_SIZEOF - PCI_HT_PRI_LCTR0))
 585     return;
 586   rid = get_conf_byte(d, where + PCI_HT_PRI_RID);
 587   if (rid < 0x22 && rid > 0x11)
 588     printf("\t\t!!! Possibly incomplete decoding\n");
 589
 590   if (rid >= 0x22)
 591     fmt = "\t\tCommand: BaseUnitID=%u UnitCnt=%u MastHost%c DefDir%c DUL%c\n";
 592   else
 593     fmt = "\t\tCommand: BaseUnitID=%u UnitCnt=%u MastHost%c DefDir%c\n";
 594   printf(fmt,
 595          (cmd & PCI_HT_PRI_CMD_BUID),
 596          (cmd & PCI_HT_PRI_CMD_UC) >> 5,
 597          FLAG(cmd, PCI_HT_PRI_CMD_MH),
 598          FLAG(cmd, PCI_HT_PRI_CMD_DD),
 599          FLAG(cmd, PCI_HT_PRI_CMD_DUL));
 600   lctr0 = get_conf_word(d, where + PCI_HT_PRI_LCTR0);
 601   if (rid >= 0x22)
 602     fmt = "\t\tLink Control 0: CFlE%c CST%c CFE%c <LkFail%c Init%c EOC%c TXO%c <CRCErr=%x IsocEn%c LSEn%c ExtCTL%c 64b%c\n";
 603   else
 604     fmt = "\t\tLink Control 0: CFlE%c CST%c CFE%c <LkFail%c Init%c EOC%c TXO%c <CRCErr=%x\n";
 605   printf(fmt,
 606          FLAG(lctr0, PCI_HT_LCTR_CFLE),
 607          FLAG(lctr0, PCI_HT_LCTR_CST),
 608          FLAG(lctr0, PCI_HT_LCTR_CFE),
 609          FLAG(lctr0, PCI_HT_LCTR_LKFAIL),
 610          FLAG(lctr0, PCI_HT_LCTR_INIT),
 611          FLAG(lctr0, PCI_HT_LCTR_EOC),
 612          FLAG(lctr0, PCI_HT_LCTR_TXO),
 613          (lctr0 & PCI_HT_LCTR_CRCERR) >> 8,
 614          FLAG(lctr0, PCI_HT_LCTR_ISOCEN),
 615          FLAG(lctr0, PCI_HT_LCTR_LSEN),
 616          FLAG(lctr0, PCI_HT_LCTR_EXTCTL),
 617          FLAG(lctr0, PCI_HT_LCTR_64B));
 618   lcnf0 = get_conf_word(d, where + PCI_HT_PRI_LCNF0);
 619   if (rid >= 0x22)
 620     fmt = "\t\tLink Config 0: MLWI=%1$s DwFcIn%5$c MLWO=%2$s DwFcOut%6$c LWI=%3$s DwFcInEn%7$c LWO=%4$s DwFcOutEn%8$c\n";
 621   else
 622     fmt = "\t\tLink Config 0: MLWI=%s MLWO=%s LWI=%s LWO=%s\n";
 623   printf(fmt,
 624          ht_link_width(lcnf0 & PCI_HT_LCNF_MLWI),
 625          ht_link_width((lcnf0 & PCI_HT_LCNF_MLWO) >> 4),
 626          ht_link_width((lcnf0 & PCI_HT_LCNF_LWI) >> 8),
 627          ht_link_width((lcnf0 & PCI_HT_LCNF_LWO) >> 12),
 628          FLAG(lcnf0, PCI_HT_LCNF_DFI),
 629          FLAG(lcnf0, PCI_HT_LCNF_DFO),
 630          FLAG(lcnf0, PCI_HT_LCNF_DFIE),
 631          FLAG(lcnf0, PCI_HT_LCNF_DFOE));
 632   lctr1 = get_conf_word(d, where + PCI_HT_PRI_LCTR1);
 633   if (rid >= 0x22)
 634     fmt = "\t\tLink Control 1: CFlE%c CST%c CFE%c <LkFail%c Init%c EOC%c TXO%c <CRCErr=%x IsocEn%c LSEn%c ExtCTL%c 64b%c\n";
 635   else
 636     fmt = "\t\tLink Control 1: CFlE%c CST%c CFE%c <LkFail%c Init%c EOC%c TXO%c <CRCErr=%x\n";
 637   printf(fmt,
 638          FLAG(lctr1, PCI_HT_LCTR_CFLE),
 639          FLAG(lctr1, PCI_HT_LCTR_CST),
 640          FLAG(lctr1, PCI_HT_LCTR_CFE),
 641          FLAG(lctr1, PCI_HT_LCTR_LKFAIL),
 642          FLAG(lctr1, PCI_HT_LCTR_INIT),
 643          FLAG(lctr1, PCI_HT_LCTR_EOC),
 644          FLAG(lctr1, PCI_HT_LCTR_TXO),
 645          (lctr1 & PCI_HT_LCTR_CRCERR) >> 8,
 646          FLAG(lctr1, PCI_HT_LCTR_ISOCEN),
 647          FLAG(lctr1, PCI_HT_LCTR_LSEN),
 648          FLAG(lctr1, PCI_HT_LCTR_EXTCTL),
 649          FLAG(lctr1, PCI_HT_LCTR_64B));
 650   lcnf1 = get_conf_word(d, where + PCI_HT_PRI_LCNF1);
 651   if (rid >= 0x22)
 652     fmt = "\t\tLink Config 1: MLWI=%1$s DwFcIn%5$c MLWO=%2$s DwFcOut%6$c LWI=%3$s DwFcInEn%7$c LWO=%4$s DwFcOutEn%8$c\n";
 653   else
 654     fmt = "\t\tLink Config 1: MLWI=%s MLWO=%s LWI=%s LWO=%s\n";
 655   printf(fmt,
 656          ht_link_width(lcnf1 & PCI_HT_LCNF_MLWI),
 657          ht_link_width((lcnf1 & PCI_HT_LCNF_MLWO) >> 4),
 658          ht_link_width((lcnf1 & PCI_HT_LCNF_LWI) >> 8),
 659          ht_link_width((lcnf1 & PCI_HT_LCNF_LWO) >> 12),
 660          FLAG(lcnf1, PCI_HT_LCNF_DFI),
 661          FLAG(lcnf1, PCI_HT_LCNF_DFO),
 662          FLAG(lcnf1, PCI_HT_LCNF_DFIE),
 663          FLAG(lcnf1, PCI_HT_LCNF_DFOE));
 664   printf("\t\tRevision ID: %u.%02u\n",
 665          (rid & PCI_HT_RID_MAJ) >> 5, (rid & PCI_HT_RID_MIN));
 666   if (rid < 0x22)
 667     return;
 668   lfrer0 = get_conf_byte(d, where + PCI_HT_PRI_LFRER0);
 669   printf("\t\tLink Frequency 0: %s\n", ht_link_freq(lfrer0 & PCI_HT_LFRER_FREQ));
 670   printf("\t\tLink Error 0: <Prot%c <Ovfl%c <EOC%c CTLTm%c\n",
 671          FLAG(lfrer0, PCI_HT_LFRER_PROT),
 672          FLAG(lfrer0, PCI_HT_LFRER_OV),
 673          FLAG(lfrer0, PCI_HT_LFRER_EOC),
 674          FLAG(lfrer0, PCI_HT_LFRER_CTLT));
 675   lfcap0 = get_conf_byte(d, where + PCI_HT_PRI_LFCAP0);
 676   printf("\t\tLink Frequency Capability 0: 200MHz%c 300MHz%c 400MHz%c 500MHz%c 600MHz%c 800MHz%c 1.0GHz%c 1.2GHz%c 1.4GHz%c 1.6GHz%c Vend%c\n",
 677          FLAG(lfcap0, PCI_HT_LFCAP_200),
 678          FLAG(lfcap0, PCI_HT_LFCAP_300),
 679          FLAG(lfcap0, PCI_HT_LFCAP_400),
 680          FLAG(lfcap0, PCI_HT_LFCAP_500),
 681          FLAG(lfcap0, PCI_HT_LFCAP_600),
 682          FLAG(lfcap0, PCI_HT_LFCAP_800),
 683          FLAG(lfcap0, PCI_HT_LFCAP_1000),
 684          FLAG(lfcap0, PCI_HT_LFCAP_1200),
 685          FLAG(lfcap0, PCI_HT_LFCAP_1400),
 686          FLAG(lfcap0, PCI_HT_LFCAP_1600),
 687          FLAG(lfcap0, PCI_HT_LFCAP_VEND));
 688   ftr = get_conf_byte(d, where + PCI_HT_PRI_FTR);
 689   printf("\t\tFeature Capability: IsocFC%c LDTSTOP%c CRCTM%c ECTLT%c 64bA%c UIDRD%c\n",
 690          FLAG(ftr, PCI_HT_FTR_ISOCFC),
 691          FLAG(ftr, PCI_HT_FTR_LDTSTOP),
 692          FLAG(ftr, PCI_HT_FTR_CRCTM),
 693          FLAG(ftr, PCI_HT_FTR_ECTLT),
 694          FLAG(ftr, PCI_HT_FTR_64BA),
 695          FLAG(ftr, PCI_HT_FTR_UIDRD));
 696   lfrer1 = get_conf_byte(d, where + PCI_HT_PRI_LFRER1);
 697   printf("\t\tLink Frequency 1: %s\n", ht_link_freq(lfrer1 & PCI_HT_LFRER_FREQ));
 698   printf("\t\tLink Error 1: <Prot%c <Ovfl%c <EOC%c CTLTm%c\n",
 699          FLAG(lfrer1, PCI_HT_LFRER_PROT),
 700          FLAG(lfrer1, PCI_HT_LFRER_OV),
 701          FLAG(lfrer1, PCI_HT_LFRER_EOC),
 702          FLAG(lfrer1, PCI_HT_LFRER_CTLT));
 703   lfcap1 = get_conf_byte(d, where + PCI_HT_PRI_LFCAP1);
 704   printf("\t\tLink Frequency Capability 1: 200MHz%c 300MHz%c 400MHz%c 500MHz%c 600MHz%c 800MHz%c 1.0GHz%c 1.2GHz%c 1.4GHz%c 1.6GHz%c Vend%c\n",
 705          FLAG(lfcap1, PCI_HT_LFCAP_200),
 706          FLAG(lfcap1, PCI_HT_LFCAP_300),
 707          FLAG(lfcap1, PCI_HT_LFCAP_400),
 708          FLAG(lfcap1, PCI_HT_LFCAP_500),
 709          FLAG(lfcap1, PCI_HT_LFCAP_600),
 710          FLAG(lfcap1, PCI_HT_LFCAP_800),
 711          FLAG(lfcap1, PCI_HT_LFCAP_1000),
 712          FLAG(lfcap1, PCI_HT_LFCAP_1200),
 713          FLAG(lfcap1, PCI_HT_LFCAP_1400),
 714          FLAG(lfcap1, PCI_HT_LFCAP_1600),
 715          FLAG(lfcap1, PCI_HT_LFCAP_VEND));
 716   eh = get_conf_word(d, where + PCI_HT_PRI_EH);
 717   printf("\t\tError Handling: PFlE%c OFlE%c PFE%c OFE%c EOCFE%c RFE%c CRCFE%c SERRFE%c CF%c RE%c PNFE%c ONFE%c EOCNFE%c RNFE%c CRCNFE%c SERRNFE%c\n",
 718          FLAG(eh, PCI_HT_EH_PFLE),
 719          FLAG(eh, PCI_HT_EH_OFLE),
 720          FLAG(eh, PCI_HT_EH_PFE),
 721          FLAG(eh, PCI_HT_EH_OFE),
 722          FLAG(eh, PCI_HT_EH_EOCFE),
 723          FLAG(eh, PCI_HT_EH_RFE),
 724          FLAG(eh, PCI_HT_EH_CRCFE),
 725          FLAG(eh, PCI_HT_EH_SERRFE),
 726          FLAG(eh, PCI_HT_EH_CF),
 727          FLAG(eh, PCI_HT_EH_RE),
 728          FLAG(eh, PCI_HT_EH_PNFE),
 729          FLAG(eh, PCI_HT_EH_ONFE),
 730          FLAG(eh, PCI_HT_EH_EOCNFE),
 731          FLAG(eh, PCI_HT_EH_RNFE),
 732          FLAG(eh, PCI_HT_EH_CRCNFE),
 733          FLAG(eh, PCI_HT_EH_SERRNFE));
 734   mbu = get_conf_byte(d, where + PCI_HT_PRI_MBU);
 735   mlu = get_conf_byte(d, where + PCI_HT_PRI_MLU);
 736   printf("\t\tPrefetchable memory behind bridge Upper: %02x-%02x\n", mbu, mlu);
 737   bn = get_conf_byte(d, where + PCI_HT_PRI_BN);
 738   printf("\t\tBus Number: %02x\n", bn);
 739 }
 740
 741 static void
 742 cap_ht_sec(struct device *d, int where, int cmd)
 743 {
 744   u16 lctr, lcnf, ftr, eh;
 745   u8 rid, lfrer, lfcap, mbu, mlu;
 746   char *fmt;
 747
 748   printf("HyperTransport: Host or Secondary Interface\n");
 749   if (verbose < 2)
 750     return;
 751
 752   if (!config_fetch(d, where + PCI_HT_SEC_LCTR, PCI_HT_SEC_SIZEOF - PCI_HT_SEC_LCTR))
 753     return;
 754   rid = get_conf_byte(d, where + PCI_HT_SEC_RID);
 755   if (rid < 0x22 && rid > 0x11)
 756     printf("\t\t!!! Possibly incomplete decoding\n");
 757
 758   if (rid >= 0x22)
 759     fmt = "\t\tCommand: WarmRst%c DblEnd%c DevNum=%u ChainSide%c HostHide%c Slave%c <EOCErr%c DUL%c\n";
 760   else
 761     fmt = "\t\tCommand: WarmRst%c DblEnd%c\n";
 762   printf(fmt,
 763          FLAG(cmd, PCI_HT_SEC_CMD_WR),
 764          FLAG(cmd, PCI_HT_SEC_CMD_DE),
 765          (cmd & PCI_HT_SEC_CMD_DN) >> 2,
 766          FLAG(cmd, PCI_HT_SEC_CMD_CS),
 767          FLAG(cmd, PCI_HT_SEC_CMD_HH),
 768          FLAG(cmd, PCI_HT_SEC_CMD_AS),
 769          FLAG(cmd, PCI_HT_SEC_CMD_HIECE),
 770          FLAG(cmd, PCI_HT_SEC_CMD_DUL));
 771   lctr = get_conf_word(d, where + PCI_HT_SEC_LCTR);
 772   if (rid >= 0x22)
 773     fmt = "\t\tLink Control: CFlE%c CST%c CFE%c <LkFail%c Init%c EOC%c TXO%c <CRCErr=%x IsocEn%c LSEn%c ExtCTL%c 64b%c\n";
 774   else
 775     fmt = "\t\tLink Control: CFlE%c CST%c CFE%c <LkFail%c Init%c EOC%c TXO%c <CRCErr=%x\n";
 776   printf(fmt,
 777          FLAG(lctr, PCI_HT_LCTR_CFLE),
 778          FLAG(lctr, PCI_HT_LCTR_CST),
 779          FLAG(lctr, PCI_HT_LCTR_CFE),
 780          FLAG(lctr, PCI_HT_LCTR_LKFAIL),
 781          FLAG(lctr, PCI_HT_LCTR_INIT),
 782          FLAG(lctr, PCI_HT_LCTR_EOC),
 783          FLAG(lctr, PCI_HT_LCTR_TXO),
 784          (lctr & PCI_HT_LCTR_CRCERR) >> 8,
 785          FLAG(lctr, PCI_HT_LCTR_ISOCEN),
 786          FLAG(lctr, PCI_HT_LCTR_LSEN),
 787          FLAG(lctr, PCI_HT_LCTR_EXTCTL),
 788          FLAG(lctr, PCI_HT_LCTR_64B));
 789   lcnf = get_conf_word(d, where + PCI_HT_SEC_LCNF);
 790   if (rid >= 0x22)
 791     fmt = "\t\tLink Config: MLWI=%1$s DwFcIn%5$c MLWO=%2$s DwFcOut%6$c LWI=%3$s DwFcInEn%7$c LWO=%4$s DwFcOutEn%8$c\n";
 792   else
 793     fmt = "\t\tLink Config: MLWI=%s MLWO=%s LWI=%s LWO=%s\n";
 794   printf(fmt,
 795          ht_link_width(lcnf & PCI_HT_LCNF_MLWI),
 796          ht_link_width((lcnf & PCI_HT_LCNF_MLWO) >> 4),
 797          ht_link_width((lcnf & PCI_HT_LCNF_LWI) >> 8),
 798          ht_link_width((lcnf & PCI_HT_LCNF_LWO) >> 12),
 799          FLAG(lcnf, PCI_HT_LCNF_DFI),
 800          FLAG(lcnf, PCI_HT_LCNF_DFO),
 801          FLAG(lcnf, PCI_HT_LCNF_DFIE),
 802          FLAG(lcnf, PCI_HT_LCNF_DFOE));
 803   printf("\t\tRevision ID: %u.%02u\n",
 804          (rid & PCI_HT_RID_MAJ) >> 5, (rid & PCI_HT_RID_MIN));
 805   if (rid < 0x22)
 806     return;
 807   lfrer = get_conf_byte(d, where + PCI_HT_SEC_LFRER);
 808   printf("\t\tLink Frequency: %s\n", ht_link_freq(lfrer & PCI_HT_LFRER_FREQ));
 809   printf("\t\tLink Error: <Prot%c <Ovfl%c <EOC%c CTLTm%c\n",
 810          FLAG(lfrer, PCI_HT_LFRER_PROT),
 811          FLAG(lfrer, PCI_HT_LFRER_OV),
 812          FLAG(lfrer, PCI_HT_LFRER_EOC),
 813          FLAG(lfrer, PCI_HT_LFRER_CTLT));
 814   lfcap = get_conf_byte(d, where + PCI_HT_SEC_LFCAP);
 815   printf("\t\tLink Frequency Capability: 200MHz%c 300MHz%c 400MHz%c 500MHz%c 600MHz%c 800MHz%c 1.0GHz%c 1.2GHz%c 1.4GHz%c 1.6GHz%c Vend%c\n",
 816          FLAG(lfcap, PCI_HT_LFCAP_200),
 817          FLAG(lfcap, PCI_HT_LFCAP_300),
 818          FLAG(lfcap, PCI_HT_LFCAP_400),
 819          FLAG(lfcap, PCI_HT_LFCAP_500),
 820          FLAG(lfcap, PCI_HT_LFCAP_600),
 821          FLAG(lfcap, PCI_HT_LFCAP_800),
 822          FLAG(lfcap, PCI_HT_LFCAP_1000),
 823          FLAG(lfcap, PCI_HT_LFCAP_1200),
 824          FLAG(lfcap, PCI_HT_LFCAP_1400),
 825          FLAG(lfcap, PCI_HT_LFCAP_1600),
 826          FLAG(lfcap, PCI_HT_LFCAP_VEND));
 827   ftr = get_conf_word(d, where + PCI_HT_SEC_FTR);
 828   printf("\t\tFeature Capability: IsocFC%c LDTSTOP%c CRCTM%c ECTLT%c 64bA%c UIDRD%c ExtRS%c UCnfE%c\n",
 829          FLAG(ftr, PCI_HT_FTR_ISOCFC),
 830          FLAG(ftr, PCI_HT_FTR_LDTSTOP),
 831          FLAG(ftr, PCI_HT_FTR_CRCTM),
 832          FLAG(ftr, PCI_HT_FTR_ECTLT),
 833          FLAG(ftr, PCI_HT_FTR_64BA),
 834          FLAG(ftr, PCI_HT_FTR_UIDRD),
 835          FLAG(ftr, PCI_HT_SEC_FTR_EXTRS),
 836          FLAG(ftr, PCI_HT_SEC_FTR_UCNFE));
 837   if (ftr & PCI_HT_SEC_FTR_EXTRS)
 838     {
 839       eh = get_conf_word(d, where + PCI_HT_SEC_EH);
 840       printf("\t\tError Handling: PFlE%c OFlE%c PFE%c OFE%c EOCFE%c RFE%c CRCFE%c SERRFE%c CF%c RE%c PNFE%c ONFE%c EOCNFE%c RNFE%c CRCNFE%c SERRNFE%c\n",
 841              FLAG(eh, PCI_HT_EH_PFLE),
 842              FLAG(eh, PCI_HT_EH_OFLE),
 843              FLAG(eh, PCI_HT_EH_PFE),
 844              FLAG(eh, PCI_HT_EH_OFE),
 845              FLAG(eh, PCI_HT_EH_EOCFE),
 846              FLAG(eh, PCI_HT_EH_RFE),
 847              FLAG(eh, PCI_HT_EH_CRCFE),
 848              FLAG(eh, PCI_HT_EH_SERRFE),
 849              FLAG(eh, PCI_HT_EH_CF),
 850              FLAG(eh, PCI_HT_EH_RE),
 851              FLAG(eh, PCI_HT_EH_PNFE),
 852              FLAG(eh, PCI_HT_EH_ONFE),
 853              FLAG(eh, PCI_HT_EH_EOCNFE),
 854              FLAG(eh, PCI_HT_EH_RNFE),
 855              FLAG(eh, PCI_HT_EH_CRCNFE),
 856              FLAG(eh, PCI_HT_EH_SERRNFE));
 857       mbu = get_conf_byte(d, where + PCI_HT_SEC_MBU);
 858       mlu = get_conf_byte(d, where + PCI_HT_SEC_MLU);
 859       printf("\t\tPrefetchable memory behind bridge Upper: %02x-%02x\n", mbu, mlu);
 860     }
 861 }
 862
 863 static void
 864 cap_ht(struct device *d, int where, int cmd)
 865 {
 866   int type;
 867
 868   switch (cmd & PCI_HT_CMD_TYP_HI)
 869     {
 870     case PCI_HT_CMD_TYP_HI_PRI:
 871       cap_ht_pri(d, where, cmd);
 872       return;
 873     case PCI_HT_CMD_TYP_HI_SEC:
 874       cap_ht_sec(d, where, cmd);
 875       return;
 876     }
 877
 878   type = cmd & PCI_HT_CMD_TYP;
 879   switch (type)
 880     {
 881     case PCI_HT_CMD_TYP_SW:
 882       printf("HyperTransport: Switch\n");
 883       break;
 884     case PCI_HT_CMD_TYP_IDC:
 885       printf("HyperTransport: Interrupt Discovery and Configuration\n");
 886       break;
 887     case PCI_HT_CMD_TYP_RID:
 888       printf("HyperTransport: Revision ID: %u.%02u\n",
 889              (cmd & PCI_HT_RID_MAJ) >> 5, (cmd & PCI_HT_RID_MIN));
 890       break;
 891     case PCI_HT_CMD_TYP_UIDC:
 892       printf("HyperTransport: UnitID Clumping\n");
 893       break;
 894     case PCI_HT_CMD_TYP_ECSA:
 895       printf("HyperTransport: Extended Configuration Space Access\n");
 896       break;
 897     case PCI_HT_CMD_TYP_AM:
 898       printf("HyperTransport: Address Mapping\n");
 899       break;
 900     case PCI_HT_CMD_TYP_MSIM:
 901       printf("HyperTransport: MSI Mapping Enable%c Fixed%c\n",
 902              FLAG(cmd, PCI_HT_MSIM_CMD_EN),
 903              FLAG(cmd, PCI_HT_MSIM_CMD_FIXD));
 904       if (verbose >= 2 && !(cmd & PCI_HT_MSIM_CMD_FIXD))
 905         {
 906           u32 offl, offh;
 907           if (!config_fetch(d, where + PCI_HT_MSIM_ADDR_LO, 8))
 908             break;
 909           offl = get_conf_long(d, where + PCI_HT_MSIM_ADDR_LO);
 910           offh = get_conf_long(d, where + PCI_HT_MSIM_ADDR_HI);
 911           printf("\t\tMapping Address Base: %016llx\n", ((unsigned long long)offh << 32) | (offl & ~0xfffff));
 912         }
 913       break;
 914     case PCI_HT_CMD_TYP_DR:
 915       printf("HyperTransport: DirectRoute\n");
 916       break;
 917     case PCI_HT_CMD_TYP_VCS:
 918       printf("HyperTransport: VCSet\n");
 919       break;
 920     case PCI_HT_CMD_TYP_RM:
 921       printf("HyperTransport: Retry Mode\n");
 922       break;
 923     case PCI_HT_CMD_TYP_X86:
 924       printf("HyperTransport: X86 (reserved)\n");
 925       break;
 926     default:
 927       printf("HyperTransport: #%02x\n", type >> 11);
 928     }
 929 }
 930
 931 static void
 932 cap_msi(struct device *d, int where, int cap)
 933 {
 934   int is64;
 935   u32 t;
 936   u16 w;
 937
 938   printf("MSI: Mask%c 64bit%c Count=%d/%d Enable%c\n",
 939          FLAG(cap, PCI_MSI_FLAGS_MASK_BIT),
 940          FLAG(cap, PCI_MSI_FLAGS_64BIT),
 941          1 << ((cap & PCI_MSI_FLAGS_QSIZE) >> 4),
 942          1 << ((cap & PCI_MSI_FLAGS_QMASK) >> 1),
 943          FLAG(cap, PCI_MSI_FLAGS_ENABLE));
 944   if (verbose < 2)
 945     return;
 946   is64 = cap & PCI_MSI_FLAGS_64BIT;
 947   if (!config_fetch(d, where + PCI_MSI_ADDRESS_LO, (is64 ? PCI_MSI_DATA_64 : PCI_MSI_DATA_32) + 2 - PCI_MSI_ADDRESS_LO))
 948     return;
 949   printf("\t\tAddress: ");
 950   if (is64)
 951     {
 952       t = get_conf_long(d, where + PCI_MSI_ADDRESS_HI);
 953       w = get_conf_word(d, where + PCI_MSI_DATA_64);
 954       printf("%08x", t);
 955     }
 956   else
 957     w = get_conf_word(d, where + PCI_MSI_DATA_32);
 958   t = get_conf_long(d, where + PCI_MSI_ADDRESS_LO);
 959   printf("%08x  Data: %04x\n", t, w);
 960   if (cap & PCI_MSI_FLAGS_MASK_BIT)
 961     {
 962       u32 mask, pending;
 963
 964       if (is64)
 965         {
 966           if (!config_fetch(d, where + PCI_MSI_MASK_BIT_64, 8))
 967             return;
 968           mask = get_conf_long(d, where + PCI_MSI_MASK_BIT_64);
 969           pending = get_conf_long(d, where + PCI_MSI_PENDING_64);
 970         }
 971       else
 972         {
 973           if (!config_fetch(d, where + PCI_MSI_MASK_BIT_32, 8))
 974             return;
 975           mask = get_conf_long(d, where + PCI_MSI_MASK_BIT_32);
 976           pending = get_conf_long(d, where + PCI_MSI_PENDING_32);
 977         }
 978       printf("\t\tMasking: %08x  Pending: %08x\n", mask, pending);
 979     }
 980 }
 981
 982 static float power_limit(int value, int scale)
 983 {
 984   static const float scales[4] = { 1.0, 0.1, 0.01, 0.001 };
 985   return value * scales[scale];
 986 }
 987
 988 static const char *latency_l0s(int value)
 989 {
 990   static const char *latencies[] = { "<64ns", "<128ns", "<256ns", "<512ns", "<1us", "<2us", "<4us", "unlimited" };
 991   return latencies[value];
 992 }
 993
 994 static const char *latency_l1(int value)
 995 {
 996   static const char *latencies[] = { "<1us", "<2us", "<4us", "<8us", "<16us", "<32us", "<64us", "unlimited" };
 997   return latencies[value];
 998 }
 999
1000 static void cap_express_dev(struct device *d, int where, int type)
1001 {
1002   u32 t;
1003   u16 w;
1004
1005   t = get_conf_long(d, where + PCI_EXP_DEVCAP);
1006   printf("\t\tDevCap:\tMaxPayload %d bytes, PhantFunc %d, Latency L0s %s, L1 %s\n",
1007         128 << (t & PCI_EXP_DEVCAP_PAYLOAD),
1008         (1 << ((t & PCI_EXP_DEVCAP_PHANTOM) >> 3)) - 1,
1009         latency_l0s((t & PCI_EXP_DEVCAP_L0S) >> 6),
1010         latency_l1((t & PCI_EXP_DEVCAP_L1) >> 9));
1011   printf("\t\t\tExtTag%c", FLAG(t, PCI_EXP_DEVCAP_EXT_TAG));
1012   if ((type == PCI_EXP_TYPE_ENDPOINT) || (type == PCI_EXP_TYPE_LEG_END) ||
1013       (type == PCI_EXP_TYPE_UPSTREAM) || (type == PCI_EXP_TYPE_PCI_BRIDGE))
1014     printf(" AttnBtn%c AttnInd%c PwrInd%c",
1015         FLAG(t, PCI_EXP_DEVCAP_ATN_BUT),
1016         FLAG(t, PCI_EXP_DEVCAP_ATN_IND), FLAG(t, PCI_EXP_DEVCAP_PWR_IND));
1017   printf(" RBE%c FLReset%c",
1018         FLAG(t, PCI_EXP_DEVCAP_RBE),
1019         FLAG(t, PCI_EXP_DEVCAP_FLRESET));
1020   if (type == PCI_EXP_TYPE_UPSTREAM)
1021     printf("SlotPowerLimit %fW",
1022         power_limit((t & PCI_EXP_DEVCAP_PWR_VAL) >> 18,
1023                     (t & PCI_EXP_DEVCAP_PWR_SCL) >> 26));
1024   printf("\n");
1025
1026   w = get_conf_word(d, where + PCI_EXP_DEVCTL);
1027   printf("\t\tDevCtl:\tReport errors: Correctable%c Non-Fatal%c Fatal%c Unsupported%c\n",
1028         FLAG(w, PCI_EXP_DEVCTL_CERE),
1029         FLAG(w, PCI_EXP_DEVCTL_NFERE),
1030         FLAG(w, PCI_EXP_DEVCTL_FERE),
1031         FLAG(w, PCI_EXP_DEVCTL_URRE));
1032   printf("\t\t\tRlxdOrd%c ExtTag%c PhantFunc%c AuxPwr%c NoSnoop%c",
1033         FLAG(w, PCI_EXP_DEVCTL_RELAXED),
1034         FLAG(w, PCI_EXP_DEVCTL_EXT_TAG),
1035         FLAG(w, PCI_EXP_DEVCTL_PHANTOM),
1036         FLAG(w, PCI_EXP_DEVCTL_AUX_PME),
1037         FLAG(w, PCI_EXP_DEVCTL_NOSNOOP));
1038   if (type == PCI_EXP_TYPE_PCI_BRIDGE || type == PCI_EXP_TYPE_PCIE_BRIDGE)
1039     printf(" BrConfRtry%c", FLAG(w, PCI_EXP_DEVCTL_BCRE));
1040   if (type == PCI_EXP_TYPE_ENDPOINT && (t & PCI_EXP_DEVCAP_FLRESET))
1041     printf(" FLReset%c", FLAG(w, PCI_EXP_DEVCTL_FLRESET));
1042   printf("\n\t\t\tMaxPayload %d bytes, MaxReadReq %d bytes\n",
1043         128 << ((w & PCI_EXP_DEVCTL_PAYLOAD) >> 5),
1044         128 << ((w & PCI_EXP_DEVCTL_READRQ) >> 12));
1045
1046   w = get_conf_word(d, where + PCI_EXP_DEVSTA);
1047   printf("\t\tDevSta:\tCorrErr%c UncorrErr%c FatalErr%c UnsuppReq%c AuxPwr%c TransPend%c\n",
1048         FLAG(w, PCI_EXP_DEVSTA_CED),
1049         FLAG(w, PCI_EXP_DEVSTA_NFED),
1050         FLAG(w, PCI_EXP_DEVSTA_FED),
1051         FLAG(w, PCI_EXP_DEVSTA_URD),
1052         FLAG(w, PCI_EXP_DEVSTA_AUXPD),
1053         FLAG(w, PCI_EXP_DEVSTA_TRPND));
1054 }
1055
1056 static char *link_speed(int speed)
1057 {
1058   switch (speed)
1059     {
1060       case 1:
1061         return "2.5GT/s";
1062       case 2:
1063         return "5GT/s";
1064       default:
1065         return "unknown";
1066     }
1067 }
1068
1069 static char *aspm_support(int code)
1070 {
1071   switch (code)
1072     {
1073       case 1:
1074         return "L0s";
1075       case 3:
1076         return "L0s L1";
1077       default:
1078         return "unknown";
1079     }
1080 }
1081
1082 static const char *aspm_enabled(int code)
1083 {
1084   static const char *desc[] = { "Disabled", "L0s Enabled", "L1 Enabled", "L0s L1 Enabled" };
1085   return desc[code];
1086 }
1087
1088 static void cap_express_link(struct device *d, int where, int type)
1089 {
1090   u32 t;
1091   u16 w;
1092
1093   t = get_conf_long(d, where + PCI_EXP_LNKCAP);
1094   printf("\t\tLnkCap:\tPort #%d, Speed %s, Width x%d, ASPM %s, Latency L0 %s, L1 %s\n",
1095         t >> 24,
1096         link_speed(t & PCI_EXP_LNKCAP_SPEED), (t & PCI_EXP_LNKCAP_WIDTH) >> 4,
1097         aspm_support((t & PCI_EXP_LNKCAP_ASPM) >> 10),
1098         latency_l0s((t & PCI_EXP_LNKCAP_L0S) >> 12),
1099         latency_l1((t & PCI_EXP_LNKCAP_L1) >> 15));
1100   printf("\t\t\tClockPM%c Suprise%c LLActRep%c BwNot%c\n",
1101         FLAG(t, PCI_EXP_LNKCAP_CLOCKPM),
1102         FLAG(t, PCI_EXP_LNKCAP_SURPRISE),
1103         FLAG(t, PCI_EXP_LNKCAP_DLLA),
1104         FLAG(t, PCI_EXP_LNKCAP_LBNC));
1105
1106   w = get_conf_word(d, where + PCI_EXP_LNKCTL);
1107   printf("\t\tLnkCtl:\tASPM %s;", aspm_enabled(w & PCI_EXP_LNKCTL_ASPM));
1108   if ((type == PCI_EXP_TYPE_ROOT_PORT) || (type == PCI_EXP_TYPE_ENDPOINT) ||
1109       (type == PCI_EXP_TYPE_LEG_END))
1110     printf(" RCB %d bytes", w & PCI_EXP_LNKCTL_RCB ? 128 : 64);
1111   printf(" Disabled%c Retrain%c CommClk%c\n\t\t\tExtSynch%c ClockPM%c AutWidDis%c BWInt%c AutBWInt%c\n",
1112         FLAG(w, PCI_EXP_LNKCTL_DISABLE),
1113         FLAG(w, PCI_EXP_LNKCTL_RETRAIN),
1114         FLAG(w, PCI_EXP_LNKCTL_CLOCK),
1115         FLAG(w, PCI_EXP_LNKCTL_XSYNCH),
1116         FLAG(w, PCI_EXP_LNKCTL_CLOCKPM),
1117         FLAG(w, PCI_EXP_LNKCTL_HWAUTWD),
1118         FLAG(w, PCI_EXP_LNKCTL_BWMIE),
1119         FLAG(w, PCI_EXP_LNKCTL_AUTBWIE));
1120
1121   w = get_conf_word(d, where + PCI_EXP_LNKSTA);
1122   printf("\t\tLnkSta:\tSpeed %s, Width x%d, TrErr%c Train%c SlotClk%c DLActive%c BWMgmt%c ABWMgmt%c\n",
1123         link_speed(w & PCI_EXP_LNKSTA_SPEED),
1124         (w & PCI_EXP_LNKSTA_WIDTH) >> 4,
1125         FLAG(w, PCI_EXP_LNKSTA_TR_ERR),
1126         FLAG(w, PCI_EXP_LNKSTA_TRAIN),
1127         FLAG(w, PCI_EXP_LNKSTA_SL_CLK),
1128         FLAG(w, PCI_EXP_LNKSTA_DL_ACT),
1129         FLAG(w, PCI_EXP_LNKSTA_BWMGMT),
1130         FLAG(w, PCI_EXP_LNKSTA_AUTBW));
1131 }
1132
1133 static const char *indicator(int code)
1134 {
1135   static const char *names[] = { "Unknown", "On", "Blink", "Off" };
1136   return names[code];
1137 }
1138
1139 static void cap_express_slot(struct device *d, int where)
1140 {
1141   u32 t;
1142   u16 w;
1143
1144   t = get_conf_long(d, where + PCI_EXP_SLTCAP);
1145   printf("\t\tSltCap:\tAttnBtn%c PwrCtrl%c MRL%c AttnInd%c PwrInd%c HotPlug%c Surpise%c\n",
1146         FLAG(t, PCI_EXP_SLTCAP_ATNB),
1147         FLAG(t, PCI_EXP_SLTCAP_PWRC),
1148         FLAG(t, PCI_EXP_SLTCAP_MRL),
1149         FLAG(t, PCI_EXP_SLTCAP_ATNI),
1150         FLAG(t, PCI_EXP_SLTCAP_PWRI),
1151         FLAG(t, PCI_EXP_SLTCAP_HPC),
1152         FLAG(t, PCI_EXP_SLTCAP_HPS));
1153   printf("\t\t\tSlot #%3x, PowerLimit %f; Interlock%c NoCompl%c\n",
1154         t >> 19,
1155         power_limit((t & PCI_EXP_SLTCAP_PWR_VAL) >> 7, (t & PCI_EXP_SLTCAP_PWR_SCL) >> 15),
1156         FLAG(t, PCI_EXP_SLTCAP_INTERLOCK),
1157         FLAG(t, PCI_EXP_SLTCAP_NOCMDCOMP));
1158
1159   w = get_conf_word(d, where + PCI_EXP_SLTCTL);
1160   printf("\t\tSltCtl:\tEnable: AttnBtn%c PwrFlt%c MRL%c PresDet%c CmdCplt%c HPIrq%c LinkChg%c\n",
1161         FLAG(w, PCI_EXP_SLTCTL_ATNB),
1162         FLAG(w, PCI_EXP_SLTCTL_PWRF),
1163         FLAG(w, PCI_EXP_SLTCTL_MRLS),
1164         FLAG(w, PCI_EXP_SLTCTL_PRSD),
1165         FLAG(w, PCI_EXP_SLTCTL_CMDC),
1166         FLAG(w, PCI_EXP_SLTCTL_HPIE),
1167         FLAG(w, PCI_EXP_SLTCTL_LLCHG));
1168   printf("\t\t\tControl: AttnInd %s, PwrInd %s, Power%c Interlock%c\n",
1169         indicator((w & PCI_EXP_SLTCTL_ATNI) >> 6),
1170         indicator((w & PCI_EXP_SLTCTL_PWRI) >> 8),
1171         FLAG(w, PCI_EXP_SLTCTL_PWRC),
1172         FLAG(w, PCI_EXP_SLTCTL_INTERLOCK));
1173
1174   w = get_conf_word(d, where + PCI_EXP_SLTSTA);
1175   printf("\t\tSltSta:\tStatus: AttnBtn%c PowerFlt%c MRL%c CmdCplt%c PresDet%c Interlock%c\n",
1176         FLAG(w, PCI_EXP_SLTSTA_ATNB),
1177         FLAG(w, PCI_EXP_SLTSTA_PWRF),
1178         FLAG(w, PCI_EXP_SLTSTA_MRL_ST),
1179         FLAG(w, PCI_EXP_SLTSTA_CMDC),
1180         FLAG(w, PCI_EXP_SLTSTA_PRES),
1181         FLAG(w, PCI_EXP_SLTSTA_INTERLOCK));
1182   printf("\t\t\tChanged: MRL%c PresDet%c LinkState%c\n",
1183         FLAG(w, PCI_EXP_SLTSTA_MRLS),
1184         FLAG(w, PCI_EXP_SLTSTA_PRSD),
1185         FLAG(w, PCI_EXP_SLTSTA_LLCHG));
1186 }
1187
1188 static void cap_express_root(struct device *d, int where)
1189 {
1190   u32 w = get_conf_word(d, where + PCI_EXP_RTCTL);
1191   printf("\t\tRootCtl: ErrCorrectable%c ErrNon-Fatal%c ErrFatal%c PMEIntEna%c CRSVisible%c\n",
1192         FLAG(w, PCI_EXP_RTCTL_SECEE),
1193         FLAG(w, PCI_EXP_RTCTL_SENFEE),
1194         FLAG(w, PCI_EXP_RTCTL_SEFEE),
1195         FLAG(w, PCI_EXP_RTCTL_PMEIE),
1196         FLAG(w, PCI_EXP_RTCTL_CRSVIS));
1197
1198   w = get_conf_word(d, where + PCI_EXP_RTCAP);
1199   printf("\t\tRootCap: CRSVisible%c\n",
1200         FLAG(w, PCI_EXP_RTCAP_CRSVIS));
1201
1202   w = get_conf_word(d, where + PCI_EXP_RTSTA);
1203   printf("\t\tRootSta: PME ReqID %04x, PMEStatus%c PMEPending%c\n",
1204         w & PCI_EXP_RTSTA_PME_REQID,
1205         FLAG(w, PCI_EXP_RTSTA_PME_STATUS),
1206         FLAG(w, PCI_EXP_RTSTA_PME_PENDING));
1207 }
1208
1209 static const char *cap_express_dev2_timeout_range(int type)
1210 {
1211   /* Decode Completion Timeout Ranges. */
1212   switch (type)
1213     {
1214       case 0:
1215         return "Not Supported";
1216       case 1:
1217         return "Range A";
1218       case 2:
1219         return "Range B";
1220       case 3:
1221         return "Range AB";
1222       case 6:
1223         return "Range BC";
1224       case 7:
1225         return "Range ABC";
1226       case 14:
1227         return "Range BCD";
1228       case 15:
1229         return "Range ABCD";
1230       default:
1231         return "Unknown";
1232     }
1233 }
1234
1235 static const char *cap_express_dev2_timeout_value(int type)
1236 {
1237   /* Decode Completion Timeout Value. */
1238   switch (type)
1239     {
1240       case 0:
1241         return "50us to 50ms";
1242       case 1:
1243         return "50us to 100us";
1244       case 2:
1245         return "1ms to 10ms";
1246       case 5:
1247         return "16ms to 55ms";
1248       case 6:
1249         return "65ms to 210ms";
1250       case 9:
1251         return "260ms to 900ms";
1252       case 10:
1253         return "1s to 3.5s";
1254       case 13:
1255         return "4s to 13s";
1256       case 14:
1257         return "17s to 64s";
1258       default:
1259         return "Unknown";
1260     }
1261 }
1262
1263 static void cap_express_dev2(struct device *d, int where, int type)
1264 {
1265   u32 l;
1266   u16 w;
1267
1268   l = get_conf_long(d, where + PCI_EXP_DEVCAP2);
1269   printf("\t\tDevCap2: Completion Timeout: %s, TimeoutDis%c",
1270         cap_express_dev2_timeout_range(PCI_EXP_DEV2_TIMEOUT_RANGE(l)),
1271         FLAG(l, PCI_EXP_DEV2_TIMEOUT_DIS));
1272   if (type == PCI_EXP_TYPE_ROOT_PORT || type == PCI_EXP_TYPE_DOWNSTREAM)
1273     printf(" ARIFwd%c\n", FLAG(l, PCI_EXP_DEV2_ARI));
1274   else
1275     printf("\n");
1276
1277   w = get_conf_word(d, where + PCI_EXP_DEVCTL2);
1278   printf("\t\tDevCtl2: Completion Timeout: %s, TimeoutDis%c",
1279         cap_express_dev2_timeout_value(PCI_EXP_DEV2_TIMEOUT_VALUE(w)),
1280         FLAG(w, PCI_EXP_DEV2_TIMEOUT_DIS));
1281   if (type == PCI_EXP_TYPE_ROOT_PORT || type == PCI_EXP_TYPE_DOWNSTREAM)
1282     printf(" ARIFwd%c\n", FLAG(w, PCI_EXP_DEV2_ARI));
1283   else
1284     printf("\n");
1285 }
1286
1287 static const char *cap_express_link2_speed(int type)
1288 {
1289   switch (type)
1290     {
1291       case 0: /* hardwire to 0 means only the 2.5GT/s is supported */
1292       case 1:
1293         return "2.5GT/s";
1294       case 2:
1295         return "5GT/s";
1296       default:
1297         return "Unknown";
1298     }
1299 }
1300
1301 static const char *cap_express_link2_deemphasis(int type)
1302 {
1303   switch (type)
1304     {
1305       case 0:
1306         return "-6dB";
1307       case 1:
1308         return "-3.5dB";
1309       default:
1310         return "Unknown";
1311     }
1312 }
1313
1314 static const char *cap_express_link2_transmargin(int type)
1315 {
1316   switch (type)
1317     {
1318       case 0:
1319         return "Normal Operating Range";
1320       case 1:
1321         return "800-1200mV(full-swing)/400-700mV(half-swing)";
1322       case 2:
1323       case 3:
1324       case 4:
1325       case 5:
1326         return "200-400mV(full-swing)/100-200mV(half-swing)";
1327       default:
1328         return "Unknown";
1329     }
1330 }
1331
1332 static void cap_express_link2(struct device *d, int where, int type UNUSED)
1333 {
1334   u16 w;
1335
1336   w = get_conf_word(d, where + PCI_EXP_LNKCTL2);
1337   printf("\t\tLnkCtl2: Target Link Speed: %s, EnterCompliance%c SpeedDis%c, Selectable De-emphasis: %s\n"
1338         "\t\t\t Transmit Margin: %s, EnterModifiedCompliance%c ComplianceSOS%c\n"
1339         "\t\t\t Compliance De-emphasis: %s\n",
1340         cap_express_link2_speed(PCI_EXP_LNKCTL2_SPEED(w)),
1341         FLAG(w, PCI_EXP_LNKCTL2_CMPLNC),
1342         FLAG(w, PCI_EXP_LNKCTL2_SPEED_DIS),
1343         cap_express_link2_deemphasis(PCI_EXP_LNKCTL2_DEEMPHASIS(w)),
1344         cap_express_link2_transmargin(PCI_EXP_LNKCTL2_MARGIN(w)),
1345         FLAG(w, PCI_EXP_LNKCTL2_MOD_CMPLNC),
1346         FLAG(w, PCI_EXP_LNKCTL2_CMPLNC_SOS),
1347         cap_express_link2_deemphasis(PCI_EXP_LNKCTL2_COM_DEEMPHASIS(w)));
1348
1349   w = get_conf_word(d, where + PCI_EXP_LNKSTA2);
1350   printf("\t\tLnkSta2: Current De-emphasis Level: %s\n",
1351         cap_express_link2_deemphasis(PCI_EXP_LINKSTA2_DEEMPHASIS(w)));
1352 }
1353
1354 static void cap_express_slot2(struct device *d UNUSED, int where UNUSED)
1355 {
1356   /* No capabilities that require this field in PCIe rev2.0 spec. */
1357 }
1358
1359 static void
1360 cap_express(struct device *d, int where, int cap)
1361 {
1362   int type = (cap & PCI_EXP_FLAGS_TYPE) >> 4;
1363   int size;
1364   int slot = 0;
1365
1366   printf("Express ");
1367   if (verbose >= 2)
1368     printf("(v%d) ", cap & PCI_EXP_FLAGS_VERS);
1369   switch (type)
1370     {
1371     case PCI_EXP_TYPE_ENDPOINT:
1372       printf("Endpoint");
1373       break;
1374     case PCI_EXP_TYPE_LEG_END:
1375       printf("Legacy Endpoint");
1376       break;
1377     case PCI_EXP_TYPE_ROOT_PORT:
1378       slot = cap & PCI_EXP_FLAGS_SLOT;
1379       printf("Root Port (Slot%c)", FLAG(cap, PCI_EXP_FLAGS_SLOT));
1380       break;
1381     case PCI_EXP_TYPE_UPSTREAM:
1382       printf("Upstream Port");
1383       break;
1384     case PCI_EXP_TYPE_DOWNSTREAM:
1385       slot = cap & PCI_EXP_FLAGS_SLOT;
1386       printf("Downstream Port (Slot%c)", FLAG(cap, PCI_EXP_FLAGS_SLOT));
1387       break;
1388     case PCI_EXP_TYPE_PCI_BRIDGE:
1389       printf("PCI/PCI-X Bridge");
1390       break;
1391     case PCI_EXP_TYPE_PCIE_BRIDGE:
1392       printf("PCI/PCI-X to PCI-Express Bridge");
1393       break;
1394     case PCI_EXP_TYPE_ROOT_INT_EP:
1395       printf("Root Complex Integrated Endpoint");
1396       break;
1397     case PCI_EXP_TYPE_ROOT_EC:
1398       printf("Root Complex Event Collector");
1399       break;
1400     default:
1401       printf("Unknown type %d", type);
1402   }
1403   printf(", MSI %02x\n", (cap & PCI_EXP_FLAGS_IRQ) >> 9);
1404   if (verbose < 2)
1405     return;
1406
1407   size = 16;
1408   if (slot)
1409     size = 24;
1410   if (type == PCI_EXP_TYPE_ROOT_PORT)
1411     size = 32;
1412   if (!config_fetch(d, where + PCI_EXP_DEVCAP, size))
1413     return;
1414
1415   cap_express_dev(d, where, type);
1416   cap_express_link(d, where, type);
1417   if (slot)
1418     cap_express_slot(d, where);
1419   if (type == PCI_EXP_TYPE_ROOT_PORT)
1420     cap_express_root(d, where);
1421
1422   if ((cap & PCI_EXP_FLAGS_VERS) < 2)
1423     return;
1424
1425   size = 16;
1426   if (slot)
1427     size = 24;
1428   if (!config_fetch(d, where + PCI_EXP_DEVCAP2, size))
1429     return;
1430
1431   cap_express_dev2(d, where, type);
1432   cap_express_link2(d, where, type);
1433   if (slot)
1434     cap_express_slot2(d, where);
1435 }
1436
1437 static void
1438 cap_msix(struct device *d, int where, int cap)
1439 {
1440   u32 off;
1441
1442   printf("MSI-X: Enable%c Mask%c TabSize=%d\n",
1443          FLAG(cap, PCI_MSIX_ENABLE),
1444          FLAG(cap, PCI_MSIX_MASK),
1445          (cap & PCI_MSIX_TABSIZE) + 1);
1446   if (verbose < 2 || !config_fetch(d, where + PCI_MSIX_TABLE, 8))
1447     return;
1448
1449   off = get_conf_long(d, where + PCI_MSIX_TABLE);
1450   printf("\t\tVector table: BAR=%d offset=%08x\n",
1451          off & PCI_MSIX_BIR, off & ~PCI_MSIX_BIR);
1452   off = get_conf_long(d, where + PCI_MSIX_PBA);
1453   printf("\t\tPBA: BAR=%d offset=%08x\n",
1454          off & PCI_MSIX_BIR, off & ~PCI_MSIX_BIR);
1455 }
1456
1457 static void
1458 cap_slotid(int cap)
1459 {
1460   int esr = cap & 0xff;
1461   int chs = cap >> 8;
1462
1463   printf("Slot ID: %d slots, First%c, chassis %02x\n",
1464          esr & PCI_SID_ESR_NSLOTS,
1465          FLAG(esr, PCI_SID_ESR_FIC),
1466          chs);
1467 }
1468
1469 static void
1470 cap_ssvid(struct device *d, int where)
1471 {
1472   u16 subsys_v, subsys_d;
1473   char ssnamebuf[256];
1474
1475   if (!config_fetch(d, where, 8))
1476     return;
1477   subsys_v = get_conf_word(d, where + PCI_SSVID_VENDOR);
1478   subsys_d = get_conf_word(d, where + PCI_SSVID_DEVICE);
1479   printf("Subsystem: %s\n",
1480            pci_lookup_name(pacc, ssnamebuf, sizeof(ssnamebuf),
1481                            PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE,
1482                            d->dev->vendor_id, d->dev->device_id, subsys_v, subsys_d));
1483 }
1484
1485 static void
1486 cap_dsn(struct device *d, int where)
1487 {
1488   u32 t1, t2;
1489   if (!config_fetch(d, where + 4, 8))
1490     return;
1491   t1 = get_conf_long(d, where + 4);
1492   t2 = get_conf_long(d, where + 8);
1493   printf("Device Serial Number %02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x\n",
1494         t1 & 0xff, (t1 >> 8) & 0xff, (t1 >> 16) & 0xff, t1 >> 24,
1495         t2 & 0xff, (t2 >> 8) & 0xff, (t2 >> 16) & 0xff, t2 >> 24);
1496 }
1497
1498 static void
1499 cap_debug_port(int cap)
1500 {
1501   int bar = cap >> 13;
1502   int pos = cap & 0x1fff;
1503   printf("Debug port: BAR=%d offset=%04x\n", bar, pos);
1504 }
1505
1506 static void
1507 cap_aer(struct device *d, int where)
1508 {
1509   u32 l;
1510
1511   printf("Advanced Error Reporting\n");
1512   if (!config_fetch(d, where + PCI_ERR_UNCOR_STATUS, 24))
1513     return;
1514
1515   l = get_conf_long(d, where + PCI_ERR_UNCOR_STATUS);
1516   printf("\t\tUESta:\tDLP%c SDES%c TLP%c FCP%c CmpltTO%c CmpltAbrt%c UnxCmplt%c RxOF%c "
1517         "MalfTLP%c ECRC%c UnsupReq%c ACSViol%c\n",
1518         FLAG(l, PCI_ERR_UNC_DLP), FLAG(l, PCI_ERR_UNC_SDES), FLAG(l, PCI_ERR_UNC_POISON_TLP),
1519         FLAG(l, PCI_ERR_UNC_FCP), FLAG(l, PCI_ERR_UNC_COMP_TIME), FLAG(l, PCI_ERR_UNC_COMP_ABORT),
1520         FLAG(l, PCI_ERR_UNC_UNX_COMP), FLAG(l, PCI_ERR_UNC_RX_OVER), FLAG(l, PCI_ERR_UNC_MALF_TLP),
1521         FLAG(l, PCI_ERR_UNC_ECRC), FLAG(l, PCI_ERR_UNC_UNSUP), FLAG(l, PCI_ERR_UNC_ACS_VIOL));
1522   l = get_conf_long(d, where + PCI_ERR_UNCOR_MASK);
1523   printf("\t\tUEMsk:\tDLP%c SDES%c TLP%c FCP%c CmpltTO%c CmpltAbrt%c UnxCmplt%c RxOF%c "
1524         "MalfTLP%c ECRC%c UnsupReq%c ACSViol%c\n",
1525         FLAG(l, PCI_ERR_UNC_DLP), FLAG(l, PCI_ERR_UNC_SDES), FLAG(l, PCI_ERR_UNC_POISON_TLP),
1526         FLAG(l, PCI_ERR_UNC_FCP), FLAG(l, PCI_ERR_UNC_COMP_TIME), FLAG(l, PCI_ERR_UNC_COMP_ABORT),
1527         FLAG(l, PCI_ERR_UNC_UNX_COMP), FLAG(l, PCI_ERR_UNC_RX_OVER), FLAG(l, PCI_ERR_UNC_MALF_TLP),
1528         FLAG(l, PCI_ERR_UNC_ECRC), FLAG(l, PCI_ERR_UNC_UNSUP), FLAG(l, PCI_ERR_UNC_ACS_VIOL));
1529   l = get_conf_long(d, where + PCI_ERR_UNCOR_SEVER);
1530   printf("\t\tUESvrt:\tDLP%c SDES%c TLP%c FCP%c CmpltTO%c CmpltAbrt%c UnxCmplt%c RxOF%c "
1531         "MalfTLP%c ECRC%c UnsupReq%c ACSViol%c\n",
1532         FLAG(l, PCI_ERR_UNC_DLP), FLAG(l, PCI_ERR_UNC_SDES), FLAG(l, PCI_ERR_UNC_POISON_TLP),
1533         FLAG(l, PCI_ERR_UNC_FCP), FLAG(l, PCI_ERR_UNC_COMP_TIME), FLAG(l, PCI_ERR_UNC_COMP_ABORT),
1534         FLAG(l, PCI_ERR_UNC_UNX_COMP), FLAG(l, PCI_ERR_UNC_RX_OVER), FLAG(l, PCI_ERR_UNC_MALF_TLP),
1535         FLAG(l, PCI_ERR_UNC_ECRC), FLAG(l, PCI_ERR_UNC_UNSUP), FLAG(l, PCI_ERR_UNC_ACS_VIOL));
1536   l = get_conf_long(d, where + PCI_ERR_COR_STATUS);
1537   printf("\t\tCESta:\tRxErr%c BadTLP%c BadDLLP%c Rollover%c Timeout%c NonFatalErr%c\n",
1538         FLAG(l, PCI_ERR_COR_RCVR), FLAG(l, PCI_ERR_COR_BAD_TLP), FLAG(l, PCI_ERR_COR_BAD_DLLP),
1539         FLAG(l, PCI_ERR_COR_REP_ROLL), FLAG(l, PCI_ERR_COR_REP_TIMER), FLAG(l, PCI_ERR_COR_REP_ANFE));
1540   l = get_conf_long(d, where + PCI_ERR_COR_MASK);
1541   printf("\t\tCEMsk:\tRxErr%c BadTLP%c BadDLLP%c Rollover%c Timeout%c NonFatalErr%c\n",
1542         FLAG(l, PCI_ERR_COR_RCVR), FLAG(l, PCI_ERR_COR_BAD_TLP), FLAG(l, PCI_ERR_COR_BAD_DLLP),
1543         FLAG(l, PCI_ERR_COR_REP_ROLL), FLAG(l, PCI_ERR_COR_REP_TIMER), FLAG(l, PCI_ERR_COR_REP_ANFE));
1544   l = get_conf_long(d, where + PCI_ERR_CAP);
1545   printf("\t\tAERCap:\tFirst Error Pointer: %02x, GenCap%c CGenEn%c ChkCap%c ChkEn%c\n",
1546         PCI_ERR_CAP_FEP(l), FLAG(l, PCI_ERR_CAP_ECRC_GENC), FLAG(l, PCI_ERR_CAP_ECRC_GENE),
1547         FLAG(l, PCI_ERR_CAP_ECRC_CHKC), FLAG(l, PCI_ERR_CAP_ECRC_CHKE));
1548
1549 }
1550
1551 static void
1552 cap_acs(struct device *d, int where)
1553 {
1554   u16 w;
1555
1556   printf("Access Control Services\n");
1557   if (!config_fetch(d, where + PCI_ACS_CAP, 4))
1558     return;
1559
1560   w = get_conf_word(d, where + PCI_ACS_CAP);
1561   printf("\t\tACSCap:\tSrcValid%c TransBlk%c ReqRedir%c CmpltRedir%c UpstreamFwd%c EgressCtrl%c "
1562         "DirectTrans%c\n",
1563         FLAG(w, PCI_ACS_CAP_VALID), FLAG(w, PCI_ACS_CAP_BLOCK), FLAG(w, PCI_ACS_CAP_REQ_RED),
1564         FLAG(w, PCI_ACS_CAP_CMPLT_RED), FLAG(w, PCI_ACS_CAP_FORWARD), FLAG(w, PCI_ACS_CAP_EGRESS),
1565         FLAG(w, PCI_ACS_CAP_TRANS));
1566   w = get_conf_word(d, where + PCI_ACS_CTRL);
1567   printf("\t\tACSCtl:\tSrcValid%c TransBlk%c ReqRedir%c CmpltRedir%c UpstreamFwd%c EgressCtrl%c "
1568         "DirectTrans%c\n",
1569         FLAG(w, PCI_ACS_CTRL_VALID), FLAG(w, PCI_ACS_CTRL_BLOCK), FLAG(w, PCI_ACS_CTRL_REQ_RED),
1570         FLAG(w, PCI_ACS_CTRL_CMPLT_RED), FLAG(w, PCI_ACS_CTRL_FORWARD), FLAG(w, PCI_ACS_CTRL_EGRESS),
1571         FLAG(w, PCI_ACS_CTRL_TRANS));
1572 }
1573
1574 static void
1575 cap_ari(struct device *d, int where)
1576 {
1577   u16 w;
1578
1579   printf("Alternative Routing-ID Interpretation (ARI)\n");
1580   if (!config_fetch(d, where + PCI_ARI_CAP, 4))
1581     return;
1582
1583   w = get_conf_word(d, where + PCI_ARI_CAP);
1584   printf("\t\tARICap:\tMFVC%c ACS%c, Next Function: %d\n",
1585         FLAG(w, PCI_ARI_CAP_MFVC), FLAG(w, PCI_ARI_CAP_ACS),
1586         PCI_ARI_CAP_NFN(w));
1587   w = get_conf_word(d, where + PCI_ARI_CTRL);
1588   printf("\t\tARICtl:\tMFVC%c ACS%c, Function Group: %d\n",
1589         FLAG(w, PCI_ARI_CTRL_MFVC), FLAG(w, PCI_ARI_CTRL_ACS),
1590         PCI_ARI_CTRL_FG(w));
1591 }
1592
1593 static void
1594 cap_sriov(struct device *d, int where)
1595 {
1596   u16 b;
1597   u16 w;
1598   u32 l;
1599
1600   printf("Single Root I/O Virtualization (SR-IOV)\n");
1601   if (!config_fetch(d, where + PCI_IOV_CAP, 0x3c))
1602     return;
1603
1604   l = get_conf_long(d, where + PCI_IOV_CAP);
1605   printf("\t\tIOVCap:\tMigration%c, Interrupt Message Number: %03x\n",
1606         FLAG(l, PCI_IOV_CAP_VFM), PCI_IOV_CAP_IMN(l));
1607   w = get_conf_word(d, where + PCI_IOV_CTRL);
1608   printf("\t\tIOVCtl:\tEnable%c Migration%c Interrupt%c MSE%c ARIHierarchy%c\n",
1609         FLAG(w, PCI_IOV_CTRL_VFE), FLAG(w, PCI_IOV_CTRL_VFME),
1610         FLAG(w, PCI_IOV_CTRL_VFMIE), FLAG(w, PCI_IOV_CTRL_MSE),
1611         FLAG(w, PCI_IOV_CTRL_ARI));
1612   w = get_conf_word(d, where + PCI_IOV_STATUS);
1613   printf("\t\tIOVSta:\tMigration%c\n", FLAG(w, PCI_IOV_STATUS_MS));
1614   w = get_conf_word(d, where + PCI_IOV_INITIALVF);
1615   printf("\t\tInitial VFs: %d, ", w);
1616   w = get_conf_word(d, where + PCI_IOV_TOTALVF);
1617   printf("Total VFs: %d, ", w);
1618   w = get_conf_word(d, where + PCI_IOV_NUMVF);
1619   printf("Number of VFs: %d, ", w);
1620   b = get_conf_byte(d, where + PCI_IOV_FDL);
1621   printf("Function Dependency Link: %02x\n", b);
1622   w = get_conf_word(d, where + PCI_IOV_OFFSET);
1623   printf("\t\tVF offset: %d, ", w);
1624   w = get_conf_word(d, where + PCI_IOV_STRIDE);
1625   printf("stride: %d, ", w);
1626   w = get_conf_word(d, where + PCI_IOV_DID);
1627   printf("Device ID: %04x\n", w);
1628   l = get_conf_long(d, where + PCI_IOV_SUPPS);
1629   printf("\t\tSupported Page Size: %08x, ", l);
1630   l = get_conf_long(d, where + PCI_IOV_SYSPS);
1631   printf("System Page Size: %08x\n", l);
1632   printf("\t\tVF Migration: offset: %08x, BIR: %x\n", PCI_IOV_MSA_OFFSET(l),
1633         PCI_IOV_MSA_BIR(l));
1634 }
1635
1636 static void
1637 show_ext_caps(struct device *d)
1638 {
1639   int where = 0x100;
1640   char been_there[0x1000];
1641   memset(been_there, 0, 0x1000);
1642   do
1643     {
1644       u32 header;
1645       int id;
1646
1647       if (!config_fetch(d, where, 4))
1648         break;
1649       header = get_conf_long(d, where);
1650       if (!header)
1651         break;
1652       id = header & 0xffff;
1653       printf("\tCapabilities: [%03x] ", where);
1654       if (been_there[where]++)
1655         {
1656           printf("<chain looped>\n");
1657           break;
1658         }
1659       switch (id)
1660         {
1661           case PCI_EXT_CAP_ID_AER:
1662             cap_aer(d, where);
1663             break;
1664           case PCI_EXT_CAP_ID_VC:
1665             printf("Virtual Channel <?>\n");
1666             break;
1667           case PCI_EXT_CAP_ID_DSN:
1668             cap_dsn(d, where);
1669             break;
1670           case PCI_EXT_CAP_ID_PB:
1671             printf("Power Budgeting <?>\n");
1672             break;
1673           case PCI_EXT_CAP_ID_RCLINK:
1674             printf("Root Complex Link <?>\n");
1675             break;
1676           case PCI_EXT_CAP_ID_RCILINK:
1677             printf("Root Complex Internal Link <?>\n");
1678             break;
1679           case PCI_EXT_CAP_ID_RCECOLL:
1680             printf("Root Complex Event Collector <?>\n");
1681             break;
1682           case PCI_EXT_CAP_ID_MFVC:
1683             printf("Multi-Function Virtual Channel <?>\n");
1684             break;
1685           case PCI_EXT_CAP_ID_RBCB:
1686             printf("Root Bridge Control Block <?>\n");
1687             break;
1688           case PCI_EXT_CAP_ID_VNDR:
1689             printf("Vendor Specific Information <?>\n");
1690             break;
1691           case PCI_EXT_CAP_ID_ACS:
1692             cap_acs(d, where);
1693             break;
1694           case PCI_EXT_CAP_ID_ARI:
1695             cap_ari(d, where);
1696             break;
1697           case PCI_EXT_CAP_ID_SRIOV:
1698             cap_sriov(d, where);
1699             break;
1700           default:
1701             printf("#%02x\n", id);
1702             break;
1703         }
1704       where = header >> 20;
1705     } while (where);
1706 }
1707
1708 static void
1709 show_caps(struct device *d)
1710 {
1711   int can_have_ext_caps = 0;
1712
1713   if (get_conf_word(d, PCI_STATUS) & PCI_STATUS_CAP_LIST)
1714     {
1715       int where = get_conf_byte(d, PCI_CAPABILITY_LIST) & ~3;
1716       byte been_there[256];
1717       memset(been_there, 0, 256);
1718       while (where)
1719         {
1720           int id, next, cap;
1721           printf("\tCapabilities: ");
1722           if (!config_fetch(d, where, 4))
1723             {
1724               puts("<access denied>");
1725               break;
1726             }
1727           id = get_conf_byte(d, where + PCI_CAP_LIST_ID);
1728           next = get_conf_byte(d, where + PCI_CAP_LIST_NEXT) & ~3;
1729           cap = get_conf_word(d, where + PCI_CAP_FLAGS);
1730           printf("[%02x] ", where);
1731           if (been_there[where]++)
1732             {
1733               printf("<chain looped>\n");
1734               break;
1735             }
1736           if (id == 0xff)
1737             {
1738               printf("<chain broken>\n");
1739               break;
1740             }
1741           switch (id)
1742             {
1743             case PCI_CAP_ID_PM:
1744               cap_pm(d, where, cap);
1745               break;
1746             case PCI_CAP_ID_AGP:
1747               cap_agp(d, where, cap);
1748               break;
1749             case PCI_CAP_ID_VPD:
1750               printf("Vital Product Data <?>\n");
1751               break;
1752             case PCI_CAP_ID_SLOTID:
1753               cap_slotid(cap);
1754               break;
1755             case PCI_CAP_ID_MSI:
1756               cap_msi(d, where, cap);
1757               break;
1758             case PCI_CAP_ID_CHSWP:
1759               printf("CompactPCI hot-swap <?>\n");
1760               break;
1761             case PCI_CAP_ID_PCIX:
1762               cap_pcix(d, where);
1763               can_have_ext_caps = 1;
1764               break;
1765             case PCI_CAP_ID_HT:
1766               cap_ht(d, where, cap);
1767               break;
1768             case PCI_CAP_ID_VNDR:
1769               printf("Vendor Specific Information <?>\n");
1770               break;
1771             case PCI_CAP_ID_DBG:
1772               cap_debug_port(cap);
1773               break;
1774             case PCI_CAP_ID_CCRC:
1775               printf("CompactPCI central resource control <?>\n");
1776               break;
1777             case PCI_CAP_ID_HOTPLUG:
1778               printf("Hot-plug capable\n");
1779               break;
1780             case PCI_CAP_ID_SSVID:
1781               cap_ssvid(d, where);
1782               break;
1783             case PCI_CAP_ID_AGP3:
1784               printf("AGP3 <?>\n");
1785               break;
1786             case PCI_CAP_ID_SECURE:
1787               printf("Secure device <?>\n");
1788               break;
1789             case PCI_CAP_ID_EXP:
1790               cap_express(d, where, cap);
1791               can_have_ext_caps = 1;
1792               break;
1793             case PCI_CAP_ID_MSIX:
1794               cap_msix(d, where, cap);
1795               break;
1796             case PCI_CAP_ID_SATA:
1797               printf("SATA HBA <?>\n");
1798               break;
1799             case PCI_CAP_ID_AF:
1800               printf("PCIe advanced features <?>\n");
1801               break;
1802             default:
1803               printf("#%02x [%04x]\n", id, cap);
1804             }
1805           where = next;
1806         }
1807     }
1808   if (can_have_ext_caps)
1809     show_ext_caps(d);
1810 }
1811
1812 /*** Kernel drivers ***/
1813
1814 #ifdef PCI_OS_LINUX
1815
1816 #include <sys/utsname.h>
1817
1818 struct pcimap_entry {
1819   struct pcimap_entry *next;
1820   unsigned int vendor, device;
1821   unsigned int subvendor, subdevice;
1822   unsigned int class, class_mask;
1823   char module[1];
1824 };
1825
1826 static struct pcimap_entry *pcimap_head;
1827
1828 static void
1829 load_pcimap(void)
1830 {
1831   static int tried_pcimap;
1832   struct utsname uts;
1833   char *name, line[1024];
1834   FILE *f;
1835
1836   if (tried_pcimap)
1837     return;
1838   tried_pcimap = 1;
1839
1840   if (name = opt_pcimap)
1841     {
1842       f = fopen(name, "r");
1843       if (!f)
1844         die("Cannot open pcimap file %s: %m", name);
1845     }
1846   else
1847     {
1848       if (uname(&uts) < 0)
1849         die("uname() failed: %m");
1850       name = alloca(64 + strlen(uts.release));
1851       sprintf(name, "/lib/modules/%s/modules.pcimap", uts.release);
1852       f = fopen(name, "r");
1853       if (!f)
1854         return;
1855     }
1856
1857   while (fgets(line, sizeof(line), f))
1858     {
1859       char *c = strchr(line, '\n');
1860       struct pcimap_entry *e;
1861
1862       if (!c)
1863         die("Unterminated or too long line in %s", name);
1864       *c = 0;
1865       if (!line[0] || line[0] == '#')
1866         continue;
1867
1868       c = line;
1869       while (*c && *c != ' ' && *c != '\t')
1870         c++;
1871       if (!*c)
1872         continue;       /* FIXME: Emit warnings! */
1873       *c++ = 0;
1874
1875       e = xmalloc(sizeof(*e) + strlen(line));
1876       if (sscanf(c, "%i%i%i%i%i%i",
1877                  &e->vendor, &e->device,
1878                  &e->subvendor, &e->subdevice,
1879                  &e->class, &e->class_mask) != 6)
1880         continue;
1881       e->next = pcimap_head;
1882       pcimap_head = e;
1883       strcpy(e->module, line);
1884     }
1885   fclose(f);
1886 }
1887
1888 static int
1889 match_pcimap(struct device *d, struct pcimap_entry *e)
1890 {
1891   struct pci_dev *dev = d->dev;
1892   unsigned int class = get_conf_long(d, PCI_REVISION_ID) >> 8;
1893   word subv, subd;
1894
1895 #define MATCH(x, y) ((y) > 0xffff || (x) == (y))
1896   get_subid(d, &subv, &subd);
1897   return
1898     MATCH(dev->vendor_id, e->vendor) &&
1899     MATCH(dev->device_id, e->device) &&
1900     MATCH(subv, e->subvendor) &&
1901     MATCH(subd, e->subdevice) &&
1902     (class & e->class_mask) == e->class;
1903 #undef MATCH
1904 }
1905
1906 #define DRIVER_BUF_SIZE 1024
1907
1908 static char *
1909 find_driver(struct device *d, char *buf)
1910 {
1911   struct pci_dev *dev = d->dev;
1912   char name[1024], *drv, *base;
1913   int n;
1914
1915   if (dev->access->method != PCI_ACCESS_SYS_BUS_PCI)
1916     return NULL;
1917
1918   base = pci_get_param(dev->access, "sysfs.path");
1919   if (!base || !base[0])
1920     return NULL;
1921
1922   n = snprintf(name, sizeof(name), "%s/devices/%04x:%02x:%02x.%d/driver",
1923                base, dev->domain, dev->bus, dev->dev, dev->func);
1924   if (n < 0 || n >= (int)sizeof(name))
1925     die("show_driver: sysfs device name too long, why?");
1926
1927   n = readlink(name, buf, DRIVER_BUF_SIZE);
1928   if (n < 0)
1929     return NULL;
1930   if (n >= DRIVER_BUF_SIZE)
1931     return "<name-too-long>";
1932   buf[n] = 0;
1933
1934   if (drv = strrchr(buf, '/'))
1935     return drv+1;
1936   else
1937     return buf;
1938 }
1939
1940 static void
1941 show_kernel(struct device *d)
1942 {
1943   char buf[DRIVER_BUF_SIZE];
1944   char *driver;
1945   struct pcimap_entry *e, *last = NULL;
1946
1947   if (driver = find_driver(d, buf))
1948     printf("\tKernel driver in use: %s\n", driver);
1949
1950   load_pcimap();
1951   for (e=pcimap_head; e; e=e->next)
1952     if (match_pcimap(d, e) && (!last || strcmp(last->module, e->module)))
1953       {
1954         printf("%s %s", (last ? "," : "\tKernel modules:"), e->module);
1955         last = e;
1956       }
1957   if (last)
1958     putchar('\n');
1959 }
1960
1961 static void
1962 show_kernel_machine(struct device *d)
1963 {
1964   char buf[DRIVER_BUF_SIZE];
1965   char *driver;
1966   struct pcimap_entry *e, *last = NULL;
1967
1968   if (driver = find_driver(d, buf))
1969     printf("Driver:\t%s\n", driver);
1970
1971   load_pcimap();
1972   for (e=pcimap_head; e; e=e->next)
1973     if (match_pcimap(d, e) && (!last || strcmp(last->module, e->module)))
1974       {
1975         printf("Module:\t%s\n", e->module);
1976         last = e;
1977       }
1978 }
1979
1980 #else
1981
1982 static void
1983 show_kernel(struct device *d UNUSED)
1984 {
1985 }
1986
1987 static void
1988 show_kernel_machine(struct device *d UNUSED)
1989 {
1990 }
1991
1992 #endif
1993
1994 /*** Verbose output ***/
1995
1996 static void
1997 show_size(pciaddr_t x)
1998 {
1999   if (!x)
2000     return;
2001   printf(" [size=");
2002   if (x < 1024)
2003     printf("%d", (int) x);
2004   else if (x < 1048576)
2005     printf("%dK", (int)(x / 1024));
2006   else if (x < 0x80000000)
2007     printf("%dM", (int)(x / 1048576));
2008   else
2009     printf(PCIADDR_T_FMT, x);
2010   putchar(']');
2011 }
2012
2013 static void
2014 show_bases(struct device *d, int cnt)
2015 {
2016   struct pci_dev *p = d->dev;
2017   word cmd = get_conf_word(d, PCI_COMMAND);
2018   int i;
2019
2020   for(i=0; i<cnt; i++)
2021     {
2022       pciaddr_t pos = p->base_addr[i];
2023       pciaddr_t len = (p->known_fields & PCI_FILL_SIZES) ? p->size[i] : 0;
2024       u32 flg = get_conf_long(d, PCI_BASE_ADDRESS_0 + 4*i);
2025       if (flg == 0xffffffff)
2026         flg = 0;
2027       if (!pos && !flg && !len)
2028         continue;
2029       if (verbose > 1)
2030         printf("\tRegion %d: ", i);
2031       else
2032         putchar('\t');
2033       if (pos && !flg)                  /* Reported by the OS, but not by the device */
2034         {
2035           printf("[virtual] ");
2036           flg = pos;
2037         }
2038       if (flg & PCI_BASE_ADDRESS_SPACE_IO)
2039         {
2040           pciaddr_t a = pos & PCI_BASE_ADDRESS_IO_MASK;
2041           printf("I/O ports at ");
2042           if (a)
2043             printf(PCIADDR_PORT_FMT, a);
2044           else if (flg & PCI_BASE_ADDRESS_IO_MASK)
2045             printf("<ignored>");
2046           else
2047             printf("<unassigned>");
2048           if (!(cmd & PCI_COMMAND_IO))
2049             printf(" [disabled]");
2050         }
2051       else
2052         {
2053           int t = flg & PCI_BASE_ADDRESS_MEM_TYPE_MASK;
2054           pciaddr_t a = pos & PCI_ADDR_MEM_MASK;
2055           int done = 0;
2056           u32 z = 0;
2057
2058           printf("Memory at ");
2059           if (t == PCI_BASE_ADDRESS_MEM_TYPE_64)
2060             {
2061               if (i >= cnt - 1)
2062                 {
2063                   printf("<invalid-64bit-slot>");
2064                   done = 1;
2065                 }
2066               else
2067                 {
2068                   i++;
2069                   z = get_conf_long(d, PCI_BASE_ADDRESS_0 + 4*i);
2070                   if (opt_buscentric)
2071                     {
2072                       u32 y = a & 0xffffffff;
2073                       if (a || z)
2074                         printf("%08x%08x", z, y);
2075                       else
2076                         printf("<unassigned>");
2077                       done = 1;
2078                     }
2079                 }
2080             }
2081           if (!done)
2082             {
2083               if (a)
2084                 printf(PCIADDR_T_FMT, a);
2085               else
2086                 printf(((flg & PCI_BASE_ADDRESS_MEM_MASK) || z) ? "<ignored>" : "<unassigned>");
2087             }
2088           printf(" (%s, %sprefetchable)",
2089                  (t == PCI_BASE_ADDRESS_MEM_TYPE_32) ? "32-bit" :
2090                  (t == PCI_BASE_ADDRESS_MEM_TYPE_64) ? "64-bit" :
2091                  (t == PCI_BASE_ADDRESS_MEM_TYPE_1M) ? "low-1M" : "type 3",
2092                  (flg & PCI_BASE_ADDRESS_MEM_PREFETCH) ? "" : "non-");
2093           if (!(cmd & PCI_COMMAND_MEMORY))
2094             printf(" [disabled]");
2095         }
2096       show_size(len);
2097       putchar('\n');
2098     }
2099 }
2100
2101 static void
2102 show_rom(struct device *d, int reg)
2103 {
2104   struct pci_dev *p = d->dev;
2105   pciaddr_t rom = p->rom_base_addr;
2106   pciaddr_t len = (p->known_fields & PCI_FILL_SIZES) ? p->rom_size : 0;
2107   u32 flg = get_conf_long(d, reg);
2108   word cmd = get_conf_word(d, PCI_COMMAND);
2109
2110   if (!rom && !flg && !len)
2111     return;
2112   putchar('\t');
2113   if ((rom & PCI_ROM_ADDRESS_MASK) && !(flg & PCI_ROM_ADDRESS_MASK))
2114     {
2115       printf("[virtual] ");
2116       flg = rom;
2117     }
2118   printf("Expansion ROM at ");
2119   if (rom & PCI_ROM_ADDRESS_MASK)
2120     printf(PCIADDR_T_FMT, rom & PCI_ROM_ADDRESS_MASK);
2121   else if (flg & PCI_ROM_ADDRESS_MASK)
2122     printf("<ignored>");
2123   else
2124     printf("<unassigned>");
2125   if (!(flg & PCI_ROM_ADDRESS_ENABLE))
2126     printf(" [disabled]");
2127   else if (!(cmd & PCI_COMMAND_MEMORY))
2128     printf(" [disabled by cmd]");
2129   show_size(len);
2130   putchar('\n');
2131 }
2132
2133 static void
2134 show_htype0(struct device *d)
2135 {
2136   show_bases(d, 6);
2137   show_rom(d, PCI_ROM_ADDRESS);
2138   show_caps(d);
2139 }
2140
2141 static void
2142 show_htype1(struct device *d)
2143 {
2144   u32 io_base = get_conf_byte(d, PCI_IO_BASE);
2145   u32 io_limit = get_conf_byte(d, PCI_IO_LIMIT);
2146   u32 io_type = io_base & PCI_IO_RANGE_TYPE_MASK;
2147   u32 mem_base = get_conf_word(d, PCI_MEMORY_BASE);
2148   u32 mem_limit = get_conf_word(d, PCI_MEMORY_LIMIT);
2149   u32 mem_type = mem_base & PCI_MEMORY_RANGE_TYPE_MASK;
2150   u32 pref_base = get_conf_word(d, PCI_PREF_MEMORY_BASE);
2151   u32 pref_limit = get_conf_word(d, PCI_PREF_MEMORY_LIMIT);
2152   u32 pref_type = pref_base & PCI_PREF_RANGE_TYPE_MASK;
2153   word sec_stat = get_conf_word(d, PCI_SEC_STATUS);
2154   word brc = get_conf_word(d, PCI_BRIDGE_CONTROL);
2155   int verb = verbose > 2;
2156
2157   show_bases(d, 2);
2158   printf("\tBus: primary=%02x, secondary=%02x, subordinate=%02x, sec-latency=%d\n",
2159          get_conf_byte(d, PCI_PRIMARY_BUS),
2160          get_conf_byte(d, PCI_SECONDARY_BUS),
2161          get_conf_byte(d, PCI_SUBORDINATE_BUS),
2162          get_conf_byte(d, PCI_SEC_LATENCY_TIMER));
2163
2164   if (io_type != (io_limit & PCI_IO_RANGE_TYPE_MASK) ||
2165       (io_type != PCI_IO_RANGE_TYPE_16 && io_type != PCI_IO_RANGE_TYPE_32))
2166     printf("\t!!! Unknown I/O range types %x/%x\n", io_base, io_limit);
2167   else
2168     {
2169       io_base = (io_base & PCI_IO_RANGE_MASK) << 8;
2170       io_limit = (io_limit & PCI_IO_RANGE_MASK) << 8;
2171       if (io_type == PCI_IO_RANGE_TYPE_32)
2172         {
2173           io_base |= (get_conf_word(d, PCI_IO_BASE_UPPER16) << 16);
2174           io_limit |= (get_conf_word(d, PCI_IO_LIMIT_UPPER16) << 16);
2175         }
2176       if (io_base <= io_limit || verb)
2177         printf("\tI/O behind bridge: %08x-%08x\n", io_base, io_limit+0xfff);
2178     }
2179
2180   if (mem_type != (mem_limit & PCI_MEMORY_RANGE_TYPE_MASK) ||
2181       mem_type)
2182     printf("\t!!! Unknown memory range types %x/%x\n", mem_base, mem_limit);
2183   else
2184     {
2185       mem_base = (mem_base & PCI_MEMORY_RANGE_MASK) << 16;
2186       mem_limit = (mem_limit & PCI_MEMORY_RANGE_MASK) << 16;
2187       if (mem_base <= mem_limit || verb)
2188         printf("\tMemory behind bridge: %08x-%08x\n", mem_base, mem_limit + 0xfffff);
2189     }
2190
2191   if (pref_type != (pref_limit & PCI_PREF_RANGE_TYPE_MASK) ||
2192       (pref_type != PCI_PREF_RANGE_TYPE_32 && pref_type != PCI_PREF_RANGE_TYPE_64))
2193     printf("\t!!! Unknown prefetchable memory range types %x/%x\n", pref_base, pref_limit);
2194   else
2195     {
2196       pref_base = (pref_base & PCI_PREF_RANGE_MASK) << 16;
2197       pref_limit = (pref_limit & PCI_PREF_RANGE_MASK) << 16;
2198       if (pref_base <= pref_limit || verb)
2199         {
2200           if (pref_type == PCI_PREF_RANGE_TYPE_32)
2201             printf("\tPrefetchable memory behind bridge: %08x-%08x\n", pref_base, pref_limit + 0xfffff);
2202           else
2203             printf("\tPrefetchable memory behind bridge: %08x%08x-%08x%08x\n",
2204                    get_conf_long(d, PCI_PREF_BASE_UPPER32),
2205                    pref_base,
2206                    get_conf_long(d, PCI_PREF_LIMIT_UPPER32),
2207                    pref_limit + 0xfffff);
2208         }
2209     }
2210
2211   if (verbose > 1)
2212     printf("\tSecondary status: 66MHz%c FastB2B%c ParErr%c DEVSEL=%s >TAbort%c <TAbort%c <MAbort%c <SERR%c <PERR%c\n",
2213              FLAG(sec_stat, PCI_STATUS_66MHZ),
2214              FLAG(sec_stat, PCI_STATUS_FAST_BACK),
2215              FLAG(sec_stat, PCI_STATUS_PARITY),
2216              ((sec_stat & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_SLOW) ? "slow" :
2217              ((sec_stat & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_MEDIUM) ? "medium" :
2218              ((sec_stat & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_FAST) ? "fast" : "??",
2219              FLAG(sec_stat, PCI_STATUS_SIG_TARGET_ABORT),
2220              FLAG(sec_stat, PCI_STATUS_REC_TARGET_ABORT),
2221              FLAG(sec_stat, PCI_STATUS_REC_MASTER_ABORT),
2222              FLAG(sec_stat, PCI_STATUS_SIG_SYSTEM_ERROR),
2223              FLAG(sec_stat, PCI_STATUS_DETECTED_PARITY));
2224
2225   show_rom(d, PCI_ROM_ADDRESS1);
2226
2227   if (verbose > 1)
2228     {
2229       printf("\tBridgeCtl: Parity%c SERR%c NoISA%c VGA%c MAbort%c >Reset%c FastB2B%c\n",
2230         FLAG(brc, PCI_BRIDGE_CTL_PARITY),
2231         FLAG(brc, PCI_BRIDGE_CTL_SERR),
2232         FLAG(brc, PCI_BRIDGE_CTL_NO_ISA),
2233         FLAG(brc, PCI_BRIDGE_CTL_VGA),
2234         FLAG(brc, PCI_BRIDGE_CTL_MASTER_ABORT),
2235         FLAG(brc, PCI_BRIDGE_CTL_BUS_RESET),
2236         FLAG(brc, PCI_BRIDGE_CTL_FAST_BACK));
2237       printf("\t\tPriDiscTmr%c SecDiscTmr%c DiscTmrStat%c DiscTmrSERREn%c\n",
2238         FLAG(brc, PCI_BRIDGE_CTL_PRI_DISCARD_TIMER),
2239         FLAG(brc, PCI_BRIDGE_CTL_SEC_DISCARD_TIMER),
2240         FLAG(brc, PCI_BRIDGE_CTL_DISCARD_TIMER_STATUS),
2241         FLAG(brc, PCI_BRIDGE_CTL_DISCARD_TIMER_SERR_EN));
2242     }
2243
2244   show_caps(d);
2245 }
2246
2247 static void
2248 show_htype2(struct device *d)
2249 {
2250   int i;
2251   word cmd = get_conf_word(d, PCI_COMMAND);
2252   word brc = get_conf_word(d, PCI_CB_BRIDGE_CONTROL);
2253   word exca;
2254   int verb = verbose > 2;
2255
2256   show_bases(d, 1);
2257   printf("\tBus: primary=%02x, secondary=%02x, subordinate=%02x, sec-latency=%d\n",
2258          get_conf_byte(d, PCI_CB_PRIMARY_BUS),
2259          get_conf_byte(d, PCI_CB_CARD_BUS),
2260          get_conf_byte(d, PCI_CB_SUBORDINATE_BUS),
2261          get_conf_byte(d, PCI_CB_LATENCY_TIMER));
2262   for(i=0; i<2; i++)
2263     {
2264       int p = 8*i;
2265       u32 base = get_conf_long(d, PCI_CB_MEMORY_BASE_0 + p);
2266       u32 limit = get_conf_long(d, PCI_CB_MEMORY_LIMIT_0 + p);
2267       if (limit > base || verb)
2268         printf("\tMemory window %d: %08x-%08x%s%s\n", i, base, limit,
2269                (cmd & PCI_COMMAND_MEMORY) ? "" : " [disabled]",
2270                (brc & (PCI_CB_BRIDGE_CTL_PREFETCH_MEM0 << i)) ? " (prefetchable)" : "");
2271     }
2272   for(i=0; i<2; i++)
2273     {
2274       int p = 8*i;
2275       u32 base = get_conf_long(d, PCI_CB_IO_BASE_0 + p);
2276       u32 limit = get_conf_long(d, PCI_CB_IO_LIMIT_0 + p);
2277       if (!(base & PCI_IO_RANGE_TYPE_32))
2278         {
2279           base &= 0xffff;
2280           limit &= 0xffff;
2281         }
2282       base &= PCI_CB_IO_RANGE_MASK;
2283       limit = (limit & PCI_CB_IO_RANGE_MASK) + 3;
2284       if (base <= limit || verb)
2285         printf("\tI/O window %d: %08x-%08x%s\n", i, base, limit,
2286                (cmd & PCI_COMMAND_IO) ? "" : " [disabled]");
2287     }
2288
2289   if (get_conf_word(d, PCI_CB_SEC_STATUS) & PCI_STATUS_SIG_SYSTEM_ERROR)
2290     printf("\tSecondary status: SERR\n");
2291   if (verbose > 1)
2292     printf("\tBridgeCtl: Parity%c SERR%c ISA%c VGA%c MAbort%c >Reset%c 16bInt%c PostWrite%c\n",
2293            FLAG(brc, PCI_CB_BRIDGE_CTL_PARITY),
2294            FLAG(brc, PCI_CB_BRIDGE_CTL_SERR),
2295            FLAG(brc, PCI_CB_BRIDGE_CTL_ISA),
2296            FLAG(brc, PCI_CB_BRIDGE_CTL_VGA),
2297            FLAG(brc, PCI_CB_BRIDGE_CTL_MASTER_ABORT),
2298            FLAG(brc, PCI_CB_BRIDGE_CTL_CB_RESET),
2299            FLAG(brc, PCI_CB_BRIDGE_CTL_16BIT_INT),
2300            FLAG(brc, PCI_CB_BRIDGE_CTL_POST_WRITES));
2301
2302   if (d->config_cached < 128)
2303     {
2304       printf("\t<access denied to the rest>\n");
2305       return;
2306     }
2307
2308   exca = get_conf_word(d, PCI_CB_LEGACY_MODE_BASE);
2309   if (exca)
2310     printf("\t16-bit legacy interface ports at %04x\n", exca);
2311 }
2312
2313 static void
2314 show_verbose(struct device *d)
2315 {
2316   struct pci_dev *p = d->dev;
2317   word status = get_conf_word(d, PCI_STATUS);
2318   word cmd = get_conf_word(d, PCI_COMMAND);
2319   word class = p->device_class;
2320   byte bist = get_conf_byte(d, PCI_BIST);
2321   byte htype = get_conf_byte(d, PCI_HEADER_TYPE) & 0x7f;
2322   byte latency = get_conf_byte(d, PCI_LATENCY_TIMER);
2323   byte cache_line = get_conf_byte(d, PCI_CACHE_LINE_SIZE);
2324   byte max_lat, min_gnt;
2325   byte int_pin = get_conf_byte(d, PCI_INTERRUPT_PIN);
2326   unsigned int irq = p->irq;
2327
2328   show_terse(d);
2329
2330   switch (htype)
2331     {
2332     case PCI_HEADER_TYPE_NORMAL:
2333       if (class == PCI_CLASS_BRIDGE_PCI)
2334         printf("\t!!! Invalid class %04x for header type %02x\n", class, htype);
2335       max_lat = get_conf_byte(d, PCI_MAX_LAT);
2336       min_gnt = get_conf_byte(d, PCI_MIN_GNT);
2337       break;
2338     case PCI_HEADER_TYPE_BRIDGE:
2339       if ((class >> 8) != PCI_BASE_CLASS_BRIDGE)
2340         printf("\t!!! Invalid class %04x for header type %02x\n", class, htype);
2341       irq = int_pin = min_gnt = max_lat = 0;
2342       break;
2343     case PCI_HEADER_TYPE_CARDBUS:
2344       if ((class >> 8) != PCI_BASE_CLASS_BRIDGE)
2345         printf("\t!!! Invalid class %04x for header type %02x\n", class, htype);
2346       min_gnt = max_lat = 0;
2347       break;
2348     default:
2349       printf("\t!!! Unknown header type %02x\n", htype);
2350       return;
2351     }
2352
2353   if (verbose > 1)
2354     {
2355       printf("\tControl: I/O%c Mem%c BusMaster%c SpecCycle%c MemWINV%c VGASnoop%c ParErr%c Stepping%c SERR%c FastB2B%c DisINTx%c\n",
2356              FLAG(cmd, PCI_COMMAND_IO),
2357              FLAG(cmd, PCI_COMMAND_MEMORY),
2358              FLAG(cmd, PCI_COMMAND_MASTER),
2359              FLAG(cmd, PCI_COMMAND_SPECIAL),
2360              FLAG(cmd, PCI_COMMAND_INVALIDATE),
2361              FLAG(cmd, PCI_COMMAND_VGA_PALETTE),
2362              FLAG(cmd, PCI_COMMAND_PARITY),
2363              FLAG(cmd, PCI_COMMAND_WAIT),
2364              FLAG(cmd, PCI_COMMAND_SERR),
2365              FLAG(cmd, PCI_COMMAND_FAST_BACK),
2366              FLAG(cmd, PCI_COMMAND_DISABLE_INTx));
2367       printf("\tStatus: Cap%c 66MHz%c UDF%c FastB2B%c ParErr%c DEVSEL=%s >TAbort%c <TAbort%c <MAbort%c >SERR%c <PERR%c INTx%c\n",
2368              FLAG(status, PCI_STATUS_CAP_LIST),
2369              FLAG(status, PCI_STATUS_66MHZ),
2370              FLAG(status, PCI_STATUS_UDF),
2371              FLAG(status, PCI_STATUS_FAST_BACK),
2372              FLAG(status, PCI_STATUS_PARITY),
2373              ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_SLOW) ? "slow" :
2374              ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_MEDIUM) ? "medium" :
2375              ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_FAST) ? "fast" : "??",
2376              FLAG(status, PCI_STATUS_SIG_TARGET_ABORT),
2377              FLAG(status, PCI_STATUS_REC_TARGET_ABORT),
2378              FLAG(status, PCI_STATUS_REC_MASTER_ABORT),
2379              FLAG(status, PCI_STATUS_SIG_SYSTEM_ERROR),
2380              FLAG(status, PCI_STATUS_DETECTED_PARITY),
2381              FLAG(status, PCI_STATUS_INTx));
2382       if (cmd & PCI_COMMAND_MASTER)
2383         {
2384           printf("\tLatency: %d", latency);
2385           if (min_gnt || max_lat)
2386             {
2387               printf(" (");
2388               if (min_gnt)
2389                 printf("%dns min", min_gnt*250);
2390               if (min_gnt && max_lat)
2391                 printf(", ");
2392               if (max_lat)
2393                 printf("%dns max", max_lat*250);
2394               putchar(')');
2395             }
2396           if (cache_line)
2397             printf(", Cache Line Size: %d bytes", cache_line * 4);
2398           putchar('\n');
2399         }
2400       if (int_pin || irq)
2401         printf("\tInterrupt: pin %c routed to IRQ " PCIIRQ_FMT "\n",
2402                (int_pin ? 'A' + int_pin - 1 : '?'), irq);
2403     }
2404   else
2405     {
2406       printf("\tFlags: ");
2407       if (cmd & PCI_COMMAND_MASTER)
2408         printf("bus master, ");
2409       if (cmd & PCI_COMMAND_VGA_PALETTE)
2410         printf("VGA palette snoop, ");
2411       if (cmd & PCI_COMMAND_WAIT)
2412         printf("stepping, ");
2413       if (cmd & PCI_COMMAND_FAST_BACK)
2414         printf("fast Back2Back, ");
2415       if (status & PCI_STATUS_66MHZ)
2416         printf("66MHz, ");
2417       if (status & PCI_STATUS_UDF)
2418         printf("user-definable features, ");
2419       printf("%s devsel",
2420              ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_SLOW) ? "slow" :
2421              ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_MEDIUM) ? "medium" :
2422              ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_FAST) ? "fast" : "??");
2423       if (cmd & PCI_COMMAND_MASTER)
2424         printf(", latency %d", latency);
2425       if (irq)
2426         printf(", IRQ " PCIIRQ_FMT, irq);
2427       putchar('\n');
2428     }
2429
2430   if (bist & PCI_BIST_CAPABLE)
2431     {
2432       if (bist & PCI_BIST_START)
2433         printf("\tBIST is running\n");
2434       else
2435         printf("\tBIST result: %02x\n", bist & PCI_BIST_CODE_MASK);
2436     }
2437
2438   switch (htype)
2439     {
2440     case PCI_HEADER_TYPE_NORMAL:
2441       show_htype0(d);
2442       break;
2443     case PCI_HEADER_TYPE_BRIDGE:
2444       show_htype1(d);
2445       break;
2446     case PCI_HEADER_TYPE_CARDBUS:
2447       show_htype2(d);
2448       break;
2449     }
2450 }
2451
2452 /*** Machine-readable dumps ***/
2453
2454 static void
2455 show_hex_dump(struct device *d)
2456 {
2457   unsigned int i, cnt;
2458
2459   cnt = d->config_cached;
2460   if (opt_hex >= 3 && config_fetch(d, cnt, 256-cnt))
2461     {
2462       cnt = 256;
2463       if (opt_hex >= 4 && config_fetch(d, 256, 4096-256))
2464         cnt = 4096;
2465     }
2466
2467   for(i=0; i<cnt; i++)
2468     {
2469       if (! (i & 15))
2470         printf("%02x:", i);
2471       printf(" %02x", get_conf_byte(d, i));
2472       if ((i & 15) == 15)
2473         putchar('\n');
2474     }
2475 }
2476
2477 static void
2478 print_shell_escaped(char *c)
2479 {
2480   printf(" \"");
2481   while (*c)
2482     {
2483       if (*c == '"' || *c == '\\')
2484         putchar('\\');
2485       putchar(*c++);
2486     }
2487   putchar('"');
2488 }
2489
2490 static void
2491 show_machine(struct device *d)
2492 {
2493   struct pci_dev *p = d->dev;
2494   int c;
2495   word sv_id, sd_id;
2496   char classbuf[128], vendbuf[128], devbuf[128], svbuf[128], sdbuf[128];
2497
2498   get_subid(d, &sv_id, &sd_id);
2499
2500   if (verbose)
2501     {
2502       printf((opt_machine >= 2) ? "Slot:\t" : "Device:\t");
2503       show_slot_name(d);
2504       putchar('\n');
2505       printf("Class:\t%s\n",
2506              pci_lookup_name(pacc, classbuf, sizeof(classbuf), PCI_LOOKUP_CLASS, p->device_class));
2507       printf("Vendor:\t%s\n",
2508              pci_lookup_name(pacc, vendbuf, sizeof(vendbuf), PCI_LOOKUP_VENDOR, p->vendor_id, p->device_id));
2509       printf("Device:\t%s\n",
2510              pci_lookup_name(pacc, devbuf, sizeof(devbuf), PCI_LOOKUP_DEVICE, p->vendor_id, p->device_id));
2511       if (sv_id && sv_id != 0xffff)
2512         {
2513           printf("SVendor:\t%s\n",
2514                  pci_lookup_name(pacc, svbuf, sizeof(svbuf), PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR, sv_id));
2515           printf("SDevice:\t%s\n",
2516                  pci_lookup_name(pacc, sdbuf, sizeof(sdbuf), PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_DEVICE, p->vendor_id, p->device_id, sv_id, sd_id));
2517         }
2518       if (c = get_conf_byte(d, PCI_REVISION_ID))
2519         printf("Rev:\t%02x\n", c);
2520       if (c = get_conf_byte(d, PCI_CLASS_PROG))
2521         printf("ProgIf:\t%02x\n", c);
2522       if (opt_kernel)
2523         show_kernel_machine(d);
2524     }
2525   else
2526     {
2527       show_slot_name(d);
2528       print_shell_escaped(pci_lookup_name(pacc, classbuf, sizeof(classbuf), PCI_LOOKUP_CLASS, p->device_class));
2529       print_shell_escaped(pci_lookup_name(pacc, vendbuf, sizeof(vendbuf), PCI_LOOKUP_VENDOR, p->vendor_id, p->device_id));
2530       print_shell_escaped(pci_lookup_name(pacc, devbuf, sizeof(devbuf), PCI_LOOKUP_DEVICE, p->vendor_id, p->device_id));
2531       if (c = get_conf_byte(d, PCI_REVISION_ID))
2532         printf(" -r%02x", c);
2533       if (c = get_conf_byte(d, PCI_CLASS_PROG))
2534         printf(" -p%02x", c);
2535       if (sv_id && sv_id != 0xffff)
2536         {
2537           print_shell_escaped(pci_lookup_name(pacc, svbuf, sizeof(svbuf), PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR, sv_id));
2538           print_shell_escaped(pci_lookup_name(pacc, sdbuf, sizeof(sdbuf), PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_DEVICE, p->vendor_id, p->device_id, sv_id, sd_id));
2539         }
2540       else
2541         printf(" \"\" \"\"");
2542       putchar('\n');
2543     }
2544 }
2545
2546 /*** Main show function ***/
2547
2548 static void
2549 show_device(struct device *d)
2550 {
2551   if (opt_machine)
2552     show_machine(d);
2553   else
2554     {
2555       if (verbose)
2556         show_verbose(d);
2557       else
2558         show_terse(d);
2559       if (opt_kernel || verbose)
2560         show_kernel(d);
2561     }
2562   if (opt_hex)
2563     show_hex_dump(d);
2564   if (verbose || opt_hex)
2565     putchar('\n');
2566 }
2567
2568 static void
2569 show(void)
2570 {
2571   struct device *d;
2572
2573   for(d=first_dev; d; d=d->next)
2574     show_device(d);
2575 }
2576
2577 /*** Tree output ***/
2578
2579 struct bridge {
2580   struct bridge *chain;                 /* Single-linked list of bridges */
2581   struct bridge *next, *child;          /* Tree of bridges */
2582   struct bus *first_bus;                /* List of buses connected to this bridge */
2583   unsigned int domain;
2584   unsigned int primary, secondary, subordinate; /* Bus numbers */
2585   struct device *br_dev;
2586 };
2587
2588 struct bus {
2589   unsigned int domain;
2590   unsigned int number;
2591   struct bus *sibling;
2592   struct device *first_dev, **last_dev;
2593 };
2594
2595 static struct bridge host_bridge = { NULL, NULL, NULL, NULL, 0, ~0, 0, ~0, NULL };
2596
2597 static struct bus *
2598 find_bus(struct bridge *b, unsigned int domain, unsigned int n)
2599 {
2600   struct bus *bus;
2601
2602   for(bus=b->first_bus; bus; bus=bus->sibling)
2603     if (bus->domain == domain && bus->number == n)
2604       break;
2605   return bus;
2606 }
2607
2608 static struct bus *
2609 new_bus(struct bridge *b, unsigned int domain, unsigned int n)
2610 {
2611   struct bus *bus = xmalloc(sizeof(struct bus));
2612   bus->domain = domain;
2613   bus->number = n;
2614   bus->sibling = b->first_bus;
2615   bus->first_dev = NULL;
2616   bus->last_dev = &bus->first_dev;
2617   b->first_bus = bus;
2618   return bus;
2619 }
2620
2621 static void
2622 insert_dev(struct device *d, struct bridge *b)
2623 {
2624   struct pci_dev *p = d->dev;
2625   struct bus *bus;
2626
2627   if (! (bus = find_bus(b, p->domain, p->bus)))
2628     {
2629       struct bridge *c;
2630       for(c=b->child; c; c=c->next)
2631         if (c->domain == p->domain && c->secondary <= p->bus && p->bus <= c->subordinate)
2632           {
2633             insert_dev(d, c);
2634             return;
2635           }
2636       bus = new_bus(b, p->domain, p->bus);
2637     }
2638   /* Simple insertion at the end _does_ guarantee the correct order as the
2639    * original device list was sorted by (domain, bus, devfn) lexicographically
2640    * and all devices on the new list have the same bus number.
2641    */
2642   *bus->last_dev = d;
2643   bus->last_dev = &d->next;
2644   d->next = NULL;
2645 }
2646
2647 static void
2648 grow_tree(void)
2649 {
2650   struct device *d, *d2;
2651   struct bridge **last_br, *b;
2652
2653   /* Build list of bridges */
2654
2655   last_br = &host_bridge.chain;
2656   for(d=first_dev; d; d=d->next)
2657     {
2658       word class = d->dev->device_class;
2659       byte ht = get_conf_byte(d, PCI_HEADER_TYPE) & 0x7f;
2660       if (class == PCI_CLASS_BRIDGE_PCI &&
2661           (ht == PCI_HEADER_TYPE_BRIDGE || ht == PCI_HEADER_TYPE_CARDBUS))
2662         {
2663           b = xmalloc(sizeof(struct bridge));
2664           b->domain = d->dev->domain;
2665           if (ht == PCI_HEADER_TYPE_BRIDGE)
2666             {
2667               b->primary = get_conf_byte(d, PCI_PRIMARY_BUS);
2668               b->secondary = get_conf_byte(d, PCI_SECONDARY_BUS);
2669               b->subordinate = get_conf_byte(d, PCI_SUBORDINATE_BUS);
2670             }
2671           else
2672             {
2673               b->primary = get_conf_byte(d, PCI_CB_PRIMARY_BUS);
2674               b->secondary = get_conf_byte(d, PCI_CB_CARD_BUS);
2675               b->subordinate = get_conf_byte(d, PCI_CB_SUBORDINATE_BUS);
2676             }
2677           *last_br = b;
2678           last_br = &b->chain;
2679           b->next = b->child = NULL;
2680           b->first_bus = NULL;
2681           b->br_dev = d;
2682         }
2683     }
2684   *last_br = NULL;
2685
2686   /* Create a bridge tree */
2687
2688   for(b=&host_bridge; b; b=b->chain)
2689     {
2690       struct bridge *c, *best;
2691       best = NULL;
2692       for(c=&host_bridge; c; c=c->chain)
2693         if (c != b && (c == &host_bridge || b->domain == c->domain) &&
2694             b->primary >= c->secondary && b->primary <= c->subordinate &&
2695             (!best || best->subordinate - best->primary > c->subordinate - c->primary))
2696           best = c;
2697       if (best)
2698         {
2699           b->next = best->child;
2700           best->child = b;
2701         }
2702     }
2703
2704   /* Insert secondary bus for each bridge */
2705
2706   for(b=&host_bridge; b; b=b->chain)
2707     if (!find_bus(b, b->domain, b->secondary))
2708       new_bus(b, b->domain, b->secondary);
2709
2710   /* Create bus structs and link devices */
2711
2712   for(d=first_dev; d;)
2713     {
2714       d2 = d->next;
2715       insert_dev(d, &host_bridge);
2716       d = d2;
2717     }
2718 }
2719
2720 static void
2721 print_it(char *line, char *p)
2722 {
2723   *p++ = '\n';
2724   *p = 0;
2725   fputs(line, stdout);
2726   for(p=line; *p; p++)
2727     if (*p == '+' || *p == '|')
2728       *p = '|';
2729     else
2730       *p = ' ';
2731 }
2732
2733 static void show_tree_bridge(struct bridge *, char *, char *);
2734
2735 static void
2736 show_tree_dev(struct device *d, char *line, char *p)
2737 {
2738   struct pci_dev *q = d->dev;
2739   struct bridge *b;
2740   char namebuf[256];
2741
2742   p += sprintf(p, "%02x.%x", q->dev, q->func);
2743   for(b=&host_bridge; b; b=b->chain)
2744     if (b->br_dev == d)
2745       {
2746         if (b->secondary == b->subordinate)
2747           p += sprintf(p, "-[%04x:%02x]-", b->domain, b->secondary);
2748         else
2749           p += sprintf(p, "-[%04x:%02x-%02x]-", b->domain, b->secondary, b->subordinate);
2750         show_tree_bridge(b, line, p);
2751         return;
2752       }
2753   if (verbose)
2754     p += sprintf(p, "  %s",
2755                  pci_lookup_name(pacc, namebuf, sizeof(namebuf),
2756                                  PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE,
2757                                  q->vendor_id, q->device_id));
2758   print_it(line, p);
2759 }
2760
2761 static void
2762 show_tree_bus(struct bus *b, char *line, char *p)
2763 {
2764   if (!b->first_dev)
2765     print_it(line, p);
2766   else if (!b->first_dev->next)
2767     {
2768       *p++ = '-';
2769       *p++ = '-';
2770       show_tree_dev(b->first_dev, line, p);
2771     }
2772   else
2773     {
2774       struct device *d = b->first_dev;
2775       while (d->next)
2776         {
2777           p[0] = '+';
2778           p[1] = '-';
2779           show_tree_dev(d, line, p+2);
2780           d = d->next;
2781         }
2782       p[0] = '\\';
2783       p[1] = '-';
2784       show_tree_dev(d, line, p+2);
2785     }
2786 }
2787
2788 static void
2789 show_tree_bridge(struct bridge *b, char *line, char *p)
2790 {
2791   *p++ = '-';
2792   if (!b->first_bus->sibling)
2793     {
2794       if (b == &host_bridge)
2795         p += sprintf(p, "[%04x:%02x]-", b->domain, b->first_bus->number);
2796       show_tree_bus(b->first_bus, line, p);
2797     }
2798   else
2799     {
2800       struct bus *u = b->first_bus;
2801       char *k;
2802
2803       while (u->sibling)
2804         {
2805           k = p + sprintf(p, "+-[%04x:%02x]-", u->domain, u->number);
2806           show_tree_bus(u, line, k);
2807           u = u->sibling;
2808         }
2809       k = p + sprintf(p, "\\-[%04x:%02x]-", u->domain, u->number);
2810       show_tree_bus(u, line, k);
2811     }
2812 }
2813
2814 static void
2815 show_forest(void)
2816 {
2817   char line[256];
2818
2819   grow_tree();
2820   show_tree_bridge(&host_bridge, line, line);
2821 }
2822
2823 /*** Bus mapping mode ***/
2824
2825 struct bus_bridge {
2826   struct bus_bridge *next;
2827   byte this, dev, func, first, last, bug;
2828 };
2829
2830 struct bus_info {
2831   byte exists;
2832   byte guestbook;
2833   struct bus_bridge *bridges, *via;
2834 };
2835
2836 static struct bus_info *bus_info;
2837
2838 static void
2839 map_bridge(struct bus_info *bi, struct device *d, int np, int ns, int nl)
2840 {
2841   struct bus_bridge *b = xmalloc(sizeof(struct bus_bridge));
2842   struct pci_dev *p = d->dev;
2843
2844   b->next = bi->bridges;
2845   bi->bridges = b;
2846   b->this = get_conf_byte(d, np);
2847   b->dev = p->dev;
2848   b->func = p->func;
2849   b->first = get_conf_byte(d, ns);
2850   b->last = get_conf_byte(d, nl);
2851   printf("## %02x.%02x:%d is a bridge from %02x to %02x-%02x\n",
2852          p->bus, p->dev, p->func, b->this, b->first, b->last);
2853   if (b->this != p->bus)
2854     printf("!!! Bridge points to invalid primary bus.\n");
2855   if (b->first > b->last)
2856     {
2857       printf("!!! Bridge points to invalid bus range.\n");
2858       b->last = b->first;
2859     }
2860 }
2861
2862 static void
2863 do_map_bus(int bus)
2864 {
2865   int dev, func;
2866   int verbose = pacc->debugging;
2867   struct bus_info *bi = bus_info + bus;
2868   struct device *d;
2869
2870   if (verbose)
2871     printf("Mapping bus %02x\n", bus);
2872   for(dev = 0; dev < 32; dev++)
2873     if (filter.slot < 0 || filter.slot == dev)
2874       {
2875         int func_limit = 1;
2876         for(func = 0; func < func_limit; func++)
2877           if (filter.func < 0 || filter.func == func)
2878             {
2879               /* XXX: Bus mapping supports only domain 0 */
2880               struct pci_dev *p = pci_get_dev(pacc, 0, bus, dev, func);
2881               u16 vendor = pci_read_word(p, PCI_VENDOR_ID);
2882               if (vendor && vendor != 0xffff)
2883                 {
2884                   if (!func && (pci_read_byte(p, PCI_HEADER_TYPE) & 0x80))
2885                     func_limit = 8;
2886                   if (verbose)
2887                     printf("Discovered device %02x:%02x.%d\n", bus, dev, func);
2888                   bi->exists = 1;
2889                   if (d = scan_device(p))
2890                     {
2891                       show_device(d);
2892                       switch (get_conf_byte(d, PCI_HEADER_TYPE) & 0x7f)
2893                         {
2894                         case PCI_HEADER_TYPE_BRIDGE:
2895                           map_bridge(bi, d, PCI_PRIMARY_BUS, PCI_SECONDARY_BUS, PCI_SUBORDINATE_BUS);
2896                           break;
2897                         case PCI_HEADER_TYPE_CARDBUS:
2898                           map_bridge(bi, d, PCI_CB_PRIMARY_BUS, PCI_CB_CARD_BUS, PCI_CB_SUBORDINATE_BUS);
2899                           break;
2900                         }
2901                       free(d);
2902                     }
2903                   else if (verbose)
2904                     printf("But it was filtered out.\n");
2905                 }
2906               pci_free_dev(p);
2907             }
2908       }
2909 }
2910
2911 static void
2912 do_map_bridges(int bus, int min, int max)
2913 {
2914   struct bus_info *bi = bus_info + bus;
2915   struct bus_bridge *b;
2916
2917   bi->guestbook = 1;
2918   for(b=bi->bridges; b; b=b->next)
2919     {
2920       if (bus_info[b->first].guestbook)
2921         b->bug = 1;
2922       else if (b->first < min || b->last > max)
2923         b->bug = 2;
2924       else
2925         {
2926           bus_info[b->first].via = b;
2927           do_map_bridges(b->first, b->first, b->last);
2928         }
2929     }
2930 }
2931
2932 static void
2933 map_bridges(void)
2934 {
2935   int i;
2936
2937   printf("\nSummary of buses:\n\n");
2938   for(i=0; i<256; i++)
2939     if (bus_info[i].exists && !bus_info[i].guestbook)
2940       do_map_bridges(i, 0, 255);
2941   for(i=0; i<256; i++)
2942     {
2943       struct bus_info *bi = bus_info + i;
2944       struct bus_bridge *b = bi->via;
2945
2946       if (bi->exists)
2947         {
2948           printf("%02x: ", i);
2949           if (b)
2950             printf("Entered via %02x:%02x.%d\n", b->this, b->dev, b->func);
2951           else if (!i)
2952             printf("Primary host bus\n");
2953           else
2954             printf("Secondary host bus (?)\n");
2955         }
2956       for(b=bi->bridges; b; b=b->next)
2957         {
2958           printf("\t%02x.%d Bridge to %02x-%02x", b->dev, b->func, b->first, b->last);
2959           switch (b->bug)
2960             {
2961             case 1:
2962               printf(" <overlap bug>");
2963               break;
2964             case 2:
2965               printf(" <crossing bug>");
2966               break;
2967             }
2968           putchar('\n');
2969         }
2970     }
2971 }
2972
2973 static void
2974 map_the_bus(void)
2975 {
2976   if (pacc->method == PCI_ACCESS_PROC_BUS_PCI ||
2977       pacc->method == PCI_ACCESS_DUMP)
2978     printf("WARNING: Bus mapping can be reliable only with direct hardware access enabled.\n\n");
2979   bus_info = xmalloc(sizeof(struct bus_info) * 256);
2980   memset(bus_info, 0, sizeof(struct bus_info) * 256);
2981   if (filter.bus >= 0)
2982     do_map_bus(filter.bus);
2983   else
2984     {
2985       int bus;
2986       for(bus=0; bus<256; bus++)
2987         do_map_bus(bus);
2988     }
2989   map_bridges();
2990 }
2991
2992 /* Main */
2993
2994 int
2995 main(int argc, char **argv)
2996 {
2997   int i;
2998   char *msg;
2999
3000   if (argc == 2 && !strcmp(argv[1], "--version"))
3001     {
3002       puts("lspci version " PCIUTILS_VERSION);
3003       return 0;
3004     }
3005
3006   pacc = pci_alloc();
3007   pacc->error = die;
3008   pci_filter_init(pacc, &filter);
3009
3010   while ((i = getopt(argc, argv, options)) != -1)
3011     switch (i)
3012       {
3013       case 'n':
3014         pacc->numeric_ids++;
3015         break;
3016       case 'v':
3017         verbose++;
3018         break;
3019       case 'b':
3020         pacc->buscentric = 1;
3021         opt_buscentric = 1;
3022         break;
3023       case 's':
3024         if (msg = pci_filter_parse_slot(&filter, optarg))
3025           die("-s: %s", msg);
3026         break;
3027       case 'd':
3028         if (msg = pci_filter_parse_id(&filter, optarg))
3029           die("-d: %s", msg);
3030         break;
3031       case 'x':
3032         opt_hex++;
3033         break;
3034       case 't':
3035         opt_tree++;
3036         break;
3037       case 'i':
3038         pci_set_name_list_path(pacc, optarg, 0);
3039         break;
3040       case 'm':
3041         opt_machine++;
3042         break;
3043       case 'p':
3044         opt_pcimap = optarg;
3045         break;
3046 #ifdef PCI_OS_LINUX
3047       case 'k':
3048         opt_kernel++;
3049         break;
3050 #endif
3051       case 'M':
3052         opt_map_mode++;
3053         break;
3054       case 'D':
3055         opt_domains = 2;
3056         break;
3057 #ifdef PCI_USE_DNS
3058       case 'q':
3059         opt_query_dns++;
3060         break;
3061       case 'Q':
3062         opt_query_all = 1;
3063         break;
3064 #else
3065       case 'q':
3066       case 'Q':
3067         die("DNS queries are not available in this version");
3068 #endif
3069       default:
3070         if (parse_generic_option(i, pacc, optarg))
3071           break;
3072       bad:
3073         fprintf(stderr, help_msg, pacc->id_file_name);
3074         return 1;
3075       }
3076   if (optind < argc)
3077     goto bad;
3078
3079   if (opt_query_dns)
3080     {
3081       pacc->id_lookup_mode |= PCI_LOOKUP_NETWORK;
3082       if (opt_query_dns > 1)
3083         pacc->id_lookup_mode |= PCI_LOOKUP_REFRESH_CACHE;
3084     }
3085   if (opt_query_all)
3086     pacc->id_lookup_mode |= PCI_LOOKUP_NETWORK | PCI_LOOKUP_SKIP_LOCAL;
3087
3088   pci_init(pacc);
3089   if (opt_map_mode)
3090     map_the_bus();
3091   else
3092     {
3093       scan_devices();
3094       sort_them();
3095       if (opt_tree)
3096         show_forest();
3097       else
3098         show();
3099     }
3100   pci_cleanup(pacc);
3101
3102   return (seen_errors ? 2 : 0);
3103 }