~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,17 +1,13 @@
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		- */
	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	+
15	11	#include <linux/module.h>
16	12	#include <linux/param.h>
17	13	#include <linux/err.h>
..	..	@@ -24,22 +20,16 @@
24	20	#include <linux/slab.h>
25	21	#include <linux/regmap.h>
26	22	#include <linux/regulator/fan53555.h>
27		-#include <linux/gpio.h>
28		-#include <linux/of_gpio.h>
29	23
30	24	/* Voltage setting */
31	25	#define FAN53555_VSEL0 0x00
32	26	#define FAN53555_VSEL1 0x01
33	27
34		-#define RK860X_VSEL0 0x06
35		-#define RK860X_VSEL1 0x07
36		-#define RK860X_MAX_SET 0x08
37		-
38		-#define TCS452X_VSEL0 0x11
39		-#define TCS452X_VSEL1 0x10
40		-#define TCS452X_TIME 0x13
41		-#define TCS452X_COMMAND 0x14
42		-#define TCS452X_LIMCONF 0x16
	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
43	33
44	34	/* Control register */
45	35	#define FAN53555_CONTROL 0x02
..	..	@@ -53,7 +43,6 @@
53	43	/* VSEL bit definitions */
54	44	#define VSEL_BUCK_EN (1 << 7)
55	45	#define VSEL_MODE (1 << 6)
56		-#define VSEL_NSEL_MASK 0x3F
57	46	/* Chip ID and Verison */
58	47	#define DIE_ID 0x0F /* ID1 */
59	48	#define DIE_REV 0x0F /* ID2 */
..	..	@@ -62,25 +51,31 @@
62	51	#define CTL_SLEW_MASK (0x7 << 4)
63	52	#define CTL_SLEW_SHIFT 4
64	53	#define CTL_RESET (1 << 2)
	54	+#define CTL_MODE_VSEL0_MODE BIT(0)
	55	+#define CTL_MODE_VSEL1_MODE BIT(1)
65	56
66		-#define RK_VSEL_NSEL_MASK 0xff
	57	+#define FAN53555_NVOLTAGES 64 /* Numbers of voltages */
	58	+#define FAN53526_NVOLTAGES 128
67	59
68		-#define TCS_VSEL_NSEL_MASK 0x7f
69	60	#define TCS_VSEL0_MODE (1 << 7)
70	61	#define TCS_VSEL1_MODE (1 << 6)
71	62
72	63	#define TCS_SLEW_SHIFT 3
73	64	#define TCS_SLEW_MASK (0x3 < 3)
74	65
75		-#define FAN53555_NVOLTAGES_64 64 /* Numbers of voltages */
76		-#define FAN53555_NVOLTAGES_127 127 /* Numbers of voltages */
77		-#define FAN53555_NVOLTAGES_160 160 /* Numbers of voltages */
78		-
79	66	enum fan53555_vendor {
80		- FAN53555_VENDOR_FAIRCHILD = 0,
81		- FAN53555_VENDOR_RK,
	67	+ FAN53526_VENDOR_FAIRCHILD = 0,
	68	+ FAN53555_VENDOR_FAIRCHILD,
82	69	FAN53555_VENDOR_SILERGY,
83		- FAN53555_VENDOR_TCS,
	70	+ FAN53526_VENDOR_TCS,
	71	+};
	72	+
	73	+enum {
	74	+ FAN53526_CHIP_ID_01 = 1,
	75	+};
	76	+
	77	+enum {
	78	+ FAN53526_CHIP_REV_08 = 8,
84	79	};
85	80
86	81	/* IC Type */
..	..	@@ -94,6 +89,14 @@
94	89	FAN53555_CHIP_ID_08 = 8,
95	90	};
96	91
	92	+enum {
	93	+ TCS4525_CHIP_ID_12 = 12,
	94	+};
	95	+
	96	+enum {
	97	+ TCS4526_CHIP_ID_00 = 0,
	98	+};
	99	+
97	100	/* IC mask revision */
98	101	enum {
99	102	FAN53555_CHIP_REV_00 = 0x3,
..	..	@@ -102,6 +105,7 @@
102	105
103	106	enum {
104	107	SILERGY_SYR82X = 8,
	108	+ SILERGY_SYR83X = 9,
105	109	};
106	110
107	111	struct fan53555_device_info {
..	..	@@ -109,7 +113,6 @@
109	113	struct regmap *regmap;
110	114	struct device *dev;
111	115	struct regulator_desc desc;
112		- struct regulator_dev *rdev;
113	116	struct regulator_init_data *regulator;
114	117	/* IC Type and Rev */
115	118	int chip_id;
..	..	@@ -117,50 +120,26 @@
117	120	/* Voltage setting register */
118	121	unsigned int vol_reg;
119	122	unsigned int sleep_reg;
120		- unsigned int en_reg;
121		- unsigned int sleep_en_reg;
122		- unsigned int mode_reg;
123		- unsigned int vol_mask;
124		- unsigned int mode_mask;
125		- unsigned int slew_reg;
126		- unsigned int slew_mask;
127		- unsigned int slew_shift;
128	123	/* Voltage range and step(linear) */
129	124	unsigned int vsel_min;
130	125	unsigned int vsel_step;
131		- unsigned int n_voltages;
132		- /* Voltage slew rate limiting */
133		- unsigned int slew_rate;
	126	+ unsigned int vsel_count;
	127	+ /* Mode */
	128	+ unsigned int mode_reg;
	129	+ unsigned int mode_mask;
134	130	/* Sleep voltage cache */
135	131	unsigned int sleep_vol_cache;
136		- struct gpio_desc *vsel_gpio;
137		- unsigned int sleep_vsel_id;
	132	+ /* Slew rate */
	133	+ unsigned int slew_reg;
	134	+ unsigned int slew_mask;
	135	+ unsigned int slew_shift;
	136	+ unsigned int slew_rate;
138	137	};
139	138
140	139	static unsigned int fan53555_map_mode(unsigned int mode)
141	140	{
142	141	return mode == REGULATOR_MODE_FAST ?
143	142	REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
144		-}
145		-
146		-static int fan53555_get_voltage(struct regulator_dev *rdev)
147		-{
148		- struct fan53555_device_info *di = rdev_get_drvdata(rdev);
149		- unsigned int val;
150		- int ret;
151		-
152		- if (di->vendor == FAN53555_VENDOR_RK) {
153		- ret = regmap_read(di->regmap, RK860X_MAX_SET, &val);
154		- if (ret < 0)
155		- return ret;
156		- ret = regulator_get_voltage_sel_regmap(rdev);
157		- if (ret > val)
158		- return val;
159		- } else {
160		- ret = regulator_get_voltage_sel_regmap(rdev);
161		- }
162		-
163		- return ret;
164	143	}
165	144
166	145	static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV)
..	..	@@ -173,8 +152,8 @@
173	152	ret = regulator_map_voltage_linear(rdev, uV, uV);
174	153	if (ret < 0)
175	154	return ret;
176		- ret = regmap_update_bits(di->regmap, di->sleep_reg,
177		- di->vol_mask, ret);
	155	+ ret = regmap_update_bits(rdev->regmap, di->sleep_reg,
	156	+ di->desc.vsel_mask, ret);
178	157	if (ret < 0)
179	158	return ret;
180	159	/* Cache the sleep voltage setting.
..	..	@@ -188,7 +167,7 @@
188	167	{
189	168	struct fan53555_device_info *di = rdev_get_drvdata(rdev);
190	169
191		- return regmap_update_bits(di->regmap, di->sleep_en_reg,
	170	+ return regmap_update_bits(rdev->regmap, di->sleep_reg,
192	171	VSEL_BUCK_EN, VSEL_BUCK_EN);
193	172	}
194	173
..	..	@@ -196,70 +175,8 @@
196	175	{
197	176	struct fan53555_device_info *di = rdev_get_drvdata(rdev);
198	177
199		- return regmap_update_bits(di->regmap, di->sleep_en_reg,
	178	+ return regmap_update_bits(rdev->regmap, di->sleep_reg,
200	179	VSEL_BUCK_EN, 0);
201		-}
202		-
203		-static int fan53555_resume(struct regulator_dev *rdev)
204		-{
205		- int ret;
206		-
207		- if (!rdev->constraints->state_mem.changeable)
208		- return 0;
209		-
210		- ret = fan53555_set_suspend_enable(rdev);
211		- if (ret)
212		- return ret;
213		-
214		- return regulator_suspend_enable(rdev, PM_SUSPEND_MEM);
215		-}
216		-
217		-static int fan53555_set_enable(struct regulator_dev *rdev)
218		-{
219		- struct fan53555_device_info *di = rdev_get_drvdata(rdev);
220		-
221		- if (di->vsel_gpio) {
222		- gpiod_set_raw_value(di->vsel_gpio, !di->sleep_vsel_id);
223		- return 0;
224		- }
225		-
226		- return regmap_update_bits(di->regmap, di->en_reg,
227		- VSEL_BUCK_EN, VSEL_BUCK_EN);
228		-}
229		-
230		-static int fan53555_set_disable(struct regulator_dev *rdev)
231		-{
232		- struct fan53555_device_info *di = rdev_get_drvdata(rdev);
233		-
234		- if (di->vsel_gpio) {
235		- gpiod_set_raw_value(di->vsel_gpio, di->sleep_vsel_id);
236		- return 0;
237		- }
238		-
239		- return regmap_update_bits(di->regmap, di->en_reg,
240		- VSEL_BUCK_EN, 0);
241		-}
242		-
243		-static int fan53555_is_enabled(struct regulator_dev *rdev)
244		-{
245		- struct fan53555_device_info *di = rdev_get_drvdata(rdev);
246		- unsigned int val;
247		- int ret = 0;
248		-
249		- if (di->vsel_gpio) {
250		- if (di->sleep_vsel_id)
251		- return !gpiod_get_raw_value(di->vsel_gpio);
252		- else
253		- return gpiod_get_raw_value(di->vsel_gpio);
254		- }
255		-
256		- ret = regmap_read(di->regmap, di->en_reg, &val);
257		- if (ret < 0)
258		- return ret;
259		- if (val & VSEL_BUCK_EN)
260		- return 1;
261		- else
262		- return 0;
263	180	}
264	181
265	182	static int fan53555_set_mode(struct regulator_dev *rdev, unsigned int mode)
..	..	@@ -268,11 +185,11 @@
268	185
269	186	switch (mode) {
270	187	case REGULATOR_MODE_FAST:
271		- regmap_update_bits(di->regmap, di->mode_reg,
	188	+ regmap_update_bits(rdev->regmap, di->mode_reg,
272	189	di->mode_mask, di->mode_mask);
273	190	break;
274	191	case REGULATOR_MODE_NORMAL:
275		- regmap_update_bits(di->regmap, di->mode_reg, di->mode_mask, 0);
	192	+ regmap_update_bits(rdev->regmap, di->vol_reg, di->mode_mask, 0);
276	193	break;
277	194	default:
278	195	return -EINVAL;
..	..	@@ -286,7 +203,7 @@
286	203	unsigned int val;
287	204	int ret = 0;
288	205
289		- ret = regmap_read(di->regmap, di->mode_reg, &val);
	206	+ ret = regmap_read(rdev->regmap, di->mode_reg, &val);
290	207	if (ret < 0)
291	208	return ret;
292	209	if (val & di->mode_mask)
..	..	@@ -321,13 +238,13 @@
321	238	int slew_rate_n;
322	239
323	240	switch (di->vendor) {
	241	+ case FAN53526_VENDOR_FAIRCHILD:
324	242	case FAN53555_VENDOR_FAIRCHILD:
325		- case FAN53555_VENDOR_RK:
326	243	case FAN53555_VENDOR_SILERGY:
327	244	slew_rate_t = slew_rates;
328	245	slew_rate_n = ARRAY_SIZE(slew_rates);
329	246	break;
330		- case FAN53555_VENDOR_TCS:
	247	+ case FAN53526_VENDOR_TCS:
331	248	slew_rate_t = tcs_slew_rates;
332	249	slew_rate_n = ARRAY_SIZE(tcs_slew_rates);
333	250	break;
..	..	@@ -347,27 +264,57 @@
347	264	return -EINVAL;
348	265	}
349	266
350		- return regmap_update_bits(di->regmap, di->slew_reg,
	267	+ return regmap_update_bits(rdev->regmap, di->slew_reg,
351	268	di->slew_mask, regval << di->slew_shift);
352	269	}
353	270
354	271	static const struct regulator_ops fan53555_regulator_ops = {
355	272	.set_voltage_sel = regulator_set_voltage_sel_regmap,
356		- .get_voltage_sel = fan53555_get_voltage,
	273	+ .get_voltage_sel = regulator_get_voltage_sel_regmap,
357	274	.set_voltage_time_sel = regulator_set_voltage_time_sel,
358	275	.map_voltage = regulator_map_voltage_linear,
359	276	.list_voltage = regulator_list_voltage_linear,
360	277	.set_suspend_voltage = fan53555_set_suspend_voltage,
361		- .enable = fan53555_set_enable,
362		- .disable = fan53555_set_disable,
363		- .is_enabled = fan53555_is_enabled,
	278	+ .enable = regulator_enable_regmap,
	279	+ .disable = regulator_disable_regmap,
	280	+ .is_enabled = regulator_is_enabled_regmap,
364	281	.set_mode = fan53555_set_mode,
365	282	.get_mode = fan53555_get_mode,
366	283	.set_ramp_delay = fan53555_set_ramp,
367	284	.set_suspend_enable = fan53555_set_suspend_enable,
368	285	.set_suspend_disable = fan53555_set_suspend_disable,
369		- .resume = fan53555_resume,
370	286	};
	287	+
	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	+}
371	318
372	319	static int fan53555_voltages_setup_fairchild(struct fan53555_device_info *di)
373	320	{
..	..	@@ -406,58 +353,10 @@
406	353	"Chip ID %d not supported!\n", di->chip_id);
407	354	return -EINVAL;
408	355	}
409		- di->vol_mask = VSEL_NSEL_MASK;
410		- di->mode_reg = di->vol_reg;
411		- di->mode_mask = VSEL_MODE;
412	356	di->slew_reg = FAN53555_CONTROL;
413	357	di->slew_mask = CTL_SLEW_MASK;
414	358	di->slew_shift = CTL_SLEW_SHIFT;
415		- di->n_voltages = FAN53555_NVOLTAGES_64;
416		-
417		- return 0;
418		-}
419		-
420		-static int fan53555_voltages_setup_rk(struct fan53555_device_info *di,
421		- struct fan53555_platform_data *pdata)
422		-{
423		- int ret = 0, val;
424		-
425		- if (di->sleep_vsel_id) {
426		- di->sleep_reg = RK860X_VSEL1;
427		- di->vol_reg = RK860X_VSEL0;
428		- di->mode_reg = FAN53555_VSEL0;
429		- di->en_reg = FAN53555_VSEL0;
430		- di->sleep_en_reg = FAN53555_VSEL1;
431		- } else {
432		- di->sleep_reg = RK860X_VSEL0;
433		- di->vol_reg = RK860X_VSEL1;
434		- di->mode_reg = FAN53555_VSEL1;
435		- di->en_reg = FAN53555_VSEL1;
436		- di->sleep_en_reg = FAN53555_VSEL0;
437		- }
438		-
439		- di->mode_mask = VSEL_MODE;
440		- di->vol_mask = RK_VSEL_NSEL_MASK;
441		- di->slew_reg = FAN53555_CONTROL;
442		- di->slew_mask = CTL_SLEW_MASK;
443		- di->slew_shift = CTL_SLEW_SHIFT;
444		-
445		- /* Init voltage range and step */
446		- di->vsel_min = 500000;
447		- di->vsel_step = 6250;
448		- di->n_voltages = FAN53555_NVOLTAGES_160;
449		-
450		- if (pdata->limit_volt) {
451		- if (pdata->limit_volt < di->vsel_min \|\|
452		- pdata->limit_volt > 1500000)
453		- pdata->limit_volt = 1500000;
454		- val = (pdata->limit_volt - di->vsel_min) / di->vsel_step;
455		- ret = regmap_write(di->regmap, RK860X_MAX_SET, val);
456		- if (ret < 0) {
457		- dev_err(di->dev, "Failed to set limit voltage!\n");
458		- return ret;
459		- }
460		- }
	359	+ di->vsel_count = FAN53555_NVOLTAGES;
461	360
462	361	return 0;
463	362	}
..	..	@@ -467,6 +366,7 @@
467	366	/* Init voltage range and step */
468	367	switch (di->chip_id) {
469	368	case SILERGY_SYR82X:
	369	+ case SILERGY_SYR83X:
470	370	di->vsel_min = 712500;
471	371	di->vsel_step = 12500;
472	372	break;
..	..	@@ -475,43 +375,32 @@
475	375	"Chip ID %d not supported!\n", di->chip_id);
476	376	return -EINVAL;
477	377	}
478		- di->vol_mask = VSEL_NSEL_MASK;
479		- di->mode_reg = di->vol_reg;
480		- di->mode_mask = VSEL_MODE;
481		- di->slew_reg = FAN53555_CONTROL;
482	378	di->slew_reg = FAN53555_CONTROL;
483	379	di->slew_mask = CTL_SLEW_MASK;
484	380	di->slew_shift = CTL_SLEW_SHIFT;
485		- di->n_voltages = FAN53555_NVOLTAGES_64;
	381	+ di->vsel_count = FAN53555_NVOLTAGES;
486	382
487	383	return 0;
488	384	}
489	385
490		-static int fan53555_voltages_setup_tcs(struct fan53555_device_info *di)
	386	+static int fan53526_voltages_setup_tcs(struct fan53555_device_info *di)
491	387	{
492		- if (di->sleep_vsel_id) {
493		- di->sleep_reg = TCS452X_VSEL1;
494		- di->vol_reg = TCS452X_VSEL0;
495		- di->mode_mask = TCS_VSEL0_MODE;
496		- } else {
497		- di->sleep_reg = TCS452X_VSEL0;
498		- di->vol_reg = TCS452X_VSEL1;
499		- di->mode_mask = TCS_VSEL1_MODE;
	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;
500	403	}
501		-
502		- di->mode_reg = TCS452X_COMMAND;
503		- di->vol_mask = TCS_VSEL_NSEL_MASK;
504		- di->slew_reg = TCS452X_TIME;
505		- di->slew_mask = TCS_SLEW_MASK;
506		- di->slew_shift = TCS_SLEW_MASK;
507		-
508		- /* Init voltage range and step */
509		- di->vsel_min = 600000;
510		- di->vsel_step = 6250;
511		- di->n_voltages = FAN53555_NVOLTAGES_127;
512		-
513		- di->en_reg = di->vol_reg;
514		- di->sleep_en_reg = di->sleep_reg;
515	404
516	405	return 0;
517	406	}
..	..	@@ -527,35 +416,93 @@
527	416	int ret = 0;
528	417
529	418	/* Setup voltage control register */
530		- switch (pdata->sleep_vsel_id) {
531		- case FAN53555_VSEL_ID_0:
532		- di->sleep_reg = FAN53555_VSEL0;
533		- di->vol_reg = FAN53555_VSEL1;
	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	+ }
534	436	break;
535		- case FAN53555_VSEL_ID_1:
536		- di->sleep_reg = FAN53555_VSEL1;
537		- di->vol_reg = FAN53555_VSEL0;
	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	+ }
538	451	break;
539	452	default:
540		- dev_err(di->dev, "Invalid VSEL ID!\n");
	453	+ dev_err(di->dev, "vendor %d not supported!\n", di->vendor);
541	454	return -EINVAL;
542	455	}
543	456
544		- di->en_reg = di->vol_reg;
545		- di->sleep_en_reg = di->sleep_reg;
546		-
	457	+ /* Setup mode control register */
547	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;
548	498	case FAN53555_VENDOR_FAIRCHILD:
549	499	ret = fan53555_voltages_setup_fairchild(di);
550		- break;
551		- case FAN53555_VENDOR_RK:
552		- ret = fan53555_voltages_setup_rk(di, pdata);
553	500	break;
554	501	case FAN53555_VENDOR_SILERGY:
555	502	ret = fan53555_voltages_setup_silergy(di);
556	503	break;
557		- case FAN53555_VENDOR_TCS:
558		- ret = fan53555_voltages_setup_tcs(di);
	504	+ case FAN53526_VENDOR_TCS:
	505	+ ret = fan53526_voltages_setup_tcs(di);
559	506	break;
560	507	default:
561	508	dev_err(di->dev, "vendor %d not supported!\n", di->vendor);
..	..	@@ -569,23 +516,23 @@
569	516	struct regulator_config *config)
570	517	{
571	518	struct regulator_desc *rdesc = &di->desc;
	519	+ struct regulator_dev *rdev;
572	520
573	521	rdesc->name = "fan53555-reg";
574	522	rdesc->supply_name = "vin";
575	523	rdesc->ops = &fan53555_regulator_ops;
576	524	rdesc->type = REGULATOR_VOLTAGE;
577		- rdesc->n_voltages = di->n_voltages;
578		- rdesc->enable_reg = di->en_reg;
	525	+ rdesc->n_voltages = di->vsel_count;
	526	+ rdesc->enable_reg = di->vol_reg;
579	527	rdesc->enable_mask = VSEL_BUCK_EN;
580	528	rdesc->min_uV = di->vsel_min;
581	529	rdesc->uV_step = di->vsel_step;
582	530	rdesc->vsel_reg = di->vol_reg;
583		- rdesc->vsel_mask = di->vol_mask;
	531	+ rdesc->vsel_mask = di->vsel_count - 1;
584	532	rdesc->owner = THIS_MODULE;
585		- rdesc->enable_time = 400;
586	533
587		- di->rdev = devm_regulator_register(di->dev, &di->desc, config);
588		- return PTR_ERR_OR_ZERO(di->rdev);
	534	+ rdev = devm_regulator_register(di->dev, &di->desc, config);
	535	+ return PTR_ERR_OR_ZERO(rdev);
589	536	}
590	537
591	538	static const struct regmap_config fan53555_regmap_config = {
..	..	@@ -598,7 +545,7 @@
598	545	const struct regulator_desc *desc)
599	546	{
600	547	struct fan53555_platform_data *pdata;
601		- int ret, flag, limit_volt;
	548	+ int ret;
602	549	u32 tmp;
603	550
604	551	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
..	..	@@ -606,43 +553,22 @@
606	553	return NULL;
607	554
608	555	pdata->regulator = of_get_regulator_init_data(dev, np, desc);
609		- pdata->regulator->constraints.initial_state = PM_SUSPEND_MEM;
610		-
611		- if (!(of_property_read_u32(np, "limit-microvolt", &limit_volt)))
612		- pdata->limit_volt = limit_volt;
613	556
614	557	ret = of_property_read_u32(np, "fcs,suspend-voltage-selector",
615	558	&tmp);
616	559	if (!ret)
617	560	pdata->sleep_vsel_id = tmp;
618	561
619		- if (pdata->sleep_vsel_id)
620		- flag = GPIOD_OUT_LOW;
621		- else
622		- flag = GPIOD_OUT_HIGH;
623		-
624		- pdata->vsel_gpio =
625		- devm_gpiod_get_index_optional(dev, "vsel", 0,
626		- flag);
627		- if (IS_ERR(pdata->vsel_gpio)) {
628		- ret = PTR_ERR(pdata->vsel_gpio);
629		- dev_err(dev, "failed to get vesl gpio (%d)\n", ret);
630		- pdata->vsel_gpio = NULL;
631		- }
632		-
633	562	return pdata;
634	563	}
635	564
636		-static const struct of_device_id fan53555_dt_ids[] = {
	565	+static const struct of_device_id __maybe_unused fan53555_dt_ids[] = {
637	566	{
	567	+ .compatible = "fcs,fan53526",
	568	+ .data = (void *)FAN53526_VENDOR_FAIRCHILD,
	569	+ }, {
638	570	.compatible = "fcs,fan53555",
639	571	.data = (void *)FAN53555_VENDOR_FAIRCHILD
640		- }, {
641		- .compatible = "rockchip,rk8603",
642		- .data = (void *)FAN53555_VENDOR_RK,
643		- }, {
644		- .compatible = "rockchip,rk8604",
645		- .data = (void *)FAN53555_VENDOR_RK,
646	572	}, {
647	573	.compatible = "silergy,syr827",
648	574	.data = (void *)FAN53555_VENDOR_SILERGY,
..	..	@@ -650,8 +576,14 @@
650	576	.compatible = "silergy,syr828",
651	577	.data = (void *)FAN53555_VENDOR_SILERGY,
652	578	}, {
653		- .compatible = "tcs,tcs452x", /* tcs4525/4526 */
654		- .data = (void *)FAN53555_VENDOR_TCS
	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
655	587	},
656	588	{ }
657	589	};
..	..	@@ -664,6 +596,7 @@
664	596	struct fan53555_device_info *di;
665	597	struct fan53555_platform_data *pdata;
666	598	struct regulator_config config = { };
	599	+ struct regmap *regmap;
667	600	unsigned int val;
668	601	int ret;
669	602
..	..	@@ -683,9 +616,6 @@
683	616	return -ENODEV;
684	617	}
685	618
686		- di->vsel_gpio = pdata->vsel_gpio;
687		- di->sleep_vsel_id = pdata->sleep_vsel_id;
688		-
689	619	di->regulator = pdata->regulator;
690	620	if (client->dev.of_node) {
691	621	di->vendor =
..	..	@@ -693,32 +623,35 @@
693	623	} else {
694	624	/* if no ramp constraint set, get the pdata ramp_delay */
695	625	if (!di->regulator->constraints.ramp_delay) {
696		- int slew_idx = (pdata->slew_rate & 0x7)
697		- ? pdata->slew_rate : 0;
	626	+ if (pdata->slew_rate >= ARRAY_SIZE(slew_rates)) {
	627	+ dev_err(&client->dev, "Invalid slew_rate\n");
	628	+ return -EINVAL;
	629	+ }
698	630
699	631	di->regulator->constraints.ramp_delay
700		- = slew_rates[slew_idx];
	632	+ = slew_rates[pdata->slew_rate];
701	633	}
702	634
703	635	di->vendor = id->driver_data;
704	636	}
705	637
706		- di->regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config);
707		- if (IS_ERR(di->regmap)) {
	638	+ regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config);
	639	+ if (IS_ERR(regmap)) {
708	640	dev_err(&client->dev, "Failed to allocate regmap!\n");
709		- return PTR_ERR(di->regmap);
	641	+ return PTR_ERR(regmap);
710	642	}
	643	+ di->regmap = regmap;
711	644	di->dev = &client->dev;
712	645	i2c_set_clientdata(client, di);
713	646	/* Get chip ID */
714		- ret = regmap_read(di->regmap, FAN53555_ID1, &val);
	647	+ ret = regmap_read(regmap, FAN53555_ID1, &val);
715	648	if (ret < 0) {
716	649	dev_err(&client->dev, "Failed to get chip ID!\n");
717	650	return ret;
718	651	}
719	652	di->chip_id = val & DIE_ID;
720	653	/* Get chip revision */
721		- ret = regmap_read(di->regmap, FAN53555_ID2, &val);
	654	+ ret = regmap_read(regmap, FAN53555_ID2, &val);
722	655	if (ret < 0) {
723	656	dev_err(&client->dev, "Failed to get chip Rev!\n");
724	657	return ret;
..	..	@@ -735,7 +668,7 @@
735	668	/* Register regulator */
736	669	config.dev = di->dev;
737	670	config.init_data = di->regulator;
738		- config.regmap = di->regmap;
	671	+ config.regmap = regmap;
739	672	config.driver_data = di;
740	673	config.of_node = np;
741	674
..	..	@@ -757,13 +690,12 @@
757	690
758	691	switch (di->vendor) {
759	692	case FAN53555_VENDOR_FAIRCHILD:
760		- case FAN53555_VENDOR_RK:
761	693	case FAN53555_VENDOR_SILERGY:
762	694	ret = regmap_update_bits(di->regmap, di->slew_reg,
763	695	CTL_RESET, CTL_RESET);
764	696	break;
765		- case FAN53555_VENDOR_TCS:
766		- ret = regmap_update_bits(di->regmap, TCS452X_LIMCONF,
	697	+ case FAN53526_VENDOR_TCS:
	698	+ ret = regmap_update_bits(di->regmap, TCS4525_LIMCONF,
767	699	CTL_RESET, CTL_RESET);
768	700	/*
769	701	* the device can't return 'ack' during the reset,
..	..	@@ -785,14 +717,11 @@
785	717
786	718	static const struct i2c_device_id fan53555_id[] = {
787	719	{
	720	+ .name = "fan53526",
	721	+ .driver_data = FAN53526_VENDOR_FAIRCHILD
	722	+ }, {
788	723	.name = "fan53555",
789	724	.driver_data = FAN53555_VENDOR_FAIRCHILD
790		- }, {
791		- .name = "rk8603",
792		- .driver_data = FAN53555_VENDOR_RK
793		- }, {
794		- .name = "rk8604",
795		- .driver_data = FAN53555_VENDOR_RK
796	725	}, {
797	726	.name = "syr827",
798	727	.driver_data = FAN53555_VENDOR_SILERGY
..	..	@@ -800,8 +729,14 @@
800	729	.name = "syr828",
801	730	.driver_data = FAN53555_VENDOR_SILERGY
802	731	}, {
	732	+ .name = "tcs4525",
	733	+ .driver_data = FAN53526_VENDOR_TCS
	734	+ }, {
	735	+ .name = "tcs4526",
	736	+ .driver_data = FAN53526_VENDOR_TCS
	737	+ }, {
803	738	.name = "tcs452x",
804		- .driver_data = FAN53555_VENDOR_TCS
	739	+ .driver_data = FAN53526_VENDOR_TCS
805	740	},
806	741	{ },
807	742	};