SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/power/pcf50633-charger.c

   1 /* NXP PCF50633 Main Battery Charger Driver
   2  *
   3  * (C) 2006-2008 by Openmoko, Inc.
   4  * Author: Balaji Rao <balajirrao@openmoko.org>
   5  * All rights reserved.
   6  *
   7  * Broken down from monstrous PCF50633 driver mainly by
   8  * Harald Welte, Andy Green and Werner Almesberger
   9  *
  10  *  This program is free software; you can redistribute  it and/or modify it
  11  *  under  the terms of  the GNU General  Public License as published by the
  12  *  Free Software Foundation;  either version 2 of the  License, or (at your
  13  *  option) any later version.
  14  *
  15  */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/init.h>
  20 #include <linux/types.h>
  21 #include <linux/device.h>
  22 #include <linux/sysfs.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/power_supply.h>
  25
  26 #include <linux/mfd/pcf50633/core.h>
  27 #include <linux/mfd/pcf50633/mbc.h>
  28
  29 struct pcf50633_mbc {
  30         struct pcf50633 *pcf;
  31
  32         int adapter_active;
  33         int adapter_online;
  34         int usb_active;
  35         int usb_online;
  36
  37         struct power_supply usb;
  38         struct power_supply adapter;
  39         struct power_supply ac;
  40
  41         struct delayed_work charging_restart_work;
  42 };
  43
  44 int pcf50633_mbc_usb_curlim_set(struct pcf50633 *pcf, int ma)
  45 {
  46         struct pcf50633_mbc *mbc = platform_get_drvdata(pcf->mbc_pdev);
  47         int ret = 0;
  48         u8 bits;
  49         int charging_start = 1;
  50         u8 mbcs2, chgmod;
  51
  52         if (ma >= 1000)
  53                 bits = PCF50633_MBCC7_USB_1000mA;
  54         else if (ma >= 500)
  55                 bits = PCF50633_MBCC7_USB_500mA;
  56         else if (ma >= 100)
  57                 bits = PCF50633_MBCC7_USB_100mA;
  58         else {
  59                 bits = PCF50633_MBCC7_USB_SUSPEND;
  60                 charging_start = 0;
  61         }
  62
  63         ret = pcf50633_reg_set_bit_mask(pcf, PCF50633_REG_MBCC7,
  64                                         PCF50633_MBCC7_USB_MASK, bits);
  65         if (ret)
  66                 dev_err(pcf->dev, "error setting usb curlim to %d mA\n", ma);
  67         else
  68                 dev_info(pcf->dev, "usb curlim to %d mA\n", ma);
  69
  70         /* Manual charging start */
  71         mbcs2 = pcf50633_reg_read(pcf, PCF50633_REG_MBCS2);
  72         chgmod = (mbcs2 & PCF50633_MBCS2_MBC_MASK);
  73
  74         /* If chgmod == BATFULL, setting chgena has no effect.
  75          * We need to set resume instead.
  76          */
  77         if (chgmod != PCF50633_MBCS2_MBC_BAT_FULL)
  78                 pcf50633_reg_set_bit_mask(pcf, PCF50633_REG_MBCC1,
  79                                 PCF50633_MBCC1_CHGENA, PCF50633_MBCC1_CHGENA);
  80         else
  81                 pcf50633_reg_set_bit_mask(pcf, PCF50633_REG_MBCC1,
  82                                 PCF50633_MBCC1_RESUME, PCF50633_MBCC1_RESUME);
  83
  84         mbc->usb_active = charging_start;
  85
  86         power_supply_changed(&mbc->usb);
  87
  88         return ret;
  89 }
  90 EXPORT_SYMBOL_GPL(pcf50633_mbc_usb_curlim_set);
  91
  92 int pcf50633_mbc_get_status(struct pcf50633 *pcf)
  93 {
  94         struct pcf50633_mbc *mbc  = platform_get_drvdata(pcf->mbc_pdev);
  95         int status = 0;
  96
  97         if (mbc->usb_online)
  98                 status |= PCF50633_MBC_USB_ONLINE;
  99         if (mbc->usb_active)
 100                 status |= PCF50633_MBC_USB_ACTIVE;
 101         if (mbc->adapter_online)
 102                 status |= PCF50633_MBC_ADAPTER_ONLINE;
 103         if (mbc->adapter_active)
 104                 status |= PCF50633_MBC_ADAPTER_ACTIVE;
 105
 106         return status;
 107 }
 108 EXPORT_SYMBOL_GPL(pcf50633_mbc_get_status);
 109
 110 static ssize_t
 111 show_chgmode(struct device *dev, struct device_attribute *attr, char *buf)
 112 {
 113         struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
 114
 115         u8 mbcs2 = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCS2);
 116         u8 chgmod = (mbcs2 & PCF50633_MBCS2_MBC_MASK);
 117
 118         return sprintf(buf, "%d\n", chgmod);
 119 }
 120 static DEVICE_ATTR(chgmode, S_IRUGO, show_chgmode, NULL);
 121
 122 static ssize_t
 123 show_usblim(struct device *dev, struct device_attribute *attr, char *buf)
 124 {
 125         struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
 126         u8 usblim = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCC7) &
 127                                                 PCF50633_MBCC7_USB_MASK;
 128         unsigned int ma;
 129
 130         if (usblim == PCF50633_MBCC7_USB_1000mA)
 131                 ma = 1000;
 132         else if (usblim == PCF50633_MBCC7_USB_500mA)
 133                 ma = 500;
 134         else if (usblim == PCF50633_MBCC7_USB_100mA)
 135                 ma = 100;
 136         else
 137                 ma = 0;
 138
 139         return sprintf(buf, "%u\n", ma);
 140 }
 141
 142 static ssize_t set_usblim(struct device *dev,
 143                 struct device_attribute *attr, const char *buf, size_t count)
 144 {
 145         struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
 146         unsigned long ma;
 147         int ret;
 148
 149         ret = strict_strtoul(buf, 10, &ma);
 150         if (ret)
 151                 return -EINVAL;
 152
 153         pcf50633_mbc_usb_curlim_set(mbc->pcf, ma);
 154
 155         return count;
 156 }
 157
 158 static DEVICE_ATTR(usb_curlim, S_IRUGO | S_IWUSR, show_usblim, set_usblim);
 159
 160 static struct attribute *pcf50633_mbc_sysfs_entries[] = {
 161         &dev_attr_chgmode.attr,
 162         &dev_attr_usb_curlim.attr,
 163         NULL,
 164 };
 165
 166 static struct attribute_group mbc_attr_group = {
 167         .name   = NULL,                 /* put in device directory */
 168         .attrs  = pcf50633_mbc_sysfs_entries,
 169 };
 170
 171 /* MBC state machine switches into charging mode when the battery voltage
 172  * falls below 96% of a battery float voltage. But the voltage drop in Li-ion
 173  * batteries is marginal(1~2 %) till about 80% of its capacity - which means,
 174  * after a BATFULL, charging won't be restarted until 80%.
 175  *
 176  * This work_struct function restarts charging at regular intervals to make
 177  * sure we don't discharge too much
 178  */
 179
 180 static void pcf50633_mbc_charging_restart(struct work_struct *work)
 181 {
 182         struct pcf50633_mbc *mbc;
 183         u8 mbcs2, chgmod;
 184
 185         mbc = container_of(work, struct pcf50633_mbc,
 186                                 charging_restart_work.work);
 187
 188         mbcs2 = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCS2);
 189         chgmod = (mbcs2 & PCF50633_MBCS2_MBC_MASK);
 190
 191         if (chgmod != PCF50633_MBCS2_MBC_BAT_FULL)
 192                 return;
 193
 194         /* Restart charging */
 195         pcf50633_reg_set_bit_mask(mbc->pcf, PCF50633_REG_MBCC1,
 196                                 PCF50633_MBCC1_RESUME, PCF50633_MBCC1_RESUME);
 197         mbc->usb_active = 1;
 198         power_supply_changed(&mbc->usb);
 199
 200         dev_info(mbc->pcf->dev, "Charging restarted\n");
 201 }
 202
 203 static void
 204 pcf50633_mbc_irq_handler(int irq, void *data)
 205 {
 206         struct pcf50633_mbc *mbc = data;
 207         int chg_restart_interval =
 208                         mbc->pcf->pdata->charging_restart_interval;
 209
 210         /* USB */
 211         if (irq == PCF50633_IRQ_USBINS) {
 212                 mbc->usb_online = 1;
 213         } else if (irq == PCF50633_IRQ_USBREM) {
 214                 mbc->usb_online = 0;
 215                 mbc->usb_active = 0;
 216                 pcf50633_mbc_usb_curlim_set(mbc->pcf, 0);
 217                 cancel_delayed_work_sync(&mbc->charging_restart_work);
 218         }
 219
 220         /* Adapter */
 221         if (irq == PCF50633_IRQ_ADPINS) {
 222                 mbc->adapter_online = 1;
 223                 mbc->adapter_active = 1;
 224         } else if (irq == PCF50633_IRQ_ADPREM) {
 225                 mbc->adapter_online = 0;
 226                 mbc->adapter_active = 0;
 227         }
 228
 229         if (irq == PCF50633_IRQ_BATFULL) {
 230                 mbc->usb_active = 0;
 231                 mbc->adapter_active = 0;
 232
 233                 if (chg_restart_interval > 0)
 234                         schedule_delayed_work(&mbc->charging_restart_work,
 235                                                         chg_restart_interval);
 236         } else if (irq == PCF50633_IRQ_USBLIMON)
 237                 mbc->usb_active = 0;
 238         else if (irq == PCF50633_IRQ_USBLIMOFF)
 239                 mbc->usb_active = 1;
 240
 241         power_supply_changed(&mbc->ac);
 242         power_supply_changed(&mbc->usb);
 243         power_supply_changed(&mbc->adapter);
 244
 245         if (mbc->pcf->pdata->mbc_event_callback)
 246                 mbc->pcf->pdata->mbc_event_callback(mbc->pcf, irq);
 247 }
 248
 249 static int adapter_get_property(struct power_supply *psy,
 250                         enum power_supply_property psp,
 251                         union power_supply_propval *val)
 252 {
 253         struct pcf50633_mbc *mbc = container_of(psy,
 254                                 struct pcf50633_mbc, adapter);
 255         int ret = 0;
 256
 257         switch (psp) {
 258         case POWER_SUPPLY_PROP_ONLINE:
 259                 val->intval =  mbc->adapter_online;
 260                 break;
 261         default:
 262                 ret = -EINVAL;
 263                 break;
 264         }
 265         return ret;
 266 }
 267
 268 static int usb_get_property(struct power_supply *psy,
 269                         enum power_supply_property psp,
 270                         union power_supply_propval *val)
 271 {
 272         struct pcf50633_mbc *mbc = container_of(psy, struct pcf50633_mbc, usb);
 273         int ret = 0;
 274         u8 usblim = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCC7) &
 275                                                 PCF50633_MBCC7_USB_MASK;
 276
 277         switch (psp) {
 278         case POWER_SUPPLY_PROP_ONLINE:
 279                 val->intval = mbc->usb_online &&
 280                                 (usblim <= PCF50633_MBCC7_USB_500mA);
 281                 break;
 282         default:
 283                 ret = -EINVAL;
 284                 break;
 285         }
 286         return ret;
 287 }
 288
 289 static int ac_get_property(struct power_supply *psy,
 290                         enum power_supply_property psp,
 291                         union power_supply_propval *val)
 292 {
 293         struct pcf50633_mbc *mbc = container_of(psy, struct pcf50633_mbc, ac);
 294         int ret = 0;
 295         u8 usblim = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCC7) &
 296                                                 PCF50633_MBCC7_USB_MASK;
 297
 298         switch (psp) {
 299         case POWER_SUPPLY_PROP_ONLINE:
 300                 val->intval = mbc->usb_online &&
 301                                 (usblim == PCF50633_MBCC7_USB_1000mA);
 302                 break;
 303         default:
 304                 ret = -EINVAL;
 305                 break;
 306         }
 307         return ret;
 308 }
 309
 310 static enum power_supply_property power_props[] = {
 311         POWER_SUPPLY_PROP_ONLINE,
 312 };
 313
 314 static const u8 mbc_irq_handlers[] = {
 315         PCF50633_IRQ_ADPINS,
 316         PCF50633_IRQ_ADPREM,
 317         PCF50633_IRQ_USBINS,
 318         PCF50633_IRQ_USBREM,
 319         PCF50633_IRQ_BATFULL,
 320         PCF50633_IRQ_CHGHALT,
 321         PCF50633_IRQ_THLIMON,
 322         PCF50633_IRQ_THLIMOFF,
 323         PCF50633_IRQ_USBLIMON,
 324         PCF50633_IRQ_USBLIMOFF,
 325         PCF50633_IRQ_LOWSYS,
 326         PCF50633_IRQ_LOWBAT,
 327 };
 328
 329 static int __devinit pcf50633_mbc_probe(struct platform_device *pdev)
 330 {
 331         struct pcf50633_mbc *mbc;
 332         struct pcf50633_subdev_pdata *pdata = pdev->dev.platform_data;
 333         int ret;
 334         int i;
 335         u8 mbcs1;
 336
 337         mbc = kzalloc(sizeof(*mbc), GFP_KERNEL);
 338         if (!mbc)
 339                 return -ENOMEM;
 340
 341         platform_set_drvdata(pdev, mbc);
 342         mbc->pcf = pdata->pcf;
 343
 344         /* Set up IRQ handlers */
 345         for (i = 0; i < ARRAY_SIZE(mbc_irq_handlers); i++)
 346                 pcf50633_register_irq(mbc->pcf, mbc_irq_handlers[i],
 347                                         pcf50633_mbc_irq_handler, mbc);
 348
 349         /* Create power supplies */
 350         mbc->adapter.name               = "adapter";
 351         mbc->adapter.type               = POWER_SUPPLY_TYPE_MAINS;
 352         mbc->adapter.properties         = power_props;
 353         mbc->adapter.num_properties     = ARRAY_SIZE(power_props);
 354         mbc->adapter.get_property       = &adapter_get_property;
 355         mbc->adapter.supplied_to        = mbc->pcf->pdata->batteries;
 356         mbc->adapter.num_supplicants    = mbc->pcf->pdata->num_batteries;
 357
 358         mbc->usb.name                   = "usb";
 359         mbc->usb.type                   = POWER_SUPPLY_TYPE_USB;
 360         mbc->usb.properties             = power_props;
 361         mbc->usb.num_properties         = ARRAY_SIZE(power_props);
 362         mbc->usb.get_property           = usb_get_property;
 363         mbc->usb.supplied_to            = mbc->pcf->pdata->batteries;
 364         mbc->usb.num_supplicants        = mbc->pcf->pdata->num_batteries;
 365
 366         mbc->ac.name                    = "ac";
 367         mbc->ac.type                    = POWER_SUPPLY_TYPE_MAINS;
 368         mbc->ac.properties              = power_props;
 369         mbc->ac.num_properties          = ARRAY_SIZE(power_props);
 370         mbc->ac.get_property            = ac_get_property;
 371         mbc->ac.supplied_to             = mbc->pcf->pdata->batteries;
 372         mbc->ac.num_supplicants         = mbc->pcf->pdata->num_batteries;
 373
 374         ret = power_supply_register(&pdev->dev, &mbc->adapter);
 375         if (ret) {
 376                 dev_err(mbc->pcf->dev, "failed to register adapter\n");
 377                 kfree(mbc);
 378                 return ret;
 379         }
 380
 381         ret = power_supply_register(&pdev->dev, &mbc->usb);
 382         if (ret) {
 383                 dev_err(mbc->pcf->dev, "failed to register usb\n");
 384                 power_supply_unregister(&mbc->adapter);
 385                 kfree(mbc);
 386                 return ret;
 387         }
 388
 389         ret = power_supply_register(&pdev->dev, &mbc->ac);
 390         if (ret) {
 391                 dev_err(mbc->pcf->dev, "failed to register ac\n");
 392                 power_supply_unregister(&mbc->adapter);
 393                 power_supply_unregister(&mbc->usb);
 394                 kfree(mbc);
 395                 return ret;
 396         }
 397
 398         INIT_DELAYED_WORK(&mbc->charging_restart_work,
 399                                 pcf50633_mbc_charging_restart);
 400
 401         ret = sysfs_create_group(&pdev->dev.kobj, &mbc_attr_group);
 402         if (ret)
 403                 dev_err(mbc->pcf->dev, "failed to create sysfs entries\n");
 404
 405         mbcs1 = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCS1);
 406         if (mbcs1 & PCF50633_MBCS1_USBPRES)
 407                 pcf50633_mbc_irq_handler(PCF50633_IRQ_USBINS, mbc);
 408         if (mbcs1 & PCF50633_MBCS1_ADAPTPRES)
 409                 pcf50633_mbc_irq_handler(PCF50633_IRQ_ADPINS, mbc);
 410
 411         return 0;
 412 }
 413
 414 static int __devexit pcf50633_mbc_remove(struct platform_device *pdev)
 415 {
 416         struct pcf50633_mbc *mbc = platform_get_drvdata(pdev);
 417         int i;
 418
 419         /* Remove IRQ handlers */
 420         for (i = 0; i < ARRAY_SIZE(mbc_irq_handlers); i++)
 421                 pcf50633_free_irq(mbc->pcf, mbc_irq_handlers[i]);
 422
 423         power_supply_unregister(&mbc->usb);
 424         power_supply_unregister(&mbc->adapter);
 425         power_supply_unregister(&mbc->ac);
 426
 427         cancel_delayed_work_sync(&mbc->charging_restart_work);
 428
 429         kfree(mbc);
 430
 431         return 0;
 432 }
 433
 434 static struct platform_driver pcf50633_mbc_driver = {
 435         .driver = {
 436                 .name = "pcf50633-mbc",
 437         },
 438         .probe = pcf50633_mbc_probe,
 439         .remove = __devexit_p(pcf50633_mbc_remove),
 440 };
 441
 442 static int __init pcf50633_mbc_init(void)
 443 {
 444         return platform_driver_register(&pcf50633_mbc_driver);
 445 }
 446 module_init(pcf50633_mbc_init);
 447
 448 static void __exit pcf50633_mbc_exit(void)
 449 {
 450         platform_driver_unregister(&pcf50633_mbc_driver);
 451 }
 452 module_exit(pcf50633_mbc_exit);
 453
 454 MODULE_AUTHOR("Balaji Rao <balajirrao@openmoko.org>");
 455 MODULE_DESCRIPTION("PCF50633 mbc driver");
 456 MODULE_LICENSE("GPL");
 457 MODULE_ALIAS("platform:pcf50633-mbc");