acpi_ibm.c revision 147196
1/*- 2 * Copyright (c) 2004 Takanori Watanabe 3 * Copyright (c) 2005 Markus Brueffer <markus@FreeBSD.org> 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28#include <sys/cdefs.h> 29__FBSDID("$FreeBSD: head/sys/dev/acpi_support/acpi_ibm.c 147196 2005-06-09 20:17:32Z markus $"); 30 31/* 32 * Driver for extra ACPI-controlled gadgets found on IBM ThinkPad laptops. 33 * Inspired by the ibm-acpi and tpb projects which implement these features 34 * on Linux. 35 * 36 * acpi-ibm: <http://ibm-acpi.sourceforge.net/> 37 * tpb: <http://www.nongnu.org/tpb/> 38 */ 39 40#include "opt_acpi.h" 41#include <sys/param.h> 42#include <sys/kernel.h> 43#include <sys/bus.h> 44#include <machine/cpufunc.h> 45#include "acpi.h" 46#include "acpi_if.h" 47#include <sys/module.h> 48#include <dev/acpica/acpivar.h> 49#include <dev/led/led.h> 50#include <sys/sysctl.h> 51#include <machine/clock.h> 52 53#define _COMPONENT ACPI_OEM 54ACPI_MODULE_NAME("IBM") 55 56/* Internal methods */ 57#define ACPI_IBM_METHOD_EVENTS 1 58#define ACPI_IBM_METHOD_EVENTMASK 2 59#define ACPI_IBM_METHOD_HOTKEY 3 60#define ACPI_IBM_METHOD_BRIGHTNESS 4 61#define ACPI_IBM_METHOD_VOLUME 5 62#define ACPI_IBM_METHOD_MUTE 6 63#define ACPI_IBM_METHOD_THINKLIGHT 7 64#define ACPI_IBM_METHOD_BLUETOOTH 8 65#define ACPI_IBM_METHOD_WLAN 9 66#define ACPI_IBM_METHOD_FANSPEED 10 67#define ACPI_IBM_METHOD_FANSTATUS 11 68#define ACPI_IBM_METHOD_THERMAL 12 69 70/* Hotkeys/Buttons */ 71#define IBM_RTC_HOTKEY1 0x64 72#define IBM_RTC_MASK_HOME (1 << 0) 73#define IBM_RTC_MASK_SEARCH (1 << 1) 74#define IBM_RTC_MASK_MAIL (1 << 2) 75#define IBM_RTC_MASK_WLAN (1 << 5) 76#define IBM_RTC_HOTKEY2 0x65 77#define IBM_RTC_MASK_THINKPAD (1 << 3) 78#define IBM_RTC_MASK_ZOOM (1 << 5) 79#define IBM_RTC_MASK_VIDEO (1 << 6) 80#define IBM_RTC_MASK_HIBERNATE (1 << 7) 81#define IBM_RTC_THINKLIGHT 0x66 82#define IBM_RTC_MASK_THINKLIGHT (1 << 4) 83#define IBM_RTC_SCREENEXPAND 0x67 84#define IBM_RTC_MASK_SCREENEXPAND (1 << 5) 85#define IBM_RTC_BRIGHTNESS 0x6c 86#define IBM_RTC_MASK_BRIGHTNESS (1 << 5) 87#define IBM_RTC_VOLUME 0x6e 88#define IBM_RTC_MASK_VOLUME (1 << 7) 89 90/* Embedded Controller registers */ 91#define IBM_EC_BRIGHTNESS 0x31 92#define IBM_EC_MASK_BRI 0x7 93#define IBM_EC_VOLUME 0x30 94#define IBM_EC_MASK_VOL 0xf 95#define IBM_EC_MASK_MUTE (1 << 6) 96#define IBM_EC_FANSTATUS 0x2F 97#define IBM_EC_MASK_FANSTATUS (1 << 7) 98#define IBM_EC_FANSPEED 0x84 99 100/* CMOS Commands */ 101#define IBM_CMOS_VOLUME_DOWN 0 102#define IBM_CMOS_VOLUME_UP 1 103#define IBM_CMOS_VOLUME_MUTE 2 104#define IBM_CMOS_BRIGHTNESS_UP 4 105#define IBM_CMOS_BRIGHTNESS_DOWN 5 106 107/* ACPI methods */ 108#define IBM_NAME_KEYLIGHT "KBLT" 109#define IBM_NAME_WLAN_BT_GET "GBDC" 110#define IBM_NAME_WLAN_BT_SET "SBDC" 111#define IBM_NAME_MASK_BT (1 << 1) 112#define IBM_NAME_MASK_WLAN (1 << 2) 113#define IBM_NAME_THERMAL_GET "TMP7" 114#define IBM_NAME_THERMAL_UPDT "UPDT" 115 116#define IBM_NAME_EVENTS_STATUS_GET "DHKC" 117#define IBM_NAME_EVENTS_MASK_GET "DHKN" 118#define IBM_NAME_EVENTS_STATUS_SET "MHKC" 119#define IBM_NAME_EVENTS_MASK_SET "MHKM" 120#define IBM_NAME_EVENTS_GET "MHKP" 121#define IBM_NAME_EVENTS_AVAILMASK "MHKA" 122 123#define ABS(x) (((x) < 0)? -(x) : (x)) 124 125struct acpi_ibm_softc { 126 device_t dev; 127 ACPI_HANDLE handle; 128 129 /* Embedded controller */ 130 device_t ec_dev; 131 ACPI_HANDLE ec_handle; 132 133 /* CMOS */ 134 ACPI_HANDLE cmos_handle; 135 136 /* Fan status */ 137 ACPI_HANDLE fan_handle; 138 int fan_levels; 139 140 /* Keylight commands and states */ 141 ACPI_HANDLE light_handle; 142 int light_cmd_on; 143 int light_cmd_off; 144 int light_val; 145 int light_get_supported; 146 int light_set_supported; 147 struct cdev *led_dev; 148 149 int wlan_bt_flags; 150 int thermal_updt_supported; 151 152 unsigned int events_availmask; 153 unsigned int events_initialmask; 154 int events_mask_supported; 155 int events_enable; 156 157 struct sysctl_ctx_list *sysctl_ctx; 158 struct sysctl_oid *sysctl_tree; 159}; 160 161static struct { 162 char *name; 163 int method; 164 char *description; 165 int access; 166} acpi_ibm_sysctls[] = { 167 { 168 .name = "events", 169 .method = ACPI_IBM_METHOD_EVENTS, 170 .description = "ACPI events enable", 171 .access = CTLTYPE_INT | CTLFLAG_RW 172 }, 173 { 174 .name = "eventmask", 175 .method = ACPI_IBM_METHOD_EVENTMASK, 176 .description = "ACPI eventmask", 177 .access = CTLTYPE_INT | CTLFLAG_RW 178 }, 179 { 180 .name = "hotkey", 181 .method = ACPI_IBM_METHOD_HOTKEY, 182 .description = "Key Status", 183 .access = CTLTYPE_INT | CTLFLAG_RD 184 }, 185 { 186 .name = "lcd_brightness", 187 .method = ACPI_IBM_METHOD_BRIGHTNESS, 188 .description = "LCD Brightness", 189 .access = CTLTYPE_INT | CTLFLAG_RW 190 }, 191 { 192 .name = "volume", 193 .method = ACPI_IBM_METHOD_VOLUME, 194 .description = "Volume", 195 .access = CTLTYPE_INT | CTLFLAG_RW 196 }, 197 { 198 .name = "mute", 199 .method = ACPI_IBM_METHOD_MUTE, 200 .description = "Mute", 201 .access = CTLTYPE_INT | CTLFLAG_RW 202 }, 203 { 204 .name = "thinklight", 205 .method = ACPI_IBM_METHOD_THINKLIGHT, 206 .description = "Thinklight enable", 207 .access = CTLTYPE_INT | CTLFLAG_RW 208 }, 209 { 210 .name = "bluetooth", 211 .method = ACPI_IBM_METHOD_BLUETOOTH, 212 .description = "Bluetooth enable", 213 .access = CTLTYPE_INT | CTLFLAG_RW 214 }, 215 { 216 .name = "wlan", 217 .method = ACPI_IBM_METHOD_WLAN, 218 .description = "WLAN enable", 219 .access = CTLTYPE_INT | CTLFLAG_RD 220 }, 221 { 222 .name = "fan_speed", 223 .method = ACPI_IBM_METHOD_FANSPEED, 224 .description = "Fan speed", 225 .access = CTLTYPE_INT | CTLFLAG_RD 226 }, 227 { 228 .name = "fan", 229 .method = ACPI_IBM_METHOD_FANSTATUS, 230 .description = "Fan enable", 231 .access = CTLTYPE_INT | CTLFLAG_RD 232 }, 233 234 { NULL, 0, NULL, 0 } 235}; 236 237ACPI_SERIAL_DECL(ibm, "ACPI IBM extras"); 238 239static int acpi_ibm_probe(device_t dev); 240static int acpi_ibm_attach(device_t dev); 241static int acpi_ibm_detach(device_t dev); 242 243static int acpi_ibm_sysctl(SYSCTL_HANDLER_ARGS); 244static int acpi_ibm_sysctl_init(struct acpi_ibm_softc *sc, int method); 245static int acpi_ibm_sysctl_get(struct acpi_ibm_softc *sc, int method); 246static int acpi_ibm_sysctl_set(struct acpi_ibm_softc *sc, int method, int val); 247 248static int acpi_ibm_eventmask_set(struct acpi_ibm_softc *sc, int val); 249static int acpi_ibm_thermal_sysctl(SYSCTL_HANDLER_ARGS); 250static void acpi_ibm_notify(ACPI_HANDLE h, UINT32 notify, void *context); 251 252static device_method_t acpi_ibm_methods[] = { 253 /* Device interface */ 254 DEVMETHOD(device_probe, acpi_ibm_probe), 255 DEVMETHOD(device_attach, acpi_ibm_attach), 256 DEVMETHOD(device_detach, acpi_ibm_detach), 257 258 {0, 0} 259}; 260 261static driver_t acpi_ibm_driver = { 262 "acpi_ibm", 263 acpi_ibm_methods, 264 sizeof(struct acpi_ibm_softc), 265}; 266 267static devclass_t acpi_ibm_devclass; 268 269DRIVER_MODULE(acpi_ibm, acpi, acpi_ibm_driver, acpi_ibm_devclass, 270 0, 0); 271MODULE_DEPEND(acpi_ibm, acpi, 1, 1, 1); 272static char *ibm_ids[] = {"IBM0068", NULL}; 273 274static void 275ibm_led(void *softc, int onoff) 276{ 277 ACPI_SERIAL_BEGIN(ibm); 278 acpi_ibm_sysctl_set((struct acpi_ibm_softc*)softc, 279 ACPI_IBM_METHOD_THINKLIGHT, onoff); 280 ACPI_SERIAL_END(ibm); 281} 282 283static int 284acpi_ibm_probe(device_t dev) 285{ 286 if (acpi_disabled("ibm") || 287 ACPI_ID_PROBE(device_get_parent(dev), dev, ibm_ids) == NULL || 288 device_get_unit(dev) != 0) 289 return (ENXIO); 290 291 device_set_desc(dev, "IBM ThinkPad ACPI Extras"); 292 293 return (0); 294} 295 296static int 297acpi_ibm_attach(device_t dev) 298{ 299 struct acpi_ibm_softc *sc; 300 struct acpi_softc *acpi_sc; 301 devclass_t ec_devclass; 302 303 ACPI_FUNCTION_TRACE((char *)(uintptr_t) __func__); 304 305 sc = device_get_softc(dev); 306 sc->dev = dev; 307 sc->handle = acpi_get_handle(dev); 308 309 acpi_sc = acpi_device_get_parent_softc(dev); 310 311 /* Look for the first embedded controller */ 312 if (!(ec_devclass = devclass_find ("acpi_ec"))) { 313 if (bootverbose) 314 device_printf(dev, "Couldn't find acpi_ec devclass\n"); 315 return (EINVAL); 316 } 317 if (!(sc->ec_dev = devclass_get_device(ec_devclass, 0))) { 318 if (bootverbose) 319 device_printf(dev, "Couldn't find acpi_ec device\n"); 320 return (EINVAL); 321 } 322 sc->ec_handle = acpi_get_handle(sc->ec_dev); 323 324 ACPI_SERIAL_BEGIN(ibm); 325 326 /* Get the sysctl tree */ 327 sc->sysctl_ctx = device_get_sysctl_ctx(dev); 328 sc->sysctl_tree = device_get_sysctl_tree(dev); 329 330 /* Look for event mask and hook up the nodes */ 331 sc->events_mask_supported = ACPI_SUCCESS(acpi_GetInteger(sc->handle, 332 IBM_NAME_EVENTS_MASK_GET, &sc->events_initialmask)); 333 334 if (sc->events_mask_supported) { 335 SYSCTL_ADD_INT(sc->sysctl_ctx, 336 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 337 "initialmask", CTLFLAG_RD, 338 &sc->events_initialmask, 0, "Initial eventmask"); 339 340 /* The availmask is the bitmask of supported events */ 341 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 342 IBM_NAME_EVENTS_AVAILMASK, &sc->events_availmask))) 343 sc->events_availmask = 0xffffffff; 344 345 SYSCTL_ADD_INT(sc->sysctl_ctx, 346 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 347 "availmask", CTLFLAG_RD, 348 &sc->events_availmask, 0, "Mask of supported events"); 349 } 350 351 /* Hook up proc nodes */ 352 for (int i = 0; acpi_ibm_sysctls[i].name != NULL; i++) { 353 if (!acpi_ibm_sysctl_init(sc, acpi_ibm_sysctls[i].method)) 354 continue; 355 356 SYSCTL_ADD_PROC(sc->sysctl_ctx, 357 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 358 acpi_ibm_sysctls[i].name, acpi_ibm_sysctls[i].access, 359 sc, i, acpi_ibm_sysctl, "I", 360 acpi_ibm_sysctls[i].description); 361 } 362 363 /* Hook up thermal node */ 364 if (acpi_ibm_sysctl_init(sc, ACPI_IBM_METHOD_THERMAL)) { 365 SYSCTL_ADD_PROC(sc->sysctl_ctx, 366 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 367 "thermal", CTLTYPE_STRING | CTLFLAG_RD, 368 sc, 0, acpi_ibm_thermal_sysctl, "I", 369 "Thermal zones"); 370 } 371 372 ACPI_SERIAL_END(ibm); 373 374 /* Handle notifies */ 375 AcpiInstallNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY, 376 acpi_ibm_notify, dev); 377 378 /* Hook up light to led(4) */ 379 sc->led_dev = led_create(ibm_led, sc, "thinklight"); 380 381 return (0); 382} 383 384static int 385acpi_ibm_detach(device_t dev) 386{ 387 ACPI_FUNCTION_TRACE((char *)(uintptr_t) __func__); 388 389 struct acpi_ibm_softc *sc = device_get_softc(dev); 390 391 /* Disable events and restore eventmask */ 392 ACPI_SERIAL_BEGIN(ibm); 393 acpi_ibm_sysctl_set(sc, ACPI_IBM_METHOD_EVENTS, 0); 394 acpi_ibm_sysctl_set(sc, ACPI_IBM_METHOD_EVENTMASK, sc->events_initialmask); 395 ACPI_SERIAL_END(ibm); 396 397 AcpiRemoveNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY, acpi_ibm_notify); 398 399 led_destroy(sc->led_dev); 400 return (0); 401} 402 403static int 404acpi_ibm_eventmask_set(struct acpi_ibm_softc *sc, int val) 405{ 406 ACPI_OBJECT arg[2]; 407 ACPI_OBJECT_LIST args; 408 ACPI_STATUS status; 409 410 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 411 ACPI_SERIAL_ASSERT(ibm); 412 413 args.Count = 2; 414 args.Pointer = arg; 415 arg[0].Type = ACPI_TYPE_INTEGER; 416 arg[1].Type = ACPI_TYPE_INTEGER; 417 418 for (int i = 0; i < 32; ++i) { 419 arg[0].Integer.Value = i+1; 420 arg[1].Integer.Value = (((1 << i) & val) != 0); 421 status = AcpiEvaluateObject(sc->handle, 422 IBM_NAME_EVENTS_MASK_SET, &args, NULL); 423 424 if (ACPI_FAILURE(status)) 425 return (status); 426 } 427 428 return (0); 429} 430 431static int 432acpi_ibm_sysctl(SYSCTL_HANDLER_ARGS) 433{ 434 struct acpi_ibm_softc *sc; 435 int arg; 436 int error = 0; 437 int function; 438 int method; 439 440 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 441 442 sc = (struct acpi_ibm_softc *)oidp->oid_arg1; 443 function = oidp->oid_arg2; 444 method = acpi_ibm_sysctls[function].method; 445 446 ACPI_SERIAL_BEGIN(ibm); 447 arg = acpi_ibm_sysctl_get(sc, method); 448 error = sysctl_handle_int(oidp, &arg, 0, req); 449 450 /* Sanity check */ 451 if (error != 0 || req->newptr == NULL) 452 goto out; 453 454 /* Update */ 455 error = acpi_ibm_sysctl_set(sc, method, arg); 456 457out: 458 ACPI_SERIAL_END(ibm); 459 return (error); 460} 461 462static int 463acpi_ibm_sysctl_get(struct acpi_ibm_softc *sc, int method) 464{ 465 ACPI_INTEGER val_ec; 466 int val = 0, key; 467 468 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 469 ACPI_SERIAL_ASSERT(ibm); 470 471 switch (method) { 472 case ACPI_IBM_METHOD_EVENTS: 473 acpi_GetInteger(sc->handle, IBM_NAME_EVENTS_STATUS_GET, &val); 474 break; 475 476 case ACPI_IBM_METHOD_EVENTMASK: 477 if (sc->events_mask_supported) 478 acpi_GetInteger(sc->handle, IBM_NAME_EVENTS_MASK_GET, &val); 479 break; 480 481 case ACPI_IBM_METHOD_HOTKEY: 482 /* 483 * Construct the hotkey as a bitmask as illustrated below. 484 * Note that whenever a key was pressed, the respecting bit 485 * toggles and nothing else changes. 486 * +--+--+-+-+-+-+-+-+-+-+-+-+ 487 * |11|10|9|8|7|6|5|4|3|2|1|0| 488 * +--+--+-+-+-+-+-+-+-+-+-+-+ 489 * | | | | | | | | | | | | 490 * | | | | | | | | | | | +- Home Button 491 * | | | | | | | | | | +--- Search Button 492 * | | | | | | | | | +----- Mail Button 493 * | | | | | | | | +------- Thinkpad Button 494 * | | | | | | | +--------- Zoom (Fn + Space) 495 * | | | | | | +----------- WLAN Button 496 * | | | | | +------------- Video Button 497 * | | | | +--------------- Hibernate Button 498 * | | | +----------------- Thinklight Button 499 * | | +------------------- Screen expand (Fn + F8) 500 * | +--------------------- Brightness 501 * +------------------------ Volume/Mute 502 */ 503 key = rtcin(IBM_RTC_HOTKEY1); 504 val = (IBM_RTC_MASK_HOME | IBM_RTC_MASK_SEARCH | IBM_RTC_MASK_MAIL | IBM_RTC_MASK_WLAN) & key; 505 key = rtcin(IBM_RTC_HOTKEY2); 506 val |= (IBM_RTC_MASK_THINKPAD | IBM_RTC_MASK_VIDEO | IBM_RTC_MASK_HIBERNATE) & key; 507 val |= (IBM_RTC_MASK_ZOOM & key) >> 1; 508 key = rtcin(IBM_RTC_THINKLIGHT); 509 val |= (IBM_RTC_MASK_THINKLIGHT & key) << 4; 510 key = rtcin(IBM_RTC_SCREENEXPAND); 511 val |= (IBM_RTC_MASK_THINKLIGHT & key) << 4; 512 key = rtcin(IBM_RTC_BRIGHTNESS); 513 val |= (IBM_RTC_MASK_BRIGHTNESS & key) << 5; 514 key = rtcin(IBM_RTC_VOLUME); 515 val |= (IBM_RTC_MASK_VOLUME & key) << 4; 516 break; 517 518 case ACPI_IBM_METHOD_BRIGHTNESS: 519 ACPI_EC_READ(sc->ec_dev, IBM_EC_BRIGHTNESS, &val_ec, 1); 520 val = val_ec & IBM_EC_MASK_BRI; 521 break; 522 523 case ACPI_IBM_METHOD_VOLUME: 524 ACPI_EC_READ(sc->ec_dev, IBM_EC_VOLUME, &val_ec, 1); 525 val = val_ec &IBM_EC_MASK_VOL; 526 break; 527 528 case ACPI_IBM_METHOD_MUTE: 529 ACPI_EC_READ(sc->ec_dev, IBM_EC_VOLUME, &val_ec, 1); 530 val = ((val_ec & IBM_EC_MASK_MUTE) == IBM_EC_MASK_MUTE); 531 break; 532 533 case ACPI_IBM_METHOD_THINKLIGHT: 534 if (sc->light_get_supported) 535 acpi_GetInteger(sc->ec_handle, IBM_NAME_KEYLIGHT, &val); 536 else 537 val = sc->light_val; 538 break; 539 540 case ACPI_IBM_METHOD_BLUETOOTH: 541 acpi_GetInteger(sc->handle, IBM_NAME_WLAN_BT_GET, &val); 542 sc->wlan_bt_flags = val; 543 val = ((val & IBM_NAME_MASK_BT) != 0); 544 break; 545 546 case ACPI_IBM_METHOD_WLAN: 547 acpi_GetInteger(sc->handle, IBM_NAME_WLAN_BT_GET, &val); 548 sc->wlan_bt_flags = val; 549 val = ((val & IBM_NAME_MASK_WLAN) != 0); 550 break; 551 552 case ACPI_IBM_METHOD_FANSPEED: 553 if (sc->fan_handle) { 554 if(ACPI_FAILURE(acpi_GetInteger(sc->fan_handle, NULL, &val))) 555 val = -1; 556 } 557 else { 558 ACPI_EC_READ(sc->ec_dev, IBM_EC_FANSPEED, &val_ec, 2); 559 val = val_ec; 560 } 561 break; 562 563 case ACPI_IBM_METHOD_FANSTATUS: 564 if (!sc->fan_handle) { 565 ACPI_EC_READ(sc->ec_dev, IBM_EC_FANSTATUS, &val_ec, 1); 566 val = (val_ec & IBM_EC_MASK_FANSTATUS) == IBM_EC_MASK_FANSTATUS; 567 } 568 else 569 val = -1; 570 break; 571 } 572 573 return (val); 574} 575 576static int 577acpi_ibm_sysctl_set(struct acpi_ibm_softc *sc, int method, int arg) 578{ 579 int val, step; 580 ACPI_INTEGER val_ec; 581 ACPI_OBJECT Arg; 582 ACPI_OBJECT_LIST Args; 583 ACPI_STATUS status; 584 585 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 586 ACPI_SERIAL_ASSERT(ibm); 587 588 switch (method) { 589 case ACPI_IBM_METHOD_EVENTS: 590 if (arg < 0 || arg > 1) 591 return (EINVAL); 592 593 status = acpi_SetInteger(sc->handle, IBM_NAME_EVENTS_STATUS_SET, arg); 594 if (ACPI_FAILURE(status)) 595 return (status); 596 if (sc->events_mask_supported) 597 return acpi_ibm_eventmask_set(sc, sc->events_availmask); 598 break; 599 600 case ACPI_IBM_METHOD_EVENTMASK: 601 if (sc->events_mask_supported) 602 return acpi_ibm_eventmask_set(sc, arg); 603 break; 604 605 case ACPI_IBM_METHOD_BRIGHTNESS: 606 if (arg < 0 || arg > 7) 607 return (EINVAL); 608 609 if (sc->cmos_handle) { 610 /* Read the current brightness */ 611 status = ACPI_EC_READ(sc->ec_dev, IBM_EC_BRIGHTNESS, &val_ec, 1); 612 if (ACPI_FAILURE(status)) 613 return (status); 614 val = val_ec & IBM_EC_MASK_BRI; 615 616 Args.Count = 1; 617 Args.Pointer = &Arg; 618 Arg.Type = ACPI_TYPE_INTEGER; 619 Arg.Integer.Value = (arg > val) ? IBM_CMOS_BRIGHTNESS_UP : IBM_CMOS_BRIGHTNESS_DOWN; 620 621 step = (arg > val) ? 1 : -1; 622 for (int i = val; i != arg; i += step) { 623 status = AcpiEvaluateObject(sc->cmos_handle, NULL, &Args, NULL); 624 if (ACPI_FAILURE(status)) 625 break; 626 } 627 } 628 return ACPI_EC_WRITE(sc->ec_dev, IBM_EC_BRIGHTNESS, arg, 1); 629 break; 630 631 case ACPI_IBM_METHOD_VOLUME: 632 if (arg < 0 || arg > 14) 633 return (EINVAL); 634 635 if (sc->cmos_handle) { 636 status = ACPI_EC_READ(sc->ec_dev, IBM_EC_VOLUME, &val_ec, 1); 637 if (ACPI_FAILURE(status)) 638 return (status); 639 val = val_ec & IBM_EC_MASK_VOL; 640 641 Args.Count = 1; 642 Args.Pointer = &Arg; 643 Arg.Type = ACPI_TYPE_INTEGER; 644 Arg.Integer.Value = (arg > val) ? IBM_CMOS_VOLUME_UP : IBM_CMOS_VOLUME_DOWN; 645 646 step = (arg > val) ? 1 : -1; 647 for (int i = val; i != arg; i += step) { 648 status = AcpiEvaluateObject(sc->cmos_handle, NULL, &Args, NULL); 649 if (ACPI_FAILURE(status)) 650 break; 651 } 652 } 653 return ACPI_EC_WRITE(sc->ec_dev, IBM_EC_VOLUME, arg + (val_ec & (~IBM_EC_MASK_VOL)), 1); 654 break; 655 656 case ACPI_IBM_METHOD_MUTE: 657 if (arg < 0 || arg > 1) 658 return (EINVAL); 659 660 if (sc->cmos_handle) { 661 status = ACPI_EC_READ(sc->ec_dev, IBM_EC_VOLUME, &val_ec, 1); 662 if (ACPI_FAILURE(status)) 663 return (status); 664 val = val_ec & IBM_EC_MASK_VOL; 665 666 Args.Count = 1; 667 Args.Pointer = &Arg; 668 Arg.Type = ACPI_TYPE_INTEGER; 669 Arg.Integer.Value = IBM_CMOS_VOLUME_MUTE; 670 671 status = AcpiEvaluateObject(sc->cmos_handle, NULL, &Args, NULL); 672 if (ACPI_FAILURE(status)) 673 break; 674 } 675 return ACPI_EC_WRITE(sc->ec_dev, IBM_EC_VOLUME, (arg==1) ? val_ec | IBM_EC_MASK_MUTE : val_ec & (~IBM_EC_MASK_MUTE), 1); 676 break; 677 678 case ACPI_IBM_METHOD_THINKLIGHT: 679 if (arg < 0 || arg > 1) 680 return (EINVAL); 681 682 if (sc->light_set_supported) { 683 Args.Count = 1; 684 Args.Pointer = &Arg; 685 Arg.Type = ACPI_TYPE_INTEGER; 686 Arg.Integer.Value = arg ? sc->light_cmd_on : sc->light_cmd_off; 687 688 status = AcpiEvaluateObject(sc->light_handle, NULL, &Args, NULL); 689 if (ACPI_SUCCESS(status)) 690 sc->light_val = arg; 691 return (status); 692 } 693 break; 694 695 case ACPI_IBM_METHOD_BLUETOOTH: 696 if (arg < 0 || arg > 1) 697 return (EINVAL); 698 699 val = (arg == 1) ? sc->wlan_bt_flags | IBM_NAME_MASK_BT : sc->wlan_bt_flags & (~IBM_NAME_MASK_BT); 700 return acpi_SetInteger(sc->handle, IBM_NAME_WLAN_BT_SET, val); 701 break; 702 } 703 704 return (0); 705} 706 707static int 708acpi_ibm_sysctl_init(struct acpi_ibm_softc *sc, int method) 709{ 710 int dummy; 711 ACPI_OBJECT_TYPE cmos_t; 712 ACPI_HANDLE ledb_handle; 713 714 switch (method) { 715 case ACPI_IBM_METHOD_EVENTS: 716 /* Events are disabled by default */ 717 return (TRUE); 718 719 case ACPI_IBM_METHOD_EVENTMASK: 720 return (sc->events_mask_supported); 721 722 case ACPI_IBM_METHOD_HOTKEY: 723 case ACPI_IBM_METHOD_BRIGHTNESS: 724 case ACPI_IBM_METHOD_VOLUME: 725 case ACPI_IBM_METHOD_MUTE: 726 /* EC is required here, which was aready checked before */ 727 return (TRUE); 728 729 case ACPI_IBM_METHOD_THINKLIGHT: 730 sc->cmos_handle = NULL; 731 sc->light_get_supported = ACPI_SUCCESS(acpi_GetInteger(sc->ec_handle, IBM_NAME_KEYLIGHT, &dummy)); 732 733 if ((ACPI_SUCCESS(AcpiGetHandle(sc->handle, "\\UCMS", &sc->light_handle)) || 734 ACPI_SUCCESS(AcpiGetHandle(sc->handle, "\\CMOS", &sc->light_handle)) || 735 ACPI_SUCCESS(AcpiGetHandle(sc->handle, "\\CMS", &sc->light_handle))) && 736 ACPI_SUCCESS(AcpiGetType(sc->light_handle, &cmos_t)) && 737 cmos_t == ACPI_TYPE_METHOD) { 738 sc->light_cmd_on = 0x0c; 739 sc->light_cmd_off = 0x0d; 740 sc->cmos_handle = sc->light_handle; 741 } 742 else if (ACPI_SUCCESS(AcpiGetHandle(sc->handle, "\\LGHT", &sc->light_handle))) { 743 sc->light_cmd_on = 1; 744 sc->light_cmd_off = 0; 745 } 746 else 747 sc->light_handle = NULL; 748 749 sc->light_set_supported = (sc->light_handle && 750 ACPI_FAILURE(AcpiGetHandle(sc->ec_handle, "LEDB", &ledb_handle))); 751 752 if (sc->light_get_supported || sc->light_set_supported) { 753 sc->light_val = 0; 754 return (TRUE); 755 } 756 else 757 return (FALSE); 758 759 case ACPI_IBM_METHOD_BLUETOOTH: 760 case ACPI_IBM_METHOD_WLAN: 761 if (ACPI_SUCCESS(acpi_GetInteger(sc->handle, IBM_NAME_WLAN_BT_GET, &dummy))) 762 return (TRUE); 763 return (FALSE); 764 765 case ACPI_IBM_METHOD_FANSPEED: 766 /* 767 * Some models report the fan speed in levels from 0-7 768 * Newer models report it contiguously 769 */ 770 sc->fan_levels = 771 (ACPI_SUCCESS(AcpiGetHandle(sc->handle, "GFAN", &sc->fan_handle)) || 772 ACPI_SUCCESS(AcpiGetHandle(sc->handle, "\\FSPD", &sc->fan_handle))); 773 return (TRUE); 774 775 case ACPI_IBM_METHOD_FANSTATUS: 776 /* 777 * Fan status is only supported on those models, 778 * which report fan RPM contiguously, not in levels 779 */ 780 if (sc->fan_levels) 781 return (FALSE); 782 return (TRUE); 783 784 case ACPI_IBM_METHOD_THERMAL: 785 if (ACPI_SUCCESS(acpi_GetInteger(sc->ec_handle, IBM_NAME_THERMAL_GET, &dummy))) { 786 sc->thermal_updt_supported = ACPI_SUCCESS(acpi_GetInteger(sc->ec_handle, IBM_NAME_THERMAL_UPDT, &dummy)); 787 return (TRUE); 788 } 789 return (FALSE); 790 } 791 return (FALSE); 792} 793 794static int 795acpi_ibm_thermal_sysctl(SYSCTL_HANDLER_ARGS) 796{ 797 struct acpi_ibm_softc *sc; 798 int error = 0; 799 char temp_cmd[] = "TMP0"; 800 int temp[8]; 801 802 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 803 804 sc = (struct acpi_ibm_softc *)oidp->oid_arg1; 805 806 ACPI_SERIAL_BEGIN(ibm); 807 808 for (int i = 0; i < 8; ++i) { 809 temp_cmd[3] = '0' + i; 810 811 /* 812 * The TMPx methods seem to return +/- 128 or 0 813 * when the respecting sensor is not available 814 */ 815 if (ACPI_FAILURE(acpi_GetInteger(sc->ec_handle, temp_cmd, 816 &temp[i])) || ABS(temp[i]) == 128 || temp[i] == 0) 817 temp[i] = -1; 818 else if (sc->thermal_updt_supported) 819 /* Temperature is reported in tenth of Kelvin */ 820 temp[i] = (temp[i] - 2732 + 5) / 10; 821 } 822 823 error = sysctl_handle_opaque(oidp, &temp, 8*sizeof(int), req); 824 825 ACPI_SERIAL_END(ibm); 826 return (error); 827} 828 829static void 830acpi_ibm_notify(ACPI_HANDLE h, UINT32 notify, void *context) 831{ 832 int event, arg, type; 833 device_t dev = context; 834 struct acpi_ibm_softc *sc = device_get_softc(dev); 835 836 ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, notify); 837 838 printf("IBM:NOTIFY:%x\n", notify); 839 if (notify != 0x80) 840 printf("Unknown notify\n"); 841 842 for (;;) { 843 acpi_GetInteger(acpi_get_handle(dev), IBM_NAME_EVENTS_GET, &event); 844 845 if (event == 0) 846 break; 847 848 printf("notify:%x\n", event); 849 850 type = (event >> 12) & 0xf; 851 arg = event & 0xfff; 852 switch (type) { 853 case 1: 854 if (!(sc->events_availmask & (1 << (arg - 1)))) { 855 printf("Unknown key %d\n", arg); 856 break; 857 } 858 859 /* Notify devd(8) */ 860 acpi_UserNotify("IBM", h, (arg & 0xff)); 861 break; 862 default: 863 break; 864 } 865 } 866} 867