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