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/acpi.h>
  45 #include <dev/acpica/acpivar.h>
  46 #include <dev/acpica/acpiio.h>
  47
  48 #include <machine/nexusvar.h>
  49
  50 /*
  51  * APM driver emulation
  52  */
  53
  54 #include <machine/apm_bios.h>
  55 #include <machine/pc/bios.h>
  56
  57 #include <i386/bios/apm.h>
  58
  59 SYSCTL_DECL(_debug_acpi);
  60
  61 uint32_t acpi_resume_beep;
  62 TUNABLE_INT("debug.acpi.resume_beep", &acpi_resume_beep);
  63 SYSCTL_UINT(_debug_acpi, OID_AUTO, resume_beep, CTLFLAG_RW, &acpi_resume_beep,
  64     0, "Beep the PC speaker when resuming");
  65 uint32_t acpi_reset_video;
  66 TUNABLE_INT("hw.acpi.reset_video", &acpi_reset_video);
  67
  68 static int intr_model = ACPI_INTR_PIC;
  69 static int apm_active;
  70 static struct clonedevs *apm_clones;
  71
  72 MALLOC_DEFINE(M_APMDEV, "apmdev", "APM device emulation");
  73
  74 static d_open_t         apmopen;
  75 static d_close_t        apmclose;
  76 static d_write_t        apmwrite;
  77 static d_ioctl_t        apmioctl;
  78 static d_poll_t         apmpoll;
  79 static d_kqfilter_t     apmkqfilter;
  80 static void             apmreadfiltdetach(struct knote *kn);
  81 static int              apmreadfilt(struct knote *kn, long hint);
  82 static struct filterops apm_readfiltops =
  83         { 1, NULL, apmreadfiltdetach, apmreadfilt };
  84
  85 static struct cdevsw apm_cdevsw = {
  86         .d_version =    D_VERSION,
  87         .d_flags =      D_TRACKCLOSE,
  88         .d_open =       apmopen,
  89         .d_close =      apmclose,
  90         .d_write =      apmwrite,
  91         .d_ioctl =      apmioctl,
  92         .d_poll =       apmpoll,
  93         .d_name =       "apm",
  94         .d_kqfilter =   apmkqfilter
  95 };
  96
  97 static int
  98 acpi_capm_convert_battstate(struct  acpi_battinfo *battp)
  99 {
 100         int     state;
 101
 102         state = APM_UNKNOWN;
 103
 104         if (battp->state & ACPI_BATT_STAT_DISCHARG) {
 105                 if (battp->cap >= 50)
 106                         state = 0;      /* high */
 107                 else
 108                         state = 1;      /* low */
 109         }
 110         if (battp->state & ACPI_BATT_STAT_CRITICAL)
 111                 state = 2;              /* critical */
 112         if (battp->state & ACPI_BATT_STAT_CHARGING)
 113                 state = 3;              /* charging */
 114
 115         /* If still unknown, determine it based on the battery capacity. */
 116         if (state == APM_UNKNOWN) {
 117                 if (battp->cap >= 50)
 118                         state = 0;      /* high */
 119                 else
 120                         state = 1;      /* low */
 121         }
 122
 123         return (state);
 124 }
 125
 126 static int
 127 acpi_capm_convert_battflags(struct  acpi_battinfo *battp)
 128 {
 129         int     flags;
 130
 131         flags = 0;
 132
 133         if (battp->cap >= 50)
 134                 flags |= APM_BATT_HIGH;
 135         else {
 136                 if (battp->state & ACPI_BATT_STAT_CRITICAL)
 137                         flags |= APM_BATT_CRITICAL;
 138                 else
 139                         flags |= APM_BATT_LOW;
 140         }
 141         if (battp->state & ACPI_BATT_STAT_CHARGING)
 142                 flags |= APM_BATT_CHARGING;
 143         if (battp->state == ACPI_BATT_STAT_NOT_PRESENT)
 144                 flags = APM_BATT_NOT_PRESENT;
 145
 146         return (flags);
 147 }
 148
 149 static int
 150 acpi_capm_get_info(apm_info_t aip)
 151 {
 152         int     acline;
 153         struct  acpi_battinfo batt;
 154
 155         aip->ai_infoversion = 1;
 156         aip->ai_major       = 1;
 157         aip->ai_minor       = 2;
 158         aip->ai_status      = apm_active;
 159         aip->ai_capabilities= 0xff00;   /* unknown */
 160
 161         if (acpi_acad_get_acline(&acline))
 162                 aip->ai_acline = APM_UNKNOWN;   /* unknown */
 163         else
 164                 aip->ai_acline = acline;        /* on/off */
 165
 166         if (acpi_battery_get_battinfo(NULL, &batt) != 0) {
 167                 aip->ai_batt_stat = APM_UNKNOWN;
 168                 aip->ai_batt_life = APM_UNKNOWN;
 169                 aip->ai_batt_time = -1;          /* unknown */
 170                 aip->ai_batteries = ~0U;         /* unknown */
 171         } else {
 172                 aip->ai_batt_stat = acpi_capm_convert_battstate(&batt);
 173                 aip->ai_batt_life = batt.cap;
 174                 aip->ai_batt_time = (batt.min == -1) ? -1 : batt.min * 60;
 175                 aip->ai_batteries = acpi_battery_get_units();
 176         }
 177
 178         return (0);
 179 }
 180
 181 static int
 182 acpi_capm_get_pwstatus(apm_pwstatus_t app)
 183 {
 184         device_t dev;
 185         int     acline, unit, error;
 186         struct  acpi_battinfo batt;
 187
 188         if (app->ap_device != PMDV_ALLDEV &&
 189             (app->ap_device < PMDV_BATT0 || app->ap_device > PMDV_BATT_ALL))
 190                 return (1);
 191
 192         if (app->ap_device == PMDV_ALLDEV)
 193                 error = acpi_battery_get_battinfo(NULL, &batt);
 194         else {
 195                 unit = app->ap_device - PMDV_BATT0;
 196                 dev = devclass_get_device(devclass_find("battery"), unit);
 197                 if (dev != NULL)
 198                         error = acpi_battery_get_battinfo(dev, &batt);
 199                 else
 200                         error = ENXIO;
 201         }
 202         if (error)
 203                 return (1);
 204
 205         app->ap_batt_stat = acpi_capm_convert_battstate(&batt);
 206         app->ap_batt_flag = acpi_capm_convert_battflags(&batt);
 207         app->ap_batt_life = batt.cap;
 208         app->ap_batt_time = (batt.min == -1) ? -1 : batt.min * 60;
 209
 210         if (acpi_acad_get_acline(&acline))
 211                 app->ap_acline = APM_UNKNOWN;
 212         else
 213                 app->ap_acline = acline;        /* on/off */
 214
 215         return (0);
 216 }
 217
 218 /* Create single-use devices for /dev/apm and /dev/apmctl. */
 219 static void
 220 apm_clone(void *arg, struct ucred *cred, char *name, int namelen,
 221     struct cdev **dev)
 222 {
 223         int ctl_dev, unit;
 224
 225         if (*dev != NULL)
 226                 return;
 227         if (strcmp(name, "apmctl") == 0)
 228                 ctl_dev = TRUE;
 229         else if (strcmp(name, "apm") == 0)
 230                 ctl_dev = FALSE;
 231         else
 232                 return;
 233
 234         /* Always create a new device and unit number. */
 235         unit = -1;
 236         if (clone_create(&apm_clones, &apm_cdevsw, &unit, dev, 0)) {
 237                 if (ctl_dev) {
 238                         *dev = make_dev(&apm_cdevsw, unit2minor(unit),
 239                             UID_ROOT, GID_OPERATOR, 0660, "apmctl%d", unit);
 240                 } else {
 241                         *dev = make_dev(&apm_cdevsw, unit2minor(unit),
 242                             UID_ROOT, GID_OPERATOR, 0664, "apm%d", unit);
 243                 }
 244                 if (*dev != NULL) {
 245                         dev_ref(*dev);
 246                         (*dev)->si_flags |= SI_CHEAPCLONE;
 247                 }
 248         }
 249 }
 250
 251 /* Create a struct for tracking per-device suspend notification. */
 252 static struct apm_clone_data *
 253 apm_create_clone(struct cdev *dev, struct acpi_softc *acpi_sc)
 254 {
 255         struct apm_clone_data *clone;
 256
 257         clone = malloc(sizeof(*clone), M_APMDEV, M_WAITOK);
 258         clone->cdev = dev;
 259         clone->acpi_sc = acpi_sc;
 260         clone->notify_status = APM_EV_NONE;
 261         bzero(&clone->sel_read, sizeof(clone->sel_read));
 262         knlist_init(&clone->sel_read.si_note, &acpi_mutex, NULL, NULL, NULL);
 263
 264         /*
 265          * The acpi device is always managed by devd(8) and is considered
 266          * writable (i.e., ack is required to allow suspend to proceed.)
 267          */
 268         if (strcmp("acpi", devtoname(dev)) == 0)
 269                 clone->flags = ACPI_EVF_DEVD | ACPI_EVF_WRITE;
 270         else
 271                 clone->flags = ACPI_EVF_NONE;
 272
 273         ACPI_LOCK(acpi);
 274         STAILQ_INSERT_TAIL(&acpi_sc->apm_cdevs, clone, entries);
 275         ACPI_UNLOCK(acpi);
 276         return (clone);
 277 }
 278
 279 static int
 280 apmopen(struct cdev *dev, int flag, int fmt, d_thread_t *td)
 281 {
 282         struct  acpi_softc *acpi_sc;
 283         struct  apm_clone_data *clone;
 284
 285         acpi_sc = devclass_get_softc(devclass_find("acpi"), 0);
 286         clone = apm_create_clone(dev, acpi_sc);
 287         dev->si_drv1 = clone;
 288
 289         /* If the device is opened for write, record that. */
 290         if ((flag & FWRITE) != 0)
 291                 clone->flags |= ACPI_EVF_WRITE;
 292
 293         return (0);
 294 }
 295
 296 static int
 297 apmclose(struct cdev *dev, int flag, int fmt, d_thread_t *td)
 298 {
 299         struct  apm_clone_data *clone;
 300         struct  acpi_softc *acpi_sc;
 301
 302         clone = dev->si_drv1;
 303         acpi_sc = clone->acpi_sc;
 304
 305         /* We are about to lose a reference so check if suspend should occur */
 306         if (acpi_sc->acpi_next_sstate != 0 &&
 307             clone->notify_status != APM_EV_ACKED)
 308                 acpi_AckSleepState(clone, 0);
 309
 310         /* Remove this clone's data from the list and free it. */
 311         ACPI_LOCK(acpi);
 312         STAILQ_REMOVE(&acpi_sc->apm_cdevs, clone, apm_clone_data, entries);
 313         knlist_destroy(&clone->sel_read.si_note);
 314         ACPI_UNLOCK(acpi);
 315         free(clone, M_APMDEV);
 316         destroy_dev_sched(dev);
 317         return (0);
 318 }
 319
 320 static int
 321 apmioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, d_thread_t *td)
 322 {
 323         int     error;
 324         struct  apm_clone_data *clone;
 325         struct  acpi_softc *acpi_sc;
 326         struct  apm_info info;
 327         struct  apm_event_info *ev_info;
 328         apm_info_old_t aiop;
 329
 330         error = 0;
 331         clone = dev->si_drv1;
 332         acpi_sc = clone->acpi_sc;
 333
 334         switch (cmd) {
 335         case APMIO_SUSPEND:
 336                 if ((flag & FWRITE) == 0)
 337                         return (EPERM);
 338                 if (acpi_sc->acpi_next_sstate == 0) {
 339                         if (acpi_sc->acpi_suspend_sx != ACPI_STATE_S5) {
 340                                 error = acpi_ReqSleepState(acpi_sc,
 341                                     acpi_sc->acpi_suspend_sx);
 342                         } else {
 343                                 printf(
 344                         "power off via apm suspend not supported\n");
 345                                 error = ENXIO;
 346                         }
 347                 } else
 348                         error = acpi_AckSleepState(clone, 0);
 349                 break;
 350         case APMIO_STANDBY:
 351                 if ((flag & FWRITE) == 0)
 352                         return (EPERM);
 353                 if (acpi_sc->acpi_next_sstate == 0) {
 354                         if (acpi_sc->acpi_standby_sx != ACPI_STATE_S5) {
 355                                 error = acpi_ReqSleepState(acpi_sc,
 356                                     acpi_sc->acpi_standby_sx);
 357                         } else {
 358                                 printf(
 359                         "power off via apm standby not supported\n");
 360                                 error = ENXIO;
 361                         }
 362                 } else
 363                         error = acpi_AckSleepState(clone, 0);
 364                 break;
 365         case APMIO_NEXTEVENT:
 366                 printf("apm nextevent start\n");
 367                 ACPI_LOCK(acpi);
 368                 if (acpi_sc->acpi_next_sstate != 0 && clone->notify_status ==
 369                     APM_EV_NONE) {
 370                         ev_info = (struct apm_event_info *)addr;
 371                         if (acpi_sc->acpi_next_sstate <= ACPI_STATE_S3)
 372                                 ev_info->type = PMEV_STANDBYREQ;
 373                         else
 374                                 ev_info->type = PMEV_SUSPENDREQ;
 375                         ev_info->index = 0;
 376                         clone->notify_status = APM_EV_NOTIFIED;
 377                         printf("apm event returning %d\n", ev_info->type);
 378                 } else
 379                         error = EAGAIN;
 380                 ACPI_UNLOCK(acpi);
 381                 break;
 382         case APMIO_GETINFO_OLD:
 383                 if (acpi_capm_get_info(&info))
 384                         error = ENXIO;
 385                 aiop = (apm_info_old_t)addr;
 386                 aiop->ai_major = info.ai_major;
 387                 aiop->ai_minor = info.ai_minor;
 388                 aiop->ai_acline = info.ai_acline;
 389                 aiop->ai_batt_stat = info.ai_batt_stat;
 390                 aiop->ai_batt_life = info.ai_batt_life;
 391                 aiop->ai_status = info.ai_status;
 392                 break;
 393         case APMIO_GETINFO:
 394                 if (acpi_capm_get_info((apm_info_t)addr))
 395                         error = ENXIO;
 396                 break;
 397         case APMIO_GETPWSTATUS:
 398                 if (acpi_capm_get_pwstatus((apm_pwstatus_t)addr))
 399                         error = ENXIO;
 400                 break;
 401         case APMIO_ENABLE:
 402                 if ((flag & FWRITE) == 0)
 403                         return (EPERM);
 404                 apm_active = 1;
 405                 break;
 406         case APMIO_DISABLE:
 407                 if ((flag & FWRITE) == 0)
 408                         return (EPERM);
 409                 apm_active = 0;
 410                 break;
 411         case APMIO_HALTCPU:
 412                 break;
 413         case APMIO_NOTHALTCPU:
 414                 break;
 415         case APMIO_DISPLAY:
 416                 if ((flag & FWRITE) == 0)
 417                         return (EPERM);
 418                 break;
 419         case APMIO_BIOS:
 420                 if ((flag & FWRITE) == 0)
 421                         return (EPERM);
 422                 bzero(addr, sizeof(struct apm_bios_arg));
 423                 break;
 424         default:
 425                 error = EINVAL;
 426                 break;
 427         }
 428
 429         return (error);
 430 }
 431
 432 static int
 433 apmwrite(struct cdev *dev, struct uio *uio, int ioflag)
 434 {
 435         return (uio->uio_resid);
 436 }
 437
 438 static int
 439 apmpoll(struct cdev *dev, int events, d_thread_t *td)
 440 {
 441         struct  apm_clone_data *clone;
 442         int revents;
 443
 444         revents = 0;
 445         ACPI_LOCK(acpi);
 446         clone = dev->si_drv1;
 447         if (clone->acpi_sc->acpi_next_sstate)
 448                 revents |= events & (POLLIN | POLLRDNORM);
 449         else
 450                 selrecord(td, &clone->sel_read);
 451         ACPI_UNLOCK(acpi);
 452         return (revents);
 453 }
 454
 455 static int
 456 apmkqfilter(struct cdev *dev, struct knote *kn)
 457 {
 458         struct  apm_clone_data *clone;
 459
 460         ACPI_LOCK(acpi);
 461         clone = dev->si_drv1;
 462         kn->kn_hook = clone;
 463         kn->kn_fop = &apm_readfiltops;
 464         knlist_add(&clone->sel_read.si_note, kn, 0);
 465         ACPI_UNLOCK(acpi);
 466         return (0);
 467 }
 468
 469 static void
 470 apmreadfiltdetach(struct knote *kn)
 471 {
 472         struct  apm_clone_data *clone;
 473
 474         ACPI_LOCK(acpi);
 475         clone = kn->kn_hook;
 476         knlist_remove(&clone->sel_read.si_note, kn, 0);
 477         ACPI_UNLOCK(acpi);
 478 }
 479
 480 static int
 481 apmreadfilt(struct knote *kn, long hint)
 482 {
 483         struct  apm_clone_data *clone;
 484         int     sleeping;
 485
 486         ACPI_LOCK(acpi);
 487         clone = kn->kn_hook;
 488         sleeping = clone->acpi_sc->acpi_next_sstate ? 1 : 0;
 489         ACPI_UNLOCK(acpi);
 490         return (sleeping);
 491 }
 492
 493 int
 494 acpi_machdep_init(device_t dev)
 495 {
 496         struct  acpi_softc *acpi_sc;
 497
 498         acpi_sc = devclass_get_softc(devclass_find("acpi"), 0);
 499
 500         /* Create a clone for /dev/acpi also. */
 501         STAILQ_INIT(&acpi_sc->apm_cdevs);
 502         acpi_sc->acpi_clone = apm_create_clone(acpi_sc->acpi_dev_t, acpi_sc);
 503         clone_setup(&apm_clones);
 504         EVENTHANDLER_REGISTER(dev_clone, apm_clone, 0, 1000);
 505         acpi_install_wakeup_handler(acpi_sc);
 506
 507         if (intr_model == ACPI_INTR_PIC)
 508                 BUS_CONFIG_INTR(dev, AcpiGbl_FADT.SciInterrupt,
 509                     INTR_TRIGGER_LEVEL, INTR_POLARITY_LOW);
 510         else
 511                 acpi_SetIntrModel(intr_model);
 512
 513         SYSCTL_ADD_UINT(&acpi_sc->acpi_sysctl_ctx,
 514             SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO,
 515             "reset_video", CTLFLAG_RW, &acpi_reset_video, 0,
 516             "Call the VESA reset BIOS vector on the resume path");
 517
 518         return (0);
 519 }
 520
 521 void
 522 acpi_SetDefaultIntrModel(int model)
 523 {
 524
 525         intr_model = model;
 526 }
 527
 528 /* Check BIOS date.  If 1998 or older, disable ACPI. */
 529 int
 530 acpi_machdep_quirks(int *quirks)
 531 {
 532         char *va;
 533         int year;
 534
 535         /* BIOS address 0xffff5 contains the date in the format mm/dd/yy. */
 536         va = pmap_mapbios(0xffff0, 16);
 537         sscanf(va + 11, "%2d", &year);
 538         pmap_unmapbios((vm_offset_t)va, 16);
 539
 540         /*
 541          * Date must be >= 1/1/1999 or we don't trust ACPI.  Note that this
 542          * check must be changed by my 114th birthday.
 543          */
 544         if (year > 90 && year < 99)
 545                 *quirks = ACPI_Q_BROKEN;
 546
 547         return (0);
 548 }
 549
 550 void
 551 acpi_cpu_c1()
 552 {
 553         __asm __volatile("sti; hlt");
 554 }
 555
 556 /*
 557  * ACPI nexus(4) driver.
 558  */
 559 static int
 560 nexus_acpi_probe(device_t dev)
 561 {
 562         int error;
 563
 564         error = acpi_identify();
 565         if (error)
 566                 return (error);
 567
 568         return (BUS_PROBE_DEFAULT);
 569 }
 570
 571 static int
 572 nexus_acpi_attach(device_t dev)
 573 {
 574
 575         nexus_init_resources();
 576         bus_generic_probe(dev);
 577         if (BUS_ADD_CHILD(dev, 10, "acpi", 0) == NULL)
 578                 panic("failed to add acpi0 device");
 579
 580         return (bus_generic_attach(dev));
 581 }
 582
 583 static device_method_t nexus_acpi_methods[] = {
 584         /* Device interface */
 585         DEVMETHOD(device_probe,         nexus_acpi_probe),
 586         DEVMETHOD(device_attach,        nexus_acpi_attach),
 587
 588         { 0, 0 }
 589 };
 590
 591 DEFINE_CLASS_1(nexus, nexus_acpi_driver, nexus_acpi_methods, 1, nexus_driver);
 592 static devclass_t nexus_devclass;
 593
 594 DRIVER_MODULE(nexus_acpi, root, nexus_acpi_driver, nexus_devclass, 0, 0);