drivers/power/supply/bq24257_charger.c

   1 /*
   2  * TI BQ24257 charger driver
   3  *
   4  * Copyright (C) 2015 Intel Corporation
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * Datasheets:
  17  * http://www.ti.com/product/bq24250
  18  * http://www.ti.com/product/bq24251
  19  * http://www.ti.com/product/bq24257
  20  */
  21
  22 #include <linux/module.h>
  23 #include <linux/i2c.h>
  24 #include <linux/power_supply.h>
  25 #include <linux/regmap.h>
  26 #include <linux/types.h>
  27 #include <linux/gpio/consumer.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/delay.h>
  30
  31 #include <linux/acpi.h>
  32 #include <linux/of.h>
  33
  34 #define BQ24257_REG_1                   0x00
  35 #define BQ24257_REG_2                   0x01
  36 #define BQ24257_REG_3                   0x02
  37 #define BQ24257_REG_4                   0x03
  38 #define BQ24257_REG_5                   0x04
  39 #define BQ24257_REG_6                   0x05
  40 #define BQ24257_REG_7                   0x06
  41
  42 #define BQ24257_MANUFACTURER            "Texas Instruments"
  43 #define BQ24257_PG_GPIO                 "pg"
  44
  45 #define BQ24257_ILIM_SET_DELAY          1000    /* msec */
  46
  47 /*
  48  * When adding support for new devices make sure that enum bq2425x_chip and
  49  * bq2425x_chip_name[] always stay in sync!
  50  */
  51 enum bq2425x_chip {
  52         BQ24250,
  53         BQ24251,
  54         BQ24257,
  55 };
  56
  57 static const char *const bq2425x_chip_name[] = {
  58         "bq24250",
  59         "bq24251",
  60         "bq24257",
  61 };
  62
  63 enum bq24257_fields {
  64         F_WD_FAULT, F_WD_EN, F_STAT, F_FAULT,                       /* REG 1 */
  65         F_RESET, F_IILIMIT, F_EN_STAT, F_EN_TERM, F_CE, F_HZ_MODE,  /* REG 2 */
  66         F_VBAT, F_USB_DET,                                          /* REG 3 */
  67         F_ICHG, F_ITERM,                                            /* REG 4 */
  68         F_LOOP_STATUS, F_LOW_CHG, F_DPDM_EN, F_CE_STATUS, F_VINDPM, /* REG 5 */
  69         F_X2_TMR_EN, F_TMR, F_SYSOFF, F_TS_EN, F_TS_STAT,           /* REG 6 */
  70         F_VOVP, F_CLR_VDP, F_FORCE_BATDET, F_FORCE_PTM,             /* REG 7 */
  71
  72         F_MAX_FIELDS
  73 };
  74
  75 /* initial field values, converted from uV/uA */
  76 struct bq24257_init_data {
  77         u8 ichg;        /* charge current      */
  78         u8 vbat;        /* regulation voltage  */
  79         u8 iterm;       /* termination current */
  80         u8 iilimit;     /* input current limit */
  81         u8 vovp;        /* over voltage protection voltage */
  82         u8 vindpm;      /* VDMP input threshold voltage */
  83 };
  84
  85 struct bq24257_state {
  86         u8 status;
  87         u8 fault;
  88         bool power_good;
  89 };
  90
  91 struct bq24257_device {
  92         struct i2c_client *client;
  93         struct device *dev;
  94         struct power_supply *charger;
  95
  96         enum bq2425x_chip chip;
  97
  98         struct regmap *rmap;
  99         struct regmap_field *rmap_fields[F_MAX_FIELDS];
 100
 101         struct gpio_desc *pg;
 102
 103         struct delayed_work iilimit_setup_work;
 104
 105         struct bq24257_init_data init_data;
 106         struct bq24257_state state;
 107
 108         struct mutex lock; /* protect state data */
 109
 110         bool iilimit_autoset_enable;
 111 };
 112
 113 static bool bq24257_is_volatile_reg(struct device *dev, unsigned int reg)
 114 {
 115         switch (reg) {
 116         case BQ24257_REG_2:
 117         case BQ24257_REG_4:
 118                 return false;
 119
 120         default:
 121                 return true;
 122         }
 123 }
 124
 125 static const struct regmap_config bq24257_regmap_config = {
 126         .reg_bits = 8,
 127         .val_bits = 8,
 128
 129         .max_register = BQ24257_REG_7,
 130         .cache_type = REGCACHE_RBTREE,
 131
 132         .volatile_reg = bq24257_is_volatile_reg,
 133 };
 134
 135 static const struct reg_field bq24257_reg_fields[] = {
 136         /* REG 1 */
 137         [F_WD_FAULT]            = REG_FIELD(BQ24257_REG_1, 7, 7),
 138         [F_WD_EN]               = REG_FIELD(BQ24257_REG_1, 6, 6),
 139         [F_STAT]                = REG_FIELD(BQ24257_REG_1, 4, 5),
 140         [F_FAULT]               = REG_FIELD(BQ24257_REG_1, 0, 3),
 141         /* REG 2 */
 142         [F_RESET]               = REG_FIELD(BQ24257_REG_2, 7, 7),
 143         [F_IILIMIT]             = REG_FIELD(BQ24257_REG_2, 4, 6),
 144         [F_EN_STAT]             = REG_FIELD(BQ24257_REG_2, 3, 3),
 145         [F_EN_TERM]             = REG_FIELD(BQ24257_REG_2, 2, 2),
 146         [F_CE]                  = REG_FIELD(BQ24257_REG_2, 1, 1),
 147         [F_HZ_MODE]             = REG_FIELD(BQ24257_REG_2, 0, 0),
 148         /* REG 3 */
 149         [F_VBAT]                = REG_FIELD(BQ24257_REG_3, 2, 7),
 150         [F_USB_DET]             = REG_FIELD(BQ24257_REG_3, 0, 1),
 151         /* REG 4 */
 152         [F_ICHG]                = REG_FIELD(BQ24257_REG_4, 3, 7),
 153         [F_ITERM]               = REG_FIELD(BQ24257_REG_4, 0, 2),
 154         /* REG 5 */
 155         [F_LOOP_STATUS]         = REG_FIELD(BQ24257_REG_5, 6, 7),
 156         [F_LOW_CHG]             = REG_FIELD(BQ24257_REG_5, 5, 5),
 157         [F_DPDM_EN]             = REG_FIELD(BQ24257_REG_5, 4, 4),
 158         [F_CE_STATUS]           = REG_FIELD(BQ24257_REG_5, 3, 3),
 159         [F_VINDPM]              = REG_FIELD(BQ24257_REG_5, 0, 2),
 160         /* REG 6 */
 161         [F_X2_TMR_EN]           = REG_FIELD(BQ24257_REG_6, 7, 7),
 162         [F_TMR]                 = REG_FIELD(BQ24257_REG_6, 5, 6),
 163         [F_SYSOFF]              = REG_FIELD(BQ24257_REG_6, 4, 4),
 164         [F_TS_EN]               = REG_FIELD(BQ24257_REG_6, 3, 3),
 165         [F_TS_STAT]             = REG_FIELD(BQ24257_REG_6, 0, 2),
 166         /* REG 7 */
 167         [F_VOVP]                = REG_FIELD(BQ24257_REG_7, 5, 7),
 168         [F_CLR_VDP]             = REG_FIELD(BQ24257_REG_7, 4, 4),
 169         [F_FORCE_BATDET]        = REG_FIELD(BQ24257_REG_7, 3, 3),
 170         [F_FORCE_PTM]           = REG_FIELD(BQ24257_REG_7, 2, 2)
 171 };
 172
 173 static const u32 bq24257_vbat_map[] = {
 174         3500000, 3520000, 3540000, 3560000, 3580000, 3600000, 3620000, 3640000,
 175         3660000, 3680000, 3700000, 3720000, 3740000, 3760000, 3780000, 3800000,
 176         3820000, 3840000, 3860000, 3880000, 3900000, 3920000, 3940000, 3960000,
 177         3980000, 4000000, 4020000, 4040000, 4060000, 4080000, 4100000, 4120000,
 178         4140000, 4160000, 4180000, 4200000, 4220000, 4240000, 4260000, 4280000,
 179         4300000, 4320000, 4340000, 4360000, 4380000, 4400000, 4420000, 4440000
 180 };
 181
 182 #define BQ24257_VBAT_MAP_SIZE           ARRAY_SIZE(bq24257_vbat_map)
 183
 184 static const u32 bq24257_ichg_map[] = {
 185         500000, 550000, 600000, 650000, 700000, 750000, 800000, 850000, 900000,
 186         950000, 1000000, 1050000, 1100000, 1150000, 1200000, 1250000, 1300000,
 187         1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000,
 188         1750000, 1800000, 1850000, 1900000, 1950000, 2000000
 189 };
 190
 191 #define BQ24257_ICHG_MAP_SIZE           ARRAY_SIZE(bq24257_ichg_map)
 192
 193 static const u32 bq24257_iterm_map[] = {
 194         50000, 75000, 100000, 125000, 150000, 175000, 200000, 225000
 195 };
 196
 197 #define BQ24257_ITERM_MAP_SIZE          ARRAY_SIZE(bq24257_iterm_map)
 198
 199 static const u32 bq24257_iilimit_map[] = {
 200         100000, 150000, 500000, 900000, 1500000, 2000000
 201 };
 202
 203 #define BQ24257_IILIMIT_MAP_SIZE        ARRAY_SIZE(bq24257_iilimit_map)
 204
 205 static const u32 bq24257_vovp_map[] = {
 206         6000000, 6500000, 7000000, 8000000, 9000000, 9500000, 10000000,
 207         10500000
 208 };
 209
 210 #define BQ24257_VOVP_MAP_SIZE           ARRAY_SIZE(bq24257_vovp_map)
 211
 212 static const u32 bq24257_vindpm_map[] = {
 213         4200000, 4280000, 4360000, 4440000, 4520000, 4600000, 4680000,
 214         4760000
 215 };
 216
 217 #define BQ24257_VINDPM_MAP_SIZE         ARRAY_SIZE(bq24257_vindpm_map)
 218
 219 static int bq24257_field_read(struct bq24257_device *bq,
 220                               enum bq24257_fields field_id)
 221 {
 222         int ret;
 223         int val;
 224
 225         ret = regmap_field_read(bq->rmap_fields[field_id], &val);
 226         if (ret < 0)
 227                 return ret;
 228
 229         return val;
 230 }
 231
 232 static int bq24257_field_write(struct bq24257_device *bq,
 233                                enum bq24257_fields field_id, u8 val)
 234 {
 235         return regmap_field_write(bq->rmap_fields[field_id], val);
 236 }
 237
 238 static u8 bq24257_find_idx(u32 value, const u32 *map, u8 map_size)
 239 {
 240         u8 idx;
 241
 242         for (idx = 1; idx < map_size; idx++)
 243                 if (value < map[idx])
 244                         break;
 245
 246         return idx - 1;
 247 }
 248
 249 enum bq24257_status {
 250         STATUS_READY,
 251         STATUS_CHARGE_IN_PROGRESS,
 252         STATUS_CHARGE_DONE,
 253         STATUS_FAULT,
 254 };
 255
 256 enum bq24257_fault {
 257         FAULT_NORMAL,
 258         FAULT_INPUT_OVP,
 259         FAULT_INPUT_UVLO,
 260         FAULT_SLEEP,
 261         FAULT_BAT_TS,
 262         FAULT_BAT_OVP,
 263         FAULT_TS,
 264         FAULT_TIMER,
 265         FAULT_NO_BAT,
 266         FAULT_ISET,
 267         FAULT_INPUT_LDO_LOW,
 268 };
 269
 270 static int bq24257_get_input_current_limit(struct bq24257_device *bq,
 271                                            union power_supply_propval *val)
 272 {
 273         int ret;
 274
 275         ret = bq24257_field_read(bq, F_IILIMIT);
 276         if (ret < 0)
 277                 return ret;
 278
 279         /*
 280          * The "External ILIM" and "Production & Test" modes are not exposed
 281          * through this driver and not being covered by the lookup table.
 282          * Should such a mode have become active let's return an error rather
 283          * than exceeding the bounds of the lookup table and returning
 284          * garbage.
 285          */
 286         if (ret >= BQ24257_IILIMIT_MAP_SIZE)
 287                 return -ENODATA;
 288
 289         val->intval = bq24257_iilimit_map[ret];
 290
 291         return 0;
 292 }
 293
 294 static int bq24257_set_input_current_limit(struct bq24257_device *bq,
 295                                         const union power_supply_propval *val)
 296 {
 297         /*
 298          * Address the case where the user manually sets an input current limit
 299          * while the charger auto-detection mechanism is is active. In this
 300          * case we want to abort and go straight to the user-specified value.
 301          */
 302         if (bq->iilimit_autoset_enable)
 303                 cancel_delayed_work_sync(&bq->iilimit_setup_work);
 304
 305         return bq24257_field_write(bq, F_IILIMIT,
 306                                    bq24257_find_idx(val->intval,
 307                                                     bq24257_iilimit_map,
 308                                                     BQ24257_IILIMIT_MAP_SIZE));
 309 }
 310
 311 static int bq24257_power_supply_get_property(struct power_supply *psy,
 312                                              enum power_supply_property psp,
 313                                              union power_supply_propval *val)
 314 {
 315         struct bq24257_device *bq = power_supply_get_drvdata(psy);
 316         struct bq24257_state state;
 317
 318         mutex_lock(&bq->lock);
 319         state = bq->state;
 320         mutex_unlock(&bq->lock);
 321
 322         switch (psp) {
 323         case POWER_SUPPLY_PROP_STATUS:
 324                 if (!state.power_good)
 325                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 326                 else if (state.status == STATUS_READY)
 327                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 328                 else if (state.status == STATUS_CHARGE_IN_PROGRESS)
 329                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 330                 else if (state.status == STATUS_CHARGE_DONE)
 331                         val->intval = POWER_SUPPLY_STATUS_FULL;
 332                 else
 333                         val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
 334                 break;
 335
 336         case POWER_SUPPLY_PROP_MANUFACTURER:
 337                 val->strval = BQ24257_MANUFACTURER;
 338                 break;
 339
 340         case POWER_SUPPLY_PROP_MODEL_NAME:
 341                 val->strval = bq2425x_chip_name[bq->chip];
 342                 break;
 343
 344         case POWER_SUPPLY_PROP_ONLINE:
 345                 val->intval = state.power_good;
 346                 break;
 347
 348         case POWER_SUPPLY_PROP_HEALTH:
 349                 switch (state.fault) {
 350                 case FAULT_NORMAL:
 351                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
 352                         break;
 353
 354                 case FAULT_INPUT_OVP:
 355                 case FAULT_BAT_OVP:
 356                         val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 357                         break;
 358
 359                 case FAULT_TS:
 360                 case FAULT_BAT_TS:
 361                         val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
 362                         break;
 363
 364                 case FAULT_TIMER:
 365                         val->intval = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
 366                         break;
 367
 368                 default:
 369                         val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 370                         break;
 371                 }
 372
 373                 break;
 374
 375         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 376                 val->intval = bq24257_ichg_map[bq->init_data.ichg];
 377                 break;
 378
 379         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 380                 val->intval = bq24257_ichg_map[BQ24257_ICHG_MAP_SIZE - 1];
 381                 break;
 382
 383         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 384                 val->intval = bq24257_vbat_map[bq->init_data.vbat];
 385                 break;
 386
 387         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 388                 val->intval = bq24257_vbat_map[BQ24257_VBAT_MAP_SIZE - 1];
 389                 break;
 390
 391         case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
 392                 val->intval = bq24257_iterm_map[bq->init_data.iterm];
 393                 break;
 394
 395         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 396                 return bq24257_get_input_current_limit(bq, val);
 397
 398         default:
 399                 return -EINVAL;
 400         }
 401
 402         return 0;
 403 }
 404
 405 static int bq24257_power_supply_set_property(struct power_supply *psy,
 406                                         enum power_supply_property prop,
 407                                         const union power_supply_propval *val)
 408 {
 409         struct bq24257_device *bq = power_supply_get_drvdata(psy);
 410
 411         switch (prop) {
 412         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 413                 return bq24257_set_input_current_limit(bq, val);
 414         default:
 415                 return -EINVAL;
 416         }
 417 }
 418
 419 static int bq24257_power_supply_property_is_writeable(struct power_supply *psy,
 420                                         enum power_supply_property psp)
 421 {
 422         switch (psp) {
 423         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 424                 return true;
 425         default:
 426                 return false;
 427         }
 428 }
 429
 430 static int bq24257_get_chip_state(struct bq24257_device *bq,
 431                                   struct bq24257_state *state)
 432 {
 433         int ret;
 434
 435         ret = bq24257_field_read(bq, F_STAT);
 436         if (ret < 0)
 437                 return ret;
 438
 439         state->status = ret;
 440
 441         ret = bq24257_field_read(bq, F_FAULT);
 442         if (ret < 0)
 443                 return ret;
 444
 445         state->fault = ret;
 446
 447         if (bq->pg)
 448                 state->power_good = !gpiod_get_value_cansleep(bq->pg);
 449         else
 450                 /*
 451                  * If we have a chip without a dedicated power-good GPIO or
 452                  * some other explicit bit that would provide this information
 453                  * assume the power is good if there is no supply related
 454                  * fault - and not good otherwise. There is a possibility for
 455                  * other errors to mask that power in fact is not good but this
 456                  * is probably the best we can do here.
 457                  */
 458                 switch (state->fault) {
 459                 case FAULT_INPUT_OVP:
 460                 case FAULT_INPUT_UVLO:
 461                 case FAULT_INPUT_LDO_LOW:
 462                         state->power_good = false;
 463                         break;
 464                 default:
 465                         state->power_good = true;
 466                 }
 467
 468         return 0;
 469 }
 470
 471 static bool bq24257_state_changed(struct bq24257_device *bq,
 472                                   struct bq24257_state *new_state)
 473 {
 474         int ret;
 475
 476         mutex_lock(&bq->lock);
 477         ret = (bq->state.status != new_state->status ||
 478                bq->state.fault != new_state->fault ||
 479                bq->state.power_good != new_state->power_good);
 480         mutex_unlock(&bq->lock);
 481
 482         return ret;
 483 }
 484
 485 enum bq24257_loop_status {
 486         LOOP_STATUS_NONE,
 487         LOOP_STATUS_IN_DPM,
 488         LOOP_STATUS_IN_CURRENT_LIMIT,
 489         LOOP_STATUS_THERMAL,
 490 };
 491
 492 enum bq24257_in_ilimit {
 493         IILIMIT_100,
 494         IILIMIT_150,
 495         IILIMIT_500,
 496         IILIMIT_900,
 497         IILIMIT_1500,
 498         IILIMIT_2000,
 499         IILIMIT_EXT,
 500         IILIMIT_NONE,
 501 };
 502
 503 enum bq24257_vovp {
 504         VOVP_6000,
 505         VOVP_6500,
 506         VOVP_7000,
 507         VOVP_8000,
 508         VOVP_9000,
 509         VOVP_9500,
 510         VOVP_10000,
 511         VOVP_10500
 512 };
 513
 514 enum bq24257_vindpm {
 515         VINDPM_4200,
 516         VINDPM_4280,
 517         VINDPM_4360,
 518         VINDPM_4440,
 519         VINDPM_4520,
 520         VINDPM_4600,
 521         VINDPM_4680,
 522         VINDPM_4760
 523 };
 524
 525 enum bq24257_port_type {
 526         PORT_TYPE_DCP,          /* Dedicated Charging Port */
 527         PORT_TYPE_CDP,          /* Charging Downstream Port */
 528         PORT_TYPE_SDP,          /* Standard Downstream Port */
 529         PORT_TYPE_NON_STANDARD,
 530 };
 531
 532 enum bq24257_safety_timer {
 533         SAFETY_TIMER_45,
 534         SAFETY_TIMER_360,
 535         SAFETY_TIMER_540,
 536         SAFETY_TIMER_NONE,
 537 };
 538
 539 static int bq24257_iilimit_autoset(struct bq24257_device *bq)
 540 {
 541         int loop_status;
 542         int iilimit;
 543         int port_type;
 544         int ret;
 545         const u8 new_iilimit[] = {
 546                 [PORT_TYPE_DCP] = IILIMIT_2000,
 547                 [PORT_TYPE_CDP] = IILIMIT_2000,
 548                 [PORT_TYPE_SDP] = IILIMIT_500,
 549                 [PORT_TYPE_NON_STANDARD] = IILIMIT_500
 550         };
 551
 552         ret = bq24257_field_read(bq, F_LOOP_STATUS);
 553         if (ret < 0)
 554                 goto error;
 555
 556         loop_status = ret;
 557
 558         ret = bq24257_field_read(bq, F_IILIMIT);
 559         if (ret < 0)
 560                 goto error;
 561
 562         iilimit = ret;
 563
 564         /*
 565          * All USB ports should be able to handle 500mA. If not, DPM will lower
 566          * the charging current to accommodate the power source. No need to set
 567          * a lower IILIMIT value.
 568          */
 569         if (loop_status == LOOP_STATUS_IN_DPM && iilimit == IILIMIT_500)
 570                 return 0;
 571
 572         ret = bq24257_field_read(bq, F_USB_DET);
 573         if (ret < 0)
 574                 goto error;
 575
 576         port_type = ret;
 577
 578         ret = bq24257_field_write(bq, F_IILIMIT, new_iilimit[port_type]);
 579         if (ret < 0)
 580                 goto error;
 581
 582         ret = bq24257_field_write(bq, F_TMR, SAFETY_TIMER_360);
 583         if (ret < 0)
 584                 goto error;
 585
 586         ret = bq24257_field_write(bq, F_CLR_VDP, 1);
 587         if (ret < 0)
 588                 goto error;
 589
 590         dev_dbg(bq->dev, "port/loop = %d/%d -> iilimit = %d\n",
 591                 port_type, loop_status, new_iilimit[port_type]);
 592
 593         return 0;
 594
 595 error:
 596         dev_err(bq->dev, "%s: Error communicating with the chip.\n", __func__);
 597         return ret;
 598 }
 599
 600 static void bq24257_iilimit_setup_work(struct work_struct *work)
 601 {
 602         struct bq24257_device *bq = container_of(work, struct bq24257_device,
 603                                                  iilimit_setup_work.work);
 604
 605         bq24257_iilimit_autoset(bq);
 606 }
 607
 608 static void bq24257_handle_state_change(struct bq24257_device *bq,
 609                                         struct bq24257_state *new_state)
 610 {
 611         int ret;
 612         struct bq24257_state old_state;
 613
 614         mutex_lock(&bq->lock);
 615         old_state = bq->state;
 616         mutex_unlock(&bq->lock);
 617
 618         /*
 619          * Handle BQ2425x state changes observing whether the D+/D- based input
 620          * current limit autoset functionality is enabled.
 621          */
 622         if (!new_state->power_good) {
 623                 dev_dbg(bq->dev, "Power removed\n");
 624                 if (bq->iilimit_autoset_enable) {
 625                         cancel_delayed_work_sync(&bq->iilimit_setup_work);
 626
 627                         /* activate D+/D- port detection algorithm */
 628                         ret = bq24257_field_write(bq, F_DPDM_EN, 1);
 629                         if (ret < 0)
 630                                 goto error;
 631                 }
 632                 /*
 633                  * When power is removed always return to the default input
 634                  * current limit as configured during probe.
 635                  */
 636                 ret = bq24257_field_write(bq, F_IILIMIT, bq->init_data.iilimit);
 637                 if (ret < 0)
 638                         goto error;
 639         } else if (!old_state.power_good) {
 640                 dev_dbg(bq->dev, "Power inserted\n");
 641
 642                 if (bq->iilimit_autoset_enable)
 643                         /* configure input current limit */
 644                         schedule_delayed_work(&bq->iilimit_setup_work,
 645                                       msecs_to_jiffies(BQ24257_ILIM_SET_DELAY));
 646         } else if (new_state->fault == FAULT_NO_BAT) {
 647                 dev_warn(bq->dev, "Battery removed\n");
 648         } else if (new_state->fault == FAULT_TIMER) {
 649                 dev_err(bq->dev, "Safety timer expired! Battery dead?\n");
 650         }
 651
 652         return;
 653
 654 error:
 655         dev_err(bq->dev, "%s: Error communicating with the chip.\n", __func__);
 656 }
 657
 658 static irqreturn_t bq24257_irq_handler_thread(int irq, void *private)
 659 {
 660         int ret;
 661         struct bq24257_device *bq = private;
 662         struct bq24257_state state;
 663
 664         ret = bq24257_get_chip_state(bq, &state);
 665         if (ret < 0)
 666                 return IRQ_HANDLED;
 667
 668         if (!bq24257_state_changed(bq, &state))
 669                 return IRQ_HANDLED;
 670
 671         dev_dbg(bq->dev, "irq(state changed): status/fault/pg = %d/%d/%d\n",
 672                 state.status, state.fault, state.power_good);
 673
 674         bq24257_handle_state_change(bq, &state);
 675
 676         mutex_lock(&bq->lock);
 677         bq->state = state;
 678         mutex_unlock(&bq->lock);
 679
 680         power_supply_changed(bq->charger);
 681
 682         return IRQ_HANDLED;
 683 }
 684
 685 static int bq24257_hw_init(struct bq24257_device *bq)
 686 {
 687         int ret;
 688         int i;
 689         struct bq24257_state state;
 690
 691         const struct {
 692                 int field;
 693                 u32 value;
 694         } init_data[] = {
 695                 {F_ICHG, bq->init_data.ichg},
 696                 {F_VBAT, bq->init_data.vbat},
 697                 {F_ITERM, bq->init_data.iterm},
 698                 {F_VOVP, bq->init_data.vovp},
 699                 {F_VINDPM, bq->init_data.vindpm},
 700         };
 701
 702         /*
 703          * Disable the watchdog timer to prevent the IC from going back to
 704          * default settings after 50 seconds of I2C inactivity.
 705          */
 706         ret = bq24257_field_write(bq, F_WD_EN, 0);
 707         if (ret < 0)
 708                 return ret;
 709
 710         /* configure the charge currents and voltages */
 711         for (i = 0; i < ARRAY_SIZE(init_data); i++) {
 712                 ret = bq24257_field_write(bq, init_data[i].field,
 713                                           init_data[i].value);
 714                 if (ret < 0)
 715                         return ret;
 716         }
 717
 718         ret = bq24257_get_chip_state(bq, &state);
 719         if (ret < 0)
 720                 return ret;
 721
 722         mutex_lock(&bq->lock);
 723         bq->state = state;
 724         mutex_unlock(&bq->lock);
 725
 726         if (!bq->iilimit_autoset_enable) {
 727                 dev_dbg(bq->dev, "manually setting iilimit = %u\n",
 728                         bq->init_data.iilimit);
 729
 730                 /* program fixed input current limit */
 731                 ret = bq24257_field_write(bq, F_IILIMIT,
 732                                           bq->init_data.iilimit);
 733                 if (ret < 0)
 734                         return ret;
 735         } else if (!state.power_good)
 736                 /* activate D+/D- detection algorithm */
 737                 ret = bq24257_field_write(bq, F_DPDM_EN, 1);
 738         else if (state.fault != FAULT_NO_BAT)
 739                 ret = bq24257_iilimit_autoset(bq);
 740
 741         return ret;
 742 }
 743
 744 static enum power_supply_property bq24257_power_supply_props[] = {
 745         POWER_SUPPLY_PROP_MANUFACTURER,
 746         POWER_SUPPLY_PROP_MODEL_NAME,
 747         POWER_SUPPLY_PROP_STATUS,
 748         POWER_SUPPLY_PROP_ONLINE,
 749         POWER_SUPPLY_PROP_HEALTH,
 750         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
 751         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
 752         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 753         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
 754         POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
 755         POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
 756 };
 757
 758 static char *bq24257_charger_supplied_to[] = {
 759         "main-battery",
 760 };
 761
 762 static const struct power_supply_desc bq24257_power_supply_desc = {
 763         .name = "bq24257-charger",
 764         .type = POWER_SUPPLY_TYPE_USB,
 765         .properties = bq24257_power_supply_props,
 766         .num_properties = ARRAY_SIZE(bq24257_power_supply_props),
 767         .get_property = bq24257_power_supply_get_property,
 768         .set_property = bq24257_power_supply_set_property,
 769         .property_is_writeable = bq24257_power_supply_property_is_writeable,
 770 };
 771
 772 static ssize_t bq24257_show_ovp_voltage(struct device *dev,
 773                                         struct device_attribute *attr,
 774                                         char *buf)
 775 {
 776         struct power_supply *psy = dev_get_drvdata(dev);
 777         struct bq24257_device *bq = power_supply_get_drvdata(psy);
 778
 779         return scnprintf(buf, PAGE_SIZE, "%u\n",
 780                          bq24257_vovp_map[bq->init_data.vovp]);
 781 }
 782
 783 static ssize_t bq24257_show_in_dpm_voltage(struct device *dev,
 784                                            struct device_attribute *attr,
 785                                            char *buf)
 786 {
 787         struct power_supply *psy = dev_get_drvdata(dev);
 788         struct bq24257_device *bq = power_supply_get_drvdata(psy);
 789
 790         return scnprintf(buf, PAGE_SIZE, "%u\n",
 791                          bq24257_vindpm_map[bq->init_data.vindpm]);
 792 }
 793
 794 static ssize_t bq24257_sysfs_show_enable(struct device *dev,
 795                                          struct device_attribute *attr,
 796                                          char *buf)
 797 {
 798         struct power_supply *psy = dev_get_drvdata(dev);
 799         struct bq24257_device *bq = power_supply_get_drvdata(psy);
 800         int ret;
 801
 802         if (strcmp(attr->attr.name, "high_impedance_enable") == 0)
 803                 ret = bq24257_field_read(bq, F_HZ_MODE);
 804         else if (strcmp(attr->attr.name, "sysoff_enable") == 0)
 805                 ret = bq24257_field_read(bq, F_SYSOFF);
 806         else
 807                 return -EINVAL;
 808
 809         if (ret < 0)
 810                 return ret;
 811
 812         return scnprintf(buf, PAGE_SIZE, "%d\n", ret);
 813 }
 814
 815 static ssize_t bq24257_sysfs_set_enable(struct device *dev,
 816                                         struct device_attribute *attr,
 817                                         const char *buf,
 818                                         size_t count)
 819 {
 820         struct power_supply *psy = dev_get_drvdata(dev);
 821         struct bq24257_device *bq = power_supply_get_drvdata(psy);
 822         long val;
 823         int ret;
 824
 825         if (kstrtol(buf, 10, &val) < 0)
 826                 return -EINVAL;
 827
 828         if (strcmp(attr->attr.name, "high_impedance_enable") == 0)
 829                 ret = bq24257_field_write(bq, F_HZ_MODE, (bool)val);
 830         else if (strcmp(attr->attr.name, "sysoff_enable") == 0)
 831                 ret = bq24257_field_write(bq, F_SYSOFF, (bool)val);
 832         else
 833                 return -EINVAL;
 834
 835         if (ret < 0)
 836                 return ret;
 837
 838         return count;
 839 }
 840
 841 static DEVICE_ATTR(ovp_voltage, S_IRUGO, bq24257_show_ovp_voltage, NULL);
 842 static DEVICE_ATTR(in_dpm_voltage, S_IRUGO, bq24257_show_in_dpm_voltage, NULL);
 843 static DEVICE_ATTR(high_impedance_enable, S_IWUSR | S_IRUGO,
 844                    bq24257_sysfs_show_enable, bq24257_sysfs_set_enable);
 845 static DEVICE_ATTR(sysoff_enable, S_IWUSR | S_IRUGO,
 846                    bq24257_sysfs_show_enable, bq24257_sysfs_set_enable);
 847
 848 static struct attribute *bq24257_charger_sysfs_attrs[] = {
 849         &dev_attr_ovp_voltage.attr,
 850         &dev_attr_in_dpm_voltage.attr,
 851         &dev_attr_high_impedance_enable.attr,
 852         &dev_attr_sysoff_enable.attr,
 853         NULL,
 854 };
 855
 856 ATTRIBUTE_GROUPS(bq24257_charger_sysfs);
 857
 858 static int bq24257_power_supply_init(struct bq24257_device *bq)
 859 {
 860         struct power_supply_config psy_cfg = { .drv_data = bq, };
 861
 862         psy_cfg.attr_grp = bq24257_charger_sysfs_groups;
 863         psy_cfg.supplied_to = bq24257_charger_supplied_to;
 864         psy_cfg.num_supplicants = ARRAY_SIZE(bq24257_charger_supplied_to);
 865
 866         bq->charger = devm_power_supply_register(bq->dev,
 867                                                  &bq24257_power_supply_desc,
 868                                                  &psy_cfg);
 869
 870         return PTR_ERR_OR_ZERO(bq->charger);
 871 }
 872
 873 static void bq24257_pg_gpio_probe(struct bq24257_device *bq)
 874 {
 875         bq->pg = devm_gpiod_get_optional(bq->dev, BQ24257_PG_GPIO, GPIOD_IN);
 876
 877         if (PTR_ERR(bq->pg) == -EPROBE_DEFER) {
 878                 dev_info(bq->dev, "probe retry requested for PG pin\n");
 879                 return;
 880         } else if (IS_ERR(bq->pg)) {
 881                 dev_err(bq->dev, "error probing PG pin\n");
 882                 bq->pg = NULL;
 883                 return;
 884         }
 885
 886         if (bq->pg)
 887                 dev_dbg(bq->dev, "probed PG pin = %d\n", desc_to_gpio(bq->pg));
 888 }
 889
 890 static int bq24257_fw_probe(struct bq24257_device *bq)
 891 {
 892         int ret;
 893         u32 property;
 894
 895         /* Required properties */
 896         ret = device_property_read_u32(bq->dev, "ti,charge-current", &property);
 897         if (ret < 0)
 898                 return ret;
 899
 900         bq->init_data.ichg = bq24257_find_idx(property, bq24257_ichg_map,
 901                                               BQ24257_ICHG_MAP_SIZE);
 902
 903         ret = device_property_read_u32(bq->dev, "ti,battery-regulation-voltage",
 904                                        &property);
 905         if (ret < 0)
 906                 return ret;
 907
 908         bq->init_data.vbat = bq24257_find_idx(property, bq24257_vbat_map,
 909                                               BQ24257_VBAT_MAP_SIZE);
 910
 911         ret = device_property_read_u32(bq->dev, "ti,termination-current",
 912                                        &property);
 913         if (ret < 0)
 914                 return ret;
 915
 916         bq->init_data.iterm = bq24257_find_idx(property, bq24257_iterm_map,
 917                                                BQ24257_ITERM_MAP_SIZE);
 918
 919         /* Optional properties. If not provided use reasonable default. */
 920         ret = device_property_read_u32(bq->dev, "ti,current-limit",
 921                                        &property);
 922         if (ret < 0) {
 923                 bq->iilimit_autoset_enable = true;
 924
 925                 /*
 926                  * Explicitly set a default value which will be needed for
 927                  * devices that don't support the automatic setting of the input
 928                  * current limit through the charger type detection mechanism.
 929                  */
 930                 bq->init_data.iilimit = IILIMIT_500;
 931         } else
 932                 bq->init_data.iilimit =
 933                                 bq24257_find_idx(property,
 934                                                  bq24257_iilimit_map,
 935                                                  BQ24257_IILIMIT_MAP_SIZE);
 936
 937         ret = device_property_read_u32(bq->dev, "ti,ovp-voltage",
 938                                        &property);
 939         if (ret < 0)
 940                 bq->init_data.vovp = VOVP_6500;
 941         else
 942                 bq->init_data.vovp = bq24257_find_idx(property,
 943                                                       bq24257_vovp_map,
 944                                                       BQ24257_VOVP_MAP_SIZE);
 945
 946         ret = device_property_read_u32(bq->dev, "ti,in-dpm-voltage",
 947                                        &property);
 948         if (ret < 0)
 949                 bq->init_data.vindpm = VINDPM_4360;
 950         else
 951                 bq->init_data.vindpm =
 952                                 bq24257_find_idx(property,
 953                                                  bq24257_vindpm_map,
 954                                                  BQ24257_VINDPM_MAP_SIZE);
 955
 956         return 0;
 957 }
 958
 959 static int bq24257_probe(struct i2c_client *client,
 960                          const struct i2c_device_id *id)
 961 {
 962         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
 963         struct device *dev = &client->dev;
 964         const struct acpi_device_id *acpi_id;
 965         struct bq24257_device *bq;
 966         int ret;
 967         int i;
 968
 969         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
 970                 dev_err(dev, "No support for SMBUS_BYTE_DATA\n");
 971                 return -ENODEV;
 972         }
 973
 974         bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL);
 975         if (!bq)
 976                 return -ENOMEM;
 977
 978         bq->client = client;
 979         bq->dev = dev;
 980
 981         if (ACPI_HANDLE(dev)) {
 982                 acpi_id = acpi_match_device(dev->driver->acpi_match_table,
 983                                             &client->dev);
 984                 if (!acpi_id) {
 985                         dev_err(dev, "Failed to match ACPI device\n");
 986                         return -ENODEV;
 987                 }
 988                 bq->chip = (enum bq2425x_chip)acpi_id->driver_data;
 989         } else {
 990                 bq->chip = (enum bq2425x_chip)id->driver_data;
 991         }
 992
 993         mutex_init(&bq->lock);
 994
 995         bq->rmap = devm_regmap_init_i2c(client, &bq24257_regmap_config);
 996         if (IS_ERR(bq->rmap)) {
 997                 dev_err(dev, "failed to allocate register map\n");
 998                 return PTR_ERR(bq->rmap);
 999         }
1000
1001         for (i = 0; i < ARRAY_SIZE(bq24257_reg_fields); i++) {
1002                 const struct reg_field *reg_fields = bq24257_reg_fields;
1003
1004                 bq->rmap_fields[i] = devm_regmap_field_alloc(dev, bq->rmap,
1005                                                              reg_fields[i]);
1006                 if (IS_ERR(bq->rmap_fields[i])) {
1007                         dev_err(dev, "cannot allocate regmap field\n");
1008                         return PTR_ERR(bq->rmap_fields[i]);
1009                 }
1010         }
1011
1012         i2c_set_clientdata(client, bq);
1013
1014         if (!dev->platform_data) {
1015                 ret = bq24257_fw_probe(bq);
1016                 if (ret < 0) {
1017                         dev_err(dev, "Cannot read device properties.\n");
1018                         return ret;
1019                 }
1020         } else {
1021                 return -ENODEV;
1022         }
1023
1024         /*
1025          * The BQ24250 doesn't support the D+/D- based charger type detection
1026          * used for the automatic setting of the input current limit setting so
1027          * explicitly disable that feature.
1028          */
1029         if (bq->chip == BQ24250)
1030                 bq->iilimit_autoset_enable = false;
1031
1032         if (bq->iilimit_autoset_enable)
1033                 INIT_DELAYED_WORK(&bq->iilimit_setup_work,
1034                                   bq24257_iilimit_setup_work);
1035
1036         /*
1037          * The BQ24250 doesn't have a dedicated Power Good (PG) pin so let's
1038          * not probe for it and instead use a SW-based approach to determine
1039          * the PG state. We also use a SW-based approach for all other devices
1040          * if the PG pin is either not defined or can't be probed.
1041          */
1042         if (bq->chip != BQ24250)
1043                 bq24257_pg_gpio_probe(bq);
1044
1045         if (PTR_ERR(bq->pg) == -EPROBE_DEFER)
1046                 return PTR_ERR(bq->pg);
1047         else if (!bq->pg)
1048                 dev_info(bq->dev, "using SW-based power-good detection\n");
1049
1050         /* reset all registers to defaults */
1051         ret = bq24257_field_write(bq, F_RESET, 1);
1052         if (ret < 0)
1053                 return ret;
1054
1055         /*
1056          * Put the RESET bit back to 0, in cache. For some reason the HW always
1057          * returns 1 on this bit, so this is the only way to avoid resetting the
1058          * chip every time we update another field in this register.
1059          */
1060         ret = bq24257_field_write(bq, F_RESET, 0);
1061         if (ret < 0)
1062                 return ret;
1063
1064         ret = bq24257_hw_init(bq);
1065         if (ret < 0) {
1066                 dev_err(dev, "Cannot initialize the chip.\n");
1067                 return ret;
1068         }
1069
1070         ret = bq24257_power_supply_init(bq);
1071         if (ret < 0) {
1072                 dev_err(dev, "Failed to register power supply\n");
1073                 return ret;
1074         }
1075
1076         ret = devm_request_threaded_irq(dev, client->irq, NULL,
1077                                         bq24257_irq_handler_thread,
1078                                         IRQF_TRIGGER_FALLING |
1079                                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
1080                                         bq2425x_chip_name[bq->chip], bq);
1081         if (ret) {
1082                 dev_err(dev, "Failed to request IRQ #%d\n", client->irq);
1083                 return ret;
1084         }
1085
1086         return 0;
1087 }
1088
1089 static int bq24257_remove(struct i2c_client *client)
1090 {
1091         struct bq24257_device *bq = i2c_get_clientdata(client);
1092
1093         if (bq->iilimit_autoset_enable)
1094                 cancel_delayed_work_sync(&bq->iilimit_setup_work);
1095
1096         bq24257_field_write(bq, F_RESET, 1); /* reset to defaults */
1097
1098         return 0;
1099 }
1100
1101 #ifdef CONFIG_PM_SLEEP
1102 static int bq24257_suspend(struct device *dev)
1103 {
1104         struct bq24257_device *bq = dev_get_drvdata(dev);
1105         int ret = 0;
1106
1107         if (bq->iilimit_autoset_enable)
1108                 cancel_delayed_work_sync(&bq->iilimit_setup_work);
1109
1110         /* reset all registers to default (and activate standalone mode) */
1111         ret = bq24257_field_write(bq, F_RESET, 1);
1112         if (ret < 0)
1113                 dev_err(bq->dev, "Cannot reset chip to standalone mode.\n");
1114
1115         return ret;
1116 }
1117
1118 static int bq24257_resume(struct device *dev)
1119 {
1120         int ret;
1121         struct bq24257_device *bq = dev_get_drvdata(dev);
1122
1123         ret = regcache_drop_region(bq->rmap, BQ24257_REG_1, BQ24257_REG_7);
1124         if (ret < 0)
1125                 return ret;
1126
1127         ret = bq24257_field_write(bq, F_RESET, 0);
1128         if (ret < 0)
1129                 return ret;
1130
1131         ret = bq24257_hw_init(bq);
1132         if (ret < 0) {
1133                 dev_err(bq->dev, "Cannot init chip after resume.\n");
1134                 return ret;
1135         }
1136
1137         /* signal userspace, maybe state changed while suspended */
1138         power_supply_changed(bq->charger);
1139
1140         return 0;
1141 }
1142 #endif
1143
1144 static const struct dev_pm_ops bq24257_pm = {
1145         SET_SYSTEM_SLEEP_PM_OPS(bq24257_suspend, bq24257_resume)
1146 };
1147
1148 static const struct i2c_device_id bq24257_i2c_ids[] = {
1149         { "bq24250", BQ24250 },
1150         { "bq24251", BQ24251 },
1151         { "bq24257", BQ24257 },
1152         {},
1153 };
1154 MODULE_DEVICE_TABLE(i2c, bq24257_i2c_ids);
1155
1156 static const struct of_device_id bq24257_of_match[] = {
1157         { .compatible = "ti,bq24250", },
1158         { .compatible = "ti,bq24251", },
1159         { .compatible = "ti,bq24257", },
1160         { },
1161 };
1162 MODULE_DEVICE_TABLE(of, bq24257_of_match);
1163
1164 static const struct acpi_device_id bq24257_acpi_match[] = {
1165         { "BQ242500", BQ24250 },
1166         { "BQ242510", BQ24251 },
1167         { "BQ242570", BQ24257 },
1168         {},
1169 };
1170 MODULE_DEVICE_TABLE(acpi, bq24257_acpi_match);
1171
1172 static struct i2c_driver bq24257_driver = {
1173         .driver = {
1174                 .name = "bq24257-charger",
1175                 .of_match_table = of_match_ptr(bq24257_of_match),
1176                 .acpi_match_table = ACPI_PTR(bq24257_acpi_match),
1177                 .pm = &bq24257_pm,
1178         },
1179         .probe = bq24257_probe,
1180         .remove = bq24257_remove,
1181         .id_table = bq24257_i2c_ids,
1182 };
1183 module_i2c_driver(bq24257_driver);
1184
1185 MODULE_AUTHOR("Laurentiu Palcu <laurentiu.palcu@intel.com>");
1186 MODULE_DESCRIPTION("bq24257 charger driver");
1187 MODULE_LICENSE("GPL");