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