drivers/power/supply/bq24735-charger.c

   1 /*
   2  * Battery charger driver for TI BQ24735
   3  *
   4  * Copyright (c) 2013, NVIDIA CORPORATION.  All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation;
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #include <linux/err.h>
  21 #include <linux/gpio.h>
  22 #include <linux/i2c.h>
  23 #include <linux/init.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/kernel.h>
  26 #include <linux/module.h>
  27 #include <linux/of.h>
  28 #include <linux/gpio/consumer.h>
  29 #include <linux/power_supply.h>
  30 #include <linux/slab.h>
  31
  32 #include <linux/power/bq24735-charger.h>
  33
  34 #define BQ24735_CHG_OPT                 0x12
  35 #define BQ24735_CHG_OPT_CHARGE_DISABLE  (1 << 0)
  36 #define BQ24735_CHG_OPT_AC_PRESENT      (1 << 4)
  37 #define BQ24735_CHARGE_CURRENT          0x14
  38 #define BQ24735_CHARGE_CURRENT_MASK     0x1fc0
  39 #define BQ24735_CHARGE_VOLTAGE          0x15
  40 #define BQ24735_CHARGE_VOLTAGE_MASK     0x7ff0
  41 #define BQ24735_INPUT_CURRENT           0x3f
  42 #define BQ24735_INPUT_CURRENT_MASK      0x1f80
  43 #define BQ24735_MANUFACTURER_ID         0xfe
  44 #define BQ24735_DEVICE_ID               0xff
  45
  46 struct bq24735 {
  47         struct power_supply             *charger;
  48         struct power_supply_desc        charger_desc;
  49         struct i2c_client               *client;
  50         struct bq24735_platform         *pdata;
  51         struct mutex                    lock;
  52         struct gpio_desc                *status_gpio;
  53         bool                            charging;
  54 };
  55
  56 static inline struct bq24735 *to_bq24735(struct power_supply *psy)
  57 {
  58         return power_supply_get_drvdata(psy);
  59 }
  60
  61 static enum power_supply_property bq24735_charger_properties[] = {
  62         POWER_SUPPLY_PROP_STATUS,
  63         POWER_SUPPLY_PROP_ONLINE,
  64 };
  65
  66 static int bq24735_charger_property_is_writeable(struct power_supply *psy,
  67                                                  enum power_supply_property psp)
  68 {
  69         switch (psp) {
  70         case POWER_SUPPLY_PROP_STATUS:
  71                 return 1;
  72         default:
  73                 break;
  74         }
  75
  76         return 0;
  77 }
  78
  79 static inline int bq24735_write_word(struct i2c_client *client, u8 reg,
  80                                      u16 value)
  81 {
  82         return i2c_smbus_write_word_data(client, reg, le16_to_cpu(value));
  83 }
  84
  85 static inline int bq24735_read_word(struct i2c_client *client, u8 reg)
  86 {
  87         s32 ret = i2c_smbus_read_word_data(client, reg);
  88
  89         return ret < 0 ? ret : le16_to_cpu(ret);
  90 }
  91
  92 static int bq24735_update_word(struct i2c_client *client, u8 reg,
  93                                u16 mask, u16 value)
  94 {
  95         unsigned int tmp;
  96         int ret;
  97
  98         ret = bq24735_read_word(client, reg);
  99         if (ret < 0)
 100                 return ret;
 101
 102         tmp = ret & ~mask;
 103         tmp |= value & mask;
 104
 105         return bq24735_write_word(client, reg, tmp);
 106 }
 107
 108 static inline int bq24735_enable_charging(struct bq24735 *charger)
 109 {
 110         if (charger->pdata->ext_control)
 111                 return 0;
 112
 113         return bq24735_update_word(charger->client, BQ24735_CHG_OPT,
 114                                    BQ24735_CHG_OPT_CHARGE_DISABLE,
 115                                    ~BQ24735_CHG_OPT_CHARGE_DISABLE);
 116 }
 117
 118 static inline int bq24735_disable_charging(struct bq24735 *charger)
 119 {
 120         if (charger->pdata->ext_control)
 121                 return 0;
 122
 123         return bq24735_update_word(charger->client, BQ24735_CHG_OPT,
 124                                    BQ24735_CHG_OPT_CHARGE_DISABLE,
 125                                    BQ24735_CHG_OPT_CHARGE_DISABLE);
 126 }
 127
 128 static int bq24735_config_charger(struct bq24735 *charger)
 129 {
 130         struct bq24735_platform *pdata = charger->pdata;
 131         int ret;
 132         u16 value;
 133
 134         if (pdata->ext_control)
 135                 return 0;
 136
 137         if (pdata->charge_current) {
 138                 value = pdata->charge_current & BQ24735_CHARGE_CURRENT_MASK;
 139
 140                 ret = bq24735_write_word(charger->client,
 141                                          BQ24735_CHARGE_CURRENT, value);
 142                 if (ret < 0) {
 143                         dev_err(&charger->client->dev,
 144                                 "Failed to write charger current : %d\n",
 145                                 ret);
 146                         return ret;
 147                 }
 148         }
 149
 150         if (pdata->charge_voltage) {
 151                 value = pdata->charge_voltage & BQ24735_CHARGE_VOLTAGE_MASK;
 152
 153                 ret = bq24735_write_word(charger->client,
 154                                          BQ24735_CHARGE_VOLTAGE, value);
 155                 if (ret < 0) {
 156                         dev_err(&charger->client->dev,
 157                                 "Failed to write charger voltage : %d\n",
 158                                 ret);
 159                         return ret;
 160                 }
 161         }
 162
 163         if (pdata->input_current) {
 164                 value = pdata->input_current & BQ24735_INPUT_CURRENT_MASK;
 165
 166                 ret = bq24735_write_word(charger->client,
 167                                          BQ24735_INPUT_CURRENT, value);
 168                 if (ret < 0) {
 169                         dev_err(&charger->client->dev,
 170                                 "Failed to write input current : %d\n",
 171                                 ret);
 172                         return ret;
 173                 }
 174         }
 175
 176         return 0;
 177 }
 178
 179 static bool bq24735_charger_is_present(struct bq24735 *charger)
 180 {
 181         if (charger->status_gpio) {
 182                 return !gpiod_get_value_cansleep(charger->status_gpio);
 183         } else {
 184                 int ac = 0;
 185
 186                 ac = bq24735_read_word(charger->client, BQ24735_CHG_OPT);
 187                 if (ac < 0) {
 188                         dev_err(&charger->client->dev,
 189                                 "Failed to read charger options : %d\n",
 190                                 ac);
 191                         return false;
 192                 }
 193                 return (ac & BQ24735_CHG_OPT_AC_PRESENT) ? true : false;
 194         }
 195
 196         return false;
 197 }
 198
 199 static int bq24735_charger_is_charging(struct bq24735 *charger)
 200 {
 201         int ret;
 202
 203         if (!bq24735_charger_is_present(charger))
 204                 return 0;
 205
 206         ret  = bq24735_read_word(charger->client, BQ24735_CHG_OPT);
 207         if (ret < 0)
 208                 return ret;
 209
 210         return !(ret & BQ24735_CHG_OPT_CHARGE_DISABLE);
 211 }
 212
 213 static irqreturn_t bq24735_charger_isr(int irq, void *devid)
 214 {
 215         struct power_supply *psy = devid;
 216         struct bq24735 *charger = to_bq24735(psy);
 217
 218         mutex_lock(&charger->lock);
 219
 220         if (charger->charging && bq24735_charger_is_present(charger))
 221                 bq24735_enable_charging(charger);
 222         else
 223                 bq24735_disable_charging(charger);
 224
 225         mutex_unlock(&charger->lock);
 226
 227         power_supply_changed(psy);
 228
 229         return IRQ_HANDLED;
 230 }
 231
 232 static int bq24735_charger_get_property(struct power_supply *psy,
 233                                         enum power_supply_property psp,
 234                                         union power_supply_propval *val)
 235 {
 236         struct bq24735 *charger = to_bq24735(psy);
 237
 238         switch (psp) {
 239         case POWER_SUPPLY_PROP_ONLINE:
 240                 val->intval = bq24735_charger_is_present(charger) ? 1 : 0;
 241                 break;
 242         case POWER_SUPPLY_PROP_STATUS:
 243                 switch (bq24735_charger_is_charging(charger)) {
 244                 case 1:
 245                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 246                         break;
 247                 case 0:
 248                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 249                         break;
 250                 default:
 251                         val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 252                         break;
 253                 }
 254                 break;
 255         default:
 256                 return -EINVAL;
 257         }
 258
 259         return 0;
 260 }
 261
 262 static int bq24735_charger_set_property(struct power_supply *psy,
 263                                         enum power_supply_property psp,
 264                                         const union power_supply_propval *val)
 265 {
 266         struct bq24735 *charger = to_bq24735(psy);
 267         int ret;
 268
 269         switch (psp) {
 270         case POWER_SUPPLY_PROP_STATUS:
 271                 switch (val->intval) {
 272                 case POWER_SUPPLY_STATUS_CHARGING:
 273                         mutex_lock(&charger->lock);
 274                         charger->charging = true;
 275                         ret = bq24735_enable_charging(charger);
 276                         mutex_unlock(&charger->lock);
 277                         if (ret)
 278                                 return ret;
 279                         bq24735_config_charger(charger);
 280                         break;
 281                 case POWER_SUPPLY_STATUS_DISCHARGING:
 282                 case POWER_SUPPLY_STATUS_NOT_CHARGING:
 283                         mutex_lock(&charger->lock);
 284                         charger->charging = false;
 285                         ret = bq24735_disable_charging(charger);
 286                         mutex_unlock(&charger->lock);
 287                         if (ret)
 288                                 return ret;
 289                         break;
 290                 default:
 291                         return -EINVAL;
 292                 }
 293                 power_supply_changed(psy);
 294                 break;
 295         default:
 296                 return -EPERM;
 297         }
 298
 299         return 0;
 300 }
 301
 302 static struct bq24735_platform *bq24735_parse_dt_data(struct i2c_client *client)
 303 {
 304         struct bq24735_platform *pdata;
 305         struct device_node *np = client->dev.of_node;
 306         u32 val;
 307         int ret;
 308
 309         pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
 310         if (!pdata) {
 311                 dev_err(&client->dev,
 312                         "Memory alloc for bq24735 pdata failed\n");
 313                 return NULL;
 314         }
 315
 316         ret = of_property_read_u32(np, "ti,charge-current", &val);
 317         if (!ret)
 318                 pdata->charge_current = val;
 319
 320         ret = of_property_read_u32(np, "ti,charge-voltage", &val);
 321         if (!ret)
 322                 pdata->charge_voltage = val;
 323
 324         ret = of_property_read_u32(np, "ti,input-current", &val);
 325         if (!ret)
 326                 pdata->input_current = val;
 327
 328         pdata->ext_control = of_property_read_bool(np, "ti,external-control");
 329
 330         return pdata;
 331 }
 332
 333 static int bq24735_charger_probe(struct i2c_client *client,
 334                                  const struct i2c_device_id *id)
 335 {
 336         int ret;
 337         struct bq24735 *charger;
 338         struct power_supply_desc *supply_desc;
 339         struct power_supply_config psy_cfg = {};
 340         char *name;
 341
 342         charger = devm_kzalloc(&client->dev, sizeof(*charger), GFP_KERNEL);
 343         if (!charger)
 344                 return -ENOMEM;
 345
 346         mutex_init(&charger->lock);
 347         charger->charging = true;
 348         charger->pdata = client->dev.platform_data;
 349
 350         if (IS_ENABLED(CONFIG_OF) && !charger->pdata && client->dev.of_node)
 351                 charger->pdata = bq24735_parse_dt_data(client);
 352
 353         if (!charger->pdata) {
 354                 dev_err(&client->dev, "no platform data provided\n");
 355                 return -EINVAL;
 356         }
 357
 358         name = (char *)charger->pdata->name;
 359         if (!name) {
 360                 name = devm_kasprintf(&client->dev, GFP_KERNEL,
 361                                       "bq24735@%s",
 362                                       dev_name(&client->dev));
 363                 if (!name) {
 364                         dev_err(&client->dev, "Failed to alloc device name\n");
 365                         return -ENOMEM;
 366                 }
 367         }
 368
 369         charger->client = client;
 370
 371         supply_desc = &charger->charger_desc;
 372
 373         supply_desc->name = name;
 374         supply_desc->type = POWER_SUPPLY_TYPE_MAINS;
 375         supply_desc->properties = bq24735_charger_properties;
 376         supply_desc->num_properties = ARRAY_SIZE(bq24735_charger_properties);
 377         supply_desc->get_property = bq24735_charger_get_property;
 378         supply_desc->set_property = bq24735_charger_set_property;
 379         supply_desc->property_is_writeable =
 380                                 bq24735_charger_property_is_writeable;
 381
 382         psy_cfg.supplied_to = charger->pdata->supplied_to;
 383         psy_cfg.num_supplicants = charger->pdata->num_supplicants;
 384         psy_cfg.of_node = client->dev.of_node;
 385         psy_cfg.drv_data = charger;
 386
 387         i2c_set_clientdata(client, charger);
 388
 389         charger->status_gpio = devm_gpiod_get_optional(&client->dev,
 390                                                        "ti,ac-detect",
 391                                                        GPIOD_IN);
 392         if (IS_ERR(charger->status_gpio)) {
 393                 ret = PTR_ERR(charger->status_gpio);
 394                 dev_err(&client->dev, "Getting gpio failed: %d\n", ret);
 395                 return ret;
 396         }
 397
 398         if (!charger->status_gpio || bq24735_charger_is_present(charger)) {
 399                 ret = bq24735_read_word(client, BQ24735_MANUFACTURER_ID);
 400                 if (ret < 0) {
 401                         dev_err(&client->dev, "Failed to read manufacturer id : %d\n",
 402                                 ret);
 403                         return ret;
 404                 } else if (ret != 0x0040) {
 405                         dev_err(&client->dev,
 406                                 "manufacturer id mismatch. 0x0040 != 0x%04x\n", ret);
 407                         return -ENODEV;
 408                 }
 409
 410                 ret = bq24735_read_word(client, BQ24735_DEVICE_ID);
 411                 if (ret < 0) {
 412                         dev_err(&client->dev, "Failed to read device id : %d\n", ret);
 413                         return ret;
 414                 } else if (ret != 0x000B) {
 415                         dev_err(&client->dev,
 416                                 "device id mismatch. 0x000b != 0x%04x\n", ret);
 417                         return -ENODEV;
 418                 }
 419         }
 420
 421         ret = bq24735_config_charger(charger);
 422         if (ret < 0) {
 423                 dev_err(&client->dev, "failed in configuring charger");
 424                 return ret;
 425         }
 426
 427         /* check for AC adapter presence */
 428         if (bq24735_charger_is_present(charger)) {
 429                 ret = bq24735_enable_charging(charger);
 430                 if (ret < 0) {
 431                         dev_err(&client->dev, "Failed to enable charging\n");
 432                         return ret;
 433                 }
 434         }
 435
 436         charger->charger = devm_power_supply_register(&client->dev, supply_desc,
 437                                                       &psy_cfg);
 438         if (IS_ERR(charger->charger)) {
 439                 ret = PTR_ERR(charger->charger);
 440                 dev_err(&client->dev, "Failed to register power supply: %d\n",
 441                         ret);
 442                 return ret;
 443         }
 444
 445         if (client->irq) {
 446                 ret = devm_request_threaded_irq(&client->dev, client->irq,
 447                                                 NULL, bq24735_charger_isr,
 448                                                 IRQF_TRIGGER_RISING |
 449                                                 IRQF_TRIGGER_FALLING |
 450                                                 IRQF_ONESHOT,
 451                                                 supply_desc->name,
 452                                                 charger->charger);
 453                 if (ret) {
 454                         dev_err(&client->dev,
 455                                 "Unable to register IRQ %d err %d\n",
 456                                 client->irq, ret);
 457                         return ret;
 458                 }
 459         }
 460
 461         return 0;
 462 }
 463
 464 static const struct i2c_device_id bq24735_charger_id[] = {
 465         { "bq24735-charger", 0 },
 466         {}
 467 };
 468 MODULE_DEVICE_TABLE(i2c, bq24735_charger_id);
 469
 470 static const struct of_device_id bq24735_match_ids[] = {
 471         { .compatible = "ti,bq24735", },
 472         { /* end */ }
 473 };
 474 MODULE_DEVICE_TABLE(of, bq24735_match_ids);
 475
 476 static struct i2c_driver bq24735_charger_driver = {
 477         .driver = {
 478                 .name = "bq24735-charger",
 479                 .of_match_table = bq24735_match_ids,
 480         },
 481         .probe = bq24735_charger_probe,
 482         .id_table = bq24735_charger_id,
 483 };
 484
 485 module_i2c_driver(bq24735_charger_driver);
 486
 487 MODULE_DESCRIPTION("bq24735 battery charging driver");
 488 MODULE_AUTHOR("Darbha Sriharsha <dsriharsha@nvidia.com>");
 489 MODULE_LICENSE("GPL v2");