xref: /freebsd/sys/arm/allwinner/axp81x.c (revision 64a0982bee3db2236df43357e70ce8dddbc21d48) 
1 /*-
2  * Copyright (c) 2016 Jared McNeill <jmcneill@invisible.ca>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
19  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
21  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
22  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD$
27  */
28 
29 /*
30  * X-Powers AXP813/818 PMU for Allwinner SoCs
31  */
32 
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
35 
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/eventhandler.h>
39 #include <sys/bus.h>
40 #include <sys/rman.h>
41 #include <sys/kernel.h>
42 #include <sys/reboot.h>
43 #include <sys/gpio.h>
44 #include <sys/module.h>
45 #include <machine/bus.h>
46 
47 #include <dev/iicbus/iicbus.h>
48 #include <dev/iicbus/iiconf.h>
49 
50 #include <dev/gpio/gpiobusvar.h>
51 
52 #include <dev/ofw/ofw_bus.h>
53 #include <dev/ofw/ofw_bus_subr.h>
54 
55 #include <dev/extres/regulator/regulator.h>
56 
57 #include "gpio_if.h"
58 #include "iicbus_if.h"
59 #include "regdev_if.h"
60 
61 MALLOC_DEFINE(M_AXP81X_REG, "AXP81x regulator", "AXP81x power regulator");
62 
63 #define	AXP_ICTYPE		0x03
64 #define	AXP_POWERCTL1		0x10
65 #define	 AXP_POWERCTL1_DCDC2	(1 << 1)
66 #define	AXP_POWERCTL2		0x12
67 #define	 AXP_POWERCTL2_DC1SW	(1 << 7)
68 #define	AXP_VOLTCTL_DCDC2	0x21
69 #define	 AXP_VOLTCTL_STATUS	(1 << 7)
70 #define	 AXP_VOLTCTL_MASK	0x7f
71 #define	AXP_POWERBAT		0x32
72 #define	 AXP_POWERBAT_SHUTDOWN	(1 << 7)
73 #define	AXP_IRQEN1		0x40
74 #define	AXP_IRQEN2		0x41
75 #define	AXP_IRQEN3		0x42
76 #define	AXP_IRQEN4		0x43
77 #define	AXP_IRQEN5		0x44
78 #define	 AXP_IRQEN5_POKSIRQ	(1 << 4)
79 #define	AXP_IRQEN6		0x45
80 #define	AXP_IRQSTAT5		0x4c
81 #define	 AXP_IRQSTAT5_POKSIRQ	(1 << 4)
82 #define	AXP_GPIO0_CTRL		0x90
83 #define	AXP_GPIO1_CTRL		0x92
84 #define	 AXP_GPIO_FUNC		(0x7 << 0)
85 #define	 AXP_GPIO_FUNC_SHIFT	0
86 #define	 AXP_GPIO_FUNC_DRVLO	0
87 #define	 AXP_GPIO_FUNC_DRVHI	1
88 #define	 AXP_GPIO_FUNC_INPUT	2
89 #define	AXP_GPIO_SIGBIT		0x94
90 #define	AXP_GPIO_PD		0x97
91 
92 static const struct {
93 	const char *name;
94 	uint8_t	ctrl_reg;
95 } axp81x_pins[] = {
96 	{ "GPIO0", AXP_GPIO0_CTRL },
97 	{ "GPIO1", AXP_GPIO1_CTRL },
98 };
99 
100 static struct ofw_compat_data compat_data[] = {
101 	{ "x-powers,axp813",			1 },
102 	{ "x-powers,axp818",			1 },
103 	{ NULL,					0 }
104 };
105 
106 static struct resource_spec axp81x_spec[] = {
107 	{ SYS_RES_IRQ,		0,	RF_ACTIVE },
108 	{ -1, 0 }
109 };
110 
111 struct axp81x_regdef {
112 	intptr_t		id;
113 	char			*name;
114 	char			*supply_name;
115 	uint8_t			enable_reg;
116 	uint8_t			enable_mask;
117 	uint8_t			voltage_reg;
118 	int			voltage_min;
119 	int			voltage_max;
120 	int			voltage_step1;
121 	int			voltage_nstep1;
122 	int			voltage_step2;
123 	int			voltage_nstep2;
124 };
125 
126 enum axp81x_reg_id {
127 	AXP81X_REG_ID_DC1SW,
128 	AXP81X_REG_ID_DCDC2,
129 };
130 
131 static struct axp81x_regdef axp81x_regdefs[] = {
132 	{
133 		.id = AXP81X_REG_ID_DC1SW,
134 		.name = "dc1sw",
135 		.enable_reg = AXP_POWERCTL2,
136 		.enable_mask = AXP_POWERCTL2_DC1SW,
137 	},
138 	{
139 		.id = AXP81X_REG_ID_DCDC2,
140 		.name = "dcdc2",
141 		.enable_reg = AXP_POWERCTL1,
142 		.enable_mask = AXP_POWERCTL1_DCDC2,
143 		.voltage_reg = AXP_VOLTCTL_DCDC2,
144 		.voltage_min = 500,
145 		.voltage_max = 1300,
146 		.voltage_step1 = 10,
147 		.voltage_nstep1 = 70,
148 		.voltage_step2 = 20,
149 		.voltage_nstep2 = 5,
150 	},
151 };
152 
153 struct axp81x_softc;
154 
155 struct axp81x_reg_sc {
156 	struct regnode		*regnode;
157 	device_t		base_dev;
158 	struct axp81x_regdef	*def;
159 	phandle_t		xref;
160 	struct regnode_std_param *param;
161 };
162 
163 struct axp81x_softc {
164 	struct resource		*res;
165 	uint16_t		addr;
166 	void			*ih;
167 	device_t		gpiodev;
168 	struct mtx		mtx;
169 	int			busy;
170 
171 	/* Regulators */
172 	struct axp81x_reg_sc	**regs;
173 	int			nregs;
174 };
175 
176 #define	AXP_LOCK(sc)	mtx_lock(&(sc)->mtx)
177 #define	AXP_UNLOCK(sc)	mtx_unlock(&(sc)->mtx)
178 
179 static int
180 axp81x_read(device_t dev, uint8_t reg, uint8_t *data, uint8_t size)
181 {
182 	struct axp81x_softc *sc;
183 	struct iic_msg msg[2];
184 
185 	sc = device_get_softc(dev);
186 
187 	msg[0].slave = sc->addr;
188 	msg[0].flags = IIC_M_WR;
189 	msg[0].len = 1;
190 	msg[0].buf = &reg;
191 
192 	msg[1].slave = sc->addr;
193 	msg[1].flags = IIC_M_RD;
194 	msg[1].len = size;
195 	msg[1].buf = data;
196 
197 	return (iicbus_transfer(dev, msg, 2));
198 }
199 
200 static int
201 axp81x_write(device_t dev, uint8_t reg, uint8_t val)
202 {
203 	struct axp81x_softc *sc;
204 	struct iic_msg msg[2];
205 
206 	sc = device_get_softc(dev);
207 
208 	msg[0].slave = sc->addr;
209 	msg[0].flags = IIC_M_WR;
210 	msg[0].len = 1;
211 	msg[0].buf = &reg;
212 
213 	msg[1].slave = sc->addr;
214 	msg[1].flags = IIC_M_WR;
215 	msg[1].len = 1;
216 	msg[1].buf = &val;
217 
218 	return (iicbus_transfer(dev, msg, 2));
219 }
220 
221 static int
222 axp81x_regnode_init(struct regnode *regnode)
223 {
224 	return (0);
225 }
226 
227 static int
228 axp81x_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
229 {
230 	struct axp81x_reg_sc *sc;
231 	uint8_t val;
232 
233 	sc = regnode_get_softc(regnode);
234 
235 	axp81x_read(sc->base_dev, sc->def->enable_reg, &val, 1);
236 	if (enable)
237 		val |= sc->def->enable_mask;
238 	else
239 		val &= ~sc->def->enable_mask;
240 	axp81x_write(sc->base_dev, sc->def->enable_reg, val);
241 
242 	*udelay = 0;
243 
244 	return (0);
245 }
246 
247 static void
248 axp81x_regnode_reg_to_voltage(struct axp81x_reg_sc *sc, uint8_t val, int *uv)
249 {
250 	if (val < sc->def->voltage_nstep1)
251 		*uv = sc->def->voltage_min + val * sc->def->voltage_step1;
252 	else
253 		*uv = sc->def->voltage_min +
254 		    (sc->def->voltage_nstep1 * sc->def->voltage_step1) +
255 		    ((val - sc->def->voltage_nstep1) * sc->def->voltage_step2);
256 	*uv *= 1000;
257 }
258 
259 static int
260 axp81x_regnode_voltage_to_reg(struct axp81x_reg_sc *sc, int min_uvolt,
261     int max_uvolt, uint8_t *val)
262 {
263 	uint8_t nval;
264 	int nstep, uvolt;
265 
266 	nval = 0;
267 	uvolt = sc->def->voltage_min * 1000;
268 
269 	for (nstep = 0; nstep < sc->def->voltage_nstep1 && uvolt < min_uvolt;
270 	     nstep++) {
271 		++nval;
272 		uvolt += (sc->def->voltage_step1 * 1000);
273 	}
274 	for (nstep = 0; nstep < sc->def->voltage_nstep2 && uvolt < min_uvolt;
275 	     nstep++) {
276 		++nval;
277 		uvolt += (sc->def->voltage_step2 * 1000);
278 	}
279 	if (uvolt > max_uvolt)
280 		return (EINVAL);
281 
282 	*val = nval;
283 	return (0);
284 }
285 
286 static int
287 axp81x_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
288     int max_uvolt, int *udelay)
289 {
290 	struct axp81x_reg_sc *sc;
291 	uint8_t val;
292 
293 	sc = regnode_get_softc(regnode);
294 
295 	if (!sc->def->voltage_step1 || !sc->def->voltage_step2)
296 		return (ENXIO);
297 
298 	if (axp81x_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
299 		return (ERANGE);
300 
301 	axp81x_write(sc->base_dev, sc->def->voltage_reg, val);
302 
303 	*udelay = 0;
304 
305 	return (0);
306 }
307 
308 static int
309 axp81x_regnode_get_voltage(struct regnode *regnode, int *uvolt)
310 {
311 	struct axp81x_reg_sc *sc;
312 	uint8_t val;
313 
314 	sc = regnode_get_softc(regnode);
315 
316 	if (!sc->def->voltage_step1 || !sc->def->voltage_step2)
317 		return (ENXIO);
318 
319 	axp81x_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
320 	axp81x_regnode_reg_to_voltage(sc, val & AXP_VOLTCTL_MASK, uvolt);
321 
322 	return (0);
323 }
324 
325 static regnode_method_t axp81x_regnode_methods[] = {
326 	/* Regulator interface */
327 	REGNODEMETHOD(regnode_init,		axp81x_regnode_init),
328 	REGNODEMETHOD(regnode_enable,		axp81x_regnode_enable),
329 	REGNODEMETHOD(regnode_set_voltage,	axp81x_regnode_set_voltage),
330 	REGNODEMETHOD(regnode_get_voltage,	axp81x_regnode_get_voltage),
331 	REGNODEMETHOD_END
332 };
333 DEFINE_CLASS_1(axp81x_regnode, axp81x_regnode_class, axp81x_regnode_methods,
334     sizeof(struct axp81x_reg_sc), regnode_class);
335 
336 static void
337 axp81x_shutdown(void *devp, int howto)
338 {
339 	device_t dev;
340 
341 	if ((howto & RB_POWEROFF) == 0)
342 		return;
343 
344 	dev = devp;
345 
346 	if (bootverbose)
347 		device_printf(dev, "Shutdown AXP81x\n");
348 
349 	axp81x_write(dev, AXP_POWERBAT, AXP_POWERBAT_SHUTDOWN);
350 }
351 
352 static void
353 axp81x_intr(void *arg)
354 {
355 	struct axp81x_softc *sc;
356 	device_t dev;
357 	uint8_t val;
358 	int error;
359 
360 	dev = arg;
361 	sc = device_get_softc(dev);
362 
363 	error = axp81x_read(dev, AXP_IRQSTAT5, &val, 1);
364 	if (error != 0)
365 		return;
366 
367 	if (val != 0) {
368 		if ((val & AXP_IRQSTAT5_POKSIRQ) != 0) {
369 			if (bootverbose)
370 				device_printf(dev, "Power button pressed\n");
371 			shutdown_nice(RB_POWEROFF);
372 		}
373 		/* Acknowledge */
374 		axp81x_write(dev, AXP_IRQSTAT5, val);
375 	}
376 }
377 
378 static device_t
379 axp81x_gpio_get_bus(device_t dev)
380 {
381 	struct axp81x_softc *sc;
382 
383 	sc = device_get_softc(dev);
384 
385 	return (sc->gpiodev);
386 }
387 
388 static int
389 axp81x_gpio_pin_max(device_t dev, int *maxpin)
390 {
391 	*maxpin = nitems(axp81x_pins) - 1;
392 
393 	return (0);
394 }
395 
396 static int
397 axp81x_gpio_pin_getname(device_t dev, uint32_t pin, char *name)
398 {
399 	if (pin >= nitems(axp81x_pins))
400 		return (EINVAL);
401 
402 	snprintf(name, GPIOMAXNAME, "%s", axp81x_pins[pin].name);
403 
404 	return (0);
405 }
406 
407 static int
408 axp81x_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps)
409 {
410 	if (pin >= nitems(axp81x_pins))
411 		return (EINVAL);
412 
413 	*caps = GPIO_PIN_INPUT | GPIO_PIN_OUTPUT;
414 
415 	return (0);
416 }
417 
418 static int
419 axp81x_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags)
420 {
421 	struct axp81x_softc *sc;
422 	uint8_t data, func;
423 	int error;
424 
425 	if (pin >= nitems(axp81x_pins))
426 		return (EINVAL);
427 
428 	sc = device_get_softc(dev);
429 
430 	AXP_LOCK(sc);
431 	error = axp81x_read(dev, axp81x_pins[pin].ctrl_reg, &data, 1);
432 	if (error == 0) {
433 		func = (data & AXP_GPIO_FUNC) >> AXP_GPIO_FUNC_SHIFT;
434 		if (func == AXP_GPIO_FUNC_INPUT)
435 			*flags = GPIO_PIN_INPUT;
436 		else if (func == AXP_GPIO_FUNC_DRVLO ||
437 		    func == AXP_GPIO_FUNC_DRVHI)
438 			*flags = GPIO_PIN_OUTPUT;
439 		else
440 			*flags = 0;
441 	}
442 	AXP_UNLOCK(sc);
443 
444 	return (error);
445 }
446 
447 static int
448 axp81x_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags)
449 {
450 	struct axp81x_softc *sc;
451 	uint8_t data;
452 	int error;
453 
454 	if (pin >= nitems(axp81x_pins))
455 		return (EINVAL);
456 
457 	sc = device_get_softc(dev);
458 
459 	AXP_LOCK(sc);
460 	error = axp81x_read(dev, axp81x_pins[pin].ctrl_reg, &data, 1);
461 	if (error == 0) {
462 		data &= ~AXP_GPIO_FUNC;
463 		if ((flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) != 0) {
464 			if ((flags & GPIO_PIN_OUTPUT) == 0)
465 				data |= AXP_GPIO_FUNC_INPUT;
466 		}
467 		error = axp81x_write(dev, axp81x_pins[pin].ctrl_reg, data);
468 	}
469 	AXP_UNLOCK(sc);
470 
471 	return (error);
472 }
473 
474 static int
475 axp81x_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val)
476 {
477 	struct axp81x_softc *sc;
478 	uint8_t data, func;
479 	int error;
480 
481 	if (pin >= nitems(axp81x_pins))
482 		return (EINVAL);
483 
484 	sc = device_get_softc(dev);
485 
486 	AXP_LOCK(sc);
487 	error = axp81x_read(dev, axp81x_pins[pin].ctrl_reg, &data, 1);
488 	if (error == 0) {
489 		func = (data & AXP_GPIO_FUNC) >> AXP_GPIO_FUNC_SHIFT;
490 		switch (func) {
491 		case AXP_GPIO_FUNC_DRVLO:
492 			*val = 0;
493 			break;
494 		case AXP_GPIO_FUNC_DRVHI:
495 			*val = 1;
496 			break;
497 		case AXP_GPIO_FUNC_INPUT:
498 			error = axp81x_read(dev, AXP_GPIO_SIGBIT, &data, 1);
499 			if (error == 0)
500 				*val = (data & (1 << pin)) ? 1 : 0;
501 			break;
502 		default:
503 			error = EIO;
504 			break;
505 		}
506 	}
507 	AXP_UNLOCK(sc);
508 
509 	return (error);
510 }
511 
512 static int
513 axp81x_gpio_pin_set(device_t dev, uint32_t pin, unsigned int val)
514 {
515 	struct axp81x_softc *sc;
516 	uint8_t data, func;
517 	int error;
518 
519 	if (pin >= nitems(axp81x_pins))
520 		return (EINVAL);
521 
522 	sc = device_get_softc(dev);
523 
524 	AXP_LOCK(sc);
525 	error = axp81x_read(dev, axp81x_pins[pin].ctrl_reg, &data, 1);
526 	if (error == 0) {
527 		func = (data & AXP_GPIO_FUNC) >> AXP_GPIO_FUNC_SHIFT;
528 		switch (func) {
529 		case AXP_GPIO_FUNC_DRVLO:
530 		case AXP_GPIO_FUNC_DRVHI:
531 			data &= ~AXP_GPIO_FUNC;
532 			data |= (val << AXP_GPIO_FUNC_SHIFT);
533 			break;
534 		default:
535 			error = EIO;
536 			break;
537 		}
538 	}
539 	if (error == 0)
540 		error = axp81x_write(dev, axp81x_pins[pin].ctrl_reg, data);
541 	AXP_UNLOCK(sc);
542 
543 	return (error);
544 }
545 
546 
547 static int
548 axp81x_gpio_pin_toggle(device_t dev, uint32_t pin)
549 {
550 	struct axp81x_softc *sc;
551 	uint8_t data, func;
552 	int error;
553 
554 	if (pin >= nitems(axp81x_pins))
555 		return (EINVAL);
556 
557 	sc = device_get_softc(dev);
558 
559 	AXP_LOCK(sc);
560 	error = axp81x_read(dev, axp81x_pins[pin].ctrl_reg, &data, 1);
561 	if (error == 0) {
562 		func = (data & AXP_GPIO_FUNC) >> AXP_GPIO_FUNC_SHIFT;
563 		switch (func) {
564 		case AXP_GPIO_FUNC_DRVLO:
565 			data &= ~AXP_GPIO_FUNC;
566 			data |= (AXP_GPIO_FUNC_DRVHI << AXP_GPIO_FUNC_SHIFT);
567 			break;
568 		case AXP_GPIO_FUNC_DRVHI:
569 			data &= ~AXP_GPIO_FUNC;
570 			data |= (AXP_GPIO_FUNC_DRVLO << AXP_GPIO_FUNC_SHIFT);
571 			break;
572 		default:
573 			error = EIO;
574 			break;
575 		}
576 	}
577 	if (error == 0)
578 		error = axp81x_write(dev, axp81x_pins[pin].ctrl_reg, data);
579 	AXP_UNLOCK(sc);
580 
581 	return (error);
582 }
583 
584 static int
585 axp81x_gpio_map_gpios(device_t bus, phandle_t dev, phandle_t gparent,
586     int gcells, pcell_t *gpios, uint32_t *pin, uint32_t *flags)
587 {
588 	if (gpios[0] >= nitems(axp81x_pins))
589 		return (EINVAL);
590 
591 	*pin = gpios[0];
592 	*flags = gpios[1];
593 
594 	return (0);
595 }
596 
597 static phandle_t
598 axp81x_get_node(device_t dev, device_t bus)
599 {
600 	return (ofw_bus_get_node(dev));
601 }
602 
603 static struct axp81x_reg_sc *
604 axp81x_reg_attach(device_t dev, phandle_t node,
605     struct axp81x_regdef *def)
606 {
607 	struct axp81x_reg_sc *reg_sc;
608 	struct regnode_init_def initdef;
609 	struct regnode *regnode;
610 
611 	memset(&initdef, 0, sizeof(initdef));
612 	regulator_parse_ofw_stdparam(dev, node, &initdef);
613 	if (initdef.std_param.min_uvolt == 0)
614 		initdef.std_param.min_uvolt = def->voltage_min * 1000;
615 	if (initdef.std_param.max_uvolt == 0)
616 		initdef.std_param.max_uvolt = def->voltage_max * 1000;
617 	initdef.id = def->id;
618 	initdef.ofw_node = node;
619 	regnode = regnode_create(dev, &axp81x_regnode_class, &initdef);
620 	if (regnode == NULL) {
621 		device_printf(dev, "cannot create regulator\n");
622 		return (NULL);
623 	}
624 
625 	reg_sc = regnode_get_softc(regnode);
626 	reg_sc->regnode = regnode;
627 	reg_sc->base_dev = dev;
628 	reg_sc->def = def;
629 	reg_sc->xref = OF_xref_from_node(node);
630 	reg_sc->param = regnode_get_stdparam(regnode);
631 
632 	regnode_register(regnode);
633 
634 	return (reg_sc);
635 }
636 
637 static int
638 axp81x_regdev_map(device_t dev, phandle_t xref, int ncells, pcell_t *cells,
639     intptr_t *num)
640 {
641 	struct axp81x_softc *sc;
642 	int i;
643 
644 	sc = device_get_softc(dev);
645 	for (i = 0; i < sc->nregs; i++) {
646 		if (sc->regs[i] == NULL)
647 			continue;
648 		if (sc->regs[i]->xref == xref) {
649 			*num = sc->regs[i]->def->id;
650 			return (0);
651 		}
652 	}
653 
654 	return (ENXIO);
655 }
656 
657 static int
658 axp81x_probe(device_t dev)
659 {
660 	if (!ofw_bus_status_okay(dev))
661 		return (ENXIO);
662 
663 	if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
664 		return (ENXIO);
665 
666 	device_set_desc(dev, "X-Powers AXP81x Power Management Unit");
667 
668 	return (BUS_PROBE_DEFAULT);
669 }
670 
671 static int
672 axp81x_attach(device_t dev)
673 {
674 	struct axp81x_softc *sc;
675 	struct axp81x_reg_sc *reg;
676 	uint8_t chip_id;
677 	phandle_t rnode, child;
678 	int error, i;
679 
680 	sc = device_get_softc(dev);
681 
682 	sc->addr = iicbus_get_addr(dev);
683 	mtx_init(&sc->mtx, device_get_nameunit(dev), NULL, MTX_DEF);
684 
685 	error = bus_alloc_resources(dev, axp81x_spec, &sc->res);
686 	if (error != 0) {
687 		device_printf(dev, "cannot allocate resources for device\n");
688 		return (error);
689 	}
690 
691 	if (bootverbose) {
692 		axp81x_read(dev, AXP_ICTYPE, &chip_id, 1);
693 		device_printf(dev, "chip ID 0x%02x\n", chip_id);
694 	}
695 
696 	sc->nregs = nitems(axp81x_regdefs);
697 	sc->regs = malloc(sizeof(struct axp81x_reg_sc *) * sc->nregs,
698 	    M_AXP81X_REG, M_WAITOK | M_ZERO);
699 
700 	/* Attach known regulators that exist in the DT */
701 	rnode = ofw_bus_find_child(ofw_bus_get_node(dev), "regulators");
702 	if (rnode > 0) {
703 		for (i = 0; i < sc->nregs; i++) {
704 			child = ofw_bus_find_child(rnode,
705 			    axp81x_regdefs[i].name);
706 			if (child == 0)
707 				continue;
708 			reg = axp81x_reg_attach(dev, child, &axp81x_regdefs[i]);
709 			if (reg == NULL) {
710 				device_printf(dev,
711 				    "cannot attach regulator %s\n",
712 				    axp81x_regdefs[i].name);
713 				return (ENXIO);
714 			}
715 			sc->regs[i] = reg;
716 		}
717 	}
718 
719 	/* Enable IRQ on short power key press */
720 	axp81x_write(dev, AXP_IRQEN1, 0);
721 	axp81x_write(dev, AXP_IRQEN2, 0);
722 	axp81x_write(dev, AXP_IRQEN3, 0);
723 	axp81x_write(dev, AXP_IRQEN4, 0);
724 	axp81x_write(dev, AXP_IRQEN5, AXP_IRQEN5_POKSIRQ);
725 	axp81x_write(dev, AXP_IRQEN6, 0);
726 
727 	/* Install interrupt handler */
728 	error = bus_setup_intr(dev, sc->res, INTR_TYPE_MISC | INTR_MPSAFE,
729 	    NULL, axp81x_intr, dev, &sc->ih);
730 	if (error != 0) {
731 		device_printf(dev, "cannot setup interrupt handler\n");
732 		return (error);
733 	}
734 
735 	EVENTHANDLER_REGISTER(shutdown_final, axp81x_shutdown, dev,
736 	    SHUTDOWN_PRI_LAST);
737 
738 	sc->gpiodev = gpiobus_attach_bus(dev);
739 
740 	return (0);
741 }
742 
743 static device_method_t axp81x_methods[] = {
744 	/* Device interface */
745 	DEVMETHOD(device_probe,		axp81x_probe),
746 	DEVMETHOD(device_attach,	axp81x_attach),
747 
748 	/* GPIO interface */
749 	DEVMETHOD(gpio_get_bus,		axp81x_gpio_get_bus),
750 	DEVMETHOD(gpio_pin_max,		axp81x_gpio_pin_max),
751 	DEVMETHOD(gpio_pin_getname,	axp81x_gpio_pin_getname),
752 	DEVMETHOD(gpio_pin_getcaps,	axp81x_gpio_pin_getcaps),
753 	DEVMETHOD(gpio_pin_getflags,	axp81x_gpio_pin_getflags),
754 	DEVMETHOD(gpio_pin_setflags,	axp81x_gpio_pin_setflags),
755 	DEVMETHOD(gpio_pin_get,		axp81x_gpio_pin_get),
756 	DEVMETHOD(gpio_pin_set,		axp81x_gpio_pin_set),
757 	DEVMETHOD(gpio_pin_toggle,	axp81x_gpio_pin_toggle),
758 	DEVMETHOD(gpio_map_gpios,	axp81x_gpio_map_gpios),
759 
760 	/* Regdev interface */
761 	DEVMETHOD(regdev_map,		axp81x_regdev_map),
762 
763 	/* OFW bus interface */
764 	DEVMETHOD(ofw_bus_get_node,	axp81x_get_node),
765 
766 	DEVMETHOD_END
767 };
768 
769 static driver_t axp81x_driver = {
770 	"axp81x_pmu",
771 	axp81x_methods,
772 	sizeof(struct axp81x_softc),
773 };
774 
775 static devclass_t axp81x_devclass;
776 extern devclass_t ofwgpiobus_devclass, gpioc_devclass;
777 extern driver_t ofw_gpiobus_driver, gpioc_driver;
778 
779 EARLY_DRIVER_MODULE(axp81x, iicbus, axp81x_driver, axp81x_devclass, 0, 0,
780     BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LAST);
781 EARLY_DRIVER_MODULE(ofw_gpiobus, axp81x_pmu, ofw_gpiobus_driver,
782     ofwgpiobus_devclass, 0, 0, BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LAST);
783 DRIVER_MODULE(gpioc, axp81x_pmu, gpioc_driver, gpioc_devclass, 0, 0);
784 MODULE_VERSION(axp81x, 1);
785 MODULE_DEPEND(axp81x, iicbus, 1, 1, 1);
786