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