Annotation of embedaddon/pciutils/lspci.c, revision 1.1
1.1 ! misho 1: /*
! 2: * The PCI Utilities -- List All PCI Devices
! 3: *
! 4: * Copyright (c) 1997--2008 Martin Mares <mj@ucw.cz>
! 5: *
! 6: * Can be freely distributed and used under the terms of the GNU GPL.
! 7: */
! 8:
! 9: #include <stdio.h>
! 10: #include <string.h>
! 11: #include <stdlib.h>
! 12: #include <stdarg.h>
! 13:
! 14: #include "lspci.h"
! 15:
! 16: /* Options */
! 17:
! 18: int verbose; /* Show detailed information */
! 19: static int opt_hex; /* Show contents of config space as hexadecimal numbers */
! 20: struct pci_filter filter; /* Device filter */
! 21: static int opt_tree; /* Show bus tree */
! 22: static int opt_machine; /* Generate machine-readable output */
! 23: static int opt_map_mode; /* Bus mapping mode enabled */
! 24: static int opt_domains; /* Show domain numbers (0=disabled, 1=auto-detected, 2=requested) */
! 25: static int opt_kernel; /* Show kernel drivers */
! 26: static int opt_query_dns; /* Query the DNS (0=disabled, 1=enabled, 2=refresh cache) */
! 27: static int opt_query_all; /* Query the DNS for all entries */
! 28: char *opt_pcimap; /* Override path to Linux modules.pcimap */
! 29:
! 30: const char program_name[] = "lspci";
! 31:
! 32: static char options[] = "nvbxs:d:ti:mgp:qkMDQ" GENERIC_OPTIONS ;
! 33:
! 34: static char help_msg[] =
! 35: "Usage: lspci [<switches>]\n"
! 36: "\n"
! 37: "Basic display modes:\n"
! 38: "-mm\t\tProduce machine-readable output (single -m for an obsolete format)\n"
! 39: "-t\t\tShow bus tree\n"
! 40: "\n"
! 41: "Display options:\n"
! 42: "-v\t\tBe verbose (-vv for very verbose)\n"
! 43: #ifdef PCI_OS_LINUX
! 44: "-k\t\tShow kernel drivers handling each device\n"
! 45: #endif
! 46: "-x\t\tShow hex-dump of the standard part of the config space\n"
! 47: "-xxx\t\tShow hex-dump of the whole config space (dangerous; root only)\n"
! 48: "-xxxx\t\tShow hex-dump of the 4096-byte extended config space (root only)\n"
! 49: "-b\t\tBus-centric view (addresses and IRQ's as seen by the bus)\n"
! 50: "-D\t\tAlways show domain numbers\n"
! 51: "\n"
! 52: "Resolving of device ID's to names:\n"
! 53: "-n\t\tShow numeric ID's\n"
! 54: "-nn\t\tShow both textual and numeric ID's (names & numbers)\n"
! 55: #ifdef PCI_USE_DNS
! 56: "-q\t\tQuery the PCI ID database for unknown ID's via DNS\n"
! 57: "-qq\t\tAs above, but re-query locally cached entries\n"
! 58: "-Q\t\tQuery the PCI ID database for all ID's via DNS\n"
! 59: #endif
! 60: "\n"
! 61: "Selection of devices:\n"
! 62: "-s [[[[<domain>]:]<bus>]:][<slot>][.[<func>]]\tShow only devices in selected slots\n"
! 63: "-d [<vendor>]:[<device>]\t\t\tShow only devices with specified ID's\n"
! 64: "\n"
! 65: "Other options:\n"
! 66: "-i <file>\tUse specified ID database instead of %s\n"
! 67: #ifdef PCI_OS_LINUX
! 68: "-p <file>\tLook up kernel modules in a given file instead of default modules.pcimap\n"
! 69: #endif
! 70: "-M\t\tEnable `bus mapping' mode (dangerous; root only)\n"
! 71: "\n"
! 72: "PCI access options:\n"
! 73: GENERIC_HELP
! 74: ;
! 75:
! 76: /*** Our view of the PCI bus ***/
! 77:
! 78: struct pci_access *pacc;
! 79: struct device *first_dev;
! 80: static int seen_errors;
! 81:
! 82: int
! 83: config_fetch(struct device *d, unsigned int pos, unsigned int len)
! 84: {
! 85: unsigned int end = pos+len;
! 86: int result;
! 87:
! 88: while (pos < d->config_bufsize && len && d->present[pos])
! 89: pos++, len--;
! 90: while (pos+len <= d->config_bufsize && len && d->present[pos+len-1])
! 91: len--;
! 92: if (!len)
! 93: return 1;
! 94:
! 95: if (end > d->config_bufsize)
! 96: {
! 97: int orig_size = d->config_bufsize;
! 98: while (end > d->config_bufsize)
! 99: d->config_bufsize *= 2;
! 100: d->config = xrealloc(d->config, d->config_bufsize);
! 101: d->present = xrealloc(d->present, d->config_bufsize);
! 102: memset(d->present + orig_size, 0, d->config_bufsize - orig_size);
! 103: }
! 104: result = pci_read_block(d->dev, pos, d->config + pos, len);
! 105: if (result)
! 106: memset(d->present + pos, 1, len);
! 107: return result;
! 108: }
! 109:
! 110: struct device *
! 111: scan_device(struct pci_dev *p)
! 112: {
! 113: struct device *d;
! 114:
! 115: if (p->domain && !opt_domains)
! 116: opt_domains = 1;
! 117: if (!pci_filter_match(&filter, p))
! 118: return NULL;
! 119: d = xmalloc(sizeof(struct device));
! 120: memset(d, 0, sizeof(*d));
! 121: d->dev = p;
! 122: d->config_cached = d->config_bufsize = 64;
! 123: d->config = xmalloc(64);
! 124: d->present = xmalloc(64);
! 125: memset(d->present, 1, 64);
! 126: if (!pci_read_block(p, 0, d->config, 64))
! 127: {
! 128: fprintf(stderr, "lspci: Unable to read the standard configuration space header of device %04x:%02x:%02x.%d\n",
! 129: p->domain, p->bus, p->dev, p->func);
! 130: seen_errors++;
! 131: return NULL;
! 132: }
! 133: if ((d->config[PCI_HEADER_TYPE] & 0x7f) == PCI_HEADER_TYPE_CARDBUS)
! 134: {
! 135: /* For cardbus bridges, we need to fetch 64 bytes more to get the
! 136: * full standard header... */
! 137: if (config_fetch(d, 64, 64))
! 138: d->config_cached += 64;
! 139: }
! 140: pci_setup_cache(p, d->config, d->config_cached);
! 141: pci_fill_info(p, PCI_FILL_IDENT | PCI_FILL_CLASS | PCI_FILL_IRQ | PCI_FILL_BASES | PCI_FILL_ROM_BASE | PCI_FILL_SIZES | PCI_FILL_PHYS_SLOT);
! 142: return d;
! 143: }
! 144:
! 145: static void
! 146: scan_devices(void)
! 147: {
! 148: struct device *d;
! 149: struct pci_dev *p;
! 150:
! 151: pci_scan_bus(pacc);
! 152: for (p=pacc->devices; p; p=p->next)
! 153: if (d = scan_device(p))
! 154: {
! 155: d->next = first_dev;
! 156: first_dev = d;
! 157: }
! 158: }
! 159:
! 160: /*** Config space accesses ***/
! 161:
! 162: static void
! 163: check_conf_range(struct device *d, unsigned int pos, unsigned int len)
! 164: {
! 165: while (len)
! 166: if (!d->present[pos])
! 167: die("Internal bug: Accessing non-read configuration byte at position %x", pos);
! 168: else
! 169: pos++, len--;
! 170: }
! 171:
! 172: byte
! 173: get_conf_byte(struct device *d, unsigned int pos)
! 174: {
! 175: check_conf_range(d, pos, 1);
! 176: return d->config[pos];
! 177: }
! 178:
! 179: word
! 180: get_conf_word(struct device *d, unsigned int pos)
! 181: {
! 182: check_conf_range(d, pos, 2);
! 183: return d->config[pos] | (d->config[pos+1] << 8);
! 184: }
! 185:
! 186: u32
! 187: get_conf_long(struct device *d, unsigned int pos)
! 188: {
! 189: check_conf_range(d, pos, 4);
! 190: return d->config[pos] |
! 191: (d->config[pos+1] << 8) |
! 192: (d->config[pos+2] << 16) |
! 193: (d->config[pos+3] << 24);
! 194: }
! 195:
! 196: /*** Sorting ***/
! 197:
! 198: static int
! 199: compare_them(const void *A, const void *B)
! 200: {
! 201: const struct pci_dev *a = (*(const struct device **)A)->dev;
! 202: const struct pci_dev *b = (*(const struct device **)B)->dev;
! 203:
! 204: if (a->domain < b->domain)
! 205: return -1;
! 206: if (a->domain > b->domain)
! 207: return 1;
! 208: if (a->bus < b->bus)
! 209: return -1;
! 210: if (a->bus > b->bus)
! 211: return 1;
! 212: if (a->dev < b->dev)
! 213: return -1;
! 214: if (a->dev > b->dev)
! 215: return 1;
! 216: if (a->func < b->func)
! 217: return -1;
! 218: if (a->func > b->func)
! 219: return 1;
! 220: return 0;
! 221: }
! 222:
! 223: static void
! 224: sort_them(void)
! 225: {
! 226: struct device **index, **h, **last_dev;
! 227: int cnt;
! 228: struct device *d;
! 229:
! 230: cnt = 0;
! 231: for (d=first_dev; d; d=d->next)
! 232: cnt++;
! 233: h = index = alloca(sizeof(struct device *) * cnt);
! 234: for (d=first_dev; d; d=d->next)
! 235: *h++ = d;
! 236: qsort(index, cnt, sizeof(struct device *), compare_them);
! 237: last_dev = &first_dev;
! 238: h = index;
! 239: while (cnt--)
! 240: {
! 241: *last_dev = *h;
! 242: last_dev = &(*h)->next;
! 243: h++;
! 244: }
! 245: *last_dev = NULL;
! 246: }
! 247:
! 248: /*** Normal output ***/
! 249:
! 250: static void
! 251: show_slot_name(struct device *d)
! 252: {
! 253: struct pci_dev *p = d->dev;
! 254:
! 255: if (!opt_machine ? opt_domains : (p->domain || opt_domains >= 2))
! 256: printf("%04x:", p->domain);
! 257: printf("%02x:%02x.%d", p->bus, p->dev, p->func);
! 258: }
! 259:
! 260: void
! 261: get_subid(struct device *d, word *subvp, word *subdp)
! 262: {
! 263: byte htype = get_conf_byte(d, PCI_HEADER_TYPE) & 0x7f;
! 264:
! 265: if (htype == PCI_HEADER_TYPE_NORMAL)
! 266: {
! 267: *subvp = get_conf_word(d, PCI_SUBSYSTEM_VENDOR_ID);
! 268: *subdp = get_conf_word(d, PCI_SUBSYSTEM_ID);
! 269: }
! 270: else if (htype == PCI_HEADER_TYPE_CARDBUS && d->config_cached >= 128)
! 271: {
! 272: *subvp = get_conf_word(d, PCI_CB_SUBSYSTEM_VENDOR_ID);
! 273: *subdp = get_conf_word(d, PCI_CB_SUBSYSTEM_ID);
! 274: }
! 275: else
! 276: *subvp = *subdp = 0xffff;
! 277: }
! 278:
! 279: static void
! 280: show_terse(struct device *d)
! 281: {
! 282: int c;
! 283: struct pci_dev *p = d->dev;
! 284: char classbuf[128], devbuf[128];
! 285:
! 286: show_slot_name(d);
! 287: printf(" %s: %s",
! 288: pci_lookup_name(pacc, classbuf, sizeof(classbuf),
! 289: PCI_LOOKUP_CLASS,
! 290: p->device_class),
! 291: pci_lookup_name(pacc, devbuf, sizeof(devbuf),
! 292: PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE,
! 293: p->vendor_id, p->device_id));
! 294: if (c = get_conf_byte(d, PCI_REVISION_ID))
! 295: printf(" (rev %02x)", c);
! 296: if (verbose)
! 297: {
! 298: char *x;
! 299: c = get_conf_byte(d, PCI_CLASS_PROG);
! 300: x = pci_lookup_name(pacc, devbuf, sizeof(devbuf),
! 301: PCI_LOOKUP_PROGIF | PCI_LOOKUP_NO_NUMBERS,
! 302: p->device_class, c);
! 303: if (c || x)
! 304: {
! 305: printf(" (prog-if %02x", c);
! 306: if (x)
! 307: printf(" [%s]", x);
! 308: putchar(')');
! 309: }
! 310: }
! 311: putchar('\n');
! 312:
! 313: if (verbose || opt_kernel)
! 314: {
! 315: word subsys_v, subsys_d;
! 316: char ssnamebuf[256];
! 317:
! 318: get_subid(d, &subsys_v, &subsys_d);
! 319: if (subsys_v && subsys_v != 0xffff)
! 320: printf("\tSubsystem: %s\n",
! 321: pci_lookup_name(pacc, ssnamebuf, sizeof(ssnamebuf),
! 322: PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE,
! 323: p->vendor_id, p->device_id, subsys_v, subsys_d));
! 324: }
! 325: }
! 326:
! 327: /*** Verbose output ***/
! 328:
! 329: static void
! 330: show_size(pciaddr_t x)
! 331: {
! 332: static const char suffix[][2] = { "", "K", "M", "G", "T" };
! 333: unsigned i;
! 334: if (!x)
! 335: return;
! 336: for (i = 0; i < (sizeof(suffix) / sizeof(*suffix) - 1); i++) {
! 337: if (x < 1024)
! 338: break;
! 339: x /= 1024;
! 340: }
! 341: printf(" [size=%u%s]", (unsigned)x, suffix[i]);
! 342: }
! 343:
! 344: static void
! 345: show_bases(struct device *d, int cnt)
! 346: {
! 347: struct pci_dev *p = d->dev;
! 348: word cmd = get_conf_word(d, PCI_COMMAND);
! 349: int i;
! 350: int virtual = 0;
! 351:
! 352: for (i=0; i<cnt; i++)
! 353: {
! 354: pciaddr_t pos = p->base_addr[i];
! 355: pciaddr_t len = (p->known_fields & PCI_FILL_SIZES) ? p->size[i] : 0;
! 356: u32 flg = get_conf_long(d, PCI_BASE_ADDRESS_0 + 4*i);
! 357: if (flg == 0xffffffff)
! 358: flg = 0;
! 359: if (!pos && !flg && !len)
! 360: continue;
! 361: if (verbose > 1)
! 362: printf("\tRegion %d: ", i);
! 363: else
! 364: putchar('\t');
! 365: if (pos && !flg) /* Reported by the OS, but not by the device */
! 366: {
! 367: printf("[virtual] ");
! 368: flg = pos;
! 369: virtual = 1;
! 370: }
! 371: if (flg & PCI_BASE_ADDRESS_SPACE_IO)
! 372: {
! 373: pciaddr_t a = pos & PCI_BASE_ADDRESS_IO_MASK;
! 374: printf("I/O ports at ");
! 375: if (a)
! 376: printf(PCIADDR_PORT_FMT, a);
! 377: else if (flg & PCI_BASE_ADDRESS_IO_MASK)
! 378: printf("<ignored>");
! 379: else
! 380: printf("<unassigned>");
! 381: if (!virtual && !(cmd & PCI_COMMAND_IO))
! 382: printf(" [disabled]");
! 383: }
! 384: else
! 385: {
! 386: int t = flg & PCI_BASE_ADDRESS_MEM_TYPE_MASK;
! 387: pciaddr_t a = pos & PCI_ADDR_MEM_MASK;
! 388: int done = 0;
! 389: u32 z = 0;
! 390:
! 391: printf("Memory at ");
! 392: if (t == PCI_BASE_ADDRESS_MEM_TYPE_64)
! 393: {
! 394: if (i >= cnt - 1)
! 395: {
! 396: printf("<invalid-64bit-slot>");
! 397: done = 1;
! 398: }
! 399: else
! 400: {
! 401: i++;
! 402: z = get_conf_long(d, PCI_BASE_ADDRESS_0 + 4*i);
! 403: }
! 404: }
! 405: if (!done)
! 406: {
! 407: if (a)
! 408: printf(PCIADDR_T_FMT, a);
! 409: else
! 410: printf(((flg & PCI_BASE_ADDRESS_MEM_MASK) || z) ? "<ignored>" : "<unassigned>");
! 411: }
! 412: printf(" (%s, %sprefetchable)",
! 413: (t == PCI_BASE_ADDRESS_MEM_TYPE_32) ? "32-bit" :
! 414: (t == PCI_BASE_ADDRESS_MEM_TYPE_64) ? "64-bit" :
! 415: (t == PCI_BASE_ADDRESS_MEM_TYPE_1M) ? "low-1M" : "type 3",
! 416: (flg & PCI_BASE_ADDRESS_MEM_PREFETCH) ? "" : "non-");
! 417: if (!virtual && !(cmd & PCI_COMMAND_MEMORY))
! 418: printf(" [disabled]");
! 419: }
! 420: show_size(len);
! 421: putchar('\n');
! 422: }
! 423: }
! 424:
! 425: static void
! 426: show_rom(struct device *d, int reg)
! 427: {
! 428: struct pci_dev *p = d->dev;
! 429: pciaddr_t rom = p->rom_base_addr;
! 430: pciaddr_t len = (p->known_fields & PCI_FILL_SIZES) ? p->rom_size : 0;
! 431: u32 flg = get_conf_long(d, reg);
! 432: word cmd = get_conf_word(d, PCI_COMMAND);
! 433: int virtual = 0;
! 434:
! 435: if (!rom && !flg && !len)
! 436: return;
! 437: putchar('\t');
! 438: if ((rom & PCI_ROM_ADDRESS_MASK) && !(flg & PCI_ROM_ADDRESS_MASK))
! 439: {
! 440: printf("[virtual] ");
! 441: flg = rom;
! 442: virtual = 1;
! 443: }
! 444: printf("Expansion ROM at ");
! 445: if (rom & PCI_ROM_ADDRESS_MASK)
! 446: printf(PCIADDR_T_FMT, rom & PCI_ROM_ADDRESS_MASK);
! 447: else if (flg & PCI_ROM_ADDRESS_MASK)
! 448: printf("<ignored>");
! 449: else
! 450: printf("<unassigned>");
! 451: if (!(flg & PCI_ROM_ADDRESS_ENABLE))
! 452: printf(" [disabled]");
! 453: else if (!virtual && !(cmd & PCI_COMMAND_MEMORY))
! 454: printf(" [disabled by cmd]");
! 455: show_size(len);
! 456: putchar('\n');
! 457: }
! 458:
! 459: static void
! 460: show_htype0(struct device *d)
! 461: {
! 462: show_bases(d, 6);
! 463: show_rom(d, PCI_ROM_ADDRESS);
! 464: show_caps(d);
! 465: }
! 466:
! 467: static void
! 468: show_htype1(struct device *d)
! 469: {
! 470: u32 io_base = get_conf_byte(d, PCI_IO_BASE);
! 471: u32 io_limit = get_conf_byte(d, PCI_IO_LIMIT);
! 472: u32 io_type = io_base & PCI_IO_RANGE_TYPE_MASK;
! 473: u32 mem_base = get_conf_word(d, PCI_MEMORY_BASE);
! 474: u32 mem_limit = get_conf_word(d, PCI_MEMORY_LIMIT);
! 475: u32 mem_type = mem_base & PCI_MEMORY_RANGE_TYPE_MASK;
! 476: u32 pref_base = get_conf_word(d, PCI_PREF_MEMORY_BASE);
! 477: u32 pref_limit = get_conf_word(d, PCI_PREF_MEMORY_LIMIT);
! 478: u32 pref_type = pref_base & PCI_PREF_RANGE_TYPE_MASK;
! 479: word sec_stat = get_conf_word(d, PCI_SEC_STATUS);
! 480: word brc = get_conf_word(d, PCI_BRIDGE_CONTROL);
! 481: int verb = verbose > 2;
! 482:
! 483: show_bases(d, 2);
! 484: printf("\tBus: primary=%02x, secondary=%02x, subordinate=%02x, sec-latency=%d\n",
! 485: get_conf_byte(d, PCI_PRIMARY_BUS),
! 486: get_conf_byte(d, PCI_SECONDARY_BUS),
! 487: get_conf_byte(d, PCI_SUBORDINATE_BUS),
! 488: get_conf_byte(d, PCI_SEC_LATENCY_TIMER));
! 489:
! 490: if (io_type != (io_limit & PCI_IO_RANGE_TYPE_MASK) ||
! 491: (io_type != PCI_IO_RANGE_TYPE_16 && io_type != PCI_IO_RANGE_TYPE_32))
! 492: printf("\t!!! Unknown I/O range types %x/%x\n", io_base, io_limit);
! 493: else
! 494: {
! 495: io_base = (io_base & PCI_IO_RANGE_MASK) << 8;
! 496: io_limit = (io_limit & PCI_IO_RANGE_MASK) << 8;
! 497: if (io_type == PCI_IO_RANGE_TYPE_32)
! 498: {
! 499: io_base |= (get_conf_word(d, PCI_IO_BASE_UPPER16) << 16);
! 500: io_limit |= (get_conf_word(d, PCI_IO_LIMIT_UPPER16) << 16);
! 501: }
! 502: if (io_base <= io_limit || verb)
! 503: printf("\tI/O behind bridge: %08x-%08x\n", io_base, io_limit+0xfff);
! 504: }
! 505:
! 506: if (mem_type != (mem_limit & PCI_MEMORY_RANGE_TYPE_MASK) ||
! 507: mem_type)
! 508: printf("\t!!! Unknown memory range types %x/%x\n", mem_base, mem_limit);
! 509: else
! 510: {
! 511: mem_base = (mem_base & PCI_MEMORY_RANGE_MASK) << 16;
! 512: mem_limit = (mem_limit & PCI_MEMORY_RANGE_MASK) << 16;
! 513: if (mem_base <= mem_limit || verb)
! 514: printf("\tMemory behind bridge: %08x-%08x\n", mem_base, mem_limit + 0xfffff);
! 515: }
! 516:
! 517: if (pref_type != (pref_limit & PCI_PREF_RANGE_TYPE_MASK) ||
! 518: (pref_type != PCI_PREF_RANGE_TYPE_32 && pref_type != PCI_PREF_RANGE_TYPE_64))
! 519: printf("\t!!! Unknown prefetchable memory range types %x/%x\n", pref_base, pref_limit);
! 520: else
! 521: {
! 522: pref_base = (pref_base & PCI_PREF_RANGE_MASK) << 16;
! 523: pref_limit = (pref_limit & PCI_PREF_RANGE_MASK) << 16;
! 524: if (pref_base <= pref_limit || verb)
! 525: {
! 526: if (pref_type == PCI_PREF_RANGE_TYPE_32)
! 527: printf("\tPrefetchable memory behind bridge: %08x-%08x\n", pref_base, pref_limit + 0xfffff);
! 528: else
! 529: printf("\tPrefetchable memory behind bridge: %08x%08x-%08x%08x\n",
! 530: get_conf_long(d, PCI_PREF_BASE_UPPER32),
! 531: pref_base,
! 532: get_conf_long(d, PCI_PREF_LIMIT_UPPER32),
! 533: pref_limit + 0xfffff);
! 534: }
! 535: }
! 536:
! 537: if (verbose > 1)
! 538: printf("\tSecondary status: 66MHz%c FastB2B%c ParErr%c DEVSEL=%s >TAbort%c <TAbort%c <MAbort%c <SERR%c <PERR%c\n",
! 539: FLAG(sec_stat, PCI_STATUS_66MHZ),
! 540: FLAG(sec_stat, PCI_STATUS_FAST_BACK),
! 541: FLAG(sec_stat, PCI_STATUS_PARITY),
! 542: ((sec_stat & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_SLOW) ? "slow" :
! 543: ((sec_stat & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_MEDIUM) ? "medium" :
! 544: ((sec_stat & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_FAST) ? "fast" : "??",
! 545: FLAG(sec_stat, PCI_STATUS_SIG_TARGET_ABORT),
! 546: FLAG(sec_stat, PCI_STATUS_REC_TARGET_ABORT),
! 547: FLAG(sec_stat, PCI_STATUS_REC_MASTER_ABORT),
! 548: FLAG(sec_stat, PCI_STATUS_SIG_SYSTEM_ERROR),
! 549: FLAG(sec_stat, PCI_STATUS_DETECTED_PARITY));
! 550:
! 551: show_rom(d, PCI_ROM_ADDRESS1);
! 552:
! 553: if (verbose > 1)
! 554: {
! 555: printf("\tBridgeCtl: Parity%c SERR%c NoISA%c VGA%c MAbort%c >Reset%c FastB2B%c\n",
! 556: FLAG(brc, PCI_BRIDGE_CTL_PARITY),
! 557: FLAG(brc, PCI_BRIDGE_CTL_SERR),
! 558: FLAG(brc, PCI_BRIDGE_CTL_NO_ISA),
! 559: FLAG(brc, PCI_BRIDGE_CTL_VGA),
! 560: FLAG(brc, PCI_BRIDGE_CTL_MASTER_ABORT),
! 561: FLAG(brc, PCI_BRIDGE_CTL_BUS_RESET),
! 562: FLAG(brc, PCI_BRIDGE_CTL_FAST_BACK));
! 563: printf("\t\tPriDiscTmr%c SecDiscTmr%c DiscTmrStat%c DiscTmrSERREn%c\n",
! 564: FLAG(brc, PCI_BRIDGE_CTL_PRI_DISCARD_TIMER),
! 565: FLAG(brc, PCI_BRIDGE_CTL_SEC_DISCARD_TIMER),
! 566: FLAG(brc, PCI_BRIDGE_CTL_DISCARD_TIMER_STATUS),
! 567: FLAG(brc, PCI_BRIDGE_CTL_DISCARD_TIMER_SERR_EN));
! 568: }
! 569:
! 570: show_caps(d);
! 571: }
! 572:
! 573: static void
! 574: show_htype2(struct device *d)
! 575: {
! 576: int i;
! 577: word cmd = get_conf_word(d, PCI_COMMAND);
! 578: word brc = get_conf_word(d, PCI_CB_BRIDGE_CONTROL);
! 579: word exca;
! 580: int verb = verbose > 2;
! 581:
! 582: show_bases(d, 1);
! 583: printf("\tBus: primary=%02x, secondary=%02x, subordinate=%02x, sec-latency=%d\n",
! 584: get_conf_byte(d, PCI_CB_PRIMARY_BUS),
! 585: get_conf_byte(d, PCI_CB_CARD_BUS),
! 586: get_conf_byte(d, PCI_CB_SUBORDINATE_BUS),
! 587: get_conf_byte(d, PCI_CB_LATENCY_TIMER));
! 588: for (i=0; i<2; i++)
! 589: {
! 590: int p = 8*i;
! 591: u32 base = get_conf_long(d, PCI_CB_MEMORY_BASE_0 + p);
! 592: u32 limit = get_conf_long(d, PCI_CB_MEMORY_LIMIT_0 + p);
! 593: limit = limit + 0xfff;
! 594: if (base <= limit || verb)
! 595: printf("\tMemory window %d: %08x-%08x%s%s\n", i, base, limit,
! 596: (cmd & PCI_COMMAND_MEMORY) ? "" : " [disabled]",
! 597: (brc & (PCI_CB_BRIDGE_CTL_PREFETCH_MEM0 << i)) ? " (prefetchable)" : "");
! 598: }
! 599: for (i=0; i<2; i++)
! 600: {
! 601: int p = 8*i;
! 602: u32 base = get_conf_long(d, PCI_CB_IO_BASE_0 + p);
! 603: u32 limit = get_conf_long(d, PCI_CB_IO_LIMIT_0 + p);
! 604: if (!(base & PCI_IO_RANGE_TYPE_32))
! 605: {
! 606: base &= 0xffff;
! 607: limit &= 0xffff;
! 608: }
! 609: base &= PCI_CB_IO_RANGE_MASK;
! 610: limit = (limit & PCI_CB_IO_RANGE_MASK) + 3;
! 611: if (base <= limit || verb)
! 612: printf("\tI/O window %d: %08x-%08x%s\n", i, base, limit,
! 613: (cmd & PCI_COMMAND_IO) ? "" : " [disabled]");
! 614: }
! 615:
! 616: if (get_conf_word(d, PCI_CB_SEC_STATUS) & PCI_STATUS_SIG_SYSTEM_ERROR)
! 617: printf("\tSecondary status: SERR\n");
! 618: if (verbose > 1)
! 619: printf("\tBridgeCtl: Parity%c SERR%c ISA%c VGA%c MAbort%c >Reset%c 16bInt%c PostWrite%c\n",
! 620: FLAG(brc, PCI_CB_BRIDGE_CTL_PARITY),
! 621: FLAG(brc, PCI_CB_BRIDGE_CTL_SERR),
! 622: FLAG(brc, PCI_CB_BRIDGE_CTL_ISA),
! 623: FLAG(brc, PCI_CB_BRIDGE_CTL_VGA),
! 624: FLAG(brc, PCI_CB_BRIDGE_CTL_MASTER_ABORT),
! 625: FLAG(brc, PCI_CB_BRIDGE_CTL_CB_RESET),
! 626: FLAG(brc, PCI_CB_BRIDGE_CTL_16BIT_INT),
! 627: FLAG(brc, PCI_CB_BRIDGE_CTL_POST_WRITES));
! 628:
! 629: if (d->config_cached < 128)
! 630: {
! 631: printf("\t<access denied to the rest>\n");
! 632: return;
! 633: }
! 634:
! 635: exca = get_conf_word(d, PCI_CB_LEGACY_MODE_BASE);
! 636: if (exca)
! 637: printf("\t16-bit legacy interface ports at %04x\n", exca);
! 638: }
! 639:
! 640: static void
! 641: show_verbose(struct device *d)
! 642: {
! 643: struct pci_dev *p = d->dev;
! 644: word status = get_conf_word(d, PCI_STATUS);
! 645: word cmd = get_conf_word(d, PCI_COMMAND);
! 646: word class = p->device_class;
! 647: byte bist = get_conf_byte(d, PCI_BIST);
! 648: byte htype = get_conf_byte(d, PCI_HEADER_TYPE) & 0x7f;
! 649: byte latency = get_conf_byte(d, PCI_LATENCY_TIMER);
! 650: byte cache_line = get_conf_byte(d, PCI_CACHE_LINE_SIZE);
! 651: byte max_lat, min_gnt;
! 652: byte int_pin = get_conf_byte(d, PCI_INTERRUPT_PIN);
! 653: unsigned int irq = p->irq;
! 654:
! 655: show_terse(d);
! 656:
! 657: switch (htype)
! 658: {
! 659: case PCI_HEADER_TYPE_NORMAL:
! 660: if (class == PCI_CLASS_BRIDGE_PCI)
! 661: printf("\t!!! Invalid class %04x for header type %02x\n", class, htype);
! 662: max_lat = get_conf_byte(d, PCI_MAX_LAT);
! 663: min_gnt = get_conf_byte(d, PCI_MIN_GNT);
! 664: break;
! 665: case PCI_HEADER_TYPE_BRIDGE:
! 666: if ((class >> 8) != PCI_BASE_CLASS_BRIDGE)
! 667: printf("\t!!! Invalid class %04x for header type %02x\n", class, htype);
! 668: irq = int_pin = min_gnt = max_lat = 0;
! 669: break;
! 670: case PCI_HEADER_TYPE_CARDBUS:
! 671: if ((class >> 8) != PCI_BASE_CLASS_BRIDGE)
! 672: printf("\t!!! Invalid class %04x for header type %02x\n", class, htype);
! 673: min_gnt = max_lat = 0;
! 674: break;
! 675: default:
! 676: printf("\t!!! Unknown header type %02x\n", htype);
! 677: return;
! 678: }
! 679:
! 680: if (p->phy_slot)
! 681: printf("\tPhysical Slot: %s\n", p->phy_slot);
! 682:
! 683: if (verbose > 1)
! 684: {
! 685: printf("\tControl: I/O%c Mem%c BusMaster%c SpecCycle%c MemWINV%c VGASnoop%c ParErr%c Stepping%c SERR%c FastB2B%c DisINTx%c\n",
! 686: FLAG(cmd, PCI_COMMAND_IO),
! 687: FLAG(cmd, PCI_COMMAND_MEMORY),
! 688: FLAG(cmd, PCI_COMMAND_MASTER),
! 689: FLAG(cmd, PCI_COMMAND_SPECIAL),
! 690: FLAG(cmd, PCI_COMMAND_INVALIDATE),
! 691: FLAG(cmd, PCI_COMMAND_VGA_PALETTE),
! 692: FLAG(cmd, PCI_COMMAND_PARITY),
! 693: FLAG(cmd, PCI_COMMAND_WAIT),
! 694: FLAG(cmd, PCI_COMMAND_SERR),
! 695: FLAG(cmd, PCI_COMMAND_FAST_BACK),
! 696: FLAG(cmd, PCI_COMMAND_DISABLE_INTx));
! 697: printf("\tStatus: Cap%c 66MHz%c UDF%c FastB2B%c ParErr%c DEVSEL=%s >TAbort%c <TAbort%c <MAbort%c >SERR%c <PERR%c INTx%c\n",
! 698: FLAG(status, PCI_STATUS_CAP_LIST),
! 699: FLAG(status, PCI_STATUS_66MHZ),
! 700: FLAG(status, PCI_STATUS_UDF),
! 701: FLAG(status, PCI_STATUS_FAST_BACK),
! 702: FLAG(status, PCI_STATUS_PARITY),
! 703: ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_SLOW) ? "slow" :
! 704: ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_MEDIUM) ? "medium" :
! 705: ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_FAST) ? "fast" : "??",
! 706: FLAG(status, PCI_STATUS_SIG_TARGET_ABORT),
! 707: FLAG(status, PCI_STATUS_REC_TARGET_ABORT),
! 708: FLAG(status, PCI_STATUS_REC_MASTER_ABORT),
! 709: FLAG(status, PCI_STATUS_SIG_SYSTEM_ERROR),
! 710: FLAG(status, PCI_STATUS_DETECTED_PARITY),
! 711: FLAG(status, PCI_STATUS_INTx));
! 712: if (cmd & PCI_COMMAND_MASTER)
! 713: {
! 714: printf("\tLatency: %d", latency);
! 715: if (min_gnt || max_lat)
! 716: {
! 717: printf(" (");
! 718: if (min_gnt)
! 719: printf("%dns min", min_gnt*250);
! 720: if (min_gnt && max_lat)
! 721: printf(", ");
! 722: if (max_lat)
! 723: printf("%dns max", max_lat*250);
! 724: putchar(')');
! 725: }
! 726: if (cache_line)
! 727: printf(", Cache Line Size: %d bytes", cache_line * 4);
! 728: putchar('\n');
! 729: }
! 730: if (int_pin || irq)
! 731: printf("\tInterrupt: pin %c routed to IRQ " PCIIRQ_FMT "\n",
! 732: (int_pin ? 'A' + int_pin - 1 : '?'), irq);
! 733: }
! 734: else
! 735: {
! 736: printf("\tFlags: ");
! 737: if (cmd & PCI_COMMAND_MASTER)
! 738: printf("bus master, ");
! 739: if (cmd & PCI_COMMAND_VGA_PALETTE)
! 740: printf("VGA palette snoop, ");
! 741: if (cmd & PCI_COMMAND_WAIT)
! 742: printf("stepping, ");
! 743: if (cmd & PCI_COMMAND_FAST_BACK)
! 744: printf("fast Back2Back, ");
! 745: if (status & PCI_STATUS_66MHZ)
! 746: printf("66MHz, ");
! 747: if (status & PCI_STATUS_UDF)
! 748: printf("user-definable features, ");
! 749: printf("%s devsel",
! 750: ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_SLOW) ? "slow" :
! 751: ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_MEDIUM) ? "medium" :
! 752: ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_FAST) ? "fast" : "??");
! 753: if (cmd & PCI_COMMAND_MASTER)
! 754: printf(", latency %d", latency);
! 755: if (irq)
! 756: printf(", IRQ " PCIIRQ_FMT, irq);
! 757: putchar('\n');
! 758: }
! 759:
! 760: if (bist & PCI_BIST_CAPABLE)
! 761: {
! 762: if (bist & PCI_BIST_START)
! 763: printf("\tBIST is running\n");
! 764: else
! 765: printf("\tBIST result: %02x\n", bist & PCI_BIST_CODE_MASK);
! 766: }
! 767:
! 768: switch (htype)
! 769: {
! 770: case PCI_HEADER_TYPE_NORMAL:
! 771: show_htype0(d);
! 772: break;
! 773: case PCI_HEADER_TYPE_BRIDGE:
! 774: show_htype1(d);
! 775: break;
! 776: case PCI_HEADER_TYPE_CARDBUS:
! 777: show_htype2(d);
! 778: break;
! 779: }
! 780: }
! 781:
! 782: /*** Machine-readable dumps ***/
! 783:
! 784: static void
! 785: show_hex_dump(struct device *d)
! 786: {
! 787: unsigned int i, cnt;
! 788:
! 789: cnt = d->config_cached;
! 790: if (opt_hex >= 3 && config_fetch(d, cnt, 256-cnt))
! 791: {
! 792: cnt = 256;
! 793: if (opt_hex >= 4 && config_fetch(d, 256, 4096-256))
! 794: cnt = 4096;
! 795: }
! 796:
! 797: for (i=0; i<cnt; i++)
! 798: {
! 799: if (! (i & 15))
! 800: printf("%02x:", i);
! 801: printf(" %02x", get_conf_byte(d, i));
! 802: if ((i & 15) == 15)
! 803: putchar('\n');
! 804: }
! 805: }
! 806:
! 807: static void
! 808: print_shell_escaped(char *c)
! 809: {
! 810: printf(" \"");
! 811: while (*c)
! 812: {
! 813: if (*c == '"' || *c == '\\')
! 814: putchar('\\');
! 815: putchar(*c++);
! 816: }
! 817: putchar('"');
! 818: }
! 819:
! 820: static void
! 821: show_machine(struct device *d)
! 822: {
! 823: struct pci_dev *p = d->dev;
! 824: int c;
! 825: word sv_id, sd_id;
! 826: char classbuf[128], vendbuf[128], devbuf[128], svbuf[128], sdbuf[128];
! 827:
! 828: get_subid(d, &sv_id, &sd_id);
! 829:
! 830: if (verbose)
! 831: {
! 832: printf((opt_machine >= 2) ? "Slot:\t" : "Device:\t");
! 833: show_slot_name(d);
! 834: putchar('\n');
! 835: printf("Class:\t%s\n",
! 836: pci_lookup_name(pacc, classbuf, sizeof(classbuf), PCI_LOOKUP_CLASS, p->device_class));
! 837: printf("Vendor:\t%s\n",
! 838: pci_lookup_name(pacc, vendbuf, sizeof(vendbuf), PCI_LOOKUP_VENDOR, p->vendor_id, p->device_id));
! 839: printf("Device:\t%s\n",
! 840: pci_lookup_name(pacc, devbuf, sizeof(devbuf), PCI_LOOKUP_DEVICE, p->vendor_id, p->device_id));
! 841: if (sv_id && sv_id != 0xffff)
! 842: {
! 843: printf("SVendor:\t%s\n",
! 844: pci_lookup_name(pacc, svbuf, sizeof(svbuf), PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR, sv_id));
! 845: printf("SDevice:\t%s\n",
! 846: pci_lookup_name(pacc, sdbuf, sizeof(sdbuf), PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_DEVICE, p->vendor_id, p->device_id, sv_id, sd_id));
! 847: }
! 848: if (p->phy_slot)
! 849: printf("PhySlot:\t%s\n", p->phy_slot);
! 850: if (c = get_conf_byte(d, PCI_REVISION_ID))
! 851: printf("Rev:\t%02x\n", c);
! 852: if (c = get_conf_byte(d, PCI_CLASS_PROG))
! 853: printf("ProgIf:\t%02x\n", c);
! 854: if (opt_kernel)
! 855: show_kernel_machine(d);
! 856: }
! 857: else
! 858: {
! 859: show_slot_name(d);
! 860: print_shell_escaped(pci_lookup_name(pacc, classbuf, sizeof(classbuf), PCI_LOOKUP_CLASS, p->device_class));
! 861: print_shell_escaped(pci_lookup_name(pacc, vendbuf, sizeof(vendbuf), PCI_LOOKUP_VENDOR, p->vendor_id, p->device_id));
! 862: print_shell_escaped(pci_lookup_name(pacc, devbuf, sizeof(devbuf), PCI_LOOKUP_DEVICE, p->vendor_id, p->device_id));
! 863: if (c = get_conf_byte(d, PCI_REVISION_ID))
! 864: printf(" -r%02x", c);
! 865: if (c = get_conf_byte(d, PCI_CLASS_PROG))
! 866: printf(" -p%02x", c);
! 867: if (sv_id && sv_id != 0xffff)
! 868: {
! 869: print_shell_escaped(pci_lookup_name(pacc, svbuf, sizeof(svbuf), PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR, sv_id));
! 870: print_shell_escaped(pci_lookup_name(pacc, sdbuf, sizeof(sdbuf), PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_DEVICE, p->vendor_id, p->device_id, sv_id, sd_id));
! 871: }
! 872: else
! 873: printf(" \"\" \"\"");
! 874: putchar('\n');
! 875: }
! 876: }
! 877:
! 878: /*** Main show function ***/
! 879:
! 880: void
! 881: show_device(struct device *d)
! 882: {
! 883: if (opt_machine)
! 884: show_machine(d);
! 885: else
! 886: {
! 887: if (verbose)
! 888: show_verbose(d);
! 889: else
! 890: show_terse(d);
! 891: if (opt_kernel || verbose)
! 892: show_kernel(d);
! 893: }
! 894: if (opt_hex)
! 895: show_hex_dump(d);
! 896: if (verbose || opt_hex)
! 897: putchar('\n');
! 898: }
! 899:
! 900: static void
! 901: show(void)
! 902: {
! 903: struct device *d;
! 904:
! 905: for (d=first_dev; d; d=d->next)
! 906: show_device(d);
! 907: }
! 908:
! 909: /* Main */
! 910:
! 911: int
! 912: main(int argc, char **argv)
! 913: {
! 914: int i;
! 915: char *msg;
! 916:
! 917: if (argc == 2 && !strcmp(argv[1], "--version"))
! 918: {
! 919: puts("lspci version " PCIUTILS_VERSION);
! 920: return 0;
! 921: }
! 922:
! 923: pacc = pci_alloc();
! 924: pacc->error = die;
! 925: pci_filter_init(pacc, &filter);
! 926:
! 927: while ((i = getopt(argc, argv, options)) != -1)
! 928: switch (i)
! 929: {
! 930: case 'n':
! 931: pacc->numeric_ids++;
! 932: break;
! 933: case 'v':
! 934: verbose++;
! 935: break;
! 936: case 'b':
! 937: pacc->buscentric = 1;
! 938: break;
! 939: case 's':
! 940: if (msg = pci_filter_parse_slot(&filter, optarg))
! 941: die("-s: %s", msg);
! 942: break;
! 943: case 'd':
! 944: if (msg = pci_filter_parse_id(&filter, optarg))
! 945: die("-d: %s", msg);
! 946: break;
! 947: case 'x':
! 948: opt_hex++;
! 949: break;
! 950: case 't':
! 951: opt_tree++;
! 952: break;
! 953: case 'i':
! 954: pci_set_name_list_path(pacc, optarg, 0);
! 955: break;
! 956: case 'm':
! 957: opt_machine++;
! 958: break;
! 959: case 'p':
! 960: opt_pcimap = optarg;
! 961: break;
! 962: #ifdef PCI_OS_LINUX
! 963: case 'k':
! 964: opt_kernel++;
! 965: break;
! 966: #endif
! 967: case 'M':
! 968: opt_map_mode++;
! 969: break;
! 970: case 'D':
! 971: opt_domains = 2;
! 972: break;
! 973: #ifdef PCI_USE_DNS
! 974: case 'q':
! 975: opt_query_dns++;
! 976: break;
! 977: case 'Q':
! 978: opt_query_all = 1;
! 979: break;
! 980: #else
! 981: case 'q':
! 982: case 'Q':
! 983: die("DNS queries are not available in this version");
! 984: #endif
! 985: default:
! 986: if (parse_generic_option(i, pacc, optarg))
! 987: break;
! 988: bad:
! 989: fprintf(stderr, help_msg, pacc->id_file_name);
! 990: return 1;
! 991: }
! 992: if (optind < argc)
! 993: goto bad;
! 994:
! 995: if (opt_query_dns)
! 996: {
! 997: pacc->id_lookup_mode |= PCI_LOOKUP_NETWORK;
! 998: if (opt_query_dns > 1)
! 999: pacc->id_lookup_mode |= PCI_LOOKUP_REFRESH_CACHE;
! 1000: }
! 1001: if (opt_query_all)
! 1002: pacc->id_lookup_mode |= PCI_LOOKUP_NETWORK | PCI_LOOKUP_SKIP_LOCAL;
! 1003:
! 1004: pci_init(pacc);
! 1005: if (opt_map_mode)
! 1006: map_the_bus();
! 1007: else
! 1008: {
! 1009: scan_devices();
! 1010: sort_them();
! 1011: if (opt_tree)
! 1012: show_forest();
! 1013: else
! 1014: show();
! 1015: }
! 1016: pci_cleanup(pacc);
! 1017:
! 1018: return (seen_errors ? 2 : 0);
! 1019: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to lspci.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pciutils