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 <macal...@netbsd.org> @@ -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 <macal...@netbsd.org> @@ -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 <macal...@netbsd.org> @@ -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 */