drivers/power/bq25700_charger.c

   1 /*
   2  * TI BQ257000 charger driver
   3  *
   4  * Copyright (C) 2016 Rockchip Corporation
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  */
  17
  18 #include <linux/i2c.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/mfd/core.h>
  21 #include <linux/module.h>
  22 #include <linux/regmap.h>
  23 #include <linux/of_device.h>
  24 #include <linux/delay.h>
  25 #include <linux/usb/phy.h>
  26 #include <linux/power/rk_usbbc.h>
  27 #include <linux/extcon.h>
  28 #include <linux/delay.h>
  29 #include <linux/power_supply.h>
  30 #include <linux/gpio.h>
  31 #include <linux/of_gpio.h>
  32
  33 static int dbg_enable;
  34 module_param_named(dbg_level, dbg_enable, int, 0644);
  35
  36 #define DBG(args...) \
  37         do { \
  38                 if (dbg_enable) { \
  39                         pr_info(args); \
  40                 } \
  41         } while (0)
  42
  43 #define bq25700_info(fmt, args...) pr_info("bq25700: "fmt, ##args)
  44
  45 #define BQ25700_MANUFACTURER            "Texas Instruments"
  46 #define BQ25700_ID                      0x59
  47
  48 #define DEFAULT_INPUTVOL                ((5000 - 1280) * 1000)
  49 #define MAX_INPUTVOLTAGE                24000000
  50 #define MAX_INPUTCURRENT                6350000
  51 #define MAX_CHARGEVOLTAGE               16800000
  52 #define MAX_CHARGECURRETNT              8128000
  53 #define MAX_OTGVOLTAGE                  20800000
  54 #define MAX_OTGCURRENT                  6350000
  55
  56 enum bq25700_fields {
  57         EN_LWPWR, WDTWR_ADJ, IDPM_AUTO_DISABLE,
  58         EN_OOA, PWM_FREQ, EN_LEARN, IADP_GAIN, IBAT_GAIN,
  59         EN_LDO, EN_IDPM, CHRG_INHIBIT,/*reg12h*/
  60         CHARGE_CURRENT,/*reg14h*/
  61         MAX_CHARGE_VOLTAGE,/*reg15h*/
  62
  63         AC_STAT, ICO_DONE, IN_VINDPM, IN_IINDPM, IN_FCHRG, IN_PCHRG, IN_OTG,
  64         F_ACOV, F_BATOC, F_ACOC, SYSOVP_STAT, F_LATCHOFF, F_OTG_OVP, F_OTG_OCP,
  65         /*reg20h*/
  66         STAT_COMP, STAT_ICRIT, STAT_INOM, STAT_IDCHG, STAT_VSYS, STAT_BAT_REMOV,
  67         STAT_ADP_REMOV,/*reg21h*/
  68         INPUT_CURRENT_DPM,/*reg22h*/
  69         OUTPUT_INPUT_VOL, OUTPUT_SYS_POWER,/*reg23h*/
  70         OUTPUT_DSG_CUR, OUTPUT_CHG_CUR,/*reg24h*/
  71         OUTPUT_INPUT_CUR, OUTPUT_CMPIN_VOL,/*reg25h*/
  72         OUTPUT_SYS_VOL, OUTPUT_BAT_VOL,/*reg26h*/
  73
  74         EN_IBAT, EN_PROCHOT_LPWR, EN_PSYS, RSNS_RAC, RSNS_RSR,
  75         PSYS_RATIO, CMP_REF,    CMP_POL, CMP_DEG, FORCE_LATCHOFF,
  76         EN_SHIP_DCHG, AUTO_WAKEUP_EN, /*reg30h*/
  77         PKPWR_TOVLD_REG, EN_PKPWR_IDPM, EN_PKPWR_VSYS, PKPWER_OVLD_STAT,
  78         PKPWR_RELAX_STAT, PKPWER_TMAX,  EN_EXTILIM, EN_ICHG_IDCHG, Q2_OCP,
  79         ACX_OCP, EN_ACOC, ACOC_VTH, EN_BATOC, BATCOC_VTH,/*reg31h*/
  80         EN_HIZ, RESET_REG, RESET_VINDPM, EN_OTG, EN_ICO_MODE, BATFETOFF_HIZ,
  81         PSYS_OTG_IDCHG,/*reg32h*/
  82         ILIM2_VTH, ICRIT_DEG, VSYS_VTH, EN_PROCHOT_EXT, PROCHOT_WIDTH,
  83         PROCHOT_CLEAR, INOM_DEG,/*reg33h*/
  84         IDCHG_VTH, IDCHG_DEG, PROCHOT_PROFILE_COMP, PROCHOT_PROFILE_ICRIT,
  85         PROCHOT_PROFILE_INOM, PROCHOT_PROFILE_IDCHG,
  86         PROCHOT_PROFILE_VSYS, PROCHOT_PROFILE_BATPRES, PROCHOT_PROFILE_ACOK,
  87         /*reg34h*/
  88         ADC_CONV, ADC_START, ADC_FULLSCALE, EN_ADC_CMPIN, EN_ADC_VBUS,
  89         EN_ADC_PSYS, EN_ADC_IIN, EN_ADC_IDCHG, EN_ADC_ICHG, EN_ADC_VSYS,
  90         EN_ADC_VBAT,/*reg35h*/
  91
  92         OTG_VOLTAGE,/*reg3bh*/
  93         OTG_CURRENT,/*reg3ch*/
  94         INPUT_VOLTAGE,/*reg3dh*/
  95         MIN_SYS_VOTAGE,/*reg3eh*/
  96         INPUT_CURRENT,/*reg3fh*/
  97
  98         MANUFACTURE_ID,/*regfeh*/
  99         DEVICE_ID,/*regffh*/
 100
 101         F_MAX_FIELDS
 102 };
 103
 104 enum charger_t {
 105         USB_TYPE_UNKNOWN_CHARGER,
 106         USB_TYPE_NONE_CHARGER,
 107         USB_TYPE_USB_CHARGER,
 108         USB_TYPE_AC_CHARGER,
 109         USB_TYPE_CDP_CHARGER,
 110         DC_TYPE_DC_CHARGER,
 111         DC_TYPE_NONE_CHARGER,
 112 };
 113
 114 enum usb_status_t {
 115         USB_STATUS_NONE,
 116         USB_STATUS_USB,
 117         USB_STATUS_AC,
 118         USB_STATUS_PD,
 119         USB_STATUS_OTG,
 120 };
 121
 122 enum tpyec_port_t {
 123         USB_TYPEC_0,
 124         USB_TYPEC_1,
 125 };
 126
 127 /* initial field values, converted to register values */
 128 struct bq25700_init_data {
 129         u32 ichg;       /* charge current               */
 130         u32 max_chg_vol;        /*max charge voltage*/
 131         u32 input_voltage;      /*input voltage*/
 132         u32 input_current;      /*input current*/
 133         u32 input_current_sdp;
 134         u32 input_current_dcp;
 135         u32 input_current_cdp;
 136         u32 sys_min_voltage;    /*mininum system voltage*/
 137         u32 otg_voltage;        /*OTG voltage*/
 138         u32 otg_current;        /*OTG current*/
 139 };
 140
 141 struct bq25700_state {
 142         u8 ac_stat;
 143         u8 ico_done;
 144         u8 in_vindpm;
 145         u8 in_iindpm;
 146         u8 in_fchrg;
 147         u8 in_pchrg;
 148         u8 in_otg;
 149         u8 fault_acov;
 150         u8 fault_batoc;
 151         u8 fault_acoc;
 152         u8 sysovp_stat;
 153         u8 fault_latchoff;
 154         u8 fault_otg_ovp;
 155         u8 fault_otg_ocp;
 156 };
 157
 158 struct bq25700_device {
 159         struct i2c_client                       *client;
 160         struct device                           *dev;
 161         struct power_supply                     *supply_charger;
 162         char                            model_name[I2C_NAME_SIZE];
 163         unsigned int                    irq;
 164         bool                            first_time;
 165         bool                            charger_health_valid;
 166         bool                            battery_health_valid;
 167         bool                            battery_status_valid;
 168
 169         struct workqueue_struct         *usb_charger_wq;
 170         struct workqueue_struct         *dc_charger_wq;
 171         struct workqueue_struct         *finish_sig_wq;
 172         struct delayed_work             usb_work;
 173         struct delayed_work             pd_work;
 174         struct delayed_work             host_work;
 175         struct delayed_work             discnt_work;
 176         struct delayed_work             usb_work1;
 177         struct delayed_work             pd_work1;
 178         struct delayed_work             host_work1;
 179         struct delayed_work             discnt_work1;
 180         struct delayed_work             irq_work;
 181         struct notifier_block           cable_cg_nb;
 182         struct notifier_block           cable_pd_nb;
 183         struct notifier_block           cable_host_nb;
 184         struct notifier_block           cable_discnt_nb;
 185         struct notifier_block           cable_cg_nb1;
 186         struct notifier_block           cable_pd_nb1;
 187         struct notifier_block           cable_host_nb1;
 188         struct notifier_block           cable_discnt_nb1;
 189         struct extcon_dev               *cable_edev;
 190         struct extcon_dev               *cable_edev_1;
 191         int                             typec0_status;
 192         int                             typec1_status;
 193         struct gpio_desc                *typec0_enable_io;
 194         struct gpio_desc                *typec1_enable_io;
 195         struct gpio_desc                *typec0_discharge_io;
 196         struct gpio_desc                *typec1_discharge_io;
 197
 198         struct regmap                   *regmap;
 199         struct regmap_field             *rmap_fields[F_MAX_FIELDS];
 200         int                             chip_id;
 201         struct bq25700_init_data        init_data;
 202         struct bq25700_state            state;
 203         int                             pd_charge_only;
 204 };
 205
 206 static const struct reg_field bq25700_reg_fields[] = {
 207         /*REG12*/
 208         [EN_LWPWR] = REG_FIELD(0x12, 15, 15),
 209         [WDTWR_ADJ] = REG_FIELD(0x12, 13, 14),
 210         [IDPM_AUTO_DISABLE] = REG_FIELD(0x12, 12, 12),
 211         [EN_OOA] = REG_FIELD(0x12, 10, 10),
 212         [PWM_FREQ] = REG_FIELD(0x12, 9, 9),
 213         [EN_LEARN] = REG_FIELD(0x12, 5, 5),
 214         [IADP_GAIN] = REG_FIELD(0x12, 4, 4),
 215         [IBAT_GAIN] = REG_FIELD(0x12, 3, 3),
 216         [EN_LDO] = REG_FIELD(0x12, 2, 2),
 217         [EN_IDPM] = REG_FIELD(0x12, 1, 1),
 218         [CHRG_INHIBIT] = REG_FIELD(0x12, 0, 0),
 219         /*REG0x14*/
 220         [CHARGE_CURRENT] = REG_FIELD(0x14, 6, 12),
 221         /*REG0x15*/
 222         [MAX_CHARGE_VOLTAGE] = REG_FIELD(0x15, 4, 14),
 223         /*REG20*/
 224         [AC_STAT] = REG_FIELD(0x20, 15, 15),
 225         [ICO_DONE] = REG_FIELD(0x20, 14, 14),
 226         [IN_VINDPM] = REG_FIELD(0x20, 12, 12),
 227         [IN_IINDPM] = REG_FIELD(0x20, 11, 11),
 228         [IN_FCHRG] = REG_FIELD(0x20, 10, 10),
 229         [IN_PCHRG] = REG_FIELD(0x20, 9, 9),
 230         [IN_OTG] = REG_FIELD(0x20, 8, 8),
 231         [F_ACOV] = REG_FIELD(0x20, 7, 7),
 232         [F_BATOC] = REG_FIELD(0x20, 6, 6),
 233         [F_ACOC] = REG_FIELD(0x20, 5, 5),
 234         [SYSOVP_STAT] = REG_FIELD(0x20, 4, 4),
 235         [F_LATCHOFF] = REG_FIELD(0x20, 2, 2),
 236         [F_OTG_OVP] = REG_FIELD(0x20, 1, 1),
 237         [F_OTG_OCP] = REG_FIELD(0x20, 0, 0),
 238         /*REG21*/
 239         [STAT_COMP] = REG_FIELD(0x21, 6, 6),
 240         [STAT_ICRIT] = REG_FIELD(0x21, 5, 5),
 241         [STAT_INOM] = REG_FIELD(0x21, 4, 4),
 242         [STAT_IDCHG] = REG_FIELD(0x21, 3, 3),
 243         [STAT_VSYS] = REG_FIELD(0x21, 2, 2),
 244         [STAT_BAT_REMOV] = REG_FIELD(0x21, 1, 1),
 245         [STAT_ADP_REMOV] = REG_FIELD(0x21, 0, 0),
 246         /*REG22*/
 247         [INPUT_CURRENT_DPM] = REG_FIELD(0x22, 8, 14),
 248         /*REG23H*/
 249         [OUTPUT_INPUT_VOL] = REG_FIELD(0x23, 8, 15),
 250         [OUTPUT_SYS_POWER] = REG_FIELD(0x23, 0, 7),
 251         /*REG24H*/
 252         [OUTPUT_DSG_CUR] = REG_FIELD(0x24, 8, 14),
 253         [OUTPUT_CHG_CUR] = REG_FIELD(0x24, 0, 6),
 254         /*REG25H*/
 255         [OUTPUT_INPUT_CUR] = REG_FIELD(0x25, 8, 15),
 256         [OUTPUT_CMPIN_VOL] = REG_FIELD(0x25, 0, 7),
 257         /*REG26H*/
 258         [OUTPUT_SYS_VOL] = REG_FIELD(0x26, 8, 15),
 259         [OUTPUT_BAT_VOL] = REG_FIELD(0x26, 0, 6),
 260
 261         /*REG30*/
 262         [EN_IBAT] = REG_FIELD(0x30, 15, 15),
 263         [EN_PROCHOT_LPWR] = REG_FIELD(0x30, 13, 14),
 264         [EN_PSYS] = REG_FIELD(0x30, 12, 12),
 265         [RSNS_RAC] = REG_FIELD(0x30, 11, 11),
 266         [RSNS_RSR] = REG_FIELD(0x30, 10, 10),
 267         [PSYS_RATIO] = REG_FIELD(0x30, 9, 9),
 268         [CMP_REF] = REG_FIELD(0x30, 7, 7),
 269         [CMP_POL] = REG_FIELD(0x30, 6, 6),
 270         [CMP_DEG] = REG_FIELD(0x30, 4, 5),
 271         [FORCE_LATCHOFF] = REG_FIELD(0x30, 3, 3),
 272         [EN_SHIP_DCHG] = REG_FIELD(0x30, 1, 1),
 273         [AUTO_WAKEUP_EN] = REG_FIELD(0x30, 0, 0),
 274         /*REG31*/
 275         [PKPWR_TOVLD_REG] = REG_FIELD(0x31, 14, 15),
 276         [EN_PKPWR_IDPM] = REG_FIELD(0x31, 13, 13),
 277         [EN_PKPWR_VSYS] = REG_FIELD(0x31, 12, 12),
 278         [PKPWER_OVLD_STAT] = REG_FIELD(0x31, 11, 11),
 279         [PKPWR_RELAX_STAT] = REG_FIELD(0x31, 10, 10),
 280         [PKPWER_TMAX] = REG_FIELD(0x31, 8, 9),
 281         [EN_EXTILIM] = REG_FIELD(0x31, 7, 7),
 282         [EN_ICHG_IDCHG] = REG_FIELD(0x31, 6, 6),
 283         [Q2_OCP] = REG_FIELD(0x31, 5, 5),
 284         [ACX_OCP] = REG_FIELD(0x31, 4, 4),
 285         [EN_ACOC] = REG_FIELD(0x31, 3, 3),
 286         [ACOC_VTH] = REG_FIELD(0x31, 2, 2),
 287         [EN_BATOC] = REG_FIELD(0x31, 1, 1),
 288         [BATCOC_VTH] = REG_FIELD(0x31, 0, 0),
 289         /*REG32*/
 290         [EN_HIZ] = REG_FIELD(0x32, 15, 15),
 291         [RESET_REG] = REG_FIELD(0x32, 14, 14),
 292         [RESET_VINDPM] = REG_FIELD(0x32, 13, 13),
 293         [EN_OTG] = REG_FIELD(0x32, 12, 12),
 294         [EN_ICO_MODE] = REG_FIELD(0x32, 11, 11),
 295         [BATFETOFF_HIZ] = REG_FIELD(0x32, 1, 1),
 296         [PSYS_OTG_IDCHG] = REG_FIELD(0x32, 0, 0),
 297         /*REG33*/
 298         [ILIM2_VTH] = REG_FIELD(0x33, 11, 15),
 299         [ICRIT_DEG] = REG_FIELD(0x33, 9, 10),
 300         [VSYS_VTH] = REG_FIELD(0x33, 6, 7),
 301         [EN_PROCHOT_EXT] = REG_FIELD(0x33, 5, 5),
 302         [PROCHOT_WIDTH] = REG_FIELD(0x33, 3, 4),
 303         [PROCHOT_CLEAR] = REG_FIELD(0x33, 2, 2),
 304         [INOM_DEG] = REG_FIELD(0x33, 1, 1),
 305         /*REG34*/
 306         [IDCHG_VTH] = REG_FIELD(0x34, 10, 15),
 307         [IDCHG_DEG] = REG_FIELD(0x34, 8, 9),
 308         [PROCHOT_PROFILE_COMP] = REG_FIELD(0x34, 6, 6),
 309         [PROCHOT_PROFILE_ICRIT] = REG_FIELD(0x34, 5, 5),
 310         [PROCHOT_PROFILE_INOM] = REG_FIELD(0x34, 4, 4),
 311         [PROCHOT_PROFILE_IDCHG] = REG_FIELD(0x34, 3, 3),
 312         [PROCHOT_PROFILE_VSYS] = REG_FIELD(0x34, 2, 2),
 313         [PROCHOT_PROFILE_BATPRES] = REG_FIELD(0x34, 1, 1),
 314         [PROCHOT_PROFILE_ACOK] = REG_FIELD(0x34, 0, 0),
 315         /*REG35*/
 316         [ADC_CONV] = REG_FIELD(0x35, 15, 15),
 317         [ADC_START] = REG_FIELD(0x35, 14, 14),
 318         [ADC_FULLSCALE] = REG_FIELD(0x35, 13, 13),
 319         [EN_ADC_CMPIN] = REG_FIELD(0x35, 7, 7),
 320         [EN_ADC_VBUS] = REG_FIELD(0x35, 6, 6),
 321         [EN_ADC_PSYS] = REG_FIELD(0x35, 5, 5),
 322         [EN_ADC_IIN] = REG_FIELD(0x35, 4, 4),
 323         [EN_ADC_IDCHG] = REG_FIELD(0x35, 3, 3),
 324         [EN_ADC_ICHG] = REG_FIELD(0x35, 2, 2),
 325         [EN_ADC_VSYS] = REG_FIELD(0x35, 1, 1),
 326         [EN_ADC_VBAT] = REG_FIELD(0x35, 0, 0),
 327         /*REG3B*/
 328         [OTG_VOLTAGE] = REG_FIELD(0x3B, 6, 13),
 329         /*REG3C*/
 330         [OTG_CURRENT] = REG_FIELD(0x3C, 8, 14),
 331         /*REG3D*/
 332         [INPUT_VOLTAGE] = REG_FIELD(0x3D, 6, 13),
 333         /*REG3E*/
 334         [MIN_SYS_VOTAGE] = REG_FIELD(0x3E, 8, 13),
 335         /*REG3F*/
 336         [INPUT_CURRENT] = REG_FIELD(0x3F, 8, 14),
 337
 338         /*REGFE*/
 339         [MANUFACTURE_ID] = REG_FIELD(0xFE, 0, 7),
 340         /*REFFF*/
 341         [DEVICE_ID] = REG_FIELD(0xFF, 0, 7),
 342 };
 343
 344 /*
 345  * Most of the val -> idx conversions can be computed, given the minimum,
 346  * maximum and the step between values. For the rest of conversions, we use
 347  * lookup tables.
 348  */
 349 enum bq25700_table_ids {
 350         /* range tables */
 351         TBL_ICHG,
 352         TBL_CHGMAX,
 353         TBL_INPUTVOL,
 354         TBL_INPUTCUR,
 355         TBL_SYSVMIN,
 356         TBL_OTGVOL,
 357         TBL_OTGCUR,
 358         TBL_EXTCON,
 359 };
 360
 361 struct bq25700_range {
 362         u32 min;
 363         u32 max;
 364         u32 step;
 365 };
 366
 367 struct bq25700_lookup {
 368         const u32 *tbl;
 369         u32 size;
 370 };
 371
 372 static const union {
 373         struct bq25700_range  rt;
 374         struct bq25700_lookup lt;
 375 } bq25700_tables[] = {
 376         /* range tables */
 377         [TBL_ICHG] =    { .rt = {0,       8128000, 64000} },
 378         /* uA */
 379         [TBL_CHGMAX] = { .rt = {0, 19200000, 16000} },
 380         /* uV  max charge voltage*/
 381         [TBL_INPUTVOL] = { .rt = {3200000, 19520000, 64000} },
 382         /* uV  input charge voltage*/
 383         [TBL_INPUTCUR] = {.rt = {0, 6350000, 50000} },
 384         /*uA input current*/
 385         [TBL_SYSVMIN] = { .rt = {1024000, 16182000, 256000} },
 386         /* uV min system voltage*/
 387         [TBL_OTGVOL] = {.rt = {4480000, 20800000, 64000} },
 388         /*uV OTG volage*/
 389         [TBL_OTGCUR] = {.rt = {0, 6350000, 50000} },
 390 };
 391
 392 static const struct regmap_range bq25700_readonly_reg_ranges[] = {
 393         regmap_reg_range(0x20, 0x26),
 394         regmap_reg_range(0xFE, 0xFF),
 395 };
 396
 397 static const struct regmap_access_table bq25700_writeable_regs = {
 398         .no_ranges = bq25700_readonly_reg_ranges,
 399         .n_no_ranges = ARRAY_SIZE(bq25700_readonly_reg_ranges),
 400 };
 401
 402 static const struct regmap_range bq25700_volatile_reg_ranges[] = {
 403         regmap_reg_range(0x12, 0x12),
 404         regmap_reg_range(0x14, 0x15),
 405         regmap_reg_range(0x20, 0x26),
 406         regmap_reg_range(0x30, 0x35),
 407         regmap_reg_range(0x3B, 0x3F),
 408         regmap_reg_range(0xFE, 0xFF),
 409 };
 410
 411 static const struct regmap_access_table bq25700_volatile_regs = {
 412         .yes_ranges = bq25700_volatile_reg_ranges,
 413         .n_yes_ranges = ARRAY_SIZE(bq25700_volatile_reg_ranges),
 414 };
 415
 416 static const struct regmap_config bq25700_regmap_config = {
 417         .reg_bits = 8,
 418         .val_bits = 16,
 419
 420         .max_register = 0xFF,
 421         .cache_type = REGCACHE_RBTREE,
 422
 423         .wr_table = &bq25700_writeable_regs,
 424         .volatile_table = &bq25700_volatile_regs,
 425         .val_format_endian = REGMAP_ENDIAN_LITTLE,
 426 };
 427
 428 static int bq25700_field_read(struct bq25700_device *charger,
 429                               enum bq25700_fields field_id)
 430 {
 431         int ret;
 432         int val;
 433
 434         ret = regmap_field_read(charger->rmap_fields[field_id], &val);
 435         if (ret < 0)
 436                 return ret;
 437
 438         return val;
 439 }
 440
 441 static int bq25700_field_write(struct bq25700_device *charger,
 442                                enum bq25700_fields field_id, unsigned int val)
 443 {
 444         return regmap_field_write(charger->rmap_fields[field_id], val);
 445 }
 446
 447 static int bq25700_get_chip_state(struct bq25700_device *charger,
 448                                   struct bq25700_state *state)
 449 {
 450         int i, ret;
 451
 452         struct {
 453                 enum bq25700_fields id;
 454                 u8 *data;
 455         } state_fields[] = {
 456                 {AC_STAT,       &state->ac_stat},
 457                 {ICO_DONE,      &state->ico_done},
 458                 {IN_VINDPM,     &state->in_vindpm},
 459                 {IN_IINDPM, &state->in_iindpm},
 460                 {IN_FCHRG,      &state->in_fchrg},
 461                 {IN_PCHRG,      &state->in_pchrg},
 462                 {IN_OTG,        &state->in_otg},
 463                 {F_ACOV,        &state->fault_acov},
 464                 {F_BATOC,       &state->fault_batoc},
 465                 {F_ACOC,        &state->fault_acoc},
 466                 {SYSOVP_STAT,   &state->sysovp_stat},
 467                 {F_LATCHOFF,    &state->fault_latchoff},
 468                 {F_OTG_OVP,     &state->fault_otg_ovp},
 469                 {F_OTG_OCP,     &state->fault_otg_ocp},
 470         };
 471
 472         for (i = 0; i < ARRAY_SIZE(state_fields); i++) {
 473                 ret = bq25700_field_read(charger, state_fields[i].id);
 474                 if (ret < 0)
 475                         return ret;
 476
 477                 *state_fields[i].data = ret;
 478         }
 479
 480         return 0;
 481 }
 482
 483 static int bq25700_dump_regs(struct bq25700_device *charger)
 484 {
 485         u32 val = 0;
 486         struct bq25700_state state;
 487         int ret = 0;
 488
 489         ret = bq25700_field_write(charger, ADC_START, 1);
 490         if (ret < 0) {
 491                 DBG("error: ADC_START\n");
 492                 return ret;
 493         }
 494
 495         DBG("\n==================================\n");
 496         regmap_read(charger->regmap, 0x12, &val);
 497         DBG("REG0x12 : 0x%x\n", val);
 498         regmap_read(charger->regmap, 0x14, &val);
 499         DBG("REG0x14 : 0x%x\n", val);
 500         regmap_read(charger->regmap, 0x15, &val);
 501         DBG("REG0x15 : 0x%x\n", val);
 502         regmap_read(charger->regmap, 0x30, &val);
 503         DBG("REG0x30 : 0x%x\n", val);
 504         regmap_read(charger->regmap, 0x31, &val);
 505         DBG("REG0x31 : 0x%x\n", val);
 506         regmap_read(charger->regmap, 0x32, &val);
 507         DBG("REG0x32 : 0x%x\n", val);
 508         regmap_read(charger->regmap, 0x33, &val);
 509         DBG("REG0x33 : 0x%x\n", val);
 510         regmap_read(charger->regmap, 0x34, &val);
 511         DBG("REG0x34 : 0x%x\n", val);
 512         regmap_read(charger->regmap, 0x35, &val);
 513         DBG("REG0x35 : 0x%x\n", val);
 514         regmap_read(charger->regmap, 0x20, &val);
 515         DBG("REG0x20 : 0x%x\n", val);
 516         regmap_read(charger->regmap, 0x21, &val);
 517         DBG("REG0x21 : 0x%x\n", val);
 518         regmap_read(charger->regmap, 0x22, &val);
 519         DBG("REG0x22 : 0x%x\n", val);
 520         regmap_read(charger->regmap, 0x23, &val);
 521         DBG("REG0x23 : 0x%x\n", val);
 522         regmap_read(charger->regmap, 0x24, &val);
 523         DBG("REG0x24 : 0x%x\n", val);
 524         regmap_read(charger->regmap, 0x25, &val);
 525         DBG("REG0x25 : 0x%x\n", val);
 526         regmap_read(charger->regmap, 0x26, &val);
 527         DBG("REG0x26 : 0x%x\n", val);
 528         regmap_read(charger->regmap, 0x3b, &val);
 529         DBG("REG0x3b : 0x%x\n", val);
 530         regmap_read(charger->regmap, 0x3c, &val);
 531         DBG("REG0x3c : 0x%x\n", val);
 532         regmap_read(charger->regmap, 0x3d, &val);
 533         DBG("REG0x3d : 0x%x\n", val);
 534         regmap_read(charger->regmap, 0x3e, &val);
 535         DBG("REG0x3e : 0x%x\n", val);
 536         regmap_read(charger->regmap, 0x3f, &val);
 537         DBG("REG0x3f : 0x%x\n", val);
 538         regmap_read(charger->regmap, 0xfe, &val);
 539         DBG("REG0xfe : 0x%x\n", val);
 540         regmap_read(charger->regmap, 0xff, &val);
 541         DBG("REG0xff : 0x%x\n", val);
 542
 543         DBG("battery charge current: %dmA\n",
 544             bq25700_field_read(charger, OUTPUT_DSG_CUR) * 64);
 545         DBG("battery discharge current: %dmA\n",
 546             bq25700_field_read(charger, OUTPUT_CHG_CUR) * 256);
 547         DBG("VSYS volatge: %dmV\n",
 548             2880 + bq25700_field_read(charger, OUTPUT_SYS_VOL) * 64);
 549         DBG("BAT volatge: %dmV\n",
 550             2880 + bq25700_field_read(charger, OUTPUT_BAT_VOL) * 64);
 551
 552         DBG("SET CHARGE_CURRENT: %dmA\n",
 553             bq25700_field_read(charger, CHARGE_CURRENT) * 64);
 554         DBG("MAX_CHARGE_VOLTAGE: %dmV\n",
 555             bq25700_field_read(charger, MAX_CHARGE_VOLTAGE) * 16);
 556         DBG("     INPUT_VOLTAGE: %dmV\n",
 557             3200 + bq25700_field_read(charger, INPUT_VOLTAGE) * 64);
 558         DBG("     INPUT_CURRENT: %dmA\n",
 559             bq25700_field_read(charger, INPUT_CURRENT) * 50);
 560         DBG("    MIN_SYS_VOTAGE: %dmV\n",
 561             1024 + bq25700_field_read(charger, MIN_SYS_VOTAGE) * 256);
 562         bq25700_get_chip_state(charger, &state);
 563         DBG("status:\n");
 564         DBG("AC_STAT:  %d\n", state.ac_stat);
 565         DBG("ICO_DONE: %d\n", state.ico_done);
 566         DBG("IN_VINDPM: %d\n", state.in_vindpm);
 567         DBG("IN_IINDPM: %d\n", state.in_iindpm);
 568         DBG("IN_FCHRG: %d\n", state.in_fchrg);
 569         DBG("IN_PCHRG: %d\n", state.in_pchrg);
 570         DBG("IN_OTG: %d\n", state.in_otg);
 571         DBG("F_ACOV: %d\n", state.fault_acov);
 572         DBG("F_BATOC: %d\n", state.fault_batoc);
 573         DBG("F_ACOC: %d\n", state.fault_acoc);
 574         DBG("SYSOVP_STAT: %d\n", state.sysovp_stat);
 575         DBG("F_LATCHOFF: %d\n", state.fault_latchoff);
 576         DBG("F_OTGOVP: %d\n", state.fault_otg_ovp);
 577         DBG("F_OTGOCP: %d\n", state.fault_otg_ocp);
 578
 579         DBG("\n+++++++++++++++++++++++++++++++++++++++++++++++++\n");
 580         return 0;
 581 }
 582
 583 ssize_t bq25700_charge_info_show(struct device *dev,
 584                                  struct device_attribute *attr, char *buf)
 585 {
 586         struct bq25700_device *charger = dev_get_drvdata(dev);
 587
 588         bq25700_dump_regs(charger);
 589
 590         return 0;
 591 }
 592
 593 static struct device_attribute bq25700_charger_attr[] = {
 594         __ATTR(charge_info, 0664, bq25700_charge_info_show, NULL),
 595 };
 596
 597 static void bq25700_init_sysfs(struct bq25700_device *charger)
 598 {
 599         int i, ret;
 600
 601         for (i = 0; i < ARRAY_SIZE(bq25700_charger_attr); i++) {
 602                 ret = sysfs_create_file(&charger->dev->kobj,
 603                                         &bq25700_charger_attr[i].attr);
 604                 if (ret)
 605                         dev_err(charger->dev, "create charger node(%s) error\n",
 606                                 bq25700_charger_attr[i].attr.name);
 607         }
 608 }
 609
 610 static u32 bq25700_find_idx(u32 value, enum bq25700_table_ids id)
 611 {
 612         u32 idx;
 613         u32 rtbl_size;
 614         const struct bq25700_range *rtbl = &bq25700_tables[id].rt;
 615
 616         rtbl_size = (rtbl->max - rtbl->min) / rtbl->step + 1;
 617
 618         for (idx = 1;
 619              idx < rtbl_size && (idx * rtbl->step + rtbl->min <= value);
 620              idx++)
 621                 ;
 622
 623         return idx - 1;
 624 }
 625
 626 static int bq25700_fw_read_u32_props(struct bq25700_device *charger)
 627 {
 628         int ret;
 629         u32 property;
 630         int i;
 631         struct bq25700_init_data *init = &charger->init_data;
 632         struct {
 633                 char *name;
 634                 bool optional;
 635                 enum bq25700_table_ids tbl_id;
 636                 u32 *conv_data; /* holds converted value from given property */
 637         } props[] = {
 638                 /* required properties */
 639                 {"ti,charge-current", false, TBL_ICHG,
 640                  &init->ichg},
 641                 {"ti,max-charge-voltage", false, TBL_CHGMAX,
 642                  &init->max_chg_vol},
 643                 {"ti,input-current-sdp", false, TBL_INPUTCUR,
 644                  &init->input_current_sdp},
 645                 {"ti,input-current-dcp", false, TBL_INPUTCUR,
 646                  &init->input_current_dcp},
 647                 {"ti,input-current-cdp", false, TBL_INPUTCUR,
 648                  &init->input_current_cdp},
 649                 {"ti,minimum-sys-voltage", false, TBL_SYSVMIN,
 650                  &init->sys_min_voltage},
 651                 {"ti,otg-voltage", false, TBL_OTGVOL,
 652                  &init->otg_voltage},
 653                 {"ti,otg-current", false, TBL_OTGCUR,
 654                  &init->otg_current},
 655         };
 656
 657         /* initialize data for optional properties */
 658         for (i = 0; i < ARRAY_SIZE(props); i++) {
 659                 ret = device_property_read_u32(charger->dev, props[i].name,
 660                                                &property);
 661                 if (ret < 0) {
 662                         if (props[i].optional)
 663                                 continue;
 664
 665                         return ret;
 666                 }
 667
 668                 if ((props[i].tbl_id == TBL_ICHG) &&
 669                     (property > MAX_CHARGECURRETNT)) {
 670                         dev_err(charger->dev, "ti,charge-current is error\n");
 671                         return -ENODEV;
 672                 }
 673                 if ((props[i].tbl_id == TBL_CHGMAX) &&
 674                     (property > MAX_CHARGEVOLTAGE)) {
 675                         dev_err(charger->dev, "ti,max-charge-voltage is error\n");
 676                         return -ENODEV;
 677                 }
 678                 if ((props[i].tbl_id == TBL_INPUTCUR) &&
 679                     (property > MAX_INPUTCURRENT)) {
 680                         dev_err(charger->dev, "ti,input-current is error\n");
 681                         return -ENODEV;
 682                 }
 683                 if ((props[i].tbl_id == TBL_OTGVOL) &&
 684                     (property > MAX_OTGVOLTAGE)) {
 685                         dev_err(charger->dev, "ti,ti,otg-voltage is error\n");
 686                         return -ENODEV;
 687                 }
 688                 if ((props[i].tbl_id == TBL_OTGVOL) &&
 689                     (property > MAX_OTGCURRENT)) {
 690                         dev_err(charger->dev, "ti,otg-current is error\n");
 691                         return -ENODEV;
 692                 }
 693
 694                 *props[i].conv_data = bq25700_find_idx(property,
 695                                                        props[i].tbl_id);
 696                 DBG("%s, val: %d, tbl_id =%d\n", props[i].name, property,
 697                     *props[i].conv_data);
 698         }
 699
 700         return 0;
 701 }
 702
 703 static int bq25700_chip_reset(struct bq25700_device *charger)
 704 {
 705         int ret;
 706         int rst_check_counter = 10;
 707
 708         ret = bq25700_field_write(charger, RESET_REG, 1);
 709         if (ret < 0)
 710                 return ret;
 711
 712         do {
 713                 ret = bq25700_field_read(charger, RESET_REG);
 714                 if (ret < 0)
 715                         return ret;
 716
 717                 mdelay(4);
 718         } while (ret == 1 && --rst_check_counter);
 719
 720         if (!rst_check_counter)
 721                 return -ETIMEDOUT;
 722
 723         return 0;
 724 }
 725
 726 static int bq25700_hw_init(struct bq25700_device *charger)
 727 {
 728         int ret;
 729         int i;
 730         struct bq25700_state state;
 731
 732         const struct {
 733                 enum bq25700_fields id;
 734                 u32 value;
 735         } init_data[] = {
 736                 {CHARGE_CURRENT,         charger->init_data.ichg},
 737                 {MAX_CHARGE_VOLTAGE,     charger->init_data.max_chg_vol},
 738                 {INPUT_CURRENT,  charger->init_data.input_current},
 739                 {MIN_SYS_VOTAGE,         charger->init_data.sys_min_voltage},
 740                 {OTG_VOLTAGE,    charger->init_data.otg_voltage},
 741                 {OTG_CURRENT,    charger->init_data.otg_current},
 742         };
 743
 744         ret = bq25700_chip_reset(charger);
 745         if (ret < 0)
 746                 return ret;
 747
 748         /* disable watchdog */
 749         ret = bq25700_field_write(charger, WDTWR_ADJ, 0);
 750         if (ret < 0)
 751                 return ret;
 752
 753         /* initialize currents/voltages and other parameters */
 754         for (i = 0; i < ARRAY_SIZE(init_data); i++) {
 755                 ret = bq25700_field_write(charger, init_data[i].id,
 756                                           init_data[i].value);
 757                 if (ret < 0)
 758                         return ret;
 759         }
 760
 761         DBG("    CHARGE_CURRENT: %dmA\n",
 762             bq25700_field_read(charger, CHARGE_CURRENT) * 64);
 763         DBG("MAX_CHARGE_VOLTAGE: %dmV\n",
 764             bq25700_field_read(charger, MAX_CHARGE_VOLTAGE) * 16);
 765         DBG("     INPUT_VOLTAGE: %dmV\n",
 766             3200 + bq25700_field_read(charger, INPUT_VOLTAGE) * 64);
 767         DBG("     INPUT_CURRENT: %dmA\n",
 768             bq25700_field_read(charger, INPUT_CURRENT) * 50);
 769         DBG("    MIN_SYS_VOTAGE: %dmV\n",
 770             1024 + bq25700_field_read(charger, MIN_SYS_VOTAGE) * 256);
 771
 772         /* Configure ADC for continuous conversions. This does not enable it. */
 773
 774         ret = bq25700_field_write(charger, EN_LWPWR, 0);
 775         if (ret < 0) {
 776                 DBG("error: EN_LWPWR\n");
 777                 return ret;
 778         }
 779
 780         ret = bq25700_field_write(charger, ADC_CONV, 1);
 781         if (ret < 0) {
 782                 DBG("error: ADC_CONV\n");
 783                 return ret;
 784         }
 785
 786         ret = bq25700_field_write(charger, ADC_START, 1);
 787         if (ret < 0) {
 788                 DBG("error: ADC_START\n");
 789                 return ret;
 790         }
 791
 792         ret = bq25700_field_write(charger, ADC_FULLSCALE, 1);
 793         if (ret < 0) {
 794                 DBG("error: ADC_FULLSCALE\n");
 795                 return ret;
 796         }
 797
 798         ret = bq25700_field_write(charger, EN_ADC_CMPIN, 1);
 799         if (ret < 0) {
 800                 DBG("error: EN_ADC_CMPIN\n");
 801                 return ret;
 802         }
 803
 804         ret = bq25700_field_write(charger, EN_ADC_VBUS, 1);
 805         if (ret < 0) {
 806                 DBG("error: EN_ADC_VBUS\n");
 807                 return ret;
 808         }
 809
 810         ret = bq25700_field_write(charger, EN_ADC_PSYS, 1);
 811         if (ret < 0) {
 812                 DBG("error: EN_ADC_PSYS\n");
 813                 return ret;
 814         }
 815
 816         ret = bq25700_field_write(charger, EN_ADC_IIN, 1);
 817         if (ret < 0) {
 818                 DBG("error: EN_ADC_IIN\n");
 819                 return ret;
 820         }
 821
 822         ret = bq25700_field_write(charger, EN_ADC_IDCHG, 1);
 823         if (ret < 0) {
 824                 DBG("error: EN_ADC_IDCHG\n");
 825                 return ret;
 826         }
 827
 828         ret = bq25700_field_write(charger, EN_ADC_ICHG, 1);
 829         if (ret < 0) {
 830                 DBG("error: EN_ADC_ICHG\n");
 831                 return ret;
 832         }
 833
 834         ret = bq25700_field_write(charger, EN_ADC_VSYS, 1);
 835         if (ret < 0) {
 836                 DBG("error: EN_ADC_VSYS\n");
 837                 return ret;
 838         }
 839
 840         ret = bq25700_field_write(charger, EN_ADC_VBAT, 1);
 841         if (ret < 0) {
 842                 DBG("error: EN_ADC_VBAT\n");
 843                 return ret;
 844         }
 845
 846         bq25700_get_chip_state(charger, &state);
 847         charger->state = state;
 848
 849         return 0;
 850 }
 851
 852 static int bq25700_fw_probe(struct bq25700_device *charger)
 853 {
 854         int ret;
 855
 856         ret = bq25700_fw_read_u32_props(charger);
 857         if (ret < 0)
 858                 return ret;
 859
 860         return 0;
 861 }
 862
 863 static void bq25700_enable_charger(struct bq25700_device *charger,
 864                                    u32 input_current)
 865 {
 866         bq25700_field_write(charger, INPUT_CURRENT, input_current);
 867         bq25700_field_write(charger, CHARGE_CURRENT, charger->init_data.ichg);
 868 }
 869
 870 static enum power_supply_property bq25700_power_supply_props[] = {
 871         POWER_SUPPLY_PROP_MANUFACTURER,
 872         POWER_SUPPLY_PROP_STATUS,
 873         POWER_SUPPLY_PROP_ONLINE,
 874         POWER_SUPPLY_PROP_HEALTH,
 875         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
 876         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
 877         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 878         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
 879         POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX,
 880         POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
 881 };
 882
 883 static int bq25700_power_supply_get_property(struct power_supply *psy,
 884                                              enum power_supply_property psp,
 885                                              union power_supply_propval *val)
 886 {
 887         int ret;
 888         struct bq25700_device *bq = power_supply_get_drvdata(psy);
 889         struct bq25700_state state;
 890
 891         state = bq->state;
 892
 893         switch (psp) {
 894         case POWER_SUPPLY_PROP_STATUS:
 895                 if (!state.ac_stat)
 896                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 897                 else if (state.in_fchrg == 1 ||
 898                          state.in_pchrg == 1)
 899                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 900                 else
 901                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 902                 break;
 903
 904         case POWER_SUPPLY_PROP_MANUFACTURER:
 905                 val->strval = BQ25700_MANUFACTURER;
 906                 break;
 907
 908         case POWER_SUPPLY_PROP_ONLINE:
 909                 val->intval = state.ac_stat;
 910                 break;
 911
 912         case POWER_SUPPLY_PROP_HEALTH:
 913                 if (!state.fault_acoc &&
 914                     !state.fault_acov && !state.fault_batoc)
 915                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
 916                 else if (state.fault_batoc)
 917                         val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 918                 break;
 919
 920         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 921                 /* read measured value */
 922                 ret = bq25700_field_read(bq, OUTPUT_CHG_CUR);
 923                 if (ret < 0)
 924                         return ret;
 925
 926                 /* converted_val = ADC_val * 64mA  */
 927                 val->intval = ret * 64000;
 928                 break;
 929
 930         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 931                 val->intval = bq25700_tables[TBL_ICHG].rt.max;
 932                 break;
 933
 934         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 935                 if (!state.ac_stat) {
 936                         val->intval = 0;
 937                         break;
 938                 }
 939
 940                 /* read measured value */
 941                 ret = bq25700_field_read(bq, OUTPUT_BAT_VOL);
 942                 if (ret < 0)
 943                         return ret;
 944
 945                 /* converted_val = 2.88V + ADC_val * 64mV */
 946                 val->intval = 2880000 + ret * 64000;
 947                 break;
 948
 949         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 950                 val->intval = bq25700_tables[TBL_CHGMAX].rt.max;
 951                 break;
 952
 953         case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX:
 954                 val->intval = bq25700_tables[TBL_INPUTVOL].rt.max;
 955                 break;
 956
 957         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 958                 val->intval = bq25700_tables[TBL_INPUTCUR].rt.max;
 959                 break;
 960
 961         default:
 962                 return -EINVAL;
 963         }
 964
 965         return 0;
 966 }
 967
 968 static char *bq25700_charger_supplied_to[] = {
 969         "charger",
 970 };
 971
 972 static const struct power_supply_desc bq25700_power_supply_desc = {
 973         .name = "bq25700-charger",
 974         .type = POWER_SUPPLY_TYPE_USB,
 975         .properties = bq25700_power_supply_props,
 976         .num_properties = ARRAY_SIZE(bq25700_power_supply_props),
 977         .get_property = bq25700_power_supply_get_property,
 978 };
 979
 980 static int bq25700_power_supply_init(struct bq25700_device *charger)
 981 {
 982         struct power_supply_config psy_cfg = { .drv_data = charger, };
 983
 984         psy_cfg.supplied_to = bq25700_charger_supplied_to;
 985         psy_cfg.num_supplicants = ARRAY_SIZE(bq25700_charger_supplied_to);
 986
 987         charger->supply_charger =
 988                 power_supply_register(charger->dev,
 989                                       &bq25700_power_supply_desc,
 990                                       &psy_cfg);
 991
 992         return PTR_ERR_OR_ZERO(charger->supply_charger);
 993 }
 994
 995 static irqreturn_t bq25700_irq_handler_thread(int irq, void *private)
 996 {
 997         struct bq25700_device *charger = private;
 998         int ret;
 999         struct bq25700_state state;
1000
1001         ret = bq25700_get_chip_state(charger, &state);
1002         if (ret < 0)
1003                 goto handled;
1004
1005         charger->state = state;
1006
1007         power_supply_changed(charger->supply_charger);
1008
1009 handled:
1010         return IRQ_HANDLED;
1011 }
1012
1013 static void bq25700_enable_typec0(struct bq25700_device *charger)
1014 {
1015         if (!IS_ERR_OR_NULL(charger->typec0_enable_io))
1016                 gpiod_direction_output(charger->typec0_enable_io, 1);
1017         if (!IS_ERR_OR_NULL(charger->typec1_enable_io))
1018                 gpiod_direction_output(charger->typec1_enable_io, 0);
1019 }
1020
1021 static void bq25700_enable_typec1(struct bq25700_device *charger)
1022 {
1023         if (!IS_ERR_OR_NULL(charger->typec0_enable_io))
1024                 gpiod_direction_output(charger->typec0_enable_io, 0);
1025         if (!IS_ERR_OR_NULL(charger->typec1_enable_io))
1026                 gpiod_direction_output(charger->typec1_enable_io, 1);
1027 }
1028
1029 static void bq25700_disable_charge(struct bq25700_device *charger)
1030 {
1031         if (!IS_ERR_OR_NULL(charger->typec0_enable_io))
1032                 gpiod_direction_output(charger->typec0_enable_io, 0);
1033         if (!IS_ERR_OR_NULL(charger->typec1_enable_io))
1034                 gpiod_direction_output(charger->typec1_enable_io, 0);
1035 }
1036
1037 static void bq25700_typec0_discharge(struct bq25700_device *charger)
1038 {
1039         if (!IS_ERR_OR_NULL(charger->typec0_discharge_io))
1040                 gpiod_direction_output(charger->typec0_discharge_io, 1);
1041         msleep(20);
1042         if (!IS_ERR_OR_NULL(charger->typec0_discharge_io))
1043                 gpiod_direction_output(charger->typec0_discharge_io, 0);
1044 }
1045
1046 static void bq25700_typec1_discharge(struct bq25700_device *charger)
1047 {
1048         if (!IS_ERR_OR_NULL(charger->typec1_discharge_io))
1049                 gpiod_direction_output(charger->typec1_discharge_io, 1);
1050         msleep(20);
1051         if (!IS_ERR_OR_NULL(charger->typec1_discharge_io))
1052                 gpiod_direction_output(charger->typec1_discharge_io, 0);
1053 }
1054
1055 static void bq25700_pd_connect(struct bq25700_device *charger,
1056                                struct extcon_dev *edev,
1057                                enum tpyec_port_t port)
1058 {
1059         union extcon_property_value prop_val;
1060         struct bq25700_state state;
1061         int ret;
1062         int vol, cur;
1063         int vol_idx, cur_idx;
1064         int i;
1065
1066         if (charger->typec0_status == USB_STATUS_PD ||
1067             charger->typec1_status == USB_STATUS_PD)
1068                 return;
1069
1070         if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_FAST) > 0) {
1071                 ret = extcon_get_property(edev, EXTCON_CHG_USB_FAST,
1072                                           EXTCON_PROP_USB_TYPEC_POLARITY,
1073                                           &prop_val);
1074                 DBG("usb pd charge...\n");
1075                 vol = prop_val.intval & 0xffff;
1076                 cur = prop_val.intval >> 15;
1077                 if (ret == 0) {
1078                         if (port == USB_TYPEC_0) {
1079                                 charger->typec0_status = USB_STATUS_PD;
1080                                 bq25700_enable_typec0(charger);
1081                         } else {
1082                                 charger->typec1_status = USB_STATUS_PD;
1083                                 bq25700_enable_typec1(charger);
1084                         }
1085
1086                         i = 0;
1087                         while (!bq25700_field_read(charger, AC_STAT) && i < 5) {
1088                                 msleep(1000);
1089                                 i++;
1090                         }
1091                         vol_idx = bq25700_find_idx((vol - 1280) * 1000,
1092                                                    TBL_INPUTVOL);
1093                         cur_idx = bq25700_find_idx(cur * 1000, TBL_INPUTCUR);
1094                         bq25700_field_write(charger, INPUT_VOLTAGE, vol_idx);
1095                         bq25700_field_write(charger, INPUT_CURRENT, cur_idx);
1096                         bq25700_field_write(charger, CHARGE_CURRENT,
1097                                             charger->init_data.ichg);
1098                 }
1099
1100                 bq25700_get_chip_state(charger, &state);
1101                 charger->state = state;
1102                 power_supply_changed(charger->supply_charger);
1103         }
1104 }
1105
1106 static void bq25700_pd_evt_worker(struct work_struct *work)
1107 {
1108         struct bq25700_device *charger = container_of(work,
1109                                 struct bq25700_device, pd_work.work);
1110         struct extcon_dev *edev = charger->cable_edev;
1111
1112         bq25700_pd_connect(charger, edev, USB_TYPEC_0);
1113 }
1114
1115 static void bq25700_pd_evt_worker1(struct work_struct *work)
1116 {
1117         struct bq25700_device *charger = container_of(work,
1118                                 struct bq25700_device, pd_work1.work);
1119         struct extcon_dev *edev = charger->cable_edev_1;
1120
1121         bq25700_pd_connect(charger, edev, USB_TYPEC_1);
1122 }
1123
1124 static int bq25700_pd_evt_notifier(struct notifier_block *nb,
1125                                    unsigned long event,
1126                                    void *ptr)
1127 {
1128         struct bq25700_device *charger =
1129                 container_of(nb, struct bq25700_device, cable_pd_nb);
1130
1131         queue_delayed_work(charger->usb_charger_wq, &charger->pd_work,
1132                            msecs_to_jiffies(10));
1133
1134         return NOTIFY_DONE;
1135 }
1136
1137 static int bq25700_pd_evt_notifier1(struct notifier_block *nb,
1138                                     unsigned long event,
1139                                     void *ptr)
1140 {
1141         struct bq25700_device *charger =
1142                 container_of(nb, struct bq25700_device, cable_pd_nb1);
1143
1144         queue_delayed_work(charger->usb_charger_wq, &charger->pd_work1,
1145                            msecs_to_jiffies(10));
1146
1147         return NOTIFY_DONE;
1148 }
1149
1150 static void bq25700_charger_evt_handel(struct bq25700_device *charger,
1151                                        struct extcon_dev *edev,
1152                                        enum tpyec_port_t port)
1153 {
1154         struct bq25700_state state;
1155         enum charger_t charger_state = USB_TYPE_UNKNOWN_CHARGER;
1156
1157         if (charger->typec0_status == USB_STATUS_PD ||
1158             charger->typec1_status == USB_STATUS_PD)
1159                 return;
1160
1161         /* Determine cable/charger type */
1162         if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_SDP) > 0) {
1163                 charger_state = USB_TYPE_USB_CHARGER;
1164
1165                 bq25700_enable_charger(charger,
1166                                        charger->init_data.input_current_sdp);
1167                 DBG("USB_TYPE_USB_CHARGER\n");
1168         } else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_DCP) > 0) {
1169                 charger_state = USB_TYPE_AC_CHARGER;
1170                 bq25700_enable_charger(charger,
1171                                        charger->init_data.input_current_dcp);
1172                 DBG("USB_TYPE_AC_CHARGER\n");
1173         } else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_CDP) > 0) {
1174                 charger_state = USB_TYPE_CDP_CHARGER;
1175                 bq25700_enable_charger(charger,
1176                                        charger->init_data.input_current_cdp);
1177                 DBG("USB_TYPE_CDP_CHARGER\n");
1178         }
1179         if (port == USB_TYPEC_0) {
1180                 if (charger_state == USB_TYPE_USB_CHARGER)
1181                         charger->typec0_status = USB_STATUS_USB;
1182                 else
1183                         charger->typec0_status = USB_STATUS_AC;
1184                 bq25700_enable_typec0(charger);
1185         } else {
1186                 if (charger_state == USB_TYPE_USB_CHARGER)
1187                         charger->typec1_status = USB_STATUS_USB;
1188                 else
1189                         charger->typec1_status = USB_STATUS_AC;
1190                 bq25700_enable_typec1(charger);
1191         }
1192
1193         bq25700_get_chip_state(charger, &state);
1194         charger->state = state;
1195         power_supply_changed(charger->supply_charger);
1196 }
1197
1198 static void bq25700_charger_evt_worker(struct work_struct *work)
1199 {
1200         struct bq25700_device *charger = container_of(work,
1201                                 struct bq25700_device, usb_work.work);
1202         struct extcon_dev *edev = charger->cable_edev;
1203
1204         bq25700_charger_evt_handel(charger, edev, USB_TYPEC_0);
1205 }
1206
1207 static void bq25700_charger_evt_worker1(struct work_struct *work)
1208 {
1209         struct bq25700_device *charger = container_of(work,
1210                                 struct bq25700_device, usb_work1.work);
1211         struct extcon_dev *edev = charger->cable_edev_1;
1212
1213         bq25700_charger_evt_handel(charger, edev, USB_TYPEC_1);
1214 }
1215
1216 static int bq25700_charger_evt_notifier(struct notifier_block *nb,
1217                                         unsigned long event,
1218                                         void *ptr)
1219 {
1220         struct bq25700_device *charger =
1221                 container_of(nb, struct bq25700_device, cable_cg_nb);
1222
1223         queue_delayed_work(charger->usb_charger_wq, &charger->usb_work,
1224                            msecs_to_jiffies(10));
1225
1226         return NOTIFY_DONE;
1227 }
1228
1229 static int bq25700_charger_evt_notifier1(struct notifier_block *nb,
1230                                          unsigned long event,
1231                                          void *ptr)
1232 {
1233         struct bq25700_device *charger =
1234                 container_of(nb, struct bq25700_device, cable_cg_nb1);
1235
1236         queue_delayed_work(charger->usb_charger_wq, &charger->usb_work1,
1237                            msecs_to_jiffies(10));
1238
1239         return NOTIFY_DONE;
1240 }
1241
1242 static void bq25700_host_evt_worker(struct work_struct *work)
1243 {
1244         struct bq25700_device *charger =
1245                 container_of(work, struct bq25700_device, host_work.work);
1246         struct extcon_dev *edev = charger->cable_edev;
1247
1248         /* Determine cable/charger type */
1249         if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) > 0) {
1250                 bq25700_field_write(charger, EN_OTG, 1);
1251                 DBG("OTG enable\n");
1252         } else if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) == 0) {
1253                 bq25700_field_write(charger, EN_OTG, 0);
1254                 DBG("OTG disable\n");
1255         }
1256 }
1257
1258 static void bq25700_host_evt_worker1(struct work_struct *work)
1259 {
1260         struct bq25700_device *charger =
1261                 container_of(work, struct bq25700_device, host_work1.work);
1262         struct extcon_dev *edev = charger->cable_edev_1;
1263
1264         /* Determine cable/charger type */
1265         if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) > 0) {
1266                 bq25700_field_write(charger, EN_OTG, 1);
1267                 DBG("OTG enable\n");
1268         } else if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) == 0) {
1269                 bq25700_field_write(charger, EN_OTG, 0);
1270                 DBG("OTG disable\n");
1271         }
1272 }
1273
1274 static int bq25700_host_evt_notifier(struct notifier_block *nb,
1275                                      unsigned long event, void *ptr)
1276 {
1277         struct bq25700_device *charger =
1278                 container_of(nb, struct bq25700_device, cable_host_nb);
1279
1280         queue_delayed_work(charger->usb_charger_wq, &charger->host_work,
1281                            msecs_to_jiffies(10));
1282
1283         return NOTIFY_DONE;
1284 }
1285
1286 static int bq25700_host_evt_notifier1(struct notifier_block *nb,
1287                                       unsigned long event, void *ptr)
1288 {
1289         struct bq25700_device *charger =
1290                 container_of(nb, struct bq25700_device, cable_host_nb1);
1291
1292         queue_delayed_work(charger->usb_charger_wq, &charger->host_work1,
1293                            msecs_to_jiffies(10));
1294
1295         return NOTIFY_DONE;
1296 }
1297
1298 static void bq25700_discnt(struct bq25700_device *charger,
1299                            enum tpyec_port_t port)
1300 {
1301         int vol_idx;
1302         struct bq25700_state state;
1303
1304         if (bq25700_field_read(charger, AC_STAT) == 0) {
1305                 bq25700_disable_charge(charger);
1306                 if (port == USB_TYPEC_0) {
1307                         bq25700_typec0_discharge(charger);
1308                         charger->typec0_status = USB_STATUS_NONE;
1309                 } else {
1310                         bq25700_typec1_discharge(charger);
1311                         charger->typec1_status = USB_STATUS_NONE;
1312                 }
1313
1314                 vol_idx = bq25700_find_idx(DEFAULT_INPUTVOL, TBL_INPUTVOL);
1315                 bq25700_field_write(charger, INPUT_VOLTAGE, vol_idx);
1316                 bq25700_field_write(charger, INPUT_CURRENT,
1317                                     charger->init_data.input_current_sdp);
1318                 bq25700_get_chip_state(charger, &state);
1319                 charger->state = state;
1320                 power_supply_changed(charger->supply_charger);
1321         }
1322 }
1323
1324 static void bq25700_discnt_evt_worker(struct work_struct *work)
1325 {
1326         struct bq25700_device *charger = container_of(work,
1327                                                       struct bq25700_device,
1328                                                       discnt_work.work);
1329
1330         bq25700_discnt(charger, USB_TYPEC_0);
1331 }
1332
1333 static void bq25700_discnt_evt_worker1(struct work_struct *work)
1334 {
1335         struct bq25700_device *charger = container_of(work,
1336                                                       struct bq25700_device,
1337                                                       discnt_work1.work);
1338         bq25700_discnt(charger, USB_TYPEC_1);
1339 }
1340
1341 static int bq25700_discnt_evt_notfier(struct notifier_block *nb,
1342                                       unsigned long event,
1343                                       void *ptr)
1344 {
1345         struct bq25700_device *charger =
1346                 container_of(nb, struct bq25700_device, cable_discnt_nb);
1347
1348         queue_delayed_work(charger->usb_charger_wq,
1349                            &charger->discnt_work,
1350                            msecs_to_jiffies(0));
1351
1352         return NOTIFY_DONE;
1353 }
1354
1355 static int bq25700_discnt_evt_notfier1(struct notifier_block *nb,
1356                                        unsigned long event,
1357                                        void *ptr)
1358 {
1359         struct bq25700_device *charger =
1360                 container_of(nb, struct bq25700_device, cable_discnt_nb1);
1361
1362         queue_delayed_work(charger->usb_charger_wq,
1363                            &charger->discnt_work1,
1364                            msecs_to_jiffies(0));
1365
1366         return NOTIFY_DONE;
1367 }
1368
1369 static int bq25700_register_cg_extcon(struct bq25700_device *charger,
1370                                       struct extcon_dev *edev,
1371                                       struct notifier_block *able_cg_nb)
1372 {
1373         int ret;
1374
1375         ret = extcon_register_notifier(edev,
1376                                        EXTCON_CHG_USB_SDP,
1377                                        able_cg_nb);
1378         if (ret < 0) {
1379                 dev_err(charger->dev, "failed to register notifier for SDP\n");
1380                 return -1;
1381         }
1382
1383         ret = extcon_register_notifier(edev,
1384                                        EXTCON_CHG_USB_DCP,
1385                                        able_cg_nb);
1386         if (ret < 0) {
1387                 dev_err(charger->dev, "failed to register notifier for DCP\n");
1388                 return -1;
1389         }
1390
1391         ret = extcon_register_notifier(edev,
1392                                        EXTCON_CHG_USB_CDP,
1393                                        able_cg_nb);
1394         if (ret < 0) {
1395                 dev_err(charger->dev, "failed to register notifier for CDP\n");
1396                 return -1;
1397         }
1398
1399         return 0;
1400 }
1401
1402 static int bq25700_register_cg_nb(struct bq25700_device *charger)
1403 {
1404         if (charger->cable_edev) {
1405                 /* Register chargers  */
1406                 INIT_DELAYED_WORK(&charger->usb_work,
1407                                   bq25700_charger_evt_worker);
1408                 charger->cable_cg_nb.notifier_call =
1409                         bq25700_charger_evt_notifier;
1410                 bq25700_register_cg_extcon(charger, charger->cable_edev,
1411                                            &charger->cable_cg_nb);
1412         }
1413
1414         if (charger->cable_edev_1) {
1415                 INIT_DELAYED_WORK(&charger->usb_work1,
1416                                   bq25700_charger_evt_worker1);
1417                 charger->cable_cg_nb1.notifier_call =
1418                         bq25700_charger_evt_notifier1;
1419                 bq25700_register_cg_extcon(charger, charger->cable_edev_1,
1420                                            &charger->cable_cg_nb1);
1421         }
1422
1423         return 0;
1424 }
1425
1426 static int bq25700_register_discnt_nb(struct bq25700_device *charger)
1427 {
1428         int ret;
1429
1430         /* Register discnt usb */
1431         if (charger->cable_edev) {
1432                 INIT_DELAYED_WORK(&charger->discnt_work,
1433                                   bq25700_discnt_evt_worker);
1434                 charger->cable_discnt_nb.notifier_call =
1435                         bq25700_discnt_evt_notfier;
1436                 ret = extcon_register_notifier(charger->cable_edev,
1437                                                EXTCON_USB,
1438                                                &charger->cable_discnt_nb);
1439                 if (ret < 0) {
1440                         dev_err(charger->dev,
1441                                 "failed to register notifier for HOST\n");
1442                         return ret;
1443                 }
1444         }
1445
1446         if (charger->cable_edev_1) {
1447                 INIT_DELAYED_WORK(&charger->discnt_work1,
1448                                   bq25700_discnt_evt_worker1);
1449                 charger->cable_discnt_nb1.notifier_call =
1450                         bq25700_discnt_evt_notfier1;
1451                 ret = extcon_register_notifier(charger->cable_edev_1,
1452                                                EXTCON_USB,
1453                                                &charger->cable_discnt_nb1);
1454                 if (ret < 0) {
1455                         dev_err(charger->dev,
1456                                 "failed to register notifier for HOST\n");
1457                         return ret;
1458                 }
1459         }
1460
1461         return 0;
1462 }
1463
1464 static int bq25700_register_pd_nb(struct bq25700_device *charger)
1465 {
1466         if (charger->cable_edev) {
1467                 INIT_DELAYED_WORK(&charger->pd_work, bq25700_pd_evt_worker);
1468                 charger->cable_pd_nb.notifier_call = bq25700_pd_evt_notifier;
1469                 extcon_register_notifier(charger->cable_edev,
1470                                          EXTCON_CHG_USB_FAST,
1471                                          &charger->cable_pd_nb);
1472         }
1473
1474         if (charger->cable_edev_1) {
1475                 INIT_DELAYED_WORK(&charger->pd_work1, bq25700_pd_evt_worker1);
1476                 charger->cable_pd_nb1.notifier_call = bq25700_pd_evt_notifier1;
1477                 extcon_register_notifier(charger->cable_edev_1,
1478                                          EXTCON_CHG_USB_FAST,
1479                                          &charger->cable_pd_nb1);
1480         }
1481
1482         return 0;
1483 }
1484
1485 static int bq25700_register_host_nb(struct bq25700_device *charger)
1486 {
1487         int ret;
1488
1489         /* Register host */
1490         if (charger->cable_edev) {
1491                 INIT_DELAYED_WORK(&charger->host_work, bq25700_host_evt_worker);
1492                 charger->cable_host_nb.notifier_call =
1493                         bq25700_host_evt_notifier;
1494                 ret = extcon_register_notifier(charger->cable_edev,
1495                                                EXTCON_USB_HOST,
1496                                                &charger->cable_host_nb);
1497                 if (ret < 0) {
1498                         dev_err(charger->dev,
1499                                 "failed to register notifier for HOST\n");
1500                         return -1;
1501                 }
1502         }
1503
1504         if (charger->cable_edev_1) {
1505                 INIT_DELAYED_WORK(&charger->host_work1,
1506                                   bq25700_host_evt_worker1);
1507                 charger->cable_host_nb1.notifier_call =
1508                         bq25700_host_evt_notifier1;
1509                 ret = extcon_register_notifier(charger->cable_edev_1,
1510                                                EXTCON_USB_HOST,
1511                                                &charger->cable_host_nb1);
1512                 if (ret < 0) {
1513                         dev_err(charger->dev,
1514                                 "failed to register notifier for HOST\n");
1515                         return -1;
1516                 }
1517         }
1518
1519         return 0;
1520 }
1521
1522 static long bq25700_init_usb(struct bq25700_device *charger)
1523 {
1524         struct extcon_dev *edev, *edev1;
1525         struct device *dev = charger->dev;
1526
1527         charger->usb_charger_wq = alloc_ordered_workqueue("%s",
1528                                                           WQ_MEM_RECLAIM |
1529                                                           WQ_FREEZABLE,
1530                                                           "bq25700-usb-wq");
1531         /* type-C */
1532         edev = extcon_get_edev_by_phandle(dev, 0);
1533         if (IS_ERR(edev)) {
1534                 if (PTR_ERR(edev) != -EPROBE_DEFER)
1535                         dev_err(dev, "Invalid or missing extcon\n");
1536                 charger->cable_edev = NULL;
1537         } else {
1538                 charger->cable_edev = edev;
1539         }
1540
1541         edev1 = extcon_get_edev_by_phandle(dev, 1);
1542         if (IS_ERR(edev1)) {
1543                 if (PTR_ERR(edev1) != -EPROBE_DEFER)
1544                         dev_err(dev, "Invalid or missing extcon\n");
1545                 charger->cable_edev_1 = NULL;
1546         } else {
1547                 charger->cable_edev_1 = edev1;
1548         }
1549         if (!charger->pd_charge_only)
1550                 bq25700_register_cg_nb(charger);
1551         bq25700_register_host_nb(charger);
1552         bq25700_register_discnt_nb(charger);
1553         bq25700_register_pd_nb(charger);
1554
1555         if (charger->cable_edev) {
1556                 schedule_delayed_work(&charger->host_work, 0);
1557                 schedule_delayed_work(&charger->pd_work, 0);
1558                 if (!charger->pd_charge_only)
1559                         schedule_delayed_work(&charger->usb_work, 0);
1560         }
1561         if (charger->cable_edev_1) {
1562                 schedule_delayed_work(&charger->host_work1, 0);
1563                 schedule_delayed_work(&charger->pd_work1, 0);
1564                 if (!charger->pd_charge_only)
1565                         schedule_delayed_work(&charger->usb_work1, 0);
1566         }
1567
1568         return 0;
1569 }
1570
1571 static int bq25700_parse_dt(struct bq25700_device *charger)
1572 {
1573         int ret;
1574         struct device_node *np = charger->dev->of_node;
1575
1576         charger->typec0_enable_io = devm_gpiod_get_optional(charger->dev,
1577                                                             "typec0-enable",
1578                                                             GPIOD_IN);
1579         if (!IS_ERR_OR_NULL(charger->typec0_enable_io))
1580                 gpiod_direction_output(charger->typec0_enable_io, 0);
1581
1582         charger->typec1_enable_io = devm_gpiod_get_optional(charger->dev,
1583                                                             "typec1-enable",
1584                                                             GPIOD_IN);
1585         if (!IS_ERR_OR_NULL(charger->typec1_enable_io))
1586                 gpiod_direction_output(charger->typec1_enable_io, 0);
1587
1588         charger->typec0_discharge_io =
1589                 devm_gpiod_get_optional(charger->dev, "typec0-discharge",
1590                                         GPIOD_IN);
1591
1592         charger->typec1_discharge_io =
1593                 devm_gpiod_get_optional(charger->dev, "typec1-discharge",
1594                                         GPIOD_IN);
1595
1596         ret = of_property_read_u32(np, "pd-charge-only",
1597                                    &charger->pd_charge_only);
1598         if (ret < 0)
1599                 dev_err(charger->dev, "pd-charge-only!\n");
1600
1601         return 0;
1602 }
1603
1604 static int bq25700_probe(struct i2c_client *client,
1605                          const struct i2c_device_id *id)
1606 {
1607         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
1608         struct device *dev = &client->dev;
1609         struct bq25700_device *charger;
1610         int ret = 0;
1611         u32 i = 0;
1612
1613         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
1614                 return -EIO;
1615
1616         charger = devm_kzalloc(&client->dev, sizeof(*charger), GFP_KERNEL);
1617         if (!charger)
1618                 return -EINVAL;
1619
1620         charger->client = client;
1621         charger->dev = dev;
1622         charger->regmap = devm_regmap_init_i2c(client,
1623                                                &bq25700_regmap_config);
1624
1625         if (IS_ERR(charger->regmap)) {
1626                 dev_err(&client->dev, "Failed to initialize regmap\n");
1627                 return -EINVAL;
1628         }
1629
1630         for (i = 0; i < ARRAY_SIZE(bq25700_reg_fields); i++) {
1631                 const struct reg_field *reg_fields = bq25700_reg_fields;
1632
1633                 charger->rmap_fields[i] =
1634                         devm_regmap_field_alloc(dev,
1635                                                 charger->regmap,
1636                                                 reg_fields[i]);
1637                 if (IS_ERR(charger->rmap_fields[i])) {
1638                         dev_err(dev, "cannot allocate regmap field\n");
1639                         return PTR_ERR(charger->rmap_fields[i]);
1640                 }
1641         }
1642
1643         i2c_set_clientdata(client, charger);
1644
1645         /*read chip id. Confirm whether to support the chip*/
1646         charger->chip_id = bq25700_field_read(charger, DEVICE_ID);
1647
1648         if (charger->chip_id < 0) {
1649                 dev_err(dev, "Cannot read chip ID.\n");
1650                 return charger->chip_id;
1651         }
1652
1653         if (!dev->platform_data) {
1654                 ret = bq25700_fw_probe(charger);
1655                 if (ret < 0) {
1656                         dev_err(dev, "Cannot read device properties.\n");
1657                         return ret;
1658                 }
1659         } else {
1660                 return -ENODEV;
1661         }
1662
1663         ret = bq25700_hw_init(charger);
1664         if (ret < 0) {
1665                 dev_err(dev, "Cannot initialize the chip.\n");
1666                 return ret;
1667         }
1668
1669         bq25700_parse_dt(charger);
1670
1671         bq25700_init_usb(charger);
1672         bq25700_init_sysfs(charger);
1673
1674         if (client->irq < 0) {
1675                 dev_err(dev, "No irq resource found.\n");
1676                 return client->irq;
1677         }
1678         ret = devm_request_threaded_irq(dev, client->irq, NULL,
1679                                         bq25700_irq_handler_thread,
1680                                         IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1681                                         "bq25700_irq", charger);
1682         if (ret)
1683                 goto irq_fail;
1684
1685         bq25700_power_supply_init(charger);
1686
1687 irq_fail:
1688         return ret;
1689 }
1690
1691 #ifdef CONFIG_PM_SLEEP
1692 static int bq25700_pm_suspend(struct device *dev)
1693 {
1694         return 0;
1695 }
1696
1697 static int bq25700_pm_resume(struct device *dev)
1698 {
1699         return 0;
1700 }
1701 #endif
1702
1703 static SIMPLE_DEV_PM_OPS(bq25700_pm_ops, bq25700_pm_suspend, bq25700_pm_resume);
1704
1705 static const struct i2c_device_id bq25700_i2c_ids[] = {
1706         { "bq25700"},
1707         { },
1708 };
1709 MODULE_DEVICE_TABLE(i2c, bq25700_i2c_ids);
1710
1711 #ifdef CONFIG_OF
1712 static const struct of_device_id bq25700_of_match[] = {
1713         { .compatible = "ti,bq25700", },
1714         { },
1715 };
1716 MODULE_DEVICE_TABLE(of, bq25700_of_match);
1717 #else
1718 static const struct of_device_id bq25700_of_match[] = {
1719         { },
1720 };
1721 #endif
1722
1723 static struct i2c_driver bq25700_driver = {
1724         .probe          = bq25700_probe,
1725         .id_table       = bq25700_i2c_ids,
1726         .driver = {
1727                 .name           = "bq25700-charger",
1728                 .pm             = &bq25700_pm_ops,
1729                 .of_match_table = of_match_ptr(bq25700_of_match),
1730         },
1731 };
1732 module_i2c_driver(bq25700_driver);
1733
1734 MODULE_LICENSE("GPL");
1735 MODULE_AUTHOR("shengfeixu <xsf@rock-chips.com>");
1736 MODULE_DESCRIPTION("TI bq25700 Charger Driver");