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