drivers/power/supply/bq24257_charger.c

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