1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
35static GArray *build_alloc_array(void)
36{
37 return g_array_new(false, true , 1);
38}
39
40static void build_free_array(GArray *array)
41{
42 g_array_free(array, true);
43}
44
45static void build_prepend_byte(GArray *array, uint8_t val)
46{
47 g_array_prepend_val(array, val);
48}
49
50static void build_append_byte(GArray *array, uint8_t val)
51{
52 g_array_append_val(array, val);
53}
54
55static void build_append_array(GArray *array, GArray *val)
56{
57 g_array_append_vals(array, val->data, val->len);
58}
59
60#define ACPI_NAMESEG_LEN 4
61
62void crs_range_insert(GPtrArray *ranges, uint64_t base, uint64_t limit)
63{
64 CrsRangeEntry *entry;
65
66 entry = g_malloc(sizeof(*entry));
67 entry->base = base;
68 entry->limit = limit;
69
70 g_ptr_array_add(ranges, entry);
71}
72
73static void crs_range_free(gpointer data)
74{
75 CrsRangeEntry *entry = (CrsRangeEntry *)data;
76 g_free(entry);
77}
78
79void crs_range_set_init(CrsRangeSet *range_set)
80{
81 range_set->io_ranges = g_ptr_array_new_with_free_func(crs_range_free);
82 range_set->mem_ranges = g_ptr_array_new_with_free_func(crs_range_free);
83 range_set->mem_64bit_ranges =
84 g_ptr_array_new_with_free_func(crs_range_free);
85}
86
87void crs_range_set_free(CrsRangeSet *range_set)
88{
89 g_ptr_array_free(range_set->io_ranges, true);
90 g_ptr_array_free(range_set->mem_ranges, true);
91 g_ptr_array_free(range_set->mem_64bit_ranges, true);
92}
93
94static gint crs_range_compare(gconstpointer a, gconstpointer b)
95{
96 CrsRangeEntry *entry_a = *(CrsRangeEntry **)a;
97 CrsRangeEntry *entry_b = *(CrsRangeEntry **)b;
98
99 if (entry_a->base < entry_b->base) {
100 return -1;
101 } else if (entry_a->base > entry_b->base) {
102 return 1;
103 } else {
104 return 0;
105 }
106}
107
108
109
110
111
112
113
114void crs_replace_with_free_ranges(GPtrArray *ranges,
115 uint64_t start, uint64_t end)
116{
117 GPtrArray *free_ranges = g_ptr_array_new();
118 uint64_t free_base = start;
119 int i;
120
121 g_ptr_array_sort(ranges, crs_range_compare);
122 for (i = 0; i < ranges->len; i++) {
123 CrsRangeEntry *used = g_ptr_array_index(ranges, i);
124
125 if (free_base < used->base) {
126 crs_range_insert(free_ranges, free_base, used->base - 1);
127 }
128
129 free_base = used->limit + 1;
130 }
131
132 if (free_base < end) {
133 crs_range_insert(free_ranges, free_base, end);
134 }
135
136 g_ptr_array_set_size(ranges, 0);
137 for (i = 0; i < free_ranges->len; i++) {
138 g_ptr_array_add(ranges, g_ptr_array_index(free_ranges, i));
139 }
140
141 g_ptr_array_free(free_ranges, true);
142}
143
144
145
146
147
148static void crs_range_merge(GPtrArray *range)
149{
150 GPtrArray *tmp = g_ptr_array_new_with_free_func(crs_range_free);
151 CrsRangeEntry *entry;
152 uint64_t range_base, range_limit;
153 int i;
154
155 if (!range->len) {
156 return;
157 }
158
159 g_ptr_array_sort(range, crs_range_compare);
160
161 entry = g_ptr_array_index(range, 0);
162 range_base = entry->base;
163 range_limit = entry->limit;
164 for (i = 1; i < range->len; i++) {
165 entry = g_ptr_array_index(range, i);
166 if (entry->base - 1 == range_limit) {
167 range_limit = entry->limit;
168 } else {
169 crs_range_insert(tmp, range_base, range_limit);
170 range_base = entry->base;
171 range_limit = entry->limit;
172 }
173 }
174 crs_range_insert(tmp, range_base, range_limit);
175
176 g_ptr_array_set_size(range, 0);
177 for (i = 0; i < tmp->len; i++) {
178 entry = g_ptr_array_index(tmp, i);
179 crs_range_insert(range, entry->base, entry->limit);
180 }
181 g_ptr_array_free(tmp, true);
182}
183
184static void
185build_append_nameseg(GArray *array, const char *seg)
186{
187 int len;
188
189 len = strlen(seg);
190 assert(len <= ACPI_NAMESEG_LEN);
191
192 g_array_append_vals(array, seg, len);
193
194 g_array_append_vals(array, "____", ACPI_NAMESEG_LEN - len);
195}
196
197static void GCC_FMT_ATTR(2, 0)
198build_append_namestringv(GArray *array, const char *format, va_list ap)
199{
200 char *s;
201 char **segs;
202 char **segs_iter;
203 int seg_count = 0;
204
205 s = g_strdup_vprintf(format, ap);
206 segs = g_strsplit(s, ".", 0);
207 g_free(s);
208
209
210 segs_iter = segs;
211 while (*segs_iter) {
212 ++segs_iter;
213 ++seg_count;
214 }
215
216
217
218
219 assert(seg_count > 0 && seg_count <= 255);
220
221
222 s = *segs;
223 while (*s == '\\' || *s == '^') {
224 build_append_byte(array, *s);
225 ++s;
226 }
227
228 switch (seg_count) {
229 case 1:
230 if (!*s) {
231 build_append_byte(array, 0x00);
232 } else {
233 build_append_nameseg(array, s);
234 }
235 break;
236
237 case 2:
238 build_append_byte(array, 0x2E);
239 build_append_nameseg(array, s);
240 build_append_nameseg(array, segs[1]);
241 break;
242 default:
243 build_append_byte(array, 0x2F);
244 build_append_byte(array, seg_count);
245
246
247 build_append_nameseg(array, s);
248
249
250 segs_iter = segs + 1;
251 while (*segs_iter) {
252 build_append_nameseg(array, *segs_iter);
253 ++segs_iter;
254 }
255 break;
256 }
257 g_strfreev(segs);
258}
259
260GCC_FMT_ATTR(2, 3)
261static void build_append_namestring(GArray *array, const char *format, ...)
262{
263 va_list ap;
264
265 va_start(ap, format);
266 build_append_namestringv(array, format, ap);
267 va_end(ap);
268}
269
270
271enum {
272 PACKAGE_LENGTH_1BYTE_SHIFT = 6,
273 PACKAGE_LENGTH_2BYTE_SHIFT = 4,
274 PACKAGE_LENGTH_3BYTE_SHIFT = 12,
275 PACKAGE_LENGTH_4BYTE_SHIFT = 20,
276};
277
278static void
279build_prepend_package_length(GArray *package, unsigned length, bool incl_self)
280{
281 uint8_t byte;
282 unsigned length_bytes;
283
284 if (length + 1 < (1 << PACKAGE_LENGTH_1BYTE_SHIFT)) {
285 length_bytes = 1;
286 } else if (length + 2 < (1 << PACKAGE_LENGTH_3BYTE_SHIFT)) {
287 length_bytes = 2;
288 } else if (length + 3 < (1 << PACKAGE_LENGTH_4BYTE_SHIFT)) {
289 length_bytes = 3;
290 } else {
291 length_bytes = 4;
292 }
293
294
295
296
297
298 if (incl_self) {
299
300
301
302
303
304 length += length_bytes;
305 }
306
307 switch (length_bytes) {
308 case 1:
309 byte = length;
310 build_prepend_byte(package, byte);
311 return;
312 case 4:
313 byte = length >> PACKAGE_LENGTH_4BYTE_SHIFT;
314 build_prepend_byte(package, byte);
315 length &= (1 << PACKAGE_LENGTH_4BYTE_SHIFT) - 1;
316
317 case 3:
318 byte = length >> PACKAGE_LENGTH_3BYTE_SHIFT;
319 build_prepend_byte(package, byte);
320 length &= (1 << PACKAGE_LENGTH_3BYTE_SHIFT) - 1;
321
322 case 2:
323 byte = length >> PACKAGE_LENGTH_2BYTE_SHIFT;
324 build_prepend_byte(package, byte);
325 length &= (1 << PACKAGE_LENGTH_2BYTE_SHIFT) - 1;
326
327 }
328
329
330
331
332 byte = ((length_bytes - 1) << PACKAGE_LENGTH_1BYTE_SHIFT) | length;
333 build_prepend_byte(package, byte);
334}
335
336static void
337build_append_pkg_length(GArray *array, unsigned length, bool incl_self)
338{
339 GArray *tmp = build_alloc_array();
340
341 build_prepend_package_length(tmp, length, incl_self);
342 build_append_array(array, tmp);
343 build_free_array(tmp);
344}
345
346static void build_package(GArray *package, uint8_t op)
347{
348 build_prepend_package_length(package, package->len, true);
349 build_prepend_byte(package, op);
350}
351
352static void build_extop_package(GArray *package, uint8_t op)
353{
354 build_package(package, op);
355 build_prepend_byte(package, 0x5B);
356}
357
358void build_append_int_noprefix(GArray *table, uint64_t value, int size)
359{
360 int i;
361
362 for (i = 0; i < size; ++i) {
363 build_append_byte(table, value & 0xFF);
364 value = value >> 8;
365 }
366}
367
368static void build_append_int(GArray *table, uint64_t value)
369{
370 if (value == 0x00) {
371 build_append_byte(table, 0x00);
372 } else if (value == 0x01) {
373 build_append_byte(table, 0x01);
374 } else if (value <= 0xFF) {
375 build_append_byte(table, 0x0A);
376 build_append_int_noprefix(table, value, 1);
377 } else if (value <= 0xFFFF) {
378 build_append_byte(table, 0x0B);
379 build_append_int_noprefix(table, value, 2);
380 } else if (value <= 0xFFFFFFFF) {
381 build_append_byte(table, 0x0C);
382 build_append_int_noprefix(table, value, 4);
383 } else {
384 build_append_byte(table, 0x0E);
385 build_append_int_noprefix(table, value, 8);
386 }
387}
388
389
390
391
392
393
394void build_append_gas(GArray *table, AmlAddressSpace as,
395 uint8_t bit_width, uint8_t bit_offset,
396 uint8_t access_width, uint64_t address)
397{
398 build_append_int_noprefix(table, as, 1);
399 build_append_int_noprefix(table, bit_width, 1);
400 build_append_int_noprefix(table, bit_offset, 1);
401 build_append_int_noprefix(table, access_width, 1);
402 build_append_int_noprefix(table, address, 8);
403}
404
405
406
407
408
409
410
411
412
413int
414build_append_named_dword(GArray *array, const char *name_format, ...)
415{
416 int offset;
417 va_list ap;
418
419 build_append_byte(array, 0x08);
420 va_start(ap, name_format);
421 build_append_namestringv(array, name_format, ap);
422 va_end(ap);
423
424 build_append_byte(array, 0x0C);
425
426 offset = array->len;
427 build_append_int_noprefix(array, 0x00000000, 4);
428 assert(array->len == offset + 4);
429
430 return offset;
431}
432
433static GPtrArray *alloc_list;
434
435static Aml *aml_alloc(void)
436{
437 Aml *var = g_new0(typeof(*var), 1);
438
439 g_ptr_array_add(alloc_list, var);
440 var->block_flags = AML_NO_OPCODE;
441 var->buf = build_alloc_array();
442 return var;
443}
444
445static Aml *aml_opcode(uint8_t op)
446{
447 Aml *var = aml_alloc();
448
449 var->op = op;
450 var->block_flags = AML_OPCODE;
451 return var;
452}
453
454static Aml *aml_bundle(uint8_t op, AmlBlockFlags flags)
455{
456 Aml *var = aml_alloc();
457
458 var->op = op;
459 var->block_flags = flags;
460 return var;
461}
462
463static void aml_free(gpointer data, gpointer user_data)
464{
465 Aml *var = data;
466 build_free_array(var->buf);
467 g_free(var);
468}
469
470Aml *init_aml_allocator(void)
471{
472 assert(!alloc_list);
473 alloc_list = g_ptr_array_new();
474 return aml_alloc();
475}
476
477void free_aml_allocator(void)
478{
479 g_ptr_array_foreach(alloc_list, aml_free, NULL);
480 g_ptr_array_free(alloc_list, true);
481 alloc_list = 0;
482}
483
484
485static void build_buffer(GArray *array, uint8_t op)
486{
487 GArray *data = build_alloc_array();
488
489 build_append_int(data, array->len);
490 g_array_prepend_vals(array, data->data, data->len);
491 build_free_array(data);
492 build_package(array, op);
493}
494
495void aml_append(Aml *parent_ctx, Aml *child)
496{
497 GArray *buf = build_alloc_array();
498 build_append_array(buf, child->buf);
499
500 switch (child->block_flags) {
501 case AML_OPCODE:
502 build_append_byte(parent_ctx->buf, child->op);
503 break;
504 case AML_EXT_PACKAGE:
505 build_extop_package(buf, child->op);
506 break;
507 case AML_PACKAGE:
508 build_package(buf, child->op);
509 break;
510 case AML_RES_TEMPLATE:
511 build_append_byte(buf, 0x79);
512
513
514
515
516 build_append_byte(buf, 0);
517
518 case AML_BUFFER:
519 build_buffer(buf, child->op);
520 break;
521 case AML_NO_OPCODE:
522 break;
523 default:
524 assert(0);
525 break;
526 }
527 build_append_array(parent_ctx->buf, buf);
528 build_free_array(buf);
529}
530
531
532Aml *aml_scope(const char *name_format, ...)
533{
534 va_list ap;
535 Aml *var = aml_bundle(0x10 , AML_PACKAGE);
536 va_start(ap, name_format);
537 build_append_namestringv(var->buf, name_format, ap);
538 va_end(ap);
539 return var;
540}
541
542
543Aml *aml_return(Aml *val)
544{
545 Aml *var = aml_opcode(0xA4 );
546 aml_append(var, val);
547 return var;
548}
549
550
551Aml *aml_debug(void)
552{
553 Aml *var = aml_alloc();
554 build_append_byte(var->buf, 0x5B);
555 build_append_byte(var->buf, 0x31);
556 return var;
557}
558
559
560
561
562
563Aml *aml_int(const uint64_t val)
564{
565 Aml *var = aml_alloc();
566 build_append_int(var->buf, val);
567 return var;
568}
569
570
571
572
573
574Aml *aml_name(const char *name_format, ...)
575{
576 va_list ap;
577 Aml *var = aml_alloc();
578 va_start(ap, name_format);
579 build_append_namestringv(var->buf, name_format, ap);
580 va_end(ap);
581 return var;
582}
583
584
585Aml *aml_name_decl(const char *name, Aml *val)
586{
587 Aml *var = aml_opcode(0x08 );
588 build_append_namestring(var->buf, "%s", name);
589 aml_append(var, val);
590 return var;
591}
592
593
594Aml *aml_arg(int pos)
595{
596 uint8_t op = 0x68 + pos;
597
598 assert(pos <= 6);
599 return aml_opcode(op);
600}
601
602
603Aml *aml_to_integer(Aml *arg)
604{
605 Aml *var = aml_opcode(0x99 );
606 aml_append(var, arg);
607 build_append_byte(var->buf, 0x00 );
608 return var;
609}
610
611
612Aml *aml_to_hexstring(Aml *src, Aml *dst)
613{
614 Aml *var = aml_opcode(0x98 );
615 aml_append(var, src);
616 if (dst) {
617 aml_append(var, dst);
618 } else {
619 build_append_byte(var->buf, 0x00 );
620 }
621 return var;
622}
623
624
625Aml *aml_to_buffer(Aml *src, Aml *dst)
626{
627 Aml *var = aml_opcode(0x96 );
628 aml_append(var, src);
629 if (dst) {
630 aml_append(var, dst);
631 } else {
632 build_append_byte(var->buf, 0x00 );
633 }
634 return var;
635}
636
637
638Aml *aml_to_decimalstring(Aml *src, Aml *dst)
639{
640 Aml *var = aml_opcode(0x97 );
641 aml_append(var, src);
642 if (dst) {
643 aml_append(var, dst);
644 } else {
645 build_append_byte(var->buf, 0x00 );
646 }
647 return var;
648}
649
650
651Aml *aml_store(Aml *val, Aml *target)
652{
653 Aml *var = aml_opcode(0x70 );
654 aml_append(var, val);
655 aml_append(var, target);
656 return var;
657}
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672static Aml *
673build_opcode_2arg_dst(uint8_t op, Aml *arg1, Aml *arg2, Aml *dst)
674{
675 Aml *var = aml_opcode(op);
676 aml_append(var, arg1);
677 aml_append(var, arg2);
678 if (dst) {
679 aml_append(var, dst);
680 } else {
681 build_append_byte(var->buf, 0x00 );
682 }
683 return var;
684}
685
686
687Aml *aml_and(Aml *arg1, Aml *arg2, Aml *dst)
688{
689 return build_opcode_2arg_dst(0x7B , arg1, arg2, dst);
690}
691
692
693Aml *aml_or(Aml *arg1, Aml *arg2, Aml *dst)
694{
695 return build_opcode_2arg_dst(0x7D , arg1, arg2, dst);
696}
697
698
699Aml *aml_land(Aml *arg1, Aml *arg2)
700{
701 Aml *var = aml_opcode(0x90 );
702 aml_append(var, arg1);
703 aml_append(var, arg2);
704 return var;
705}
706
707
708Aml *aml_lor(Aml *arg1, Aml *arg2)
709{
710 Aml *var = aml_opcode(0x91 );
711 aml_append(var, arg1);
712 aml_append(var, arg2);
713 return var;
714}
715
716
717Aml *aml_shiftleft(Aml *arg1, Aml *count)
718{
719 return build_opcode_2arg_dst(0x79 , arg1, count, NULL);
720}
721
722
723Aml *aml_shiftright(Aml *arg1, Aml *count, Aml *dst)
724{
725 return build_opcode_2arg_dst(0x7A , arg1, count, dst);
726}
727
728
729Aml *aml_lless(Aml *arg1, Aml *arg2)
730{
731 Aml *var = aml_opcode(0x95 );
732 aml_append(var, arg1);
733 aml_append(var, arg2);
734 return var;
735}
736
737
738Aml *aml_add(Aml *arg1, Aml *arg2, Aml *dst)
739{
740 return build_opcode_2arg_dst(0x72 , arg1, arg2, dst);
741}
742
743
744Aml *aml_subtract(Aml *arg1, Aml *arg2, Aml *dst)
745{
746 return build_opcode_2arg_dst(0x74 , arg1, arg2, dst);
747}
748
749
750Aml *aml_increment(Aml *arg)
751{
752 Aml *var = aml_opcode(0x75 );
753 aml_append(var, arg);
754 return var;
755}
756
757
758Aml *aml_decrement(Aml *arg)
759{
760 Aml *var = aml_opcode(0x76 );
761 aml_append(var, arg);
762 return var;
763}
764
765
766Aml *aml_index(Aml *arg1, Aml *idx)
767{
768 return build_opcode_2arg_dst(0x88 , arg1, idx, NULL);
769}
770
771
772Aml *aml_notify(Aml *arg1, Aml *arg2)
773{
774 Aml *var = aml_opcode(0x86 );
775 aml_append(var, arg1);
776 aml_append(var, arg2);
777 return var;
778}
779
780
781Aml *aml_break(void)
782{
783 Aml *var = aml_opcode(0xa5 );
784 return var;
785}
786
787
788Aml *aml_call0(const char *method)
789{
790 Aml *var = aml_alloc();
791 build_append_namestring(var->buf, "%s", method);
792 return var;
793}
794
795
796Aml *aml_call1(const char *method, Aml *arg1)
797{
798 Aml *var = aml_alloc();
799 build_append_namestring(var->buf, "%s", method);
800 aml_append(var, arg1);
801 return var;
802}
803
804
805Aml *aml_call2(const char *method, Aml *arg1, Aml *arg2)
806{
807 Aml *var = aml_alloc();
808 build_append_namestring(var->buf, "%s", method);
809 aml_append(var, arg1);
810 aml_append(var, arg2);
811 return var;
812}
813
814
815Aml *aml_call3(const char *method, Aml *arg1, Aml *arg2, Aml *arg3)
816{
817 Aml *var = aml_alloc();
818 build_append_namestring(var->buf, "%s", method);
819 aml_append(var, arg1);
820 aml_append(var, arg2);
821 aml_append(var, arg3);
822 return var;
823}
824
825
826Aml *aml_call4(const char *method, Aml *arg1, Aml *arg2, Aml *arg3, Aml *arg4)
827{
828 Aml *var = aml_alloc();
829 build_append_namestring(var->buf, "%s", method);
830 aml_append(var, arg1);
831 aml_append(var, arg2);
832 aml_append(var, arg3);
833 aml_append(var, arg4);
834 return var;
835}
836
837
838Aml *aml_call5(const char *method, Aml *arg1, Aml *arg2, Aml *arg3, Aml *arg4,
839 Aml *arg5)
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 aml_append(var, arg5);
848 return var;
849}
850
851
852Aml *aml_call6(const char *method, Aml *arg1, Aml *arg2, Aml *arg3, Aml *arg4,
853 Aml *arg5, Aml *arg6)
854{
855 Aml *var = aml_alloc();
856 build_append_namestring(var->buf, "%s", method);
857 aml_append(var, arg1);
858 aml_append(var, arg2);
859 aml_append(var, arg3);
860 aml_append(var, arg4);
861 aml_append(var, arg5);
862 aml_append(var, arg6);
863 return var;
864}
865
866
867
868
869
870
871static Aml *aml_gpio_connection(AmlGpioConnectionType type,
872 AmlConsumerAndProducer con_and_pro,
873 uint8_t flags, AmlPinConfig pin_config,
874 uint16_t output_drive,
875 uint16_t debounce_timeout,
876 const uint32_t pin_list[], uint32_t pin_count,
877 const char *resource_source_name,
878 const uint8_t *vendor_data,
879 uint16_t vendor_data_len)
880{
881 Aml *var = aml_alloc();
882 const uint16_t min_desc_len = 0x16;
883 uint16_t resource_source_name_len, length;
884 uint16_t pin_table_offset, resource_source_name_offset, vendor_data_offset;
885 uint32_t i;
886
887 assert(resource_source_name);
888 resource_source_name_len = strlen(resource_source_name) + 1;
889 length = min_desc_len + resource_source_name_len + vendor_data_len;
890 pin_table_offset = min_desc_len + 1;
891 resource_source_name_offset = pin_table_offset + pin_count * 2;
892 vendor_data_offset = resource_source_name_offset + resource_source_name_len;
893
894 build_append_byte(var->buf, 0x8C);
895 build_append_int_noprefix(var->buf, length, 2);
896 build_append_byte(var->buf, 1);
897 build_append_byte(var->buf, type);
898
899 build_append_int_noprefix(var->buf, con_and_pro, 2);
900
901 build_append_int_noprefix(var->buf, flags, 2);
902
903 build_append_byte(var->buf, pin_config);
904
905 build_append_int_noprefix(var->buf, output_drive, 2);
906
907 build_append_int_noprefix(var->buf, debounce_timeout, 2);
908
909 build_append_int_noprefix(var->buf, pin_table_offset, 2);
910 build_append_byte(var->buf, 0);
911
912 build_append_int_noprefix(var->buf, resource_source_name_offset, 2);
913
914 build_append_int_noprefix(var->buf, vendor_data_offset, 2);
915
916 build_append_int_noprefix(var->buf, vendor_data_len, 2);
917
918 for (i = 0; i < pin_count; i++) {
919 build_append_int_noprefix(var->buf, pin_list[i], 2);
920 }
921
922
923 build_append_namestring(var->buf, "%s", resource_source_name);
924 build_append_byte(var->buf, '\0');
925
926
927 if (vendor_data != NULL) {
928 g_array_append_vals(var->buf, vendor_data, vendor_data_len);
929 }
930
931 return var;
932}
933
934
935
936
937
938Aml *aml_gpio_int(AmlConsumerAndProducer con_and_pro,
939 AmlLevelAndEdge edge_level,
940 AmlActiveHighAndLow active_level, AmlShared shared,
941 AmlPinConfig pin_config, uint16_t debounce_timeout,
942 const uint32_t pin_list[], uint32_t pin_count,
943 const char *resource_source_name,
944 const uint8_t *vendor_data, uint16_t vendor_data_len)
945{
946 uint8_t flags = edge_level | (active_level << 1) | (shared << 3);
947
948 return aml_gpio_connection(AML_INTERRUPT_CONNECTION, con_and_pro, flags,
949 pin_config, 0, debounce_timeout, pin_list,
950 pin_count, resource_source_name, vendor_data,
951 vendor_data_len);
952}
953
954
955
956
957
958Aml *aml_memory32_fixed(uint32_t addr, uint32_t size,
959 AmlReadAndWrite read_and_write)
960{
961 Aml *var = aml_alloc();
962 build_append_byte(var->buf, 0x86);
963 build_append_byte(var->buf, 9);
964 build_append_byte(var->buf, 0);
965 build_append_byte(var->buf, read_and_write);
966
967
968 build_append_byte(var->buf, extract32(addr, 0, 8));
969 build_append_byte(var->buf, extract32(addr, 8, 8));
970 build_append_byte(var->buf, extract32(addr, 16, 8));
971 build_append_byte(var->buf, extract32(addr, 24, 8));
972
973
974 build_append_byte(var->buf, extract32(size, 0, 8));
975 build_append_byte(var->buf, extract32(size, 8, 8));
976 build_append_byte(var->buf, extract32(size, 16, 8));
977 build_append_byte(var->buf, extract32(size, 24, 8));
978 return var;
979}
980
981
982
983
984
985Aml *aml_interrupt(AmlConsumerAndProducer con_and_pro,
986 AmlLevelAndEdge level_and_edge,
987 AmlActiveHighAndLow high_and_low, AmlShared shared,
988 uint32_t *irq_list, uint8_t irq_count)
989{
990 int i;
991 Aml *var = aml_alloc();
992 uint8_t irq_flags = con_and_pro | (level_and_edge << 1)
993 | (high_and_low << 2) | (shared << 3);
994 const int header_bytes_in_len = 2;
995 uint16_t len = header_bytes_in_len + irq_count * sizeof(uint32_t);
996
997 assert(irq_count > 0);
998
999 build_append_byte(var->buf, 0x89);
1000 build_append_byte(var->buf, len & 0xFF);
1001 build_append_byte(var->buf, len >> 8);
1002 build_append_byte(var->buf, irq_flags);
1003 build_append_byte(var->buf, irq_count);
1004
1005
1006 for (i = 0; i < irq_count; i++) {
1007 build_append_int_noprefix(var->buf, irq_list[i], 4);
1008 }
1009 return var;
1010}
1011
1012
1013Aml *aml_io(AmlIODecode dec, uint16_t min_base, uint16_t max_base,
1014 uint8_t aln, uint8_t len)
1015{
1016 Aml *var = aml_alloc();
1017 build_append_byte(var->buf, 0x47);
1018 build_append_byte(var->buf, dec);
1019 build_append_byte(var->buf, min_base & 0xff);
1020 build_append_byte(var->buf, (min_base >> 8) & 0xff);
1021 build_append_byte(var->buf, max_base & 0xff);
1022 build_append_byte(var->buf, (max_base >> 8) & 0xff);
1023 build_append_byte(var->buf, aln);
1024 build_append_byte(var->buf, len);
1025 return var;
1026}
1027
1028
1029
1030
1031
1032
1033
1034
1035Aml *aml_irq_no_flags(uint8_t irq)
1036{
1037 uint16_t irq_mask;
1038 Aml *var = aml_alloc();
1039
1040 assert(irq < 16);
1041 build_append_byte(var->buf, 0x22);
1042
1043 irq_mask = 1U << irq;
1044 build_append_byte(var->buf, irq_mask & 0xFF);
1045 build_append_byte(var->buf, irq_mask >> 8);
1046 return var;
1047}
1048
1049
1050Aml *aml_lnot(Aml *arg)
1051{
1052 Aml *var = aml_opcode(0x92 );
1053 aml_append(var, arg);
1054 return var;
1055}
1056
1057
1058Aml *aml_equal(Aml *arg1, Aml *arg2)
1059{
1060 Aml *var = aml_opcode(0x93 );
1061 aml_append(var, arg1);
1062 aml_append(var, arg2);
1063 return var;
1064}
1065
1066
1067Aml *aml_lgreater(Aml *arg1, Aml *arg2)
1068{
1069 Aml *var = aml_opcode(0x94 );
1070 aml_append(var, arg1);
1071 aml_append(var, arg2);
1072 return var;
1073}
1074
1075
1076Aml *aml_lgreater_equal(Aml *arg1, Aml *arg2)
1077{
1078
1079 Aml *var = aml_opcode(0x92 );
1080 build_append_byte(var->buf, 0x95 );
1081 aml_append(var, arg1);
1082 aml_append(var, arg2);
1083 return var;
1084}
1085
1086
1087Aml *aml_if(Aml *predicate)
1088{
1089 Aml *var = aml_bundle(0xA0 , AML_PACKAGE);
1090 aml_append(var, predicate);
1091 return var;
1092}
1093
1094
1095Aml *aml_else(void)
1096{
1097 Aml *var = aml_bundle(0xA1 , AML_PACKAGE);
1098 return var;
1099}
1100
1101
1102Aml *aml_while(Aml *predicate)
1103{
1104 Aml *var = aml_bundle(0xA2 , AML_PACKAGE);
1105 aml_append(var, predicate);
1106 return var;
1107}
1108
1109
1110Aml *aml_method(const char *name, int arg_count, AmlSerializeFlag sflag)
1111{
1112 Aml *var = aml_bundle(0x14 , AML_PACKAGE);
1113 int methodflags;
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123 assert(arg_count < 8);
1124 methodflags = arg_count | (sflag << 3);
1125
1126 build_append_namestring(var->buf, "%s", name);
1127 build_append_byte(var->buf, methodflags);
1128 return var;
1129}
1130
1131
1132Aml *aml_device(const char *name_format, ...)
1133{
1134 va_list ap;
1135 Aml *var = aml_bundle(0x82 , AML_EXT_PACKAGE);
1136 va_start(ap, name_format);
1137 build_append_namestringv(var->buf, name_format, ap);
1138 va_end(ap);
1139 return var;
1140}
1141
1142
1143Aml *aml_resource_template(void)
1144{
1145
1146 Aml *var = aml_bundle(0x11 , AML_RES_TEMPLATE);
1147 return var;
1148}
1149
1150
1151
1152
1153Aml *aml_buffer(int buffer_size, uint8_t *byte_list)
1154{
1155 int i;
1156 Aml *var = aml_bundle(0x11 , AML_BUFFER);
1157
1158 for (i = 0; i < buffer_size; i++) {
1159 if (byte_list == NULL) {
1160 build_append_byte(var->buf, 0x0);
1161 } else {
1162 build_append_byte(var->buf, byte_list[i]);
1163 }
1164 }
1165
1166 return var;
1167}
1168
1169
1170Aml *aml_package(uint8_t num_elements)
1171{
1172 Aml *var = aml_bundle(0x12 , AML_PACKAGE);
1173 build_append_byte(var->buf, num_elements);
1174 return var;
1175}
1176
1177
1178Aml *aml_operation_region(const char *name, AmlRegionSpace rs,
1179 Aml *offset, uint32_t len)
1180{
1181 Aml *var = aml_alloc();
1182 build_append_byte(var->buf, 0x5B);
1183 build_append_byte(var->buf, 0x80);
1184 build_append_namestring(var->buf, "%s", name);
1185 build_append_byte(var->buf, rs);
1186 aml_append(var, offset);
1187 build_append_int(var->buf, len);
1188 return var;
1189}
1190
1191
1192Aml *aml_named_field(const char *name, unsigned length)
1193{
1194 Aml *var = aml_alloc();
1195 build_append_nameseg(var->buf, name);
1196 build_append_pkg_length(var->buf, length, false);
1197 return var;
1198}
1199
1200
1201Aml *aml_reserved_field(unsigned length)
1202{
1203 Aml *var = aml_alloc();
1204
1205 build_append_byte(var->buf, 0x00);
1206 build_append_pkg_length(var->buf, length, false);
1207 return var;
1208}
1209
1210
1211Aml *aml_field(const char *name, AmlAccessType type, AmlLockRule lock,
1212 AmlUpdateRule rule)
1213{
1214 Aml *var = aml_bundle(0x81 , AML_EXT_PACKAGE);
1215 uint8_t flags = rule << 5 | type;
1216
1217 flags |= lock << 4;
1218
1219 build_append_namestring(var->buf, "%s", name);
1220 build_append_byte(var->buf, flags);
1221 return var;
1222}
1223
1224static
1225Aml *create_field_common(int opcode, Aml *srcbuf, Aml *index, const char *name)
1226{
1227 Aml *var = aml_opcode(opcode);
1228 aml_append(var, srcbuf);
1229 aml_append(var, index);
1230 build_append_namestring(var->buf, "%s", name);
1231 return var;
1232}
1233
1234
1235Aml *aml_create_field(Aml *srcbuf, Aml *bit_index, Aml *num_bits,
1236 const char *name)
1237{
1238 Aml *var = aml_alloc();
1239 build_append_byte(var->buf, 0x5B);
1240 build_append_byte(var->buf, 0x13);
1241 aml_append(var, srcbuf);
1242 aml_append(var, bit_index);
1243 aml_append(var, num_bits);
1244 build_append_namestring(var->buf, "%s", name);
1245 return var;
1246}
1247
1248
1249Aml *aml_create_dword_field(Aml *srcbuf, Aml *index, const char *name)
1250{
1251 return create_field_common(0x8A ,
1252 srcbuf, index, name);
1253}
1254
1255
1256Aml *aml_create_qword_field(Aml *srcbuf, Aml *index, const char *name)
1257{
1258 return create_field_common(0x8F ,
1259 srcbuf, index, name);
1260}
1261
1262
1263Aml *aml_string(const char *name_format, ...)
1264{
1265 Aml *var = aml_opcode(0x0D );
1266 va_list ap;
1267 char *s;
1268 int len;
1269
1270 va_start(ap, name_format);
1271 len = g_vasprintf(&s, name_format, ap);
1272 va_end(ap);
1273
1274 g_array_append_vals(var->buf, s, len + 1);
1275 g_free(s);
1276
1277 return var;
1278}
1279
1280
1281Aml *aml_local(int num)
1282{
1283 uint8_t op = 0x60 + num;
1284
1285 assert(num <= 7);
1286 return aml_opcode(op);
1287}
1288
1289
1290Aml *aml_varpackage(uint32_t num_elements)
1291{
1292 Aml *var = aml_bundle(0x13 , AML_PACKAGE);
1293 build_append_int(var->buf, num_elements);
1294 return var;
1295}
1296
1297
1298Aml *aml_processor(uint8_t proc_id, uint32_t pblk_addr, uint8_t pblk_len,
1299 const char *name_format, ...)
1300{
1301 va_list ap;
1302 Aml *var = aml_bundle(0x83 , AML_EXT_PACKAGE);
1303 va_start(ap, name_format);
1304 build_append_namestringv(var->buf, name_format, ap);
1305 va_end(ap);
1306 build_append_byte(var->buf, proc_id);
1307 build_append_int_noprefix(var->buf, pblk_addr, sizeof(pblk_addr));
1308 build_append_byte(var->buf, pblk_len);
1309 return var;
1310}
1311
1312static uint8_t Hex2Digit(char c)
1313{
1314 if (c >= 'A') {
1315 return c - 'A' + 10;
1316 }
1317
1318 return c - '0';
1319}
1320
1321
1322Aml *aml_eisaid(const char *str)
1323{
1324 Aml *var = aml_alloc();
1325 uint32_t id;
1326
1327 g_assert(strlen(str) == 7);
1328 id = (str[0] - 0x40) << 26 |
1329 (str[1] - 0x40) << 21 |
1330 (str[2] - 0x40) << 16 |
1331 Hex2Digit(str[3]) << 12 |
1332 Hex2Digit(str[4]) << 8 |
1333 Hex2Digit(str[5]) << 4 |
1334 Hex2Digit(str[6]);
1335
1336 build_append_byte(var->buf, 0x0C);
1337 build_append_int_noprefix(var->buf, bswap32(id), sizeof(id));
1338 return var;
1339}
1340
1341
1342static Aml *aml_as_desc_header(AmlResourceType type, AmlMinFixed min_fixed,
1343 AmlMaxFixed max_fixed, AmlDecode dec,
1344 uint8_t type_flags)
1345{
1346 uint8_t flags = max_fixed | min_fixed | dec;
1347 Aml *var = aml_alloc();
1348
1349 build_append_byte(var->buf, type);
1350 build_append_byte(var->buf, flags);
1351 build_append_byte(var->buf, type_flags);
1352 return var;
1353}
1354
1355
1356static Aml *aml_word_as_desc(AmlResourceType type, AmlMinFixed min_fixed,
1357 AmlMaxFixed max_fixed, AmlDecode dec,
1358 uint16_t addr_gran, uint16_t addr_min,
1359 uint16_t addr_max, uint16_t addr_trans,
1360 uint16_t len, uint8_t type_flags)
1361{
1362 Aml *var = aml_alloc();
1363
1364 build_append_byte(var->buf, 0x88);
1365
1366 build_append_byte(var->buf, 0x0D);
1367 build_append_byte(var->buf, 0x0);
1368
1369 aml_append(var,
1370 aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags));
1371 build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran));
1372 build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min));
1373 build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max));
1374 build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans));
1375 build_append_int_noprefix(var->buf, len, sizeof(len));
1376 return var;
1377}
1378
1379
1380static Aml *aml_dword_as_desc(AmlResourceType type, AmlMinFixed min_fixed,
1381 AmlMaxFixed max_fixed, AmlDecode dec,
1382 uint32_t addr_gran, uint32_t addr_min,
1383 uint32_t addr_max, uint32_t addr_trans,
1384 uint32_t len, uint8_t type_flags)
1385{
1386 Aml *var = aml_alloc();
1387
1388 build_append_byte(var->buf, 0x87);
1389
1390 build_append_byte(var->buf, 23);
1391 build_append_byte(var->buf, 0x0);
1392
1393
1394 aml_append(var,
1395 aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags));
1396 build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran));
1397 build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min));
1398 build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max));
1399 build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans));
1400 build_append_int_noprefix(var->buf, len, sizeof(len));
1401 return var;
1402}
1403
1404
1405static Aml *aml_qword_as_desc(AmlResourceType type, AmlMinFixed min_fixed,
1406 AmlMaxFixed max_fixed, AmlDecode dec,
1407 uint64_t addr_gran, uint64_t addr_min,
1408 uint64_t addr_max, uint64_t addr_trans,
1409 uint64_t len, uint8_t type_flags)
1410{
1411 Aml *var = aml_alloc();
1412
1413 build_append_byte(var->buf, 0x8A);
1414
1415 build_append_byte(var->buf, 0x2B);
1416 build_append_byte(var->buf, 0x0);
1417
1418 aml_append(var,
1419 aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags));
1420 build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran));
1421 build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min));
1422 build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max));
1423 build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans));
1424 build_append_int_noprefix(var->buf, len, sizeof(len));
1425 return var;
1426}
1427
1428
1429
1430
1431
1432
1433
1434Aml *aml_word_bus_number(AmlMinFixed min_fixed, AmlMaxFixed max_fixed,
1435 AmlDecode dec, uint16_t addr_gran,
1436 uint16_t addr_min, uint16_t addr_max,
1437 uint16_t addr_trans, uint16_t len)
1438
1439{
1440 return aml_word_as_desc(AML_BUS_NUMBER_RANGE, min_fixed, max_fixed, dec,
1441 addr_gran, addr_min, addr_max, addr_trans, len, 0);
1442}
1443
1444
1445
1446
1447
1448
1449
1450Aml *aml_word_io(AmlMinFixed min_fixed, AmlMaxFixed max_fixed,
1451 AmlDecode dec, AmlISARanges isa_ranges,
1452 uint16_t addr_gran, uint16_t addr_min,
1453 uint16_t addr_max, uint16_t addr_trans,
1454 uint16_t len)
1455
1456{
1457 return aml_word_as_desc(AML_IO_RANGE, min_fixed, max_fixed, dec,
1458 addr_gran, addr_min, addr_max, addr_trans, len,
1459 isa_ranges);
1460}
1461
1462
1463
1464
1465
1466
1467
1468Aml *aml_dword_io(AmlMinFixed min_fixed, AmlMaxFixed max_fixed,
1469 AmlDecode dec, AmlISARanges isa_ranges,
1470 uint32_t addr_gran, uint32_t addr_min,
1471 uint32_t addr_max, uint32_t addr_trans,
1472 uint32_t len)
1473
1474{
1475 return aml_dword_as_desc(AML_IO_RANGE, min_fixed, max_fixed, dec,
1476 addr_gran, addr_min, addr_max, addr_trans, len,
1477 isa_ranges);
1478}
1479
1480
1481
1482
1483
1484
1485
1486Aml *aml_dword_memory(AmlDecode dec, AmlMinFixed min_fixed,
1487 AmlMaxFixed max_fixed, AmlCacheable cacheable,
1488 AmlReadAndWrite read_and_write,
1489 uint32_t addr_gran, uint32_t addr_min,
1490 uint32_t addr_max, uint32_t addr_trans,
1491 uint32_t len)
1492{
1493 uint8_t flags = read_and_write | (cacheable << 1);
1494
1495 return aml_dword_as_desc(AML_MEMORY_RANGE, min_fixed, max_fixed,
1496 dec, addr_gran, addr_min, addr_max,
1497 addr_trans, len, flags);
1498}
1499
1500
1501
1502
1503
1504
1505
1506Aml *aml_qword_memory(AmlDecode dec, AmlMinFixed min_fixed,
1507 AmlMaxFixed max_fixed, AmlCacheable cacheable,
1508 AmlReadAndWrite read_and_write,
1509 uint64_t addr_gran, uint64_t addr_min,
1510 uint64_t addr_max, uint64_t addr_trans,
1511 uint64_t len)
1512{
1513 uint8_t flags = read_and_write | (cacheable << 1);
1514
1515 return aml_qword_as_desc(AML_MEMORY_RANGE, min_fixed, max_fixed,
1516 dec, addr_gran, addr_min, addr_max,
1517 addr_trans, len, flags);
1518}
1519
1520
1521Aml *aml_dma(AmlDmaType typ, AmlDmaBusMaster bm, AmlTransferSize sz,
1522 uint8_t channel)
1523{
1524 Aml *var = aml_alloc();
1525 uint8_t flags = sz | bm << 2 | typ << 5;
1526
1527 assert(channel < 8);
1528 build_append_byte(var->buf, 0x2A);
1529 build_append_byte(var->buf, 1U << channel);
1530 build_append_byte(var->buf, flags);
1531 return var;
1532}
1533
1534
1535Aml *aml_sleep(uint64_t msec)
1536{
1537 Aml *var = aml_alloc();
1538 build_append_byte(var->buf, 0x5B);
1539 build_append_byte(var->buf, 0x22);
1540 aml_append(var, aml_int(msec));
1541 return var;
1542}
1543
1544static uint8_t Hex2Byte(const char *src)
1545{
1546 int hi, lo;
1547
1548 hi = Hex2Digit(src[0]);
1549 assert(hi >= 0);
1550 assert(hi <= 15);
1551
1552 lo = Hex2Digit(src[1]);
1553 assert(lo >= 0);
1554 assert(lo <= 15);
1555 return (hi << 4) | lo;
1556}
1557
1558
1559
1560
1561
1562
1563Aml *aml_touuid(const char *uuid)
1564{
1565 Aml *var = aml_bundle(0x11 , AML_BUFFER);
1566
1567 assert(strlen(uuid) == 36);
1568 assert(uuid[8] == '-');
1569 assert(uuid[13] == '-');
1570 assert(uuid[18] == '-');
1571 assert(uuid[23] == '-');
1572
1573 build_append_byte(var->buf, Hex2Byte(uuid + 6));
1574 build_append_byte(var->buf, Hex2Byte(uuid + 4));
1575 build_append_byte(var->buf, Hex2Byte(uuid + 2));
1576 build_append_byte(var->buf, Hex2Byte(uuid + 0));
1577
1578 build_append_byte(var->buf, Hex2Byte(uuid + 11));
1579 build_append_byte(var->buf, Hex2Byte(uuid + 9));
1580
1581 build_append_byte(var->buf, Hex2Byte(uuid + 16));
1582 build_append_byte(var->buf, Hex2Byte(uuid + 14));
1583
1584 build_append_byte(var->buf, Hex2Byte(uuid + 19));
1585 build_append_byte(var->buf, Hex2Byte(uuid + 21));
1586
1587 build_append_byte(var->buf, Hex2Byte(uuid + 24));
1588 build_append_byte(var->buf, Hex2Byte(uuid + 26));
1589 build_append_byte(var->buf, Hex2Byte(uuid + 28));
1590 build_append_byte(var->buf, Hex2Byte(uuid + 30));
1591 build_append_byte(var->buf, Hex2Byte(uuid + 32));
1592 build_append_byte(var->buf, Hex2Byte(uuid + 34));
1593
1594 return var;
1595}
1596
1597
1598
1599
1600Aml *aml_unicode(const char *str)
1601{
1602 int i = 0;
1603 Aml *var = aml_bundle(0x11 , AML_BUFFER);
1604
1605 do {
1606 build_append_byte(var->buf, str[i]);
1607 build_append_byte(var->buf, 0);
1608 i++;
1609 } while (i <= strlen(str));
1610
1611 return var;
1612}
1613
1614
1615Aml *aml_refof(Aml *arg)
1616{
1617 Aml *var = aml_opcode(0x71 );
1618 aml_append(var, arg);
1619 return var;
1620}
1621
1622
1623Aml *aml_derefof(Aml *arg)
1624{
1625 Aml *var = aml_opcode(0x83 );
1626 aml_append(var, arg);
1627 return var;
1628}
1629
1630
1631Aml *aml_sizeof(Aml *arg)
1632{
1633 Aml *var = aml_opcode(0x87 );
1634 aml_append(var, arg);
1635 return var;
1636}
1637
1638
1639Aml *aml_mutex(const char *name, uint8_t sync_level)
1640{
1641 Aml *var = aml_alloc();
1642 build_append_byte(var->buf, 0x5B);
1643 build_append_byte(var->buf, 0x01);
1644 build_append_namestring(var->buf, "%s", name);
1645 assert(!(sync_level & 0xF0));
1646 build_append_byte(var->buf, sync_level);
1647 return var;
1648}
1649
1650
1651Aml *aml_acquire(Aml *mutex, uint16_t timeout)
1652{
1653 Aml *var = aml_alloc();
1654 build_append_byte(var->buf, 0x5B);
1655 build_append_byte(var->buf, 0x23);
1656 aml_append(var, mutex);
1657 build_append_int_noprefix(var->buf, timeout, sizeof(timeout));
1658 return var;
1659}
1660
1661
1662Aml *aml_release(Aml *mutex)
1663{
1664 Aml *var = aml_alloc();
1665 build_append_byte(var->buf, 0x5B);
1666 build_append_byte(var->buf, 0x27);
1667 aml_append(var, mutex);
1668 return var;
1669}
1670
1671
1672Aml *aml_alias(const char *source_object, const char *alias_object)
1673{
1674 Aml *var = aml_opcode(0x06 );
1675 aml_append(var, aml_name("%s", source_object));
1676 aml_append(var, aml_name("%s", alias_object));
1677 return var;
1678}
1679
1680
1681Aml *aml_concatenate(Aml *source1, Aml *source2, Aml *target)
1682{
1683 return build_opcode_2arg_dst(0x73 , source1, source2,
1684 target);
1685}
1686
1687
1688Aml *aml_object_type(Aml *object)
1689{
1690 Aml *var = aml_opcode(0x8E );
1691 aml_append(var, object);
1692 return var;
1693}
1694
1695void
1696build_header(BIOSLinker *linker, GArray *table_data,
1697 AcpiTableHeader *h, const char *sig, int len, uint8_t rev,
1698 const char *oem_id, const char *oem_table_id)
1699{
1700 unsigned tbl_offset = (char *)h - table_data->data;
1701 unsigned checksum_offset = (char *)&h->checksum - table_data->data;
1702 memcpy(&h->signature, sig, 4);
1703 h->length = cpu_to_le32(len);
1704 h->revision = rev;
1705
1706 strpadcpy((char *)h->oem_id, sizeof h->oem_id, oem_id, ' ');
1707 strpadcpy((char *)h->oem_table_id, sizeof h->oem_table_id,
1708 oem_table_id, ' ');
1709
1710 h->oem_revision = cpu_to_le32(1);
1711 memcpy(h->asl_compiler_id, ACPI_BUILD_APPNAME8, 4);
1712 h->asl_compiler_revision = cpu_to_le32(1);
1713
1714 bios_linker_loader_add_checksum(linker, ACPI_BUILD_TABLE_FILE,
1715 tbl_offset, len, checksum_offset);
1716}
1717
1718void *acpi_data_push(GArray *table_data, unsigned size)
1719{
1720 unsigned off = table_data->len;
1721 g_array_set_size(table_data, off + size);
1722 return table_data->data + off;
1723}
1724
1725unsigned acpi_data_len(GArray *table)
1726{
1727 assert(g_array_get_element_size(table) == 1);
1728 return table->len;
1729}
1730
1731void acpi_add_table(GArray *table_offsets, GArray *table_data)
1732{
1733 uint32_t offset = table_data->len;
1734 g_array_append_val(table_offsets, offset);
1735}
1736
1737void acpi_build_tables_init(AcpiBuildTables *tables)
1738{
1739 tables->rsdp = g_array_new(false, true , 1);
1740 tables->table_data = g_array_new(false, true , 1);
1741 tables->tcpalog = g_array_new(false, true , 1);
1742 tables->vmgenid = g_array_new(false, true , 1);
1743 tables->hardware_errors = g_array_new(false, true , 1);
1744 tables->linker = bios_linker_loader_init();
1745}
1746
1747void acpi_build_tables_cleanup(AcpiBuildTables *tables, bool mfre)
1748{
1749 bios_linker_loader_cleanup(tables->linker);
1750 g_array_free(tables->rsdp, true);
1751 g_array_free(tables->table_data, true);
1752 g_array_free(tables->tcpalog, mfre);
1753 g_array_free(tables->vmgenid, mfre);
1754 g_array_free(tables->hardware_errors, mfre);
1755}
1756
1757
1758
1759
1760
1761void
1762build_rsdp(GArray *tbl, BIOSLinker *linker, AcpiRsdpData *rsdp_data)
1763{
1764 int tbl_off = tbl->len;
1765
1766 switch (rsdp_data->revision) {
1767 case 0:
1768
1769 g_assert(rsdp_data->rsdt_tbl_offset);
1770 break;
1771 case 2:
1772
1773 g_assert(rsdp_data->xsdt_tbl_offset);
1774 break;
1775 default:
1776
1777 g_assert_not_reached();
1778 }
1779
1780 bios_linker_loader_alloc(linker, ACPI_BUILD_RSDP_FILE, tbl, 16,
1781 true );
1782
1783 g_array_append_vals(tbl, "RSD PTR ", 8);
1784 build_append_int_noprefix(tbl, 0, 1);
1785 g_array_append_vals(tbl, rsdp_data->oem_id, 6);
1786 build_append_int_noprefix(tbl, rsdp_data->revision, 1);
1787 build_append_int_noprefix(tbl, 0, 4);
1788 if (rsdp_data->rsdt_tbl_offset) {
1789
1790 bios_linker_loader_add_pointer(linker, ACPI_BUILD_RSDP_FILE,
1791 tbl_off + 16, 4,
1792 ACPI_BUILD_TABLE_FILE,
1793 *rsdp_data->rsdt_tbl_offset);
1794 }
1795
1796
1797 bios_linker_loader_add_checksum(linker, ACPI_BUILD_RSDP_FILE,
1798 tbl_off, 20,
1799 8);
1800
1801 if (rsdp_data->revision == 0) {
1802
1803 return;
1804 }
1805
1806 build_append_int_noprefix(tbl, 36, 4);
1807
1808
1809 build_append_int_noprefix(tbl, 0, 8);
1810
1811 bios_linker_loader_add_pointer(linker, ACPI_BUILD_RSDP_FILE,
1812 tbl_off + 24, 8,
1813 ACPI_BUILD_TABLE_FILE,
1814 *rsdp_data->xsdt_tbl_offset);
1815
1816 build_append_int_noprefix(tbl, 0, 1);
1817 build_append_int_noprefix(tbl, 0, 3);
1818
1819
1820 bios_linker_loader_add_checksum(linker, ACPI_BUILD_RSDP_FILE,
1821 tbl_off, 36,
1822 32);
1823}
1824
1825
1826void
1827build_rsdt(GArray *table_data, BIOSLinker *linker, GArray *table_offsets,
1828 const char *oem_id, const char *oem_table_id)
1829{
1830 int i;
1831 unsigned rsdt_entries_offset;
1832 AcpiRsdtDescriptorRev1 *rsdt;
1833 const unsigned table_data_len = (sizeof(uint32_t) * table_offsets->len);
1834 const unsigned rsdt_entry_size = sizeof(rsdt->table_offset_entry[0]);
1835 const size_t rsdt_len = sizeof(*rsdt) + table_data_len;
1836
1837 rsdt = acpi_data_push(table_data, rsdt_len);
1838 rsdt_entries_offset = (char *)rsdt->table_offset_entry - table_data->data;
1839 for (i = 0; i < table_offsets->len; ++i) {
1840 uint32_t ref_tbl_offset = g_array_index(table_offsets, uint32_t, i);
1841 uint32_t rsdt_entry_offset = rsdt_entries_offset + rsdt_entry_size * i;
1842
1843
1844 bios_linker_loader_add_pointer(linker,
1845 ACPI_BUILD_TABLE_FILE, rsdt_entry_offset, rsdt_entry_size,
1846 ACPI_BUILD_TABLE_FILE, ref_tbl_offset);
1847 }
1848 build_header(linker, table_data,
1849 (void *)rsdt, "RSDT", rsdt_len, 1, oem_id, oem_table_id);
1850}
1851
1852
1853void
1854build_xsdt(GArray *table_data, BIOSLinker *linker, GArray *table_offsets,
1855 const char *oem_id, const char *oem_table_id)
1856{
1857 int i;
1858 unsigned xsdt_entries_offset;
1859 AcpiXsdtDescriptorRev2 *xsdt;
1860 const unsigned table_data_len = (sizeof(uint64_t) * table_offsets->len);
1861 const unsigned xsdt_entry_size = sizeof(xsdt->table_offset_entry[0]);
1862 const size_t xsdt_len = sizeof(*xsdt) + table_data_len;
1863
1864 xsdt = acpi_data_push(table_data, xsdt_len);
1865 xsdt_entries_offset = (char *)xsdt->table_offset_entry - table_data->data;
1866 for (i = 0; i < table_offsets->len; ++i) {
1867 uint64_t ref_tbl_offset = g_array_index(table_offsets, uint32_t, i);
1868 uint64_t xsdt_entry_offset = xsdt_entries_offset + xsdt_entry_size * i;
1869
1870
1871 bios_linker_loader_add_pointer(linker,
1872 ACPI_BUILD_TABLE_FILE, xsdt_entry_offset, xsdt_entry_size,
1873 ACPI_BUILD_TABLE_FILE, ref_tbl_offset);
1874 }
1875 build_header(linker, table_data,
1876 (void *)xsdt, "XSDT", xsdt_len, 1, oem_id, oem_table_id);
1877}
1878
1879void build_srat_memory(AcpiSratMemoryAffinity *numamem, uint64_t base,
1880 uint64_t len, int node, MemoryAffinityFlags flags)
1881{
1882 numamem->type = ACPI_SRAT_MEMORY;
1883 numamem->length = sizeof(*numamem);
1884 numamem->proximity = cpu_to_le32(node);
1885 numamem->flags = cpu_to_le32(flags);
1886 numamem->base_addr = cpu_to_le64(base);
1887 numamem->range_length = cpu_to_le64(len);
1888}
1889
1890
1891
1892
1893
1894void build_slit(GArray *table_data, BIOSLinker *linker, MachineState *ms,
1895 const char *oem_id, const char *oem_table_id)
1896{
1897 int slit_start, i, j;
1898 slit_start = table_data->len;
1899 int nb_numa_nodes = ms->numa_state->num_nodes;
1900
1901 acpi_data_push(table_data, sizeof(AcpiTableHeader));
1902
1903 build_append_int_noprefix(table_data, nb_numa_nodes, 8);
1904 for (i = 0; i < nb_numa_nodes; i++) {
1905 for (j = 0; j < nb_numa_nodes; j++) {
1906 assert(ms->numa_state->nodes[i].distance[j]);
1907 build_append_int_noprefix(table_data,
1908 ms->numa_state->nodes[i].distance[j],
1909 1);
1910 }
1911 }
1912
1913 build_header(linker, table_data,
1914 (void *)(table_data->data + slit_start),
1915 "SLIT",
1916 table_data->len - slit_start, 1, oem_id, oem_table_id);
1917}
1918
1919
1920void build_fadt(GArray *tbl, BIOSLinker *linker, const AcpiFadtData *f,
1921 const char *oem_id, const char *oem_table_id)
1922{
1923 int off;
1924 int fadt_start = tbl->len;
1925
1926 acpi_data_push(tbl, sizeof(AcpiTableHeader));
1927
1928
1929 off = tbl->len;
1930 build_append_int_noprefix(tbl, 0, 4);
1931 if (f->facs_tbl_offset) {
1932 bios_linker_loader_add_pointer(linker,
1933 ACPI_BUILD_TABLE_FILE, off, 4,
1934 ACPI_BUILD_TABLE_FILE, *f->facs_tbl_offset);
1935 }
1936
1937
1938 off = tbl->len;
1939 build_append_int_noprefix(tbl, 0, 4);
1940 if (f->dsdt_tbl_offset) {
1941 bios_linker_loader_add_pointer(linker,
1942 ACPI_BUILD_TABLE_FILE, off, 4,
1943 ACPI_BUILD_TABLE_FILE, *f->dsdt_tbl_offset);
1944 }
1945
1946
1947 build_append_int_noprefix(tbl, f->int_model , 1);
1948
1949 build_append_int_noprefix(tbl, 0 , 1);
1950 build_append_int_noprefix(tbl, f->sci_int, 2);
1951 build_append_int_noprefix(tbl, f->smi_cmd, 4);
1952 build_append_int_noprefix(tbl, f->acpi_enable_cmd, 1);
1953 build_append_int_noprefix(tbl, f->acpi_disable_cmd, 1);
1954 build_append_int_noprefix(tbl, 0 , 1);
1955
1956 build_append_int_noprefix(tbl, 0, 1);
1957 build_append_int_noprefix(tbl, f->pm1a_evt.address, 4);
1958 build_append_int_noprefix(tbl, 0, 4);
1959 build_append_int_noprefix(tbl, f->pm1a_cnt.address, 4);
1960 build_append_int_noprefix(tbl, 0, 4);
1961 build_append_int_noprefix(tbl, 0, 4);
1962 build_append_int_noprefix(tbl, f->pm_tmr.address, 4);
1963 build_append_int_noprefix(tbl, f->gpe0_blk.address, 4);
1964 build_append_int_noprefix(tbl, 0, 4);
1965
1966 build_append_int_noprefix(tbl, f->pm1a_evt.bit_width / 8, 1);
1967
1968 build_append_int_noprefix(tbl, f->pm1a_cnt.bit_width / 8, 1);
1969 build_append_int_noprefix(tbl, 0, 1);
1970 build_append_int_noprefix(tbl, f->pm_tmr.bit_width / 8, 1);
1971
1972 build_append_int_noprefix(tbl, f->gpe0_blk.bit_width / 8, 1);
1973 build_append_int_noprefix(tbl, 0, 1);
1974 build_append_int_noprefix(tbl, 0, 1);
1975 build_append_int_noprefix(tbl, 0, 1);
1976 build_append_int_noprefix(tbl, f->plvl2_lat, 2);
1977 build_append_int_noprefix(tbl, f->plvl3_lat, 2);
1978 build_append_int_noprefix(tbl, 0, 2);
1979 build_append_int_noprefix(tbl, 0, 2);
1980 build_append_int_noprefix(tbl, 0, 1);
1981 build_append_int_noprefix(tbl, 0, 1);
1982 build_append_int_noprefix(tbl, 0, 1);
1983 build_append_int_noprefix(tbl, 0, 1);
1984 build_append_int_noprefix(tbl, f->rtc_century, 1);
1985 build_append_int_noprefix(tbl, 0, 2);
1986 build_append_int_noprefix(tbl, 0, 1);
1987 build_append_int_noprefix(tbl, f->flags, 4);
1988
1989 if (f->rev == 1) {
1990 goto build_hdr;
1991 }
1992
1993 build_append_gas_from_struct(tbl, &f->reset_reg);
1994 build_append_int_noprefix(tbl, f->reset_val, 1);
1995
1996 if ((f->rev >= 6) || ((f->rev == 5) && f->minor_ver > 0)) {
1997 build_append_int_noprefix(tbl, f->arm_boot_arch, 2);
1998
1999 build_append_int_noprefix(tbl, f->minor_ver, 1);
2000 } else {
2001 build_append_int_noprefix(tbl, 0, 3);
2002 }
2003 build_append_int_noprefix(tbl, 0, 8);
2004
2005
2006 off = tbl->len;
2007 build_append_int_noprefix(tbl, 0, 8);
2008 if (f->xdsdt_tbl_offset) {
2009 bios_linker_loader_add_pointer(linker,
2010 ACPI_BUILD_TABLE_FILE, off, 8,
2011 ACPI_BUILD_TABLE_FILE, *f->xdsdt_tbl_offset);
2012 }
2013
2014 build_append_gas_from_struct(tbl, &f->pm1a_evt);
2015
2016 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0);
2017 build_append_gas_from_struct(tbl, &f->pm1a_cnt);
2018
2019 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0);
2020
2021 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0);
2022 build_append_gas_from_struct(tbl, &f->pm_tmr);
2023 build_append_gas_from_struct(tbl, &f->gpe0_blk);
2024 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0);
2025
2026 if (f->rev <= 4) {
2027 goto build_hdr;
2028 }
2029
2030
2031 build_append_gas_from_struct(tbl, &f->sleep_ctl);
2032
2033 build_append_gas_from_struct(tbl, &f->sleep_sts);
2034
2035
2036 assert(f->rev == 5);
2037
2038build_hdr:
2039 build_header(linker, tbl, (void *)(tbl->data + fadt_start),
2040 "FACP", tbl->len - fadt_start, f->rev, oem_id, oem_table_id);
2041}
2042
2043
2044
2045
2046
2047
2048void build_tpm2(GArray *table_data, BIOSLinker *linker, GArray *tcpalog,
2049 const char *oem_id, const char *oem_table_id)
2050{
2051 uint8_t start_method_params[12] = {};
2052 unsigned log_addr_offset, tpm2_start;
2053 uint64_t control_area_start_address;
2054 TPMIf *tpmif = tpm_find();
2055 uint32_t start_method;
2056 void *tpm2_ptr;
2057
2058 tpm2_start = table_data->len;
2059 tpm2_ptr = acpi_data_push(table_data, sizeof(AcpiTableHeader));
2060
2061
2062 build_append_int_noprefix(table_data, TPM2_ACPI_CLASS_CLIENT, 2);
2063
2064 build_append_int_noprefix(table_data, 0, 2);
2065 if (TPM_IS_TIS_ISA(tpmif) || TPM_IS_TIS_SYSBUS(tpmif)) {
2066 control_area_start_address = 0;
2067 start_method = TPM2_START_METHOD_MMIO;
2068 } else if (TPM_IS_CRB(tpmif)) {
2069 control_area_start_address = TPM_CRB_ADDR_CTRL;
2070 start_method = TPM2_START_METHOD_CRB;
2071 } else {
2072 g_assert_not_reached();
2073 }
2074
2075 build_append_int_noprefix(table_data, control_area_start_address, 8);
2076
2077 build_append_int_noprefix(table_data, start_method, 4);
2078
2079
2080 g_array_append_vals(table_data, &start_method_params,
2081 ARRAY_SIZE(start_method_params));
2082
2083
2084 build_append_int_noprefix(table_data, TPM_LOG_AREA_MINIMUM_SIZE, 4);
2085
2086 acpi_data_push(tcpalog, TPM_LOG_AREA_MINIMUM_SIZE);
2087 bios_linker_loader_alloc(linker, ACPI_BUILD_TPMLOG_FILE, tcpalog, 1,
2088 false);
2089
2090 log_addr_offset = table_data->len;
2091
2092
2093 build_append_int_noprefix(table_data, 0, 8);
2094 bios_linker_loader_add_pointer(linker, ACPI_BUILD_TABLE_FILE,
2095 log_addr_offset, 8,
2096 ACPI_BUILD_TPMLOG_FILE, 0);
2097 build_header(linker, table_data,
2098 tpm2_ptr, "TPM2", table_data->len - tpm2_start, 4, oem_id,
2099 oem_table_id);
2100}
2101
2102Aml *build_crs(PCIHostState *host, CrsRangeSet *range_set, uint32_t io_offset,
2103 uint32_t mmio32_offset, uint64_t mmio64_offset,
2104 uint16_t bus_nr_offset)
2105{
2106 Aml *crs = aml_resource_template();
2107 CrsRangeSet temp_range_set;
2108 CrsRangeEntry *entry;
2109 uint8_t max_bus = pci_bus_num(host->bus);
2110 uint8_t type;
2111 int devfn;
2112 int i;
2113
2114 crs_range_set_init(&temp_range_set);
2115 for (devfn = 0; devfn < ARRAY_SIZE(host->bus->devices); devfn++) {
2116 uint64_t range_base, range_limit;
2117 PCIDevice *dev = host->bus->devices[devfn];
2118
2119 if (!dev) {
2120 continue;
2121 }
2122
2123 for (i = 0; i < PCI_NUM_REGIONS; i++) {
2124 PCIIORegion *r = &dev->io_regions[i];
2125
2126 range_base = r->addr;
2127 range_limit = r->addr + r->size - 1;
2128
2129
2130
2131
2132
2133 if (!range_base || range_base > range_limit) {
2134 continue;
2135 }
2136
2137 if (r->type & PCI_BASE_ADDRESS_SPACE_IO) {
2138 crs_range_insert(temp_range_set.io_ranges,
2139 range_base, range_limit);
2140 } else {
2141 uint64_t length = range_limit - range_base + 1;
2142 if (range_limit <= UINT32_MAX && length <= UINT32_MAX) {
2143 crs_range_insert(temp_range_set.mem_ranges, range_base,
2144 range_limit);
2145 } else {
2146 crs_range_insert(temp_range_set.mem_64bit_ranges,
2147 range_base, range_limit);
2148 }
2149 }
2150 }
2151
2152 type = dev->config[PCI_HEADER_TYPE] & ~PCI_HEADER_TYPE_MULTI_FUNCTION;
2153 if (type == PCI_HEADER_TYPE_BRIDGE) {
2154 uint8_t subordinate = dev->config[PCI_SUBORDINATE_BUS];
2155 if (subordinate > max_bus) {
2156 max_bus = subordinate;
2157 }
2158
2159 range_base = pci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_IO);
2160 range_limit = pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_IO);
2161
2162
2163
2164
2165
2166 if (range_base && range_base <= range_limit) {
2167 crs_range_insert(temp_range_set.io_ranges,
2168 range_base, range_limit);
2169 }
2170
2171 range_base =
2172 pci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_MEMORY);
2173 range_limit =
2174 pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_MEMORY);
2175
2176
2177
2178
2179
2180 if (range_base && range_base <= range_limit) {
2181 uint64_t length = range_limit - range_base + 1;
2182 if (range_limit <= UINT32_MAX && length <= UINT32_MAX) {
2183 crs_range_insert(temp_range_set.mem_ranges,
2184 range_base, range_limit);
2185 } else {
2186 crs_range_insert(temp_range_set.mem_64bit_ranges,
2187 range_base, range_limit);
2188 }
2189 }
2190
2191 range_base =
2192 pci_bridge_get_base(dev, PCI_BASE_ADDRESS_MEM_PREFETCH);
2193 range_limit =
2194 pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_MEM_PREFETCH);
2195
2196
2197
2198
2199
2200 if (range_base && range_base <= range_limit) {
2201 uint64_t length = range_limit - range_base + 1;
2202 if (range_limit <= UINT32_MAX && length <= UINT32_MAX) {
2203 crs_range_insert(temp_range_set.mem_ranges,
2204 range_base, range_limit);
2205 } else {
2206 crs_range_insert(temp_range_set.mem_64bit_ranges,
2207 range_base, range_limit);
2208 }
2209 }
2210 }
2211 }
2212
2213 crs_range_merge(temp_range_set.io_ranges);
2214 for (i = 0; i < temp_range_set.io_ranges->len; i++) {
2215 entry = g_ptr_array_index(temp_range_set.io_ranges, i);
2216 aml_append(crs,
2217 aml_dword_io(AML_MIN_FIXED, AML_MAX_FIXED,
2218 AML_POS_DECODE, AML_ENTIRE_RANGE,
2219 0, entry->base, entry->limit, io_offset,
2220 entry->limit - entry->base + 1));
2221 crs_range_insert(range_set->io_ranges, entry->base, entry->limit);
2222 }
2223
2224 crs_range_merge(temp_range_set.mem_ranges);
2225 for (i = 0; i < temp_range_set.mem_ranges->len; i++) {
2226 entry = g_ptr_array_index(temp_range_set.mem_ranges, i);
2227 assert(entry->limit <= UINT32_MAX &&
2228 (entry->limit - entry->base + 1) <= UINT32_MAX);
2229 aml_append(crs,
2230 aml_dword_memory(AML_POS_DECODE, AML_MIN_FIXED,
2231 AML_MAX_FIXED, AML_NON_CACHEABLE,
2232 AML_READ_WRITE,
2233 0, entry->base, entry->limit, mmio32_offset,
2234 entry->limit - entry->base + 1));
2235 crs_range_insert(range_set->mem_ranges, entry->base, entry->limit);
2236 }
2237
2238 crs_range_merge(temp_range_set.mem_64bit_ranges);
2239 for (i = 0; i < temp_range_set.mem_64bit_ranges->len; i++) {
2240 entry = g_ptr_array_index(temp_range_set.mem_64bit_ranges, i);
2241 aml_append(crs,
2242 aml_qword_memory(AML_POS_DECODE, AML_MIN_FIXED,
2243 AML_MAX_FIXED, AML_NON_CACHEABLE,
2244 AML_READ_WRITE,
2245 0, entry->base, entry->limit, mmio64_offset,
2246 entry->limit - entry->base + 1));
2247 crs_range_insert(range_set->mem_64bit_ranges,
2248 entry->base, entry->limit);
2249 }
2250
2251 crs_range_set_free(&temp_range_set);
2252
2253 aml_append(crs,
2254 aml_word_bus_number(AML_MIN_FIXED, AML_MAX_FIXED, AML_POS_DECODE,
2255 0,
2256 pci_bus_num(host->bus),
2257 max_bus,
2258 bus_nr_offset,
2259 max_bus - pci_bus_num(host->bus) + 1));
2260
2261 return crs;
2262}
2263
2264
2265static Aml *aml_serial_bus_device(uint8_t serial_bus_type, uint8_t flags,
2266 uint16_t type_flags,
2267 uint8_t revid, uint16_t data_length,
2268 uint16_t resource_source_len)
2269{
2270 Aml *var = aml_alloc();
2271 uint16_t length = data_length + resource_source_len + 9;
2272
2273 build_append_byte(var->buf, 0x8e);
2274 build_append_int_noprefix(var->buf, length, sizeof(length));
2275 build_append_byte(var->buf, 1);
2276 build_append_byte(var->buf, 0);
2277 build_append_byte(var->buf, serial_bus_type);
2278 build_append_byte(var->buf, flags);
2279 build_append_int_noprefix(var->buf, type_flags,
2280 sizeof(type_flags));
2281 build_append_byte(var->buf, revid);
2282 build_append_int_noprefix(var->buf, data_length, sizeof(data_length));
2283
2284 return var;
2285}
2286
2287
2288Aml *aml_i2c_serial_bus_device(uint16_t address, const char *resource_source)
2289{
2290 uint16_t resource_source_len = strlen(resource_source) + 1;
2291 Aml *var = aml_serial_bus_device(AML_SERIAL_BUS_TYPE_I2C, 0, 0, 1,
2292 6, resource_source_len);
2293
2294
2295 build_append_int_noprefix(var->buf, 100000, 4);
2296 build_append_int_noprefix(var->buf, address, sizeof(address));
2297
2298
2299 g_array_append_vals(var->buf, resource_source, resource_source_len);
2300
2301 return var;
2302}
2303