battery.c revision 1.12
1 /* $NetBSD: battery.c,v 1.12 2011/06/18 08:08:28 matt Exp $ */ 2 3 /*- 4 * Copyright (c) 2007 Michael Lorenz 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __KERNEL_RCSID(0, "$NetBSD: battery.c,v 1.12 2011/06/18 08:08:28 matt Exp $"); 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/kernel.h> 35 #include <sys/device.h> 36 #include <sys/proc.h> 37 38 #include <dev/sysmon/sysmonvar.h> 39 #include <dev/sysmon/sysmon_taskq.h> 40 41 #include <macppc/dev/pmuvar.h> 42 #include <macppc/dev/batteryvar.h> 43 #include <machine/bus.h> 44 #include <machine/pio.h> 45 #include "opt_battery.h" 46 47 #ifdef BATTERY_DEBUG 48 #define DPRINTF printf 49 #else 50 #define DPRINTF while (0) printf 51 #endif 52 53 #define BTYPE_COMET 1 54 #define BTYPE_HOOPER 2 55 56 #define BAT_CPU_TEMPERATURE 0 57 #define BAT_AC_PRESENT 1 58 #define BAT_PRESENT 2 59 #define BAT_VOLTAGE 3 60 #define BAT_CURRENT 4 61 #define BAT_MAX_CHARGE 5 62 #define BAT_CHARGE 6 63 #define BAT_CHARGING 7 64 #define BAT_FULL 8 65 #define BAT_TEMPERATURE 9 66 #define BAT_NSENSORS 10 /* number of sensors */ 67 68 struct battery_softc { 69 device_t sc_dev; 70 struct pmu_ops *sc_pmu_ops; 71 int sc_type; 72 73 /* envsys stuff */ 74 struct sysmon_envsys *sc_sme; 75 envsys_data_t sc_sensor[BAT_NSENSORS]; 76 struct sysmon_pswitch sc_sm_acpower; 77 78 /* battery status */ 79 int sc_flags; 80 int sc_oflags; 81 int sc_voltage; 82 int sc_charge; 83 int sc_current; 84 int sc_time; 85 int sc_cpu_temp; 86 int sc_bat_temp; 87 int sc_vmax_charged; 88 int sc_vmax_charging; 89 uint32_t sc_timestamp; 90 }; 91 92 static void battery_attach(device_t, device_t, void *); 93 static int battery_match(device_t, cfdata_t, void *); 94 static int battery_update(struct battery_softc *, int); 95 static void battery_setup_envsys(struct battery_softc *); 96 static void battery_refresh(struct sysmon_envsys *, envsys_data_t *); 97 static void battery_poll(void *); 98 99 CFATTACH_DECL_NEW(battery, sizeof(struct battery_softc), 100 battery_match, battery_attach, NULL, NULL); 101 102 static int 103 battery_match(device_t parent, cfdata_t cf, void *aux) 104 { 105 struct battery_attach_args *baa = aux; 106 107 if (baa->baa_type == BATTERY_TYPE_LEGACY) 108 return 1; 109 110 return 0; 111 } 112 113 static void 114 battery_attach(device_t parent, device_t self, void *aux) 115 { 116 struct battery_attach_args *baa = aux; 117 struct battery_softc *sc = device_private(self); 118 uint32_t reg; 119 120 sc->sc_pmu_ops = baa->baa_pmu_ops; 121 aprint_normal(": legacy battery "); 122 123 reg = in32rb(0xf3000034); 124 DPRINTF("reg: %08x\n", reg); 125 if (reg & 0x20000000) { 126 sc->sc_type = BTYPE_HOOPER; 127 sc->sc_vmax_charged = 330; 128 sc->sc_vmax_charging = 365; 129 printf("[hooper]\n"); 130 } else { 131 sc->sc_type = BTYPE_COMET; 132 sc->sc_vmax_charged = 189; 133 sc->sc_vmax_charging = 213; 134 printf("[comet]\n"); 135 } 136 battery_update(sc, 1); 137 /* trigger a status update */ 138 sc->sc_oflags = ~sc->sc_flags; 139 140 battery_setup_envsys(sc); 141 sc->sc_pmu_ops->register_callback(sc->sc_pmu_ops->cookie, battery_poll, 142 sc); 143 144 memset(&sc->sc_sm_acpower, 0, sizeof(struct sysmon_pswitch)); 145 sc->sc_sm_acpower.smpsw_name = "AC Power"; 146 sc->sc_sm_acpower.smpsw_type = PSWITCH_TYPE_ACADAPTER; 147 if (sysmon_pswitch_register(&sc->sc_sm_acpower) != 0) 148 aprint_error_dev(self, 149 "unable to register AC power status with sysmon\n"); 150 } 151 152 static int 153 battery_update(struct battery_softc *sc, int out) 154 { 155 int len, vmax, pcharge, vb; 156 uint8_t buf[16]; 157 158 if (sc->sc_timestamp == time_second) 159 return 0; 160 sc->sc_timestamp = time_second; 161 162 len = sc->sc_pmu_ops->do_command(sc->sc_pmu_ops->cookie, 163 PMU_BATTERY_STATE, 0, NULL, 16, buf); 164 if (len != 9) 165 return -1; 166 167 sc->sc_flags = buf[1]; 168 169 if (out) { 170 if (buf[1] & PMU_PWR_AC_PRESENT) 171 printf(" AC"); 172 if (buf[1] & PMU_PWR_BATT_CHARGING) 173 printf(" charging"); 174 if (buf[1] & PMU_PWR_BATT_PRESENT) 175 printf(" present"); 176 if (buf[1] & PMU_PWR_BATT_FULL) 177 printf(" full"); 178 printf("\n"); 179 } 180 181 sc->sc_cpu_temp = buf[4]; 182 183 if ((sc->sc_flags & PMU_PWR_BATT_PRESENT) == 0) { 184 sc->sc_voltage = 0; 185 sc->sc_current = 0; 186 sc->sc_bat_temp = 0; 187 sc->sc_charge = 0; 188 sc->sc_time = 0; 189 return 0; 190 } 191 192 vmax = sc->sc_vmax_charged; 193 vb = (buf[2] << 8) | buf[3]; 194 sc->sc_voltage = (vb * 265 + 72665) / 10; 195 sc->sc_current = buf[6]; 196 if ((sc->sc_flags & PMU_PWR_AC_PRESENT) == 0) { 197 if (sc->sc_current > 200) 198 vb += ((sc->sc_current - 200) * 15) / 100; 199 } else { 200 vmax = sc->sc_vmax_charging; 201 } 202 sc->sc_charge = (100 * vb) / vmax; 203 if (sc->sc_flags & PMU_PWR_PCHARGE_RESET) { 204 pcharge = (buf[7] << 8) | buf[8]; 205 if (pcharge > 6500) 206 pcharge = 6500; 207 pcharge = 100 - pcharge * 100 / 6500; 208 if (pcharge < sc->sc_charge) 209 sc->sc_charge = pcharge; 210 } 211 if (sc->sc_current > 0) { 212 sc->sc_time = (sc->sc_charge * 16440) / sc->sc_current; 213 } else 214 sc->sc_time = 0; 215 216 sc->sc_bat_temp = buf[5]; 217 218 if (out) { 219 printf("voltage: %d.%03d\n", sc->sc_voltage / 1000, 220 sc->sc_voltage % 1000); 221 printf("charge: %d%%\n", sc->sc_charge); 222 if (sc->sc_time > 0) 223 printf("time: %d:%02d\n", sc->sc_time / 60, 224 sc->sc_time % 60); 225 } 226 227 return 0; 228 } 229 230 #define INITDATA(index, unit, string) \ 231 sc->sc_sensor[index].units = unit; \ 232 snprintf(sc->sc_sensor[index].desc, \ 233 sizeof(sc->sc_sensor[index].desc), "%s", string); 234 235 static void 236 battery_setup_envsys(struct battery_softc *sc) 237 { 238 int i; 239 240 sc->sc_sme = sysmon_envsys_create(); 241 242 INITDATA(BAT_CPU_TEMPERATURE, ENVSYS_STEMP, "CPU temperature"); 243 INITDATA(BAT_AC_PRESENT, ENVSYS_INDICATOR, "AC present"); 244 INITDATA(BAT_PRESENT, ENVSYS_INDICATOR, "Battery present"); 245 INITDATA(BAT_VOLTAGE, ENVSYS_SVOLTS_DC, "Battery voltage"); 246 INITDATA(BAT_CHARGE, ENVSYS_SAMPHOUR, "Battery charge"); 247 INITDATA(BAT_MAX_CHARGE, ENVSYS_SAMPHOUR, "Battery design cap"); 248 INITDATA(BAT_CURRENT, ENVSYS_SAMPS, "Battery current"); 249 INITDATA(BAT_TEMPERATURE, ENVSYS_STEMP, "Battery temperature"); 250 INITDATA(BAT_CHARGING, ENVSYS_BATTERY_CHARGE, "Battery charging"); 251 INITDATA(BAT_FULL, ENVSYS_INDICATOR, "Battery full"); 252 #undef INITDATA 253 254 for (i = 0; i < BAT_NSENSORS; i++) { 255 if (sysmon_envsys_sensor_attach(sc->sc_sme, 256 &sc->sc_sensor[i])) { 257 sysmon_envsys_destroy(sc->sc_sme); 258 return; 259 } 260 } 261 262 sc->sc_sme->sme_name = device_xname(sc->sc_dev); 263 sc->sc_sme->sme_cookie = sc; 264 sc->sc_sme->sme_refresh = battery_refresh; 265 266 if (sysmon_envsys_register(sc->sc_sme)) { 267 aprint_error_dev(sc->sc_dev, 268 "unable to register with sysmon\n"); 269 sysmon_envsys_destroy(sc->sc_sme); 270 } 271 } 272 273 static void 274 battery_refresh(struct sysmon_envsys *sme, envsys_data_t *edata) 275 { 276 struct battery_softc *sc = sme->sme_cookie; 277 int which = edata->sensor; 278 279 battery_update(sc, 0); 280 281 switch (which) { 282 case BAT_CPU_TEMPERATURE: 283 edata->value_cur = sc->sc_cpu_temp * 1000000 + 273150000; 284 break; 285 case BAT_AC_PRESENT: 286 edata->value_cur = (sc->sc_flags & PMU_PWR_AC_PRESENT); 287 break; 288 case BAT_PRESENT: 289 edata->value_cur = (sc->sc_flags & PMU_PWR_BATT_PRESENT); 290 break; 291 case BAT_VOLTAGE: 292 edata->value_cur = sc->sc_voltage * 1000; 293 break; 294 case BAT_CURRENT: 295 edata->value_cur = sc->sc_current * 1000; 296 break; 297 case BAT_CHARGE: 298 edata->value_cur = sc->sc_charge; 299 break; 300 case BAT_MAX_CHARGE: 301 edata->value_cur = 100; 302 break; 303 case BAT_TEMPERATURE: 304 edata->value_cur = sc->sc_bat_temp * 1000000 + 273150000; 305 break; 306 case BAT_CHARGING: 307 if ((sc->sc_flags & PMU_PWR_BATT_CHARGING) && 308 (sc->sc_flags & PMU_PWR_AC_PRESENT)) 309 edata->value_cur = 1; 310 else 311 edata->value_cur = 0; 312 313 break; 314 case BAT_FULL: 315 edata->value_cur = (sc->sc_flags & PMU_PWR_BATT_FULL); 316 break; 317 } 318 319 edata->state = ENVSYS_SVALID; 320 } 321 322 static void 323 battery_poll(void *cookie) 324 { 325 struct battery_softc *sc = cookie; 326 327 328 battery_update(sc, 0); 329 if ((sc->sc_flags & PMU_PWR_AC_PRESENT) == sc->sc_oflags) 330 return; 331 332 sc->sc_oflags = sc->sc_flags & PMU_PWR_AC_PRESENT; 333 334 sysmon_pswitch_event(&sc->sc_sm_acpower, 335 sc->sc_oflags ? PSWITCH_EVENT_PRESSED : 336 PSWITCH_EVENT_RELEASED); 337 } 338
Indexes created Tue Sep 30 11:09:46 GMT 2025