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, 0);
 115 }
 116
 117 static inline int bq24735_disable_charging(struct bq24735 *charger)
 118 {
 119         if (charger->pdata->ext_control)
 120                 return 0;
 121
 122         return bq24735_update_word(charger->client, BQ24735_CHG_OPT,
 123                                    BQ24735_CHG_OPT_CHARGE_DISABLE,
 124                                    BQ24735_CHG_OPT_CHARGE_DISABLE);
 125 }
 126
 127 static int bq24735_config_charger(struct bq24735 *charger)
 128 {
 129         struct bq24735_platform *pdata = charger->pdata;
 130         int ret;
 131         u16 value;
 132
 133         if (pdata->ext_control)
 134                 return 0;
 135
 136         if (pdata->charge_current) {
 137                 value = pdata->charge_current & BQ24735_CHARGE_CURRENT_MASK;
 138
 139                 ret = bq24735_write_word(charger->client,
 140                                          BQ24735_CHARGE_CURRENT, value);
 141                 if (ret < 0) {
 142                         dev_err(&charger->client->dev,
 143                                 "Failed to write charger current : %d\n",
 144                                 ret);
 145                         return ret;
 146                 }
 147         }
 148
 149         if (pdata->charge_voltage) {
 150                 value = pdata->charge_voltage & BQ24735_CHARGE_VOLTAGE_MASK;
 151
 152                 ret = bq24735_write_word(charger->client,
 153                                          BQ24735_CHARGE_VOLTAGE, value);
 154                 if (ret < 0) {
 155                         dev_err(&charger->client->dev,
 156                                 "Failed to write charger voltage : %d\n",
 157                                 ret);
 158                         return ret;
 159                 }
 160         }
 161
 162         if (pdata->input_current) {
 163                 value = pdata->input_current & BQ24735_INPUT_CURRENT_MASK;
 164
 165                 ret = bq24735_write_word(charger->client,
 166                                          BQ24735_INPUT_CURRENT, value);
 167                 if (ret < 0) {
 168                         dev_err(&charger->client->dev,
 169                                 "Failed to write input current : %d\n",
 170                                 ret);
 171                         return ret;
 172                 }
 173         }
 174
 175         return 0;
 176 }
 177
 178 static bool bq24735_charger_is_present(struct bq24735 *charger)
 179 {
 180         if (charger->status_gpio) {
 181                 return !gpiod_get_value_cansleep(charger->status_gpio);
 182         } else {
 183                 int ac = 0;
 184
 185                 ac = bq24735_read_word(charger->client, BQ24735_CHG_OPT);
 186                 if (ac < 0) {
 187                         dev_err(&charger->client->dev,
 188                                 "Failed to read charger options : %d\n",
 189                                 ac);
 190                         return false;
 191                 }
 192                 return (ac & BQ24735_CHG_OPT_AC_PRESENT) ? true : false;
 193         }
 194
 195         return false;
 196 }
 197
 198 static int bq24735_charger_is_charging(struct bq24735 *charger)
 199 {
 200         int ret;
 201
 202         if (!bq24735_charger_is_present(charger))
 203                 return 0;
 204
 205         ret  = bq24735_read_word(charger->client, BQ24735_CHG_OPT);
 206         if (ret < 0)
 207                 return ret;
 208
 209         return !(ret & BQ24735_CHG_OPT_CHARGE_DISABLE);
 210 }
 211
 212 static irqreturn_t bq24735_charger_isr(int irq, void *devid)
 213 {
 214         struct power_supply *psy = devid;
 215         struct bq24735 *charger = to_bq24735(psy);
 216
 217         mutex_lock(&charger->lock);
 218
 219         if (charger->charging && bq24735_charger_is_present(charger))
 220                 bq24735_enable_charging(charger);
 221         else
 222                 bq24735_disable_charging(charger);
 223
 224         mutex_unlock(&charger->lock);
 225
 226         power_supply_changed(psy);
 227
 228         return IRQ_HANDLED;
 229 }
 230
 231 static int bq24735_charger_get_property(struct power_supply *psy,
 232                                         enum power_supply_property psp,
 233                                         union power_supply_propval *val)
 234 {
 235         struct bq24735 *charger = to_bq24735(psy);
 236
 237         switch (psp) {
 238         case POWER_SUPPLY_PROP_ONLINE:
 239                 val->intval = bq24735_charger_is_present(charger) ? 1 : 0;
 240                 break;
 241         case POWER_SUPPLY_PROP_STATUS:
 242                 switch (bq24735_charger_is_charging(charger)) {
 243                 case 1:
 244                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 245                         break;
 246                 case 0:
 247                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 248                         break;
 249                 default:
 250                         val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 251                         break;
 252                 }
 253                 break;
 254         default:
 255                 return -EINVAL;
 256         }
 257
 258         return 0;
 259 }
 260
 261 static int bq24735_charger_set_property(struct power_supply *psy,
 262                                         enum power_supply_property psp,
 263                                         const union power_supply_propval *val)
 264 {
 265         struct bq24735 *charger = to_bq24735(psy);
 266         int ret;
 267
 268         switch (psp) {
 269         case POWER_SUPPLY_PROP_STATUS:
 270                 switch (val->intval) {
 271                 case POWER_SUPPLY_STATUS_CHARGING:
 272                         mutex_lock(&charger->lock);
 273                         charger->charging = true;
 274                         ret = bq24735_enable_charging(charger);
 275                         mutex_unlock(&charger->lock);
 276                         if (ret)
 277                                 return ret;
 278                         bq24735_config_charger(charger);
 279                         break;
 280                 case POWER_SUPPLY_STATUS_DISCHARGING:
 281                 case POWER_SUPPLY_STATUS_NOT_CHARGING:
 282                         mutex_lock(&charger->lock);
 283                         charger->charging = false;
 284                         ret = bq24735_disable_charging(charger);
 285                         mutex_unlock(&charger->lock);
 286                         if (ret)
 287                                 return ret;
 288                         break;
 289                 default:
 290                         return -EINVAL;
 291                 }
 292                 power_supply_changed(psy);
 293                 break;
 294         default:
 295                 return -EPERM;
 296         }
 297
 298         return 0;
 299 }
 300
 301 static struct bq24735_platform *bq24735_parse_dt_data(struct i2c_client *client)
 302 {
 303         struct bq24735_platform *pdata;
 304         struct device_node *np = client->dev.of_node;
 305         u32 val;
 306         int ret;
 307
 308         pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
 309         if (!pdata) {
 310                 dev_err(&client->dev,
 311                         "Memory alloc for bq24735 pdata failed\n");
 312                 return NULL;
 313         }
 314
 315         ret = of_property_read_u32(np, "ti,charge-current", &val);
 316         if (!ret)
 317                 pdata->charge_current = val;
 318
 319         ret = of_property_read_u32(np, "ti,charge-voltage", &val);
 320         if (!ret)
 321                 pdata->charge_voltage = val;
 322
 323         ret = of_property_read_u32(np, "ti,input-current", &val);
 324         if (!ret)
 325                 pdata->input_current = val;
 326
 327         pdata->ext_control = of_property_read_bool(np, "ti,external-control");
 328
 329         return pdata;
 330 }
 331
 332 static int bq24735_charger_probe(struct i2c_client *client,
 333                                  const struct i2c_device_id *id)
 334 {
 335         int ret;
 336         struct bq24735 *charger;
 337         struct power_supply_desc *supply_desc;
 338         struct power_supply_config psy_cfg = {};
 339         char *name;
 340
 341         charger = devm_kzalloc(&client->dev, sizeof(*charger), GFP_KERNEL);
 342         if (!charger)
 343                 return -ENOMEM;
 344
 345         mutex_init(&charger->lock);
 346         charger->charging = true;
 347         charger->pdata = client->dev.platform_data;
 348
 349         if (IS_ENABLED(CONFIG_OF) && !charger->pdata && client->dev.of_node)
 350                 charger->pdata = bq24735_parse_dt_data(client);
 351
 352         if (!charger->pdata) {
 353                 dev_err(&client->dev, "no platform data provided\n");
 354                 return -EINVAL;
 355         }
 356
 357         name = (char *)charger->pdata->name;
 358         if (!name) {
 359                 name = devm_kasprintf(&client->dev, GFP_KERNEL,
 360                                       "bq24735@%s",
 361                                       dev_name(&client->dev));
 362                 if (!name) {
 363                         dev_err(&client->dev, "Failed to alloc device name\n");
 364                         return -ENOMEM;
 365                 }
 366         }
 367
 368         charger->client = client;
 369
 370         supply_desc = &charger->charger_desc;
 371
 372         supply_desc->name = name;
 373         supply_desc->type = POWER_SUPPLY_TYPE_MAINS;
 374         supply_desc->properties = bq24735_charger_properties;
 375         supply_desc->num_properties = ARRAY_SIZE(bq24735_charger_properties);
 376         supply_desc->get_property = bq24735_charger_get_property;
 377         supply_desc->set_property = bq24735_charger_set_property;
 378         supply_desc->property_is_writeable =
 379                                 bq24735_charger_property_is_writeable;
 380
 381         psy_cfg.supplied_to = charger->pdata->supplied_to;
 382         psy_cfg.num_supplicants = charger->pdata->num_supplicants;
 383         psy_cfg.of_node = client->dev.of_node;
 384         psy_cfg.drv_data = charger;
 385
 386         i2c_set_clientdata(client, charger);
 387
 388         charger->status_gpio = devm_gpiod_get_optional(&client->dev,
 389                                                        "ti,ac-detect",
 390                                                        GPIOD_IN);
 391         if (IS_ERR(charger->status_gpio)) {
 392                 ret = PTR_ERR(charger->status_gpio);
 393                 dev_err(&client->dev, "Getting gpio failed: %d\n", ret);
 394                 return ret;
 395         }
 396
 397         if (!charger->status_gpio || bq24735_charger_is_present(charger)) {
 398                 ret = bq24735_read_word(client, BQ24735_MANUFACTURER_ID);
 399                 if (ret < 0) {
 400                         dev_err(&client->dev, "Failed to read manufacturer id : %d\n",
 401                                 ret);
 402                         return ret;
 403                 } else if (ret != 0x0040) {
 404                         dev_err(&client->dev,
 405                                 "manufacturer id mismatch. 0x0040 != 0x%04x\n", ret);
 406                         return -ENODEV;
 407                 }
 408
 409                 ret = bq24735_read_word(client, BQ24735_DEVICE_ID);
 410                 if (ret < 0) {
 411                         dev_err(&client->dev, "Failed to read device id : %d\n", ret);
 412                         return ret;
 413                 } else if (ret != 0x000B) {
 414                         dev_err(&client->dev,
 415                                 "device id mismatch. 0x000b != 0x%04x\n", ret);
 416                         return -ENODEV;
 417                 }
 418         }
 419
 420         ret = bq24735_config_charger(charger);
 421         if (ret < 0) {
 422                 dev_err(&client->dev, "failed in configuring charger");
 423                 return ret;
 424         }
 425
 426         /* check for AC adapter presence */
 427         if (bq24735_charger_is_present(charger)) {
 428                 ret = bq24735_enable_charging(charger);
 429                 if (ret < 0) {
 430                         dev_err(&client->dev, "Failed to enable charging\n");
 431                         return ret;
 432                 }
 433         }
 434
 435         charger->charger = devm_power_supply_register(&client->dev, supply_desc,
 436                                                       &psy_cfg);
 437         if (IS_ERR(charger->charger)) {
 438                 ret = PTR_ERR(charger->charger);
 439                 dev_err(&client->dev, "Failed to register power supply: %d\n",
 440                         ret);
 441                 return ret;
 442         }
 443
 444         if (client->irq) {
 445                 ret = devm_request_threaded_irq(&client->dev, client->irq,
 446                                                 NULL, bq24735_charger_isr,
 447                                                 IRQF_TRIGGER_RISING |
 448                                                 IRQF_TRIGGER_FALLING |
 449                                                 IRQF_ONESHOT,
 450                                                 supply_desc->name,
 451                                                 charger->charger);
 452                 if (ret) {
 453                         dev_err(&client->dev,
 454                                 "Unable to register IRQ %d err %d\n",
 455                                 client->irq, ret);
 456                         return ret;
 457                 }
 458         }
 459
 460         return 0;
 461 }
 462
 463 static const struct i2c_device_id bq24735_charger_id[] = {
 464         { "bq24735-charger", 0 },
 465         {}
 466 };
 467 MODULE_DEVICE_TABLE(i2c, bq24735_charger_id);
 468
 469 static const struct of_device_id bq24735_match_ids[] = {
 470         { .compatible = "ti,bq24735", },
 471         { /* end */ }
 472 };
 473 MODULE_DEVICE_TABLE(of, bq24735_match_ids);
 474
 475 static struct i2c_driver bq24735_charger_driver = {
 476         .driver = {
 477                 .name = "bq24735-charger",
 478                 .of_match_table = bq24735_match_ids,
 479         },
 480         .probe = bq24735_charger_probe,
 481         .id_table = bq24735_charger_id,
 482 };
 483
 484 module_i2c_driver(bq24735_charger_driver);
 485
 486 MODULE_DESCRIPTION("bq24735 battery charging driver");
 487 MODULE_AUTHOR("Darbha Sriharsha <dsriharsha@nvidia.com>");
 488 MODULE_LICENSE("GPL v2");