1 /*
2  * Regulators driver for Maxim max8925
3  *
4  * Copyright (C) 2009 Marvell International Ltd.
5  *      Haojian Zhuang <haojian.zhuang@marvell.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/err.h>
15 #include <linux/i2c.h>
16 #include <linux/platform_device.h>
17 #include <linux/regulator/driver.h>
18 #include <linux/regulator/machine.h>
19 #include <linux/mfd/max8925.h>
20 #include <linux/of.h>
21 #include <linux/regulator/of_regulator.h>
22 
23 #define SD1_DVM_VMIN		850000
24 #define SD1_DVM_VMAX		1000000
25 #define SD1_DVM_STEP		50000
26 #define SD1_DVM_SHIFT		5		/* SDCTL1 bit5 */
27 #define SD1_DVM_EN		6		/* SDV1 bit 6 */
28 
29 /* bit definitions in LDO control registers */
30 #define LDO_SEQ_I2C		0x7		/* Power U/D by i2c */
31 #define LDO_SEQ_MASK		0x7		/* Power U/D sequence mask */
32 #define LDO_SEQ_SHIFT		2		/* Power U/D sequence offset */
33 #define LDO_I2C_EN		0x1		/* Enable by i2c */
34 #define LDO_I2C_EN_MASK		0x1		/* Enable mask by i2c */
35 #define LDO_I2C_EN_SHIFT	0		/* Enable offset by i2c */
36 
37 struct max8925_regulator_info {
38 	struct regulator_desc	desc;
39 	struct i2c_client	*i2c;
40 
41 	int	vol_reg;
42 	int	enable_reg;
43 };
44 
45 static int max8925_set_voltage_sel(struct regulator_dev *rdev,
46 				   unsigned int selector)
47 {
48 	struct max8925_regulator_info *info = rdev_get_drvdata(rdev);
49 	unsigned char mask = rdev->desc->n_voltages - 1;
50 
51 	return max8925_set_bits(info->i2c, info->vol_reg, mask, selector);
52 }
53 
54 static int max8925_get_voltage_sel(struct regulator_dev *rdev)
55 {
56 	struct max8925_regulator_info *info = rdev_get_drvdata(rdev);
57 	unsigned char data, mask;
58 	int ret;
59 
60 	ret = max8925_reg_read(info->i2c, info->vol_reg);
61 	if (ret < 0)
62 		return ret;
63 	mask = rdev->desc->n_voltages - 1;
64 	data = ret & mask;
65 
66 	return data;
67 }
68 
69 static int max8925_enable(struct regulator_dev *rdev)
70 {
71 	struct max8925_regulator_info *info = rdev_get_drvdata(rdev);
72 
73 	return max8925_set_bits(info->i2c, info->enable_reg,
74 				LDO_SEQ_MASK << LDO_SEQ_SHIFT |
75 				LDO_I2C_EN_MASK << LDO_I2C_EN_SHIFT,
76 				LDO_SEQ_I2C << LDO_SEQ_SHIFT |
77 				LDO_I2C_EN << LDO_I2C_EN_SHIFT);
78 }
79 
80 static int max8925_disable(struct regulator_dev *rdev)
81 {
82 	struct max8925_regulator_info *info = rdev_get_drvdata(rdev);
83 
84 	return max8925_set_bits(info->i2c, info->enable_reg,
85 				LDO_SEQ_MASK << LDO_SEQ_SHIFT |
86 				LDO_I2C_EN_MASK << LDO_I2C_EN_SHIFT,
87 				LDO_SEQ_I2C << LDO_SEQ_SHIFT);
88 }
89 
90 static int max8925_is_enabled(struct regulator_dev *rdev)
91 {
92 	struct max8925_regulator_info *info = rdev_get_drvdata(rdev);
93 	int ldo_seq, ret;
94 
95 	ret = max8925_reg_read(info->i2c, info->enable_reg);
96 	if (ret < 0)
97 		return ret;
98 	ldo_seq = (ret >> LDO_SEQ_SHIFT) & LDO_SEQ_MASK;
99 	if (ldo_seq != LDO_SEQ_I2C)
100 		return 1;
101 	else
102 		return ret & (LDO_I2C_EN_MASK << LDO_I2C_EN_SHIFT);
103 }
104 
105 static int max8925_set_dvm_voltage(struct regulator_dev *rdev, int uV)
106 {
107 	struct max8925_regulator_info *info = rdev_get_drvdata(rdev);
108 	unsigned char data, mask;
109 
110 	if (uV < SD1_DVM_VMIN || uV > SD1_DVM_VMAX)
111 		return -EINVAL;
112 
113 	data = DIV_ROUND_UP(uV - SD1_DVM_VMIN, SD1_DVM_STEP);
114 	data <<= SD1_DVM_SHIFT;
115 	mask = 3 << SD1_DVM_SHIFT;
116 
117 	return max8925_set_bits(info->i2c, info->enable_reg, mask, data);
118 }
119 
120 static int max8925_set_dvm_enable(struct regulator_dev *rdev)
121 {
122 	struct max8925_regulator_info *info = rdev_get_drvdata(rdev);
123 
124 	return max8925_set_bits(info->i2c, info->vol_reg, 1 << SD1_DVM_EN,
125 				1 << SD1_DVM_EN);
126 }
127 
128 static int max8925_set_dvm_disable(struct regulator_dev *rdev)
129 {
130 	struct max8925_regulator_info *info = rdev_get_drvdata(rdev);
131 
132 	return max8925_set_bits(info->i2c, info->vol_reg, 1 << SD1_DVM_EN, 0);
133 }
134 
135 static const struct regulator_ops max8925_regulator_sdv_ops = {
136 	.map_voltage		= regulator_map_voltage_linear,
137 	.list_voltage		= regulator_list_voltage_linear,
138 	.set_voltage_sel	= max8925_set_voltage_sel,
139 	.get_voltage_sel	= max8925_get_voltage_sel,
140 	.enable			= max8925_enable,
141 	.disable		= max8925_disable,
142 	.is_enabled		= max8925_is_enabled,
143 	.set_suspend_voltage	= max8925_set_dvm_voltage,
144 	.set_suspend_enable	= max8925_set_dvm_enable,
145 	.set_suspend_disable	= max8925_set_dvm_disable,
146 };
147 
148 static const struct regulator_ops max8925_regulator_ldo_ops = {
149 	.map_voltage		= regulator_map_voltage_linear,
150 	.list_voltage		= regulator_list_voltage_linear,
151 	.set_voltage_sel	= max8925_set_voltage_sel,
152 	.get_voltage_sel	= max8925_get_voltage_sel,
153 	.enable			= max8925_enable,
154 	.disable		= max8925_disable,
155 	.is_enabled		= max8925_is_enabled,
156 };
157 
158 #define MAX8925_SDV(_id, min, max, step)			\
159 {								\
160 	.desc	= {						\
161 		.name	= "SDV" #_id,				\
162 		.of_match = of_match_ptr("SDV" #_id),		\
163 		.regulators_node = of_match_ptr("regulators"),	\
164 		.ops	= &max8925_regulator_sdv_ops,		\
165 		.type	= REGULATOR_VOLTAGE,			\
166 		.id	= MAX8925_ID_SD##_id,			\
167 		.owner	= THIS_MODULE,				\
168 		.n_voltages = 64,				\
169 		.min_uV = min * 1000,				\
170 		.uV_step = step * 1000,				\
171 	},							\
172 	.vol_reg	= MAX8925_SDV##_id,			\
173 	.enable_reg	= MAX8925_SDCTL##_id,			\
174 }
175 
176 #define MAX8925_LDO(_id, min, max, step)			\
177 {								\
178 	.desc	= {						\
179 		.name	= "LDO" #_id,				\
180 		.of_match = of_match_ptr("LDO" #_id),		\
181 		.regulators_node = of_match_ptr("regulators"),	\
182 		.ops	= &max8925_regulator_ldo_ops,		\
183 		.type	= REGULATOR_VOLTAGE,			\
184 		.id	= MAX8925_ID_LDO##_id,			\
185 		.owner	= THIS_MODULE,				\
186 		.n_voltages = 64,				\
187 		.min_uV = min * 1000,				\
188 		.uV_step = step * 1000,				\
189 	},							\
190 	.vol_reg	= MAX8925_LDOVOUT##_id,			\
191 	.enable_reg	= MAX8925_LDOCTL##_id,			\
192 }
193 
194 static struct max8925_regulator_info max8925_regulator_info[] = {
195 	MAX8925_SDV(1, 637.5, 1425, 12.5),
196 	MAX8925_SDV(2,   650, 2225,   25),
197 	MAX8925_SDV(3,   750, 3900,   50),
198 
199 	MAX8925_LDO(1,  750, 3900, 50),
200 	MAX8925_LDO(2,  650, 2250, 25),
201 	MAX8925_LDO(3,  650, 2250, 25),
202 	MAX8925_LDO(4,  750, 3900, 50),
203 	MAX8925_LDO(5,  750, 3900, 50),
204 	MAX8925_LDO(6,  750, 3900, 50),
205 	MAX8925_LDO(7,  750, 3900, 50),
206 	MAX8925_LDO(8,  750, 3900, 50),
207 	MAX8925_LDO(9,  750, 3900, 50),
208 	MAX8925_LDO(10, 750, 3900, 50),
209 	MAX8925_LDO(11, 750, 3900, 50),
210 	MAX8925_LDO(12, 750, 3900, 50),
211 	MAX8925_LDO(13, 750, 3900, 50),
212 	MAX8925_LDO(14, 750, 3900, 50),
213 	MAX8925_LDO(15, 750, 3900, 50),
214 	MAX8925_LDO(16, 750, 3900, 50),
215 	MAX8925_LDO(17, 650, 2250, 25),
216 	MAX8925_LDO(18, 650, 2250, 25),
217 	MAX8925_LDO(19, 750, 3900, 50),
218 	MAX8925_LDO(20, 750, 3900, 50),
219 };
220 
221 static int max8925_regulator_probe(struct platform_device *pdev)
222 {
223 	struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
224 	struct regulator_init_data *pdata = dev_get_platdata(&pdev->dev);
225 	struct regulator_config config = { };
226 	struct max8925_regulator_info *ri;
227 	struct resource *res;
228 	struct regulator_dev *rdev;
229 	int i;
230 
231 	res = platform_get_resource(pdev, IORESOURCE_REG, 0);
232 	if (!res) {
233 		dev_err(&pdev->dev, "No REG resource!\n");
234 		return -EINVAL;
235 	}
236 	for (i = 0; i < ARRAY_SIZE(max8925_regulator_info); i++) {
237 		ri = &max8925_regulator_info[i];
238 		if (ri->vol_reg == res->start)
239 			break;
240 	}
241 
242 	if (i == ARRAY_SIZE(max8925_regulator_info)) {
243 		dev_err(&pdev->dev, "Failed to find regulator %llu\n",
244 			(unsigned long long)res->start);
245 		return -EINVAL;
246 	}
247 	ri->i2c = chip->i2c;
248 
249 	config.dev = chip->dev;
250 	config.driver_data = ri;
251 
252 	if (pdata)
253 		config.init_data = pdata;
254 
255 	rdev = devm_regulator_register(&pdev->dev, &ri->desc, &config);
256 	if (IS_ERR(rdev)) {
257 		dev_err(&pdev->dev, "failed to register regulator %s\n",
258 				ri->desc.name);
259 		return PTR_ERR(rdev);
260 	}
261 
262 	platform_set_drvdata(pdev, rdev);
263 	return 0;
264 }
265 
266 static struct platform_driver max8925_regulator_driver = {
267 	.driver		= {
268 		.name	= "max8925-regulator",
269 	},
270 	.probe		= max8925_regulator_probe,
271 };
272 
273 static int __init max8925_regulator_init(void)
274 {
275 	return platform_driver_register(&max8925_regulator_driver);
276 }
277 subsys_initcall(max8925_regulator_init);
278 
279 static void __exit max8925_regulator_exit(void)
280 {
281 	platform_driver_unregister(&max8925_regulator_driver);
282 }
283 module_exit(max8925_regulator_exit);
284 
285 MODULE_LICENSE("GPL");
286 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
287 MODULE_DESCRIPTION("Regulator Driver for Maxim 8925 PMIC");
288 MODULE_ALIAS("platform:max8925-regulator");
289