linux/drivers/power/supply/bq256xx_charger.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2// BQ256XX Battery Charger Driver
   3// Copyright (C) 2020 Texas Instruments Incorporated - http://www.ti.com/
   4
   5#include <linux/err.h>
   6#include <linux/i2c.h>
   7#include <linux/init.h>
   8#include <linux/interrupt.h>
   9#include <linux/kernel.h>
  10#include <linux/module.h>
  11#include <linux/gpio/consumer.h>
  12#include <linux/power_supply.h>
  13#include <linux/regmap.h>
  14#include <linux/types.h>
  15#include <linux/usb/phy.h>
  16#include <linux/device.h>
  17#include <linux/moduleparam.h>
  18#include <linux/slab.h>
  19#include <linux/acpi.h>
  20
  21#define BQ256XX_MANUFACTURER "Texas Instruments"
  22
  23#define BQ256XX_INPUT_CURRENT_LIMIT             0x00
  24#define BQ256XX_CHARGER_CONTROL_0               0x01
  25#define BQ256XX_CHARGE_CURRENT_LIMIT            0x02
  26#define BQ256XX_PRECHG_AND_TERM_CURR_LIM        0x03
  27#define BQ256XX_BATTERY_VOLTAGE_LIMIT           0x04
  28#define BQ256XX_CHARGER_CONTROL_1               0x05
  29#define BQ256XX_CHARGER_CONTROL_2               0x06
  30#define BQ256XX_CHARGER_CONTROL_3               0x07
  31#define BQ256XX_CHARGER_STATUS_0                0x08
  32#define BQ256XX_CHARGER_STATUS_1                0x09
  33#define BQ256XX_CHARGER_STATUS_2                0x0a
  34#define BQ256XX_PART_INFORMATION                0x0b
  35#define BQ256XX_CHARGER_CONTROL_4               0x0c
  36
  37#define BQ256XX_IINDPM_MASK             GENMASK(4, 0)
  38#define BQ256XX_IINDPM_STEP_uA          100000
  39#define BQ256XX_IINDPM_OFFSET_uA        100000
  40#define BQ256XX_IINDPM_MIN_uA           100000
  41#define BQ256XX_IINDPM_MAX_uA           3200000
  42#define BQ256XX_IINDPM_DEF_uA           2400000
  43
  44#define BQ256XX_VINDPM_MASK             GENMASK(3, 0)
  45#define BQ256XX_VINDPM_STEP_uV          100000
  46#define BQ256XX_VINDPM_OFFSET_uV        3900000
  47#define BQ256XX_VINDPM_MIN_uV           3900000
  48#define BQ256XX_VINDPM_MAX_uV           5400000
  49#define BQ256XX_VINDPM_DEF_uV           4500000
  50
  51#define BQ256XX_VBATREG_MASK            GENMASK(7, 3)
  52#define BQ2560X_VBATREG_STEP_uV         32000
  53#define BQ2560X_VBATREG_OFFSET_uV       3856000
  54#define BQ2560X_VBATREG_MIN_uV          3856000
  55#define BQ2560X_VBATREG_MAX_uV          4624000
  56#define BQ2560X_VBATREG_DEF_uV          4208000
  57#define BQ25601D_VBATREG_OFFSET_uV      3847000
  58#define BQ25601D_VBATREG_MIN_uV         3847000
  59#define BQ25601D_VBATREG_MAX_uV         4615000
  60#define BQ25601D_VBATREG_DEF_uV         4199000
  61#define BQ2561X_VBATREG_STEP_uV         10000
  62#define BQ25611D_VBATREG_MIN_uV         3494000
  63#define BQ25611D_VBATREG_MAX_uV         4510000
  64#define BQ25611D_VBATREG_DEF_uV         4190000
  65#define BQ25618_VBATREG_MIN_uV          3504000
  66#define BQ25618_VBATREG_MAX_uV          4500000
  67#define BQ25618_VBATREG_DEF_uV          4200000
  68#define BQ256XX_VBATREG_BIT_SHIFT       3
  69#define BQ2561X_VBATREG_THRESH          0x8
  70#define BQ25611D_VBATREG_THRESH_uV      4290000
  71#define BQ25618_VBATREG_THRESH_uV       4300000
  72
  73#define BQ256XX_ITERM_MASK              GENMASK(3, 0)
  74#define BQ256XX_ITERM_STEP_uA           60000
  75#define BQ256XX_ITERM_OFFSET_uA         60000
  76#define BQ256XX_ITERM_MIN_uA            60000
  77#define BQ256XX_ITERM_MAX_uA            780000
  78#define BQ256XX_ITERM_DEF_uA            180000
  79#define BQ25618_ITERM_STEP_uA           20000
  80#define BQ25618_ITERM_OFFSET_uA         20000
  81#define BQ25618_ITERM_MIN_uA            20000
  82#define BQ25618_ITERM_MAX_uA            260000
  83#define BQ25618_ITERM_DEF_uA            60000
  84
  85#define BQ256XX_IPRECHG_MASK            GENMASK(7, 4)
  86#define BQ256XX_IPRECHG_STEP_uA         60000
  87#define BQ256XX_IPRECHG_OFFSET_uA       60000
  88#define BQ256XX_IPRECHG_MIN_uA          60000
  89#define BQ256XX_IPRECHG_MAX_uA          780000
  90#define BQ256XX_IPRECHG_DEF_uA          180000
  91#define BQ25618_IPRECHG_STEP_uA         20000
  92#define BQ25618_IPRECHG_OFFSET_uA       20000
  93#define BQ25618_IPRECHG_MIN_uA          20000
  94#define BQ25618_IPRECHG_MAX_uA          260000
  95#define BQ25618_IPRECHG_DEF_uA          40000
  96#define BQ256XX_IPRECHG_BIT_SHIFT       4
  97
  98#define BQ256XX_ICHG_MASK               GENMASK(5, 0)
  99#define BQ256XX_ICHG_STEP_uA            60000
 100#define BQ256XX_ICHG_MIN_uA             0
 101#define BQ256XX_ICHG_MAX_uA             3000000
 102#define BQ2560X_ICHG_DEF_uA             2040000
 103#define BQ25611D_ICHG_DEF_uA            1020000
 104#define BQ25618_ICHG_STEP_uA            20000
 105#define BQ25618_ICHG_MIN_uA             0
 106#define BQ25618_ICHG_MAX_uA             1500000
 107#define BQ25618_ICHG_DEF_uA             340000
 108#define BQ25618_ICHG_THRESH             0x3c
 109#define BQ25618_ICHG_THRESH_uA          1180000
 110
 111#define BQ256XX_VBUS_STAT_MASK          GENMASK(7, 5)
 112#define BQ256XX_VBUS_STAT_NO_INPUT      0
 113#define BQ256XX_VBUS_STAT_USB_SDP       BIT(5)
 114#define BQ256XX_VBUS_STAT_USB_CDP       BIT(6)
 115#define BQ256XX_VBUS_STAT_USB_DCP       (BIT(6) | BIT(5))
 116#define BQ256XX_VBUS_STAT_USB_OTG       (BIT(7) | BIT(6) | BIT(5))
 117
 118#define BQ256XX_CHRG_STAT_MASK          GENMASK(4, 3)
 119#define BQ256XX_CHRG_STAT_NOT_CHRGING   0
 120#define BQ256XX_CHRG_STAT_PRECHRGING    BIT(3)
 121#define BQ256XX_CHRG_STAT_FAST_CHRGING  BIT(4)
 122#define BQ256XX_CHRG_STAT_CHRG_TERM     (BIT(4) | BIT(3))
 123
 124#define BQ256XX_PG_STAT_MASK            BIT(2)
 125#define BQ256XX_WDT_FAULT_MASK          BIT(7)
 126#define BQ256XX_CHRG_FAULT_MASK         GENMASK(5, 4)
 127#define BQ256XX_CHRG_FAULT_NORMAL       0
 128#define BQ256XX_CHRG_FAULT_INPUT        BIT(4)
 129#define BQ256XX_CHRG_FAULT_THERM        BIT(5)
 130#define BQ256XX_CHRG_FAULT_CST_EXPIRE   (BIT(5) | BIT(4))
 131#define BQ256XX_BAT_FAULT_MASK          BIT(3)
 132#define BQ256XX_NTC_FAULT_MASK          GENMASK(2, 0)
 133#define BQ256XX_NTC_FAULT_WARM          BIT(1)
 134#define BQ256XX_NTC_FAULT_COOL          (BIT(1) | BIT(0))
 135#define BQ256XX_NTC_FAULT_COLD          (BIT(2) | BIT(0))
 136#define BQ256XX_NTC_FAULT_HOT           (BIT(2) | BIT(1))
 137
 138#define BQ256XX_NUM_WD_VAL      4
 139#define BQ256XX_WATCHDOG_MASK   GENMASK(5, 4)
 140#define BQ256XX_WATCHDOG_MAX    1600000
 141#define BQ256XX_WATCHDOG_DIS    0
 142#define BQ256XX_WDT_BIT_SHIFT   4
 143
 144#define BQ256XX_REG_RST         BIT(7)
 145
 146/**
 147 * struct bq256xx_init_data -
 148 * @ichg: fast charge current
 149 * @iindpm: input current limit
 150 * @vbatreg: charge voltage
 151 * @iterm: termination current
 152 * @iprechg: precharge current
 153 * @vindpm: input voltage limit
 154 * @ichg_max: maximum fast charge current
 155 * @vbatreg_max: maximum charge voltage
 156 */
 157struct bq256xx_init_data {
 158        u32 ichg;
 159        u32 iindpm;
 160        u32 vbatreg;
 161        u32 iterm;
 162        u32 iprechg;
 163        u32 vindpm;
 164        u32 ichg_max;
 165        u32 vbatreg_max;
 166};
 167
 168/**
 169 * struct bq256xx_state -
 170 * @vbus_stat: VBUS status according to BQ256XX_CHARGER_STATUS_0
 171 * @chrg_stat: charging status according to BQ256XX_CHARGER_STATUS_0
 172 * @online: PG status according to BQ256XX_CHARGER_STATUS_0
 173 *
 174 * @wdt_fault: watchdog fault according to BQ256XX_CHARGER_STATUS_1
 175 * @bat_fault: battery fault according to BQ256XX_CHARGER_STATUS_1
 176 * @chrg_fault: charging fault according to BQ256XX_CHARGER_STATUS_1
 177 * @ntc_fault: TS fault according to BQ256XX_CHARGER_STATUS_1
 178 */
 179struct bq256xx_state {
 180        u8 vbus_stat;
 181        u8 chrg_stat;
 182        bool online;
 183
 184        u8 wdt_fault;
 185        u8 bat_fault;
 186        u8 chrg_fault;
 187        u8 ntc_fault;
 188};
 189
 190enum bq256xx_id {
 191        BQ25600,
 192        BQ25600D,
 193        BQ25601,
 194        BQ25601D,
 195        BQ25618,
 196        BQ25619,
 197        BQ25611D,
 198};
 199
 200/**
 201 * struct bq256xx_device -
 202 * @client: i2c client structure
 203 * @regmap: register map structure
 204 * @dev: device structure
 205 * @charger: power supply registered for the charger
 206 * @battery: power supply registered for the battery
 207 * @lock: mutex lock structure
 208 *
 209 * @usb2_phy: usb_phy identifier
 210 * @usb3_phy: usb_phy identifier
 211 * @usb_nb: notifier block
 212 * @usb_work: usb work queue
 213 * @usb_event: usb_event code
 214 *
 215 * @model_name: i2c name string
 216 *
 217 * @init_data: initialization data
 218 * @chip_info: device variant information
 219 * @state: device status and faults
 220 * @watchdog_timer: watchdog timer value in milliseconds
 221 */
 222struct bq256xx_device {
 223        struct i2c_client *client;
 224        struct device *dev;
 225        struct power_supply *charger;
 226        struct power_supply *battery;
 227        struct mutex lock;
 228        struct regmap *regmap;
 229
 230        struct usb_phy *usb2_phy;
 231        struct usb_phy *usb3_phy;
 232        struct notifier_block usb_nb;
 233        struct work_struct usb_work;
 234        unsigned long usb_event;
 235
 236        char model_name[I2C_NAME_SIZE];
 237
 238        struct bq256xx_init_data init_data;
 239        const struct bq256xx_chip_info *chip_info;
 240        struct bq256xx_state state;
 241        int watchdog_timer;
 242};
 243
 244/**
 245 * struct bq256xx_chip_info -
 246 * @model_id: device instance
 247 *
 248 * @bq256xx_regmap_config: regmap configuration struct
 249 * @bq256xx_get_ichg: pointer to instance specific get_ichg function
 250 * @bq256xx_get_iindpm: pointer to instance specific get_iindpm function
 251 * @bq256xx_get_vbatreg: pointer to instance specific get_vbatreg function
 252 * @bq256xx_get_iterm: pointer to instance specific get_iterm function
 253 * @bq256xx_get_iprechg: pointer to instance specific get_iprechg function
 254 * @bq256xx_get_vindpm: pointer to instance specific get_vindpm function
 255 *
 256 * @bq256xx_set_ichg: pointer to instance specific set_ichg function
 257 * @bq256xx_set_iindpm: pointer to instance specific set_iindpm function
 258 * @bq256xx_set_vbatreg: pointer to instance specific set_vbatreg function
 259 * @bq256xx_set_iterm: pointer to instance specific set_iterm function
 260 * @bq256xx_set_iprechg: pointer to instance specific set_iprechg function
 261 * @bq256xx_set_vindpm: pointer to instance specific set_vindpm function
 262 *
 263 * @bq256xx_def_ichg: default ichg value in microamps
 264 * @bq256xx_def_iindpm: default iindpm value in microamps
 265 * @bq256xx_def_vbatreg: default vbatreg value in microvolts
 266 * @bq256xx_def_iterm: default iterm value in microamps
 267 * @bq256xx_def_iprechg: default iprechg value in microamps
 268 * @bq256xx_def_vindpm: default vindpm value in microvolts
 269 *
 270 * @bq256xx_max_ichg: maximum charge current in microamps
 271 * @bq256xx_max_vbatreg: maximum battery regulation voltage in microvolts
 272 *
 273 * @has_usb_detect: indicates whether device has BC1.2 detection
 274 */
 275struct bq256xx_chip_info {
 276        int model_id;
 277
 278        const struct regmap_config *bq256xx_regmap_config;
 279
 280        int (*bq256xx_get_ichg)(struct bq256xx_device *bq);
 281        int (*bq256xx_get_iindpm)(struct bq256xx_device *bq);
 282        int (*bq256xx_get_vbatreg)(struct bq256xx_device *bq);
 283        int (*bq256xx_get_iterm)(struct bq256xx_device *bq);
 284        int (*bq256xx_get_iprechg)(struct bq256xx_device *bq);
 285        int (*bq256xx_get_vindpm)(struct bq256xx_device *bq);
 286
 287        int (*bq256xx_set_ichg)(struct bq256xx_device *bq, int ichg);
 288        int (*bq256xx_set_iindpm)(struct bq256xx_device *bq, int iindpm);
 289        int (*bq256xx_set_vbatreg)(struct bq256xx_device *bq, int vbatreg);
 290        int (*bq256xx_set_iterm)(struct bq256xx_device *bq, int iterm);
 291        int (*bq256xx_set_iprechg)(struct bq256xx_device *bq, int iprechg);
 292        int (*bq256xx_set_vindpm)(struct bq256xx_device *bq, int vindpm);
 293
 294        int bq256xx_def_ichg;
 295        int bq256xx_def_iindpm;
 296        int bq256xx_def_vbatreg;
 297        int bq256xx_def_iterm;
 298        int bq256xx_def_iprechg;
 299        int bq256xx_def_vindpm;
 300
 301        int bq256xx_max_ichg;
 302        int bq256xx_max_vbatreg;
 303
 304        bool has_usb_detect;
 305};
 306
 307static int bq256xx_watchdog_time[BQ256XX_NUM_WD_VAL] = {
 308        0, 40000, 80000, 1600000
 309};
 310
 311static const int bq25611d_vbatreg_values[] = {
 312        3494000, 3590000, 3686000, 3790000, 3894000, 3990000, 4090000, 4140000,
 313        4190000
 314};
 315
 316static const int bq25618_619_vbatreg_values[] = {
 317        3504000, 3600000, 3696000, 3800000, 3904000, 4000000, 4100000, 4150000,
 318        4200000
 319};
 320
 321static const int bq25618_619_ichg_values[] = {
 322        1290000, 1360000, 1430000, 1500000
 323};
 324
 325static enum power_supply_usb_type bq256xx_usb_type[] = {
 326        POWER_SUPPLY_USB_TYPE_SDP,
 327        POWER_SUPPLY_USB_TYPE_CDP,
 328        POWER_SUPPLY_USB_TYPE_DCP,
 329        POWER_SUPPLY_USB_TYPE_UNKNOWN,
 330        POWER_SUPPLY_USB_TYPE_ACA,
 331};
 332
 333static int bq256xx_array_parse(int array_size, int val, const int array[])
 334{
 335        int i = 0;
 336
 337        if (val < array[i])
 338                return i - 1;
 339
 340        if (val >= array[array_size - 1])
 341                return array_size - 1;
 342
 343        for (i = 1; i < array_size; i++) {
 344                if (val == array[i])
 345                        return i;
 346
 347                if (val > array[i - 1] && val < array[i]) {
 348                        if (val < array[i])
 349                                return i - 1;
 350                        else
 351                                return i;
 352                }
 353        }
 354        return -EINVAL;
 355}
 356
 357static int bq256xx_usb_notifier(struct notifier_block *nb, unsigned long val,
 358                                void *priv)
 359{
 360        struct bq256xx_device *bq =
 361                        container_of(nb, struct bq256xx_device, usb_nb);
 362
 363        bq->usb_event = val;
 364        queue_work(system_power_efficient_wq, &bq->usb_work);
 365
 366        return NOTIFY_OK;
 367}
 368
 369static void bq256xx_usb_work(struct work_struct *data)
 370{
 371        struct bq256xx_device *bq =
 372                        container_of(data, struct bq256xx_device, usb_work);
 373
 374        switch (bq->usb_event) {
 375        case USB_EVENT_ID:
 376                break;
 377        case USB_EVENT_NONE:
 378                power_supply_changed(bq->charger);
 379                break;
 380        default:
 381                dev_err(bq->dev, "Error switching to charger mode.\n");
 382                break;
 383        }
 384}
 385
 386static struct reg_default bq2560x_reg_defs[] = {
 387        {BQ256XX_INPUT_CURRENT_LIMIT, 0x17},
 388        {BQ256XX_CHARGER_CONTROL_0, 0x1a},
 389        {BQ256XX_CHARGE_CURRENT_LIMIT, 0xa2},
 390        {BQ256XX_PRECHG_AND_TERM_CURR_LIM, 0x22},
 391        {BQ256XX_BATTERY_VOLTAGE_LIMIT, 0x58},
 392        {BQ256XX_CHARGER_CONTROL_1, 0x9f},
 393        {BQ256XX_CHARGER_CONTROL_2, 0x66},
 394        {BQ256XX_CHARGER_CONTROL_3, 0x4c},
 395};
 396
 397static struct reg_default bq25611d_reg_defs[] = {
 398        {BQ256XX_INPUT_CURRENT_LIMIT, 0x17},
 399        {BQ256XX_CHARGER_CONTROL_0, 0x1a},
 400        {BQ256XX_CHARGE_CURRENT_LIMIT, 0x91},
 401        {BQ256XX_PRECHG_AND_TERM_CURR_LIM, 0x12},
 402        {BQ256XX_BATTERY_VOLTAGE_LIMIT, 0x40},
 403        {BQ256XX_CHARGER_CONTROL_1, 0x9e},
 404        {BQ256XX_CHARGER_CONTROL_2, 0xe6},
 405        {BQ256XX_CHARGER_CONTROL_3, 0x4c},
 406        {BQ256XX_PART_INFORMATION, 0x54},
 407        {BQ256XX_CHARGER_CONTROL_4, 0x75},
 408};
 409
 410static struct reg_default bq25618_619_reg_defs[] = {
 411        {BQ256XX_INPUT_CURRENT_LIMIT, 0x17},
 412        {BQ256XX_CHARGER_CONTROL_0, 0x1a},
 413        {BQ256XX_CHARGE_CURRENT_LIMIT, 0x91},
 414        {BQ256XX_PRECHG_AND_TERM_CURR_LIM, 0x12},
 415        {BQ256XX_BATTERY_VOLTAGE_LIMIT, 0x40},
 416        {BQ256XX_CHARGER_CONTROL_1, 0x9e},
 417        {BQ256XX_CHARGER_CONTROL_2, 0xe6},
 418        {BQ256XX_CHARGER_CONTROL_3, 0x4c},
 419        {BQ256XX_PART_INFORMATION, 0x2c},
 420        {BQ256XX_CHARGER_CONTROL_4, 0x75},
 421};
 422
 423static int bq256xx_get_state(struct bq256xx_device *bq,
 424                                struct bq256xx_state *state)
 425{
 426        unsigned int charger_status_0;
 427        unsigned int charger_status_1;
 428        int ret;
 429
 430        ret = regmap_read(bq->regmap, BQ256XX_CHARGER_STATUS_0,
 431                                                &charger_status_0);
 432        if (ret)
 433                return ret;
 434
 435        ret = regmap_read(bq->regmap, BQ256XX_CHARGER_STATUS_1,
 436                                                &charger_status_1);
 437        if (ret)
 438                return ret;
 439
 440        state->vbus_stat = charger_status_0 & BQ256XX_VBUS_STAT_MASK;
 441        state->chrg_stat = charger_status_0 & BQ256XX_CHRG_STAT_MASK;
 442        state->online = charger_status_0 & BQ256XX_PG_STAT_MASK;
 443
 444        state->wdt_fault = charger_status_1 & BQ256XX_WDT_FAULT_MASK;
 445        state->bat_fault = charger_status_1 & BQ256XX_BAT_FAULT_MASK;
 446        state->chrg_fault = charger_status_1 & BQ256XX_CHRG_FAULT_MASK;
 447        state->ntc_fault = charger_status_1 & BQ256XX_NTC_FAULT_MASK;
 448
 449        return 0;
 450}
 451
 452static int bq256xx_get_ichg_curr(struct bq256xx_device *bq)
 453{
 454        unsigned int charge_current_limit;
 455        unsigned int ichg_reg_code;
 456        int ret;
 457
 458        ret = regmap_read(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
 459                                                &charge_current_limit);
 460        if (ret)
 461                return ret;
 462
 463        ichg_reg_code = charge_current_limit & BQ256XX_ICHG_MASK;
 464
 465        return ichg_reg_code * BQ256XX_ICHG_STEP_uA;
 466}
 467
 468static int bq25618_619_get_ichg_curr(struct bq256xx_device *bq)
 469{
 470        unsigned int charge_current_limit;
 471        unsigned int ichg_reg_code;
 472        int ret;
 473
 474        ret = regmap_read(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
 475                                                &charge_current_limit);
 476        if (ret)
 477                return ret;
 478
 479        ichg_reg_code = charge_current_limit & BQ256XX_ICHG_MASK;
 480
 481        if (ichg_reg_code < BQ25618_ICHG_THRESH)
 482                return ichg_reg_code * BQ25618_ICHG_STEP_uA;
 483
 484        return bq25618_619_ichg_values[ichg_reg_code - BQ25618_ICHG_THRESH];
 485}
 486
 487static int bq256xx_set_ichg_curr(struct bq256xx_device *bq, int ichg)
 488{
 489        unsigned int ichg_reg_code;
 490        int ichg_max = bq->init_data.ichg_max;
 491
 492        ichg = clamp(ichg, BQ256XX_ICHG_MIN_uA, ichg_max);
 493        ichg_reg_code = ichg / BQ256XX_ICHG_STEP_uA;
 494
 495        return regmap_update_bits(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
 496                                        BQ256XX_ICHG_MASK, ichg_reg_code);
 497}
 498
 499static int bq25618_619_set_ichg_curr(struct bq256xx_device *bq, int ichg)
 500{
 501        int array_size = ARRAY_SIZE(bq25618_619_ichg_values);
 502        unsigned int ichg_reg_code;
 503        int ichg_max = bq->init_data.ichg_max;
 504
 505        ichg = clamp(ichg, BQ25618_ICHG_MIN_uA, ichg_max);
 506
 507        if (ichg <= BQ25618_ICHG_THRESH_uA) {
 508                ichg_reg_code = ichg / BQ25618_ICHG_STEP_uA;
 509        } else {
 510                ichg_reg_code = bq256xx_array_parse(array_size, ichg,
 511                        bq25618_619_ichg_values) + BQ25618_ICHG_THRESH;
 512        }
 513
 514        return regmap_update_bits(bq->regmap, BQ256XX_CHARGE_CURRENT_LIMIT,
 515                                        BQ256XX_ICHG_MASK, ichg_reg_code);
 516}
 517
 518static int bq25618_619_get_chrg_volt(struct bq256xx_device *bq)
 519{
 520        unsigned int battery_volt_lim;
 521        unsigned int vbatreg_reg_code;
 522        int ret;
 523
 524        ret = regmap_read(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 525                                                        &battery_volt_lim);
 526
 527        if (ret)
 528                return ret;
 529
 530        vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
 531                                                BQ256XX_VBATREG_BIT_SHIFT;
 532
 533        if (vbatreg_reg_code > BQ2561X_VBATREG_THRESH)
 534                return ((vbatreg_reg_code - BQ2561X_VBATREG_THRESH) *
 535                                        BQ2561X_VBATREG_STEP_uV) +
 536                                        BQ25618_VBATREG_THRESH_uV;
 537
 538        return bq25618_619_vbatreg_values[vbatreg_reg_code];
 539}
 540
 541static int bq25611d_get_chrg_volt(struct bq256xx_device *bq)
 542{
 543        unsigned int battery_volt_lim;
 544        unsigned int vbatreg_reg_code;
 545        int ret;
 546
 547        ret = regmap_read(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 548                                                        &battery_volt_lim);
 549        if (ret)
 550                return ret;
 551
 552        vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
 553                                                BQ256XX_VBATREG_BIT_SHIFT;
 554
 555        if (vbatreg_reg_code > BQ2561X_VBATREG_THRESH)
 556                return ((vbatreg_reg_code - BQ2561X_VBATREG_THRESH) *
 557                                        BQ2561X_VBATREG_STEP_uV) +
 558                                        BQ25611D_VBATREG_THRESH_uV;
 559
 560        return bq25611d_vbatreg_values[vbatreg_reg_code];
 561}
 562
 563static int bq2560x_get_chrg_volt(struct bq256xx_device *bq)
 564{
 565        unsigned int battery_volt_lim;
 566        unsigned int vbatreg_reg_code;
 567        int ret;
 568
 569        ret = regmap_read(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 570                                                        &battery_volt_lim);
 571        if (ret)
 572                return ret;
 573
 574        vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
 575                                                BQ256XX_VBATREG_BIT_SHIFT;
 576
 577        return (vbatreg_reg_code * BQ2560X_VBATREG_STEP_uV)
 578                                        + BQ2560X_VBATREG_OFFSET_uV;
 579}
 580
 581static int bq25601d_get_chrg_volt(struct bq256xx_device *bq)
 582{
 583        unsigned int battery_volt_lim;
 584        unsigned int vbatreg_reg_code;
 585        int ret;
 586
 587        ret = regmap_read(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 588                                                        &battery_volt_lim);
 589        if (ret)
 590                return ret;
 591
 592        vbatreg_reg_code = (battery_volt_lim & BQ256XX_VBATREG_MASK) >>
 593                                                BQ256XX_VBATREG_BIT_SHIFT;
 594
 595        return (vbatreg_reg_code * BQ2560X_VBATREG_STEP_uV)
 596                                        + BQ25601D_VBATREG_OFFSET_uV;
 597}
 598
 599static int bq25618_619_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
 600{
 601        int array_size = ARRAY_SIZE(bq25618_619_vbatreg_values);
 602        unsigned int vbatreg_reg_code;
 603        int vbatreg_max = bq->init_data.vbatreg_max;
 604
 605        vbatreg = clamp(vbatreg, BQ25618_VBATREG_MIN_uV, vbatreg_max);
 606
 607        if (vbatreg > BQ25618_VBATREG_THRESH_uV)
 608                vbatreg_reg_code = ((vbatreg -
 609                BQ25618_VBATREG_THRESH_uV) /
 610                (BQ2561X_VBATREG_STEP_uV)) + BQ2561X_VBATREG_THRESH;
 611        else {
 612                vbatreg_reg_code = bq256xx_array_parse(array_size, vbatreg,
 613                                                bq25618_619_vbatreg_values);
 614        }
 615
 616        return regmap_update_bits(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 617                                BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
 618                                                BQ256XX_VBATREG_BIT_SHIFT);
 619}
 620
 621static int bq25611d_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
 622{
 623        int array_size = ARRAY_SIZE(bq25611d_vbatreg_values);
 624        unsigned int vbatreg_reg_code;
 625        int vbatreg_max = bq->init_data.vbatreg_max;
 626
 627        vbatreg = clamp(vbatreg, BQ25611D_VBATREG_MIN_uV, vbatreg_max);
 628
 629        if (vbatreg > BQ25611D_VBATREG_THRESH_uV)
 630                vbatreg_reg_code = ((vbatreg -
 631                BQ25611D_VBATREG_THRESH_uV) /
 632                (BQ2561X_VBATREG_STEP_uV)) + BQ2561X_VBATREG_THRESH;
 633        else {
 634                vbatreg_reg_code = bq256xx_array_parse(array_size, vbatreg,
 635                                                bq25611d_vbatreg_values);
 636        }
 637
 638        return regmap_update_bits(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 639                                BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
 640                                                BQ256XX_VBATREG_BIT_SHIFT);
 641}
 642
 643static int bq2560x_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
 644{
 645        unsigned int vbatreg_reg_code;
 646        int vbatreg_max = bq->init_data.vbatreg_max;
 647
 648        vbatreg = clamp(vbatreg, BQ2560X_VBATREG_MIN_uV, vbatreg_max);
 649
 650        vbatreg_reg_code = (vbatreg - BQ2560X_VBATREG_OFFSET_uV) /
 651                                                BQ2560X_VBATREG_STEP_uV;
 652
 653        return regmap_update_bits(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 654                                BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
 655                                                BQ256XX_VBATREG_BIT_SHIFT);
 656}
 657
 658static int bq25601d_set_chrg_volt(struct bq256xx_device *bq, int vbatreg)
 659{
 660        unsigned int vbatreg_reg_code;
 661        int vbatreg_max = bq->init_data.vbatreg_max;
 662
 663        vbatreg = clamp(vbatreg, BQ25601D_VBATREG_MIN_uV, vbatreg_max);
 664
 665        vbatreg_reg_code = (vbatreg - BQ25601D_VBATREG_OFFSET_uV) /
 666                                                BQ2560X_VBATREG_STEP_uV;
 667
 668        return regmap_update_bits(bq->regmap, BQ256XX_BATTERY_VOLTAGE_LIMIT,
 669                                BQ256XX_VBATREG_MASK, vbatreg_reg_code <<
 670                                                BQ256XX_VBATREG_BIT_SHIFT);
 671}
 672
 673static int bq256xx_get_prechrg_curr(struct bq256xx_device *bq)
 674{
 675        unsigned int prechg_and_term_curr_lim;
 676        unsigned int iprechg_reg_code;
 677        int ret;
 678
 679        ret = regmap_read(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 680                                                &prechg_and_term_curr_lim);
 681        if (ret)
 682                return ret;
 683
 684        iprechg_reg_code = (prechg_and_term_curr_lim & BQ256XX_IPRECHG_MASK)
 685                                                >> BQ256XX_IPRECHG_BIT_SHIFT;
 686
 687        return (iprechg_reg_code * BQ256XX_IPRECHG_STEP_uA) +
 688                                                BQ256XX_IPRECHG_OFFSET_uA;
 689}
 690
 691static int bq256xx_set_prechrg_curr(struct bq256xx_device *bq, int iprechg)
 692{
 693        unsigned int iprechg_reg_code;
 694
 695        iprechg = clamp(iprechg, BQ256XX_IPRECHG_MIN_uA,
 696                                                BQ256XX_IPRECHG_MAX_uA);
 697
 698        iprechg_reg_code = ((iprechg - BQ256XX_IPRECHG_OFFSET_uA) /
 699                        BQ256XX_IPRECHG_STEP_uA) << BQ256XX_IPRECHG_BIT_SHIFT;
 700
 701        return regmap_update_bits(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 702                                BQ256XX_IPRECHG_MASK, iprechg_reg_code);
 703}
 704
 705static int bq25618_619_get_prechrg_curr(struct bq256xx_device *bq)
 706{
 707        unsigned int prechg_and_term_curr_lim;
 708        unsigned int iprechg_reg_code;
 709        int ret;
 710
 711        ret = regmap_read(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 712                                                &prechg_and_term_curr_lim);
 713        if (ret)
 714                return ret;
 715
 716        iprechg_reg_code = (prechg_and_term_curr_lim & BQ256XX_IPRECHG_MASK)
 717                                                >> BQ256XX_IPRECHG_BIT_SHIFT;
 718
 719        return (iprechg_reg_code * BQ25618_IPRECHG_STEP_uA) +
 720                                                BQ25618_IPRECHG_OFFSET_uA;
 721}
 722
 723static int bq25618_619_set_prechrg_curr(struct bq256xx_device *bq, int iprechg)
 724{
 725        unsigned int iprechg_reg_code;
 726
 727        iprechg = clamp(iprechg, BQ25618_IPRECHG_MIN_uA,
 728                                                BQ25618_IPRECHG_MAX_uA);
 729
 730        iprechg_reg_code = ((iprechg - BQ25618_IPRECHG_OFFSET_uA) /
 731                        BQ25618_IPRECHG_STEP_uA) << BQ256XX_IPRECHG_BIT_SHIFT;
 732
 733        return regmap_update_bits(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 734                                BQ256XX_IPRECHG_MASK, iprechg_reg_code);
 735}
 736
 737static int bq256xx_get_term_curr(struct bq256xx_device *bq)
 738{
 739        unsigned int prechg_and_term_curr_lim;
 740        unsigned int iterm_reg_code;
 741        int ret;
 742
 743        ret = regmap_read(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 744                                                &prechg_and_term_curr_lim);
 745        if (ret)
 746                return ret;
 747
 748        iterm_reg_code = prechg_and_term_curr_lim & BQ256XX_ITERM_MASK;
 749
 750        return (iterm_reg_code * BQ256XX_ITERM_STEP_uA) +
 751                                                BQ256XX_ITERM_OFFSET_uA;
 752}
 753
 754static int bq256xx_set_term_curr(struct bq256xx_device *bq, int iterm)
 755{
 756        unsigned int iterm_reg_code;
 757
 758        iterm = clamp(iterm, BQ256XX_ITERM_MIN_uA, BQ256XX_ITERM_MAX_uA);
 759
 760        iterm_reg_code = (iterm - BQ256XX_ITERM_OFFSET_uA) /
 761                                                        BQ256XX_ITERM_STEP_uA;
 762
 763        return regmap_update_bits(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 764                                BQ256XX_ITERM_MASK, iterm_reg_code);
 765}
 766
 767static int bq25618_619_get_term_curr(struct bq256xx_device *bq)
 768{
 769        unsigned int prechg_and_term_curr_lim;
 770        unsigned int iterm_reg_code;
 771        int ret;
 772
 773        ret = regmap_read(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 774                                                &prechg_and_term_curr_lim);
 775        if (ret)
 776                return ret;
 777
 778        iterm_reg_code = prechg_and_term_curr_lim & BQ256XX_ITERM_MASK;
 779
 780        return (iterm_reg_code * BQ25618_ITERM_STEP_uA) +
 781                                                BQ25618_ITERM_OFFSET_uA;
 782}
 783
 784static int bq25618_619_set_term_curr(struct bq256xx_device *bq, int iterm)
 785{
 786        unsigned int iterm_reg_code;
 787
 788        iterm = clamp(iterm, BQ25618_ITERM_MIN_uA, BQ25618_ITERM_MAX_uA);
 789
 790        iterm_reg_code = (iterm - BQ25618_ITERM_OFFSET_uA) /
 791                                                        BQ25618_ITERM_STEP_uA;
 792
 793        return regmap_update_bits(bq->regmap, BQ256XX_PRECHG_AND_TERM_CURR_LIM,
 794                                BQ256XX_ITERM_MASK, iterm_reg_code);
 795}
 796
 797static int bq256xx_get_input_volt_lim(struct bq256xx_device *bq)
 798{
 799        unsigned int charger_control_2;
 800        unsigned int vindpm_reg_code;
 801        int ret;
 802
 803        ret = regmap_read(bq->regmap, BQ256XX_CHARGER_CONTROL_2,
 804                                                &charger_control_2);
 805        if (ret)
 806                return ret;
 807
 808        vindpm_reg_code = charger_control_2 & BQ256XX_VINDPM_MASK;
 809
 810        return (vindpm_reg_code * BQ256XX_VINDPM_STEP_uV) +
 811                                                BQ256XX_VINDPM_OFFSET_uV;
 812}
 813
 814static int bq256xx_set_input_volt_lim(struct bq256xx_device *bq, int vindpm)
 815{
 816        unsigned int vindpm_reg_code;
 817
 818        vindpm = clamp(vindpm, BQ256XX_VINDPM_MIN_uV, BQ256XX_VINDPM_MAX_uV);
 819
 820        vindpm_reg_code = (vindpm - BQ256XX_VINDPM_OFFSET_uV) /
 821                                                BQ256XX_VINDPM_STEP_uV;
 822
 823        return regmap_update_bits(bq->regmap, BQ256XX_CHARGER_CONTROL_2,
 824                                        BQ256XX_VINDPM_MASK, vindpm_reg_code);
 825}
 826
 827static int bq256xx_get_input_curr_lim(struct bq256xx_device *bq)
 828{
 829        unsigned int input_current_limit;
 830        unsigned int iindpm_reg_code;
 831        int ret;
 832
 833        ret = regmap_read(bq->regmap, BQ256XX_INPUT_CURRENT_LIMIT,
 834                                                &input_current_limit);
 835        if (ret)
 836                return ret;
 837
 838        iindpm_reg_code = input_current_limit & BQ256XX_IINDPM_MASK;
 839
 840        return (iindpm_reg_code * BQ256XX_IINDPM_STEP_uA) +
 841                                                BQ256XX_IINDPM_OFFSET_uA;
 842}
 843
 844static int bq256xx_set_input_curr_lim(struct bq256xx_device *bq, int iindpm)
 845{
 846        unsigned int iindpm_reg_code;
 847
 848        iindpm = clamp(iindpm, BQ256XX_IINDPM_MIN_uA, BQ256XX_IINDPM_MAX_uA);
 849
 850        iindpm_reg_code = (iindpm - BQ256XX_IINDPM_OFFSET_uA) /
 851                                                        BQ256XX_IINDPM_STEP_uA;
 852
 853        return regmap_update_bits(bq->regmap, BQ256XX_INPUT_CURRENT_LIMIT,
 854                                        BQ256XX_IINDPM_MASK, iindpm_reg_code);
 855}
 856
 857static void bq256xx_charger_reset(void *data)
 858{
 859        struct bq256xx_device *bq = data;
 860
 861        regmap_update_bits(bq->regmap, BQ256XX_PART_INFORMATION,
 862                                        BQ256XX_REG_RST, BQ256XX_REG_RST);
 863
 864        if (!IS_ERR_OR_NULL(bq->usb2_phy))
 865                usb_unregister_notifier(bq->usb2_phy, &bq->usb_nb);
 866
 867        if (!IS_ERR_OR_NULL(bq->usb3_phy))
 868                usb_unregister_notifier(bq->usb3_phy, &bq->usb_nb);
 869}
 870
 871static int bq256xx_set_charger_property(struct power_supply *psy,
 872                enum power_supply_property prop,
 873                const union power_supply_propval *val)
 874{
 875        struct bq256xx_device *bq = power_supply_get_drvdata(psy);
 876        int ret = -EINVAL;
 877
 878        switch (prop) {
 879        case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 880                ret = bq->chip_info->bq256xx_set_iindpm(bq, val->intval);
 881                if (ret)
 882                        return ret;
 883                break;
 884
 885        case POWER_SUPPLY_PROP_STATUS:
 886                break;
 887
 888        case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 889                ret = bq->chip_info->bq256xx_set_vbatreg(bq, val->intval);
 890                if (ret)
 891                        return ret;
 892                break;
 893
 894        case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 895                ret = bq->chip_info->bq256xx_set_ichg(bq, val->intval);
 896                if (ret)
 897                        return ret;
 898                break;
 899
 900        case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
 901                ret = bq->chip_info->bq256xx_set_iprechg(bq, val->intval);
 902                if (ret)
 903                        return ret;
 904                break;
 905
 906        case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
 907                ret = bq->chip_info->bq256xx_set_iterm(bq, val->intval);
 908                if (ret)
 909                        return ret;
 910                break;
 911
 912        case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
 913                ret = bq->chip_info->bq256xx_set_vindpm(bq, val->intval);
 914                if (ret)
 915                        return ret;
 916                break;
 917
 918        default:
 919                break;
 920        }
 921
 922        return ret;
 923}
 924
 925
 926static int bq256xx_get_battery_property(struct power_supply *psy,
 927                                enum power_supply_property psp,
 928                                union power_supply_propval *val)
 929{
 930        struct bq256xx_device *bq = power_supply_get_drvdata(psy);
 931
 932        switch (psp) {
 933        case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 934                val->intval = bq->init_data.ichg_max;
 935                break;
 936
 937        case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 938                val->intval = bq->init_data.vbatreg_max;
 939                break;
 940
 941        default:
 942                return -EINVAL;
 943        }
 944
 945        return 0;
 946}
 947
 948static int bq256xx_get_charger_property(struct power_supply *psy,
 949                                enum power_supply_property psp,
 950                                union power_supply_propval *val)
 951{
 952        struct bq256xx_device *bq = power_supply_get_drvdata(psy);
 953        struct bq256xx_state state;
 954        int ret = 0;
 955
 956        mutex_lock(&bq->lock);
 957        ret = bq256xx_get_state(bq, &state);
 958        mutex_unlock(&bq->lock);
 959        if (ret)
 960                return ret;
 961
 962        switch (psp) {
 963        case POWER_SUPPLY_PROP_STATUS:
 964                if (state.vbus_stat == BQ256XX_VBUS_STAT_NO_INPUT ||
 965                    state.vbus_stat == BQ256XX_VBUS_STAT_USB_OTG)
 966                        val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 967                else if (state.chrg_stat == BQ256XX_CHRG_STAT_NOT_CHRGING)
 968                        val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
 969                else if (state.chrg_stat == BQ256XX_CHRG_STAT_CHRG_TERM)
 970                        val->intval = POWER_SUPPLY_STATUS_FULL;
 971                else
 972                        val->intval = POWER_SUPPLY_STATUS_CHARGING;
 973                break;
 974
 975        case POWER_SUPPLY_PROP_HEALTH:
 976                val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
 977                if (state.wdt_fault) {
 978                        val->intval =
 979                                POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE;
 980                } else if (state.bat_fault) {
 981                        val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 982                } else {
 983                        switch (state.chrg_stat) {
 984                        case BQ256XX_CHRG_FAULT_INPUT:
 985                                val->intval =
 986                                        POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 987                                break;
 988                        case BQ256XX_CHRG_FAULT_THERM:
 989                                val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
 990                                break;
 991                        case BQ256XX_CHRG_FAULT_CST_EXPIRE:
 992                                val->intval =
 993                                POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
 994                                break;
 995                        default:
 996                                break;
 997                        }
 998
 999                        switch (state.ntc_fault) {
1000                        case BQ256XX_NTC_FAULT_WARM:
1001                                val->intval = POWER_SUPPLY_HEALTH_WARM;
1002                                break;
1003                        case BQ256XX_NTC_FAULT_COOL:
1004                                val->intval = POWER_SUPPLY_HEALTH_COOL;
1005                                break;
1006                        case BQ256XX_NTC_FAULT_COLD:
1007                                val->intval = POWER_SUPPLY_HEALTH_COLD;
1008                                break;
1009                        case BQ256XX_NTC_FAULT_HOT:
1010                                val->intval = POWER_SUPPLY_HEALTH_HOT;
1011                                break;
1012                        default:
1013                                val->intval = POWER_SUPPLY_HEALTH_GOOD;
1014                                break;
1015                        }
1016                }
1017                break;
1018
1019        case POWER_SUPPLY_PROP_USB_TYPE:
1020                if (bq->chip_info->has_usb_detect) {
1021                        switch (state.vbus_stat) {
1022                        case BQ256XX_VBUS_STAT_USB_SDP:
1023                                val->intval = POWER_SUPPLY_USB_TYPE_SDP;
1024                                break;
1025                        case BQ256XX_VBUS_STAT_USB_CDP:
1026                                val->intval = POWER_SUPPLY_USB_TYPE_CDP;
1027                                break;
1028                        case BQ256XX_VBUS_STAT_USB_DCP:
1029                                val->intval = POWER_SUPPLY_USB_TYPE_DCP;
1030                                break;
1031                        case BQ256XX_VBUS_STAT_USB_OTG:
1032                                val->intval = POWER_SUPPLY_USB_TYPE_ACA;
1033                                break;
1034                        default:
1035                                val->intval = POWER_SUPPLY_USB_TYPE_UNKNOWN;
1036                                break;
1037                        }
1038                } else {
1039                        switch (state.vbus_stat) {
1040                        case BQ256XX_VBUS_STAT_USB_SDP:
1041                                val->intval = POWER_SUPPLY_USB_TYPE_SDP;
1042                                break;
1043                        case BQ256XX_VBUS_STAT_USB_OTG:
1044                                val->intval = POWER_SUPPLY_USB_TYPE_ACA;
1045                                break;
1046                        default:
1047                                val->intval = POWER_SUPPLY_USB_TYPE_UNKNOWN;
1048                                break;
1049                        }
1050                }
1051                break;
1052
1053        case POWER_SUPPLY_PROP_CHARGE_TYPE:
1054                switch (state.chrg_stat) {
1055                case BQ256XX_CHRG_STAT_NOT_CHRGING:
1056                        val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
1057                        break;
1058                case BQ256XX_CHRG_STAT_PRECHRGING:
1059                        val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1060                        break;
1061                case BQ256XX_CHRG_STAT_FAST_CHRGING:
1062                        val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
1063                        break;
1064                case BQ256XX_CHRG_STAT_CHRG_TERM:
1065                        val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1066                        break;
1067                default:
1068                        val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
1069                }
1070                break;
1071
1072        case POWER_SUPPLY_PROP_MANUFACTURER:
1073                val->strval = BQ256XX_MANUFACTURER;
1074                break;
1075
1076        case POWER_SUPPLY_PROP_MODEL_NAME:
1077                val->strval = bq->model_name;
1078                break;
1079
1080        case POWER_SUPPLY_PROP_ONLINE:
1081                val->intval = state.online;
1082                break;
1083
1084        case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
1085                ret = bq->chip_info->bq256xx_get_vindpm(bq);
1086                if (ret < 0)
1087                        return ret;
1088                val->intval = ret;
1089                break;
1090
1091        case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1092                ret = bq->chip_info->bq256xx_get_iindpm(bq);
1093                if (ret < 0)
1094                        return ret;
1095                val->intval = ret;
1096                break;
1097
1098        case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1099                ret = bq->chip_info->bq256xx_get_vbatreg(bq);
1100                if (ret < 0)
1101                        return ret;
1102                val->intval = ret;
1103                break;
1104
1105        case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1106                ret = bq->chip_info->bq256xx_get_ichg(bq);
1107                if (ret < 0)
1108                        return ret;
1109                val->intval = ret;
1110                break;
1111
1112        case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
1113                ret = bq->chip_info->bq256xx_get_iprechg(bq);
1114                if (ret < 0)
1115                        return ret;
1116                val->intval = ret;
1117                break;
1118
1119        case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
1120                ret = bq->chip_info->bq256xx_get_iterm(bq);
1121                if (ret < 0)
1122                        return ret;
1123                val->intval = ret;
1124                break;
1125
1126        default:
1127                return -EINVAL;
1128        }
1129
1130        return ret;
1131}
1132
1133static bool bq256xx_state_changed(struct bq256xx_device *bq,
1134                                  struct bq256xx_state *new_state)
1135{
1136        struct bq256xx_state old_state;
1137
1138        mutex_lock(&bq->lock);
1139        old_state = bq->state;
1140        mutex_unlock(&bq->lock);
1141
1142        return memcmp(&old_state, new_state, sizeof(struct bq256xx_state)) != 0;
1143}
1144
1145static irqreturn_t bq256xx_irq_handler_thread(int irq, void *private)
1146{
1147        struct bq256xx_device *bq = private;
1148        struct bq256xx_state state;
1149        int ret;
1150
1151        ret = bq256xx_get_state(bq, &state);
1152        if (ret < 0)
1153                goto irq_out;
1154
1155        if (!bq256xx_state_changed(bq, &state))
1156                goto irq_out;
1157
1158        mutex_lock(&bq->lock);
1159        bq->state = state;
1160        mutex_unlock(&bq->lock);
1161
1162        power_supply_changed(bq->charger);
1163
1164irq_out:
1165        return IRQ_HANDLED;
1166}
1167
1168static enum power_supply_property bq256xx_power_supply_props[] = {
1169        POWER_SUPPLY_PROP_MANUFACTURER,
1170        POWER_SUPPLY_PROP_MODEL_NAME,
1171        POWER_SUPPLY_PROP_STATUS,
1172        POWER_SUPPLY_PROP_ONLINE,
1173        POWER_SUPPLY_PROP_HEALTH,
1174        POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT,
1175        POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
1176        POWER_SUPPLY_PROP_CHARGE_TYPE,
1177        POWER_SUPPLY_PROP_USB_TYPE,
1178        POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
1179        POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
1180        POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
1181        POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT,
1182};
1183
1184static enum power_supply_property bq256xx_battery_props[] = {
1185        POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
1186        POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
1187};
1188
1189static int bq256xx_property_is_writeable(struct power_supply *psy,
1190                                         enum power_supply_property prop)
1191{
1192        switch (prop) {
1193        case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
1194        case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
1195        case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
1196        case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
1197        case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
1198        case POWER_SUPPLY_PROP_STATUS:
1199        case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT:
1200                return true;
1201        default:
1202                return false;
1203        }
1204}
1205
1206static const struct power_supply_desc bq256xx_power_supply_desc = {
1207        .name = "bq256xx-charger",
1208        .type = POWER_SUPPLY_TYPE_USB,
1209        .usb_types = bq256xx_usb_type,
1210        .num_usb_types = ARRAY_SIZE(bq256xx_usb_type),
1211        .properties = bq256xx_power_supply_props,
1212        .num_properties = ARRAY_SIZE(bq256xx_power_supply_props),
1213        .get_property = bq256xx_get_charger_property,
1214        .set_property = bq256xx_set_charger_property,
1215        .property_is_writeable = bq256xx_property_is_writeable,
1216};
1217
1218static struct power_supply_desc bq256xx_battery_desc = {
1219        .name                   = "bq256xx-battery",
1220        .type                   = POWER_SUPPLY_TYPE_BATTERY,
1221        .get_property           = bq256xx_get_battery_property,
1222        .properties             = bq256xx_battery_props,
1223        .num_properties         = ARRAY_SIZE(bq256xx_battery_props),
1224        .property_is_writeable  = bq256xx_property_is_writeable,
1225};
1226
1227
1228static bool bq256xx_is_volatile_reg(struct device *dev, unsigned int reg)
1229{
1230        switch (reg) {
1231        case BQ256XX_INPUT_CURRENT_LIMIT:
1232        case BQ256XX_CHARGER_STATUS_0...BQ256XX_CHARGER_STATUS_2:
1233                return true;
1234        default:
1235                return false;
1236        }
1237}
1238
1239static const struct regmap_config bq25600_regmap_config = {
1240        .reg_bits = 8,
1241        .val_bits = 8,
1242
1243        .max_register = BQ256XX_PART_INFORMATION,
1244        .reg_defaults   = bq2560x_reg_defs,
1245        .num_reg_defaults = ARRAY_SIZE(bq2560x_reg_defs),
1246        .cache_type = REGCACHE_FLAT,
1247        .volatile_reg = bq256xx_is_volatile_reg,
1248};
1249
1250static const struct regmap_config bq25611d_regmap_config = {
1251        .reg_bits = 8,
1252        .val_bits = 8,
1253
1254        .max_register = BQ256XX_CHARGER_CONTROL_4,
1255        .reg_defaults   = bq25611d_reg_defs,
1256        .num_reg_defaults = ARRAY_SIZE(bq25611d_reg_defs),
1257        .cache_type = REGCACHE_FLAT,
1258        .volatile_reg = bq256xx_is_volatile_reg,
1259};
1260
1261static const struct regmap_config bq25618_619_regmap_config = {
1262        .reg_bits = 8,
1263        .val_bits = 8,
1264
1265        .max_register = BQ256XX_CHARGER_CONTROL_4,
1266        .reg_defaults   = bq25618_619_reg_defs,
1267        .num_reg_defaults = ARRAY_SIZE(bq25618_619_reg_defs),
1268        .cache_type = REGCACHE_FLAT,
1269        .volatile_reg = bq256xx_is_volatile_reg,
1270};
1271
1272static const struct bq256xx_chip_info bq256xx_chip_info_tbl[] = {
1273        [BQ25600] = {
1274                .model_id = BQ25600,
1275                .bq256xx_regmap_config = &bq25600_regmap_config,
1276                .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1277                .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1278                .bq256xx_get_vbatreg = bq2560x_get_chrg_volt,
1279                .bq256xx_get_iterm = bq256xx_get_term_curr,
1280                .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1281                .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1282
1283                .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1284                .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1285                .bq256xx_set_vbatreg = bq2560x_set_chrg_volt,
1286                .bq256xx_set_iterm = bq256xx_set_term_curr,
1287                .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1288                .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1289
1290                .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1291                .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1292                .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1293                .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1294                .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1295                .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1296
1297                .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1298                .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1299
1300                .has_usb_detect = false,
1301        },
1302
1303        [BQ25600D] = {
1304                .model_id = BQ25600D,
1305                .bq256xx_regmap_config = &bq25600_regmap_config,
1306                .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1307                .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1308                .bq256xx_get_vbatreg = bq2560x_get_chrg_volt,
1309                .bq256xx_get_iterm = bq256xx_get_term_curr,
1310                .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1311                .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1312
1313                .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1314                .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1315                .bq256xx_set_vbatreg = bq2560x_set_chrg_volt,
1316                .bq256xx_set_iterm = bq256xx_set_term_curr,
1317                .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1318                .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1319
1320                .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1321                .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1322                .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1323                .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1324                .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1325                .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1326
1327                .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1328                .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1329
1330                .has_usb_detect = true,
1331        },
1332
1333        [BQ25601] = {
1334                .model_id = BQ25601,
1335                .bq256xx_regmap_config = &bq25600_regmap_config,
1336                .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1337                .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1338                .bq256xx_get_vbatreg = bq2560x_get_chrg_volt,
1339                .bq256xx_get_iterm = bq256xx_get_term_curr,
1340                .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1341                .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1342
1343                .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1344                .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1345                .bq256xx_set_vbatreg = bq2560x_set_chrg_volt,
1346                .bq256xx_set_iterm = bq256xx_set_term_curr,
1347                .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1348                .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1349
1350                .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1351                .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1352                .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1353                .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1354                .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1355                .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1356
1357                .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1358                .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1359
1360                .has_usb_detect = false,
1361        },
1362
1363        [BQ25601D] = {
1364                .model_id = BQ25601D,
1365                .bq256xx_regmap_config = &bq25600_regmap_config,
1366                .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1367                .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1368                .bq256xx_get_vbatreg = bq25601d_get_chrg_volt,
1369                .bq256xx_get_iterm = bq256xx_get_term_curr,
1370                .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1371                .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1372
1373                .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1374                .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1375                .bq256xx_set_vbatreg = bq25601d_set_chrg_volt,
1376                .bq256xx_set_iterm = bq256xx_set_term_curr,
1377                .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1378                .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1379
1380                .bq256xx_def_ichg = BQ2560X_ICHG_DEF_uA,
1381                .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1382                .bq256xx_def_vbatreg = BQ2560X_VBATREG_DEF_uV,
1383                .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1384                .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1385                .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1386
1387                .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1388                .bq256xx_max_vbatreg = BQ2560X_VBATREG_MAX_uV,
1389
1390                .has_usb_detect = true,
1391        },
1392
1393        [BQ25611D] = {
1394                .model_id = BQ25611D,
1395                .bq256xx_regmap_config = &bq25611d_regmap_config,
1396                .bq256xx_get_ichg = bq256xx_get_ichg_curr,
1397                .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1398                .bq256xx_get_vbatreg = bq25611d_get_chrg_volt,
1399                .bq256xx_get_iterm = bq256xx_get_term_curr,
1400                .bq256xx_get_iprechg = bq256xx_get_prechrg_curr,
1401                .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1402
1403                .bq256xx_set_ichg = bq256xx_set_ichg_curr,
1404                .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1405                .bq256xx_set_vbatreg = bq25611d_set_chrg_volt,
1406                .bq256xx_set_iterm = bq256xx_set_term_curr,
1407                .bq256xx_set_iprechg = bq256xx_set_prechrg_curr,
1408                .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1409
1410                .bq256xx_def_ichg = BQ25611D_ICHG_DEF_uA,
1411                .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1412                .bq256xx_def_vbatreg = BQ25611D_VBATREG_DEF_uV,
1413                .bq256xx_def_iterm = BQ256XX_ITERM_DEF_uA,
1414                .bq256xx_def_iprechg = BQ256XX_IPRECHG_DEF_uA,
1415                .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1416
1417                .bq256xx_max_ichg = BQ256XX_ICHG_MAX_uA,
1418                .bq256xx_max_vbatreg = BQ25611D_VBATREG_MAX_uV,
1419
1420                .has_usb_detect = true,
1421        },
1422
1423        [BQ25618] = {
1424                .model_id = BQ25618,
1425                .bq256xx_regmap_config = &bq25618_619_regmap_config,
1426                .bq256xx_get_ichg = bq25618_619_get_ichg_curr,
1427                .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1428                .bq256xx_get_vbatreg = bq25618_619_get_chrg_volt,
1429                .bq256xx_get_iterm = bq25618_619_get_term_curr,
1430                .bq256xx_get_iprechg = bq25618_619_get_prechrg_curr,
1431                .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1432
1433                .bq256xx_set_ichg = bq25618_619_set_ichg_curr,
1434                .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1435                .bq256xx_set_vbatreg = bq25618_619_set_chrg_volt,
1436                .bq256xx_set_iterm = bq25618_619_set_term_curr,
1437                .bq256xx_set_iprechg = bq25618_619_set_prechrg_curr,
1438                .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1439
1440                .bq256xx_def_ichg = BQ25618_ICHG_DEF_uA,
1441                .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1442                .bq256xx_def_vbatreg = BQ25618_VBATREG_DEF_uV,
1443                .bq256xx_def_iterm = BQ25618_ITERM_DEF_uA,
1444                .bq256xx_def_iprechg = BQ25618_IPRECHG_DEF_uA,
1445                .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1446
1447                .bq256xx_max_ichg = BQ25618_ICHG_MAX_uA,
1448                .bq256xx_max_vbatreg = BQ25618_VBATREG_MAX_uV,
1449
1450                .has_usb_detect = false,
1451        },
1452
1453        [BQ25619] = {
1454                .model_id = BQ25619,
1455                .bq256xx_regmap_config = &bq25618_619_regmap_config,
1456                .bq256xx_get_ichg = bq25618_619_get_ichg_curr,
1457                .bq256xx_get_iindpm = bq256xx_get_input_curr_lim,
1458                .bq256xx_get_vbatreg = bq25618_619_get_chrg_volt,
1459                .bq256xx_get_iterm = bq25618_619_get_term_curr,
1460                .bq256xx_get_iprechg = bq25618_619_get_prechrg_curr,
1461                .bq256xx_get_vindpm = bq256xx_get_input_volt_lim,
1462
1463                .bq256xx_set_ichg = bq25618_619_set_ichg_curr,
1464                .bq256xx_set_iindpm = bq256xx_set_input_curr_lim,
1465                .bq256xx_set_vbatreg = bq25618_619_set_chrg_volt,
1466                .bq256xx_set_iterm = bq25618_619_set_term_curr,
1467                .bq256xx_set_iprechg = bq25618_619_set_prechrg_curr,
1468                .bq256xx_set_vindpm = bq256xx_set_input_volt_lim,
1469
1470                .bq256xx_def_ichg = BQ25618_ICHG_DEF_uA,
1471                .bq256xx_def_iindpm = BQ256XX_IINDPM_DEF_uA,
1472                .bq256xx_def_vbatreg = BQ25618_VBATREG_DEF_uV,
1473                .bq256xx_def_iterm = BQ25618_ITERM_DEF_uA,
1474                .bq256xx_def_iprechg = BQ25618_IPRECHG_DEF_uA,
1475                .bq256xx_def_vindpm = BQ256XX_VINDPM_DEF_uV,
1476
1477                .bq256xx_max_ichg = BQ25618_ICHG_MAX_uA,
1478                .bq256xx_max_vbatreg = BQ25618_VBATREG_MAX_uV,
1479
1480                .has_usb_detect = false,
1481        },
1482};
1483
1484static int bq256xx_power_supply_init(struct bq256xx_device *bq,
1485                struct power_supply_config *psy_cfg, struct device *dev)
1486{
1487        bq->charger = devm_power_supply_register(bq->dev,
1488                                                 &bq256xx_power_supply_desc,
1489                                                 psy_cfg);
1490        if (IS_ERR(bq->charger)) {
1491                dev_err(dev, "power supply register charger failed\n");
1492                return PTR_ERR(bq->charger);
1493        }
1494
1495        bq->battery = devm_power_supply_register(bq->dev,
1496                                                      &bq256xx_battery_desc,
1497                                                      psy_cfg);
1498        if (IS_ERR(bq->battery)) {
1499                dev_err(dev, "power supply register battery failed\n");
1500                return PTR_ERR(bq->battery);
1501        }
1502        return 0;
1503}
1504
1505static int bq256xx_hw_init(struct bq256xx_device *bq)
1506{
1507        struct power_supply_battery_info bat_info = { };
1508        int wd_reg_val = BQ256XX_WATCHDOG_DIS;
1509        int ret = 0;
1510        int i;
1511
1512        for (i = 0; i < BQ256XX_NUM_WD_VAL; i++) {
1513                if (bq->watchdog_timer == bq256xx_watchdog_time[i]) {
1514                        wd_reg_val = i;
1515                        break;
1516                }
1517                if (bq->watchdog_timer > bq256xx_watchdog_time[i] &&
1518                    bq->watchdog_timer < bq256xx_watchdog_time[i + 1])
1519                        wd_reg_val = i;
1520        }
1521        ret = regmap_update_bits(bq->regmap, BQ256XX_CHARGER_CONTROL_1,
1522                                 BQ256XX_WATCHDOG_MASK, wd_reg_val <<
1523                                                BQ256XX_WDT_BIT_SHIFT);
1524
1525        ret = power_supply_get_battery_info(bq->charger, &bat_info);
1526        if (ret) {
1527                dev_warn(bq->dev, "battery info missing, default values will be applied\n");
1528
1529                bat_info.constant_charge_current_max_ua =
1530                                bq->chip_info->bq256xx_def_ichg;
1531
1532                bat_info.constant_charge_voltage_max_uv =
1533                                bq->chip_info->bq256xx_def_vbatreg;
1534
1535                bat_info.precharge_current_ua =
1536                                bq->chip_info->bq256xx_def_iprechg;
1537
1538                bat_info.charge_term_current_ua =
1539                                bq->chip_info->bq256xx_def_iterm;
1540
1541                bq->init_data.ichg_max =
1542                                bq->chip_info->bq256xx_max_ichg;
1543
1544                bq->init_data.vbatreg_max =
1545                                bq->chip_info->bq256xx_max_vbatreg;
1546        } else {
1547                bq->init_data.ichg_max =
1548                        bat_info.constant_charge_current_max_ua;
1549
1550                bq->init_data.vbatreg_max =
1551                        bat_info.constant_charge_voltage_max_uv;
1552        }
1553
1554        ret = bq->chip_info->bq256xx_set_vindpm(bq, bq->init_data.vindpm);
1555        if (ret)
1556                return ret;
1557
1558        ret = bq->chip_info->bq256xx_set_iindpm(bq, bq->init_data.iindpm);
1559        if (ret)
1560                return ret;
1561
1562        ret = bq->chip_info->bq256xx_set_ichg(bq,
1563                                bat_info.constant_charge_current_max_ua);
1564        if (ret)
1565                return ret;
1566
1567        ret = bq->chip_info->bq256xx_set_iprechg(bq,
1568                                bat_info.precharge_current_ua);
1569        if (ret)
1570                return ret;
1571
1572        ret = bq->chip_info->bq256xx_set_vbatreg(bq,
1573                                bat_info.constant_charge_voltage_max_uv);
1574        if (ret)
1575                return ret;
1576
1577        ret = bq->chip_info->bq256xx_set_iterm(bq,
1578                                bat_info.charge_term_current_ua);
1579        if (ret)
1580                return ret;
1581
1582        power_supply_put_battery_info(bq->charger, &bat_info);
1583
1584        return 0;
1585}
1586
1587static int bq256xx_parse_dt(struct bq256xx_device *bq,
1588                struct power_supply_config *psy_cfg, struct device *dev)
1589{
1590        int ret = 0;
1591
1592        psy_cfg->drv_data = bq;
1593        psy_cfg->of_node = dev->of_node;
1594
1595        ret = device_property_read_u32(bq->dev, "ti,watchdog-timeout-ms",
1596                                       &bq->watchdog_timer);
1597        if (ret)
1598                bq->watchdog_timer = BQ256XX_WATCHDOG_DIS;
1599
1600        if (bq->watchdog_timer > BQ256XX_WATCHDOG_MAX ||
1601            bq->watchdog_timer < BQ256XX_WATCHDOG_DIS)
1602                return -EINVAL;
1603
1604        ret = device_property_read_u32(bq->dev,
1605                                       "input-voltage-limit-microvolt",
1606                                       &bq->init_data.vindpm);
1607        if (ret)
1608                bq->init_data.vindpm = bq->chip_info->bq256xx_def_vindpm;
1609
1610        ret = device_property_read_u32(bq->dev,
1611                                       "input-current-limit-microamp",
1612                                       &bq->init_data.iindpm);
1613        if (ret)
1614                bq->init_data.iindpm = bq->chip_info->bq256xx_def_iindpm;
1615
1616        return 0;
1617}
1618
1619static int bq256xx_probe(struct i2c_client *client,
1620                         const struct i2c_device_id *id)
1621{
1622        struct device *dev = &client->dev;
1623        struct bq256xx_device *bq;
1624        struct power_supply_config psy_cfg = { };
1625
1626        int ret;
1627
1628        bq = devm_kzalloc(dev, sizeof(*bq), GFP_KERNEL);
1629        if (!bq)
1630                return -ENOMEM;
1631
1632        bq->client = client;
1633        bq->dev = dev;
1634        bq->chip_info = &bq256xx_chip_info_tbl[id->driver_data];
1635
1636        mutex_init(&bq->lock);
1637
1638        strncpy(bq->model_name, id->name, I2C_NAME_SIZE);
1639
1640        bq->regmap = devm_regmap_init_i2c(client,
1641                                        bq->chip_info->bq256xx_regmap_config);
1642
1643        if (IS_ERR(bq->regmap)) {
1644                dev_err(dev, "Failed to allocate register map\n");
1645                return PTR_ERR(bq->regmap);
1646        }
1647
1648        i2c_set_clientdata(client, bq);
1649
1650        ret = bq256xx_parse_dt(bq, &psy_cfg, dev);
1651        if (ret) {
1652                dev_err(dev, "Failed to read device tree properties%d\n", ret);
1653                return ret;
1654        }
1655
1656        ret = devm_add_action_or_reset(dev, bq256xx_charger_reset, bq);
1657        if (ret)
1658                return ret;
1659
1660        /* OTG reporting */
1661        bq->usb2_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
1662        if (!IS_ERR_OR_NULL(bq->usb2_phy)) {
1663                INIT_WORK(&bq->usb_work, bq256xx_usb_work);
1664                bq->usb_nb.notifier_call = bq256xx_usb_notifier;
1665                usb_register_notifier(bq->usb2_phy, &bq->usb_nb);
1666        }
1667
1668        bq->usb3_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB3);
1669        if (!IS_ERR_OR_NULL(bq->usb3_phy)) {
1670                INIT_WORK(&bq->usb_work, bq256xx_usb_work);
1671                bq->usb_nb.notifier_call = bq256xx_usb_notifier;
1672                usb_register_notifier(bq->usb3_phy, &bq->usb_nb);
1673        }
1674
1675        if (client->irq) {
1676                ret = devm_request_threaded_irq(dev, client->irq, NULL,
1677                                                bq256xx_irq_handler_thread,
1678                                                IRQF_TRIGGER_FALLING |
1679                                                IRQF_ONESHOT,
1680                                                dev_name(&client->dev), bq);
1681                if (ret < 0) {
1682                        dev_err(dev, "get irq fail: %d\n", ret);
1683                        return ret;
1684                }
1685        }
1686
1687        ret = bq256xx_power_supply_init(bq, &psy_cfg, dev);
1688        if (ret) {
1689                dev_err(dev, "Failed to register power supply\n");
1690                return ret;
1691        }
1692
1693        ret = bq256xx_hw_init(bq);
1694        if (ret) {
1695                dev_err(dev, "Cannot initialize the chip.\n");
1696                return ret;
1697        }
1698
1699        return ret;
1700}
1701
1702static const struct i2c_device_id bq256xx_i2c_ids[] = {
1703        { "bq25600", BQ25600 },
1704        { "bq25600d", BQ25600D },
1705        { "bq25601", BQ25601 },
1706        { "bq25601d", BQ25601D },
1707        { "bq25611d", BQ25611D },
1708        { "bq25618", BQ25618 },
1709        { "bq25619", BQ25619 },
1710        {},
1711};
1712MODULE_DEVICE_TABLE(i2c, bq256xx_i2c_ids);
1713
1714static const struct of_device_id bq256xx_of_match[] = {
1715        { .compatible = "ti,bq25600", .data = (void *)BQ25600 },
1716        { .compatible = "ti,bq25600d", .data = (void *)BQ25600D },
1717        { .compatible = "ti,bq25601", .data = (void *)BQ25601 },
1718        { .compatible = "ti,bq25601d", .data = (void *)BQ25601D },
1719        { .compatible = "ti,bq25611d", .data = (void *)BQ25611D },
1720        { .compatible = "ti,bq25618", .data = (void *)BQ25618 },
1721        { .compatible = "ti,bq25619", .data = (void *)BQ25619 },
1722        { },
1723};
1724MODULE_DEVICE_TABLE(of, bq256xx_of_match);
1725
1726static const struct acpi_device_id bq256xx_acpi_match[] = {
1727        { "bq25600", BQ25600 },
1728        { "bq25600d", BQ25600D },
1729        { "bq25601", BQ25601 },
1730        { "bq25601d", BQ25601D },
1731        { "bq25611d", BQ25611D },
1732        { "bq25618", BQ25618 },
1733        { "bq25619", BQ25619 },
1734        {},
1735};
1736MODULE_DEVICE_TABLE(acpi, bq256xx_acpi_match);
1737
1738static struct i2c_driver bq256xx_driver = {
1739        .driver = {
1740                .name = "bq256xx-charger",
1741                .of_match_table = bq256xx_of_match,
1742                .acpi_match_table = bq256xx_acpi_match,
1743        },
1744        .probe = bq256xx_probe,
1745        .id_table = bq256xx_i2c_ids,
1746};
1747module_i2c_driver(bq256xx_driver);
1748
1749MODULE_AUTHOR("Ricardo Rivera-Matos <r-rivera-matos@ti.com>");
1750MODULE_DESCRIPTION("bq256xx charger driver");
1751MODULE_LICENSE("GPL v2");
1752
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.