1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * PMU driver for Wolfson Microelectronics wm831x PMICs
4 *
5 * Copyright 2009 Wolfson Microelectronics PLC.
6 */
7
8#include <linux/module.h>
9#include <linux/err.h>
10#include <linux/platform_device.h>
11#include <linux/power_supply.h>
12#include <linux/slab.h>
13#include <linux/usb/phy.h>
14
15#include <linux/mfd/wm831x/core.h>
16#include <linux/mfd/wm831x/auxadc.h>
17#include <linux/mfd/wm831x/pmu.h>
18#include <linux/mfd/wm831x/pdata.h>
19
20struct wm831x_power {
21 struct wm831x *wm831x;
22 struct power_supply *wall;
23 struct power_supply *usb;
24 struct power_supply *battery;
25 struct power_supply_desc wall_desc;
26 struct power_supply_desc usb_desc;
27 struct power_supply_desc battery_desc;
28 char wall_name[20];
29 char usb_name[20];
30 char battery_name[20];
31 bool have_battery;
32 struct usb_phy *usb_phy;
33 struct notifier_block usb_notify;
34};
35
36static int wm831x_power_check_online(struct wm831x *wm831x, int supply,
37 union power_supply_propval *val)
38{
39 int ret;
40
41 ret = wm831x_reg_read(wm831x, WM831X_SYSTEM_STATUS);
42 if (ret < 0)
43 return ret;
44
45 if (ret & supply)
46 val->intval = 1;
47 else
48 val->intval = 0;
49
50 return 0;
51}
52
53static int wm831x_power_read_voltage(struct wm831x *wm831x,
54 enum wm831x_auxadc src,
55 union power_supply_propval *val)
56{
57 int ret;
58
59 ret = wm831x_auxadc_read_uv(wm831x, input: src);
60 if (ret >= 0)
61 val->intval = ret;
62
63 return ret;
64}
65
66/*********************************************************************
67 * WALL Power
68 *********************************************************************/
69static int wm831x_wall_get_prop(struct power_supply *psy,
70 enum power_supply_property psp,
71 union power_supply_propval *val)
72{
73 struct wm831x_power *wm831x_power = dev_get_drvdata(dev: psy->dev.parent);
74 struct wm831x *wm831x = wm831x_power->wm831x;
75 int ret = 0;
76
77 switch (psp) {
78 case POWER_SUPPLY_PROP_ONLINE:
79 ret = wm831x_power_check_online(wm831x, WM831X_PWR_WALL, val);
80 break;
81 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
82 ret = wm831x_power_read_voltage(wm831x, src: WM831X_AUX_WALL, val);
83 break;
84 default:
85 ret = -EINVAL;
86 break;
87 }
88
89 return ret;
90}
91
92static const enum power_supply_property wm831x_wall_props[] = {
93 POWER_SUPPLY_PROP_ONLINE,
94 POWER_SUPPLY_PROP_VOLTAGE_NOW,
95};
96
97/*********************************************************************
98 * USB Power
99 *********************************************************************/
100static int wm831x_usb_get_prop(struct power_supply *psy,
101 enum power_supply_property psp,
102 union power_supply_propval *val)
103{
104 struct wm831x_power *wm831x_power = dev_get_drvdata(dev: psy->dev.parent);
105 struct wm831x *wm831x = wm831x_power->wm831x;
106 int ret = 0;
107
108 switch (psp) {
109 case POWER_SUPPLY_PROP_ONLINE:
110 ret = wm831x_power_check_online(wm831x, WM831X_PWR_USB, val);
111 break;
112 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
113 ret = wm831x_power_read_voltage(wm831x, src: WM831X_AUX_USB, val);
114 break;
115 default:
116 ret = -EINVAL;
117 break;
118 }
119
120 return ret;
121}
122
123static const enum power_supply_property wm831x_usb_props[] = {
124 POWER_SUPPLY_PROP_ONLINE,
125 POWER_SUPPLY_PROP_VOLTAGE_NOW,
126};
127
128/* In milliamps */
129static const unsigned int wm831x_usb_limits[] = {
130 0,
131 2,
132 100,
133 500,
134 900,
135 1500,
136 1800,
137 550,
138};
139
140static int wm831x_usb_limit_change(struct notifier_block *nb,
141 unsigned long limit, void *data)
142{
143 struct wm831x_power *wm831x_power = container_of(nb,
144 struct wm831x_power,
145 usb_notify);
146 unsigned int i, best;
147 int ret;
148
149 /* Find the highest supported limit */
150 best = 0;
151 for (i = 0; i < ARRAY_SIZE(wm831x_usb_limits); i++) {
152 if (limit >= wm831x_usb_limits[i] &&
153 wm831x_usb_limits[best] < wm831x_usb_limits[i])
154 best = i;
155 }
156
157 dev_dbg(wm831x_power->wm831x->dev,
158 "Limiting USB current to %umA", wm831x_usb_limits[best]);
159
160 ret = wm831x_set_bits(wm831x: wm831x_power->wm831x, WM831X_POWER_STATE,
161 WM831X_USB_ILIM_MASK, val: best);
162 if (ret < 0) {
163 dev_err(wm831x_power->wm831x->dev,
164 "Failed to set USB current limit: %d\n", ret);
165 return ret;
166 }
167
168 return 0;
169}
170
171/*********************************************************************
172 * Battery properties
173 *********************************************************************/
174
175struct chg_map {
176 int val;
177 int reg_val;
178};
179
180static const struct chg_map trickle_ilims[] = {
181 { 50, 0 << WM831X_CHG_TRKL_ILIM_SHIFT },
182 { 100, 1 << WM831X_CHG_TRKL_ILIM_SHIFT },
183 { 150, 2 << WM831X_CHG_TRKL_ILIM_SHIFT },
184 { 200, 3 << WM831X_CHG_TRKL_ILIM_SHIFT },
185};
186
187static const struct chg_map vsels[] = {
188 { 4050, 0 << WM831X_CHG_VSEL_SHIFT },
189 { 4100, 1 << WM831X_CHG_VSEL_SHIFT },
190 { 4150, 2 << WM831X_CHG_VSEL_SHIFT },
191 { 4200, 3 << WM831X_CHG_VSEL_SHIFT },
192};
193
194static const struct chg_map fast_ilims[] = {
195 { 0, 0 << WM831X_CHG_FAST_ILIM_SHIFT },
196 { 50, 1 << WM831X_CHG_FAST_ILIM_SHIFT },
197 { 100, 2 << WM831X_CHG_FAST_ILIM_SHIFT },
198 { 150, 3 << WM831X_CHG_FAST_ILIM_SHIFT },
199 { 200, 4 << WM831X_CHG_FAST_ILIM_SHIFT },
200 { 250, 5 << WM831X_CHG_FAST_ILIM_SHIFT },
201 { 300, 6 << WM831X_CHG_FAST_ILIM_SHIFT },
202 { 350, 7 << WM831X_CHG_FAST_ILIM_SHIFT },
203 { 400, 8 << WM831X_CHG_FAST_ILIM_SHIFT },
204 { 450, 9 << WM831X_CHG_FAST_ILIM_SHIFT },
205 { 500, 10 << WM831X_CHG_FAST_ILIM_SHIFT },
206 { 600, 11 << WM831X_CHG_FAST_ILIM_SHIFT },
207 { 700, 12 << WM831X_CHG_FAST_ILIM_SHIFT },
208 { 800, 13 << WM831X_CHG_FAST_ILIM_SHIFT },
209 { 900, 14 << WM831X_CHG_FAST_ILIM_SHIFT },
210 { 1000, 15 << WM831X_CHG_FAST_ILIM_SHIFT },
211};
212
213static const struct chg_map eoc_iterms[] = {
214 { 20, 0 << WM831X_CHG_ITERM_SHIFT },
215 { 30, 1 << WM831X_CHG_ITERM_SHIFT },
216 { 40, 2 << WM831X_CHG_ITERM_SHIFT },
217 { 50, 3 << WM831X_CHG_ITERM_SHIFT },
218 { 60, 4 << WM831X_CHG_ITERM_SHIFT },
219 { 70, 5 << WM831X_CHG_ITERM_SHIFT },
220 { 80, 6 << WM831X_CHG_ITERM_SHIFT },
221 { 90, 7 << WM831X_CHG_ITERM_SHIFT },
222};
223
224static const struct chg_map chg_times[] = {
225 { 60, 0 << WM831X_CHG_TIME_SHIFT },
226 { 90, 1 << WM831X_CHG_TIME_SHIFT },
227 { 120, 2 << WM831X_CHG_TIME_SHIFT },
228 { 150, 3 << WM831X_CHG_TIME_SHIFT },
229 { 180, 4 << WM831X_CHG_TIME_SHIFT },
230 { 210, 5 << WM831X_CHG_TIME_SHIFT },
231 { 240, 6 << WM831X_CHG_TIME_SHIFT },
232 { 270, 7 << WM831X_CHG_TIME_SHIFT },
233 { 300, 8 << WM831X_CHG_TIME_SHIFT },
234 { 330, 9 << WM831X_CHG_TIME_SHIFT },
235 { 360, 10 << WM831X_CHG_TIME_SHIFT },
236 { 390, 11 << WM831X_CHG_TIME_SHIFT },
237 { 420, 12 << WM831X_CHG_TIME_SHIFT },
238 { 450, 13 << WM831X_CHG_TIME_SHIFT },
239 { 480, 14 << WM831X_CHG_TIME_SHIFT },
240 { 510, 15 << WM831X_CHG_TIME_SHIFT },
241};
242
243static void wm831x_battery_apply_config(struct wm831x *wm831x,
244 const struct chg_map *map, int count, int val,
245 int *reg, const char *name,
246 const char *units)
247{
248 int i;
249
250 for (i = 0; i < count; i++)
251 if (val == map[i].val)
252 break;
253 if (i == count) {
254 dev_err(wm831x->dev, "Invalid %s %d%s\n",
255 name, val, units);
256 } else {
257 *reg |= map[i].reg_val;
258 dev_dbg(wm831x->dev, "Set %s of %d%s\n", name, val, units);
259 }
260}
261
262static void wm831x_config_battery(struct wm831x *wm831x)
263{
264 struct wm831x_pdata *wm831x_pdata = wm831x->dev->platform_data;
265 struct wm831x_battery_pdata *pdata;
266 int ret, reg1, reg2;
267
268 if (!wm831x_pdata || !wm831x_pdata->battery) {
269 dev_warn(wm831x->dev,
270 "No battery charger configuration\n");
271 return;
272 }
273
274 pdata = wm831x_pdata->battery;
275
276 reg1 = 0;
277 reg2 = 0;
278
279 if (!pdata->enable) {
280 dev_info(wm831x->dev, "Battery charger disabled\n");
281 return;
282 }
283
284 reg1 |= WM831X_CHG_ENA;
285 if (pdata->off_mask)
286 reg2 |= WM831X_CHG_OFF_MSK;
287 if (pdata->fast_enable)
288 reg1 |= WM831X_CHG_FAST;
289
290 wm831x_battery_apply_config(wm831x, map: trickle_ilims,
291 ARRAY_SIZE(trickle_ilims),
292 val: pdata->trickle_ilim, reg: &reg2,
293 name: "trickle charge current limit", units: "mA");
294
295 wm831x_battery_apply_config(wm831x, map: vsels, ARRAY_SIZE(vsels),
296 val: pdata->vsel, reg: &reg2,
297 name: "target voltage", units: "mV");
298
299 wm831x_battery_apply_config(wm831x, map: fast_ilims, ARRAY_SIZE(fast_ilims),
300 val: pdata->fast_ilim, reg: &reg2,
301 name: "fast charge current limit", units: "mA");
302
303 wm831x_battery_apply_config(wm831x, map: eoc_iterms, ARRAY_SIZE(eoc_iterms),
304 val: pdata->eoc_iterm, reg: &reg1,
305 name: "end of charge current threshold", units: "mA");
306
307 wm831x_battery_apply_config(wm831x, map: chg_times, ARRAY_SIZE(chg_times),
308 val: pdata->timeout, reg: &reg2,
309 name: "charger timeout", units: "min");
310
311 ret = wm831x_reg_unlock(wm831x);
312 if (ret != 0) {
313 dev_err(wm831x->dev, "Failed to unlock registers: %d\n", ret);
314 return;
315 }
316
317 ret = wm831x_set_bits(wm831x, WM831X_CHARGER_CONTROL_1,
318 WM831X_CHG_ENA_MASK |
319 WM831X_CHG_FAST_MASK |
320 WM831X_CHG_ITERM_MASK,
321 val: reg1);
322 if (ret != 0)
323 dev_err(wm831x->dev, "Failed to set charger control 1: %d\n",
324 ret);
325
326 ret = wm831x_set_bits(wm831x, WM831X_CHARGER_CONTROL_2,
327 WM831X_CHG_OFF_MSK |
328 WM831X_CHG_TIME_MASK |
329 WM831X_CHG_FAST_ILIM_MASK |
330 WM831X_CHG_TRKL_ILIM_MASK |
331 WM831X_CHG_VSEL_MASK,
332 val: reg2);
333 if (ret != 0)
334 dev_err(wm831x->dev, "Failed to set charger control 2: %d\n",
335 ret);
336
337 wm831x_reg_lock(wm831x);
338}
339
340static int wm831x_bat_check_status(struct wm831x *wm831x, int *status)
341{
342 int ret;
343
344 ret = wm831x_reg_read(wm831x, WM831X_SYSTEM_STATUS);
345 if (ret < 0)
346 return ret;
347
348 if (ret & WM831X_PWR_SRC_BATT) {
349 *status = POWER_SUPPLY_STATUS_DISCHARGING;
350 return 0;
351 }
352
353 ret = wm831x_reg_read(wm831x, WM831X_CHARGER_STATUS);
354 if (ret < 0)
355 return ret;
356
357 switch (ret & WM831X_CHG_STATE_MASK) {
358 case WM831X_CHG_STATE_OFF:
359 *status = POWER_SUPPLY_STATUS_NOT_CHARGING;
360 break;
361 case WM831X_CHG_STATE_TRICKLE:
362 case WM831X_CHG_STATE_FAST:
363 *status = POWER_SUPPLY_STATUS_CHARGING;
364 break;
365
366 default:
367 *status = POWER_SUPPLY_STATUS_UNKNOWN;
368 break;
369 }
370
371 return 0;
372}
373
374static int wm831x_bat_check_type(struct wm831x *wm831x, int *type)
375{
376 int ret;
377
378 ret = wm831x_reg_read(wm831x, WM831X_CHARGER_STATUS);
379 if (ret < 0)
380 return ret;
381
382 switch (ret & WM831X_CHG_STATE_MASK) {
383 case WM831X_CHG_STATE_TRICKLE:
384 case WM831X_CHG_STATE_TRICKLE_OT:
385 *type = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
386 break;
387 case WM831X_CHG_STATE_FAST:
388 case WM831X_CHG_STATE_FAST_OT:
389 *type = POWER_SUPPLY_CHARGE_TYPE_FAST;
390 break;
391 default:
392 *type = POWER_SUPPLY_CHARGE_TYPE_NONE;
393 break;
394 }
395
396 return 0;
397}
398
399static int wm831x_bat_check_health(struct wm831x *wm831x, int *health)
400{
401 int ret;
402
403 ret = wm831x_reg_read(wm831x, WM831X_CHARGER_STATUS);
404 if (ret < 0)
405 return ret;
406
407 if (ret & WM831X_BATT_HOT_STS) {
408 *health = POWER_SUPPLY_HEALTH_OVERHEAT;
409 return 0;
410 }
411
412 if (ret & WM831X_BATT_COLD_STS) {
413 *health = POWER_SUPPLY_HEALTH_COLD;
414 return 0;
415 }
416
417 if (ret & WM831X_BATT_OV_STS) {
418 *health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
419 return 0;
420 }
421
422 switch (ret & WM831X_CHG_STATE_MASK) {
423 case WM831X_CHG_STATE_TRICKLE_OT:
424 case WM831X_CHG_STATE_FAST_OT:
425 *health = POWER_SUPPLY_HEALTH_OVERHEAT;
426 break;
427 case WM831X_CHG_STATE_DEFECTIVE:
428 *health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
429 break;
430 default:
431 *health = POWER_SUPPLY_HEALTH_GOOD;
432 break;
433 }
434
435 return 0;
436}
437
438static int wm831x_bat_get_prop(struct power_supply *psy,
439 enum power_supply_property psp,
440 union power_supply_propval *val)
441{
442 struct wm831x_power *wm831x_power = dev_get_drvdata(dev: psy->dev.parent);
443 struct wm831x *wm831x = wm831x_power->wm831x;
444 int ret = 0;
445
446 switch (psp) {
447 case POWER_SUPPLY_PROP_STATUS:
448 ret = wm831x_bat_check_status(wm831x, status: &val->intval);
449 break;
450 case POWER_SUPPLY_PROP_ONLINE:
451 ret = wm831x_power_check_online(wm831x, WM831X_PWR_SRC_BATT,
452 val);
453 break;
454 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
455 ret = wm831x_power_read_voltage(wm831x, src: WM831X_AUX_BATT, val);
456 break;
457 case POWER_SUPPLY_PROP_HEALTH:
458 ret = wm831x_bat_check_health(wm831x, health: &val->intval);
459 break;
460 case POWER_SUPPLY_PROP_CHARGE_TYPE:
461 ret = wm831x_bat_check_type(wm831x, type: &val->intval);
462 break;
463 default:
464 ret = -EINVAL;
465 break;
466 }
467
468 return ret;
469}
470
471static const enum power_supply_property wm831x_bat_props[] = {
472 POWER_SUPPLY_PROP_STATUS,
473 POWER_SUPPLY_PROP_ONLINE,
474 POWER_SUPPLY_PROP_VOLTAGE_NOW,
475 POWER_SUPPLY_PROP_HEALTH,
476 POWER_SUPPLY_PROP_CHARGE_TYPE,
477};
478
479static const char * const wm831x_bat_irqs[] = {
480 "BATT HOT",
481 "BATT COLD",
482 "BATT FAIL",
483 "OV",
484 "END",
485 "TO",
486 "MODE",
487 "START",
488};
489
490static irqreturn_t wm831x_bat_irq(int irq, void *data)
491{
492 struct wm831x_power *wm831x_power = data;
493 struct wm831x *wm831x = wm831x_power->wm831x;
494
495 dev_dbg(wm831x->dev, "Battery status changed: %d\n", irq);
496
497 /* The battery charger is autonomous so we don't need to do
498 * anything except kick user space */
499 if (wm831x_power->have_battery)
500 power_supply_changed(psy: wm831x_power->battery);
501
502 return IRQ_HANDLED;
503}
504
505
506/*********************************************************************
507 * Initialisation
508 *********************************************************************/
509
510static irqreturn_t wm831x_syslo_irq(int irq, void *data)
511{
512 struct wm831x_power *wm831x_power = data;
513 struct wm831x *wm831x = wm831x_power->wm831x;
514
515 /* Not much we can actually *do* but tell people for
516 * posterity, we're probably about to run out of power. */
517 dev_crit(wm831x->dev, "SYSVDD under voltage\n");
518
519 return IRQ_HANDLED;
520}
521
522static irqreturn_t wm831x_pwr_src_irq(int irq, void *data)
523{
524 struct wm831x_power *wm831x_power = data;
525 struct wm831x *wm831x = wm831x_power->wm831x;
526
527 dev_dbg(wm831x->dev, "Power source changed\n");
528
529 /* Just notify for everything - little harm in overnotifying. */
530 if (wm831x_power->have_battery)
531 power_supply_changed(psy: wm831x_power->battery);
532 power_supply_changed(psy: wm831x_power->usb);
533 power_supply_changed(psy: wm831x_power->wall);
534
535 return IRQ_HANDLED;
536}
537
538static int wm831x_power_probe(struct platform_device *pdev)
539{
540 struct wm831x *wm831x = dev_get_drvdata(dev: pdev->dev.parent);
541 struct wm831x_pdata *wm831x_pdata = wm831x->dev->platform_data;
542 struct wm831x_power *power;
543 int ret, irq, i;
544
545 power = devm_kzalloc(dev: &pdev->dev, size: sizeof(struct wm831x_power),
546 GFP_KERNEL);
547 if (power == NULL)
548 return -ENOMEM;
549
550 power->wm831x = wm831x;
551 platform_set_drvdata(pdev, data: power);
552
553 if (wm831x_pdata && wm831x_pdata->wm831x_num) {
554 snprintf(buf: power->wall_name, size: sizeof(power->wall_name),
555 fmt: "wm831x-wall.%d", wm831x_pdata->wm831x_num);
556 snprintf(buf: power->battery_name, size: sizeof(power->wall_name),
557 fmt: "wm831x-battery.%d", wm831x_pdata->wm831x_num);
558 snprintf(buf: power->usb_name, size: sizeof(power->wall_name),
559 fmt: "wm831x-usb.%d", wm831x_pdata->wm831x_num);
560 } else {
561 snprintf(buf: power->wall_name, size: sizeof(power->wall_name),
562 fmt: "wm831x-wall");
563 snprintf(buf: power->battery_name, size: sizeof(power->wall_name),
564 fmt: "wm831x-battery");
565 snprintf(buf: power->usb_name, size: sizeof(power->wall_name),
566 fmt: "wm831x-usb");
567 }
568
569 /* We ignore configuration failures since we can still read back
570 * the status without enabling the charger.
571 */
572 wm831x_config_battery(wm831x);
573
574 power->wall_desc.name = power->wall_name;
575 power->wall_desc.type = POWER_SUPPLY_TYPE_MAINS;
576 power->wall_desc.properties = wm831x_wall_props;
577 power->wall_desc.num_properties = ARRAY_SIZE(wm831x_wall_props);
578 power->wall_desc.get_property = wm831x_wall_get_prop;
579 power->wall = devm_power_supply_register(parent: &pdev->dev,
580 desc: &power->wall_desc,
581 NULL);
582 if (IS_ERR(ptr: power->wall)) {
583 ret = PTR_ERR(ptr: power->wall);
584 goto err;
585 }
586
587 power->usb_desc.name = power->usb_name,
588 power->usb_desc.type = POWER_SUPPLY_TYPE_USB;
589 power->usb_desc.properties = wm831x_usb_props;
590 power->usb_desc.num_properties = ARRAY_SIZE(wm831x_usb_props);
591 power->usb_desc.get_property = wm831x_usb_get_prop;
592 power->usb = devm_power_supply_register(parent: &pdev->dev,
593 desc: &power->usb_desc,
594 NULL);
595 if (IS_ERR(ptr: power->usb)) {
596 ret = PTR_ERR(ptr: power->usb);
597 goto err_wall;
598 }
599
600 ret = wm831x_reg_read(wm831x, WM831X_CHARGER_CONTROL_1);
601 if (ret < 0)
602 goto err_wall;
603 power->have_battery = ret & WM831X_CHG_ENA;
604
605 if (power->have_battery) {
606 power->battery_desc.name = power->battery_name;
607 power->battery_desc.properties = wm831x_bat_props;
608 power->battery_desc.num_properties = ARRAY_SIZE(wm831x_bat_props);
609 power->battery_desc.get_property = wm831x_bat_get_prop;
610 power->battery_desc.use_for_apm = 1;
611 power->battery = devm_power_supply_register(parent: &pdev->dev,
612 desc: &power->battery_desc,
613 NULL);
614 if (IS_ERR(ptr: power->battery)) {
615 ret = PTR_ERR(ptr: power->battery);
616 goto err_usb;
617 }
618 }
619
620 irq = wm831x_irq(wm831x, irq: platform_get_irq_byname(pdev, "SYSLO"));
621 ret = request_threaded_irq(irq, NULL, thread_fn: wm831x_syslo_irq,
622 IRQF_TRIGGER_RISING | IRQF_ONESHOT, name: "System power low",
623 dev: power);
624 if (ret != 0) {
625 dev_err(&pdev->dev, "Failed to request SYSLO IRQ %d: %d\n",
626 irq, ret);
627 goto err_battery;
628 }
629
630 irq = wm831x_irq(wm831x, irq: platform_get_irq_byname(pdev, "PWR SRC"));
631 ret = request_threaded_irq(irq, NULL, thread_fn: wm831x_pwr_src_irq,
632 IRQF_TRIGGER_RISING | IRQF_ONESHOT, name: "Power source",
633 dev: power);
634 if (ret != 0) {
635 dev_err(&pdev->dev, "Failed to request PWR SRC IRQ %d: %d\n",
636 irq, ret);
637 goto err_syslo;
638 }
639
640 for (i = 0; i < ARRAY_SIZE(wm831x_bat_irqs); i++) {
641 irq = wm831x_irq(wm831x,
642 irq: platform_get_irq_byname(pdev,
643 wm831x_bat_irqs[i]));
644 ret = request_threaded_irq(irq, NULL, thread_fn: wm831x_bat_irq,
645 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
646 name: wm831x_bat_irqs[i],
647 dev: power);
648 if (ret != 0) {
649 dev_err(&pdev->dev,
650 "Failed to request %s IRQ %d: %d\n",
651 wm831x_bat_irqs[i], irq, ret);
652 goto err_bat_irq;
653 }
654 }
655
656 power->usb_phy = devm_usb_get_phy_by_phandle(dev: &pdev->dev, phandle: "phys", index: 0);
657 ret = PTR_ERR_OR_ZERO(ptr: power->usb_phy);
658
659 switch (ret) {
660 case 0:
661 power->usb_notify.notifier_call = wm831x_usb_limit_change;
662 ret = usb_register_notifier(x: power->usb_phy, nb: &power->usb_notify);
663 if (ret) {
664 dev_err(&pdev->dev, "Failed to register notifier: %d\n",
665 ret);
666 goto err_bat_irq;
667 }
668 break;
669 case -EINVAL:
670 case -ENODEV:
671 /* ignore missing usb-phy, it's optional */
672 power->usb_phy = NULL;
673 ret = 0;
674 break;
675 default:
676 dev_err(&pdev->dev, "Failed to find USB phy: %d\n", ret);
677 fallthrough;
678 case -EPROBE_DEFER:
679 goto err_bat_irq;
680 }
681
682 return ret;
683
684err_bat_irq:
685 --i;
686 for (; i >= 0; i--) {
687 irq = platform_get_irq_byname(pdev, wm831x_bat_irqs[i]);
688 free_irq(irq, power);
689 }
690 irq = wm831x_irq(wm831x, irq: platform_get_irq_byname(pdev, "PWR SRC"));
691 free_irq(irq, power);
692err_syslo:
693 irq = wm831x_irq(wm831x, irq: platform_get_irq_byname(pdev, "SYSLO"));
694 free_irq(irq, power);
695err_battery:
696err_usb:
697err_wall:
698err:
699 return ret;
700}
701
702static void wm831x_power_remove(struct platform_device *pdev)
703{
704 struct wm831x_power *wm831x_power = platform_get_drvdata(pdev);
705 struct wm831x *wm831x = wm831x_power->wm831x;
706 int irq, i;
707
708 if (wm831x_power->usb_phy) {
709 usb_unregister_notifier(x: wm831x_power->usb_phy,
710 nb: &wm831x_power->usb_notify);
711 }
712
713 for (i = 0; i < ARRAY_SIZE(wm831x_bat_irqs); i++) {
714 irq = wm831x_irq(wm831x,
715 irq: platform_get_irq_byname(pdev,
716 wm831x_bat_irqs[i]));
717 free_irq(irq, wm831x_power);
718 }
719
720 irq = wm831x_irq(wm831x, irq: platform_get_irq_byname(pdev, "PWR SRC"));
721 free_irq(irq, wm831x_power);
722
723 irq = wm831x_irq(wm831x, irq: platform_get_irq_byname(pdev, "SYSLO"));
724 free_irq(irq, wm831x_power);
725}
726
727static struct platform_driver wm831x_power_driver = {
728 .probe = wm831x_power_probe,
729 .remove = wm831x_power_remove,
730 .driver = {
731 .name = "wm831x-power",
732 },
733};
734
735module_platform_driver(wm831x_power_driver);
736
737MODULE_DESCRIPTION("Power supply driver for WM831x PMICs");
738MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
739MODULE_LICENSE("GPL");
740MODULE_ALIAS("platform:wm831x-power");
741

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