sys/arm/allwinner/axp209.c

   1 /*-
   2  * Copyright (c) 2015-2016 Emmanuel Vadot <manu@freebsd.org>
   3  * Copyright (c) 2016 Jared McNeill <jmcneill@invisible.ca>
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 /*
  31 * X-Power AXP209/AXP211 PMU for Allwinner SoCs
  32 */
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/eventhandler.h>
  37 #include <sys/kernel.h>
  38 #include <sys/module.h>
  39 #include <sys/clock.h>
  40 #include <sys/time.h>
  41 #include <sys/bus.h>
  42 #include <sys/proc.h>
  43 #include <sys/gpio.h>
  44 #include <sys/reboot.h>
  45 #include <sys/resource.h>
  46 #include <sys/rman.h>
  47 #include <sys/sysctl.h>
  48
  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 <arm/allwinner/axp209reg.h>
  59
  60 #include "gpio_if.h"
  61 #include "regdev_if.h"
  62
  63 MALLOC_DEFINE(M_AXP2XX_REG, "Axp2XX regulator", "Axp2XX power regulator");
  64
  65 struct axp2xx_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         uint8_t                 voltage_shift;
  73         int                     voltage_min;
  74         int                     voltage_max;
  75         int                     voltage_step;
  76         int                     voltage_nstep;
  77 };
  78
  79 static struct axp2xx_regdef axp209_regdefs[] = {
  80         {
  81                 .id = AXP209_REG_ID_DCDC2,
  82                 .name = "dcdc2",
  83                 .enable_reg = AXP209_POWERCTL,
  84                 .enable_mask = AXP209_POWERCTL_DCDC2,
  85                 .voltage_reg = AXP209_REG_DCDC2_VOLTAGE,
  86                 .voltage_mask = 0x3f,
  87                 .voltage_min = 700,
  88                 .voltage_max = 2275,
  89                 .voltage_step = 25,
  90                 .voltage_nstep = 64,
  91         },
  92         {
  93                 .id = AXP209_REG_ID_DCDC3,
  94                 .name = "dcdc3",
  95                 .enable_reg = AXP209_POWERCTL,
  96                 .enable_mask = AXP209_POWERCTL_DCDC3,
  97                 .voltage_reg = AXP209_REG_DCDC3_VOLTAGE,
  98                 .voltage_mask = 0x7f,
  99                 .voltage_min = 700,
 100                 .voltage_max = 3500,
 101                 .voltage_step = 25,
 102                 .voltage_nstep = 128,
 103         },
 104         {
 105                 .id = AXP209_REG_ID_LDO2,
 106                 .name = "ldo2",
 107                 .enable_reg = AXP209_POWERCTL,
 108                 .enable_mask = AXP209_POWERCTL_LDO2,
 109                 .voltage_reg = AXP209_REG_LDO24_VOLTAGE,
 110                 .voltage_mask = 0xf0,
 111                 .voltage_shift = 4,
 112                 .voltage_min = 1800,
 113                 .voltage_max = 3300,
 114                 .voltage_step = 100,
 115                 .voltage_nstep = 16,
 116         },
 117         {
 118                 .id = AXP209_REG_ID_LDO3,
 119                 .name = "ldo3",
 120                 .enable_reg = AXP209_POWERCTL,
 121                 .enable_mask = AXP209_POWERCTL_LDO3,
 122                 .voltage_reg = AXP209_REG_LDO3_VOLTAGE,
 123                 .voltage_mask = 0x7f,
 124                 .voltage_min = 700,
 125                 .voltage_max = 2275,
 126                 .voltage_step = 25,
 127                 .voltage_nstep = 128,
 128         },
 129 };
 130
 131 static struct axp2xx_regdef axp221_regdefs[] = {
 132         {
 133                 .id = AXP221_REG_ID_DLDO1,
 134                 .name = "dldo1",
 135                 .enable_reg = AXP221_POWERCTL_2,
 136                 .enable_mask = AXP221_POWERCTL2_DLDO1,
 137                 .voltage_reg = AXP221_REG_DLDO1_VOLTAGE,
 138                 .voltage_mask = 0x1f,
 139                 .voltage_min = 700,
 140                 .voltage_max = 3300,
 141                 .voltage_step = 100,
 142                 .voltage_nstep = 26,
 143         },
 144         {
 145                 .id = AXP221_REG_ID_DLDO2,
 146                 .name = "dldo2",
 147                 .enable_reg = AXP221_POWERCTL_2,
 148                 .enable_mask = AXP221_POWERCTL2_DLDO2,
 149                 .voltage_reg = AXP221_REG_DLDO2_VOLTAGE,
 150                 .voltage_mask = 0x1f,
 151                 .voltage_min = 700,
 152                 .voltage_max = 3300,
 153                 .voltage_step = 100,
 154                 .voltage_nstep = 26,
 155         },
 156         {
 157                 .id = AXP221_REG_ID_DLDO3,
 158                 .name = "dldo3",
 159                 .enable_reg = AXP221_POWERCTL_2,
 160                 .enable_mask = AXP221_POWERCTL2_DLDO3,
 161                 .voltage_reg = AXP221_REG_DLDO3_VOLTAGE,
 162                 .voltage_mask = 0x1f,
 163                 .voltage_min = 700,
 164                 .voltage_max = 3300,
 165                 .voltage_step = 100,
 166                 .voltage_nstep = 26,
 167         },
 168         {
 169                 .id = AXP221_REG_ID_DLDO4,
 170                 .name = "dldo4",
 171                 .enable_reg = AXP221_POWERCTL_2,
 172                 .enable_mask = AXP221_POWERCTL2_DLDO4,
 173                 .voltage_reg = AXP221_REG_DLDO4_VOLTAGE,
 174                 .voltage_mask = 0x1f,
 175                 .voltage_min = 700,
 176                 .voltage_max = 3300,
 177                 .voltage_step = 100,
 178                 .voltage_nstep = 26,
 179         },
 180         {
 181                 .id = AXP221_REG_ID_ELDO1,
 182                 .name = "eldo1",
 183                 .enable_reg = AXP221_POWERCTL_2,
 184                 .enable_mask = AXP221_POWERCTL2_ELDO1,
 185                 .voltage_reg = AXP221_REG_ELDO1_VOLTAGE,
 186                 .voltage_mask = 0x1f,
 187                 .voltage_min = 700,
 188                 .voltage_max = 3300,
 189                 .voltage_step = 100,
 190                 .voltage_nstep = 26,
 191         },
 192         {
 193                 .id = AXP221_REG_ID_ELDO2,
 194                 .name = "eldo2",
 195                 .enable_reg = AXP221_POWERCTL_2,
 196                 .enable_mask = AXP221_POWERCTL2_ELDO2,
 197                 .voltage_reg = AXP221_REG_ELDO2_VOLTAGE,
 198                 .voltage_mask = 0x1f,
 199                 .voltage_min = 700,
 200                 .voltage_max = 3300,
 201                 .voltage_step = 100,
 202                 .voltage_nstep = 26,
 203         },
 204         {
 205                 .id = AXP221_REG_ID_ELDO3,
 206                 .name = "eldo3",
 207                 .enable_reg = AXP221_POWERCTL_2,
 208                 .enable_mask = AXP221_POWERCTL2_ELDO3,
 209                 .voltage_reg = AXP221_REG_ELDO3_VOLTAGE,
 210                 .voltage_mask = 0x1f,
 211                 .voltage_min = 700,
 212                 .voltage_max = 3300,
 213                 .voltage_step = 100,
 214                 .voltage_nstep = 26,
 215         },
 216         {
 217                 .id = AXP221_REG_ID_DC5LDO,
 218                 .name = "dc5ldo",
 219                 .enable_reg = AXP221_POWERCTL_1,
 220                 .enable_mask = AXP221_POWERCTL1_DC5LDO,
 221                 .voltage_reg = AXP221_REG_DC5LDO_VOLTAGE,
 222                 .voltage_mask = 0x3,
 223                 .voltage_min = 700,
 224                 .voltage_max = 1400,
 225                 .voltage_step = 100,
 226                 .voltage_nstep = 7,
 227         },
 228         {
 229                 .id = AXP221_REG_ID_DCDC1,
 230                 .name = "dcdc1",
 231                 .enable_reg = AXP221_POWERCTL_1,
 232                 .enable_mask = AXP221_POWERCTL1_DCDC1,
 233                 .voltage_reg = AXP221_REG_DCDC1_VOLTAGE,
 234                 .voltage_mask = 0x1f,
 235                 .voltage_min = 1600,
 236                 .voltage_max = 3400,
 237                 .voltage_step = 100,
 238                 .voltage_nstep = 18,
 239         },
 240         {
 241                 .id = AXP221_REG_ID_DCDC2,
 242                 .name = "dcdc2",
 243                 .enable_reg = AXP221_POWERCTL_1,
 244                 .enable_mask = AXP221_POWERCTL1_DCDC2,
 245                 .voltage_reg = AXP221_REG_DCDC2_VOLTAGE,
 246                 .voltage_mask = 0x3f,
 247                 .voltage_min = 600,
 248                 .voltage_max = 1540,
 249                 .voltage_step = 20,
 250                 .voltage_nstep = 47,
 251         },
 252         {
 253                 .id = AXP221_REG_ID_DCDC3,
 254                 .name = "dcdc3",
 255                 .enable_reg = AXP221_POWERCTL_1,
 256                 .enable_mask = AXP221_POWERCTL1_DCDC3,
 257                 .voltage_reg = AXP221_REG_DCDC3_VOLTAGE,
 258                 .voltage_mask = 0x3f,
 259                 .voltage_min = 600,
 260                 .voltage_max = 1860,
 261                 .voltage_step = 20,
 262                 .voltage_nstep = 63,
 263         },
 264         {
 265                 .id = AXP221_REG_ID_DCDC4,
 266                 .name = "dcdc4",
 267                 .enable_reg = AXP221_POWERCTL_1,
 268                 .enable_mask = AXP221_POWERCTL1_DCDC4,
 269                 .voltage_reg = AXP221_REG_DCDC4_VOLTAGE,
 270                 .voltage_mask = 0x3f,
 271                 .voltage_min = 600,
 272                 .voltage_max = 1540,
 273                 .voltage_step = 20,
 274                 .voltage_nstep = 47,
 275         },
 276         {
 277                 .id = AXP221_REG_ID_DCDC5,
 278                 .name = "dcdc5",
 279                 .enable_reg = AXP221_POWERCTL_1,
 280                 .enable_mask = AXP221_POWERCTL1_DCDC5,
 281                 .voltage_reg = AXP221_REG_DCDC5_VOLTAGE,
 282                 .voltage_mask = 0x1f,
 283                 .voltage_min = 1000,
 284                 .voltage_max = 2550,
 285                 .voltage_step = 50,
 286                 .voltage_nstep = 31,
 287         },
 288         {
 289                 .id = AXP221_REG_ID_ALDO1,
 290                 .name = "aldo1",
 291                 .enable_reg = AXP221_POWERCTL_1,
 292                 .enable_mask = AXP221_POWERCTL1_ALDO1,
 293                 .voltage_reg = AXP221_REG_ALDO1_VOLTAGE,
 294                 .voltage_mask = 0x1f,
 295                 .voltage_min = 700,
 296                 .voltage_max = 3300,
 297                 .voltage_step = 100,
 298                 .voltage_nstep = 26,
 299         },
 300         {
 301                 .id = AXP221_REG_ID_ALDO2,
 302                 .name = "aldo2",
 303                 .enable_reg = AXP221_POWERCTL_1,
 304                 .enable_mask = AXP221_POWERCTL1_ALDO2,
 305                 .voltage_reg = AXP221_REG_ALDO2_VOLTAGE,
 306                 .voltage_mask = 0x1f,
 307                 .voltage_min = 700,
 308                 .voltage_max = 3300,
 309                 .voltage_step = 100,
 310                 .voltage_nstep = 26,
 311         },
 312         {
 313                 .id = AXP221_REG_ID_ALDO3,
 314                 .name = "aldo3",
 315                 .enable_reg = AXP221_POWERCTL_3,
 316                 .enable_mask = AXP221_POWERCTL3_ALDO3,
 317                 .voltage_reg = AXP221_REG_ALDO3_VOLTAGE,
 318                 .voltage_mask = 0x1f,
 319                 .voltage_min = 700,
 320                 .voltage_max = 3300,
 321                 .voltage_step = 100,
 322                 .voltage_nstep = 26,
 323         },
 324         {
 325                 .id = AXP221_REG_ID_DC1SW,
 326                 .name = "dc1sw",
 327                 .enable_reg = AXP221_POWERCTL_2,
 328                 .enable_mask = AXP221_POWERCTL2_DC1SW,
 329         },
 330 };
 331
 332 struct axp2xx_reg_sc {
 333         struct regnode          *regnode;
 334         device_t                base_dev;
 335         struct axp2xx_regdef    *def;
 336         phandle_t               xref;
 337         struct regnode_std_param *param;
 338 };
 339
 340 struct axp2xx_pins {
 341         const char      *name;
 342         uint8_t         ctrl_reg;
 343         uint8_t         status_reg;
 344         uint8_t         status_mask;
 345         uint8_t         status_shift;
 346 };
 347
 348 /* GPIO3 is different, don't expose it for now */
 349 static const struct axp2xx_pins axp209_pins[] = {
 350         {
 351                 .name = "GPIO0",
 352                 .ctrl_reg = AXP2XX_GPIO0_CTRL,
 353                 .status_reg = AXP2XX_GPIO_STATUS,
 354                 .status_mask = 0x10,
 355                 .status_shift = 4,
 356         },
 357         {
 358                 .name = "GPIO1",
 359                 .ctrl_reg = AXP2XX_GPIO1_CTRL,
 360                 .status_reg = AXP2XX_GPIO_STATUS,
 361                 .status_mask = 0x20,
 362                 .status_shift = 5,
 363         },
 364         {
 365                 .name = "GPIO2",
 366                 .ctrl_reg = AXP209_GPIO2_CTRL,
 367                 .status_reg = AXP2XX_GPIO_STATUS,
 368                 .status_mask = 0x40,
 369                 .status_shift = 6,
 370         },
 371 };
 372
 373 static const struct axp2xx_pins axp221_pins[] = {
 374         {
 375                 .name = "GPIO0",
 376                 .ctrl_reg = AXP2XX_GPIO0_CTRL,
 377                 .status_reg = AXP2XX_GPIO_STATUS,
 378                 .status_mask = 0x1,
 379                 .status_shift = 0x0,
 380         },
 381         {
 382                 .name = "GPIO1",
 383                 .ctrl_reg = AXP2XX_GPIO0_CTRL,
 384                 .status_reg = AXP2XX_GPIO_STATUS,
 385                 .status_mask = 0x2,
 386                 .status_shift = 0x1,
 387         },
 388 };
 389
 390 struct axp2xx_sensors {
 391         int             id;
 392         const char      *name;
 393         const char      *desc;
 394         const char      *format;
 395         uint8_t         enable_reg;
 396         uint8_t         enable_mask;
 397         uint8_t         value_reg;
 398         uint8_t         value_size;
 399         uint8_t         h_value_mask;
 400         uint8_t         h_value_shift;
 401         uint8_t         l_value_mask;
 402         uint8_t         l_value_shift;
 403         int             value_step;
 404         int             value_convert;
 405 };
 406
 407 static const struct axp2xx_sensors axp209_sensors[] = {
 408         {
 409                 .id = AXP209_ACVOLT,
 410                 .name = "acvolt",
 411                 .desc = "AC Voltage (microvolt)",
 412                 .format = "I",
 413                 .enable_reg = AXP2XX_ADC_ENABLE1,
 414                 .enable_mask = AXP209_ADC1_ACVOLT,
 415                 .value_reg = AXP209_ACIN_VOLTAGE,
 416                 .value_size = 2,
 417                 .h_value_mask = 0xff,
 418                 .h_value_shift = 4,
 419                 .l_value_mask = 0xf,
 420                 .l_value_shift = 0,
 421                 .value_step = AXP209_VOLT_STEP,
 422         },
 423         {
 424                 .id = AXP209_ACCURRENT,
 425                 .name = "accurrent",
 426                 .desc = "AC Current (microAmpere)",
 427                 .format = "I",
 428                 .enable_reg = AXP2XX_ADC_ENABLE1,
 429                 .enable_mask = AXP209_ADC1_ACCURRENT,
 430                 .value_reg = AXP209_ACIN_CURRENT,
 431                 .value_size = 2,
 432                 .h_value_mask = 0xff,
 433                 .h_value_shift = 4,
 434                 .l_value_mask = 0xf,
 435                 .l_value_shift = 0,
 436                 .value_step = AXP209_ACCURRENT_STEP,
 437         },
 438         {
 439                 .id = AXP209_VBUSVOLT,
 440                 .name = "vbusvolt",
 441                 .desc = "VBUS Voltage (microVolt)",
 442                 .format = "I",
 443                 .enable_reg = AXP2XX_ADC_ENABLE1,
 444                 .enable_mask = AXP209_ADC1_VBUSVOLT,
 445                 .value_reg = AXP209_VBUS_VOLTAGE,
 446                 .value_size = 2,
 447                 .h_value_mask = 0xff,
 448                 .h_value_shift = 4,
 449                 .l_value_mask = 0xf,
 450                 .l_value_shift = 0,
 451                 .value_step = AXP209_VOLT_STEP,
 452         },
 453         {
 454                 .id = AXP209_VBUSCURRENT,
 455                 .name = "vbuscurrent",
 456                 .desc = "VBUS Current (microAmpere)",
 457                 .format = "I",
 458                 .enable_reg = AXP2XX_ADC_ENABLE1,
 459                 .enable_mask = AXP209_ADC1_VBUSCURRENT,
 460                 .value_reg = AXP209_VBUS_CURRENT,
 461                 .value_size = 2,
 462                 .h_value_mask = 0xff,
 463                 .h_value_shift = 4,
 464                 .l_value_mask = 0xf,
 465                 .l_value_shift = 0,
 466                 .value_step = AXP209_VBUSCURRENT_STEP,
 467         },
 468         {
 469                 .id = AXP2XX_BATVOLT,
 470                 .name = "batvolt",
 471                 .desc = "Battery Voltage (microVolt)",
 472                 .format = "I",
 473                 .enable_reg = AXP2XX_ADC_ENABLE1,
 474                 .enable_mask = AXP2XX_ADC1_BATVOLT,
 475                 .value_reg = AXP2XX_BAT_VOLTAGE,
 476                 .value_size = 2,
 477                 .h_value_mask = 0xff,
 478                 .h_value_shift = 4,
 479                 .l_value_mask = 0xf,
 480                 .l_value_shift = 0,
 481                 .value_step = AXP2XX_BATVOLT_STEP,
 482         },
 483         {
 484                 .id = AXP2XX_BATCHARGECURRENT,
 485                 .name = "batchargecurrent",
 486                 .desc = "Battery Charging Current (microAmpere)",
 487                 .format = "I",
 488                 .enable_reg = AXP2XX_ADC_ENABLE1,
 489                 .enable_mask = AXP2XX_ADC1_BATCURRENT,
 490                 .value_reg = AXP2XX_BAT_CHARGE_CURRENT,
 491                 .value_size = 2,
 492                 .h_value_mask = 0xff,
 493                 .h_value_shift = 5,
 494                 .l_value_mask = 0x1f,
 495                 .l_value_shift = 0,
 496                 .value_step = AXP2XX_BATCURRENT_STEP,
 497         },
 498         {
 499                 .id = AXP2XX_BATDISCHARGECURRENT,
 500                 .name = "batdischargecurrent",
 501                 .desc = "Battery Discharging Current (microAmpere)",
 502                 .format = "I",
 503                 .enable_reg = AXP2XX_ADC_ENABLE1,
 504                 .enable_mask = AXP2XX_ADC1_BATCURRENT,
 505                 .value_reg = AXP2XX_BAT_DISCHARGE_CURRENT,
 506                 .value_size = 2,
 507                 .h_value_mask = 0xff,
 508                 .h_value_shift = 5,
 509                 .l_value_mask = 0x1f,
 510                 .l_value_shift = 0,
 511                 .value_step = AXP2XX_BATCURRENT_STEP,
 512         },
 513         {
 514                 .id = AXP2XX_TEMP,
 515                 .name = "temp",
 516                 .desc = "Internal Temperature",
 517                 .format = "IK",
 518                 .enable_reg = AXP209_ADC_ENABLE2,
 519                 .enable_mask = AXP209_ADC2_TEMP,
 520                 .value_reg = AXP209_TEMPMON,
 521                 .value_size = 2,
 522                 .h_value_mask = 0xff,
 523                 .h_value_shift = 4,
 524                 .l_value_mask = 0xf,
 525                 .l_value_shift = 0,
 526                 .value_step = 1,
 527                 .value_convert = -(AXP209_TEMPMON_MIN - AXP209_0C_TO_K),
 528         },
 529 };
 530
 531 static const struct axp2xx_sensors axp221_sensors[] = {
 532         {
 533                 .id = AXP2XX_BATVOLT,
 534                 .name = "batvolt",
 535                 .desc = "Battery Voltage (microVolt)",
 536                 .format = "I",
 537                 .enable_reg = AXP2XX_ADC_ENABLE1,
 538                 .enable_mask = AXP2XX_ADC1_BATVOLT,
 539                 .value_reg = AXP2XX_BAT_VOLTAGE,
 540                 .value_size = 2,
 541                 .h_value_mask = 0xff,
 542                 .h_value_shift = 4,
 543                 .l_value_mask = 0xf,
 544                 .l_value_shift = 0,
 545                 .value_step = AXP2XX_BATVOLT_STEP,
 546         },
 547         {
 548                 .id = AXP2XX_BATCHARGECURRENT,
 549                 .name = "batchargecurrent",
 550                 .desc = "Battery Charging Current (microAmpere)",
 551                 .format = "I",
 552                 .enable_reg = AXP2XX_ADC_ENABLE1,
 553                 .enable_mask = AXP2XX_ADC1_BATCURRENT,
 554                 .value_reg = AXP2XX_BAT_CHARGE_CURRENT,
 555                 .value_size = 2,
 556                 .h_value_mask = 0xff,
 557                 .h_value_shift = 5,
 558                 .l_value_mask = 0x1f,
 559                 .l_value_shift = 0,
 560                 .value_step = AXP2XX_BATCURRENT_STEP,
 561         },
 562         {
 563                 .id = AXP2XX_BATDISCHARGECURRENT,
 564                 .name = "batdischargecurrent",
 565                 .desc = "Battery Discharging Current (microAmpere)",
 566                 .format = "I",
 567                 .enable_reg = AXP2XX_ADC_ENABLE1,
 568                 .enable_mask = AXP2XX_ADC1_BATCURRENT,
 569                 .value_reg = AXP2XX_BAT_DISCHARGE_CURRENT,
 570                 .value_size = 2,
 571                 .h_value_mask = 0xff,
 572                 .h_value_shift = 5,
 573                 .l_value_mask = 0x1f,
 574                 .l_value_shift = 0,
 575                 .value_step = AXP2XX_BATCURRENT_STEP,
 576         },
 577         {
 578                 .id = AXP2XX_TEMP,
 579                 .name = "temp",
 580                 .desc = "Internal Temperature",
 581                 .format = "IK",
 582                 .enable_reg = AXP2XX_ADC_ENABLE1,
 583                 .enable_mask = AXP221_ADC1_TEMP,
 584                 .value_reg = AXP221_TEMPMON,
 585                 .value_size = 2,
 586                 .h_value_mask = 0xff,
 587                 .h_value_shift = 4,
 588                 .l_value_mask = 0xf,
 589                 .l_value_shift = 0,
 590                 .value_step = 1,
 591                 .value_convert = -(AXP221_TEMPMON_MIN - AXP209_0C_TO_K),
 592         },
 593 };
 594
 595 enum AXP2XX_TYPE {
 596         AXP209 = 1,
 597         AXP221,
 598 };
 599
 600 struct axp2xx_softc {
 601         device_t                dev;
 602         struct resource *       res[1];
 603         void *                  intrcookie;
 604         struct intr_config_hook intr_hook;
 605         struct mtx              mtx;
 606         uint8_t                 type;
 607
 608         /* GPIO */
 609         device_t                gpiodev;
 610         int                     npins;
 611         const struct axp2xx_pins        *pins;
 612
 613         /* Sensors */
 614         const struct axp2xx_sensors     *sensors;
 615         int                             nsensors;
 616
 617         /* Regulators */
 618         struct axp2xx_reg_sc    **regs;
 619         int                     nregs;
 620         struct axp2xx_regdef    *regdefs;
 621 };
 622
 623 static struct ofw_compat_data compat_data[] = {
 624         { "x-powers,axp209",            AXP209 },
 625         { "x-powers,axp221",            AXP221 },
 626         { NULL,                         0 }
 627 };
 628
 629 static struct resource_spec axp_res_spec[] = {
 630         { SYS_RES_IRQ,          0,      RF_ACTIVE },
 631         { -1,                   0,      0 }
 632 };
 633
 634 #define AXP_LOCK(sc)    mtx_lock(&(sc)->mtx)
 635 #define AXP_UNLOCK(sc)  mtx_unlock(&(sc)->mtx)
 636
 637 static int
 638 axp2xx_read(device_t dev, uint8_t reg, uint8_t *data, uint8_t size)
 639 {
 640
 641         return (iicdev_readfrom(dev, reg, data, size, IIC_INTRWAIT));
 642 }
 643
 644 static int
 645 axp2xx_write(device_t dev, uint8_t reg, uint8_t data)
 646 {
 647
 648         return (iicdev_writeto(dev, reg, &data, sizeof(data), IIC_INTRWAIT));
 649 }
 650
 651 static int
 652 axp2xx_regnode_init(struct regnode *regnode)
 653 {
 654         return (0);
 655 }
 656
 657 static int
 658 axp2xx_regnode_enable(struct regnode *regnode, bool enable, int *udelay)
 659 {
 660         struct axp2xx_reg_sc *sc;
 661         uint8_t val;
 662
 663         sc = regnode_get_softc(regnode);
 664
 665         axp2xx_read(sc->base_dev, sc->def->enable_reg, &val, 1);
 666         if (enable)
 667                 val |= sc->def->enable_mask;
 668         else
 669                 val &= ~sc->def->enable_mask;
 670         axp2xx_write(sc->base_dev, sc->def->enable_reg, val);
 671
 672         *udelay = 0;
 673
 674         return (0);
 675 }
 676
 677 static void
 678 axp2xx_regnode_reg_to_voltage(struct axp2xx_reg_sc *sc, uint8_t val, int *uv)
 679 {
 680         if (val < sc->def->voltage_nstep)
 681                 *uv = sc->def->voltage_min + val * sc->def->voltage_step;
 682         else
 683                 *uv = sc->def->voltage_min +
 684                        (sc->def->voltage_nstep * sc->def->voltage_step);
 685         *uv *= 1000;
 686 }
 687
 688 static int
 689 axp2xx_regnode_voltage_to_reg(struct axp2xx_reg_sc *sc, int min_uvolt,
 690     int max_uvolt, uint8_t *val)
 691 {
 692         uint8_t nval;
 693         int nstep, uvolt;
 694
 695         nval = 0;
 696         uvolt = sc->def->voltage_min * 1000;
 697
 698         for (nstep = 0; nstep < sc->def->voltage_nstep && uvolt < min_uvolt;
 699              nstep++) {
 700                 ++nval;
 701                 uvolt += (sc->def->voltage_step * 1000);
 702         }
 703         if (uvolt > max_uvolt)
 704                 return (EINVAL);
 705
 706         *val = nval;
 707         return (0);
 708 }
 709
 710 static int
 711 axp2xx_regnode_status(struct regnode *regnode, int *status)
 712 {
 713         struct axp2xx_reg_sc *sc;
 714         uint8_t val;
 715
 716         sc = regnode_get_softc(regnode);
 717
 718         *status = 0;
 719         axp2xx_read(sc->base_dev, sc->def->enable_reg, &val, 1);
 720         if (val & sc->def->enable_mask)
 721                 *status = REGULATOR_STATUS_ENABLED;
 722
 723         return (0);
 724 }
 725
 726 static int
 727 axp2xx_regnode_set_voltage(struct regnode *regnode, int min_uvolt,
 728     int max_uvolt, int *udelay)
 729 {
 730         struct axp2xx_reg_sc *sc;
 731         uint8_t val;
 732
 733         sc = regnode_get_softc(regnode);
 734
 735         if (!sc->def->voltage_step)
 736                 return (ENXIO);
 737
 738         if (axp2xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0)
 739                 return (ERANGE);
 740
 741         axp2xx_write(sc->base_dev, sc->def->voltage_reg, val);
 742
 743         *udelay = 0;
 744
 745         return (0);
 746 }
 747
 748 static int
 749 axp2xx_regnode_get_voltage(struct regnode *regnode, int *uvolt)
 750 {
 751         struct axp2xx_reg_sc *sc;
 752         uint8_t val;
 753
 754         sc = regnode_get_softc(regnode);
 755
 756         if (!sc->def->voltage_step)
 757                 return (ENXIO);
 758
 759         axp2xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1);
 760         axp2xx_regnode_reg_to_voltage(sc, val & sc->def->voltage_mask, uvolt);
 761
 762         return (0);
 763 }
 764
 765 static regnode_method_t axp2xx_regnode_methods[] = {
 766         /* Regulator interface */
 767         REGNODEMETHOD(regnode_init,             axp2xx_regnode_init),
 768         REGNODEMETHOD(regnode_enable,           axp2xx_regnode_enable),
 769         REGNODEMETHOD(regnode_status,           axp2xx_regnode_status),
 770         REGNODEMETHOD(regnode_set_voltage,      axp2xx_regnode_set_voltage),
 771         REGNODEMETHOD(regnode_get_voltage,      axp2xx_regnode_get_voltage),
 772         REGNODEMETHOD(regnode_check_voltage,    regnode_method_check_voltage),
 773         REGNODEMETHOD_END
 774 };
 775 DEFINE_CLASS_1(axp2xx_regnode, axp2xx_regnode_class, axp2xx_regnode_methods,
 776     sizeof(struct axp2xx_reg_sc), regnode_class);
 777
 778 static int
 779 axp2xx_sysctl(SYSCTL_HANDLER_ARGS)
 780 {
 781         struct axp2xx_softc *sc;
 782         device_t dev = arg1;
 783         enum axp2xx_sensor sensor = arg2;
 784         uint8_t data[2];
 785         int val, error, i, found;
 786
 787         sc = device_get_softc(dev);
 788
 789         for (found = 0, i = 0; i < sc->nsensors; i++) {
 790                 if (sc->sensors[i].id == sensor) {
 791                         found = 1;
 792                         break;
 793                 }
 794         }
 795
 796         if (found == 0)
 797                 return (ENOENT);
 798
 799         error = axp2xx_read(dev, sc->sensors[i].value_reg, data, 2);
 800         if (error != 0)
 801                 return (error);
 802
 803         val = ((data[0] & sc->sensors[i].h_value_mask) <<
 804             sc->sensors[i].h_value_shift);
 805         val |= ((data[1] & sc->sensors[i].l_value_mask) <<
 806             sc->sensors[i].l_value_shift);
 807         val *= sc->sensors[i].value_step;
 808         val += sc->sensors[i].value_convert;
 809
 810         return sysctl_handle_opaque(oidp, &val, sizeof(val), req);
 811 }
 812
 813 static void
 814 axp2xx_shutdown(void *devp, int howto)
 815 {
 816         device_t dev;
 817
 818         if (!(howto & RB_POWEROFF))
 819                 return;
 820         dev = (device_t)devp;
 821
 822         if (bootverbose)
 823                 device_printf(dev, "Shutdown AXP2xx\n");
 824
 825         axp2xx_write(dev, AXP2XX_SHUTBAT, AXP2XX_SHUTBAT_SHUTDOWN);
 826 }
 827
 828 static void
 829 axp2xx_intr(void *arg)
 830 {
 831         struct axp2xx_softc *sc;
 832         uint8_t reg;
 833
 834         sc = arg;
 835
 836         axp2xx_read(sc->dev, AXP2XX_IRQ1_STATUS, &reg, 1);
 837         if (reg) {
 838                 if (reg & AXP2XX_IRQ1_AC_OVERVOLT)
 839                         devctl_notify("PMU", "AC", "overvoltage", NULL);
 840                 if (reg & AXP2XX_IRQ1_VBUS_OVERVOLT)
 841                         devctl_notify("PMU", "USB", "overvoltage", NULL);
 842                 if (reg & AXP2XX_IRQ1_VBUS_LOW)
 843                         devctl_notify("PMU", "USB", "undervoltage", NULL);
 844                 if (reg & AXP2XX_IRQ1_AC_CONN)
 845                         devctl_notify("PMU", "AC", "plugged", NULL);
 846                 if (reg & AXP2XX_IRQ1_AC_DISCONN)
 847                         devctl_notify("PMU", "AC", "unplugged", NULL);
 848                 if (reg & AXP2XX_IRQ1_VBUS_CONN)
 849                         devctl_notify("PMU", "USB", "plugged", NULL);
 850                 if (reg & AXP2XX_IRQ1_VBUS_DISCONN)
 851                         devctl_notify("PMU", "USB", "unplugged", NULL);
 852                 axp2xx_write(sc->dev, AXP2XX_IRQ1_STATUS, AXP2XX_IRQ_ACK);
 853         }
 854
 855         axp2xx_read(sc->dev, AXP2XX_IRQ2_STATUS, &reg, 1);
 856         if (reg) {
 857                 if (reg & AXP2XX_IRQ2_BATT_CHARGED)
 858                         devctl_notify("PMU", "Battery", "charged", NULL);
 859                 if (reg & AXP2XX_IRQ2_BATT_CHARGING)
 860                         devctl_notify("PMU", "Battery", "charging", NULL);
 861                 if (reg & AXP2XX_IRQ2_BATT_CONN)
 862                         devctl_notify("PMU", "Battery", "connected", NULL);
 863                 if (reg & AXP2XX_IRQ2_BATT_DISCONN)
 864                         devctl_notify("PMU", "Battery", "disconnected", NULL);
 865                 if (reg & AXP2XX_IRQ2_BATT_TEMP_LOW)
 866                         devctl_notify("PMU", "Battery", "low temp", NULL);
 867                 if (reg & AXP2XX_IRQ2_BATT_TEMP_OVER)
 868                         devctl_notify("PMU", "Battery", "high temp", NULL);
 869                 axp2xx_write(sc->dev, AXP2XX_IRQ2_STATUS, AXP2XX_IRQ_ACK);
 870         }
 871
 872         axp2xx_read(sc->dev, AXP2XX_IRQ3_STATUS, &reg, 1);
 873         if (reg) {
 874                 if (reg & AXP2XX_IRQ3_PEK_SHORT)
 875                         shutdown_nice(RB_POWEROFF);
 876                 axp2xx_write(sc->dev, AXP2XX_IRQ3_STATUS, AXP2XX_IRQ_ACK);
 877         }
 878
 879         axp2xx_read(sc->dev, AXP2XX_IRQ4_STATUS, &reg, 1);
 880         if (reg) {
 881                 axp2xx_write(sc->dev, AXP2XX_IRQ4_STATUS, AXP2XX_IRQ_ACK);
 882         }
 883
 884         axp2xx_read(sc->dev, AXP2XX_IRQ5_STATUS, &reg, 1);
 885         if (reg) {
 886                 axp2xx_write(sc->dev, AXP2XX_IRQ5_STATUS, AXP2XX_IRQ_ACK);
 887         }
 888 }
 889
 890 static device_t
 891 axp2xx_gpio_get_bus(device_t dev)
 892 {
 893         struct axp2xx_softc *sc;
 894
 895         sc = device_get_softc(dev);
 896
 897         return (sc->gpiodev);
 898 }
 899
 900 static int
 901 axp2xx_gpio_pin_max(device_t dev, int *maxpin)
 902 {
 903         struct axp2xx_softc *sc;
 904
 905         sc = device_get_softc(dev);
 906
 907         *maxpin = sc->npins - 1;
 908
 909         return (0);
 910 }
 911
 912 static int
 913 axp2xx_gpio_pin_getname(device_t dev, uint32_t pin, char *name)
 914 {
 915         struct axp2xx_softc *sc;
 916
 917         sc = device_get_softc(dev);
 918
 919         if (pin >= sc->npins)
 920                 return (EINVAL);
 921
 922         snprintf(name, GPIOMAXNAME, "%s", axp209_pins[pin].name);
 923
 924         return (0);
 925 }
 926
 927 static int
 928 axp2xx_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps)
 929 {
 930         struct axp2xx_softc *sc;
 931
 932         sc = device_get_softc(dev);
 933
 934         if (pin >= sc->npins)
 935                 return (EINVAL);
 936
 937         *caps = GPIO_PIN_INPUT | GPIO_PIN_OUTPUT;
 938
 939         return (0);
 940 }
 941
 942 static int
 943 axp2xx_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags)
 944 {
 945         struct axp2xx_softc *sc;
 946         uint8_t data, func;
 947         int error;
 948
 949         sc = device_get_softc(dev);
 950
 951         if (pin >= sc->npins)
 952                 return (EINVAL);
 953
 954         AXP_LOCK(sc);
 955         error = axp2xx_read(dev, sc->pins[pin].ctrl_reg, &data, 1);
 956         if (error == 0) {
 957                 func = data & AXP2XX_GPIO_FUNC_MASK;
 958                 if (func == AXP2XX_GPIO_FUNC_INPUT)
 959                         *flags = GPIO_PIN_INPUT;
 960                 else if (func == AXP2XX_GPIO_FUNC_DRVLO ||
 961                     func == AXP2XX_GPIO_FUNC_DRVHI)
 962                         *flags = GPIO_PIN_OUTPUT;
 963                 else
 964                         *flags = 0;
 965         }
 966         AXP_UNLOCK(sc);
 967
 968         return (error);
 969 }
 970
 971 static int
 972 axp2xx_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags)
 973 {
 974         struct axp2xx_softc *sc;
 975         uint8_t data;
 976         int error;
 977
 978         sc = device_get_softc(dev);
 979
 980         if (pin >= sc->npins)
 981                 return (EINVAL);
 982
 983         AXP_LOCK(sc);
 984         error = axp2xx_read(dev, sc->pins[pin].ctrl_reg, &data, 1);
 985         if (error == 0) {
 986                 data &= ~AXP2XX_GPIO_FUNC_MASK;
 987                 if ((flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) != 0) {
 988                         if ((flags & GPIO_PIN_OUTPUT) == 0)
 989                                 data |= AXP2XX_GPIO_FUNC_INPUT;
 990                 }
 991                 error = axp2xx_write(dev, sc->pins[pin].ctrl_reg, data);
 992         }
 993         AXP_UNLOCK(sc);
 994
 995         return (error);
 996 }
 997
 998 static int
 999 axp2xx_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val)
1000 {
1001         struct axp2xx_softc *sc;
1002         uint8_t data, func;
1003         int error;
1004
1005         sc = device_get_softc(dev);
1006
1007         if (pin >= sc->npins)
1008                 return (EINVAL);
1009
1010         AXP_LOCK(sc);
1011         error = axp2xx_read(dev, sc->pins[pin].ctrl_reg, &data, 1);
1012         if (error == 0) {
1013                 func = data & AXP2XX_GPIO_FUNC_MASK;
1014                 switch (func) {
1015                 case AXP2XX_GPIO_FUNC_DRVLO:
1016                         *val = 0;
1017                         break;
1018                 case AXP2XX_GPIO_FUNC_DRVHI:
1019                         *val = 1;
1020                         break;
1021                 case AXP2XX_GPIO_FUNC_INPUT:
1022                         error = axp2xx_read(dev, sc->pins[pin].status_reg,
1023                             &data, 1);
1024                         if (error == 0) {
1025                                 *val = (data & sc->pins[pin].status_mask);
1026                                 *val >>= sc->pins[pin].status_shift;
1027                         }
1028                         break;
1029                 default:
1030                         error = EIO;
1031                         break;
1032                 }
1033         }
1034         AXP_UNLOCK(sc);
1035
1036         return (error);
1037 }
1038
1039 static int
1040 axp2xx_gpio_pin_set(device_t dev, uint32_t pin, unsigned int val)
1041 {
1042         struct axp2xx_softc *sc;
1043         uint8_t data, func;
1044         int error;
1045
1046         sc = device_get_softc(dev);
1047
1048         if (pin >= sc->npins)
1049                 return (EINVAL);
1050
1051         AXP_LOCK(sc);
1052         error = axp2xx_read(dev, sc->pins[pin].ctrl_reg, &data, 1);
1053         if (error == 0) {
1054                 func = data & AXP2XX_GPIO_FUNC_MASK;
1055                 switch (func) {
1056                 case AXP2XX_GPIO_FUNC_DRVLO:
1057                 case AXP2XX_GPIO_FUNC_DRVHI:
1058                         /* GPIO2 can't be set to 1 */
1059                         if (pin == 2 && val == 1) {
1060                                 error = EINVAL;
1061                                 break;
1062                         }
1063                         data &= ~AXP2XX_GPIO_FUNC_MASK;
1064                         data |= val;
1065                         break;
1066                 default:
1067                         error = EIO;
1068                         break;
1069                 }
1070         }
1071         if (error == 0)
1072                 error = axp2xx_write(dev, sc->pins[pin].ctrl_reg, data);
1073         AXP_UNLOCK(sc);
1074
1075         return (error);
1076 }
1077
1078
1079 static int
1080 axp2xx_gpio_pin_toggle(device_t dev, uint32_t pin)
1081 {
1082         struct axp2xx_softc *sc;
1083         uint8_t data, func;
1084         int error;
1085
1086         sc = device_get_softc(dev);
1087
1088         if (pin >= sc->npins)
1089                 return (EINVAL);
1090
1091         AXP_LOCK(sc);
1092         error = axp2xx_read(dev, sc->pins[pin].ctrl_reg, &data, 1);
1093         if (error == 0) {
1094                 func = data & AXP2XX_GPIO_FUNC_MASK;
1095                 switch (func) {
1096                 case AXP2XX_GPIO_FUNC_DRVLO:
1097                         /* Pin 2 can't be set to 1*/
1098                         if (pin == 2) {
1099                                 error = EINVAL;
1100                                 break;
1101                         }
1102                         data &= ~AXP2XX_GPIO_FUNC_MASK;
1103                         data |= AXP2XX_GPIO_FUNC_DRVHI;
1104                         break;
1105                 case AXP2XX_GPIO_FUNC_DRVHI:
1106                         data &= ~AXP2XX_GPIO_FUNC_MASK;
1107                         data |= AXP2XX_GPIO_FUNC_DRVLO;
1108                         break;
1109                 default:
1110                         error = EIO;
1111                         break;
1112                 }
1113         }
1114         if (error == 0)
1115                 error = axp2xx_write(dev, sc->pins[pin].ctrl_reg, data);
1116         AXP_UNLOCK(sc);
1117
1118         return (error);
1119 }
1120
1121 static int
1122 axp2xx_gpio_map_gpios(device_t bus, phandle_t dev, phandle_t gparent,
1123     int gcells, pcell_t *gpios, uint32_t *pin, uint32_t *flags)
1124 {
1125         struct axp2xx_softc *sc;
1126
1127         sc = device_get_softc(bus);
1128
1129         if (gpios[0] >= sc->npins)
1130                 return (EINVAL);
1131
1132         *pin = gpios[0];
1133         *flags = gpios[1];
1134
1135         return (0);
1136 }
1137
1138 static phandle_t
1139 axp2xx_get_node(device_t dev, device_t bus)
1140 {
1141         return (ofw_bus_get_node(dev));
1142 }
1143
1144 static struct axp2xx_reg_sc *
1145 axp2xx_reg_attach(device_t dev, phandle_t node,
1146     struct axp2xx_regdef *def)
1147 {
1148         struct axp2xx_reg_sc *reg_sc;
1149         struct regnode_init_def initdef;
1150         struct regnode *regnode;
1151
1152         memset(&initdef, 0, sizeof(initdef));
1153         if (regulator_parse_ofw_stdparam(dev, node, &initdef) != 0) {
1154                 device_printf(dev, "cannot create regulator\n");
1155                 return (NULL);
1156         }
1157         if (initdef.std_param.min_uvolt == 0)
1158                 initdef.std_param.min_uvolt = def->voltage_min * 1000;
1159         if (initdef.std_param.max_uvolt == 0)
1160                 initdef.std_param.max_uvolt = def->voltage_max * 1000;
1161         initdef.id = def->id;
1162         initdef.ofw_node = node;
1163         regnode = regnode_create(dev, &axp2xx_regnode_class, &initdef);
1164         if (regnode == NULL) {
1165                 device_printf(dev, "cannot create regulator\n");
1166                 return (NULL);
1167         }
1168
1169         reg_sc = regnode_get_softc(regnode);
1170         reg_sc->regnode = regnode;
1171         reg_sc->base_dev = dev;
1172         reg_sc->def = def;
1173         reg_sc->xref = OF_xref_from_node(node);
1174         reg_sc->param = regnode_get_stdparam(regnode);
1175
1176         regnode_register(regnode);
1177
1178         return (reg_sc);
1179 }
1180
1181 static int
1182 axp2xx_regdev_map(device_t dev, phandle_t xref, int ncells, pcell_t *cells,
1183     intptr_t *num)
1184 {
1185         struct axp2xx_softc *sc;
1186         int i;
1187
1188         sc = device_get_softc(dev);
1189         for (i = 0; i < sc->nregs; i++) {
1190                 if (sc->regs[i] == NULL)
1191                         continue;
1192                 if (sc->regs[i]->xref == xref) {
1193                         *num = sc->regs[i]->def->id;
1194                         return (0);
1195                 }
1196         }
1197
1198         return (ENXIO);
1199 }
1200
1201 static void
1202 axp2xx_start(void *pdev)
1203 {
1204         device_t dev;
1205         struct axp2xx_softc *sc;
1206         const char *pwr_name[] = {"Battery", "AC", "USB", "AC and USB"};
1207         int i;
1208         uint8_t reg, data;
1209         uint8_t pwr_src;
1210
1211         dev = pdev;
1212
1213         sc = device_get_softc(dev);
1214         sc->dev = dev;
1215
1216         if (bootverbose) {
1217                 /*
1218                  * Read the Power State register.
1219                  * Shift the AC presence into bit 0.
1220                  * Shift the Battery presence into bit 1.
1221                  */
1222                 axp2xx_read(dev, AXP2XX_PSR, &data, 1);
1223                 pwr_src = ((data & AXP2XX_PSR_ACIN) >> AXP2XX_PSR_ACIN_SHIFT) |
1224                     ((data & AXP2XX_PSR_VBUS) >> (AXP2XX_PSR_VBUS_SHIFT - 1));
1225
1226                 device_printf(dev, "Powered by %s\n",
1227                     pwr_name[pwr_src]);
1228         }
1229
1230         /* Only enable interrupts that we are interested in */
1231         axp2xx_write(dev, AXP2XX_IRQ1_ENABLE,
1232             AXP2XX_IRQ1_AC_OVERVOLT |
1233             AXP2XX_IRQ1_AC_DISCONN |
1234             AXP2XX_IRQ1_AC_CONN |
1235             AXP2XX_IRQ1_VBUS_OVERVOLT |
1236             AXP2XX_IRQ1_VBUS_DISCONN |
1237             AXP2XX_IRQ1_VBUS_CONN);
1238         axp2xx_write(dev, AXP2XX_IRQ2_ENABLE,
1239             AXP2XX_IRQ2_BATT_CONN |
1240             AXP2XX_IRQ2_BATT_DISCONN |
1241             AXP2XX_IRQ2_BATT_CHARGE_ACCT_ON |
1242             AXP2XX_IRQ2_BATT_CHARGE_ACCT_OFF |
1243             AXP2XX_IRQ2_BATT_CHARGING |
1244             AXP2XX_IRQ2_BATT_CHARGED |
1245             AXP2XX_IRQ2_BATT_TEMP_OVER |
1246             AXP2XX_IRQ2_BATT_TEMP_LOW);
1247         axp2xx_write(dev, AXP2XX_IRQ3_ENABLE,
1248             AXP2XX_IRQ3_PEK_SHORT | AXP2XX_IRQ3_PEK_LONG);
1249         axp2xx_write(dev, AXP2XX_IRQ4_ENABLE, AXP2XX_IRQ4_APS_LOW_2);
1250         axp2xx_write(dev, AXP2XX_IRQ5_ENABLE, 0x0);
1251
1252         EVENTHANDLER_REGISTER(shutdown_final, axp2xx_shutdown, dev,
1253             SHUTDOWN_PRI_LAST);
1254
1255         /* Enable ADC sensors */
1256         for (i = 0; i < sc->nsensors; i++) {
1257                 if (axp2xx_read(dev, sc->sensors[i].enable_reg, &reg, 1) == -1) {
1258                         device_printf(dev, "Cannot enable sensor '%s'\n",
1259                             sc->sensors[i].name);
1260                         continue;
1261                 }
1262                 reg |= sc->sensors[i].enable_mask;
1263                 if (axp2xx_write(dev, sc->sensors[i].enable_reg, reg) == -1) {
1264                         device_printf(dev, "Cannot enable sensor '%s'\n",
1265                             sc->sensors[i].name);
1266                         continue;
1267                 }
1268                 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
1269                     SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
1270                     OID_AUTO, sc->sensors[i].name,
1271                     CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT,
1272                     dev, sc->sensors[i].id, axp2xx_sysctl,
1273                     sc->sensors[i].format,
1274                     sc->sensors[i].desc);
1275         }
1276
1277         if ((bus_setup_intr(dev, sc->res[0], INTR_TYPE_MISC | INTR_MPSAFE,
1278               NULL, axp2xx_intr, sc, &sc->intrcookie)))
1279                 device_printf(dev, "unable to register interrupt handler\n");
1280
1281         config_intrhook_disestablish(&sc->intr_hook);
1282 }
1283
1284 static int
1285 axp2xx_probe(device_t dev)
1286 {
1287
1288         if (!ofw_bus_status_okay(dev))
1289                 return (ENXIO);
1290
1291         switch (ofw_bus_search_compatible(dev, compat_data)->ocd_data)
1292         {
1293         case AXP209:
1294                 device_set_desc(dev, "X-Powers AXP209 Power Management Unit");
1295                 break;
1296         case AXP221:
1297                 device_set_desc(dev, "X-Powers AXP221 Power Management Unit");
1298                 break;
1299         default:
1300                 return (ENXIO);
1301         }
1302
1303         return (BUS_PROBE_DEFAULT);
1304 }
1305
1306 static int
1307 axp2xx_attach(device_t dev)
1308 {
1309         struct axp2xx_softc *sc;
1310         struct axp2xx_reg_sc *reg;
1311         struct axp2xx_regdef *regdefs;
1312         phandle_t rnode, child;
1313         int i;
1314
1315         sc = device_get_softc(dev);
1316         mtx_init(&sc->mtx, device_get_nameunit(dev), NULL, MTX_DEF);
1317
1318         if (bus_alloc_resources(dev, axp_res_spec, sc->res) != 0) {
1319                 device_printf(dev, "can't allocate device resources\n");
1320                 return (ENXIO);
1321         }
1322
1323         sc->type = ofw_bus_search_compatible(dev, compat_data)->ocd_data;
1324         switch (sc->type) {
1325         case AXP209:
1326                 sc->pins = axp209_pins;
1327                 sc->npins = nitems(axp209_pins);
1328                 sc->gpiodev = gpiobus_attach_bus(dev);
1329
1330                 sc->sensors = axp209_sensors;
1331                 sc->nsensors = nitems(axp209_sensors);
1332
1333                 regdefs = axp209_regdefs;
1334                 sc->nregs = nitems(axp209_regdefs);
1335                 break;
1336         case AXP221:
1337                 sc->pins = axp221_pins;
1338                 sc->npins = nitems(axp221_pins);
1339                 sc->gpiodev = gpiobus_attach_bus(dev);
1340
1341                 sc->sensors = axp221_sensors;
1342                 sc->nsensors = nitems(axp221_sensors);
1343
1344                 regdefs = axp221_regdefs;
1345                 sc->nregs = nitems(axp221_regdefs);
1346                 break;
1347         }
1348
1349         sc->regs = malloc(sizeof(struct axp2xx_reg_sc *) * sc->nregs,
1350             M_AXP2XX_REG, M_WAITOK | M_ZERO);
1351
1352         sc->intr_hook.ich_func = axp2xx_start;
1353         sc->intr_hook.ich_arg = dev;
1354
1355         if (config_intrhook_establish(&sc->intr_hook) != 0)
1356                 return (ENOMEM);
1357
1358         /* Attach known regulators that exist in the DT */
1359         rnode = ofw_bus_find_child(ofw_bus_get_node(dev), "regulators");
1360         if (rnode > 0) {
1361                 for (i = 0; i < sc->nregs; i++) {
1362                         child = ofw_bus_find_child(rnode,
1363                             regdefs[i].name);
1364                         if (child == 0)
1365                                 continue;
1366                         reg = axp2xx_reg_attach(dev, child, &regdefs[i]);
1367                         if (reg == NULL) {
1368                                 device_printf(dev,
1369                                     "cannot attach regulator %s\n",
1370                                     regdefs[i].name);
1371                                 continue;
1372                         }
1373                         sc->regs[i] = reg;
1374                         if (bootverbose)
1375                                 device_printf(dev, "Regulator %s attached\n",
1376                                     regdefs[i].name);
1377                 }
1378         }
1379
1380         return (0);
1381 }
1382
1383 static device_method_t axp2xx_methods[] = {
1384         DEVMETHOD(device_probe,         axp2xx_probe),
1385         DEVMETHOD(device_attach,        axp2xx_attach),
1386
1387         /* GPIO interface */
1388         DEVMETHOD(gpio_get_bus,         axp2xx_gpio_get_bus),
1389         DEVMETHOD(gpio_pin_max,         axp2xx_gpio_pin_max),
1390         DEVMETHOD(gpio_pin_getname,     axp2xx_gpio_pin_getname),
1391         DEVMETHOD(gpio_pin_getcaps,     axp2xx_gpio_pin_getcaps),
1392         DEVMETHOD(gpio_pin_getflags,    axp2xx_gpio_pin_getflags),
1393         DEVMETHOD(gpio_pin_setflags,    axp2xx_gpio_pin_setflags),
1394         DEVMETHOD(gpio_pin_get,         axp2xx_gpio_pin_get),
1395         DEVMETHOD(gpio_pin_set,         axp2xx_gpio_pin_set),
1396         DEVMETHOD(gpio_pin_toggle,      axp2xx_gpio_pin_toggle),
1397         DEVMETHOD(gpio_map_gpios,       axp2xx_gpio_map_gpios),
1398
1399         /* Regdev interface */
1400         DEVMETHOD(regdev_map,           axp2xx_regdev_map),
1401
1402         /* OFW bus interface */
1403         DEVMETHOD(ofw_bus_get_node,     axp2xx_get_node),
1404
1405         DEVMETHOD_END
1406 };
1407
1408 static driver_t axp2xx_driver = {
1409         "axp2xx_pmu",
1410         axp2xx_methods,
1411         sizeof(struct axp2xx_softc),
1412 };
1413
1414 static devclass_t axp2xx_devclass;
1415 extern devclass_t ofwgpiobus_devclass, gpioc_devclass;
1416 extern driver_t ofw_gpiobus_driver, gpioc_driver;
1417
1418 EARLY_DRIVER_MODULE(axp2xx, iicbus, axp2xx_driver, axp2xx_devclass,
1419   0, 0, BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LATE);
1420 EARLY_DRIVER_MODULE(ofw_gpiobus, axp2xx_pmu, ofw_gpiobus_driver,
1421     ofwgpiobus_devclass, 0, 0, BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LATE);
1422 DRIVER_MODULE(gpioc, axp2xx_pmu, gpioc_driver, gpioc_devclass,
1423     0, 0);
1424 MODULE_VERSION(axp2xx, 1);
1425 MODULE_DEPEND(axp2xx, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER);