2 * TI BQ257000 charger driver
4 * Copyright (C) 2016 Rockchip Corporation
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
18 #include <linux/power/bq25700-charge.h>
19 #include <linux/i2c.h>
20 #include <linux/interrupt.h>
21 #include <linux/irq.h>
22 #include <linux/mfd/core.h>
23 #include <linux/module.h>
24 #include <linux/regmap.h>
25 #include <linux/of_device.h>
26 #include <linux/delay.h>
27 #include <linux/usb/phy.h>
28 #include <linux/power/rk_usbbc.h>
29 #include <linux/extcon.h>
30 #include <linux/delay.h>
31 #include <linux/power_supply.h>
32 #include <linux/gpio.h>
33 #include <linux/of_gpio.h>
34 #include <linux/rk_keys.h>
36 static int dbg_enable;
37 module_param_named(dbg_level, dbg_enable, int, 0644);
39 #define DBG(args...) \
46 #define bq25700_info(fmt, args...) pr_info("bq25700: "fmt, ##args)
48 #define BQ25700_MANUFACTURER "Texas Instruments"
49 #define BQ25700_ID 0x59
51 #define DEFAULT_INPUTVOL ((5000 - 1280) * 1000)
52 #define MAX_INPUTVOLTAGE 24000000
53 #define MAX_INPUTCURRENT 6350000
54 #define MAX_CHARGEVOLTAGE 16800000
55 #define MAX_CHARGECURRETNT 8128000
56 #define MAX_OTGVOLTAGE 20800000
57 #define MAX_OTGCURRENT 6350000
60 EN_LWPWR, WDTWR_ADJ, IDPM_AUTO_DISABLE,
61 EN_OOA, PWM_FREQ, EN_LEARN, IADP_GAIN, IBAT_GAIN,
62 EN_LDO, EN_IDPM, CHRG_INHIBIT,/*reg12h*/
63 CHARGE_CURRENT,/*reg14h*/
64 MAX_CHARGE_VOLTAGE,/*reg15h*/
66 AC_STAT, ICO_DONE, IN_VINDPM, IN_IINDPM, IN_FCHRG, IN_PCHRG, IN_OTG,
67 F_ACOV, F_BATOC, F_ACOC, SYSOVP_STAT, F_LATCHOFF, F_OTG_OVP, F_OTG_OCP,
69 STAT_COMP, STAT_ICRIT, STAT_INOM, STAT_IDCHG, STAT_VSYS, STAT_BAT_REMOV,
70 STAT_ADP_REMOV,/*reg21h*/
71 INPUT_CURRENT_DPM,/*reg22h*/
72 OUTPUT_INPUT_VOL, OUTPUT_SYS_POWER,/*reg23h*/
73 OUTPUT_DSG_CUR, OUTPUT_CHG_CUR,/*reg24h*/
74 OUTPUT_INPUT_CUR, OUTPUT_CMPIN_VOL,/*reg25h*/
75 OUTPUT_SYS_VOL, OUTPUT_BAT_VOL,/*reg26h*/
77 EN_IBAT, EN_PROCHOT_LPWR, EN_PSYS, RSNS_RAC, RSNS_RSR,
78 PSYS_RATIO, CMP_REF, CMP_POL, CMP_DEG, FORCE_LATCHOFF,
79 EN_SHIP_DCHG, AUTO_WAKEUP_EN, /*reg30h*/
80 PKPWR_TOVLD_REG, EN_PKPWR_IDPM, EN_PKPWR_VSYS, PKPWER_OVLD_STAT,
81 PKPWR_RELAX_STAT, PKPWER_TMAX, EN_EXTILIM, EN_ICHG_IDCHG, Q2_OCP,
82 ACX_OCP, EN_ACOC, ACOC_VTH, EN_BATOC, BATCOC_VTH,/*reg31h*/
83 EN_HIZ, RESET_REG, RESET_VINDPM, EN_OTG, EN_ICO_MODE, BATFETOFF_HIZ,
84 PSYS_OTG_IDCHG,/*reg32h*/
85 ILIM2_VTH, ICRIT_DEG, VSYS_VTH, EN_PROCHOT_EXT, PROCHOT_WIDTH,
86 PROCHOT_CLEAR, INOM_DEG,/*reg33h*/
87 IDCHG_VTH, IDCHG_DEG, PROCHOT_PROFILE_COMP, PROCHOT_PROFILE_ICRIT,
88 PROCHOT_PROFILE_INOM, PROCHOT_PROFILE_IDCHG,
89 PROCHOT_PROFILE_VSYS, PROCHOT_PROFILE_BATPRES, PROCHOT_PROFILE_ACOK,
91 ADC_CONV, ADC_START, ADC_FULLSCALE, EN_ADC_CMPIN, EN_ADC_VBUS,
92 EN_ADC_PSYS, EN_ADC_IIN, EN_ADC_IDCHG, EN_ADC_ICHG, EN_ADC_VSYS,
93 EN_ADC_VBAT,/*reg35h*/
95 OTG_VOLTAGE,/*reg3bh*/
96 OTG_CURRENT,/*reg3ch*/
97 INPUT_VOLTAGE,/*reg3dh*/
98 MIN_SYS_VOTAGE,/*reg3eh*/
99 INPUT_CURRENT,/*reg3fh*/
101 MANUFACTURE_ID,/*regfeh*/
108 USB_TYPE_UNKNOWN_CHARGER,
109 USB_TYPE_NONE_CHARGER,
110 USB_TYPE_USB_CHARGER,
112 USB_TYPE_CDP_CHARGER,
114 DC_TYPE_NONE_CHARGER,
130 /* initial field values, converted to register values */
131 struct bq25700_init_data {
132 u32 ichg; /* charge current */
133 u32 max_chg_vol; /*max charge voltage*/
134 u32 input_voltage; /*input voltage*/
135 u32 input_current; /*input current*/
136 u32 input_current_sdp;
137 u32 input_current_dcp;
138 u32 input_current_cdp;
139 u32 sys_min_voltage; /*mininum system voltage*/
140 u32 otg_voltage; /*OTG voltage*/
141 u32 otg_current; /*OTG current*/
144 struct bq25700_state {
161 struct bq25700_device {
162 struct i2c_client *client;
164 struct power_supply *supply_charger;
165 char model_name[I2C_NAME_SIZE];
168 bool charger_health_valid;
169 bool battery_health_valid;
170 bool battery_status_valid;
172 struct workqueue_struct *usb_charger_wq;
173 struct workqueue_struct *dc_charger_wq;
174 struct workqueue_struct *finish_sig_wq;
175 struct delayed_work usb_work;
176 struct delayed_work pd_work;
177 struct delayed_work host_work;
178 struct delayed_work discnt_work;
179 struct delayed_work usb_work1;
180 struct delayed_work pd_work1;
181 struct delayed_work host_work1;
182 struct delayed_work discnt_work1;
183 struct delayed_work irq_work;
184 struct notifier_block cable_cg_nb;
185 struct notifier_block cable_pd_nb;
186 struct notifier_block cable_host_nb;
187 struct notifier_block cable_discnt_nb;
188 struct notifier_block cable_cg_nb1;
189 struct notifier_block cable_pd_nb1;
190 struct notifier_block cable_host_nb1;
191 struct notifier_block cable_discnt_nb1;
192 struct extcon_dev *cable_edev;
193 struct extcon_dev *cable_edev_1;
196 struct gpio_desc *typec0_enable_io;
197 struct gpio_desc *typec1_enable_io;
198 struct gpio_desc *typec0_discharge_io;
199 struct gpio_desc *typec1_discharge_io;
201 struct regmap *regmap;
202 struct regmap_field *rmap_fields[F_MAX_FIELDS];
204 struct bq25700_init_data init_data;
205 struct bq25700_state state;
209 static const struct reg_field bq25700_reg_fields[] = {
211 [EN_LWPWR] = REG_FIELD(0x12, 15, 15),
212 [WDTWR_ADJ] = REG_FIELD(0x12, 13, 14),
213 [IDPM_AUTO_DISABLE] = REG_FIELD(0x12, 12, 12),
214 [EN_OOA] = REG_FIELD(0x12, 10, 10),
215 [PWM_FREQ] = REG_FIELD(0x12, 9, 9),
216 [EN_LEARN] = REG_FIELD(0x12, 5, 5),
217 [IADP_GAIN] = REG_FIELD(0x12, 4, 4),
218 [IBAT_GAIN] = REG_FIELD(0x12, 3, 3),
219 [EN_LDO] = REG_FIELD(0x12, 2, 2),
220 [EN_IDPM] = REG_FIELD(0x12, 1, 1),
221 [CHRG_INHIBIT] = REG_FIELD(0x12, 0, 0),
223 [CHARGE_CURRENT] = REG_FIELD(0x14, 6, 12),
225 [MAX_CHARGE_VOLTAGE] = REG_FIELD(0x15, 4, 14),
227 [AC_STAT] = REG_FIELD(0x20, 15, 15),
228 [ICO_DONE] = REG_FIELD(0x20, 14, 14),
229 [IN_VINDPM] = REG_FIELD(0x20, 12, 12),
230 [IN_IINDPM] = REG_FIELD(0x20, 11, 11),
231 [IN_FCHRG] = REG_FIELD(0x20, 10, 10),
232 [IN_PCHRG] = REG_FIELD(0x20, 9, 9),
233 [IN_OTG] = REG_FIELD(0x20, 8, 8),
234 [F_ACOV] = REG_FIELD(0x20, 7, 7),
235 [F_BATOC] = REG_FIELD(0x20, 6, 6),
236 [F_ACOC] = REG_FIELD(0x20, 5, 5),
237 [SYSOVP_STAT] = REG_FIELD(0x20, 4, 4),
238 [F_LATCHOFF] = REG_FIELD(0x20, 2, 2),
239 [F_OTG_OVP] = REG_FIELD(0x20, 1, 1),
240 [F_OTG_OCP] = REG_FIELD(0x20, 0, 0),
242 [STAT_COMP] = REG_FIELD(0x21, 6, 6),
243 [STAT_ICRIT] = REG_FIELD(0x21, 5, 5),
244 [STAT_INOM] = REG_FIELD(0x21, 4, 4),
245 [STAT_IDCHG] = REG_FIELD(0x21, 3, 3),
246 [STAT_VSYS] = REG_FIELD(0x21, 2, 2),
247 [STAT_BAT_REMOV] = REG_FIELD(0x21, 1, 1),
248 [STAT_ADP_REMOV] = REG_FIELD(0x21, 0, 0),
250 [INPUT_CURRENT_DPM] = REG_FIELD(0x22, 8, 14),
252 [OUTPUT_INPUT_VOL] = REG_FIELD(0x23, 8, 15),
253 [OUTPUT_SYS_POWER] = REG_FIELD(0x23, 0, 7),
255 [OUTPUT_DSG_CUR] = REG_FIELD(0x24, 8, 14),
256 [OUTPUT_CHG_CUR] = REG_FIELD(0x24, 0, 6),
258 [OUTPUT_INPUT_CUR] = REG_FIELD(0x25, 8, 15),
259 [OUTPUT_CMPIN_VOL] = REG_FIELD(0x25, 0, 7),
261 [OUTPUT_SYS_VOL] = REG_FIELD(0x26, 8, 15),
262 [OUTPUT_BAT_VOL] = REG_FIELD(0x26, 0, 6),
265 [EN_IBAT] = REG_FIELD(0x30, 15, 15),
266 [EN_PROCHOT_LPWR] = REG_FIELD(0x30, 13, 14),
267 [EN_PSYS] = REG_FIELD(0x30, 12, 12),
268 [RSNS_RAC] = REG_FIELD(0x30, 11, 11),
269 [RSNS_RSR] = REG_FIELD(0x30, 10, 10),
270 [PSYS_RATIO] = REG_FIELD(0x30, 9, 9),
271 [CMP_REF] = REG_FIELD(0x30, 7, 7),
272 [CMP_POL] = REG_FIELD(0x30, 6, 6),
273 [CMP_DEG] = REG_FIELD(0x30, 4, 5),
274 [FORCE_LATCHOFF] = REG_FIELD(0x30, 3, 3),
275 [EN_SHIP_DCHG] = REG_FIELD(0x30, 1, 1),
276 [AUTO_WAKEUP_EN] = REG_FIELD(0x30, 0, 0),
278 [PKPWR_TOVLD_REG] = REG_FIELD(0x31, 14, 15),
279 [EN_PKPWR_IDPM] = REG_FIELD(0x31, 13, 13),
280 [EN_PKPWR_VSYS] = REG_FIELD(0x31, 12, 12),
281 [PKPWER_OVLD_STAT] = REG_FIELD(0x31, 11, 11),
282 [PKPWR_RELAX_STAT] = REG_FIELD(0x31, 10, 10),
283 [PKPWER_TMAX] = REG_FIELD(0x31, 8, 9),
284 [EN_EXTILIM] = REG_FIELD(0x31, 7, 7),
285 [EN_ICHG_IDCHG] = REG_FIELD(0x31, 6, 6),
286 [Q2_OCP] = REG_FIELD(0x31, 5, 5),
287 [ACX_OCP] = REG_FIELD(0x31, 4, 4),
288 [EN_ACOC] = REG_FIELD(0x31, 3, 3),
289 [ACOC_VTH] = REG_FIELD(0x31, 2, 2),
290 [EN_BATOC] = REG_FIELD(0x31, 1, 1),
291 [BATCOC_VTH] = REG_FIELD(0x31, 0, 0),
293 [EN_HIZ] = REG_FIELD(0x32, 15, 15),
294 [RESET_REG] = REG_FIELD(0x32, 14, 14),
295 [RESET_VINDPM] = REG_FIELD(0x32, 13, 13),
296 [EN_OTG] = REG_FIELD(0x32, 12, 12),
297 [EN_ICO_MODE] = REG_FIELD(0x32, 11, 11),
298 [BATFETOFF_HIZ] = REG_FIELD(0x32, 1, 1),
299 [PSYS_OTG_IDCHG] = REG_FIELD(0x32, 0, 0),
301 [ILIM2_VTH] = REG_FIELD(0x33, 11, 15),
302 [ICRIT_DEG] = REG_FIELD(0x33, 9, 10),
303 [VSYS_VTH] = REG_FIELD(0x33, 6, 7),
304 [EN_PROCHOT_EXT] = REG_FIELD(0x33, 5, 5),
305 [PROCHOT_WIDTH] = REG_FIELD(0x33, 3, 4),
306 [PROCHOT_CLEAR] = REG_FIELD(0x33, 2, 2),
307 [INOM_DEG] = REG_FIELD(0x33, 1, 1),
309 [IDCHG_VTH] = REG_FIELD(0x34, 10, 15),
310 [IDCHG_DEG] = REG_FIELD(0x34, 8, 9),
311 [PROCHOT_PROFILE_COMP] = REG_FIELD(0x34, 6, 6),
312 [PROCHOT_PROFILE_ICRIT] = REG_FIELD(0x34, 5, 5),
313 [PROCHOT_PROFILE_INOM] = REG_FIELD(0x34, 4, 4),
314 [PROCHOT_PROFILE_IDCHG] = REG_FIELD(0x34, 3, 3),
315 [PROCHOT_PROFILE_VSYS] = REG_FIELD(0x34, 2, 2),
316 [PROCHOT_PROFILE_BATPRES] = REG_FIELD(0x34, 1, 1),
317 [PROCHOT_PROFILE_ACOK] = REG_FIELD(0x34, 0, 0),
319 [ADC_CONV] = REG_FIELD(0x35, 15, 15),
320 [ADC_START] = REG_FIELD(0x35, 14, 14),
321 [ADC_FULLSCALE] = REG_FIELD(0x35, 13, 13),
322 [EN_ADC_CMPIN] = REG_FIELD(0x35, 7, 7),
323 [EN_ADC_VBUS] = REG_FIELD(0x35, 6, 6),
324 [EN_ADC_PSYS] = REG_FIELD(0x35, 5, 5),
325 [EN_ADC_IIN] = REG_FIELD(0x35, 4, 4),
326 [EN_ADC_IDCHG] = REG_FIELD(0x35, 3, 3),
327 [EN_ADC_ICHG] = REG_FIELD(0x35, 2, 2),
328 [EN_ADC_VSYS] = REG_FIELD(0x35, 1, 1),
329 [EN_ADC_VBAT] = REG_FIELD(0x35, 0, 0),
331 [OTG_VOLTAGE] = REG_FIELD(0x3B, 6, 13),
333 [OTG_CURRENT] = REG_FIELD(0x3C, 8, 14),
335 [INPUT_VOLTAGE] = REG_FIELD(0x3D, 6, 13),
337 [MIN_SYS_VOTAGE] = REG_FIELD(0x3E, 8, 13),
339 [INPUT_CURRENT] = REG_FIELD(0x3F, 8, 14),
342 [MANUFACTURE_ID] = REG_FIELD(0xFE, 0, 7),
344 [DEVICE_ID] = REG_FIELD(0xFF, 0, 7),
348 * Most of the val -> idx conversions can be computed, given the minimum,
349 * maximum and the step between values. For the rest of conversions, we use
352 enum bq25700_table_ids {
364 struct bq25700_range {
370 struct bq25700_lookup {
376 struct bq25700_range rt;
377 struct bq25700_lookup lt;
378 } bq25700_tables[] = {
380 [TBL_ICHG] = { .rt = {0, 8128000, 64000} },
382 [TBL_CHGMAX] = { .rt = {0, 19200000, 16000} },
383 /* uV max charge voltage*/
384 [TBL_INPUTVOL] = { .rt = {3200000, 19520000, 64000} },
385 /* uV input charge voltage*/
386 [TBL_INPUTCUR] = {.rt = {0, 6350000, 50000} },
388 [TBL_SYSVMIN] = { .rt = {1024000, 16182000, 256000} },
389 /* uV min system voltage*/
390 [TBL_OTGVOL] = {.rt = {4480000, 20800000, 64000} },
392 [TBL_OTGCUR] = {.rt = {0, 6350000, 50000} },
395 static const struct regmap_range bq25700_readonly_reg_ranges[] = {
396 regmap_reg_range(0x20, 0x26),
397 regmap_reg_range(0xFE, 0xFF),
400 static const struct regmap_access_table bq25700_writeable_regs = {
401 .no_ranges = bq25700_readonly_reg_ranges,
402 .n_no_ranges = ARRAY_SIZE(bq25700_readonly_reg_ranges),
405 static const struct regmap_range bq25700_volatile_reg_ranges[] = {
406 regmap_reg_range(0x12, 0x12),
407 regmap_reg_range(0x14, 0x15),
408 regmap_reg_range(0x20, 0x26),
409 regmap_reg_range(0x30, 0x35),
410 regmap_reg_range(0x3B, 0x3F),
411 regmap_reg_range(0xFE, 0xFF),
414 static const struct regmap_access_table bq25700_volatile_regs = {
415 .yes_ranges = bq25700_volatile_reg_ranges,
416 .n_yes_ranges = ARRAY_SIZE(bq25700_volatile_reg_ranges),
419 static const struct regmap_config bq25700_regmap_config = {
423 .max_register = 0xFF,
424 .cache_type = REGCACHE_RBTREE,
426 .wr_table = &bq25700_writeable_regs,
427 .volatile_table = &bq25700_volatile_regs,
428 .val_format_endian = REGMAP_ENDIAN_LITTLE,
431 static void bq25700_disable_charge(struct bq25700_device *charger);
433 static struct bq25700_device *bq25700_charger;
435 static int bq25700_field_read(struct bq25700_device *charger,
436 enum bq25700_fields field_id)
441 ret = regmap_field_read(charger->rmap_fields[field_id], &val);
448 static int bq25700_field_write(struct bq25700_device *charger,
449 enum bq25700_fields field_id, unsigned int val)
451 return regmap_field_write(charger->rmap_fields[field_id], val);
454 static int bq25700_get_chip_state(struct bq25700_device *charger,
455 struct bq25700_state *state)
460 enum bq25700_fields id;
463 {AC_STAT, &state->ac_stat},
464 {ICO_DONE, &state->ico_done},
465 {IN_VINDPM, &state->in_vindpm},
466 {IN_IINDPM, &state->in_iindpm},
467 {IN_FCHRG, &state->in_fchrg},
468 {IN_PCHRG, &state->in_pchrg},
469 {IN_OTG, &state->in_otg},
470 {F_ACOV, &state->fault_acov},
471 {F_BATOC, &state->fault_batoc},
472 {F_ACOC, &state->fault_acoc},
473 {SYSOVP_STAT, &state->sysovp_stat},
474 {F_LATCHOFF, &state->fault_latchoff},
475 {F_OTG_OVP, &state->fault_otg_ovp},
476 {F_OTG_OCP, &state->fault_otg_ocp},
479 for (i = 0; i < ARRAY_SIZE(state_fields); i++) {
480 ret = bq25700_field_read(charger, state_fields[i].id);
484 *state_fields[i].data = ret;
490 static int bq25700_dump_regs(struct bq25700_device *charger)
493 struct bq25700_state state;
496 ret = bq25700_field_write(charger, ADC_START, 1);
498 DBG("error: ADC_START\n");
502 DBG("\n==================================\n");
503 regmap_read(charger->regmap, 0x12, &val);
504 DBG("REG0x12 : 0x%x\n", val);
505 regmap_read(charger->regmap, 0x14, &val);
506 DBG("REG0x14 : 0x%x\n", val);
507 regmap_read(charger->regmap, 0x15, &val);
508 DBG("REG0x15 : 0x%x\n", val);
509 regmap_read(charger->regmap, 0x30, &val);
510 DBG("REG0x30 : 0x%x\n", val);
511 regmap_read(charger->regmap, 0x31, &val);
512 DBG("REG0x31 : 0x%x\n", val);
513 regmap_read(charger->regmap, 0x32, &val);
514 DBG("REG0x32 : 0x%x\n", val);
515 regmap_read(charger->regmap, 0x33, &val);
516 DBG("REG0x33 : 0x%x\n", val);
517 regmap_read(charger->regmap, 0x34, &val);
518 DBG("REG0x34 : 0x%x\n", val);
519 regmap_read(charger->regmap, 0x35, &val);
520 DBG("REG0x35 : 0x%x\n", val);
521 regmap_read(charger->regmap, 0x20, &val);
522 DBG("REG0x20 : 0x%x\n", val);
523 regmap_read(charger->regmap, 0x21, &val);
524 DBG("REG0x21 : 0x%x\n", val);
525 regmap_read(charger->regmap, 0x22, &val);
526 DBG("REG0x22 : 0x%x\n", val);
527 regmap_read(charger->regmap, 0x23, &val);
528 DBG("REG0x23 : 0x%x\n", val);
529 regmap_read(charger->regmap, 0x24, &val);
530 DBG("REG0x24 : 0x%x\n", val);
531 regmap_read(charger->regmap, 0x25, &val);
532 DBG("REG0x25 : 0x%x\n", val);
533 regmap_read(charger->regmap, 0x26, &val);
534 DBG("REG0x26 : 0x%x\n", val);
535 regmap_read(charger->regmap, 0x3b, &val);
536 DBG("REG0x3b : 0x%x\n", val);
537 regmap_read(charger->regmap, 0x3c, &val);
538 DBG("REG0x3c : 0x%x\n", val);
539 regmap_read(charger->regmap, 0x3d, &val);
540 DBG("REG0x3d : 0x%x\n", val);
541 regmap_read(charger->regmap, 0x3e, &val);
542 DBG("REG0x3e : 0x%x\n", val);
543 regmap_read(charger->regmap, 0x3f, &val);
544 DBG("REG0x3f : 0x%x\n", val);
545 regmap_read(charger->regmap, 0xfe, &val);
546 DBG("REG0xfe : 0x%x\n", val);
547 regmap_read(charger->regmap, 0xff, &val);
548 DBG("REG0xff : 0x%x\n", val);
550 DBG("battery charge current: %dmA\n",
551 bq25700_field_read(charger, OUTPUT_DSG_CUR) * 64);
552 DBG("battery discharge current: %dmA\n",
553 bq25700_field_read(charger, OUTPUT_CHG_CUR) * 256);
554 DBG("VSYS volatge: %dmV\n",
555 2880 + bq25700_field_read(charger, OUTPUT_SYS_VOL) * 64);
556 DBG("BAT volatge: %dmV\n",
557 2880 + bq25700_field_read(charger, OUTPUT_BAT_VOL) * 64);
559 DBG("SET CHARGE_CURRENT: %dmA\n",
560 bq25700_field_read(charger, CHARGE_CURRENT) * 64);
561 DBG("MAX_CHARGE_VOLTAGE: %dmV\n",
562 bq25700_field_read(charger, MAX_CHARGE_VOLTAGE) * 16);
563 DBG(" INPUT_VOLTAGE: %dmV\n",
564 3200 + bq25700_field_read(charger, INPUT_VOLTAGE) * 64);
565 DBG(" INPUT_CURRENT: %dmA\n",
566 bq25700_field_read(charger, INPUT_CURRENT) * 50);
567 DBG(" MIN_SYS_VOTAGE: %dmV\n",
568 1024 + bq25700_field_read(charger, MIN_SYS_VOTAGE) * 256);
569 bq25700_get_chip_state(charger, &state);
571 DBG("AC_STAT: %d\n", state.ac_stat);
572 DBG("ICO_DONE: %d\n", state.ico_done);
573 DBG("IN_VINDPM: %d\n", state.in_vindpm);
574 DBG("IN_IINDPM: %d\n", state.in_iindpm);
575 DBG("IN_FCHRG: %d\n", state.in_fchrg);
576 DBG("IN_PCHRG: %d\n", state.in_pchrg);
577 DBG("IN_OTG: %d\n", state.in_otg);
578 DBG("F_ACOV: %d\n", state.fault_acov);
579 DBG("F_BATOC: %d\n", state.fault_batoc);
580 DBG("F_ACOC: %d\n", state.fault_acoc);
581 DBG("SYSOVP_STAT: %d\n", state.sysovp_stat);
582 DBG("F_LATCHOFF: %d\n", state.fault_latchoff);
583 DBG("F_OTGOVP: %d\n", state.fault_otg_ovp);
584 DBG("F_OTGOCP: %d\n", state.fault_otg_ocp);
586 DBG("\n+++++++++++++++++++++++++++++++++++++++++++++++++\n");
590 ssize_t bq25700_charge_info_show(struct device *dev,
591 struct device_attribute *attr, char *buf)
593 struct bq25700_device *charger = dev_get_drvdata(dev);
595 bq25700_dump_regs(charger);
600 static struct device_attribute bq25700_charger_attr[] = {
601 __ATTR(charge_info, 0664, bq25700_charge_info_show, NULL),
604 static void bq25700_init_sysfs(struct bq25700_device *charger)
608 for (i = 0; i < ARRAY_SIZE(bq25700_charger_attr); i++) {
609 ret = sysfs_create_file(&charger->dev->kobj,
610 &bq25700_charger_attr[i].attr);
612 dev_err(charger->dev, "create charger node(%s) error\n",
613 bq25700_charger_attr[i].attr.name);
617 static u32 bq25700_find_idx(u32 value, enum bq25700_table_ids id)
621 const struct bq25700_range *rtbl = &bq25700_tables[id].rt;
623 rtbl_size = (rtbl->max - rtbl->min) / rtbl->step + 1;
626 idx < rtbl_size && (idx * rtbl->step + rtbl->min <= value);
633 void bq25700_charger_set_current(unsigned long event,
638 if (!bq25700_charger) {
639 pr_err("[%s,%d] bq25700_charger is null\n", __func__, __LINE__);
643 case CHARGER_CURRENT_EVENT:
644 idx = bq25700_find_idx(current_value, TBL_ICHG);
645 bq25700_field_write(bq25700_charger, CHARGE_CURRENT, idx);
648 case INPUT_CURRENT_EVENT:
649 idx = bq25700_find_idx(current_value, TBL_INPUTCUR);
650 bq25700_field_write(bq25700_charger, INPUT_CURRENT, idx);
658 static int bq25700_fw_read_u32_props(struct bq25700_device *charger)
663 struct bq25700_init_data *init = &charger->init_data;
667 enum bq25700_table_ids tbl_id;
668 u32 *conv_data; /* holds converted value from given property */
670 /* required properties */
671 {"ti,charge-current", false, TBL_ICHG,
673 {"ti,max-charge-voltage", false, TBL_CHGMAX,
675 {"ti,input-current-sdp", false, TBL_INPUTCUR,
676 &init->input_current_sdp},
677 {"ti,input-current-dcp", false, TBL_INPUTCUR,
678 &init->input_current_dcp},
679 {"ti,input-current-cdp", false, TBL_INPUTCUR,
680 &init->input_current_cdp},
681 {"ti,minimum-sys-voltage", false, TBL_SYSVMIN,
682 &init->sys_min_voltage},
683 {"ti,otg-voltage", false, TBL_OTGVOL,
685 {"ti,otg-current", false, TBL_OTGCUR,
689 /* initialize data for optional properties */
690 for (i = 0; i < ARRAY_SIZE(props); i++) {
691 ret = device_property_read_u32(charger->dev, props[i].name,
694 if (props[i].optional)
700 if ((props[i].tbl_id == TBL_ICHG) &&
701 (property > MAX_CHARGECURRETNT)) {
702 dev_err(charger->dev, "ti,charge-current is error\n");
705 if ((props[i].tbl_id == TBL_CHGMAX) &&
706 (property > MAX_CHARGEVOLTAGE)) {
707 dev_err(charger->dev, "ti,max-charge-voltage is error\n");
710 if ((props[i].tbl_id == TBL_INPUTCUR) &&
711 (property > MAX_INPUTCURRENT)) {
712 dev_err(charger->dev, "ti,input-current is error\n");
715 if ((props[i].tbl_id == TBL_OTGVOL) &&
716 (property > MAX_OTGVOLTAGE)) {
717 dev_err(charger->dev, "ti,ti,otg-voltage is error\n");
720 if ((props[i].tbl_id == TBL_OTGVOL) &&
721 (property > MAX_OTGCURRENT)) {
722 dev_err(charger->dev, "ti,otg-current is error\n");
726 *props[i].conv_data = bq25700_find_idx(property,
728 DBG("%s, val: %d, tbl_id =%d\n", props[i].name, property,
729 *props[i].conv_data);
735 static int bq25700_chip_reset(struct bq25700_device *charger)
738 int rst_check_counter = 10;
740 ret = bq25700_field_write(charger, RESET_REG, 1);
745 ret = bq25700_field_read(charger, RESET_REG);
750 } while (ret == 1 && --rst_check_counter);
752 if (!rst_check_counter)
758 static int bq25700_hw_init(struct bq25700_device *charger)
762 struct bq25700_state state;
765 enum bq25700_fields id;
768 {CHARGE_CURRENT, charger->init_data.ichg},
769 {MAX_CHARGE_VOLTAGE, charger->init_data.max_chg_vol},
770 {INPUT_CURRENT, charger->init_data.input_current},
771 {MIN_SYS_VOTAGE, charger->init_data.sys_min_voltage},
772 {OTG_VOLTAGE, charger->init_data.otg_voltage},
773 {OTG_CURRENT, charger->init_data.otg_current},
776 ret = bq25700_chip_reset(charger);
780 /* disable watchdog */
781 ret = bq25700_field_write(charger, WDTWR_ADJ, 0);
785 /* initialize currents/voltages and other parameters */
786 for (i = 0; i < ARRAY_SIZE(init_data); i++) {
787 ret = bq25700_field_write(charger, init_data[i].id,
793 DBG(" CHARGE_CURRENT: %dmA\n",
794 bq25700_field_read(charger, CHARGE_CURRENT) * 64);
795 DBG("MAX_CHARGE_VOLTAGE: %dmV\n",
796 bq25700_field_read(charger, MAX_CHARGE_VOLTAGE) * 16);
797 DBG(" INPUT_VOLTAGE: %dmV\n",
798 3200 + bq25700_field_read(charger, INPUT_VOLTAGE) * 64);
799 DBG(" INPUT_CURRENT: %dmA\n",
800 bq25700_field_read(charger, INPUT_CURRENT) * 50);
801 DBG(" MIN_SYS_VOTAGE: %dmV\n",
802 1024 + bq25700_field_read(charger, MIN_SYS_VOTAGE) * 256);
804 /* Configure ADC for continuous conversions. This does not enable it. */
806 ret = bq25700_field_write(charger, EN_LWPWR, 0);
808 DBG("error: EN_LWPWR\n");
812 ret = bq25700_field_write(charger, ADC_CONV, 1);
814 DBG("error: ADC_CONV\n");
818 ret = bq25700_field_write(charger, ADC_START, 1);
820 DBG("error: ADC_START\n");
824 ret = bq25700_field_write(charger, ADC_FULLSCALE, 1);
826 DBG("error: ADC_FULLSCALE\n");
830 ret = bq25700_field_write(charger, EN_ADC_CMPIN, 1);
832 DBG("error: EN_ADC_CMPIN\n");
836 ret = bq25700_field_write(charger, EN_ADC_VBUS, 1);
838 DBG("error: EN_ADC_VBUS\n");
842 ret = bq25700_field_write(charger, EN_ADC_PSYS, 1);
844 DBG("error: EN_ADC_PSYS\n");
848 ret = bq25700_field_write(charger, EN_ADC_IIN, 1);
850 DBG("error: EN_ADC_IIN\n");
854 ret = bq25700_field_write(charger, EN_ADC_IDCHG, 1);
856 DBG("error: EN_ADC_IDCHG\n");
860 ret = bq25700_field_write(charger, EN_ADC_ICHG, 1);
862 DBG("error: EN_ADC_ICHG\n");
866 ret = bq25700_field_write(charger, EN_ADC_VSYS, 1);
868 DBG("error: EN_ADC_VSYS\n");
872 ret = bq25700_field_write(charger, EN_ADC_VBAT, 1);
874 DBG("error: EN_ADC_VBAT\n");
878 bq25700_get_chip_state(charger, &state);
879 charger->state = state;
884 static int bq25700_fw_probe(struct bq25700_device *charger)
888 ret = bq25700_fw_read_u32_props(charger);
895 static void bq25700_enable_charger(struct bq25700_device *charger,
898 bq25700_field_write(charger, INPUT_CURRENT, input_current);
899 bq25700_field_write(charger, CHARGE_CURRENT, charger->init_data.ichg);
902 static enum power_supply_property bq25700_power_supply_props[] = {
903 POWER_SUPPLY_PROP_MANUFACTURER,
904 POWER_SUPPLY_PROP_STATUS,
905 POWER_SUPPLY_PROP_ONLINE,
906 POWER_SUPPLY_PROP_HEALTH,
907 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
908 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
909 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
910 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
911 POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX,
912 POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
915 static int bq25700_power_supply_get_property(struct power_supply *psy,
916 enum power_supply_property psp,
917 union power_supply_propval *val)
920 struct bq25700_device *bq = power_supply_get_drvdata(psy);
921 struct bq25700_state state;
926 case POWER_SUPPLY_PROP_STATUS:
928 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
929 else if (state.in_fchrg == 1 ||
931 val->intval = POWER_SUPPLY_STATUS_CHARGING;
933 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
936 case POWER_SUPPLY_PROP_MANUFACTURER:
937 val->strval = BQ25700_MANUFACTURER;
940 case POWER_SUPPLY_PROP_ONLINE:
941 val->intval = state.ac_stat;
944 case POWER_SUPPLY_PROP_HEALTH:
945 if (!state.fault_acoc &&
946 !state.fault_acov && !state.fault_batoc)
947 val->intval = POWER_SUPPLY_HEALTH_GOOD;
948 else if (state.fault_batoc)
949 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
952 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
953 /* read measured value */
954 ret = bq25700_field_read(bq, OUTPUT_CHG_CUR);
958 /* converted_val = ADC_val * 64mA */
959 val->intval = ret * 64000;
962 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
963 val->intval = bq25700_tables[TBL_ICHG].rt.max;
966 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
967 if (!state.ac_stat) {
972 /* read measured value */
973 ret = bq25700_field_read(bq, OUTPUT_BAT_VOL);
977 /* converted_val = 2.88V + ADC_val * 64mV */
978 val->intval = 2880000 + ret * 64000;
981 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
982 val->intval = bq25700_tables[TBL_CHGMAX].rt.max;
985 case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX:
986 val->intval = bq25700_tables[TBL_INPUTVOL].rt.max;
989 case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
990 val->intval = bq25700_tables[TBL_INPUTCUR].rt.max;
1000 static char *bq25700_charger_supplied_to[] = {
1004 static const struct power_supply_desc bq25700_power_supply_desc = {
1005 .name = "bq25700-charger",
1006 .type = POWER_SUPPLY_TYPE_USB,
1007 .properties = bq25700_power_supply_props,
1008 .num_properties = ARRAY_SIZE(bq25700_power_supply_props),
1009 .get_property = bq25700_power_supply_get_property,
1012 static int bq25700_power_supply_init(struct bq25700_device *charger)
1014 struct power_supply_config psy_cfg = { .drv_data = charger, };
1016 psy_cfg.supplied_to = bq25700_charger_supplied_to;
1017 psy_cfg.num_supplicants = ARRAY_SIZE(bq25700_charger_supplied_to);
1019 charger->supply_charger =
1020 power_supply_register(charger->dev,
1021 &bq25700_power_supply_desc,
1024 return PTR_ERR_OR_ZERO(charger->supply_charger);
1027 static irqreturn_t bq25700_irq_handler_thread(int irq, void *private)
1029 struct bq25700_device *charger = private;
1031 struct bq25700_state state;
1033 if (bq25700_field_read(charger, AC_STAT)) {
1034 irq_flag = IRQF_TRIGGER_LOW;
1036 irq_flag = IRQF_TRIGGER_HIGH;
1037 bq25700_field_write(charger, INPUT_CURRENT,
1038 charger->init_data.input_current_sdp);
1039 bq25700_disable_charge(charger);
1040 bq25700_get_chip_state(charger, &state);
1041 charger->state = state;
1042 power_supply_changed(charger->supply_charger);
1043 charger->typec0_status = USB_STATUS_NONE;
1044 charger->typec1_status = USB_STATUS_NONE;
1046 irq_set_irq_type(irq, irq_flag | IRQF_ONESHOT);
1047 rk_send_wakeup_key();
1052 static void bq25700_enable_typec0(struct bq25700_device *charger)
1054 if (!IS_ERR_OR_NULL(charger->typec0_enable_io))
1055 gpiod_direction_output(charger->typec0_enable_io, 1);
1056 if (!IS_ERR_OR_NULL(charger->typec1_enable_io))
1057 gpiod_direction_output(charger->typec1_enable_io, 0);
1060 static void bq25700_enable_typec1(struct bq25700_device *charger)
1062 if (!IS_ERR_OR_NULL(charger->typec0_enable_io))
1063 gpiod_direction_output(charger->typec0_enable_io, 0);
1064 if (!IS_ERR_OR_NULL(charger->typec1_enable_io))
1065 gpiod_direction_output(charger->typec1_enable_io, 1);
1068 static void bq25700_disable_charge(struct bq25700_device *charger)
1070 if (!IS_ERR_OR_NULL(charger->typec0_enable_io))
1071 gpiod_direction_output(charger->typec0_enable_io, 0);
1072 if (!IS_ERR_OR_NULL(charger->typec1_enable_io))
1073 gpiod_direction_output(charger->typec1_enable_io, 0);
1076 static void bq25700_typec0_discharge(struct bq25700_device *charger)
1078 if (!IS_ERR_OR_NULL(charger->typec0_discharge_io))
1079 gpiod_direction_output(charger->typec0_discharge_io, 1);
1081 if (!IS_ERR_OR_NULL(charger->typec0_discharge_io))
1082 gpiod_direction_output(charger->typec0_discharge_io, 0);
1085 static void bq25700_typec1_discharge(struct bq25700_device *charger)
1087 if (!IS_ERR_OR_NULL(charger->typec1_discharge_io))
1088 gpiod_direction_output(charger->typec1_discharge_io, 1);
1090 if (!IS_ERR_OR_NULL(charger->typec1_discharge_io))
1091 gpiod_direction_output(charger->typec1_discharge_io, 0);
1094 static void bq25700_pd_connect(struct bq25700_device *charger,
1095 struct extcon_dev *edev,
1096 enum tpyec_port_t port)
1098 union extcon_property_value prop_val;
1099 struct bq25700_state state;
1102 int vol_idx, cur_idx;
1105 if (charger->typec0_status == USB_STATUS_PD ||
1106 charger->typec1_status == USB_STATUS_PD)
1109 if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_FAST) > 0) {
1110 ret = extcon_get_property(edev, EXTCON_CHG_USB_FAST,
1111 EXTCON_PROP_USB_TYPEC_POLARITY,
1113 DBG("usb pd charge...\n");
1114 vol = prop_val.intval & 0xffff;
1115 cur = prop_val.intval >> 15;
1117 if (port == USB_TYPEC_0) {
1118 charger->typec0_status = USB_STATUS_PD;
1119 bq25700_enable_typec0(charger);
1121 charger->typec1_status = USB_STATUS_PD;
1122 bq25700_enable_typec1(charger);
1126 while (!bq25700_field_read(charger, AC_STAT) && i < 5) {
1130 vol_idx = bq25700_find_idx((vol - 1280) * 1000,
1132 cur_idx = bq25700_find_idx(cur * 1000, TBL_INPUTCUR);
1133 bq25700_field_write(charger, INPUT_VOLTAGE, vol_idx);
1134 bq25700_field_write(charger, INPUT_CURRENT, cur_idx);
1135 bq25700_field_write(charger, CHARGE_CURRENT,
1136 charger->init_data.ichg);
1139 bq25700_get_chip_state(charger, &state);
1140 charger->state = state;
1141 power_supply_changed(charger->supply_charger);
1145 static void bq25700_pd_evt_worker(struct work_struct *work)
1147 struct bq25700_device *charger = container_of(work,
1148 struct bq25700_device, pd_work.work);
1149 struct extcon_dev *edev = charger->cable_edev;
1151 bq25700_pd_connect(charger, edev, USB_TYPEC_0);
1154 static void bq25700_pd_evt_worker1(struct work_struct *work)
1156 struct bq25700_device *charger = container_of(work,
1157 struct bq25700_device, pd_work1.work);
1158 struct extcon_dev *edev = charger->cable_edev_1;
1160 bq25700_pd_connect(charger, edev, USB_TYPEC_1);
1163 static int bq25700_pd_evt_notifier(struct notifier_block *nb,
1164 unsigned long event,
1167 struct bq25700_device *charger =
1168 container_of(nb, struct bq25700_device, cable_pd_nb);
1170 queue_delayed_work(charger->usb_charger_wq, &charger->pd_work,
1171 msecs_to_jiffies(10));
1176 static int bq25700_pd_evt_notifier1(struct notifier_block *nb,
1177 unsigned long event,
1180 struct bq25700_device *charger =
1181 container_of(nb, struct bq25700_device, cable_pd_nb1);
1183 queue_delayed_work(charger->usb_charger_wq, &charger->pd_work1,
1184 msecs_to_jiffies(10));
1189 static void bq25700_charger_evt_handel(struct bq25700_device *charger,
1190 struct extcon_dev *edev,
1191 enum tpyec_port_t port)
1193 struct bq25700_state state;
1194 enum charger_t charger_state = USB_TYPE_UNKNOWN_CHARGER;
1196 if (charger->typec0_status == USB_STATUS_PD ||
1197 charger->typec1_status == USB_STATUS_PD)
1200 /* Determine cable/charger type */
1201 if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_SDP) > 0) {
1202 charger_state = USB_TYPE_USB_CHARGER;
1204 bq25700_enable_charger(charger,
1205 charger->init_data.input_current_sdp);
1206 DBG("USB_TYPE_USB_CHARGER\n");
1207 } else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_DCP) > 0) {
1208 charger_state = USB_TYPE_AC_CHARGER;
1209 bq25700_enable_charger(charger,
1210 charger->init_data.input_current_dcp);
1211 DBG("USB_TYPE_AC_CHARGER\n");
1212 } else if (extcon_get_cable_state_(edev, EXTCON_CHG_USB_CDP) > 0) {
1213 charger_state = USB_TYPE_CDP_CHARGER;
1214 bq25700_enable_charger(charger,
1215 charger->init_data.input_current_cdp);
1216 DBG("USB_TYPE_CDP_CHARGER\n");
1218 if (port == USB_TYPEC_0) {
1219 if (charger_state == USB_TYPE_USB_CHARGER)
1220 charger->typec0_status = USB_STATUS_USB;
1222 charger->typec0_status = USB_STATUS_AC;
1223 bq25700_enable_typec0(charger);
1225 if (charger_state == USB_TYPE_USB_CHARGER)
1226 charger->typec1_status = USB_STATUS_USB;
1228 charger->typec1_status = USB_STATUS_AC;
1229 bq25700_enable_typec1(charger);
1232 bq25700_get_chip_state(charger, &state);
1233 charger->state = state;
1234 power_supply_changed(charger->supply_charger);
1237 static void bq25700_charger_evt_worker(struct work_struct *work)
1239 struct bq25700_device *charger = container_of(work,
1240 struct bq25700_device, usb_work.work);
1241 struct extcon_dev *edev = charger->cable_edev;
1243 bq25700_charger_evt_handel(charger, edev, USB_TYPEC_0);
1246 static void bq25700_charger_evt_worker1(struct work_struct *work)
1248 struct bq25700_device *charger = container_of(work,
1249 struct bq25700_device, usb_work1.work);
1250 struct extcon_dev *edev = charger->cable_edev_1;
1252 bq25700_charger_evt_handel(charger, edev, USB_TYPEC_1);
1255 static int bq25700_charger_evt_notifier(struct notifier_block *nb,
1256 unsigned long event,
1259 struct bq25700_device *charger =
1260 container_of(nb, struct bq25700_device, cable_cg_nb);
1262 queue_delayed_work(charger->usb_charger_wq, &charger->usb_work,
1263 msecs_to_jiffies(10));
1268 static int bq25700_charger_evt_notifier1(struct notifier_block *nb,
1269 unsigned long event,
1272 struct bq25700_device *charger =
1273 container_of(nb, struct bq25700_device, cable_cg_nb1);
1275 queue_delayed_work(charger->usb_charger_wq, &charger->usb_work1,
1276 msecs_to_jiffies(10));
1281 static void bq25700_host_evt_worker(struct work_struct *work)
1283 struct bq25700_device *charger =
1284 container_of(work, struct bq25700_device, host_work.work);
1285 struct extcon_dev *edev = charger->cable_edev;
1287 /* Determine cable/charger type */
1288 if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) > 0) {
1289 bq25700_field_write(charger, EN_OTG, 1);
1290 DBG("OTG enable\n");
1291 } else if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) == 0) {
1292 bq25700_field_write(charger, EN_OTG, 0);
1293 DBG("OTG disable\n");
1297 static void bq25700_host_evt_worker1(struct work_struct *work)
1299 struct bq25700_device *charger =
1300 container_of(work, struct bq25700_device, host_work1.work);
1301 struct extcon_dev *edev = charger->cable_edev_1;
1303 /* Determine cable/charger type */
1304 if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) > 0) {
1305 bq25700_field_write(charger, EN_OTG, 1);
1306 DBG("OTG enable\n");
1307 } else if (extcon_get_cable_state_(edev, EXTCON_USB_VBUS_EN) == 0) {
1308 bq25700_field_write(charger, EN_OTG, 0);
1309 DBG("OTG disable\n");
1313 static int bq25700_host_evt_notifier(struct notifier_block *nb,
1314 unsigned long event, void *ptr)
1316 struct bq25700_device *charger =
1317 container_of(nb, struct bq25700_device, cable_host_nb);
1319 queue_delayed_work(charger->usb_charger_wq, &charger->host_work,
1320 msecs_to_jiffies(10));
1325 static int bq25700_host_evt_notifier1(struct notifier_block *nb,
1326 unsigned long event, void *ptr)
1328 struct bq25700_device *charger =
1329 container_of(nb, struct bq25700_device, cable_host_nb1);
1331 queue_delayed_work(charger->usb_charger_wq, &charger->host_work1,
1332 msecs_to_jiffies(10));
1337 static void bq25700_discnt(struct bq25700_device *charger,
1338 enum tpyec_port_t port)
1341 struct bq25700_state state;
1343 if (bq25700_field_read(charger, AC_STAT) == 0) {
1344 bq25700_disable_charge(charger);
1345 if (port == USB_TYPEC_0) {
1346 bq25700_typec0_discharge(charger);
1347 charger->typec0_status = USB_STATUS_NONE;
1349 bq25700_typec1_discharge(charger);
1350 charger->typec1_status = USB_STATUS_NONE;
1353 vol_idx = bq25700_find_idx(DEFAULT_INPUTVOL, TBL_INPUTVOL);
1354 bq25700_field_write(charger, INPUT_VOLTAGE, vol_idx);
1355 bq25700_field_write(charger, INPUT_CURRENT,
1356 charger->init_data.input_current_sdp);
1357 bq25700_get_chip_state(charger, &state);
1358 charger->state = state;
1359 power_supply_changed(charger->supply_charger);
1363 static void bq25700_discnt_evt_worker(struct work_struct *work)
1365 struct bq25700_device *charger = container_of(work,
1366 struct bq25700_device,
1369 bq25700_discnt(charger, USB_TYPEC_0);
1372 static void bq25700_discnt_evt_worker1(struct work_struct *work)
1374 struct bq25700_device *charger = container_of(work,
1375 struct bq25700_device,
1377 bq25700_discnt(charger, USB_TYPEC_1);
1380 static int bq25700_discnt_evt_notfier(struct notifier_block *nb,
1381 unsigned long event,
1384 struct bq25700_device *charger =
1385 container_of(nb, struct bq25700_device, cable_discnt_nb);
1387 queue_delayed_work(charger->usb_charger_wq,
1388 &charger->discnt_work,
1389 msecs_to_jiffies(0));
1394 static int bq25700_discnt_evt_notfier1(struct notifier_block *nb,
1395 unsigned long event,
1398 struct bq25700_device *charger =
1399 container_of(nb, struct bq25700_device, cable_discnt_nb1);
1401 queue_delayed_work(charger->usb_charger_wq,
1402 &charger->discnt_work1,
1403 msecs_to_jiffies(0));
1408 static int bq25700_register_cg_extcon(struct bq25700_device *charger,
1409 struct extcon_dev *edev,
1410 struct notifier_block *able_cg_nb)
1414 ret = extcon_register_notifier(edev,
1418 dev_err(charger->dev, "failed to register notifier for SDP\n");
1422 ret = extcon_register_notifier(edev,
1426 dev_err(charger->dev, "failed to register notifier for DCP\n");
1430 ret = extcon_register_notifier(edev,
1434 dev_err(charger->dev, "failed to register notifier for CDP\n");
1441 static int bq25700_register_cg_nb(struct bq25700_device *charger)
1443 if (charger->cable_edev) {
1444 /* Register chargers */
1445 INIT_DELAYED_WORK(&charger->usb_work,
1446 bq25700_charger_evt_worker);
1447 charger->cable_cg_nb.notifier_call =
1448 bq25700_charger_evt_notifier;
1449 bq25700_register_cg_extcon(charger, charger->cable_edev,
1450 &charger->cable_cg_nb);
1453 if (charger->cable_edev_1) {
1454 INIT_DELAYED_WORK(&charger->usb_work1,
1455 bq25700_charger_evt_worker1);
1456 charger->cable_cg_nb1.notifier_call =
1457 bq25700_charger_evt_notifier1;
1458 bq25700_register_cg_extcon(charger, charger->cable_edev_1,
1459 &charger->cable_cg_nb1);
1465 static int bq25700_register_discnt_nb(struct bq25700_device *charger)
1469 /* Register discnt usb */
1470 if (charger->cable_edev) {
1471 INIT_DELAYED_WORK(&charger->discnt_work,
1472 bq25700_discnt_evt_worker);
1473 charger->cable_discnt_nb.notifier_call =
1474 bq25700_discnt_evt_notfier;
1475 ret = extcon_register_notifier(charger->cable_edev,
1477 &charger->cable_discnt_nb);
1479 dev_err(charger->dev,
1480 "failed to register notifier for HOST\n");
1485 if (charger->cable_edev_1) {
1486 INIT_DELAYED_WORK(&charger->discnt_work1,
1487 bq25700_discnt_evt_worker1);
1488 charger->cable_discnt_nb1.notifier_call =
1489 bq25700_discnt_evt_notfier1;
1490 ret = extcon_register_notifier(charger->cable_edev_1,
1492 &charger->cable_discnt_nb1);
1494 dev_err(charger->dev,
1495 "failed to register notifier for HOST\n");
1503 static int bq25700_register_pd_nb(struct bq25700_device *charger)
1505 if (charger->cable_edev) {
1506 INIT_DELAYED_WORK(&charger->pd_work, bq25700_pd_evt_worker);
1507 charger->cable_pd_nb.notifier_call = bq25700_pd_evt_notifier;
1508 extcon_register_notifier(charger->cable_edev,
1509 EXTCON_CHG_USB_FAST,
1510 &charger->cable_pd_nb);
1513 if (charger->cable_edev_1) {
1514 INIT_DELAYED_WORK(&charger->pd_work1, bq25700_pd_evt_worker1);
1515 charger->cable_pd_nb1.notifier_call = bq25700_pd_evt_notifier1;
1516 extcon_register_notifier(charger->cable_edev_1,
1517 EXTCON_CHG_USB_FAST,
1518 &charger->cable_pd_nb1);
1524 static int bq25700_register_host_nb(struct bq25700_device *charger)
1529 if (charger->cable_edev) {
1530 INIT_DELAYED_WORK(&charger->host_work, bq25700_host_evt_worker);
1531 charger->cable_host_nb.notifier_call =
1532 bq25700_host_evt_notifier;
1533 ret = extcon_register_notifier(charger->cable_edev,
1535 &charger->cable_host_nb);
1537 dev_err(charger->dev,
1538 "failed to register notifier for HOST\n");
1543 if (charger->cable_edev_1) {
1544 INIT_DELAYED_WORK(&charger->host_work1,
1545 bq25700_host_evt_worker1);
1546 charger->cable_host_nb1.notifier_call =
1547 bq25700_host_evt_notifier1;
1548 ret = extcon_register_notifier(charger->cable_edev_1,
1550 &charger->cable_host_nb1);
1552 dev_err(charger->dev,
1553 "failed to register notifier for HOST\n");
1561 static long bq25700_init_usb(struct bq25700_device *charger)
1563 struct extcon_dev *edev, *edev1;
1564 struct device *dev = charger->dev;
1566 charger->usb_charger_wq = alloc_ordered_workqueue("%s",
1571 edev = extcon_get_edev_by_phandle(dev, 0);
1573 if (PTR_ERR(edev) != -EPROBE_DEFER)
1574 dev_err(dev, "Invalid or missing extcon\n");
1575 charger->cable_edev = NULL;
1577 charger->cable_edev = edev;
1580 edev1 = extcon_get_edev_by_phandle(dev, 1);
1581 if (IS_ERR(edev1)) {
1582 if (PTR_ERR(edev1) != -EPROBE_DEFER)
1583 dev_err(dev, "Invalid or missing extcon\n");
1584 charger->cable_edev_1 = NULL;
1586 charger->cable_edev_1 = edev1;
1588 if (!charger->pd_charge_only)
1589 bq25700_register_cg_nb(charger);
1590 bq25700_register_host_nb(charger);
1591 bq25700_register_discnt_nb(charger);
1592 bq25700_register_pd_nb(charger);
1594 if (charger->cable_edev) {
1595 schedule_delayed_work(&charger->host_work, 0);
1596 schedule_delayed_work(&charger->pd_work, 0);
1597 if (!charger->pd_charge_only)
1598 schedule_delayed_work(&charger->usb_work, 0);
1600 if (charger->cable_edev_1) {
1601 schedule_delayed_work(&charger->host_work1, 0);
1602 schedule_delayed_work(&charger->pd_work1, 0);
1603 if (!charger->pd_charge_only)
1604 schedule_delayed_work(&charger->usb_work1, 0);
1610 static int bq25700_parse_dt(struct bq25700_device *charger)
1613 struct device_node *np = charger->dev->of_node;
1615 charger->typec0_enable_io = devm_gpiod_get_optional(charger->dev,
1618 if (!IS_ERR_OR_NULL(charger->typec0_enable_io))
1619 gpiod_direction_output(charger->typec0_enable_io, 0);
1621 charger->typec1_enable_io = devm_gpiod_get_optional(charger->dev,
1624 if (!IS_ERR_OR_NULL(charger->typec1_enable_io))
1625 gpiod_direction_output(charger->typec1_enable_io, 0);
1627 charger->typec0_discharge_io =
1628 devm_gpiod_get_optional(charger->dev, "typec0-discharge",
1631 charger->typec1_discharge_io =
1632 devm_gpiod_get_optional(charger->dev, "typec1-discharge",
1635 ret = of_property_read_u32(np, "pd-charge-only",
1636 &charger->pd_charge_only);
1638 dev_err(charger->dev, "pd-charge-only!\n");
1643 static int bq25700_probe(struct i2c_client *client,
1644 const struct i2c_device_id *id)
1646 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
1647 struct device *dev = &client->dev;
1648 struct bq25700_device *charger;
1653 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
1656 charger = devm_kzalloc(&client->dev, sizeof(*charger), GFP_KERNEL);
1660 charger->client = client;
1662 charger->regmap = devm_regmap_init_i2c(client,
1663 &bq25700_regmap_config);
1665 if (IS_ERR(charger->regmap)) {
1666 dev_err(&client->dev, "Failed to initialize regmap\n");
1670 for (i = 0; i < ARRAY_SIZE(bq25700_reg_fields); i++) {
1671 const struct reg_field *reg_fields = bq25700_reg_fields;
1673 charger->rmap_fields[i] =
1674 devm_regmap_field_alloc(dev,
1677 if (IS_ERR(charger->rmap_fields[i])) {
1678 dev_err(dev, "cannot allocate regmap field\n");
1679 return PTR_ERR(charger->rmap_fields[i]);
1683 i2c_set_clientdata(client, charger);
1685 /*read chip id. Confirm whether to support the chip*/
1686 charger->chip_id = bq25700_field_read(charger, DEVICE_ID);
1688 if (charger->chip_id < 0) {
1689 dev_err(dev, "Cannot read chip ID.\n");
1690 return charger->chip_id;
1693 if (!dev->platform_data) {
1694 ret = bq25700_fw_probe(charger);
1696 dev_err(dev, "Cannot read device properties.\n");
1703 ret = bq25700_hw_init(charger);
1705 dev_err(dev, "Cannot initialize the chip.\n");
1709 bq25700_parse_dt(charger);
1711 bq25700_init_usb(charger);
1712 bq25700_init_sysfs(charger);
1714 if (client->irq < 0) {
1715 dev_err(dev, "No irq resource found.\n");
1719 if (bq25700_field_read(charger, AC_STAT))
1720 irq_flag = IRQF_TRIGGER_LOW;
1722 irq_flag = IRQF_TRIGGER_HIGH;
1724 device_init_wakeup(dev, 1);
1726 ret = devm_request_threaded_irq(dev, client->irq, NULL,
1727 bq25700_irq_handler_thread,
1728 irq_flag | IRQF_ONESHOT,
1729 "bq25700_irq", charger);
1732 enable_irq_wake(client->irq);
1734 bq25700_power_supply_init(charger);
1735 bq25700_charger = charger;
1741 void bq25700_shutdown(struct i2c_client *client)
1744 struct bq25700_device *charger = i2c_get_clientdata(client);
1746 vol_idx = bq25700_find_idx(DEFAULT_INPUTVOL, TBL_INPUTVOL);
1747 bq25700_field_write(charger, INPUT_VOLTAGE, vol_idx);
1748 bq25700_field_write(charger, INPUT_CURRENT,
1749 charger->init_data.input_current_sdp);
1752 #ifdef CONFIG_PM_SLEEP
1753 static int bq25700_pm_suspend(struct device *dev)
1758 static int bq25700_pm_resume(struct device *dev)
1764 static SIMPLE_DEV_PM_OPS(bq25700_pm_ops, bq25700_pm_suspend, bq25700_pm_resume);
1766 static const struct i2c_device_id bq25700_i2c_ids[] = {
1770 MODULE_DEVICE_TABLE(i2c, bq25700_i2c_ids);
1773 static const struct of_device_id bq25700_of_match[] = {
1774 { .compatible = "ti,bq25700", },
1777 MODULE_DEVICE_TABLE(of, bq25700_of_match);
1779 static const struct of_device_id bq25700_of_match[] = {
1784 static struct i2c_driver bq25700_driver = {
1785 .probe = bq25700_probe,
1786 .shutdown = bq25700_shutdown,
1787 .id_table = bq25700_i2c_ids,
1789 .name = "bq25700-charger",
1790 .pm = &bq25700_pm_ops,
1791 .of_match_table = of_match_ptr(bq25700_of_match),
1794 module_i2c_driver(bq25700_driver);
1796 MODULE_LICENSE("GPL");
1797 MODULE_AUTHOR("shengfeixu <xsf@rock-chips.com>");
1798 MODULE_DESCRIPTION("TI bq25700 Charger Driver");