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