apm.c revision 1.22
1/* $NetBSD: apm.c,v 1.22 2009/03/14 15:36:09 dsl Exp $ */ 2/* $OpenBSD: apm.c,v 1.5 2002/06/07 07:13:59 miod Exp $ */ 3 4/*- 5 * Copyright (c) 2001 Alexander Guy. All rights reserved. 6 * Copyright (c) 1998-2001 Michael Shalayeff. All rights reserved. 7 * Copyright (c) 1995 John T. Kohl. All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. Neither the names of the authors nor the names of contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 */ 34 35#include <sys/cdefs.h> 36__KERNEL_RCSID(0, "$NetBSD: apm.c,v 1.22 2009/03/14 15:36:09 dsl Exp $"); 37 38#include "apm.h" 39 40#if NAPM > 1 41#error only one APM emulation device may be configured 42#endif 43 44#include <sys/param.h> 45#include <sys/systm.h> 46#include <sys/kernel.h> 47#include <sys/proc.h> 48#include <sys/device.h> 49#include <sys/fcntl.h> 50#include <sys/ioctl.h> 51#include <sys/mutex.h> 52#ifdef __OpenBSD__ 53#include <sys/event.h> 54#endif 55#ifdef __NetBSD__ 56#include <sys/select.h> 57#include <sys/poll.h> 58#include <sys/conf.h> 59#endif 60 61#ifdef __OpenBSD__ 62#include <machine/conf.h> 63#endif 64#include <machine/cpu.h> 65#include <machine/apmvar.h> 66 67#include <macppc/dev/adbvar.h> 68#include <macppc/dev/pm_direct.h> 69 70#if defined(APMDEBUG) 71#define DPRINTF(x) printf x 72#else 73#define DPRINTF(x) /**/ 74#endif 75 76#define APM_NEVENTS 16 77 78struct apm_softc { 79 struct device sc_dev; 80 struct selinfo sc_rsel; 81#ifdef __OpenBSD__ 82 struct klist sc_note; 83#endif 84 int sc_flags; 85 int event_count; 86 int event_ptr; 87 kmutex_t sc_lock; 88 struct apm_event_info event_list[APM_NEVENTS]; 89}; 90 91/* 92 * A brief note on the locking protocol: it's very simple; we 93 * assert an exclusive lock any time thread context enters the 94 * APM module. This is both the APM thread itself, as well as 95 * user context. 96 */ 97#ifdef __NetBSD__ 98#define APM_LOCK(apmsc) mutex_enter(&(apmsc)->sc_lock) 99#define APM_UNLOCK(apmsc) mutex_exit(&(apmsc)->sc_lock) 100#else 101#define APM_LOCK(apmsc) 102#define APM_UNLOCK(apmsc) 103#endif 104 105int apmmatch(struct device *, struct cfdata *, void *); 106void apmattach(struct device *, struct device *, void *); 107 108#ifdef __NetBSD__ 109#if 0 110static int apm_record_event(struct apm_softc *, u_int); 111#endif 112#endif 113 114CFATTACH_DECL(apm, sizeof(struct apm_softc), 115 apmmatch, apmattach, NULL, NULL); 116 117#ifdef __OpenBSD__ 118struct cfdriver apm_cd = { 119 NULL, "apm", DV_DULL 120}; 121#else 122extern struct cfdriver apm_cd; 123 124dev_type_open(apmopen); 125dev_type_close(apmclose); 126dev_type_ioctl(apmioctl); 127dev_type_poll(apmpoll); 128dev_type_kqfilter(apmkqfilter); 129 130const struct cdevsw apm_cdevsw = { 131 apmopen, apmclose, noread, nowrite, apmioctl, 132 nostop, notty, apmpoll, nommap, apmkqfilter, 133}; 134#endif 135 136int apm_evindex; 137 138#define APMUNIT(dev) (minor(dev)&0xf0) 139#define APMDEV(dev) (minor(dev)&0x0f) 140#define APMDEV_NORMAL 0 141#define APMDEV_CTL 8 142 143/* 144 * Flags to control kernel display 145 * SCFLAG_NOPRINT: do not output APM power messages due to 146 * a power change event. 147 * 148 * SCFLAG_PCTPRINT: do not output APM power messages due to 149 * to a power change event unless the battery 150 * percentage changes. 151 */ 152 153#define SCFLAG_NOPRINT 0x0008000 154#define SCFLAG_PCTPRINT 0x0004000 155#define SCFLAG_PRINT (SCFLAG_NOPRINT|SCFLAG_PCTPRINT) 156 157#define SCFLAG_OREAD (1 << 0) 158#define SCFLAG_OWRITE (1 << 1) 159#define SCFLAG_OPEN (SCFLAG_OREAD|SCFLAG_OWRITE) 160 161 162int 163apmmatch(struct device *parent, struct cfdata *match, void *aux) 164{ 165 struct adb_attach_args *aa = (void *)aux; 166 if (aa->origaddr != ADBADDR_APM || 167 aa->handler_id != ADBADDR_APM || 168 aa->adbaddr != ADBADDR_APM) 169 return 0; 170 171 if (adbHardware != ADB_HW_PMU) 172 return 0; 173 174 return 1; 175} 176 177void 178apmattach(parent, self, aux) 179 struct device *parent, *self; 180 void *aux; 181{ 182 struct apm_softc *sc = (struct apm_softc *) self; 183 struct pmu_battery_info info; 184 185 pm_battery_info(0, &info); 186 187 printf(": battery flags 0x%X, ", info.flags); 188 printf("%d%% charged\n", ((info.cur_charge * 100) / info.max_charge)); 189 190 sc->sc_flags = 0; 191 sc->event_ptr = 0; 192 sc->event_count = 0; 193 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE); 194 selinit(&sc->sc_rsel); 195} 196 197int 198apmopen(dev_t dev, int flag, int mode, struct lwp *l) 199{ 200 struct apm_softc *sc; 201 int error = 0; 202 203 /* apm0 only */ 204 sc = device_lookup_private(&apm_cd, APMUNIT(dev)); 205 if (sc == NULL) 206 return ENXIO; 207 208 DPRINTF(("apmopen: dev %d pid %d flag %x mode %x\n", 209 APMDEV(dev), l->l_proc->p_pid, flag, mode)); 210 211 APM_LOCK(sc); 212 switch (APMDEV(dev)) { 213 case APMDEV_CTL: 214 if (!(flag & FWRITE)) { 215 error = EINVAL; 216 break; 217 } 218 if (sc->sc_flags & SCFLAG_OWRITE) { 219 error = EBUSY; 220 break; 221 } 222 sc->sc_flags |= SCFLAG_OWRITE; 223 break; 224 case APMDEV_NORMAL: 225 if (!(flag & FREAD) || (flag & FWRITE)) { 226 error = EINVAL; 227 break; 228 } 229 sc->sc_flags |= SCFLAG_OREAD; 230 break; 231 default: 232 error = ENXIO; 233 break; 234 } 235 APM_UNLOCK(sc); 236 return error; 237} 238 239int 240apmclose(dev_t dev, int flag, int mode, struct lwp *l) 241{ 242 struct apm_softc *sc; 243 244 /* apm0 only */ 245 sc = device_lookup_private(&apm_cd, APMUNIT(dev)); 246 if (sc == NULL) 247 return ENXIO; 248 249 DPRINTF(("apmclose: pid %d flag %x mode %x\n", l->l_proc->p_pid, flag, mode)); 250 251 APM_LOCK(sc); 252 switch (APMDEV(dev)) { 253 case APMDEV_CTL: 254 sc->sc_flags &= ~SCFLAG_OWRITE; 255 break; 256 case APMDEV_NORMAL: 257 sc->sc_flags &= ~SCFLAG_OREAD; 258 break; 259 } 260 APM_UNLOCK(sc); 261 return 0; 262} 263 264int 265apmioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) 266{ 267 struct apm_softc *sc; 268 struct pmu_battery_info batt; 269 struct apm_power_info *power; 270 int error = 0; 271 272 /* apm0 only */ 273 sc = device_lookup_private(&apm_cd, APMUNIT(dev)); 274 if (sc == NULL) 275 return ENXIO; 276 277 APM_LOCK(sc); 278 switch (cmd) { 279 /* some ioctl names from linux */ 280 case APM_IOC_STANDBY: 281 if ((flag & FWRITE) == 0) 282 error = EBADF; 283 case APM_IOC_SUSPEND: 284 if ((flag & FWRITE) == 0) 285 error = EBADF; 286 break; 287 case APM_IOC_PRN_CTL: 288 if ((flag & FWRITE) == 0) 289 error = EBADF; 290 else { 291 int op = *(int *)data; 292 DPRINTF(( "APM_IOC_PRN_CTL: %d\n", op )); 293 switch (op) { 294 case APM_PRINT_ON: /* enable printing */ 295 sc->sc_flags &= ~SCFLAG_PRINT; 296 break; 297 case APM_PRINT_OFF: /* disable printing */ 298 sc->sc_flags &= ~SCFLAG_PRINT; 299 sc->sc_flags |= SCFLAG_NOPRINT; 300 break; 301 case APM_PRINT_PCT: /* disable some printing */ 302 sc->sc_flags &= ~SCFLAG_PRINT; 303 sc->sc_flags |= SCFLAG_PCTPRINT; 304 break; 305 default: 306 error = EINVAL; 307 break; 308 } 309 } 310 break; 311 case APM_IOC_DEV_CTL: 312 if ((flag & FWRITE) == 0) 313 error = EBADF; 314 break; 315 case APM_IOC_GETPOWER: 316 power = (struct apm_power_info *)data; 317 318 pm_battery_info(0, &batt); 319 320 power->ac_state = ((batt.flags & PMU_PWR_AC_PRESENT) ? 321 APM_AC_ON : APM_AC_OFF); 322 power->battery_life = 323 ((batt.cur_charge * 100) / batt.max_charge); 324 325 /* 326 * If the battery is charging, return the minutes left until 327 * charging is complete. apmd knows this. 328 */ 329 330 if (!(batt.flags & PMU_PWR_BATT_PRESENT)) { 331 power->battery_state = APM_BATT_UNKNOWN; 332 power->minutes_left = 0; 333 power->battery_life = 0; 334 } else if ((power->ac_state == APM_AC_ON) && 335 (batt.draw > 0)) { 336 power->minutes_left = batt.secs_remaining / 60; 337 power->battery_state = APM_BATT_CHARGING; 338 } else { 339 power->minutes_left = batt.secs_remaining / 60; 340 341 /* XXX - Arbitrary */ 342 if (power->battery_life > 60) { 343 power->battery_state = APM_BATT_HIGH; 344 } else if (power->battery_life < 10) { 345 power->battery_state = APM_BATT_CRITICAL; 346 } else { 347 power->battery_state = APM_BATT_LOW; 348 } 349 } 350 351 break; 352 353 default: 354 error = ENOTTY; 355 } 356 APM_UNLOCK(sc); 357 358 return error; 359} 360 361#ifdef __NetBSD__ 362#if 0 363/* 364 * return 0 if the user will notice and handle the event, 365 * return 1 if the kernel driver should do so. 366 */ 367static int 368apm_record_event(struct apm_softc *sc, u_int event_type) 369{ 370 struct apm_event_info *evp; 371 372 if ((sc->sc_flags & SCFLAG_OPEN) == 0) 373 return 1; /* no user waiting */ 374 if (sc->event_count == APM_NEVENTS) { 375 DPRINTF(("apm_record_event: queue full!\n")); 376 return 1; /* overflow */ 377 } 378 evp = &sc->event_list[sc->event_ptr]; 379 sc->event_count++; 380 sc->event_ptr++; 381 sc->event_ptr %= APM_NEVENTS; 382 evp->type = event_type; 383 evp->index = ++apm_evindex; 384 selnotify(&sc->sc_rsel, 0, 0); 385 return (sc->sc_flags & SCFLAG_OWRITE) ? 0 : 1; /* user may handle */ 386} 387#endif 388 389int 390apmpoll(dev_t dev, int events, struct lwp *l) 391{ 392 struct apm_softc *sc = device_lookup_private(&apm_cd,APMUNIT(dev)); 393 int revents = 0; 394 395 APM_LOCK(sc); 396 if (events & (POLLIN | POLLRDNORM)) { 397 if (sc->event_count) 398 revents |= events & (POLLIN | POLLRDNORM); 399 else 400 selrecord(l, &sc->sc_rsel); 401 } 402 APM_UNLOCK(sc); 403 404 return (revents); 405} 406#endif 407 408static void 409filt_apmrdetach(struct knote *kn) 410{ 411 struct apm_softc *sc = (struct apm_softc *)kn->kn_hook; 412 413 APM_LOCK(sc); 414 SLIST_REMOVE(&sc->sc_rsel.sel_klist, kn, knote, kn_selnext); 415 APM_UNLOCK(sc); 416} 417 418static int 419filt_apmread(struct knote *kn, long hint) 420{ 421 struct apm_softc *sc = kn->kn_hook; 422 423 kn->kn_data = sc->event_count; 424 return (kn->kn_data > 0); 425} 426 427static struct filterops apmread_filtops = 428 { 1, NULL, filt_apmrdetach, filt_apmread}; 429 430int 431apmkqfilter(dev_t dev, struct knote *kn) 432{ 433 struct apm_softc *sc = device_lookup_private(&apm_cd,APMUNIT(dev)); 434 struct klist *klist; 435 436 switch (kn->kn_filter) { 437 case EVFILT_READ: 438 klist = &sc->sc_rsel.sel_klist; 439 kn->kn_fop = &apmread_filtops; 440 break; 441 default: 442 return (1); 443 } 444 445 kn->kn_hook = sc; 446 447 APM_LOCK(sc); 448 SLIST_INSERT_HEAD(klist, kn, kn_selnext); 449 APM_UNLOCK(sc); 450 451 return (0); 452} 453