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