1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (c) 2021 MediaTek Inc. |
4 | */ |
5 | |
6 | #include <linux/devm-helpers.h> |
7 | #include <linux/init.h> |
8 | #include <linux/interrupt.h> |
9 | #include <linux/kernel.h> |
10 | #include <linux/linear_range.h> |
11 | #include <linux/module.h> |
12 | #include <linux/of.h> |
13 | #include <linux/platform_device.h> |
14 | #include <linux/power_supply.h> |
15 | #include <linux/property.h> |
16 | #include <linux/regmap.h> |
17 | #include <linux/regulator/driver.h> |
18 | |
19 | #define MT6360_PMU_CHG_CTRL1 0x311 |
20 | #define MT6360_PMU_CHG_CTRL2 0x312 |
21 | #define MT6360_PMU_CHG_CTRL3 0x313 |
22 | #define MT6360_PMU_CHG_CTRL4 0x314 |
23 | #define MT6360_PMU_CHG_CTRL5 0x315 |
24 | #define MT6360_PMU_CHG_CTRL6 0x316 |
25 | #define MT6360_PMU_CHG_CTRL7 0x317 |
26 | #define MT6360_PMU_CHG_CTRL8 0x318 |
27 | #define MT6360_PMU_CHG_CTRL9 0x319 |
28 | #define MT6360_PMU_CHG_CTRL10 0x31A |
29 | #define MT6360_PMU_DEVICE_TYPE 0x322 |
30 | #define MT6360_PMU_USB_STATUS1 0x327 |
31 | #define MT6360_PMU_CHG_STAT 0x34A |
32 | #define MT6360_PMU_CHG_CTRL19 0x361 |
33 | #define MT6360_PMU_FOD_STAT 0x3E7 |
34 | |
35 | /* MT6360_PMU_CHG_CTRL1 */ |
36 | #define MT6360_FSLP_SHFT (3) |
37 | #define MT6360_FSLP_MASK BIT(MT6360_FSLP_SHFT) |
38 | #define MT6360_OPA_MODE_SHFT (0) |
39 | #define MT6360_OPA_MODE_MASK BIT(MT6360_OPA_MODE_SHFT) |
40 | /* MT6360_PMU_CHG_CTRL2 */ |
41 | #define MT6360_IINLMTSEL_SHFT (2) |
42 | #define MT6360_IINLMTSEL_MASK GENMASK(3, 2) |
43 | /* MT6360_PMU_CHG_CTRL3 */ |
44 | #define MT6360_IAICR_SHFT (2) |
45 | #define MT6360_IAICR_MASK GENMASK(7, 2) |
46 | #define MT6360_ILIM_EN_MASK BIT(0) |
47 | /* MT6360_PMU_CHG_CTRL4 */ |
48 | #define MT6360_VOREG_SHFT (1) |
49 | #define MT6360_VOREG_MASK GENMASK(7, 1) |
50 | /* MT6360_PMU_CHG_CTRL5 */ |
51 | #define MT6360_VOBST_MASK GENMASK(7, 2) |
52 | /* MT6360_PMU_CHG_CTRL6 */ |
53 | #define MT6360_VMIVR_SHFT (1) |
54 | #define MT6360_VMIVR_MASK GENMASK(7, 1) |
55 | /* MT6360_PMU_CHG_CTRL7 */ |
56 | #define MT6360_ICHG_SHFT (2) |
57 | #define MT6360_ICHG_MASK GENMASK(7, 2) |
58 | /* MT6360_PMU_CHG_CTRL8 */ |
59 | #define MT6360_IPREC_SHFT (0) |
60 | #define MT6360_IPREC_MASK GENMASK(3, 0) |
61 | /* MT6360_PMU_CHG_CTRL9 */ |
62 | #define MT6360_IEOC_SHFT (4) |
63 | #define MT6360_IEOC_MASK GENMASK(7, 4) |
64 | /* MT6360_PMU_CHG_CTRL10 */ |
65 | #define MT6360_OTG_OC_MASK GENMASK(3, 0) |
66 | /* MT6360_PMU_DEVICE_TYPE */ |
67 | #define MT6360_USBCHGEN_MASK BIT(7) |
68 | /* MT6360_PMU_USB_STATUS1 */ |
69 | #define MT6360_USB_STATUS_SHFT (4) |
70 | #define MT6360_USB_STATUS_MASK GENMASK(6, 4) |
71 | /* MT6360_PMU_CHG_STAT */ |
72 | #define MT6360_CHG_STAT_SHFT (6) |
73 | #define MT6360_CHG_STAT_MASK GENMASK(7, 6) |
74 | #define MT6360_VBAT_LVL_MASK BIT(5) |
75 | /* MT6360_PMU_CHG_CTRL19 */ |
76 | #define MT6360_VINOVP_SHFT (5) |
77 | #define MT6360_VINOVP_MASK GENMASK(6, 5) |
78 | /* MT6360_PMU_FOD_STAT */ |
79 | #define MT6360_CHRDET_EXT_MASK BIT(4) |
80 | |
81 | /* uV */ |
82 | #define MT6360_VMIVR_MIN 3900000 |
83 | #define MT6360_VMIVR_MAX 13400000 |
84 | #define MT6360_VMIVR_STEP 100000 |
85 | /* uA */ |
86 | #define MT6360_ICHG_MIN 100000 |
87 | #define MT6360_ICHG_MAX 5000000 |
88 | #define MT6360_ICHG_STEP 100000 |
89 | /* uV */ |
90 | #define MT6360_VOREG_MIN 3900000 |
91 | #define MT6360_VOREG_MAX 4710000 |
92 | #define MT6360_VOREG_STEP 10000 |
93 | /* uA */ |
94 | #define MT6360_AICR_MIN 100000 |
95 | #define MT6360_AICR_MAX 3250000 |
96 | #define MT6360_AICR_STEP 50000 |
97 | /* uA */ |
98 | #define MT6360_IPREC_MIN 100000 |
99 | #define MT6360_IPREC_MAX 850000 |
100 | #define MT6360_IPREC_STEP 50000 |
101 | /* uA */ |
102 | #define MT6360_IEOC_MIN 100000 |
103 | #define MT6360_IEOC_MAX 850000 |
104 | #define MT6360_IEOC_STEP 50000 |
105 | |
106 | enum { |
107 | MT6360_RANGE_VMIVR, |
108 | MT6360_RANGE_ICHG, |
109 | MT6360_RANGE_VOREG, |
110 | MT6360_RANGE_AICR, |
111 | MT6360_RANGE_IPREC, |
112 | MT6360_RANGE_IEOC, |
113 | MT6360_RANGE_MAX, |
114 | }; |
115 | |
116 | static const struct linear_range mt6360_chg_range[MT6360_RANGE_MAX] = { |
117 | LINEAR_RANGE_IDX(MT6360_RANGE_VMIVR, 3900000, 0, 0x5F, 100000), |
118 | LINEAR_RANGE_IDX(MT6360_RANGE_ICHG, 100000, 0, 0x31, 100000), |
119 | LINEAR_RANGE_IDX(MT6360_RANGE_VOREG, 3900000, 0, 0x51, 10000), |
120 | LINEAR_RANGE_IDX(MT6360_RANGE_AICR, 100000, 0, 0x3F, 50000), |
121 | LINEAR_RANGE_IDX(MT6360_RANGE_IPREC, 100000, 0, 0x0F, 50000), |
122 | LINEAR_RANGE_IDX(MT6360_RANGE_IEOC, 100000, 0, 0x0F, 50000), |
123 | }; |
124 | |
125 | struct mt6360_chg_info { |
126 | struct device *dev; |
127 | struct regmap *regmap; |
128 | struct power_supply_desc psy_desc; |
129 | struct power_supply *psy; |
130 | struct regulator_dev *otg_rdev; |
131 | struct mutex chgdet_lock; |
132 | u32 vinovp; |
133 | bool pwr_rdy; |
134 | bool bc12_en; |
135 | int psy_usb_type; |
136 | struct work_struct chrdet_work; |
137 | }; |
138 | |
139 | enum mt6360_iinlmtsel { |
140 | MT6360_IINLMTSEL_AICR_3250 = 0, |
141 | MT6360_IINLMTSEL_CHG_TYPE, |
142 | MT6360_IINLMTSEL_AICR, |
143 | MT6360_IINLMTSEL_LOWER_LEVEL, |
144 | }; |
145 | |
146 | enum mt6360_pmu_chg_type { |
147 | MT6360_CHG_TYPE_NOVBUS = 0, |
148 | MT6360_CHG_TYPE_UNDER_GOING, |
149 | MT6360_CHG_TYPE_SDP, |
150 | MT6360_CHG_TYPE_SDPNSTD, |
151 | MT6360_CHG_TYPE_DCP, |
152 | MT6360_CHG_TYPE_CDP, |
153 | MT6360_CHG_TYPE_DISABLE_BC12, |
154 | MT6360_CHG_TYPE_MAX, |
155 | }; |
156 | |
157 | static enum power_supply_usb_type mt6360_charger_usb_types[] = { |
158 | POWER_SUPPLY_USB_TYPE_UNKNOWN, |
159 | POWER_SUPPLY_USB_TYPE_SDP, |
160 | POWER_SUPPLY_USB_TYPE_DCP, |
161 | POWER_SUPPLY_USB_TYPE_CDP, |
162 | }; |
163 | |
164 | static int mt6360_get_chrdet_ext_stat(struct mt6360_chg_info *mci, |
165 | bool *pwr_rdy) |
166 | { |
167 | int ret; |
168 | unsigned int regval; |
169 | |
170 | ret = regmap_read(map: mci->regmap, MT6360_PMU_FOD_STAT, val: ®val); |
171 | if (ret < 0) |
172 | return ret; |
173 | *pwr_rdy = (regval & MT6360_CHRDET_EXT_MASK) ? true : false; |
174 | return 0; |
175 | } |
176 | |
177 | static int mt6360_charger_get_online(struct mt6360_chg_info *mci, |
178 | union power_supply_propval *val) |
179 | { |
180 | int ret; |
181 | bool pwr_rdy; |
182 | |
183 | ret = mt6360_get_chrdet_ext_stat(mci, pwr_rdy: &pwr_rdy); |
184 | if (ret < 0) |
185 | return ret; |
186 | val->intval = pwr_rdy ? true : false; |
187 | return 0; |
188 | } |
189 | |
190 | static int mt6360_charger_get_status(struct mt6360_chg_info *mci, |
191 | union power_supply_propval *val) |
192 | { |
193 | int status, ret; |
194 | unsigned int regval; |
195 | bool pwr_rdy; |
196 | |
197 | ret = mt6360_get_chrdet_ext_stat(mci, pwr_rdy: &pwr_rdy); |
198 | if (ret < 0) |
199 | return ret; |
200 | if (!pwr_rdy) { |
201 | status = POWER_SUPPLY_STATUS_DISCHARGING; |
202 | goto out; |
203 | } |
204 | |
205 | ret = regmap_read(map: mci->regmap, MT6360_PMU_CHG_STAT, val: ®val); |
206 | if (ret < 0) |
207 | return ret; |
208 | regval &= MT6360_CHG_STAT_MASK; |
209 | regval >>= MT6360_CHG_STAT_SHFT; |
210 | switch (regval) { |
211 | case 0x0: |
212 | status = POWER_SUPPLY_STATUS_NOT_CHARGING; |
213 | break; |
214 | case 0x1: |
215 | status = POWER_SUPPLY_STATUS_CHARGING; |
216 | break; |
217 | case 0x2: |
218 | status = POWER_SUPPLY_STATUS_FULL; |
219 | break; |
220 | default: |
221 | ret = -EIO; |
222 | } |
223 | out: |
224 | if (!ret) |
225 | val->intval = status; |
226 | return ret; |
227 | } |
228 | |
229 | static int mt6360_charger_get_charge_type(struct mt6360_chg_info *mci, |
230 | union power_supply_propval *val) |
231 | { |
232 | int type, ret; |
233 | unsigned int regval; |
234 | u8 chg_stat; |
235 | |
236 | ret = regmap_read(map: mci->regmap, MT6360_PMU_CHG_STAT, val: ®val); |
237 | if (ret < 0) |
238 | return ret; |
239 | |
240 | chg_stat = (regval & MT6360_CHG_STAT_MASK) >> MT6360_CHG_STAT_SHFT; |
241 | switch (chg_stat) { |
242 | case 0x01: /* Charge in Progress */ |
243 | if (regval & MT6360_VBAT_LVL_MASK) |
244 | type = POWER_SUPPLY_CHARGE_TYPE_FAST; |
245 | else |
246 | type = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; |
247 | break; |
248 | case 0x00: /* Not Charging */ |
249 | case 0x02: /* Charge Done */ |
250 | case 0x03: /* Charge Fault */ |
251 | default: |
252 | type = POWER_SUPPLY_CHARGE_TYPE_NONE; |
253 | break; |
254 | } |
255 | |
256 | val->intval = type; |
257 | return 0; |
258 | } |
259 | |
260 | static int mt6360_charger_get_ichg(struct mt6360_chg_info *mci, |
261 | union power_supply_propval *val) |
262 | { |
263 | int ret; |
264 | u32 sel, value; |
265 | |
266 | ret = regmap_read(map: mci->regmap, MT6360_PMU_CHG_CTRL7, val: &sel); |
267 | if (ret < 0) |
268 | return ret; |
269 | sel = (sel & MT6360_ICHG_MASK) >> MT6360_ICHG_SHFT; |
270 | ret = linear_range_get_value(r: &mt6360_chg_range[MT6360_RANGE_ICHG], selector: sel, val: &value); |
271 | if (!ret) |
272 | val->intval = value; |
273 | return ret; |
274 | } |
275 | |
276 | static int mt6360_charger_get_max_ichg(struct mt6360_chg_info *mci, |
277 | union power_supply_propval *val) |
278 | { |
279 | val->intval = MT6360_ICHG_MAX; |
280 | return 0; |
281 | } |
282 | |
283 | static int mt6360_charger_get_cv(struct mt6360_chg_info *mci, |
284 | union power_supply_propval *val) |
285 | { |
286 | int ret; |
287 | u32 sel, value; |
288 | |
289 | ret = regmap_read(map: mci->regmap, MT6360_PMU_CHG_CTRL4, val: &sel); |
290 | if (ret < 0) |
291 | return ret; |
292 | sel = (sel & MT6360_VOREG_MASK) >> MT6360_VOREG_SHFT; |
293 | ret = linear_range_get_value(r: &mt6360_chg_range[MT6360_RANGE_VOREG], selector: sel, val: &value); |
294 | if (!ret) |
295 | val->intval = value; |
296 | return ret; |
297 | } |
298 | |
299 | static int mt6360_charger_get_max_cv(struct mt6360_chg_info *mci, |
300 | union power_supply_propval *val) |
301 | { |
302 | val->intval = MT6360_VOREG_MAX; |
303 | return 0; |
304 | } |
305 | |
306 | static int mt6360_charger_get_aicr(struct mt6360_chg_info *mci, |
307 | union power_supply_propval *val) |
308 | { |
309 | int ret; |
310 | u32 sel, value; |
311 | |
312 | ret = regmap_read(map: mci->regmap, MT6360_PMU_CHG_CTRL3, val: &sel); |
313 | if (ret < 0) |
314 | return ret; |
315 | sel = (sel & MT6360_IAICR_MASK) >> MT6360_IAICR_SHFT; |
316 | ret = linear_range_get_value(r: &mt6360_chg_range[MT6360_RANGE_AICR], selector: sel, val: &value); |
317 | if (!ret) |
318 | val->intval = value; |
319 | return ret; |
320 | } |
321 | |
322 | static int mt6360_charger_get_mivr(struct mt6360_chg_info *mci, |
323 | union power_supply_propval *val) |
324 | { |
325 | int ret; |
326 | u32 sel, value; |
327 | |
328 | ret = regmap_read(map: mci->regmap, MT6360_PMU_CHG_CTRL6, val: &sel); |
329 | if (ret < 0) |
330 | return ret; |
331 | sel = (sel & MT6360_VMIVR_MASK) >> MT6360_VMIVR_SHFT; |
332 | ret = linear_range_get_value(r: &mt6360_chg_range[MT6360_RANGE_VMIVR], selector: sel, val: &value); |
333 | if (!ret) |
334 | val->intval = value; |
335 | return ret; |
336 | } |
337 | |
338 | static int mt6360_charger_get_iprechg(struct mt6360_chg_info *mci, |
339 | union power_supply_propval *val) |
340 | { |
341 | int ret; |
342 | u32 sel, value; |
343 | |
344 | ret = regmap_read(map: mci->regmap, MT6360_PMU_CHG_CTRL8, val: &sel); |
345 | if (ret < 0) |
346 | return ret; |
347 | sel = (sel & MT6360_IPREC_MASK) >> MT6360_IPREC_SHFT; |
348 | ret = linear_range_get_value(r: &mt6360_chg_range[MT6360_RANGE_IPREC], selector: sel, val: &value); |
349 | if (!ret) |
350 | val->intval = value; |
351 | return ret; |
352 | } |
353 | |
354 | static int mt6360_charger_get_ieoc(struct mt6360_chg_info *mci, |
355 | union power_supply_propval *val) |
356 | { |
357 | int ret; |
358 | u32 sel, value; |
359 | |
360 | ret = regmap_read(map: mci->regmap, MT6360_PMU_CHG_CTRL9, val: &sel); |
361 | if (ret < 0) |
362 | return ret; |
363 | sel = (sel & MT6360_IEOC_MASK) >> MT6360_IEOC_SHFT; |
364 | ret = linear_range_get_value(r: &mt6360_chg_range[MT6360_RANGE_IEOC], selector: sel, val: &value); |
365 | if (!ret) |
366 | val->intval = value; |
367 | return ret; |
368 | } |
369 | |
370 | static int mt6360_charger_set_online(struct mt6360_chg_info *mci, |
371 | const union power_supply_propval *val) |
372 | { |
373 | u8 force_sleep = val->intval ? 0 : 1; |
374 | |
375 | return regmap_update_bits(map: mci->regmap, |
376 | MT6360_PMU_CHG_CTRL1, |
377 | MT6360_FSLP_MASK, |
378 | val: force_sleep << MT6360_FSLP_SHFT); |
379 | } |
380 | |
381 | static int mt6360_charger_set_ichg(struct mt6360_chg_info *mci, |
382 | const union power_supply_propval *val) |
383 | { |
384 | u32 sel; |
385 | |
386 | linear_range_get_selector_within(r: &mt6360_chg_range[MT6360_RANGE_ICHG], val: val->intval, selector: &sel); |
387 | return regmap_update_bits(map: mci->regmap, |
388 | MT6360_PMU_CHG_CTRL7, |
389 | MT6360_ICHG_MASK, |
390 | val: sel << MT6360_ICHG_SHFT); |
391 | } |
392 | |
393 | static int mt6360_charger_set_cv(struct mt6360_chg_info *mci, |
394 | const union power_supply_propval *val) |
395 | { |
396 | u32 sel; |
397 | |
398 | linear_range_get_selector_within(r: &mt6360_chg_range[MT6360_RANGE_VOREG], val: val->intval, selector: &sel); |
399 | return regmap_update_bits(map: mci->regmap, |
400 | MT6360_PMU_CHG_CTRL4, |
401 | MT6360_VOREG_MASK, |
402 | val: sel << MT6360_VOREG_SHFT); |
403 | } |
404 | |
405 | static int mt6360_charger_set_aicr(struct mt6360_chg_info *mci, |
406 | const union power_supply_propval *val) |
407 | { |
408 | u32 sel; |
409 | |
410 | linear_range_get_selector_within(r: &mt6360_chg_range[MT6360_RANGE_AICR], val: val->intval, selector: &sel); |
411 | return regmap_update_bits(map: mci->regmap, |
412 | MT6360_PMU_CHG_CTRL3, |
413 | MT6360_IAICR_MASK, |
414 | val: sel << MT6360_IAICR_SHFT); |
415 | } |
416 | |
417 | static int mt6360_charger_set_mivr(struct mt6360_chg_info *mci, |
418 | const union power_supply_propval *val) |
419 | { |
420 | u32 sel; |
421 | |
422 | linear_range_get_selector_within(r: &mt6360_chg_range[MT6360_RANGE_VMIVR], val: val->intval, selector: &sel); |
423 | return regmap_update_bits(map: mci->regmap, |
424 | MT6360_PMU_CHG_CTRL3, |
425 | MT6360_VMIVR_MASK, |
426 | val: sel << MT6360_VMIVR_SHFT); |
427 | } |
428 | |
429 | static int mt6360_charger_set_iprechg(struct mt6360_chg_info *mci, |
430 | const union power_supply_propval *val) |
431 | { |
432 | u32 sel; |
433 | |
434 | linear_range_get_selector_within(r: &mt6360_chg_range[MT6360_RANGE_IPREC], val: val->intval, selector: &sel); |
435 | return regmap_update_bits(map: mci->regmap, |
436 | MT6360_PMU_CHG_CTRL8, |
437 | MT6360_IPREC_MASK, |
438 | val: sel << MT6360_IPREC_SHFT); |
439 | } |
440 | |
441 | static int mt6360_charger_set_ieoc(struct mt6360_chg_info *mci, |
442 | const union power_supply_propval *val) |
443 | { |
444 | u32 sel; |
445 | |
446 | linear_range_get_selector_within(r: &mt6360_chg_range[MT6360_RANGE_IEOC], val: val->intval, selector: &sel); |
447 | return regmap_update_bits(map: mci->regmap, |
448 | MT6360_PMU_CHG_CTRL9, |
449 | MT6360_IEOC_MASK, |
450 | val: sel << MT6360_IEOC_SHFT); |
451 | } |
452 | |
453 | static int mt6360_charger_get_property(struct power_supply *psy, |
454 | enum power_supply_property psp, |
455 | union power_supply_propval *val) |
456 | { |
457 | struct mt6360_chg_info *mci = power_supply_get_drvdata(psy); |
458 | int ret = 0; |
459 | |
460 | switch (psp) { |
461 | case POWER_SUPPLY_PROP_ONLINE: |
462 | ret = mt6360_charger_get_online(mci, val); |
463 | break; |
464 | case POWER_SUPPLY_PROP_STATUS: |
465 | ret = mt6360_charger_get_status(mci, val); |
466 | break; |
467 | case POWER_SUPPLY_PROP_CHARGE_TYPE: |
468 | ret = mt6360_charger_get_charge_type(mci, val); |
469 | break; |
470 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: |
471 | ret = mt6360_charger_get_ichg(mci, val); |
472 | break; |
473 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: |
474 | ret = mt6360_charger_get_max_ichg(mci, val); |
475 | break; |
476 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: |
477 | ret = mt6360_charger_get_cv(mci, val); |
478 | break; |
479 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: |
480 | ret = mt6360_charger_get_max_cv(mci, val); |
481 | break; |
482 | case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: |
483 | ret = mt6360_charger_get_aicr(mci, val); |
484 | break; |
485 | case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT: |
486 | ret = mt6360_charger_get_mivr(mci, val); |
487 | break; |
488 | case POWER_SUPPLY_PROP_PRECHARGE_CURRENT: |
489 | ret = mt6360_charger_get_iprechg(mci, val); |
490 | break; |
491 | case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: |
492 | ret = mt6360_charger_get_ieoc(mci, val); |
493 | break; |
494 | case POWER_SUPPLY_PROP_USB_TYPE: |
495 | val->intval = mci->psy_usb_type; |
496 | break; |
497 | default: |
498 | ret = -ENODATA; |
499 | } |
500 | return ret; |
501 | } |
502 | |
503 | static int mt6360_charger_set_property(struct power_supply *psy, |
504 | enum power_supply_property psp, |
505 | const union power_supply_propval *val) |
506 | { |
507 | struct mt6360_chg_info *mci = power_supply_get_drvdata(psy); |
508 | int ret; |
509 | |
510 | switch (psp) { |
511 | case POWER_SUPPLY_PROP_ONLINE: |
512 | ret = mt6360_charger_set_online(mci, val); |
513 | break; |
514 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: |
515 | ret = mt6360_charger_set_ichg(mci, val); |
516 | break; |
517 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: |
518 | ret = mt6360_charger_set_cv(mci, val); |
519 | break; |
520 | case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: |
521 | ret = mt6360_charger_set_aicr(mci, val); |
522 | break; |
523 | case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT: |
524 | ret = mt6360_charger_set_mivr(mci, val); |
525 | break; |
526 | case POWER_SUPPLY_PROP_PRECHARGE_CURRENT: |
527 | ret = mt6360_charger_set_iprechg(mci, val); |
528 | break; |
529 | case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: |
530 | ret = mt6360_charger_set_ieoc(mci, val); |
531 | break; |
532 | default: |
533 | ret = -EINVAL; |
534 | } |
535 | return ret; |
536 | } |
537 | |
538 | static int mt6360_charger_property_is_writeable(struct power_supply *psy, |
539 | enum power_supply_property psp) |
540 | { |
541 | switch (psp) { |
542 | case POWER_SUPPLY_PROP_ONLINE: |
543 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT: |
544 | case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE: |
545 | case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: |
546 | case POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT: |
547 | case POWER_SUPPLY_PROP_PRECHARGE_CURRENT: |
548 | case POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT: |
549 | return 1; |
550 | default: |
551 | return 0; |
552 | } |
553 | } |
554 | |
555 | static enum power_supply_property mt6360_charger_properties[] = { |
556 | POWER_SUPPLY_PROP_ONLINE, |
557 | POWER_SUPPLY_PROP_STATUS, |
558 | POWER_SUPPLY_PROP_CHARGE_TYPE, |
559 | POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT, |
560 | POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, |
561 | POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE, |
562 | POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, |
563 | POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, |
564 | POWER_SUPPLY_PROP_INPUT_VOLTAGE_LIMIT, |
565 | POWER_SUPPLY_PROP_PRECHARGE_CURRENT, |
566 | POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT, |
567 | POWER_SUPPLY_PROP_USB_TYPE, |
568 | }; |
569 | |
570 | static const struct power_supply_desc mt6360_charger_desc = { |
571 | .type = POWER_SUPPLY_TYPE_USB, |
572 | .properties = mt6360_charger_properties, |
573 | .num_properties = ARRAY_SIZE(mt6360_charger_properties), |
574 | .get_property = mt6360_charger_get_property, |
575 | .set_property = mt6360_charger_set_property, |
576 | .property_is_writeable = mt6360_charger_property_is_writeable, |
577 | .usb_types = mt6360_charger_usb_types, |
578 | .num_usb_types = ARRAY_SIZE(mt6360_charger_usb_types), |
579 | }; |
580 | |
581 | static const struct regulator_ops mt6360_chg_otg_ops = { |
582 | .list_voltage = regulator_list_voltage_linear, |
583 | .enable = regulator_enable_regmap, |
584 | .disable = regulator_disable_regmap, |
585 | .is_enabled = regulator_is_enabled_regmap, |
586 | .set_voltage_sel = regulator_set_voltage_sel_regmap, |
587 | .get_voltage_sel = regulator_get_voltage_sel_regmap, |
588 | }; |
589 | |
590 | static const struct regulator_desc mt6360_otg_rdesc = { |
591 | .of_match = "usb-otg-vbus" , |
592 | .name = "usb-otg-vbus" , |
593 | .ops = &mt6360_chg_otg_ops, |
594 | .owner = THIS_MODULE, |
595 | .type = REGULATOR_VOLTAGE, |
596 | .min_uV = 4425000, |
597 | .uV_step = 25000, |
598 | .n_voltages = 57, |
599 | .vsel_reg = MT6360_PMU_CHG_CTRL5, |
600 | .vsel_mask = MT6360_VOBST_MASK, |
601 | .enable_reg = MT6360_PMU_CHG_CTRL1, |
602 | .enable_mask = MT6360_OPA_MODE_MASK, |
603 | }; |
604 | |
605 | static irqreturn_t mt6360_pmu_attach_i_handler(int irq, void *data) |
606 | { |
607 | struct mt6360_chg_info *mci = data; |
608 | int ret; |
609 | unsigned int usb_status; |
610 | int last_usb_type; |
611 | |
612 | mutex_lock(&mci->chgdet_lock); |
613 | if (!mci->bc12_en) { |
614 | dev_warn(mci->dev, "Received attach interrupt, bc12 disabled, ignore irq\n" ); |
615 | goto out; |
616 | } |
617 | last_usb_type = mci->psy_usb_type; |
618 | /* Plug in */ |
619 | ret = regmap_read(map: mci->regmap, MT6360_PMU_USB_STATUS1, val: &usb_status); |
620 | if (ret < 0) |
621 | goto out; |
622 | usb_status &= MT6360_USB_STATUS_MASK; |
623 | usb_status >>= MT6360_USB_STATUS_SHFT; |
624 | switch (usb_status) { |
625 | case MT6360_CHG_TYPE_NOVBUS: |
626 | dev_dbg(mci->dev, "Received attach interrupt, no vbus\n" ); |
627 | goto out; |
628 | case MT6360_CHG_TYPE_UNDER_GOING: |
629 | dev_dbg(mci->dev, "Received attach interrupt, under going...\n" ); |
630 | goto out; |
631 | case MT6360_CHG_TYPE_SDP: |
632 | mci->psy_usb_type = POWER_SUPPLY_USB_TYPE_SDP; |
633 | break; |
634 | case MT6360_CHG_TYPE_SDPNSTD: |
635 | mci->psy_usb_type = POWER_SUPPLY_USB_TYPE_SDP; |
636 | break; |
637 | case MT6360_CHG_TYPE_CDP: |
638 | mci->psy_usb_type = POWER_SUPPLY_USB_TYPE_CDP; |
639 | break; |
640 | case MT6360_CHG_TYPE_DCP: |
641 | mci->psy_usb_type = POWER_SUPPLY_USB_TYPE_DCP; |
642 | break; |
643 | case MT6360_CHG_TYPE_DISABLE_BC12: |
644 | dev_dbg(mci->dev, "Received attach interrupt, bc12 detect not enable\n" ); |
645 | goto out; |
646 | default: |
647 | mci->psy_usb_type = POWER_SUPPLY_USB_TYPE_UNKNOWN; |
648 | dev_dbg(mci->dev, "Received attach interrupt, reserved address\n" ); |
649 | goto out; |
650 | } |
651 | |
652 | dev_dbg(mci->dev, "Received attach interrupt, chg_type = %d\n" , mci->psy_usb_type); |
653 | if (last_usb_type != mci->psy_usb_type) |
654 | power_supply_changed(psy: mci->psy); |
655 | out: |
656 | mutex_unlock(lock: &mci->chgdet_lock); |
657 | return IRQ_HANDLED; |
658 | } |
659 | |
660 | static void mt6360_handle_chrdet_ext_evt(struct mt6360_chg_info *mci) |
661 | { |
662 | int ret; |
663 | bool pwr_rdy; |
664 | |
665 | mutex_lock(&mci->chgdet_lock); |
666 | ret = mt6360_get_chrdet_ext_stat(mci, pwr_rdy: &pwr_rdy); |
667 | if (ret < 0) |
668 | goto out; |
669 | if (mci->pwr_rdy == pwr_rdy) { |
670 | dev_dbg(mci->dev, "Received vbus interrupt, pwr_rdy is same(%d)\n" , pwr_rdy); |
671 | goto out; |
672 | } |
673 | mci->pwr_rdy = pwr_rdy; |
674 | dev_dbg(mci->dev, "Received vbus interrupt, pwr_rdy = %d\n" , pwr_rdy); |
675 | if (!pwr_rdy) { |
676 | mci->psy_usb_type = POWER_SUPPLY_USB_TYPE_UNKNOWN; |
677 | power_supply_changed(psy: mci->psy); |
678 | |
679 | } |
680 | ret = regmap_update_bits(map: mci->regmap, |
681 | MT6360_PMU_DEVICE_TYPE, |
682 | MT6360_USBCHGEN_MASK, |
683 | val: pwr_rdy ? MT6360_USBCHGEN_MASK : 0); |
684 | if (ret < 0) |
685 | goto out; |
686 | mci->bc12_en = pwr_rdy; |
687 | out: |
688 | mutex_unlock(lock: &mci->chgdet_lock); |
689 | } |
690 | |
691 | static void mt6360_chrdet_work(struct work_struct *work) |
692 | { |
693 | struct mt6360_chg_info *mci = (struct mt6360_chg_info *)container_of( |
694 | work, struct mt6360_chg_info, chrdet_work); |
695 | |
696 | mt6360_handle_chrdet_ext_evt(mci); |
697 | } |
698 | |
699 | static irqreturn_t mt6360_pmu_chrdet_ext_evt_handler(int irq, void *data) |
700 | { |
701 | struct mt6360_chg_info *mci = data; |
702 | |
703 | mt6360_handle_chrdet_ext_evt(mci); |
704 | return IRQ_HANDLED; |
705 | } |
706 | |
707 | static int mt6360_chg_irq_register(struct platform_device *pdev) |
708 | { |
709 | const struct { |
710 | const char *name; |
711 | irq_handler_t handler; |
712 | } irq_descs[] = { |
713 | { "attach_i" , mt6360_pmu_attach_i_handler }, |
714 | { "chrdet_ext_evt" , mt6360_pmu_chrdet_ext_evt_handler } |
715 | }; |
716 | int i, ret; |
717 | |
718 | for (i = 0; i < ARRAY_SIZE(irq_descs); i++) { |
719 | ret = platform_get_irq_byname(pdev, irq_descs[i].name); |
720 | if (ret < 0) |
721 | return ret; |
722 | |
723 | ret = devm_request_threaded_irq(dev: &pdev->dev, irq: ret, NULL, |
724 | thread_fn: irq_descs[i].handler, |
725 | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, |
726 | devname: irq_descs[i].name, |
727 | dev_id: platform_get_drvdata(pdev)); |
728 | if (ret < 0) |
729 | return dev_err_probe(dev: &pdev->dev, err: ret, fmt: "Failed to request %s irq\n" , |
730 | irq_descs[i].name); |
731 | } |
732 | |
733 | return 0; |
734 | } |
735 | |
736 | static u32 mt6360_vinovp_trans_to_sel(u32 val) |
737 | { |
738 | u32 vinovp_tbl[] = { 5500000, 6500000, 11000000, 14500000 }; |
739 | int i; |
740 | |
741 | /* Select the smaller and equal supported value */ |
742 | for (i = 0; i < ARRAY_SIZE(vinovp_tbl)-1; i++) { |
743 | if (val < vinovp_tbl[i+1]) |
744 | break; |
745 | } |
746 | return i; |
747 | } |
748 | |
749 | static int mt6360_chg_init_setting(struct mt6360_chg_info *mci) |
750 | { |
751 | int ret; |
752 | u32 sel; |
753 | |
754 | sel = mt6360_vinovp_trans_to_sel(val: mci->vinovp); |
755 | ret = regmap_update_bits(map: mci->regmap, MT6360_PMU_CHG_CTRL19, |
756 | MT6360_VINOVP_MASK, val: sel << MT6360_VINOVP_SHFT); |
757 | if (ret) |
758 | return dev_err_probe(dev: mci->dev, err: ret, fmt: "%s: Failed to apply vinovp\n" , __func__); |
759 | ret = regmap_update_bits(map: mci->regmap, MT6360_PMU_DEVICE_TYPE, |
760 | MT6360_USBCHGEN_MASK, val: 0); |
761 | if (ret) |
762 | return dev_err_probe(dev: mci->dev, err: ret, fmt: "%s: Failed to disable bc12\n" , __func__); |
763 | ret = regmap_update_bits(map: mci->regmap, MT6360_PMU_CHG_CTRL2, |
764 | MT6360_IINLMTSEL_MASK, |
765 | val: MT6360_IINLMTSEL_AICR << |
766 | MT6360_IINLMTSEL_SHFT); |
767 | if (ret) |
768 | return dev_err_probe(dev: mci->dev, err: ret, |
769 | fmt: "%s: Failed to switch iinlmtsel to aicr\n" , __func__); |
770 | usleep_range(min: 5000, max: 6000); |
771 | ret = regmap_update_bits(map: mci->regmap, MT6360_PMU_CHG_CTRL3, |
772 | MT6360_ILIM_EN_MASK, val: 0); |
773 | if (ret) |
774 | return dev_err_probe(dev: mci->dev, err: ret, |
775 | fmt: "%s: Failed to disable ilim\n" , __func__); |
776 | ret = regmap_update_bits(map: mci->regmap, MT6360_PMU_CHG_CTRL10, |
777 | MT6360_OTG_OC_MASK, MT6360_OTG_OC_MASK); |
778 | if (ret) |
779 | return dev_err_probe(dev: mci->dev, err: ret, |
780 | fmt: "%s: Failed to config otg oc to 3A\n" , __func__); |
781 | return 0; |
782 | } |
783 | |
784 | static int mt6360_charger_probe(struct platform_device *pdev) |
785 | { |
786 | struct mt6360_chg_info *mci; |
787 | struct power_supply_config charger_cfg = {}; |
788 | struct regulator_config config = { }; |
789 | int ret; |
790 | |
791 | mci = devm_kzalloc(dev: &pdev->dev, size: sizeof(*mci), GFP_KERNEL); |
792 | if (!mci) |
793 | return -ENOMEM; |
794 | |
795 | mci->dev = &pdev->dev; |
796 | mci->vinovp = 6500000; |
797 | mutex_init(&mci->chgdet_lock); |
798 | platform_set_drvdata(pdev, data: mci); |
799 | ret = devm_work_autocancel(dev: &pdev->dev, w: &mci->chrdet_work, worker: mt6360_chrdet_work); |
800 | if (ret) |
801 | return dev_err_probe(dev: &pdev->dev, err: ret, fmt: "Failed to set delayed work\n" ); |
802 | |
803 | ret = device_property_read_u32(dev: &pdev->dev, propname: "richtek,vinovp-microvolt" , val: &mci->vinovp); |
804 | if (ret) |
805 | dev_warn(&pdev->dev, "Failed to parse vinovp in DT, keep default 6.5v\n" ); |
806 | |
807 | mci->regmap = dev_get_regmap(dev: pdev->dev.parent, NULL); |
808 | if (!mci->regmap) |
809 | return dev_err_probe(dev: &pdev->dev, err: -ENODEV, fmt: "Failed to get parent regmap\n" ); |
810 | |
811 | ret = mt6360_chg_init_setting(mci); |
812 | if (ret) |
813 | return dev_err_probe(dev: &pdev->dev, err: ret, fmt: "Failed to initial setting\n" ); |
814 | |
815 | memcpy(&mci->psy_desc, &mt6360_charger_desc, sizeof(mci->psy_desc)); |
816 | mci->psy_desc.name = dev_name(dev: &pdev->dev); |
817 | charger_cfg.drv_data = mci; |
818 | charger_cfg.of_node = pdev->dev.of_node; |
819 | mci->psy = devm_power_supply_register(parent: &pdev->dev, |
820 | desc: &mci->psy_desc, cfg: &charger_cfg); |
821 | if (IS_ERR(ptr: mci->psy)) |
822 | return dev_err_probe(dev: &pdev->dev, err: PTR_ERR(ptr: mci->psy), |
823 | fmt: "Failed to register power supply dev\n" ); |
824 | |
825 | |
826 | ret = mt6360_chg_irq_register(pdev); |
827 | if (ret) |
828 | return dev_err_probe(dev: &pdev->dev, err: ret, fmt: "Failed to register irqs\n" ); |
829 | |
830 | config.dev = &pdev->dev; |
831 | config.regmap = mci->regmap; |
832 | mci->otg_rdev = devm_regulator_register(dev: &pdev->dev, regulator_desc: &mt6360_otg_rdesc, |
833 | config: &config); |
834 | if (IS_ERR(ptr: mci->otg_rdev)) |
835 | return PTR_ERR(ptr: mci->otg_rdev); |
836 | |
837 | schedule_work(work: &mci->chrdet_work); |
838 | |
839 | return 0; |
840 | } |
841 | |
842 | static const struct of_device_id __maybe_unused mt6360_charger_of_id[] = { |
843 | { .compatible = "mediatek,mt6360-chg" , }, |
844 | {}, |
845 | }; |
846 | MODULE_DEVICE_TABLE(of, mt6360_charger_of_id); |
847 | |
848 | static const struct platform_device_id mt6360_charger_id[] = { |
849 | { "mt6360-chg" , 0 }, |
850 | {}, |
851 | }; |
852 | MODULE_DEVICE_TABLE(platform, mt6360_charger_id); |
853 | |
854 | static struct platform_driver mt6360_charger_driver = { |
855 | .driver = { |
856 | .name = "mt6360-chg" , |
857 | .of_match_table = of_match_ptr(mt6360_charger_of_id), |
858 | }, |
859 | .probe = mt6360_charger_probe, |
860 | .id_table = mt6360_charger_id, |
861 | }; |
862 | module_platform_driver(mt6360_charger_driver); |
863 | |
864 | MODULE_AUTHOR("Gene Chen <gene_chen@richtek.com>" ); |
865 | MODULE_DESCRIPTION("MT6360 Charger Driver" ); |
866 | MODULE_LICENSE("GPL" ); |
867 | |