1 /*- 2 * Copyright (c) 2004 Takanori Watanabe 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 "opt_acpi.h" 31 #include <sys/param.h> 32 #include <sys/kernel.h> 33 #include <sys/bus.h> 34 #include <machine/cpufunc.h> 35 #include "acpi.h" 36 #include "acpi_if.h" 37 #include <sys/module.h> 38 #include <dev/acpica/acpivar.h> 39 #include <sys/sysctl.h> 40 #include <machine/clock.h> 41 42 #define _COMPONENT ACPI_OEM 43 ACPI_MODULE_NAME("IBM") 44 45 #define IBM_RTC_MISCKEY 0x65 46 #define IBM_RTC_BRIGHTNESS 0x6c 47 #define IBM_RTC_MASK_BRI 0x7 48 #define IBM_RTC_MASK_BRKEY 0x40 49 #define IBM_RTC_KEYLIGHT 0x66 50 #define IBM_RTC_MASK_KEYLIGHT 0x10 51 #define IBM_RTC_VOLUME 0x6e 52 #define IBM_RTC_MASK_VOL 0xf 53 #define IBM_RTC_MASK_MUTE 0x40 54 #define IBM_RTC_MASK_VOLKEY 0x80 55 56 #define IBM_NAME_GET_WIRELESS "GBDC" 57 #define IBM_NAME_SET_WIRELESS "SBDC" 58 #define IBM_NAME_INTERFACE_VERSION "MHKV" 59 #define IBM_NAME_AVAIL_MASK "MHKA" 60 #define IBM_NAME_CURRENT_MASK "MHKN" 61 #define IBM_NAME_MODIFY_MASK "MHKM" 62 #define IBM_NAME_GET_EVENT "MHKP" 63 #define IBM_NAME_ENABLE "MHKC" 64 #if 0 65 /* TPX31 Specific? */ 66 #define IBM_UCMS_VOLDN 0x0 67 #define IBM_UCMS_VOLUP 0x1 68 #define IBM_UCMS_MUTE 0x2 69 #define IBM_UCMS_BRIUP 0x4 70 #define IBM_UCMS_BRIDN 0x5 71 #define IBM_UCMS_KEYLIGHT 0xe 72 #endif 73 74 struct acpi_ibm_softc { 75 unsigned int ibm_version; 76 unsigned int ibm_availmask; 77 unsigned int ibm_initialmask; 78 int ibm_enable; 79 int device_flag; 80 #define IBM_MHKN_AVAIL 1 81 #define IBM_MHKM_AVAIL 2 82 struct sysctl_oid *oid_bluetooth; 83 struct sysctl_oid *oid_wlan; 84 }; 85 86 static int acpi_ibm_probe(device_t dev); 87 static int acpi_ibm_attach(device_t dev); 88 static int acpi_ibm_detach(device_t dev); 89 static void 90 acpi_ibm_notify_handler(ACPI_HANDLE h, UINT32 notify, 91 void *context); 92 static int sysctl_acpi_ibm_mask_handler(SYSCTL_HANDLER_ARGS); 93 static int sysctl_acpi_ibm_enable_handler(SYSCTL_HANDLER_ARGS); 94 static int sysctl_acpi_ibm_misckey_handler(SYSCTL_HANDLER_ARGS); 95 static int sysctl_acpi_ibm_volume_handler(SYSCTL_HANDLER_ARGS); 96 static int sysctl_acpi_ibm_mute_handler(SYSCTL_HANDLER_ARGS); 97 static int sysctl_acpi_ibm_brightness_handler(SYSCTL_HANDLER_ARGS); 98 static int sysctl_acpi_ibm_keylight_handler(SYSCTL_HANDLER_ARGS); 99 static int sysctl_acpi_ibm_wireless_handler(SYSCTL_HANDLER_ARGS); 100 static int acpi_ibm_enable_mask(device_t dev, int val); 101 102 static device_method_t acpi_ibm_methods[] = { 103 /* Device interface */ 104 DEVMETHOD(device_probe, acpi_ibm_probe), 105 DEVMETHOD(device_attach, acpi_ibm_attach), 106 DEVMETHOD(device_detach, acpi_ibm_detach), 107 108 {0, 0} 109 }; 110 111 static driver_t acpi_ibm_driver = { 112 "acpi_ibm", 113 acpi_ibm_methods, 114 sizeof(struct acpi_ibm_softc), 115 }; 116 117 static devclass_t acpi_ibm_devclass; 118 119 DRIVER_MODULE(acpi_ibm, acpi, acpi_ibm_driver, acpi_ibm_devclass, 120 0, 0); 121 MODULE_DEPEND(acpi_ibm, acpi, 1, 1, 1); 122 static char *ibm_id[] = {"IBM0068", NULL}; 123 124 static int 125 acpi_ibm_probe(device_t dev) 126 { 127 struct acpi_ibm_softc *sc; 128 int ret = ENXIO; 129 130 sc = device_get_softc(dev); 131 132 if (ACPI_ID_PROBE(device_get_parent(dev), dev, ibm_id)) { 133 device_set_desc(dev, "IBM ThinkPad Button"); 134 ret = 0; 135 } 136 return (ret); 137 } 138 139 static int 140 acpi_ibm_call_two_method(device_t dev, char *name, int val1, int val2) 141 { 142 ACPI_OBJECT arg [2]; 143 ACPI_OBJECT_LIST args = {.Count = 2,.Pointer = arg}; 144 arg[0].Type = ACPI_TYPE_INTEGER; 145 arg[0].Integer.Value = val1; 146 arg[1].Type = ACPI_TYPE_INTEGER; 147 arg[1].Integer.Value = val2; 148 return AcpiEvaluateObject(acpi_get_handle(dev), name, &args, NULL); 149 } 150 151 static int 152 acpi_ibm_attach(device_t dev) 153 { 154 struct acpi_ibm_softc *sc; 155 ACPI_STATUS status; 156 ACPI_HANDLE h; 157 int dummy; 158 struct sysctl_oid *oid; 159 ACPI_FUNCTION_TRACE((char *)(uintptr_t) __func__); 160 161 sc = device_get_softc(dev); 162 sc->device_flag = 0; 163 if (ACPI_FAILURE 164 (acpi_GetInteger(acpi_get_handle(dev), IBM_NAME_INTERFACE_VERSION, &sc->ibm_version))) { 165 sc->ibm_version = 0; 166 } 167 device_printf(dev, "Version %x\n", sc->ibm_version); 168 if (ACPI_FAILURE 169 (acpi_GetInteger(acpi_get_handle(dev), IBM_NAME_AVAIL_MASK, &sc->ibm_availmask))) 170 sc->ibm_availmask = 0xffffffff; 171 172 if (ACPI_FAILURE 173 (acpi_GetInteger(acpi_get_handle(dev), IBM_NAME_CURRENT_MASK, &sc->ibm_initialmask))) 174 sc->ibm_initialmask = 0xffffffff; 175 else 176 sc->device_flag |= IBM_MHKN_AVAIL; 177 178 if (ACPI_SUCCESS(status = AcpiGetHandle(acpi_get_handle(dev), IBM_NAME_MODIFY_MASK, &h))) 179 sc->device_flag |= IBM_MHKM_AVAIL; 180 else 181 printf("%s\n", AcpiFormatException(status)); 182 183 device_printf(dev, "Available Mask %x\n", sc->ibm_availmask); 184 device_printf(dev, "Initial Mask %x\n", sc->ibm_initialmask); 185 /* Install Specific Handler */ 186 status = AcpiInstallNotifyHandler(acpi_get_handle(dev), ACPI_DEVICE_NOTIFY, acpi_ibm_notify_handler, dev); 187 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 188 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 189 OID_AUTO, "key_mask", CTLTYPE_INT | CTLFLAG_RW, 190 dev, 0, 191 sysctl_acpi_ibm_mask_handler, "I", "Hot key mask"); 192 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), 193 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 194 OID_AUTO, "version", CTLFLAG_RD, 195 &sc->ibm_version, 0, "Interface version"); 196 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), 197 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 198 OID_AUTO, "avail_mask", CTLFLAG_RD, 199 &sc->ibm_availmask, 0, "Available Key mask"); 200 if (ACPI_FAILURE(acpi_SetInteger(acpi_get_handle(dev), IBM_NAME_ENABLE, 1))) 201 goto fail; 202 sc->ibm_enable = 1; 203 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 204 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 205 OID_AUTO, "enable", CTLTYPE_INT | CTLFLAG_RW, 206 dev, 0, 207 sysctl_acpi_ibm_enable_handler, "I", "Hot key enable"); 208 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 209 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 210 OID_AUTO, "misckey", CTLTYPE_INT | CTLFLAG_RD, 211 dev, 0, 212 sysctl_acpi_ibm_misckey_handler, "I", "Key Status: Poll me"); 213 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 214 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 215 OID_AUTO, "brightness", CTLTYPE_INT | CTLFLAG_RD, 216 dev, 0, 217 sysctl_acpi_ibm_brightness_handler, "I", "Brightness"); 218 219 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 220 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 221 OID_AUTO, "volume", CTLTYPE_INT | CTLFLAG_RD, 222 dev, 0, 223 sysctl_acpi_ibm_volume_handler, "I", "Volume"); 224 225 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 226 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 227 OID_AUTO, "mute", CTLTYPE_INT | CTLFLAG_RD, 228 dev, 0, 229 sysctl_acpi_ibm_mute_handler, "I", "Muting"); 230 231 232 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 233 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 234 OID_AUTO, "keylight", CTLTYPE_INT | CTLFLAG_RD, 235 dev, 0, 236 sysctl_acpi_ibm_keylight_handler, "I", "Key Light"); 237 if (ACPI_SUCCESS(acpi_GetInteger(acpi_get_handle(dev), IBM_NAME_GET_WIRELESS, &dummy))) { 238 oid = SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 239 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 240 OID_AUTO, "bluetooth", CTLTYPE_INT | CTLFLAG_RW, dev, 0, 241 sysctl_acpi_ibm_wireless_handler, "I", "Bluetooth Enable"); 242 sc->oid_bluetooth = oid; 243 oid = SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 244 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 245 OID_AUTO, "wlan", CTLTYPE_INT | CTLFLAG_RW, dev, 0, 246 sysctl_acpi_ibm_wireless_handler, "I", "WLAN Enable"); 247 sc->oid_wlan = oid; 248 } 249 return_VALUE(0); 250 fail: 251 device_printf(dev, "FAILED\n"); 252 AcpiRemoveNotifyHandler(acpi_get_handle(dev), ACPI_DEVICE_NOTIFY, acpi_ibm_notify_handler); 253 return_VALUE(EINVAL); 254 } 255 256 static int 257 acpi_ibm_detach(device_t dev) 258 { 259 ACPI_FUNCTION_TRACE((char *)(uintptr_t) __func__); 260 261 struct acpi_ibm_softc *sc = device_get_softc(dev); 262 acpi_SetInteger(acpi_get_handle(dev), IBM_NAME_ENABLE, 0); 263 acpi_ibm_enable_mask(dev, sc->ibm_initialmask); 264 265 AcpiRemoveNotifyHandler(acpi_get_handle(dev), ACPI_DEVICE_NOTIFY, acpi_ibm_notify_handler); 266 return_VALUE(0); 267 } 268 #if 0 269 static int 270 acpi_ibm_suspend(device_t dev) 271 { 272 struct acpi_ibm_softc *sc = device_get_softc(dev); 273 return_VALUE(0); 274 } 275 276 static int 277 acpi_ibm_resume(device_t dev) 278 { 279 return (0); 280 } 281 #endif 282 static void 283 acpi_ibm_notify_handler(ACPI_HANDLE h, UINT32 notify, 284 void *context) 285 { 286 int mhkp , arg, type; 287 device_t dev = context; 288 struct acpi_ibm_softc *sc = device_get_softc(dev); 289 290 printf("IBM:NOTIFY:%x\n", notify); 291 if (notify != 0x80) { 292 printf("Unknown notify\n"); 293 } 294 for (;;) { 295 296 acpi_GetInteger(acpi_get_handle(dev), IBM_NAME_GET_EVENT, &mhkp); 297 298 if (mhkp == 0) { 299 break; 300 } 301 printf("notify:%x\n", mhkp); 302 303 type = (mhkp >> 12) & 0xf; 304 arg = mhkp & 0xfff; 305 switch (type) { 306 case 1: 307 if (!(sc->ibm_availmask & (1 << (arg - 1)))) { 308 printf("Unknown key %d\n", arg); 309 break; 310 } 311 acpi_UserNotify("IBM", h, (arg & 0xff)); 312 break; 313 default: 314 break; 315 } 316 } 317 } 318 319 static int 320 acpi_ibm_enable_mask(device_t dev, int val) 321 { 322 int i; 323 struct acpi_ibm_softc *sc = device_get_softc(dev); 324 325 if (!(sc->device_flag | IBM_MHKM_AVAIL)) { 326 return -1; 327 } 328 for (i = 0; i < 32; i++) { 329 acpi_ibm_call_two_method(dev, IBM_NAME_MODIFY_MASK, i + 1, 1); 330 if (!((1 << i) & val)) 331 acpi_ibm_call_two_method(dev, IBM_NAME_MODIFY_MASK, i + 1, 0); 332 } 333 return 0; 334 } 335 336 static int 337 sysctl_acpi_ibm_mask_handler(SYSCTL_HANDLER_ARGS) 338 { 339 device_t dev = arg1; 340 int val = 0xffffffff; 341 int error = 0; 342 343 struct acpi_ibm_softc *sc = device_get_softc(dev); 344 345 if (sc->device_flag & IBM_MHKN_AVAIL) 346 acpi_GetInteger(acpi_get_handle(dev), IBM_NAME_CURRENT_MASK, &val); 347 348 error = sysctl_handle_int(oidp, &val, 0, req); 349 350 if (error || !req->newptr) 351 return error; 352 353 val &= sc->ibm_availmask; 354 val |= sc->ibm_initialmask; 355 356 acpi_ibm_enable_mask(dev, val); 357 358 return 0; 359 } 360 361 static int 362 sysctl_acpi_ibm_misckey_handler(SYSCTL_HANDLER_ARGS) 363 { 364 int val , error; 365 val = rtcin(IBM_RTC_MISCKEY); 366 error = sysctl_handle_int(oidp, &val, 0, req); 367 if (error || !req->newptr) 368 return error; 369 return 0; 370 } 371 372 373 static int 374 sysctl_acpi_ibm_brightness_handler(SYSCTL_HANDLER_ARGS) 375 { 376 int val , error; 377 val = rtcin(IBM_RTC_BRIGHTNESS); 378 val &= IBM_RTC_MASK_BRI; 379 error = sysctl_handle_int(oidp, &val, 0, req); 380 if (error || !req->newptr) 381 return error; 382 return 0; 383 } 384 385 static int 386 sysctl_acpi_ibm_mute_handler(SYSCTL_HANDLER_ARGS) 387 { 388 int val , error; 389 val = rtcin(IBM_RTC_VOLUME); 390 val = ((val & IBM_RTC_MASK_MUTE) == IBM_RTC_MASK_MUTE); 391 392 error = sysctl_handle_int(oidp, &val, 0, req); 393 if (error || !req->newptr) 394 return error; 395 return 0; 396 } 397 398 static int 399 sysctl_acpi_ibm_keylight_handler(SYSCTL_HANDLER_ARGS) 400 { 401 int val , error; 402 val = ((rtcin(IBM_RTC_KEYLIGHT) & IBM_RTC_MASK_KEYLIGHT) 403 == IBM_RTC_MASK_KEYLIGHT); 404 405 error = sysctl_handle_int(oidp, &val, 0, req); 406 if (error || !req->newptr) 407 return error; 408 return 0; 409 } 410 411 static int 412 sysctl_acpi_ibm_volume_handler(SYSCTL_HANDLER_ARGS) 413 { 414 int val , error; 415 val = rtcin(IBM_RTC_VOLUME); 416 val &= IBM_RTC_MASK_VOL; 417 error = sysctl_handle_int(oidp, &val, 0, req); 418 if (error || !req->newptr) 419 return error; 420 return 0; 421 } 422 423 static int 424 sysctl_acpi_ibm_enable_handler(SYSCTL_HANDLER_ARGS) 425 { 426 device_t dev = arg1; 427 struct acpi_ibm_softc *sc = device_get_softc(dev); 428 int error = 0; 429 430 error = sysctl_handle_int(oidp, &sc->ibm_enable, 0, req); 431 432 if (error || !req->newptr) 433 return error; 434 435 if (sc->ibm_enable) 436 sc->ibm_enable = 1; 437 else 438 sc->ibm_enable = 0; 439 acpi_SetInteger(acpi_get_handle(dev), IBM_NAME_ENABLE, sc->ibm_enable); 440 441 return 0; 442 } 443 444 static int 445 sysctl_acpi_ibm_wireless_handler(SYSCTL_HANDLER_ARGS) 446 { 447 device_t dev = arg1; 448 struct acpi_ibm_softc *sc = device_get_softc(dev); 449 int error = 0, val, oldval, mask; 450 if (sc->oid_bluetooth == oidp) { 451 mask = 2; 452 } else if (sc->oid_wlan == oidp) { 453 mask = 4; 454 } else { 455 printf("WARNING: wrong handler invoked\n"); 456 return ENOENT; 457 } 458 459 acpi_GetInteger(acpi_get_handle(dev), IBM_NAME_GET_WIRELESS, &oldval); 460 val = !((oldval & mask) == 0); 461 error = sysctl_handle_int(oidp, &val, 0, req); 462 463 if (error || !req->newptr) 464 return error; 465 oldval &= (~mask); 466 if (val) 467 oldval |= mask; 468 acpi_SetInteger(acpi_get_handle(dev), IBM_NAME_SET_WIRELESS, oldval); 469 return 0; 470 471 472 } 473