Loading...
Note: File does not exist in v3.5.6.
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");