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_set_voltage(struct regnode *regnode, int min_uvolt, 712 int max_uvolt, int *udelay) 713 { 714 struct axp2xx_reg_sc *sc; 715 uint8_t val; 716 717 sc = regnode_get_softc(regnode); 718 719 if (!sc->def->voltage_step) 720 return (ENXIO); 721 722 if (axp2xx_regnode_voltage_to_reg(sc, min_uvolt, max_uvolt, &val) != 0) 723 return (ERANGE); 724 725 axp2xx_write(sc->base_dev, sc->def->voltage_reg, val); 726 727 *udelay = 0; 728 729 return (0); 730 } 731 732 static int 733 axp2xx_regnode_get_voltage(struct regnode *regnode, int *uvolt) 734 { 735 struct axp2xx_reg_sc *sc; 736 uint8_t val; 737 738 sc = regnode_get_softc(regnode); 739 740 if (!sc->def->voltage_step) 741 return (ENXIO); 742 743 axp2xx_read(sc->base_dev, sc->def->voltage_reg, &val, 1); 744 axp2xx_regnode_reg_to_voltage(sc, val & sc->def->voltage_mask, uvolt); 745 746 return (0); 747 } 748 749 static regnode_method_t axp2xx_regnode_methods[] = { 750 /* Regulator interface */ 751 REGNODEMETHOD(regnode_init, axp2xx_regnode_init), 752 REGNODEMETHOD(regnode_enable, axp2xx_regnode_enable), 753 REGNODEMETHOD(regnode_set_voltage, axp2xx_regnode_set_voltage), 754 REGNODEMETHOD(regnode_get_voltage, axp2xx_regnode_get_voltage), 755 REGNODEMETHOD(regnode_check_voltage, regnode_method_check_voltage), 756 REGNODEMETHOD_END 757 }; 758 DEFINE_CLASS_1(axp2xx_regnode, axp2xx_regnode_class, axp2xx_regnode_methods, 759 sizeof(struct axp2xx_reg_sc), regnode_class); 760 761 static int 762 axp2xx_sysctl(SYSCTL_HANDLER_ARGS) 763 { 764 struct axp2xx_softc *sc; 765 device_t dev = arg1; 766 enum axp2xx_sensor sensor = arg2; 767 uint8_t data[2]; 768 int val, error, i, found; 769 770 sc = device_get_softc(dev); 771 772 for (found = 0, i = 0; i < sc->nsensors; i++) { 773 if (sc->sensors[i].id == sensor) { 774 found = 1; 775 break; 776 } 777 } 778 779 if (found == 0) 780 return (ENOENT); 781 782 error = axp2xx_read(dev, sc->sensors[i].value_reg, data, 2); 783 if (error != 0) 784 return (error); 785 786 val = ((data[0] & sc->sensors[i].h_value_mask) << 787 sc->sensors[i].h_value_shift); 788 val |= ((data[1] & sc->sensors[i].l_value_mask) << 789 sc->sensors[i].l_value_shift); 790 val *= sc->sensors[i].value_step; 791 val += sc->sensors[i].value_convert; 792 793 return sysctl_handle_opaque(oidp, &val, sizeof(val), req); 794 } 795 796 static void 797 axp2xx_shutdown(void *devp, int howto) 798 { 799 device_t dev; 800 801 if (!(howto & RB_POWEROFF)) 802 return; 803 dev = (device_t)devp; 804 805 if (bootverbose) 806 device_printf(dev, "Shutdown AXP2xx\n"); 807 808 axp2xx_write(dev, AXP2XX_SHUTBAT, AXP2XX_SHUTBAT_SHUTDOWN); 809 } 810 811 static void 812 axp2xx_intr(void *arg) 813 { 814 struct axp2xx_softc *sc; 815 uint8_t reg; 816 817 sc = arg; 818 819 axp2xx_read(sc->dev, AXP2XX_IRQ1_STATUS, ®, 1); 820 if (reg) { 821 if (reg & AXP2XX_IRQ1_AC_OVERVOLT) 822 devctl_notify("PMU", "AC", "overvoltage", NULL); 823 if (reg & AXP2XX_IRQ1_VBUS_OVERVOLT) 824 devctl_notify("PMU", "USB", "overvoltage", NULL); 825 if (reg & AXP2XX_IRQ1_VBUS_LOW) 826 devctl_notify("PMU", "USB", "undervoltage", NULL); 827 if (reg & AXP2XX_IRQ1_AC_CONN) 828 devctl_notify("PMU", "AC", "plugged", NULL); 829 if (reg & AXP2XX_IRQ1_AC_DISCONN) 830 devctl_notify("PMU", "AC", "unplugged", NULL); 831 if (reg & AXP2XX_IRQ1_VBUS_CONN) 832 devctl_notify("PMU", "USB", "plugged", NULL); 833 if (reg & AXP2XX_IRQ1_VBUS_DISCONN) 834 devctl_notify("PMU", "USB", "unplugged", NULL); 835 axp2xx_write(sc->dev, AXP2XX_IRQ1_STATUS, AXP2XX_IRQ_ACK); 836 } 837 838 axp2xx_read(sc->dev, AXP2XX_IRQ2_STATUS, ®, 1); 839 if (reg) { 840 if (reg & AXP2XX_IRQ2_BATT_CHARGED) 841 devctl_notify("PMU", "Battery", "charged", NULL); 842 if (reg & AXP2XX_IRQ2_BATT_CHARGING) 843 devctl_notify("PMU", "Battery", "charging", NULL); 844 if (reg & AXP2XX_IRQ2_BATT_CONN) 845 devctl_notify("PMU", "Battery", "connected", NULL); 846 if (reg & AXP2XX_IRQ2_BATT_DISCONN) 847 devctl_notify("PMU", "Battery", "disconnected", NULL); 848 if (reg & AXP2XX_IRQ2_BATT_TEMP_LOW) 849 devctl_notify("PMU", "Battery", "low temp", NULL); 850 if (reg & AXP2XX_IRQ2_BATT_TEMP_OVER) 851 devctl_notify("PMU", "Battery", "high temp", NULL); 852 axp2xx_write(sc->dev, AXP2XX_IRQ2_STATUS, AXP2XX_IRQ_ACK); 853 } 854 855 axp2xx_read(sc->dev, AXP2XX_IRQ3_STATUS, ®, 1); 856 if (reg) { 857 if (reg & AXP2XX_IRQ3_PEK_SHORT) 858 shutdown_nice(RB_POWEROFF); 859 axp2xx_write(sc->dev, AXP2XX_IRQ3_STATUS, AXP2XX_IRQ_ACK); 860 } 861 862 axp2xx_read(sc->dev, AXP2XX_IRQ4_STATUS, ®, 1); 863 if (reg) { 864 axp2xx_write(sc->dev, AXP2XX_IRQ4_STATUS, AXP2XX_IRQ_ACK); 865 } 866 867 axp2xx_read(sc->dev, AXP2XX_IRQ5_STATUS, ®, 1); 868 if (reg) { 869 axp2xx_write(sc->dev, AXP2XX_IRQ5_STATUS, AXP2XX_IRQ_ACK); 870 } 871 } 872 873 static device_t 874 axp2xx_gpio_get_bus(device_t dev) 875 { 876 struct axp2xx_softc *sc; 877 878 sc = device_get_softc(dev); 879 880 return (sc->gpiodev); 881 } 882 883 static int 884 axp2xx_gpio_pin_max(device_t dev, int *maxpin) 885 { 886 struct axp2xx_softc *sc; 887 888 sc = device_get_softc(dev); 889 890 *maxpin = sc->npins - 1; 891 892 return (0); 893 } 894 895 static int 896 axp2xx_gpio_pin_getname(device_t dev, uint32_t pin, char *name) 897 { 898 struct axp2xx_softc *sc; 899 900 sc = device_get_softc(dev); 901 902 if (pin >= sc->npins) 903 return (EINVAL); 904 905 snprintf(name, GPIOMAXNAME, "%s", axp209_pins[pin].name); 906 907 return (0); 908 } 909 910 static int 911 axp2xx_gpio_pin_getcaps(device_t dev, uint32_t pin, uint32_t *caps) 912 { 913 struct axp2xx_softc *sc; 914 915 sc = device_get_softc(dev); 916 917 if (pin >= sc->npins) 918 return (EINVAL); 919 920 *caps = GPIO_PIN_INPUT | GPIO_PIN_OUTPUT; 921 922 return (0); 923 } 924 925 static int 926 axp2xx_gpio_pin_getflags(device_t dev, uint32_t pin, uint32_t *flags) 927 { 928 struct axp2xx_softc *sc; 929 uint8_t data, func; 930 int error; 931 932 sc = device_get_softc(dev); 933 934 if (pin >= sc->npins) 935 return (EINVAL); 936 937 AXP_LOCK(sc); 938 error = axp2xx_read(dev, sc->pins[pin].ctrl_reg, &data, 1); 939 if (error == 0) { 940 func = data & AXP2XX_GPIO_FUNC_MASK; 941 if (func == AXP2XX_GPIO_FUNC_INPUT) 942 *flags = GPIO_PIN_INPUT; 943 else if (func == AXP2XX_GPIO_FUNC_DRVLO || 944 func == AXP2XX_GPIO_FUNC_DRVHI) 945 *flags = GPIO_PIN_OUTPUT; 946 else 947 *flags = 0; 948 } 949 AXP_UNLOCK(sc); 950 951 return (error); 952 } 953 954 static int 955 axp2xx_gpio_pin_setflags(device_t dev, uint32_t pin, uint32_t flags) 956 { 957 struct axp2xx_softc *sc; 958 uint8_t data; 959 int error; 960 961 sc = device_get_softc(dev); 962 963 if (pin >= sc->npins) 964 return (EINVAL); 965 966 AXP_LOCK(sc); 967 error = axp2xx_read(dev, sc->pins[pin].ctrl_reg, &data, 1); 968 if (error == 0) { 969 data &= ~AXP2XX_GPIO_FUNC_MASK; 970 if ((flags & (GPIO_PIN_INPUT|GPIO_PIN_OUTPUT)) != 0) { 971 if ((flags & GPIO_PIN_OUTPUT) == 0) 972 data |= AXP2XX_GPIO_FUNC_INPUT; 973 } 974 error = axp2xx_write(dev, sc->pins[pin].ctrl_reg, data); 975 } 976 AXP_UNLOCK(sc); 977 978 return (error); 979 } 980 981 static int 982 axp2xx_gpio_pin_get(device_t dev, uint32_t pin, unsigned int *val) 983 { 984 struct axp2xx_softc *sc; 985 uint8_t data, func; 986 int error; 987 988 sc = device_get_softc(dev); 989 990 if (pin >= sc->npins) 991 return (EINVAL); 992 993 AXP_LOCK(sc); 994 error = axp2xx_read(dev, sc->pins[pin].ctrl_reg, &data, 1); 995 if (error == 0) { 996 func = data & AXP2XX_GPIO_FUNC_MASK; 997 switch (func) { 998 case AXP2XX_GPIO_FUNC_DRVLO: 999 *val = 0; 1000 break; 1001 case AXP2XX_GPIO_FUNC_DRVHI: 1002 *val = 1; 1003 break; 1004 case AXP2XX_GPIO_FUNC_INPUT: 1005 error = axp2xx_read(dev, sc->pins[pin].status_reg, 1006 &data, 1); 1007 if (error == 0) { 1008 *val = (data & sc->pins[pin].status_mask); 1009 *val >>= sc->pins[pin].status_shift; 1010 } 1011 break; 1012 default: 1013 error = EIO; 1014 break; 1015 } 1016 } 1017 AXP_UNLOCK(sc); 1018 1019 return (error); 1020 } 1021 1022 static int 1023 axp2xx_gpio_pin_set(device_t dev, uint32_t pin, unsigned int val) 1024 { 1025 struct axp2xx_softc *sc; 1026 uint8_t data, func; 1027 int error; 1028 1029 sc = device_get_softc(dev); 1030 1031 if (pin >= sc->npins) 1032 return (EINVAL); 1033 1034 AXP_LOCK(sc); 1035 error = axp2xx_read(dev, sc->pins[pin].ctrl_reg, &data, 1); 1036 if (error == 0) { 1037 func = data & AXP2XX_GPIO_FUNC_MASK; 1038 switch (func) { 1039 case AXP2XX_GPIO_FUNC_DRVLO: 1040 case AXP2XX_GPIO_FUNC_DRVHI: 1041 /* GPIO2 can't be set to 1 */ 1042 if (pin == 2 && val == 1) { 1043 error = EINVAL; 1044 break; 1045 } 1046 data &= ~AXP2XX_GPIO_FUNC_MASK; 1047 data |= val; 1048 break; 1049 default: 1050 error = EIO; 1051 break; 1052 } 1053 } 1054 if (error == 0) 1055 error = axp2xx_write(dev, sc->pins[pin].ctrl_reg, data); 1056 AXP_UNLOCK(sc); 1057 1058 return (error); 1059 } 1060 1061 1062 static int 1063 axp2xx_gpio_pin_toggle(device_t dev, uint32_t pin) 1064 { 1065 struct axp2xx_softc *sc; 1066 uint8_t data, func; 1067 int error; 1068 1069 sc = device_get_softc(dev); 1070 1071 if (pin >= sc->npins) 1072 return (EINVAL); 1073 1074 AXP_LOCK(sc); 1075 error = axp2xx_read(dev, sc->pins[pin].ctrl_reg, &data, 1); 1076 if (error == 0) { 1077 func = data & AXP2XX_GPIO_FUNC_MASK; 1078 switch (func) { 1079 case AXP2XX_GPIO_FUNC_DRVLO: 1080 /* Pin 2 can't be set to 1*/ 1081 if (pin == 2) { 1082 error = EINVAL; 1083 break; 1084 } 1085 data &= ~AXP2XX_GPIO_FUNC_MASK; 1086 data |= AXP2XX_GPIO_FUNC_DRVHI; 1087 break; 1088 case AXP2XX_GPIO_FUNC_DRVHI: 1089 data &= ~AXP2XX_GPIO_FUNC_MASK; 1090 data |= AXP2XX_GPIO_FUNC_DRVLO; 1091 break; 1092 default: 1093 error = EIO; 1094 break; 1095 } 1096 } 1097 if (error == 0) 1098 error = axp2xx_write(dev, sc->pins[pin].ctrl_reg, data); 1099 AXP_UNLOCK(sc); 1100 1101 return (error); 1102 } 1103 1104 static int 1105 axp2xx_gpio_map_gpios(device_t bus, phandle_t dev, phandle_t gparent, 1106 int gcells, pcell_t *gpios, uint32_t *pin, uint32_t *flags) 1107 { 1108 struct axp2xx_softc *sc; 1109 1110 sc = device_get_softc(bus); 1111 1112 if (gpios[0] >= sc->npins) 1113 return (EINVAL); 1114 1115 *pin = gpios[0]; 1116 *flags = gpios[1]; 1117 1118 return (0); 1119 } 1120 1121 static phandle_t 1122 axp2xx_get_node(device_t dev, device_t bus) 1123 { 1124 return (ofw_bus_get_node(dev)); 1125 } 1126 1127 static struct axp2xx_reg_sc * 1128 axp2xx_reg_attach(device_t dev, phandle_t node, 1129 struct axp2xx_regdef *def) 1130 { 1131 struct axp2xx_reg_sc *reg_sc; 1132 struct regnode_init_def initdef; 1133 struct regnode *regnode; 1134 1135 memset(&initdef, 0, sizeof(initdef)); 1136 if (regulator_parse_ofw_stdparam(dev, node, &initdef) != 0) { 1137 device_printf(dev, "cannot create regulator\n"); 1138 return (NULL); 1139 } 1140 if (initdef.std_param.min_uvolt == 0) 1141 initdef.std_param.min_uvolt = def->voltage_min * 1000; 1142 if (initdef.std_param.max_uvolt == 0) 1143 initdef.std_param.max_uvolt = def->voltage_max * 1000; 1144 initdef.id = def->id; 1145 initdef.ofw_node = node; 1146 regnode = regnode_create(dev, &axp2xx_regnode_class, &initdef); 1147 if (regnode == NULL) { 1148 device_printf(dev, "cannot create regulator\n"); 1149 return (NULL); 1150 } 1151 1152 reg_sc = regnode_get_softc(regnode); 1153 reg_sc->regnode = regnode; 1154 reg_sc->base_dev = dev; 1155 reg_sc->def = def; 1156 reg_sc->xref = OF_xref_from_node(node); 1157 reg_sc->param = regnode_get_stdparam(regnode); 1158 1159 regnode_register(regnode); 1160 1161 return (reg_sc); 1162 } 1163 1164 static int 1165 axp2xx_regdev_map(device_t dev, phandle_t xref, int ncells, pcell_t *cells, 1166 intptr_t *num) 1167 { 1168 struct axp2xx_softc *sc; 1169 int i; 1170 1171 sc = device_get_softc(dev); 1172 for (i = 0; i < sc->nregs; i++) { 1173 if (sc->regs[i] == NULL) 1174 continue; 1175 if (sc->regs[i]->xref == xref) { 1176 *num = sc->regs[i]->def->id; 1177 return (0); 1178 } 1179 } 1180 1181 return (ENXIO); 1182 } 1183 1184 static void 1185 axp2xx_start(void *pdev) 1186 { 1187 device_t dev; 1188 struct axp2xx_softc *sc; 1189 const char *pwr_name[] = {"Battery", "AC", "USB", "AC and USB"}; 1190 int i; 1191 uint8_t reg, data; 1192 uint8_t pwr_src; 1193 1194 dev = pdev; 1195 1196 sc = device_get_softc(dev); 1197 sc->dev = dev; 1198 1199 if (bootverbose) { 1200 /* 1201 * Read the Power State register. 1202 * Shift the AC presence into bit 0. 1203 * Shift the Battery presence into bit 1. 1204 */ 1205 axp2xx_read(dev, AXP2XX_PSR, &data, 1); 1206 pwr_src = ((data & AXP2XX_PSR_ACIN) >> AXP2XX_PSR_ACIN_SHIFT) | 1207 ((data & AXP2XX_PSR_VBUS) >> (AXP2XX_PSR_VBUS_SHIFT - 1)); 1208 1209 device_printf(dev, "Powered by %s\n", 1210 pwr_name[pwr_src]); 1211 } 1212 1213 /* Only enable interrupts that we are interested in */ 1214 axp2xx_write(dev, AXP2XX_IRQ1_ENABLE, 1215 AXP2XX_IRQ1_AC_OVERVOLT | 1216 AXP2XX_IRQ1_AC_DISCONN | 1217 AXP2XX_IRQ1_AC_CONN | 1218 AXP2XX_IRQ1_VBUS_OVERVOLT | 1219 AXP2XX_IRQ1_VBUS_DISCONN | 1220 AXP2XX_IRQ1_VBUS_CONN); 1221 axp2xx_write(dev, AXP2XX_IRQ2_ENABLE, 1222 AXP2XX_IRQ2_BATT_CONN | 1223 AXP2XX_IRQ2_BATT_DISCONN | 1224 AXP2XX_IRQ2_BATT_CHARGE_ACCT_ON | 1225 AXP2XX_IRQ2_BATT_CHARGE_ACCT_OFF | 1226 AXP2XX_IRQ2_BATT_CHARGING | 1227 AXP2XX_IRQ2_BATT_CHARGED | 1228 AXP2XX_IRQ2_BATT_TEMP_OVER | 1229 AXP2XX_IRQ2_BATT_TEMP_LOW); 1230 axp2xx_write(dev, AXP2XX_IRQ3_ENABLE, 1231 AXP2XX_IRQ3_PEK_SHORT | AXP2XX_IRQ3_PEK_LONG); 1232 axp2xx_write(dev, AXP2XX_IRQ4_ENABLE, AXP2XX_IRQ4_APS_LOW_2); 1233 axp2xx_write(dev, AXP2XX_IRQ5_ENABLE, 0x0); 1234 1235 EVENTHANDLER_REGISTER(shutdown_final, axp2xx_shutdown, dev, 1236 SHUTDOWN_PRI_LAST); 1237 1238 /* Enable ADC sensors */ 1239 for (i = 0; i < sc->nsensors; i++) { 1240 if (axp2xx_read(dev, sc->sensors[i].enable_reg, ®, 1) == -1) { 1241 device_printf(dev, "Cannot enable sensor '%s'\n", 1242 sc->sensors[i].name); 1243 continue; 1244 } 1245 reg |= sc->sensors[i].enable_mask; 1246 if (axp2xx_write(dev, sc->sensors[i].enable_reg, reg) == -1) { 1247 device_printf(dev, "Cannot enable sensor '%s'\n", 1248 sc->sensors[i].name); 1249 continue; 1250 } 1251 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 1252 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 1253 OID_AUTO, sc->sensors[i].name, 1254 CTLTYPE_INT | CTLFLAG_RD, 1255 dev, sc->sensors[i].id, axp2xx_sysctl, 1256 sc->sensors[i].format, 1257 sc->sensors[i].desc); 1258 } 1259 1260 if ((bus_setup_intr(dev, sc->res[0], INTR_TYPE_MISC | INTR_MPSAFE, 1261 NULL, axp2xx_intr, sc, &sc->intrcookie))) 1262 device_printf(dev, "unable to register interrupt handler\n"); 1263 1264 config_intrhook_disestablish(&sc->intr_hook); 1265 } 1266 1267 static int 1268 axp2xx_probe(device_t dev) 1269 { 1270 1271 if (!ofw_bus_status_okay(dev)) 1272 return (ENXIO); 1273 1274 switch (ofw_bus_search_compatible(dev, compat_data)->ocd_data) 1275 { 1276 case AXP209: 1277 device_set_desc(dev, "X-Powers AXP209 Power Management Unit"); 1278 break; 1279 case AXP221: 1280 device_set_desc(dev, "X-Powers AXP221 Power Management Unit"); 1281 break; 1282 default: 1283 return (ENXIO); 1284 } 1285 1286 return (BUS_PROBE_DEFAULT); 1287 } 1288 1289 static int 1290 axp2xx_attach(device_t dev) 1291 { 1292 struct axp2xx_softc *sc; 1293 struct axp2xx_reg_sc *reg; 1294 struct axp2xx_regdef *regdefs; 1295 phandle_t rnode, child; 1296 int i; 1297 1298 sc = device_get_softc(dev); 1299 mtx_init(&sc->mtx, device_get_nameunit(dev), NULL, MTX_DEF); 1300 1301 if (bus_alloc_resources(dev, axp_res_spec, sc->res) != 0) { 1302 device_printf(dev, "can't allocate device resources\n"); 1303 return (ENXIO); 1304 } 1305 1306 sc->type = ofw_bus_search_compatible(dev, compat_data)->ocd_data; 1307 switch (sc->type) { 1308 case AXP209: 1309 sc->pins = axp209_pins; 1310 sc->npins = nitems(axp209_pins); 1311 sc->gpiodev = gpiobus_attach_bus(dev); 1312 1313 sc->sensors = axp209_sensors; 1314 sc->nsensors = nitems(axp209_sensors); 1315 1316 regdefs = axp209_regdefs; 1317 sc->nregs = nitems(axp209_regdefs); 1318 break; 1319 case AXP221: 1320 sc->pins = axp221_pins; 1321 sc->npins = nitems(axp221_pins); 1322 sc->gpiodev = gpiobus_attach_bus(dev); 1323 1324 sc->sensors = axp221_sensors; 1325 sc->nsensors = nitems(axp221_sensors); 1326 1327 regdefs = axp221_regdefs; 1328 sc->nregs = nitems(axp221_regdefs); 1329 break; 1330 } 1331 1332 sc->regs = malloc(sizeof(struct axp2xx_reg_sc *) * sc->nregs, 1333 M_AXP2XX_REG, M_WAITOK | M_ZERO); 1334 1335 sc->intr_hook.ich_func = axp2xx_start; 1336 sc->intr_hook.ich_arg = dev; 1337 1338 if (config_intrhook_establish(&sc->intr_hook) != 0) 1339 return (ENOMEM); 1340 1341 /* Attach known regulators that exist in the DT */ 1342 rnode = ofw_bus_find_child(ofw_bus_get_node(dev), "regulators"); 1343 if (rnode > 0) { 1344 for (i = 0; i < sc->nregs; i++) { 1345 child = ofw_bus_find_child(rnode, 1346 regdefs[i].name); 1347 if (child == 0) 1348 continue; 1349 reg = axp2xx_reg_attach(dev, child, ®defs[i]); 1350 if (reg == NULL) { 1351 device_printf(dev, 1352 "cannot attach regulator %s\n", 1353 regdefs[i].name); 1354 continue; 1355 } 1356 sc->regs[i] = reg; 1357 if (bootverbose) 1358 device_printf(dev, "Regulator %s attached\n", 1359 regdefs[i].name); 1360 } 1361 } 1362 1363 return (0); 1364 } 1365 1366 static device_method_t axp2xx_methods[] = { 1367 DEVMETHOD(device_probe, axp2xx_probe), 1368 DEVMETHOD(device_attach, axp2xx_attach), 1369 1370 /* GPIO interface */ 1371 DEVMETHOD(gpio_get_bus, axp2xx_gpio_get_bus), 1372 DEVMETHOD(gpio_pin_max, axp2xx_gpio_pin_max), 1373 DEVMETHOD(gpio_pin_getname, axp2xx_gpio_pin_getname), 1374 DEVMETHOD(gpio_pin_getcaps, axp2xx_gpio_pin_getcaps), 1375 DEVMETHOD(gpio_pin_getflags, axp2xx_gpio_pin_getflags), 1376 DEVMETHOD(gpio_pin_setflags, axp2xx_gpio_pin_setflags), 1377 DEVMETHOD(gpio_pin_get, axp2xx_gpio_pin_get), 1378 DEVMETHOD(gpio_pin_set, axp2xx_gpio_pin_set), 1379 DEVMETHOD(gpio_pin_toggle, axp2xx_gpio_pin_toggle), 1380 DEVMETHOD(gpio_map_gpios, axp2xx_gpio_map_gpios), 1381 1382 /* Regdev interface */ 1383 DEVMETHOD(regdev_map, axp2xx_regdev_map), 1384 1385 /* OFW bus interface */ 1386 DEVMETHOD(ofw_bus_get_node, axp2xx_get_node), 1387 1388 DEVMETHOD_END 1389 }; 1390 1391 static driver_t axp2xx_driver = { 1392 "axp2xx_pmu", 1393 axp2xx_methods, 1394 sizeof(struct axp2xx_softc), 1395 }; 1396 1397 static devclass_t axp2xx_devclass; 1398 extern devclass_t ofwgpiobus_devclass, gpioc_devclass; 1399 extern driver_t ofw_gpiobus_driver, gpioc_driver; 1400 1401 EARLY_DRIVER_MODULE(axp2xx, iicbus, axp2xx_driver, axp2xx_devclass, 1402 0, 0, BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LATE); 1403 EARLY_DRIVER_MODULE(ofw_gpiobus, axp2xx_pmu, ofw_gpiobus_driver, 1404 ofwgpiobus_devclass, 0, 0, BUS_PASS_INTERRUPT + BUS_PASS_ORDER_LATE); 1405 DRIVER_MODULE(gpioc, axp2xx_pmu, gpioc_driver, gpioc_devclass, 1406 0, 0); 1407 MODULE_VERSION(axp2xx, 1); 1408 MODULE_DEPEND(axp2xx, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER); 1409