Loading...
1// SPDX-License-Identifier: GPL-2.0
2//
3// FAN53555 Fairchild Digitally Programmable TinyBuck Regulator Driver.
4//
5// Supported Part Numbers:
6// FAN53555UC00X/01X/03X/04X/05X
7//
8// Copyright (c) 2012 Marvell Technology Ltd.
9// Yunfan Zhang <yfzhang@marvell.com>
10
11#include <linux/module.h>
12#include <linux/param.h>
13#include <linux/err.h>
14#include <linux/platform_device.h>
15#include <linux/regulator/driver.h>
16#include <linux/regulator/machine.h>
17#include <linux/regulator/of_regulator.h>
18#include <linux/of_device.h>
19#include <linux/i2c.h>
20#include <linux/slab.h>
21#include <linux/regmap.h>
22#include <linux/regulator/fan53555.h>
23
24/* Voltage setting */
25#define FAN53555_VSEL0 0x00
26#define FAN53555_VSEL1 0x01
27
28#define TCS4525_VSEL0 0x11
29#define TCS4525_VSEL1 0x10
30#define TCS4525_TIME 0x13
31#define TCS4525_COMMAND 0x14
32
33/* Control register */
34#define FAN53555_CONTROL 0x02
35/* IC Type */
36#define FAN53555_ID1 0x03
37/* IC mask version */
38#define FAN53555_ID2 0x04
39/* Monitor register */
40#define FAN53555_MONITOR 0x05
41
42/* VSEL bit definitions */
43#define VSEL_BUCK_EN (1 << 7)
44#define VSEL_MODE (1 << 6)
45/* Chip ID and Verison */
46#define DIE_ID 0x0F /* ID1 */
47#define DIE_REV 0x0F /* ID2 */
48/* Control bit definitions */
49#define CTL_OUTPUT_DISCHG (1 << 7)
50#define CTL_SLEW_MASK (0x7 << 4)
51#define CTL_SLEW_SHIFT 4
52#define CTL_RESET (1 << 2)
53#define CTL_MODE_VSEL0_MODE BIT(0)
54#define CTL_MODE_VSEL1_MODE BIT(1)
55
56#define FAN53555_NVOLTAGES 64 /* Numbers of voltages */
57#define FAN53526_NVOLTAGES 128
58
59#define TCS_VSEL0_MODE (1 << 7)
60#define TCS_VSEL1_MODE (1 << 6)
61
62#define TCS_SLEW_SHIFT 3
63#define TCS_SLEW_MASK (0x3 < 3)
64
65enum fan53555_vendor {
66 FAN53526_VENDOR_FAIRCHILD = 0,
67 FAN53555_VENDOR_FAIRCHILD,
68 FAN53555_VENDOR_SILERGY,
69 FAN53526_VENDOR_TCS,
70};
71
72enum {
73 FAN53526_CHIP_ID_01 = 1,
74};
75
76enum {
77 FAN53526_CHIP_REV_08 = 8,
78};
79
80/* IC Type */
81enum {
82 FAN53555_CHIP_ID_00 = 0,
83 FAN53555_CHIP_ID_01,
84 FAN53555_CHIP_ID_02,
85 FAN53555_CHIP_ID_03,
86 FAN53555_CHIP_ID_04,
87 FAN53555_CHIP_ID_05,
88 FAN53555_CHIP_ID_08 = 8,
89};
90
91enum {
92 TCS4525_CHIP_ID_12 = 12,
93};
94
95enum {
96 TCS4526_CHIP_ID_00 = 0,
97};
98
99/* IC mask revision */
100enum {
101 FAN53555_CHIP_REV_00 = 0x3,
102 FAN53555_CHIP_REV_13 = 0xf,
103};
104
105enum {
106 SILERGY_SYR82X = 8,
107 SILERGY_SYR83X = 9,
108};
109
110struct fan53555_device_info {
111 enum fan53555_vendor vendor;
112 struct device *dev;
113 struct regulator_desc desc;
114 struct regulator_init_data *regulator;
115 /* IC Type and Rev */
116 int chip_id;
117 int chip_rev;
118 /* Voltage setting register */
119 unsigned int vol_reg;
120 unsigned int sleep_reg;
121 /* Voltage range and step(linear) */
122 unsigned int vsel_min;
123 unsigned int vsel_step;
124 unsigned int vsel_count;
125 /* Mode */
126 unsigned int mode_reg;
127 unsigned int mode_mask;
128 /* Sleep voltage cache */
129 unsigned int sleep_vol_cache;
130 /* Slew rate */
131 unsigned int slew_reg;
132 unsigned int slew_mask;
133 const unsigned int *ramp_delay_table;
134 unsigned int n_ramp_values;
135 unsigned int slew_rate;
136};
137
138static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV)
139{
140 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
141 int ret;
142
143 if (di->sleep_vol_cache == uV)
144 return 0;
145 ret = regulator_map_voltage_linear(rdev, uV, uV);
146 if (ret < 0)
147 return ret;
148 ret = regmap_update_bits(rdev->regmap, di->sleep_reg,
149 di->desc.vsel_mask, ret);
150 if (ret < 0)
151 return ret;
152 /* Cache the sleep voltage setting.
153 * Might not be the real voltage which is rounded */
154 di->sleep_vol_cache = uV;
155
156 return 0;
157}
158
159static int fan53555_set_suspend_enable(struct regulator_dev *rdev)
160{
161 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
162
163 return regmap_update_bits(rdev->regmap, di->sleep_reg,
164 VSEL_BUCK_EN, VSEL_BUCK_EN);
165}
166
167static int fan53555_set_suspend_disable(struct regulator_dev *rdev)
168{
169 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
170
171 return regmap_update_bits(rdev->regmap, di->sleep_reg,
172 VSEL_BUCK_EN, 0);
173}
174
175static int fan53555_set_mode(struct regulator_dev *rdev, unsigned int mode)
176{
177 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
178
179 switch (mode) {
180 case REGULATOR_MODE_FAST:
181 regmap_update_bits(rdev->regmap, di->mode_reg,
182 di->mode_mask, di->mode_mask);
183 break;
184 case REGULATOR_MODE_NORMAL:
185 regmap_update_bits(rdev->regmap, di->vol_reg, di->mode_mask, 0);
186 break;
187 default:
188 return -EINVAL;
189 }
190 return 0;
191}
192
193static unsigned int fan53555_get_mode(struct regulator_dev *rdev)
194{
195 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
196 unsigned int val;
197 int ret = 0;
198
199 ret = regmap_read(rdev->regmap, di->mode_reg, &val);
200 if (ret < 0)
201 return ret;
202 if (val & di->mode_mask)
203 return REGULATOR_MODE_FAST;
204 else
205 return REGULATOR_MODE_NORMAL;
206}
207
208static const unsigned int slew_rates[] = {
209 64000,
210 32000,
211 16000,
212 8000,
213 4000,
214 2000,
215 1000,
216 500,
217};
218
219static const unsigned int tcs_slew_rates[] = {
220 18700,
221 9300,
222 4600,
223 2300,
224};
225
226static const struct regulator_ops fan53555_regulator_ops = {
227 .set_voltage_sel = regulator_set_voltage_sel_regmap,
228 .get_voltage_sel = regulator_get_voltage_sel_regmap,
229 .set_voltage_time_sel = regulator_set_voltage_time_sel,
230 .map_voltage = regulator_map_voltage_linear,
231 .list_voltage = regulator_list_voltage_linear,
232 .set_suspend_voltage = fan53555_set_suspend_voltage,
233 .enable = regulator_enable_regmap,
234 .disable = regulator_disable_regmap,
235 .is_enabled = regulator_is_enabled_regmap,
236 .set_mode = fan53555_set_mode,
237 .get_mode = fan53555_get_mode,
238 .set_ramp_delay = regulator_set_ramp_delay_regmap,
239 .set_suspend_enable = fan53555_set_suspend_enable,
240 .set_suspend_disable = fan53555_set_suspend_disable,
241};
242
243static int fan53526_voltages_setup_fairchild(struct fan53555_device_info *di)
244{
245 /* Init voltage range and step */
246 switch (di->chip_id) {
247 case FAN53526_CHIP_ID_01:
248 switch (di->chip_rev) {
249 case FAN53526_CHIP_REV_08:
250 di->vsel_min = 600000;
251 di->vsel_step = 6250;
252 break;
253 default:
254 dev_err(di->dev,
255 "Chip ID %d with rev %d not supported!\n",
256 di->chip_id, di->chip_rev);
257 return -EINVAL;
258 }
259 break;
260 default:
261 dev_err(di->dev,
262 "Chip ID %d not supported!\n", di->chip_id);
263 return -EINVAL;
264 }
265
266 di->slew_reg = FAN53555_CONTROL;
267 di->slew_mask = CTL_SLEW_MASK;
268 di->ramp_delay_table = slew_rates;
269 di->n_ramp_values = ARRAY_SIZE(slew_rates);
270 di->vsel_count = FAN53526_NVOLTAGES;
271
272 return 0;
273}
274
275static int fan53555_voltages_setup_fairchild(struct fan53555_device_info *di)
276{
277 /* Init voltage range and step */
278 switch (di->chip_id) {
279 case FAN53555_CHIP_ID_00:
280 switch (di->chip_rev) {
281 case FAN53555_CHIP_REV_00:
282 di->vsel_min = 600000;
283 di->vsel_step = 10000;
284 break;
285 case FAN53555_CHIP_REV_13:
286 di->vsel_min = 800000;
287 di->vsel_step = 10000;
288 break;
289 default:
290 dev_err(di->dev,
291 "Chip ID %d with rev %d not supported!\n",
292 di->chip_id, di->chip_rev);
293 return -EINVAL;
294 }
295 break;
296 case FAN53555_CHIP_ID_01:
297 case FAN53555_CHIP_ID_03:
298 case FAN53555_CHIP_ID_05:
299 case FAN53555_CHIP_ID_08:
300 di->vsel_min = 600000;
301 di->vsel_step = 10000;
302 break;
303 case FAN53555_CHIP_ID_04:
304 di->vsel_min = 603000;
305 di->vsel_step = 12826;
306 break;
307 default:
308 dev_err(di->dev,
309 "Chip ID %d not supported!\n", di->chip_id);
310 return -EINVAL;
311 }
312 di->slew_reg = FAN53555_CONTROL;
313 di->slew_mask = CTL_SLEW_MASK;
314 di->ramp_delay_table = slew_rates;
315 di->n_ramp_values = ARRAY_SIZE(slew_rates);
316 di->vsel_count = FAN53555_NVOLTAGES;
317
318 return 0;
319}
320
321static int fan53555_voltages_setup_silergy(struct fan53555_device_info *di)
322{
323 /* Init voltage range and step */
324 switch (di->chip_id) {
325 case SILERGY_SYR82X:
326 case SILERGY_SYR83X:
327 di->vsel_min = 712500;
328 di->vsel_step = 12500;
329 break;
330 default:
331 dev_err(di->dev,
332 "Chip ID %d not supported!\n", di->chip_id);
333 return -EINVAL;
334 }
335 di->slew_reg = FAN53555_CONTROL;
336 di->slew_mask = CTL_SLEW_MASK;
337 di->ramp_delay_table = slew_rates;
338 di->n_ramp_values = ARRAY_SIZE(slew_rates);
339 di->vsel_count = FAN53555_NVOLTAGES;
340
341 return 0;
342}
343
344static int fan53526_voltages_setup_tcs(struct fan53555_device_info *di)
345{
346 switch (di->chip_id) {
347 case TCS4525_CHIP_ID_12:
348 case TCS4526_CHIP_ID_00:
349 di->slew_reg = TCS4525_TIME;
350 di->slew_mask = TCS_SLEW_MASK;
351 di->ramp_delay_table = tcs_slew_rates;
352 di->n_ramp_values = ARRAY_SIZE(tcs_slew_rates);
353
354 /* Init voltage range and step */
355 di->vsel_min = 600000;
356 di->vsel_step = 6250;
357 di->vsel_count = FAN53526_NVOLTAGES;
358 break;
359 default:
360 dev_err(di->dev, "Chip ID %d not supported!\n", di->chip_id);
361 return -EINVAL;
362 }
363
364 return 0;
365}
366
367/* For 00,01,03,05 options:
368 * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V.
369 * For 04 option:
370 * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V.
371 * */
372static int fan53555_device_setup(struct fan53555_device_info *di,
373 struct fan53555_platform_data *pdata)
374{
375 int ret = 0;
376
377 /* Setup voltage control register */
378 switch (di->vendor) {
379 case FAN53526_VENDOR_FAIRCHILD:
380 case FAN53555_VENDOR_FAIRCHILD:
381 case FAN53555_VENDOR_SILERGY:
382 switch (pdata->sleep_vsel_id) {
383 case FAN53555_VSEL_ID_0:
384 di->sleep_reg = FAN53555_VSEL0;
385 di->vol_reg = FAN53555_VSEL1;
386 break;
387 case FAN53555_VSEL_ID_1:
388 di->sleep_reg = FAN53555_VSEL1;
389 di->vol_reg = FAN53555_VSEL0;
390 break;
391 default:
392 dev_err(di->dev, "Invalid VSEL ID!\n");
393 return -EINVAL;
394 }
395 break;
396 case FAN53526_VENDOR_TCS:
397 switch (pdata->sleep_vsel_id) {
398 case FAN53555_VSEL_ID_0:
399 di->sleep_reg = TCS4525_VSEL0;
400 di->vol_reg = TCS4525_VSEL1;
401 break;
402 case FAN53555_VSEL_ID_1:
403 di->sleep_reg = TCS4525_VSEL1;
404 di->vol_reg = TCS4525_VSEL0;
405 break;
406 default:
407 dev_err(di->dev, "Invalid VSEL ID!\n");
408 return -EINVAL;
409 }
410 break;
411 default:
412 dev_err(di->dev, "vendor %d not supported!\n", di->vendor);
413 return -EINVAL;
414 }
415
416 /* Setup mode control register */
417 switch (di->vendor) {
418 case FAN53526_VENDOR_FAIRCHILD:
419 di->mode_reg = FAN53555_CONTROL;
420
421 switch (pdata->sleep_vsel_id) {
422 case FAN53555_VSEL_ID_0:
423 di->mode_mask = CTL_MODE_VSEL1_MODE;
424 break;
425 case FAN53555_VSEL_ID_1:
426 di->mode_mask = CTL_MODE_VSEL0_MODE;
427 break;
428 }
429 break;
430 case FAN53555_VENDOR_FAIRCHILD:
431 case FAN53555_VENDOR_SILERGY:
432 di->mode_reg = di->vol_reg;
433 di->mode_mask = VSEL_MODE;
434 break;
435 case FAN53526_VENDOR_TCS:
436 di->mode_reg = TCS4525_COMMAND;
437
438 switch (pdata->sleep_vsel_id) {
439 case FAN53555_VSEL_ID_0:
440 di->mode_mask = TCS_VSEL1_MODE;
441 break;
442 case FAN53555_VSEL_ID_1:
443 di->mode_mask = TCS_VSEL0_MODE;
444 break;
445 }
446 break;
447 default:
448 dev_err(di->dev, "vendor %d not supported!\n", di->vendor);
449 return -EINVAL;
450 }
451
452 /* Setup voltage range */
453 switch (di->vendor) {
454 case FAN53526_VENDOR_FAIRCHILD:
455 ret = fan53526_voltages_setup_fairchild(di);
456 break;
457 case FAN53555_VENDOR_FAIRCHILD:
458 ret = fan53555_voltages_setup_fairchild(di);
459 break;
460 case FAN53555_VENDOR_SILERGY:
461 ret = fan53555_voltages_setup_silergy(di);
462 break;
463 case FAN53526_VENDOR_TCS:
464 ret = fan53526_voltages_setup_tcs(di);
465 break;
466 default:
467 dev_err(di->dev, "vendor %d not supported!\n", di->vendor);
468 return -EINVAL;
469 }
470
471 return ret;
472}
473
474static int fan53555_regulator_register(struct fan53555_device_info *di,
475 struct regulator_config *config)
476{
477 struct regulator_desc *rdesc = &di->desc;
478 struct regulator_dev *rdev;
479
480 rdesc->name = "fan53555-reg";
481 rdesc->supply_name = "vin";
482 rdesc->ops = &fan53555_regulator_ops;
483 rdesc->type = REGULATOR_VOLTAGE;
484 rdesc->n_voltages = di->vsel_count;
485 rdesc->enable_reg = di->vol_reg;
486 rdesc->enable_mask = VSEL_BUCK_EN;
487 rdesc->min_uV = di->vsel_min;
488 rdesc->uV_step = di->vsel_step;
489 rdesc->vsel_reg = di->vol_reg;
490 rdesc->vsel_mask = di->vsel_count - 1;
491 rdesc->ramp_reg = di->slew_reg;
492 rdesc->ramp_mask = di->slew_mask;
493 rdesc->ramp_delay_table = di->ramp_delay_table;
494 rdesc->n_ramp_values = di->n_ramp_values;
495 rdesc->owner = THIS_MODULE;
496
497 rdev = devm_regulator_register(di->dev, &di->desc, config);
498 return PTR_ERR_OR_ZERO(rdev);
499}
500
501static const struct regmap_config fan53555_regmap_config = {
502 .reg_bits = 8,
503 .val_bits = 8,
504};
505
506static struct fan53555_platform_data *fan53555_parse_dt(struct device *dev,
507 struct device_node *np,
508 const struct regulator_desc *desc)
509{
510 struct fan53555_platform_data *pdata;
511 int ret;
512 u32 tmp;
513
514 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
515 if (!pdata)
516 return NULL;
517
518 pdata->regulator = of_get_regulator_init_data(dev, np, desc);
519
520 ret = of_property_read_u32(np, "fcs,suspend-voltage-selector",
521 &tmp);
522 if (!ret)
523 pdata->sleep_vsel_id = tmp;
524
525 return pdata;
526}
527
528static const struct of_device_id __maybe_unused fan53555_dt_ids[] = {
529 {
530 .compatible = "fcs,fan53526",
531 .data = (void *)FAN53526_VENDOR_FAIRCHILD,
532 }, {
533 .compatible = "fcs,fan53555",
534 .data = (void *)FAN53555_VENDOR_FAIRCHILD
535 }, {
536 .compatible = "silergy,syr827",
537 .data = (void *)FAN53555_VENDOR_SILERGY,
538 }, {
539 .compatible = "silergy,syr828",
540 .data = (void *)FAN53555_VENDOR_SILERGY,
541 }, {
542 .compatible = "tcs,tcs4525",
543 .data = (void *)FAN53526_VENDOR_TCS
544 }, {
545 .compatible = "tcs,tcs4526",
546 .data = (void *)FAN53526_VENDOR_TCS
547 },
548 { }
549};
550MODULE_DEVICE_TABLE(of, fan53555_dt_ids);
551
552static int fan53555_regulator_probe(struct i2c_client *client)
553{
554 const struct i2c_device_id *id = i2c_client_get_device_id(client);
555 struct device_node *np = client->dev.of_node;
556 struct fan53555_device_info *di;
557 struct fan53555_platform_data *pdata;
558 struct regulator_config config = { };
559 struct regmap *regmap;
560 unsigned int val;
561 int ret;
562
563 di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info),
564 GFP_KERNEL);
565 if (!di)
566 return -ENOMEM;
567
568 pdata = dev_get_platdata(&client->dev);
569 if (!pdata)
570 pdata = fan53555_parse_dt(&client->dev, np, &di->desc);
571
572 if (!pdata || !pdata->regulator) {
573 dev_err(&client->dev, "Platform data not found!\n");
574 return -ENODEV;
575 }
576
577 di->regulator = pdata->regulator;
578 if (client->dev.of_node) {
579 di->vendor =
580 (unsigned long)of_device_get_match_data(&client->dev);
581 } else {
582 /* if no ramp constraint set, get the pdata ramp_delay */
583 if (!di->regulator->constraints.ramp_delay) {
584 if (pdata->slew_rate >= ARRAY_SIZE(slew_rates)) {
585 dev_err(&client->dev, "Invalid slew_rate\n");
586 return -EINVAL;
587 }
588
589 di->regulator->constraints.ramp_delay
590 = slew_rates[pdata->slew_rate];
591 }
592
593 di->vendor = id->driver_data;
594 }
595
596 regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config);
597 if (IS_ERR(regmap)) {
598 dev_err(&client->dev, "Failed to allocate regmap!\n");
599 return PTR_ERR(regmap);
600 }
601 di->dev = &client->dev;
602 i2c_set_clientdata(client, di);
603 /* Get chip ID */
604 ret = regmap_read(regmap, FAN53555_ID1, &val);
605 if (ret < 0) {
606 dev_err(&client->dev, "Failed to get chip ID!\n");
607 return ret;
608 }
609 di->chip_id = val & DIE_ID;
610 /* Get chip revision */
611 ret = regmap_read(regmap, FAN53555_ID2, &val);
612 if (ret < 0) {
613 dev_err(&client->dev, "Failed to get chip Rev!\n");
614 return ret;
615 }
616 di->chip_rev = val & DIE_REV;
617 dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n",
618 di->chip_id, di->chip_rev);
619 /* Device init */
620 ret = fan53555_device_setup(di, pdata);
621 if (ret < 0) {
622 dev_err(&client->dev, "Failed to setup device!\n");
623 return ret;
624 }
625 /* Register regulator */
626 config.dev = di->dev;
627 config.init_data = di->regulator;
628 config.regmap = regmap;
629 config.driver_data = di;
630 config.of_node = np;
631
632 ret = fan53555_regulator_register(di, &config);
633 if (ret < 0)
634 dev_err(&client->dev, "Failed to register regulator!\n");
635 return ret;
636
637}
638
639static const struct i2c_device_id fan53555_id[] = {
640 {
641 .name = "fan53526",
642 .driver_data = FAN53526_VENDOR_FAIRCHILD
643 }, {
644 .name = "fan53555",
645 .driver_data = FAN53555_VENDOR_FAIRCHILD
646 }, {
647 .name = "syr827",
648 .driver_data = FAN53555_VENDOR_SILERGY
649 }, {
650 .name = "syr828",
651 .driver_data = FAN53555_VENDOR_SILERGY
652 }, {
653 .name = "tcs4525",
654 .driver_data = FAN53526_VENDOR_TCS
655 }, {
656 .name = "tcs4526",
657 .driver_data = FAN53526_VENDOR_TCS
658 },
659 { },
660};
661MODULE_DEVICE_TABLE(i2c, fan53555_id);
662
663static struct i2c_driver fan53555_regulator_driver = {
664 .driver = {
665 .name = "fan53555-regulator",
666 .of_match_table = of_match_ptr(fan53555_dt_ids),
667 },
668 .probe_new = fan53555_regulator_probe,
669 .id_table = fan53555_id,
670};
671
672module_i2c_driver(fan53555_regulator_driver);
673
674MODULE_AUTHOR("Yunfan Zhang <yfzhang@marvell.com>");
675MODULE_DESCRIPTION("FAN53555 regulator driver");
676MODULE_LICENSE("GPL v2");
1/*
2 * FAN53555 Fairchild Digitally Programmable TinyBuck Regulator Driver.
3 *
4 * Supported Part Numbers:
5 * FAN53555UC00X/01X/03X/04X/05X
6 *
7 * Copyright (c) 2012 Marvell Technology Ltd.
8 * Yunfan Zhang <yfzhang@marvell.com>
9 *
10 * This package is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 *
14 */
15#include <linux/module.h>
16#include <linux/param.h>
17#include <linux/err.h>
18#include <linux/platform_device.h>
19#include <linux/regulator/driver.h>
20#include <linux/regulator/machine.h>
21#include <linux/regulator/of_regulator.h>
22#include <linux/of_device.h>
23#include <linux/i2c.h>
24#include <linux/slab.h>
25#include <linux/regmap.h>
26#include <linux/regulator/fan53555.h>
27
28/* Voltage setting */
29#define FAN53555_VSEL0 0x00
30#define FAN53555_VSEL1 0x01
31/* Control register */
32#define FAN53555_CONTROL 0x02
33/* IC Type */
34#define FAN53555_ID1 0x03
35/* IC mask version */
36#define FAN53555_ID2 0x04
37/* Monitor register */
38#define FAN53555_MONITOR 0x05
39
40/* VSEL bit definitions */
41#define VSEL_BUCK_EN (1 << 7)
42#define VSEL_MODE (1 << 6)
43#define VSEL_NSEL_MASK 0x3F
44/* Chip ID and Verison */
45#define DIE_ID 0x0F /* ID1 */
46#define DIE_REV 0x0F /* ID2 */
47/* Control bit definitions */
48#define CTL_OUTPUT_DISCHG (1 << 7)
49#define CTL_SLEW_MASK (0x7 << 4)
50#define CTL_SLEW_SHIFT 4
51#define CTL_RESET (1 << 2)
52
53#define FAN53555_NVOLTAGES 64 /* Numbers of voltages */
54
55enum fan53555_vendor {
56 FAN53555_VENDOR_FAIRCHILD = 0,
57 FAN53555_VENDOR_SILERGY,
58};
59
60/* IC Type */
61enum {
62 FAN53555_CHIP_ID_00 = 0,
63 FAN53555_CHIP_ID_01,
64 FAN53555_CHIP_ID_02,
65 FAN53555_CHIP_ID_03,
66 FAN53555_CHIP_ID_04,
67 FAN53555_CHIP_ID_05,
68};
69
70enum {
71 SILERGY_SYR82X = 8,
72};
73
74struct fan53555_device_info {
75 enum fan53555_vendor vendor;
76 struct regmap *regmap;
77 struct device *dev;
78 struct regulator_desc desc;
79 struct regulator_dev *rdev;
80 struct regulator_init_data *regulator;
81 /* IC Type and Rev */
82 int chip_id;
83 int chip_rev;
84 /* Voltage setting register */
85 unsigned int vol_reg;
86 unsigned int sleep_reg;
87 /* Voltage range and step(linear) */
88 unsigned int vsel_min;
89 unsigned int vsel_step;
90 /* Voltage slew rate limiting */
91 unsigned int slew_rate;
92 /* Sleep voltage cache */
93 unsigned int sleep_vol_cache;
94};
95
96static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV)
97{
98 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
99 int ret;
100
101 if (di->sleep_vol_cache == uV)
102 return 0;
103 ret = regulator_map_voltage_linear(rdev, uV, uV);
104 if (ret < 0)
105 return ret;
106 ret = regmap_update_bits(di->regmap, di->sleep_reg,
107 VSEL_NSEL_MASK, ret);
108 if (ret < 0)
109 return ret;
110 /* Cache the sleep voltage setting.
111 * Might not be the real voltage which is rounded */
112 di->sleep_vol_cache = uV;
113
114 return 0;
115}
116
117static int fan53555_set_suspend_enable(struct regulator_dev *rdev)
118{
119 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
120
121 return regmap_update_bits(di->regmap, di->sleep_reg,
122 VSEL_BUCK_EN, VSEL_BUCK_EN);
123}
124
125static int fan53555_set_suspend_disable(struct regulator_dev *rdev)
126{
127 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
128
129 return regmap_update_bits(di->regmap, di->sleep_reg,
130 VSEL_BUCK_EN, 0);
131}
132
133static int fan53555_set_mode(struct regulator_dev *rdev, unsigned int mode)
134{
135 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
136
137 switch (mode) {
138 case REGULATOR_MODE_FAST:
139 regmap_update_bits(di->regmap, di->vol_reg,
140 VSEL_MODE, VSEL_MODE);
141 break;
142 case REGULATOR_MODE_NORMAL:
143 regmap_update_bits(di->regmap, di->vol_reg, VSEL_MODE, 0);
144 break;
145 default:
146 return -EINVAL;
147 }
148 return 0;
149}
150
151static unsigned int fan53555_get_mode(struct regulator_dev *rdev)
152{
153 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
154 unsigned int val;
155 int ret = 0;
156
157 ret = regmap_read(di->regmap, di->vol_reg, &val);
158 if (ret < 0)
159 return ret;
160 if (val & VSEL_MODE)
161 return REGULATOR_MODE_FAST;
162 else
163 return REGULATOR_MODE_NORMAL;
164}
165
166static const int slew_rates[] = {
167 64000,
168 32000,
169 16000,
170 8000,
171 4000,
172 2000,
173 1000,
174 500,
175};
176
177static int fan53555_set_ramp(struct regulator_dev *rdev, int ramp)
178{
179 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
180 int regval = -1, i;
181
182 for (i = 0; i < ARRAY_SIZE(slew_rates); i++) {
183 if (ramp <= slew_rates[i])
184 regval = i;
185 else
186 break;
187 }
188
189 if (regval < 0) {
190 dev_err(di->dev, "unsupported ramp value %d\n", ramp);
191 return -EINVAL;
192 }
193
194 return regmap_update_bits(di->regmap, FAN53555_CONTROL,
195 CTL_SLEW_MASK, regval << CTL_SLEW_SHIFT);
196}
197
198static struct regulator_ops fan53555_regulator_ops = {
199 .set_voltage_sel = regulator_set_voltage_sel_regmap,
200 .get_voltage_sel = regulator_get_voltage_sel_regmap,
201 .set_voltage_time_sel = regulator_set_voltage_time_sel,
202 .map_voltage = regulator_map_voltage_linear,
203 .list_voltage = regulator_list_voltage_linear,
204 .set_suspend_voltage = fan53555_set_suspend_voltage,
205 .enable = regulator_enable_regmap,
206 .disable = regulator_disable_regmap,
207 .is_enabled = regulator_is_enabled_regmap,
208 .set_mode = fan53555_set_mode,
209 .get_mode = fan53555_get_mode,
210 .set_ramp_delay = fan53555_set_ramp,
211 .set_suspend_enable = fan53555_set_suspend_enable,
212 .set_suspend_disable = fan53555_set_suspend_disable,
213};
214
215static int fan53555_voltages_setup_fairchild(struct fan53555_device_info *di)
216{
217 /* Init voltage range and step */
218 switch (di->chip_id) {
219 case FAN53555_CHIP_ID_00:
220 case FAN53555_CHIP_ID_01:
221 case FAN53555_CHIP_ID_03:
222 case FAN53555_CHIP_ID_05:
223 di->vsel_min = 600000;
224 di->vsel_step = 10000;
225 break;
226 case FAN53555_CHIP_ID_04:
227 di->vsel_min = 603000;
228 di->vsel_step = 12826;
229 break;
230 default:
231 dev_err(di->dev,
232 "Chip ID %d not supported!\n", di->chip_id);
233 return -EINVAL;
234 }
235
236 return 0;
237}
238
239static int fan53555_voltages_setup_silergy(struct fan53555_device_info *di)
240{
241 /* Init voltage range and step */
242 switch (di->chip_id) {
243 case SILERGY_SYR82X:
244 di->vsel_min = 712500;
245 di->vsel_step = 12500;
246 break;
247 default:
248 dev_err(di->dev,
249 "Chip ID %d not supported!\n", di->chip_id);
250 return -EINVAL;
251 }
252
253 return 0;
254}
255
256/* For 00,01,03,05 options:
257 * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V.
258 * For 04 option:
259 * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V.
260 * */
261static int fan53555_device_setup(struct fan53555_device_info *di,
262 struct fan53555_platform_data *pdata)
263{
264 int ret = 0;
265
266 /* Setup voltage control register */
267 switch (pdata->sleep_vsel_id) {
268 case FAN53555_VSEL_ID_0:
269 di->sleep_reg = FAN53555_VSEL0;
270 di->vol_reg = FAN53555_VSEL1;
271 break;
272 case FAN53555_VSEL_ID_1:
273 di->sleep_reg = FAN53555_VSEL1;
274 di->vol_reg = FAN53555_VSEL0;
275 break;
276 default:
277 dev_err(di->dev, "Invalid VSEL ID!\n");
278 return -EINVAL;
279 }
280
281 switch (di->vendor) {
282 case FAN53555_VENDOR_FAIRCHILD:
283 ret = fan53555_voltages_setup_fairchild(di);
284 break;
285 case FAN53555_VENDOR_SILERGY:
286 ret = fan53555_voltages_setup_silergy(di);
287 break;
288 default:
289 dev_err(di->dev, "vendor %d not supported!\n", di->vendor);
290 return -EINVAL;
291 }
292
293 return ret;
294}
295
296static int fan53555_regulator_register(struct fan53555_device_info *di,
297 struct regulator_config *config)
298{
299 struct regulator_desc *rdesc = &di->desc;
300
301 rdesc->name = "fan53555-reg";
302 rdesc->supply_name = "vin";
303 rdesc->ops = &fan53555_regulator_ops;
304 rdesc->type = REGULATOR_VOLTAGE;
305 rdesc->n_voltages = FAN53555_NVOLTAGES;
306 rdesc->enable_reg = di->vol_reg;
307 rdesc->enable_mask = VSEL_BUCK_EN;
308 rdesc->min_uV = di->vsel_min;
309 rdesc->uV_step = di->vsel_step;
310 rdesc->vsel_reg = di->vol_reg;
311 rdesc->vsel_mask = VSEL_NSEL_MASK;
312 rdesc->owner = THIS_MODULE;
313
314 di->rdev = devm_regulator_register(di->dev, &di->desc, config);
315 return PTR_ERR_OR_ZERO(di->rdev);
316}
317
318static const struct regmap_config fan53555_regmap_config = {
319 .reg_bits = 8,
320 .val_bits = 8,
321};
322
323static struct fan53555_platform_data *fan53555_parse_dt(struct device *dev,
324 struct device_node *np,
325 const struct regulator_desc *desc)
326{
327 struct fan53555_platform_data *pdata;
328 int ret;
329 u32 tmp;
330
331 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
332 if (!pdata)
333 return NULL;
334
335 pdata->regulator = of_get_regulator_init_data(dev, np, desc);
336
337 ret = of_property_read_u32(np, "fcs,suspend-voltage-selector",
338 &tmp);
339 if (!ret)
340 pdata->sleep_vsel_id = tmp;
341
342 return pdata;
343}
344
345static const struct of_device_id fan53555_dt_ids[] = {
346 {
347 .compatible = "fcs,fan53555",
348 .data = (void *)FAN53555_VENDOR_FAIRCHILD
349 }, {
350 .compatible = "silergy,syr827",
351 .data = (void *)FAN53555_VENDOR_SILERGY,
352 }, {
353 .compatible = "silergy,syr828",
354 .data = (void *)FAN53555_VENDOR_SILERGY,
355 },
356 { }
357};
358MODULE_DEVICE_TABLE(of, fan53555_dt_ids);
359
360static int fan53555_regulator_probe(struct i2c_client *client,
361 const struct i2c_device_id *id)
362{
363 struct device_node *np = client->dev.of_node;
364 struct fan53555_device_info *di;
365 struct fan53555_platform_data *pdata;
366 struct regulator_config config = { };
367 unsigned int val;
368 int ret;
369
370 di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info),
371 GFP_KERNEL);
372 if (!di)
373 return -ENOMEM;
374
375 pdata = dev_get_platdata(&client->dev);
376 if (!pdata)
377 pdata = fan53555_parse_dt(&client->dev, np, &di->desc);
378
379 if (!pdata || !pdata->regulator) {
380 dev_err(&client->dev, "Platform data not found!\n");
381 return -ENODEV;
382 }
383
384 di->regulator = pdata->regulator;
385 if (client->dev.of_node) {
386 const struct of_device_id *match;
387
388 match = of_match_device(of_match_ptr(fan53555_dt_ids),
389 &client->dev);
390 if (!match)
391 return -ENODEV;
392
393 di->vendor = (unsigned long) match->data;
394 } else {
395 /* if no ramp constraint set, get the pdata ramp_delay */
396 if (!di->regulator->constraints.ramp_delay) {
397 int slew_idx = (pdata->slew_rate & 0x7)
398 ? pdata->slew_rate : 0;
399
400 di->regulator->constraints.ramp_delay
401 = slew_rates[slew_idx];
402 }
403
404 di->vendor = id->driver_data;
405 }
406
407 di->regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config);
408 if (IS_ERR(di->regmap)) {
409 dev_err(&client->dev, "Failed to allocate regmap!\n");
410 return PTR_ERR(di->regmap);
411 }
412 di->dev = &client->dev;
413 i2c_set_clientdata(client, di);
414 /* Get chip ID */
415 ret = regmap_read(di->regmap, FAN53555_ID1, &val);
416 if (ret < 0) {
417 dev_err(&client->dev, "Failed to get chip ID!\n");
418 return ret;
419 }
420 di->chip_id = val & DIE_ID;
421 /* Get chip revision */
422 ret = regmap_read(di->regmap, FAN53555_ID2, &val);
423 if (ret < 0) {
424 dev_err(&client->dev, "Failed to get chip Rev!\n");
425 return ret;
426 }
427 di->chip_rev = val & DIE_REV;
428 dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n",
429 di->chip_id, di->chip_rev);
430 /* Device init */
431 ret = fan53555_device_setup(di, pdata);
432 if (ret < 0) {
433 dev_err(&client->dev, "Failed to setup device!\n");
434 return ret;
435 }
436 /* Register regulator */
437 config.dev = di->dev;
438 config.init_data = di->regulator;
439 config.regmap = di->regmap;
440 config.driver_data = di;
441 config.of_node = np;
442
443 ret = fan53555_regulator_register(di, &config);
444 if (ret < 0)
445 dev_err(&client->dev, "Failed to register regulator!\n");
446 return ret;
447
448}
449
450static const struct i2c_device_id fan53555_id[] = {
451 {
452 .name = "fan53555",
453 .driver_data = FAN53555_VENDOR_FAIRCHILD
454 }, {
455 .name = "syr82x",
456 .driver_data = FAN53555_VENDOR_SILERGY
457 },
458 { },
459};
460MODULE_DEVICE_TABLE(i2c, fan53555_id);
461
462static struct i2c_driver fan53555_regulator_driver = {
463 .driver = {
464 .name = "fan53555-regulator",
465 .of_match_table = of_match_ptr(fan53555_dt_ids),
466 },
467 .probe = fan53555_regulator_probe,
468 .id_table = fan53555_id,
469};
470
471module_i2c_driver(fan53555_regulator_driver);
472
473MODULE_AUTHOR("Yunfan Zhang <yfzhang@marvell.com>");
474MODULE_DESCRIPTION("FAN53555 regulator driver");
475MODULE_LICENSE("GPL v2");