sony_acpi.c revision 1.11
1 /* $NetBSD: sony_acpi.c,v 1.11 2009/09/16 10:47:55 mlelstv Exp $ */ 2 3 /*- 4 * Copyright (c) 2005 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Christos Zoulas. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 #include <sys/cdefs.h> 32 __KERNEL_RCSID(0, "$NetBSD: sony_acpi.c,v 1.11 2009/09/16 10:47:55 mlelstv Exp $"); 33 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/device.h> 37 #include <sys/proc.h> 38 #include <sys/kernel.h> 39 #include <sys/callout.h> 40 #include <sys/sysctl.h> 41 42 #include <machine/bus.h> 43 44 #include <dev/acpi/acpica.h> 45 #include <dev/acpi/acpivar.h> 46 #include <dev/acpi/acpireg.h> 47 48 #define _COMPONENT ACPI_RESOURCE_COMPONENT 49 ACPI_MODULE_NAME ("sony_acpi") 50 51 #define SONY_NOTIFY_FnKeyEvent 0x92 52 #define SONY_NOTIFY_BrightnessDownPressed 0x85 53 #define SONY_NOTIFY_BrightnessDownReleased 0x05 54 #define SONY_NOTIFY_BrightnessUpPressed 0x86 55 #define SONY_NOTIFY_BrightnessUpReleased 0x06 56 #define SONY_NOTIFY_DisplaySwitchPressed 0x87 57 #define SONY_NOTIFY_DisplaySwitchReleased 0x07 58 #define SONY_NOTIFY_ZoomPressed 0x8a 59 #define SONY_NOTIFY_ZoomReleased 0x0a 60 #define SONY_NOTIFY_SuspendPressed 0x8c 61 #define SONY_NOTIFY_SuspendReleased 0x0c 62 63 struct sony_acpi_softc { 64 device_t sc_dev; 65 struct sysctllog *sc_log; 66 struct acpi_devnode *sc_node; 67 68 #define SONY_PSW_SLEEP 0 69 #define SONY_PSW_DISPLAY_CYCLE 1 70 #define SONY_PSW_ZOOM 2 71 #define SONY_PSW_LAST 3 72 struct sysmon_pswitch sc_smpsw[SONY_PSW_LAST]; 73 int sc_smpsw_valid; 74 75 #define SONY_ACPI_QUIRK_FNINIT 0x01 76 int sc_quirks; 77 bool sc_has_pic; 78 79 struct sony_acpi_pmstate { 80 ACPI_INTEGER brt; 81 } sc_pmstate; 82 }; 83 84 static const char * const sony_acpi_ids[] = { 85 "SNY5001", 86 NULL 87 }; 88 89 static int sony_acpi_match(device_t, cfdata_t, void *); 90 static void sony_acpi_attach(device_t, device_t, void *); 91 static ACPI_STATUS sony_acpi_eval_set_integer(ACPI_HANDLE, const char *, 92 ACPI_INTEGER, ACPI_INTEGER *); 93 static void sony_acpi_quirk_setup(struct sony_acpi_softc *); 94 static void sony_acpi_notify_handler(ACPI_HANDLE, UINT32, void *); 95 static bool sony_acpi_suspend(device_t PMF_FN_PROTO); 96 static bool sony_acpi_resume(device_t PMF_FN_PROTO); 97 static void sony_acpi_brightness_down(device_t); 98 static void sony_acpi_brightness_up(device_t); 99 static ACPI_STATUS sony_acpi_find_pic(ACPI_HANDLE, UINT32, void *, void **); 100 101 CFATTACH_DECL_NEW(sony_acpi, sizeof(struct sony_acpi_softc), 102 sony_acpi_match, sony_acpi_attach, NULL, NULL); 103 104 static int 105 sony_acpi_match(device_t parent, cfdata_t match, void *aux) 106 { 107 struct acpi_attach_args *aa = aux; 108 109 if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE) 110 return 0; 111 112 return acpi_match_hid(aa->aa_node->ad_devinfo, sony_acpi_ids); 113 } 114 115 static int 116 sony_sysctl_helper(SYSCTLFN_ARGS) 117 { 118 struct sysctlnode node; 119 ACPI_INTEGER acpi_val; 120 ACPI_STATUS rv; 121 int val, old_val, error; 122 char buf[SYSCTL_NAMELEN + 1], *ptr; 123 struct sony_acpi_softc *sc = rnode->sysctl_data; 124 125 (void)snprintf(buf, sizeof(buf), "G%s", rnode->sysctl_name); 126 for (ptr = buf; *ptr; ptr++) 127 *ptr = toupper((unsigned char)*ptr); 128 129 rv = acpi_eval_integer(sc->sc_node->ad_handle, buf, &acpi_val); 130 if (ACPI_FAILURE(rv)) { 131 #ifdef DIAGNOSTIC 132 printf("%s: couldn't get `%s'\n", device_xname(sc->sc_dev), buf); 133 #endif 134 return EIO; 135 } 136 val = old_val = acpi_val; 137 138 node = *rnode; 139 node.sysctl_data = &val; 140 141 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 142 if (error || newp == NULL) 143 return error; 144 145 buf[0] = 'S'; 146 acpi_val = val; 147 rv = sony_acpi_eval_set_integer(sc->sc_node->ad_handle, buf, 148 acpi_val, NULL); 149 if (ACPI_FAILURE(rv)) { 150 #ifdef DIAGNOSTIC 151 printf("%s: couldn't set `%s' to %d\n", 152 device_xname(sc->sc_dev), buf, val); 153 #endif 154 return EIO; 155 } 156 return 0; 157 } 158 159 static ACPI_STATUS 160 sony_walk_cb(ACPI_HANDLE hnd, UINT32 v, void *context, void **status) 161 { 162 struct sony_acpi_softc *sc = (void *)context; 163 const struct sysctlnode *node, *snode; 164 const char *name = acpi_name(hnd); 165 ACPI_INTEGER acpi_val; 166 char buf[SYSCTL_NAMELEN + 1], *ptr; 167 int rv; 168 169 if ((name = strrchr(name, '.')) == NULL) 170 return AE_OK; 171 172 name++; 173 if ((*name != 'G') && (*name != 'S')) 174 return AE_OK; 175 176 (void)strlcpy(buf, name, sizeof(buf)); 177 *buf = 'G'; 178 179 /* 180 * We assume that if the 'get' of the name as an integer is 181 * successful it is ok. 182 */ 183 if (acpi_eval_integer(sc->sc_node->ad_handle, buf, &acpi_val)) 184 return AE_OK; 185 186 for (ptr = buf; *ptr; ptr++) 187 *ptr = tolower(*ptr); 188 189 if ((rv = sysctl_createv(&sc->sc_log, 0, NULL, &node, CTLFLAG_PERMANENT, 190 CTLTYPE_NODE, "hw", NULL, NULL, 0, NULL, 0, CTL_HW, CTL_EOL)) != 0) 191 goto out; 192 193 if ((rv = sysctl_createv(&sc->sc_log, 0, &node, &snode, 0, 194 CTLTYPE_NODE, device_xname(sc->sc_dev), 195 SYSCTL_DESCR("sony controls"), 196 NULL, 0, NULL, 0, CTL_CREATE, CTL_EOL)) != 0) 197 goto out; 198 199 if ((rv = sysctl_createv(&sc->sc_log, 0, &snode, &node, 200 CTLFLAG_READWRITE, CTLTYPE_INT, buf + 1, NULL, 201 sony_sysctl_helper, 0, sc, 0, CTL_CREATE, CTL_EOL)) != 0) 202 goto out; 203 204 out: 205 #ifdef DIAGNOSTIC 206 if (rv) 207 printf("%s: sysctl_createv failed (rv = %d)\n", 208 device_xname(sc->sc_dev), rv); 209 #endif 210 return AE_OK; 211 } 212 213 ACPI_STATUS 214 sony_acpi_eval_set_integer(ACPI_HANDLE handle, const char *path, 215 ACPI_INTEGER val, ACPI_INTEGER *valp) 216 { 217 ACPI_STATUS rv; 218 ACPI_BUFFER buf; 219 ACPI_OBJECT param, ret_val; 220 ACPI_OBJECT_LIST params; 221 222 if (handle == NULL) 223 handle = ACPI_ROOT_OBJECT; 224 225 params.Count = 1; 226 params.Pointer = ¶m; 227 228 param.Type = ACPI_TYPE_INTEGER; 229 param.Integer.Value = val; 230 231 buf.Pointer = &ret_val; 232 buf.Length = sizeof(ret_val); 233 234 rv = AcpiEvaluateObjectTyped(handle, path, ¶ms, &buf, 235 ACPI_TYPE_INTEGER); 236 237 if (ACPI_SUCCESS(rv) && valp) 238 *valp = ret_val.Integer.Value; 239 240 return rv; 241 } 242 243 static void 244 sony_acpi_attach(device_t parent, device_t self, void *aux) 245 { 246 struct sony_acpi_softc *sc = device_private(self); 247 struct acpi_attach_args *aa = aux; 248 ACPI_STATUS rv; 249 int i; 250 251 aprint_naive(": Sony Miscellaneous Controller\n"); 252 aprint_normal(": Sony Miscellaneous Controller\n"); 253 254 sc->sc_node = aa->aa_node; 255 sc->sc_dev = self; 256 257 rv = AcpiWalkNamespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 100, 258 sony_acpi_find_pic, sc, NULL); 259 if (ACPI_FAILURE(rv)) 260 aprint_error_dev(self, "couldn't walk namespace: %s\n", 261 AcpiFormatException(rv)); 262 263 /* 264 * If we don't find an SNY6001 device, assume that we need the 265 * Fn key initialization sequence. 266 */ 267 if (sc->sc_has_pic == false) 268 sc->sc_quirks |= SONY_ACPI_QUIRK_FNINIT; 269 270 sony_acpi_quirk_setup(sc); 271 272 /* Configure suspend button and hotkeys */ 273 sc->sc_smpsw[SONY_PSW_SLEEP].smpsw_name = device_xname(self); 274 sc->sc_smpsw[SONY_PSW_SLEEP].smpsw_type = PSWITCH_TYPE_SLEEP; 275 sc->sc_smpsw[SONY_PSW_DISPLAY_CYCLE].smpsw_name = 276 PSWITCH_HK_DISPLAY_CYCLE; 277 sc->sc_smpsw[SONY_PSW_DISPLAY_CYCLE].smpsw_type = PSWITCH_TYPE_HOTKEY; 278 sc->sc_smpsw[SONY_PSW_ZOOM].smpsw_name = PSWITCH_HK_ZOOM_BUTTON; 279 sc->sc_smpsw[SONY_PSW_ZOOM].smpsw_type = PSWITCH_TYPE_HOTKEY; 280 sc->sc_smpsw_valid = 1; 281 282 for (i = 0; i < SONY_PSW_LAST; i++) 283 if (sysmon_pswitch_register(&sc->sc_smpsw[i]) != 0) { 284 aprint_error_dev(self, 285 "couldn't register %s with sysmon\n", 286 sc->sc_smpsw[i].smpsw_name); 287 sc->sc_smpsw_valid = 0; 288 } 289 290 /* Install notify handler */ 291 rv = AcpiInstallNotifyHandler(sc->sc_node->ad_handle, 292 ACPI_DEVICE_NOTIFY, sony_acpi_notify_handler, self); 293 if (ACPI_FAILURE(rv)) 294 aprint_error_dev(self, 295 "couldn't install notify handler (%d)\n", rv); 296 297 /* Install sysctl handler */ 298 rv = AcpiWalkNamespace(ACPI_TYPE_METHOD, 299 sc->sc_node->ad_handle, 1, sony_walk_cb, sc, NULL); 300 #ifdef DIAGNOSTIC 301 if (ACPI_FAILURE(rv)) 302 aprint_error_dev(self, "Cannot walk ACPI namespace (%d)\n", 303 rv); 304 #endif 305 306 if (!pmf_device_register(self, sony_acpi_suspend, sony_acpi_resume)) 307 aprint_error_dev(self, "couldn't establish power handler\n"); 308 309 if (!pmf_event_register(self, PMFE_DISPLAY_BRIGHTNESS_UP, 310 sony_acpi_brightness_up, true)) 311 aprint_error_dev(self, "couldn't register BRIGHTNESS UP handler\n"); 312 313 if (!pmf_event_register(self, PMFE_DISPLAY_BRIGHTNESS_DOWN, 314 sony_acpi_brightness_down, true)) 315 aprint_error_dev(self, "couldn't register BRIGHTNESS DOWN handler\n"); 316 } 317 318 static void 319 sony_acpi_quirk_setup(struct sony_acpi_softc *sc) 320 { 321 ACPI_HANDLE hdl = sc->sc_node->ad_handle; 322 323 if (sc->sc_quirks & SONY_ACPI_QUIRK_FNINIT) { 324 /* Initialize extra Fn keys */ 325 sony_acpi_eval_set_integer(hdl, "SN02", 0x04, NULL); 326 sony_acpi_eval_set_integer(hdl, "SN07", 0x02, NULL); 327 sony_acpi_eval_set_integer(hdl, "SN02", 0x10, NULL); 328 sony_acpi_eval_set_integer(hdl, "SN07", 0x00, NULL); 329 sony_acpi_eval_set_integer(hdl, "SN03", 0x02, NULL); 330 sony_acpi_eval_set_integer(hdl, "SN07", 0x101, NULL); 331 } 332 } 333 334 static void 335 sony_acpi_notify_handler(ACPI_HANDLE hdl, UINT32 notify, void *opaque) 336 { 337 device_t dv = opaque; 338 struct sony_acpi_softc *sc = device_private(dv); 339 ACPI_STATUS rv; 340 ACPI_INTEGER arg; 341 int s; 342 343 if (notify == SONY_NOTIFY_FnKeyEvent) { 344 rv = sony_acpi_eval_set_integer(hdl, "SN07", 0x202, &arg); 345 if (ACPI_FAILURE(rv)) 346 return; 347 348 notify = arg & 0xff; 349 } 350 351 s = spltty(); 352 switch (notify) { 353 case SONY_NOTIFY_BrightnessDownPressed: 354 sony_acpi_brightness_down(dv); 355 break; 356 case SONY_NOTIFY_BrightnessUpPressed: 357 sony_acpi_brightness_up(dv); 358 break; 359 case SONY_NOTIFY_BrightnessDownReleased: 360 case SONY_NOTIFY_BrightnessUpReleased: 361 break; 362 case SONY_NOTIFY_SuspendPressed: 363 if (!sc->sc_smpsw_valid) 364 break; 365 sysmon_pswitch_event(&sc->sc_smpsw[SONY_PSW_SLEEP], 366 PSWITCH_EVENT_PRESSED); 367 break; 368 case SONY_NOTIFY_SuspendReleased: 369 break; 370 case SONY_NOTIFY_DisplaySwitchPressed: 371 if (!sc->sc_smpsw_valid) 372 break; 373 sysmon_pswitch_event(&sc->sc_smpsw[SONY_PSW_DISPLAY_CYCLE], 374 PSWITCH_EVENT_PRESSED); 375 break; 376 case SONY_NOTIFY_DisplaySwitchReleased: 377 break; 378 case SONY_NOTIFY_ZoomPressed: 379 if (!sc->sc_smpsw_valid) 380 break; 381 sysmon_pswitch_event(&sc->sc_smpsw[SONY_PSW_ZOOM], 382 PSWITCH_EVENT_PRESSED); 383 break; 384 case SONY_NOTIFY_ZoomReleased: 385 break; 386 default: 387 aprint_debug_dev(dv, "unknown notify event 0x%x\n", 388 notify); 389 break; 390 } 391 splx(s); 392 } 393 394 static bool 395 sony_acpi_suspend(device_t dv PMF_FN_ARGS) 396 { 397 struct sony_acpi_softc *sc = device_private(dv); 398 399 acpi_eval_integer(sc->sc_node->ad_handle, "GBRT", &sc->sc_pmstate.brt); 400 401 return true; 402 } 403 404 static bool 405 sony_acpi_resume(device_t dv PMF_FN_ARGS) 406 { 407 struct sony_acpi_softc *sc = device_private(dv); 408 409 sony_acpi_eval_set_integer(sc->sc_node->ad_handle, "SBRT", 410 sc->sc_pmstate.brt, NULL); 411 sony_acpi_quirk_setup(sc); 412 413 return true; 414 } 415 416 static void 417 sony_acpi_brightness_up(device_t dv) 418 { 419 struct sony_acpi_softc *sc = device_private(dv); 420 ACPI_INTEGER arg; 421 ACPI_STATUS rv; 422 423 rv = acpi_eval_integer(sc->sc_node->ad_handle, "GBRT", &arg); 424 if (ACPI_FAILURE(rv)) 425 return; 426 if (arg >= 8) 427 arg = 8; 428 else 429 arg++; 430 sony_acpi_eval_set_integer(sc->sc_node->ad_handle, "SBRT", arg, NULL); 431 } 432 433 static void 434 sony_acpi_brightness_down(device_t dv) 435 { 436 struct sony_acpi_softc *sc = device_private(dv); 437 ACPI_INTEGER arg; 438 ACPI_STATUS rv; 439 440 rv = acpi_eval_integer(sc->sc_node->ad_handle, "GBRT", &arg); 441 if (ACPI_FAILURE(rv)) 442 return; 443 if (arg <= 0) 444 arg = 0; 445 else 446 arg--; 447 sony_acpi_eval_set_integer(sc->sc_node->ad_handle, "SBRT", arg, NULL); 448 } 449 450 static ACPI_STATUS 451 sony_acpi_find_pic(ACPI_HANDLE hdl, UINT32 level, void *opaque, void **status) 452 { 453 struct sony_acpi_softc *sc = opaque; 454 ACPI_STATUS rv; 455 ACPI_DEVICE_INFO *devinfo; 456 457 rv = AcpiGetObjectInfo(hdl, &devinfo); 458 if (ACPI_FAILURE(rv) || devinfo == NULL) 459 return AE_OK; /* we don't want to stop searching */ 460 461 if (devinfo->HardwareId.String && 462 strncmp(devinfo->HardwareId.String, "SNY6001", 7) == 0) 463 sc->sc_has_pic = true; 464 465 ACPI_FREE(devinfo); 466 467 return AE_OK; 468 } 469
Indexes created Thu Oct 02 07:10:07 GMT 2025