2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2018 Emmanuel Vadot <manu@FreeBSD.org>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 #include <sys/cdefs.h>
29 __FBSDID("$FreeBSD$");
31 #include <sys/param.h>
33 #include <sys/kernel.h>
34 #include <sys/module.h>
35 #include <sys/mutex.h>
37 #include <machine/bus.h>
39 #include <dev/iicbus/iiconf.h>
40 #include <dev/iicbus/iicbus.h>
42 #include <dev/ofw/ofw_bus.h>
43 #include <dev/ofw/ofw_bus_subr.h>
45 #include <dev/extres/regulator/regulator.h>
47 #include <arm64/rockchip/rk805reg.h>
49 #include "regdev_if.h"
51 MALLOC_DEFINE(M_RK805_REG, "RK805 regulator", "RK805 power regulator");
53 /* #define dprintf(sc, format, arg...) device_printf(sc->base_dev, "%s: " format, __func__, arg) */
54 #define dprintf(sc, format, arg...)
61 static struct ofw_compat_data compat_data[] = {
62 {"rockchip,rk805", RK805},
63 {"rockchip,rk808", RK808},
81 struct regnode *regnode;
83 struct rk805_regdef *def;
85 struct regnode_std_param *param;
89 TAILQ_ENTRY(reg_list) next;
90 struct rk805_reg_sc *reg;
96 struct resource * res[1];
98 struct intr_config_hook intr_hook;
99 enum rk_pmic_type type;
101 TAILQ_HEAD(, reg_list) regs;
105 static int rk805_regnode_status(struct regnode *regnode, int *status);
106 static int rk805_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
107 int max_uvolt, int *udelay);
108 static int rk805_regnode_get_voltage(struct regnode *regnode, int *uvolt);
110 static struct rk805_regdef rk805_regdefs[] = {
114 .enable_reg = RK805_DCDC_EN,
116 .voltage_reg = RK805_DCDC1_ON_VSEL,
117 .voltage_mask = 0x3F,
118 .voltage_min = 712500,
119 .voltage_max = 1450000,
120 .voltage_step = 12500,
126 .enable_reg = RK805_DCDC_EN,
128 .voltage_reg = RK805_DCDC2_ON_VSEL,
129 .voltage_mask = 0x3F,
130 .voltage_min = 712500,
131 .voltage_max = 1450000,
132 .voltage_step = 12500,
138 .enable_reg = RK805_DCDC_EN,
144 .enable_reg = RK805_DCDC_EN,
146 .voltage_reg = RK805_DCDC4_ON_VSEL,
147 .voltage_mask = 0x3F,
148 .voltage_min = 800000,
149 .voltage_max = 3500000,
150 .voltage_step = 100000,
156 .enable_reg = RK805_LDO_EN,
158 .voltage_reg = RK805_LDO1_ON_VSEL,
159 .voltage_mask = 0x1F,
160 .voltage_min = 800000,
161 .voltage_max = 3400000,
162 .voltage_step = 100000,
168 .enable_reg = RK805_LDO_EN,
170 .voltage_reg = RK805_LDO2_ON_VSEL,
171 .voltage_mask = 0x1F,
172 .voltage_min = 800000,
173 .voltage_max = 3400000,
174 .voltage_step = 100000,
180 .enable_reg = RK805_LDO_EN,
182 .voltage_reg = RK805_LDO3_ON_VSEL,
183 .voltage_mask = 0x1F,
184 .voltage_min = 800000,
185 .voltage_max = 3400000,
186 .voltage_step = 100000,
191 static struct rk805_regdef rk808_regdefs[] = {
195 .enable_reg = RK805_DCDC_EN,
197 .voltage_reg = RK805_DCDC1_ON_VSEL,
198 .voltage_mask = 0x3F,
199 .voltage_min = 712500,
200 .voltage_max = 1500000,
201 .voltage_step = 12500,
207 .enable_reg = RK805_DCDC_EN,
209 .voltage_reg = RK805_DCDC2_ON_VSEL,
210 .voltage_mask = 0x3F,
211 .voltage_min = 712500,
212 .voltage_max = 1500000,
213 .voltage_step = 12500,
217 /* BUCK3 voltage is calculated based on external resistor */
220 .enable_reg = RK805_DCDC_EN,
226 .enable_reg = RK805_DCDC_EN,
228 .voltage_reg = RK805_DCDC4_ON_VSEL,
230 .voltage_min = 1800000,
231 .voltage_max = 3300000,
232 .voltage_step = 100000,
238 .enable_reg = RK808_LDO_EN,
240 .voltage_reg = RK805_LDO1_ON_VSEL,
241 .voltage_mask = 0x1F,
242 .voltage_min = 1800000,
243 .voltage_max = 3400000,
244 .voltage_step = 100000,
250 .enable_reg = RK808_LDO_EN,
252 .voltage_reg = RK805_LDO2_ON_VSEL,
253 .voltage_mask = 0x1F,
254 .voltage_min = 1800000,
255 .voltage_max = 3400000,
256 .voltage_step = 100000,
262 .enable_reg = RK808_LDO_EN,
264 .voltage_reg = RK805_LDO3_ON_VSEL,
266 .voltage_min = 800000,
267 .voltage_max = 2500000,
268 .voltage_step = 100000,
274 .enable_reg = RK808_LDO_EN,
276 .voltage_reg = RK808_LDO4_ON_VSEL,
277 .voltage_mask = 0x1F,
278 .voltage_min = 1800000,
279 .voltage_max = 3400000,
280 .voltage_step = 100000,
286 .enable_reg = RK808_LDO_EN,
288 .voltage_reg = RK808_LDO5_ON_VSEL,
289 .voltage_mask = 0x1F,
290 .voltage_min = 1800000,
291 .voltage_max = 3400000,
292 .voltage_step = 100000,
298 .enable_reg = RK808_LDO_EN,
300 .voltage_reg = RK808_LDO6_ON_VSEL,
301 .voltage_mask = 0x1F,
302 .voltage_min = 800000,
303 .voltage_max = 2500000,
304 .voltage_step = 100000,
310 .enable_reg = RK808_LDO_EN,
312 .voltage_reg = RK808_LDO7_ON_VSEL,
313 .voltage_mask = 0x1F,
314 .voltage_min = 800000,
315 .voltage_max = 2500000,
316 .voltage_step = 100000,
322 .enable_reg = RK808_LDO_EN,
324 .voltage_reg = RK808_LDO8_ON_VSEL,
325 .voltage_mask = 0x1F,
326 .voltage_min = 1800000,
327 .voltage_max = 3400000,
328 .voltage_step = 100000,
333 .name = "SWITCH_REG1",
334 .enable_reg = RK805_DCDC_EN,
336 .voltage_min = 3000000,
337 .voltage_max = 3000000,
341 .name = "SWITCH_REG2",
342 .enable_reg = RK805_DCDC_EN,
344 .voltage_min = 3000000,
345 .voltage_max = 3000000,
350 rk805_read(device_t dev, uint8_t reg, uint8_t *data, uint8_t size)
354 err = iicdev_readfrom(dev, reg, data, size, IIC_INTRWAIT);
359 rk805_write(device_t dev, uint8_t reg, uint8_t data)
362 return (iicdev_writeto(dev, reg, &data, 1, IIC_INTRWAIT));
366 rk805_regnode_init(struct regnode *regnode)
368 struct rk805_reg_sc *sc;
369 struct regnode_std_param *param;
370 int rv, udelay, uvolt, status;
372 sc = regnode_get_softc(regnode);
373 dprintf(sc, "Regulator %s init called\n", sc->def->name);
374 param = regnode_get_stdparam(regnode);
375 if (param->min_uvolt == 0)
378 /* Check that the regulator is preset to the correct voltage */
379 rv = rk805_regnode_get_voltage(regnode, &uvolt);
383 if (uvolt >= param->min_uvolt && uvolt <= param->max_uvolt)
386 * Set the regulator at the correct voltage if it is not enabled.
387 * Do not enable it, this is will be done either by a
388 * consumer or by regnode_set_constraint if boot_on is true
390 rv = rk805_regnode_status(regnode, &status);
391 if (rv != 0 || status == REGULATOR_STATUS_ENABLED)
394 rv = rk805_regnode_set_voltage(regnode, param->min_uvolt,
395 param->max_uvolt, &udelay);
403 rk805_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
405 struct rk805_reg_sc *sc;
408 sc = regnode_get_softc(regnode);
410 dprintf(sc, "%sabling regulator %s\n",
411 enable ? "En" : "Dis",
413 rk805_read(sc->base_dev, sc->def->enable_reg, &val, 1);
415 val |= sc->def->enable_mask;
417 val &= ~sc->def->enable_mask;
418 rk805_write(sc->base_dev, sc->def->enable_reg, val);
426 rk805_regnode_reg_to_voltage(struct rk805_reg_sc *sc, uint8_t val, int *uv)
428 if (val < sc->def->voltage_nstep)
429 *uv = sc->def->voltage_min + val * sc->def->voltage_step;
431 *uv = sc->def->voltage_min +
432 (sc->def->voltage_nstep * sc->def->voltage_step);
436 rk805_regnode_voltage_to_reg(struct rk805_reg_sc *sc, int min_uvolt,
437 int max_uvolt, uint8_t *val)
443 uvolt = sc->def->voltage_min;
445 for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
448 uvolt += sc->def->voltage_step;
450 if (uvolt > max_uvolt)
458 rk805_regnode_status(struct regnode *regnode, int *status)
460 struct rk805_reg_sc *sc;
463 sc = regnode_get_softc(regnode);
466 rk805_read(sc->base_dev, sc->def->enable_reg, &val, 1);
467 if (val & sc->def->enable_mask)
468 *status = REGULATOR_STATUS_ENABLED;
474 rk805_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
475 int max_uvolt, int *udelay)
477 struct rk805_reg_sc *sc;
481 sc = regnode_get_softc(regnode);
483 if (!sc->def->voltage_step)
486 dprintf(sc, "Setting %s to %d<->%d uvolts\n",
490 rk805_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
491 if (rk805_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
494 rk805_write(sc->base_dev, sc->def->voltage_reg, val);
496 rk805_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
500 rk805_regnode_reg_to_voltage(sc, val, &uvolt);
501 dprintf(sc, "Regulator %s set to %d uvolt\n",
509 rk805_regnode_get_voltage(struct regnode *regnode, int *uvolt)
511 struct rk805_reg_sc *sc;
514 sc = regnode_get_softc(regnode);
516 if (sc->def->voltage_min == sc->def->voltage_max) {
517 *uvolt = sc->def->voltage_min;
521 if (!sc->def->voltage_step)
524 rk805_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
525 rk805_regnode_reg_to_voltage(sc, val & sc->def->voltage_mask, uvolt);
527 dprintf(sc, "Regulator %s is at %d uvolt\n",
534 static regnode_method_t rk805_regnode_methods[] = {
535 /* Regulator interface */
536 REGNODEMETHOD(regnode_init, rk805_regnode_init),
537 REGNODEMETHOD(regnode_enable, rk805_regnode_enable),
538 REGNODEMETHOD(regnode_status, rk805_regnode_status),
539 REGNODEMETHOD(regnode_set_voltage, rk805_regnode_set_voltage),
540 REGNODEMETHOD(regnode_get_voltage, rk805_regnode_get_voltage),
541 REGNODEMETHOD(regnode_check_voltage, regnode_method_check_voltage),
544 DEFINE_CLASS_1(rk805_regnode, rk805_regnode_class, rk805_regnode_methods,
545 sizeof(struct rk805_reg_sc), regnode_class);
547 static struct rk805_reg_sc *
548 rk805_reg_attach(device_t dev, phandle_t node,
549 struct rk805_regdef *def)
551 struct rk805_reg_sc *reg_sc;
552 struct regnode_init_def initdef;
553 struct regnode *regnode;
555 memset(&initdef, 0, sizeof(initdef));
556 if (regulator_parse_ofw_stdparam(dev, node, &initdef) != 0) {
557 device_printf(dev, "cannot create regulator\n");
560 if (initdef.std_param.min_uvolt == 0)
561 initdef.std_param.min_uvolt = def->voltage_min;
562 if (initdef.std_param.max_uvolt == 0)
563 initdef.std_param.max_uvolt = def->voltage_max;
564 initdef.id = def->id;
565 initdef.ofw_node = node;
567 regnode = regnode_create(dev, &rk805_regnode_class, &initdef);
568 if (regnode == NULL) {
569 device_printf(dev, "cannot create regulator\n");
573 reg_sc = regnode_get_softc(regnode);
574 reg_sc->regnode = regnode;
575 reg_sc->base_dev = dev;
577 reg_sc->xref = OF_xref_from_node(node);
578 reg_sc->param = regnode_get_stdparam(regnode);
580 regnode_register(regnode);
586 rk805_probe(device_t dev)
588 if (!ofw_bus_status_okay(dev))
591 if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
594 device_set_desc(dev, "RockChip RK805 PMIC");
595 return (BUS_PROBE_DEFAULT);
599 rk805_start(void *pdev)
601 struct rk805_softc *sc;
607 sc = device_get_softc(dev);
610 /* No version register in RK808 */
611 if (bootverbose && sc->type == RK805) {
612 err = rk805_read(dev, RK805_CHIP_NAME, data, 1);
614 device_printf(dev, "Cannot read chip name reg\n");
617 err = rk805_read(dev, RK805_CHIP_VER, data + 1, 1);
619 device_printf(dev, "Cannot read chip version reg\n");
622 device_printf(dev, "Chip Name: %x\n",
623 data[0] << 4 | ((data[1] >> 4) & 0xf));
624 device_printf(dev, "Chip Version: %x\n", data[1] & 0xf);
627 config_intrhook_disestablish(&sc->intr_hook);
631 rk805_attach(device_t dev)
633 struct rk805_softc *sc;
634 struct rk805_reg_sc *reg;
635 struct rk805_regdef *regdefs;
636 struct reg_list *regp;
637 phandle_t rnode, child;
640 sc = device_get_softc(dev);
642 sc->intr_hook.ich_func = rk805_start;
643 sc->intr_hook.ich_arg = dev;
645 if (config_intrhook_establish(&sc->intr_hook) != 0)
648 sc->type = ofw_bus_search_compatible(dev, compat_data)->ocd_data;
651 regdefs = rk805_regdefs;
652 sc->nregs = nitems(rk805_regdefs);
655 regdefs = rk808_regdefs;
656 sc->nregs = nitems(rk808_regdefs);
659 device_printf(dev, "Unknown type %d\n", sc->type);
663 TAILQ_INIT(&sc->regs);
665 rnode = ofw_bus_find_child(ofw_bus_get_node(dev), "regulators");
667 for (i = 0; i < sc->nregs; i++) {
668 child = ofw_bus_find_child(rnode,
672 if (OF_hasprop(child, "regulator-name") != 1)
674 reg = rk805_reg_attach(dev, child, ®defs[i]);
677 "cannot attach regulator %s\n",
681 regp = malloc(sizeof(*regp), M_DEVBUF, M_WAITOK | M_ZERO);
683 TAILQ_INSERT_TAIL(&sc->regs, regp, next);
685 device_printf(dev, "Regulator %s attached\n",
694 rk805_detach(device_t dev)
697 /* We cannot detach regulators */
702 rk805_map(device_t dev, phandle_t xref, int ncells,
703 pcell_t *cells, intptr_t *id)
705 struct rk805_softc *sc;
706 struct reg_list *regp;
708 sc = device_get_softc(dev);
710 TAILQ_FOREACH(regp, &sc->regs, next) {
711 if (regp->reg->xref == xref) {
712 *id = regp->reg->def->id;
720 static device_method_t rk805_methods[] = {
721 DEVMETHOD(device_probe, rk805_probe),
722 DEVMETHOD(device_attach, rk805_attach),
723 DEVMETHOD(device_detach, rk805_detach),
725 /* regdev interface */
726 DEVMETHOD(regdev_map, rk805_map),
730 static driver_t rk805_driver = {
733 sizeof(struct rk805_softc),
736 static devclass_t rk805_devclass;
738 EARLY_DRIVER_MODULE(rk805, iicbus, rk805_driver, rk805_devclass, 0, 0,
739 BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LAST);
740 MODULE_DEPEND(rk805, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER);
741 MODULE_VERSION(rk805, 1);