Mike Rapoport | 4961023 | 2010-07-27 14:03:01 +0300 | [diff] [blame] | 1 | /* |
| 2 | * Regulator driver for TI TPS6586x |
| 3 | * |
| 4 | * Copyright (C) 2010 Compulab Ltd. |
| 5 | * Author: Mike Rapoport <mike@compulab.co.il> |
| 6 | * |
| 7 | * Based on da903x |
| 8 | * Copyright (C) 2006-2008 Marvell International Ltd. |
| 9 | * Copyright (C) 2008 Compulab Ltd. |
| 10 | * |
| 11 | * This program is free software; you can redistribute it and/or modify |
| 12 | * it under the terms of the GNU General Public License version 2 as |
| 13 | * published by the Free Software Foundation. |
| 14 | */ |
| 15 | |
Mike Rapoport | 4961023 | 2010-07-27 14:03:01 +0300 | [diff] [blame] | 16 | #include <linux/kernel.h> |
| 17 | #include <linux/init.h> |
| 18 | #include <linux/err.h> |
| 19 | #include <linux/slab.h> |
| 20 | #include <linux/platform_device.h> |
| 21 | #include <linux/regulator/driver.h> |
| 22 | #include <linux/regulator/machine.h> |
| 23 | #include <linux/mfd/tps6586x.h> |
| 24 | |
| 25 | /* supply control and voltage setting */ |
| 26 | #define TPS6586X_SUPPLYENA 0x10 |
| 27 | #define TPS6586X_SUPPLYENB 0x11 |
| 28 | #define TPS6586X_SUPPLYENC 0x12 |
| 29 | #define TPS6586X_SUPPLYEND 0x13 |
| 30 | #define TPS6586X_SUPPLYENE 0x14 |
| 31 | #define TPS6586X_VCC1 0x20 |
| 32 | #define TPS6586X_VCC2 0x21 |
| 33 | #define TPS6586X_SM1V1 0x23 |
| 34 | #define TPS6586X_SM1V2 0x24 |
| 35 | #define TPS6586X_SM1SL 0x25 |
| 36 | #define TPS6586X_SM0V1 0x26 |
| 37 | #define TPS6586X_SM0V2 0x27 |
| 38 | #define TPS6586X_SM0SL 0x28 |
| 39 | #define TPS6586X_LDO2AV1 0x29 |
| 40 | #define TPS6586X_LDO2AV2 0x2A |
| 41 | #define TPS6586X_LDO2BV1 0x2F |
| 42 | #define TPS6586X_LDO2BV2 0x30 |
| 43 | #define TPS6586X_LDO4V1 0x32 |
| 44 | #define TPS6586X_LDO4V2 0x33 |
| 45 | |
| 46 | /* converter settings */ |
| 47 | #define TPS6586X_SUPPLYV1 0x41 |
| 48 | #define TPS6586X_SUPPLYV2 0x42 |
| 49 | #define TPS6586X_SUPPLYV3 0x43 |
| 50 | #define TPS6586X_SUPPLYV4 0x44 |
| 51 | #define TPS6586X_SUPPLYV5 0x45 |
| 52 | #define TPS6586X_SUPPLYV6 0x46 |
| 53 | #define TPS6586X_SMODE1 0x47 |
| 54 | #define TPS6586X_SMODE2 0x48 |
| 55 | |
| 56 | struct tps6586x_regulator { |
| 57 | struct regulator_desc desc; |
| 58 | |
| 59 | int volt_reg; |
| 60 | int volt_shift; |
| 61 | int volt_nbits; |
| 62 | int enable_bit[2]; |
| 63 | int enable_reg[2]; |
| 64 | |
| 65 | int *voltages; |
| 66 | |
| 67 | /* for DVM regulators */ |
| 68 | int go_reg; |
| 69 | int go_bit; |
| 70 | }; |
| 71 | |
| 72 | static inline struct device *to_tps6586x_dev(struct regulator_dev *rdev) |
| 73 | { |
| 74 | return rdev_get_dev(rdev)->parent->parent; |
| 75 | } |
| 76 | |
| 77 | static int tps6586x_ldo_list_voltage(struct regulator_dev *rdev, |
| 78 | unsigned selector) |
| 79 | { |
| 80 | struct tps6586x_regulator *info = rdev_get_drvdata(rdev); |
| 81 | |
Gary King | 4cc2e39 | 2010-07-30 22:58:58 +0300 | [diff] [blame] | 82 | return info->voltages[selector] * 1000; |
Mike Rapoport | 4961023 | 2010-07-27 14:03:01 +0300 | [diff] [blame] | 83 | } |
| 84 | |
| 85 | |
| 86 | static int __tps6586x_ldo_set_voltage(struct device *parent, |
| 87 | struct tps6586x_regulator *ri, |
| 88 | int min_uV, int max_uV) |
| 89 | { |
| 90 | int val, uV; |
| 91 | uint8_t mask; |
| 92 | |
| 93 | for (val = 0; val < ri->desc.n_voltages; val++) { |
| 94 | uV = ri->voltages[val] * 1000; |
| 95 | |
| 96 | /* LDO0 has minimal voltage 1.2 rather than 1.25 */ |
| 97 | if (ri->desc.id == TPS6586X_ID_LDO_0 && val == 0) |
| 98 | uV -= 50 * 1000; |
| 99 | |
| 100 | /* use the first in-range value */ |
| 101 | if (min_uV <= uV && uV <= max_uV) { |
| 102 | |
| 103 | val <<= ri->volt_shift; |
| 104 | mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift; |
| 105 | |
| 106 | return tps6586x_update(parent, ri->volt_reg, val, mask); |
| 107 | } |
| 108 | } |
| 109 | |
| 110 | return -EINVAL; |
| 111 | } |
| 112 | |
| 113 | static int tps6586x_ldo_set_voltage(struct regulator_dev *rdev, |
| 114 | int min_uV, int max_uV) |
| 115 | { |
| 116 | struct tps6586x_regulator *ri = rdev_get_drvdata(rdev); |
| 117 | struct device *parent = to_tps6586x_dev(rdev); |
| 118 | |
| 119 | return __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV); |
| 120 | } |
| 121 | |
| 122 | static int tps6586x_ldo_get_voltage(struct regulator_dev *rdev) |
| 123 | { |
| 124 | struct tps6586x_regulator *ri = rdev_get_drvdata(rdev); |
| 125 | struct device *parent = to_tps6586x_dev(rdev); |
| 126 | uint8_t val, mask; |
| 127 | int ret; |
| 128 | |
| 129 | ret = tps6586x_read(parent, ri->volt_reg, &val); |
| 130 | if (ret) |
| 131 | return ret; |
| 132 | |
| 133 | mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift; |
| 134 | val = (val & mask) >> ri->volt_shift; |
| 135 | |
Axel Lin | 327531b | 2010-08-22 22:38:15 +0800 | [diff] [blame] | 136 | if (val >= ri->desc.n_voltages) |
Mike Rapoport | 4961023 | 2010-07-27 14:03:01 +0300 | [diff] [blame] | 137 | BUG(); |
| 138 | |
Gary King | 4cc2e39 | 2010-07-30 22:58:58 +0300 | [diff] [blame] | 139 | return ri->voltages[val] * 1000; |
Mike Rapoport | 4961023 | 2010-07-27 14:03:01 +0300 | [diff] [blame] | 140 | } |
| 141 | |
| 142 | static int tps6586x_dvm_set_voltage(struct regulator_dev *rdev, |
| 143 | int min_uV, int max_uV) |
| 144 | { |
| 145 | struct tps6586x_regulator *ri = rdev_get_drvdata(rdev); |
| 146 | struct device *parent = to_tps6586x_dev(rdev); |
| 147 | int ret; |
| 148 | |
| 149 | ret = __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV); |
| 150 | if (ret) |
| 151 | return ret; |
| 152 | |
Axel Lin | 938b459 | 2010-08-22 22:42:42 +0800 | [diff] [blame] | 153 | return tps6586x_set_bits(parent, ri->go_reg, 1 << ri->go_bit); |
Mike Rapoport | 4961023 | 2010-07-27 14:03:01 +0300 | [diff] [blame] | 154 | } |
| 155 | |
| 156 | static int tps6586x_regulator_enable(struct regulator_dev *rdev) |
| 157 | { |
| 158 | struct tps6586x_regulator *ri = rdev_get_drvdata(rdev); |
| 159 | struct device *parent = to_tps6586x_dev(rdev); |
| 160 | |
| 161 | return tps6586x_set_bits(parent, ri->enable_reg[0], |
| 162 | 1 << ri->enable_bit[0]); |
| 163 | } |
| 164 | |
| 165 | static int tps6586x_regulator_disable(struct regulator_dev *rdev) |
| 166 | { |
| 167 | struct tps6586x_regulator *ri = rdev_get_drvdata(rdev); |
| 168 | struct device *parent = to_tps6586x_dev(rdev); |
| 169 | |
| 170 | return tps6586x_clr_bits(parent, ri->enable_reg[0], |
| 171 | 1 << ri->enable_bit[0]); |
| 172 | } |
| 173 | |
| 174 | static int tps6586x_regulator_is_enabled(struct regulator_dev *rdev) |
| 175 | { |
| 176 | struct tps6586x_regulator *ri = rdev_get_drvdata(rdev); |
| 177 | struct device *parent = to_tps6586x_dev(rdev); |
| 178 | uint8_t reg_val; |
| 179 | int ret; |
| 180 | |
| 181 | ret = tps6586x_read(parent, ri->enable_reg[0], ®_val); |
| 182 | if (ret) |
| 183 | return ret; |
| 184 | |
| 185 | return !!(reg_val & (1 << ri->enable_bit[0])); |
| 186 | } |
| 187 | |
| 188 | static struct regulator_ops tps6586x_regulator_ldo_ops = { |
| 189 | .list_voltage = tps6586x_ldo_list_voltage, |
| 190 | .get_voltage = tps6586x_ldo_get_voltage, |
| 191 | .set_voltage = tps6586x_ldo_set_voltage, |
| 192 | |
| 193 | .is_enabled = tps6586x_regulator_is_enabled, |
| 194 | .enable = tps6586x_regulator_enable, |
| 195 | .disable = tps6586x_regulator_disable, |
| 196 | }; |
| 197 | |
| 198 | static struct regulator_ops tps6586x_regulator_dvm_ops = { |
| 199 | .list_voltage = tps6586x_ldo_list_voltage, |
| 200 | .get_voltage = tps6586x_ldo_get_voltage, |
| 201 | .set_voltage = tps6586x_dvm_set_voltage, |
| 202 | |
| 203 | .is_enabled = tps6586x_regulator_is_enabled, |
| 204 | .enable = tps6586x_regulator_enable, |
| 205 | .disable = tps6586x_regulator_disable, |
| 206 | }; |
| 207 | |
| 208 | static int tps6586x_ldo_voltages[] = { |
| 209 | 1250, 1500, 1800, 2500, 2700, 2850, 3100, 3300, |
| 210 | }; |
| 211 | |
| 212 | static int tps6586x_ldo4_voltages[] = { |
| 213 | 1700, 1725, 1750, 1775, 1800, 1825, 1850, 1875, |
| 214 | 1900, 1925, 1950, 1975, 2000, 2025, 2050, 2075, |
| 215 | 2100, 2125, 2150, 2175, 2200, 2225, 2250, 2275, |
| 216 | 2300, 2325, 2350, 2375, 2400, 2425, 2450, 2475, |
| 217 | }; |
| 218 | |
Gary King | 4cc2e39 | 2010-07-30 22:58:58 +0300 | [diff] [blame] | 219 | static int tps6586x_sm2_voltages[] = { |
| 220 | 3000, 3050, 3100, 3150, 3200, 3250, 3300, 3350, |
| 221 | 3400, 3450, 3500, 3550, 3600, 3650, 3700, 3750, |
| 222 | 3800, 3850, 3900, 3950, 4000, 4050, 4100, 4150, |
| 223 | 4200, 4250, 4300, 4350, 4400, 4450, 4500, 4550, |
| 224 | }; |
| 225 | |
Mike Rapoport | 4961023 | 2010-07-27 14:03:01 +0300 | [diff] [blame] | 226 | static int tps6586x_dvm_voltages[] = { |
| 227 | 725, 750, 775, 800, 825, 850, 875, 900, |
| 228 | 925, 950, 975, 1000, 1025, 1050, 1075, 1100, |
| 229 | 1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300, |
| 230 | 1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500, |
| 231 | }; |
| 232 | |
| 233 | #define TPS6586X_REGULATOR(_id, vdata, _ops, vreg, shift, nbits, \ |
| 234 | ereg0, ebit0, ereg1, ebit1, goreg, gobit) \ |
| 235 | { \ |
| 236 | .desc = { \ |
| 237 | .name = "REG-" #_id, \ |
| 238 | .ops = &tps6586x_regulator_##_ops, \ |
| 239 | .type = REGULATOR_VOLTAGE, \ |
| 240 | .id = TPS6586X_ID_##_id, \ |
| 241 | .n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages), \ |
| 242 | .owner = THIS_MODULE, \ |
| 243 | }, \ |
| 244 | .volt_reg = TPS6586X_##vreg, \ |
| 245 | .volt_shift = (shift), \ |
| 246 | .volt_nbits = (nbits), \ |
| 247 | .enable_reg[0] = TPS6586X_SUPPLY##ereg0, \ |
| 248 | .enable_bit[0] = (ebit0), \ |
| 249 | .enable_reg[1] = TPS6586X_SUPPLY##ereg1, \ |
| 250 | .enable_bit[1] = (ebit1), \ |
| 251 | .voltages = tps6586x_##vdata##_voltages, \ |
| 252 | } |
| 253 | |
| 254 | #define TPS6586X_LDO(_id, vdata, vreg, shift, nbits, \ |
| 255 | ereg0, ebit0, ereg1, ebit1) \ |
| 256 | TPS6586X_REGULATOR(_id, vdata, ldo_ops, vreg, shift, nbits, \ |
| 257 | ereg0, ebit0, ereg1, ebit1, 0, 0) |
| 258 | |
| 259 | #define TPS6586X_DVM(_id, vdata, vreg, shift, nbits, \ |
| 260 | ereg0, ebit0, ereg1, ebit1, goreg, gobit) \ |
| 261 | TPS6586X_REGULATOR(_id, vdata, dvm_ops, vreg, shift, nbits, \ |
| 262 | ereg0, ebit0, ereg1, ebit1, goreg, gobit) |
| 263 | |
| 264 | static struct tps6586x_regulator tps6586x_regulator[] = { |
| 265 | TPS6586X_LDO(LDO_0, ldo, SUPPLYV1, 5, 3, ENC, 0, END, 0), |
| 266 | TPS6586X_LDO(LDO_3, ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2), |
| 267 | TPS6586X_LDO(LDO_5, ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6), |
| 268 | TPS6586X_LDO(LDO_6, ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4), |
| 269 | TPS6586X_LDO(LDO_7, ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5), |
| 270 | TPS6586X_LDO(LDO_8, ldo, SUPPLYV1, 5, 3, ENC, 6, END, 6), |
| 271 | TPS6586X_LDO(LDO_9, ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7), |
| 272 | TPS6586X_LDO(LDO_RTC, ldo, SUPPLYV4, 3, 3, ENE, 7, ENE, 7), |
| 273 | TPS6586X_LDO(LDO_1, dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1), |
Gary King | 4cc2e39 | 2010-07-30 22:58:58 +0300 | [diff] [blame] | 274 | TPS6586X_LDO(SM_2, sm2, SUPPLYV2, 0, 5, ENC, 1, END, 1), |
Mike Rapoport | 4961023 | 2010-07-27 14:03:01 +0300 | [diff] [blame] | 275 | |
| 276 | TPS6586X_DVM(LDO_2, dvm, LDO2BV1, 0, 5, ENA, 3, ENB, 3, VCC2, 6), |
| 277 | TPS6586X_DVM(LDO_4, ldo4, LDO4V1, 0, 5, ENC, 3, END, 3, VCC1, 6), |
| 278 | TPS6586X_DVM(SM_0, dvm, SM0V1, 0, 5, ENA, 1, ENB, 1, VCC1, 2), |
| 279 | TPS6586X_DVM(SM_1, dvm, SM1V1, 0, 5, ENA, 0, ENB, 0, VCC1, 0), |
| 280 | }; |
| 281 | |
| 282 | /* |
| 283 | * TPS6586X has 2 enable bits that are OR'ed to determine the actual |
| 284 | * regulator state. Clearing one of this bits allows switching |
| 285 | * regulator on and of with single register write. |
| 286 | */ |
| 287 | static inline int tps6586x_regulator_preinit(struct device *parent, |
| 288 | struct tps6586x_regulator *ri) |
| 289 | { |
| 290 | uint8_t val1, val2; |
| 291 | int ret; |
| 292 | |
| 293 | ret = tps6586x_read(parent, ri->enable_reg[0], &val1); |
| 294 | if (ret) |
| 295 | return ret; |
| 296 | |
| 297 | ret = tps6586x_read(parent, ri->enable_reg[1], &val2); |
| 298 | if (ret) |
| 299 | return ret; |
| 300 | |
| 301 | if (!(val2 & ri->enable_bit[1])) |
| 302 | return 0; |
| 303 | |
| 304 | /* |
| 305 | * The regulator is on, but it's enabled with the bit we don't |
| 306 | * want to use, so we switch the enable bits |
| 307 | */ |
| 308 | if (!(val1 & ri->enable_bit[0])) { |
| 309 | ret = tps6586x_set_bits(parent, ri->enable_reg[0], |
| 310 | 1 << ri->enable_bit[0]); |
| 311 | if (ret) |
| 312 | return ret; |
| 313 | } |
| 314 | |
| 315 | return tps6586x_clr_bits(parent, ri->enable_reg[1], |
| 316 | 1 << ri->enable_bit[1]); |
| 317 | } |
| 318 | |
| 319 | static inline struct tps6586x_regulator *find_regulator_info(int id) |
| 320 | { |
| 321 | struct tps6586x_regulator *ri; |
| 322 | int i; |
| 323 | |
| 324 | for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) { |
| 325 | ri = &tps6586x_regulator[i]; |
| 326 | if (ri->desc.id == id) |
| 327 | return ri; |
| 328 | } |
| 329 | return NULL; |
| 330 | } |
| 331 | |
| 332 | static int __devinit tps6586x_regulator_probe(struct platform_device *pdev) |
| 333 | { |
| 334 | struct tps6586x_regulator *ri = NULL; |
| 335 | struct regulator_dev *rdev; |
| 336 | int id = pdev->id; |
| 337 | int err; |
| 338 | |
| 339 | dev_dbg(&pdev->dev, "Probing reulator %d\n", id); |
| 340 | |
| 341 | ri = find_regulator_info(id); |
| 342 | if (ri == NULL) { |
| 343 | dev_err(&pdev->dev, "invalid regulator ID specified\n"); |
| 344 | return -EINVAL; |
| 345 | } |
| 346 | |
| 347 | err = tps6586x_regulator_preinit(pdev->dev.parent, ri); |
| 348 | if (err) |
| 349 | return err; |
| 350 | |
| 351 | rdev = regulator_register(&ri->desc, &pdev->dev, |
| 352 | pdev->dev.platform_data, ri); |
| 353 | if (IS_ERR(rdev)) { |
| 354 | dev_err(&pdev->dev, "failed to register regulator %s\n", |
| 355 | ri->desc.name); |
| 356 | return PTR_ERR(rdev); |
| 357 | } |
| 358 | |
Axel Lin | e7973c3 | 2010-08-09 15:58:06 +0800 | [diff] [blame] | 359 | platform_set_drvdata(pdev, rdev); |
Mike Rapoport | 4961023 | 2010-07-27 14:03:01 +0300 | [diff] [blame] | 360 | |
| 361 | return 0; |
| 362 | } |
| 363 | |
| 364 | static int __devexit tps6586x_regulator_remove(struct platform_device *pdev) |
| 365 | { |
Axel Lin | e7973c3 | 2010-08-09 15:58:06 +0800 | [diff] [blame] | 366 | struct regulator_dev *rdev = platform_get_drvdata(pdev); |
| 367 | |
| 368 | regulator_unregister(rdev); |
Mike Rapoport | 4961023 | 2010-07-27 14:03:01 +0300 | [diff] [blame] | 369 | return 0; |
| 370 | } |
| 371 | |
| 372 | static struct platform_driver tps6586x_regulator_driver = { |
| 373 | .driver = { |
| 374 | .name = "tps6586x-regulator", |
| 375 | .owner = THIS_MODULE, |
| 376 | }, |
| 377 | .probe = tps6586x_regulator_probe, |
| 378 | .remove = __devexit_p(tps6586x_regulator_remove), |
| 379 | }; |
| 380 | |
| 381 | static int __init tps6586x_regulator_init(void) |
| 382 | { |
| 383 | return platform_driver_register(&tps6586x_regulator_driver); |
| 384 | } |
| 385 | subsys_initcall(tps6586x_regulator_init); |
| 386 | |
| 387 | static void __exit tps6586x_regulator_exit(void) |
| 388 | { |
| 389 | platform_driver_unregister(&tps6586x_regulator_driver); |
| 390 | } |
| 391 | module_exit(tps6586x_regulator_exit); |
| 392 | |
| 393 | MODULE_LICENSE("GPL"); |
| 394 | MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>"); |
| 395 | MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC"); |
| 396 | MODULE_ALIAS("platform:tps6586x-regulator"); |