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, ®, 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, ®, 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, ®, 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, ®, 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, ®, 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, ®, 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, ®defs[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); 1426