blob: de7b9c73e3fa09f3b14db1c5d8949ca99a37c352 [file] [log] [blame]
Mark Brownda091552008-10-10 15:58:15 +01001/*
2 * wm8350.c -- Voltage and current regulation for the Wolfson WM8350 PMIC
3 *
4 * Copyright 2007, 2008 Wolfson Microelectronics PLC.
5 *
6 * Author: Liam Girdwood
7 * linux@wolfsonmicro.com
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
13 */
14
15#include <linux/module.h>
16#include <linux/moduleparam.h>
17#include <linux/init.h>
18#include <linux/bitops.h>
19#include <linux/err.h>
20#include <linux/i2c.h>
21#include <linux/mfd/wm8350/core.h>
22#include <linux/mfd/wm8350/pmic.h>
23#include <linux/platform_device.h>
24#include <linux/regulator/driver.h>
25#include <linux/regulator/machine.h>
26
Mark Brown221a7c72009-03-02 16:32:47 +000027/* Maximum value possible for VSEL */
28#define WM8350_DCDC_MAX_VSEL 0x66
29
Mark Brownda091552008-10-10 15:58:15 +010030/* Microamps */
31static const int isink_cur[] = {
32 4,
33 5,
34 6,
35 7,
36 8,
37 10,
38 11,
39 14,
40 16,
41 19,
42 23,
43 27,
44 32,
45 39,
46 46,
47 54,
48 65,
49 77,
50 92,
51 109,
52 130,
53 154,
54 183,
55 218,
56 259,
57 308,
58 367,
59 436,
60 518,
61 616,
62 733,
63 872,
64 1037,
65 1233,
66 1466,
67 1744,
68 2073,
69 2466,
70 2933,
71 3487,
72 4147,
73 4932,
74 5865,
75 6975,
76 8294,
77 9864,
78 11730,
79 13949,
80 16589,
81 19728,
82 23460,
83 27899,
84 33178,
85 39455,
86 46920,
87 55798,
88 66355,
89 78910,
90 93840,
91 111596,
92 132710,
93 157820,
94 187681,
95 223191
96};
97
98static int get_isink_val(int min_uA, int max_uA, u16 *setting)
99{
100 int i;
101
Axel Lin3a744032012-03-27 15:20:08 +0800102 for (i = 0; i < ARRAY_SIZE(isink_cur); i++) {
Mark Brownda091552008-10-10 15:58:15 +0100103 if (min_uA <= isink_cur[i] && max_uA >= isink_cur[i]) {
104 *setting = i;
105 return 0;
106 }
107 }
108 return -EINVAL;
109}
110
Mark Brownda091552008-10-10 15:58:15 +0100111static int wm8350_isink_set_current(struct regulator_dev *rdev, int min_uA,
112 int max_uA)
113{
114 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
115 int isink = rdev_get_id(rdev);
116 u16 val, setting;
117 int ret;
118
119 ret = get_isink_val(min_uA, max_uA, &setting);
120 if (ret != 0)
121 return ret;
122
123 switch (isink) {
124 case WM8350_ISINK_A:
125 val = wm8350_reg_read(wm8350, WM8350_CURRENT_SINK_DRIVER_A) &
126 ~WM8350_CS1_ISEL_MASK;
127 wm8350_reg_write(wm8350, WM8350_CURRENT_SINK_DRIVER_A,
128 val | setting);
129 break;
130 case WM8350_ISINK_B:
131 val = wm8350_reg_read(wm8350, WM8350_CURRENT_SINK_DRIVER_B) &
132 ~WM8350_CS1_ISEL_MASK;
133 wm8350_reg_write(wm8350, WM8350_CURRENT_SINK_DRIVER_B,
134 val | setting);
135 break;
136 default:
137 return -EINVAL;
138 }
139
140 return 0;
141}
142
143static int wm8350_isink_get_current(struct regulator_dev *rdev)
144{
145 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
146 int isink = rdev_get_id(rdev);
147 u16 val;
148
149 switch (isink) {
150 case WM8350_ISINK_A:
151 val = wm8350_reg_read(wm8350, WM8350_CURRENT_SINK_DRIVER_A) &
152 WM8350_CS1_ISEL_MASK;
153 break;
154 case WM8350_ISINK_B:
155 val = wm8350_reg_read(wm8350, WM8350_CURRENT_SINK_DRIVER_B) &
156 WM8350_CS1_ISEL_MASK;
157 break;
158 default:
159 return 0;
160 }
161
Axel Linfa5a97b2012-03-27 15:21:45 +0800162 return isink_cur[val];
Mark Brownda091552008-10-10 15:58:15 +0100163}
164
165/* turn on ISINK followed by DCDC */
166static int wm8350_isink_enable(struct regulator_dev *rdev)
167{
168 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
169 int isink = rdev_get_id(rdev);
170
171 switch (isink) {
172 case WM8350_ISINK_A:
173 switch (wm8350->pmic.isink_A_dcdc) {
174 case WM8350_DCDC_2:
175 case WM8350_DCDC_5:
176 wm8350_set_bits(wm8350, WM8350_POWER_MGMT_7,
177 WM8350_CS1_ENA);
178 wm8350_set_bits(wm8350, WM8350_CSA_FLASH_CONTROL,
179 WM8350_CS1_DRIVE);
180 wm8350_set_bits(wm8350, WM8350_DCDC_LDO_REQUESTED,
181 1 << (wm8350->pmic.isink_A_dcdc -
182 WM8350_DCDC_1));
183 break;
184 default:
185 return -EINVAL;
186 }
187 break;
188 case WM8350_ISINK_B:
189 switch (wm8350->pmic.isink_B_dcdc) {
190 case WM8350_DCDC_2:
191 case WM8350_DCDC_5:
192 wm8350_set_bits(wm8350, WM8350_POWER_MGMT_7,
193 WM8350_CS2_ENA);
194 wm8350_set_bits(wm8350, WM8350_CSB_FLASH_CONTROL,
195 WM8350_CS2_DRIVE);
196 wm8350_set_bits(wm8350, WM8350_DCDC_LDO_REQUESTED,
197 1 << (wm8350->pmic.isink_B_dcdc -
198 WM8350_DCDC_1));
199 break;
200 default:
201 return -EINVAL;
202 }
203 break;
204 default:
205 return -EINVAL;
206 }
207 return 0;
208}
209
210static int wm8350_isink_disable(struct regulator_dev *rdev)
211{
212 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
213 int isink = rdev_get_id(rdev);
214
215 switch (isink) {
216 case WM8350_ISINK_A:
217 switch (wm8350->pmic.isink_A_dcdc) {
218 case WM8350_DCDC_2:
219 case WM8350_DCDC_5:
220 wm8350_clear_bits(wm8350, WM8350_DCDC_LDO_REQUESTED,
221 1 << (wm8350->pmic.isink_A_dcdc -
222 WM8350_DCDC_1));
223 wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_7,
224 WM8350_CS1_ENA);
225 break;
226 default:
227 return -EINVAL;
228 }
229 break;
230 case WM8350_ISINK_B:
231 switch (wm8350->pmic.isink_B_dcdc) {
232 case WM8350_DCDC_2:
233 case WM8350_DCDC_5:
234 wm8350_clear_bits(wm8350, WM8350_DCDC_LDO_REQUESTED,
235 1 << (wm8350->pmic.isink_B_dcdc -
236 WM8350_DCDC_1));
237 wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_7,
238 WM8350_CS2_ENA);
239 break;
240 default:
241 return -EINVAL;
242 }
243 break;
244 default:
245 return -EINVAL;
246 }
247 return 0;
248}
249
250static int wm8350_isink_is_enabled(struct regulator_dev *rdev)
251{
252 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
253 int isink = rdev_get_id(rdev);
254
255 switch (isink) {
256 case WM8350_ISINK_A:
257 return wm8350_reg_read(wm8350, WM8350_CURRENT_SINK_DRIVER_A) &
258 0x8000;
259 case WM8350_ISINK_B:
260 return wm8350_reg_read(wm8350, WM8350_CURRENT_SINK_DRIVER_B) &
261 0x8000;
262 }
263 return -EINVAL;
264}
265
Mark Brown75c8ac22010-01-04 17:24:01 +0000266static int wm8350_isink_enable_time(struct regulator_dev *rdev)
267{
268 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
269 int isink = rdev_get_id(rdev);
270 int reg;
271
272 switch (isink) {
273 case WM8350_ISINK_A:
274 reg = wm8350_reg_read(wm8350, WM8350_CSA_FLASH_CONTROL);
275 break;
276 case WM8350_ISINK_B:
277 reg = wm8350_reg_read(wm8350, WM8350_CSB_FLASH_CONTROL);
278 break;
279 default:
280 return -EINVAL;
281 }
282
283 if (reg & WM8350_CS1_FLASH_MODE) {
284 switch (reg & WM8350_CS1_ON_RAMP_MASK) {
285 case 0:
286 return 0;
287 case 1:
288 return 1950;
289 case 2:
290 return 3910;
291 case 3:
292 return 7800;
293 }
294 } else {
295 switch (reg & WM8350_CS1_ON_RAMP_MASK) {
296 case 0:
297 return 0;
298 case 1:
299 return 250000;
300 case 2:
301 return 500000;
302 case 3:
303 return 1000000;
304 }
305 }
306
307 return -EINVAL;
308}
309
310
Mark Brownda091552008-10-10 15:58:15 +0100311int wm8350_isink_set_flash(struct wm8350 *wm8350, int isink, u16 mode,
312 u16 trigger, u16 duration, u16 on_ramp, u16 off_ramp,
313 u16 drive)
314{
315 switch (isink) {
316 case WM8350_ISINK_A:
317 wm8350_reg_write(wm8350, WM8350_CSA_FLASH_CONTROL,
318 (mode ? WM8350_CS1_FLASH_MODE : 0) |
319 (trigger ? WM8350_CS1_TRIGSRC : 0) |
320 duration | on_ramp | off_ramp | drive);
321 break;
322 case WM8350_ISINK_B:
323 wm8350_reg_write(wm8350, WM8350_CSB_FLASH_CONTROL,
324 (mode ? WM8350_CS2_FLASH_MODE : 0) |
325 (trigger ? WM8350_CS2_TRIGSRC : 0) |
326 duration | on_ramp | off_ramp | drive);
327 break;
328 default:
329 return -EINVAL;
330 }
331 return 0;
332}
333EXPORT_SYMBOL_GPL(wm8350_isink_set_flash);
334
Mark Brownda091552008-10-10 15:58:15 +0100335static int wm8350_dcdc_set_suspend_voltage(struct regulator_dev *rdev, int uV)
336{
337 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
Axel Linc7057422012-06-12 20:10:26 +0800338 int sel, volt_reg, dcdc = rdev_get_id(rdev);
Mark Brownda091552008-10-10 15:58:15 +0100339 u16 val;
340
Axel Linc7057422012-06-12 20:10:26 +0800341 dev_dbg(wm8350->dev, "%s %d mV %d\n", __func__, dcdc, uV / 1000);
Mark Brownda091552008-10-10 15:58:15 +0100342
343 switch (dcdc) {
344 case WM8350_DCDC_1:
345 volt_reg = WM8350_DCDC1_LOW_POWER;
346 break;
347 case WM8350_DCDC_3:
348 volt_reg = WM8350_DCDC3_LOW_POWER;
349 break;
350 case WM8350_DCDC_4:
351 volt_reg = WM8350_DCDC4_LOW_POWER;
352 break;
353 case WM8350_DCDC_6:
354 volt_reg = WM8350_DCDC6_LOW_POWER;
355 break;
356 case WM8350_DCDC_2:
357 case WM8350_DCDC_5:
358 default:
359 return -EINVAL;
360 }
361
Axel Linc7057422012-06-12 20:10:26 +0800362 sel = regulator_map_voltage_linear(rdev, uV, uV);
363 if (sel < 0)
364 return -EINVAL;
365
Mark Brownda091552008-10-10 15:58:15 +0100366 /* all DCDCs have same mV bits */
367 val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_DC1_VSEL_MASK;
Axel Linc7057422012-06-12 20:10:26 +0800368 wm8350_reg_write(wm8350, volt_reg, val | sel);
Mark Brownda091552008-10-10 15:58:15 +0100369 return 0;
370}
371
372static int wm8350_dcdc_set_suspend_enable(struct regulator_dev *rdev)
373{
374 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
375 int dcdc = rdev_get_id(rdev);
376 u16 val;
377
378 switch (dcdc) {
379 case WM8350_DCDC_1:
380 val = wm8350_reg_read(wm8350, WM8350_DCDC1_LOW_POWER)
381 & ~WM8350_DCDC_HIB_MODE_MASK;
382 wm8350_reg_write(wm8350, WM8350_DCDC1_LOW_POWER,
Axel Lineb416812012-03-23 06:25:05 +0800383 val | wm8350->pmic.dcdc1_hib_mode);
Mark Brownda091552008-10-10 15:58:15 +0100384 break;
385 case WM8350_DCDC_3:
386 val = wm8350_reg_read(wm8350, WM8350_DCDC3_LOW_POWER)
387 & ~WM8350_DCDC_HIB_MODE_MASK;
388 wm8350_reg_write(wm8350, WM8350_DCDC3_LOW_POWER,
Axel Lineb416812012-03-23 06:25:05 +0800389 val | wm8350->pmic.dcdc3_hib_mode);
Mark Brownda091552008-10-10 15:58:15 +0100390 break;
391 case WM8350_DCDC_4:
392 val = wm8350_reg_read(wm8350, WM8350_DCDC4_LOW_POWER)
393 & ~WM8350_DCDC_HIB_MODE_MASK;
394 wm8350_reg_write(wm8350, WM8350_DCDC4_LOW_POWER,
Axel Lineb416812012-03-23 06:25:05 +0800395 val | wm8350->pmic.dcdc4_hib_mode);
Mark Brownda091552008-10-10 15:58:15 +0100396 break;
397 case WM8350_DCDC_6:
398 val = wm8350_reg_read(wm8350, WM8350_DCDC6_LOW_POWER)
399 & ~WM8350_DCDC_HIB_MODE_MASK;
400 wm8350_reg_write(wm8350, WM8350_DCDC6_LOW_POWER,
Axel Lineb416812012-03-23 06:25:05 +0800401 val | wm8350->pmic.dcdc6_hib_mode);
Mark Brownda091552008-10-10 15:58:15 +0100402 break;
403 case WM8350_DCDC_2:
404 case WM8350_DCDC_5:
405 default:
406 return -EINVAL;
407 }
408
409 return 0;
410}
411
412static int wm8350_dcdc_set_suspend_disable(struct regulator_dev *rdev)
413{
414 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
415 int dcdc = rdev_get_id(rdev);
416 u16 val;
417
418 switch (dcdc) {
419 case WM8350_DCDC_1:
420 val = wm8350_reg_read(wm8350, WM8350_DCDC1_LOW_POWER);
421 wm8350->pmic.dcdc1_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
422 wm8350_reg_write(wm8350, WM8350_DCDC1_LOW_POWER,
Axel Lincee1a792012-03-29 10:47:36 +0800423 val | WM8350_DCDC_HIB_MODE_DIS);
Mark Brownda091552008-10-10 15:58:15 +0100424 break;
425 case WM8350_DCDC_3:
426 val = wm8350_reg_read(wm8350, WM8350_DCDC3_LOW_POWER);
427 wm8350->pmic.dcdc3_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
428 wm8350_reg_write(wm8350, WM8350_DCDC3_LOW_POWER,
Axel Lincee1a792012-03-29 10:47:36 +0800429 val | WM8350_DCDC_HIB_MODE_DIS);
Mark Brownda091552008-10-10 15:58:15 +0100430 break;
431 case WM8350_DCDC_4:
432 val = wm8350_reg_read(wm8350, WM8350_DCDC4_LOW_POWER);
433 wm8350->pmic.dcdc4_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
434 wm8350_reg_write(wm8350, WM8350_DCDC4_LOW_POWER,
Axel Lincee1a792012-03-29 10:47:36 +0800435 val | WM8350_DCDC_HIB_MODE_DIS);
Mark Brownda091552008-10-10 15:58:15 +0100436 break;
437 case WM8350_DCDC_6:
438 val = wm8350_reg_read(wm8350, WM8350_DCDC6_LOW_POWER);
439 wm8350->pmic.dcdc6_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
440 wm8350_reg_write(wm8350, WM8350_DCDC6_LOW_POWER,
Axel Lincee1a792012-03-29 10:47:36 +0800441 val | WM8350_DCDC_HIB_MODE_DIS);
Mark Brownda091552008-10-10 15:58:15 +0100442 break;
443 case WM8350_DCDC_2:
444 case WM8350_DCDC_5:
445 default:
446 return -EINVAL;
447 }
448
449 return 0;
450}
451
452static int wm8350_dcdc25_set_suspend_enable(struct regulator_dev *rdev)
453{
454 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
455 int dcdc = rdev_get_id(rdev);
456 u16 val;
457
458 switch (dcdc) {
459 case WM8350_DCDC_2:
460 val = wm8350_reg_read(wm8350, WM8350_DCDC2_CONTROL)
461 & ~WM8350_DC2_HIB_MODE_MASK;
462 wm8350_reg_write(wm8350, WM8350_DCDC2_CONTROL, val |
Axel Lin93009282012-03-23 06:27:10 +0800463 (WM8350_DC2_HIB_MODE_ACTIVE << WM8350_DC2_HIB_MODE_SHIFT));
Mark Brownda091552008-10-10 15:58:15 +0100464 break;
465 case WM8350_DCDC_5:
466 val = wm8350_reg_read(wm8350, WM8350_DCDC5_CONTROL)
Axel Lin93009282012-03-23 06:27:10 +0800467 & ~WM8350_DC5_HIB_MODE_MASK;
Mark Brownda091552008-10-10 15:58:15 +0100468 wm8350_reg_write(wm8350, WM8350_DCDC5_CONTROL, val |
Axel Lin93009282012-03-23 06:27:10 +0800469 (WM8350_DC5_HIB_MODE_ACTIVE << WM8350_DC5_HIB_MODE_SHIFT));
Mark Brownda091552008-10-10 15:58:15 +0100470 break;
471 default:
472 return -EINVAL;
473 }
474 return 0;
475}
476
477static int wm8350_dcdc25_set_suspend_disable(struct regulator_dev *rdev)
478{
479 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
480 int dcdc = rdev_get_id(rdev);
481 u16 val;
482
483 switch (dcdc) {
484 case WM8350_DCDC_2:
485 val = wm8350_reg_read(wm8350, WM8350_DCDC2_CONTROL)
486 & ~WM8350_DC2_HIB_MODE_MASK;
487 wm8350_reg_write(wm8350, WM8350_DCDC2_CONTROL, val |
Axel Lin93009282012-03-23 06:27:10 +0800488 (WM8350_DC2_HIB_MODE_DISABLE << WM8350_DC2_HIB_MODE_SHIFT));
Mark Brownda091552008-10-10 15:58:15 +0100489 break;
490 case WM8350_DCDC_5:
491 val = wm8350_reg_read(wm8350, WM8350_DCDC5_CONTROL)
Axel Lin93009282012-03-23 06:27:10 +0800492 & ~WM8350_DC5_HIB_MODE_MASK;
Mark Brownda091552008-10-10 15:58:15 +0100493 wm8350_reg_write(wm8350, WM8350_DCDC5_CONTROL, val |
Axel Lin93009282012-03-23 06:27:10 +0800494 (WM8350_DC5_HIB_MODE_DISABLE << WM8350_DC5_HIB_MODE_SHIFT));
Mark Brownda091552008-10-10 15:58:15 +0100495 break;
496 default:
497 return -EINVAL;
498 }
499 return 0;
500}
501
502static int wm8350_dcdc_set_suspend_mode(struct regulator_dev *rdev,
503 unsigned int mode)
504{
505 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
506 int dcdc = rdev_get_id(rdev);
507 u16 *hib_mode;
508
509 switch (dcdc) {
510 case WM8350_DCDC_1:
511 hib_mode = &wm8350->pmic.dcdc1_hib_mode;
512 break;
513 case WM8350_DCDC_3:
514 hib_mode = &wm8350->pmic.dcdc3_hib_mode;
515 break;
516 case WM8350_DCDC_4:
517 hib_mode = &wm8350->pmic.dcdc4_hib_mode;
518 break;
519 case WM8350_DCDC_6:
520 hib_mode = &wm8350->pmic.dcdc6_hib_mode;
521 break;
522 case WM8350_DCDC_2:
523 case WM8350_DCDC_5:
524 default:
525 return -EINVAL;
526 }
527
528 switch (mode) {
529 case REGULATOR_MODE_NORMAL:
530 *hib_mode = WM8350_DCDC_HIB_MODE_IMAGE;
531 break;
532 case REGULATOR_MODE_IDLE:
533 *hib_mode = WM8350_DCDC_HIB_MODE_STANDBY;
534 break;
535 case REGULATOR_MODE_STANDBY:
536 *hib_mode = WM8350_DCDC_HIB_MODE_LDO_IM;
537 break;
538 default:
539 return -EINVAL;
540 }
541
542 return 0;
543}
544
Mark Brownc36a1cd2013-07-02 23:35:42 +0100545static const struct regulator_linear_range wm8350_ldo_ranges[] = {
Axel Lin8828bae2013-10-11 09:32:18 +0800546 REGULATOR_LINEAR_RANGE(900000, 0, 15, 50000),
547 REGULATOR_LINEAR_RANGE(1800000, 16, 31, 100000),
Mark Brownc36a1cd2013-07-02 23:35:42 +0100548};
Axel Linc7057422012-06-12 20:10:26 +0800549
Mark Brownda091552008-10-10 15:58:15 +0100550static int wm8350_ldo_set_suspend_voltage(struct regulator_dev *rdev, int uV)
551{
552 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
Axel Linc7057422012-06-12 20:10:26 +0800553 int sel, volt_reg, ldo = rdev_get_id(rdev);
Mark Brownda091552008-10-10 15:58:15 +0100554 u16 val;
555
Axel Linc7057422012-06-12 20:10:26 +0800556 dev_dbg(wm8350->dev, "%s %d mV %d\n", __func__, ldo, uV / 1000);
Mark Brownda091552008-10-10 15:58:15 +0100557
558 switch (ldo) {
559 case WM8350_LDO_1:
560 volt_reg = WM8350_LDO1_LOW_POWER;
561 break;
562 case WM8350_LDO_2:
563 volt_reg = WM8350_LDO2_LOW_POWER;
564 break;
565 case WM8350_LDO_3:
566 volt_reg = WM8350_LDO3_LOW_POWER;
567 break;
568 case WM8350_LDO_4:
569 volt_reg = WM8350_LDO4_LOW_POWER;
570 break;
571 default:
572 return -EINVAL;
573 }
574
Mark Brownc36a1cd2013-07-02 23:35:42 +0100575 sel = regulator_map_voltage_linear_range(rdev, uV, uV);
Axel Linc7057422012-06-12 20:10:26 +0800576 if (sel < 0)
577 return -EINVAL;
578
Mark Brownda091552008-10-10 15:58:15 +0100579 /* all LDOs have same mV bits */
580 val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_LDO1_VSEL_MASK;
Axel Linc7057422012-06-12 20:10:26 +0800581 wm8350_reg_write(wm8350, volt_reg, val | sel);
Mark Brownda091552008-10-10 15:58:15 +0100582 return 0;
583}
584
585static int wm8350_ldo_set_suspend_enable(struct regulator_dev *rdev)
586{
587 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
588 int volt_reg, ldo = rdev_get_id(rdev);
589 u16 val;
590
591 switch (ldo) {
592 case WM8350_LDO_1:
593 volt_reg = WM8350_LDO1_LOW_POWER;
594 break;
595 case WM8350_LDO_2:
596 volt_reg = WM8350_LDO2_LOW_POWER;
597 break;
598 case WM8350_LDO_3:
599 volt_reg = WM8350_LDO3_LOW_POWER;
600 break;
601 case WM8350_LDO_4:
602 volt_reg = WM8350_LDO4_LOW_POWER;
603 break;
604 default:
605 return -EINVAL;
606 }
607
608 /* all LDOs have same mV bits */
609 val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_LDO1_HIB_MODE_MASK;
610 wm8350_reg_write(wm8350, volt_reg, val);
611 return 0;
612}
613
614static int wm8350_ldo_set_suspend_disable(struct regulator_dev *rdev)
615{
616 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
617 int volt_reg, ldo = rdev_get_id(rdev);
618 u16 val;
619
620 switch (ldo) {
621 case WM8350_LDO_1:
622 volt_reg = WM8350_LDO1_LOW_POWER;
623 break;
624 case WM8350_LDO_2:
625 volt_reg = WM8350_LDO2_LOW_POWER;
626 break;
627 case WM8350_LDO_3:
628 volt_reg = WM8350_LDO3_LOW_POWER;
629 break;
630 case WM8350_LDO_4:
631 volt_reg = WM8350_LDO4_LOW_POWER;
632 break;
633 default:
634 return -EINVAL;
635 }
636
637 /* all LDOs have same mV bits */
638 val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_LDO1_HIB_MODE_MASK;
Axel Lincee1a792012-03-29 10:47:36 +0800639 wm8350_reg_write(wm8350, volt_reg, val | WM8350_LDO1_HIB_MODE_DIS);
Mark Brownda091552008-10-10 15:58:15 +0100640 return 0;
641}
642
Mark Brownda091552008-10-10 15:58:15 +0100643int wm8350_dcdc_set_slot(struct wm8350 *wm8350, int dcdc, u16 start,
644 u16 stop, u16 fault)
645{
646 int slot_reg;
647 u16 val;
648
649 dev_dbg(wm8350->dev, "%s %d start %d stop %d\n",
650 __func__, dcdc, start, stop);
651
652 /* slot valid ? */
653 if (start > 15 || stop > 15)
654 return -EINVAL;
655
656 switch (dcdc) {
657 case WM8350_DCDC_1:
658 slot_reg = WM8350_DCDC1_TIMEOUTS;
659 break;
660 case WM8350_DCDC_2:
661 slot_reg = WM8350_DCDC2_TIMEOUTS;
662 break;
663 case WM8350_DCDC_3:
664 slot_reg = WM8350_DCDC3_TIMEOUTS;
665 break;
666 case WM8350_DCDC_4:
667 slot_reg = WM8350_DCDC4_TIMEOUTS;
668 break;
669 case WM8350_DCDC_5:
670 slot_reg = WM8350_DCDC5_TIMEOUTS;
671 break;
672 case WM8350_DCDC_6:
673 slot_reg = WM8350_DCDC6_TIMEOUTS;
674 break;
675 default:
676 return -EINVAL;
677 }
678
679 val = wm8350_reg_read(wm8350, slot_reg) &
680 ~(WM8350_DC1_ENSLOT_MASK | WM8350_DC1_SDSLOT_MASK |
681 WM8350_DC1_ERRACT_MASK);
682 wm8350_reg_write(wm8350, slot_reg,
683 val | (start << WM8350_DC1_ENSLOT_SHIFT) |
684 (stop << WM8350_DC1_SDSLOT_SHIFT) |
685 (fault << WM8350_DC1_ERRACT_SHIFT));
686
687 return 0;
688}
689EXPORT_SYMBOL_GPL(wm8350_dcdc_set_slot);
690
691int wm8350_ldo_set_slot(struct wm8350 *wm8350, int ldo, u16 start, u16 stop)
692{
693 int slot_reg;
694 u16 val;
695
696 dev_dbg(wm8350->dev, "%s %d start %d stop %d\n",
697 __func__, ldo, start, stop);
698
699 /* slot valid ? */
700 if (start > 15 || stop > 15)
701 return -EINVAL;
702
703 switch (ldo) {
704 case WM8350_LDO_1:
705 slot_reg = WM8350_LDO1_TIMEOUTS;
706 break;
707 case WM8350_LDO_2:
708 slot_reg = WM8350_LDO2_TIMEOUTS;
709 break;
710 case WM8350_LDO_3:
711 slot_reg = WM8350_LDO3_TIMEOUTS;
712 break;
713 case WM8350_LDO_4:
714 slot_reg = WM8350_LDO4_TIMEOUTS;
715 break;
716 default:
717 return -EINVAL;
718 }
719
720 val = wm8350_reg_read(wm8350, slot_reg) & ~WM8350_LDO1_SDSLOT_MASK;
721 wm8350_reg_write(wm8350, slot_reg, val | ((start << 10) | (stop << 6)));
722 return 0;
723}
724EXPORT_SYMBOL_GPL(wm8350_ldo_set_slot);
725
726int wm8350_dcdc25_set_mode(struct wm8350 *wm8350, int dcdc, u16 mode,
727 u16 ilim, u16 ramp, u16 feedback)
728{
729 u16 val;
730
731 dev_dbg(wm8350->dev, "%s %d mode: %s %s\n", __func__, dcdc,
732 mode ? "normal" : "boost", ilim ? "low" : "normal");
733
734 switch (dcdc) {
735 case WM8350_DCDC_2:
736 val = wm8350_reg_read(wm8350, WM8350_DCDC2_CONTROL)
737 & ~(WM8350_DC2_MODE_MASK | WM8350_DC2_ILIM_MASK |
738 WM8350_DC2_RMP_MASK | WM8350_DC2_FBSRC_MASK);
739 wm8350_reg_write(wm8350, WM8350_DCDC2_CONTROL, val |
740 (mode << WM8350_DC2_MODE_SHIFT) |
741 (ilim << WM8350_DC2_ILIM_SHIFT) |
742 (ramp << WM8350_DC2_RMP_SHIFT) |
743 (feedback << WM8350_DC2_FBSRC_SHIFT));
744 break;
745 case WM8350_DCDC_5:
746 val = wm8350_reg_read(wm8350, WM8350_DCDC5_CONTROL)
747 & ~(WM8350_DC5_MODE_MASK | WM8350_DC5_ILIM_MASK |
748 WM8350_DC5_RMP_MASK | WM8350_DC5_FBSRC_MASK);
749 wm8350_reg_write(wm8350, WM8350_DCDC5_CONTROL, val |
750 (mode << WM8350_DC5_MODE_SHIFT) |
751 (ilim << WM8350_DC5_ILIM_SHIFT) |
752 (ramp << WM8350_DC5_RMP_SHIFT) |
753 (feedback << WM8350_DC5_FBSRC_SHIFT));
754 break;
755 default:
756 return -EINVAL;
757 }
758
759 return 0;
760}
761EXPORT_SYMBOL_GPL(wm8350_dcdc25_set_mode);
762
Mark Brownda091552008-10-10 15:58:15 +0100763static int force_continuous_enable(struct wm8350 *wm8350, int dcdc, int enable)
764{
765 int reg = 0, ret;
766
767 switch (dcdc) {
768 case WM8350_DCDC_1:
769 reg = WM8350_DCDC1_FORCE_PWM;
770 break;
771 case WM8350_DCDC_3:
772 reg = WM8350_DCDC3_FORCE_PWM;
773 break;
774 case WM8350_DCDC_4:
775 reg = WM8350_DCDC4_FORCE_PWM;
776 break;
777 case WM8350_DCDC_6:
778 reg = WM8350_DCDC6_FORCE_PWM;
779 break;
780 default:
781 return -EINVAL;
782 }
783
784 if (enable)
785 ret = wm8350_set_bits(wm8350, reg,
786 WM8350_DCDC1_FORCE_PWM_ENA);
787 else
788 ret = wm8350_clear_bits(wm8350, reg,
789 WM8350_DCDC1_FORCE_PWM_ENA);
790 return ret;
791}
792
793static int wm8350_dcdc_set_mode(struct regulator_dev *rdev, unsigned int mode)
794{
795 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
796 int dcdc = rdev_get_id(rdev);
797 u16 val;
798
799 if (dcdc < WM8350_DCDC_1 || dcdc > WM8350_DCDC_6)
800 return -EINVAL;
801
802 if (dcdc == WM8350_DCDC_2 || dcdc == WM8350_DCDC_5)
803 return -EINVAL;
804
805 val = 1 << (dcdc - WM8350_DCDC_1);
806
807 switch (mode) {
808 case REGULATOR_MODE_FAST:
809 /* force continuous mode */
810 wm8350_set_bits(wm8350, WM8350_DCDC_ACTIVE_OPTIONS, val);
811 wm8350_clear_bits(wm8350, WM8350_DCDC_SLEEP_OPTIONS, val);
812 force_continuous_enable(wm8350, dcdc, 1);
813 break;
814 case REGULATOR_MODE_NORMAL:
815 /* active / pulse skipping */
816 wm8350_set_bits(wm8350, WM8350_DCDC_ACTIVE_OPTIONS, val);
817 wm8350_clear_bits(wm8350, WM8350_DCDC_SLEEP_OPTIONS, val);
818 force_continuous_enable(wm8350, dcdc, 0);
819 break;
820 case REGULATOR_MODE_IDLE:
821 /* standby mode */
822 force_continuous_enable(wm8350, dcdc, 0);
823 wm8350_clear_bits(wm8350, WM8350_DCDC_SLEEP_OPTIONS, val);
824 wm8350_clear_bits(wm8350, WM8350_DCDC_ACTIVE_OPTIONS, val);
825 break;
826 case REGULATOR_MODE_STANDBY:
827 /* LDO mode */
828 force_continuous_enable(wm8350, dcdc, 0);
829 wm8350_set_bits(wm8350, WM8350_DCDC_SLEEP_OPTIONS, val);
830 break;
831 }
832
833 return 0;
834}
835
836static unsigned int wm8350_dcdc_get_mode(struct regulator_dev *rdev)
837{
838 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
839 int dcdc = rdev_get_id(rdev);
840 u16 mask, sleep, active, force;
841 int mode = REGULATOR_MODE_NORMAL;
Mark Brown33f301a2009-02-26 19:24:20 +0000842 int reg;
Mark Brownda091552008-10-10 15:58:15 +0100843
Mark Brown33f301a2009-02-26 19:24:20 +0000844 switch (dcdc) {
845 case WM8350_DCDC_1:
846 reg = WM8350_DCDC1_FORCE_PWM;
847 break;
848 case WM8350_DCDC_3:
849 reg = WM8350_DCDC3_FORCE_PWM;
850 break;
851 case WM8350_DCDC_4:
852 reg = WM8350_DCDC4_FORCE_PWM;
853 break;
854 case WM8350_DCDC_6:
855 reg = WM8350_DCDC6_FORCE_PWM;
856 break;
857 default:
Mark Brownda091552008-10-10 15:58:15 +0100858 return -EINVAL;
Mark Brown33f301a2009-02-26 19:24:20 +0000859 }
Mark Brownda091552008-10-10 15:58:15 +0100860
861 mask = 1 << (dcdc - WM8350_DCDC_1);
862 active = wm8350_reg_read(wm8350, WM8350_DCDC_ACTIVE_OPTIONS) & mask;
Mark Brown33f301a2009-02-26 19:24:20 +0000863 force = wm8350_reg_read(wm8350, reg) & WM8350_DCDC1_FORCE_PWM_ENA;
Mark Brownda091552008-10-10 15:58:15 +0100864 sleep = wm8350_reg_read(wm8350, WM8350_DCDC_SLEEP_OPTIONS) & mask;
Mark Brown33f301a2009-02-26 19:24:20 +0000865
Mark Brownda091552008-10-10 15:58:15 +0100866 dev_dbg(wm8350->dev, "mask %x active %x sleep %x force %x",
867 mask, active, sleep, force);
868
869 if (active && !sleep) {
870 if (force)
871 mode = REGULATOR_MODE_FAST;
872 else
873 mode = REGULATOR_MODE_NORMAL;
874 } else if (!active && !sleep)
875 mode = REGULATOR_MODE_IDLE;
Axel Lin8ecee362010-09-06 14:06:07 +0800876 else if (sleep)
Mark Brownda091552008-10-10 15:58:15 +0100877 mode = REGULATOR_MODE_STANDBY;
878
879 return mode;
880}
881
882static unsigned int wm8350_ldo_get_mode(struct regulator_dev *rdev)
883{
884 return REGULATOR_MODE_NORMAL;
885}
886
887struct wm8350_dcdc_efficiency {
888 int uA_load_min;
889 int uA_load_max;
890 unsigned int mode;
891};
892
893static const struct wm8350_dcdc_efficiency dcdc1_6_efficiency[] = {
894 {0, 10000, REGULATOR_MODE_STANDBY}, /* 0 - 10mA - LDO */
895 {10000, 100000, REGULATOR_MODE_IDLE}, /* 10mA - 100mA - Standby */
896 {100000, 1000000, REGULATOR_MODE_NORMAL}, /* > 100mA - Active */
897 {-1, -1, REGULATOR_MODE_NORMAL},
898};
899
900static const struct wm8350_dcdc_efficiency dcdc3_4_efficiency[] = {
901 {0, 10000, REGULATOR_MODE_STANDBY}, /* 0 - 10mA - LDO */
902 {10000, 100000, REGULATOR_MODE_IDLE}, /* 10mA - 100mA - Standby */
903 {100000, 800000, REGULATOR_MODE_NORMAL}, /* > 100mA - Active */
904 {-1, -1, REGULATOR_MODE_NORMAL},
905};
906
907static unsigned int get_mode(int uA, const struct wm8350_dcdc_efficiency *eff)
908{
909 int i = 0;
910
911 while (eff[i].uA_load_min != -1) {
912 if (uA >= eff[i].uA_load_min && uA <= eff[i].uA_load_max)
913 return eff[i].mode;
914 }
915 return REGULATOR_MODE_NORMAL;
916}
917
918/* Query the regulator for it's most efficient mode @ uV,uA
919 * WM8350 regulator efficiency is pretty similar over
920 * different input and output uV.
921 */
922static unsigned int wm8350_dcdc_get_optimum_mode(struct regulator_dev *rdev,
923 int input_uV, int output_uV,
924 int output_uA)
925{
926 int dcdc = rdev_get_id(rdev), mode;
927
928 switch (dcdc) {
929 case WM8350_DCDC_1:
930 case WM8350_DCDC_6:
931 mode = get_mode(output_uA, dcdc1_6_efficiency);
932 break;
933 case WM8350_DCDC_3:
934 case WM8350_DCDC_4:
935 mode = get_mode(output_uA, dcdc3_4_efficiency);
936 break;
937 default:
938 mode = REGULATOR_MODE_NORMAL;
939 break;
940 }
941 return mode;
942}
943
Mark Brownda091552008-10-10 15:58:15 +0100944static struct regulator_ops wm8350_dcdc_ops = {
Mark Brown107a3962012-05-09 22:22:30 +0100945 .set_voltage_sel = regulator_set_voltage_sel_regmap,
Mark Brownb4ec87a2012-04-30 21:00:10 +0100946 .get_voltage_sel = regulator_get_voltage_sel_regmap,
Mark Brown107a3962012-05-09 22:22:30 +0100947 .list_voltage = regulator_list_voltage_linear,
Axel Linfcbb71f2012-06-03 23:12:16 +0800948 .map_voltage = regulator_map_voltage_linear,
Mark Browna540f682012-04-30 21:08:59 +0100949 .enable = regulator_enable_regmap,
950 .disable = regulator_disable_regmap,
951 .is_enabled = regulator_is_enabled_regmap,
Mark Brownda091552008-10-10 15:58:15 +0100952 .get_mode = wm8350_dcdc_get_mode,
953 .set_mode = wm8350_dcdc_set_mode,
954 .get_optimum_mode = wm8350_dcdc_get_optimum_mode,
Mark Brownda091552008-10-10 15:58:15 +0100955 .set_suspend_voltage = wm8350_dcdc_set_suspend_voltage,
956 .set_suspend_enable = wm8350_dcdc_set_suspend_enable,
957 .set_suspend_disable = wm8350_dcdc_set_suspend_disable,
958 .set_suspend_mode = wm8350_dcdc_set_suspend_mode,
959};
960
961static struct regulator_ops wm8350_dcdc2_5_ops = {
Mark Browna540f682012-04-30 21:08:59 +0100962 .enable = regulator_enable_regmap,
963 .disable = regulator_disable_regmap,
964 .is_enabled = regulator_is_enabled_regmap,
Mark Brownda091552008-10-10 15:58:15 +0100965 .set_suspend_enable = wm8350_dcdc25_set_suspend_enable,
966 .set_suspend_disable = wm8350_dcdc25_set_suspend_disable,
967};
968
969static struct regulator_ops wm8350_ldo_ops = {
Mark Brownc36a1cd2013-07-02 23:35:42 +0100970 .map_voltage = regulator_map_voltage_linear_range,
Mark Brownfc492f92012-05-09 22:27:41 +0100971 .set_voltage_sel = regulator_set_voltage_sel_regmap,
Mark Brownb4ec87a2012-04-30 21:00:10 +0100972 .get_voltage_sel = regulator_get_voltage_sel_regmap,
Mark Brownc36a1cd2013-07-02 23:35:42 +0100973 .list_voltage = regulator_list_voltage_linear_range,
Mark Browna540f682012-04-30 21:08:59 +0100974 .enable = regulator_enable_regmap,
975 .disable = regulator_disable_regmap,
976 .is_enabled = regulator_is_enabled_regmap,
Mark Brownda091552008-10-10 15:58:15 +0100977 .get_mode = wm8350_ldo_get_mode,
978 .set_suspend_voltage = wm8350_ldo_set_suspend_voltage,
979 .set_suspend_enable = wm8350_ldo_set_suspend_enable,
980 .set_suspend_disable = wm8350_ldo_set_suspend_disable,
981};
982
983static struct regulator_ops wm8350_isink_ops = {
984 .set_current_limit = wm8350_isink_set_current,
985 .get_current_limit = wm8350_isink_get_current,
986 .enable = wm8350_isink_enable,
987 .disable = wm8350_isink_disable,
988 .is_enabled = wm8350_isink_is_enabled,
Mark Brown75c8ac22010-01-04 17:24:01 +0000989 .enable_time = wm8350_isink_enable_time,
Mark Brownda091552008-10-10 15:58:15 +0100990};
991
Mark Brown47924b62012-04-03 20:47:15 +0100992static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
Mark Brownda091552008-10-10 15:58:15 +0100993 {
994 .name = "DCDC1",
995 .id = WM8350_DCDC_1,
996 .ops = &wm8350_dcdc_ops,
997 .irq = WM8350_IRQ_UV_DC1,
998 .type = REGULATOR_VOLTAGE,
Mark Brown221a7c72009-03-02 16:32:47 +0000999 .n_voltages = WM8350_DCDC_MAX_VSEL + 1,
Mark Brown107a3962012-05-09 22:22:30 +01001000 .min_uV = 850000,
1001 .uV_step = 25000,
Mark Brownb4ec87a2012-04-30 21:00:10 +01001002 .vsel_reg = WM8350_DCDC1_CONTROL,
1003 .vsel_mask = WM8350_DC1_VSEL_MASK,
Mark Browna540f682012-04-30 21:08:59 +01001004 .enable_reg = WM8350_DCDC_LDO_REQUESTED,
1005 .enable_mask = WM8350_DC1_ENA,
Mark Brownda091552008-10-10 15:58:15 +01001006 .owner = THIS_MODULE,
1007 },
1008 {
1009 .name = "DCDC2",
1010 .id = WM8350_DCDC_2,
1011 .ops = &wm8350_dcdc2_5_ops,
1012 .irq = WM8350_IRQ_UV_DC2,
1013 .type = REGULATOR_VOLTAGE,
Mark Browna540f682012-04-30 21:08:59 +01001014 .enable_reg = WM8350_DCDC_LDO_REQUESTED,
1015 .enable_mask = WM8350_DC2_ENA,
Mark Brownda091552008-10-10 15:58:15 +01001016 .owner = THIS_MODULE,
1017 },
1018 {
1019 .name = "DCDC3",
1020 .id = WM8350_DCDC_3,
1021 .ops = &wm8350_dcdc_ops,
1022 .irq = WM8350_IRQ_UV_DC3,
1023 .type = REGULATOR_VOLTAGE,
Mark Brown221a7c72009-03-02 16:32:47 +00001024 .n_voltages = WM8350_DCDC_MAX_VSEL + 1,
Mark Brown107a3962012-05-09 22:22:30 +01001025 .min_uV = 850000,
1026 .uV_step = 25000,
Mark Brownb4ec87a2012-04-30 21:00:10 +01001027 .vsel_reg = WM8350_DCDC3_CONTROL,
1028 .vsel_mask = WM8350_DC3_VSEL_MASK,
Mark Browna540f682012-04-30 21:08:59 +01001029 .enable_reg = WM8350_DCDC_LDO_REQUESTED,
1030 .enable_mask = WM8350_DC3_ENA,
Mark Brownda091552008-10-10 15:58:15 +01001031 .owner = THIS_MODULE,
1032 },
1033 {
1034 .name = "DCDC4",
1035 .id = WM8350_DCDC_4,
1036 .ops = &wm8350_dcdc_ops,
1037 .irq = WM8350_IRQ_UV_DC4,
1038 .type = REGULATOR_VOLTAGE,
Mark Brown221a7c72009-03-02 16:32:47 +00001039 .n_voltages = WM8350_DCDC_MAX_VSEL + 1,
Axel Lin0ff47242012-06-12 17:18:49 +08001040 .min_uV = 850000,
1041 .uV_step = 25000,
Mark Brownb4ec87a2012-04-30 21:00:10 +01001042 .vsel_reg = WM8350_DCDC4_CONTROL,
1043 .vsel_mask = WM8350_DC4_VSEL_MASK,
Mark Browna540f682012-04-30 21:08:59 +01001044 .enable_reg = WM8350_DCDC_LDO_REQUESTED,
1045 .enable_mask = WM8350_DC4_ENA,
Mark Brownda091552008-10-10 15:58:15 +01001046 .owner = THIS_MODULE,
1047 },
1048 {
1049 .name = "DCDC5",
1050 .id = WM8350_DCDC_5,
1051 .ops = &wm8350_dcdc2_5_ops,
1052 .irq = WM8350_IRQ_UV_DC5,
1053 .type = REGULATOR_VOLTAGE,
Mark Browna540f682012-04-30 21:08:59 +01001054 .enable_reg = WM8350_DCDC_LDO_REQUESTED,
1055 .enable_mask = WM8350_DC5_ENA,
Mark Brownda091552008-10-10 15:58:15 +01001056 .owner = THIS_MODULE,
1057 },
1058 {
1059 .name = "DCDC6",
1060 .id = WM8350_DCDC_6,
1061 .ops = &wm8350_dcdc_ops,
1062 .irq = WM8350_IRQ_UV_DC6,
1063 .type = REGULATOR_VOLTAGE,
Mark Brown221a7c72009-03-02 16:32:47 +00001064 .n_voltages = WM8350_DCDC_MAX_VSEL + 1,
Mark Brown107a3962012-05-09 22:22:30 +01001065 .min_uV = 850000,
1066 .uV_step = 25000,
Mark Brownb4ec87a2012-04-30 21:00:10 +01001067 .vsel_reg = WM8350_DCDC6_CONTROL,
1068 .vsel_mask = WM8350_DC6_VSEL_MASK,
Mark Browna540f682012-04-30 21:08:59 +01001069 .enable_reg = WM8350_DCDC_LDO_REQUESTED,
1070 .enable_mask = WM8350_DC6_ENA,
Mark Brownda091552008-10-10 15:58:15 +01001071 .owner = THIS_MODULE,
1072 },
1073 {
1074 .name = "LDO1",
1075 .id = WM8350_LDO_1,
1076 .ops = &wm8350_ldo_ops,
1077 .irq = WM8350_IRQ_UV_LDO1,
1078 .type = REGULATOR_VOLTAGE,
Mark Brown221a7c72009-03-02 16:32:47 +00001079 .n_voltages = WM8350_LDO1_VSEL_MASK + 1,
Mark Brownc36a1cd2013-07-02 23:35:42 +01001080 .linear_ranges = wm8350_ldo_ranges,
1081 .n_linear_ranges = ARRAY_SIZE(wm8350_ldo_ranges),
Mark Brownb4ec87a2012-04-30 21:00:10 +01001082 .vsel_reg = WM8350_LDO1_CONTROL,
1083 .vsel_mask = WM8350_LDO1_VSEL_MASK,
Mark Browna540f682012-04-30 21:08:59 +01001084 .enable_reg = WM8350_DCDC_LDO_REQUESTED,
1085 .enable_mask = WM8350_LDO1_ENA,
Mark Brownda091552008-10-10 15:58:15 +01001086 .owner = THIS_MODULE,
1087 },
1088 {
1089 .name = "LDO2",
1090 .id = WM8350_LDO_2,
1091 .ops = &wm8350_ldo_ops,
1092 .irq = WM8350_IRQ_UV_LDO2,
1093 .type = REGULATOR_VOLTAGE,
Mark Brown221a7c72009-03-02 16:32:47 +00001094 .n_voltages = WM8350_LDO2_VSEL_MASK + 1,
Mark Brownc36a1cd2013-07-02 23:35:42 +01001095 .linear_ranges = wm8350_ldo_ranges,
1096 .n_linear_ranges = ARRAY_SIZE(wm8350_ldo_ranges),
Mark Brownb4ec87a2012-04-30 21:00:10 +01001097 .vsel_reg = WM8350_LDO2_CONTROL,
1098 .vsel_mask = WM8350_LDO2_VSEL_MASK,
Mark Browna540f682012-04-30 21:08:59 +01001099 .enable_reg = WM8350_DCDC_LDO_REQUESTED,
1100 .enable_mask = WM8350_LDO2_ENA,
Mark Brownda091552008-10-10 15:58:15 +01001101 .owner = THIS_MODULE,
1102 },
1103 {
1104 .name = "LDO3",
1105 .id = WM8350_LDO_3,
1106 .ops = &wm8350_ldo_ops,
1107 .irq = WM8350_IRQ_UV_LDO3,
1108 .type = REGULATOR_VOLTAGE,
Mark Brown221a7c72009-03-02 16:32:47 +00001109 .n_voltages = WM8350_LDO3_VSEL_MASK + 1,
Mark Brownc36a1cd2013-07-02 23:35:42 +01001110 .linear_ranges = wm8350_ldo_ranges,
1111 .n_linear_ranges = ARRAY_SIZE(wm8350_ldo_ranges),
Mark Brownb4ec87a2012-04-30 21:00:10 +01001112 .vsel_reg = WM8350_LDO3_CONTROL,
1113 .vsel_mask = WM8350_LDO3_VSEL_MASK,
Mark Browna540f682012-04-30 21:08:59 +01001114 .enable_reg = WM8350_DCDC_LDO_REQUESTED,
1115 .enable_mask = WM8350_LDO3_ENA,
Mark Brownda091552008-10-10 15:58:15 +01001116 .owner = THIS_MODULE,
1117 },
1118 {
1119 .name = "LDO4",
1120 .id = WM8350_LDO_4,
1121 .ops = &wm8350_ldo_ops,
1122 .irq = WM8350_IRQ_UV_LDO4,
1123 .type = REGULATOR_VOLTAGE,
Mark Brown221a7c72009-03-02 16:32:47 +00001124 .n_voltages = WM8350_LDO4_VSEL_MASK + 1,
Mark Brownc36a1cd2013-07-02 23:35:42 +01001125 .linear_ranges = wm8350_ldo_ranges,
1126 .n_linear_ranges = ARRAY_SIZE(wm8350_ldo_ranges),
Mark Brownb4ec87a2012-04-30 21:00:10 +01001127 .vsel_reg = WM8350_LDO4_CONTROL,
1128 .vsel_mask = WM8350_LDO4_VSEL_MASK,
Mark Browna540f682012-04-30 21:08:59 +01001129 .enable_reg = WM8350_DCDC_LDO_REQUESTED,
1130 .enable_mask = WM8350_LDO4_ENA,
Mark Brownda091552008-10-10 15:58:15 +01001131 .owner = THIS_MODULE,
1132 },
1133 {
1134 .name = "ISINKA",
1135 .id = WM8350_ISINK_A,
1136 .ops = &wm8350_isink_ops,
1137 .irq = WM8350_IRQ_CS1,
1138 .type = REGULATOR_CURRENT,
1139 .owner = THIS_MODULE,
1140 },
1141 {
1142 .name = "ISINKB",
1143 .id = WM8350_ISINK_B,
1144 .ops = &wm8350_isink_ops,
1145 .irq = WM8350_IRQ_CS2,
1146 .type = REGULATOR_CURRENT,
1147 .owner = THIS_MODULE,
1148 },
1149};
1150
Mark Brown5a65edb2009-11-04 16:10:51 +00001151static irqreturn_t pmic_uv_handler(int irq, void *data)
Mark Brownda091552008-10-10 15:58:15 +01001152{
1153 struct regulator_dev *rdev = (struct regulator_dev *)data;
Mark Brown5a65edb2009-11-04 16:10:51 +00001154 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
Mark Brownda091552008-10-10 15:58:15 +01001155
Jonathan Cameronb136fb42009-01-19 18:20:58 +00001156 mutex_lock(&rdev->mutex);
Mark Brownda091552008-10-10 15:58:15 +01001157 if (irq == WM8350_IRQ_CS1 || irq == WM8350_IRQ_CS2)
1158 regulator_notifier_call_chain(rdev,
1159 REGULATOR_EVENT_REGULATION_OUT,
1160 wm8350);
1161 else
1162 regulator_notifier_call_chain(rdev,
1163 REGULATOR_EVENT_UNDER_VOLTAGE,
1164 wm8350);
Jonathan Cameronb136fb42009-01-19 18:20:58 +00001165 mutex_unlock(&rdev->mutex);
Mark Brown5a65edb2009-11-04 16:10:51 +00001166
1167 return IRQ_HANDLED;
Mark Brownda091552008-10-10 15:58:15 +01001168}
1169
1170static int wm8350_regulator_probe(struct platform_device *pdev)
1171{
1172 struct wm8350 *wm8350 = dev_get_drvdata(&pdev->dev);
Mark Brownc1727082012-04-04 00:50:22 +01001173 struct regulator_config config = { };
Mark Brownda091552008-10-10 15:58:15 +01001174 struct regulator_dev *rdev;
1175 int ret;
1176 u16 val;
1177
1178 if (pdev->id < WM8350_DCDC_1 || pdev->id > WM8350_ISINK_B)
1179 return -ENODEV;
1180
1181 /* do any regulatior specific init */
1182 switch (pdev->id) {
1183 case WM8350_DCDC_1:
1184 val = wm8350_reg_read(wm8350, WM8350_DCDC1_LOW_POWER);
1185 wm8350->pmic.dcdc1_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
1186 break;
1187 case WM8350_DCDC_3:
1188 val = wm8350_reg_read(wm8350, WM8350_DCDC3_LOW_POWER);
1189 wm8350->pmic.dcdc3_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
1190 break;
1191 case WM8350_DCDC_4:
1192 val = wm8350_reg_read(wm8350, WM8350_DCDC4_LOW_POWER);
1193 wm8350->pmic.dcdc4_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
1194 break;
1195 case WM8350_DCDC_6:
1196 val = wm8350_reg_read(wm8350, WM8350_DCDC6_LOW_POWER);
1197 wm8350->pmic.dcdc6_hib_mode = val & WM8350_DCDC_HIB_MODE_MASK;
1198 break;
1199 }
1200
Mark Brownc1727082012-04-04 00:50:22 +01001201 config.dev = &pdev->dev;
Jingoo Handff91d02013-07-30 17:20:47 +09001202 config.init_data = dev_get_platdata(&pdev->dev);
Mark Brownc1727082012-04-04 00:50:22 +01001203 config.driver_data = dev_get_drvdata(&pdev->dev);
Mark Brownb4ec87a2012-04-30 21:00:10 +01001204 config.regmap = wm8350->regmap;
Mark Brownc1727082012-04-04 00:50:22 +01001205
Mark Brownda091552008-10-10 15:58:15 +01001206 /* register regulator */
Mark Browne57e5462013-08-31 12:00:37 +01001207 rdev = devm_regulator_register(&pdev->dev, &wm8350_reg[pdev->id],
1208 &config);
Mark Brownda091552008-10-10 15:58:15 +01001209 if (IS_ERR(rdev)) {
1210 dev_err(&pdev->dev, "failed to register %s\n",
1211 wm8350_reg[pdev->id].name);
1212 return PTR_ERR(rdev);
1213 }
1214
1215 /* register regulator IRQ */
1216 ret = wm8350_register_irq(wm8350, wm8350_reg[pdev->id].irq,
Mark Brown5a65edb2009-11-04 16:10:51 +00001217 pmic_uv_handler, 0, "UV", rdev);
Mark Brownda091552008-10-10 15:58:15 +01001218 if (ret < 0) {
Mark Brownda091552008-10-10 15:58:15 +01001219 dev_err(&pdev->dev, "failed to register regulator %s IRQ\n",
1220 wm8350_reg[pdev->id].name);
1221 return ret;
1222 }
1223
Mark Brownda091552008-10-10 15:58:15 +01001224 return 0;
1225}
1226
1227static int wm8350_regulator_remove(struct platform_device *pdev)
1228{
1229 struct regulator_dev *rdev = platform_get_drvdata(pdev);
1230 struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
1231
Mark Brownf99344f2010-01-05 13:59:07 +00001232 wm8350_free_irq(wm8350, wm8350_reg[pdev->id].irq, rdev);
Mark Brownda091552008-10-10 15:58:15 +01001233
Mark Brownda091552008-10-10 15:58:15 +01001234 return 0;
1235}
1236
1237int wm8350_register_regulator(struct wm8350 *wm8350, int reg,
1238 struct regulator_init_data *initdata)
1239{
1240 struct platform_device *pdev;
1241 int ret;
Roel Kluin4dee4d42009-06-15 22:30:39 +02001242 if (reg < 0 || reg >= NUM_WM8350_REGULATORS)
1243 return -EINVAL;
Mark Brownda091552008-10-10 15:58:15 +01001244
1245 if (wm8350->pmic.pdev[reg])
1246 return -EBUSY;
1247
Mark Brown645524a2008-12-18 23:12:16 +01001248 if (reg >= WM8350_DCDC_1 && reg <= WM8350_DCDC_6 &&
1249 reg > wm8350->pmic.max_dcdc)
1250 return -ENODEV;
1251 if (reg >= WM8350_ISINK_A && reg <= WM8350_ISINK_B &&
1252 reg > wm8350->pmic.max_isink)
1253 return -ENODEV;
1254
Mark Brownda091552008-10-10 15:58:15 +01001255 pdev = platform_device_alloc("wm8350-regulator", reg);
1256 if (!pdev)
1257 return -ENOMEM;
1258
1259 wm8350->pmic.pdev[reg] = pdev;
1260
1261 initdata->driver_data = wm8350;
1262
1263 pdev->dev.platform_data = initdata;
1264 pdev->dev.parent = wm8350->dev;
1265 platform_set_drvdata(pdev, wm8350);
1266
1267 ret = platform_device_add(pdev);
1268
1269 if (ret != 0) {
1270 dev_err(wm8350->dev, "Failed to register regulator %d: %d\n",
1271 reg, ret);
Axel Line9a1c512010-07-26 10:41:58 +08001272 platform_device_put(pdev);
Mark Brownda091552008-10-10 15:58:15 +01001273 wm8350->pmic.pdev[reg] = NULL;
1274 }
1275
1276 return ret;
1277}
1278EXPORT_SYMBOL_GPL(wm8350_register_regulator);
1279
Mark Brown0081e802008-12-04 16:52:33 +00001280/**
1281 * wm8350_register_led - Register a WM8350 LED output
1282 *
1283 * @param wm8350 The WM8350 device to configure.
1284 * @param lednum LED device index to create.
1285 * @param dcdc The DCDC to use for the LED.
1286 * @param isink The ISINK to use for the LED.
1287 * @param pdata Configuration for the LED.
1288 *
1289 * The WM8350 supports the use of an ISINK together with a DCDC to
1290 * provide a power-efficient LED driver. This function registers the
1291 * regulators and instantiates the platform device for a LED. The
1292 * operating modes for the LED regulators must be configured using
1293 * wm8350_isink_set_flash(), wm8350_dcdc25_set_mode() and
1294 * wm8350_dcdc_set_slot() prior to calling this function.
1295 */
1296int wm8350_register_led(struct wm8350 *wm8350, int lednum, int dcdc, int isink,
1297 struct wm8350_led_platform_data *pdata)
1298{
1299 struct wm8350_led *led;
1300 struct platform_device *pdev;
1301 int ret;
1302
Roel Kluin8dd2c9e2009-01-17 16:06:40 +01001303 if (lednum >= ARRAY_SIZE(wm8350->pmic.led) || lednum < 0) {
Mark Brown0081e802008-12-04 16:52:33 +00001304 dev_err(wm8350->dev, "Invalid LED index %d\n", lednum);
1305 return -ENODEV;
1306 }
1307
1308 led = &wm8350->pmic.led[lednum];
1309
1310 if (led->pdev) {
1311 dev_err(wm8350->dev, "LED %d already allocated\n", lednum);
1312 return -EINVAL;
1313 }
1314
1315 pdev = platform_device_alloc("wm8350-led", lednum);
1316 if (pdev == NULL) {
1317 dev_err(wm8350->dev, "Failed to allocate LED %d\n", lednum);
1318 return -ENOMEM;
1319 }
1320
Mark Brown34ce8d02012-02-02 13:45:09 +00001321 led->isink_consumer.dev_name = dev_name(&pdev->dev);
Mark Brown0081e802008-12-04 16:52:33 +00001322 led->isink_consumer.supply = "led_isink";
1323 led->isink_init.num_consumer_supplies = 1;
1324 led->isink_init.consumer_supplies = &led->isink_consumer;
1325 led->isink_init.constraints.min_uA = 0;
1326 led->isink_init.constraints.max_uA = pdata->max_uA;
Mark Browna2fad9b2010-01-04 15:30:54 +00001327 led->isink_init.constraints.valid_ops_mask
1328 = REGULATOR_CHANGE_CURRENT | REGULATOR_CHANGE_STATUS;
Mark Brown0081e802008-12-04 16:52:33 +00001329 led->isink_init.constraints.valid_modes_mask = REGULATOR_MODE_NORMAL;
1330 ret = wm8350_register_regulator(wm8350, isink, &led->isink_init);
1331 if (ret != 0) {
1332 platform_device_put(pdev);
1333 return ret;
1334 }
1335
Mark Brown34ce8d02012-02-02 13:45:09 +00001336 led->dcdc_consumer.dev_name = dev_name(&pdev->dev);
Mark Brown0081e802008-12-04 16:52:33 +00001337 led->dcdc_consumer.supply = "led_vcc";
1338 led->dcdc_init.num_consumer_supplies = 1;
1339 led->dcdc_init.consumer_supplies = &led->dcdc_consumer;
1340 led->dcdc_init.constraints.valid_modes_mask = REGULATOR_MODE_NORMAL;
Mark Browna2fad9b2010-01-04 15:30:54 +00001341 led->dcdc_init.constraints.valid_ops_mask = REGULATOR_CHANGE_STATUS;
Mark Brown0081e802008-12-04 16:52:33 +00001342 ret = wm8350_register_regulator(wm8350, dcdc, &led->dcdc_init);
1343 if (ret != 0) {
1344 platform_device_put(pdev);
1345 return ret;
1346 }
1347
1348 switch (isink) {
1349 case WM8350_ISINK_A:
1350 wm8350->pmic.isink_A_dcdc = dcdc;
1351 break;
1352 case WM8350_ISINK_B:
1353 wm8350->pmic.isink_B_dcdc = dcdc;
1354 break;
1355 }
1356
1357 pdev->dev.platform_data = pdata;
1358 pdev->dev.parent = wm8350->dev;
1359 ret = platform_device_add(pdev);
1360 if (ret != 0) {
1361 dev_err(wm8350->dev, "Failed to register LED %d: %d\n",
1362 lednum, ret);
1363 platform_device_put(pdev);
1364 return ret;
1365 }
1366
1367 led->pdev = pdev;
1368
1369 return 0;
1370}
1371EXPORT_SYMBOL_GPL(wm8350_register_led);
1372
Mark Brownda091552008-10-10 15:58:15 +01001373static struct platform_driver wm8350_regulator_driver = {
1374 .probe = wm8350_regulator_probe,
1375 .remove = wm8350_regulator_remove,
1376 .driver = {
1377 .name = "wm8350-regulator",
1378 },
1379};
1380
1381static int __init wm8350_regulator_init(void)
1382{
1383 return platform_driver_register(&wm8350_regulator_driver);
1384}
1385subsys_initcall(wm8350_regulator_init);
1386
1387static void __exit wm8350_regulator_exit(void)
1388{
1389 platform_driver_unregister(&wm8350_regulator_driver);
1390}
1391module_exit(wm8350_regulator_exit);
1392
1393/* Module information */
1394MODULE_AUTHOR("Liam Girdwood");
1395MODULE_DESCRIPTION("WM8350 voltage and current regulator driver");
1396MODULE_LICENSE("GPL");
Mark Brown38c53c82009-04-28 11:13:55 +01001397MODULE_ALIAS("platform:wm8350-regulator");