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
29static GArray *build_alloc_array(void)
30{
31 return g_array_new(false, true , 1);
32}
33
34static void build_free_array(GArray *array)
35{
36 g_array_free(array, true);
37}
38
39static void build_prepend_byte(GArray *array, uint8_t val)
40{
41 g_array_prepend_val(array, val);
42}
43
44static void build_append_byte(GArray *array, uint8_t val)
45{
46 g_array_append_val(array, val);
47}
48
49static void build_append_array(GArray *array, GArray *val)
50{
51 g_array_append_vals(array, val->data, val->len);
52}
53
54#define ACPI_NAMESEG_LEN 4
55
56static void
57build_append_nameseg(GArray *array, const char *seg)
58{
59 int len;
60
61 len = strlen(seg);
62 assert(len <= ACPI_NAMESEG_LEN);
63
64 g_array_append_vals(array, seg, len);
65
66 g_array_append_vals(array, "____", ACPI_NAMESEG_LEN - len);
67}
68
69static void GCC_FMT_ATTR(2, 0)
70build_append_namestringv(GArray *array, const char *format, va_list ap)
71{
72 char *s;
73 char **segs;
74 char **segs_iter;
75 int seg_count = 0;
76
77 s = g_strdup_vprintf(format, ap);
78 segs = g_strsplit(s, ".", 0);
79 g_free(s);
80
81
82 segs_iter = segs;
83 while (*segs_iter) {
84 ++segs_iter;
85 ++seg_count;
86 }
87
88
89
90
91 assert(seg_count > 0 && seg_count <= 255);
92
93
94 s = *segs;
95 while (*s == '\\' || *s == '^') {
96 build_append_byte(array, *s);
97 ++s;
98 }
99
100 switch (seg_count) {
101 case 1:
102 if (!*s) {
103 build_append_byte(array, 0x00);
104 } else {
105 build_append_nameseg(array, s);
106 }
107 break;
108
109 case 2:
110 build_append_byte(array, 0x2E);
111 build_append_nameseg(array, s);
112 build_append_nameseg(array, segs[1]);
113 break;
114 default:
115 build_append_byte(array, 0x2F);
116 build_append_byte(array, seg_count);
117
118
119 build_append_nameseg(array, s);
120
121
122 segs_iter = segs + 1;
123 while (*segs_iter) {
124 build_append_nameseg(array, *segs_iter);
125 ++segs_iter;
126 }
127 break;
128 }
129 g_strfreev(segs);
130}
131
132GCC_FMT_ATTR(2, 3)
133static void build_append_namestring(GArray *array, const char *format, ...)
134{
135 va_list ap;
136
137 va_start(ap, format);
138 build_append_namestringv(array, format, ap);
139 va_end(ap);
140}
141
142
143enum {
144 PACKAGE_LENGTH_1BYTE_SHIFT = 6,
145 PACKAGE_LENGTH_2BYTE_SHIFT = 4,
146 PACKAGE_LENGTH_3BYTE_SHIFT = 12,
147 PACKAGE_LENGTH_4BYTE_SHIFT = 20,
148};
149
150static void
151build_prepend_package_length(GArray *package, unsigned length, bool incl_self)
152{
153 uint8_t byte;
154 unsigned length_bytes;
155
156 if (length + 1 < (1 << PACKAGE_LENGTH_1BYTE_SHIFT)) {
157 length_bytes = 1;
158 } else if (length + 2 < (1 << PACKAGE_LENGTH_3BYTE_SHIFT)) {
159 length_bytes = 2;
160 } else if (length + 3 < (1 << PACKAGE_LENGTH_4BYTE_SHIFT)) {
161 length_bytes = 3;
162 } else {
163 length_bytes = 4;
164 }
165
166
167
168
169
170 if (incl_self) {
171
172
173
174
175
176 length += length_bytes;
177 }
178
179 switch (length_bytes) {
180 case 1:
181 byte = length;
182 build_prepend_byte(package, byte);
183 return;
184 case 4:
185 byte = length >> PACKAGE_LENGTH_4BYTE_SHIFT;
186 build_prepend_byte(package, byte);
187 length &= (1 << PACKAGE_LENGTH_4BYTE_SHIFT) - 1;
188
189 case 3:
190 byte = length >> PACKAGE_LENGTH_3BYTE_SHIFT;
191 build_prepend_byte(package, byte);
192 length &= (1 << PACKAGE_LENGTH_3BYTE_SHIFT) - 1;
193
194 case 2:
195 byte = length >> PACKAGE_LENGTH_2BYTE_SHIFT;
196 build_prepend_byte(package, byte);
197 length &= (1 << PACKAGE_LENGTH_2BYTE_SHIFT) - 1;
198
199 }
200
201
202
203
204 byte = ((length_bytes - 1) << PACKAGE_LENGTH_1BYTE_SHIFT) | length;
205 build_prepend_byte(package, byte);
206}
207
208static void
209build_append_pkg_length(GArray *array, unsigned length, bool incl_self)
210{
211 GArray *tmp = build_alloc_array();
212
213 build_prepend_package_length(tmp, length, incl_self);
214 build_append_array(array, tmp);
215 build_free_array(tmp);
216}
217
218static void build_package(GArray *package, uint8_t op)
219{
220 build_prepend_package_length(package, package->len, true);
221 build_prepend_byte(package, op);
222}
223
224static void build_extop_package(GArray *package, uint8_t op)
225{
226 build_package(package, op);
227 build_prepend_byte(package, 0x5B);
228}
229
230void build_append_int_noprefix(GArray *table, uint64_t value, int size)
231{
232 int i;
233
234 for (i = 0; i < size; ++i) {
235 build_append_byte(table, value & 0xFF);
236 value = value >> 8;
237 }
238}
239
240static void build_append_int(GArray *table, uint64_t value)
241{
242 if (value == 0x00) {
243 build_append_byte(table, 0x00);
244 } else if (value == 0x01) {
245 build_append_byte(table, 0x01);
246 } else if (value <= 0xFF) {
247 build_append_byte(table, 0x0A);
248 build_append_int_noprefix(table, value, 1);
249 } else if (value <= 0xFFFF) {
250 build_append_byte(table, 0x0B);
251 build_append_int_noprefix(table, value, 2);
252 } else if (value <= 0xFFFFFFFF) {
253 build_append_byte(table, 0x0C);
254 build_append_int_noprefix(table, value, 4);
255 } else {
256 build_append_byte(table, 0x0E);
257 build_append_int_noprefix(table, value, 8);
258 }
259}
260
261
262
263
264
265
266void build_append_gas(GArray *table, AmlAddressSpace as,
267 uint8_t bit_width, uint8_t bit_offset,
268 uint8_t access_width, uint64_t address)
269{
270 build_append_int_noprefix(table, as, 1);
271 build_append_int_noprefix(table, bit_width, 1);
272 build_append_int_noprefix(table, bit_offset, 1);
273 build_append_int_noprefix(table, access_width, 1);
274 build_append_int_noprefix(table, address, 8);
275}
276
277
278
279
280
281
282
283
284
285int
286build_append_named_dword(GArray *array, const char *name_format, ...)
287{
288 int offset;
289 va_list ap;
290
291 build_append_byte(array, 0x08);
292 va_start(ap, name_format);
293 build_append_namestringv(array, name_format, ap);
294 va_end(ap);
295
296 build_append_byte(array, 0x0C);
297
298 offset = array->len;
299 build_append_int_noprefix(array, 0x00000000, 4);
300 assert(array->len == offset + 4);
301
302 return offset;
303}
304
305static GPtrArray *alloc_list;
306
307static Aml *aml_alloc(void)
308{
309 Aml *var = g_new0(typeof(*var), 1);
310
311 g_ptr_array_add(alloc_list, var);
312 var->block_flags = AML_NO_OPCODE;
313 var->buf = build_alloc_array();
314 return var;
315}
316
317static Aml *aml_opcode(uint8_t op)
318{
319 Aml *var = aml_alloc();
320
321 var->op = op;
322 var->block_flags = AML_OPCODE;
323 return var;
324}
325
326static Aml *aml_bundle(uint8_t op, AmlBlockFlags flags)
327{
328 Aml *var = aml_alloc();
329
330 var->op = op;
331 var->block_flags = flags;
332 return var;
333}
334
335static void aml_free(gpointer data, gpointer user_data)
336{
337 Aml *var = data;
338 build_free_array(var->buf);
339 g_free(var);
340}
341
342Aml *init_aml_allocator(void)
343{
344 assert(!alloc_list);
345 alloc_list = g_ptr_array_new();
346 return aml_alloc();
347}
348
349void free_aml_allocator(void)
350{
351 g_ptr_array_foreach(alloc_list, aml_free, NULL);
352 g_ptr_array_free(alloc_list, true);
353 alloc_list = 0;
354}
355
356
357static void build_buffer(GArray *array, uint8_t op)
358{
359 GArray *data = build_alloc_array();
360
361 build_append_int(data, array->len);
362 g_array_prepend_vals(array, data->data, data->len);
363 build_free_array(data);
364 build_package(array, op);
365}
366
367void aml_append(Aml *parent_ctx, Aml *child)
368{
369 GArray *buf = build_alloc_array();
370 build_append_array(buf, child->buf);
371
372 switch (child->block_flags) {
373 case AML_OPCODE:
374 build_append_byte(parent_ctx->buf, child->op);
375 break;
376 case AML_EXT_PACKAGE:
377 build_extop_package(buf, child->op);
378 break;
379 case AML_PACKAGE:
380 build_package(buf, child->op);
381 break;
382 case AML_RES_TEMPLATE:
383 build_append_byte(buf, 0x79);
384
385
386
387
388 build_append_byte(buf, 0);
389
390 case AML_BUFFER:
391 build_buffer(buf, child->op);
392 break;
393 case AML_NO_OPCODE:
394 break;
395 default:
396 assert(0);
397 break;
398 }
399 build_append_array(parent_ctx->buf, buf);
400 build_free_array(buf);
401}
402
403
404Aml *aml_scope(const char *name_format, ...)
405{
406 va_list ap;
407 Aml *var = aml_bundle(0x10 , AML_PACKAGE);
408 va_start(ap, name_format);
409 build_append_namestringv(var->buf, name_format, ap);
410 va_end(ap);
411 return var;
412}
413
414
415Aml *aml_return(Aml *val)
416{
417 Aml *var = aml_opcode(0xA4 );
418 aml_append(var, val);
419 return var;
420}
421
422
423Aml *aml_debug(void)
424{
425 Aml *var = aml_alloc();
426 build_append_byte(var->buf, 0x5B);
427 build_append_byte(var->buf, 0x31);
428 return var;
429}
430
431
432
433
434
435Aml *aml_int(const uint64_t val)
436{
437 Aml *var = aml_alloc();
438 build_append_int(var->buf, val);
439 return var;
440}
441
442
443
444
445
446Aml *aml_name(const char *name_format, ...)
447{
448 va_list ap;
449 Aml *var = aml_alloc();
450 va_start(ap, name_format);
451 build_append_namestringv(var->buf, name_format, ap);
452 va_end(ap);
453 return var;
454}
455
456
457Aml *aml_name_decl(const char *name, Aml *val)
458{
459 Aml *var = aml_opcode(0x08 );
460 build_append_namestring(var->buf, "%s", name);
461 aml_append(var, val);
462 return var;
463}
464
465
466Aml *aml_arg(int pos)
467{
468 uint8_t op = 0x68 + pos;
469
470 assert(pos <= 6);
471 return aml_opcode(op);
472}
473
474
475Aml *aml_to_integer(Aml *arg)
476{
477 Aml *var = aml_opcode(0x99 );
478 aml_append(var, arg);
479 build_append_byte(var->buf, 0x00 );
480 return var;
481}
482
483
484Aml *aml_to_hexstring(Aml *src, Aml *dst)
485{
486 Aml *var = aml_opcode(0x98 );
487 aml_append(var, src);
488 if (dst) {
489 aml_append(var, dst);
490 } else {
491 build_append_byte(var->buf, 0x00 );
492 }
493 return var;
494}
495
496
497Aml *aml_to_buffer(Aml *src, Aml *dst)
498{
499 Aml *var = aml_opcode(0x96 );
500 aml_append(var, src);
501 if (dst) {
502 aml_append(var, dst);
503 } else {
504 build_append_byte(var->buf, 0x00 );
505 }
506 return var;
507}
508
509
510Aml *aml_store(Aml *val, Aml *target)
511{
512 Aml *var = aml_opcode(0x70 );
513 aml_append(var, val);
514 aml_append(var, target);
515 return var;
516}
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531static Aml *
532build_opcode_2arg_dst(uint8_t op, Aml *arg1, Aml *arg2, Aml *dst)
533{
534 Aml *var = aml_opcode(op);
535 aml_append(var, arg1);
536 aml_append(var, arg2);
537 if (dst) {
538 aml_append(var, dst);
539 } else {
540 build_append_byte(var->buf, 0x00 );
541 }
542 return var;
543}
544
545
546Aml *aml_and(Aml *arg1, Aml *arg2, Aml *dst)
547{
548 return build_opcode_2arg_dst(0x7B , arg1, arg2, dst);
549}
550
551
552Aml *aml_or(Aml *arg1, Aml *arg2, Aml *dst)
553{
554 return build_opcode_2arg_dst(0x7D , arg1, arg2, dst);
555}
556
557
558Aml *aml_lor(Aml *arg1, Aml *arg2)
559{
560 Aml *var = aml_opcode(0x91 );
561 aml_append(var, arg1);
562 aml_append(var, arg2);
563 return var;
564}
565
566
567Aml *aml_shiftleft(Aml *arg1, Aml *count)
568{
569 return build_opcode_2arg_dst(0x79 , arg1, count, NULL);
570}
571
572
573Aml *aml_shiftright(Aml *arg1, Aml *count, Aml *dst)
574{
575 return build_opcode_2arg_dst(0x7A , arg1, count, dst);
576}
577
578
579Aml *aml_lless(Aml *arg1, Aml *arg2)
580{
581 Aml *var = aml_opcode(0x95 );
582 aml_append(var, arg1);
583 aml_append(var, arg2);
584 return var;
585}
586
587
588Aml *aml_add(Aml *arg1, Aml *arg2, Aml *dst)
589{
590 return build_opcode_2arg_dst(0x72 , arg1, arg2, dst);
591}
592
593
594Aml *aml_subtract(Aml *arg1, Aml *arg2, Aml *dst)
595{
596 return build_opcode_2arg_dst(0x74 , arg1, arg2, dst);
597}
598
599
600Aml *aml_increment(Aml *arg)
601{
602 Aml *var = aml_opcode(0x75 );
603 aml_append(var, arg);
604 return var;
605}
606
607
608Aml *aml_decrement(Aml *arg)
609{
610 Aml *var = aml_opcode(0x76 );
611 aml_append(var, arg);
612 return var;
613}
614
615
616Aml *aml_index(Aml *arg1, Aml *idx)
617{
618 return build_opcode_2arg_dst(0x88 , arg1, idx, NULL);
619}
620
621
622Aml *aml_notify(Aml *arg1, Aml *arg2)
623{
624 Aml *var = aml_opcode(0x86 );
625 aml_append(var, arg1);
626 aml_append(var, arg2);
627 return var;
628}
629
630
631Aml *aml_call0(const char *method)
632{
633 Aml *var = aml_alloc();
634 build_append_namestring(var->buf, "%s", method);
635 return var;
636}
637
638
639Aml *aml_call1(const char *method, Aml *arg1)
640{
641 Aml *var = aml_alloc();
642 build_append_namestring(var->buf, "%s", method);
643 aml_append(var, arg1);
644 return var;
645}
646
647
648Aml *aml_call2(const char *method, Aml *arg1, Aml *arg2)
649{
650 Aml *var = aml_alloc();
651 build_append_namestring(var->buf, "%s", method);
652 aml_append(var, arg1);
653 aml_append(var, arg2);
654 return var;
655}
656
657
658Aml *aml_call3(const char *method, Aml *arg1, Aml *arg2, Aml *arg3)
659{
660 Aml *var = aml_alloc();
661 build_append_namestring(var->buf, "%s", method);
662 aml_append(var, arg1);
663 aml_append(var, arg2);
664 aml_append(var, arg3);
665 return var;
666}
667
668
669Aml *aml_call4(const char *method, Aml *arg1, Aml *arg2, Aml *arg3, Aml *arg4)
670{
671 Aml *var = aml_alloc();
672 build_append_namestring(var->buf, "%s", method);
673 aml_append(var, arg1);
674 aml_append(var, arg2);
675 aml_append(var, arg3);
676 aml_append(var, arg4);
677 return var;
678}
679
680
681Aml *aml_call5(const char *method, Aml *arg1, Aml *arg2, Aml *arg3, Aml *arg4,
682 Aml *arg5)
683{
684 Aml *var = aml_alloc();
685 build_append_namestring(var->buf, "%s", method);
686 aml_append(var, arg1);
687 aml_append(var, arg2);
688 aml_append(var, arg3);
689 aml_append(var, arg4);
690 aml_append(var, arg5);
691 return var;
692}
693
694
695
696
697
698
699static Aml *aml_gpio_connection(AmlGpioConnectionType type,
700 AmlConsumerAndProducer con_and_pro,
701 uint8_t flags, AmlPinConfig pin_config,
702 uint16_t output_drive,
703 uint16_t debounce_timeout,
704 const uint32_t pin_list[], uint32_t pin_count,
705 const char *resource_source_name,
706 const uint8_t *vendor_data,
707 uint16_t vendor_data_len)
708{
709 Aml *var = aml_alloc();
710 const uint16_t min_desc_len = 0x16;
711 uint16_t resource_source_name_len, length;
712 uint16_t pin_table_offset, resource_source_name_offset, vendor_data_offset;
713 uint32_t i;
714
715 assert(resource_source_name);
716 resource_source_name_len = strlen(resource_source_name) + 1;
717 length = min_desc_len + resource_source_name_len + vendor_data_len;
718 pin_table_offset = min_desc_len + 1;
719 resource_source_name_offset = pin_table_offset + pin_count * 2;
720 vendor_data_offset = resource_source_name_offset + resource_source_name_len;
721
722 build_append_byte(var->buf, 0x8C);
723 build_append_int_noprefix(var->buf, length, 2);
724 build_append_byte(var->buf, 1);
725 build_append_byte(var->buf, type);
726
727 build_append_int_noprefix(var->buf, con_and_pro, 2);
728
729 build_append_int_noprefix(var->buf, flags, 2);
730
731 build_append_byte(var->buf, pin_config);
732
733 build_append_int_noprefix(var->buf, output_drive, 2);
734
735 build_append_int_noprefix(var->buf, debounce_timeout, 2);
736
737 build_append_int_noprefix(var->buf, pin_table_offset, 2);
738 build_append_byte(var->buf, 0);
739
740 build_append_int_noprefix(var->buf, resource_source_name_offset, 2);
741
742 build_append_int_noprefix(var->buf, vendor_data_offset, 2);
743
744 build_append_int_noprefix(var->buf, vendor_data_len, 2);
745
746 for (i = 0; i < pin_count; i++) {
747 build_append_int_noprefix(var->buf, pin_list[i], 2);
748 }
749
750
751 build_append_namestring(var->buf, "%s", resource_source_name);
752 build_append_byte(var->buf, '\0');
753
754
755 if (vendor_data != NULL) {
756 g_array_append_vals(var->buf, vendor_data, vendor_data_len);
757 }
758
759 return var;
760}
761
762
763
764
765
766Aml *aml_gpio_int(AmlConsumerAndProducer con_and_pro,
767 AmlLevelAndEdge edge_level,
768 AmlActiveHighAndLow active_level, AmlShared shared,
769 AmlPinConfig pin_config, uint16_t debounce_timeout,
770 const uint32_t pin_list[], uint32_t pin_count,
771 const char *resource_source_name,
772 const uint8_t *vendor_data, uint16_t vendor_data_len)
773{
774 uint8_t flags = edge_level | (active_level << 1) | (shared << 3);
775
776 return aml_gpio_connection(AML_INTERRUPT_CONNECTION, con_and_pro, flags,
777 pin_config, 0, debounce_timeout, pin_list,
778 pin_count, resource_source_name, vendor_data,
779 vendor_data_len);
780}
781
782
783
784
785
786Aml *aml_memory32_fixed(uint32_t addr, uint32_t size,
787 AmlReadAndWrite read_and_write)
788{
789 Aml *var = aml_alloc();
790 build_append_byte(var->buf, 0x86);
791 build_append_byte(var->buf, 9);
792 build_append_byte(var->buf, 0);
793 build_append_byte(var->buf, read_and_write);
794
795
796 build_append_byte(var->buf, extract32(addr, 0, 8));
797 build_append_byte(var->buf, extract32(addr, 8, 8));
798 build_append_byte(var->buf, extract32(addr, 16, 8));
799 build_append_byte(var->buf, extract32(addr, 24, 8));
800
801
802 build_append_byte(var->buf, extract32(size, 0, 8));
803 build_append_byte(var->buf, extract32(size, 8, 8));
804 build_append_byte(var->buf, extract32(size, 16, 8));
805 build_append_byte(var->buf, extract32(size, 24, 8));
806 return var;
807}
808
809
810
811
812
813Aml *aml_interrupt(AmlConsumerAndProducer con_and_pro,
814 AmlLevelAndEdge level_and_edge,
815 AmlActiveHighAndLow high_and_low, AmlShared shared,
816 uint32_t *irq_list, uint8_t irq_count)
817{
818 int i;
819 Aml *var = aml_alloc();
820 uint8_t irq_flags = con_and_pro | (level_and_edge << 1)
821 | (high_and_low << 2) | (shared << 3);
822 const int header_bytes_in_len = 2;
823 uint16_t len = header_bytes_in_len + irq_count * sizeof(uint32_t);
824
825 assert(irq_count > 0);
826
827 build_append_byte(var->buf, 0x89);
828 build_append_byte(var->buf, len & 0xFF);
829 build_append_byte(var->buf, len >> 8);
830 build_append_byte(var->buf, irq_flags);
831 build_append_byte(var->buf, irq_count);
832
833
834 for (i = 0; i < irq_count; i++) {
835 build_append_int_noprefix(var->buf, irq_list[i], 4);
836 }
837 return var;
838}
839
840
841Aml *aml_io(AmlIODecode dec, uint16_t min_base, uint16_t max_base,
842 uint8_t aln, uint8_t len)
843{
844 Aml *var = aml_alloc();
845 build_append_byte(var->buf, 0x47);
846 build_append_byte(var->buf, dec);
847 build_append_byte(var->buf, min_base & 0xff);
848 build_append_byte(var->buf, (min_base >> 8) & 0xff);
849 build_append_byte(var->buf, max_base & 0xff);
850 build_append_byte(var->buf, (max_base >> 8) & 0xff);
851 build_append_byte(var->buf, aln);
852 build_append_byte(var->buf, len);
853 return var;
854}
855
856
857
858
859
860
861
862
863Aml *aml_irq_no_flags(uint8_t irq)
864{
865 uint16_t irq_mask;
866 Aml *var = aml_alloc();
867
868 assert(irq < 16);
869 build_append_byte(var->buf, 0x22);
870
871 irq_mask = 1U << irq;
872 build_append_byte(var->buf, irq_mask & 0xFF);
873 build_append_byte(var->buf, irq_mask >> 8);
874 return var;
875}
876
877
878Aml *aml_lnot(Aml *arg)
879{
880 Aml *var = aml_opcode(0x92 );
881 aml_append(var, arg);
882 return var;
883}
884
885
886Aml *aml_equal(Aml *arg1, Aml *arg2)
887{
888 Aml *var = aml_opcode(0x93 );
889 aml_append(var, arg1);
890 aml_append(var, arg2);
891 return var;
892}
893
894
895Aml *aml_lgreater(Aml *arg1, Aml *arg2)
896{
897 Aml *var = aml_opcode(0x94 );
898 aml_append(var, arg1);
899 aml_append(var, arg2);
900 return var;
901}
902
903
904Aml *aml_lgreater_equal(Aml *arg1, Aml *arg2)
905{
906
907 Aml *var = aml_opcode(0x92 );
908 build_append_byte(var->buf, 0x95 );
909 aml_append(var, arg1);
910 aml_append(var, arg2);
911 return var;
912}
913
914
915Aml *aml_if(Aml *predicate)
916{
917 Aml *var = aml_bundle(0xA0 , AML_PACKAGE);
918 aml_append(var, predicate);
919 return var;
920}
921
922
923Aml *aml_else(void)
924{
925 Aml *var = aml_bundle(0xA1 , AML_PACKAGE);
926 return var;
927}
928
929
930Aml *aml_while(Aml *predicate)
931{
932 Aml *var = aml_bundle(0xA2 , AML_PACKAGE);
933 aml_append(var, predicate);
934 return var;
935}
936
937
938Aml *aml_method(const char *name, int arg_count, AmlSerializeFlag sflag)
939{
940 Aml *var = aml_bundle(0x14 , AML_PACKAGE);
941 int methodflags;
942
943
944
945
946
947
948
949
950
951 assert(arg_count < 8);
952 methodflags = arg_count | (sflag << 3);
953
954 build_append_namestring(var->buf, "%s", name);
955 build_append_byte(var->buf, methodflags);
956 return var;
957}
958
959
960Aml *aml_device(const char *name_format, ...)
961{
962 va_list ap;
963 Aml *var = aml_bundle(0x82 , AML_EXT_PACKAGE);
964 va_start(ap, name_format);
965 build_append_namestringv(var->buf, name_format, ap);
966 va_end(ap);
967 return var;
968}
969
970
971Aml *aml_resource_template(void)
972{
973
974 Aml *var = aml_bundle(0x11 , AML_RES_TEMPLATE);
975 return var;
976}
977
978
979
980
981Aml *aml_buffer(int buffer_size, uint8_t *byte_list)
982{
983 int i;
984 Aml *var = aml_bundle(0x11 , AML_BUFFER);
985
986 for (i = 0; i < buffer_size; i++) {
987 if (byte_list == NULL) {
988 build_append_byte(var->buf, 0x0);
989 } else {
990 build_append_byte(var->buf, byte_list[i]);
991 }
992 }
993
994 return var;
995}
996
997
998Aml *aml_package(uint8_t num_elements)
999{
1000 Aml *var = aml_bundle(0x12 , AML_PACKAGE);
1001 build_append_byte(var->buf, num_elements);
1002 return var;
1003}
1004
1005
1006Aml *aml_operation_region(const char *name, AmlRegionSpace rs,
1007 Aml *offset, uint32_t len)
1008{
1009 Aml *var = aml_alloc();
1010 build_append_byte(var->buf, 0x5B);
1011 build_append_byte(var->buf, 0x80);
1012 build_append_namestring(var->buf, "%s", name);
1013 build_append_byte(var->buf, rs);
1014 aml_append(var, offset);
1015 build_append_int(var->buf, len);
1016 return var;
1017}
1018
1019
1020Aml *aml_named_field(const char *name, unsigned length)
1021{
1022 Aml *var = aml_alloc();
1023 build_append_nameseg(var->buf, name);
1024 build_append_pkg_length(var->buf, length, false);
1025 return var;
1026}
1027
1028
1029Aml *aml_reserved_field(unsigned length)
1030{
1031 Aml *var = aml_alloc();
1032
1033 build_append_byte(var->buf, 0x00);
1034 build_append_pkg_length(var->buf, length, false);
1035 return var;
1036}
1037
1038
1039Aml *aml_field(const char *name, AmlAccessType type, AmlLockRule lock,
1040 AmlUpdateRule rule)
1041{
1042 Aml *var = aml_bundle(0x81 , AML_EXT_PACKAGE);
1043 uint8_t flags = rule << 5 | type;
1044
1045 flags |= lock << 4;
1046
1047 build_append_namestring(var->buf, "%s", name);
1048 build_append_byte(var->buf, flags);
1049 return var;
1050}
1051
1052static
1053Aml *create_field_common(int opcode, Aml *srcbuf, Aml *index, const char *name)
1054{
1055 Aml *var = aml_opcode(opcode);
1056 aml_append(var, srcbuf);
1057 aml_append(var, index);
1058 build_append_namestring(var->buf, "%s", name);
1059 return var;
1060}
1061
1062
1063Aml *aml_create_field(Aml *srcbuf, Aml *bit_index, Aml *num_bits,
1064 const char *name)
1065{
1066 Aml *var = aml_alloc();
1067 build_append_byte(var->buf, 0x5B);
1068 build_append_byte(var->buf, 0x13);
1069 aml_append(var, srcbuf);
1070 aml_append(var, bit_index);
1071 aml_append(var, num_bits);
1072 build_append_namestring(var->buf, "%s", name);
1073 return var;
1074}
1075
1076
1077Aml *aml_create_dword_field(Aml *srcbuf, Aml *index, const char *name)
1078{
1079 return create_field_common(0x8A ,
1080 srcbuf, index, name);
1081}
1082
1083
1084Aml *aml_create_qword_field(Aml *srcbuf, Aml *index, const char *name)
1085{
1086 return create_field_common(0x8F ,
1087 srcbuf, index, name);
1088}
1089
1090
1091Aml *aml_string(const char *name_format, ...)
1092{
1093 Aml *var = aml_opcode(0x0D );
1094 va_list ap;
1095 char *s;
1096 int len;
1097
1098 va_start(ap, name_format);
1099 len = g_vasprintf(&s, name_format, ap);
1100 va_end(ap);
1101
1102 g_array_append_vals(var->buf, s, len + 1);
1103 g_free(s);
1104
1105 return var;
1106}
1107
1108
1109Aml *aml_local(int num)
1110{
1111 uint8_t op = 0x60 + num;
1112
1113 assert(num <= 7);
1114 return aml_opcode(op);
1115}
1116
1117
1118Aml *aml_varpackage(uint32_t num_elements)
1119{
1120 Aml *var = aml_bundle(0x13 , AML_PACKAGE);
1121 build_append_int(var->buf, num_elements);
1122 return var;
1123}
1124
1125
1126Aml *aml_processor(uint8_t proc_id, uint32_t pblk_addr, uint8_t pblk_len,
1127 const char *name_format, ...)
1128{
1129 va_list ap;
1130 Aml *var = aml_bundle(0x83 , AML_EXT_PACKAGE);
1131 va_start(ap, name_format);
1132 build_append_namestringv(var->buf, name_format, ap);
1133 va_end(ap);
1134 build_append_byte(var->buf, proc_id);
1135 build_append_int_noprefix(var->buf, pblk_addr, sizeof(pblk_addr));
1136 build_append_byte(var->buf, pblk_len);
1137 return var;
1138}
1139
1140static uint8_t Hex2Digit(char c)
1141{
1142 if (c >= 'A') {
1143 return c - 'A' + 10;
1144 }
1145
1146 return c - '0';
1147}
1148
1149
1150Aml *aml_eisaid(const char *str)
1151{
1152 Aml *var = aml_alloc();
1153 uint32_t id;
1154
1155 g_assert(strlen(str) == 7);
1156 id = (str[0] - 0x40) << 26 |
1157 (str[1] - 0x40) << 21 |
1158 (str[2] - 0x40) << 16 |
1159 Hex2Digit(str[3]) << 12 |
1160 Hex2Digit(str[4]) << 8 |
1161 Hex2Digit(str[5]) << 4 |
1162 Hex2Digit(str[6]);
1163
1164 build_append_byte(var->buf, 0x0C);
1165 build_append_int_noprefix(var->buf, bswap32(id), sizeof(id));
1166 return var;
1167}
1168
1169
1170static Aml *aml_as_desc_header(AmlResourceType type, AmlMinFixed min_fixed,
1171 AmlMaxFixed max_fixed, AmlDecode dec,
1172 uint8_t type_flags)
1173{
1174 uint8_t flags = max_fixed | min_fixed | dec;
1175 Aml *var = aml_alloc();
1176
1177 build_append_byte(var->buf, type);
1178 build_append_byte(var->buf, flags);
1179 build_append_byte(var->buf, type_flags);
1180 return var;
1181}
1182
1183
1184static Aml *aml_word_as_desc(AmlResourceType type, AmlMinFixed min_fixed,
1185 AmlMaxFixed max_fixed, AmlDecode dec,
1186 uint16_t addr_gran, uint16_t addr_min,
1187 uint16_t addr_max, uint16_t addr_trans,
1188 uint16_t len, uint8_t type_flags)
1189{
1190 Aml *var = aml_alloc();
1191
1192 build_append_byte(var->buf, 0x88);
1193
1194 build_append_byte(var->buf, 0x0D);
1195 build_append_byte(var->buf, 0x0);
1196
1197 aml_append(var,
1198 aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags));
1199 build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran));
1200 build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min));
1201 build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max));
1202 build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans));
1203 build_append_int_noprefix(var->buf, len, sizeof(len));
1204 return var;
1205}
1206
1207
1208static Aml *aml_dword_as_desc(AmlResourceType type, AmlMinFixed min_fixed,
1209 AmlMaxFixed max_fixed, AmlDecode dec,
1210 uint32_t addr_gran, uint32_t addr_min,
1211 uint32_t addr_max, uint32_t addr_trans,
1212 uint32_t len, uint8_t type_flags)
1213{
1214 Aml *var = aml_alloc();
1215
1216 build_append_byte(var->buf, 0x87);
1217
1218 build_append_byte(var->buf, 23);
1219 build_append_byte(var->buf, 0x0);
1220
1221
1222 aml_append(var,
1223 aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags));
1224 build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran));
1225 build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min));
1226 build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max));
1227 build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans));
1228 build_append_int_noprefix(var->buf, len, sizeof(len));
1229 return var;
1230}
1231
1232
1233static Aml *aml_qword_as_desc(AmlResourceType type, AmlMinFixed min_fixed,
1234 AmlMaxFixed max_fixed, AmlDecode dec,
1235 uint64_t addr_gran, uint64_t addr_min,
1236 uint64_t addr_max, uint64_t addr_trans,
1237 uint64_t len, uint8_t type_flags)
1238{
1239 Aml *var = aml_alloc();
1240
1241 build_append_byte(var->buf, 0x8A);
1242
1243 build_append_byte(var->buf, 0x2B);
1244 build_append_byte(var->buf, 0x0);
1245
1246 aml_append(var,
1247 aml_as_desc_header(type, min_fixed, max_fixed, dec, type_flags));
1248 build_append_int_noprefix(var->buf, addr_gran, sizeof(addr_gran));
1249 build_append_int_noprefix(var->buf, addr_min, sizeof(addr_min));
1250 build_append_int_noprefix(var->buf, addr_max, sizeof(addr_max));
1251 build_append_int_noprefix(var->buf, addr_trans, sizeof(addr_trans));
1252 build_append_int_noprefix(var->buf, len, sizeof(len));
1253 return var;
1254}
1255
1256
1257
1258
1259
1260
1261
1262Aml *aml_word_bus_number(AmlMinFixed min_fixed, AmlMaxFixed max_fixed,
1263 AmlDecode dec, uint16_t addr_gran,
1264 uint16_t addr_min, uint16_t addr_max,
1265 uint16_t addr_trans, uint16_t len)
1266
1267{
1268 return aml_word_as_desc(AML_BUS_NUMBER_RANGE, min_fixed, max_fixed, dec,
1269 addr_gran, addr_min, addr_max, addr_trans, len, 0);
1270}
1271
1272
1273
1274
1275
1276
1277
1278Aml *aml_word_io(AmlMinFixed min_fixed, AmlMaxFixed max_fixed,
1279 AmlDecode dec, AmlISARanges isa_ranges,
1280 uint16_t addr_gran, uint16_t addr_min,
1281 uint16_t addr_max, uint16_t addr_trans,
1282 uint16_t len)
1283
1284{
1285 return aml_word_as_desc(AML_IO_RANGE, min_fixed, max_fixed, dec,
1286 addr_gran, addr_min, addr_max, addr_trans, len,
1287 isa_ranges);
1288}
1289
1290
1291
1292
1293
1294
1295
1296Aml *aml_dword_io(AmlMinFixed min_fixed, AmlMaxFixed max_fixed,
1297 AmlDecode dec, AmlISARanges isa_ranges,
1298 uint32_t addr_gran, uint32_t addr_min,
1299 uint32_t addr_max, uint32_t addr_trans,
1300 uint32_t len)
1301
1302{
1303 return aml_dword_as_desc(AML_IO_RANGE, min_fixed, max_fixed, dec,
1304 addr_gran, addr_min, addr_max, addr_trans, len,
1305 isa_ranges);
1306}
1307
1308
1309
1310
1311
1312
1313
1314Aml *aml_dword_memory(AmlDecode dec, AmlMinFixed min_fixed,
1315 AmlMaxFixed max_fixed, AmlCacheable cacheable,
1316 AmlReadAndWrite read_and_write,
1317 uint32_t addr_gran, uint32_t addr_min,
1318 uint32_t addr_max, uint32_t addr_trans,
1319 uint32_t len)
1320{
1321 uint8_t flags = read_and_write | (cacheable << 1);
1322
1323 return aml_dword_as_desc(AML_MEMORY_RANGE, min_fixed, max_fixed,
1324 dec, addr_gran, addr_min, addr_max,
1325 addr_trans, len, flags);
1326}
1327
1328
1329
1330
1331
1332
1333
1334Aml *aml_qword_memory(AmlDecode dec, AmlMinFixed min_fixed,
1335 AmlMaxFixed max_fixed, AmlCacheable cacheable,
1336 AmlReadAndWrite read_and_write,
1337 uint64_t addr_gran, uint64_t addr_min,
1338 uint64_t addr_max, uint64_t addr_trans,
1339 uint64_t len)
1340{
1341 uint8_t flags = read_and_write | (cacheable << 1);
1342
1343 return aml_qword_as_desc(AML_MEMORY_RANGE, min_fixed, max_fixed,
1344 dec, addr_gran, addr_min, addr_max,
1345 addr_trans, len, flags);
1346}
1347
1348
1349Aml *aml_dma(AmlDmaType typ, AmlDmaBusMaster bm, AmlTransferSize sz,
1350 uint8_t channel)
1351{
1352 Aml *var = aml_alloc();
1353 uint8_t flags = sz | bm << 2 | typ << 5;
1354
1355 assert(channel < 8);
1356 build_append_byte(var->buf, 0x2A);
1357 build_append_byte(var->buf, 1U << channel);
1358 build_append_byte(var->buf, flags);
1359 return var;
1360}
1361
1362
1363Aml *aml_sleep(uint64_t msec)
1364{
1365 Aml *var = aml_alloc();
1366 build_append_byte(var->buf, 0x5B);
1367 build_append_byte(var->buf, 0x22);
1368 aml_append(var, aml_int(msec));
1369 return var;
1370}
1371
1372static uint8_t Hex2Byte(const char *src)
1373{
1374 int hi, lo;
1375
1376 hi = Hex2Digit(src[0]);
1377 assert(hi >= 0);
1378 assert(hi <= 15);
1379
1380 lo = Hex2Digit(src[1]);
1381 assert(lo >= 0);
1382 assert(lo <= 15);
1383 return (hi << 4) | lo;
1384}
1385
1386
1387
1388
1389
1390
1391Aml *aml_touuid(const char *uuid)
1392{
1393 Aml *var = aml_bundle(0x11 , AML_BUFFER);
1394
1395 assert(strlen(uuid) == 36);
1396 assert(uuid[8] == '-');
1397 assert(uuid[13] == '-');
1398 assert(uuid[18] == '-');
1399 assert(uuid[23] == '-');
1400
1401 build_append_byte(var->buf, Hex2Byte(uuid + 6));
1402 build_append_byte(var->buf, Hex2Byte(uuid + 4));
1403 build_append_byte(var->buf, Hex2Byte(uuid + 2));
1404 build_append_byte(var->buf, Hex2Byte(uuid + 0));
1405
1406 build_append_byte(var->buf, Hex2Byte(uuid + 11));
1407 build_append_byte(var->buf, Hex2Byte(uuid + 9));
1408
1409 build_append_byte(var->buf, Hex2Byte(uuid + 16));
1410 build_append_byte(var->buf, Hex2Byte(uuid + 14));
1411
1412 build_append_byte(var->buf, Hex2Byte(uuid + 19));
1413 build_append_byte(var->buf, Hex2Byte(uuid + 21));
1414
1415 build_append_byte(var->buf, Hex2Byte(uuid + 24));
1416 build_append_byte(var->buf, Hex2Byte(uuid + 26));
1417 build_append_byte(var->buf, Hex2Byte(uuid + 28));
1418 build_append_byte(var->buf, Hex2Byte(uuid + 30));
1419 build_append_byte(var->buf, Hex2Byte(uuid + 32));
1420 build_append_byte(var->buf, Hex2Byte(uuid + 34));
1421
1422 return var;
1423}
1424
1425
1426
1427
1428Aml *aml_unicode(const char *str)
1429{
1430 int i = 0;
1431 Aml *var = aml_bundle(0x11 , AML_BUFFER);
1432
1433 do {
1434 build_append_byte(var->buf, str[i]);
1435 build_append_byte(var->buf, 0);
1436 i++;
1437 } while (i <= strlen(str));
1438
1439 return var;
1440}
1441
1442
1443Aml *aml_refof(Aml *arg)
1444{
1445 Aml *var = aml_opcode(0x71 );
1446 aml_append(var, arg);
1447 return var;
1448}
1449
1450
1451Aml *aml_derefof(Aml *arg)
1452{
1453 Aml *var = aml_opcode(0x83 );
1454 aml_append(var, arg);
1455 return var;
1456}
1457
1458
1459Aml *aml_sizeof(Aml *arg)
1460{
1461 Aml *var = aml_opcode(0x87 );
1462 aml_append(var, arg);
1463 return var;
1464}
1465
1466
1467Aml *aml_mutex(const char *name, uint8_t sync_level)
1468{
1469 Aml *var = aml_alloc();
1470 build_append_byte(var->buf, 0x5B);
1471 build_append_byte(var->buf, 0x01);
1472 build_append_namestring(var->buf, "%s", name);
1473 assert(!(sync_level & 0xF0));
1474 build_append_byte(var->buf, sync_level);
1475 return var;
1476}
1477
1478
1479Aml *aml_acquire(Aml *mutex, uint16_t timeout)
1480{
1481 Aml *var = aml_alloc();
1482 build_append_byte(var->buf, 0x5B);
1483 build_append_byte(var->buf, 0x23);
1484 aml_append(var, mutex);
1485 build_append_int_noprefix(var->buf, timeout, sizeof(timeout));
1486 return var;
1487}
1488
1489
1490Aml *aml_release(Aml *mutex)
1491{
1492 Aml *var = aml_alloc();
1493 build_append_byte(var->buf, 0x5B);
1494 build_append_byte(var->buf, 0x27);
1495 aml_append(var, mutex);
1496 return var;
1497}
1498
1499
1500Aml *aml_alias(const char *source_object, const char *alias_object)
1501{
1502 Aml *var = aml_opcode(0x06 );
1503 aml_append(var, aml_name("%s", source_object));
1504 aml_append(var, aml_name("%s", alias_object));
1505 return var;
1506}
1507
1508
1509Aml *aml_concatenate(Aml *source1, Aml *source2, Aml *target)
1510{
1511 return build_opcode_2arg_dst(0x73 , source1, source2,
1512 target);
1513}
1514
1515
1516Aml *aml_object_type(Aml *object)
1517{
1518 Aml *var = aml_opcode(0x8E );
1519 aml_append(var, object);
1520 return var;
1521}
1522
1523void
1524build_header(BIOSLinker *linker, GArray *table_data,
1525 AcpiTableHeader *h, const char *sig, int len, uint8_t rev,
1526 const char *oem_id, const char *oem_table_id)
1527{
1528 unsigned tbl_offset = (char *)h - table_data->data;
1529 unsigned checksum_offset = (char *)&h->checksum - table_data->data;
1530 memcpy(&h->signature, sig, 4);
1531 h->length = cpu_to_le32(len);
1532 h->revision = rev;
1533
1534 if (oem_id) {
1535 strncpy((char *)h->oem_id, oem_id, sizeof h->oem_id);
1536 } else {
1537 memcpy(h->oem_id, ACPI_BUILD_APPNAME6, 6);
1538 }
1539
1540 if (oem_table_id) {
1541 strncpy((char *)h->oem_table_id, oem_table_id, sizeof(h->oem_table_id));
1542 } else {
1543 memcpy(h->oem_table_id, ACPI_BUILD_APPNAME4, 4);
1544 memcpy(h->oem_table_id + 4, sig, 4);
1545 }
1546
1547 h->oem_revision = cpu_to_le32(1);
1548 memcpy(h->asl_compiler_id, ACPI_BUILD_APPNAME4, 4);
1549 h->asl_compiler_revision = cpu_to_le32(1);
1550
1551 bios_linker_loader_add_checksum(linker, ACPI_BUILD_TABLE_FILE,
1552 tbl_offset, len, checksum_offset);
1553}
1554
1555void *acpi_data_push(GArray *table_data, unsigned size)
1556{
1557 unsigned off = table_data->len;
1558 g_array_set_size(table_data, off + size);
1559 return table_data->data + off;
1560}
1561
1562unsigned acpi_data_len(GArray *table)
1563{
1564 assert(g_array_get_element_size(table) == 1);
1565 return table->len;
1566}
1567
1568void acpi_add_table(GArray *table_offsets, GArray *table_data)
1569{
1570 uint32_t offset = table_data->len;
1571 g_array_append_val(table_offsets, offset);
1572}
1573
1574void acpi_build_tables_init(AcpiBuildTables *tables)
1575{
1576 tables->rsdp = g_array_new(false, true , 1);
1577 tables->table_data = g_array_new(false, true , 1);
1578 tables->tcpalog = g_array_new(false, true , 1);
1579 tables->vmgenid = g_array_new(false, true , 1);
1580 tables->linker = bios_linker_loader_init();
1581}
1582
1583void acpi_build_tables_cleanup(AcpiBuildTables *tables, bool mfre)
1584{
1585 bios_linker_loader_cleanup(tables->linker);
1586 g_array_free(tables->rsdp, true);
1587 g_array_free(tables->table_data, true);
1588 g_array_free(tables->tcpalog, mfre);
1589 g_array_free(tables->vmgenid, mfre);
1590}
1591
1592
1593void
1594build_rsdt(GArray *table_data, BIOSLinker *linker, GArray *table_offsets,
1595 const char *oem_id, const char *oem_table_id)
1596{
1597 int i;
1598 unsigned rsdt_entries_offset;
1599 AcpiRsdtDescriptorRev1 *rsdt;
1600 const unsigned table_data_len = (sizeof(uint32_t) * table_offsets->len);
1601 const unsigned rsdt_entry_size = sizeof(rsdt->table_offset_entry[0]);
1602 const size_t rsdt_len = sizeof(*rsdt) + table_data_len;
1603
1604 rsdt = acpi_data_push(table_data, rsdt_len);
1605 rsdt_entries_offset = (char *)rsdt->table_offset_entry - table_data->data;
1606 for (i = 0; i < table_offsets->len; ++i) {
1607 uint32_t ref_tbl_offset = g_array_index(table_offsets, uint32_t, i);
1608 uint32_t rsdt_entry_offset = rsdt_entries_offset + rsdt_entry_size * i;
1609
1610
1611 bios_linker_loader_add_pointer(linker,
1612 ACPI_BUILD_TABLE_FILE, rsdt_entry_offset, rsdt_entry_size,
1613 ACPI_BUILD_TABLE_FILE, ref_tbl_offset);
1614 }
1615 build_header(linker, table_data,
1616 (void *)rsdt, "RSDT", rsdt_len, 1, oem_id, oem_table_id);
1617}
1618
1619
1620void
1621build_xsdt(GArray *table_data, BIOSLinker *linker, GArray *table_offsets,
1622 const char *oem_id, const char *oem_table_id)
1623{
1624 int i;
1625 unsigned xsdt_entries_offset;
1626 AcpiXsdtDescriptorRev2 *xsdt;
1627 const unsigned table_data_len = (sizeof(uint64_t) * table_offsets->len);
1628 const unsigned xsdt_entry_size = sizeof(xsdt->table_offset_entry[0]);
1629 const size_t xsdt_len = sizeof(*xsdt) + table_data_len;
1630
1631 xsdt = acpi_data_push(table_data, xsdt_len);
1632 xsdt_entries_offset = (char *)xsdt->table_offset_entry - table_data->data;
1633 for (i = 0; i < table_offsets->len; ++i) {
1634 uint64_t ref_tbl_offset = g_array_index(table_offsets, uint32_t, i);
1635 uint64_t xsdt_entry_offset = xsdt_entries_offset + xsdt_entry_size * i;
1636
1637
1638 bios_linker_loader_add_pointer(linker,
1639 ACPI_BUILD_TABLE_FILE, xsdt_entry_offset, xsdt_entry_size,
1640 ACPI_BUILD_TABLE_FILE, ref_tbl_offset);
1641 }
1642 build_header(linker, table_data,
1643 (void *)xsdt, "XSDT", xsdt_len, 1, oem_id, oem_table_id);
1644}
1645
1646void build_srat_memory(AcpiSratMemoryAffinity *numamem, uint64_t base,
1647 uint64_t len, int node, MemoryAffinityFlags flags)
1648{
1649 numamem->type = ACPI_SRAT_MEMORY;
1650 numamem->length = sizeof(*numamem);
1651 numamem->proximity = cpu_to_le32(node);
1652 numamem->flags = cpu_to_le32(flags);
1653 numamem->base_addr = cpu_to_le64(base);
1654 numamem->range_length = cpu_to_le64(len);
1655}
1656
1657
1658
1659
1660
1661void build_slit(GArray *table_data, BIOSLinker *linker)
1662{
1663 int slit_start, i, j;
1664 slit_start = table_data->len;
1665
1666 acpi_data_push(table_data, sizeof(AcpiTableHeader));
1667
1668 build_append_int_noprefix(table_data, nb_numa_nodes, 8);
1669 for (i = 0; i < nb_numa_nodes; i++) {
1670 for (j = 0; j < nb_numa_nodes; j++) {
1671 assert(numa_info[i].distance[j]);
1672 build_append_int_noprefix(table_data, numa_info[i].distance[j], 1);
1673 }
1674 }
1675
1676 build_header(linker, table_data,
1677 (void *)(table_data->data + slit_start),
1678 "SLIT",
1679 table_data->len - slit_start, 1, NULL, NULL);
1680}
1681
1682
1683void build_fadt(GArray *tbl, BIOSLinker *linker, const AcpiFadtData *f,
1684 const char *oem_id, const char *oem_table_id)
1685{
1686 int off;
1687 int fadt_start = tbl->len;
1688
1689 acpi_data_push(tbl, sizeof(AcpiTableHeader));
1690
1691
1692 off = tbl->len;
1693 build_append_int_noprefix(tbl, 0, 4);
1694 if (f->facs_tbl_offset) {
1695 bios_linker_loader_add_pointer(linker,
1696 ACPI_BUILD_TABLE_FILE, off, 4,
1697 ACPI_BUILD_TABLE_FILE, *f->facs_tbl_offset);
1698 }
1699
1700
1701 off = tbl->len;
1702 build_append_int_noprefix(tbl, 0, 4);
1703 if (f->dsdt_tbl_offset) {
1704 bios_linker_loader_add_pointer(linker,
1705 ACPI_BUILD_TABLE_FILE, off, 4,
1706 ACPI_BUILD_TABLE_FILE, *f->dsdt_tbl_offset);
1707 }
1708
1709
1710 build_append_int_noprefix(tbl, f->int_model , 1);
1711
1712 build_append_int_noprefix(tbl, 0 , 1);
1713 build_append_int_noprefix(tbl, f->sci_int, 2);
1714 build_append_int_noprefix(tbl, f->smi_cmd, 4);
1715 build_append_int_noprefix(tbl, f->acpi_enable_cmd, 1);
1716 build_append_int_noprefix(tbl, f->acpi_disable_cmd, 1);
1717 build_append_int_noprefix(tbl, 0 , 1);
1718
1719 build_append_int_noprefix(tbl, 0, 1);
1720 build_append_int_noprefix(tbl, f->pm1a_evt.address, 4);
1721 build_append_int_noprefix(tbl, 0, 4);
1722 build_append_int_noprefix(tbl, f->pm1a_cnt.address, 4);
1723 build_append_int_noprefix(tbl, 0, 4);
1724 build_append_int_noprefix(tbl, 0, 4);
1725 build_append_int_noprefix(tbl, f->pm_tmr.address, 4);
1726 build_append_int_noprefix(tbl, f->gpe0_blk.address, 4);
1727 build_append_int_noprefix(tbl, 0, 4);
1728
1729 build_append_int_noprefix(tbl, f->pm1a_evt.bit_width / 8, 1);
1730
1731 build_append_int_noprefix(tbl, f->pm1a_cnt.bit_width / 8, 1);
1732 build_append_int_noprefix(tbl, 0, 1);
1733 build_append_int_noprefix(tbl, f->pm_tmr.bit_width / 8, 1);
1734
1735 build_append_int_noprefix(tbl, f->gpe0_blk.bit_width / 8, 1);
1736 build_append_int_noprefix(tbl, 0, 1);
1737 build_append_int_noprefix(tbl, 0, 1);
1738 build_append_int_noprefix(tbl, 0, 1);
1739 build_append_int_noprefix(tbl, f->plvl2_lat, 2);
1740 build_append_int_noprefix(tbl, f->plvl3_lat, 2);
1741 build_append_int_noprefix(tbl, 0, 2);
1742 build_append_int_noprefix(tbl, 0, 2);
1743 build_append_int_noprefix(tbl, 0, 1);
1744 build_append_int_noprefix(tbl, 0, 1);
1745 build_append_int_noprefix(tbl, 0, 1);
1746 build_append_int_noprefix(tbl, 0, 1);
1747 build_append_int_noprefix(tbl, f->rtc_century, 1);
1748 build_append_int_noprefix(tbl, 0, 2);
1749 build_append_int_noprefix(tbl, 0, 1);
1750 build_append_int_noprefix(tbl, f->flags, 4);
1751
1752 if (f->rev == 1) {
1753 goto build_hdr;
1754 }
1755
1756 build_append_gas_from_struct(tbl, &f->reset_reg);
1757 build_append_int_noprefix(tbl, f->reset_val, 1);
1758
1759 if ((f->rev >= 6) || ((f->rev == 5) && f->minor_ver > 0)) {
1760 build_append_int_noprefix(tbl, f->arm_boot_arch, 2);
1761
1762 build_append_int_noprefix(tbl, f->minor_ver, 1);
1763 } else {
1764 build_append_int_noprefix(tbl, 0, 3);
1765 }
1766 build_append_int_noprefix(tbl, 0, 8);
1767
1768
1769 off = tbl->len;
1770 build_append_int_noprefix(tbl, 0, 8);
1771 if (f->xdsdt_tbl_offset) {
1772 bios_linker_loader_add_pointer(linker,
1773 ACPI_BUILD_TABLE_FILE, off, 8,
1774 ACPI_BUILD_TABLE_FILE, *f->xdsdt_tbl_offset);
1775 }
1776
1777 build_append_gas_from_struct(tbl, &f->pm1a_evt);
1778
1779 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0);
1780 build_append_gas_from_struct(tbl, &f->pm1a_cnt);
1781
1782 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0);
1783
1784 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0);
1785 build_append_gas_from_struct(tbl, &f->pm_tmr);
1786 build_append_gas_from_struct(tbl, &f->gpe0_blk);
1787 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0);
1788
1789 if (f->rev <= 4) {
1790 goto build_hdr;
1791 }
1792
1793
1794 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0);
1795
1796 build_append_gas(tbl, AML_AS_SYSTEM_MEMORY, 0 , 0, 0, 0);
1797
1798
1799 assert(f->rev == 5);
1800
1801build_hdr:
1802 build_header(linker, tbl, (void *)(tbl->data + fadt_start),
1803 "FACP", tbl->len - fadt_start, f->rev, oem_id, oem_table_id);
1804}
1805