]> mj.ucw.cz Git - pciutils.git/blob - lspci.c
Improved reporting of NUMA nodes
[pciutils.git] / lspci.c
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>][:<class>]\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 | PCI_FILL_LABEL);
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       if (p->label)
319         printf("\tDeviceName: %s", p->label);
320       get_subid(d, &subsys_v, &subsys_d);
321       if (subsys_v && subsys_v != 0xffff)
322         printf("\tSubsystem: %s\n",
323                 pci_lookup_name(pacc, ssnamebuf, sizeof(ssnamebuf),
324                         PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR | PCI_LOOKUP_DEVICE,
325                         p->vendor_id, p->device_id, subsys_v, subsys_d));
326     }
327 }
328
329 /*** Verbose output ***/
330
331 static void
332 show_size(pciaddr_t x)
333 {
334   static const char suffix[][2] = { "", "K", "M", "G", "T" };
335   unsigned i;
336   if (!x)
337     return;
338   for (i = 0; i < (sizeof(suffix) / sizeof(*suffix) - 1); i++) {
339     if (x < 1024)
340       break;
341     x /= 1024;
342   }
343   printf(" [size=%u%s]", (unsigned)x, suffix[i]);
344 }
345
346 static void
347 show_bases(struct device *d, int cnt)
348 {
349   struct pci_dev *p = d->dev;
350   word cmd = get_conf_word(d, PCI_COMMAND);
351   int i;
352   int virtual = 0;
353
354   for (i=0; i<cnt; i++)
355     {
356       pciaddr_t pos = p->base_addr[i];
357       pciaddr_t len = (p->known_fields & PCI_FILL_SIZES) ? p->size[i] : 0;
358       u32 flg = get_conf_long(d, PCI_BASE_ADDRESS_0 + 4*i);
359       if (flg == 0xffffffff)
360         flg = 0;
361       if (!pos && !flg && !len)
362         continue;
363       if (verbose > 1)
364         printf("\tRegion %d: ", i);
365       else
366         putchar('\t');
367       if (pos && !flg)                  /* Reported by the OS, but not by the device */
368         {
369           printf("[virtual] ");
370           flg = pos;
371           virtual = 1;
372         }
373       if (flg & PCI_BASE_ADDRESS_SPACE_IO)
374         {
375           pciaddr_t a = pos & PCI_BASE_ADDRESS_IO_MASK;
376           printf("I/O ports at ");
377           if (a || (cmd & PCI_COMMAND_IO))
378             printf(PCIADDR_PORT_FMT, a);
379           else if (flg & PCI_BASE_ADDRESS_IO_MASK)
380             printf("<ignored>");
381           else
382             printf("<unassigned>");
383           if (!virtual && !(cmd & PCI_COMMAND_IO))
384             printf(" [disabled]");
385         }
386       else
387         {
388           int t = flg & PCI_BASE_ADDRESS_MEM_TYPE_MASK;
389           pciaddr_t a = pos & PCI_ADDR_MEM_MASK;
390           int done = 0;
391           u32 z = 0;
392
393           printf("Memory at ");
394           if (t == PCI_BASE_ADDRESS_MEM_TYPE_64)
395             {
396               if (i >= cnt - 1)
397                 {
398                   printf("<invalid-64bit-slot>");
399                   done = 1;
400                 }
401               else
402                 {
403                   i++;
404                   z = get_conf_long(d, PCI_BASE_ADDRESS_0 + 4*i);
405                 }
406             }
407           if (!done)
408             {
409               if (a)
410                 printf(PCIADDR_T_FMT, a);
411               else
412                 printf(((flg & PCI_BASE_ADDRESS_MEM_MASK) || z) ? "<ignored>" : "<unassigned>");
413             }
414           printf(" (%s, %sprefetchable)",
415                  (t == PCI_BASE_ADDRESS_MEM_TYPE_32) ? "32-bit" :
416                  (t == PCI_BASE_ADDRESS_MEM_TYPE_64) ? "64-bit" :
417                  (t == PCI_BASE_ADDRESS_MEM_TYPE_1M) ? "low-1M" : "type 3",
418                  (flg & PCI_BASE_ADDRESS_MEM_PREFETCH) ? "" : "non-");
419           if (!virtual && !(cmd & PCI_COMMAND_MEMORY))
420             printf(" [disabled]");
421         }
422       show_size(len);
423       putchar('\n');
424     }
425 }
426
427 static void
428 show_rom(struct device *d, int reg)
429 {
430   struct pci_dev *p = d->dev;
431   pciaddr_t rom = p->rom_base_addr;
432   pciaddr_t len = (p->known_fields & PCI_FILL_SIZES) ? p->rom_size : 0;
433   u32 flg = get_conf_long(d, reg);
434   word cmd = get_conf_word(d, PCI_COMMAND);
435   int virtual = 0;
436
437   if (!rom && !flg && !len)
438     return;
439   putchar('\t');
440   if ((rom & PCI_ROM_ADDRESS_MASK) && !(flg & PCI_ROM_ADDRESS_MASK))
441     {
442       printf("[virtual] ");
443       flg = rom;
444       virtual = 1;
445     }
446   printf("Expansion ROM at ");
447   if (rom & PCI_ROM_ADDRESS_MASK)
448     printf(PCIADDR_T_FMT, rom & PCI_ROM_ADDRESS_MASK);
449   else if (flg & PCI_ROM_ADDRESS_MASK)
450     printf("<ignored>");
451   else
452     printf("<unassigned>");
453   if (!(flg & PCI_ROM_ADDRESS_ENABLE))
454     printf(" [disabled]");
455   else if (!virtual && !(cmd & PCI_COMMAND_MEMORY))
456     printf(" [disabled by cmd]");
457   show_size(len);
458   putchar('\n');
459 }
460
461 static void
462 show_htype0(struct device *d)
463 {
464   show_bases(d, 6);
465   show_rom(d, PCI_ROM_ADDRESS);
466   show_caps(d, PCI_CAPABILITY_LIST);
467 }
468
469 static void
470 show_htype1(struct device *d)
471 {
472   u32 io_base = get_conf_byte(d, PCI_IO_BASE);
473   u32 io_limit = get_conf_byte(d, PCI_IO_LIMIT);
474   u32 io_type = io_base & PCI_IO_RANGE_TYPE_MASK;
475   u32 mem_base = get_conf_word(d, PCI_MEMORY_BASE);
476   u32 mem_limit = get_conf_word(d, PCI_MEMORY_LIMIT);
477   u32 mem_type = mem_base & PCI_MEMORY_RANGE_TYPE_MASK;
478   u32 pref_base = get_conf_word(d, PCI_PREF_MEMORY_BASE);
479   u32 pref_limit = get_conf_word(d, PCI_PREF_MEMORY_LIMIT);
480   u32 pref_type = pref_base & PCI_PREF_RANGE_TYPE_MASK;
481   word sec_stat = get_conf_word(d, PCI_SEC_STATUS);
482   word brc = get_conf_word(d, PCI_BRIDGE_CONTROL);
483   int verb = verbose > 2;
484
485   show_bases(d, 2);
486   printf("\tBus: primary=%02x, secondary=%02x, subordinate=%02x, sec-latency=%d\n",
487          get_conf_byte(d, PCI_PRIMARY_BUS),
488          get_conf_byte(d, PCI_SECONDARY_BUS),
489          get_conf_byte(d, PCI_SUBORDINATE_BUS),
490          get_conf_byte(d, PCI_SEC_LATENCY_TIMER));
491
492   if (io_type != (io_limit & PCI_IO_RANGE_TYPE_MASK) ||
493       (io_type != PCI_IO_RANGE_TYPE_16 && io_type != PCI_IO_RANGE_TYPE_32))
494     printf("\t!!! Unknown I/O range types %x/%x\n", io_base, io_limit);
495   else
496     {
497       io_base = (io_base & PCI_IO_RANGE_MASK) << 8;
498       io_limit = (io_limit & PCI_IO_RANGE_MASK) << 8;
499       if (io_type == PCI_IO_RANGE_TYPE_32)
500         {
501           io_base |= (get_conf_word(d, PCI_IO_BASE_UPPER16) << 16);
502           io_limit |= (get_conf_word(d, PCI_IO_LIMIT_UPPER16) << 16);
503         }
504       if (io_base <= io_limit || verb)
505         printf("\tI/O behind bridge: %08x-%08x\n", io_base, io_limit+0xfff);
506     }
507
508   if (mem_type != (mem_limit & PCI_MEMORY_RANGE_TYPE_MASK) ||
509       mem_type)
510     printf("\t!!! Unknown memory range types %x/%x\n", mem_base, mem_limit);
511   else
512     {
513       mem_base = (mem_base & PCI_MEMORY_RANGE_MASK) << 16;
514       mem_limit = (mem_limit & PCI_MEMORY_RANGE_MASK) << 16;
515       if (mem_base <= mem_limit || verb)
516         printf("\tMemory behind bridge: %08x-%08x\n", mem_base, mem_limit + 0xfffff);
517     }
518
519   if (pref_type != (pref_limit & PCI_PREF_RANGE_TYPE_MASK) ||
520       (pref_type != PCI_PREF_RANGE_TYPE_32 && pref_type != PCI_PREF_RANGE_TYPE_64))
521     printf("\t!!! Unknown prefetchable memory range types %x/%x\n", pref_base, pref_limit);
522   else
523     {
524       pref_base = (pref_base & PCI_PREF_RANGE_MASK) << 16;
525       pref_limit = (pref_limit & PCI_PREF_RANGE_MASK) << 16;
526       if (pref_base <= pref_limit || verb)
527         {
528           if (pref_type == PCI_PREF_RANGE_TYPE_32)
529             printf("\tPrefetchable memory behind bridge: %08x-%08x\n", pref_base, pref_limit + 0xfffff);
530           else
531             printf("\tPrefetchable memory behind bridge: %08x%08x-%08x%08x\n",
532                    get_conf_long(d, PCI_PREF_BASE_UPPER32),
533                    pref_base,
534                    get_conf_long(d, PCI_PREF_LIMIT_UPPER32),
535                    pref_limit + 0xfffff);
536         }
537     }
538
539   if (verbose > 1)
540     printf("\tSecondary status: 66MHz%c FastB2B%c ParErr%c DEVSEL=%s >TAbort%c <TAbort%c <MAbort%c <SERR%c <PERR%c\n",
541              FLAG(sec_stat, PCI_STATUS_66MHZ),
542              FLAG(sec_stat, PCI_STATUS_FAST_BACK),
543              FLAG(sec_stat, PCI_STATUS_PARITY),
544              ((sec_stat & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_SLOW) ? "slow" :
545              ((sec_stat & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_MEDIUM) ? "medium" :
546              ((sec_stat & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_FAST) ? "fast" : "??",
547              FLAG(sec_stat, PCI_STATUS_SIG_TARGET_ABORT),
548              FLAG(sec_stat, PCI_STATUS_REC_TARGET_ABORT),
549              FLAG(sec_stat, PCI_STATUS_REC_MASTER_ABORT),
550              FLAG(sec_stat, PCI_STATUS_SIG_SYSTEM_ERROR),
551              FLAG(sec_stat, PCI_STATUS_DETECTED_PARITY));
552
553   show_rom(d, PCI_ROM_ADDRESS1);
554
555   if (verbose > 1)
556     {
557       printf("\tBridgeCtl: Parity%c SERR%c NoISA%c VGA%c MAbort%c >Reset%c FastB2B%c\n",
558         FLAG(brc, PCI_BRIDGE_CTL_PARITY),
559         FLAG(brc, PCI_BRIDGE_CTL_SERR),
560         FLAG(brc, PCI_BRIDGE_CTL_NO_ISA),
561         FLAG(brc, PCI_BRIDGE_CTL_VGA),
562         FLAG(brc, PCI_BRIDGE_CTL_MASTER_ABORT),
563         FLAG(brc, PCI_BRIDGE_CTL_BUS_RESET),
564         FLAG(brc, PCI_BRIDGE_CTL_FAST_BACK));
565       printf("\t\tPriDiscTmr%c SecDiscTmr%c DiscTmrStat%c DiscTmrSERREn%c\n",
566         FLAG(brc, PCI_BRIDGE_CTL_PRI_DISCARD_TIMER),
567         FLAG(brc, PCI_BRIDGE_CTL_SEC_DISCARD_TIMER),
568         FLAG(brc, PCI_BRIDGE_CTL_DISCARD_TIMER_STATUS),
569         FLAG(brc, PCI_BRIDGE_CTL_DISCARD_TIMER_SERR_EN));
570     }
571
572   show_caps(d, PCI_CAPABILITY_LIST);
573 }
574
575 static void
576 show_htype2(struct device *d)
577 {
578   int i;
579   word cmd = get_conf_word(d, PCI_COMMAND);
580   word brc = get_conf_word(d, PCI_CB_BRIDGE_CONTROL);
581   word exca;
582   int verb = verbose > 2;
583
584   show_bases(d, 1);
585   printf("\tBus: primary=%02x, secondary=%02x, subordinate=%02x, sec-latency=%d\n",
586          get_conf_byte(d, PCI_CB_PRIMARY_BUS),
587          get_conf_byte(d, PCI_CB_CARD_BUS),
588          get_conf_byte(d, PCI_CB_SUBORDINATE_BUS),
589          get_conf_byte(d, PCI_CB_LATENCY_TIMER));
590   for (i=0; i<2; i++)
591     {
592       int p = 8*i;
593       u32 base = get_conf_long(d, PCI_CB_MEMORY_BASE_0 + p);
594       u32 limit = get_conf_long(d, PCI_CB_MEMORY_LIMIT_0 + p);
595       limit = limit + 0xfff;
596       if (base <= limit || verb)
597         printf("\tMemory window %d: %08x-%08x%s%s\n", i, base, limit,
598                (cmd & PCI_COMMAND_MEMORY) ? "" : " [disabled]",
599                (brc & (PCI_CB_BRIDGE_CTL_PREFETCH_MEM0 << i)) ? " (prefetchable)" : "");
600     }
601   for (i=0; i<2; i++)
602     {
603       int p = 8*i;
604       u32 base = get_conf_long(d, PCI_CB_IO_BASE_0 + p);
605       u32 limit = get_conf_long(d, PCI_CB_IO_LIMIT_0 + p);
606       if (!(base & PCI_IO_RANGE_TYPE_32))
607         {
608           base &= 0xffff;
609           limit &= 0xffff;
610         }
611       base &= PCI_CB_IO_RANGE_MASK;
612       limit = (limit & PCI_CB_IO_RANGE_MASK) + 3;
613       if (base <= limit || verb)
614         printf("\tI/O window %d: %08x-%08x%s\n", i, base, limit,
615                (cmd & PCI_COMMAND_IO) ? "" : " [disabled]");
616     }
617
618   if (get_conf_word(d, PCI_CB_SEC_STATUS) & PCI_STATUS_SIG_SYSTEM_ERROR)
619     printf("\tSecondary status: SERR\n");
620   if (verbose > 1)
621     printf("\tBridgeCtl: Parity%c SERR%c ISA%c VGA%c MAbort%c >Reset%c 16bInt%c PostWrite%c\n",
622            FLAG(brc, PCI_CB_BRIDGE_CTL_PARITY),
623            FLAG(brc, PCI_CB_BRIDGE_CTL_SERR),
624            FLAG(brc, PCI_CB_BRIDGE_CTL_ISA),
625            FLAG(brc, PCI_CB_BRIDGE_CTL_VGA),
626            FLAG(brc, PCI_CB_BRIDGE_CTL_MASTER_ABORT),
627            FLAG(brc, PCI_CB_BRIDGE_CTL_CB_RESET),
628            FLAG(brc, PCI_CB_BRIDGE_CTL_16BIT_INT),
629            FLAG(brc, PCI_CB_BRIDGE_CTL_POST_WRITES));
630
631   if (d->config_cached < 128)
632     {
633       printf("\t<access denied to the rest>\n");
634       return;
635     }
636
637   exca = get_conf_word(d, PCI_CB_LEGACY_MODE_BASE);
638   if (exca)
639     printf("\t16-bit legacy interface ports at %04x\n", exca);
640   show_caps(d, PCI_CB_CAPABILITY_LIST);
641 }
642
643 static void
644 show_verbose(struct device *d)
645 {
646   struct pci_dev *p = d->dev;
647   word status = get_conf_word(d, PCI_STATUS);
648   word cmd = get_conf_word(d, PCI_COMMAND);
649   word class = p->device_class;
650   byte bist = get_conf_byte(d, PCI_BIST);
651   byte htype = get_conf_byte(d, PCI_HEADER_TYPE) & 0x7f;
652   byte latency = get_conf_byte(d, PCI_LATENCY_TIMER);
653   byte cache_line = get_conf_byte(d, PCI_CACHE_LINE_SIZE);
654   byte max_lat, min_gnt;
655   byte int_pin = get_conf_byte(d, PCI_INTERRUPT_PIN);
656   unsigned int irq = p->irq;
657
658   show_terse(d);
659
660   switch (htype)
661     {
662     case PCI_HEADER_TYPE_NORMAL:
663       if (class == PCI_CLASS_BRIDGE_PCI)
664         printf("\t!!! Invalid class %04x for header type %02x\n", class, htype);
665       max_lat = get_conf_byte(d, PCI_MAX_LAT);
666       min_gnt = get_conf_byte(d, PCI_MIN_GNT);
667       break;
668     case PCI_HEADER_TYPE_BRIDGE:
669       if ((class >> 8) != PCI_BASE_CLASS_BRIDGE)
670         printf("\t!!! Invalid class %04x for header type %02x\n", class, htype);
671       min_gnt = max_lat = 0;
672       break;
673     case PCI_HEADER_TYPE_CARDBUS:
674       if ((class >> 8) != PCI_BASE_CLASS_BRIDGE)
675         printf("\t!!! Invalid class %04x for header type %02x\n", class, htype);
676       min_gnt = max_lat = 0;
677       break;
678     default:
679       printf("\t!!! Unknown header type %02x\n", htype);
680       return;
681     }
682
683   if (p->phy_slot)
684     printf("\tPhysical Slot: %s\n", p->phy_slot);
685
686   if (verbose > 1)
687     {
688       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",
689              FLAG(cmd, PCI_COMMAND_IO),
690              FLAG(cmd, PCI_COMMAND_MEMORY),
691              FLAG(cmd, PCI_COMMAND_MASTER),
692              FLAG(cmd, PCI_COMMAND_SPECIAL),
693              FLAG(cmd, PCI_COMMAND_INVALIDATE),
694              FLAG(cmd, PCI_COMMAND_VGA_PALETTE),
695              FLAG(cmd, PCI_COMMAND_PARITY),
696              FLAG(cmd, PCI_COMMAND_WAIT),
697              FLAG(cmd, PCI_COMMAND_SERR),
698              FLAG(cmd, PCI_COMMAND_FAST_BACK),
699              FLAG(cmd, PCI_COMMAND_DISABLE_INTx));
700       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",
701              FLAG(status, PCI_STATUS_CAP_LIST),
702              FLAG(status, PCI_STATUS_66MHZ),
703              FLAG(status, PCI_STATUS_UDF),
704              FLAG(status, PCI_STATUS_FAST_BACK),
705              FLAG(status, PCI_STATUS_PARITY),
706              ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_SLOW) ? "slow" :
707              ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_MEDIUM) ? "medium" :
708              ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_FAST) ? "fast" : "??",
709              FLAG(status, PCI_STATUS_SIG_TARGET_ABORT),
710              FLAG(status, PCI_STATUS_REC_TARGET_ABORT),
711              FLAG(status, PCI_STATUS_REC_MASTER_ABORT),
712              FLAG(status, PCI_STATUS_SIG_SYSTEM_ERROR),
713              FLAG(status, PCI_STATUS_DETECTED_PARITY),
714              FLAG(status, PCI_STATUS_INTx));
715       if (cmd & PCI_COMMAND_MASTER)
716         {
717           printf("\tLatency: %d", latency);
718           if (min_gnt || max_lat)
719             {
720               printf(" (");
721               if (min_gnt)
722                 printf("%dns min", min_gnt*250);
723               if (min_gnt && max_lat)
724                 printf(", ");
725               if (max_lat)
726                 printf("%dns max", max_lat*250);
727               putchar(')');
728             }
729           if (cache_line)
730             printf(", Cache Line Size: %d bytes", cache_line * 4);
731           putchar('\n');
732         }
733       if (int_pin || irq)
734         printf("\tInterrupt: pin %c routed to IRQ " PCIIRQ_FMT "\n",
735                (int_pin ? 'A' + int_pin - 1 : '?'), irq);
736       if (p->numa_node != -1)
737         printf("\tNUMA node: %d\n", p->numa_node);
738     }
739   else
740     {
741       printf("\tFlags: ");
742       if (cmd & PCI_COMMAND_MASTER)
743         printf("bus master, ");
744       if (cmd & PCI_COMMAND_VGA_PALETTE)
745         printf("VGA palette snoop, ");
746       if (cmd & PCI_COMMAND_WAIT)
747         printf("stepping, ");
748       if (cmd & PCI_COMMAND_FAST_BACK)
749         printf("fast Back2Back, ");
750       if (status & PCI_STATUS_66MHZ)
751         printf("66MHz, ");
752       if (status & PCI_STATUS_UDF)
753         printf("user-definable features, ");
754       printf("%s devsel",
755              ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_SLOW) ? "slow" :
756              ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_MEDIUM) ? "medium" :
757              ((status & PCI_STATUS_DEVSEL_MASK) == PCI_STATUS_DEVSEL_FAST) ? "fast" : "??");
758       if (cmd & PCI_COMMAND_MASTER)
759         printf(", latency %d", latency);
760       if (irq)
761         printf(", IRQ " PCIIRQ_FMT, irq);
762       if (p->numa_node != -1)
763         printf(", NUMA node %d", p->numa_node);
764       putchar('\n');
765     }
766
767   if (bist & PCI_BIST_CAPABLE)
768     {
769       if (bist & PCI_BIST_START)
770         printf("\tBIST is running\n");
771       else
772         printf("\tBIST result: %02x\n", bist & PCI_BIST_CODE_MASK);
773     }
774
775   switch (htype)
776     {
777     case PCI_HEADER_TYPE_NORMAL:
778       show_htype0(d);
779       break;
780     case PCI_HEADER_TYPE_BRIDGE:
781       show_htype1(d);
782       break;
783     case PCI_HEADER_TYPE_CARDBUS:
784       show_htype2(d);
785       break;
786     }
787 }
788
789 /*** Machine-readable dumps ***/
790
791 static void
792 show_hex_dump(struct device *d)
793 {
794   unsigned int i, cnt;
795
796   cnt = d->config_cached;
797   if (opt_hex >= 3 && config_fetch(d, cnt, 256-cnt))
798     {
799       cnt = 256;
800       if (opt_hex >= 4 && config_fetch(d, 256, 4096-256))
801         cnt = 4096;
802     }
803
804   for (i=0; i<cnt; i++)
805     {
806       if (! (i & 15))
807         printf("%02x:", i);
808       printf(" %02x", get_conf_byte(d, i));
809       if ((i & 15) == 15)
810         putchar('\n');
811     }
812 }
813
814 static void
815 print_shell_escaped(char *c)
816 {
817   printf(" \"");
818   while (*c)
819     {
820       if (*c == '"' || *c == '\\')
821         putchar('\\');
822       putchar(*c++);
823     }
824   putchar('"');
825 }
826
827 static void
828 show_machine(struct device *d)
829 {
830   struct pci_dev *p = d->dev;
831   int c;
832   word sv_id, sd_id;
833   char classbuf[128], vendbuf[128], devbuf[128], svbuf[128], sdbuf[128];
834
835   get_subid(d, &sv_id, &sd_id);
836
837   if (verbose)
838     {
839       printf((opt_machine >= 2) ? "Slot:\t" : "Device:\t");
840       show_slot_name(d);
841       putchar('\n');
842       printf("Class:\t%s\n",
843              pci_lookup_name(pacc, classbuf, sizeof(classbuf), PCI_LOOKUP_CLASS, p->device_class));
844       printf("Vendor:\t%s\n",
845              pci_lookup_name(pacc, vendbuf, sizeof(vendbuf), PCI_LOOKUP_VENDOR, p->vendor_id, p->device_id));
846       printf("Device:\t%s\n",
847              pci_lookup_name(pacc, devbuf, sizeof(devbuf), PCI_LOOKUP_DEVICE, p->vendor_id, p->device_id));
848       if (sv_id && sv_id != 0xffff)
849         {
850           printf("SVendor:\t%s\n",
851                  pci_lookup_name(pacc, svbuf, sizeof(svbuf), PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR, sv_id));
852           printf("SDevice:\t%s\n",
853                  pci_lookup_name(pacc, sdbuf, sizeof(sdbuf), PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_DEVICE, p->vendor_id, p->device_id, sv_id, sd_id));
854         }
855       if (p->phy_slot)
856         printf("PhySlot:\t%s\n", p->phy_slot);
857       if (c = get_conf_byte(d, PCI_REVISION_ID))
858         printf("Rev:\t%02x\n", c);
859       if (c = get_conf_byte(d, PCI_CLASS_PROG))
860         printf("ProgIf:\t%02x\n", c);
861       if (opt_kernel)
862         show_kernel_machine(d);
863       if (p->numa_node != -1)
864         printf("NUMANode:\t%d\n", p->numa_node);
865     }
866   else
867     {
868       show_slot_name(d);
869       print_shell_escaped(pci_lookup_name(pacc, classbuf, sizeof(classbuf), PCI_LOOKUP_CLASS, p->device_class));
870       print_shell_escaped(pci_lookup_name(pacc, vendbuf, sizeof(vendbuf), PCI_LOOKUP_VENDOR, p->vendor_id, p->device_id));
871       print_shell_escaped(pci_lookup_name(pacc, devbuf, sizeof(devbuf), PCI_LOOKUP_DEVICE, p->vendor_id, p->device_id));
872       if (c = get_conf_byte(d, PCI_REVISION_ID))
873         printf(" -r%02x", c);
874       if (c = get_conf_byte(d, PCI_CLASS_PROG))
875         printf(" -p%02x", c);
876       if (sv_id && sv_id != 0xffff)
877         {
878           print_shell_escaped(pci_lookup_name(pacc, svbuf, sizeof(svbuf), PCI_LOOKUP_SUBSYSTEM | PCI_LOOKUP_VENDOR, sv_id));
879           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));
880         }
881       else
882         printf(" \"\" \"\"");
883       putchar('\n');
884     }
885 }
886
887 /*** Main show function ***/
888
889 void
890 show_device(struct device *d)
891 {
892   if (opt_machine)
893     show_machine(d);
894   else
895     {
896       if (verbose)
897         show_verbose(d);
898       else
899         show_terse(d);
900       if (opt_kernel || verbose)
901         show_kernel(d);
902     }
903   if (opt_hex)
904     show_hex_dump(d);
905   if (verbose || opt_hex)
906     putchar('\n');
907 }
908
909 static void
910 show(void)
911 {
912   struct device *d;
913
914   for (d=first_dev; d; d=d->next)
915     show_device(d);
916 }
917
918 /* Main */
919
920 int
921 main(int argc, char **argv)
922 {
923   int i;
924   char *msg;
925
926   if (argc == 2 && !strcmp(argv[1], "--version"))
927     {
928       puts("lspci version " PCIUTILS_VERSION);
929       return 0;
930     }
931
932   pacc = pci_alloc();
933   pacc->error = die;
934   pci_filter_init(pacc, &filter);
935
936   while ((i = getopt(argc, argv, options)) != -1)
937     switch (i)
938       {
939       case 'n':
940         pacc->numeric_ids++;
941         break;
942       case 'v':
943         verbose++;
944         break;
945       case 'b':
946         pacc->buscentric = 1;
947         break;
948       case 's':
949         if (msg = pci_filter_parse_slot(&filter, optarg))
950           die("-s: %s", msg);
951         break;
952       case 'd':
953         if (msg = pci_filter_parse_id(&filter, optarg))
954           die("-d: %s", msg);
955         break;
956       case 'x':
957         opt_hex++;
958         break;
959       case 't':
960         opt_tree++;
961         break;
962       case 'i':
963         pci_set_name_list_path(pacc, optarg, 0);
964         break;
965       case 'm':
966         opt_machine++;
967         break;
968       case 'p':
969         opt_pcimap = optarg;
970         break;
971 #ifdef PCI_OS_LINUX
972       case 'k':
973         opt_kernel++;
974         break;
975 #endif
976       case 'M':
977         opt_map_mode++;
978         break;
979       case 'D':
980         opt_domains = 2;
981         break;
982 #ifdef PCI_USE_DNS
983       case 'q':
984         opt_query_dns++;
985         break;
986       case 'Q':
987         opt_query_all = 1;
988         break;
989 #else
990       case 'q':
991       case 'Q':
992         die("DNS queries are not available in this version");
993 #endif
994       default:
995         if (parse_generic_option(i, pacc, optarg))
996           break;
997       bad:
998         fprintf(stderr, help_msg, pacc->id_file_name);
999         return 1;
1000       }
1001   if (optind < argc)
1002     goto bad;
1003
1004   if (opt_query_dns)
1005     {
1006       pacc->id_lookup_mode |= PCI_LOOKUP_NETWORK;
1007       if (opt_query_dns > 1)
1008         pacc->id_lookup_mode |= PCI_LOOKUP_REFRESH_CACHE;
1009     }
1010   if (opt_query_all)
1011     pacc->id_lookup_mode |= PCI_LOOKUP_NETWORK | PCI_LOOKUP_SKIP_LOCAL;
1012
1013   pci_init(pacc);
1014   if (opt_map_mode)
1015     map_the_bus();
1016   else
1017     {
1018       scan_devices();
1019       sort_them();
1020       if (opt_tree)
1021         show_forest();
1022       else
1023         show();
1024     }
1025   show_kernel_cleanup();
1026   pci_cleanup(pacc);
1027
1028   return (seen_errors ? 2 : 0);
1029 }