1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * AXP20x PMIC USB power supply status driver |
4 | * |
5 | * Copyright (C) 2015 Hans de Goede <hdegoede@redhat.com> |
6 | * Copyright (C) 2014 Bruno Prémont <bonbons@linux-vserver.org> |
7 | */ |
8 | |
9 | #include <linux/bitops.h> |
10 | #include <linux/device.h> |
11 | #include <linux/devm-helpers.h> |
12 | #include <linux/init.h> |
13 | #include <linux/interrupt.h> |
14 | #include <linux/kernel.h> |
15 | #include <linux/mfd/axp20x.h> |
16 | #include <linux/module.h> |
17 | #include <linux/of.h> |
18 | #include <linux/platform_device.h> |
19 | #include <linux/pm.h> |
20 | #include <linux/power_supply.h> |
21 | #include <linux/regmap.h> |
22 | #include <linux/slab.h> |
23 | #include <linux/iio/consumer.h> |
24 | #include <linux/workqueue.h> |
25 | |
26 | #define DRVNAME "axp20x-usb-power-supply" |
27 | |
28 | #define AXP192_USB_OTG_STATUS 0x04 |
29 | |
30 | #define AXP20X_PWR_STATUS_VBUS_PRESENT BIT(5) |
31 | #define AXP20X_PWR_STATUS_VBUS_USED BIT(4) |
32 | |
33 | #define AXP20X_USB_STATUS_VBUS_VALID BIT(2) |
34 | |
35 | #define AXP20X_VBUS_VHOLD_uV(b) (4000000 + (((b) >> 3) & 7) * 100000) |
36 | #define AXP20X_VBUS_VHOLD_MASK GENMASK(5, 3) |
37 | #define AXP20X_VBUS_VHOLD_OFFSET 3 |
38 | |
39 | #define AXP20X_ADC_EN1_VBUS_CURR BIT(2) |
40 | #define AXP20X_ADC_EN1_VBUS_VOLT BIT(3) |
41 | |
42 | /* |
43 | * Note do not raise the debounce time, we must report Vusb high within |
44 | * 100ms otherwise we get Vbus errors in musb. |
45 | */ |
46 | #define DEBOUNCE_TIME msecs_to_jiffies(50) |
47 | |
48 | struct axp_data { |
49 | const struct power_supply_desc *power_desc; |
50 | const char * const *irq_names; |
51 | unsigned int num_irq_names; |
52 | const int *curr_lim_table; |
53 | int curr_lim_table_size; |
54 | struct reg_field curr_lim_fld; |
55 | struct reg_field vbus_valid_bit; |
56 | struct reg_field vbus_mon_bit; |
57 | struct reg_field usb_bc_en_bit; |
58 | struct reg_field usb_bc_det_fld; |
59 | struct reg_field vbus_disable_bit; |
60 | bool vbus_needs_polling: 1; |
61 | }; |
62 | |
63 | struct axp20x_usb_power { |
64 | struct device *dev; |
65 | struct regmap *regmap; |
66 | struct regmap_field *curr_lim_fld; |
67 | struct regmap_field *vbus_valid_bit; |
68 | struct regmap_field *vbus_mon_bit; |
69 | struct regmap_field *usb_bc_en_bit; |
70 | struct regmap_field *usb_bc_det_fld; |
71 | struct regmap_field *vbus_disable_bit; |
72 | struct power_supply *supply; |
73 | const struct axp_data *axp_data; |
74 | struct iio_channel *vbus_v; |
75 | struct iio_channel *vbus_i; |
76 | struct delayed_work vbus_detect; |
77 | unsigned int old_status; |
78 | unsigned int online; |
79 | unsigned int num_irqs; |
80 | unsigned int irqs[] __counted_by(num_irqs); |
81 | }; |
82 | |
83 | static bool axp20x_usb_vbus_needs_polling(struct axp20x_usb_power *power) |
84 | { |
85 | /* |
86 | * Polling is only necessary while VBUS is offline. While online, a |
87 | * present->absent transition implies an online->offline transition |
88 | * and will trigger the VBUS_REMOVAL IRQ. |
89 | */ |
90 | if (power->axp_data->vbus_needs_polling && !power->online) |
91 | return true; |
92 | |
93 | return false; |
94 | } |
95 | |
96 | static irqreturn_t axp20x_usb_power_irq(int irq, void *devid) |
97 | { |
98 | struct axp20x_usb_power *power = devid; |
99 | |
100 | power_supply_changed(psy: power->supply); |
101 | |
102 | mod_delayed_work(wq: system_power_efficient_wq, dwork: &power->vbus_detect, DEBOUNCE_TIME); |
103 | |
104 | return IRQ_HANDLED; |
105 | } |
106 | |
107 | static void axp20x_usb_power_poll_vbus(struct work_struct *work) |
108 | { |
109 | struct axp20x_usb_power *power = |
110 | container_of(work, struct axp20x_usb_power, vbus_detect.work); |
111 | unsigned int val; |
112 | int ret; |
113 | |
114 | ret = regmap_read(map: power->regmap, AXP20X_PWR_INPUT_STATUS, val: &val); |
115 | if (ret) |
116 | goto out; |
117 | |
118 | val &= (AXP20X_PWR_STATUS_VBUS_PRESENT | AXP20X_PWR_STATUS_VBUS_USED); |
119 | if (val != power->old_status) |
120 | power_supply_changed(psy: power->supply); |
121 | |
122 | if (power->usb_bc_en_bit && (val & AXP20X_PWR_STATUS_VBUS_PRESENT) != |
123 | (power->old_status & AXP20X_PWR_STATUS_VBUS_PRESENT)) { |
124 | dev_dbg(power->dev, "Cable status changed, re-enabling USB BC" ); |
125 | ret = regmap_field_write(field: power->usb_bc_en_bit, val: 1); |
126 | if (ret) |
127 | dev_err(power->dev, "failed to enable USB BC: errno %d" , |
128 | ret); |
129 | } |
130 | |
131 | power->old_status = val; |
132 | power->online = val & AXP20X_PWR_STATUS_VBUS_USED; |
133 | |
134 | out: |
135 | if (axp20x_usb_vbus_needs_polling(power)) |
136 | mod_delayed_work(wq: system_power_efficient_wq, dwork: &power->vbus_detect, DEBOUNCE_TIME); |
137 | } |
138 | |
139 | static int axp20x_get_usb_type(struct axp20x_usb_power *power, |
140 | union power_supply_propval *val) |
141 | { |
142 | unsigned int reg; |
143 | int ret; |
144 | |
145 | if (!power->usb_bc_det_fld) |
146 | return -EINVAL; |
147 | |
148 | ret = regmap_field_read(field: power->usb_bc_det_fld, val: ®); |
149 | if (ret) |
150 | return ret; |
151 | |
152 | switch (reg) { |
153 | case 1: |
154 | val->intval = POWER_SUPPLY_USB_TYPE_SDP; |
155 | break; |
156 | case 2: |
157 | val->intval = POWER_SUPPLY_USB_TYPE_CDP; |
158 | break; |
159 | case 3: |
160 | val->intval = POWER_SUPPLY_USB_TYPE_DCP; |
161 | break; |
162 | default: |
163 | val->intval = POWER_SUPPLY_USB_TYPE_UNKNOWN; |
164 | break; |
165 | } |
166 | |
167 | return 0; |
168 | } |
169 | |
170 | static int axp20x_usb_power_get_property(struct power_supply *psy, |
171 | enum power_supply_property psp, union power_supply_propval *val) |
172 | { |
173 | struct axp20x_usb_power *power = power_supply_get_drvdata(psy); |
174 | unsigned int input, v; |
175 | int ret; |
176 | |
177 | switch (psp) { |
178 | case POWER_SUPPLY_PROP_VOLTAGE_MIN: |
179 | ret = regmap_read(map: power->regmap, AXP20X_VBUS_IPSOUT_MGMT, val: &v); |
180 | if (ret) |
181 | return ret; |
182 | |
183 | val->intval = AXP20X_VBUS_VHOLD_uV(v); |
184 | return 0; |
185 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: |
186 | if (IS_ENABLED(CONFIG_AXP20X_ADC)) { |
187 | ret = iio_read_channel_processed(chan: power->vbus_v, |
188 | val: &val->intval); |
189 | if (ret) |
190 | return ret; |
191 | |
192 | /* |
193 | * IIO framework gives mV but Power Supply framework |
194 | * gives uV. |
195 | */ |
196 | val->intval *= 1000; |
197 | return 0; |
198 | } |
199 | |
200 | ret = axp20x_read_variable_width(regmap: power->regmap, |
201 | AXP20X_VBUS_V_ADC_H, width: 12); |
202 | if (ret < 0) |
203 | return ret; |
204 | |
205 | val->intval = ret * 1700; /* 1 step = 1.7 mV */ |
206 | return 0; |
207 | case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: |
208 | ret = regmap_field_read(field: power->curr_lim_fld, val: &v); |
209 | if (ret) |
210 | return ret; |
211 | |
212 | if (v < power->axp_data->curr_lim_table_size) |
213 | val->intval = power->axp_data->curr_lim_table[v]; |
214 | else |
215 | val->intval = power->axp_data->curr_lim_table[ |
216 | power->axp_data->curr_lim_table_size - 1]; |
217 | return 0; |
218 | case POWER_SUPPLY_PROP_CURRENT_NOW: |
219 | if (IS_ENABLED(CONFIG_AXP20X_ADC)) { |
220 | ret = iio_read_channel_processed(chan: power->vbus_i, |
221 | val: &val->intval); |
222 | if (ret) |
223 | return ret; |
224 | |
225 | /* |
226 | * IIO framework gives mA but Power Supply framework |
227 | * gives uA. |
228 | */ |
229 | val->intval *= 1000; |
230 | return 0; |
231 | } |
232 | |
233 | ret = axp20x_read_variable_width(regmap: power->regmap, |
234 | AXP20X_VBUS_I_ADC_H, width: 12); |
235 | if (ret < 0) |
236 | return ret; |
237 | |
238 | val->intval = ret * 375; /* 1 step = 0.375 mA */ |
239 | return 0; |
240 | |
241 | case POWER_SUPPLY_PROP_USB_TYPE: |
242 | return axp20x_get_usb_type(power, val); |
243 | default: |
244 | break; |
245 | } |
246 | |
247 | /* All the properties below need the input-status reg value */ |
248 | ret = regmap_read(map: power->regmap, AXP20X_PWR_INPUT_STATUS, val: &input); |
249 | if (ret) |
250 | return ret; |
251 | |
252 | switch (psp) { |
253 | case POWER_SUPPLY_PROP_HEALTH: |
254 | if (!(input & AXP20X_PWR_STATUS_VBUS_PRESENT)) { |
255 | val->intval = POWER_SUPPLY_HEALTH_UNKNOWN; |
256 | break; |
257 | } |
258 | |
259 | val->intval = POWER_SUPPLY_HEALTH_GOOD; |
260 | |
261 | if (power->vbus_valid_bit) { |
262 | ret = regmap_field_read(field: power->vbus_valid_bit, val: &v); |
263 | if (ret) |
264 | return ret; |
265 | |
266 | if (v == 0) |
267 | val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE; |
268 | } |
269 | |
270 | break; |
271 | case POWER_SUPPLY_PROP_PRESENT: |
272 | val->intval = !!(input & AXP20X_PWR_STATUS_VBUS_PRESENT); |
273 | break; |
274 | case POWER_SUPPLY_PROP_ONLINE: |
275 | val->intval = !!(input & AXP20X_PWR_STATUS_VBUS_USED); |
276 | break; |
277 | default: |
278 | return -EINVAL; |
279 | } |
280 | |
281 | return 0; |
282 | } |
283 | |
284 | static int axp20x_usb_power_set_voltage_min(struct axp20x_usb_power *power, |
285 | int intval) |
286 | { |
287 | int val; |
288 | |
289 | switch (intval) { |
290 | case 4000000: |
291 | case 4100000: |
292 | case 4200000: |
293 | case 4300000: |
294 | case 4400000: |
295 | case 4500000: |
296 | case 4600000: |
297 | case 4700000: |
298 | val = (intval - 4000000) / 100000; |
299 | return regmap_update_bits(map: power->regmap, |
300 | AXP20X_VBUS_IPSOUT_MGMT, |
301 | AXP20X_VBUS_VHOLD_MASK, |
302 | val: val << AXP20X_VBUS_VHOLD_OFFSET); |
303 | default: |
304 | return -EINVAL; |
305 | } |
306 | |
307 | return -EINVAL; |
308 | } |
309 | |
310 | static int axp20x_usb_power_set_input_current_limit(struct axp20x_usb_power *power, |
311 | int intval) |
312 | { |
313 | int ret; |
314 | unsigned int reg; |
315 | const unsigned int max = power->axp_data->curr_lim_table_size; |
316 | |
317 | if (intval == -1) |
318 | return -EINVAL; |
319 | |
320 | /* |
321 | * BC1.2 detection can cause a race condition if we try to set a current |
322 | * limit while it's in progress. When it finishes it will overwrite the |
323 | * current limit we just set. |
324 | */ |
325 | if (power->usb_bc_en_bit) { |
326 | dev_dbg(power->dev, |
327 | "disabling BC1.2 detection because current limit was set" ); |
328 | ret = regmap_field_write(field: power->usb_bc_en_bit, val: 0); |
329 | if (ret) |
330 | return ret; |
331 | } |
332 | |
333 | for (reg = max - 1; reg > 0; reg--) |
334 | if (power->axp_data->curr_lim_table[reg] <= intval) |
335 | break; |
336 | |
337 | dev_dbg(power->dev, "setting input current limit reg to %d (%d uA), requested %d uA" , |
338 | reg, power->axp_data->curr_lim_table[reg], intval); |
339 | |
340 | return regmap_field_write(field: power->curr_lim_fld, val: reg); |
341 | } |
342 | |
343 | static int axp20x_usb_power_set_property(struct power_supply *psy, |
344 | enum power_supply_property psp, |
345 | const union power_supply_propval *val) |
346 | { |
347 | struct axp20x_usb_power *power = power_supply_get_drvdata(psy); |
348 | |
349 | switch (psp) { |
350 | case POWER_SUPPLY_PROP_ONLINE: |
351 | if (!power->vbus_disable_bit) |
352 | return -EINVAL; |
353 | |
354 | return regmap_field_write(field: power->vbus_disable_bit, val: !val->intval); |
355 | |
356 | case POWER_SUPPLY_PROP_VOLTAGE_MIN: |
357 | return axp20x_usb_power_set_voltage_min(power, intval: val->intval); |
358 | |
359 | case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: |
360 | return axp20x_usb_power_set_input_current_limit(power, intval: val->intval); |
361 | |
362 | default: |
363 | return -EINVAL; |
364 | } |
365 | |
366 | return -EINVAL; |
367 | } |
368 | |
369 | static int axp20x_usb_power_prop_writeable(struct power_supply *psy, |
370 | enum power_supply_property psp) |
371 | { |
372 | struct axp20x_usb_power *power = power_supply_get_drvdata(psy); |
373 | |
374 | /* |
375 | * The VBUS path select flag works differently on AXP288 and newer: |
376 | * - On AXP20x and AXP22x, the flag enables VBUS (ignoring N_VBUSEN). |
377 | * - On AXP288 and AXP8xx, the flag disables VBUS (ignoring N_VBUSEN). |
378 | * We only expose the control on variants where it can be used to force |
379 | * the VBUS input offline. |
380 | */ |
381 | if (psp == POWER_SUPPLY_PROP_ONLINE) |
382 | return power->vbus_disable_bit != NULL; |
383 | |
384 | return psp == POWER_SUPPLY_PROP_VOLTAGE_MIN || |
385 | psp == POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT; |
386 | } |
387 | |
388 | static enum power_supply_property axp20x_usb_power_properties[] = { |
389 | POWER_SUPPLY_PROP_HEALTH, |
390 | POWER_SUPPLY_PROP_PRESENT, |
391 | POWER_SUPPLY_PROP_ONLINE, |
392 | POWER_SUPPLY_PROP_VOLTAGE_MIN, |
393 | POWER_SUPPLY_PROP_VOLTAGE_NOW, |
394 | POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, |
395 | POWER_SUPPLY_PROP_CURRENT_NOW, |
396 | }; |
397 | |
398 | static enum power_supply_property axp22x_usb_power_properties[] = { |
399 | POWER_SUPPLY_PROP_HEALTH, |
400 | POWER_SUPPLY_PROP_PRESENT, |
401 | POWER_SUPPLY_PROP_ONLINE, |
402 | POWER_SUPPLY_PROP_VOLTAGE_MIN, |
403 | POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, |
404 | }; |
405 | |
406 | static enum power_supply_property axp813_usb_power_properties[] = { |
407 | POWER_SUPPLY_PROP_HEALTH, |
408 | POWER_SUPPLY_PROP_PRESENT, |
409 | POWER_SUPPLY_PROP_ONLINE, |
410 | POWER_SUPPLY_PROP_VOLTAGE_MIN, |
411 | POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, |
412 | POWER_SUPPLY_PROP_USB_TYPE, |
413 | }; |
414 | |
415 | static enum power_supply_usb_type axp813_usb_types[] = { |
416 | POWER_SUPPLY_USB_TYPE_SDP, |
417 | POWER_SUPPLY_USB_TYPE_DCP, |
418 | POWER_SUPPLY_USB_TYPE_CDP, |
419 | POWER_SUPPLY_USB_TYPE_UNKNOWN, |
420 | }; |
421 | |
422 | static const struct power_supply_desc axp20x_usb_power_desc = { |
423 | .name = "axp20x-usb" , |
424 | .type = POWER_SUPPLY_TYPE_USB, |
425 | .properties = axp20x_usb_power_properties, |
426 | .num_properties = ARRAY_SIZE(axp20x_usb_power_properties), |
427 | .property_is_writeable = axp20x_usb_power_prop_writeable, |
428 | .get_property = axp20x_usb_power_get_property, |
429 | .set_property = axp20x_usb_power_set_property, |
430 | }; |
431 | |
432 | static const struct power_supply_desc axp22x_usb_power_desc = { |
433 | .name = "axp20x-usb" , |
434 | .type = POWER_SUPPLY_TYPE_USB, |
435 | .properties = axp22x_usb_power_properties, |
436 | .num_properties = ARRAY_SIZE(axp22x_usb_power_properties), |
437 | .property_is_writeable = axp20x_usb_power_prop_writeable, |
438 | .get_property = axp20x_usb_power_get_property, |
439 | .set_property = axp20x_usb_power_set_property, |
440 | }; |
441 | |
442 | static const struct power_supply_desc axp813_usb_power_desc = { |
443 | .name = "axp20x-usb" , |
444 | .type = POWER_SUPPLY_TYPE_USB, |
445 | .properties = axp813_usb_power_properties, |
446 | .num_properties = ARRAY_SIZE(axp813_usb_power_properties), |
447 | .property_is_writeable = axp20x_usb_power_prop_writeable, |
448 | .get_property = axp20x_usb_power_get_property, |
449 | .set_property = axp20x_usb_power_set_property, |
450 | .usb_types = axp813_usb_types, |
451 | .num_usb_types = ARRAY_SIZE(axp813_usb_types), |
452 | }; |
453 | |
454 | static const char * const axp20x_irq_names[] = { |
455 | "VBUS_PLUGIN" , |
456 | "VBUS_REMOVAL" , |
457 | "VBUS_VALID" , |
458 | "VBUS_NOT_VALID" , |
459 | }; |
460 | |
461 | static const char * const axp22x_irq_names[] = { |
462 | "VBUS_PLUGIN" , |
463 | "VBUS_REMOVAL" , |
464 | }; |
465 | |
466 | static int axp192_usb_curr_lim_table[] = { |
467 | -1, |
468 | -1, |
469 | 500000, |
470 | 100000, |
471 | }; |
472 | |
473 | static int axp20x_usb_curr_lim_table[] = { |
474 | 900000, |
475 | 500000, |
476 | 100000, |
477 | -1, |
478 | }; |
479 | |
480 | static int axp221_usb_curr_lim_table[] = { |
481 | 900000, |
482 | 500000, |
483 | -1, |
484 | -1, |
485 | }; |
486 | |
487 | static int axp813_usb_curr_lim_table[] = { |
488 | 100000, |
489 | 500000, |
490 | 900000, |
491 | 1500000, |
492 | 2000000, |
493 | 2500000, |
494 | 3000000, |
495 | 3500000, |
496 | 4000000, |
497 | }; |
498 | |
499 | static const struct axp_data axp192_data = { |
500 | .power_desc = &axp20x_usb_power_desc, |
501 | .irq_names = axp20x_irq_names, |
502 | .num_irq_names = ARRAY_SIZE(axp20x_irq_names), |
503 | .curr_lim_table = axp192_usb_curr_lim_table, |
504 | .curr_lim_table_size = ARRAY_SIZE(axp192_usb_curr_lim_table), |
505 | .curr_lim_fld = REG_FIELD(AXP20X_VBUS_IPSOUT_MGMT, 0, 1), |
506 | .vbus_valid_bit = REG_FIELD(AXP192_USB_OTG_STATUS, 2, 2), |
507 | .vbus_mon_bit = REG_FIELD(AXP20X_VBUS_MON, 3, 3), |
508 | }; |
509 | |
510 | static const struct axp_data axp202_data = { |
511 | .power_desc = &axp20x_usb_power_desc, |
512 | .irq_names = axp20x_irq_names, |
513 | .num_irq_names = ARRAY_SIZE(axp20x_irq_names), |
514 | .curr_lim_table = axp20x_usb_curr_lim_table, |
515 | .curr_lim_table_size = ARRAY_SIZE(axp20x_usb_curr_lim_table), |
516 | .curr_lim_fld = REG_FIELD(AXP20X_VBUS_IPSOUT_MGMT, 0, 1), |
517 | .vbus_valid_bit = REG_FIELD(AXP20X_USB_OTG_STATUS, 2, 2), |
518 | .vbus_mon_bit = REG_FIELD(AXP20X_VBUS_MON, 3, 3), |
519 | }; |
520 | |
521 | static const struct axp_data axp221_data = { |
522 | .power_desc = &axp22x_usb_power_desc, |
523 | .irq_names = axp22x_irq_names, |
524 | .num_irq_names = ARRAY_SIZE(axp22x_irq_names), |
525 | .curr_lim_table = axp221_usb_curr_lim_table, |
526 | .curr_lim_table_size = ARRAY_SIZE(axp221_usb_curr_lim_table), |
527 | .curr_lim_fld = REG_FIELD(AXP20X_VBUS_IPSOUT_MGMT, 0, 1), |
528 | .vbus_needs_polling = true, |
529 | }; |
530 | |
531 | static const struct axp_data axp223_data = { |
532 | .power_desc = &axp22x_usb_power_desc, |
533 | .irq_names = axp22x_irq_names, |
534 | .num_irq_names = ARRAY_SIZE(axp22x_irq_names), |
535 | .curr_lim_table = axp20x_usb_curr_lim_table, |
536 | .curr_lim_table_size = ARRAY_SIZE(axp20x_usb_curr_lim_table), |
537 | .curr_lim_fld = REG_FIELD(AXP20X_VBUS_IPSOUT_MGMT, 0, 1), |
538 | .vbus_needs_polling = true, |
539 | }; |
540 | |
541 | static const struct axp_data axp813_data = { |
542 | .power_desc = &axp813_usb_power_desc, |
543 | .irq_names = axp22x_irq_names, |
544 | .num_irq_names = ARRAY_SIZE(axp22x_irq_names), |
545 | .curr_lim_table = axp813_usb_curr_lim_table, |
546 | .curr_lim_table_size = ARRAY_SIZE(axp813_usb_curr_lim_table), |
547 | .curr_lim_fld = REG_FIELD(AXP22X_CHRG_CTRL3, 4, 7), |
548 | .usb_bc_en_bit = REG_FIELD(AXP288_BC_GLOBAL, 0, 0), |
549 | .usb_bc_det_fld = REG_FIELD(AXP288_BC_DET_STAT, 5, 7), |
550 | .vbus_disable_bit = REG_FIELD(AXP20X_VBUS_IPSOUT_MGMT, 7, 7), |
551 | .vbus_needs_polling = true, |
552 | }; |
553 | |
554 | #ifdef CONFIG_PM_SLEEP |
555 | static int axp20x_usb_power_suspend(struct device *dev) |
556 | { |
557 | struct axp20x_usb_power *power = dev_get_drvdata(dev); |
558 | int i = 0; |
559 | |
560 | /* |
561 | * Allow wake via VBUS_PLUGIN only. |
562 | * |
563 | * As nested threaded IRQs are not automatically disabled during |
564 | * suspend, we must explicitly disable the remainder of the IRQs. |
565 | */ |
566 | if (device_may_wakeup(dev: &power->supply->dev)) |
567 | enable_irq_wake(irq: power->irqs[i++]); |
568 | while (i < power->num_irqs) |
569 | disable_irq(irq: power->irqs[i++]); |
570 | |
571 | return 0; |
572 | } |
573 | |
574 | static int axp20x_usb_power_resume(struct device *dev) |
575 | { |
576 | struct axp20x_usb_power *power = dev_get_drvdata(dev); |
577 | int i = 0; |
578 | |
579 | if (device_may_wakeup(dev: &power->supply->dev)) |
580 | disable_irq_wake(irq: power->irqs[i++]); |
581 | while (i < power->num_irqs) |
582 | enable_irq(irq: power->irqs[i++]); |
583 | |
584 | mod_delayed_work(wq: system_power_efficient_wq, dwork: &power->vbus_detect, DEBOUNCE_TIME); |
585 | |
586 | return 0; |
587 | } |
588 | #endif |
589 | |
590 | static SIMPLE_DEV_PM_OPS(axp20x_usb_power_pm_ops, axp20x_usb_power_suspend, |
591 | axp20x_usb_power_resume); |
592 | |
593 | static int configure_iio_channels(struct platform_device *pdev, |
594 | struct axp20x_usb_power *power) |
595 | { |
596 | power->vbus_v = devm_iio_channel_get(dev: &pdev->dev, consumer_channel: "vbus_v" ); |
597 | if (IS_ERR(ptr: power->vbus_v)) { |
598 | if (PTR_ERR(ptr: power->vbus_v) == -ENODEV) |
599 | return -EPROBE_DEFER; |
600 | return PTR_ERR(ptr: power->vbus_v); |
601 | } |
602 | |
603 | power->vbus_i = devm_iio_channel_get(dev: &pdev->dev, consumer_channel: "vbus_i" ); |
604 | if (IS_ERR(ptr: power->vbus_i)) { |
605 | if (PTR_ERR(ptr: power->vbus_i) == -ENODEV) |
606 | return -EPROBE_DEFER; |
607 | return PTR_ERR(ptr: power->vbus_i); |
608 | } |
609 | |
610 | return 0; |
611 | } |
612 | |
613 | static int configure_adc_registers(struct axp20x_usb_power *power) |
614 | { |
615 | /* Enable vbus voltage and current measurement */ |
616 | return regmap_update_bits(map: power->regmap, AXP20X_ADC_EN1, |
617 | AXP20X_ADC_EN1_VBUS_CURR | |
618 | AXP20X_ADC_EN1_VBUS_VOLT, |
619 | AXP20X_ADC_EN1_VBUS_CURR | |
620 | AXP20X_ADC_EN1_VBUS_VOLT); |
621 | } |
622 | |
623 | static int axp20x_regmap_field_alloc_optional(struct device *dev, |
624 | struct regmap *regmap, |
625 | struct reg_field fdesc, |
626 | struct regmap_field **fieldp) |
627 | { |
628 | struct regmap_field *field; |
629 | |
630 | if (fdesc.reg == 0) { |
631 | *fieldp = NULL; |
632 | return 0; |
633 | } |
634 | |
635 | field = devm_regmap_field_alloc(dev, regmap, reg_field: fdesc); |
636 | if (IS_ERR(ptr: field)) |
637 | return PTR_ERR(ptr: field); |
638 | |
639 | *fieldp = field; |
640 | return 0; |
641 | } |
642 | |
643 | static int axp20x_usb_power_probe(struct platform_device *pdev) |
644 | { |
645 | struct axp20x_dev *axp20x = dev_get_drvdata(dev: pdev->dev.parent); |
646 | struct power_supply_config psy_cfg = {}; |
647 | struct axp20x_usb_power *power; |
648 | const struct axp_data *axp_data; |
649 | int i, irq, ret; |
650 | |
651 | if (!of_device_is_available(device: pdev->dev.of_node)) |
652 | return -ENODEV; |
653 | |
654 | if (!axp20x) { |
655 | dev_err(&pdev->dev, "Parent drvdata not set\n" ); |
656 | return -EINVAL; |
657 | } |
658 | |
659 | axp_data = of_device_get_match_data(dev: &pdev->dev); |
660 | |
661 | power = devm_kzalloc(dev: &pdev->dev, |
662 | struct_size(power, irqs, axp_data->num_irq_names), |
663 | GFP_KERNEL); |
664 | if (!power) |
665 | return -ENOMEM; |
666 | |
667 | platform_set_drvdata(pdev, data: power); |
668 | |
669 | power->dev = &pdev->dev; |
670 | power->axp_data = axp_data; |
671 | power->regmap = axp20x->regmap; |
672 | power->num_irqs = axp_data->num_irq_names; |
673 | |
674 | power->curr_lim_fld = devm_regmap_field_alloc(dev: &pdev->dev, regmap: power->regmap, |
675 | reg_field: axp_data->curr_lim_fld); |
676 | if (IS_ERR(ptr: power->curr_lim_fld)) |
677 | return PTR_ERR(ptr: power->curr_lim_fld); |
678 | |
679 | ret = axp20x_regmap_field_alloc_optional(dev: &pdev->dev, regmap: power->regmap, |
680 | fdesc: axp_data->vbus_valid_bit, |
681 | fieldp: &power->vbus_valid_bit); |
682 | if (ret) |
683 | return ret; |
684 | |
685 | ret = axp20x_regmap_field_alloc_optional(dev: &pdev->dev, regmap: power->regmap, |
686 | fdesc: axp_data->vbus_mon_bit, |
687 | fieldp: &power->vbus_mon_bit); |
688 | if (ret) |
689 | return ret; |
690 | |
691 | ret = axp20x_regmap_field_alloc_optional(dev: &pdev->dev, regmap: power->regmap, |
692 | fdesc: axp_data->usb_bc_en_bit, |
693 | fieldp: &power->usb_bc_en_bit); |
694 | if (ret) |
695 | return ret; |
696 | |
697 | ret = axp20x_regmap_field_alloc_optional(dev: &pdev->dev, regmap: power->regmap, |
698 | fdesc: axp_data->usb_bc_det_fld, |
699 | fieldp: &power->usb_bc_det_fld); |
700 | if (ret) |
701 | return ret; |
702 | |
703 | ret = axp20x_regmap_field_alloc_optional(dev: &pdev->dev, regmap: power->regmap, |
704 | fdesc: axp_data->vbus_disable_bit, |
705 | fieldp: &power->vbus_disable_bit); |
706 | if (ret) |
707 | return ret; |
708 | |
709 | ret = devm_delayed_work_autocancel(dev: &pdev->dev, w: &power->vbus_detect, |
710 | worker: axp20x_usb_power_poll_vbus); |
711 | if (ret) |
712 | return ret; |
713 | |
714 | if (power->vbus_mon_bit) { |
715 | /* Enable vbus valid checking */ |
716 | ret = regmap_field_write(field: power->vbus_mon_bit, val: 1); |
717 | if (ret) |
718 | return ret; |
719 | |
720 | if (IS_ENABLED(CONFIG_AXP20X_ADC)) |
721 | ret = configure_iio_channels(pdev, power); |
722 | else |
723 | ret = configure_adc_registers(power); |
724 | |
725 | if (ret) |
726 | return ret; |
727 | } |
728 | |
729 | if (power->usb_bc_en_bit) { |
730 | /* Enable USB Battery Charging specification detection */ |
731 | ret = regmap_field_write(field: power->usb_bc_en_bit, val: 1); |
732 | if (ret) |
733 | return ret; |
734 | } |
735 | |
736 | psy_cfg.of_node = pdev->dev.of_node; |
737 | psy_cfg.drv_data = power; |
738 | |
739 | power->supply = devm_power_supply_register(parent: &pdev->dev, |
740 | desc: axp_data->power_desc, |
741 | cfg: &psy_cfg); |
742 | if (IS_ERR(ptr: power->supply)) |
743 | return PTR_ERR(ptr: power->supply); |
744 | |
745 | /* Request irqs after registering, as irqs may trigger immediately */ |
746 | for (i = 0; i < axp_data->num_irq_names; i++) { |
747 | irq = platform_get_irq_byname(pdev, axp_data->irq_names[i]); |
748 | if (irq < 0) |
749 | return irq; |
750 | |
751 | power->irqs[i] = regmap_irq_get_virq(data: axp20x->regmap_irqc, irq); |
752 | ret = devm_request_any_context_irq(dev: &pdev->dev, irq: power->irqs[i], |
753 | handler: axp20x_usb_power_irq, irqflags: 0, |
754 | DRVNAME, dev_id: power); |
755 | if (ret < 0) { |
756 | dev_err(&pdev->dev, "Error requesting %s IRQ: %d\n" , |
757 | axp_data->irq_names[i], ret); |
758 | return ret; |
759 | } |
760 | } |
761 | |
762 | if (axp20x_usb_vbus_needs_polling(power)) |
763 | queue_delayed_work(wq: system_power_efficient_wq, dwork: &power->vbus_detect, delay: 0); |
764 | |
765 | return 0; |
766 | } |
767 | |
768 | static const struct of_device_id axp20x_usb_power_match[] = { |
769 | { |
770 | .compatible = "x-powers,axp192-usb-power-supply" , |
771 | .data = &axp192_data, |
772 | }, { |
773 | .compatible = "x-powers,axp202-usb-power-supply" , |
774 | .data = &axp202_data, |
775 | }, { |
776 | .compatible = "x-powers,axp221-usb-power-supply" , |
777 | .data = &axp221_data, |
778 | }, { |
779 | .compatible = "x-powers,axp223-usb-power-supply" , |
780 | .data = &axp223_data, |
781 | }, { |
782 | .compatible = "x-powers,axp813-usb-power-supply" , |
783 | .data = &axp813_data, |
784 | }, { /* sentinel */ } |
785 | }; |
786 | MODULE_DEVICE_TABLE(of, axp20x_usb_power_match); |
787 | |
788 | static struct platform_driver axp20x_usb_power_driver = { |
789 | .probe = axp20x_usb_power_probe, |
790 | .driver = { |
791 | .name = DRVNAME, |
792 | .of_match_table = axp20x_usb_power_match, |
793 | .pm = &axp20x_usb_power_pm_ops, |
794 | }, |
795 | }; |
796 | |
797 | module_platform_driver(axp20x_usb_power_driver); |
798 | |
799 | MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>" ); |
800 | MODULE_DESCRIPTION("AXP20x PMIC USB power supply status driver" ); |
801 | MODULE_LICENSE("GPL" ); |
802 | |