1 /* $OpenBSD: kb3310.c,v 1.16 2010/10/14 21:23:04 pirofti Exp $ */
2 /*
3 * Copyright (c) 2010 Otto Moerbeek <otto@drijf.net>
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 #include <sys/param.h>
19 #include <sys/kernel.h>
20 #include <sys/systm.h>
21 #include <sys/device.h>
22 #include <sys/sensors.h>
23 #include <sys/timeout.h>
24
25 #include <mips64/archtype.h>
26 #include <machine/apmvar.h>
27 #include <evbmips/loongson/autoconf.h>
28 #include <machine/bus.h>
29 #include <dev/isa/isavar.h>
30
31 #include <dev/pci/glxreg.h>
32
33 #include <loongson/dev/bonitoreg.h>
34 #include <loongson/dev/kb3310var.h>
35
36 #include "apm.h"
37 #include "pckbd.h"
38 #include "hidkbd.h"
39
40 #if NPCKBD > 0 || NHIDKBD > 0
41 #include <dev/ic/pckbcvar.h>
42 #include <dev/pckbc/pckbdvar.h>
43 #include <dev/usb/hidkbdvar.h>
44 #endif
45
46 struct cfdriver ykbec_cd = {
47 NULL, "ykbec", DV_DULL,
48 };
49
50 #ifdef KB3310_DEBUG
51 #define DPRINTF(x) printf x
52 #else
53 #define DPRINTF(x)
54 #endif
55
56 #define IO_YKBEC 0x381
57 #define IO_YKBECSIZE 0x3
58
59 static const struct {
60 const char *desc;
61 int type;
62 } ykbec_table[] = {
63 #define YKBEC_FAN 0
64 { NULL, SENSOR_FANRPM },
65 #define YKBEC_ITEMP 1
66 { "Internal temperature", SENSOR_TEMP },
67 #define YKBEC_FCAP 2
68 { "Battery full charge capacity", SENSOR_AMPHOUR },
69 #define YKBEC_BCURRENT 3
70 { "Battery current", SENSOR_AMPS },
71 #define YKBEC_BVOLT 4
72 { "Battery voltage", SENSOR_VOLTS_DC },
73 #define YKBEC_BTEMP 5
74 { "Battery temperature", SENSOR_TEMP },
75 #define YKBEC_CAP 6
76 { "Battery capacity", SENSOR_PERCENT },
77 #define YKBEC_CHARGING 7
78 { "Battery charging", SENSOR_INDICATOR },
79 #define YKBEC_AC 8
80 { "AC-Power", SENSOR_INDICATOR }
81 #define YKBEC_NSENSORS 9
82 };
83
84 struct ykbec_softc {
85 bus_space_tag_t sc_iot;
86 bus_space_handle_t sc_ioh;
87 struct ksensor sc_sensor[YKBEC_NSENSORS];
88 struct ksensordev sc_sensordev;
89 #if NPCKBD > 0 || NHIDKBD > 0
90 struct timeout sc_bell_tmo;
91 #endif
92 };
93
94 static struct ykbec_softc *ykbec_sc;
95 static int ykbec_chip_config;
96
97 extern void loongson_set_isa_imr(uint);
98
99 int ykbec_match(device_t, cfdata_t, void *);
100 void ykbec_attach(device_t, device_t, void *);
101
102 CFATTACH_DECL_NEW(ykbec, sizeof(struct ykbec_softc),
103 ykbec_match, ykbec_attach, NULL, NULL);
104
105 int ykbec_apminfo(struct apm_power_info *);
106 void ykbec_bell(void *, u_int, u_int, u_int, int);
107 void ykbec_bell_stop(void *);
108 void ykbec_print_bat_info(struct ykbec_softc *);
109 u_int ykbec_read(struct ykbec_softc *, u_int);
110 u_int ykbec_read16(struct ykbec_softc *, u_int);
111 void ykbec_refresh(void *arg);
112 void ykbec_write(struct ykbec_softc *, u_int, u_int);
113
114 #if NAPM > 0
115 struct apm_power_info ykbec_apmdata;
116 const char *ykbec_batstate[] = {
117 "high",
118 "low",
119 "critical",
120 "charging",
121 "unknown"
122 };
123 #define BATTERY_STRING(x) ((x) < nitems(ykbec_batstate) ? \
124 ykbec_batstate[x] : ykbec_batstate[4])
125 #endif
126
127 int
ykbec_match(device_t parent,cfdata_t match,void * aux)128 ykbec_match(device_t parent, cfdata_t match, void *aux)
129 {
130 struct isa_attach_args *ia = aux;
131 bus_space_handle_t ioh;
132
133 if (sys_platform->system_type != LOONGSON_YEELOONG)
134 return (0);
135
136 if ((ia->ia_iobase != IOBASEUNK && ia->ia_iobase != IO_YKBEC) ||
137 /* (ia->ia_iosize != 0 && ia->ia_iosize != IO_YKBECSIZE) || XXX isa.c */
138 ia->ia_maddr != MADDRUNK || ia->ia_msize != 0 ||
139 ia->ia_irq != IRQUNK || ia->ia_drq != DRQUNK)
140 return (0);
141
142 if (bus_space_map(ia->ia_iot, IO_YKBEC, IO_YKBECSIZE, 0, &ioh))
143 return (0);
144
145 bus_space_unmap(ia->ia_iot, ioh, IO_YKBECSIZE);
146
147 ia->ia_iobase = IO_YKBEC;
148 ia->ia_iosize = IO_YKBECSIZE;
149
150 return (1);
151 }
152
153 void
ykbec_attach(device_t parent,device_t self,void * aux)154 ykbec_attach(device_t parent, device_t self, void *aux)
155 {
156 struct isa_attach_args *ia = aux;
157 struct ykbec_softc *sc = device_private(self);
158 int i;
159
160 sc->sc_iot = ia->ia_iot;
161 if (bus_space_map(sc->sc_iot, ia->ia_iobase, ia->ia_iosize, 0,
162 &sc->sc_ioh)) {
163 aprint_error(": couldn't map I/O space");
164 return;
165 }
166
167 /* Initialize sensor data. */
168 strlcpy(sc->sc_sensordev.xname, device_xname(self),
169 sizeof(sc->sc_sensordev.xname));
170 if (sensor_task_register(sc, ykbec_refresh, 5) == NULL) {
171 aprint_error(", unable to register update task\n");
172 return;
173 }
174
175 #ifdef DEBUG
176 ykbec_print_bat_info(sc);
177 #endif
178 aprint_normal("\n");
179
180 for (i = 0; i < YKBEC_NSENSORS; i++) {
181 sc->sc_sensor[i].type = ykbec_table[i].type;
182 if (ykbec_table[i].desc)
183 strlcpy(sc->sc_sensor[i].desc, ykbec_table[i].desc,
184 sizeof(sc->sc_sensor[i].desc));
185 sensor_attach(&sc->sc_sensordev, &sc->sc_sensor[i]);
186 }
187
188 sensordev_install(&sc->sc_sensordev);
189
190 #if NAPM > 0
191 /* make sure we have the apm state initialized before apm attaches */
192 ykbec_refresh(sc);
193 apm_setinfohook(ykbec_apminfo);
194 #endif
195 #if NPCKBD > 0 || NHIDKBD > 0
196 timeout_set(&sc->sc_bell_tmo, ykbec_bell_stop, sc);
197 #if NPCKBD > 0
198 pckbd_hookup_bell(ykbec_bell, sc);
199 #endif
200 #if NHIDKBD > 0
201 hidkbd_hookup_bell(ykbec_bell, sc);
202 #endif
203 #endif
204 ykbec_sc = sc;
205 }
206
207 void
ykbec_write(struct ykbec_softc * mcsc,u_int reg,u_int datum)208 ykbec_write(struct ykbec_softc *mcsc, u_int reg, u_int datum)
209 {
210 struct ykbec_softc *sc = (struct ykbec_softc *)mcsc;
211 bus_space_tag_t iot = sc->sc_iot;
212 bus_space_handle_t ioh = sc->sc_ioh;
213
214 bus_space_write_1(iot, ioh, 0, (reg >> 8) & 0xff);
215 bus_space_write_1(iot, ioh, 1, (reg >> 0) & 0xff);
216 bus_space_write_1(iot, ioh, 2, datum);
217 }
218
219 u_int
ykbec_read(struct ykbec_softc * mcsc,u_int reg)220 ykbec_read(struct ykbec_softc *mcsc, u_int reg)
221 {
222 struct ykbec_softc *sc = (struct ykbec_softc *)mcsc;
223 bus_space_tag_t iot = sc->sc_iot;
224 bus_space_handle_t ioh = sc->sc_ioh;
225
226 bus_space_write_1(iot, ioh, 0, (reg >> 8) & 0xff);
227 bus_space_write_1(iot, ioh, 1, (reg >> 0) & 0xff);
228 return bus_space_read_1(iot, ioh, 2);
229 }
230
231 u_int
ykbec_read16(struct ykbec_softc * mcsc,u_int reg)232 ykbec_read16(struct ykbec_softc *mcsc, u_int reg)
233 {
234 u_int val;
235
236 val = ykbec_read(mcsc, reg);
237 return (val << 8) | ykbec_read(mcsc, reg + 1);
238 }
239
240 #define KB3310_FAN_SPEED_DIVIDER 480000
241
242 #define ECTEMP_CURRENT_REG 0xf458
243 #define REG_FAN_SPEED_HIGH 0xfe22
244 #define REG_FAN_SPEED_LOW 0xfe23
245
246 #define REG_DESIGN_CAP_HIGH 0xf77d
247 #define REG_DESIGN_CAP_LOW 0xf77e
248 #define REG_FULLCHG_CAP_HIGH 0xf780
249 #define REG_FULLCHG_CAP_LOW 0xf781
250
251 #define REG_DESIGN_VOL_HIGH 0xf782
252 #define REG_DESIGN_VOL_LOW 0xf783
253 #define REG_CURRENT_HIGH 0xf784
254 #define REG_CURRENT_LOW 0xf785
255 #define REG_VOLTAGE_HIGH 0xf786
256 #define REG_VOLTAGE_LOW 0xf787
257 #define REG_TEMPERATURE_HIGH 0xf788
258 #define REG_TEMPERATURE_LOW 0xf789
259 #define REG_RELATIVE_CAT_HIGH 0xf492
260 #define REG_RELATIVE_CAT_LOW 0xf493
261 #define REG_BAT_VENDOR 0xf4c4
262 #define REG_BAT_CELL_COUNT 0xf4c6
263
264 #define REG_BAT_CHARGE 0xf4a2
265 #define BAT_CHARGE_AC 0x00
266 #define BAT_CHARGE_DISCHARGE 0x01
267 #define BAT_CHARGE_CHARGE 0x02
268
269 #define REG_POWER_FLAG 0xf440
270 #define POWER_FLAG_ADAPTER_IN (1<<0)
271 #define POWER_FLAG_POWER_ON (1<<1)
272 #define POWER_FLAG_ENTER_SUS (1<<2)
273
274 #define REG_BAT_STATUS 0xf4b0
275 #define BAT_STATUS_BAT_EXISTS (1<<0)
276 #define BAT_STATUS_BAT_FULL (1<<1)
277 #define BAT_STATUS_BAT_DESTROY (1<<2)
278 #define BAT_STATUS_BAT_LOW (1<<5)
279
280 #define REG_CHARGE_STATUS 0xf4b1
281 #define CHARGE_STATUS_PRECHARGE (1<<1)
282 #define CHARGE_STATUS_OVERHEAT (1<<2)
283
284 #define REG_BAT_STATE 0xf482
285 #define BAT_STATE_DISCHARGING (1<<0)
286 #define BAT_STATE_CHARGING (1<<1)
287
288 #define REG_BEEP_CONTROL 0xf4d0
289 #define BEEP_ENABLE (1<<0)
290
291 #define REG_PMUCFG 0xff0c
292 #define PMUCFG_STOP_MODE (1<<7)
293 #define PMUCFG_IDLE_MODE (1<<6)
294 #define PMUCFG_LPC_WAKEUP (1<<5)
295 #define PMUCFG_RESET_8051 (1<<4)
296 #define PMUCFG_SCI_WAKEUP (1<<3)
297 #define PMUCFG_WDT_WAKEUP (1<<2)
298 #define PMUCFG_GPWU_WAKEUP (1<<1)
299 #define PMUCFG_IRQ_IDLE (1<<0)
300
301 #define REG_USB0 0xf461
302 #define REG_USB1 0xf462
303 #define REG_USB2 0xf463
304 #define USB_FLAG_ON 1
305 #define USB_FLAG_OFF 0
306
307 #define REG_FAN_CONTROL 0xf4d2
308 #define REG_FAN_ON 1
309 #define REG_FAN_OFF 0
310
311 #define YKBEC_SCI_IRQ 0xa
312
313 #ifdef DEBUG
314 void
ykbec_print_bat_info(struct ykbec_softc * sc)315 ykbec_print_bat_info(struct ykbec_softc *sc)
316 {
317 uint bat_status, count, dvolt, dcap;
318
319 printf(": battery ");
320 bat_status = ykbec_read(sc, REG_BAT_STATUS);
321 if (!ISSET(bat_status, BAT_STATUS_BAT_EXISTS)) {
322 printf("absent");
323 return;
324 }
325
326 count = ykbec_read(sc, REG_BAT_CELL_COUNT);
327 dvolt = ykbec_read16(sc, REG_DESIGN_VOL_HIGH);
328 dcap = ykbec_read16(sc, REG_DESIGN_CAP_HIGH);
329 printf("%d cells, design capacity %dmV %dmAh", count, dvolt, dcap);
330 }
331 #endif
332
333 void
ykbec_refresh(void * arg)334 ykbec_refresh(void *arg)
335 {
336 struct ykbec_softc *sc = (struct ykbec_softc *)arg;
337 u_int val, bat_charge, bat_status, charge_status, bat_state, power_flag;
338 u_int cap_pct, fullcap;
339 int current;
340 #if NAPM > 0
341 struct apm_power_info old;
342 #endif
343
344 val = ykbec_read16(sc, REG_FAN_SPEED_HIGH) & 0xfffff;
345 if (val != 0) {
346 val = KB3310_FAN_SPEED_DIVIDER / val;
347 sc->sc_sensor[YKBEC_FAN].value = val;
348 CLR(sc->sc_sensor[YKBEC_FAN].flags, SENSOR_FINVALID);
349 } else
350 SET(sc->sc_sensor[YKBEC_FAN].flags, SENSOR_FINVALID);
351
352 val = ykbec_read(sc, ECTEMP_CURRENT_REG);
353 sc->sc_sensor[YKBEC_ITEMP].value = val * 1000000 + 273150000;
354
355 fullcap = ykbec_read16(sc, REG_FULLCHG_CAP_HIGH);
356 sc->sc_sensor[YKBEC_FCAP].value = fullcap * 1000;
357
358 current = ykbec_read16(sc, REG_CURRENT_HIGH);
359 /* sign extend short -> int, int -> int64 will be done next statement */
360 current |= -(current & 0x8000);
361 sc->sc_sensor[YKBEC_BCURRENT].value = -1000 * current;
362
363 sc->sc_sensor[YKBEC_BVOLT].value = ykbec_read16(sc, REG_VOLTAGE_HIGH) *
364 1000;
365
366 val = ykbec_read16(sc, REG_TEMPERATURE_HIGH);
367 sc->sc_sensor[YKBEC_BTEMP].value = val * 1000000 + 273150000;
368
369 cap_pct = ykbec_read16(sc, REG_RELATIVE_CAT_HIGH);
370 sc->sc_sensor[YKBEC_CAP].value = cap_pct * 1000;
371
372 bat_charge = ykbec_read(sc, REG_BAT_CHARGE);
373 bat_status = ykbec_read(sc, REG_BAT_STATUS);
374 charge_status = ykbec_read(sc, REG_CHARGE_STATUS);
375 bat_state = ykbec_read(sc, REG_BAT_STATE);
376 power_flag = ykbec_read(sc, REG_POWER_FLAG);
377
378 sc->sc_sensor[YKBEC_CHARGING].value = !!ISSET(bat_state,
379 BAT_STATE_CHARGING);
380 sc->sc_sensor[YKBEC_AC].value = !!ISSET(power_flag,
381 POWER_FLAG_ADAPTER_IN);
382
383 sc->sc_sensor[YKBEC_CAP].status = ISSET(bat_status, BAT_STATUS_BAT_LOW) ?
384 SENSOR_S_CRIT : SENSOR_S_OK;
385
386 #if NAPM > 0
387 bcopy(&ykbec_apmdata, &old, sizeof(old));
388 ykbec_apmdata.battery_life = cap_pct;
389 ykbec_apmdata.ac_state = ISSET(power_flag, POWER_FLAG_ADAPTER_IN) ?
390 APM_AC_ON : APM_AC_OFF;
391 if (!ISSET(bat_status, BAT_STATUS_BAT_EXISTS)) {
392 ykbec_apmdata.battery_state = APM_BATTERY_ABSENT;
393 ykbec_apmdata.minutes_left = 0;
394 ykbec_apmdata.battery_life = 0;
395 } else {
396 if (ISSET(bat_state, BAT_STATE_CHARGING))
397 ykbec_apmdata.battery_state = APM_BATT_CHARGING;
398 else if (ISSET(bat_status, BAT_STATUS_BAT_LOW))
399 ykbec_apmdata.battery_state = APM_BATT_CRITICAL;
400 /* XXX arbitrary */
401 else if (cap_pct > 60)
402 ykbec_apmdata.battery_state = APM_BATT_HIGH;
403 else
404 ykbec_apmdata.battery_state = APM_BATT_LOW;
405
406 /* if charging, current is positive */
407 if (ISSET(bat_state, BAT_STATE_CHARGING))
408 current = 0;
409 else
410 current = -current;
411 /* XXX Yeeloong draw is about 1A */
412 if (current <= 0)
413 current = 1000;
414 /* XXX at 5?%, the Yeeloong shuts down */
415 if (cap_pct <= 5)
416 cap_pct = 0;
417 else
418 cap_pct -= 5;
419 fullcap = cap_pct * 60 * fullcap / 100;
420 ykbec_apmdata.minutes_left = fullcap / current;
421
422 }
423 if (old.ac_state != ykbec_apmdata.ac_state)
424 apm_record_event(APM_POWER_CHANGE, "AC power",
425 ykbec_apmdata.ac_state ? "restored" : "lost");
426 if (old.battery_state != ykbec_apmdata.battery_state)
427 apm_record_event(APM_POWER_CHANGE, "battery",
428 BATTERY_STRING(ykbec_apmdata.battery_state));
429 #endif
430 }
431
432
433 #if NAPM > 0
434 int
ykbec_apminfo(struct apm_power_info * info)435 ykbec_apminfo(struct apm_power_info *info)
436 {
437 bcopy(&ykbec_apmdata, info, sizeof(struct apm_power_info));
438 return 0;
439 }
440
441 int
ykbec_suspend()442 ykbec_suspend()
443 {
444 struct ykbec_softc *sc = ykbec_sc;
445 int ctrl;
446
447 /*
448 * Set up wakeup sources: currently only the internal keyboard.
449 */
450 loongson_set_isa_imr(1 << 1);
451
452 /* USB */
453 DPRINTF(("USB\n"));
454 ykbec_write(sc, REG_USB0, USB_FLAG_OFF);
455 ykbec_write(sc, REG_USB1, USB_FLAG_OFF);
456 ykbec_write(sc, REG_USB2, USB_FLAG_OFF);
457
458 /* EC */
459 DPRINTF(("REG_PMUCFG\n"));
460 ctrl = PMUCFG_SCI_WAKEUP | PMUCFG_WDT_WAKEUP | PMUCFG_GPWU_WAKEUP |
461 PMUCFG_LPC_WAKEUP | PMUCFG_STOP_MODE | PMUCFG_RESET_8051;
462 ykbec_write(sc, REG_PMUCFG, ctrl);
463
464 /* FAN */
465 DPRINTF(("FAN\n"));
466 ykbec_write(sc, REG_FAN_CONTROL, REG_FAN_OFF);
467
468 /* CPU */
469 DPRINTF(("CPU\n"));
470 ykbec_chip_config = REGVAL(LOONGSON_CHIP_CONFIG0);
471 enableintr();
472 REGVAL(LOONGSON_CHIP_CONFIG0) = ykbec_chip_config & ~0x7;
473 (void)REGVAL(LOONGSON_CHIP_CONFIG0);
474
475 /*
476 * When a resume interrupt fires, we will enter the interrupt
477 * dispatcher, which will do nothing because we are at splhigh,
478 * and execution flow will return here and continue.
479 */
480 (void)disableintr();
481
482 return 0;
483 }
484
485 int
ykbec_resume()486 ykbec_resume()
487 {
488 struct ykbec_softc *sc = ykbec_sc;
489
490 /* CPU */
491 DPRINTF(("CPU\n"));
492 REGVAL(LOONGSON_CHIP_CONFIG0) = ykbec_chip_config;
493 (void)REGVAL(LOONGSON_CHIP_CONFIG0);
494
495 /* FAN */
496 DPRINTF(("FAN\n"));
497 ykbec_write(sc, REG_FAN_CONTROL, REG_FAN_ON);
498
499 /* USB */
500 DPRINTF(("USB\n"));
501 ykbec_write(sc, REG_USB0, USB_FLAG_ON);
502 ykbec_write(sc, REG_USB1, USB_FLAG_ON);
503 ykbec_write(sc, REG_USB2, USB_FLAG_ON);
504
505 ykbec_refresh(sc);
506
507 return 0;
508 }
509 #endif
510
511 #if NPCKBD > 0 || NHIDKBD > 0
512 void
ykbec_bell(void * arg,u_int pitch,u_int period,u_int volume,int poll)513 ykbec_bell(void *arg, u_int pitch, u_int period, u_int volume, int poll)
514 {
515 struct ykbec_softc *sc = (struct ykbec_softc *)arg;
516 int bctrl;
517 int s;
518
519 s = spltty();
520 bctrl = ykbec_read(sc, REG_BEEP_CONTROL);
521 if (volume == 0 || timeout_pending(&sc->sc_bell_tmo)) {
522 timeout_del(&sc->sc_bell_tmo);
523 /* inline ykbec_bell_stop(arg); */
524 ykbec_write(sc, REG_BEEP_CONTROL, bctrl & ~BEEP_ENABLE);
525 }
526
527 if (volume != 0) {
528 ykbec_write(sc, REG_BEEP_CONTROL, bctrl | BEEP_ENABLE);
529 if (poll) {
530 delay(period * 1000);
531 ykbec_write(sc, REG_BEEP_CONTROL, bctrl & ~BEEP_ENABLE);
532 } else {
533 timeout_add_msec(&sc->sc_bell_tmo, period);
534 }
535 }
536 splx(s);
537 }
538
539 void
ykbec_bell_stop(void * arg)540 ykbec_bell_stop(void *arg)
541 {
542 struct ykbec_softc *sc = (struct ykbec_softc *)arg;
543 int s;
544
545 s = spltty();
546 ykbec_write(sc, REG_BEEP_CONTROL,
547 ykbec_read(sc, REG_BEEP_CONTROL) & ~BEEP_ENABLE);
548 splx(s);
549 }
550 #endif
551