xref: /netbsd/sys/arch/sparc64/dev/psm.c (revision 6550d01e) 
1 /* $NetBSD: psm.c,v 1.7 2008/04/05 13:40:05 cegger Exp $ */
2 /*
3  * Copyright (c) 2006 Itronix Inc.
4  * All rights reserved.
5  *
6  * Ported from Tadpole Solaris sources by Garrett D'Amore for Itronix Inc.
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  * 3. The name of Itronix Inc. may not be used to endorse
17  *    or promote products derived from this software without specific
18  *    prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
24  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
27  * ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30  * POSSIBILITY OF SUCH DAMAGE.
31  */
32 /*
33  * Tadpole-RDI Ultrabook IIi (huxley) power management.  Note that
34  * there is a lot of stuff still missing here, due in part to the confusion
35  * that exists with the NetBSD power management framework.  I'm not wasting
36  * time with APM at this point, and some of sysmon seems "lacking".
37  */
38 #include <sys/cdefs.h>
39 __KERNEL_RCSID(0, "$NetBSD: psm.c,v 1.7 2008/04/05 13:40:05 cegger Exp $");
40 
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/proc.h>
44 #include <sys/kernel.h>
45 #include <sys/kthread.h>
46 #include <sys/types.h>
47 #include <sys/device.h>
48 #include <sys/poll.h>
49 #include <sys/kauth.h>
50 
51 #include <machine/autoconf.h>
52 #include <machine/bus.h>
53 #include <machine/intr.h>
54 
55 #include <dev/ebus/ebusreg.h>
56 #include <dev/ebus/ebusvar.h>
57 
58 #include <dev/sysmon/sysmonvar.h>
59 
60 #include <sparc64/dev/psmreg.h>
61 
62 struct psm_softc {
63 	struct device		sc_dev;
64 	bus_space_tag_t		sc_memt;
65 	bus_space_handle_t	sc_memh;
66 
67 	int			sc_event;
68 	int			sc_flags;
69 	struct sysmon_pswitch	sc_sm_pbutton;
70 	struct sysmon_pswitch	sc_sm_lid;
71 	struct sysmon_pswitch	sc_sm_ac;
72 	struct evcnt		sc_intrcnt;
73 	lwp_t			*sc_thread;
74 };
75 
76 #define	PUT8(sc, r, v)		\
77 	bus_space_write_1(sc->sc_memt, sc->sc_memh, r, v)
78 #define	GET8(sc, r)		\
79 	bus_space_read_1(sc->sc_memt, sc->sc_memh, r)
80 
81 #define	WAIT_DELAY		1000
82 #define	WAIT_RETRIES		1000
83 
84 #define	RESET_DELAY		200
85 #define	CMD_DELAY		10
86 #define	CMD_RETRIES		5
87 
88 #ifdef	DEBUG
89 #define	STATIC
90 #else
91 #define	STATIC	static
92 #endif
93 
94 /* flags indicating state */
95 #define	PSM_FLAG_ACPWR		0x1
96 #define	PSM_FLAG_LIDCLOSED	0x2
97 #define	PSM_FLAG_DOCKED		0x4
98 
99 /* system events -- causes activity in the event thread */
100 #define	PSM_EV_PBUTTON		0x1
101 #define	PSM_EV_LID		0x2
102 #define	PSM_EV_ACPWR		0x4
103 #define	PSM_EV_BATT		0x8
104 #define	PSM_EV_TEMP		0x10
105 
106 STATIC void psm_sysmon_setup(struct psm_softc *);
107 STATIC void psm_event_thread(void *);
108 STATIC int psm_init(struct psm_softc *);
109 STATIC void psm_reset(struct psm_softc *);
110 STATIC void psm_poll_acpower(struct psm_softc *);
111 STATIC int psm_intr(void *);
112 STATIC int psm_misc_rd(struct psm_softc *, uint8_t, uint8_t *);
113 STATIC int psm_misc_wr(struct psm_softc *, uint8_t, uint8_t);
114 STATIC int psm_wait(struct psm_softc *, uint8_t);
115 #if 0
116 STATIC int psm_ecmd_rd16(struct psm_softc *, uint16_t *, uint8_t, uint8_t,
117     uint8_t);
118 #endif
119 STATIC int psm_ecmd_rd8(struct psm_softc *, uint8_t *, uint8_t, uint8_t,
120     uint8_t);
121 STATIC int psm_ecmd_wr8(struct psm_softc *, uint8_t, uint8_t, uint8_t,
122     uint8_t);
123 STATIC int psm_match(struct device *, struct cfdata *, void *);
124 STATIC void psm_attach(struct device *, struct device *, void *);
125 
126 CFATTACH_DECL(psm, sizeof(struct psm_softc),
127     psm_match, psm_attach, NULL, NULL);
128 
129 
130 int
131 psm_match(struct device *parent, struct cfdata *cf, void *aux)
132 {
133 	struct ebus_attach_args *ea = aux;
134 
135 	if (strcmp(ea->ea_name, "psm") != 0)
136 		return (0);
137 	return (1);
138 }
139 
140 void
141 psm_attach(struct device *parent, struct device *self, void *aux)
142 {
143 	struct psm_softc	*sc = (struct psm_softc *)self;
144 	struct ebus_attach_args	*ea = aux;
145 	bus_addr_t		devaddr;
146 	const char		*xname;
147 
148 	xname = device_xname(&sc->sc_dev);
149 
150 	sc->sc_memt = ea->ea_bustag;
151 	devaddr = EBUS_ADDR_FROM_REG(&ea->ea_reg[0]);
152 
153 	if (bus_space_map(sc->sc_memt, devaddr, ea->ea_reg[0].size,
154 		0, &sc->sc_memh) != 0) {
155 		printf(": unable to map device registers\n");
156 		return;
157 	}
158 	if (psm_init(sc) != 0) {
159 		printf(": unable to initialize device\n");
160 		return;
161 	}
162 
163 	printf(": UltraBook IIi power control\n");
164 
165 	psm_sysmon_setup(sc);
166 
167 	if (kthread_create(PRI_NONE, 0, NULL, psm_event_thread, sc,
168 	    &sc->sc_thread, "%s", device_xname(&sc->sc_dev)) != 0) {
169 		aprint_error_dev(&sc->sc_dev, "unable to create event kthread\n");
170 	}
171 
172 	/*
173 	 * Establish device interrupts
174 	 */
175 	(void) bus_intr_establish(sc->sc_memt, ea->ea_intr[0], IPL_HIGH,
176 	    psm_intr, sc);
177 	evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, NULL,
178 	    device_xname(&sc->sc_dev), "intr");
179 }
180 
181 /*
182  * Register sensors and events with sysmon.
183  */
184 void
185 psm_sysmon_setup(struct psm_softc *sc)
186 {
187 	const char	*xname	= device_xname(&sc->sc_dev);
188 
189 
190 	/*
191 	 * XXX: Register sysmon environment.
192 	 */
193 
194 	/*
195 	 * Register sysmon events
196 	 */
197 	sc->sc_sm_pbutton.smpsw_name = xname;
198 	sc->sc_sm_pbutton.smpsw_type = PSWITCH_TYPE_POWER;
199 	if (sysmon_pswitch_register(&sc->sc_sm_pbutton) != 0)
200 		printf("%s: unable to register power button\n", xname);
201 
202 	sc->sc_sm_lid.smpsw_name = xname;
203 	sc->sc_sm_lid.smpsw_type = PSWITCH_TYPE_LID;
204 	if (sysmon_pswitch_register(&sc->sc_sm_lid) != 0)
205 		printf("%s: unable to register lid switch\n", xname);
206 
207 	sc->sc_sm_ac.smpsw_name = xname;
208 	sc->sc_sm_ac.smpsw_type = PSWITCH_TYPE_ACADAPTER;
209 	if (sysmon_pswitch_register(&sc->sc_sm_ac) != 0)
210 		printf("%s: unable to register AC adapter\n", xname);
211 }
212 
213 void
214 psm_event_thread(void *arg)
215 {
216 	struct psm_softc *sc = arg;
217 	int	x;
218 	int	event;
219 	int	flags;
220 
221 	for (;;) {
222 		x = splhigh();
223 		/* check for AC power.  sets event if there is a change */
224 		psm_poll_acpower(sc);
225 
226 		/* read and clear events */
227 		event = sc->sc_event;
228 		flags = sc->sc_flags;
229 		sc->sc_event = 0;
230 		splx(x);
231 
232 		if (event & PSM_EV_PBUTTON) {
233 			sysmon_pswitch_event(&sc->sc_sm_pbutton,
234 			    PSWITCH_EVENT_PRESSED);
235 		}
236 
237 		if (event & PSM_EV_LID) {
238 			sysmon_pswitch_event(&sc->sc_sm_lid,
239 			    flags & PSM_FLAG_LIDCLOSED ?
240 			    PSWITCH_EVENT_PRESSED : PSWITCH_EVENT_RELEASED);
241 		}
242 
243 		if (event & PSM_EV_ACPWR) {
244 			sysmon_pswitch_event(&sc->sc_sm_ac,
245 			    flags & PSM_FLAG_ACPWR ?
246 			    PSWITCH_EVENT_PRESSED : PSWITCH_EVENT_RELEASED);
247 		}
248 
249 		/* XXX: handle PSM_EV_TEMP */
250 
251 		/* one second interval between probes of power */
252 		tsleep(&sc, PWAIT, "psm", hz);
253 	}
254 }
255 
256 int
257 psm_init(struct psm_softc *sc)
258 {
259 	int	x;
260 	uint8_t	batt = 0xff;	/* keep GCC 4.x happy */
261 
262 	/* clear interrupts */
263 	x = splhigh();
264 	PUT8(sc, PSM_ICR, 0xff);
265 	splx(x);
266 
267 	/* enable interrupts */
268 	if (psm_misc_wr(sc, PSM_MISC_IMR, PSM_IMR_ALL))
269 		return (-1);
270 
271 	/* make sure that UPS battery is reasonable */
272 	if (psm_misc_rd(sc, PSM_MISC_UPS, &batt) || (batt > PSM_MAX_BATTERIES))
273 		if (psm_misc_wr(sc, PSM_MISC_UPS, batt))
274 			aprint_error_dev(&sc->sc_dev, "cannot set UPS battery");
275 
276 	return (0);
277 }
278 
279 void
280 psm_reset(struct psm_softc *sc)
281 {
282 
283 	PUT8(sc, PSM_MCR, PSM_MCR_RST);
284 	delay(RESET_DELAY);
285 }
286 
287 void
288 psm_poll_acpower(struct psm_softc *sc)
289 {
290 	int	flags = sc->sc_flags;
291 
292 	if (GET8(sc, PSM_STAT) & PSM_STAT_AC) {
293 		sc->sc_flags |= PSM_FLAG_ACPWR;
294 	} else {
295 		sc->sc_flags &= ~PSM_FLAG_ACPWR;
296 	}
297 	if (flags != sc->sc_flags)
298 		sc->sc_event |= PSM_EV_ACPWR;
299 }
300 
301 int
302 psm_misc_rd(struct psm_softc *sc, uint8_t mreg, uint8_t *data)
303 {
304 
305 	return (psm_ecmd_rd8(sc, data, mreg, PSM_MODE_MISC, 0));
306 }
307 
308 int
309 psm_misc_wr(struct psm_softc *sc, uint8_t mreg, uint8_t data)
310 {
311 
312 	return (psm_ecmd_wr8(sc, data, mreg, PSM_MODE_MISC, 0));
313 }
314 
315 int
316 psm_wait(struct psm_softc *sc, uint8_t flag)
317 {
318     int retr = WAIT_RETRIES;
319 
320     while (GET8(sc, PSM_STAT) & flag) {
321 	    if (!(retr--)) {
322 		    return (-1);
323 	    }
324 	    delay(WAIT_DELAY);
325     }
326     return (0);
327 }
328 
329 #if 0
330 int
331 psm_ecmd_rd16(struct psm_softc *sc, uint16_t *data, uint8_t iar, uint8_t mode,
332     uint8_t addr)
333 {
334 	uint8_t	cmr = PSM_CMR_DATA(mode, PSM_L_16, PSM_D_RD, addr);
335 	int	x, rc, retr = CMD_RETRIES;
336 
337 	x = splhigh();
338 
339 	do {
340 		if ((rc = psm_wait(sc, PSM_STAT_RDA)) != 0) {
341 			psm_reset(sc);
342 			continue;
343 		}
344 
345 		PUT8(sc, PSM_IAR, iar);
346 		PUT8(sc, PSM_CMR, cmr);
347 
348 		delay(CMD_DELAY);
349 
350 		if ((rc = psm_wait(sc, PSM_STAT_RDA)) == 0) {
351 			*data = GET8(sc, PSM_PWDL) | (GET8(sc, PSM_PWDU) << 8);
352 			break;
353 		}
354 
355 		psm_reset(sc);
356 
357 	} while (--retr);
358 
359 	splx(x);
360 	return (rc);
361 }
362 #endif
363 
364 int
365 psm_ecmd_rd8(struct psm_softc *sc, uint8_t *data, uint8_t iar, uint8_t mode,
366     uint8_t addr)
367 {
368 	uint8_t	cmr = PSM_CMR_DATA(mode, PSM_L_8, PSM_D_RD, addr);
369 	int	x, rc, retr = CMD_RETRIES;
370 
371 	x = splhigh();
372 
373 	do {
374 		if ((rc = psm_wait(sc, PSM_STAT_RDA)) != 0) {
375 			psm_reset(sc);
376 			continue;
377 		}
378 
379 		PUT8(sc, PSM_IAR, iar);
380 		PUT8(sc, PSM_CMR, cmr);
381 
382 		delay(CMD_DELAY);
383 
384 		if ((rc = psm_wait(sc, PSM_STAT_RDA)) == 0) {
385 			(void) GET8(sc, PSM_PWDU);
386 			*data = GET8(sc, PSM_PWDL);
387 			break;
388 		}
389 
390 		psm_reset(sc);
391 
392 	} while (--retr);
393 
394 	splx(x);
395 	return (rc);
396 }
397 
398 int
399 psm_ecmd_wr8(struct psm_softc *sc, uint8_t data, uint8_t iar, uint8_t mode,
400     uint8_t addr)
401 {
402 	uint8_t	cmr = PSM_CMR_DATA(mode, PSM_L_8, PSM_D_WR, addr);
403 	int	x, rc, retr = CMD_RETRIES;
404 
405 	x = splhigh();
406 
407 	do {
408 		if ((rc = psm_wait(sc, PSM_STAT_WBF)) != 0) {
409 			psm_reset(sc);
410 			continue;
411 		}
412 
413 		PUT8(sc, PSM_PWDU, 0);
414 		PUT8(sc, PSM_PWDL, data);
415 		PUT8(sc, PSM_IAR, iar);
416 		PUT8(sc, PSM_CMR, cmr);
417 
418 		delay(CMD_DELAY);
419 
420 		if ((rc = psm_wait(sc, PSM_STAT_WBF)) == 0) {
421 			break;
422 		}
423 
424 		psm_reset(sc);
425 	} while (--retr);
426 
427 	splx(x);
428 
429 	return (rc);
430 }
431 
432 int
433 psm_intr(void *arg)
434 {
435 	struct psm_softc *sc = arg;
436 	uint8_t	isr;
437 
438 	isr = GET8(sc, PSM_ISR);
439 	if (isr & PSM_ISR_PO) {
440 		PUT8(sc, PSM_ICR, PSM_ISR_PO);
441 		sc->sc_event |= PSM_EV_PBUTTON;
442 	}
443 	if (isr & PSM_ISR_DK) {
444 		PUT8(sc, PSM_ICR, PSM_ISR_DK);
445 		sc->sc_flags |= PSM_FLAG_DOCKED;
446 	}
447 	if (isr & PSM_ISR_UDK) {
448 		PUT8(sc, PSM_ICR, PSM_ISR_UDK);
449 		sc->sc_flags &= ~PSM_FLAG_DOCKED;
450 	}
451 	if (isr & PSM_ISR_LIDC) {
452 		PUT8(sc, PSM_ICR, PSM_ISR_LIDC);
453 		sc->sc_flags |= PSM_FLAG_LIDCLOSED;
454 		sc->sc_event |= PSM_EV_LID;
455 	}
456 	if (isr & PSM_ISR_LIDO) {
457 		PUT8(sc, PSM_ICR, PSM_ISR_LIDO);
458 		sc->sc_flags &= ~PSM_FLAG_LIDCLOSED;
459 		sc->sc_event |= PSM_EV_LID;
460 	}
461 	if (isr & PSM_ISR_TMP) {
462 		/* Over temperature */
463 		PUT8(sc, PSM_ICR, PSM_ISR_TMP);
464 		sc->sc_event |= PSM_EV_TEMP;
465 	}
466 	if (isr & PSM_ISR_BCC) {
467 		/* battery config changed */
468 		PUT8(sc, PSM_ICR, PSM_ISR_BCC);
469 		sc->sc_event |= PSM_EV_BATT;
470 	}
471 	if (isr & PSM_ISR_RPD) {
472 		/* request to power down */
473 		sc->sc_event |= PSM_EV_PBUTTON;
474 	}
475 	if (sc->sc_event) {
476 		/* wake up the thread */
477 		wakeup(sc);
478 	}
479 	return (1);
480 }
481