2 * bq2419x-charger.c -- BQ24190/BQ24192/BQ24192i/BQ24193 Charger driver
4 * Copyright (c) 2013-2014, NVIDIA CORPORATION. All rights reserved.
6 * Author: Laxman Dewangan <ldewangan@nvidia.com>
7 * Author: Syed Rafiuddin <srafiuddin@nvidia.com>
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License as
11 * published by the Free Software Foundation version 2.
13 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
14 * whether express or implied; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
23 #include <linux/delay.h>
24 #include <linux/err.h>
25 #include <linux/i2c.h>
26 #include <linux/init.h>
27 #include <linux/interrupt.h>
28 #include <linux/kthread.h>
29 #include <linux/sched.h>
30 #include <linux/sched/rt.h>
31 #include <linux/time.h>
32 #include <linux/timer.h>
33 #include <linux/gpio.h>
34 #include <linux/of_gpio.h>
35 #include <linux/kernel.h>
36 #include <linux/module.h>
37 #include <linux/power/bq2419x-charger.h>
38 #include <linux/regmap.h>
39 #include <linux/regmap.h>
40 #include <linux/regulator/driver.h>
41 #include <linux/regulator/machine.h>
42 #include <linux/regulator/of_regulator.h>
43 #include <linux/slab.h>
44 #include <linux/alarmtimer.h>
45 #include <linux/power/battery-charger-gauge-comm.h>
46 #include <linux/workqueue.h>
48 #define MAX_STR_PRINT 50
50 #define bq_chg_err(bq, fmt, ...) \
51 dev_err(bq->dev, "Charging Fault: " fmt, ##__VA_ARGS__)
53 #define BQ2419X_INPUT_VINDPM_OFFSET 3880
54 #define BQ2419X_CHARGE_ICHG_OFFSET 512
55 #define BQ2419X_PRE_CHG_IPRECHG_OFFSET 128
56 #define BQ2419X_PRE_CHG_TERM_OFFSET 128
57 #define BQ2419X_CHARGE_VOLTAGE_OFFSET 3504
58 #define BQ2419X_CHARGE_LED_OFF 1
59 #define BQ2419x_OTG_ENABLE_TIME (30*HZ)
61 /* input current limit */
62 static const unsigned int iinlim[] = {
63 100, 150, 500, 900, 1200, 1500, 2000, 3000,
66 static const struct regmap_config bq2419x_regmap_config = {
69 .max_register = BQ2419X_MAX_REGS,
72 struct bq2419x_reg_info {
79 struct regmap *regmap;
82 int wdt_refresh_timeout;
84 int auto_recharge_time_power_off;
85 bool emulate_input_disconnected;
88 struct mutex otg_mutex;
91 struct regulator_dev *chg_rdev;
92 struct regulator_desc chg_reg_desc;
93 struct regulator_init_data chg_reg_init_data;
95 struct regulator_dev *vbus_rdev;
96 struct regulator_desc vbus_reg_desc;
97 struct regulator_init_data vbus_reg_init_data;
99 struct battery_charger_dev *bc_dev;
102 struct delayed_work wdt_restart_wq;
103 struct delayed_work otg_reset_work;
104 int chg_restart_time;
105 int is_otg_connected;
106 int battery_presense;
107 bool cable_connected;
108 int last_charging_current;
109 bool disable_suspend_during_charging;
111 u32 auto_recharge_time_supend;
113 struct bq2419x_reg_info input_src;
114 struct bq2419x_reg_info chg_current_control;
115 struct bq2419x_reg_info prechg_term_control;
116 struct bq2419x_reg_info ir_comp_therm;
117 struct bq2419x_reg_info chg_voltage_control;
118 struct bq2419x_vbus_platform_data *vbus_pdata;
119 struct bq2419x_charger_platform_data *charger_pdata;
122 static int current_to_reg(const unsigned int *tbl,
123 size_t size, unsigned int val)
127 for (i = 0; i < size; i++)
130 return i > 0 ? i - 1 : -EINVAL;
133 static int bq2419x_charger_enable(struct bq2419x_chip *bq2419x)
137 if (bq2419x->battery_presense) {
138 dev_info(bq2419x->dev, "Charging enabled\n");
139 /* set default Charge regulation voltage */
140 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_VOLT_CTRL_REG,
141 bq2419x->chg_voltage_control.mask,
142 bq2419x->chg_voltage_control.val);
144 dev_err(bq2419x->dev,
145 "VOLT_CTRL_REG update failed %d\n", ret);
148 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_PWR_ON_REG,
149 BQ2419X_ENABLE_CHARGE_MASK,
150 BQ2419X_ENABLE_CHARGE);
152 dev_info(bq2419x->dev, "Charging disabled\n");
153 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_PWR_ON_REG,
154 BQ2419X_ENABLE_CHARGE_MASK,
155 BQ2419X_DISABLE_CHARGE);
158 dev_err(bq2419x->dev, "register update failed, err %d\n", ret);
162 static int bq2419x_vbus_enable(struct regulator_dev *rdev)
164 struct bq2419x_chip *bq2419x = rdev_get_drvdata(rdev);
167 dev_info(bq2419x->dev, "VBUS enabled, charging disabled\n");
169 mutex_lock(&bq2419x->otg_mutex);
170 bq2419x->is_otg_connected = true;
171 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_PWR_ON_REG,
172 BQ2419X_ENABLE_CHARGE_MASK, BQ2419X_ENABLE_VBUS);
174 dev_err(bq2419x->dev, "PWR_ON_REG update failed %d", ret);
175 mutex_unlock(&bq2419x->otg_mutex);
180 static int bq2419x_vbus_disable(struct regulator_dev *rdev)
182 struct bq2419x_chip *bq2419x = rdev_get_drvdata(rdev);
185 dev_info(bq2419x->dev, "VBUS disabled, charging enabled\n");
187 mutex_lock(&bq2419x->otg_mutex);
188 bq2419x->is_otg_connected = false;
189 ret = bq2419x_charger_enable(bq2419x);
191 dev_err(bq2419x->dev, "Charger enable failed %d", ret);
192 mutex_unlock(&bq2419x->otg_mutex);
197 static int bq2419x_vbus_is_enabled(struct regulator_dev *rdev)
199 struct bq2419x_chip *bq2419x = rdev_get_drvdata(rdev);
203 ret = regmap_read(bq2419x->regmap, BQ2419X_PWR_ON_REG, &data);
205 dev_err(bq2419x->dev, "PWR_ON_REG read failed %d", ret);
208 return (data & BQ2419X_ENABLE_CHARGE_MASK) == BQ2419X_ENABLE_VBUS;
211 static struct regulator_ops bq2419x_vbus_ops = {
212 .enable = bq2419x_vbus_enable,
213 .disable = bq2419x_vbus_disable,
214 .is_enabled = bq2419x_vbus_is_enabled,
217 static int bq2419x_val_to_reg(int val, int offset, int div, int nbits,
220 int max_val = offset + (BIT(nbits) - 1) * div;
226 return BIT(nbits) - 1;
229 return DIV_ROUND_UP(val - offset, div);
231 return (val - offset) / div;
234 static int bq2419x_process_charger_plat_data(struct bq2419x_chip *bq2419x,
235 struct bq2419x_charger_platform_data *chg_pdata)
238 int fast_charge_current;
239 int pre_charge_current;
240 int termination_current;
241 int ir_compensation_resistor;
242 int ir_compensation_voltage;
243 int thermal_regulation_threshold;
244 int charge_voltage_limit;
245 int vindpm, ichg, iprechg, iterm, bat_comp, vclamp, treg, vreg;
248 voltage_input = chg_pdata->input_voltage_limit_mV ?: 4200;
249 fast_charge_current =
250 chg_pdata->fast_charge_current_limit_mA ?: 4544;
252 chg_pdata->pre_charge_current_limit_mA ?: 256;
253 termination_current =
254 chg_pdata->termination_current_limit_mA ?: 128;
255 ir_compensation_resistor =
256 chg_pdata->ir_compensation_resister_ohm ?: 70;
257 ir_compensation_voltage =
258 chg_pdata->ir_compensation_voltage_mV ?: 112;
259 thermal_regulation_threshold =
260 chg_pdata->thermal_regulation_threshold_degC ?: 100;
261 charge_voltage_limit =
262 chg_pdata->charge_voltage_limit_mV ?: 4208;
264 voltage_input = 4200;
265 fast_charge_current = 4544;
266 pre_charge_current = 256;
267 termination_current = 128;
268 ir_compensation_resistor = 70;
269 ir_compensation_voltage = 112;
270 thermal_regulation_threshold = 100;
271 charge_voltage_limit = 4208;
274 vindpm = bq2419x_val_to_reg(voltage_input,
275 BQ2419X_INPUT_VINDPM_OFFSET, 80, 4, 0);
276 bq2419x->input_src.mask = BQ2419X_INPUT_VINDPM_MASK;
277 bq2419x->input_src.val = vindpm << 3;
278 bq2419x->input_src.mask |= BQ2419X_INPUT_IINLIM_MASK;
279 bq2419x->input_src.val |= 0x2;
281 ichg = bq2419x_val_to_reg(fast_charge_current,
282 BQ2419X_CHARGE_ICHG_OFFSET, 64, 6, 0);
283 bq2419x->chg_current_control.mask = BQ2419X_CHRG_CTRL_ICHG_MASK;
284 bq2419x->chg_current_control.val = ichg << 2;
286 iprechg = bq2419x_val_to_reg(pre_charge_current,
287 BQ2419X_PRE_CHG_IPRECHG_OFFSET, 128, 4, 0);
288 bq2419x->prechg_term_control.mask = BQ2419X_CHRG_TERM_PRECHG_MASK;
289 bq2419x->prechg_term_control.val = iprechg << 4;
290 iterm = bq2419x_val_to_reg(termination_current,
291 BQ2419X_PRE_CHG_TERM_OFFSET, 128, 4, 0);
292 bq2419x->prechg_term_control.mask |= BQ2419X_CHRG_TERM_TERM_MASK;
293 bq2419x->prechg_term_control.val |= iterm;
295 bat_comp = ir_compensation_resistor / 10;
296 bq2419x->ir_comp_therm.mask = BQ2419X_THERM_BAT_COMP_MASK;
297 bq2419x->ir_comp_therm.val = bat_comp << 5;
298 vclamp = ir_compensation_voltage / 16;
299 bq2419x->ir_comp_therm.mask |= BQ2419X_THERM_VCLAMP_MASK;
300 bq2419x->ir_comp_therm.val |= vclamp << 2;
301 bq2419x->ir_comp_therm.mask |= BQ2419X_THERM_TREG_MASK;
302 if (thermal_regulation_threshold <= 60)
304 else if (thermal_regulation_threshold <= 80)
306 else if (thermal_regulation_threshold <= 100)
310 bq2419x->ir_comp_therm.val |= treg;
312 vreg = bq2419x_val_to_reg(charge_voltage_limit,
313 BQ2419X_CHARGE_VOLTAGE_OFFSET, 16, 6, 1);
314 bq2419x->chg_voltage_control.mask = BQ2419X_CHG_VOLT_LIMIT_MASK;
315 bq2419x->chg_voltage_control.val = vreg << 2;
319 static int bq2419x_charger_init(struct bq2419x_chip *bq2419x)
323 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_CHRG_CTRL_REG,
324 bq2419x->chg_current_control.mask,
325 bq2419x->chg_current_control.val);
327 dev_err(bq2419x->dev, "CHRG_CTRL_REG write failed %d\n", ret);
331 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_CHRG_TERM_REG,
332 bq2419x->prechg_term_control.mask,
333 bq2419x->prechg_term_control.val);
335 dev_err(bq2419x->dev, "CHRG_TERM_REG write failed %d\n", ret);
339 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
340 bq2419x->input_src.mask, bq2419x->input_src.val);
342 dev_err(bq2419x->dev, "INPUT_SRC_REG write failed %d\n", ret);
344 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_THERM_REG,
345 bq2419x->ir_comp_therm.mask, bq2419x->ir_comp_therm.val);
347 dev_err(bq2419x->dev, "THERM_REG write failed: %d\n", ret);
349 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_VOLT_CTRL_REG,
350 bq2419x->chg_voltage_control.mask,
351 bq2419x->chg_voltage_control.val);
353 dev_err(bq2419x->dev, "VOLT_CTRL update failed: %d\n", ret);
355 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_TIME_CTRL_REG,
356 BQ2419X_TIME_JEITA_ISET, 0);
358 dev_err(bq2419x->dev, "TIME_CTRL update failed: %d\n", ret);
363 static void bq2419x_otg_reset_work_handler(struct work_struct *work)
366 struct bq2419x_chip *bq2419x = container_of(to_delayed_work(work),
367 struct bq2419x_chip, otg_reset_work);
369 if (!mutex_is_locked(&bq2419x->otg_mutex)) {
370 mutex_lock(&bq2419x->otg_mutex);
371 if (bq2419x->is_otg_connected) {
372 ret = regmap_update_bits(bq2419x->regmap,
374 BQ2419X_ENABLE_CHARGE_MASK,
375 BQ2419X_ENABLE_VBUS);
377 dev_err(bq2419x->dev,
378 "PWR_ON_REG update failed %d", ret);
380 mutex_unlock(&bq2419x->otg_mutex);
384 static int bq2419x_disable_otg_mode(struct bq2419x_chip *bq2419x)
388 mutex_lock(&bq2419x->otg_mutex);
389 if (bq2419x->is_otg_connected) {
390 ret = bq2419x_charger_enable(bq2419x);
392 dev_err(bq2419x->dev,
393 "Charger enable failed %d", ret);
394 mutex_unlock(&bq2419x->otg_mutex);
397 schedule_delayed_work(&bq2419x->otg_reset_work,
398 BQ2419x_OTG_ENABLE_TIME);
400 mutex_unlock(&bq2419x->otg_mutex);
405 static int bq2419x_configure_charging_current(struct bq2419x_chip *bq2419x,
406 int in_current_limit)
413 if (!bq2419x->emulate_input_disconnected) {
414 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
417 dev_err(bq2419x->dev,
418 "INPUT_SRC_REG update failed %d\n", ret);
423 /* Configure input voltage limit*/
424 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
425 bq2419x->input_src.mask, bq2419x->input_src.val);
427 dev_err(bq2419x->dev, "INPUT_SRC_REG update failed %d\n", ret);
431 /* Configure input current limit in steps */
432 val = current_to_reg(iinlim, ARRAY_SIZE(iinlim), in_current_limit);
433 floor = current_to_reg(iinlim, ARRAY_SIZE(iinlim), 500);
434 if (val < 0 || floor < 0)
437 for (; floor <= val; floor++) {
438 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
439 BQ2419x_CONFIG_MASK, floor);
441 dev_err(bq2419x->dev,
442 "INPUT_SRC_REG update failed: %d\n", ret);
443 udelay(BQ2419x_CHARGING_CURRENT_STEP_DELAY_US);
445 bq2419x->in_current_limit = in_current_limit;
449 static int bq2419x_set_charging_current(struct regulator_dev *rdev,
450 int min_uA, int max_uA)
452 struct bq2419x_chip *bq2419x = rdev_get_drvdata(rdev);
453 int in_current_limit;
454 int old_current_limit;
458 dev_info(bq2419x->dev, "Setting charging current %d\n", max_uA/1000);
460 bq2419x->chg_status = BATTERY_DISCHARGING;
462 ret = bq2419x_charger_enable(bq2419x);
464 dev_err(bq2419x->dev, "Charger enable failed %d", ret);
468 ret = regmap_read(bq2419x->regmap, BQ2419X_SYS_STAT_REG, &val);
470 dev_err(bq2419x->dev, "SYS_STAT_REG read failed: %d\n", ret);
472 if (max_uA == 0 && val != 0)
475 old_current_limit = bq2419x->in_current_limit;
476 bq2419x->last_charging_current = max_uA;
477 if ((val & BQ2419x_VBUS_STAT) == BQ2419x_VBUS_UNKNOWN) {
478 battery_charging_restart_cancel(bq2419x->bc_dev);
479 in_current_limit = 500;
480 bq2419x->cable_connected = 0;
481 bq2419x->chg_status = BATTERY_DISCHARGING;
482 battery_charger_thermal_stop_monitoring(
484 } else if ((val & BQ2419x_CHRG_STATE_MASK) ==
485 BQ2419x_CHRG_STATE_CHARGE_DONE) {
486 dev_info(bq2419x->dev, "Charging completed\n");
487 bq2419x->chg_status = BATTERY_CHARGING_DONE;
488 bq2419x->cable_connected = 1;
489 in_current_limit = max_uA/1000;
490 battery_charging_restart(bq2419x->bc_dev,
491 bq2419x->chg_restart_time);
492 battery_charger_thermal_stop_monitoring(
495 in_current_limit = max_uA/1000;
496 bq2419x->cable_connected = 1;
497 bq2419x->chg_status = BATTERY_CHARGING;
498 battery_charger_thermal_start_monitoring(
501 ret = bq2419x_configure_charging_current(bq2419x, in_current_limit);
505 battery_charging_status_update(bq2419x->bc_dev, bq2419x->chg_status);
506 if (bq2419x->disable_suspend_during_charging) {
507 if (bq2419x->cable_connected && in_current_limit > 500
508 && (bq2419x->chg_status != BATTERY_CHARGING_DONE))
509 battery_charger_acquire_wake_lock(bq2419x->bc_dev);
510 else if (!bq2419x->cable_connected && old_current_limit > 500)
511 battery_charger_release_wake_lock(bq2419x->bc_dev);
516 dev_err(bq2419x->dev, "Charger enable failed, err = %d\n", ret);
520 static struct regulator_ops bq2419x_tegra_regulator_ops = {
521 .set_current_limit = bq2419x_set_charging_current,
524 static int bq2419x_set_charging_current_suspend(struct bq2419x_chip *bq2419x,
525 int in_current_limit)
530 dev_info(bq2419x->dev, "Setting charging current %d mA\n",
533 ret = bq2419x_charger_enable(bq2419x);
535 dev_err(bq2419x->dev, "Charger enable failed %d", ret);
539 ret = regmap_read(bq2419x->regmap, BQ2419X_SYS_STAT_REG, &val);
541 dev_err(bq2419x->dev, "SYS_STAT_REG read failed: %d\n", ret);
543 if (!bq2419x->cable_connected) {
544 battery_charging_restart_cancel(bq2419x->bc_dev);
545 ret = bq2419x_configure_charging_current(bq2419x,
553 static int bq2419x_reset_wdt(struct bq2419x_chip *bq2419x, const char *from)
559 mutex_lock(&bq2419x->mutex);
560 dev_dbg(bq2419x->dev, "%s() from %s()\n", __func__, from);
563 if (bq2419x->emulate_input_disconnected)
564 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
565 BQ2419X_EN_HIZ, BQ2419X_EN_HIZ);
567 ret = regmap_update_bits(bq2419x->regmap,
568 BQ2419X_INPUT_SRC_REG, BQ2419X_EN_HIZ, 0);
570 dev_err(bq2419x->dev, "INPUT_SRC_REG update failed:%d\n", ret);
574 if (!bq2419x->wdt_refresh_timeout)
577 ret = regmap_read(bq2419x->regmap, BQ2419X_PWR_ON_REG, ®01);
579 dev_err(bq2419x->dev, "PWR_ON_REG read failed: %d\n", ret);
585 /* Write two times to make sure reset WDT */
586 ret = regmap_write(bq2419x->regmap, BQ2419X_PWR_ON_REG, reg01);
588 dev_err(bq2419x->dev, "PWR_ON_REG write failed: %d\n", ret);
591 ret = regmap_write(bq2419x->regmap, BQ2419X_PWR_ON_REG, reg01);
593 dev_err(bq2419x->dev, "PWR_ON_REG write failed: %d\n", ret);
598 mutex_unlock(&bq2419x->mutex);
600 timeout = bq2419x->wdt_refresh_timeout ? : 100;
601 schedule_delayed_work(&bq2419x->wdt_restart_wq, timeout * HZ);
605 static int bq2419x_fault_clear_sts(struct bq2419x_chip *bq2419x,
606 unsigned int *reg09_val)
609 unsigned int reg09_1, reg09_2;
611 ret = regmap_read(bq2419x->regmap, BQ2419X_FAULT_REG, ®09_1);
613 dev_err(bq2419x->dev, "FAULT_REG read failed: %d\n", ret);
617 ret = regmap_read(bq2419x->regmap, BQ2419X_FAULT_REG, ®09_2);
619 dev_err(bq2419x->dev, "FAULT_REG read failed: %d\n", ret);
622 unsigned int reg09 = 0;
624 if ((reg09_1 | reg09_2) & BQ2419x_FAULT_WATCHDOG_FAULT)
625 reg09 |= BQ2419x_FAULT_WATCHDOG_FAULT;
626 if ((reg09_1 | reg09_2) & BQ2419x_FAULT_BOOST_FAULT)
627 reg09 |= BQ2419x_FAULT_BOOST_FAULT;
628 if ((reg09_1 | reg09_2) & BQ2419x_FAULT_BAT_FAULT)
629 reg09 |= BQ2419x_FAULT_BAT_FAULT;
630 if (((reg09_1 & BQ2419x_FAULT_CHRG_FAULT_MASK) ==
631 BQ2419x_FAULT_CHRG_SAFTY) ||
632 ((reg09_2 & BQ2419x_FAULT_CHRG_FAULT_MASK) ==
633 BQ2419x_FAULT_CHRG_SAFTY))
634 reg09 |= BQ2419x_FAULT_CHRG_SAFTY;
635 else if (((reg09_1 & BQ2419x_FAULT_CHRG_FAULT_MASK) ==
636 BQ2419x_FAULT_CHRG_INPUT) ||
637 ((reg09_2 & BQ2419x_FAULT_CHRG_FAULT_MASK) ==
638 BQ2419x_FAULT_CHRG_INPUT))
639 reg09 |= BQ2419x_FAULT_CHRG_INPUT;
640 else if (((reg09_1 & BQ2419x_FAULT_CHRG_FAULT_MASK) ==
641 BQ2419x_FAULT_CHRG_THERMAL) ||
642 ((reg09_2 & BQ2419x_FAULT_CHRG_FAULT_MASK) ==
643 BQ2419x_FAULT_CHRG_THERMAL))
644 reg09 |= BQ2419x_FAULT_CHRG_THERMAL;
646 reg09 |= reg09_2 &BQ2419x_FAULT_NTC_FAULT;
652 static int bq2419x_watchdog_init(struct bq2419x_chip *bq2419x,
653 int timeout, const char *from)
659 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_TIME_CTRL_REG,
662 dev_err(bq2419x->dev, "TIME_CTRL_REG read failed: %d\n",
664 bq2419x->wdt_refresh_timeout = 0;
669 val = BQ2419X_WD_40ms;
670 bq2419x->wdt_refresh_timeout = 25;
671 } else if (timeout <= 120) {
672 val = BQ2419X_WD_80ms;
673 bq2419x->wdt_refresh_timeout = 50;
675 val = BQ2419X_WD_160ms;
676 bq2419x->wdt_refresh_timeout = 125;
679 ret = regmap_read(bq2419x->regmap, BQ2419X_TIME_CTRL_REG, ®05);
681 dev_err(bq2419x->dev, "TIME_CTRL_REG read failed:%d\n", ret);
685 /* Reset WDT to be safe if about to end */
686 ret = bq2419x_reset_wdt(bq2419x, from);
688 dev_err(bq2419x->dev, "bq2419x_reset_wdt failed: %d\n", ret);
690 if ((reg05 & BQ2419X_WD_MASK) != val) {
691 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_TIME_CTRL_REG,
692 BQ2419X_WD_MASK, val);
694 dev_err(bq2419x->dev, "TIME_CTRL_REG read failed: %d\n",
700 ret = bq2419x_reset_wdt(bq2419x, from);
702 dev_err(bq2419x->dev, "bq2419x_reset_wdt failed: %d\n", ret);
707 static void bq2419x_wdt_restart_wq(struct work_struct *work)
709 struct bq2419x_chip *bq2419x;
712 bq2419x = container_of(work, struct bq2419x_chip, wdt_restart_wq.work);
713 ret = bq2419x_reset_wdt(bq2419x, "THREAD");
715 dev_err(bq2419x->dev, "bq2419x_reset_wdt failed: %d\n", ret);
718 static int bq2419x_reconfigure_charger_param(struct bq2419x_chip *bq2419x,
723 dev_info(bq2419x->dev, "Reconfiguring charging param from %s\n", from);
724 ret = bq2419x_watchdog_init(bq2419x, bq2419x->wdt_time_sec, from);
726 dev_err(bq2419x->dev, "BQWDT init failed %d\n", ret);
730 ret = bq2419x_charger_init(bq2419x);
732 dev_err(bq2419x->dev, "Charger init failed: %d\n", ret);
736 ret = bq2419x_configure_charging_current(bq2419x,
737 bq2419x->in_current_limit);
739 dev_err(bq2419x->dev, "Current config failed: %d\n", ret);
745 static int bq2419x_handle_safety_timer_expire(struct bq2419x_chip *bq2419x)
747 struct device *dev = bq2419x->dev;
750 /* Reset saftty timer by setting 0 and then making 1 */
751 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_TIME_CTRL_REG,
752 BQ2419X_EN_SFT_TIMER_MASK, 0);
754 dev_err(dev, "TIME_CTRL_REG update failed: %d\n", ret);
758 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_TIME_CTRL_REG,
759 BQ2419X_EN_SFT_TIMER_MASK, BQ2419X_EN_SFT_TIMER_MASK);
761 dev_err(dev, "TIME_CTRL_REG update failed: %d\n", ret);
765 /* Need to toggel the Charging-enable bit from 1 to 0 to 1 */
766 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_PWR_ON_REG,
767 BQ2419X_ENABLE_CHARGE_MASK, 0);
769 dev_err(dev, "PWR_ON_REG update failed %d\n", ret);
772 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_PWR_ON_REG,
773 BQ2419X_ENABLE_CHARGE_MASK, BQ2419X_ENABLE_CHARGE);
775 dev_err(dev, "PWR_ON_REG update failed %d\n", ret);
779 ret = bq2419x_reconfigure_charger_param(bq2419x, "SAFETY-TIMER_EXPIRE");
781 dev_err(dev, "Reconfig of BQ parm failed: %d\n", ret);
787 static irqreturn_t bq2419x_irq(int irq, void *data)
789 struct bq2419x_chip *bq2419x = data;
792 int check_chg_state = 0;
794 ret = bq2419x_fault_clear_sts(bq2419x, &val);
796 dev_err(bq2419x->dev, "fault clear status failed %d\n", ret);
800 dev_info(bq2419x->dev, "%s() Irq %d status 0x%02x\n",
803 if ((val & BQ2419x_CHARGING_FAULT_MASK) &&
804 gpio_is_valid(bq2419x->chg_status_gpio) &&
805 bq2419x->chg_status == BATTERY_CHARGING) {
806 gpio_set_value(bq2419x->chg_status_gpio, BQ2419X_CHARGE_LED_OFF);
809 if (val & BQ2419x_FAULT_BOOST_FAULT) {
810 bq_chg_err(bq2419x, "VBUS Overloaded\n");
811 ret = bq2419x_disable_otg_mode(bq2419x);
813 bq_chg_err(bq2419x, "otg mode disable failed\n");
818 if (!bq2419x->battery_presense)
821 if (val & BQ2419x_FAULT_WATCHDOG_FAULT) {
822 bq_chg_err(bq2419x, "WatchDog Expired\n");
823 ret = bq2419x_reconfigure_charger_param(bq2419x, "WDT-EXP-ISR");
825 dev_err(bq2419x->dev, "BQ reconfig failed %d\n", ret);
830 switch (val & BQ2419x_FAULT_CHRG_FAULT_MASK) {
831 case BQ2419x_FAULT_CHRG_INPUT:
833 "Input Fault (VBUS OVP or VBAT<VBUS<3.8V)\n");
835 case BQ2419x_FAULT_CHRG_THERMAL:
836 bq_chg_err(bq2419x, "Thermal shutdown\n");
838 ret = bq2419x_disable_otg_mode(bq2419x);
840 bq_chg_err(bq2419x, "otg mode disable failed\n");
844 case BQ2419x_FAULT_CHRG_SAFTY:
845 bq_chg_err(bq2419x, "Safety timer expiration\n");
846 ret = bq2419x_handle_safety_timer_expire(bq2419x);
848 dev_err(bq2419x->dev,
849 "Handling of safty timer expire failed: %d\n",
858 if (val & BQ2419x_FAULT_NTC_FAULT) {
859 bq_chg_err(bq2419x, "NTC fault %d\n",
860 val & BQ2419x_FAULT_NTC_FAULT);
864 ret = regmap_read(bq2419x->regmap, BQ2419X_SYS_STAT_REG, &val);
866 dev_err(bq2419x->dev, "SYS_STAT_REG read failed %d\n", ret);
870 if ((val & BQ2419x_CHRG_STATE_MASK) == BQ2419x_CHRG_STATE_CHARGE_DONE) {
871 dev_info(bq2419x->dev, "Charging completed\n");
872 bq2419x->chg_status = BATTERY_CHARGING_DONE;
873 battery_charging_status_update(bq2419x->bc_dev,
874 bq2419x->chg_status);
875 battery_charging_restart(bq2419x->bc_dev,
876 bq2419x->chg_restart_time);
877 if (bq2419x->disable_suspend_during_charging)
878 battery_charger_release_wake_lock(bq2419x->bc_dev);
879 battery_charger_thermal_stop_monitoring(
883 if ((val & BQ2419x_VSYS_STAT_MASK) == BQ2419x_VSYS_STAT_BATT_LOW)
884 dev_info(bq2419x->dev,
885 "In VSYSMIN regulation, battery is too low\n");
887 /* Update Charging status based on STAT register */
888 if (check_chg_state &&
889 ((val & BQ2419x_CHRG_STATE_MASK) == BQ2419x_CHRG_STATE_NOTCHARGING)) {
890 bq2419x->chg_status = BATTERY_DISCHARGING;
891 battery_charging_status_update(bq2419x->bc_dev,
892 bq2419x->chg_status);
893 battery_charging_restart(bq2419x->bc_dev,
894 bq2419x->chg_restart_time);
895 if (bq2419x->disable_suspend_during_charging)
896 battery_charger_release_wake_lock(bq2419x->bc_dev);
902 static int bq2419x_init_charger_regulator(struct bq2419x_chip *bq2419x,
903 struct bq2419x_platform_data *pdata)
906 struct regulator_config rconfig = { };
908 if (!pdata->bcharger_pdata) {
909 dev_err(bq2419x->dev, "No charger platform data\n");
913 bq2419x->chg_reg_desc.name = "bq2419x-charger";
914 bq2419x->chg_reg_desc.ops = &bq2419x_tegra_regulator_ops;
915 bq2419x->chg_reg_desc.type = REGULATOR_CURRENT;
916 bq2419x->chg_reg_desc.owner = THIS_MODULE;
918 bq2419x->chg_reg_init_data.supply_regulator = NULL;
919 bq2419x->chg_reg_init_data.regulator_init = NULL;
920 bq2419x->chg_reg_init_data.num_consumer_supplies =
921 pdata->bcharger_pdata->num_consumer_supplies;
922 bq2419x->chg_reg_init_data.consumer_supplies =
923 pdata->bcharger_pdata->consumer_supplies;
924 bq2419x->chg_reg_init_data.driver_data = bq2419x;
925 bq2419x->chg_reg_init_data.constraints.name = "bq2419x-charger";
926 bq2419x->chg_reg_init_data.constraints.min_uA = 0;
927 bq2419x->chg_reg_init_data.constraints.max_uA =
928 pdata->bcharger_pdata->max_charge_current_mA * 1000;
930 bq2419x->chg_reg_init_data.constraints.ignore_current_constraint_init =
932 bq2419x->chg_reg_init_data.constraints.valid_modes_mask =
933 REGULATOR_MODE_NORMAL |
934 REGULATOR_MODE_STANDBY;
936 bq2419x->chg_reg_init_data.constraints.valid_ops_mask =
937 REGULATOR_CHANGE_MODE |
938 REGULATOR_CHANGE_STATUS |
939 REGULATOR_CHANGE_CURRENT;
941 rconfig.dev = bq2419x->dev;
942 rconfig.of_node = NULL;
943 rconfig.init_data = &bq2419x->chg_reg_init_data;
944 rconfig.driver_data = bq2419x;
945 bq2419x->chg_rdev = devm_regulator_register(bq2419x->dev,
946 &bq2419x->chg_reg_desc, &rconfig);
947 if (IS_ERR(bq2419x->chg_rdev)) {
948 ret = PTR_ERR(bq2419x->chg_rdev);
949 dev_err(bq2419x->dev,
950 "vbus-charger regulator register failed %d\n", ret);
955 static int bq2419x_init_vbus_regulator(struct bq2419x_chip *bq2419x,
956 struct bq2419x_platform_data *pdata)
959 struct regulator_config rconfig = { };
961 if (!pdata->vbus_pdata) {
962 dev_err(bq2419x->dev, "No vbus platform data\n");
966 bq2419x->gpio_otg_iusb = pdata->vbus_pdata->gpio_otg_iusb;
967 bq2419x->vbus_reg_desc.name = "bq2419x-vbus";
968 bq2419x->vbus_reg_desc.ops = &bq2419x_vbus_ops;
969 bq2419x->vbus_reg_desc.type = REGULATOR_VOLTAGE;
970 bq2419x->vbus_reg_desc.owner = THIS_MODULE;
971 bq2419x->vbus_reg_desc.enable_time = 8000;
973 bq2419x->vbus_reg_init_data.supply_regulator = NULL;
974 bq2419x->vbus_reg_init_data.regulator_init = NULL;
975 bq2419x->vbus_reg_init_data.num_consumer_supplies =
976 pdata->vbus_pdata->num_consumer_supplies;
977 bq2419x->vbus_reg_init_data.consumer_supplies =
978 pdata->vbus_pdata->consumer_supplies;
979 bq2419x->vbus_reg_init_data.driver_data = bq2419x;
981 bq2419x->vbus_reg_init_data.constraints.name = "bq2419x-vbus";
982 bq2419x->vbus_reg_init_data.constraints.min_uV = 0;
983 bq2419x->vbus_reg_init_data.constraints.max_uV = 5000000,
984 bq2419x->vbus_reg_init_data.constraints.valid_modes_mask =
985 REGULATOR_MODE_NORMAL |
986 REGULATOR_MODE_STANDBY;
987 bq2419x->vbus_reg_init_data.constraints.valid_ops_mask =
988 REGULATOR_CHANGE_MODE |
989 REGULATOR_CHANGE_STATUS |
990 REGULATOR_CHANGE_VOLTAGE;
992 if (gpio_is_valid(bq2419x->gpio_otg_iusb)) {
993 ret = gpio_request_one(bq2419x->gpio_otg_iusb,
994 GPIOF_OUT_INIT_HIGH, dev_name(bq2419x->dev));
996 dev_err(bq2419x->dev, "gpio request failed %d\n", ret);
1001 /* Register the regulators */
1002 rconfig.dev = bq2419x->dev;
1003 rconfig.of_node = NULL;
1004 rconfig.init_data = &bq2419x->vbus_reg_init_data;
1005 rconfig.driver_data = bq2419x;
1006 bq2419x->vbus_rdev = devm_regulator_register(bq2419x->dev,
1007 &bq2419x->vbus_reg_desc, &rconfig);
1008 if (IS_ERR(bq2419x->vbus_rdev)) {
1009 ret = PTR_ERR(bq2419x->vbus_rdev);
1010 dev_err(bq2419x->dev,
1011 "VBUS regulator register failed %d\n", ret);
1015 /* Disable the VBUS regulator and enable charging */
1016 ret = bq2419x_charger_enable(bq2419x);
1018 dev_err(bq2419x->dev, "Charging enable failed %d", ret);
1024 if (gpio_is_valid(bq2419x->gpio_otg_iusb))
1025 gpio_free(bq2419x->gpio_otg_iusb);
1029 static int bq2419x_show_chip_version(struct bq2419x_chip *bq2419x)
1034 ret = regmap_read(bq2419x->regmap, BQ2419X_REVISION_REG, &val);
1036 dev_err(bq2419x->dev, "REVISION_REG read failed: %d\n", ret);
1040 if ((val & BQ24190_IC_VER) == BQ24190_IC_VER)
1041 dev_info(bq2419x->dev, "chip type BQ24190 detected\n");
1042 else if ((val & BQ24192_IC_VER) == BQ24192_IC_VER)
1043 dev_info(bq2419x->dev, "chip type BQ2419X/3 detected\n");
1044 else if ((val & BQ24192i_IC_VER) == BQ24192i_IC_VER)
1045 dev_info(bq2419x->dev, "chip type BQ2419Xi detected\n");
1050 static ssize_t bq2419x_show_input_charging_current(struct device *dev,
1051 struct device_attribute *attr, char *buf)
1053 struct i2c_client *client = to_i2c_client(dev);
1054 struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1055 unsigned int reg_val;
1058 ret = regmap_read(bq2419x->regmap, BQ2419X_INPUT_SRC_REG, ®_val);
1060 dev_err(bq2419x->dev, "INPUT_SRC read failed: %d\n", ret);
1063 ret = iinlim[BQ2419x_CONFIG_MASK & reg_val];
1064 return snprintf(buf, MAX_STR_PRINT, "%d mA\n", ret);
1067 static ssize_t bq2419x_set_input_charging_current(struct device *dev,
1068 struct device_attribute *attr, const char *buf, size_t count)
1070 struct i2c_client *client = to_i2c_client(dev);
1071 struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1073 int in_current_limit;
1074 char *p = (char *)buf;
1076 in_current_limit = memparse(p, &p);
1077 ret = bq2419x_configure_charging_current(bq2419x, in_current_limit);
1079 dev_err(dev, "Current %d mA configuration faild: %d\n",
1080 in_current_limit, ret);
1086 static ssize_t bq2419x_show_charging_state(struct device *dev,
1087 struct device_attribute *attr, char *buf)
1089 struct i2c_client *client = to_i2c_client(dev);
1090 struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1091 unsigned int reg_val;
1094 ret = regmap_read(bq2419x->regmap, BQ2419X_PWR_ON_REG, ®_val);
1096 dev_err(dev, "BQ2419X_PWR_ON register read failed: %d\n", ret);
1100 if ((reg_val & BQ2419X_ENABLE_CHARGE_MASK) == BQ2419X_ENABLE_CHARGE)
1101 return snprintf(buf, MAX_STR_PRINT, "enabled\n");
1103 return snprintf(buf, MAX_STR_PRINT, "disabled\n");
1106 static ssize_t bq2419x_set_charging_state(struct device *dev,
1107 struct device_attribute *attr, const char *buf, size_t count)
1109 struct i2c_client *client = to_i2c_client(dev);
1110 struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1114 if ((*buf == 'E') || (*buf == 'e'))
1116 else if ((*buf == 'D') || (*buf == 'd'))
1122 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_PWR_ON_REG,
1123 BQ2419X_ENABLE_CHARGE_MASK, BQ2419X_ENABLE_CHARGE);
1125 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_PWR_ON_REG,
1126 BQ2419X_ENABLE_CHARGE_MASK, BQ2419X_DISABLE_CHARGE);
1128 dev_err(bq2419x->dev, "register update failed, %d\n", ret);
1134 static ssize_t bq2419x_show_input_cable_state(struct device *dev,
1135 struct device_attribute *attr, char *buf)
1137 struct i2c_client *client = to_i2c_client(dev);
1138 struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1139 unsigned int reg_val;
1142 ret = regmap_read(bq2419x->regmap, BQ2419X_INPUT_SRC_REG, ®_val);
1144 dev_err(dev, "BQ2419X_PWR_ON register read failed: %d\n", ret);
1148 if ((reg_val & BQ2419X_EN_HIZ) == BQ2419X_EN_HIZ)
1149 return snprintf(buf, MAX_STR_PRINT, "Disconnected\n");
1151 return snprintf(buf, MAX_STR_PRINT, "Connected\n");
1154 static ssize_t bq2419x_set_input_cable_state(struct device *dev,
1155 struct device_attribute *attr, const char *buf, size_t count)
1157 struct i2c_client *client = to_i2c_client(dev);
1158 struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1162 if ((*buf == 'C') || (*buf == 'c'))
1164 else if ((*buf == 'D') || (*buf == 'd'))
1170 bq2419x->emulate_input_disconnected = false;
1171 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
1174 bq2419x->emulate_input_disconnected = true;
1175 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
1176 BQ2419X_EN_HIZ, BQ2419X_EN_HIZ);
1179 dev_err(bq2419x->dev, "register update failed, %d\n", ret);
1183 dev_info(bq2419x->dev,
1184 "Emulation of charger cable disconnect disabled\n");
1186 dev_info(bq2419x->dev,
1187 "Emulated as charger cable Disconnected\n");
1191 static ssize_t bq2419x_show_output_charging_current(struct device *dev,
1192 struct device_attribute *attr,
1195 struct i2c_client *client = to_i2c_client(dev);
1196 struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1200 ret = regmap_read(bq2419x->regmap, BQ2419X_CHRG_CTRL_REG, &data);
1202 dev_err(bq2419x->dev, "CHRG_CTRL read failed %d", ret);
1206 data = data * 64 + BQ2419X_CHARGE_ICHG_OFFSET;
1207 return snprintf(buf, MAX_STR_PRINT, "%u mA\n", data);
1210 static ssize_t bq2419x_set_output_charging_current(struct device *dev,
1211 struct device_attribute *attr,
1212 const char *buf, size_t count)
1214 struct i2c_client *client = to_i2c_client(dev);
1215 struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1219 if (kstrtouint(buf, 0, &curr_val)) {
1220 dev_err(dev, "\nfile: %s, line=%d return %s()",
1221 __FILE__, __LINE__, __func__);
1225 ichg = bq2419x_val_to_reg(curr_val, BQ2419X_CHARGE_ICHG_OFFSET,
1227 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_CHRG_CTRL_REG,
1228 BQ2419X_CHRG_CTRL_ICHG_MASK, ichg << 2);
1233 static ssize_t bq2419x_show_output_charging_current_values(struct device *dev,
1234 struct device_attribute *attr, char *buf)
1238 for (i = 0; i <= 63; i++)
1239 ret += snprintf(buf + strlen(buf), MAX_STR_PRINT,
1240 "%d mA\n", i * 64 + BQ2419X_CHARGE_ICHG_OFFSET);
1245 static DEVICE_ATTR(output_charging_current, (S_IRUGO | (S_IWUSR | S_IWGRP)),
1246 bq2419x_show_output_charging_current,
1247 bq2419x_set_output_charging_current);
1249 static DEVICE_ATTR(output_current_allowed_values, S_IRUGO,
1250 bq2419x_show_output_charging_current_values, NULL);
1252 static DEVICE_ATTR(input_charging_current_mA, (S_IRUGO | (S_IWUSR | S_IWGRP)),
1253 bq2419x_show_input_charging_current,
1254 bq2419x_set_input_charging_current);
1256 static DEVICE_ATTR(charging_state, (S_IRUGO | (S_IWUSR | S_IWGRP)),
1257 bq2419x_show_charging_state, bq2419x_set_charging_state);
1259 static DEVICE_ATTR(input_cable_state, (S_IRUGO | (S_IWUSR | S_IWGRP)),
1260 bq2419x_show_input_cable_state, bq2419x_set_input_cable_state);
1262 static struct attribute *bq2419x_attributes[] = {
1263 &dev_attr_output_charging_current.attr,
1264 &dev_attr_output_current_allowed_values.attr,
1265 &dev_attr_input_charging_current_mA.attr,
1266 &dev_attr_charging_state.attr,
1267 &dev_attr_input_cable_state.attr,
1271 static const struct attribute_group bq2419x_attr_group = {
1272 .attrs = bq2419x_attributes,
1275 static int bq2419x_charger_get_status(struct battery_charger_dev *bc_dev)
1277 struct bq2419x_chip *bq2419x = battery_charger_get_drvdata(bc_dev);
1279 return bq2419x->chg_status;
1282 static int bq2419x_charger_thermal_configure(
1283 struct battery_charger_dev *bc_dev,
1284 int temp, bool enable_charger, bool enable_charg_half_current,
1285 int battery_voltage)
1287 struct bq2419x_chip *bq2419x = battery_charger_get_drvdata(bc_dev);
1288 struct bq2419x_charger_platform_data *chg_pdata;
1289 int fast_charge_current = 0;
1290 u32 charge_voltage_limit = 0;
1294 int curr_ichg, vreg;
1296 chg_pdata = bq2419x->charger_pdata;
1297 if (!bq2419x->cable_connected || !chg_pdata->n_temp_profile)
1300 if (bq2419x->last_temp == temp)
1303 bq2419x->last_temp = temp;
1305 dev_info(bq2419x->dev, "Battery temp %d\n", temp);
1307 for (i = 0; i < chg_pdata->n_temp_profile; ++i) {
1308 if (temp <= chg_pdata->temp_range[i]) {
1309 fast_charge_current = chg_pdata->chg_current_limit[i];
1310 if (chg_pdata->chg_thermal_voltage_limit)
1311 charge_voltage_limit =
1312 chg_pdata->chg_thermal_voltage_limit[i];
1316 if (!fast_charge_current || !temp) {
1317 dev_info(bq2419x->dev, "Disable charging done by HW\n");
1321 /* Fast charger become 50% when temp is at < 10 degC */
1323 fast_charge_current *= 2;
1325 curr_ichg = bq2419x->chg_current_control.val >> 2;
1326 ichg = bq2419x_val_to_reg(fast_charge_current,
1327 BQ2419X_CHARGE_ICHG_OFFSET, 64, 6, 0);
1328 if (curr_ichg == ichg)
1331 bq2419x->chg_current_control.val = ichg << 2;
1332 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_CHRG_CTRL_REG,
1333 BQ2419X_CHRG_CTRL_ICHG_MASK, ichg << 2);
1335 dev_err(bq2419x->dev, "CHRG_CTRL_REG update failed %d\n", ret);
1339 if (!charge_voltage_limit)
1342 /* Charge voltage limit */
1343 vreg = bq2419x_val_to_reg(charge_voltage_limit,
1344 BQ2419X_CHARGE_VOLTAGE_OFFSET, 16, 6, 1);
1345 bq2419x->chg_voltage_control.mask = BQ2419X_CHG_VOLT_LIMIT_MASK;
1346 bq2419x->chg_voltage_control.val = vreg << 2;
1347 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_VOLT_CTRL_REG,
1348 bq2419x->chg_voltage_control.mask,
1349 bq2419x->chg_voltage_control.val);
1351 dev_err(bq2419x->dev, "VOLT_CTRL_REG update failed %d\n", ret);
1358 static int bq2419x_charging_restart(struct battery_charger_dev *bc_dev)
1360 struct bq2419x_chip *bq2419x = battery_charger_get_drvdata(bc_dev);
1363 if (!bq2419x->cable_connected)
1366 dev_info(bq2419x->dev, "Restarting the charging\n");
1367 ret = bq2419x_set_charging_current(bq2419x->chg_rdev,
1368 bq2419x->last_charging_current,
1369 bq2419x->last_charging_current);
1371 dev_err(bq2419x->dev,
1372 "Restarting of charging failed: %d\n", ret);
1373 battery_charging_restart(bq2419x->bc_dev,
1374 bq2419x->chg_restart_time);
1379 static int bq2419x_charger_input_voltage_configure(
1380 struct battery_charger_dev *bc_dev, int battery_soc)
1382 struct bq2419x_chip *bq2419x = battery_charger_get_drvdata(bc_dev);
1383 struct bq2419x_charger_platform_data *chg_pdata;
1384 u32 input_voltage_limit = 0;
1389 chg_pdata = bq2419x->charger_pdata;
1390 if (!bq2419x->cable_connected || !chg_pdata->n_soc_profile)
1393 for (i = 0; i < chg_pdata->n_soc_profile; ++i) {
1394 if (battery_soc <= chg_pdata->soc_range[i]) {
1395 if (chg_pdata->input_voltage_soc_limit)
1396 input_voltage_limit =
1397 chg_pdata->input_voltage_soc_limit[i];
1402 if (!input_voltage_limit)
1405 /*Configure input voltage limit */
1406 vreg = bq2419x_val_to_reg(input_voltage_limit,
1407 BQ2419X_INPUT_VINDPM_OFFSET, 80, 4, 0);
1408 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
1409 BQ2419X_INPUT_VINDPM_MASK,
1412 dev_err(bq2419x->dev, "INPUT_VOLTAGE update failed %d\n", ret);
1419 static struct battery_charging_ops bq2419x_charger_bci_ops = {
1420 .get_charging_status = bq2419x_charger_get_status,
1421 .restart_charging = bq2419x_charging_restart,
1422 .thermal_configure = bq2419x_charger_thermal_configure,
1423 .input_voltage_configure = bq2419x_charger_input_voltage_configure,
1426 static struct battery_charger_info bq2419x_charger_bci = {
1428 .bc_ops = &bq2419x_charger_bci_ops,
1431 static struct bq2419x_platform_data *bq2419x_dt_parse(struct i2c_client *client)
1433 struct device_node *np = client->dev.of_node;
1434 struct bq2419x_platform_data *pdata;
1435 struct device_node *batt_reg_node;
1436 struct device_node *vbus_reg_node;
1439 pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
1441 return ERR_PTR(-ENOMEM);
1443 batt_reg_node = of_find_node_by_name(np, "charger");
1444 if (batt_reg_node) {
1445 int temp_range_len, chg_current_lim_len, chg_voltage_lim_len;
1448 int chg_restart_time;
1449 int auto_recharge_time_power_off;
1450 int temp_polling_time;
1451 int soc_range_len, inut_volt_lim_len = 0;
1452 struct regulator_init_data *batt_init_data;
1453 struct bq2419x_charger_platform_data *chg_pdata;
1454 const char *status_str;
1455 struct bq2419x_charger_platform_data *bcharger_pdata;
1458 status_str = of_get_property(batt_reg_node, "status", NULL);
1459 if (status_str && !(!strcmp(status_str, "okay"))) {
1460 dev_info(&client->dev,
1461 "charger node status is disabled\n");
1465 pdata->bcharger_pdata = devm_kzalloc(&client->dev,
1466 sizeof(*(pdata->bcharger_pdata)), GFP_KERNEL);
1467 if (!pdata->bcharger_pdata)
1468 return ERR_PTR(-ENOMEM);
1469 bcharger_pdata = pdata->bcharger_pdata;
1471 chg_pdata = pdata->bcharger_pdata;
1472 batt_init_data = of_get_regulator_init_data(&client->dev,
1474 if (!batt_init_data)
1475 return ERR_PTR(-EINVAL);
1477 bcharger_pdata->chg_status_gpio =
1478 of_get_named_gpio(batt_reg_node,
1479 "ti,charge-status-gpio", 0);
1481 ret = of_property_read_u32(batt_reg_node,
1482 "ti,input-voltage-limit-millivolt", &pval);
1484 bcharger_pdata->input_voltage_limit_mV = pval;
1486 ret = of_property_read_u32(batt_reg_node,
1487 "ti,fast-charge-current-limit-milliamp", &pval);
1489 bcharger_pdata->fast_charge_current_limit_mA =
1492 ret = of_property_read_u32(batt_reg_node,
1493 "ti,pre-charge-current-limit-milliamp", &pval);
1495 bcharger_pdata->pre_charge_current_limit_mA = pval;
1497 ret = of_property_read_u32(batt_reg_node,
1498 "ti,charge-term-current-limit-milliamp", &pval);
1500 bcharger_pdata->termination_current_limit_mA = pval;
1502 ret = of_property_read_u32(batt_reg_node,
1503 "ti,ir-comp-resister-ohm", &pval);
1505 bcharger_pdata->ir_compensation_resister_ohm = pval;
1507 ret = of_property_read_u32(batt_reg_node,
1508 "ti,ir-comp-voltage-millivolt", &pval);
1510 bcharger_pdata->ir_compensation_voltage_mV = pval;
1512 ret = of_property_read_u32(batt_reg_node,
1513 "ti,thermal-regulation-threshold-degc", &pval);
1515 bcharger_pdata->thermal_regulation_threshold_degC =
1518 ret = of_property_read_u32(batt_reg_node,
1519 "ti,charge-voltage-limit-millivolt", &pval);
1521 pdata->bcharger_pdata->charge_voltage_limit_mV = pval;
1523 pdata->bcharger_pdata->disable_suspend_during_charging =
1524 of_property_read_bool(batt_reg_node,
1525 "ti,disbale-suspend-during-charging");
1527 ret = of_property_read_u32(batt_reg_node,
1528 "ti,watchdog-timeout", &wdt_timeout);
1530 pdata->bcharger_pdata->wdt_timeout = wdt_timeout;
1532 ret = of_property_read_u32(batt_reg_node,
1533 "ti,auto-recharge-time-power-off",
1534 &auto_recharge_time_power_off);
1536 pdata->bcharger_pdata->auto_recharge_time_power_off =
1537 auto_recharge_time_power_off;
1539 pdata->bcharger_pdata->auto_recharge_time_power_off =
1542 ret = of_property_read_u32(batt_reg_node,
1543 "ti,auto-recharge-time", &chg_restart_time);
1545 pdata->bcharger_pdata->chg_restart_time =
1548 ret = of_property_read_u32(batt_reg_node,
1549 "ti,auto-recharge-time-suspend",
1552 pdata->bcharger_pdata->auto_recharge_time_supend =
1555 pdata->bcharger_pdata->auto_recharge_time_supend =
1558 ret = of_property_read_u32(batt_reg_node,
1559 "ti,temp-polling-time-sec", &temp_polling_time);
1561 bcharger_pdata->temp_polling_time_sec =
1564 count = of_property_count_u32(batt_reg_node, "ti,soc-range");
1565 soc_range_len = (count > 0) ? count : 0;
1567 if (soc_range_len) {
1568 chg_pdata->n_soc_profile = soc_range_len;
1569 chg_pdata->soc_range = devm_kzalloc(&client->dev,
1570 sizeof(u32) * soc_range_len, GFP_KERNEL);
1571 if (!chg_pdata->soc_range)
1572 return ERR_PTR(-ENOMEM);
1574 ret = of_property_read_u32_array(batt_reg_node,
1576 chg_pdata->soc_range, soc_range_len);
1578 return ERR_PTR(ret);
1580 count = of_property_count_u32(batt_reg_node,
1581 "ti,input-voltage-soc-limit");
1582 inut_volt_lim_len = (count > 0) ? count : 0;
1585 if (inut_volt_lim_len) {
1586 chg_pdata->input_voltage_soc_limit =
1587 devm_kzalloc(&client->dev,
1588 sizeof(u32) * inut_volt_lim_len,
1590 if (!chg_pdata->input_voltage_soc_limit)
1591 return ERR_PTR(-ENOMEM);
1593 ret = of_property_read_u32_array(batt_reg_node,
1594 "ti,input-voltage-soc-limit",
1595 chg_pdata->input_voltage_soc_limit,
1598 return ERR_PTR(ret);
1601 chg_pdata->tz_name = of_get_property(batt_reg_node,
1602 "ti,thermal-zone", NULL);
1604 count = of_property_count_u32(batt_reg_node, "ti,temp-range");
1605 temp_range_len = (count > 0) ? count : 0;
1607 count = of_property_count_u32(batt_reg_node,
1608 "ti,charge-current-limit");
1610 count = of_property_count_u32(batt_reg_node,
1611 "ti,charge-thermal-current-limit");
1612 chg_current_lim_len = (count > 0) ? count : 0;
1614 count = of_property_count_u32(batt_reg_node,
1615 "ti,charge-thermal-voltage-limit");
1616 chg_voltage_lim_len = (count > 0) ? count : 0;
1618 if (!temp_range_len)
1619 goto skip_therm_profile;
1621 if (temp_range_len != chg_current_lim_len) {
1622 dev_info(&client->dev,
1623 "current thermal profile is not correct\n");
1624 goto skip_therm_profile;
1627 if (chg_voltage_lim_len && (temp_range_len != chg_voltage_lim_len)) {
1628 dev_info(&client->dev,
1629 "voltage thermal profile is not correct\n");
1630 goto skip_therm_profile;
1633 chg_pdata->temp_range = devm_kzalloc(&client->dev,
1634 sizeof(u32) * temp_range_len, GFP_KERNEL);
1635 if (!chg_pdata->temp_range)
1636 return ERR_PTR(-ENOMEM);
1638 ret = of_property_read_u32_array(batt_reg_node, "ti,temp-range",
1639 chg_pdata->temp_range, temp_range_len);
1641 return ERR_PTR(ret);
1643 chg_pdata->chg_current_limit = devm_kzalloc(&client->dev,
1644 sizeof(u32) * temp_range_len, GFP_KERNEL);
1645 if (!chg_pdata->chg_current_limit)
1646 return ERR_PTR(-ENOMEM);
1648 ret = of_property_read_u32_array(batt_reg_node,
1649 "ti,charge-current-limit",
1650 chg_pdata->chg_current_limit,
1653 ret = of_property_read_u32_array(batt_reg_node,
1654 "ti,charge-thermal-current-limit",
1655 chg_pdata->chg_current_limit,
1658 return ERR_PTR(ret);
1660 if (!chg_voltage_lim_len)
1661 goto skip_thermal_volt_profle;
1663 chg_pdata->chg_thermal_voltage_limit =
1664 devm_kzalloc(&client->dev,
1665 sizeof(u32) * temp_range_len,
1667 if (!chg_pdata->chg_thermal_voltage_limit)
1668 return ERR_PTR(-ENOMEM);
1670 ret = of_property_read_u32_array(batt_reg_node,
1671 "ti,charge-thermal-voltage-limit",
1672 chg_pdata->chg_thermal_voltage_limit,
1675 return ERR_PTR(ret);
1677 skip_thermal_volt_profle:
1678 chg_pdata->n_temp_profile = temp_range_len;
1681 pdata->bcharger_pdata->consumer_supplies =
1682 batt_init_data->consumer_supplies;
1683 pdata->bcharger_pdata->num_consumer_supplies =
1684 batt_init_data->num_consumer_supplies;
1685 pdata->bcharger_pdata->max_charge_current_mA =
1686 batt_init_data->constraints.max_uA / 1000;
1690 vbus_reg_node = of_find_node_by_name(np, "vbus");
1691 if (vbus_reg_node) {
1692 struct regulator_init_data *vbus_init_data;
1694 pdata->vbus_pdata = devm_kzalloc(&client->dev,
1695 sizeof(*(pdata->vbus_pdata)), GFP_KERNEL);
1696 if (!pdata->vbus_pdata)
1697 return ERR_PTR(-ENOMEM);
1699 vbus_init_data = of_get_regulator_init_data(
1700 &client->dev, vbus_reg_node);
1701 if (!vbus_init_data)
1702 return ERR_PTR(-EINVAL);
1704 pdata->vbus_pdata->consumer_supplies =
1705 vbus_init_data->consumer_supplies;
1706 pdata->vbus_pdata->num_consumer_supplies =
1707 vbus_init_data->num_consumer_supplies;
1708 pdata->vbus_pdata->gpio_otg_iusb =
1709 of_get_named_gpio(vbus_reg_node,
1710 "ti,otg-iusb-gpio", 0);
1716 static int bq2419x_probe(struct i2c_client *client,
1717 const struct i2c_device_id *id)
1719 struct bq2419x_chip *bq2419x;
1720 struct bq2419x_platform_data *pdata = NULL;
1723 if (client->dev.platform_data)
1724 pdata = client->dev.platform_data;
1726 if (!pdata && client->dev.of_node) {
1727 pdata = bq2419x_dt_parse(client);
1728 if (IS_ERR(pdata)) {
1729 ret = PTR_ERR(pdata);
1730 dev_err(&client->dev, "Parsing of node failed, %d\n",
1737 dev_err(&client->dev, "No Platform data");
1741 bq2419x = devm_kzalloc(&client->dev, sizeof(*bq2419x), GFP_KERNEL);
1743 dev_err(&client->dev, "Memory allocation failed\n");
1746 bq2419x->charger_pdata = pdata->bcharger_pdata;
1747 bq2419x->vbus_pdata = pdata->vbus_pdata;
1749 bq2419x->regmap = devm_regmap_init_i2c(client, &bq2419x_regmap_config);
1750 if (IS_ERR(bq2419x->regmap)) {
1751 ret = PTR_ERR(bq2419x->regmap);
1752 dev_err(&client->dev, "regmap init failed with err %d\n", ret);
1756 bq2419x->dev = &client->dev;
1757 i2c_set_clientdata(client, bq2419x);
1758 bq2419x->irq = client->irq;
1759 mutex_init(&bq2419x->otg_mutex);
1760 bq2419x->is_otg_connected = 0;
1762 ret = bq2419x_show_chip_version(bq2419x);
1764 dev_err(&client->dev, "version read failed %d\n", ret);
1768 ret = sysfs_create_group(&client->dev.kobj, &bq2419x_attr_group);
1770 dev_err(&client->dev, "sysfs create failed %d\n", ret);
1774 mutex_init(&bq2419x->mutex);
1776 if (!pdata->bcharger_pdata) {
1777 dev_info(&client->dev, "No battery charger supported\n");
1778 ret = bq2419x_watchdog_init(bq2419x, 0, "PROBE");
1780 dev_err(bq2419x->dev, "WDT disable failed: %d\n", ret);
1784 ret = bq2419x_fault_clear_sts(bq2419x, NULL);
1786 dev_err(bq2419x->dev, "fault clear status failed %d\n", ret);
1789 goto skip_bcharger_init;
1792 bq2419x->auto_recharge_time_power_off =
1793 pdata->bcharger_pdata->auto_recharge_time_power_off;
1794 bq2419x->wdt_time_sec = pdata->bcharger_pdata->wdt_timeout;
1795 bq2419x->chg_restart_time = pdata->bcharger_pdata->chg_restart_time;
1796 bq2419x->battery_presense = true;
1797 bq2419x->last_temp = -1000;
1798 bq2419x->disable_suspend_during_charging =
1799 pdata->bcharger_pdata->disable_suspend_during_charging;
1800 bq2419x->auto_recharge_time_supend =
1801 pdata->bcharger_pdata->auto_recharge_time_supend;
1802 bq2419x->chg_status_gpio = pdata->bcharger_pdata->chg_status_gpio;
1804 bq2419x_process_charger_plat_data(bq2419x, pdata->bcharger_pdata);
1806 ret = bq2419x_charger_init(bq2419x);
1808 dev_err(bq2419x->dev, "Charger init failed: %d\n", ret);
1812 ret = bq2419x_init_charger_regulator(bq2419x, pdata);
1814 dev_err(&client->dev,
1815 "Charger regualtor init failed %d\n", ret);
1819 bq2419x_charger_bci.polling_time_sec =
1820 pdata->bcharger_pdata->temp_polling_time_sec;
1821 bq2419x_charger_bci.tz_name = pdata->bcharger_pdata->tz_name;
1822 bq2419x->bc_dev = battery_charger_register(bq2419x->dev,
1823 &bq2419x_charger_bci, bq2419x);
1824 if (IS_ERR(bq2419x->bc_dev)) {
1825 ret = PTR_ERR(bq2419x->bc_dev);
1826 dev_err(bq2419x->dev, "battery charger register failed: %d\n",
1831 INIT_DELAYED_WORK(&bq2419x->wdt_restart_wq, bq2419x_wdt_restart_wq);
1832 ret = bq2419x_watchdog_init(bq2419x, bq2419x->wdt_time_sec, "PROBE");
1834 dev_err(bq2419x->dev, "BQWDT init failed %d\n", ret);
1838 INIT_DELAYED_WORK(&bq2419x->otg_reset_work,
1839 bq2419x_otg_reset_work_handler);
1840 ret = bq2419x_fault_clear_sts(bq2419x, NULL);
1842 dev_err(bq2419x->dev, "fault clear status failed %d\n", ret);
1846 ret = devm_request_threaded_irq(bq2419x->dev, bq2419x->irq, NULL,
1847 bq2419x_irq, IRQF_ONESHOT | IRQF_TRIGGER_FALLING,
1848 dev_name(bq2419x->dev), bq2419x);
1850 dev_warn(bq2419x->dev, "request IRQ %d fail, err = %d\n",
1852 dev_info(bq2419x->dev,
1853 "Supporting bq driver without interrupt\n");
1857 if (gpio_is_valid(bq2419x->chg_status_gpio)) {
1858 ret = devm_gpio_request(bq2419x->dev, bq2419x->chg_status_gpio,
1861 dev_err(bq2419x->dev, "error: can't request GPIO%d\n",
1862 bq2419x->chg_status_gpio);
1864 ret = gpio_direction_output(bq2419x->chg_status_gpio, 0);
1866 dev_err(bq2419x->dev,
1867 "can't setup GPIO%d as Output\n",
1868 bq2419x->chg_status_gpio);
1874 ret = bq2419x_init_vbus_regulator(bq2419x, pdata);
1876 dev_err(&client->dev, "VBUS regulator init failed %d\n", ret);
1880 /* enable charging */
1881 ret = bq2419x_charger_enable(bq2419x);
1887 if (pdata->bcharger_pdata) {
1888 cancel_delayed_work(&bq2419x->wdt_restart_wq);
1889 battery_charger_unregister(bq2419x->bc_dev);
1892 mutex_destroy(&bq2419x->mutex);
1893 mutex_destroy(&bq2419x->otg_mutex);
1897 static int bq2419x_remove(struct i2c_client *client)
1899 struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1901 if (bq2419x->battery_presense) {
1902 battery_charger_unregister(bq2419x->bc_dev);
1903 cancel_delayed_work(&bq2419x->wdt_restart_wq);
1905 mutex_destroy(&bq2419x->mutex);
1906 mutex_destroy(&bq2419x->otg_mutex);
1907 cancel_delayed_work_sync(&bq2419x->otg_reset_work);
1911 static void bq2419x_shutdown(struct i2c_client *client)
1913 struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1914 struct device *dev = &client->dev;
1916 int next_poweron_time = 0;
1918 if (!bq2419x->battery_presense)
1921 if (!bq2419x->cable_connected)
1924 ret = bq2419x_reset_wdt(bq2419x, "SHUTDOWN");
1926 dev_err(bq2419x->dev, "Reset WDT failed: %d\n", ret);
1928 if (bq2419x->chg_status == BATTERY_CHARGING_DONE) {
1929 dev_info(bq2419x->dev, "Battery charging done\n");
1933 if (bq2419x->in_current_limit <= 500) {
1934 dev_info(bq2419x->dev, "Battery charging with 500mA\n");
1935 next_poweron_time = bq2419x->auto_recharge_time_power_off;
1937 dev_info(bq2419x->dev, "Battery charging with high current\n");
1938 next_poweron_time = bq2419x->wdt_refresh_timeout;
1941 ret = battery_charging_system_reset_after(bq2419x->bc_dev,
1944 dev_err(dev, "System poweron after %d config failed %d\n",
1945 next_poweron_time, ret);
1947 if (next_poweron_time)
1948 dev_info(dev, "System-charger will power-ON after %d sec\n",
1951 dev_info(bq2419x->dev, "System-charger will not power-ON\n");
1953 battery_charging_system_power_on_usb_event(bq2419x->bc_dev);
1954 cancel_delayed_work_sync(&bq2419x->otg_reset_work);
1957 #ifdef CONFIG_PM_SLEEP
1958 static int bq2419x_suspend(struct device *dev)
1960 struct bq2419x_chip *bq2419x = dev_get_drvdata(dev);
1961 int next_wakeup = 0;
1964 if (!bq2419x->battery_presense)
1967 battery_charging_restart_cancel(bq2419x->bc_dev);
1969 if (!bq2419x->cable_connected)
1972 ret = bq2419x_reset_wdt(bq2419x, "Suspend");
1974 dev_err(bq2419x->dev, "Reset WDT failed: %d\n", ret);
1976 if (bq2419x->chg_status == BATTERY_CHARGING_DONE) {
1977 dev_info(bq2419x->dev, "Battery charging done\n");
1981 if (bq2419x->in_current_limit <= 500) {
1982 dev_info(bq2419x->dev, "Battery charging with 500mA\n");
1983 next_wakeup = bq2419x->auto_recharge_time_supend;
1985 dev_info(bq2419x->dev, "Battery charging with high current\n");
1986 next_wakeup = bq2419x->wdt_refresh_timeout;
1989 battery_charging_wakeup(bq2419x->bc_dev, next_wakeup);
1992 dev_info(dev, "System-charger will resume after %d sec\n",
1995 dev_info(dev, "System-charger will not have resume time\n");
1997 if (next_wakeup == bq2419x->wdt_refresh_timeout)
2000 ret = bq2419x_set_charging_current_suspend(bq2419x, 500);
2002 dev_err(bq2419x->dev, "Config of charging failed: %d\n", ret);
2006 static int bq2419x_resume(struct device *dev)
2009 struct bq2419x_chip *bq2419x = dev_get_drvdata(dev);
2012 if (!bq2419x->battery_presense)
2015 ret = bq2419x_fault_clear_sts(bq2419x, &val);
2017 dev_err(bq2419x->dev, "fault clear status failed %d\n", ret);
2021 if (val & BQ2419x_FAULT_WATCHDOG_FAULT) {
2022 bq_chg_err(bq2419x, "Watchdog Timer Expired\n");
2024 ret = bq2419x_reconfigure_charger_param(bq2419x,
2027 dev_err(bq2419x->dev, "BQ reconfig failed %d\n", ret);
2031 ret = bq2419x_reset_wdt(bq2419x, "Resume");
2033 dev_err(bq2419x->dev, "Reset WDT failed: %d\n", ret);
2036 if (val & BQ2419x_FAULT_CHRG_SAFTY) {
2037 bq_chg_err(bq2419x, "Safety timer Expired\n");
2038 ret = bq2419x_handle_safety_timer_expire(bq2419x);
2040 dev_err(bq2419x->dev,
2041 "Handling of safty timer expire failed: %d\n",
2050 static const struct dev_pm_ops bq2419x_pm_ops = {
2051 SET_SYSTEM_SLEEP_PM_OPS(bq2419x_suspend, bq2419x_resume)
2054 static const struct i2c_device_id bq2419x_id[] = {
2055 {.name = "bq2419x",},
2058 MODULE_DEVICE_TABLE(i2c, bq2419x_id);
2060 static struct i2c_driver bq2419x_i2c_driver = {
2063 .owner = THIS_MODULE,
2064 .pm = &bq2419x_pm_ops,
2066 .probe = bq2419x_probe,
2067 .remove = bq2419x_remove,
2068 .shutdown = bq2419x_shutdown,
2069 .id_table = bq2419x_id,
2072 static int __init bq2419x_module_init(void)
2074 return i2c_add_driver(&bq2419x_i2c_driver);
2076 subsys_initcall(bq2419x_module_init);
2078 static void __exit bq2419x_cleanup(void)
2080 i2c_del_driver(&bq2419x_i2c_driver);
2082 module_exit(bq2419x_cleanup);
2084 MODULE_DESCRIPTION("BQ24190/BQ24192/BQ24192i/BQ24193 battery charger driver");
2085 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
2086 MODULE_AUTHOR("Syed Rafiuddin <srafiuddin@nvidia.com");
2087 MODULE_LICENSE("GPL v2");