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         if (val & PCIEM_CAP_FLR)
 432                 printf(" FLR");
 433         val = read_config(fd, &p->pc_sel, ptr + PCIER_LINK_CAP, 4);
 434         flags = read_config(fd, &p->pc_sel, ptr+ PCIER_LINK_STA, 2);
 435         printf(" link x%d(x%d)", (flags & PCIEM_LINK_STA_WIDTH) >> 4,
 436             (val & PCIEM_LINK_CAP_MAX_WIDTH) >> 4);
 437         /*
 438          * Only print link speed info if the link's max width is
 439          * greater than 0.
 440          */
 441         if ((val & PCIEM_LINK_CAP_MAX_WIDTH) != 0) {
 442                 printf("\n                 speed");
 443                 printf(" %s(%s)", (flags & PCIEM_LINK_STA_WIDTH) == 0 ?
 444                     "0.0" : link_speed_string(flags & PCIEM_LINK_STA_SPEED),
 445                     link_speed_string(val & PCIEM_LINK_CAP_MAX_SPEED));
 446         }
 447 }
 448
 449 static void
 450 cap_msix(int fd, struct pci_conf *p, uint8_t ptr)
 451 {
 452         uint32_t val;
 453         uint16_t ctrl;
 454         int msgnum, table_bar, pba_bar;
 455
 456         ctrl = read_config(fd, &p->pc_sel, ptr + PCIR_MSIX_CTRL, 2);
 457         msgnum = (ctrl & PCIM_MSIXCTRL_TABLE_SIZE) + 1;
 458         val = read_config(fd, &p->pc_sel, ptr + PCIR_MSIX_TABLE, 4);
 459         table_bar = PCIR_BAR(val & PCIM_MSIX_BIR_MASK);
 460         val = read_config(fd, &p->pc_sel, ptr + PCIR_MSIX_PBA, 4);
 461         pba_bar = PCIR_BAR(val & PCIM_MSIX_BIR_MASK);
 462         printf("MSI-X supports %d message%s ", msgnum,
 463             (msgnum == 1) ? "" : "s");
 464         if (table_bar == pba_bar)
 465                 printf("in map 0x%x", table_bar);
 466         else
 467                 printf("in maps 0x%x and 0x%x", table_bar, pba_bar);
 468         if (ctrl & PCIM_MSIXCTRL_MSIX_ENABLE)
 469                 printf(" enabled");
 470 }
 471
 472 static void
 473 cap_sata(int fd, struct pci_conf *p, uint8_t ptr)
 474 {
 475
 476         printf("SATA Index-Data Pair");
 477 }
 478
 479 static void
 480 cap_pciaf(int fd, struct pci_conf *p, uint8_t ptr)
 481 {
 482         uint8_t cap;
 483
 484         cap = read_config(fd, &p->pc_sel, ptr + PCIR_PCIAF_CAP, 1);
 485         printf("PCI Advanced Features:%s%s",
 486             cap & PCIM_PCIAFCAP_FLR ? " FLR" : "",
 487             cap & PCIM_PCIAFCAP_TP  ? " TP"  : "");
 488 }
 489
 490 void
 491 list_caps(int fd, struct pci_conf *p)
 492 {
 493         int express;
 494         uint16_t sta;
 495         uint8_t ptr, cap;
 496
 497         /* Are capabilities present for this device? */
 498         sta = read_config(fd, &p->pc_sel, PCIR_STATUS, 2);
 499         if (!(sta & PCIM_STATUS_CAPPRESENT))
 500                 return;
 501
 502         switch (p->pc_hdr & PCIM_HDRTYPE) {
 503         case PCIM_HDRTYPE_NORMAL:
 504         case PCIM_HDRTYPE_BRIDGE:
 505                 ptr = PCIR_CAP_PTR;
 506                 break;
 507         case PCIM_HDRTYPE_CARDBUS:
 508                 ptr = PCIR_CAP_PTR_2;
 509                 break;
 510         default:
 511                 errx(1, "list_caps: bad header type");
 512         }
 513
 514         /* Walk the capability list. */
 515         express = 0;
 516         ptr = read_config(fd, &p->pc_sel, ptr, 1);
 517         while (ptr != 0 && ptr != 0xff) {
 518                 cap = read_config(fd, &p->pc_sel, ptr + PCICAP_ID, 1);
 519                 printf("    cap %02x[%02x] = ", cap, ptr);
 520                 switch (cap) {
 521                 case PCIY_PMG:
 522                         cap_power(fd, p, ptr);
 523                         break;
 524                 case PCIY_AGP:
 525                         cap_agp(fd, p, ptr);
 526                         break;
 527                 case PCIY_VPD:
 528                         cap_vpd(fd, p, ptr);
 529                         break;
 530                 case PCIY_MSI:
 531                         cap_msi(fd, p, ptr);
 532                         break;
 533                 case PCIY_PCIX:
 534                         cap_pcix(fd, p, ptr);
 535                         break;
 536                 case PCIY_HT:
 537                         cap_ht(fd, p, ptr);
 538                         break;
 539                 case PCIY_VENDOR:
 540                         cap_vendor(fd, p, ptr);
 541                         break;
 542                 case PCIY_DEBUG:
 543                         cap_debug(fd, p, ptr);
 544                         break;
 545                 case PCIY_SUBVENDOR:
 546                         cap_subvendor(fd, p, ptr);
 547                         break;
 548                 case PCIY_EXPRESS:
 549                         express = 1;
 550                         cap_express(fd, p, ptr);
 551                         break;
 552                 case PCIY_MSIX:
 553                         cap_msix(fd, p, ptr);
 554                         break;
 555                 case PCIY_SATA:
 556                         cap_sata(fd, p, ptr);
 557                         break;
 558                 case PCIY_PCIAF:
 559                         cap_pciaf(fd, p, ptr);
 560                         break;
 561                 default:
 562                         printf("unknown");
 563                         break;
 564                 }
 565                 printf("\n");
 566                 ptr = read_config(fd, &p->pc_sel, ptr + PCICAP_NEXTPTR, 1);
 567         }
 568
 569         if (express)
 570                 list_ecaps(fd, p);
 571 }
 572
 573 /* From <sys/systm.h>. */
 574 static __inline uint32_t
 575 bitcount32(uint32_t x)
 576 {
 577
 578         x = (x & 0x55555555) + ((x & 0xaaaaaaaa) >> 1);
 579         x = (x & 0x33333333) + ((x & 0xcccccccc) >> 2);
 580         x = (x + (x >> 4)) & 0x0f0f0f0f;
 581         x = (x + (x >> 8));
 582         x = (x + (x >> 16)) & 0x000000ff;
 583         return (x);
 584 }
 585
 586 static void
 587 ecap_aer(int fd, struct pci_conf *p, uint16_t ptr, uint8_t ver)
 588 {
 589         uint32_t sta, mask;
 590
 591         printf("AER %d", ver);
 592         if (ver < 1)
 593                 return;
 594         sta = read_config(fd, &p->pc_sel, ptr + PCIR_AER_UC_STATUS, 4);
 595         mask = read_config(fd, &p->pc_sel, ptr + PCIR_AER_UC_SEVERITY, 4);
 596         printf(" %d fatal", bitcount32(sta & mask));
 597         printf(" %d non-fatal", bitcount32(sta & ~mask));
 598         sta = read_config(fd, &p->pc_sel, ptr + PCIR_AER_COR_STATUS, 4);
 599         printf(" %d corrected", bitcount32(sta));
 600 }
 601
 602 static void
 603 ecap_vc(int fd, struct pci_conf *p, uint16_t ptr, uint8_t ver)
 604 {
 605         uint32_t cap1;
 606
 607         printf("VC %d", ver);
 608         if (ver < 1)
 609                 return;
 610         cap1 = read_config(fd, &p->pc_sel, ptr + PCIR_VC_CAP1, 4);
 611         printf(" max VC%d", cap1 & PCIM_VC_CAP1_EXT_COUNT);
 612         if ((cap1 & PCIM_VC_CAP1_LOWPRI_EXT_COUNT) != 0)
 613                 printf(" lowpri VC0-VC%d",
 614                     (cap1 & PCIM_VC_CAP1_LOWPRI_EXT_COUNT) >> 4);
 615 }
 616
 617 static void
 618 ecap_sernum(int fd, struct pci_conf *p, uint16_t ptr, uint8_t ver)
 619 {
 620         uint32_t high, low;
 621
 622         printf("Serial %d", ver);
 623         if (ver < 1)
 624                 return;
 625         low = read_config(fd, &p->pc_sel, ptr + PCIR_SERIAL_LOW, 4);
 626         high = read_config(fd, &p->pc_sel, ptr + PCIR_SERIAL_HIGH, 4);
 627         printf(" %08x%08x", high, low);
 628 }
 629
 630 static void
 631 ecap_vendor(int fd, struct pci_conf *p, uint16_t ptr, uint8_t ver)
 632 {
 633         uint32_t val;
 634
 635         printf("Vendor %d", ver);
 636         if (ver < 1)
 637                 return;
 638         val = read_config(fd, &p->pc_sel, ptr + 4, 4);
 639         printf(" ID %d", val & 0xffff);
 640 }
 641
 642 static void
 643 ecap_sec_pcie(int fd, struct pci_conf *p, uint16_t ptr, uint8_t ver)
 644 {
 645         uint32_t val;
 646
 647         printf("PCIe Sec %d", ver);
 648         if (ver < 1)
 649                 return;
 650         val = read_config(fd, &p->pc_sel, ptr + 8, 4);
 651         printf(" lane errors %#x", val);
 652 }
 653
 654 struct {
 655         uint16_t id;
 656         const char *name;
 657 } ecap_names[] = {
 658         { PCIZ_PWRBDGT, "Power Budgeting" },
 659         { PCIZ_RCLINK_DCL, "Root Complex Link Declaration" },
 660         { PCIZ_RCLINK_CTL, "Root Complex Internal Link Control" },
 661         { PCIZ_RCEC_ASSOC, "Root Complex Event Collector ASsociation" },
 662         { PCIZ_MFVC, "MFVC" },
 663         { PCIZ_RCRB, "RCRB" },
 664         { PCIZ_ACS, "ACS" },
 665         { PCIZ_ARI, "ARI" },
 666         { PCIZ_ATS, "ATS" },
 667         { PCIZ_SRIOV, "SRIOV" },
 668         { PCIZ_MULTICAST, "Multicast" },
 669         { PCIZ_RESIZE_BAR, "Resizable BAR" },
 670         { PCIZ_DPA, "DPA" },
 671         { PCIZ_TPH_REQ, "TPH Requester" },
 672         { PCIZ_LTR, "LTR" },
 673         { 0, NULL }
 674 };
 675
 676 static void
 677 list_ecaps(int fd, struct pci_conf *p)
 678 {
 679         const char *name;
 680         uint32_t ecap;
 681         uint16_t ptr;
 682         int i;
 683
 684         ptr = PCIR_EXTCAP;
 685         ecap = read_config(fd, &p->pc_sel, ptr, 4);
 686         if (ecap == 0xffffffff || ecap == 0)
 687                 return;
 688         for (;;) {
 689                 printf("ecap %04x[%03x] = ", PCI_EXTCAP_ID(ecap), ptr);
 690                 switch (PCI_EXTCAP_ID(ecap)) {
 691                 case PCIZ_AER:
 692                         ecap_aer(fd, p, ptr, PCI_EXTCAP_VER(ecap));
 693                         break;
 694                 case PCIZ_VC:
 695                         ecap_vc(fd, p, ptr, PCI_EXTCAP_VER(ecap));
 696                         break;
 697                 case PCIZ_SERNUM:
 698                         ecap_sernum(fd, p, ptr, PCI_EXTCAP_VER(ecap));
 699                         break;
 700                 case PCIZ_VENDOR:
 701                         ecap_vendor(fd, p, ptr, PCI_EXTCAP_VER(ecap));
 702                         break;
 703                 case PCIZ_SEC_PCIE:
 704                         ecap_sec_pcie(fd, p, ptr, PCI_EXTCAP_VER(ecap));
 705                         break;
 706                 default:
 707                         name = "unknown";
 708                         for (i = 0; ecap_names[i].name != NULL; i++)
 709                                 if (ecap_names[i].id == PCI_EXTCAP_ID(ecap)) {
 710                                         name = ecap_names[i].name;
 711                                         break;
 712                                 }
 713                         printf("%s %d", name, PCI_EXTCAP_VER(ecap));
 714                         break;
 715                 }
 716                 printf("\n");
 717                 ptr = PCI_EXTCAP_NEXTPTR(ecap);
 718                 if (ptr == 0)
 719                         break;
 720                 ecap = read_config(fd, &p->pc_sel, ptr, 4);
 721         }
 722 }
 723
 724 /* Find offset of a specific capability.  Returns 0 on failure. */
 725 uint8_t
 726 pci_find_cap(int fd, struct pci_conf *p, uint8_t id)
 727 {
 728         uint16_t sta;
 729         uint8_t ptr, cap;
 730
 731         /* Are capabilities present for this device? */
 732         sta = read_config(fd, &p->pc_sel, PCIR_STATUS, 2);
 733         if (!(sta & PCIM_STATUS_CAPPRESENT))
 734                 return (0);
 735
 736         switch (p->pc_hdr & PCIM_HDRTYPE) {
 737         case PCIM_HDRTYPE_NORMAL:
 738         case PCIM_HDRTYPE_BRIDGE:
 739                 ptr = PCIR_CAP_PTR;
 740                 break;
 741         case PCIM_HDRTYPE_CARDBUS:
 742                 ptr = PCIR_CAP_PTR_2;
 743                 break;
 744         default:
 745                 return (0);
 746         }
 747
 748         ptr = read_config(fd, &p->pc_sel, ptr, 1);
 749         while (ptr != 0 && ptr != 0xff) {
 750                 cap = read_config(fd, &p->pc_sel, ptr + PCICAP_ID, 1);
 751                 if (cap == id)
 752                         return (ptr);
 753                 ptr = read_config(fd, &p->pc_sel, ptr + PCICAP_NEXTPTR, 1);
 754         }
 755         return (0);
 756 }
 757
 758 /* Find offset of a specific extended capability.  Returns 0 on failure. */
 759 uint16_t
 760 pcie_find_cap(int fd, struct pci_conf *p, uint16_t id)
 761 {
 762         uint32_t ecap;
 763         uint16_t ptr;
 764
 765         ptr = PCIR_EXTCAP;
 766         ecap = read_config(fd, &p->pc_sel, ptr, 4);
 767         if (ecap == 0xffffffff || ecap == 0)
 768                 return (0);
 769         for (;;) {
 770                 if (PCI_EXTCAP_ID(ecap) == id)
 771                         return (ptr);
 772                 ptr = PCI_EXTCAP_NEXTPTR(ecap);
 773                 if (ptr == 0)
 774                         break;
 775                 ecap = read_config(fd, &p->pc_sel, ptr, 4);
 776         }
 777         return (0);
 778 }