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 32 struct 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 45 static irqreturn_t wm831x_ldo_uv_irq(int irq, void *data) 46 { 47 struct wm831x_ldo *ldo = data; 48 49 regulator_notifier_call_chain(ldo->regulator, 50 REGULATOR_EVENT_UNDER_VOLTAGE, 51 NULL); 52 53 return IRQ_HANDLED; 54 } 55 56 /* 57 * General purpose LDOs 58 */ 59 60 static const struct linear_range wm831x_gp_ldo_ranges[] = { 61 REGULATOR_LINEAR_RANGE(900000, 0, 14, 50000), 62 REGULATOR_LINEAR_RANGE(1700000, 15, 31, 100000), 63 }; 64 65 static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev, 66 int uV) 67 { 68 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 69 struct wm831x *wm831x = ldo->wm831x; 70 int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL; 71 72 sel = regulator_map_voltage_linear_range(rdev, uV, uV); 73 if (sel < 0) 74 return sel; 75 76 return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, sel); 77 } 78 79 static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev) 80 { 81 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 82 struct wm831x *wm831x = ldo->wm831x; 83 int ctrl_reg = ldo->base + WM831X_LDO_CONTROL; 84 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL; 85 int ret; 86 87 ret = wm831x_reg_read(wm831x, on_reg); 88 if (ret < 0) 89 return ret; 90 91 if (!(ret & WM831X_LDO1_ON_MODE)) 92 return REGULATOR_MODE_NORMAL; 93 94 ret = wm831x_reg_read(wm831x, ctrl_reg); 95 if (ret < 0) 96 return ret; 97 98 if (ret & WM831X_LDO1_LP_MODE) 99 return REGULATOR_MODE_STANDBY; 100 else 101 return REGULATOR_MODE_IDLE; 102 } 103 104 static int wm831x_gp_ldo_set_mode(struct regulator_dev *rdev, 105 unsigned int mode) 106 { 107 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 108 struct wm831x *wm831x = ldo->wm831x; 109 int ctrl_reg = ldo->base + WM831X_LDO_CONTROL; 110 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL; 111 int ret; 112 113 114 switch (mode) { 115 case REGULATOR_MODE_NORMAL: 116 ret = wm831x_set_bits(wm831x, on_reg, 117 WM831X_LDO1_ON_MODE, 0); 118 if (ret < 0) 119 return ret; 120 break; 121 122 case REGULATOR_MODE_IDLE: 123 ret = wm831x_set_bits(wm831x, ctrl_reg, 124 WM831X_LDO1_LP_MODE, 0); 125 if (ret < 0) 126 return ret; 127 128 ret = wm831x_set_bits(wm831x, on_reg, 129 WM831X_LDO1_ON_MODE, 130 WM831X_LDO1_ON_MODE); 131 if (ret < 0) 132 return ret; 133 break; 134 135 case REGULATOR_MODE_STANDBY: 136 ret = wm831x_set_bits(wm831x, ctrl_reg, 137 WM831X_LDO1_LP_MODE, 138 WM831X_LDO1_LP_MODE); 139 if (ret < 0) 140 return ret; 141 142 ret = wm831x_set_bits(wm831x, on_reg, 143 WM831X_LDO1_ON_MODE, 144 WM831X_LDO1_ON_MODE); 145 if (ret < 0) 146 return ret; 147 break; 148 149 default: 150 return -EINVAL; 151 } 152 153 return 0; 154 } 155 156 static int wm831x_gp_ldo_get_status(struct regulator_dev *rdev) 157 { 158 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 159 struct wm831x *wm831x = ldo->wm831x; 160 int mask = 1 << rdev_get_id(rdev); 161 int ret; 162 163 /* Is the regulator on? */ 164 ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS); 165 if (ret < 0) 166 return ret; 167 if (!(ret & mask)) 168 return REGULATOR_STATUS_OFF; 169 170 /* Is it reporting under voltage? */ 171 ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS); 172 if (ret < 0) 173 return ret; 174 if (ret & mask) 175 return REGULATOR_STATUS_ERROR; 176 177 ret = wm831x_gp_ldo_get_mode(rdev); 178 if (ret < 0) 179 return ret; 180 else 181 return regulator_mode_to_status(ret); 182 } 183 184 static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev, 185 int input_uV, 186 int output_uV, int load_uA) 187 { 188 if (load_uA < 20000) 189 return REGULATOR_MODE_STANDBY; 190 if (load_uA < 50000) 191 return REGULATOR_MODE_IDLE; 192 return REGULATOR_MODE_NORMAL; 193 } 194 195 196 static const struct regulator_ops wm831x_gp_ldo_ops = { 197 .list_voltage = regulator_list_voltage_linear_range, 198 .map_voltage = regulator_map_voltage_linear_range, 199 .get_voltage_sel = regulator_get_voltage_sel_regmap, 200 .set_voltage_sel = regulator_set_voltage_sel_regmap, 201 .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage, 202 .get_mode = wm831x_gp_ldo_get_mode, 203 .set_mode = wm831x_gp_ldo_set_mode, 204 .get_status = wm831x_gp_ldo_get_status, 205 .get_optimum_mode = wm831x_gp_ldo_get_optimum_mode, 206 .get_bypass = regulator_get_bypass_regmap, 207 .set_bypass = regulator_set_bypass_regmap, 208 209 .is_enabled = regulator_is_enabled_regmap, 210 .enable = regulator_enable_regmap, 211 .disable = regulator_disable_regmap, 212 }; 213 214 static int wm831x_gp_ldo_probe(struct platform_device *pdev) 215 { 216 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 217 struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev); 218 struct regulator_config config = { }; 219 int id; 220 struct wm831x_ldo *ldo; 221 struct resource *res; 222 int ret, irq; 223 224 if (pdata && pdata->wm831x_num) 225 id = (pdata->wm831x_num * 10) + 1; 226 else 227 id = 0; 228 id = pdev->id - id; 229 230 dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1); 231 232 ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL); 233 if (!ldo) 234 return -ENOMEM; 235 236 ldo->wm831x = wm831x; 237 238 res = platform_get_resource(pdev, IORESOURCE_REG, 0); 239 if (res == NULL) { 240 dev_err(&pdev->dev, "No REG resource\n"); 241 ret = -EINVAL; 242 goto err; 243 } 244 ldo->base = res->start; 245 246 snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1); 247 ldo->desc.name = ldo->name; 248 249 snprintf(ldo->supply_name, sizeof(ldo->supply_name), 250 "LDO%dVDD", id + 1); 251 ldo->desc.supply_name = ldo->supply_name; 252 253 ldo->desc.id = id; 254 ldo->desc.type = REGULATOR_VOLTAGE; 255 ldo->desc.n_voltages = 32; 256 ldo->desc.ops = &wm831x_gp_ldo_ops; 257 ldo->desc.owner = THIS_MODULE; 258 ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL; 259 ldo->desc.vsel_mask = WM831X_LDO1_ON_VSEL_MASK; 260 ldo->desc.enable_reg = WM831X_LDO_ENABLE; 261 ldo->desc.enable_mask = 1 << id; 262 ldo->desc.bypass_reg = ldo->base; 263 ldo->desc.bypass_mask = WM831X_LDO1_SWI; 264 ldo->desc.linear_ranges = wm831x_gp_ldo_ranges; 265 ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_gp_ldo_ranges); 266 267 config.dev = pdev->dev.parent; 268 if (pdata) 269 config.init_data = pdata->ldo[id]; 270 config.driver_data = ldo; 271 config.regmap = wm831x->regmap; 272 273 ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc, 274 &config); 275 if (IS_ERR(ldo->regulator)) { 276 ret = PTR_ERR(ldo->regulator); 277 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n", 278 id + 1, ret); 279 goto err; 280 } 281 282 irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV")); 283 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 284 wm831x_ldo_uv_irq, 285 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 286 ldo->name, 287 ldo); 288 if (ret != 0) { 289 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", 290 irq, ret); 291 goto err; 292 } 293 294 platform_set_drvdata(pdev, ldo); 295 296 return 0; 297 298 err: 299 return ret; 300 } 301 302 static struct platform_driver wm831x_gp_ldo_driver = { 303 .probe = wm831x_gp_ldo_probe, 304 .driver = { 305 .name = "wm831x-ldo", 306 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 307 }, 308 }; 309 310 /* 311 * Analogue LDOs 312 */ 313 314 static const struct linear_range wm831x_aldo_ranges[] = { 315 REGULATOR_LINEAR_RANGE(1000000, 0, 12, 50000), 316 REGULATOR_LINEAR_RANGE(1700000, 13, 31, 100000), 317 }; 318 319 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev, 320 int uV) 321 { 322 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 323 struct wm831x *wm831x = ldo->wm831x; 324 int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL; 325 326 sel = regulator_map_voltage_linear_range(rdev, uV, uV); 327 if (sel < 0) 328 return sel; 329 330 return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, sel); 331 } 332 333 static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev) 334 { 335 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 336 struct wm831x *wm831x = ldo->wm831x; 337 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL; 338 int ret; 339 340 ret = wm831x_reg_read(wm831x, on_reg); 341 if (ret < 0) 342 return 0; 343 344 if (ret & WM831X_LDO7_ON_MODE) 345 return REGULATOR_MODE_IDLE; 346 else 347 return REGULATOR_MODE_NORMAL; 348 } 349 350 static int wm831x_aldo_set_mode(struct regulator_dev *rdev, 351 unsigned int mode) 352 { 353 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 354 struct wm831x *wm831x = ldo->wm831x; 355 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL; 356 int ret; 357 358 359 switch (mode) { 360 case REGULATOR_MODE_NORMAL: 361 ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 0); 362 if (ret < 0) 363 return ret; 364 break; 365 366 case REGULATOR_MODE_IDLE: 367 ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 368 WM831X_LDO7_ON_MODE); 369 if (ret < 0) 370 return ret; 371 break; 372 373 default: 374 return -EINVAL; 375 } 376 377 return 0; 378 } 379 380 static int wm831x_aldo_get_status(struct regulator_dev *rdev) 381 { 382 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 383 struct wm831x *wm831x = ldo->wm831x; 384 int mask = 1 << rdev_get_id(rdev); 385 int ret; 386 387 /* Is the regulator on? */ 388 ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS); 389 if (ret < 0) 390 return ret; 391 if (!(ret & mask)) 392 return REGULATOR_STATUS_OFF; 393 394 /* Is it reporting under voltage? */ 395 ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS); 396 if (ret < 0) 397 return ret; 398 if (ret & mask) 399 return REGULATOR_STATUS_ERROR; 400 401 ret = wm831x_aldo_get_mode(rdev); 402 if (ret < 0) 403 return ret; 404 else 405 return regulator_mode_to_status(ret); 406 } 407 408 static const struct regulator_ops wm831x_aldo_ops = { 409 .list_voltage = regulator_list_voltage_linear_range, 410 .map_voltage = regulator_map_voltage_linear_range, 411 .get_voltage_sel = regulator_get_voltage_sel_regmap, 412 .set_voltage_sel = regulator_set_voltage_sel_regmap, 413 .set_suspend_voltage = wm831x_aldo_set_suspend_voltage, 414 .get_mode = wm831x_aldo_get_mode, 415 .set_mode = wm831x_aldo_set_mode, 416 .get_status = wm831x_aldo_get_status, 417 .set_bypass = regulator_set_bypass_regmap, 418 .get_bypass = regulator_get_bypass_regmap, 419 420 .is_enabled = regulator_is_enabled_regmap, 421 .enable = regulator_enable_regmap, 422 .disable = regulator_disable_regmap, 423 }; 424 425 static int wm831x_aldo_probe(struct platform_device *pdev) 426 { 427 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 428 struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev); 429 struct regulator_config config = { }; 430 int id; 431 struct wm831x_ldo *ldo; 432 struct resource *res; 433 int ret, irq; 434 435 if (pdata && pdata->wm831x_num) 436 id = (pdata->wm831x_num * 10) + 1; 437 else 438 id = 0; 439 id = pdev->id - id; 440 441 dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1); 442 443 ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL); 444 if (!ldo) 445 return -ENOMEM; 446 447 ldo->wm831x = wm831x; 448 449 res = platform_get_resource(pdev, IORESOURCE_REG, 0); 450 if (res == NULL) { 451 dev_err(&pdev->dev, "No REG resource\n"); 452 ret = -EINVAL; 453 goto err; 454 } 455 ldo->base = res->start; 456 457 snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1); 458 ldo->desc.name = ldo->name; 459 460 snprintf(ldo->supply_name, sizeof(ldo->supply_name), 461 "LDO%dVDD", id + 1); 462 ldo->desc.supply_name = ldo->supply_name; 463 464 ldo->desc.id = id; 465 ldo->desc.type = REGULATOR_VOLTAGE; 466 ldo->desc.n_voltages = 32; 467 ldo->desc.linear_ranges = wm831x_aldo_ranges; 468 ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_aldo_ranges); 469 ldo->desc.ops = &wm831x_aldo_ops; 470 ldo->desc.owner = THIS_MODULE; 471 ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL; 472 ldo->desc.vsel_mask = WM831X_LDO7_ON_VSEL_MASK; 473 ldo->desc.enable_reg = WM831X_LDO_ENABLE; 474 ldo->desc.enable_mask = 1 << id; 475 ldo->desc.bypass_reg = ldo->base; 476 ldo->desc.bypass_mask = WM831X_LDO7_SWI; 477 478 config.dev = pdev->dev.parent; 479 if (pdata) 480 config.init_data = pdata->ldo[id]; 481 config.driver_data = ldo; 482 config.regmap = wm831x->regmap; 483 484 ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc, 485 &config); 486 if (IS_ERR(ldo->regulator)) { 487 ret = PTR_ERR(ldo->regulator); 488 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n", 489 id + 1, ret); 490 goto err; 491 } 492 493 irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV")); 494 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 495 wm831x_ldo_uv_irq, 496 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 497 ldo->name, ldo); 498 if (ret != 0) { 499 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", 500 irq, ret); 501 goto err; 502 } 503 504 platform_set_drvdata(pdev, ldo); 505 506 return 0; 507 508 err: 509 return ret; 510 } 511 512 static struct platform_driver wm831x_aldo_driver = { 513 .probe = wm831x_aldo_probe, 514 .driver = { 515 .name = "wm831x-aldo", 516 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 517 }, 518 }; 519 520 /* 521 * Alive LDO 522 */ 523 524 #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf 525 526 static 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 540 static 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 557 static 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 570 static 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 642 err: 643 return ret; 644 } 645 646 static struct platform_driver wm831x_alive_ldo_driver = { 647 .probe = wm831x_alive_ldo_probe, 648 .driver = { 649 .name = "wm831x-alive-ldo", 650 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 651 }, 652 }; 653 654 static struct platform_driver * const drivers[] = { 655 &wm831x_gp_ldo_driver, 656 &wm831x_aldo_driver, 657 &wm831x_alive_ldo_driver, 658 }; 659 660 static int __init wm831x_ldo_init(void) 661 { 662 return platform_register_drivers(drivers, ARRAY_SIZE(drivers)); 663 } 664 subsys_initcall(wm831x_ldo_init); 665 666 static void __exit wm831x_ldo_exit(void) 667 { 668 platform_unregister_drivers(drivers, ARRAY_SIZE(drivers)); 669 } 670 module_exit(wm831x_ldo_exit); 671 672 /* Module information */ 673 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 674 MODULE_DESCRIPTION("WM831x LDO driver"); 675 MODULE_LICENSE("GPL"); 676 MODULE_ALIAS("platform:wm831x-ldo"); 677 MODULE_ALIAS("platform:wm831x-aldo"); 678 MODULE_ALIAS("platform:wm831x-aliveldo"); 679