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