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 <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 <stdio.h>
  23 #include <stdarg.h>
  24 #include <assert.h>
  25 #include <stdbool.h>
  26 #include <string.h>
  27 #include "hw/acpi/aml-build.h"
  28 #include "qemu/bswap.h"
  29
  30 static GArray *build_alloc_array(void)
  31 {
  32     return g_array_new(false, true /* clear */, 1);
  33 }
  34
  35 static void build_free_array(GArray *array)
  36 {
  37     g_array_free(array, true);
  38 }
  39
  40 static void build_prepend_byte(GArray *array, uint8_t val)
  41 {
  42     g_array_prepend_val(array, val);
  43 }
  44
  45 static void build_append_byte(GArray *array, uint8_t val)
  46 {
  47     g_array_append_val(array, val);
  48 }
  49
  50 static void build_append_array(GArray *array, GArray *val)
  51 {
  52     g_array_append_vals(array, val->data, val->len);
  53 }
  54
  55 #define ACPI_NAMESEG_LEN 4
  56
  57 static void
  58 build_append_nameseg(GArray *array, const char *seg)
  59 {
  60     /* It would be nicer to use g_string_vprintf but it's only there in 2.22 */
  61     int len;
  62
  63     len = strlen(seg);
  64     assert(len <= ACPI_NAMESEG_LEN);
  65
  66     g_array_append_vals(array, seg, len);
  67     /* Pad up to ACPI_NAMESEG_LEN characters if necessary. */
  68     g_array_append_vals(array, "____", ACPI_NAMESEG_LEN - len);
  69 }
  70
  71 static void
  72 build_append_namestringv(GArray *array, const char *format, va_list ap)
  73 {
  74     /* It would be nicer to use g_string_vprintf but it's only there in 2.22 */
  75     char *s;
  76     int len;
  77     va_list va_len;
  78     char **segs;
  79     char **segs_iter;
  80     int seg_count = 0;
  81
  82     va_copy(va_len, ap);
  83     len = vsnprintf(NULL, 0, format, va_len);
  84     va_end(va_len);
  85     len += 1;
  86     s = g_new(typeof(*s), len);
  87
  88     len = vsnprintf(s, len, format, ap);
  89
  90     segs = g_strsplit(s, ".", 0);
  91     g_free(s);
  92
  93     /* count segments */
  94     segs_iter = segs;
  95     while (*segs_iter) {
  96         ++segs_iter;
  97         ++seg_count;
  98     }
  99     /*
 100      * ACPI 5.0 spec: 20.2.2 Name Objects Encoding:
 101      * "SegCount can be from 1 to 255"
 102      */
 103     assert(seg_count > 0 && seg_count <= 255);
 104
 105     /* handle RootPath || PrefixPath */
 106     s = *segs;
 107     while (*s == '\\' || *s == '^') {
 108         build_append_byte(array, *s);
 109         ++s;
 110     }
 111
 112     switch (seg_count) {
 113     case 1:
 114         if (!*s) {
 115             build_append_byte(array, 0x00); /* NullName */
 116         } else {
 117             build_append_nameseg(array, s);
 118         }
 119         break;
 120
 121     case 2:
 122         build_append_byte(array, 0x2E); /* DualNamePrefix */
 123         build_append_nameseg(array, s);
 124         build_append_nameseg(array, segs[1]);
 125         break;
 126     default:
 127         build_append_byte(array, 0x2F); /* MultiNamePrefix */
 128         build_append_byte(array, seg_count);
 129
 130         /* handle the 1st segment manually due to prefix/root path */
 131         build_append_nameseg(array, s);
 132
 133         /* add the rest of segments */
 134         segs_iter = segs + 1;
 135         while (*segs_iter) {
 136             build_append_nameseg(array, *segs_iter);
 137             ++segs_iter;
 138         }
 139         break;
 140     }
 141     g_strfreev(segs);
 142 }
 143
 144 static void build_append_namestring(GArray *array, const char *format, ...)
 145 {
 146     va_list ap;
 147
 148     va_start(ap, format);
 149     build_append_namestringv(array, format, ap);
 150     va_end(ap);
 151 }
 152
 153 /* 5.4 Definition Block Encoding */
 154 enum {
 155     PACKAGE_LENGTH_1BYTE_SHIFT = 6, /* Up to 63 - use extra 2 bits. */
 156     PACKAGE_LENGTH_2BYTE_SHIFT = 4,
 157     PACKAGE_LENGTH_3BYTE_SHIFT = 12,
 158     PACKAGE_LENGTH_4BYTE_SHIFT = 20,
 159 };
 160
 161 static void
 162 build_prepend_package_length(GArray *package, unsigned length, bool incl_self)
 163 {
 164     uint8_t byte;
 165     unsigned length_bytes;
 166
 167     if (length + 1 < (1 << PACKAGE_LENGTH_1BYTE_SHIFT)) {
 168         length_bytes = 1;
 169     } else if (length + 2 < (1 << PACKAGE_LENGTH_3BYTE_SHIFT)) {
 170         length_bytes = 2;
 171     } else if (length + 3 < (1 << PACKAGE_LENGTH_4BYTE_SHIFT)) {
 172         length_bytes = 3;
 173     } else {
 174         length_bytes = 4;
 175     }
 176
 177     /*
 178      * NamedField uses PkgLength encoding but it doesn't include length
 179      * of PkgLength itself.
 180      */
 181     if (incl_self) {
 182         /*
 183          * PkgLength is the length of the inclusive length of the data
 184          * and PkgLength's length itself when used for terms with
 185          * explitit length.
 186          */
 187         length += length_bytes;
 188     }
 189
 190     switch (length_bytes) {
 191     case 1:
 192         byte = length;
 193         build_prepend_byte(package, byte);
 194         return;
 195     case 4:
 196         byte = length >> PACKAGE_LENGTH_4BYTE_SHIFT;
 197         build_prepend_byte(package, byte);
 198         length &= (1 << PACKAGE_LENGTH_4BYTE_SHIFT) - 1;
 199         /* fall through */
 200     case 3:
 201         byte = length >> PACKAGE_LENGTH_3BYTE_SHIFT;
 202         build_prepend_byte(package, byte);
 203         length &= (1 << PACKAGE_LENGTH_3BYTE_SHIFT) - 1;
 204         /* fall through */
 205     case 2:
 206         byte = length >> PACKAGE_LENGTH_2BYTE_SHIFT;
 207         build_prepend_byte(package, byte);
 208         length &= (1 << PACKAGE_LENGTH_2BYTE_SHIFT) - 1;
 209         /* fall through */
 210     }
 211     /*
 212      * Most significant two bits of byte zero indicate how many following bytes
 213      * are in PkgLength encoding.
 214      */
 215     byte = ((length_bytes - 1) << PACKAGE_LENGTH_1BYTE_SHIFT) | length;
 216     build_prepend_byte(package, byte);
 217 }
 218
 219 static void
 220 build_append_pkg_length(GArray *array, unsigned length, bool incl_self)
 221 {
 222     GArray *tmp = build_alloc_array();
 223
 224     build_prepend_package_length(tmp, length, incl_self);
 225     build_append_array(array, tmp);
 226     build_free_array(tmp);
 227 }
 228
 229 static void build_package(GArray *package, uint8_t op)
 230 {
 231     build_prepend_package_length(package, package->len, true);
 232     build_prepend_byte(package, op);
 233 }
 234
 235 static void build_extop_package(GArray *package, uint8_t op)
 236 {
 237     build_package(package, op);
 238     build_prepend_byte(package, 0x5B); /* ExtOpPrefix */
 239 }
 240
 241 static void build_append_int_noprefix(GArray *table, uint64_t value, int size)
 242 {
 243     int i;
 244
 245     for (i = 0; i < size; ++i) {
 246         build_append_byte(table, value & 0xFF);
 247         value = value >> 8;
 248     }
 249 }
 250
 251 static void build_append_int(GArray *table, uint64_t value)
 252 {
 253     if (value == 0x00) {
 254         build_append_byte(table, 0x00); /* ZeroOp */
 255     } else if (value == 0x01) {
 256         build_append_byte(table, 0x01); /* OneOp */
 257     } else if (value <= 0xFF) {
 258         build_append_byte(table, 0x0A); /* BytePrefix */
 259         build_append_int_noprefix(table, value, 1);
 260     } else if (value <= 0xFFFF) {
 261         build_append_byte(table, 0x0B); /* WordPrefix */
 262         build_append_int_noprefix(table, value, 2);
 263     } else if (value <= 0xFFFFFFFF) {
 264         build_append_byte(table, 0x0C); /* DWordPrefix */
 265         build_append_int_noprefix(table, value, 4);
 266     } else {
 267         build_append_byte(table, 0x0E); /* QWordPrefix */
 268         build_append_int_noprefix(table, value, 8);
 269     }
 270 }
 271
 272 static GPtrArray *alloc_list;
 273
 274 static Aml *aml_alloc(void)
 275 {
 276     Aml *var = g_new0(typeof(*var), 1);
 277
 278     g_ptr_array_add(alloc_list, var);
 279     var->block_flags = AML_NO_OPCODE;
 280     var->buf = build_alloc_array();
 281     return var;
 282 }
 283
 284 static Aml *aml_opcode(uint8_t op)
 285 {
 286     Aml *var = aml_alloc();
 287
 288     var->op  = op;
 289     var->block_flags = AML_OPCODE;
 290     return var;
 291 }
 292
 293 static Aml *aml_bundle(uint8_t op, AmlBlockFlags flags)
 294 {
 295     Aml *var = aml_alloc();
 296
 297     var->op  = op;
 298     var->block_flags = flags;
 299     return var;
 300 }
 301
 302 static void aml_free(gpointer data, gpointer user_data)
 303 {
 304     Aml *var = data;
 305     build_free_array(var->buf);
 306 }
 307
 308 Aml *init_aml_allocator(void)
 309 {
 310     Aml *var;
 311
 312     assert(!alloc_list);
 313     alloc_list = g_ptr_array_new();
 314     var = aml_alloc();
 315     return var;
 316 }
 317
 318 void free_aml_allocator(void)
 319 {
 320     g_ptr_array_foreach(alloc_list, aml_free, NULL);
 321     g_ptr_array_free(alloc_list, true);
 322     alloc_list = 0;
 323 }
 324
 325 /* pack data with DefBuffer encoding */
 326 static void build_buffer(GArray *array, uint8_t op)
 327 {
 328     GArray *data = build_alloc_array();
 329
 330     build_append_int(data, array->len);
 331     g_array_prepend_vals(array, data->data, data->len);
 332     build_free_array(data);
 333     build_package(array, op);
 334 }
 335
 336 void aml_append(Aml *parent_ctx, Aml *child)
 337 {
 338     GArray *buf = build_alloc_array();
 339     build_append_array(buf, child->buf);
 340
 341     switch (child->block_flags) {
 342     case AML_OPCODE:
 343         build_append_byte(parent_ctx->buf, child->op);
 344         break;
 345     case AML_EXT_PACKAGE:
 346         build_extop_package(buf, child->op);
 347         break;
 348     case AML_PACKAGE:
 349         build_package(buf, child->op);
 350         break;
 351     case AML_RES_TEMPLATE:
 352         build_append_byte(buf, 0x79); /* EndTag */
 353         /*
 354          * checksum operations are treated as succeeded if checksum
 355          * field is zero. [ACPI Spec 1.0b, 6.4.2.8 End Tag]
 356          */
 357         build_append_byte(buf, 0);
 358         /* fall through, to pack resources in buffer */
 359     case AML_BUFFER:
 360         build_buffer(buf, child->op);
 361         break;
 362     case AML_NO_OPCODE:
 363         break;
 364     default:
 365         assert(0);
 366         break;
 367     }
 368     build_append_array(parent_ctx->buf, buf);
 369     build_free_array(buf);
 370 }
 371
 372 /* ACPI 1.0b: 16.2.5.1 Namespace Modifier Objects Encoding: DefScope */
 373 Aml *aml_scope(const char *name_format, ...)
 374 {
 375     va_list ap;
 376     Aml *var = aml_bundle(0x10 /* ScopeOp */, AML_PACKAGE);
 377     va_start(ap, name_format);
 378     build_append_namestringv(var->buf, name_format, ap);
 379     va_end(ap);
 380     return var;
 381 }
 382
 383 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefReturn */
 384 Aml *aml_return(Aml *val)
 385 {
 386     Aml *var = aml_opcode(0xA4 /* ReturnOp */);
 387     aml_append(var, val);
 388     return var;
 389 }
 390
 391 /*
 392  * ACPI 1.0b: 16.2.3 Data Objects Encoding:
 393  * encodes: ByteConst, WordConst, DWordConst, QWordConst, ZeroOp, OneOp
 394  */
 395 Aml *aml_int(const uint64_t val)
 396 {
 397     Aml *var = aml_alloc();
 398     build_append_int(var->buf, val);
 399     return var;
 400 }
 401
 402 /*
 403  * helper to construct NameString, which returns Aml object
 404  * for using with aml_append or other aml_* terms
 405  */
 406 Aml *aml_name(const char *name_format, ...)
 407 {
 408     va_list ap;
 409     Aml *var = aml_alloc();
 410     va_start(ap, name_format);
 411     build_append_namestringv(var->buf, name_format, ap);
 412     va_end(ap);
 413     return var;
 414 }
 415
 416 /* ACPI 1.0b: 16.2.5.1 Namespace Modifier Objects Encoding: DefName */
 417 Aml *aml_name_decl(const char *name, Aml *val)
 418 {
 419     Aml *var = aml_opcode(0x08 /* NameOp */);
 420     build_append_namestring(var->buf, "%s", name);
 421     aml_append(var, val);
 422     return var;
 423 }
 424
 425 /* ACPI 1.0b: 16.2.6.1 Arg Objects Encoding */
 426 Aml *aml_arg(int pos)
 427 {
 428     Aml *var;
 429     uint8_t op = 0x68 /* ARG0 op */ + pos;
 430
 431     assert(pos <= 6);
 432     var = aml_opcode(op);
 433     return var;
 434 }
 435
 436 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefStore */
 437 Aml *aml_store(Aml *val, Aml *target)
 438 {
 439     Aml *var = aml_opcode(0x70 /* StoreOp */);
 440     aml_append(var, val);
 441     aml_append(var, target);
 442     return var;
 443 }
 444
 445 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefAnd */
 446 Aml *aml_and(Aml *arg1, Aml *arg2)
 447 {
 448     Aml *var = aml_opcode(0x7B /* AndOp */);
 449     aml_append(var, arg1);
 450     aml_append(var, arg2);
 451     build_append_byte(var->buf, 0x00 /* NullNameOp */);
 452     return var;
 453 }
 454
 455 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefNotify */
 456 Aml *aml_notify(Aml *arg1, Aml *arg2)
 457 {
 458     Aml *var = aml_opcode(0x86 /* NotifyOp */);
 459     aml_append(var, arg1);
 460     aml_append(var, arg2);
 461     return var;
 462 }
 463
 464 /* helper to call method with 1 argument */
 465 Aml *aml_call1(const char *method, Aml *arg1)
 466 {
 467     Aml *var = aml_alloc();
 468     build_append_namestring(var->buf, "%s", method);
 469     aml_append(var, arg1);
 470     return var;
 471 }
 472
 473 /* helper to call method with 2 arguments */
 474 Aml *aml_call2(const char *method, Aml *arg1, Aml *arg2)
 475 {
 476     Aml *var = aml_alloc();
 477     build_append_namestring(var->buf, "%s", method);
 478     aml_append(var, arg1);
 479     aml_append(var, arg2);
 480     return var;
 481 }
 482
 483 /* helper to call method with 3 arguments */
 484 Aml *aml_call3(const char *method, Aml *arg1, Aml *arg2, Aml *arg3)
 485 {
 486     Aml *var = aml_alloc();
 487     build_append_namestring(var->buf, "%s", method);
 488     aml_append(var, arg1);
 489     aml_append(var, arg2);
 490     aml_append(var, arg3);
 491     return var;
 492 }
 493
 494 /* helper to call method with 4 arguments */
 495 Aml *aml_call4(const char *method, Aml *arg1, Aml *arg2, Aml *arg3, Aml *arg4)
 496 {
 497     Aml *var = aml_alloc();
 498     build_append_namestring(var->buf, "%s", method);
 499     aml_append(var, arg1);
 500     aml_append(var, arg2);
 501     aml_append(var, arg3);
 502     aml_append(var, arg4);
 503     return var;
 504 }
 505
 506 /* ACPI 1.0b: 6.4.2.5 I/O Port Descriptor */
 507 Aml *aml_io(AmlIODecode dec, uint16_t min_base, uint16_t max_base,
 508             uint8_t aln, uint8_t len)
 509 {
 510     Aml *var = aml_alloc();
 511     build_append_byte(var->buf, 0x47); /* IO port descriptor */
 512     build_append_byte(var->buf, dec);
 513     build_append_byte(var->buf, min_base & 0xff);
 514     build_append_byte(var->buf, (min_base >> 8) & 0xff);
 515     build_append_byte(var->buf, max_base & 0xff);
 516     build_append_byte(var->buf, (max_base >> 8) & 0xff);
 517     build_append_byte(var->buf, aln);
 518     build_append_byte(var->buf, len);
 519     return var;
 520 }
 521
 522 /*
 523  * ACPI 1.0b: 6.4.2.1.1 ASL Macro for IRQ Descriptor
 524  *
 525  * More verbose description at:
 526  * ACPI 5.0: 19.5.64 IRQNoFlags (Interrupt Resource Descriptor Macro)
 527  *           6.4.2.1 IRQ Descriptor
 528  */
 529 Aml *aml_irq_no_flags(uint8_t irq)
 530 {
 531     uint16_t irq_mask;
 532     Aml *var = aml_alloc();
 533
 534     assert(irq < 16);
 535     build_append_byte(var->buf, 0x22); /* IRQ descriptor 2 byte form */
 536
 537     irq_mask = 1U << irq;
 538     build_append_byte(var->buf, irq_mask & 0xFF); /* IRQ mask bits[7:0] */
 539     build_append_byte(var->buf, irq_mask >> 8); /* IRQ mask bits[15:8] */
 540     return var;
 541 }
 542
 543 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefLEqual */
 544 Aml *aml_equal(Aml *arg1, Aml *arg2)
 545 {
 546     Aml *var = aml_opcode(0x93 /* LequalOp */);
 547     aml_append(var, arg1);
 548     aml_append(var, arg2);
 549     return var;
 550 }
 551
 552 /* ACPI 1.0b: 16.2.5.3 Type 1 Opcodes Encoding: DefIfElse */
 553 Aml *aml_if(Aml *predicate)
 554 {
 555     Aml *var = aml_bundle(0xA0 /* IfOp */, AML_PACKAGE);
 556     aml_append(var, predicate);
 557     return var;
 558 }
 559
 560 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefMethod */
 561 Aml *aml_method(const char *name, int arg_count)
 562 {
 563     Aml *var = aml_bundle(0x14 /* MethodOp */, AML_PACKAGE);
 564     build_append_namestring(var->buf, "%s", name);
 565     build_append_byte(var->buf, arg_count); /* MethodFlags: ArgCount */
 566     return var;
 567 }
 568
 569 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefDevice */
 570 Aml *aml_device(const char *name_format, ...)
 571 {
 572     va_list ap;
 573     Aml *var = aml_bundle(0x82 /* DeviceOp */, AML_EXT_PACKAGE);
 574     va_start(ap, name_format);
 575     build_append_namestringv(var->buf, name_format, ap);
 576     va_end(ap);
 577     return var;
 578 }
 579
 580 /* ACPI 1.0b: 6.4.1 ASL Macros for Resource Descriptors */
 581 Aml *aml_resource_template(void)
 582 {
 583     /* ResourceTemplate is a buffer of Resources with EndTag at the end */
 584     Aml *var = aml_bundle(0x11 /* BufferOp */, AML_RES_TEMPLATE);
 585     return var;
 586 }
 587
 588 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefBuffer */
 589 Aml *aml_buffer(void)
 590 {
 591     Aml *var = aml_bundle(0x11 /* BufferOp */, AML_BUFFER);
 592     return var;
 593 }
 594
 595 /* ACPI 1.0b: 16.2.5.4 Type 2 Opcodes Encoding: DefPackage */
 596 Aml *aml_package(uint8_t num_elements)
 597 {
 598     Aml *var = aml_bundle(0x12 /* PackageOp */, AML_PACKAGE);
 599     build_append_byte(var->buf, num_elements);
 600     return var;
 601 }
 602
 603 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefOpRegion */
 604 Aml *aml_operation_region(const char *name, AmlRegionSpace rs,
 605                           uint32_t offset, uint32_t len)
 606 {
 607     Aml *var = aml_alloc();
 608     build_append_byte(var->buf, 0x5B); /* ExtOpPrefix */
 609     build_append_byte(var->buf, 0x80); /* OpRegionOp */
 610     build_append_namestring(var->buf, "%s", name);
 611     build_append_byte(var->buf, rs);
 612     build_append_int(var->buf, offset);
 613     build_append_int(var->buf, len);
 614     return var;
 615 }
 616
 617 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: NamedField */
 618 Aml *aml_named_field(const char *name, unsigned length)
 619 {
 620     Aml *var = aml_alloc();
 621     build_append_nameseg(var->buf, name);
 622     build_append_pkg_length(var->buf, length, false);
 623     return var;
 624 }
 625
 626 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: ReservedField */
 627 Aml *aml_reserved_field(unsigned length)
 628 {
 629     Aml *var = aml_alloc();
 630     /* ReservedField  := 0x00 PkgLength */
 631     build_append_byte(var->buf, 0x00);
 632     build_append_pkg_length(var->buf, length, false);
 633     return var;
 634 }
 635
 636 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefField */
 637 Aml *aml_field(const char *name, AmlFieldFlags flags)
 638 {
 639     Aml *var = aml_bundle(0x81 /* FieldOp */, AML_EXT_PACKAGE);
 640     build_append_namestring(var->buf, "%s", name);
 641     build_append_byte(var->buf, flags);
 642     return var;
 643 }
 644
 645 /* ACPI 1.0b: 16.2.3 Data Objects Encoding: String */
 646 Aml *aml_string(const char *name_format, ...)
 647 {
 648     Aml *var = aml_opcode(0x0D /* StringPrefix */);
 649     va_list ap, va_len;
 650     char *s;
 651     int len;
 652
 653     va_start(ap, name_format);
 654     va_copy(va_len, ap);
 655     len = vsnprintf(NULL, 0, name_format, va_len);
 656     va_end(va_len);
 657     len += 1;
 658     s = g_new0(typeof(*s), len);
 659
 660     len = vsnprintf(s, len, name_format, ap);
 661     va_end(ap);
 662
 663     g_array_append_vals(var->buf, s, len);
 664     build_append_byte(var->buf, 0x0); /* NullChar */
 665     g_free(s);
 666
 667     return var;
 668 }
 669
 670 /* ACPI 1.0b: 16.2.6.2 Local Objects Encoding */
 671 Aml *aml_local(int num)
 672 {
 673     Aml *var;
 674     uint8_t op = 0x60 /* Local0Op */ + num;
 675
 676     assert(num <= 7);
 677     var = aml_opcode(op);
 678     return var;
 679 }
 680
 681 /* ACPI 2.0a: 17.2.2 Data Objects Encoding: DefVarPackage */
 682 Aml *aml_varpackage(uint32_t num_elements)
 683 {
 684     Aml *var = aml_bundle(0x13 /* VarPackageOp */, AML_PACKAGE);
 685     build_append_int(var->buf, num_elements);
 686     return var;
 687 }
 688
 689 /* ACPI 1.0b: 16.2.5.2 Named Objects Encoding: DefProcessor */
 690 Aml *aml_processor(uint8_t proc_id, uint32_t pblk_addr, uint8_t pblk_len,
 691                    const char *name_format, ...)
 692 {
 693     va_list ap;
 694     Aml *var = aml_bundle(0x83 /* ProcessorOp */, AML_EXT_PACKAGE);
 695     va_start(ap, name_format);
 696     build_append_namestringv(var->buf, name_format, ap);
 697     va_end(ap);
 698     build_append_byte(var->buf, proc_id); /* ProcID */
 699     build_append_int_noprefix(var->buf, pblk_addr, sizeof(pblk_addr));
 700     build_append_byte(var->buf, pblk_len); /* PblkLen */
 701     return var;
 702 }
 703
 704 static uint8_t Hex2Digit(char c)
 705 {
 706     if (c >= 'A') {
 707         return c - 'A' + 10;
 708     }
 709
 710     return c - '0';
 711 }
 712
 713 /* ACPI 1.0b: 15.2.3.6.4.1 EISAID Macro - Convert EISA ID String To Integer */
 714 Aml *aml_eisaid(const char *str)
 715 {
 716     Aml *var = aml_alloc();
 717     uint32_t id;
 718
 719     g_assert(strlen(str) == 7);
 720     id = (str[0] - 0x40) << 26 |
 721     (str[1] - 0x40) << 21 |
 722     (str[2] - 0x40) << 16 |
 723     Hex2Digit(str[3]) << 12 |
 724     Hex2Digit(str[4]) << 8 |
 725     Hex2Digit(str[5]) << 4 |
 726     Hex2Digit(str[6]);
 727
 728     build_append_byte(var->buf, 0x0C); /* DWordPrefix */
 729     build_append_int_noprefix(var->buf, bswap32(id), sizeof(id));
 730     return var;
 731 }
 732
 733 /* ACPI 1.0b: 6.4.3.5.5 Word Address Space Descriptor: bytes 3-5 */
 734 static Aml *aml_as_desc_header(AmlResourceType type, AmlMinFixed min_fixed,
 735                                AmlMaxFixed max_fixed, AmlDecode dec,
 736                                uint8_t type_flags)
 737 {
 738     uint8_t flags = max_fixed | min_fixed | dec;
 739     Aml *var = aml_alloc();
 740
 741     build_append_byte(var->buf, type);
 742     build_append_byte(var->buf, flags);
 743     build_append_byte(var->buf, type_flags); /* Type Specific Flags */
 744     return var;
 745 }
 746
 747 /* ACPI 1.0b: 6.4.3.5.5 Word Address Space Descriptor */
 748 static Aml *aml_word_as_desc(AmlResourceType type, AmlMinFixed min_fixed,
 749                              AmlMaxFixed max_fixed, AmlDecode dec,
 750                              uint16_t addr_gran, uint16_t addr_min,
 751                              uint16_t addr_max, uint16_t addr_trans,
 752                              uint16_t len, uint8_t type_flags)
 753 {
 754     Aml *var = aml_alloc();
 755
 756     build_append_byte(var->buf, 0x88); /* Word Address Space Descriptor */
 757     /* minimum length since we do not encode optional fields */
 758     build_append_byte(var->buf, 0x0D);
 759     build_append_byte(var->buf, 0x0);
 760
 761     aml_append(var,
 762         aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags));
 763     build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran));
 764     build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min));
 765     build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max));
 766     build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans));
 767     build_append_int_noprefix(var->buf, len, sizeof(len));
 768     return var;
 769 }
 770
 771 /* ACPI 1.0b: 6.4.3.5.3 DWord Address Space Descriptor */
 772 static Aml *aml_dword_as_desc(AmlResourceType type, AmlMinFixed min_fixed,
 773                               AmlMaxFixed max_fixed, AmlDecode dec,
 774                               uint32_t addr_gran, uint32_t addr_min,
 775                               uint32_t addr_max, uint32_t addr_trans,
 776                               uint32_t len, uint8_t type_flags)
 777 {
 778     Aml *var = aml_alloc();
 779
 780     build_append_byte(var->buf, 0x87); /* DWord Address Space Descriptor */
 781     /* minimum length since we do not encode optional fields */
 782     build_append_byte(var->buf, 23);
 783     build_append_byte(var->buf, 0x0);
 784
 785
 786     aml_append(var,
 787         aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags));
 788     build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran));
 789     build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min));
 790     build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max));
 791     build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans));
 792     build_append_int_noprefix(var->buf, len, sizeof(len));
 793     return var;
 794 }
 795
 796 /* ACPI 1.0b: 6.4.3.5.1 QWord Address Space Descriptor */
 797 static Aml *aml_qword_as_desc(AmlResourceType type, AmlMinFixed min_fixed,
 798                               AmlMaxFixed max_fixed, AmlDecode dec,
 799                               uint64_t addr_gran, uint64_t addr_min,
 800                               uint64_t addr_max, uint64_t addr_trans,
 801                               uint64_t len, uint8_t type_flags)
 802 {
 803     Aml *var = aml_alloc();
 804
 805     build_append_byte(var->buf, 0x8A); /* QWord Address Space Descriptor */
 806     /* minimum length since we do not encode optional fields */
 807     build_append_byte(var->buf, 0x2B);
 808     build_append_byte(var->buf, 0x0);
 809
 810     aml_append(var,
 811         aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags));
 812     build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran));
 813     build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min));
 814     build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max));
 815     build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans));
 816     build_append_int_noprefix(var->buf, len, sizeof(len));
 817     return var;
 818 }
 819
 820 /*
 821  * ACPI 1.0b: 6.4.3.5.6 ASL Macros for WORD Address Descriptor
 822  *
 823  * More verbose description at:
 824  * ACPI 5.0: 19.5.141 WordBusNumber (Word Bus Number Resource Descriptor Macro)
 825  */
 826 Aml *aml_word_bus_number(AmlMinFixed min_fixed, AmlMaxFixed max_fixed,
 827                          AmlDecode dec, uint16_t addr_gran,
 828                          uint16_t addr_min, uint16_t addr_max,
 829                          uint16_t addr_trans, uint16_t len)
 830
 831 {
 832     return aml_word_as_desc(aml_bus_number_range, min_fixed, max_fixed, dec,
 833                             addr_gran, addr_min, addr_max, addr_trans, len, 0);
 834 }
 835
 836 /*
 837  * ACPI 1.0b: 6.4.3.5.6 ASL Macros for WORD Address Descriptor
 838  *
 839  * More verbose description at:
 840  * ACPI 5.0: 19.5.142 WordIO (Word IO Resource Descriptor Macro)
 841  */
 842 Aml *aml_word_io(AmlMinFixed min_fixed, AmlMaxFixed max_fixed,
 843                  AmlDecode dec, AmlISARanges isa_ranges,
 844                  uint16_t addr_gran, uint16_t addr_min,
 845                  uint16_t addr_max, uint16_t addr_trans,
 846                  uint16_t len)
 847
 848 {
 849     return aml_word_as_desc(aml_io_range, min_fixed, max_fixed, dec,
 850                             addr_gran, addr_min, addr_max, addr_trans, len,
 851                             isa_ranges);
 852 }
 853
 854 /*
 855  * ACPI 1.0b: 6.4.3.5.4 ASL Macros for DWORD Address Space Descriptor
 856  *
 857  * More verbose description at:
 858  * ACPI 5.0: 19.5.34 DWordMemory (DWord Memory Resource Descriptor Macro)
 859  */
 860 Aml *aml_dword_memory(AmlDecode dec, AmlMinFixed min_fixed,
 861                       AmlMaxFixed max_fixed, AmlCacheble cacheable,
 862                       AmlReadAndWrite read_and_write,
 863                       uint32_t addr_gran, uint32_t addr_min,
 864                       uint32_t addr_max, uint32_t addr_trans,
 865                       uint32_t len)
 866 {
 867     uint8_t flags = read_and_write | (cacheable << 1);
 868
 869     return aml_dword_as_desc(aml_memory_range, min_fixed, max_fixed,
 870                              dec, addr_gran, addr_min, addr_max,
 871                              addr_trans, len, flags);
 872 }
 873
 874 /*
 875  * ACPI 1.0b: 6.4.3.5.2 ASL Macros for QWORD Address Space Descriptor
 876  *
 877  * More verbose description at:
 878  * ACPI 5.0: 19.5.102 QWordMemory (QWord Memory Resource Descriptor Macro)
 879  */
 880 Aml *aml_qword_memory(AmlDecode dec, AmlMinFixed min_fixed,
 881                       AmlMaxFixed max_fixed, AmlCacheble cacheable,
 882                       AmlReadAndWrite read_and_write,
 883                       uint64_t addr_gran, uint64_t addr_min,
 884                       uint64_t addr_max, uint64_t addr_trans,
 885                       uint64_t len)
 886 {
 887     uint8_t flags = read_and_write | (cacheable << 1);
 888
 889     return aml_qword_as_desc(aml_memory_range, min_fixed, max_fixed,
 890                              dec, addr_gran, addr_min, addr_max,
 891                              addr_trans, len, flags);
 892 }