1/* $NetBSD: wmi_eeepc.c,v 1.4 2015/04/23 23:23:00 pgoyette Exp $ */
2
3/*-
4 * Copyright (c) 2011 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Jukka Ruohonen.
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 *
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33#include <sys/cdefs.h>
34__KERNEL_RCSID(0, "$NetBSD: wmi_eeepc.c,v 1.4 2015/04/23 23:23:00 pgoyette Exp $");
35
36#include <sys/param.h>
37#include <sys/device.h>
38#include <sys/module.h>
39
40#include <dev/acpi/acpireg.h>
41#include <dev/acpi/acpivar.h>
42#include <dev/acpi/wmi/wmi_acpivar.h>
43
44#include <dev/sysmon/sysmonvar.h>
45
46#define _COMPONENT ACPI_RESOURCE_COMPONENT
47ACPI_MODULE_NAME ("wmi_eeepc")
48
49
50/*
51 * Current brightness is reported by events in the range of 0x10 to 0x2f.
52 * The low nibble containing a value from 0x0 to 0xA proportionate to
53 * brightness, 0x0 indicates minimum illumination, not backlight off.
54 */
55#define WMI_EEEPC_HK_BACKLIGHT_STATUS_BRIGHTNESS_MASK 0x0f /* 0x0 to 0xA */
56#define WMI_EEEPC_HK_BACKLIGHT_STATUS_DIRECTION_MASK (~WMI_EEEPC_HK_BACKLIGHT_STATUS_BRIGHTNESS_MASK)
57#define WMI_EEEPC_HK_BACKLIGHT_STATUS_DIRECTION_INC 0x10
58#define WMI_EEEPC_HK_BACKLIGHT_STATUS_DIRECTION_DEC 0x20
59
60#define WMI_EEEPC_HK_VOLUME_UP 0x30
61#define WMI_EEEPC_HK_VOLUME_DOWN 0x31
62#define WMI_EEEPC_HK_VOLUME_MUTE 0x32
63#define WMI_EEEPC_HK_EXPRESSGATE 0x5C /* Also, "SuperHybrid" */
64#define WMI_EEEPC_HK_TOUCHPAD 0x6B
65#define WMI_EEEPC_HK_WIRELESS 0x88
66#define WMI_EEEPC_HK_WEBCAM 0xBD
67#define WMI_EEEPC_HK_DISPLAY_CYCLE 0xCC
68#define WMI_EEEPC_HK_DISPLAY_SAVER 0xE8
69#define WMI_EEEPC_HK_DISPLAY_OFF 0xE9
70 /* Unlabeled keys on 1215T */
71#define WMI_EEEPC_HK_UNKNOWN_xEC 0xEC /* Fn+E */
72#define WMI_EEEPC_HK_UNKNOWN_xED 0xED /* Fn+D */
73#define WMI_EEEPC_HK_UNKNOWN_xEE 0xEE /* Fn+S */
74#define WMI_EEEPC_HK_UNKNOWN_xEF 0xEF /* Fn+F */
75
76#define WMI_EEEPC_IS_BACKLIGHT_STATUS(x) (((x & WMI_EEEPC_HK_BACKLIGHT_STATUS_DIRECTION_MASK) == WMI_EEEPC_HK_BACKLIGHT_STATUS_DIRECTION_INC) || ((x & WMI_EEEPC_HK_BACKLIGHT_STATUS_DIRECTION_MASK) == WMI_EEEPC_HK_BACKLIGHT_STATUS_DIRECTION_DEC))
77
78enum eeepc_smpsw {
79 WMI_EEEPC_PSW_EXPRESSGATE = 0,
80 WMI_EEEPC_PSW_TOUCHPAD,
81 WMI_EEEPC_PSW_WIRELESS,
82 WMI_EEEPC_PSW_WEBCAM,
83 WMI_EEEPC_PSW_DISPLAY_CYCLE,
84 WMI_EEEPC_PSW_DISPLAY_SAVER,
85 WMI_EEEPC_PSW_DISPLAY_OFF,
86 WMI_EEEPC_PSW_UNKNOWN_xEC,
87 WMI_EEEPC_PSW_UNKNOWN_xED,
88 WMI_EEEPC_PSW_UNKNOWN_xEE,
89 WMI_EEEPC_PSW_UNKNOWN_xEF,
90 WMI_EEEPC_PSW_COUNT /* Must be last. */
91};
92
93#define WMI_EEEPC_GUID_EVENT "ABBC0F72-8EA1-11D1-00A0-C90629100000"
94
95struct wmi_eeepc_softc {
96 device_t sc_dev;
97 device_t sc_parent;
98 struct sysmon_pswitch sc_psw[WMI_EEEPC_PSW_COUNT];
99 bool sc_psw_valid[WMI_EEEPC_PSW_COUNT];
100};
101
102static int wmi_eeepc_match(device_t, cfdata_t, void *);
103static void wmi_eeepc_attach(device_t, device_t, void *);
104static int wmi_eeepc_detach(device_t, int);
105static void wmi_eeepc_notify_handler(ACPI_HANDLE, uint32_t, void *);
106static bool wmi_eeepc_suspend(device_t, const pmf_qual_t *);
107static bool wmi_eeepc_resume(device_t, const pmf_qual_t *);
108
109CFATTACH_DECL_NEW(wmieeepc, sizeof(struct wmi_eeepc_softc),
110 wmi_eeepc_match, wmi_eeepc_attach, wmi_eeepc_detach, NULL);
111
112static int
113wmi_eeepc_match(device_t parent, cfdata_t match, void *aux)
114{
115 return acpi_wmi_guid_match(parent, WMI_EEEPC_GUID_EVENT);
116}
117
118static void
119wmi_eeepc_attach(device_t parent, device_t self, void *aux)
120{
121 struct wmi_eeepc_softc *sc = device_private(self);
122 ACPI_STATUS rv;
123
124 sc->sc_dev = self;
125 sc->sc_parent = parent;
126
127 rv = acpi_wmi_event_register(parent, wmi_eeepc_notify_handler);
128
129 if (ACPI_FAILURE(rv)) {
130 aprint_error(": failed to install WMI notify handler\n");
131 return;
132 }
133
134 aprint_naive("\n");
135 aprint_normal(": Asus Eee PC WMI mappings\n");
136
137 memset(sc->sc_psw, 0, sizeof(sc->sc_psw));
138 sc->sc_psw[WMI_EEEPC_PSW_EXPRESSGATE].smpsw_name = "expressgate";
139 sc->sc_psw[WMI_EEEPC_PSW_TOUCHPAD].smpsw_name = "touchpad-toggle";
140 sc->sc_psw[WMI_EEEPC_PSW_WIRELESS].smpsw_name = "wireless-toggle";
141 sc->sc_psw[WMI_EEEPC_PSW_WEBCAM].smpsw_name = "camera-button";
142 sc->sc_psw[WMI_EEEPC_PSW_DISPLAY_CYCLE].smpsw_name = PSWITCH_HK_DISPLAY_CYCLE;
143 sc->sc_psw[WMI_EEEPC_PSW_DISPLAY_SAVER].smpsw_name = PSWITCH_HK_LOCK_SCREEN;
144 sc->sc_psw[WMI_EEEPC_PSW_DISPLAY_OFF].smpsw_name = "display-off";
145 sc->sc_psw[WMI_EEEPC_PSW_UNKNOWN_xEC].smpsw_name = "unlabeled-xEC";
146 sc->sc_psw[WMI_EEEPC_PSW_UNKNOWN_xED].smpsw_name = "unlabeled-xED";
147 sc->sc_psw[WMI_EEEPC_PSW_UNKNOWN_xEE].smpsw_name = "unlabeled-xEE";
148 sc->sc_psw[WMI_EEEPC_PSW_UNKNOWN_xEF].smpsw_name = "unlabeled-xEF";
149
150 for (int i = 0; i < WMI_EEEPC_PSW_COUNT; i++) {
151 KASSERT(sc->sc_psw[i].smpsw_name != NULL);
152 sc->sc_psw[i].smpsw_type = PSWITCH_TYPE_HOTKEY;
153 if (sysmon_pswitch_register(&sc->sc_psw[i]) == 0) {
154 sc->sc_psw_valid[i] = true;
155 } else {
156 sc->sc_psw_valid[i] = false;
157 aprint_error_dev(self,
158 "hotkey[%d] registration failed\n", i);
159 }
160 }
161
162 (void)pmf_device_register(self, wmi_eeepc_suspend, wmi_eeepc_resume);
163}
164
165static int
166wmi_eeepc_detach(device_t self, int flags)
167{
168 struct wmi_eeepc_softc *sc = device_private(self);
169 device_t parent = sc->sc_parent;
170
171
172 for (int i = 0; i < WMI_EEEPC_PSW_COUNT; i++) {
173 if (sc->sc_psw_valid[i] == true) {
174 sysmon_pswitch_unregister(&sc->sc_psw[i]);
175 sc->sc_psw_valid[i] = false;
176 }
177 }
178
179 (void)pmf_device_deregister(self);
180 (void)acpi_wmi_event_deregister(parent);
181
182 return 0;
183}
184
185static bool
186wmi_eeepc_suspend(device_t self, const pmf_qual_t *qual)
187{
188 struct wmi_eeepc_softc *sc = device_private(self);
189 device_t parent = sc->sc_parent;
190
191 (void)acpi_wmi_event_deregister(parent);
192
193 return true;
194}
195
196static bool
197wmi_eeepc_resume(device_t self, const pmf_qual_t *qual)
198{
199 struct wmi_eeepc_softc *sc = device_private(self);
200 device_t parent = sc->sc_parent;
201
202 (void)acpi_wmi_event_register(parent, wmi_eeepc_notify_handler);
203
204 return true;
205}
206
207static void
208wmi_eeepc_pswitch_event(struct wmi_eeepc_softc *sc, enum eeepc_smpsw key)
209{
210 if (sc->sc_psw_valid[key] != true) {
211 device_printf(sc->sc_dev, "hotkey[%d] not registered\n", key);
212 return;
213 }
214
215 /*
216 * This function is called upon key release,
217 * but the default powerd scripts expect presses.
218 *
219 * Anyway, we may as well send the make and the break event.
220 */
221
222 sysmon_pswitch_event(&sc->sc_psw[key], PSWITCH_EVENT_PRESSED);
223 sysmon_pswitch_event(&sc->sc_psw[key], PSWITCH_EVENT_RELEASED);
224}
225
226static void
227wmi_eeepc_notify_handler(ACPI_HANDLE hdl, uint32_t evt, void *aux)
228{
229 struct wmi_eeepc_softc *sc;
230 device_t self = aux;
231 ACPI_OBJECT *obj;
232 ACPI_BUFFER buf;
233 ACPI_STATUS rv;
234 uint32_t val = 0; /* XXX GCC */
235
236 buf.Pointer = NULL;
237
238 sc = device_private(self);
239 rv = acpi_wmi_event_get(sc->sc_parent, evt, &buf);
240
241 if (ACPI_FAILURE(rv))
242 goto out;
243
244 obj = buf.Pointer;
245
246 if (obj->Type != ACPI_TYPE_INTEGER) {
247 rv = AE_TYPE;
248 goto out;
249 }
250
251 if (obj->Integer.Value > UINT32_MAX) {
252 rv = AE_LIMIT;
253 goto out;
254 }
255
256 val = obj->Integer.Value;
257
258 if (WMI_EEEPC_IS_BACKLIGHT_STATUS(val)) {
259 /* We'll silently ignore these for now. */
260 goto out;
261 }
262
263 switch (val) {
264
265 case WMI_EEEPC_HK_VOLUME_UP:
266 pmf_event_inject(NULL, PMFE_AUDIO_VOLUME_UP);
267 break;
268
269 case WMI_EEEPC_HK_VOLUME_DOWN:
270 pmf_event_inject(NULL, PMFE_AUDIO_VOLUME_DOWN);
271 break;
272
273 case WMI_EEEPC_HK_VOLUME_MUTE:
274 pmf_event_inject(NULL, PMFE_AUDIO_VOLUME_TOGGLE);
275 break;
276
277 case WMI_EEEPC_HK_EXPRESSGATE:
278 wmi_eeepc_pswitch_event(sc, WMI_EEEPC_PSW_EXPRESSGATE);
279 break;
280
281 case WMI_EEEPC_HK_TOUCHPAD:
282 wmi_eeepc_pswitch_event(sc, WMI_EEEPC_PSW_TOUCHPAD);
283 break;
284
285 case WMI_EEEPC_HK_WIRELESS:
286 wmi_eeepc_pswitch_event(sc, WMI_EEEPC_PSW_WIRELESS);
287 break;
288
289 case WMI_EEEPC_HK_WEBCAM:
290 wmi_eeepc_pswitch_event(sc, WMI_EEEPC_PSW_WEBCAM);
291 break;
292
293 case WMI_EEEPC_HK_DISPLAY_CYCLE:
294 wmi_eeepc_pswitch_event(sc, WMI_EEEPC_PSW_DISPLAY_CYCLE);
295 break;
296
297 case WMI_EEEPC_HK_DISPLAY_SAVER:
298 wmi_eeepc_pswitch_event(sc, WMI_EEEPC_PSW_DISPLAY_SAVER);
299 break;
300
301 case WMI_EEEPC_HK_DISPLAY_OFF:
302 wmi_eeepc_pswitch_event(sc, WMI_EEEPC_PSW_DISPLAY_OFF);
303 break;
304
305 case WMI_EEEPC_HK_UNKNOWN_xEC:
306 wmi_eeepc_pswitch_event(sc, WMI_EEEPC_PSW_UNKNOWN_xEC);
307 break;
308
309 case WMI_EEEPC_HK_UNKNOWN_xED:
310 wmi_eeepc_pswitch_event(sc, WMI_EEEPC_PSW_UNKNOWN_xED);
311 break;
312
313 case WMI_EEEPC_HK_UNKNOWN_xEE:
314 wmi_eeepc_pswitch_event(sc, WMI_EEEPC_PSW_UNKNOWN_xEE);
315 break;
316
317 case WMI_EEEPC_HK_UNKNOWN_xEF:
318 wmi_eeepc_pswitch_event(sc, WMI_EEEPC_PSW_UNKNOWN_xEF);
319 break;
320
321 default:
322 device_printf(self, "unknown key 0x%02X for event 0x%02X\n",
323 val, evt);
324 break;
325 }
326
327out:
328 if (buf.Pointer != NULL)
329 ACPI_FREE(buf.Pointer);
330
331 if (ACPI_FAILURE(rv))
332 device_printf(self, "failed to get data for "
333 "event 0x%02X: %s\n", evt, AcpiFormatException(rv));
334}
335
336MODULE(MODULE_CLASS_DRIVER, wmieeepc, "acpiwmi,sysmon_power");
337
338#ifdef _MODULE
339#include "ioconf.c"
340#endif
341
342static int
343wmieeepc_modcmd(modcmd_t cmd, void *aux)
344{
345 int rv = 0;
346
347 switch (cmd) {
348
349 case MODULE_CMD_INIT:
350
351#ifdef _MODULE
352 rv = config_init_component(cfdriver_ioconf_wmieeepc,
353 cfattach_ioconf_wmieeepc, cfdata_ioconf_wmieeepc);
354#endif
355 break;
356
357 case MODULE_CMD_FINI:
358
359#ifdef _MODULE
360 rv = config_fini_component(cfdriver_ioconf_wmieeepc,
361 cfattach_ioconf_wmieeepc, cfdata_ioconf_wmieeepc);
362#endif
363 break;
364
365 default:
366 rv = ENOTTY;
367 }
368
369 return rv;
370}
371