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