xref: /freebsd/sys/powerpc/powermac/pmu.c (revision 4f52dfbb8d6c4d446500c5b097e3806ec219fbd4)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2006 Michael Lorenz
5  * Copyright 2008 by Nathan Whitehorn
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 AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
22  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
24  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25  * 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 __FBSDID("$FreeBSD$");
33 
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/module.h>
37 #include <sys/bus.h>
38 #include <sys/conf.h>
39 #include <sys/kernel.h>
40 #include <sys/kthread.h>
41 #include <sys/clock.h>
42 #include <sys/proc.h>
43 #include <sys/reboot.h>
44 #include <sys/sysctl.h>
45 
46 #include <dev/ofw/ofw_bus.h>
47 #include <dev/ofw/openfirm.h>
48 #include <dev/led/led.h>
49 
50 #include <machine/_inttypes.h>
51 #include <machine/bus.h>
52 #include <machine/cpu.h>
53 #include <machine/hid.h>
54 #include <machine/intr_machdep.h>
55 #include <machine/md_var.h>
56 #include <machine/pcb.h>
57 #include <machine/pio.h>
58 #include <machine/resource.h>
59 
60 #include <vm/vm.h>
61 #include <vm/pmap.h>
62 
63 #include <sys/rman.h>
64 
65 #include <dev/adb/adb.h>
66 
67 #include "clock_if.h"
68 #include "pmuvar.h"
69 #include "viareg.h"
70 #include "uninorthvar.h"	/* For unin_chip_sleep()/unin_chip_wake() */
71 
72 #define PMU_DEFAULTS	PMU_INT_TICK | PMU_INT_ADB | \
73 	PMU_INT_PCEJECT | PMU_INT_SNDBRT | \
74 	PMU_INT_BATTERY | PMU_INT_ENVIRONMENT
75 
76 /*
77  * Bus interface
78  */
79 static int	pmu_probe(device_t);
80 static int	pmu_attach(device_t);
81 static int	pmu_detach(device_t);
82 
83 /*
84  * Clock interface
85  */
86 static int	pmu_gettime(device_t dev, struct timespec *ts);
87 static int	pmu_settime(device_t dev, struct timespec *ts);
88 
89 /*
90  * ADB Interface
91  */
92 
93 static u_int	pmu_adb_send(device_t dev, u_char command_byte, int len,
94 		    u_char *data, u_char poll);
95 static u_int	pmu_adb_autopoll(device_t dev, uint16_t mask);
96 static u_int	pmu_poll(device_t dev);
97 
98 /*
99  * Power interface
100  */
101 
102 static void	pmu_shutdown(void *xsc, int howto);
103 static void	pmu_set_sleepled(void *xsc, int onoff);
104 static int	pmu_server_mode(SYSCTL_HANDLER_ARGS);
105 static int	pmu_acline_state(SYSCTL_HANDLER_ARGS);
106 static int	pmu_query_battery(struct pmu_softc *sc, int batt,
107 		    struct pmu_battstate *info);
108 static int	pmu_battquery_sysctl(SYSCTL_HANDLER_ARGS);
109 static int	pmu_battmon(SYSCTL_HANDLER_ARGS);
110 static void	pmu_battquery_proc(void);
111 static void	pmu_battery_notify(struct pmu_battstate *batt,
112 		    struct pmu_battstate *old);
113 
114 /*
115  * List of battery-related sysctls we might ask for
116  */
117 
118 enum {
119 	PMU_BATSYSCTL_PRESENT	= 1 << 8,
120 	PMU_BATSYSCTL_CHARGING	= 2 << 8,
121 	PMU_BATSYSCTL_CHARGE	= 3 << 8,
122 	PMU_BATSYSCTL_MAXCHARGE = 4 << 8,
123 	PMU_BATSYSCTL_CURRENT	= 5 << 8,
124 	PMU_BATSYSCTL_VOLTAGE	= 6 << 8,
125 	PMU_BATSYSCTL_TIME	= 7 << 8,
126 	PMU_BATSYSCTL_LIFE	= 8 << 8
127 };
128 
129 static device_method_t  pmu_methods[] = {
130 	/* Device interface */
131 	DEVMETHOD(device_probe,		pmu_probe),
132 	DEVMETHOD(device_attach,	pmu_attach),
133         DEVMETHOD(device_detach,        pmu_detach),
134         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
135 
136 	/* ADB bus interface */
137 	DEVMETHOD(adb_hb_send_raw_packet,   pmu_adb_send),
138 	DEVMETHOD(adb_hb_controller_poll,   pmu_poll),
139 	DEVMETHOD(adb_hb_set_autopoll_mask, pmu_adb_autopoll),
140 
141 	/* Clock interface */
142 	DEVMETHOD(clock_gettime,	pmu_gettime),
143 	DEVMETHOD(clock_settime,	pmu_settime),
144 
145 	DEVMETHOD_END
146 };
147 
148 static driver_t pmu_driver = {
149 	"pmu",
150 	pmu_methods,
151 	sizeof(struct pmu_softc),
152 };
153 
154 static devclass_t pmu_devclass;
155 
156 DRIVER_MODULE(pmu, macio, pmu_driver, pmu_devclass, 0, 0);
157 DRIVER_MODULE(adb, pmu, adb_driver, adb_devclass, 0, 0);
158 
159 static int	pmuextint_probe(device_t);
160 static int	pmuextint_attach(device_t);
161 
162 static device_method_t  pmuextint_methods[] = {
163 	/* Device interface */
164 	DEVMETHOD(device_probe,		pmuextint_probe),
165 	DEVMETHOD(device_attach,	pmuextint_attach),
166 
167 	{0,0}
168 };
169 
170 static driver_t pmuextint_driver = {
171 	"pmuextint",
172 	pmuextint_methods,
173 	0
174 };
175 
176 static devclass_t pmuextint_devclass;
177 
178 DRIVER_MODULE(pmuextint, macgpio, pmuextint_driver, pmuextint_devclass, 0, 0);
179 
180 /* Make sure uhid is loaded, as it turns off some of the ADB emulation */
181 MODULE_DEPEND(pmu, usb, 1, 1, 1);
182 
183 static void pmu_intr(void *arg);
184 static void pmu_in(struct pmu_softc *sc);
185 static void pmu_out(struct pmu_softc *sc);
186 static void pmu_ack_on(struct pmu_softc *sc);
187 static void pmu_ack_off(struct pmu_softc *sc);
188 static int pmu_send(void *cookie, int cmd, int length, uint8_t *in_msg,
189 	int rlen, uint8_t *out_msg);
190 static uint8_t pmu_read_reg(struct pmu_softc *sc, u_int offset);
191 static void pmu_write_reg(struct pmu_softc *sc, u_int offset, uint8_t value);
192 static int pmu_intr_state(struct pmu_softc *);
193 
194 /* these values shows that number of data returned after 'send' cmd is sent */
195 static signed char pm_send_cmd_type[] = {
196 	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
197 	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
198 	0x01, 0x01,   -1,   -1,   -1,   -1,   -1,   -1,
199 	0x00, 0x00,   -1,   -1,   -1,   -1,   -1, 0x00,
200 	  -1, 0x00, 0x02, 0x01, 0x01,   -1,   -1,   -1,
201 	0x00,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
202 	0x04, 0x14,   -1, 0x03,   -1,   -1,   -1,   -1,
203 	0x00, 0x00, 0x02, 0x02,   -1,   -1,   -1,   -1,
204 	0x01, 0x01,   -1,   -1,   -1,   -1,   -1,   -1,
205 	0x00, 0x00,   -1,   -1, 0x01,   -1,   -1,   -1,
206 	0x01, 0x00, 0x02, 0x02,   -1, 0x01, 0x03, 0x01,
207 	0x00, 0x01, 0x00, 0x00, 0x00,   -1,   -1,   -1,
208 	0x02,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
209 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00,   -1,   -1,
210 	0x01, 0x01, 0x01,   -1,   -1,   -1,   -1,   -1,
211 	0x00, 0x00,   -1,   -1,   -1, 0x05, 0x04, 0x04,
212 	0x04,   -1, 0x00,   -1,   -1,   -1,   -1,   -1,
213 	0x00,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
214 	0x01, 0x02,   -1,   -1,   -1,   -1,   -1,   -1,
215 	0x00, 0x00,   -1,   -1,   -1,   -1,   -1,   -1,
216 	0x02, 0x02, 0x02, 0x04,   -1, 0x00,   -1,   -1,
217 	0x01, 0x01, 0x03, 0x02,   -1,   -1,   -1,   -1,
218 	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
219 	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
220 	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
221 	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
222 	0x00,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
223 	0x01, 0x01,   -1,   -1, 0x00, 0x00,   -1,   -1,
224 	  -1, 0x04, 0x00,   -1,   -1,   -1,   -1,   -1,
225 	0x03,   -1, 0x00,   -1, 0x00,   -1,   -1, 0x00,
226 	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
227 	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1
228 };
229 
230 /* these values shows that number of data returned after 'receive' cmd is sent */
231 static signed char pm_receive_cmd_type[] = {
232 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
233 	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
234 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
235 	0x02, 0x02,   -1,   -1,   -1,   -1,   -1, 0x00,
236 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
237 	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
238 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
239 	0x05, 0x15,   -1, 0x02,   -1,   -1,   -1,   -1,
240 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
241 	0x02, 0x02,   -1,   -1,   -1,   -1,   -1,   -1,
242 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
243 	0x02, 0x00, 0x03, 0x03,   -1,   -1,   -1,   -1,
244 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
245 	0x04, 0x04, 0x03, 0x09,   -1,   -1,   -1,   -1,
246 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
247 	  -1,   -1,   -1,   -1,   -1, 0x01, 0x01, 0x01,
248 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
249 	0x06,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
250 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
251 	0x02, 0x02,   -1,   -1,   -1,   -1,   -1,   -1,
252 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
253 	0x02, 0x00, 0x00, 0x00,   -1,   -1,   -1,   -1,
254 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
255 	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
256 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
257 	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
258 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
259 	0x02, 0x02,   -1,   -1, 0x02,   -1,   -1,   -1,
260 	0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
261 	  -1,   -1, 0x02,   -1,   -1,   -1,   -1, 0x00,
262 	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
263 	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
264 };
265 
266 static int pmu_battmon_enabled = 1;
267 static struct proc *pmubattproc;
268 static struct kproc_desc pmu_batt_kp = {
269 	"pmu_batt",
270 	pmu_battquery_proc,
271 	&pmubattproc
272 };
273 
274 /* We only have one of each device, so globals are safe */
275 static device_t pmu = NULL;
276 static device_t pmu_extint = NULL;
277 
278 static int
279 pmuextint_probe(device_t dev)
280 {
281 	const char *type = ofw_bus_get_type(dev);
282 
283 	if (strcmp(type, "extint-gpio1") != 0)
284                 return (ENXIO);
285 
286 	device_set_desc(dev, "Apple PMU99 External Interrupt");
287 	return (0);
288 }
289 
290 static int
291 pmu_probe(device_t dev)
292 {
293 	const char *type = ofw_bus_get_type(dev);
294 
295 	if (strcmp(type, "via-pmu") != 0)
296                 return (ENXIO);
297 
298 	device_set_desc(dev, "Apple PMU99 Controller");
299 	return (0);
300 }
301 
302 
303 static int
304 setup_pmu_intr(device_t dev, device_t extint)
305 {
306 	struct pmu_softc *sc;
307 	sc = device_get_softc(dev);
308 
309 	sc->sc_irqrid = 0;
310 	sc->sc_irq = bus_alloc_resource_any(extint, SYS_RES_IRQ, &sc->sc_irqrid,
311            	RF_ACTIVE);
312         if (sc->sc_irq == NULL) {
313                 device_printf(dev, "could not allocate interrupt\n");
314                 return (ENXIO);
315         }
316 
317 	if (bus_setup_intr(dev, sc->sc_irq, INTR_TYPE_MISC | INTR_MPSAFE
318 	    | INTR_ENTROPY, NULL, pmu_intr, dev, &sc->sc_ih) != 0) {
319                 device_printf(dev, "could not setup interrupt\n");
320                 bus_release_resource(dev, SYS_RES_IRQ, sc->sc_irqrid,
321                     sc->sc_irq);
322                 return (ENXIO);
323         }
324 
325 	return (0);
326 }
327 
328 static int
329 pmuextint_attach(device_t dev)
330 {
331 	pmu_extint = dev;
332 	if (pmu)
333 		return (setup_pmu_intr(pmu,dev));
334 
335 	return (0);
336 }
337 
338 static int
339 pmu_attach(device_t dev)
340 {
341 	struct pmu_softc *sc;
342 
343 	int i;
344 	uint8_t reg;
345 	uint8_t cmd[2] = {2, 0};
346 	uint8_t resp[16];
347 	phandle_t node,child;
348 	struct sysctl_ctx_list *ctx;
349 	struct sysctl_oid *tree;
350 
351 	sc = device_get_softc(dev);
352 	sc->sc_dev = dev;
353 
354 	sc->sc_memrid = 0;
355 	sc->sc_memr = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
356 		          &sc->sc_memrid, RF_ACTIVE);
357 
358 	mtx_init(&sc->sc_mutex,"pmu",NULL,MTX_DEF | MTX_RECURSE);
359 
360 	if (sc->sc_memr == NULL) {
361 		device_printf(dev, "Could not alloc mem resource!\n");
362 		return (ENXIO);
363 	}
364 
365 	/*
366 	 * Our interrupt is attached to a GPIO pin. Depending on probe order,
367 	 * we may not have found it yet. If we haven't, it will find us, and
368 	 * attach our interrupt then.
369 	 */
370 	pmu = dev;
371 	if (pmu_extint != NULL) {
372 		if (setup_pmu_intr(dev,pmu_extint) != 0)
373 			return (ENXIO);
374 	}
375 
376 	sc->sc_autopoll = 0;
377 	sc->sc_batteries = 0;
378 	sc->adb_bus = NULL;
379 	sc->sc_leddev = NULL;
380 
381 	/* Init PMU */
382 
383 	pmu_write_reg(sc, vBufB, pmu_read_reg(sc, vBufB) | vPB4);
384 	pmu_write_reg(sc, vDirB, (pmu_read_reg(sc, vDirB) | vPB4) & ~vPB3);
385 
386 	reg = PMU_DEFAULTS;
387 	pmu_send(sc, PMU_SET_IMASK, 1, &reg, 16, resp);
388 
389 	pmu_write_reg(sc, vIER, 0x94); /* make sure VIA interrupts are on */
390 
391 	pmu_send(sc, PMU_SYSTEM_READY, 1, cmd, 16, resp);
392 	pmu_send(sc, PMU_GET_VERSION, 0, cmd, 16, resp);
393 
394 	/* Initialize child buses (ADB) */
395 	node = ofw_bus_get_node(dev);
396 
397 	for (child = OF_child(node); child != 0; child = OF_peer(child)) {
398 		char name[32];
399 
400 		memset(name, 0, sizeof(name));
401 		OF_getprop(child, "name", name, sizeof(name));
402 
403 		if (bootverbose)
404 			device_printf(dev, "PMU child <%s>\n",name);
405 
406 		if (strncmp(name, "adb", 4) == 0) {
407 			sc->adb_bus = device_add_child(dev,"adb",-1);
408 		}
409 
410 		if (strncmp(name, "power-mgt", 9) == 0) {
411 			uint32_t prim_info[9];
412 
413 			if (OF_getprop(child, "prim-info", prim_info,
414 			    sizeof(prim_info)) >= 7)
415 				sc->sc_batteries = (prim_info[6] >> 16) & 0xff;
416 
417 			if (bootverbose && sc->sc_batteries > 0)
418 				device_printf(dev, "%d batteries detected\n",
419 				    sc->sc_batteries);
420 		}
421 	}
422 
423 	/*
424 	 * Set up sysctls
425 	 */
426 
427 	ctx = device_get_sysctl_ctx(dev);
428 	tree = device_get_sysctl_tree(dev);
429 
430 	SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
431 	    "server_mode", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
432 	    pmu_server_mode, "I", "Enable reboot after power failure");
433 
434 	if (sc->sc_batteries > 0) {
435 		struct sysctl_oid *oid, *battroot;
436 		char battnum[2];
437 
438 		/* Only start the battery monitor if we have a battery. */
439 		kproc_start(&pmu_batt_kp);
440 		SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
441 		    "monitor_batteries", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
442 		    pmu_battmon, "I", "Post battery events to devd");
443 
444 
445 		SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
446 		    "acline", CTLTYPE_INT | CTLFLAG_RD, sc, 0,
447 		    pmu_acline_state, "I", "AC Line Status");
448 
449 		battroot = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
450 		    "batteries", CTLFLAG_RD, 0, "Battery Information");
451 
452 		for (i = 0; i < sc->sc_batteries; i++) {
453 			battnum[0] = i + '0';
454 			battnum[1] = '\0';
455 
456 			oid = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(battroot),
457 			    OID_AUTO, battnum, CTLFLAG_RD, 0,
458 			    "Battery Information");
459 
460 			SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
461 			    "present", CTLTYPE_INT | CTLFLAG_RD, sc,
462 			    PMU_BATSYSCTL_PRESENT | i, pmu_battquery_sysctl,
463 			    "I", "Battery present");
464 			SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
465 			    "charging", CTLTYPE_INT | CTLFLAG_RD, sc,
466 			    PMU_BATSYSCTL_CHARGING | i, pmu_battquery_sysctl,
467 			    "I", "Battery charging");
468 			SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
469 			    "charge", CTLTYPE_INT | CTLFLAG_RD, sc,
470 			    PMU_BATSYSCTL_CHARGE | i, pmu_battquery_sysctl,
471 			    "I", "Battery charge (mAh)");
472 			SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
473 			    "maxcharge", CTLTYPE_INT | CTLFLAG_RD, sc,
474 			    PMU_BATSYSCTL_MAXCHARGE | i, pmu_battquery_sysctl,
475 			    "I", "Maximum battery capacity (mAh)");
476 			SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
477 			    "rate", CTLTYPE_INT | CTLFLAG_RD, sc,
478 			    PMU_BATSYSCTL_CURRENT | i, pmu_battquery_sysctl,
479 			    "I", "Battery discharge rate (mA)");
480 			SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
481 			    "voltage", CTLTYPE_INT | CTLFLAG_RD, sc,
482 			    PMU_BATSYSCTL_VOLTAGE | i, pmu_battquery_sysctl,
483 			    "I", "Battery voltage (mV)");
484 
485 			/* Knobs for mental compatibility with ACPI */
486 
487 			SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
488 			    "time", CTLTYPE_INT | CTLFLAG_RD, sc,
489 			    PMU_BATSYSCTL_TIME | i, pmu_battquery_sysctl,
490 			    "I", "Time Remaining (minutes)");
491 			SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
492 			    "life", CTLTYPE_INT | CTLFLAG_RD, sc,
493 			    PMU_BATSYSCTL_LIFE | i, pmu_battquery_sysctl,
494 			    "I", "Capacity remaining (percent)");
495 		}
496 	}
497 
498 	/*
499 	 * Set up LED interface
500 	 */
501 
502 	sc->sc_leddev = led_create(pmu_set_sleepled, sc, "sleepled");
503 
504 	/*
505 	 * Register RTC
506 	 */
507 
508 	clock_register(dev, 1000);
509 
510 	/*
511 	 * Register power control handler
512 	 */
513 	EVENTHANDLER_REGISTER(shutdown_final, pmu_shutdown, sc,
514 	    SHUTDOWN_PRI_LAST);
515 
516 	return (bus_generic_attach(dev));
517 }
518 
519 static int
520 pmu_detach(device_t dev)
521 {
522 	struct pmu_softc *sc;
523 
524 	sc = device_get_softc(dev);
525 
526 	if (sc->sc_leddev != NULL)
527 		led_destroy(sc->sc_leddev);
528 
529 	bus_teardown_intr(dev, sc->sc_irq, sc->sc_ih);
530 	bus_release_resource(dev, SYS_RES_IRQ, sc->sc_irqrid, sc->sc_irq);
531 	bus_release_resource(dev, SYS_RES_MEMORY, sc->sc_memrid, sc->sc_memr);
532 	mtx_destroy(&sc->sc_mutex);
533 
534 	return (bus_generic_detach(dev));
535 }
536 
537 static uint8_t
538 pmu_read_reg(struct pmu_softc *sc, u_int offset)
539 {
540 	return (bus_read_1(sc->sc_memr, offset));
541 }
542 
543 static void
544 pmu_write_reg(struct pmu_softc *sc, u_int offset, uint8_t value)
545 {
546 	bus_write_1(sc->sc_memr, offset, value);
547 }
548 
549 static int
550 pmu_send_byte(struct pmu_softc *sc, uint8_t data)
551 {
552 
553 	pmu_out(sc);
554 	pmu_write_reg(sc, vSR, data);
555 	pmu_ack_off(sc);
556 	/* wait for intr to come up */
557 	/* XXX should add a timeout and bail if it expires */
558 	do {} while (pmu_intr_state(sc) == 0);
559 	pmu_ack_on(sc);
560 	do {} while (pmu_intr_state(sc));
561 	pmu_ack_on(sc);
562 	return 0;
563 }
564 
565 static inline int
566 pmu_read_byte(struct pmu_softc *sc, uint8_t *data)
567 {
568 	volatile uint8_t scratch;
569 	pmu_in(sc);
570 	scratch = pmu_read_reg(sc, vSR);
571 	pmu_ack_off(sc);
572 	/* wait for intr to come up */
573 	do {} while (pmu_intr_state(sc) == 0);
574 	pmu_ack_on(sc);
575 	do {} while (pmu_intr_state(sc));
576 	*data = pmu_read_reg(sc, vSR);
577 	return 0;
578 }
579 
580 static int
581 pmu_intr_state(struct pmu_softc *sc)
582 {
583 	return ((pmu_read_reg(sc, vBufB) & vPB3) == 0);
584 }
585 
586 static int
587 pmu_send(void *cookie, int cmd, int length, uint8_t *in_msg, int rlen,
588     uint8_t *out_msg)
589 {
590 	struct pmu_softc *sc = cookie;
591 	int i, rcv_len = -1;
592 	uint8_t out_len, intreg;
593 
594 	intreg = pmu_read_reg(sc, vIER);
595 	intreg &= 0x10;
596 	pmu_write_reg(sc, vIER, intreg);
597 
598 	/* wait idle */
599 	do {} while (pmu_intr_state(sc));
600 
601 	/* send command */
602 	pmu_send_byte(sc, cmd);
603 
604 	/* send length if necessary */
605 	if (pm_send_cmd_type[cmd] < 0) {
606 		pmu_send_byte(sc, length);
607 	}
608 
609 	for (i = 0; i < length; i++) {
610 		pmu_send_byte(sc, in_msg[i]);
611 	}
612 
613 	/* see if there's data to read */
614 	rcv_len = pm_receive_cmd_type[cmd];
615 	if (rcv_len == 0)
616 		goto done;
617 
618 	/* read command */
619 	if (rcv_len == 1) {
620 		pmu_read_byte(sc, out_msg);
621 		goto done;
622 	} else
623 		out_msg[0] = cmd;
624 	if (rcv_len < 0) {
625 		pmu_read_byte(sc, &out_len);
626 		rcv_len = out_len + 1;
627 	}
628 	for (i = 1; i < min(rcv_len, rlen); i++)
629 		pmu_read_byte(sc, &out_msg[i]);
630 
631 done:
632 	pmu_write_reg(sc, vIER, (intreg == 0) ? 0 : 0x90);
633 
634 	return rcv_len;
635 }
636 
637 
638 static u_int
639 pmu_poll(device_t dev)
640 {
641 	pmu_intr(dev);
642 	return (0);
643 }
644 
645 static void
646 pmu_in(struct pmu_softc *sc)
647 {
648 	uint8_t reg;
649 
650 	reg = pmu_read_reg(sc, vACR);
651 	reg &= ~vSR_OUT;
652 	reg |= 0x0c;
653 	pmu_write_reg(sc, vACR, reg);
654 }
655 
656 static void
657 pmu_out(struct pmu_softc *sc)
658 {
659 	uint8_t reg;
660 
661 	reg = pmu_read_reg(sc, vACR);
662 	reg |= vSR_OUT;
663 	reg |= 0x0c;
664 	pmu_write_reg(sc, vACR, reg);
665 }
666 
667 static void
668 pmu_ack_off(struct pmu_softc *sc)
669 {
670 	uint8_t reg;
671 
672 	reg = pmu_read_reg(sc, vBufB);
673 	reg &= ~vPB4;
674 	pmu_write_reg(sc, vBufB, reg);
675 }
676 
677 static void
678 pmu_ack_on(struct pmu_softc *sc)
679 {
680 	uint8_t reg;
681 
682 	reg = pmu_read_reg(sc, vBufB);
683 	reg |= vPB4;
684 	pmu_write_reg(sc, vBufB, reg);
685 }
686 
687 static void
688 pmu_intr(void *arg)
689 {
690 	device_t        dev;
691 	struct pmu_softc *sc;
692 
693 	unsigned int len;
694 	uint8_t resp[16];
695 	uint8_t junk[16];
696 
697         dev = (device_t)arg;
698 	sc = device_get_softc(dev);
699 
700 	mtx_lock(&sc->sc_mutex);
701 
702 	pmu_write_reg(sc, vIFR, 0x90);	/* Clear 'em */
703 	len = pmu_send(sc, PMU_INT_ACK, 0, NULL, 16, resp);
704 
705 	mtx_unlock(&sc->sc_mutex);
706 
707 	if ((len < 1) || (resp[1] == 0)) {
708 		return;
709 	}
710 
711 	if (resp[1] & PMU_INT_ADB) {
712 		/*
713 		 * the PMU will turn off autopolling after each command that
714 		 * it did not issue, so we assume any but TALK R0 is ours and
715 		 * re-enable autopoll here whenever we receive an ACK for a
716 		 * non TR0 command.
717 		 */
718 		mtx_lock(&sc->sc_mutex);
719 
720 		if ((resp[2] & 0x0f) != (ADB_COMMAND_TALK << 2)) {
721 			if (sc->sc_autopoll) {
722 				uint8_t cmd[] = {0, PMU_SET_POLL_MASK,
723 				    (sc->sc_autopoll >> 8) & 0xff,
724 				    sc->sc_autopoll & 0xff};
725 
726 				pmu_send(sc, PMU_ADB_CMD, 4, cmd, 16, junk);
727 			}
728 		}
729 
730 		mtx_unlock(&sc->sc_mutex);
731 
732 		adb_receive_raw_packet(sc->adb_bus,resp[1],resp[2],
733 			len - 3,&resp[3]);
734 	}
735 	if (resp[1] & PMU_INT_ENVIRONMENT) {
736 		/* if the lid was just closed, notify devd. */
737 		if ((resp[2] & PMU_ENV_LID_CLOSED) && (!sc->lid_closed)) {
738 			sc->lid_closed = 1;
739 			devctl_notify("PMU", "lid", "close", NULL);
740 		}
741 		else if (!(resp[2] & PMU_ENV_LID_CLOSED) && (sc->lid_closed)) {
742 			/* if the lid was just opened, notify devd. */
743 			sc->lid_closed = 0;
744 			devctl_notify("PMU", "lid", "open", NULL);
745 		}
746 		if (resp[2] & PMU_ENV_POWER)
747 			devctl_notify("PMU", "Button", "pressed", NULL);
748 	}
749 }
750 
751 static u_int
752 pmu_adb_send(device_t dev, u_char command_byte, int len, u_char *data,
753     u_char poll)
754 {
755 	struct pmu_softc *sc = device_get_softc(dev);
756 	int i,replen;
757 	uint8_t packet[16], resp[16];
758 
759 	/* construct an ADB command packet and send it */
760 
761 	packet[0] = command_byte;
762 
763 	packet[1] = 0;
764 	packet[2] = len;
765 	for (i = 0; i < len; i++)
766 		packet[i + 3] = data[i];
767 
768 	mtx_lock(&sc->sc_mutex);
769 	replen = pmu_send(sc, PMU_ADB_CMD, len + 3, packet, 16, resp);
770 	mtx_unlock(&sc->sc_mutex);
771 
772 	if (poll)
773 		pmu_poll(dev);
774 
775 	return 0;
776 }
777 
778 static u_int
779 pmu_adb_autopoll(device_t dev, uint16_t mask)
780 {
781 	struct pmu_softc *sc = device_get_softc(dev);
782 
783 	/* magical incantation to re-enable autopolling */
784 	uint8_t cmd[] = {0, PMU_SET_POLL_MASK, (mask >> 8) & 0xff, mask & 0xff};
785 	uint8_t resp[16];
786 
787 	mtx_lock(&sc->sc_mutex);
788 
789 	if (sc->sc_autopoll == mask) {
790 		mtx_unlock(&sc->sc_mutex);
791 		return 0;
792 	}
793 
794 	sc->sc_autopoll = mask & 0xffff;
795 
796 	if (mask)
797 		pmu_send(sc, PMU_ADB_CMD, 4, cmd, 16, resp);
798 	else
799 		pmu_send(sc, PMU_ADB_POLL_OFF, 0, NULL, 16, resp);
800 
801 	mtx_unlock(&sc->sc_mutex);
802 
803 	return 0;
804 }
805 
806 static void
807 pmu_shutdown(void *xsc, int howto)
808 {
809 	struct pmu_softc *sc = xsc;
810 	uint8_t cmd[] = {'M', 'A', 'T', 'T'};
811 
812 	if (howto & RB_HALT)
813 		pmu_send(sc, PMU_POWER_OFF, 4, cmd, 0, NULL);
814 	else
815 		pmu_send(sc, PMU_RESET_CPU, 0, NULL, 0, NULL);
816 
817 	for (;;);
818 }
819 
820 static void
821 pmu_set_sleepled(void *xsc, int onoff)
822 {
823 	struct pmu_softc *sc = xsc;
824 	uint8_t cmd[] = {4, 0, 0};
825 
826 	cmd[2] = onoff;
827 
828 	mtx_lock(&sc->sc_mutex);
829 	pmu_send(sc, PMU_SET_SLEEPLED, 3, cmd, 0, NULL);
830 	mtx_unlock(&sc->sc_mutex);
831 }
832 
833 static int
834 pmu_server_mode(SYSCTL_HANDLER_ARGS)
835 {
836 	struct pmu_softc *sc = arg1;
837 
838 	u_int server_mode = 0;
839 	uint8_t getcmd[] = {PMU_PWR_GET_POWERUP_EVENTS};
840 	uint8_t setcmd[] = {0, 0, PMU_PWR_WAKEUP_AC_INSERT};
841 	uint8_t resp[3];
842 	int error, len;
843 
844 	mtx_lock(&sc->sc_mutex);
845 	len = pmu_send(sc, PMU_POWER_EVENTS, 1, getcmd, 3, resp);
846 	mtx_unlock(&sc->sc_mutex);
847 
848 	if (len == 3)
849 		server_mode = (resp[2] & PMU_PWR_WAKEUP_AC_INSERT) ? 1 : 0;
850 
851 	error = sysctl_handle_int(oidp, &server_mode, 0, req);
852 
853 	if (len != 3)
854 		return (EINVAL);
855 
856 	if (error || !req->newptr)
857 		return (error);
858 
859 	if (server_mode == 1)
860 		setcmd[0] = PMU_PWR_SET_POWERUP_EVENTS;
861 	else if (server_mode == 0)
862 		setcmd[0] = PMU_PWR_CLR_POWERUP_EVENTS;
863 	else
864 		return (EINVAL);
865 
866 	setcmd[1] = resp[1];
867 
868 	mtx_lock(&sc->sc_mutex);
869 	pmu_send(sc, PMU_POWER_EVENTS, 3, setcmd, 2, resp);
870 	mtx_unlock(&sc->sc_mutex);
871 
872 	return (0);
873 }
874 
875 static int
876 pmu_query_battery(struct pmu_softc *sc, int batt, struct pmu_battstate *info)
877 {
878 	uint8_t reg;
879 	uint8_t resp[16];
880 	int len;
881 
882 	reg = batt + 1;
883 
884 	mtx_lock(&sc->sc_mutex);
885 	len = pmu_send(sc, PMU_SMART_BATTERY_STATE, 1, &reg, 16, resp);
886 	mtx_unlock(&sc->sc_mutex);
887 
888 	if (len < 3)
889 		return (-1);
890 
891 	/* All PMU battery info replies share a common header:
892 	 * Byte 1	Payload Format
893 	 * Byte 2	Battery Flags
894 	 */
895 
896 	info->state = resp[2];
897 
898 	switch (resp[1]) {
899 	case 3:
900 	case 4:
901 		/*
902 		 * Formats 3 and 4 appear to be the same:
903 		 * Byte 3	Charge
904 		 * Byte 4	Max Charge
905 		 * Byte 5	Current
906 		 * Byte 6	Voltage
907 		 */
908 
909 		info->charge = resp[3];
910 		info->maxcharge = resp[4];
911 		/* Current can be positive or negative */
912 		info->current = (int8_t)resp[5];
913 		info->voltage = resp[6];
914 		break;
915 	case 5:
916 		/*
917 		 * Formats 5 is a wider version of formats 3 and 4
918 		 * Byte 3-4	Charge
919 		 * Byte 5-6	Max Charge
920 		 * Byte 7-8	Current
921 		 * Byte 9-10	Voltage
922 		 */
923 
924 		info->charge = (resp[3] << 8) | resp[4];
925 		info->maxcharge = (resp[5] << 8) | resp[6];
926 		/* Current can be positive or negative */
927 		info->current = (int16_t)((resp[7] << 8) | resp[8]);
928 		info->voltage = (resp[9] << 8) | resp[10];
929 		break;
930 	default:
931 		device_printf(sc->sc_dev, "Unknown battery info format (%d)!\n",
932 		    resp[1]);
933 		return (-1);
934 	}
935 
936 	return (0);
937 }
938 
939 static void
940 pmu_battery_notify(struct pmu_battstate *batt, struct pmu_battstate *old)
941 {
942 	char notify_buf[16];
943 	int new_acline, old_acline;
944 
945 	new_acline = (batt->state & PMU_PWR_AC_PRESENT) ? 1 : 0;
946 	old_acline = (old->state & PMU_PWR_AC_PRESENT) ? 1 : 0;
947 
948 	if (new_acline != old_acline) {
949 		snprintf(notify_buf, sizeof(notify_buf),
950 		    "notify=0x%02x", new_acline);
951 		devctl_notify("PMU", "POWER", "ACLINE", notify_buf);
952 	}
953 }
954 
955 static void
956 pmu_battquery_proc()
957 {
958 	struct pmu_softc *sc;
959 	struct pmu_battstate batt;
960 	struct pmu_battstate cur_batt;
961 	int error;
962 
963 	sc = device_get_softc(pmu);
964 
965 	bzero(&cur_batt, sizeof(cur_batt));
966 	while (1) {
967 		kproc_suspend_check(curproc);
968 		error = pmu_query_battery(sc, 0, &batt);
969 		pmu_battery_notify(&batt, &cur_batt);
970 		cur_batt = batt;
971 		pause("pmu_batt", hz);
972 	}
973 }
974 
975 static int
976 pmu_battmon(SYSCTL_HANDLER_ARGS)
977 {
978 	struct pmu_softc *sc;
979 	int error, result;
980 
981 	sc = arg1;
982 	result = pmu_battmon_enabled;
983 
984 	error = sysctl_handle_int(oidp, &result, 0, req);
985 
986 	if (error || !req->newptr)
987 		return (error);
988 
989 	if (!result && pmu_battmon_enabled)
990 		error = kproc_suspend(pmubattproc, hz);
991 	else if (result && pmu_battmon_enabled == 0)
992 		error = kproc_resume(pmubattproc);
993 	pmu_battmon_enabled = (result != 0);
994 
995 	return (error);
996 }
997 
998 static int
999 pmu_acline_state(SYSCTL_HANDLER_ARGS)
1000 {
1001 	struct pmu_softc *sc;
1002 	struct pmu_battstate batt;
1003 	int error, result;
1004 
1005 	sc = arg1;
1006 
1007 	/* The PMU treats the AC line status as a property of the battery */
1008 	error = pmu_query_battery(sc, 0, &batt);
1009 
1010 	if (error != 0)
1011 		return (error);
1012 
1013 	result = (batt.state & PMU_PWR_AC_PRESENT) ? 1 : 0;
1014 	error = sysctl_handle_int(oidp, &result, 0, req);
1015 
1016 	return (error);
1017 }
1018 
1019 static int
1020 pmu_battquery_sysctl(SYSCTL_HANDLER_ARGS)
1021 {
1022 	struct pmu_softc *sc;
1023 	struct pmu_battstate batt;
1024 	int error, result;
1025 
1026 	sc = arg1;
1027 
1028 	error = pmu_query_battery(sc, arg2 & 0x00ff, &batt);
1029 
1030 	if (error != 0)
1031 		return (error);
1032 
1033 	switch (arg2 & 0xff00) {
1034 	case PMU_BATSYSCTL_PRESENT:
1035 		result = (batt.state & PMU_PWR_BATT_PRESENT) ? 1 : 0;
1036 		break;
1037 	case PMU_BATSYSCTL_CHARGING:
1038 		result = (batt.state & PMU_PWR_BATT_CHARGING) ? 1 : 0;
1039 		break;
1040 	case PMU_BATSYSCTL_CHARGE:
1041 		result = batt.charge;
1042 		break;
1043 	case PMU_BATSYSCTL_MAXCHARGE:
1044 		result = batt.maxcharge;
1045 		break;
1046 	case PMU_BATSYSCTL_CURRENT:
1047 		result = batt.current;
1048 		break;
1049 	case PMU_BATSYSCTL_VOLTAGE:
1050 		result = batt.voltage;
1051 		break;
1052 	case PMU_BATSYSCTL_TIME:
1053 		/* Time remaining until full charge/discharge, in minutes */
1054 
1055 		if (batt.current >= 0)
1056 			result = (batt.maxcharge - batt.charge) /* mAh */ * 60
1057 			    / batt.current /* mA */;
1058 		else
1059 			result = (batt.charge /* mAh */ * 60)
1060 			    / (-batt.current /* mA */);
1061 		break;
1062 	case PMU_BATSYSCTL_LIFE:
1063 		/* Battery charge fraction, in percent */
1064 		result = (batt.charge * 100) / batt.maxcharge;
1065 		break;
1066 	default:
1067 		/* This should never happen */
1068 		result = -1;
1069 	}
1070 
1071 	error = sysctl_handle_int(oidp, &result, 0, req);
1072 
1073 	return (error);
1074 }
1075 
1076 #define DIFF19041970	2082844800
1077 
1078 static int
1079 pmu_gettime(device_t dev, struct timespec *ts)
1080 {
1081 	struct pmu_softc *sc = device_get_softc(dev);
1082 	uint8_t resp[16];
1083 	uint32_t sec;
1084 
1085 	mtx_lock(&sc->sc_mutex);
1086 	pmu_send(sc, PMU_READ_RTC, 0, NULL, 16, resp);
1087 	mtx_unlock(&sc->sc_mutex);
1088 
1089 	memcpy(&sec, &resp[1], 4);
1090 	ts->tv_sec = sec - DIFF19041970;
1091 	ts->tv_nsec = 0;
1092 
1093 	return (0);
1094 }
1095 
1096 static int
1097 pmu_settime(device_t dev, struct timespec *ts)
1098 {
1099 	struct pmu_softc *sc = device_get_softc(dev);
1100 	uint32_t sec;
1101 
1102 	sec = ts->tv_sec + DIFF19041970;
1103 
1104 	mtx_lock(&sc->sc_mutex);
1105 	pmu_send(sc, PMU_SET_RTC, sizeof(sec), (uint8_t *)&sec, 0, NULL);
1106 	mtx_unlock(&sc->sc_mutex);
1107 
1108 	return (0);
1109 }
1110 
1111 int
1112 pmu_set_speed(int low_speed)
1113 {
1114 	struct pmu_softc *sc;
1115 	uint8_t sleepcmd[] = {'W', 'O', 'O', 'F', 0};
1116 	uint8_t resp[16];
1117 
1118 	sc = device_get_softc(pmu);
1119 	pmu_write_reg(sc, vIER, 0x10);
1120 	spinlock_enter();
1121 	mtdec(0x7fffffff);
1122 	mb();
1123 	mtdec(0x7fffffff);
1124 
1125 	sleepcmd[4] = low_speed;
1126 	pmu_send(sc, PMU_CPU_SPEED, 5, sleepcmd, 16, resp);
1127 	unin_chip_sleep(NULL, 1);
1128 	platform_sleep();
1129 	unin_chip_wake(NULL);
1130 
1131 	mtdec(1);	/* Force a decrementer exception */
1132 	spinlock_exit();
1133 	pmu_write_reg(sc, vIER, 0x90);
1134 
1135 	return (0);
1136 }
1137