1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2011 5 * Ben Gray <ben.r.gray@gmail.com>. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 /* 34 * Texas Instruments TWL4030/TWL5030/TWL60x0/TPS659x0 Power Management. 35 * 36 * This driver covers the voltages regulators (LDO), allows for enabling & 37 * disabling the voltage output and adjusting the voltage level. 38 * 39 * Voltage regulators can belong to different power groups, in this driver we 40 * put the regulators under our control in the "Application power group". 41 * 42 * 43 * FLATTENED DEVICE TREE (FDT) 44 * Startup override settings can be specified in the FDT, if they are they 45 * should be under the twl parent device and take the following form: 46 * 47 * voltage-regulators = "name1", "millivolts1", 48 * "name2", "millivolts2"; 49 * 50 * Each override should be a pair, the first entry is the name of the regulator 51 * the second is the voltage (in millivolts) to set for the given regulator. 52 * 53 */ 54 55 #include <sys/param.h> 56 #include <sys/systm.h> 57 #include <sys/kernel.h> 58 #include <sys/lock.h> 59 #include <sys/module.h> 60 #include <sys/bus.h> 61 #include <sys/resource.h> 62 #include <sys/rman.h> 63 #include <sys/sysctl.h> 64 #include <sys/sx.h> 65 #include <sys/malloc.h> 66 67 #include <machine/bus.h> 68 #include <machine/resource.h> 69 #include <machine/intr.h> 70 71 #include <dev/ofw/openfirm.h> 72 #include <dev/ofw/ofw_bus.h> 73 74 #include "twl.h" 75 #include "twl_vreg.h" 76 77 static int twl_vreg_debug = 1; 78 79 /* 80 * Power Groups bits for the 4030 and 6030 devices 81 */ 82 #define TWL4030_P3_GRP 0x80 /* Peripherals, power group */ 83 #define TWL4030_P2_GRP 0x40 /* Modem power group */ 84 #define TWL4030_P1_GRP 0x20 /* Application power group (FreeBSD control) */ 85 86 #define TWL6030_P3_GRP 0x04 /* Modem power group */ 87 #define TWL6030_P2_GRP 0x02 /* Connectivity power group */ 88 #define TWL6030_P1_GRP 0x01 /* Application power group (FreeBSD control) */ 89 90 /* 91 * Register offsets within a LDO regulator register set 92 */ 93 #define TWL_VREG_GRP 0x00 /* Regulator GRP register */ 94 #define TWL_VREG_STATE 0x02 95 #define TWL_VREG_VSEL 0x03 /* Voltage select register */ 96 97 #define UNDF 0xFFFF 98 99 static const uint16_t twl6030_voltages[] = { 100 0000, 1000, 1100, 1200, 1300, 1400, 1500, 1600, 101 1700, 1800, 1900, 2000, 2100, 2200, 2300, 2400, 102 2500, 2600, 2700, 2800, 2900, 3000, 3100, 3200, 103 3300, UNDF, UNDF, UNDF, UNDF, UNDF, UNDF, 2750 104 }; 105 106 static const uint16_t twl4030_vaux1_voltages[] = { 107 1500, 1800, 2500, 2800, 3000, 3000, 3000, 3000 108 }; 109 static const uint16_t twl4030_vaux2_voltages[] = { 110 1700, 1700, 1900, 1300, 1500, 1800, 2000, 2500, 111 2100, 2800, 2200, 2300, 2400, 2400, 2400, 2400 112 }; 113 static const uint16_t twl4030_vaux3_voltages[] = { 114 1500, 1800, 2500, 2800, 3000, 3000, 3000, 3000 115 }; 116 static const uint16_t twl4030_vaux4_voltages[] = { 117 700, 1000, 1200, 1300, 1500, 1800, 1850, 2500, 118 2600, 2800, 2850, 3000, 3150, 3150, 3150, 3150 119 }; 120 static const uint16_t twl4030_vmmc1_voltages[] = { 121 1850, 2850, 3000, 3150 122 }; 123 static const uint16_t twl4030_vmmc2_voltages[] = { 124 1000, 1000, 1200, 1300, 1500, 1800, 1850, 2500, 125 2600, 2800, 2850, 3000, 3150, 3150, 3150, 3150 126 }; 127 static const uint16_t twl4030_vpll1_voltages[] = { 128 1000, 1200, 1300, 1800, 2800, 3000, 3000, 3000 129 }; 130 static const uint16_t twl4030_vpll2_voltages[] = { 131 700, 1000, 1200, 1300, 1500, 1800, 1850, 2500, 132 2600, 2800, 2850, 3000, 3150, 3150, 3150, 3150 133 }; 134 static const uint16_t twl4030_vsim_voltages[] = { 135 1000, 1200, 1300, 1800, 2800, 3000, 3000, 3000 136 }; 137 static const uint16_t twl4030_vdac_voltages[] = { 138 1200, 1300, 1800, 1800 139 }; 140 #if 0 /* vdd1, vdd2, vdio, not currently used. */ 141 static const uint16_t twl4030_vdd1_voltages[] = { 142 800, 1450 143 }; 144 static const uint16_t twl4030_vdd2_voltages[] = { 145 800, 1450, 1500 146 }; 147 static const uint16_t twl4030_vio_voltages[] = { 148 1800, 1850 149 }; 150 #endif 151 static const uint16_t twl4030_vintana2_voltages[] = { 152 2500, 2750 153 }; 154 155 /** 156 * Support voltage regulators for the different IC's 157 */ 158 struct twl_regulator { 159 const char *name; 160 uint8_t subdev; 161 uint8_t regbase; 162 163 uint16_t fixedvoltage; 164 165 const uint16_t *voltages; 166 uint32_t num_voltages; 167 }; 168 169 #define TWL_REGULATOR_ADJUSTABLE(name, subdev, reg, voltages) \ 170 { name, subdev, reg, 0, voltages, (sizeof(voltages)/sizeof(voltages[0])) } 171 #define TWL_REGULATOR_FIXED(name, subdev, reg, voltage) \ 172 { name, subdev, reg, voltage, NULL, 0 } 173 174 static const struct twl_regulator twl4030_regulators[] = { 175 TWL_REGULATOR_ADJUSTABLE("vaux1", 0, 0x17, twl4030_vaux1_voltages), 176 TWL_REGULATOR_ADJUSTABLE("vaux2", 0, 0x1B, twl4030_vaux2_voltages), 177 TWL_REGULATOR_ADJUSTABLE("vaux3", 0, 0x1F, twl4030_vaux3_voltages), 178 TWL_REGULATOR_ADJUSTABLE("vaux4", 0, 0x23, twl4030_vaux4_voltages), 179 TWL_REGULATOR_ADJUSTABLE("vmmc1", 0, 0x27, twl4030_vmmc1_voltages), 180 TWL_REGULATOR_ADJUSTABLE("vmmc2", 0, 0x2B, twl4030_vmmc2_voltages), 181 TWL_REGULATOR_ADJUSTABLE("vpll1", 0, 0x2F, twl4030_vpll1_voltages), 182 TWL_REGULATOR_ADJUSTABLE("vpll2", 0, 0x33, twl4030_vpll2_voltages), 183 TWL_REGULATOR_ADJUSTABLE("vsim", 0, 0x37, twl4030_vsim_voltages), 184 TWL_REGULATOR_ADJUSTABLE("vdac", 0, 0x3B, twl4030_vdac_voltages), 185 TWL_REGULATOR_ADJUSTABLE("vintana2", 0, 0x43, twl4030_vintana2_voltages), 186 TWL_REGULATOR_FIXED("vintana1", 0, 0x3F, 1500), 187 TWL_REGULATOR_FIXED("vintdig", 0, 0x47, 1500), 188 TWL_REGULATOR_FIXED("vusb1v5", 0, 0x71, 1500), 189 TWL_REGULATOR_FIXED("vusb1v8", 0, 0x74, 1800), 190 TWL_REGULATOR_FIXED("vusb3v1", 0, 0x77, 3100), 191 { NULL, 0, 0x00, 0, NULL, 0 } 192 }; 193 194 static const struct twl_regulator twl6030_regulators[] = { 195 TWL_REGULATOR_ADJUSTABLE("vaux1", 0, 0x84, twl6030_voltages), 196 TWL_REGULATOR_ADJUSTABLE("vaux2", 0, 0x89, twl6030_voltages), 197 TWL_REGULATOR_ADJUSTABLE("vaux3", 0, 0x8C, twl6030_voltages), 198 TWL_REGULATOR_ADJUSTABLE("vmmc", 0, 0x98, twl6030_voltages), 199 TWL_REGULATOR_ADJUSTABLE("vpp", 0, 0x9C, twl6030_voltages), 200 TWL_REGULATOR_ADJUSTABLE("vusim", 0, 0xA4, twl6030_voltages), 201 TWL_REGULATOR_FIXED("vmem", 0, 0x64, 1800), 202 TWL_REGULATOR_FIXED("vusb", 0, 0xA0, 3300), 203 TWL_REGULATOR_FIXED("v1v8", 0, 0x46, 1800), 204 TWL_REGULATOR_FIXED("v2v1", 0, 0x4C, 2100), 205 TWL_REGULATOR_FIXED("v1v29", 0, 0x40, 1290), 206 TWL_REGULATOR_FIXED("vcxio", 0, 0x90, 1800), 207 TWL_REGULATOR_FIXED("vdac", 0, 0x94, 1800), 208 TWL_REGULATOR_FIXED("vana", 0, 0x80, 2100), 209 { NULL, 0, 0x00, 0, NULL, 0 } 210 }; 211 212 #define TWL_VREG_MAX_NAMELEN 32 213 214 struct twl_regulator_entry { 215 LIST_ENTRY(twl_regulator_entry) entries; 216 char name[TWL_VREG_MAX_NAMELEN]; 217 struct sysctl_oid *oid; 218 uint8_t sub_dev; /* TWL sub-device group */ 219 uint8_t reg_off; /* base register offset for the LDO */ 220 uint16_t fixed_voltage; /* the (milli)voltage if LDO is fixed */ 221 const uint16_t *supp_voltages; /* pointer to an array of possible voltages */ 222 uint32_t num_supp_voltages; /* the number of supplied voltages */ 223 }; 224 225 struct twl_vreg_softc { 226 device_t sc_dev; 227 device_t sc_pdev; 228 struct sx sc_sx; 229 230 struct intr_config_hook sc_init_hook; 231 LIST_HEAD(twl_regulator_list, twl_regulator_entry) sc_vreg_list; 232 }; 233 234 #define TWL_VREG_XLOCK(_sc) sx_xlock(&(_sc)->sc_sx) 235 #define TWL_VREG_XUNLOCK(_sc) sx_xunlock(&(_sc)->sc_sx) 236 #define TWL_VREG_SLOCK(_sc) sx_slock(&(_sc)->sc_sx) 237 #define TWL_VREG_SUNLOCK(_sc) sx_sunlock(&(_sc)->sc_sx) 238 #define TWL_VREG_LOCK_INIT(_sc) sx_init(&(_sc)->sc_sx, "twl_vreg") 239 #define TWL_VREG_LOCK_DESTROY(_sc) sx_destroy(&(_sc)->sc_sx); 240 241 #define TWL_VREG_ASSERT_LOCKED(_sc) sx_assert(&(_sc)->sc_sx, SA_LOCKED); 242 243 #define TWL_VREG_LOCK_UPGRADE(_sc) \ 244 do { \ 245 while (!sx_try_upgrade(&(_sc)->sc_sx)) \ 246 pause("twl_vreg_ex", (hz / 100)); \ 247 } while(0) 248 #define TWL_VREG_LOCK_DOWNGRADE(_sc) sx_downgrade(&(_sc)->sc_sx); 249 250 /** 251 * twl_vreg_read_1 - read single register from the TWL device 252 * twl_vreg_write_1 - write a single register in the TWL device 253 * @sc: device context 254 * @clk: the clock device we're reading from / writing to 255 * @off: offset within the clock's register set 256 * @val: the value to write or a pointer to a variable to store the result 257 * 258 * RETURNS: 259 * Zero on success or an error code on failure. 260 */ 261 static inline int 262 twl_vreg_read_1(struct twl_vreg_softc *sc, struct twl_regulator_entry *regulator, 263 uint8_t off, uint8_t *val) 264 { 265 return (twl_read(sc->sc_pdev, regulator->sub_dev, 266 regulator->reg_off + off, val, 1)); 267 } 268 269 static inline int 270 twl_vreg_write_1(struct twl_vreg_softc *sc, struct twl_regulator_entry *regulator, 271 uint8_t off, uint8_t val) 272 { 273 return (twl_write(sc->sc_pdev, regulator->sub_dev, 274 regulator->reg_off + off, &val, 1)); 275 } 276 277 /** 278 * twl_millivolt_to_vsel - gets the vsel bit value to write into the register 279 * for a desired voltage and regulator 280 * @sc: the device soft context 281 * @regulator: pointer to the regulator device 282 * @millivolts: the millivolts to find the bit value for 283 * @vsel: upon return will contain the corresponding register value 284 * 285 * Accepts a (milli)voltage value and tries to find the closest match to the 286 * actual supported voltages for the given regulator. If a match is found 287 * within 100mv of the target, @vsel is written with the match and 0 is 288 * returned. If no voltage match is found the function returns an non-zero 289 * value. 290 * 291 * RETURNS: 292 * Zero on success or an error code on failure. 293 */ 294 static int 295 twl_vreg_millivolt_to_vsel(struct twl_vreg_softc *sc, 296 struct twl_regulator_entry *regulator, int millivolts, uint8_t *vsel) 297 { 298 int delta, smallest_delta; 299 unsigned i, closest_idx; 300 301 TWL_VREG_ASSERT_LOCKED(sc); 302 303 if (regulator->supp_voltages == NULL) 304 return (EINVAL); 305 306 /* Loop over the support voltages and try and find the closest match */ 307 closest_idx = 0; 308 smallest_delta = 0x7fffffff; 309 for (i = 0; i < regulator->num_supp_voltages; i++) { 310 /* Ignore undefined values */ 311 if (regulator->supp_voltages[i] == UNDF) 312 continue; 313 314 /* Calculate the difference */ 315 delta = millivolts - (int)regulator->supp_voltages[i]; 316 if (abs(delta) < smallest_delta) { 317 smallest_delta = abs(delta); 318 closest_idx = i; 319 } 320 } 321 322 /* Check we got a voltage that was within 100mv of the actual target, this 323 * is just a value I picked out of thin air. 324 */ 325 if ((smallest_delta > 100) && (closest_idx < 0x100)) 326 return (EINVAL); 327 328 *vsel = closest_idx; 329 return (0); 330 } 331 332 /** 333 * twl_vreg_is_regulator_enabled - returns the enabled status of the regulator 334 * @sc: the device soft context 335 * @regulator: pointer to the regulator device 336 * @enabled: stores the enabled status, zero disabled, non-zero enabled 337 * 338 * LOCKING: 339 * On entry expects the TWL VREG lock to be held. Will upgrade the lock to 340 * exclusive if not already but, if so, it will be downgraded again before 341 * returning. 342 * 343 * RETURNS: 344 * Zero on success or an error code on failure. 345 */ 346 static int 347 twl_vreg_is_regulator_enabled(struct twl_vreg_softc *sc, 348 struct twl_regulator_entry *regulator, int *enabled) 349 { 350 int err; 351 uint8_t grp; 352 uint8_t state; 353 int xlocked; 354 355 if (enabled == NULL) 356 return (EINVAL); 357 358 TWL_VREG_ASSERT_LOCKED(sc); 359 360 xlocked = sx_xlocked(&sc->sc_sx); 361 if (!xlocked) 362 TWL_VREG_LOCK_UPGRADE(sc); 363 364 /* The status reading is different for the different devices */ 365 if (twl_is_4030(sc->sc_pdev)) { 366 err = twl_vreg_read_1(sc, regulator, TWL_VREG_GRP, &state); 367 if (err) 368 goto done; 369 370 *enabled = (state & TWL4030_P1_GRP); 371 372 } else if (twl_is_6030(sc->sc_pdev) || twl_is_6025(sc->sc_pdev)) { 373 /* Check the regulator is in the application group */ 374 if (twl_is_6030(sc->sc_pdev)) { 375 err = twl_vreg_read_1(sc, regulator, TWL_VREG_GRP, &grp); 376 if (err) 377 goto done; 378 379 if (!(grp & TWL6030_P1_GRP)) { 380 *enabled = 0; /* disabled */ 381 goto done; 382 } 383 } 384 385 /* Read the application mode state and verify it's ON */ 386 err = twl_vreg_read_1(sc, regulator, TWL_VREG_STATE, &state); 387 if (err) 388 goto done; 389 390 *enabled = ((state & 0x0C) == 0x04); 391 392 } else { 393 err = EINVAL; 394 } 395 396 done: 397 if (!xlocked) 398 TWL_VREG_LOCK_DOWNGRADE(sc); 399 400 return (err); 401 } 402 403 /** 404 * twl_vreg_disable_regulator - disables a voltage regulator 405 * @sc: the device soft context 406 * @regulator: pointer to the regulator device 407 * 408 * Disables the regulator which will stop the output drivers. 409 * 410 * LOCKING: 411 * On entry expects the TWL VREG lock to be held. Will upgrade the lock to 412 * exclusive if not already but, if so, it will be downgraded again before 413 * returning. 414 * 415 * RETURNS: 416 * Zero on success or a positive error code on failure. 417 */ 418 static int 419 twl_vreg_disable_regulator(struct twl_vreg_softc *sc, 420 struct twl_regulator_entry *regulator) 421 { 422 int err = 0; 423 uint8_t grp; 424 int xlocked; 425 426 TWL_VREG_ASSERT_LOCKED(sc); 427 428 xlocked = sx_xlocked(&sc->sc_sx); 429 if (!xlocked) 430 TWL_VREG_LOCK_UPGRADE(sc); 431 432 if (twl_is_4030(sc->sc_pdev)) { 433 /* Read the regulator CFG_GRP register */ 434 err = twl_vreg_read_1(sc, regulator, TWL_VREG_GRP, &grp); 435 if (err) 436 goto done; 437 438 /* On the TWL4030 we just need to remove the regulator from all the 439 * power groups. 440 */ 441 grp &= ~(TWL4030_P1_GRP | TWL4030_P2_GRP | TWL4030_P3_GRP); 442 err = twl_vreg_write_1(sc, regulator, TWL_VREG_GRP, grp); 443 444 } else if (twl_is_6030(sc->sc_pdev) || twl_is_6025(sc->sc_pdev)) { 445 /* On TWL6030 we need to make sure we disable power for all groups */ 446 if (twl_is_6030(sc->sc_pdev)) 447 grp = TWL6030_P1_GRP | TWL6030_P2_GRP | TWL6030_P3_GRP; 448 else 449 grp = 0x00; 450 451 /* Write the resource state to "OFF" */ 452 err = twl_vreg_write_1(sc, regulator, TWL_VREG_STATE, (grp << 5)); 453 } 454 455 done: 456 if (!xlocked) 457 TWL_VREG_LOCK_DOWNGRADE(sc); 458 459 return (err); 460 } 461 462 /** 463 * twl_vreg_enable_regulator - enables the voltage regulator 464 * @sc: the device soft context 465 * @regulator: pointer to the regulator device 466 * 467 * Enables the regulator which will enable the voltage out at the currently 468 * set voltage. Set the voltage before calling this function to avoid 469 * driving the voltage too high/low by mistake. 470 * 471 * LOCKING: 472 * On entry expects the TWL VREG lock to be held. Will upgrade the lock to 473 * exclusive if not already but, if so, it will be downgraded again before 474 * returning. 475 * 476 * RETURNS: 477 * Zero on success or a positive error code on failure. 478 */ 479 static int 480 twl_vreg_enable_regulator(struct twl_vreg_softc *sc, 481 struct twl_regulator_entry *regulator) 482 { 483 int err; 484 uint8_t grp; 485 int xlocked; 486 487 TWL_VREG_ASSERT_LOCKED(sc); 488 489 xlocked = sx_xlocked(&sc->sc_sx); 490 if (!xlocked) 491 TWL_VREG_LOCK_UPGRADE(sc); 492 493 err = twl_vreg_read_1(sc, regulator, TWL_VREG_GRP, &grp); 494 if (err) 495 goto done; 496 497 /* Enable the regulator by ensuring it's in the application power group 498 * and is in the "on" state. 499 */ 500 if (twl_is_4030(sc->sc_pdev)) { 501 /* On the TWL4030 we just need to ensure the regulator is in the right 502 * power domain, don't need to turn on explicitly like TWL6030. 503 */ 504 grp |= TWL4030_P1_GRP; 505 err = twl_vreg_write_1(sc, regulator, TWL_VREG_GRP, grp); 506 507 } else if (twl_is_6030(sc->sc_pdev) || twl_is_6025(sc->sc_pdev)) { 508 if (twl_is_6030(sc->sc_pdev) && !(grp & TWL6030_P1_GRP)) { 509 grp |= TWL6030_P1_GRP; 510 err = twl_vreg_write_1(sc, regulator, TWL_VREG_GRP, grp); 511 if (err) 512 goto done; 513 } 514 515 /* Write the resource state to "ON" */ 516 err = twl_vreg_write_1(sc, regulator, TWL_VREG_STATE, (grp << 5) | 0x01); 517 } 518 519 done: 520 if (!xlocked) 521 TWL_VREG_LOCK_DOWNGRADE(sc); 522 523 return (err); 524 } 525 526 /** 527 * twl_vreg_write_regulator_voltage - sets the voltage level on a regulator 528 * @sc: the device soft context 529 * @regulator: pointer to the regulator structure 530 * @millivolts: the voltage to set 531 * 532 * Sets the voltage output on a given regulator, if the regulator is not 533 * enabled, it will be enabled. 534 * 535 * LOCKING: 536 * On entry expects the TWL VREG lock to be held, may upgrade the lock to 537 * exclusive but if so it will be downgraded once again before returning. 538 * 539 * RETURNS: 540 * Zero on success or an error code on failure. 541 */ 542 static int 543 twl_vreg_write_regulator_voltage(struct twl_vreg_softc *sc, 544 struct twl_regulator_entry *regulator, int millivolts) 545 { 546 int err; 547 uint8_t vsel; 548 int xlocked; 549 550 TWL_VREG_ASSERT_LOCKED(sc); 551 552 /* If millivolts is zero then we simply disable the output */ 553 if (millivolts == 0) 554 return (twl_vreg_disable_regulator(sc, regulator)); 555 556 /* If the regulator has a fixed voltage then check the setting matches 557 * and simply enable. 558 */ 559 if (regulator->supp_voltages == NULL || regulator->num_supp_voltages == 0) { 560 if (millivolts != regulator->fixed_voltage) 561 return (EINVAL); 562 563 return (twl_vreg_enable_regulator(sc, regulator)); 564 } 565 566 /* Get the VSEL value for the given voltage */ 567 err = twl_vreg_millivolt_to_vsel(sc, regulator, millivolts, &vsel); 568 if (err) 569 return (err); 570 571 /* Need to upgrade because writing the voltage and enabling should be atomic */ 572 xlocked = sx_xlocked(&sc->sc_sx); 573 if (!xlocked) 574 TWL_VREG_LOCK_UPGRADE(sc); 575 576 /* Set voltage and enable (atomically) */ 577 err = twl_vreg_write_1(sc, regulator, TWL_VREG_VSEL, (vsel & 0x1f)); 578 if (!err) { 579 err = twl_vreg_enable_regulator(sc, regulator); 580 } 581 582 if (!xlocked) 583 TWL_VREG_LOCK_DOWNGRADE(sc); 584 585 if ((twl_vreg_debug > 1) && !err) 586 device_printf(sc->sc_dev, "%s : setting voltage to %dmV (vsel: 0x%x)\n", 587 regulator->name, millivolts, vsel); 588 589 return (err); 590 } 591 592 /** 593 * twl_vreg_read_regulator_voltage - reads the voltage on a given regulator 594 * @sc: the device soft context 595 * @regulator: pointer to the regulator structure 596 * @millivolts: upon return will contain the voltage on the regulator 597 * 598 * LOCKING: 599 * On entry expects the TWL VREG lock to be held. It will upgrade the lock to 600 * exclusive if not already, but if so, it will be downgraded again before 601 * returning. 602 * 603 * RETURNS: 604 * Zero on success, or otherwise an error code. 605 */ 606 static int 607 twl_vreg_read_regulator_voltage(struct twl_vreg_softc *sc, 608 struct twl_regulator_entry *regulator, int *millivolts) 609 { 610 int err; 611 int en = 0; 612 int xlocked; 613 uint8_t vsel; 614 615 TWL_VREG_ASSERT_LOCKED(sc); 616 617 /* Need to upgrade the lock because checking enabled state and voltage 618 * should be atomic. 619 */ 620 xlocked = sx_xlocked(&sc->sc_sx); 621 if (!xlocked) 622 TWL_VREG_LOCK_UPGRADE(sc); 623 624 /* Check if the regulator is currently enabled */ 625 err = twl_vreg_is_regulator_enabled(sc, regulator, &en); 626 if (err) 627 goto done; 628 629 *millivolts = 0; 630 if (!en) 631 goto done; 632 633 /* Not all voltages are adjustable */ 634 if (regulator->supp_voltages == NULL || !regulator->num_supp_voltages) { 635 *millivolts = regulator->fixed_voltage; 636 goto done; 637 } 638 639 /* For variable voltages read the voltage register */ 640 err = twl_vreg_read_1(sc, regulator, TWL_VREG_VSEL, &vsel); 641 if (err) 642 goto done; 643 644 vsel &= (regulator->num_supp_voltages - 1); 645 if (regulator->supp_voltages[vsel] == UNDF) { 646 err = EINVAL; 647 goto done; 648 } 649 650 *millivolts = regulator->supp_voltages[vsel]; 651 652 done: 653 if (!xlocked) 654 TWL_VREG_LOCK_DOWNGRADE(sc); 655 656 if ((twl_vreg_debug > 1) && !err) 657 device_printf(sc->sc_dev, "%s : reading voltage is %dmV (vsel: 0x%x)\n", 658 regulator->name, *millivolts, vsel); 659 660 return (err); 661 } 662 663 /** 664 * twl_vreg_get_voltage - public interface to read the voltage on a regulator 665 * @dev: TWL VREG device 666 * @name: the name of the regulator to read the voltage of 667 * @millivolts: pointer to an integer that upon return will contain the mV 668 * 669 * If the regulator is disabled the function will set the @millivolts to zero. 670 * 671 * LOCKING: 672 * Internally the function takes and releases the TWL VREG lock. 673 * 674 * RETURNS: 675 * Zero on success or a negative error code on failure. 676 */ 677 int 678 twl_vreg_get_voltage(device_t dev, const char *name, int *millivolts) 679 { 680 struct twl_vreg_softc *sc; 681 struct twl_regulator_entry *regulator; 682 int err = EINVAL; 683 684 if (millivolts == NULL) 685 return (EINVAL); 686 687 sc = device_get_softc(dev); 688 689 TWL_VREG_SLOCK(sc); 690 691 LIST_FOREACH(regulator, &sc->sc_vreg_list, entries) { 692 if (strcmp(regulator->name, name) == 0) { 693 err = twl_vreg_read_regulator_voltage(sc, regulator, millivolts); 694 break; 695 } 696 } 697 698 TWL_VREG_SUNLOCK(sc); 699 700 return (err); 701 } 702 703 /** 704 * twl_vreg_set_voltage - public interface to write the voltage on a regulator 705 * @dev: TWL VREG device 706 * @name: the name of the regulator to read the voltage of 707 * @millivolts: the voltage to set in millivolts 708 * 709 * Sets the output voltage on a given regulator. If the regulator is a fixed 710 * voltage reg then the @millivolts value should match the fixed voltage. If 711 * a variable regulator then the @millivolt value must fit within the max/min 712 * range of the given regulator. 713 * 714 * LOCKING: 715 * Internally the function takes and releases the TWL VREG lock. 716 * 717 * RETURNS: 718 * Zero on success or a negative error code on failure. 719 */ 720 int 721 twl_vreg_set_voltage(device_t dev, const char *name, int millivolts) 722 { 723 struct twl_vreg_softc *sc; 724 struct twl_regulator_entry *regulator; 725 int err = EINVAL; 726 727 sc = device_get_softc(dev); 728 729 TWL_VREG_SLOCK(sc); 730 731 LIST_FOREACH(regulator, &sc->sc_vreg_list, entries) { 732 if (strcmp(regulator->name, name) == 0) { 733 err = twl_vreg_write_regulator_voltage(sc, regulator, millivolts); 734 break; 735 } 736 } 737 738 TWL_VREG_SUNLOCK(sc); 739 740 return (err); 741 } 742 743 /** 744 * twl_sysctl_voltage - reads or writes the voltage for a regulator 745 * @SYSCTL_HANDLER_ARGS: arguments for the callback 746 * 747 * Callback for the sysctl entry for the regulator, simply used to return 748 * the voltage on a particular regulator. 749 * 750 * LOCKING: 751 * Takes the TWL_VREG shared lock internally. 752 * 753 * RETURNS: 754 * Zero on success or an error code on failure. 755 */ 756 static int 757 twl_vreg_sysctl_voltage(SYSCTL_HANDLER_ARGS) 758 { 759 struct twl_vreg_softc *sc = (struct twl_vreg_softc*)arg1; 760 struct twl_regulator_entry *regulator; 761 int voltage; 762 int found = 0; 763 764 TWL_VREG_SLOCK(sc); 765 766 /* Find the regulator with the matching name */ 767 LIST_FOREACH(regulator, &sc->sc_vreg_list, entries) { 768 if (strcmp(regulator->name, oidp->oid_name) == 0) { 769 found = 1; 770 break; 771 } 772 } 773 774 /* Sanity check that we found the regulator */ 775 if (!found) { 776 TWL_VREG_SUNLOCK(sc); 777 return (EINVAL); 778 } 779 780 twl_vreg_read_regulator_voltage(sc, regulator, &voltage); 781 782 TWL_VREG_SUNLOCK(sc); 783 784 return sysctl_handle_int(oidp, &voltage, 0, req); 785 } 786 787 /** 788 * twl_add_regulator - adds single voltage regulator sysctls for the device 789 * @sc: device soft context 790 * @name: the name of the regulator 791 * @nsub: the number of the subdevice 792 * @regbase: the base address of the voltage regulator registers 793 * @fixed_voltage: if a fixed voltage regulator this defines it's voltage 794 * @voltages: if a variable voltage regulator, an array of possible voltages 795 * @num_voltages: the number of entries @voltages 796 * 797 * Adds a voltage regulator to the device and also a sysctl interface for the 798 * regulator. 799 * 800 * LOCKING: 801 * The TWL_VEG exclusive lock must be held while this function is called. 802 * 803 * RETURNS: 804 * Pointer to the new regulator entry on success, otherwise on failure NULL. 805 */ 806 static struct twl_regulator_entry* 807 twl_vreg_add_regulator(struct twl_vreg_softc *sc, const char *name, 808 uint8_t nsub, uint8_t regbase, uint16_t fixed_voltage, 809 const uint16_t *voltages, uint32_t num_voltages) 810 { 811 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev); 812 struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev); 813 struct twl_regulator_entry *new; 814 815 new = malloc(sizeof(struct twl_regulator_entry), M_DEVBUF, M_NOWAIT | M_ZERO); 816 if (new == NULL) 817 return (NULL); 818 819 strncpy(new->name, name, TWL_VREG_MAX_NAMELEN); 820 new->name[TWL_VREG_MAX_NAMELEN - 1] = '\0'; 821 822 new->sub_dev = nsub; 823 new->reg_off = regbase; 824 825 new->fixed_voltage = fixed_voltage; 826 827 new->supp_voltages = voltages; 828 new->num_supp_voltages = num_voltages; 829 830 /* Add a sysctl entry for the voltage */ 831 new->oid = SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, name, 832 CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_NEEDGIANT, sc, 0, 833 twl_vreg_sysctl_voltage, "I", "voltage regulator"); 834 835 /* Finally add the regulator to list of supported regulators */ 836 LIST_INSERT_HEAD(&sc->sc_vreg_list, new, entries); 837 838 return (new); 839 } 840 841 /** 842 * twl_vreg_add_regulators - adds any voltage regulators to the device 843 * @sc: device soft context 844 * @chip: the name of the chip used in the hints 845 * @regulators: the list of possible voltage regulators 846 * 847 * Loops over the list of regulators and matches up with the FDT values, 848 * adjusting the actual voltage based on the supplied values. 849 * 850 * LOCKING: 851 * The TWL_VEG exclusive lock must be held while this function is called. 852 * 853 * RETURNS: 854 * Always returns 0. 855 */ 856 static int 857 twl_vreg_add_regulators(struct twl_vreg_softc *sc, 858 const struct twl_regulator *regulators) 859 { 860 int err; 861 int millivolts; 862 const struct twl_regulator *walker; 863 struct twl_regulator_entry *entry; 864 phandle_t child; 865 char rnames[256]; 866 char *name, *voltage; 867 int len = 0, prop_len; 868 869 /* Add the regulators from the list */ 870 walker = ®ulators[0]; 871 while (walker->name != NULL) { 872 /* Add the regulator to the list */ 873 entry = twl_vreg_add_regulator(sc, walker->name, walker->subdev, 874 walker->regbase, walker->fixedvoltage, 875 walker->voltages, walker->num_voltages); 876 if (entry == NULL) 877 continue; 878 879 walker++; 880 } 881 882 /* Check if the FDT is telling us to set any voltages */ 883 child = ofw_bus_get_node(sc->sc_pdev); 884 if (child) { 885 prop_len = OF_getprop(child, "voltage-regulators", rnames, sizeof(rnames)); 886 while (len < prop_len) { 887 name = rnames + len; 888 len += strlen(name) + 1; 889 if ((len >= prop_len) || (name[0] == '\0')) 890 break; 891 892 voltage = rnames + len; 893 len += strlen(voltage) + 1; 894 if (voltage[0] == '\0') 895 break; 896 897 millivolts = strtoul(voltage, NULL, 0); 898 899 LIST_FOREACH(entry, &sc->sc_vreg_list, entries) { 900 if (strcmp(entry->name, name) == 0) { 901 twl_vreg_write_regulator_voltage(sc, entry, millivolts); 902 break; 903 } 904 } 905 } 906 } 907 908 if (twl_vreg_debug) { 909 LIST_FOREACH(entry, &sc->sc_vreg_list, entries) { 910 err = twl_vreg_read_regulator_voltage(sc, entry, &millivolts); 911 if (!err) 912 device_printf(sc->sc_dev, "%s : %d mV\n", entry->name, millivolts); 913 } 914 } 915 916 return (0); 917 } 918 919 /** 920 * twl_vreg_init - initialises the list of regulators 921 * @dev: the twl_vreg device 922 * 923 * This function is called as an intrhook once interrupts have been enabled, 924 * this is done so that the driver has the option to enable/disable or set 925 * the voltage level based on settings providied in the FDT. 926 * 927 * LOCKING: 928 * Takes the exclusive lock in the function. 929 */ 930 static void 931 twl_vreg_init(void *dev) 932 { 933 struct twl_vreg_softc *sc; 934 935 sc = device_get_softc((device_t)dev); 936 937 TWL_VREG_XLOCK(sc); 938 939 if (twl_is_4030(sc->sc_pdev)) 940 twl_vreg_add_regulators(sc, twl4030_regulators); 941 else if (twl_is_6030(sc->sc_pdev) || twl_is_6025(sc->sc_pdev)) 942 twl_vreg_add_regulators(sc, twl6030_regulators); 943 944 TWL_VREG_XUNLOCK(sc); 945 946 config_intrhook_disestablish(&sc->sc_init_hook); 947 } 948 949 static int 950 twl_vreg_probe(device_t dev) 951 { 952 if (twl_is_4030(device_get_parent(dev))) 953 device_set_desc(dev, "TI TWL4030 PMIC Voltage Regulators"); 954 else if (twl_is_6025(device_get_parent(dev)) || 955 twl_is_6030(device_get_parent(dev))) 956 device_set_desc(dev, "TI TWL6025/TWL6030 PMIC Voltage Regulators"); 957 else 958 return (ENXIO); 959 960 return (0); 961 } 962 963 static int 964 twl_vreg_attach(device_t dev) 965 { 966 struct twl_vreg_softc *sc; 967 968 sc = device_get_softc(dev); 969 sc->sc_dev = dev; 970 sc->sc_pdev = device_get_parent(dev); 971 972 TWL_VREG_LOCK_INIT(sc); 973 974 LIST_INIT(&sc->sc_vreg_list); 975 976 /* We have to wait until interrupts are enabled. I2C read and write 977 * only works if the interrupts are available. 978 */ 979 sc->sc_init_hook.ich_func = twl_vreg_init; 980 sc->sc_init_hook.ich_arg = dev; 981 982 if (config_intrhook_establish(&sc->sc_init_hook) != 0) 983 return (ENOMEM); 984 985 return (0); 986 } 987 988 static int 989 twl_vreg_detach(device_t dev) 990 { 991 struct twl_vreg_softc *sc; 992 struct twl_regulator_entry *regulator; 993 struct twl_regulator_entry *tmp; 994 995 sc = device_get_softc(dev); 996 997 /* Take the lock and free all the added regulators */ 998 TWL_VREG_XLOCK(sc); 999 1000 LIST_FOREACH_SAFE(regulator, &sc->sc_vreg_list, entries, tmp) { 1001 LIST_REMOVE(regulator, entries); 1002 sysctl_remove_oid(regulator->oid, 1, 0); 1003 free(regulator, M_DEVBUF); 1004 } 1005 1006 TWL_VREG_XUNLOCK(sc); 1007 1008 TWL_VREG_LOCK_DESTROY(sc); 1009 1010 return (0); 1011 } 1012 1013 static device_method_t twl_vreg_methods[] = { 1014 DEVMETHOD(device_probe, twl_vreg_probe), 1015 DEVMETHOD(device_attach, twl_vreg_attach), 1016 DEVMETHOD(device_detach, twl_vreg_detach), 1017 1018 {0, 0}, 1019 }; 1020 1021 static driver_t twl_vreg_driver = { 1022 "twl_vreg", 1023 twl_vreg_methods, 1024 sizeof(struct twl_vreg_softc), 1025 }; 1026 1027 DRIVER_MODULE(twl_vreg, twl, twl_vreg_driver, 0, 0); 1028 MODULE_VERSION(twl_vreg, 1); 1029