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