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 rk805_softc {
  90         device_t                dev;
  91         struct mtx              mtx;
  92         struct resource *       res[1];
  93         void *                  intrcookie;
  94         struct intr_config_hook intr_hook;
  95         enum rk_pmic_type       type;
  96
  97         struct rk805_reg_sc     **regs;
  98         int                     nregs;
  99 };
 100
 101 static struct rk805_regdef rk805_regdefs[] = {
 102         {
 103                 .id = RK805_DCDC1,
 104                 .name = "DCDC_REG1",
 105                 .enable_reg = RK805_DCDC_EN,
 106                 .enable_mask = 0x11,
 107                 .voltage_reg = RK805_DCDC1_ON_VSEL,
 108                 .voltage_mask = 0x3F,
 109                 .voltage_min = 712500,
 110                 .voltage_max = 1450000,
 111                 .voltage_step = 12500,
 112                 .voltage_nstep = 64,
 113         },
 114         {
 115                 .id = RK805_DCDC2,
 116                 .name = "DCDC_REG2",
 117                 .enable_reg = RK805_DCDC_EN,
 118                 .enable_mask = 0x22,
 119                 .voltage_reg = RK805_DCDC2_ON_VSEL,
 120                 .voltage_mask = 0x3F,
 121                 .voltage_min = 712500,
 122                 .voltage_max = 1450000,
 123                 .voltage_step = 12500,
 124                 .voltage_nstep = 64,
 125         },
 126         {
 127                 .id = RK805_DCDC3,
 128                 .name = "DCDC_REG3",
 129                 .enable_reg = RK805_DCDC_EN,
 130                 .enable_mask = 0x44,
 131         },
 132         {
 133                 .id = RK805_DCDC4,
 134                 .name = "DCDC_REG4",
 135                 .enable_reg = RK805_DCDC_EN,
 136                 .enable_mask = 0x88,
 137                 .voltage_reg = RK805_DCDC4_ON_VSEL,
 138                 .voltage_mask = 0x3F,
 139                 .voltage_min = 800000,
 140                 .voltage_max = 3500000,
 141                 .voltage_step = 100000,
 142                 .voltage_nstep = 28,
 143         },
 144         {
 145                 .id = RK805_LDO1,
 146                 .name = "LDO_REG1",
 147                 .enable_reg = RK805_LDO_EN,
 148                 .enable_mask = 0x11,
 149                 .voltage_reg = RK805_LDO1_ON_VSEL,
 150                 .voltage_mask = 0x1F,
 151                 .voltage_min = 800000,
 152                 .voltage_max = 3400000,
 153                 .voltage_step = 100000,
 154                 .voltage_nstep = 27,
 155         },
 156         {
 157                 .id = RK805_LDO2,
 158                 .name = "LDO_REG2",
 159                 .enable_reg = RK805_LDO_EN,
 160                 .enable_mask = 0x22,
 161                 .voltage_reg = RK805_LDO2_ON_VSEL,
 162                 .voltage_mask = 0x1F,
 163                 .voltage_min = 800000,
 164                 .voltage_max = 3400000,
 165                 .voltage_step = 100000,
 166                 .voltage_nstep = 27,
 167         },
 168         {
 169                 .id = RK805_LDO3,
 170                 .name = "LDO_REG3",
 171                 .enable_reg = RK805_LDO_EN,
 172                 .enable_mask = 0x44,
 173                 .voltage_reg = RK805_LDO3_ON_VSEL,
 174                 .voltage_mask = 0x1F,
 175                 .voltage_min = 800000,
 176                 .voltage_max = 3400000,
 177                 .voltage_step = 100000,
 178                 .voltage_nstep = 27,
 179         },
 180 };
 181
 182 static struct rk805_regdef rk808_regdefs[] = {
 183         {
 184                 .id = RK805_DCDC1,
 185                 .name = "DCDC_REG1",
 186                 .enable_reg = RK805_DCDC_EN,
 187                 .enable_mask = 0x1,
 188                 .voltage_reg = RK805_DCDC1_ON_VSEL,
 189                 .voltage_mask = 0x3F,
 190                 .voltage_min = 712500,
 191                 .voltage_max = 1500000,
 192                 .voltage_step = 12500,
 193                 .voltage_nstep = 64,
 194         },
 195         {
 196                 .id = RK805_DCDC2,
 197                 .name = "DCDC_REG2",
 198                 .enable_reg = RK805_DCDC_EN,
 199                 .enable_mask = 0x2,
 200                 .voltage_reg = RK805_DCDC2_ON_VSEL,
 201                 .voltage_mask = 0x3F,
 202                 .voltage_min = 712500,
 203                 .voltage_max = 1500000,
 204                 .voltage_step = 12500,
 205                 .voltage_nstep = 64,
 206         },
 207         {
 208                 .id = RK805_DCDC3,
 209                 .name = "DCDC_REG3",
 210                 .enable_reg = RK805_DCDC_EN,
 211                 .enable_mask = 0x4,
 212         },
 213         {
 214                 .id = RK805_DCDC4,
 215                 .name = "DCDC_REG4",
 216                 .enable_reg = RK805_DCDC_EN,
 217                 .enable_mask = 0x8,
 218                 .voltage_reg = RK805_DCDC4_ON_VSEL,
 219                 .voltage_mask = 0xF,
 220                 .voltage_min = 1800000,
 221                 .voltage_max = 3300000,
 222                 .voltage_step = 100000,
 223                 .voltage_nstep = 16,
 224         },
 225 };
 226
 227 static int
 228 rk805_read(device_t dev, uint8_t reg, uint8_t *data, uint8_t size)
 229 {
 230
 231         return (iicdev_readfrom(dev, reg, data, size, IIC_INTRWAIT));
 232 }
 233
 234 static int
 235 rk805_write(device_t dev, uint8_t reg, uint8_t data)
 236 {
 237         struct iic_msg msg;
 238         uint8_t buf[2];
 239
 240         buf[0] = reg;
 241         buf[1] = data;
 242         msg.slave = iicbus_get_addr(dev);
 243         msg.flags = IIC_M_WR;
 244         msg.buf = buf;
 245         msg.len = sizeof(buf);
 246
 247         return (iicbus_transfer_excl(dev, &msg, 1, IIC_INTRWAIT));
 248 }
 249
 250 static int
 251 rk805_regnode_init(struct regnode *regnode)
 252 {
 253         return (0);
 254 }
 255
 256 static int
 257 rk805_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
 258 {
 259         struct rk805_reg_sc *sc;
 260         uint8_t val;
 261
 262         sc = regnode_get_softc(regnode);
 263
 264         dprintf(sc, "%sabling regulator %s\n",
 265             enable ? "En" : "Dis",
 266             sc->def->name);
 267         rk805_read(sc->base_dev, sc->def->enable_reg, &val, 1);
 268         if (enable)
 269                 val |= sc->def->enable_mask;
 270         else
 271                 val &= ~sc->def->enable_mask;
 272         rk805_write(sc->base_dev, sc->def->enable_reg, val);
 273
 274         *udelay = 0;
 275
 276         return (0);
 277 }
 278
 279 static void
 280 rk805_regnode_reg_to_voltage(struct rk805_reg_sc *sc, uint8_t val, int *uv)
 281 {
 282         if (val < sc->def->voltage_nstep)
 283                 *uv = sc->def->voltage_min + val * sc->def->voltage_step;
 284         else
 285                 *uv = sc->def->voltage_min +
 286                        (sc->def->voltage_nstep * sc->def->voltage_step);
 287 }
 288
 289 static int
 290 rk805_regnode_voltage_to_reg(struct rk805_reg_sc *sc, int min_uvolt,
 291     int max_uvolt, uint8_t *val)
 292 {
 293         uint8_t nval;
 294         int nstep, uvolt;
 295
 296         nval = 0;
 297         uvolt = sc->def->voltage_min;
 298
 299         for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
 300              nstep++) {
 301                 ++nval;
 302                 uvolt += sc->def->voltage_step;
 303         }
 304         if (uvolt > max_uvolt)
 305                 return (EINVAL);
 306
 307         *val = nval;
 308         return (0);
 309 }
 310
 311 static int
 312 rk805_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
 313     int max_uvolt, int *udelay)
 314 {
 315         struct rk805_reg_sc *sc;
 316         uint8_t val;
 317         int uvolt;
 318
 319         sc = regnode_get_softc(regnode);
 320
 321         if (!sc->def->voltage_step)
 322                 return (ENXIO);
 323
 324         dprintf(sc, "Setting %s to %d<->%d uvolts\n",
 325             sc->def->name,
 326             min_uvolt,
 327             max_uvolt);
 328         rk805_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
 329         if (rk805_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
 330                 return (ERANGE);
 331
 332         rk805_write(sc->base_dev, sc->def->voltage_reg, val);
 333
 334         rk805_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
 335
 336         *udelay = 0;
 337
 338         rk805_regnode_reg_to_voltage(sc, val, &uvolt);
 339         dprintf(sc, "Regulator %s set to %d uvolt\n",
 340           sc->def->name,
 341           uvolt);
 342
 343         return (0);
 344 }
 345
 346 static int
 347 rk805_regnode_get_voltage(struct regnode *regnode, int *uvolt)
 348 {
 349         struct rk805_reg_sc *sc;
 350         uint8_t val;
 351
 352         sc = regnode_get_softc(regnode);
 353
 354         if (!sc->def->voltage_step)
 355                 return (ENXIO);
 356
 357         rk805_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
 358         rk805_regnode_reg_to_voltage(sc, val & sc->def->voltage_mask, uvolt);
 359
 360         dprintf(sc, "Regulator %s is at %d uvolt\n",
 361           sc->def->name,
 362           *uvolt);
 363
 364         return (0);
 365 }
 366
 367 static regnode_method_t rk805_regnode_methods[] = {
 368         /* Regulator interface */
 369         REGNODEMETHOD(regnode_init,             rk805_regnode_init),
 370         REGNODEMETHOD(regnode_enable,           rk805_regnode_enable),
 371         REGNODEMETHOD(regnode_set_voltage,      rk805_regnode_set_voltage),
 372         REGNODEMETHOD(regnode_get_voltage,      rk805_regnode_get_voltage),
 373         REGNODEMETHOD_END
 374 };
 375 DEFINE_CLASS_1(rk805_regnode, rk805_regnode_class, rk805_regnode_methods,
 376     sizeof(struct rk805_reg_sc), regnode_class);
 377
 378 static struct rk805_reg_sc *
 379 rk805_reg_attach(device_t dev, phandle_t node,
 380     struct rk805_regdef *def)
 381 {
 382         struct rk805_reg_sc *reg_sc;
 383         struct regnode_init_def initdef;
 384         struct regnode *regnode;
 385
 386         memset(&initdef, 0, sizeof(initdef));
 387         if (regulator_parse_ofw_stdparam(dev, node, &initdef) != 0) {
 388                 device_printf(dev, "cannot create regulator\n");
 389                 return (NULL);
 390         }
 391         if (initdef.std_param.min_uvolt == 0)
 392                 initdef.std_param.min_uvolt = def->voltage_min;
 393         if (initdef.std_param.max_uvolt == 0)
 394                 initdef.std_param.max_uvolt = def->voltage_max;
 395         initdef.id = def->id;
 396         initdef.ofw_node = node;
 397
 398         regnode = regnode_create(dev, &rk805_regnode_class, &initdef);
 399         if (regnode == NULL) {
 400                 device_printf(dev, "cannot create regulator\n");
 401                 return (NULL);
 402         }
 403
 404         reg_sc = regnode_get_softc(regnode);
 405         reg_sc->regnode = regnode;
 406         reg_sc->base_dev = dev;
 407         reg_sc->def = def;
 408         reg_sc->xref = OF_xref_from_node(node);
 409         reg_sc->param = regnode_get_stdparam(regnode);
 410
 411         regnode_register(regnode);
 412
 413         return (reg_sc);
 414 }
 415
 416 static int
 417 rk805_probe(device_t dev)
 418 {
 419         if (!ofw_bus_status_okay(dev))
 420                 return (ENXIO);
 421
 422         if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0)
 423                 return (ENXIO);
 424
 425         device_set_desc(dev, "RockChip RK805 PMIC");
 426         return (BUS_PROBE_DEFAULT);
 427 }
 428
 429 static void
 430 rk805_start(void *pdev)
 431 {
 432         struct rk805_softc *sc;
 433         device_t dev;
 434         uint8_t data[2];
 435         int err;
 436
 437         dev = pdev;
 438         sc = device_get_softc(dev);
 439         sc->dev = dev;
 440
 441         /* No version register in RK808 */
 442         if (bootverbose && sc->type == RK805) {
 443                 err = rk805_read(dev, RK805_CHIP_NAME, data, 1);
 444                 if (err != 0) {
 445                         device_printf(dev, "Cannot read chip name reg\n");
 446                         return;
 447                 }
 448                 err = rk805_read(dev, RK805_CHIP_VER, data + 1, 1);
 449                 if (err != 0) {
 450                         device_printf(dev, "Cannot read chip version reg\n");
 451                         return;
 452                 }
 453                 device_printf(dev, "Chip Name: %x\n",
 454                     data[0] << 4 | ((data[1] >> 4) & 0xf));
 455                 device_printf(dev, "Chip Version: %x\n", data[1] & 0xf);
 456         }
 457
 458         config_intrhook_disestablish(&sc->intr_hook);
 459 }
 460
 461 static int
 462 rk805_attach(device_t dev)
 463 {
 464         struct rk805_softc *sc;
 465         struct rk805_reg_sc *reg;
 466         struct rk805_regdef *regdefs;
 467         phandle_t rnode, child;
 468         int i;
 469
 470         sc = device_get_softc(dev);
 471
 472         sc->intr_hook.ich_func = rk805_start;
 473         sc->intr_hook.ich_arg = dev;
 474
 475         if (config_intrhook_establish(&sc->intr_hook) != 0)
 476                 return (ENOMEM);
 477
 478         sc->regs = malloc(sizeof(struct rk805_reg_sc *) * sc->nregs,
 479             M_RK805_REG, M_WAITOK | M_ZERO);
 480
 481         sc->type = ofw_bus_search_compatible(dev, compat_data)->ocd_data;
 482         switch (sc->type) {
 483         case RK805:
 484                 regdefs = rk805_regdefs;
 485                 sc->nregs = nitems(rk805_regdefs);
 486                 break;
 487         case RK808:
 488                 regdefs = rk808_regdefs;
 489                 sc->nregs = nitems(rk808_regdefs);
 490                 break;
 491         }
 492
 493         rnode = ofw_bus_find_child(ofw_bus_get_node(dev), "regulators");
 494         if (rnode > 0) {
 495                 for (i = 0; i < sc->nregs; i++) {
 496                         child = ofw_bus_find_child(rnode,
 497                             regdefs[i].name);
 498                         if (child == 0)
 499                                 continue;
 500                         reg = rk805_reg_attach(dev, child, &regdefs[i]);
 501                         if (reg == NULL) {
 502                                 device_printf(dev,
 503                                     "cannot attach regulator %s\n",
 504                                     regdefs[i].name);
 505                                 continue;
 506                         }
 507                         sc->regs[i] = reg;
 508                         if (bootverbose)
 509                                 device_printf(dev, "Regulator %s attached\n",
 510                                     regdefs[i].name);
 511                 }
 512         }
 513
 514         return (0);
 515 }
 516
 517 static int
 518 rk805_detach(device_t dev)
 519 {
 520
 521         /* We cannot detach regulators */
 522         return (EBUSY);
 523 }
 524
 525 static int
 526 rk805_map(device_t dev, phandle_t xref, int ncells,
 527     pcell_t *cells, intptr_t *id)
 528 {
 529         struct rk805_softc *sc;
 530         int i;
 531
 532         sc = device_get_softc(dev);
 533
 534         for (i = 0; i < sc->nregs; i++) {
 535                 if (sc->regs[i]->xref == xref) {
 536                         *id = sc->regs[i]->def->id;
 537                         return (0);
 538                 }
 539         }
 540
 541         return (ERANGE);
 542 }
 543
 544 static device_method_t rk805_methods[] = {
 545         DEVMETHOD(device_probe,         rk805_probe),
 546         DEVMETHOD(device_attach,        rk805_attach),
 547         DEVMETHOD(device_detach,        rk805_detach),
 548
 549         /* regdev interface */
 550         DEVMETHOD(regdev_map,           rk805_map),
 551         DEVMETHOD_END
 552 };
 553
 554 static driver_t rk805_driver = {
 555         "rk805_pmu",
 556         rk805_methods,
 557         sizeof(struct rk805_softc),
 558 };
 559
 560 static devclass_t rk805_devclass;
 561
 562 EARLY_DRIVER_MODULE(rk805, iicbus, rk805_driver, rk805_devclass, 0, 0,
 563     BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LAST);
 564 MODULE_DEPEND(rk805, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER);
 565 MODULE_VERSION(rk805, 1);