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 }, 307 }; 308 309 /* 310 * Analogue LDOs 311 */ 312 313 static const struct linear_range wm831x_aldo_ranges[] = { 314 REGULATOR_LINEAR_RANGE(1000000, 0, 12, 50000), 315 REGULATOR_LINEAR_RANGE(1700000, 13, 31, 100000), 316 }; 317 318 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev, 319 int uV) 320 { 321 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 322 struct wm831x *wm831x = ldo->wm831x; 323 int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL; 324 325 sel = regulator_map_voltage_linear_range(rdev, uV, uV); 326 if (sel < 0) 327 return sel; 328 329 return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, sel); 330 } 331 332 static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev) 333 { 334 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 335 struct wm831x *wm831x = ldo->wm831x; 336 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL; 337 int ret; 338 339 ret = wm831x_reg_read(wm831x, on_reg); 340 if (ret < 0) 341 return 0; 342 343 if (ret & WM831X_LDO7_ON_MODE) 344 return REGULATOR_MODE_IDLE; 345 else 346 return REGULATOR_MODE_NORMAL; 347 } 348 349 static int wm831x_aldo_set_mode(struct regulator_dev *rdev, 350 unsigned int mode) 351 { 352 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 353 struct wm831x *wm831x = ldo->wm831x; 354 int on_reg = ldo->base + WM831X_LDO_ON_CONTROL; 355 int ret; 356 357 358 switch (mode) { 359 case REGULATOR_MODE_NORMAL: 360 ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 0); 361 if (ret < 0) 362 return ret; 363 break; 364 365 case REGULATOR_MODE_IDLE: 366 ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 367 WM831X_LDO7_ON_MODE); 368 if (ret < 0) 369 return ret; 370 break; 371 372 default: 373 return -EINVAL; 374 } 375 376 return 0; 377 } 378 379 static int wm831x_aldo_get_status(struct regulator_dev *rdev) 380 { 381 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 382 struct wm831x *wm831x = ldo->wm831x; 383 int mask = 1 << rdev_get_id(rdev); 384 int ret; 385 386 /* Is the regulator on? */ 387 ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS); 388 if (ret < 0) 389 return ret; 390 if (!(ret & mask)) 391 return REGULATOR_STATUS_OFF; 392 393 /* Is it reporting under voltage? */ 394 ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS); 395 if (ret < 0) 396 return ret; 397 if (ret & mask) 398 return REGULATOR_STATUS_ERROR; 399 400 ret = wm831x_aldo_get_mode(rdev); 401 if (ret < 0) 402 return ret; 403 else 404 return regulator_mode_to_status(ret); 405 } 406 407 static const struct regulator_ops wm831x_aldo_ops = { 408 .list_voltage = regulator_list_voltage_linear_range, 409 .map_voltage = regulator_map_voltage_linear_range, 410 .get_voltage_sel = regulator_get_voltage_sel_regmap, 411 .set_voltage_sel = regulator_set_voltage_sel_regmap, 412 .set_suspend_voltage = wm831x_aldo_set_suspend_voltage, 413 .get_mode = wm831x_aldo_get_mode, 414 .set_mode = wm831x_aldo_set_mode, 415 .get_status = wm831x_aldo_get_status, 416 .set_bypass = regulator_set_bypass_regmap, 417 .get_bypass = regulator_get_bypass_regmap, 418 419 .is_enabled = regulator_is_enabled_regmap, 420 .enable = regulator_enable_regmap, 421 .disable = regulator_disable_regmap, 422 }; 423 424 static int wm831x_aldo_probe(struct platform_device *pdev) 425 { 426 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 427 struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev); 428 struct regulator_config config = { }; 429 int id; 430 struct wm831x_ldo *ldo; 431 struct resource *res; 432 int ret, irq; 433 434 if (pdata && pdata->wm831x_num) 435 id = (pdata->wm831x_num * 10) + 1; 436 else 437 id = 0; 438 id = pdev->id - id; 439 440 dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1); 441 442 ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL); 443 if (!ldo) 444 return -ENOMEM; 445 446 ldo->wm831x = wm831x; 447 448 res = platform_get_resource(pdev, IORESOURCE_REG, 0); 449 if (res == NULL) { 450 dev_err(&pdev->dev, "No REG resource\n"); 451 ret = -EINVAL; 452 goto err; 453 } 454 ldo->base = res->start; 455 456 snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1); 457 ldo->desc.name = ldo->name; 458 459 snprintf(ldo->supply_name, sizeof(ldo->supply_name), 460 "LDO%dVDD", id + 1); 461 ldo->desc.supply_name = ldo->supply_name; 462 463 ldo->desc.id = id; 464 ldo->desc.type = REGULATOR_VOLTAGE; 465 ldo->desc.n_voltages = 32; 466 ldo->desc.linear_ranges = wm831x_aldo_ranges; 467 ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_aldo_ranges); 468 ldo->desc.ops = &wm831x_aldo_ops; 469 ldo->desc.owner = THIS_MODULE; 470 ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL; 471 ldo->desc.vsel_mask = WM831X_LDO7_ON_VSEL_MASK; 472 ldo->desc.enable_reg = WM831X_LDO_ENABLE; 473 ldo->desc.enable_mask = 1 << id; 474 ldo->desc.bypass_reg = ldo->base; 475 ldo->desc.bypass_mask = WM831X_LDO7_SWI; 476 477 config.dev = pdev->dev.parent; 478 if (pdata) 479 config.init_data = pdata->ldo[id]; 480 config.driver_data = ldo; 481 config.regmap = wm831x->regmap; 482 483 ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc, 484 &config); 485 if (IS_ERR(ldo->regulator)) { 486 ret = PTR_ERR(ldo->regulator); 487 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n", 488 id + 1, ret); 489 goto err; 490 } 491 492 irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV")); 493 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, 494 wm831x_ldo_uv_irq, 495 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 496 ldo->name, ldo); 497 if (ret != 0) { 498 dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n", 499 irq, ret); 500 goto err; 501 } 502 503 platform_set_drvdata(pdev, ldo); 504 505 return 0; 506 507 err: 508 return ret; 509 } 510 511 static struct platform_driver wm831x_aldo_driver = { 512 .probe = wm831x_aldo_probe, 513 .driver = { 514 .name = "wm831x-aldo", 515 }, 516 }; 517 518 /* 519 * Alive LDO 520 */ 521 522 #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf 523 524 static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev, 525 int uV) 526 { 527 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 528 struct wm831x *wm831x = ldo->wm831x; 529 int sel, reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL; 530 531 sel = regulator_map_voltage_linear(rdev, uV, uV); 532 if (sel < 0) 533 return sel; 534 535 return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, sel); 536 } 537 538 static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev) 539 { 540 struct wm831x_ldo *ldo = rdev_get_drvdata(rdev); 541 struct wm831x *wm831x = ldo->wm831x; 542 int mask = 1 << rdev_get_id(rdev); 543 int ret; 544 545 /* Is the regulator on? */ 546 ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS); 547 if (ret < 0) 548 return ret; 549 if (ret & mask) 550 return REGULATOR_STATUS_ON; 551 else 552 return REGULATOR_STATUS_OFF; 553 } 554 555 static const struct regulator_ops wm831x_alive_ldo_ops = { 556 .list_voltage = regulator_list_voltage_linear, 557 .map_voltage = regulator_map_voltage_linear, 558 .get_voltage_sel = regulator_get_voltage_sel_regmap, 559 .set_voltage_sel = regulator_set_voltage_sel_regmap, 560 .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage, 561 .get_status = wm831x_alive_ldo_get_status, 562 563 .is_enabled = regulator_is_enabled_regmap, 564 .enable = regulator_enable_regmap, 565 .disable = regulator_disable_regmap, 566 }; 567 568 static int wm831x_alive_ldo_probe(struct platform_device *pdev) 569 { 570 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 571 struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev); 572 struct regulator_config config = { }; 573 int id; 574 struct wm831x_ldo *ldo; 575 struct resource *res; 576 int ret; 577 578 if (pdata && pdata->wm831x_num) 579 id = (pdata->wm831x_num * 10) + 1; 580 else 581 id = 0; 582 id = pdev->id - id; 583 584 585 dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1); 586 587 ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL); 588 if (!ldo) 589 return -ENOMEM; 590 591 ldo->wm831x = wm831x; 592 593 res = platform_get_resource(pdev, IORESOURCE_REG, 0); 594 if (res == NULL) { 595 dev_err(&pdev->dev, "No REG resource\n"); 596 ret = -EINVAL; 597 goto err; 598 } 599 ldo->base = res->start; 600 601 snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1); 602 ldo->desc.name = ldo->name; 603 604 snprintf(ldo->supply_name, sizeof(ldo->supply_name), 605 "LDO%dVDD", id + 1); 606 ldo->desc.supply_name = ldo->supply_name; 607 608 ldo->desc.id = id; 609 ldo->desc.type = REGULATOR_VOLTAGE; 610 ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1; 611 ldo->desc.ops = &wm831x_alive_ldo_ops; 612 ldo->desc.owner = THIS_MODULE; 613 ldo->desc.vsel_reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL; 614 ldo->desc.vsel_mask = WM831X_LDO11_ON_VSEL_MASK; 615 ldo->desc.enable_reg = WM831X_LDO_ENABLE; 616 ldo->desc.enable_mask = 1 << id; 617 ldo->desc.min_uV = 800000; 618 ldo->desc.uV_step = 50000; 619 ldo->desc.enable_time = 1000; 620 621 config.dev = pdev->dev.parent; 622 if (pdata) 623 config.init_data = pdata->ldo[id]; 624 config.driver_data = ldo; 625 config.regmap = wm831x->regmap; 626 627 ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc, 628 &config); 629 if (IS_ERR(ldo->regulator)) { 630 ret = PTR_ERR(ldo->regulator); 631 dev_err(wm831x->dev, "Failed to register LDO%d: %d\n", 632 id + 1, ret); 633 goto err; 634 } 635 636 platform_set_drvdata(pdev, ldo); 637 638 return 0; 639 640 err: 641 return ret; 642 } 643 644 static struct platform_driver wm831x_alive_ldo_driver = { 645 .probe = wm831x_alive_ldo_probe, 646 .driver = { 647 .name = "wm831x-alive-ldo", 648 }, 649 }; 650 651 static struct platform_driver * const drivers[] = { 652 &wm831x_gp_ldo_driver, 653 &wm831x_aldo_driver, 654 &wm831x_alive_ldo_driver, 655 }; 656 657 static int __init wm831x_ldo_init(void) 658 { 659 return platform_register_drivers(drivers, ARRAY_SIZE(drivers)); 660 } 661 subsys_initcall(wm831x_ldo_init); 662 663 static void __exit wm831x_ldo_exit(void) 664 { 665 platform_unregister_drivers(drivers, ARRAY_SIZE(drivers)); 666 } 667 module_exit(wm831x_ldo_exit); 668 669 /* Module information */ 670 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 671 MODULE_DESCRIPTION("WM831x LDO driver"); 672 MODULE_LICENSE("GPL"); 673 MODULE_ALIAS("platform:wm831x-ldo"); 674 MODULE_ALIAS("platform:wm831x-aldo"); 675 MODULE_ALIAS("platform:wm831x-aliveldo"); 676