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 const char *
 367 link_speed_string(uint8_t speed)
 368 {
 369
 370         switch (speed) {
 371         case 1:
 372                 return ("2.5");
 373         case 2:
 374                 return ("5.0");
 375         case 3:
 376                 return ("8.0");
 377         default:
 378                 return ("undef");
 379         }
 380 }
 381
 382 static void
 383 cap_express(int fd, struct pci_conf *p, uint8_t ptr)
 384 {
 385         uint32_t val;
 386         uint16_t flags;
 387
 388         flags = read_config(fd, &p->pc_sel, ptr + PCIER_FLAGS, 2);
 389         printf("PCI-Express %d ", flags & PCIEM_FLAGS_VERSION);
 390         switch (flags & PCIEM_FLAGS_TYPE) {
 391         case PCIEM_TYPE_ENDPOINT:
 392                 printf("endpoint");
 393                 break;
 394         case PCIEM_TYPE_LEGACY_ENDPOINT:
 395                 printf("legacy endpoint");
 396                 break;
 397         case PCIEM_TYPE_ROOT_PORT:
 398                 printf("root port");
 399                 break;
 400         case PCIEM_TYPE_UPSTREAM_PORT:
 401                 printf("upstream port");
 402                 break;
 403         case PCIEM_TYPE_DOWNSTREAM_PORT:
 404                 printf("downstream port");
 405                 break;
 406         case PCIEM_TYPE_PCI_BRIDGE:
 407                 printf("PCI bridge");
 408                 break;
 409         case PCIEM_TYPE_PCIE_BRIDGE:
 410                 printf("PCI to PCIe bridge");
 411                 break;
 412         case PCIEM_TYPE_ROOT_INT_EP:
 413                 printf("root endpoint");
 414                 break;
 415         case PCIEM_TYPE_ROOT_EC:
 416                 printf("event collector");
 417                 break;
 418         default:
 419                 printf("type %d", (flags & PCIEM_FLAGS_TYPE) >> 4);
 420                 break;
 421         }
 422         if (flags & PCIEM_FLAGS_SLOT)
 423                 printf(" slot");
 424         if (flags & PCIEM_FLAGS_IRQ)
 425                 printf(" IRQ %d", (flags & PCIEM_FLAGS_IRQ) >> 9);
 426         val = read_config(fd, &p->pc_sel, ptr + PCIER_DEVICE_CAP, 4);
 427         flags = read_config(fd, &p->pc_sel, ptr + PCIER_DEVICE_CTL, 2);
 428         printf(" max data %d(%d)",
 429             MAX_PAYLOAD((flags & PCIEM_CTL_MAX_PAYLOAD) >> 5),
 430             MAX_PAYLOAD(val & PCIEM_CAP_MAX_PAYLOAD));
 431         val = read_config(fd, &p->pc_sel, ptr + PCIER_LINK_CAP, 4);
 432         flags = read_config(fd, &p->pc_sel, ptr+ PCIER_LINK_STA, 2);
 433         printf(" link x%d(x%d)", (flags & PCIEM_LINK_STA_WIDTH) >> 4,
 434             (val & PCIEM_LINK_CAP_MAX_WIDTH) >> 4);
 435         /*
 436          * Only print link speed info if the link's max width is
 437          * greater than 0.
 438          */
 439         if ((val & PCIEM_LINK_CAP_MAX_WIDTH) != 0) {
 440                 printf("\n                 speed");
 441                 printf(" %s(%s)", (flags & PCIEM_LINK_STA_WIDTH) == 0 ?
 442                     "0.0" : link_speed_string(flags & PCIEM_LINK_STA_SPEED),
 443                     link_speed_string(val & PCIEM_LINK_CAP_MAX_SPEED));
 444         }
 445 }
 446
 447 static void
 448 cap_msix(int fd, struct pci_conf *p, uint8_t ptr)
 449 {
 450         uint32_t val;
 451         uint16_t ctrl;
 452         int msgnum, table_bar, pba_bar;
 453
 454         ctrl = read_config(fd, &p->pc_sel, ptr + PCIR_MSIX_CTRL, 2);
 455         msgnum = (ctrl & PCIM_MSIXCTRL_TABLE_SIZE) + 1;
 456         val = read_config(fd, &p->pc_sel, ptr + PCIR_MSIX_TABLE, 4);
 457         table_bar = PCIR_BAR(val & PCIM_MSIX_BIR_MASK);
 458         val = read_config(fd, &p->pc_sel, ptr + PCIR_MSIX_PBA, 4);
 459         pba_bar = PCIR_BAR(val & PCIM_MSIX_BIR_MASK);
 460         printf("MSI-X supports %d message%s ", msgnum,
 461             (msgnum == 1) ? "" : "s");
 462         if (table_bar == pba_bar)
 463                 printf("in map 0x%x", table_bar);
 464         else
 465                 printf("in maps 0x%x and 0x%x", table_bar, pba_bar);
 466         if (ctrl & PCIM_MSIXCTRL_MSIX_ENABLE)
 467                 printf(" enabled");
 468 }
 469
 470 static void
 471 cap_sata(int fd, struct pci_conf *p, uint8_t ptr)
 472 {
 473
 474         printf("SATA Index-Data Pair");
 475 }
 476
 477 static void
 478 cap_pciaf(int fd, struct pci_conf *p, uint8_t ptr)
 479 {
 480         uint8_t cap;
 481
 482         cap = read_config(fd, &p->pc_sel, ptr + PCIR_PCIAF_CAP, 1);
 483         printf("PCI Advanced Features:%s%s",
 484             cap & PCIM_PCIAFCAP_FLR ? " FLR" : "",
 485             cap & PCIM_PCIAFCAP_TP  ? " TP"  : "");
 486 }
 487
 488 void
 489 list_caps(int fd, struct pci_conf *p)
 490 {
 491         int express;
 492         uint16_t sta;
 493         uint8_t ptr, cap;
 494
 495         /* Are capabilities present for this device? */
 496         sta = read_config(fd, &p->pc_sel, PCIR_STATUS, 2);
 497         if (!(sta & PCIM_STATUS_CAPPRESENT))
 498                 return;
 499
 500         switch (p->pc_hdr & PCIM_HDRTYPE) {
 501         case PCIM_HDRTYPE_NORMAL:
 502         case PCIM_HDRTYPE_BRIDGE:
 503                 ptr = PCIR_CAP_PTR;
 504                 break;
 505         case PCIM_HDRTYPE_CARDBUS:
 506                 ptr = PCIR_CAP_PTR_2;
 507                 break;
 508         default:
 509                 errx(1, "list_caps: bad header type");
 510         }
 511
 512         /* Walk the capability list. */
 513         express = 0;
 514         ptr = read_config(fd, &p->pc_sel, ptr, 1);
 515         while (ptr != 0 && ptr != 0xff) {
 516                 cap = read_config(fd, &p->pc_sel, ptr + PCICAP_ID, 1);
 517                 printf("    cap %02x[%02x] = ", cap, ptr);
 518                 switch (cap) {
 519                 case PCIY_PMG:
 520                         cap_power(fd, p, ptr);
 521                         break;
 522                 case PCIY_AGP:
 523                         cap_agp(fd, p, ptr);
 524                         break;
 525                 case PCIY_VPD:
 526                         cap_vpd(fd, p, ptr);
 527                         break;
 528                 case PCIY_MSI:
 529                         cap_msi(fd, p, ptr);
 530                         break;
 531                 case PCIY_PCIX:
 532                         cap_pcix(fd, p, ptr);
 533                         break;
 534                 case PCIY_HT:
 535                         cap_ht(fd, p, ptr);
 536                         break;
 537                 case PCIY_VENDOR:
 538                         cap_vendor(fd, p, ptr);
 539                         break;
 540                 case PCIY_DEBUG:
 541                         cap_debug(fd, p, ptr);
 542                         break;
 543                 case PCIY_SUBVENDOR:
 544                         cap_subvendor(fd, p, ptr);
 545                         break;
 546                 case PCIY_EXPRESS:
 547                         express = 1;
 548                         cap_express(fd, p, ptr);
 549                         break;
 550                 case PCIY_MSIX:
 551                         cap_msix(fd, p, ptr);
 552                         break;
 553                 case PCIY_SATA:
 554                         cap_sata(fd, p, ptr);
 555                         break;
 556                 case PCIY_PCIAF:
 557                         cap_pciaf(fd, p, ptr);
 558                         break;
 559                 default:
 560                         printf("unknown");
 561                         break;
 562                 }
 563                 printf("\n");
 564                 ptr = read_config(fd, &p->pc_sel, ptr + PCICAP_NEXTPTR, 1);
 565         }
 566
 567         if (express)
 568                 list_ecaps(fd, p);
 569 }
 570
 571 /* From <sys/systm.h>. */
 572 static __inline uint32_t
 573 bitcount32(uint32_t x)
 574 {
 575
 576         x = (x & 0x55555555) + ((x & 0xaaaaaaaa) >> 1);
 577         x = (x & 0x33333333) + ((x & 0xcccccccc) >> 2);
 578         x = (x + (x >> 4)) & 0x0f0f0f0f;
 579         x = (x + (x >> 8));
 580         x = (x + (x >> 16)) & 0x000000ff;
 581         return (x);
 582 }
 583
 584 static void
 585 ecap_aer(int fd, struct pci_conf *p, uint16_t ptr, uint8_t ver)
 586 {
 587         uint32_t sta, mask;
 588
 589         printf("AER %d", ver);
 590         if (ver != 1)
 591                 return;
 592         sta = read_config(fd, &p->pc_sel, ptr + PCIR_AER_UC_STATUS, 4);
 593         mask = read_config(fd, &p->pc_sel, ptr + PCIR_AER_UC_SEVERITY, 4);
 594         printf(" %d fatal", bitcount32(sta & mask));
 595         printf(" %d non-fatal", bitcount32(sta & ~mask));
 596         sta = read_config(fd, &p->pc_sel, ptr + PCIR_AER_COR_STATUS, 4);
 597         printf(" %d corrected", bitcount32(sta));
 598 }
 599
 600 static void
 601 ecap_vc(int fd, struct pci_conf *p, uint16_t ptr, uint8_t ver)
 602 {
 603         uint32_t cap1;
 604
 605         printf("VC %d", ver);
 606         if (ver != 1)
 607                 return;
 608         cap1 = read_config(fd, &p->pc_sel, ptr + PCIR_VC_CAP1, 4);
 609         printf(" max VC%d", cap1 & PCIM_VC_CAP1_EXT_COUNT);
 610         if ((cap1 & PCIM_VC_CAP1_LOWPRI_EXT_COUNT) != 0)
 611                 printf(" lowpri VC0-VC%d",
 612                     (cap1 & PCIM_VC_CAP1_LOWPRI_EXT_COUNT) >> 4);
 613 }
 614
 615 static void
 616 ecap_sernum(int fd, struct pci_conf *p, uint16_t ptr, uint8_t ver)
 617 {
 618         uint32_t high, low;
 619
 620         printf("Serial %d", ver);
 621         if (ver != 1)
 622                 return;
 623         low = read_config(fd, &p->pc_sel, ptr + PCIR_SERIAL_LOW, 4);
 624         high = read_config(fd, &p->pc_sel, ptr + PCIR_SERIAL_HIGH, 4);
 625         printf(" %08x%08x", high, low);
 626 }
 627
 628 static void
 629 list_ecaps(int fd, struct pci_conf *p)
 630 {
 631         uint32_t ecap;
 632         uint16_t ptr;
 633
 634         ptr = PCIR_EXTCAP;
 635         ecap = read_config(fd, &p->pc_sel, ptr, 4);
 636         if (ecap == 0xffffffff || ecap == 0)
 637                 return;
 638         for (;;) {
 639                 printf("ecap %04x[%03x] = ", PCI_EXTCAP_ID(ecap), ptr);
 640                 switch (PCI_EXTCAP_ID(ecap)) {
 641                 case PCIZ_AER:
 642                         ecap_aer(fd, p, ptr, PCI_EXTCAP_VER(ecap));
 643                         break;
 644                 case PCIZ_VC:
 645                         ecap_vc(fd, p, ptr, PCI_EXTCAP_VER(ecap));
 646                         break;
 647                 case PCIZ_SERNUM:
 648                         ecap_sernum(fd, p, ptr, PCI_EXTCAP_VER(ecap));
 649                         break;
 650                 default:
 651                         printf("unknown %d", PCI_EXTCAP_VER(ecap));
 652                         break;
 653                 }
 654                 printf("\n");
 655                 ptr = PCI_EXTCAP_NEXTPTR(ecap);
 656                 if (ptr == 0)
 657                         break;
 658                 ecap = read_config(fd, &p->pc_sel, ptr, 4);
 659         }
 660 }
 661
 662 /* Find offset of a specific capability.  Returns 0 on failure. */
 663 uint8_t
 664 pci_find_cap(int fd, struct pci_conf *p, uint8_t id)
 665 {
 666         uint16_t sta;
 667         uint8_t ptr, cap;
 668
 669         /* Are capabilities present for this device? */
 670         sta = read_config(fd, &p->pc_sel, PCIR_STATUS, 2);
 671         if (!(sta & PCIM_STATUS_CAPPRESENT))
 672                 return (0);
 673
 674         switch (p->pc_hdr & PCIM_HDRTYPE) {
 675         case PCIM_HDRTYPE_NORMAL:
 676         case PCIM_HDRTYPE_BRIDGE:
 677                 ptr = PCIR_CAP_PTR;
 678                 break;
 679         case PCIM_HDRTYPE_CARDBUS:
 680                 ptr = PCIR_CAP_PTR_2;
 681                 break;
 682         default:
 683                 return (0);
 684         }
 685
 686         ptr = read_config(fd, &p->pc_sel, ptr, 1);
 687         while (ptr != 0 && ptr != 0xff) {
 688                 cap = read_config(fd, &p->pc_sel, ptr + PCICAP_ID, 1);
 689                 if (cap == id)
 690                         return (ptr);
 691                 ptr = read_config(fd, &p->pc_sel, ptr + PCICAP_NEXTPTR, 1);
 692         }
 693         return (0);
 694 }
 695
 696 /* Find offset of a specific extended capability.  Returns 0 on failure. */
 697 uint16_t
 698 pcie_find_cap(int fd, struct pci_conf *p, uint16_t id)
 699 {
 700         uint32_t ecap;
 701         uint16_t ptr;
 702
 703         ptr = PCIR_EXTCAP;
 704         ecap = read_config(fd, &p->pc_sel, ptr, 4);
 705         if (ecap == 0xffffffff || ecap == 0)
 706                 return (0);
 707         for (;;) {
 708                 if (PCI_EXTCAP_ID(ecap) == id)
 709                         return (ptr);
 710                 ptr = PCI_EXTCAP_NEXTPTR(ecap);
 711                 if (ptr == 0)
 712                         break;
 713                 ecap = read_config(fd, &p->pc_sel, ptr, 4);
 714         }
 715         return (0);
 716 }