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
48struct 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
63struct 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
83static 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
96static 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
107static 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
134out:
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
139static 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: &reg);
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
170static 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
284static 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
310static 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
343static 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
369static 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
388static 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
398static 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
406static 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
415static 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
422static 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
432static 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
442static 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
454static const char * const axp20x_irq_names[] = {
455 "VBUS_PLUGIN",
456 "VBUS_REMOVAL",
457 "VBUS_VALID",
458 "VBUS_NOT_VALID",
459};
460
461static const char * const axp22x_irq_names[] = {
462 "VBUS_PLUGIN",
463 "VBUS_REMOVAL",
464};
465
466static int axp192_usb_curr_lim_table[] = {
467 -1,
468 -1,
469 500000,
470 100000,
471};
472
473static int axp20x_usb_curr_lim_table[] = {
474 900000,
475 500000,
476 100000,
477 -1,
478};
479
480static int axp221_usb_curr_lim_table[] = {
481 900000,
482 500000,
483 -1,
484 -1,
485};
486
487static 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
499static 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
510static 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
521static 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
531static 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
541static 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
555static 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
574static 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
590static SIMPLE_DEV_PM_OPS(axp20x_usb_power_pm_ops, axp20x_usb_power_suspend,
591 axp20x_usb_power_resume);
592
593static 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
613static 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
623static 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
643static 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
768static 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};
786MODULE_DEVICE_TABLE(of, axp20x_usb_power_match);
787
788static 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
797module_platform_driver(axp20x_usb_power_driver);
798
799MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
800MODULE_DESCRIPTION("AXP20x PMIC USB power supply status driver");
801MODULE_LICENSE("GPL");
802

source code of linux/drivers/power/supply/axp20x_usb_power.c