drivers/power/supply/bq24257

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
bq24257_is_volatile_reg
bq24257_field_read
bq24257_field_write
bq24257_find_idx
bq24257_get_input_current_limit
bq24257_set_input_current_limit
bq24257_power_supply_get_property
bq24257_power_supply_set_property
bq24257_power_supply_property_is_writeable
bq24257_get_chip_state
bq24257_state_changed
bq24257_iilimit_autoset
bq24257_iilimit_setup_work
bq24257_handle_state_change
bq24257_irq_handler_thread
bq24257_hw_init
bq24257_show_ovp_voltage
bq24257_show_in_dpm_voltage
bq24257_sysfs_show_enable
bq24257_sysfs_set_enable
bq24257_power_supply_init
bq24257_pg_gpio_probe
bq24257_fw_probe
bq24257_probe
bq24257_remove
bq24257_suspend
bq24257_resume
   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 = client->adapter;
 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");
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/power/supply/bq24257_charger.c

DEFINITIONS
