Root/
1 | /* |
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 */ |
48 | static const int da9055_current_limits[] = { 500000, 600000, 700000, 800000 }; |
49 | |
50 | struct da9055_conf_reg { |
51 | int reg; |
52 | int sel_mask; |
53 | int en_mask; |
54 | }; |
55 | |
56 | struct da9055_volt_reg { |
57 | int reg_a; |
58 | int reg_b; |
59 | int sl_shift; |
60 | int v_mask; |
61 | }; |
62 | |
63 | struct da9055_mode_reg { |
64 | int reg; |
65 | int mask; |
66 | int shift; |
67 | }; |
68 | |
69 | struct 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 | |
76 | struct 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 | |
83 | static 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 | |
108 | static 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 | |
131 | static 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 | |
147 | static 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 | |
169 | static 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 | |
183 | static 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; |
188 | int i; |
189 | |
190 | 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); |
197 | } |
198 | |
199 | return -EINVAL; |
200 | } |
201 | |
202 | static 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); |
230 | return sel; |
231 | } |
232 | |
233 | static 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 */ |
252 | return da9055_reg_update(regulator->da9055, info->volt.reg_a, |
253 | info->volt.v_mask, selector); |
254 | } |
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) |
269 | return da9055_reg_update(regulator->da9055, info->volt.reg_a, |
270 | info->volt.v_mask, selector); |
271 | else |
272 | return da9055_reg_update(regulator->da9055, info->volt.reg_b, |
273 | info->volt.v_mask, selector); |
274 | } |
275 | |
276 | static 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 | |
291 | ret = regulator_map_voltage_linear(rdev, uV, uV); |
292 | if (ret < 0) |
293 | return ret; |
294 | |
295 | return da9055_reg_update(regulator->da9055, info->volt.reg_b, |
296 | info->volt.v_mask, ret); |
297 | } |
298 | |
299 | static 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 | |
312 | static 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 | |
325 | static 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, |
334 | .list_voltage = regulator_list_voltage_linear, |
335 | .map_voltage = regulator_map_voltage_linear, |
336 | .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 | |
346 | static 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, |
352 | .list_voltage = regulator_list_voltage_linear, |
353 | .map_voltage = regulator_map_voltage_linear, |
354 | .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,\ |
372 | .n_voltages = (max - min) / step + 1 + (voffset), \ |
373 | .enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \ |
374 | .enable_mask = 1, \ |
375 | .min_uV = (min) * 1000,\ |
376 | .uV_step = (step) * 1000,\ |
377 | .linear_min_sel = (voffset),\ |
378 | .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,\ |
389 | .v_mask = (1 << (vbits)) - 1,\ |
390 | },\ |
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,\ |
400 | .n_voltages = (max - min) / step + 1 + (voffset), \ |
401 | .enable_reg = DA9055_REG_BCORE_CONT + DA9055_ID_##_id, \ |
402 | .enable_mask = 1,\ |
403 | .min_uV = (min) * 1000,\ |
404 | .uV_step = (step) * 1000,\ |
405 | .linear_min_sel = (voffset),\ |
406 | .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,\ |
417 | .v_mask = (1 << (vbits)) - 1,\ |
418 | },\ |
419 | .mode = {\ |
420 | .reg = DA9055_REG_BCORE_MODE,\ |
421 | .mask = (mbits),\ |
422 | .shift = (sbits),\ |
423 | },\ |
424 | } |
425 | |
426 | static 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 | */ |
442 | static int da9055_gpio_init(struct da9055_regulator *regulator, |
443 | struct regulator_config *config, |
444 | struct da9055_pdata *pdata, int id) |
445 | { |
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 | |
479 | if (pdata->gpio_rsel && pdata->gpio_rsel[id]) { |
480 | 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 | |
505 | err: |
506 | return ret; |
507 | } |
508 | |
509 | static 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 | |
519 | static 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 | |
533 | static int da9055_regulator_probe(struct platform_device *pdev) |
534 | { |
535 | struct regulator_config config = { }; |
536 | struct da9055_regulator *regulator; |
537 | struct da9055 *da9055 = dev_get_drvdata(pdev->dev.parent); |
538 | struct da9055_pdata *pdata = da9055->dev->platform_data; |
539 | 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 | |
567 | regulator->rdev = regulator_register(®ulator->info->reg_desc, |
568 | &config); |
569 | if (IS_ERR(regulator->rdev)) { |
570 | dev_err(&pdev->dev, "Failed to register regulator %s\n", |
571 | regulator->info->reg_desc.name); |
572 | ret = PTR_ERR(regulator->rdev); |
573 | return ret; |
574 | } |
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); |
591 | goto err_regulator; |
592 | } |
593 | } |
594 | } |
595 | |
596 | platform_set_drvdata(pdev, regulator); |
597 | |
598 | return 0; |
599 | |
600 | err_regulator: |
601 | regulator_unregister(regulator->rdev); |
602 | return ret; |
603 | } |
604 | |
605 | static int da9055_regulator_remove(struct platform_device *pdev) |
606 | { |
607 | struct da9055_regulator *regulator = platform_get_drvdata(pdev); |
608 | |
609 | regulator_unregister(regulator->rdev); |
610 | |
611 | return 0; |
612 | } |
613 | |
614 | static struct platform_driver da9055_regulator_driver = { |
615 | .probe = da9055_regulator_probe, |
616 | .remove = da9055_regulator_remove, |
617 | .driver = { |
618 | .name = "da9055-regulator", |
619 | .owner = THIS_MODULE, |
620 | }, |
621 | }; |
622 | |
623 | static int __init da9055_regulator_init(void) |
624 | { |
625 | return platform_driver_register(&da9055_regulator_driver); |
626 | } |
627 | subsys_initcall(da9055_regulator_init); |
628 | |
629 | static void __exit da9055_regulator_exit(void) |
630 | { |
631 | platform_driver_unregister(&da9055_regulator_driver); |
632 | } |
633 | module_exit(da9055_regulator_exit); |
634 | |
635 | MODULE_AUTHOR("David Dajun Chen <dchen@diasemi.com>"); |
636 | MODULE_DESCRIPTION("Power Regulator driver for Dialog DA9055 PMIC"); |
637 | MODULE_LICENSE("GPL"); |
638 | MODULE_ALIAS("platform:da9055-regulator"); |
639 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9