usr.sbin/bhyve/acpi.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2012 NetApp, Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY NETAPP, INC ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL NETAPP, INC OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 /*
  30  * bhyve ACPI table generator.
  31  *
  32  * Create the minimal set of ACPI tables required to boot FreeBSD (and
  33  * hopefully other o/s's).
  34  *
  35  * The tables are placed in the guest's ROM area just below 1MB physical,
  36  * above the MPTable.
  37  */
  38
  39 #include <sys/cdefs.h>
  40 #include <sys/param.h>
  41 #include <sys/endian.h>
  42 #include <sys/errno.h>
  43 #include <sys/stat.h>
  44
  45 #include <err.h>
  46 #include <paths.h>
  47 #include <stdarg.h>
  48 #include <stddef.h>
  49 #include <stdio.h>
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <unistd.h>
  53
  54 #include <machine/vmm.h>
  55 #include <vmmapi.h>
  56
  57 #include "bhyverun.h"
  58 #include "acpi.h"
  59 #include "basl.h"
  60 #include "pci_emul.h"
  61 #include "vmgenc.h"
  62
  63 #define BHYVE_ASL_TEMPLATE      "bhyve.XXXXXXX"
  64 #define BHYVE_ASL_SUFFIX        ".aml"
  65 #define BHYVE_ASL_COMPILER      "/usr/sbin/iasl"
  66
  67 #define BHYVE_ADDRESS_IOAPIC    0xFEC00000
  68 #define BHYVE_ADDRESS_HPET      0xFED00000
  69 #define BHYVE_ADDRESS_LAPIC     0xFEE00000
  70
  71 static int basl_keep_temps;
  72 static int basl_verbose_iasl;
  73 static int basl_ncpu;
  74 static uint32_t hpet_capabilities;
  75
  76 /*
  77  * Contains the full pathname of the template to be passed
  78  * to mkstemp/mktemps(3)
  79  */
  80 static char basl_template[MAXPATHLEN];
  81 static char basl_stemplate[MAXPATHLEN];
  82
  83 /*
  84  * State for dsdt_line(), dsdt_indent(), and dsdt_unindent().
  85  */
  86 static FILE *dsdt_fp;
  87 static int dsdt_indent_level;
  88 static int dsdt_error;
  89
  90 static struct basl_table *rsdt;
  91 static struct basl_table *xsdt;
  92
  93 struct basl_fio {
  94         int     fd;
  95         FILE    *fp;
  96         char    f_name[MAXPATHLEN];
  97 };
  98
  99 #define EFPRINTF(...) \
 100         if (fprintf(__VA_ARGS__) < 0) goto err_exit;
 101
 102 #define EFFLUSH(x) \
 103         if (fflush(x) != 0) goto err_exit;
 104
 105 /*
 106  * A list for additional ACPI devices like a TPM.
 107  */
 108 struct acpi_device_list_entry {
 109         SLIST_ENTRY(acpi_device_list_entry) chain;
 110         const struct acpi_device *dev;
 111 };
 112 static SLIST_HEAD(acpi_device_list,
 113     acpi_device_list_entry) acpi_devices = SLIST_HEAD_INITIALIZER(acpi_devices);
 114
 115 int
 116 acpi_tables_add_device(const struct acpi_device *const dev)
 117 {
 118         struct acpi_device_list_entry *const entry = calloc(1, sizeof(*entry));
 119         if (entry == NULL) {
 120                 return (ENOMEM);
 121         }
 122
 123         entry->dev = dev;
 124         SLIST_INSERT_HEAD(&acpi_devices, entry, chain);
 125
 126         return (0);
 127 }
 128
 129 /*
 130  * Helper routines for writing to the DSDT from other modules.
 131  */
 132 void
 133 dsdt_line(const char *fmt, ...)
 134 {
 135         va_list ap;
 136
 137         if (dsdt_error != 0)
 138                 return;
 139
 140         if (strcmp(fmt, "") != 0) {
 141                 if (dsdt_indent_level != 0)
 142                         EFPRINTF(dsdt_fp, "%*c", dsdt_indent_level * 2, ' ');
 143                 va_start(ap, fmt);
 144                 if (vfprintf(dsdt_fp, fmt, ap) < 0) {
 145                         va_end(ap);
 146                         goto err_exit;
 147                 }
 148                 va_end(ap);
 149         }
 150         EFPRINTF(dsdt_fp, "\n");
 151         return;
 152
 153 err_exit:
 154         dsdt_error = errno;
 155 }
 156
 157 void
 158 dsdt_indent(int levels)
 159 {
 160
 161         dsdt_indent_level += levels;
 162         assert(dsdt_indent_level >= 0);
 163 }
 164
 165 void
 166 dsdt_unindent(int levels)
 167 {
 168
 169         assert(dsdt_indent_level >= levels);
 170         dsdt_indent_level -= levels;
 171 }
 172
 173 void
 174 dsdt_fixed_ioport(uint16_t iobase, uint16_t length)
 175 {
 176
 177         dsdt_line("IO (Decode16,");
 178         dsdt_line("  0x%04X,             // Range Minimum", iobase);
 179         dsdt_line("  0x%04X,             // Range Maximum", iobase);
 180         dsdt_line("  0x01,               // Alignment");
 181         dsdt_line("  0x%02X,               // Length", length);
 182         dsdt_line("  )");
 183 }
 184
 185 void
 186 dsdt_fixed_irq(uint8_t irq)
 187 {
 188
 189         dsdt_line("IRQNoFlags ()");
 190         dsdt_line("  {%d}", irq);
 191 }
 192
 193 void
 194 dsdt_fixed_mem32(uint32_t base, uint32_t length)
 195 {
 196
 197         dsdt_line("Memory32Fixed (ReadWrite,");
 198         dsdt_line("  0x%08X,         // Address Base", base);
 199         dsdt_line("  0x%08X,         // Address Length", length);
 200         dsdt_line("  )");
 201 }
 202
 203 static int
 204 basl_fwrite_dsdt(FILE *fp)
 205 {
 206         dsdt_fp = fp;
 207         dsdt_error = 0;
 208         dsdt_indent_level = 0;
 209
 210         dsdt_line("/*");
 211         dsdt_line(" * bhyve DSDT template");
 212         dsdt_line(" */");
 213         dsdt_line("DefinitionBlock (\"bhyve_dsdt.aml\", \"DSDT\", 2,"
 214                  "\"BHYVE \", \"BVDSDT  \", 0x00000001)");
 215         dsdt_line("{");
 216         dsdt_line("  Name (_S5, Package ()");
 217         dsdt_line("  {");
 218         dsdt_line("      0x05,");
 219         dsdt_line("      Zero,");
 220         dsdt_line("  })");
 221
 222         pci_write_dsdt();
 223
 224         dsdt_line("");
 225         dsdt_line("  Scope (_SB.PC00)");
 226         dsdt_line("  {");
 227         dsdt_line("    Device (HPET)");
 228         dsdt_line("    {");
 229         dsdt_line("      Name (_HID, EISAID(\"PNP0103\"))");
 230         dsdt_line("      Name (_UID, 0)");
 231         dsdt_line("      Name (_CRS, ResourceTemplate ()");
 232         dsdt_line("      {");
 233         dsdt_indent(4);
 234         dsdt_fixed_mem32(0xFED00000, 0x400);
 235         dsdt_unindent(4);
 236         dsdt_line("      })");
 237         dsdt_line("    }");
 238         dsdt_line("  }");
 239
 240         vmgenc_write_dsdt();
 241
 242         const struct acpi_device_list_entry *entry;
 243         SLIST_FOREACH(entry, &acpi_devices, chain) {
 244                 BASL_EXEC(acpi_device_write_dsdt(entry->dev));
 245         }
 246
 247         dsdt_line("}");
 248
 249         if (dsdt_error != 0)
 250                 return (dsdt_error);
 251
 252         EFFLUSH(fp);
 253
 254         return (0);
 255
 256 err_exit:
 257         return (errno);
 258 }
 259
 260 static int
 261 basl_open(struct basl_fio *bf, int suffix)
 262 {
 263         int err;
 264
 265         err = 0;
 266
 267         if (suffix) {
 268                 strlcpy(bf->f_name, basl_stemplate, MAXPATHLEN);
 269                 bf->fd = mkstemps(bf->f_name, strlen(BHYVE_ASL_SUFFIX));
 270         } else {
 271                 strlcpy(bf->f_name, basl_template, MAXPATHLEN);
 272                 bf->fd = mkstemp(bf->f_name);
 273         }
 274
 275         if (bf->fd > 0) {
 276                 bf->fp = fdopen(bf->fd, "w+");
 277                 if (bf->fp == NULL) {
 278                         unlink(bf->f_name);
 279                         close(bf->fd);
 280                 }
 281         } else {
 282                 err = 1;
 283         }
 284
 285         return (err);
 286 }
 287
 288 static void
 289 basl_close(struct basl_fio *bf)
 290 {
 291
 292         if (!basl_keep_temps)
 293                 unlink(bf->f_name);
 294         fclose(bf->fp);
 295 }
 296
 297 static int
 298 basl_start(struct basl_fio *in, struct basl_fio *out)
 299 {
 300         int err;
 301
 302         err = basl_open(in, 0);
 303         if (!err) {
 304                 err = basl_open(out, 1);
 305                 if (err) {
 306                         basl_close(in);
 307                 }
 308         }
 309
 310         return (err);
 311 }
 312
 313 static void
 314 basl_end(struct basl_fio *in, struct basl_fio *out)
 315 {
 316
 317         basl_close(in);
 318         basl_close(out);
 319 }
 320
 321 static int
 322 basl_load(struct vmctx *ctx, int fd)
 323 {
 324         struct stat sb;
 325         void *addr;
 326
 327         if (fstat(fd, &sb) < 0)
 328                 return (errno);
 329
 330         addr = calloc(1, sb.st_size);
 331         if (addr == NULL)
 332                 return (EFAULT);
 333
 334         if (read(fd, addr, sb.st_size) < 0)
 335                 return (errno);
 336
 337         struct basl_table *table;
 338
 339         uint8_t name[ACPI_NAMESEG_SIZE + 1] = { 0 };
 340         memcpy(name, addr, sizeof(name) - 1 /* last char is '\0' */);
 341         BASL_EXEC(basl_table_create(&table, ctx, name, BASL_TABLE_ALIGNMENT));
 342         BASL_EXEC(basl_table_append_bytes(table, addr, sb.st_size));
 343
 344         return (0);
 345 }
 346
 347 static int
 348 basl_compile(struct vmctx *ctx, int (*fwrite_section)(FILE *))
 349 {
 350         struct basl_fio io[2];
 351         static char iaslbuf[3*MAXPATHLEN + 10];
 352         const char *fmt;
 353         int err;
 354
 355         err = basl_start(&io[0], &io[1]);
 356         if (!err) {
 357                 err = (*fwrite_section)(io[0].fp);
 358
 359                 if (!err) {
 360                         /*
 361                          * iasl sends the results of the compilation to
 362                          * stdout. Shut this down by using the shell to
 363                          * redirect stdout to /dev/null, unless the user
 364                          * has requested verbose output for debugging
 365                          * purposes
 366                          */
 367                         fmt = basl_verbose_iasl ?
 368                                 "%s -p %s %s" :
 369                                 "/bin/sh -c \"%s -p %s %s\" 1> /dev/null";
 370
 371                         snprintf(iaslbuf, sizeof(iaslbuf),
 372                                  fmt,
 373                                  BHYVE_ASL_COMPILER,
 374                                  io[1].f_name, io[0].f_name);
 375                         err = system(iaslbuf);
 376
 377                         if (!err) {
 378                                 /*
 379                                  * Copy the aml output file into guest
 380                                  * memory at the specified location
 381                                  */
 382                                 err = basl_load(ctx, io[1].fd);
 383                         }
 384                 }
 385                 basl_end(&io[0], &io[1]);
 386         }
 387
 388         return (err);
 389 }
 390
 391 static int
 392 basl_make_templates(void)
 393 {
 394         const char *tmpdir;
 395         int err;
 396         int len;
 397
 398         err = 0;
 399
 400         /*
 401          *
 402          */
 403         if ((tmpdir = getenv("BHYVE_TMPDIR")) == NULL || *tmpdir == '\0' ||
 404             (tmpdir = getenv("TMPDIR")) == NULL || *tmpdir == '\0') {
 405                 tmpdir = _PATH_TMP;
 406         }
 407
 408         len = strlen(tmpdir);
 409
 410         if ((len + sizeof(BHYVE_ASL_TEMPLATE) + 1) < MAXPATHLEN) {
 411                 strcpy(basl_template, tmpdir);
 412                 while (len > 0 && basl_template[len - 1] == '/')
 413                         len--;
 414                 basl_template[len] = '/';
 415                 strcpy(&basl_template[len + 1], BHYVE_ASL_TEMPLATE);
 416         } else
 417                 err = E2BIG;
 418
 419         if (!err) {
 420                 /*
 421                  * len has been intialized (and maybe adjusted) above
 422                  */
 423                 if ((len + sizeof(BHYVE_ASL_TEMPLATE) + 1 +
 424                      sizeof(BHYVE_ASL_SUFFIX)) < MAXPATHLEN) {
 425                         strcpy(basl_stemplate, tmpdir);
 426                         basl_stemplate[len] = '/';
 427                         strcpy(&basl_stemplate[len + 1], BHYVE_ASL_TEMPLATE);
 428                         len = strlen(basl_stemplate);
 429                         strcpy(&basl_stemplate[len], BHYVE_ASL_SUFFIX);
 430                 } else
 431                         err = E2BIG;
 432         }
 433
 434         return (err);
 435 }
 436
 437 static int
 438 build_dsdt(struct vmctx *const ctx)
 439 {
 440         BASL_EXEC(basl_compile(ctx, basl_fwrite_dsdt));
 441
 442         return (0);
 443 }
 444
 445 static int
 446 build_facs(struct vmctx *const ctx)
 447 {
 448         ACPI_TABLE_FACS facs;
 449         struct basl_table *table;
 450
 451         BASL_EXEC(basl_table_create(&table, ctx, ACPI_SIG_FACS,
 452             BASL_TABLE_ALIGNMENT_FACS));
 453
 454         memset(&facs, 0, sizeof(facs));
 455         memcpy(facs.Signature, ACPI_SIG_FACS, ACPI_NAMESEG_SIZE);
 456         facs.Length = sizeof(facs);
 457         facs.Version = htole32(2);
 458         BASL_EXEC(basl_table_append_bytes(table, &facs, sizeof(facs)));
 459
 460         return (0);
 461 }
 462
 463 static int
 464 build_fadt(struct vmctx *const ctx)
 465 {
 466         ACPI_TABLE_FADT fadt;
 467         struct basl_table *table;
 468
 469         BASL_EXEC(basl_table_create(&table, ctx, ACPI_SIG_FADT,
 470             BASL_TABLE_ALIGNMENT));
 471
 472         memset(&fadt, 0, sizeof(fadt));
 473         BASL_EXEC(basl_table_append_header(table, ACPI_SIG_FADT, 5, 1));
 474         fadt.Facs = htole32(0); /* patched by basl */
 475         fadt.Dsdt = htole32(0); /* patched by basl */
 476         fadt.SciInterrupt = htole16(SCI_INT);
 477         fadt.SmiCommand = htole32(SMI_CMD);
 478         fadt.AcpiEnable = BHYVE_ACPI_ENABLE;
 479         fadt.AcpiDisable = BHYVE_ACPI_DISABLE;
 480         fadt.Pm1aEventBlock = htole32(PM1A_EVT_ADDR);
 481         fadt.Pm1aControlBlock = htole32(PM1A_CNT_ADDR);
 482         fadt.PmTimerBlock = htole32(IO_PMTMR);
 483         fadt.Gpe0Block = htole32(IO_GPE0_BLK);
 484         fadt.Pm1EventLength = 4;
 485         fadt.Pm1ControlLength = 2;
 486         fadt.PmTimerLength = 4;
 487         fadt.Gpe0BlockLength = IO_GPE0_LEN;
 488         fadt.Century = 0x32;
 489         fadt.BootFlags = htole16(ACPI_FADT_NO_VGA | ACPI_FADT_NO_ASPM);
 490         fadt.Flags = htole32(ACPI_FADT_WBINVD | ACPI_FADT_C1_SUPPORTED |
 491             ACPI_FADT_SLEEP_BUTTON | ACPI_FADT_32BIT_TIMER |
 492             ACPI_FADT_RESET_REGISTER | ACPI_FADT_HEADLESS |
 493             ACPI_FADT_APIC_PHYSICAL);
 494         basl_fill_gas(&fadt.ResetRegister, ACPI_ADR_SPACE_SYSTEM_IO, 8, 0,
 495             ACPI_GAS_ACCESS_WIDTH_BYTE, 0xCF9);
 496         fadt.ResetValue = 6;
 497         fadt.MinorRevision = 1;
 498         fadt.XFacs = htole64(0); /* patched by basl */
 499         fadt.XDsdt = htole64(0); /* patched by basl */
 500         basl_fill_gas(&fadt.XPm1aEventBlock, ACPI_ADR_SPACE_SYSTEM_IO, 0x20, 0,
 501             ACPI_GAS_ACCESS_WIDTH_WORD, PM1A_EVT_ADDR);
 502         basl_fill_gas(&fadt.XPm1bEventBlock, ACPI_ADR_SPACE_SYSTEM_IO, 0, 0,
 503             ACPI_GAS_ACCESS_WIDTH_UNDEFINED, 0);
 504         basl_fill_gas(&fadt.XPm1aControlBlock, ACPI_ADR_SPACE_SYSTEM_IO, 0x10,
 505             0, ACPI_GAS_ACCESS_WIDTH_WORD, PM1A_CNT_ADDR);
 506         basl_fill_gas(&fadt.XPm1bControlBlock, ACPI_ADR_SPACE_SYSTEM_IO, 0, 0,
 507             ACPI_GAS_ACCESS_WIDTH_UNDEFINED, 0);
 508         basl_fill_gas(&fadt.XPm2ControlBlock, ACPI_ADR_SPACE_SYSTEM_IO, 8, 0,
 509             ACPI_GAS_ACCESS_WIDTH_UNDEFINED, 0);
 510         basl_fill_gas(&fadt.XPmTimerBlock, ACPI_ADR_SPACE_SYSTEM_IO, 0x20, 0,
 511             ACPI_GAS_ACCESS_WIDTH_DWORD, IO_PMTMR);
 512         basl_fill_gas(&fadt.XGpe0Block, ACPI_ADR_SPACE_SYSTEM_IO,
 513             IO_GPE0_LEN * 8, 0, ACPI_GAS_ACCESS_WIDTH_BYTE, IO_GPE0_BLK);
 514         basl_fill_gas(&fadt.XGpe1Block, ACPI_ADR_SPACE_SYSTEM_IO, 0, 0,
 515             ACPI_GAS_ACCESS_WIDTH_UNDEFINED, 0);
 516         basl_fill_gas(&fadt.SleepControl, ACPI_ADR_SPACE_SYSTEM_IO, 8, 0,
 517             ACPI_GAS_ACCESS_WIDTH_BYTE, 0);
 518         basl_fill_gas(&fadt.SleepStatus, ACPI_ADR_SPACE_SYSTEM_IO, 8, 0,
 519             ACPI_GAS_ACCESS_WIDTH_BYTE, 0);
 520         BASL_EXEC(basl_table_append_content(table, &fadt, sizeof(fadt)));
 521
 522         BASL_EXEC(basl_table_add_pointer(table, ACPI_SIG_FACS,
 523             offsetof(ACPI_TABLE_FADT, Facs), sizeof(fadt.Facs)));
 524         BASL_EXEC(basl_table_add_pointer(table, ACPI_SIG_DSDT,
 525             offsetof(ACPI_TABLE_FADT, Dsdt), sizeof(fadt.Dsdt)));
 526         BASL_EXEC(basl_table_add_pointer(table, ACPI_SIG_FACS,
 527             offsetof(ACPI_TABLE_FADT, XFacs), sizeof(fadt.XFacs)));
 528         BASL_EXEC(basl_table_add_pointer(table, ACPI_SIG_DSDT,
 529             offsetof(ACPI_TABLE_FADT, XDsdt), sizeof(fadt.XDsdt)));
 530
 531         BASL_EXEC(basl_table_append_pointer(rsdt, ACPI_SIG_FADT,
 532             ACPI_RSDT_ENTRY_SIZE));
 533         BASL_EXEC(basl_table_append_pointer(xsdt, ACPI_SIG_FADT,
 534             ACPI_XSDT_ENTRY_SIZE));
 535
 536         return (0);
 537 }
 538
 539 static int
 540 build_hpet(struct vmctx *const ctx)
 541 {
 542         ACPI_TABLE_HPET hpet;
 543         struct basl_table *table;
 544
 545         BASL_EXEC(basl_table_create(&table, ctx, ACPI_SIG_HPET,
 546             BASL_TABLE_ALIGNMENT));
 547
 548         memset(&hpet, 0, sizeof(hpet));
 549         BASL_EXEC(basl_table_append_header(table, ACPI_SIG_HPET, 1, 1));
 550         hpet.Id = htole32(hpet_capabilities);
 551         basl_fill_gas(&hpet.Address, ACPI_ADR_SPACE_SYSTEM_MEMORY, 0, 0,
 552             ACPI_GAS_ACCESS_WIDTH_LEGACY, BHYVE_ADDRESS_HPET);
 553         hpet.Flags = ACPI_HPET_PAGE_PROTECT4;
 554         BASL_EXEC(basl_table_append_content(table, &hpet, sizeof(hpet)));
 555
 556         BASL_EXEC(basl_table_append_pointer(rsdt, ACPI_SIG_HPET,
 557             ACPI_RSDT_ENTRY_SIZE));
 558         BASL_EXEC(basl_table_append_pointer(xsdt, ACPI_SIG_HPET,
 559             ACPI_XSDT_ENTRY_SIZE));
 560
 561         return (0);
 562 }
 563
 564 static int
 565 build_madt(struct vmctx *const ctx)
 566 {
 567         ACPI_TABLE_MADT madt;
 568         ACPI_MADT_LOCAL_APIC madt_lapic;
 569         ACPI_MADT_IO_APIC madt_ioapic;
 570         ACPI_MADT_INTERRUPT_OVERRIDE madt_irq_override;
 571         ACPI_MADT_LOCAL_APIC_NMI madt_lapic_nmi;
 572         struct basl_table *table;
 573
 574         BASL_EXEC(basl_table_create(&table, ctx, ACPI_SIG_MADT,
 575             BASL_TABLE_ALIGNMENT));
 576
 577         memset(&madt, 0, sizeof(madt));
 578         BASL_EXEC(basl_table_append_header(table, ACPI_SIG_MADT, 1, 1));
 579         madt.Address = htole32(BHYVE_ADDRESS_LAPIC);
 580         madt.Flags = htole32(ACPI_MADT_PCAT_COMPAT);
 581         BASL_EXEC(basl_table_append_content(table, &madt, sizeof(madt)));
 582
 583         /* Local APIC for each CPU */
 584         for (int i = 0; i < basl_ncpu; ++i) {
 585                 memset(&madt_lapic, 0, sizeof(madt_lapic));
 586                 madt_lapic.Header.Type = ACPI_MADT_TYPE_LOCAL_APIC;
 587                 madt_lapic.Header.Length = sizeof(madt_lapic);
 588                 madt_lapic.ProcessorId = i;
 589                 madt_lapic.Id = i;
 590                 madt_lapic.LapicFlags = htole32(ACPI_MADT_ENABLED);
 591                 BASL_EXEC(basl_table_append_bytes(table, &madt_lapic,
 592                     sizeof(madt_lapic)));
 593         }
 594
 595         /* I/O APIC */
 596         memset(&madt_ioapic, 0, sizeof(madt_ioapic));
 597         madt_ioapic.Header.Type = ACPI_MADT_TYPE_IO_APIC;
 598         madt_ioapic.Header.Length = sizeof(madt_ioapic);
 599         madt_ioapic.Address = htole32(BHYVE_ADDRESS_IOAPIC);
 600         BASL_EXEC(
 601             basl_table_append_bytes(table, &madt_ioapic, sizeof(madt_ioapic)));
 602
 603         /* Legacy IRQ0 is connected to pin 2 of the I/O APIC */
 604         memset(&madt_irq_override, 0, sizeof(madt_irq_override));
 605         madt_irq_override.Header.Type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE;
 606         madt_irq_override.Header.Length = sizeof(madt_irq_override);
 607         madt_irq_override.GlobalIrq = htole32(2);
 608         madt_irq_override.IntiFlags = htole16(
 609             ACPI_MADT_POLARITY_ACTIVE_HIGH | ACPI_MADT_TRIGGER_EDGE);
 610         BASL_EXEC(basl_table_append_bytes(table, &madt_irq_override,
 611             sizeof(madt_irq_override)));
 612
 613         memset(&madt_irq_override, 0, sizeof(madt_irq_override));
 614         madt_irq_override.Header.Type = ACPI_MADT_TYPE_INTERRUPT_OVERRIDE;
 615         madt_irq_override.Header.Length = sizeof(madt_irq_override);
 616         madt_irq_override.SourceIrq = SCI_INT;
 617         madt_irq_override.GlobalIrq = htole32(SCI_INT);
 618         madt_irq_override.IntiFlags = htole16(
 619             ACPI_MADT_POLARITY_ACTIVE_LOW | ACPI_MADT_TRIGGER_LEVEL);
 620         BASL_EXEC(basl_table_append_bytes(table, &madt_irq_override,
 621             sizeof(madt_irq_override)));
 622
 623         /* Local APIC NMI is conntected to LINT 1 on all CPUs */
 624         memset(&madt_lapic_nmi, 0, sizeof(madt_lapic_nmi));
 625         madt_lapic_nmi.Header.Type = ACPI_MADT_TYPE_LOCAL_APIC_NMI;
 626         madt_lapic_nmi.Header.Length = sizeof(madt_lapic_nmi);
 627         madt_lapic_nmi.ProcessorId = 0xFF;
 628         madt_lapic_nmi.IntiFlags = htole16(
 629             ACPI_MADT_POLARITY_ACTIVE_HIGH | ACPI_MADT_TRIGGER_EDGE);
 630         madt_lapic_nmi.Lint = 1;
 631         BASL_EXEC(basl_table_append_bytes(table, &madt_lapic_nmi,
 632             sizeof(madt_lapic_nmi)));
 633
 634         BASL_EXEC(basl_table_append_pointer(rsdt, ACPI_SIG_MADT,
 635             ACPI_RSDT_ENTRY_SIZE));
 636         BASL_EXEC(basl_table_append_pointer(xsdt, ACPI_SIG_MADT,
 637             ACPI_XSDT_ENTRY_SIZE));
 638
 639         return (0);
 640 }
 641
 642 static int
 643 build_mcfg(struct vmctx *const ctx)
 644 {
 645         ACPI_TABLE_MCFG mcfg;
 646         ACPI_MCFG_ALLOCATION mcfg_allocation;
 647         struct basl_table *table;
 648
 649         BASL_EXEC(basl_table_create(&table, ctx, ACPI_SIG_MCFG,
 650             BASL_TABLE_ALIGNMENT));
 651
 652         memset(&mcfg, 0, sizeof(mcfg));
 653         BASL_EXEC(basl_table_append_header(table, ACPI_SIG_MCFG, 1, 1));
 654         BASL_EXEC(basl_table_append_content(table, &mcfg, sizeof(mcfg)));
 655
 656         memset(&mcfg_allocation, 0, sizeof(mcfg_allocation));
 657         mcfg_allocation.Address = htole64(pci_ecfg_base());
 658         mcfg_allocation.EndBusNumber = 0xFF;
 659         BASL_EXEC(basl_table_append_bytes(table, &mcfg_allocation,
 660             sizeof(mcfg_allocation)));
 661
 662         BASL_EXEC(basl_table_append_pointer(rsdt, ACPI_SIG_MCFG,
 663             ACPI_RSDT_ENTRY_SIZE));
 664         BASL_EXEC(basl_table_append_pointer(xsdt, ACPI_SIG_MCFG,
 665             ACPI_XSDT_ENTRY_SIZE));
 666
 667         return (0);
 668 }
 669
 670 static int
 671 build_rsdp(struct vmctx *const ctx)
 672 {
 673         ACPI_TABLE_RSDP rsdp;
 674         struct basl_table *table;
 675
 676         BASL_EXEC(basl_table_create(&table, ctx, ACPI_RSDP_NAME,
 677             BASL_TABLE_ALIGNMENT));
 678
 679         memset(&rsdp, 0, sizeof(rsdp));
 680         memcpy(rsdp.Signature, ACPI_SIG_RSDP, 8);
 681         rsdp.Checksum = 0; /* patched by basl */
 682         memcpy(rsdp.OemId, "BHYVE ", ACPI_OEM_ID_SIZE);
 683         rsdp.Revision = 2;
 684         rsdp.RsdtPhysicalAddress = htole32(0); /* patched by basl */
 685         rsdp.Length = htole32(0);              /* patched by basl */
 686         rsdp.XsdtPhysicalAddress = htole64(0); /* patched by basl */
 687         rsdp.ExtendedChecksum = 0;             /* patched by basl */
 688         BASL_EXEC(basl_table_append_bytes(table, &rsdp, sizeof(rsdp)));
 689
 690         BASL_EXEC(basl_table_add_checksum(table,
 691             offsetof(ACPI_TABLE_RSDP, Checksum), 0, 20));
 692         BASL_EXEC(basl_table_add_pointer(table, ACPI_SIG_RSDT,
 693             offsetof(ACPI_TABLE_RSDP, RsdtPhysicalAddress),
 694             sizeof(rsdp.RsdtPhysicalAddress)));
 695         BASL_EXEC(basl_table_add_length(table,
 696             offsetof(ACPI_TABLE_RSDP, Length), sizeof(rsdp.Length)));
 697         BASL_EXEC(basl_table_add_pointer(table, ACPI_SIG_XSDT,
 698             offsetof(ACPI_TABLE_RSDP, XsdtPhysicalAddress),
 699             sizeof(rsdp.XsdtPhysicalAddress)));
 700         BASL_EXEC(basl_table_add_checksum(table,
 701             offsetof(ACPI_TABLE_RSDP, ExtendedChecksum), 0,
 702             BASL_TABLE_CHECKSUM_LEN_FULL_TABLE));
 703
 704         return (0);
 705 }
 706
 707 static int
 708 build_rsdt(struct vmctx *const ctx)
 709 {
 710         BASL_EXEC(
 711             basl_table_create(&rsdt, ctx, ACPI_SIG_RSDT, BASL_TABLE_ALIGNMENT));
 712
 713         /* Header */
 714         BASL_EXEC(basl_table_append_header(rsdt, ACPI_SIG_RSDT, 1, 1));
 715         /* Pointers (added by other build_XXX funcs) */
 716
 717         return (0);
 718 }
 719
 720 static int
 721 build_spcr(struct vmctx *const ctx)
 722 {
 723         ACPI_TABLE_SPCR spcr;
 724         struct basl_table *table;
 725
 726         BASL_EXEC(basl_table_create(&table, ctx, ACPI_SIG_SPCR,
 727             BASL_TABLE_ALIGNMENT));
 728
 729         memset(&spcr, 0, sizeof(spcr));
 730         BASL_EXEC(basl_table_append_header(table, ACPI_SIG_SPCR, 1, 1));
 731         spcr.InterfaceType = ACPI_DBG2_16550_COMPATIBLE;
 732         basl_fill_gas(&spcr.SerialPort, ACPI_ADR_SPACE_SYSTEM_IO, 8, 0,
 733             ACPI_GAS_ACCESS_WIDTH_LEGACY, 0x3F8);
 734         spcr.InterruptType = ACPI_SPCR_INTERRUPT_TYPE_8259;
 735         spcr.PcInterrupt = 4;
 736         spcr.BaudRate = ACPI_SPCR_BAUD_RATE_115200;
 737         spcr.Parity = ACPI_SPCR_PARITY_NO_PARITY;
 738         spcr.StopBits = ACPI_SPCR_STOP_BITS_1;
 739         spcr.FlowControl = 3; /* RTS/CTS | DCD */
 740         spcr.TerminalType = ACPI_SPCR_TERMINAL_TYPE_VT_UTF8;
 741         BASL_EXEC(basl_table_append_content(table, &spcr, sizeof(spcr)));
 742
 743         BASL_EXEC(basl_table_append_pointer(rsdt, ACPI_SIG_SPCR,
 744             ACPI_RSDT_ENTRY_SIZE));
 745         BASL_EXEC(basl_table_append_pointer(xsdt, ACPI_SIG_SPCR,
 746             ACPI_XSDT_ENTRY_SIZE));
 747
 748         return (0);
 749 }
 750
 751 static int
 752 build_xsdt(struct vmctx *const ctx)
 753 {
 754         BASL_EXEC(
 755             basl_table_create(&xsdt, ctx, ACPI_SIG_XSDT, BASL_TABLE_ALIGNMENT));
 756
 757         /* Header */
 758         BASL_EXEC(basl_table_append_header(xsdt, ACPI_SIG_XSDT, 1, 1));
 759         /* Pointers (added by other build_XXX funcs) */
 760
 761         return (0);
 762 }
 763
 764 int
 765 acpi_build(struct vmctx *ctx, int ncpu)
 766 {
 767         int err;
 768
 769         basl_ncpu = ncpu;
 770
 771         err = vm_get_hpet_capabilities(ctx, &hpet_capabilities);
 772         if (err != 0)
 773                 return (err);
 774
 775         /*
 776          * For debug, allow the user to have iasl compiler output sent
 777          * to stdout rather than /dev/null
 778          */
 779         if (getenv("BHYVE_ACPI_VERBOSE_IASL"))
 780                 basl_verbose_iasl = 1;
 781
 782         /*
 783          * Allow the user to keep the generated ASL files for debugging
 784          * instead of deleting them following use
 785          */
 786         if (getenv("BHYVE_ACPI_KEEPTMPS"))
 787                 basl_keep_temps = 1;
 788
 789         BASL_EXEC(basl_init());
 790
 791         BASL_EXEC(basl_make_templates());
 792
 793         /*
 794          * Generate ACPI tables and copy them into guest memory.
 795          *
 796          * According to UEFI Specification v6.3 chapter 5.1 the FADT should be
 797          * the first table pointed to by XSDT. For that reason, build it as the
 798          * first table after XSDT.
 799          */
 800         BASL_EXEC(build_rsdp(ctx));
 801         BASL_EXEC(build_rsdt(ctx));
 802         BASL_EXEC(build_xsdt(ctx));
 803         BASL_EXEC(build_fadt(ctx));
 804         BASL_EXEC(build_madt(ctx));
 805         BASL_EXEC(build_hpet(ctx));
 806         BASL_EXEC(build_mcfg(ctx));
 807         BASL_EXEC(build_facs(ctx));
 808         BASL_EXEC(build_spcr(ctx));
 809
 810         /* Build ACPI device-specific tables such as a TPM2 table. */
 811         const struct acpi_device_list_entry *entry;
 812         SLIST_FOREACH(entry, &acpi_devices, chain) {
 813                 BASL_EXEC(acpi_device_build_table(entry->dev));
 814         }
 815
 816         BASL_EXEC(build_dsdt(ctx));
 817
 818         BASL_EXEC(basl_finish());
 819
 820         return (0);
 821 }