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