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
  31 static int dbg_enable;
  32 module_param_named(dbg_level, dbg_enable, int, 0644);
  33
  34 #define DBG(args...) \
  35         do { \
  36                 if (dbg_enable) { \
  37                         pr_info(args); \
  38                 } \
  39         } while (0)
  40
  41 #define bq25700_info(fmt, args...) pr_info("bq25700: "fmt, ##args)
  42
  43 #define BQ25700_MANUFACTURER            "Texas Instruments"
  44 #define BQ25700_ID                      0x59
  45
  46 #define DEFAULT_INPUTVOL                ((5000 - 1280) * 1000)
  47 #define MAX_INPUTVOLTAGE                24000000
  48 #define MAX_INPUTCURRENT                6350000
  49 #define MAX_CHARGEVOLTAGE               16800000
  50 #define MAX_CHARGECURRETNT              8128000
  51 #define MAX_OTGVOLTAGE                  20800000
  52 #define MAX_OTGCURRENT                  6350000
  53
  54 enum bq25700_fields {
  55         EN_LWPWR, WDTWR_ADJ, IDPM_AUTO_DISABLE,
  56         EN_OOA, PWM_FREQ, EN_LEARN, IADP_GAIN, IBAT_GAIN,
  57         EN_LDO, EN_IDPM, CHRG_INHIBIT,/*reg12h*/
  58         CHARGE_CURRENT,/*reg14h*/
  59         MAX_CHARGE_VOLTAGE,/*reg15h*/
  60
  61         AC_STAT, ICO_DONE, IN_VINDPM, IN_IINDPM, IN_FCHRG, IN_PCHRG, IN_OTG,
  62         F_ACOV, F_BATOC, F_ACOC, SYSOVP_STAT, F_LATCHOFF, F_OTG_OVP, F_OTG_OCP,
  63         /*reg20h*/
  64         STAT_COMP, STAT_ICRIT, STAT_INOM, STAT_IDCHG, STAT_VSYS, STAT_BAT_REMOV,
  65         STAT_ADP_REMOV,/*reg21h*/
  66         INPUT_CURRENT_DPM,/*reg22h*/
  67         OUTPUT_INPUT_VOL, OUTPUT_SYS_POWER,/*reg23h*/
  68         OUTPUT_DSG_CUR, OUTPUT_CHG_CUR,/*reg24h*/
  69         OUTPUT_INPUT_CUR, OUTPUT_CMPIN_VOL,/*reg25h*/
  70         OUTPUT_SYS_VOL, OUTPUT_BAT_VOL,/*reg26h*/
  71
  72         EN_IBAT, EN_PROCHOT_LPWR, EN_PSYS, RSNS_RAC, RSNS_RSR,
  73         PSYS_RATIO, CMP_REF,    CMP_POL, CMP_DEG, FORCE_LATCHOFF,
  74         EN_SHIP_DCHG, AUTO_WAKEUP_EN, /*reg30h*/
  75         PKPWR_TOVLD_REG, EN_PKPWR_IDPM, EN_PKPWR_VSYS, PKPWER_OVLD_STAT,
  76         PKPWR_RELAX_STAT, PKPWER_TMAX,  EN_EXTILIM, EN_ICHG_IDCHG, Q2_OCP,
  77         ACX_OCP, EN_ACOC, ACOC_VTH, EN_BATOC, BATCOC_VTH,/*reg31h*/
  78         EN_HIZ, RESET_REG, RESET_VINDPM, EN_OTG, EN_ICO_MODE, BATFETOFF_HIZ,
  79         PSYS_OTG_IDCHG,/*reg32h*/
  80         ILIM2_VTH, ICRIT_DEG, VSYS_VTH, EN_PROCHOT_EXT, PROCHOT_WIDTH,
  81         PROCHOT_CLEAR, INOM_DEG,/*reg33h*/
  82         IDCHG_VTH, IDCHG_DEG, PROCHOT_PROFILE_COMP, PROCHOT_PROFILE_ICRIT,
  83         PROCHOT_PROFILE_INOM, PROCHOT_PROFILE_IDCHG,
  84         PROCHOT_PROFILE_VSYS, PROCHOT_PROFILE_BATPRES, PROCHOT_PROFILE_ACOK,
  85         /*reg34h*/
  86         ADC_CONV, ADC_START, ADC_FULLSCALE, EN_ADC_CMPIN, EN_ADC_VBUS,
  87         EN_ADC_PSYS, EN_ADC_IIN, EN_ADC_IDCHG, EN_ADC_ICHG, EN_ADC_VSYS,
  88         EN_ADC_VBAT,/*reg35h*/
  89
  90         OTG_VOLTAGE,/*reg3bh*/
  91         OTG_CURRENT,/*reg3ch*/
  92         INPUT_VOLTAGE,/*reg3dh*/
  93         MIN_SYS_VOTAGE,/*reg3eh*/
  94         INPUT_CURRENT,/*reg3fh*/
  95
  96         MANUFACTURE_ID,/*regfeh*/
  97         DEVICE_ID,/*regffh*/
  98
  99         F_MAX_FIELDS
 100 };
 101
 102 enum charger_t {
 103         USB_TYPE_UNKNOWN_CHARGER,
 104         USB_TYPE_NONE_CHARGER,
 105         USB_TYPE_USB_CHARGER,
 106         USB_TYPE_AC_CHARGER,
 107         USB_TYPE_CDP_CHARGER,
 108         DC_TYPE_DC_CHARGER,
 109         DC_TYPE_NONE_CHARGER,
 110 };
 111
 112 /* initial field values, converted to register values */
 113 struct bq25700_init_data {
 114         u32 ichg;       /* charge current               */
 115         u32 max_chg_vol;        /*max charge voltage*/
 116         u32 input_voltage;      /*input voltage*/
 117         u32 input_current;      /*input current*/
 118         u32 input_current_sdp;
 119         u32 input_current_dcp;
 120         u32 input_current_cdp;
 121         u32 sys_min_voltage;    /*mininum system voltage*/
 122         u32 otg_voltage;        /*OTG voltage*/
 123         u32 otg_current;        /*OTG current*/
 124 };
 125
 126 struct bq25700_state {
 127         u8 ac_stat;
 128         u8 ico_done;
 129         u8 in_vindpm;
 130         u8 in_iindpm;
 131         u8 in_fchrg;
 132         u8 in_pchrg;
 133         u8 in_otg;
 134         u8 fault_acov;
 135         u8 fault_batoc;
 136         u8 fault_acoc;
 137         u8 sysovp_stat;
 138         u8 fault_latchoff;
 139         u8 fault_otg_ovp;
 140         u8 fault_otg_ocp;
 141 };
 142
 143 struct bq25700_device {
 144         struct i2c_client                       *client;
 145         struct device                           *dev;
 146         struct power_supply                     *supply_charger;
 147         char                            model_name[I2C_NAME_SIZE];
 148         unsigned int                    irq;
 149         bool                            first_time;
 150         bool                            charger_health_valid;
 151         bool                            battery_health_valid;
 152         bool                            battery_status_valid;
 153
 154         struct workqueue_struct         *usb_charger_wq;
 155         struct workqueue_struct         *dc_charger_wq;
 156         struct workqueue_struct         *finish_sig_wq;
 157         struct delayed_work             usb_work;
 158         struct delayed_work             pd_work;
 159         struct delayed_work             host_work;
 160         struct delayed_work             discnt_work;
 161         struct delayed_work             irq_work;
 162         struct notifier_block           cable_cg_nb;
 163         struct notifier_block           cable_pd_nb;
 164         struct notifier_block           cable_host_nb;
 165         struct notifier_block           cable_discnt_nb;
 166         struct extcon_dev               *cable_edev;
 167
 168         struct regmap                   *regmap;
 169         struct regmap_field             *rmap_fields[F_MAX_FIELDS];
 170         int                             chip_id;
 171         struct bq25700_init_data        init_data;
 172         struct bq25700_state            state;
 173 };
 174
 175 static const struct reg_field bq25700_reg_fields[] = {
 176         /*REG12*/
 177         [EN_LWPWR] = REG_FIELD(0x12, 15, 15),
 178         [WDTWR_ADJ] = REG_FIELD(0x12, 13, 14),
 179         [IDPM_AUTO_DISABLE] = REG_FIELD(0x12, 12, 12),
 180         [EN_OOA] = REG_FIELD(0x12, 10, 10),
 181         [PWM_FREQ] = REG_FIELD(0x12, 9, 9),
 182         [EN_LEARN] = REG_FIELD(0x12, 5, 5),
 183         [IADP_GAIN] = REG_FIELD(0x12, 4, 4),
 184         [IBAT_GAIN] = REG_FIELD(0x12, 3, 3),
 185         [EN_LDO] = REG_FIELD(0x12, 2, 2),
 186         [EN_IDPM] = REG_FIELD(0x12, 1, 1),
 187         [CHRG_INHIBIT] = REG_FIELD(0x12, 0, 0),
 188         /*REG0x14*/
 189         [CHARGE_CURRENT] = REG_FIELD(0x14, 6, 12),
 190         /*REG0x15*/
 191         [MAX_CHARGE_VOLTAGE] = REG_FIELD(0x15, 4, 14),
 192         /*REG20*/
 193         [AC_STAT] = REG_FIELD(0x20, 15, 15),
 194         [ICO_DONE] = REG_FIELD(0x20, 14, 14),
 195         [IN_VINDPM] = REG_FIELD(0x20, 12, 12),
 196         [IN_IINDPM] = REG_FIELD(0x20, 11, 11),
 197         [IN_FCHRG] = REG_FIELD(0x20, 10, 10),
 198         [IN_PCHRG] = REG_FIELD(0x20, 9, 9),
 199         [IN_OTG] = REG_FIELD(0x20, 8, 8),
 200         [F_ACOV] = REG_FIELD(0x20, 7, 7),
 201         [F_BATOC] = REG_FIELD(0x20, 6, 6),
 202         [F_ACOC] = REG_FIELD(0x20, 5, 5),
 203         [SYSOVP_STAT] = REG_FIELD(0x20, 4, 4),
 204         [F_LATCHOFF] = REG_FIELD(0x20, 2, 2),
 205         [F_OTG_OVP] = REG_FIELD(0x20, 1, 1),
 206         [F_OTG_OCP] = REG_FIELD(0x20, 0, 0),
 207         /*REG21*/
 208         [STAT_COMP] = REG_FIELD(0x21, 6, 6),
 209         [STAT_ICRIT] = REG_FIELD(0x21, 5, 5),
 210         [STAT_INOM] = REG_FIELD(0x21, 4, 4),
 211         [STAT_IDCHG] = REG_FIELD(0x21, 3, 3),
 212         [STAT_VSYS] = REG_FIELD(0x21, 2, 2),
 213         [STAT_BAT_REMOV] = REG_FIELD(0x21, 1, 1),
 214         [STAT_ADP_REMOV] = REG_FIELD(0x21, 0, 0),
 215         /*REG22*/
 216         [INPUT_CURRENT_DPM] = REG_FIELD(0x22, 8, 14),
 217         /*REG23H*/
 218         [OUTPUT_INPUT_VOL] = REG_FIELD(0x23, 8, 15),
 219         [OUTPUT_SYS_POWER] = REG_FIELD(0x23, 0, 7),
 220         /*REG24H*/
 221         [OUTPUT_DSG_CUR] = REG_FIELD(0x24, 8, 14),
 222         [OUTPUT_CHG_CUR] = REG_FIELD(0x24, 0, 6),
 223         /*REG25H*/
 224         [OUTPUT_INPUT_CUR] = REG_FIELD(0x25, 8, 15),
 225         [OUTPUT_CMPIN_VOL] = REG_FIELD(0x25, 0, 7),
 226         /*REG26H*/
 227         [OUTPUT_SYS_VOL] = REG_FIELD(0x26, 8, 15),
 228         [OUTPUT_BAT_VOL] = REG_FIELD(0x26, 0, 6),
 229
 230         /*REG30*/
 231         [EN_IBAT] = REG_FIELD(0x30, 15, 15),
 232         [EN_PROCHOT_LPWR] = REG_FIELD(0x30, 13, 14),
 233         [EN_PSYS] = REG_FIELD(0x30, 12, 12),
 234         [RSNS_RAC] = REG_FIELD(0x30, 11, 11),
 235         [RSNS_RSR] = REG_FIELD(0x30, 10, 10),
 236         [PSYS_RATIO] = REG_FIELD(0x30, 9, 9),
 237         [CMP_REF] = REG_FIELD(0x30, 7, 7),
 238         [CMP_POL] = REG_FIELD(0x30, 6, 6),
 239         [CMP_DEG] = REG_FIELD(0x30, 4, 5),
 240         [FORCE_LATCHOFF] = REG_FIELD(0x30, 3, 3),
 241         [EN_SHIP_DCHG] = REG_FIELD(0x30, 1, 1),
 242         [AUTO_WAKEUP_EN] = REG_FIELD(0x30, 0, 0),
 243         /*REG31*/
 244         [PKPWR_TOVLD_REG] = REG_FIELD(0x31, 14, 15),
 245         [EN_PKPWR_IDPM] = REG_FIELD(0x31, 13, 13),
 246         [EN_PKPWR_VSYS] = REG_FIELD(0x31, 12, 12),
 247         [PKPWER_OVLD_STAT] = REG_FIELD(0x31, 11, 11),
 248         [PKPWR_RELAX_STAT] = REG_FIELD(0x31, 10, 10),
 249         [PKPWER_TMAX] = REG_FIELD(0x31, 8, 9),
 250         [EN_EXTILIM] = REG_FIELD(0x31, 7, 7),
 251         [EN_ICHG_IDCHG] = REG_FIELD(0x31, 6, 6),
 252         [Q2_OCP] = REG_FIELD(0x31, 5, 5),
 253         [ACX_OCP] = REG_FIELD(0x31, 4, 4),
 254         [EN_ACOC] = REG_FIELD(0x31, 3, 3),
 255         [ACOC_VTH] = REG_FIELD(0x31, 2, 2),
 256         [EN_BATOC] = REG_FIELD(0x31, 1, 1),
 257         [BATCOC_VTH] = REG_FIELD(0x31, 0, 0),
 258         /*REG32*/
 259         [EN_HIZ] = REG_FIELD(0x32, 15, 15),
 260         [RESET_REG] = REG_FIELD(0x32, 14, 14),
 261         [RESET_VINDPM] = REG_FIELD(0x32, 13, 13),
 262         [EN_OTG] = REG_FIELD(0x32, 12, 12),
 263         [EN_ICO_MODE] = REG_FIELD(0x32, 11, 11),
 264         [BATFETOFF_HIZ] = REG_FIELD(0x32, 1, 1),
 265         [PSYS_OTG_IDCHG] = REG_FIELD(0x32, 0, 0),
 266         /*REG33*/
 267         [ILIM2_VTH] = REG_FIELD(0x33, 11, 15),
 268         [ICRIT_DEG] = REG_FIELD(0x33, 9, 10),
 269         [VSYS_VTH] = REG_FIELD(0x33, 6, 7),
 270         [EN_PROCHOT_EXT] = REG_FIELD(0x33, 5, 5),
 271         [PROCHOT_WIDTH] = REG_FIELD(0x33, 3, 4),
 272         [PROCHOT_CLEAR] = REG_FIELD(0x33, 2, 2),
 273         [INOM_DEG] = REG_FIELD(0x33, 1, 1),
 274         /*REG34*/
 275         [IDCHG_VTH] = REG_FIELD(0x34, 10, 15),
 276         [IDCHG_DEG] = REG_FIELD(0x34, 8, 9),
 277         [PROCHOT_PROFILE_COMP] = REG_FIELD(0x34, 6, 6),
 278         [PROCHOT_PROFILE_ICRIT] = REG_FIELD(0x34, 5, 5),
 279         [PROCHOT_PROFILE_INOM] = REG_FIELD(0x34, 4, 4),
 280         [PROCHOT_PROFILE_IDCHG] = REG_FIELD(0x34, 3, 3),
 281         [PROCHOT_PROFILE_VSYS] = REG_FIELD(0x34, 2, 2),
 282         [PROCHOT_PROFILE_BATPRES] = REG_FIELD(0x34, 1, 1),
 283         [PROCHOT_PROFILE_ACOK] = REG_FIELD(0x34, 0, 0),
 284         /*REG35*/
 285         [ADC_CONV] = REG_FIELD(0x35, 15, 15),
 286         [ADC_START] = REG_FIELD(0x35, 14, 14),
 287         [ADC_FULLSCALE] = REG_FIELD(0x35, 13, 13),
 288         [EN_ADC_CMPIN] = REG_FIELD(0x35, 7, 7),
 289         [EN_ADC_VBUS] = REG_FIELD(0x35, 6, 6),
 290         [EN_ADC_PSYS] = REG_FIELD(0x35, 5, 5),
 291         [EN_ADC_IIN] = REG_FIELD(0x35, 4, 4),
 292         [EN_ADC_IDCHG] = REG_FIELD(0x35, 3, 3),
 293         [EN_ADC_ICHG] = REG_FIELD(0x35, 2, 2),
 294         [EN_ADC_VSYS] = REG_FIELD(0x35, 1, 1),
 295         [EN_ADC_VBAT] = REG_FIELD(0x35, 0, 0),
 296         /*REG3B*/
 297         [OTG_VOLTAGE] = REG_FIELD(0x3B, 6, 13),
 298         /*REG3C*/
 299         [OTG_CURRENT] = REG_FIELD(0x3C, 8, 14),
 300         /*REG3D*/
 301         [INPUT_VOLTAGE] = REG_FIELD(0x3D, 6, 13),
 302         /*REG3E*/
 303         [MIN_SYS_VOTAGE] = REG_FIELD(0x3E, 8, 13),
 304         /*REG3F*/
 305         [INPUT_CURRENT] = REG_FIELD(0x3F, 8, 14),
 306
 307         /*REGFE*/
 308         [MANUFACTURE_ID] = REG_FIELD(0xFE, 0, 7),
 309         /*REFFF*/
 310         [DEVICE_ID] = REG_FIELD(0xFF, 0, 7),
 311 };
 312
 313 /*
 314  * Most of the val -> idx conversions can be computed, given the minimum,
 315  * maximum and the step between values. For the rest of conversions, we use
 316  * lookup tables.
 317  */
 318 enum bq25700_table_ids {
 319         /* range tables */
 320         TBL_ICHG,
 321         TBL_CHGMAX,
 322         TBL_INPUTVOL,
 323         TBL_INPUTCUR,
 324         TBL_SYSVMIN,
 325         TBL_OTGVOL,
 326         TBL_OTGCUR,
 327         TBL_EXTCON,
 328 };
 329
 330 struct bq25700_range {
 331         u32 min;
 332         u32 max;
 333         u32 step;
 334 };
 335
 336 struct bq25700_lookup {
 337         const u32 *tbl;
 338         u32 size;
 339 };
 340
 341 static const union {
 342         struct bq25700_range  rt;
 343         struct bq25700_lookup lt;
 344 } bq25700_tables[] = {
 345         /* range tables */
 346         [TBL_ICHG] =    { .rt = {0,       8128000, 64000} },
 347         /* uA */
 348         [TBL_CHGMAX] = { .rt = {0, 19200000, 16000} },
 349         /* uV  max charge voltage*/
 350         [TBL_INPUTVOL] = { .rt = {3200000, 19520000, 64000} },
 351         /* uV  input charge voltage*/
 352         [TBL_INPUTCUR] = {.rt = {0, 6350000, 50000} },
 353         /*uA input current*/
 354         [TBL_SYSVMIN] = { .rt = {1024000, 16182000, 256000} },
 355         /* uV min system voltage*/
 356         [TBL_OTGVOL] = {.rt = {4480000, 20800000, 64000} },
 357         /*uV OTG volage*/
 358         [TBL_OTGCUR] = {.rt = {0, 6350000, 50000} },
 359 };
 360
 361 static const struct regmap_range bq25700_readonly_reg_ranges[] = {
 362         regmap_reg_range(0x20, 0x26),
 363         regmap_reg_range(0xFE, 0xFF),
 364 };
 365
 366 static const struct regmap_access_table bq25700_writeable_regs = {
 367         .no_ranges = bq25700_readonly_reg_ranges,
 368         .n_no_ranges = ARRAY_SIZE(bq25700_readonly_reg_ranges),
 369 };
 370
 371 static const struct regmap_range bq25700_volatile_reg_ranges[] = {
 372         regmap_reg_range(0x12, 0x12),
 373         regmap_reg_range(0x14, 0x15),
 374         regmap_reg_range(0x20, 0x26),
 375         regmap_reg_range(0x30, 0x35),
 376         regmap_reg_range(0x3B, 0x3F),
 377         regmap_reg_range(0xFE, 0xFF),
 378 };
 379
 380 static const struct regmap_access_table bq25700_volatile_regs = {
 381         .yes_ranges = bq25700_volatile_reg_ranges,
 382         .n_yes_ranges = ARRAY_SIZE(bq25700_volatile_reg_ranges),
 383 };
 384
 385 static const struct regmap_config bq25700_regmap_config = {
 386         .reg_bits = 8,
 387         .val_bits = 16,
 388
 389         .max_register = 0xFF,
 390         .cache_type = REGCACHE_RBTREE,
 391
 392         .wr_table = &bq25700_writeable_regs,
 393         .volatile_table = &bq25700_volatile_regs,
 394         .val_format_endian = REGMAP_ENDIAN_LITTLE,
 395 };
 396
 397 static int bq25700_field_read(struct bq25700_device *charger,
 398                               enum bq25700_fields field_id)
 399 {
 400         int ret;
 401         int val;
 402
 403         ret = regmap_field_read(charger->rmap_fields[field_id], &val);
 404         if (ret < 0)
 405                 return ret;
 406
 407         return val;
 408 }
 409
 410 static int bq25700_field_write(struct bq25700_device *charger,
 411                                enum bq25700_fields field_id, unsigned int val)
 412 {
 413         return regmap_field_write(charger->rmap_fields[field_id], val);
 414 }
 415
 416 static int bq25700_get_chip_state(struct bq25700_device *charger,
 417                                   struct bq25700_state *state)
 418 {
 419         int i, ret;
 420
 421         struct {
 422                 enum bq25700_fields id;
 423                 u8 *data;
 424         } state_fields[] = {
 425                 {AC_STAT,       &state->ac_stat},
 426                 {ICO_DONE,      &state->ico_done},
 427                 {IN_VINDPM,     &state->in_vindpm},
 428                 {IN_IINDPM, &state->in_iindpm},
 429                 {IN_FCHRG,      &state->in_fchrg},
 430                 {IN_PCHRG,      &state->in_pchrg},
 431                 {IN_OTG,        &state->in_otg},
 432                 {F_ACOV,        &state->fault_acov},
 433                 {F_BATOC,       &state->fault_batoc},
 434                 {F_ACOC,        &state->fault_acoc},
 435                 {SYSOVP_STAT,   &state->sysovp_stat},
 436                 {F_LATCHOFF,    &state->fault_latchoff},
 437                 {F_OTG_OVP,     &state->fault_otg_ovp},
 438                 {F_OTG_OCP,     &state->fault_otg_ocp},
 439         };
 440
 441         for (i = 0; i < ARRAY_SIZE(state_fields); i++) {
 442                 ret = bq25700_field_read(charger, state_fields[i].id);
 443                 if (ret < 0)
 444                         return ret;
 445
 446                 *state_fields[i].data = ret;
 447         }
 448
 449         DBG("status:\n");
 450         DBG("AC_STAT:  %d\n", state->ac_stat);
 451         DBG("ICO_DONE: %d\n", state->ico_done);
 452         DBG("IN_VINDPM: %d\n", state->in_vindpm);
 453         DBG("IN_IINDPM: %d\n", state->in_iindpm);
 454         DBG("IN_FCHRG: %d\n", state->in_fchrg);
 455         DBG("IN_PCHRG: %d\n", state->in_pchrg);
 456         DBG("IN_OTG: %d\n", state->in_otg);
 457         DBG("F_ACOV: %d\n", state->fault_acov);
 458         DBG("F_BATOC: %d\n", state->fault_batoc);
 459         DBG("F_ACOC: %d\n", state->fault_acoc);
 460         DBG("SYSOVP_STAT: %d\n", state->sysovp_stat);
 461         DBG("F_LATCHOFF: %d\n", state->fault_latchoff);
 462         DBG("F_OTGOVP: %d\n", state->fault_otg_ovp);
 463         DBG("F_OTGOCP: %d\n", state->fault_otg_ocp);
 464         return 0;
 465 }
 466
 467 static u32 bq25700_find_idx(u32 value, enum bq25700_table_ids id)
 468 {
 469         u32 idx;
 470         u32 rtbl_size;
 471         const struct bq25700_range *rtbl = &bq25700_tables[id].rt;
 472
 473         rtbl_size = (rtbl->max - rtbl->min) / rtbl->step + 1;
 474
 475         for (idx = 1;
 476              idx < rtbl_size && (idx * rtbl->step + rtbl->min <= value);
 477              idx++)
 478                 ;
 479
 480         return idx - 1;
 481 }
 482
 483 static int bq25700_fw_read_u32_props(struct bq25700_device *charger)
 484 {
 485         int ret;
 486         u32 property;
 487         int i;
 488         struct bq25700_init_data *init = &charger->init_data;
 489         struct {
 490                 char *name;
 491                 bool optional;
 492                 enum bq25700_table_ids tbl_id;
 493                 u32 *conv_data; /* holds converted value from given property */
 494         } props[] = {
 495                 /* required properties */
 496                 {"ti,charge-current", false, TBL_ICHG,
 497                  &init->ichg},
 498                 {"ti,max-charge-voltage", false, TBL_CHGMAX,
 499                  &init->max_chg_vol},
 500                 {"ti,input-current-sdp", false, TBL_INPUTCUR,
 501                  &init->input_current_sdp},
 502                 {"ti,input-current-dcp", false, TBL_INPUTCUR,
 503                  &init->input_current_dcp},
 504                 {"ti,input-current-cdp", false, TBL_INPUTCUR,
 505                  &init->input_current_cdp},
 506                 {"ti,minimum-sys-voltage", false, TBL_SYSVMIN,
 507                  &init->sys_min_voltage},
 508                 {"ti,otg-voltage", false, TBL_OTGVOL,
 509                  &init->otg_voltage},
 510                 {"ti,otg-current", false, TBL_OTGCUR,
 511                  &init->otg_current},
 512         };
 513
 514         /* initialize data for optional properties */
 515         for (i = 0; i < ARRAY_SIZE(props); i++) {
 516                 ret = device_property_read_u32(charger->dev, props[i].name,
 517                                                &property);
 518                 if (ret < 0) {
 519                         if (props[i].optional)
 520                                 continue;
 521
 522                         return ret;
 523                 }
 524
 525                 if ((props[i].tbl_id == TBL_ICHG) &&
 526                     (property > MAX_CHARGECURRETNT)) {
 527                         dev_err(charger->dev, "ti,charge-current is error\n");
 528                         return -ENODEV;
 529                 }
 530                 if ((props[i].tbl_id == TBL_CHGMAX) &&
 531                     (property > MAX_CHARGEVOLTAGE)) {
 532                         dev_err(charger->dev, "ti,max-charge-voltage is error\n");
 533                         return -ENODEV;
 534                 }
 535                 if ((props[i].tbl_id == TBL_INPUTCUR) &&
 536                     (property > MAX_INPUTCURRENT)) {
 537                         dev_err(charger->dev, "ti,input-current is error\n");
 538                         return -ENODEV;
 539                 }
 540                 if ((props[i].tbl_id == TBL_OTGVOL) &&
 541                     (property > MAX_OTGVOLTAGE)) {
 542                         dev_err(charger->dev, "ti,ti,otg-voltage is error\n");
 543                         return -ENODEV;
 544                 }
 545                 if ((props[i].tbl_id == TBL_OTGVOL) &&
 546                     (property > MAX_OTGCURRENT)) {
 547                         dev_err(charger->dev, "ti,otg-current is error\n");
 548                         return -ENODEV;
 549                 }
 550
 551                 *props[i].conv_data = bq25700_find_idx(property,
 552                                                        props[i].tbl_id);
 553                 DBG("%s, val: %d, tbl_id =%d\n", props[i].name, property,
 554                     *props[i].conv_data);
 555         }
 556
 557         return 0;
 558 }
 559
 560 static int bq25700_chip_reset(struct bq25700_device *charger)
 561 {
 562         int ret;
 563         int rst_check_counter = 10;
 564
 565         ret = bq25700_field_write(charger, RESET_REG, 1);
 566         if (ret < 0)
 567                 return ret;
 568
 569         do {
 570                 ret = bq25700_field_read(charger, RESET_REG);
 571                 if (ret < 0)
 572                         return ret;
 573
 574                 mdelay(4);
 575         } while (ret == 1 && --rst_check_counter);
 576
 577         if (!rst_check_counter)
 578                 return -ETIMEDOUT;
 579
 580         return 0;
 581 }
 582
 583 static int bq25700_hw_init(struct bq25700_device *charger)
 584 {
 585         int ret;
 586         int i;
 587         struct bq25700_state state;
 588
 589         const struct {
 590                 enum bq25700_fields id;
 591                 u32 value;
 592         } init_data[] = {
 593                 {CHARGE_CURRENT,         charger->init_data.ichg},
 594                 {MAX_CHARGE_VOLTAGE,     charger->init_data.max_chg_vol},
 595                 {INPUT_CURRENT,  charger->init_data.input_current},
 596                 {MIN_SYS_VOTAGE,         charger->init_data.sys_min_voltage},
 597                 {OTG_VOLTAGE,    charger->init_data.otg_voltage},
 598                 {OTG_CURRENT,    charger->init_data.otg_current},
 599         };
 600
 601         ret = bq25700_chip_reset(charger);
 602         if (ret < 0)
 603                 return ret;
 604
 605         /* disable watchdog */
 606         ret = bq25700_field_write(charger, WDTWR_ADJ, 0);
 607         if (ret < 0)
 608                 return ret;
 609
 610         /* initialize currents/voltages and other parameters */
 611         for (i = 0; i < ARRAY_SIZE(init_data); i++) {
 612                 ret = bq25700_field_write(charger, init_data[i].id,
 613                                           init_data[i].value);
 614                 if (ret < 0)
 615                         return ret;
 616         }
 617
 618         DBG("    CHARGE_CURRENT: %dmA\n",
 619             bq25700_field_read(charger, CHARGE_CURRENT) * 64);
 620         DBG("MAX_CHARGE_VOLTAGE: %dmV\n",
 621             bq25700_field_read(charger, MAX_CHARGE_VOLTAGE) * 16);
 622         DBG("     INPUT_VOLTAGE: %dmV\n",
 623             3200 + bq25700_field_read(charger, INPUT_VOLTAGE) * 64);
 624         DBG("     INPUT_CURRENT: %dmA\n",
 625             bq25700_field_read(charger, INPUT_CURRENT) * 50);
 626         DBG("    MIN_SYS_VOTAGE: %dmV\n",
 627             1024 + bq25700_field_read(charger, MIN_SYS_VOTAGE) * 256);
 628
 629         /* Configure ADC for continuous conversions. This does not enable it. */
 630
 631         ret = bq25700_field_write(charger, EN_LWPWR, 0);
 632         if (ret < 0) {
 633                 DBG("error: EN_LWPWR\n");
 634                 return ret;
 635         }
 636
 637         ret = bq25700_field_write(charger, ADC_CONV, 1);
 638         if (ret < 0) {
 639                 DBG("error: ADC_CONV\n");
 640                 return ret;
 641         }
 642
 643         ret = bq25700_field_write(charger, ADC_START, 1);
 644         if (ret < 0) {
 645                 DBG("error: ADC_START\n");
 646                 return ret;
 647         }
 648
 649         ret = bq25700_field_write(charger, ADC_FULLSCALE, 1);
 650         if (ret < 0) {
 651                 DBG("error: ADC_FULLSCALE\n");
 652                 return ret;
 653         }
 654
 655         ret = bq25700_field_write(charger, EN_ADC_CMPIN, 1);
 656         if (ret < 0) {
 657                 DBG("error: EN_ADC_CMPIN\n");
 658                 return ret;
 659         }
 660
 661         ret = bq25700_field_write(charger, EN_ADC_VBUS, 1);
 662         if (ret < 0) {
 663                 DBG("error: EN_ADC_VBUS\n");
 664                 return ret;
 665         }
 666
 667         ret = bq25700_field_write(charger, EN_ADC_PSYS, 1);
 668         if (ret < 0) {
 669                 DBG("error: EN_ADC_PSYS\n");
 670                 return ret;
 671         }
 672
 673         ret = bq25700_field_write(charger, EN_ADC_IIN, 1);
 674         if (ret < 0) {
 675                 DBG("error: EN_ADC_IIN\n");
 676                 return ret;
 677         }
 678
 679         ret = bq25700_field_write(charger, EN_ADC_IDCHG, 1);
 680         if (ret < 0) {
 681                 DBG("error: EN_ADC_IDCHG\n");
 682                 return ret;
 683         }
 684
 685         ret = bq25700_field_write(charger, EN_ADC_ICHG, 1);
 686         if (ret < 0) {
 687                 DBG("error: EN_ADC_ICHG\n");
 688                 return ret;
 689         }
 690
 691         ret = bq25700_field_write(charger, EN_ADC_VSYS, 1);
 692         if (ret < 0) {
 693                 DBG("error: EN_ADC_VSYS\n");
 694                 return ret;
 695         }
 696
 697         ret = bq25700_field_write(charger, EN_ADC_VBAT, 1);
 698         if (ret < 0) {
 699                 DBG("error: EN_ADC_VBAT\n");
 700                 return ret;
 701         }
 702
 703         bq25700_get_chip_state(charger, &state);
 704         charger->state = state;
 705
 706         return 0;
 707 }
 708
 709 static int bq25700_fw_probe(struct bq25700_device *charger)
 710 {
 711         int ret;
 712
 713         ret = bq25700_fw_read_u32_props(charger);
 714         if (ret < 0)
 715                 return ret;
 716
 717         return 0;
 718 }
 719
 720 static void bq25700_enable_charger(struct bq25700_device *charger,
 721                                    u32 input_current)
 722 {
 723         bq25700_field_write(charger, INPUT_CURRENT, input_current);
 724         bq25700_field_write(charger, CHARGE_CURRENT, charger->init_data.ichg);
 725 }
 726
 727 static enum power_supply_property bq25700_power_supply_props[] = {
 728         POWER_SUPPLY_PROP_MANUFACTURER,
 729         POWER_SUPPLY_PROP_STATUS,
 730         POWER_SUPPLY_PROP_ONLINE,
 731         POWER_SUPPLY_PROP_HEALTH,
 732         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
 733         POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
 734         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
 735         POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
 736         POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX,
 737         POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
 738 };
 739
 740 static int bq25700_power_supply_get_property(struct power_supply *psy,
 741                                              enum power_supply_property psp,
 742                                              union power_supply_propval *val)
 743 {
 744         int ret;
 745         struct bq25700_device *bq = power_supply_get_drvdata(psy);
 746         struct bq25700_state state;
 747
 748         state = bq->state;
 749
 750         switch (psp) {
 751         case POWER_SUPPLY_PROP_STATUS:
 752                 if (!state.ac_stat)
 753                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 754                 else if (state.in_fchrg == 1 ||
 755                          state.in_pchrg == 1)
 756                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
 757                 else
 758                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
 759                 break;
 760
 761         case POWER_SUPPLY_PROP_MANUFACTURER:
 762                 val->strval = BQ25700_MANUFACTURER;
 763                 break;
 764
 765         case POWER_SUPPLY_PROP_ONLINE:
 766                 val->intval = state.ac_stat;
 767                 break;
 768
 769         case POWER_SUPPLY_PROP_HEALTH:
 770                 if (!state.fault_acoc &&
 771                     !state.fault_acov && !state.fault_batoc)
 772                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
 773                 else if (state.fault_batoc)
 774                         val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 775                 break;
 776
 777         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
 778                 /* read measured value */
 779                 ret = bq25700_field_read(bq, OUTPUT_CHG_CUR);
 780                 if (ret < 0)
 781                         return ret;
 782
 783                 /* converted_val = ADC_val * 64mA  */
 784                 val->intval = ret * 64000;
 785                 break;
 786
 787         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
 788                 val->intval = bq25700_tables[TBL_ICHG].rt.max;
 789                 break;
 790
 791         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
 792                 if (!state.ac_stat) {
 793                         val->intval = 0;
 794                         break;
 795                 }
 796
 797                 /* read measured value */
 798                 ret = bq25700_field_read(bq, OUTPUT_BAT_VOL);
 799                 if (ret < 0)
 800                         return ret;
 801
 802                 /* converted_val = 2.88V + ADC_val * 64mV */
 803                 val->intval = 2880000 + ret * 64000;
 804                 break;
 805
 806         case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
 807                 val->intval = bq25700_tables[TBL_CHGMAX].rt.max;
 808                 break;
 809
 810         case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX:
 811                 val->intval = bq25700_tables[TBL_INPUTVOL].rt.max;
 812                 break;
 813
 814         case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
 815                 val->intval = bq25700_tables[TBL_INPUTCUR].rt.max;
 816                 break;
 817
 818         default:
 819                 return -EINVAL;
 820         }
 821
 822         return 0;
 823 }
 824
 825 static char *bq25700_charger_supplied_to[] = {
 826         "charger",
 827 };
 828
 829 static const struct power_supply_desc bq25700_power_supply_desc = {
 830         .name = "bq25700-charger",
 831         .type = POWER_SUPPLY_TYPE_USB,
 832         .properties = bq25700_power_supply_props,
 833         .num_properties = ARRAY_SIZE(bq25700_power_supply_props),
 834         .get_property = bq25700_power_supply_get_property,
 835 };
 836
 837 static int bq25700_power_supply_init(struct bq25700_device *charger)
 838 {
 839         struct power_supply_config psy_cfg = { .drv_data = charger, };
 840
 841         psy_cfg.supplied_to = bq25700_charger_supplied_to;
 842         psy_cfg.num_supplicants = ARRAY_SIZE(bq25700_charger_supplied_to);
 843
 844         charger->supply_charger =
 845                 power_supply_register(charger->dev,
 846                                       &bq25700_power_supply_desc,
 847                                       &psy_cfg);
 848
 849         return PTR_ERR_OR_ZERO(charger->supply_charger);
 850 }
 851
 852 static irqreturn_t bq25700_irq_handler_thread(int irq, void *private)
 853 {
 854         struct bq25700_device *charger = private;
 855         int ret;
 856         struct bq25700_state state;
 857
 858         ret = bq25700_get_chip_state(charger, &state);
 859         if (ret < 0)
 860                 goto handled;
 861
 862         charger->state = state;
 863
 864         power_supply_changed(charger->supply_charger);
 865
 866 handled:
 867         return IRQ_HANDLED;
 868 }
 869
 870 static void bq25700_pd_evt_worker(struct work_struct *work)
 871 {
 872         struct bq25700_device *charger =
 873                 container_of(work, struct bq25700_device, pd_work.work);
 874         struct extcon_dev *edev = charger->cable_edev;
 875         union extcon_property_value prop_val;
 876         struct bq25700_state state;
 877         int ret;
 878         int vol, cur;
 879         int vol_idx, cur_idx;
 880
 881         if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_FAST) > 0) {
 882                 ret = extcon_get_property(edev, EXTCON_CHG_USB_FAST,
 883                                           EXTCON_PROP_USB_TYPEC_POLARITY,
 884                                           &prop_val);
 885                 DBG("usb pd charge...\n");
 886                 vol = prop_val.intval & 0xffff;
 887                 cur = prop_val.intval >> 15;
 888                 if (ret == 0) {
 889                         vol_idx = bq25700_find_idx((vol - 1280) * 1000,
 890                                                    TBL_INPUTVOL);
 891                         cur_idx = bq25700_find_idx(cur * 1000, TBL_INPUTCUR);
 892                         bq25700_field_write(charger, INPUT_VOLTAGE, vol_idx);
 893                         bq25700_field_write(charger, INPUT_CURRENT, cur_idx);
 894                         bq25700_field_write(charger, CHARGE_CURRENT,
 895                                             charger->init_data.ichg);
 896                 }
 897
 898                 bq25700_get_chip_state(charger, &state);
 899                 charger->state = state;
 900                 power_supply_changed(charger->supply_charger);
 901         }
 902 }
 903
 904 static int bq25700_pd_evt_notifier(struct notifier_block *nb,
 905                                    unsigned long event,
 906                                    void *ptr)
 907 {
 908         struct bq25700_device *charger =
 909                 container_of(nb, struct bq25700_device, cable_pd_nb);
 910
 911         queue_delayed_work(charger->usb_charger_wq, &charger->pd_work,
 912                            msecs_to_jiffies(10));
 913
 914         return NOTIFY_DONE;
 915 }
 916
 917 static void bq25700_charger_evt_worker(struct work_struct *work)
 918 {
 919         struct bq25700_device *charger =
 920                 container_of(work, struct bq25700_device, usb_work.work);
 921         struct extcon_dev *edev = charger->cable_edev;
 922         struct bq25700_state state;
 923         enum charger_t charger_state = USB_TYPE_UNKNOWN_CHARGER;
 924
 925         if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_FAST) > 0)
 926                 return;
 927
 928         /* Determine cable/charger type */
 929         if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_SDP) > 0) {
 930                 charger_state = USB_TYPE_USB_CHARGER;
 931
 932                 bq25700_enable_charger(charger,
 933                                        charger->init_data.input_current_sdp);
 934                 DBG("USB_TYPE_USB_CHARGER\n");
 935         } else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_DCP) > 0) {
 936                 charger_state = USB_TYPE_AC_CHARGER;
 937                 bq25700_enable_charger(charger,
 938                                        charger->init_data.input_current_dcp);
 939                 DBG("USB_TYPE_AC_CHARGER\n");
 940         } else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_CDP) > 0) {
 941                 charger_state = USB_TYPE_CDP_CHARGER;
 942                 bq25700_enable_charger(charger,
 943                                        charger->init_data.input_current_cdp);
 944                 DBG("USB_TYPE_CDP_CHARGER\n");
 945         }
 946
 947         bq25700_get_chip_state(charger, &state);
 948         charger->state = state;
 949         power_supply_changed(charger->supply_charger);
 950 }
 951
 952 static int bq25700_charger_evt_notifier(struct notifier_block *nb,
 953                                         unsigned long event,
 954                                         void *ptr)
 955 {
 956         struct bq25700_device *charger =
 957                 container_of(nb, struct bq25700_device, cable_cg_nb);
 958
 959         queue_delayed_work(charger->usb_charger_wq, &charger->usb_work,
 960                            msecs_to_jiffies(10));
 961
 962         return NOTIFY_DONE;
 963 }
 964
 965 static void bq25700_host_evt_worker(struct work_struct *work)
 966 {
 967         struct bq25700_device *charger =
 968                 container_of(work, struct bq25700_device, host_work.work);
 969         struct extcon_dev *edev = charger->cable_edev;
 970
 971         /* Determine cable/charger type */
 972         if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) > 0) {
 973                 bq25700_field_write(charger, EN_OTG, 1);
 974                 DBG("OTG enable\n");
 975         } else if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) == 0) {
 976                 bq25700_field_write(charger, EN_OTG, 0);
 977                 DBG("OTG disable\n");
 978         }
 979 }
 980
 981 static int bq25700_host_evt_notifier(struct notifier_block *nb,
 982                                      unsigned long event, void *ptr)
 983 {
 984         struct bq25700_device *charger =
 985                 container_of(nb, struct bq25700_device, cable_host_nb);
 986
 987         queue_delayed_work(charger->usb_charger_wq, &charger->host_work,
 988                            msecs_to_jiffies(10));
 989
 990         return NOTIFY_DONE;
 991 }
 992
 993 static void bq25700_discnt_evt_worker(struct work_struct *work)
 994 {
 995         int vol_idx;
 996         struct bq25700_device *charger =
 997                 container_of(work, struct bq25700_device, discnt_work.work);
 998         struct bq25700_state state;
 999
1000         if (extcon_get_cable_state_(charger->cable_edev, EXTCON_USB) == 0) {
1001                 vol_idx = bq25700_find_idx(DEFAULT_INPUTVOL, TBL_INPUTVOL);
1002                 bq25700_field_write(charger, INPUT_VOLTAGE, vol_idx);
1003                 bq25700_field_write(charger, INPUT_CURRENT,
1004                                     charger->init_data.input_current_sdp);
1005                 bq25700_get_chip_state(charger, &state);
1006                 charger->state = state;
1007                 power_supply_changed(charger->supply_charger);
1008         }
1009 }
1010
1011 static int bq25700_discnt_evt_notfier(struct notifier_block *nb,
1012                                       unsigned long event,
1013                                       void *ptr)
1014 {
1015         struct bq25700_device *charger =
1016                 container_of(nb, struct bq25700_device, cable_discnt_nb);
1017
1018         queue_delayed_work(charger->usb_charger_wq,
1019                            &charger->discnt_work,
1020                            msecs_to_jiffies(10));
1021
1022         return NOTIFY_DONE;
1023 }
1024
1025 static long bq25700_init_usb(struct bq25700_device *charger)
1026 {
1027         struct extcon_dev *edev;
1028         struct device *dev = charger->dev;
1029         int ret;
1030
1031         charger->usb_charger_wq = alloc_ordered_workqueue("%s",
1032                                                           WQ_MEM_RECLAIM |
1033                                                           WQ_FREEZABLE,
1034                                                           "bq25700-usb-wq");
1035
1036         /* type-C */
1037         edev = extcon_get_edev_by_phandle(dev, 0);
1038         if (IS_ERR(edev)) {
1039                 if (PTR_ERR(edev) != -EPROBE_DEFER)
1040                         dev_err(dev, "Invalid or missing extcon\n");
1041                 return PTR_ERR(edev);
1042         }
1043
1044         /* Register chargers  */
1045         INIT_DELAYED_WORK(&charger->usb_work, bq25700_charger_evt_worker);
1046         charger->cable_cg_nb.notifier_call = bq25700_charger_evt_notifier;
1047
1048         ret = extcon_register_notifier(edev,
1049                                        EXTCON_CHG_USB_SDP,
1050                                        &charger->cable_cg_nb);
1051         if (ret < 0) {
1052                 dev_err(dev, "failed to register notifier for SDP\n");
1053                 return ret;
1054         }
1055
1056         ret = extcon_register_notifier(edev,
1057                                        EXTCON_CHG_USB_DCP,
1058                                        &charger->cable_cg_nb);
1059         if (ret < 0) {
1060                 dev_err(dev, "failed to register notifier for DCP\n");
1061                 extcon_unregister_notifier(edev,
1062                                            EXTCON_CHG_USB_SDP,
1063                                            &charger->cable_cg_nb);
1064                 return ret;
1065         }
1066
1067         ret = extcon_register_notifier(edev,
1068                                        EXTCON_CHG_USB_CDP,
1069                                        &charger->cable_cg_nb);
1070         if (ret < 0) {
1071                 dev_err(dev, "failed to register notifier for CDP\n");
1072                 extcon_unregister_notifier(edev,
1073                                            EXTCON_CHG_USB_SDP,
1074                                            &charger->cable_cg_nb);
1075                 extcon_unregister_notifier(edev,
1076                                            EXTCON_CHG_USB_DCP,
1077                                            &charger->cable_cg_nb);
1078                 return ret;
1079         }
1080
1081         /* Register host */
1082         INIT_DELAYED_WORK(&charger->host_work, bq25700_host_evt_worker);
1083         charger->cable_host_nb.notifier_call = bq25700_host_evt_notifier;
1084         ret = extcon_register_notifier(edev,
1085                                        EXTCON_USB_HOST,
1086                                        &charger->cable_host_nb);
1087         if (ret < 0) {
1088                 dev_err(dev, "failed to register notifier for HOST\n");
1089                 extcon_unregister_notifier(edev,
1090                                            EXTCON_CHG_USB_SDP,
1091                                            &charger->cable_cg_nb);
1092                 extcon_unregister_notifier(edev,
1093                                            EXTCON_CHG_USB_DCP,
1094                                            &charger->cable_cg_nb);
1095                 extcon_unregister_notifier(edev,
1096                                            EXTCON_CHG_USB_CDP,
1097                                            &charger->cable_cg_nb);
1098
1099                 return ret;
1100         }
1101
1102         /* Register discnt usb */
1103         INIT_DELAYED_WORK(&charger->discnt_work, bq25700_discnt_evt_worker);
1104         charger->cable_discnt_nb.notifier_call = bq25700_discnt_evt_notfier;
1105         ret = extcon_register_notifier(edev,
1106                                        EXTCON_USB,
1107                                        &charger->cable_discnt_nb);
1108         if (ret < 0) {
1109                 dev_err(dev, "failed to register notifier for HOST\n");
1110                 extcon_unregister_notifier(edev,
1111                                            EXTCON_CHG_USB_SDP,
1112                                            &charger->cable_cg_nb);
1113                 extcon_unregister_notifier(edev,
1114                                            EXTCON_CHG_USB_DCP,
1115                                            &charger->cable_cg_nb);
1116                 extcon_unregister_notifier(edev,
1117                                            EXTCON_CHG_USB_CDP,
1118                                            &charger->cable_cg_nb);
1119                 extcon_unregister_notifier(edev,
1120                                            EXTCON_USB_VBUS_EN,
1121                                            &charger->cable_host_nb);
1122
1123                 return ret;
1124         }
1125
1126         charger->cable_edev = edev;
1127
1128         schedule_delayed_work(&charger->host_work, 0);
1129         schedule_delayed_work(&charger->usb_work, 0);
1130
1131         INIT_DELAYED_WORK(&charger->pd_work, bq25700_pd_evt_worker);
1132         charger->cable_pd_nb.notifier_call = bq25700_pd_evt_notifier;
1133         ret = extcon_register_notifier(edev,
1134                                        EXTCON_CHG_USB_FAST,
1135                                        &charger->cable_pd_nb);
1136
1137         return 0;
1138 }
1139
1140 static int bq25700_probe(struct i2c_client *client,
1141                          const struct i2c_device_id *id)
1142 {
1143         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
1144         struct device *dev = &client->dev;
1145         struct bq25700_device *charger;
1146         int ret = 0;
1147         u32 i = 0;
1148
1149         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
1150                 return -EIO;
1151
1152         charger = devm_kzalloc(&client->dev, sizeof(*charger), GFP_KERNEL);
1153         if (!charger)
1154                 return -EINVAL;
1155
1156         charger->client = client;
1157         charger->dev = dev;
1158         charger->regmap = devm_regmap_init_i2c(client,
1159                                                &bq25700_regmap_config);
1160
1161         if (IS_ERR(charger->regmap)) {
1162                 dev_err(&client->dev, "Failed to initialize regmap\n");
1163                 return -EINVAL;
1164         }
1165
1166         for (i = 0; i < ARRAY_SIZE(bq25700_reg_fields); i++) {
1167                 const struct reg_field *reg_fields = bq25700_reg_fields;
1168
1169                 charger->rmap_fields[i] =
1170                         devm_regmap_field_alloc(dev,
1171                                                 charger->regmap,
1172                                                 reg_fields[i]);
1173                 if (IS_ERR(charger->rmap_fields[i])) {
1174                         dev_err(dev, "cannot allocate regmap field\n");
1175                         return PTR_ERR(charger->rmap_fields[i]);
1176                 }
1177         }
1178
1179         i2c_set_clientdata(client, charger);
1180
1181         /*read chip id. Confirm whether to support the chip*/
1182         charger->chip_id = bq25700_field_read(charger, DEVICE_ID);
1183
1184         if (charger->chip_id < 0) {
1185                 dev_err(dev, "Cannot read chip ID.\n");
1186                 return charger->chip_id;
1187         }
1188
1189         if (!dev->platform_data) {
1190                 ret = bq25700_fw_probe(charger);
1191                 if (ret < 0) {
1192                         dev_err(dev, "Cannot read device properties.\n");
1193                         return ret;
1194                 }
1195         } else {
1196                 return -ENODEV;
1197         }
1198
1199         ret = bq25700_hw_init(charger);
1200         if (ret < 0) {
1201                 dev_err(dev, "Cannot initialize the chip.\n");
1202                 return ret;
1203         }
1204
1205         bq25700_init_usb(charger);
1206
1207         if (client->irq < 0) {
1208                 dev_err(dev, "No irq resource found.\n");
1209                 return client->irq;
1210         }
1211         ret = devm_request_threaded_irq(dev, client->irq, NULL,
1212                                         bq25700_irq_handler_thread,
1213                                         IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
1214                                         "bq25700_irq", charger);
1215         if (ret)
1216                 goto irq_fail;
1217
1218         bq25700_power_supply_init(charger);
1219
1220 irq_fail:
1221         return ret;
1222 }
1223
1224 #ifdef CONFIG_PM_SLEEP
1225 static int bq25700_pm_suspend(struct device *dev)
1226 {
1227         return 0;
1228 }
1229
1230 static int bq25700_pm_resume(struct device *dev)
1231 {
1232         return 0;
1233 }
1234 #endif
1235
1236 static SIMPLE_DEV_PM_OPS(bq25700_pm_ops, bq25700_pm_suspend, bq25700_pm_resume);
1237
1238 static const struct i2c_device_id bq25700_i2c_ids[] = {
1239         { "bq25700"},
1240         { },
1241 };
1242 MODULE_DEVICE_TABLE(i2c, bq25700_i2c_ids);
1243
1244 #ifdef CONFIG_OF
1245 static const struct of_device_id bq25700_of_match[] = {
1246         { .compatible = "ti,bq25700", },
1247         { },
1248 };
1249 MODULE_DEVICE_TABLE(of, bq25700_of_match);
1250 #else
1251 static const struct of_device_id bq25700_of_match[] = {
1252         { },
1253 };
1254 #endif
1255
1256 static struct i2c_driver bq25700_driver = {
1257         .probe          = bq25700_probe,
1258         .id_table       = bq25700_i2c_ids,
1259         .driver = {
1260                 .name           = "bq25700-charger",
1261                 .pm             = &bq25700_pm_ops,
1262                 .of_match_table = of_match_ptr(bq25700_of_match),
1263         },
1264 };
1265 module_i2c_driver(bq25700_driver);
1266
1267 MODULE_LICENSE("GPL");
1268 MODULE_AUTHOR("shengfeixu <xsf@rock-chips.com>");
1269 MODULE_DESCRIPTION("TI bq25700 Charger Driver");