1 /* $NetBSD: psm.c,v 1.11 2016/07/07 06:55:38 msaitoh 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.11 2016/07/07 06:55:38 msaitoh 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 <sys/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 device_t 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(device_t, cfdata_t, void *);
124 STATIC void psm_attach(device_t, device_t, void *);
125
126 CFATTACH_DECL_NEW(psm, sizeof(struct psm_softc),
127 psm_match, psm_attach, NULL, NULL);
128
129
130 int
psm_match(device_t parent,cfdata_t cf,void * aux)131 psm_match(device_t parent, cfdata_t 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
psm_attach(device_t parent,device_t self,void * aux)141 psm_attach(device_t parent, device_t self, void *aux)
142 {
143 struct psm_softc *sc = device_private(self);
144 struct ebus_attach_args *ea = aux;
145 bus_addr_t devaddr;
146 const char *xname;
147
148
149 sc->sc_dev = self;
150 sc->sc_memt = ea->ea_bustag;
151 devaddr = EBUS_ADDR_FROM_REG(&ea->ea_reg[0]);
152
153 xname = device_xname(sc->sc_dev);
154 if (bus_space_map(sc->sc_memt, devaddr, ea->ea_reg[0].size,
155 0, &sc->sc_memh) != 0) {
156 printf(": unable to map device registers\n");
157 return;
158 }
159 if (psm_init(sc) != 0) {
160 printf(": unable to initialize device\n");
161 return;
162 }
163
164 printf(": UltraBook IIi power control\n");
165
166 psm_sysmon_setup(sc);
167
168 if (kthread_create(PRI_NONE, 0, NULL, psm_event_thread, sc,
169 &sc->sc_thread, "%s", xname) != 0) {
170 aprint_error_dev(sc->sc_dev, "unable to create event kthread\n");
171 }
172
173 /*
174 * Establish device interrupts
175 */
176 (void) bus_intr_establish(sc->sc_memt, ea->ea_intr[0], IPL_HIGH,
177 psm_intr, sc);
178 evcnt_attach_dynamic(&sc->sc_intrcnt, EVCNT_TYPE_INTR, NULL,
179 xname, "intr");
180 }
181
182 /*
183 * Register sensors and events with sysmon.
184 */
185 void
psm_sysmon_setup(struct psm_softc * sc)186 psm_sysmon_setup(struct psm_softc *sc)
187 {
188 const char *xname = device_xname(sc->sc_dev);
189
190
191 /*
192 * XXX: Register sysmon environment.
193 */
194
195 /*
196 * Register sysmon events
197 */
198 sc->sc_sm_pbutton.smpsw_name = xname;
199 sc->sc_sm_pbutton.smpsw_type = PSWITCH_TYPE_POWER;
200 if (sysmon_pswitch_register(&sc->sc_sm_pbutton) != 0)
201 printf("%s: unable to register power button\n", xname);
202
203 sc->sc_sm_lid.smpsw_name = xname;
204 sc->sc_sm_lid.smpsw_type = PSWITCH_TYPE_LID;
205 if (sysmon_pswitch_register(&sc->sc_sm_lid) != 0)
206 printf("%s: unable to register lid switch\n", xname);
207
208 sc->sc_sm_ac.smpsw_name = xname;
209 sc->sc_sm_ac.smpsw_type = PSWITCH_TYPE_ACADAPTER;
210 if (sysmon_pswitch_register(&sc->sc_sm_ac) != 0)
211 printf("%s: unable to register AC adapter\n", xname);
212 }
213
214 void
psm_event_thread(void * arg)215 psm_event_thread(void *arg)
216 {
217 struct psm_softc *sc = arg;
218 int x;
219 int event;
220 int flags;
221
222 for (;;) {
223 x = splhigh();
224 /* check for AC power. sets event if there is a change */
225 psm_poll_acpower(sc);
226
227 /* read and clear events */
228 event = sc->sc_event;
229 flags = sc->sc_flags;
230 sc->sc_event = 0;
231 splx(x);
232
233 if (event & PSM_EV_PBUTTON) {
234 sysmon_pswitch_event(&sc->sc_sm_pbutton,
235 PSWITCH_EVENT_PRESSED);
236 }
237
238 if (event & PSM_EV_LID) {
239 sysmon_pswitch_event(&sc->sc_sm_lid,
240 flags & PSM_FLAG_LIDCLOSED ?
241 PSWITCH_EVENT_PRESSED : PSWITCH_EVENT_RELEASED);
242 }
243
244 if (event & PSM_EV_ACPWR) {
245 sysmon_pswitch_event(&sc->sc_sm_ac,
246 flags & PSM_FLAG_ACPWR ?
247 PSWITCH_EVENT_PRESSED : PSWITCH_EVENT_RELEASED);
248 }
249
250 /* XXX: handle PSM_EV_TEMP */
251
252 /* one second interval between probes of power */
253 tsleep(&sc, PWAIT, "psm", hz);
254 }
255 }
256
257 int
psm_init(struct psm_softc * sc)258 psm_init(struct psm_softc *sc)
259 {
260 int x;
261 uint8_t batt = 0xff; /* keep GCC 4.x happy */
262
263 /* clear interrupts */
264 x = splhigh();
265 PUT8(sc, PSM_ICR, 0xff);
266 splx(x);
267
268 /* enable interrupts */
269 if (psm_misc_wr(sc, PSM_MISC_IMR, PSM_IMR_ALL))
270 return (-1);
271
272 /* make sure that UPS battery is reasonable */
273 if (psm_misc_rd(sc, PSM_MISC_UPS, &batt) || (batt > PSM_MAX_BATTERIES))
274 if (psm_misc_wr(sc, PSM_MISC_UPS, batt))
275 aprint_error_dev(sc->sc_dev, "cannot set UPS battery");
276
277 return (0);
278 }
279
280 void
psm_reset(struct psm_softc * sc)281 psm_reset(struct psm_softc *sc)
282 {
283
284 PUT8(sc, PSM_MCR, PSM_MCR_RST);
285 delay(RESET_DELAY);
286 }
287
288 void
psm_poll_acpower(struct psm_softc * sc)289 psm_poll_acpower(struct psm_softc *sc)
290 {
291 int flags = sc->sc_flags;
292
293 if (GET8(sc, PSM_STAT) & PSM_STAT_AC) {
294 sc->sc_flags |= PSM_FLAG_ACPWR;
295 } else {
296 sc->sc_flags &= ~PSM_FLAG_ACPWR;
297 }
298 if (flags != sc->sc_flags)
299 sc->sc_event |= PSM_EV_ACPWR;
300 }
301
302 int
psm_misc_rd(struct psm_softc * sc,uint8_t mreg,uint8_t * data)303 psm_misc_rd(struct psm_softc *sc, uint8_t mreg, uint8_t *data)
304 {
305
306 return (psm_ecmd_rd8(sc, data, mreg, PSM_MODE_MISC, 0));
307 }
308
309 int
psm_misc_wr(struct psm_softc * sc,uint8_t mreg,uint8_t data)310 psm_misc_wr(struct psm_softc *sc, uint8_t mreg, uint8_t data)
311 {
312
313 return (psm_ecmd_wr8(sc, data, mreg, PSM_MODE_MISC, 0));
314 }
315
316 int
psm_wait(struct psm_softc * sc,uint8_t flag)317 psm_wait(struct psm_softc *sc, uint8_t flag)
318 {
319 int retr = WAIT_RETRIES;
320
321 while (GET8(sc, PSM_STAT) & flag) {
322 if (!(retr--)) {
323 return (-1);
324 }
325 delay(WAIT_DELAY);
326 }
327 return (0);
328 }
329
330 #if 0
331 int
332 psm_ecmd_rd16(struct psm_softc *sc, uint16_t *data, uint8_t iar, uint8_t mode,
333 uint8_t addr)
334 {
335 uint8_t cmr = PSM_CMR_DATA(mode, PSM_L_16, PSM_D_RD, addr);
336 int x, rc, retr = CMD_RETRIES;
337
338 x = splhigh();
339
340 do {
341 if ((rc = psm_wait(sc, PSM_STAT_RDA)) != 0) {
342 psm_reset(sc);
343 continue;
344 }
345
346 PUT8(sc, PSM_IAR, iar);
347 PUT8(sc, PSM_CMR, cmr);
348
349 delay(CMD_DELAY);
350
351 if ((rc = psm_wait(sc, PSM_STAT_RDA)) == 0) {
352 *data = GET8(sc, PSM_PWDL) | (GET8(sc, PSM_PWDU) << 8);
353 break;
354 }
355
356 psm_reset(sc);
357
358 } while (--retr);
359
360 splx(x);
361 return (rc);
362 }
363 #endif
364
365 int
psm_ecmd_rd8(struct psm_softc * sc,uint8_t * data,uint8_t iar,uint8_t mode,uint8_t addr)366 psm_ecmd_rd8(struct psm_softc *sc, uint8_t *data, uint8_t iar, uint8_t mode,
367 uint8_t addr)
368 {
369 uint8_t cmr = PSM_CMR_DATA(mode, PSM_L_8, PSM_D_RD, addr);
370 int x, rc, retr = CMD_RETRIES;
371
372 x = splhigh();
373
374 do {
375 if ((rc = psm_wait(sc, PSM_STAT_RDA)) != 0) {
376 psm_reset(sc);
377 continue;
378 }
379
380 PUT8(sc, PSM_IAR, iar);
381 PUT8(sc, PSM_CMR, cmr);
382
383 delay(CMD_DELAY);
384
385 if ((rc = psm_wait(sc, PSM_STAT_RDA)) == 0) {
386 (void) GET8(sc, PSM_PWDU);
387 *data = GET8(sc, PSM_PWDL);
388 break;
389 }
390
391 psm_reset(sc);
392
393 } while (--retr);
394
395 splx(x);
396 return (rc);
397 }
398
399 int
psm_ecmd_wr8(struct psm_softc * sc,uint8_t data,uint8_t iar,uint8_t mode,uint8_t addr)400 psm_ecmd_wr8(struct psm_softc *sc, uint8_t data, uint8_t iar, uint8_t mode,
401 uint8_t addr)
402 {
403 uint8_t cmr = PSM_CMR_DATA(mode, PSM_L_8, PSM_D_WR, addr);
404 int x, rc, retr = CMD_RETRIES;
405
406 x = splhigh();
407
408 do {
409 if ((rc = psm_wait(sc, PSM_STAT_WBF)) != 0) {
410 psm_reset(sc);
411 continue;
412 }
413
414 PUT8(sc, PSM_PWDU, 0);
415 PUT8(sc, PSM_PWDL, data);
416 PUT8(sc, PSM_IAR, iar);
417 PUT8(sc, PSM_CMR, cmr);
418
419 delay(CMD_DELAY);
420
421 if ((rc = psm_wait(sc, PSM_STAT_WBF)) == 0) {
422 break;
423 }
424
425 psm_reset(sc);
426 } while (--retr);
427
428 splx(x);
429
430 return (rc);
431 }
432
433 int
psm_intr(void * arg)434 psm_intr(void *arg)
435 {
436 struct psm_softc *sc = arg;
437 uint8_t isr;
438
439 isr = GET8(sc, PSM_ISR);
440 if (isr & PSM_ISR_PO) {
441 PUT8(sc, PSM_ICR, PSM_ISR_PO);
442 sc->sc_event |= PSM_EV_PBUTTON;
443 }
444 if (isr & PSM_ISR_DK) {
445 PUT8(sc, PSM_ICR, PSM_ISR_DK);
446 sc->sc_flags |= PSM_FLAG_DOCKED;
447 }
448 if (isr & PSM_ISR_UDK) {
449 PUT8(sc, PSM_ICR, PSM_ISR_UDK);
450 sc->sc_flags &= ~PSM_FLAG_DOCKED;
451 }
452 if (isr & PSM_ISR_LIDC) {
453 PUT8(sc, PSM_ICR, PSM_ISR_LIDC);
454 sc->sc_flags |= PSM_FLAG_LIDCLOSED;
455 sc->sc_event |= PSM_EV_LID;
456 }
457 if (isr & PSM_ISR_LIDO) {
458 PUT8(sc, PSM_ICR, PSM_ISR_LIDO);
459 sc->sc_flags &= ~PSM_FLAG_LIDCLOSED;
460 sc->sc_event |= PSM_EV_LID;
461 }
462 if (isr & PSM_ISR_TMP) {
463 /* Over temperature */
464 PUT8(sc, PSM_ICR, PSM_ISR_TMP);
465 sc->sc_event |= PSM_EV_TEMP;
466 }
467 if (isr & PSM_ISR_BCC) {
468 /* battery config changed */
469 PUT8(sc, PSM_ICR, PSM_ISR_BCC);
470 sc->sc_event |= PSM_EV_BATT;
471 }
472 if (isr & PSM_ISR_RPD) {
473 /* request to power down */
474 sc->sc_event |= PSM_EV_PBUTTON;
475 }
476 if (sc->sc_event) {
477 /* wake up the thread */
478 wakeup(sc);
479 }
480 return (1);
481 }
482