From 49bf9467cae835ec04d2d3585083f6c74e3ad626 Mon Sep 17 00:00:00 2001 From: Shengfei xu Date: Fri, 9 Dec 2016 15:27:11 +0800 Subject: [PATCH] power_supply: Add support for TI BQ25700 charger chip Change-Id: I362b5bb06455c2ddb9583bb5882ee349438ba799 Signed-off-by: Shengfei xu --- .../devicetree/bindings/power/bq25700.txt | 24 + drivers/power/Kconfig | 6 + drivers/power/Makefile | 3 +- drivers/power/bq25700_charger.c | 1269 +++++++++++++++++ 4 files changed, 1301 insertions(+), 1 deletion(-) create mode 100644 Documentation/devicetree/bindings/power/bq25700.txt create mode 100644 drivers/power/bq25700_charger.c diff --git a/Documentation/devicetree/bindings/power/bq25700.txt b/Documentation/devicetree/bindings/power/bq25700.txt new file mode 100644 index 000000000000..5fcf275fba7a --- /dev/null +++ b/Documentation/devicetree/bindings/power/bq25700.txt @@ -0,0 +1,24 @@ +Binding for TI bq25700 Li-Ion Charger + +Required properties: +- compatible: Should contain one of the following: + * "ti,bq25700" +- reg: integer, smbus address of the device. +- ti,battery-regulation-voltage: integer, maximum charging voltage (in uV); +- ti,charge-current: integer, maximum charging current (in uA); +- ti,minimum-sys-voltage: integer, when battery is charging and it is below + minimum system voltage, the system will be regulated above + minimum-sys-voltage setting (in uV); + +Optional properties: + +Example: + +bq25700 { + compatible = "ti,bq25700"; + reg = <0x09>; + + ti,charge-current = <1000000>; + ti,termination-current = <50000>; + ti,minimum-sys-voltage = <3600000>; +}; diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig index 18788dd3fde2..6d9f84daa948 100644 --- a/drivers/power/Kconfig +++ b/drivers/power/Kconfig @@ -433,6 +433,12 @@ config CHARGER_BQ24735 help Say Y to enable support for the TI BQ24735 battery charger. +config CHARGER_BQ25700 + tristate "TI BQ25700 battery charger driver" + depends on REGMAP_I2C + help + Say Y to enable support for the TI BQ25700 battery charger. + config CHARGER_BQ25890 tristate "TI BQ25890 battery charger driver" depends on I2C diff --git a/drivers/power/Makefile b/drivers/power/Makefile index c2ad15e3de09..1df9f9ae5ee2 100644 --- a/drivers/power/Makefile +++ b/drivers/power/Makefile @@ -66,6 +66,7 @@ obj-$(CONFIG_CHARGER_BQ2415X) += bq2415x_charger.o obj-$(CONFIG_CHARGER_BQ24190) += bq24190_charger.o obj-$(CONFIG_CHARGER_BQ24257) += bq24257_charger.o obj-$(CONFIG_CHARGER_BQ24735) += bq24735-charger.o +obj-$(CONFIG_CHARGER_BQ25700) += bq25700_charger.o obj-$(CONFIG_CHARGER_BQ25890) += bq25890_charger.o obj-$(CONFIG_POWER_AVS) += avs/ obj-$(CONFIG_CHARGER_SMB347) += smb347-charger.o @@ -73,4 +74,4 @@ obj-$(CONFIG_CHARGER_TPS65090) += tps65090-charger.o obj-$(CONFIG_CHARGER_TPS65217) += tps65217_charger.o obj-$(CONFIG_POWER_RESET) += reset/ obj-$(CONFIG_AXP288_FUEL_GAUGE) += axp288_fuel_gauge.o -obj-$(CONFIG_AXP288_CHARGER) += axp288_charger.o +obj-$(CONFIG_AXP288_CHARGER) += axp288_charger.o \ No newline at end of file diff --git a/drivers/power/bq25700_charger.c b/drivers/power/bq25700_charger.c new file mode 100644 index 000000000000..49f043f5acdf --- /dev/null +++ b/drivers/power/bq25700_charger.c @@ -0,0 +1,1269 @@ +/* + * TI BQ257000 charger driver + * + * Copyright (C) 2016 Rockchip Corporation + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static int dbg_enable; +module_param_named(dbg_level, dbg_enable, int, 0644); + +#define DBG(args...) \ + do { \ + if (dbg_enable) { \ + pr_info(args); \ + } \ + } while (0) + +#define bq25700_info(fmt, args...) pr_info("bq25700: "fmt, ##args) + +#define BQ25700_MANUFACTURER "Texas Instruments" +#define BQ25700_ID 0x59 + +#define DEFAULT_INPUTVOL ((5000 - 1280) * 1000) +#define MAX_INPUTVOLTAGE 24000000 +#define MAX_INPUTCURRENT 6350000 +#define MAX_CHARGEVOLTAGE 16800000 +#define MAX_CHARGECURRETNT 8128000 +#define MAX_OTGVOLTAGE 20800000 +#define MAX_OTGCURRENT 6350000 + +enum bq25700_fields { + EN_LWPWR, WDTWR_ADJ, IDPM_AUTO_DISABLE, + EN_OOA, PWM_FREQ, EN_LEARN, IADP_GAIN, IBAT_GAIN, + EN_LDO, EN_IDPM, CHRG_INHIBIT,/*reg12h*/ + CHARGE_CURRENT,/*reg14h*/ + MAX_CHARGE_VOLTAGE,/*reg15h*/ + + AC_STAT, ICO_DONE, IN_VINDPM, IN_IINDPM, IN_FCHRG, IN_PCHRG, IN_OTG, + F_ACOV, F_BATOC, F_ACOC, SYSOVP_STAT, F_LATCHOFF, F_OTG_OVP, F_OTG_OCP, + /*reg20h*/ + STAT_COMP, STAT_ICRIT, STAT_INOM, STAT_IDCHG, STAT_VSYS, STAT_BAT_REMOV, + STAT_ADP_REMOV,/*reg21h*/ + INPUT_CURRENT_DPM,/*reg22h*/ + OUTPUT_INPUT_VOL, OUTPUT_SYS_POWER,/*reg23h*/ + OUTPUT_DSG_CUR, OUTPUT_CHG_CUR,/*reg24h*/ + OUTPUT_INPUT_CUR, OUTPUT_CMPIN_VOL,/*reg25h*/ + OUTPUT_SYS_VOL, OUTPUT_BAT_VOL,/*reg26h*/ + + EN_IBAT, EN_PROCHOT_LPWR, EN_PSYS, RSNS_RAC, RSNS_RSR, + PSYS_RATIO, CMP_REF, CMP_POL, CMP_DEG, FORCE_LATCHOFF, + EN_SHIP_DCHG, AUTO_WAKEUP_EN, /*reg30h*/ + PKPWR_TOVLD_REG, EN_PKPWR_IDPM, EN_PKPWR_VSYS, PKPWER_OVLD_STAT, + PKPWR_RELAX_STAT, PKPWER_TMAX, EN_EXTILIM, EN_ICHG_IDCHG, Q2_OCP, + ACX_OCP, EN_ACOC, ACOC_VTH, EN_BATOC, BATCOC_VTH,/*reg31h*/ + EN_HIZ, RESET_REG, RESET_VINDPM, EN_OTG, EN_ICO_MODE, BATFETOFF_HIZ, + PSYS_OTG_IDCHG,/*reg32h*/ + ILIM2_VTH, ICRIT_DEG, VSYS_VTH, EN_PROCHOT_EXT, PROCHOT_WIDTH, + PROCHOT_CLEAR, INOM_DEG,/*reg33h*/ + IDCHG_VTH, IDCHG_DEG, PROCHOT_PROFILE_COMP, PROCHOT_PROFILE_ICRIT, + PROCHOT_PROFILE_INOM, PROCHOT_PROFILE_IDCHG, + PROCHOT_PROFILE_VSYS, PROCHOT_PROFILE_BATPRES, PROCHOT_PROFILE_ACOK, + /*reg34h*/ + ADC_CONV, ADC_START, ADC_FULLSCALE, EN_ADC_CMPIN, EN_ADC_VBUS, + EN_ADC_PSYS, EN_ADC_IIN, EN_ADC_IDCHG, EN_ADC_ICHG, EN_ADC_VSYS, + EN_ADC_VBAT,/*reg35h*/ + + OTG_VOLTAGE,/*reg3bh*/ + OTG_CURRENT,/*reg3ch*/ + INPUT_VOLTAGE,/*reg3dh*/ + MIN_SYS_VOTAGE,/*reg3eh*/ + INPUT_CURRENT,/*reg3fh*/ + + MANUFACTURE_ID,/*regfeh*/ + DEVICE_ID,/*regffh*/ + + F_MAX_FIELDS +}; + +enum charger_t { + USB_TYPE_UNKNOWN_CHARGER, + USB_TYPE_NONE_CHARGER, + USB_TYPE_USB_CHARGER, + USB_TYPE_AC_CHARGER, + USB_TYPE_CDP_CHARGER, + DC_TYPE_DC_CHARGER, + DC_TYPE_NONE_CHARGER, +}; + +/* initial field values, converted to register values */ +struct bq25700_init_data { + u32 ichg; /* charge current */ + u32 max_chg_vol; /*max charge voltage*/ + u32 input_voltage; /*input voltage*/ + u32 input_current; /*input current*/ + u32 input_current_sdp; + u32 input_current_dcp; + u32 input_current_cdp; + u32 sys_min_voltage; /*mininum system voltage*/ + u32 otg_voltage; /*OTG voltage*/ + u32 otg_current; /*OTG current*/ +}; + +struct bq25700_state { + u8 ac_stat; + u8 ico_done; + u8 in_vindpm; + u8 in_iindpm; + u8 in_fchrg; + u8 in_pchrg; + u8 in_otg; + u8 fault_acov; + u8 fault_batoc; + u8 fault_acoc; + u8 sysovp_stat; + u8 fault_latchoff; + u8 fault_otg_ovp; + u8 fault_otg_ocp; +}; + +struct bq25700_device { + struct i2c_client *client; + struct device *dev; + struct power_supply *supply_charger; + char model_name[I2C_NAME_SIZE]; + unsigned int irq; + bool first_time; + bool charger_health_valid; + bool battery_health_valid; + bool battery_status_valid; + + struct workqueue_struct *usb_charger_wq; + struct workqueue_struct *dc_charger_wq; + struct workqueue_struct *finish_sig_wq; + struct delayed_work usb_work; + struct delayed_work pd_work; + struct delayed_work host_work; + struct delayed_work discnt_work; + struct delayed_work irq_work; + struct notifier_block cable_cg_nb; + struct notifier_block cable_pd_nb; + struct notifier_block cable_host_nb; + struct notifier_block cable_discnt_nb; + struct extcon_dev *cable_edev; + + struct regmap *regmap; + struct regmap_field *rmap_fields[F_MAX_FIELDS]; + int chip_id; + struct bq25700_init_data init_data; + struct bq25700_state state; +}; + +static const struct reg_field bq25700_reg_fields[] = { + /*REG12*/ + [EN_LWPWR] = REG_FIELD(0x12, 15, 15), + [WDTWR_ADJ] = REG_FIELD(0x12, 13, 14), + [IDPM_AUTO_DISABLE] = REG_FIELD(0x12, 12, 12), + [EN_OOA] = REG_FIELD(0x12, 10, 10), + [PWM_FREQ] = REG_FIELD(0x12, 9, 9), + [EN_LEARN] = REG_FIELD(0x12, 5, 5), + [IADP_GAIN] = REG_FIELD(0x12, 4, 4), + [IBAT_GAIN] = REG_FIELD(0x12, 3, 3), + [EN_LDO] = REG_FIELD(0x12, 2, 2), + [EN_IDPM] = REG_FIELD(0x12, 1, 1), + [CHRG_INHIBIT] = REG_FIELD(0x12, 0, 0), + /*REG0x14*/ + [CHARGE_CURRENT] = REG_FIELD(0x14, 6, 12), + /*REG0x15*/ + [MAX_CHARGE_VOLTAGE] = REG_FIELD(0x15, 4, 14), + /*REG20*/ + [AC_STAT] = REG_FIELD(0x20, 15, 15), + [ICO_DONE] = REG_FIELD(0x20, 14, 14), + [IN_VINDPM] = REG_FIELD(0x20, 12, 12), + [IN_IINDPM] = REG_FIELD(0x20, 11, 11), + [IN_FCHRG] = REG_FIELD(0x20, 10, 10), + [IN_PCHRG] = REG_FIELD(0x20, 9, 9), + [IN_OTG] = REG_FIELD(0x20, 8, 8), + [F_ACOV] = REG_FIELD(0x20, 7, 7), + [F_BATOC] = REG_FIELD(0x20, 6, 6), + [F_ACOC] = REG_FIELD(0x20, 5, 5), + [SYSOVP_STAT] = REG_FIELD(0x20, 4, 4), + [F_LATCHOFF] = REG_FIELD(0x20, 2, 2), + [F_OTG_OVP] = REG_FIELD(0x20, 1, 1), + [F_OTG_OCP] = REG_FIELD(0x20, 0, 0), + /*REG21*/ + [STAT_COMP] = REG_FIELD(0x21, 6, 6), + [STAT_ICRIT] = REG_FIELD(0x21, 5, 5), + [STAT_INOM] = REG_FIELD(0x21, 4, 4), + [STAT_IDCHG] = REG_FIELD(0x21, 3, 3), + [STAT_VSYS] = REG_FIELD(0x21, 2, 2), + [STAT_BAT_REMOV] = REG_FIELD(0x21, 1, 1), + [STAT_ADP_REMOV] = REG_FIELD(0x21, 0, 0), + /*REG22*/ + [INPUT_CURRENT_DPM] = REG_FIELD(0x22, 8, 14), + /*REG23H*/ + [OUTPUT_INPUT_VOL] = REG_FIELD(0x23, 8, 15), + [OUTPUT_SYS_POWER] = REG_FIELD(0x23, 0, 7), + /*REG24H*/ + [OUTPUT_DSG_CUR] = REG_FIELD(0x24, 8, 14), + [OUTPUT_CHG_CUR] = REG_FIELD(0x24, 0, 6), + /*REG25H*/ + [OUTPUT_INPUT_CUR] = REG_FIELD(0x25, 8, 15), + [OUTPUT_CMPIN_VOL] = REG_FIELD(0x25, 0, 7), + /*REG26H*/ + [OUTPUT_SYS_VOL] = REG_FIELD(0x26, 8, 15), + [OUTPUT_BAT_VOL] = REG_FIELD(0x26, 0, 6), + + /*REG30*/ + [EN_IBAT] = REG_FIELD(0x30, 15, 15), + [EN_PROCHOT_LPWR] = REG_FIELD(0x30, 13, 14), + [EN_PSYS] = REG_FIELD(0x30, 12, 12), + [RSNS_RAC] = REG_FIELD(0x30, 11, 11), + [RSNS_RSR] = REG_FIELD(0x30, 10, 10), + [PSYS_RATIO] = REG_FIELD(0x30, 9, 9), + [CMP_REF] = REG_FIELD(0x30, 7, 7), + [CMP_POL] = REG_FIELD(0x30, 6, 6), + [CMP_DEG] = REG_FIELD(0x30, 4, 5), + [FORCE_LATCHOFF] = REG_FIELD(0x30, 3, 3), + [EN_SHIP_DCHG] = REG_FIELD(0x30, 1, 1), + [AUTO_WAKEUP_EN] = REG_FIELD(0x30, 0, 0), + /*REG31*/ + [PKPWR_TOVLD_REG] = REG_FIELD(0x31, 14, 15), + [EN_PKPWR_IDPM] = REG_FIELD(0x31, 13, 13), + [EN_PKPWR_VSYS] = REG_FIELD(0x31, 12, 12), + [PKPWER_OVLD_STAT] = REG_FIELD(0x31, 11, 11), + [PKPWR_RELAX_STAT] = REG_FIELD(0x31, 10, 10), + [PKPWER_TMAX] = REG_FIELD(0x31, 8, 9), + [EN_EXTILIM] = REG_FIELD(0x31, 7, 7), + [EN_ICHG_IDCHG] = REG_FIELD(0x31, 6, 6), + [Q2_OCP] = REG_FIELD(0x31, 5, 5), + [ACX_OCP] = REG_FIELD(0x31, 4, 4), + [EN_ACOC] = REG_FIELD(0x31, 3, 3), + [ACOC_VTH] = REG_FIELD(0x31, 2, 2), + [EN_BATOC] = REG_FIELD(0x31, 1, 1), + [BATCOC_VTH] = REG_FIELD(0x31, 0, 0), + /*REG32*/ + [EN_HIZ] = REG_FIELD(0x32, 15, 15), + [RESET_REG] = REG_FIELD(0x32, 14, 14), + [RESET_VINDPM] = REG_FIELD(0x32, 13, 13), + [EN_OTG] = REG_FIELD(0x32, 12, 12), + [EN_ICO_MODE] = REG_FIELD(0x32, 11, 11), + [BATFETOFF_HIZ] = REG_FIELD(0x32, 1, 1), + [PSYS_OTG_IDCHG] = REG_FIELD(0x32, 0, 0), + /*REG33*/ + [ILIM2_VTH] = REG_FIELD(0x33, 11, 15), + [ICRIT_DEG] = REG_FIELD(0x33, 9, 10), + [VSYS_VTH] = REG_FIELD(0x33, 6, 7), + [EN_PROCHOT_EXT] = REG_FIELD(0x33, 5, 5), + [PROCHOT_WIDTH] = REG_FIELD(0x33, 3, 4), + [PROCHOT_CLEAR] = REG_FIELD(0x33, 2, 2), + [INOM_DEG] = REG_FIELD(0x33, 1, 1), + /*REG34*/ + [IDCHG_VTH] = REG_FIELD(0x34, 10, 15), + [IDCHG_DEG] = REG_FIELD(0x34, 8, 9), + [PROCHOT_PROFILE_COMP] = REG_FIELD(0x34, 6, 6), + [PROCHOT_PROFILE_ICRIT] = REG_FIELD(0x34, 5, 5), + [PROCHOT_PROFILE_INOM] = REG_FIELD(0x34, 4, 4), + [PROCHOT_PROFILE_IDCHG] = REG_FIELD(0x34, 3, 3), + [PROCHOT_PROFILE_VSYS] = REG_FIELD(0x34, 2, 2), + [PROCHOT_PROFILE_BATPRES] = REG_FIELD(0x34, 1, 1), + [PROCHOT_PROFILE_ACOK] = REG_FIELD(0x34, 0, 0), + /*REG35*/ + [ADC_CONV] = REG_FIELD(0x35, 15, 15), + [ADC_START] = REG_FIELD(0x35, 14, 14), + [ADC_FULLSCALE] = REG_FIELD(0x35, 13, 13), + [EN_ADC_CMPIN] = REG_FIELD(0x35, 7, 7), + [EN_ADC_VBUS] = REG_FIELD(0x35, 6, 6), + [EN_ADC_PSYS] = REG_FIELD(0x35, 5, 5), + [EN_ADC_IIN] = REG_FIELD(0x35, 4, 4), + [EN_ADC_IDCHG] = REG_FIELD(0x35, 3, 3), + [EN_ADC_ICHG] = REG_FIELD(0x35, 2, 2), + [EN_ADC_VSYS] = REG_FIELD(0x35, 1, 1), + [EN_ADC_VBAT] = REG_FIELD(0x35, 0, 0), + /*REG3B*/ + [OTG_VOLTAGE] = REG_FIELD(0x3B, 6, 13), + /*REG3C*/ + [OTG_CURRENT] = REG_FIELD(0x3C, 8, 14), + /*REG3D*/ + [INPUT_VOLTAGE] = REG_FIELD(0x3D, 6, 13), + /*REG3E*/ + [MIN_SYS_VOTAGE] = REG_FIELD(0x3E, 8, 13), + /*REG3F*/ + [INPUT_CURRENT] = REG_FIELD(0x3F, 8, 14), + + /*REGFE*/ + [MANUFACTURE_ID] = REG_FIELD(0xFE, 0, 7), + /*REFFF*/ + [DEVICE_ID] = REG_FIELD(0xFF, 0, 7), +}; + +/* + * Most of the val -> idx conversions can be computed, given the minimum, + * maximum and the step between values. For the rest of conversions, we use + * lookup tables. + */ +enum bq25700_table_ids { + /* range tables */ + TBL_ICHG, + TBL_CHGMAX, + TBL_INPUTVOL, + TBL_INPUTCUR, + TBL_SYSVMIN, + TBL_OTGVOL, + TBL_OTGCUR, + TBL_EXTCON, +}; + +struct bq25700_range { + u32 min; + u32 max; + u32 step; +}; + +struct bq25700_lookup { + const u32 *tbl; + u32 size; +}; + +static const union { + struct bq25700_range rt; + struct bq25700_lookup lt; +} bq25700_tables[] = { + /* range tables */ + [TBL_ICHG] = { .rt = {0, 8128000, 64000} }, + /* uA */ + [TBL_CHGMAX] = { .rt = {0, 19200000, 16000} }, + /* uV max charge voltage*/ + [TBL_INPUTVOL] = { .rt = {3200000, 19520000, 64000} }, + /* uV input charge voltage*/ + [TBL_INPUTCUR] = {.rt = {0, 6350000, 50000} }, + /*uA input current*/ + [TBL_SYSVMIN] = { .rt = {1024000, 16182000, 256000} }, + /* uV min system voltage*/ + [TBL_OTGVOL] = {.rt = {4480000, 20800000, 64000} }, + /*uV OTG volage*/ + [TBL_OTGCUR] = {.rt = {0, 6350000, 50000} }, +}; + +static const struct regmap_range bq25700_readonly_reg_ranges[] = { + regmap_reg_range(0x20, 0x26), + regmap_reg_range(0xFE, 0xFF), +}; + +static const struct regmap_access_table bq25700_writeable_regs = { + .no_ranges = bq25700_readonly_reg_ranges, + .n_no_ranges = ARRAY_SIZE(bq25700_readonly_reg_ranges), +}; + +static const struct regmap_range bq25700_volatile_reg_ranges[] = { + regmap_reg_range(0x12, 0x12), + regmap_reg_range(0x14, 0x15), + regmap_reg_range(0x20, 0x26), + regmap_reg_range(0x30, 0x35), + regmap_reg_range(0x3B, 0x3F), + regmap_reg_range(0xFE, 0xFF), +}; + +static const struct regmap_access_table bq25700_volatile_regs = { + .yes_ranges = bq25700_volatile_reg_ranges, + .n_yes_ranges = ARRAY_SIZE(bq25700_volatile_reg_ranges), +}; + +static const struct regmap_config bq25700_regmap_config = { + .reg_bits = 8, + .val_bits = 16, + + .max_register = 0xFF, + .cache_type = REGCACHE_RBTREE, + + .wr_table = &bq25700_writeable_regs, + .volatile_table = &bq25700_volatile_regs, + .val_format_endian = REGMAP_ENDIAN_LITTLE, +}; + +static int bq25700_field_read(struct bq25700_device *charger, + enum bq25700_fields field_id) +{ + int ret; + int val; + + ret = regmap_field_read(charger->rmap_fields[field_id], &val); + if (ret < 0) + return ret; + + return val; +} + +static int bq25700_field_write(struct bq25700_device *charger, + enum bq25700_fields field_id, unsigned int val) +{ + return regmap_field_write(charger->rmap_fields[field_id], val); +} + +static int bq25700_get_chip_state(struct bq25700_device *charger, + struct bq25700_state *state) +{ + int i, ret; + + struct { + enum bq25700_fields id; + u8 *data; + } state_fields[] = { + {AC_STAT, &state->ac_stat}, + {ICO_DONE, &state->ico_done}, + {IN_VINDPM, &state->in_vindpm}, + {IN_IINDPM, &state->in_iindpm}, + {IN_FCHRG, &state->in_fchrg}, + {IN_PCHRG, &state->in_pchrg}, + {IN_OTG, &state->in_otg}, + {F_ACOV, &state->fault_acov}, + {F_BATOC, &state->fault_batoc}, + {F_ACOC, &state->fault_acoc}, + {SYSOVP_STAT, &state->sysovp_stat}, + {F_LATCHOFF, &state->fault_latchoff}, + {F_OTG_OVP, &state->fault_otg_ovp}, + {F_OTG_OCP, &state->fault_otg_ocp}, + }; + + for (i = 0; i < ARRAY_SIZE(state_fields); i++) { + ret = bq25700_field_read(charger, state_fields[i].id); + if (ret < 0) + return ret; + + *state_fields[i].data = ret; + } + + DBG("status:\n"); + DBG("AC_STAT: %d\n", state->ac_stat); + DBG("ICO_DONE: %d\n", state->ico_done); + DBG("IN_VINDPM: %d\n", state->in_vindpm); + DBG("IN_IINDPM: %d\n", state->in_iindpm); + DBG("IN_FCHRG: %d\n", state->in_fchrg); + DBG("IN_PCHRG: %d\n", state->in_pchrg); + DBG("IN_OTG: %d\n", state->in_otg); + DBG("F_ACOV: %d\n", state->fault_acov); + DBG("F_BATOC: %d\n", state->fault_batoc); + DBG("F_ACOC: %d\n", state->fault_acoc); + DBG("SYSOVP_STAT: %d\n", state->sysovp_stat); + DBG("F_LATCHOFF: %d\n", state->fault_latchoff); + DBG("F_OTGOVP: %d\n", state->fault_otg_ovp); + DBG("F_OTGOCP: %d\n", state->fault_otg_ocp); + return 0; +} + +static u32 bq25700_find_idx(u32 value, enum bq25700_table_ids id) +{ + u32 idx; + u32 rtbl_size; + const struct bq25700_range *rtbl = &bq25700_tables[id].rt; + + rtbl_size = (rtbl->max - rtbl->min) / rtbl->step + 1; + + for (idx = 1; + idx < rtbl_size && (idx * rtbl->step + rtbl->min <= value); + idx++) + ; + + return idx - 1; +} + +static int bq25700_fw_read_u32_props(struct bq25700_device *charger) +{ + int ret; + u32 property; + int i; + struct bq25700_init_data *init = &charger->init_data; + struct { + char *name; + bool optional; + enum bq25700_table_ids tbl_id; + u32 *conv_data; /* holds converted value from given property */ + } props[] = { + /* required properties */ + {"ti,charge-current", false, TBL_ICHG, + &init->ichg}, + {"ti,max-charge-voltage", false, TBL_CHGMAX, + &init->max_chg_vol}, + {"ti,input-current-sdp", false, TBL_INPUTCUR, + &init->input_current_sdp}, + {"ti,input-current-dcp", false, TBL_INPUTCUR, + &init->input_current_dcp}, + {"ti,input-current-cdp", false, TBL_INPUTCUR, + &init->input_current_cdp}, + {"ti,minimum-sys-voltage", false, TBL_SYSVMIN, + &init->sys_min_voltage}, + {"ti,otg-voltage", false, TBL_OTGVOL, + &init->otg_voltage}, + {"ti,otg-current", false, TBL_OTGCUR, + &init->otg_current}, + }; + + /* initialize data for optional properties */ + for (i = 0; i < ARRAY_SIZE(props); i++) { + ret = device_property_read_u32(charger->dev, props[i].name, + &property); + if (ret < 0) { + if (props[i].optional) + continue; + + return ret; + } + + if ((props[i].tbl_id == TBL_ICHG) && + (property > MAX_CHARGECURRETNT)) { + dev_err(charger->dev, "ti,charge-current is error\n"); + return -ENODEV; + } + if ((props[i].tbl_id == TBL_CHGMAX) && + (property > MAX_CHARGEVOLTAGE)) { + dev_err(charger->dev, "ti,max-charge-voltage is error\n"); + return -ENODEV; + } + if ((props[i].tbl_id == TBL_INPUTCUR) && + (property > MAX_INPUTCURRENT)) { + dev_err(charger->dev, "ti,input-current is error\n"); + return -ENODEV; + } + if ((props[i].tbl_id == TBL_OTGVOL) && + (property > MAX_OTGVOLTAGE)) { + dev_err(charger->dev, "ti,ti,otg-voltage is error\n"); + return -ENODEV; + } + if ((props[i].tbl_id == TBL_OTGVOL) && + (property > MAX_OTGCURRENT)) { + dev_err(charger->dev, "ti,otg-current is error\n"); + return -ENODEV; + } + + *props[i].conv_data = bq25700_find_idx(property, + props[i].tbl_id); + DBG("%s, val: %d, tbl_id =%d\n", props[i].name, property, + *props[i].conv_data); + } + + return 0; +} + +static int bq25700_chip_reset(struct bq25700_device *charger) +{ + int ret; + int rst_check_counter = 10; + + ret = bq25700_field_write(charger, RESET_REG, 1); + if (ret < 0) + return ret; + + do { + ret = bq25700_field_read(charger, RESET_REG); + if (ret < 0) + return ret; + + mdelay(4); + } while (ret == 1 && --rst_check_counter); + + if (!rst_check_counter) + return -ETIMEDOUT; + + return 0; +} + +static int bq25700_hw_init(struct bq25700_device *charger) +{ + int ret; + int i; + struct bq25700_state state; + + const struct { + enum bq25700_fields id; + u32 value; + } init_data[] = { + {CHARGE_CURRENT, charger->init_data.ichg}, + {MAX_CHARGE_VOLTAGE, charger->init_data.max_chg_vol}, + {INPUT_CURRENT, charger->init_data.input_current}, + {MIN_SYS_VOTAGE, charger->init_data.sys_min_voltage}, + {OTG_VOLTAGE, charger->init_data.otg_voltage}, + {OTG_CURRENT, charger->init_data.otg_current}, + }; + + ret = bq25700_chip_reset(charger); + if (ret < 0) + return ret; + + /* disable watchdog */ + ret = bq25700_field_write(charger, WDTWR_ADJ, 0); + if (ret < 0) + return ret; + + /* initialize currents/voltages and other parameters */ + for (i = 0; i < ARRAY_SIZE(init_data); i++) { + ret = bq25700_field_write(charger, init_data[i].id, + init_data[i].value); + if (ret < 0) + return ret; + } + + DBG(" CHARGE_CURRENT: %dmA\n", + bq25700_field_read(charger, CHARGE_CURRENT) * 64); + DBG("MAX_CHARGE_VOLTAGE: %dmV\n", + bq25700_field_read(charger, MAX_CHARGE_VOLTAGE) * 16); + DBG(" INPUT_VOLTAGE: %dmV\n", + 3200 + bq25700_field_read(charger, INPUT_VOLTAGE) * 64); + DBG(" INPUT_CURRENT: %dmA\n", + bq25700_field_read(charger, INPUT_CURRENT) * 50); + DBG(" MIN_SYS_VOTAGE: %dmV\n", + 1024 + bq25700_field_read(charger, MIN_SYS_VOTAGE) * 256); + + /* Configure ADC for continuous conversions. This does not enable it. */ + + ret = bq25700_field_write(charger, EN_LWPWR, 0); + if (ret < 0) { + DBG("error: EN_LWPWR\n"); + return ret; + } + + ret = bq25700_field_write(charger, ADC_CONV, 1); + if (ret < 0) { + DBG("error: ADC_CONV\n"); + return ret; + } + + ret = bq25700_field_write(charger, ADC_START, 1); + if (ret < 0) { + DBG("error: ADC_START\n"); + return ret; + } + + ret = bq25700_field_write(charger, ADC_FULLSCALE, 1); + if (ret < 0) { + DBG("error: ADC_FULLSCALE\n"); + return ret; + } + + ret = bq25700_field_write(charger, EN_ADC_CMPIN, 1); + if (ret < 0) { + DBG("error: EN_ADC_CMPIN\n"); + return ret; + } + + ret = bq25700_field_write(charger, EN_ADC_VBUS, 1); + if (ret < 0) { + DBG("error: EN_ADC_VBUS\n"); + return ret; + } + + ret = bq25700_field_write(charger, EN_ADC_PSYS, 1); + if (ret < 0) { + DBG("error: EN_ADC_PSYS\n"); + return ret; + } + + ret = bq25700_field_write(charger, EN_ADC_IIN, 1); + if (ret < 0) { + DBG("error: EN_ADC_IIN\n"); + return ret; + } + + ret = bq25700_field_write(charger, EN_ADC_IDCHG, 1); + if (ret < 0) { + DBG("error: EN_ADC_IDCHG\n"); + return ret; + } + + ret = bq25700_field_write(charger, EN_ADC_ICHG, 1); + if (ret < 0) { + DBG("error: EN_ADC_ICHG\n"); + return ret; + } + + ret = bq25700_field_write(charger, EN_ADC_VSYS, 1); + if (ret < 0) { + DBG("error: EN_ADC_VSYS\n"); + return ret; + } + + ret = bq25700_field_write(charger, EN_ADC_VBAT, 1); + if (ret < 0) { + DBG("error: EN_ADC_VBAT\n"); + return ret; + } + + bq25700_get_chip_state(charger, &state); + charger->state = state; + + return 0; +} + +static int bq25700_fw_probe(struct bq25700_device *charger) +{ + int ret; + + ret = bq25700_fw_read_u32_props(charger); + if (ret < 0) + return ret; + + return 0; +} + +static void bq25700_enable_charger(struct bq25700_device *charger, + u32 input_current) +{ + bq25700_field_write(charger, INPUT_CURRENT, input_current); + bq25700_field_write(charger, CHARGE_CURRENT, charger->init_data.ichg); +} + +static enum power_supply_property bq25700_power_supply_props[] = { + POWER_SUPPLY_PROP_MANUFACTURER, + POWER_SUPPLY_PROP_STATUS, + POWER_SUPPLY_PROP_ONLINE, + POWER_SUPPLY_PROP_HEALTH, + POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, + POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, + POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, + POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, + POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX, + POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, +}; + +static int bq25700_power_supply_get_property(struct power_supply *psy, + enum power_supply_property psp, + union power_supply_propval *val) +{ + int ret; + struct bq25700_device *bq = power_supply_get_drvdata(psy); + struct bq25700_state state; + + state = bq->state; + + switch (psp) { + case POWER_SUPPLY_PROP_STATUS: + if (!state.ac_stat) + val->intval = POWER_SUPPLY_STATUS_DISCHARGING; + else if (state.in_fchrg == 1 || + state.in_pchrg == 1) + val->intval = POWER_SUPPLY_STATUS_CHARGING; + else + val->intval = POWER_SUPPLY_STATUS_DISCHARGING; + break; + + case POWER_SUPPLY_PROP_MANUFACTURER: + val->strval = BQ25700_MANUFACTURER; + break; + + case POWER_SUPPLY_PROP_ONLINE: + val->intval = state.ac_stat; + break; + + case POWER_SUPPLY_PROP_HEALTH: + if (!state.fault_acoc && + !state.fault_acov && !state.fault_batoc) + val->intval = POWER_SUPPLY_HEALTH_GOOD; + else if (state.fault_batoc) + val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE; + break; + + case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: + /* read measured value */ + ret = bq25700_field_read(bq, OUTPUT_CHG_CUR); + if (ret < 0) + return ret; + + /* converted_val = ADC_val * 64mA */ + val->intval = ret * 64000; + break; + + case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: + val->intval = bq25700_tables[TBL_ICHG].rt.max; + break; + + case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: + if (!state.ac_stat) { + val->intval = 0; + break; + } + + /* read measured value */ + ret = bq25700_field_read(bq, OUTPUT_BAT_VOL); + if (ret < 0) + return ret; + + /* converted_val = 2.88V + ADC_val * 64mV */ + val->intval = 2880000 + ret * 64000; + break; + + case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: + val->intval = bq25700_tables[TBL_CHGMAX].rt.max; + break; + + case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX: + val->intval = bq25700_tables[TBL_INPUTVOL].rt.max; + break; + + case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: + val->intval = bq25700_tables[TBL_INPUTCUR].rt.max; + break; + + default: + return -EINVAL; + } + + return 0; +} + +static char *bq25700_charger_supplied_to[] = { + "charger", +}; + +static const struct power_supply_desc bq25700_power_supply_desc = { + .name = "bq25700-charger", + .type = POWER_SUPPLY_TYPE_USB, + .properties = bq25700_power_supply_props, + .num_properties = ARRAY_SIZE(bq25700_power_supply_props), + .get_property = bq25700_power_supply_get_property, +}; + +static int bq25700_power_supply_init(struct bq25700_device *charger) +{ + struct power_supply_config psy_cfg = { .drv_data = charger, }; + + psy_cfg.supplied_to = bq25700_charger_supplied_to; + psy_cfg.num_supplicants = ARRAY_SIZE(bq25700_charger_supplied_to); + + charger->supply_charger = + power_supply_register(charger->dev, + &bq25700_power_supply_desc, + &psy_cfg); + + return PTR_ERR_OR_ZERO(charger->supply_charger); +} + +static irqreturn_t bq25700_irq_handler_thread(int irq, void *private) +{ + struct bq25700_device *charger = private; + int ret; + struct bq25700_state state; + + ret = bq25700_get_chip_state(charger, &state); + if (ret < 0) + goto handled; + + charger->state = state; + + power_supply_changed(charger->supply_charger); + +handled: + return IRQ_HANDLED; +} + +static void bq25700_pd_evt_worker(struct work_struct *work) +{ + struct bq25700_device *charger = + container_of(work, struct bq25700_device, pd_work.work); + struct extcon_dev *edev = charger->cable_edev; + union extcon_property_value prop_val; + struct bq25700_state state; + int ret; + int vol, cur; + int vol_idx, cur_idx; + + if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_FAST) > 0) { + ret = extcon_get_property(edev, EXTCON_CHG_USB_FAST, + EXTCON_PROP_USB_TYPEC_POLARITY, + &prop_val); + DBG("usb pd charge...\n"); + vol = prop_val.intval & 0xffff; + cur = prop_val.intval >> 15; + if (ret == 0) { + vol_idx = bq25700_find_idx((vol - 1280) * 1000, + TBL_INPUTVOL); + cur_idx = bq25700_find_idx(cur * 1000, TBL_INPUTCUR); + bq25700_field_write(charger, INPUT_VOLTAGE, vol_idx); + bq25700_field_write(charger, INPUT_CURRENT, cur_idx); + bq25700_field_write(charger, CHARGE_CURRENT, + charger->init_data.ichg); + } + + bq25700_get_chip_state(charger, &state); + charger->state = state; + power_supply_changed(charger->supply_charger); + } +} + +static int bq25700_pd_evt_notifier(struct notifier_block *nb, + unsigned long event, + void *ptr) +{ + struct bq25700_device *charger = + container_of(nb, struct bq25700_device, cable_pd_nb); + + queue_delayed_work(charger->usb_charger_wq, &charger->pd_work, + msecs_to_jiffies(10)); + + return NOTIFY_DONE; +} + +static void bq25700_charger_evt_worker(struct work_struct *work) +{ + struct bq25700_device *charger = + container_of(work, struct bq25700_device, usb_work.work); + struct extcon_dev *edev = charger->cable_edev; + struct bq25700_state state; + enum charger_t charger_state = USB_TYPE_UNKNOWN_CHARGER; + + if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_FAST) > 0) + return; + + /* Determine cable/charger type */ + if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_SDP) > 0) { + charger_state = USB_TYPE_USB_CHARGER; + + bq25700_enable_charger(charger, + charger->init_data.input_current_sdp); + DBG("USB_TYPE_USB_CHARGER\n"); + } else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_DCP) > 0) { + charger_state = USB_TYPE_AC_CHARGER; + bq25700_enable_charger(charger, + charger->init_data.input_current_dcp); + DBG("USB_TYPE_AC_CHARGER\n"); + } else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_CDP) > 0) { + charger_state = USB_TYPE_CDP_CHARGER; + bq25700_enable_charger(charger, + charger->init_data.input_current_cdp); + DBG("USB_TYPE_CDP_CHARGER\n"); + } + + bq25700_get_chip_state(charger, &state); + charger->state = state; + power_supply_changed(charger->supply_charger); +} + +static int bq25700_charger_evt_notifier(struct notifier_block *nb, + unsigned long event, + void *ptr) +{ + struct bq25700_device *charger = + container_of(nb, struct bq25700_device, cable_cg_nb); + + queue_delayed_work(charger->usb_charger_wq, &charger->usb_work, + msecs_to_jiffies(10)); + + return NOTIFY_DONE; +} + +static void bq25700_host_evt_worker(struct work_struct *work) +{ + struct bq25700_device *charger = + container_of(work, struct bq25700_device, host_work.work); + struct extcon_dev *edev = charger->cable_edev; + + /* Determine cable/charger type */ + if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) > 0) { + bq25700_field_write(charger, EN_OTG, 1); + DBG("OTG enable\n"); + } else if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) == 0) { + bq25700_field_write(charger, EN_OTG, 0); + DBG("OTG disable\n"); + } +} + +static int bq25700_host_evt_notifier(struct notifier_block *nb, + unsigned long event, void *ptr) +{ + struct bq25700_device *charger = + container_of(nb, struct bq25700_device, cable_host_nb); + + queue_delayed_work(charger->usb_charger_wq, &charger->host_work, + msecs_to_jiffies(10)); + + return NOTIFY_DONE; +} + +static void bq25700_discnt_evt_worker(struct work_struct *work) +{ + int vol_idx; + struct bq25700_device *charger = + container_of(work, struct bq25700_device, discnt_work.work); + struct bq25700_state state; + + if (extcon_get_cable_state_(charger->cable_edev, EXTCON_USB) == 0) { + vol_idx = bq25700_find_idx(DEFAULT_INPUTVOL, TBL_INPUTVOL); + bq25700_field_write(charger, INPUT_VOLTAGE, vol_idx); + bq25700_field_write(charger, INPUT_CURRENT, + charger->init_data.input_current_sdp); + bq25700_get_chip_state(charger, &state); + charger->state = state; + power_supply_changed(charger->supply_charger); + } +} + +static int bq25700_discnt_evt_notfier(struct notifier_block *nb, + unsigned long event, + void *ptr) +{ + struct bq25700_device *charger = + container_of(nb, struct bq25700_device, cable_discnt_nb); + + queue_delayed_work(charger->usb_charger_wq, + &charger->discnt_work, + msecs_to_jiffies(10)); + + return NOTIFY_DONE; +} + +static long bq25700_init_usb(struct bq25700_device *charger) +{ + struct extcon_dev *edev; + struct device *dev = charger->dev; + int ret; + + charger->usb_charger_wq = alloc_ordered_workqueue("%s", + WQ_MEM_RECLAIM | + WQ_FREEZABLE, + "bq25700-usb-wq"); + + /* type-C */ + edev = extcon_get_edev_by_phandle(dev, 0); + if (IS_ERR(edev)) { + if (PTR_ERR(edev) != -EPROBE_DEFER) + dev_err(dev, "Invalid or missing extcon\n"); + return PTR_ERR(edev); + } + + /* Register chargers */ + INIT_DELAYED_WORK(&charger->usb_work, bq25700_charger_evt_worker); + charger->cable_cg_nb.notifier_call = bq25700_charger_evt_notifier; + + ret = extcon_register_notifier(edev, + EXTCON_CHG_USB_SDP, + &charger->cable_cg_nb); + if (ret < 0) { + dev_err(dev, "failed to register notifier for SDP\n"); + return ret; + } + + ret = extcon_register_notifier(edev, + EXTCON_CHG_USB_DCP, + &charger->cable_cg_nb); + if (ret < 0) { + dev_err(dev, "failed to register notifier for DCP\n"); + extcon_unregister_notifier(edev, + EXTCON_CHG_USB_SDP, + &charger->cable_cg_nb); + return ret; + } + + ret = extcon_register_notifier(edev, + EXTCON_CHG_USB_CDP, + &charger->cable_cg_nb); + if (ret < 0) { + dev_err(dev, "failed to register notifier for CDP\n"); + extcon_unregister_notifier(edev, + EXTCON_CHG_USB_SDP, + &charger->cable_cg_nb); + extcon_unregister_notifier(edev, + EXTCON_CHG_USB_DCP, + &charger->cable_cg_nb); + return ret; + } + + /* Register host */ + INIT_DELAYED_WORK(&charger->host_work, bq25700_host_evt_worker); + charger->cable_host_nb.notifier_call = bq25700_host_evt_notifier; + ret = extcon_register_notifier(edev, + EXTCON_USB_HOST, + &charger->cable_host_nb); + if (ret < 0) { + dev_err(dev, "failed to register notifier for HOST\n"); + extcon_unregister_notifier(edev, + EXTCON_CHG_USB_SDP, + &charger->cable_cg_nb); + extcon_unregister_notifier(edev, + EXTCON_CHG_USB_DCP, + &charger->cable_cg_nb); + extcon_unregister_notifier(edev, + EXTCON_CHG_USB_CDP, + &charger->cable_cg_nb); + + return ret; + } + + /* Register discnt usb */ + INIT_DELAYED_WORK(&charger->discnt_work, bq25700_discnt_evt_worker); + charger->cable_discnt_nb.notifier_call = bq25700_discnt_evt_notfier; + ret = extcon_register_notifier(edev, + EXTCON_USB, + &charger->cable_discnt_nb); + if (ret < 0) { + dev_err(dev, "failed to register notifier for HOST\n"); + extcon_unregister_notifier(edev, + EXTCON_CHG_USB_SDP, + &charger->cable_cg_nb); + extcon_unregister_notifier(edev, + EXTCON_CHG_USB_DCP, + &charger->cable_cg_nb); + extcon_unregister_notifier(edev, + EXTCON_CHG_USB_CDP, + &charger->cable_cg_nb); + extcon_unregister_notifier(edev, + EXTCON_USB_VBUS_EN, + &charger->cable_host_nb); + + return ret; + } + + charger->cable_edev = edev; + + schedule_delayed_work(&charger->host_work, 0); + schedule_delayed_work(&charger->usb_work, 0); + + INIT_DELAYED_WORK(&charger->pd_work, bq25700_pd_evt_worker); + charger->cable_pd_nb.notifier_call = bq25700_pd_evt_notifier; + ret = extcon_register_notifier(edev, + EXTCON_CHG_USB_FAST, + &charger->cable_pd_nb); + + return 0; +} + +static int bq25700_probe(struct i2c_client *client, + const struct i2c_device_id *id) +{ + struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); + struct device *dev = &client->dev; + struct bq25700_device *charger; + int ret = 0; + u32 i = 0; + + if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) + return -EIO; + + charger = devm_kzalloc(&client->dev, sizeof(*charger), GFP_KERNEL); + if (!charger) + return -EINVAL; + + charger->client = client; + charger->dev = dev; + charger->regmap = devm_regmap_init_i2c(client, + &bq25700_regmap_config); + + if (IS_ERR(charger->regmap)) { + dev_err(&client->dev, "Failed to initialize regmap\n"); + return -EINVAL; + } + + for (i = 0; i < ARRAY_SIZE(bq25700_reg_fields); i++) { + const struct reg_field *reg_fields = bq25700_reg_fields; + + charger->rmap_fields[i] = + devm_regmap_field_alloc(dev, + charger->regmap, + reg_fields[i]); + if (IS_ERR(charger->rmap_fields[i])) { + dev_err(dev, "cannot allocate regmap field\n"); + return PTR_ERR(charger->rmap_fields[i]); + } + } + + i2c_set_clientdata(client, charger); + + /*read chip id. Confirm whether to support the chip*/ + charger->chip_id = bq25700_field_read(charger, DEVICE_ID); + + if (charger->chip_id < 0) { + dev_err(dev, "Cannot read chip ID.\n"); + return charger->chip_id; + } + + if (!dev->platform_data) { + ret = bq25700_fw_probe(charger); + if (ret < 0) { + dev_err(dev, "Cannot read device properties.\n"); + return ret; + } + } else { + return -ENODEV; + } + + ret = bq25700_hw_init(charger); + if (ret < 0) { + dev_err(dev, "Cannot initialize the chip.\n"); + return ret; + } + + bq25700_init_usb(charger); + + if (client->irq < 0) { + dev_err(dev, "No irq resource found.\n"); + return client->irq; + } + ret = devm_request_threaded_irq(dev, client->irq, NULL, + bq25700_irq_handler_thread, + IRQF_TRIGGER_FALLING | IRQF_ONESHOT, + "bq25700_irq", charger); + if (ret) + goto irq_fail; + + bq25700_power_supply_init(charger); + +irq_fail: + return ret; +} + +#ifdef CONFIG_PM_SLEEP +static int bq25700_pm_suspend(struct device *dev) +{ + return 0; +} + +static int bq25700_pm_resume(struct device *dev) +{ + return 0; +} +#endif + +static SIMPLE_DEV_PM_OPS(bq25700_pm_ops, bq25700_pm_suspend, bq25700_pm_resume); + +static const struct i2c_device_id bq25700_i2c_ids[] = { + { "bq25700"}, + { }, +}; +MODULE_DEVICE_TABLE(i2c, bq25700_i2c_ids); + +#ifdef CONFIG_OF +static const struct of_device_id bq25700_of_match[] = { + { .compatible = "ti,bq25700", }, + { }, +}; +MODULE_DEVICE_TABLE(of, bq25700_of_match); +#else +static const struct of_device_id bq25700_of_match[] = { + { }, +}; +#endif + +static struct i2c_driver bq25700_driver = { + .probe = bq25700_probe, + .id_table = bq25700_i2c_ids, + .driver = { + .name = "bq25700-charger", + .pm = &bq25700_pm_ops, + .of_match_table = of_match_ptr(bq25700_of_match), + }, +}; +module_i2c_driver(bq25700_driver); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("shengfeixu "); +MODULE_DESCRIPTION("TI bq25700 Charger Driver"); -- 2.34.1