drivers/power/tosa_battery.c

   1 /*
   2  * Battery and Power Management code for the Sharp SL-6000x
   3  *
   4  * Copyright (c) 2005 Dirk Opfer
   5  * Copyright (c) 2008 Dmitry Baryshkov
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  */
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/power_supply.h>
  15 #include <linux/wm97xx.h>
  16 #include <linux/delay.h>
  17 #include <linux/spinlock.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/gpio.h>
  20
  21 #include <asm/mach-types.h>
  22 #include <mach/tosa.h>
  23
  24 static DEFINE_MUTEX(bat_lock); /* protects gpio pins */
  25 static struct work_struct bat_work;
  26
  27 struct tosa_bat {
  28         int status;
  29         struct power_supply psy;
  30         int full_chrg;
  31
  32         struct mutex work_lock; /* protects data */
  33
  34         bool (*is_present)(struct tosa_bat *bat);
  35         int gpio_full;
  36         int gpio_charge_off;
  37
  38         int technology;
  39
  40         int gpio_bat;
  41         int adc_bat;
  42         int adc_bat_divider;
  43         int bat_max;
  44         int bat_min;
  45
  46         int gpio_temp;
  47         int adc_temp;
  48         int adc_temp_divider;
  49 };
  50
  51 static struct tosa_bat tosa_bat_main;
  52 static struct tosa_bat tosa_bat_jacket;
  53
  54 static unsigned long tosa_read_bat(struct tosa_bat *bat)
  55 {
  56         unsigned long value = 0;
  57
  58         if (bat->gpio_bat < 0 || bat->adc_bat < 0)
  59                 return 0;
  60
  61         mutex_lock(&bat_lock);
  62         gpio_set_value(bat->gpio_bat, 1);
  63         msleep(5);
  64         value = wm97xx_read_aux_adc(dev_get_drvdata(bat->psy.dev->parent),
  65                         bat->adc_bat);
  66         gpio_set_value(bat->gpio_bat, 0);
  67         mutex_unlock(&bat_lock);
  68
  69         value = value * 1000000 / bat->adc_bat_divider;
  70
  71         return value;
  72 }
  73
  74 static unsigned long tosa_read_temp(struct tosa_bat *bat)
  75 {
  76         unsigned long value = 0;
  77
  78         if (bat->gpio_temp < 0 || bat->adc_temp < 0)
  79                 return 0;
  80
  81         mutex_lock(&bat_lock);
  82         gpio_set_value(bat->gpio_temp, 1);
  83         msleep(5);
  84         value = wm97xx_read_aux_adc(dev_get_drvdata(bat->psy.dev->parent),
  85                         bat->adc_temp);
  86         gpio_set_value(bat->gpio_temp, 0);
  87         mutex_unlock(&bat_lock);
  88
  89         value = value * 10000 / bat->adc_temp_divider;
  90
  91         return value;
  92 }
  93
  94 static int tosa_bat_get_property(struct power_supply *psy,
  95                             enum power_supply_property psp,
  96                             union power_supply_propval *val)
  97 {
  98         int ret = 0;
  99         struct tosa_bat *bat = container_of(psy, struct tosa_bat, psy);
 100
 101         if (bat->is_present && !bat->is_present(bat)
 102                         && psp != POWER_SUPPLY_PROP_PRESENT) {
 103                 return -ENODEV;
 104         }
 105
 106         switch (psp) {
 107         case POWER_SUPPLY_PROP_STATUS:
 108                 val->intval = bat->status;
 109                 break;
 110         case POWER_SUPPLY_PROP_TECHNOLOGY:
 111                 val->intval = bat->technology;
 112                 break;
 113         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 114                 val->intval = tosa_read_bat(bat);
 115                 break;
 116         case POWER_SUPPLY_PROP_VOLTAGE_MAX:
 117                 if (bat->full_chrg == -1)
 118                         val->intval = bat->bat_max;
 119                 else
 120                         val->intval = bat->full_chrg;
 121                 break;
 122         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
 123                 val->intval = bat->bat_max;
 124                 break;
 125         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 126                 val->intval = bat->bat_min;
 127                 break;
 128         case POWER_SUPPLY_PROP_TEMP:
 129                 val->intval = tosa_read_temp(bat);
 130                 break;
 131         case POWER_SUPPLY_PROP_PRESENT:
 132                 val->intval = bat->is_present ? bat->is_present(bat) : 1;
 133                 break;
 134         default:
 135                 ret = -EINVAL;
 136                 break;
 137         }
 138         return ret;
 139 }
 140
 141 static bool tosa_jacket_bat_is_present(struct tosa_bat *bat)
 142 {
 143         return gpio_get_value(TOSA_GPIO_JACKET_DETECT) == 0;
 144 }
 145
 146 static void tosa_bat_external_power_changed(struct power_supply *psy)
 147 {
 148         schedule_work(&bat_work);
 149 }
 150
 151 static irqreturn_t tosa_bat_gpio_isr(int irq, void *data)
 152 {
 153         pr_info("tosa_bat_gpio irq: %d\n", gpio_get_value(irq_to_gpio(irq)));
 154         schedule_work(&bat_work);
 155         return IRQ_HANDLED;
 156 }
 157
 158 static void tosa_bat_update(struct tosa_bat *bat)
 159 {
 160         int old;
 161         struct power_supply *psy = &bat->psy;
 162
 163         mutex_lock(&bat->work_lock);
 164
 165         old = bat->status;
 166
 167         if (bat->is_present && !bat->is_present(bat)) {
 168                 printk(KERN_NOTICE "%s not present\n", psy->name);
 169                 bat->status = POWER_SUPPLY_STATUS_UNKNOWN;
 170                 bat->full_chrg = -1;
 171         } else if (power_supply_am_i_supplied(psy)) {
 172                 if (bat->status == POWER_SUPPLY_STATUS_DISCHARGING) {
 173                         gpio_set_value(bat->gpio_charge_off, 0);
 174                         mdelay(15);
 175                 }
 176
 177                 if (gpio_get_value(bat->gpio_full)) {
 178                         if (old == POWER_SUPPLY_STATUS_CHARGING ||
 179                                         bat->full_chrg == -1)
 180                                 bat->full_chrg = tosa_read_bat(bat);
 181
 182                         gpio_set_value(bat->gpio_charge_off, 1);
 183                         bat->status = POWER_SUPPLY_STATUS_FULL;
 184                 } else {
 185                         gpio_set_value(bat->gpio_charge_off, 0);
 186                         bat->status = POWER_SUPPLY_STATUS_CHARGING;
 187                 }
 188         } else {
 189                 gpio_set_value(bat->gpio_charge_off, 1);
 190                 bat->status = POWER_SUPPLY_STATUS_DISCHARGING;
 191         }
 192
 193         if (old != bat->status)
 194                 power_supply_changed(psy);
 195
 196         mutex_unlock(&bat->work_lock);
 197 }
 198
 199 static void tosa_bat_work(struct work_struct *work)
 200 {
 201         tosa_bat_update(&tosa_bat_main);
 202         tosa_bat_update(&tosa_bat_jacket);
 203 }
 204
 205
 206 static enum power_supply_property tosa_bat_main_props[] = {
 207         POWER_SUPPLY_PROP_STATUS,
 208         POWER_SUPPLY_PROP_TECHNOLOGY,
 209         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 210         POWER_SUPPLY_PROP_VOLTAGE_MAX,
 211         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 212         POWER_SUPPLY_PROP_TEMP,
 213         POWER_SUPPLY_PROP_PRESENT,
 214 };
 215
 216 static enum power_supply_property tosa_bat_bu_props[] = {
 217         POWER_SUPPLY_PROP_STATUS,
 218         POWER_SUPPLY_PROP_TECHNOLOGY,
 219         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 220         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 221         POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
 222         POWER_SUPPLY_PROP_PRESENT,
 223 };
 224
 225 static struct tosa_bat tosa_bat_main = {
 226         .status = POWER_SUPPLY_STATUS_DISCHARGING,
 227         .full_chrg = -1,
 228         .psy = {
 229                 .name           = "main-battery",
 230                 .type           = POWER_SUPPLY_TYPE_BATTERY,
 231                 .properties     = tosa_bat_main_props,
 232                 .num_properties = ARRAY_SIZE(tosa_bat_main_props),
 233                 .get_property   = tosa_bat_get_property,
 234                 .external_power_changed = tosa_bat_external_power_changed,
 235                 .use_for_apm    = 1,
 236         },
 237
 238         .gpio_full = TOSA_GPIO_BAT0_CRG,
 239         .gpio_charge_off = TOSA_GPIO_CHARGE_OFF,
 240
 241         .technology = POWER_SUPPLY_TECHNOLOGY_LIPO,
 242
 243         .gpio_bat = TOSA_GPIO_BAT0_V_ON,
 244         .adc_bat = WM97XX_AUX_ID3,
 245         .adc_bat_divider = 414,
 246         .bat_max = 4310000,
 247         .bat_min = 1551 * 1000000 / 414,
 248
 249         .gpio_temp = TOSA_GPIO_BAT1_TH_ON,
 250         .adc_temp = WM97XX_AUX_ID2,
 251         .adc_temp_divider = 10000,
 252 };
 253
 254 static struct tosa_bat tosa_bat_jacket = {
 255         .status = POWER_SUPPLY_STATUS_DISCHARGING,
 256         .full_chrg = -1,
 257         .psy = {
 258                 .name           = "jacket-battery",
 259                 .type           = POWER_SUPPLY_TYPE_BATTERY,
 260                 .properties     = tosa_bat_main_props,
 261                 .num_properties = ARRAY_SIZE(tosa_bat_main_props),
 262                 .get_property   = tosa_bat_get_property,
 263                 .external_power_changed = tosa_bat_external_power_changed,
 264         },
 265
 266         .is_present = tosa_jacket_bat_is_present,
 267         .gpio_full = TOSA_GPIO_BAT1_CRG,
 268         .gpio_charge_off = TOSA_GPIO_CHARGE_OFF_JC,
 269
 270         .technology = POWER_SUPPLY_TECHNOLOGY_LIPO,
 271
 272         .gpio_bat = TOSA_GPIO_BAT1_V_ON,
 273         .adc_bat = WM97XX_AUX_ID3,
 274         .adc_bat_divider = 414,
 275         .bat_max = 4310000,
 276         .bat_min = 1551 * 1000000 / 414,
 277
 278         .gpio_temp = TOSA_GPIO_BAT0_TH_ON,
 279         .adc_temp = WM97XX_AUX_ID2,
 280         .adc_temp_divider = 10000,
 281 };
 282
 283 static struct tosa_bat tosa_bat_bu = {
 284         .status = POWER_SUPPLY_STATUS_UNKNOWN,
 285         .full_chrg = -1,
 286
 287         .psy = {
 288                 .name           = "backup-battery",
 289                 .type           = POWER_SUPPLY_TYPE_BATTERY,
 290                 .properties     = tosa_bat_bu_props,
 291                 .num_properties = ARRAY_SIZE(tosa_bat_bu_props),
 292                 .get_property   = tosa_bat_get_property,
 293                 .external_power_changed = tosa_bat_external_power_changed,
 294         },
 295
 296         .gpio_full = -1,
 297         .gpio_charge_off = -1,
 298
 299         .technology = POWER_SUPPLY_TECHNOLOGY_LiMn,
 300
 301         .gpio_bat = TOSA_GPIO_BU_CHRG_ON,
 302         .adc_bat = WM97XX_AUX_ID4,
 303         .adc_bat_divider = 1266,
 304
 305         .gpio_temp = -1,
 306         .adc_temp = -1,
 307         .adc_temp_divider = -1,
 308 };
 309
 310 static struct gpio tosa_bat_gpios[] = {
 311         { TOSA_GPIO_CHARGE_OFF,    GPIOF_OUT_INIT_HIGH, "main charge off" },
 312         { TOSA_GPIO_CHARGE_OFF_JC, GPIOF_OUT_INIT_HIGH, "jacket charge off" },
 313         { TOSA_GPIO_BAT_SW_ON,     GPIOF_OUT_INIT_LOW,  "battery switch" },
 314         { TOSA_GPIO_BAT0_V_ON,     GPIOF_OUT_INIT_LOW,  "main battery" },
 315         { TOSA_GPIO_BAT1_V_ON,     GPIOF_OUT_INIT_LOW,  "jacket battery" },
 316         { TOSA_GPIO_BAT1_TH_ON,    GPIOF_OUT_INIT_LOW,  "main battery temp" },
 317         { TOSA_GPIO_BAT0_TH_ON,    GPIOF_OUT_INIT_LOW,  "jacket battery temp" },
 318         { TOSA_GPIO_BU_CHRG_ON,    GPIOF_OUT_INIT_LOW,  "backup battery" },
 319         { TOSA_GPIO_BAT0_CRG,      GPIOF_IN,            "main battery full" },
 320         { TOSA_GPIO_BAT1_CRG,      GPIOF_IN,            "jacket battery full" },
 321         { TOSA_GPIO_BAT0_LOW,      GPIOF_IN,            "main battery low" },
 322         { TOSA_GPIO_BAT1_LOW,      GPIOF_IN,            "jacket battery low" },
 323         { TOSA_GPIO_JACKET_DETECT, GPIOF_IN,            "jacket detect" },
 324 };
 325
 326 #ifdef CONFIG_PM
 327 static int tosa_bat_suspend(struct platform_device *dev, pm_message_t state)
 328 {
 329         /* flush all pending status updates */
 330         flush_work(&bat_work);
 331         return 0;
 332 }
 333
 334 static int tosa_bat_resume(struct platform_device *dev)
 335 {
 336         /* things may have changed while we were away */
 337         schedule_work(&bat_work);
 338         return 0;
 339 }
 340 #else
 341 #define tosa_bat_suspend NULL
 342 #define tosa_bat_resume NULL
 343 #endif
 344
 345 static int __devinit tosa_bat_probe(struct platform_device *dev)
 346 {
 347         int ret;
 348
 349         if (!machine_is_tosa())
 350                 return -ENODEV;
 351
 352         ret = gpio_request_array(tosa_bat_gpios, ARRAY_SIZE(tosa_bat_gpios));
 353         if (ret)
 354                 return ret;
 355
 356         mutex_init(&tosa_bat_main.work_lock);
 357         mutex_init(&tosa_bat_jacket.work_lock);
 358
 359         INIT_WORK(&bat_work, tosa_bat_work);
 360
 361         ret = power_supply_register(&dev->dev, &tosa_bat_main.psy);
 362         if (ret)
 363                 goto err_psy_reg_main;
 364         ret = power_supply_register(&dev->dev, &tosa_bat_jacket.psy);
 365         if (ret)
 366                 goto err_psy_reg_jacket;
 367         ret = power_supply_register(&dev->dev, &tosa_bat_bu.psy);
 368         if (ret)
 369                 goto err_psy_reg_bu;
 370
 371         ret = request_irq(gpio_to_irq(TOSA_GPIO_BAT0_CRG),
 372                                 tosa_bat_gpio_isr,
 373                                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
 374                                 "main full", &tosa_bat_main);
 375         if (ret)
 376                 goto err_req_main;
 377
 378         ret = request_irq(gpio_to_irq(TOSA_GPIO_BAT1_CRG),
 379                                 tosa_bat_gpio_isr,
 380                                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
 381                                 "jacket full", &tosa_bat_jacket);
 382         if (ret)
 383                 goto err_req_jacket;
 384
 385         ret = request_irq(gpio_to_irq(TOSA_GPIO_JACKET_DETECT),
 386                                 tosa_bat_gpio_isr,
 387                                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
 388                                 "jacket detect", &tosa_bat_jacket);
 389         if (!ret) {
 390                 schedule_work(&bat_work);
 391                 return 0;
 392         }
 393
 394         free_irq(gpio_to_irq(TOSA_GPIO_BAT1_CRG), &tosa_bat_jacket);
 395 err_req_jacket:
 396         free_irq(gpio_to_irq(TOSA_GPIO_BAT0_CRG), &tosa_bat_main);
 397 err_req_main:
 398         power_supply_unregister(&tosa_bat_bu.psy);
 399 err_psy_reg_bu:
 400         power_supply_unregister(&tosa_bat_jacket.psy);
 401 err_psy_reg_jacket:
 402         power_supply_unregister(&tosa_bat_main.psy);
 403 err_psy_reg_main:
 404
 405         /* see comment in tosa_bat_remove */
 406         cancel_work_sync(&bat_work);
 407
 408         gpio_free_array(tosa_bat_gpios, ARRAY_SIZE(tosa_bat_gpios));
 409         return ret;
 410 }
 411
 412 static int __devexit tosa_bat_remove(struct platform_device *dev)
 413 {
 414         free_irq(gpio_to_irq(TOSA_GPIO_JACKET_DETECT), &tosa_bat_jacket);
 415         free_irq(gpio_to_irq(TOSA_GPIO_BAT1_CRG), &tosa_bat_jacket);
 416         free_irq(gpio_to_irq(TOSA_GPIO_BAT0_CRG), &tosa_bat_main);
 417
 418         power_supply_unregister(&tosa_bat_bu.psy);
 419         power_supply_unregister(&tosa_bat_jacket.psy);
 420         power_supply_unregister(&tosa_bat_main.psy);
 421
 422         /*
 423          * Now cancel the bat_work.  We won't get any more schedules,
 424          * since all sources (isr and external_power_changed) are
 425          * unregistered now.
 426          */
 427         cancel_work_sync(&bat_work);
 428         gpio_free_array(tosa_bat_gpios, ARRAY_SIZE(tosa_bat_gpios));
 429         return 0;
 430 }
 431
 432 static struct platform_driver tosa_bat_driver = {
 433         .driver.name    = "wm97xx-battery",
 434         .driver.owner   = THIS_MODULE,
 435         .probe          = tosa_bat_probe,
 436         .remove         = __devexit_p(tosa_bat_remove),
 437         .suspend        = tosa_bat_suspend,
 438         .resume         = tosa_bat_resume,
 439 };
 440
 441 module_platform_driver(tosa_bat_driver);
 442
 443 MODULE_LICENSE("GPL");
 444 MODULE_AUTHOR("Dmitry Baryshkov");
 445 MODULE_DESCRIPTION("Tosa battery driver");
 446 MODULE_ALIAS("platform:wm97xx-battery");