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
28 static int dbg_enable;
29 module_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
52 enum 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
100 enum 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
110 enum 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
118 enum tpyec_port_t {
119 USB_TYPEC_0,
120 USB_TYPEC_1,
121 };
122
123 /* initial field values, converted to register values */
124 struct 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
137 struct 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
154 struct 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
203 static 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
341 static 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 */
486 enum 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
498 struct bq25700_range {
499 u32 min;
500 u32 max;
501 u32 step;
502 };
503
504 struct bq25700_lookup {
505 const u32 *tbl;
506 u32 size;
507 };
508
509 static 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
529 static const struct regmap_range bq25700_readonly_reg_ranges[] = {
530 regmap_reg_range(0x20, 0x26),
531 regmap_reg_range(0xFE, 0xFF),
532 };
533
534 static 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
539 static 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
548 static 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
553 static 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
565 static const struct regmap_range bq25703_readonly_reg_ranges[] = {
566 regmap_reg_range(0x20, 0x2F),
567 };
568
569 static 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
574 static const struct regmap_range bq25703_volatile_reg_ranges[] = {
575 regmap_reg_range(0x00, 0x0F),
576 regmap_reg_range(0x20, 0x3B),
577 };
578
579 static 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
584 static 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
596 static void bq25700_disable_charge(struct bq25700_device *charger);
597
598 static struct bq25700_device *bq25700_charger;
599
bq25700_field_read(struct bq25700_device * charger,enum bq25700_fields field_id)600 static 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
bq25700_field_write(struct bq25700_device * charger,enum bq25700_fields field_id,unsigned int val)613 static 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
bq25700_get_chip_state(struct bq25700_device * charger,struct bq25700_state * state)619 static 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
bq25700_dump_regs(struct bq25700_device * charger)655 static 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
bq25703_dump_regs(struct bq25700_device * charger)755 static 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
bq25700_charge_info_show(struct device * dev,struct device_attribute * attr,char * buf)810 static 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
823 static struct device_attribute bq25700_charger_attr[] = {
824 __ATTR(charge_info, 0664, bq25700_charge_info_show, NULL),
825 };
826
bq25700_init_sysfs(struct bq25700_device * charger)827 static 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
bq25700_find_idx(u32 value,enum bq25700_table_ids id)840 static 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
bq25700_charger_set_current(unsigned long event,int current_value)856 void 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
bq25700_fw_read_u32_props(struct bq25700_device * charger)881 static 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
bq25700_hw_init(struct bq25700_device * charger)958 static 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
bq25700_fw_probe(struct bq25700_device * charger)1079 static 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
bq25700_enable_charger(struct bq25700_device * charger,u32 input_current)1090 static 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
1097 static 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
bq25700_power_supply_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)1112 static 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
1207 static char *bq25700_charger_supplied_to[] = {
1208 "charger",
1209 };
1210
1211 static 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
bq25700_power_supply_init(struct bq25700_device * charger)1219 static 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
1235 static void bq25700_discnt(struct bq25700_device *charger, enum tpyec_port_t port);
1236
bq2570x_pd_notifier_call(struct notifier_block * nb,unsigned long val,void * v)1237 static 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
bq25700_irq_handler_thread(int irq,void * private)1300 static 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
bq25700_enable_typec0(struct bq25700_device * charger)1324 static 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
bq25700_enable_typec1(struct bq25700_device * charger)1332 static 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
bq25700_disable_charge(struct bq25700_device * charger)1340 static 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
bq25700_typec0_discharge(struct bq25700_device * charger)1348 static 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
bq25700_typec1_discharge(struct bq25700_device * charger)1357 static 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
bq25700_charger_evt_handel(struct bq25700_device * charger,struct extcon_dev * edev,enum tpyec_port_t port)1366 static 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
bq25700_charger_usb_bc_handel(struct bq25700_device * charger)1414 static 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
bq25700_charger_evt_worker(struct work_struct * work)1441 static 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
bq25700_charger_evt_worker1(struct work_struct * work)1453 static 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
bq25700_charger_evt_notifier(struct notifier_block * nb,unsigned long event,void * ptr)1462 static 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
bq25700_charger_evt_notifier1(struct notifier_block * nb,unsigned long event,void * ptr)1475 static 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
bq25700_set_otg_vbus(struct bq25700_device * charger,bool enable)1488 static 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
bq25700_host_evt_worker(struct work_struct * work)1497 static 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
bq25700_host_evt_worker1(struct work_struct * work)1509 static 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
bq25700_host_evt_notifier(struct notifier_block * nb,unsigned long event,void * ptr)1521 static 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
bq25700_host_evt_notifier1(struct notifier_block * nb,unsigned long event,void * ptr)1533 static 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
bq25700_discnt(struct bq25700_device * charger,enum tpyec_port_t port)1545 static 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
bq25700_discnt_evt_worker(struct work_struct * work)1571 static 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
bq25700_register_cg_extcon(struct bq25700_device * charger,struct extcon_dev * edev,struct notifier_block * able_cg_nb)1580 static 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
bq25700_register_cg_nb(struct bq25700_device * charger)1613 static 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
bq25700_register_pd_nb(struct bq25700_device * charger)1654 static 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
bq25700_register_host_nb(struct bq25700_device * charger)1714 static 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
bq25700_otg_vbus_enable(struct regulator_dev * dev)1751 static 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
bq25700_otg_vbus_disable(struct regulator_dev * dev)1760 static 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
bq25700_otg_vbus_is_enabled(struct regulator_dev * dev)1769 static 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
1782 static 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
1788 static 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
bq25700_register_otg_vbus_regulator(struct bq25700_device * charger)1799 static 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
bq25700_init_usb(struct bq25700_device * charger)1822 static 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
bq25700_parse_dt(struct bq25700_device * charger)1881 static 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
bq25700_probe(struct i2c_client * client,const struct i2c_device_id * id)1931 static 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
2051 irq_fail:
2052 return ret;
2053 }
2054
bq25700_shutdown(struct i2c_client * client)2055 static 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
bq25700_pm_suspend(struct device * dev)2070 static int bq25700_pm_suspend(struct device *dev)
2071 {
2072 return 0;
2073 }
2074
bq25700_pm_resume(struct device * dev)2075 static int bq25700_pm_resume(struct device *dev)
2076 {
2077 return 0;
2078 }
2079 #endif
2080
2081 static SIMPLE_DEV_PM_OPS(bq25700_pm_ops, bq25700_pm_suspend, bq25700_pm_resume);
2082
2083 static const struct i2c_device_id bq25700_i2c_ids[] = {
2084 { "bq25700"},
2085 { },
2086 };
2087 MODULE_DEVICE_TABLE(i2c, bq25700_i2c_ids);
2088
2089 #ifdef CONFIG_OF
2090 static 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 };
2097 MODULE_DEVICE_TABLE(of, bq25700_of_match);
2098 #else
2099 static const struct of_device_id bq25700_of_match[] = {
2100 { },
2101 };
2102 #endif
2103
2104 static 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 };
2114 module_i2c_driver(bq25700_driver);
2115
2116 MODULE_LICENSE("GPL");
2117 MODULE_AUTHOR("shengfeixu <xsf@rock-chips.com>");
2118 MODULE_DESCRIPTION("TI bq25700 Charger Driver");
2119