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