acpi.c 7.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314
  1. /* Minimal ACPI RSDP/RSDT/XSDT/MADT parser. See acpi.h.
  2. *
  3. * ACPI tables are usually below the 128 MB identity map, but on larger
  4. * machines they can sit above it; every table page is mapped through
  5. * paging_map_ram() before it is read. Anything malformed or unsupported is
  6. * treated as "no SMP", never as a fatal error.
  7. */
  8. #include "acpi.h"
  9. #include "paging.h"
  10. #include "serial.h"
  11. struct acpi_rsdp {
  12. char signature[8];
  13. unsigned char checksum;
  14. char oem_id[6];
  15. unsigned char revision;
  16. unsigned int rsdt;
  17. unsigned int length;
  18. unsigned long long xsdt;
  19. unsigned char ext_checksum;
  20. unsigned char reserved[3];
  21. } __attribute__((packed));
  22. struct acpi_sdt {
  23. char signature[4];
  24. unsigned int length;
  25. unsigned char revision;
  26. unsigned char checksum;
  27. char oem_id[6];
  28. char oem_table_id[8];
  29. unsigned int oem_revision;
  30. unsigned int creator_id;
  31. unsigned int creator_revision;
  32. } __attribute__((packed));
  33. #define RSDP_SIG "RSD PTR "
  34. #define MADT_SIG "APIC"
  35. #define LAPIC_DEFAULT 0xFEE00000u
  36. static unsigned int ids[ACPI_MAX_CPUS];
  37. static unsigned int ncpu;
  38. static unsigned int bsp_apic;
  39. static unsigned int lapic_base;
  40. static int acpi_ok;
  41. static void *phys_ptr(unsigned int addr)
  42. {
  43. return (void *)addr;
  44. }
  45. static int range_ok(unsigned int addr, unsigned int len)
  46. {
  47. if (addr >= 0xFFFFF000u || len > 0x100000u)
  48. return 0;
  49. return addr + len >= addr;
  50. }
  51. /* Map every 4 MB page touched by [addr, addr+len). */
  52. static void map_table(unsigned int addr, unsigned int len)
  53. {
  54. unsigned int p = addr & 0xFFC00000u;
  55. unsigned int last = (addr + len - 1u) & 0xFFC00000u;
  56. for (;;) {
  57. paging_map_ram(p, 0x400000u);
  58. if (p >= last)
  59. break;
  60. if (p > 0xFFC00000u - 0x400000u)
  61. break;
  62. p += 0x400000u;
  63. }
  64. }
  65. static int sum_ok(const unsigned char *p, unsigned int len)
  66. {
  67. unsigned char sum = 0;
  68. unsigned int i;
  69. for (i = 0; i < len; i++)
  70. sum = (unsigned char)(sum + p[i]);
  71. return sum == 0;
  72. }
  73. static int rsdp_valid(const struct acpi_rsdp *r)
  74. {
  75. unsigned int i;
  76. for (i = 0; i < 8; i++)
  77. if (r->signature[i] != RSDP_SIG[i])
  78. return 0;
  79. if (!sum_ok((const unsigned char *)r, 20))
  80. return 0;
  81. if (r->revision >= 2) {
  82. if (r->length < 36 || r->length > 4096)
  83. return 0;
  84. if (!sum_ok((const unsigned char *)r, r->length))
  85. return 0;
  86. }
  87. return 1;
  88. }
  89. static const struct acpi_rsdp *find_rsdp(void)
  90. {
  91. volatile unsigned short *ebda_seg = (volatile unsigned short *)0x40E;
  92. unsigned int ebda, i;
  93. /* Opaque asm keeps -Warray-bounds quiet about the fixed BIOS pointer. */
  94. __asm__ volatile ("" : "+r"(ebda_seg));
  95. ebda = (unsigned int)(*ebda_seg) << 4;
  96. if (ebda) {
  97. for (i = 0; i < 1024; i += 16) {
  98. const struct acpi_rsdp *r =
  99. (const struct acpi_rsdp *)(ebda + i);
  100. if (rsdp_valid(r))
  101. return r;
  102. }
  103. }
  104. for (i = 0xE0000; i < 0x100000; i += 16) {
  105. const struct acpi_rsdp *r =
  106. (const struct acpi_rsdp *)(i);
  107. if (rsdp_valid(r))
  108. return r;
  109. }
  110. return 0;
  111. }
  112. static const struct acpi_sdt *find_madt(const struct acpi_rsdp *rsdp)
  113. {
  114. unsigned int addr, len, i, step;
  115. const struct acpi_sdt *sdt;
  116. /* Prefer the 64-bit XSDT when it is reachable from the 32-bit
  117. * identity map; otherwise fall back to the ACPI 1.0 RSDT. */
  118. if (rsdp->revision >= 2 && rsdp->xsdt &&
  119. (unsigned int)(rsdp->xsdt >> 32) == 0) {
  120. addr = (unsigned int)rsdp->xsdt;
  121. step = 8;
  122. } else {
  123. addr = rsdp->rsdt;
  124. step = 4;
  125. }
  126. if (!addr || !range_ok(addr, sizeof(struct acpi_sdt)))
  127. return 0;
  128. map_table(addr, sizeof(struct acpi_sdt));
  129. sdt = (const struct acpi_sdt *)phys_ptr(addr);
  130. len = sdt->length;
  131. if (len < sizeof(struct acpi_sdt) || len > 0x100000u)
  132. return 0;
  133. map_table(addr, len);
  134. if (!sum_ok((const unsigned char *)sdt, len))
  135. return 0;
  136. for (i = sizeof(struct acpi_sdt); i + step <= len; i += step) {
  137. unsigned int taddr;
  138. const struct acpi_sdt *t;
  139. unsigned int tlen;
  140. if (step == 8) {
  141. unsigned long long a =
  142. *(const unsigned long long *)((const unsigned char *)sdt + i);
  143. if ((unsigned int)(a >> 32) != 0)
  144. continue;
  145. taddr = (unsigned int)a;
  146. } else {
  147. taddr = *(const unsigned int *)((const unsigned char *)sdt + i);
  148. }
  149. if (!taddr || !range_ok(taddr, sizeof(struct acpi_sdt)))
  150. continue;
  151. map_table(taddr, sizeof(struct acpi_sdt));
  152. t = (const struct acpi_sdt *)phys_ptr(taddr);
  153. tlen = t->length;
  154. if (tlen < sizeof(struct acpi_sdt) || tlen > 0x100000u)
  155. continue;
  156. map_table(taddr, tlen);
  157. if (t->signature[0] == 'A' && t->signature[1] == 'P' &&
  158. t->signature[2] == 'I' && t->signature[3] == 'C' &&
  159. sum_ok((const unsigned char *)t, tlen))
  160. return t;
  161. }
  162. return 0;
  163. }
  164. static unsigned int cpuid_apic_id(void)
  165. {
  166. unsigned int eax, ebx, ecx, edx;
  167. eax = 1;
  168. __asm__ volatile ("cpuid"
  169. : "+a"(eax), "=b"(ebx), "=c"(ecx), "=d"(edx));
  170. if (!(edx & (1u << 9))) /* CPUID.1:EDX.APIC */
  171. return 0xFFFFFFFFu;
  172. return ebx >> 24; /* initial local APIC ID */
  173. }
  174. static void parse_madt(const struct acpi_sdt *madt)
  175. {
  176. const unsigned char *p = (const unsigned char *)madt;
  177. unsigned int len = madt->length;
  178. unsigned int i;
  179. lapic_base = LAPIC_DEFAULT;
  180. if (len >= 44) {
  181. unsigned int base = *(const unsigned int *)(p + 36);
  182. if (base)
  183. lapic_base = base;
  184. }
  185. for (i = 44; i + 2 <= len; ) {
  186. unsigned char type = p[i];
  187. unsigned char elen = p[i + 1];
  188. if (elen < 2 || i + elen > len)
  189. break;
  190. if (type == 0 && elen >= 8) {
  191. /* Processor Local APIC: flags bit 0 = enabled. */
  192. if ((p[i + 4] & 1) && ncpu < ACPI_MAX_CPUS)
  193. ids[ncpu++] = p[i + 3];
  194. } else if (type == 5 && elen >= 12) {
  195. /* Local APIC Address Override (64-bit). */
  196. unsigned int lo = *(const unsigned int *)(p + i + 4);
  197. unsigned int hi = *(const unsigned int *)(p + i + 8);
  198. if (!hi && lo)
  199. lapic_base = lo;
  200. }
  201. /* x2APIC (type 9), IOAPIC (1), NMI (4) and overrides are not
  202. * needed for the first SMP step. */
  203. i += elen;
  204. }
  205. }
  206. int acpi_init(void)
  207. {
  208. const struct acpi_rsdp *rsdp;
  209. const struct acpi_sdt *madt;
  210. unsigned int i;
  211. acpi_ok = 0;
  212. ncpu = 0;
  213. bsp_apic = cpuid_apic_id();
  214. if (bsp_apic == 0xFFFFFFFFu)
  215. return 0;
  216. rsdp = find_rsdp();
  217. if (!rsdp) {
  218. serial_puts(SERIAL_COM1, "acpi: no RSDP, staying UP\n");
  219. return 0;
  220. }
  221. madt = find_madt(rsdp);
  222. if (!madt) {
  223. serial_puts(SERIAL_COM1, "acpi: no MADT, staying UP\n");
  224. return 0;
  225. }
  226. parse_madt(madt);
  227. /* Put the BSP first. If firmware omitted it, keep the discovered list
  228. * but make sure entry 0 is a real CPU. */
  229. for (i = 0; i < ncpu; i++)
  230. if (ids[i] == bsp_apic)
  231. break;
  232. if (i < ncpu) {
  233. unsigned int t = ids[0];
  234. ids[0] = ids[i];
  235. ids[i] = t;
  236. } else if (ncpu) {
  237. ids[0] = bsp_apic;
  238. }
  239. if (!ncpu)
  240. return 0;
  241. acpi_ok = 1;
  242. return 1;
  243. }
  244. unsigned int acpi_cpu_count(void)
  245. {
  246. return acpi_ok ? ncpu : 0;
  247. }
  248. unsigned int acpi_cpu_apic_id(unsigned int index)
  249. {
  250. return (acpi_ok && index < ncpu) ? ids[index] : 0;
  251. }
  252. unsigned int acpi_bsp_apic_id(void)
  253. {
  254. return bsp_apic;
  255. }
  256. unsigned int acpi_lapic_base(void)
  257. {
  258. return lapic_base;
  259. }
  260. void acpi_dump(void)
  261. {
  262. unsigned int i;
  263. if (!acpi_ok) {
  264. serial_puts(SERIAL_COM1, "acpi: unavailable, 1 cpu\n");
  265. return;
  266. }
  267. serial_puts(SERIAL_COM1, "acpi: lapic ");
  268. serial_puthex(SERIAL_COM1, lapic_base);
  269. serial_puts(SERIAL_COM1, ", ");
  270. serial_putdec(SERIAL_COM1, ncpu);
  271. serial_puts(SERIAL_COM1, " cpus:");
  272. for (i = 0; i < ncpu; i++) {
  273. serial_puts(SERIAL_COM1, " ");
  274. serial_putdec(SERIAL_COM1, ids[i]);
  275. }
  276. serial_puts(SERIAL_COM1, "\n");
  277. }