sys/arm/allwinner/axp81x.c

   1 /*-
   2  * Copyright (c) 2018 Emmanuel Vadot <manu@freebsd.org>
   3  * Copyright (c) 2016 Jared McNeill <jmcneill@invisible.ca>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   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.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  20  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  21  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  22  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  23  * 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
  25  * SUCH DAMAGE.
  26  *
  27  * $FreeBSD$
  28  */
  29
  30 /*
  31  * X-Powers AXP803/813/818 PMU for Allwinner SoCs
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/eventhandler.h>
  40 #include <sys/bus.h>
  41 #include <sys/rman.h>
  42 #include <sys/kernel.h>
  43 #include <sys/reboot.h>
  44 #include <sys/gpio.h>
  45 #include <sys/module.h>
  46 #include <machine/bus.h>
  47
  48 #include <dev/iicbus/iicbus.h>
  49 #include <dev/iicbus/iiconf.h>
  50
  51 #include <dev/gpio/gpiobusvar.h>
  52
  53 #include <dev/ofw/ofw_bus.h>
  54 #include <dev/ofw/ofw_bus_subr.h>
  55
  56 #include <dev/extres/regulator/regulator.h>
  57
  58 #include "gpio_if.h"
  59 #include "iicbus_if.h"
  60 #include "regdev_if.h"
  61
  62 MALLOC_DEFINE(M_AXP8XX_REG, "AXP8xx regulator", "AXP8xx power regulator");
  63
  64 #define AXP_POWERSRC            0x00
  65 #define  AXP_POWERSRC_ACIN      (1 << 7)
  66 #define  AXP_POWERSRC_VBUS      (1 << 5)
  67 #define  AXP_POWERSRC_VBAT      (1 << 3)
  68 #define  AXP_POWERSRC_CHARING   (1 << 2)        /* Charging Direction */
  69 #define  AXP_POWERSRC_SHORTED   (1 << 1)
  70 #define  AXP_POWERSRC_STARTUP   (1 << 0)
  71 #define AXP_POWERMODE           0x01
  72 #define  AXP_POWERMODE_BAT_CHARGING     (1 << 6)
  73 #define  AXP_POWERMODE_BAT_PRESENT      (1 << 5)
  74 #define  AXP_POWERMODE_BAT_VALID        (1 << 4)
  75 #define AXP_ICTYPE              0x03
  76 #define AXP_POWERCTL1           0x10
  77 #define  AXP_POWERCTL1_DCDC7    (1 << 6)        /* AXP813/818 only */
  78 #define  AXP_POWERCTL1_DCDC6    (1 << 5)
  79 #define  AXP_POWERCTL1_DCDC5    (1 << 4)
  80 #define  AXP_POWERCTL1_DCDC4    (1 << 3)
  81 #define  AXP_POWERCTL1_DCDC3    (1 << 2)
  82 #define  AXP_POWERCTL1_DCDC2    (1 << 1)
  83 #define  AXP_POWERCTL1_DCDC1    (1 << 0)
  84 #define AXP_POWERCTL2           0x12
  85 #define  AXP_POWERCTL2_DC1SW    (1 << 7)        /* AXP803 only */
  86 #define  AXP_POWERCTL2_DLDO4    (1 << 6)
  87 #define  AXP_POWERCTL2_DLDO3    (1 << 5)
  88 #define  AXP_POWERCTL2_DLDO2    (1 << 4)
  89 #define  AXP_POWERCTL2_DLDO1    (1 << 3)
  90 #define  AXP_POWERCTL2_ELDO3    (1 << 2)
  91 #define  AXP_POWERCTL2_ELDO2    (1 << 1)
  92 #define  AXP_POWERCTL2_ELDO1    (1 << 0)
  93 #define AXP_POWERCTL3           0x13
  94 #define  AXP_POWERCTL3_ALDO3    (1 << 7)
  95 #define  AXP_POWERCTL3_ALDO2    (1 << 6)
  96 #define  AXP_POWERCTL3_ALDO1    (1 << 5)
  97 #define  AXP_POWERCTL3_FLDO3    (1 << 4)        /* AXP813/818 only */
  98 #define  AXP_POWERCTL3_FLDO2    (1 << 3)
  99 #define  AXP_POWERCTL3_FLDO1    (1 << 2)
 100 #define AXP_VOLTCTL_DLDO1       0x15
 101 #define AXP_VOLTCTL_DLDO2       0x16
 102 #define AXP_VOLTCTL_DLDO3       0x17
 103 #define AXP_VOLTCTL_DLDO4       0x18
 104 #define AXP_VOLTCTL_ELDO1       0x19
 105 #define AXP_VOLTCTL_ELDO2       0x1A
 106 #define AXP_VOLTCTL_ELDO3       0x1B
 107 #define AXP_VOLTCTL_FLDO1       0x1C
 108 #define AXP_VOLTCTL_FLDO2       0x1D
 109 #define AXP_VOLTCTL_DCDC1       0x20
 110 #define AXP_VOLTCTL_DCDC2       0x21
 111 #define AXP_VOLTCTL_DCDC3       0x22
 112 #define AXP_VOLTCTL_DCDC4       0x23
 113 #define AXP_VOLTCTL_DCDC5       0x24
 114 #define AXP_VOLTCTL_DCDC6       0x25
 115 #define AXP_VOLTCTL_DCDC7       0x26
 116 #define AXP_VOLTCTL_ALDO1       0x28
 117 #define AXP_VOLTCTL_ALDO2       0x29
 118 #define AXP_VOLTCTL_ALDO3       0x2A
 119 #define  AXP_VOLTCTL_STATUS     (1 << 7)
 120 #define  AXP_VOLTCTL_MASK       0x7f
 121 #define AXP_POWERBAT            0x32
 122 #define  AXP_POWERBAT_SHUTDOWN  (1 << 7)
 123 #define AXP_IRQEN1              0x40
 124 #define  AXP_IRQEN1_ACIN_HI     (1 << 6)
 125 #define  AXP_IRQEN1_ACIN_LO     (1 << 5)
 126 #define  AXP_IRQEN1_VBUS_HI     (1 << 3)
 127 #define  AXP_IRQEN1_VBUS_LO     (1 << 2)
 128 #define AXP_IRQEN2              0x41
 129 #define  AXP_IRQEN2_BAT_IN      (1 << 7)
 130 #define  AXP_IRQEN2_BAT_NO      (1 << 6)
 131 #define  AXP_IRQEN2_BATCHGC     (1 << 3)
 132 #define  AXP_IRQEN2_BATCHGD     (1 << 2)
 133 #define AXP_IRQEN3              0x42
 134 #define AXP_IRQEN4              0x43
 135 #define  AXP_IRQEN4_BATLVL_LO1  (1 << 1)
 136 #define  AXP_IRQEN4_BATLVL_LO0  (1 << 0)
 137 #define AXP_IRQEN5              0x44
 138 #define  AXP_IRQEN5_POKSIRQ     (1 << 4)
 139 #define  AXP_IRQEN5_POKLIRQ     (1 << 3)
 140 #define AXP_IRQEN6              0x45
 141 #define AXP_IRQSTAT1            0x48
 142 #define  AXP_IRQSTAT1_ACIN_HI   (1 << 6)
 143 #define  AXP_IRQSTAT1_ACIN_LO   (1 << 5)
 144 #define  AXP_IRQSTAT1_VBUS_HI   (1 << 3)
 145 #define  AXP_IRQSTAT1_VBUS_LO   (1 << 2)
 146 #define AXP_IRQSTAT2            0x49
 147 #define  AXP_IRQSTAT2_BAT_IN    (1 << 7)
 148 #define  AXP_IRQSTAT2_BAT_NO    (1 << 6)
 149 #define  AXP_IRQSTAT2_BATCHGC   (1 << 3)
 150 #define  AXP_IRQSTAT2_BATCHGD   (1 << 2)
 151 #define AXP_IRQSTAT3            0x4a
 152 #define AXP_IRQSTAT4            0x4b
 153 #define  AXP_IRQSTAT4_BATLVL_LO1        (1 << 1)
 154 #define  AXP_IRQSTAT4_BATLVL_LO0        (1 << 0)
 155 #define AXP_IRQSTAT5            0x4c
 156 #define  AXP_IRQSTAT5_POKSIRQ   (1 << 4)
 157 #define  AXP_IRQEN5_POKLIRQ     (1 << 3)
 158 #define AXP_IRQSTAT6            0x4d
 159 #define AXP_BATSENSE_HI         0x78
 160 #define AXP_BATSENSE_LO         0x79
 161 #define AXP_BATCHG_HI           0x7a
 162 #define AXP_BATCHG_LO           0x7b
 163 #define AXP_BATDISCHG_HI        0x7c
 164 #define AXP_BATDISCHG_LO        0x7d
 165 #define AXP_GPIO0_CTRL          0x90
 166 #define AXP_GPIO0LDO_CTRL       0x91
 167 #define AXP_GPIO1_CTRL          0x92
 168 #define AXP_GPIO1LDO_CTRL       0x93
 169 #define  AXP_GPIO_FUNC          (0x7 << 0)
 170 #define  AXP_GPIO_FUNC_SHIFT    0
 171 #define  AXP_GPIO_FUNC_DRVLO    0
 172 #define  AXP_GPIO_FUNC_DRVHI    1
 173 #define  AXP_GPIO_FUNC_INPUT    2
 174 #define  AXP_GPIO_FUNC_LDO_ON   3
 175 #define  AXP_GPIO_FUNC_LDO_OFF  4
 176 #define AXP_GPIO_SIGBIT         0x94
 177 #define AXP_GPIO_PD             0x97
 178 #define AXP_FUEL_GAUGECTL       0xb8
 179 #define  AXP_FUEL_GAUGECTL_EN   (1 << 7)
 180
 181 #define AXP_BAT_CAP             0xb9
 182 #define  AXP_BAT_CAP_VALID      (1 << 7)
 183 #define  AXP_BAT_CAP_PERCENT    0x7f
 184
 185 #define AXP_BAT_MAX_CAP_HI      0xe0
 186 #define  AXP_BAT_MAX_CAP_VALID  (1 << 7)
 187 #define AXP_BAT_MAX_CAP_LO      0xe1
 188
 189 #define AXP_BAT_COULOMB_HI      0xe2
 190 #define  AXP_BAT_COULOMB_VALID  (1 << 7)
 191 #define AXP_BAT_COULOMB_LO      0xe3
 192
 193 #define AXP_BAT_CAP_WARN        0xe6
 194 #define  AXP_BAT_CAP_WARN_LV1   0xf0    /* Bits 4, 5, 6, 7 */
 195 #define  AXP_BAT_CAP_WARN_LV2   0xf     /* Bits 0, 1, 2, 3 */
 196
 197 static const struct {
 198         const char *name;
 199         uint8_t ctrl_reg;
 200 } axp8xx_pins[] = {
 201         { "GPIO0", AXP_GPIO0_CTRL },
 202         { "GPIO1", AXP_GPIO1_CTRL },
 203 };
 204
 205 enum AXP8XX_TYPE {
 206         AXP803 = 1,
 207         AXP813,
 208 };
 209
 210 static struct ofw_compat_data compat_data[] = {
 211         { "x-powers,axp803",                    AXP803 },
 212         { "x-powers,axp813",                    AXP813 },
 213         { "x-powers,axp818",                    AXP813 },
 214         { NULL,                                 0 }
 215 };
 216
 217 static struct resource_spec axp8xx_spec[] = {
 218         { SYS_RES_IRQ,          0,      RF_ACTIVE },
 219         { -1, 0 }
 220 };
 221
 222 struct axp8xx_regdef {
 223         intptr_t                id;
 224         char                    *name;
 225         char                    *supply_name;
 226         uint8_t                 enable_reg;
 227         uint8_t                 enable_mask;
 228         uint8_t                 enable_value;
 229         uint8_t                 disable_value;
 230         uint8_t                 voltage_reg;
 231         int                     voltage_min;
 232         int                     voltage_max;
 233         int                     voltage_step1;
 234         int                     voltage_nstep1;
 235         int                     voltage_step2;
 236         int                     voltage_nstep2;
 237 };
 238
 239 enum axp8xx_reg_id {
 240         AXP8XX_REG_ID_DCDC1 = 100,
 241         AXP8XX_REG_ID_DCDC2,
 242         AXP8XX_REG_ID_DCDC3,
 243         AXP8XX_REG_ID_DCDC4,
 244         AXP8XX_REG_ID_DCDC5,
 245         AXP8XX_REG_ID_DCDC6,
 246         AXP813_REG_ID_DCDC7,
 247         AXP803_REG_ID_DC1SW,
 248         AXP8XX_REG_ID_DLDO1,
 249         AXP8XX_REG_ID_DLDO2,
 250         AXP8XX_REG_ID_DLDO3,
 251         AXP8XX_REG_ID_DLDO4,
 252         AXP8XX_REG_ID_ELDO1,
 253         AXP8XX_REG_ID_ELDO2,
 254         AXP8XX_REG_ID_ELDO3,
 255         AXP8XX_REG_ID_ALDO1,
 256         AXP8XX_REG_ID_ALDO2,
 257         AXP8XX_REG_ID_ALDO3,
 258         AXP8XX_REG_ID_FLDO1,
 259         AXP8XX_REG_ID_FLDO2,
 260         AXP813_REG_ID_FLDO3,
 261         AXP8XX_REG_ID_GPIO0_LDO,
 262         AXP8XX_REG_ID_GPIO1_LDO,
 263 };
 264
 265 static struct axp8xx_regdef axp803_regdefs[] = {
 266         {
 267                 .id = AXP803_REG_ID_DC1SW,
 268                 .name = "dc1sw",
 269                 .enable_reg = AXP_POWERCTL2,
 270                 .enable_mask = (uint8_t) AXP_POWERCTL2_DC1SW,
 271                 .enable_value = AXP_POWERCTL2_DC1SW,
 272         },
 273 };
 274
 275 static struct axp8xx_regdef axp813_regdefs[] = {
 276         {
 277                 .id = AXP813_REG_ID_DCDC7,
 278                 .name = "dcdc7",
 279                 .enable_reg = AXP_POWERCTL1,
 280                 .enable_mask = (uint8_t) AXP_POWERCTL1_DCDC7,
 281                 .enable_value = AXP_POWERCTL1_DCDC7,
 282                 .voltage_reg = AXP_VOLTCTL_DCDC7,
 283                 .voltage_min = 600,
 284                 .voltage_max = 1520,
 285                 .voltage_step1 = 10,
 286                 .voltage_nstep1 = 50,
 287                 .voltage_step2 = 20,
 288                 .voltage_nstep2 = 21,
 289         },
 290 };
 291
 292 static struct axp8xx_regdef axp8xx_common_regdefs[] = {
 293         {
 294                 .id = AXP8XX_REG_ID_DCDC1,
 295                 .name = "dcdc1",
 296                 .enable_reg = AXP_POWERCTL1,
 297                 .enable_mask = (uint8_t) AXP_POWERCTL1_DCDC1,
 298                 .enable_value = AXP_POWERCTL1_DCDC1,
 299                 .voltage_reg = AXP_VOLTCTL_DCDC1,
 300                 .voltage_min = 1600,
 301                 .voltage_max = 3400,
 302                 .voltage_step1 = 100,
 303                 .voltage_nstep1 = 18,
 304         },
 305         {
 306                 .id = AXP8XX_REG_ID_DCDC2,
 307                 .name = "dcdc2",
 308                 .enable_reg = AXP_POWERCTL1,
 309                 .enable_mask = (uint8_t) AXP_POWERCTL1_DCDC2,
 310                 .enable_value = AXP_POWERCTL1_DCDC2,
 311                 .voltage_reg = AXP_VOLTCTL_DCDC2,
 312                 .voltage_min = 500,
 313                 .voltage_max = 1300,
 314                 .voltage_step1 = 10,
 315                 .voltage_nstep1 = 70,
 316                 .voltage_step2 = 20,
 317                 .voltage_nstep2 = 5,
 318         },
 319         {
 320                 .id = AXP8XX_REG_ID_DCDC3,
 321                 .name = "dcdc3",
 322                 .enable_reg = AXP_POWERCTL1,
 323                 .enable_mask = (uint8_t) AXP_POWERCTL1_DCDC3,
 324                 .enable_value = AXP_POWERCTL1_DCDC3,
 325                 .voltage_reg = AXP_VOLTCTL_DCDC3,
 326                 .voltage_min = 500,
 327                 .voltage_max = 1300,
 328                 .voltage_step1 = 10,
 329                 .voltage_nstep1 = 70,
 330                 .voltage_step2 = 20,
 331                 .voltage_nstep2 = 5,
 332         },
 333         {
 334                 .id = AXP8XX_REG_ID_DCDC4,
 335                 .name = "dcdc4",
 336                 .enable_reg = AXP_POWERCTL1,
 337                 .enable_mask = (uint8_t) AXP_POWERCTL1_DCDC4,
 338                 .enable_value = AXP_POWERCTL1_DCDC4,
 339                 .voltage_reg = AXP_VOLTCTL_DCDC4,
 340                 .voltage_min = 500,
 341                 .voltage_max = 1300,
 342                 .voltage_step1 = 10,
 343                 .voltage_nstep1 = 70,
 344                 .voltage_step2 = 20,
 345                 .voltage_nstep2 = 5,
 346         },
 347         {
 348                 .id = AXP8XX_REG_ID_DCDC5,
 349                 .name = "dcdc5",
 350                 .enable_reg = AXP_POWERCTL1,
 351                 .enable_mask = (uint8_t) AXP_POWERCTL1_DCDC5,
 352                 .enable_value = AXP_POWERCTL1_DCDC5,
 353                 .voltage_reg = AXP_VOLTCTL_DCDC5,
 354                 .voltage_min = 800,
 355                 .voltage_max = 1840,
 356                 .voltage_step1 = 10,
 357                 .voltage_nstep1 = 42,
 358                 .voltage_step2 = 20,
 359                 .voltage_nstep2 = 36,
 360         },
 361         {
 362                 .id = AXP8XX_REG_ID_DCDC6,
 363                 .name = "dcdc6",
 364                 .enable_reg = AXP_POWERCTL1,
 365                 .enable_mask = (uint8_t) AXP_POWERCTL1_DCDC6,
 366                 .enable_value = AXP_POWERCTL1_DCDC6,
 367                 .voltage_reg = AXP_VOLTCTL_DCDC6,
 368                 .voltage_min = 600,
 369                 .voltage_max = 1520,
 370                 .voltage_step1 = 10,
 371                 .voltage_nstep1 = 50,
 372                 .voltage_step2 = 20,
 373                 .voltage_nstep2 = 21,
 374         },
 375         {
 376                 .id = AXP8XX_REG_ID_DLDO1,
 377                 .name = "dldo1",
 378                 .enable_reg = AXP_POWERCTL2,
 379                 .enable_mask = (uint8_t) AXP_POWERCTL2_DLDO1,
 380                 .enable_value = AXP_POWERCTL2_DLDO1,
 381                 .voltage_reg = AXP_VOLTCTL_DLDO1,
 382                 .voltage_min = 700,
 383                 .voltage_max = 3300,
 384                 .voltage_step1 = 100,
 385                 .voltage_nstep1 = 26,
 386         },
 387         {
 388                 .id = AXP8XX_REG_ID_DLDO2,
 389                 .name = "dldo2",
 390                 .enable_reg = AXP_POWERCTL2,
 391                 .enable_mask = (uint8_t) AXP_POWERCTL2_DLDO2,
 392                 .enable_value = AXP_POWERCTL2_DLDO2,
 393                 .voltage_reg = AXP_VOLTCTL_DLDO2,
 394                 .voltage_min = 700,
 395                 .voltage_max = 4200,
 396                 .voltage_step1 = 100,
 397                 .voltage_nstep1 = 27,
 398                 .voltage_step2 = 200,
 399                 .voltage_nstep2 = 4,
 400         },
 401         {
 402                 .id = AXP8XX_REG_ID_DLDO3,
 403                 .name = "dldo3",
 404                 .enable_reg = AXP_POWERCTL2,
 405                 .enable_mask = (uint8_t) AXP_POWERCTL2_DLDO3,
 406                 .enable_value = AXP_POWERCTL2_DLDO3,
 407                 .voltage_reg = AXP_VOLTCTL_DLDO3,
 408                 .voltage_min = 700,
 409                 .voltage_max = 3300,
 410                 .voltage_step1 = 100,
 411                 .voltage_nstep1 = 26,
 412         },
 413         {
 414                 .id = AXP8XX_REG_ID_DLDO4,
 415                 .name = "dldo4",
 416                 .enable_reg = AXP_POWERCTL2,
 417                 .enable_mask = (uint8_t) AXP_POWERCTL2_DLDO4,
 418                 .enable_value = AXP_POWERCTL2_DLDO4,
 419                 .voltage_reg = AXP_VOLTCTL_DLDO4,
 420                 .voltage_min = 700,
 421                 .voltage_max = 3300,
 422                 .voltage_step1 = 100,
 423                 .voltage_nstep1 = 26,
 424         },
 425         {
 426                 .id = AXP8XX_REG_ID_ALDO1,
 427                 .name = "aldo1",
 428                 .enable_reg = AXP_POWERCTL3,
 429                 .enable_mask = (uint8_t) AXP_POWERCTL3_ALDO1,
 430                 .enable_value = AXP_POWERCTL3_ALDO1,
 431                 .voltage_min = 700,
 432                 .voltage_max = 3300,
 433                 .voltage_step1 = 100,
 434                 .voltage_nstep1 = 26,
 435         },
 436         {
 437                 .id = AXP8XX_REG_ID_ALDO2,
 438                 .name = "aldo2",
 439                 .enable_reg = AXP_POWERCTL3,
 440                 .enable_mask = (uint8_t) AXP_POWERCTL3_ALDO2,
 441                 .enable_value = AXP_POWERCTL3_ALDO2,
 442                 .voltage_min = 700,
 443                 .voltage_max = 3300,
 444                 .voltage_step1 = 100,
 445                 .voltage_nstep1 = 26,
 446         },
 447         {
 448                 .id = AXP8XX_REG_ID_ALDO3,
 449                 .name = "aldo3",
 450                 .enable_reg = AXP_POWERCTL3,
 451                 .enable_mask = (uint8_t) AXP_POWERCTL3_ALDO3,
 452                 .enable_value = AXP_POWERCTL3_ALDO3,
 453                 .voltage_min = 700,
 454                 .voltage_max = 3300,
 455                 .voltage_step1 = 100,
 456                 .voltage_nstep1 = 26,
 457         },
 458         {
 459                 .id = AXP8XX_REG_ID_ELDO1,
 460                 .name = "eldo1",
 461                 .enable_reg = AXP_POWERCTL2,
 462                 .enable_mask = (uint8_t) AXP_POWERCTL2_ELDO1,
 463                 .enable_value = AXP_POWERCTL2_ELDO1,
 464                 .voltage_min = 700,
 465                 .voltage_max = 1900,
 466                 .voltage_step1 = 50,
 467                 .voltage_nstep1 = 24,
 468         },
 469         {
 470                 .id = AXP8XX_REG_ID_ELDO2,
 471                 .name = "eldo2",
 472                 .enable_reg = AXP_POWERCTL2,
 473                 .enable_mask = (uint8_t) AXP_POWERCTL2_ELDO2,
 474                 .enable_value = AXP_POWERCTL2_ELDO2,
 475                 .voltage_min = 700,
 476                 .voltage_max = 1900,
 477                 .voltage_step1 = 50,
 478                 .voltage_nstep1 = 24,
 479         },
 480         {
 481                 .id = AXP8XX_REG_ID_ELDO3,
 482                 .name = "eldo3",
 483                 .enable_reg = AXP_POWERCTL2,
 484                 .enable_mask = (uint8_t) AXP_POWERCTL2_ELDO3,
 485                 .enable_value = AXP_POWERCTL2_ELDO3,
 486                 .voltage_min = 700,
 487                 .voltage_max = 1900,
 488                 .voltage_step1 = 50,
 489                 .voltage_nstep1 = 24,
 490         },
 491         {
 492                 .id = AXP8XX_REG_ID_FLDO1,
 493                 .name = "fldo1",
 494                 .enable_reg = AXP_POWERCTL3,
 495                 .enable_mask = (uint8_t) AXP_POWERCTL3_FLDO1,
 496                 .enable_value = AXP_POWERCTL3_FLDO1,
 497                 .voltage_min = 700,
 498                 .voltage_max = 1450,
 499                 .voltage_step1 = 50,
 500                 .voltage_nstep1 = 15,
 501         },
 502         {
 503                 .id = AXP8XX_REG_ID_FLDO2,
 504                 .name = "fldo2",
 505                 .enable_reg = AXP_POWERCTL3,
 506                 .enable_mask = (uint8_t) AXP_POWERCTL3_FLDO2,
 507                 .enable_value = AXP_POWERCTL3_FLDO2,
 508                 .voltage_min = 700,
 509                 .voltage_max = 1450,
 510                 .voltage_step1 = 50,
 511                 .voltage_nstep1 = 15,
 512         },
 513         {
 514                 .id = AXP8XX_REG_ID_GPIO0_LDO,
 515                 .name = "ldo-io0",
 516                 .enable_reg = AXP_GPIO0_CTRL,
 517                 .enable_mask = (uint8_t) AXP_GPIO_FUNC,
 518                 .enable_value = AXP_GPIO_FUNC_LDO_ON,
 519                 .disable_value = AXP_GPIO_FUNC_LDO_OFF,
 520                 .voltage_reg = AXP_GPIO0LDO_CTRL,
 521                 .voltage_min = 700,
 522                 .voltage_max = 3300,
 523                 .voltage_step1 = 100,
 524                 .voltage_nstep1 = 26,
 525         },
 526         {
 527                 .id = AXP8XX_REG_ID_GPIO1_LDO,
 528                 .name = "ldo-io1",
 529                 .enable_reg = AXP_GPIO1_CTRL,
 530                 .enable_mask = (uint8_t) AXP_GPIO_FUNC,
 531                 .enable_value = AXP_GPIO_FUNC_LDO_ON,
 532                 .disable_value = AXP_GPIO_FUNC_LDO_OFF,
 533                 .voltage_reg = AXP_GPIO1LDO_CTRL,
 534                 .voltage_min = 700,
 535                 .voltage_max = 3300,
 536                 .voltage_step1 = 100,
 537                 .voltage_nstep1 = 26,
 538         },
 539 };
 540
 541 struct axp8xx_softc;
 542
 543 struct axp8xx_reg_sc {
 544         struct regnode          *regnode;
 545         device_t                base_dev;
 546         struct axp8xx_regdef    *def;
 547         phandle_t               xref;
 548         struct regnode_std_param *param;
 549 };
 550
 551 struct axp8xx_softc {
 552         struct resource         *res;
 553         uint16_t                addr;
 554         void                    *ih;
 555         device_t                gpiodev;
 556         struct mtx              mtx;
 557         int                     busy;
 558
 559         int                     type;
 560
 561         /* Regulators */
 562         struct axp8xx_reg_sc    **regs;
 563         int                     nregs;
 564 };
 565
 566 #define AXP_LOCK(sc)    mtx_lock(&(sc)->mtx)
 567 #define AXP_UNLOCK(sc)  mtx_unlock(&(sc)->mtx)
 568
 569 static int
 570 axp8xx_read(device_t dev, uint8_t reg, uint8_t *data, uint8_t size)
 571 {
 572         struct axp8xx_softc *sc;
 573         struct iic_msg msg[2];
 574
 575         sc = device_get_softc(dev);
 576
 577         msg[0].slave = sc->addr;
 578         msg[0].flags = IIC_M_WR;
 579         msg[0].len = 1;
 580         msg[0].buf = &reg;
 581
 582         msg[1].slave = sc->addr;
 583         msg[1].flags = IIC_M_RD;
 584         msg[1].len = size;
 585         msg[1].buf = data;
 586
 587         return (iicbus_transfer(dev, msg, 2));
 588 }
 589
 590 static int
 591 axp8xx_write(device_t dev, uint8_t reg, uint8_t val)
 592 {
 593         struct axp8xx_softc *sc;
 594         struct iic_msg msg[2];
 595
 596         sc = device_get_softc(dev);
 597
 598         msg[0].slave = sc->addr;
 599         msg[0].flags = IIC_M_WR;
 600         msg[0].len = 1;
 601         msg[0].buf = &reg;
 602
 603         msg[1].slave = sc->addr;
 604         msg[1].flags = IIC_M_WR;
 605         msg[1].len = 1;
 606         msg[1].buf = &val;
 607
 608         return (iicbus_transfer(dev, msg, 2));
 609 }
 610
 611 static int
 612 axp8xx_regnode_init(struct regnode *regnode)
 613 {
 614         return (0);
 615 }
 616
 617 static int
 618 axp8xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
 619 {
 620         struct axp8xx_reg_sc *sc;
 621         uint8_t val;
 622
 623         sc = regnode_get_softc(regnode);
 624
 625         if (bootverbose)
 626                 device_printf(sc->base_dev, "%sable %s (%s)\n",
 627                     enable ? "En" : "Dis",
 628                     regnode_get_name(regnode),
 629                     sc->def->name);
 630
 631         axp8xx_read(sc->base_dev, sc->def->enable_reg, &val, 1);
 632         val &= ~sc->def->enable_mask;
 633         if (enable)
 634                 val |= sc->def->enable_value;
 635         else {
 636                 if (sc->def->disable_value)
 637                         val |= sc->def->disable_value;
 638                 else
 639                         val &= ~sc->def->enable_value;
 640         }
 641         axp8xx_write(sc->base_dev, sc->def->enable_reg, val);
 642
 643         *udelay = 0;
 644
 645         return (0);
 646 }
 647
 648 static void
 649 axp8xx_regnode_reg_to_voltage(struct axp8xx_reg_sc *sc, uint8_t val, int *uv)
 650 {
 651         if (val < sc->def->voltage_nstep1)
 652                 *uv = sc->def->voltage_min + val * sc->def->voltage_step1;
 653         else
 654                 *uv = sc->def->voltage_min +
 655                     (sc->def->voltage_nstep1 * sc->def->voltage_step1) +
 656                     ((val - sc->def->voltage_nstep1) * sc->def->voltage_step2);
 657         *uv *= 1000;
 658 }
 659
 660 static int
 661 axp8xx_regnode_voltage_to_reg(struct axp8xx_reg_sc *sc, int min_uvolt,
 662     int max_uvolt, uint8_t *val)
 663 {
 664         uint8_t nval;
 665         int nstep, uvolt;
 666
 667         nval = 0;
 668         uvolt = sc->def->voltage_min * 1000;
 669
 670         for (nstep = 0; nstep < sc->def->voltage_nstep1 && uvolt < min_uvolt;
 671              nstep++) {
 672                 ++nval;
 673                 uvolt += (sc->def->voltage_step1 * 1000);
 674         }
 675         for (nstep = 0; nstep < sc->def->voltage_nstep2 && uvolt < min_uvolt;
 676              nstep++) {
 677                 ++nval;
 678                 uvolt += (sc->def->voltage_step2 * 1000);
 679         }
 680         if (uvolt > max_uvolt)
 681                 return (EINVAL);
 682
 683         *val = nval;
 684         return (0);
 685 }
 686
 687 static int
 688 axp8xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
 689     int max_uvolt, int *udelay)
 690 {
 691         struct axp8xx_reg_sc *sc;
 692         uint8_t val;
 693
 694         sc = regnode_get_softc(regnode);
 695
 696         if (bootverbose)
 697                 device_printf(sc->base_dev, "Setting %s (%s) to %d<->%d\n",
 698                     regnode_get_name(regnode),
 699                     sc->def->name,
 700                     min_uvolt, max_uvolt);
 701
 702         if (sc->def->voltage_step1 == 0)
 703                 return (ENXIO);
 704
 705         if (axp8xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
 706                 return (ERANGE);
 707
 708         axp8xx_write(sc->base_dev, sc->def->voltage_reg, val);
 709
 710         *udelay = 0;
 711
 712         return (0);
 713 }
 714
 715 static int
 716 axp8xx_regnode_get_voltage(struct regnode *regnode, int *uvolt)
 717 {
 718         struct axp8xx_reg_sc *sc;
 719         uint8_t val;
 720
 721         sc = regnode_get_softc(regnode);
 722
 723         if (!sc->def->voltage_step1 || !sc->def->voltage_step2)
 724                 return (ENXIO);
 725
 726         axp8xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
 727         axp8xx_regnode_reg_to_voltage(sc, val & AXP_VOLTCTL_MASK, uvolt);
 728
 729         return (0);
 730 }
 731
 732 static regnode_method_t axp8xx_regnode_methods[] = {
 733         /* Regulator interface */
 734         REGNODEMETHOD(regnode_init,             axp8xx_regnode_init),
 735         REGNODEMETHOD(regnode_enable,           axp8xx_regnode_enable),
 736         REGNODEMETHOD(regnode_set_voltage,      axp8xx_regnode_set_voltage),
 737         REGNODEMETHOD(regnode_get_voltage,      axp8xx_regnode_get_voltage),
 738         REGNODEMETHOD_END
 739 };
 740 DEFINE_CLASS_1(axp8xx_regnode, axp8xx_regnode_class, axp8xx_regnode_methods,
 741     sizeof(struct axp8xx_reg_sc), regnode_class);
 742
 743 static void
 744 axp8xx_shutdown(void *devp, int howto)
 745 {
 746         device_t dev;
 747
 748         if ((howto & RB_POWEROFF) == 0)
 749                 return;
 750
 751         dev = devp;
 752
 753         if (bootverbose)
 754                 device_printf(dev, "Shutdown Axp8xx\n");
 755
 756         axp8xx_write(dev, AXP_POWERBAT, AXP_POWERBAT_SHUTDOWN);
 757 }
 758
 759 static void
 760 axp8xx_intr(void *arg)
 761 {
 762         device_t dev;
 763         uint8_t val;
 764         int error;
 765
 766         dev = arg;
 767
 768         error = axp8xx_read(dev, AXP_IRQSTAT1, &val, 1);
 769         if (error != 0)
 770                 return;
 771
 772         if (val) {
 773                 if (bootverbose)
 774                         device_printf(dev, "AXP_IRQSTAT1 val: %x\n", val);
 775                 if (val & AXP_IRQSTAT1_ACIN_HI)
 776                         devctl_notify("PMU", "AC", "plugged", NULL);
 777                 if (val & AXP_IRQSTAT1_ACIN_LO)
 778                         devctl_notify("PMU", "AC", "unplugged", NULL);
 779                 if (val & AXP_IRQSTAT1_VBUS_HI)
 780                         devctl_notify("PMU", "USB", "plugged", NULL);
 781                 if (val & AXP_IRQSTAT1_VBUS_LO)
 782                         devctl_notify("PMU", "USB", "unplugged", NULL);
 783                 /* Acknowledge */
 784                 axp8xx_write(dev, AXP_IRQSTAT1, val);
 785         }
 786
 787         error = axp8xx_read(dev, AXP_IRQSTAT2, &val, 1);
 788         if (error != 0)
 789                 return;
 790
 791         if (val) {
 792                 if (bootverbose)
 793                         device_printf(dev, "AXP_IRQSTAT2 val: %x\n", val);
 794                 if (val & AXP_IRQSTAT2_BATCHGD)
 795                         devctl_notify("PMU", "Battery", "charged", NULL);
 796                 if (val & AXP_IRQSTAT2_BATCHGC)
 797                         devctl_notify("PMU", "Battery", "charging", NULL);
 798                 if (val & AXP_IRQSTAT2_BAT_NO)
 799                         devctl_notify("PMU", "Battery", "absent", NULL);
 800                 if (val & AXP_IRQSTAT2_BAT_IN)
 801                         devctl_notify("PMU", "Battery", "plugged", NULL);
 802                 /* Acknowledge */
 803                 axp8xx_write(dev, AXP_IRQSTAT2, val);
 804         }
 805
 806         error = axp8xx_read(dev, AXP_IRQSTAT3, &val, 1);
 807         if (error != 0)
 808                 return;
 809
 810         if (val) {
 811                 /* Acknowledge */
 812                 axp8xx_write(dev, AXP_IRQSTAT3, val);
 813         }
 814
 815         error = axp8xx_read(dev, AXP_IRQSTAT4, &val, 1);
 816         if (error != 0)
 817                 return;
 818
 819         if (val) {
 820                 if (bootverbose)
 821                         device_printf(dev, "AXP_IRQSTAT4 val: %x\n", val);
 822                 if (val & AXP_IRQSTAT4_BATLVL_LO0)
 823                         devctl_notify("PMU", "Battery", "lower than level 2", NULL);
 824                 if (val & AXP_IRQSTAT4_BATLVL_LO1)
 825                         devctl_notify("PMU", "Battery", "lower than level 1", NULL);
 826                 /* Acknowledge */
 827                 axp8xx_write(dev, AXP_IRQSTAT4, val);
 828         }
 829
 830         error = axp8xx_read(dev, AXP_IRQSTAT5, &val, 1);
 831         if (error != 0)
 832                 return;
 833
 834         if (val != 0) {
 835                 if ((val & AXP_IRQSTAT5_POKSIRQ) != 0) {
 836                         if (bootverbose)
 837                                 device_printf(dev, "Power button pressed\n");
 838                         shutdown_nice(RB_POWEROFF);
 839                 }
 840                 /* Acknowledge */
 841                 axp8xx_write(dev, AXP_IRQSTAT5, val);
 842         }
 843
 844         error = axp8xx_read(dev, AXP_IRQSTAT6, &val, 1);
 845         if (error != 0)
 846                 return;
 847
 848         if (val) {
 849                 /* Acknowledge */
 850                 axp8xx_write(dev, AXP_IRQSTAT6, val);
 851         }
 852 }
 853
 854 static device_t
 855 axp8xx_gpio_get_bus(device_t dev)
 856 {
 857         struct axp8xx_softc *sc;
 858
 859         sc = device_get_softc(dev);
 860
 861         return (sc->gpiodev);
 862 }
 863
 864 static int
 865 axp8xx_gpio_pin_max(device_t dev, int *maxpin)
 866 {
 867         *maxpin = nitems(axp8xx_pins) - 1;
 868
 869         return (0);
 870 }
 871
 872 static int
 873 axp8xx_gpio_pin_getname(device_t dev, uint32_t pin, char *name)
 874 {
 875         if (pin >= nitems(axp8xx_pins))
 876                 return (EINVAL);
 877
 878         snprintf(name, GPIOMAXNAME, "%s", axp8xx_pins[pin].name);
 879
 880         return (0);
 881 }
 882
 883 static int
 884 axp8xx_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps)
 885 {
 886         if (pin >= nitems(axp8xx_pins))
 887                 return (EINVAL);
 888
 889         *caps = GPIO_PIN_INPUT | GPIO_PIN_OUTPUT;
 890
 891         return (0);
 892 }
 893
 894 static int
 895 axp8xx_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags)
 896 {
 897         struct axp8xx_softc *sc;
 898         uint8_t data, func;
 899         int error;
 900
 901         if (pin >= nitems(axp8xx_pins))
 902                 return (EINVAL);
 903
 904         sc = device_get_softc(dev);
 905
 906         AXP_LOCK(sc);
 907         error = axp8xx_read(dev, axp8xx_pins[pin].ctrl_reg, &data, 1);
 908         if (error == 0) {
 909                 func = (data & AXP_GPIO_FUNC) >> AXP_GPIO_FUNC_SHIFT;
 910                 if (func == AXP_GPIO_FUNC_INPUT)
 911                         *flags = GPIO_PIN_INPUT;
 912                 else if (func == AXP_GPIO_FUNC_DRVLO ||
 913                     func == AXP_GPIO_FUNC_DRVHI)
 914                         *flags = GPIO_PIN_OUTPUT;
 915                 else
 916                         *flags = 0;
 917         }
 918         AXP_UNLOCK(sc);
 919
 920         return (error);
 921 }
 922
 923 static int
 924 axp8xx_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags)
 925 {
 926         struct axp8xx_softc *sc;
 927         uint8_t data;
 928         int error;
 929
 930         if (pin >= nitems(axp8xx_pins))
 931                 return (EINVAL);
 932
 933         sc = device_get_softc(dev);
 934
 935         AXP_LOCK(sc);
 936         error = axp8xx_read(dev, axp8xx_pins[pin].ctrl_reg, &data, 1);
 937         if (error == 0) {
 938                 data &= ~AXP_GPIO_FUNC;
 939                 if ((flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) != 0) {
 940                         if ((flags & GPIO_PIN_OUTPUT) == 0)
 941                                 data |= AXP_GPIO_FUNC_INPUT;
 942                 }
 943                 error = axp8xx_write(dev, axp8xx_pins[pin].ctrl_reg, data);
 944         }
 945         AXP_UNLOCK(sc);
 946
 947         return (error);
 948 }
 949
 950 static int
 951 axp8xx_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val)
 952 {
 953         struct axp8xx_softc *sc;
 954         uint8_t data, func;
 955         int error;
 956
 957         if (pin >= nitems(axp8xx_pins))
 958                 return (EINVAL);
 959
 960         sc = device_get_softc(dev);
 961
 962         AXP_LOCK(sc);
 963         error = axp8xx_read(dev, axp8xx_pins[pin].ctrl_reg, &data, 1);
 964         if (error == 0) {
 965                 func = (data & AXP_GPIO_FUNC) >> AXP_GPIO_FUNC_SHIFT;
 966                 switch (func) {
 967                 case AXP_GPIO_FUNC_DRVLO:
 968                         *val = 0;
 969                         break;
 970                 case AXP_GPIO_FUNC_DRVHI:
 971                         *val = 1;
 972                         break;
 973                 case AXP_GPIO_FUNC_INPUT:
 974                         error = axp8xx_read(dev, AXP_GPIO_SIGBIT, &data, 1);
 975                         if (error == 0)
 976                                 *val = (data & (1 << pin)) ? 1 : 0;
 977                         break;
 978                 default:
 979                         error = EIO;
 980                         break;
 981                 }
 982         }
 983         AXP_UNLOCK(sc);
 984
 985         return (error);
 986 }
 987
 988 static int
 989 axp8xx_gpio_pin_set(device_t dev, uint32_t pin, unsigned int val)
 990 {
 991         struct axp8xx_softc *sc;
 992         uint8_t data, func;
 993         int error;
 994
 995         if (pin >= nitems(axp8xx_pins))
 996                 return (EINVAL);
 997
 998         sc = device_get_softc(dev);
 999
1000         AXP_LOCK(sc);
1001         error = axp8xx_read(dev, axp8xx_pins[pin].ctrl_reg, &data, 1);
1002         if (error == 0) {
1003                 func = (data & AXP_GPIO_FUNC) >> AXP_GPIO_FUNC_SHIFT;
1004                 switch (func) {
1005                 case AXP_GPIO_FUNC_DRVLO:
1006                 case AXP_GPIO_FUNC_DRVHI:
1007                         data &= ~AXP_GPIO_FUNC;
1008                         data |= (val << AXP_GPIO_FUNC_SHIFT);
1009                         break;
1010                 default:
1011                         error = EIO;
1012                         break;
1013                 }
1014         }
1015         if (error == 0)
1016                 error = axp8xx_write(dev, axp8xx_pins[pin].ctrl_reg, data);
1017         AXP_UNLOCK(sc);
1018
1019         return (error);
1020 }
1021
1022
1023 static int
1024 axp8xx_gpio_pin_toggle(device_t dev, uint32_t pin)
1025 {
1026         struct axp8xx_softc *sc;
1027         uint8_t data, func;
1028         int error;
1029
1030         if (pin >= nitems(axp8xx_pins))
1031                 return (EINVAL);
1032
1033         sc = device_get_softc(dev);
1034
1035         AXP_LOCK(sc);
1036         error = axp8xx_read(dev, axp8xx_pins[pin].ctrl_reg, &data, 1);
1037         if (error == 0) {
1038                 func = (data & AXP_GPIO_FUNC) >> AXP_GPIO_FUNC_SHIFT;
1039                 switch (func) {
1040                 case AXP_GPIO_FUNC_DRVLO:
1041                         data &= ~AXP_GPIO_FUNC;
1042                         data |= (AXP_GPIO_FUNC_DRVHI << AXP_GPIO_FUNC_SHIFT);
1043                         break;
1044                 case AXP_GPIO_FUNC_DRVHI:
1045                         data &= ~AXP_GPIO_FUNC;
1046                         data |= (AXP_GPIO_FUNC_DRVLO << AXP_GPIO_FUNC_SHIFT);
1047                         break;
1048                 default:
1049                         error = EIO;
1050                         break;
1051                 }
1052         }
1053         if (error == 0)
1054                 error = axp8xx_write(dev, axp8xx_pins[pin].ctrl_reg, data);
1055         AXP_UNLOCK(sc);
1056
1057         return (error);
1058 }
1059
1060 static int
1061 axp8xx_gpio_map_gpios(device_t bus, phandle_t dev, phandle_t gparent,
1062     int gcells, pcell_t *gpios, uint32_t *pin, uint32_t *flags)
1063 {
1064         if (gpios[0] >= nitems(axp8xx_pins))
1065                 return (EINVAL);
1066
1067         *pin = gpios[0];
1068         *flags = gpios[1];
1069
1070         return (0);
1071 }
1072
1073 static phandle_t
1074 axp8xx_get_node(device_t dev, device_t bus)
1075 {
1076         return (ofw_bus_get_node(dev));
1077 }
1078
1079 static struct axp8xx_reg_sc *
1080 axp8xx_reg_attach(device_t dev, phandle_t node,
1081     struct axp8xx_regdef *def)
1082 {
1083         struct axp8xx_reg_sc *reg_sc;
1084         struct regnode_init_def initdef;
1085         struct regnode *regnode;
1086
1087         memset(&initdef, 0, sizeof(initdef));
1088         if (regulator_parse_ofw_stdparam(dev, node, &initdef) != 0)
1089                 return (NULL);
1090         if (initdef.std_param.min_uvolt == 0)
1091                 initdef.std_param.min_uvolt = def->voltage_min * 1000;
1092         if (initdef.std_param.max_uvolt == 0)
1093                 initdef.std_param.max_uvolt = def->voltage_max * 1000;
1094         initdef.id = def->id;
1095         initdef.ofw_node = node;
1096         regnode = regnode_create(dev, &axp8xx_regnode_class, &initdef);
1097         if (regnode == NULL) {
1098                 device_printf(dev, "cannot create regulator\n");
1099                 return (NULL);
1100         }
1101
1102         reg_sc = regnode_get_softc(regnode);
1103         reg_sc->regnode = regnode;
1104         reg_sc->base_dev = dev;
1105         reg_sc->def = def;
1106         reg_sc->xref = OF_xref_from_node(node);
1107         reg_sc->param = regnode_get_stdparam(regnode);
1108
1109         regnode_register(regnode);
1110
1111         return (reg_sc);
1112 }
1113
1114 static int
1115 axp8xx_regdev_map(device_t dev, phandle_t xref, int ncells, pcell_t *cells,
1116     intptr_t *num)
1117 {
1118         struct axp8xx_softc *sc;
1119         int i;
1120
1121         sc = device_get_softc(dev);
1122         for (i = 0; i < sc->nregs; i++) {
1123                 if (sc->regs[i] == NULL)
1124                         continue;
1125                 if (sc->regs[i]->xref == xref) {
1126                         *num = sc->regs[i]->def->id;
1127                         return (0);
1128                 }
1129         }
1130
1131         return (ENXIO);
1132 }
1133
1134 static int
1135 axp8xx_probe(device_t dev)
1136 {
1137         if (!ofw_bus_status_okay(dev))
1138                 return (ENXIO);
1139
1140         switch (ofw_bus_search_compatible(dev, compat_data)->ocd_data)
1141         {
1142         case AXP803:
1143                 device_set_desc(dev, "X-Powers AXP803 Power Management Unit");
1144                 break;
1145         case AXP813:
1146                 device_set_desc(dev, "X-Powers AXP813 Power Management Unit");
1147                 break;
1148         default:
1149                 return (ENXIO);
1150         }
1151
1152         return (BUS_PROBE_DEFAULT);
1153 }
1154
1155 static int
1156 axp8xx_attach(device_t dev)
1157 {
1158         struct axp8xx_softc *sc;
1159         struct axp8xx_reg_sc *reg;
1160         uint8_t chip_id;
1161         phandle_t rnode, child;
1162         int error, i;
1163
1164         sc = device_get_softc(dev);
1165
1166         sc->addr = iicbus_get_addr(dev);
1167         mtx_init(&sc->mtx, device_get_nameunit(dev), NULL, MTX_DEF);
1168
1169         error = bus_alloc_resources(dev, axp8xx_spec, &sc->res);
1170         if (error != 0) {
1171                 device_printf(dev, "cannot allocate resources for device\n");
1172                 return (error);
1173         }
1174
1175         if (bootverbose) {
1176                 axp8xx_read(dev, AXP_ICTYPE, &chip_id, 1);
1177                 device_printf(dev, "chip ID 0x%02x\n", chip_id);
1178         }
1179
1180         sc->nregs = nitems(axp8xx_common_regdefs);
1181         sc->type = ofw_bus_search_compatible(dev, compat_data)->ocd_data;
1182         switch (sc->type) {
1183         case AXP803:
1184                 sc->nregs += nitems(axp803_regdefs);
1185                 break;
1186         case AXP813:
1187                 sc->nregs += nitems(axp813_regdefs);
1188                 break;
1189         }
1190         sc->regs = malloc(sizeof(struct axp8xx_reg_sc *) * sc->nregs,
1191             M_AXP8XX_REG, M_WAITOK | M_ZERO);
1192
1193         /* Attach known regulators that exist in the DT */
1194         rnode = ofw_bus_find_child(ofw_bus_get_node(dev), "regulators");
1195         if (rnode > 0) {
1196                 for (i = 0; i < sc->nregs; i++) {
1197                         char *regname;
1198                         struct axp8xx_regdef *regdef;
1199
1200                         if (i <= nitems(axp8xx_common_regdefs)) {
1201                                 regname = axp8xx_common_regdefs[i].name;
1202                                 regdef = &axp8xx_common_regdefs[i];
1203                         } else {
1204                                 int off;
1205
1206                                 off = i - nitems(axp8xx_common_regdefs);
1207                                 switch (sc->type) {
1208                                 case AXP803:
1209                                         regname = axp803_regdefs[off].name;
1210                                         regdef = &axp803_regdefs[off];
1211                                         break;
1212                                 case AXP813:
1213                                         regname = axp813_regdefs[off].name;
1214                                         regdef = &axp813_regdefs[off];
1215                                         break;
1216                                 }
1217                         }
1218                         child = ofw_bus_find_child(rnode,
1219                             regname);
1220                         if (child == 0)
1221                                 continue;
1222                         reg = axp8xx_reg_attach(dev, child,
1223                             regdef);
1224                         if (reg == NULL) {
1225                                 device_printf(dev,
1226                                     "cannot attach regulator %s\n",
1227                                     regname);
1228                                 continue;
1229                         }
1230                         sc->regs[i] = reg;
1231                 }
1232         }
1233
1234         /* Enable interrupts */
1235         axp8xx_write(dev, AXP_IRQEN1,
1236             AXP_IRQEN1_VBUS_LO |
1237             AXP_IRQEN1_VBUS_HI |
1238             AXP_IRQEN1_ACIN_LO |
1239             AXP_IRQEN1_ACIN_HI);
1240         axp8xx_write(dev, AXP_IRQEN2,
1241             AXP_IRQEN2_BATCHGD |
1242             AXP_IRQEN2_BATCHGC |
1243             AXP_IRQEN2_BAT_NO |
1244             AXP_IRQEN2_BAT_IN);
1245         axp8xx_write(dev, AXP_IRQEN3, 0);
1246         axp8xx_write(dev, AXP_IRQEN4,
1247             AXP_IRQEN4_BATLVL_LO0 |
1248             AXP_IRQEN4_BATLVL_LO1);
1249         axp8xx_write(dev, AXP_IRQEN5,
1250             AXP_IRQEN5_POKSIRQ |
1251             AXP_IRQEN5_POKLIRQ);
1252         axp8xx_write(dev, AXP_IRQEN6, 0);
1253
1254         /* Install interrupt handler */
1255         error = bus_setup_intr(dev, sc->res, INTR_TYPE_MISC | INTR_MPSAFE,
1256             NULL, axp8xx_intr, dev, &sc->ih);
1257         if (error != 0) {
1258                 device_printf(dev, "cannot setup interrupt handler\n");
1259                 return (error);
1260         }
1261
1262         EVENTHANDLER_REGISTER(shutdown_final, axp8xx_shutdown, dev,
1263             SHUTDOWN_PRI_LAST);
1264
1265         sc->gpiodev = gpiobus_attach_bus(dev);
1266
1267         return (0);
1268 }
1269
1270 static device_method_t axp8xx_methods[] = {
1271         /* Device interface */
1272         DEVMETHOD(device_probe,         axp8xx_probe),
1273         DEVMETHOD(device_attach,        axp8xx_attach),
1274
1275         /* GPIO interface */
1276         DEVMETHOD(gpio_get_bus,         axp8xx_gpio_get_bus),
1277         DEVMETHOD(gpio_pin_max,         axp8xx_gpio_pin_max),
1278         DEVMETHOD(gpio_pin_getname,     axp8xx_gpio_pin_getname),
1279         DEVMETHOD(gpio_pin_getcaps,     axp8xx_gpio_pin_getcaps),
1280         DEVMETHOD(gpio_pin_getflags,    axp8xx_gpio_pin_getflags),
1281         DEVMETHOD(gpio_pin_setflags,    axp8xx_gpio_pin_setflags),
1282         DEVMETHOD(gpio_pin_get,         axp8xx_gpio_pin_get),
1283         DEVMETHOD(gpio_pin_set,         axp8xx_gpio_pin_set),
1284         DEVMETHOD(gpio_pin_toggle,      axp8xx_gpio_pin_toggle),
1285         DEVMETHOD(gpio_map_gpios,       axp8xx_gpio_map_gpios),
1286
1287         /* Regdev interface */
1288         DEVMETHOD(regdev_map,           axp8xx_regdev_map),
1289
1290         /* OFW bus interface */
1291         DEVMETHOD(ofw_bus_get_node,     axp8xx_get_node),
1292
1293         DEVMETHOD_END
1294 };
1295
1296 static driver_t axp8xx_driver = {
1297         "axp8xx_pmu",
1298         axp8xx_methods,
1299         sizeof(struct axp8xx_softc),
1300 };
1301
1302 static devclass_t axp8xx_devclass;
1303 extern devclass_t ofwgpiobus_devclass, gpioc_devclass;
1304 extern driver_t ofw_gpiobus_driver, gpioc_driver;
1305
1306 EARLY_DRIVER_MODULE(axp8xx, iicbus, axp8xx_driver, axp8xx_devclass, 0, 0,
1307     BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LAST);
1308 EARLY_DRIVER_MODULE(ofw_gpiobus, axp8xx_pmu, ofw_gpiobus_driver,
1309     ofwgpiobus_devclass, 0, 0, BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LAST);
1310 DRIVER_MODULE(gpioc, axp8xx_pmu, gpioc_driver, gpioc_devclass, 0, 0);
1311 MODULE_VERSION(axp8xx, 1);
1312 MODULE_DEPEND(axp8xx, iicbus, 1, 1, 1);