lspci.c 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237
  1. /* lspci command: enumerate PCI functions.
  2. *
  3. * lspci one line per function:
  4. * bb:dd.f vvvv:dddd rNN class CCSS irq NN
  5. * lspci <filter> additionally print BAR details for every function whose
  6. * "vvvv:dddd" or "CCSS" contains <filter> (hex, case
  7. * insensitive), e.g. `lspci 8168` or `lspci 0200`.
  8. *
  9. * BAR sizes are probed by writing all-ones and restoring the original value
  10. * (the same trick lspci(8) uses). Probing only happens for filter matches,
  11. * so a plain `lspci` never touches config space.
  12. */
  13. #include "io.h"
  14. #include "pci.h"
  15. static void put_hex2(unsigned int v)
  16. {
  17. static const char hex[] = "0123456789ABCDEF";
  18. io_putchar(hex[(v >> 4) & 0xF]);
  19. io_putchar(hex[v & 0xF]);
  20. }
  21. static void put_hex4(unsigned int v)
  22. {
  23. put_hex2((v >> 8) & 0xFF);
  24. put_hex2(v & 0xFF);
  25. }
  26. static void put_hex8(unsigned int v)
  27. {
  28. put_hex4((v >> 16) & 0xFFFF);
  29. put_hex4(v & 0xFFFF);
  30. }
  31. static void put_dec(unsigned int v)
  32. {
  33. char b[12];
  34. int i = 0;
  35. if (v == 0) {
  36. io_putchar('0');
  37. return;
  38. }
  39. while (v) {
  40. b[i++] = (char)('0' + (v % 10));
  41. v /= 10;
  42. }
  43. while (i)
  44. io_putchar(b[--i]);
  45. }
  46. static void put_size(unsigned int bytes)
  47. {
  48. if (bytes == 0) {
  49. io_putchar('?');
  50. } else if (bytes >= 1024u * 1024u) {
  51. put_dec(bytes / (1024u * 1024u));
  52. io_putchar('M');
  53. } else if (bytes >= 1024u) {
  54. put_dec(bytes / 1024u);
  55. io_putchar('K');
  56. } else {
  57. put_dec(bytes);
  58. io_putchar('B');
  59. }
  60. }
  61. static void hex_str(char *dst, unsigned int v, unsigned int digits)
  62. {
  63. static const char hex[] = "0123456789ABCDEF";
  64. unsigned int i;
  65. for (i = 0; i < digits; i++)
  66. dst[i] = hex[(v >> (4 * (digits - 1 - i))) & 0xF];
  67. dst[digits] = '\0';
  68. }
  69. static char lcc(char c)
  70. {
  71. return (c >= 'A' && c <= 'Z') ? (char)(c - 'A' + 'a') : c;
  72. }
  73. static int contains_ci(const char *hay, const char *needle)
  74. {
  75. unsigned int i, j;
  76. if (!needle[0])
  77. return 1;
  78. for (i = 0; hay[i]; i++) {
  79. for (j = 0; needle[j] && hay[i + j] &&
  80. lcc(hay[i + j]) == lcc(needle[j]); j++)
  81. ;
  82. if (!needle[j])
  83. return 1;
  84. }
  85. return 0;
  86. }
  87. static const char *class_name(unsigned int cls)
  88. {
  89. switch (cls) {
  90. case 0x00: return "legacy";
  91. case 0x01: return "storage";
  92. case 0x02: return "net";
  93. case 0x03: return "display";
  94. case 0x04: return "multimedia";
  95. case 0x06: return "bridge";
  96. case 0x08: return "system";
  97. case 0x0C: return "serial";
  98. default: return 0;
  99. }
  100. }
  101. /* Print one BAR; returns the number of config slots consumed (2 for 64-bit). */
  102. static unsigned int print_bar(unsigned int bus, unsigned int dev,
  103. unsigned int func, unsigned int index)
  104. {
  105. unsigned int reg = 0x10u + 4u * index;
  106. unsigned int val = pci_cfg_read32(bus, dev, func, reg);
  107. unsigned int is64, hi, mask;
  108. if (val == 0 || val == 0xFFFFFFFFu)
  109. return 1; /* not implemented */
  110. if (!(val & 1u) && !(val & 0xFFFFFFF0u))
  111. return 1; /* mem BAR without a base */
  112. io_putstr(" bar");
  113. put_dec(index);
  114. io_putstr((val & 1u) ? " i/o " : " mem ");
  115. if (val & 1u) {
  116. pci_cfg_write32(bus, dev, func, reg, 0xFFFFFFFFu);
  117. mask = pci_cfg_read32(bus, dev, func, reg) & 0xFFFFFFFCu;
  118. pci_cfg_write32(bus, dev, func, reg, val);
  119. put_hex4(val & 0xFFFCu);
  120. io_putstr(" (");
  121. put_size(mask ? (~mask + 1u) : 0);
  122. io_putchar(')');
  123. io_putchar('\n');
  124. return 1;
  125. }
  126. is64 = (val & 4u) ? 1u : 0u;
  127. hi = is64 ? pci_cfg_read32(bus, dev, func, reg + 4) : 0;
  128. pci_cfg_write32(bus, dev, func, reg, 0xFFFFFFFFu);
  129. if (is64)
  130. pci_cfg_write32(bus, dev, func, reg + 4, 0xFFFFFFFFu);
  131. mask = pci_cfg_read32(bus, dev, func, reg) & 0xFFFFFFF0u;
  132. pci_cfg_write32(bus, dev, func, reg, val);
  133. if (is64)
  134. pci_cfg_write32(bus, dev, func, reg + 4, hi);
  135. if (hi)
  136. put_hex8(hi);
  137. put_hex8(val & 0xFFFFFFF0u);
  138. io_putstr(" (");
  139. put_size(mask ? (~mask + 1u) : 0);
  140. if (is64)
  141. io_putstr(", 64b");
  142. if (val & 8u)
  143. io_putstr(", pf");
  144. io_putchar(')');
  145. io_putchar('\n');
  146. return is64 ? 2u : 1u;
  147. }
  148. void program_lspci_main(const char *filter)
  149. {
  150. unsigned int bus, dev, func, nfunc, matches = 0;
  151. for (bus = 0; bus < 256; bus++) {
  152. for (dev = 0; dev < 32; dev++) {
  153. unsigned int id = pci_cfg_read32(bus, dev, 0, 0x00);
  154. unsigned int htype;
  155. if (id == 0xFFFFFFFFu || id == 0)
  156. continue;
  157. /* Multifunction if header type bit 7 is set. */
  158. htype = (pci_cfg_read32(bus, dev, 0, 0x0C) >> 16) & 0xFFu;
  159. nfunc = (htype & 0x80u) ? 8u : 1u;
  160. for (func = 0; func < nfunc; func++) {
  161. unsigned int idf = pci_cfg_read32(bus, dev, func, 0x00);
  162. unsigned int class_rev, cls, sub, irq, b;
  163. const char *cn;
  164. char vd[10], cs[5];
  165. if (idf == 0xFFFFFFFFu || idf == 0)
  166. continue;
  167. class_rev = pci_cfg_read32(bus, dev, func, 0x08);
  168. cls = (class_rev >> 24) & 0xFFu;
  169. sub = (class_rev >> 16) & 0xFFu;
  170. irq = pci_cfg_read32(bus, dev, func, 0x3C) & 0xFFu;
  171. hex_str(vd, idf & 0xFFFFu, 4);
  172. vd[4] = ':';
  173. hex_str(vd + 5, (idf >> 16) & 0xFFFFu, 4);
  174. hex_str(cs, (cls << 8) | sub, 4);
  175. put_hex2(bus);
  176. io_putchar(':');
  177. put_hex2(dev);
  178. io_putchar('.');
  179. io_putchar((char)('0' + func));
  180. io_putchar(' ');
  181. io_putstr(vd);
  182. io_putstr(" r");
  183. put_hex2(class_rev & 0xFFu);
  184. io_putstr(" class ");
  185. io_putstr(cs);
  186. cn = class_name(cls);
  187. if (cn) {
  188. io_putchar(' ');
  189. io_putstr(cn);
  190. }
  191. io_putstr(" irq ");
  192. put_dec(irq);
  193. io_putchar('\n');
  194. if (!contains_ci(vd, filter) && !contains_ci(cs, filter))
  195. continue;
  196. matches++;
  197. for (b = 0; b < 6; )
  198. b += print_bar(bus, dev, func, b);
  199. }
  200. }
  201. }
  202. if (filter[0] && matches == 0) {
  203. io_putstr("lspci: no match for ");
  204. io_putstr(filter);
  205. io_putchar('\n');
  206. }
  207. }