usr.sbin/pciconf/cap.c

   1 /*-
   2  * Copyright (c) 2007 Yahoo!, Inc.
   3  * All rights reserved.
   4  * Written by: John Baldwin <jhb@FreeBSD.org>
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. Neither the name of the author nor the names of any co-contributors
  15  *    may be used to endorse or promote products derived from this software
  16  *    without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #ifndef lint
  32 static const char rcsid[] =
  33   "$FreeBSD$";
  34 #endif /* not lint */
  35
  36 #include <sys/types.h>
  37
  38 #include <err.h>
  39 #include <stdio.h>
  40 #include <sys/agpio.h>
  41 #include <sys/pciio.h>
  42
  43 #include <dev/agp/agpreg.h>
  44 #include <dev/pci/pcireg.h>
  45
  46 #include "pciconf.h"
  47
  48 static void     list_ecaps(int fd, struct pci_conf *p);
  49
  50 static void
  51 cap_power(int fd, struct pci_conf *p, uint8_t ptr)
  52 {
  53         uint16_t cap, status;
  54
  55         cap = read_config(fd, &p->pc_sel, ptr + PCIR_POWER_CAP, 2);
  56         status = read_config(fd, &p->pc_sel, ptr + PCIR_POWER_STATUS, 2);
  57         printf("powerspec %d  supports D0%s%s D3  current D%d",
  58             cap & PCIM_PCAP_SPEC,
  59             cap & PCIM_PCAP_D1SUPP ? " D1" : "",
  60             cap & PCIM_PCAP_D2SUPP ? " D2" : "",
  61             status & PCIM_PSTAT_DMASK);
  62 }
  63
  64 static void
  65 cap_agp(int fd, struct pci_conf *p, uint8_t ptr)
  66 {
  67         uint32_t status, command;
  68
  69         status = read_config(fd, &p->pc_sel, ptr + AGP_STATUS, 4);
  70         command = read_config(fd, &p->pc_sel, ptr + AGP_CAPID, 4);
  71         printf("AGP ");
  72         if (AGP_MODE_GET_MODE_3(status)) {
  73                 printf("v3 ");
  74                 if (AGP_MODE_GET_RATE(status) & AGP_MODE_V3_RATE_8x)
  75                         printf("8x ");
  76                 if (AGP_MODE_GET_RATE(status) & AGP_MODE_V3_RATE_4x)
  77                         printf("4x ");
  78         } else {
  79                 if (AGP_MODE_GET_RATE(status) & AGP_MODE_V2_RATE_4x)
  80                         printf("4x ");
  81                 if (AGP_MODE_GET_RATE(status) & AGP_MODE_V2_RATE_2x)
  82                         printf("2x ");
  83                 if (AGP_MODE_GET_RATE(status) & AGP_MODE_V2_RATE_1x)
  84                         printf("1x ");
  85         }
  86         if (AGP_MODE_GET_SBA(status))
  87                 printf("SBA ");
  88         if (AGP_MODE_GET_AGP(command)) {
  89                 printf("enabled at ");
  90                 if (AGP_MODE_GET_MODE_3(command)) {
  91                         printf("v3 ");
  92                         switch (AGP_MODE_GET_RATE(command)) {
  93                         case AGP_MODE_V3_RATE_8x:
  94                                 printf("8x ");
  95                                 break;
  96                         case AGP_MODE_V3_RATE_4x:
  97                                 printf("4x ");
  98                                 break;
  99                         }
 100                 } else
 101                         switch (AGP_MODE_GET_RATE(command)) {
 102                         case AGP_MODE_V2_RATE_4x:
 103                                 printf("4x ");
 104                                 break;
 105                         case AGP_MODE_V2_RATE_2x:
 106                                 printf("2x ");
 107                                 break;
 108                         case AGP_MODE_V2_RATE_1x:
 109                                 printf("1x ");
 110                                 break;
 111                         }
 112                 if (AGP_MODE_GET_SBA(command))
 113                         printf("SBA ");
 114         } else
 115                 printf("disabled");
 116 }
 117
 118 static void
 119 cap_vpd(int fd, struct pci_conf *p, uint8_t ptr)
 120 {
 121
 122         printf("VPD");
 123 }
 124
 125 static void
 126 cap_msi(int fd, struct pci_conf *p, uint8_t ptr)
 127 {
 128         uint16_t ctrl;
 129         int msgnum;
 130
 131         ctrl = read_config(fd, &p->pc_sel, ptr + PCIR_MSI_CTRL, 2);
 132         msgnum = 1 << ((ctrl & PCIM_MSICTRL_MMC_MASK) >> 1);
 133         printf("MSI supports %d message%s%s%s ", msgnum,
 134             (msgnum == 1) ? "" : "s",
 135             (ctrl & PCIM_MSICTRL_64BIT) ? ", 64 bit" : "",
 136             (ctrl & PCIM_MSICTRL_VECTOR) ? ", vector masks" : "");
 137         if (ctrl & PCIM_MSICTRL_MSI_ENABLE) {
 138                 msgnum = 1 << ((ctrl & PCIM_MSICTRL_MME_MASK) >> 4);
 139                 printf("enabled with %d message%s", msgnum,
 140                     (msgnum == 1) ? "" : "s");
 141         }
 142 }
 143
 144 static void
 145 cap_pcix(int fd, struct pci_conf *p, uint8_t ptr)
 146 {
 147         uint32_t status;
 148         int comma, max_splits, max_burst_read;
 149
 150         status = read_config(fd, &p->pc_sel, ptr + PCIXR_STATUS, 4);
 151         printf("PCI-X ");
 152         if (status & PCIXM_STATUS_64BIT)
 153                 printf("64-bit ");
 154         if ((p->pc_hdr & PCIM_HDRTYPE) == 1)
 155                 printf("bridge ");
 156         if ((p->pc_hdr & PCIM_HDRTYPE) != 1 || (status & (PCIXM_STATUS_133CAP |
 157             PCIXM_STATUS_266CAP | PCIXM_STATUS_533CAP)) != 0)
 158                 printf("supports");
 159         comma = 0;
 160         if (status & PCIXM_STATUS_133CAP) {
 161                 printf("%s 133MHz", comma ? "," : "");
 162                 comma = 1;
 163         }
 164         if (status & PCIXM_STATUS_266CAP) {
 165                 printf("%s 266MHz", comma ? "," : "");
 166                 comma = 1;
 167         }
 168         if (status & PCIXM_STATUS_533CAP) {
 169                 printf("%s 533MHz", comma ? "," : "");
 170                 comma = 1;
 171         }
 172         if ((p->pc_hdr & PCIM_HDRTYPE) == 1)
 173                 return;
 174         switch (status & PCIXM_STATUS_MAX_READ) {
 175         case PCIXM_STATUS_MAX_READ_512:
 176                 max_burst_read = 512;
 177                 break;
 178         case PCIXM_STATUS_MAX_READ_1024:
 179                 max_burst_read = 1024;
 180                 break;
 181         case PCIXM_STATUS_MAX_READ_2048:
 182                 max_burst_read = 2048;
 183                 break;
 184         case PCIXM_STATUS_MAX_READ_4096:
 185                 max_burst_read = 4096;
 186                 break;
 187         }
 188         switch (status & PCIXM_STATUS_MAX_SPLITS) {
 189         case PCIXM_STATUS_MAX_SPLITS_1:
 190                 max_splits = 1;
 191                 break;
 192         case PCIXM_STATUS_MAX_SPLITS_2:
 193                 max_splits = 2;
 194                 break;
 195         case PCIXM_STATUS_MAX_SPLITS_3:
 196                 max_splits = 3;
 197                 break;
 198         case PCIXM_STATUS_MAX_SPLITS_4:
 199                 max_splits = 4;
 200                 break;
 201         case PCIXM_STATUS_MAX_SPLITS_8:
 202                 max_splits = 8;
 203                 break;
 204         case PCIXM_STATUS_MAX_SPLITS_12:
 205                 max_splits = 12;
 206                 break;
 207         case PCIXM_STATUS_MAX_SPLITS_16:
 208                 max_splits = 16;
 209                 break;
 210         case PCIXM_STATUS_MAX_SPLITS_32:
 211                 max_splits = 32;
 212                 break;
 213         }
 214         printf("%s %d burst read, %d split transaction%s", comma ? "," : "",
 215             max_burst_read, max_splits, max_splits == 1 ? "" : "s");
 216 }
 217
 218 static void
 219 cap_ht(int fd, struct pci_conf *p, uint8_t ptr)
 220 {
 221         uint32_t reg;
 222         uint16_t command;
 223
 224         command = read_config(fd, &p->pc_sel, ptr + PCIR_HT_COMMAND, 2);
 225         printf("HT ");
 226         if ((command & 0xe000) == PCIM_HTCAP_SLAVE)
 227                 printf("slave");
 228         else if ((command & 0xe000) == PCIM_HTCAP_HOST)
 229                 printf("host");
 230         else
 231                 switch (command & PCIM_HTCMD_CAP_MASK) {
 232                 case PCIM_HTCAP_SWITCH:
 233                         printf("switch");
 234                         break;
 235                 case PCIM_HTCAP_INTERRUPT:
 236                         printf("interrupt");
 237                         break;
 238                 case PCIM_HTCAP_REVISION_ID:
 239                         printf("revision ID");
 240                         break;
 241                 case PCIM_HTCAP_UNITID_CLUMPING:
 242                         printf("unit ID clumping");
 243                         break;
 244                 case PCIM_HTCAP_EXT_CONFIG_SPACE:
 245                         printf("extended config space");
 246                         break;
 247                 case PCIM_HTCAP_ADDRESS_MAPPING:
 248                         printf("address mapping");
 249                         break;
 250                 case PCIM_HTCAP_MSI_MAPPING:
 251                         printf("MSI %saddress window %s at 0x",
 252                             command & PCIM_HTCMD_MSI_FIXED ? "fixed " : "",
 253                             command & PCIM_HTCMD_MSI_ENABLE ? "enabled" :
 254                             "disabled");
 255                         if (command & PCIM_HTCMD_MSI_FIXED)
 256                                 printf("fee00000");
 257                         else {
 258                                 reg = read_config(fd, &p->pc_sel,
 259                                     ptr + PCIR_HTMSI_ADDRESS_HI, 4);
 260                                 if (reg != 0)
 261                                         printf("%08x", reg);
 262                                 reg = read_config(fd, &p->pc_sel,
 263                                     ptr + PCIR_HTMSI_ADDRESS_LO, 4);
 264                                 printf("%08x", reg);
 265                         }
 266                         break;
 267                 case PCIM_HTCAP_DIRECT_ROUTE:
 268                         printf("direct route");
 269                         break;
 270                 case PCIM_HTCAP_VCSET:
 271                         printf("VC set");
 272                         break;
 273                 case PCIM_HTCAP_RETRY_MODE:
 274                         printf("retry mode");
 275                         break;
 276                 case PCIM_HTCAP_X86_ENCODING:
 277                         printf("X86 encoding");
 278                         break;
 279                 default:
 280                         printf("unknown %02x", command);
 281                         break;
 282                 }
 283 }
 284
 285 static void
 286 cap_vendor(int fd, struct pci_conf *p, uint8_t ptr)
 287 {
 288         uint8_t length;
 289
 290         length = read_config(fd, &p->pc_sel, ptr + PCIR_VENDOR_LENGTH, 1);
 291         printf("vendor (length %d)", length);
 292         if (p->pc_vendor == 0x8086) {
 293                 /* Intel */
 294                 uint8_t version;
 295
 296                 version = read_config(fd, &p->pc_sel, ptr + PCIR_VENDOR_DATA,
 297                     1);
 298                 printf(" Intel cap %d version %d", version >> 4, version & 0xf);
 299                 if (version >> 4 == 1 && length == 12) {
 300                         /* Feature Detection */
 301                         uint32_t fvec;
 302                         int comma;
 303
 304                         comma = 0;
 305                         fvec = read_config(fd, &p->pc_sel, ptr +
 306                             PCIR_VENDOR_DATA + 5, 4);
 307                         printf("\n\t\t features:");
 308                         if (fvec & (1 << 0)) {
 309                                 printf(" AMT");
 310                                 comma = 1;
 311                         }
 312                         fvec = read_config(fd, &p->pc_sel, ptr +
 313                             PCIR_VENDOR_DATA + 1, 4);
 314                         if (fvec & (1 << 21)) {
 315                                 printf("%s Quick Resume", comma ? "," : "");
 316                                 comma = 1;
 317                         }
 318                         if (fvec & (1 << 18)) {
 319                                 printf("%s SATA RAID-5", comma ? "," : "");
 320                                 comma = 1;
 321                         }
 322                         if (fvec & (1 << 9)) {
 323                                 printf("%s Mobile", comma ? "," : "");
 324                                 comma = 1;
 325                         }
 326                         if (fvec & (1 << 7)) {
 327                                 printf("%s 6 PCI-e x1 slots", comma ? "," : "");
 328                                 comma = 1;
 329                         } else {
 330                                 printf("%s 4 PCI-e x1 slots", comma ? "," : "");
 331                                 comma = 1;
 332                         }
 333                         if (fvec & (1 << 5)) {
 334                                 printf("%s SATA RAID-0/1/10", comma ? "," : "");
 335                                 comma = 1;
 336                         }
 337                         if (fvec & (1 << 3)) {
 338                                 printf("%s SATA AHCI", comma ? "," : "");
 339                                 comma = 1;
 340                         }
 341                 }
 342         }
 343 }
 344
 345 static void
 346 cap_debug(int fd, struct pci_conf *p, uint8_t ptr)
 347 {
 348         uint16_t debug_port;
 349
 350         debug_port = read_config(fd, &p->pc_sel, ptr + PCIR_DEBUG_PORT, 2);
 351         printf("EHCI Debug Port at offset 0x%x in map 0x%x", debug_port &
 352             PCIM_DEBUG_PORT_OFFSET, PCIR_BAR(debug_port >> 13));
 353 }
 354
 355 static void
 356 cap_subvendor(int fd, struct pci_conf *p, uint8_t ptr)
 357 {
 358         uint32_t id;
 359
 360         id = read_config(fd, &p->pc_sel, ptr + PCIR_SUBVENDCAP_ID, 4);
 361         printf("PCI Bridge card=0x%08x", id);
 362 }
 363
 364 #define MAX_PAYLOAD(field)              (128 << (field))
 365
 366 static void
 367 cap_express(int fd, struct pci_conf *p, uint8_t ptr)
 368 {
 369         uint32_t val;
 370         uint16_t flags;
 371
 372         flags = read_config(fd, &p->pc_sel, ptr + PCIR_EXPRESS_FLAGS, 2);
 373         printf("PCI-Express %d ", flags & PCIM_EXP_FLAGS_VERSION);
 374         switch (flags & PCIM_EXP_FLAGS_TYPE) {
 375         case PCIM_EXP_TYPE_ENDPOINT:
 376                 printf("endpoint");
 377                 break;
 378         case PCIM_EXP_TYPE_LEGACY_ENDPOINT:
 379                 printf("legacy endpoint");
 380                 break;
 381         case PCIM_EXP_TYPE_ROOT_PORT:
 382                 printf("root port");
 383                 break;
 384         case PCIM_EXP_TYPE_UPSTREAM_PORT:
 385                 printf("upstream port");
 386                 break;
 387         case PCIM_EXP_TYPE_DOWNSTREAM_PORT:
 388                 printf("downstream port");
 389                 break;
 390         case PCIM_EXP_TYPE_PCI_BRIDGE:
 391                 printf("PCI bridge");
 392                 break;
 393         case PCIM_EXP_TYPE_PCIE_BRIDGE:
 394                 printf("PCI to PCIe bridge");
 395                 break;
 396         case PCIM_EXP_TYPE_ROOT_INT_EP:
 397                 printf("root endpoint");
 398                 break;
 399         case PCIM_EXP_TYPE_ROOT_EC:
 400                 printf("event collector");
 401                 break;
 402         default:
 403                 printf("type %d", (flags & PCIM_EXP_FLAGS_TYPE) >> 4);
 404                 break;
 405         }
 406         if (flags & PCIM_EXP_FLAGS_IRQ)
 407                 printf(" IRQ %d", (flags & PCIM_EXP_FLAGS_IRQ) >> 8);
 408         val = read_config(fd, &p->pc_sel, ptr + PCIR_EXPRESS_DEVICE_CAP, 4);
 409         flags = read_config(fd, &p->pc_sel, ptr + PCIR_EXPRESS_DEVICE_CTL, 2);
 410         printf(" max data %d(%d)",
 411             MAX_PAYLOAD((flags & PCIM_EXP_CTL_MAX_PAYLOAD) >> 5),
 412             MAX_PAYLOAD(val & PCIM_EXP_CAP_MAX_PAYLOAD));
 413         val = read_config(fd, &p->pc_sel, ptr + PCIR_EXPRESS_LINK_CAP, 4);
 414         flags = read_config(fd, &p->pc_sel, ptr+ PCIR_EXPRESS_LINK_STA, 2);
 415         printf(" link x%d(x%d)", (flags & PCIM_LINK_STA_WIDTH) >> 4,
 416             (val & PCIM_LINK_CAP_MAX_WIDTH) >> 4);
 417 }
 418
 419 static void
 420 cap_msix(int fd, struct pci_conf *p, uint8_t ptr)
 421 {
 422         uint32_t val;
 423         uint16_t ctrl;
 424         int msgnum, table_bar, pba_bar;
 425
 426         ctrl = read_config(fd, &p->pc_sel, ptr + PCIR_MSIX_CTRL, 2);
 427         msgnum = (ctrl & PCIM_MSIXCTRL_TABLE_SIZE) + 1;
 428         val = read_config(fd, &p->pc_sel, ptr + PCIR_MSIX_TABLE, 4);
 429         table_bar = PCIR_BAR(val & PCIM_MSIX_BIR_MASK);
 430         val = read_config(fd, &p->pc_sel, ptr + PCIR_MSIX_PBA, 4);
 431         pba_bar = PCIR_BAR(val & PCIM_MSIX_BIR_MASK);
 432         printf("MSI-X supports %d message%s ", msgnum,
 433             (msgnum == 1) ? "" : "s");
 434         if (table_bar == pba_bar)
 435                 printf("in map 0x%x", table_bar);
 436         else
 437                 printf("in maps 0x%x and 0x%x", table_bar, pba_bar);
 438         if (ctrl & PCIM_MSIXCTRL_MSIX_ENABLE)
 439                 printf(" enabled");
 440 }
 441
 442 static void
 443 cap_sata(int fd, struct pci_conf *p, uint8_t ptr)
 444 {
 445
 446         printf("SATA Index-Data Pair");
 447 }
 448
 449 static void
 450 cap_pciaf(int fd, struct pci_conf *p, uint8_t ptr)
 451 {
 452         uint8_t cap;
 453
 454         cap = read_config(fd, &p->pc_sel, ptr + PCIR_PCIAF_CAP, 1);
 455         printf("PCI Advanced Features:%s%s",
 456             cap & PCIM_PCIAFCAP_FLR ? " FLR" : "",
 457             cap & PCIM_PCIAFCAP_TP  ? " TP"  : "");
 458 }
 459
 460 void
 461 list_caps(int fd, struct pci_conf *p)
 462 {
 463         int express;
 464         uint16_t sta;
 465         uint8_t ptr, cap;
 466
 467         /* Are capabilities present for this device? */
 468         sta = read_config(fd, &p->pc_sel, PCIR_STATUS, 2);
 469         if (!(sta & PCIM_STATUS_CAPPRESENT))
 470                 return;
 471
 472         switch (p->pc_hdr & PCIM_HDRTYPE) {
 473         case PCIM_HDRTYPE_NORMAL:
 474         case PCIM_HDRTYPE_BRIDGE:
 475                 ptr = PCIR_CAP_PTR;
 476                 break;
 477         case PCIM_HDRTYPE_CARDBUS:
 478                 ptr = PCIR_CAP_PTR_2;
 479                 break;
 480         default:
 481                 errx(1, "list_caps: bad header type");
 482         }
 483
 484         /* Walk the capability list. */
 485         express = 0;
 486         ptr = read_config(fd, &p->pc_sel, ptr, 1);
 487         while (ptr != 0 && ptr != 0xff) {
 488                 cap = read_config(fd, &p->pc_sel, ptr + PCICAP_ID, 1);
 489                 printf("    cap %02x[%02x] = ", cap, ptr);
 490                 switch (cap) {
 491                 case PCIY_PMG:
 492                         cap_power(fd, p, ptr);
 493                         break;
 494                 case PCIY_AGP:
 495                         cap_agp(fd, p, ptr);
 496                         break;
 497                 case PCIY_VPD:
 498                         cap_vpd(fd, p, ptr);
 499                         break;
 500                 case PCIY_MSI:
 501                         cap_msi(fd, p, ptr);
 502                         break;
 503                 case PCIY_PCIX:
 504                         cap_pcix(fd, p, ptr);
 505                         break;
 506                 case PCIY_HT:
 507                         cap_ht(fd, p, ptr);
 508                         break;
 509                 case PCIY_VENDOR:
 510                         cap_vendor(fd, p, ptr);
 511                         break;
 512                 case PCIY_DEBUG:
 513                         cap_debug(fd, p, ptr);
 514                         break;
 515                 case PCIY_SUBVENDOR:
 516                         cap_subvendor(fd, p, ptr);
 517                         break;
 518                 case PCIY_EXPRESS:
 519                         express = 1;
 520                         cap_express(fd, p, ptr);
 521                         break;
 522                 case PCIY_MSIX:
 523                         cap_msix(fd, p, ptr);
 524                         break;
 525                 case PCIY_SATA:
 526                         cap_sata(fd, p, ptr);
 527                         break;
 528                 case PCIY_PCIAF:
 529                         cap_pciaf(fd, p, ptr);
 530                         break;
 531                 default:
 532                         printf("unknown");
 533                         break;
 534                 }
 535                 printf("\n");
 536                 ptr = read_config(fd, &p->pc_sel, ptr + PCICAP_NEXTPTR, 1);
 537         }
 538
 539         if (express)
 540                 list_ecaps(fd, p);
 541 }
 542
 543 /* From <sys/systm.h>. */
 544 static __inline uint32_t
 545 bitcount32(uint32_t x)
 546 {
 547
 548         x = (x & 0x55555555) + ((x & 0xaaaaaaaa) >> 1);
 549         x = (x & 0x33333333) + ((x & 0xcccccccc) >> 2);
 550         x = (x + (x >> 4)) & 0x0f0f0f0f;
 551         x = (x + (x >> 8));
 552         x = (x + (x >> 16)) & 0x000000ff;
 553         return (x);
 554 }
 555
 556 static void
 557 ecap_aer(int fd, struct pci_conf *p, uint16_t ptr, uint8_t ver)
 558 {
 559         uint32_t sta, mask;
 560
 561         printf("AER %d", ver);
 562         if (ver != 1)
 563                 return;
 564         sta = read_config(fd, &p->pc_sel, ptr + PCIR_AER_UC_STATUS, 4);
 565         mask = read_config(fd, &p->pc_sel, ptr + PCIR_AER_UC_SEVERITY, 4);
 566         printf(" %d fatal", bitcount32(sta & mask));
 567         printf(" %d non-fatal", bitcount32(sta & ~mask));
 568         sta = read_config(fd, &p->pc_sel, ptr + PCIR_AER_COR_STATUS, 4);
 569         printf(" %d corrected", bitcount32(sta));
 570 }
 571
 572 static void
 573 ecap_vc(int fd, struct pci_conf *p, uint16_t ptr, uint8_t ver)
 574 {
 575         uint32_t cap1;
 576
 577         printf("VC %d", ver);
 578         if (ver != 1)
 579                 return;
 580         cap1 = read_config(fd, &p->pc_sel, ptr + PCIR_VC_CAP1, 4);
 581         printf(" max VC%d", cap1 & PCIM_VC_CAP1_EXT_COUNT);
 582         if ((cap1 & PCIM_VC_CAP1_LOWPRI_EXT_COUNT) != 0)
 583                 printf(" lowpri VC0-VC%d",
 584                     (cap1 & PCIM_VC_CAP1_LOWPRI_EXT_COUNT) >> 4);
 585 }
 586
 587 static void
 588 ecap_sernum(int fd, struct pci_conf *p, uint16_t ptr, uint8_t ver)
 589 {
 590         uint32_t high, low;
 591
 592         printf("Serial %d", ver);
 593         if (ver != 1)
 594                 return;
 595         low = read_config(fd, &p->pc_sel, ptr + PCIR_SERIAL_LOW, 4);
 596         high = read_config(fd, &p->pc_sel, ptr + PCIR_SERIAL_HIGH, 4);
 597         printf(" %08x%08x", high, low);
 598 }
 599
 600 static void
 601 list_ecaps(int fd, struct pci_conf *p)
 602 {
 603         uint32_t ecap;
 604         uint16_t ptr;
 605
 606         ptr = PCIR_EXTCAP;
 607         ecap = read_config(fd, &p->pc_sel, ptr, 4);
 608         if (ecap == 0xffffffff || ecap == 0)
 609                 return;
 610         for (;;) {
 611                 printf("ecap %04x[%03x] = ", PCI_EXTCAP_ID(ecap), ptr);
 612                 switch (PCI_EXTCAP_ID(ecap)) {
 613                 case PCIZ_AER:
 614                         ecap_aer(fd, p, ptr, PCI_EXTCAP_VER(ecap));
 615                         break;
 616                 case PCIZ_VC:
 617                         ecap_vc(fd, p, ptr, PCI_EXTCAP_VER(ecap));
 618                         break;
 619                 case PCIZ_SERNUM:
 620                         ecap_sernum(fd, p, ptr, PCI_EXTCAP_VER(ecap));
 621                         break;
 622                 default:
 623                         printf("unknown %d", PCI_EXTCAP_VER(ecap));
 624                         break;
 625                 }
 626                 printf("\n");
 627                 ptr = PCI_EXTCAP_NEXTPTR(ecap);
 628                 if (ptr == 0)
 629                         break;
 630                 ecap = read_config(fd, &p->pc_sel, ptr, 4);
 631         }
 632 }