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