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 assert(0); 538 break; 539 } 540 build_append_array(parent_ctx->buf, buf); 541 build_free_array(buf); 542 } 543 544 /* ACPI 1.0b: 16.2.5.1 Namespace Modifier Objects Encoding: DefScope */ 545 Aml *aml_scope(const char *name_format, ...) 546 { 547 va_list ap; 548 Aml *var = aml_bundle(0x10 /* ScopeOp */, AML_PACKAGE); 549 va_start(ap, name_format); 550 build_append_namestringv(var->buf, name_format, ap); 551 va_end(ap); 552 return var; 553 } 554 555 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefReturn */ 556 Aml *aml_return(Aml *val) 557 { 558 Aml *var = aml_opcode(0xA4 /* ReturnOp */); 559 aml_append(var, val); 560 return var; 561 } 562 563 /* ACPI 1.0b: 16.2.6.3 Debug Objects Encoding: DebugObj */ 564 Aml *aml_debug(void) 565 { 566 Aml *var = aml_alloc(); 567 build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */ 568 build_append_byte(var->buf, 0x31); /* DebugOp */ 569 return var; 570 } 571 572 /* 573 * ACPI 1.0b: 16.2.3 Data Objects Encoding: 574 * encodes: ByteConst, WordConst, DWordConst, QWordConst, ZeroOp, OneOp 575 */ 576 Aml *aml_int(const uint64_t val) 577 { 578 Aml *var = aml_alloc(); 579 build_append_int(var->buf, val); 580 return var; 581 } 582 583 /* 584 * helper to construct NameString, which returns Aml object 585 * for using with aml_append or other aml_* terms 586 */ 587 Aml *aml_name(const char *name_format, ...) 588 { 589 va_list ap; 590 Aml *var = aml_alloc(); 591 va_start(ap, name_format); 592 build_append_namestringv(var->buf, name_format, ap); 593 va_end(ap); 594 return var; 595 } 596 597 /* ACPI 1.0b: 16.2.5.1 Namespace Modifier Objects Encoding: DefName */ 598 Aml *aml_name_decl(const char *name, Aml *val) 599 { 600 Aml *var = aml_opcode(0x08 /* NameOp */); 601 build_append_namestring(var->buf, "%s", name); 602 aml_append(var, val); 603 return var; 604 } 605 606 /* ACPI 1.0b: 16.2.6.1 Arg Objects Encoding */ 607 Aml *aml_arg(int pos) 608 { 609 uint8_t op = 0x68 /* ARG0 op */ + pos; 610 611 assert(pos <= 6); 612 return aml_opcode(op); 613 } 614 615 /* ACPI 2.0a: 17.2.4.4 Type 2 Opcodes Encoding: DefToInteger */ 616 Aml *aml_to_integer(Aml *arg) 617 { 618 Aml *var = aml_opcode(0x99 /* ToIntegerOp */); 619 aml_append(var, arg); 620 build_append_byte(var->buf, 0x00 /* NullNameOp */); 621 return var; 622 } 623 624 /* ACPI 2.0a: 17.2.4.4 Type 2 Opcodes Encoding: DefToHexString */ 625 Aml *aml_to_hexstring(Aml *src, Aml *dst) 626 { 627 Aml *var = aml_opcode(0x98 /* ToHexStringOp */); 628 aml_append(var, src); 629 if (dst) { 630 aml_append(var, dst); 631 } else { 632 build_append_byte(var->buf, 0x00 /* NullNameOp */); 633 } 634 return var; 635 } 636 637 /* ACPI 2.0a: 17.2.4.4 Type 2 Opcodes Encoding: DefToBuffer */ 638 Aml *aml_to_buffer(Aml *src, Aml *dst) 639 { 640 Aml *var = aml_opcode(0x96 /* ToBufferOp */); 641 aml_append(var, src); 642 if (dst) { 643 aml_append(var, dst); 644 } else { 645 build_append_byte(var->buf, 0x00 /* NullNameOp */); 646 } 647 return var; 648 } 649 650 /* ACPI 2.0a: 17.2.4.4 Type 2 Opcodes Encoding: DefToDecimalString */ 651 Aml *aml_to_decimalstring(Aml *src, Aml *dst) 652 { 653 Aml *var = aml_opcode(0x97 /* ToDecimalStringOp */); 654 aml_append(var, src); 655 if (dst) { 656 aml_append(var, dst); 657 } else { 658 build_append_byte(var->buf, 0x00 /* NullNameOp */); 659 } 660 return var; 661 } 662 663 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefStore */ 664 Aml *aml_store(Aml *val, Aml *target) 665 { 666 Aml *var = aml_opcode(0x70 /* StoreOp */); 667 aml_append(var, val); 668 aml_append(var, target); 669 return var; 670 } 671 672 /** 673 * build_opcode_2arg_dst: 674 * @op: 1-byte opcode 675 * @arg1: 1st operand 676 * @arg2: 2nd operand 677 * @dst: optional target to store to, set to NULL if it's not required 678 * 679 * An internal helper to compose AML terms that have 680 * "Op Operand Operand Target" 681 * pattern. 682 * 683 * Returns: The newly allocated and composed according to pattern Aml object. 684 */ 685 static Aml * 686 build_opcode_2arg_dst(uint8_t op, Aml *arg1, Aml *arg2, Aml *dst) 687 { 688 Aml *var = aml_opcode(op); 689 aml_append(var, arg1); 690 aml_append(var, arg2); 691 if (dst) { 692 aml_append(var, dst); 693 } else { 694 build_append_byte(var->buf, 0x00 /* NullNameOp */); 695 } 696 return var; 697 } 698 699 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefAnd */ 700 Aml *aml_and(Aml *arg1, Aml *arg2, Aml *dst) 701 { 702 return build_opcode_2arg_dst(0x7B /* AndOp */, arg1, arg2, dst); 703 } 704 705 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefOr */ 706 Aml *aml_or(Aml *arg1, Aml *arg2, Aml *dst) 707 { 708 return build_opcode_2arg_dst(0x7D /* OrOp */, arg1, arg2, dst); 709 } 710 711 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLAnd */ 712 Aml *aml_land(Aml *arg1, Aml *arg2) 713 { 714 Aml *var = aml_opcode(0x90 /* LAndOp */); 715 aml_append(var, arg1); 716 aml_append(var, arg2); 717 return var; 718 } 719 720 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLOr */ 721 Aml *aml_lor(Aml *arg1, Aml *arg2) 722 { 723 Aml *var = aml_opcode(0x91 /* LOrOp */); 724 aml_append(var, arg1); 725 aml_append(var, arg2); 726 return var; 727 } 728 729 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefShiftLeft */ 730 Aml *aml_shiftleft(Aml *arg1, Aml *count) 731 { 732 return build_opcode_2arg_dst(0x79 /* ShiftLeftOp */, arg1, count, NULL); 733 } 734 735 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefShiftRight */ 736 Aml *aml_shiftright(Aml *arg1, Aml *count, Aml *dst) 737 { 738 return build_opcode_2arg_dst(0x7A /* ShiftRightOp */, arg1, count, dst); 739 } 740 741 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLLess */ 742 Aml *aml_lless(Aml *arg1, Aml *arg2) 743 { 744 Aml *var = aml_opcode(0x95 /* LLessOp */); 745 aml_append(var, arg1); 746 aml_append(var, arg2); 747 return var; 748 } 749 750 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefAdd */ 751 Aml *aml_add(Aml *arg1, Aml *arg2, Aml *dst) 752 { 753 return build_opcode_2arg_dst(0x72 /* AddOp */, arg1, arg2, dst); 754 } 755 756 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefSubtract */ 757 Aml *aml_subtract(Aml *arg1, Aml *arg2, Aml *dst) 758 { 759 return build_opcode_2arg_dst(0x74 /* SubtractOp */, arg1, arg2, dst); 760 } 761 762 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefIncrement */ 763 Aml *aml_increment(Aml *arg) 764 { 765 Aml *var = aml_opcode(0x75 /* IncrementOp */); 766 aml_append(var, arg); 767 return var; 768 } 769 770 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefDecrement */ 771 Aml *aml_decrement(Aml *arg) 772 { 773 Aml *var = aml_opcode(0x76 /* DecrementOp */); 774 aml_append(var, arg); 775 return var; 776 } 777 778 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefIndex */ 779 Aml *aml_index(Aml *arg1, Aml *idx) 780 { 781 return build_opcode_2arg_dst(0x88 /* IndexOp */, arg1, idx, NULL); 782 } 783 784 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefNotify */ 785 Aml *aml_notify(Aml *arg1, Aml *arg2) 786 { 787 Aml *var = aml_opcode(0x86 /* NotifyOp */); 788 aml_append(var, arg1); 789 aml_append(var, arg2); 790 return var; 791 } 792 793 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefBreak */ 794 Aml *aml_break(void) 795 { 796 Aml *var = aml_opcode(0xa5 /* BreakOp */); 797 return var; 798 } 799 800 /* helper to call method without argument */ 801 Aml *aml_call0(const char *method) 802 { 803 Aml *var = aml_alloc(); 804 build_append_namestring(var->buf, "%s", method); 805 return var; 806 } 807 808 /* helper to call method with 1 argument */ 809 Aml *aml_call1(const char *method, Aml *arg1) 810 { 811 Aml *var = aml_alloc(); 812 build_append_namestring(var->buf, "%s", method); 813 aml_append(var, arg1); 814 return var; 815 } 816 817 /* helper to call method with 2 arguments */ 818 Aml *aml_call2(const char *method, Aml *arg1, Aml *arg2) 819 { 820 Aml *var = aml_alloc(); 821 build_append_namestring(var->buf, "%s", method); 822 aml_append(var, arg1); 823 aml_append(var, arg2); 824 return var; 825 } 826 827 /* helper to call method with 3 arguments */ 828 Aml *aml_call3(const char *method, Aml *arg1, Aml *arg2, Aml *arg3) 829 { 830 Aml *var = aml_alloc(); 831 build_append_namestring(var->buf, "%s", method); 832 aml_append(var, arg1); 833 aml_append(var, arg2); 834 aml_append(var, arg3); 835 return var; 836 } 837 838 /* helper to call method with 4 arguments */ 839 Aml *aml_call4(const char *method, Aml *arg1, Aml *arg2, Aml *arg3, Aml *arg4) 840 { 841 Aml *var = aml_alloc(); 842 build_append_namestring(var->buf, "%s", method); 843 aml_append(var, arg1); 844 aml_append(var, arg2); 845 aml_append(var, arg3); 846 aml_append(var, arg4); 847 return var; 848 } 849 850 /* helper to call method with 5 arguments */ 851 Aml *aml_call5(const char *method, Aml *arg1, Aml *arg2, Aml *arg3, Aml *arg4, 852 Aml *arg5) 853 { 854 Aml *var = aml_alloc(); 855 build_append_namestring(var->buf, "%s", method); 856 aml_append(var, arg1); 857 aml_append(var, arg2); 858 aml_append(var, arg3); 859 aml_append(var, arg4); 860 aml_append(var, arg5); 861 return var; 862 } 863 864 /* helper to call method with 5 arguments */ 865 Aml *aml_call6(const char *method, Aml *arg1, Aml *arg2, Aml *arg3, Aml *arg4, 866 Aml *arg5, Aml *arg6) 867 { 868 Aml *var = aml_alloc(); 869 build_append_namestring(var->buf, "%s", method); 870 aml_append(var, arg1); 871 aml_append(var, arg2); 872 aml_append(var, arg3); 873 aml_append(var, arg4); 874 aml_append(var, arg5); 875 aml_append(var, arg6); 876 return var; 877 } 878 879 /* 880 * ACPI 5.0: 6.4.3.8.1 GPIO Connection Descriptor 881 * Type 1, Large Item Name 0xC 882 */ 883 884 static Aml *aml_gpio_connection(AmlGpioConnectionType type, 885 AmlConsumerAndProducer con_and_pro, 886 uint8_t flags, AmlPinConfig pin_config, 887 uint16_t output_drive, 888 uint16_t debounce_timeout, 889 const uint32_t pin_list[], uint32_t pin_count, 890 const char *resource_source_name, 891 const uint8_t *vendor_data, 892 uint16_t vendor_data_len) 893 { 894 Aml *var = aml_alloc(); 895 const uint16_t min_desc_len = 0x16; 896 uint16_t resource_source_name_len, length; 897 uint16_t pin_table_offset, resource_source_name_offset, vendor_data_offset; 898 uint32_t i; 899 900 assert(resource_source_name); 901 resource_source_name_len = strlen(resource_source_name) + 1; 902 length = min_desc_len + resource_source_name_len + vendor_data_len; 903 pin_table_offset = min_desc_len + 1; 904 resource_source_name_offset = pin_table_offset + pin_count * 2; 905 vendor_data_offset = resource_source_name_offset + resource_source_name_len; 906 907 build_append_byte(var->buf, 0x8C); /* GPIO Connection Descriptor */ 908 build_append_int_noprefix(var->buf, length, 2); /* Length */ 909 build_append_byte(var->buf, 1); /* Revision ID */ 910 build_append_byte(var->buf, type); /* GPIO Connection Type */ 911 /* General Flags (2 bytes) */ 912 build_append_int_noprefix(var->buf, con_and_pro, 2); 913 /* Interrupt and IO Flags (2 bytes) */ 914 build_append_int_noprefix(var->buf, flags, 2); 915 /* Pin Configuration 0 = Default 1 = Pull-up 2 = Pull-down 3 = No Pull */ 916 build_append_byte(var->buf, pin_config); 917 /* Output Drive Strength (2 bytes) */ 918 build_append_int_noprefix(var->buf, output_drive, 2); 919 /* Debounce Timeout (2 bytes) */ 920 build_append_int_noprefix(var->buf, debounce_timeout, 2); 921 /* Pin Table Offset (2 bytes) */ 922 build_append_int_noprefix(var->buf, pin_table_offset, 2); 923 build_append_byte(var->buf, 0); /* Resource Source Index */ 924 /* Resource Source Name Offset (2 bytes) */ 925 build_append_int_noprefix(var->buf, resource_source_name_offset, 2); 926 /* Vendor Data Offset (2 bytes) */ 927 build_append_int_noprefix(var->buf, vendor_data_offset, 2); 928 /* Vendor Data Length (2 bytes) */ 929 build_append_int_noprefix(var->buf, vendor_data_len, 2); 930 /* Pin Number (2n bytes)*/ 931 for (i = 0; i < pin_count; i++) { 932 build_append_int_noprefix(var->buf, pin_list[i], 2); 933 } 934 935 /* Resource Source Name */ 936 build_append_namestring(var->buf, "%s", resource_source_name); 937 build_append_byte(var->buf, '\0'); 938 939 /* Vendor-defined Data */ 940 if (vendor_data != NULL) { 941 g_array_append_vals(var->buf, vendor_data, vendor_data_len); 942 } 943 944 return var; 945 } 946 947 /* 948 * ACPI 5.0: 19.5.53 949 * GpioInt(GPIO Interrupt Connection Resource Descriptor Macro) 950 */ 951 Aml *aml_gpio_int(AmlConsumerAndProducer con_and_pro, 952 AmlLevelAndEdge edge_level, 953 AmlActiveHighAndLow active_level, AmlShared shared, 954 AmlPinConfig pin_config, uint16_t debounce_timeout, 955 const uint32_t pin_list[], uint32_t pin_count, 956 const char *resource_source_name, 957 const uint8_t *vendor_data, uint16_t vendor_data_len) 958 { 959 uint8_t flags = edge_level | (active_level << 1) | (shared << 3); 960 961 return aml_gpio_connection(AML_INTERRUPT_CONNECTION, con_and_pro, flags, 962 pin_config, 0, debounce_timeout, pin_list, 963 pin_count, resource_source_name, vendor_data, 964 vendor_data_len); 965 } 966 967 /* 968 * ACPI 1.0b: 6.4.3.4 32-Bit Fixed Location Memory Range Descriptor 969 * (Type 1, Large Item Name 0x6) 970 */ 971 Aml *aml_memory32_fixed(uint32_t addr, uint32_t size, 972 AmlReadAndWrite read_and_write) 973 { 974 Aml *var = aml_alloc(); 975 build_append_byte(var->buf, 0x86); /* Memory32Fixed Resource Descriptor */ 976 build_append_byte(var->buf, 9); /* Length, bits[7:0] value = 9 */ 977 build_append_byte(var->buf, 0); /* Length, bits[15:8] value = 0 */ 978 build_append_byte(var->buf, read_and_write); /* Write status, 1 rw 0 ro */ 979 980 /* Range base address */ 981 build_append_byte(var->buf, extract32(addr, 0, 8)); /* bits[7:0] */ 982 build_append_byte(var->buf, extract32(addr, 8, 8)); /* bits[15:8] */ 983 build_append_byte(var->buf, extract32(addr, 16, 8)); /* bits[23:16] */ 984 build_append_byte(var->buf, extract32(addr, 24, 8)); /* bits[31:24] */ 985 986 /* Range length */ 987 build_append_byte(var->buf, extract32(size, 0, 8)); /* bits[7:0] */ 988 build_append_byte(var->buf, extract32(size, 8, 8)); /* bits[15:8] */ 989 build_append_byte(var->buf, extract32(size, 16, 8)); /* bits[23:16] */ 990 build_append_byte(var->buf, extract32(size, 24, 8)); /* bits[31:24] */ 991 return var; 992 } 993 994 /* 995 * ACPI 5.0: 6.4.3.6 Extended Interrupt Descriptor 996 * Type 1, Large Item Name 0x9 997 */ 998 Aml *aml_interrupt(AmlConsumerAndProducer con_and_pro, 999 AmlLevelAndEdge level_and_edge, 1000 AmlActiveHighAndLow high_and_low, AmlShared shared, 1001 uint32_t *irq_list, uint8_t irq_count) 1002 { 1003 int i; 1004 Aml *var = aml_alloc(); 1005 uint8_t irq_flags = con_and_pro | (level_and_edge << 1) 1006 | (high_and_low << 2) | (shared << 3); 1007 const int header_bytes_in_len = 2; 1008 uint16_t len = header_bytes_in_len + irq_count * sizeof(uint32_t); 1009 1010 assert(irq_count > 0); 1011 1012 build_append_byte(var->buf, 0x89); /* Extended irq descriptor */ 1013 build_append_byte(var->buf, len & 0xFF); /* Length, bits[7:0] */ 1014 build_append_byte(var->buf, len >> 8); /* Length, bits[15:8] */ 1015 build_append_byte(var->buf, irq_flags); /* Interrupt Vector Information. */ 1016 build_append_byte(var->buf, irq_count); /* Interrupt table length */ 1017 1018 /* Interrupt Number List */ 1019 for (i = 0; i < irq_count; i++) { 1020 build_append_int_noprefix(var->buf, irq_list[i], 4); 1021 } 1022 return var; 1023 } 1024 1025 /* ACPI 1.0b: 6.4.2.5 I/O Port Descriptor */ 1026 Aml *aml_io(AmlIODecode dec, uint16_t min_base, uint16_t max_base, 1027 uint8_t aln, uint8_t len) 1028 { 1029 Aml *var = aml_alloc(); 1030 build_append_byte(var->buf, 0x47); /* IO port descriptor */ 1031 build_append_byte(var->buf, dec); 1032 build_append_byte(var->buf, min_base & 0xff); 1033 build_append_byte(var->buf, (min_base >> 8) & 0xff); 1034 build_append_byte(var->buf, max_base & 0xff); 1035 build_append_byte(var->buf, (max_base >> 8) & 0xff); 1036 build_append_byte(var->buf, aln); 1037 build_append_byte(var->buf, len); 1038 return var; 1039 } 1040 1041 /* 1042 * ACPI 1.0b: 6.4.2.1.1 ASL Macro for IRQ Descriptor 1043 * 1044 * More verbose description at: 1045 * ACPI 5.0: 19.5.64 IRQNoFlags (Interrupt Resource Descriptor Macro) 1046 * 6.4.2.1 IRQ Descriptor 1047 */ 1048 Aml *aml_irq_no_flags(uint8_t irq) 1049 { 1050 uint16_t irq_mask; 1051 Aml *var = aml_alloc(); 1052 1053 assert(irq < 16); 1054 build_append_byte(var->buf, 0x22); /* IRQ descriptor 2 byte form */ 1055 1056 irq_mask = 1U << irq; 1057 build_append_byte(var->buf, irq_mask & 0xFF); /* IRQ mask bits[7:0] */ 1058 build_append_byte(var->buf, irq_mask >> 8); /* IRQ mask bits[15:8] */ 1059 return var; 1060 } 1061 1062 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLNot */ 1063 Aml *aml_lnot(Aml *arg) 1064 { 1065 Aml *var = aml_opcode(0x92 /* LNotOp */); 1066 aml_append(var, arg); 1067 return var; 1068 } 1069 1070 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLEqual */ 1071 Aml *aml_equal(Aml *arg1, Aml *arg2) 1072 { 1073 Aml *var = aml_opcode(0x93 /* LequalOp */); 1074 aml_append(var, arg1); 1075 aml_append(var, arg2); 1076 return var; 1077 } 1078 1079 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLGreater */ 1080 Aml *aml_lgreater(Aml *arg1, Aml *arg2) 1081 { 1082 Aml *var = aml_opcode(0x94 /* LGreaterOp */); 1083 aml_append(var, arg1); 1084 aml_append(var, arg2); 1085 return var; 1086 } 1087 1088 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLGreaterEqual */ 1089 Aml *aml_lgreater_equal(Aml *arg1, Aml *arg2) 1090 { 1091 /* LGreaterEqualOp := LNotOp LLessOp */ 1092 Aml *var = aml_opcode(0x92 /* LNotOp */); 1093 build_append_byte(var->buf, 0x95 /* LLessOp */); 1094 aml_append(var, arg1); 1095 aml_append(var, arg2); 1096 return var; 1097 } 1098 1099 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefIfElse */ 1100 Aml *aml_if(Aml *predicate) 1101 { 1102 Aml *var = aml_bundle(0xA0 /* IfOp */, AML_PACKAGE); 1103 aml_append(var, predicate); 1104 return var; 1105 } 1106 1107 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefElse */ 1108 Aml *aml_else(void) 1109 { 1110 Aml *var = aml_bundle(0xA1 /* ElseOp */, AML_PACKAGE); 1111 return var; 1112 } 1113 1114 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefWhile */ 1115 Aml *aml_while(Aml *predicate) 1116 { 1117 Aml *var = aml_bundle(0xA2 /* WhileOp */, AML_PACKAGE); 1118 aml_append(var, predicate); 1119 return var; 1120 } 1121 1122 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefMethod */ 1123 Aml *aml_method(const char *name, int arg_count, AmlSerializeFlag sflag) 1124 { 1125 Aml *var = aml_bundle(0x14 /* MethodOp */, AML_PACKAGE); 1126 int methodflags; 1127 1128 /* 1129 * MethodFlags: 1130 * bit 0-2: ArgCount (0-7) 1131 * bit 3: SerializeFlag 1132 * 0: NotSerialized 1133 * 1: Serialized 1134 * bit 4-7: reserved (must be 0) 1135 */ 1136 assert(arg_count < 8); 1137 methodflags = arg_count | (sflag << 3); 1138 1139 build_append_namestring(var->buf, "%s", name); 1140 build_append_byte(var->buf, methodflags); /* MethodFlags: ArgCount */ 1141 return var; 1142 } 1143 1144 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefDevice */ 1145 Aml *aml_device(const char *name_format, ...) 1146 { 1147 va_list ap; 1148 Aml *var = aml_bundle(0x82 /* DeviceOp */, AML_EXT_PACKAGE); 1149 va_start(ap, name_format); 1150 build_append_namestringv(var->buf, name_format, ap); 1151 va_end(ap); 1152 return var; 1153 } 1154 1155 /* ACPI 1.0b: 6.4.1 ASL Macros for Resource Descriptors */ 1156 Aml *aml_resource_template(void) 1157 { 1158 /* ResourceTemplate is a buffer of Resources with EndTag at the end */ 1159 Aml *var = aml_bundle(0x11 /* BufferOp */, AML_RES_TEMPLATE); 1160 return var; 1161 } 1162 1163 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefBuffer 1164 * Pass byte_list as NULL to request uninitialized buffer to reserve space. 1165 */ 1166 Aml *aml_buffer(int buffer_size, uint8_t *byte_list) 1167 { 1168 int i; 1169 Aml *var = aml_bundle(0x11 /* BufferOp */, AML_BUFFER); 1170 1171 for (i = 0; i < buffer_size; i++) { 1172 if (byte_list == NULL) { 1173 build_append_byte(var->buf, 0x0); 1174 } else { 1175 build_append_byte(var->buf, byte_list[i]); 1176 } 1177 } 1178 1179 return var; 1180 } 1181 1182 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefPackage */ 1183 Aml *aml_package(uint8_t num_elements) 1184 { 1185 Aml *var = aml_bundle(0x12 /* PackageOp */, AML_PACKAGE); 1186 build_append_byte(var->buf, num_elements); 1187 return var; 1188 } 1189 1190 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefOpRegion */ 1191 Aml *aml_operation_region(const char *name, AmlRegionSpace rs, 1192 Aml *offset, uint32_t len) 1193 { 1194 Aml *var = aml_alloc(); 1195 build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */ 1196 build_append_byte(var->buf, 0x80); /* OpRegionOp */ 1197 build_append_namestring(var->buf, "%s", name); 1198 build_append_byte(var->buf, rs); 1199 aml_append(var, offset); 1200 build_append_int(var->buf, len); 1201 return var; 1202 } 1203 1204 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: NamedField */ 1205 Aml *aml_named_field(const char *name, unsigned length) 1206 { 1207 Aml *var = aml_alloc(); 1208 build_append_nameseg(var->buf, name); 1209 build_append_pkg_length(var->buf, length, false); 1210 return var; 1211 } 1212 1213 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: ReservedField */ 1214 Aml *aml_reserved_field(unsigned length) 1215 { 1216 Aml *var = aml_alloc(); 1217 /* ReservedField := 0x00 PkgLength */ 1218 build_append_byte(var->buf, 0x00); 1219 build_append_pkg_length(var->buf, length, false); 1220 return var; 1221 } 1222 1223 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefField */ 1224 Aml *aml_field(const char *name, AmlAccessType type, AmlLockRule lock, 1225 AmlUpdateRule rule) 1226 { 1227 Aml *var = aml_bundle(0x81 /* FieldOp */, AML_EXT_PACKAGE); 1228 uint8_t flags = rule << 5 | type; 1229 1230 flags |= lock << 4; /* LockRule at 4 bit offset */ 1231 1232 build_append_namestring(var->buf, "%s", name); 1233 build_append_byte(var->buf, flags); 1234 return var; 1235 } 1236 1237 static 1238 Aml *create_field_common(int opcode, Aml *srcbuf, Aml *index, const char *name) 1239 { 1240 Aml *var = aml_opcode(opcode); 1241 aml_append(var, srcbuf); 1242 aml_append(var, index); 1243 build_append_namestring(var->buf, "%s", name); 1244 return var; 1245 } 1246 1247 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefCreateField */ 1248 Aml *aml_create_field(Aml *srcbuf, Aml *bit_index, Aml *num_bits, 1249 const char *name) 1250 { 1251 Aml *var = aml_alloc(); 1252 build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */ 1253 build_append_byte(var->buf, 0x13); /* CreateFieldOp */ 1254 aml_append(var, srcbuf); 1255 aml_append(var, bit_index); 1256 aml_append(var, num_bits); 1257 build_append_namestring(var->buf, "%s", name); 1258 return var; 1259 } 1260 1261 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefCreateDWordField */ 1262 Aml *aml_create_dword_field(Aml *srcbuf, Aml *index, const char *name) 1263 { 1264 return create_field_common(0x8A /* CreateDWordFieldOp */, 1265 srcbuf, index, name); 1266 } 1267 1268 /* ACPI 2.0a: 17.2.4.2 Named Objects Encoding: DefCreateQWordField */ 1269 Aml *aml_create_qword_field(Aml *srcbuf, Aml *index, const char *name) 1270 { 1271 return create_field_common(0x8F /* CreateQWordFieldOp */, 1272 srcbuf, index, name); 1273 } 1274 1275 /* ACPI 1.0b: 16.2.3 Data Objects Encoding: String */ 1276 Aml *aml_string(const char *name_format, ...) 1277 { 1278 Aml *var = aml_opcode(0x0D /* StringPrefix */); 1279 va_list ap; 1280 char *s; 1281 int len; 1282 1283 va_start(ap, name_format); 1284 len = g_vasprintf(&s, name_format, ap); 1285 va_end(ap); 1286 1287 g_array_append_vals(var->buf, s, len + 1); 1288 g_free(s); 1289 1290 return var; 1291 } 1292 1293 /* ACPI 1.0b: 16.2.6.2 Local Objects Encoding */ 1294 Aml *aml_local(int num) 1295 { 1296 uint8_t op = 0x60 /* Local0Op */ + num; 1297 1298 assert(num <= 7); 1299 return aml_opcode(op); 1300 } 1301 1302 /* ACPI 2.0a: 17.2.2 Data Objects Encoding: DefVarPackage */ 1303 Aml *aml_varpackage(uint32_t num_elements) 1304 { 1305 Aml *var = aml_bundle(0x13 /* VarPackageOp */, AML_PACKAGE); 1306 build_append_int(var->buf, num_elements); 1307 return var; 1308 } 1309 1310 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefProcessor */ 1311 Aml *aml_processor(uint8_t proc_id, uint32_t pblk_addr, uint8_t pblk_len, 1312 const char *name_format, ...) 1313 { 1314 va_list ap; 1315 Aml *var = aml_bundle(0x83 /* ProcessorOp */, AML_EXT_PACKAGE); 1316 va_start(ap, name_format); 1317 build_append_namestringv(var->buf, name_format, ap); 1318 va_end(ap); 1319 build_append_byte(var->buf, proc_id); /* ProcID */ 1320 build_append_int_noprefix(var->buf, pblk_addr, sizeof(pblk_addr)); 1321 build_append_byte(var->buf, pblk_len); /* PblkLen */ 1322 return var; 1323 } 1324 1325 static uint8_t Hex2Digit(char c) 1326 { 1327 if (c >= 'A') { 1328 return c - 'A' + 10; 1329 } 1330 1331 return c - '0'; 1332 } 1333 1334 /* ACPI 1.0b: 15.2.3.6.4.1 EISAID Macro - Convert EISA ID String To Integer */ 1335 Aml *aml_eisaid(const char *str) 1336 { 1337 Aml *var = aml_alloc(); 1338 uint32_t id; 1339 1340 g_assert(strlen(str) == 7); 1341 id = (str[0] - 0x40) << 26 | 1342 (str[1] - 0x40) << 21 | 1343 (str[2] - 0x40) << 16 | 1344 Hex2Digit(str[3]) << 12 | 1345 Hex2Digit(str[4]) << 8 | 1346 Hex2Digit(str[5]) << 4 | 1347 Hex2Digit(str[6]); 1348 1349 build_append_byte(var->buf, 0x0C); /* DWordPrefix */ 1350 build_append_int_noprefix(var->buf, bswap32(id), sizeof(id)); 1351 return var; 1352 } 1353 1354 /* ACPI 1.0b: 6.4.3.5.5 Word Address Space Descriptor: bytes 3-5 */ 1355 static Aml *aml_as_desc_header(AmlResourceType type, AmlMinFixed min_fixed, 1356 AmlMaxFixed max_fixed, AmlDecode dec, 1357 uint8_t type_flags) 1358 { 1359 uint8_t flags = max_fixed | min_fixed | dec; 1360 Aml *var = aml_alloc(); 1361 1362 build_append_byte(var->buf, type); 1363 build_append_byte(var->buf, flags); 1364 build_append_byte(var->buf, type_flags); /* Type Specific Flags */ 1365 return var; 1366 } 1367 1368 /* ACPI 1.0b: 6.4.3.5.5 Word Address Space Descriptor */ 1369 static Aml *aml_word_as_desc(AmlResourceType type, AmlMinFixed min_fixed, 1370 AmlMaxFixed max_fixed, AmlDecode dec, 1371 uint16_t addr_gran, uint16_t addr_min, 1372 uint16_t addr_max, uint16_t addr_trans, 1373 uint16_t len, uint8_t type_flags) 1374 { 1375 Aml *var = aml_alloc(); 1376 1377 build_append_byte(var->buf, 0x88); /* Word Address Space Descriptor */ 1378 /* minimum length since we do not encode optional fields */ 1379 build_append_byte(var->buf, 0x0D); 1380 build_append_byte(var->buf, 0x0); 1381 1382 aml_append(var, 1383 aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags)); 1384 build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran)); 1385 build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min)); 1386 build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max)); 1387 build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans)); 1388 build_append_int_noprefix(var->buf, len, sizeof(len)); 1389 return var; 1390 } 1391 1392 /* ACPI 1.0b: 6.4.3.5.3 DWord Address Space Descriptor */ 1393 static Aml *aml_dword_as_desc(AmlResourceType type, AmlMinFixed min_fixed, 1394 AmlMaxFixed max_fixed, AmlDecode dec, 1395 uint32_t addr_gran, uint32_t addr_min, 1396 uint32_t addr_max, uint32_t addr_trans, 1397 uint32_t len, uint8_t type_flags) 1398 { 1399 Aml *var = aml_alloc(); 1400 1401 build_append_byte(var->buf, 0x87); /* DWord Address Space Descriptor */ 1402 /* minimum length since we do not encode optional fields */ 1403 build_append_byte(var->buf, 23); 1404 build_append_byte(var->buf, 0x0); 1405 1406 1407 aml_append(var, 1408 aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags)); 1409 build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran)); 1410 build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min)); 1411 build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max)); 1412 build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans)); 1413 build_append_int_noprefix(var->buf, len, sizeof(len)); 1414 return var; 1415 } 1416 1417 /* ACPI 1.0b: 6.4.3.5.1 QWord Address Space Descriptor */ 1418 static Aml *aml_qword_as_desc(AmlResourceType type, AmlMinFixed min_fixed, 1419 AmlMaxFixed max_fixed, AmlDecode dec, 1420 uint64_t addr_gran, uint64_t addr_min, 1421 uint64_t addr_max, uint64_t addr_trans, 1422 uint64_t len, uint8_t type_flags) 1423 { 1424 Aml *var = aml_alloc(); 1425 1426 build_append_byte(var->buf, 0x8A); /* QWord Address Space Descriptor */ 1427 /* minimum length since we do not encode optional fields */ 1428 build_append_byte(var->buf, 0x2B); 1429 build_append_byte(var->buf, 0x0); 1430 1431 aml_append(var, 1432 aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags)); 1433 build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran)); 1434 build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min)); 1435 build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max)); 1436 build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans)); 1437 build_append_int_noprefix(var->buf, len, sizeof(len)); 1438 return var; 1439 } 1440 1441 /* 1442 * ACPI 1.0b: 6.4.3.5.6 ASL Macros for WORD Address Descriptor 1443 * 1444 * More verbose description at: 1445 * ACPI 5.0: 19.5.141 WordBusNumber (Word Bus Number Resource Descriptor Macro) 1446 */ 1447 Aml *aml_word_bus_number(AmlMinFixed min_fixed, AmlMaxFixed max_fixed, 1448 AmlDecode dec, uint16_t addr_gran, 1449 uint16_t addr_min, uint16_t addr_max, 1450 uint16_t addr_trans, uint16_t len) 1451 1452 { 1453 return aml_word_as_desc(AML_BUS_NUMBER_RANGE, min_fixed, max_fixed, dec, 1454 addr_gran, addr_min, addr_max, addr_trans, len, 0); 1455 } 1456 1457 /* 1458 * ACPI 1.0b: 6.4.3.5.6 ASL Macros for WORD Address Descriptor 1459 * 1460 * More verbose description at: 1461 * ACPI 5.0: 19.5.142 WordIO (Word IO Resource Descriptor Macro) 1462 */ 1463 Aml *aml_word_io(AmlMinFixed min_fixed, AmlMaxFixed max_fixed, 1464 AmlDecode dec, AmlISARanges isa_ranges, 1465 uint16_t addr_gran, uint16_t addr_min, 1466 uint16_t addr_max, uint16_t addr_trans, 1467 uint16_t len) 1468 1469 { 1470 return aml_word_as_desc(AML_IO_RANGE, min_fixed, max_fixed, dec, 1471 addr_gran, addr_min, addr_max, addr_trans, len, 1472 isa_ranges); 1473 } 1474 1475 /* 1476 * ACPI 1.0b: 6.4.3.5.4 ASL Macros for DWORD Address Descriptor 1477 * 1478 * More verbose description at: 1479 * ACPI 5.0: 19.5.33 DWordIO (DWord IO Resource Descriptor Macro) 1480 */ 1481 Aml *aml_dword_io(AmlMinFixed min_fixed, AmlMaxFixed max_fixed, 1482 AmlDecode dec, AmlISARanges isa_ranges, 1483 uint32_t addr_gran, uint32_t addr_min, 1484 uint32_t addr_max, uint32_t addr_trans, 1485 uint32_t len) 1486 1487 { 1488 return aml_dword_as_desc(AML_IO_RANGE, min_fixed, max_fixed, dec, 1489 addr_gran, addr_min, addr_max, addr_trans, len, 1490 isa_ranges); 1491 } 1492 1493 /* 1494 * ACPI 1.0b: 6.4.3.5.4 ASL Macros for DWORD Address Space Descriptor 1495 * 1496 * More verbose description at: 1497 * ACPI 5.0: 19.5.34 DWordMemory (DWord Memory Resource Descriptor Macro) 1498 */ 1499 Aml *aml_dword_memory(AmlDecode dec, AmlMinFixed min_fixed, 1500 AmlMaxFixed max_fixed, AmlCacheable cacheable, 1501 AmlReadAndWrite read_and_write, 1502 uint32_t addr_gran, uint32_t addr_min, 1503 uint32_t addr_max, uint32_t addr_trans, 1504 uint32_t len) 1505 { 1506 uint8_t flags = read_and_write | (cacheable << 1); 1507 1508 return aml_dword_as_desc(AML_MEMORY_RANGE, min_fixed, max_fixed, 1509 dec, addr_gran, addr_min, addr_max, 1510 addr_trans, len, flags); 1511 } 1512 1513 /* 1514 * ACPI 1.0b: 6.4.3.5.2 ASL Macros for QWORD Address Space Descriptor 1515 * 1516 * More verbose description at: 1517 * ACPI 5.0: 19.5.102 QWordMemory (QWord Memory Resource Descriptor Macro) 1518 */ 1519 Aml *aml_qword_memory(AmlDecode dec, AmlMinFixed min_fixed, 1520 AmlMaxFixed max_fixed, AmlCacheable cacheable, 1521 AmlReadAndWrite read_and_write, 1522 uint64_t addr_gran, uint64_t addr_min, 1523 uint64_t addr_max, uint64_t addr_trans, 1524 uint64_t len) 1525 { 1526 uint8_t flags = read_and_write | (cacheable << 1); 1527 1528 return aml_qword_as_desc(AML_MEMORY_RANGE, min_fixed, max_fixed, 1529 dec, addr_gran, addr_min, addr_max, 1530 addr_trans, len, flags); 1531 } 1532 1533 /* ACPI 1.0b: 6.4.2.2 DMA Format/6.4.2.2.1 ASL Macro for DMA Descriptor */ 1534 Aml *aml_dma(AmlDmaType typ, AmlDmaBusMaster bm, AmlTransferSize sz, 1535 uint8_t channel) 1536 { 1537 Aml *var = aml_alloc(); 1538 uint8_t flags = sz | bm << 2 | typ << 5; 1539 1540 assert(channel < 8); 1541 build_append_byte(var->buf, 0x2A); /* Byte 0: DMA Descriptor */ 1542 build_append_byte(var->buf, 1U << channel); /* Byte 1: _DMA - DmaChannel */ 1543 build_append_byte(var->buf, flags); /* Byte 2 */ 1544 return var; 1545 } 1546 1547 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefSleep */ 1548 Aml *aml_sleep(uint64_t msec) 1549 { 1550 Aml *var = aml_alloc(); 1551 build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */ 1552 build_append_byte(var->buf, 0x22); /* SleepOp */ 1553 aml_append(var, aml_int(msec)); 1554 return var; 1555 } 1556 1557 static uint8_t Hex2Byte(const char *src) 1558 { 1559 int hi, lo; 1560 1561 hi = Hex2Digit(src[0]); 1562 assert(hi >= 0); 1563 assert(hi <= 15); 1564 1565 lo = Hex2Digit(src[1]); 1566 assert(lo >= 0); 1567 assert(lo <= 15); 1568 return (hi << 4) | lo; 1569 } 1570 1571 /* 1572 * ACPI 3.0: 17.5.124 ToUUID (Convert String to UUID Macro) 1573 * e.g. UUID: aabbccdd-eeff-gghh-iijj-kkllmmnnoopp 1574 * call aml_touuid("aabbccdd-eeff-gghh-iijj-kkllmmnnoopp"); 1575 */ 1576 Aml *aml_touuid(const char *uuid) 1577 { 1578 Aml *var = aml_bundle(0x11 /* BufferOp */, AML_BUFFER); 1579 1580 assert(strlen(uuid) == 36); 1581 assert(uuid[8] == '-'); 1582 assert(uuid[13] == '-'); 1583 assert(uuid[18] == '-'); 1584 assert(uuid[23] == '-'); 1585 1586 build_append_byte(var->buf, Hex2Byte(uuid + 6)); /* dd - at offset 00 */ 1587 build_append_byte(var->buf, Hex2Byte(uuid + 4)); /* cc - at offset 01 */ 1588 build_append_byte(var->buf, Hex2Byte(uuid + 2)); /* bb - at offset 02 */ 1589 build_append_byte(var->buf, Hex2Byte(uuid + 0)); /* aa - at offset 03 */ 1590 1591 build_append_byte(var->buf, Hex2Byte(uuid + 11)); /* ff - at offset 04 */ 1592 build_append_byte(var->buf, Hex2Byte(uuid + 9)); /* ee - at offset 05 */ 1593 1594 build_append_byte(var->buf, Hex2Byte(uuid + 16)); /* hh - at offset 06 */ 1595 build_append_byte(var->buf, Hex2Byte(uuid + 14)); /* gg - at offset 07 */ 1596 1597 build_append_byte(var->buf, Hex2Byte(uuid + 19)); /* ii - at offset 08 */ 1598 build_append_byte(var->buf, Hex2Byte(uuid + 21)); /* jj - at offset 09 */ 1599 1600 build_append_byte(var->buf, Hex2Byte(uuid + 24)); /* kk - at offset 10 */ 1601 build_append_byte(var->buf, Hex2Byte(uuid + 26)); /* ll - at offset 11 */ 1602 build_append_byte(var->buf, Hex2Byte(uuid + 28)); /* mm - at offset 12 */ 1603 build_append_byte(var->buf, Hex2Byte(uuid + 30)); /* nn - at offset 13 */ 1604 build_append_byte(var->buf, Hex2Byte(uuid + 32)); /* oo - at offset 14 */ 1605 build_append_byte(var->buf, Hex2Byte(uuid + 34)); /* pp - at offset 15 */ 1606 1607 return var; 1608 } 1609 1610 /* 1611 * ACPI 2.0b: 16.2.3.6.4.3 Unicode Macro (Convert Ascii String To Unicode) 1612 */ 1613 Aml *aml_unicode(const char *str) 1614 { 1615 int i = 0; 1616 Aml *var = aml_bundle(0x11 /* BufferOp */, AML_BUFFER); 1617 1618 do { 1619 build_append_byte(var->buf, str[i]); 1620 build_append_byte(var->buf, 0); 1621 i++; 1622 } while (i <= strlen(str)); 1623 1624 return var; 1625 } 1626 1627 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefRefOf */ 1628 Aml *aml_refof(Aml *arg) 1629 { 1630 Aml *var = aml_opcode(0x71 /* RefOfOp */); 1631 aml_append(var, arg); 1632 return var; 1633 } 1634 1635 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefDerefOf */ 1636 Aml *aml_derefof(Aml *arg) 1637 { 1638 Aml *var = aml_opcode(0x83 /* DerefOfOp */); 1639 aml_append(var, arg); 1640 return var; 1641 } 1642 1643 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefSizeOf */ 1644 Aml *aml_sizeof(Aml *arg) 1645 { 1646 Aml *var = aml_opcode(0x87 /* SizeOfOp */); 1647 aml_append(var, arg); 1648 return var; 1649 } 1650 1651 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefMutex */ 1652 Aml *aml_mutex(const char *name, uint8_t sync_level) 1653 { 1654 Aml *var = aml_alloc(); 1655 build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */ 1656 build_append_byte(var->buf, 0x01); /* MutexOp */ 1657 build_append_namestring(var->buf, "%s", name); 1658 assert(!(sync_level & 0xF0)); 1659 build_append_byte(var->buf, sync_level); 1660 return var; 1661 } 1662 1663 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefAcquire */ 1664 Aml *aml_acquire(Aml *mutex, uint16_t timeout) 1665 { 1666 Aml *var = aml_alloc(); 1667 build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */ 1668 build_append_byte(var->buf, 0x23); /* AcquireOp */ 1669 aml_append(var, mutex); 1670 build_append_int_noprefix(var->buf, timeout, sizeof(timeout)); 1671 return var; 1672 } 1673 1674 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefRelease */ 1675 Aml *aml_release(Aml *mutex) 1676 { 1677 Aml *var = aml_alloc(); 1678 build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */ 1679 build_append_byte(var->buf, 0x27); /* ReleaseOp */ 1680 aml_append(var, mutex); 1681 return var; 1682 } 1683 1684 /* ACPI 1.0b: 16.2.5.1 Name Space Modifier Objects Encoding: DefAlias */ 1685 Aml *aml_alias(const char *source_object, const char *alias_object) 1686 { 1687 Aml *var = aml_opcode(0x06 /* AliasOp */); 1688 aml_append(var, aml_name("%s", source_object)); 1689 aml_append(var, aml_name("%s", alias_object)); 1690 return var; 1691 } 1692 1693 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefConcat */ 1694 Aml *aml_concatenate(Aml *source1, Aml *source2, Aml *target) 1695 { 1696 return build_opcode_2arg_dst(0x73 /* ConcatOp */, source1, source2, 1697 target); 1698 } 1699 1700 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefObjectType */ 1701 Aml *aml_object_type(Aml *object) 1702 { 1703 Aml *var = aml_opcode(0x8E /* ObjectTypeOp */); 1704 aml_append(var, object); 1705 return var; 1706 } 1707 1708 void acpi_table_begin(AcpiTable *desc, GArray *array) 1709 { 1710 1711 desc->array = array; 1712 desc->table_offset = array->len; 1713 1714 /* 1715 * ACPI spec 1.0b 1716 * 5.2.3 System Description Table Header 1717 */ 1718 g_assert(strlen(desc->sig) == 4); 1719 g_array_append_vals(array, desc->sig, 4); /* Signature */ 1720 /* 1721 * reserve space for Length field, which will be patched by 1722 * acpi_table_end() when the table creation is finished. 1723 */ 1724 build_append_int_noprefix(array, 0, 4); /* Length */ 1725 build_append_int_noprefix(array, desc->rev, 1); /* Revision */ 1726 build_append_int_noprefix(array, 0, 1); /* Checksum */ 1727 build_append_padded_str(array, desc->oem_id, 6, '\0'); /* OEMID */ 1728 /* OEM Table ID */ 1729 build_append_padded_str(array, desc->oem_table_id, 8, '\0'); 1730 build_append_int_noprefix(array, 1, 4); /* OEM Revision */ 1731 g_array_append_vals(array, ACPI_BUILD_APPNAME8, 4); /* Creator ID */ 1732 build_append_int_noprefix(array, 1, 4); /* Creator Revision */ 1733 } 1734 1735 void acpi_table_end(BIOSLinker *linker, AcpiTable *desc) 1736 { 1737 /* 1738 * ACPI spec 1.0b 1739 * 5.2.3 System Description Table Header 1740 * Table 5-2 DESCRIPTION_HEADER Fields 1741 */ 1742 const unsigned checksum_offset = 9; 1743 uint32_t table_len = desc->array->len - desc->table_offset; 1744 uint32_t table_len_le = cpu_to_le32(table_len); 1745 gchar *len_ptr = &desc->array->data[desc->table_offset + 4]; 1746 1747 /* patch "Length" field that has been reserved by acpi_table_begin() 1748 * to the actual length, i.e. accumulated table length from 1749 * acpi_table_begin() till acpi_table_end() 1750 */ 1751 memcpy(len_ptr, &table_len_le, sizeof table_len_le); 1752 1753 bios_linker_loader_add_checksum(linker, ACPI_BUILD_TABLE_FILE, 1754 desc->table_offset, table_len, desc->table_offset + checksum_offset); 1755 } 1756 1757 void *acpi_data_push(GArray *table_data, unsigned size) 1758 { 1759 unsigned off = table_data->len; 1760 g_array_set_size(table_data, off + size); 1761 return table_data->data + off; 1762 } 1763 1764 unsigned acpi_data_len(GArray *table) 1765 { 1766 assert(g_array_get_element_size(table) == 1); 1767 return table->len; 1768 } 1769 1770 void acpi_add_table(GArray *table_offsets, GArray *table_data) 1771 { 1772 uint32_t offset = table_data->len; 1773 g_array_append_val(table_offsets, offset); 1774 } 1775 1776 void acpi_build_tables_init(AcpiBuildTables *tables) 1777 { 1778 tables->rsdp = g_array_new(false, true /* clear */, 1); 1779 tables->table_data = g_array_new(false, true /* clear */, 1); 1780 tables->tcpalog = g_array_new(false, true /* clear */, 1); 1781 tables->vmgenid = g_array_new(false, true /* clear */, 1); 1782 tables->hardware_errors = g_array_new(false, true /* clear */, 1); 1783 tables->linker = bios_linker_loader_init(); 1784 } 1785 1786 void acpi_build_tables_cleanup(AcpiBuildTables *tables, bool mfre) 1787 { 1788 bios_linker_loader_cleanup(tables->linker); 1789 g_array_free(tables->rsdp, true); 1790 g_array_free(tables->table_data, true); 1791 g_array_free(tables->tcpalog, mfre); 1792 g_array_free(tables->vmgenid, mfre); 1793 g_array_free(tables->hardware_errors, mfre); 1794 } 1795 1796 /* 1797 * ACPI spec 5.2.5.3 Root System Description Pointer (RSDP). 1798 * (Revision 1.0 or later) 1799 */ 1800 void 1801 build_rsdp(GArray *tbl, BIOSLinker *linker, AcpiRsdpData *rsdp_data) 1802 { 1803 int tbl_off = tbl->len; /* Table offset in the RSDP file */ 1804 1805 switch (rsdp_data->revision) { 1806 case 0: 1807 /* With ACPI 1.0, we must have an RSDT pointer */ 1808 g_assert(rsdp_data->rsdt_tbl_offset); 1809 break; 1810 case 2: 1811 /* With ACPI 2.0+, we must have an XSDT pointer */ 1812 g_assert(rsdp_data->xsdt_tbl_offset); 1813 break; 1814 default: 1815 /* Only revisions 0 (ACPI 1.0) and 2 (ACPI 2.0+) are valid for RSDP */ 1816 g_assert_not_reached(); 1817 } 1818 1819 bios_linker_loader_alloc(linker, ACPI_BUILD_RSDP_FILE, tbl, 16, 1820 true /* fseg memory */); 1821 1822 g_array_append_vals(tbl, "RSD PTR ", 8); /* Signature */ 1823 build_append_int_noprefix(tbl, 0, 1); /* Checksum */ 1824 g_array_append_vals(tbl, rsdp_data->oem_id, 6); /* OEMID */ 1825 build_append_int_noprefix(tbl, rsdp_data->revision, 1); /* Revision */ 1826 build_append_int_noprefix(tbl, 0, 4); /* RsdtAddress */ 1827 if (rsdp_data->rsdt_tbl_offset) { 1828 /* RSDT address to be filled by guest linker */ 1829 bios_linker_loader_add_pointer(linker, ACPI_BUILD_RSDP_FILE, 1830 tbl_off + 16, 4, 1831 ACPI_BUILD_TABLE_FILE, 1832 *rsdp_data->rsdt_tbl_offset); 1833 } 1834 1835 /* Checksum to be filled by guest linker */ 1836 bios_linker_loader_add_checksum(linker, ACPI_BUILD_RSDP_FILE, 1837 tbl_off, 20, /* ACPI rev 1.0 RSDP size */ 1838 8); 1839 1840 if (rsdp_data->revision == 0) { 1841 /* ACPI 1.0 RSDP, we're done */ 1842 return; 1843 } 1844 1845 build_append_int_noprefix(tbl, 36, 4); /* Length */ 1846 1847 /* XSDT address to be filled by guest linker */ 1848 build_append_int_noprefix(tbl, 0, 8); /* XsdtAddress */ 1849 /* We already validated our xsdt pointer */ 1850 bios_linker_loader_add_pointer(linker, ACPI_BUILD_RSDP_FILE, 1851 tbl_off + 24, 8, 1852 ACPI_BUILD_TABLE_FILE, 1853 *rsdp_data->xsdt_tbl_offset); 1854 1855 build_append_int_noprefix(tbl, 0, 1); /* Extended Checksum */ 1856 build_append_int_noprefix(tbl, 0, 3); /* Reserved */ 1857 1858 /* Extended checksum to be filled by Guest linker */ 1859 bios_linker_loader_add_checksum(linker, ACPI_BUILD_RSDP_FILE, 1860 tbl_off, 36, /* ACPI rev 2.0 RSDP size */ 1861 32); 1862 } 1863 1864 /* 1865 * ACPI 1.0 Root System Description Table (RSDT) 1866 */ 1867 void 1868 build_rsdt(GArray *table_data, BIOSLinker *linker, GArray *table_offsets, 1869 const char *oem_id, const char *oem_table_id) 1870 { 1871 int i; 1872 AcpiTable table = { .sig = "RSDT", .rev = 1, 1873 .oem_id = oem_id, .oem_table_id = oem_table_id }; 1874 1875 acpi_table_begin(&table, table_data); 1876 for (i = 0; i < table_offsets->len; ++i) { 1877 uint32_t ref_tbl_offset = g_array_index(table_offsets, uint32_t, i); 1878 uint32_t rsdt_entry_offset = table.array->len; 1879 1880 /* reserve space for entry */ 1881 build_append_int_noprefix(table.array, 0, 4); 1882 1883 /* mark position of RSDT entry to be filled by Guest linker */ 1884 bios_linker_loader_add_pointer(linker, 1885 ACPI_BUILD_TABLE_FILE, rsdt_entry_offset, 4, 1886 ACPI_BUILD_TABLE_FILE, ref_tbl_offset); 1887 1888 } 1889 acpi_table_end(linker, &table); 1890 } 1891 1892 /* 1893 * ACPI 2.0 eXtended System Description Table (XSDT) 1894 */ 1895 void 1896 build_xsdt(GArray *table_data, BIOSLinker *linker, GArray *table_offsets, 1897 const char *oem_id, const char *oem_table_id) 1898 { 1899 int i; 1900 AcpiTable table = { .sig = "XSDT", .rev = 1, 1901 .oem_id = oem_id, .oem_table_id = oem_table_id }; 1902 1903 acpi_table_begin(&table, table_data); 1904 1905 for (i = 0; i < table_offsets->len; ++i) { 1906 uint64_t ref_tbl_offset = g_array_index(table_offsets, uint32_t, i); 1907 uint64_t xsdt_entry_offset = table.array->len; 1908 1909 /* reserve space for entry */ 1910 build_append_int_noprefix(table.array, 0, 8); 1911 1912 /* mark position of RSDT entry to be filled by Guest linker */ 1913 bios_linker_loader_add_pointer(linker, 1914 ACPI_BUILD_TABLE_FILE, xsdt_entry_offset, 8, 1915 ACPI_BUILD_TABLE_FILE, ref_tbl_offset); 1916 } 1917 acpi_table_end(linker, &table); 1918 } 1919 1920 /* 1921 * ACPI spec, Revision 4.0 1922 * 5.2.16.2 Memory Affinity Structure 1923 */ 1924 void build_srat_memory(GArray *table_data, uint64_t base, 1925 uint64_t len, int node, MemoryAffinityFlags flags) 1926 { 1927 build_append_int_noprefix(table_data, 1, 1); /* Type */ 1928 build_append_int_noprefix(table_data, 40, 1); /* Length */ 1929 build_append_int_noprefix(table_data, node, 4); /* Proximity Domain */ 1930 build_append_int_noprefix(table_data, 0, 2); /* Reserved */ 1931 build_append_int_noprefix(table_data, base, 4); /* Base Address Low */ 1932 /* Base Address High */ 1933 build_append_int_noprefix(table_data, base >> 32, 4); 1934 build_append_int_noprefix(table_data, len, 4); /* Length Low */ 1935 build_append_int_noprefix(table_data, len >> 32, 4); /* Length High */ 1936 build_append_int_noprefix(table_data, 0, 4); /* Reserved */ 1937 build_append_int_noprefix(table_data, flags, 4); /* Flags */ 1938 build_append_int_noprefix(table_data, 0, 8); /* Reserved */ 1939 } 1940 1941 /* 1942 * ACPI spec 5.2.17 System Locality Distance Information Table 1943 * (Revision 2.0 or later) 1944 */ 1945 void build_slit(GArray *table_data, BIOSLinker *linker, MachineState *ms, 1946 const char *oem_id, const char *oem_table_id) 1947 { 1948 int i, j; 1949 int nb_numa_nodes = ms->numa_state->num_nodes; 1950 AcpiTable table = { .sig = "SLIT", .rev = 1, 1951 .oem_id = oem_id, .oem_table_id = oem_table_id }; 1952 1953 acpi_table_begin(&table, table_data); 1954 1955 build_append_int_noprefix(table_data, nb_numa_nodes, 8); 1956 for (i = 0; i < nb_numa_nodes; i++) { 1957 for (j = 0; j < nb_numa_nodes; j++) { 1958 assert(ms->numa_state->nodes[i].distance[j]); 1959 build_append_int_noprefix(table_data, 1960 ms->numa_state->nodes[i].distance[j], 1961 1); 1962 } 1963 } 1964 acpi_table_end(linker, &table); 1965 } 1966 1967 /* 1968 * ACPI spec, Revision 6.3 1969 * 5.2.29.1 Processor hierarchy node structure (Type 0) 1970 */ 1971 static void build_processor_hierarchy_node(GArray *tbl, uint32_t flags, 1972 uint32_t parent, uint32_t id, 1973 uint32_t *priv_rsrc, 1974 uint32_t priv_num) 1975 { 1976 int i; 1977 1978 build_append_byte(tbl, 0); /* Type 0 - processor */ 1979 build_append_byte(tbl, 20 + priv_num * 4); /* Length */ 1980 build_append_int_noprefix(tbl, 0, 2); /* Reserved */ 1981 build_append_int_noprefix(tbl, flags, 4); /* Flags */ 1982 build_append_int_noprefix(tbl, parent, 4); /* Parent */ 1983 build_append_int_noprefix(tbl, id, 4); /* ACPI Processor ID */ 1984 1985 /* Number of private resources */ 1986 build_append_int_noprefix(tbl, priv_num, 4); 1987 1988 /* Private resources[N] */ 1989 if (priv_num > 0) { 1990 assert(priv_rsrc); 1991 for (i = 0; i < priv_num; i++) { 1992 build_append_int_noprefix(tbl, priv_rsrc[i], 4); 1993 } 1994 } 1995 } 1996 1997 void build_spcr(GArray *table_data, BIOSLinker *linker, 1998 const AcpiSpcrData *f, const uint8_t rev, 1999 const char *oem_id, const char *oem_table_id) 2000 { 2001 AcpiTable table = { .sig = "SPCR", .rev = rev, .oem_id = oem_id, 2002 .oem_table_id = oem_table_id }; 2003 2004 acpi_table_begin(&table, table_data); 2005 /* Interface type */ 2006 build_append_int_noprefix(table_data, f->interface_type, 1); 2007 /* Reserved */ 2008 build_append_int_noprefix(table_data, 0, 3); 2009 /* Base Address */ 2010 build_append_gas(table_data, f->base_addr.id, f->base_addr.width, 2011 f->base_addr.offset, f->base_addr.size, 2012 f->base_addr.addr); 2013 /* Interrupt type */ 2014 build_append_int_noprefix(table_data, f->interrupt_type, 1); 2015 /* IRQ */ 2016 build_append_int_noprefix(table_data, f->pc_interrupt, 1); 2017 /* Global System Interrupt */ 2018 build_append_int_noprefix(table_data, f->interrupt, 4); 2019 /* Baud Rate */ 2020 build_append_int_noprefix(table_data, f->baud_rate, 1); 2021 /* Parity */ 2022 build_append_int_noprefix(table_data, f->parity, 1); 2023 /* Stop Bits */ 2024 build_append_int_noprefix(table_data, f->stop_bits, 1); 2025 /* Flow Control */ 2026 build_append_int_noprefix(table_data, f->flow_control, 1); 2027 /* Language */ 2028 build_append_int_noprefix(table_data, f->language, 1); 2029 /* Terminal Type */ 2030 build_append_int_noprefix(table_data, f->terminal_type, 1); 2031 /* PCI Device ID */ 2032 build_append_int_noprefix(table_data, f->pci_device_id, 2); 2033 /* PCI Vendor ID */ 2034 build_append_int_noprefix(table_data, f->pci_vendor_id, 2); 2035 /* PCI Bus Number */ 2036 build_append_int_noprefix(table_data, f->pci_bus, 1); 2037 /* PCI Device Number */ 2038 build_append_int_noprefix(table_data, f->pci_device, 1); 2039 /* PCI Function Number */ 2040 build_append_int_noprefix(table_data, f->pci_function, 1); 2041 /* PCI Flags */ 2042 build_append_int_noprefix(table_data, f->pci_flags, 4); 2043 /* PCI Segment */ 2044 build_append_int_noprefix(table_data, f->pci_segment, 1); 2045 /* Reserved */ 2046 build_append_int_noprefix(table_data, 0, 4); 2047 2048 acpi_table_end(linker, &table); 2049 } 2050 /* 2051 * ACPI spec, Revision 6.3 2052 * 5.2.29 Processor Properties Topology Table (PPTT) 2053 */ 2054 void build_pptt(GArray *table_data, BIOSLinker *linker, MachineState *ms, 2055 const char *oem_id, const char *oem_table_id) 2056 { 2057 MachineClass *mc = MACHINE_GET_CLASS(ms); 2058 CPUArchIdList *cpus = ms->possible_cpus; 2059 int64_t socket_id = -1, cluster_id = -1, core_id = -1; 2060 uint32_t socket_offset = 0, cluster_offset = 0, core_offset = 0; 2061 uint32_t pptt_start = table_data->len; 2062 int n; 2063 AcpiTable table = { .sig = "PPTT", .rev = 2, 2064 .oem_id = oem_id, .oem_table_id = oem_table_id }; 2065 2066 acpi_table_begin(&table, table_data); 2067 2068 /* 2069 * This works with the assumption that cpus[n].props.*_id has been 2070 * sorted from top to down levels in mc->possible_cpu_arch_ids(). 2071 * Otherwise, the unexpected and duplicated containers will be 2072 * created. 2073 */ 2074 for (n = 0; n < cpus->len; n++) { 2075 if (cpus->cpus[n].props.socket_id != socket_id) { 2076 assert(cpus->cpus[n].props.socket_id > socket_id); 2077 socket_id = cpus->cpus[n].props.socket_id; 2078 cluster_id = -1; 2079 core_id = -1; 2080 socket_offset = table_data->len - pptt_start; 2081 build_processor_hierarchy_node(table_data, 2082 (1 << 0), /* Physical package */ 2083 0, socket_id, NULL, 0); 2084 } 2085 2086 if (mc->smp_props.clusters_supported && mc->smp_props.has_clusters) { 2087 if (cpus->cpus[n].props.cluster_id != cluster_id) { 2088 assert(cpus->cpus[n].props.cluster_id > cluster_id); 2089 cluster_id = cpus->cpus[n].props.cluster_id; 2090 core_id = -1; 2091 cluster_offset = table_data->len - pptt_start; 2092 build_processor_hierarchy_node(table_data, 2093 (0 << 0), /* Not a physical package */ 2094 socket_offset, cluster_id, NULL, 0); 2095 } 2096 } else { 2097 cluster_offset = socket_offset; 2098 } 2099 2100 if (ms->smp.threads == 1) { 2101 build_processor_hierarchy_node(table_data, 2102 (1 << 1) | /* ACPI Processor ID valid */ 2103 (1 << 3), /* Node is a Leaf */ 2104 cluster_offset, n, NULL, 0); 2105 } else { 2106 if (cpus->cpus[n].props.core_id != core_id) { 2107 assert(cpus->cpus[n].props.core_id > core_id); 2108 core_id = cpus->cpus[n].props.core_id; 2109 core_offset = table_data->len - pptt_start; 2110 build_processor_hierarchy_node(table_data, 2111 (0 << 0), /* Not a physical package */ 2112 cluster_offset, core_id, NULL, 0); 2113 } 2114 2115 build_processor_hierarchy_node(table_data, 2116 (1 << 1) | /* ACPI Processor ID valid */ 2117 (1 << 2) | /* Processor is a Thread */ 2118 (1 << 3), /* Node is a Leaf */ 2119 core_offset, n, NULL, 0); 2120 } 2121 } 2122 2123 acpi_table_end(linker, &table); 2124 } 2125 2126 /* build rev1/rev3/rev5.1/rev6.0 FADT */ 2127 void build_fadt(GArray *tbl, BIOSLinker *linker, const AcpiFadtData *f, 2128 const char *oem_id, const char *oem_table_id) 2129 { 2130 int off; 2131 AcpiTable table = { .sig = "FACP", .rev = f->rev, 2132 .oem_id = oem_id, .oem_table_id = oem_table_id }; 2133 2134 acpi_table_begin(&table, tbl); 2135 2136 /* FACS address to be filled by Guest linker at runtime */ 2137 off = tbl->len; 2138 build_append_int_noprefix(tbl, 0, 4); /* FIRMWARE_CTRL */ 2139 if (f->facs_tbl_offset) { /* don't patch if not supported by platform */ 2140 bios_linker_loader_add_pointer(linker, 2141 ACPI_BUILD_TABLE_FILE, off, 4, 2142 ACPI_BUILD_TABLE_FILE, *f->facs_tbl_offset); 2143 } 2144 2145 /* DSDT address to be filled by Guest linker at runtime */ 2146 off = tbl->len; 2147 build_append_int_noprefix(tbl, 0, 4); /* DSDT */ 2148 if (f->dsdt_tbl_offset) { /* don't patch if not supported by platform */ 2149 bios_linker_loader_add_pointer(linker, 2150 ACPI_BUILD_TABLE_FILE, off, 4, 2151 ACPI_BUILD_TABLE_FILE, *f->dsdt_tbl_offset); 2152 } 2153 2154 /* ACPI1.0: INT_MODEL, ACPI2.0+: Reserved */ 2155 build_append_int_noprefix(tbl, f->int_model /* Multiple APIC */, 1); 2156 /* Preferred_PM_Profile */ 2157 build_append_int_noprefix(tbl, 0 /* Unspecified */, 1); 2158 build_append_int_noprefix(tbl, f->sci_int, 2); /* SCI_INT */ 2159 build_append_int_noprefix(tbl, f->smi_cmd, 4); /* SMI_CMD */ 2160 build_append_int_noprefix(tbl, f->acpi_enable_cmd, 1); /* ACPI_ENABLE */ 2161 build_append_int_noprefix(tbl, f->acpi_disable_cmd, 1); /* ACPI_DISABLE */ 2162 build_append_int_noprefix(tbl, 0 /* not supported */, 1); /* S4BIOS_REQ */ 2163 /* ACPI1.0: Reserved, ACPI2.0+: PSTATE_CNT */ 2164 build_append_int_noprefix(tbl, 0, 1); 2165 build_append_int_noprefix(tbl, f->pm1a_evt.address, 4); /* PM1a_EVT_BLK */ 2166 build_append_int_noprefix(tbl, 0, 4); /* PM1b_EVT_BLK */ 2167 build_append_int_noprefix(tbl, f->pm1a_cnt.address, 4); /* PM1a_CNT_BLK */ 2168 build_append_int_noprefix(tbl, 0, 4); /* PM1b_CNT_BLK */ 2169 build_append_int_noprefix(tbl, 0, 4); /* PM2_CNT_BLK */ 2170 build_append_int_noprefix(tbl, f->pm_tmr.address, 4); /* PM_TMR_BLK */ 2171 build_append_int_noprefix(tbl, f->gpe0_blk.address, 4); /* GPE0_BLK */ 2172 build_append_int_noprefix(tbl, 0, 4); /* GPE1_BLK */ 2173 /* PM1_EVT_LEN */ 2174 build_append_int_noprefix(tbl, f->pm1a_evt.bit_width / 8, 1); 2175 /* PM1_CNT_LEN */ 2176 build_append_int_noprefix(tbl, f->pm1a_cnt.bit_width / 8, 1); 2177 build_append_int_noprefix(tbl, 0, 1); /* PM2_CNT_LEN */ 2178 build_append_int_noprefix(tbl, f->pm_tmr.bit_width / 8, 1); /* PM_TMR_LEN */ 2179 /* GPE0_BLK_LEN */ 2180 build_append_int_noprefix(tbl, f->gpe0_blk.bit_width / 8, 1); 2181 build_append_int_noprefix(tbl, 0, 1); /* GPE1_BLK_LEN */ 2182 build_append_int_noprefix(tbl, 0, 1); /* GPE1_BASE */ 2183 build_append_int_noprefix(tbl, 0, 1); /* CST_CNT */ 2184 build_append_int_noprefix(tbl, f->plvl2_lat, 2); /* P_LVL2_LAT */ 2185 build_append_int_noprefix(tbl, f->plvl3_lat, 2); /* P_LVL3_LAT */ 2186 build_append_int_noprefix(tbl, 0, 2); /* FLUSH_SIZE */ 2187 build_append_int_noprefix(tbl, 0, 2); /* FLUSH_STRIDE */ 2188 build_append_int_noprefix(tbl, 0, 1); /* DUTY_OFFSET */ 2189 build_append_int_noprefix(tbl, 0, 1); /* DUTY_WIDTH */ 2190 build_append_int_noprefix(tbl, 0, 1); /* DAY_ALRM */ 2191 build_append_int_noprefix(tbl, 0, 1); /* MON_ALRM */ 2192 build_append_int_noprefix(tbl, f->rtc_century, 1); /* CENTURY */ 2193 /* IAPC_BOOT_ARCH */ 2194 if (f->rev == 1) { 2195 build_append_int_noprefix(tbl, 0, 2); 2196 } else { 2197 /* since ACPI v2.0 */ 2198 build_append_int_noprefix(tbl, f->iapc_boot_arch, 2); 2199 } 2200 build_append_int_noprefix(tbl, 0, 1); /* Reserved */ 2201 build_append_int_noprefix(tbl, f->flags, 4); /* Flags */ 2202 2203 if (f->rev == 1) { 2204 goto done; 2205 } 2206 2207 build_append_gas_from_struct(tbl, &f->reset_reg); /* RESET_REG */ 2208 build_append_int_noprefix(tbl, f->reset_val, 1); /* RESET_VALUE */ 2209 /* Since ACPI 5.1 */ 2210 if ((f->rev >= 6) || ((f->rev == 5) && f->minor_ver > 0)) { 2211 build_append_int_noprefix(tbl, f->arm_boot_arch, 2); /* ARM_BOOT_ARCH */ 2212 /* FADT Minor Version */ 2213 build_append_int_noprefix(tbl, f->minor_ver, 1); 2214 } else { 2215 build_append_int_noprefix(tbl, 0, 3); /* Reserved up to ACPI 5.0 */ 2216 } 2217 build_append_int_noprefix(tbl, 0, 8); /* X_FIRMWARE_CTRL */ 2218 2219 /* XDSDT address to be filled by Guest linker at runtime */ 2220 off = tbl->len; 2221 build_append_int_noprefix(tbl, 0, 8); /* X_DSDT */ 2222 if (f->xdsdt_tbl_offset) { 2223 bios_linker_loader_add_pointer(linker, 2224 ACPI_BUILD_TABLE_FILE, off, 8, 2225 ACPI_BUILD_TABLE_FILE, *f->xdsdt_tbl_offset); 2226 } 2227 2228 build_append_gas_from_struct(tbl, &f->pm1a_evt); /* X_PM1a_EVT_BLK */ 2229 /* X_PM1b_EVT_BLK */ 2230 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0); 2231 build_append_gas_from_struct(tbl, &f->pm1a_cnt); /* X_PM1a_CNT_BLK */ 2232 /* X_PM1b_CNT_BLK */ 2233 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0); 2234 /* X_PM2_CNT_BLK */ 2235 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0); 2236 build_append_gas_from_struct(tbl, &f->pm_tmr); /* X_PM_TMR_BLK */ 2237 build_append_gas_from_struct(tbl, &f->gpe0_blk); /* X_GPE0_BLK */ 2238 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0); /* X_GPE1_BLK */ 2239 2240 if (f->rev <= 4) { 2241 goto done; 2242 } 2243 2244 /* SLEEP_CONTROL_REG */ 2245 build_append_gas_from_struct(tbl, &f->sleep_ctl); 2246 /* SLEEP_STATUS_REG */ 2247 build_append_gas_from_struct(tbl, &f->sleep_sts); 2248 2249 if (f->rev == 5) { 2250 goto done; 2251 } 2252 2253 /* Hypervisor Vendor Identity */ 2254 build_append_padded_str(tbl, "QEMU", 8, '\0'); 2255 2256 /* TODO: extra fields need to be added to support revisions above rev6 */ 2257 assert(f->rev == 6); 2258 2259 done: 2260 acpi_table_end(linker, &table); 2261 } 2262 2263 #ifdef CONFIG_TPM 2264 /* 2265 * build_tpm2 - Build the TPM2 table as specified in 2266 * table 7: TCG Hardware Interface Description Table Format for TPM 2.0 2267 * of TCG ACPI Specification, Family “1.2” and “2.0”, Version 1.2, Rev 8 2268 */ 2269 void build_tpm2(GArray *table_data, BIOSLinker *linker, GArray *tcpalog, 2270 const char *oem_id, const char *oem_table_id) 2271 { 2272 uint8_t start_method_params[12] = {}; 2273 unsigned log_addr_offset; 2274 uint64_t control_area_start_address; 2275 TPMIf *tpmif = tpm_find(); 2276 uint32_t start_method; 2277 AcpiTable table = { .sig = "TPM2", .rev = 4, 2278 .oem_id = oem_id, .oem_table_id = oem_table_id }; 2279 2280 acpi_table_begin(&table, table_data); 2281 2282 /* Platform Class */ 2283 build_append_int_noprefix(table_data, TPM2_ACPI_CLASS_CLIENT, 2); 2284 /* Reserved */ 2285 build_append_int_noprefix(table_data, 0, 2); 2286 if (TPM_IS_TIS_ISA(tpmif) || TPM_IS_TIS_SYSBUS(tpmif)) { 2287 control_area_start_address = 0; 2288 start_method = TPM2_START_METHOD_MMIO; 2289 } else if (TPM_IS_CRB(tpmif)) { 2290 control_area_start_address = TPM_CRB_ADDR_CTRL; 2291 start_method = TPM2_START_METHOD_CRB; 2292 } else { 2293 g_assert_not_reached(); 2294 } 2295 /* Address of Control Area */ 2296 build_append_int_noprefix(table_data, control_area_start_address, 8); 2297 /* Start Method */ 2298 build_append_int_noprefix(table_data, start_method, 4); 2299 2300 /* Platform Specific Parameters */ 2301 g_array_append_vals(table_data, &start_method_params, 2302 ARRAY_SIZE(start_method_params)); 2303 2304 /* Log Area Minimum Length */ 2305 build_append_int_noprefix(table_data, TPM_LOG_AREA_MINIMUM_SIZE, 4); 2306 2307 acpi_data_push(tcpalog, TPM_LOG_AREA_MINIMUM_SIZE); 2308 bios_linker_loader_alloc(linker, ACPI_BUILD_TPMLOG_FILE, tcpalog, 1, 2309 false); 2310 2311 log_addr_offset = table_data->len; 2312 2313 /* Log Area Start Address to be filled by Guest linker */ 2314 build_append_int_noprefix(table_data, 0, 8); 2315 bios_linker_loader_add_pointer(linker, ACPI_BUILD_TABLE_FILE, 2316 log_addr_offset, 8, 2317 ACPI_BUILD_TPMLOG_FILE, 0); 2318 acpi_table_end(linker, &table); 2319 } 2320 #endif 2321 2322 Aml *build_crs(PCIHostState *host, CrsRangeSet *range_set, uint32_t io_offset, 2323 uint32_t mmio32_offset, uint64_t mmio64_offset, 2324 uint16_t bus_nr_offset) 2325 { 2326 Aml *crs = aml_resource_template(); 2327 CrsRangeSet temp_range_set; 2328 CrsRangeEntry *entry; 2329 uint8_t max_bus = pci_bus_num(host->bus); 2330 uint8_t type; 2331 int devfn; 2332 int i; 2333 2334 crs_range_set_init(&temp_range_set); 2335 for (devfn = 0; devfn < ARRAY_SIZE(host->bus->devices); devfn++) { 2336 uint64_t range_base, range_limit; 2337 PCIDevice *dev = host->bus->devices[devfn]; 2338 2339 if (!dev) { 2340 continue; 2341 } 2342 2343 for (i = 0; i < PCI_NUM_REGIONS; i++) { 2344 PCIIORegion *r = &dev->io_regions[i]; 2345 2346 range_base = r->addr; 2347 range_limit = r->addr + r->size - 1; 2348 2349 /* 2350 * Work-around for old bioses 2351 * that do not support multiple root buses 2352 */ 2353 if (!range_base || range_base > range_limit) { 2354 continue; 2355 } 2356 2357 if (r->type & PCI_BASE_ADDRESS_SPACE_IO) { 2358 crs_range_insert(temp_range_set.io_ranges, 2359 range_base, range_limit); 2360 } else { /* "memory" */ 2361 uint64_t length = range_limit - range_base + 1; 2362 if (range_limit <= UINT32_MAX && length <= UINT32_MAX) { 2363 crs_range_insert(temp_range_set.mem_ranges, range_base, 2364 range_limit); 2365 } else { 2366 crs_range_insert(temp_range_set.mem_64bit_ranges, 2367 range_base, range_limit); 2368 } 2369 } 2370 } 2371 2372 type = dev->config[PCI_HEADER_TYPE] & ~PCI_HEADER_TYPE_MULTI_FUNCTION; 2373 if (type == PCI_HEADER_TYPE_BRIDGE) { 2374 uint8_t subordinate = dev->config[PCI_SUBORDINATE_BUS]; 2375 if (subordinate > max_bus) { 2376 max_bus = subordinate; 2377 } 2378 2379 range_base = pci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_IO); 2380 range_limit = pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_IO); 2381 2382 /* 2383 * Work-around for old bioses 2384 * that do not support multiple root buses 2385 */ 2386 if (range_base && range_base <= range_limit) { 2387 crs_range_insert(temp_range_set.io_ranges, 2388 range_base, range_limit); 2389 } 2390 2391 range_base = 2392 pci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_MEMORY); 2393 range_limit = 2394 pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_MEMORY); 2395 2396 /* 2397 * Work-around for old bioses 2398 * that do not support multiple root buses 2399 */ 2400 if (range_base && range_base <= range_limit) { 2401 uint64_t length = range_limit - range_base + 1; 2402 if (range_limit <= UINT32_MAX && length <= UINT32_MAX) { 2403 crs_range_insert(temp_range_set.mem_ranges, 2404 range_base, range_limit); 2405 } else { 2406 crs_range_insert(temp_range_set.mem_64bit_ranges, 2407 range_base, range_limit); 2408 } 2409 } 2410 2411 range_base = 2412 pci_bridge_get_base(dev, PCI_BASE_ADDRESS_MEM_PREFETCH); 2413 range_limit = 2414 pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_MEM_PREFETCH); 2415 2416 /* 2417 * Work-around for old bioses 2418 * that do not support multiple root buses 2419 */ 2420 if (range_base && range_base <= range_limit) { 2421 uint64_t length = range_limit - range_base + 1; 2422 if (range_limit <= UINT32_MAX && length <= UINT32_MAX) { 2423 crs_range_insert(temp_range_set.mem_ranges, 2424 range_base, range_limit); 2425 } else { 2426 crs_range_insert(temp_range_set.mem_64bit_ranges, 2427 range_base, range_limit); 2428 } 2429 } 2430 } 2431 } 2432 2433 crs_range_merge(temp_range_set.io_ranges); 2434 for (i = 0; i < temp_range_set.io_ranges->len; i++) { 2435 entry = g_ptr_array_index(temp_range_set.io_ranges, i); 2436 aml_append(crs, 2437 aml_dword_io(AML_MIN_FIXED, AML_MAX_FIXED, 2438 AML_POS_DECODE, AML_ENTIRE_RANGE, 2439 0, entry->base, entry->limit, io_offset, 2440 entry->limit - entry->base + 1)); 2441 crs_range_insert(range_set->io_ranges, entry->base, entry->limit); 2442 } 2443 2444 crs_range_merge(temp_range_set.mem_ranges); 2445 for (i = 0; i < temp_range_set.mem_ranges->len; i++) { 2446 entry = g_ptr_array_index(temp_range_set.mem_ranges, i); 2447 assert(entry->limit <= UINT32_MAX && 2448 (entry->limit - entry->base + 1) <= UINT32_MAX); 2449 aml_append(crs, 2450 aml_dword_memory(AML_POS_DECODE, AML_MIN_FIXED, 2451 AML_MAX_FIXED, AML_NON_CACHEABLE, 2452 AML_READ_WRITE, 2453 0, entry->base, entry->limit, mmio32_offset, 2454 entry->limit - entry->base + 1)); 2455 crs_range_insert(range_set->mem_ranges, entry->base, entry->limit); 2456 } 2457 2458 crs_range_merge(temp_range_set.mem_64bit_ranges); 2459 for (i = 0; i < temp_range_set.mem_64bit_ranges->len; i++) { 2460 entry = g_ptr_array_index(temp_range_set.mem_64bit_ranges, i); 2461 aml_append(crs, 2462 aml_qword_memory(AML_POS_DECODE, AML_MIN_FIXED, 2463 AML_MAX_FIXED, AML_NON_CACHEABLE, 2464 AML_READ_WRITE, 2465 0, entry->base, entry->limit, mmio64_offset, 2466 entry->limit - entry->base + 1)); 2467 crs_range_insert(range_set->mem_64bit_ranges, 2468 entry->base, entry->limit); 2469 } 2470 2471 crs_range_set_free(&temp_range_set); 2472 2473 aml_append(crs, 2474 aml_word_bus_number(AML_MIN_FIXED, AML_MAX_FIXED, AML_POS_DECODE, 2475 0, 2476 pci_bus_num(host->bus), 2477 max_bus, 2478 bus_nr_offset, 2479 max_bus - pci_bus_num(host->bus) + 1)); 2480 2481 return crs; 2482 } 2483 2484 /* ACPI 5.0: 6.4.3.8.2 Serial Bus Connection Descriptors */ 2485 static Aml *aml_serial_bus_device(uint8_t serial_bus_type, uint8_t flags, 2486 uint16_t type_flags, 2487 uint8_t revid, uint16_t data_length, 2488 uint16_t resource_source_len) 2489 { 2490 Aml *var = aml_alloc(); 2491 uint16_t length = data_length + resource_source_len + 9; 2492 2493 build_append_byte(var->buf, 0x8e); /* Serial Bus Connection Descriptor */ 2494 build_append_int_noprefix(var->buf, length, sizeof(length)); 2495 build_append_byte(var->buf, 1); /* Revision ID */ 2496 build_append_byte(var->buf, 0); /* Resource Source Index */ 2497 build_append_byte(var->buf, serial_bus_type); /* Serial Bus Type */ 2498 build_append_byte(var->buf, flags); /* General Flags */ 2499 build_append_int_noprefix(var->buf, type_flags, /* Type Specific Flags */ 2500 sizeof(type_flags)); 2501 build_append_byte(var->buf, revid); /* Type Specification Revision ID */ 2502 build_append_int_noprefix(var->buf, data_length, sizeof(data_length)); 2503 2504 return var; 2505 } 2506 2507 /* ACPI 5.0: 6.4.3.8.2.1 I2C Serial Bus Connection Resource Descriptor */ 2508 Aml *aml_i2c_serial_bus_device(uint16_t address, const char *resource_source) 2509 { 2510 uint16_t resource_source_len = strlen(resource_source) + 1; 2511 Aml *var = aml_serial_bus_device(AML_SERIAL_BUS_TYPE_I2C, 0, 0, 1, 2512 6, resource_source_len); 2513 2514 /* Connection Speed. Just set to 100K for now, it doesn't really matter. */ 2515 build_append_int_noprefix(var->buf, 100000, 4); 2516 build_append_int_noprefix(var->buf, address, sizeof(address)); 2517 2518 /* This is a string, not a name, so just copy it directly in. */ 2519 g_array_append_vals(var->buf, resource_source, resource_source_len); 2520 2521 return var; 2522 } 2523