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