mb/google/brya/var/orisa: Update Type C DisplayPort HPD Configuration
[coreboot2.git] / src / acpi / acpigen.c
blob4049df0dd633b335de3e38533d4afd72ecc13ff6
1 /* SPDX-License-Identifier: GPL-2.0-only */
3 /* How much nesting do we support? */
4 #define ACPIGEN_LENSTACK_SIZE 10
6 /* If you need to change this, change acpigen_pop_len too */
7 #define ACPIGEN_RSVD_PKGLEN_BYTES 3
9 #include <lib.h>
10 #include <string.h>
11 #include <acpi/acpigen.h>
12 #include <assert.h>
13 #include <commonlib/helpers.h>
14 #include <console/console.h>
15 #include <device/device.h>
16 #include <device/soundwire.h>
17 #include <stdio.h>
18 #include <types.h>
20 static char *gencurrent;
22 char *len_stack[ACPIGEN_LENSTACK_SIZE];
23 int ltop = 0;
25 void acpigen_write_len_f(void)
27 ASSERT(ltop < (ACPIGEN_LENSTACK_SIZE - 1))
28 len_stack[ltop++] = gencurrent;
29 /* Reserve ACPIGEN_RSVD_PKGLEN_BYTES bytes for PkgLength. The actual byte values will
30 be written later in the corresponding acpigen_pop_len call. */
31 for (size_t i = 0; i < ACPIGEN_RSVD_PKGLEN_BYTES; i++)
32 acpigen_emit_byte(0);
35 void acpigen_pop_len(void)
37 size_t len;
38 ASSERT(ltop > 0)
39 char *p = len_stack[--ltop];
40 len = gencurrent - p;
41 const size_t payload_len = len - ACPIGEN_RSVD_PKGLEN_BYTES;
43 if (len <= 0x3f + 2) {
44 /* PkgLength of up to 0x3f can be encoded in one PkgLength byte instead of the
45 reserved 3 bytes. Since only 1 PkgLength byte will be written, the payload
46 data needs to be moved by 2 bytes */
47 memmove(&p[ACPIGEN_RSVD_PKGLEN_BYTES - 2],
48 &p[ACPIGEN_RSVD_PKGLEN_BYTES], payload_len);
49 /* Adjust the PkgLength to take into account that we only use 1 of the 3
50 reserved bytes */
51 len -= 2;
52 /* The two most significant bits of PkgLength get the value of 0 to indicate
53 there are no additional PkgLength bytes. In this case the single PkgLength
54 byte encodes the length in its lower 6 bits */
55 p[0] = len;
56 /* Adjust pointer for next ACPI bytecode byte */
57 acpigen_set_current(p + len);
58 } else if (len <= 0xfff + 1) {
59 /* PkgLength of up to 0xfff can be encoded in 2 PkgLength bytes instead of the
60 reserved 3 bytes. Since only 2 PkgLength bytes will be written, the payload
61 data needs to be moved by 1 byte */
62 memmove(&p[ACPIGEN_RSVD_PKGLEN_BYTES - 1],
63 &p[ACPIGEN_RSVD_PKGLEN_BYTES], payload_len);
64 /* Adjust the PkgLength to take into account that we only use 2 of the 3
65 reserved bytes */
66 len -= 1;
67 /* The two most significant bits of PkgLength get the value of 1 to indicate
68 there's a second PkgLength byte. The lower 4 bits of the first PkgLength
69 byte and the second PkgLength byte encode the length */
70 p[0] = (0x1 << 6 | (len & 0xf));
71 p[1] = (len >> 4 & 0xff);
72 /* Adjust pointer for next ACPI bytecode byte */
73 acpigen_set_current(p + len);
74 } else if (len <= 0xfffff) {
75 /* PkgLength of up to 0xfffff can be encoded in 3 PkgLength bytes. Since this
76 is the amount of reserved bytes, no need to move the payload in this case */
77 /* The two most significant bits of PkgLength get the value of 2 to indicate
78 there are two more PkgLength bytes following the first one. The lower 4 bits
79 of the first PkgLength byte and the two following PkgLength bytes encode the
80 length */
81 p[0] = (0x2 << 6 | (len & 0xf));
82 p[1] = (len >> 4 & 0xff);
83 p[2] = (len >> 12 & 0xff);
84 /* No need to adjust pointer for next ACPI bytecode byte */
85 } else {
86 /* The case of PkgLength up to 0xfffffff isn't supported at the moment */
87 printk(BIOS_ERR, "%s: package length exceeds maximum of 0xfffff.\n", __func__);
91 void acpigen_set_current(char *curr)
93 gencurrent = curr;
96 char *acpigen_get_current(void)
98 return gencurrent;
101 void acpigen_emit_byte(unsigned char b)
103 (*gencurrent++) = b;
106 void acpigen_emit_ext_op(uint8_t op)
108 acpigen_emit_byte(EXT_OP_PREFIX);
109 acpigen_emit_byte(op);
112 void acpigen_emit_word(unsigned int data)
114 acpigen_emit_byte(data & 0xff);
115 acpigen_emit_byte((data >> 8) & 0xff);
118 void acpigen_emit_dword(unsigned int data)
120 acpigen_emit_byte(data & 0xff);
121 acpigen_emit_byte((data >> 8) & 0xff);
122 acpigen_emit_byte((data >> 16) & 0xff);
123 acpigen_emit_byte((data >> 24) & 0xff);
126 char *acpigen_write_package(int nr_el)
128 char *p;
129 acpigen_emit_byte(PACKAGE_OP);
130 acpigen_write_len_f();
131 p = acpigen_get_current();
132 acpigen_emit_byte(nr_el);
133 return p;
136 void acpigen_write_byte(unsigned int data)
138 acpigen_emit_byte(BYTE_PREFIX);
139 acpigen_emit_byte(data & 0xff);
142 void acpigen_write_word(unsigned int data)
144 acpigen_emit_byte(WORD_PREFIX);
145 acpigen_emit_word(data);
148 void acpigen_write_dword(unsigned int data)
150 acpigen_emit_byte(DWORD_PREFIX);
151 acpigen_emit_dword(data);
154 void acpigen_write_qword(uint64_t data)
156 acpigen_emit_byte(QWORD_PREFIX);
157 acpigen_emit_dword(data & 0xffffffff);
158 acpigen_emit_dword((data >> 32) & 0xffffffff);
161 void acpigen_write_zero(void)
163 acpigen_emit_byte(ZERO_OP);
166 void acpigen_write_one(void)
168 acpigen_emit_byte(ONE_OP);
171 void acpigen_write_ones(void)
173 acpigen_emit_byte(ONES_OP);
176 void acpigen_write_integer(uint64_t data)
178 if (data == 0)
179 acpigen_write_zero();
180 else if (data == 1)
181 acpigen_write_one();
182 else if (data <= 0xff)
183 acpigen_write_byte((unsigned char)data);
184 else if (data <= 0xffff)
185 acpigen_write_word((unsigned int)data);
186 else if (data <= 0xffffffff)
187 acpigen_write_dword((unsigned int)data);
188 else
189 acpigen_write_qword(data);
192 void acpigen_write_name_byte(const char *name, uint8_t val)
194 acpigen_write_name(name);
195 acpigen_write_byte(val);
198 void acpigen_write_name_dword(const char *name, uint32_t val)
200 acpigen_write_name(name);
201 acpigen_write_dword(val);
204 void acpigen_write_name_qword(const char *name, uint64_t val)
206 acpigen_write_name(name);
207 acpigen_write_qword(val);
210 void acpigen_write_name_integer(const char *name, uint64_t val)
212 acpigen_write_name(name);
213 acpigen_write_integer(val);
216 void acpigen_write_name_string(const char *name, const char *string)
218 acpigen_write_name(name);
219 acpigen_write_string(string);
222 void acpigen_write_name_unicode(const char *name, const char *string)
224 const size_t len = strlen(string) + 1;
225 acpigen_write_name(name);
226 acpigen_emit_byte(BUFFER_OP);
227 acpigen_write_len_f();
228 acpigen_write_integer(2 * len);
229 for (size_t i = 0; i < len; i++) {
230 const signed char c = string[i];
231 /* Simple ASCII to UTF-16 conversion, replace non ASCII characters */
232 acpigen_emit_word(c >= 0 ? c : '?');
234 acpigen_pop_len();
237 void acpigen_emit_stream(const char *data, int size)
239 int i;
240 for (i = 0; i < size; i++)
241 acpigen_emit_byte(data[i]);
244 void acpigen_emit_string(const char *string)
246 acpigen_emit_stream(string, string ? strlen(string) : 0);
247 acpigen_emit_byte('\0'); /* NUL */
250 void acpigen_write_string(const char *string)
252 acpigen_emit_byte(STRING_PREFIX);
253 acpigen_emit_string(string);
256 void acpigen_write_coreboot_hid(enum coreboot_acpi_ids id)
258 char hid[9]; /* BOOTxxxx */
260 snprintf(hid, sizeof(hid), "%.4s%04X", COREBOOT_ACPI_ID, id);
261 acpigen_write_name_string("_HID", hid);
265 * The naming conventions for ACPI namespace names are a bit tricky as
266 * each element has to be 4 chars wide ("All names are a fixed 32 bits.")
267 * and "By convention, when an ASL compiler pads a name shorter than 4
268 * characters, it is done so with trailing underscores ('_')".
270 * Check sections 5.3, 18.2.2 and 18.4 of ACPI spec 3.0 for details.
273 static void acpigen_emit_simple_namestring(const char *name)
275 int i;
276 char ud[] = "____";
277 for (i = 0; i < 4; i++) {
278 if ((name[i] == '\0') || (name[i] == '.')) {
279 acpigen_emit_stream(ud, 4 - i);
280 break;
282 acpigen_emit_byte(name[i]);
286 static void acpigen_emit_double_namestring(const char *name, int dotpos)
288 acpigen_emit_byte(DUAL_NAME_PREFIX);
289 acpigen_emit_simple_namestring(name);
290 acpigen_emit_simple_namestring(&name[dotpos + 1]);
293 static void acpigen_emit_multi_namestring(const char *name)
295 int count = 0;
296 unsigned char *pathlen;
297 acpigen_emit_byte(MULTI_NAME_PREFIX);
298 acpigen_emit_byte(ZERO_OP);
299 pathlen = ((unsigned char *)acpigen_get_current()) - 1;
301 while (name[0] != '\0') {
302 acpigen_emit_simple_namestring(name);
303 /* find end or next entity */
304 while ((name[0] != '.') && (name[0] != '\0'))
305 name++;
306 /* forward to next */
307 if (name[0] == '.')
308 name++;
309 count++;
312 pathlen[0] = count;
315 void acpigen_emit_namestring(const char *namepath)
317 int dotcount = 0, i;
318 int dotpos = 0;
320 /* Check for NULL pointer */
321 if (!namepath)
322 return;
324 /* We can start with a '\'. */
325 if (namepath[0] == '\\') {
326 acpigen_emit_byte('\\');
327 namepath++;
330 /* And there can be any number of '^' */
331 while (namepath[0] == '^') {
332 acpigen_emit_byte('^');
333 namepath++;
336 /* If we have only \\ or only ^...^. Then we need to put a null
337 name (0x00). */
338 if (namepath[0] == '\0') {
339 acpigen_emit_byte(ZERO_OP);
340 return;
343 i = 0;
344 while (namepath[i] != '\0') {
345 if (namepath[i] == '.') {
346 dotcount++;
347 dotpos = i;
349 i++;
352 if (dotcount == 0)
353 acpigen_emit_simple_namestring(namepath);
354 else if (dotcount == 1)
355 acpigen_emit_double_namestring(namepath, dotpos);
356 else
357 acpigen_emit_multi_namestring(namepath);
360 void acpigen_write_name(const char *name)
362 acpigen_emit_byte(NAME_OP);
363 acpigen_emit_namestring(name);
366 void acpigen_write_scope(const char *name)
368 acpigen_emit_byte(SCOPE_OP);
369 acpigen_write_len_f();
370 acpigen_emit_namestring(name);
373 void acpigen_get_package_op_element(uint8_t package_op, unsigned int element, uint8_t dest_op)
375 /* <dest_op> = DeRefOf (<package_op>[<element>]) */
376 acpigen_write_store();
377 acpigen_emit_byte(DEREF_OP);
378 acpigen_emit_byte(INDEX_OP);
379 acpigen_emit_byte(package_op);
380 acpigen_write_integer(element);
381 acpigen_emit_byte(ZERO_OP); /* Ignore Index() Destination */
382 acpigen_emit_byte(dest_op);
385 void acpigen_set_package_op_element_int(uint8_t package_op, unsigned int element, uint64_t src)
387 /* DeRefOf (<package>[<element>]) = <src> */
388 acpigen_write_store();
389 acpigen_write_integer(src);
390 acpigen_emit_byte(DEREF_OP);
391 acpigen_emit_byte(INDEX_OP);
392 acpigen_emit_byte(package_op);
393 acpigen_write_integer(element);
394 acpigen_emit_byte(ZERO_OP); /* Ignore Index() Destination */
397 void acpigen_get_package_element(const char *package, unsigned int element, uint8_t dest_op)
399 /* <dest_op> = <package>[<element>] */
400 acpigen_write_store();
401 acpigen_emit_byte(INDEX_OP);
402 acpigen_emit_namestring(package);
403 acpigen_write_integer(element);
404 acpigen_emit_byte(ZERO_OP); /* Ignore Index() Destination */
405 acpigen_emit_byte(dest_op);
408 void acpigen_set_package_element_int(const char *package, unsigned int element, uint64_t src)
410 /* <package>[<element>] = <src> */
411 acpigen_write_store();
412 acpigen_write_integer(src);
413 acpigen_emit_byte(INDEX_OP);
414 acpigen_emit_namestring(package);
415 acpigen_write_integer(element);
416 acpigen_emit_byte(ZERO_OP); /* Ignore Index() Destination */
419 void acpigen_set_package_element_namestr(const char *package, unsigned int element,
420 const char *src)
422 /* <package>[<element>] = <src> */
423 acpigen_write_store();
424 acpigen_emit_namestring(src);
425 acpigen_emit_byte(INDEX_OP);
426 acpigen_emit_namestring(package);
427 acpigen_write_integer(element);
428 acpigen_emit_byte(ZERO_OP); /* Ignore Index() Destination */
431 void acpigen_write_processor_namestring(unsigned int cpu_index)
433 char buffer[16];
434 snprintf(buffer, sizeof(buffer), "\\_SB." CONFIG_ACPI_CPU_STRING, cpu_index);
435 acpigen_emit_namestring(buffer);
438 /* Processor() operator is deprecated as of ACPI 6.0, use Device() instead. */
439 void acpigen_write_processor(u8 cpuindex, u32 pblock_addr, u8 pblock_len)
442 Processor (\_SB.CPcpuindex, cpuindex, pblock_addr, pblock_len)
445 acpigen_emit_ext_op(PROCESSOR_OP);
446 acpigen_write_len_f();
447 acpigen_write_processor_namestring(cpuindex);
448 acpigen_emit_byte(cpuindex);
449 acpigen_emit_dword(pblock_addr);
450 acpigen_emit_byte(pblock_len);
453 void acpigen_write_processor_device(unsigned int cpu_index)
455 acpigen_emit_ext_op(DEVICE_OP);
456 acpigen_write_len_f();
457 acpigen_write_processor_namestring(cpu_index);
458 acpigen_write_name_string("_HID", "ACPI0007");
459 acpigen_write_name_integer("_UID", cpu_index);
462 void acpigen_write_processor_package(const char *const name, const unsigned int first_core,
463 const unsigned int core_count)
465 unsigned int i;
467 acpigen_write_name(name);
468 acpigen_write_package(core_count);
470 for (i = first_core; i < first_core + core_count; ++i)
471 acpigen_write_processor_namestring(i);
473 acpigen_pop_len();
476 /* Method to notify all CPU cores */
477 void acpigen_write_processor_cnot(const unsigned int number_of_cores)
479 int core_id;
481 acpigen_write_method("\\_SB.CNOT", 1);
482 for (core_id = 0; core_id < number_of_cores; core_id++) {
483 acpigen_emit_byte(NOTIFY_OP);
484 acpigen_write_processor_namestring(core_id);
485 acpigen_emit_byte(ARG0_OP);
487 acpigen_pop_len();
491 * Generate ACPI AML code for OperationRegion
492 * Arg0: Pointer to struct opregion opreg = OPREGION(rname, space, offset, len)
493 * where rname is region name, space is region space, offset is region offset &
494 * len is region length.
495 * OperationRegion(regionname, regionspace, regionoffset, regionlength)
497 void acpigen_write_opregion(const struct opregion *opreg)
499 /* OpregionOp */
500 acpigen_emit_ext_op(OPREGION_OP);
501 /* NameString 4 chars only */
502 acpigen_emit_simple_namestring(opreg->name);
503 /* RegionSpace */
504 acpigen_emit_byte(opreg->regionspace);
505 /* RegionOffset & RegionLen, it can be byte word or double word */
506 acpigen_write_integer(opreg->regionoffset);
507 acpigen_write_integer(opreg->regionlen);
511 * Generate ACPI AML code for Mutex
512 * Arg0: Pointer to name of mutex
513 * Arg1: Initial value of mutex
515 void acpigen_write_mutex(const char *name, const uint8_t flags)
517 /* MutexOp */
518 acpigen_emit_ext_op(MUTEX_OP);
519 acpigen_emit_namestring(name);
520 acpigen_emit_byte(flags);
523 void acpigen_write_acquire(const char *name, const uint16_t val)
525 /* AcquireOp */
526 acpigen_emit_ext_op(ACQUIRE_OP);
527 acpigen_emit_namestring(name);
528 acpigen_emit_word(val);
531 void acpigen_write_release(const char *name)
533 /* ReleaseOp */
534 acpigen_emit_ext_op(RELEASE_OP);
535 acpigen_emit_namestring(name);
538 static void acpigen_write_field_length(uint32_t len)
540 uint8_t i, j;
541 uint8_t emit[4];
543 i = 1;
544 if (len < 0x40) {
545 emit[0] = len & 0x3F;
546 } else {
547 emit[0] = len & 0xF;
548 len >>= 4;
549 while (len) {
550 emit[i] = len & 0xFF;
551 i++;
552 len >>= 8;
555 /* Update bit 7:6 : Number of bytes followed by emit[0] */
556 emit[0] |= (i - 1) << 6;
558 for (j = 0; j < i; j++)
559 acpigen_emit_byte(emit[j]);
562 static void acpigen_write_field_offset(uint32_t offset, uint32_t current_bit_pos)
564 uint32_t diff_bits;
566 if (offset < current_bit_pos) {
567 printk(BIOS_WARNING, "%s: Cannot move offset backward", __func__);
568 return;
571 diff_bits = offset - current_bit_pos;
572 /* Upper limit */
573 if (diff_bits > 0xFFFFFFF) {
574 printk(BIOS_WARNING, "%s: Offset very large to encode", __func__);
575 return;
578 acpigen_emit_byte(0);
579 acpigen_write_field_length(diff_bits);
582 void acpigen_write_field_name(const char *name, uint32_t size)
584 acpigen_emit_simple_namestring(name);
585 acpigen_write_field_length(size);
588 static void acpigen_write_field_reserved(uint32_t size)
590 acpigen_emit_byte(0);
591 acpigen_write_field_length(size);
595 * Generate ACPI AML code for Field
596 * Arg0: region name
597 * Arg1: Pointer to struct fieldlist.
598 * Arg2: no. of entries in Arg1
599 * Arg3: flags which indicate filed access type, lock rule & update rule.
600 * Example with fieldlist
601 * struct fieldlist l[] = {
602 * FIELDLIST_OFFSET(0x84),
603 * FIELDLIST_NAMESTR("PMCS", 2),
604 * FIELDLIST_RESERVED(6),
605 * };
606 * acpigen_write_field("UART", l, ARRAY_SIZE(l), FIELD_ANYACC | FIELD_NOLOCK |
607 * FIELD_PRESERVE);
608 * Output:
609 * Field (UART, AnyAcc, NoLock, Preserve)
611 * Offset (0x84),
612 * PMCS, 2,
613 * , 6,
616 void acpigen_write_field(const char *name, const struct fieldlist *l, size_t count,
617 uint8_t flags)
619 uint16_t i;
620 uint32_t current_bit_pos = 0;
622 /* FieldOp */
623 acpigen_emit_ext_op(FIELD_OP);
624 /* Package Length */
625 acpigen_write_len_f();
626 /* NameString 4 chars only */
627 acpigen_emit_simple_namestring(name);
628 /* Field Flag */
629 acpigen_emit_byte(flags);
631 for (i = 0; i < count; i++) {
632 switch (l[i].type) {
633 case NAME_STRING:
634 acpigen_write_field_name(l[i].name, l[i].bits);
635 current_bit_pos += l[i].bits;
636 break;
637 case RESERVED:
638 acpigen_write_field_reserved(l[i].bits);
639 current_bit_pos += l[i].bits;
640 break;
641 case OFFSET:
642 acpigen_write_field_offset(l[i].bits, current_bit_pos);
643 current_bit_pos = l[i].bits;
644 break;
645 default:
646 printk(BIOS_ERR, "%s: Invalid field type 0x%X\n", __func__, l[i].type);
647 break;
650 acpigen_pop_len();
654 * Generate ACPI AML code for IndexField
655 * Arg0: region name
656 * Arg1: Pointer to struct fieldlist.
657 * Arg2: no. of entries in Arg1
658 * Arg3: flags which indicate filed access type, lock rule & update rule.
659 * Example with fieldlist
660 * struct fieldlist l[] = {
661 * FIELDLIST_OFFSET(0x84),
662 * FIELDLIST_NAMESTR("PMCS", 2),
663 * };
664 * acpigen_write_field("IDX", "DATA" l, ARRAY_SIZE(l), FIELD_ANYACC |
665 * FIELD_NOLOCK |
666 * FIELD_PRESERVE);
667 * Output:
668 * IndexField (IDX, DATA, AnyAcc, NoLock, Preserve)
670 * Offset (0x84),
671 * PMCS, 2
674 void acpigen_write_indexfield(const char *idx, const char *data, struct fieldlist *l,
675 size_t count, uint8_t flags)
677 uint16_t i;
678 uint32_t current_bit_pos = 0;
680 /* FieldOp */
681 acpigen_emit_ext_op(INDEX_FIELD_OP);
682 /* Package Length */
683 acpigen_write_len_f();
684 /* NameString 4 chars only */
685 acpigen_emit_simple_namestring(idx);
686 /* NameString 4 chars only */
687 acpigen_emit_simple_namestring(data);
688 /* Field Flag */
689 acpigen_emit_byte(flags);
691 for (i = 0; i < count; i++) {
692 switch (l[i].type) {
693 case NAME_STRING:
694 acpigen_write_field_name(l[i].name, l[i].bits);
695 current_bit_pos += l[i].bits;
696 break;
697 case OFFSET:
698 acpigen_write_field_offset(l[i].bits, current_bit_pos);
699 current_bit_pos = l[i].bits;
700 break;
701 default:
702 printk(BIOS_ERR, "%s: Invalid field type 0x%X\n", __func__, l[i].type);
703 break;
706 acpigen_pop_len();
709 void acpigen_write_empty_PCT(void)
712 Name (_PCT, Package (0x02)
714 ResourceTemplate ()
716 Register (FFixedHW,
717 0x00, // Bit Width
718 0x00, // Bit Offset
719 0x0000000000000000, // Address
723 ResourceTemplate ()
725 Register (FFixedHW,
726 0x00, // Bit Width
727 0x00, // Bit Offset
728 0x0000000000000000, // Address
733 static char stream[] = {
734 /* 00000030 "0._PCT.," */
735 0x08, 0x5F, 0x50, 0x43, 0x54, 0x12, 0x2C,
736 /* 00000038 "........" */
737 0x02, 0x11, 0x14, 0x0A, 0x11, 0x82, 0x0C, 0x00,
738 /* 00000040 "........" */
739 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
740 /* 00000048 "....y..." */
741 0x00, 0x00, 0x00, 0x00, 0x79, 0x00, 0x11, 0x14,
742 /* 00000050 "........" */
743 0x0A, 0x11, 0x82, 0x0C, 0x00, 0x7F, 0x00, 0x00,
744 /* 00000058 "........" */
745 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
746 0x00, 0x79, 0x00
748 acpigen_emit_stream(stream, ARRAY_SIZE(stream));
751 void acpigen_write_PTC(uint8_t duty_width, uint8_t duty_offset, uint16_t p_cnt)
754 Name (_PTC, Package (0x02)
756 ResourceTemplate ()
758 Register (FFixedHW,
759 0x00, // Duty Width
760 0x00, // Duty Offset
761 0x0000000000000000, // P_CNT IO Address
765 ResourceTemplate ()
767 Register (FFixedHW,
768 0x00, // Duty Width
769 0x00, // Duty Offset
770 0x0000000000000000, // P_CNT IO Address
775 acpi_addr_t addr = {
776 .bit_width = duty_width,
777 .bit_offset = duty_offset,
778 .access_size = ACPI_ACCESS_SIZE_UNDEFINED,
779 .addrl = p_cnt,
780 .addrh = 0,
783 if (addr.addrl != 0)
784 addr.space_id = ACPI_ADDRESS_SPACE_IO;
785 else
786 addr.space_id = ACPI_ADDRESS_SPACE_FIXED;
788 acpigen_write_name("_PTC");
789 acpigen_write_package(2);
791 /* ControlRegister */
792 acpigen_write_register_resource(&addr);
794 /* StatusRegister */
795 acpigen_write_register_resource(&addr);
797 acpigen_pop_len();
800 void acpigen_write_empty_PTC(void)
802 acpigen_write_PTC(0, 0, 0);
805 static void __acpigen_write_method(const char *name, uint8_t flags)
807 acpigen_emit_byte(METHOD_OP);
808 acpigen_write_len_f();
809 acpigen_emit_namestring(name);
810 acpigen_emit_byte(flags);
813 /* Method (name, nargs, NotSerialized) */
814 void acpigen_write_method(const char *name, int nargs)
816 __acpigen_write_method(name, (nargs & 7));
819 /* Method (name, nargs, Serialized) */
820 void acpigen_write_method_serialized(const char *name, int nargs)
822 __acpigen_write_method(name, (nargs & 7) | (1 << 3));
825 void acpigen_write_device(const char *name)
827 acpigen_emit_ext_op(DEVICE_OP);
828 acpigen_write_len_f();
829 acpigen_emit_namestring(name);
832 void acpigen_write_thermal_zone(const char *name)
834 acpigen_emit_ext_op(THERMAL_ZONE_OP);
835 acpigen_write_len_f();
836 acpigen_emit_namestring(name);
839 void acpigen_write_STA(uint8_t status)
842 * Method (_STA, 0, NotSerialized) { Return (status) }
844 acpigen_write_method("_STA", 0);
845 acpigen_emit_byte(RETURN_OP);
846 acpigen_write_byte(status);
847 acpigen_pop_len();
850 void acpigen_write_STA_ext(const char *namestring)
853 * Method (_STA, 0, NotSerialized) { Return (ext_val) }
855 acpigen_write_method("_STA", 0);
856 acpigen_emit_byte(RETURN_OP);
857 acpigen_emit_namestring(namestring);
858 acpigen_pop_len();
861 void acpigen_write_BBN(uint8_t base_bus_number)
864 * Method (_BBN, 0, NotSerialized) { Return (status) }
866 acpigen_write_method("_BBN", 0);
867 acpigen_emit_byte(RETURN_OP);
868 acpigen_write_byte(base_bus_number);
869 acpigen_pop_len();
872 void acpigen_write_SEG(uint8_t segment_group_number)
875 * Method (_SEG, 0, NotSerialized) { Return (status) }
877 acpigen_write_method("_SEG", 0);
878 acpigen_emit_byte(RETURN_OP);
879 acpigen_write_byte(segment_group_number);
880 acpigen_pop_len();
883 void acpigen_write_LPI_package(u64 level, const struct acpi_lpi_state *states, u16 nentries)
886 * Name (_LPI, Package (0x06) // _LPI: Low Power Idle States
888 * 0x0000,
889 * 0x0000000000000000,
890 * 0x0003,
891 * Package (0x0A)
893 * 0x00000002,
894 * 0x00000001,
895 * 0x00000001,
896 * 0x00000000,
897 * 0x00000000,
898 * 0x00000000,
899 * ResourceTemplate ()
901 * Register (FFixedHW,
902 * 0x02, // Bit Width
903 * 0x02, // Bit Offset
904 * 0x0000000000000000, // Address
905 * ,)
906 * },
908 * ResourceTemplate ()
910 * Register (SystemMemory,
911 * 0x00, // Bit Width
912 * 0x00, // Bit Offset
913 * 0x0000000000000000, // Address
914 * ,)
915 * },
917 * ResourceTemplate ()
919 * Register (SystemMemory,
920 * 0x00, // Bit Width
921 * 0x00, // Bit Offset
922 * 0x0000000000000000, // Address
923 * ,)
924 * },
926 * "C1"
927 * },
928 * ...
932 acpigen_write_name("_LPI");
933 acpigen_write_package(3 + nentries);
934 acpigen_write_word(0); /* Revision */
935 acpigen_write_qword(level);
936 acpigen_write_word(nentries);
938 for (size_t i = 0; i < nentries; i++, states++) {
939 acpigen_write_package(0xA);
940 acpigen_write_dword(states->min_residency_us);
941 acpigen_write_dword(states->worst_case_wakeup_latency_us);
942 acpigen_write_dword(states->flags);
943 acpigen_write_dword(states->arch_context_lost_flags);
944 acpigen_write_dword(states->residency_counter_frequency_hz);
945 acpigen_write_dword(states->enabled_parent_state);
946 acpigen_write_register_resource(&states->entry_method);
947 acpigen_write_register_resource(&states->residency_counter_register);
948 acpigen_write_register_resource(&states->usage_counter_register);
949 acpigen_write_string(states->state_name);
950 acpigen_pop_len();
952 acpigen_pop_len();
956 * Generates a func with max supported P-states.
958 void acpigen_write_PPC(u8 nr)
961 Method (_PPC, 0, NotSerialized)
963 Return (nr)
966 acpigen_write_method("_PPC", 0);
967 acpigen_emit_byte(RETURN_OP);
968 /* arg */
969 acpigen_write_byte(nr);
970 acpigen_pop_len();
974 * Generates a func with max supported P-states saved
975 * in the variable PPCM.
977 void acpigen_write_PPC_NVS(void)
980 Method (_PPC, 0, NotSerialized)
982 Return (PPCM)
985 acpigen_write_method("_PPC", 0);
986 acpigen_emit_byte(RETURN_OP);
987 /* arg */
988 acpigen_emit_namestring("PPCM");
989 acpigen_pop_len();
992 void acpigen_write_TPC(const char *gnvs_tpc_limit)
995 // Sample _TPC method
996 Method (_TPC, 0, NotSerialized)
998 Return (\TLVL)
1001 acpigen_write_method("_TPC", 0);
1002 acpigen_emit_byte(RETURN_OP);
1003 acpigen_emit_namestring(gnvs_tpc_limit);
1004 acpigen_pop_len();
1007 void acpigen_write_PRW(u32 wake, u32 level)
1010 * Name (_PRW, Package () { wake, level }
1012 acpigen_write_name("_PRW");
1013 acpigen_write_package(2);
1014 acpigen_write_integer(wake);
1015 acpigen_write_integer(level);
1016 acpigen_pop_len();
1019 void acpigen_write_PSS_package(u32 coreFreq, u32 power, u32 transLat, u32 busmLat, u32 control,
1020 u32 status)
1022 acpigen_write_package(6);
1023 acpigen_write_dword(coreFreq);
1024 acpigen_write_dword(power);
1025 acpigen_write_dword(transLat);
1026 acpigen_write_dword(busmLat);
1027 acpigen_write_dword(control);
1028 acpigen_write_dword(status);
1029 acpigen_pop_len();
1031 printk(BIOS_DEBUG, "PSS: %uMHz power %u control 0x%x status 0x%x\n", coreFreq, power,
1032 control, status);
1035 void acpigen_write_pss_object(const struct acpi_sw_pstate *pstate_values, size_t nentries)
1037 size_t pstate;
1039 acpigen_write_name("_PSS");
1040 acpigen_write_package(nentries);
1041 for (pstate = 0; pstate < nentries; pstate++) {
1042 acpigen_write_PSS_package(
1043 pstate_values->core_freq, pstate_values->power,
1044 pstate_values->transition_latency, pstate_values->bus_master_latency,
1045 pstate_values->control_value, pstate_values->status_value);
1046 pstate_values++;
1049 acpigen_pop_len();
1052 void acpigen_write_PSD_package(u32 domain, u32 numprocs, PSD_coord coordtype)
1054 acpigen_write_name("_PSD");
1055 acpigen_write_package(1);
1056 acpigen_write_package(5);
1057 acpigen_write_byte(5); // 5 values
1058 acpigen_write_byte(0); // revision 0
1059 acpigen_write_dword(domain);
1060 acpigen_write_dword(coordtype);
1061 acpigen_write_dword(numprocs);
1062 acpigen_pop_len();
1063 acpigen_pop_len();
1066 void acpigen_write_CST_package_entry(const acpi_cstate_t *cstate)
1068 acpigen_write_package(4);
1069 acpigen_write_register_resource(&cstate->resource);
1070 acpigen_write_byte(cstate->ctype);
1071 acpigen_write_word(cstate->latency);
1072 acpigen_write_dword(cstate->power);
1073 acpigen_pop_len();
1076 void acpigen_write_CST_package(const acpi_cstate_t *cstate, int nentries)
1078 int i;
1079 acpigen_write_name("_CST");
1080 acpigen_write_package(nentries+1);
1081 acpigen_write_integer(nentries);
1083 for (i = 0; i < nentries; i++)
1084 acpigen_write_CST_package_entry(cstate + i);
1086 acpigen_pop_len();
1089 void acpigen_write_CSD_package(u32 domain, u32 numprocs, CSD_coord coordtype,
1090 u32 index)
1092 acpigen_write_name("_CSD");
1093 acpigen_write_package(1);
1094 acpigen_write_package(6);
1095 acpigen_write_integer(6); // 6 values
1096 acpigen_write_byte(0); // revision 0
1097 acpigen_write_dword(domain);
1098 acpigen_write_dword(coordtype);
1099 acpigen_write_dword(numprocs);
1100 acpigen_write_dword(index);
1101 acpigen_pop_len();
1102 acpigen_pop_len();
1105 void acpigen_write_TSS_package(int entries, acpi_tstate_t *tstate_list)
1108 Sample _TSS package with 100% and 50% duty cycles
1109 Name (_TSS, Package (0x02)
1111 Package(){100, 1000, 0, 0x00, 0)
1112 Package(){50, 520, 0, 0x18, 0)
1115 int i;
1116 acpi_tstate_t *tstate = tstate_list;
1118 acpigen_write_name("_TSS");
1119 acpigen_write_package(entries);
1121 for (i = 0; i < entries; i++) {
1122 acpigen_write_package(5);
1123 acpigen_write_dword(tstate->percent);
1124 acpigen_write_dword(tstate->power);
1125 acpigen_write_dword(tstate->latency);
1126 acpigen_write_dword(tstate->control);
1127 acpigen_write_dword(tstate->status);
1128 acpigen_pop_len();
1129 tstate++;
1132 acpigen_pop_len();
1135 void acpigen_write_TSD_package(u32 domain, u32 numprocs, PSD_coord coordtype)
1137 acpigen_write_name("_TSD");
1138 acpigen_write_package(1);
1139 acpigen_write_package(5);
1140 acpigen_write_byte(5); // 5 values
1141 acpigen_write_byte(0); // revision 0
1142 acpigen_write_dword(domain);
1143 acpigen_write_dword(coordtype);
1144 acpigen_write_dword(numprocs);
1145 acpigen_pop_len();
1146 acpigen_pop_len();
1149 void acpigen_write_mem32fixed(int readwrite, u32 base, u32 size)
1152 * ACPI 4.0 section 6.4.3.4: 32-Bit Fixed Memory Range Descriptor
1153 * Byte 0:
1154 * Bit7 : 1 => big item
1155 * Bit6-0: 0000110 (0x6) => 32-bit fixed memory
1157 acpigen_emit_byte(0x86);
1158 /* Byte 1+2: length (0x0009) */
1159 acpigen_emit_byte(0x09);
1160 acpigen_emit_byte(0x00);
1161 /* bit1-7 are ignored */
1162 acpigen_emit_byte(readwrite ? 0x01 : 0x00);
1163 acpigen_emit_dword(base);
1164 acpigen_emit_dword(size);
1167 static void acpigen_write_register(const acpi_addr_t *addr)
1169 acpigen_emit_byte(0x82); /* Register Descriptor */
1170 acpigen_emit_byte(0x0c); /* Register Length 7:0 */
1171 acpigen_emit_byte(0x00); /* Register Length 15:8 */
1172 acpigen_emit_byte(addr->space_id); /* Address Space ID */
1173 acpigen_emit_byte(addr->bit_width); /* Register Bit Width */
1174 acpigen_emit_byte(addr->bit_offset); /* Register Bit Offset */
1175 acpigen_emit_byte(addr->access_size); /* Register Access Size */
1176 acpigen_emit_dword(addr->addrl); /* Register Address Low */
1177 acpigen_emit_dword(addr->addrh); /* Register Address High */
1180 void acpigen_write_register_resource(const acpi_addr_t *addr)
1182 acpigen_write_resourcetemplate_header();
1183 acpigen_write_register(addr);
1184 acpigen_write_resourcetemplate_footer();
1187 void acpigen_write_irq(u16 mask)
1190 * ACPI 3.0b section 6.4.2.1: IRQ Descriptor
1191 * Byte 0:
1192 * Bit7 : 0 => small item
1193 * Bit6-3: 0100 (0x4) => IRQ port descriptor
1194 * Bit2-0: 010 (0x2) => 2 Bytes long
1196 acpigen_emit_byte(0x22);
1197 acpigen_emit_byte(mask & 0xff);
1198 acpigen_emit_byte((mask >> 8) & 0xff);
1201 void acpigen_write_io16(u16 min, u16 max, u8 align, u8 len, u8 decode16)
1204 * ACPI 4.0 section 6.4.2.6: I/O Port Descriptor
1205 * Byte 0:
1206 * Bit7 : 0 => small item
1207 * Bit6-3: 1000 (0x8) => I/O port descriptor
1208 * Bit2-0: 111 (0x7) => 7 Bytes long
1210 acpigen_emit_byte(0x47);
1211 /* Does the device decode all 16 or just 10 bits? */
1212 /* bit1-7 are ignored */
1213 acpigen_emit_byte(decode16 ? 0x01 : 0x00);
1214 /* minimum base address the device may be configured for */
1215 acpigen_emit_byte(min & 0xff);
1216 acpigen_emit_byte((min >> 8) & 0xff);
1217 /* maximum base address the device may be configured for */
1218 acpigen_emit_byte(max & 0xff);
1219 acpigen_emit_byte((max >> 8) & 0xff);
1220 /* alignment for min base */
1221 acpigen_emit_byte(align & 0xff);
1222 acpigen_emit_byte(len & 0xff);
1225 void acpigen_write_resourcetemplate_header(void)
1228 * A ResourceTemplate() is a Buffer() with a
1229 * (Byte|Word|DWord) containing the length, followed by one or more
1230 * resource items, terminated by the end tag.
1231 * (small item 0xf, len 1)
1233 acpigen_emit_byte(BUFFER_OP);
1234 acpigen_write_len_f();
1235 acpigen_emit_byte(WORD_PREFIX);
1236 len_stack[ltop++] = acpigen_get_current();
1237 /* Add 2 dummy bytes for the ACPI word (keep aligned with
1238 the calculation in acpigen_write_resourcetemplate() below). */
1239 acpigen_emit_byte(0x00);
1240 acpigen_emit_byte(0x00);
1243 void acpigen_write_resourcetemplate_footer(void)
1245 char *p = len_stack[--ltop];
1246 int len;
1248 * end tag (acpi 4.0 Section 6.4.2.8)
1249 * 0x79 <checksum>
1250 * 0x00 is treated as a good checksum according to the spec
1251 * and is what iasl generates.
1253 acpigen_emit_byte(0x79);
1254 acpigen_emit_byte(0x00);
1256 /* Start counting past the 2-bytes length added in
1257 acpigen_write_resourcetemplate() above. */
1258 len = acpigen_get_current() - (p + 2);
1260 /* patch len word */
1261 p[0] = len & 0xff;
1262 p[1] = (len >> 8) & 0xff;
1263 /* patch len field */
1264 acpigen_pop_len();
1267 static void acpigen_add_mainboard_rsvd_mem32(void *gp, struct device *dev, struct resource *res)
1269 acpigen_write_mem32fixed(0, res->base, res->size);
1272 static void acpigen_add_mainboard_rsvd_io(void *gp, struct device *dev, struct resource *res)
1274 resource_t base = res->base;
1275 resource_t size = res->size;
1276 while (size > 0) {
1277 resource_t sz = size > 255 ? 255 : size;
1278 acpigen_write_io16(base, base, 0, sz, 1);
1279 size -= sz;
1280 base += sz;
1284 void acpigen_write_mainboard_resource_template(void)
1286 acpigen_write_resourcetemplate_header();
1288 /* Add reserved memory ranges. */
1289 search_global_resources(
1290 IORESOURCE_MEM | IORESOURCE_RESERVE,
1291 IORESOURCE_MEM | IORESOURCE_RESERVE,
1292 acpigen_add_mainboard_rsvd_mem32, 0);
1294 /* Add reserved io ranges. */
1295 search_global_resources(
1296 IORESOURCE_IO | IORESOURCE_RESERVE,
1297 IORESOURCE_IO | IORESOURCE_RESERVE,
1298 acpigen_add_mainboard_rsvd_io, 0);
1300 acpigen_write_resourcetemplate_footer();
1303 void acpigen_write_mainboard_resources(const char *scope, const char *name)
1305 acpigen_write_scope(scope);
1306 acpigen_write_name(name);
1307 acpigen_write_mainboard_resource_template();
1308 acpigen_pop_len();
1311 static int hex2bin(const char c)
1313 if (c >= 'A' && c <= 'F')
1314 return c - 'A' + 10;
1315 if (c >= 'a' && c <= 'f')
1316 return c - 'a' + 10;
1317 return c - '0';
1320 void acpigen_emit_eisaid(const char *eisaid)
1322 u32 compact = 0;
1324 /* Clamping individual values would be better but
1325 there is a disagreement over what is a valid
1326 EISA id, so accept anything and don't clamp,
1327 parent code should create a valid EISAid.
1329 compact |= (eisaid[0] - 'A' + 1) << 26;
1330 compact |= (eisaid[1] - 'A' + 1) << 21;
1331 compact |= (eisaid[2] - 'A' + 1) << 16;
1332 compact |= hex2bin(eisaid[3]) << 12;
1333 compact |= hex2bin(eisaid[4]) << 8;
1334 compact |= hex2bin(eisaid[5]) << 4;
1335 compact |= hex2bin(eisaid[6]);
1337 acpigen_emit_byte(0xc);
1338 acpigen_emit_byte((compact >> 24) & 0xff);
1339 acpigen_emit_byte((compact >> 16) & 0xff);
1340 acpigen_emit_byte((compact >> 8) & 0xff);
1341 acpigen_emit_byte(compact & 0xff);
1345 * ToUUID(uuid)
1347 * ACPI 6.1 Section 19.6.136 table 19-385 defines a special output
1348 * order for the bytes that make up a UUID Buffer object.
1349 * UUID byte order for input:
1350 * aabbccdd-eeff-gghh-iijj-kkllmmnnoopp
1351 * UUID byte order for output:
1352 * ddccbbaa-ffee-hhgg-iijj-kkllmmnnoopp
1354 #define UUID_LEN 16
1355 void acpigen_write_uuid(const char *uuid)
1357 uint8_t buf[UUID_LEN];
1358 size_t i, order[UUID_LEN] = { 3, 2, 1, 0, 5, 4, 7, 6,
1359 8, 9, 10, 11, 12, 13, 14, 15 };
1361 /* Parse UUID string into bytes */
1362 if (hexstrtobin(uuid, buf, UUID_LEN) < UUID_LEN)
1363 return;
1365 /* BufferOp */
1366 acpigen_emit_byte(BUFFER_OP);
1367 acpigen_write_len_f();
1369 /* Buffer length in bytes */
1370 acpigen_write_word(UUID_LEN);
1372 /* Output UUID in expected order */
1373 for (i = 0; i < UUID_LEN; i++)
1374 acpigen_emit_byte(buf[order[i]]);
1376 acpigen_pop_len();
1380 * Name (_PRx, Package(One) { name })
1381 * ...
1382 * PowerResource (name, level, order)
1384 void acpigen_write_power_res(const char *name, uint8_t level, uint16_t order,
1385 const char * const dev_states[], size_t dev_states_count)
1387 size_t i;
1388 for (i = 0; i < dev_states_count; i++) {
1389 acpigen_write_name(dev_states[i]);
1390 acpigen_write_package(1);
1391 acpigen_emit_simple_namestring(name);
1392 acpigen_pop_len(); /* Package */
1395 acpigen_emit_ext_op(POWER_RES_OP);
1397 acpigen_write_len_f();
1399 acpigen_emit_simple_namestring(name);
1400 acpigen_emit_byte(level);
1401 acpigen_emit_word(order);
1404 /* Sleep (ms) */
1405 void acpigen_write_sleep(uint64_t sleep_ms)
1407 acpigen_emit_ext_op(SLEEP_OP);
1408 acpigen_write_integer(sleep_ms);
1411 void acpigen_write_store(void)
1413 acpigen_emit_byte(STORE_OP);
1416 /* Store (src, dst) */
1417 void acpigen_write_store_ops(uint8_t src, uint8_t dst)
1419 acpigen_write_store();
1420 acpigen_emit_byte(src);
1421 acpigen_emit_byte(dst);
1424 /* Store (src, "namestr") */
1425 void acpigen_write_store_op_to_namestr(uint8_t src, const char *dst)
1427 acpigen_write_store();
1428 acpigen_emit_byte(src);
1429 acpigen_emit_namestring(dst);
1432 /* Store (src, "namestr") */
1433 void acpigen_write_store_int_to_namestr(uint64_t src, const char *dst)
1435 acpigen_write_store();
1436 acpigen_write_integer(src);
1437 acpigen_emit_namestring(dst);
1440 /* Store ("namestr", dst) */
1441 void acpigen_write_store_namestr_to_op(const char *src, uint8_t dst)
1443 acpigen_write_store();
1444 acpigen_emit_namestring(src);
1445 acpigen_emit_byte(dst);
1448 /* Store (src, dst) */
1449 void acpigen_write_store_int_to_op(uint64_t src, uint8_t dst)
1451 acpigen_write_store();
1452 acpigen_write_integer(src);
1453 acpigen_emit_byte(dst);
1456 /* Store ("namestr", "namestr") */
1457 void acpigen_write_store_namestr_to_namestr(const char *src, const char *dst)
1459 acpigen_write_store();
1460 acpigen_emit_namestring(src);
1461 acpigen_emit_namestring(dst);
1464 /* Or (arg1, arg2, res) */
1465 void acpigen_write_or(uint8_t arg1, uint8_t arg2, uint8_t res)
1467 acpigen_emit_byte(OR_OP);
1468 acpigen_emit_byte(arg1);
1469 acpigen_emit_byte(arg2);
1470 acpigen_emit_byte(res);
1473 /* Xor (arg1, arg2, res) */
1474 void acpigen_write_xor(uint8_t arg1, uint8_t arg2, uint8_t res)
1476 acpigen_emit_byte(XOR_OP);
1477 acpigen_emit_byte(arg1);
1478 acpigen_emit_byte(arg2);
1479 acpigen_emit_byte(res);
1482 /* And (arg1, arg2, res) */
1483 void acpigen_write_and(uint8_t arg1, uint8_t arg2, uint8_t res)
1485 acpigen_emit_byte(AND_OP);
1486 acpigen_emit_byte(arg1);
1487 acpigen_emit_byte(arg2);
1488 acpigen_emit_byte(res);
1491 /* Not (arg, res) */
1492 void acpigen_write_not(uint8_t arg, uint8_t res)
1494 acpigen_emit_byte(NOT_OP);
1495 acpigen_emit_byte(arg);
1496 acpigen_emit_byte(res);
1499 /* Concatenate (str, src_res, dest_res) */
1500 void acpigen_concatenate_string_op(const char *str, uint8_t src_res, uint8_t dest_res)
1502 acpigen_emit_byte(CONCATENATE_OP);
1503 acpigen_write_string(str);
1504 acpigen_emit_byte(src_res);
1505 acpigen_emit_byte(dest_res);
1508 /* Store (str, DEBUG) */
1509 void acpigen_write_debug_string(const char *str)
1511 acpigen_write_store();
1512 acpigen_write_string(str);
1513 acpigen_emit_ext_op(DEBUG_OP);
1516 /* Store (val, DEBUG) */
1517 void acpigen_write_debug_integer(uint64_t val)
1519 acpigen_write_store();
1520 acpigen_write_integer(val);
1521 acpigen_emit_ext_op(DEBUG_OP);
1524 /* Store (op, DEBUG) */
1525 void acpigen_write_debug_op(uint8_t op)
1527 acpigen_write_store();
1528 acpigen_emit_byte(op);
1529 acpigen_emit_ext_op(DEBUG_OP);
1532 /* Store (str, DEBUG) */
1533 void acpigen_write_debug_namestr(const char *str)
1535 acpigen_write_store();
1536 acpigen_emit_namestring(str);
1537 acpigen_emit_ext_op(DEBUG_OP);
1540 /* Concatenate (str1, res, tmp_res)
1541 Store(tmp_res, DEBUG) */
1542 void acpigen_write_debug_concatenate_string_op(const char *str, uint8_t res,
1543 uint8_t tmp_res)
1545 acpigen_concatenate_string_op(str, res, tmp_res);
1546 acpigen_write_debug_op(tmp_res);
1549 static void acpigen_tx_byte(unsigned char byte, void *data)
1551 acpigen_emit_byte(byte);
1554 /* Store("formatted string", DEBUG) */
1555 void acpigen_write_debug_sprintf(const char *fmt, ...)
1557 va_list args;
1559 acpigen_write_store();
1561 acpigen_emit_byte(STRING_PREFIX);
1562 va_start(args, fmt);
1563 vtxprintf(acpigen_tx_byte, fmt, args, NULL);
1564 va_end(args);
1565 acpigen_emit_byte('\0');
1567 acpigen_emit_ext_op(DEBUG_OP);
1570 void acpigen_write_if(void)
1572 acpigen_emit_byte(IF_OP);
1573 acpigen_write_len_f();
1576 /* If (And (arg1, arg2)) */
1577 void acpigen_write_if_and(uint8_t arg1, uint8_t arg2)
1579 acpigen_write_if();
1580 acpigen_emit_byte(AND_OP);
1581 acpigen_emit_byte(arg1);
1582 acpigen_emit_byte(arg2);
1586 * Generates ACPI code for checking if operand1 and operand2 are equal.
1587 * Both operand1 and operand2 are ACPI ops.
1589 * If (Lequal (op,1 op2))
1591 void acpigen_write_if_lequal_op_op(uint8_t op1, uint8_t op2)
1593 acpigen_write_if();
1594 acpigen_emit_byte(LEQUAL_OP);
1595 acpigen_emit_byte(op1);
1596 acpigen_emit_byte(op2);
1600 * Generates ACPI code for checking if operand1 is greater than operand2.
1601 * Both operand1 and operand2 are ACPI ops.
1603 * If (Lgreater (op1 op2))
1605 void acpigen_write_if_lgreater_op_op(uint8_t op1, uint8_t op2)
1607 acpigen_write_if();
1608 acpigen_emit_byte(LGREATER_OP);
1609 acpigen_emit_byte(op1);
1610 acpigen_emit_byte(op2);
1614 * Generates ACPI code for checking if operand1 and operand2 are equal, where,
1615 * operand1 is ACPI op and operand2 is an integer.
1617 * If (Lequal (op, val))
1619 void acpigen_write_if_lequal_op_int(uint8_t op, uint64_t val)
1621 acpigen_write_if();
1622 acpigen_emit_byte(LEQUAL_OP);
1623 acpigen_emit_byte(op);
1624 acpigen_write_integer(val);
1628 * Generates ACPI code for checking if operand is greater than the value, where,
1629 * operand is ACPI op and val is an integer.
1631 * If (Lgreater (op, val))
1633 void acpigen_write_if_lgreater_op_int(uint8_t op, uint64_t val)
1635 acpigen_write_if();
1636 acpigen_emit_byte(LGREATER_OP);
1637 acpigen_emit_byte(op);
1638 acpigen_write_integer(val);
1642 * Generates ACPI code for checking if operand1 and operand2 are equal, where,
1643 * operand1 is namestring and operand2 is an integer.
1645 * If (Lequal ("namestr", val))
1647 void acpigen_write_if_lequal_namestr_int(const char *namestr, uint64_t val)
1649 acpigen_write_if();
1650 acpigen_emit_byte(LEQUAL_OP);
1651 acpigen_emit_namestring(namestr);
1652 acpigen_write_integer(val);
1656 * Generates ACPI code for checking if operand1 and operand2 are equal, where,
1657 * operand1 is namestring and operand2 is an integer.
1659 * If (Lgreater ("namestr", val))
1661 void acpigen_write_if_lgreater_namestr_int(const char *namestr, uint64_t val)
1663 acpigen_write_if();
1664 acpigen_emit_byte(LGREATER_OP);
1665 acpigen_emit_namestring(namestr);
1666 acpigen_write_integer(val);
1670 * Generates ACPI code to check at runtime if an object named `namestring`
1671 * exists, and leaves the If scope open to continue execute code when this
1672 * is true. NOTE: Requires matching acpigen_write_if_end().
1674 * If (CondRefOf (NAME))
1676 void acpigen_write_if_cond_ref_of(const char *namestring)
1678 acpigen_write_if();
1679 acpigen_emit_ext_op(COND_REFOF_OP);
1680 acpigen_emit_namestring(namestring);
1681 acpigen_emit_byte(ZERO_OP); /* ignore COND_REFOF_OP destination */
1684 /* Closes previously opened if statement and generates ACPI code for else statement. */
1685 void acpigen_write_else(void)
1687 acpigen_pop_len();
1688 acpigen_emit_byte(ELSE_OP);
1689 acpigen_write_len_f();
1692 void acpigen_write_shiftleft_op_int(uint8_t src_result, uint64_t count)
1694 acpigen_emit_byte(SHIFT_LEFT_OP);
1695 acpigen_emit_byte(src_result);
1696 acpigen_write_integer(count);
1697 acpigen_emit_byte(ZERO_OP);
1700 void acpigen_write_to_buffer(uint8_t src, uint8_t dst)
1702 acpigen_emit_byte(TO_BUFFER_OP);
1703 acpigen_emit_byte(src);
1704 acpigen_emit_byte(dst);
1707 void acpigen_write_to_integer(uint8_t src, uint8_t dst)
1709 acpigen_emit_byte(TO_INTEGER_OP);
1710 acpigen_emit_byte(src);
1711 acpigen_emit_byte(dst);
1714 void acpigen_write_to_integer_from_namestring(const char *source, uint8_t dst_op)
1716 acpigen_emit_byte(TO_INTEGER_OP);
1717 acpigen_emit_namestring(source);
1718 acpigen_emit_byte(dst_op);
1721 void acpigen_write_byte_buffer(uint8_t *arr, size_t size)
1723 size_t i;
1725 acpigen_emit_byte(BUFFER_OP);
1726 acpigen_write_len_f();
1727 acpigen_write_integer(size);
1729 for (i = 0; i < size; i++)
1730 acpigen_emit_byte(arr[i]);
1732 acpigen_pop_len();
1735 void acpigen_write_return_byte_buffer(uint8_t *arr, size_t size)
1737 acpigen_emit_byte(RETURN_OP);
1738 acpigen_write_byte_buffer(arr, size);
1741 void acpigen_write_return_singleton_buffer(uint8_t arg)
1743 acpigen_write_return_byte_buffer(&arg, 1);
1746 void acpigen_write_return_op(uint8_t arg)
1748 acpigen_emit_byte(RETURN_OP);
1749 acpigen_emit_byte(arg);
1752 void acpigen_write_return_byte(uint8_t arg)
1754 acpigen_emit_byte(RETURN_OP);
1755 acpigen_write_byte(arg);
1758 void acpigen_write_return_integer(uint64_t arg)
1760 acpigen_emit_byte(RETURN_OP);
1761 acpigen_write_integer(arg);
1764 void acpigen_write_return_namestr(const char *arg)
1766 acpigen_emit_byte(RETURN_OP);
1767 acpigen_emit_namestring(arg);
1770 void acpigen_write_return_string(const char *arg)
1772 acpigen_emit_byte(RETURN_OP);
1773 acpigen_write_string(arg);
1776 void acpigen_write_upc(enum acpi_upc_type type)
1778 acpigen_write_name("_UPC");
1779 acpigen_write_package(4);
1780 /* Connectable */
1781 acpigen_write_byte(type == UPC_TYPE_UNUSED ? 0 : 0xff);
1782 /* Type */
1783 acpigen_write_byte(type);
1784 /* Reserved0 */
1785 acpigen_write_zero();
1786 /* Reserved1 */
1787 acpigen_write_zero();
1788 acpigen_pop_len();
1791 void acpigen_write_pld(const struct acpi_pld *pld)
1793 uint8_t buf[20];
1795 if (acpi_pld_to_buffer(pld, buf, ARRAY_SIZE(buf)) < 0)
1796 return;
1798 acpigen_write_name("_PLD");
1799 acpigen_write_package(1);
1800 acpigen_write_byte_buffer(buf, ARRAY_SIZE(buf));
1801 acpigen_pop_len();
1804 void acpigen_write_dsm(const char *uuid, void (**callbacks)(void *), size_t count, void *arg)
1806 struct dsm_uuid id = DSM_UUID(uuid, callbacks, count, arg);
1807 acpigen_write_dsm_uuid_arr(&id, 1);
1811 * Create a supported functions bitmask
1812 * bit 0: other functions than 0 are supported
1813 * bits 1-x: function x supported
1815 /* On GCC aarch64 the compiler is worried about alloca() having unbounded stack usage. */
1816 #if defined(__GNUC__) && !defined(__clang__)
1817 #pragma GCC diagnostic ignored "-Wstack-usage="
1818 #endif
1819 static void acpigen_dsm_uuid_enum_functions(const struct dsm_uuid *id)
1821 const size_t bytes = DIV_ROUND_UP(id->count, BITS_PER_BYTE);
1822 uint8_t *buffer = alloca(bytes);
1823 bool set = false;
1824 size_t cb_idx = 0;
1826 memset(buffer, 0, bytes);
1828 for (size_t i = 0; i < bytes; i++) {
1829 for (size_t j = 0; j < BITS_PER_BYTE; j++) {
1830 if (cb_idx >= id->count)
1831 break;
1833 if (id->callbacks[cb_idx++]) {
1834 set = true;
1835 buffer[i] |= BIT(j);
1840 if (set)
1841 buffer[0] |= BIT(0);
1843 acpigen_write_return_byte_buffer(buffer, bytes);
1846 static void acpigen_write_dsm_uuid(struct dsm_uuid *id)
1848 size_t i;
1850 /* If (LEqual (Local0, ToUUID(uuid))) */
1851 acpigen_write_if();
1852 acpigen_emit_byte(LEQUAL_OP);
1853 acpigen_emit_byte(LOCAL0_OP);
1854 acpigen_write_uuid(id->uuid);
1856 /* ToInteger (Arg2, Local1) */
1857 acpigen_write_to_integer(ARG2_OP, LOCAL1_OP);
1859 /* If (LEqual(Local1, 0)) */
1861 acpigen_write_if_lequal_op_int(LOCAL1_OP, 0);
1862 if (id->callbacks[0])
1863 id->callbacks[0](id->arg);
1864 else if (id->count)
1865 acpigen_dsm_uuid_enum_functions(id);
1866 acpigen_write_if_end();
1869 for (i = 1; i < id->count; i++) {
1870 /* If (LEqual (Local1, i)) */
1871 acpigen_write_if_lequal_op_int(LOCAL1_OP, i);
1873 /* Callback to write if handler. */
1874 if (id->callbacks[i])
1875 id->callbacks[i](id->arg);
1877 acpigen_write_if_end(); /* If */
1880 /* Default case: Return (Buffer (One) { 0x0 }) */
1881 acpigen_write_return_singleton_buffer(0x0);
1883 acpigen_write_if_end(); /* If (LEqual (Local0, ToUUID(uuid))) */
1887 * Generate ACPI AML code for _DSM method.
1888 * This function takes as input array of uuid for the device, set of callbacks
1889 * and argument to pass into the callbacks. Callbacks should ensure that Local0
1890 * and Local1 are left untouched. Use of Local2-Local7 is permitted in
1891 * callbacks.
1893 * Arguments passed into _DSM method:
1894 * Arg0 = UUID
1895 * Arg1 = Revision
1896 * Arg2 = Function index
1897 * Arg3 = Function specific arguments
1899 * AML code generated would look like:
1900 * Method (_DSM, 4, Serialized) {
1901 * ToBuffer (Arg0, Local0)
1902 * If (LEqual (Local0, ToUUID(uuid))) {
1903 * ToInteger (Arg2, Local1)
1904 * If (LEqual (Local1, 0)) {
1905 * <acpigen by callback[0]>
1907 * ...
1908 * If (LEqual (Local1, n)) {
1909 * <acpigen by callback[n]>
1911 * Return (Buffer (One) { 0x0 })
1913 * ...
1914 * If (LEqual (Local0, ToUUID(uuidn))) {
1915 * ...
1917 * Return (Buffer (One) { 0x0 })
1920 void acpigen_write_dsm_uuid_arr(struct dsm_uuid *ids, size_t count)
1922 size_t i;
1924 /* Method (_DSM, 4, Serialized) */
1925 acpigen_write_method_serialized("_DSM", 0x4);
1927 /* ToBuffer (Arg0, Local0) */
1928 acpigen_write_to_buffer(ARG0_OP, LOCAL0_OP);
1930 for (i = 0; i < count; i++)
1931 acpigen_write_dsm_uuid(&ids[i]);
1933 /* Return (Buffer (One) { 0x0 }) */
1934 acpigen_write_return_singleton_buffer(0x0);
1936 acpigen_pop_len(); /* Method _DSM */
1939 void acpigen_write_CPPC_package(const struct cppc_config *config)
1941 u32 i;
1942 u32 max;
1943 switch (config->version) {
1944 case 1:
1945 max = CPPC_MAX_FIELDS_VER_1;
1946 break;
1947 case 2:
1948 max = CPPC_MAX_FIELDS_VER_2;
1949 break;
1950 case 3:
1951 max = CPPC_MAX_FIELDS_VER_3;
1952 break;
1953 default:
1954 printk(BIOS_ERR, "CPPC version %u is not implemented\n", config->version);
1955 return;
1957 acpigen_write_name(CPPC_PACKAGE_NAME);
1959 /* Adding 2 to account for length and version fields */
1960 acpigen_write_package(max + 2);
1961 acpigen_write_dword(max + 2);
1963 acpigen_write_byte(config->version);
1965 for (i = 0; i < max; ++i) {
1966 const cppc_entry_t *entry = &config->entries[i];
1967 if (entry->type == CPPC_TYPE_DWORD)
1968 acpigen_write_dword(entry->dword);
1969 else
1970 acpigen_write_register_resource(&entry->reg);
1972 acpigen_pop_len();
1975 void acpigen_write_CPPC_method(void)
1977 char pscope[16];
1978 snprintf(pscope, sizeof(pscope),
1979 "\\_SB." CONFIG_ACPI_CPU_STRING "." CPPC_PACKAGE_NAME, 0);
1981 acpigen_write_method("_CPC", 0);
1982 acpigen_emit_byte(RETURN_OP);
1983 acpigen_emit_namestring(pscope);
1984 acpigen_pop_len();
1988 * Generate ACPI AML code for _ROM method.
1989 * This function takes as input ROM data and ROM length.
1991 * The ACPI spec isn't clear about what should happen at the end of the
1992 * ROM. Tests showed that it shouldn't truncate, but fill the remaining
1993 * bytes in the returned buffer with zeros.
1995 * Arguments passed into _DSM method:
1996 * Arg0 = Offset in Bytes
1997 * Arg1 = Bytes to return
1999 * Example:
2000 * acpigen_write_rom(0xdeadbeef, 0x10000)
2002 * AML code generated would look like:
2003 * Method (_ROM, 2, NotSerialized) {
2005 * OperationRegion("ROMS", SYSTEMMEMORY, 0xdeadbeef, 0x10000)
2006 * Field (ROMS, AnyAcc, NoLock, Preserve)
2008 * Offset (0),
2009 * RBF0, 0x80000
2012 * Store (Arg0, Local0)
2013 * Store (Arg1, Local1)
2015 * If (LGreater (Local1, 0x1000))
2017 * Store (0x1000, Local1)
2020 * Store (Local1, Local3)
2022 * If (LGreater (Local0, 0x10000))
2024 * Return(Buffer(Local1){0})
2027 * If (LGreater (Local0, 0x0f000))
2029 * Subtract (0x10000, Local0, Local2)
2030 * If (LGreater (Local1, Local2))
2032 * Store (Local2, Local1)
2036 * Name (ROM1, Buffer (Local3) {0})
2038 * Multiply (Local0, 0x08, Local0)
2039 * Multiply (Local1, 0x08, Local1)
2041 * CreateField (RBF0, Local0, Local1, TMPB)
2042 * Store (TMPB, ROM1)
2043 * Return (ROM1)
2047 void acpigen_write_rom(void *bios, const size_t length)
2049 ASSERT(bios)
2050 ASSERT(length)
2052 /* Method (_ROM, 2, Serialized) */
2053 acpigen_write_method_serialized("_ROM", 2);
2055 /* OperationRegion("ROMS", SYSTEMMEMORY, current, length) */
2056 struct opregion opreg = OPREGION("ROMS", SYSTEMMEMORY, (uintptr_t)bios, length);
2057 acpigen_write_opregion(&opreg);
2059 struct fieldlist l[] = {
2060 FIELDLIST_OFFSET(0),
2061 FIELDLIST_NAMESTR("RBF0", 8 * length),
2064 /* Field (ROMS, AnyAcc, NoLock, Preserve)
2066 * Offset (0),
2067 * RBF0, 0x80000
2068 * } */
2069 acpigen_write_field(opreg.name, l, 2, FIELD_ANYACC | FIELD_NOLOCK | FIELD_PRESERVE);
2071 /* Store (Arg0, Local0) */
2072 acpigen_write_store_ops(ARG0_OP, LOCAL0_OP);
2074 /* Store (Arg1, Local1) */
2075 acpigen_write_store_ops(ARG1_OP, LOCAL1_OP);
2077 /* ACPI SPEC requires to return at maximum 4KiB */
2078 /* If (LGreater (Local1, 0x1000)) */
2079 acpigen_write_if_lgreater_op_int(LOCAL1_OP, 0x1000);
2081 /* Store (0x1000, Local1) */
2082 acpigen_write_store_int_to_op(0x1000, LOCAL1_OP);
2084 /* Pop if */
2085 acpigen_pop_len();
2087 /* Store (Local1, Local3) */
2088 acpigen_write_store_ops(LOCAL1_OP, LOCAL3_OP);
2090 /* If (LGreater (Local0, length)) */
2091 acpigen_write_if_lgreater_op_int(LOCAL0_OP, length);
2093 /* Return(Buffer(Local1){0}) */
2094 acpigen_emit_byte(RETURN_OP);
2095 acpigen_emit_byte(BUFFER_OP);
2096 acpigen_write_len_f();
2097 acpigen_emit_byte(LOCAL1_OP);
2098 acpigen_emit_byte(0);
2099 acpigen_pop_len();
2101 /* Pop if */
2102 acpigen_pop_len();
2104 /* If (LGreater (Local0, length - 4096)) */
2105 acpigen_write_if_lgreater_op_int(LOCAL0_OP, length - 4096);
2107 /* Subtract (length, Local0, Local2) */
2108 acpigen_emit_byte(SUBTRACT_OP);
2109 acpigen_write_integer(length);
2110 acpigen_emit_byte(LOCAL0_OP);
2111 acpigen_emit_byte(LOCAL2_OP);
2113 /* If (LGreater (Local1, Local2)) */
2114 acpigen_write_if_lgreater_op_op(LOCAL1_OP, LOCAL2_OP);
2116 /* Store (Local2, Local1) */
2117 acpigen_write_store_ops(LOCAL2_OP, LOCAL1_OP);
2119 /* Pop if */
2120 acpigen_pop_len();
2122 /* Pop if */
2123 acpigen_pop_len();
2125 /* Name (ROM1, Buffer (Local3) {0}) */
2126 acpigen_write_name("ROM1");
2127 acpigen_emit_byte(BUFFER_OP);
2128 acpigen_write_len_f();
2129 acpigen_emit_byte(LOCAL3_OP);
2130 acpigen_emit_byte(0);
2131 acpigen_pop_len();
2133 /* Multiply (Local1, 0x08, Local1) */
2134 acpigen_emit_byte(MULTIPLY_OP);
2135 acpigen_emit_byte(LOCAL1_OP);
2136 acpigen_write_integer(0x08);
2137 acpigen_emit_byte(LOCAL1_OP);
2139 /* Multiply (Local0, 0x08, Local0) */
2140 acpigen_emit_byte(MULTIPLY_OP);
2141 acpigen_emit_byte(LOCAL0_OP);
2142 acpigen_write_integer(0x08);
2143 acpigen_emit_byte(LOCAL0_OP);
2145 /* CreateField (RBF0, Local0, Local1, TMPB) */
2146 acpigen_emit_ext_op(CREATEFIELD_OP);
2147 acpigen_emit_namestring("RBF0");
2148 acpigen_emit_byte(LOCAL0_OP);
2149 acpigen_emit_byte(LOCAL1_OP);
2150 acpigen_emit_namestring("TMPB");
2152 /* Store (TMPB, ROM1) */
2153 acpigen_write_store_namestr_to_namestr("TMPB", "ROM1");
2155 /* Return (ROM1) */
2156 acpigen_emit_byte(RETURN_OP);
2157 acpigen_emit_namestring("ROM1");
2159 /* Pop method */
2160 acpigen_pop_len();
2164 * Helper functions for enabling/disabling Tx GPIOs based on the GPIO
2165 * polarity. These functions end up calling acpigen_soc_{set,clear}_tx_gpio to
2166 * make callbacks into SoC acpigen code.
2168 * Returns 0 on success and -1 on error.
2170 int acpigen_enable_tx_gpio(const struct acpi_gpio *gpio)
2172 if (gpio->active_low)
2173 return acpigen_soc_clear_tx_gpio(gpio->pins[0]);
2174 else
2175 return acpigen_soc_set_tx_gpio(gpio->pins[0]);
2178 int acpigen_disable_tx_gpio(const struct acpi_gpio *gpio)
2180 if (gpio->active_low)
2181 return acpigen_soc_set_tx_gpio(gpio->pins[0]);
2182 else
2183 return acpigen_soc_clear_tx_gpio(gpio->pins[0]);
2186 void acpigen_get_rx_gpio(const struct acpi_gpio *gpio)
2188 acpigen_soc_read_rx_gpio(gpio->pins[0]);
2190 if (gpio->active_low)
2191 acpigen_write_xor(LOCAL0_OP, 1, LOCAL0_OP);
2194 void acpigen_get_tx_gpio(const struct acpi_gpio *gpio)
2196 acpigen_soc_get_tx_gpio(gpio->pins[0]);
2198 if (gpio->active_low)
2199 acpigen_write_xor(LOCAL0_OP, 1, LOCAL0_OP);
2202 /* refer to ACPI 6.4.3.5.3 Word Address Space Descriptor section for details */
2203 void acpigen_resource_word(u16 res_type, u16 gen_flags, u16 type_flags, u16 gran, u16 range_min,
2204 u16 range_max, u16 translation, u16 length)
2206 /* Byte 0: Type 1, Large Item Value 0x8: Word Address Space Descriptor */
2207 acpigen_emit_byte(0x88);
2208 /* Byte 1+2: length (0x000d) */
2209 acpigen_emit_byte(0x0d);
2210 acpigen_emit_byte(0x00);
2211 /* resource type */
2212 acpigen_emit_byte(res_type); // 0 - mem, 1 - io, 2 - bus
2213 /* general flags */
2214 acpigen_emit_byte(gen_flags);
2215 /* type flags */
2216 // refer to ACPI Table 6-234 (Memory), 6-235 (IO), 6-236 (Bus) for details
2217 acpigen_emit_byte(type_flags);
2218 /* granularity, min, max, translation, length */
2219 acpigen_emit_word(gran);
2220 acpigen_emit_word(range_min);
2221 acpigen_emit_word(range_max);
2222 acpigen_emit_word(translation);
2223 acpigen_emit_word(length);
2226 /* refer to ACPI 6.4.3.5.2 DWord Address Space Descriptor section for details */
2227 void acpigen_resource_dword(u16 res_type, u16 gen_flags, u16 type_flags, u32 gran,
2228 u32 range_min, u32 range_max, u32 translation, u32 length)
2230 /* Byte 0: Type 1, Large Item Value 0x7: DWord Address Space Descriptor */
2231 acpigen_emit_byte(0x87);
2232 /* Byte 1+2: length (0023) */
2233 acpigen_emit_byte(23);
2234 acpigen_emit_byte(0x00);
2235 /* resource type */
2236 acpigen_emit_byte(res_type); // 0 - mem, 1 - io, 2 - bus
2237 /* general flags */
2238 acpigen_emit_byte(gen_flags);
2239 /* type flags */
2240 // refer to ACPI Table 6-234 (Memory), 6-235 (IO), 6-236 (Bus) for details
2241 acpigen_emit_byte(type_flags);
2242 /* granularity, min, max, translation, length */
2243 acpigen_emit_dword(gran);
2244 acpigen_emit_dword(range_min);
2245 acpigen_emit_dword(range_max);
2246 acpigen_emit_dword(translation);
2247 acpigen_emit_dword(length);
2250 static void acpigen_emit_qword(u64 data)
2252 acpigen_emit_dword(data & 0xffffffff);
2253 acpigen_emit_dword((data >> 32) & 0xffffffff);
2256 /* refer to ACPI 6.4.3.5.1 QWord Address Space Descriptor section for details */
2257 void acpigen_resource_qword(u16 res_type, u16 gen_flags, u16 type_flags, u64 gran,
2258 u64 range_min, u64 range_max, u64 translation, u64 length)
2260 /* Byte 0: Type 1, Large Item Value 0xa: QWord Address Space Descriptor */
2261 acpigen_emit_byte(0x8a);
2262 /* Byte 1+2: length (0x002b) */
2263 acpigen_emit_byte(0x2b);
2264 acpigen_emit_byte(0x00);
2265 /* resource type */
2266 acpigen_emit_byte(res_type); // 0 - mem, 1 - io, 2 - bus
2267 /* general flags */
2268 acpigen_emit_byte(gen_flags);
2269 /* type flags */
2270 // refer to ACPI Table 6-234 (Memory), 6-235 (IO), 6-236 (Bus) for details
2271 acpigen_emit_byte(type_flags);
2272 /* granularity, min, max, translation, length */
2273 acpigen_emit_qword(gran);
2274 acpigen_emit_qword(range_min);
2275 acpigen_emit_qword(range_max);
2276 acpigen_emit_qword(translation);
2277 acpigen_emit_qword(length);
2280 void acpigen_resource_producer_bus_number(u16 bus_base, u16 bus_limit)
2282 acpigen_resource_word(RSRC_TYPE_BUS, /* res_type */
2283 ADDR_SPACE_GENERAL_FLAG_MAX_FIXED
2284 | ADDR_SPACE_GENERAL_FLAG_MIN_FIXED
2285 | ADDR_SPACE_GENERAL_FLAG_DEC_POS
2286 | ADDR_SPACE_GENERAL_FLAG_PRODUCER, /* gen_flags */
2287 BUS_NUM_RANGE_RESOURCE_FLAG, /* type_flags */
2288 0, /* gran */
2289 bus_base, /* range_min */
2290 bus_limit, /* range_max */
2291 0x0, /* translation */
2292 bus_limit - bus_base + 1); /* length */
2295 void acpigen_resource_producer_io(u16 io_base, u16 io_limit)
2297 acpigen_resource_dword(RSRC_TYPE_IO, /* res_type */
2298 ADDR_SPACE_GENERAL_FLAG_MAX_FIXED
2299 | ADDR_SPACE_GENERAL_FLAG_MIN_FIXED
2300 | ADDR_SPACE_GENERAL_FLAG_DEC_POS
2301 | ADDR_SPACE_GENERAL_FLAG_PRODUCER, /* gen_flags */
2302 IO_RSRC_FLAG_ENTIRE_RANGE, /* type_flags */
2303 0, /* gran */
2304 io_base, /* range_min */
2305 io_limit, /* range_max */
2306 0x0, /* translation */
2307 io_limit - io_base + 1); /* length */
2310 static void acpigen_resource_mmio32(u32 mmio_base, u32 mmio_limit, u16 gen_flags,
2311 u16 type_flags)
2313 acpigen_resource_dword(RSRC_TYPE_MEM, /* res_type */
2314 gen_flags, /* gen_flags */
2315 type_flags, /* type_flags */
2316 0, /* gran */
2317 mmio_base, /* range_min */
2318 mmio_limit, /* range_max */
2319 0x0, /* translation */
2320 mmio_limit - mmio_base + 1); /* length */
2323 static void acpigen_resource_mmio64(u64 mmio_base, u64 mmio_limit, u16 gen_flags,
2324 u16 type_flags)
2326 acpigen_resource_qword(RSRC_TYPE_MEM, /* res_type */
2327 gen_flags, /* gen_flags */
2328 type_flags, /* type_flags */
2329 0, /* gran */
2330 mmio_base, /* range_min */
2331 mmio_limit, /* range_max */
2332 0x0, /* translation */
2333 mmio_limit - mmio_base + 1); /* length */
2336 static void acpigen_resource_mmio(u64 mmio_base, u64 mmio_limit, bool is_producer, u16 type_flags)
2338 const u16 gen_flags = ADDR_SPACE_GENERAL_FLAG_MAX_FIXED
2339 | ADDR_SPACE_GENERAL_FLAG_MIN_FIXED
2340 | ADDR_SPACE_GENERAL_FLAG_DEC_POS
2341 | (is_producer ? ADDR_SPACE_GENERAL_FLAG_PRODUCER
2342 : ADDR_SPACE_GENERAL_FLAG_CONSUMER);
2344 if (mmio_base < 4ULL * GiB && mmio_limit < 4ULL * GiB)
2345 acpigen_resource_mmio32(mmio_base, mmio_limit, gen_flags, type_flags);
2346 else
2347 acpigen_resource_mmio64(mmio_base, mmio_limit, gen_flags, type_flags);
2350 void acpigen_resource_producer_mmio(u64 mmio_base, u64 mmio_limit, u16 type_flags)
2352 acpigen_resource_mmio(mmio_base, mmio_limit, true, type_flags);
2355 void acpigen_resource_consumer_mmio(u64 mmio_base, u64 mmio_limit, u16 type_flags)
2357 acpigen_resource_mmio(mmio_base, mmio_limit, false, type_flags);
2360 void acpigen_write_ADR(uint64_t adr)
2362 acpigen_write_name_qword("_ADR", adr);
2366 * acpigen_write_ADR_soundwire_device() - SoundWire ACPI Device Address Encoding.
2367 * @address: SoundWire device address properties.
2369 * From SoundWire Discovery and Configuration Specification Version 1.0 Table 3.
2371 * 63..52 - Reserved (0)
2372 * 51..48 - Zero-based SoundWire Link ID, relative to the immediate parent.
2373 * Used when a Controller has multiple master devices, each producing a
2374 * separate SoundWire Link. Set to 0 for single-link controllers.
2375 * 47..0 - SoundWire Device ID Encoding from specification version 1.2 table 88
2376 * 47..44 - SoundWire specification version that this device supports
2377 * 43..40 - Unique ID for multiple devices
2378 * 39..24 - MIPI standard manufacturer code
2379 * 23..08 - Vendor defined part ID
2380 * 07..00 - MIPI class encoding
2382 void acpigen_write_ADR_soundwire_device(const struct soundwire_address *address)
2384 acpigen_write_ADR((((uint64_t)address->link_id & 0xf) << 48) |
2385 (((uint64_t)address->version & 0xf) << 44) |
2386 (((uint64_t)address->unique_id & 0xf) << 40) |
2387 (((uint64_t)address->manufacturer_id & 0xffff) << 24) |
2388 (((uint64_t)address->part_id & 0xffff) << 8) |
2389 (((uint64_t)address->class & 0xff)));
2392 void acpigen_notify(const char *namestr, int value)
2394 acpigen_emit_byte(NOTIFY_OP);
2395 acpigen_emit_namestring(namestr);
2396 acpigen_write_integer(value);
2399 static void _create_field(uint8_t aml_op, uint8_t srcop, size_t byte_offset, const char *name)
2401 acpigen_emit_byte(aml_op);
2402 acpigen_emit_byte(srcop);
2403 acpigen_write_integer(byte_offset);
2404 acpigen_emit_namestring(name);
2407 void acpigen_write_create_byte_field(uint8_t op, size_t byte_offset, const char *name)
2409 _create_field(CREATE_BYTE_OP, op, byte_offset, name);
2412 void acpigen_write_create_word_field(uint8_t op, size_t byte_offset, const char *name)
2414 _create_field(CREATE_WORD_OP, op, byte_offset, name);
2417 void acpigen_write_create_dword_field(uint8_t op, size_t byte_offset, const char *name)
2419 _create_field(CREATE_DWORD_OP, op, byte_offset, name);
2422 void acpigen_write_create_qword_field(uint8_t op, size_t byte_offset, const char *name)
2424 _create_field(CREATE_QWORD_OP, op, byte_offset, name);
2427 void acpigen_write_pct_package(const acpi_addr_t *perf_ctrl, const acpi_addr_t *perf_sts)
2429 acpigen_write_name("_PCT");
2430 acpigen_write_package(0x02);
2431 acpigen_write_register_resource(perf_ctrl);
2432 acpigen_write_register_resource(perf_sts);
2434 acpigen_pop_len();
2437 void acpigen_write_xpss_package(const struct acpi_xpss_sw_pstate *pstate_value)
2439 acpigen_write_package(0x08);
2440 acpigen_write_dword(pstate_value->core_freq);
2441 acpigen_write_dword(pstate_value->power);
2442 acpigen_write_dword(pstate_value->transition_latency);
2443 acpigen_write_dword(pstate_value->bus_master_latency);
2445 acpigen_write_byte_buffer((uint8_t *)&pstate_value->control_value, sizeof(uint64_t));
2446 acpigen_write_byte_buffer((uint8_t *)&pstate_value->status_value, sizeof(uint64_t));
2447 acpigen_write_byte_buffer((uint8_t *)&pstate_value->control_mask, sizeof(uint64_t));
2448 acpigen_write_byte_buffer((uint8_t *)&pstate_value->status_mask, sizeof(uint64_t));
2450 acpigen_pop_len();
2453 void acpigen_write_xpss_object(const struct acpi_xpss_sw_pstate *pstate_values, size_t nentries)
2455 size_t pstate;
2457 acpigen_write_name("XPSS");
2458 acpigen_write_package(nentries);
2459 for (pstate = 0; pstate < nentries; pstate++) {
2460 acpigen_write_xpss_package(pstate_values);
2461 pstate_values++;
2464 acpigen_pop_len();
2467 /* Delay up to wait_ms until provided namestr matches expected value. */
2468 void acpigen_write_delay_until_namestr_int(uint32_t wait_ms, const char *name, uint64_t value)
2470 uint32_t wait_ms_segment = 1;
2471 uint32_t segments = wait_ms;
2473 /* Sleep in 2ms segments if delay is more than 2ms. */
2474 if (wait_ms > 2) {
2475 wait_ms_segment = 2;
2476 segments = wait_ms / wait_ms_segment;
2479 acpigen_write_store_int_to_op(segments, LOCAL7_OP);
2480 acpigen_emit_byte(WHILE_OP);
2481 acpigen_write_len_f();
2482 acpigen_emit_byte(LGREATER_OP);
2483 acpigen_emit_byte(LOCAL7_OP);
2484 acpigen_emit_byte(ZERO_OP);
2486 /* If name is not provided then just delay in a loop. */
2487 if (name) {
2488 acpigen_write_if_lequal_namestr_int(name, value);
2489 acpigen_emit_byte(BREAK_OP);
2490 acpigen_pop_len(); /* If */
2493 acpigen_write_sleep(wait_ms_segment);
2494 acpigen_emit_byte(DECREMENT_OP);
2495 acpigen_emit_byte(LOCAL7_OP);
2496 acpigen_pop_len(); /* While */
2498 if (name) {
2499 acpigen_write_if_lequal_op_op(LOCAL7_OP, ZERO_OP);
2500 acpigen_write_debug_sprintf("WARN: Wait loop timeout for variable %s",
2501 name);
2502 acpigen_pop_len(); /* If */
2506 void acpigen_ssdt_override_sleep_states(bool enable_s1, bool enable_s2, bool enable_s3,
2507 bool enable_s4)
2509 assert(!(enable_s1 && CONFIG(ACPI_S1_NOT_SUPPORTED)));
2510 assert(!(enable_s3 && !CONFIG(HAVE_ACPI_RESUME)));
2511 assert(!(enable_s4 && CONFIG(DISABLE_ACPI_HIBERNATE)));
2513 acpigen_write_scope("\\");
2514 uint32_t sleep_enable = (enable_s1 << 0) | (enable_s2 << 1)
2515 | (enable_s3 << 2) | (enable_s4 << 3);
2516 acpigen_write_name_dword("OSFG", sleep_enable);
2517 acpigen_pop_len();