diff options
author | Sangbeom Kim <sbkim73@samsung.com> | 2012-01-09 05:10:25 -0500 |
---|---|---|
committer | Mark Brown <broonie@opensource.wolfsonmicro.com> | 2012-01-20 07:01:25 -0500 |
commit | 9767ec7fe8d9bf00e764f1d0ca0176988255be11 (patch) | |
tree | d09f8ca8662e7dd191f9d1f3a729488113b4ce96 | |
parent | 6219929f5f82708309b3054ec7db6cb6e3ee47d5 (diff) |
regulator: Add S5M8767A regulator driver
S5M8767A is a cost-effective PMIC which is designed for mobile applications.
It includes high efficient 9 Buck converters, 28 LDOs.
Especially, S5M8767A is optimized for Multi-core SOCs.
And during DVFS operation, S5M8767A output stable voltage.
This patch implement regulator driver for S5M8767A.
Signed-off-by: Sangbeom Kim <sbkim73@samsung.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
-rw-r--r-- | drivers/regulator/s5m8767.c | 834 |
1 files changed, 834 insertions, 0 deletions
diff --git a/drivers/regulator/s5m8767.c b/drivers/regulator/s5m8767.c new file mode 100644 index 000000000000..b3d356f5e271 --- /dev/null +++ b/drivers/regulator/s5m8767.c | |||
@@ -0,0 +1,834 @@ | |||
1 | /* | ||
2 | * s5m8767.c | ||
3 | * | ||
4 | * Copyright (c) 2011 Samsung Electronics Co., Ltd | ||
5 | * http://www.samsung.com | ||
6 | * | ||
7 | * This program is free software; you can redistribute it and/or modify it | ||
8 | * under the terms of the GNU General Public License as published by the | ||
9 | * Free Software Foundation; either version 2 of the License, or (at your | ||
10 | * option) any later version. | ||
11 | * | ||
12 | */ | ||
13 | |||
14 | #include <linux/bug.h> | ||
15 | #include <linux/delay.h> | ||
16 | #include <linux/err.h> | ||
17 | #include <linux/gpio.h> | ||
18 | #include <linux/slab.h> | ||
19 | #include <linux/module.h> | ||
20 | #include <linux/platform_device.h> | ||
21 | #include <linux/regulator/driver.h> | ||
22 | #include <linux/regulator/machine.h> | ||
23 | #include <linux/mfd/s5m87xx/s5m-core.h> | ||
24 | #include <linux/mfd/s5m87xx/s5m-pmic.h> | ||
25 | |||
26 | struct s5m8767_info { | ||
27 | struct device *dev; | ||
28 | struct s5m87xx_dev *iodev; | ||
29 | int num_regulators; | ||
30 | struct regulator_dev **rdev; | ||
31 | |||
32 | int ramp_delay; | ||
33 | bool buck2_ramp; | ||
34 | bool buck3_ramp; | ||
35 | bool buck4_ramp; | ||
36 | |||
37 | bool buck2_gpiodvs; | ||
38 | bool buck3_gpiodvs; | ||
39 | bool buck4_gpiodvs; | ||
40 | u8 buck2_vol[8]; | ||
41 | u8 buck3_vol[8]; | ||
42 | u8 buck4_vol[8]; | ||
43 | int buck_gpios[3]; | ||
44 | int buck_gpioindex; | ||
45 | }; | ||
46 | |||
47 | struct s5m_voltage_desc { | ||
48 | int max; | ||
49 | int min; | ||
50 | int step; | ||
51 | }; | ||
52 | |||
53 | static const struct s5m_voltage_desc buck_voltage_val1 = { | ||
54 | .max = 2225000, | ||
55 | .min = 650000, | ||
56 | .step = 6250, | ||
57 | }; | ||
58 | |||
59 | static const struct s5m_voltage_desc buck_voltage_val2 = { | ||
60 | .max = 1600000, | ||
61 | .min = 600000, | ||
62 | .step = 6250, | ||
63 | }; | ||
64 | |||
65 | static const struct s5m_voltage_desc buck_voltage_val3 = { | ||
66 | .max = 3000000, | ||
67 | .min = 750000, | ||
68 | .step = 12500, | ||
69 | }; | ||
70 | |||
71 | static const struct s5m_voltage_desc ldo_voltage_val1 = { | ||
72 | .max = 3950000, | ||
73 | .min = 800000, | ||
74 | .step = 50000, | ||
75 | }; | ||
76 | |||
77 | static const struct s5m_voltage_desc ldo_voltage_val2 = { | ||
78 | .max = 2375000, | ||
79 | .min = 800000, | ||
80 | .step = 25000, | ||
81 | }; | ||
82 | |||
83 | static const struct s5m_voltage_desc *reg_voltage_map[] = { | ||
84 | [S5M8767_LDO1] = &ldo_voltage_val2, | ||
85 | [S5M8767_LDO2] = &ldo_voltage_val2, | ||
86 | [S5M8767_LDO3] = &ldo_voltage_val1, | ||
87 | [S5M8767_LDO4] = &ldo_voltage_val1, | ||
88 | [S5M8767_LDO5] = &ldo_voltage_val1, | ||
89 | [S5M8767_LDO6] = &ldo_voltage_val2, | ||
90 | [S5M8767_LDO7] = &ldo_voltage_val2, | ||
91 | [S5M8767_LDO8] = &ldo_voltage_val2, | ||
92 | [S5M8767_LDO9] = &ldo_voltage_val1, | ||
93 | [S5M8767_LDO10] = &ldo_voltage_val1, | ||
94 | [S5M8767_LDO11] = &ldo_voltage_val1, | ||
95 | [S5M8767_LDO12] = &ldo_voltage_val1, | ||
96 | [S5M8767_LDO13] = &ldo_voltage_val1, | ||
97 | [S5M8767_LDO14] = &ldo_voltage_val1, | ||
98 | [S5M8767_LDO15] = &ldo_voltage_val2, | ||
99 | [S5M8767_LDO16] = &ldo_voltage_val1, | ||
100 | [S5M8767_LDO17] = &ldo_voltage_val1, | ||
101 | [S5M8767_LDO18] = &ldo_voltage_val1, | ||
102 | [S5M8767_LDO19] = &ldo_voltage_val1, | ||
103 | [S5M8767_LDO20] = &ldo_voltage_val1, | ||
104 | [S5M8767_LDO21] = &ldo_voltage_val1, | ||
105 | [S5M8767_LDO22] = &ldo_voltage_val1, | ||
106 | [S5M8767_LDO23] = &ldo_voltage_val1, | ||
107 | [S5M8767_LDO24] = &ldo_voltage_val1, | ||
108 | [S5M8767_LDO25] = &ldo_voltage_val1, | ||
109 | [S5M8767_LDO26] = &ldo_voltage_val1, | ||
110 | [S5M8767_LDO27] = &ldo_voltage_val1, | ||
111 | [S5M8767_LDO28] = &ldo_voltage_val1, | ||
112 | [S5M8767_BUCK1] = &buck_voltage_val1, | ||
113 | [S5M8767_BUCK2] = &buck_voltage_val2, | ||
114 | [S5M8767_BUCK3] = &buck_voltage_val2, | ||
115 | [S5M8767_BUCK4] = &buck_voltage_val2, | ||
116 | [S5M8767_BUCK5] = &buck_voltage_val1, | ||
117 | [S5M8767_BUCK6] = &buck_voltage_val1, | ||
118 | [S5M8767_BUCK7] = NULL, | ||
119 | [S5M8767_BUCK8] = NULL, | ||
120 | [S5M8767_BUCK9] = &buck_voltage_val3, | ||
121 | }; | ||
122 | |||
123 | static inline int s5m8767_get_reg_id(struct regulator_dev *rdev) | ||
124 | { | ||
125 | return rdev_get_id(rdev); | ||
126 | } | ||
127 | |||
128 | static int s5m8767_list_voltage(struct regulator_dev *rdev, | ||
129 | unsigned int selector) | ||
130 | { | ||
131 | const struct s5m_voltage_desc *desc; | ||
132 | int reg_id = s5m8767_get_reg_id(rdev); | ||
133 | int val; | ||
134 | |||
135 | if (reg_id >= ARRAY_SIZE(reg_voltage_map) || reg_id < 0) | ||
136 | return -EINVAL; | ||
137 | |||
138 | desc = reg_voltage_map[reg_id]; | ||
139 | if (desc == NULL) | ||
140 | return -EINVAL; | ||
141 | |||
142 | val = desc->min + desc->step * selector; | ||
143 | if (val > desc->max) | ||
144 | return -EINVAL; | ||
145 | |||
146 | return val; | ||
147 | } | ||
148 | |||
149 | static int s5m8767_get_register(struct regulator_dev *rdev, int *reg) | ||
150 | { | ||
151 | int reg_id = s5m8767_get_reg_id(rdev); | ||
152 | |||
153 | switch (reg_id) { | ||
154 | case S5M8767_LDO1 ... S5M8767_LDO2: | ||
155 | *reg = S5M8767_REG_LDO1CTRL + (reg_id - S5M8767_LDO1); | ||
156 | break; | ||
157 | case S5M8767_LDO3 ... S5M8767_LDO28: | ||
158 | *reg = S5M8767_REG_LDO3CTRL + (reg_id - S5M8767_LDO3); | ||
159 | break; | ||
160 | case S5M8767_BUCK1: | ||
161 | *reg = S5M8767_REG_BUCK1CTRL1; | ||
162 | break; | ||
163 | case S5M8767_BUCK2 ... S5M8767_BUCK4: | ||
164 | *reg = S5M8767_REG_BUCK2CTRL + (reg_id - S5M8767_BUCK2) * 9; | ||
165 | break; | ||
166 | case S5M8767_BUCK5: | ||
167 | *reg = S5M8767_REG_BUCK5CTRL1; | ||
168 | break; | ||
169 | case S5M8767_BUCK6 ... S5M8767_BUCK9: | ||
170 | *reg = S5M8767_REG_BUCK6CTRL1 + (reg_id - S5M8767_BUCK6) * 2; | ||
171 | break; | ||
172 | default: | ||
173 | return -EINVAL; | ||
174 | } | ||
175 | |||
176 | return 0; | ||
177 | } | ||
178 | |||
179 | static int s5m8767_reg_is_enabled(struct regulator_dev *rdev) | ||
180 | { | ||
181 | struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev); | ||
182 | int ret, reg; | ||
183 | int mask = 0xc0, pattern = 0xc0; | ||
184 | u8 val; | ||
185 | |||
186 | ret = s5m8767_get_register(rdev, ®); | ||
187 | if (ret == -EINVAL) | ||
188 | return 1; | ||
189 | else if (ret) | ||
190 | return ret; | ||
191 | |||
192 | ret = s5m_reg_read(s5m8767->iodev, reg, &val); | ||
193 | if (ret) | ||
194 | return ret; | ||
195 | |||
196 | return (val & mask) == pattern; | ||
197 | } | ||
198 | |||
199 | static int s5m8767_reg_enable(struct regulator_dev *rdev) | ||
200 | { | ||
201 | struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev); | ||
202 | int ret, reg; | ||
203 | int mask = 0xc0, pattern = 0xc0; | ||
204 | |||
205 | ret = s5m8767_get_register(rdev, ®); | ||
206 | if (ret) | ||
207 | return ret; | ||
208 | |||
209 | return s5m_reg_update(s5m8767->iodev, reg, pattern, mask); | ||
210 | } | ||
211 | |||
212 | static int s5m8767_reg_disable(struct regulator_dev *rdev) | ||
213 | { | ||
214 | struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev); | ||
215 | int ret, reg; | ||
216 | int mask = 0xc0, pattern = 0xc0; | ||
217 | |||
218 | ret = s5m8767_get_register(rdev, ®); | ||
219 | if (ret) | ||
220 | return ret; | ||
221 | |||
222 | return s5m_reg_update(s5m8767->iodev, reg, ~pattern, mask); | ||
223 | } | ||
224 | |||
225 | static int s5m8767_get_voltage_register(struct regulator_dev *rdev, int *_reg) | ||
226 | { | ||
227 | int reg_id = s5m8767_get_reg_id(rdev); | ||
228 | int reg; | ||
229 | |||
230 | switch (reg_id) { | ||
231 | case S5M8767_LDO1 ... S5M8767_LDO2: | ||
232 | reg = S5M8767_REG_LDO1CTRL + (reg_id - S5M8767_LDO1); | ||
233 | break; | ||
234 | case S5M8767_LDO3 ... S5M8767_LDO28: | ||
235 | reg = S5M8767_REG_LDO3CTRL + (reg_id - S5M8767_LDO3); | ||
236 | break; | ||
237 | case S5M8767_BUCK1: | ||
238 | reg = S5M8767_REG_BUCK1CTRL2; | ||
239 | break; | ||
240 | case S5M8767_BUCK2: | ||
241 | reg = S5M8767_REG_BUCK2DVS1; | ||
242 | break; | ||
243 | case S5M8767_BUCK3: | ||
244 | reg = S5M8767_REG_BUCK3DVS1; | ||
245 | break; | ||
246 | case S5M8767_BUCK4: | ||
247 | reg = S5M8767_REG_BUCK4DVS1; | ||
248 | break; | ||
249 | case S5M8767_BUCK5: | ||
250 | reg = S5M8767_REG_BUCK5CTRL2; | ||
251 | break; | ||
252 | case S5M8767_BUCK6 ... S5M8767_BUCK9: | ||
253 | reg = S5M8767_REG_BUCK6CTRL2 + (reg_id - S5M8767_BUCK6) * 2; | ||
254 | break; | ||
255 | default: | ||
256 | return -EINVAL; | ||
257 | } | ||
258 | |||
259 | *_reg = reg; | ||
260 | |||
261 | return 0; | ||
262 | } | ||
263 | |||
264 | static int s5m8767_get_voltage_sel(struct regulator_dev *rdev) | ||
265 | { | ||
266 | struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev); | ||
267 | int reg, mask = 0xff, ret; | ||
268 | int reg_id = s5m8767_get_reg_id(rdev); | ||
269 | u8 val; | ||
270 | |||
271 | ret = s5m8767_get_voltage_register(rdev, ®); | ||
272 | if (ret) | ||
273 | return ret; | ||
274 | |||
275 | switch (reg_id) { | ||
276 | case S5M8767_LDO1 ... S5M8767_LDO28: | ||
277 | mask = 0x3f; | ||
278 | break; | ||
279 | case S5M8767_BUCK2: | ||
280 | if (s5m8767->buck2_gpiodvs) | ||
281 | reg += s5m8767->buck_gpioindex; | ||
282 | break; | ||
283 | case S5M8767_BUCK3: | ||
284 | if (s5m8767->buck3_gpiodvs) | ||
285 | reg += s5m8767->buck_gpioindex; | ||
286 | break; | ||
287 | case S5M8767_BUCK4: | ||
288 | if (s5m8767->buck4_gpiodvs) | ||
289 | reg += s5m8767->buck_gpioindex; | ||
290 | break; | ||
291 | } | ||
292 | |||
293 | ret = s5m_reg_read(s5m8767->iodev, reg, &val); | ||
294 | if (ret) | ||
295 | return ret; | ||
296 | |||
297 | val &= mask; | ||
298 | |||
299 | return val; | ||
300 | } | ||
301 | |||
302 | static inline int s5m8767_convert_voltage( | ||
303 | const struct s5m_voltage_desc *desc, | ||
304 | int min_vol, int max_vol) | ||
305 | { | ||
306 | int out_vol = 0; | ||
307 | |||
308 | if (desc == NULL) | ||
309 | return -EINVAL; | ||
310 | |||
311 | if (max_vol < desc->min || min_vol > desc->max) | ||
312 | return -EINVAL; | ||
313 | |||
314 | out_vol = (min_vol - desc->min) / desc->step; | ||
315 | |||
316 | if (desc->min + desc->step * out_vol > max_vol) | ||
317 | return -EINVAL; | ||
318 | |||
319 | return out_vol; | ||
320 | } | ||
321 | |||
322 | static int s5m8767_set_voltage(struct regulator_dev *rdev, | ||
323 | int min_uV, int max_uV, unsigned *selector) | ||
324 | { | ||
325 | struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev); | ||
326 | int min_vol = min_uV, max_vol = max_uV; | ||
327 | const struct s5m_voltage_desc *desc; | ||
328 | int reg_id = s5m8767_get_reg_id(rdev); | ||
329 | int reg, mask, ret; | ||
330 | int i; | ||
331 | u8 val; | ||
332 | |||
333 | switch (reg_id) { | ||
334 | case S5M8767_LDO1 ... S5M8767_LDO28: | ||
335 | mask = 0x3f; | ||
336 | break; | ||
337 | case S5M8767_BUCK1 ... S5M8767_BUCK6: | ||
338 | mask = 0xff; | ||
339 | break; | ||
340 | case S5M8767_BUCK7 ... S5M8767_BUCK8: | ||
341 | return -EINVAL; | ||
342 | case S5M8767_BUCK9: | ||
343 | mask = 0xff; | ||
344 | break; | ||
345 | default: | ||
346 | return -EINVAL; | ||
347 | } | ||
348 | |||
349 | desc = reg_voltage_map[reg_id]; | ||
350 | |||
351 | i = s5m8767_convert_voltage(desc, min_vol, max_vol); | ||
352 | if (i < 0) | ||
353 | return i; | ||
354 | |||
355 | ret = s5m8767_get_voltage_register(rdev, ®); | ||
356 | if (ret) | ||
357 | return ret; | ||
358 | |||
359 | s5m_reg_read(s5m8767->iodev, reg, &val); | ||
360 | val = val & mask; | ||
361 | |||
362 | ret = s5m_reg_write(s5m8767->iodev, reg, val); | ||
363 | *selector = i; | ||
364 | |||
365 | return ret; | ||
366 | } | ||
367 | |||
368 | static inline void s5m8767_set_high(struct s5m8767_info *s5m8767) | ||
369 | { | ||
370 | int temp_index = s5m8767->buck_gpioindex; | ||
371 | |||
372 | gpio_set_value(s5m8767->buck_gpios[0], (temp_index >> 2) & 0x1); | ||
373 | gpio_set_value(s5m8767->buck_gpios[1], (temp_index >> 1) & 0x1); | ||
374 | gpio_set_value(s5m8767->buck_gpios[2], temp_index & 0x1); | ||
375 | } | ||
376 | |||
377 | static inline void s5m8767_set_low(struct s5m8767_info *s5m8767) | ||
378 | { | ||
379 | int temp_index = s5m8767->buck_gpioindex; | ||
380 | |||
381 | gpio_set_value(s5m8767->buck_gpios[2], temp_index & 0x1); | ||
382 | gpio_set_value(s5m8767->buck_gpios[1], (temp_index >> 1) & 0x1); | ||
383 | gpio_set_value(s5m8767->buck_gpios[0], (temp_index >> 2) & 0x1); | ||
384 | } | ||
385 | |||
386 | static int s5m8767_set_voltage_buck(struct regulator_dev *rdev, | ||
387 | int min_uV, int max_uV, unsigned *selector) | ||
388 | { | ||
389 | struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev); | ||
390 | int reg_id = s5m8767_get_reg_id(rdev); | ||
391 | const struct s5m_voltage_desc *desc; | ||
392 | int new_val, old_val, i = 0; | ||
393 | int min_vol = min_uV, max_vol = max_uV; | ||
394 | |||
395 | if (reg_id < S5M8767_BUCK1 || reg_id > S5M8767_BUCK6) | ||
396 | return -EINVAL; | ||
397 | |||
398 | switch (reg_id) { | ||
399 | case S5M8767_BUCK1: | ||
400 | return s5m8767_set_voltage(rdev, min_uV, max_uV, selector); | ||
401 | case S5M8767_BUCK2 ... S5M8767_BUCK4: | ||
402 | break; | ||
403 | case S5M8767_BUCK5 ... S5M8767_BUCK6: | ||
404 | return s5m8767_set_voltage(rdev, min_uV, max_uV, selector); | ||
405 | case S5M8767_BUCK9: | ||
406 | return s5m8767_set_voltage(rdev, min_uV, max_uV, selector); | ||
407 | } | ||
408 | |||
409 | desc = reg_voltage_map[reg_id]; | ||
410 | new_val = s5m8767_convert_voltage(desc, min_vol, max_vol); | ||
411 | if (new_val < 0) | ||
412 | return new_val; | ||
413 | |||
414 | switch (reg_id) { | ||
415 | case S5M8767_BUCK2: | ||
416 | if (s5m8767->buck2_gpiodvs) { | ||
417 | while (s5m8767->buck2_vol[i] != new_val) | ||
418 | i++; | ||
419 | } else | ||
420 | return s5m8767_set_voltage(rdev, min_uV, | ||
421 | max_uV, selector); | ||
422 | break; | ||
423 | case S5M8767_BUCK3: | ||
424 | if (s5m8767->buck3_gpiodvs) { | ||
425 | while (s5m8767->buck3_vol[i] != new_val) | ||
426 | i++; | ||
427 | } else | ||
428 | return s5m8767_set_voltage(rdev, min_uV, | ||
429 | max_uV, selector); | ||
430 | break; | ||
431 | case S5M8767_BUCK4: | ||
432 | if (s5m8767->buck3_gpiodvs) { | ||
433 | while (s5m8767->buck4_vol[i] != new_val) | ||
434 | i++; | ||
435 | } else | ||
436 | return s5m8767_set_voltage(rdev, min_uV, | ||
437 | max_uV, selector); | ||
438 | break; | ||
439 | } | ||
440 | |||
441 | old_val = s5m8767->buck_gpioindex; | ||
442 | s5m8767->buck_gpioindex = i; | ||
443 | |||
444 | if (i > old_val) | ||
445 | s5m8767_set_high(s5m8767); | ||
446 | else | ||
447 | s5m8767_set_low(s5m8767); | ||
448 | |||
449 | *selector = new_val; | ||
450 | return 0; | ||
451 | } | ||
452 | |||
453 | static int s5m8767_set_voltage_time_sel(struct regulator_dev *rdev, | ||
454 | unsigned int old_sel, | ||
455 | unsigned int new_sel) | ||
456 | { | ||
457 | struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev); | ||
458 | const struct s5m_voltage_desc *desc; | ||
459 | int reg_id = s5m8767_get_reg_id(rdev); | ||
460 | int mask; | ||
461 | int new_val, old_val; | ||
462 | |||
463 | switch (reg_id) { | ||
464 | case S5M8767_LDO1 ... S5M8767_LDO28: | ||
465 | mask = 0x3f; | ||
466 | break; | ||
467 | case S5M8767_BUCK1 ... S5M8767_BUCK6: | ||
468 | mask = 0xff; | ||
469 | break; | ||
470 | case S5M8767_BUCK7 ... S5M8767_BUCK8: | ||
471 | return -EINVAL; | ||
472 | case S5M8767_BUCK9: | ||
473 | mask = 0xff; | ||
474 | break; | ||
475 | default: | ||
476 | return -EINVAL; | ||
477 | } | ||
478 | desc = reg_voltage_map[reg_id]; | ||
479 | |||
480 | new_val = s5m8767_convert_voltage(desc, new_sel, new_sel); | ||
481 | if (new_val < 0) | ||
482 | return new_val; | ||
483 | |||
484 | old_val = s5m8767_convert_voltage(desc, old_sel, old_sel); | ||
485 | if (old_val < 0) | ||
486 | return old_val; | ||
487 | |||
488 | if (old_sel < new_sel) | ||
489 | return DIV_ROUND_UP(desc->step * (new_val - old_val), | ||
490 | s5m8767->ramp_delay); | ||
491 | else | ||
492 | return 0; | ||
493 | } | ||
494 | |||
495 | static struct regulator_ops s5m8767_ldo_ops = { | ||
496 | .list_voltage = s5m8767_list_voltage, | ||
497 | .is_enabled = s5m8767_reg_is_enabled, | ||
498 | .enable = s5m8767_reg_enable, | ||
499 | .disable = s5m8767_reg_disable, | ||
500 | .get_voltage_sel = s5m8767_get_voltage_sel, | ||
501 | .set_voltage = s5m8767_set_voltage, | ||
502 | .set_voltage_time_sel = s5m8767_set_voltage_time_sel, | ||
503 | }; | ||
504 | |||
505 | static struct regulator_ops s5m8767_buck_ops = { | ||
506 | .list_voltage = s5m8767_list_voltage, | ||
507 | .is_enabled = s5m8767_reg_is_enabled, | ||
508 | .enable = s5m8767_reg_enable, | ||
509 | .disable = s5m8767_reg_disable, | ||
510 | .get_voltage_sel = s5m8767_get_voltage_sel, | ||
511 | .set_voltage = s5m8767_set_voltage_buck, | ||
512 | .set_voltage_time_sel = s5m8767_set_voltage_time_sel, | ||
513 | }; | ||
514 | |||
515 | #define regulator_desc_ldo(num) { \ | ||
516 | .name = "LDO"#num, \ | ||
517 | .id = S5M8767_LDO##num, \ | ||
518 | .ops = &s5m8767_ldo_ops, \ | ||
519 | .type = REGULATOR_VOLTAGE, \ | ||
520 | .owner = THIS_MODULE, \ | ||
521 | } | ||
522 | #define regulator_desc_buck(num) { \ | ||
523 | .name = "BUCK"#num, \ | ||
524 | .id = S5M8767_BUCK##num, \ | ||
525 | .ops = &s5m8767_buck_ops, \ | ||
526 | .type = REGULATOR_VOLTAGE, \ | ||
527 | .owner = THIS_MODULE, \ | ||
528 | } | ||
529 | |||
530 | static struct regulator_desc regulators[] = { | ||
531 | regulator_desc_ldo(1), | ||
532 | regulator_desc_ldo(2), | ||
533 | regulator_desc_ldo(3), | ||
534 | regulator_desc_ldo(4), | ||
535 | regulator_desc_ldo(5), | ||
536 | regulator_desc_ldo(6), | ||
537 | regulator_desc_ldo(7), | ||
538 | regulator_desc_ldo(8), | ||
539 | regulator_desc_ldo(9), | ||
540 | regulator_desc_ldo(10), | ||
541 | regulator_desc_ldo(11), | ||
542 | regulator_desc_ldo(12), | ||
543 | regulator_desc_ldo(13), | ||
544 | regulator_desc_ldo(14), | ||
545 | regulator_desc_ldo(15), | ||
546 | regulator_desc_ldo(16), | ||
547 | regulator_desc_ldo(17), | ||
548 | regulator_desc_ldo(18), | ||
549 | regulator_desc_ldo(19), | ||
550 | regulator_desc_ldo(20), | ||
551 | regulator_desc_ldo(21), | ||
552 | regulator_desc_ldo(22), | ||
553 | regulator_desc_ldo(23), | ||
554 | regulator_desc_ldo(24), | ||
555 | regulator_desc_ldo(25), | ||
556 | regulator_desc_ldo(26), | ||
557 | regulator_desc_ldo(27), | ||
558 | regulator_desc_ldo(28), | ||
559 | regulator_desc_buck(1), | ||
560 | regulator_desc_buck(2), | ||
561 | regulator_desc_buck(3), | ||
562 | regulator_desc_buck(4), | ||
563 | regulator_desc_buck(5), | ||
564 | regulator_desc_buck(6), | ||
565 | regulator_desc_buck(7), | ||
566 | regulator_desc_buck(8), | ||
567 | regulator_desc_buck(9), | ||
568 | }; | ||
569 | |||
570 | static __devinit int s5m8767_pmic_probe(struct platform_device *pdev) | ||
571 | { | ||
572 | struct s5m87xx_dev *iodev = dev_get_drvdata(pdev->dev.parent); | ||
573 | struct s5m_platform_data *pdata = dev_get_platdata(iodev->dev); | ||
574 | struct regulator_dev **rdev; | ||
575 | struct s5m8767_info *s5m8767; | ||
576 | struct i2c_client *i2c; | ||
577 | int i, ret, size, reg; | ||
578 | |||
579 | if (!pdata) { | ||
580 | dev_err(pdev->dev.parent, "Platform data not supplied\n"); | ||
581 | return -ENODEV; | ||
582 | } | ||
583 | |||
584 | s5m8767 = devm_kzalloc(&pdev->dev, sizeof(struct s5m8767_info), | ||
585 | GFP_KERNEL); | ||
586 | if (!s5m8767) | ||
587 | return -ENOMEM; | ||
588 | |||
589 | size = sizeof(struct regulator_dev *) * (S5M8767_REG_MAX - 2); | ||
590 | s5m8767->rdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL); | ||
591 | if (!s5m8767->rdev) | ||
592 | return -ENOMEM; | ||
593 | |||
594 | rdev = s5m8767->rdev; | ||
595 | s5m8767->dev = &pdev->dev; | ||
596 | s5m8767->iodev = iodev; | ||
597 | s5m8767->num_regulators = S5M8767_REG_MAX - 2; | ||
598 | platform_set_drvdata(pdev, s5m8767); | ||
599 | i2c = s5m8767->iodev->i2c; | ||
600 | |||
601 | s5m8767->buck_gpioindex = pdata->buck_default_idx; | ||
602 | s5m8767->buck2_gpiodvs = pdata->buck2_gpiodvs; | ||
603 | s5m8767->buck3_gpiodvs = pdata->buck3_gpiodvs; | ||
604 | s5m8767->buck4_gpiodvs = pdata->buck4_gpiodvs; | ||
605 | s5m8767->buck_gpios[0] = pdata->buck_gpios[0]; | ||
606 | s5m8767->buck_gpios[1] = pdata->buck_gpios[1]; | ||
607 | s5m8767->buck_gpios[2] = pdata->buck_gpios[2]; | ||
608 | s5m8767->ramp_delay = pdata->buck_ramp_delay; | ||
609 | s5m8767->buck2_ramp = pdata->buck2_ramp_enable; | ||
610 | s5m8767->buck3_ramp = pdata->buck3_ramp_enable; | ||
611 | s5m8767->buck4_ramp = pdata->buck4_ramp_enable; | ||
612 | |||
613 | for (i = 0; i < 8; i++) { | ||
614 | if (s5m8767->buck2_gpiodvs) { | ||
615 | s5m8767->buck2_vol[i] = | ||
616 | s5m8767_convert_voltage( | ||
617 | &buck_voltage_val2, | ||
618 | pdata->buck2_voltage[i], | ||
619 | pdata->buck2_voltage[i] + | ||
620 | buck_voltage_val2.step); | ||
621 | } | ||
622 | |||
623 | if (s5m8767->buck3_gpiodvs) { | ||
624 | s5m8767->buck3_vol[i] = | ||
625 | s5m8767_convert_voltage( | ||
626 | &buck_voltage_val2, | ||
627 | pdata->buck3_voltage[i], | ||
628 | pdata->buck3_voltage[i] + | ||
629 | buck_voltage_val2.step); | ||
630 | } | ||
631 | |||
632 | if (s5m8767->buck4_gpiodvs) { | ||
633 | s5m8767->buck4_vol[i] = | ||
634 | s5m8767_convert_voltage( | ||
635 | &buck_voltage_val2, | ||
636 | pdata->buck4_voltage[i], | ||
637 | pdata->buck4_voltage[i] + | ||
638 | buck_voltage_val2.step); | ||
639 | } | ||
640 | } | ||
641 | |||
642 | if (pdata->buck2_gpiodvs || pdata->buck3_gpiodvs || | ||
643 | pdata->buck4_gpiodvs) { | ||
644 | if (gpio_is_valid(pdata->buck_gpios[0]) && | ||
645 | gpio_is_valid(pdata->buck_gpios[1]) && | ||
646 | gpio_is_valid(pdata->buck_gpios[2])) { | ||
647 | ret = gpio_request(pdata->buck_gpios[0], | ||
648 | "S5M8767 SET1"); | ||
649 | if (ret == -EBUSY) | ||
650 | dev_warn(&pdev->dev, "Duplicated gpio request for SET1\n"); | ||
651 | |||
652 | ret = gpio_request(pdata->buck_gpios[1], | ||
653 | "S5M8767 SET2"); | ||
654 | if (ret == -EBUSY) | ||
655 | dev_warn(&pdev->dev, "Duplicated gpio request for SET2\n"); | ||
656 | |||
657 | ret = gpio_request(pdata->buck_gpios[2], | ||
658 | "S5M8767 SET3"); | ||
659 | if (ret == -EBUSY) | ||
660 | dev_warn(&pdev->dev, "Duplicated gpio request for SET3\n"); | ||
661 | /* SET1 GPIO */ | ||
662 | gpio_direction_output(pdata->buck_gpios[0], | ||
663 | (s5m8767->buck_gpioindex >> 2) & 0x1); | ||
664 | /* SET2 GPIO */ | ||
665 | gpio_direction_output(pdata->buck_gpios[1], | ||
666 | (s5m8767->buck_gpioindex >> 1) & 0x1); | ||
667 | /* SET3 GPIO */ | ||
668 | gpio_direction_output(pdata->buck_gpios[2], | ||
669 | (s5m8767->buck_gpioindex >> 0) & 0x1); | ||
670 | ret = 0; | ||
671 | } else { | ||
672 | dev_err(&pdev->dev, "GPIO NOT VALID\n"); | ||
673 | ret = -EINVAL; | ||
674 | return ret; | ||
675 | } | ||
676 | } | ||
677 | |||
678 | if (pdata->buck2_gpiodvs) { | ||
679 | if (pdata->buck3_gpiodvs || pdata->buck4_gpiodvs) { | ||
680 | dev_err(&pdev->dev, "S5M8767 GPIO DVS NOT VALID\n"); | ||
681 | ret = -EINVAL; | ||
682 | return ret; | ||
683 | } | ||
684 | } | ||
685 | |||
686 | if (pdata->buck3_gpiodvs) { | ||
687 | if (pdata->buck2_gpiodvs || pdata->buck4_gpiodvs) { | ||
688 | dev_err(&pdev->dev, "S5M8767 GPIO DVS NOT VALID\n"); | ||
689 | ret = -EINVAL; | ||
690 | return ret; | ||
691 | } | ||
692 | } | ||
693 | |||
694 | if (pdata->buck4_gpiodvs) { | ||
695 | if (pdata->buck2_gpiodvs || pdata->buck3_gpiodvs) { | ||
696 | dev_err(&pdev->dev, "S5M8767 GPIO DVS NOT VALID\n"); | ||
697 | ret = -EINVAL; | ||
698 | return ret; | ||
699 | } | ||
700 | } | ||
701 | |||
702 | s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK2CTRL, | ||
703 | (pdata->buck2_gpiodvs) ? (1 << 1) : (0 << 1), 1 << 1); | ||
704 | s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK3CTRL, | ||
705 | (pdata->buck3_gpiodvs) ? (1 << 1) : (0 << 1), 1 << 1); | ||
706 | s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK4CTRL, | ||
707 | (pdata->buck4_gpiodvs) ? (1 << 1) : (0 << 1), 1 << 1); | ||
708 | |||
709 | /* Initialize GPIO DVS registers */ | ||
710 | for (i = 0; i < 8; i++) { | ||
711 | if (s5m8767->buck2_gpiodvs) { | ||
712 | s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK2DVS1 + i, | ||
713 | s5m8767->buck2_vol[i]); | ||
714 | } | ||
715 | |||
716 | if (s5m8767->buck3_gpiodvs) { | ||
717 | s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK3DVS1 + i, | ||
718 | s5m8767->buck3_vol[i]); | ||
719 | } | ||
720 | |||
721 | if (s5m8767->buck4_gpiodvs) { | ||
722 | s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK4DVS1 + i, | ||
723 | s5m8767->buck4_vol[i]); | ||
724 | } | ||
725 | } | ||
726 | s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK2CTRL, 0x78, 0xff); | ||
727 | s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK3CTRL, 0x58, 0xff); | ||
728 | s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK4CTRL, 0x78, 0xff); | ||
729 | |||
730 | if (s5m8767->buck2_ramp) | ||
731 | s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x08, 0x08); | ||
732 | |||
733 | if (s5m8767->buck3_ramp) | ||
734 | s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x04, 0x04); | ||
735 | |||
736 | if (s5m8767->buck4_ramp) | ||
737 | s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x02, 0x02); | ||
738 | |||
739 | if (s5m8767->buck2_ramp || s5m8767->buck3_ramp | ||
740 | || s5m8767->buck4_ramp) { | ||
741 | switch (s5m8767->ramp_delay) { | ||
742 | case 15: | ||
743 | s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, | ||
744 | 0xc0, 0xf0); | ||
745 | case 25: | ||
746 | s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, | ||
747 | 0xd0, 0xf0); | ||
748 | case 50: | ||
749 | s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, | ||
750 | 0xe0, 0xf0); | ||
751 | case 100: | ||
752 | s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, | ||
753 | 0xf0, 0xf0); | ||
754 | default: | ||
755 | s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, | ||
756 | 0x90, 0xf0); | ||
757 | } | ||
758 | } | ||
759 | |||
760 | for (i = 0; i < pdata->num_regulators; i++) { | ||
761 | const struct s5m_voltage_desc *desc; | ||
762 | int id = pdata->regulators[i].id; | ||
763 | |||
764 | desc = reg_voltage_map[id]; | ||
765 | if (desc) | ||
766 | regulators[id].n_voltages = | ||
767 | (desc->max - desc->min) / desc->step + 1; | ||
768 | |||
769 | rdev[i] = regulator_register(®ulators[id], s5m8767->dev, | ||
770 | pdata->regulators[i].initdata, s5m8767); | ||
771 | if (IS_ERR(rdev[i])) { | ||
772 | ret = PTR_ERR(rdev[i]); | ||
773 | dev_err(s5m8767->dev, "regulator init failed for %d\n", | ||
774 | id); | ||
775 | rdev[i] = NULL; | ||
776 | goto err; | ||
777 | } | ||
778 | } | ||
779 | |||
780 | return 0; | ||
781 | err: | ||
782 | for (i = 0; i < s5m8767->num_regulators; i++) | ||
783 | if (rdev[i]) | ||
784 | regulator_unregister(rdev[i]); | ||
785 | |||
786 | return ret; | ||
787 | } | ||
788 | |||
789 | static int __devexit s5m8767_pmic_remove(struct platform_device *pdev) | ||
790 | { | ||
791 | struct s5m8767_info *s5m8767 = platform_get_drvdata(pdev); | ||
792 | struct regulator_dev **rdev = s5m8767->rdev; | ||
793 | int i; | ||
794 | |||
795 | for (i = 0; i < s5m8767->num_regulators; i++) | ||
796 | if (rdev[i]) | ||
797 | regulator_unregister(rdev[i]); | ||
798 | |||
799 | return 0; | ||
800 | } | ||
801 | |||
802 | static const struct platform_device_id s5m8767_pmic_id[] = { | ||
803 | { "s5m8767-pmic", 0}, | ||
804 | { }, | ||
805 | }; | ||
806 | MODULE_DEVICE_TABLE(platform, s5m8767_pmic_id); | ||
807 | |||
808 | static struct platform_driver s5m8767_pmic_driver = { | ||
809 | .driver = { | ||
810 | .name = "s5m8767-pmic", | ||
811 | .owner = THIS_MODULE, | ||
812 | }, | ||
813 | .probe = s5m8767_pmic_probe, | ||
814 | .remove = __devexit_p(s5m8767_pmic_remove), | ||
815 | .id_table = s5m8767_pmic_id, | ||
816 | }; | ||
817 | |||
818 | static int __init s5m8767_pmic_init(void) | ||
819 | { | ||
820 | return platform_driver_register(&s5m8767_pmic_driver); | ||
821 | } | ||
822 | subsys_initcall(s5m8767_pmic_init); | ||
823 | |||
824 | static void __exit s5m8767_pmic_exit(void) | ||
825 | { | ||
826 | platform_driver_unregister(&s5m8767_pmic_driver); | ||
827 | } | ||
828 | module_exit(s5m8767_pmic_exit); | ||
829 | |||
830 | /* Module information */ | ||
831 | MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>"); | ||
832 | MODULE_DESCRIPTION("SAMSUNG S5M8767 Regulator Driver"); | ||
833 | MODULE_LICENSE("GPL"); | ||
834 | MODULE_ALIAS("platform:s5m8767-pmic"); | ||