Module Name: src
Committed By: jdc
Date: Sat May 16 07:16:14 UTC 2020
Modified Files:
src/sys/arch/sparc64/dev: tadpmu.c tadpmureg.h tadpmuvar.h
Log Message:
Extend the monitoring to battery state, with capacity based on voltage.
Add more PMU definitions.
To generate a diff of this commit:
cvs rdiff -u -r1.4 -r1.5 src/sys/arch/sparc64/dev/tadpmu.c
cvs rdiff -u -r1.2 -r1.3 src/sys/arch/sparc64/dev/tadpmureg.h \
src/sys/arch/sparc64/dev/tadpmuvar.h
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/sys/arch/sparc64/dev/tadpmu.c
diff -u src/sys/arch/sparc64/dev/tadpmu.c:1.4 src/sys/arch/sparc64/dev/tadpmu.c:1.5
--- src/sys/arch/sparc64/dev/tadpmu.c:1.4 Sun Oct 14 05:08:39 2018
+++ src/sys/arch/sparc64/dev/tadpmu.c Sat May 16 07:16:14 2020
@@ -1,4 +1,4 @@
-/*/* $NetBSD: tadpmu.c,v 1.4 2018/10/14 05:08:39 macallan Exp $ */
+/*/* $NetBSD: tadpmu.c,v 1.5 2020/05/16 07:16:14 jdc Exp $ */
/*-
* Copyright (c) 2018 Michael Lorenz <[email protected]>
@@ -26,7 +26,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
-/* a driver for the PMU found in Tadpole Wiper and possibly SPARCle laptops */
+/* a driver for the PMU found in Tadpole Viper and SPARCle laptops */
#include "opt_tadpmu.h"
#ifdef HAVE_TADPMU
@@ -56,13 +56,16 @@
static bus_space_tag_t tadpmu_iot;
static bus_space_handle_t tadpmu_hcmd;
static bus_space_handle_t tadpmu_hdata;
-static struct sysmon_envsys *tadpmu_sme;
-static envsys_data_t tadpmu_sensors[5];
+static struct sysmon_envsys *tadpmu_sens_sme;
+static struct sysmon_envsys *tadpmu_acad_sme;
+static struct sysmon_envsys *tadpmu_batt_sme;
+static envsys_data_t tadpmu_sensors[8];
static uint8_t idata = 0xff;
static uint8_t ivalid = 0;
+static uint8_t ev_data = 0;
static wchan_t tadpmu, tadpmuev;
-static struct sysmon_pswitch tadpmu_pbutton, tadpmu_lidswitch;
-static kmutex_t tadpmu_lock;
+static struct sysmon_pswitch tadpmu_pbutton, tadpmu_lidswitch, tadpmu_dcpower;
+static kmutex_t tadpmu_lock, data_lock;
static lwp_t *tadpmu_thread;
static int tadpmu_dying = 0;
@@ -202,10 +205,52 @@ tadpmu_send(uint8_t v)
}
}
+static uint32_t
+tadpmu_battery_capacity(uint8_t gstat)
+{
+ uint8_t res;
+
+ if (gstat == GENSTAT_STATE_BATTERY_FULL) {
+ return ENVSYS_BATTERY_CAPACITY_NORMAL;
+ }
+
+ mutex_enter(&tadpmu_lock);
+ tadpmu_flush();
+ tadpmu_send_cmd(CMD_READ_VBATT);
+ res = tadpmu_recv();
+ mutex_exit(&tadpmu_lock);
+
+ if (gstat & GENSTAT_STATE_BATTERY_DISCHARGE) {
+ if (res < TADPMU_BATT_DIS_CAP_CRIT)
+ return ENVSYS_BATTERY_CAPACITY_CRITICAL;
+ if (res < TADPMU_BATT_DIS_CAP_WARN)
+ return ENVSYS_BATTERY_CAPACITY_WARNING;
+ if (res < TADPMU_BATT_DIS_CAP_LOW)
+ return ENVSYS_BATTERY_CAPACITY_LOW;
+ else
+ return ENVSYS_BATTERY_CAPACITY_NORMAL;
+ } else if (gstat == GENSTAT_STATE_BATTERY_CHARGE) {
+ if (res < TADPMU_BATT_CHG_CAP_CRIT)
+ return ENVSYS_BATTERY_CAPACITY_CRITICAL;
+ else if (res < TADPMU_BATT_CHG_CAP_WARN)
+ return ENVSYS_BATTERY_CAPACITY_WARNING;
+ else if (res < TADPMU_BATT_CHG_CAP_LOW)
+ return ENVSYS_BATTERY_CAPACITY_LOW;
+ else
+ return ENVSYS_BATTERY_CAPACITY_NORMAL;
+ } else {
+ DPRINTF("%s unknown battery state %02x\n",
+ __func__, gstat);
+ return ENVSYS_BATTERY_CAPACITY_NORMAL;
+ }
+}
+
+/* The data to read is calculated from the command and the units */
static void
tadpmu_sensors_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
{
int res;
+
if (edata->private > 0) {
mutex_enter(&tadpmu_lock);
tadpmu_flush();
@@ -214,8 +259,27 @@ tadpmu_sensors_refresh(struct sysmon_env
mutex_exit(&tadpmu_lock);
if (edata->units == ENVSYS_STEMP) {
edata->value_cur = res * 1000000 + 273150000;
+ } else if (edata->units == ENVSYS_SVOLTS_DC) {
+ edata->value_cur = res * 100000;
+ } else if (edata->units == ENVSYS_BATTERY_CHARGE) {
+ if (res & GENSTAT_BATTERY_CHARGING)
+ edata->value_cur = ENVSYS_INDICATOR_TRUE;
+ else
+ edata->value_cur = ENVSYS_INDICATOR_FALSE;
+ } else if (edata->units == ENVSYS_BATTERY_CAPACITY) {
+ edata->value_cur = tadpmu_battery_capacity(res);
} else {
- edata->value_cur = res;
+ if (edata->units == ENVSYS_INDICATOR &&
+ edata->private == CMD_READ_GENSTAT) {
+ if (res & GENSTAT_DC_PRESENT)
+ edata->value_cur =
+ ENVSYS_INDICATOR_TRUE;
+ else
+ edata->value_cur =
+ ENVSYS_INDICATOR_FALSE;
+ } else {
+ edata->value_cur = res;
+ }
}
edata->state = ENVSYS_SVALID;
} else {
@@ -226,27 +290,73 @@ tadpmu_sensors_refresh(struct sysmon_env
static void
tadpmu_events(void *cookie)
{
- uint8_t res, ores = 0;
+ uint8_t events, gs, vb;
+
while (!tadpmu_dying) {
mutex_enter(&tadpmu_lock);
tadpmu_flush();
tadpmu_send_cmd(CMD_READ_GENSTAT);
- res = tadpmu_recv();
+ gs = tadpmu_recv();
+ tadpmu_send_cmd(CMD_READ_VBATT);
+ vb = tadpmu_recv();
mutex_exit(&tadpmu_lock);
- res &= GENSTAT_LID_CLOSED;
- if (res != ores) {
- ores = res;
+
+ mutex_enter(&data_lock);
+ events = ev_data;
+ mutex_exit(&data_lock);
+ DPRINTF("%s event %02x, status %02x/%02x\n", __func__,
+ events, gs, vb);
+
+ if (events & TADPMU_EV_PWRBUTT) {
+ mutex_enter(&data_lock);
+ ev_data &= ~TADPMU_EV_PWRBUTT;
+ mutex_exit(&data_lock);
+ sysmon_pswitch_event(&tadpmu_pbutton,
+ PSWITCH_EVENT_PRESSED);
+ }
+
+ if (events & TADPMU_EV_LID) {
+ mutex_enter(&data_lock);
+ ev_data &= ~TADPMU_EV_LID;
+ mutex_exit(&data_lock);
sysmon_pswitch_event(&tadpmu_lidswitch,
- (res & GENSTAT_LID_CLOSED) ?
- PSWITCH_EVENT_PRESSED :
- PSWITCH_EVENT_RELEASED);
+ gs & GENSTAT_LID_CLOSED ?
+ PSWITCH_EVENT_PRESSED : PSWITCH_EVENT_RELEASED);
+ }
+
+ if (events & TADPMU_EV_DCPOWER) {
+ mutex_enter(&data_lock);
+ ev_data &= ~TADPMU_EV_DCPOWER;
+ mutex_exit(&data_lock);
+ sysmon_pswitch_event(&tadpmu_dcpower,
+ gs & GENSTAT_DC_PRESENT ?
+ PSWITCH_EVENT_PRESSED : PSWITCH_EVENT_RELEASED);
}
+
+ if (events & TADPMU_EV_BATTCHANGE) {
+ mutex_enter(&data_lock);
+ ev_data &= ~TADPMU_EV_BATTCHANGE;
+ mutex_exit(&data_lock);
+ if (gs == GENSTAT_STATE_BATTERY_DISCHARGE) {
+ if (vb < TADPMU_BATT_DIS_CAP_CRIT)
+ printf("Battery critical!\n");
+ else if (vb < TADPMU_BATT_DIS_CAP_WARN)
+ printf("Battery warning!\n");
+ }
+ }
+
+ if (events & TADPMU_EV_BATTCHARGED) {
+ mutex_enter(&data_lock);
+ ev_data &= ~TADPMU_EV_BATTCHARGED;
+ mutex_exit(&data_lock);
+ printf("Battery charged\n");
+ }
+
tsleep(tadpmuev, 0, "tadpmuev", hz);
}
kthread_exit(0);
}
-
int
tadpmu_intr(void *cookie)
{
@@ -254,17 +364,38 @@ tadpmu_intr(void *cookie)
if (s & STATUS_INTR) {
/* interrupt message */
d = tadpmu_data();
- DPRINTF("status change %02x\n", d);
+ DPRINTF("%s status change %02x\n", __func__, d);
+
switch (d) {
- case TADPMU_POWERBUTTON:
- sysmon_pswitch_event(&tadpmu_pbutton,
- PSWITCH_EVENT_PRESSED);
+ case TADPMU_INTR_POWERBUTTON:
+ mutex_enter(&data_lock);
+ ev_data |= TADPMU_EV_PWRBUTT;;
+ mutex_exit(&data_lock);
+ break;
+ case TADPMU_INTR_LID:
+ mutex_enter(&data_lock);
+ ev_data |= TADPMU_EV_LID;
+ mutex_exit(&data_lock);
+ break;
+ case TADPMU_INTR_DCPOWER:
+ mutex_enter(&data_lock);
+ ev_data |= TADPMU_EV_DCPOWER;
+ mutex_exit(&data_lock);
break;
- case TADPMU_LID:
- /* read genstat and report lid */
- wakeup(tadpmuev);
+ case TADPMU_INTR_BATTERY_STATE:
+ mutex_enter(&data_lock);
+ ev_data |= TADPMU_EV_BATTCHANGE;
+ mutex_exit(&data_lock);
+ break;
+ case TADPMU_INTR_BATTERY_CHARGED:
+ mutex_enter(&data_lock);
+ ev_data |= TADPMU_EV_BATTCHARGED;
+ mutex_exit(&data_lock);
break;
}
+ /* Report events */
+ if (ev_data)
+ wakeup(tadpmuev);
}
s = tadpmu_status();
if (s & STATUS_HAVE_DATA) {
@@ -280,7 +411,7 @@ tadpmu_intr(void *cookie)
int
tadpmu_init(bus_space_tag_t t, bus_space_handle_t hcmd, bus_space_handle_t hdata)
{
- int ver;
+ uint8_t ver;
tadpmu_iot = t;
tadpmu_hcmd = hcmd;
@@ -294,52 +425,91 @@ tadpmu_init(bus_space_tag_t t, bus_space
printf("Tadpole PMU Version 1.%d\n", ver);
tadpmu_send_cmd(CMD_SET_OPMODE);
- tadpmu_send(0x75);
+ tadpmu_send(OPMODE_UNIX);
+#ifdef TADPMU_DEBUG
tadpmu_send_cmd(CMD_READ_SYSTEMP);
ver = tadpmu_recv();
- printf("Temperature %d\n", ver);
+ printf("Temperature 0x%02x\n", ver);
tadpmu_send_cmd(CMD_READ_VBATT);
ver = tadpmu_recv();
- printf("Battery voltage %d\n", ver);
+ printf("Battery voltage 0x%02x\n", ver);
tadpmu_send_cmd(CMD_READ_GENSTAT);
ver = tadpmu_recv();
- printf("status %02x\n", ver);
+ printf("status 0x%02x\n", ver);
+#endif
mutex_init(&tadpmu_lock, MUTEX_DEFAULT, IPL_NONE);
+ mutex_init(&data_lock, MUTEX_DEFAULT, IPL_HIGH);
- tadpmu_sme = sysmon_envsys_create();
- tadpmu_sme->sme_name = "tadpmu";
- tadpmu_sme->sme_cookie = NULL;
- tadpmu_sme->sme_refresh = tadpmu_sensors_refresh;
+ tadpmu_sens_sme = sysmon_envsys_create();
+ tadpmu_sens_sme->sme_name = "tadpmu";
+ tadpmu_sens_sme->sme_cookie = NULL;
+ tadpmu_sens_sme->sme_refresh = tadpmu_sensors_refresh;
+
+ tadpmu_acad_sme = sysmon_envsys_create();
+ tadpmu_acad_sme->sme_name = "ac adapter";
+ tadpmu_acad_sme->sme_cookie = NULL;
+ tadpmu_acad_sme->sme_refresh = tadpmu_sensors_refresh;
+ tadpmu_acad_sme->sme_class = SME_CLASS_ACADAPTER;
+
+ tadpmu_batt_sme = sysmon_envsys_create();
+ tadpmu_batt_sme->sme_name = "battery";
+ tadpmu_batt_sme->sme_cookie = NULL;
+ tadpmu_batt_sme->sme_refresh = tadpmu_sensors_refresh;
+ tadpmu_batt_sme->sme_class = SME_CLASS_BATTERY;
+ tadpmu_sensors[0].state = ENVSYS_SINVALID;
tadpmu_sensors[0].units = ENVSYS_STEMP;
tadpmu_sensors[0].private = CMD_READ_SYSTEMP;
strcpy(tadpmu_sensors[0].desc, "systemp");
- sysmon_envsys_sensor_attach(tadpmu_sme, &tadpmu_sensors[0]);
+ sysmon_envsys_sensor_attach(tadpmu_sens_sme, &tadpmu_sensors[0]);
+
+ tadpmu_sensors[1].state = ENVSYS_SINVALID;
+ tadpmu_sensors[1].units = ENVSYS_INDICATOR;
+ tadpmu_sensors[1].private = CMD_READ_FAN_EN;
+ strcpy(tadpmu_sensors[1].desc, "fan on");
+ sysmon_envsys_sensor_attach(tadpmu_sens_sme, &tadpmu_sensors[1]);
+
+ tadpmu_sensors[2].state = ENVSYS_SINVALID;
+ tadpmu_sensors[2].units = ENVSYS_INDICATOR;
+ tadpmu_sensors[2].private = CMD_READ_GENSTAT;
+ strcpy(tadpmu_sensors[2].desc, "DC power");
+ sysmon_envsys_sensor_attach(tadpmu_acad_sme, &tadpmu_sensors[2]);
+
+ tadpmu_sensors[3].state = ENVSYS_SINVALID;
+ tadpmu_sensors[3].units = ENVSYS_SVOLTS_DC;
+ tadpmu_sensors[3].private = CMD_READ_VBATT;
+ strcpy(tadpmu_sensors[3].desc, "Vbatt");
+ sysmon_envsys_sensor_attach(tadpmu_batt_sme, &tadpmu_sensors[3]);
+
+ tadpmu_sensors[4].state = ENVSYS_SINVALID;
+ tadpmu_sensors[4].units = ENVSYS_BATTERY_CAPACITY;
+ tadpmu_sensors[4].private = CMD_READ_GENSTAT;
+ /* We must provide an initial value for battery capacity */
+ tadpmu_sensors[4].value_cur = ENVSYS_BATTERY_CAPACITY_NORMAL;
+ strcpy(tadpmu_sensors[4].desc, "capacity");
+ sysmon_envsys_sensor_attach(tadpmu_batt_sme, &tadpmu_sensors[4]);
+
+ tadpmu_sensors[5].state = ENVSYS_SINVALID;
+ tadpmu_sensors[5].units = ENVSYS_BATTERY_CHARGE;
+ tadpmu_sensors[5].private = CMD_READ_GENSTAT;
+ strcpy(tadpmu_sensors[5].desc, "charging");
+ sysmon_envsys_sensor_attach(tadpmu_batt_sme, &tadpmu_sensors[5]);
+
#ifdef TADPMU_DEBUG
- tadpmu_sensors[1].units = ENVSYS_INTEGER;
- tadpmu_sensors[1].private = 0x17;
- strcpy(tadpmu_sensors[1].desc, "reg 17");
- sysmon_envsys_sensor_attach(tadpmu_sme, &tadpmu_sensors[1]);
- tadpmu_sensors[2].units = ENVSYS_INTEGER;
- tadpmu_sensors[2].private = 0x18;
- strcpy(tadpmu_sensors[2].desc, "reg 18");
- sysmon_envsys_sensor_attach(tadpmu_sme, &tadpmu_sensors[2]);
- tadpmu_sensors[3].units = ENVSYS_INTEGER;
- tadpmu_sensors[3].private = CMD_READ_GENSTAT;
- strcpy(tadpmu_sensors[3].desc, "genstat");
- sysmon_envsys_sensor_attach(tadpmu_sme, &tadpmu_sensors[3]);
-#if 0
- tadpmu_sensors[4].units = ENVSYS_INTEGER;
- tadpmu_sensors[4].private = CMD_READ_VBATT;
- strcpy(tadpmu_sensors[4].desc, "Vbatt");
- sysmon_envsys_sensor_attach(tadpmu_sme, &tadpmu_sensors[4]);
+ tadpmu_sensors[6].state = ENVSYS_SINVALID;
+ tadpmu_sensors[6].units = ENVSYS_INTEGER;
+ tadpmu_sensors[6].private = CMD_READ_GENSTAT;
+ strcpy(tadpmu_sensors[6].desc, "genstat");
+ sysmon_envsys_sensor_attach(tadpmu_sens_sme, &tadpmu_sensors[6]);
#endif
-#endif
- sysmon_envsys_register(tadpmu_sme);
+
+ sysmon_envsys_register(tadpmu_sens_sme);
+ sysmon_envsys_register(tadpmu_acad_sme);
+ sysmon_envsys_register(tadpmu_batt_sme);
sysmon_task_queue_init();
memset(&tadpmu_pbutton, 0, sizeof(struct sysmon_pswitch));
@@ -349,12 +519,20 @@ tadpmu_init(bus_space_tag_t t, bus_space
aprint_error(
"unable to register power button with sysmon\n");
+ memset(&tadpmu_lidswitch, 0, sizeof(struct sysmon_pswitch));
tadpmu_lidswitch.smpsw_name = "lid";
tadpmu_lidswitch.smpsw_type = PSWITCH_TYPE_LID;
if (sysmon_pswitch_register(&tadpmu_lidswitch) != 0)
aprint_error(
"unable to register lid switch with sysmon\n");
+ memset(&tadpmu_dcpower, 0, sizeof(struct sysmon_pswitch));
+ tadpmu_dcpower.smpsw_name = "AC adapter";
+ tadpmu_dcpower.smpsw_type = PSWITCH_TYPE_ACADAPTER;
+ if (sysmon_pswitch_register(&tadpmu_dcpower) != 0)
+ aprint_error(
+ "unable to register AC adapter with sysmon\n");
+
kthread_create(PRI_NONE, 0, curcpu(), tadpmu_events, NULL,
&tadpmu_thread, "tadpmu_events");
Index: src/sys/arch/sparc64/dev/tadpmureg.h
diff -u src/sys/arch/sparc64/dev/tadpmureg.h:1.2 src/sys/arch/sparc64/dev/tadpmureg.h:1.3
--- src/sys/arch/sparc64/dev/tadpmureg.h:1.2 Sat Oct 13 19:53:43 2018
+++ src/sys/arch/sparc64/dev/tadpmureg.h Sat May 16 07:16:14 2020
@@ -1,4 +1,4 @@
-/* $NetBSD: tadpmureg.h,v 1.2 2018/10/13 19:53:43 macallan Exp $ */
+/* $NetBSD: tadpmureg.h,v 1.3 2020/05/16 07:16:14 jdc Exp $ */
/*-
* Copyright (c) 2018 Michael Lorenz <[email protected]>
@@ -26,7 +26,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
-/* registers and commands for the PMU found in Tadpole Viper laptops */
+/* registers and commands for the PMU found in Tadpole SPARCle/Viper laptops */
#ifndef TADPMUREG_H
#define TADPMUREG_H
@@ -46,23 +46,40 @@
#define CMD_SET_OPMODE 0x41 /* not sure what exactly this does... */
#define OPMODE_UNIX 0x75 /* other than toggling the UNIX mode */
#define OPMODE_OF 0x67 /* bit in the GENSTAT register */
+#define OPMODE_DBG_ON 0x64 /* Debug ON */
+#define OPMODE_DBG_OFF 0x6E /* Debug OFF */
+#define OPMODE_OBP 0x6F
+#define CMD_CHRGCTL 0x42
#define CMD_SET_BACKLIGHT 0x43 /* apparently 0 - 1f */
#define CMD_SET_CPUSPEED 0x44 /* in 10MHz, so 120 == 1.2GHz */
-#define CMD_SET_FANSPEED 0x46 /* ??? */
+#define CMD_SET_SPREADCLK 0x45
+#define CMD_SET_FANSPEED 0x46
#define CMD_SET_VOLUME 0x48 /* beeper volume */
+#define CMD_SET_DIR_CLK 0x80
+#define CMD_WRITE 0xC0
#define CMD_READ_GENSTAT 0x10
#define CMD_READ_BACKLIGHT 0x11
#define CMD_READ_SYSTEMP 0x12 /* temperature */
#define CMD_READ_VOLUME 0x13
-#define CMD_READ_VBATT 0x14
+#define CMD_READ_VBATT 0x14 /* Voltage * 10 (e.g. 120 = 12.0v) */
#define CMD_READ_VERSION 0x15
#define CMD_READ_CPUSPEED 0x16
-/* 0x17 returns a byte, always 0 */
-/* 0x18 returns a byte, always(?) 0x77 */
+#define CMD_READ_KEYSTAT 0x17 /* Pause-A, D, N, O, R */
+#define CMD_READ_FAN_EN 0x18 /* Fan(s): off=0x00, full=0x77 */
#define CMD_READ_GENSTAT2 0x19
+#define READ_DIPSWITCH 0x1A
+
#define CMD_READ_FANSPEED 0x50 /* takes a parameter, returns nothing? */
+#define CMD_SHUTDOWN 0x40
+#define CMD_BEEP 0x47 /* Start/stop beep, param is freq */
+#define CMD_READ_BMU 0x70
+#define CMD_REFLASH 0x49
+#define CMD_READ 0x89
+#define CMD_WRITE 0xC0
+#define CMD_WRITE_BMU 0xC1
+
/* these are according to the ROM methods
#define GENSTAT_DC_PRESENT 0x01
#define GENSTAT_DC_ENABLE 0x02
@@ -71,18 +88,38 @@
#define GENSTAT_LID_CLOSED 0x10
#define GENSTAT_UNIX_MODE 0x20
#define GENSTAT_SPREADSPECTRUM 0x40
-*/
-/* these are according to experiment */
+ Values of genstat (from observation)
+ 0b = on battery
+ 3b = battery charging
+ 1f = battery full
+ 1b = no battery
+ */
#define GENSTAT_UNIX_MODE 0x01
- #define GENSTAT_DC_PRESENT 0x08 /* guess */
- #define GENSTAT_DC_ENABLE 0x18 /* guess */
+#define GENSTAT_BATTERY_PRESENT 0x04 /* only valid if DC present? */
+#define GENSTAT_BATTERY_CHARGED 0x08
+#define GENSTAT_DC_PRESENT 0x10
+#define GENSTAT_BATTERY_CHARGING 0x20
#define GENSTAT_LID_CLOSED 0x80
+#define GENSTAT_STATE_BATTERY_FULL 0x1f
+#define GENSTAT_STATE_BATTERY_DISCHARGE 0x0b
+#define GENSTAT_STATE_BATTERY_CHARGE 0x3b
+
+#define GENSTAT2_DEBUG 0x01 /* PMU debug enable? */
#define GENSTAT2_MUTE 0x02
/* messages from interrupts */
-#define TADPMU_LID 0x05
-#define TADPMU_POWERBUTTON 0x06
+#define TADPMU_INTR_BATTERY_CHARGED 0x03
+#define TADPMU_INTR_DCPOWER 0x04
+#define TADPMU_INTR_LID 0x05
+#define TADPMU_INTR_POWERBUTTON 0x06
+#define TADPMU_INTR_BATTERY_VOLT 0xcd /* Voltage change */
+#define TADPMU_INTR_BATTERY_STATE 0xd6 /* e.g. warn -> crit */
+/* Other observed values:
+ 0xc9
+ 0xcb
+ 0xd2
+ */
-#endif /* TADPMUREG_H */
\ No newline at end of file
+#endif /* TADPMUREG_H */
Index: src/sys/arch/sparc64/dev/tadpmuvar.h
diff -u src/sys/arch/sparc64/dev/tadpmuvar.h:1.2 src/sys/arch/sparc64/dev/tadpmuvar.h:1.3
--- src/sys/arch/sparc64/dev/tadpmuvar.h:1.2 Sat Oct 13 19:53:43 2018
+++ src/sys/arch/sparc64/dev/tadpmuvar.h Sat May 16 07:16:14 2020
@@ -1,4 +1,4 @@
-/* $NetBSD: tadpmuvar.h,v 1.2 2018/10/13 19:53:43 macallan Exp $ */
+/* $NetBSD: tadpmuvar.h,v 1.3 2020/05/16 07:16:14 jdc Exp $ */
/*-
* Copyright (c) 2018 Michael Lorenz <[email protected]>
@@ -26,7 +26,7 @@
* POSSIBILITY OF SUCH DAMAGE.
*/
-/* functions to talk to the PMU found in Tadpole Viper laptops */
+/* functions to talk to the PMU found in Tadpole SPARCle and Viper laptops */
#ifndef TADPMUVAR_H
#define TADPMUVAR_H
@@ -34,4 +34,22 @@
int tadpmu_init(bus_space_tag_t, bus_space_handle_t, bus_space_handle_t);
int tadpmu_intr(void *);
-#endif /* TADPMUVAR_H */
\ No newline at end of file
+/* PMU events from the interrupt routine */
+#define TADPMU_EV_PWRBUTT (1 << 0)
+#define TADPMU_EV_LID (1 << 1)
+#define TADPMU_EV_DCPOWER (1 << 2)
+#define TADPMU_EV_BATTCHANGE (1 << 3)
+#define TADPMU_EV_BATTCHARGED (1 << 4)
+
+/* Battery thresholds versus voltage (higher voltage when charging) */
+#define TADPMU_BATT_DIS_CAP_CRIT 108
+#define TADPMU_BATT_DIS_CAP_WARN 110
+#define TADPMU_BATT_DIS_CAP_LOW 115
+#define TADPMU_BATT_DIS_CAP_NORM 120
+
+#define TADPMU_BATT_CHG_CAP_CRIT 116
+#define TADPMU_BATT_CHG_CAP_WARN 118
+#define TADPMU_BATT_CHG_CAP_LOW 123
+#define TADPMU_BATT_CHG_CAP_NORM 126
+
+#endif /* TADPMUVAR_H */
