FreeBSD/Linux Kernel Cross Reference
sys/dev/hpc/hpcapm.c
1 /* $NetBSD: hpcapm.c,v 1.13 2007/10/19 11:59:42 ad Exp $ */
2
3 /*
4 * Copyright (c) 2000 Takemura Shin
5 * Copyright (c) 2000-2001 SATO Kazumi
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 REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 */
30
31 #include <sys/cdefs.h>
32 __KERNEL_RCSID(0, "$NetBSD: hpcapm.c,v 1.13 2007/10/19 11:59:42 ad Exp $");
33
34 #ifdef _KERNEL_OPT
35 #include "opt_hpcapm.h"
36 #endif
37
38 #include <sys/param.h>
39 #include <sys/device.h>
40 #include <sys/kernel.h>
41 #include <sys/systm.h>
42
43 #include <dev/hpc/apm/apmvar.h>
44
45 #include <sys/bus.h>
46 #include <machine/config_hook.h>
47 #include <machine/platid.h>
48 #include <machine/platid_mask.h>
49
50 #ifdef HPCAPMDEBUG
51 #ifndef HPCAPMDEBUG_CONF
52 #define HPCAPMDEBUG_CONF 1
53 #endif
54 int hpcapm_debug = HPCAPMDEBUG_CONF;
55 #define DPRINTF(arg) do { if (hpcapm_debug) printf arg; } while(0);
56 #define DPRINTFN(n, arg) do { if (hpcapm_debug > (n)) printf arg; } while (0);
57 #else
58 #define DPRINTF(arg) do { } while (0);
59 #define DPRINTFN(n, arg) do { } while (0);
60 #endif
61
62 /* Definition of the driver for autoconfig. */
63 static int hpcapm_match(struct device *, struct cfdata *, void *);
64 static void hpcapm_attach(struct device *, struct device *, void *);
65 static int hpcapm_hook(void *, int, long, void *);
66
67 static void hpcapm_disconnect(void *);
68 static void hpcapm_enable(void *, int);
69 static int hpcapm_set_powstate(void *, u_int, u_int);
70 static int hpcapm_get_powstat(void *, struct apm_power_info *);
71 static int hpcapm_get_event(void *, u_int *, u_int *);
72 static void hpcapm_cpu_busy(void *);
73 static void hpcapm_cpu_idle(void *);
74 static void hpcapm_get_capabilities(void *, u_int *, u_int *);
75
76 struct apmhpc_softc {
77 struct device sc_dev;
78 void *sc_apmdev;
79 volatile unsigned int events;
80 volatile int power_state;
81 volatile int battery_state;
82 volatile int ac_state;
83 config_hook_tag sc_standby_hook;
84 config_hook_tag sc_suspend_hook;
85 config_hook_tag sc_battery_hook;
86 config_hook_tag sc_ac_hook;
87 int battery_life;
88 int minutes_left;
89 };
90
91 CFATTACH_DECL(hpcapm, sizeof (struct apmhpc_softc),
92 hpcapm_match, hpcapm_attach, NULL, NULL);
93
94 struct apm_accessops hpcapm_accessops = {
95 hpcapm_disconnect,
96 hpcapm_enable,
97 hpcapm_set_powstate,
98 hpcapm_get_powstat,
99 hpcapm_get_event,
100 hpcapm_cpu_busy,
101 hpcapm_cpu_idle,
102 hpcapm_get_capabilities,
103 };
104
105 extern struct cfdriver hpcapm_cd;
106
107 static int
108 hpcapm_match(struct device *parent,
109 struct cfdata *cf, void *aux)
110 {
111
112 return 1;
113 }
114
115 static void
116 hpcapm_attach(struct device *parent,
117 struct device *self, void *aux)
118 {
119 struct apmhpc_softc *sc;
120 struct apmdev_attach_args aaa;
121
122 sc = device_private(self);
123 printf(": pseudo power management module\n");
124
125 sc->events = 0;
126 sc->power_state = APM_SYS_READY;
127 sc->battery_state = APM_BATT_FLAG_UNKNOWN;
128 sc->ac_state = APM_AC_UNKNOWN;
129 sc->battery_life = APM_BATT_LIFE_UNKNOWN;
130 sc->minutes_left = 0;
131 sc->sc_standby_hook = config_hook(CONFIG_HOOK_PMEVENT,
132 CONFIG_HOOK_PMEVENT_STANDBYREQ,
133 CONFIG_HOOK_EXCLUSIVE,
134 hpcapm_hook, sc);
135 sc->sc_suspend_hook = config_hook(CONFIG_HOOK_PMEVENT,
136 CONFIG_HOOK_PMEVENT_SUSPENDREQ,
137 CONFIG_HOOK_EXCLUSIVE,
138 hpcapm_hook, sc);
139
140 sc->sc_battery_hook = config_hook(CONFIG_HOOK_PMEVENT,
141 CONFIG_HOOK_PMEVENT_BATTERY,
142 CONFIG_HOOK_SHARE,
143 hpcapm_hook, sc);
144
145 sc->sc_ac_hook = config_hook(CONFIG_HOOK_PMEVENT,
146 CONFIG_HOOK_PMEVENT_AC,
147 CONFIG_HOOK_SHARE,
148 hpcapm_hook, sc);
149
150 aaa.accessops = &hpcapm_accessops;
151 aaa.accesscookie = sc;
152 aaa.apm_detail = 0x0102;
153
154 sc->sc_apmdev = config_found_ia(self, "apmdevif", &aaa, apmprint);
155 }
156
157 static int
158 hpcapm_hook(void *ctx, int type, long id, void *msg)
159 {
160 struct apmhpc_softc *sc;
161 int s;
162 int charge;
163 int message;
164
165 sc = ctx;
166
167 if (type != CONFIG_HOOK_PMEVENT)
168 return 1;
169
170 if (CONFIG_HOOK_VALUEP(msg))
171 message = (int)msg;
172 else
173 message = *(int *)msg;
174
175 s = splhigh();
176 switch (id) {
177 case CONFIG_HOOK_PMEVENT_STANDBYREQ:
178 if (sc->power_state != APM_SYS_STANDBY) {
179 sc->events |= (1 << APM_USER_STANDBY_REQ);
180 } else {
181 sc->events |= (1 << APM_NORMAL_RESUME);
182 }
183 break;
184 case CONFIG_HOOK_PMEVENT_SUSPENDREQ:
185 if (sc->power_state != APM_SYS_SUSPEND) {
186 DPRINTF(("hpcapm: suspend request\n"));
187 sc->events |= (1 << APM_USER_SUSPEND_REQ);
188 } else {
189 sc->events |= (1 << APM_NORMAL_RESUME);
190 }
191 break;
192 case CONFIG_HOOK_PMEVENT_BATTERY:
193 switch (message) {
194 case CONFIG_HOOK_BATT_CRITICAL:
195 DPRINTF(("hpcapm: battery state critical\n"));
196 charge = sc->battery_state & APM_BATT_FLAG_CHARGING;
197 sc->battery_state = APM_BATT_FLAG_CRITICAL;
198 sc->battery_state |= charge;
199 sc->battery_life = 0;
200 break;
201 case CONFIG_HOOK_BATT_LOW:
202 DPRINTF(("hpcapm: battery state low\n"));
203 charge = sc->battery_state & APM_BATT_FLAG_CHARGING;
204 sc->battery_state = APM_BATT_FLAG_LOW;
205 sc->battery_state |= charge;
206 break;
207 case CONFIG_HOOK_BATT_HIGH:
208 DPRINTF(("hpcapm: battery state high\n"));
209 charge = sc->battery_state & APM_BATT_FLAG_CHARGING;
210 sc->battery_state = APM_BATT_FLAG_HIGH;
211 sc->battery_state |= charge;
212 break;
213 case CONFIG_HOOK_BATT_10P:
214 DPRINTF(("hpcapm: battery life 10%%\n"));
215 sc->battery_life = 10;
216 break;
217 case CONFIG_HOOK_BATT_20P:
218 DPRINTF(("hpcapm: battery life 20%%\n"));
219 sc->battery_life = 20;
220 break;
221 case CONFIG_HOOK_BATT_30P:
222 DPRINTF(("hpcapm: battery life 30%%\n"));
223 sc->battery_life = 30;
224 break;
225 case CONFIG_HOOK_BATT_40P:
226 DPRINTF(("hpcapm: battery life 40%%\n"));
227 sc->battery_life = 40;
228 break;
229 case CONFIG_HOOK_BATT_50P:
230 DPRINTF(("hpcapm: battery life 50%%\n"));
231 sc->battery_life = 50;
232 break;
233 case CONFIG_HOOK_BATT_60P:
234 DPRINTF(("hpcapm: battery life 60%%\n"));
235 sc->battery_life = 60;
236 break;
237 case CONFIG_HOOK_BATT_70P:
238 DPRINTF(("hpcapm: battery life 70%%\n"));
239 sc->battery_life = 70;
240 break;
241 case CONFIG_HOOK_BATT_80P:
242 DPRINTF(("hpcapm: battery life 80%%\n"));
243 sc->battery_life = 80;
244 break;
245 case CONFIG_HOOK_BATT_90P:
246 DPRINTF(("hpcapm: battery life 90%%\n"));
247 sc->battery_life = 90;
248 break;
249 case CONFIG_HOOK_BATT_100P:
250 DPRINTF(("hpcapm: battery life 100%%\n"));
251 sc->battery_life = 100;
252 break;
253 case CONFIG_HOOK_BATT_UNKNOWN:
254 DPRINTF(("hpcapm: battery state unknown\n"));
255 sc->battery_state = APM_BATT_FLAG_UNKNOWN;
256 sc->battery_life = APM_BATT_LIFE_UNKNOWN;
257 break;
258 case CONFIG_HOOK_BATT_NO_SYSTEM_BATTERY:
259 DPRINTF(("hpcapm: battery state no system battery?\n"));
260 sc->battery_state = APM_BATT_FLAG_NO_SYSTEM_BATTERY;
261 sc->battery_life = APM_BATT_LIFE_UNKNOWN;
262 break;
263 }
264 break;
265 case CONFIG_HOOK_PMEVENT_AC:
266 switch (message) {
267 case CONFIG_HOOK_AC_OFF:
268 DPRINTF(("hpcapm: ac not connected\n"));
269 sc->battery_state &= ~APM_BATT_FLAG_CHARGING;
270 sc->ac_state = APM_AC_OFF;
271 break;
272 case CONFIG_HOOK_AC_ON_CHARGE:
273 DPRINTF(("hpcapm: charging\n"));
274 sc->battery_state |= APM_BATT_FLAG_CHARGING;
275 sc->ac_state = APM_AC_ON;
276 break;
277 case CONFIG_HOOK_AC_ON_NOCHARGE:
278 DPRINTF(("hpcapm: ac connected\n"));
279 sc->battery_state &= ~APM_BATT_FLAG_CHARGING;
280 sc->ac_state = APM_AC_ON;
281 break;
282 case CONFIG_HOOK_AC_UNKNOWN:
283 sc->ac_state = APM_AC_UNKNOWN;
284 break;
285 }
286 break;
287 }
288 splx(s);
289
290 return (0);
291 }
292
293 static void
294 hpcapm_disconnect(void *scx)
295 {
296 struct apmhpc_softc *sc;
297
298 sc = scx;
299 }
300
301 static void
302 hpcapm_enable(void *scx, int onoff)
303 {
304 struct apmhpc_softc *sc;
305
306 sc = scx;
307 }
308
309 static int
310 hpcapm_set_powstate(void *scx, u_int devid, u_int powstat)
311 {
312 struct apmhpc_softc *sc;
313 int s;
314
315 sc = scx;
316
317 if (devid != APM_DEV_ALLDEVS)
318 return APM_ERR_UNRECOG_DEV;
319
320 switch (powstat) {
321 case APM_SYS_READY:
322 DPRINTF(("hpcapm: set power state READY\n"));
323 sc->power_state = APM_SYS_READY;
324 break;
325 case APM_SYS_STANDBY:
326 DPRINTF(("hpcapm: set power state STANDBY\n"));
327 s = splhigh();
328 config_hook_call(CONFIG_HOOK_PMEVENT,
329 CONFIG_HOOK_PMEVENT_HARDPOWER,
330 (void *)PWR_STANDBY);
331 sc->power_state = APM_SYS_STANDBY;
332 machine_standby();
333 config_hook_call_reverse(CONFIG_HOOK_PMEVENT,
334 CONFIG_HOOK_PMEVENT_HARDPOWER,
335 (void *)PWR_RESUME);
336 DPRINTF(("hpcapm: resume\n"));
337 splx(s);
338 break;
339 case APM_SYS_SUSPEND:
340 DPRINTF(("hpcapm: set power state SUSPEND...\n"));
341 s = splhigh();
342 config_hook_call(CONFIG_HOOK_PMEVENT,
343 CONFIG_HOOK_PMEVENT_HARDPOWER,
344 (void *)PWR_SUSPEND);
345 sc->power_state = APM_SYS_SUSPEND;
346 machine_sleep();
347 config_hook_call_reverse(CONFIG_HOOK_PMEVENT,
348 CONFIG_HOOK_PMEVENT_HARDPOWER,
349 (void *)PWR_RESUME);
350 DPRINTF(("hpcapm: resume\n"));
351 splx(s);
352 break;
353 case APM_SYS_OFF:
354 DPRINTF(("hpcapm: set power state OFF\n"));
355 sc->power_state = APM_SYS_OFF;
356 break;
357 case APM_LASTREQ_INPROG:
358 /*DPRINTF(("hpcapm: set power state INPROG\n"));
359 */
360 break;
361 case APM_LASTREQ_REJECTED:
362 DPRINTF(("hpcapm: set power state REJECTED\n"));
363 break;
364 }
365
366 return (0);
367 }
368
369 static int
370 hpcapm_get_powstat(void *scx, struct apm_power_info *pinfo)
371 {
372 struct apmhpc_softc *sc;
373 int val;
374
375 sc = scx;
376
377 if (config_hook_call(CONFIG_HOOK_GET,
378 CONFIG_HOOK_ACADAPTER, &val) != -1)
379 pinfo->ac_state = val;
380 else
381 pinfo->ac_state = sc->ac_state;
382 if (config_hook_call(CONFIG_HOOK_GET,
383 CONFIG_HOOK_CHARGE, &val) != -1)
384 pinfo->battery_state = val;
385 else
386 pinfo->battery_state = sc->battery_state;
387 if (config_hook_call(CONFIG_HOOK_GET,
388 CONFIG_HOOK_BATTERYVAL, &val) != -1)
389 pinfo->battery_life = val;
390 else
391 pinfo->battery_life = sc->battery_life;
392 return (0);
393 }
394
395 static int
396 hpcapm_get_event(void *scx, u_int *event_type, u_int *event_info)
397 {
398 struct apmhpc_softc *sc;
399 int s, i;
400
401 sc = scx;
402 s = splhigh();
403 for (i = APM_STANDBY_REQ; i <= APM_CAP_CHANGE; i++) {
404 if (sc->events & (1 << i)) {
405 sc->events &= ~(1 << i);
406 *event_type = i;
407 if (*event_type == APM_NORMAL_RESUME ||
408 *event_type == APM_CRIT_RESUME) {
409 /* pccard power off in the suspend state */
410 *event_info = 1;
411 sc->power_state = APM_SYS_READY;
412 } else
413 *event_info = 0;
414 return (0);
415 }
416 }
417 splx(s);
418
419 return APM_ERR_NOEVENTS;
420 }
421
422 static void
423 hpcapm_cpu_busy(void *scx)
424 {
425 struct apmhpc_softc *sc;
426
427 sc = scx;
428 }
429
430 static void
431 hpcapm_cpu_idle(void *scx)
432 {
433 struct apmhpc_softc *sc;
434
435 sc = scx;
436 }
437
438 static void
439 hpcapm_get_capabilities(void *scx, u_int *numbatts, u_int *capflags)
440 {
441 struct apmhpc_softc *sc;
442
443 *numbatts = 0;
444 *capflags = APM_GLOBAL_STANDBY | APM_GLOBAL_SUSPEND;
445
446 sc = scx;
447 }
Cache object: 753402091ec69119b9b84dfb74d5d056
|