xref: /dragonfly/sys/dev/acpica/acpi_button.c (revision 25a2db75)
1 /*-
2  * Copyright (c) 2000 Mitsaru IWASAKI <iwasaki@jp.freebsd.org>
3  * Copyright (c) 2000 Michael Smith <msmith@freebsd.org>
4  * Copyright (c) 2000 BSDi
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  *
28  * $FreeBSD: src/sys/dev/acpica/acpi_button.c,v 1.33 2009/06/05 18:44:36 jkim Exp
29  */
30 
31 #include "opt_acpi.h"
32 #include <sys/param.h>
33 #include <sys/kernel.h>
34 #include <sys/module.h>
35 #include <sys/bus.h>
36 
37 #include "acpi.h"
38 #include "accommon.h"
39 
40 #include <dev/acpica/acpivar.h>
41 
42 /* Hooks for the ACPI CA debugging infrastructure */
43 #define _COMPONENT	ACPI_BUTTON
44 ACPI_MODULE_NAME("BUTTON")
45 
46 struct acpi_button_softc {
47     device_t	button_dev;
48     ACPI_HANDLE	button_handle;
49     boolean_t	button_type;
50 #define		ACPI_POWER_BUTTON	0
51 #define		ACPI_SLEEP_BUTTON	1
52     boolean_t	fixed;
53 };
54 
55 #define		ACPI_NOTIFY_BUTTON_PRESSED_FOR_SLEEP	0x80
56 #define		ACPI_NOTIFY_BUTTON_PRESSED_FOR_WAKEUP	0x02
57 
58 static int	acpi_button_probe(device_t dev);
59 static int	acpi_button_attach(device_t dev);
60 static int	acpi_button_suspend(device_t dev);
61 static int	acpi_button_resume(device_t dev);
62 static void 	acpi_button_notify_handler(ACPI_HANDLE h, UINT32 notify,
63 					   void *context);
64 static ACPI_STATUS
65 		acpi_button_fixed_handler(void *context);
66 static void	acpi_button_notify_sleep(void *arg);
67 static void	acpi_button_notify_wakeup(void *arg);
68 
69 static char *btn_ids[] = {
70     "PNP0C0C", "ACPI_FPB", "PNP0C0E", "ACPI_FSB",
71     NULL
72 };
73 
74 static device_method_t acpi_button_methods[] = {
75     /* Device interface */
76     DEVMETHOD(device_probe,	acpi_button_probe),
77     DEVMETHOD(device_attach,	acpi_button_attach),
78     DEVMETHOD(device_suspend,	acpi_button_suspend),
79     DEVMETHOD(device_shutdown,	acpi_button_suspend),
80     DEVMETHOD(device_resume,	acpi_button_resume),
81 
82     DEVMETHOD_END
83 };
84 
85 static driver_t acpi_button_driver = {
86     "acpi_button",
87     acpi_button_methods,
88     sizeof(struct acpi_button_softc),
89 };
90 
91 static devclass_t acpi_button_devclass;
92 DRIVER_MODULE(acpi_button, acpi, acpi_button_driver, acpi_button_devclass,
93 	      0, 0);
94 MODULE_DEPEND(acpi_button, acpi, 1, 1, 1);
95 
96 static int
97 acpi_button_probe(device_t dev)
98 {
99     struct acpi_button_softc *sc;
100     char *str;
101 
102     if (acpi_disabled("button") ||
103 	(str = ACPI_ID_PROBE(device_get_parent(dev), dev, btn_ids)) == NULL)
104 	return (ENXIO);
105 
106     sc = device_get_softc(dev);
107     if (strcmp(str, "PNP0C0C") == 0) {
108 	device_set_desc(dev, "Power Button");
109 	sc->button_type = ACPI_POWER_BUTTON;
110     } else if (strcmp(str, "ACPI_FPB") == 0) {
111 	device_set_desc(dev, "Power Button (fixed)");
112 	sc->button_type = ACPI_POWER_BUTTON;
113 	sc->fixed = 1;
114     } else if (strcmp(str, "PNP0C0E") == 0) {
115 	device_set_desc(dev, "Sleep Button");
116 	sc->button_type = ACPI_SLEEP_BUTTON;
117     } else if (strcmp(str, "ACPI_FSB") == 0) {
118 	device_set_desc(dev, "Sleep Button (fixed)");
119 	sc->button_type = ACPI_SLEEP_BUTTON;
120 	sc->fixed = 1;
121     }
122 
123     return (0);
124 }
125 
126 static int
127 acpi_button_attach(device_t dev)
128 {
129     struct acpi_prw_data	prw;
130     struct acpi_button_softc	*sc;
131     ACPI_STATUS			status;
132     int event;
133 
134     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
135 
136     sc = device_get_softc(dev);
137     sc->button_dev = dev;
138     sc->button_handle = acpi_get_handle(dev);
139     event = (sc->button_type == ACPI_SLEEP_BUTTON) ?
140 	    ACPI_EVENT_SLEEP_BUTTON : ACPI_EVENT_POWER_BUTTON;
141 
142     /*
143      * Install the new handler.  We could remove any fixed handlers added
144      * from the FADT once we have a duplicate from the AML but some systems
145      * only return events on one or the other so we have to keep both.
146      */
147     if (sc->fixed) {
148 	AcpiClearEvent(event);
149 	status = AcpiInstallFixedEventHandler(event,
150 			acpi_button_fixed_handler, sc);
151     } else {
152 	/*
153 	 * If a system does not get lid events, it may make sense to change
154 	 * the type to ACPI_ALL_NOTIFY.  Some systems generate both a wake
155 	 * and runtime notify in that case though.
156 	 */
157 	status = AcpiInstallNotifyHandler(sc->button_handle,
158 			ACPI_DEVICE_NOTIFY, acpi_button_notify_handler, sc);
159     }
160     if (ACPI_FAILURE(status)) {
161 	device_printf(sc->button_dev, "couldn't install notify handler - %s\n",
162 		      AcpiFormatException(status));
163 	return_VALUE (ENXIO);
164     }
165 
166     /* Enable the GPE for wake/runtime */
167     acpi_wake_set_enable(dev, 1);
168     if (acpi_parse_prw(sc->button_handle, &prw) == 0)
169 	AcpiEnableGpe(prw.gpe_handle, prw.gpe_bit);
170 
171     return_VALUE (0);
172 }
173 
174 static int
175 acpi_button_suspend(device_t dev)
176 {
177     return (0);
178 }
179 
180 static int
181 acpi_button_resume(device_t dev)
182 {
183     return (0);
184 }
185 
186 static void
187 acpi_button_notify_sleep(void *arg)
188 {
189     struct acpi_button_softc	*sc;
190     struct acpi_softc		*acpi_sc;
191 
192     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
193 
194     sc = (struct acpi_button_softc *)arg;
195     acpi_sc = acpi_device_get_parent_softc(sc->button_dev);
196     if (acpi_sc == NULL)
197 	return_VOID;
198 
199     acpi_UserNotify("Button", sc->button_handle, sc->button_type);
200 
201     switch (sc->button_type) {
202     case ACPI_POWER_BUTTON:
203 	ACPI_VPRINT(sc->button_dev, acpi_sc, "power button pressed\n");
204 	acpi_event_power_button_sleep(acpi_sc);
205 	break;
206     case ACPI_SLEEP_BUTTON:
207 	ACPI_VPRINT(sc->button_dev, acpi_sc, "sleep button pressed\n");
208 	acpi_event_sleep_button_sleep(acpi_sc);
209 	break;
210     default:
211 	break;		/* unknown button type */
212     }
213 }
214 
215 static void
216 acpi_button_notify_wakeup(void *arg)
217 {
218     struct acpi_button_softc	*sc;
219     struct acpi_softc		*acpi_sc;
220 
221     ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
222 
223     sc = (struct acpi_button_softc *)arg;
224     acpi_sc = acpi_device_get_parent_softc(sc->button_dev);
225     if (acpi_sc == NULL)
226 	return_VOID;
227 
228     acpi_UserNotify("Button", sc->button_handle, sc->button_type);
229 
230     switch (sc->button_type) {
231     case ACPI_POWER_BUTTON:
232 	ACPI_VPRINT(sc->button_dev, acpi_sc, "wakeup by power button\n");
233 	acpi_event_power_button_wake(acpi_sc);
234 	break;
235     case ACPI_SLEEP_BUTTON:
236 	ACPI_VPRINT(sc->button_dev, acpi_sc, "wakeup by sleep button\n");
237 	acpi_event_sleep_button_wake(acpi_sc);
238 	break;
239     default:
240 	break;		/* unknown button type */
241     }
242 }
243 
244 static void
245 acpi_button_notify_handler(ACPI_HANDLE h, UINT32 notify, void *context)
246 {
247     struct acpi_button_softc	*sc;
248 
249     ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, notify);
250 
251     sc = (struct acpi_button_softc *)context;
252     switch (notify) {
253     case ACPI_NOTIFY_BUTTON_PRESSED_FOR_SLEEP:
254 	AcpiOsExecute(OSL_NOTIFY_HANDLER, acpi_button_notify_sleep, sc);
255 	break;
256     case ACPI_NOTIFY_BUTTON_PRESSED_FOR_WAKEUP:
257 	AcpiOsExecute(OSL_NOTIFY_HANDLER, acpi_button_notify_wakeup, sc);
258 	break;
259     default:
260 	device_printf(sc->button_dev, "unknown notify %#x\n", notify);
261 	break;
262     }
263 }
264 
265 static ACPI_STATUS
266 acpi_button_fixed_handler(void *context)
267 {
268     struct acpi_button_softc	*sc = (struct acpi_button_softc *)context;
269 
270     ACPI_FUNCTION_TRACE_PTR((char *)(uintptr_t)__func__, context);
271 
272     if (context == NULL)
273 	return_ACPI_STATUS (AE_BAD_PARAMETER);
274 
275     acpi_button_notify_handler(sc->button_handle,
276 			       ACPI_NOTIFY_BUTTON_PRESSED_FOR_SLEEP, sc);
277     return_ACPI_STATUS (AE_OK);
278 }
279