apm.c revision 1.19 
1/*	$NetBSD: apm.c,v 1.19 2008/03/01 14:16:49 rmind 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.19 2008/03/01 14:16:49 rmind 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 __P((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(parent, match, aux)
164	struct device *parent;
165	struct cfdata *match;
166	void *aux;
167{
168	struct adb_attach_args *aa = (void *)aux;
169	if (aa->origaddr != ADBADDR_APM ||
170	    aa->handler_id != ADBADDR_APM ||
171	    aa->adbaddr != ADBADDR_APM)
172		return 0;
173
174	if (adbHardware != ADB_HW_PMU)
175		return 0;
176
177	return 1;
178}
179
180void
181apmattach(parent, self, aux)
182	struct device *parent, *self;
183	void *aux;
184{
185	struct apm_softc *sc = (struct apm_softc *) self;
186	struct pmu_battery_info info;
187
188	pm_battery_info(0, &info);
189
190	printf(": battery flags 0x%X, ", info.flags);
191	printf("%d%% charged\n", ((info.cur_charge * 100) / info.max_charge));
192
193	sc->sc_flags = 0;
194	sc->event_ptr = 0;
195	sc->event_count = 0;
196	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
197	selinit(&sc->sc_rsel);
198}
199
200int
201apmopen(dev, flag, mode, l)
202	dev_t dev;
203	int flag, mode;
204	struct lwp *l;
205{
206	struct apm_softc *sc;
207	int error = 0;
208
209	/* apm0 only */
210	if (!apm_cd.cd_ndevs || APMUNIT(dev) != 0 ||
211	    !(sc = apm_cd.cd_devs[APMUNIT(dev)]))
212		return ENXIO;
213
214	DPRINTF(("apmopen: dev %d pid %d flag %x mode %x\n",
215	    APMDEV(dev), l->l_proc->p_pid, flag, mode));
216
217	APM_LOCK(sc);
218	switch (APMDEV(dev)) {
219	case APMDEV_CTL:
220		if (!(flag & FWRITE)) {
221			error = EINVAL;
222			break;
223		}
224		if (sc->sc_flags & SCFLAG_OWRITE) {
225			error = EBUSY;
226			break;
227		}
228		sc->sc_flags |= SCFLAG_OWRITE;
229		break;
230	case APMDEV_NORMAL:
231		if (!(flag & FREAD) || (flag & FWRITE)) {
232			error = EINVAL;
233			break;
234		}
235		sc->sc_flags |= SCFLAG_OREAD;
236		break;
237	default:
238		error = ENXIO;
239		break;
240	}
241	APM_UNLOCK(sc);
242	return error;
243}
244
245int
246apmclose(dev, flag, mode, l)
247	dev_t dev;
248	int flag, mode;
249	struct lwp *l;
250{
251	struct apm_softc *sc;
252
253	/* apm0 only */
254	if (!apm_cd.cd_ndevs || APMUNIT(dev) != 0 ||
255	    !(sc = apm_cd.cd_devs[APMUNIT(dev)]))
256		return ENXIO;
257
258	DPRINTF(("apmclose: pid %d flag %x mode %x\n", l->l_proc->p_pid, flag, mode));
259
260	APM_LOCK(sc);
261	switch (APMDEV(dev)) {
262	case APMDEV_CTL:
263		sc->sc_flags &= ~SCFLAG_OWRITE;
264		break;
265	case APMDEV_NORMAL:
266		sc->sc_flags &= ~SCFLAG_OREAD;
267		break;
268	}
269	APM_UNLOCK(sc);
270	return 0;
271}
272
273int
274apmioctl(dev, cmd, data, flag, l)
275	dev_t dev;
276	u_long cmd;
277	void *data;
278	int flag;
279	struct lwp *l;
280{
281	struct apm_softc *sc;
282	struct pmu_battery_info batt;
283	struct apm_power_info *power;
284	int error = 0;
285
286	/* apm0 only */
287	if (!apm_cd.cd_ndevs || APMUNIT(dev) != 0 ||
288	    !(sc = apm_cd.cd_devs[APMUNIT(dev)]))
289		return ENXIO;
290
291	APM_LOCK(sc);
292	switch (cmd) {
293		/* some ioctl names from linux */
294	case APM_IOC_STANDBY:
295		if ((flag & FWRITE) == 0)
296			error = EBADF;
297	case APM_IOC_SUSPEND:
298		if ((flag & FWRITE) == 0)
299			error = EBADF;
300		break;
301	case APM_IOC_PRN_CTL:
302		if ((flag & FWRITE) == 0)
303			error = EBADF;
304		else {
305			int op = *(int *)data;
306			DPRINTF(( "APM_IOC_PRN_CTL: %d\n", op ));
307			switch (op) {
308			case APM_PRINT_ON:	/* enable printing */
309				sc->sc_flags &= ~SCFLAG_PRINT;
310				break;
311			case APM_PRINT_OFF: /* disable printing */
312				sc->sc_flags &= ~SCFLAG_PRINT;
313				sc->sc_flags |= SCFLAG_NOPRINT;
314				break;
315			case APM_PRINT_PCT: /* disable some printing */
316				sc->sc_flags &= ~SCFLAG_PRINT;
317				sc->sc_flags |= SCFLAG_PCTPRINT;
318				break;
319			default:
320				error = EINVAL;
321				break;
322			}
323		}
324		break;
325	case APM_IOC_DEV_CTL:
326		if ((flag & FWRITE) == 0)
327			error = EBADF;
328		break;
329	case APM_IOC_GETPOWER:
330	        power = (struct apm_power_info *)data;
331
332		pm_battery_info(0, &batt);
333
334		power->ac_state = ((batt.flags & PMU_PWR_AC_PRESENT) ?
335		    APM_AC_ON : APM_AC_OFF);
336		power->battery_life =
337		    ((batt.cur_charge * 100) / batt.max_charge);
338
339		/*
340		 * If the battery is charging, return the minutes left until
341		 * charging is complete. apmd knows this.
342		 */
343
344		if (!(batt.flags & PMU_PWR_BATT_PRESENT)) {
345			power->battery_state = APM_BATT_UNKNOWN;
346			power->minutes_left = 0;
347			power->battery_life = 0;
348		} else if ((power->ac_state == APM_AC_ON) &&
349			   (batt.draw > 0)) {
350			power->minutes_left = batt.secs_remaining / 60;
351			power->battery_state = APM_BATT_CHARGING;
352		} else {
353			power->minutes_left = batt.secs_remaining / 60;
354
355			/* XXX - Arbitrary */
356			if (power->battery_life > 60) {
357				power->battery_state = APM_BATT_HIGH;
358			} else if (power->battery_life < 10) {
359				power->battery_state = APM_BATT_CRITICAL;
360			} else {
361				power->battery_state = APM_BATT_LOW;
362			}
363		}
364
365		break;
366
367	default:
368		error = ENOTTY;
369	}
370	APM_UNLOCK(sc);
371
372	return error;
373}
374
375#ifdef __NetBSD__
376#if 0
377/*
378 * return 0 if the user will notice and handle the event,
379 * return 1 if the kernel driver should do so.
380 */
381static int
382apm_record_event(sc, event_type)
383	struct apm_softc *sc;
384	u_int event_type;
385{
386	struct apm_event_info *evp;
387
388	if ((sc->sc_flags & SCFLAG_OPEN) == 0)
389		return 1;		/* no user waiting */
390	if (sc->event_count == APM_NEVENTS) {
391		DPRINTF(("apm_record_event: queue full!\n"));
392		return 1;			/* overflow */
393	}
394	evp = &sc->event_list[sc->event_ptr];
395	sc->event_count++;
396	sc->event_ptr++;
397	sc->event_ptr %= APM_NEVENTS;
398	evp->type = event_type;
399	evp->index = ++apm_evindex;
400	selnotify(&sc->sc_rsel, 0, 0);
401	return (sc->sc_flags & SCFLAG_OWRITE) ? 0 : 1; /* user may handle */
402}
403#endif
404
405int
406apmpoll(dev, events, l)
407	dev_t dev;
408	int events;
409	struct lwp *l;
410{
411	struct apm_softc *sc = apm_cd.cd_devs[APMUNIT(dev)];
412	int revents = 0;
413
414	APM_LOCK(sc);
415	if (events & (POLLIN | POLLRDNORM)) {
416		if (sc->event_count)
417			revents |= events & (POLLIN | POLLRDNORM);
418		else
419			selrecord(l, &sc->sc_rsel);
420	}
421	APM_UNLOCK(sc);
422
423	return (revents);
424}
425#endif
426
427static void
428filt_apmrdetach(struct knote *kn)
429{
430	struct apm_softc *sc = (struct apm_softc *)kn->kn_hook;
431
432	APM_LOCK(sc);
433	SLIST_REMOVE(&sc->sc_rsel.sel_klist, kn, knote, kn_selnext);
434	APM_UNLOCK(sc);
435}
436
437static int
438filt_apmread(struct knote *kn, long hint)
439{
440	struct apm_softc *sc = kn->kn_hook;
441
442	kn->kn_data = sc->event_count;
443	return (kn->kn_data > 0);
444}
445
446static struct filterops apmread_filtops =
447	{ 1, NULL, filt_apmrdetach, filt_apmread};
448
449int
450apmkqfilter(dev, kn)
451	dev_t dev;
452	struct knote *kn;
453{
454	struct apm_softc *sc = apm_cd.cd_devs[APMUNIT(dev)];
455	struct klist *klist;
456
457	switch (kn->kn_filter) {
458	case EVFILT_READ:
459		klist = &sc->sc_rsel.sel_klist;
460		kn->kn_fop = &apmread_filtops;
461		break;
462	default:
463		return (1);
464	}
465
466	kn->kn_hook = sc;
467
468	APM_LOCK(sc);
469	SLIST_INSERT_HEAD(klist, kn, kn_selnext);
470	APM_UNLOCK(sc);
471
472	return (0);
473}
474