1 /* Support for generating ACPI tables and passing them to Guests 2 * 3 * Copyright (C) 2015 Red Hat Inc 4 * 5 * Author: Michael S. Tsirkin <mst@redhat.com> 6 * Author: Igor Mammedov <imammedo@redhat.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 18 * You should have received a copy of the GNU General Public License along 19 * with this program; if not, see <http://www.gnu.org/licenses/>. 20 */ 21 22 #include "qemu/osdep.h" 23 #include <glib/gprintf.h> 24 #include "hw/acpi/aml-build.h" 25 #include "qemu/bswap.h" 26 #include "qemu/bitops.h" 27 #include "sysemu/numa.h" 28 #include "hw/boards.h" 29 #include "hw/acpi/tpm.h" 30 #include "hw/pci/pci_host.h" 31 #include "hw/pci/pci_bus.h" 32 #include "hw/pci/pci_bridge.h" 33 #include "qemu/cutils.h" 34 35 static GArray *build_alloc_array(void) 36 { 37 return g_array_new(false, true /* clear */, 1); 38 } 39 40 static void build_free_array(GArray *array) 41 { 42 g_array_free(array, true); 43 } 44 45 static void build_prepend_byte(GArray *array, uint8_t val) 46 { 47 g_array_prepend_val(array, val); 48 } 49 50 static void build_append_byte(GArray *array, uint8_t val) 51 { 52 g_array_append_val(array, val); 53 } 54 55 static void build_append_padded_str(GArray *array, const char *str, 56 size_t maxlen, char pad) 57 { 58 size_t i; 59 size_t len = strlen(str); 60 61 g_assert(len <= maxlen); 62 g_array_append_vals(array, str, len); 63 for (i = maxlen - len; i > 0; i--) { 64 g_array_append_val(array, pad); 65 } 66 } 67 68 static void build_append_array(GArray *array, GArray *val) 69 { 70 g_array_append_vals(array, val->data, val->len); 71 } 72 73 #define ACPI_NAMESEG_LEN 4 74 75 void crs_range_insert(GPtrArray *ranges, uint64_t base, uint64_t limit) 76 { 77 CrsRangeEntry *entry; 78 79 entry = g_malloc(sizeof(*entry)); 80 entry->base = base; 81 entry->limit = limit; 82 83 g_ptr_array_add(ranges, entry); 84 } 85 86 static void crs_range_free(gpointer data) 87 { 88 CrsRangeEntry *entry = (CrsRangeEntry *)data; 89 g_free(entry); 90 } 91 92 void crs_range_set_init(CrsRangeSet *range_set) 93 { 94 range_set->io_ranges = g_ptr_array_new_with_free_func(crs_range_free); 95 range_set->mem_ranges = g_ptr_array_new_with_free_func(crs_range_free); 96 range_set->mem_64bit_ranges = 97 g_ptr_array_new_with_free_func(crs_range_free); 98 } 99 100 void crs_range_set_free(CrsRangeSet *range_set) 101 { 102 g_ptr_array_free(range_set->io_ranges, true); 103 g_ptr_array_free(range_set->mem_ranges, true); 104 g_ptr_array_free(range_set->mem_64bit_ranges, true); 105 } 106 107 static gint crs_range_compare(gconstpointer a, gconstpointer b) 108 { 109 CrsRangeEntry *entry_a = *(CrsRangeEntry **)a; 110 CrsRangeEntry *entry_b = *(CrsRangeEntry **)b; 111 112 if (entry_a->base < entry_b->base) { 113 return -1; 114 } else if (entry_a->base > entry_b->base) { 115 return 1; 116 } else { 117 return 0; 118 } 119 } 120 121 /* 122 * crs_replace_with_free_ranges - given the 'used' ranges within [start - end] 123 * interval, computes the 'free' ranges from the same interval. 124 * Example: If the input array is { [a1 - a2],[b1 - b2] }, the function 125 * will return { [base - a1], [a2 - b1], [b2 - limit] }. 126 */ 127 void crs_replace_with_free_ranges(GPtrArray *ranges, 128 uint64_t start, uint64_t end) 129 { 130 GPtrArray *free_ranges = g_ptr_array_new(); 131 uint64_t free_base = start; 132 int i; 133 134 g_ptr_array_sort(ranges, crs_range_compare); 135 for (i = 0; i < ranges->len; i++) { 136 CrsRangeEntry *used = g_ptr_array_index(ranges, i); 137 138 if (free_base < used->base) { 139 crs_range_insert(free_ranges, free_base, used->base - 1); 140 } 141 142 free_base = used->limit + 1; 143 } 144 145 if (free_base < end) { 146 crs_range_insert(free_ranges, free_base, end); 147 } 148 149 g_ptr_array_set_size(ranges, 0); 150 for (i = 0; i < free_ranges->len; i++) { 151 g_ptr_array_add(ranges, g_ptr_array_index(free_ranges, i)); 152 } 153 154 g_ptr_array_free(free_ranges, true); 155 } 156 157 /* 158 * crs_range_merge - merges adjacent ranges in the given array. 159 * Array elements are deleted and replaced with the merged ranges. 160 */ 161 static void crs_range_merge(GPtrArray *range) 162 { 163 GPtrArray *tmp = g_ptr_array_new_with_free_func(crs_range_free); 164 CrsRangeEntry *entry; 165 uint64_t range_base, range_limit; 166 int i; 167 168 if (!range->len) { 169 return; 170 } 171 172 g_ptr_array_sort(range, crs_range_compare); 173 174 entry = g_ptr_array_index(range, 0); 175 range_base = entry->base; 176 range_limit = entry->limit; 177 for (i = 1; i < range->len; i++) { 178 entry = g_ptr_array_index(range, i); 179 if (entry->base - 1 == range_limit) { 180 range_limit = entry->limit; 181 } else { 182 crs_range_insert(tmp, range_base, range_limit); 183 range_base = entry->base; 184 range_limit = entry->limit; 185 } 186 } 187 crs_range_insert(tmp, range_base, range_limit); 188 189 g_ptr_array_set_size(range, 0); 190 for (i = 0; i < tmp->len; i++) { 191 entry = g_ptr_array_index(tmp, i); 192 crs_range_insert(range, entry->base, entry->limit); 193 } 194 g_ptr_array_free(tmp, true); 195 } 196 197 static void 198 build_append_nameseg(GArray *array, const char *seg) 199 { 200 int len; 201 202 len = strlen(seg); 203 assert(len <= ACPI_NAMESEG_LEN); 204 205 g_array_append_vals(array, seg, len); 206 /* Pad up to ACPI_NAMESEG_LEN characters if necessary. */ 207 g_array_append_vals(array, "____", ACPI_NAMESEG_LEN - len); 208 } 209 210 static void G_GNUC_PRINTF(2, 0) 211 build_append_namestringv(GArray *array, const char *format, va_list ap) 212 { 213 char *s; 214 char **segs; 215 char **segs_iter; 216 int seg_count = 0; 217 218 s = g_strdup_vprintf(format, ap); 219 segs = g_strsplit(s, ".", 0); 220 g_free(s); 221 222 /* count segments */ 223 segs_iter = segs; 224 while (*segs_iter) { 225 ++segs_iter; 226 ++seg_count; 227 } 228 /* 229 * ACPI 5.0 spec: 20.2.2 Name Objects Encoding: 230 * "SegCount can be from 1 to 255" 231 */ 232 assert(seg_count > 0 && seg_count <= 255); 233 234 /* handle RootPath || PrefixPath */ 235 s = *segs; 236 while (*s == '\\' || *s == '^') { 237 build_append_byte(array, *s); 238 ++s; 239 } 240 241 switch (seg_count) { 242 case 1: 243 if (!*s) { 244 build_append_byte(array, 0x00); /* NullName */ 245 } else { 246 build_append_nameseg(array, s); 247 } 248 break; 249 250 case 2: 251 build_append_byte(array, 0x2E); /* DualNamePrefix */ 252 build_append_nameseg(array, s); 253 build_append_nameseg(array, segs[1]); 254 break; 255 default: 256 build_append_byte(array, 0x2F); /* MultiNamePrefix */ 257 build_append_byte(array, seg_count); 258 259 /* handle the 1st segment manually due to prefix/root path */ 260 build_append_nameseg(array, s); 261 262 /* add the rest of segments */ 263 segs_iter = segs + 1; 264 while (*segs_iter) { 265 build_append_nameseg(array, *segs_iter); 266 ++segs_iter; 267 } 268 break; 269 } 270 g_strfreev(segs); 271 } 272 273 G_GNUC_PRINTF(2, 3) 274 static void build_append_namestring(GArray *array, const char *format, ...) 275 { 276 va_list ap; 277 278 va_start(ap, format); 279 build_append_namestringv(array, format, ap); 280 va_end(ap); 281 } 282 283 /* 5.4 Definition Block Encoding */ 284 enum { 285 PACKAGE_LENGTH_1BYTE_SHIFT = 6, /* Up to 63 - use extra 2 bits. */ 286 PACKAGE_LENGTH_2BYTE_SHIFT = 4, 287 PACKAGE_LENGTH_3BYTE_SHIFT = 12, 288 PACKAGE_LENGTH_4BYTE_SHIFT = 20, 289 }; 290 291 static void 292 build_prepend_package_length(GArray *package, unsigned length, bool incl_self) 293 { 294 uint8_t byte; 295 unsigned length_bytes; 296 297 if (length + 1 < (1 << PACKAGE_LENGTH_1BYTE_SHIFT)) { 298 length_bytes = 1; 299 } else if (length + 2 < (1 << PACKAGE_LENGTH_3BYTE_SHIFT)) { 300 length_bytes = 2; 301 } else if (length + 3 < (1 << PACKAGE_LENGTH_4BYTE_SHIFT)) { 302 length_bytes = 3; 303 } else { 304 length_bytes = 4; 305 } 306 307 /* 308 * NamedField uses PkgLength encoding but it doesn't include length 309 * of PkgLength itself. 310 */ 311 if (incl_self) { 312 /* 313 * PkgLength is the length of the inclusive length of the data 314 * and PkgLength's length itself when used for terms with 315 * explicit length. 316 */ 317 length += length_bytes; 318 } 319 320 switch (length_bytes) { 321 case 1: 322 byte = length; 323 build_prepend_byte(package, byte); 324 return; 325 case 4: 326 byte = length >> PACKAGE_LENGTH_4BYTE_SHIFT; 327 build_prepend_byte(package, byte); 328 length &= (1 << PACKAGE_LENGTH_4BYTE_SHIFT) - 1; 329 /* fall through */ 330 case 3: 331 byte = length >> PACKAGE_LENGTH_3BYTE_SHIFT; 332 build_prepend_byte(package, byte); 333 length &= (1 << PACKAGE_LENGTH_3BYTE_SHIFT) - 1; 334 /* fall through */ 335 case 2: 336 byte = length >> PACKAGE_LENGTH_2BYTE_SHIFT; 337 build_prepend_byte(package, byte); 338 length &= (1 << PACKAGE_LENGTH_2BYTE_SHIFT) - 1; 339 /* fall through */ 340 } 341 /* 342 * Most significant two bits of byte zero indicate how many following bytes 343 * are in PkgLength encoding. 344 */ 345 byte = ((length_bytes - 1) << PACKAGE_LENGTH_1BYTE_SHIFT) | length; 346 build_prepend_byte(package, byte); 347 } 348 349 static void 350 build_append_pkg_length(GArray *array, unsigned length, bool incl_self) 351 { 352 GArray *tmp = build_alloc_array(); 353 354 build_prepend_package_length(tmp, length, incl_self); 355 build_append_array(array, tmp); 356 build_free_array(tmp); 357 } 358 359 static void build_package(GArray *package, uint8_t op) 360 { 361 build_prepend_package_length(package, package->len, true); 362 build_prepend_byte(package, op); 363 } 364 365 static void build_extop_package(GArray *package, uint8_t op) 366 { 367 build_package(package, op); 368 build_prepend_byte(package, 0x5B); /* ExtOpPrefix */ 369 } 370 371 void build_append_int_noprefix(GArray *table, uint64_t value, int size) 372 { 373 int i; 374 375 for (i = 0; i < size; ++i) { 376 build_append_byte(table, value & 0xFF); 377 value = value >> 8; 378 } 379 } 380 381 static void build_append_int(GArray *table, uint64_t value) 382 { 383 if (value == 0x00) { 384 build_append_byte(table, 0x00); /* ZeroOp */ 385 } else if (value == 0x01) { 386 build_append_byte(table, 0x01); /* OneOp */ 387 } else if (value <= 0xFF) { 388 build_append_byte(table, 0x0A); /* BytePrefix */ 389 build_append_int_noprefix(table, value, 1); 390 } else if (value <= 0xFFFF) { 391 build_append_byte(table, 0x0B); /* WordPrefix */ 392 build_append_int_noprefix(table, value, 2); 393 } else if (value <= 0xFFFFFFFF) { 394 build_append_byte(table, 0x0C); /* DWordPrefix */ 395 build_append_int_noprefix(table, value, 4); 396 } else { 397 build_append_byte(table, 0x0E); /* QWordPrefix */ 398 build_append_int_noprefix(table, value, 8); 399 } 400 } 401 402 /* Generic Address Structure (GAS) 403 * ACPI 2.0/3.0: 5.2.3.1 Generic Address Structure 404 * 2.0 compat note: 405 * @access_width must be 0, see ACPI 2.0:Table 5-1 406 */ 407 void build_append_gas(GArray *table, AmlAddressSpace as, 408 uint8_t bit_width, uint8_t bit_offset, 409 uint8_t access_width, uint64_t address) 410 { 411 build_append_int_noprefix(table, as, 1); 412 build_append_int_noprefix(table, bit_width, 1); 413 build_append_int_noprefix(table, bit_offset, 1); 414 build_append_int_noprefix(table, access_width, 1); 415 build_append_int_noprefix(table, address, 8); 416 } 417 418 /* 419 * Build NAME(XXXX, 0x00000000) where 0x00000000 is encoded as a dword, 420 * and return the offset to 0x00000000 for runtime patching. 421 * 422 * Warning: runtime patching is best avoided. Only use this as 423 * a replacement for DataTableRegion (for guests that don't 424 * support it). 425 */ 426 int 427 build_append_named_dword(GArray *array, const char *name_format, ...) 428 { 429 int offset; 430 va_list ap; 431 432 build_append_byte(array, 0x08); /* NameOp */ 433 va_start(ap, name_format); 434 build_append_namestringv(array, name_format, ap); 435 va_end(ap); 436 437 build_append_byte(array, 0x0C); /* DWordPrefix */ 438 439 offset = array->len; 440 build_append_int_noprefix(array, 0x00000000, 4); 441 assert(array->len == offset + 4); 442 443 return offset; 444 } 445 446 static GPtrArray *alloc_list; 447 448 static Aml *aml_alloc(void) 449 { 450 Aml *var = g_new0(typeof(*var), 1); 451 452 g_ptr_array_add(alloc_list, var); 453 var->block_flags = AML_NO_OPCODE; 454 var->buf = build_alloc_array(); 455 return var; 456 } 457 458 static Aml *aml_opcode(uint8_t op) 459 { 460 Aml *var = aml_alloc(); 461 462 var->op = op; 463 var->block_flags = AML_OPCODE; 464 return var; 465 } 466 467 static Aml *aml_bundle(uint8_t op, AmlBlockFlags flags) 468 { 469 Aml *var = aml_alloc(); 470 471 var->op = op; 472 var->block_flags = flags; 473 return var; 474 } 475 476 static void aml_free(gpointer data, gpointer user_data) 477 { 478 Aml *var = data; 479 build_free_array(var->buf); 480 g_free(var); 481 } 482 483 Aml *init_aml_allocator(void) 484 { 485 assert(!alloc_list); 486 alloc_list = g_ptr_array_new(); 487 return aml_alloc(); 488 } 489 490 void free_aml_allocator(void) 491 { 492 g_ptr_array_foreach(alloc_list, aml_free, NULL); 493 g_ptr_array_free(alloc_list, true); 494 alloc_list = 0; 495 } 496 497 /* pack data with DefBuffer encoding */ 498 static void build_buffer(GArray *array, uint8_t op) 499 { 500 GArray *data = build_alloc_array(); 501 502 build_append_int(data, array->len); 503 g_array_prepend_vals(array, data->data, data->len); 504 build_free_array(data); 505 build_package(array, op); 506 } 507 508 void aml_append(Aml *parent_ctx, Aml *child) 509 { 510 GArray *buf = build_alloc_array(); 511 build_append_array(buf, child->buf); 512 513 switch (child->block_flags) { 514 case AML_OPCODE: 515 build_append_byte(parent_ctx->buf, child->op); 516 break; 517 case AML_EXT_PACKAGE: 518 build_extop_package(buf, child->op); 519 break; 520 case AML_PACKAGE: 521 build_package(buf, child->op); 522 break; 523 case AML_RES_TEMPLATE: 524 build_append_byte(buf, 0x79); /* EndTag */ 525 /* 526 * checksum operations are treated as succeeded if checksum 527 * field is zero. [ACPI Spec 1.0b, 6.4.2.8 End Tag] 528 */ 529 build_append_byte(buf, 0); 530 /* fall through, to pack resources in buffer */ 531 case AML_BUFFER: 532 build_buffer(buf, child->op); 533 break; 534 case AML_NO_OPCODE: 535 break; 536 default: 537 g_assert_not_reached(); 538 } 539 build_append_array(parent_ctx->buf, buf); 540 build_free_array(buf); 541 } 542 543 /* ACPI 1.0b: 16.2.5.1 Namespace Modifier Objects Encoding: DefScope */ 544 Aml *aml_scope(const char *name_format, ...) 545 { 546 va_list ap; 547 Aml *var = aml_bundle(0x10 /* ScopeOp */, AML_PACKAGE); 548 va_start(ap, name_format); 549 build_append_namestringv(var->buf, name_format, ap); 550 va_end(ap); 551 return var; 552 } 553 554 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefReturn */ 555 Aml *aml_return(Aml *val) 556 { 557 Aml *var = aml_opcode(0xA4 /* ReturnOp */); 558 aml_append(var, val); 559 return var; 560 } 561 562 /* ACPI 1.0b: 16.2.6.3 Debug Objects Encoding: DebugObj */ 563 Aml *aml_debug(void) 564 { 565 Aml *var = aml_alloc(); 566 build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */ 567 build_append_byte(var->buf, 0x31); /* DebugOp */ 568 return var; 569 } 570 571 /* 572 * ACPI 1.0b: 16.2.3 Data Objects Encoding: 573 * encodes: ByteConst, WordConst, DWordConst, QWordConst, ZeroOp, OneOp 574 */ 575 Aml *aml_int(const uint64_t val) 576 { 577 Aml *var = aml_alloc(); 578 build_append_int(var->buf, val); 579 return var; 580 } 581 582 /* 583 * helper to construct NameString, which returns Aml object 584 * for using with aml_append or other aml_* terms 585 */ 586 Aml *aml_name(const char *name_format, ...) 587 { 588 va_list ap; 589 Aml *var = aml_alloc(); 590 va_start(ap, name_format); 591 build_append_namestringv(var->buf, name_format, ap); 592 va_end(ap); 593 return var; 594 } 595 596 /* ACPI 1.0b: 16.2.5.1 Namespace Modifier Objects Encoding: DefName */ 597 Aml *aml_name_decl(const char *name, Aml *val) 598 { 599 Aml *var = aml_opcode(0x08 /* NameOp */); 600 build_append_namestring(var->buf, "%s", name); 601 aml_append(var, val); 602 return var; 603 } 604 605 /* ACPI 1.0b: 16.2.6.1 Arg Objects Encoding */ 606 Aml *aml_arg(int pos) 607 { 608 uint8_t op = 0x68 /* ARG0 op */ + pos; 609 610 assert(pos <= 6); 611 return aml_opcode(op); 612 } 613 614 /* ACPI 2.0a: 17.2.4.4 Type 2 Opcodes Encoding: DefToInteger */ 615 Aml *aml_to_integer(Aml *arg) 616 { 617 Aml *var = aml_opcode(0x99 /* ToIntegerOp */); 618 aml_append(var, arg); 619 build_append_byte(var->buf, 0x00 /* NullNameOp */); 620 return var; 621 } 622 623 /* ACPI 2.0a: 17.2.4.4 Type 2 Opcodes Encoding: DefToHexString */ 624 Aml *aml_to_hexstring(Aml *src, Aml *dst) 625 { 626 Aml *var = aml_opcode(0x98 /* ToHexStringOp */); 627 aml_append(var, src); 628 if (dst) { 629 aml_append(var, dst); 630 } else { 631 build_append_byte(var->buf, 0x00 /* NullNameOp */); 632 } 633 return var; 634 } 635 636 /* ACPI 2.0a: 17.2.4.4 Type 2 Opcodes Encoding: DefToBuffer */ 637 Aml *aml_to_buffer(Aml *src, Aml *dst) 638 { 639 Aml *var = aml_opcode(0x96 /* ToBufferOp */); 640 aml_append(var, src); 641 if (dst) { 642 aml_append(var, dst); 643 } else { 644 build_append_byte(var->buf, 0x00 /* NullNameOp */); 645 } 646 return var; 647 } 648 649 /* ACPI 2.0a: 17.2.4.4 Type 2 Opcodes Encoding: DefToDecimalString */ 650 Aml *aml_to_decimalstring(Aml *src, Aml *dst) 651 { 652 Aml *var = aml_opcode(0x97 /* ToDecimalStringOp */); 653 aml_append(var, src); 654 if (dst) { 655 aml_append(var, dst); 656 } else { 657 build_append_byte(var->buf, 0x00 /* NullNameOp */); 658 } 659 return var; 660 } 661 662 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefStore */ 663 Aml *aml_store(Aml *val, Aml *target) 664 { 665 Aml *var = aml_opcode(0x70 /* StoreOp */); 666 aml_append(var, val); 667 aml_append(var, target); 668 return var; 669 } 670 671 /** 672 * build_opcode_2arg_dst: 673 * @op: 1-byte opcode 674 * @arg1: 1st operand 675 * @arg2: 2nd operand 676 * @dst: optional target to store to, set to NULL if it's not required 677 * 678 * An internal helper to compose AML terms that have 679 * "Op Operand Operand Target" 680 * pattern. 681 * 682 * Returns: The newly allocated and composed according to pattern Aml object. 683 */ 684 static Aml * 685 build_opcode_2arg_dst(uint8_t op, Aml *arg1, Aml *arg2, Aml *dst) 686 { 687 Aml *var = aml_opcode(op); 688 aml_append(var, arg1); 689 aml_append(var, arg2); 690 if (dst) { 691 aml_append(var, dst); 692 } else { 693 build_append_byte(var->buf, 0x00 /* NullNameOp */); 694 } 695 return var; 696 } 697 698 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefAnd */ 699 Aml *aml_and(Aml *arg1, Aml *arg2, Aml *dst) 700 { 701 return build_opcode_2arg_dst(0x7B /* AndOp */, arg1, arg2, dst); 702 } 703 704 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefOr */ 705 Aml *aml_or(Aml *arg1, Aml *arg2, Aml *dst) 706 { 707 return build_opcode_2arg_dst(0x7D /* OrOp */, arg1, arg2, dst); 708 } 709 710 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLAnd */ 711 Aml *aml_land(Aml *arg1, Aml *arg2) 712 { 713 Aml *var = aml_opcode(0x90 /* LAndOp */); 714 aml_append(var, arg1); 715 aml_append(var, arg2); 716 return var; 717 } 718 719 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLOr */ 720 Aml *aml_lor(Aml *arg1, Aml *arg2) 721 { 722 Aml *var = aml_opcode(0x91 /* LOrOp */); 723 aml_append(var, arg1); 724 aml_append(var, arg2); 725 return var; 726 } 727 728 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefShiftLeft */ 729 Aml *aml_shiftleft(Aml *arg1, Aml *count) 730 { 731 return build_opcode_2arg_dst(0x79 /* ShiftLeftOp */, arg1, count, NULL); 732 } 733 734 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefShiftRight */ 735 Aml *aml_shiftright(Aml *arg1, Aml *count, Aml *dst) 736 { 737 return build_opcode_2arg_dst(0x7A /* ShiftRightOp */, arg1, count, dst); 738 } 739 740 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLLess */ 741 Aml *aml_lless(Aml *arg1, Aml *arg2) 742 { 743 Aml *var = aml_opcode(0x95 /* LLessOp */); 744 aml_append(var, arg1); 745 aml_append(var, arg2); 746 return var; 747 } 748 749 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefAdd */ 750 Aml *aml_add(Aml *arg1, Aml *arg2, Aml *dst) 751 { 752 return build_opcode_2arg_dst(0x72 /* AddOp */, arg1, arg2, dst); 753 } 754 755 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefSubtract */ 756 Aml *aml_subtract(Aml *arg1, Aml *arg2, Aml *dst) 757 { 758 return build_opcode_2arg_dst(0x74 /* SubtractOp */, arg1, arg2, dst); 759 } 760 761 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefIncrement */ 762 Aml *aml_increment(Aml *arg) 763 { 764 Aml *var = aml_opcode(0x75 /* IncrementOp */); 765 aml_append(var, arg); 766 return var; 767 } 768 769 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefDecrement */ 770 Aml *aml_decrement(Aml *arg) 771 { 772 Aml *var = aml_opcode(0x76 /* DecrementOp */); 773 aml_append(var, arg); 774 return var; 775 } 776 777 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefIndex */ 778 Aml *aml_index(Aml *arg1, Aml *idx) 779 { 780 return build_opcode_2arg_dst(0x88 /* IndexOp */, arg1, idx, NULL); 781 } 782 783 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefNotify */ 784 Aml *aml_notify(Aml *arg1, Aml *arg2) 785 { 786 Aml *var = aml_opcode(0x86 /* NotifyOp */); 787 aml_append(var, arg1); 788 aml_append(var, arg2); 789 return var; 790 } 791 792 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefBreak */ 793 Aml *aml_break(void) 794 { 795 Aml *var = aml_opcode(0xa5 /* BreakOp */); 796 return var; 797 } 798 799 /* helper to call method without argument */ 800 Aml *aml_call0(const char *method) 801 { 802 Aml *var = aml_alloc(); 803 build_append_namestring(var->buf, "%s", method); 804 return var; 805 } 806 807 /* helper to call method with 1 argument */ 808 Aml *aml_call1(const char *method, Aml *arg1) 809 { 810 Aml *var = aml_alloc(); 811 build_append_namestring(var->buf, "%s", method); 812 aml_append(var, arg1); 813 return var; 814 } 815 816 /* helper to call method with 2 arguments */ 817 Aml *aml_call2(const char *method, Aml *arg1, Aml *arg2) 818 { 819 Aml *var = aml_alloc(); 820 build_append_namestring(var->buf, "%s", method); 821 aml_append(var, arg1); 822 aml_append(var, arg2); 823 return var; 824 } 825 826 /* helper to call method with 3 arguments */ 827 Aml *aml_call3(const char *method, Aml *arg1, Aml *arg2, Aml *arg3) 828 { 829 Aml *var = aml_alloc(); 830 build_append_namestring(var->buf, "%s", method); 831 aml_append(var, arg1); 832 aml_append(var, arg2); 833 aml_append(var, arg3); 834 return var; 835 } 836 837 /* helper to call method with 4 arguments */ 838 Aml *aml_call4(const char *method, Aml *arg1, Aml *arg2, Aml *arg3, Aml *arg4) 839 { 840 Aml *var = aml_alloc(); 841 build_append_namestring(var->buf, "%s", method); 842 aml_append(var, arg1); 843 aml_append(var, arg2); 844 aml_append(var, arg3); 845 aml_append(var, arg4); 846 return var; 847 } 848 849 /* helper to call method with 5 arguments */ 850 Aml *aml_call5(const char *method, Aml *arg1, Aml *arg2, Aml *arg3, Aml *arg4, 851 Aml *arg5) 852 { 853 Aml *var = aml_alloc(); 854 build_append_namestring(var->buf, "%s", method); 855 aml_append(var, arg1); 856 aml_append(var, arg2); 857 aml_append(var, arg3); 858 aml_append(var, arg4); 859 aml_append(var, arg5); 860 return var; 861 } 862 863 /* helper to call method with 5 arguments */ 864 Aml *aml_call6(const char *method, Aml *arg1, Aml *arg2, Aml *arg3, Aml *arg4, 865 Aml *arg5, Aml *arg6) 866 { 867 Aml *var = aml_alloc(); 868 build_append_namestring(var->buf, "%s", method); 869 aml_append(var, arg1); 870 aml_append(var, arg2); 871 aml_append(var, arg3); 872 aml_append(var, arg4); 873 aml_append(var, arg5); 874 aml_append(var, arg6); 875 return var; 876 } 877 878 /* 879 * ACPI 5.0: 6.4.3.8.1 GPIO Connection Descriptor 880 * Type 1, Large Item Name 0xC 881 */ 882 883 static Aml *aml_gpio_connection(AmlGpioConnectionType type, 884 AmlConsumerAndProducer con_and_pro, 885 uint8_t flags, AmlPinConfig pin_config, 886 uint16_t output_drive, 887 uint16_t debounce_timeout, 888 const uint32_t pin_list[], uint32_t pin_count, 889 const char *resource_source_name, 890 const uint8_t *vendor_data, 891 uint16_t vendor_data_len) 892 { 893 Aml *var = aml_alloc(); 894 const uint16_t min_desc_len = 0x16; 895 uint16_t resource_source_name_len, length; 896 uint16_t pin_table_offset, resource_source_name_offset, vendor_data_offset; 897 uint32_t i; 898 899 assert(resource_source_name); 900 resource_source_name_len = strlen(resource_source_name) + 1; 901 length = min_desc_len + resource_source_name_len + vendor_data_len; 902 pin_table_offset = min_desc_len + 1; 903 resource_source_name_offset = pin_table_offset + pin_count * 2; 904 vendor_data_offset = resource_source_name_offset + resource_source_name_len; 905 906 build_append_byte(var->buf, 0x8C); /* GPIO Connection Descriptor */ 907 build_append_int_noprefix(var->buf, length, 2); /* Length */ 908 build_append_byte(var->buf, 1); /* Revision ID */ 909 build_append_byte(var->buf, type); /* GPIO Connection Type */ 910 /* General Flags (2 bytes) */ 911 build_append_int_noprefix(var->buf, con_and_pro, 2); 912 /* Interrupt and IO Flags (2 bytes) */ 913 build_append_int_noprefix(var->buf, flags, 2); 914 /* Pin Configuration 0 = Default 1 = Pull-up 2 = Pull-down 3 = No Pull */ 915 build_append_byte(var->buf, pin_config); 916 /* Output Drive Strength (2 bytes) */ 917 build_append_int_noprefix(var->buf, output_drive, 2); 918 /* Debounce Timeout (2 bytes) */ 919 build_append_int_noprefix(var->buf, debounce_timeout, 2); 920 /* Pin Table Offset (2 bytes) */ 921 build_append_int_noprefix(var->buf, pin_table_offset, 2); 922 build_append_byte(var->buf, 0); /* Resource Source Index */ 923 /* Resource Source Name Offset (2 bytes) */ 924 build_append_int_noprefix(var->buf, resource_source_name_offset, 2); 925 /* Vendor Data Offset (2 bytes) */ 926 build_append_int_noprefix(var->buf, vendor_data_offset, 2); 927 /* Vendor Data Length (2 bytes) */ 928 build_append_int_noprefix(var->buf, vendor_data_len, 2); 929 /* Pin Number (2n bytes)*/ 930 for (i = 0; i < pin_count; i++) { 931 build_append_int_noprefix(var->buf, pin_list[i], 2); 932 } 933 934 /* Resource Source Name */ 935 build_append_namestring(var->buf, "%s", resource_source_name); 936 build_append_byte(var->buf, '\0'); 937 938 /* Vendor-defined Data */ 939 if (vendor_data != NULL) { 940 g_array_append_vals(var->buf, vendor_data, vendor_data_len); 941 } 942 943 return var; 944 } 945 946 /* 947 * ACPI 5.0: 19.5.53 948 * GpioInt(GPIO Interrupt Connection Resource Descriptor Macro) 949 */ 950 Aml *aml_gpio_int(AmlConsumerAndProducer con_and_pro, 951 AmlLevelAndEdge edge_level, 952 AmlActiveHighAndLow active_level, AmlShared shared, 953 AmlPinConfig pin_config, uint16_t debounce_timeout, 954 const uint32_t pin_list[], uint32_t pin_count, 955 const char *resource_source_name, 956 const uint8_t *vendor_data, uint16_t vendor_data_len) 957 { 958 uint8_t flags = edge_level | (active_level << 1) | (shared << 3); 959 960 return aml_gpio_connection(AML_INTERRUPT_CONNECTION, con_and_pro, flags, 961 pin_config, 0, debounce_timeout, pin_list, 962 pin_count, resource_source_name, vendor_data, 963 vendor_data_len); 964 } 965 966 /* 967 * ACPI 1.0b: 6.4.3.4 32-Bit Fixed Location Memory Range Descriptor 968 * (Type 1, Large Item Name 0x6) 969 */ 970 Aml *aml_memory32_fixed(uint32_t addr, uint32_t size, 971 AmlReadAndWrite read_and_write) 972 { 973 Aml *var = aml_alloc(); 974 build_append_byte(var->buf, 0x86); /* Memory32Fixed Resource Descriptor */ 975 build_append_byte(var->buf, 9); /* Length, bits[7:0] value = 9 */ 976 build_append_byte(var->buf, 0); /* Length, bits[15:8] value = 0 */ 977 build_append_byte(var->buf, read_and_write); /* Write status, 1 rw 0 ro */ 978 979 /* Range base address */ 980 build_append_byte(var->buf, extract32(addr, 0, 8)); /* bits[7:0] */ 981 build_append_byte(var->buf, extract32(addr, 8, 8)); /* bits[15:8] */ 982 build_append_byte(var->buf, extract32(addr, 16, 8)); /* bits[23:16] */ 983 build_append_byte(var->buf, extract32(addr, 24, 8)); /* bits[31:24] */ 984 985 /* Range length */ 986 build_append_byte(var->buf, extract32(size, 0, 8)); /* bits[7:0] */ 987 build_append_byte(var->buf, extract32(size, 8, 8)); /* bits[15:8] */ 988 build_append_byte(var->buf, extract32(size, 16, 8)); /* bits[23:16] */ 989 build_append_byte(var->buf, extract32(size, 24, 8)); /* bits[31:24] */ 990 return var; 991 } 992 993 /* 994 * ACPI 5.0: 6.4.3.6 Extended Interrupt Descriptor 995 * Type 1, Large Item Name 0x9 996 */ 997 Aml *aml_interrupt(AmlConsumerAndProducer con_and_pro, 998 AmlLevelAndEdge level_and_edge, 999 AmlActiveHighAndLow high_and_low, AmlShared shared, 1000 uint32_t *irq_list, uint8_t irq_count) 1001 { 1002 int i; 1003 Aml *var = aml_alloc(); 1004 uint8_t irq_flags = con_and_pro | (level_and_edge << 1) 1005 | (high_and_low << 2) | (shared << 3); 1006 const int header_bytes_in_len = 2; 1007 uint16_t len = header_bytes_in_len + irq_count * sizeof(uint32_t); 1008 1009 assert(irq_count > 0); 1010 1011 build_append_byte(var->buf, 0x89); /* Extended irq descriptor */ 1012 build_append_byte(var->buf, len & 0xFF); /* Length, bits[7:0] */ 1013 build_append_byte(var->buf, len >> 8); /* Length, bits[15:8] */ 1014 build_append_byte(var->buf, irq_flags); /* Interrupt Vector Information. */ 1015 build_append_byte(var->buf, irq_count); /* Interrupt table length */ 1016 1017 /* Interrupt Number List */ 1018 for (i = 0; i < irq_count; i++) { 1019 build_append_int_noprefix(var->buf, irq_list[i], 4); 1020 } 1021 return var; 1022 } 1023 1024 /* ACPI 1.0b: 6.4.2.5 I/O Port Descriptor */ 1025 Aml *aml_io(AmlIODecode dec, uint16_t min_base, uint16_t max_base, 1026 uint8_t aln, uint8_t len) 1027 { 1028 Aml *var = aml_alloc(); 1029 build_append_byte(var->buf, 0x47); /* IO port descriptor */ 1030 build_append_byte(var->buf, dec); 1031 build_append_byte(var->buf, min_base & 0xff); 1032 build_append_byte(var->buf, (min_base >> 8) & 0xff); 1033 build_append_byte(var->buf, max_base & 0xff); 1034 build_append_byte(var->buf, (max_base >> 8) & 0xff); 1035 build_append_byte(var->buf, aln); 1036 build_append_byte(var->buf, len); 1037 return var; 1038 } 1039 1040 /* 1041 * ACPI 1.0b: 6.4.2.1.1 ASL Macro for IRQ Descriptor 1042 * 1043 * More verbose description at: 1044 * ACPI 5.0: 19.5.64 IRQNoFlags (Interrupt Resource Descriptor Macro) 1045 * 6.4.2.1 IRQ Descriptor 1046 */ 1047 Aml *aml_irq_no_flags(uint8_t irq) 1048 { 1049 uint16_t irq_mask; 1050 Aml *var = aml_alloc(); 1051 1052 assert(irq < 16); 1053 build_append_byte(var->buf, 0x22); /* IRQ descriptor 2 byte form */ 1054 1055 irq_mask = 1U << irq; 1056 build_append_byte(var->buf, irq_mask & 0xFF); /* IRQ mask bits[7:0] */ 1057 build_append_byte(var->buf, irq_mask >> 8); /* IRQ mask bits[15:8] */ 1058 return var; 1059 } 1060 1061 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLNot */ 1062 Aml *aml_lnot(Aml *arg) 1063 { 1064 Aml *var = aml_opcode(0x92 /* LNotOp */); 1065 aml_append(var, arg); 1066 return var; 1067 } 1068 1069 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLEqual */ 1070 Aml *aml_equal(Aml *arg1, Aml *arg2) 1071 { 1072 Aml *var = aml_opcode(0x93 /* LequalOp */); 1073 aml_append(var, arg1); 1074 aml_append(var, arg2); 1075 return var; 1076 } 1077 1078 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLGreater */ 1079 Aml *aml_lgreater(Aml *arg1, Aml *arg2) 1080 { 1081 Aml *var = aml_opcode(0x94 /* LGreaterOp */); 1082 aml_append(var, arg1); 1083 aml_append(var, arg2); 1084 return var; 1085 } 1086 1087 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLGreaterEqual */ 1088 Aml *aml_lgreater_equal(Aml *arg1, Aml *arg2) 1089 { 1090 /* LGreaterEqualOp := LNotOp LLessOp */ 1091 Aml *var = aml_opcode(0x92 /* LNotOp */); 1092 build_append_byte(var->buf, 0x95 /* LLessOp */); 1093 aml_append(var, arg1); 1094 aml_append(var, arg2); 1095 return var; 1096 } 1097 1098 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefIfElse */ 1099 Aml *aml_if(Aml *predicate) 1100 { 1101 Aml *var = aml_bundle(0xA0 /* IfOp */, AML_PACKAGE); 1102 aml_append(var, predicate); 1103 return var; 1104 } 1105 1106 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefElse */ 1107 Aml *aml_else(void) 1108 { 1109 Aml *var = aml_bundle(0xA1 /* ElseOp */, AML_PACKAGE); 1110 return var; 1111 } 1112 1113 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefWhile */ 1114 Aml *aml_while(Aml *predicate) 1115 { 1116 Aml *var = aml_bundle(0xA2 /* WhileOp */, AML_PACKAGE); 1117 aml_append(var, predicate); 1118 return var; 1119 } 1120 1121 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefMethod */ 1122 Aml *aml_method(const char *name, int arg_count, AmlSerializeFlag sflag) 1123 { 1124 Aml *var = aml_bundle(0x14 /* MethodOp */, AML_PACKAGE); 1125 int methodflags; 1126 1127 /* 1128 * MethodFlags: 1129 * bit 0-2: ArgCount (0-7) 1130 * bit 3: SerializeFlag 1131 * 0: NotSerialized 1132 * 1: Serialized 1133 * bit 4-7: reserved (must be 0) 1134 */ 1135 assert(arg_count < 8); 1136 methodflags = arg_count | (sflag << 3); 1137 1138 build_append_namestring(var->buf, "%s", name); 1139 build_append_byte(var->buf, methodflags); /* MethodFlags: ArgCount */ 1140 return var; 1141 } 1142 1143 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefDevice */ 1144 Aml *aml_device(const char *name_format, ...) 1145 { 1146 va_list ap; 1147 Aml *var = aml_bundle(0x82 /* DeviceOp */, AML_EXT_PACKAGE); 1148 va_start(ap, name_format); 1149 build_append_namestringv(var->buf, name_format, ap); 1150 va_end(ap); 1151 return var; 1152 } 1153 1154 /* ACPI 1.0b: 6.4.1 ASL Macros for Resource Descriptors */ 1155 Aml *aml_resource_template(void) 1156 { 1157 /* ResourceTemplate is a buffer of Resources with EndTag at the end */ 1158 Aml *var = aml_bundle(0x11 /* BufferOp */, AML_RES_TEMPLATE); 1159 return var; 1160 } 1161 1162 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefBuffer 1163 * Pass byte_list as NULL to request uninitialized buffer to reserve space. 1164 */ 1165 Aml *aml_buffer(int buffer_size, uint8_t *byte_list) 1166 { 1167 int i; 1168 Aml *var = aml_bundle(0x11 /* BufferOp */, AML_BUFFER); 1169 1170 for (i = 0; i < buffer_size; i++) { 1171 if (byte_list == NULL) { 1172 build_append_byte(var->buf, 0x0); 1173 } else { 1174 build_append_byte(var->buf, byte_list[i]); 1175 } 1176 } 1177 1178 return var; 1179 } 1180 1181 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefPackage */ 1182 Aml *aml_package(uint8_t num_elements) 1183 { 1184 Aml *var = aml_bundle(0x12 /* PackageOp */, AML_PACKAGE); 1185 build_append_byte(var->buf, num_elements); 1186 return var; 1187 } 1188 1189 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefOpRegion */ 1190 Aml *aml_operation_region(const char *name, AmlRegionSpace rs, 1191 Aml *offset, uint32_t len) 1192 { 1193 Aml *var = aml_alloc(); 1194 build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */ 1195 build_append_byte(var->buf, 0x80); /* OpRegionOp */ 1196 build_append_namestring(var->buf, "%s", name); 1197 build_append_byte(var->buf, rs); 1198 aml_append(var, offset); 1199 build_append_int(var->buf, len); 1200 return var; 1201 } 1202 1203 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: NamedField */ 1204 Aml *aml_named_field(const char *name, unsigned length) 1205 { 1206 Aml *var = aml_alloc(); 1207 build_append_nameseg(var->buf, name); 1208 build_append_pkg_length(var->buf, length, false); 1209 return var; 1210 } 1211 1212 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: ReservedField */ 1213 Aml *aml_reserved_field(unsigned length) 1214 { 1215 Aml *var = aml_alloc(); 1216 /* ReservedField := 0x00 PkgLength */ 1217 build_append_byte(var->buf, 0x00); 1218 build_append_pkg_length(var->buf, length, false); 1219 return var; 1220 } 1221 1222 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefField */ 1223 Aml *aml_field(const char *name, AmlAccessType type, AmlLockRule lock, 1224 AmlUpdateRule rule) 1225 { 1226 Aml *var = aml_bundle(0x81 /* FieldOp */, AML_EXT_PACKAGE); 1227 uint8_t flags = rule << 5 | type; 1228 1229 flags |= lock << 4; /* LockRule at 4 bit offset */ 1230 1231 build_append_namestring(var->buf, "%s", name); 1232 build_append_byte(var->buf, flags); 1233 return var; 1234 } 1235 1236 static 1237 Aml *create_field_common(int opcode, Aml *srcbuf, Aml *index, const char *name) 1238 { 1239 Aml *var = aml_opcode(opcode); 1240 aml_append(var, srcbuf); 1241 aml_append(var, index); 1242 build_append_namestring(var->buf, "%s", name); 1243 return var; 1244 } 1245 1246 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefCreateField */ 1247 Aml *aml_create_field(Aml *srcbuf, Aml *bit_index, Aml *num_bits, 1248 const char *name) 1249 { 1250 Aml *var = aml_alloc(); 1251 build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */ 1252 build_append_byte(var->buf, 0x13); /* CreateFieldOp */ 1253 aml_append(var, srcbuf); 1254 aml_append(var, bit_index); 1255 aml_append(var, num_bits); 1256 build_append_namestring(var->buf, "%s", name); 1257 return var; 1258 } 1259 1260 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefCreateDWordField */ 1261 Aml *aml_create_dword_field(Aml *srcbuf, Aml *index, const char *name) 1262 { 1263 return create_field_common(0x8A /* CreateDWordFieldOp */, 1264 srcbuf, index, name); 1265 } 1266 1267 /* ACPI 2.0a: 17.2.4.2 Named Objects Encoding: DefCreateQWordField */ 1268 Aml *aml_create_qword_field(Aml *srcbuf, Aml *index, const char *name) 1269 { 1270 return create_field_common(0x8F /* CreateQWordFieldOp */, 1271 srcbuf, index, name); 1272 } 1273 1274 /* ACPI 1.0b: 16.2.3 Data Objects Encoding: String */ 1275 Aml *aml_string(const char *name_format, ...) 1276 { 1277 Aml *var = aml_opcode(0x0D /* StringPrefix */); 1278 va_list ap; 1279 char *s; 1280 int len; 1281 1282 va_start(ap, name_format); 1283 len = g_vasprintf(&s, name_format, ap); 1284 va_end(ap); 1285 1286 g_array_append_vals(var->buf, s, len + 1); 1287 g_free(s); 1288 1289 return var; 1290 } 1291 1292 /* ACPI 1.0b: 16.2.6.2 Local Objects Encoding */ 1293 Aml *aml_local(int num) 1294 { 1295 uint8_t op = 0x60 /* Local0Op */ + num; 1296 1297 assert(num <= 7); 1298 return aml_opcode(op); 1299 } 1300 1301 /* ACPI 2.0a: 17.2.2 Data Objects Encoding: DefVarPackage */ 1302 Aml *aml_varpackage(uint32_t num_elements) 1303 { 1304 Aml *var = aml_bundle(0x13 /* VarPackageOp */, AML_PACKAGE); 1305 build_append_int(var->buf, num_elements); 1306 return var; 1307 } 1308 1309 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefProcessor */ 1310 Aml *aml_processor(uint8_t proc_id, uint32_t pblk_addr, uint8_t pblk_len, 1311 const char *name_format, ...) 1312 { 1313 va_list ap; 1314 Aml *var = aml_bundle(0x83 /* ProcessorOp */, AML_EXT_PACKAGE); 1315 va_start(ap, name_format); 1316 build_append_namestringv(var->buf, name_format, ap); 1317 va_end(ap); 1318 build_append_byte(var->buf, proc_id); /* ProcID */ 1319 build_append_int_noprefix(var->buf, pblk_addr, sizeof(pblk_addr)); 1320 build_append_byte(var->buf, pblk_len); /* PblkLen */ 1321 return var; 1322 } 1323 1324 static uint8_t Hex2Digit(char c) 1325 { 1326 if (c >= 'A') { 1327 return c - 'A' + 10; 1328 } 1329 1330 return c - '0'; 1331 } 1332 1333 /* ACPI 1.0b: 15.2.3.6.4.1 EISAID Macro - Convert EISA ID String To Integer */ 1334 Aml *aml_eisaid(const char *str) 1335 { 1336 Aml *var = aml_alloc(); 1337 uint32_t id; 1338 1339 g_assert(strlen(str) == 7); 1340 id = (str[0] - 0x40) << 26 | 1341 (str[1] - 0x40) << 21 | 1342 (str[2] - 0x40) << 16 | 1343 Hex2Digit(str[3]) << 12 | 1344 Hex2Digit(str[4]) << 8 | 1345 Hex2Digit(str[5]) << 4 | 1346 Hex2Digit(str[6]); 1347 1348 build_append_byte(var->buf, 0x0C); /* DWordPrefix */ 1349 build_append_int_noprefix(var->buf, bswap32(id), sizeof(id)); 1350 return var; 1351 } 1352 1353 /* ACPI 1.0b: 6.4.3.5.5 Word Address Space Descriptor: bytes 3-5 */ 1354 static Aml *aml_as_desc_header(AmlResourceType type, AmlMinFixed min_fixed, 1355 AmlMaxFixed max_fixed, AmlDecode dec, 1356 uint8_t type_flags) 1357 { 1358 uint8_t flags = max_fixed | min_fixed | dec; 1359 Aml *var = aml_alloc(); 1360 1361 build_append_byte(var->buf, type); 1362 build_append_byte(var->buf, flags); 1363 build_append_byte(var->buf, type_flags); /* Type Specific Flags */ 1364 return var; 1365 } 1366 1367 /* ACPI 1.0b: 6.4.3.5.5 Word Address Space Descriptor */ 1368 static Aml *aml_word_as_desc(AmlResourceType type, AmlMinFixed min_fixed, 1369 AmlMaxFixed max_fixed, AmlDecode dec, 1370 uint16_t addr_gran, uint16_t addr_min, 1371 uint16_t addr_max, uint16_t addr_trans, 1372 uint16_t len, uint8_t type_flags) 1373 { 1374 Aml *var = aml_alloc(); 1375 1376 build_append_byte(var->buf, 0x88); /* Word Address Space Descriptor */ 1377 /* minimum length since we do not encode optional fields */ 1378 build_append_byte(var->buf, 0x0D); 1379 build_append_byte(var->buf, 0x0); 1380 1381 aml_append(var, 1382 aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags)); 1383 build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran)); 1384 build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min)); 1385 build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max)); 1386 build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans)); 1387 build_append_int_noprefix(var->buf, len, sizeof(len)); 1388 return var; 1389 } 1390 1391 /* ACPI 1.0b: 6.4.3.5.3 DWord Address Space Descriptor */ 1392 static Aml *aml_dword_as_desc(AmlResourceType type, AmlMinFixed min_fixed, 1393 AmlMaxFixed max_fixed, AmlDecode dec, 1394 uint32_t addr_gran, uint32_t addr_min, 1395 uint32_t addr_max, uint32_t addr_trans, 1396 uint32_t len, uint8_t type_flags) 1397 { 1398 Aml *var = aml_alloc(); 1399 1400 build_append_byte(var->buf, 0x87); /* DWord Address Space Descriptor */ 1401 /* minimum length since we do not encode optional fields */ 1402 build_append_byte(var->buf, 23); 1403 build_append_byte(var->buf, 0x0); 1404 1405 1406 aml_append(var, 1407 aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags)); 1408 build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran)); 1409 build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min)); 1410 build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max)); 1411 build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans)); 1412 build_append_int_noprefix(var->buf, len, sizeof(len)); 1413 return var; 1414 } 1415 1416 /* ACPI 1.0b: 6.4.3.5.1 QWord Address Space Descriptor */ 1417 static Aml *aml_qword_as_desc(AmlResourceType type, AmlMinFixed min_fixed, 1418 AmlMaxFixed max_fixed, AmlDecode dec, 1419 uint64_t addr_gran, uint64_t addr_min, 1420 uint64_t addr_max, uint64_t addr_trans, 1421 uint64_t len, uint8_t type_flags) 1422 { 1423 Aml *var = aml_alloc(); 1424 1425 build_append_byte(var->buf, 0x8A); /* QWord Address Space Descriptor */ 1426 /* minimum length since we do not encode optional fields */ 1427 build_append_byte(var->buf, 0x2B); 1428 build_append_byte(var->buf, 0x0); 1429 1430 aml_append(var, 1431 aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags)); 1432 build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran)); 1433 build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min)); 1434 build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max)); 1435 build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans)); 1436 build_append_int_noprefix(var->buf, len, sizeof(len)); 1437 return var; 1438 } 1439 1440 /* 1441 * ACPI 1.0b: 6.4.3.5.6 ASL Macros for WORD Address Descriptor 1442 * 1443 * More verbose description at: 1444 * ACPI 5.0: 19.5.141 WordBusNumber (Word Bus Number Resource Descriptor Macro) 1445 */ 1446 Aml *aml_word_bus_number(AmlMinFixed min_fixed, AmlMaxFixed max_fixed, 1447 AmlDecode dec, uint16_t addr_gran, 1448 uint16_t addr_min, uint16_t addr_max, 1449 uint16_t addr_trans, uint16_t len) 1450 1451 { 1452 return aml_word_as_desc(AML_BUS_NUMBER_RANGE, min_fixed, max_fixed, dec, 1453 addr_gran, addr_min, addr_max, addr_trans, len, 0); 1454 } 1455 1456 /* 1457 * ACPI 1.0b: 6.4.3.5.6 ASL Macros for WORD Address Descriptor 1458 * 1459 * More verbose description at: 1460 * ACPI 5.0: 19.5.142 WordIO (Word IO Resource Descriptor Macro) 1461 */ 1462 Aml *aml_word_io(AmlMinFixed min_fixed, AmlMaxFixed max_fixed, 1463 AmlDecode dec, AmlISARanges isa_ranges, 1464 uint16_t addr_gran, uint16_t addr_min, 1465 uint16_t addr_max, uint16_t addr_trans, 1466 uint16_t len) 1467 1468 { 1469 return aml_word_as_desc(AML_IO_RANGE, min_fixed, max_fixed, dec, 1470 addr_gran, addr_min, addr_max, addr_trans, len, 1471 isa_ranges); 1472 } 1473 1474 /* 1475 * ACPI 1.0b: 6.4.3.5.4 ASL Macros for DWORD Address Descriptor 1476 * 1477 * More verbose description at: 1478 * ACPI 5.0: 19.5.33 DWordIO (DWord IO Resource Descriptor Macro) 1479 */ 1480 Aml *aml_dword_io(AmlMinFixed min_fixed, AmlMaxFixed max_fixed, 1481 AmlDecode dec, AmlISARanges isa_ranges, 1482 uint32_t addr_gran, uint32_t addr_min, 1483 uint32_t addr_max, uint32_t addr_trans, 1484 uint32_t len) 1485 1486 { 1487 return aml_dword_as_desc(AML_IO_RANGE, min_fixed, max_fixed, dec, 1488 addr_gran, addr_min, addr_max, addr_trans, len, 1489 isa_ranges); 1490 } 1491 1492 /* 1493 * ACPI 1.0b: 6.4.3.5.4 ASL Macros for DWORD Address Space Descriptor 1494 * 1495 * More verbose description at: 1496 * ACPI 5.0: 19.5.34 DWordMemory (DWord Memory Resource Descriptor Macro) 1497 */ 1498 Aml *aml_dword_memory(AmlDecode dec, AmlMinFixed min_fixed, 1499 AmlMaxFixed max_fixed, AmlCacheable cacheable, 1500 AmlReadAndWrite read_and_write, 1501 uint32_t addr_gran, uint32_t addr_min, 1502 uint32_t addr_max, uint32_t addr_trans, 1503 uint32_t len) 1504 { 1505 uint8_t flags = read_and_write | (cacheable << 1); 1506 1507 return aml_dword_as_desc(AML_MEMORY_RANGE, min_fixed, max_fixed, 1508 dec, addr_gran, addr_min, addr_max, 1509 addr_trans, len, flags); 1510 } 1511 1512 /* 1513 * ACPI 1.0b: 6.4.3.5.2 ASL Macros for QWORD Address Space Descriptor 1514 * 1515 * More verbose description at: 1516 * ACPI 5.0: 19.5.102 QWordMemory (QWord Memory Resource Descriptor Macro) 1517 */ 1518 Aml *aml_qword_memory(AmlDecode dec, AmlMinFixed min_fixed, 1519 AmlMaxFixed max_fixed, AmlCacheable cacheable, 1520 AmlReadAndWrite read_and_write, 1521 uint64_t addr_gran, uint64_t addr_min, 1522 uint64_t addr_max, uint64_t addr_trans, 1523 uint64_t len) 1524 { 1525 uint8_t flags = read_and_write | (cacheable << 1); 1526 1527 return aml_qword_as_desc(AML_MEMORY_RANGE, min_fixed, max_fixed, 1528 dec, addr_gran, addr_min, addr_max, 1529 addr_trans, len, flags); 1530 } 1531 1532 /* ACPI 1.0b: 6.4.2.2 DMA Format/6.4.2.2.1 ASL Macro for DMA Descriptor */ 1533 Aml *aml_dma(AmlDmaType typ, AmlDmaBusMaster bm, AmlTransferSize sz, 1534 uint8_t channel) 1535 { 1536 Aml *var = aml_alloc(); 1537 uint8_t flags = sz | bm << 2 | typ << 5; 1538 1539 assert(channel < 8); 1540 build_append_byte(var->buf, 0x2A); /* Byte 0: DMA Descriptor */ 1541 build_append_byte(var->buf, 1U << channel); /* Byte 1: _DMA - DmaChannel */ 1542 build_append_byte(var->buf, flags); /* Byte 2 */ 1543 return var; 1544 } 1545 1546 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefSleep */ 1547 Aml *aml_sleep(uint64_t msec) 1548 { 1549 Aml *var = aml_alloc(); 1550 build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */ 1551 build_append_byte(var->buf, 0x22); /* SleepOp */ 1552 aml_append(var, aml_int(msec)); 1553 return var; 1554 } 1555 1556 static uint8_t Hex2Byte(const char *src) 1557 { 1558 int hi, lo; 1559 1560 hi = Hex2Digit(src[0]); 1561 assert(hi >= 0); 1562 assert(hi <= 15); 1563 1564 lo = Hex2Digit(src[1]); 1565 assert(lo >= 0); 1566 assert(lo <= 15); 1567 return (hi << 4) | lo; 1568 } 1569 1570 /* 1571 * ACPI 3.0: 17.5.124 ToUUID (Convert String to UUID Macro) 1572 * e.g. UUID: aabbccdd-eeff-gghh-iijj-kkllmmnnoopp 1573 * call aml_touuid("aabbccdd-eeff-gghh-iijj-kkllmmnnoopp"); 1574 */ 1575 Aml *aml_touuid(const char *uuid) 1576 { 1577 Aml *var = aml_bundle(0x11 /* BufferOp */, AML_BUFFER); 1578 1579 assert(strlen(uuid) == 36); 1580 assert(uuid[8] == '-'); 1581 assert(uuid[13] == '-'); 1582 assert(uuid[18] == '-'); 1583 assert(uuid[23] == '-'); 1584 1585 build_append_byte(var->buf, Hex2Byte(uuid + 6)); /* dd - at offset 00 */ 1586 build_append_byte(var->buf, Hex2Byte(uuid + 4)); /* cc - at offset 01 */ 1587 build_append_byte(var->buf, Hex2Byte(uuid + 2)); /* bb - at offset 02 */ 1588 build_append_byte(var->buf, Hex2Byte(uuid + 0)); /* aa - at offset 03 */ 1589 1590 build_append_byte(var->buf, Hex2Byte(uuid + 11)); /* ff - at offset 04 */ 1591 build_append_byte(var->buf, Hex2Byte(uuid + 9)); /* ee - at offset 05 */ 1592 1593 build_append_byte(var->buf, Hex2Byte(uuid + 16)); /* hh - at offset 06 */ 1594 build_append_byte(var->buf, Hex2Byte(uuid + 14)); /* gg - at offset 07 */ 1595 1596 build_append_byte(var->buf, Hex2Byte(uuid + 19)); /* ii - at offset 08 */ 1597 build_append_byte(var->buf, Hex2Byte(uuid + 21)); /* jj - at offset 09 */ 1598 1599 build_append_byte(var->buf, Hex2Byte(uuid + 24)); /* kk - at offset 10 */ 1600 build_append_byte(var->buf, Hex2Byte(uuid + 26)); /* ll - at offset 11 */ 1601 build_append_byte(var->buf, Hex2Byte(uuid + 28)); /* mm - at offset 12 */ 1602 build_append_byte(var->buf, Hex2Byte(uuid + 30)); /* nn - at offset 13 */ 1603 build_append_byte(var->buf, Hex2Byte(uuid + 32)); /* oo - at offset 14 */ 1604 build_append_byte(var->buf, Hex2Byte(uuid + 34)); /* pp - at offset 15 */ 1605 1606 return var; 1607 } 1608 1609 /* 1610 * ACPI 2.0b: 16.2.3.6.4.3 Unicode Macro (Convert Ascii String To Unicode) 1611 */ 1612 Aml *aml_unicode(const char *str) 1613 { 1614 int i = 0; 1615 Aml *var = aml_bundle(0x11 /* BufferOp */, AML_BUFFER); 1616 1617 do { 1618 build_append_byte(var->buf, str[i]); 1619 build_append_byte(var->buf, 0); 1620 i++; 1621 } while (i <= strlen(str)); 1622 1623 return var; 1624 } 1625 1626 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefRefOf */ 1627 Aml *aml_refof(Aml *arg) 1628 { 1629 Aml *var = aml_opcode(0x71 /* RefOfOp */); 1630 aml_append(var, arg); 1631 return var; 1632 } 1633 1634 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefDerefOf */ 1635 Aml *aml_derefof(Aml *arg) 1636 { 1637 Aml *var = aml_opcode(0x83 /* DerefOfOp */); 1638 aml_append(var, arg); 1639 return var; 1640 } 1641 1642 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefSizeOf */ 1643 Aml *aml_sizeof(Aml *arg) 1644 { 1645 Aml *var = aml_opcode(0x87 /* SizeOfOp */); 1646 aml_append(var, arg); 1647 return var; 1648 } 1649 1650 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefMutex */ 1651 Aml *aml_mutex(const char *name, uint8_t sync_level) 1652 { 1653 Aml *var = aml_alloc(); 1654 build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */ 1655 build_append_byte(var->buf, 0x01); /* MutexOp */ 1656 build_append_namestring(var->buf, "%s", name); 1657 assert(!(sync_level & 0xF0)); 1658 build_append_byte(var->buf, sync_level); 1659 return var; 1660 } 1661 1662 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefAcquire */ 1663 Aml *aml_acquire(Aml *mutex, uint16_t timeout) 1664 { 1665 Aml *var = aml_alloc(); 1666 build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */ 1667 build_append_byte(var->buf, 0x23); /* AcquireOp */ 1668 aml_append(var, mutex); 1669 build_append_int_noprefix(var->buf, timeout, sizeof(timeout)); 1670 return var; 1671 } 1672 1673 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefRelease */ 1674 Aml *aml_release(Aml *mutex) 1675 { 1676 Aml *var = aml_alloc(); 1677 build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */ 1678 build_append_byte(var->buf, 0x27); /* ReleaseOp */ 1679 aml_append(var, mutex); 1680 return var; 1681 } 1682 1683 /* ACPI 1.0b: 16.2.5.1 Name Space Modifier Objects Encoding: DefAlias */ 1684 Aml *aml_alias(const char *source_object, const char *alias_object) 1685 { 1686 Aml *var = aml_opcode(0x06 /* AliasOp */); 1687 aml_append(var, aml_name("%s", source_object)); 1688 aml_append(var, aml_name("%s", alias_object)); 1689 return var; 1690 } 1691 1692 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefConcat */ 1693 Aml *aml_concatenate(Aml *source1, Aml *source2, Aml *target) 1694 { 1695 return build_opcode_2arg_dst(0x73 /* ConcatOp */, source1, source2, 1696 target); 1697 } 1698 1699 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefObjectType */ 1700 Aml *aml_object_type(Aml *object) 1701 { 1702 Aml *var = aml_opcode(0x8E /* ObjectTypeOp */); 1703 aml_append(var, object); 1704 return var; 1705 } 1706 1707 void acpi_table_begin(AcpiTable *desc, GArray *array) 1708 { 1709 1710 desc->array = array; 1711 desc->table_offset = array->len; 1712 1713 /* 1714 * ACPI spec 1.0b 1715 * 5.2.3 System Description Table Header 1716 */ 1717 g_assert(strlen(desc->sig) == 4); 1718 g_array_append_vals(array, desc->sig, 4); /* Signature */ 1719 /* 1720 * reserve space for Length field, which will be patched by 1721 * acpi_table_end() when the table creation is finished. 1722 */ 1723 build_append_int_noprefix(array, 0, 4); /* Length */ 1724 build_append_int_noprefix(array, desc->rev, 1); /* Revision */ 1725 build_append_int_noprefix(array, 0, 1); /* Checksum */ 1726 build_append_padded_str(array, desc->oem_id, 6, '\0'); /* OEMID */ 1727 /* OEM Table ID */ 1728 build_append_padded_str(array, desc->oem_table_id, 8, '\0'); 1729 build_append_int_noprefix(array, 1, 4); /* OEM Revision */ 1730 g_array_append_vals(array, ACPI_BUILD_APPNAME8, 4); /* Creator ID */ 1731 build_append_int_noprefix(array, 1, 4); /* Creator Revision */ 1732 } 1733 1734 void acpi_table_end(BIOSLinker *linker, AcpiTable *desc) 1735 { 1736 /* 1737 * ACPI spec 1.0b 1738 * 5.2.3 System Description Table Header 1739 * Table 5-2 DESCRIPTION_HEADER Fields 1740 */ 1741 const unsigned checksum_offset = 9; 1742 uint32_t table_len = desc->array->len - desc->table_offset; 1743 uint32_t table_len_le = cpu_to_le32(table_len); 1744 gchar *len_ptr = &desc->array->data[desc->table_offset + 4]; 1745 1746 /* patch "Length" field that has been reserved by acpi_table_begin() 1747 * to the actual length, i.e. accumulated table length from 1748 * acpi_table_begin() till acpi_table_end() 1749 */ 1750 memcpy(len_ptr, &table_len_le, sizeof table_len_le); 1751 1752 bios_linker_loader_add_checksum(linker, ACPI_BUILD_TABLE_FILE, 1753 desc->table_offset, table_len, desc->table_offset + checksum_offset); 1754 } 1755 1756 void *acpi_data_push(GArray *table_data, unsigned size) 1757 { 1758 unsigned off = table_data->len; 1759 g_array_set_size(table_data, off + size); 1760 return table_data->data + off; 1761 } 1762 1763 unsigned acpi_data_len(GArray *table) 1764 { 1765 assert(g_array_get_element_size(table) == 1); 1766 return table->len; 1767 } 1768 1769 void acpi_add_table(GArray *table_offsets, GArray *table_data) 1770 { 1771 uint32_t offset = table_data->len; 1772 g_array_append_val(table_offsets, offset); 1773 } 1774 1775 void acpi_build_tables_init(AcpiBuildTables *tables) 1776 { 1777 tables->rsdp = g_array_new(false, true /* clear */, 1); 1778 tables->table_data = g_array_new(false, true /* clear */, 1); 1779 tables->tcpalog = g_array_new(false, true /* clear */, 1); 1780 tables->vmgenid = g_array_new(false, true /* clear */, 1); 1781 tables->hardware_errors = g_array_new(false, true /* clear */, 1); 1782 tables->linker = bios_linker_loader_init(); 1783 } 1784 1785 void acpi_build_tables_cleanup(AcpiBuildTables *tables, bool mfre) 1786 { 1787 bios_linker_loader_cleanup(tables->linker); 1788 g_array_free(tables->rsdp, true); 1789 g_array_free(tables->table_data, true); 1790 g_array_free(tables->tcpalog, mfre); 1791 g_array_free(tables->vmgenid, mfre); 1792 g_array_free(tables->hardware_errors, mfre); 1793 } 1794 1795 /* 1796 * ACPI spec 5.2.5.3 Root System Description Pointer (RSDP). 1797 * (Revision 1.0 or later) 1798 */ 1799 void 1800 build_rsdp(GArray *tbl, BIOSLinker *linker, AcpiRsdpData *rsdp_data) 1801 { 1802 int tbl_off = tbl->len; /* Table offset in the RSDP file */ 1803 1804 switch (rsdp_data->revision) { 1805 case 0: 1806 /* With ACPI 1.0, we must have an RSDT pointer */ 1807 g_assert(rsdp_data->rsdt_tbl_offset); 1808 break; 1809 case 2: 1810 /* With ACPI 2.0+, we must have an XSDT pointer */ 1811 g_assert(rsdp_data->xsdt_tbl_offset); 1812 break; 1813 default: 1814 /* Only revisions 0 (ACPI 1.0) and 2 (ACPI 2.0+) are valid for RSDP */ 1815 g_assert_not_reached(); 1816 } 1817 1818 bios_linker_loader_alloc(linker, ACPI_BUILD_RSDP_FILE, tbl, 16, 1819 true /* fseg memory */); 1820 1821 g_array_append_vals(tbl, "RSD PTR ", 8); /* Signature */ 1822 build_append_int_noprefix(tbl, 0, 1); /* Checksum */ 1823 g_array_append_vals(tbl, rsdp_data->oem_id, 6); /* OEMID */ 1824 build_append_int_noprefix(tbl, rsdp_data->revision, 1); /* Revision */ 1825 build_append_int_noprefix(tbl, 0, 4); /* RsdtAddress */ 1826 if (rsdp_data->rsdt_tbl_offset) { 1827 /* RSDT address to be filled by guest linker */ 1828 bios_linker_loader_add_pointer(linker, ACPI_BUILD_RSDP_FILE, 1829 tbl_off + 16, 4, 1830 ACPI_BUILD_TABLE_FILE, 1831 *rsdp_data->rsdt_tbl_offset); 1832 } 1833 1834 /* Checksum to be filled by guest linker */ 1835 bios_linker_loader_add_checksum(linker, ACPI_BUILD_RSDP_FILE, 1836 tbl_off, 20, /* ACPI rev 1.0 RSDP size */ 1837 8); 1838 1839 if (rsdp_data->revision == 0) { 1840 /* ACPI 1.0 RSDP, we're done */ 1841 return; 1842 } 1843 1844 build_append_int_noprefix(tbl, 36, 4); /* Length */ 1845 1846 /* XSDT address to be filled by guest linker */ 1847 build_append_int_noprefix(tbl, 0, 8); /* XsdtAddress */ 1848 /* We already validated our xsdt pointer */ 1849 bios_linker_loader_add_pointer(linker, ACPI_BUILD_RSDP_FILE, 1850 tbl_off + 24, 8, 1851 ACPI_BUILD_TABLE_FILE, 1852 *rsdp_data->xsdt_tbl_offset); 1853 1854 build_append_int_noprefix(tbl, 0, 1); /* Extended Checksum */ 1855 build_append_int_noprefix(tbl, 0, 3); /* Reserved */ 1856 1857 /* Extended checksum to be filled by Guest linker */ 1858 bios_linker_loader_add_checksum(linker, ACPI_BUILD_RSDP_FILE, 1859 tbl_off, 36, /* ACPI rev 2.0 RSDP size */ 1860 32); 1861 } 1862 1863 /* 1864 * ACPI 1.0 Root System Description Table (RSDT) 1865 */ 1866 void 1867 build_rsdt(GArray *table_data, BIOSLinker *linker, GArray *table_offsets, 1868 const char *oem_id, const char *oem_table_id) 1869 { 1870 int i; 1871 AcpiTable table = { .sig = "RSDT", .rev = 1, 1872 .oem_id = oem_id, .oem_table_id = oem_table_id }; 1873 1874 acpi_table_begin(&table, table_data); 1875 for (i = 0; i < table_offsets->len; ++i) { 1876 uint32_t ref_tbl_offset = g_array_index(table_offsets, uint32_t, i); 1877 uint32_t rsdt_entry_offset = table.array->len; 1878 1879 /* reserve space for entry */ 1880 build_append_int_noprefix(table.array, 0, 4); 1881 1882 /* mark position of RSDT entry to be filled by Guest linker */ 1883 bios_linker_loader_add_pointer(linker, 1884 ACPI_BUILD_TABLE_FILE, rsdt_entry_offset, 4, 1885 ACPI_BUILD_TABLE_FILE, ref_tbl_offset); 1886 1887 } 1888 acpi_table_end(linker, &table); 1889 } 1890 1891 /* 1892 * ACPI 2.0 eXtended System Description Table (XSDT) 1893 */ 1894 void 1895 build_xsdt(GArray *table_data, BIOSLinker *linker, GArray *table_offsets, 1896 const char *oem_id, const char *oem_table_id) 1897 { 1898 int i; 1899 AcpiTable table = { .sig = "XSDT", .rev = 1, 1900 .oem_id = oem_id, .oem_table_id = oem_table_id }; 1901 1902 acpi_table_begin(&table, table_data); 1903 1904 for (i = 0; i < table_offsets->len; ++i) { 1905 uint64_t ref_tbl_offset = g_array_index(table_offsets, uint32_t, i); 1906 uint64_t xsdt_entry_offset = table.array->len; 1907 1908 /* reserve space for entry */ 1909 build_append_int_noprefix(table.array, 0, 8); 1910 1911 /* mark position of RSDT entry to be filled by Guest linker */ 1912 bios_linker_loader_add_pointer(linker, 1913 ACPI_BUILD_TABLE_FILE, xsdt_entry_offset, 8, 1914 ACPI_BUILD_TABLE_FILE, ref_tbl_offset); 1915 } 1916 acpi_table_end(linker, &table); 1917 } 1918 1919 /* 1920 * ACPI spec, Revision 4.0 1921 * 5.2.16.2 Memory Affinity Structure 1922 */ 1923 void build_srat_memory(GArray *table_data, uint64_t base, 1924 uint64_t len, int node, MemoryAffinityFlags flags) 1925 { 1926 build_append_int_noprefix(table_data, 1, 1); /* Type */ 1927 build_append_int_noprefix(table_data, 40, 1); /* Length */ 1928 build_append_int_noprefix(table_data, node, 4); /* Proximity Domain */ 1929 build_append_int_noprefix(table_data, 0, 2); /* Reserved */ 1930 build_append_int_noprefix(table_data, base, 4); /* Base Address Low */ 1931 /* Base Address High */ 1932 build_append_int_noprefix(table_data, base >> 32, 4); 1933 build_append_int_noprefix(table_data, len, 4); /* Length Low */ 1934 build_append_int_noprefix(table_data, len >> 32, 4); /* Length High */ 1935 build_append_int_noprefix(table_data, 0, 4); /* Reserved */ 1936 build_append_int_noprefix(table_data, flags, 4); /* Flags */ 1937 build_append_int_noprefix(table_data, 0, 8); /* Reserved */ 1938 } 1939 1940 /* 1941 * ACPI Spec Revision 6.3 1942 * Table 5-80 Device Handle - PCI 1943 */ 1944 static void build_append_srat_pci_device_handle(GArray *table_data, 1945 uint16_t segment, 1946 uint8_t bus, uint8_t devfn) 1947 { 1948 /* PCI segment number */ 1949 build_append_int_noprefix(table_data, segment, 2); 1950 /* PCI Bus Device Function */ 1951 build_append_int_noprefix(table_data, bus, 1); 1952 build_append_int_noprefix(table_data, devfn, 1); 1953 /* Reserved */ 1954 build_append_int_noprefix(table_data, 0, 12); 1955 } 1956 1957 static void build_append_srat_acpi_device_handle(GArray *table_data, 1958 const char *hid, 1959 uint32_t uid) 1960 { 1961 assert(strlen(hid) == 8); 1962 /* Device Handle - ACPI */ 1963 for (int i = 0; i < sizeof(hid); i++) { 1964 build_append_int_noprefix(table_data, hid[i], 1); 1965 } 1966 build_append_int_noprefix(table_data, uid, 4); 1967 build_append_int_noprefix(table_data, 0, 4); 1968 } 1969 1970 /* 1971 * ACPI spec, Revision 6.3 1972 * 5.2.16.6 Generic Initiator Affinity Structure 1973 * With PCI Device Handle. 1974 */ 1975 void build_srat_pci_generic_initiator(GArray *table_data, uint32_t node, 1976 uint16_t segment, uint8_t bus, 1977 uint8_t devfn) 1978 { 1979 /* Type */ 1980 build_append_int_noprefix(table_data, 5, 1); 1981 /* Length */ 1982 build_append_int_noprefix(table_data, 32, 1); 1983 /* Reserved */ 1984 build_append_int_noprefix(table_data, 0, 1); 1985 /* Device Handle Type: PCI */ 1986 build_append_int_noprefix(table_data, 1, 1); 1987 /* Proximity Domain */ 1988 build_append_int_noprefix(table_data, node, 4); 1989 /* Device Handle */ 1990 build_append_srat_pci_device_handle(table_data, segment, bus, devfn); 1991 /* Flags - GI Enabled */ 1992 build_append_int_noprefix(table_data, 1, 4); 1993 /* Reserved */ 1994 build_append_int_noprefix(table_data, 0, 4); 1995 } 1996 1997 /* 1998 * ACPI spec, Revision 6.5 1999 * 5.2.16.7 Generic Port Affinity Structure 2000 * With ACPI Device Handle. 2001 */ 2002 void build_srat_acpi_generic_port(GArray *table_data, uint32_t node, 2003 const char *hid, uint32_t uid) 2004 { 2005 /* Type */ 2006 build_append_int_noprefix(table_data, 6, 1); 2007 /* Length */ 2008 build_append_int_noprefix(table_data, 32, 1); 2009 /* Reserved */ 2010 build_append_int_noprefix(table_data, 0, 1); 2011 /* Device Handle Type: ACPI */ 2012 build_append_int_noprefix(table_data, 0, 1); 2013 /* Proximity Domain */ 2014 build_append_int_noprefix(table_data, node, 4); 2015 /* Device Handle */ 2016 build_append_srat_acpi_device_handle(table_data, hid, uid); 2017 /* Flags - GP Enabled */ 2018 build_append_int_noprefix(table_data, 1, 4); 2019 /* Reserved */ 2020 build_append_int_noprefix(table_data, 0, 4); 2021 } 2022 2023 /* 2024 * ACPI spec 5.2.17 System Locality Distance Information Table 2025 * (Revision 2.0 or later) 2026 */ 2027 void build_slit(GArray *table_data, BIOSLinker *linker, MachineState *ms, 2028 const char *oem_id, const char *oem_table_id) 2029 { 2030 int i, j; 2031 int nb_numa_nodes = ms->numa_state->num_nodes; 2032 AcpiTable table = { .sig = "SLIT", .rev = 1, 2033 .oem_id = oem_id, .oem_table_id = oem_table_id }; 2034 2035 acpi_table_begin(&table, table_data); 2036 2037 build_append_int_noprefix(table_data, nb_numa_nodes, 8); 2038 for (i = 0; i < nb_numa_nodes; i++) { 2039 for (j = 0; j < nb_numa_nodes; j++) { 2040 assert(ms->numa_state->nodes[i].distance[j]); 2041 build_append_int_noprefix(table_data, 2042 ms->numa_state->nodes[i].distance[j], 2043 1); 2044 } 2045 } 2046 acpi_table_end(linker, &table); 2047 } 2048 2049 /* 2050 * ACPI spec, Revision 6.3 2051 * 5.2.29.1 Processor hierarchy node structure (Type 0) 2052 */ 2053 static void build_processor_hierarchy_node(GArray *tbl, uint32_t flags, 2054 uint32_t parent, uint32_t id, 2055 uint32_t *priv_rsrc, 2056 uint32_t priv_num) 2057 { 2058 int i; 2059 2060 build_append_byte(tbl, 0); /* Type 0 - processor */ 2061 build_append_byte(tbl, 20 + priv_num * 4); /* Length */ 2062 build_append_int_noprefix(tbl, 0, 2); /* Reserved */ 2063 build_append_int_noprefix(tbl, flags, 4); /* Flags */ 2064 build_append_int_noprefix(tbl, parent, 4); /* Parent */ 2065 build_append_int_noprefix(tbl, id, 4); /* ACPI Processor ID */ 2066 2067 /* Number of private resources */ 2068 build_append_int_noprefix(tbl, priv_num, 4); 2069 2070 /* Private resources[N] */ 2071 if (priv_num > 0) { 2072 assert(priv_rsrc); 2073 for (i = 0; i < priv_num; i++) { 2074 build_append_int_noprefix(tbl, priv_rsrc[i], 4); 2075 } 2076 } 2077 } 2078 2079 void build_spcr(GArray *table_data, BIOSLinker *linker, 2080 const AcpiSpcrData *f, const uint8_t rev, 2081 const char *oem_id, const char *oem_table_id) 2082 { 2083 AcpiTable table = { .sig = "SPCR", .rev = rev, .oem_id = oem_id, 2084 .oem_table_id = oem_table_id }; 2085 2086 acpi_table_begin(&table, table_data); 2087 /* Interface type */ 2088 build_append_int_noprefix(table_data, f->interface_type, 1); 2089 /* Reserved */ 2090 build_append_int_noprefix(table_data, 0, 3); 2091 /* Base Address */ 2092 build_append_gas(table_data, f->base_addr.id, f->base_addr.width, 2093 f->base_addr.offset, f->base_addr.size, 2094 f->base_addr.addr); 2095 /* Interrupt type */ 2096 build_append_int_noprefix(table_data, f->interrupt_type, 1); 2097 /* IRQ */ 2098 build_append_int_noprefix(table_data, f->pc_interrupt, 1); 2099 /* Global System Interrupt */ 2100 build_append_int_noprefix(table_data, f->interrupt, 4); 2101 /* Baud Rate */ 2102 build_append_int_noprefix(table_data, f->baud_rate, 1); 2103 /* Parity */ 2104 build_append_int_noprefix(table_data, f->parity, 1); 2105 /* Stop Bits */ 2106 build_append_int_noprefix(table_data, f->stop_bits, 1); 2107 /* Flow Control */ 2108 build_append_int_noprefix(table_data, f->flow_control, 1); 2109 /* Language */ 2110 build_append_int_noprefix(table_data, f->language, 1); 2111 /* Terminal Type */ 2112 build_append_int_noprefix(table_data, f->terminal_type, 1); 2113 /* PCI Device ID */ 2114 build_append_int_noprefix(table_data, f->pci_device_id, 2); 2115 /* PCI Vendor ID */ 2116 build_append_int_noprefix(table_data, f->pci_vendor_id, 2); 2117 /* PCI Bus Number */ 2118 build_append_int_noprefix(table_data, f->pci_bus, 1); 2119 /* PCI Device Number */ 2120 build_append_int_noprefix(table_data, f->pci_device, 1); 2121 /* PCI Function Number */ 2122 build_append_int_noprefix(table_data, f->pci_function, 1); 2123 /* PCI Flags */ 2124 build_append_int_noprefix(table_data, f->pci_flags, 4); 2125 /* PCI Segment */ 2126 build_append_int_noprefix(table_data, f->pci_segment, 1); 2127 /* Reserved */ 2128 build_append_int_noprefix(table_data, 0, 4); 2129 2130 acpi_table_end(linker, &table); 2131 } 2132 /* 2133 * ACPI spec, Revision 6.3 2134 * 5.2.29 Processor Properties Topology Table (PPTT) 2135 */ 2136 void build_pptt(GArray *table_data, BIOSLinker *linker, MachineState *ms, 2137 const char *oem_id, const char *oem_table_id) 2138 { 2139 MachineClass *mc = MACHINE_GET_CLASS(ms); 2140 CPUArchIdList *cpus = ms->possible_cpus; 2141 int64_t socket_id = -1, cluster_id = -1, core_id = -1; 2142 uint32_t socket_offset = 0, cluster_offset = 0, core_offset = 0; 2143 uint32_t pptt_start = table_data->len; 2144 int n; 2145 AcpiTable table = { .sig = "PPTT", .rev = 2, 2146 .oem_id = oem_id, .oem_table_id = oem_table_id }; 2147 2148 acpi_table_begin(&table, table_data); 2149 2150 /* 2151 * This works with the assumption that cpus[n].props.*_id has been 2152 * sorted from top to down levels in mc->possible_cpu_arch_ids(). 2153 * Otherwise, the unexpected and duplicated containers will be 2154 * created. 2155 */ 2156 for (n = 0; n < cpus->len; n++) { 2157 if (cpus->cpus[n].props.socket_id != socket_id) { 2158 assert(cpus->cpus[n].props.socket_id > socket_id); 2159 socket_id = cpus->cpus[n].props.socket_id; 2160 cluster_id = -1; 2161 core_id = -1; 2162 socket_offset = table_data->len - pptt_start; 2163 build_processor_hierarchy_node(table_data, 2164 (1 << 0), /* Physical package */ 2165 0, socket_id, NULL, 0); 2166 } 2167 2168 if (mc->smp_props.clusters_supported && mc->smp_props.has_clusters) { 2169 if (cpus->cpus[n].props.cluster_id != cluster_id) { 2170 assert(cpus->cpus[n].props.cluster_id > cluster_id); 2171 cluster_id = cpus->cpus[n].props.cluster_id; 2172 core_id = -1; 2173 cluster_offset = table_data->len - pptt_start; 2174 build_processor_hierarchy_node(table_data, 2175 (0 << 0), /* Not a physical package */ 2176 socket_offset, cluster_id, NULL, 0); 2177 } 2178 } else { 2179 cluster_offset = socket_offset; 2180 } 2181 2182 if (ms->smp.threads == 1) { 2183 build_processor_hierarchy_node(table_data, 2184 (1 << 1) | /* ACPI Processor ID valid */ 2185 (1 << 3), /* Node is a Leaf */ 2186 cluster_offset, n, NULL, 0); 2187 } else { 2188 if (cpus->cpus[n].props.core_id != core_id) { 2189 assert(cpus->cpus[n].props.core_id > core_id); 2190 core_id = cpus->cpus[n].props.core_id; 2191 core_offset = table_data->len - pptt_start; 2192 build_processor_hierarchy_node(table_data, 2193 (0 << 0), /* Not a physical package */ 2194 cluster_offset, core_id, NULL, 0); 2195 } 2196 2197 build_processor_hierarchy_node(table_data, 2198 (1 << 1) | /* ACPI Processor ID valid */ 2199 (1 << 2) | /* Processor is a Thread */ 2200 (1 << 3), /* Node is a Leaf */ 2201 core_offset, n, NULL, 0); 2202 } 2203 } 2204 2205 acpi_table_end(linker, &table); 2206 } 2207 2208 /* build rev1/rev3/rev5.1/rev6.0 FADT */ 2209 void build_fadt(GArray *tbl, BIOSLinker *linker, const AcpiFadtData *f, 2210 const char *oem_id, const char *oem_table_id) 2211 { 2212 int off; 2213 AcpiTable table = { .sig = "FACP", .rev = f->rev, 2214 .oem_id = oem_id, .oem_table_id = oem_table_id }; 2215 2216 acpi_table_begin(&table, tbl); 2217 2218 /* FACS address to be filled by Guest linker at runtime */ 2219 off = tbl->len; 2220 build_append_int_noprefix(tbl, 0, 4); /* FIRMWARE_CTRL */ 2221 if (f->facs_tbl_offset) { /* don't patch if not supported by platform */ 2222 bios_linker_loader_add_pointer(linker, 2223 ACPI_BUILD_TABLE_FILE, off, 4, 2224 ACPI_BUILD_TABLE_FILE, *f->facs_tbl_offset); 2225 } 2226 2227 /* DSDT address to be filled by Guest linker at runtime */ 2228 off = tbl->len; 2229 build_append_int_noprefix(tbl, 0, 4); /* DSDT */ 2230 if (f->dsdt_tbl_offset) { /* don't patch if not supported by platform */ 2231 bios_linker_loader_add_pointer(linker, 2232 ACPI_BUILD_TABLE_FILE, off, 4, 2233 ACPI_BUILD_TABLE_FILE, *f->dsdt_tbl_offset); 2234 } 2235 2236 /* ACPI1.0: INT_MODEL, ACPI2.0+: Reserved */ 2237 build_append_int_noprefix(tbl, f->int_model /* Multiple APIC */, 1); 2238 /* Preferred_PM_Profile */ 2239 build_append_int_noprefix(tbl, 0 /* Unspecified */, 1); 2240 build_append_int_noprefix(tbl, f->sci_int, 2); /* SCI_INT */ 2241 build_append_int_noprefix(tbl, f->smi_cmd, 4); /* SMI_CMD */ 2242 build_append_int_noprefix(tbl, f->acpi_enable_cmd, 1); /* ACPI_ENABLE */ 2243 build_append_int_noprefix(tbl, f->acpi_disable_cmd, 1); /* ACPI_DISABLE */ 2244 build_append_int_noprefix(tbl, 0 /* not supported */, 1); /* S4BIOS_REQ */ 2245 /* ACPI1.0: Reserved, ACPI2.0+: PSTATE_CNT */ 2246 build_append_int_noprefix(tbl, 0, 1); 2247 build_append_int_noprefix(tbl, f->pm1a_evt.address, 4); /* PM1a_EVT_BLK */ 2248 build_append_int_noprefix(tbl, 0, 4); /* PM1b_EVT_BLK */ 2249 build_append_int_noprefix(tbl, f->pm1a_cnt.address, 4); /* PM1a_CNT_BLK */ 2250 build_append_int_noprefix(tbl, 0, 4); /* PM1b_CNT_BLK */ 2251 build_append_int_noprefix(tbl, 0, 4); /* PM2_CNT_BLK */ 2252 build_append_int_noprefix(tbl, f->pm_tmr.address, 4); /* PM_TMR_BLK */ 2253 build_append_int_noprefix(tbl, f->gpe0_blk.address, 4); /* GPE0_BLK */ 2254 build_append_int_noprefix(tbl, 0, 4); /* GPE1_BLK */ 2255 /* PM1_EVT_LEN */ 2256 build_append_int_noprefix(tbl, f->pm1a_evt.bit_width / 8, 1); 2257 /* PM1_CNT_LEN */ 2258 build_append_int_noprefix(tbl, f->pm1a_cnt.bit_width / 8, 1); 2259 build_append_int_noprefix(tbl, 0, 1); /* PM2_CNT_LEN */ 2260 build_append_int_noprefix(tbl, f->pm_tmr.bit_width / 8, 1); /* PM_TMR_LEN */ 2261 /* GPE0_BLK_LEN */ 2262 build_append_int_noprefix(tbl, f->gpe0_blk.bit_width / 8, 1); 2263 build_append_int_noprefix(tbl, 0, 1); /* GPE1_BLK_LEN */ 2264 build_append_int_noprefix(tbl, 0, 1); /* GPE1_BASE */ 2265 build_append_int_noprefix(tbl, 0, 1); /* CST_CNT */ 2266 build_append_int_noprefix(tbl, f->plvl2_lat, 2); /* P_LVL2_LAT */ 2267 build_append_int_noprefix(tbl, f->plvl3_lat, 2); /* P_LVL3_LAT */ 2268 build_append_int_noprefix(tbl, 0, 2); /* FLUSH_SIZE */ 2269 build_append_int_noprefix(tbl, 0, 2); /* FLUSH_STRIDE */ 2270 build_append_int_noprefix(tbl, 0, 1); /* DUTY_OFFSET */ 2271 build_append_int_noprefix(tbl, 0, 1); /* DUTY_WIDTH */ 2272 build_append_int_noprefix(tbl, 0, 1); /* DAY_ALRM */ 2273 build_append_int_noprefix(tbl, 0, 1); /* MON_ALRM */ 2274 build_append_int_noprefix(tbl, f->rtc_century, 1); /* CENTURY */ 2275 /* IAPC_BOOT_ARCH */ 2276 if (f->rev == 1) { 2277 build_append_int_noprefix(tbl, 0, 2); 2278 } else { 2279 /* since ACPI v2.0 */ 2280 build_append_int_noprefix(tbl, f->iapc_boot_arch, 2); 2281 } 2282 build_append_int_noprefix(tbl, 0, 1); /* Reserved */ 2283 build_append_int_noprefix(tbl, f->flags, 4); /* Flags */ 2284 2285 if (f->rev == 1) { 2286 goto done; 2287 } 2288 2289 build_append_gas_from_struct(tbl, &f->reset_reg); /* RESET_REG */ 2290 build_append_int_noprefix(tbl, f->reset_val, 1); /* RESET_VALUE */ 2291 /* Since ACPI 5.1 */ 2292 if ((f->rev >= 6) || ((f->rev == 5) && f->minor_ver > 0)) { 2293 build_append_int_noprefix(tbl, f->arm_boot_arch, 2); /* ARM_BOOT_ARCH */ 2294 /* FADT Minor Version */ 2295 build_append_int_noprefix(tbl, f->minor_ver, 1); 2296 } else { 2297 build_append_int_noprefix(tbl, 0, 3); /* Reserved up to ACPI 5.0 */ 2298 } 2299 build_append_int_noprefix(tbl, 0, 8); /* X_FIRMWARE_CTRL */ 2300 2301 /* XDSDT address to be filled by Guest linker at runtime */ 2302 off = tbl->len; 2303 build_append_int_noprefix(tbl, 0, 8); /* X_DSDT */ 2304 if (f->xdsdt_tbl_offset) { 2305 bios_linker_loader_add_pointer(linker, 2306 ACPI_BUILD_TABLE_FILE, off, 8, 2307 ACPI_BUILD_TABLE_FILE, *f->xdsdt_tbl_offset); 2308 } 2309 2310 build_append_gas_from_struct(tbl, &f->pm1a_evt); /* X_PM1a_EVT_BLK */ 2311 /* X_PM1b_EVT_BLK */ 2312 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0); 2313 build_append_gas_from_struct(tbl, &f->pm1a_cnt); /* X_PM1a_CNT_BLK */ 2314 /* X_PM1b_CNT_BLK */ 2315 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0); 2316 /* X_PM2_CNT_BLK */ 2317 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0); 2318 build_append_gas_from_struct(tbl, &f->pm_tmr); /* X_PM_TMR_BLK */ 2319 build_append_gas_from_struct(tbl, &f->gpe0_blk); /* X_GPE0_BLK */ 2320 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0); /* X_GPE1_BLK */ 2321 2322 if (f->rev <= 4) { 2323 goto done; 2324 } 2325 2326 /* SLEEP_CONTROL_REG */ 2327 build_append_gas_from_struct(tbl, &f->sleep_ctl); 2328 /* SLEEP_STATUS_REG */ 2329 build_append_gas_from_struct(tbl, &f->sleep_sts); 2330 2331 if (f->rev == 5) { 2332 goto done; 2333 } 2334 2335 /* Hypervisor Vendor Identity */ 2336 build_append_padded_str(tbl, "QEMU", 8, '\0'); 2337 2338 /* TODO: extra fields need to be added to support revisions above rev6 */ 2339 assert(f->rev == 6); 2340 2341 done: 2342 acpi_table_end(linker, &table); 2343 } 2344 2345 #ifdef CONFIG_TPM 2346 /* 2347 * build_tpm2 - Build the TPM2 table as specified in 2348 * table 7: TCG Hardware Interface Description Table Format for TPM 2.0 2349 * of TCG ACPI Specification, Family “1.2” and “2.0”, Version 1.2, Rev 8 2350 */ 2351 void build_tpm2(GArray *table_data, BIOSLinker *linker, GArray *tcpalog, 2352 const char *oem_id, const char *oem_table_id) 2353 { 2354 uint8_t start_method_params[12] = {}; 2355 unsigned log_addr_offset; 2356 uint64_t control_area_start_address; 2357 TPMIf *tpmif = tpm_find(); 2358 uint32_t start_method; 2359 AcpiTable table = { .sig = "TPM2", .rev = 4, 2360 .oem_id = oem_id, .oem_table_id = oem_table_id }; 2361 2362 acpi_table_begin(&table, table_data); 2363 2364 /* Platform Class */ 2365 build_append_int_noprefix(table_data, TPM2_ACPI_CLASS_CLIENT, 2); 2366 /* Reserved */ 2367 build_append_int_noprefix(table_data, 0, 2); 2368 if (TPM_IS_TIS_ISA(tpmif) || TPM_IS_TIS_SYSBUS(tpmif)) { 2369 control_area_start_address = 0; 2370 start_method = TPM2_START_METHOD_MMIO; 2371 } else if (TPM_IS_CRB(tpmif)) { 2372 control_area_start_address = TPM_CRB_ADDR_CTRL; 2373 start_method = TPM2_START_METHOD_CRB; 2374 } else { 2375 g_assert_not_reached(); 2376 } 2377 /* Address of Control Area */ 2378 build_append_int_noprefix(table_data, control_area_start_address, 8); 2379 /* Start Method */ 2380 build_append_int_noprefix(table_data, start_method, 4); 2381 2382 /* Platform Specific Parameters */ 2383 g_array_append_vals(table_data, &start_method_params, 2384 ARRAY_SIZE(start_method_params)); 2385 2386 /* Log Area Minimum Length */ 2387 build_append_int_noprefix(table_data, TPM_LOG_AREA_MINIMUM_SIZE, 4); 2388 2389 acpi_data_push(tcpalog, TPM_LOG_AREA_MINIMUM_SIZE); 2390 bios_linker_loader_alloc(linker, ACPI_BUILD_TPMLOG_FILE, tcpalog, 1, 2391 false); 2392 2393 log_addr_offset = table_data->len; 2394 2395 /* Log Area Start Address to be filled by Guest linker */ 2396 build_append_int_noprefix(table_data, 0, 8); 2397 bios_linker_loader_add_pointer(linker, ACPI_BUILD_TABLE_FILE, 2398 log_addr_offset, 8, 2399 ACPI_BUILD_TPMLOG_FILE, 0); 2400 acpi_table_end(linker, &table); 2401 } 2402 #endif 2403 2404 Aml *build_crs(PCIHostState *host, CrsRangeSet *range_set, uint32_t io_offset, 2405 uint32_t mmio32_offset, uint64_t mmio64_offset, 2406 uint16_t bus_nr_offset) 2407 { 2408 Aml *crs = aml_resource_template(); 2409 CrsRangeSet temp_range_set; 2410 CrsRangeEntry *entry; 2411 uint8_t max_bus = pci_bus_num(host->bus); 2412 uint8_t type; 2413 int devfn; 2414 int i; 2415 2416 crs_range_set_init(&temp_range_set); 2417 for (devfn = 0; devfn < ARRAY_SIZE(host->bus->devices); devfn++) { 2418 uint64_t range_base, range_limit; 2419 PCIDevice *dev = host->bus->devices[devfn]; 2420 2421 if (!dev) { 2422 continue; 2423 } 2424 2425 for (i = 0; i < PCI_NUM_REGIONS; i++) { 2426 PCIIORegion *r = &dev->io_regions[i]; 2427 2428 range_base = r->addr; 2429 range_limit = r->addr + r->size - 1; 2430 2431 /* 2432 * Work-around for old bioses 2433 * that do not support multiple root buses 2434 */ 2435 if (!range_base || range_base > range_limit) { 2436 continue; 2437 } 2438 2439 if (r->type & PCI_BASE_ADDRESS_SPACE_IO) { 2440 crs_range_insert(temp_range_set.io_ranges, 2441 range_base, range_limit); 2442 } else { /* "memory" */ 2443 uint64_t length = range_limit - range_base + 1; 2444 if (range_limit <= UINT32_MAX && length <= UINT32_MAX) { 2445 crs_range_insert(temp_range_set.mem_ranges, range_base, 2446 range_limit); 2447 } else { 2448 crs_range_insert(temp_range_set.mem_64bit_ranges, 2449 range_base, range_limit); 2450 } 2451 } 2452 } 2453 2454 type = dev->config[PCI_HEADER_TYPE] & ~PCI_HEADER_TYPE_MULTI_FUNCTION; 2455 if (type == PCI_HEADER_TYPE_BRIDGE) { 2456 uint8_t subordinate = dev->config[PCI_SUBORDINATE_BUS]; 2457 if (subordinate > max_bus) { 2458 max_bus = subordinate; 2459 } 2460 2461 range_base = pci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_IO); 2462 range_limit = pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_IO); 2463 2464 /* 2465 * Work-around for old bioses 2466 * that do not support multiple root buses 2467 */ 2468 if (range_base && range_base <= range_limit) { 2469 crs_range_insert(temp_range_set.io_ranges, 2470 range_base, range_limit); 2471 } 2472 2473 range_base = 2474 pci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_MEMORY); 2475 range_limit = 2476 pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_MEMORY); 2477 2478 /* 2479 * Work-around for old bioses 2480 * that do not support multiple root buses 2481 */ 2482 if (range_base && range_base <= range_limit) { 2483 uint64_t length = range_limit - range_base + 1; 2484 if (range_limit <= UINT32_MAX && length <= UINT32_MAX) { 2485 crs_range_insert(temp_range_set.mem_ranges, 2486 range_base, range_limit); 2487 } else { 2488 crs_range_insert(temp_range_set.mem_64bit_ranges, 2489 range_base, range_limit); 2490 } 2491 } 2492 2493 range_base = 2494 pci_bridge_get_base(dev, PCI_BASE_ADDRESS_MEM_PREFETCH); 2495 range_limit = 2496 pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_MEM_PREFETCH); 2497 2498 /* 2499 * Work-around for old bioses 2500 * that do not support multiple root buses 2501 */ 2502 if (range_base && range_base <= range_limit) { 2503 uint64_t length = range_limit - range_base + 1; 2504 if (range_limit <= UINT32_MAX && length <= UINT32_MAX) { 2505 crs_range_insert(temp_range_set.mem_ranges, 2506 range_base, range_limit); 2507 } else { 2508 crs_range_insert(temp_range_set.mem_64bit_ranges, 2509 range_base, range_limit); 2510 } 2511 } 2512 } 2513 } 2514 2515 crs_range_merge(temp_range_set.io_ranges); 2516 for (i = 0; i < temp_range_set.io_ranges->len; i++) { 2517 entry = g_ptr_array_index(temp_range_set.io_ranges, i); 2518 aml_append(crs, 2519 aml_dword_io(AML_MIN_FIXED, AML_MAX_FIXED, 2520 AML_POS_DECODE, AML_ENTIRE_RANGE, 2521 0, entry->base, entry->limit, io_offset, 2522 entry->limit - entry->base + 1)); 2523 crs_range_insert(range_set->io_ranges, entry->base, entry->limit); 2524 } 2525 2526 crs_range_merge(temp_range_set.mem_ranges); 2527 for (i = 0; i < temp_range_set.mem_ranges->len; i++) { 2528 entry = g_ptr_array_index(temp_range_set.mem_ranges, i); 2529 assert(entry->limit <= UINT32_MAX && 2530 (entry->limit - entry->base + 1) <= UINT32_MAX); 2531 aml_append(crs, 2532 aml_dword_memory(AML_POS_DECODE, AML_MIN_FIXED, 2533 AML_MAX_FIXED, AML_NON_CACHEABLE, 2534 AML_READ_WRITE, 2535 0, entry->base, entry->limit, mmio32_offset, 2536 entry->limit - entry->base + 1)); 2537 crs_range_insert(range_set->mem_ranges, entry->base, entry->limit); 2538 } 2539 2540 crs_range_merge(temp_range_set.mem_64bit_ranges); 2541 for (i = 0; i < temp_range_set.mem_64bit_ranges->len; i++) { 2542 entry = g_ptr_array_index(temp_range_set.mem_64bit_ranges, i); 2543 aml_append(crs, 2544 aml_qword_memory(AML_POS_DECODE, AML_MIN_FIXED, 2545 AML_MAX_FIXED, AML_NON_CACHEABLE, 2546 AML_READ_WRITE, 2547 0, entry->base, entry->limit, mmio64_offset, 2548 entry->limit - entry->base + 1)); 2549 crs_range_insert(range_set->mem_64bit_ranges, 2550 entry->base, entry->limit); 2551 } 2552 2553 crs_range_set_free(&temp_range_set); 2554 2555 aml_append(crs, 2556 aml_word_bus_number(AML_MIN_FIXED, AML_MAX_FIXED, AML_POS_DECODE, 2557 0, 2558 pci_bus_num(host->bus), 2559 max_bus, 2560 bus_nr_offset, 2561 max_bus - pci_bus_num(host->bus) + 1)); 2562 2563 return crs; 2564 } 2565 2566 /* ACPI 5.0: 6.4.3.8.2 Serial Bus Connection Descriptors */ 2567 static Aml *aml_serial_bus_device(uint8_t serial_bus_type, uint8_t flags, 2568 uint16_t type_flags, 2569 uint8_t revid, uint16_t data_length, 2570 uint16_t resource_source_len) 2571 { 2572 Aml *var = aml_alloc(); 2573 uint16_t length = data_length + resource_source_len + 9; 2574 2575 build_append_byte(var->buf, 0x8e); /* Serial Bus Connection Descriptor */ 2576 build_append_int_noprefix(var->buf, length, sizeof(length)); 2577 build_append_byte(var->buf, 1); /* Revision ID */ 2578 build_append_byte(var->buf, 0); /* Resource Source Index */ 2579 build_append_byte(var->buf, serial_bus_type); /* Serial Bus Type */ 2580 build_append_byte(var->buf, flags); /* General Flags */ 2581 build_append_int_noprefix(var->buf, type_flags, /* Type Specific Flags */ 2582 sizeof(type_flags)); 2583 build_append_byte(var->buf, revid); /* Type Specification Revision ID */ 2584 build_append_int_noprefix(var->buf, data_length, sizeof(data_length)); 2585 2586 return var; 2587 } 2588 2589 /* ACPI 5.0: 6.4.3.8.2.1 I2C Serial Bus Connection Resource Descriptor */ 2590 Aml *aml_i2c_serial_bus_device(uint16_t address, const char *resource_source) 2591 { 2592 uint16_t resource_source_len = strlen(resource_source) + 1; 2593 Aml *var = aml_serial_bus_device(AML_SERIAL_BUS_TYPE_I2C, 0, 0, 1, 2594 6, resource_source_len); 2595 2596 /* Connection Speed. Just set to 100K for now, it doesn't really matter. */ 2597 build_append_int_noprefix(var->buf, 100000, 4); 2598 build_append_int_noprefix(var->buf, address, sizeof(address)); 2599 2600 /* This is a string, not a name, so just copy it directly in. */ 2601 g_array_append_vals(var->buf, resource_source, resource_source_len); 2602 2603 return var; 2604 } 2605