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_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 60static 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 65static 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 79static 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 104static 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 156static 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 184static 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 196static 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 214static 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 298err: 299 return ret; 300} 301 302static 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 313static 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 318static 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 332static 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 349static 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 379static 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 407static 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 424static 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 507err: 508 return ret; 509} 510 511static 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 524static 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 538static 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 555static 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 568static 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 640err: 641 return ret; 642} 643 644static struct platform_driver wm831x_alive_ldo_driver = { 645 .probe = wm831x_alive_ldo_probe, 646 .driver = { 647 .name = "wm831x-alive-ldo", 648 }, 649}; 650 651static struct platform_driver * const drivers[] = { 652 &wm831x_gp_ldo_driver, 653 &wm831x_aldo_driver, 654 &wm831x_alive_ldo_driver, 655}; 656 657static int __init wm831x_ldo_init(void) 658{ 659 return platform_register_drivers(drivers, ARRAY_SIZE(drivers)); 660} 661subsys_initcall(wm831x_ldo_init); 662 663static void __exit wm831x_ldo_exit(void) 664{ 665 platform_unregister_drivers(drivers, ARRAY_SIZE(drivers)); 666} 667module_exit(wm831x_ldo_exit); 668 669/* Module information */ 670MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 671MODULE_DESCRIPTION("WM831x LDO driver"); 672MODULE_LICENSE("GPL"); 673MODULE_ALIAS("platform:wm831x-ldo"); 674MODULE_ALIAS("platform:wm831x-aldo"); 675MODULE_ALIAS("platform:wm831x-aliveldo"); 676