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