1 /* $NetBSD: pci_subr.c,v 1.222 2020/03/21 17:09:29 thorpej Exp $ */ 2 3 /* 4 * Copyright (c) 1997 Zubin D. Dittia. All rights reserved. 5 * Copyright (c) 1995, 1996, 1998, 2000 6 * Christopher G. Demetriou. All rights reserved. 7 * Copyright (c) 1994 Charles M. Hannum. All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed by Charles M. Hannum. 20 * 4. The name of the author may not be used to endorse or promote products 21 * derived from this software without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 26 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 28 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 32 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 /* 36 * PCI autoconfiguration support functions. 37 * 38 * Note: This file is also built into a userland library (libpci). 39 * Pay attention to this when you make modifications. 40 */ 41 42 #include <sys/cdefs.h> 43 __KERNEL_RCSID(0, "$NetBSD: pci_subr.c,v 1.222 2020/03/21 17:09:29 thorpej Exp $"); 44 45 #ifdef _KERNEL_OPT 46 #include "opt_pci.h" 47 #endif 48 49 #include <sys/param.h> 50 51 #ifdef _KERNEL 52 #include <sys/systm.h> 53 #include <sys/intr.h> 54 #include <sys/module.h> 55 #else 56 #include <pci.h> 57 #include <stdarg.h> 58 #include <stdbool.h> 59 #include <stdio.h> 60 #include <stdlib.h> 61 #include <string.h> 62 #endif 63 64 #include <dev/pci/pcireg.h> 65 #ifdef _KERNEL 66 #include <dev/pci/pcivar.h> 67 #else 68 #include <dev/pci/pci_verbose.h> 69 #include <dev/pci/pcidevs.h> 70 #include <dev/pci/pcidevs_data.h> 71 #endif 72 73 static int pci_conf_find_cap(const pcireg_t *, unsigned int, int *); 74 static int pci_conf_find_extcap(const pcireg_t *, unsigned int, int *); 75 static void pci_conf_print_pcie_power(uint8_t, unsigned int); 76 77 /* 78 * Descriptions of known PCI classes and subclasses. 79 * 80 * Subclasses are described in the same way as classes, but have a 81 * NULL subclass pointer. 82 */ 83 struct pci_class { 84 const char *name; 85 u_int val; /* as wide as pci_{,sub}class_t */ 86 const struct pci_class *subclasses; 87 }; 88 89 /* 90 * Class 0x00. 91 * Before rev. 2.0. 92 */ 93 static const struct pci_class pci_subclass_prehistoric[] = { 94 { "miscellaneous", PCI_SUBCLASS_PREHISTORIC_MISC, NULL, }, 95 { "VGA", PCI_SUBCLASS_PREHISTORIC_VGA, NULL, }, 96 { NULL, 0, NULL, }, 97 }; 98 99 /* 100 * Class 0x01. 101 * Mass storage controller 102 */ 103 104 /* ATA programming interface */ 105 static const struct pci_class pci_interface_ata[] = { 106 { "with single DMA", PCI_INTERFACE_ATA_SINGLEDMA, NULL, }, 107 { "with chained DMA", PCI_INTERFACE_ATA_CHAINEDDMA, NULL, }, 108 { NULL, 0, NULL, }, 109 }; 110 111 /* SATA programming interface */ 112 static const struct pci_class pci_interface_sata[] = { 113 { "vendor specific", PCI_INTERFACE_SATA_VND, NULL, }, 114 { "AHCI 1.0", PCI_INTERFACE_SATA_AHCI10, NULL, }, 115 { "Serial Storage Bus Interface", PCI_INTERFACE_SATA_SSBI, NULL, }, 116 { NULL, 0, NULL, }, 117 }; 118 119 /* Flash programming interface */ 120 static const struct pci_class pci_interface_nvm[] = { 121 { "vendor specific", PCI_INTERFACE_NVM_VND, NULL, }, 122 { "NVMHCI 1.0", PCI_INTERFACE_NVM_NVMHCI10, NULL, }, 123 { "NVMe", PCI_INTERFACE_NVM_NVME, NULL, }, 124 { NULL, 0, NULL, }, 125 }; 126 127 /* Subclasses */ 128 static const struct pci_class pci_subclass_mass_storage[] = { 129 { "SCSI", PCI_SUBCLASS_MASS_STORAGE_SCSI, NULL, }, 130 { "IDE", PCI_SUBCLASS_MASS_STORAGE_IDE, NULL, }, 131 { "floppy", PCI_SUBCLASS_MASS_STORAGE_FLOPPY, NULL, }, 132 { "IPI", PCI_SUBCLASS_MASS_STORAGE_IPI, NULL, }, 133 { "RAID", PCI_SUBCLASS_MASS_STORAGE_RAID, NULL, }, 134 { "ATA", PCI_SUBCLASS_MASS_STORAGE_ATA, 135 pci_interface_ata, }, 136 { "SATA", PCI_SUBCLASS_MASS_STORAGE_SATA, 137 pci_interface_sata, }, 138 { "SAS", PCI_SUBCLASS_MASS_STORAGE_SAS, NULL, }, 139 { "Flash", PCI_SUBCLASS_MASS_STORAGE_NVM, 140 pci_interface_nvm, }, 141 { "miscellaneous", PCI_SUBCLASS_MASS_STORAGE_MISC, NULL, }, 142 { NULL, 0, NULL, }, 143 }; 144 145 /* 146 * Class 0x02. 147 * Network controller. 148 */ 149 static const struct pci_class pci_subclass_network[] = { 150 { "ethernet", PCI_SUBCLASS_NETWORK_ETHERNET, NULL, }, 151 { "token ring", PCI_SUBCLASS_NETWORK_TOKENRING, NULL, }, 152 { "FDDI", PCI_SUBCLASS_NETWORK_FDDI, NULL, }, 153 { "ATM", PCI_SUBCLASS_NETWORK_ATM, NULL, }, 154 { "ISDN", PCI_SUBCLASS_NETWORK_ISDN, NULL, }, 155 { "WorldFip", PCI_SUBCLASS_NETWORK_WORLDFIP, NULL, }, 156 { "PCMIG Multi Computing", PCI_SUBCLASS_NETWORK_PCIMGMULTICOMP, NULL, }, 157 { "miscellaneous", PCI_SUBCLASS_NETWORK_MISC, NULL, }, 158 { NULL, 0, NULL, }, 159 }; 160 161 /* 162 * Class 0x03. 163 * Display controller. 164 */ 165 166 /* VGA programming interface */ 167 static const struct pci_class pci_interface_vga[] = { 168 { "", PCI_INTERFACE_VGA_VGA, NULL, }, 169 { "8514-compat", PCI_INTERFACE_VGA_8514, NULL, }, 170 { NULL, 0, NULL, }, 171 }; 172 /* Subclasses */ 173 static const struct pci_class pci_subclass_display[] = { 174 { "VGA", PCI_SUBCLASS_DISPLAY_VGA, pci_interface_vga,}, 175 { "XGA", PCI_SUBCLASS_DISPLAY_XGA, NULL, }, 176 { "3D", PCI_SUBCLASS_DISPLAY_3D, NULL, }, 177 { "miscellaneous", PCI_SUBCLASS_DISPLAY_MISC, NULL, }, 178 { NULL, 0, NULL, }, 179 }; 180 181 /* 182 * Class 0x04. 183 * Multimedia device. 184 */ 185 static const struct pci_class pci_subclass_multimedia[] = { 186 { "video", PCI_SUBCLASS_MULTIMEDIA_VIDEO, NULL, }, 187 { "audio", PCI_SUBCLASS_MULTIMEDIA_AUDIO, NULL, }, 188 { "telephony", PCI_SUBCLASS_MULTIMEDIA_TELEPHONY, NULL,}, 189 { "mixed mode", PCI_SUBCLASS_MULTIMEDIA_HDAUDIO, NULL, }, 190 { "miscellaneous", PCI_SUBCLASS_MULTIMEDIA_MISC, NULL, }, 191 { NULL, 0, NULL, }, 192 }; 193 194 /* 195 * Class 0x05. 196 * Memory controller. 197 */ 198 static const struct pci_class pci_subclass_memory[] = { 199 { "RAM", PCI_SUBCLASS_MEMORY_RAM, NULL, }, 200 { "flash", PCI_SUBCLASS_MEMORY_FLASH, NULL, }, 201 { "miscellaneous", PCI_SUBCLASS_MEMORY_MISC, NULL, }, 202 { NULL, 0, NULL, }, 203 }; 204 205 /* 206 * Class 0x06. 207 * Bridge device. 208 */ 209 210 /* PCI bridge programming interface */ 211 static const struct pci_class pci_interface_pcibridge[] = { 212 { "", PCI_INTERFACE_BRIDGE_PCI_PCI, NULL, }, 213 { "subtractive decode", PCI_INTERFACE_BRIDGE_PCI_SUBDEC, NULL, }, 214 { NULL, 0, NULL, }, 215 }; 216 217 /* Semi-transparent PCI-to-PCI bridge programming interface */ 218 static const struct pci_class pci_interface_stpci[] = { 219 { "primary side facing host", PCI_INTERFACE_STPCI_PRIMARY, NULL, }, 220 { "secondary side facing host", PCI_INTERFACE_STPCI_SECONDARY, NULL, }, 221 { NULL, 0, NULL, }, 222 }; 223 224 /* Advanced Switching programming interface */ 225 static const struct pci_class pci_interface_advsw[] = { 226 { "custom interface", PCI_INTERFACE_ADVSW_CUSTOM, NULL, }, 227 { "ASI-SIG", PCI_INTERFACE_ADVSW_ASISIG, NULL, }, 228 { NULL, 0, NULL, }, 229 }; 230 231 /* Subclasses */ 232 static const struct pci_class pci_subclass_bridge[] = { 233 { "host", PCI_SUBCLASS_BRIDGE_HOST, NULL, }, 234 { "ISA", PCI_SUBCLASS_BRIDGE_ISA, NULL, }, 235 { "EISA", PCI_SUBCLASS_BRIDGE_EISA, NULL, }, 236 { "MicroChannel", PCI_SUBCLASS_BRIDGE_MC, NULL, }, 237 { "PCI", PCI_SUBCLASS_BRIDGE_PCI, 238 pci_interface_pcibridge, }, 239 { "PCMCIA", PCI_SUBCLASS_BRIDGE_PCMCIA, NULL, }, 240 { "NuBus", PCI_SUBCLASS_BRIDGE_NUBUS, NULL, }, 241 { "CardBus", PCI_SUBCLASS_BRIDGE_CARDBUS, NULL, }, 242 { "RACEway", PCI_SUBCLASS_BRIDGE_RACEWAY, NULL, }, 243 { "Semi-transparent PCI", PCI_SUBCLASS_BRIDGE_STPCI, 244 pci_interface_stpci, }, 245 { "InfiniBand", PCI_SUBCLASS_BRIDGE_INFINIBAND, NULL, }, 246 { "advanced switching", PCI_SUBCLASS_BRIDGE_ADVSW, 247 pci_interface_advsw, }, 248 { "miscellaneous", PCI_SUBCLASS_BRIDGE_MISC, NULL, }, 249 { NULL, 0, NULL, }, 250 }; 251 252 /* 253 * Class 0x07. 254 * Simple communications controller. 255 */ 256 257 /* Serial controller programming interface */ 258 static const struct pci_class pci_interface_serial[] = { 259 { "generic XT-compat", PCI_INTERFACE_SERIAL_XT, NULL, }, 260 { "16450-compat", PCI_INTERFACE_SERIAL_16450, NULL, }, 261 { "16550-compat", PCI_INTERFACE_SERIAL_16550, NULL, }, 262 { "16650-compat", PCI_INTERFACE_SERIAL_16650, NULL, }, 263 { "16750-compat", PCI_INTERFACE_SERIAL_16750, NULL, }, 264 { "16850-compat", PCI_INTERFACE_SERIAL_16850, NULL, }, 265 { "16950-compat", PCI_INTERFACE_SERIAL_16950, NULL, }, 266 { NULL, 0, NULL, }, 267 }; 268 269 /* Parallel controller programming interface */ 270 static const struct pci_class pci_interface_parallel[] = { 271 { "", PCI_INTERFACE_PARALLEL, NULL,}, 272 { "bi-directional", PCI_INTERFACE_PARALLEL_BIDIRECTIONAL, NULL,}, 273 { "ECP 1.X-compat", PCI_INTERFACE_PARALLEL_ECP1X, NULL,}, 274 { "IEEE1284 controller", PCI_INTERFACE_PARALLEL_IEEE1284_CNTRL, NULL,}, 275 { "IEEE1284 target", PCI_INTERFACE_PARALLEL_IEEE1284_TGT, NULL,}, 276 { NULL, 0, NULL,}, 277 }; 278 279 /* Modem programming interface */ 280 static const struct pci_class pci_interface_modem[] = { 281 { "", PCI_INTERFACE_MODEM, NULL,}, 282 { "Hayes&16450-compat", PCI_INTERFACE_MODEM_HAYES16450, NULL,}, 283 { "Hayes&16550-compat", PCI_INTERFACE_MODEM_HAYES16550, NULL,}, 284 { "Hayes&16650-compat", PCI_INTERFACE_MODEM_HAYES16650, NULL,}, 285 { "Hayes&16750-compat", PCI_INTERFACE_MODEM_HAYES16750, NULL,}, 286 { NULL, 0, NULL,}, 287 }; 288 289 /* Subclasses */ 290 static const struct pci_class pci_subclass_communications[] = { 291 { "serial", PCI_SUBCLASS_COMMUNICATIONS_SERIAL, 292 pci_interface_serial, }, 293 { "parallel", PCI_SUBCLASS_COMMUNICATIONS_PARALLEL, 294 pci_interface_parallel, }, 295 { "multi-port serial", PCI_SUBCLASS_COMMUNICATIONS_MPSERIAL, NULL,}, 296 { "modem", PCI_SUBCLASS_COMMUNICATIONS_MODEM, 297 pci_interface_modem, }, 298 { "GPIB", PCI_SUBCLASS_COMMUNICATIONS_GPIB, NULL,}, 299 { "smartcard", PCI_SUBCLASS_COMMUNICATIONS_SMARTCARD, NULL,}, 300 { "miscellaneous", PCI_SUBCLASS_COMMUNICATIONS_MISC, NULL,}, 301 { NULL, 0, NULL,}, 302 }; 303 304 /* 305 * Class 0x08. 306 * Base system peripheral. 307 */ 308 309 /* PIC programming interface */ 310 static const struct pci_class pci_interface_pic[] = { 311 { "generic 8259", PCI_INTERFACE_PIC_8259, NULL, }, 312 { "ISA PIC", PCI_INTERFACE_PIC_ISA, NULL, }, 313 { "EISA PIC", PCI_INTERFACE_PIC_EISA, NULL, }, 314 { "IO APIC", PCI_INTERFACE_PIC_IOAPIC, NULL, }, 315 { "IO(x) APIC", PCI_INTERFACE_PIC_IOXAPIC, NULL, }, 316 { NULL, 0, NULL, }, 317 }; 318 319 /* DMA programming interface */ 320 static const struct pci_class pci_interface_dma[] = { 321 { "generic 8237", PCI_INTERFACE_DMA_8237, NULL, }, 322 { "ISA", PCI_INTERFACE_DMA_ISA, NULL, }, 323 { "EISA", PCI_INTERFACE_DMA_EISA, NULL, }, 324 { NULL, 0, NULL, }, 325 }; 326 327 /* Timer programming interface */ 328 static const struct pci_class pci_interface_tmr[] = { 329 { "generic 8254", PCI_INTERFACE_TIMER_8254, NULL, }, 330 { "ISA", PCI_INTERFACE_TIMER_ISA, NULL, }, 331 { "EISA", PCI_INTERFACE_TIMER_EISA, NULL, }, 332 { "HPET", PCI_INTERFACE_TIMER_HPET, NULL, }, 333 { NULL, 0, NULL, }, 334 }; 335 336 /* RTC programming interface */ 337 static const struct pci_class pci_interface_rtc[] = { 338 { "generic", PCI_INTERFACE_RTC_GENERIC, NULL, }, 339 { "ISA", PCI_INTERFACE_RTC_ISA, NULL, }, 340 { NULL, 0, NULL, }, 341 }; 342 343 /* Subclasses */ 344 static const struct pci_class pci_subclass_system[] = { 345 { "interrupt", PCI_SUBCLASS_SYSTEM_PIC, pci_interface_pic,}, 346 { "DMA", PCI_SUBCLASS_SYSTEM_DMA, pci_interface_dma,}, 347 { "timer", PCI_SUBCLASS_SYSTEM_TIMER, pci_interface_tmr,}, 348 { "RTC", PCI_SUBCLASS_SYSTEM_RTC, pci_interface_rtc,}, 349 { "PCI Hot-Plug", PCI_SUBCLASS_SYSTEM_PCIHOTPLUG, NULL, }, 350 { "SD Host Controller", PCI_SUBCLASS_SYSTEM_SDHC, NULL, }, 351 { "IOMMU", PCI_SUBCLASS_SYSTEM_IOMMU, NULL, }, 352 { "Root Complex Event Collector", PCI_SUBCLASS_SYSTEM_RCEC, NULL, }, 353 { "miscellaneous", PCI_SUBCLASS_SYSTEM_MISC, NULL, }, 354 { NULL, 0, NULL, }, 355 }; 356 357 /* 358 * Class 0x09. 359 * Input device. 360 */ 361 362 /* Gameport programming interface */ 363 static const struct pci_class pci_interface_game[] = { 364 { "generic", PCI_INTERFACE_GAMEPORT_GENERIC, NULL, }, 365 { "legacy", PCI_INTERFACE_GAMEPORT_LEGACY, NULL, }, 366 { NULL, 0, NULL, }, 367 }; 368 369 /* Subclasses */ 370 static const struct pci_class pci_subclass_input[] = { 371 { "keyboard", PCI_SUBCLASS_INPUT_KEYBOARD, NULL, }, 372 { "digitizer", PCI_SUBCLASS_INPUT_DIGITIZER, NULL, }, 373 { "mouse", PCI_SUBCLASS_INPUT_MOUSE, NULL, }, 374 { "scanner", PCI_SUBCLASS_INPUT_SCANNER, NULL, }, 375 { "game port", PCI_SUBCLASS_INPUT_GAMEPORT, 376 pci_interface_game, }, 377 { "miscellaneous", PCI_SUBCLASS_INPUT_MISC, NULL, }, 378 { NULL, 0, NULL, }, 379 }; 380 381 /* 382 * Class 0x0a. 383 * Docking station. 384 */ 385 static const struct pci_class pci_subclass_dock[] = { 386 { "generic", PCI_SUBCLASS_DOCK_GENERIC, NULL, }, 387 { "miscellaneous", PCI_SUBCLASS_DOCK_MISC, NULL, }, 388 { NULL, 0, NULL, }, 389 }; 390 391 /* 392 * Class 0x0b. 393 * Processor. 394 */ 395 static const struct pci_class pci_subclass_processor[] = { 396 { "386", PCI_SUBCLASS_PROCESSOR_386, NULL, }, 397 { "486", PCI_SUBCLASS_PROCESSOR_486, NULL, }, 398 { "Pentium", PCI_SUBCLASS_PROCESSOR_PENTIUM, NULL, }, 399 { "Alpha", PCI_SUBCLASS_PROCESSOR_ALPHA, NULL, }, 400 { "PowerPC", PCI_SUBCLASS_PROCESSOR_POWERPC, NULL, }, 401 { "MIPS", PCI_SUBCLASS_PROCESSOR_MIPS, NULL, }, 402 { "Co-processor", PCI_SUBCLASS_PROCESSOR_COPROC, NULL, }, 403 { "miscellaneous", PCI_SUBCLASS_PROCESSOR_MISC, NULL, }, 404 { NULL, 0, NULL, }, 405 }; 406 407 /* 408 * Class 0x0c. 409 * Serial bus controller. 410 */ 411 412 /* IEEE1394 programming interface */ 413 static const struct pci_class pci_interface_ieee1394[] = { 414 { "Firewire", PCI_INTERFACE_IEEE1394_FIREWIRE, NULL,}, 415 { "OpenHCI", PCI_INTERFACE_IEEE1394_OPENHCI, NULL,}, 416 { NULL, 0, NULL,}, 417 }; 418 419 /* USB programming interface */ 420 static const struct pci_class pci_interface_usb[] = { 421 { "UHCI", PCI_INTERFACE_USB_UHCI, NULL, }, 422 { "OHCI", PCI_INTERFACE_USB_OHCI, NULL, }, 423 { "EHCI", PCI_INTERFACE_USB_EHCI, NULL, }, 424 { "xHCI", PCI_INTERFACE_USB_XHCI, NULL, }, 425 { "other HC", PCI_INTERFACE_USB_OTHERHC, NULL, }, 426 { "device", PCI_INTERFACE_USB_DEVICE, NULL, }, 427 { NULL, 0, NULL, }, 428 }; 429 430 /* IPMI programming interface */ 431 static const struct pci_class pci_interface_ipmi[] = { 432 { "SMIC", PCI_INTERFACE_IPMI_SMIC, NULL, }, 433 { "keyboard", PCI_INTERFACE_IPMI_KBD, NULL, }, 434 { "block transfer", PCI_INTERFACE_IPMI_BLOCKXFER, NULL, }, 435 { NULL, 0, NULL, }, 436 }; 437 438 /* Subclasses */ 439 static const struct pci_class pci_subclass_serialbus[] = { 440 { "IEEE1394", PCI_SUBCLASS_SERIALBUS_FIREWIRE, 441 pci_interface_ieee1394, }, 442 { "ACCESS.bus", PCI_SUBCLASS_SERIALBUS_ACCESS, NULL, }, 443 { "SSA", PCI_SUBCLASS_SERIALBUS_SSA, NULL, }, 444 { "USB", PCI_SUBCLASS_SERIALBUS_USB, 445 pci_interface_usb, }, 446 /* XXX Fiber Channel/_FIBRECHANNEL */ 447 { "Fiber Channel", PCI_SUBCLASS_SERIALBUS_FIBER, NULL, }, 448 { "SMBus", PCI_SUBCLASS_SERIALBUS_SMBUS, NULL, }, 449 { "InfiniBand", PCI_SUBCLASS_SERIALBUS_INFINIBAND, NULL,}, 450 { "IPMI", PCI_SUBCLASS_SERIALBUS_IPMI, 451 pci_interface_ipmi, }, 452 { "SERCOS", PCI_SUBCLASS_SERIALBUS_SERCOS, NULL, }, 453 { "CANbus", PCI_SUBCLASS_SERIALBUS_CANBUS, NULL, }, 454 { "miscellaneous", PCI_SUBCLASS_SERIALBUS_MISC, NULL, }, 455 { NULL, 0, NULL, }, 456 }; 457 458 /* 459 * Class 0x0d. 460 * Wireless Controller. 461 */ 462 static const struct pci_class pci_subclass_wireless[] = { 463 { "IrDA", PCI_SUBCLASS_WIRELESS_IRDA, NULL, }, 464 { "Consumer IR",/*XXX*/ PCI_SUBCLASS_WIRELESS_CONSUMERIR, NULL, }, 465 { "RF", PCI_SUBCLASS_WIRELESS_RF, NULL, }, 466 { "bluetooth", PCI_SUBCLASS_WIRELESS_BLUETOOTH, NULL, }, 467 { "broadband", PCI_SUBCLASS_WIRELESS_BROADBAND, NULL, }, 468 { "802.11a (5 GHz)", PCI_SUBCLASS_WIRELESS_802_11A, NULL, }, 469 { "802.11b (2.4 GHz)", PCI_SUBCLASS_WIRELESS_802_11B, NULL, }, 470 { "miscellaneous", PCI_SUBCLASS_WIRELESS_MISC, NULL, }, 471 { NULL, 0, NULL, }, 472 }; 473 474 /* 475 * Class 0x0e. 476 * Intelligent IO controller. 477 */ 478 479 /* Intelligent IO programming interface */ 480 static const struct pci_class pci_interface_i2o[] = { 481 { "FIFO at offset 0x40", PCI_INTERFACE_I2O_FIFOAT40, NULL, }, 482 { NULL, 0, NULL, }, 483 }; 484 485 /* Subclasses */ 486 static const struct pci_class pci_subclass_i2o[] = { 487 { "standard", PCI_SUBCLASS_I2O_STANDARD, pci_interface_i2o,}, 488 { "miscellaneous", PCI_SUBCLASS_I2O_MISC, NULL, }, 489 { NULL, 0, NULL, }, 490 }; 491 492 /* 493 * Class 0x0f. 494 * Satellite communication controller. 495 */ 496 static const struct pci_class pci_subclass_satcom[] = { 497 { "TV", PCI_SUBCLASS_SATCOM_TV, NULL, }, 498 { "audio", PCI_SUBCLASS_SATCOM_AUDIO, NULL, }, 499 { "voice", PCI_SUBCLASS_SATCOM_VOICE, NULL, }, 500 { "data", PCI_SUBCLASS_SATCOM_DATA, NULL, }, 501 { "miscellaneous", PCI_SUBCLASS_SATCOM_MISC, NULL, }, 502 { NULL, 0, NULL, }, 503 }; 504 505 /* 506 * Class 0x10. 507 * Encryption/Decryption controller. 508 */ 509 static const struct pci_class pci_subclass_crypto[] = { 510 { "network/computing", PCI_SUBCLASS_CRYPTO_NETCOMP, NULL, }, 511 { "entertainment", PCI_SUBCLASS_CRYPTO_ENTERTAINMENT, NULL,}, 512 { "miscellaneous", PCI_SUBCLASS_CRYPTO_MISC, NULL, }, 513 { NULL, 0, NULL, }, 514 }; 515 516 /* 517 * Class 0x11. 518 * Data aquuisition and signal processing controller. 519 */ 520 static const struct pci_class pci_subclass_dasp[] = { 521 { "DPIO", PCI_SUBCLASS_DASP_DPIO, NULL, }, 522 { "performance counters", PCI_SUBCLASS_DASP_TIMEFREQ, NULL, }, 523 { "synchronization", PCI_SUBCLASS_DASP_SYNC, NULL, }, 524 { "management", PCI_SUBCLASS_DASP_MGMT, NULL, }, 525 { "miscellaneous", PCI_SUBCLASS_DASP_MISC, NULL, }, 526 { NULL, 0, NULL, }, 527 }; 528 529 /* List of classes */ 530 static const struct pci_class pci_classes[] = { 531 { "prehistoric", PCI_CLASS_PREHISTORIC, 532 pci_subclass_prehistoric, }, 533 { "mass storage", PCI_CLASS_MASS_STORAGE, 534 pci_subclass_mass_storage, }, 535 { "network", PCI_CLASS_NETWORK, 536 pci_subclass_network, }, 537 { "display", PCI_CLASS_DISPLAY, 538 pci_subclass_display, }, 539 { "multimedia", PCI_CLASS_MULTIMEDIA, 540 pci_subclass_multimedia, }, 541 { "memory", PCI_CLASS_MEMORY, 542 pci_subclass_memory, }, 543 { "bridge", PCI_CLASS_BRIDGE, 544 pci_subclass_bridge, }, 545 { "communications", PCI_CLASS_COMMUNICATIONS, 546 pci_subclass_communications, }, 547 { "system", PCI_CLASS_SYSTEM, 548 pci_subclass_system, }, 549 { "input", PCI_CLASS_INPUT, 550 pci_subclass_input, }, 551 { "dock", PCI_CLASS_DOCK, 552 pci_subclass_dock, }, 553 { "processor", PCI_CLASS_PROCESSOR, 554 pci_subclass_processor, }, 555 { "serial bus", PCI_CLASS_SERIALBUS, 556 pci_subclass_serialbus, }, 557 { "wireless", PCI_CLASS_WIRELESS, 558 pci_subclass_wireless, }, 559 { "I2O", PCI_CLASS_I2O, 560 pci_subclass_i2o, }, 561 { "satellite comm", PCI_CLASS_SATCOM, 562 pci_subclass_satcom, }, 563 { "crypto", PCI_CLASS_CRYPTO, 564 pci_subclass_crypto, }, 565 { "DASP", PCI_CLASS_DASP, 566 pci_subclass_dasp, }, 567 { "processing accelerators", PCI_CLASS_ACCEL, 568 NULL, }, 569 { "non-essential instrumentation", PCI_CLASS_INSTRUMENT, 570 NULL, }, 571 { "undefined", PCI_CLASS_UNDEFINED, 572 NULL, }, 573 { NULL, 0, 574 NULL, }, 575 }; 576 577 DEV_VERBOSE_DEFINE(pci); 578 579 /* 580 * Append a formatted string to dest without writing more than len 581 * characters (including the trailing NUL character). dest and len 582 * are updated for use in subsequent calls to snappendf(). 583 * 584 * Returns 0 on success, a negative value if vnsprintf() fails, or 585 * a positive value if the dest buffer would have overflowed. 586 */ 587 588 static int __printflike(3, 4) 589 snappendf(char **dest, size_t *len, const char * restrict fmt, ...) 590 { 591 va_list ap; 592 int count; 593 594 va_start(ap, fmt); 595 count = vsnprintf(*dest, *len, fmt, ap); 596 va_end(ap); 597 598 /* Let vsnprintf() errors bubble up to caller */ 599 if (count < 0 || *len == 0) 600 return count; 601 602 /* Handle overflow */ 603 if ((size_t)count >= *len) { 604 *dest += *len - 1; 605 *len = 1; 606 return 1; 607 } 608 609 /* Update dest & len to point at trailing NUL */ 610 *dest += count; 611 *len -= count; 612 613 return 0; 614 } 615 616 void 617 pci_devinfo(pcireg_t id_reg, pcireg_t class_reg, int showclass, char *cp, 618 size_t l) 619 { 620 pci_class_t class; 621 pci_subclass_t subclass; 622 pci_interface_t interface; 623 pci_revision_t revision; 624 char vendor[PCI_VENDORSTR_LEN], product[PCI_PRODUCTSTR_LEN]; 625 const struct pci_class *classp, *subclassp, *interfacep; 626 627 class = PCI_CLASS(class_reg); 628 subclass = PCI_SUBCLASS(class_reg); 629 interface = PCI_INTERFACE(class_reg); 630 revision = PCI_REVISION(class_reg); 631 632 pci_findvendor(vendor, sizeof(vendor), PCI_VENDOR(id_reg)); 633 pci_findproduct(product, sizeof(product), PCI_VENDOR(id_reg), 634 PCI_PRODUCT(id_reg)); 635 636 classp = pci_classes; 637 while (classp->name != NULL) { 638 if (class == classp->val) 639 break; 640 classp++; 641 } 642 643 subclassp = (classp->name != NULL) ? classp->subclasses : NULL; 644 while (subclassp && subclassp->name != NULL) { 645 if (subclass == subclassp->val) 646 break; 647 subclassp++; 648 } 649 650 interfacep = (subclassp && subclassp->name != NULL) ? 651 subclassp->subclasses : NULL; 652 while (interfacep && interfacep->name != NULL) { 653 if (interface == interfacep->val) 654 break; 655 interfacep++; 656 } 657 658 (void)snappendf(&cp, &l, "%s %s", vendor, product); 659 if (showclass) { 660 (void)snappendf(&cp, &l, " ("); 661 if (classp->name == NULL) 662 (void)snappendf(&cp, &l, 663 "class 0x%02x, subclass 0x%02x", 664 class, subclass); 665 else { 666 if (subclassp == NULL || subclassp->name == NULL) 667 (void)snappendf(&cp, &l, 668 "%s, subclass 0x%02x", 669 classp->name, subclass); 670 else 671 (void)snappendf(&cp, &l, "%s %s", 672 subclassp->name, classp->name); 673 } 674 if ((interfacep == NULL) || (interfacep->name == NULL)) { 675 if (interface != 0) 676 (void)snappendf(&cp, &l, ", interface 0x%02x", 677 interface); 678 } else if (strncmp(interfacep->name, "", 1) != 0) 679 (void)snappendf(&cp, &l, ", %s", interfacep->name); 680 if (revision != 0) 681 (void)snappendf(&cp, &l, ", revision 0x%02x", revision); 682 (void)snappendf(&cp, &l, ")"); 683 } 684 } 685 686 #ifdef _KERNEL 687 void 688 pci_aprint_devinfo_fancy(const struct pci_attach_args *pa, const char *naive, 689 const char *known, int addrev) 690 { 691 char devinfo[256]; 692 693 if (known) { 694 aprint_normal(": %s", known); 695 if (addrev) 696 aprint_normal(" (rev. 0x%02x)", 697 PCI_REVISION(pa->pa_class)); 698 aprint_normal("\n"); 699 } else { 700 pci_devinfo(pa->pa_id, pa->pa_class, 0, 701 devinfo, sizeof(devinfo)); 702 aprint_normal(": %s (rev. 0x%02x)\n", devinfo, 703 PCI_REVISION(pa->pa_class)); 704 } 705 if (naive) 706 aprint_naive(": %s\n", naive); 707 else 708 aprint_naive("\n"); 709 } 710 #endif 711 712 /* 713 * Print out most of the PCI configuration registers. Typically used 714 * in a device attach routine like this: 715 * 716 * #ifdef MYDEV_DEBUG 717 * printf("%s: ", device_xname(sc->sc_dev)); 718 * pci_conf_print(pa->pa_pc, pa->pa_tag, NULL); 719 * #endif 720 */ 721 722 #define i2o(i) ((i) * 4) 723 #define o2i(o) ((o) / 4) 724 #define onoff2(str, rval, bit, onstr, offstr) \ 725 printf(" %s: %s\n", (str), ((rval) & (bit)) ? onstr : offstr); 726 #define onoff(str, rval, bit) onoff2(str, rval, bit, "on", "off") 727 728 static void 729 pci_conf_print_common( 730 #ifdef _KERNEL 731 pci_chipset_tag_t pc, pcitag_t tag, 732 #endif 733 const pcireg_t *regs) 734 { 735 pci_class_t class; 736 pci_subclass_t subclass; 737 pci_interface_t interface; 738 pci_revision_t revision; 739 char vendor[PCI_VENDORSTR_LEN], product[PCI_PRODUCTSTR_LEN]; 740 const struct pci_class *classp, *subclassp, *interfacep; 741 const char *name; 742 pcireg_t rval; 743 unsigned int num; 744 745 rval = regs[o2i(PCI_CLASS_REG)]; 746 class = PCI_CLASS(rval); 747 subclass = PCI_SUBCLASS(rval); 748 interface = PCI_INTERFACE(rval); 749 revision = PCI_REVISION(rval); 750 751 rval = regs[o2i(PCI_ID_REG)]; 752 name = pci_findvendor(vendor, sizeof(vendor), PCI_VENDOR(rval)); 753 if (name) 754 printf(" Vendor Name: %s (0x%04x)\n", name, 755 PCI_VENDOR(rval)); 756 else 757 printf(" Vendor ID: 0x%04x\n", PCI_VENDOR(rval)); 758 name = pci_findproduct(product, sizeof(product), PCI_VENDOR(rval), 759 PCI_PRODUCT(rval)); 760 if (name) 761 printf(" Device Name: %s (0x%04x)\n", name, 762 PCI_PRODUCT(rval)); 763 else 764 printf(" Device ID: 0x%04x\n", PCI_PRODUCT(rval)); 765 766 rval = regs[o2i(PCI_COMMAND_STATUS_REG)]; 767 768 printf(" Command register: 0x%04x\n", rval & 0xffff); 769 onoff("I/O space accesses", rval, PCI_COMMAND_IO_ENABLE); 770 onoff("Memory space accesses", rval, PCI_COMMAND_MEM_ENABLE); 771 onoff("Bus mastering", rval, PCI_COMMAND_MASTER_ENABLE); 772 onoff("Special cycles", rval, PCI_COMMAND_SPECIAL_ENABLE); 773 onoff("MWI transactions", rval, PCI_COMMAND_INVALIDATE_ENABLE); 774 onoff("Palette snooping", rval, PCI_COMMAND_PALETTE_ENABLE); 775 onoff("Parity error checking", rval, PCI_COMMAND_PARITY_ENABLE); 776 onoff("Address/data stepping", rval, PCI_COMMAND_STEPPING_ENABLE); 777 onoff("System error (SERR)", rval, PCI_COMMAND_SERR_ENABLE); 778 onoff("Fast back-to-back transactions", rval, 779 PCI_COMMAND_BACKTOBACK_ENABLE); 780 onoff("Interrupt disable", rval, PCI_COMMAND_INTERRUPT_DISABLE); 781 782 printf(" Status register: 0x%04x\n", (rval >> 16) & 0xffff); 783 onoff("Immediate Readiness", rval, PCI_STATUS_IMMD_READNESS); 784 onoff2("Interrupt status", rval, PCI_STATUS_INT_STATUS, "active", 785 "inactive"); 786 onoff("Capability List support", rval, PCI_STATUS_CAPLIST_SUPPORT); 787 onoff("66 MHz capable", rval, PCI_STATUS_66MHZ_SUPPORT); 788 onoff("User Definable Features (UDF) support", rval, 789 PCI_STATUS_UDF_SUPPORT); 790 onoff("Fast back-to-back capable", rval, 791 PCI_STATUS_BACKTOBACK_SUPPORT); 792 onoff("Data parity error detected", rval, PCI_STATUS_PARITY_ERROR); 793 794 printf(" DEVSEL timing: "); 795 switch (rval & PCI_STATUS_DEVSEL_MASK) { 796 case PCI_STATUS_DEVSEL_FAST: 797 printf("fast"); 798 break; 799 case PCI_STATUS_DEVSEL_MEDIUM: 800 printf("medium"); 801 break; 802 case PCI_STATUS_DEVSEL_SLOW: 803 printf("slow"); 804 break; 805 default: 806 printf("unknown/reserved"); /* XXX */ 807 break; 808 } 809 printf(" (0x%x)\n", __SHIFTOUT(rval, PCI_STATUS_DEVSEL_MASK)); 810 811 onoff("Slave signaled Target Abort", rval, 812 PCI_STATUS_TARGET_TARGET_ABORT); 813 onoff("Master received Target Abort", rval, 814 PCI_STATUS_MASTER_TARGET_ABORT); 815 onoff("Master received Master Abort", rval, PCI_STATUS_MASTER_ABORT); 816 onoff("Asserted System Error (SERR)", rval, PCI_STATUS_SPECIAL_ERROR); 817 onoff("Parity error detected", rval, PCI_STATUS_PARITY_DETECT); 818 819 rval = regs[o2i(PCI_CLASS_REG)]; 820 for (classp = pci_classes; classp->name != NULL; classp++) { 821 if (class == classp->val) 822 break; 823 } 824 825 /* 826 * ECN: Change Root Complex Event Collector Class Code 827 * Old RCEC has subclass 0x06. It's the same as IOMMU. Read the type 828 * in PCIe extend capability to know whether it's RCEC or IOMMU. 829 */ 830 if ((class == PCI_CLASS_SYSTEM) 831 && (subclass == PCI_SUBCLASS_SYSTEM_IOMMU)) { 832 int pcie_capoff; 833 pcireg_t reg; 834 835 if (pci_conf_find_cap(regs, PCI_CAP_PCIEXPRESS, &pcie_capoff)) { 836 reg = regs[o2i(pcie_capoff + PCIE_XCAP)]; 837 if (PCIE_XCAP_TYPE(reg) == PCIE_XCAP_TYPE_ROOT_EVNTC) 838 subclass = PCI_SUBCLASS_SYSTEM_RCEC; 839 } 840 } 841 subclassp = (classp->name != NULL) ? classp->subclasses : NULL; 842 while (subclassp && subclassp->name != NULL) { 843 if (subclass == subclassp->val) 844 break; 845 subclassp++; 846 } 847 848 interfacep = (subclassp && subclassp->name != NULL) ? 849 subclassp->subclasses : NULL; 850 while (interfacep && interfacep->name != NULL) { 851 if (interface == interfacep->val) 852 break; 853 interfacep++; 854 } 855 856 if (classp->name != NULL) 857 printf(" Class Name: %s (0x%02x)\n", classp->name, class); 858 else 859 printf(" Class ID: 0x%02x\n", class); 860 if (subclassp != NULL && subclassp->name != NULL) 861 printf(" Subclass Name: %s (0x%02x)\n", 862 subclassp->name, PCI_SUBCLASS(rval)); 863 else 864 printf(" Subclass ID: 0x%02x\n", PCI_SUBCLASS(rval)); 865 if ((interfacep != NULL) && (interfacep->name != NULL) 866 && (strncmp(interfacep->name, "", 1) != 0)) 867 printf(" Interface Name: %s (0x%02x)\n", 868 interfacep->name, interface); 869 else 870 printf(" Interface: 0x%02x\n", interface); 871 printf(" Revision ID: 0x%02x\n", revision); 872 873 rval = regs[o2i(PCI_BHLC_REG)]; 874 printf(" BIST: 0x%02x\n", PCI_BIST(rval)); 875 printf(" Header Type: 0x%02x%s (0x%02x)\n", PCI_HDRTYPE_TYPE(rval), 876 PCI_HDRTYPE_MULTIFN(rval) ? "+multifunction" : "", 877 PCI_HDRTYPE(rval)); 878 printf(" Latency Timer: 0x%02x\n", PCI_LATTIMER(rval)); 879 num = PCI_CACHELINE(rval); 880 printf(" Cache Line Size: %ubytes (0x%02x)\n", num * 4, num); 881 } 882 883 static int 884 pci_conf_print_bar( 885 #ifdef _KERNEL 886 pci_chipset_tag_t pc, pcitag_t tag, 887 #endif 888 const pcireg_t *regs, int reg, const char *name) 889 { 890 int width; 891 pcireg_t rval, rval64h; 892 bool ioen, memen; 893 #ifdef _KERNEL 894 pcireg_t mask, mask64h = 0; 895 #endif 896 897 rval = regs[o2i(PCI_COMMAND_STATUS_REG)]; 898 ioen = rval & PCI_COMMAND_IO_ENABLE; 899 memen = rval & PCI_COMMAND_MEM_ENABLE; 900 901 width = 4; 902 /* 903 * Section 6.2.5.1, `Address Maps', tells us that: 904 * 905 * 1) The builtin software should have already mapped the 906 * device in a reasonable way. 907 * 908 * 2) A device which wants 2^n bytes of memory will hardwire 909 * the bottom n bits of the address to 0. As recommended, 910 * we write all 1s and see what we get back. 911 */ 912 913 rval = regs[o2i(reg)]; 914 if (PCI_MAPREG_TYPE(rval) == PCI_MAPREG_TYPE_MEM && 915 PCI_MAPREG_MEM_TYPE(rval) == PCI_MAPREG_MEM_TYPE_64BIT) { 916 rval64h = regs[o2i(reg + 4)]; 917 width = 8; 918 } else 919 rval64h = 0; 920 921 #ifdef _KERNEL 922 if (rval != 0 && memen) { 923 int s; 924 925 /* 926 * The following sequence seems to make some devices 927 * (e.g. host bus bridges, which don't normally 928 * have their space mapped) very unhappy, to 929 * the point of crashing the system. 930 * 931 * Therefore, if the mapping register is zero to 932 * start out with, don't bother trying. 933 */ 934 s = splhigh(); 935 pci_conf_write(pc, tag, reg, 0xffffffff); 936 mask = pci_conf_read(pc, tag, reg); 937 pci_conf_write(pc, tag, reg, rval); 938 if (PCI_MAPREG_TYPE(rval) == PCI_MAPREG_TYPE_MEM && 939 PCI_MAPREG_MEM_TYPE(rval) == PCI_MAPREG_MEM_TYPE_64BIT) { 940 pci_conf_write(pc, tag, reg + 4, 0xffffffff); 941 mask64h = pci_conf_read(pc, tag, reg + 4); 942 pci_conf_write(pc, tag, reg + 4, rval64h); 943 } 944 splx(s); 945 } else 946 mask = mask64h = 0; 947 #endif /* _KERNEL */ 948 949 printf(" Base address register at 0x%02x", reg); 950 if (name) 951 printf(" (%s)", name); 952 printf("\n "); 953 if (rval == 0) { 954 printf("not implemented\n"); 955 return width; 956 } 957 printf("type: "); 958 if (PCI_MAPREG_TYPE(rval) == PCI_MAPREG_TYPE_MEM) { 959 const char *type, *prefetch; 960 961 switch (PCI_MAPREG_MEM_TYPE(rval)) { 962 case PCI_MAPREG_MEM_TYPE_32BIT: 963 type = "32-bit"; 964 break; 965 case PCI_MAPREG_MEM_TYPE_32BIT_1M: 966 type = "32-bit-1M"; 967 break; 968 case PCI_MAPREG_MEM_TYPE_64BIT: 969 type = "64-bit"; 970 break; 971 default: 972 type = "unknown (XXX)"; 973 break; 974 } 975 if (PCI_MAPREG_MEM_PREFETCHABLE(rval)) 976 prefetch = ""; 977 else 978 prefetch = "non"; 979 printf("%s %sprefetchable memory\n", type, prefetch); 980 switch (PCI_MAPREG_MEM_TYPE(rval)) { 981 case PCI_MAPREG_MEM_TYPE_64BIT: 982 printf(" base: 0x%016llx", 983 PCI_MAPREG_MEM64_ADDR( 984 ((((long long) rval64h) << 32) | rval))); 985 if (!memen) 986 printf(", disabled"); 987 printf("\n"); 988 #ifdef _KERNEL 989 printf(" size: 0x%016llx\n", 990 PCI_MAPREG_MEM64_SIZE( 991 ((((long long) mask64h) << 32) | mask))); 992 #endif 993 break; 994 case PCI_MAPREG_MEM_TYPE_32BIT: 995 case PCI_MAPREG_MEM_TYPE_32BIT_1M: 996 default: 997 printf(" base: 0x%08x", 998 PCI_MAPREG_MEM_ADDR(rval)); 999 if (!memen) 1000 printf(", disabled"); 1001 printf("\n"); 1002 #ifdef _KERNEL 1003 printf(" size: 0x%08x\n", 1004 PCI_MAPREG_MEM_SIZE(mask)); 1005 #endif 1006 break; 1007 } 1008 } else { 1009 #ifdef _KERNEL 1010 if (ioen) 1011 printf("%d-bit ", mask & ~0x0000ffff ? 32 : 16); 1012 #endif 1013 printf("I/O\n"); 1014 printf(" base: 0x%08x", PCI_MAPREG_IO_ADDR(rval)); 1015 if (!ioen) 1016 printf(", disabled"); 1017 printf("\n"); 1018 #ifdef _KERNEL 1019 printf(" size: 0x%08x\n", PCI_MAPREG_IO_SIZE(mask)); 1020 #endif 1021 } 1022 1023 return width; 1024 } 1025 1026 static void 1027 pci_conf_print_regs(const pcireg_t *regs, int first, int pastlast) 1028 { 1029 int off, needaddr, neednl; 1030 1031 needaddr = 1; 1032 neednl = 0; 1033 for (off = first; off < pastlast; off += 4) { 1034 if ((off % 16) == 0 || needaddr) { 1035 printf(" 0x%02x:", off); 1036 needaddr = 0; 1037 } 1038 printf(" 0x%08x", regs[o2i(off)]); 1039 neednl = 1; 1040 if ((off % 16) == 12) { 1041 printf("\n"); 1042 neednl = 0; 1043 } 1044 } 1045 if (neednl) 1046 printf("\n"); 1047 } 1048 1049 static const char * 1050 pci_conf_print_agp_calcycle(uint8_t cal) 1051 { 1052 1053 switch (cal) { 1054 case 0x0: 1055 return "4ms"; 1056 case 0x1: 1057 return "16ms"; 1058 case 0x2: 1059 return "64ms"; 1060 case 0x3: 1061 return "256ms"; 1062 case 0x7: 1063 return "Calibration Cycle Not Needed"; 1064 default: 1065 return "(reserved)"; 1066 } 1067 } 1068 1069 static void 1070 pci_conf_print_agp_datarate(pcireg_t reg, bool isagp3) 1071 { 1072 if (isagp3) { 1073 /* AGP 3.0 */ 1074 if (reg & AGP_MODE_V3_RATE_4x) 1075 printf("x4"); 1076 if (reg & AGP_MODE_V3_RATE_8x) 1077 printf("x8"); 1078 } else { 1079 /* AGP 2.0 */ 1080 if (reg & AGP_MODE_V2_RATE_1x) 1081 printf("x1"); 1082 if (reg & AGP_MODE_V2_RATE_2x) 1083 printf("x2"); 1084 if (reg & AGP_MODE_V2_RATE_4x) 1085 printf("x4"); 1086 } 1087 printf("\n"); 1088 } 1089 1090 static void 1091 pci_conf_print_agp_cap(const pcireg_t *regs, int capoff) 1092 { 1093 pcireg_t rval; 1094 bool isagp3; 1095 1096 printf("\n AGP Capabilities Register\n"); 1097 1098 rval = regs[o2i(capoff)]; 1099 printf(" Revision: %d.%d\n", 1100 PCI_CAP_AGP_MAJOR(rval), PCI_CAP_AGP_MINOR(rval)); 1101 1102 rval = regs[o2i(capoff + PCI_AGP_STATUS)]; 1103 printf(" Status register: 0x%04x\n", rval); 1104 printf(" RQ: %d\n", 1105 (unsigned int)__SHIFTOUT(rval, AGP_MODE_RQ) + 1); 1106 printf(" ARQSZ: %d\n", 1107 (unsigned int)__SHIFTOUT(rval, AGP_MODE_ARQSZ)); 1108 printf(" CAL cycle: %s\n", 1109 pci_conf_print_agp_calcycle(__SHIFTOUT(rval, AGP_MODE_CAL))); 1110 onoff("SBA", rval, AGP_MODE_SBA); 1111 onoff("htrans#", rval, AGP_MODE_HTRANS); 1112 onoff("Over 4G", rval, AGP_MODE_4G); 1113 onoff("Fast Write", rval, AGP_MODE_FW); 1114 onoff("AGP 3.0 Mode", rval, AGP_MODE_MODE_3); 1115 isagp3 = rval & AGP_MODE_MODE_3; 1116 printf(" Data Rate Support: "); 1117 pci_conf_print_agp_datarate(rval, isagp3); 1118 1119 rval = regs[o2i(capoff + PCI_AGP_COMMAND)]; 1120 printf(" Command register: 0x%08x\n", rval); 1121 printf(" PRQ: %d\n", 1122 (unsigned int)__SHIFTOUT(rval, AGP_MODE_RQ) + 1); 1123 printf(" PARQSZ: %d\n", 1124 (unsigned int)__SHIFTOUT(rval, AGP_MODE_ARQSZ)); 1125 printf(" PCAL cycle: %s\n", 1126 pci_conf_print_agp_calcycle(__SHIFTOUT(rval, AGP_MODE_CAL))); 1127 onoff("SBA", rval, AGP_MODE_SBA); 1128 onoff("AGP", rval, AGP_MODE_AGP); 1129 onoff("Over 4G", rval, AGP_MODE_4G); 1130 onoff("Fast Write", rval, AGP_MODE_FW); 1131 if (isagp3) { 1132 printf(" Data Rate Enable: "); 1133 /* 1134 * The Data Rate Enable bits are used only on 3.0 and the 1135 * Command register has no AGP_MODE_MODE_3 bit, so pass the 1136 * flag to print correctly. 1137 */ 1138 pci_conf_print_agp_datarate(rval, isagp3); 1139 } 1140 } 1141 1142 static const char * 1143 pci_conf_print_pcipm_cap_aux(uint16_t caps) 1144 { 1145 1146 switch ((caps >> 6) & 7) { 1147 case 0: return "self-powered"; 1148 case 1: return "55 mA"; 1149 case 2: return "100 mA"; 1150 case 3: return "160 mA"; 1151 case 4: return "220 mA"; 1152 case 5: return "270 mA"; 1153 case 6: return "320 mA"; 1154 case 7: 1155 default: return "375 mA"; 1156 } 1157 } 1158 1159 static const char * 1160 pci_conf_print_pcipm_cap_pmrev(uint8_t val) 1161 { 1162 static const char unk[] = "unknown"; 1163 static const char *pmrev[8] = { 1164 unk, "1.0", "1.1", "1.2", unk, unk, unk, unk 1165 }; 1166 if (val > 7) 1167 return unk; 1168 return pmrev[val]; 1169 } 1170 1171 static void 1172 pci_conf_print_pcipm_cap(const pcireg_t *regs, int capoff) 1173 { 1174 uint16_t caps, pmcsr; 1175 1176 caps = regs[o2i(capoff)] >> PCI_PMCR_SHIFT; 1177 pmcsr = regs[o2i(capoff + PCI_PMCSR)]; 1178 1179 printf("\n PCI Power Management Capabilities Register\n"); 1180 1181 printf(" Capabilities register: 0x%04x\n", caps); 1182 printf(" Version: %s\n", 1183 pci_conf_print_pcipm_cap_pmrev(caps & PCI_PMCR_VERSION_MASK)); 1184 onoff("PME# clock", caps, PCI_PMCR_PME_CLOCK); 1185 onoff("Device specific initialization", caps, PCI_PMCR_DSI); 1186 printf(" 3.3V auxiliary current: %s\n", 1187 pci_conf_print_pcipm_cap_aux(caps)); 1188 onoff("D1 power management state support", caps, PCI_PMCR_D1SUPP); 1189 onoff("D2 power management state support", caps, PCI_PMCR_D2SUPP); 1190 onoff("PME# support D0", caps, PCI_PMCR_PME_D0); 1191 onoff("PME# support D1", caps, PCI_PMCR_PME_D1); 1192 onoff("PME# support D2", caps, PCI_PMCR_PME_D2); 1193 onoff("PME# support D3 hot", caps, PCI_PMCR_PME_D3HOT); 1194 onoff("PME# support D3 cold", caps, PCI_PMCR_PME_D3COLD); 1195 1196 printf(" Control/status register: 0x%08x\n", pmcsr); 1197 printf(" Power state: D%d\n", pmcsr & PCI_PMCSR_STATE_MASK); 1198 onoff("PCI Express reserved", (pmcsr >> 2), 1); 1199 onoff("No soft reset", pmcsr, PCI_PMCSR_NO_SOFTRST); 1200 printf(" PME# assertion: %sabled\n", 1201 (pmcsr & PCI_PMCSR_PME_EN) ? "en" : "dis"); 1202 printf(" Data Select: %d\n", 1203 __SHIFTOUT(pmcsr, PCI_PMCSR_DATASEL_MASK)); 1204 printf(" Data Scale: %d\n", 1205 __SHIFTOUT(pmcsr, PCI_PMCSR_DATASCL_MASK)); 1206 onoff("PME# status", pmcsr, PCI_PMCSR_PME_STS); 1207 printf(" Bridge Support Extensions register: 0x%02x\n", 1208 (pmcsr >> 16) & 0xff); 1209 onoff("B2/B3 support", pmcsr, PCI_PMCSR_B2B3_SUPPORT); 1210 onoff("Bus Power/Clock Control Enable", pmcsr, PCI_PMCSR_BPCC_EN); 1211 printf(" Data register: 0x%02x\n", 1212 __SHIFTOUT(pmcsr, PCI_PMCSR_DATA)); 1213 } 1214 1215 /* XXX pci_conf_print_vpd_cap */ 1216 /* XXX pci_conf_print_slotid_cap */ 1217 1218 static void 1219 pci_conf_print_msi_cap(const pcireg_t *regs, int capoff) 1220 { 1221 uint32_t ctl, mmc, mme; 1222 1223 regs += o2i(capoff); 1224 ctl = *regs++; 1225 mmc = __SHIFTOUT(ctl, PCI_MSI_CTL_MMC_MASK); 1226 mme = __SHIFTOUT(ctl, PCI_MSI_CTL_MME_MASK); 1227 1228 printf("\n PCI Message Signaled Interrupt\n"); 1229 1230 printf(" Message Control register: 0x%04x\n", ctl >> 16); 1231 onoff("MSI Enabled", ctl, PCI_MSI_CTL_MSI_ENABLE); 1232 printf(" Multiple Message Capable: %s (%d vector%s)\n", 1233 mmc > 0 ? "yes" : "no", 1 << mmc, mmc > 0 ? "s" : ""); 1234 printf(" Multiple Message Enabled: %s (%d vector%s)\n", 1235 mme > 0 ? "on" : "off", 1 << mme, mme > 0 ? "s" : ""); 1236 onoff("64 Bit Address Capable", ctl, PCI_MSI_CTL_64BIT_ADDR); 1237 onoff("Per-Vector Masking Capable", ctl, PCI_MSI_CTL_PERVEC_MASK); 1238 onoff("Extended Message Data Capable", ctl, PCI_MSI_CTL_EXTMDATA_CAP); 1239 onoff("Extended Message Data Enable", ctl, PCI_MSI_CTL_EXTMDATA_EN); 1240 printf(" Message Address %sregister: 0x%08x\n", 1241 ctl & PCI_MSI_CTL_64BIT_ADDR ? "(lower) " : "", *regs++); 1242 if (ctl & PCI_MSI_CTL_64BIT_ADDR) { 1243 printf(" Message Address %sregister: 0x%08x\n", 1244 "(upper) ", *regs++); 1245 } 1246 printf(" Message Data register: "); 1247 if (ctl & PCI_MSI_CTL_EXTMDATA_CAP) 1248 printf("0x%08x\n", *regs); 1249 else 1250 printf("0x%04x\n", *regs & 0xffff); 1251 regs++; 1252 if (ctl & PCI_MSI_CTL_PERVEC_MASK) { 1253 printf(" Vector Mask register: 0x%08x\n", *regs++); 1254 printf(" Vector Pending register: 0x%08x\n", *regs++); 1255 } 1256 } 1257 1258 /* XXX pci_conf_print_cpci_hostwap_cap */ 1259 1260 /* 1261 * For both command register and status register. 1262 * The argument "idx" is index number (0 to 7). 1263 */ 1264 static int 1265 pcix_split_trans(unsigned int idx) 1266 { 1267 static int table[8] = { 1268 1, 2, 3, 4, 8, 12, 16, 32 1269 }; 1270 1271 if (idx >= __arraycount(table)) 1272 return -1; 1273 return table[idx]; 1274 } 1275 1276 static void 1277 pci_conf_print_pcix_cap_2ndbusmode(int num) 1278 { 1279 const char *maxfreq, *maxperiod; 1280 1281 printf(" Mode: "); 1282 if (num <= 0x07) 1283 printf("PCI-X Mode 1\n"); 1284 else if (num <= 0x0b) 1285 printf("PCI-X 266 (Mode 2)\n"); 1286 else 1287 printf("PCI-X 533 (Mode 2)\n"); 1288 1289 printf(" Error protection: %s\n", (num <= 3) ? "parity" : "ECC"); 1290 switch (num & 0x03) { 1291 default: 1292 case 0: 1293 maxfreq = "N/A"; 1294 maxperiod = "N/A"; 1295 break; 1296 case 1: 1297 maxfreq = "66MHz"; 1298 maxperiod = "15ns"; 1299 break; 1300 case 2: 1301 maxfreq = "100MHz"; 1302 maxperiod = "10ns"; 1303 break; 1304 case 3: 1305 maxfreq = "133MHz"; 1306 maxperiod = "7.5ns"; 1307 break; 1308 } 1309 printf(" Max Clock Freq: %s\n", maxfreq); 1310 printf(" Min Clock Period: %s\n", maxperiod); 1311 } 1312 1313 static void 1314 pci_conf_print_pcix_cap(const pcireg_t *regs, int capoff) 1315 { 1316 pcireg_t reg; 1317 int isbridge; 1318 int i; 1319 1320 isbridge = (PCI_HDRTYPE_TYPE(regs[o2i(PCI_BHLC_REG)]) 1321 & PCI_HDRTYPE_PPB) != 0 ? 1 : 0; 1322 printf("\n PCI-X %s Capabilities Register\n", 1323 isbridge ? "Bridge" : "Non-bridge"); 1324 1325 reg = regs[o2i(capoff)]; 1326 if (isbridge != 0) { 1327 printf(" Secondary status register: 0x%04x\n", 1328 (reg & 0xffff0000) >> 16); 1329 onoff("64bit device", reg, PCIX_STATUS_64BIT); 1330 onoff("133MHz capable", reg, PCIX_STATUS_133); 1331 onoff("Split completion discarded", reg, PCIX_STATUS_SPLDISC); 1332 onoff("Unexpected split completion", reg, PCIX_STATUS_SPLUNEX); 1333 onoff("Split completion overrun", reg, PCIX_BRIDGE_ST_SPLOVRN); 1334 onoff("Split request delayed", reg, PCIX_BRIDGE_ST_SPLRQDL); 1335 pci_conf_print_pcix_cap_2ndbusmode( 1336 __SHIFTOUT(reg, PCIX_BRIDGE_2NDST_CLKF)); 1337 printf(" Version: 0x%x\n", 1338 (reg & PCIX_BRIDGE_2NDST_VER_MASK) 1339 >> PCIX_BRIDGE_2NDST_VER_SHIFT); 1340 onoff("266MHz capable", reg, PCIX_BRIDGE_ST_266); 1341 onoff("533MHz capable", reg, PCIX_BRIDGE_ST_533); 1342 } else { 1343 printf(" Command register: 0x%04x\n", 1344 (reg & 0xffff0000) >> 16); 1345 onoff("Data Parity Error Recovery", reg, 1346 PCIX_CMD_PERR_RECOVER); 1347 onoff("Enable Relaxed Ordering", reg, PCIX_CMD_RELAXED_ORDER); 1348 printf(" Maximum Burst Read Count: %u\n", 1349 PCIX_CMD_BYTECNT(reg)); 1350 printf(" Maximum Split Transactions: %d\n", 1351 pcix_split_trans((reg & PCIX_CMD_SPLTRANS_MASK) 1352 >> PCIX_CMD_SPLTRANS_SHIFT)); 1353 } 1354 reg = regs[o2i(capoff+PCIX_STATUS)]; /* Or PCIX_BRIDGE_PRI_STATUS */ 1355 printf(" %sStatus register: 0x%08x\n", 1356 isbridge ? "Bridge " : "", reg); 1357 printf(" Function: %d\n", PCIX_STATUS_FN(reg)); 1358 printf(" Device: %d\n", PCIX_STATUS_DEV(reg)); 1359 printf(" Bus: %d\n", PCIX_STATUS_BUS(reg)); 1360 onoff("64bit device", reg, PCIX_STATUS_64BIT); 1361 onoff("133MHz capable", reg, PCIX_STATUS_133); 1362 onoff("Split completion discarded", reg, PCIX_STATUS_SPLDISC); 1363 onoff("Unexpected split completion", reg, PCIX_STATUS_SPLUNEX); 1364 if (isbridge != 0) { 1365 onoff("Split completion overrun", reg, PCIX_BRIDGE_ST_SPLOVRN); 1366 onoff("Split request delayed", reg, PCIX_BRIDGE_ST_SPLRQDL); 1367 } else { 1368 onoff2("Device Complexity", reg, PCIX_STATUS_DEVCPLX, 1369 "bridge device", "simple device"); 1370 printf(" Designed max memory read byte count: %d\n", 1371 512 << ((reg & PCIX_STATUS_MAXB_MASK) 1372 >> PCIX_STATUS_MAXB_SHIFT)); 1373 printf(" Designed max outstanding split transaction: %d\n", 1374 pcix_split_trans((reg & PCIX_STATUS_MAXST_MASK) 1375 >> PCIX_STATUS_MAXST_SHIFT)); 1376 printf(" MAX cumulative Read Size: %u\n", 1377 8 << ((reg & 0x1c000000) >> PCIX_STATUS_MAXRS_SHIFT)); 1378 onoff("Received split completion error", reg, 1379 PCIX_STATUS_SCERR); 1380 } 1381 onoff("266MHz capable", reg, PCIX_STATUS_266); 1382 onoff("533MHz capable", reg, PCIX_STATUS_533); 1383 1384 if (isbridge == 0) 1385 return; 1386 1387 /* Only for bridge */ 1388 for (i = 0; i < 2; i++) { 1389 reg = regs[o2i(capoff + PCIX_BRIDGE_UP_STCR + (4 * i))]; 1390 printf(" %s split transaction control register: 0x%08x\n", 1391 (i == 0) ? "Upstream" : "Downstream", reg); 1392 printf(" Capacity: %d\n", reg & PCIX_BRIDGE_STCAP); 1393 printf(" Commitment Limit: %d\n", 1394 (reg & PCIX_BRIDGE_STCLIM) >> PCIX_BRIDGE_STCLIM_SHIFT); 1395 } 1396 } 1397 1398 /* pci_conf_print_ht_slave_cap */ 1399 /* pci_conf_print_ht_host_cap */ 1400 /* pci_conf_print_ht_switch_cap */ 1401 /* pci_conf_print_ht_intr_cap */ 1402 /* pci_conf_print_ht_revid_cap */ 1403 /* pci_conf_print_ht_unitid_cap */ 1404 /* pci_conf_print_ht_extcnf_cap */ 1405 /* pci_conf_print_ht_addrmap_cap */ 1406 /* pci_conf_print_ht_msimap_cap */ 1407 1408 static void 1409 pci_conf_print_ht_msimap_cap(const pcireg_t *regs, int capoff) 1410 { 1411 pcireg_t val; 1412 uint32_t lo, hi; 1413 1414 /* 1415 * Print the rest of the command register bits. Others are 1416 * printed in pci_conf_print_ht_cap(). 1417 */ 1418 val = regs[o2i(capoff + PCI_HT_CMD)]; 1419 onoff("Enable", val, PCI_HT_MSI_ENABLED); 1420 onoff("Fixed", val, PCI_HT_MSI_FIXED); 1421 1422 lo = regs[o2i(capoff + PCI_HT_MSI_ADDR_LO)]; 1423 hi = regs[o2i(capoff + PCI_HT_MSI_ADDR_HI)]; 1424 printf(" Address Low register: 0x%08x\n", lo); 1425 printf(" Address high register: 0x%08x\n", hi); 1426 printf(" Address: 0x%016" PRIx64 "\n", 1427 (uint64_t)hi << 32 | (lo & PCI_HT_MSI_ADDR_LO_MASK)); 1428 } 1429 1430 /* pci_conf_print_ht_droute_cap */ 1431 /* pci_conf_print_ht_vcset_cap */ 1432 /* pci_conf_print_ht_retry_cap */ 1433 /* pci_conf_print_ht_x86enc_cap */ 1434 /* pci_conf_print_ht_gen3_cap */ 1435 /* pci_conf_print_ht_fle_cap */ 1436 /* pci_conf_print_ht_pm_cap */ 1437 /* pci_conf_print_ht_hnc_cap */ 1438 1439 static const struct ht_types { 1440 pcireg_t cap; 1441 const char *name; 1442 void (*printfunc)(const pcireg_t *, int); 1443 } ht_captab[] = { 1444 {PCI_HT_CAP_SLAVE, "Slave or Primary Interface", NULL }, 1445 {PCI_HT_CAP_HOST, "Host or Secondary Interface", NULL }, 1446 {PCI_HT_CAP_SWITCH, "Switch", NULL }, 1447 {PCI_HT_CAP_INTERRUPT, "Interrupt Discovery and Configuration", NULL}, 1448 {PCI_HT_CAP_REVID, "Revision ID", NULL }, 1449 {PCI_HT_CAP_UNITID_CLUMP, "UnitID Clumping", NULL }, 1450 {PCI_HT_CAP_EXTCNFSPACE, "Extended Configuration Space Access", NULL }, 1451 {PCI_HT_CAP_ADDRMAP, "Address Mapping", NULL }, 1452 {PCI_HT_CAP_MSIMAP, "MSI Mapping", pci_conf_print_ht_msimap_cap }, 1453 {PCI_HT_CAP_DIRECTROUTE, "Direct Route", NULL }, 1454 {PCI_HT_CAP_VCSET, "VCSet", NULL }, 1455 {PCI_HT_CAP_RETRYMODE, "Retry Mode", NULL }, 1456 {PCI_HT_CAP_X86ENCODE, "X86 Encoding", NULL }, 1457 {PCI_HT_CAP_GEN3, "Gen3", NULL }, 1458 {PCI_HT_CAP_FLE, "Function-Level Extension", NULL }, 1459 {PCI_HT_CAP_PM, "Power Management", NULL }, 1460 {PCI_HT_CAP_HIGHNODECNT, "High Node Count", NULL }, 1461 }; 1462 1463 static void 1464 pci_conf_print_ht_cap(const pcireg_t *regs, int capoff) 1465 { 1466 pcireg_t val, foundcap; 1467 unsigned int off; 1468 1469 val = regs[o2i(capoff + PCI_HT_CMD)]; 1470 1471 printf("\n HyperTransport Capability Register at 0x%02x\n", capoff); 1472 1473 printf(" Command register: 0x%04x\n", val >> 16); 1474 foundcap = PCI_HT_CAP(val); 1475 for (off = 0; off < __arraycount(ht_captab); off++) { 1476 if (ht_captab[off].cap == foundcap) 1477 break; 1478 } 1479 printf(" Capability Type: 0x%02x ", foundcap); 1480 if (off >= __arraycount(ht_captab)) { 1481 printf("(unknown)\n"); 1482 return; 1483 } 1484 printf("(%s)\n", ht_captab[off].name); 1485 if (ht_captab[off].printfunc != NULL) 1486 ht_captab[off].printfunc(regs, capoff); 1487 } 1488 1489 static void 1490 pci_conf_print_vendspec_cap(const pcireg_t *regs, int capoff) 1491 { 1492 uint16_t caps; 1493 1494 caps = regs[o2i(capoff)] >> PCI_VENDORSPECIFIC_SHIFT; 1495 1496 printf("\n PCI Vendor Specific Capabilities Register\n"); 1497 printf(" Capabilities length: 0x%02x\n", caps & 0xff); 1498 } 1499 1500 static void 1501 pci_conf_print_debugport_cap(const pcireg_t *regs, int capoff) 1502 { 1503 pcireg_t val; 1504 1505 val = regs[o2i(capoff + PCI_DEBUG_BASER)]; 1506 1507 printf("\n Debugport Capability Register\n"); 1508 printf(" Debug base Register: 0x%04x\n", 1509 val >> PCI_DEBUG_BASER_SHIFT); 1510 printf(" port offset: 0x%04x\n", 1511 (val & PCI_DEBUG_PORTOFF_MASK) >> PCI_DEBUG_PORTOFF_SHIFT); 1512 printf(" BAR number: %u\n", 1513 (val & PCI_DEBUG_BARNUM_MASK) >> PCI_DEBUG_BARNUM_SHIFT); 1514 } 1515 1516 /* XXX pci_conf_print_cpci_rsrcctl_cap */ 1517 /* XXX pci_conf_print_hotplug_cap */ 1518 1519 static void 1520 pci_conf_print_subsystem_cap(const pcireg_t *regs, int capoff) 1521 { 1522 pcireg_t reg; 1523 1524 reg = regs[o2i(capoff + PCI_CAP_SUBSYS_ID)]; 1525 1526 printf("\n Subsystem ID Capability Register\n"); 1527 printf(" Subsystem ID: 0x%08x\n", reg); 1528 } 1529 1530 /* XXX pci_conf_print_agp8_cap */ 1531 static void 1532 pci_conf_print_secure_cap(const pcireg_t *regs, int capoff) 1533 { 1534 pcireg_t reg, reg2, val; 1535 bool havemisc1; 1536 1537 printf("\n Secure Capability Register\n"); 1538 reg = regs[o2i(capoff + PCI_SECURE_CAP)]; 1539 printf(" Capability Register: 0x%04x\n", reg >> 16); 1540 val = __SHIFTOUT(reg, PCI_SECURE_CAP_TYPE); 1541 printf(" Capability block type: "); 1542 /* I know IOMMU Only */ 1543 if (val == PCI_SECURE_CAP_TYPE_IOMMU) 1544 printf("IOMMU\n"); 1545 else { 1546 printf("0x%x(unknown)\n", val); 1547 return; 1548 } 1549 1550 val = __SHIFTOUT(reg, PCI_SECURE_CAP_REV); 1551 printf(" Capability revision: 0x%02x ", val); 1552 if (val == PCI_SECURE_CAP_REV_IOMMU) 1553 printf("(IOMMU)\n"); 1554 else { 1555 printf("(unknown)\n"); 1556 return; 1557 } 1558 onoff("IOTLB support", reg, PCI_SECURE_CAP_IOTLBSUP); 1559 onoff("HyperTransport tunnel translation support", reg, 1560 PCI_SECURE_CAP_HTTUNNEL); 1561 onoff("Not present table entries cached", reg, PCI_SECURE_CAP_NPCACHE); 1562 onoff("IOMMU Extended Feature Register support", reg, 1563 PCI_SECURE_CAP_EFRSUP); 1564 onoff("IOMMU Miscellaneous Information Register 1", reg, 1565 PCI_SECURE_CAP_EXT); 1566 havemisc1 = reg & PCI_SECURE_CAP_EXT; 1567 1568 reg = regs[o2i(capoff + PCI_SECURE_IOMMU_BAL)]; 1569 printf(" Base Address Low Register: 0x%08x\n", reg); 1570 onoff("Enable", reg, PCI_SECURE_IOMMU_BAL_EN); 1571 reg2 = regs[o2i(capoff + PCI_SECURE_IOMMU_BAH)]; 1572 printf(" Base Address High Register: 0x%08x\n", reg2); 1573 printf(" Base Address: 0x%016" PRIx64 "\n", 1574 ((uint64_t)reg2 << 32) 1575 | (reg & (PCI_SECURE_IOMMU_BAL_H | PCI_SECURE_IOMMU_BAL_L))); 1576 1577 reg = regs[o2i(capoff + PCI_SECURE_IOMMU_RANGE)]; 1578 printf(" IOMMU Range Register: 0x%08x\n", reg); 1579 printf(" HyperTransport UnitID: 0x%02x\n", 1580 (uint32_t)__SHIFTOUT(reg, PCI_SECURE_IOMMU_RANGE_UNITID)); 1581 onoff("Range valid", reg, PCI_SECURE_IOMMU_RANGE_RNGVALID); 1582 printf(" Device range bus number: 0x%02x\n", 1583 (uint32_t)__SHIFTOUT(reg, PCI_SECURE_IOMMU_RANGE_BUSNUM)); 1584 printf(" First device: 0x%04x\n", 1585 (uint32_t)__SHIFTOUT(reg, PCI_SECURE_IOMMU_RANGE_FIRSTDEV)); 1586 printf(" Last device: 0x%04x\n", 1587 (uint32_t)__SHIFTOUT(reg, PCI_SECURE_IOMMU_RANGE_LASTDEV)); 1588 1589 reg = regs[o2i(capoff + PCI_SECURE_IOMMU_MISC0)]; 1590 printf(" Miscellaneous Information Register 0: 0x%08x\n", reg); 1591 printf(" MSI Message number: 0x%02x\n", 1592 (uint32_t)__SHIFTOUT(reg, PCI_SECURE_IOMMU_MISC0_MSINUM)); 1593 val = __SHIFTOUT(reg, PCI_SECURE_IOMMU_MISC0_GVASIZE); 1594 printf(" Guest Virtual Address size: "); 1595 if (val == PCI_SECURE_IOMMU_MISC0_GVASIZE_48B) 1596 printf("48bits\n"); 1597 else 1598 printf("0x%x(unknown)\n", val); 1599 val = __SHIFTOUT(reg, PCI_SECURE_IOMMU_MISC0_PASIZE); 1600 printf(" Physical Address size: %dbits\n", val); 1601 val = __SHIFTOUT(reg, PCI_SECURE_IOMMU_MISC0_VASIZE); 1602 printf(" Virtual Address size: %dbits\n", val); 1603 onoff("ATS response address range reserved", reg, 1604 PCI_SECURE_IOMMU_MISC0_ATSRESV); 1605 printf(" Peripheral Page Request MSI Message number: 0x%02x\n", 1606 (uint32_t)__SHIFTOUT(reg, PCI_SECURE_IOMMU_MISC0_MISNPPR)); 1607 1608 if (!havemisc1) 1609 return; 1610 1611 reg = regs[o2i(capoff + PCI_SECURE_IOMMU_MISC1)]; 1612 printf(" Miscellaneous Information Register 1: 0x%08x\n", reg); 1613 printf(" MSI Message number (GA): 0x%02x\n", 1614 (uint32_t)__SHIFTOUT(reg, PCI_SECURE_IOMMU_MISC1_MSINUM)); 1615 } 1616 1617 static void 1618 pci_print_pcie_L0s_latency(uint32_t val) 1619 { 1620 1621 switch (val) { 1622 case 0x0: 1623 printf("Less than 64ns\n"); 1624 break; 1625 case 0x1: 1626 case 0x2: 1627 case 0x3: 1628 printf("%dns to less than %dns\n", 32 << val, 32 << (val + 1)); 1629 break; 1630 case 0x4: 1631 printf("512ns to less than 1us\n"); 1632 break; 1633 case 0x5: 1634 printf("1us to less than 2us\n"); 1635 break; 1636 case 0x6: 1637 printf("2us - 4us\n"); 1638 break; 1639 case 0x7: 1640 printf("More than 4us\n"); 1641 break; 1642 } 1643 } 1644 1645 static void 1646 pci_print_pcie_L1_latency(uint32_t val) 1647 { 1648 1649 switch (val) { 1650 case 0x0: 1651 printf("Less than 1us\n"); 1652 break; 1653 case 0x6: 1654 printf("32us - 64us\n"); 1655 break; 1656 case 0x7: 1657 printf("More than 64us\n"); 1658 break; 1659 default: 1660 printf("%dus to less than %dus\n", 1 << (val - 1), 1 << val); 1661 break; 1662 } 1663 } 1664 1665 static void 1666 pci_print_pcie_compl_timeout(uint32_t val) 1667 { 1668 1669 switch (val) { 1670 case 0x0: 1671 printf("50us to 50ms\n"); 1672 break; 1673 case 0x5: 1674 printf("16ms to 55ms\n"); 1675 break; 1676 case 0x6: 1677 printf("65ms to 210ms\n"); 1678 break; 1679 case 0x9: 1680 printf("260ms to 900ms\n"); 1681 break; 1682 case 0xa: 1683 printf("1s to 3.5s\n"); 1684 break; 1685 default: 1686 printf("unknown %u value\n", val); 1687 break; 1688 } 1689 } 1690 1691 static const char * const pcie_linkspeeds[] = {"2.5", "5.0", "8.0", "16.0"}; 1692 1693 /* 1694 * Print link speed. This function is used for the following register bits: 1695 * Maximum Link Speed in LCAP 1696 * Current Link Speed in LCSR 1697 * Target Link Speed in LCSR2 1698 * All of above bitfield's values start from 1. 1699 * For LCSR2, 0 is allowed for a device which supports 2.5GT/s only (and 1700 * this check also works for devices which compliant to versions of the base 1701 * specification prior to 3.0. 1702 */ 1703 static void 1704 pci_print_pcie_linkspeed(int regnum, pcireg_t val) 1705 { 1706 1707 if ((regnum == PCIE_LCSR2) && (val == 0)) 1708 printf("2.5GT/s\n"); 1709 else if ((val < 1) || (val > __arraycount(pcie_linkspeeds))) 1710 printf("unknown value (%u)\n", val); 1711 else 1712 printf("%sGT/s\n", pcie_linkspeeds[val - 1]); 1713 } 1714 1715 /* 1716 * Print link speed "vector". 1717 * This function is used for the following register bits: 1718 * Supported Link Speeds Vector in LCAP2 1719 * Lower SKP OS Generation Supported Speed Vector in LCAP2 1720 * Lower SKP OS Reception Supported Speed Vector in LCAP2 1721 * Enable Lower SKP OS Generation Vector in LCTL3 1722 * All of above bitfield's values start from 0. 1723 */ 1724 static void 1725 pci_print_pcie_linkspeedvector(pcireg_t val) 1726 { 1727 unsigned int i; 1728 1729 /* Start from 0 */ 1730 for (i = 0; i < 16; i++) 1731 if (((val >> i) & 0x01) != 0) { 1732 if (i >= __arraycount(pcie_linkspeeds)) 1733 printf(" unknown vector (0x%x)", 1 << i); 1734 else 1735 printf(" %sGT/s", pcie_linkspeeds[i]); 1736 } 1737 } 1738 1739 static void 1740 pci_print_pcie_link_deemphasis(pcireg_t val) 1741 { 1742 switch (val) { 1743 case 0: 1744 printf("-6dB"); 1745 break; 1746 case 1: 1747 printf("-3.5dB"); 1748 break; 1749 default: 1750 printf("(reserved value)"); 1751 } 1752 } 1753 1754 static void 1755 pci_conf_print_pcie_cap(const pcireg_t *regs, int capoff) 1756 { 1757 pcireg_t reg; /* for each register */ 1758 pcireg_t val; /* for each bitfield */ 1759 bool check_slot = false; 1760 unsigned int pcie_devtype; 1761 bool check_upstreamport = false; 1762 unsigned int pciever; 1763 unsigned int i; 1764 1765 printf("\n PCI Express Capabilities Register\n"); 1766 /* Capability Register */ 1767 reg = regs[o2i(capoff)]; 1768 printf(" Capability register: 0x%04x\n", reg >> 16); 1769 pciever = (unsigned int)(PCIE_XCAP_VER(reg)); 1770 printf(" Capability version: %u\n", pciever); 1771 printf(" Device type: "); 1772 pcie_devtype = PCIE_XCAP_TYPE(reg); 1773 switch (pcie_devtype) { 1774 case PCIE_XCAP_TYPE_PCIE_DEV: /* 0x0 */ 1775 printf("PCI Express Endpoint device\n"); 1776 check_upstreamport = true; 1777 break; 1778 case PCIE_XCAP_TYPE_PCI_DEV: /* 0x1 */ 1779 printf("Legacy PCI Express Endpoint device\n"); 1780 check_upstreamport = true; 1781 break; 1782 case PCIE_XCAP_TYPE_ROOT: /* 0x4 */ 1783 printf("Root Port of PCI Express Root Complex\n"); 1784 check_slot = true; 1785 break; 1786 case PCIE_XCAP_TYPE_UP: /* 0x5 */ 1787 printf("Upstream Port of PCI Express Switch\n"); 1788 check_upstreamport = true; 1789 break; 1790 case PCIE_XCAP_TYPE_DOWN: /* 0x6 */ 1791 printf("Downstream Port of PCI Express Switch\n"); 1792 check_slot = true; 1793 break; 1794 case PCIE_XCAP_TYPE_PCIE2PCI: /* 0x7 */ 1795 printf("PCI Express to PCI/PCI-X Bridge\n"); 1796 check_upstreamport = true; 1797 break; 1798 case PCIE_XCAP_TYPE_PCI2PCIE: /* 0x8 */ 1799 printf("PCI/PCI-X to PCI Express Bridge\n"); 1800 /* Upstream port is not PCIe */ 1801 check_slot = true; 1802 break; 1803 case PCIE_XCAP_TYPE_ROOT_INTEP: /* 0x9 */ 1804 printf("Root Complex Integrated Endpoint\n"); 1805 break; 1806 case PCIE_XCAP_TYPE_ROOT_EVNTC: /* 0xa */ 1807 printf("Root Complex Event Collector\n"); 1808 break; 1809 default: 1810 printf("unknown\n"); 1811 break; 1812 } 1813 onoff("Slot implemented", reg, PCIE_XCAP_SI); 1814 printf(" Interrupt Message Number: 0x%02x\n", 1815 (unsigned int)__SHIFTOUT(reg, PCIE_XCAP_IRQ)); 1816 1817 /* Device Capability Register */ 1818 reg = regs[o2i(capoff + PCIE_DCAP)]; 1819 printf(" Device Capabilities Register: 0x%08x\n", reg); 1820 printf(" Max Payload Size Supported: %u bytes max\n", 1821 128 << (unsigned int)(reg & PCIE_DCAP_MAX_PAYLOAD)); 1822 printf(" Phantom Functions Supported: "); 1823 switch (__SHIFTOUT(reg, PCIE_DCAP_PHANTOM_FUNCS)) { 1824 case 0x0: 1825 printf("not available\n"); 1826 break; 1827 case 0x1: 1828 printf("MSB\n"); 1829 break; 1830 case 0x2: 1831 printf("two MSB\n"); 1832 break; 1833 case 0x3: 1834 printf("All three bits\n"); 1835 break; 1836 } 1837 printf(" Extended Tag Field Supported: %dbit\n", 1838 (reg & PCIE_DCAP_EXT_TAG_FIELD) == 0 ? 5 : 8); 1839 printf(" Endpoint L0 Acceptable Latency: "); 1840 pci_print_pcie_L0s_latency(__SHIFTOUT(reg, PCIE_DCAP_L0S_LATENCY)); 1841 printf(" Endpoint L1 Acceptable Latency: "); 1842 pci_print_pcie_L1_latency(__SHIFTOUT(reg, PCIE_DCAP_L1_LATENCY)); 1843 onoff("Attention Button Present", reg, PCIE_DCAP_ATTN_BUTTON); 1844 onoff("Attention Indicator Present", reg, PCIE_DCAP_ATTN_IND); 1845 onoff("Power Indicator Present", reg, PCIE_DCAP_PWR_IND); 1846 onoff("Role-Based Error Report", reg, PCIE_DCAP_ROLE_ERR_RPT); 1847 if (check_upstreamport) { 1848 printf(" Captured Slot Power Limit: "); 1849 pci_conf_print_pcie_power( 1850 __SHIFTOUT(reg, PCIE_DCAP_SLOT_PWR_LIM_VAL), 1851 __SHIFTOUT(reg, PCIE_DCAP_SLOT_PWR_LIM_SCALE)); 1852 } 1853 onoff("Function-Level Reset Capability", reg, PCIE_DCAP_FLR); 1854 1855 /* Device Control Register */ 1856 reg = regs[o2i(capoff + PCIE_DCSR)]; 1857 printf(" Device Control Register: 0x%04x\n", reg & 0xffff); 1858 onoff("Correctable Error Reporting Enable", reg, 1859 PCIE_DCSR_ENA_COR_ERR); 1860 onoff("Non Fatal Error Reporting Enable", reg, PCIE_DCSR_ENA_NFER); 1861 onoff("Fatal Error Reporting Enable", reg, PCIE_DCSR_ENA_FER); 1862 onoff("Unsupported Request Reporting Enable", reg, PCIE_DCSR_ENA_URR); 1863 onoff("Enable Relaxed Ordering", reg, PCIE_DCSR_ENA_RELAX_ORD); 1864 printf(" Max Payload Size: %d byte\n", 1865 128 << __SHIFTOUT(reg, PCIE_DCSR_MAX_PAYLOAD)); 1866 onoff("Extended Tag Field Enable", reg, PCIE_DCSR_EXT_TAG_FIELD); 1867 onoff("Phantom Functions Enable", reg, PCIE_DCSR_PHANTOM_FUNCS); 1868 onoff("Aux Power PM Enable", reg, PCIE_DCSR_AUX_POWER_PM); 1869 onoff("Enable No Snoop", reg, PCIE_DCSR_ENA_NO_SNOOP); 1870 printf(" Max Read Request Size: %d byte\n", 1871 128 << __SHIFTOUT(reg, PCIE_DCSR_MAX_READ_REQ)); 1872 if (pcie_devtype == PCIE_XCAP_TYPE_PCIE2PCI) 1873 onoff("Bridge Config Retry Enable", reg, 1874 PCIE_DCSR_BRDG_CFG_RETRY); 1875 1876 /* Device Status Register */ 1877 reg = regs[o2i(capoff + PCIE_DCSR)]; 1878 printf(" Device Status Register: 0x%04x\n", reg >> 16); 1879 onoff("Correctable Error Detected", reg, PCIE_DCSR_CED); 1880 onoff("Non Fatal Error Detected", reg, PCIE_DCSR_NFED); 1881 onoff("Fatal Error Detected", reg, PCIE_DCSR_FED); 1882 onoff("Unsupported Request Detected", reg, PCIE_DCSR_URD); 1883 onoff("Aux Power Detected", reg, PCIE_DCSR_AUX_PWR); 1884 onoff("Transaction Pending", reg, PCIE_DCSR_TRANSACTION_PND); 1885 onoff("Emergency Power Reduction Detected", reg, PCIE_DCSR_EMGPWRREDD); 1886 1887 if (PCIE_HAS_LINKREGS(pcie_devtype)) { 1888 /* Link Capability Register */ 1889 reg = regs[o2i(capoff + PCIE_LCAP)]; 1890 printf(" Link Capabilities Register: 0x%08x\n", reg); 1891 printf(" Maximum Link Speed: "); 1892 pci_print_pcie_linkspeed(PCIE_LCAP, reg & PCIE_LCAP_MAX_SPEED); 1893 printf(" Maximum Link Width: x%u lanes\n", 1894 (unsigned int)__SHIFTOUT(reg, PCIE_LCAP_MAX_WIDTH)); 1895 printf(" Active State PM Support: "); 1896 switch (__SHIFTOUT(reg, PCIE_LCAP_ASPM)) { 1897 case 0x0: 1898 printf("No ASPM support\n"); 1899 break; 1900 case 0x1: 1901 printf("L0s supported\n"); 1902 break; 1903 case 0x2: 1904 printf("L1 supported\n"); 1905 break; 1906 case 0x3: 1907 printf("L0s and L1 supported\n"); 1908 break; 1909 } 1910 printf(" L0 Exit Latency: "); 1911 pci_print_pcie_L0s_latency(__SHIFTOUT(reg,PCIE_LCAP_L0S_EXIT)); 1912 printf(" L1 Exit Latency: "); 1913 pci_print_pcie_L1_latency(__SHIFTOUT(reg, PCIE_LCAP_L1_EXIT)); 1914 printf(" Port Number: %u\n", 1915 (unsigned int)__SHIFTOUT(reg, PCIE_LCAP_PORT)); 1916 onoff("Clock Power Management", reg, PCIE_LCAP_CLOCK_PM); 1917 onoff("Surprise Down Error Report", reg, 1918 PCIE_LCAP_SURPRISE_DOWN); 1919 onoff("Data Link Layer Link Active", reg, PCIE_LCAP_DL_ACTIVE); 1920 onoff("Link BW Notification Capable", reg, 1921 PCIE_LCAP_LINK_BW_NOTIFY); 1922 onoff("ASPM Optionally Compliance", reg, 1923 PCIE_LCAP_ASPM_COMPLIANCE); 1924 1925 /* Link Control Register */ 1926 reg = regs[o2i(capoff + PCIE_LCSR)]; 1927 printf(" Link Control Register: 0x%04x\n", reg & 0xffff); 1928 printf(" Active State PM Control: "); 1929 switch (reg & (PCIE_LCSR_ASPM_L1 | PCIE_LCSR_ASPM_L0S)) { 1930 case 0: 1931 printf("disabled\n"); 1932 break; 1933 case 1: 1934 printf("L0s Entry Enabled\n"); 1935 break; 1936 case 2: 1937 printf("L1 Entry Enabled\n"); 1938 break; 1939 case 3: 1940 printf("L0s and L1 Entry Enabled\n"); 1941 break; 1942 } 1943 onoff2("Read Completion Boundary Control", reg, PCIE_LCSR_RCB, 1944 "128bytes", "64bytes"); 1945 onoff("Link Disable", reg, PCIE_LCSR_LINK_DIS); 1946 onoff("Retrain Link", reg, PCIE_LCSR_RETRAIN); 1947 onoff("Common Clock Configuration", reg, PCIE_LCSR_COMCLKCFG); 1948 onoff("Extended Synch", reg, PCIE_LCSR_EXTNDSYNC); 1949 onoff("Enable Clock Power Management", reg, PCIE_LCSR_ENCLKPM); 1950 onoff("Hardware Autonomous Width Disable", reg,PCIE_LCSR_HAWD); 1951 onoff("Link Bandwidth Management Interrupt Enable", reg, 1952 PCIE_LCSR_LBMIE); 1953 onoff("Link Autonomous Bandwidth Interrupt Enable", reg, 1954 PCIE_LCSR_LABIE); 1955 printf(" DRS Signaling Control: "); 1956 switch (__SHIFTOUT(reg, PCIE_LCSR_DRSSGNL)) { 1957 case 0: 1958 printf("not reported\n"); 1959 break; 1960 case 1: 1961 printf("Interrupt Enabled\n"); 1962 break; 1963 case 2: 1964 printf("DRS to FRS Signaling Enabled\n"); 1965 break; 1966 default: 1967 printf("reserved\n"); 1968 break; 1969 } 1970 1971 /* Link Status Register */ 1972 reg = regs[o2i(capoff + PCIE_LCSR)]; 1973 printf(" Link Status Register: 0x%04x\n", reg >> 16); 1974 printf(" Negotiated Link Speed: "); 1975 pci_print_pcie_linkspeed(PCIE_LCSR, 1976 __SHIFTOUT(reg, PCIE_LCSR_LINKSPEED)); 1977 printf(" Negotiated Link Width: x%u lanes\n", 1978 (unsigned int)__SHIFTOUT(reg, PCIE_LCSR_NLW)); 1979 onoff("Training Error", reg, PCIE_LCSR_LINKTRAIN_ERR); 1980 onoff("Link Training", reg, PCIE_LCSR_LINKTRAIN); 1981 onoff("Slot Clock Configuration", reg, PCIE_LCSR_SLOTCLKCFG); 1982 onoff("Data Link Layer Link Active", reg, PCIE_LCSR_DLACTIVE); 1983 onoff("Link Bandwidth Management Status", reg, 1984 PCIE_LCSR_LINK_BW_MGMT); 1985 onoff("Link Autonomous Bandwidth Status", reg, 1986 PCIE_LCSR_LINK_AUTO_BW); 1987 } 1988 1989 if (check_slot == true) { 1990 pcireg_t slcap; 1991 1992 /* Slot Capability Register */ 1993 slcap = reg = regs[o2i(capoff + PCIE_SLCAP)]; 1994 printf(" Slot Capability Register: 0x%08x\n", reg); 1995 onoff("Attention Button Present", reg, PCIE_SLCAP_ABP); 1996 onoff("Power Controller Present", reg, PCIE_SLCAP_PCP); 1997 onoff("MRL Sensor Present", reg, PCIE_SLCAP_MSP); 1998 onoff("Attention Indicator Present", reg, PCIE_SLCAP_AIP); 1999 onoff("Power Indicator Present", reg, PCIE_SLCAP_PIP); 2000 onoff("Hot-Plug Surprise", reg, PCIE_SLCAP_HPS); 2001 onoff("Hot-Plug Capable", reg, PCIE_SLCAP_HPC); 2002 printf(" Slot Power Limit Value: "); 2003 pci_conf_print_pcie_power(__SHIFTOUT(reg, PCIE_SLCAP_SPLV), 2004 __SHIFTOUT(reg, PCIE_SLCAP_SPLS)); 2005 onoff("Electromechanical Interlock Present", reg, 2006 PCIE_SLCAP_EIP); 2007 onoff("No Command Completed Support", reg, PCIE_SLCAP_NCCS); 2008 printf(" Physical Slot Number: %d\n", 2009 (unsigned int)(reg & PCIE_SLCAP_PSN) >> 19); 2010 2011 /* Slot Control Register */ 2012 reg = regs[o2i(capoff + PCIE_SLCSR)]; 2013 printf(" Slot Control Register: 0x%04x\n", reg & 0xffff); 2014 onoff("Attention Button Pressed Enabled", reg, PCIE_SLCSR_ABE); 2015 onoff("Power Fault Detected Enabled", reg, PCIE_SLCSR_PFE); 2016 onoff("MRL Sensor Changed Enabled", reg, PCIE_SLCSR_MSE); 2017 onoff("Presence Detect Changed Enabled", reg, PCIE_SLCSR_PDE); 2018 onoff("Command Completed Interrupt Enabled", reg, 2019 PCIE_SLCSR_CCE); 2020 onoff("Hot-Plug Interrupt Enabled", reg, PCIE_SLCSR_HPE); 2021 /* 2022 * For Attention Indicator Control and Power Indicator Control, 2023 * it's allowed to be a read only value 0 if corresponding 2024 * capability register bit is 0. 2025 */ 2026 if (slcap & PCIE_SLCAP_AIP) { 2027 printf(" Attention Indicator Control: "); 2028 switch ((reg & PCIE_SLCSR_AIC) >> 6) { 2029 case 0x0: 2030 printf("reserved\n"); 2031 break; 2032 case PCIE_SLCSR_IND_ON: 2033 printf("on\n"); 2034 break; 2035 case PCIE_SLCSR_IND_BLINK: 2036 printf("blink\n"); 2037 break; 2038 case PCIE_SLCSR_IND_OFF: 2039 printf("off\n"); 2040 break; 2041 } 2042 } 2043 if (slcap & PCIE_SLCAP_PIP) { 2044 printf(" Power Indicator Control: "); 2045 switch ((reg & PCIE_SLCSR_PIC) >> 8) { 2046 case 0x0: 2047 printf("reserved\n"); 2048 break; 2049 case PCIE_SLCSR_IND_ON: 2050 printf("on\n"); 2051 break; 2052 case PCIE_SLCSR_IND_BLINK: 2053 printf("blink\n"); 2054 break; 2055 case PCIE_SLCSR_IND_OFF: 2056 printf("off\n"); 2057 break; 2058 } 2059 } 2060 printf(" Power Controller Control: Power %s\n", 2061 reg & PCIE_SLCSR_PCC ? "off" : "on"); 2062 onoff("Electromechanical Interlock Control", 2063 reg, PCIE_SLCSR_EIC); 2064 onoff("Data Link Layer State Changed Enable", reg, 2065 PCIE_SLCSR_DLLSCE); 2066 onoff("Auto Slot Power Limit Disable", reg, 2067 PCIE_SLCSR_AUTOSPLDIS); 2068 2069 /* Slot Status Register */ 2070 printf(" Slot Status Register: 0x%04x\n", reg >> 16); 2071 onoff("Attention Button Pressed", reg, PCIE_SLCSR_ABP); 2072 onoff("Power Fault Detected", reg, PCIE_SLCSR_PFD); 2073 onoff("MRL Sensor Changed", reg, PCIE_SLCSR_MSC); 2074 onoff("Presence Detect Changed", reg, PCIE_SLCSR_PDC); 2075 onoff("Command Completed", reg, PCIE_SLCSR_CC); 2076 onoff("MRL Open", reg, PCIE_SLCSR_MS); 2077 onoff("Card Present in slot", reg, PCIE_SLCSR_PDS); 2078 onoff("Electromechanical Interlock engaged", reg, 2079 PCIE_SLCSR_EIS); 2080 onoff("Data Link Layer State Changed", reg, PCIE_SLCSR_LACS); 2081 } 2082 2083 if (PCIE_HAS_ROOTREGS(pcie_devtype)) { 2084 /* Root Control Register */ 2085 reg = regs[o2i(capoff + PCIE_RCR)]; 2086 printf(" Root Control Register: 0x%04x\n", reg & 0xffff); 2087 onoff("SERR on Correctable Error Enable", reg, 2088 PCIE_RCR_SERR_CER); 2089 onoff("SERR on Non-Fatal Error Enable", reg, 2090 PCIE_RCR_SERR_NFER); 2091 onoff("SERR on Fatal Error Enable", reg, PCIE_RCR_SERR_FER); 2092 onoff("PME Interrupt Enable", reg, PCIE_RCR_PME_IE); 2093 onoff("CRS Software Visibility Enable", reg, PCIE_RCR_CRS_SVE); 2094 2095 /* Root Capability Register */ 2096 printf(" Root Capability Register: 0x%04x\n", 2097 reg >> 16); 2098 onoff("CRS Software Visibility", reg, PCIE_RCR_CRS_SV); 2099 2100 /* Root Status Register */ 2101 reg = regs[o2i(capoff + PCIE_RSR)]; 2102 printf(" Root Status Register: 0x%08x\n", reg); 2103 printf(" PME Requester ID: 0x%04x\n", 2104 (unsigned int)(reg & PCIE_RSR_PME_REQESTER)); 2105 onoff("PME was asserted", reg, PCIE_RSR_PME_STAT); 2106 onoff("another PME is pending", reg, PCIE_RSR_PME_PEND); 2107 } 2108 2109 /* PCIe DW9 to DW14 is for PCIe 2.0 and newer */ 2110 if (pciever < 2) 2111 return; 2112 2113 /* Device Capabilities 2 */ 2114 reg = regs[o2i(capoff + PCIE_DCAP2)]; 2115 printf(" Device Capabilities 2: 0x%08x\n", reg); 2116 printf(" Completion Timeout Ranges Supported: "); 2117 val = reg & PCIE_DCAP2_COMPT_RANGE; 2118 switch (val) { 2119 case 0: 2120 printf("not supported\n"); 2121 break; 2122 default: 2123 for (i = 0; i <= 3; i++) { 2124 if (((val >> i) & 0x01) != 0) 2125 printf("%c", 'A' + i); 2126 } 2127 printf("\n"); 2128 } 2129 onoff("Completion Timeout Disable Supported", reg, 2130 PCIE_DCAP2_COMPT_DIS); 2131 onoff("ARI Forwarding Supported", reg, PCIE_DCAP2_ARI_FWD); 2132 onoff("AtomicOp Routing Supported", reg, PCIE_DCAP2_ATOM_ROUT); 2133 onoff("32bit AtomicOp Completer Supported", reg, PCIE_DCAP2_32ATOM); 2134 onoff("64bit AtomicOp Completer Supported", reg, PCIE_DCAP2_64ATOM); 2135 onoff("128-bit CAS Completer Supported", reg, PCIE_DCAP2_128CAS); 2136 onoff("No RO-enabled PR-PR passing", reg, PCIE_DCAP2_NO_ROPR_PASS); 2137 onoff("LTR Mechanism Supported", reg, PCIE_DCAP2_LTR_MEC); 2138 printf(" TPH Completer Supported: "); 2139 switch (__SHIFTOUT(reg, PCIE_DCAP2_TPH_COMP)) { 2140 case 0: 2141 printf("Not supported\n"); 2142 break; 2143 case 1: 2144 printf("TPH\n"); 2145 break; 2146 case 3: 2147 printf("TPH and Extended TPH\n"); 2148 break; 2149 default: 2150 printf("(reserved value)\n"); 2151 break; 2152 } 2153 printf(" LN System CLS: "); 2154 switch (__SHIFTOUT(reg, PCIE_DCAP2_LNSYSCLS)) { 2155 case 0x0: 2156 printf("Not supported or not in effect\n"); 2157 break; 2158 case 0x1: 2159 printf("64byte cachelines in effect\n"); 2160 break; 2161 case 0x2: 2162 printf("128byte cachelines in effect\n"); 2163 break; 2164 case 0x3: 2165 printf("Reserved\n"); 2166 break; 2167 } 2168 onoff("10-bit Tag Completer Supported", reg, PCIE_DCAP2_TBT_COMP); 2169 onoff("10-bit Tag Requester Supported", reg, PCIE_DCAP2_TBT_REQ); 2170 printf(" OBFF Supported: "); 2171 switch (__SHIFTOUT(reg, PCIE_DCAP2_OBFF)) { 2172 case 0x0: 2173 printf("Not supported\n"); 2174 break; 2175 case 0x1: 2176 printf("Message only\n"); 2177 break; 2178 case 0x2: 2179 printf("WAKE# only\n"); 2180 break; 2181 case 0x3: 2182 printf("Both\n"); 2183 break; 2184 } 2185 onoff("Extended Fmt Field Supported", reg, PCIE_DCAP2_EXTFMT_FLD); 2186 onoff("End-End TLP Prefix Supported", reg, PCIE_DCAP2_EETLP_PREF); 2187 val = __SHIFTOUT(reg, PCIE_DCAP2_MAX_EETLP); 2188 printf(" Max End-End TLP Prefixes: %u\n", (val == 0) ? 4 : val); 2189 printf(" Emergency Power Reduction Supported: "); 2190 switch (__SHIFTOUT(reg, PCIE_DCAP2_EMGPWRRED)) { 2191 case 0x0: 2192 printf("Not supported\n"); 2193 break; 2194 case 0x1: 2195 printf("Device Specific mechanism\n"); 2196 break; 2197 case 0x2: 2198 printf("Form Factor spec or Device Specific mechanism\n"); 2199 break; 2200 case 0x3: 2201 printf("Reserved\n"); 2202 break; 2203 } 2204 onoff("Emergency Power Reduction Initialization Required", reg, 2205 PCIE_DCAP2_EMGPWRRED_INI); 2206 onoff("FRS Supported", reg, PCIE_DCAP2_FRS); 2207 2208 /* Device Control 2 */ 2209 reg = regs[o2i(capoff + PCIE_DCSR2)]; 2210 printf(" Device Control 2: 0x%04x\n", reg & 0xffff); 2211 printf(" Completion Timeout Value: "); 2212 pci_print_pcie_compl_timeout(reg & PCIE_DCSR2_COMPT_VAL); 2213 onoff("Completion Timeout Disabled", reg, PCIE_DCSR2_COMPT_DIS); 2214 onoff("ARI Forwarding Enabled", reg, PCIE_DCSR2_ARI_FWD); 2215 onoff("AtomicOp Requester Enabled", reg, PCIE_DCSR2_ATOM_REQ); 2216 onoff("AtomicOp Egress Blocking", reg, PCIE_DCSR2_ATOM_EBLK); 2217 onoff("IDO Request Enabled", reg, PCIE_DCSR2_IDO_REQ); 2218 onoff("IDO Completion Enabled", reg, PCIE_DCSR2_IDO_COMP); 2219 onoff("LTR Mechanism Enabled", reg, PCIE_DCSR2_LTR_MEC); 2220 onoff("Emergency Power Reduction Request", reg, 2221 PCIE_DCSR2_EMGPWRRED_REQ); 2222 onoff("10-bit Tag Requester Enabled", reg, PCIE_DCSR2_TBT_REQ); 2223 printf(" OBFF: "); 2224 switch (__SHIFTOUT(reg, PCIE_DCSR2_OBFF_EN)) { 2225 case 0x0: 2226 printf("Disabled\n"); 2227 break; 2228 case 0x1: 2229 printf("Enabled with Message Signaling Variation A\n"); 2230 break; 2231 case 0x2: 2232 printf("Enabled with Message Signaling Variation B\n"); 2233 break; 2234 case 0x3: 2235 printf("Enabled using WAKE# signaling\n"); 2236 break; 2237 } 2238 onoff("End-End TLP Prefix Blocking on", reg, PCIE_DCSR2_EETLP); 2239 2240 if (PCIE_HAS_LINKREGS(pcie_devtype)) { 2241 bool drs_supported = false; 2242 2243 /* Link Capability 2 */ 2244 reg = regs[o2i(capoff + PCIE_LCAP2)]; 2245 /* If the vector is 0, LCAP2 is not implemented */ 2246 if ((reg & PCIE_LCAP2_SUP_LNKSV) != 0) { 2247 printf(" Link Capabilities 2: 0x%08x\n", reg); 2248 printf(" Supported Link Speeds Vector:"); 2249 pci_print_pcie_linkspeedvector( 2250 __SHIFTOUT(reg, PCIE_LCAP2_SUP_LNKSV)); 2251 printf("\n"); 2252 onoff("Crosslink Supported", reg, PCIE_LCAP2_CROSSLNK); 2253 printf(" " 2254 "Lower SKP OS Generation Supported Speed Vector:"); 2255 pci_print_pcie_linkspeedvector( 2256 __SHIFTOUT(reg, PCIE_LCAP2_LOWSKPOS_GENSUPPSV)); 2257 printf("\n"); 2258 printf(" " 2259 "Lower SKP OS Reception Supported Speed Vector:"); 2260 pci_print_pcie_linkspeedvector( 2261 __SHIFTOUT(reg, PCIE_LCAP2_LOWSKPOS_RECSUPPSV)); 2262 printf("\n"); 2263 onoff("Retimer Presence Detect Supported", reg, 2264 PCIE_LCAP2_RETIMERPD); 2265 onoff("DRS Supported", reg, PCIE_LCAP2_DRS); 2266 drs_supported = (reg & PCIE_LCAP2_DRS) ? true : false; 2267 } 2268 2269 /* Link Control 2 */ 2270 reg = regs[o2i(capoff + PCIE_LCSR2)]; 2271 /* If the vector is 0, LCAP2 is not implemented */ 2272 printf(" Link Control 2: 0x%04x\n", reg & 0xffff); 2273 printf(" Target Link Speed: "); 2274 pci_print_pcie_linkspeed(PCIE_LCSR2, 2275 __SHIFTOUT(reg, PCIE_LCSR2_TGT_LSPEED)); 2276 onoff("Enter Compliance Enabled", reg, PCIE_LCSR2_ENT_COMPL); 2277 onoff("HW Autonomous Speed Disabled", reg, 2278 PCIE_LCSR2_HW_AS_DIS); 2279 printf(" Selectable De-emphasis: "); 2280 pci_print_pcie_link_deemphasis( 2281 __SHIFTOUT(reg, PCIE_LCSR2_SEL_DEEMP)); 2282 printf("\n"); 2283 printf(" Transmit Margin: %u\n", 2284 (unsigned int)__SHIFTOUT(reg, PCIE_LCSR2_TX_MARGIN)); 2285 onoff("Enter Modified Compliance", reg, PCIE_LCSR2_EN_MCOMP); 2286 onoff("Compliance SOS", reg, PCIE_LCSR2_COMP_SOS); 2287 printf(" Compliance Present/De-emphasis: "); 2288 pci_print_pcie_link_deemphasis( 2289 __SHIFTOUT(reg, PCIE_LCSR2_COMP_DEEMP)); 2290 printf("\n"); 2291 2292 /* Link Status 2 */ 2293 printf(" Link Status 2: 0x%04x\n", (reg >> 16) & 0xffff); 2294 printf(" Current De-emphasis Level: "); 2295 pci_print_pcie_link_deemphasis( 2296 __SHIFTOUT(reg, PCIE_LCSR2_DEEMP_LVL)); 2297 printf("\n"); 2298 onoff("Equalization Complete", reg, PCIE_LCSR2_EQ_COMPL); 2299 onoff("Equalization Phase 1 Successful", reg, 2300 PCIE_LCSR2_EQP1_SUC); 2301 onoff("Equalization Phase 2 Successful", reg, 2302 PCIE_LCSR2_EQP2_SUC); 2303 onoff("Equalization Phase 3 Successful", reg, 2304 PCIE_LCSR2_EQP3_SUC); 2305 onoff("Link Equalization Request", reg, PCIE_LCSR2_LNKEQ_REQ); 2306 onoff("Retimer Presence Detected", reg, PCIE_LCSR2_RETIMERPD); 2307 if (drs_supported) { 2308 printf(" Downstream Component Presence: "); 2309 switch (__SHIFTOUT(reg, PCIE_LCSR2_DSCOMPN)) { 2310 case PCIE_DSCOMPN_DOWN_NOTDETERM: 2311 printf("Link Down - Presence Not" 2312 " Determined\n"); 2313 break; 2314 case PCIE_DSCOMPN_DOWN_NOTPRES: 2315 printf("Link Down - Component Not Present\n"); 2316 break; 2317 case PCIE_DSCOMPN_DOWN_PRES: 2318 printf("Link Down - Component Present\n"); 2319 break; 2320 case PCIE_DSCOMPN_UP_PRES: 2321 printf("Link Up - Component Present\n"); 2322 break; 2323 case PCIE_DSCOMPN_UP_PRES_DRS: 2324 printf("Link Up - Component Present and DRS" 2325 " received\n"); 2326 break; 2327 default: 2328 printf("reserved\n"); 2329 break; 2330 } 2331 onoff("DRS Message Received", reg, PCIE_LCSR2_DRSRCV); 2332 } 2333 } 2334 2335 /* Slot Capability 2 */ 2336 /* Slot Control 2 */ 2337 /* Slot Status 2 */ 2338 } 2339 2340 static void 2341 pci_conf_print_msix_cap(const pcireg_t *regs, int capoff) 2342 { 2343 pcireg_t reg; 2344 2345 printf("\n MSI-X Capability Register\n"); 2346 2347 reg = regs[o2i(capoff + PCI_MSIX_CTL)]; 2348 printf(" Message Control register: 0x%04x\n", 2349 (reg >> 16) & 0xff); 2350 printf(" Table Size: %d\n", PCI_MSIX_CTL_TBLSIZE(reg)); 2351 onoff("Function Mask", reg, PCI_MSIX_CTL_FUNCMASK); 2352 onoff("MSI-X Enable", reg, PCI_MSIX_CTL_ENABLE); 2353 reg = regs[o2i(capoff + PCI_MSIX_TBLOFFSET)]; 2354 printf(" Table offset register: 0x%08x\n", reg); 2355 printf(" Table offset: 0x%08x\n", 2356 (pcireg_t)(reg & PCI_MSIX_TBLOFFSET_MASK)); 2357 printf(" BIR: 0x%x\n", (pcireg_t)(reg & PCI_MSIX_TBLBIR_MASK)); 2358 reg = regs[o2i(capoff + PCI_MSIX_PBAOFFSET)]; 2359 printf(" Pending bit array register: 0x%08x\n", reg); 2360 printf(" Pending bit array offset: 0x%08x\n", 2361 (pcireg_t)(reg & PCI_MSIX_PBAOFFSET_MASK)); 2362 printf(" BIR: 0x%x\n", (pcireg_t)(reg & PCI_MSIX_PBABIR_MASK)); 2363 } 2364 2365 static void 2366 pci_conf_print_sata_cap(const pcireg_t *regs, int capoff) 2367 { 2368 pcireg_t reg; 2369 2370 printf("\n Serial ATA Capability Register\n"); 2371 2372 reg = regs[o2i(capoff + PCI_SATA_REV)]; 2373 printf(" Revision register: 0x%04x\n", (reg >> 16) & 0xff); 2374 printf(" Revision: %u.%u\n", 2375 (unsigned int)__SHIFTOUT(reg, PCI_SATA_REV_MAJOR), 2376 (unsigned int)__SHIFTOUT(reg, PCI_SATA_REV_MINOR)); 2377 2378 reg = regs[o2i(capoff + PCI_SATA_BAR)]; 2379 2380 printf(" BAR Register: 0x%08x\n", reg); 2381 printf(" Register location: "); 2382 if ((reg & PCI_SATA_BAR_SPEC) == PCI_SATA_BAR_INCONF) 2383 printf("in config space\n"); 2384 else { 2385 printf("BAR %d\n", (int)PCI_SATA_BAR_NUM(reg)); 2386 printf(" BAR offset: 0x%08x\n", 2387 (pcireg_t)__SHIFTOUT(reg, PCI_SATA_BAR_OFFSET) * 4); 2388 } 2389 } 2390 2391 static void 2392 pci_conf_print_pciaf_cap(const pcireg_t *regs, int capoff) 2393 { 2394 pcireg_t reg; 2395 2396 printf("\n Advanced Features Capability Register\n"); 2397 2398 reg = regs[o2i(capoff + PCI_AFCAPR)]; 2399 printf(" AF Capabilities register: 0x%02x\n", (reg >> 24) & 0xff); 2400 printf(" AF Structure Length: 0x%02x\n", 2401 (pcireg_t)__SHIFTOUT(reg, PCI_AF_LENGTH)); 2402 onoff("Transaction Pending", reg, PCI_AF_TP_CAP); 2403 onoff("Function Level Reset", reg, PCI_AF_FLR_CAP); 2404 reg = regs[o2i(capoff + PCI_AFCSR)]; 2405 printf(" AF Control register: 0x%02x\n", reg & 0xff); 2406 /* 2407 * Only PCI_AFCR_INITIATE_FLR is a member of the AF control register 2408 * and it's always 0 on read 2409 */ 2410 printf(" AF Status register: 0x%02x\n", (reg >> 8) & 0xff); 2411 onoff("Transaction Pending", reg, PCI_AFSR_TP); 2412 } 2413 2414 static void 2415 pci_conf_print_ea_cap_prop(unsigned int prop) 2416 { 2417 2418 switch (prop) { 2419 case PCI_EA_PROP_MEM_NONPREF: 2420 printf("Memory Space, Non-Prefetchable\n"); 2421 break; 2422 case PCI_EA_PROP_MEM_PREF: 2423 printf("Memory Space, Prefetchable\n"); 2424 break; 2425 case PCI_EA_PROP_IO: 2426 printf("I/O Space\n"); 2427 break; 2428 case PCI_EA_PROP_VF_MEM_NONPREF: 2429 printf("Resorce for VF use, Memory Space, Non-Prefetchable\n"); 2430 break; 2431 case PCI_EA_PROP_VF_MEM_PREF: 2432 printf("Resorce for VF use, Memory Space, Prefetch\n"); 2433 break; 2434 case PCI_EA_PROP_BB_MEM_NONPREF: 2435 printf("Behind the Bridge, Memory Space, Non-Pref\n"); 2436 break; 2437 case PCI_EA_PROP_BB_MEM_PREF: 2438 printf("Behind the Bridge, Memory Space. Prefetchable\n"); 2439 break; 2440 case PCI_EA_PROP_BB_IO: 2441 printf("Behind Bridge, I/O Space\n"); 2442 break; 2443 case PCI_EA_PROP_MEM_UNAVAIL: 2444 printf("Memory Space Unavailable\n"); 2445 break; 2446 case PCI_EA_PROP_IO_UNAVAIL: 2447 printf("IO Space Unavailable\n"); 2448 break; 2449 case PCI_EA_PROP_UNAVAIL: 2450 printf("Entry Unavailable for use\n"); 2451 break; 2452 default: 2453 printf("Reserved\n"); 2454 break; 2455 } 2456 } 2457 2458 static void 2459 pci_conf_print_ea_cap(const pcireg_t *regs, int capoff) 2460 { 2461 pcireg_t reg, reg2; 2462 unsigned int entries, entoff, i; 2463 2464 printf("\n Enhanced Allocation Capability Register\n"); 2465 2466 reg = regs[o2i(capoff + PCI_EA_CAP1)]; 2467 printf(" EA Num Entries register: 0x%04x\n", reg >> 16); 2468 entries = __SHIFTOUT(reg, PCI_EA_CAP1_NUMENTRIES); 2469 printf(" EA Num Entries: %u\n", entries); 2470 2471 /* Type 1 only */ 2472 if (PCI_HDRTYPE_TYPE(regs[o2i(PCI_BHLC_REG)]) == PCI_HDRTYPE_PPB) { 2473 reg = regs[o2i(capoff + PCI_EA_CAP2)]; 2474 printf(" EA Capability Second register: 0x%08x\n", reg); 2475 printf(" Fixed Secondary Bus Number: %hhu\n", 2476 (unsigned char)__SHIFTOUT(reg, PCI_EA_CAP2_SECONDARY)); 2477 printf(" Fixed Subordinate Bus Number: %hhu\n", 2478 (unsigned char)__SHIFTOUT(reg, PCI_EA_CAP2_SUBORDINATE)); 2479 entoff = capoff + 8; 2480 } else 2481 entoff = capoff + 4; 2482 2483 for (i = 0; i < entries; i++) { 2484 uint64_t base, offset; 2485 bool baseis64, offsetis64; 2486 unsigned int bei, entry_size; 2487 2488 printf(" Entry %u:\n", i); 2489 /* The first DW */ 2490 reg = regs[o2i(entoff)]; 2491 printf(" The first register: 0x%08x\n", reg); 2492 entry_size = __SHIFTOUT(reg, PCI_EA_ES); 2493 printf(" Entry size: %u\n", entry_size); 2494 printf(" BAR Equivalent Indicator: "); 2495 bei = __SHIFTOUT(reg, PCI_EA_BEI); 2496 switch (bei) { 2497 case PCI_EA_BEI_BAR0: 2498 case PCI_EA_BEI_BAR1: 2499 case PCI_EA_BEI_BAR2: 2500 case PCI_EA_BEI_BAR3: 2501 case PCI_EA_BEI_BAR4: 2502 case PCI_EA_BEI_BAR5: 2503 printf("BAR %u\n", bei - PCI_EA_BEI_BAR0); 2504 break; 2505 case PCI_EA_BEI_BEHIND: 2506 printf("Behind the function\n"); 2507 break; 2508 case PCI_EA_BEI_NOTIND: 2509 printf("Not Indicated\n"); 2510 break; 2511 case PCI_EA_BEI_EXPROM: 2512 printf("Expansion ROM\n"); 2513 break; 2514 case PCI_EA_BEI_VFBAR0: 2515 case PCI_EA_BEI_VFBAR1: 2516 case PCI_EA_BEI_VFBAR2: 2517 case PCI_EA_BEI_VFBAR3: 2518 case PCI_EA_BEI_VFBAR4: 2519 case PCI_EA_BEI_VFBAR5: 2520 printf("VF BAR %u\n", bei - PCI_EA_BEI_VFBAR0); 2521 break; 2522 case PCI_EA_BEI_RESERVED: 2523 default: 2524 printf("Reserved\n"); 2525 break; 2526 } 2527 2528 printf(" Primary Properties: "); 2529 pci_conf_print_ea_cap_prop(__SHIFTOUT(reg, PCI_EA_PP)); 2530 printf(" Secondary Properties: "); 2531 pci_conf_print_ea_cap_prop(__SHIFTOUT(reg, PCI_EA_SP)); 2532 onoff("Writable", reg, PCI_EA_W); 2533 onoff("Enable for this entry", reg, PCI_EA_E); 2534 2535 if (entry_size == 0) { 2536 entoff += 4; 2537 continue; 2538 } 2539 2540 /* Base addr */ 2541 reg = regs[o2i(entoff + 4)]; 2542 base = reg & PCI_EA_LOWMASK; 2543 baseis64 = reg & PCI_EA_BASEMAXOFFSET_64BIT; 2544 printf(" Base Address Register Low: 0x%08x\n", reg); 2545 if (baseis64) { 2546 /* 64bit */ 2547 reg2 = regs[o2i(entoff + 12)]; 2548 printf(" Base Address Register high: 0x%08x\n", 2549 reg2); 2550 base |= (uint64_t)reg2 << 32; 2551 } 2552 2553 /* Offset addr */ 2554 reg = regs[o2i(entoff + 8)]; 2555 offset = reg & PCI_EA_LOWMASK; 2556 offsetis64 = reg & PCI_EA_BASEMAXOFFSET_64BIT; 2557 printf(" Max Offset Register Low: 0x%08x\n", reg); 2558 if (offsetis64) { 2559 /* 64bit */ 2560 reg2 = regs[o2i(entoff + (baseis64 ? 16 : 12))]; 2561 printf(" Max Offset Register high: 0x%08x\n", 2562 reg2); 2563 offset |= (uint64_t)reg2 << 32; 2564 } 2565 2566 printf(" range: 0x%016" PRIx64 "-0x%016" PRIx64 2567 "\n", base, base + offset); 2568 2569 entoff += 4 + (4 * entry_size); 2570 } 2571 } 2572 2573 /* XXX pci_conf_print_fpb_cap */ 2574 2575 static struct { 2576 pcireg_t cap; 2577 const char *name; 2578 void (*printfunc)(const pcireg_t *, int); 2579 } pci_captab[] = { 2580 { PCI_CAP_RESERVED0, "reserved", NULL }, 2581 { PCI_CAP_PWRMGMT, "Power Management", pci_conf_print_pcipm_cap }, 2582 { PCI_CAP_AGP, "AGP", pci_conf_print_agp_cap }, 2583 { PCI_CAP_VPD, "VPD", NULL }, 2584 { PCI_CAP_SLOTID, "SlotID", NULL }, 2585 { PCI_CAP_MSI, "MSI", pci_conf_print_msi_cap }, 2586 { PCI_CAP_CPCI_HOTSWAP, "CompactPCI Hot-swapping", NULL }, 2587 { PCI_CAP_PCIX, "PCI-X", pci_conf_print_pcix_cap }, 2588 { PCI_CAP_LDT, "HyperTransport", pci_conf_print_ht_cap }, 2589 { PCI_CAP_VENDSPEC, "Vendor-specific", 2590 pci_conf_print_vendspec_cap }, 2591 { PCI_CAP_DEBUGPORT, "Debug Port", pci_conf_print_debugport_cap }, 2592 { PCI_CAP_CPCI_RSRCCTL, "CompactPCI Resource Control", NULL }, 2593 { PCI_CAP_HOTPLUG, "Hot-Plug", NULL }, 2594 { PCI_CAP_SUBVENDOR, "Subsystem vendor ID", 2595 pci_conf_print_subsystem_cap }, 2596 { PCI_CAP_AGP8, "AGP 8x", NULL }, 2597 { PCI_CAP_SECURE, "Secure Device", pci_conf_print_secure_cap }, 2598 { PCI_CAP_PCIEXPRESS, "PCI Express", pci_conf_print_pcie_cap }, 2599 { PCI_CAP_MSIX, "MSI-X", pci_conf_print_msix_cap }, 2600 { PCI_CAP_SATA, "SATA", pci_conf_print_sata_cap }, 2601 { PCI_CAP_PCIAF, "Advanced Features", pci_conf_print_pciaf_cap}, 2602 { PCI_CAP_EA, "Enhanced Allocation", pci_conf_print_ea_cap }, 2603 { PCI_CAP_FPB, "Flattening Portal Bridge", NULL } 2604 }; 2605 2606 static int 2607 pci_conf_find_cap(const pcireg_t *regs, unsigned int capid, int *offsetp) 2608 { 2609 pcireg_t rval; 2610 unsigned int capptr; 2611 int off; 2612 2613 if (!(regs[o2i(PCI_COMMAND_STATUS_REG)] & PCI_STATUS_CAPLIST_SUPPORT)) 2614 return 0; 2615 2616 /* Determine the Capability List Pointer register to start with. */ 2617 switch (PCI_HDRTYPE_TYPE(regs[o2i(PCI_BHLC_REG)])) { 2618 case 0: /* standard device header */ 2619 case 1: /* PCI-PCI bridge header */ 2620 capptr = PCI_CAPLISTPTR_REG; 2621 break; 2622 case 2: /* PCI-CardBus Bridge header */ 2623 capptr = PCI_CARDBUS_CAPLISTPTR_REG; 2624 break; 2625 default: 2626 return 0; 2627 } 2628 2629 for (off = PCI_CAPLIST_PTR(regs[o2i(capptr)]); 2630 off != 0; off = PCI_CAPLIST_NEXT(rval)) { 2631 rval = regs[o2i(off)]; 2632 if (capid == PCI_CAPLIST_CAP(rval)) { 2633 if (offsetp != NULL) 2634 *offsetp = off; 2635 return 1; 2636 } 2637 } 2638 return 0; 2639 } 2640 2641 static void 2642 pci_conf_print_caplist( 2643 #ifdef _KERNEL 2644 pci_chipset_tag_t pc, pcitag_t tag, 2645 #endif 2646 const pcireg_t *regs, int capoff) 2647 { 2648 int off; 2649 pcireg_t foundcap; 2650 pcireg_t rval; 2651 bool foundtable[__arraycount(pci_captab)]; 2652 unsigned int i; 2653 2654 /* Clear table */ 2655 for (i = 0; i < __arraycount(pci_captab); i++) 2656 foundtable[i] = false; 2657 2658 /* Print capability register's offset and the type first */ 2659 for (off = PCI_CAPLIST_PTR(regs[o2i(capoff)]); 2660 off != 0; off = PCI_CAPLIST_NEXT(regs[o2i(off)])) { 2661 rval = regs[o2i(off)]; 2662 printf(" Capability register at 0x%02x\n", off); 2663 2664 printf(" type: 0x%02x (", PCI_CAPLIST_CAP(rval)); 2665 foundcap = PCI_CAPLIST_CAP(rval); 2666 if (foundcap < __arraycount(pci_captab)) { 2667 printf("%s)\n", pci_captab[foundcap].name); 2668 /* Mark as found */ 2669 foundtable[foundcap] = true; 2670 } else 2671 printf("unknown)\n"); 2672 } 2673 2674 /* 2675 * And then, print the detail of each capability registers 2676 * in capability value's order. 2677 */ 2678 for (i = 0; i < __arraycount(pci_captab); i++) { 2679 if (foundtable[i] == false) 2680 continue; 2681 2682 /* 2683 * The type was found. Search capability list again and 2684 * print all capabilities that the capabiliy type is 2685 * the same. This is required because some capabilities 2686 * appear multiple times (e.g. HyperTransport capability). 2687 */ 2688 for (off = PCI_CAPLIST_PTR(regs[o2i(capoff)]); 2689 off != 0; off = PCI_CAPLIST_NEXT(regs[o2i(off)])) { 2690 rval = regs[o2i(off)]; 2691 if ((PCI_CAPLIST_CAP(rval) == i) 2692 && (pci_captab[i].printfunc != NULL)) 2693 pci_captab[i].printfunc(regs, off); 2694 } 2695 } 2696 } 2697 2698 /* Extended Capability */ 2699 2700 static void 2701 pci_conf_print_aer_cap_uc(pcireg_t reg) 2702 { 2703 2704 onoff("Undefined", reg, PCI_AER_UC_UNDEFINED); 2705 onoff("Data Link Protocol Error", reg, PCI_AER_UC_DL_PROTOCOL_ERROR); 2706 onoff("Surprise Down Error", reg, PCI_AER_UC_SURPRISE_DOWN_ERROR); 2707 onoff("Poisoned TLP Received", reg, PCI_AER_UC_POISONED_TLP); 2708 onoff("Flow Control Protocol Error", reg, PCI_AER_UC_FC_PROTOCOL_ERROR); 2709 onoff("Completion Timeout", reg, PCI_AER_UC_COMPLETION_TIMEOUT); 2710 onoff("Completer Abort", reg, PCI_AER_UC_COMPLETER_ABORT); 2711 onoff("Unexpected Completion", reg, PCI_AER_UC_UNEXPECTED_COMPLETION); 2712 onoff("Receiver Overflow", reg, PCI_AER_UC_RECEIVER_OVERFLOW); 2713 onoff("Malformed TLP", reg, PCI_AER_UC_MALFORMED_TLP); 2714 onoff("ECRC Error", reg, PCI_AER_UC_ECRC_ERROR); 2715 onoff("Unsupported Request Error", reg, 2716 PCI_AER_UC_UNSUPPORTED_REQUEST_ERROR); 2717 onoff("ACS Violation", reg, PCI_AER_UC_ACS_VIOLATION); 2718 onoff("Uncorrectable Internal Error", reg, PCI_AER_UC_INTERNAL_ERROR); 2719 onoff("MC Blocked TLP", reg, PCI_AER_UC_MC_BLOCKED_TLP); 2720 onoff("AtomicOp Egress BLK", reg, PCI_AER_UC_ATOMIC_OP_EGRESS_BLOCKED); 2721 onoff("TLP Prefix Blocked Error", reg, 2722 PCI_AER_UC_TLP_PREFIX_BLOCKED_ERROR); 2723 onoff("Poisoned TLP Egress Blocked", reg, 2724 PCI_AER_UC_POISONTLP_EGRESS_BLOCKED); 2725 } 2726 2727 static void 2728 pci_conf_print_aer_cap_cor(pcireg_t reg) 2729 { 2730 2731 onoff("Receiver Error", reg, PCI_AER_COR_RECEIVER_ERROR); 2732 onoff("Bad TLP", reg, PCI_AER_COR_BAD_TLP); 2733 onoff("Bad DLLP", reg, PCI_AER_COR_BAD_DLLP); 2734 onoff("REPLAY_NUM Rollover", reg, PCI_AER_COR_REPLAY_NUM_ROLLOVER); 2735 onoff("Replay Timer Timeout", reg, PCI_AER_COR_REPLAY_TIMER_TIMEOUT); 2736 onoff("Advisory Non-Fatal Error", reg, PCI_AER_COR_ADVISORY_NF_ERROR); 2737 onoff("Corrected Internal Error", reg, PCI_AER_COR_INTERNAL_ERROR); 2738 onoff("Header Log Overflow", reg, PCI_AER_COR_HEADER_LOG_OVERFLOW); 2739 } 2740 2741 static void 2742 pci_conf_print_aer_cap_control(pcireg_t reg, bool *tlp_prefix_log) 2743 { 2744 2745 printf(" First Error Pointer: 0x%04x\n", 2746 (pcireg_t)__SHIFTOUT(reg, PCI_AER_FIRST_ERROR_PTR)); 2747 onoff("ECRC Generation Capable", reg, PCI_AER_ECRC_GEN_CAPABLE); 2748 onoff("ECRC Generation Enable", reg, PCI_AER_ECRC_GEN_ENABLE); 2749 onoff("ECRC Check Capable", reg, PCI_AER_ECRC_CHECK_CAPABLE); 2750 onoff("ECRC Check Enable", reg, PCI_AER_ECRC_CHECK_ENABLE); 2751 onoff("Multiple Header Recording Capable", reg, 2752 PCI_AER_MULT_HDR_CAPABLE); 2753 onoff("Multiple Header Recording Enable", reg,PCI_AER_MULT_HDR_ENABLE); 2754 onoff("Completion Timeout Prefix/Header Log Capable", reg, 2755 PCI_AER_COMPTOUTPRFXHDRLOG_CAP); 2756 2757 /* This bit is RsvdP if the End-End TLP Prefix Supported bit is Clear */ 2758 if (!tlp_prefix_log) 2759 return; 2760 onoff("TLP Prefix Log Present", reg, PCI_AER_TLP_PREFIX_LOG_PRESENT); 2761 *tlp_prefix_log = (reg & PCI_AER_TLP_PREFIX_LOG_PRESENT) ? true : false; 2762 } 2763 2764 static void 2765 pci_conf_print_aer_cap_rooterr_cmd(pcireg_t reg) 2766 { 2767 2768 onoff("Correctable Error Reporting Enable", reg, 2769 PCI_AER_ROOTERR_COR_ENABLE); 2770 onoff("Non-Fatal Error Reporting Enable", reg, 2771 PCI_AER_ROOTERR_NF_ENABLE); 2772 onoff("Fatal Error Reporting Enable", reg, PCI_AER_ROOTERR_F_ENABLE); 2773 } 2774 2775 static void 2776 pci_conf_print_aer_cap_rooterr_status(pcireg_t reg) 2777 { 2778 2779 onoff("ERR_COR Received", reg, PCI_AER_ROOTERR_COR_ERR); 2780 onoff("Multiple ERR_COR Received", reg, PCI_AER_ROOTERR_MULTI_COR_ERR); 2781 onoff("ERR_FATAL/NONFATAL_ERR Received", reg, PCI_AER_ROOTERR_UC_ERR); 2782 onoff("Multiple ERR_FATAL/NONFATAL_ERR Received", reg, 2783 PCI_AER_ROOTERR_MULTI_UC_ERR); 2784 onoff("First Uncorrectable Fatal", reg,PCI_AER_ROOTERR_FIRST_UC_FATAL); 2785 onoff("Non-Fatal Error Messages Received", reg,PCI_AER_ROOTERR_NF_ERR); 2786 onoff("Fatal Error Messages Received", reg, PCI_AER_ROOTERR_F_ERR); 2787 printf(" Advanced Error Interrupt Message Number: 0x%02x\n", 2788 (unsigned int)__SHIFTOUT(reg, PCI_AER_ROOTERR_INT_MESSAGE)); 2789 } 2790 2791 static void 2792 pci_conf_print_aer_cap_errsrc_id(pcireg_t reg) 2793 { 2794 2795 printf(" Correctable Source ID: 0x%04x\n", 2796 (pcireg_t)__SHIFTOUT(reg, PCI_AER_ERRSRC_ID_ERR_COR)); 2797 printf(" ERR_FATAL/NONFATAL Source ID: 0x%04x\n", 2798 (pcireg_t)__SHIFTOUT(reg, PCI_AER_ERRSRC_ID_ERR_UC)); 2799 } 2800 2801 static void 2802 pci_conf_print_aer_cap(const pcireg_t *regs, int extcapoff) 2803 { 2804 pcireg_t reg; 2805 int pcie_capoff; 2806 int pcie_devtype = -1; 2807 bool tlp_prefix_log = false; 2808 2809 if (pci_conf_find_cap(regs, PCI_CAP_PCIEXPRESS, &pcie_capoff)) { 2810 reg = regs[o2i(pcie_capoff)]; 2811 pcie_devtype = PCIE_XCAP_TYPE(reg); 2812 /* PCIe DW9 to DW14 is for PCIe 2.0 and newer */ 2813 if (__SHIFTOUT(reg, PCIE_XCAP_VER_MASK) >= 2) { 2814 reg = regs[o2i(pcie_capoff + PCIE_DCAP2)]; 2815 /* End-End TLP Prefix Supported */ 2816 if (reg & PCIE_DCAP2_EETLP_PREF) { 2817 tlp_prefix_log = true; 2818 } 2819 } 2820 } 2821 2822 printf("\n Advanced Error Reporting Register\n"); 2823 2824 reg = regs[o2i(extcapoff + PCI_AER_UC_STATUS)]; 2825 printf(" Uncorrectable Error Status register: 0x%08x\n", reg); 2826 pci_conf_print_aer_cap_uc(reg); 2827 reg = regs[o2i(extcapoff + PCI_AER_UC_MASK)]; 2828 printf(" Uncorrectable Error Mask register: 0x%08x\n", reg); 2829 pci_conf_print_aer_cap_uc(reg); 2830 reg = regs[o2i(extcapoff + PCI_AER_UC_SEVERITY)]; 2831 printf(" Uncorrectable Error Severity register: 0x%08x\n", reg); 2832 pci_conf_print_aer_cap_uc(reg); 2833 2834 reg = regs[o2i(extcapoff + PCI_AER_COR_STATUS)]; 2835 printf(" Correctable Error Status register: 0x%08x\n", reg); 2836 pci_conf_print_aer_cap_cor(reg); 2837 reg = regs[o2i(extcapoff + PCI_AER_COR_MASK)]; 2838 printf(" Correctable Error Mask register: 0x%08x\n", reg); 2839 pci_conf_print_aer_cap_cor(reg); 2840 2841 reg = regs[o2i(extcapoff + PCI_AER_CAP_CONTROL)]; 2842 printf(" Advanced Error Capabilities and Control register: 0x%08x\n", 2843 reg); 2844 pci_conf_print_aer_cap_control(reg, &tlp_prefix_log); 2845 reg = regs[o2i(extcapoff + PCI_AER_HEADER_LOG)]; 2846 printf(" Header Log register:\n"); 2847 pci_conf_print_regs(regs, extcapoff + PCI_AER_HEADER_LOG, 2848 extcapoff + PCI_AER_ROOTERR_CMD); 2849 2850 switch (pcie_devtype) { 2851 case PCIE_XCAP_TYPE_ROOT: /* Root Port of PCI Express Root Complex */ 2852 case PCIE_XCAP_TYPE_ROOT_EVNTC: /* Root Complex Event Collector */ 2853 reg = regs[o2i(extcapoff + PCI_AER_ROOTERR_CMD)]; 2854 printf(" Root Error Command register: 0x%08x\n", reg); 2855 pci_conf_print_aer_cap_rooterr_cmd(reg); 2856 reg = regs[o2i(extcapoff + PCI_AER_ROOTERR_STATUS)]; 2857 printf(" Root Error Status register: 0x%08x\n", reg); 2858 pci_conf_print_aer_cap_rooterr_status(reg); 2859 2860 reg = regs[o2i(extcapoff + PCI_AER_ERRSRC_ID)]; 2861 printf(" Error Source Identification register: 0x%08x\n", 2862 reg); 2863 pci_conf_print_aer_cap_errsrc_id(reg); 2864 break; 2865 } 2866 2867 if (tlp_prefix_log) { 2868 reg = regs[o2i(extcapoff + PCI_AER_TLP_PREFIX_LOG)]; 2869 printf(" TLP Prefix Log register: 0x%08x\n", reg); 2870 } 2871 } 2872 2873 /* 2874 * Helper function to print the arbitration phase register. 2875 * 2876 * phases: Number of phases in the arbitration tables. 2877 * arbsize: Number of bits in each phase. 2878 * indent: Add more two spaces if it's true. 2879 */ 2880 static void 2881 pci_conf_print_vc_cap_arbtab(const pcireg_t *regs, int off, const char *name, 2882 const int phases, int arbsize, bool indent) 2883 { 2884 pcireg_t reg; 2885 int num_per_reg = 32 / arbsize; 2886 int i, j; 2887 2888 printf("%s %s Arbitration Table:\n", indent ? " " : "", name); 2889 for (i = 0; i < phases; i += num_per_reg) { 2890 reg = regs[o2i(off + (sizeof(uint32_t) * (i / num_per_reg)))]; 2891 for (j = 0; j < num_per_reg; j++) { 2892 printf("%s Phase[%d]: 0x%x\n", indent ? " " : "", 2893 i + j, 2894 (uint32_t)(reg & __BITS(arbsize - 1, 0))); 2895 reg >>= arbsize; 2896 } 2897 } 2898 } 2899 2900 /* For VC, bit 4-7 are reserved. For Port, bit 6-7 are reserved */ 2901 static const int arb_phases[8] = {0, 32, 64, 128, 128, 256, 0, 0 }; 2902 2903 static void 2904 pci_conf_print_vc_cap(const pcireg_t *regs, int extcapoff) 2905 { 2906 pcireg_t reg, n; 2907 int arbtab, parbsize; 2908 pcireg_t arbsel; 2909 int i, count; 2910 2911 printf("\n Virtual Channel Register\n"); 2912 reg = regs[o2i(extcapoff + PCI_VC_CAP1)]; 2913 printf(" Port VC Capability register 1: 0x%08x\n", reg); 2914 count = __SHIFTOUT(reg, PCI_VC_CAP1_EXT_COUNT); 2915 printf(" Extended VC Count: %d\n", count); 2916 n = __SHIFTOUT(reg, PCI_VC_CAP1_LOWPRI_EXT_COUNT); 2917 printf(" Low Priority Extended VC Count: %u\n", n); 2918 n = __SHIFTOUT(reg, PCI_VC_CAP1_REFCLK); 2919 printf(" Reference Clock: %s\n", 2920 (n == PCI_VC_CAP1_REFCLK_100NS) ? "100ns" : "unknown"); 2921 parbsize = 1 << __SHIFTOUT(reg, PCI_VC_CAP1_PORT_ARB_TABLE_SIZE); 2922 printf(" Port Arbitration Table Entry Size: %dbit\n", parbsize); 2923 2924 reg = regs[o2i(extcapoff + PCI_VC_CAP2)]; 2925 printf(" Port VC Capability register 2: 0x%08x\n", reg); 2926 onoff("Hardware fixed arbitration scheme", 2927 reg, PCI_VC_CAP2_ARB_CAP_HW_FIXED_SCHEME); 2928 onoff("WRR arbitration with 32 phases", 2929 reg, PCI_VC_CAP2_ARB_CAP_WRR_32); 2930 onoff("WRR arbitration with 64 phases", 2931 reg, PCI_VC_CAP2_ARB_CAP_WRR_64); 2932 onoff("WRR arbitration with 128 phases", 2933 reg, PCI_VC_CAP2_ARB_CAP_WRR_128); 2934 arbtab = __SHIFTOUT(reg, PCI_VC_CAP2_ARB_TABLE_OFFSET); 2935 printf(" VC Arbitration Table Offset: 0x%x\n", arbtab); 2936 2937 reg = regs[o2i(extcapoff + PCI_VC_CONTROL)] & 0xffff; 2938 printf(" Port VC Control register: 0x%04x\n", reg); 2939 arbsel = __SHIFTOUT(reg, PCI_VC_CONTROL_VC_ARB_SELECT); 2940 printf(" VC Arbitration Select: 0x%x\n", arbsel); 2941 2942 reg = regs[o2i(extcapoff + PCI_VC_STATUS)] >> 16; 2943 printf(" Port VC Status register: 0x%04x\n", reg); 2944 onoff("VC Arbitration Table Status", 2945 reg, PCI_VC_STATUS_LOAD_VC_ARB_TABLE); 2946 2947 if ((arbtab != 0) && (arbsel != 0)) 2948 pci_conf_print_vc_cap_arbtab(regs, extcapoff + (arbtab * 16), 2949 "VC", arb_phases[arbsel], 4, false); 2950 2951 for (i = 0; i < count + 1; i++) { 2952 reg = regs[o2i(extcapoff + PCI_VC_RESOURCE_CAP(i))]; 2953 printf(" VC number %d\n", i); 2954 printf(" VC Resource Capability Register: 0x%08x\n", reg); 2955 onoff(" Non-configurable Hardware fixed arbitration scheme", 2956 reg, PCI_VC_RESOURCE_CAP_PORT_ARB_CAP_HW_FIXED_SCHEME); 2957 onoff(" WRR arbitration with 32 phases", 2958 reg, PCI_VC_RESOURCE_CAP_PORT_ARB_CAP_WRR_32); 2959 onoff(" WRR arbitration with 64 phases", 2960 reg, PCI_VC_RESOURCE_CAP_PORT_ARB_CAP_WRR_64); 2961 onoff(" WRR arbitration with 128 phases", 2962 reg, PCI_VC_RESOURCE_CAP_PORT_ARB_CAP_WRR_128); 2963 onoff(" Time-based WRR arbitration with 128 phases", 2964 reg, PCI_VC_RESOURCE_CAP_PORT_ARB_CAP_TWRR_128); 2965 onoff(" WRR arbitration with 256 phases", 2966 reg, PCI_VC_RESOURCE_CAP_PORT_ARB_CAP_WRR_256); 2967 onoff(" Advanced Packet Switching", 2968 reg, PCI_VC_RESOURCE_CAP_ADV_PKT_SWITCH); 2969 onoff(" Reject Snoop Transaction", 2970 reg, PCI_VC_RESOURCE_CAP_REJCT_SNOOP_TRANS); 2971 n = __SHIFTOUT(reg, PCI_VC_RESOURCE_CAP_MAX_TIME_SLOTS) + 1; 2972 printf(" Maximum Time Slots: %d\n", n); 2973 arbtab = __SHIFTOUT(reg, 2974 PCI_VC_RESOURCE_CAP_PORT_ARB_TABLE_OFFSET); 2975 printf(" Port Arbitration Table offset: 0x%02x\n", 2976 arbtab); 2977 2978 reg = regs[o2i(extcapoff + PCI_VC_RESOURCE_CTL(i))]; 2979 printf(" VC Resource Control Register: 0x%08x\n", reg); 2980 printf(" TC/VC Map: 0x%02x\n", 2981 (pcireg_t)__SHIFTOUT(reg, PCI_VC_RESOURCE_CTL_TCVC_MAP)); 2982 /* 2983 * The load Port Arbitration Table bit is used to update 2984 * the Port Arbitration logic and it's always 0 on read, so 2985 * we don't print it. 2986 */ 2987 arbsel = __SHIFTOUT(reg, PCI_VC_RESOURCE_CTL_PORT_ARB_SELECT); 2988 printf(" Port Arbitration Select: 0x%x\n", arbsel); 2989 n = __SHIFTOUT(reg, PCI_VC_RESOURCE_CTL_VC_ID); 2990 printf(" VC ID: %d\n", n); 2991 onoff(" VC Enable", reg, PCI_VC_RESOURCE_CTL_VC_ENABLE); 2992 2993 reg = regs[o2i(extcapoff + PCI_VC_RESOURCE_STA(i))] >> 16; 2994 printf(" VC Resource Status Register: 0x%08x\n", reg); 2995 onoff(" Port Arbitration Table Status", 2996 reg, PCI_VC_RESOURCE_STA_PORT_ARB_TABLE); 2997 onoff(" VC Negotiation Pending", 2998 reg, PCI_VC_RESOURCE_STA_VC_NEG_PENDING); 2999 3000 if ((arbtab != 0) && (arbsel != 0)) 3001 pci_conf_print_vc_cap_arbtab(regs, 3002 extcapoff + (arbtab * 16), 3003 "Port", arb_phases[arbsel], parbsize, true); 3004 } 3005 } 3006 3007 /* 3008 * Print Power limit. This encoding is the same among the following registers: 3009 * - The Captured Slot Power Limit in the PCIe Device Capability Register. 3010 * - The Slot Power Limit in the PCIe Slot Capability Register. 3011 * - The Base Power in the Data register of Power Budgeting capability. 3012 */ 3013 static void 3014 pci_conf_print_pcie_power(uint8_t base, unsigned int scale) 3015 { 3016 unsigned int sdiv = 1; 3017 3018 if ((scale == 0) && (base > 0xef)) { 3019 const char *s; 3020 3021 switch (base) { 3022 case 0xf0: 3023 s = "239W < x <= 250W"; 3024 break; 3025 case 0xf1: 3026 s = "250W < x <= 275W"; 3027 break; 3028 case 0xf2: 3029 s = "275W < x <= 300W"; 3030 break; 3031 default: 3032 s = "reserved for greater than 300W"; 3033 break; 3034 } 3035 printf("%s\n", s); 3036 return; 3037 } 3038 3039 for (unsigned int i = scale; i > 0; i--) 3040 sdiv *= 10; 3041 3042 printf("%u", base / sdiv); 3043 3044 if (scale != 0) { 3045 printf(".%u", base % sdiv); 3046 } 3047 printf ("W\n"); 3048 return; 3049 } 3050 3051 static const char * 3052 pci_conf_print_pwrbdgt_type(uint8_t reg) 3053 { 3054 3055 switch (reg) { 3056 case 0x00: 3057 return "PME Aux"; 3058 case 0x01: 3059 return "Auxilary"; 3060 case 0x02: 3061 return "Idle"; 3062 case 0x03: 3063 return "Sustained"; 3064 case 0x04: 3065 return "Sustained (Emergency Power Reduction)"; 3066 case 0x05: 3067 return "Maximum (Emergency Power Reduction)"; 3068 case 0x07: 3069 return "Maximum"; 3070 default: 3071 return "Unknown"; 3072 } 3073 } 3074 3075 static const char * 3076 pci_conf_print_pwrbdgt_pwrrail(uint8_t reg) 3077 { 3078 3079 switch (reg) { 3080 case 0x00: 3081 return "Power(12V)"; 3082 case 0x01: 3083 return "Power(3.3V)"; 3084 case 0x02: 3085 return "Power(1.5V or 1.8V)"; 3086 case 0x07: 3087 return "Thermal"; 3088 default: 3089 return "Unknown"; 3090 } 3091 } 3092 3093 static void 3094 pci_conf_print_pwrbdgt_cap(const pcireg_t *regs, int extcapoff) 3095 { 3096 pcireg_t reg; 3097 3098 printf("\n Power Budgeting\n"); 3099 3100 reg = regs[o2i(extcapoff + PCI_PWRBDGT_DSEL)]; 3101 printf(" Data Select register: 0x%08x\n", reg); 3102 3103 reg = regs[o2i(extcapoff + PCI_PWRBDGT_DATA)]; 3104 printf(" Data register: 0x%08x\n", reg); 3105 printf(" Base Power: "); 3106 pci_conf_print_pcie_power( 3107 __SHIFTOUT(reg, PCI_PWRBDGT_DATA_BASEPWR), 3108 __SHIFTOUT(reg, PCI_PWRBDGT_DATA_SCALE)); 3109 printf(" PM Sub State: 0x%hhx\n", 3110 (uint8_t)__SHIFTOUT(reg, PCI_PWRBDGT_PM_SUBSTAT)); 3111 printf(" PM State: D%u\n", 3112 (unsigned int)__SHIFTOUT(reg, PCI_PWRBDGT_PM_STAT)); 3113 printf(" Type: %s\n", 3114 pci_conf_print_pwrbdgt_type( 3115 (uint8_t)(__SHIFTOUT(reg, PCI_PWRBDGT_TYPE)))); 3116 printf(" Power Rail: %s\n", 3117 pci_conf_print_pwrbdgt_pwrrail( 3118 (uint8_t)(__SHIFTOUT(reg, PCI_PWRBDGT_PWRRAIL)))); 3119 3120 reg = regs[o2i(extcapoff + PCI_PWRBDGT_CAP)]; 3121 printf(" Power Budget Capability register: 0x%08x\n", reg); 3122 onoff("System Allocated", 3123 reg, PCI_PWRBDGT_CAP_SYSALLOC); 3124 } 3125 3126 static const char * 3127 pci_conf_print_rclink_dcl_cap_elmtype(unsigned char type) 3128 { 3129 3130 switch (type) { 3131 case 0x00: 3132 return "Configuration Space Element"; 3133 case 0x01: 3134 return "System Egress Port or internal sink (memory)"; 3135 case 0x02: 3136 return "Internal Root Complex Link"; 3137 default: 3138 return "Unknown"; 3139 } 3140 } 3141 3142 static void 3143 pci_conf_print_rclink_dcl_cap(const pcireg_t *regs, int extcapoff) 3144 { 3145 pcireg_t reg; 3146 unsigned char nent, linktype; 3147 int i; 3148 3149 printf("\n Root Complex Link Declaration\n"); 3150 3151 reg = regs[o2i(extcapoff + PCI_RCLINK_DCL_ESDESC)]; 3152 printf(" Element Self Description Register: 0x%08x\n", reg); 3153 printf(" Element Type: %s\n", 3154 pci_conf_print_rclink_dcl_cap_elmtype((unsigned char)reg)); 3155 nent = __SHIFTOUT(reg, PCI_RCLINK_DCL_ESDESC_NUMLINKENT); 3156 printf(" Number of Link Entries: %hhu\n", nent); 3157 printf(" Component ID: %hhu\n", 3158 (uint8_t)__SHIFTOUT(reg, PCI_RCLINK_DCL_ESDESC_COMPID)); 3159 printf(" Port Number: %hhu\n", 3160 (uint8_t)__SHIFTOUT(reg, PCI_RCLINK_DCL_ESDESC_PORTNUM)); 3161 for (i = 0; i < nent; i++) { 3162 reg = regs[o2i(extcapoff + PCI_RCLINK_DCL_LINKDESC(i))]; 3163 printf(" Link Entry %d:\n", i + 1); 3164 printf(" Link Description Register: 0x%08x\n", reg); 3165 onoff(" Link Valid", reg, PCI_RCLINK_DCL_LINKDESC_LVALID); 3166 linktype = reg & PCI_RCLINK_DCL_LINKDESC_LTYPE; 3167 onoff2(" Link Type", reg, PCI_RCLINK_DCL_LINKDESC_LTYPE, 3168 "Configuration Space", "Memory-Mapped Space"); 3169 onoff(" Associated RCRB Header", reg, 3170 PCI_RCLINK_DCL_LINKDESC_ARCRBH); 3171 printf(" Target Component ID: %hhu\n", 3172 (unsigned char)__SHIFTOUT(reg, 3173 PCI_RCLINK_DCL_LINKDESC_TCOMPID)); 3174 printf(" Target Port Number: %hhu\n", 3175 (unsigned char)__SHIFTOUT(reg, 3176 PCI_RCLINK_DCL_LINKDESC_TPNUM)); 3177 3178 if (linktype == 0) { 3179 /* Memory-Mapped Space */ 3180 reg = regs[o2i(extcapoff 3181 + PCI_RCLINK_DCL_LINKADDR_LT0_LO(i))]; 3182 printf(" Link Address Low Register: 0x%08x\n", 3183 reg); 3184 reg = regs[o2i(extcapoff 3185 + PCI_RCLINK_DCL_LINKADDR_LT0_HI(i))]; 3186 printf(" Link Address High Register: 0x%08x\n", 3187 reg); 3188 } else { 3189 unsigned int nb; 3190 pcireg_t lo, hi; 3191 3192 /* Configuration Space */ 3193 lo = regs[o2i(extcapoff 3194 + PCI_RCLINK_DCL_LINKADDR_LT1_LO(i))]; 3195 printf(" Configuration Space Low Register: " 3196 "0x%08x\n", lo); 3197 hi = regs[o2i(extcapoff 3198 + PCI_RCLINK_DCL_LINKADDR_LT1_HI(i))]; 3199 printf(" Configuration Space High Register: " 3200 "0x%08x\n", hi); 3201 nb = __SHIFTOUT(lo, PCI_RCLINK_DCL_LINKADDR_LT1_N); 3202 printf(" N: %u\n", nb); 3203 printf(" Func: %hhu\n", 3204 (unsigned char)__SHIFTOUT(lo, 3205 PCI_RCLINK_DCL_LINKADDR_LT1_FUNC)); 3206 printf(" Dev: %hhu\n", 3207 (unsigned char)__SHIFTOUT(lo, 3208 PCI_RCLINK_DCL_LINKADDR_LT1_DEV)); 3209 printf(" Bus: %hhu\n", 3210 (unsigned char)__SHIFTOUT(lo, 3211 PCI_RCLINK_DCL_LINKADDR_LT1_BUS(nb))); 3212 lo &= PCI_RCLINK_DCL_LINKADDR_LT1_BAL(i); 3213 printf(" Configuration Space Base Address: " 3214 "0x%016" PRIx64 "\n", ((uint64_t)hi << 32) + lo); 3215 } 3216 } 3217 } 3218 3219 /* XXX pci_conf_print_rclink_ctl_cap */ 3220 3221 static void 3222 pci_conf_print_rcec_assoc_cap(const pcireg_t *regs, int extcapoff) 3223 { 3224 pcireg_t reg; 3225 3226 printf("\n Root Complex Event Collector Association\n"); 3227 3228 reg = regs[o2i(extcapoff + PCI_RCEC_ASSOC_ASSOCBITMAP)]; 3229 printf(" Association Bitmap for Root Complex Integrated Devices:" 3230 " 0x%08x\n", reg); 3231 3232 if (PCI_EXTCAPLIST_VERSION(regs[o2i(extcapoff)]) >= 2) { 3233 reg = regs[o2i(extcapoff + PCI_RCEC_ASSOC_ASSOCBUSNUM)]; 3234 printf(" RCEC Associated Bus Numbers register: 0x%08x\n", 3235 reg); 3236 printf(" RCEC Next Bus: %u\n", 3237 (unsigned int)__SHIFTOUT(reg, 3238 PCI_RCEC_ASSOCBUSNUM_RCECNEXT)); 3239 printf(" RCEC Last Bus: %u\n", 3240 (unsigned int)__SHIFTOUT(reg, 3241 PCI_RCEC_ASSOCBUSNUM_RCECLAST)); 3242 } 3243 } 3244 3245 /* XXX pci_conf_print_mfvc_cap */ 3246 /* XXX pci_conf_print_vc2_cap */ 3247 /* XXX pci_conf_print_rcrb_cap */ 3248 /* XXX pci_conf_print_vendor_cap */ 3249 /* XXX pci_conf_print_cac_cap */ 3250 3251 static void 3252 pci_conf_print_acs_cap(const pcireg_t *regs, int extcapoff) 3253 { 3254 pcireg_t reg, cap, ctl; 3255 unsigned int size, i; 3256 3257 printf("\n Access Control Services\n"); 3258 3259 reg = regs[o2i(extcapoff + PCI_ACS_CAP)]; 3260 cap = reg & 0xffff; 3261 ctl = reg >> 16; 3262 printf(" ACS Capability register: 0x%08x\n", cap); 3263 onoff("ACS Source Validation", cap, PCI_ACS_CAP_V); 3264 onoff("ACS Transaction Blocking", cap, PCI_ACS_CAP_B); 3265 onoff("ACS P2P Request Redirect", cap, PCI_ACS_CAP_R); 3266 onoff("ACS P2P Completion Redirect", cap, PCI_ACS_CAP_C); 3267 onoff("ACS Upstream Forwarding", cap, PCI_ACS_CAP_U); 3268 onoff("ACS Egress Control", cap, PCI_ACS_CAP_E); 3269 onoff("ACS Direct Translated P2P", cap, PCI_ACS_CAP_T); 3270 size = __SHIFTOUT(cap, PCI_ACS_CAP_ECVSIZE); 3271 if (size == 0) 3272 size = 256; 3273 printf(" Egress Control Vector Size: %u\n", size); 3274 printf(" ACS Control register: 0x%08x\n", ctl); 3275 onoff("ACS Source Validation Enable", ctl, PCI_ACS_CTL_V); 3276 onoff("ACS Transaction Blocking Enable", ctl, PCI_ACS_CTL_B); 3277 onoff("ACS P2P Request Redirect Enable", ctl, PCI_ACS_CTL_R); 3278 onoff("ACS P2P Completion Redirect Enable", ctl, PCI_ACS_CTL_C); 3279 onoff("ACS Upstream Forwarding Enable", ctl, PCI_ACS_CTL_U); 3280 onoff("ACS Egress Control Enable", ctl, PCI_ACS_CTL_E); 3281 onoff("ACS Direct Translated P2P Enable", ctl, PCI_ACS_CTL_T); 3282 3283 /* 3284 * If the P2P Egress Control Capability bit is 0, ignore the Egress 3285 * Control vector. 3286 */ 3287 if ((cap & PCI_ACS_CAP_E) == 0) 3288 return; 3289 for (i = 0; i < size; i += 32) 3290 printf(" Egress Control Vector [%u..%u]: 0x%08x\n", i + 31, 3291 i, regs[o2i(extcapoff + PCI_ACS_ECV + (i / 32) * 4 )]); 3292 } 3293 3294 static void 3295 pci_conf_print_ari_cap(const pcireg_t *regs, int extcapoff) 3296 { 3297 pcireg_t reg, cap, ctl; 3298 3299 printf("\n Alternative Routing-ID Interpretation Register\n"); 3300 3301 reg = regs[o2i(extcapoff + PCI_ARI_CAP)]; 3302 cap = reg & 0xffff; 3303 ctl = reg >> 16; 3304 printf(" Capability register: 0x%08x\n", cap); 3305 onoff("MVFC Function Groups Capability", reg, PCI_ARI_CAP_M); 3306 onoff("ACS Function Groups Capability", reg, PCI_ARI_CAP_A); 3307 printf(" Next Function Number: %u\n", 3308 (unsigned int)__SHIFTOUT(reg, PCI_ARI_CAP_NXTFN)); 3309 printf(" Control register: 0x%08x\n", ctl); 3310 onoff("MVFC Function Groups Enable", reg, PCI_ARI_CTL_M); 3311 onoff("ACS Function Groups Enable", reg, PCI_ARI_CTL_A); 3312 printf(" Function Group: %u\n", 3313 (unsigned int)__SHIFTOUT(reg, PCI_ARI_CTL_FUNCGRP)); 3314 } 3315 3316 static void 3317 pci_conf_print_ats_cap(const pcireg_t *regs, int extcapoff) 3318 { 3319 pcireg_t reg, cap, ctl; 3320 unsigned int num; 3321 3322 printf("\n Address Translation Services\n"); 3323 3324 reg = regs[o2i(extcapoff + PCI_ARI_CAP)]; 3325 cap = reg & 0xffff; 3326 ctl = reg >> 16; 3327 printf(" Capability register: 0x%04x\n", cap); 3328 num = __SHIFTOUT(reg, PCI_ATS_CAP_INVQDEPTH); 3329 if (num == 0) 3330 num = 32; 3331 printf(" Invalidate Queue Depth: %u\n", num); 3332 onoff("Page Aligned Request", reg, PCI_ATS_CAP_PALIGNREQ); 3333 onoff("Global Invalidate", reg, PCI_ATS_CAP_GLOBALINVL); 3334 onoff("Relaxed Ordering", reg, PCI_ATS_CAP_RELAXORD); 3335 3336 printf(" Control register: 0x%04x\n", ctl); 3337 printf(" Smallest Translation Unit: %u\n", 3338 (unsigned int)__SHIFTOUT(reg, PCI_ATS_CTL_STU)); 3339 onoff("Enable", reg, PCI_ATS_CTL_EN); 3340 } 3341 3342 static void 3343 pci_conf_print_sernum_cap(const pcireg_t *regs, int extcapoff) 3344 { 3345 pcireg_t lo, hi; 3346 3347 printf("\n Device Serial Number Register\n"); 3348 3349 lo = regs[o2i(extcapoff + PCI_SERIAL_LOW)]; 3350 hi = regs[o2i(extcapoff + PCI_SERIAL_HIGH)]; 3351 printf(" Serial Number: %02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x\n", 3352 hi >> 24, (hi >> 16) & 0xff, (hi >> 8) & 0xff, hi & 0xff, 3353 lo >> 24, (lo >> 16) & 0xff, (lo >> 8) & 0xff, lo & 0xff); 3354 } 3355 3356 static void 3357 pci_conf_print_sriov_cap(const pcireg_t *regs, int extcapoff) 3358 { 3359 char buf[sizeof("99999 MB")]; 3360 pcireg_t reg; 3361 pcireg_t total_vfs; 3362 int i; 3363 bool first; 3364 3365 printf("\n Single Root IO Virtualization Register\n"); 3366 3367 reg = regs[o2i(extcapoff + PCI_SRIOV_CAP)]; 3368 printf(" Capabilities register: 0x%08x\n", reg); 3369 onoff("VF Migration Capable", reg, PCI_SRIOV_CAP_VF_MIGRATION); 3370 onoff("ARI Capable Hierarchy Preserved", reg, 3371 PCI_SRIOV_CAP_ARI_CAP_HIER_PRESERVED); 3372 if (reg & PCI_SRIOV_CAP_VF_MIGRATION) { 3373 printf(" VF Migration Interrupt Message Number: 0x%03x\n", 3374 (pcireg_t)__SHIFTOUT(reg, 3375 PCI_SRIOV_CAP_VF_MIGRATION_INTMSG_N)); 3376 } 3377 3378 reg = regs[o2i(extcapoff + PCI_SRIOV_CTL)] & 0xffff; 3379 printf(" Control register: 0x%04x\n", reg); 3380 onoff("VF Enable", reg, PCI_SRIOV_CTL_VF_ENABLE); 3381 onoff("VF Migration Enable", reg, PCI_SRIOV_CTL_VF_MIGRATION_SUPPORT); 3382 onoff("VF Migration Interrupt Enable", reg, 3383 PCI_SRIOV_CTL_VF_MIGRATION_INT_ENABLE); 3384 onoff("VF Memory Space Enable", reg, PCI_SRIOV_CTL_VF_MSE); 3385 onoff("ARI Capable Hierarchy", reg, PCI_SRIOV_CTL_ARI_CAP_HIER); 3386 3387 reg = regs[o2i(extcapoff + PCI_SRIOV_STA)] >> 16; 3388 printf(" Status register: 0x%04x\n", reg); 3389 onoff("VF Migration Status", reg, PCI_SRIOV_STA_VF_MIGRATION); 3390 3391 reg = regs[o2i(extcapoff + PCI_SRIOV_INITIAL_VFS)] & 0xffff; 3392 printf(" InitialVFs register: 0x%04x\n", reg); 3393 total_vfs = reg = regs[o2i(extcapoff + PCI_SRIOV_TOTAL_VFS)] >> 16; 3394 printf(" TotalVFs register: 0x%04x\n", reg); 3395 reg = regs[o2i(extcapoff + PCI_SRIOV_NUM_VFS)] & 0xffff; 3396 printf(" NumVFs register: 0x%04x\n", reg); 3397 3398 reg = regs[o2i(extcapoff + PCI_SRIOV_FUNC_DEP_LINK)] >> 16; 3399 printf(" Function Dependency Link register: 0x%04x\n", reg); 3400 3401 reg = regs[o2i(extcapoff + PCI_SRIOV_VF_OFF)] & 0xffff; 3402 printf(" First VF Offset register: 0x%04x\n", reg); 3403 reg = regs[o2i(extcapoff + PCI_SRIOV_VF_STRIDE)] >> 16; 3404 printf(" VF Stride register: 0x%04x\n", reg); 3405 reg = regs[o2i(extcapoff + PCI_SRIOV_VF_DID)] >> 16; 3406 printf(" Device ID: 0x%04x\n", reg); 3407 3408 reg = regs[o2i(extcapoff + PCI_SRIOV_PAGE_CAP)]; 3409 printf(" Supported Page Sizes register: 0x%08x\n", reg); 3410 printf(" Supported Page Size:"); 3411 for (i = 0, first = true; i < 32; i++) { 3412 if (reg & __BIT(i)) { 3413 #ifdef _KERNEL 3414 format_bytes(buf, sizeof(buf), 1LL << (i + 12)); 3415 #else 3416 humanize_number(buf, sizeof(buf), 1LL << (i + 12), "B", 3417 HN_AUTOSCALE, 0); 3418 #endif 3419 printf("%s %s", first ? "" : ",", buf); 3420 first = false; 3421 } 3422 } 3423 printf("\n"); 3424 3425 reg = regs[o2i(extcapoff + PCI_SRIOV_PAGE_SIZE)]; 3426 printf(" System Page Sizes register: 0x%08x\n", reg); 3427 printf(" Page Size: "); 3428 if (reg != 0) { 3429 int bitpos = ffs(reg) -1; 3430 3431 /* Assume only one bit is set. */ 3432 #ifdef _KERNEL 3433 format_bytes(buf, sizeof(buf), 1LL << (bitpos + 12)); 3434 #else 3435 humanize_number(buf, sizeof(buf), 1LL << (bitpos + 12), 3436 "B", HN_AUTOSCALE, 0); 3437 #endif 3438 printf("%s", buf); 3439 } else { 3440 printf("unknown"); 3441 } 3442 printf("\n"); 3443 3444 for (i = 0; i < 6; i++) { 3445 reg = regs[o2i(extcapoff + PCI_SRIOV_BAR(i))]; 3446 printf(" VF BAR%d register: 0x%08x\n", i, reg); 3447 } 3448 3449 if (total_vfs > 0) { 3450 reg = regs[o2i(extcapoff + PCI_SRIOV_VF_MIG_STA_AR)]; 3451 printf(" VF Migration State Array Offset register: 0x%08x\n", 3452 reg); 3453 printf(" VF Migration State Offset: 0x%08x\n", 3454 (pcireg_t)__SHIFTOUT(reg, PCI_SRIOV_VF_MIG_STA_OFFSET)); 3455 i = __SHIFTOUT(reg, PCI_SRIOV_VF_MIG_STA_BIR); 3456 printf(" VF Migration State BIR: "); 3457 if (i >= 0 && i <= 5) { 3458 printf("BAR%d", i); 3459 } else { 3460 printf("unknown BAR (%d)", i); 3461 } 3462 printf("\n"); 3463 } 3464 } 3465 3466 /* XXX pci_conf_print_mriov_cap */ 3467 3468 static void 3469 pci_conf_print_multicast_cap(const pcireg_t *regs, int extcapoff) 3470 { 3471 pcireg_t reg, cap, ctl; 3472 pcireg_t regl, regh; 3473 uint64_t addr; 3474 int n; 3475 3476 printf("\n Multicast\n"); 3477 3478 reg = regs[o2i(extcapoff + PCI_MCAST_CTL)]; 3479 cap = reg & 0xffff; 3480 ctl = reg >> 16; 3481 printf(" Capability Register: 0x%04x\n", cap); 3482 printf(" Max Group: %u\n", 3483 (pcireg_t)(reg & PCI_MCAST_CAP_MAXGRP) + 1); 3484 3485 /* Endpoint Only */ 3486 n = __SHIFTOUT(reg, PCI_MCAST_CAP_WINSIZEREQ); 3487 if (n > 0) 3488 printf(" Windw Size Requested: %d\n", 1 << (n - 1)); 3489 3490 onoff("ECRC Regeneration Supported", reg, PCI_MCAST_CAP_ECRCREGEN); 3491 3492 printf(" Control Register: 0x%04x\n", ctl); 3493 printf(" Num Group: %u\n", 3494 (unsigned int)__SHIFTOUT(reg, PCI_MCAST_CTL_NUMGRP) + 1); 3495 onoff("Enable", reg, PCI_MCAST_CTL_ENA); 3496 3497 regl = regs[o2i(extcapoff + PCI_MCAST_BARL)]; 3498 regh = regs[o2i(extcapoff + PCI_MCAST_BARH)]; 3499 printf(" Base Address Register 0: 0x%08x\n", regl); 3500 printf(" Base Address Register 1: 0x%08x\n", regh); 3501 printf(" Index Position: %u\n", 3502 (unsigned int)(regl & PCI_MCAST_BARL_INDPOS)); 3503 addr = ((uint64_t)regh << 32) | (regl & PCI_MCAST_BARL_ADDR); 3504 printf(" Base Address: 0x%016" PRIx64 "\n", addr); 3505 3506 regl = regs[o2i(extcapoff + PCI_MCAST_RECVL)]; 3507 regh = regs[o2i(extcapoff + PCI_MCAST_RECVH)]; 3508 printf(" Receive Register 0: 0x%08x\n", regl); 3509 printf(" Receive Register 1: 0x%08x\n", regh); 3510 3511 regl = regs[o2i(extcapoff + PCI_MCAST_BLOCKALLL)]; 3512 regh = regs[o2i(extcapoff + PCI_MCAST_BLOCKALLH)]; 3513 printf(" Block All Register 0: 0x%08x\n", regl); 3514 printf(" Block All Register 1: 0x%08x\n", regh); 3515 3516 regl = regs[o2i(extcapoff + PCI_MCAST_BLOCKUNTRNSL)]; 3517 regh = regs[o2i(extcapoff + PCI_MCAST_BLOCKUNTRNSH)]; 3518 printf(" Block Untranslated Register 0: 0x%08x\n", regl); 3519 printf(" Block Untranslated Register 1: 0x%08x\n", regh); 3520 3521 regl = regs[o2i(extcapoff + PCI_MCAST_OVERLAYL)]; 3522 regh = regs[o2i(extcapoff + PCI_MCAST_OVERLAYH)]; 3523 printf(" Overlay BAR 0: 0x%08x\n", regl); 3524 printf(" Overlay BAR 1: 0x%08x\n", regh); 3525 3526 n = regl & PCI_MCAST_OVERLAYL_SIZE; 3527 printf(" Overlay Size: "); 3528 if (n >= 6) 3529 printf("%d\n", n); 3530 else 3531 printf("off\n"); 3532 addr = ((uint64_t)regh << 32) | (regl & PCI_MCAST_OVERLAYL_ADDR); 3533 printf(" Overlay BAR: 0x%016" PRIx64 "\n", addr); 3534 } 3535 3536 static void 3537 pci_conf_print_page_req_cap(const pcireg_t *regs, int extcapoff) 3538 { 3539 pcireg_t reg, ctl, sta; 3540 3541 printf("\n Page Request\n"); 3542 3543 reg = regs[o2i(extcapoff + PCI_PAGE_REQ_CTL)]; 3544 ctl = reg & 0xffff; 3545 sta = reg >> 16; 3546 printf(" Control Register: 0x%04x\n", ctl); 3547 onoff("Enable", reg, PCI_PAGE_REQ_CTL_E); 3548 onoff("Reset", reg, PCI_PAGE_REQ_CTL_R); 3549 3550 printf(" Status Register: 0x%04x\n", sta); 3551 onoff("Response Failure", reg, PCI_PAGE_REQ_STA_RF); 3552 onoff("Unexpected Page Request Group Index", reg, 3553 PCI_PAGE_REQ_STA_UPRGI); 3554 onoff("Stopped", reg, PCI_PAGE_REQ_STA_S); 3555 onoff("PRG Response PASID Required", reg, PCI_PAGE_REQ_STA_PASIDR); 3556 3557 reg = regs[o2i(extcapoff + PCI_PAGE_REQ_OUTSTCAPA)]; 3558 printf(" Outstanding Page Request Capacity: %u\n", reg); 3559 reg = regs[o2i(extcapoff + PCI_PAGE_REQ_OUTSTALLOC)]; 3560 printf(" Outstanding Page Request Allocation: %u\n", reg); 3561 } 3562 3563 /* XXX pci_conf_print_amd_cap */ 3564 3565 #define MEM_PBUFSIZE sizeof("999GB") 3566 3567 static void 3568 pci_conf_print_resizbar_cap(const pcireg_t *regs, int extcapoff) 3569 { 3570 pcireg_t cap, ctl; 3571 unsigned int bars, i, n; 3572 char pbuf[MEM_PBUFSIZE]; 3573 3574 printf("\n Resizable BAR\n"); 3575 3576 /* Get Number of Resizable BARs */ 3577 ctl = regs[o2i(extcapoff + PCI_RESIZBAR_CTL(0))]; 3578 bars = __SHIFTOUT(ctl, PCI_RESIZBAR_CTL_NUMBAR); 3579 printf(" Number of Resizable BARs: "); 3580 if (bars <= 6) 3581 printf("%u\n", bars); 3582 else { 3583 printf("incorrect (%u)\n", bars); 3584 return; 3585 } 3586 3587 for (n = 0; n < 6; n++) { 3588 cap = regs[o2i(extcapoff + PCI_RESIZBAR_CAP(n))]; 3589 printf(" Capability register(%u): 0x%08x\n", n, cap); 3590 if ((cap & PCI_RESIZBAR_CAP_SIZEMASK) == 0) 3591 continue; /* Not Used */ 3592 printf(" Acceptable BAR sizes:"); 3593 for (i = 4; i <= 23; i++) { 3594 if ((cap & (1 << i)) != 0) { 3595 humanize_number(pbuf, MEM_PBUFSIZE, 3596 (int64_t)1024 * 1024 << (i - 4), "B", 3597 #ifdef _KERNEL 3598 1); 3599 #else 3600 HN_AUTOSCALE, HN_NOSPACE); 3601 #endif 3602 printf(" %s", pbuf); 3603 } 3604 } 3605 printf("\n"); 3606 3607 ctl = regs[o2i(extcapoff + PCI_RESIZBAR_CTL(n))]; 3608 printf(" Control register(%u): 0x%08x\n", n, ctl); 3609 printf(" BAR Index: %u\n", 3610 (unsigned int)__SHIFTOUT(ctl, PCI_RESIZBAR_CTL_BARIDX)); 3611 humanize_number(pbuf, MEM_PBUFSIZE, 3612 (int64_t)1024 * 1024 3613 << __SHIFTOUT(ctl, PCI_RESIZBAR_CTL_BARSIZ), 3614 "B", 3615 #ifdef _KERNEL 3616 1); 3617 #else 3618 HN_AUTOSCALE, HN_NOSPACE); 3619 #endif 3620 printf(" BAR Size: %s\n", pbuf); 3621 } 3622 } 3623 3624 static void 3625 pci_conf_print_dpa_cap(const pcireg_t *regs, int extcapoff) 3626 { 3627 pcireg_t reg; 3628 unsigned int substmax, i; 3629 3630 printf("\n Dynamic Power Allocation\n"); 3631 3632 reg = regs[o2i(extcapoff + PCI_DPA_CAP)]; 3633 printf(" Capability register: 0x%08x\n", reg); 3634 substmax = __SHIFTOUT(reg, PCI_DPA_CAP_SUBSTMAX); 3635 printf(" Substate Max: %u\n", substmax); 3636 printf(" Transition Latency Unit: "); 3637 switch (__SHIFTOUT(reg, PCI_DPA_CAP_TLUINT)) { 3638 case 0: 3639 printf("1ms\n"); 3640 break; 3641 case 1: 3642 printf("10ms\n"); 3643 break; 3644 case 2: 3645 printf("100ms\n"); 3646 break; 3647 default: 3648 printf("reserved\n"); 3649 break; 3650 } 3651 printf(" Power Allocation Scale: "); 3652 switch (__SHIFTOUT(reg, PCI_DPA_CAP_PAS)) { 3653 case 0: 3654 printf("10.0x\n"); 3655 break; 3656 case 1: 3657 printf("1.0x\n"); 3658 break; 3659 case 2: 3660 printf("0.1x\n"); 3661 break; 3662 case 3: 3663 printf("0.01x\n"); 3664 break; 3665 } 3666 printf(" Transition Latency Value 0: %u\n", 3667 (unsigned int)__SHIFTOUT(reg, PCI_DPA_CAP_XLCY0)); 3668 printf(" Transition Latency Value 1: %u\n", 3669 (unsigned int)__SHIFTOUT(reg, PCI_DPA_CAP_XLCY1)); 3670 3671 reg = regs[o2i(extcapoff + PCI_DPA_LATIND)]; 3672 printf(" Latency Indicatior register: 0x%08x\n", reg); 3673 3674 reg = regs[o2i(extcapoff + PCI_DPA_CS)]; 3675 printf(" Status register: 0x%04x\n", reg & 0xffff); 3676 printf(" Substate Status: 0x%02x\n", 3677 (unsigned int)__SHIFTOUT(reg, PCI_DPA_CS_SUBSTSTAT)); 3678 onoff("Substate Control Enabled", reg, PCI_DPA_CS_SUBSTCTLEN); 3679 printf(" Control register: 0x%04x\n", reg >> 16); 3680 printf(" Substate Control: 0x%02x\n", 3681 (unsigned int)__SHIFTOUT(reg, PCI_DPA_CS_SUBSTCTL)); 3682 3683 for (i = 0; i <= substmax; i++) 3684 printf(" Substate Power Allocation register %d: 0x%02x\n", 3685 i, (regs[PCI_DPA_PWRALLOC + (i / 4)] >> (i % 4) & 0xff)); 3686 } 3687 3688 static const char * 3689 pci_conf_print_tph_req_cap_sttabloc(uint8_t val) 3690 { 3691 3692 switch (val) { 3693 case PCI_TPH_REQ_STTBLLOC_NONE: 3694 return "Not Present"; 3695 case PCI_TPH_REQ_STTBLLOC_TPHREQ: 3696 return "in the TPH Requester Capability Structure"; 3697 case PCI_TPH_REQ_STTBLLOC_MSIX: 3698 return "in the MSI-X Table"; 3699 default: 3700 return "Unknown"; 3701 } 3702 } 3703 3704 static void 3705 pci_conf_print_tph_req_cap(const pcireg_t *regs, int extcapoff) 3706 { 3707 pcireg_t reg; 3708 int size = 0, i, j; 3709 uint8_t sttbloc; 3710 3711 printf("\n TPH Requester Extended Capability\n"); 3712 3713 reg = regs[o2i(extcapoff + PCI_TPH_REQ_CAP)]; 3714 printf(" TPH Requester Capabililty register: 0x%08x\n", reg); 3715 onoff("No ST Mode Supported", reg, PCI_TPH_REQ_CAP_NOST); 3716 onoff("Interrupt Vector Mode Supported", reg, PCI_TPH_REQ_CAP_INTVEC); 3717 onoff("Device Specific Mode Supported", reg, PCI_TPH_REQ_CAP_DEVSPEC); 3718 onoff("Extend TPH Reqester Supported", reg, PCI_TPH_REQ_CAP_XTPHREQ); 3719 sttbloc = __SHIFTOUT(reg, PCI_TPH_REQ_CAP_STTBLLOC); 3720 printf(" ST Table Location: %s\n", 3721 pci_conf_print_tph_req_cap_sttabloc(sttbloc)); 3722 if (sttbloc == PCI_TPH_REQ_STTBLLOC_TPHREQ) { 3723 size = __SHIFTOUT(reg, PCI_TPH_REQ_CAP_STTBLSIZ) + 1; 3724 printf(" ST Table Size: %d\n", size); 3725 } 3726 3727 reg = regs[o2i(extcapoff + PCI_TPH_REQ_CTL)]; 3728 printf(" TPH Requester Control register: 0x%08x\n", reg); 3729 printf(" ST Mode Select: "); 3730 switch (__SHIFTOUT(reg, PCI_TPH_REQ_CTL_STSEL)) { 3731 case PCI_TPH_REQ_CTL_STSEL_NO: 3732 printf("No ST Mode\n"); 3733 break; 3734 case PCI_TPH_REQ_CTL_STSEL_IV: 3735 printf("Interrupt Vector Mode\n"); 3736 break; 3737 case PCI_TPH_REQ_CTL_STSEL_DS: 3738 printf("Device Specific Mode\n"); 3739 break; 3740 default: 3741 printf("(reserved value)\n"); 3742 break; 3743 } 3744 printf(" TPH Requester Enable: "); 3745 switch (__SHIFTOUT(reg, PCI_TPH_REQ_CTL_TPHREQEN)) { 3746 case PCI_TPH_REQ_CTL_TPHREQEN_NO: /* 0x0 */ 3747 printf("Not permitted\n"); 3748 break; 3749 case PCI_TPH_REQ_CTL_TPHREQEN_TPH: 3750 printf("TPH and not Extended TPH\n"); 3751 break; 3752 case PCI_TPH_REQ_CTL_TPHREQEN_ETPH: 3753 printf("TPH and Extended TPH"); 3754 break; 3755 default: 3756 printf("(reserved value)\n"); 3757 break; 3758 } 3759 3760 if (sttbloc != PCI_TPH_REQ_STTBLLOC_TPHREQ) 3761 return; 3762 3763 for (i = 0; i < size ; i += 2) { 3764 reg = regs[o2i(extcapoff + PCI_TPH_REQ_STTBL + i / 2)]; 3765 for (j = 0; j < 2 ; j++) { 3766 uint32_t entry = reg; 3767 3768 if (j != 0) 3769 entry >>= 16; 3770 entry &= 0xffff; 3771 printf(" TPH ST Table Entry (%d): 0x%04"PRIx32"\n", 3772 i + j, entry); 3773 } 3774 } 3775 } 3776 3777 static void 3778 pci_conf_print_ltr_cap(const pcireg_t *regs, int extcapoff) 3779 { 3780 pcireg_t reg; 3781 3782 printf("\n Latency Tolerance Reporting\n"); 3783 reg = regs[o2i(extcapoff + PCI_LTR_MAXSNOOPLAT)]; 3784 printf(" Max Snoop Latency Register: 0x%04x\n", reg & 0xffff); 3785 printf(" Max Snoop Latency: %juns\n", 3786 (uintmax_t)(__SHIFTOUT(reg, PCI_LTR_MAXSNOOPLAT_VAL) 3787 * PCI_LTR_SCALETONS(__SHIFTOUT(reg, PCI_LTR_MAXSNOOPLAT_SCALE)))); 3788 printf(" Max No-Snoop Latency Register: 0x%04x\n", reg >> 16); 3789 printf(" Max No-Snoop Latency: %juns\n", 3790 (uintmax_t)(__SHIFTOUT(reg, PCI_LTR_MAXNOSNOOPLAT_VAL) 3791 * PCI_LTR_SCALETONS(__SHIFTOUT(reg, PCI_LTR_MAXNOSNOOPLAT_SCALE)))); 3792 } 3793 3794 static void 3795 pci_conf_print_sec_pcie_cap(const pcireg_t *regs, int extcapoff) 3796 { 3797 int pcie_capoff; 3798 pcireg_t reg; 3799 int i, maxlinkwidth; 3800 3801 printf("\n Secondary PCI Express Register\n"); 3802 3803 reg = regs[o2i(extcapoff + PCI_SECPCIE_LCTL3)]; 3804 printf(" Link Control 3 register: 0x%08x\n", reg); 3805 onoff("Perform Equalization", reg, PCI_SECPCIE_LCTL3_PERFEQ); 3806 onoff("Link Equalization Request Interrupt Enable", 3807 reg, PCI_SECPCIE_LCTL3_LINKEQREQ_IE); 3808 printf(" Enable Lower SKP OS Generation Vector:"); 3809 pci_print_pcie_linkspeedvector( 3810 __SHIFTOUT(reg, PCI_SECPCIE_LCTL3_ELSKPOSGENV)); 3811 printf("\n"); 3812 3813 reg = regs[o2i(extcapoff + PCI_SECPCIE_LANEERR_STA)]; 3814 printf(" Lane Error Status register: 0x%08x\n", reg); 3815 3816 /* Get Max Link Width */ 3817 if (pci_conf_find_cap(regs, PCI_CAP_PCIEXPRESS, &pcie_capoff)) { 3818 reg = regs[o2i(pcie_capoff + PCIE_LCAP)]; 3819 maxlinkwidth = __SHIFTOUT(reg, PCIE_LCAP_MAX_WIDTH); 3820 } else { 3821 printf("error: falied to get PCIe capablity\n"); 3822 return; 3823 } 3824 for (i = 0; i < maxlinkwidth; i++) { 3825 reg = regs[o2i(extcapoff + PCI_SECPCIE_EQCTL(i))]; 3826 if (i % 2 != 0) 3827 reg >>= 16; 3828 else 3829 reg &= 0xffff; 3830 printf(" Equalization Control Register (Link %d): 0x%04x\n", 3831 i, reg); 3832 printf(" Downstream Port Transmit Preset: 0x%x\n", 3833 (pcireg_t)__SHIFTOUT(reg, 3834 PCI_SECPCIE_EQCTL_DP_XMIT_PRESET)); 3835 printf(" Downstream Port Receive Hint: 0x%x\n", 3836 (pcireg_t)__SHIFTOUT(reg, PCI_SECPCIE_EQCTL_DP_RCV_HINT)); 3837 printf(" Upstream Port Transmit Preset: 0x%x\n", 3838 (pcireg_t)__SHIFTOUT(reg, 3839 PCI_SECPCIE_EQCTL_UP_XMIT_PRESET)); 3840 printf(" Upstream Port Receive Hint: 0x%x\n", 3841 (pcireg_t)__SHIFTOUT(reg, PCI_SECPCIE_EQCTL_UP_RCV_HINT)); 3842 } 3843 } 3844 3845 /* XXX pci_conf_print_pmux_cap */ 3846 3847 static void 3848 pci_conf_print_pasid_cap(const pcireg_t *regs, int extcapoff) 3849 { 3850 pcireg_t reg, cap, ctl; 3851 unsigned int num; 3852 3853 printf("\n Process Address Space ID\n"); 3854 3855 reg = regs[o2i(extcapoff + PCI_PASID_CAP)]; 3856 cap = reg & 0xffff; 3857 ctl = reg >> 16; 3858 printf(" PASID Capability Register: 0x%04x\n", cap); 3859 onoff("Execute Permission Supported", reg, PCI_PASID_CAP_XPERM); 3860 onoff("Privileged Mode Supported", reg, PCI_PASID_CAP_PRIVMODE); 3861 num = (1 << __SHIFTOUT(reg, PCI_PASID_CAP_MAXPASIDW)) - 1; 3862 printf(" Max PASID Width: %u\n", num); 3863 3864 printf(" PASID Control Register: 0x%04x\n", ctl); 3865 onoff("PASID Enable", reg, PCI_PASID_CTL_PASID_EN); 3866 onoff("Execute Permission Enable", reg, PCI_PASID_CTL_XPERM_EN); 3867 onoff("Privileged Mode Enable", reg, PCI_PASID_CTL_PRIVMODE_EN); 3868 } 3869 3870 static void 3871 pci_conf_print_lnr_cap(const pcireg_t *regs, int extcapoff) 3872 { 3873 pcireg_t reg, cap, ctl; 3874 unsigned int num; 3875 3876 printf("\n LN Requester\n"); 3877 3878 reg = regs[o2i(extcapoff + PCI_LNR_CAP)]; 3879 cap = reg & 0xffff; 3880 ctl = reg >> 16; 3881 printf(" LNR Capability register: 0x%04x\n", cap); 3882 onoff("LNR-64 Supported", reg, PCI_LNR_CAP_64); 3883 onoff("LNR-128 Supported", reg, PCI_LNR_CAP_128); 3884 num = 1 << __SHIFTOUT(reg, PCI_LNR_CAP_REGISTMAX); 3885 printf(" LNR Registration MAX: %u\n", num); 3886 3887 printf(" LNR Control register: 0x%04x\n", ctl); 3888 onoff("LNR Enable", reg, PCI_LNR_CTL_EN); 3889 onoff("LNR CLS", reg, PCI_LNR_CTL_CLS); 3890 num = 1 << __SHIFTOUT(reg, PCI_LNR_CTL_REGISTLIM); 3891 printf(" LNR Registration Limit: %u\n", num); 3892 } 3893 3894 static void 3895 pci_conf_print_dpc_pio(pcireg_t r) 3896 { 3897 onoff("Cfg Request received UR Completion", r,PCI_DPC_RPPIO_CFGUR_CPL); 3898 onoff("Cfg Request received CA Completion", r,PCI_DPC_RPPIO_CFGCA_CPL); 3899 onoff("Cfg Request Completion Timeout", r, PCI_DPC_RPPIO_CFG_CTO); 3900 onoff("I/O Request received UR Completion", r, PCI_DPC_RPPIO_IOUR_CPL); 3901 onoff("I/O Request received CA Completion", r, PCI_DPC_RPPIO_IOCA_CPL); 3902 onoff("I/O Request Completion Timeout", r, PCI_DPC_RPPIO_IO_CTO); 3903 onoff("Mem Request received UR Completion", r,PCI_DPC_RPPIO_MEMUR_CPL); 3904 onoff("Mem Request received CA Completion", r,PCI_DPC_RPPIO_MEMCA_CPL); 3905 onoff("Mem Request Completion Timeout", r, PCI_DPC_RPPIO_MEM_CTO); 3906 } 3907 3908 static void 3909 pci_conf_print_dpc_cap(const pcireg_t *regs, int extcapoff) 3910 { 3911 pcireg_t reg, cap, ctl, stat, errsrc; 3912 const char *trigstr; 3913 bool rpext; 3914 3915 printf("\n Downstream Port Containment\n"); 3916 3917 reg = regs[o2i(extcapoff + PCI_DPC_CCR)]; 3918 cap = reg & 0xffff; 3919 ctl = reg >> 16; 3920 rpext = (reg & PCI_DPCCAP_RPEXT) ? true : false; 3921 printf(" DPC Capability register: 0x%04x\n", cap); 3922 printf(" DPC Interrupt Message Number: %02x\n", 3923 (unsigned int)(cap & PCI_DPCCAP_IMSGN)); 3924 onoff("RP Extensions for DPC", reg, PCI_DPCCAP_RPEXT); 3925 onoff("Poisoned TLP Egress Blocking Supported", reg, 3926 PCI_DPCCAP_POISONTLPEB); 3927 onoff("DPC Software Triggering Supported", reg, PCI_DPCCAP_SWTRIG); 3928 printf(" RP PIO Log Size: %u\n", 3929 (unsigned int)__SHIFTOUT(reg, PCI_DPCCAP_RPPIOLOGSZ)); 3930 onoff("DL_Active ERR_COR Signaling Supported", reg, 3931 PCI_DPCCAP_DLACTECORS); 3932 printf(" DPC Control register: 0x%04x\n", ctl); 3933 switch (__SHIFTOUT(reg, PCI_DPCCTL_TIRGEN)) { 3934 case 0: 3935 trigstr = "disabled"; 3936 break; 3937 case 1: 3938 trigstr = "enabled(ERR_FATAL)"; 3939 break; 3940 case 2: 3941 trigstr = "enabled(ERR_NONFATAL or ERR_FATAL)"; 3942 break; 3943 default: 3944 trigstr = "(reserverd)"; 3945 break; 3946 } 3947 printf(" DPC Trigger Enable: %s\n", trigstr); 3948 printf(" DPC Completion Control: %s Completion Status\n", 3949 (reg & PCI_DPCCTL_COMPCTL) 3950 ? "Unsupported Request(UR)" : "Completer Abort(CA)"); 3951 onoff("DPC Interrupt Enable", reg, PCI_DPCCTL_IE); 3952 onoff("DPC ERR_COR Enable", reg, PCI_DPCCTL_ERRCOREN); 3953 onoff("Poisoned TLP Egress Blocking Enable", reg, 3954 PCI_DPCCTL_POISONTLPEB); 3955 onoff("DPC Software Trigger", reg, PCI_DPCCTL_SWTRIG); 3956 onoff("DL_Active ERR_COR Enable", reg, PCI_DPCCTL_DLACTECOR); 3957 3958 reg = regs[o2i(extcapoff + PCI_DPC_STATESID)]; 3959 stat = reg & 0xffff; 3960 errsrc = reg >> 16; 3961 printf(" DPC Status register: 0x%04x\n", stat); 3962 onoff("DPC Trigger Status", reg, PCI_DPCSTAT_TSTAT); 3963 switch (__SHIFTOUT(reg, PCI_DPCSTAT_TREASON)) { 3964 case 0: 3965 trigstr = "an unmasked uncorrectable error"; 3966 break; 3967 case 1: 3968 trigstr = "receiving an ERR_NONFATAL"; 3969 break; 3970 case 2: 3971 trigstr = "receiving an ERR_FATAL"; 3972 break; 3973 case 3: 3974 trigstr = "DPC Trigger Reason Extension field"; 3975 break; 3976 } 3977 printf(" DPC Trigger Reason: Due to %s\n", trigstr); 3978 onoff("DPC Interrupt Status", reg, PCI_DPCSTAT_ISTAT); 3979 if (rpext) 3980 onoff("DPC RP Busy", reg, PCI_DPCSTAT_RPBUSY); 3981 switch (__SHIFTOUT(reg, PCI_DPCSTAT_TREASON)) { 3982 case 0: 3983 trigstr = "Due to RP PIO error"; 3984 break; 3985 case 1: 3986 trigstr = "Due to the DPC Software trigger bit"; 3987 break; 3988 default: 3989 trigstr = "(reserved)"; 3990 break; 3991 } 3992 printf(" DPC Trigger Reason Extension: %s\n", trigstr); 3993 if (rpext) 3994 printf(" RP PIO First Error Pointer: %02x\n", 3995 (unsigned int)__SHIFTOUT(reg, PCI_DPCSTAT_RPPIOFEP)); 3996 printf(" DPC Error Source ID register: 0x%04x\n", errsrc); 3997 3998 if (!rpext) 3999 return; 4000 /* 4001 * All of the following registers are implemented by a device which has 4002 * RP Extensions for DPC 4003 */ 4004 4005 reg = regs[o2i(extcapoff + PCI_DPC_RPPIO_STAT)]; 4006 printf(" RP PIO Status Register: 0x%08x\n", reg); 4007 pci_conf_print_dpc_pio(reg); 4008 4009 reg = regs[o2i(extcapoff + PCI_DPC_RPPIO_MASK)]; 4010 printf(" RP PIO Mask Register: 0x%08x\n", reg); 4011 pci_conf_print_dpc_pio(reg); 4012 4013 reg = regs[o2i(extcapoff + PCI_DPC_RPPIO_SEVE)]; 4014 printf(" RP PIO Severity Register: 0x%08x\n", reg); 4015 pci_conf_print_dpc_pio(reg); 4016 4017 reg = regs[o2i(extcapoff + PCI_DPC_RPPIO_SYSERR)]; 4018 printf(" RP PIO SysError Register: 0x%08x\n", reg); 4019 pci_conf_print_dpc_pio(reg); 4020 4021 reg = regs[o2i(extcapoff + PCI_DPC_RPPIO_EXCPT)]; 4022 printf(" RP PIO Exception Register: 0x%08x\n", reg); 4023 pci_conf_print_dpc_pio(reg); 4024 4025 printf(" RP PIO Header Log Register: start from 0x%03x\n", 4026 extcapoff + PCI_DPC_RPPIO_HLOG); 4027 printf(" RP PIO ImpSpec Log Register: start from 0x%03x\n", 4028 extcapoff + PCI_DPC_RPPIO_IMPSLOG); 4029 printf(" RP PIO TLP Prefix Log Register: start from 0x%03x\n", 4030 extcapoff + PCI_DPC_RPPIO_TLPPLOG); 4031 } 4032 4033 4034 static int 4035 pci_conf_l1pm_cap_tposcale(unsigned char scale) 4036 { 4037 4038 /* Return scale in us */ 4039 switch (scale) { 4040 case 0x0: 4041 return 2; 4042 case 0x1: 4043 return 10; 4044 case 0x2: 4045 return 100; 4046 default: 4047 return -1; 4048 } 4049 } 4050 4051 static void 4052 pci_conf_print_l1pm_cap(const pcireg_t *regs, int extcapoff) 4053 { 4054 pcireg_t reg; 4055 int scale, val; 4056 int pcie_capoff; 4057 4058 printf("\n L1 PM Substates\n"); 4059 4060 reg = regs[o2i(extcapoff + PCI_L1PM_CAP)]; 4061 printf(" L1 PM Substates Capability register: 0x%08x\n", reg); 4062 onoff("PCI-PM L1.2 Supported", reg, PCI_L1PM_CAP_PCIPM12); 4063 onoff("PCI-PM L1.1 Supported", reg, PCI_L1PM_CAP_PCIPM11); 4064 onoff("ASPM L1.2 Supported", reg, PCI_L1PM_CAP_ASPM12); 4065 onoff("ASPM L1.1 Supported", reg, PCI_L1PM_CAP_ASPM11); 4066 onoff("L1 PM Substates Supported", reg, PCI_L1PM_CAP_L1PM); 4067 /* The Link Activation Supported bit is only for Downstream Port */ 4068 if (pci_conf_find_cap(regs, PCI_CAP_PCIEXPRESS, &pcie_capoff)) { 4069 uint32_t t = regs[o2i(pcie_capoff)]; 4070 4071 if ((t == PCIE_XCAP_TYPE_ROOT) || (t == PCIE_XCAP_TYPE_DOWN)) 4072 onoff("Link Activation Supported", reg, 4073 PCI_L1PM_CAP_LA); 4074 } 4075 printf(" Port Common Mode Restore Time: %uus\n", 4076 (unsigned int)__SHIFTOUT(reg, PCI_L1PM_CAP_PCMRT)); 4077 scale = pci_conf_l1pm_cap_tposcale( 4078 __SHIFTOUT(reg, PCI_L1PM_CAP_PTPOSCALE)); 4079 val = __SHIFTOUT(reg, PCI_L1PM_CAP_PTPOVAL); 4080 printf(" Port T_POWER_ON: "); 4081 if (scale == -1) 4082 printf("unknown\n"); 4083 else 4084 printf("%dus\n", val * scale); 4085 4086 reg = regs[o2i(extcapoff + PCI_L1PM_CTL1)]; 4087 printf(" L1 PM Substates Control register 1: 0x%08x\n", reg); 4088 onoff("PCI-PM L1.2 Enable", reg, PCI_L1PM_CTL1_PCIPM12_EN); 4089 onoff("PCI-PM L1.1 Enable", reg, PCI_L1PM_CTL1_PCIPM11_EN); 4090 onoff("ASPM L1.2 Enable", reg, PCI_L1PM_CTL1_ASPM12_EN); 4091 onoff("ASPM L1.1 Enable", reg, PCI_L1PM_CTL1_ASPM11_EN); 4092 onoff("Link Activation Interrupt Enable", reg, PCI_L1PM_CTL1_LAIE); 4093 onoff("Link Activation Control", reg, PCI_L1PM_CTL1_LA); 4094 printf(" Common Mode Restore Time: %uus\n", 4095 (unsigned int)__SHIFTOUT(reg, PCI_L1PM_CTL1_CMRT)); 4096 scale = PCI_LTR_SCALETONS(__SHIFTOUT(reg, PCI_L1PM_CTL1_LTRTHSCALE)); 4097 val = __SHIFTOUT(reg, PCI_L1PM_CTL1_LTRTHVAL); 4098 printf(" LTR L1.2 THRESHOLD: %dus\n", val * scale); 4099 4100 reg = regs[o2i(extcapoff + PCI_L1PM_CTL2)]; 4101 printf(" L1 PM Substates Control register 2: 0x%08x\n", reg); 4102 scale = pci_conf_l1pm_cap_tposcale( 4103 __SHIFTOUT(reg, PCI_L1PM_CTL2_TPOSCALE)); 4104 val = __SHIFTOUT(reg, PCI_L1PM_CTL2_TPOVAL); 4105 printf(" T_POWER_ON: "); 4106 if (scale == -1) 4107 printf("unknown\n"); 4108 else 4109 printf("%dus\n", val * scale); 4110 4111 if (PCI_EXTCAPLIST_VERSION(regs[o2i(extcapoff)]) >= 2) { 4112 reg = regs[o2i(extcapoff + PCI_L1PM_CTL2)]; 4113 printf(" L1 PM Substates Status register: 0x%08x\n", reg); 4114 onoff("Link Activation Status", reg, PCI_L1PM_STAT_LA); 4115 } 4116 } 4117 4118 static void 4119 pci_conf_print_ptm_cap(const pcireg_t *regs, int extcapoff) 4120 { 4121 pcireg_t reg; 4122 uint32_t val; 4123 4124 printf("\n Precision Time Management\n"); 4125 4126 reg = regs[o2i(extcapoff + PCI_PTM_CAP)]; 4127 printf(" PTM Capability register: 0x%08x\n", reg); 4128 onoff("PTM Requester Capable", reg, PCI_PTM_CAP_REQ); 4129 onoff("PTM Responder Capable", reg, PCI_PTM_CAP_RESP); 4130 onoff("PTM Root Capable", reg, PCI_PTM_CAP_ROOT); 4131 printf(" Local Clock Granularity: "); 4132 val = __SHIFTOUT(reg, PCI_PTM_CAP_LCLCLKGRNL); 4133 switch (val) { 4134 case 0: 4135 printf("Not implemented\n"); 4136 break; 4137 case 0xffff: 4138 printf("> 254ns\n"); 4139 break; 4140 default: 4141 printf("%uns\n", val); 4142 break; 4143 } 4144 4145 reg = regs[o2i(extcapoff + PCI_PTM_CTL)]; 4146 printf(" PTM Control register: 0x%08x\n", reg); 4147 onoff("PTM Enable", reg, PCI_PTM_CTL_EN); 4148 onoff("Root Select", reg, PCI_PTM_CTL_ROOTSEL); 4149 printf(" Effective Granularity: "); 4150 val = __SHIFTOUT(reg, PCI_PTM_CTL_EFCTGRNL); 4151 switch (val) { 4152 case 0: 4153 printf("Unknown\n"); 4154 break; 4155 case 0xffff: 4156 printf("> 254ns\n"); 4157 break; 4158 default: 4159 printf("%uns\n", val); 4160 break; 4161 } 4162 } 4163 4164 /* XXX pci_conf_print_mpcie_cap */ 4165 /* XXX pci_conf_print_frsq_cap */ 4166 /* XXX pci_conf_print_rtr_cap */ 4167 /* XXX pci_conf_print_desigvndsp_cap */ 4168 /* XXX pci_conf_print_vf_resizbar_cap */ 4169 4170 static void 4171 pci_conf_print_dlf_cap(const pcireg_t *regs, int extcapoff) 4172 { 4173 pcireg_t reg; 4174 4175 printf("\n Data link Feature Register\n"); 4176 reg = regs[o2i(extcapoff + PCI_DLF_CAP)]; 4177 printf(" Capability register: 0x%08x\n", reg); 4178 onoff("Scaled Flow Control", reg, PCI_DLF_LFEAT_SCLFCTL); 4179 onoff("DLF Exchange enable", reg, PCI_DLF_CAP_XCHG); 4180 4181 reg = regs[o2i(extcapoff + PCI_DLF_STAT)]; 4182 printf(" Status register: 0x%08x\n", reg); 4183 onoff("Scaled Flow Control", reg, PCI_DLF_LFEAT_SCLFCTL); 4184 onoff("Remote DLF supported Valid", reg, PCI_DLF_STAT_RMTVALID); 4185 } 4186 4187 /* XXX pci_conf_print_hierarchyid_cap */ 4188 /* XXX pci_conf_print_npem_cap */ 4189 4190 #undef MS 4191 #undef SM 4192 #undef RW 4193 4194 static struct { 4195 pcireg_t cap; 4196 const char *name; 4197 void (*printfunc)(const pcireg_t *, int); 4198 } pci_extcaptab[] = { 4199 { 0, "reserved", 4200 NULL }, 4201 { PCI_EXTCAP_AER, "Advanced Error Reporting", 4202 pci_conf_print_aer_cap }, 4203 { PCI_EXTCAP_VC, "Virtual Channel", 4204 pci_conf_print_vc_cap }, 4205 { PCI_EXTCAP_SERNUM, "Device Serial Number", 4206 pci_conf_print_sernum_cap }, 4207 { PCI_EXTCAP_PWRBDGT, "Power Budgeting", 4208 pci_conf_print_pwrbdgt_cap }, 4209 { PCI_EXTCAP_RCLINK_DCL,"Root Complex Link Declaration", 4210 pci_conf_print_rclink_dcl_cap }, 4211 { PCI_EXTCAP_RCLINK_CTL,"Root Complex Internal Link Control", 4212 NULL }, 4213 { PCI_EXTCAP_RCEC_ASSOC,"Root Complex Event Collector Association", 4214 pci_conf_print_rcec_assoc_cap }, 4215 { PCI_EXTCAP_MFVC, "Multi-Function Virtual Channel", 4216 NULL }, 4217 { PCI_EXTCAP_VC2, "Virtual Channel", 4218 NULL }, 4219 { PCI_EXTCAP_RCRB, "RCRB Header", 4220 NULL }, 4221 { PCI_EXTCAP_VENDOR, "Vendor Unique", 4222 NULL }, 4223 { PCI_EXTCAP_CAC, "Configuration Access Correction", 4224 NULL }, 4225 { PCI_EXTCAP_ACS, "Access Control Services", 4226 pci_conf_print_acs_cap }, 4227 { PCI_EXTCAP_ARI, "Alternative Routing-ID Interpretation", 4228 pci_conf_print_ari_cap }, 4229 { PCI_EXTCAP_ATS, "Address Translation Services", 4230 pci_conf_print_ats_cap }, 4231 { PCI_EXTCAP_SRIOV, "Single Root IO Virtualization", 4232 pci_conf_print_sriov_cap }, 4233 { PCI_EXTCAP_MRIOV, "Multiple Root IO Virtualization", 4234 NULL }, 4235 { PCI_EXTCAP_MCAST, "Multicast", 4236 pci_conf_print_multicast_cap }, 4237 { PCI_EXTCAP_PAGE_REQ, "Page Request", 4238 pci_conf_print_page_req_cap }, 4239 { PCI_EXTCAP_AMD, "Reserved for AMD", 4240 NULL }, 4241 { PCI_EXTCAP_RESIZBAR, "Resizable BAR", 4242 pci_conf_print_resizbar_cap }, 4243 { PCI_EXTCAP_DPA, "Dynamic Power Allocation", 4244 pci_conf_print_dpa_cap }, 4245 { PCI_EXTCAP_TPH_REQ, "TPH Requester", 4246 pci_conf_print_tph_req_cap }, 4247 { PCI_EXTCAP_LTR, "Latency Tolerance Reporting", 4248 pci_conf_print_ltr_cap }, 4249 { PCI_EXTCAP_SEC_PCIE, "Secondary PCI Express", 4250 pci_conf_print_sec_pcie_cap }, 4251 { PCI_EXTCAP_PMUX, "Protocol Multiplexing", 4252 NULL }, 4253 { PCI_EXTCAP_PASID, "Process Address Space ID", 4254 pci_conf_print_pasid_cap }, 4255 { PCI_EXTCAP_LNR, "LN Requester", 4256 pci_conf_print_lnr_cap }, 4257 { PCI_EXTCAP_DPC, "Downstream Port Containment", 4258 pci_conf_print_dpc_cap }, 4259 { PCI_EXTCAP_L1PM, "L1 PM Substates", 4260 pci_conf_print_l1pm_cap }, 4261 { PCI_EXTCAP_PTM, "Precision Time Management", 4262 pci_conf_print_ptm_cap }, 4263 { PCI_EXTCAP_MPCIE, "M-PCIe", 4264 NULL }, 4265 { PCI_EXTCAP_FRSQ, "Function Reading Status Queueing", 4266 NULL }, 4267 { PCI_EXTCAP_RTR, "Readiness Time Reporting", 4268 NULL }, 4269 { PCI_EXTCAP_DESIGVNDSP, "Designated Vendor-Specific", 4270 NULL }, 4271 { PCI_EXTCAP_VF_RESIZBAR, "VF Resizable BARs", 4272 NULL }, 4273 { PCI_EXTCAP_DLF, "Data link Feature", pci_conf_print_dlf_cap }, 4274 { PCI_EXTCAP_PYSLAY_16GT, "Physical Layer 16.0 GT/s", NULL }, 4275 { 0x27, "unknown", NULL }, 4276 { PCI_EXTCAP_HIERARCHYID, "Hierarchy ID", 4277 NULL }, 4278 { PCI_EXTCAP_NPEM, "Native PCIe Enclosure Management", 4279 NULL }, 4280 }; 4281 4282 static int 4283 pci_conf_find_extcap(const pcireg_t *regs, unsigned int capid, int *offsetp) 4284 { 4285 int off; 4286 pcireg_t rval; 4287 4288 for (off = PCI_EXTCAPLIST_BASE; 4289 off != 0; 4290 off = PCI_EXTCAPLIST_NEXT(rval)) { 4291 rval = regs[o2i(off)]; 4292 if (capid == PCI_EXTCAPLIST_CAP(rval)) { 4293 if (offsetp != NULL) 4294 *offsetp = off; 4295 return 1; 4296 } 4297 } 4298 return 0; 4299 } 4300 4301 static void 4302 pci_conf_print_extcaplist( 4303 #ifdef _KERNEL 4304 pci_chipset_tag_t pc, pcitag_t tag, 4305 #endif 4306 const pcireg_t *regs) 4307 { 4308 int off; 4309 pcireg_t foundcap; 4310 pcireg_t rval; 4311 bool foundtable[__arraycount(pci_extcaptab)]; 4312 unsigned int i; 4313 4314 /* Check Extended capability structure */ 4315 off = PCI_EXTCAPLIST_BASE; 4316 rval = regs[o2i(off)]; 4317 if (rval == 0xffffffff || rval == 0) 4318 return; 4319 4320 /* Clear table */ 4321 for (i = 0; i < __arraycount(pci_extcaptab); i++) 4322 foundtable[i] = false; 4323 4324 /* Print extended capability register's offset and the type first */ 4325 for (;;) { 4326 printf(" Extended Capability Register at 0x%02x\n", off); 4327 4328 foundcap = PCI_EXTCAPLIST_CAP(rval); 4329 printf(" type: 0x%04x (", foundcap); 4330 if (foundcap < __arraycount(pci_extcaptab)) { 4331 printf("%s)\n", pci_extcaptab[foundcap].name); 4332 /* Mark as found */ 4333 foundtable[foundcap] = true; 4334 } else 4335 printf("unknown)\n"); 4336 printf(" version: %d\n", PCI_EXTCAPLIST_VERSION(rval)); 4337 4338 off = PCI_EXTCAPLIST_NEXT(rval); 4339 if (off == 0) 4340 break; 4341 else if (off <= PCI_CONF_SIZE) { 4342 printf(" next pointer: 0x%03x (incorrect)\n", off); 4343 return; 4344 } 4345 rval = regs[o2i(off)]; 4346 } 4347 4348 /* 4349 * And then, print the detail of each capability registers 4350 * in capability value's order. 4351 */ 4352 for (i = 0; i < __arraycount(pci_extcaptab); i++) { 4353 if (foundtable[i] == false) 4354 continue; 4355 4356 /* 4357 * The type was found. Search capability list again and 4358 * print all capabilities that the capabiliy type is 4359 * the same. 4360 */ 4361 if (pci_conf_find_extcap(regs, i, &off) == 0) 4362 continue; 4363 rval = regs[o2i(off)]; 4364 if ((PCI_EXTCAPLIST_VERSION(rval) <= 0) 4365 || (pci_extcaptab[i].printfunc == NULL)) 4366 continue; 4367 4368 pci_extcaptab[i].printfunc(regs, off); 4369 4370 } 4371 } 4372 4373 /* Print the Secondary Status Register. */ 4374 static void 4375 pci_conf_print_ssr(pcireg_t rval) 4376 { 4377 pcireg_t devsel; 4378 4379 printf(" Secondary status register: 0x%04x\n", rval); /* XXX bits */ 4380 onoff("66 MHz capable", rval, __BIT(5)); 4381 onoff("User Definable Features (UDF) support", rval, __BIT(6)); 4382 onoff("Fast back-to-back capable", rval, __BIT(7)); 4383 onoff("Data parity error detected", rval, __BIT(8)); 4384 4385 printf(" DEVSEL timing: "); 4386 devsel = __SHIFTOUT(rval, __BITS(10, 9)); 4387 switch (devsel) { 4388 case 0: 4389 printf("fast"); 4390 break; 4391 case 1: 4392 printf("medium"); 4393 break; 4394 case 2: 4395 printf("slow"); 4396 break; 4397 default: 4398 printf("unknown/reserved"); /* XXX */ 4399 break; 4400 } 4401 printf(" (0x%x)\n", devsel); 4402 4403 onoff("Signalled target abort", rval, __BIT(11)); 4404 onoff("Received target abort", rval, __BIT(12)); 4405 onoff("Received master abort", rval, __BIT(13)); 4406 onoff("Received system error", rval, __BIT(14)); 4407 onoff("Detected parity error", rval, __BIT(15)); 4408 } 4409 4410 static void 4411 pci_conf_print_type0( 4412 #ifdef _KERNEL 4413 pci_chipset_tag_t pc, pcitag_t tag, 4414 #endif 4415 const pcireg_t *regs) 4416 { 4417 int off, width; 4418 pcireg_t rval; 4419 const char *str; 4420 4421 for (off = PCI_MAPREG_START; off < PCI_MAPREG_END; off += width) { 4422 #ifdef _KERNEL 4423 width = pci_conf_print_bar(pc, tag, regs, off, NULL); 4424 #else 4425 width = pci_conf_print_bar(regs, off, NULL); 4426 #endif 4427 } 4428 4429 printf(" Cardbus CIS Pointer: 0x%08x\n", 4430 regs[o2i(PCI_CARDBUS_CIS_REG)]); 4431 4432 rval = regs[o2i(PCI_SUBSYS_ID_REG)]; 4433 printf(" Subsystem vendor ID: 0x%04x\n", PCI_VENDOR(rval)); 4434 printf(" Subsystem ID: 0x%04x\n", PCI_PRODUCT(rval)); 4435 4436 rval = regs[o2i(PCI_MAPREG_ROM)]; 4437 printf(" Expansion ROM Base Address Register: 0x%08x\n", rval); 4438 printf(" base: 0x%08x\n", (uint32_t)PCI_MAPREG_ROM_ADDR(rval)); 4439 onoff("Expansion ROM Enable", rval, PCI_MAPREG_ROM_ENABLE); 4440 printf(" Validation Status: "); 4441 switch (__SHIFTOUT(rval, PCI_MAPREG_ROM_VALID_STAT)) { 4442 case PCI_MAPREG_ROM_VSTAT_NOTSUPP: 4443 str = "Validation not supported"; 4444 break; 4445 case PCI_MAPREG_ROM_VSTAT_INPROG: 4446 str = "Validation in Progress"; 4447 break; 4448 case PCI_MAPREG_ROM_VSTAT_VPASS: 4449 str = "Validation Pass. " 4450 "Valid contents, trust test was not performed"; 4451 break; 4452 case PCI_MAPREG_ROM_VSTAT_VPASSTRUST: 4453 str = "Validation Pass. Valid and trusted contents"; 4454 break; 4455 case PCI_MAPREG_ROM_VSTAT_VFAIL: 4456 str = "Validation Fail. Invalid contents"; 4457 break; 4458 case PCI_MAPREG_ROM_VSTAT_VFAILUNTRUST: 4459 str = "Validation Fail. Valid but untrusted contents"; 4460 break; 4461 case PCI_MAPREG_ROM_VSTAT_WPASS: 4462 str = "Warning Pass. Validation passed with warning. " 4463 "Valid contents, trust test was not performed"; 4464 break; 4465 case PCI_MAPREG_ROM_VSTAT_WPASSTRUST: 4466 str = "Warning Pass. Validation passed with warning. " 4467 "Valid and trusted contents"; 4468 break; 4469 } 4470 printf("%s\n", str); 4471 printf(" Validation Details: 0x%x\n", 4472 (uint32_t)__SHIFTOUT(rval, PCI_MAPREG_ROM_VALID_DETAIL)); 4473 4474 if (regs[o2i(PCI_COMMAND_STATUS_REG)] & PCI_STATUS_CAPLIST_SUPPORT) 4475 printf(" Capability list pointer: 0x%02x\n", 4476 PCI_CAPLIST_PTR(regs[o2i(PCI_CAPLISTPTR_REG)])); 4477 else 4478 printf(" Reserved @ 0x34: 0x%08x\n", regs[o2i(0x34)]); 4479 4480 printf(" Reserved @ 0x38: 0x%08x\n", regs[o2i(0x38)]); 4481 4482 rval = regs[o2i(PCI_INTERRUPT_REG)]; 4483 printf(" Maximum Latency: 0x%02x\n", PCI_MAX_LAT(rval)); 4484 printf(" Minimum Grant: 0x%02x\n", PCI_MIN_GNT(rval)); 4485 printf(" Interrupt pin: 0x%02x ", PCI_INTERRUPT_PIN(rval)); 4486 switch (PCI_INTERRUPT_PIN(rval)) { 4487 case PCI_INTERRUPT_PIN_NONE: 4488 printf("(none)"); 4489 break; 4490 case PCI_INTERRUPT_PIN_A: 4491 printf("(pin A)"); 4492 break; 4493 case PCI_INTERRUPT_PIN_B: 4494 printf("(pin B)"); 4495 break; 4496 case PCI_INTERRUPT_PIN_C: 4497 printf("(pin C)"); 4498 break; 4499 case PCI_INTERRUPT_PIN_D: 4500 printf("(pin D)"); 4501 break; 4502 default: 4503 printf("(? ? ?)"); 4504 break; 4505 } 4506 printf("\n"); 4507 printf(" Interrupt line: 0x%02x\n", PCI_INTERRUPT_LINE(rval)); 4508 } 4509 4510 static void 4511 pci_conf_print_type1( 4512 #ifdef _KERNEL 4513 pci_chipset_tag_t pc, pcitag_t tag, 4514 #endif 4515 const pcireg_t *regs) 4516 { 4517 int off, width; 4518 pcireg_t rval, csreg; 4519 uint32_t base, limit; 4520 uint32_t base_h, limit_h; 4521 uint64_t pbase, plimit; 4522 int use_upper; 4523 4524 /* 4525 * This layout was cribbed from the TI PCI2030 PCI-to-PCI 4526 * Bridge chip documentation, and may not be correct with 4527 * respect to various standards. (XXX) 4528 */ 4529 4530 for (off = 0x10; off < 0x18; off += width) { 4531 #ifdef _KERNEL 4532 width = pci_conf_print_bar(pc, tag, regs, off, NULL); 4533 #else 4534 width = pci_conf_print_bar(regs, off, NULL); 4535 #endif 4536 } 4537 4538 rval = regs[o2i(PCI_BRIDGE_BUS_REG)]; 4539 printf(" Primary bus number: 0x%02x\n", 4540 PCI_BRIDGE_BUS_NUM_PRIMARY(rval)); 4541 printf(" Secondary bus number: 0x%02x\n", 4542 PCI_BRIDGE_BUS_NUM_SECONDARY(rval)); 4543 printf(" Subordinate bus number: 0x%02x\n", 4544 PCI_BRIDGE_BUS_NUM_SUBORDINATE(rval)); 4545 printf(" Secondary bus latency timer: 0x%02x\n", 4546 PCI_BRIDGE_BUS_SEC_LATTIMER_VAL(rval)); 4547 4548 rval = regs[o2i(PCI_BRIDGE_STATIO_REG)]; 4549 pci_conf_print_ssr(__SHIFTOUT(rval, __BITS(31, 16))); 4550 4551 /* I/O region */ 4552 printf(" I/O region:\n"); 4553 printf(" base register: 0x%02x\n", (rval >> 0) & 0xff); 4554 printf(" limit register: 0x%02x\n", (rval >> 8) & 0xff); 4555 if (PCI_BRIDGE_IO_32BITS(rval)) 4556 use_upper = 1; 4557 else 4558 use_upper = 0; 4559 onoff("32bit I/O", rval, use_upper); 4560 base = PCI_BRIDGE_STATIO_IOBASE_ADDR(rval); 4561 limit = PCI_BRIDGE_STATIO_IOLIMIT_ADDR(rval); 4562 4563 rval = regs[o2i(PCI_BRIDGE_IOHIGH_REG)]; 4564 base_h = __SHIFTOUT(rval, PCI_BRIDGE_IOHIGH_BASE); 4565 limit_h = __SHIFTOUT(rval, PCI_BRIDGE_IOHIGH_LIMIT); 4566 printf(" base upper 16 bits register: 0x%04x\n", base_h); 4567 printf(" limit upper 16 bits register: 0x%04x\n", limit_h); 4568 4569 if (use_upper == 1) { 4570 base |= base_h << 16; 4571 limit |= limit_h << 16; 4572 } 4573 if (base < limit) { 4574 if (use_upper == 1) 4575 printf(" range: 0x%08x-0x%08x\n", base, limit); 4576 else 4577 printf(" range: 0x%04x-0x%04x\n", base, limit); 4578 } else 4579 printf(" range: not set\n"); 4580 4581 /* Non-prefetchable memory region */ 4582 rval = regs[o2i(PCI_BRIDGE_MEMORY_REG)]; 4583 printf(" Memory region:\n"); 4584 printf(" base register: 0x%04hx\n", 4585 (uint16_t)__SHIFTOUT(rval, PCI_BRIDGE_MEMORY_BASE)); 4586 printf(" limit register: 0x%04hx\n", 4587 (uint16_t)__SHIFTOUT(rval, PCI_BRIDGE_MEMORY_LIMIT)); 4588 base = PCI_BRIDGE_MEMORY_BASE_ADDR(rval); 4589 limit = PCI_BRIDGE_MEMORY_LIMIT_ADDR(rval); 4590 if (base < limit) 4591 printf(" range: 0x%08x-0x%08x\n", base, limit); 4592 else 4593 printf(" range: not set\n"); 4594 4595 /* Prefetchable memory region */ 4596 rval = regs[o2i(PCI_BRIDGE_PREFETCHMEM_REG)]; 4597 printf(" Prefetchable memory region:\n"); 4598 printf(" base register: 0x%04x\n", 4599 (rval >> 0) & 0xffff); 4600 printf(" limit register: 0x%04x\n", 4601 (rval >> 16) & 0xffff); 4602 base_h = regs[o2i(PCI_BRIDGE_PREFETCHBASEUP32_REG)]; 4603 limit_h = regs[o2i(PCI_BRIDGE_PREFETCHLIMITUP32_REG)]; 4604 printf(" base upper 32 bits register: 0x%08x\n", 4605 base_h); 4606 printf(" limit upper 32 bits register: 0x%08x\n", 4607 limit_h); 4608 if (PCI_BRIDGE_PREFETCHMEM_64BITS(rval)) 4609 use_upper = 1; 4610 else 4611 use_upper = 0; 4612 onoff("64bit memory address", rval, use_upper); 4613 pbase = PCI_BRIDGE_PREFETCHMEM_BASE_ADDR(rval); 4614 plimit = PCI_BRIDGE_PREFETCHMEM_LIMIT_ADDR(rval); 4615 if (use_upper == 1) { 4616 pbase |= (uint64_t)base_h << 32; 4617 plimit |= (uint64_t)limit_h << 32; 4618 } 4619 if (pbase < plimit) { 4620 if (use_upper == 1) 4621 printf(" range: 0x%016" PRIx64 "-0x%016" PRIx64 4622 "\n", pbase, plimit); 4623 else 4624 printf(" range: 0x%08x-0x%08x\n", 4625 (uint32_t)pbase, (uint32_t)plimit); 4626 } else 4627 printf(" range: not set\n"); 4628 4629 csreg = regs[o2i(PCI_COMMAND_STATUS_REG)]; 4630 if (csreg & PCI_STATUS_CAPLIST_SUPPORT) 4631 printf(" Capability list pointer: 0x%02x\n", 4632 PCI_CAPLIST_PTR(regs[o2i(PCI_CAPLISTPTR_REG)])); 4633 else 4634 printf(" Reserved @ 0x34: 0x%08x\n", regs[o2i(0x34)]); 4635 4636 printf(" Expansion ROM Base Address: 0x%08x\n", 4637 regs[o2i(PCI_BRIDGE_EXPROMADDR_REG)]); 4638 4639 rval = regs[o2i(PCI_INTERRUPT_REG)]; 4640 printf(" Interrupt line: 0x%02x\n", 4641 (rval >> 0) & 0xff); 4642 printf(" Interrupt pin: 0x%02x ", 4643 (rval >> 8) & 0xff); 4644 switch ((rval >> 8) & 0xff) { 4645 case PCI_INTERRUPT_PIN_NONE: 4646 printf("(none)"); 4647 break; 4648 case PCI_INTERRUPT_PIN_A: 4649 printf("(pin A)"); 4650 break; 4651 case PCI_INTERRUPT_PIN_B: 4652 printf("(pin B)"); 4653 break; 4654 case PCI_INTERRUPT_PIN_C: 4655 printf("(pin C)"); 4656 break; 4657 case PCI_INTERRUPT_PIN_D: 4658 printf("(pin D)"); 4659 break; 4660 default: 4661 printf("(? ? ?)"); 4662 break; 4663 } 4664 printf("\n"); 4665 rval = regs[o2i(PCI_BRIDGE_CONTROL_REG)]; 4666 printf(" Bridge control register: 0x%04hx\n", 4667 (uint16_t)__SHIFTOUT(rval, PCI_BRIDGE_CONTROL)); 4668 onoff("Parity error response", rval, PCI_BRIDGE_CONTROL_PERE); 4669 onoff("Secondary SERR forwarding", rval, PCI_BRIDGE_CONTROL_SERR); 4670 onoff("ISA enable", rval, PCI_BRIDGE_CONTROL_ISA); 4671 onoff("VGA enable", rval, PCI_BRIDGE_CONTROL_VGA); 4672 /* 4673 * VGA 16bit decode bit has meaning if the VGA enable bit or the 4674 * VGA Palette Snoop Enable bit is set. 4675 */ 4676 if (((rval & PCI_BRIDGE_CONTROL_VGA) != 0) 4677 || ((csreg & PCI_COMMAND_PALETTE_ENABLE) != 0)) 4678 onoff("VGA 16bit enable", rval, PCI_BRIDGE_CONTROL_VGA16); 4679 onoff("Master abort reporting", rval, PCI_BRIDGE_CONTROL_MABRT); 4680 onoff("Secondary bus reset", rval, PCI_BRIDGE_CONTROL_SECBR); 4681 onoff("Fast back-to-back enable", rval, PCI_BRIDGE_CONTROL_SECFASTB2B); 4682 onoff("Primary Discard Timer", rval, 4683 PCI_BRIDGE_CONTROL_PRI_DISC_TIMER); 4684 onoff("Secondary Discard Timer", 4685 rval, PCI_BRIDGE_CONTROL_SEC_DISC_TIMER); 4686 onoff("Discard Timer Status", rval, 4687 PCI_BRIDGE_CONTROL_DISC_TIMER_STAT); 4688 onoff("Discard Timer SERR# Enable", rval, 4689 PCI_BRIDGE_CONTROL_DISC_TIMER_SERR); 4690 } 4691 4692 static void 4693 pci_conf_print_type2( 4694 #ifdef _KERNEL 4695 pci_chipset_tag_t pc, pcitag_t tag, 4696 #endif 4697 const pcireg_t *regs) 4698 { 4699 pcireg_t rval; 4700 4701 /* 4702 * XXX these need to be printed in more detail, need to be 4703 * XXX checked against specs/docs, etc. 4704 * 4705 * This layout was cribbed from the TI PCI1420 PCI-to-CardBus 4706 * controller chip documentation, and may not be correct with 4707 * respect to various standards. (XXX) 4708 */ 4709 4710 #ifdef _KERNEL 4711 pci_conf_print_bar(pc, tag, regs, 0x10, 4712 "CardBus socket/ExCA registers"); 4713 #else 4714 pci_conf_print_bar(regs, 0x10, "CardBus socket/ExCA registers"); 4715 #endif 4716 4717 /* Capability list pointer and secondary status register */ 4718 rval = regs[o2i(PCI_CARDBUS_CAPLISTPTR_REG)]; 4719 if (regs[o2i(PCI_COMMAND_STATUS_REG)] & PCI_STATUS_CAPLIST_SUPPORT) 4720 printf(" Capability list pointer: 0x%02x\n", 4721 PCI_CAPLIST_PTR(rval)); 4722 else 4723 printf(" Reserved @ 0x14: 0x%04x\n", 4724 (pcireg_t)__SHIFTOUT(rval, __BITS(15, 0))); 4725 pci_conf_print_ssr(__SHIFTOUT(rval, __BITS(31, 16))); 4726 4727 rval = regs[o2i(PCI_BRIDGE_BUS_REG)]; 4728 printf(" PCI bus number: 0x%02x\n", 4729 (rval >> 0) & 0xff); 4730 printf(" CardBus bus number: 0x%02x\n", 4731 (rval >> 8) & 0xff); 4732 printf(" Subordinate bus number: 0x%02x\n", 4733 (rval >> 16) & 0xff); 4734 printf(" CardBus latency timer: 0x%02x\n", 4735 (rval >> 24) & 0xff); 4736 4737 /* XXX Print more prettily */ 4738 printf(" CardBus memory region 0:\n"); 4739 printf(" base register: 0x%08x\n", regs[o2i(0x1c)]); 4740 printf(" limit register: 0x%08x\n", regs[o2i(0x20)]); 4741 printf(" CardBus memory region 1:\n"); 4742 printf(" base register: 0x%08x\n", regs[o2i(0x24)]); 4743 printf(" limit register: 0x%08x\n", regs[o2i(0x28)]); 4744 printf(" CardBus I/O region 0:\n"); 4745 printf(" base register: 0x%08x\n", regs[o2i(0x2c)]); 4746 printf(" limit register: 0x%08x\n", regs[o2i(0x30)]); 4747 printf(" CardBus I/O region 1:\n"); 4748 printf(" base register: 0x%08x\n", regs[o2i(0x34)]); 4749 printf(" limit register: 0x%08x\n", regs[o2i(0x38)]); 4750 4751 rval = regs[o2i(PCI_INTERRUPT_REG)]; 4752 printf(" Interrupt line: 0x%02x\n", 4753 (rval >> 0) & 0xff); 4754 printf(" Interrupt pin: 0x%02x ", 4755 (rval >> 8) & 0xff); 4756 switch ((rval >> 8) & 0xff) { 4757 case PCI_INTERRUPT_PIN_NONE: 4758 printf("(none)"); 4759 break; 4760 case PCI_INTERRUPT_PIN_A: 4761 printf("(pin A)"); 4762 break; 4763 case PCI_INTERRUPT_PIN_B: 4764 printf("(pin B)"); 4765 break; 4766 case PCI_INTERRUPT_PIN_C: 4767 printf("(pin C)"); 4768 break; 4769 case PCI_INTERRUPT_PIN_D: 4770 printf("(pin D)"); 4771 break; 4772 default: 4773 printf("(? ? ?)"); 4774 break; 4775 } 4776 printf("\n"); 4777 rval = (regs[o2i(PCI_BRIDGE_CONTROL_REG)] >> 16) & 0xffff; 4778 printf(" Bridge control register: 0x%04x\n", rval); 4779 onoff("Parity error response", rval, __BIT(0)); 4780 onoff("SERR# enable", rval, __BIT(1)); 4781 onoff("ISA enable", rval, __BIT(2)); 4782 onoff("VGA enable", rval, __BIT(3)); 4783 onoff("Master abort mode", rval, __BIT(5)); 4784 onoff("Secondary (CardBus) bus reset", rval, __BIT(6)); 4785 onoff("Functional interrupts routed by ExCA registers", rval, 4786 __BIT(7)); 4787 onoff("Memory window 0 prefetchable", rval, __BIT(8)); 4788 onoff("Memory window 1 prefetchable", rval, __BIT(9)); 4789 onoff("Write posting enable", rval, __BIT(10)); 4790 4791 rval = regs[o2i(0x40)]; 4792 printf(" Subsystem vendor ID: 0x%04x\n", PCI_VENDOR(rval)); 4793 printf(" Subsystem ID: 0x%04x\n", PCI_PRODUCT(rval)); 4794 4795 #ifdef _KERNEL 4796 pci_conf_print_bar(pc, tag, regs, 0x44, "legacy-mode registers"); 4797 #else 4798 pci_conf_print_bar(regs, 0x44, "legacy-mode registers"); 4799 #endif 4800 } 4801 4802 void 4803 pci_conf_print( 4804 #ifdef _KERNEL 4805 pci_chipset_tag_t pc, pcitag_t tag, 4806 void (*printfn)(pci_chipset_tag_t, pcitag_t, const pcireg_t *) 4807 #else 4808 int pcifd, u_int bus, u_int dev, u_int func 4809 #endif 4810 ) 4811 { 4812 pcireg_t regs[o2i(PCI_EXTCONF_SIZE)]; 4813 int off, capoff, endoff, hdrtype; 4814 const char *type_name; 4815 #ifdef _KERNEL 4816 void (*type_printfn)(pci_chipset_tag_t, pcitag_t, const pcireg_t *); 4817 #else 4818 void (*type_printfn)(const pcireg_t *); 4819 #endif 4820 4821 printf("PCI configuration registers:\n"); 4822 4823 for (off = 0; off < PCI_EXTCONF_SIZE; off += 4) { 4824 #ifdef _KERNEL 4825 regs[o2i(off)] = pci_conf_read(pc, tag, off); 4826 #else 4827 if (pcibus_conf_read(pcifd, bus, dev, func, off, 4828 ®s[o2i(off)]) == -1) 4829 regs[o2i(off)] = 0; 4830 #endif 4831 } 4832 4833 /* common header */ 4834 printf(" Common header:\n"); 4835 pci_conf_print_regs(regs, 0, 16); 4836 4837 printf("\n"); 4838 #ifdef _KERNEL 4839 pci_conf_print_common(pc, tag, regs); 4840 #else 4841 pci_conf_print_common(regs); 4842 #endif 4843 printf("\n"); 4844 4845 /* type-dependent header */ 4846 hdrtype = PCI_HDRTYPE_TYPE(regs[o2i(PCI_BHLC_REG)]); 4847 switch (hdrtype) { /* XXX make a table, eventually */ 4848 case 0: 4849 /* Standard device header */ 4850 type_name = "\"normal\" device"; 4851 type_printfn = &pci_conf_print_type0; 4852 capoff = PCI_CAPLISTPTR_REG; 4853 endoff = 64; 4854 break; 4855 case 1: 4856 /* PCI-PCI bridge header */ 4857 type_name = "PCI-PCI bridge"; 4858 type_printfn = &pci_conf_print_type1; 4859 capoff = PCI_CAPLISTPTR_REG; 4860 endoff = 64; 4861 break; 4862 case 2: 4863 /* PCI-CardBus bridge header */ 4864 type_name = "PCI-CardBus bridge"; 4865 type_printfn = &pci_conf_print_type2; 4866 capoff = PCI_CARDBUS_CAPLISTPTR_REG; 4867 endoff = 72; 4868 break; 4869 default: 4870 type_name = NULL; 4871 type_printfn = 0; 4872 capoff = -1; 4873 endoff = 64; 4874 break; 4875 } 4876 printf(" Type %d ", hdrtype); 4877 if (type_name != NULL) 4878 printf("(%s) ", type_name); 4879 printf("header:\n"); 4880 pci_conf_print_regs(regs, 16, endoff); 4881 printf("\n"); 4882 if (type_printfn) { 4883 #ifdef _KERNEL 4884 (*type_printfn)(pc, tag, regs); 4885 #else 4886 (*type_printfn)(regs); 4887 #endif 4888 } else 4889 printf(" Don't know how to pretty-print type %d header.\n", 4890 hdrtype); 4891 printf("\n"); 4892 4893 /* capability list, if present */ 4894 if ((regs[o2i(PCI_COMMAND_STATUS_REG)] & PCI_STATUS_CAPLIST_SUPPORT) 4895 && (capoff > 0)) { 4896 #ifdef _KERNEL 4897 pci_conf_print_caplist(pc, tag, regs, capoff); 4898 #else 4899 pci_conf_print_caplist(regs, capoff); 4900 #endif 4901 printf("\n"); 4902 } 4903 4904 /* device-dependent header */ 4905 printf(" Device-dependent header:\n"); 4906 pci_conf_print_regs(regs, endoff, PCI_CONF_SIZE); 4907 #ifdef _KERNEL 4908 printf("\n"); 4909 if (printfn) 4910 (*printfn)(pc, tag, regs); 4911 else 4912 printf(" Don't know how to pretty-print device-dependent header.\n"); 4913 #endif /* _KERNEL */ 4914 4915 if (regs[o2i(PCI_EXTCAPLIST_BASE)] == 0xffffffff || 4916 regs[o2i(PCI_EXTCAPLIST_BASE)] == 0) 4917 return; 4918 4919 printf("\n"); 4920 #ifdef _KERNEL 4921 pci_conf_print_extcaplist(pc, tag, regs); 4922 #else 4923 pci_conf_print_extcaplist(regs); 4924 #endif 4925 printf("\n"); 4926 4927 /* Extended Configuration Space, if present */ 4928 printf(" Extended Configuration Space:\n"); 4929 pci_conf_print_regs(regs, PCI_EXTCAPLIST_BASE, PCI_EXTCONF_SIZE); 4930 } 4931