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