1 /* 2 * Copyright (C) ST-Ericsson SA 2010 3 * 4 * License Terms: GNU General Public License v2 5 * 6 * Authors: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson 7 * Bengt Jonsson <bengt.g.jonsson@stericsson.com> for ST-Ericsson 8 * 9 * AB8500 peripheral regulators 10 * 11 * AB8500 supports the following regulators: 12 * VAUX1/2/3, VINTCORE, VTVOUT, VAUDIO, VAMIC1/2, VDMIC, VANA 13 */ 14 #include <linux/init.h> 15 #include <linux/kernel.h> 16 #include <linux/err.h> 17 #include <linux/platform_device.h> 18 #include <linux/mfd/ab8500.h> 19 #include <linux/mfd/abx500.h> 20 #include <linux/regulator/driver.h> 21 #include <linux/regulator/machine.h> 22 #include <linux/regulator/ab8500.h> 23 24 /** 25 * struct ab8500_regulator_info - ab8500 regulator information 26 * @dev: device pointer 27 * @desc: regulator description 28 * @regulator_dev: regulator device 29 * @max_uV: maximum voltage (for variable voltage supplies) 30 * @min_uV: minimum voltage (for variable voltage supplies) 31 * @fixed_uV: typical voltage (for fixed voltage supplies) 32 * @update_bank: bank to control on/off 33 * @update_reg: register to control on/off 34 * @update_mask: mask to enable/disable regulator 35 * @update_val_enable: bits to enable the regulator in normal (high power) mode 36 * @voltage_bank: bank to control regulator voltage 37 * @voltage_reg: register to control regulator voltage 38 * @voltage_mask: mask to control regulator voltage 39 * @voltages: supported voltage table 40 * @voltages_len: number of supported voltages for the regulator 41 */ 42 struct ab8500_regulator_info { 43 struct device *dev; 44 struct regulator_desc desc; 45 struct regulator_dev *regulator; 46 int max_uV; 47 int min_uV; 48 int fixed_uV; 49 u8 update_bank; 50 u8 update_reg; 51 u8 update_mask; 52 u8 update_val_enable; 53 u8 voltage_bank; 54 u8 voltage_reg; 55 u8 voltage_mask; 56 int const *voltages; 57 int voltages_len; 58 }; 59 60 /* voltage tables for the vauxn/vintcore supplies */ 61 static const int ldo_vauxn_voltages[] = { 62 1100000, 63 1200000, 64 1300000, 65 1400000, 66 1500000, 67 1800000, 68 1850000, 69 1900000, 70 2500000, 71 2650000, 72 2700000, 73 2750000, 74 2800000, 75 2900000, 76 3000000, 77 3300000, 78 }; 79 80 static const int ldo_vaux3_voltages[] = { 81 1200000, 82 1500000, 83 1800000, 84 2100000, 85 2500000, 86 2750000, 87 2790000, 88 2910000, 89 }; 90 91 static const int ldo_vintcore_voltages[] = { 92 1200000, 93 1225000, 94 1250000, 95 1275000, 96 1300000, 97 1325000, 98 1350000, 99 }; 100 101 static int ab8500_regulator_enable(struct regulator_dev *rdev) 102 { 103 int ret; 104 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev); 105 106 if (info == NULL) { 107 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n"); 108 return -EINVAL; 109 } 110 111 ret = abx500_mask_and_set_register_interruptible(info->dev, 112 info->update_bank, info->update_reg, 113 info->update_mask, info->update_val_enable); 114 if (ret < 0) 115 dev_err(rdev_get_dev(rdev), 116 "couldn't set enable bits for regulator\n"); 117 118 dev_vdbg(rdev_get_dev(rdev), 119 "%s-enable (bank, reg, mask, value): 0x%x, 0x%x, 0x%x, 0x%x\n", 120 info->desc.name, info->update_bank, info->update_reg, 121 info->update_mask, info->update_val_enable); 122 123 return ret; 124 } 125 126 static int ab8500_regulator_disable(struct regulator_dev *rdev) 127 { 128 int ret; 129 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev); 130 131 if (info == NULL) { 132 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n"); 133 return -EINVAL; 134 } 135 136 ret = abx500_mask_and_set_register_interruptible(info->dev, 137 info->update_bank, info->update_reg, 138 info->update_mask, 0x0); 139 if (ret < 0) 140 dev_err(rdev_get_dev(rdev), 141 "couldn't set disable bits for regulator\n"); 142 143 dev_vdbg(rdev_get_dev(rdev), 144 "%s-disable (bank, reg, mask, value): 0x%x, 0x%x, 0x%x, 0x%x\n", 145 info->desc.name, info->update_bank, info->update_reg, 146 info->update_mask, 0x0); 147 148 return ret; 149 } 150 151 static int ab8500_regulator_is_enabled(struct regulator_dev *rdev) 152 { 153 int ret; 154 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev); 155 u8 regval; 156 157 if (info == NULL) { 158 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n"); 159 return -EINVAL; 160 } 161 162 ret = abx500_get_register_interruptible(info->dev, 163 info->update_bank, info->update_reg, ®val); 164 if (ret < 0) { 165 dev_err(rdev_get_dev(rdev), 166 "couldn't read 0x%x register\n", info->update_reg); 167 return ret; 168 } 169 170 dev_vdbg(rdev_get_dev(rdev), 171 "%s-is_enabled (bank, reg, mask, value): 0x%x, 0x%x, 0x%x," 172 " 0x%x\n", 173 info->desc.name, info->update_bank, info->update_reg, 174 info->update_mask, regval); 175 176 if (regval & info->update_mask) 177 return true; 178 else 179 return false; 180 } 181 182 static int ab8500_list_voltage(struct regulator_dev *rdev, unsigned selector) 183 { 184 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev); 185 186 if (info == NULL) { 187 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n"); 188 return -EINVAL; 189 } 190 191 /* return the uV for the fixed regulators */ 192 if (info->fixed_uV) 193 return info->fixed_uV; 194 195 if (selector >= info->voltages_len) 196 return -EINVAL; 197 198 return info->voltages[selector]; 199 } 200 201 static int ab8500_regulator_get_voltage(struct regulator_dev *rdev) 202 { 203 int ret, val; 204 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev); 205 u8 regval; 206 207 if (info == NULL) { 208 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n"); 209 return -EINVAL; 210 } 211 212 ret = abx500_get_register_interruptible(info->dev, 213 info->voltage_bank, info->voltage_reg, ®val); 214 if (ret < 0) { 215 dev_err(rdev_get_dev(rdev), 216 "couldn't read voltage reg for regulator\n"); 217 return ret; 218 } 219 220 dev_vdbg(rdev_get_dev(rdev), 221 "%s-get_voltage (bank, reg, mask, value): 0x%x, 0x%x, 0x%x," 222 " 0x%x\n", 223 info->desc.name, info->voltage_bank, info->voltage_reg, 224 info->voltage_mask, regval); 225 226 /* vintcore has a different layout */ 227 val = regval & info->voltage_mask; 228 if (info->desc.id == AB8500_LDO_INTCORE) 229 ret = info->voltages[val >> 0x3]; 230 else 231 ret = info->voltages[val]; 232 233 return ret; 234 } 235 236 static int ab8500_get_best_voltage_index(struct regulator_dev *rdev, 237 int min_uV, int max_uV) 238 { 239 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev); 240 int i; 241 242 /* check the supported voltage */ 243 for (i = 0; i < info->voltages_len; i++) { 244 if ((info->voltages[i] >= min_uV) && 245 (info->voltages[i] <= max_uV)) 246 return i; 247 } 248 249 return -EINVAL; 250 } 251 252 static int ab8500_regulator_set_voltage(struct regulator_dev *rdev, 253 int min_uV, int max_uV, 254 unsigned *selector) 255 { 256 int ret; 257 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev); 258 u8 regval; 259 260 if (info == NULL) { 261 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n"); 262 return -EINVAL; 263 } 264 265 /* get the appropriate voltages within the range */ 266 ret = ab8500_get_best_voltage_index(rdev, min_uV, max_uV); 267 if (ret < 0) { 268 dev_err(rdev_get_dev(rdev), 269 "couldn't get best voltage for regulator\n"); 270 return ret; 271 } 272 273 *selector = ret; 274 275 /* set the registers for the request */ 276 regval = (u8)ret; 277 ret = abx500_mask_and_set_register_interruptible(info->dev, 278 info->voltage_bank, info->voltage_reg, 279 info->voltage_mask, regval); 280 if (ret < 0) 281 dev_err(rdev_get_dev(rdev), 282 "couldn't set voltage reg for regulator\n"); 283 284 dev_vdbg(rdev_get_dev(rdev), 285 "%s-set_voltage (bank, reg, mask, value): 0x%x, 0x%x, 0x%x," 286 " 0x%x\n", 287 info->desc.name, info->voltage_bank, info->voltage_reg, 288 info->voltage_mask, regval); 289 290 return ret; 291 } 292 293 static struct regulator_ops ab8500_regulator_ops = { 294 .enable = ab8500_regulator_enable, 295 .disable = ab8500_regulator_disable, 296 .is_enabled = ab8500_regulator_is_enabled, 297 .get_voltage = ab8500_regulator_get_voltage, 298 .set_voltage = ab8500_regulator_set_voltage, 299 .list_voltage = ab8500_list_voltage, 300 }; 301 302 static int ab8500_fixed_get_voltage(struct regulator_dev *rdev) 303 { 304 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev); 305 306 if (info == NULL) { 307 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n"); 308 return -EINVAL; 309 } 310 311 return info->fixed_uV; 312 } 313 314 static struct regulator_ops ab8500_regulator_fixed_ops = { 315 .enable = ab8500_regulator_enable, 316 .disable = ab8500_regulator_disable, 317 .is_enabled = ab8500_regulator_is_enabled, 318 .get_voltage = ab8500_fixed_get_voltage, 319 .list_voltage = ab8500_list_voltage, 320 }; 321 322 static struct ab8500_regulator_info 323 ab8500_regulator_info[AB8500_NUM_REGULATORS] = { 324 /* 325 * Variable Voltage Regulators 326 * name, min mV, max mV, 327 * update bank, reg, mask, enable val 328 * volt bank, reg, mask, table, table length 329 */ 330 [AB8500_LDO_AUX1] = { 331 .desc = { 332 .name = "LDO-AUX1", 333 .ops = &ab8500_regulator_ops, 334 .type = REGULATOR_VOLTAGE, 335 .id = AB8500_LDO_AUX1, 336 .owner = THIS_MODULE, 337 .n_voltages = ARRAY_SIZE(ldo_vauxn_voltages), 338 }, 339 .min_uV = 1100000, 340 .max_uV = 3300000, 341 .update_bank = 0x04, 342 .update_reg = 0x09, 343 .update_mask = 0x03, 344 .update_val_enable = 0x01, 345 .voltage_bank = 0x04, 346 .voltage_reg = 0x1f, 347 .voltage_mask = 0x0f, 348 .voltages = ldo_vauxn_voltages, 349 .voltages_len = ARRAY_SIZE(ldo_vauxn_voltages), 350 }, 351 [AB8500_LDO_AUX2] = { 352 .desc = { 353 .name = "LDO-AUX2", 354 .ops = &ab8500_regulator_ops, 355 .type = REGULATOR_VOLTAGE, 356 .id = AB8500_LDO_AUX2, 357 .owner = THIS_MODULE, 358 .n_voltages = ARRAY_SIZE(ldo_vauxn_voltages), 359 }, 360 .min_uV = 1100000, 361 .max_uV = 3300000, 362 .update_bank = 0x04, 363 .update_reg = 0x09, 364 .update_mask = 0x0c, 365 .update_val_enable = 0x04, 366 .voltage_bank = 0x04, 367 .voltage_reg = 0x20, 368 .voltage_mask = 0x0f, 369 .voltages = ldo_vauxn_voltages, 370 .voltages_len = ARRAY_SIZE(ldo_vauxn_voltages), 371 }, 372 [AB8500_LDO_AUX3] = { 373 .desc = { 374 .name = "LDO-AUX3", 375 .ops = &ab8500_regulator_ops, 376 .type = REGULATOR_VOLTAGE, 377 .id = AB8500_LDO_AUX3, 378 .owner = THIS_MODULE, 379 .n_voltages = ARRAY_SIZE(ldo_vaux3_voltages), 380 }, 381 .min_uV = 1100000, 382 .max_uV = 3300000, 383 .update_bank = 0x04, 384 .update_reg = 0x0a, 385 .update_mask = 0x03, 386 .update_val_enable = 0x01, 387 .voltage_bank = 0x04, 388 .voltage_reg = 0x21, 389 .voltage_mask = 0x07, 390 .voltages = ldo_vaux3_voltages, 391 .voltages_len = ARRAY_SIZE(ldo_vaux3_voltages), 392 }, 393 [AB8500_LDO_INTCORE] = { 394 .desc = { 395 .name = "LDO-INTCORE", 396 .ops = &ab8500_regulator_ops, 397 .type = REGULATOR_VOLTAGE, 398 .id = AB8500_LDO_INTCORE, 399 .owner = THIS_MODULE, 400 .n_voltages = ARRAY_SIZE(ldo_vintcore_voltages), 401 }, 402 .min_uV = 1100000, 403 .max_uV = 3300000, 404 .update_bank = 0x03, 405 .update_reg = 0x80, 406 .update_mask = 0x44, 407 .update_val_enable = 0x04, 408 .voltage_bank = 0x03, 409 .voltage_reg = 0x80, 410 .voltage_mask = 0x38, 411 .voltages = ldo_vintcore_voltages, 412 .voltages_len = ARRAY_SIZE(ldo_vintcore_voltages), 413 }, 414 415 /* 416 * Fixed Voltage Regulators 417 * name, fixed mV, 418 * update bank, reg, mask, enable val 419 */ 420 [AB8500_LDO_TVOUT] = { 421 .desc = { 422 .name = "LDO-TVOUT", 423 .ops = &ab8500_regulator_fixed_ops, 424 .type = REGULATOR_VOLTAGE, 425 .id = AB8500_LDO_TVOUT, 426 .owner = THIS_MODULE, 427 .n_voltages = 1, 428 }, 429 .fixed_uV = 2000000, 430 .update_bank = 0x03, 431 .update_reg = 0x80, 432 .update_mask = 0x82, 433 .update_val_enable = 0x02, 434 }, 435 [AB8500_LDO_AUDIO] = { 436 .desc = { 437 .name = "LDO-AUDIO", 438 .ops = &ab8500_regulator_fixed_ops, 439 .type = REGULATOR_VOLTAGE, 440 .id = AB8500_LDO_AUDIO, 441 .owner = THIS_MODULE, 442 .n_voltages = 1, 443 }, 444 .fixed_uV = 2000000, 445 .update_bank = 0x03, 446 .update_reg = 0x83, 447 .update_mask = 0x02, 448 .update_val_enable = 0x02, 449 }, 450 [AB8500_LDO_ANAMIC1] = { 451 .desc = { 452 .name = "LDO-ANAMIC1", 453 .ops = &ab8500_regulator_fixed_ops, 454 .type = REGULATOR_VOLTAGE, 455 .id = AB8500_LDO_ANAMIC1, 456 .owner = THIS_MODULE, 457 .n_voltages = 1, 458 }, 459 .fixed_uV = 2050000, 460 .update_bank = 0x03, 461 .update_reg = 0x83, 462 .update_mask = 0x08, 463 .update_val_enable = 0x08, 464 }, 465 [AB8500_LDO_ANAMIC2] = { 466 .desc = { 467 .name = "LDO-ANAMIC2", 468 .ops = &ab8500_regulator_fixed_ops, 469 .type = REGULATOR_VOLTAGE, 470 .id = AB8500_LDO_ANAMIC2, 471 .owner = THIS_MODULE, 472 .n_voltages = 1, 473 }, 474 .fixed_uV = 2050000, 475 .update_bank = 0x03, 476 .update_reg = 0x83, 477 .update_mask = 0x10, 478 .update_val_enable = 0x10, 479 }, 480 [AB8500_LDO_DMIC] = { 481 .desc = { 482 .name = "LDO-DMIC", 483 .ops = &ab8500_regulator_fixed_ops, 484 .type = REGULATOR_VOLTAGE, 485 .id = AB8500_LDO_DMIC, 486 .owner = THIS_MODULE, 487 .n_voltages = 1, 488 }, 489 .fixed_uV = 1800000, 490 .update_bank = 0x03, 491 .update_reg = 0x83, 492 .update_mask = 0x04, 493 .update_val_enable = 0x04, 494 }, 495 [AB8500_LDO_ANA] = { 496 .desc = { 497 .name = "LDO-ANA", 498 .ops = &ab8500_regulator_fixed_ops, 499 .type = REGULATOR_VOLTAGE, 500 .id = AB8500_LDO_ANA, 501 .owner = THIS_MODULE, 502 .n_voltages = 1, 503 }, 504 .fixed_uV = 1200000, 505 .update_bank = 0x04, 506 .update_reg = 0x06, 507 .update_mask = 0x0c, 508 .update_val_enable = 0x04, 509 }, 510 511 512 }; 513 514 static __devinit int ab8500_regulator_probe(struct platform_device *pdev) 515 { 516 struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent); 517 struct ab8500_platform_data *pdata; 518 int i, err; 519 520 if (!ab8500) { 521 dev_err(&pdev->dev, "null mfd parent\n"); 522 return -EINVAL; 523 } 524 pdata = dev_get_platdata(ab8500->dev); 525 if (!pdata) { 526 dev_err(&pdev->dev, "null pdata\n"); 527 return -EINVAL; 528 } 529 530 /* make sure the platform data has the correct size */ 531 if (pdata->num_regulator != ARRAY_SIZE(ab8500_regulator_info)) { 532 dev_err(&pdev->dev, "platform configuration error\n"); 533 return -EINVAL; 534 } 535 536 /* register all regulators */ 537 for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) { 538 struct ab8500_regulator_info *info = NULL; 539 540 /* assign per-regulator data */ 541 info = &ab8500_regulator_info[i]; 542 info->dev = &pdev->dev; 543 544 /* fix for hardware before ab8500v2.0 */ 545 if (abx500_get_chip_id(info->dev) < 0x20) { 546 if (info->desc.id == AB8500_LDO_AUX3) { 547 info->desc.n_voltages = 548 ARRAY_SIZE(ldo_vauxn_voltages); 549 info->voltages = ldo_vauxn_voltages; 550 info->voltages_len = 551 ARRAY_SIZE(ldo_vauxn_voltages); 552 info->voltage_mask = 0xf; 553 } 554 } 555 556 /* register regulator with framework */ 557 info->regulator = regulator_register(&info->desc, &pdev->dev, 558 &pdata->regulator[i], info); 559 if (IS_ERR(info->regulator)) { 560 err = PTR_ERR(info->regulator); 561 dev_err(&pdev->dev, "failed to register regulator %s\n", 562 info->desc.name); 563 /* when we fail, un-register all earlier regulators */ 564 while (--i >= 0) { 565 info = &ab8500_regulator_info[i]; 566 regulator_unregister(info->regulator); 567 } 568 return err; 569 } 570 571 dev_vdbg(rdev_get_dev(info->regulator), 572 "%s-probed\n", info->desc.name); 573 } 574 575 return 0; 576 } 577 578 static __devexit int ab8500_regulator_remove(struct platform_device *pdev) 579 { 580 int i; 581 582 for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) { 583 struct ab8500_regulator_info *info = NULL; 584 info = &ab8500_regulator_info[i]; 585 586 dev_vdbg(rdev_get_dev(info->regulator), 587 "%s-remove\n", info->desc.name); 588 589 regulator_unregister(info->regulator); 590 } 591 592 return 0; 593 } 594 595 static struct platform_driver ab8500_regulator_driver = { 596 .probe = ab8500_regulator_probe, 597 .remove = __devexit_p(ab8500_regulator_remove), 598 .driver = { 599 .name = "ab8500-regulator", 600 .owner = THIS_MODULE, 601 }, 602 }; 603 604 static int __init ab8500_regulator_init(void) 605 { 606 int ret; 607 608 ret = platform_driver_register(&ab8500_regulator_driver); 609 if (ret != 0) 610 pr_err("Failed to register ab8500 regulator: %d\n", ret); 611 612 return ret; 613 } 614 subsys_initcall(ab8500_regulator_init); 615 616 static void __exit ab8500_regulator_exit(void) 617 { 618 platform_driver_unregister(&ab8500_regulator_driver); 619 } 620 module_exit(ab8500_regulator_exit); 621 622 MODULE_LICENSE("GPL v2"); 623 MODULE_AUTHOR("Sundar Iyer <sundar.iyer@stericsson.com>"); 624 MODULE_DESCRIPTION("Regulator Driver for ST-Ericsson AB8500 Mixed-Sig PMIC"); 625 MODULE_ALIAS("platform:ab8500-regulator"); 626