dalb_acpi.c revision 1.11 1 /* $NetBSD: dalb_acpi.c,v 1.11 2010/04/09 15:45:59 jruoho Exp $ */
2
3 /*-
4 * Copyright (c) 2008 Christoph Egger <cegger (at) netbsd.org>
5 * Copyright (c) 2008 Jared D. McNeill <jmcneill (at) netbsd.org>
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 */
29 #include <sys/cdefs.h>
30 __KERNEL_RCSID(0, "$NetBSD: dalb_acpi.c,v 1.11 2010/04/09 15:45:59 jruoho Exp $");
31
32 /*
33 * Direct Application Launch Button:
34 * http://www.microsoft.com/whdc/system/vista/DirAppLaunch.mspx
35 */
36
37 #include <sys/param.h>
38 #include <sys/device.h>
39 #include <sys/systm.h>
40
41 #include <dev/acpi/acpireg.h>
42 #include <dev/acpi/acpivar.h>
43
44 #define _COMPONENT ACPI_RESOURCE_COMPONENT
45 ACPI_MODULE_NAME ("dalb_acpi")
46
47 #define DALB_ID_INVALID -1
48
49 struct acpi_dalb_softc {
50 device_t sc_dev;
51 struct acpi_devnode *sc_node;
52
53 ACPI_INTEGER sc_usageid;
54
55 /* There's one PNP0C32 ACPI device for each button.
56 * Therefore, one instance is enough. */
57 struct sysmon_pswitch sc_smpsw;
58 bool sc_smpsw_valid;
59 };
60
61 static int acpi_dalb_match(device_t, cfdata_t, void *);
62 static void acpi_dalb_attach(device_t, device_t, void *);
63 static int acpi_dalb_detach(device_t, int);
64 static void acpi_dalb_notify_handler(ACPI_HANDLE, UINT32, void *);
65 static bool acpi_dalb_resume(device_t, const pmf_qual_t *);
66
67 static void acpi_dalb_get_wakeup_hotkeys(void *opaque);
68 static void acpi_dalb_get_runtime_hotkeys(void *opaque);
69
70 CFATTACH_DECL_NEW(acpidalb, sizeof(struct acpi_dalb_softc),
71 acpi_dalb_match, acpi_dalb_attach, acpi_dalb_detach, NULL);
72
73 static const char * const acpi_dalb_ids[] = {
74 "PNP0C32", /* Direct Application Launch Button */
75 NULL
76 };
77
78 #define DALB_SYSTEM_WAKEUP 0x02
79 #define DALB_SYSTEM_RUNTIME 0x80
80
81 static int
82 acpi_dalb_match(device_t parent, cfdata_t match, void *aux)
83 {
84 struct acpi_attach_args *aa = aux;
85
86 if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE)
87 return 0;
88
89 return acpi_match_hid(aa->aa_node->ad_devinfo, acpi_dalb_ids);
90 }
91
92 static void
93 acpi_dalb_sysmon_init(struct acpi_dalb_softc *sc)
94 {
95 sc->sc_smpsw_valid = true;
96 sc->sc_smpsw.smpsw_name = device_xname(sc->sc_dev);
97 sc->sc_smpsw.smpsw_type = PSWITCH_TYPE_HOTKEY;
98 if (sysmon_pswitch_register(&sc->sc_smpsw)) {
99 aprint_error_dev(sc->sc_dev,
100 "couldn't register sleep with sysmon\n");
101 sc->sc_smpsw_valid = false;
102 }
103 }
104
105
106 static void
107 acpi_dalb_init(device_t dev)
108 {
109 struct acpi_dalb_softc *sc = device_private(dev);
110 ACPI_OBJECT *obj;
111 ACPI_STATUS rv;
112 ACPI_BUFFER ret;
113
114 rv = acpi_eval_struct(sc->sc_node->ad_handle, "GHID", &ret);
115 if (ACPI_FAILURE(rv) || ret.Pointer == NULL) {
116 aprint_error_dev(dev,
117 "couldn't enable notify handler: (%s)\n",
118 AcpiFormatException(rv));
119 return;
120 }
121
122 obj = (ACPI_OBJECT *)ret.Pointer;
123 if (obj->Type != ACPI_TYPE_BUFFER) {
124 sc->sc_usageid = DALB_ID_INVALID;
125 aprint_debug_dev(dev, "invalid ACPI type: %u\n", obj->Type);
126 goto out;
127 }
128
129 switch (obj->Buffer.Length) {
130 case 1:
131 sc->sc_usageid = *(uint8_t *)obj->Buffer.Pointer;
132 break;
133 case 2:
134 sc->sc_usageid = le16toh(*(uint16_t *)obj->Buffer.Pointer);
135 break;
136 case 4:
137 sc->sc_usageid = le32toh(*(uint32_t *)obj->Buffer.Pointer);
138 break;
139 default:
140 aprint_debug_dev(dev, "unhandled ret.Length: 0x%lx\n",
141 (unsigned long)obj->Buffer.Length);
142 sc->sc_usageid = DALB_ID_INVALID;
143 break;
144 }
145
146 out:
147 ACPI_FREE(ret.Pointer);
148 }
149
150 static void
151 acpi_dalb_attach(device_t parent, device_t self, void *aux)
152 {
153 struct acpi_dalb_softc *sc = device_private(self);
154 struct acpi_attach_args *aa = aux;
155 ACPI_STATUS rv;
156
157 aprint_naive("\n");
158 aprint_normal(": Direct Application Launch Button\n");
159
160 sc->sc_node = aa->aa_node;
161 sc->sc_dev = self;
162
163 config_interrupts(self, acpi_dalb_init);
164
165 /* Install notify handler */
166 rv = AcpiInstallNotifyHandler(sc->sc_node->ad_handle,
167 ACPI_ALL_NOTIFY, acpi_dalb_notify_handler, self);
168 if (ACPI_FAILURE(rv))
169 aprint_error_dev(self,
170 "couldn't install notify handler: (%s)\n",
171 AcpiFormatException(rv));
172
173 sc->sc_smpsw_valid = false;
174 acpi_dalb_sysmon_init(sc);
175
176 if (!pmf_device_register(self, NULL, acpi_dalb_resume))
177 aprint_error_dev(self, "couldn't establish power handler\n");
178 }
179
180 static int
181 acpi_dalb_detach(device_t self, int flags)
182 {
183 struct acpi_dalb_softc *sc = device_private(self);
184 ACPI_STATUS rv;
185
186 rv = AcpiRemoveNotifyHandler(sc->sc_node->ad_handle,
187 ACPI_ALL_NOTIFY, acpi_dalb_notify_handler);
188
189 if (ACPI_FAILURE(rv))
190 return EBUSY;
191
192 pmf_device_deregister(self);
193 sysmon_pswitch_unregister(&sc->sc_smpsw);
194
195 return 0;
196 }
197
198 static void
199 acpi_dalb_notify_handler(ACPI_HANDLE hdl, UINT32 notify, void *opaque)
200 {
201 device_t dev = opaque;
202 struct acpi_dalb_softc *sc = device_private(dev);
203 ACPI_STATUS rv;
204
205 switch (notify) {
206 case DALB_SYSTEM_WAKEUP:
207 rv = AcpiOsExecute(OSL_NOTIFY_HANDLER,
208 acpi_dalb_get_wakeup_hotkeys, dev);
209 break;
210 case DALB_SYSTEM_RUNTIME:
211 rv = AcpiOsExecute(OSL_NOTIFY_HANDLER,
212 acpi_dalb_get_runtime_hotkeys, dev);
213 break;
214
215 default:
216 aprint_error_dev(dev,
217 "unknown notification event 0x%x from button 0x%x\n",
218 notify, (uint32_t)sc->sc_usageid);
219 return;
220 }
221
222 if (ACPI_FAILURE(rv))
223 aprint_error_dev(dev, "couldn't queue hotkey handler: %s\n",
224 AcpiFormatException(rv));
225 }
226
227 static void
228 acpi_dalb_get_wakeup_hotkeys(void *opaque)
229 {
230 device_t dev = opaque;
231 struct acpi_dalb_softc *sc = device_private(dev);
232
233 if (!sc->sc_smpsw_valid)
234 return;
235
236 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
237 "%s: %s: invoking sysmon_pswitch_event\n",
238 sc->sc_smpsw.smpsw_name, __func__));
239
240 sysmon_pswitch_event(&sc->sc_smpsw, PSWITCH_EVENT_PRESSED);
241 }
242
243 static void
244 acpi_dalb_get_runtime_hotkeys(void *opaque)
245 {
246 device_t dev = opaque;
247 struct acpi_dalb_softc *sc = device_private(dev);
248
249 if (!sc->sc_smpsw_valid)
250 return;
251
252 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
253 "%s: %s: invoking sysmon_pswitch_event\n",
254 sc->sc_smpsw.smpsw_name, __func__));
255
256 sysmon_pswitch_event(&sc->sc_smpsw, PSWITCH_EVENT_PRESSED);
257 }
258
259 static bool
260 acpi_dalb_resume(device_t dev, const pmf_qual_t *qual)
261 {
262 struct acpi_dalb_softc *sc = device_private(dev);
263 ACPI_STATUS rv;
264 ACPI_BUFFER ret;
265
266 rv = acpi_eval_struct(sc->sc_node->ad_handle, "GHID", &ret);
267 if (ACPI_FAILURE(rv)) {
268 aprint_error_dev(dev, "couldn't evaluate GHID: %s\n",
269 AcpiFormatException(rv));
270 return false;
271 }
272 if (ret.Pointer)
273 ACPI_FREE(ret.Pointer);
274
275 return true;
276 }
277