/drivers/regulator/wm831x-ldo.c
C | 677 lines | 534 code | 118 blank | 25 comment | 57 complexity | 5a434b53b729be31867d72708abac82d MD5 | raw file
1// SPDX-License-Identifier: GPL-2.0+ 2// 3// wm831x-ldo.c -- LDO driver for the WM831x series 4// 5// Copyright 2009 Wolfson Microelectronics PLC. 6// 7// Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 8 9#include <linux/module.h> 10#include <linux/moduleparam.h> 11#include <linux/init.h> 12#include <linux/bitops.h> 13#include <linux/err.h> 14#include <linux/i2c.h> 15#include <linux/platform_device.h> 16#include <linux/regulator/driver.h> 17#include <linux/slab.h> 18 19#include <linux/mfd/wm831x/core.h> 20#include <linux/mfd/wm831x/regulator.h> 21#include <linux/mfd/wm831x/pdata.h> 22 23#define WM831X_LDO_MAX_NAME 9 24 25#define WM831X_LDO_CONTROL 0 26#define WM831X_LDO_ON_CONTROL 1 27#define WM831X_LDO_SLEEP_CONTROL 2 28 29#define WM831X_ALIVE_LDO_ON_CONTROL 0 30#define WM831X_ALIVE_LDO_SLEEP_CONTROL 1 31 32struct wm831x_ldo { 33 char name[WM831X_LDO_MAX_NAME]; 34 char supply_name[WM831X_LDO_MAX_NAME]; 35 struct regulator_desc desc; 36 int base; 37 struct wm831x *wm831x; 38 struct regulator_dev *regulator; 39}; 40 41/* 42 * Shared 43 */ 44 45static irqreturn_t wm831x_ldo_uv_irq(int irq, void *data) 46{ 47 struct wm831x_ldo *ldo = data; 48 49 regulator_lock(ldo->regulator); 50 regulator_notifier_call_chain(ldo->regulator, 51 REGULATOR_EVENT_UNDER_VOLTAGE, 52 NULL); 53 regulator_unlock(ldo->regulator); 54 55 return IRQ_HANDLED; 56} 57 58/* 59 * General purpose LDOs 60 */ 61 62static const struct regulator_linear_range wm831x_gp_ldo_ranges[] = { 63 REGULATOR_LINEAR_RANGE(900000, 0, 14, 50000), 64 REGULATOR_LINEAR_RANGE(1700000, 15, 31, 100000), 65}; 66 67static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev, 68 int uV) 69{ 70 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 71 struct wm831x *wm831x = ldo->wm831x; 72 int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL; 73 74 sel = regulator_map_voltage_linear_range(rdev, uV, uV); 75 if (sel < 0) 76 return sel; 77 78 return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, sel); 79} 80 81static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev) 82{ 83 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 84 struct wm831x *wm831x = ldo->wm831x; 85 int ctrl_reg = ldo->base + WM831X_LDO_CONTROL; 86 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL; 87 int ret; 88 89 ret = wm831x_reg_read(wm831x, on_reg); 90 if (ret < 0) 91 return ret; 92 93 if (!(ret & WM831X_LDO1_ON_MODE)) 94 return REGULATOR_MODE_NORMAL; 95 96 ret = wm831x_reg_read(wm831x, ctrl_reg); 97 if (ret < 0) 98 return ret; 99 100 if (ret & WM831X_LDO1_LP_MODE) 101 return REGULATOR_MODE_STANDBY; 102 else 103 return REGULATOR_MODE_IDLE; 104} 105 106static int wm831x_gp_ldo_set_mode(struct regulator_dev *rdev, 107 unsigned int mode) 108{ 109 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 110 struct wm831x *wm831x = ldo->wm831x; 111 int ctrl_reg = ldo->base + WM831X_LDO_CONTROL; 112 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL; 113 int ret; 114 115 116 switch (mode) { 117 case REGULATOR_MODE_NORMAL: 118 ret = wm831x_set_bits(wm831x, on_reg, 119 WM831X_LDO1_ON_MODE, 0); 120 if (ret < 0) 121 return ret; 122 break; 123 124 case REGULATOR_MODE_IDLE: 125 ret = wm831x_set_bits(wm831x, ctrl_reg, 126 WM831X_LDO1_LP_MODE, 0); 127 if (ret < 0) 128 return ret; 129 130 ret = wm831x_set_bits(wm831x, on_reg, 131 WM831X_LDO1_ON_MODE, 132 WM831X_LDO1_ON_MODE); 133 if (ret < 0) 134 return ret; 135 break; 136 137 case REGULATOR_MODE_STANDBY: 138 ret = wm831x_set_bits(wm831x, ctrl_reg, 139 WM831X_LDO1_LP_MODE, 140 WM831X_LDO1_LP_MODE); 141 if (ret < 0) 142 return ret; 143 144 ret = wm831x_set_bits(wm831x, on_reg, 145 WM831X_LDO1_ON_MODE, 146 WM831X_LDO1_ON_MODE); 147 if (ret < 0) 148 return ret; 149 break; 150 151 default: 152 return -EINVAL; 153 } 154 155 return 0; 156} 157 158static int wm831x_gp_ldo_get_status(struct regulator_dev *rdev) 159{ 160 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 161 struct wm831x *wm831x = ldo->wm831x; 162 int mask = 1 << rdev_get_id(rdev); 163 int ret; 164 165 /* Is the regulator on? */ 166 ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS); 167 if (ret < 0) 168 return ret; 169 if (!(ret & mask)) 170 return REGULATOR_STATUS_OFF; 171 172 /* Is it reporting under voltage? */ 173 ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS); 174 if (ret < 0) 175 return ret; 176 if (ret & mask) 177 return REGULATOR_STATUS_ERROR; 178 179 ret = wm831x_gp_ldo_get_mode(rdev); 180 if (ret < 0) 181 return ret; 182 else 183 return regulator_mode_to_status(ret); 184} 185 186static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev, 187 int input_uV, 188 int output_uV, int load_uA) 189{ 190 if (load_uA < 20000) 191 return REGULATOR_MODE_STANDBY; 192 if (load_uA < 50000) 193 return REGULATOR_MODE_IDLE; 194 return REGULATOR_MODE_NORMAL; 195} 196 197 198static const struct regulator_ops wm831x_gp_ldo_ops = { 199 .list_voltage = regulator_list_voltage_linear_range, 200 .map_voltage = regulator_map_voltage_linear_range, 201 .get_voltage_sel = regulator_get_voltage_sel_regmap, 202 .set_voltage_sel = regulator_set_voltage_sel_regmap, 203 .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage, 204 .get_mode = wm831x_gp_ldo_get_mode, 205 .set_mode = wm831x_gp_ldo_set_mode, 206 .get_status = wm831x_gp_ldo_get_status, 207 .get_optimum_mode = wm831x_gp_ldo_get_optimum_mode, 208 .get_bypass = regulator_get_bypass_regmap, 209 .set_bypass = regulator_set_bypass_regmap, 210 211 .is_enabled = regulator_is_enabled_regmap, 212 .enable = regulator_enable_regmap, 213 .disable = regulator_disable_regmap, 214}; 215 216static int wm831x_gp_ldo_probe(struct platform_device *pdev) 217{ 218 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 219 struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev); 220 struct regulator_config config = { }; 221 int id; 222 struct wm831x_ldo *ldo; 223 struct resource *res; 224 int ret, irq; 225 226 if (pdata && pdata->wm831x_num) 227 id = (pdata->wm831x_num * 10) + 1; 228 else 229 id = 0; 230 id = pdev->id - id; 231 232 dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1); 233 234 ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL); 235 if (!ldo) 236 return -ENOMEM; 237 238 ldo->wm831x = wm831x; 239 240 res = platform_get_resource(pdev, IORESOURCE_REG, 0); 241 if (res == NULL) { 242 dev_err(&pdev->dev, "No REG resource\n"); 243 ret = -EINVAL; 244 goto err; 245 } 246 ldo->base = res->start; 247 248 snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1); 249 ldo->desc.name = ldo->name; 250 251 snprintf(ldo->supply_name, sizeof(ldo->supply_name), 252 "LDO%dVDD", id + 1); 253 ldo->desc.supply_name = ldo->supply_name; 254 255 ldo->desc.id = id; 256 ldo->desc.type = REGULATOR_VOLTAGE; 257 ldo->desc.n_voltages = 32; 258 ldo->desc.ops = &wm831x_gp_ldo_ops; 259 ldo->desc.owner = THIS_MODULE; 260 ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL; 261 ldo->desc.vsel_mask = WM831X_LDO1_ON_VSEL_MASK; 262 ldo->desc.enable_reg = WM831X_LDO_ENABLE; 263 ldo->desc.enable_mask = 1 << id; 264 ldo->desc.bypass_reg = ldo->base; 265 ldo->desc.bypass_mask = WM831X_LDO1_SWI; 266 ldo->desc.linear_ranges = wm831x_gp_ldo_ranges; 267 ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_gp_ldo_ranges); 268 269 config.dev = pdev->dev.parent; 270 if (pdata) 271 config.init_data = pdata->ldo[id]; 272 config.driver_data = ldo; 273 config.regmap = wm831x->regmap; 274 275 ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc, 276 &config); 277 if (IS_ERR(ldo->regulator)) { 278 ret = PTR_ERR(ldo->regulator); 279 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n", 280 id + 1, ret); 281 goto err; 282 } 283 284 irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV")); 285 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 286 wm831x_ldo_uv_irq, 287 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 288 ldo->name, 289 ldo); 290 if (ret != 0) { 291 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", 292 irq, ret); 293 goto err; 294 } 295 296 platform_set_drvdata(pdev, ldo); 297 298 return 0; 299 300err: 301 return ret; 302} 303 304static struct platform_driver wm831x_gp_ldo_driver = { 305 .probe = wm831x_gp_ldo_probe, 306 .driver = { 307 .name = "wm831x-ldo", 308 }, 309}; 310 311/* 312 * Analogue LDOs 313 */ 314 315static const struct regulator_linear_range wm831x_aldo_ranges[] = { 316 REGULATOR_LINEAR_RANGE(1000000, 0, 12, 50000), 317 REGULATOR_LINEAR_RANGE(1700000, 13, 31, 100000), 318}; 319 320static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev, 321 int uV) 322{ 323 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 324 struct wm831x *wm831x = ldo->wm831x; 325 int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL; 326 327 sel = regulator_map_voltage_linear_range(rdev, uV, uV); 328 if (sel < 0) 329 return sel; 330 331 return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, sel); 332} 333 334static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev) 335{ 336 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 337 struct wm831x *wm831x = ldo->wm831x; 338 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL; 339 int ret; 340 341 ret = wm831x_reg_read(wm831x, on_reg); 342 if (ret < 0) 343 return 0; 344 345 if (ret & WM831X_LDO7_ON_MODE) 346 return REGULATOR_MODE_IDLE; 347 else 348 return REGULATOR_MODE_NORMAL; 349} 350 351static int wm831x_aldo_set_mode(struct regulator_dev *rdev, 352 unsigned int mode) 353{ 354 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 355 struct wm831x *wm831x = ldo->wm831x; 356 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL; 357 int ret; 358 359 360 switch (mode) { 361 case REGULATOR_MODE_NORMAL: 362 ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 0); 363 if (ret < 0) 364 return ret; 365 break; 366 367 case REGULATOR_MODE_IDLE: 368 ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 369 WM831X_LDO7_ON_MODE); 370 if (ret < 0) 371 return ret; 372 break; 373 374 default: 375 return -EINVAL; 376 } 377 378 return 0; 379} 380 381static int wm831x_aldo_get_status(struct regulator_dev *rdev) 382{ 383 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 384 struct wm831x *wm831x = ldo->wm831x; 385 int mask = 1 << rdev_get_id(rdev); 386 int ret; 387 388 /* Is the regulator on? */ 389 ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS); 390 if (ret < 0) 391 return ret; 392 if (!(ret & mask)) 393 return REGULATOR_STATUS_OFF; 394 395 /* Is it reporting under voltage? */ 396 ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS); 397 if (ret < 0) 398 return ret; 399 if (ret & mask) 400 return REGULATOR_STATUS_ERROR; 401 402 ret = wm831x_aldo_get_mode(rdev); 403 if (ret < 0) 404 return ret; 405 else 406 return regulator_mode_to_status(ret); 407} 408 409static const struct regulator_ops wm831x_aldo_ops = { 410 .list_voltage = regulator_list_voltage_linear_range, 411 .map_voltage = regulator_map_voltage_linear_range, 412 .get_voltage_sel = regulator_get_voltage_sel_regmap, 413 .set_voltage_sel = regulator_set_voltage_sel_regmap, 414 .set_suspend_voltage = wm831x_aldo_set_suspend_voltage, 415 .get_mode = wm831x_aldo_get_mode, 416 .set_mode = wm831x_aldo_set_mode, 417 .get_status = wm831x_aldo_get_status, 418 .set_bypass = regulator_set_bypass_regmap, 419 .get_bypass = regulator_get_bypass_regmap, 420 421 .is_enabled = regulator_is_enabled_regmap, 422 .enable = regulator_enable_regmap, 423 .disable = regulator_disable_regmap, 424}; 425 426static int wm831x_aldo_probe(struct platform_device *pdev) 427{ 428 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 429 struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev); 430 struct regulator_config config = { }; 431 int id; 432 struct wm831x_ldo *ldo; 433 struct resource *res; 434 int ret, irq; 435 436 if (pdata && pdata->wm831x_num) 437 id = (pdata->wm831x_num * 10) + 1; 438 else 439 id = 0; 440 id = pdev->id - id; 441 442 dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1); 443 444 ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL); 445 if (!ldo) 446 return -ENOMEM; 447 448 ldo->wm831x = wm831x; 449 450 res = platform_get_resource(pdev, IORESOURCE_REG, 0); 451 if (res == NULL) { 452 dev_err(&pdev->dev, "No REG resource\n"); 453 ret = -EINVAL; 454 goto err; 455 } 456 ldo->base = res->start; 457 458 snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1); 459 ldo->desc.name = ldo->name; 460 461 snprintf(ldo->supply_name, sizeof(ldo->supply_name), 462 "LDO%dVDD", id + 1); 463 ldo->desc.supply_name = ldo->supply_name; 464 465 ldo->desc.id = id; 466 ldo->desc.type = REGULATOR_VOLTAGE; 467 ldo->desc.n_voltages = 32; 468 ldo->desc.linear_ranges = wm831x_aldo_ranges; 469 ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_aldo_ranges); 470 ldo->desc.ops = &wm831x_aldo_ops; 471 ldo->desc.owner = THIS_MODULE; 472 ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL; 473 ldo->desc.vsel_mask = WM831X_LDO7_ON_VSEL_MASK; 474 ldo->desc.enable_reg = WM831X_LDO_ENABLE; 475 ldo->desc.enable_mask = 1 << id; 476 ldo->desc.bypass_reg = ldo->base; 477 ldo->desc.bypass_mask = WM831X_LDO7_SWI; 478 479 config.dev = pdev->dev.parent; 480 if (pdata) 481 config.init_data = pdata->ldo[id]; 482 config.driver_data = ldo; 483 config.regmap = wm831x->regmap; 484 485 ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc, 486 &config); 487 if (IS_ERR(ldo->regulator)) { 488 ret = PTR_ERR(ldo->regulator); 489 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n", 490 id + 1, ret); 491 goto err; 492 } 493 494 irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV")); 495 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 496 wm831x_ldo_uv_irq, 497 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 498 ldo->name, ldo); 499 if (ret != 0) { 500 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", 501 irq, ret); 502 goto err; 503 } 504 505 platform_set_drvdata(pdev, ldo); 506 507 return 0; 508 509err: 510 return ret; 511} 512 513static struct platform_driver wm831x_aldo_driver = { 514 .probe = wm831x_aldo_probe, 515 .driver = { 516 .name = "wm831x-aldo", 517 }, 518}; 519 520/* 521 * Alive LDO 522 */ 523 524#define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf 525 526static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev, 527 int uV) 528{ 529 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 530 struct wm831x *wm831x = ldo->wm831x; 531 int sel, reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL; 532 533 sel = regulator_map_voltage_linear(rdev, uV, uV); 534 if (sel < 0) 535 return sel; 536 537 return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, sel); 538} 539 540static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev) 541{ 542 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 543 struct wm831x *wm831x = ldo->wm831x; 544 int mask = 1 << rdev_get_id(rdev); 545 int ret; 546 547 /* Is the regulator on? */ 548 ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS); 549 if (ret < 0) 550 return ret; 551 if (ret & mask) 552 return REGULATOR_STATUS_ON; 553 else 554 return REGULATOR_STATUS_OFF; 555} 556 557static const struct regulator_ops wm831x_alive_ldo_ops = { 558 .list_voltage = regulator_list_voltage_linear, 559 .map_voltage = regulator_map_voltage_linear, 560 .get_voltage_sel = regulator_get_voltage_sel_regmap, 561 .set_voltage_sel = regulator_set_voltage_sel_regmap, 562 .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage, 563 .get_status = wm831x_alive_ldo_get_status, 564 565 .is_enabled = regulator_is_enabled_regmap, 566 .enable = regulator_enable_regmap, 567 .disable = regulator_disable_regmap, 568}; 569 570static int wm831x_alive_ldo_probe(struct platform_device *pdev) 571{ 572 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 573 struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev); 574 struct regulator_config config = { }; 575 int id; 576 struct wm831x_ldo *ldo; 577 struct resource *res; 578 int ret; 579 580 if (pdata && pdata->wm831x_num) 581 id = (pdata->wm831x_num * 10) + 1; 582 else 583 id = 0; 584 id = pdev->id - id; 585 586 587 dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1); 588 589 ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL); 590 if (!ldo) 591 return -ENOMEM; 592 593 ldo->wm831x = wm831x; 594 595 res = platform_get_resource(pdev, IORESOURCE_REG, 0); 596 if (res == NULL) { 597 dev_err(&pdev->dev, "No REG resource\n"); 598 ret = -EINVAL; 599 goto err; 600 } 601 ldo->base = res->start; 602 603 snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1); 604 ldo->desc.name = ldo->name; 605 606 snprintf(ldo->supply_name, sizeof(ldo->supply_name), 607 "LDO%dVDD", id + 1); 608 ldo->desc.supply_name = ldo->supply_name; 609 610 ldo->desc.id = id; 611 ldo->desc.type = REGULATOR_VOLTAGE; 612 ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1; 613 ldo->desc.ops = &wm831x_alive_ldo_ops; 614 ldo->desc.owner = THIS_MODULE; 615 ldo->desc.vsel_reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL; 616 ldo->desc.vsel_mask = WM831X_LDO11_ON_VSEL_MASK; 617 ldo->desc.enable_reg = WM831X_LDO_ENABLE; 618 ldo->desc.enable_mask = 1 << id; 619 ldo->desc.min_uV = 800000; 620 ldo->desc.uV_step = 50000; 621 ldo->desc.enable_time = 1000; 622 623 config.dev = pdev->dev.parent; 624 if (pdata) 625 config.init_data = pdata->ldo[id]; 626 config.driver_data = ldo; 627 config.regmap = wm831x->regmap; 628 629 ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc, 630 &config); 631 if (IS_ERR(ldo->regulator)) { 632 ret = PTR_ERR(ldo->regulator); 633 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n", 634 id + 1, ret); 635 goto err; 636 } 637 638 platform_set_drvdata(pdev, ldo); 639 640 return 0; 641 642err: 643 return ret; 644} 645 646static struct platform_driver wm831x_alive_ldo_driver = { 647 .probe = wm831x_alive_ldo_probe, 648 .driver = { 649 .name = "wm831x-alive-ldo", 650 }, 651}; 652 653static struct platform_driver * const drivers[] = { 654 &wm831x_gp_ldo_driver, 655 &wm831x_aldo_driver, 656 &wm831x_alive_ldo_driver, 657}; 658 659static int __init wm831x_ldo_init(void) 660{ 661 return platform_register_drivers(drivers, ARRAY_SIZE(drivers)); 662} 663subsys_initcall(wm831x_ldo_init); 664 665static void __exit wm831x_ldo_exit(void) 666{ 667 platform_unregister_drivers(drivers, ARRAY_SIZE(drivers)); 668} 669module_exit(wm831x_ldo_exit); 670 671/* Module information */ 672MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 673MODULE_DESCRIPTION("WM831x LDO driver"); 674MODULE_LICENSE("GPL"); 675MODULE_ALIAS("platform:wm831x-ldo"); 676MODULE_ALIAS("platform:wm831x-aldo"); 677MODULE_ALIAS("platform:wm831x-aliveldo");