~hc/RK356X_SDK_RELEASE.git

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