sys/arm64/rockchip/rk805.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2018 Emmanuel Vadot <manu@FreeBSD.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/bus.h>
  34 #include <sys/kernel.h>
  35 #include <sys/module.h>
  36 #include <sys/mutex.h>
  37 #include <sys/rman.h>
  38 #include <machine/bus.h>
  39
  40 #include <dev/iicbus/iiconf.h>
  41 #include <dev/iicbus/iicbus.h>
  42
  43 #include <dev/ofw/ofw_bus.h>
  44 #include <dev/ofw/ofw_bus_subr.h>
  45
  46 #include <dev/extres/regulator/regulator.h>
  47
  48 #include <arm64/rockchip/rk805reg.h>
  49
  50 #include "regdev_if.h"
  51
  52 MALLOC_DEFINE(M_RK805_REG, "RK805 regulator", "RK805 power regulator");
  53
  54 /* #define      dprintf(sc, format, arg...)     device_printf(sc->base_dev, "%s: " format, __func__, arg) */
  55 #define dprintf(sc, format, arg...)
  56
  57 enum rk_pmic_type {
  58         RK805 = 1,
  59         RK808,
  60 };
  61
  62 static struct ofw_compat_data compat_data[] = {
  63         {"rockchip,rk805", RK805},
  64         {"rockchip,rk808", RK808},
  65         {NULL,             0}
  66 };
  67
  68 struct rk805_regdef {
  69         intptr_t                id;
  70         char                    *name;
  71         uint8_t                 enable_reg;
  72         uint8_t                 enable_mask;
  73         uint8_t                 voltage_reg;
  74         uint8_t                 voltage_mask;
  75         int                     voltage_min;
  76         int                     voltage_max;
  77         int                     voltage_step;
  78         int                     voltage_nstep;
  79 };
  80
  81 struct rk805_reg_sc {
  82         struct regnode          *regnode;
  83         device_t                base_dev;
  84         struct rk805_regdef     *def;
  85         phandle_t               xref;
  86         struct regnode_std_param *param;
  87 };
  88
  89 struct reg_list {
  90         TAILQ_ENTRY(reg_list)   next;
  91         struct rk805_reg_sc     *reg;
  92 };
  93
  94 struct rk805_softc {
  95         device_t                dev;
  96         struct mtx              mtx;
  97         struct resource *       res[1];
  98         void *                  intrcookie;
  99         struct intr_config_hook intr_hook;
 100         enum rk_pmic_type       type;
 101
 102         TAILQ_HEAD(, reg_list)          regs;
 103         int                     nregs;
 104 };
 105
 106 static int rk805_regnode_status(struct regnode *regnode, int *status);
 107 static int rk805_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
 108     int max_uvolt, int *udelay);
 109
 110 static struct rk805_regdef rk805_regdefs[] = {
 111         {
 112                 .id = RK805_DCDC1,
 113                 .name = "DCDC_REG1",
 114                 .enable_reg = RK805_DCDC_EN,
 115                 .enable_mask = 0x11,
 116                 .voltage_reg = RK805_DCDC1_ON_VSEL,
 117                 .voltage_mask = 0x3F,
 118                 .voltage_min = 712500,
 119                 .voltage_max = 1450000,
 120                 .voltage_step = 12500,
 121                 .voltage_nstep = 64,
 122         },
 123         {
 124                 .id = RK805_DCDC2,
 125                 .name = "DCDC_REG2",
 126                 .enable_reg = RK805_DCDC_EN,
 127                 .enable_mask = 0x22,
 128                 .voltage_reg = RK805_DCDC2_ON_VSEL,
 129                 .voltage_mask = 0x3F,
 130                 .voltage_min = 712500,
 131                 .voltage_max = 1450000,
 132                 .voltage_step = 12500,
 133                 .voltage_nstep = 64,
 134         },
 135         {
 136                 .id = RK805_DCDC3,
 137                 .name = "DCDC_REG3",
 138                 .enable_reg = RK805_DCDC_EN,
 139                 .enable_mask = 0x44,
 140         },
 141         {
 142                 .id = RK805_DCDC4,
 143                 .name = "DCDC_REG4",
 144                 .enable_reg = RK805_DCDC_EN,
 145                 .enable_mask = 0x88,
 146                 .voltage_reg = RK805_DCDC4_ON_VSEL,
 147                 .voltage_mask = 0x3F,
 148                 .voltage_min = 800000,
 149                 .voltage_max = 3500000,
 150                 .voltage_step = 100000,
 151                 .voltage_nstep = 28,
 152         },
 153         {
 154                 .id = RK805_LDO1,
 155                 .name = "LDO_REG1",
 156                 .enable_reg = RK805_LDO_EN,
 157                 .enable_mask = 0x11,
 158                 .voltage_reg = RK805_LDO1_ON_VSEL,
 159                 .voltage_mask = 0x1F,
 160                 .voltage_min = 800000,
 161                 .voltage_max = 3400000,
 162                 .voltage_step = 100000,
 163                 .voltage_nstep = 27,
 164         },
 165         {
 166                 .id = RK805_LDO2,
 167                 .name = "LDO_REG2",
 168                 .enable_reg = RK805_LDO_EN,
 169                 .enable_mask = 0x22,
 170                 .voltage_reg = RK805_LDO2_ON_VSEL,
 171                 .voltage_mask = 0x1F,
 172                 .voltage_min = 800000,
 173                 .voltage_max = 3400000,
 174                 .voltage_step = 100000,
 175                 .voltage_nstep = 27,
 176         },
 177         {
 178                 .id = RK805_LDO3,
 179                 .name = "LDO_REG3",
 180                 .enable_reg = RK805_LDO_EN,
 181                 .enable_mask = 0x44,
 182                 .voltage_reg = RK805_LDO3_ON_VSEL,
 183                 .voltage_mask = 0x1F,
 184                 .voltage_min = 800000,
 185                 .voltage_max = 3400000,
 186                 .voltage_step = 100000,
 187                 .voltage_nstep = 27,
 188         },
 189 };
 190
 191 static struct rk805_regdef rk808_regdefs[] = {
 192         {
 193                 .id = RK805_DCDC1,
 194                 .name = "DCDC_REG1",
 195                 .enable_reg = RK805_DCDC_EN,
 196                 .enable_mask = 0x1,
 197                 .voltage_reg = RK805_DCDC1_ON_VSEL,
 198                 .voltage_mask = 0x3F,
 199                 .voltage_min = 712500,
 200                 .voltage_max = 1500000,
 201                 .voltage_step = 12500,
 202                 .voltage_nstep = 64,
 203         },
 204         {
 205                 .id = RK805_DCDC2,
 206                 .name = "DCDC_REG2",
 207                 .enable_reg = RK805_DCDC_EN,
 208                 .enable_mask = 0x2,
 209                 .voltage_reg = RK805_DCDC2_ON_VSEL,
 210                 .voltage_mask = 0x3F,
 211                 .voltage_min = 712500,
 212                 .voltage_max = 1500000,
 213                 .voltage_step = 12500,
 214                 .voltage_nstep = 64,
 215         },
 216         {
 217                 /* BUCK3 voltage is calculated based on external resistor */
 218                 .id = RK805_DCDC3,
 219                 .name = "DCDC_REG3",
 220                 .enable_reg = RK805_DCDC_EN,
 221                 .enable_mask = 0x4,
 222         },
 223         {
 224                 .id = RK805_DCDC4,
 225                 .name = "DCDC_REG4",
 226                 .enable_reg = RK805_DCDC_EN,
 227                 .enable_mask = 0x8,
 228                 .voltage_reg = RK805_DCDC4_ON_VSEL,
 229                 .voltage_mask = 0xF,
 230                 .voltage_min = 1800000,
 231                 .voltage_max = 3300000,
 232                 .voltage_step = 100000,
 233                 .voltage_nstep = 16,
 234         },
 235         {
 236                 .id = RK808_LDO1,
 237                 .name = "LDO_REG1",
 238                 .enable_reg = RK808_LDO_EN,
 239                 .enable_mask = 0x1,
 240                 .voltage_reg = RK805_LDO1_ON_VSEL,
 241                 .voltage_mask = 0x1F,
 242                 .voltage_min = 1800000,
 243                 .voltage_max = 3400000,
 244                 .voltage_step = 100000,
 245                 .voltage_nstep = 17,
 246         },
 247         {
 248                 .id = RK808_LDO2,
 249                 .name = "LDO_REG2",
 250                 .enable_reg = RK808_LDO_EN,
 251                 .enable_mask = 0x2,
 252                 .voltage_reg = RK805_LDO2_ON_VSEL,
 253                 .voltage_mask = 0x1F,
 254                 .voltage_min = 1800000,
 255                 .voltage_max = 3400000,
 256                 .voltage_step = 100000,
 257                 .voltage_nstep = 17,
 258         },
 259         {
 260                 .id = RK808_LDO3,
 261                 .name = "LDO_REG3",
 262                 .enable_reg = RK808_LDO_EN,
 263                 .enable_mask = 0x4,
 264                 .voltage_reg = RK805_LDO3_ON_VSEL,
 265                 .voltage_mask = 0xF,
 266                 .voltage_min = 800000,
 267                 .voltage_max = 2500000,
 268                 .voltage_step = 100000,
 269                 .voltage_nstep = 18,
 270         },
 271         {
 272                 .id = RK808_LDO4,
 273                 .name = "LDO_REG4",
 274                 .enable_reg = RK808_LDO_EN,
 275                 .enable_mask = 0x8,
 276                 .voltage_reg = RK808_LDO4_ON_VSEL,
 277                 .voltage_mask = 0x1F,
 278                 .voltage_min = 1800000,
 279                 .voltage_max = 3400000,
 280                 .voltage_step = 100000,
 281                 .voltage_nstep = 17,
 282         },
 283         {
 284                 .id = RK808_LDO5,
 285                 .name = "LDO_REG5",
 286                 .enable_reg = RK808_LDO_EN,
 287                 .enable_mask = 0x10,
 288                 .voltage_reg = RK808_LDO5_ON_VSEL,
 289                 .voltage_mask = 0x1F,
 290                 .voltage_min = 1800000,
 291                 .voltage_max = 3400000,
 292                 .voltage_step = 100000,
 293                 .voltage_nstep = 17,
 294         },
 295         {
 296                 .id = RK808_LDO6,
 297                 .name = "LDO_REG6",
 298                 .enable_reg = RK808_LDO_EN,
 299                 .enable_mask = 0x20,
 300                 .voltage_reg = RK808_LDO6_ON_VSEL,
 301                 .voltage_mask = 0x1F,
 302                 .voltage_min = 800000,
 303                 .voltage_max = 2500000,
 304                 .voltage_step = 100000,
 305                 .voltage_nstep = 18,
 306         },
 307         {
 308                 .id = RK808_LDO7,
 309                 .name = "LDO_REG7",
 310                 .enable_reg = RK808_LDO_EN,
 311                 .enable_mask = 0x40,
 312                 .voltage_reg = RK808_LDO7_ON_VSEL,
 313                 .voltage_mask = 0x1F,
 314                 .voltage_min = 800000,
 315                 .voltage_max = 2500000,
 316                 .voltage_step = 100000,
 317                 .voltage_nstep = 18,
 318         },
 319         {
 320                 .id = RK808_LDO8,
 321                 .name = "LDO_REG8",
 322                 .enable_reg = RK808_LDO_EN,
 323                 .enable_mask = 0x80,
 324                 .voltage_reg = RK808_LDO8_ON_VSEL,
 325                 .voltage_mask = 0x1F,
 326                 .voltage_min = 1800000,
 327                 .voltage_max = 3400000,
 328                 .voltage_step = 100000,
 329                 .voltage_nstep = 17,
 330         },
 331         {
 332                 .id = RK808_SWITCH1,
 333                 .name = "SWITCH_REG1",
 334                 .enable_reg = RK805_DCDC_EN,
 335                 .enable_mask = 0x20,
 336                 .voltage_min = 3000000,
 337                 .voltage_max = 3000000,
 338         },
 339         {
 340                 .id = RK808_SWITCH2,
 341                 .name = "SWITCH_REG2",
 342                 .enable_reg = RK805_DCDC_EN,
 343                 .enable_mask = 0x40,
 344                 .voltage_min = 3000000,
 345                 .voltage_max = 3000000,
 346         },
 347 };
 348
 349 static int
 350 rk805_read(device_t dev, uint8_t reg, uint8_t *data, uint8_t size)
 351 {
 352         int err;
 353
 354         err = iicdev_readfrom(dev, reg, data, size, IIC_INTRWAIT);
 355         return (err);
 356 }
 357
 358 static int
 359 rk805_write(device_t dev, uint8_t reg, uint8_t data)
 360 {
 361
 362         return (iicdev_writeto(dev, reg, &data, 1, IIC_INTRWAIT));
 363 }
 364
 365 static int
 366 rk805_regnode_init(struct regnode *regnode)
 367 {
 368         struct rk805_reg_sc *sc;
 369         struct regnode_std_param *param;
 370         int rv, udelay, status;
 371
 372         sc = regnode_get_softc(regnode);
 373         param = regnode_get_stdparam(regnode);
 374         if (param->min_uvolt == 0)
 375                 return (0);
 376
 377         /*
 378          * Set the regulator at the correct voltage if it is not enabled.
 379          * Do not enable it, this is will be done either by a
 380          * consumer or by regnode_set_constraint if boot_on is true
 381          */
 382         rv = rk805_regnode_status(regnode, &status);
 383         if (rv != 0 || status == REGULATOR_STATUS_ENABLED)
 384                 return (rv);
 385
 386         rv = rk805_regnode_set_voltage(regnode, param->min_uvolt,
 387             param->max_uvolt, &udelay);
 388         if (udelay != 0)
 389                 DELAY(udelay);
 390
 391         return (rv);
 392 }
 393
 394 static int
 395 rk805_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
 396 {
 397         struct rk805_reg_sc *sc;
 398         uint8_t val;
 399
 400         sc = regnode_get_softc(regnode);
 401
 402         dprintf(sc, "%sabling regulator %s\n",
 403             enable ? "En" : "Dis",
 404             sc->def->name);
 405         rk805_read(sc->base_dev, sc->def->enable_reg, &val, 1);
 406         if (enable)
 407                 val |= sc->def->enable_mask;
 408         else
 409                 val &= ~sc->def->enable_mask;
 410         rk805_write(sc->base_dev, sc->def->enable_reg, val);
 411
 412         *udelay = 0;
 413
 414         return (0);
 415 }
 416
 417 static void
 418 rk805_regnode_reg_to_voltage(struct rk805_reg_sc *sc, uint8_t val, int *uv)
 419 {
 420         if (val < sc->def->voltage_nstep)
 421                 *uv = sc->def->voltage_min + val * sc->def->voltage_step;
 422         else
 423                 *uv = sc->def->voltage_min +
 424                        (sc->def->voltage_nstep * sc->def->voltage_step);
 425 }
 426
 427 static int
 428 rk805_regnode_voltage_to_reg(struct rk805_reg_sc *sc, int min_uvolt,
 429     int max_uvolt, uint8_t *val)
 430 {
 431         uint8_t nval;
 432         int nstep, uvolt;
 433
 434         nval = 0;
 435         uvolt = sc->def->voltage_min;
 436
 437         for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
 438              nstep++) {
 439                 ++nval;
 440                 uvolt += sc->def->voltage_step;
 441         }
 442         if (uvolt > max_uvolt)
 443                 return (EINVAL);
 444
 445         *val = nval;
 446         return (0);
 447 }
 448
 449 static int
 450 rk805_regnode_status(struct regnode *regnode, int *status)
 451 {
 452         struct rk805_reg_sc *sc;
 453         uint8_t val;
 454
 455         sc = regnode_get_softc(regnode);
 456
 457         *status = 0;
 458         rk805_read(sc->base_dev, sc->def->enable_reg, &val, 1);
 459         if (val & sc->def->enable_mask)
 460                 *status = REGULATOR_STATUS_ENABLED;
 461
 462         return (0);
 463 }
 464
 465 static int
 466 rk805_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
 467     int max_uvolt, int *udelay)
 468 {
 469         struct rk805_reg_sc *sc;
 470         uint8_t val;
 471         int uvolt;
 472
 473         sc = regnode_get_softc(regnode);
 474
 475         if (!sc->def->voltage_step)
 476                 return (ENXIO);
 477
 478         dprintf(sc, "Setting %s to %d<->%d uvolts\n",
 479             sc->def->name,
 480             min_uvolt,
 481             max_uvolt);
 482         rk805_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
 483         if (rk805_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
 484                 return (ERANGE);
 485
 486         rk805_write(sc->base_dev, sc->def->voltage_reg, val);
 487
 488         rk805_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
 489
 490         *udelay = 0;
 491
 492         rk805_regnode_reg_to_voltage(sc, val, &uvolt);
 493         dprintf(sc, "Regulator %s set to %d uvolt\n",
 494           sc->def->name,
 495           uvolt);
 496
 497         return (0);
 498 }
 499
 500 static int
 501 rk805_regnode_get_voltage(struct regnode *regnode, int *uvolt)
 502 {
 503         struct rk805_reg_sc *sc;
 504         uint8_t val;
 505
 506         sc = regnode_get_softc(regnode);
 507
 508         if (sc->def->voltage_min ==  sc->def->voltage_max) {
 509                 *uvolt = sc->def->voltage_min;
 510                 return (0);
 511         }
 512
 513         if (!sc->def->voltage_step)
 514                 return (ENXIO);
 515
 516         rk805_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
 517         rk805_regnode_reg_to_voltage(sc, val & sc->def->voltage_mask, uvolt);
 518
 519         dprintf(sc, "Regulator %s is at %d uvolt\n",
 520           sc->def->name,
 521           *uvolt);
 522
 523         return (0);
 524 }
 525
 526 static regnode_method_t rk805_regnode_methods[] = {
 527         /* Regulator interface */
 528         REGNODEMETHOD(regnode_init,             rk805_regnode_init),
 529         REGNODEMETHOD(regnode_enable,           rk805_regnode_enable),
 530         REGNODEMETHOD(regnode_status,           rk805_regnode_status),
 531         REGNODEMETHOD(regnode_set_voltage,      rk805_regnode_set_voltage),
 532         REGNODEMETHOD(regnode_get_voltage,      rk805_regnode_get_voltage),
 533         REGNODEMETHOD(regnode_check_voltage,    regnode_method_check_voltage),
 534         REGNODEMETHOD_END
 535 };
 536 DEFINE_CLASS_1(rk805_regnode, rk805_regnode_class, rk805_regnode_methods,
 537     sizeof(struct rk805_reg_sc), regnode_class);
 538
 539 static struct rk805_reg_sc *
 540 rk805_reg_attach(device_t dev, phandle_t node,
 541     struct rk805_regdef *def)
 542 {
 543         struct rk805_reg_sc *reg_sc;
 544         struct regnode_init_def initdef;
 545         struct regnode *regnode;
 546
 547         memset(&initdef, 0, sizeof(initdef));
 548         if (regulator_parse_ofw_stdparam(dev, node, &initdef) != 0) {
 549                 device_printf(dev, "cannot create regulator\n");
 550                 return (NULL);
 551         }
 552         if (initdef.std_param.min_uvolt == 0)
 553                 initdef.std_param.min_uvolt = def->voltage_min;
 554         if (initdef.std_param.max_uvolt == 0)
 555                 initdef.std_param.max_uvolt = def->voltage_max;
 556         initdef.id = def->id;
 557         initdef.ofw_node = node;
 558
 559         regnode = regnode_create(dev, &rk805_regnode_class, &initdef);
 560         if (regnode == NULL) {
 561                 device_printf(dev, "cannot create regulator\n");
 562                 return (NULL);
 563         }
 564
 565         reg_sc = regnode_get_softc(regnode);
 566         reg_sc->regnode = regnode;
 567         reg_sc->base_dev = dev;
 568         reg_sc->def = def;
 569         reg_sc->xref = OF_xref_from_node(node);
 570         reg_sc->param = regnode_get_stdparam(regnode);
 571
 572         regnode_register(regnode);
 573
 574         return (reg_sc);
 575 }
 576
 577 static int
 578 rk805_probe(device_t dev)
 579 {
 580         if (!ofw_bus_status_okay(dev))
 581                 return (ENXIO);
 582
 583         if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
 584                 return (ENXIO);
 585
 586         device_set_desc(dev, "RockChip RK805 PMIC");
 587         return (BUS_PROBE_DEFAULT);
 588 }
 589
 590 static void
 591 rk805_start(void *pdev)
 592 {
 593         struct rk805_softc *sc;
 594         device_t dev;
 595         uint8_t data[2];
 596         int err;
 597
 598         dev = pdev;
 599         sc = device_get_softc(dev);
 600         sc->dev = dev;
 601
 602         /* No version register in RK808 */
 603         if (bootverbose && sc->type == RK805) {
 604                 err = rk805_read(dev, RK805_CHIP_NAME, data, 1);
 605                 if (err != 0) {
 606                         device_printf(dev, "Cannot read chip name reg\n");
 607                         return;
 608                 }
 609                 err = rk805_read(dev, RK805_CHIP_VER, data + 1, 1);
 610                 if (err != 0) {
 611                         device_printf(dev, "Cannot read chip version reg\n");
 612                         return;
 613                 }
 614                 device_printf(dev, "Chip Name: %x\n",
 615                     data[0] << 4 | ((data[1] >> 4) & 0xf));
 616                 device_printf(dev, "Chip Version: %x\n", data[1] & 0xf);
 617         }
 618
 619         config_intrhook_disestablish(&sc->intr_hook);
 620 }
 621
 622 static int
 623 rk805_attach(device_t dev)
 624 {
 625         struct rk805_softc *sc;
 626         struct rk805_reg_sc *reg;
 627         struct rk805_regdef *regdefs;
 628         struct reg_list *regp;
 629         phandle_t rnode, child;
 630         int i;
 631
 632         sc = device_get_softc(dev);
 633
 634         sc->intr_hook.ich_func = rk805_start;
 635         sc->intr_hook.ich_arg = dev;
 636
 637         if (config_intrhook_establish(&sc->intr_hook) != 0)
 638                 return (ENOMEM);
 639
 640         sc->type = ofw_bus_search_compatible(dev, compat_data)->ocd_data;
 641         switch (sc->type) {
 642         case RK805:
 643                 regdefs = rk805_regdefs;
 644                 sc->nregs = nitems(rk805_regdefs);
 645                 break;
 646         case RK808:
 647                 regdefs = rk808_regdefs;
 648                 sc->nregs = nitems(rk808_regdefs);
 649                 break;
 650         default:
 651                 device_printf(dev, "Unknown type %d\n", sc->type);
 652                 return (ENXIO);
 653         }
 654
 655         TAILQ_INIT(&sc->regs);
 656
 657         rnode = ofw_bus_find_child(ofw_bus_get_node(dev), "regulators");
 658         if (rnode > 0) {
 659                 for (i = 0; i < sc->nregs; i++) {
 660                         child = ofw_bus_find_child(rnode,
 661                             regdefs[i].name);
 662                         if (child == 0)
 663                                 continue;
 664                         if (OF_hasprop(child, "regulator-name") != 1)
 665                                 continue;
 666                         reg = rk805_reg_attach(dev, child, &regdefs[i]);
 667                         if (reg == NULL) {
 668                                 device_printf(dev,
 669                                     "cannot attach regulator %s\n",
 670                                     regdefs[i].name);
 671                                 continue;
 672                         }
 673                         regp = malloc(sizeof(*regp), M_DEVBUF, M_WAITOK | M_ZERO);
 674                         regp->reg = reg;
 675                         TAILQ_INSERT_TAIL(&sc->regs, regp, next);
 676                         if (bootverbose)
 677                                 device_printf(dev, "Regulator %s attached\n",
 678                                     regdefs[i].name);
 679                 }
 680         }
 681
 682         return (0);
 683 }
 684
 685 static int
 686 rk805_detach(device_t dev)
 687 {
 688
 689         /* We cannot detach regulators */
 690         return (EBUSY);
 691 }
 692
 693 static int
 694 rk805_map(device_t dev, phandle_t xref, int ncells,
 695     pcell_t *cells, intptr_t *id)
 696 {
 697         struct rk805_softc *sc;
 698         struct reg_list *regp;
 699
 700         sc = device_get_softc(dev);
 701
 702         TAILQ_FOREACH(regp, &sc->regs, next) {
 703                 if (regp->reg->xref == xref) {
 704                         *id = regp->reg->def->id;
 705                         return (0);
 706                 }
 707         }
 708
 709         return (ERANGE);
 710 }
 711
 712 static device_method_t rk805_methods[] = {
 713         DEVMETHOD(device_probe,         rk805_probe),
 714         DEVMETHOD(device_attach,        rk805_attach),
 715         DEVMETHOD(device_detach,        rk805_detach),
 716
 717         /* regdev interface */
 718         DEVMETHOD(regdev_map,           rk805_map),
 719         DEVMETHOD_END
 720 };
 721
 722 static driver_t rk805_driver = {
 723         "rk805_pmu",
 724         rk805_methods,
 725         sizeof(struct rk805_softc),
 726 };
 727
 728 static devclass_t rk805_devclass;
 729
 730 EARLY_DRIVER_MODULE(rk805, iicbus, rk805_driver, rk805_devclass, 0, 0,
 731     BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LAST);
 732 MODULE_DEPEND(rk805, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER);
 733 MODULE_VERSION(rk805, 1);