1 /* 2 * max8998.c - Voltage regulator driver for the Maxim 8998 3 * 4 * Copyright (C) 2009-2010 Samsung Electronics 5 * Kyungmin Park <kyungmin.park@samsung.com> 6 * Marek Szyprowski <m.szyprowski@samsung.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 */ 22 23 #include <linux/module.h> 24 #include <linux/init.h> 25 #include <linux/i2c.h> 26 #include <linux/err.h> 27 #include <linux/gpio.h> 28 #include <linux/slab.h> 29 #include <linux/interrupt.h> 30 #include <linux/mutex.h> 31 #include <linux/delay.h> 32 #include <linux/platform_device.h> 33 #include <linux/regulator/driver.h> 34 #include <linux/mfd/max8998.h> 35 #include <linux/mfd/max8998-private.h> 36 37 struct max8998_data { 38 struct device *dev; 39 struct max8998_dev *iodev; 40 int num_regulators; 41 struct regulator_dev **rdev; 42 }; 43 44 struct voltage_map_desc { 45 int min; 46 int max; 47 int step; 48 }; 49 50 /* Voltage maps */ 51 static const struct voltage_map_desc ldo23_voltage_map_desc = { 52 .min = 800, .step = 50, .max = 1300, 53 }; 54 static const struct voltage_map_desc ldo456711_voltage_map_desc = { 55 .min = 1600, .step = 100, .max = 3600, 56 }; 57 static const struct voltage_map_desc ldo8_voltage_map_desc = { 58 .min = 3000, .step = 100, .max = 3600, 59 }; 60 static const struct voltage_map_desc ldo9_voltage_map_desc = { 61 .min = 2800, .step = 100, .max = 3100, 62 }; 63 static const struct voltage_map_desc ldo10_voltage_map_desc = { 64 .min = 950, .step = 50, .max = 1300, 65 }; 66 static const struct voltage_map_desc ldo1213_voltage_map_desc = { 67 .min = 800, .step = 100, .max = 3300, 68 }; 69 static const struct voltage_map_desc ldo1415_voltage_map_desc = { 70 .min = 1200, .step = 100, .max = 3300, 71 }; 72 static const struct voltage_map_desc ldo1617_voltage_map_desc = { 73 .min = 1600, .step = 100, .max = 3600, 74 }; 75 static const struct voltage_map_desc buck12_voltage_map_desc = { 76 .min = 750, .step = 25, .max = 1525, 77 }; 78 static const struct voltage_map_desc buck3_voltage_map_desc = { 79 .min = 1600, .step = 100, .max = 3600, 80 }; 81 static const struct voltage_map_desc buck4_voltage_map_desc = { 82 .min = 800, .step = 100, .max = 2300, 83 }; 84 85 static const struct voltage_map_desc *ldo_voltage_map[] = { 86 NULL, 87 NULL, 88 &ldo23_voltage_map_desc, /* LDO2 */ 89 &ldo23_voltage_map_desc, /* LDO3 */ 90 &ldo456711_voltage_map_desc, /* LDO4 */ 91 &ldo456711_voltage_map_desc, /* LDO5 */ 92 &ldo456711_voltage_map_desc, /* LDO6 */ 93 &ldo456711_voltage_map_desc, /* LDO7 */ 94 &ldo8_voltage_map_desc, /* LDO8 */ 95 &ldo9_voltage_map_desc, /* LDO9 */ 96 &ldo10_voltage_map_desc, /* LDO10 */ 97 &ldo456711_voltage_map_desc, /* LDO11 */ 98 &ldo1213_voltage_map_desc, /* LDO12 */ 99 &ldo1213_voltage_map_desc, /* LDO13 */ 100 &ldo1415_voltage_map_desc, /* LDO14 */ 101 &ldo1415_voltage_map_desc, /* LDO15 */ 102 &ldo1617_voltage_map_desc, /* LDO16 */ 103 &ldo1617_voltage_map_desc, /* LDO17 */ 104 &buck12_voltage_map_desc, /* BUCK1 */ 105 &buck12_voltage_map_desc, /* BUCK2 */ 106 &buck3_voltage_map_desc, /* BUCK3 */ 107 &buck4_voltage_map_desc, /* BUCK4 */ 108 }; 109 110 static inline int max8998_get_ldo(struct regulator_dev *rdev) 111 { 112 return rdev_get_id(rdev); 113 } 114 115 static int max8998_list_voltage(struct regulator_dev *rdev, 116 unsigned int selector) 117 { 118 const struct voltage_map_desc *desc; 119 int ldo = max8998_get_ldo(rdev); 120 int val; 121 122 if (ldo >= ARRAY_SIZE(ldo_voltage_map)) 123 return -EINVAL; 124 125 desc = ldo_voltage_map[ldo]; 126 if (desc == NULL) 127 return -EINVAL; 128 129 val = desc->min + desc->step * selector; 130 if (val > desc->max) 131 return -EINVAL; 132 133 return val * 1000; 134 } 135 136 static int max8998_get_enable_register(struct regulator_dev *rdev, 137 int *reg, int *shift) 138 { 139 int ldo = max8998_get_ldo(rdev); 140 141 switch (ldo) { 142 case MAX8998_LDO2 ... MAX8998_LDO5: 143 *reg = MAX8998_REG_ONOFF1; 144 *shift = 3 - (ldo - MAX8998_LDO2); 145 break; 146 case MAX8998_LDO6 ... MAX8998_LDO13: 147 *reg = MAX8998_REG_ONOFF2; 148 *shift = 7 - (ldo - MAX8998_LDO6); 149 break; 150 case MAX8998_LDO14 ... MAX8998_LDO17: 151 *reg = MAX8998_REG_ONOFF3; 152 *shift = 7 - (ldo - MAX8998_LDO14); 153 break; 154 case MAX8998_BUCK1 ... MAX8998_BUCK4: 155 *reg = MAX8998_REG_ONOFF1; 156 *shift = 7 - (ldo - MAX8998_BUCK1); 157 break; 158 case MAX8998_EN32KHZ_AP ... MAX8998_ENVICHG: 159 *reg = MAX8998_REG_ONOFF4; 160 *shift = 7 - (ldo - MAX8998_EN32KHZ_AP); 161 break; 162 case MAX8998_ESAFEOUT1 ... MAX8998_ESAFEOUT2: 163 *reg = MAX8998_REG_CHGR2; 164 *shift = 7 - (ldo - MAX8998_ESAFEOUT1); 165 break; 166 default: 167 return -EINVAL; 168 } 169 170 return 0; 171 } 172 173 static int max8998_ldo_is_enabled(struct regulator_dev *rdev) 174 { 175 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 176 int ret, reg, shift = 8; 177 u8 val; 178 179 ret = max8998_get_enable_register(rdev, ®, &shift); 180 if (ret) 181 return ret; 182 183 ret = max8998_read_reg(max8998->iodev, reg, &val); 184 if (ret) 185 return ret; 186 187 return val & (1 << shift); 188 } 189 190 static int max8998_ldo_enable(struct regulator_dev *rdev) 191 { 192 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 193 int reg, shift = 8, ret; 194 195 ret = max8998_get_enable_register(rdev, ®, &shift); 196 if (ret) 197 return ret; 198 199 return max8998_update_reg(max8998->iodev, reg, 1<<shift, 1<<shift); 200 } 201 202 static int max8998_ldo_disable(struct regulator_dev *rdev) 203 { 204 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 205 int reg, shift = 8, ret; 206 207 ret = max8998_get_enable_register(rdev, ®, &shift); 208 if (ret) 209 return ret; 210 211 return max8998_update_reg(max8998->iodev, reg, 0, 1<<shift); 212 } 213 214 static int max8998_get_voltage_register(struct regulator_dev *rdev, 215 int *_reg, int *_shift, int *_mask) 216 { 217 int ldo = max8998_get_ldo(rdev); 218 int reg, shift = 0, mask = 0xff; 219 220 switch (ldo) { 221 case MAX8998_LDO2 ... MAX8998_LDO3: 222 reg = MAX8998_REG_LDO2_LDO3; 223 mask = 0xf; 224 if (ldo == MAX8998_LDO2) 225 shift = 4; 226 else 227 shift = 0; 228 break; 229 case MAX8998_LDO4 ... MAX8998_LDO7: 230 reg = MAX8998_REG_LDO4 + (ldo - MAX8998_LDO4); 231 break; 232 case MAX8998_LDO8 ... MAX8998_LDO9: 233 reg = MAX8998_REG_LDO8_LDO9; 234 mask = 0xf; 235 if (ldo == MAX8998_LDO8) 236 shift = 4; 237 else 238 shift = 0; 239 break; 240 case MAX8998_LDO10 ... MAX8998_LDO11: 241 reg = MAX8998_REG_LDO10_LDO11; 242 if (ldo == MAX8998_LDO10) { 243 shift = 5; 244 mask = 0x7; 245 } else { 246 shift = 0; 247 mask = 0x1f; 248 } 249 break; 250 case MAX8998_LDO12 ... MAX8998_LDO17: 251 reg = MAX8998_REG_LDO12 + (ldo - MAX8998_LDO12); 252 break; 253 case MAX8998_BUCK1: 254 reg = MAX8998_REG_BUCK1_DVSARM1; 255 break; 256 case MAX8998_BUCK2: 257 reg = MAX8998_REG_BUCK2_DVSINT1; 258 break; 259 case MAX8998_BUCK3: 260 reg = MAX8998_REG_BUCK3; 261 break; 262 case MAX8998_BUCK4: 263 reg = MAX8998_REG_BUCK4; 264 break; 265 default: 266 return -EINVAL; 267 } 268 269 *_reg = reg; 270 *_shift = shift; 271 *_mask = mask; 272 273 return 0; 274 } 275 276 static int max8998_get_voltage(struct regulator_dev *rdev) 277 { 278 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 279 int reg, shift = 0, mask, ret; 280 u8 val; 281 282 ret = max8998_get_voltage_register(rdev, ®, &shift, &mask); 283 if (ret) 284 return ret; 285 286 ret = max8998_read_reg(max8998->iodev, reg, &val); 287 if (ret) 288 return ret; 289 290 val >>= shift; 291 val &= mask; 292 293 return max8998_list_voltage(rdev, val); 294 } 295 296 static int max8998_set_voltage(struct regulator_dev *rdev, 297 int min_uV, int max_uV) 298 { 299 struct max8998_data *max8998 = rdev_get_drvdata(rdev); 300 int min_vol = min_uV / 1000, max_vol = max_uV / 1000; 301 int previous_vol = 0; 302 const struct voltage_map_desc *desc; 303 int ldo = max8998_get_ldo(rdev); 304 int reg, shift = 0, mask, ret; 305 int i = 0; 306 u8 val; 307 bool en_ramp = false; 308 309 if (ldo >= ARRAY_SIZE(ldo_voltage_map)) 310 return -EINVAL; 311 312 desc = ldo_voltage_map[ldo]; 313 if (desc == NULL) 314 return -EINVAL; 315 316 if (max_vol < desc->min || min_vol > desc->max) 317 return -EINVAL; 318 319 while (desc->min + desc->step*i < min_vol && 320 desc->min + desc->step*i < desc->max) 321 i++; 322 323 if (desc->min + desc->step*i > max_vol) 324 return -EINVAL; 325 326 ret = max8998_get_voltage_register(rdev, ®, &shift, &mask); 327 if (ret) 328 return ret; 329 330 /* wait for RAMP_UP_DELAY if rdev is BUCK1/2 and 331 * ENRAMP is ON */ 332 if (ldo == MAX8998_BUCK1 || ldo == MAX8998_BUCK2) { 333 max8998_read_reg(max8998->iodev, MAX8998_REG_ONOFF4, &val); 334 if (val & (1 << 4)) { 335 en_ramp = true; 336 previous_vol = max8998_get_voltage(rdev); 337 } 338 } 339 340 ret = max8998_update_reg(max8998->iodev, reg, i<<shift, mask<<shift); 341 342 if (en_ramp == true) { 343 int difference = desc->min + desc->step*i - previous_vol/1000; 344 if (difference > 0) 345 udelay(difference / ((val & 0x0f) + 1)); 346 } 347 348 return ret; 349 } 350 351 static struct regulator_ops max8998_ldo_ops = { 352 .list_voltage = max8998_list_voltage, 353 .is_enabled = max8998_ldo_is_enabled, 354 .enable = max8998_ldo_enable, 355 .disable = max8998_ldo_disable, 356 .get_voltage = max8998_get_voltage, 357 .set_voltage = max8998_set_voltage, 358 .set_suspend_enable = max8998_ldo_enable, 359 .set_suspend_disable = max8998_ldo_disable, 360 }; 361 362 static struct regulator_ops max8998_buck_ops = { 363 .list_voltage = max8998_list_voltage, 364 .is_enabled = max8998_ldo_is_enabled, 365 .enable = max8998_ldo_enable, 366 .disable = max8998_ldo_disable, 367 .get_voltage = max8998_get_voltage, 368 .set_voltage = max8998_set_voltage, 369 .set_suspend_enable = max8998_ldo_enable, 370 .set_suspend_disable = max8998_ldo_disable, 371 }; 372 373 static struct regulator_ops max8998_others_ops = { 374 .is_enabled = max8998_ldo_is_enabled, 375 .enable = max8998_ldo_enable, 376 .disable = max8998_ldo_disable, 377 .set_suspend_enable = max8998_ldo_enable, 378 .set_suspend_disable = max8998_ldo_disable, 379 }; 380 381 static struct regulator_desc regulators[] = { 382 { 383 .name = "LDO2", 384 .id = MAX8998_LDO2, 385 .ops = &max8998_ldo_ops, 386 .type = REGULATOR_VOLTAGE, 387 .owner = THIS_MODULE, 388 }, { 389 .name = "LDO3", 390 .id = MAX8998_LDO3, 391 .ops = &max8998_ldo_ops, 392 .type = REGULATOR_VOLTAGE, 393 .owner = THIS_MODULE, 394 }, { 395 .name = "LDO4", 396 .id = MAX8998_LDO4, 397 .ops = &max8998_ldo_ops, 398 .type = REGULATOR_VOLTAGE, 399 .owner = THIS_MODULE, 400 }, { 401 .name = "LDO5", 402 .id = MAX8998_LDO5, 403 .ops = &max8998_ldo_ops, 404 .type = REGULATOR_VOLTAGE, 405 .owner = THIS_MODULE, 406 }, { 407 .name = "LDO6", 408 .id = MAX8998_LDO6, 409 .ops = &max8998_ldo_ops, 410 .type = REGULATOR_VOLTAGE, 411 .owner = THIS_MODULE, 412 }, { 413 .name = "LDO7", 414 .id = MAX8998_LDO7, 415 .ops = &max8998_ldo_ops, 416 .type = REGULATOR_VOLTAGE, 417 .owner = THIS_MODULE, 418 }, { 419 .name = "LDO8", 420 .id = MAX8998_LDO8, 421 .ops = &max8998_ldo_ops, 422 .type = REGULATOR_VOLTAGE, 423 .owner = THIS_MODULE, 424 }, { 425 .name = "LDO9", 426 .id = MAX8998_LDO9, 427 .ops = &max8998_ldo_ops, 428 .type = REGULATOR_VOLTAGE, 429 .owner = THIS_MODULE, 430 }, { 431 .name = "LDO10", 432 .id = MAX8998_LDO10, 433 .ops = &max8998_ldo_ops, 434 .type = REGULATOR_VOLTAGE, 435 .owner = THIS_MODULE, 436 }, { 437 .name = "LDO11", 438 .id = MAX8998_LDO11, 439 .ops = &max8998_ldo_ops, 440 .type = REGULATOR_VOLTAGE, 441 .owner = THIS_MODULE, 442 }, { 443 .name = "LDO12", 444 .id = MAX8998_LDO12, 445 .ops = &max8998_ldo_ops, 446 .type = REGULATOR_VOLTAGE, 447 .owner = THIS_MODULE, 448 }, { 449 .name = "LDO13", 450 .id = MAX8998_LDO13, 451 .ops = &max8998_ldo_ops, 452 .type = REGULATOR_VOLTAGE, 453 .owner = THIS_MODULE, 454 }, { 455 .name = "LDO14", 456 .id = MAX8998_LDO14, 457 .ops = &max8998_ldo_ops, 458 .type = REGULATOR_VOLTAGE, 459 .owner = THIS_MODULE, 460 }, { 461 .name = "LDO15", 462 .id = MAX8998_LDO15, 463 .ops = &max8998_ldo_ops, 464 .type = REGULATOR_VOLTAGE, 465 .owner = THIS_MODULE, 466 }, { 467 .name = "LDO16", 468 .id = MAX8998_LDO16, 469 .ops = &max8998_ldo_ops, 470 .type = REGULATOR_VOLTAGE, 471 .owner = THIS_MODULE, 472 }, { 473 .name = "LDO17", 474 .id = MAX8998_LDO17, 475 .ops = &max8998_ldo_ops, 476 .type = REGULATOR_VOLTAGE, 477 .owner = THIS_MODULE, 478 }, { 479 .name = "BUCK1", 480 .id = MAX8998_BUCK1, 481 .ops = &max8998_buck_ops, 482 .type = REGULATOR_VOLTAGE, 483 .owner = THIS_MODULE, 484 }, { 485 .name = "BUCK2", 486 .id = MAX8998_BUCK2, 487 .ops = &max8998_buck_ops, 488 .type = REGULATOR_VOLTAGE, 489 .owner = THIS_MODULE, 490 }, { 491 .name = "BUCK3", 492 .id = MAX8998_BUCK3, 493 .ops = &max8998_buck_ops, 494 .type = REGULATOR_VOLTAGE, 495 .owner = THIS_MODULE, 496 }, { 497 .name = "BUCK4", 498 .id = MAX8998_BUCK4, 499 .ops = &max8998_buck_ops, 500 .type = REGULATOR_VOLTAGE, 501 .owner = THIS_MODULE, 502 }, { 503 .name = "EN32KHz AP", 504 .id = MAX8998_EN32KHZ_AP, 505 .ops = &max8998_others_ops, 506 .type = REGULATOR_VOLTAGE, 507 .owner = THIS_MODULE, 508 }, { 509 .name = "EN32KHz CP", 510 .id = MAX8998_EN32KHZ_CP, 511 .ops = &max8998_others_ops, 512 .type = REGULATOR_VOLTAGE, 513 .owner = THIS_MODULE, 514 }, { 515 .name = "ENVICHG", 516 .id = MAX8998_ENVICHG, 517 .ops = &max8998_others_ops, 518 .type = REGULATOR_VOLTAGE, 519 .owner = THIS_MODULE, 520 }, { 521 .name = "ESAFEOUT1", 522 .id = MAX8998_ESAFEOUT1, 523 .ops = &max8998_others_ops, 524 .type = REGULATOR_VOLTAGE, 525 .owner = THIS_MODULE, 526 }, { 527 .name = "ESAFEOUT2", 528 .id = MAX8998_ESAFEOUT2, 529 .ops = &max8998_others_ops, 530 .type = REGULATOR_VOLTAGE, 531 .owner = THIS_MODULE, 532 } 533 }; 534 535 static __devinit int max8998_pmic_probe(struct platform_device *pdev) 536 { 537 struct max8998_dev *iodev = dev_get_drvdata(pdev->dev.parent); 538 struct max8998_platform_data *pdata = dev_get_platdata(iodev->dev); 539 struct regulator_dev **rdev; 540 struct max8998_data *max8998; 541 int i, ret, size; 542 543 if (!pdata) { 544 dev_err(pdev->dev.parent, "No platform init data supplied\n"); 545 return -ENODEV; 546 } 547 548 max8998 = kzalloc(sizeof(struct max8998_data), GFP_KERNEL); 549 if (!max8998) 550 return -ENOMEM; 551 552 size = sizeof(struct regulator_dev *) * (pdata->num_regulators + 1); 553 max8998->rdev = kzalloc(size, GFP_KERNEL); 554 if (!max8998->rdev) { 555 kfree(max8998); 556 return -ENOMEM; 557 } 558 559 rdev = max8998->rdev; 560 max8998->iodev = iodev; 561 platform_set_drvdata(pdev, max8998); 562 563 for (i = 0; i < pdata->num_regulators; i++) { 564 const struct voltage_map_desc *desc; 565 int id = pdata->regulators[i].id; 566 int index = id - MAX8998_LDO2; 567 568 desc = ldo_voltage_map[id]; 569 if (desc && regulators[index].ops != &max8998_others_ops) { 570 int count = (desc->max - desc->min) / desc->step + 1; 571 regulators[index].n_voltages = count; 572 } 573 rdev[i] = regulator_register(®ulators[index], max8998->dev, 574 pdata->regulators[i].initdata, max8998); 575 if (IS_ERR(rdev[i])) { 576 ret = PTR_ERR(rdev[i]); 577 dev_err(max8998->dev, "regulator init failed\n"); 578 rdev[i] = NULL; 579 goto err; 580 } 581 } 582 583 584 return 0; 585 err: 586 for (i = 0; i <= max8998->num_regulators; i++) 587 if (rdev[i]) 588 regulator_unregister(rdev[i]); 589 590 kfree(max8998->rdev); 591 kfree(max8998); 592 593 return ret; 594 } 595 596 static int __devexit max8998_pmic_remove(struct platform_device *pdev) 597 { 598 struct max8998_data *max8998 = platform_get_drvdata(pdev); 599 struct regulator_dev **rdev = max8998->rdev; 600 int i; 601 602 for (i = 0; i <= max8998->num_regulators; i++) 603 if (rdev[i]) 604 regulator_unregister(rdev[i]); 605 606 kfree(max8998->rdev); 607 kfree(max8998); 608 609 return 0; 610 } 611 612 static struct platform_driver max8998_pmic_driver = { 613 .driver = { 614 .name = "max8998-pmic", 615 .owner = THIS_MODULE, 616 }, 617 .probe = max8998_pmic_probe, 618 .remove = __devexit_p(max8998_pmic_remove), 619 }; 620 621 static int __init max8998_pmic_init(void) 622 { 623 return platform_driver_register(&max8998_pmic_driver); 624 } 625 subsys_initcall(max8998_pmic_init); 626 627 static void __exit max8998_pmic_cleanup(void) 628 { 629 platform_driver_unregister(&max8998_pmic_driver); 630 } 631 module_exit(max8998_pmic_cleanup); 632 633 MODULE_DESCRIPTION("MAXIM 8998 voltage regulator driver"); 634 MODULE_AUTHOR("Kyungmin Park <kyungmin.park@samsung.com>"); 635 MODULE_LICENSE("GPL"); 636