drivers/power/bq2419x-charger.c

   1 /*
   2  * bq2419x-charger.c -- BQ24190/BQ24192/BQ24192i/BQ24193 Charger driver
   3  *
   4  * Copyright (c) 2013-2014, NVIDIA CORPORATION.  All rights reserved.
   5  *
   6  * Author: Laxman Dewangan <ldewangan@nvidia.com>
   7  * Author: Syed Rafiuddin <srafiuddin@nvidia.com>
   8  *
   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.
  12  *
  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.
  17  *
  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
  21  * 02111-1307, USA
  22  */
  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>
  47
  48 #define MAX_STR_PRINT 50
  49
  50 #define bq_chg_err(bq, fmt, ...)                        \
  51                 dev_err(bq->dev, "Charging Fault: " fmt, ##__VA_ARGS__)
  52
  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)
  60
  61 /* input current limit */
  62 static const unsigned int iinlim[] = {
  63         100, 150, 500, 900, 1200, 1500, 2000, 3000,
  64 };
  65
  66 static const struct regmap_config bq2419x_regmap_config = {
  67         .reg_bits               = 8,
  68         .val_bits               = 8,
  69         .max_register           = BQ2419X_MAX_REGS,
  70 };
  71
  72 struct bq2419x_reg_info {
  73         u8 mask;
  74         u8 val;
  75 };
  76
  77 struct bq2419x_chip {
  78         struct device                   *dev;
  79         struct regmap                   *regmap;
  80         int                             irq;
  81         int                             gpio_otg_iusb;
  82         int                             wdt_refresh_timeout;
  83         int                             wdt_time_sec;
  84         int                             auto_recharge_time_power_off;
  85         bool                            emulate_input_disconnected;
  86
  87         struct mutex                    mutex;
  88         struct mutex                    otg_mutex;
  89         int                             in_current_limit;
  90
  91         struct regulator_dev            *chg_rdev;
  92         struct regulator_desc           chg_reg_desc;
  93         struct regulator_init_data      chg_reg_init_data;
  94
  95         struct regulator_dev            *vbus_rdev;
  96         struct regulator_desc           vbus_reg_desc;
  97         struct regulator_init_data      vbus_reg_init_data;
  98
  99         struct battery_charger_dev      *bc_dev;
 100         int                             chg_status;
 101
 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;
 110         int                             last_temp;
 111         u32                             auto_recharge_time_supend;
 112         int                             chg_status_gpio;
 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;
 120         int                             last_input_voltage;
 121 };
 122
 123 static int current_to_reg(const unsigned int *tbl,
 124                         size_t size, unsigned int val)
 125 {
 126         size_t i;
 127
 128         for (i = 0; i < size; i++)
 129                 if (val < tbl[i])
 130                         break;
 131         return i > 0 ? i - 1 : -EINVAL;
 132 }
 133
 134 static int bq2419x_charger_enable(struct bq2419x_chip *bq2419x)
 135 {
 136         int ret;
 137
 138         if (bq2419x->battery_presense) {
 139                 dev_info(bq2419x->dev, "Charging enabled\n");
 140                 /* set default Charge regulation voltage */
 141                 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_VOLT_CTRL_REG,
 142                         bq2419x->chg_voltage_control.mask,
 143                         bq2419x->chg_voltage_control.val);
 144                 if (ret < 0) {
 145                         dev_err(bq2419x->dev,
 146                                 "VOLT_CTRL_REG update failed %d\n", ret);
 147                         return ret;
 148                 }
 149                 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_PWR_ON_REG,
 150                                 BQ2419X_ENABLE_CHARGE_MASK,
 151                                 BQ2419X_ENABLE_CHARGE);
 152         } else {
 153                 dev_info(bq2419x->dev, "Charging disabled\n");
 154                 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_PWR_ON_REG,
 155                                  BQ2419X_ENABLE_CHARGE_MASK,
 156                                  BQ2419X_DISABLE_CHARGE);
 157         }
 158         if (ret < 0)
 159                 dev_err(bq2419x->dev, "register update failed, err %d\n", ret);
 160         return ret;
 161 }
 162
 163 static int bq2419x_vbus_enable(struct regulator_dev *rdev)
 164 {
 165         struct bq2419x_chip *bq2419x = rdev_get_drvdata(rdev);
 166         int ret;
 167
 168         dev_info(bq2419x->dev, "VBUS enabled, charging disabled\n");
 169
 170         mutex_lock(&bq2419x->otg_mutex);
 171         bq2419x->is_otg_connected = true;
 172         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_PWR_ON_REG,
 173                         BQ2419X_ENABLE_CHARGE_MASK, BQ2419X_ENABLE_VBUS);
 174         if (ret < 0)
 175                 dev_err(bq2419x->dev, "PWR_ON_REG update failed %d", ret);
 176         mutex_unlock(&bq2419x->otg_mutex);
 177
 178         return ret;
 179 }
 180
 181 static int bq2419x_vbus_disable(struct regulator_dev *rdev)
 182 {
 183         struct bq2419x_chip *bq2419x = rdev_get_drvdata(rdev);
 184         int ret;
 185
 186         dev_info(bq2419x->dev, "VBUS disabled, charging enabled\n");
 187
 188         mutex_lock(&bq2419x->otg_mutex);
 189         bq2419x->is_otg_connected = false;
 190         ret = bq2419x_charger_enable(bq2419x);
 191         if (ret < 0)
 192                 dev_err(bq2419x->dev, "Charger enable failed %d", ret);
 193         mutex_unlock(&bq2419x->otg_mutex);
 194
 195         return ret;
 196 }
 197
 198 static int bq2419x_vbus_is_enabled(struct regulator_dev *rdev)
 199 {
 200         struct bq2419x_chip *bq2419x = rdev_get_drvdata(rdev);
 201         int ret;
 202         unsigned int data;
 203
 204         ret = regmap_read(bq2419x->regmap, BQ2419X_PWR_ON_REG, &data);
 205         if (ret < 0) {
 206                 dev_err(bq2419x->dev, "PWR_ON_REG read failed %d", ret);
 207                 return ret;
 208         }
 209         return (data & BQ2419X_ENABLE_CHARGE_MASK) == BQ2419X_ENABLE_VBUS;
 210 }
 211
 212 static struct regulator_ops bq2419x_vbus_ops = {
 213         .enable         = bq2419x_vbus_enable,
 214         .disable        = bq2419x_vbus_disable,
 215         .is_enabled     = bq2419x_vbus_is_enabled,
 216 };
 217
 218 static int bq2419x_val_to_reg(int val, int offset, int div, int nbits,
 219         bool roundup)
 220 {
 221         int max_val = offset + (BIT(nbits) - 1) * div;
 222
 223         if (val <= offset)
 224                 return 0;
 225
 226         if (val >= max_val)
 227                 return BIT(nbits) - 1;
 228
 229         if (roundup)
 230                 return DIV_ROUND_UP(val - offset, div);
 231         else
 232                 return (val - offset) / div;
 233 }
 234
 235 static int bq2419x_process_charger_plat_data(struct bq2419x_chip *bq2419x,
 236                 struct bq2419x_charger_platform_data *chg_pdata)
 237 {
 238         int voltage_input;
 239         int fast_charge_current;
 240         int pre_charge_current;
 241         int termination_current;
 242         int ir_compensation_resistor;
 243         int ir_compensation_voltage;
 244         int thermal_regulation_threshold;
 245         int charge_voltage_limit;
 246         int vindpm, ichg, iprechg, iterm, bat_comp, vclamp, treg, vreg;
 247
 248         if (chg_pdata) {
 249                 voltage_input = chg_pdata->input_voltage_limit_mV ?: 4200;
 250                 fast_charge_current =
 251                         chg_pdata->fast_charge_current_limit_mA ?: 4544;
 252                 pre_charge_current =
 253                         chg_pdata->pre_charge_current_limit_mA ?: 256;
 254                 termination_current =
 255                         chg_pdata->termination_current_limit_mA ?: 128;
 256                 ir_compensation_resistor =
 257                         chg_pdata->ir_compensation_resister_ohm ?: 70;
 258                 ir_compensation_voltage =
 259                         chg_pdata->ir_compensation_voltage_mV ?: 112;
 260                 thermal_regulation_threshold =
 261                         chg_pdata->thermal_regulation_threshold_degC ?: 100;
 262                 charge_voltage_limit =
 263                         chg_pdata->charge_voltage_limit_mV ?: 4208;
 264         } else {
 265                 voltage_input = 4200;
 266                 fast_charge_current = 4544;
 267                 pre_charge_current = 256;
 268                 termination_current = 128;
 269                 ir_compensation_resistor = 70;
 270                 ir_compensation_voltage = 112;
 271                 thermal_regulation_threshold = 100;
 272                 charge_voltage_limit = 4208;
 273         }
 274
 275         vindpm = bq2419x_val_to_reg(voltage_input,
 276                         BQ2419X_INPUT_VINDPM_OFFSET, 80, 4, 0);
 277         bq2419x->input_src.mask = BQ2419X_INPUT_VINDPM_MASK;
 278         bq2419x->input_src.val = vindpm << 3;
 279         bq2419x->input_src.mask |= BQ2419X_INPUT_IINLIM_MASK;
 280         bq2419x->input_src.val |= 0x2;
 281
 282         ichg = bq2419x_val_to_reg(fast_charge_current,
 283                         BQ2419X_CHARGE_ICHG_OFFSET, 64, 6, 0);
 284         bq2419x->chg_current_control.mask = BQ2419X_CHRG_CTRL_ICHG_MASK;
 285         bq2419x->chg_current_control.val = ichg << 2;
 286
 287         iprechg = bq2419x_val_to_reg(pre_charge_current,
 288                         BQ2419X_PRE_CHG_IPRECHG_OFFSET, 128, 4, 0);
 289         bq2419x->prechg_term_control.mask = BQ2419X_CHRG_TERM_PRECHG_MASK;
 290         bq2419x->prechg_term_control.val = iprechg << 4;
 291         iterm =  bq2419x_val_to_reg(termination_current,
 292                         BQ2419X_PRE_CHG_TERM_OFFSET, 128, 4, 0);
 293         bq2419x->prechg_term_control.mask |= BQ2419X_CHRG_TERM_TERM_MASK;
 294         bq2419x->prechg_term_control.val |= iterm;
 295
 296         bat_comp = ir_compensation_resistor / 10;
 297         bq2419x->ir_comp_therm.mask = BQ2419X_THERM_BAT_COMP_MASK;
 298         bq2419x->ir_comp_therm.val = bat_comp << 5;
 299         vclamp = ir_compensation_voltage / 16;
 300         bq2419x->ir_comp_therm.mask |= BQ2419X_THERM_VCLAMP_MASK;
 301         bq2419x->ir_comp_therm.val |= vclamp << 2;
 302         bq2419x->ir_comp_therm.mask |= BQ2419X_THERM_TREG_MASK;
 303         if (thermal_regulation_threshold <= 60)
 304                 treg = 0;
 305         else if (thermal_regulation_threshold <= 80)
 306                 treg = 1;
 307         else if (thermal_regulation_threshold <= 100)
 308                 treg = 2;
 309         else
 310                 treg = 3;
 311         bq2419x->ir_comp_therm.val |= treg;
 312
 313         vreg = bq2419x_val_to_reg(charge_voltage_limit,
 314                         BQ2419X_CHARGE_VOLTAGE_OFFSET, 16, 6, 1);
 315         bq2419x->chg_voltage_control.mask = BQ2419X_CHG_VOLT_LIMIT_MASK;
 316         bq2419x->chg_voltage_control.val = vreg << 2;
 317         return 0;
 318 }
 319
 320 static int bq2419x_charger_init(struct bq2419x_chip *bq2419x)
 321 {
 322         int ret;
 323
 324         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_CHRG_CTRL_REG,
 325                         bq2419x->chg_current_control.mask,
 326                         bq2419x->chg_current_control.val);
 327         if (ret < 0) {
 328                 dev_err(bq2419x->dev, "CHRG_CTRL_REG write failed %d\n", ret);
 329                 return ret;
 330         }
 331
 332         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_CHRG_TERM_REG,
 333                         bq2419x->prechg_term_control.mask,
 334                         bq2419x->prechg_term_control.val);
 335         if (ret < 0) {
 336                 dev_err(bq2419x->dev, "CHRG_TERM_REG write failed %d\n", ret);
 337                 return ret;
 338         }
 339
 340         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
 341                         bq2419x->input_src.mask, bq2419x->input_src.val);
 342         if (ret < 0)
 343                 dev_err(bq2419x->dev, "INPUT_SRC_REG write failed %d\n", ret);
 344         bq2419x->last_input_voltage = (bq2419x->input_src.val >> 3) & 0xF;
 345
 346         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_THERM_REG,
 347                     bq2419x->ir_comp_therm.mask, bq2419x->ir_comp_therm.val);
 348         if (ret < 0)
 349                 dev_err(bq2419x->dev, "THERM_REG write failed: %d\n", ret);
 350
 351         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_VOLT_CTRL_REG,
 352                         bq2419x->chg_voltage_control.mask,
 353                         bq2419x->chg_voltage_control.val);
 354         if (ret < 0)
 355                 dev_err(bq2419x->dev, "VOLT_CTRL update failed: %d\n", ret);
 356
 357         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_TIME_CTRL_REG,
 358                         BQ2419X_TIME_JEITA_ISET, 0);
 359         if (ret < 0)
 360                 dev_err(bq2419x->dev, "TIME_CTRL update failed: %d\n", ret);
 361
 362         return ret;
 363 }
 364
 365 static void bq2419x_otg_reset_work_handler(struct work_struct *work)
 366 {
 367         int ret;
 368         struct bq2419x_chip *bq2419x = container_of(to_delayed_work(work),
 369                         struct bq2419x_chip, otg_reset_work);
 370
 371         if (!mutex_is_locked(&bq2419x->otg_mutex)) {
 372                 mutex_lock(&bq2419x->otg_mutex);
 373                 if (bq2419x->is_otg_connected) {
 374                         ret = regmap_update_bits(bq2419x->regmap,
 375                                         BQ2419X_PWR_ON_REG,
 376                                         BQ2419X_ENABLE_CHARGE_MASK,
 377                                         BQ2419X_ENABLE_VBUS);
 378                         if (ret < 0)
 379                                 dev_err(bq2419x->dev,
 380                                 "PWR_ON_REG update failed %d", ret);
 381                 }
 382                 mutex_unlock(&bq2419x->otg_mutex);
 383         }
 384 }
 385
 386 static int bq2419x_disable_otg_mode(struct bq2419x_chip *bq2419x)
 387 {
 388         int ret = 0;
 389
 390         mutex_lock(&bq2419x->otg_mutex);
 391         if (bq2419x->is_otg_connected) {
 392                 ret = bq2419x_charger_enable(bq2419x);
 393                 if (ret < 0) {
 394                         dev_err(bq2419x->dev,
 395                                 "Charger enable failed %d", ret);
 396                         mutex_unlock(&bq2419x->otg_mutex);
 397                         return ret;
 398                 }
 399                 schedule_delayed_work(&bq2419x->otg_reset_work,
 400                                         BQ2419x_OTG_ENABLE_TIME);
 401         }
 402         mutex_unlock(&bq2419x->otg_mutex);
 403
 404         return ret;
 405 }
 406
 407 static int bq2419x_charger_input_voltage_configure(
 408                 struct battery_charger_dev *bc_dev, int battery_soc)
 409 {
 410         struct bq2419x_chip *bq2419x = battery_charger_get_drvdata(bc_dev);
 411         struct bq2419x_charger_platform_data *chg_pdata;
 412         u32 input_voltage_limit = 0;
 413         int ret;
 414         int i;
 415         int vreg;
 416
 417         chg_pdata = bq2419x->charger_pdata;
 418         if (!bq2419x->cable_connected || !chg_pdata->n_soc_profile)
 419                 return 0;
 420
 421         for (i = 0; i < chg_pdata->n_soc_profile; ++i) {
 422                 if (battery_soc < chg_pdata->soc_range[i]) {
 423                         if (chg_pdata->input_voltage_soc_limit)
 424                                 input_voltage_limit =
 425                                         chg_pdata->input_voltage_soc_limit[i];
 426                         break;
 427                 }
 428         }
 429
 430         if (!input_voltage_limit)
 431                 return 0;
 432
 433         /*Configure input voltage limit */
 434         vreg = bq2419x_val_to_reg(input_voltage_limit,
 435                         BQ2419X_INPUT_VINDPM_OFFSET, 80, 4, 0);
 436         if (bq2419x->last_input_voltage == vreg)
 437                 return 0;
 438
 439         dev_info(bq2419x->dev, "Changing VINDPM to soc:voltage:vreg %d:%d:%d\n",
 440                         battery_soc, input_voltage_limit, vreg);
 441
 442         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
 443                                 BQ2419X_INPUT_VINDPM_MASK,
 444                                 (vreg << 3));
 445         if (ret < 0) {
 446                 dev_err(bq2419x->dev, "INPUT_VOLTAGE update failed %d\n", ret);
 447                 return ret;
 448         }
 449         bq2419x->last_input_voltage = vreg;
 450
 451         return 0;
 452 }
 453
 454 static int bq2419x_configure_charging_current(struct bq2419x_chip *bq2419x,
 455         int in_current_limit)
 456 {
 457         int val = 0;
 458         int ret = 0;
 459         int floor = 0;
 460         int battery_soc = 0;
 461
 462         /* Clear EN_HIZ */
 463         if (!bq2419x->emulate_input_disconnected) {
 464                 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
 465                         BQ2419X_EN_HIZ, 0);
 466                 if (ret < 0) {
 467                         dev_err(bq2419x->dev,
 468                                 "INPUT_SRC_REG update failed %d\n", ret);
 469                         return ret;
 470                 }
 471         }
 472
 473         /* Configure input voltage limit*/
 474         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
 475                         bq2419x->input_src.mask, bq2419x->input_src.val);
 476         if (ret < 0) {
 477                 dev_err(bq2419x->dev, "INPUT_SRC_REG update failed %d\n", ret);
 478                 return ret;
 479         }
 480         bq2419x->last_input_voltage =  (bq2419x->input_src.val >> 3) & 0xF;
 481
 482         /* Configure input current limit in steps */
 483         val = current_to_reg(iinlim, ARRAY_SIZE(iinlim), in_current_limit);
 484         floor = current_to_reg(iinlim, ARRAY_SIZE(iinlim), 500);
 485         if (val < 0 || floor < 0)
 486                 return 0;
 487
 488         for (; floor <= val; floor++) {
 489                 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
 490                                 BQ2419x_CONFIG_MASK, floor);
 491                 if (ret < 0)
 492                         dev_err(bq2419x->dev,
 493                                 "INPUT_SRC_REG update failed: %d\n", ret);
 494                 udelay(BQ2419x_CHARGING_CURRENT_STEP_DELAY_US);
 495         }
 496         bq2419x->in_current_limit = in_current_limit;
 497
 498         if (bq2419x->charger_pdata->n_soc_profile) {
 499                 battery_soc = battery_gauge_get_battery_soc(bq2419x->bc_dev);
 500                 if (battery_soc > 0)
 501                         bq2419x_charger_input_voltage_configure(
 502                                 bq2419x->bc_dev, battery_soc);
 503         }
 504
 505         return ret;
 506 }
 507
 508 static int bq2419x_set_charging_current(struct regulator_dev *rdev,
 509                         int min_uA, int max_uA)
 510 {
 511         struct bq2419x_chip *bq2419x = rdev_get_drvdata(rdev);
 512         int in_current_limit;
 513         int old_current_limit;
 514         int ret = 0;
 515         int val;
 516
 517         dev_info(bq2419x->dev, "Setting charging current %d\n", max_uA/1000);
 518         msleep(200);
 519         bq2419x->chg_status = BATTERY_DISCHARGING;
 520
 521         if (!bq2419x->is_otg_connected) {
 522                 ret = bq2419x_charger_enable(bq2419x);
 523                 if (ret < 0) {
 524                         dev_err(bq2419x->dev, "Charger enable failed %d", ret);
 525                         return ret;
 526                 }
 527         }
 528
 529         ret = regmap_read(bq2419x->regmap, BQ2419X_SYS_STAT_REG, &val);
 530         if (ret < 0)
 531                 dev_err(bq2419x->dev, "SYS_STAT_REG read failed: %d\n", ret);
 532
 533         if (max_uA == 0 && val != 0)
 534                 return ret;
 535
 536         old_current_limit = bq2419x->in_current_limit;
 537         bq2419x->last_charging_current = max_uA;
 538         if ((val & BQ2419x_VBUS_STAT) == BQ2419x_VBUS_UNKNOWN) {
 539                 battery_charging_restart_cancel(bq2419x->bc_dev);
 540                 in_current_limit = 500;
 541                 bq2419x->cable_connected = 0;
 542                 bq2419x->chg_status = BATTERY_DISCHARGING;
 543                 battery_charger_thermal_stop_monitoring(
 544                                 bq2419x->bc_dev);
 545         } else if ((val & BQ2419x_CHRG_STATE_MASK) ==
 546                                 BQ2419x_CHRG_STATE_CHARGE_DONE) {
 547                 dev_info(bq2419x->dev, "Charging completed\n");
 548                 bq2419x->chg_status = BATTERY_CHARGING_DONE;
 549                 bq2419x->cable_connected = 1;
 550                 in_current_limit = max_uA/1000;
 551                 battery_charging_restart(bq2419x->bc_dev,
 552                                         bq2419x->chg_restart_time);
 553                 battery_charger_thermal_stop_monitoring(
 554                                 bq2419x->bc_dev);
 555         } else {
 556                 in_current_limit = max_uA/1000;
 557                 bq2419x->cable_connected = 1;
 558                 bq2419x->chg_status = BATTERY_CHARGING;
 559                 battery_charger_thermal_start_monitoring(
 560                                 bq2419x->bc_dev);
 561         }
 562         ret = bq2419x_configure_charging_current(bq2419x, in_current_limit);
 563         if (ret < 0)
 564                 goto error;
 565
 566         battery_charging_status_update(bq2419x->bc_dev, bq2419x->chg_status);
 567         if (bq2419x->disable_suspend_during_charging) {
 568                 if (bq2419x->cable_connected && in_current_limit > 500
 569                         && (bq2419x->chg_status != BATTERY_CHARGING_DONE))
 570                         battery_charger_acquire_wake_lock(bq2419x->bc_dev);
 571                 else if (!bq2419x->cable_connected && old_current_limit > 500)
 572                         battery_charger_release_wake_lock(bq2419x->bc_dev);
 573         }
 574
 575         return 0;
 576 error:
 577         dev_err(bq2419x->dev, "Charger enable failed, err = %d\n", ret);
 578         return ret;
 579 }
 580
 581 static struct regulator_ops bq2419x_tegra_regulator_ops = {
 582         .set_current_limit = bq2419x_set_charging_current,
 583 };
 584
 585 static int bq2419x_set_charging_current_suspend(struct bq2419x_chip *bq2419x,
 586                         int in_current_limit)
 587 {
 588         int ret;
 589         int val;
 590
 591         dev_info(bq2419x->dev, "Setting charging current %d mA\n",
 592                         in_current_limit);
 593
 594         if (!bq2419x->is_otg_connected) {
 595                 ret = bq2419x_charger_enable(bq2419x);
 596                 if (ret < 0) {
 597                         dev_err(bq2419x->dev, "Charger enable failed %d", ret);
 598                         return ret;
 599                 }
 600         }
 601
 602         ret = regmap_read(bq2419x->regmap, BQ2419X_SYS_STAT_REG, &val);
 603         if (ret < 0)
 604                 dev_err(bq2419x->dev, "SYS_STAT_REG read failed: %d\n", ret);
 605
 606         if (!bq2419x->cable_connected) {
 607                 battery_charging_restart_cancel(bq2419x->bc_dev);
 608                 ret = bq2419x_configure_charging_current(bq2419x,
 609                                 in_current_limit);
 610                 if (ret < 0)
 611                         return ret;
 612         }
 613         return 0;
 614 }
 615
 616 static int bq2419x_reset_wdt(struct bq2419x_chip *bq2419x, const char *from)
 617 {
 618         int ret = 0;
 619         unsigned int reg01;
 620         int timeout;
 621
 622         mutex_lock(&bq2419x->mutex);
 623         dev_dbg(bq2419x->dev, "%s() from %s()\n", __func__, from);
 624
 625         /* Clear EN_HIZ */
 626         if (bq2419x->emulate_input_disconnected)
 627                 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
 628                                 BQ2419X_EN_HIZ, BQ2419X_EN_HIZ);
 629         else
 630                 ret = regmap_update_bits(bq2419x->regmap,
 631                                 BQ2419X_INPUT_SRC_REG, BQ2419X_EN_HIZ, 0);
 632         if (ret < 0) {
 633                 dev_err(bq2419x->dev, "INPUT_SRC_REG update failed:%d\n", ret);
 634                 goto scrub;
 635         }
 636
 637         if (!bq2419x->wdt_refresh_timeout)
 638                 goto scrub;
 639
 640         ret = regmap_read(bq2419x->regmap, BQ2419X_PWR_ON_REG, &reg01);
 641         if (ret < 0) {
 642                 dev_err(bq2419x->dev, "PWR_ON_REG read failed: %d\n", ret);
 643                 goto scrub;
 644         }
 645
 646         reg01 |= BIT(6);
 647
 648         /* Write two times to make sure reset WDT */
 649         ret = regmap_write(bq2419x->regmap, BQ2419X_PWR_ON_REG, reg01);
 650         if (ret < 0) {
 651                 dev_err(bq2419x->dev, "PWR_ON_REG write failed: %d\n", ret);
 652                 goto scrub;
 653         }
 654         ret = regmap_write(bq2419x->regmap, BQ2419X_PWR_ON_REG, reg01);
 655         if (ret < 0) {
 656                 dev_err(bq2419x->dev, "PWR_ON_REG write failed: %d\n", ret);
 657                 goto scrub;
 658         }
 659
 660 scrub:
 661         mutex_unlock(&bq2419x->mutex);
 662
 663         timeout = bq2419x->wdt_refresh_timeout ? : 100;
 664         schedule_delayed_work(&bq2419x->wdt_restart_wq, timeout * HZ);
 665         return ret;
 666 }
 667
 668 static int bq2419x_fault_clear_sts(struct bq2419x_chip *bq2419x,
 669         unsigned int *reg09_val)
 670 {
 671         int ret;
 672         unsigned int reg09_1, reg09_2;
 673
 674         ret = regmap_read(bq2419x->regmap, BQ2419X_FAULT_REG, &reg09_1);
 675         if (ret < 0) {
 676                 dev_err(bq2419x->dev, "FAULT_REG read failed: %d\n", ret);
 677                 return ret;
 678         }
 679
 680         ret = regmap_read(bq2419x->regmap, BQ2419X_FAULT_REG, &reg09_2);
 681         if (ret < 0)
 682                 dev_err(bq2419x->dev, "FAULT_REG read failed: %d\n", ret);
 683
 684         if (reg09_val) {
 685                 unsigned int reg09 = 0;
 686
 687                 if ((reg09_1 | reg09_2) & BQ2419x_FAULT_WATCHDOG_FAULT)
 688                         reg09 |= BQ2419x_FAULT_WATCHDOG_FAULT;
 689                 if ((reg09_1 | reg09_2) & BQ2419x_FAULT_BOOST_FAULT)
 690                         reg09 |= BQ2419x_FAULT_BOOST_FAULT;
 691                 if ((reg09_1 | reg09_2) & BQ2419x_FAULT_BAT_FAULT)
 692                         reg09 |= BQ2419x_FAULT_BAT_FAULT;
 693                 if (((reg09_1 & BQ2419x_FAULT_CHRG_FAULT_MASK) ==
 694                                 BQ2419x_FAULT_CHRG_SAFTY) ||
 695                         ((reg09_2 & BQ2419x_FAULT_CHRG_FAULT_MASK) ==
 696                                 BQ2419x_FAULT_CHRG_SAFTY))
 697                         reg09 |= BQ2419x_FAULT_CHRG_SAFTY;
 698                 else if (((reg09_1 & BQ2419x_FAULT_CHRG_FAULT_MASK) ==
 699                                 BQ2419x_FAULT_CHRG_INPUT) ||
 700                         ((reg09_2 & BQ2419x_FAULT_CHRG_FAULT_MASK) ==
 701                                 BQ2419x_FAULT_CHRG_INPUT))
 702                         reg09 |= BQ2419x_FAULT_CHRG_INPUT;
 703                 else if (((reg09_1 & BQ2419x_FAULT_CHRG_FAULT_MASK) ==
 704                                 BQ2419x_FAULT_CHRG_THERMAL) ||
 705                         ((reg09_2 & BQ2419x_FAULT_CHRG_FAULT_MASK) ==
 706                                 BQ2419x_FAULT_CHRG_THERMAL))
 707                         reg09 |= BQ2419x_FAULT_CHRG_THERMAL;
 708
 709                 reg09 |= reg09_2 &BQ2419x_FAULT_NTC_FAULT;
 710                 *reg09_val = reg09;
 711         }
 712         return ret;
 713 }
 714
 715 static int bq2419x_watchdog_init(struct bq2419x_chip *bq2419x,
 716                         int timeout, const char *from)
 717 {
 718         int ret, val;
 719         unsigned int reg05;
 720
 721         if (!timeout) {
 722                 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_TIME_CTRL_REG,
 723                                 BQ2419X_WD_MASK, 0);
 724                 if (ret < 0)
 725                         dev_err(bq2419x->dev, "TIME_CTRL_REG read failed: %d\n",
 726                                 ret);
 727                 bq2419x->wdt_refresh_timeout = 0;
 728                 return ret;
 729         }
 730
 731         if (timeout <= 60) {
 732                 val = BQ2419X_WD_40ms;
 733                 bq2419x->wdt_refresh_timeout = 25;
 734         } else if (timeout <= 120) {
 735                 val = BQ2419X_WD_80ms;
 736                 bq2419x->wdt_refresh_timeout = 50;
 737         } else {
 738                 val = BQ2419X_WD_160ms;
 739                 bq2419x->wdt_refresh_timeout = 125;
 740         }
 741
 742         ret = regmap_read(bq2419x->regmap, BQ2419X_TIME_CTRL_REG, &reg05);
 743         if (ret < 0) {
 744                 dev_err(bq2419x->dev, "TIME_CTRL_REG read failed:%d\n", ret);
 745                 return ret;
 746         }
 747
 748         /* Reset WDT to be safe if about to end */
 749         ret = bq2419x_reset_wdt(bq2419x, from);
 750         if (ret < 0)
 751                 dev_err(bq2419x->dev, "bq2419x_reset_wdt failed: %d\n", ret);
 752
 753         if ((reg05 & BQ2419X_WD_MASK) != val) {
 754                 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_TIME_CTRL_REG,
 755                                 BQ2419X_WD_MASK, val);
 756                 if (ret < 0) {
 757                         dev_err(bq2419x->dev, "TIME_CTRL_REG read failed: %d\n",
 758                                 ret);
 759                         return ret;
 760                 }
 761         }
 762
 763         ret = bq2419x_reset_wdt(bq2419x, from);
 764         if (ret < 0)
 765                 dev_err(bq2419x->dev, "bq2419x_reset_wdt failed: %d\n", ret);
 766
 767         return ret;
 768 }
 769
 770 static void bq2419x_wdt_restart_wq(struct work_struct *work)
 771 {
 772         struct bq2419x_chip *bq2419x;
 773         int ret;
 774
 775         bq2419x = container_of(work, struct bq2419x_chip, wdt_restart_wq.work);
 776         ret = bq2419x_reset_wdt(bq2419x, "THREAD");
 777         if (ret < 0)
 778                 dev_err(bq2419x->dev, "bq2419x_reset_wdt failed: %d\n", ret);
 779
 780 }
 781 static int bq2419x_reconfigure_charger_param(struct bq2419x_chip *bq2419x,
 782                 const char *from)
 783 {
 784         int ret;
 785
 786         dev_info(bq2419x->dev, "Reconfiguring charging param from %s\n", from);
 787         ret = bq2419x_watchdog_init(bq2419x, bq2419x->wdt_time_sec, from);
 788         if (ret < 0) {
 789                 dev_err(bq2419x->dev, "BQWDT init failed %d\n", ret);
 790                 return ret;
 791         }
 792
 793         ret = bq2419x_charger_init(bq2419x);
 794         if (ret < 0) {
 795                 dev_err(bq2419x->dev, "Charger init failed: %d\n", ret);
 796                 return ret;
 797         }
 798
 799         ret = bq2419x_configure_charging_current(bq2419x,
 800                         bq2419x->in_current_limit);
 801         if (ret < 0) {
 802                 dev_err(bq2419x->dev, "Current config failed: %d\n", ret);
 803                 return ret;
 804         }
 805         return ret;
 806 }
 807
 808 static int bq2419x_handle_safety_timer_expire(struct bq2419x_chip *bq2419x)
 809 {
 810         struct device *dev = bq2419x->dev;
 811         int ret;
 812
 813         /* Reset saftty timer by setting 0 and then making 1 */
 814         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_TIME_CTRL_REG,
 815                         BQ2419X_EN_SFT_TIMER_MASK, 0);
 816         if (ret < 0) {
 817                 dev_err(dev, "TIME_CTRL_REG update failed: %d\n", ret);
 818                 return ret;
 819         }
 820
 821         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_TIME_CTRL_REG,
 822                         BQ2419X_EN_SFT_TIMER_MASK, BQ2419X_EN_SFT_TIMER_MASK);
 823         if (ret < 0) {
 824                 dev_err(dev, "TIME_CTRL_REG update failed: %d\n", ret);
 825                 return ret;
 826         }
 827
 828         /* Need to toggel the Charging-enable bit from 1 to 0 to 1 */
 829         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_PWR_ON_REG,
 830                         BQ2419X_ENABLE_CHARGE_MASK, 0);
 831         if (ret < 0) {
 832                 dev_err(dev, "PWR_ON_REG update failed %d\n", ret);
 833                 return ret;
 834         }
 835         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_PWR_ON_REG,
 836                         BQ2419X_ENABLE_CHARGE_MASK, BQ2419X_ENABLE_CHARGE);
 837         if (ret < 0) {
 838                 dev_err(dev, "PWR_ON_REG update failed %d\n", ret);
 839                 return ret;
 840         }
 841
 842         ret = bq2419x_reconfigure_charger_param(bq2419x, "SAFETY-TIMER_EXPIRE");
 843         if (ret < 0) {
 844                 dev_err(dev, "Reconfig of BQ parm failed: %d\n", ret);
 845                 return ret;
 846         }
 847         return ret;
 848 }
 849
 850 static irqreturn_t bq2419x_irq(int irq, void *data)
 851 {
 852         struct bq2419x_chip *bq2419x = data;
 853         int ret;
 854         unsigned int val;
 855         int check_chg_state = 0;
 856
 857         ret = bq2419x_fault_clear_sts(bq2419x, &val);
 858         if (ret < 0) {
 859                 dev_err(bq2419x->dev, "fault clear status failed %d\n", ret);
 860                 return ret;
 861         }
 862
 863         dev_info(bq2419x->dev, "%s() Irq %d status 0x%02x\n",
 864                 __func__, irq, val);
 865
 866         if ((val & BQ2419x_CHARGING_FAULT_MASK) &&
 867                         gpio_is_valid(bq2419x->chg_status_gpio) &&
 868                         bq2419x->chg_status == BATTERY_CHARGING) {
 869                 gpio_set_value(bq2419x->chg_status_gpio, BQ2419X_CHARGE_LED_OFF);
 870         }
 871
 872         if (val & BQ2419x_FAULT_BOOST_FAULT) {
 873                 bq_chg_err(bq2419x, "VBUS Overloaded\n");
 874                 ret = bq2419x_disable_otg_mode(bq2419x);
 875                 if (ret < 0) {
 876                         bq_chg_err(bq2419x, "otg mode disable failed\n");
 877                         return ret;
 878                 }
 879         }
 880
 881         if (!bq2419x->battery_presense)
 882                 return IRQ_HANDLED;
 883
 884         if (val & BQ2419x_FAULT_WATCHDOG_FAULT) {
 885                 bq_chg_err(bq2419x, "WatchDog Expired\n");
 886                 ret = bq2419x_reconfigure_charger_param(bq2419x, "WDT-EXP-ISR");
 887                 if (ret < 0) {
 888                         dev_err(bq2419x->dev, "BQ reconfig failed %d\n", ret);
 889                         return ret;
 890                 }
 891         }
 892
 893         switch (val & BQ2419x_FAULT_CHRG_FAULT_MASK) {
 894         case BQ2419x_FAULT_CHRG_INPUT:
 895                 bq_chg_err(bq2419x,
 896                         "Input Fault (VBUS OVP or VBAT<VBUS<3.8V)\n");
 897                 break;
 898         case BQ2419x_FAULT_CHRG_THERMAL:
 899                 bq_chg_err(bq2419x, "Thermal shutdown\n");
 900                 check_chg_state = 1;
 901                 ret = bq2419x_disable_otg_mode(bq2419x);
 902                 if (ret < 0) {
 903                         bq_chg_err(bq2419x, "otg mode disable failed\n");
 904                         return ret;
 905                 }
 906                 break;
 907         case BQ2419x_FAULT_CHRG_SAFTY:
 908                 bq_chg_err(bq2419x, "Safety timer expiration\n");
 909                 ret = bq2419x_handle_safety_timer_expire(bq2419x);
 910                 if (ret < 0) {
 911                         dev_err(bq2419x->dev,
 912                                 "Handling of safty timer expire failed: %d\n",
 913                                 ret);
 914                 }
 915                 check_chg_state = 1;
 916                 break;
 917         default:
 918                 break;
 919         }
 920
 921         if (val & BQ2419x_FAULT_NTC_FAULT) {
 922                 bq_chg_err(bq2419x, "NTC fault %d\n",
 923                                 val & BQ2419x_FAULT_NTC_FAULT);
 924                 check_chg_state = 1;
 925         }
 926
 927         ret = regmap_read(bq2419x->regmap, BQ2419X_SYS_STAT_REG, &val);
 928         if (ret < 0) {
 929                 dev_err(bq2419x->dev, "SYS_STAT_REG read failed %d\n", ret);
 930                 return ret;
 931         }
 932
 933         if ((val & BQ2419x_CHRG_STATE_MASK) == BQ2419x_CHRG_STATE_CHARGE_DONE) {
 934                 dev_info(bq2419x->dev, "Charging completed\n");
 935                 bq2419x->chg_status = BATTERY_CHARGING_DONE;
 936                 battery_charging_status_update(bq2419x->bc_dev,
 937                                         bq2419x->chg_status);
 938                 battery_charging_restart(bq2419x->bc_dev,
 939                                         bq2419x->chg_restart_time);
 940                 if (bq2419x->disable_suspend_during_charging)
 941                         battery_charger_release_wake_lock(bq2419x->bc_dev);
 942                 battery_charger_thermal_stop_monitoring(
 943                                 bq2419x->bc_dev);
 944         }
 945
 946         if ((val & BQ2419x_VSYS_STAT_MASK) == BQ2419x_VSYS_STAT_BATT_LOW)
 947                 dev_info(bq2419x->dev,
 948                         "In VSYSMIN regulation, battery is too low\n");
 949
 950         /* Update Charging status based on STAT register */
 951         if (check_chg_state &&
 952           ((val & BQ2419x_CHRG_STATE_MASK) == BQ2419x_CHRG_STATE_NOTCHARGING)) {
 953                 bq2419x->chg_status = BATTERY_DISCHARGING;
 954                 battery_charging_status_update(bq2419x->bc_dev,
 955                                 bq2419x->chg_status);
 956                 battery_charging_restart(bq2419x->bc_dev,
 957                                         bq2419x->chg_restart_time);
 958                 if (bq2419x->disable_suspend_during_charging)
 959                         battery_charger_release_wake_lock(bq2419x->bc_dev);
 960         }
 961
 962         return IRQ_HANDLED;
 963 }
 964
 965 static int bq2419x_init_charger_regulator(struct bq2419x_chip *bq2419x,
 966                 struct bq2419x_platform_data *pdata)
 967 {
 968         int ret = 0;
 969         struct regulator_config rconfig = { };
 970
 971         if (!pdata->bcharger_pdata) {
 972                 dev_err(bq2419x->dev, "No charger platform data\n");
 973                 return 0;
 974         }
 975
 976         bq2419x->chg_reg_desc.name  = "bq2419x-charger";
 977         bq2419x->chg_reg_desc.ops   = &bq2419x_tegra_regulator_ops;
 978         bq2419x->chg_reg_desc.type  = REGULATOR_CURRENT;
 979         bq2419x->chg_reg_desc.owner = THIS_MODULE;
 980
 981         bq2419x->chg_reg_init_data.supply_regulator     = NULL;
 982         bq2419x->chg_reg_init_data.regulator_init       = NULL;
 983         bq2419x->chg_reg_init_data.num_consumer_supplies =
 984                                 pdata->bcharger_pdata->num_consumer_supplies;
 985         bq2419x->chg_reg_init_data.consumer_supplies    =
 986                                 pdata->bcharger_pdata->consumer_supplies;
 987         bq2419x->chg_reg_init_data.driver_data          = bq2419x;
 988         bq2419x->chg_reg_init_data.constraints.name     = "bq2419x-charger";
 989         bq2419x->chg_reg_init_data.constraints.min_uA   = 0;
 990         bq2419x->chg_reg_init_data.constraints.max_uA   =
 991                         pdata->bcharger_pdata->max_charge_current_mA * 1000;
 992
 993         bq2419x->chg_reg_init_data.constraints.ignore_current_constraint_init =
 994                                                         true;
 995         bq2419x->chg_reg_init_data.constraints.valid_modes_mask =
 996                                                 REGULATOR_MODE_NORMAL |
 997                                                 REGULATOR_MODE_STANDBY;
 998
 999         bq2419x->chg_reg_init_data.constraints.valid_ops_mask =
1000                                                 REGULATOR_CHANGE_MODE |
1001                                                 REGULATOR_CHANGE_STATUS |
1002                                                 REGULATOR_CHANGE_CURRENT;
1003
1004         rconfig.dev = bq2419x->dev;
1005         rconfig.of_node = NULL;
1006         rconfig.init_data = &bq2419x->chg_reg_init_data;
1007         rconfig.driver_data = bq2419x;
1008         bq2419x->chg_rdev = devm_regulator_register(bq2419x->dev,
1009                                 &bq2419x->chg_reg_desc, &rconfig);
1010         if (IS_ERR(bq2419x->chg_rdev)) {
1011                 ret = PTR_ERR(bq2419x->chg_rdev);
1012                 dev_err(bq2419x->dev,
1013                         "vbus-charger regulator register failed %d\n", ret);
1014         }
1015         return ret;
1016 }
1017
1018 static int bq2419x_init_vbus_regulator(struct bq2419x_chip *bq2419x,
1019                 struct bq2419x_platform_data *pdata)
1020 {
1021         int ret = 0;
1022         struct regulator_config rconfig = { };
1023
1024         if (!pdata->vbus_pdata) {
1025                 dev_err(bq2419x->dev, "No vbus platform data\n");
1026                 return 0;
1027         }
1028
1029         bq2419x->gpio_otg_iusb = pdata->vbus_pdata->gpio_otg_iusb;
1030         bq2419x->vbus_reg_desc.name = "bq2419x-vbus";
1031         bq2419x->vbus_reg_desc.ops = &bq2419x_vbus_ops;
1032         bq2419x->vbus_reg_desc.type = REGULATOR_VOLTAGE;
1033         bq2419x->vbus_reg_desc.owner = THIS_MODULE;
1034         bq2419x->vbus_reg_desc.enable_time = 8000;
1035
1036         bq2419x->vbus_reg_init_data.supply_regulator    = NULL;
1037         bq2419x->vbus_reg_init_data.regulator_init      = NULL;
1038         bq2419x->vbus_reg_init_data.num_consumer_supplies       =
1039                                 pdata->vbus_pdata->num_consumer_supplies;
1040         bq2419x->vbus_reg_init_data.consumer_supplies   =
1041                                 pdata->vbus_pdata->consumer_supplies;
1042         bq2419x->vbus_reg_init_data.driver_data         = bq2419x;
1043
1044         bq2419x->vbus_reg_init_data.constraints.name    = "bq2419x-vbus";
1045         bq2419x->vbus_reg_init_data.constraints.min_uV  = 0;
1046         bq2419x->vbus_reg_init_data.constraints.max_uV  = 5000000,
1047         bq2419x->vbus_reg_init_data.constraints.valid_modes_mask =
1048                                         REGULATOR_MODE_NORMAL |
1049                                         REGULATOR_MODE_STANDBY;
1050         bq2419x->vbus_reg_init_data.constraints.valid_ops_mask =
1051                                         REGULATOR_CHANGE_MODE |
1052                                         REGULATOR_CHANGE_STATUS |
1053                                         REGULATOR_CHANGE_VOLTAGE;
1054
1055         if (gpio_is_valid(bq2419x->gpio_otg_iusb)) {
1056                 ret = gpio_request_one(bq2419x->gpio_otg_iusb,
1057                                 GPIOF_OUT_INIT_HIGH, dev_name(bq2419x->dev));
1058                 if (ret < 0) {
1059                         dev_err(bq2419x->dev, "gpio request failed  %d\n", ret);
1060                         return ret;
1061                 }
1062         }
1063
1064         /* Register the regulators */
1065         rconfig.dev = bq2419x->dev;
1066         rconfig.of_node = NULL;
1067         rconfig.init_data = &bq2419x->vbus_reg_init_data;
1068         rconfig.driver_data = bq2419x;
1069         bq2419x->vbus_rdev = devm_regulator_register(bq2419x->dev,
1070                                 &bq2419x->vbus_reg_desc, &rconfig);
1071         if (IS_ERR(bq2419x->vbus_rdev)) {
1072                 ret = PTR_ERR(bq2419x->vbus_rdev);
1073                 dev_err(bq2419x->dev,
1074                         "VBUS regulator register failed %d\n", ret);
1075                 goto scrub;
1076         }
1077
1078         /* Disable the VBUS regulator and enable charging */
1079         ret = bq2419x_charger_enable(bq2419x);
1080         if (ret < 0) {
1081                 dev_err(bq2419x->dev, "Charging enable failed %d", ret);
1082                 goto scrub;
1083         }
1084         return ret;
1085
1086 scrub:
1087         if (gpio_is_valid(bq2419x->gpio_otg_iusb))
1088                 gpio_free(bq2419x->gpio_otg_iusb);
1089         return ret;
1090 }
1091
1092 static int bq2419x_show_chip_version(struct bq2419x_chip *bq2419x)
1093 {
1094         int ret;
1095         unsigned int val;
1096
1097         ret = regmap_read(bq2419x->regmap, BQ2419X_REVISION_REG, &val);
1098         if (ret < 0) {
1099                 dev_err(bq2419x->dev, "REVISION_REG read failed: %d\n", ret);
1100                 return ret;
1101         }
1102
1103         if ((val & BQ24190_IC_VER) == BQ24190_IC_VER)
1104                 dev_info(bq2419x->dev, "chip type BQ24190 detected\n");
1105         else if ((val & BQ24192_IC_VER) == BQ24192_IC_VER)
1106                 dev_info(bq2419x->dev, "chip type BQ2419X/3 detected\n");
1107         else if ((val & BQ24192i_IC_VER) == BQ24192i_IC_VER)
1108                 dev_info(bq2419x->dev, "chip type BQ2419Xi detected\n");
1109         return 0;
1110 }
1111
1112
1113 static ssize_t bq2419x_show_input_charging_current(struct device *dev,
1114                         struct device_attribute *attr, char *buf)
1115 {
1116         struct i2c_client *client = to_i2c_client(dev);
1117         struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1118         unsigned int reg_val;
1119         int ret;
1120
1121         ret = regmap_read(bq2419x->regmap, BQ2419X_INPUT_SRC_REG, &reg_val);
1122         if (ret < 0) {
1123                 dev_err(bq2419x->dev, "INPUT_SRC read failed: %d\n", ret);
1124                 return ret;
1125         }
1126         ret = iinlim[BQ2419x_CONFIG_MASK & reg_val];
1127         return snprintf(buf, MAX_STR_PRINT, "%d mA\n", ret);
1128 }
1129
1130 static ssize_t bq2419x_set_input_charging_current(struct device *dev,
1131                 struct device_attribute *attr, const char *buf, size_t count)
1132 {
1133         struct i2c_client *client = to_i2c_client(dev);
1134         struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1135         int ret;
1136         int in_current_limit;
1137         char *p = (char *)buf;
1138
1139         in_current_limit = memparse(p, &p);
1140         ret = bq2419x_configure_charging_current(bq2419x, in_current_limit);
1141         if (ret  < 0) {
1142                 dev_err(dev, "Current %d mA configuration faild: %d\n",
1143                         in_current_limit, ret);
1144                 return ret;
1145         }
1146         return count;
1147 }
1148
1149 static ssize_t bq2419x_show_charging_state(struct device *dev,
1150                         struct device_attribute *attr, char *buf)
1151 {
1152         struct i2c_client *client = to_i2c_client(dev);
1153         struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1154         unsigned int reg_val;
1155         int ret;
1156
1157         ret = regmap_read(bq2419x->regmap, BQ2419X_PWR_ON_REG, &reg_val);
1158         if (ret < 0) {
1159                 dev_err(dev, "BQ2419X_PWR_ON register read failed: %d\n", ret);
1160                 return ret;
1161         }
1162
1163         if ((reg_val & BQ2419X_ENABLE_CHARGE_MASK) == BQ2419X_ENABLE_CHARGE)
1164                 return snprintf(buf, MAX_STR_PRINT, "enabled\n");
1165         else
1166                 return snprintf(buf, MAX_STR_PRINT, "disabled\n");
1167 }
1168
1169 static ssize_t bq2419x_set_charging_state(struct device *dev,
1170                 struct device_attribute *attr, const char *buf, size_t count)
1171 {
1172         struct i2c_client *client = to_i2c_client(dev);
1173         struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1174         bool enabled;
1175         int ret;
1176
1177         if ((*buf == 'E') || (*buf == 'e'))
1178                 enabled = true;
1179         else if ((*buf == 'D') || (*buf == 'd'))
1180                 enabled = false;
1181         else
1182                 return -EINVAL;
1183
1184         if (enabled)
1185                 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_PWR_ON_REG,
1186                         BQ2419X_ENABLE_CHARGE_MASK, BQ2419X_ENABLE_CHARGE);
1187         else
1188                 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_PWR_ON_REG,
1189                          BQ2419X_ENABLE_CHARGE_MASK, BQ2419X_DISABLE_CHARGE);
1190         if (ret < 0) {
1191                 dev_err(bq2419x->dev, "register update failed, %d\n", ret);
1192                 return ret;
1193         }
1194         return count;
1195 }
1196
1197 static ssize_t bq2419x_show_input_cable_state(struct device *dev,
1198                         struct device_attribute *attr, char *buf)
1199 {
1200         struct i2c_client *client = to_i2c_client(dev);
1201         struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1202         unsigned int reg_val;
1203         int ret;
1204
1205         ret = regmap_read(bq2419x->regmap, BQ2419X_INPUT_SRC_REG, &reg_val);
1206         if (ret < 0) {
1207                 dev_err(dev, "BQ2419X_PWR_ON register read failed: %d\n", ret);
1208                 return ret;
1209         }
1210
1211         if ((reg_val & BQ2419X_EN_HIZ) == BQ2419X_EN_HIZ)
1212                 return snprintf(buf, MAX_STR_PRINT, "Disconnected\n");
1213         else
1214                 return snprintf(buf, MAX_STR_PRINT, "Connected\n");
1215 }
1216
1217 static ssize_t bq2419x_set_input_cable_state(struct device *dev,
1218                 struct device_attribute *attr, const char *buf, size_t count)
1219 {
1220         struct i2c_client *client = to_i2c_client(dev);
1221         struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1222         bool connect;
1223         int ret;
1224
1225         if ((*buf == 'C') || (*buf == 'c'))
1226                 connect = true;
1227         else if ((*buf == 'D') || (*buf == 'd'))
1228                 connect = false;
1229         else
1230                 return -EINVAL;
1231
1232         if (connect) {
1233                 bq2419x->emulate_input_disconnected = false;
1234                 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
1235                                 BQ2419X_EN_HIZ, 0);
1236         } else {
1237                 bq2419x->emulate_input_disconnected = true;
1238                 ret = regmap_update_bits(bq2419x->regmap, BQ2419X_INPUT_SRC_REG,
1239                                 BQ2419X_EN_HIZ, BQ2419X_EN_HIZ);
1240         }
1241         if (ret < 0) {
1242                 dev_err(bq2419x->dev, "register update failed, %d\n", ret);
1243                 return ret;
1244         }
1245         if (connect)
1246                 dev_info(bq2419x->dev,
1247                         "Emulation of charger cable disconnect disabled\n");
1248         else
1249                 dev_info(bq2419x->dev,
1250                         "Emulated as charger cable Disconnected\n");
1251         return count;
1252 }
1253
1254 static ssize_t bq2419x_show_output_charging_current(struct device *dev,
1255                                 struct device_attribute *attr,
1256                                 char *buf)
1257 {
1258         struct i2c_client *client = to_i2c_client(dev);
1259         struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1260         int ret;
1261         unsigned int data;
1262
1263         ret = regmap_read(bq2419x->regmap, BQ2419X_CHRG_CTRL_REG, &data);
1264         if (ret < 0) {
1265                 dev_err(bq2419x->dev, "CHRG_CTRL read failed %d", ret);
1266                 return ret;
1267         }
1268         data >>= 2;
1269         data = data * 64 + BQ2419X_CHARGE_ICHG_OFFSET;
1270         return snprintf(buf, MAX_STR_PRINT, "%u mA\n", data);
1271 }
1272
1273 static ssize_t bq2419x_set_output_charging_current(struct device *dev,
1274                                 struct device_attribute *attr,
1275                                 const char *buf, size_t count)
1276 {
1277         struct i2c_client *client = to_i2c_client(dev);
1278         struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1279         int curr_val, ret;
1280         int ichg;
1281
1282         if (kstrtouint(buf, 0, &curr_val)) {
1283                 dev_err(dev, "\nfile: %s, line=%d return %s()",
1284                                         __FILE__, __LINE__, __func__);
1285                 return -EINVAL;
1286         }
1287
1288         ichg = bq2419x_val_to_reg(curr_val, BQ2419X_CHARGE_ICHG_OFFSET,
1289                                                 64, 6, 0);
1290         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_CHRG_CTRL_REG,
1291                                 BQ2419X_CHRG_CTRL_ICHG_MASK, ichg << 2);
1292
1293         return count;
1294 }
1295
1296 static ssize_t bq2419x_show_output_charging_current_values(struct device *dev,
1297                         struct device_attribute *attr, char *buf)
1298 {
1299         int i, ret = 0;
1300
1301         for (i = 0; i <= 63; i++)
1302                 ret += snprintf(buf + strlen(buf), MAX_STR_PRINT,
1303                                 "%d mA\n", i * 64 + BQ2419X_CHARGE_ICHG_OFFSET);
1304
1305         return ret;
1306 }
1307
1308 static DEVICE_ATTR(output_charging_current, (S_IRUGO | (S_IWUSR | S_IWGRP)),
1309                 bq2419x_show_output_charging_current,
1310                 bq2419x_set_output_charging_current);
1311
1312 static DEVICE_ATTR(output_current_allowed_values, S_IRUGO,
1313                 bq2419x_show_output_charging_current_values, NULL);
1314
1315 static DEVICE_ATTR(input_charging_current_mA, (S_IRUGO | (S_IWUSR | S_IWGRP)),
1316                 bq2419x_show_input_charging_current,
1317                 bq2419x_set_input_charging_current);
1318
1319 static DEVICE_ATTR(charging_state, (S_IRUGO | (S_IWUSR | S_IWGRP)),
1320                 bq2419x_show_charging_state, bq2419x_set_charging_state);
1321
1322 static DEVICE_ATTR(input_cable_state, (S_IRUGO | (S_IWUSR | S_IWGRP)),
1323                 bq2419x_show_input_cable_state, bq2419x_set_input_cable_state);
1324
1325 static struct attribute *bq2419x_attributes[] = {
1326         &dev_attr_output_charging_current.attr,
1327         &dev_attr_output_current_allowed_values.attr,
1328         &dev_attr_input_charging_current_mA.attr,
1329         &dev_attr_charging_state.attr,
1330         &dev_attr_input_cable_state.attr,
1331         NULL
1332 };
1333
1334 static const struct attribute_group bq2419x_attr_group = {
1335         .attrs = bq2419x_attributes,
1336 };
1337
1338 static int bq2419x_charger_get_status(struct battery_charger_dev *bc_dev)
1339 {
1340         struct bq2419x_chip *bq2419x = battery_charger_get_drvdata(bc_dev);
1341
1342         return bq2419x->chg_status;
1343 }
1344
1345 static int bq2419x_charger_thermal_configure(
1346                 struct battery_charger_dev *bc_dev,
1347                 int temp, bool enable_charger, bool enable_charg_half_current,
1348                 int battery_voltage)
1349 {
1350         struct bq2419x_chip *bq2419x = battery_charger_get_drvdata(bc_dev);
1351         struct bq2419x_charger_platform_data *chg_pdata;
1352         int fast_charge_current = 0;
1353         u32 charge_voltage_limit = 0;
1354         int ichg;
1355         int ret;
1356         int i;
1357         int curr_ichg, vreg;
1358
1359         chg_pdata = bq2419x->charger_pdata;
1360         if (!bq2419x->cable_connected || !chg_pdata->n_temp_profile)
1361                 return 0;
1362
1363         if (bq2419x->last_temp == temp)
1364                 return 0;
1365
1366         bq2419x->last_temp = temp;
1367
1368         dev_info(bq2419x->dev, "Battery temp %d\n", temp);
1369
1370         for (i = 0; i < chg_pdata->n_temp_profile; ++i) {
1371                 if (temp <= chg_pdata->temp_range[i]) {
1372                         fast_charge_current = chg_pdata->chg_current_limit[i];
1373                         if (chg_pdata->chg_thermal_voltage_limit)
1374                                 charge_voltage_limit =
1375                                         chg_pdata->chg_thermal_voltage_limit[i];
1376                         break;
1377                 }
1378         }
1379         if (!fast_charge_current || !temp) {
1380                 dev_info(bq2419x->dev, "Disable charging done by HW\n");
1381                 return 0;
1382         }
1383
1384         /* Fast charger become 50% when temp is at < 10 degC */
1385         if (temp <= 10)
1386                 fast_charge_current *= 2;
1387
1388         curr_ichg = bq2419x->chg_current_control.val >> 2;
1389         ichg = bq2419x_val_to_reg(fast_charge_current,
1390                         BQ2419X_CHARGE_ICHG_OFFSET, 64, 6, 0);
1391         if (curr_ichg == ichg)
1392                 return 0;
1393
1394         bq2419x->chg_current_control.val = ichg << 2;
1395         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_CHRG_CTRL_REG,
1396                         BQ2419X_CHRG_CTRL_ICHG_MASK, ichg << 2);
1397         if (ret < 0) {
1398                 dev_err(bq2419x->dev, "CHRG_CTRL_REG update failed %d\n", ret);
1399                 return ret;
1400         }
1401
1402         if (!charge_voltage_limit)
1403                 return 0;
1404
1405         /* Charge voltage limit */
1406         vreg = bq2419x_val_to_reg(charge_voltage_limit,
1407                         BQ2419X_CHARGE_VOLTAGE_OFFSET, 16, 6, 1);
1408         bq2419x->chg_voltage_control.mask = BQ2419X_CHG_VOLT_LIMIT_MASK;
1409         bq2419x->chg_voltage_control.val = vreg << 2;
1410         ret = regmap_update_bits(bq2419x->regmap, BQ2419X_VOLT_CTRL_REG,
1411                                 bq2419x->chg_voltage_control.mask,
1412                                 bq2419x->chg_voltage_control.val);
1413         if (ret < 0) {
1414                 dev_err(bq2419x->dev, "VOLT_CTRL_REG update failed %d\n", ret);
1415                 return ret;
1416         }
1417
1418         return 0;
1419 }
1420
1421 static int bq2419x_charging_restart(struct battery_charger_dev *bc_dev)
1422 {
1423         struct bq2419x_chip *bq2419x = battery_charger_get_drvdata(bc_dev);
1424         int ret;
1425
1426         if (!bq2419x->cable_connected)
1427                 return 0;
1428
1429         dev_info(bq2419x->dev, "Restarting the charging\n");
1430         ret = bq2419x_set_charging_current(bq2419x->chg_rdev,
1431                         bq2419x->last_charging_current,
1432                         bq2419x->last_charging_current);
1433         if (ret < 0) {
1434                 dev_err(bq2419x->dev,
1435                         "Restarting of charging failed: %d\n", ret);
1436                 battery_charging_restart(bq2419x->bc_dev,
1437                                 bq2419x->chg_restart_time);
1438         }
1439         return ret;
1440 }
1441
1442 static struct battery_charging_ops bq2419x_charger_bci_ops = {
1443         .get_charging_status = bq2419x_charger_get_status,
1444         .restart_charging = bq2419x_charging_restart,
1445         .thermal_configure = bq2419x_charger_thermal_configure,
1446         .input_voltage_configure = bq2419x_charger_input_voltage_configure,
1447 };
1448
1449 static struct battery_charger_info bq2419x_charger_bci = {
1450         .cell_id = 0,
1451         .bc_ops = &bq2419x_charger_bci_ops,
1452 };
1453
1454 static struct bq2419x_platform_data *bq2419x_dt_parse(struct i2c_client *client)
1455 {
1456         struct device_node *np = client->dev.of_node;
1457         struct bq2419x_platform_data *pdata;
1458         struct device_node *batt_reg_node;
1459         struct device_node *vbus_reg_node;
1460         int ret;
1461
1462         pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
1463         if (!pdata)
1464                 return ERR_PTR(-ENOMEM);
1465
1466         batt_reg_node = of_find_node_by_name(np, "charger");
1467         if (batt_reg_node) {
1468                 int temp_range_len, chg_current_lim_len, chg_voltage_lim_len;
1469                 int count;
1470                 int wdt_timeout;
1471                 int chg_restart_time;
1472                 int auto_recharge_time_power_off;
1473                 int temp_polling_time;
1474                 int soc_range_len, inut_volt_lim_len = 0;
1475                 struct regulator_init_data *batt_init_data;
1476                 struct bq2419x_charger_platform_data *chg_pdata;
1477                 const char *status_str;
1478                 struct bq2419x_charger_platform_data *bcharger_pdata;
1479                 u32 pval;
1480
1481                 status_str = of_get_property(batt_reg_node, "status", NULL);
1482                 if (status_str && !(!strcmp(status_str, "okay"))) {
1483                         dev_info(&client->dev,
1484                                 "charger node status is disabled\n");
1485                         goto  vbus_node;
1486                 }
1487
1488                 pdata->bcharger_pdata = devm_kzalloc(&client->dev,
1489                                 sizeof(*(pdata->bcharger_pdata)), GFP_KERNEL);
1490                 if (!pdata->bcharger_pdata)
1491                         return ERR_PTR(-ENOMEM);
1492                 bcharger_pdata = pdata->bcharger_pdata;
1493
1494                 chg_pdata = pdata->bcharger_pdata;
1495                 batt_init_data = of_get_regulator_init_data(&client->dev,
1496                                                                 batt_reg_node);
1497                 if (!batt_init_data)
1498                         return ERR_PTR(-EINVAL);
1499
1500                 bcharger_pdata->chg_status_gpio =
1501                                 of_get_named_gpio(batt_reg_node,
1502                                         "ti,charge-status-gpio", 0);
1503
1504                 ret = of_property_read_u32(batt_reg_node,
1505                                 "ti,input-voltage-limit-millivolt", &pval);
1506                 if (!ret)
1507                         bcharger_pdata->input_voltage_limit_mV = pval;
1508
1509                 ret = of_property_read_u32(batt_reg_node,
1510                                 "ti,fast-charge-current-limit-milliamp", &pval);
1511                 if (!ret)
1512                         bcharger_pdata->fast_charge_current_limit_mA =
1513                                                         pval;
1514
1515                 ret = of_property_read_u32(batt_reg_node,
1516                                 "ti,pre-charge-current-limit-milliamp", &pval);
1517                 if (!ret)
1518                         bcharger_pdata->pre_charge_current_limit_mA = pval;
1519
1520                 ret = of_property_read_u32(batt_reg_node,
1521                                 "ti,charge-term-current-limit-milliamp", &pval);
1522                 if (!ret)
1523                         bcharger_pdata->termination_current_limit_mA = pval;
1524
1525                 ret = of_property_read_u32(batt_reg_node,
1526                                 "ti,ir-comp-resister-ohm", &pval);
1527                 if (!ret)
1528                         bcharger_pdata->ir_compensation_resister_ohm = pval;
1529
1530                 ret = of_property_read_u32(batt_reg_node,
1531                                 "ti,ir-comp-voltage-millivolt", &pval);
1532                 if (!ret)
1533                         bcharger_pdata->ir_compensation_voltage_mV = pval;
1534
1535                 ret = of_property_read_u32(batt_reg_node,
1536                                 "ti,thermal-regulation-threshold-degc", &pval);
1537                 if (!ret)
1538                         bcharger_pdata->thermal_regulation_threshold_degC =
1539                                                 pval;
1540
1541                 ret = of_property_read_u32(batt_reg_node,
1542                                 "ti,charge-voltage-limit-millivolt", &pval);
1543                 if (!ret)
1544                         pdata->bcharger_pdata->charge_voltage_limit_mV = pval;
1545
1546                 pdata->bcharger_pdata->disable_suspend_during_charging =
1547                                 of_property_read_bool(batt_reg_node,
1548                                 "ti,disbale-suspend-during-charging");
1549
1550                 ret = of_property_read_u32(batt_reg_node,
1551                                 "ti,watchdog-timeout", &wdt_timeout);
1552                 if (!ret)
1553                         pdata->bcharger_pdata->wdt_timeout = wdt_timeout;
1554
1555                 ret = of_property_read_u32(batt_reg_node,
1556                         "ti,auto-recharge-time-power-off",
1557                         &auto_recharge_time_power_off);
1558                 if (!ret)
1559                         pdata->bcharger_pdata->auto_recharge_time_power_off =
1560                                         auto_recharge_time_power_off;
1561                 else
1562                         pdata->bcharger_pdata->auto_recharge_time_power_off =
1563                                         3600;
1564
1565                 ret = of_property_read_u32(batt_reg_node,
1566                                 "ti,auto-recharge-time", &chg_restart_time);
1567                 if (!ret)
1568                         pdata->bcharger_pdata->chg_restart_time =
1569                                                         chg_restart_time;
1570
1571                 ret = of_property_read_u32(batt_reg_node,
1572                                 "ti,auto-recharge-time-suspend",
1573                                 &chg_restart_time);
1574                 if (!ret)
1575                         pdata->bcharger_pdata->auto_recharge_time_supend =
1576                                                         chg_restart_time;
1577                 else
1578                         pdata->bcharger_pdata->auto_recharge_time_supend =
1579                                         3600;
1580
1581                 ret = of_property_read_u32(batt_reg_node,
1582                         "ti,temp-polling-time-sec", &temp_polling_time);
1583                 if (!ret)
1584                         bcharger_pdata->temp_polling_time_sec =
1585                                                 temp_polling_time;
1586
1587                 count = of_property_count_u32(batt_reg_node, "ti,soc-range");
1588                 soc_range_len = (count > 0) ? count : 0;
1589
1590                 if (soc_range_len) {
1591                         chg_pdata->n_soc_profile = soc_range_len;
1592                         chg_pdata->soc_range = devm_kzalloc(&client->dev,
1593                                 sizeof(u32) * soc_range_len, GFP_KERNEL);
1594                         if (!chg_pdata->soc_range)
1595                                 return ERR_PTR(-ENOMEM);
1596
1597                         ret = of_property_read_u32_array(batt_reg_node,
1598                                         "ti,soc-range",
1599                                         chg_pdata->soc_range, soc_range_len);
1600                         if (ret < 0)
1601                                 return ERR_PTR(ret);
1602
1603                         count =  of_property_count_u32(batt_reg_node,
1604                                         "ti,input-voltage-soc-limit");
1605                         inut_volt_lim_len = (count > 0) ? count : 0;
1606                 }
1607
1608                 if (inut_volt_lim_len) {
1609                         chg_pdata->input_voltage_soc_limit =
1610                                         devm_kzalloc(&client->dev,
1611                                         sizeof(u32) * inut_volt_lim_len,
1612                                         GFP_KERNEL);
1613                         if (!chg_pdata->input_voltage_soc_limit)
1614                                 return ERR_PTR(-ENOMEM);
1615
1616                         ret = of_property_read_u32_array(batt_reg_node,
1617                                         "ti,input-voltage-soc-limit",
1618                                         chg_pdata->input_voltage_soc_limit,
1619                                         inut_volt_lim_len);
1620                         if (ret < 0)
1621                                 return ERR_PTR(ret);
1622                 }
1623
1624                 chg_pdata->tz_name = of_get_property(batt_reg_node,
1625                                                 "ti,thermal-zone", NULL);
1626
1627                 count = of_property_count_u32(batt_reg_node, "ti,temp-range");
1628                 temp_range_len = (count > 0) ? count : 0;
1629
1630                 count = of_property_count_u32(batt_reg_node,
1631                                         "ti,charge-current-limit");
1632                 if (count <= 0)
1633                         count = of_property_count_u32(batt_reg_node,
1634                                         "ti,charge-thermal-current-limit");
1635                 chg_current_lim_len = (count > 0) ? count : 0;
1636
1637                 count = of_property_count_u32(batt_reg_node,
1638                                         "ti,charge-thermal-voltage-limit");
1639                 chg_voltage_lim_len = (count > 0) ? count : 0;
1640
1641                 if (!temp_range_len)
1642                         goto skip_therm_profile;
1643
1644                 if (temp_range_len != chg_current_lim_len) {
1645                         dev_info(&client->dev,
1646                                 "current thermal profile is not correct\n");
1647                         goto skip_therm_profile;
1648                 }
1649
1650                 if (chg_voltage_lim_len && (temp_range_len != chg_voltage_lim_len)) {
1651                         dev_info(&client->dev,
1652                                 "voltage thermal profile is not correct\n");
1653                         goto skip_therm_profile;
1654                 }
1655
1656                 chg_pdata->temp_range = devm_kzalloc(&client->dev,
1657                                 sizeof(u32) * temp_range_len, GFP_KERNEL);
1658                 if (!chg_pdata->temp_range)
1659                         return ERR_PTR(-ENOMEM);
1660
1661                 ret = of_property_read_u32_array(batt_reg_node, "ti,temp-range",
1662                                 chg_pdata->temp_range, temp_range_len);
1663                 if (ret < 0)
1664                         return ERR_PTR(ret);
1665
1666                 chg_pdata->chg_current_limit = devm_kzalloc(&client->dev,
1667                                 sizeof(u32) * temp_range_len, GFP_KERNEL);
1668                 if (!chg_pdata->chg_current_limit)
1669                         return ERR_PTR(-ENOMEM);
1670
1671                 ret = of_property_read_u32_array(batt_reg_node,
1672                                 "ti,charge-current-limit",
1673                                 chg_pdata->chg_current_limit,
1674                                 temp_range_len);
1675                 if (ret < 0)
1676                         ret = of_property_read_u32_array(batt_reg_node,
1677                                 "ti,charge-thermal-current-limit",
1678                                         chg_pdata->chg_current_limit,
1679                                         temp_range_len);
1680                 if (ret < 0)
1681                         return ERR_PTR(ret);
1682
1683                 if (!chg_voltage_lim_len)
1684                         goto skip_thermal_volt_profle;
1685
1686                 chg_pdata->chg_thermal_voltage_limit =
1687                                         devm_kzalloc(&client->dev,
1688                                         sizeof(u32) * temp_range_len,
1689                                         GFP_KERNEL);
1690                 if (!chg_pdata->chg_thermal_voltage_limit)
1691                         return ERR_PTR(-ENOMEM);
1692
1693                 ret = of_property_read_u32_array(batt_reg_node,
1694                                 "ti,charge-thermal-voltage-limit",
1695                                 chg_pdata->chg_thermal_voltage_limit,
1696                                 temp_range_len);
1697                 if (ret < 0)
1698                         return ERR_PTR(ret);
1699
1700 skip_thermal_volt_profle:
1701                 chg_pdata->n_temp_profile = temp_range_len;
1702
1703 skip_therm_profile:
1704                 pdata->bcharger_pdata->consumer_supplies =
1705                                         batt_init_data->consumer_supplies;
1706                 pdata->bcharger_pdata->num_consumer_supplies =
1707                                         batt_init_data->num_consumer_supplies;
1708                 pdata->bcharger_pdata->max_charge_current_mA =
1709                                 batt_init_data->constraints.max_uA / 1000;
1710         }
1711
1712 vbus_node:
1713         vbus_reg_node = of_find_node_by_name(np, "vbus");
1714         if (vbus_reg_node) {
1715                 struct regulator_init_data *vbus_init_data;
1716
1717                 pdata->vbus_pdata = devm_kzalloc(&client->dev,
1718                         sizeof(*(pdata->vbus_pdata)), GFP_KERNEL);
1719                 if (!pdata->vbus_pdata)
1720                         return ERR_PTR(-ENOMEM);
1721
1722                 vbus_init_data = of_get_regulator_init_data(
1723                                         &client->dev, vbus_reg_node);
1724                 if (!vbus_init_data)
1725                         return ERR_PTR(-EINVAL);
1726
1727                 pdata->vbus_pdata->consumer_supplies =
1728                                 vbus_init_data->consumer_supplies;
1729                 pdata->vbus_pdata->num_consumer_supplies =
1730                                 vbus_init_data->num_consumer_supplies;
1731                 pdata->vbus_pdata->gpio_otg_iusb =
1732                                 of_get_named_gpio(vbus_reg_node,
1733                                         "ti,otg-iusb-gpio", 0);
1734         }
1735
1736         return pdata;
1737 }
1738
1739 static int bq2419x_probe(struct i2c_client *client,
1740                                 const struct i2c_device_id *id)
1741 {
1742         struct bq2419x_chip *bq2419x;
1743         struct bq2419x_platform_data *pdata = NULL;
1744         int ret = 0;
1745
1746         if (client->dev.platform_data)
1747                 pdata = client->dev.platform_data;
1748
1749         if (!pdata && client->dev.of_node) {
1750                 pdata = bq2419x_dt_parse(client);
1751                 if (IS_ERR(pdata)) {
1752                         ret = PTR_ERR(pdata);
1753                         dev_err(&client->dev, "Parsing of node failed, %d\n",
1754                                 ret);
1755                         return ret;
1756                 }
1757         }
1758
1759         if (!pdata) {
1760                 dev_err(&client->dev, "No Platform data");
1761                 return -EINVAL;
1762         }
1763
1764         bq2419x = devm_kzalloc(&client->dev, sizeof(*bq2419x), GFP_KERNEL);
1765         if (!bq2419x) {
1766                 dev_err(&client->dev, "Memory allocation failed\n");
1767                 return -ENOMEM;
1768         }
1769         bq2419x->charger_pdata = pdata->bcharger_pdata;
1770         bq2419x->vbus_pdata = pdata->vbus_pdata;
1771
1772         bq2419x->regmap = devm_regmap_init_i2c(client, &bq2419x_regmap_config);
1773         if (IS_ERR(bq2419x->regmap)) {
1774                 ret = PTR_ERR(bq2419x->regmap);
1775                 dev_err(&client->dev, "regmap init failed with err %d\n", ret);
1776                 return ret;
1777         }
1778
1779         bq2419x->dev = &client->dev;
1780         i2c_set_clientdata(client, bq2419x);
1781         bq2419x->irq = client->irq;
1782         mutex_init(&bq2419x->otg_mutex);
1783         bq2419x->is_otg_connected = 0;
1784
1785         ret = bq2419x_show_chip_version(bq2419x);
1786         if (ret < 0) {
1787                 dev_err(&client->dev, "version read failed %d\n", ret);
1788                 return ret;
1789         }
1790
1791         ret = sysfs_create_group(&client->dev.kobj, &bq2419x_attr_group);
1792         if (ret < 0) {
1793                 dev_err(&client->dev, "sysfs create failed %d\n", ret);
1794                 return ret;
1795         }
1796
1797         mutex_init(&bq2419x->mutex);
1798
1799         if (!pdata->bcharger_pdata) {
1800                 dev_info(&client->dev, "No battery charger supported\n");
1801                 ret = bq2419x_watchdog_init(bq2419x, 0, "PROBE");
1802                 if (ret < 0) {
1803                         dev_err(bq2419x->dev, "WDT disable failed: %d\n", ret);
1804                         goto scrub_mutex;
1805                 }
1806
1807                 ret = bq2419x_fault_clear_sts(bq2419x, NULL);
1808                 if (ret < 0) {
1809                         dev_err(bq2419x->dev, "fault clear status failed %d\n", ret);
1810                         goto scrub_mutex;
1811                 }
1812                 goto skip_bcharger_init;
1813         }
1814
1815         bq2419x->auto_recharge_time_power_off =
1816                         pdata->bcharger_pdata->auto_recharge_time_power_off;
1817         bq2419x->wdt_time_sec = pdata->bcharger_pdata->wdt_timeout;
1818         bq2419x->chg_restart_time = pdata->bcharger_pdata->chg_restart_time;
1819         bq2419x->battery_presense = true;
1820         bq2419x->last_temp = -1000;
1821         bq2419x->disable_suspend_during_charging =
1822                         pdata->bcharger_pdata->disable_suspend_during_charging;
1823         bq2419x->auto_recharge_time_supend =
1824                         pdata->bcharger_pdata->auto_recharge_time_supend;
1825         bq2419x->chg_status_gpio = pdata->bcharger_pdata->chg_status_gpio;
1826
1827         bq2419x_process_charger_plat_data(bq2419x, pdata->bcharger_pdata);
1828
1829         ret = bq2419x_charger_init(bq2419x);
1830         if (ret < 0) {
1831                 dev_err(bq2419x->dev, "Charger init failed: %d\n", ret);
1832                 goto scrub_mutex;
1833         }
1834
1835         ret = bq2419x_init_charger_regulator(bq2419x, pdata);
1836         if (ret < 0) {
1837                 dev_err(&client->dev,
1838                         "Charger regualtor init failed %d\n", ret);
1839                 goto scrub_mutex;
1840         }
1841
1842         bq2419x_charger_bci.polling_time_sec =
1843                         pdata->bcharger_pdata->temp_polling_time_sec;
1844         bq2419x_charger_bci.tz_name = pdata->bcharger_pdata->tz_name;
1845         bq2419x->bc_dev = battery_charger_register(bq2419x->dev,
1846                         &bq2419x_charger_bci, bq2419x);
1847         if (IS_ERR(bq2419x->bc_dev)) {
1848                 ret = PTR_ERR(bq2419x->bc_dev);
1849                 dev_err(bq2419x->dev, "battery charger register failed: %d\n",
1850                         ret);
1851                 goto scrub_mutex;
1852         }
1853
1854         INIT_DELAYED_WORK(&bq2419x->wdt_restart_wq, bq2419x_wdt_restart_wq);
1855         ret = bq2419x_watchdog_init(bq2419x, bq2419x->wdt_time_sec, "PROBE");
1856         if (ret < 0) {
1857                 dev_err(bq2419x->dev, "BQWDT init failed %d\n", ret);
1858                 goto scrub_wq;
1859         }
1860
1861         INIT_DELAYED_WORK(&bq2419x->otg_reset_work,
1862                                 bq2419x_otg_reset_work_handler);
1863         ret = bq2419x_fault_clear_sts(bq2419x, NULL);
1864         if (ret < 0) {
1865                 dev_err(bq2419x->dev, "fault clear status failed %d\n", ret);
1866                 goto scrub_wq;
1867         }
1868
1869         ret = devm_request_threaded_irq(bq2419x->dev, bq2419x->irq, NULL,
1870                 bq2419x_irq, IRQF_ONESHOT | IRQF_TRIGGER_FALLING,
1871                         dev_name(bq2419x->dev), bq2419x);
1872         if (ret < 0) {
1873                 dev_warn(bq2419x->dev, "request IRQ %d fail, err = %d\n",
1874                                 bq2419x->irq, ret);
1875                 dev_info(bq2419x->dev,
1876                         "Supporting bq driver without interrupt\n");
1877                 ret = 0;
1878         }
1879
1880         if (gpio_is_valid(bq2419x->chg_status_gpio)) {
1881                 ret = devm_gpio_request(bq2419x->dev, bq2419x->chg_status_gpio,
1882                                                 "charger_led");
1883                 if (ret < 0) {
1884                         dev_err(bq2419x->dev, "error: can't request GPIO%d\n",
1885                                 bq2419x->chg_status_gpio);
1886                 } else {
1887                         ret = gpio_direction_output(bq2419x->chg_status_gpio, 0);
1888                         if (ret < 0) {
1889                                 dev_err(bq2419x->dev,
1890                                         "can't setup GPIO%d as Output\n",
1891                                         bq2419x->chg_status_gpio);
1892                         }
1893                 }
1894         }
1895
1896 skip_bcharger_init:
1897         ret = bq2419x_init_vbus_regulator(bq2419x, pdata);
1898         if (ret < 0) {
1899                 dev_err(&client->dev, "VBUS regulator init failed %d\n", ret);
1900                 goto scrub_wq;
1901         }
1902
1903         /* enable charging */
1904         ret = bq2419x_charger_enable(bq2419x);
1905         if (ret < 0)
1906                 goto scrub_wq;
1907
1908         return 0;
1909 scrub_wq:
1910         if (pdata->bcharger_pdata) {
1911                 cancel_delayed_work(&bq2419x->wdt_restart_wq);
1912                 battery_charger_unregister(bq2419x->bc_dev);
1913         }
1914 scrub_mutex:
1915         mutex_destroy(&bq2419x->mutex);
1916         mutex_destroy(&bq2419x->otg_mutex);
1917         return ret;
1918 }
1919
1920 static int bq2419x_remove(struct i2c_client *client)
1921 {
1922         struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1923
1924         if (bq2419x->battery_presense) {
1925                 battery_charger_unregister(bq2419x->bc_dev);
1926                 cancel_delayed_work(&bq2419x->wdt_restart_wq);
1927         }
1928         mutex_destroy(&bq2419x->mutex);
1929         mutex_destroy(&bq2419x->otg_mutex);
1930         cancel_delayed_work_sync(&bq2419x->otg_reset_work);
1931         return 0;
1932 }
1933
1934 static void bq2419x_shutdown(struct i2c_client *client)
1935 {
1936         struct bq2419x_chip *bq2419x = i2c_get_clientdata(client);
1937         struct device *dev = &client->dev;
1938         int ret;
1939         int next_poweron_time = 0;
1940
1941         if (!bq2419x->battery_presense)
1942                 return;
1943
1944         if (!bq2419x->cable_connected)
1945                 goto end;
1946
1947         ret = bq2419x_reset_wdt(bq2419x, "SHUTDOWN");
1948         if (ret < 0)
1949                 dev_err(bq2419x->dev, "Reset WDT failed: %d\n", ret);
1950
1951         if (bq2419x->chg_status == BATTERY_CHARGING_DONE) {
1952                 dev_info(bq2419x->dev, "Battery charging done\n");
1953                 goto end;
1954         }
1955
1956         if (bq2419x->in_current_limit <= 500) {
1957                 dev_info(bq2419x->dev, "Battery charging with 500mA\n");
1958                 next_poweron_time = bq2419x->auto_recharge_time_power_off;
1959         } else {
1960                 dev_info(bq2419x->dev, "Battery charging with high current\n");
1961                 next_poweron_time = bq2419x->wdt_refresh_timeout;
1962         }
1963
1964         ret = battery_charging_system_reset_after(bq2419x->bc_dev,
1965                                 next_poweron_time);
1966         if (ret < 0)
1967                 dev_err(dev, "System poweron after %d config failed %d\n",
1968                         next_poweron_time, ret);
1969 end:
1970         if (next_poweron_time)
1971                 dev_info(dev, "System-charger will power-ON after %d sec\n",
1972                                 next_poweron_time);
1973         else
1974                 dev_info(bq2419x->dev, "System-charger will not power-ON\n");
1975
1976         battery_charging_system_power_on_usb_event(bq2419x->bc_dev);
1977         cancel_delayed_work_sync(&bq2419x->otg_reset_work);
1978 }
1979
1980 #ifdef CONFIG_PM_SLEEP
1981 static int bq2419x_suspend(struct device *dev)
1982 {
1983         struct bq2419x_chip *bq2419x = dev_get_drvdata(dev);
1984         int next_wakeup = 0;
1985         int ret;
1986
1987         if (!bq2419x->battery_presense)
1988                 return 0;
1989
1990         battery_charging_restart_cancel(bq2419x->bc_dev);
1991
1992         if (!bq2419x->cable_connected)
1993                 goto end;
1994
1995         ret = bq2419x_reset_wdt(bq2419x, "Suspend");
1996         if (ret < 0)
1997                 dev_err(bq2419x->dev, "Reset WDT failed: %d\n", ret);
1998
1999         if (bq2419x->chg_status == BATTERY_CHARGING_DONE) {
2000                 dev_info(bq2419x->dev, "Battery charging done\n");
2001                 goto end;
2002         }
2003
2004         if (bq2419x->in_current_limit <= 500) {
2005                 dev_info(bq2419x->dev, "Battery charging with 500mA\n");
2006                 next_wakeup = bq2419x->auto_recharge_time_supend;
2007         } else {
2008                 dev_info(bq2419x->dev, "Battery charging with high current\n");
2009                 next_wakeup = bq2419x->wdt_refresh_timeout;
2010         }
2011
2012         battery_charging_wakeup(bq2419x->bc_dev, next_wakeup);
2013 end:
2014         if (next_wakeup)
2015                 dev_info(dev, "System-charger will resume after %d sec\n",
2016                                 next_wakeup);
2017         else
2018                 dev_info(dev, "System-charger will not have resume time\n");
2019
2020         if (next_wakeup == bq2419x->wdt_refresh_timeout)
2021                 return 0;
2022
2023         ret = bq2419x_set_charging_current_suspend(bq2419x, 500);
2024         if (ret < 0)
2025                 dev_err(bq2419x->dev, "Config of charging failed: %d\n", ret);
2026         return ret;
2027 }
2028
2029 static int bq2419x_resume(struct device *dev)
2030 {
2031         int ret = 0;
2032         struct bq2419x_chip *bq2419x = dev_get_drvdata(dev);
2033         unsigned int val;
2034
2035         if (!bq2419x->battery_presense)
2036                 return 0;
2037
2038         ret = bq2419x_fault_clear_sts(bq2419x, &val);
2039         if (ret < 0) {
2040                 dev_err(bq2419x->dev, "fault clear status failed %d\n", ret);
2041                 return ret;
2042         }
2043
2044         if (val & BQ2419x_FAULT_WATCHDOG_FAULT) {
2045                 bq_chg_err(bq2419x, "Watchdog Timer Expired\n");
2046
2047                 ret = bq2419x_reconfigure_charger_param(bq2419x,
2048                                 "WDT-EXP-RESUME");
2049                 if (ret < 0) {
2050                         dev_err(bq2419x->dev, "BQ reconfig failed %d\n", ret);
2051                         return ret;
2052                 }
2053         } else {
2054                 ret = bq2419x_reset_wdt(bq2419x, "Resume");
2055                 if (ret < 0)
2056                         dev_err(bq2419x->dev, "Reset WDT failed: %d\n", ret);
2057         }
2058
2059         if (val & BQ2419x_FAULT_CHRG_SAFTY) {
2060                 bq_chg_err(bq2419x, "Safety timer Expired\n");
2061                 ret = bq2419x_handle_safety_timer_expire(bq2419x);
2062                 if (ret < 0) {
2063                         dev_err(bq2419x->dev,
2064                                 "Handling of safty timer expire failed: %d\n",
2065                                 ret);
2066                 }
2067         }
2068
2069         return 0;
2070 };
2071 #endif
2072
2073 static const struct dev_pm_ops bq2419x_pm_ops = {
2074         SET_SYSTEM_SLEEP_PM_OPS(bq2419x_suspend, bq2419x_resume)
2075 };
2076
2077 static const struct i2c_device_id bq2419x_id[] = {
2078         {.name = "bq2419x",},
2079         {},
2080 };
2081 MODULE_DEVICE_TABLE(i2c, bq2419x_id);
2082
2083 static struct i2c_driver bq2419x_i2c_driver = {
2084         .driver = {
2085                 .name   = "bq2419x",
2086                 .owner  = THIS_MODULE,
2087                 .pm = &bq2419x_pm_ops,
2088         },
2089         .probe          = bq2419x_probe,
2090         .remove         = bq2419x_remove,
2091         .shutdown       = bq2419x_shutdown,
2092         .id_table       = bq2419x_id,
2093 };
2094
2095 static int __init bq2419x_module_init(void)
2096 {
2097         return i2c_add_driver(&bq2419x_i2c_driver);
2098 }
2099 subsys_initcall(bq2419x_module_init);
2100
2101 static void __exit bq2419x_cleanup(void)
2102 {
2103         i2c_del_driver(&bq2419x_i2c_driver);
2104 }
2105 module_exit(bq2419x_cleanup);
2106
2107 MODULE_DESCRIPTION("BQ24190/BQ24192/BQ24192i/BQ24193 battery charger driver");
2108 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
2109 MODULE_AUTHOR("Syed Rafiuddin <srafiuddin@nvidia.com");
2110 MODULE_LICENSE("GPL v2");