2 * Battery charger driver for TI BQ24735
4 * Copyright (c) 2013, NVIDIA CORPORATION. All rights reserved.
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;
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
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.
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>
28 #include <linux/gpio/consumer.h>
29 #include <linux/power_supply.h>
30 #include <linux/slab.h>
32 #include <linux/power/bq24735-charger.h>
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
47 struct power_supply
*charger
;
48 struct power_supply_desc charger_desc
;
49 struct i2c_client
*client
;
50 struct bq24735_platform
*pdata
;
52 struct gpio_desc
*status_gpio
;
53 struct delayed_work poll
;
58 static inline struct bq24735
*to_bq24735(struct power_supply
*psy
)
60 return power_supply_get_drvdata(psy
);
63 static enum power_supply_property bq24735_charger_properties
[] = {
64 POWER_SUPPLY_PROP_STATUS
,
65 POWER_SUPPLY_PROP_ONLINE
,
68 static int bq24735_charger_property_is_writeable(struct power_supply
*psy
,
69 enum power_supply_property psp
)
72 case POWER_SUPPLY_PROP_STATUS
:
81 static inline int bq24735_write_word(struct i2c_client
*client
, u8 reg
,
84 return i2c_smbus_write_word_data(client
, reg
, le16_to_cpu(value
));
87 static inline int bq24735_read_word(struct i2c_client
*client
, u8 reg
)
89 s32 ret
= i2c_smbus_read_word_data(client
, reg
);
91 return ret
< 0 ? ret
: le16_to_cpu(ret
);
94 static int bq24735_update_word(struct i2c_client
*client
, u8 reg
,
100 ret
= bq24735_read_word(client
, reg
);
107 return bq24735_write_word(client
, reg
, tmp
);
110 static int bq24735_config_charger(struct bq24735
*charger
)
112 struct bq24735_platform
*pdata
= charger
->pdata
;
116 if (pdata
->ext_control
)
119 if (pdata
->charge_current
) {
120 value
= pdata
->charge_current
& BQ24735_CHARGE_CURRENT_MASK
;
122 ret
= bq24735_write_word(charger
->client
,
123 BQ24735_CHARGE_CURRENT
, value
);
125 dev_err(&charger
->client
->dev
,
126 "Failed to write charger current : %d\n",
132 if (pdata
->charge_voltage
) {
133 value
= pdata
->charge_voltage
& BQ24735_CHARGE_VOLTAGE_MASK
;
135 ret
= bq24735_write_word(charger
->client
,
136 BQ24735_CHARGE_VOLTAGE
, value
);
138 dev_err(&charger
->client
->dev
,
139 "Failed to write charger voltage : %d\n",
145 if (pdata
->input_current
) {
146 value
= pdata
->input_current
& BQ24735_INPUT_CURRENT_MASK
;
148 ret
= bq24735_write_word(charger
->client
,
149 BQ24735_INPUT_CURRENT
, value
);
151 dev_err(&charger
->client
->dev
,
152 "Failed to write input current : %d\n",
161 static inline int bq24735_enable_charging(struct bq24735
*charger
)
163 if (charger
->pdata
->ext_control
)
166 return bq24735_update_word(charger
->client
, BQ24735_CHG_OPT
,
167 BQ24735_CHG_OPT_CHARGE_DISABLE
, 0);
170 static inline int bq24735_disable_charging(struct bq24735
*charger
)
172 if (charger
->pdata
->ext_control
)
175 return bq24735_update_word(charger
->client
, BQ24735_CHG_OPT
,
176 BQ24735_CHG_OPT_CHARGE_DISABLE
,
177 BQ24735_CHG_OPT_CHARGE_DISABLE
);
180 static bool bq24735_charger_is_present(struct bq24735
*charger
)
182 if (charger
->status_gpio
) {
183 return !gpiod_get_value_cansleep(charger
->status_gpio
);
187 ac
= bq24735_read_word(charger
->client
, BQ24735_CHG_OPT
);
189 dev_err(&charger
->client
->dev
,
190 "Failed to read charger options : %d\n",
194 return (ac
& BQ24735_CHG_OPT_AC_PRESENT
) ? true : false;
200 static int bq24735_charger_is_charging(struct bq24735
*charger
)
204 if (!bq24735_charger_is_present(charger
))
207 ret
= bq24735_read_word(charger
->client
, BQ24735_CHG_OPT
);
211 return !(ret
& BQ24735_CHG_OPT_CHARGE_DISABLE
);
214 static void bq24735_update(struct bq24735
*charger
)
216 mutex_lock(&charger
->lock
);
218 if (charger
->charging
&& bq24735_charger_is_present(charger
))
219 bq24735_enable_charging(charger
);
221 bq24735_disable_charging(charger
);
223 mutex_unlock(&charger
->lock
);
225 power_supply_changed(charger
->charger
);
228 static irqreturn_t
bq24735_charger_isr(int irq
, void *devid
)
230 struct power_supply
*psy
= devid
;
231 struct bq24735
*charger
= to_bq24735(psy
);
233 bq24735_update(charger
);
238 static void bq24735_poll(struct work_struct
*work
)
240 struct bq24735
*charger
= container_of(work
, struct bq24735
, poll
.work
);
242 bq24735_update(charger
);
244 schedule_delayed_work(&charger
->poll
,
245 msecs_to_jiffies(charger
->poll_interval
));
248 static int bq24735_charger_get_property(struct power_supply
*psy
,
249 enum power_supply_property psp
,
250 union power_supply_propval
*val
)
252 struct bq24735
*charger
= to_bq24735(psy
);
255 case POWER_SUPPLY_PROP_ONLINE
:
256 val
->intval
= bq24735_charger_is_present(charger
) ? 1 : 0;
258 case POWER_SUPPLY_PROP_STATUS
:
259 switch (bq24735_charger_is_charging(charger
)) {
261 val
->intval
= POWER_SUPPLY_STATUS_CHARGING
;
264 val
->intval
= POWER_SUPPLY_STATUS_NOT_CHARGING
;
267 val
->intval
= POWER_SUPPLY_STATUS_UNKNOWN
;
278 static int bq24735_charger_set_property(struct power_supply
*psy
,
279 enum power_supply_property psp
,
280 const union power_supply_propval
*val
)
282 struct bq24735
*charger
= to_bq24735(psy
);
286 case POWER_SUPPLY_PROP_STATUS
:
287 switch (val
->intval
) {
288 case POWER_SUPPLY_STATUS_CHARGING
:
289 mutex_lock(&charger
->lock
);
290 charger
->charging
= true;
291 ret
= bq24735_enable_charging(charger
);
292 mutex_unlock(&charger
->lock
);
295 bq24735_config_charger(charger
);
297 case POWER_SUPPLY_STATUS_DISCHARGING
:
298 case POWER_SUPPLY_STATUS_NOT_CHARGING
:
299 mutex_lock(&charger
->lock
);
300 charger
->charging
= false;
301 ret
= bq24735_disable_charging(charger
);
302 mutex_unlock(&charger
->lock
);
309 power_supply_changed(psy
);
318 static struct bq24735_platform
*bq24735_parse_dt_data(struct i2c_client
*client
)
320 struct bq24735_platform
*pdata
;
321 struct device_node
*np
= client
->dev
.of_node
;
325 pdata
= devm_kzalloc(&client
->dev
, sizeof(*pdata
), GFP_KERNEL
);
327 dev_err(&client
->dev
,
328 "Memory alloc for bq24735 pdata failed\n");
332 ret
= of_property_read_u32(np
, "ti,charge-current", &val
);
334 pdata
->charge_current
= val
;
336 ret
= of_property_read_u32(np
, "ti,charge-voltage", &val
);
338 pdata
->charge_voltage
= val
;
340 ret
= of_property_read_u32(np
, "ti,input-current", &val
);
342 pdata
->input_current
= val
;
344 pdata
->ext_control
= of_property_read_bool(np
, "ti,external-control");
349 static int bq24735_charger_probe(struct i2c_client
*client
,
350 const struct i2c_device_id
*id
)
353 struct bq24735
*charger
;
354 struct power_supply_desc
*supply_desc
;
355 struct power_supply_config psy_cfg
= {};
358 charger
= devm_kzalloc(&client
->dev
, sizeof(*charger
), GFP_KERNEL
);
362 mutex_init(&charger
->lock
);
363 charger
->charging
= true;
364 charger
->pdata
= client
->dev
.platform_data
;
366 if (IS_ENABLED(CONFIG_OF
) && !charger
->pdata
&& client
->dev
.of_node
)
367 charger
->pdata
= bq24735_parse_dt_data(client
);
369 if (!charger
->pdata
) {
370 dev_err(&client
->dev
, "no platform data provided\n");
374 name
= (char *)charger
->pdata
->name
;
376 name
= devm_kasprintf(&client
->dev
, GFP_KERNEL
,
378 dev_name(&client
->dev
));
380 dev_err(&client
->dev
, "Failed to alloc device name\n");
385 charger
->client
= client
;
387 supply_desc
= &charger
->charger_desc
;
389 supply_desc
->name
= name
;
390 supply_desc
->type
= POWER_SUPPLY_TYPE_MAINS
;
391 supply_desc
->properties
= bq24735_charger_properties
;
392 supply_desc
->num_properties
= ARRAY_SIZE(bq24735_charger_properties
);
393 supply_desc
->get_property
= bq24735_charger_get_property
;
394 supply_desc
->set_property
= bq24735_charger_set_property
;
395 supply_desc
->property_is_writeable
=
396 bq24735_charger_property_is_writeable
;
398 psy_cfg
.supplied_to
= charger
->pdata
->supplied_to
;
399 psy_cfg
.num_supplicants
= charger
->pdata
->num_supplicants
;
400 psy_cfg
.of_node
= client
->dev
.of_node
;
401 psy_cfg
.drv_data
= charger
;
403 i2c_set_clientdata(client
, charger
);
405 charger
->status_gpio
= devm_gpiod_get_optional(&client
->dev
,
408 if (IS_ERR(charger
->status_gpio
)) {
409 ret
= PTR_ERR(charger
->status_gpio
);
410 dev_err(&client
->dev
, "Getting gpio failed: %d\n", ret
);
414 if (!charger
->status_gpio
|| bq24735_charger_is_present(charger
)) {
415 ret
= bq24735_read_word(client
, BQ24735_MANUFACTURER_ID
);
417 dev_err(&client
->dev
, "Failed to read manufacturer id : %d\n",
420 } else if (ret
!= 0x0040) {
421 dev_err(&client
->dev
,
422 "manufacturer id mismatch. 0x0040 != 0x%04x\n", ret
);
426 ret
= bq24735_read_word(client
, BQ24735_DEVICE_ID
);
428 dev_err(&client
->dev
, "Failed to read device id : %d\n", ret
);
430 } else if (ret
!= 0x000B) {
431 dev_err(&client
->dev
,
432 "device id mismatch. 0x000b != 0x%04x\n", ret
);
437 ret
= bq24735_config_charger(charger
);
439 dev_err(&client
->dev
, "failed in configuring charger");
443 /* check for AC adapter presence */
444 if (bq24735_charger_is_present(charger
)) {
445 ret
= bq24735_enable_charging(charger
);
447 dev_err(&client
->dev
, "Failed to enable charging\n");
452 charger
->charger
= devm_power_supply_register(&client
->dev
, supply_desc
,
454 if (IS_ERR(charger
->charger
)) {
455 ret
= PTR_ERR(charger
->charger
);
456 dev_err(&client
->dev
, "Failed to register power supply: %d\n",
462 ret
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
463 NULL
, bq24735_charger_isr
,
464 IRQF_TRIGGER_RISING
|
465 IRQF_TRIGGER_FALLING
|
470 dev_err(&client
->dev
,
471 "Unable to register IRQ %d err %d\n",
475 } else if (charger
->status_gpio
) {
476 ret
= device_property_read_u32(&client
->dev
, "poll-interval",
477 &charger
->poll_interval
);
480 if (!charger
->poll_interval
)
483 INIT_DELAYED_WORK(&charger
->poll
, bq24735_poll
);
484 schedule_delayed_work(&charger
->poll
,
485 msecs_to_jiffies(charger
->poll_interval
));
491 static int bq24735_charger_remove(struct i2c_client
*client
)
493 struct bq24735
*charger
= i2c_get_clientdata(client
);
495 if (charger
->poll_interval
)
496 cancel_delayed_work_sync(&charger
->poll
);
501 static const struct i2c_device_id bq24735_charger_id
[] = {
502 { "bq24735-charger", 0 },
505 MODULE_DEVICE_TABLE(i2c
, bq24735_charger_id
);
507 static const struct of_device_id bq24735_match_ids
[] = {
508 { .compatible
= "ti,bq24735", },
511 MODULE_DEVICE_TABLE(of
, bq24735_match_ids
);
513 static struct i2c_driver bq24735_charger_driver
= {
515 .name
= "bq24735-charger",
516 .of_match_table
= bq24735_match_ids
,
518 .probe
= bq24735_charger_probe
,
519 .remove
= bq24735_charger_remove
,
520 .id_table
= bq24735_charger_id
,
523 module_i2c_driver(bq24735_charger_driver
);
525 MODULE_DESCRIPTION("bq24735 battery charging driver");
526 MODULE_AUTHOR("Darbha Sriharsha <dsriharsha@nvidia.com>");
527 MODULE_LICENSE("GPL v2");