sys/arch/macppc/dev/battery.c

   1 /*      $NetBSD: battery.c,v 1.10 2008/04/29 06:53:02 martin 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.10 2008/04/29 06:53:02 martin 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         struct device 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(struct device *, struct device *, void *);
  93 static int battery_match(struct device *, struct cfdata *, 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(battery, sizeof(struct battery_softc),
 100     battery_match, battery_attach, NULL, NULL);
 101
 102 static int
 103 battery_match(struct device *parent, struct cfdata *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(struct device *parent, struct device *self, void *aux)
 115 {
 116         struct battery_attach_args *baa = aux;
 117         struct battery_softc *sc = (struct battery_softc *)self;
 118         uint32_t reg;
 119
 120         sc->sc_pmu_ops = baa->baa_pmu_ops;
 121         printf(": 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                 printf("%s: unable to register AC power status with sysmon\n",
 149                     sc->sc_dev.dv_xname);
 150
 151 }
 152
 153 static int
 154 battery_update(struct battery_softc *sc, int out)
 155 {
 156         int len, vmax, pcharge, vb;
 157         uint8_t buf[16];
 158
 159         if (sc->sc_timestamp == time_second)
 160                 return 0;
 161         sc->sc_timestamp = time_second;
 162
 163         len = sc->sc_pmu_ops->do_command(sc->sc_pmu_ops->cookie,
 164             PMU_BATTERY_STATE, 0, NULL, 16, buf);
 165         if (len != 9)
 166                 return -1;
 167
 168         sc->sc_flags = buf[1];
 169
 170         if (out) {
 171                 if (buf[1] & PMU_PWR_AC_PRESENT)
 172                         printf(" AC");
 173                 if (buf[1] & PMU_PWR_BATT_CHARGING)
 174                         printf(" charging");
 175                 if (buf[1] & PMU_PWR_BATT_PRESENT)
 176                         printf(" present");
 177                 if (buf[1] & PMU_PWR_BATT_FULL)
 178                         printf(" full");
 179                 printf("\n");
 180         }
 181
 182         sc->sc_cpu_temp = buf[4];
 183
 184         if ((sc->sc_flags & PMU_PWR_BATT_PRESENT) == 0) {
 185                 sc->sc_voltage = 0;
 186                 sc->sc_current = 0;
 187                 sc->sc_bat_temp = 0;
 188                 sc->sc_charge = 0;
 189                 sc->sc_time = 0;
 190                 return 0;
 191         }
 192
 193         vmax = sc->sc_vmax_charged;
 194         vb = (buf[2] << 8) | buf[3];
 195         sc->sc_voltage = (vb * 265 + 72665) / 10;
 196         sc->sc_current = buf[6];
 197         if ((sc->sc_flags & PMU_PWR_AC_PRESENT) == 0) {
 198                 if (sc->sc_current > 200)
 199                         vb += ((sc->sc_current - 200) * 15) / 100;
 200         } else {
 201                 vmax = sc->sc_vmax_charging;
 202         }
 203         sc->sc_charge = (100 * vb) / vmax;
 204         if (sc->sc_flags & PMU_PWR_PCHARGE_RESET) {
 205                 pcharge = (buf[7] << 8) | buf[8];
 206                 if (pcharge > 6500)
 207                         pcharge = 6500;
 208                 pcharge = 100 - pcharge * 100 / 6500;
 209                 if (pcharge < sc->sc_charge)
 210                         sc->sc_charge = pcharge;
 211         }
 212         if (sc->sc_current > 0) {
 213                 sc->sc_time = (sc->sc_charge * 16440) / sc->sc_current;
 214         } else
 215                 sc->sc_time = 0;
 216
 217         sc->sc_bat_temp = buf[5];
 218
 219         if (out) {
 220                 printf("voltage: %d.%03d\n", sc->sc_voltage / 1000,
 221                     sc->sc_voltage % 1000);
 222                 printf("charge:  %d%%\n", sc->sc_charge);
 223                 if (sc->sc_time > 0)
 224                         printf("time:    %d:%02d\n", sc->sc_time / 60,
 225                             sc->sc_time % 60);
 226         }
 227
 228         return 0;
 229 }
 230
 231 #define INITDATA(index, unit, string)                                   \
 232         sc->sc_sensor[index].units = unit;                              \
 233         snprintf(sc->sc_sensor[index].desc,                             \
 234             sizeof(sc->sc_sensor[index].desc), "%s", string);
 235
 236 static void
 237 battery_setup_envsys(struct battery_softc *sc)
 238 {
 239         int i;
 240
 241         sc->sc_sme = sysmon_envsys_create();
 242
 243         INITDATA(BAT_CPU_TEMPERATURE, ENVSYS_STEMP, "CPU temperature");
 244         INITDATA(BAT_AC_PRESENT, ENVSYS_INDICATOR, "AC present");
 245         INITDATA(BAT_PRESENT, ENVSYS_INDICATOR, "Battery present");
 246         INITDATA(BAT_VOLTAGE, ENVSYS_SVOLTS_DC, "Battery voltage");
 247         INITDATA(BAT_CHARGE, ENVSYS_SAMPHOUR, "Battery charge");
 248         INITDATA(BAT_MAX_CHARGE, ENVSYS_SAMPHOUR, "Battery design cap");
 249         INITDATA(BAT_CURRENT, ENVSYS_SAMPS, "Battery current");
 250         INITDATA(BAT_TEMPERATURE, ENVSYS_STEMP, "Battery temperature");
 251         INITDATA(BAT_CHARGING, ENVSYS_BATTERY_CHARGE, "Battery charging");
 252         INITDATA(BAT_FULL, ENVSYS_INDICATOR, "Battery full");
 253 #undef INITDATA
 254
 255         for (i = 0; i < BAT_NSENSORS; i++) {
 256                 if (sysmon_envsys_sensor_attach(sc->sc_sme,
 257                                                 &sc->sc_sensor[i])) {
 258                         sysmon_envsys_destroy(sc->sc_sme);
 259                         return;
 260                 }
 261         }
 262
 263         sc->sc_sme->sme_name = sc->sc_dev.dv_xname;
 264         sc->sc_sme->sme_cookie = sc;
 265         sc->sc_sme->sme_refresh = battery_refresh;
 266
 267         if (sysmon_envsys_register(sc->sc_sme)) {
 268                 aprint_error("%s: unable to register with sysmon\n",
 269                     sc->sc_dev.dv_xname);
 270                 sysmon_envsys_destroy(sc->sc_sme);
 271         }
 272 }
 273
 274 static void
 275 battery_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
 276 {
 277         struct battery_softc *sc = sme->sme_cookie;
 278         int which = edata->sensor;
 279
 280         battery_update(sc, 0);
 281
 282         switch (which) {
 283         case BAT_CPU_TEMPERATURE:
 284                 edata->value_cur = sc->sc_cpu_temp * 1000000 + 273150000;
 285                 break;
 286         case BAT_AC_PRESENT:
 287                 edata->value_cur = (sc->sc_flags & PMU_PWR_AC_PRESENT);
 288                 break;
 289         case BAT_PRESENT:
 290                 edata->value_cur = (sc->sc_flags & PMU_PWR_BATT_PRESENT);
 291                 break;
 292         case BAT_VOLTAGE:
 293                 edata->value_cur = sc->sc_voltage * 1000;
 294                 break;
 295         case BAT_CURRENT:
 296                 edata->value_cur = sc->sc_current * 1000;
 297                 break;
 298         case BAT_CHARGE:
 299                 edata->value_cur = sc->sc_charge;
 300                 break;
 301         case BAT_MAX_CHARGE:
 302                 edata->value_cur = 100;
 303                 break;
 304         case BAT_TEMPERATURE:
 305                 edata->value_cur = sc->sc_bat_temp * 1000000 + 273150000;
 306                 break;
 307         case BAT_CHARGING:
 308                 if ((sc->sc_flags & PMU_PWR_BATT_CHARGING) &&
 309                     (sc->sc_flags & PMU_PWR_AC_PRESENT))
 310                         edata->value_cur = 1;
 311                 else
 312                         edata->value_cur = 0;
 313
 314                 break;
 315         case BAT_FULL:
 316                 edata->value_cur = (sc->sc_flags & PMU_PWR_BATT_FULL);
 317                 break;
 318         }
 319
 320         edata->state = ENVSYS_SVALID;
 321 }
 322
 323 static void
 324 battery_poll(void *cookie)
 325 {
 326         struct battery_softc *sc = cookie;
 327
 328
 329         battery_update(sc, 0);
 330         if ((sc->sc_flags & PMU_PWR_AC_PRESENT) == sc->sc_oflags)
 331                 return;
 332
 333         sc->sc_oflags = sc->sc_flags & PMU_PWR_AC_PRESENT;
 334
 335         sysmon_pswitch_event(&sc->sc_sm_acpower,
 336             sc->sc_oflags ? PSWITCH_EVENT_PRESSED :
 337             PSWITCH_EVENT_RELEASED);
 338 }