Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 //
0003 // wm831x-ldo.c  --  LDO driver for the WM831x series
0004 //
0005 // Copyright 2009 Wolfson Microelectronics PLC.
0006 //
0007 // Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
0008 
0009 #include <linux/module.h>
0010 #include <linux/moduleparam.h>
0011 #include <linux/init.h>
0012 #include <linux/bitops.h>
0013 #include <linux/err.h>
0014 #include <linux/i2c.h>
0015 #include <linux/platform_device.h>
0016 #include <linux/regulator/driver.h>
0017 #include <linux/slab.h>
0018 
0019 #include <linux/mfd/wm831x/core.h>
0020 #include <linux/mfd/wm831x/regulator.h>
0021 #include <linux/mfd/wm831x/pdata.h>
0022 
0023 #define WM831X_LDO_MAX_NAME 9
0024 
0025 #define WM831X_LDO_CONTROL       0
0026 #define WM831X_LDO_ON_CONTROL    1
0027 #define WM831X_LDO_SLEEP_CONTROL 2
0028 
0029 #define WM831X_ALIVE_LDO_ON_CONTROL    0
0030 #define WM831X_ALIVE_LDO_SLEEP_CONTROL 1
0031 
0032 struct wm831x_ldo {
0033     char name[WM831X_LDO_MAX_NAME];
0034     char supply_name[WM831X_LDO_MAX_NAME];
0035     struct regulator_desc desc;
0036     int base;
0037     struct wm831x *wm831x;
0038     struct regulator_dev *regulator;
0039 };
0040 
0041 /*
0042  * Shared
0043  */
0044 
0045 static irqreturn_t wm831x_ldo_uv_irq(int irq, void *data)
0046 {
0047     struct wm831x_ldo *ldo = data;
0048 
0049     regulator_notifier_call_chain(ldo->regulator,
0050                       REGULATOR_EVENT_UNDER_VOLTAGE,
0051                       NULL);
0052 
0053     return IRQ_HANDLED;
0054 }
0055 
0056 /*
0057  * General purpose LDOs
0058  */
0059 
0060 static const struct linear_range wm831x_gp_ldo_ranges[] = {
0061     REGULATOR_LINEAR_RANGE(900000, 0, 14, 50000),
0062     REGULATOR_LINEAR_RANGE(1700000, 15, 31, 100000),
0063 };
0064 
0065 static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev,
0066                          int uV)
0067 {
0068     struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
0069     struct wm831x *wm831x = ldo->wm831x;
0070     int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
0071 
0072     sel = regulator_map_voltage_linear_range(rdev, uV, uV);
0073     if (sel < 0)
0074         return sel;
0075 
0076     return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, sel);
0077 }
0078 
0079 static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev)
0080 {
0081     struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
0082     struct wm831x *wm831x = ldo->wm831x;
0083     int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
0084     int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
0085     int ret;
0086 
0087     ret = wm831x_reg_read(wm831x, on_reg);
0088     if (ret < 0)
0089         return ret;
0090 
0091     if (!(ret & WM831X_LDO1_ON_MODE))
0092         return REGULATOR_MODE_NORMAL;
0093 
0094     ret = wm831x_reg_read(wm831x, ctrl_reg);
0095     if (ret < 0)
0096         return ret;
0097 
0098     if (ret & WM831X_LDO1_LP_MODE)
0099         return REGULATOR_MODE_STANDBY;
0100     else
0101         return REGULATOR_MODE_IDLE;
0102 }
0103 
0104 static int wm831x_gp_ldo_set_mode(struct regulator_dev *rdev,
0105                   unsigned int mode)
0106 {
0107     struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
0108     struct wm831x *wm831x = ldo->wm831x;
0109     int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
0110     int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
0111     int ret;
0112 
0113 
0114     switch (mode) {
0115     case REGULATOR_MODE_NORMAL:
0116         ret = wm831x_set_bits(wm831x, on_reg,
0117                       WM831X_LDO1_ON_MODE, 0);
0118         if (ret < 0)
0119             return ret;
0120         break;
0121 
0122     case REGULATOR_MODE_IDLE:
0123         ret = wm831x_set_bits(wm831x, ctrl_reg,
0124                       WM831X_LDO1_LP_MODE, 0);
0125         if (ret < 0)
0126             return ret;
0127 
0128         ret = wm831x_set_bits(wm831x, on_reg,
0129                       WM831X_LDO1_ON_MODE,
0130                       WM831X_LDO1_ON_MODE);
0131         if (ret < 0)
0132             return ret;
0133         break;
0134 
0135     case REGULATOR_MODE_STANDBY:
0136         ret = wm831x_set_bits(wm831x, ctrl_reg,
0137                       WM831X_LDO1_LP_MODE,
0138                       WM831X_LDO1_LP_MODE);
0139         if (ret < 0)
0140             return ret;
0141 
0142         ret = wm831x_set_bits(wm831x, on_reg,
0143                       WM831X_LDO1_ON_MODE,
0144                       WM831X_LDO1_ON_MODE);
0145         if (ret < 0)
0146             return ret;
0147         break;
0148 
0149     default:
0150         return -EINVAL;
0151     }
0152 
0153     return 0;
0154 }
0155 
0156 static int wm831x_gp_ldo_get_status(struct regulator_dev *rdev)
0157 {
0158     struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
0159     struct wm831x *wm831x = ldo->wm831x;
0160     int mask = 1 << rdev_get_id(rdev);
0161     int ret;
0162 
0163     /* Is the regulator on? */
0164     ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
0165     if (ret < 0)
0166         return ret;
0167     if (!(ret & mask))
0168         return REGULATOR_STATUS_OFF;
0169 
0170     /* Is it reporting under voltage? */
0171     ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
0172     if (ret < 0)
0173         return ret;
0174     if (ret & mask)
0175         return REGULATOR_STATUS_ERROR;
0176 
0177     ret = wm831x_gp_ldo_get_mode(rdev);
0178     if (ret < 0)
0179         return ret;
0180     else
0181         return regulator_mode_to_status(ret);
0182 }
0183 
0184 static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev,
0185                            int input_uV,
0186                            int output_uV, int load_uA)
0187 {
0188     if (load_uA < 20000)
0189         return REGULATOR_MODE_STANDBY;
0190     if (load_uA < 50000)
0191         return REGULATOR_MODE_IDLE;
0192     return REGULATOR_MODE_NORMAL;
0193 }
0194 
0195 
0196 static const struct regulator_ops wm831x_gp_ldo_ops = {
0197     .list_voltage = regulator_list_voltage_linear_range,
0198     .map_voltage = regulator_map_voltage_linear_range,
0199     .get_voltage_sel = regulator_get_voltage_sel_regmap,
0200     .set_voltage_sel = regulator_set_voltage_sel_regmap,
0201     .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage,
0202     .get_mode = wm831x_gp_ldo_get_mode,
0203     .set_mode = wm831x_gp_ldo_set_mode,
0204     .get_status = wm831x_gp_ldo_get_status,
0205     .get_optimum_mode = wm831x_gp_ldo_get_optimum_mode,
0206     .get_bypass = regulator_get_bypass_regmap,
0207     .set_bypass = regulator_set_bypass_regmap,
0208 
0209     .is_enabled = regulator_is_enabled_regmap,
0210     .enable = regulator_enable_regmap,
0211     .disable = regulator_disable_regmap,
0212 };
0213 
0214 static int wm831x_gp_ldo_probe(struct platform_device *pdev)
0215 {
0216     struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
0217     struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
0218     struct regulator_config config = { };
0219     int id;
0220     struct wm831x_ldo *ldo;
0221     struct resource *res;
0222     int ret, irq;
0223 
0224     if (pdata && pdata->wm831x_num)
0225         id = (pdata->wm831x_num * 10) + 1;
0226     else
0227         id = 0;
0228     id = pdev->id - id;
0229 
0230     dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
0231 
0232     ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
0233     if (!ldo)
0234         return -ENOMEM;
0235 
0236     ldo->wm831x = wm831x;
0237 
0238     res = platform_get_resource(pdev, IORESOURCE_REG, 0);
0239     if (res == NULL) {
0240         dev_err(&pdev->dev, "No REG resource\n");
0241         ret = -EINVAL;
0242         goto err;
0243     }
0244     ldo->base = res->start;
0245 
0246     snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
0247     ldo->desc.name = ldo->name;
0248 
0249     snprintf(ldo->supply_name, sizeof(ldo->supply_name),
0250          "LDO%dVDD", id + 1);
0251     ldo->desc.supply_name = ldo->supply_name;
0252 
0253     ldo->desc.id = id;
0254     ldo->desc.type = REGULATOR_VOLTAGE;
0255     ldo->desc.n_voltages = 32;
0256     ldo->desc.ops = &wm831x_gp_ldo_ops;
0257     ldo->desc.owner = THIS_MODULE;
0258     ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
0259     ldo->desc.vsel_mask = WM831X_LDO1_ON_VSEL_MASK;
0260     ldo->desc.enable_reg = WM831X_LDO_ENABLE;
0261     ldo->desc.enable_mask = 1 << id;
0262     ldo->desc.bypass_reg = ldo->base;
0263     ldo->desc.bypass_mask = WM831X_LDO1_SWI;
0264     ldo->desc.linear_ranges = wm831x_gp_ldo_ranges;
0265     ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_gp_ldo_ranges);
0266 
0267     config.dev = pdev->dev.parent;
0268     if (pdata)
0269         config.init_data = pdata->ldo[id];
0270     config.driver_data = ldo;
0271     config.regmap = wm831x->regmap;
0272 
0273     ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
0274                          &config);
0275     if (IS_ERR(ldo->regulator)) {
0276         ret = PTR_ERR(ldo->regulator);
0277         dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
0278             id + 1, ret);
0279         goto err;
0280     }
0281 
0282     irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
0283     ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
0284                     wm831x_ldo_uv_irq,
0285                     IRQF_TRIGGER_RISING | IRQF_ONESHOT,
0286                     ldo->name,
0287                     ldo);
0288     if (ret != 0) {
0289         dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
0290             irq, ret);
0291         goto err;
0292     }
0293 
0294     platform_set_drvdata(pdev, ldo);
0295 
0296     return 0;
0297 
0298 err:
0299     return ret;
0300 }
0301 
0302 static struct platform_driver wm831x_gp_ldo_driver = {
0303     .probe = wm831x_gp_ldo_probe,
0304     .driver     = {
0305         .name   = "wm831x-ldo",
0306     },
0307 };
0308 
0309 /*
0310  * Analogue LDOs
0311  */
0312 
0313 static const struct linear_range wm831x_aldo_ranges[] = {
0314     REGULATOR_LINEAR_RANGE(1000000, 0, 12, 50000),
0315     REGULATOR_LINEAR_RANGE(1700000, 13, 31, 100000),
0316 };
0317 
0318 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
0319                          int uV)
0320 {
0321     struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
0322     struct wm831x *wm831x = ldo->wm831x;
0323     int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
0324 
0325     sel = regulator_map_voltage_linear_range(rdev, uV, uV);
0326     if (sel < 0)
0327         return sel;
0328 
0329     return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, sel);
0330 }
0331 
0332 static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
0333 {
0334     struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
0335     struct wm831x *wm831x = ldo->wm831x;
0336     int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
0337     int ret;
0338 
0339     ret = wm831x_reg_read(wm831x, on_reg);
0340     if (ret < 0)
0341         return 0;
0342 
0343     if (ret & WM831X_LDO7_ON_MODE)
0344         return REGULATOR_MODE_IDLE;
0345     else
0346         return REGULATOR_MODE_NORMAL;
0347 }
0348 
0349 static int wm831x_aldo_set_mode(struct regulator_dev *rdev,
0350                   unsigned int mode)
0351 {
0352     struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
0353     struct wm831x *wm831x = ldo->wm831x;
0354     int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
0355     int ret;
0356 
0357 
0358     switch (mode) {
0359     case REGULATOR_MODE_NORMAL:
0360         ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 0);
0361         if (ret < 0)
0362             return ret;
0363         break;
0364 
0365     case REGULATOR_MODE_IDLE:
0366         ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE,
0367                       WM831X_LDO7_ON_MODE);
0368         if (ret < 0)
0369             return ret;
0370         break;
0371 
0372     default:
0373         return -EINVAL;
0374     }
0375 
0376     return 0;
0377 }
0378 
0379 static int wm831x_aldo_get_status(struct regulator_dev *rdev)
0380 {
0381     struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
0382     struct wm831x *wm831x = ldo->wm831x;
0383     int mask = 1 << rdev_get_id(rdev);
0384     int ret;
0385 
0386     /* Is the regulator on? */
0387     ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
0388     if (ret < 0)
0389         return ret;
0390     if (!(ret & mask))
0391         return REGULATOR_STATUS_OFF;
0392 
0393     /* Is it reporting under voltage? */
0394     ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
0395     if (ret < 0)
0396         return ret;
0397     if (ret & mask)
0398         return REGULATOR_STATUS_ERROR;
0399 
0400     ret = wm831x_aldo_get_mode(rdev);
0401     if (ret < 0)
0402         return ret;
0403     else
0404         return regulator_mode_to_status(ret);
0405 }
0406 
0407 static const struct regulator_ops wm831x_aldo_ops = {
0408     .list_voltage = regulator_list_voltage_linear_range,
0409     .map_voltage = regulator_map_voltage_linear_range,
0410     .get_voltage_sel = regulator_get_voltage_sel_regmap,
0411     .set_voltage_sel = regulator_set_voltage_sel_regmap,
0412     .set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
0413     .get_mode = wm831x_aldo_get_mode,
0414     .set_mode = wm831x_aldo_set_mode,
0415     .get_status = wm831x_aldo_get_status,
0416     .set_bypass = regulator_set_bypass_regmap,
0417     .get_bypass = regulator_get_bypass_regmap,
0418 
0419     .is_enabled = regulator_is_enabled_regmap,
0420     .enable = regulator_enable_regmap,
0421     .disable = regulator_disable_regmap,
0422 };
0423 
0424 static int wm831x_aldo_probe(struct platform_device *pdev)
0425 {
0426     struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
0427     struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
0428     struct regulator_config config = { };
0429     int id;
0430     struct wm831x_ldo *ldo;
0431     struct resource *res;
0432     int ret, irq;
0433 
0434     if (pdata && pdata->wm831x_num)
0435         id = (pdata->wm831x_num * 10) + 1;
0436     else
0437         id = 0;
0438     id = pdev->id - id;
0439 
0440     dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
0441 
0442     ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
0443     if (!ldo)
0444         return -ENOMEM;
0445 
0446     ldo->wm831x = wm831x;
0447 
0448     res = platform_get_resource(pdev, IORESOURCE_REG, 0);
0449     if (res == NULL) {
0450         dev_err(&pdev->dev, "No REG resource\n");
0451         ret = -EINVAL;
0452         goto err;
0453     }
0454     ldo->base = res->start;
0455 
0456     snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
0457     ldo->desc.name = ldo->name;
0458 
0459     snprintf(ldo->supply_name, sizeof(ldo->supply_name),
0460          "LDO%dVDD", id + 1);
0461     ldo->desc.supply_name = ldo->supply_name;
0462 
0463     ldo->desc.id = id;
0464     ldo->desc.type = REGULATOR_VOLTAGE;
0465     ldo->desc.n_voltages = 32;
0466     ldo->desc.linear_ranges = wm831x_aldo_ranges;
0467     ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_aldo_ranges);
0468     ldo->desc.ops = &wm831x_aldo_ops;
0469     ldo->desc.owner = THIS_MODULE;
0470     ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
0471     ldo->desc.vsel_mask = WM831X_LDO7_ON_VSEL_MASK;
0472     ldo->desc.enable_reg = WM831X_LDO_ENABLE;
0473     ldo->desc.enable_mask = 1 << id;
0474     ldo->desc.bypass_reg = ldo->base;
0475     ldo->desc.bypass_mask = WM831X_LDO7_SWI;
0476 
0477     config.dev = pdev->dev.parent;
0478     if (pdata)
0479         config.init_data = pdata->ldo[id];
0480     config.driver_data = ldo;
0481     config.regmap = wm831x->regmap;
0482 
0483     ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
0484                          &config);
0485     if (IS_ERR(ldo->regulator)) {
0486         ret = PTR_ERR(ldo->regulator);
0487         dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
0488             id + 1, ret);
0489         goto err;
0490     }
0491 
0492     irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
0493     ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
0494                     wm831x_ldo_uv_irq,
0495                     IRQF_TRIGGER_RISING | IRQF_ONESHOT,
0496                     ldo->name, ldo);
0497     if (ret != 0) {
0498         dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
0499             irq, ret);
0500         goto err;
0501     }
0502 
0503     platform_set_drvdata(pdev, ldo);
0504 
0505     return 0;
0506 
0507 err:
0508     return ret;
0509 }
0510 
0511 static struct platform_driver wm831x_aldo_driver = {
0512     .probe = wm831x_aldo_probe,
0513     .driver     = {
0514         .name   = "wm831x-aldo",
0515     },
0516 };
0517 
0518 /*
0519  * Alive LDO
0520  */
0521 
0522 #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
0523 
0524 static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
0525                          int uV)
0526 {
0527     struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
0528     struct wm831x *wm831x = ldo->wm831x;
0529     int sel, reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
0530 
0531     sel = regulator_map_voltage_linear(rdev, uV, uV);
0532     if (sel < 0)
0533         return sel;
0534 
0535     return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, sel);
0536 }
0537 
0538 static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
0539 {
0540     struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
0541     struct wm831x *wm831x = ldo->wm831x;
0542     int mask = 1 << rdev_get_id(rdev);
0543     int ret;
0544 
0545     /* Is the regulator on? */
0546     ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
0547     if (ret < 0)
0548         return ret;
0549     if (ret & mask)
0550         return REGULATOR_STATUS_ON;
0551     else
0552         return REGULATOR_STATUS_OFF;
0553 }
0554 
0555 static const struct regulator_ops wm831x_alive_ldo_ops = {
0556     .list_voltage = regulator_list_voltage_linear,
0557     .map_voltage = regulator_map_voltage_linear,
0558     .get_voltage_sel = regulator_get_voltage_sel_regmap,
0559     .set_voltage_sel = regulator_set_voltage_sel_regmap,
0560     .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage,
0561     .get_status = wm831x_alive_ldo_get_status,
0562 
0563     .is_enabled = regulator_is_enabled_regmap,
0564     .enable = regulator_enable_regmap,
0565     .disable = regulator_disable_regmap,
0566 };
0567 
0568 static int wm831x_alive_ldo_probe(struct platform_device *pdev)
0569 {
0570     struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
0571     struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
0572     struct regulator_config config = { };
0573     int id;
0574     struct wm831x_ldo *ldo;
0575     struct resource *res;
0576     int ret;
0577 
0578     if (pdata && pdata->wm831x_num)
0579         id = (pdata->wm831x_num * 10) + 1;
0580     else
0581         id = 0;
0582     id = pdev->id - id;
0583 
0584 
0585     dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
0586 
0587     ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
0588     if (!ldo)
0589         return -ENOMEM;
0590 
0591     ldo->wm831x = wm831x;
0592 
0593     res = platform_get_resource(pdev, IORESOURCE_REG, 0);
0594     if (res == NULL) {
0595         dev_err(&pdev->dev, "No REG resource\n");
0596         ret = -EINVAL;
0597         goto err;
0598     }
0599     ldo->base = res->start;
0600 
0601     snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
0602     ldo->desc.name = ldo->name;
0603 
0604     snprintf(ldo->supply_name, sizeof(ldo->supply_name),
0605          "LDO%dVDD", id + 1);
0606     ldo->desc.supply_name = ldo->supply_name;
0607 
0608     ldo->desc.id = id;
0609     ldo->desc.type = REGULATOR_VOLTAGE;
0610     ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1;
0611     ldo->desc.ops = &wm831x_alive_ldo_ops;
0612     ldo->desc.owner = THIS_MODULE;
0613     ldo->desc.vsel_reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
0614     ldo->desc.vsel_mask = WM831X_LDO11_ON_VSEL_MASK;
0615     ldo->desc.enable_reg = WM831X_LDO_ENABLE;
0616     ldo->desc.enable_mask = 1 << id;
0617     ldo->desc.min_uV = 800000;
0618     ldo->desc.uV_step = 50000;
0619     ldo->desc.enable_time = 1000;
0620 
0621     config.dev = pdev->dev.parent;
0622     if (pdata)
0623         config.init_data = pdata->ldo[id];
0624     config.driver_data = ldo;
0625     config.regmap = wm831x->regmap;
0626 
0627     ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
0628                          &config);
0629     if (IS_ERR(ldo->regulator)) {
0630         ret = PTR_ERR(ldo->regulator);
0631         dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
0632             id + 1, ret);
0633         goto err;
0634     }
0635 
0636     platform_set_drvdata(pdev, ldo);
0637 
0638     return 0;
0639 
0640 err:
0641     return ret;
0642 }
0643 
0644 static struct platform_driver wm831x_alive_ldo_driver = {
0645     .probe = wm831x_alive_ldo_probe,
0646     .driver     = {
0647         .name   = "wm831x-alive-ldo",
0648     },
0649 };
0650 
0651 static struct platform_driver * const drivers[] = {
0652     &wm831x_gp_ldo_driver,
0653     &wm831x_aldo_driver,
0654     &wm831x_alive_ldo_driver,
0655 };
0656 
0657 static int __init wm831x_ldo_init(void)
0658 {
0659     return platform_register_drivers(drivers, ARRAY_SIZE(drivers));
0660 }
0661 subsys_initcall(wm831x_ldo_init);
0662 
0663 static void __exit wm831x_ldo_exit(void)
0664 {
0665     platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
0666 }
0667 module_exit(wm831x_ldo_exit);
0668 
0669 /* Module information */
0670 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
0671 MODULE_DESCRIPTION("WM831x LDO driver");
0672 MODULE_LICENSE("GPL");
0673 MODULE_ALIAS("platform:wm831x-ldo");
0674 MODULE_ALIAS("platform:wm831x-aldo");
0675 MODULE_ALIAS("platform:wm831x-aliveldo");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!