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