Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/i386/acpica/acpi_machdep.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
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: releng/8.0/sys/i386/acpica/acpi_machdep.c 196405 2009-08-20 20:23:28Z jhb $"); 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 46 #include <dev/acpica/acpivar.h> 47 #include <dev/acpica/acpiio.h> 48 49 #include <machine/nexusvar.h> 50 51 /* 52 * APM driver emulation 53 */ 54 55 #include <machine/apm_bios.h> 56 #include <machine/pc/bios.h> 57 58 #include <i386/bios/apm.h> 59 60 SYSCTL_DECL(_debug_acpi); 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 knlist_destroy(&clone->sel_read.si_note); 315 ACPI_UNLOCK(acpi); 316 free(clone, M_APMDEV); 317 destroy_dev_sched(dev); 318 return (0); 319 } 320 321 static int 322 apmioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td) 323 { 324 int error; 325 struct apm_clone_data *clone; 326 struct acpi_softc *acpi_sc; 327 struct apm_info info; 328 struct apm_event_info *ev_info; 329 apm_info_old_t aiop; 330 331 error = 0; 332 clone = dev->si_drv1; 333 acpi_sc = clone->acpi_sc; 334 335 switch (cmd) { 336 case APMIO_SUSPEND: 337 if ((flag & FWRITE) == 0) 338 return (EPERM); 339 if (acpi_sc->acpi_next_sstate == 0) { 340 if (acpi_sc->acpi_suspend_sx != ACPI_STATE_S5) { 341 error = acpi_ReqSleepState(acpi_sc, 342 acpi_sc->acpi_suspend_sx); 343 } else { 344 printf( 345 "power off via apm suspend not supported\n"); 346 error = ENXIO; 347 } 348 } else 349 error = acpi_AckSleepState(clone, 0); 350 break; 351 case APMIO_STANDBY: 352 if ((flag & FWRITE) == 0) 353 return (EPERM); 354 if (acpi_sc->acpi_next_sstate == 0) { 355 if (acpi_sc->acpi_standby_sx != ACPI_STATE_S5) { 356 error = acpi_ReqSleepState(acpi_sc, 357 acpi_sc->acpi_standby_sx); 358 } else { 359 printf( 360 "power off via apm standby not supported\n"); 361 error = ENXIO; 362 } 363 } else 364 error = acpi_AckSleepState(clone, 0); 365 break; 366 case APMIO_NEXTEVENT: 367 printf("apm nextevent start\n"); 368 ACPI_LOCK(acpi); 369 if (acpi_sc->acpi_next_sstate != 0 && clone->notify_status == 370 APM_EV_NONE) { 371 ev_info = (struct apm_event_info *)addr; 372 if (acpi_sc->acpi_next_sstate <= ACPI_STATE_S3) 373 ev_info->type = PMEV_STANDBYREQ; 374 else 375 ev_info->type = PMEV_SUSPENDREQ; 376 ev_info->index = 0; 377 clone->notify_status = APM_EV_NOTIFIED; 378 printf("apm event returning %d\n", ev_info->type); 379 } else 380 error = EAGAIN; 381 ACPI_UNLOCK(acpi); 382 break; 383 case APMIO_GETINFO_OLD: 384 if (acpi_capm_get_info(&info)) 385 error = ENXIO; 386 aiop = (apm_info_old_t)addr; 387 aiop->ai_major = info.ai_major; 388 aiop->ai_minor = info.ai_minor; 389 aiop->ai_acline = info.ai_acline; 390 aiop->ai_batt_stat = info.ai_batt_stat; 391 aiop->ai_batt_life = info.ai_batt_life; 392 aiop->ai_status = info.ai_status; 393 break; 394 case APMIO_GETINFO: 395 if (acpi_capm_get_info((apm_info_t)addr)) 396 error = ENXIO; 397 break; 398 case APMIO_GETPWSTATUS: 399 if (acpi_capm_get_pwstatus((apm_pwstatus_t)addr)) 400 error = ENXIO; 401 break; 402 case APMIO_ENABLE: 403 if ((flag & FWRITE) == 0) 404 return (EPERM); 405 apm_active = 1; 406 break; 407 case APMIO_DISABLE: 408 if ((flag & FWRITE) == 0) 409 return (EPERM); 410 apm_active = 0; 411 break; 412 case APMIO_HALTCPU: 413 break; 414 case APMIO_NOTHALTCPU: 415 break; 416 case APMIO_DISPLAY: 417 if ((flag & FWRITE) == 0) 418 return (EPERM); 419 break; 420 case APMIO_BIOS: 421 if ((flag & FWRITE) == 0) 422 return (EPERM); 423 bzero(addr, sizeof(struct apm_bios_arg)); 424 break; 425 default: 426 error = EINVAL; 427 break; 428 } 429 430 return (error); 431 } 432 433 static int 434 apmwrite(struct cdev *dev, struct uio *uio, int ioflag) 435 { 436 return (uio->uio_resid); 437 } 438 439 static int 440 apmpoll(struct cdev *dev, int events, struct thread *td) 441 { 442 struct apm_clone_data *clone; 443 int revents; 444 445 revents = 0; 446 ACPI_LOCK(acpi); 447 clone = dev->si_drv1; 448 if (clone->acpi_sc->acpi_next_sstate) 449 revents |= events & (POLLIN | POLLRDNORM); 450 else 451 selrecord(td, &clone->sel_read); 452 ACPI_UNLOCK(acpi); 453 return (revents); 454 } 455 456 static int 457 apmkqfilter(struct cdev *dev, struct knote *kn) 458 { 459 struct apm_clone_data *clone; 460 461 ACPI_LOCK(acpi); 462 clone = dev->si_drv1; 463 kn->kn_hook = clone; 464 kn->kn_fop = &apm_readfiltops; 465 knlist_add(&clone->sel_read.si_note, kn, 0); 466 ACPI_UNLOCK(acpi); 467 return (0); 468 } 469 470 static void 471 apmreadfiltdetach(struct knote *kn) 472 { 473 struct apm_clone_data *clone; 474 475 ACPI_LOCK(acpi); 476 clone = kn->kn_hook; 477 knlist_remove(&clone->sel_read.si_note, kn, 0); 478 ACPI_UNLOCK(acpi); 479 } 480 481 static int 482 apmreadfilt(struct knote *kn, long hint) 483 { 484 struct apm_clone_data *clone; 485 int sleeping; 486 487 ACPI_LOCK(acpi); 488 clone = kn->kn_hook; 489 sleeping = clone->acpi_sc->acpi_next_sstate ? 1 : 0; 490 ACPI_UNLOCK(acpi); 491 return (sleeping); 492 } 493 494 int 495 acpi_machdep_init(device_t dev) 496 { 497 struct acpi_softc *acpi_sc; 498 499 acpi_sc = devclass_get_softc(devclass_find("acpi"), 0); 500 501 /* Create a clone for /dev/acpi also. */ 502 STAILQ_INIT(&acpi_sc->apm_cdevs); 503 acpi_sc->acpi_clone = apm_create_clone(acpi_sc->acpi_dev_t, acpi_sc); 504 clone_setup(&apm_clones); 505 EVENTHANDLER_REGISTER(dev_clone, apm_clone, 0, 1000); 506 acpi_install_wakeup_handler(acpi_sc); 507 508 if (intr_model == ACPI_INTR_PIC) 509 BUS_CONFIG_INTR(dev, AcpiGbl_FADT.SciInterrupt, 510 INTR_TRIGGER_LEVEL, INTR_POLARITY_LOW); 511 else 512 acpi_SetIntrModel(intr_model); 513 514 SYSCTL_ADD_UINT(&acpi_sc->acpi_sysctl_ctx, 515 SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO, 516 "reset_video", CTLFLAG_RW, &acpi_reset_video, 0, 517 "Call the VESA reset BIOS vector on the resume path"); 518 519 return (0); 520 } 521 522 void 523 acpi_SetDefaultIntrModel(int model) 524 { 525 526 intr_model = model; 527 } 528 529 /* Check BIOS date. If 1998 or older, disable ACPI. */ 530 int 531 acpi_machdep_quirks(int *quirks) 532 { 533 char *va; 534 int year; 535 536 /* BIOS address 0xffff5 contains the date in the format mm/dd/yy. */ 537 va = pmap_mapbios(0xffff0, 16); 538 sscanf(va + 11, "%2d", &year); 539 pmap_unmapbios((vm_offset_t)va, 16); 540 541 /* 542 * Date must be >= 1/1/1999 or we don't trust ACPI. Note that this 543 * check must be changed by my 114th birthday. 544 */ 545 if (year > 90 && year < 99) 546 *quirks = ACPI_Q_BROKEN; 547 548 return (0); 549 } 550 551 void 552 acpi_cpu_c1() 553 { 554 __asm __volatile("sti; hlt"); 555 } 556 557 /* 558 * ACPI nexus(4) driver. 559 */ 560 static int 561 nexus_acpi_probe(device_t dev) 562 { 563 int error; 564 565 error = acpi_identify(); 566 if (error) 567 return (error); 568 569 return (BUS_PROBE_DEFAULT); 570 } 571 572 static int 573 nexus_acpi_attach(device_t dev) 574 { 575 576 nexus_init_resources(); 577 bus_generic_probe(dev); 578 if (BUS_ADD_CHILD(dev, 10, "acpi", 0) == NULL) 579 panic("failed to add acpi0 device"); 580 581 return (bus_generic_attach(dev)); 582 } 583 584 static device_method_t nexus_acpi_methods[] = { 585 /* Device interface */ 586 DEVMETHOD(device_probe, nexus_acpi_probe), 587 DEVMETHOD(device_attach, nexus_acpi_attach), 588 589 { 0, 0 } 590 }; 591 592 DEFINE_CLASS_1(nexus, nexus_acpi_driver, nexus_acpi_methods, 1, nexus_driver); 593 static devclass_t nexus_devclass; 594 595 DRIVER_MODULE(nexus_acpi, root, nexus_acpi_driver, nexus_devclass, 0, 0);
Cache object: 325b5b853ffe1c4e013d4fbf3ecd2f50
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]