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