hpcapm.c revision 1.10
1 /* $NetBSD: hpcapm.c,v 1.10 2006/10/09 10:33:42 peter 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.10 2006/10/09 10:33:42 peter 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 <machine/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, struct cfdata *cf, void *aux) 109 { 110 return 1; 111 } 112 113 static void 114 hpcapm_attach(struct device *parent, struct device *self, void *aux) 115 { 116 struct apmhpc_softc *sc; 117 struct apmdev_attach_args aaa; 118 119 sc = device_private(self); 120 printf(": pseudo power management module\n"); 121 122 sc->events = 0; 123 sc->power_state = APM_SYS_READY; 124 sc->battery_state = APM_BATT_FLAG_UNKNOWN; 125 sc->ac_state = APM_AC_UNKNOWN; 126 sc->battery_life = APM_BATT_LIFE_UNKNOWN; 127 sc->minutes_left = 0; 128 sc->sc_standby_hook = config_hook(CONFIG_HOOK_PMEVENT, 129 CONFIG_HOOK_PMEVENT_STANDBYREQ, 130 CONFIG_HOOK_EXCLUSIVE, 131 hpcapm_hook, sc); 132 sc->sc_suspend_hook = config_hook(CONFIG_HOOK_PMEVENT, 133 CONFIG_HOOK_PMEVENT_SUSPENDREQ, 134 CONFIG_HOOK_EXCLUSIVE, 135 hpcapm_hook, sc); 136 137 sc->sc_battery_hook = config_hook(CONFIG_HOOK_PMEVENT, 138 CONFIG_HOOK_PMEVENT_BATTERY, 139 CONFIG_HOOK_SHARE, 140 hpcapm_hook, sc); 141 142 sc->sc_ac_hook = config_hook(CONFIG_HOOK_PMEVENT, 143 CONFIG_HOOK_PMEVENT_AC, 144 CONFIG_HOOK_SHARE, 145 hpcapm_hook, sc); 146 147 aaa.accessops = &hpcapm_accessops; 148 aaa.accesscookie = sc; 149 aaa.apm_detail = 0x0102; 150 151 sc->sc_apmdev = config_found_ia(self, "apmdevif", &aaa, apmprint); 152 } 153 154 static int 155 hpcapm_hook(void *ctx, int type, long id, void *msg) 156 { 157 struct apmhpc_softc *sc; 158 int s; 159 int charge; 160 int message; 161 162 sc = ctx; 163 164 if (type != CONFIG_HOOK_PMEVENT) 165 return 1; 166 167 if (CONFIG_HOOK_VALUEP(msg)) 168 message = (int)msg; 169 else 170 message = *(int *)msg; 171 172 s = splhigh(); 173 switch (id) { 174 case CONFIG_HOOK_PMEVENT_STANDBYREQ: 175 if (sc->power_state != APM_SYS_STANDBY) { 176 sc->events |= (1 << APM_USER_STANDBY_REQ); 177 } else { 178 sc->events |= (1 << APM_NORMAL_RESUME); 179 } 180 break; 181 case CONFIG_HOOK_PMEVENT_SUSPENDREQ: 182 if (sc->power_state != APM_SYS_SUSPEND) { 183 DPRINTF(("hpcapm: suspend request\n")); 184 sc->events |= (1 << APM_USER_SUSPEND_REQ); 185 } else { 186 sc->events |= (1 << APM_NORMAL_RESUME); 187 } 188 break; 189 case CONFIG_HOOK_PMEVENT_BATTERY: 190 switch (message) { 191 case CONFIG_HOOK_BATT_CRITICAL: 192 DPRINTF(("hpcapm: battery state critical\n")); 193 charge = sc->battery_state & APM_BATT_FLAG_CHARGING; 194 sc->battery_state = APM_BATT_FLAG_CRITICAL; 195 sc->battery_state |= charge; 196 sc->battery_life = 0; 197 break; 198 case CONFIG_HOOK_BATT_LOW: 199 DPRINTF(("hpcapm: battery state low\n")); 200 charge = sc->battery_state & APM_BATT_FLAG_CHARGING; 201 sc->battery_state = APM_BATT_FLAG_LOW; 202 sc->battery_state |= charge; 203 break; 204 case CONFIG_HOOK_BATT_HIGH: 205 DPRINTF(("hpcapm: battery state high\n")); 206 charge = sc->battery_state & APM_BATT_FLAG_CHARGING; 207 sc->battery_state = APM_BATT_FLAG_HIGH; 208 sc->battery_state |= charge; 209 break; 210 case CONFIG_HOOK_BATT_10P: 211 DPRINTF(("hpcapm: battery life 10%%\n")); 212 sc->battery_life = 10; 213 break; 214 case CONFIG_HOOK_BATT_20P: 215 DPRINTF(("hpcapm: battery life 20%%\n")); 216 sc->battery_life = 20; 217 break; 218 case CONFIG_HOOK_BATT_30P: 219 DPRINTF(("hpcapm: battery life 30%%\n")); 220 sc->battery_life = 30; 221 break; 222 case CONFIG_HOOK_BATT_40P: 223 DPRINTF(("hpcapm: battery life 40%%\n")); 224 sc->battery_life = 40; 225 break; 226 case CONFIG_HOOK_BATT_50P: 227 DPRINTF(("hpcapm: battery life 50%%\n")); 228 sc->battery_life = 50; 229 break; 230 case CONFIG_HOOK_BATT_60P: 231 DPRINTF(("hpcapm: battery life 60%%\n")); 232 sc->battery_life = 60; 233 break; 234 case CONFIG_HOOK_BATT_70P: 235 DPRINTF(("hpcapm: battery life 70%%\n")); 236 sc->battery_life = 70; 237 break; 238 case CONFIG_HOOK_BATT_80P: 239 DPRINTF(("hpcapm: battery life 80%%\n")); 240 sc->battery_life = 80; 241 break; 242 case CONFIG_HOOK_BATT_90P: 243 DPRINTF(("hpcapm: battery life 90%%\n")); 244 sc->battery_life = 90; 245 break; 246 case CONFIG_HOOK_BATT_100P: 247 DPRINTF(("hpcapm: battery life 100%%\n")); 248 sc->battery_life = 100; 249 break; 250 case CONFIG_HOOK_BATT_UNKNOWN: 251 DPRINTF(("hpcapm: battery state unknown\n")); 252 sc->battery_state = APM_BATT_FLAG_UNKNOWN; 253 sc->battery_life = APM_BATT_LIFE_UNKNOWN; 254 break; 255 case CONFIG_HOOK_BATT_NO_SYSTEM_BATTERY: 256 DPRINTF(("hpcapm: battery state no system battery?\n")); 257 sc->battery_state = APM_BATT_FLAG_NO_SYSTEM_BATTERY; 258 sc->battery_life = APM_BATT_LIFE_UNKNOWN; 259 break; 260 } 261 break; 262 case CONFIG_HOOK_PMEVENT_AC: 263 switch (message) { 264 case CONFIG_HOOK_AC_OFF: 265 DPRINTF(("hpcapm: ac not connected\n")); 266 sc->battery_state &= ~APM_BATT_FLAG_CHARGING; 267 sc->ac_state = APM_AC_OFF; 268 break; 269 case CONFIG_HOOK_AC_ON_CHARGE: 270 DPRINTF(("hpcapm: charging\n")); 271 sc->battery_state |= APM_BATT_FLAG_CHARGING; 272 sc->ac_state = APM_AC_ON; 273 break; 274 case CONFIG_HOOK_AC_ON_NOCHARGE: 275 DPRINTF(("hpcapm: ac connected\n")); 276 sc->battery_state &= ~APM_BATT_FLAG_CHARGING; 277 sc->ac_state = APM_AC_ON; 278 break; 279 case CONFIG_HOOK_AC_UNKNOWN: 280 sc->ac_state = APM_AC_UNKNOWN; 281 break; 282 } 283 break; 284 } 285 splx(s); 286 287 return (0); 288 } 289 290 static void 291 hpcapm_disconnect(void *scx) 292 { 293 struct apmhpc_softc *sc; 294 295 sc = scx; 296 } 297 298 static void 299 hpcapm_enable(void *scx, int onoff) 300 { 301 struct apmhpc_softc *sc; 302 303 sc = scx; 304 } 305 306 static int 307 hpcapm_set_powstate(void *scx, u_int devid, u_int powstat) 308 { 309 struct apmhpc_softc *sc; 310 int s; 311 312 sc = scx; 313 314 if (devid != APM_DEV_ALLDEVS) 315 return APM_ERR_UNRECOG_DEV; 316 317 switch (powstat) { 318 case APM_SYS_READY: 319 DPRINTF(("hpcapm: set power state READY\n")); 320 sc->power_state = APM_SYS_READY; 321 break; 322 case APM_SYS_STANDBY: 323 DPRINTF(("hpcapm: set power state STANDBY\n")); 324 s = splhigh(); 325 config_hook_call(CONFIG_HOOK_PMEVENT, 326 CONFIG_HOOK_PMEVENT_HARDPOWER, 327 (void *)PWR_STANDBY); 328 sc->power_state = APM_SYS_STANDBY; 329 machine_standby(); 330 config_hook_call_reverse(CONFIG_HOOK_PMEVENT, 331 CONFIG_HOOK_PMEVENT_HARDPOWER, 332 (void *)PWR_RESUME); 333 DPRINTF(("hpcapm: resume\n")); 334 splx(s); 335 break; 336 case APM_SYS_SUSPEND: 337 DPRINTF(("hpcapm: set power state SUSPEND...\n")); 338 s = splhigh(); 339 config_hook_call(CONFIG_HOOK_PMEVENT, 340 CONFIG_HOOK_PMEVENT_HARDPOWER, 341 (void *)PWR_SUSPEND); 342 sc->power_state = APM_SYS_SUSPEND; 343 machine_sleep(); 344 config_hook_call_reverse(CONFIG_HOOK_PMEVENT, 345 CONFIG_HOOK_PMEVENT_HARDPOWER, 346 (void *)PWR_RESUME); 347 DPRINTF(("hpcapm: resume\n")); 348 splx(s); 349 break; 350 case APM_SYS_OFF: 351 DPRINTF(("hpcapm: set power state OFF\n")); 352 sc->power_state = APM_SYS_OFF; 353 break; 354 case APM_LASTREQ_INPROG: 355 /*DPRINTF(("hpcapm: set power state INPROG\n")); 356 */ 357 break; 358 case APM_LASTREQ_REJECTED: 359 DPRINTF(("hpcapm: set power state REJECTED\n")); 360 break; 361 } 362 363 return (0); 364 } 365 366 static int 367 hpcapm_get_powstat(void *scx, struct apm_power_info *pinfo) 368 { 369 struct apmhpc_softc *sc; 370 int val; 371 372 sc = scx; 373 374 if (config_hook_call(CONFIG_HOOK_GET, 375 CONFIG_HOOK_ACADAPTER, &val) != -1) 376 pinfo->ac_state = val; 377 else 378 pinfo->ac_state = sc->ac_state; 379 if (config_hook_call(CONFIG_HOOK_GET, 380 CONFIG_HOOK_CHARGE, &val) != -1) 381 pinfo->battery_state = val; 382 else 383 pinfo->battery_state = sc->battery_state; 384 if (config_hook_call(CONFIG_HOOK_GET, 385 CONFIG_HOOK_BATTERYVAL, &val) != -1) 386 pinfo->battery_life = val; 387 else 388 pinfo->battery_life = sc->battery_life; 389 return (0); 390 } 391 392 static int 393 hpcapm_get_event(void *scx, u_int *event_type, u_int *event_info) 394 { 395 struct apmhpc_softc *sc; 396 int s, i; 397 398 sc = scx; 399 s = splhigh(); 400 for (i = APM_STANDBY_REQ; i <= APM_CAP_CHANGE; i++) { 401 if (sc->events & (1 << i)) { 402 sc->events &= ~(1 << i); 403 *event_type = i; 404 if (*event_type == APM_NORMAL_RESUME || 405 *event_type == APM_CRIT_RESUME) { 406 /* pccard power off in the suspend state */ 407 *event_info = 1; 408 sc->power_state = APM_SYS_READY; 409 } else 410 *event_info = 0; 411 return (0); 412 } 413 } 414 splx(s); 415 416 return APM_ERR_NOEVENTS; 417 } 418 419 static void 420 hpcapm_cpu_busy(void *scx) 421 { 422 struct apmhpc_softc *sc; 423 424 sc = scx; 425 } 426 427 static void 428 hpcapm_cpu_idle(void *scx) 429 { 430 struct apmhpc_softc *sc; 431 432 sc = scx; 433 } 434 435 static void 436 hpcapm_get_capabilities(void *scx, u_int *numbatts, u_int *capflags) 437 { 438 struct apmhpc_softc *sc; 439 440 *numbatts = 0; 441 *capflags = APM_GLOBAL_STANDBY | APM_GLOBAL_SUSPEND; 442 443 sc = scx; 444 } 445
Indexes created Thu Oct 02 10:09:58 GMT 2025