blob: 7f340206d329d452710a319deba4869a2d6c603b [file] [log] [blame]
Ashish Jangamf6130be2012-11-01 13:57:56 +05301/*
2* Regulator driver for DA9055 PMIC
3*
4* Copyright(c) 2012 Dialog Semiconductor Ltd.
5*
6* Author: David Dajun Chen <dchen@diasemi.com>
7*
8* This program is free software; you can redistribute it and/or modify
9* it under the terms of the GNU General Public License as published by
10* the Free Software Foundation; either version 2 of the License, or
11* (at your option) any later version.
12*
13*/
14
15#include <linux/module.h>
16#include <linux/init.h>
17#include <linux/err.h>
18#include <linux/gpio.h>
19#include <linux/platform_device.h>
20#include <linux/regulator/driver.h>
21#include <linux/regulator/machine.h>
22
23#include <linux/mfd/da9055/core.h>
24#include <linux/mfd/da9055/reg.h>
25#include <linux/mfd/da9055/pdata.h>
26
27#define DA9055_MIN_UA 0
28#define DA9055_MAX_UA 3
29
30#define DA9055_LDO_MODE_SYNC 0
31#define DA9055_LDO_MODE_SLEEP 1
32
33#define DA9055_BUCK_MODE_SLEEP 1
34#define DA9055_BUCK_MODE_SYNC 2
35#define DA9055_BUCK_MODE_AUTO 3
36
37/* DA9055 REGULATOR IDs */
38#define DA9055_ID_BUCK1 0
39#define DA9055_ID_BUCK2 1
40#define DA9055_ID_LDO1 2
41#define DA9055_ID_LDO2 3
42#define DA9055_ID_LDO3 4
43#define DA9055_ID_LDO4 5
44#define DA9055_ID_LDO5 6
45#define DA9055_ID_LDO6 7
46
47/* DA9055 BUCK current limit */
48static const int da9055_current_limits[] = { 500000, 600000, 700000, 800000 };
49
50struct da9055_conf_reg {
51 int reg;
52 int sel_mask;
53 int en_mask;
54};
55
56struct da9055_volt_reg {
57 int reg_a;
58 int reg_b;
59 int sl_shift;
Ashish Jangamf6130be2012-11-01 13:57:56 +053060 int v_mask;
Ashish Jangamf6130be2012-11-01 13:57:56 +053061};
62
63struct da9055_mode_reg {
64 int reg;
65 int mask;
66 int shift;
67};
68
69struct da9055_regulator_info {
70 struct regulator_desc reg_desc;
71 struct da9055_conf_reg conf;
72 struct da9055_volt_reg volt;
73 struct da9055_mode_reg mode;
74};
75
76struct da9055_regulator {
77 struct da9055 *da9055;
78 struct da9055_regulator_info *info;
79 struct regulator_dev *rdev;
80 enum gpio_select reg_rselect;
81};
82
83static unsigned int da9055_buck_get_mode(struct regulator_dev *rdev)
84{
85 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
86 struct da9055_regulator_info *info = regulator->info;
87 int ret, mode = 0;
88
89 ret = da9055_reg_read(regulator->da9055, info->mode.reg);
90 if (ret < 0)
91 return ret;
92
93 switch ((ret & info->mode.mask) >> info->mode.shift) {
94 case DA9055_BUCK_MODE_SYNC:
95 mode = REGULATOR_MODE_FAST;
96 break;
97 case DA9055_BUCK_MODE_AUTO:
98 mode = REGULATOR_MODE_NORMAL;
99 break;
100 case DA9055_BUCK_MODE_SLEEP:
101 mode = REGULATOR_MODE_STANDBY;
102 break;
103 }
104
105 return mode;
106}
107
108static int da9055_buck_set_mode(struct regulator_dev *rdev,
109 unsigned int mode)
110{
111 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
112 struct da9055_regulator_info *info = regulator->info;
113 int val = 0;
114
115 switch (mode) {
116 case REGULATOR_MODE_FAST:
117 val = DA9055_BUCK_MODE_SYNC << info->mode.shift;
118 break;
119 case REGULATOR_MODE_NORMAL:
120 val = DA9055_BUCK_MODE_AUTO << info->mode.shift;
121 break;
122 case REGULATOR_MODE_STANDBY:
123 val = DA9055_BUCK_MODE_SLEEP << info->mode.shift;
124 break;
125 }
126
127 return da9055_reg_update(regulator->da9055, info->mode.reg,
128 info->mode.mask, val);
129}
130
131static unsigned int da9055_ldo_get_mode(struct regulator_dev *rdev)
132{
133 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
134 struct da9055_regulator_info *info = regulator->info;
135 int ret;
136
137 ret = da9055_reg_read(regulator->da9055, info->volt.reg_b);
138 if (ret < 0)
139 return ret;
140
141 if (ret >> info->volt.sl_shift)
142 return REGULATOR_MODE_STANDBY;
143 else
144 return REGULATOR_MODE_NORMAL;
145}
146
147static int da9055_ldo_set_mode(struct regulator_dev *rdev, unsigned int mode)
148{
149 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
150 struct da9055_regulator_info *info = regulator->info;
151 struct da9055_volt_reg volt = info->volt;
152 int val = 0;
153
154 switch (mode) {
155 case REGULATOR_MODE_NORMAL:
156 case REGULATOR_MODE_FAST:
157 val = DA9055_LDO_MODE_SYNC;
158 break;
159 case REGULATOR_MODE_STANDBY:
160 val = DA9055_LDO_MODE_SLEEP;
161 break;
162 }
163
164 return da9055_reg_update(regulator->da9055, volt.reg_b,
165 1 << volt.sl_shift,
166 val << volt.sl_shift);
167}
168
169static int da9055_buck_get_current_limit(struct regulator_dev *rdev)
170{
171 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
172 struct da9055_regulator_info *info = regulator->info;
173 int ret;
174
175 ret = da9055_reg_read(regulator->da9055, DA9055_REG_BUCK_LIM);
176 if (ret < 0)
177 return ret;
178
179 ret &= info->mode.mask;
180 return da9055_current_limits[ret >> info->mode.shift];
181}
182
183static int da9055_buck_set_current_limit(struct regulator_dev *rdev, int min_uA,
184 int max_uA)
185{
186 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
187 struct da9055_regulator_info *info = regulator->info;
Axel Linf509fd42012-11-26 15:26:41 +0800188 int i;
Ashish Jangamf6130be2012-11-01 13:57:56 +0530189
Axel Linf509fd42012-11-26 15:26:41 +0800190 for (i = ARRAY_SIZE(da9055_current_limits) - 1; i >= 0; i--) {
191 if ((min_uA <= da9055_current_limits[i]) &&
192 (da9055_current_limits[i] <= max_uA))
193 return da9055_reg_update(regulator->da9055,
194 DA9055_REG_BUCK_LIM,
195 info->mode.mask,
196 i << info->mode.shift);
Ashish Jangamf6130be2012-11-01 13:57:56 +0530197 }
198
Axel Linf509fd42012-11-26 15:26:41 +0800199 return -EINVAL;
Ashish Jangamf6130be2012-11-01 13:57:56 +0530200}
201
202static int da9055_regulator_get_voltage_sel(struct regulator_dev *rdev)
203{
204 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
205 struct da9055_regulator_info *info = regulator->info;
206 struct da9055_volt_reg volt = info->volt;
207 int ret, sel;
208
209 /*
210 * There are two voltage register set A & B for voltage ramping but
211 * either one of then can be active therefore we first determine
212 * the active register set.
213 */
214 ret = da9055_reg_read(regulator->da9055, info->conf.reg);
215 if (ret < 0)
216 return ret;
217
218 ret &= info->conf.sel_mask;
219
220 /* Get the voltage for the active register set A/B */
221 if (ret == DA9055_REGUALTOR_SET_A)
222 ret = da9055_reg_read(regulator->da9055, volt.reg_a);
223 else
224 ret = da9055_reg_read(regulator->da9055, volt.reg_b);
225
226 if (ret < 0)
227 return ret;
228
229 sel = (ret & volt.v_mask);
Axel Lin6b1f8a42012-11-27 10:26:14 +0800230 return sel;
Ashish Jangamf6130be2012-11-01 13:57:56 +0530231}
232
Ashish Jangamf6130be2012-11-01 13:57:56 +0530233static int da9055_regulator_set_voltage_sel(struct regulator_dev *rdev,
234 unsigned int selector)
235{
236 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
237 struct da9055_regulator_info *info = regulator->info;
238 int ret;
239
240 /*
241 * Regulator register set A/B is not selected through GPIO therefore
242 * we use default register set A for voltage ramping.
243 */
244 if (regulator->reg_rselect == NO_GPIO) {
245 /* Select register set A */
246 ret = da9055_reg_update(regulator->da9055, info->conf.reg,
247 info->conf.sel_mask, DA9055_SEL_REG_A);
248 if (ret < 0)
249 return ret;
250
251 /* Set the voltage */
Axel Lin369cf602012-11-20 15:36:46 +0800252 return da9055_reg_update(regulator->da9055, info->volt.reg_a,
253 info->volt.v_mask, selector);
Ashish Jangamf6130be2012-11-01 13:57:56 +0530254 }
255
256 /*
257 * Here regulator register set A/B is selected through GPIO.
258 * Therefore we first determine the selected register set A/B and
259 * then set the desired voltage for that register set A/B.
260 */
261 ret = da9055_reg_read(regulator->da9055, info->conf.reg);
262 if (ret < 0)
263 return ret;
264
265 ret &= info->conf.sel_mask;
266
267 /* Set the voltage */
268 if (ret == DA9055_REGUALTOR_SET_A)
Axel Lin369cf602012-11-20 15:36:46 +0800269 return da9055_reg_update(regulator->da9055, info->volt.reg_a,
270 info->volt.v_mask, selector);
Ashish Jangamf6130be2012-11-01 13:57:56 +0530271 else
Axel Lin369cf602012-11-20 15:36:46 +0800272 return da9055_reg_update(regulator->da9055, info->volt.reg_b,
273 info->volt.v_mask, selector);
Ashish Jangamf6130be2012-11-01 13:57:56 +0530274}
275
276static int da9055_regulator_set_suspend_voltage(struct regulator_dev *rdev,
277 int uV)
278{
279 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
280 struct da9055_regulator_info *info = regulator->info;
281 int ret;
282
283 /* Select register set B for suspend voltage ramping. */
284 if (regulator->reg_rselect == NO_GPIO) {
285 ret = da9055_reg_update(regulator->da9055, info->conf.reg,
286 info->conf.sel_mask, DA9055_SEL_REG_B);
287 if (ret < 0)
288 return ret;
289 }
290
Axel Lin6b1f8a42012-11-27 10:26:14 +0800291 ret = regulator_map_voltage_linear(rdev, uV, uV);
Ashish Jangamf6130be2012-11-01 13:57:56 +0530292 if (ret < 0)
293 return ret;
294
Axel Lin369cf602012-11-20 15:36:46 +0800295 return da9055_reg_update(regulator->da9055, info->volt.reg_b,
296 info->volt.v_mask, ret);
Ashish Jangamf6130be2012-11-01 13:57:56 +0530297}
298
299static int da9055_suspend_enable(struct regulator_dev *rdev)
300{
301 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
302 struct da9055_regulator_info *info = regulator->info;
303
304 /* Select register set B for voltage ramping. */
305 if (regulator->reg_rselect == NO_GPIO)
306 return da9055_reg_update(regulator->da9055, info->conf.reg,
307 info->conf.sel_mask, DA9055_SEL_REG_B);
308 else
309 return 0;
310}
311
312static int da9055_suspend_disable(struct regulator_dev *rdev)
313{
314 struct da9055_regulator *regulator = rdev_get_drvdata(rdev);
315 struct da9055_regulator_info *info = regulator->info;
316
317 /* Diselect register set B. */
318 if (regulator->reg_rselect == NO_GPIO)
319 return da9055_reg_update(regulator->da9055, info->conf.reg,
320 info->conf.sel_mask, DA9055_SEL_REG_A);
321 else
322 return 0;
323}
324
325static struct regulator_ops da9055_buck_ops = {
326 .get_mode = da9055_buck_get_mode,
327 .set_mode = da9055_buck_set_mode,
328
329 .get_current_limit = da9055_buck_get_current_limit,
330 .set_current_limit = da9055_buck_set_current_limit,
331
332 .get_voltage_sel = da9055_regulator_get_voltage_sel,
333 .set_voltage_sel = da9055_regulator_set_voltage_sel,
Axel Lin6b1f8a42012-11-27 10:26:14 +0800334 .list_voltage = regulator_list_voltage_linear,
335 .map_voltage = regulator_map_voltage_linear,
Ashish Jangamf6130be2012-11-01 13:57:56 +0530336 .is_enabled = regulator_is_enabled_regmap,
337 .enable = regulator_enable_regmap,
338 .disable = regulator_disable_regmap,
339
340 .set_suspend_voltage = da9055_regulator_set_suspend_voltage,
341 .set_suspend_enable = da9055_suspend_enable,
342 .set_suspend_disable = da9055_suspend_disable,
343 .set_suspend_mode = da9055_buck_set_mode,
344};
345
346static struct regulator_ops da9055_ldo_ops = {
347 .get_mode = da9055_ldo_get_mode,
348 .set_mode = da9055_ldo_set_mode,
349
350 .get_voltage_sel = da9055_regulator_get_voltage_sel,
351 .set_voltage_sel = da9055_regulator_set_voltage_sel,
Axel Lin6b1f8a42012-11-27 10:26:14 +0800352 .list_voltage = regulator_list_voltage_linear,
353 .map_voltage = regulator_map_voltage_linear,
Ashish Jangamf6130be2012-11-01 13:57:56 +0530354 .is_enabled = regulator_is_enabled_regmap,
355 .enable = regulator_enable_regmap,
356 .disable = regulator_disable_regmap,
357
358 .set_suspend_voltage = da9055_regulator_set_suspend_voltage,
359 .set_suspend_enable = da9055_suspend_enable,
360 .set_suspend_disable = da9055_suspend_disable,
361 .set_suspend_mode = da9055_ldo_set_mode,
362
363};
364
365#define DA9055_LDO(_id, step, min, max, vbits, voffset) \
366{\
367 .reg_desc = {\
368 .name = #_id,\
369 .ops = &da9055_ldo_ops,\
370 .type = REGULATOR_VOLTAGE,\
371 .id = DA9055_ID_##_id,\
Axel Lin369cf602012-11-20 15:36:46 +0800372 .n_voltages = (max - min) / step + 1 + (voffset), \
Ashish Jangamf6130be2012-11-01 13:57:56 +0530373 .enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
374 .enable_mask = 1, \
375 .min_uV = (min) * 1000,\
376 .uV_step = (step) * 1000,\
Axel Lin6b1f8a42012-11-27 10:26:14 +0800377 .linear_min_sel = (voffset),\
Ashish Jangamf6130be2012-11-01 13:57:56 +0530378 .owner = THIS_MODULE,\
379 },\
380 .conf = {\
381 .reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
382 .sel_mask = (1 << 4),\
383 .en_mask = 1,\
384 },\
385 .volt = {\
386 .reg_a = DA9055_REG_VBCORE_A + DA9055_ID_##_id, \
387 .reg_b = DA9055_REG_VBCORE_B + DA9055_ID_##_id, \
388 .sl_shift = 7,\
Ashish Jangamf6130be2012-11-01 13:57:56 +0530389 .v_mask = (1 << (vbits)) - 1,\
Ashish Jangamf6130be2012-11-01 13:57:56 +0530390 },\
391}
392
393#define DA9055_BUCK(_id, step, min, max, vbits, voffset, mbits, sbits) \
394{\
395 .reg_desc = {\
396 .name = #_id,\
397 .ops = &da9055_buck_ops,\
398 .type = REGULATOR_VOLTAGE,\
399 .id = DA9055_ID_##_id,\
Axel Lin369cf602012-11-20 15:36:46 +0800400 .n_voltages = (max - min) / step + 1 + (voffset), \
Ashish Jangamf6130be2012-11-01 13:57:56 +0530401 .enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
402 .enable_mask = 1,\
403 .min_uV = (min) * 1000,\
404 .uV_step = (step) * 1000,\
Axel Lin6b1f8a42012-11-27 10:26:14 +0800405 .linear_min_sel = (voffset),\
Ashish Jangamf6130be2012-11-01 13:57:56 +0530406 .owner = THIS_MODULE,\
407 },\
408 .conf = {\
409 .reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \
410 .sel_mask = (1 << 4),\
411 .en_mask = 1,\
412 },\
413 .volt = {\
414 .reg_a = DA9055_REG_VBCORE_A + DA9055_ID_##_id, \
415 .reg_b = DA9055_REG_VBCORE_B + DA9055_ID_##_id, \
416 .sl_shift = 7,\
Ashish Jangamf6130be2012-11-01 13:57:56 +0530417 .v_mask = (1 << (vbits)) - 1,\
Ashish Jangamf6130be2012-11-01 13:57:56 +0530418 },\
419 .mode = {\
420 .reg = DA9055_REG_BCORE_MODE,\
421 .mask = (mbits),\
422 .shift = (sbits),\
423 },\
424}
425
426static struct da9055_regulator_info da9055_regulator_info[] = {
427 DA9055_BUCK(BUCK1, 25, 725, 2075, 6, 9, 0xc, 2),
428 DA9055_BUCK(BUCK2, 25, 925, 2500, 6, 0, 3, 0),
429 DA9055_LDO(LDO1, 50, 900, 3300, 6, 2),
430 DA9055_LDO(LDO2, 50, 900, 3300, 6, 3),
431 DA9055_LDO(LDO3, 50, 900, 3300, 6, 2),
432 DA9055_LDO(LDO4, 50, 900, 3300, 6, 2),
433 DA9055_LDO(LDO5, 50, 900, 2750, 6, 2),
434 DA9055_LDO(LDO6, 20, 900, 3300, 7, 0),
435};
436
437/*
438 * Configures regulator to be controlled either through GPIO 1 or 2.
439 * GPIO can control regulator state and/or select the regulator register
440 * set A/B for voltage ramping.
441 */
Greg Kroah-Hartman3d68dfe2012-12-21 13:26:06 -0800442static int da9055_gpio_init(struct da9055_regulator *regulator,
443 struct regulator_config *config,
444 struct da9055_pdata *pdata, int id)
Ashish Jangamf6130be2012-11-01 13:57:56 +0530445{
446 struct da9055_regulator_info *info = regulator->info;
447 int ret = 0;
448
449 if (pdata->gpio_ren && pdata->gpio_ren[id]) {
450 char name[18];
451 int gpio_mux = pdata->gpio_ren[id];
452
453 config->ena_gpio = pdata->ena_gpio[id];
454 config->ena_gpio_flags = GPIOF_OUT_INIT_HIGH;
455 config->ena_gpio_invert = 1;
456
457 /*
458 * GPI pin is muxed with regulator to control the
459 * regulator state.
460 */
461 sprintf(name, "DA9055 GPI %d", gpio_mux);
462 ret = devm_gpio_request_one(config->dev, gpio_mux, GPIOF_DIR_IN,
463 name);
464 if (ret < 0)
465 goto err;
466
467 /*
468 * Let the regulator know that its state is controlled
469 * through GPI.
470 */
471 ret = da9055_reg_update(regulator->da9055, info->conf.reg,
472 DA9055_E_GPI_MASK,
473 pdata->reg_ren[id]
474 << DA9055_E_GPI_SHIFT);
475 if (ret < 0)
476 goto err;
477 }
478
Axel Lin26cbd302012-11-16 00:35:14 +0800479 if (pdata->gpio_rsel && pdata->gpio_rsel[id]) {
Ashish Jangamf6130be2012-11-01 13:57:56 +0530480 char name[18];
481 int gpio_mux = pdata->gpio_rsel[id];
482
483 regulator->reg_rselect = pdata->reg_rsel[id];
484
485 /*
486 * GPI pin is muxed with regulator to select the
487 * regulator register set A/B for voltage ramping.
488 */
489 sprintf(name, "DA9055 GPI %d", gpio_mux);
490 ret = devm_gpio_request_one(config->dev, gpio_mux, GPIOF_DIR_IN,
491 name);
492 if (ret < 0)
493 goto err;
494
495 /*
496 * Let the regulator know that its register set A/B
497 * will be selected through GPI for voltage ramping.
498 */
499 ret = da9055_reg_update(regulator->da9055, info->conf.reg,
500 DA9055_V_GPI_MASK,
501 pdata->reg_rsel[id]
502 << DA9055_V_GPI_SHIFT);
503 }
504
505err:
506 return ret;
507}
508
509static irqreturn_t da9055_ldo5_6_oc_irq(int irq, void *data)
510{
511 struct da9055_regulator *regulator = data;
512
513 regulator_notifier_call_chain(regulator->rdev,
514 REGULATOR_EVENT_OVER_CURRENT, NULL);
515
516 return IRQ_HANDLED;
517}
518
519static inline struct da9055_regulator_info *find_regulator_info(int id)
520{
521 struct da9055_regulator_info *info;
522 int i;
523
524 for (i = 0; i < ARRAY_SIZE(da9055_regulator_info); i++) {
525 info = &da9055_regulator_info[i];
526 if (info->reg_desc.id == id)
527 return info;
528 }
529
530 return NULL;
531}
532
Greg Kroah-Hartman3d68dfe2012-12-21 13:26:06 -0800533static int da9055_regulator_probe(struct platform_device *pdev)
Ashish Jangamf6130be2012-11-01 13:57:56 +0530534{
535 struct regulator_config config = { };
536 struct da9055_regulator *regulator;
537 struct da9055 *da9055 = dev_get_drvdata(pdev->dev.parent);
Jingoo Handff91d02013-07-30 17:20:47 +0900538 struct da9055_pdata *pdata = dev_get_platdata(da9055->dev);
Ashish Jangamf6130be2012-11-01 13:57:56 +0530539 int ret, irq;
540
541 if (pdata == NULL || pdata->regulators[pdev->id] == NULL)
542 return -ENODEV;
543
544 regulator = devm_kzalloc(&pdev->dev, sizeof(struct da9055_regulator),
545 GFP_KERNEL);
546 if (!regulator)
547 return -ENOMEM;
548
549 regulator->info = find_regulator_info(pdev->id);
550 if (regulator->info == NULL) {
551 dev_err(&pdev->dev, "invalid regulator ID specified\n");
552 return -EINVAL;
553 }
554
555 regulator->da9055 = da9055;
556 config.dev = &pdev->dev;
557 config.driver_data = regulator;
558 config.regmap = da9055->regmap;
559
560 if (pdata && pdata->regulators)
561 config.init_data = pdata->regulators[pdev->id];
562
563 ret = da9055_gpio_init(regulator, &config, pdata, pdev->id);
564 if (ret < 0)
565 return ret;
566
Axel Lin0d328802013-09-03 14:26:10 +0800567 regulator->rdev = devm_regulator_register(&pdev->dev,
568 &regulator->info->reg_desc,
569 &config);
Ashish Jangamf6130be2012-11-01 13:57:56 +0530570 if (IS_ERR(regulator->rdev)) {
571 dev_err(&pdev->dev, "Failed to register regulator %s\n",
572 regulator->info->reg_desc.name);
Axel Lin0d328802013-09-03 14:26:10 +0800573 return PTR_ERR(regulator->rdev);
Ashish Jangamf6130be2012-11-01 13:57:56 +0530574 }
575
576 /* Only LDO 5 and 6 has got the over current interrupt */
577 if (pdev->id == DA9055_ID_LDO5 || pdev->id == DA9055_ID_LDO6) {
578 irq = platform_get_irq_byname(pdev, "REGULATOR");
579 irq = regmap_irq_get_virq(da9055->irq_data, irq);
580 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
581 da9055_ldo5_6_oc_irq,
582 IRQF_TRIGGER_HIGH |
583 IRQF_ONESHOT |
584 IRQF_PROBE_SHARED,
585 pdev->name, regulator);
586 if (ret != 0) {
587 if (ret != -EBUSY) {
588 dev_err(&pdev->dev,
589 "Failed to request Regulator IRQ %d: %d\n",
590 irq, ret);
Axel Lin0d328802013-09-03 14:26:10 +0800591 return ret;
Ashish Jangamf6130be2012-11-01 13:57:56 +0530592 }
593 }
594 }
595
596 platform_set_drvdata(pdev, regulator);
597
598 return 0;
Ashish Jangamf6130be2012-11-01 13:57:56 +0530599}
600
601static struct platform_driver da9055_regulator_driver = {
602 .probe = da9055_regulator_probe,
Ashish Jangamf6130be2012-11-01 13:57:56 +0530603 .driver = {
604 .name = "da9055-regulator",
605 .owner = THIS_MODULE,
606 },
607};
608
609static int __init da9055_regulator_init(void)
610{
611 return platform_driver_register(&da9055_regulator_driver);
612}
613subsys_initcall(da9055_regulator_init);
614
615static void __exit da9055_regulator_exit(void)
616{
617 platform_driver_unregister(&da9055_regulator_driver);
618}
619module_exit(da9055_regulator_exit);
620
621MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>");
622MODULE_DESCRIPTION("Power Regulator driver for Dialog DA9055 PMIC");
623MODULE_LICENSE("GPL");
624MODULE_ALIAS("platform:da9055-regulator");