usr.sbin/acpi/acpidb/acpidb.c

   1 /*-
   2  * Copyright (c) 2000-2002 Mitsuru IWASAKI <iwasaki@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  *      $FreeBSD$
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/queue.h>
  31 #include <sys/mman.h>
  32 #include <sys/stat.h>
  33 #include <sys/stdint.h>
  34 #include <sys/types.h>
  35
  36 #include <assert.h>
  37 #include <ctype.h>
  38 #include <err.h>
  39 #include <fcntl.h>
  40 #include <limits.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <unistd.h>
  44
  45 #include <contrib/dev/acpica/include/acpi.h>
  46 #include <contrib/dev/acpica/include/accommon.h>
  47 #include <contrib/dev/acpica/include/acdebug.h>
  48
  49 /*
  50  * Dummy DSDT Table Header
  51  */
  52
  53 static ACPI_TABLE_HEADER dummy_dsdt_table = {
  54         "DSDT", 123, 1, 123, "OEMID", "OEMTBLID", 1, "CRID", 1
  55 };
  56
  57 /*
  58  * Region space I/O routines on virtual machine
  59  */
  60
  61 static int      aml_debug_prompt = 1;
  62
  63 struct ACPIRegionContent {
  64         TAILQ_ENTRY(ACPIRegionContent) links;
  65         int                     regtype;
  66         ACPI_PHYSICAL_ADDRESS   addr;
  67         UINT8                   value;
  68 };
  69
  70 TAILQ_HEAD(ACPIRegionContentList, ACPIRegionContent);
  71 static struct   ACPIRegionContentList RegionContentList;
  72
  73 static int               aml_simulation_initialized = 0;
  74
  75 ACPI_PHYSICAL_ADDRESS    AeLocalGetRootPointer(void);
  76 void                     AeTableOverride(ACPI_TABLE_HEADER *, ACPI_TABLE_HEADER **);
  77
  78 static void              aml_simulation_init(void);
  79 static int               aml_simulate_regcontent_add(int regtype,
  80                              ACPI_PHYSICAL_ADDRESS addr,
  81                              UINT8 value);
  82 static int               aml_simulate_regcontent_read(int regtype,
  83                              ACPI_PHYSICAL_ADDRESS addr,
  84                              UINT8 *valuep);
  85 static int               aml_simulate_regcontent_write(int regtype,
  86                              ACPI_PHYSICAL_ADDRESS addr,
  87                              UINT8 *valuep);
  88 static UINT64            aml_simulate_prompt(char *msg, UINT64 def_val);
  89 static void              aml_simulation_regload(const char *dumpfile);
  90 static void              aml_simulation_regdump(const char *dumpfile);
  91
  92 /* Stubs to simplify linkage to the ACPI CA core subsystem. */
  93 ACPI_PHYSICAL_ADDRESS
  94 AeLocalGetRootPointer(void)
  95 {
  96
  97         return (0);
  98 }
  99
 100 void
 101 AeTableOverride(ACPI_TABLE_HEADER *ExistingTable, ACPI_TABLE_HEADER **NewTable)
 102 {
 103 }
 104
 105 static void
 106 aml_simulation_init(void)
 107 {
 108
 109         aml_simulation_initialized = 1;
 110         TAILQ_INIT(&RegionContentList);
 111         aml_simulation_regload("region.ini");
 112 }
 113
 114 static int
 115 aml_simulate_regcontent_add(int regtype, ACPI_PHYSICAL_ADDRESS addr, UINT8 value)
 116 {
 117         struct  ACPIRegionContent *rc;
 118
 119         rc = malloc(sizeof(struct ACPIRegionContent));
 120         if (rc == NULL) {
 121                 return (-1);    /* malloc fail */
 122         }
 123         rc->regtype = regtype;
 124         rc->addr = addr;
 125         rc->value = value;
 126
 127         TAILQ_INSERT_TAIL(&RegionContentList, rc, links);
 128         return (0);
 129 }
 130
 131 static int
 132 aml_simulate_regcontent_read(int regtype, ACPI_PHYSICAL_ADDRESS addr, UINT8 *valuep)
 133 {
 134         struct  ACPIRegionContent *rc;
 135
 136         if (!aml_simulation_initialized) {
 137                 aml_simulation_init();
 138         }
 139         TAILQ_FOREACH(rc, &RegionContentList, links) {
 140                 if (rc->regtype == regtype && rc->addr == addr) {
 141                         *valuep = rc->value;
 142                         return (1);     /* found */
 143                 }
 144         }
 145
 146         *valuep = 0;
 147         return (aml_simulate_regcontent_add(regtype, addr, *valuep));
 148 }
 149
 150 static int
 151 aml_simulate_regcontent_write(int regtype, ACPI_PHYSICAL_ADDRESS addr, UINT8 *valuep)
 152 {
 153         struct  ACPIRegionContent *rc;
 154
 155         if (!aml_simulation_initialized) {
 156                 aml_simulation_init();
 157         }
 158         TAILQ_FOREACH(rc, &RegionContentList, links) {
 159                 if (rc->regtype == regtype && rc->addr == addr) {
 160                         rc->value = *valuep;
 161                         return (1);     /* exists */
 162                 }
 163         }
 164
 165         return (aml_simulate_regcontent_add(regtype, addr, *valuep));
 166 }
 167
 168 static UINT64
 169 aml_simulate_prompt(char *msg, UINT64 def_val)
 170 {
 171         char            buf[16], *ep;
 172         UINT64          val;
 173
 174         val = def_val;
 175         printf("DEBUG");
 176         if (msg != NULL) {
 177                 printf("%s", msg);
 178         }
 179         printf("(default: 0x%jx ", (uintmax_t)val);
 180         printf(" / %ju) >>", (uintmax_t)val);
 181         fflush(stdout);
 182
 183         bzero(buf, sizeof buf);
 184         while (1) {
 185                 if (read(0, buf, sizeof buf) == 0) {
 186                         continue;
 187                 }
 188                 if (buf[0] == '\n') {
 189                         break;  /* use default value */
 190                 }
 191                 if (buf[0] == '0' && buf[1] == 'x') {
 192                         val = strtoq(buf, &ep, 16);
 193                 } else {
 194                         val = strtoq(buf, &ep, 10);
 195                 }
 196                 break;
 197         }
 198         return (val);
 199 }
 200
 201 static void
 202 aml_simulation_regload(const char *dumpfile)
 203 {
 204         char    buf[256], *np, *ep;
 205         struct  ACPIRegionContent rc;
 206         FILE    *fp;
 207
 208         if (!aml_simulation_initialized) {
 209                 return;
 210         }
 211
 212         if ((fp = fopen(dumpfile, "r")) == NULL) {
 213                 return;
 214         }
 215
 216         while (fgets(buf, sizeof buf, fp) != NULL) {
 217                 np = buf;
 218                 /* reading region type */
 219                 rc.regtype = strtoq(np, &ep, 10);
 220                 if (np == ep) {
 221                         continue;
 222                 }
 223                 np = ep;
 224
 225                 /* reading address */
 226                 rc.addr = strtoq(np, &ep, 16);
 227                 if (np == ep) {
 228                         continue;
 229                 }
 230                 np = ep;
 231
 232                 /* reading value */
 233                 rc.value = strtoq(np, &ep, 16);
 234                 if (np == ep) {
 235                         continue;
 236                 }
 237                 aml_simulate_regcontent_write(rc.regtype, rc.addr, &rc.value);
 238         }
 239
 240         fclose(fp);
 241 }
 242
 243 static void
 244 aml_simulation_regdump(const char *dumpfile)
 245 {
 246         struct  ACPIRegionContent *rc;
 247         FILE    *fp;
 248
 249         if (!aml_simulation_initialized) {
 250                 return;
 251         }
 252         if ((fp = fopen(dumpfile, "w")) == NULL) {
 253                 warn("%s", dumpfile);
 254                 return;
 255         }
 256         while (!TAILQ_EMPTY(&RegionContentList)) {
 257                 rc = TAILQ_FIRST(&RegionContentList);
 258                 fprintf(fp, "%d 0x%jx   0x%x\n",
 259                     rc->regtype, (uintmax_t)rc->addr, rc->value);
 260                 TAILQ_REMOVE(&RegionContentList, rc, links);
 261                 free(rc);
 262         }
 263
 264         fclose(fp);
 265         TAILQ_INIT(&RegionContentList);
 266 }
 267
 268 /*
 269  * Space handlers on virtual machine
 270  */
 271
 272 static ACPI_STATUS
 273 aml_vm_space_handler(
 274         UINT32                  SpaceID,
 275         UINT32                  Function,
 276         ACPI_PHYSICAL_ADDRESS   Address,
 277         UINT32                  BitWidth,
 278         UINT64                  *Value,
 279         int                     Prompt)
 280 {
 281         int                     state;
 282         UINT8                   val;
 283         UINT64                  value, i;
 284         char                    msg[256];
 285         static const char       *space_names[] = {
 286                 "SYSTEM_MEMORY", "SYSTEM_IO", "PCI_CONFIG",
 287                 "EC", "SMBUS", "CMOS", "PCI_BAR_TARGET"};
 288
 289         switch (Function) {
 290         case ACPI_READ:
 291                 value = 0;
 292                 for (i = 0; (i * 8) < BitWidth; i++) {
 293                         state = aml_simulate_regcontent_read(SpaceID,
 294                                                              Address + i, &val);
 295                         if (state == -1) {
 296                                 return (AE_NO_MEMORY);
 297                         }
 298                         value |= val << (i * 8);
 299                 }
 300                 *Value = value;
 301                 if (Prompt) {
 302                         sprintf(msg, "[read (%s, %2d, 0x%jx)]",
 303                                 space_names[SpaceID], BitWidth,
 304                                 (uintmax_t)Address);
 305                         *Value = aml_simulate_prompt(msg, value);
 306                         if (*Value != value) {
 307                                 return(aml_vm_space_handler(SpaceID,
 308                                                 ACPI_WRITE,
 309                                                 Address, BitWidth, Value, 0));
 310                         }
 311                 }
 312                 break;
 313
 314         case ACPI_WRITE:
 315                 value = *Value;
 316                 if (Prompt) {
 317                         sprintf(msg, "[write(%s, %2d, 0x%jx)]",
 318                                 space_names[SpaceID], BitWidth,
 319                                 (uintmax_t)Address);
 320                         value = aml_simulate_prompt(msg, *Value);
 321                 }
 322                 *Value = value;
 323                 for (i = 0; (i * 8) < BitWidth; i++) {
 324                         val = value & 0xff;
 325                         state = aml_simulate_regcontent_write(SpaceID,
 326                                                               Address + i, &val);
 327                         if (state == -1) {
 328                                 return (AE_NO_MEMORY);
 329                         }
 330                         value = value >> 8;
 331                 }
 332         }
 333
 334         return (AE_OK);
 335 }
 336
 337 #define DECLARE_VM_SPACE_HANDLER(name, id);                     \
 338 static ACPI_STATUS                                              \
 339 aml_vm_space_handler_##name (                                   \
 340         UINT32                  Function,                       \
 341         ACPI_PHYSICAL_ADDRESS   Address,                        \
 342         UINT32                  BitWidth,                       \
 343         UINT64                  *Value)                         \
 344 {                                                               \
 345         return (aml_vm_space_handler(id, Function, Address,     \
 346                 BitWidth, Value, aml_debug_prompt));            \
 347 }
 348
 349 DECLARE_VM_SPACE_HANDLER(system_memory, ACPI_ADR_SPACE_SYSTEM_MEMORY);
 350 DECLARE_VM_SPACE_HANDLER(system_io,     ACPI_ADR_SPACE_SYSTEM_IO);
 351 DECLARE_VM_SPACE_HANDLER(pci_config,    ACPI_ADR_SPACE_PCI_CONFIG);
 352 DECLARE_VM_SPACE_HANDLER(ec,            ACPI_ADR_SPACE_EC);
 353 DECLARE_VM_SPACE_HANDLER(smbus,         ACPI_ADR_SPACE_SMBUS);
 354 DECLARE_VM_SPACE_HANDLER(cmos,          ACPI_ADR_SPACE_CMOS);
 355 DECLARE_VM_SPACE_HANDLER(pci_bar_target,ACPI_ADR_SPACE_PCI_BAR_TARGET);
 356
 357 /*
 358  * Load DSDT data file and invoke debugger
 359  */
 360
 361 static int
 362 load_dsdt(const char *dsdtfile)
 363 {
 364         char                    filetmp[PATH_MAX];
 365         u_int8_t                *code;
 366         struct stat             sb;
 367         int                     fd, fd2;
 368         int                     error;
 369
 370         fd = open(dsdtfile, O_RDONLY, 0);
 371         if (fd == -1) {
 372                 perror("open");
 373                 return (-1);
 374         }
 375         if (fstat(fd, &sb) == -1) {
 376                 perror("fstat");
 377                 close(fd);
 378                 return (-1);
 379         }
 380         code = mmap(NULL, (size_t)sb.st_size, PROT_READ, MAP_PRIVATE, fd, (off_t)0);
 381         if (code == NULL) {
 382                 perror("mmap");
 383                 return (-1);
 384         }
 385         if ((error = AcpiInitializeSubsystem()) != AE_OK) {
 386                 return (-1);
 387         }
 388
 389         /*
 390          * make sure DSDT data contains table header or not.
 391          */
 392         if (strncmp((char *)code, "DSDT", 4) == 0) {
 393                 strncpy(filetmp, dsdtfile, sizeof(filetmp));
 394         } else {
 395                 mode_t  mode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 396                 dummy_dsdt_table.Length = sizeof(ACPI_TABLE_HEADER) + sb.st_size;
 397                 snprintf(filetmp, sizeof(filetmp), "%s.tmp", dsdtfile);
 398                 fd2 = open(filetmp, O_WRONLY | O_CREAT | O_TRUNC, mode);
 399                 if (fd2 == -1) {
 400                         perror("open");
 401                         return (-1);
 402                 }
 403                 write(fd2, &dummy_dsdt_table, sizeof(ACPI_TABLE_HEADER));
 404
 405                 write(fd2, code, sb.st_size);
 406                 close(fd2);
 407         }
 408
 409         /*
 410          * Install the virtual machine version of address space handlers.
 411          */
 412         if ((error = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
 413                         ACPI_ADR_SPACE_SYSTEM_MEMORY,
 414                         (ACPI_ADR_SPACE_HANDLER)aml_vm_space_handler_system_memory,
 415                         NULL, NULL)) != AE_OK) {
 416                 fprintf(stderr, "could not initialise SystemMemory handler: %d\n", error);
 417                 return (-1);
 418         }
 419         if ((error = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
 420                         ACPI_ADR_SPACE_SYSTEM_IO,
 421                         (ACPI_ADR_SPACE_HANDLER)aml_vm_space_handler_system_io,
 422                         NULL, NULL)) != AE_OK) {
 423                 fprintf(stderr, "could not initialise SystemIO handler: %d\n", error);
 424                 return (-1);
 425         }
 426         if ((error = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
 427                         ACPI_ADR_SPACE_PCI_CONFIG,
 428                         (ACPI_ADR_SPACE_HANDLER)aml_vm_space_handler_pci_config,
 429                         NULL, NULL)) != AE_OK) {
 430                 fprintf(stderr, "could not initialise PciConfig handler: %d\n", error);
 431                 return (-1);
 432         }
 433         if ((error = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
 434                         ACPI_ADR_SPACE_EC,
 435                         (ACPI_ADR_SPACE_HANDLER)aml_vm_space_handler_ec,
 436                         NULL, NULL)) != AE_OK) {
 437                 fprintf(stderr, "could not initialise EC handler: %d\n", error);
 438                 return (-1);
 439         }
 440         if ((error = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
 441                         ACPI_ADR_SPACE_SMBUS,
 442                         (ACPI_ADR_SPACE_HANDLER)aml_vm_space_handler_smbus,
 443                         NULL, NULL)) != AE_OK) {
 444                 fprintf(stderr, "could not initialise SMBUS handler: %d\n", error);
 445                 return (-1);
 446         }
 447         if ((error = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
 448                         ACPI_ADR_SPACE_CMOS,
 449                         (ACPI_ADR_SPACE_HANDLER)aml_vm_space_handler_cmos,
 450                         NULL, NULL)) != AE_OK) {
 451                 fprintf(stderr, "could not initialise CMOS handler: %d\n", error);
 452                 return (-1);
 453         }
 454         if ((error = AcpiInstallAddressSpaceHandler(ACPI_ROOT_OBJECT,
 455                         ACPI_ADR_SPACE_PCI_BAR_TARGET,
 456                         (ACPI_ADR_SPACE_HANDLER)aml_vm_space_handler_pci_bar_target,
 457                         NULL, NULL)) != AE_OK) {
 458                 fprintf(stderr, "could not initialise PCI BAR TARGET handler: %d\n", error);
 459                 return (-1);
 460         }
 461
 462         AcpiDbGetTableFromFile(filetmp, NULL);
 463
 464         AcpiDbInitialize();
 465         AcpiGbl_DebuggerConfiguration = 0;
 466         AcpiDbUserCommands(':', NULL);
 467
 468         if (strcmp(dsdtfile, filetmp) != 0) {
 469                 unlink(filetmp);
 470         }
 471
 472         return (0);
 473 }
 474
 475 static void
 476 usage(const char *progname)
 477 {
 478
 479         printf("usage: %s dsdt_file\n", progname);
 480         exit(1);
 481 }
 482
 483 int
 484 main(int argc, char *argv[])
 485 {
 486         char    *progname;
 487
 488         progname = argv[0];
 489
 490         if (argc == 1) {
 491                 usage(progname);
 492         }
 493
 494         AcpiDbgLevel = ACPI_DEBUG_DEFAULT;
 495
 496         /*
 497          * Match kernel options for the interpreter.  Global variable names
 498          * can be found in acglobal.h.
 499          */
 500         AcpiGbl_EnableInterpreterSlack = TRUE;
 501
 502         aml_simulation_regload("region.ini");
 503         if (load_dsdt(argv[1]) == 0) {
 504                 aml_simulation_regdump("region.dmp");
 505         }
 506
 507         return (0);
 508 }