?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
qapi-schema: dump-guest-memory: Improve text
[qemu/ar7.git] / hw / acpi / aml-build.c
blob78e12902086fc3356c45eb53ab90991e2f4c6eb0
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 <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 }
AR7 emulation for QEMU