Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/regulator/ab8500-ext.c

  1 /*
  2  * Copyright (C) ST-Ericsson SA 2010
  3  *
  4  * License Terms: GNU General Public License v2
  5  *
  6  * Authors: Bengt Jonsson <bengt.g.jonsson@stericsson.com>
  7  *
  8  * This file is based on drivers/regulator/ab8500.c
  9  *
 10  * AB8500 external regulators
 11  *
 12  * ab8500-ext supports the following regulators:
 13  * - VextSupply3
 14  */
 15 #include <linux/init.h>
 16 #include <linux/kernel.h>
 17 #include <linux/err.h>
 18 #include <linux/module.h>
 19 #include <linux/of.h>
 20 #include <linux/platform_device.h>
 21 #include <linux/regulator/driver.h>
 22 #include <linux/regulator/machine.h>
 23 #include <linux/regulator/of_regulator.h>
 24 #include <linux/mfd/abx500.h>
 25 #include <linux/mfd/abx500/ab8500.h>
 26 #include <linux/regulator/ab8500.h>
 27 
 28 /**
 29  * struct ab8500_ext_regulator_info - ab8500 regulator information
 30  * @dev: device pointer
 31  * @desc: regulator description
 32  * @rdev: regulator device
 33  * @cfg: regulator configuration (extension of regulator FW configuration)
 34  * @update_bank: bank to control on/off
 35  * @update_reg: register to control on/off
 36  * @update_mask: mask to enable/disable and set mode of regulator
 37  * @update_val: bits holding the regulator current mode
 38  * @update_val_hp: bits to set EN pin active (LPn pin deactive)
 39  *                 normally this means high power mode
 40  * @update_val_lp: bits to set EN pin active and LPn pin active
 41  *                 normally this means low power mode
 42  * @update_val_hw: bits to set regulator pins in HW control
 43  *                 SysClkReq pins and logic will choose mode
 44  */
 45 struct ab8500_ext_regulator_info {
 46         struct device *dev;
 47         struct regulator_desc desc;
 48         struct regulator_dev *rdev;
 49         struct ab8500_ext_regulator_cfg *cfg;
 50         u8 update_bank;
 51         u8 update_reg;
 52         u8 update_mask;
 53         u8 update_val;
 54         u8 update_val_hp;
 55         u8 update_val_lp;
 56         u8 update_val_hw;
 57 };
 58 
 59 static int ab8500_ext_regulator_enable(struct regulator_dev *rdev)
 60 {
 61         int ret;
 62         struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
 63         u8 regval;
 64 
 65         if (info == NULL) {
 66                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
 67                 return -EINVAL;
 68         }
 69 
 70         /*
 71          * To satisfy both HW high power request and SW request, the regulator
 72          * must be on in high power.
 73          */
 74         if (info->cfg && info->cfg->hwreq)
 75                 regval = info->update_val_hp;
 76         else
 77                 regval = info->update_val;
 78 
 79         ret = abx500_mask_and_set_register_interruptible(info->dev,
 80                 info->update_bank, info->update_reg,
 81                 info->update_mask, regval);
 82         if (ret < 0) {
 83                 dev_err(rdev_get_dev(info->rdev),
 84                         "couldn't set enable bits for regulator\n");
 85                 return ret;
 86         }
 87 
 88         dev_dbg(rdev_get_dev(rdev),
 89                 "%s-enable (bank, reg, mask, value): 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
 90                 info->desc.name, info->update_bank, info->update_reg,
 91                 info->update_mask, regval);
 92 
 93         return 0;
 94 }
 95 
 96 static int ab8500_ext_regulator_disable(struct regulator_dev *rdev)
 97 {
 98         int ret;
 99         struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
100         u8 regval;
101 
102         if (info == NULL) {
103                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
104                 return -EINVAL;
105         }
106 
107         /*
108          * Set the regulator in HW request mode if configured
109          */
110         if (info->cfg && info->cfg->hwreq)
111                 regval = info->update_val_hw;
112         else
113                 regval = 0;
114 
115         ret = abx500_mask_and_set_register_interruptible(info->dev,
116                 info->update_bank, info->update_reg,
117                 info->update_mask, regval);
118         if (ret < 0) {
119                 dev_err(rdev_get_dev(info->rdev),
120                         "couldn't set disable bits for regulator\n");
121                 return ret;
122         }
123 
124         dev_dbg(rdev_get_dev(rdev), "%s-disable (bank, reg, mask, value):"
125                 " 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
126                 info->desc.name, info->update_bank, info->update_reg,
127                 info->update_mask, regval);
128 
129         return 0;
130 }
131 
132 static int ab8500_ext_regulator_is_enabled(struct regulator_dev *rdev)
133 {
134         int ret;
135         struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
136         u8 regval;
137 
138         if (info == NULL) {
139                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
140                 return -EINVAL;
141         }
142 
143         ret = abx500_get_register_interruptible(info->dev,
144                 info->update_bank, info->update_reg, &regval);
145         if (ret < 0) {
146                 dev_err(rdev_get_dev(rdev),
147                         "couldn't read 0x%x register\n", info->update_reg);
148                 return ret;
149         }
150 
151         dev_dbg(rdev_get_dev(rdev), "%s-is_enabled (bank, reg, mask, value):"
152                 " 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
153                 info->desc.name, info->update_bank, info->update_reg,
154                 info->update_mask, regval);
155 
156         if (((regval & info->update_mask) == info->update_val_lp) ||
157             ((regval & info->update_mask) == info->update_val_hp))
158                 return 1;
159         else
160                 return 0;
161 }
162 
163 static int ab8500_ext_regulator_set_mode(struct regulator_dev *rdev,
164                                          unsigned int mode)
165 {
166         int ret = 0;
167         struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
168         u8 regval;
169 
170         if (info == NULL) {
171                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
172                 return -EINVAL;
173         }
174 
175         switch (mode) {
176         case REGULATOR_MODE_NORMAL:
177                 regval = info->update_val_hp;
178                 break;
179         case REGULATOR_MODE_IDLE:
180                 regval = info->update_val_lp;
181                 break;
182 
183         default:
184                 return -EINVAL;
185         }
186 
187         /* If regulator is enabled and info->cfg->hwreq is set, the regulator
188            must be on in high power, so we don't need to write the register with
189            the same value.
190          */
191         if (ab8500_ext_regulator_is_enabled(rdev) &&
192             !(info->cfg && info->cfg->hwreq)) {
193                 ret = abx500_mask_and_set_register_interruptible(info->dev,
194                                         info->update_bank, info->update_reg,
195                                         info->update_mask, regval);
196                 if (ret < 0) {
197                         dev_err(rdev_get_dev(rdev),
198                                 "Could not set regulator mode.\n");
199                         return ret;
200                 }
201 
202                 dev_dbg(rdev_get_dev(rdev),
203                         "%s-set_mode (bank, reg, mask, value): "
204                         "0x%x, 0x%x, 0x%x, 0x%x\n",
205                         info->desc.name, info->update_bank, info->update_reg,
206                         info->update_mask, regval);
207         }
208 
209         info->update_val = regval;
210 
211         return 0;
212 }
213 
214 static unsigned int ab8500_ext_regulator_get_mode(struct regulator_dev *rdev)
215 {
216         struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev);
217         int ret;
218 
219         if (info == NULL) {
220                 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
221                 return -EINVAL;
222         }
223 
224         if (info->update_val == info->update_val_hp)
225                 ret = REGULATOR_MODE_NORMAL;
226         else if (info->update_val == info->update_val_lp)
227                 ret = REGULATOR_MODE_IDLE;
228         else
229                 ret = -EINVAL;
230 
231         return ret;
232 }
233 
234 static int ab8500_ext_set_voltage(struct regulator_dev *rdev, int min_uV,
235                                   int max_uV, unsigned *selector)
236 {
237         struct regulation_constraints *regu_constraints = rdev->constraints;
238 
239         if (!regu_constraints) {
240                 dev_err(rdev_get_dev(rdev), "No regulator constraints\n");
241                 return -EINVAL;
242         }
243 
244         if (regu_constraints->min_uV == min_uV &&
245             regu_constraints->max_uV == max_uV)
246                 return 0;
247 
248         dev_err(rdev_get_dev(rdev),
249                 "Requested min %duV max %duV != constrained min %duV max %duV\n",
250                 min_uV, max_uV,
251                 regu_constraints->min_uV, regu_constraints->max_uV);
252 
253         return -EINVAL;
254 }
255 
256 static int ab8500_ext_list_voltage(struct regulator_dev *rdev,
257                                    unsigned selector)
258 {
259         struct regulation_constraints *regu_constraints = rdev->constraints;
260 
261         if (regu_constraints == NULL) {
262                 dev_err(rdev_get_dev(rdev), "regulator constraints null pointer\n");
263                 return -EINVAL;
264         }
265         /* return the uV for the fixed regulators */
266         if (regu_constraints->min_uV && regu_constraints->max_uV) {
267                 if (regu_constraints->min_uV == regu_constraints->max_uV)
268                         return regu_constraints->min_uV;
269         }
270         return -EINVAL;
271 }
272 
273 static struct regulator_ops ab8500_ext_regulator_ops = {
274         .enable                 = ab8500_ext_regulator_enable,
275         .disable                = ab8500_ext_regulator_disable,
276         .is_enabled             = ab8500_ext_regulator_is_enabled,
277         .set_mode               = ab8500_ext_regulator_set_mode,
278         .get_mode               = ab8500_ext_regulator_get_mode,
279         .set_voltage            = ab8500_ext_set_voltage,
280         .list_voltage           = ab8500_ext_list_voltage,
281 };
282 
283 static struct ab8500_ext_regulator_info
284                 ab8500_ext_regulator_info[AB8500_NUM_EXT_REGULATORS] = {
285         [AB8500_EXT_SUPPLY1] = {
286                 .desc = {
287                         .name           = "VEXTSUPPLY1",
288                         .ops            = &ab8500_ext_regulator_ops,
289                         .type           = REGULATOR_VOLTAGE,
290                         .id             = AB8500_EXT_SUPPLY1,
291                         .owner          = THIS_MODULE,
292                         .n_voltages     = 1,
293                 },
294                 .update_bank            = 0x04,
295                 .update_reg             = 0x08,
296                 .update_mask            = 0x03,
297                 .update_val             = 0x01,
298                 .update_val_hp          = 0x01,
299                 .update_val_lp          = 0x03,
300                 .update_val_hw          = 0x02,
301         },
302         [AB8500_EXT_SUPPLY2] = {
303                 .desc = {
304                         .name           = "VEXTSUPPLY2",
305                         .ops            = &ab8500_ext_regulator_ops,
306                         .type           = REGULATOR_VOLTAGE,
307                         .id             = AB8500_EXT_SUPPLY2,
308                         .owner          = THIS_MODULE,
309                         .n_voltages     = 1,
310                 },
311                 .update_bank            = 0x04,
312                 .update_reg             = 0x08,
313                 .update_mask            = 0x0c,
314                 .update_val             = 0x04,
315                 .update_val_hp          = 0x04,
316                 .update_val_lp          = 0x0c,
317                 .update_val_hw          = 0x08,
318         },
319         [AB8500_EXT_SUPPLY3] = {
320                 .desc = {
321                         .name           = "VEXTSUPPLY3",
322                         .ops            = &ab8500_ext_regulator_ops,
323                         .type           = REGULATOR_VOLTAGE,
324                         .id             = AB8500_EXT_SUPPLY3,
325                         .owner          = THIS_MODULE,
326                         .n_voltages     = 1,
327                 },
328                 .update_bank            = 0x04,
329                 .update_reg             = 0x08,
330                 .update_mask            = 0x30,
331                 .update_val             = 0x10,
332                 .update_val_hp          = 0x10,
333                 .update_val_lp          = 0x30,
334                 .update_val_hw          = 0x20,
335         },
336 };
337 
338 static struct of_regulator_match ab8500_ext_regulator_match[] = {
339         { .name = "ab8500_ext1", .driver_data = (void *) AB8500_EXT_SUPPLY1, },
340         { .name = "ab8500_ext2", .driver_data = (void *) AB8500_EXT_SUPPLY2, },
341         { .name = "ab8500_ext3", .driver_data = (void *) AB8500_EXT_SUPPLY3, },
342 };
343 
344 static int ab8500_ext_regulator_probe(struct platform_device *pdev)
345 {
346         struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
347         struct ab8500_platform_data *ppdata;
348         struct ab8500_regulator_platform_data *pdata;
349         struct device_node *np = pdev->dev.of_node;
350         struct regulator_config config = { };
351         int i, err;
352 
353         if (np) {
354                 err = of_regulator_match(&pdev->dev, np,
355                                          ab8500_ext_regulator_match,
356                                          ARRAY_SIZE(ab8500_ext_regulator_match));
357                 if (err < 0) {
358                         dev_err(&pdev->dev,
359                                 "Error parsing regulator init data: %d\n", err);
360                         return err;
361                 }
362         }
363 
364         if (!ab8500) {
365                 dev_err(&pdev->dev, "null mfd parent\n");
366                 return -EINVAL;
367         }
368 
369         ppdata = dev_get_platdata(ab8500->dev);
370         if (!ppdata) {
371                 dev_err(&pdev->dev, "null parent pdata\n");
372                 return -EINVAL;
373         }
374 
375         pdata = ppdata->regulator;
376         if (!pdata) {
377                 dev_err(&pdev->dev, "null pdata\n");
378                 return -EINVAL;
379         }
380 
381         /* make sure the platform data has the correct size */
382         if (pdata->num_ext_regulator != ARRAY_SIZE(ab8500_ext_regulator_info)) {
383                 dev_err(&pdev->dev, "Configuration error: size mismatch.\n");
384                 return -EINVAL;
385         }
386 
387         /* check for AB8500 2.x */
388         if (is_ab8500_2p0_or_earlier(ab8500)) {
389                 struct ab8500_ext_regulator_info *info;
390 
391                 /* VextSupply3LPn is inverted on AB8500 2.x */
392                 info = &ab8500_ext_regulator_info[AB8500_EXT_SUPPLY3];
393                 info->update_val = 0x30;
394                 info->update_val_hp = 0x30;
395                 info->update_val_lp = 0x10;
396         }
397 
398         /* register all regulators */
399         for (i = 0; i < ARRAY_SIZE(ab8500_ext_regulator_info); i++) {
400                 struct ab8500_ext_regulator_info *info = NULL;
401 
402                 /* assign per-regulator data */
403                 info = &ab8500_ext_regulator_info[i];
404                 info->dev = &pdev->dev;
405                 info->cfg = (struct ab8500_ext_regulator_cfg *)
406                         pdata->ext_regulator[i].driver_data;
407 
408                 config.dev = &pdev->dev;
409                 config.driver_data = info;
410                 config.of_node = ab8500_ext_regulator_match[i].of_node;
411                 config.init_data = (np) ?
412                         ab8500_ext_regulator_match[i].init_data :
413                         &pdata->ext_regulator[i];
414 
415                 /* register regulator with framework */
416                 info->rdev = devm_regulator_register(&pdev->dev, &info->desc,
417                                                      &config);
418                 if (IS_ERR(info->rdev)) {
419                         err = PTR_ERR(info->rdev);
420                         dev_err(&pdev->dev, "failed to register regulator %s\n",
421                                         info->desc.name);
422                         return err;
423                 }
424 
425                 dev_dbg(rdev_get_dev(info->rdev),
426                         "%s-probed\n", info->desc.name);
427         }
428 
429         return 0;
430 }
431 
432 static struct platform_driver ab8500_ext_regulator_driver = {
433         .probe = ab8500_ext_regulator_probe,
434         .driver         = {
435                 .name   = "ab8500-ext-regulator",
436                 .owner  = THIS_MODULE,
437         },
438 };
439 
440 static int __init ab8500_ext_regulator_init(void)
441 {
442         int ret;
443 
444         ret = platform_driver_register(&ab8500_ext_regulator_driver);
445         if (ret)
446                 pr_err("Failed to register ab8500 ext regulator: %d\n", ret);
447 
448         return ret;
449 }
450 subsys_initcall(ab8500_ext_regulator_init);
451 
452 static void __exit ab8500_ext_regulator_exit(void)
453 {
454         platform_driver_unregister(&ab8500_ext_regulator_driver);
455 }
456 module_exit(ab8500_ext_regulator_exit);
457 
458 MODULE_LICENSE("GPL v2");
459 MODULE_AUTHOR("Bengt Jonsson <bengt.g.jonsson@stericsson.com>");
460 MODULE_DESCRIPTION("AB8500 external regulator driver");
461 MODULE_ALIAS("platform:ab8500-ext-regulator");
462 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us