projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
regulator: max8907: fix compile error when !CONFIG_OF
[linux-block.git] / drivers / regulator / ab8500.c
CommitLineData
c789ca20
SI		 1/*
2 * Copyright (C) ST-Ericsson SA 2010
3 *
4 * License Terms: GNU General Public License v2
5 *
e1159e6d
BJ		 6 * Authors: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
7 * Bengt Jonsson <bengt.g.jonsson@stericsson.com> for ST-Ericsson
c789ca20
SI		 8 *
9 * AB8500 peripheral regulators
10 *
e1159e6d 11 * AB8500 supports the following regulators:
ea05ef31 12 * VAUX1/2/3, VINTCORE, VTVOUT, VUSB, VAUDIO, VAMIC1/2, VDMIC, VANA
c789ca20
SI		 13 */
14#include <linux/init.h>
15#include <linux/kernel.h>
65602c32 16#include <linux/module.h>
c789ca20
SI		 17#include <linux/err.h>
18#include <linux/platform_device.h>
47c16975 19#include <linux/mfd/abx500.h>
ee66e653 20#include <linux/mfd/abx500/ab8500.h>
3a8334b9
LJ		 21#include <linux/of.h>
22#include <linux/regulator/of_regulator.h>
c789ca20
SI		 23#include <linux/regulator/driver.h>
24#include <linux/regulator/machine.h>
25#include <linux/regulator/ab8500.h>
3a8334b9 26#include <linux/slab.h>
c789ca20
SI		 27
28/**
29 * struct ab8500_regulator_info - ab8500 regulator information
e1159e6d 30 * @dev: device pointer
c789ca20 31 * @desc: regulator description
c789ca20 32 * @regulator_dev: regulator device
47c16975 33 * @update_bank: bank to control on/off
c789ca20 34 * @update_reg: register to control on/off
e1159e6d
BJ		 35 * @update_mask: mask to enable/disable regulator
36 * @update_val_enable: bits to enable the regulator in normal (high power) mode
47c16975 37 * @voltage_bank: bank to control regulator voltage
c789ca20
SI		 38 * @voltage_reg: register to control regulator voltage
39 * @voltage_mask: mask to control regulator voltage
42ab616a 40 * @delay: startup/set voltage delay in us
c789ca20
SI		 41 */
42struct ab8500_regulator_info {
43 struct device *dev;
44 struct regulator_desc desc;
c789ca20 45 struct regulator_dev *regulator;
47c16975
MW		 46 u8 update_bank;
47 u8 update_reg;
e1159e6d
BJ		 48 u8 update_mask;
49 u8 update_val_enable;
47c16975
MW		 50 u8 voltage_bank;
51 u8 voltage_reg;
52 u8 voltage_mask;
42ab616a 53 unsigned int delay;
c789ca20
SI		 54};
55
56/* voltage tables for the vauxn/vintcore supplies */
ec1cc4d9 57static const unsigned int ldo_vauxn_voltages[] = {
c789ca20
SI		 58 1100000,
59 1200000,
60 1300000,
61 1400000,
62 1500000,
63 1800000,
64 1850000,
65 1900000,
66 2500000,
67 2650000,
68 2700000,
69 2750000,
70 2800000,
71 2900000,
72 3000000,
73 3300000,
74};
75
ec1cc4d9 76static const unsigned int ldo_vaux3_voltages[] = {
2b75151a
BJ		 77 1200000,
78 1500000,
79 1800000,
80 2100000,
81 2500000,
82 2750000,
83 2790000,
84 2910000,
85};
86
ec1cc4d9 87static const unsigned int ldo_vintcore_voltages[] = {
c789ca20
SI		 88 1200000,
89 1225000,
90 1250000,
91 1275000,
92 1300000,
93 1325000,
94 1350000,
95};
96
97static int ab8500_regulator_enable(struct regulator_dev *rdev)
98{
fc24b426 99 int ret;
c789ca20
SI		 100 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
101
fc24b426
BJ		 102 if (info == NULL) {
103 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
c789ca20 104 return -EINVAL;
fc24b426 105 }
c789ca20 106
47c16975 107 ret = abx500_mask_and_set_register_interruptible(info->dev,
e1159e6d
BJ		 108 info->update_bank, info->update_reg,
109 info->update_mask, info->update_val_enable);
c789ca20
SI		 110 if (ret < 0)
111 dev_err(rdev_get_dev(rdev),
112 "couldn't set enable bits for regulator\n");
09aefa12
BJ		 113
114 dev_vdbg(rdev_get_dev(rdev),
115 "%s-enable (bank, reg, mask, value): 0x%x, 0x%x, 0x%x, 0x%x\n",
116 info->desc.name, info->update_bank, info->update_reg,
117 info->update_mask, info->update_val_enable);
118
c789ca20
SI		 119 return ret;
120}
121
122static int ab8500_regulator_disable(struct regulator_dev *rdev)
123{
fc24b426 124 int ret;
c789ca20
SI		 125 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
126
fc24b426
BJ		 127 if (info == NULL) {
128 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
c789ca20 129 return -EINVAL;
fc24b426 130 }
c789ca20 131
47c16975 132 ret = abx500_mask_and_set_register_interruptible(info->dev,
e1159e6d
BJ		 133 info->update_bank, info->update_reg,
134 info->update_mask, 0x0);
c789ca20
SI		 135 if (ret < 0)
136 dev_err(rdev_get_dev(rdev),
137 "couldn't set disable bits for regulator\n");
09aefa12
BJ		 138
139 dev_vdbg(rdev_get_dev(rdev),
140 "%s-disable (bank, reg, mask, value): 0x%x, 0x%x, 0x%x, 0x%x\n",
141 info->desc.name, info->update_bank, info->update_reg,
142 info->update_mask, 0x0);
143
c789ca20
SI		 144 return ret;
145}
146
147static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
148{
fc24b426 149 int ret;
c789ca20 150 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
09aefa12 151 u8 regval;
c789ca20 152
fc24b426
BJ		 153 if (info == NULL) {
154 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
c789ca20 155 return -EINVAL;
fc24b426 156 }
c789ca20 157
47c16975 158 ret = abx500_get_register_interruptible(info->dev,
09aefa12 159 info->update_bank, info->update_reg, &regval);
c789ca20
SI		 160 if (ret < 0) {
161 dev_err(rdev_get_dev(rdev),
162 "couldn't read 0x%x register\n", info->update_reg);
163 return ret;
164 }
165
09aefa12
BJ		 166 dev_vdbg(rdev_get_dev(rdev),
167 "%s-is_enabled (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
168 " 0x%x\n",
169 info->desc.name, info->update_bank, info->update_reg,
170 info->update_mask, regval);
171
172 if (regval & info->update_mask)
c789ca20
SI		 173 return true;
174 else
175 return false;
176}
177
3bf6e90e 178static int ab8500_regulator_get_voltage_sel(struct regulator_dev *rdev)
c789ca20 179{
09aefa12 180 int ret, val;
c789ca20 181 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
09aefa12 182 u8 regval;
c789ca20 183
fc24b426
BJ		 184 if (info == NULL) {
185 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
c789ca20 186 return -EINVAL;
fc24b426 187 }
c789ca20 188
09aefa12
BJ		 189 ret = abx500_get_register_interruptible(info->dev,
190 info->voltage_bank, info->voltage_reg, &regval);
c789ca20
SI		 191 if (ret < 0) {
192 dev_err(rdev_get_dev(rdev),
193 "couldn't read voltage reg for regulator\n");
194 return ret;
195 }
196
09aefa12
BJ		 197 dev_vdbg(rdev_get_dev(rdev),
198 "%s-get_voltage (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
199 " 0x%x\n",
200 info->desc.name, info->voltage_bank, info->voltage_reg,
201 info->voltage_mask, regval);
202
c789ca20 203 /* vintcore has a different layout */
09aefa12 204 val = regval & info->voltage_mask;
fc24b426 205 if (info->desc.id == AB8500_LDO_INTCORE)
3bf6e90e 206 return val >> 0x3;
c789ca20 207 else
3bf6e90e 208 return val;
c789ca20
SI		 209}
210
ae713d39
AL		 211static int ab8500_regulator_set_voltage_sel(struct regulator_dev *rdev,
212 unsigned selector)
c789ca20 213{
fc24b426 214 int ret;
c789ca20 215 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
09aefa12 216 u8 regval;
c789ca20 217
fc24b426
BJ		 218 if (info == NULL) {
219 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
c789ca20 220 return -EINVAL;
fc24b426 221 }
c789ca20 222
c789ca20 223 /* set the registers for the request */
ae713d39 224 regval = (u8)selector;
47c16975 225 ret = abx500_mask_and_set_register_interruptible(info->dev,
09aefa12
BJ		 226 info->voltage_bank, info->voltage_reg,
227 info->voltage_mask, regval);
c789ca20
SI		 228 if (ret < 0)
229 dev_err(rdev_get_dev(rdev),
230 "couldn't set voltage reg for regulator\n");
231
09aefa12
BJ		 232 dev_vdbg(rdev_get_dev(rdev),
233 "%s-set_voltage (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
234 " 0x%x\n",
235 info->desc.name, info->voltage_bank, info->voltage_reg,
236 info->voltage_mask, regval);
237
c789ca20
SI		 238 return ret;
239}
240
42ab616a
LW		 241static int ab8500_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
242 unsigned int old_sel,
243 unsigned int new_sel)
244{
245 struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
42ab616a 246
42ab616a
LW		 247 return info->delay;
248}
249
c789ca20
SI		 250static struct regulator_ops ab8500_regulator_ops = {
251 .enable = ab8500_regulator_enable,
252 .disable = ab8500_regulator_disable,
253 .is_enabled = ab8500_regulator_is_enabled,
3bf6e90e 254 .get_voltage_sel = ab8500_regulator_get_voltage_sel,
ae713d39 255 .set_voltage_sel = ab8500_regulator_set_voltage_sel,
ec1cc4d9 256 .list_voltage = regulator_list_voltage_table,
42ab616a 257 .set_voltage_time_sel = ab8500_regulator_set_voltage_time_sel,
c789ca20
SI		 258};
259
6909b452 260static struct regulator_ops ab8500_regulator_fixed_ops = {
c789ca20
SI		 261 .enable = ab8500_regulator_enable,
262 .disable = ab8500_regulator_disable,
263 .is_enabled = ab8500_regulator_is_enabled,
7142e213 264 .list_voltage = regulator_list_voltage_linear,
c789ca20
SI		 265};
266
6909b452
BJ		 267static struct ab8500_regulator_info
268 ab8500_regulator_info[AB8500_NUM_REGULATORS] = {
c789ca20 269 /*
e1159e6d
BJ		 270 * Variable Voltage Regulators
271 * name, min mV, max mV,
272 * update bank, reg, mask, enable val
ec1cc4d9 273 * volt bank, reg, mask
c789ca20 274 */
6909b452
BJ		 275 [AB8500_LDO_AUX1] = {
276 .desc = {
277 .name = "LDO-AUX1",
278 .ops = &ab8500_regulator_ops,
279 .type = REGULATOR_VOLTAGE,
280 .id = AB8500_LDO_AUX1,
281 .owner = THIS_MODULE,
282 .n_voltages = ARRAY_SIZE(ldo_vauxn_voltages),
ec1cc4d9 283 .volt_table = ldo_vauxn_voltages,
6909b452 284 },
6909b452
BJ		 285 .update_bank = 0x04,
286 .update_reg = 0x09,
287 .update_mask = 0x03,
288 .update_val_enable = 0x01,
289 .voltage_bank = 0x04,
290 .voltage_reg = 0x1f,
291 .voltage_mask = 0x0f,
6909b452
BJ		 292 },
293 [AB8500_LDO_AUX2] = {
294 .desc = {
295 .name = "LDO-AUX2",
296 .ops = &ab8500_regulator_ops,
297 .type = REGULATOR_VOLTAGE,
298 .id = AB8500_LDO_AUX2,
299 .owner = THIS_MODULE,
300 .n_voltages = ARRAY_SIZE(ldo_vauxn_voltages),
ec1cc4d9 301 .volt_table = ldo_vauxn_voltages,
6909b452 302 },
6909b452
BJ		 303 .update_bank = 0x04,
304 .update_reg = 0x09,
305 .update_mask = 0x0c,
306 .update_val_enable = 0x04,
307 .voltage_bank = 0x04,
308 .voltage_reg = 0x20,
309 .voltage_mask = 0x0f,
6909b452
BJ		 310 },
311 [AB8500_LDO_AUX3] = {
312 .desc = {
313 .name = "LDO-AUX3",
314 .ops = &ab8500_regulator_ops,
315 .type = REGULATOR_VOLTAGE,
316 .id = AB8500_LDO_AUX3,
317 .owner = THIS_MODULE,
318 .n_voltages = ARRAY_SIZE(ldo_vaux3_voltages),
ec1cc4d9 319 .volt_table = ldo_vaux3_voltages,
6909b452 320 },
6909b452
BJ		 321 .update_bank = 0x04,
322 .update_reg = 0x0a,
323 .update_mask = 0x03,
324 .update_val_enable = 0x01,
325 .voltage_bank = 0x04,
326 .voltage_reg = 0x21,
327 .voltage_mask = 0x07,
6909b452
BJ		 328 },
329 [AB8500_LDO_INTCORE] = {
330 .desc = {
331 .name = "LDO-INTCORE",
332 .ops = &ab8500_regulator_ops,
333 .type = REGULATOR_VOLTAGE,
334 .id = AB8500_LDO_INTCORE,
335 .owner = THIS_MODULE,
336 .n_voltages = ARRAY_SIZE(ldo_vintcore_voltages),
ec1cc4d9 337 .volt_table = ldo_vintcore_voltages,
6909b452 338 },
6909b452
BJ		 339 .update_bank = 0x03,
340 .update_reg = 0x80,
341 .update_mask = 0x44,
342 .update_val_enable = 0x04,
343 .voltage_bank = 0x03,
344 .voltage_reg = 0x80,
345 .voltage_mask = 0x38,
6909b452 346 },
c789ca20
SI		 347
348 /*
e1159e6d
BJ		 349 * Fixed Voltage Regulators
350 * name, fixed mV,
351 * update bank, reg, mask, enable val
c789ca20 352 */
6909b452
BJ		 353 [AB8500_LDO_TVOUT] = {
354 .desc = {
355 .name = "LDO-TVOUT",
356 .ops = &ab8500_regulator_fixed_ops,
357 .type = REGULATOR_VOLTAGE,
358 .id = AB8500_LDO_TVOUT,
359 .owner = THIS_MODULE,
360 .n_voltages = 1,
7142e213 361 .min_uV = 2000000,
7fee2afb 362 .enable_time = 10000,
6909b452 363 },
42ab616a 364 .delay = 10000,
6909b452
BJ		 365 .update_bank = 0x03,
366 .update_reg = 0x80,
367 .update_mask = 0x82,
368 .update_val_enable = 0x02,
369 },
ea05ef31
BJ		 370 [AB8500_LDO_USB] = {
371 .desc = {
372 .name = "LDO-USB",
373 .ops = &ab8500_regulator_fixed_ops,
374 .type = REGULATOR_VOLTAGE,
375 .id = AB8500_LDO_USB,
376 .owner = THIS_MODULE,
377 .n_voltages = 1,
7142e213 378 .min_uV = 3300000,
ea05ef31 379 },
ea05ef31
BJ		 380 .update_bank = 0x03,
381 .update_reg = 0x82,
382 .update_mask = 0x03,
383 .update_val_enable = 0x01,
384 },
6909b452
BJ		 385 [AB8500_LDO_AUDIO] = {
386 .desc = {
387 .name = "LDO-AUDIO",
388 .ops = &ab8500_regulator_fixed_ops,
389 .type = REGULATOR_VOLTAGE,
390 .id = AB8500_LDO_AUDIO,
391 .owner = THIS_MODULE,
392 .n_voltages = 1,
7142e213 393 .min_uV = 2000000,
6909b452 394 },
6909b452
BJ		 395 .update_bank = 0x03,
396 .update_reg = 0x83,
397 .update_mask = 0x02,
398 .update_val_enable = 0x02,
399 },
400 [AB8500_LDO_ANAMIC1] = {
401 .desc = {
402 .name = "LDO-ANAMIC1",
403 .ops = &ab8500_regulator_fixed_ops,
404 .type = REGULATOR_VOLTAGE,
405 .id = AB8500_LDO_ANAMIC1,
406 .owner = THIS_MODULE,
407 .n_voltages = 1,
7142e213 408 .min_uV = 2050000,
6909b452 409 },
6909b452
BJ		 410 .update_bank = 0x03,
411 .update_reg = 0x83,
412 .update_mask = 0x08,
413 .update_val_enable = 0x08,
414 },
415 [AB8500_LDO_ANAMIC2] = {
416 .desc = {
417 .name = "LDO-ANAMIC2",
418 .ops = &ab8500_regulator_fixed_ops,
419 .type = REGULATOR_VOLTAGE,
420 .id = AB8500_LDO_ANAMIC2,
421 .owner = THIS_MODULE,
422 .n_voltages = 1,
7142e213 423 .min_uV = 2050000,
6909b452 424 },
6909b452
BJ		 425 .update_bank = 0x03,
426 .update_reg = 0x83,
427 .update_mask = 0x10,
428 .update_val_enable = 0x10,
429 },
430 [AB8500_LDO_DMIC] = {
431 .desc = {
432 .name = "LDO-DMIC",
433 .ops = &ab8500_regulator_fixed_ops,
434 .type = REGULATOR_VOLTAGE,
435 .id = AB8500_LDO_DMIC,
436 .owner = THIS_MODULE,
437 .n_voltages = 1,
7142e213 438 .min_uV = 1800000,
6909b452 439 },
6909b452
BJ		 440 .update_bank = 0x03,
441 .update_reg = 0x83,
442 .update_mask = 0x04,
443 .update_val_enable = 0x04,
444 },
445 [AB8500_LDO_ANA] = {
446 .desc = {
447 .name = "LDO-ANA",
448 .ops = &ab8500_regulator_fixed_ops,
449 .type = REGULATOR_VOLTAGE,
450 .id = AB8500_LDO_ANA,
451 .owner = THIS_MODULE,
452 .n_voltages = 1,
7142e213 453 .min_uV = 1200000,
6909b452 454 },
6909b452
BJ		 455 .update_bank = 0x04,
456 .update_reg = 0x06,
457 .update_mask = 0x0c,
458 .update_val_enable = 0x04,
459 },
460
461
c789ca20
SI		 462};
463
79568b94
BJ		 464struct ab8500_reg_init {
465 u8 bank;
466 u8 addr;
467 u8 mask;
468};
469
470#define REG_INIT(_id, _bank, _addr, _mask) \
471 [_id] = { \
472 .bank = _bank, \
473 .addr = _addr, \
474 .mask = _mask, \
475 }
476
477static struct ab8500_reg_init ab8500_reg_init[] = {
478 /*
479 * 0x30, VanaRequestCtrl
480 * 0x0C, VpllRequestCtrl
481 * 0xc0, VextSupply1RequestCtrl
482 */
483 REG_INIT(AB8500_REGUREQUESTCTRL2, 0x03, 0x04, 0xfc),
484 /*
485 * 0x03, VextSupply2RequestCtrl
486 * 0x0c, VextSupply3RequestCtrl
487 * 0x30, Vaux1RequestCtrl
488 * 0xc0, Vaux2RequestCtrl
489 */
490 REG_INIT(AB8500_REGUREQUESTCTRL3, 0x03, 0x05, 0xff),
491 /*
492 * 0x03, Vaux3RequestCtrl
493 * 0x04, SwHPReq
494 */
495 REG_INIT(AB8500_REGUREQUESTCTRL4, 0x03, 0x06, 0x07),
496 /*
497 * 0x08, VanaSysClkReq1HPValid
498 * 0x20, Vaux1SysClkReq1HPValid
499 * 0x40, Vaux2SysClkReq1HPValid
500 * 0x80, Vaux3SysClkReq1HPValid
501 */
502 REG_INIT(AB8500_REGUSYSCLKREQ1HPVALID1, 0x03, 0x07, 0xe8),
503 /*
504 * 0x10, VextSupply1SysClkReq1HPValid
505 * 0x20, VextSupply2SysClkReq1HPValid
506 * 0x40, VextSupply3SysClkReq1HPValid
507 */
508 REG_INIT(AB8500_REGUSYSCLKREQ1HPVALID2, 0x03, 0x08, 0x70),
509 /*
510 * 0x08, VanaHwHPReq1Valid
511 * 0x20, Vaux1HwHPReq1Valid
512 * 0x40, Vaux2HwHPReq1Valid
513 * 0x80, Vaux3HwHPReq1Valid
514 */
515 REG_INIT(AB8500_REGUHWHPREQ1VALID1, 0x03, 0x09, 0xe8),
516 /*
517 * 0x01, VextSupply1HwHPReq1Valid
518 * 0x02, VextSupply2HwHPReq1Valid
519 * 0x04, VextSupply3HwHPReq1Valid
520 */
521 REG_INIT(AB8500_REGUHWHPREQ1VALID2, 0x03, 0x0a, 0x07),
522 /*
523 * 0x08, VanaHwHPReq2Valid
524 * 0x20, Vaux1HwHPReq2Valid
525 * 0x40, Vaux2HwHPReq2Valid
526 * 0x80, Vaux3HwHPReq2Valid
527 */
528 REG_INIT(AB8500_REGUHWHPREQ2VALID1, 0x03, 0x0b, 0xe8),
529 /*
530 * 0x01, VextSupply1HwHPReq2Valid
531 * 0x02, VextSupply2HwHPReq2Valid
532 * 0x04, VextSupply3HwHPReq2Valid
533 */
534 REG_INIT(AB8500_REGUHWHPREQ2VALID2, 0x03, 0x0c, 0x07),
535 /*
536 * 0x20, VanaSwHPReqValid
537 * 0x80, Vaux1SwHPReqValid
538 */
539 REG_INIT(AB8500_REGUSWHPREQVALID1, 0x03, 0x0d, 0xa0),
540 /*
541 * 0x01, Vaux2SwHPReqValid
542 * 0x02, Vaux3SwHPReqValid
543 * 0x04, VextSupply1SwHPReqValid
544 * 0x08, VextSupply2SwHPReqValid
545 * 0x10, VextSupply3SwHPReqValid
546 */
547 REG_INIT(AB8500_REGUSWHPREQVALID2, 0x03, 0x0e, 0x1f),
548 /*
549 * 0x02, SysClkReq2Valid1
550 * ...
551 * 0x80, SysClkReq8Valid1
552 */
553 REG_INIT(AB8500_REGUSYSCLKREQVALID1, 0x03, 0x0f, 0xfe),
554 /*
555 * 0x02, SysClkReq2Valid2
556 * ...
557 * 0x80, SysClkReq8Valid2
558 */
559 REG_INIT(AB8500_REGUSYSCLKREQVALID2, 0x03, 0x10, 0xfe),
560 /*
561 * 0x02, VTVoutEna
562 * 0x04, Vintcore12Ena
563 * 0x38, Vintcore12Sel
564 * 0x40, Vintcore12LP
565 * 0x80, VTVoutLP
566 */
567 REG_INIT(AB8500_REGUMISC1, 0x03, 0x80, 0xfe),
568 /*
569 * 0x02, VaudioEna
570 * 0x04, VdmicEna
571 * 0x08, Vamic1Ena
572 * 0x10, Vamic2Ena
573 */
574 REG_INIT(AB8500_VAUDIOSUPPLY, 0x03, 0x83, 0x1e),
575 /*
576 * 0x01, Vamic1_dzout
577 * 0x02, Vamic2_dzout
578 */
579 REG_INIT(AB8500_REGUCTRL1VAMIC, 0x03, 0x84, 0x03),
580 /*
581 * 0x0c, VanaRegu
582 * 0x03, VpllRegu
583 */
584 REG_INIT(AB8500_VPLLVANAREGU, 0x04, 0x06, 0x0f),
585 /*
586 * 0x01, VrefDDREna
587 * 0x02, VrefDDRSleepMode
588 */
589 REG_INIT(AB8500_VREFDDR, 0x04, 0x07, 0x03),
590 /*
591 * 0x03, VextSupply1Regu
592 * 0x0c, VextSupply2Regu
593 * 0x30, VextSupply3Regu
594 * 0x40, ExtSupply2Bypass
595 * 0x80, ExtSupply3Bypass
596 */
597 REG_INIT(AB8500_EXTSUPPLYREGU, 0x04, 0x08, 0xff),
598 /*
599 * 0x03, Vaux1Regu
600 * 0x0c, Vaux2Regu
601 */
602 REG_INIT(AB8500_VAUX12REGU, 0x04, 0x09, 0x0f),
603 /*
604 * 0x03, Vaux3Regu
605 */
606 REG_INIT(AB8500_VRF1VAUX3REGU, 0x04, 0x0a, 0x03),
607 /*
608 * 0x3f, Vsmps1Sel1
609 */
610 REG_INIT(AB8500_VSMPS1SEL1, 0x04, 0x13, 0x3f),
611 /*
612 * 0x0f, Vaux1Sel
613 */
614 REG_INIT(AB8500_VAUX1SEL, 0x04, 0x1f, 0x0f),
615 /*
616 * 0x0f, Vaux2Sel
617 */
618 REG_INIT(AB8500_VAUX2SEL, 0x04, 0x20, 0x0f),
619 /*
620 * 0x07, Vaux3Sel
621 */
622 REG_INIT(AB8500_VRF1VAUX3SEL, 0x04, 0x21, 0x07),
623 /*
624 * 0x01, VextSupply12LP
625 */
626 REG_INIT(AB8500_REGUCTRL2SPARE, 0x04, 0x22, 0x01),
627 /*
628 * 0x04, Vaux1Disch
629 * 0x08, Vaux2Disch
630 * 0x10, Vaux3Disch
631 * 0x20, Vintcore12Disch
632 * 0x40, VTVoutDisch
633 * 0x80, VaudioDisch
634 */
635 REG_INIT(AB8500_REGUCTRLDISCH, 0x04, 0x43, 0xfc),
636 /*
637 * 0x02, VanaDisch
638 * 0x04, VdmicPullDownEna
639 * 0x10, VdmicDisch
640 */
641 REG_INIT(AB8500_REGUCTRLDISCH2, 0x04, 0x44, 0x16),
642};
643
a7ac1d9e
LJ		 644static __devinit int
645ab8500_regulator_init_registers(struct platform_device *pdev, int id, int value)
646{
647 int err;
648
649 if (value & ~ab8500_reg_init[id].mask) {
650 dev_err(&pdev->dev,
651 "Configuration error: value outside mask.\n");
652 return -EINVAL;
653 }
654
655 err = abx500_mask_and_set_register_interruptible(
656 &pdev->dev,
657 ab8500_reg_init[id].bank,
658 ab8500_reg_init[id].addr,
659 ab8500_reg_init[id].mask,
660 value);
661 if (err < 0) {
662 dev_err(&pdev->dev,
663 "Failed to initialize 0x%02x, 0x%02x.\n",
664 ab8500_reg_init[id].bank,
665 ab8500_reg_init[id].addr);
666 return err;
667 }
668
669 dev_vdbg(&pdev->dev,
670 "init: 0x%02x, 0x%02x, 0x%02x, 0x%02x\n",
671 ab8500_reg_init[id].bank,
672 ab8500_reg_init[id].addr,
673 ab8500_reg_init[id].mask,
674 value);
675
676 return 0;
677}
678
679static __devinit int ab8500_regulator_register(struct platform_device *pdev,
680 struct regulator_init_data *init_data,
681 int id,
682 struct device_node *np)
683{
684 struct ab8500_regulator_info *info = NULL;
685 struct regulator_config config = { };
686 int err;
687
688 /* assign per-regulator data */
689 info = &ab8500_regulator_info[id];
690 info->dev = &pdev->dev;
691
692 config.dev = &pdev->dev;
693 config.init_data = init_data;
694 config.driver_data = info;
695 config.of_node = np;
696
697 /* fix for hardware before ab8500v2.0 */
698 if (abx500_get_chip_id(info->dev) < 0x20) {
699 if (info->desc.id == AB8500_LDO_AUX3) {
700 info->desc.n_voltages =
701 ARRAY_SIZE(ldo_vauxn_voltages);
ec1cc4d9 702 info->desc.volt_table = ldo_vauxn_voltages;
a7ac1d9e
LJ		 703 info->voltage_mask = 0xf;
704 }
705 }
706
707 /* register regulator with framework */
708 info->regulator = regulator_register(&info->desc, &config);
709 if (IS_ERR(info->regulator)) {
710 err = PTR_ERR(info->regulator);
711 dev_err(&pdev->dev, "failed to register regulator %s\n",
712 info->desc.name);
713 /* when we fail, un-register all earlier regulators */
714 while (--id >= 0) {
715 info = &ab8500_regulator_info[id];
716 regulator_unregister(info->regulator);
717 }
718 return err;
719 }
720
721 return 0;
722}
723
3a8334b9 724static struct of_regulator_match ab8500_regulator_matches[] = {
7e715b95
LJ		 725 { .name = "ab8500_ldo_aux1", .driver_data = (void *) AB8500_LDO_AUX1, },
726 { .name = "ab8500_ldo_aux2", .driver_data = (void *) AB8500_LDO_AUX2, },
727 { .name = "ab8500_ldo_aux3", .driver_data = (void *) AB8500_LDO_AUX3, },
728 { .name = "ab8500_ldo_intcore", .driver_data = (void *) AB8500_LDO_INTCORE, },
729 { .name = "ab8500_ldo_tvout", .driver_data = (void *) AB8500_LDO_TVOUT, },
730 { .name = "ab8500_ldo_usb", .driver_data = (void *) AB8500_LDO_USB, },
731 { .name = "ab8500_ldo_audio", .driver_data = (void *) AB8500_LDO_AUDIO, },
732 { .name = "ab8500_ldo_anamic1", .driver_data = (void *) AB8500_LDO_ANAMIC1, },
733 { .name = "ab8500_ldo_amamic2", .driver_data = (void *) AB8500_LDO_ANAMIC2, },
734 { .name = "ab8500_ldo_dmic", .driver_data = (void *) AB8500_LDO_DMIC, },
735 { .name = "ab8500_ldo_ana", .driver_data = (void *) AB8500_LDO_ANA, },
3a8334b9
LJ		 736};
737
738static __devinit int
739ab8500_regulator_of_probe(struct platform_device *pdev, struct device_node *np)
740{
741 int err, i;
742
743 for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
744 err = ab8500_regulator_register(
745 pdev, ab8500_regulator_matches[i].init_data,
746 i, ab8500_regulator_matches[i].of_node);
747 if (err)
748 return err;
749 }
750
751 return 0;
752}
753
c789ca20
SI		 754static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
755{
756 struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent);
af54decd 757 struct ab8500_platform_data *pdata;
3a8334b9 758 struct device_node *np = pdev->dev.of_node;
c789ca20
SI		 759 int i, err;
760
3a8334b9
LJ		 761 if (np) {
762 err = of_regulator_match(&pdev->dev, np,
763 ab8500_regulator_matches,
764 ARRAY_SIZE(ab8500_regulator_matches));
765 if (err < 0) {
766 dev_err(&pdev->dev,
767 "Error parsing regulator init data: %d\n", err);
768 return err;
769 }
770
771 err = ab8500_regulator_of_probe(pdev, np);
772 return err;
773 }
774
c789ca20
SI		 775 if (!ab8500) {
776 dev_err(&pdev->dev, "null mfd parent\n");
777 return -EINVAL;
778 }
af54decd 779 pdata = dev_get_platdata(ab8500->dev);
fc24b426
BJ		 780 if (!pdata) {
781 dev_err(&pdev->dev, "null pdata\n");
782 return -EINVAL;
783 }
c789ca20 784
cb189b07
BJ		 785 /* make sure the platform data has the correct size */
786 if (pdata->num_regulator != ARRAY_SIZE(ab8500_regulator_info)) {
79568b94 787 dev_err(&pdev->dev, "Configuration error: size mismatch.\n");
cb189b07
BJ		 788 return -EINVAL;
789 }
790
79568b94
BJ		 791 /* initialize registers */
792 for (i = 0; i < pdata->num_regulator_reg_init; i++) {
a7ac1d9e 793 int id, value;
79568b94
BJ		 794
795 id = pdata->regulator_reg_init[i].id;
796 value = pdata->regulator_reg_init[i].value;
797
798 /* check for configuration errors */
799 if (id >= AB8500_NUM_REGULATOR_REGISTERS) {
800 dev_err(&pdev->dev,
801 "Configuration error: id outside range.\n");
802 return -EINVAL;
803 }
79568b94 804
a7ac1d9e
LJ		 805 err = ab8500_regulator_init_registers(pdev, id, value);
806 if (err < 0)
79568b94 807 return err;
79568b94
BJ		 808 }
809
c789ca20
SI		 810 /* register all regulators */
811 for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
a7ac1d9e
LJ		 812 err = ab8500_regulator_register(pdev, &pdata->regulator[i], i, NULL);
813 if (err < 0)
c789ca20 814 return err;
c789ca20
SI		 815 }
816
817 return 0;
818}
819
820static __devexit int ab8500_regulator_remove(struct platform_device *pdev)
821{
822 int i;
823
824 for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
825 struct ab8500_regulator_info *info = NULL;
826 info = &ab8500_regulator_info[i];
09aefa12
BJ		 827
828 dev_vdbg(rdev_get_dev(info->regulator),
829 "%s-remove\n", info->desc.name);
830
c789ca20
SI		 831 regulator_unregister(info->regulator);
832 }
833
834 return 0;
835}
836
837static struct platform_driver ab8500_regulator_driver = {
838 .probe = ab8500_regulator_probe,
839 .remove = __devexit_p(ab8500_regulator_remove),
840 .driver = {
841 .name = "ab8500-regulator",
842 .owner = THIS_MODULE,
843 },
844};
845
846static int __init ab8500_regulator_init(void)
847{
848 int ret;
849
850 ret = platform_driver_register(&ab8500_regulator_driver);
851 if (ret != 0)
852 pr_err("Failed to register ab8500 regulator: %d\n", ret);
853
854 return ret;
855}
856subsys_initcall(ab8500_regulator_init);
857
858static void __exit ab8500_regulator_exit(void)
859{
860 platform_driver_unregister(&ab8500_regulator_driver);
861}
862module_exit(ab8500_regulator_exit);
863
864MODULE_LICENSE("GPL v2");
865MODULE_AUTHOR("Sundar Iyer <sundar.iyer@stericsson.com>");
866MODULE_DESCRIPTION("Regulator Driver for ST-Ericsson AB8500 Mixed-Sig PMIC");
867MODULE_ALIAS("platform:ab8500-regulator");
Linux 6.x block layer and io_uring tree(s)