hw/acpi/aml-build.c

   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 <[email protected]>
   6  * Author: Igor Mammedov <[email protected]>
   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 <glib/gprintf.h>
  23 #include <stdio.h>
  24 #include <stdarg.h>
  25 #include <assert.h>
  26 #include <stdbool.h>
  27 #include <string.h>
  28 #include "hw/acpi/aml-build.h"
  29 #include "qemu/bswap.h"
  30 #include "qemu/bitops.h"
  31 #include "hw/acpi/bios-linker-loader.h"
  32
  33 static GArray *build_alloc_array(void)
  34 {
  35     return g_array_new(false, true /* clear */, 1);
  36 }
  37
  38 static void build_free_array(GArray *array)
  39 {
  40     g_array_free(array, true);
  41 }
  42
  43 static void build_prepend_byte(GArray *array, uint8_t val)
  44 {
  45     g_array_prepend_val(array, val);
  46 }
  47
  48 static void build_append_byte(GArray *array, uint8_t val)
  49 {
  50     g_array_append_val(array, val);
  51 }
  52
  53 static void build_append_array(GArray *array, GArray *val)
  54 {
  55     g_array_append_vals(array, val->data, val->len);
  56 }
  57
  58 #define ACPI_NAMESEG_LEN 4
  59
  60 static void
  61 build_append_nameseg(GArray *array, const char *seg)
  62 {
  63     int len;
  64
  65     len = strlen(seg);
  66     assert(len <= ACPI_NAMESEG_LEN);
  67
  68     g_array_append_vals(array, seg, len);
  69     /* Pad up to ACPI_NAMESEG_LEN characters if necessary. */
  70     g_array_append_vals(array, "____", ACPI_NAMESEG_LEN - len);
  71 }
  72
  73 static void GCC_FMT_ATTR(2, 0)
  74 build_append_namestringv(GArray *array, const char *format, va_list ap)
  75 {
  76     char *s;
  77     char **segs;
  78     char **segs_iter;
  79     int seg_count = 0;
  80
  81     s = g_strdup_vprintf(format, ap);
  82     segs = g_strsplit(s, ".", 0);
  83     g_free(s);
  84
  85     /* count segments */
  86     segs_iter = segs;
  87     while (*segs_iter) {
  88         ++segs_iter;
  89         ++seg_count;
  90     }
  91     /*
  92      * ACPI 5.0 spec: 20.2.2 Name Objects Encoding:
  93      * "SegCount can be from 1 to 255"
  94      */
  95     assert(seg_count > 0 && seg_count <= 255);
  96
  97     /* handle RootPath || PrefixPath */
  98     s = *segs;
  99     while (*s == '\\' || *s == '^') {
 100         build_append_byte(array, *s);
 101         ++s;
 102     }
 103
 104     switch (seg_count) {
 105     case 1:
 106         if (!*s) {
 107             build_append_byte(array, 0x00); /* NullName */
 108         } else {
 109             build_append_nameseg(array, s);
 110         }
 111         break;
 112
 113     case 2:
 114         build_append_byte(array, 0x2E); /* DualNamePrefix */
 115         build_append_nameseg(array, s);
 116         build_append_nameseg(array, segs[1]);
 117         break;
 118     default:
 119         build_append_byte(array, 0x2F); /* MultiNamePrefix */
 120         build_append_byte(array, seg_count);
 121
 122         /* handle the 1st segment manually due to prefix/root path */
 123         build_append_nameseg(array, s);
 124
 125         /* add the rest of segments */
 126         segs_iter = segs + 1;
 127         while (*segs_iter) {
 128             build_append_nameseg(array, *segs_iter);
 129             ++segs_iter;
 130         }
 131         break;
 132     }
 133     g_strfreev(segs);
 134 }
 135
 136 GCC_FMT_ATTR(2, 3)
 137 static void build_append_namestring(GArray *array, const char *format, ...)
 138 {
 139     va_list ap;
 140
 141     va_start(ap, format);
 142     build_append_namestringv(array, format, ap);
 143     va_end(ap);
 144 }
 145
 146 /* 5.4 Definition Block Encoding */
 147 enum {
 148     PACKAGE_LENGTH_1BYTE_SHIFT = 6, /* Up to 63 - use extra 2 bits. */
 149     PACKAGE_LENGTH_2BYTE_SHIFT = 4,
 150     PACKAGE_LENGTH_3BYTE_SHIFT = 12,
 151     PACKAGE_LENGTH_4BYTE_SHIFT = 20,
 152 };
 153
 154 static void
 155 build_prepend_package_length(GArray *package, unsigned length, bool incl_self)
 156 {
 157     uint8_t byte;
 158     unsigned length_bytes;
 159
 160     if (length + 1 < (1 << PACKAGE_LENGTH_1BYTE_SHIFT)) {
 161         length_bytes = 1;
 162     } else if (length + 2 < (1 << PACKAGE_LENGTH_3BYTE_SHIFT)) {
 163         length_bytes = 2;
 164     } else if (length + 3 < (1 << PACKAGE_LENGTH_4BYTE_SHIFT)) {
 165         length_bytes = 3;
 166     } else {
 167         length_bytes = 4;
 168     }
 169
 170     /*
 171      * NamedField uses PkgLength encoding but it doesn't include length
 172      * of PkgLength itself.
 173      */
 174     if (incl_self) {
 175         /*
 176          * PkgLength is the length of the inclusive length of the data
 177          * and PkgLength's length itself when used for terms with
 178          * explitit length.
 179          */
 180         length += length_bytes;
 181     }
 182
 183     switch (length_bytes) {
 184     case 1:
 185         byte = length;
 186         build_prepend_byte(package, byte);
 187         return;
 188     case 4:
 189         byte = length >> PACKAGE_LENGTH_4BYTE_SHIFT;
 190         build_prepend_byte(package, byte);
 191         length &= (1 << PACKAGE_LENGTH_4BYTE_SHIFT) - 1;
 192         /* fall through */
 193     case 3:
 194         byte = length >> PACKAGE_LENGTH_3BYTE_SHIFT;
 195         build_prepend_byte(package, byte);
 196         length &= (1 << PACKAGE_LENGTH_3BYTE_SHIFT) - 1;
 197         /* fall through */
 198     case 2:
 199         byte = length >> PACKAGE_LENGTH_2BYTE_SHIFT;
 200         build_prepend_byte(package, byte);
 201         length &= (1 << PACKAGE_LENGTH_2BYTE_SHIFT) - 1;
 202         /* fall through */
 203     }
 204     /*
 205      * Most significant two bits of byte zero indicate how many following bytes
 206      * are in PkgLength encoding.
 207      */
 208     byte = ((length_bytes - 1) << PACKAGE_LENGTH_1BYTE_SHIFT) | length;
 209     build_prepend_byte(package, byte);
 210 }
 211
 212 static void
 213 build_append_pkg_length(GArray *array, unsigned length, bool incl_self)
 214 {
 215     GArray *tmp = build_alloc_array();
 216
 217     build_prepend_package_length(tmp, length, incl_self);
 218     build_append_array(array, tmp);
 219     build_free_array(tmp);
 220 }
 221
 222 static void build_package(GArray *package, uint8_t op)
 223 {
 224     build_prepend_package_length(package, package->len, true);
 225     build_prepend_byte(package, op);
 226 }
 227
 228 static void build_extop_package(GArray *package, uint8_t op)
 229 {
 230     build_package(package, op);
 231     build_prepend_byte(package, 0x5B); /* ExtOpPrefix */
 232 }
 233
 234 static void build_append_int_noprefix(GArray *table, uint64_t value, int size)
 235 {
 236     int i;
 237
 238     for (i = 0; i < size; ++i) {
 239         build_append_byte(table, value & 0xFF);
 240         value = value >> 8;
 241     }
 242 }
 243
 244 static void build_append_int(GArray *table, uint64_t value)
 245 {
 246     if (value == 0x00) {
 247         build_append_byte(table, 0x00); /* ZeroOp */
 248     } else if (value == 0x01) {
 249         build_append_byte(table, 0x01); /* OneOp */
 250     } else if (value <= 0xFF) {
 251         build_append_byte(table, 0x0A); /* BytePrefix */
 252         build_append_int_noprefix(table, value, 1);
 253     } else if (value <= 0xFFFF) {
 254         build_append_byte(table, 0x0B); /* WordPrefix */
 255         build_append_int_noprefix(table, value, 2);
 256     } else if (value <= 0xFFFFFFFF) {
 257         build_append_byte(table, 0x0C); /* DWordPrefix */
 258         build_append_int_noprefix(table, value, 4);
 259     } else {
 260         build_append_byte(table, 0x0E); /* QWordPrefix */
 261         build_append_int_noprefix(table, value, 8);
 262     }
 263 }
 264
 265 static GPtrArray *alloc_list;
 266
 267 static Aml *aml_alloc(void)
 268 {
 269     Aml *var = g_new0(typeof(*var), 1);
 270
 271     g_ptr_array_add(alloc_list, var);
 272     var->block_flags = AML_NO_OPCODE;
 273     var->buf = build_alloc_array();
 274     return var;
 275 }
 276
 277 static Aml *aml_opcode(uint8_t op)
 278 {
 279     Aml *var = aml_alloc();
 280
 281     var->op  = op;
 282     var->block_flags = AML_OPCODE;
 283     return var;
 284 }
 285
 286 static Aml *aml_bundle(uint8_t op, AmlBlockFlags flags)
 287 {
 288     Aml *var = aml_alloc();
 289
 290     var->op  = op;
 291     var->block_flags = flags;
 292     return var;
 293 }
 294
 295 static void aml_free(gpointer data, gpointer user_data)
 296 {
 297     Aml *var = data;
 298     build_free_array(var->buf);
 299     g_free(var);
 300 }
 301
 302 Aml *init_aml_allocator(void)
 303 {
 304     Aml *var;
 305
 306     assert(!alloc_list);
 307     alloc_list = g_ptr_array_new();
 308     var = aml_alloc();
 309     return var;
 310 }
 311
 312 void free_aml_allocator(void)
 313 {
 314     g_ptr_array_foreach(alloc_list, aml_free, NULL);
 315     g_ptr_array_free(alloc_list, true);
 316     alloc_list = 0;
 317 }
 318
 319 /* pack data with DefBuffer encoding */
 320 static void build_buffer(GArray *array, uint8_t op)
 321 {
 322     GArray *data = build_alloc_array();
 323
 324     build_append_int(data, array->len);
 325     g_array_prepend_vals(array, data->data, data->len);
 326     build_free_array(data);
 327     build_package(array, op);
 328 }
 329
 330 void aml_append(Aml *parent_ctx, Aml *child)
 331 {
 332     GArray *buf = build_alloc_array();
 333     build_append_array(buf, child->buf);
 334
 335     switch (child->block_flags) {
 336     case AML_OPCODE:
 337         build_append_byte(parent_ctx->buf, child->op);
 338         break;
 339     case AML_EXT_PACKAGE:
 340         build_extop_package(buf, child->op);
 341         break;
 342     case AML_PACKAGE:
 343         build_package(buf, child->op);
 344         break;
 345     case AML_RES_TEMPLATE:
 346         build_append_byte(buf, 0x79); /* EndTag */
 347         /*
 348          * checksum operations are treated as succeeded if checksum
 349          * field is zero. [ACPI Spec 1.0b, 6.4.2.8 End Tag]
 350          */
 351         build_append_byte(buf, 0);
 352         /* fall through, to pack resources in buffer */
 353     case AML_BUFFER:
 354         build_buffer(buf, child->op);
 355         break;
 356     case AML_NO_OPCODE:
 357         break;
 358     default:
 359         assert(0);
 360         break;
 361     }
 362     build_append_array(parent_ctx->buf, buf);
 363     build_free_array(buf);
 364 }
 365
 366 /* ACPI 1.0b: 16.2.5.1 Namespace Modifier Objects Encoding: DefScope */
 367 Aml *aml_scope(const char *name_format, ...)
 368 {
 369     va_list ap;
 370     Aml *var = aml_bundle(0x10 /* ScopeOp */, AML_PACKAGE);
 371     va_start(ap, name_format);
 372     build_append_namestringv(var->buf, name_format, ap);
 373     va_end(ap);
 374     return var;
 375 }
 376
 377 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefReturn */
 378 Aml *aml_return(Aml *val)
 379 {
 380     Aml *var = aml_opcode(0xA4 /* ReturnOp */);
 381     aml_append(var, val);
 382     return var;
 383 }
 384
 385 /*
 386  * ACPI 1.0b: 16.2.3 Data Objects Encoding:
 387  * encodes: ByteConst, WordConst, DWordConst, QWordConst, ZeroOp, OneOp
 388  */
 389 Aml *aml_int(const uint64_t val)
 390 {
 391     Aml *var = aml_alloc();
 392     build_append_int(var->buf, val);
 393     return var;
 394 }
 395
 396 /*
 397  * helper to construct NameString, which returns Aml object
 398  * for using with aml_append or other aml_* terms
 399  */
 400 Aml *aml_name(const char *name_format, ...)
 401 {
 402     va_list ap;
 403     Aml *var = aml_alloc();
 404     va_start(ap, name_format);
 405     build_append_namestringv(var->buf, name_format, ap);
 406     va_end(ap);
 407     return var;
 408 }
 409
 410 /* ACPI 1.0b: 16.2.5.1 Namespace Modifier Objects Encoding: DefName */
 411 Aml *aml_name_decl(const char *name, Aml *val)
 412 {
 413     Aml *var = aml_opcode(0x08 /* NameOp */);
 414     build_append_namestring(var->buf, "%s", name);
 415     aml_append(var, val);
 416     return var;
 417 }
 418
 419 /* ACPI 1.0b: 16.2.6.1 Arg Objects Encoding */
 420 Aml *aml_arg(int pos)
 421 {
 422     Aml *var;
 423     uint8_t op = 0x68 /* ARG0 op */ + pos;
 424
 425     assert(pos <= 6);
 426     var = aml_opcode(op);
 427     return var;
 428 }
 429
 430 /* ACPI 2.0a: 17.2.4.4 Type 2 Opcodes Encoding: DefToInteger */
 431 Aml *aml_to_integer(Aml *arg)
 432 {
 433     Aml *var = aml_opcode(0x99 /* ToIntegerOp */);
 434     aml_append(var, arg);
 435     build_append_byte(var->buf, 0x00 /* NullNameOp */);
 436     return var;
 437 }
 438
 439 /* ACPI 2.0a: 17.2.4.4 Type 2 Opcodes Encoding: DefToHexString */
 440 Aml *aml_to_hexstring(Aml *src, Aml *dst)
 441 {
 442     Aml *var = aml_opcode(0x98 /* ToHexStringOp */);
 443     aml_append(var, src);
 444     if (dst) {
 445         aml_append(var, dst);
 446     } else {
 447         build_append_byte(var->buf, 0x00 /* NullNameOp */);
 448     }
 449     return var;
 450 }
 451
 452 /* ACPI 2.0a: 17.2.4.4 Type 2 Opcodes Encoding: DefToBuffer */
 453 Aml *aml_to_buffer(Aml *src, Aml *dst)
 454 {
 455     Aml *var = aml_opcode(0x96 /* ToBufferOp */);
 456     aml_append(var, src);
 457     if (dst) {
 458         aml_append(var, dst);
 459     } else {
 460         build_append_byte(var->buf, 0x00 /* NullNameOp */);
 461     }
 462     return var;
 463 }
 464
 465 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefStore */
 466 Aml *aml_store(Aml *val, Aml *target)
 467 {
 468     Aml *var = aml_opcode(0x70 /* StoreOp */);
 469     aml_append(var, val);
 470     aml_append(var, target);
 471     return var;
 472 }
 473
 474 /**
 475  * build_opcode_2arg_dst:
 476  * @op: 1-byte opcode
 477  * @arg1: 1st operand
 478  * @arg2: 2nd operand
 479  * @dst: optional target to store to, set to NULL if it's not required
 480  *
 481  * An internal helper to compose AML terms that have
 482  *   "Op Operand Operand Target"
 483  * pattern.
 484  *
 485  * Returns: The newly allocated and composed according to patter Aml object.
 486  */
 487 static Aml *
 488 build_opcode_2arg_dst(uint8_t op, Aml *arg1, Aml *arg2, Aml *dst)
 489 {
 490     Aml *var = aml_opcode(op);
 491     aml_append(var, arg1);
 492     aml_append(var, arg2);
 493     if (dst) {
 494         aml_append(var, dst);
 495     } else {
 496         build_append_byte(var->buf, 0x00 /* NullNameOp */);
 497     }
 498     return var;
 499 }
 500
 501 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefAnd */
 502 Aml *aml_and(Aml *arg1, Aml *arg2, Aml *dst)
 503 {
 504     return build_opcode_2arg_dst(0x7B /* AndOp */, arg1, arg2, dst);
 505 }
 506
 507 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefOr */
 508 Aml *aml_or(Aml *arg1, Aml *arg2, Aml *dst)
 509 {
 510     return build_opcode_2arg_dst(0x7D /* OrOp */, arg1, arg2, dst);
 511 }
 512
 513 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLOr */
 514 Aml *aml_lor(Aml *arg1, Aml *arg2)
 515 {
 516     Aml *var = aml_opcode(0x91 /* LOrOp */);
 517     aml_append(var, arg1);
 518     aml_append(var, arg2);
 519     return var;
 520 }
 521
 522 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefShiftLeft */
 523 Aml *aml_shiftleft(Aml *arg1, Aml *count)
 524 {
 525     return build_opcode_2arg_dst(0x79 /* ShiftLeftOp */, arg1, count, NULL);
 526 }
 527
 528 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefShiftRight */
 529 Aml *aml_shiftright(Aml *arg1, Aml *count, Aml *dst)
 530 {
 531     return build_opcode_2arg_dst(0x7A /* ShiftRightOp */, arg1, count, dst);
 532 }
 533
 534 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLLess */
 535 Aml *aml_lless(Aml *arg1, Aml *arg2)
 536 {
 537     Aml *var = aml_opcode(0x95 /* LLessOp */);
 538     aml_append(var, arg1);
 539     aml_append(var, arg2);
 540     return var;
 541 }
 542
 543 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefAdd */
 544 Aml *aml_add(Aml *arg1, Aml *arg2, Aml *dst)
 545 {
 546     return build_opcode_2arg_dst(0x72 /* AddOp */, arg1, arg2, dst);
 547 }
 548
 549 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefSubtract */
 550 Aml *aml_subtract(Aml *arg1, Aml *arg2, Aml *dst)
 551 {
 552     return build_opcode_2arg_dst(0x74 /* SubtractOp */, arg1, arg2, dst);
 553 }
 554
 555 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefIncrement */
 556 Aml *aml_increment(Aml *arg)
 557 {
 558     Aml *var = aml_opcode(0x75 /* IncrementOp */);
 559     aml_append(var, arg);
 560     return var;
 561 }
 562
 563 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefDecrement */
 564 Aml *aml_decrement(Aml *arg)
 565 {
 566     Aml *var = aml_opcode(0x76 /* DecrementOp */);
 567     aml_append(var, arg);
 568     return var;
 569 }
 570
 571 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefIndex */
 572 Aml *aml_index(Aml *arg1, Aml *idx)
 573 {
 574     return build_opcode_2arg_dst(0x88 /* IndexOp */, arg1, idx, NULL);
 575 }
 576
 577 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefNotify */
 578 Aml *aml_notify(Aml *arg1, Aml *arg2)
 579 {
 580     Aml *var = aml_opcode(0x86 /* NotifyOp */);
 581     aml_append(var, arg1);
 582     aml_append(var, arg2);
 583     return var;
 584 }
 585
 586 /* helper to call method with 1 argument */
 587 Aml *aml_call0(const char *method)
 588 {
 589     Aml *var = aml_alloc();
 590     build_append_namestring(var->buf, "%s", method);
 591     return var;
 592 }
 593
 594 /* helper to call method with 1 argument */
 595 Aml *aml_call1(const char *method, Aml *arg1)
 596 {
 597     Aml *var = aml_alloc();
 598     build_append_namestring(var->buf, "%s", method);
 599     aml_append(var, arg1);
 600     return var;
 601 }
 602
 603 /* helper to call method with 2 arguments */
 604 Aml *aml_call2(const char *method, Aml *arg1, Aml *arg2)
 605 {
 606     Aml *var = aml_alloc();
 607     build_append_namestring(var->buf, "%s", method);
 608     aml_append(var, arg1);
 609     aml_append(var, arg2);
 610     return var;
 611 }
 612
 613 /* helper to call method with 3 arguments */
 614 Aml *aml_call3(const char *method, Aml *arg1, Aml *arg2, Aml *arg3)
 615 {
 616     Aml *var = aml_alloc();
 617     build_append_namestring(var->buf, "%s", method);
 618     aml_append(var, arg1);
 619     aml_append(var, arg2);
 620     aml_append(var, arg3);
 621     return var;
 622 }
 623
 624 /* helper to call method with 4 arguments */
 625 Aml *aml_call4(const char *method, Aml *arg1, Aml *arg2, Aml *arg3, Aml *arg4)
 626 {
 627     Aml *var = aml_alloc();
 628     build_append_namestring(var->buf, "%s", method);
 629     aml_append(var, arg1);
 630     aml_append(var, arg2);
 631     aml_append(var, arg3);
 632     aml_append(var, arg4);
 633     return var;
 634 }
 635
 636 /*
 637  * ACPI 5.0: 6.4.3.8.1 GPIO Connection Descriptor
 638  * Type 1, Large Item Name 0xC
 639  */
 640
 641 static Aml *aml_gpio_connection(AmlGpioConnectionType type,
 642                                 AmlConsumerAndProducer con_and_pro,
 643                                 uint8_t flags, AmlPinConfig pin_config,
 644                                 uint16_t output_drive,
 645                                 uint16_t debounce_timeout,
 646                                 const uint32_t pin_list[], uint32_t pin_count,
 647                                 const char *resource_source_name,
 648                                 const uint8_t *vendor_data,
 649                                 uint16_t vendor_data_len)
 650 {
 651     Aml *var = aml_alloc();
 652     const uint16_t min_desc_len = 0x16;
 653     uint16_t resource_source_name_len, length;
 654     uint16_t pin_table_offset, resource_source_name_offset, vendor_data_offset;
 655     uint32_t i;
 656
 657     assert(resource_source_name);
 658     resource_source_name_len = strlen(resource_source_name) + 1;
 659     length = min_desc_len + resource_source_name_len + vendor_data_len;
 660     pin_table_offset = min_desc_len + 1;
 661     resource_source_name_offset = pin_table_offset + pin_count * 2;
 662     vendor_data_offset = resource_source_name_offset + resource_source_name_len;
 663
 664     build_append_byte(var->buf, 0x8C);  /* GPIO Connection Descriptor */
 665     build_append_int_noprefix(var->buf, length, 2); /* Length */
 666     build_append_byte(var->buf, 1);     /* Revision ID */
 667     build_append_byte(var->buf, type);  /* GPIO Connection Type */
 668     /* General Flags (2 bytes) */
 669     build_append_int_noprefix(var->buf, con_and_pro, 2);
 670     /* Interrupt and IO Flags (2 bytes) */
 671     build_append_int_noprefix(var->buf, flags, 2);
 672     /* Pin Configuration 0 = Default 1 = Pull-up 2 = Pull-down 3 = No Pull */
 673     build_append_byte(var->buf, pin_config);
 674     /* Output Drive Strength (2 bytes) */
 675     build_append_int_noprefix(var->buf, output_drive, 2);
 676     /* Debounce Timeout (2 bytes) */
 677     build_append_int_noprefix(var->buf, debounce_timeout, 2);
 678     /* Pin Table Offset (2 bytes) */
 679     build_append_int_noprefix(var->buf, pin_table_offset, 2);
 680     build_append_byte(var->buf, 0);     /* Resource Source Index */
 681     /* Resource Source Name Offset (2 bytes) */
 682     build_append_int_noprefix(var->buf, resource_source_name_offset, 2);
 683     /* Vendor Data Offset (2 bytes) */
 684     build_append_int_noprefix(var->buf, vendor_data_offset, 2);
 685     /* Vendor Data Length (2 bytes) */
 686     build_append_int_noprefix(var->buf, vendor_data_len, 2);
 687     /* Pin Number (2n bytes)*/
 688     for (i = 0; i < pin_count; i++) {
 689         build_append_int_noprefix(var->buf, pin_list[i], 2);
 690     }
 691
 692     /* Resource Source Name */
 693     build_append_namestring(var->buf, "%s", resource_source_name);
 694     build_append_byte(var->buf, '\0');
 695
 696     /* Vendor-defined Data */
 697     if (vendor_data != NULL) {
 698         g_array_append_vals(var->buf, vendor_data, vendor_data_len);
 699     }
 700
 701     return var;
 702 }
 703
 704 /*
 705  * ACPI 5.0: 19.5.53
 706  * GpioInt(GPIO Interrupt Connection Resource Descriptor Macro)
 707  */
 708 Aml *aml_gpio_int(AmlConsumerAndProducer con_and_pro,
 709                   AmlLevelAndEdge edge_level,
 710                   AmlActiveHighAndLow active_level, AmlShared shared,
 711                   AmlPinConfig pin_config, uint16_t debounce_timeout,
 712                   const uint32_t pin_list[], uint32_t pin_count,
 713                   const char *resource_source_name,
 714                   const uint8_t *vendor_data, uint16_t vendor_data_len)
 715 {
 716     uint8_t flags = edge_level | (active_level << 1) | (shared << 3);
 717
 718     return aml_gpio_connection(AML_INTERRUPT_CONNECTION, con_and_pro, flags,
 719                                pin_config, 0, debounce_timeout, pin_list,
 720                                pin_count, resource_source_name, vendor_data,
 721                                vendor_data_len);
 722 }
 723
 724 /*
 725  * ACPI 1.0b: 6.4.3.4 32-Bit Fixed Location Memory Range Descriptor
 726  * (Type 1, Large Item Name 0x6)
 727  */
 728 Aml *aml_memory32_fixed(uint32_t addr, uint32_t size,
 729                         AmlReadAndWrite read_and_write)
 730 {
 731     Aml *var = aml_alloc();
 732     build_append_byte(var->buf, 0x86); /* Memory32Fixed Resource Descriptor */
 733     build_append_byte(var->buf, 9);    /* Length, bits[7:0] value = 9 */
 734     build_append_byte(var->buf, 0);    /* Length, bits[15:8] value = 0 */
 735     build_append_byte(var->buf, read_and_write); /* Write status, 1 rw 0 ro */
 736
 737     /* Range base address */
 738     build_append_byte(var->buf, extract32(addr, 0, 8));  /* bits[7:0] */
 739     build_append_byte(var->buf, extract32(addr, 8, 8));  /* bits[15:8] */
 740     build_append_byte(var->buf, extract32(addr, 16, 8)); /* bits[23:16] */
 741     build_append_byte(var->buf, extract32(addr, 24, 8)); /* bits[31:24] */
 742
 743     /* Range length */
 744     build_append_byte(var->buf, extract32(size, 0, 8));  /* bits[7:0] */
 745     build_append_byte(var->buf, extract32(size, 8, 8));  /* bits[15:8] */
 746     build_append_byte(var->buf, extract32(size, 16, 8)); /* bits[23:16] */
 747     build_append_byte(var->buf, extract32(size, 24, 8)); /* bits[31:24] */
 748     return var;
 749 }
 750
 751 /*
 752  * ACPI 5.0: 6.4.3.6 Extended Interrupt Descriptor
 753  * Type 1, Large Item Name 0x9
 754  */
 755 Aml *aml_interrupt(AmlConsumerAndProducer con_and_pro,
 756                    AmlLevelAndEdge level_and_edge,
 757                    AmlActiveHighAndLow high_and_low, AmlShared shared,
 758                    uint32_t *irq_list, uint8_t irq_count)
 759 {
 760     int i;
 761     Aml *var = aml_alloc();
 762     uint8_t irq_flags = con_and_pro | (level_and_edge << 1)
 763                         | (high_and_low << 2) | (shared << 3);
 764     const int header_bytes_in_len = 2;
 765     uint16_t len = header_bytes_in_len + irq_count * sizeof(uint32_t);
 766
 767     assert(irq_count > 0);
 768
 769     build_append_byte(var->buf, 0x89); /* Extended irq descriptor */
 770     build_append_byte(var->buf, len & 0xFF); /* Length, bits[7:0] */
 771     build_append_byte(var->buf, len >> 8); /* Length, bits[15:8] */
 772     build_append_byte(var->buf, irq_flags); /* Interrupt Vector Information. */
 773     build_append_byte(var->buf, irq_count);   /* Interrupt table length */
 774
 775     /* Interrupt Number List */
 776     for (i = 0; i < irq_count; i++) {
 777         build_append_int_noprefix(var->buf, irq_list[i], 4);
 778     }
 779     return var;
 780 }
 781
 782 /* ACPI 1.0b: 6.4.2.5 I/O Port Descriptor */
 783 Aml *aml_io(AmlIODecode dec, uint16_t min_base, uint16_t max_base,
 784             uint8_t aln, uint8_t len)
 785 {
 786     Aml *var = aml_alloc();
 787     build_append_byte(var->buf, 0x47); /* IO port descriptor */
 788     build_append_byte(var->buf, dec);
 789     build_append_byte(var->buf, min_base & 0xff);
 790     build_append_byte(var->buf, (min_base >> 8) & 0xff);
 791     build_append_byte(var->buf, max_base & 0xff);
 792     build_append_byte(var->buf, (max_base >> 8) & 0xff);
 793     build_append_byte(var->buf, aln);
 794     build_append_byte(var->buf, len);
 795     return var;
 796 }
 797
 798 /*
 799  * ACPI 1.0b: 6.4.2.1.1 ASL Macro for IRQ Descriptor
 800  *
 801  * More verbose description at:
 802  * ACPI 5.0: 19.5.64 IRQNoFlags (Interrupt Resource Descriptor Macro)
 803  *           6.4.2.1 IRQ Descriptor
 804  */
 805 Aml *aml_irq_no_flags(uint8_t irq)
 806 {
 807     uint16_t irq_mask;
 808     Aml *var = aml_alloc();
 809
 810     assert(irq < 16);
 811     build_append_byte(var->buf, 0x22); /* IRQ descriptor 2 byte form */
 812
 813     irq_mask = 1U << irq;
 814     build_append_byte(var->buf, irq_mask & 0xFF); /* IRQ mask bits[7:0] */
 815     build_append_byte(var->buf, irq_mask >> 8); /* IRQ mask bits[15:8] */
 816     return var;
 817 }
 818
 819 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLNot */
 820 Aml *aml_lnot(Aml *arg)
 821 {
 822     Aml *var = aml_opcode(0x92 /* LNotOp */);
 823     aml_append(var, arg);
 824     return var;
 825 }
 826
 827 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLEqual */
 828 Aml *aml_equal(Aml *arg1, Aml *arg2)
 829 {
 830     Aml *var = aml_opcode(0x93 /* LequalOp */);
 831     aml_append(var, arg1);
 832     aml_append(var, arg2);
 833     return var;
 834 }
 835
 836 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLGreater */
 837 Aml *aml_lgreater(Aml *arg1, Aml *arg2)
 838 {
 839     Aml *var = aml_opcode(0x94 /* LGreaterOp */);
 840     aml_append(var, arg1);
 841     aml_append(var, arg2);
 842     return var;
 843 }
 844
 845 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLGreaterEqual */
 846 Aml *aml_lgreater_equal(Aml *arg1, Aml *arg2)
 847 {
 848     /* LGreaterEqualOp := LNotOp LLessOp */
 849     Aml *var = aml_opcode(0x92 /* LNotOp */);
 850     build_append_byte(var->buf, 0x95 /* LLessOp */);
 851     aml_append(var, arg1);
 852     aml_append(var, arg2);
 853     return var;
 854 }
 855
 856 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefIfElse */
 857 Aml *aml_if(Aml *predicate)
 858 {
 859     Aml *var = aml_bundle(0xA0 /* IfOp */, AML_PACKAGE);
 860     aml_append(var, predicate);
 861     return var;
 862 }
 863
 864 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefElse */
 865 Aml *aml_else(void)
 866 {
 867     Aml *var = aml_bundle(0xA1 /* ElseOp */, AML_PACKAGE);
 868     return var;
 869 }
 870
 871 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefWhile */
 872 Aml *aml_while(Aml *predicate)
 873 {
 874     Aml *var = aml_bundle(0xA2 /* WhileOp */, AML_PACKAGE);
 875     aml_append(var, predicate);
 876     return var;
 877 }
 878
 879 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefMethod */
 880 Aml *aml_method(const char *name, int arg_count, AmlSerializeFlag sflag)
 881 {
 882     Aml *var = aml_bundle(0x14 /* MethodOp */, AML_PACKAGE);
 883     int methodflags;
 884
 885     /*
 886      * MethodFlags:
 887      *   bit 0-2: ArgCount (0-7)
 888      *   bit 3: SerializeFlag
 889      *     0: NotSerialized
 890      *     1: Serialized
 891      *   bit 4-7: reserved (must be 0)
 892      */
 893     assert(arg_count < 8);
 894     methodflags = arg_count | (sflag << 3);
 895
 896     build_append_namestring(var->buf, "%s", name);
 897     build_append_byte(var->buf, methodflags); /* MethodFlags: ArgCount */
 898     return var;
 899 }
 900
 901 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefDevice */
 902 Aml *aml_device(const char *name_format, ...)
 903 {
 904     va_list ap;
 905     Aml *var = aml_bundle(0x82 /* DeviceOp */, AML_EXT_PACKAGE);
 906     va_start(ap, name_format);
 907     build_append_namestringv(var->buf, name_format, ap);
 908     va_end(ap);
 909     return var;
 910 }
 911
 912 /* ACPI 1.0b: 6.4.1 ASL Macros for Resource Descriptors */
 913 Aml *aml_resource_template(void)
 914 {
 915     /* ResourceTemplate is a buffer of Resources with EndTag at the end */
 916     Aml *var = aml_bundle(0x11 /* BufferOp */, AML_RES_TEMPLATE);
 917     return var;
 918 }
 919
 920 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefBuffer
 921  * Pass byte_list as NULL to request uninitialized buffer to reserve space.
 922  */
 923 Aml *aml_buffer(int buffer_size, uint8_t *byte_list)
 924 {
 925     int i;
 926     Aml *var = aml_bundle(0x11 /* BufferOp */, AML_BUFFER);
 927
 928     for (i = 0; i < buffer_size; i++) {
 929         if (byte_list == NULL) {
 930             build_append_byte(var->buf, 0x0);
 931         } else {
 932             build_append_byte(var->buf, byte_list[i]);
 933         }
 934     }
 935
 936     return var;
 937 }
 938
 939 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefPackage */
 940 Aml *aml_package(uint8_t num_elements)
 941 {
 942     Aml *var = aml_bundle(0x12 /* PackageOp */, AML_PACKAGE);
 943     build_append_byte(var->buf, num_elements);
 944     return var;
 945 }
 946
 947 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefOpRegion */
 948 Aml *aml_operation_region(const char *name, AmlRegionSpace rs,
 949                           uint32_t offset, uint32_t len)
 950 {
 951     Aml *var = aml_alloc();
 952     build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */
 953     build_append_byte(var->buf, 0x80); /* OpRegionOp */
 954     build_append_namestring(var->buf, "%s", name);
 955     build_append_byte(var->buf, rs);
 956     build_append_int(var->buf, offset);
 957     build_append_int(var->buf, len);
 958     return var;
 959 }
 960
 961 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: NamedField */
 962 Aml *aml_named_field(const char *name, unsigned length)
 963 {
 964     Aml *var = aml_alloc();
 965     build_append_nameseg(var->buf, name);
 966     build_append_pkg_length(var->buf, length, false);
 967     return var;
 968 }
 969
 970 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: ReservedField */
 971 Aml *aml_reserved_field(unsigned length)
 972 {
 973     Aml *var = aml_alloc();
 974     /* ReservedField  := 0x00 PkgLength */
 975     build_append_byte(var->buf, 0x00);
 976     build_append_pkg_length(var->buf, length, false);
 977     return var;
 978 }
 979
 980 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefField */
 981 Aml *aml_field(const char *name, AmlAccessType type, AmlLockRule lock,
 982                AmlUpdateRule rule)
 983 {
 984     Aml *var = aml_bundle(0x81 /* FieldOp */, AML_EXT_PACKAGE);
 985     uint8_t flags = rule << 5 | type;
 986
 987     flags |= lock << 4; /* LockRule at 4 bit offset */
 988
 989     build_append_namestring(var->buf, "%s", name);
 990     build_append_byte(var->buf, flags);
 991     return var;
 992 }
 993
 994 static
 995 Aml *create_field_common(int opcode, Aml *srcbuf, Aml *index, const char *name)
 996 {
 997     Aml *var = aml_opcode(opcode);
 998     aml_append(var, srcbuf);
 999     aml_append(var, index);
1000     build_append_namestring(var->buf, "%s", name);
1001     return var;
1002 }
1003
1004 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefCreateDWordField */
1005 Aml *aml_create_dword_field(Aml *srcbuf, Aml *index, const char *name)
1006 {
1007     return create_field_common(0x8A /* CreateDWordFieldOp */,
1008                                srcbuf, index, name);
1009 }
1010
1011 /* ACPI 2.0a: 17.2.4.2 Named Objects Encoding: DefCreateQWordField */
1012 Aml *aml_create_qword_field(Aml *srcbuf, Aml *index, const char *name)
1013 {
1014     return create_field_common(0x8F /* CreateQWordFieldOp */,
1015                                srcbuf, index, name);
1016 }
1017
1018 /* ACPI 1.0b: 16.2.3 Data Objects Encoding: String */
1019 Aml *aml_string(const char *name_format, ...)
1020 {
1021     Aml *var = aml_opcode(0x0D /* StringPrefix */);
1022     va_list ap;
1023     char *s;
1024     int len;
1025
1026     va_start(ap, name_format);
1027     len = g_vasprintf(&s, name_format, ap);
1028     va_end(ap);
1029
1030     g_array_append_vals(var->buf, s, len + 1);
1031     g_free(s);
1032
1033     return var;
1034 }
1035
1036 /* ACPI 1.0b: 16.2.6.2 Local Objects Encoding */
1037 Aml *aml_local(int num)
1038 {
1039     Aml *var;
1040     uint8_t op = 0x60 /* Local0Op */ + num;
1041
1042     assert(num <= 7);
1043     var = aml_opcode(op);
1044     return var;
1045 }
1046
1047 /* ACPI 2.0a: 17.2.2 Data Objects Encoding: DefVarPackage */
1048 Aml *aml_varpackage(uint32_t num_elements)
1049 {
1050     Aml *var = aml_bundle(0x13 /* VarPackageOp */, AML_PACKAGE);
1051     build_append_int(var->buf, num_elements);
1052     return var;
1053 }
1054
1055 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefProcessor */
1056 Aml *aml_processor(uint8_t proc_id, uint32_t pblk_addr, uint8_t pblk_len,
1057                    const char *name_format, ...)
1058 {
1059     va_list ap;
1060     Aml *var = aml_bundle(0x83 /* ProcessorOp */, AML_EXT_PACKAGE);
1061     va_start(ap, name_format);
1062     build_append_namestringv(var->buf, name_format, ap);
1063     va_end(ap);
1064     build_append_byte(var->buf, proc_id); /* ProcID */
1065     build_append_int_noprefix(var->buf, pblk_addr, sizeof(pblk_addr));
1066     build_append_byte(var->buf, pblk_len); /* PblkLen */
1067     return var;
1068 }
1069
1070 static uint8_t Hex2Digit(char c)
1071 {
1072     if (c >= 'A') {
1073         return c - 'A' + 10;
1074     }
1075
1076     return c - '0';
1077 }
1078
1079 /* ACPI 1.0b: 15.2.3.6.4.1 EISAID Macro - Convert EISA ID String To Integer */
1080 Aml *aml_eisaid(const char *str)
1081 {
1082     Aml *var = aml_alloc();
1083     uint32_t id;
1084
1085     g_assert(strlen(str) == 7);
1086     id = (str[0] - 0x40) << 26 |
1087     (str[1] - 0x40) << 21 |
1088     (str[2] - 0x40) << 16 |
1089     Hex2Digit(str[3]) << 12 |
1090     Hex2Digit(str[4]) << 8 |
1091     Hex2Digit(str[5]) << 4 |
1092     Hex2Digit(str[6]);
1093
1094     build_append_byte(var->buf, 0x0C); /* DWordPrefix */
1095     build_append_int_noprefix(var->buf, bswap32(id), sizeof(id));
1096     return var;
1097 }
1098
1099 /* ACPI 1.0b: 6.4.3.5.5 Word Address Space Descriptor: bytes 3-5 */
1100 static Aml *aml_as_desc_header(AmlResourceType type, AmlMinFixed min_fixed,
1101                                AmlMaxFixed max_fixed, AmlDecode dec,
1102                                uint8_t type_flags)
1103 {
1104     uint8_t flags = max_fixed | min_fixed | dec;
1105     Aml *var = aml_alloc();
1106
1107     build_append_byte(var->buf, type);
1108     build_append_byte(var->buf, flags);
1109     build_append_byte(var->buf, type_flags); /* Type Specific Flags */
1110     return var;
1111 }
1112
1113 /* ACPI 1.0b: 6.4.3.5.5 Word Address Space Descriptor */
1114 static Aml *aml_word_as_desc(AmlResourceType type, AmlMinFixed min_fixed,
1115                              AmlMaxFixed max_fixed, AmlDecode dec,
1116                              uint16_t addr_gran, uint16_t addr_min,
1117                              uint16_t addr_max, uint16_t addr_trans,
1118                              uint16_t len, uint8_t type_flags)
1119 {
1120     Aml *var = aml_alloc();
1121
1122     build_append_byte(var->buf, 0x88); /* Word Address Space Descriptor */
1123     /* minimum length since we do not encode optional fields */
1124     build_append_byte(var->buf, 0x0D);
1125     build_append_byte(var->buf, 0x0);
1126
1127     aml_append(var,
1128         aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags));
1129     build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran));
1130     build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min));
1131     build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max));
1132     build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans));
1133     build_append_int_noprefix(var->buf, len, sizeof(len));
1134     return var;
1135 }
1136
1137 /* ACPI 1.0b: 6.4.3.5.3 DWord Address Space Descriptor */
1138 static Aml *aml_dword_as_desc(AmlResourceType type, AmlMinFixed min_fixed,
1139                               AmlMaxFixed max_fixed, AmlDecode dec,
1140                               uint32_t addr_gran, uint32_t addr_min,
1141                               uint32_t addr_max, uint32_t addr_trans,
1142                               uint32_t len, uint8_t type_flags)
1143 {
1144     Aml *var = aml_alloc();
1145
1146     build_append_byte(var->buf, 0x87); /* DWord Address Space Descriptor */
1147     /* minimum length since we do not encode optional fields */
1148     build_append_byte(var->buf, 23);
1149     build_append_byte(var->buf, 0x0);
1150
1151
1152     aml_append(var,
1153         aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags));
1154     build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran));
1155     build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min));
1156     build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max));
1157     build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans));
1158     build_append_int_noprefix(var->buf, len, sizeof(len));
1159     return var;
1160 }
1161
1162 /* ACPI 1.0b: 6.4.3.5.1 QWord Address Space Descriptor */
1163 static Aml *aml_qword_as_desc(AmlResourceType type, AmlMinFixed min_fixed,
1164                               AmlMaxFixed max_fixed, AmlDecode dec,
1165                               uint64_t addr_gran, uint64_t addr_min,
1166                               uint64_t addr_max, uint64_t addr_trans,
1167                               uint64_t len, uint8_t type_flags)
1168 {
1169     Aml *var = aml_alloc();
1170
1171     build_append_byte(var->buf, 0x8A); /* QWord Address Space Descriptor */
1172     /* minimum length since we do not encode optional fields */
1173     build_append_byte(var->buf, 0x2B);
1174     build_append_byte(var->buf, 0x0);
1175
1176     aml_append(var,
1177         aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags));
1178     build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran));
1179     build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min));
1180     build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max));
1181     build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans));
1182     build_append_int_noprefix(var->buf, len, sizeof(len));
1183     return var;
1184 }
1185
1186 /*
1187  * ACPI 1.0b: 6.4.3.5.6 ASL Macros for WORD Address Descriptor
1188  *
1189  * More verbose description at:
1190  * ACPI 5.0: 19.5.141 WordBusNumber (Word Bus Number Resource Descriptor Macro)
1191  */
1192 Aml *aml_word_bus_number(AmlMinFixed min_fixed, AmlMaxFixed max_fixed,
1193                          AmlDecode dec, uint16_t addr_gran,
1194                          uint16_t addr_min, uint16_t addr_max,
1195                          uint16_t addr_trans, uint16_t len)
1196
1197 {
1198     return aml_word_as_desc(AML_BUS_NUMBER_RANGE, min_fixed, max_fixed, dec,
1199                             addr_gran, addr_min, addr_max, addr_trans, len, 0);
1200 }
1201
1202 /*
1203  * ACPI 1.0b: 6.4.3.5.6 ASL Macros for WORD Address Descriptor
1204  *
1205  * More verbose description at:
1206  * ACPI 5.0: 19.5.142 WordIO (Word IO Resource Descriptor Macro)
1207  */
1208 Aml *aml_word_io(AmlMinFixed min_fixed, AmlMaxFixed max_fixed,
1209                  AmlDecode dec, AmlISARanges isa_ranges,
1210                  uint16_t addr_gran, uint16_t addr_min,
1211                  uint16_t addr_max, uint16_t addr_trans,
1212                  uint16_t len)
1213
1214 {
1215     return aml_word_as_desc(AML_IO_RANGE, min_fixed, max_fixed, dec,
1216                             addr_gran, addr_min, addr_max, addr_trans, len,
1217                             isa_ranges);
1218 }
1219
1220 /*
1221  * ACPI 1.0b: 6.4.3.5.4 ASL Macros for DWORD Address Descriptor
1222  *
1223  * More verbose description at:
1224  * ACPI 5.0: 19.5.33 DWordIO (DWord IO Resource Descriptor Macro)
1225  */
1226 Aml *aml_dword_io(AmlMinFixed min_fixed, AmlMaxFixed max_fixed,
1227                  AmlDecode dec, AmlISARanges isa_ranges,
1228                  uint32_t addr_gran, uint32_t addr_min,
1229                  uint32_t addr_max, uint32_t addr_trans,
1230                  uint32_t len)
1231
1232 {
1233     return aml_dword_as_desc(AML_IO_RANGE, min_fixed, max_fixed, dec,
1234                             addr_gran, addr_min, addr_max, addr_trans, len,
1235                             isa_ranges);
1236 }
1237
1238 /*
1239  * ACPI 1.0b: 6.4.3.5.4 ASL Macros for DWORD Address Space Descriptor
1240  *
1241  * More verbose description at:
1242  * ACPI 5.0: 19.5.34 DWordMemory (DWord Memory Resource Descriptor Macro)
1243  */
1244 Aml *aml_dword_memory(AmlDecode dec, AmlMinFixed min_fixed,
1245                       AmlMaxFixed max_fixed, AmlCacheable cacheable,
1246                       AmlReadAndWrite read_and_write,
1247                       uint32_t addr_gran, uint32_t addr_min,
1248                       uint32_t addr_max, uint32_t addr_trans,
1249                       uint32_t len)
1250 {
1251     uint8_t flags = read_and_write | (cacheable << 1);
1252
1253     return aml_dword_as_desc(AML_MEMORY_RANGE, min_fixed, max_fixed,
1254                              dec, addr_gran, addr_min, addr_max,
1255                              addr_trans, len, flags);
1256 }
1257
1258 /*
1259  * ACPI 1.0b: 6.4.3.5.2 ASL Macros for QWORD Address Space Descriptor
1260  *
1261  * More verbose description at:
1262  * ACPI 5.0: 19.5.102 QWordMemory (QWord Memory Resource Descriptor Macro)
1263  */
1264 Aml *aml_qword_memory(AmlDecode dec, AmlMinFixed min_fixed,
1265                       AmlMaxFixed max_fixed, AmlCacheable cacheable,
1266                       AmlReadAndWrite read_and_write,
1267                       uint64_t addr_gran, uint64_t addr_min,
1268                       uint64_t addr_max, uint64_t addr_trans,
1269                       uint64_t len)
1270 {
1271     uint8_t flags = read_and_write | (cacheable << 1);
1272
1273     return aml_qword_as_desc(AML_MEMORY_RANGE, min_fixed, max_fixed,
1274                              dec, addr_gran, addr_min, addr_max,
1275                              addr_trans, len, flags);
1276 }
1277
1278 /* ACPI 1.0b: 6.4.2.2 DMA Format/6.4.2.2.1 ASL Macro for DMA Descriptor */
1279 Aml *aml_dma(AmlDmaType typ, AmlDmaBusMaster bm, AmlTransferSize sz,
1280              uint8_t channel)
1281 {
1282     Aml *var = aml_alloc();
1283     uint8_t flags = sz | bm << 2 | typ << 5;
1284
1285     assert(channel < 8);
1286     build_append_byte(var->buf, 0x2A);    /* Byte 0: DMA Descriptor */
1287     build_append_byte(var->buf, 1U << channel); /* Byte 1: _DMA - DmaChannel */
1288     build_append_byte(var->buf, flags);   /* Byte 2 */
1289     return var;
1290 }
1291
1292 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefSleep */
1293 Aml *aml_sleep(uint64_t msec)
1294 {
1295     Aml *var = aml_alloc();
1296     build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */
1297     build_append_byte(var->buf, 0x22); /* SleepOp */
1298     aml_append(var, aml_int(msec));
1299     return var;
1300 }
1301
1302 static uint8_t Hex2Byte(const char *src)
1303 {
1304     int hi, lo;
1305
1306     hi = Hex2Digit(src[0]);
1307     assert(hi >= 0);
1308     assert(hi <= 15);
1309
1310     lo = Hex2Digit(src[1]);
1311     assert(lo >= 0);
1312     assert(lo <= 15);
1313     return (hi << 4) | lo;
1314 }
1315
1316 /*
1317  * ACPI 3.0: 17.5.124 ToUUID (Convert String to UUID Macro)
1318  * e.g. UUID: aabbccdd-eeff-gghh-iijj-kkllmmnnoopp
1319  * call aml_touuid("aabbccdd-eeff-gghh-iijj-kkllmmnnoopp");
1320  */
1321 Aml *aml_touuid(const char *uuid)
1322 {
1323     Aml *var = aml_bundle(0x11 /* BufferOp */, AML_BUFFER);
1324
1325     assert(strlen(uuid) == 36);
1326     assert(uuid[8] == '-');
1327     assert(uuid[13] == '-');
1328     assert(uuid[18] == '-');
1329     assert(uuid[23] == '-');
1330
1331     build_append_byte(var->buf, Hex2Byte(uuid + 6));  /* dd - at offset 00 */
1332     build_append_byte(var->buf, Hex2Byte(uuid + 4));  /* cc - at offset 01 */
1333     build_append_byte(var->buf, Hex2Byte(uuid + 2));  /* bb - at offset 02 */
1334     build_append_byte(var->buf, Hex2Byte(uuid + 0));  /* aa - at offset 03 */
1335
1336     build_append_byte(var->buf, Hex2Byte(uuid + 11)); /* ff - at offset 04 */
1337     build_append_byte(var->buf, Hex2Byte(uuid + 9));  /* ee - at offset 05 */
1338
1339     build_append_byte(var->buf, Hex2Byte(uuid + 16)); /* hh - at offset 06 */
1340     build_append_byte(var->buf, Hex2Byte(uuid + 14)); /* gg - at offset 07 */
1341
1342     build_append_byte(var->buf, Hex2Byte(uuid + 19)); /* ii - at offset 08 */
1343     build_append_byte(var->buf, Hex2Byte(uuid + 21)); /* jj - at offset 09 */
1344
1345     build_append_byte(var->buf, Hex2Byte(uuid + 24)); /* kk - at offset 10 */
1346     build_append_byte(var->buf, Hex2Byte(uuid + 26)); /* ll - at offset 11 */
1347     build_append_byte(var->buf, Hex2Byte(uuid + 28)); /* mm - at offset 12 */
1348     build_append_byte(var->buf, Hex2Byte(uuid + 30)); /* nn - at offset 13 */
1349     build_append_byte(var->buf, Hex2Byte(uuid + 32)); /* oo - at offset 14 */
1350     build_append_byte(var->buf, Hex2Byte(uuid + 34)); /* pp - at offset 15 */
1351
1352     return var;
1353 }
1354
1355 /*
1356  * ACPI 2.0b: 16.2.3.6.4.3  Unicode Macro (Convert Ascii String To Unicode)
1357  */
1358 Aml *aml_unicode(const char *str)
1359 {
1360     int i = 0;
1361     Aml *var = aml_bundle(0x11 /* BufferOp */, AML_BUFFER);
1362
1363     do {
1364         build_append_byte(var->buf, str[i]);
1365         build_append_byte(var->buf, 0);
1366         i++;
1367     } while (i <= strlen(str));
1368
1369     return var;
1370 }
1371
1372 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefDerefOf */
1373 Aml *aml_derefof(Aml *arg)
1374 {
1375     Aml *var = aml_opcode(0x83 /* DerefOfOp */);
1376     aml_append(var, arg);
1377     return var;
1378 }
1379
1380 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefSizeOf */
1381 Aml *aml_sizeof(Aml *arg)
1382 {
1383     Aml *var = aml_opcode(0x87 /* SizeOfOp */);
1384     aml_append(var, arg);
1385     return var;
1386 }
1387
1388 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefMutex */
1389 Aml *aml_mutex(const char *name, uint8_t sync_level)
1390 {
1391     Aml *var = aml_alloc();
1392     build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */
1393     build_append_byte(var->buf, 0x01); /* MutexOp */
1394     build_append_namestring(var->buf, "%s", name);
1395     assert(!(sync_level & 0xF0));
1396     build_append_byte(var->buf, sync_level);
1397     return var;
1398 }
1399
1400 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefAcquire */
1401 Aml *aml_acquire(Aml *mutex, uint16_t timeout)
1402 {
1403     Aml *var = aml_alloc();
1404     build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */
1405     build_append_byte(var->buf, 0x23); /* AcquireOp */
1406     aml_append(var, mutex);
1407     build_append_int_noprefix(var->buf, timeout, sizeof(timeout));
1408     return var;
1409 }
1410
1411 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefRelease */
1412 Aml *aml_release(Aml *mutex)
1413 {
1414     Aml *var = aml_alloc();
1415     build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */
1416     build_append_byte(var->buf, 0x27); /* ReleaseOp */
1417     aml_append(var, mutex);
1418     return var;
1419 }
1420
1421 /* ACPI 1.0b: 16.2.5.1 Name Space Modifier Objects Encoding: DefAlias */
1422 Aml *aml_alias(const char *source_object, const char *alias_object)
1423 {
1424     Aml *var = aml_opcode(0x06 /* AliasOp */);
1425     aml_append(var, aml_name("%s", source_object));
1426     aml_append(var, aml_name("%s", alias_object));
1427     return var;
1428 }
1429
1430 void
1431 build_header(GArray *linker, GArray *table_data,
1432              AcpiTableHeader *h, const char *sig, int len, uint8_t rev,
1433              const char *oem_table_id)
1434 {
1435     memcpy(&h->signature, sig, 4);
1436     h->length = cpu_to_le32(len);
1437     h->revision = rev;
1438     memcpy(h->oem_id, ACPI_BUILD_APPNAME6, 6);
1439
1440     if (oem_table_id) {
1441         strncpy((char *)h->oem_table_id, oem_table_id, sizeof(h->oem_table_id));
1442     } else {
1443         memcpy(h->oem_table_id, ACPI_BUILD_APPNAME4, 4);
1444         memcpy(h->oem_table_id + 4, sig, 4);
1445     }
1446
1447     h->oem_revision = cpu_to_le32(1);
1448     memcpy(h->asl_compiler_id, ACPI_BUILD_APPNAME4, 4);
1449     h->asl_compiler_revision = cpu_to_le32(1);
1450     h->checksum = 0;
1451     /* Checksum to be filled in by Guest linker */
1452     bios_linker_loader_add_checksum(linker, ACPI_BUILD_TABLE_FILE,
1453                                     table_data->data, h, len, &h->checksum);
1454 }
1455
1456 void *acpi_data_push(GArray *table_data, unsigned size)
1457 {
1458     unsigned off = table_data->len;
1459     g_array_set_size(table_data, off + size);
1460     return table_data->data + off;
1461 }
1462
1463 unsigned acpi_data_len(GArray *table)
1464 {
1465     assert(g_array_get_element_size(table) == 1);
1466     return table->len;
1467 }
1468
1469 void acpi_add_table(GArray *table_offsets, GArray *table_data)
1470 {
1471     uint32_t offset = cpu_to_le32(table_data->len);
1472     g_array_append_val(table_offsets, offset);
1473 }
1474
1475 void acpi_build_tables_init(AcpiBuildTables *tables)
1476 {
1477     tables->rsdp = g_array_new(false, true /* clear */, 1);
1478     tables->table_data = g_array_new(false, true /* clear */, 1);
1479     tables->tcpalog = g_array_new(false, true /* clear */, 1);
1480     tables->linker = bios_linker_loader_init();
1481 }
1482
1483 void acpi_build_tables_cleanup(AcpiBuildTables *tables, bool mfre)
1484 {
1485     void *linker_data = bios_linker_loader_cleanup(tables->linker);
1486     g_free(linker_data);
1487     g_array_free(tables->rsdp, true);
1488     g_array_free(tables->table_data, true);
1489     g_array_free(tables->tcpalog, mfre);
1490 }
1491
1492 /* Build rsdt table */
1493 void
1494 build_rsdt(GArray *table_data, GArray *linker, GArray *table_offsets)
1495 {
1496     AcpiRsdtDescriptorRev1 *rsdt;
1497     size_t rsdt_len;
1498     int i;
1499     const int table_data_len = (sizeof(uint32_t) * table_offsets->len);
1500
1501     rsdt_len = sizeof(*rsdt) + table_data_len;
1502     rsdt = acpi_data_push(table_data, rsdt_len);
1503     memcpy(rsdt->table_offset_entry, table_offsets->data, table_data_len);
1504     for (i = 0; i < table_offsets->len; ++i) {
1505         /* rsdt->table_offset_entry to be filled by Guest linker */
1506         bios_linker_loader_add_pointer(linker,
1507                                        ACPI_BUILD_TABLE_FILE,
1508                                        ACPI_BUILD_TABLE_FILE,
1509                                        table_data, &rsdt->table_offset_entry[i],
1510                                        sizeof(uint32_t));
1511     }
1512     build_header(linker, table_data,
1513                  (void *)rsdt, "RSDT", rsdt_len, 1, NULL);
1514 }