1 /* 2 * wm831x-ldo.c -- LDO driver for the WM831x series 3 * 4 * Copyright 2009 Wolfson Microelectronics PLC. 5 * 6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published by the 10 * Free Software Foundation; either version 2 of the License, or (at your 11 * option) any later version. 12 */ 13 14 #include <linux/module.h> 15 #include <linux/moduleparam.h> 16 #include <linux/init.h> 17 #include <linux/bitops.h> 18 #include <linux/err.h> 19 #include <linux/i2c.h> 20 #include <linux/platform_device.h> 21 #include <linux/regulator/driver.h> 22 #include <linux/slab.h> 23 24 #include <linux/mfd/wm831x/core.h> 25 #include <linux/mfd/wm831x/regulator.h> 26 #include <linux/mfd/wm831x/pdata.h> 27 28 #define WM831X_LDO_MAX_NAME 6 29 30 #define WM831X_LDO_CONTROL 0 31 #define WM831X_LDO_ON_CONTROL 1 32 #define WM831X_LDO_SLEEP_CONTROL 2 33 34 #define WM831X_ALIVE_LDO_ON_CONTROL 0 35 #define WM831X_ALIVE_LDO_SLEEP_CONTROL 1 36 37 struct wm831x_ldo { 38 char name[WM831X_LDO_MAX_NAME]; 39 struct regulator_desc desc; 40 int base; 41 struct wm831x *wm831x; 42 struct regulator_dev *regulator; 43 }; 44 45 /* 46 * Shared 47 */ 48 49 static int wm831x_ldo_is_enabled(struct regulator_dev *rdev) 50 { 51 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 52 struct wm831x *wm831x = ldo->wm831x; 53 int mask = 1 << rdev_get_id(rdev); 54 int reg; 55 56 reg = wm831x_reg_read(wm831x, WM831X_LDO_ENABLE); 57 if (reg < 0) 58 return reg; 59 60 if (reg & mask) 61 return 1; 62 else 63 return 0; 64 } 65 66 static int wm831x_ldo_enable(struct regulator_dev *rdev) 67 { 68 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 69 struct wm831x *wm831x = ldo->wm831x; 70 int mask = 1 << rdev_get_id(rdev); 71 72 return wm831x_set_bits(wm831x, WM831X_LDO_ENABLE, mask, mask); 73 } 74 75 static int wm831x_ldo_disable(struct regulator_dev *rdev) 76 { 77 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 78 struct wm831x *wm831x = ldo->wm831x; 79 int mask = 1 << rdev_get_id(rdev); 80 81 return wm831x_set_bits(wm831x, WM831X_LDO_ENABLE, mask, 0); 82 } 83 84 static irqreturn_t wm831x_ldo_uv_irq(int irq, void *data) 85 { 86 struct wm831x_ldo *ldo = data; 87 88 regulator_notifier_call_chain(ldo->regulator, 89 REGULATOR_EVENT_UNDER_VOLTAGE, 90 NULL); 91 92 return IRQ_HANDLED; 93 } 94 95 /* 96 * General purpose LDOs 97 */ 98 99 #define WM831X_GP_LDO_SELECTOR_LOW 0xe 100 #define WM831X_GP_LDO_MAX_SELECTOR 0x1f 101 102 static int wm831x_gp_ldo_list_voltage(struct regulator_dev *rdev, 103 unsigned int selector) 104 { 105 /* 0.9-1.6V in 50mV steps */ 106 if (selector <= WM831X_GP_LDO_SELECTOR_LOW) 107 return 900000 + (selector * 50000); 108 /* 1.7-3.3V in 50mV steps */ 109 if (selector <= WM831X_GP_LDO_MAX_SELECTOR) 110 return 1600000 + ((selector - WM831X_GP_LDO_SELECTOR_LOW) 111 * 100000); 112 return -EINVAL; 113 } 114 115 static int wm831x_gp_ldo_set_voltage_int(struct regulator_dev *rdev, int reg, 116 int min_uV, int max_uV, 117 unsigned *selector) 118 { 119 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 120 struct wm831x *wm831x = ldo->wm831x; 121 int vsel, ret; 122 123 if (min_uV < 900000) 124 vsel = 0; 125 else if (min_uV < 1700000) 126 vsel = ((min_uV - 900000) / 50000); 127 else 128 vsel = ((min_uV - 1700000) / 100000) 129 + WM831X_GP_LDO_SELECTOR_LOW + 1; 130 131 ret = wm831x_gp_ldo_list_voltage(rdev, vsel); 132 if (ret < 0) 133 return ret; 134 if (ret < min_uV || ret > max_uV) 135 return -EINVAL; 136 137 *selector = vsel; 138 139 return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, vsel); 140 } 141 142 static int wm831x_gp_ldo_set_voltage(struct regulator_dev *rdev, 143 int min_uV, int max_uV, 144 unsigned *selector) 145 { 146 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 147 int reg = ldo->base + WM831X_LDO_ON_CONTROL; 148 149 return wm831x_gp_ldo_set_voltage_int(rdev, reg, min_uV, max_uV, 150 selector); 151 } 152 153 static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev, 154 int uV) 155 { 156 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 157 int reg = ldo->base + WM831X_LDO_SLEEP_CONTROL; 158 unsigned int selector; 159 160 return wm831x_gp_ldo_set_voltage_int(rdev, reg, uV, uV, &selector); 161 } 162 163 static int wm831x_gp_ldo_get_voltage_sel(struct regulator_dev *rdev) 164 { 165 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 166 struct wm831x *wm831x = ldo->wm831x; 167 int reg = ldo->base + WM831X_LDO_ON_CONTROL; 168 int ret; 169 170 ret = wm831x_reg_read(wm831x, reg); 171 if (ret < 0) 172 return ret; 173 174 ret &= WM831X_LDO1_ON_VSEL_MASK; 175 176 return ret; 177 } 178 179 static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev) 180 { 181 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 182 struct wm831x *wm831x = ldo->wm831x; 183 int ctrl_reg = ldo->base + WM831X_LDO_CONTROL; 184 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL; 185 int ret; 186 187 ret = wm831x_reg_read(wm831x, on_reg); 188 if (ret < 0) 189 return ret; 190 191 if (!(ret & WM831X_LDO1_ON_MODE)) 192 return REGULATOR_MODE_NORMAL; 193 194 ret = wm831x_reg_read(wm831x, ctrl_reg); 195 if (ret < 0) 196 return ret; 197 198 if (ret & WM831X_LDO1_LP_MODE) 199 return REGULATOR_MODE_STANDBY; 200 else 201 return REGULATOR_MODE_IDLE; 202 } 203 204 static int wm831x_gp_ldo_set_mode(struct regulator_dev *rdev, 205 unsigned int mode) 206 { 207 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 208 struct wm831x *wm831x = ldo->wm831x; 209 int ctrl_reg = ldo->base + WM831X_LDO_CONTROL; 210 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL; 211 int ret; 212 213 214 switch (mode) { 215 case REGULATOR_MODE_NORMAL: 216 ret = wm831x_set_bits(wm831x, on_reg, 217 WM831X_LDO1_ON_MODE, 0); 218 if (ret < 0) 219 return ret; 220 break; 221 222 case REGULATOR_MODE_IDLE: 223 ret = wm831x_set_bits(wm831x, ctrl_reg, 224 WM831X_LDO1_LP_MODE, 0); 225 if (ret < 0) 226 return ret; 227 228 ret = wm831x_set_bits(wm831x, on_reg, 229 WM831X_LDO1_ON_MODE, 230 WM831X_LDO1_ON_MODE); 231 if (ret < 0) 232 return ret; 233 break; 234 235 case REGULATOR_MODE_STANDBY: 236 ret = wm831x_set_bits(wm831x, ctrl_reg, 237 WM831X_LDO1_LP_MODE, 238 WM831X_LDO1_LP_MODE); 239 if (ret < 0) 240 return ret; 241 242 ret = wm831x_set_bits(wm831x, on_reg, 243 WM831X_LDO1_ON_MODE, 244 WM831X_LDO1_ON_MODE); 245 if (ret < 0) 246 return ret; 247 break; 248 249 default: 250 return -EINVAL; 251 } 252 253 return 0; 254 } 255 256 static int wm831x_gp_ldo_get_status(struct regulator_dev *rdev) 257 { 258 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 259 struct wm831x *wm831x = ldo->wm831x; 260 int mask = 1 << rdev_get_id(rdev); 261 int ret; 262 263 /* Is the regulator on? */ 264 ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS); 265 if (ret < 0) 266 return ret; 267 if (!(ret & mask)) 268 return REGULATOR_STATUS_OFF; 269 270 /* Is it reporting under voltage? */ 271 ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS); 272 if (ret & mask) 273 return REGULATOR_STATUS_ERROR; 274 275 ret = wm831x_gp_ldo_get_mode(rdev); 276 if (ret < 0) 277 return ret; 278 else 279 return regulator_mode_to_status(ret); 280 } 281 282 static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev, 283 int input_uV, 284 int output_uV, int load_uA) 285 { 286 if (load_uA < 20000) 287 return REGULATOR_MODE_STANDBY; 288 if (load_uA < 50000) 289 return REGULATOR_MODE_IDLE; 290 return REGULATOR_MODE_NORMAL; 291 } 292 293 294 static struct regulator_ops wm831x_gp_ldo_ops = { 295 .list_voltage = wm831x_gp_ldo_list_voltage, 296 .get_voltage_sel = wm831x_gp_ldo_get_voltage_sel, 297 .set_voltage = wm831x_gp_ldo_set_voltage, 298 .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage, 299 .get_mode = wm831x_gp_ldo_get_mode, 300 .set_mode = wm831x_gp_ldo_set_mode, 301 .get_status = wm831x_gp_ldo_get_status, 302 .get_optimum_mode = wm831x_gp_ldo_get_optimum_mode, 303 304 .is_enabled = wm831x_ldo_is_enabled, 305 .enable = wm831x_ldo_enable, 306 .disable = wm831x_ldo_disable, 307 }; 308 309 static __devinit int wm831x_gp_ldo_probe(struct platform_device *pdev) 310 { 311 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 312 struct wm831x_pdata *pdata = wm831x->dev->platform_data; 313 int id; 314 struct wm831x_ldo *ldo; 315 struct resource *res; 316 int ret, irq; 317 318 if (pdata && pdata->wm831x_num) 319 id = (pdata->wm831x_num * 10) + 1; 320 else 321 id = 0; 322 id = pdev->id - id; 323 324 dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1); 325 326 if (pdata == NULL || pdata->ldo[id] == NULL) 327 return -ENODEV; 328 329 ldo = kzalloc(sizeof(struct wm831x_ldo), GFP_KERNEL); 330 if (ldo == NULL) { 331 dev_err(&pdev->dev, "Unable to allocate private data\n"); 332 return -ENOMEM; 333 } 334 335 ldo->wm831x = wm831x; 336 337 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 338 if (res == NULL) { 339 dev_err(&pdev->dev, "No I/O resource\n"); 340 ret = -EINVAL; 341 goto err; 342 } 343 ldo->base = res->start; 344 345 snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1); 346 ldo->desc.name = ldo->name; 347 ldo->desc.id = id; 348 ldo->desc.type = REGULATOR_VOLTAGE; 349 ldo->desc.n_voltages = WM831X_GP_LDO_MAX_SELECTOR + 1; 350 ldo->desc.ops = &wm831x_gp_ldo_ops; 351 ldo->desc.owner = THIS_MODULE; 352 353 ldo->regulator = regulator_register(&ldo->desc, &pdev->dev, 354 pdata->ldo[id], ldo); 355 if (IS_ERR(ldo->regulator)) { 356 ret = PTR_ERR(ldo->regulator); 357 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n", 358 id + 1, ret); 359 goto err; 360 } 361 362 irq = platform_get_irq_byname(pdev, "UV"); 363 ret = request_threaded_irq(irq, NULL, wm831x_ldo_uv_irq, 364 IRQF_TRIGGER_RISING, ldo->name, 365 ldo); 366 if (ret != 0) { 367 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", 368 irq, ret); 369 goto err_regulator; 370 } 371 372 platform_set_drvdata(pdev, ldo); 373 374 return 0; 375 376 err_regulator: 377 regulator_unregister(ldo->regulator); 378 err: 379 kfree(ldo); 380 return ret; 381 } 382 383 static __devexit int wm831x_gp_ldo_remove(struct platform_device *pdev) 384 { 385 struct wm831x_ldo *ldo = platform_get_drvdata(pdev); 386 387 platform_set_drvdata(pdev, NULL); 388 389 free_irq(platform_get_irq_byname(pdev, "UV"), ldo); 390 regulator_unregister(ldo->regulator); 391 kfree(ldo); 392 393 return 0; 394 } 395 396 static struct platform_driver wm831x_gp_ldo_driver = { 397 .probe = wm831x_gp_ldo_probe, 398 .remove = __devexit_p(wm831x_gp_ldo_remove), 399 .driver = { 400 .name = "wm831x-ldo", 401 .owner = THIS_MODULE, 402 }, 403 }; 404 405 /* 406 * Analogue LDOs 407 */ 408 409 410 #define WM831X_ALDO_SELECTOR_LOW 0xc 411 #define WM831X_ALDO_MAX_SELECTOR 0x1f 412 413 static int wm831x_aldo_list_voltage(struct regulator_dev *rdev, 414 unsigned int selector) 415 { 416 /* 1-1.6V in 50mV steps */ 417 if (selector <= WM831X_ALDO_SELECTOR_LOW) 418 return 1000000 + (selector * 50000); 419 /* 1.7-3.5V in 50mV steps */ 420 if (selector <= WM831X_ALDO_MAX_SELECTOR) 421 return 1600000 + ((selector - WM831X_ALDO_SELECTOR_LOW) 422 * 100000); 423 return -EINVAL; 424 } 425 426 static int wm831x_aldo_set_voltage_int(struct regulator_dev *rdev, int reg, 427 int min_uV, int max_uV, 428 unsigned *selector) 429 { 430 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 431 struct wm831x *wm831x = ldo->wm831x; 432 int vsel, ret; 433 434 if (min_uV < 1000000) 435 vsel = 0; 436 else if (min_uV < 1700000) 437 vsel = ((min_uV - 1000000) / 50000); 438 else 439 vsel = ((min_uV - 1700000) / 100000) 440 + WM831X_ALDO_SELECTOR_LOW + 1; 441 442 ret = wm831x_aldo_list_voltage(rdev, vsel); 443 if (ret < 0) 444 return ret; 445 if (ret < min_uV || ret > max_uV) 446 return -EINVAL; 447 448 *selector = vsel; 449 450 return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, vsel); 451 } 452 453 static int wm831x_aldo_set_voltage(struct regulator_dev *rdev, 454 int min_uV, int max_uV, unsigned *selector) 455 { 456 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 457 int reg = ldo->base + WM831X_LDO_ON_CONTROL; 458 459 return wm831x_aldo_set_voltage_int(rdev, reg, min_uV, max_uV, 460 selector); 461 } 462 463 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev, 464 int uV) 465 { 466 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 467 int reg = ldo->base + WM831X_LDO_SLEEP_CONTROL; 468 unsigned int selector; 469 470 return wm831x_aldo_set_voltage_int(rdev, reg, uV, uV, &selector); 471 } 472 473 static int wm831x_aldo_get_voltage_sel(struct regulator_dev *rdev) 474 { 475 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 476 struct wm831x *wm831x = ldo->wm831x; 477 int reg = ldo->base + WM831X_LDO_ON_CONTROL; 478 int ret; 479 480 ret = wm831x_reg_read(wm831x, reg); 481 if (ret < 0) 482 return ret; 483 484 ret &= WM831X_LDO7_ON_VSEL_MASK; 485 486 return ret; 487 } 488 489 static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev) 490 { 491 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 492 struct wm831x *wm831x = ldo->wm831x; 493 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL; 494 int ret; 495 496 ret = wm831x_reg_read(wm831x, on_reg); 497 if (ret < 0) 498 return 0; 499 500 if (ret & WM831X_LDO7_ON_MODE) 501 return REGULATOR_MODE_IDLE; 502 else 503 return REGULATOR_MODE_NORMAL; 504 } 505 506 static int wm831x_aldo_set_mode(struct regulator_dev *rdev, 507 unsigned int mode) 508 { 509 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 510 struct wm831x *wm831x = ldo->wm831x; 511 int ctrl_reg = ldo->base + WM831X_LDO_CONTROL; 512 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL; 513 int ret; 514 515 516 switch (mode) { 517 case REGULATOR_MODE_NORMAL: 518 ret = wm831x_set_bits(wm831x, on_reg, 519 WM831X_LDO7_ON_MODE, 0); 520 if (ret < 0) 521 return ret; 522 break; 523 524 case REGULATOR_MODE_IDLE: 525 ret = wm831x_set_bits(wm831x, ctrl_reg, 526 WM831X_LDO7_ON_MODE, 527 WM831X_LDO7_ON_MODE); 528 if (ret < 0) 529 return ret; 530 break; 531 532 default: 533 return -EINVAL; 534 } 535 536 return 0; 537 } 538 539 static int wm831x_aldo_get_status(struct regulator_dev *rdev) 540 { 541 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 542 struct wm831x *wm831x = ldo->wm831x; 543 int mask = 1 << rdev_get_id(rdev); 544 int ret; 545 546 /* Is the regulator on? */ 547 ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS); 548 if (ret < 0) 549 return ret; 550 if (!(ret & mask)) 551 return REGULATOR_STATUS_OFF; 552 553 /* Is it reporting under voltage? */ 554 ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS); 555 if (ret & mask) 556 return REGULATOR_STATUS_ERROR; 557 558 ret = wm831x_aldo_get_mode(rdev); 559 if (ret < 0) 560 return ret; 561 else 562 return regulator_mode_to_status(ret); 563 } 564 565 static struct regulator_ops wm831x_aldo_ops = { 566 .list_voltage = wm831x_aldo_list_voltage, 567 .get_voltage_sel = wm831x_aldo_get_voltage_sel, 568 .set_voltage = wm831x_aldo_set_voltage, 569 .set_suspend_voltage = wm831x_aldo_set_suspend_voltage, 570 .get_mode = wm831x_aldo_get_mode, 571 .set_mode = wm831x_aldo_set_mode, 572 .get_status = wm831x_aldo_get_status, 573 574 .is_enabled = wm831x_ldo_is_enabled, 575 .enable = wm831x_ldo_enable, 576 .disable = wm831x_ldo_disable, 577 }; 578 579 static __devinit int wm831x_aldo_probe(struct platform_device *pdev) 580 { 581 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 582 struct wm831x_pdata *pdata = wm831x->dev->platform_data; 583 int id; 584 struct wm831x_ldo *ldo; 585 struct resource *res; 586 int ret, irq; 587 588 if (pdata && pdata->wm831x_num) 589 id = (pdata->wm831x_num * 10) + 1; 590 else 591 id = 0; 592 id = pdev->id - id; 593 594 dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1); 595 596 if (pdata == NULL || pdata->ldo[id] == NULL) 597 return -ENODEV; 598 599 ldo = kzalloc(sizeof(struct wm831x_ldo), GFP_KERNEL); 600 if (ldo == NULL) { 601 dev_err(&pdev->dev, "Unable to allocate private data\n"); 602 return -ENOMEM; 603 } 604 605 ldo->wm831x = wm831x; 606 607 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 608 if (res == NULL) { 609 dev_err(&pdev->dev, "No I/O resource\n"); 610 ret = -EINVAL; 611 goto err; 612 } 613 ldo->base = res->start; 614 615 snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1); 616 ldo->desc.name = ldo->name; 617 ldo->desc.id = id; 618 ldo->desc.type = REGULATOR_VOLTAGE; 619 ldo->desc.n_voltages = WM831X_ALDO_MAX_SELECTOR + 1; 620 ldo->desc.ops = &wm831x_aldo_ops; 621 ldo->desc.owner = THIS_MODULE; 622 623 ldo->regulator = regulator_register(&ldo->desc, &pdev->dev, 624 pdata->ldo[id], ldo); 625 if (IS_ERR(ldo->regulator)) { 626 ret = PTR_ERR(ldo->regulator); 627 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n", 628 id + 1, ret); 629 goto err; 630 } 631 632 irq = platform_get_irq_byname(pdev, "UV"); 633 ret = request_threaded_irq(irq, NULL, wm831x_ldo_uv_irq, 634 IRQF_TRIGGER_RISING, ldo->name, ldo); 635 if (ret != 0) { 636 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", 637 irq, ret); 638 goto err_regulator; 639 } 640 641 platform_set_drvdata(pdev, ldo); 642 643 return 0; 644 645 err_regulator: 646 regulator_unregister(ldo->regulator); 647 err: 648 kfree(ldo); 649 return ret; 650 } 651 652 static __devexit int wm831x_aldo_remove(struct platform_device *pdev) 653 { 654 struct wm831x_ldo *ldo = platform_get_drvdata(pdev); 655 656 free_irq(platform_get_irq_byname(pdev, "UV"), ldo); 657 regulator_unregister(ldo->regulator); 658 kfree(ldo); 659 660 return 0; 661 } 662 663 static struct platform_driver wm831x_aldo_driver = { 664 .probe = wm831x_aldo_probe, 665 .remove = __devexit_p(wm831x_aldo_remove), 666 .driver = { 667 .name = "wm831x-aldo", 668 .owner = THIS_MODULE, 669 }, 670 }; 671 672 /* 673 * Alive LDO 674 */ 675 676 #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf 677 678 static int wm831x_alive_ldo_list_voltage(struct regulator_dev *rdev, 679 unsigned int selector) 680 { 681 /* 0.8-1.55V in 50mV steps */ 682 if (selector <= WM831X_ALIVE_LDO_MAX_SELECTOR) 683 return 800000 + (selector * 50000); 684 return -EINVAL; 685 } 686 687 static int wm831x_alive_ldo_set_voltage_int(struct regulator_dev *rdev, 688 int reg, 689 int min_uV, int max_uV, 690 unsigned *selector) 691 { 692 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 693 struct wm831x *wm831x = ldo->wm831x; 694 int vsel, ret; 695 696 vsel = (min_uV - 800000) / 50000; 697 698 ret = wm831x_alive_ldo_list_voltage(rdev, vsel); 699 if (ret < 0) 700 return ret; 701 if (ret < min_uV || ret > max_uV) 702 return -EINVAL; 703 704 *selector = vsel; 705 706 return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, vsel); 707 } 708 709 static int wm831x_alive_ldo_set_voltage(struct regulator_dev *rdev, 710 int min_uV, int max_uV, 711 unsigned *selector) 712 { 713 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 714 int reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL; 715 716 return wm831x_alive_ldo_set_voltage_int(rdev, reg, min_uV, max_uV, 717 selector); 718 } 719 720 static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev, 721 int uV) 722 { 723 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 724 int reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL; 725 unsigned selector; 726 727 return wm831x_alive_ldo_set_voltage_int(rdev, reg, uV, uV, &selector); 728 } 729 730 static int wm831x_alive_ldo_get_voltage_sel(struct regulator_dev *rdev) 731 { 732 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 733 struct wm831x *wm831x = ldo->wm831x; 734 int reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL; 735 int ret; 736 737 ret = wm831x_reg_read(wm831x, reg); 738 if (ret < 0) 739 return ret; 740 741 ret &= WM831X_LDO11_ON_VSEL_MASK; 742 743 return ret; 744 } 745 746 static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev) 747 { 748 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 749 struct wm831x *wm831x = ldo->wm831x; 750 int mask = 1 << rdev_get_id(rdev); 751 int ret; 752 753 /* Is the regulator on? */ 754 ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS); 755 if (ret < 0) 756 return ret; 757 if (ret & mask) 758 return REGULATOR_STATUS_ON; 759 else 760 return REGULATOR_STATUS_OFF; 761 } 762 763 static struct regulator_ops wm831x_alive_ldo_ops = { 764 .list_voltage = wm831x_alive_ldo_list_voltage, 765 .get_voltage_sel = wm831x_alive_ldo_get_voltage_sel, 766 .set_voltage = wm831x_alive_ldo_set_voltage, 767 .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage, 768 .get_status = wm831x_alive_ldo_get_status, 769 770 .is_enabled = wm831x_ldo_is_enabled, 771 .enable = wm831x_ldo_enable, 772 .disable = wm831x_ldo_disable, 773 }; 774 775 static __devinit int wm831x_alive_ldo_probe(struct platform_device *pdev) 776 { 777 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 778 struct wm831x_pdata *pdata = wm831x->dev->platform_data; 779 int id; 780 struct wm831x_ldo *ldo; 781 struct resource *res; 782 int ret; 783 784 if (pdata && pdata->wm831x_num) 785 id = (pdata->wm831x_num * 10) + 1; 786 else 787 id = 0; 788 id = pdev->id - id; 789 790 791 dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1); 792 793 if (pdata == NULL || pdata->ldo[id] == NULL) 794 return -ENODEV; 795 796 ldo = kzalloc(sizeof(struct wm831x_ldo), GFP_KERNEL); 797 if (ldo == NULL) { 798 dev_err(&pdev->dev, "Unable to allocate private data\n"); 799 return -ENOMEM; 800 } 801 802 ldo->wm831x = wm831x; 803 804 res = platform_get_resource(pdev, IORESOURCE_IO, 0); 805 if (res == NULL) { 806 dev_err(&pdev->dev, "No I/O resource\n"); 807 ret = -EINVAL; 808 goto err; 809 } 810 ldo->base = res->start; 811 812 snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1); 813 ldo->desc.name = ldo->name; 814 ldo->desc.id = id; 815 ldo->desc.type = REGULATOR_VOLTAGE; 816 ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1; 817 ldo->desc.ops = &wm831x_alive_ldo_ops; 818 ldo->desc.owner = THIS_MODULE; 819 820 ldo->regulator = regulator_register(&ldo->desc, &pdev->dev, 821 pdata->ldo[id], ldo); 822 if (IS_ERR(ldo->regulator)) { 823 ret = PTR_ERR(ldo->regulator); 824 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n", 825 id + 1, ret); 826 goto err; 827 } 828 829 platform_set_drvdata(pdev, ldo); 830 831 return 0; 832 833 err: 834 kfree(ldo); 835 return ret; 836 } 837 838 static __devexit int wm831x_alive_ldo_remove(struct platform_device *pdev) 839 { 840 struct wm831x_ldo *ldo = platform_get_drvdata(pdev); 841 842 regulator_unregister(ldo->regulator); 843 kfree(ldo); 844 845 return 0; 846 } 847 848 static struct platform_driver wm831x_alive_ldo_driver = { 849 .probe = wm831x_alive_ldo_probe, 850 .remove = __devexit_p(wm831x_alive_ldo_remove), 851 .driver = { 852 .name = "wm831x-alive-ldo", 853 .owner = THIS_MODULE, 854 }, 855 }; 856 857 static int __init wm831x_ldo_init(void) 858 { 859 int ret; 860 861 ret = platform_driver_register(&wm831x_gp_ldo_driver); 862 if (ret != 0) 863 pr_err("Failed to register WM831x GP LDO driver: %d\n", ret); 864 865 ret = platform_driver_register(&wm831x_aldo_driver); 866 if (ret != 0) 867 pr_err("Failed to register WM831x ALDO driver: %d\n", ret); 868 869 ret = platform_driver_register(&wm831x_alive_ldo_driver); 870 if (ret != 0) 871 pr_err("Failed to register WM831x alive LDO driver: %d\n", 872 ret); 873 874 return 0; 875 } 876 subsys_initcall(wm831x_ldo_init); 877 878 static void __exit wm831x_ldo_exit(void) 879 { 880 platform_driver_unregister(&wm831x_alive_ldo_driver); 881 platform_driver_unregister(&wm831x_aldo_driver); 882 platform_driver_unregister(&wm831x_gp_ldo_driver); 883 } 884 module_exit(wm831x_ldo_exit); 885 886 /* Module information */ 887 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 888 MODULE_DESCRIPTION("WM831x LDO driver"); 889 MODULE_LICENSE("GPL"); 890 MODULE_ALIAS("platform:wm831x-ldo"); 891 MODULE_ALIAS("platform:wm831x-aldo"); 892 MODULE_ALIAS("platform:wm831x-aliveldo"); 893