?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SCSI] megaraid_sas: Add 4k FastPath DIF support
[linux-2.6.git] / drivers / regulator / tps6524x-regulator.c
blob843ee0a9bb92ce2a23e7a2209590b99cfa13e76c
1 /*
2 * Regulator driver for TPS6524x PMIC
3 *
4 * Copyright (C) 2010 Texas Instruments
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation version 2.
9 *
10 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
11 * whether express or implied; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 */
15
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/err.h>
19 #include <linux/errno.h>
20 #include <linux/slab.h>
21 #include <linux/spi/spi.h>
22 #include <linux/regulator/driver.h>
23 #include <linux/regulator/machine.h>
24
25 #define REG_LDO_SET 0x0
26 #define LDO_ILIM_MASK 1 /* 0 = 400-800, 1 = 900-1500 */
27 #define LDO_VSEL_MASK 0x0f
28 #define LDO2_ILIM_SHIFT 12
29 #define LDO2_VSEL_SHIFT 4
30 #define LDO1_ILIM_SHIFT 8
31 #define LDO1_VSEL_SHIFT 0
32
33 #define REG_BLOCK_EN 0x1
34 #define BLOCK_MASK 1
35 #define BLOCK_LDO1_SHIFT 0
36 #define BLOCK_LDO2_SHIFT 1
37 #define BLOCK_LCD_SHIFT 2
38 #define BLOCK_USB_SHIFT 3
39
40 #define REG_DCDC_SET 0x2
41 #define DCDC_VDCDC_MASK 0x1f
42 #define DCDC_VDCDC1_SHIFT 0
43 #define DCDC_VDCDC2_SHIFT 5
44 #define DCDC_VDCDC3_SHIFT 10
45
46 #define REG_DCDC_EN 0x3
47 #define DCDCDCDC_EN_MASK 0x1
48 #define DCDCDCDC1_EN_SHIFT 0
49 #define DCDCDCDC1_PG_MSK BIT(1)
50 #define DCDCDCDC2_EN_SHIFT 2
51 #define DCDCDCDC2_PG_MSK BIT(3)
52 #define DCDCDCDC3_EN_SHIFT 4
53 #define DCDCDCDC3_PG_MSK BIT(5)
54
55 #define REG_USB 0x4
56 #define USB_ILIM_SHIFT 0
57 #define USB_ILIM_MASK 0x3
58 #define USB_TSD_SHIFT 2
59 #define USB_TSD_MASK 0x3
60 #define USB_TWARN_SHIFT 4
61 #define USB_TWARN_MASK 0x3
62 #define USB_IWARN_SD BIT(6)
63 #define USB_FAST_LOOP BIT(7)
64
65 #define REG_ALARM 0x5
66 #define ALARM_LDO1 BIT(0)
67 #define ALARM_DCDC1 BIT(1)
68 #define ALARM_DCDC2 BIT(2)
69 #define ALARM_DCDC3 BIT(3)
70 #define ALARM_LDO2 BIT(4)
71 #define ALARM_USB_WARN BIT(5)
72 #define ALARM_USB_ALARM BIT(6)
73 #define ALARM_LCD BIT(9)
74 #define ALARM_TEMP_WARM BIT(10)
75 #define ALARM_TEMP_HOT BIT(11)
76 #define ALARM_NRST BIT(14)
77 #define ALARM_POWERUP BIT(15)
78
79 #define REG_INT_ENABLE 0x6
80 #define INT_LDO1 BIT(0)
81 #define INT_DCDC1 BIT(1)
82 #define INT_DCDC2 BIT(2)
83 #define INT_DCDC3 BIT(3)
84 #define INT_LDO2 BIT(4)
85 #define INT_USB_WARN BIT(5)
86 #define INT_USB_ALARM BIT(6)
87 #define INT_LCD BIT(9)
88 #define INT_TEMP_WARM BIT(10)
89 #define INT_TEMP_HOT BIT(11)
90 #define INT_GLOBAL_EN BIT(15)
91
92 #define REG_INT_STATUS 0x7
93 #define STATUS_LDO1 BIT(0)
94 #define STATUS_DCDC1 BIT(1)
95 #define STATUS_DCDC2 BIT(2)
96 #define STATUS_DCDC3 BIT(3)
97 #define STATUS_LDO2 BIT(4)
98 #define STATUS_USB_WARN BIT(5)
99 #define STATUS_USB_ALARM BIT(6)
100 #define STATUS_LCD BIT(9)
101 #define STATUS_TEMP_WARM BIT(10)
102 #define STATUS_TEMP_HOT BIT(11)
103
104 #define REG_SOFTWARE_RESET 0xb
105 #define REG_WRITE_ENABLE 0xd
106 #define REG_REV_ID 0xf
107
108 #define N_DCDC 3
109 #define N_LDO 2
110 #define N_SWITCH 2
111 #define N_REGULATORS (N_DCDC + N_LDO + N_SWITCH)
112
113 #define CMD_READ(reg) ((reg) << 6)
114 #define CMD_WRITE(reg) (BIT(5) | (reg) << 6)
115 #define STAT_CLK BIT(3)
116 #define STAT_WRITE BIT(2)
117 #define STAT_INVALID BIT(1)
118 #define STAT_WP BIT(0)
119
120 struct field {
121 int reg;
122 int shift;
123 int mask;
124 };
125
126 struct supply_info {
127 const char *name;
128 int n_voltages;
129 const unsigned int *voltages;
130 int n_ilimsels;
131 const unsigned int *ilimsels;
132 struct field enable, voltage, ilimsel;
133 };
134
135 struct tps6524x {
136 struct device *dev;
137 struct spi_device *spi;
138 struct mutex lock;
139 struct regulator_desc desc[N_REGULATORS];
140 struct regulator_dev *rdev[N_REGULATORS];
141 };
142
143 static int __read_reg(struct tps6524x *hw, int reg)
144 {
145 int error = 0;
146 u16 cmd = CMD_READ(reg), in;
147 u8 status;
148 struct spi_message m;
149 struct spi_transfer t[3];
150
151 spi_message_init(&m);
152 memset(t, 0, sizeof(t));
153
154 t[0].tx_buf = &cmd;
155 t[0].len = 2;
156 t[0].bits_per_word = 12;
157 spi_message_add_tail(&t[0], &m);
158
159 t[1].rx_buf = &in;
160 t[1].len = 2;
161 t[1].bits_per_word = 16;
162 spi_message_add_tail(&t[1], &m);
163
164 t[2].rx_buf = &status;
165 t[2].len = 1;
166 t[2].bits_per_word = 4;
167 spi_message_add_tail(&t[2], &m);
168
169 error = spi_sync(hw->spi, &m);
170 if (error < 0)
171 return error;
172
173 dev_dbg(hw->dev, "read reg %d, data %x, status %x\n",
174 reg, in, status);
175
176 if (!(status & STAT_CLK) || (status & STAT_WRITE))
177 return -EIO;
178
179 if (status & STAT_INVALID)
180 return -EINVAL;
181
182 return in;
183 }
184
185 static int read_reg(struct tps6524x *hw, int reg)
186 {
187 int ret;
188
189 mutex_lock(&hw->lock);
190 ret = __read_reg(hw, reg);
191 mutex_unlock(&hw->lock);
192
193 return ret;
194 }
195
196 static int __write_reg(struct tps6524x *hw, int reg, int val)
197 {
198 int error = 0;
199 u16 cmd = CMD_WRITE(reg), out = val;
200 u8 status;
201 struct spi_message m;
202 struct spi_transfer t[3];
203
204 spi_message_init(&m);
205 memset(t, 0, sizeof(t));
206
207 t[0].tx_buf = &cmd;
208 t[0].len = 2;
209 t[0].bits_per_word = 12;
210 spi_message_add_tail(&t[0], &m);
211
212 t[1].tx_buf = &out;
213 t[1].len = 2;
214 t[1].bits_per_word = 16;
215 spi_message_add_tail(&t[1], &m);
216
217 t[2].rx_buf = &status;
218 t[2].len = 1;
219 t[2].bits_per_word = 4;
220 spi_message_add_tail(&t[2], &m);
221
222 error = spi_sync(hw->spi, &m);
223 if (error < 0)
224 return error;
225
226 dev_dbg(hw->dev, "wrote reg %d, data %x, status %x\n",
227 reg, out, status);
228
229 if (!(status & STAT_CLK) || !(status & STAT_WRITE))
230 return -EIO;
231
232 if (status & (STAT_INVALID | STAT_WP))
233 return -EINVAL;
234
235 return error;
236 }
237
238 static int __rmw_reg(struct tps6524x *hw, int reg, int mask, int val)
239 {
240 int ret;
241
242 ret = __read_reg(hw, reg);
243 if (ret < 0)
244 return ret;
245
246 ret &= ~mask;
247 ret |= val;
248
249 ret = __write_reg(hw, reg, ret);
250
251 return (ret < 0) ? ret : 0;
252 }
253
254 static int rmw_protect(struct tps6524x *hw, int reg, int mask, int val)
255 {
256 int ret;
257
258 mutex_lock(&hw->lock);
259
260 ret = __write_reg(hw, REG_WRITE_ENABLE, 1);
261 if (ret) {
262 dev_err(hw->dev, "failed to set write enable\n");
263 goto error;
264 }
265
266 ret = __rmw_reg(hw, reg, mask, val);
267 if (ret)
268 dev_err(hw->dev, "failed to rmw register %d\n", reg);
269
270 ret = __write_reg(hw, REG_WRITE_ENABLE, 0);
271 if (ret) {
272 dev_err(hw->dev, "failed to clear write enable\n");
273 goto error;
274 }
275
276 error:
277 mutex_unlock(&hw->lock);
278
279 return ret;
280 }
281
282 static int read_field(struct tps6524x *hw, const struct field *field)
283 {
284 int tmp;
285
286 tmp = read_reg(hw, field->reg);
287 if (tmp < 0)
288 return tmp;
289
290 return (tmp >> field->shift) & field->mask;
291 }
292
293 static int write_field(struct tps6524x *hw, const struct field *field,
294 int val)
295 {
296 if (val & ~field->mask)
297 return -EOVERFLOW;
298
299 return rmw_protect(hw, field->reg,
300 field->mask << field->shift,
301 val << field->shift);
302 }
303
304 static const unsigned int dcdc1_voltages[] = {
305 800000, 825000, 850000, 875000,
306 900000, 925000, 950000, 975000,
307 1000000, 1025000, 1050000, 1075000,
308 1100000, 1125000, 1150000, 1175000,
309 1200000, 1225000, 1250000, 1275000,
310 1300000, 1325000, 1350000, 1375000,
311 1400000, 1425000, 1450000, 1475000,
312 1500000, 1525000, 1550000, 1575000,
313 };
314
315 static const unsigned int dcdc2_voltages[] = {
316 1400000, 1450000, 1500000, 1550000,
317 1600000, 1650000, 1700000, 1750000,
318 1800000, 1850000, 1900000, 1950000,
319 2000000, 2050000, 2100000, 2150000,
320 2200000, 2250000, 2300000, 2350000,
321 2400000, 2450000, 2500000, 2550000,
322 2600000, 2650000, 2700000, 2750000,
323 2800000, 2850000, 2900000, 2950000,
324 };
325
326 static const unsigned int dcdc3_voltages[] = {
327 2400000, 2450000, 2500000, 2550000, 2600000,
328 2650000, 2700000, 2750000, 2800000, 2850000,
329 2900000, 2950000, 3000000, 3050000, 3100000,
330 3150000, 3200000, 3250000, 3300000, 3350000,
331 3400000, 3450000, 3500000, 3550000, 3600000,
332 };
333
334 static const unsigned int ldo1_voltages[] = {
335 4300000, 4350000, 4400000, 4450000,
336 4500000, 4550000, 4600000, 4650000,
337 4700000, 4750000, 4800000, 4850000,
338 4900000, 4950000, 5000000, 5050000,
339 };
340
341 static const unsigned int ldo2_voltages[] = {
342 1100000, 1150000, 1200000, 1250000,
343 1300000, 1700000, 1750000, 1800000,
344 1850000, 1900000, 3150000, 3200000,
345 3250000, 3300000, 3350000, 3400000,
346 };
347
348 static const unsigned int fixed_5000000_voltage[] = {
349 5000000
350 };
351
352 static const unsigned int ldo_ilimsel[] = {
353 400000, 1500000
354 };
355
356 static const unsigned int usb_ilimsel[] = {
357 200000, 400000, 800000, 1000000
358 };
359
360 static const unsigned int fixed_2400000_ilimsel[] = {
361 2400000
362 };
363
364 static const unsigned int fixed_1200000_ilimsel[] = {
365 1200000
366 };
367
368 static const unsigned int fixed_400000_ilimsel[] = {
369 400000
370 };
371
372 #define __MK_FIELD(_reg, _mask, _shift) \
373 { .reg = (_reg), .mask = (_mask), .shift = (_shift), }
374
375 static const struct supply_info supply_info[N_REGULATORS] = {
376 {
377 .name = "DCDC1",
378 .n_voltages = ARRAY_SIZE(dcdc1_voltages),
379 .voltages = dcdc1_voltages,
380 .n_ilimsels = ARRAY_SIZE(fixed_2400000_ilimsel),
381 .ilimsels = fixed_2400000_ilimsel,
382 .enable = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
383 DCDCDCDC1_EN_SHIFT),
384 .voltage = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
385 DCDC_VDCDC1_SHIFT),
386 },
387 {
388 .name = "DCDC2",
389 .n_voltages = ARRAY_SIZE(dcdc2_voltages),
390 .voltages = dcdc2_voltages,
391 .n_ilimsels = ARRAY_SIZE(fixed_1200000_ilimsel),
392 .ilimsels = fixed_1200000_ilimsel,
393 .enable = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
394 DCDCDCDC2_EN_SHIFT),
395 .voltage = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
396 DCDC_VDCDC2_SHIFT),
397 },
398 {
399 .name = "DCDC3",
400 .n_voltages = ARRAY_SIZE(dcdc3_voltages),
401 .voltages = dcdc3_voltages,
402 .n_ilimsels = ARRAY_SIZE(fixed_1200000_ilimsel),
403 .ilimsels = fixed_1200000_ilimsel,
404 .enable = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
405 DCDCDCDC3_EN_SHIFT),
406 .voltage = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
407 DCDC_VDCDC3_SHIFT),
408 },
409 {
410 .name = "LDO1",
411 .n_voltages = ARRAY_SIZE(ldo1_voltages),
412 .voltages = ldo1_voltages,
413 .n_ilimsels = ARRAY_SIZE(ldo_ilimsel),
414 .ilimsels = ldo_ilimsel,
415 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
416 BLOCK_LDO1_SHIFT),
417 .voltage = __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK,
418 LDO1_VSEL_SHIFT),
419 .ilimsel = __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK,
420 LDO1_ILIM_SHIFT),
421 },
422 {
423 .name = "LDO2",
424 .n_voltages = ARRAY_SIZE(ldo2_voltages),
425 .voltages = ldo2_voltages,
426 .n_ilimsels = ARRAY_SIZE(ldo_ilimsel),
427 .ilimsels = ldo_ilimsel,
428 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
429 BLOCK_LDO2_SHIFT),
430 .voltage = __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK,
431 LDO2_VSEL_SHIFT),
432 .ilimsel = __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK,
433 LDO2_ILIM_SHIFT),
434 },
435 {
436 .name = "USB",
437 .n_voltages = ARRAY_SIZE(fixed_5000000_voltage),
438 .voltages = fixed_5000000_voltage,
439 .n_ilimsels = ARRAY_SIZE(usb_ilimsel),
440 .ilimsels = usb_ilimsel,
441 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
442 BLOCK_USB_SHIFT),
443 .ilimsel = __MK_FIELD(REG_USB, USB_ILIM_MASK,
444 USB_ILIM_SHIFT),
445 },
446 {
447 .name = "LCD",
448 .n_voltages = ARRAY_SIZE(fixed_5000000_voltage),
449 .voltages = fixed_5000000_voltage,
450 .n_ilimsels = ARRAY_SIZE(fixed_400000_ilimsel),
451 .ilimsels = fixed_400000_ilimsel,
452 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
453 BLOCK_LCD_SHIFT),
454 },
455 };
456
457 static int set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
458 {
459 const struct supply_info *info;
460 struct tps6524x *hw;
461
462 hw = rdev_get_drvdata(rdev);
463 info = &supply_info[rdev_get_id(rdev)];
464
465 if (rdev->desc->n_voltages == 1)
466 return -EINVAL;
467
468 return write_field(hw, &info->voltage, selector);
469 }
470
471 static int get_voltage_sel(struct regulator_dev *rdev)
472 {
473 const struct supply_info *info;
474 struct tps6524x *hw;
475 int ret;
476
477 hw = rdev_get_drvdata(rdev);
478 info = &supply_info[rdev_get_id(rdev)];
479
480 if (rdev->desc->n_voltages == 1)
481 return 0;
482
483 ret = read_field(hw, &info->voltage);
484 if (ret < 0)
485 return ret;
486 if (WARN_ON(ret >= info->n_voltages))
487 return -EIO;
488
489 return ret;
490 }
491
492 static int set_current_limit(struct regulator_dev *rdev, int min_uA,
493 int max_uA)
494 {
495 const struct supply_info *info;
496 struct tps6524x *hw;
497 int i;
498
499 hw = rdev_get_drvdata(rdev);
500 info = &supply_info[rdev_get_id(rdev)];
501
502 if (info->n_ilimsels == 1)
503 return -EINVAL;
504
505 for (i = info->n_ilimsels - 1; i >= 0; i--) {
506 if (min_uA <= info->ilimsels[i] &&
507 max_uA >= info->ilimsels[i])
508 return write_field(hw, &info->ilimsel, i);
509 }
510
511 return -EINVAL;
512 }
513
514 static int get_current_limit(struct regulator_dev *rdev)
515 {
516 const struct supply_info *info;
517 struct tps6524x *hw;
518 int ret;
519
520 hw = rdev_get_drvdata(rdev);
521 info = &supply_info[rdev_get_id(rdev)];
522
523 if (info->n_ilimsels == 1)
524 return info->ilimsels[0];
525
526 ret = read_field(hw, &info->ilimsel);
527 if (ret < 0)
528 return ret;
529 if (WARN_ON(ret >= info->n_ilimsels))
530 return -EIO;
531
532 return info->ilimsels[ret];
533 }
534
535 static int enable_supply(struct regulator_dev *rdev)
536 {
537 const struct supply_info *info;
538 struct tps6524x *hw;
539
540 hw = rdev_get_drvdata(rdev);
541 info = &supply_info[rdev_get_id(rdev)];
542
543 return write_field(hw, &info->enable, 1);
544 }
545
546 static int disable_supply(struct regulator_dev *rdev)
547 {
548 const struct supply_info *info;
549 struct tps6524x *hw;
550
551 hw = rdev_get_drvdata(rdev);
552 info = &supply_info[rdev_get_id(rdev)];
553
554 return write_field(hw, &info->enable, 0);
555 }
556
557 static int is_supply_enabled(struct regulator_dev *rdev)
558 {
559 const struct supply_info *info;
560 struct tps6524x *hw;
561
562 hw = rdev_get_drvdata(rdev);
563 info = &supply_info[rdev_get_id(rdev)];
564
565 return read_field(hw, &info->enable);
566 }
567
568 static struct regulator_ops regulator_ops = {
569 .is_enabled = is_supply_enabled,
570 .enable = enable_supply,
571 .disable = disable_supply,
572 .get_voltage_sel = get_voltage_sel,
573 .set_voltage_sel = set_voltage_sel,
574 .list_voltage = regulator_list_voltage_table,
575 .set_current_limit = set_current_limit,
576 .get_current_limit = get_current_limit,
577 };
578
579 static int pmic_remove(struct spi_device *spi)
580 {
581 struct tps6524x *hw = spi_get_drvdata(spi);
582 int i;
583
584 if (!hw)
585 return 0;
586 for (i = 0; i < N_REGULATORS; i++) {
587 if (hw->rdev[i])
588 regulator_unregister(hw->rdev[i]);
589 hw->rdev[i] = NULL;
590 }
591 spi_set_drvdata(spi, NULL);
592 return 0;
593 }
594
595 static int pmic_probe(struct spi_device *spi)
596 {
597 struct tps6524x *hw;
598 struct device *dev = &spi->dev;
599 const struct supply_info *info = supply_info;
600 struct regulator_init_data *init_data;
601 struct regulator_config config = { };
602 int ret = 0, i;
603
604 init_data = dev->platform_data;
605 if (!init_data) {
606 dev_err(dev, "could not find regulator platform data\n");
607 return -EINVAL;
608 }
609
610 hw = devm_kzalloc(&spi->dev, sizeof(struct tps6524x), GFP_KERNEL);
611 if (!hw) {
612 dev_err(dev, "cannot allocate regulator private data\n");
613 return -ENOMEM;
614 }
615 spi_set_drvdata(spi, hw);
616
617 memset(hw, 0, sizeof(struct tps6524x));
618 hw->dev = dev;
619 hw->spi = spi_dev_get(spi);
620 mutex_init(&hw->lock);
621
622 for (i = 0; i < N_REGULATORS; i++, info++, init_data++) {
623 hw->desc[i].name = info->name;
624 hw->desc[i].id = i;
625 hw->desc[i].n_voltages = info->n_voltages;
626 hw->desc[i].volt_table = info->voltages;
627 hw->desc[i].ops = &regulator_ops;
628 hw->desc[i].type = REGULATOR_VOLTAGE;
629 hw->desc[i].owner = THIS_MODULE;
630
631 config.dev = dev;
632 config.init_data = init_data;
633 config.driver_data = hw;
634
635 hw->rdev[i] = regulator_register(&hw->desc[i], &config);
636 if (IS_ERR(hw->rdev[i])) {
637 ret = PTR_ERR(hw->rdev[i]);
638 hw->rdev[i] = NULL;
639 goto fail;
640 }
641 }
642
643 return 0;
644
645 fail:
646 pmic_remove(spi);
647 return ret;
648 }
649
650 static struct spi_driver pmic_driver = {
651 .probe = pmic_probe,
652 .remove = pmic_remove,
653 .driver = {
654 .name = "tps6524x",
655 .owner = THIS_MODULE,
656 },
657 };
658
659 module_spi_driver(pmic_driver);
660
661 MODULE_DESCRIPTION("TPS6524X PMIC Driver");
662 MODULE_AUTHOR("Cyril Chemparathy");
663 MODULE_LICENSE("GPL");
664 MODULE_ALIAS("spi:tps6524x");
Linus' kernel tree