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