1 /* $NetBSD: stvii.c,v 1.7 2023/12/20 14:12:25 thorpej Exp $ */ 2 3 /*- 4 * Copyright (C) 2011 Michael Lorenz. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 24 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27 /* 28 * a driver for the ST7 microcontroller found in Gdium Liberty 1000 notebooks 29 */ 30 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: stvii.c,v 1.7 2023/12/20 14:12:25 thorpej Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/kernel.h> 38 #include <sys/device.h> 39 #include <sys/sysctl.h> 40 #include <sys/kthread.h> 41 #include <sys/proc.h> 42 43 #include <dev/sysmon/sysmonvar.h> 44 #include <dev/sysmon/sysmon_taskq.h> 45 46 #include <dev/i2c/i2cvar.h> 47 48 #include "opt_stvii.h" 49 50 #ifdef STVII_DEBUG 51 #define DPRINTF aprint_error 52 #else 53 #define DPRINTF while (0) printf 54 #endif 55 56 /* register definitions from OpenBSD */ 57 #define ST7_VERSION 0x00 /* only on later mobos */ 58 59 #define ST7_STATUS 0x01 60 #define STS_LID_CLOSED 0x01 61 #define STS_POWER_BTN_DOWN 0x02 62 #define STS_BATTERY_PRESENT 0x04 /* not available on old mobo */ 63 #define STS_POWER_AVAILABLE 0x08 64 #define STS_WAVELAN_BTN_DOWN 0x10 /* ``enable'' on old mobo */ 65 #define STS_AC_AVAILABLE 0x20 66 #define ST7_CONTROL 0x02 67 #define STC_DDR_CLOCK 0x01 68 #define STC_CHARGE_LED_LIT 0x02 69 #define STC_BEEP 0x04 70 #define STC_DDR_POWER 0x08 71 #define STC_TRICKLE 0x10 /* trickle charge rate */ 72 #define STC_RADIO_ENABLE 0x20 /* enable wavelan rf, later mobos */ 73 #define STC_MAIN_POWER 0x40 74 #define STC_CHARGE_ENABLE 0x80 75 #define ST7_BATTERY_L 0x03 76 #define ST7_BATTERY_H 0x04 77 #define ST7_SIGNATURE 0x05 78 #define STSIG_EC_CONTROL 0x00 79 #define STSIG_OS_CONTROL 0xae 80 /* rough battery operating state limits */ 81 #define STSEC_BAT_MIN_VOLT 7000000 /* 7V */ 82 #define STSEC_BAT_MAX_VOLT 8000000 /* 8V */ 83 84 #define BAT_AC_PRESENT 0 85 #define BAT_BATTERY_PRESENT 1 86 #define BAT_CHARGING 2 87 #define BAT_CHARGE 3 88 #define BAT_MAX_CHARGE 4 89 #define BAT_NSENSORS 5 90 91 struct stvii_softc { 92 device_t sc_dev; 93 i2c_tag_t sc_i2c; 94 int sc_address, sc_version; 95 int sc_sleep; 96 int sc_flags, sc_charge, sc_bat_level; 97 uint8_t sc_control; 98 struct sysmon_envsys *sc_sme; 99 envsys_data_t sc_sensor[BAT_NSENSORS]; 100 struct sysmon_pswitch sc_sm_acpower; 101 struct sysmon_pswitch sc_sm_lid; 102 struct sysmon_pswitch sc_sm_powerbutton; 103 }; 104 105 static void stvii_attach(device_t, device_t, void *); 106 static int stvii_match(device_t, cfdata_t, void *); 107 static void stvii_writereg(struct stvii_softc *, int, uint8_t); 108 static int stvii_readreg(struct stvii_softc *, int); 109 static void stvii_worker(void *); 110 static void stvii_setup_envsys(struct stvii_softc *); 111 static void stvii_refresh(struct sysmon_envsys *, envsys_data_t *); 112 static int stvii_battery_level(struct stvii_softc *); 113 114 CFATTACH_DECL_NEW(stvii, sizeof(struct stvii_softc), 115 stvii_match, stvii_attach, NULL, NULL); 116 117 void stvii_poweroff(void); 118 static device_t stvii_dev = NULL; 119 120 #define BAT_FULL 8000000 121 #define BAT_LOW 7100000 122 123 static int 124 stvii_match(device_t parent, cfdata_t cf, void *aux) 125 { 126 struct i2c_attach_args *args = aux; 127 int ret = -1; 128 uint8_t out = ST7_VERSION, in = 0; 129 130 /* see if we can talk to something at address 0x40 */ 131 if (args->ia_addr == 0x40) { 132 iic_acquire_bus(args->ia_tag, 0); 133 ret = iic_exec(args->ia_tag, I2C_OP_READ_WITH_STOP, args->ia_addr, 134 &out, 1, &in, 1, 0); 135 DPRINTF("%02x\n", in); 136 iic_release_bus(args->ia_tag, 0); 137 } 138 return (ret >= 0) ? I2C_MATCH_ADDRESS_AND_PROBE : 0; 139 } 140 141 static void 142 stvii_attach(device_t parent, device_t self, void *aux) 143 { 144 struct stvii_softc *sc = device_private(self); 145 struct i2c_attach_args *args = aux; 146 uint8_t ver, reg; 147 148 sc->sc_dev = self; 149 stvii_dev = self; 150 sc->sc_address = args->ia_addr; 151 aprint_normal(": ST7 Microcontroller\n"); 152 sc->sc_i2c = args->ia_tag; 153 ver = stvii_readreg(sc, ST7_VERSION); 154 sc->sc_version = ver; 155 aprint_normal_dev(sc->sc_dev, "firmware version %d.%d\n", (ver >> 4) & 0xf, ver & 0xf); 156 #ifdef STVII_DEBUG 157 { 158 int i; 159 160 for (i = 0; i < 6; i++) { 161 printf("%02x ", stvii_readreg(sc, i)); 162 } 163 printf("\n"); 164 } 165 #endif 166 stvii_writereg(sc, ST7_SIGNATURE, STSIG_OS_CONTROL); 167 reg = stvii_readreg(sc, ST7_CONTROL); 168 reg |= STC_RADIO_ENABLE; 169 stvii_writereg(sc, ST7_CONTROL, reg); 170 sc->sc_control = reg; 171 reg = stvii_readreg(sc, ST7_CONTROL); 172 173 sc->sc_bat_level = stvii_battery_level(sc); 174 175 if (kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL, stvii_worker, sc, 176 NULL, "stvii") != 0) { 177 aprint_error_dev(sc->sc_dev, "Failed to start kernel thread\n"); 178 } 179 180 memset(&sc->sc_sm_acpower, 0, sizeof(struct sysmon_pswitch)); 181 sc->sc_sm_acpower.smpsw_name = "AC Power"; 182 sc->sc_sm_acpower.smpsw_type = PSWITCH_TYPE_ACADAPTER; 183 if (sysmon_pswitch_register(&sc->sc_sm_acpower) != 0) 184 printf("%s: unable to register AC power status with sysmon\n", 185 device_xname(sc->sc_dev)); 186 memset(&sc->sc_sm_lid, 0, sizeof(struct sysmon_pswitch)); 187 sc->sc_sm_lid.smpsw_name = "Lid Switch"; 188 sc->sc_sm_lid.smpsw_type = PSWITCH_TYPE_LID; 189 if (sysmon_pswitch_register(&sc->sc_sm_lid) != 0) 190 printf("%s: unable to register lid switch with sysmon\n", 191 device_xname(sc->sc_dev)); 192 memset(&sc->sc_sm_powerbutton, 0, sizeof(struct sysmon_pswitch)); 193 sc->sc_sm_powerbutton.smpsw_name = "Power Button"; 194 sc->sc_sm_powerbutton.smpsw_type = PSWITCH_TYPE_POWER; 195 if (sysmon_pswitch_register(&sc->sc_sm_powerbutton) != 0) 196 printf("%s: unable to register power button with sysmon\n", 197 device_xname(sc->sc_dev)); 198 stvii_setup_envsys(sc); 199 } 200 201 static void 202 stvii_writereg(struct stvii_softc *sc, int reg, uint8_t val) 203 { 204 uint8_t out[2] = {reg, val}; 205 206 if ((reg < 0) || (reg > 5)) 207 return; 208 209 iic_acquire_bus(sc->sc_i2c, 0); 210 iic_exec(sc->sc_i2c, I2C_OP_WRITE_WITH_STOP, sc->sc_address, out, 2, NULL, 0, 0); 211 iic_release_bus(sc->sc_i2c, 0); 212 } 213 214 static int 215 stvii_readreg(struct stvii_softc *sc, int reg) 216 { 217 uint8_t inreg[1], outreg[1]; 218 int ret = 1, bail = 0; 219 220 if ((reg < 0) || (reg > 5)) 221 return 0xff; 222 inreg[0] = 0x77; 223 outreg[0] = reg; 224 iic_acquire_bus(sc->sc_i2c, 0); 225 while ((ret != 0) && (bail < 10)) { 226 ret = iic_exec(sc->sc_i2c, I2C_OP_READ_WITH_STOP, 227 sc->sc_address, outreg, 1, inreg, 1, 0); 228 bail++; 229 delay(10); 230 } 231 iic_release_bus(sc->sc_i2c, 0); 232 if (ret != 0) 233 return -1; 234 return inreg[0]; 235 } 236 237 static int 238 stvii_battery_level(struct stvii_softc *sc) 239 { 240 int bl, bh, ret; 241 242 bl = stvii_readreg(sc, ST7_BATTERY_L); 243 bh = stvii_readreg(sc, ST7_BATTERY_H); 244 ret = (bl & 3) | (bh << 2); 245 ret = ((ret * 10000) / 1024) * 1000; 246 return ret; 247 } 248 249 static void 250 stvii_worker(void *cookie) 251 { 252 struct stvii_softc *sc = cookie; 253 int status = 0, st, cnt = 4; 254 int bl; 255 int charging = 0; 256 int ok = TRUE; 257 uint8_t nctrl; 258 259 /* if we were charging when we took over, keep charging */ 260 if (sc->sc_control & STC_CHARGE_ENABLE) 261 charging = 1; 262 263 while (ok) { 264 st = stvii_readreg(sc, ST7_STATUS); 265 /* 266 * I get i2c timeouts when the power button is pressed. 267 * According to the linux driver this happens on firmware 268 * version 0x13 and newer, mine is 0x16. 269 * So, when we see read errors on the right version we assume 270 * it's the power button as long as the lid is open 271 * ( the button is inside the lid ) 272 */ 273 if ((st == -1) && (sc->sc_version >= 0x13)) { 274 if ((status & (STS_LID_CLOSED | STS_POWER_BTN_DOWN) ) 275 == 0) { 276 st = status | STS_POWER_BTN_DOWN; 277 } 278 } 279 if ((st != -1) && (st != status)) { 280 if ((status ^ st) & STS_LID_CLOSED) { 281 sysmon_pswitch_event(&sc->sc_sm_lid, 282 ((st & STS_LID_CLOSED) ? 283 PSWITCH_EVENT_PRESSED : 284 PSWITCH_EVENT_RELEASED)); 285 } 286 if ((status ^ st) & STS_AC_AVAILABLE) { 287 sysmon_pswitch_event(&sc->sc_sm_acpower, 288 ((st & STS_AC_AVAILABLE) ? 289 PSWITCH_EVENT_PRESSED : 290 PSWITCH_EVENT_RELEASED)); 291 } 292 if ((status ^ st) & STS_POWER_BTN_DOWN) { 293 sysmon_pswitch_event(&sc->sc_sm_powerbutton, 294 ((st & STS_POWER_BTN_DOWN) ? 295 PSWITCH_EVENT_PRESSED : 296 PSWITCH_EVENT_RELEASED)); 297 } 298 status = st; 299 } 300 sc->sc_flags = status; 301 if (cnt >= 4) { 302 nctrl = sc->sc_control & ~(STC_TRICKLE | STC_CHARGE_ENABLE); 303 bl = stvii_battery_level(sc); 304 sc->sc_bat_level = bl; 305 if (charging && (bl > BAT_FULL)) { 306 /* stop charging, we're full */ 307 charging = 0; 308 } else if (!charging && (bl < BAT_LOW)) { 309 charging = 1; 310 } 311 if (st & STS_AC_AVAILABLE) { 312 if (charging) { 313 nctrl |= STC_CHARGE_ENABLE; 314 } else 315 nctrl |= STC_TRICKLE; 316 } 317 if (nctrl != sc->sc_control) { 318 sc->sc_control = nctrl; 319 stvii_writereg(sc, ST7_CONTROL, sc->sc_control); 320 } 321 cnt = 0; 322 } else 323 cnt++; 324 tsleep(&sc->sc_sleep, 0, "stvii", hz / 2); 325 } 326 } 327 328 #define INITDATA(index, unit, string) \ 329 sc->sc_sensor[index].units = unit; \ 330 sc->sc_sensor[index].state = ENVSYS_SINVALID; \ 331 snprintf(sc->sc_sensor[index].desc, \ 332 sizeof(sc->sc_sensor[index].desc), "%s", string); 333 334 static void 335 stvii_setup_envsys(struct stvii_softc *sc) 336 { 337 int i; 338 339 sc->sc_sme = sysmon_envsys_create(); 340 341 INITDATA(BAT_AC_PRESENT, ENVSYS_INDICATOR, "AC present"); 342 INITDATA(BAT_BATTERY_PRESENT, ENVSYS_INDICATOR, "Battery present"); 343 INITDATA(BAT_CHARGING, ENVSYS_BATTERY_CHARGE, "Battery charging"); 344 INITDATA(BAT_CHARGE, ENVSYS_SVOLTS_DC, "Battery voltage"); 345 INITDATA(BAT_MAX_CHARGE, ENVSYS_SVOLTS_DC, "Battery design cap"); 346 #undef INITDATA 347 348 for (i = 0; i < BAT_NSENSORS; i++) { 349 if (sysmon_envsys_sensor_attach(sc->sc_sme, 350 &sc->sc_sensor[i])) { 351 sysmon_envsys_destroy(sc->sc_sme); 352 return; 353 } 354 } 355 356 sc->sc_sme->sme_name = device_xname(sc->sc_dev); 357 sc->sc_sme->sme_cookie = sc; 358 sc->sc_sme->sme_refresh = stvii_refresh; 359 360 if (sysmon_envsys_register(sc->sc_sme)) { 361 aprint_error_dev(sc->sc_dev, 362 "unable to register with sysmon\n"); 363 sysmon_envsys_destroy(sc->sc_sme); 364 } 365 } 366 367 static void 368 stvii_refresh(struct sysmon_envsys *sme, envsys_data_t *edata) 369 { 370 struct stvii_softc *sc = sme->sme_cookie; 371 int which = edata->sensor; 372 373 edata->state = ENVSYS_SINVALID; 374 switch (which) { 375 case BAT_AC_PRESENT: 376 edata->value_cur = (sc->sc_flags & STS_AC_AVAILABLE); 377 edata->state = ENVSYS_SVALID; 378 break; 379 case BAT_BATTERY_PRESENT: 380 edata->value_cur = (sc->sc_flags & STS_BATTERY_PRESENT); 381 edata->state = ENVSYS_SVALID; 382 break; 383 case BAT_CHARGE: 384 if (sc->sc_flags & STS_BATTERY_PRESENT) { 385 edata->value_cur = sc->sc_bat_level; 386 edata->state = ENVSYS_SVALID; 387 } 388 break; 389 case BAT_MAX_CHARGE: 390 if (sc->sc_flags & STS_BATTERY_PRESENT) { 391 edata->value_cur = 8000000; 392 /*edata->state = ENVSYS_SVALID;*/ 393 } 394 break; 395 case BAT_CHARGING: 396 edata->value_cur = sc->sc_control & STC_CHARGE_ENABLE; 397 edata->state = ENVSYS_SVALID; 398 break; 399 } 400 } 401 402 void 403 stvii_poweroff(void) 404 { 405 struct stvii_softc *sc = device_private(stvii_dev); 406 int ctl; 407 408 if (sc == NULL) 409 return; 410 ctl = stvii_readreg(sc, ST7_CONTROL); 411 if (ctl == -1) 412 return; 413 stvii_writereg(sc, ST7_CONTROL, ctl & ~(STC_MAIN_POWER | STC_DDR_POWER)); 414 } 415
Indexes created Wed Oct 01 15:09:59 GMT 2025