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"); 490