sys/i386/acpica/acpi_machdep.c

   1 /*-
   2  * Copyright (c) 2001 Mitsuru IWASAKI
   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
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/bus.h>
  32 #include <sys/condvar.h>
  33 #include <sys/conf.h>
  34 #include <sys/fcntl.h>
  35 #include <sys/kernel.h>
  36 #include <sys/malloc.h>
  37 #include <sys/module.h>
  38 #include <sys/poll.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/uio.h>
  41 #include <vm/vm.h>
  42 #include <vm/pmap.h>
  43
  44 #include <contrib/dev/acpica/include/acpi.h>
  45 #include <contrib/dev/acpica/include/accommon.h>
  46 #include <contrib/dev/acpica/include/actables.h>
  47
  48 #include <dev/acpica/acpivar.h>
  49 #include <dev/acpica/acpiio.h>
  50
  51 #include <machine/nexusvar.h>
  52
  53 /*
  54  * APM driver emulation
  55  */
  56
  57 #include <machine/apm_bios.h>
  58 #include <machine/pc/bios.h>
  59
  60 #include <i386/bios/apm.h>
  61
  62 uint32_t acpi_resume_beep;
  63 TUNABLE_INT("debug.acpi.resume_beep", &acpi_resume_beep);
  64 SYSCTL_UINT(_debug_acpi, OID_AUTO, resume_beep, CTLFLAG_RW, &acpi_resume_beep,
  65     0, "Beep the PC speaker when resuming");
  66 uint32_t acpi_reset_video;
  67 TUNABLE_INT("hw.acpi.reset_video", &acpi_reset_video);
  68
  69 static int intr_model = ACPI_INTR_PIC;
  70 static int apm_active;
  71 static struct clonedevs *apm_clones;
  72
  73 MALLOC_DEFINE(M_APMDEV, "apmdev", "APM device emulation");
  74
  75 static d_open_t         apmopen;
  76 static d_close_t        apmclose;
  77 static d_write_t        apmwrite;
  78 static d_ioctl_t        apmioctl;
  79 static d_poll_t         apmpoll;
  80 static d_kqfilter_t     apmkqfilter;
  81 static void             apmreadfiltdetach(struct knote *kn);
  82 static int              apmreadfilt(struct knote *kn, long hint);
  83 static struct filterops apm_readfiltops =
  84         { 1, NULL, apmreadfiltdetach, apmreadfilt };
  85
  86 static struct cdevsw apm_cdevsw = {
  87         .d_version =    D_VERSION,
  88         .d_flags =      D_TRACKCLOSE | D_NEEDMINOR,
  89         .d_open =       apmopen,
  90         .d_close =      apmclose,
  91         .d_write =      apmwrite,
  92         .d_ioctl =      apmioctl,
  93         .d_poll =       apmpoll,
  94         .d_name =       "apm",
  95         .d_kqfilter =   apmkqfilter
  96 };
  97
  98 static int
  99 acpi_capm_convert_battstate(struct  acpi_battinfo *battp)
 100 {
 101         int     state;
 102
 103         state = APM_UNKNOWN;
 104
 105         if (battp->state & ACPI_BATT_STAT_DISCHARG) {
 106                 if (battp->cap >= 50)
 107                         state = 0;      /* high */
 108                 else
 109                         state = 1;      /* low */
 110         }
 111         if (battp->state & ACPI_BATT_STAT_CRITICAL)
 112                 state = 2;              /* critical */
 113         if (battp->state & ACPI_BATT_STAT_CHARGING)
 114                 state = 3;              /* charging */
 115
 116         /* If still unknown, determine it based on the battery capacity. */
 117         if (state == APM_UNKNOWN) {
 118                 if (battp->cap >= 50)
 119                         state = 0;      /* high */
 120                 else
 121                         state = 1;      /* low */
 122         }
 123
 124         return (state);
 125 }
 126
 127 static int
 128 acpi_capm_convert_battflags(struct  acpi_battinfo *battp)
 129 {
 130         int     flags;
 131
 132         flags = 0;
 133
 134         if (battp->cap >= 50)
 135                 flags |= APM_BATT_HIGH;
 136         else {
 137                 if (battp->state & ACPI_BATT_STAT_CRITICAL)
 138                         flags |= APM_BATT_CRITICAL;
 139                 else
 140                         flags |= APM_BATT_LOW;
 141         }
 142         if (battp->state & ACPI_BATT_STAT_CHARGING)
 143                 flags |= APM_BATT_CHARGING;
 144         if (battp->state == ACPI_BATT_STAT_NOT_PRESENT)
 145                 flags = APM_BATT_NOT_PRESENT;
 146
 147         return (flags);
 148 }
 149
 150 static int
 151 acpi_capm_get_info(apm_info_t aip)
 152 {
 153         int     acline;
 154         struct  acpi_battinfo batt;
 155
 156         aip->ai_infoversion = 1;
 157         aip->ai_major       = 1;
 158         aip->ai_minor       = 2;
 159         aip->ai_status      = apm_active;
 160         aip->ai_capabilities= 0xff00;   /* unknown */
 161
 162         if (acpi_acad_get_acline(&acline))
 163                 aip->ai_acline = APM_UNKNOWN;   /* unknown */
 164         else
 165                 aip->ai_acline = acline;        /* on/off */
 166
 167         if (acpi_battery_get_battinfo(NULL, &batt) != 0) {
 168                 aip->ai_batt_stat = APM_UNKNOWN;
 169                 aip->ai_batt_life = APM_UNKNOWN;
 170                 aip->ai_batt_time = -1;          /* unknown */
 171                 aip->ai_batteries = ~0U;         /* unknown */
 172         } else {
 173                 aip->ai_batt_stat = acpi_capm_convert_battstate(&batt);
 174                 aip->ai_batt_life = batt.cap;
 175                 aip->ai_batt_time = (batt.min == -1) ? -1 : batt.min * 60;
 176                 aip->ai_batteries = acpi_battery_get_units();
 177         }
 178
 179         return (0);
 180 }
 181
 182 static int
 183 acpi_capm_get_pwstatus(apm_pwstatus_t app)
 184 {
 185         device_t dev;
 186         int     acline, unit, error;
 187         struct  acpi_battinfo batt;
 188
 189         if (app->ap_device != PMDV_ALLDEV &&
 190             (app->ap_device < PMDV_BATT0 || app->ap_device > PMDV_BATT_ALL))
 191                 return (1);
 192
 193         if (app->ap_device == PMDV_ALLDEV)
 194                 error = acpi_battery_get_battinfo(NULL, &batt);
 195         else {
 196                 unit = app->ap_device - PMDV_BATT0;
 197                 dev = devclass_get_device(devclass_find("battery"), unit);
 198                 if (dev != NULL)
 199                         error = acpi_battery_get_battinfo(dev, &batt);
 200                 else
 201                         error = ENXIO;
 202         }
 203         if (error)
 204                 return (1);
 205
 206         app->ap_batt_stat = acpi_capm_convert_battstate(&batt);
 207         app->ap_batt_flag = acpi_capm_convert_battflags(&batt);
 208         app->ap_batt_life = batt.cap;
 209         app->ap_batt_time = (batt.min == -1) ? -1 : batt.min * 60;
 210
 211         if (acpi_acad_get_acline(&acline))
 212                 app->ap_acline = APM_UNKNOWN;
 213         else
 214                 app->ap_acline = acline;        /* on/off */
 215
 216         return (0);
 217 }
 218
 219 /* Create single-use devices for /dev/apm and /dev/apmctl. */
 220 static void
 221 apm_clone(void *arg, struct ucred *cred, char *name, int namelen,
 222     struct cdev **dev)
 223 {
 224         int ctl_dev, unit;
 225
 226         if (*dev != NULL)
 227                 return;
 228         if (strcmp(name, "apmctl") == 0)
 229                 ctl_dev = TRUE;
 230         else if (strcmp(name, "apm") == 0)
 231                 ctl_dev = FALSE;
 232         else
 233                 return;
 234
 235         /* Always create a new device and unit number. */
 236         unit = -1;
 237         if (clone_create(&apm_clones, &apm_cdevsw, &unit, dev, 0)) {
 238                 if (ctl_dev) {
 239                         *dev = make_dev(&apm_cdevsw, unit,
 240                             UID_ROOT, GID_OPERATOR, 0660, "apmctl%d", unit);
 241                 } else {
 242                         *dev = make_dev(&apm_cdevsw, unit,
 243                             UID_ROOT, GID_OPERATOR, 0664, "apm%d", unit);
 244                 }
 245                 if (*dev != NULL) {
 246                         dev_ref(*dev);
 247                         (*dev)->si_flags |= SI_CHEAPCLONE;
 248                 }
 249         }
 250 }
 251
 252 /* Create a struct for tracking per-device suspend notification. */
 253 static struct apm_clone_data *
 254 apm_create_clone(struct cdev *dev, struct acpi_softc *acpi_sc)
 255 {
 256         struct apm_clone_data *clone;
 257
 258         clone = malloc(sizeof(*clone), M_APMDEV, M_WAITOK);
 259         clone->cdev = dev;
 260         clone->acpi_sc = acpi_sc;
 261         clone->notify_status = APM_EV_NONE;
 262         bzero(&clone->sel_read, sizeof(clone->sel_read));
 263         knlist_init_mtx(&clone->sel_read.si_note, &acpi_mutex);
 264
 265         /*
 266          * The acpi device is always managed by devd(8) and is considered
 267          * writable (i.e., ack is required to allow suspend to proceed.)
 268          */
 269         if (strcmp("acpi", devtoname(dev)) == 0)
 270                 clone->flags = ACPI_EVF_DEVD | ACPI_EVF_WRITE;
 271         else
 272                 clone->flags = ACPI_EVF_NONE;
 273
 274         ACPI_LOCK(acpi);
 275         STAILQ_INSERT_TAIL(&acpi_sc->apm_cdevs, clone, entries);
 276         ACPI_UNLOCK(acpi);
 277         return (clone);
 278 }
 279
 280 static int
 281 apmopen(struct cdev *dev, int flag, int fmt, struct thread *td)
 282 {
 283         struct  acpi_softc *acpi_sc;
 284         struct  apm_clone_data *clone;
 285
 286         acpi_sc = devclass_get_softc(devclass_find("acpi"), 0);
 287         clone = apm_create_clone(dev, acpi_sc);
 288         dev->si_drv1 = clone;
 289
 290         /* If the device is opened for write, record that. */
 291         if ((flag & FWRITE) != 0)
 292                 clone->flags |= ACPI_EVF_WRITE;
 293
 294         return (0);
 295 }
 296
 297 static int
 298 apmclose(struct cdev *dev, int flag, int fmt, struct thread *td)
 299 {
 300         struct  apm_clone_data *clone;
 301         struct  acpi_softc *acpi_sc;
 302
 303         clone = dev->si_drv1;
 304         acpi_sc = clone->acpi_sc;
 305
 306         /* We are about to lose a reference so check if suspend should occur */
 307         if (acpi_sc->acpi_next_sstate != 0 &&
 308             clone->notify_status != APM_EV_ACKED)
 309                 acpi_AckSleepState(clone, 0);
 310
 311         /* Remove this clone's data from the list and free it. */
 312         ACPI_LOCK(acpi);
 313         STAILQ_REMOVE(&acpi_sc->apm_cdevs, clone, apm_clone_data, entries);
 314         seldrain(&clone->sel_read);
 315         knlist_destroy(&clone->sel_read.si_note);
 316         ACPI_UNLOCK(acpi);
 317         free(clone, M_APMDEV);
 318         destroy_dev_sched(dev);
 319         return (0);
 320 }
 321
 322 static int
 323 apmioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td)
 324 {
 325         int     error;
 326         struct  apm_clone_data *clone;
 327         struct  acpi_softc *acpi_sc;
 328         struct  apm_info info;
 329         struct  apm_event_info *ev_info;
 330         apm_info_old_t aiop;
 331
 332         error = 0;
 333         clone = dev->si_drv1;
 334         acpi_sc = clone->acpi_sc;
 335
 336         switch (cmd) {
 337         case APMIO_SUSPEND:
 338                 if ((flag & FWRITE) == 0)
 339                         return (EPERM);
 340                 if (acpi_sc->acpi_next_sstate == 0) {
 341                         if (acpi_sc->acpi_suspend_sx != ACPI_STATE_S5) {
 342                                 error = acpi_ReqSleepState(acpi_sc,
 343                                     acpi_sc->acpi_suspend_sx);
 344                         } else {
 345                                 printf(
 346                         "power off via apm suspend not supported\n");
 347                                 error = ENXIO;
 348                         }
 349                 } else
 350                         error = acpi_AckSleepState(clone, 0);
 351                 break;
 352         case APMIO_STANDBY:
 353                 if ((flag & FWRITE) == 0)
 354                         return (EPERM);
 355                 if (acpi_sc->acpi_next_sstate == 0) {
 356                         if (acpi_sc->acpi_standby_sx != ACPI_STATE_S5) {
 357                                 error = acpi_ReqSleepState(acpi_sc,
 358                                     acpi_sc->acpi_standby_sx);
 359                         } else {
 360                                 printf(
 361                         "power off via apm standby not supported\n");
 362                                 error = ENXIO;
 363                         }
 364                 } else
 365                         error = acpi_AckSleepState(clone, 0);
 366                 break;
 367         case APMIO_NEXTEVENT:
 368                 printf("apm nextevent start\n");
 369                 ACPI_LOCK(acpi);
 370                 if (acpi_sc->acpi_next_sstate != 0 && clone->notify_status ==
 371                     APM_EV_NONE) {
 372                         ev_info = (struct apm_event_info *)addr;
 373                         if (acpi_sc->acpi_next_sstate <= ACPI_STATE_S3)
 374                                 ev_info->type = PMEV_STANDBYREQ;
 375                         else
 376                                 ev_info->type = PMEV_SUSPENDREQ;
 377                         ev_info->index = 0;
 378                         clone->notify_status = APM_EV_NOTIFIED;
 379                         printf("apm event returning %d\n", ev_info->type);
 380                 } else
 381                         error = EAGAIN;
 382                 ACPI_UNLOCK(acpi);
 383                 break;
 384         case APMIO_GETINFO_OLD:
 385                 if (acpi_capm_get_info(&info))
 386                         error = ENXIO;
 387                 aiop = (apm_info_old_t)addr;
 388                 aiop->ai_major = info.ai_major;
 389                 aiop->ai_minor = info.ai_minor;
 390                 aiop->ai_acline = info.ai_acline;
 391                 aiop->ai_batt_stat = info.ai_batt_stat;
 392                 aiop->ai_batt_life = info.ai_batt_life;
 393                 aiop->ai_status = info.ai_status;
 394                 break;
 395         case APMIO_GETINFO:
 396                 if (acpi_capm_get_info((apm_info_t)addr))
 397                         error = ENXIO;
 398                 break;
 399         case APMIO_GETPWSTATUS:
 400                 if (acpi_capm_get_pwstatus((apm_pwstatus_t)addr))
 401                         error = ENXIO;
 402                 break;
 403         case APMIO_ENABLE:
 404                 if ((flag & FWRITE) == 0)
 405                         return (EPERM);
 406                 apm_active = 1;
 407                 break;
 408         case APMIO_DISABLE:
 409                 if ((flag & FWRITE) == 0)
 410                         return (EPERM);
 411                 apm_active = 0;
 412                 break;
 413         case APMIO_HALTCPU:
 414                 break;
 415         case APMIO_NOTHALTCPU:
 416                 break;
 417         case APMIO_DISPLAY:
 418                 if ((flag & FWRITE) == 0)
 419                         return (EPERM);
 420                 break;
 421         case APMIO_BIOS:
 422                 if ((flag & FWRITE) == 0)
 423                         return (EPERM);
 424                 bzero(addr, sizeof(struct apm_bios_arg));
 425                 break;
 426         default:
 427                 error = EINVAL;
 428                 break;
 429         }
 430
 431         return (error);
 432 }
 433
 434 static int
 435 apmwrite(struct cdev *dev, struct uio *uio, int ioflag)
 436 {
 437         return (uio->uio_resid);
 438 }
 439
 440 static int
 441 apmpoll(struct cdev *dev, int events, struct thread *td)
 442 {
 443         struct  apm_clone_data *clone;
 444         int revents;
 445
 446         revents = 0;
 447         ACPI_LOCK(acpi);
 448         clone = dev->si_drv1;
 449         if (clone->acpi_sc->acpi_next_sstate)
 450                 revents |= events & (POLLIN | POLLRDNORM);
 451         else
 452                 selrecord(td, &clone->sel_read);
 453         ACPI_UNLOCK(acpi);
 454         return (revents);
 455 }
 456
 457 static int
 458 apmkqfilter(struct cdev *dev, struct knote *kn)
 459 {
 460         struct  apm_clone_data *clone;
 461
 462         ACPI_LOCK(acpi);
 463         clone = dev->si_drv1;
 464         kn->kn_hook = clone;
 465         kn->kn_fop = &apm_readfiltops;
 466         knlist_add(&clone->sel_read.si_note, kn, 0);
 467         ACPI_UNLOCK(acpi);
 468         return (0);
 469 }
 470
 471 static void
 472 apmreadfiltdetach(struct knote *kn)
 473 {
 474         struct  apm_clone_data *clone;
 475
 476         ACPI_LOCK(acpi);
 477         clone = kn->kn_hook;
 478         knlist_remove(&clone->sel_read.si_note, kn, 0);
 479         ACPI_UNLOCK(acpi);
 480 }
 481
 482 static int
 483 apmreadfilt(struct knote *kn, long hint)
 484 {
 485         struct  apm_clone_data *clone;
 486         int     sleeping;
 487
 488         ACPI_LOCK(acpi);
 489         clone = kn->kn_hook;
 490         sleeping = clone->acpi_sc->acpi_next_sstate ? 1 : 0;
 491         ACPI_UNLOCK(acpi);
 492         return (sleeping);
 493 }
 494
 495 int
 496 acpi_machdep_init(device_t dev)
 497 {
 498         struct  acpi_softc *acpi_sc;
 499
 500         acpi_sc = devclass_get_softc(devclass_find("acpi"), 0);
 501
 502         /* Create a clone for /dev/acpi also. */
 503         STAILQ_INIT(&acpi_sc->apm_cdevs);
 504         acpi_sc->acpi_clone = apm_create_clone(acpi_sc->acpi_dev_t, acpi_sc);
 505         clone_setup(&apm_clones);
 506         EVENTHANDLER_REGISTER(dev_clone, apm_clone, 0, 1000);
 507         acpi_install_wakeup_handler(acpi_sc);
 508
 509         if (intr_model == ACPI_INTR_PIC)
 510                 BUS_CONFIG_INTR(dev, AcpiGbl_FADT.SciInterrupt,
 511                     INTR_TRIGGER_LEVEL, INTR_POLARITY_LOW);
 512         else
 513                 acpi_SetIntrModel(intr_model);
 514
 515         SYSCTL_ADD_UINT(&acpi_sc->acpi_sysctl_ctx,
 516             SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO,
 517             "reset_video", CTLFLAG_RW, &acpi_reset_video, 0,
 518             "Call the VESA reset BIOS vector on the resume path");
 519
 520         return (0);
 521 }
 522
 523 void
 524 acpi_SetDefaultIntrModel(int model)
 525 {
 526
 527         intr_model = model;
 528 }
 529
 530 /* Check BIOS date.  If 1998 or older, disable ACPI. */
 531 int
 532 acpi_machdep_quirks(int *quirks)
 533 {
 534         char *va;
 535         int year;
 536
 537         /* BIOS address 0xffff5 contains the date in the format mm/dd/yy. */
 538         va = pmap_mapbios(0xffff0, 16);
 539         sscanf(va + 11, "%2d", &year);
 540         pmap_unmapbios((vm_offset_t)va, 16);
 541
 542         /*
 543          * Date must be >= 1/1/1999 or we don't trust ACPI.  Note that this
 544          * check must be changed by my 114th birthday.
 545          */
 546         if (year > 90 && year < 99)
 547                 *quirks = ACPI_Q_BROKEN;
 548
 549         return (0);
 550 }
 551
 552 void
 553 acpi_cpu_c1()
 554 {
 555         __asm __volatile("sti; hlt");
 556 }
 557
 558 /*
 559  * Support for mapping ACPI tables during early boot.  This abuses the
 560  * crashdump map because the kernel cannot allocate KVA in
 561  * pmap_mapbios() when this is used.  This makes the following
 562  * assumptions about how we use this KVA: pages 0 and 1 are used to
 563  * map in the header of each table found via the RSDT or XSDT and
 564  * pages 2 to n are used to map in the RSDT or XSDT.  This has to use
 565  * 2 pages for the table headers in case a header spans a page
 566  * boundary.
 567  *
 568  * XXX: We don't ensure the table fits in the available address space
 569  * in the crashdump map.
 570  */
 571
 572 /*
 573  * Map some memory using the crashdump map.  'offset' is an offset in
 574  * pages into the crashdump map to use for the start of the mapping.
 575  */
 576 static void *
 577 table_map(vm_paddr_t pa, int offset, vm_offset_t length)
 578 {
 579         vm_offset_t va, off;
 580         void *data;
 581
 582         off = pa & PAGE_MASK;
 583         length = roundup(length + off, PAGE_SIZE);
 584         pa = pa & PG_FRAME;
 585         va = (vm_offset_t)pmap_kenter_temporary(pa, offset) +
 586             (offset * PAGE_SIZE);
 587         data = (void *)(va + off);
 588         length -= PAGE_SIZE;
 589         while (length > 0) {
 590                 va += PAGE_SIZE;
 591                 pa += PAGE_SIZE;
 592                 length -= PAGE_SIZE;
 593                 pmap_kenter(va, pa);
 594                 invlpg(va);
 595         }
 596         return (data);
 597 }
 598
 599 /* Unmap memory previously mapped with table_map(). */
 600 static void
 601 table_unmap(void *data, vm_offset_t length)
 602 {
 603         vm_offset_t va, off;
 604
 605         va = (vm_offset_t)data;
 606         off = va & PAGE_MASK;
 607         length = roundup(length + off, PAGE_SIZE);
 608         va &= ~PAGE_MASK;
 609         while (length > 0) {
 610                 pmap_kremove(va);
 611                 invlpg(va);
 612                 va += PAGE_SIZE;
 613                 length -= PAGE_SIZE;
 614         }
 615 }
 616
 617 /*
 618  * Map a table at a given offset into the crashdump map.  It first
 619  * maps the header to determine the table length and then maps the
 620  * entire table.
 621  */
 622 static void *
 623 map_table(vm_paddr_t pa, int offset, const char *sig)
 624 {
 625         ACPI_TABLE_HEADER *header;
 626         vm_offset_t length;
 627         void *table;
 628
 629         header = table_map(pa, offset, sizeof(ACPI_TABLE_HEADER));
 630         if (strncmp(header->Signature, sig, ACPI_NAME_SIZE) != 0) {
 631                 table_unmap(header, sizeof(ACPI_TABLE_HEADER));
 632                 return (NULL);
 633         }
 634         length = header->Length;
 635         table_unmap(header, sizeof(ACPI_TABLE_HEADER));
 636         table = table_map(pa, offset, length);
 637         if (ACPI_FAILURE(AcpiTbChecksum(table, length))) {
 638                 if (bootverbose)
 639                         printf("ACPI: Failed checksum for table %s\n", sig);
 640 #if (ACPI_CHECKSUM_ABORT)
 641                 table_unmap(table, length);
 642                 return (NULL);
 643 #endif
 644         }
 645         return (table);
 646 }
 647
 648 /*
 649  * See if a given ACPI table is the requested table.  Returns the
 650  * length of the able if it matches or zero on failure.
 651  */
 652 static int
 653 probe_table(vm_paddr_t address, const char *sig)
 654 {
 655         ACPI_TABLE_HEADER *table;
 656
 657         table = table_map(address, 0, sizeof(ACPI_TABLE_HEADER));
 658         if (table == NULL) {
 659                 if (bootverbose)
 660                         printf("ACPI: Failed to map table at 0x%jx\n",
 661                             (uintmax_t)address);
 662                 return (0);
 663         }
 664         if (bootverbose)
 665                 printf("Table '%.4s' at 0x%jx\n", table->Signature,
 666                     (uintmax_t)address);
 667
 668         if (strncmp(table->Signature, sig, ACPI_NAME_SIZE) != 0) {
 669                 table_unmap(table, sizeof(ACPI_TABLE_HEADER));
 670                 return (0);
 671         }
 672         table_unmap(table, sizeof(ACPI_TABLE_HEADER));
 673         return (1);
 674 }
 675
 676 /*
 677  * Try to map a table at a given physical address previously returned
 678  * by acpi_find_table().
 679  */
 680 void *
 681 acpi_map_table(vm_paddr_t pa, const char *sig)
 682 {
 683
 684         return (map_table(pa, 0, sig));
 685 }
 686
 687 /* Unmap a table previously mapped via acpi_map_table(). */
 688 void
 689 acpi_unmap_table(void *table)
 690 {
 691         ACPI_TABLE_HEADER *header;
 692
 693         header = (ACPI_TABLE_HEADER *)table;
 694         table_unmap(table, header->Length);
 695 }
 696
 697 /*
 698  * Return the physical address of the requested table or zero if one
 699  * is not found.
 700  */
 701 vm_paddr_t
 702 acpi_find_table(const char *sig)
 703 {
 704         ACPI_PHYSICAL_ADDRESS rsdp_ptr;
 705         ACPI_TABLE_RSDP *rsdp;
 706         ACPI_TABLE_RSDT *rsdt;
 707         ACPI_TABLE_XSDT *xsdt;
 708         ACPI_TABLE_HEADER *table;
 709         vm_paddr_t addr;
 710         int i, count;
 711
 712         if (resource_disabled("acpi", 0))
 713                 return (0);
 714
 715         /*
 716          * Map in the RSDP.  Since ACPI uses AcpiOsMapMemory() which in turn
 717          * calls pmap_mapbios() to find the RSDP, we assume that we can use
 718          * pmap_mapbios() to map the RSDP.
 719          */
 720         if ((rsdp_ptr = AcpiOsGetRootPointer()) == 0)
 721                 return (0);
 722         rsdp = pmap_mapbios(rsdp_ptr, sizeof(ACPI_TABLE_RSDP));
 723         if (rsdp == NULL) {
 724                 if (bootverbose)
 725                         printf("ACPI: Failed to map RSDP\n");
 726                 return (0);
 727         }
 728
 729         /*
 730          * For ACPI >= 2.0, use the XSDT if it is available.
 731          * Otherwise, use the RSDT.  We map the XSDT or RSDT at page 2
 732          * in the crashdump area.  Pages 0 and 1 are used to map in the
 733          * headers of candidate ACPI tables.
 734          */
 735         addr = 0;
 736         if (rsdp->Revision >= 2 && rsdp->XsdtPhysicalAddress != 0) {
 737                 /*
 738                  * AcpiOsGetRootPointer only verifies the checksum for
 739                  * the version 1.0 portion of the RSDP.  Version 2.0 has
 740                  * an additional checksum that we verify first.
 741                  */
 742                 if (AcpiTbChecksum((UINT8 *)rsdp, ACPI_RSDP_XCHECKSUM_LENGTH)) {
 743                         if (bootverbose)
 744                                 printf("ACPI: RSDP failed extended checksum\n");
 745                         return (0);
 746                 }
 747                 xsdt = map_table(rsdp->XsdtPhysicalAddress, 2, ACPI_SIG_XSDT);
 748                 if (xsdt == NULL) {
 749                         if (bootverbose)
 750                                 printf("ACPI: Failed to map XSDT\n");
 751                         return (0);
 752                 }
 753                 count = (xsdt->Header.Length - sizeof(ACPI_TABLE_HEADER)) /
 754                     sizeof(UINT64);
 755                 for (i = 0; i < count; i++)
 756                         if (probe_table(xsdt->TableOffsetEntry[i], sig)) {
 757                                 addr = xsdt->TableOffsetEntry[i];
 758                                 break;
 759                         }
 760                 acpi_unmap_table(xsdt);
 761         } else {
 762                 rsdt = map_table(rsdp->RsdtPhysicalAddress, 2, ACPI_SIG_RSDT);
 763                 if (rsdt == NULL) {
 764                         if (bootverbose)
 765                                 printf("ACPI: Failed to map RSDT\n");
 766                         return (0);
 767                 }
 768                 count = (rsdt->Header.Length - sizeof(ACPI_TABLE_HEADER)) /
 769                     sizeof(UINT32);
 770                 for (i = 0; i < count; i++)
 771                         if (probe_table(rsdt->TableOffsetEntry[i], sig)) {
 772                                 addr = rsdt->TableOffsetEntry[i];
 773                                 break;
 774                         }
 775                 acpi_unmap_table(rsdt);
 776         }
 777         pmap_unmapbios((vm_offset_t)rsdp, sizeof(ACPI_TABLE_RSDP));
 778         if (addr == 0) {
 779                 if (bootverbose)
 780                         printf("ACPI: No %s table found\n", sig);
 781                 return (0);
 782         }
 783         if (bootverbose)
 784                 printf("%s: Found table at 0x%jx\n", sig, (uintmax_t)addr);
 785
 786         /*
 787          * Verify that we can map the full table and that its checksum is
 788          * correct, etc.
 789          */
 790         table = map_table(addr, 0, sig);
 791         if (table == NULL)
 792                 return (0);
 793         acpi_unmap_table(table);
 794
 795         return (addr);
 796 }
 797
 798 /*
 799  * ACPI nexus(4) driver.
 800  */
 801 static int
 802 nexus_acpi_probe(device_t dev)
 803 {
 804         int error;
 805
 806         error = acpi_identify();
 807         if (error)
 808                 return (error);
 809
 810         return (BUS_PROBE_DEFAULT);
 811 }
 812
 813 static int
 814 nexus_acpi_attach(device_t dev)
 815 {
 816
 817         nexus_init_resources();
 818         bus_generic_probe(dev);
 819         if (BUS_ADD_CHILD(dev, 10, "acpi", 0) == NULL)
 820                 panic("failed to add acpi0 device");
 821
 822         return (bus_generic_attach(dev));
 823 }
 824
 825 static device_method_t nexus_acpi_methods[] = {
 826         /* Device interface */
 827         DEVMETHOD(device_probe,         nexus_acpi_probe),
 828         DEVMETHOD(device_attach,        nexus_acpi_attach),
 829
 830         { 0, 0 }
 831 };
 832
 833 DEFINE_CLASS_1(nexus, nexus_acpi_driver, nexus_acpi_methods, 1, nexus_driver);
 834 static devclass_t nexus_devclass;
 835
 836 DRIVER_MODULE(nexus_acpi, root, nexus_acpi_driver, nexus_devclass, 0, 0);