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