blob: d7da81a875cf612bf367d08f174f66f18aed4341 [file] [log] [blame]
Yunfan Zhang49d8c592012-09-08 03:52:18 -07001/*
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>
Heiko Stuebner91f23d82014-09-16 21:22:53 +020021#include <linux/regulator/of_regulator.h>
22#include <linux/of_device.h>
Yunfan Zhang49d8c592012-09-08 03:52:18 -070023#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
Heiko Stuebneree309282014-09-16 21:22:54 +020055enum fan53555_vendor {
56 FAN53555_VENDOR_FAIRCHILD = 0,
57 FAN53555_VENDOR_SILERGY,
58};
59
Yunfan Zhang49d8c592012-09-08 03:52:18 -070060/* 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,
Wadim Egorov5e39cf42016-04-20 10:01:07 +020068 FAN53555_CHIP_ID_08 = 8,
Yunfan Zhang49d8c592012-09-08 03:52:18 -070069};
70
Wadim Egorove57cbb72016-04-20 10:01:08 +020071/* IC mask revision */
72enum {
73 FAN53555_CHIP_REV_00 = 0x3,
74 FAN53555_CHIP_REV_13 = 0xf,
75};
76
Heiko Stuebneree309282014-09-16 21:22:54 +020077enum {
78 SILERGY_SYR82X = 8,
79};
80
Yunfan Zhang49d8c592012-09-08 03:52:18 -070081struct fan53555_device_info {
Heiko Stuebneree309282014-09-16 21:22:54 +020082 enum fan53555_vendor vendor;
Yunfan Zhang49d8c592012-09-08 03:52:18 -070083 struct regmap *regmap;
84 struct device *dev;
85 struct regulator_desc desc;
86 struct regulator_dev *rdev;
87 struct regulator_init_data *regulator;
88 /* IC Type and Rev */
89 int chip_id;
90 int chip_rev;
91 /* Voltage setting register */
92 unsigned int vol_reg;
93 unsigned int sleep_reg;
94 /* Voltage range and step(linear) */
95 unsigned int vsel_min;
Yunfan Zhang49d8c592012-09-08 03:52:18 -070096 unsigned int vsel_step;
97 /* Voltage slew rate limiting */
98 unsigned int slew_rate;
99 /* Sleep voltage cache */
100 unsigned int sleep_vol_cache;
101};
102
103static int fan53555_set_suspend_voltage(struct regulator_dev *rdev, int uV)
104{
105 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
106 int ret;
107
108 if (di->sleep_vol_cache == uV)
109 return 0;
110 ret = regulator_map_voltage_linear(rdev, uV, uV);
111 if (ret < 0)
Sachin Kamat145fe1e2014-02-18 16:11:04 +0530112 return ret;
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700113 ret = regmap_update_bits(di->regmap, di->sleep_reg,
114 VSEL_NSEL_MASK, ret);
115 if (ret < 0)
Sachin Kamat145fe1e2014-02-18 16:11:04 +0530116 return ret;
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700117 /* Cache the sleep voltage setting.
118 * Might not be the real voltage which is rounded */
119 di->sleep_vol_cache = uV;
120
121 return 0;
122}
123
zhangqingab7cad32016-01-12 03:05:56 -0800124static int fan53555_set_suspend_enable(struct regulator_dev *rdev)
125{
126 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
127
128 return regmap_update_bits(di->regmap, di->sleep_reg,
129 VSEL_BUCK_EN, VSEL_BUCK_EN);
130}
131
132static int fan53555_set_suspend_disable(struct regulator_dev *rdev)
133{
134 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
135
136 return regmap_update_bits(di->regmap, di->sleep_reg,
137 VSEL_BUCK_EN, 0);
138}
139
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700140static int fan53555_set_mode(struct regulator_dev *rdev, unsigned int mode)
141{
142 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
143
144 switch (mode) {
145 case REGULATOR_MODE_FAST:
146 regmap_update_bits(di->regmap, di->vol_reg,
147 VSEL_MODE, VSEL_MODE);
148 break;
149 case REGULATOR_MODE_NORMAL:
150 regmap_update_bits(di->regmap, di->vol_reg, VSEL_MODE, 0);
151 break;
152 default:
153 return -EINVAL;
154 }
155 return 0;
156}
157
158static unsigned int fan53555_get_mode(struct regulator_dev *rdev)
159{
160 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
161 unsigned int val;
162 int ret = 0;
163
164 ret = regmap_read(di->regmap, di->vol_reg, &val);
165 if (ret < 0)
166 return ret;
167 if (val & VSEL_MODE)
168 return REGULATOR_MODE_FAST;
169 else
170 return REGULATOR_MODE_NORMAL;
171}
172
Krzysztof Kozlowski121b5672015-01-05 10:04:19 +0100173static const int slew_rates[] = {
Heiko Stuebnerdd7e71f2014-09-16 17:54:01 +0200174 64000,
175 32000,
176 16000,
177 8000,
178 4000,
179 2000,
180 1000,
181 500,
182};
183
184static int fan53555_set_ramp(struct regulator_dev *rdev, int ramp)
185{
186 struct fan53555_device_info *di = rdev_get_drvdata(rdev);
187 int regval = -1, i;
188
189 for (i = 0; i < ARRAY_SIZE(slew_rates); i++) {
190 if (ramp <= slew_rates[i])
191 regval = i;
192 else
193 break;
194 }
195
196 if (regval < 0) {
197 dev_err(di->dev, "unsupported ramp value %d\n", ramp);
198 return -EINVAL;
199 }
200
201 return regmap_update_bits(di->regmap, FAN53555_CONTROL,
202 CTL_SLEW_MASK, regval << CTL_SLEW_SHIFT);
203}
204
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700205static struct regulator_ops fan53555_regulator_ops = {
206 .set_voltage_sel = regulator_set_voltage_sel_regmap,
207 .get_voltage_sel = regulator_get_voltage_sel_regmap,
Heiko Stuebnerfda87a42015-05-26 18:19:45 +0200208 .set_voltage_time_sel = regulator_set_voltage_time_sel,
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700209 .map_voltage = regulator_map_voltage_linear,
210 .list_voltage = regulator_list_voltage_linear,
211 .set_suspend_voltage = fan53555_set_suspend_voltage,
212 .enable = regulator_enable_regmap,
213 .disable = regulator_disable_regmap,
214 .is_enabled = regulator_is_enabled_regmap,
215 .set_mode = fan53555_set_mode,
216 .get_mode = fan53555_get_mode,
Heiko Stuebnerdd7e71f2014-09-16 17:54:01 +0200217 .set_ramp_delay = fan53555_set_ramp,
zhangqingab7cad32016-01-12 03:05:56 -0800218 .set_suspend_enable = fan53555_set_suspend_enable,
219 .set_suspend_disable = fan53555_set_suspend_disable,
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700220};
221
Heiko Stuebneree309282014-09-16 21:22:54 +0200222static int fan53555_voltages_setup_fairchild(struct fan53555_device_info *di)
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700223{
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700224 /* Init voltage range and step */
225 switch (di->chip_id) {
226 case FAN53555_CHIP_ID_00:
Wadim Egorove57cbb72016-04-20 10:01:08 +0200227 switch (di->chip_rev) {
228 case FAN53555_CHIP_REV_00:
229 di->vsel_min = 600000;
230 di->vsel_step = 10000;
231 break;
232 case FAN53555_CHIP_REV_13:
233 di->vsel_min = 800000;
234 di->vsel_step = 10000;
235 break;
236 default:
237 dev_err(di->dev,
238 "Chip ID %d with rev %d not supported!\n",
239 di->chip_id, di->chip_rev);
240 return -EINVAL;
241 }
242 break;
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700243 case FAN53555_CHIP_ID_01:
244 case FAN53555_CHIP_ID_03:
245 case FAN53555_CHIP_ID_05:
Wadim Egorov5e39cf42016-04-20 10:01:07 +0200246 case FAN53555_CHIP_ID_08:
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700247 di->vsel_min = 600000;
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700248 di->vsel_step = 10000;
249 break;
250 case FAN53555_CHIP_ID_04:
251 di->vsel_min = 603000;
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700252 di->vsel_step = 12826;
253 break;
254 default:
255 dev_err(di->dev,
Heiko Stuebneree309282014-09-16 21:22:54 +0200256 "Chip ID %d not supported!\n", di->chip_id);
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700257 return -EINVAL;
258 }
Heiko Stuebnerdd7e71f2014-09-16 17:54:01 +0200259
260 return 0;
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700261}
262
Heiko Stuebneree309282014-09-16 21:22:54 +0200263static int fan53555_voltages_setup_silergy(struct fan53555_device_info *di)
264{
265 /* Init voltage range and step */
266 switch (di->chip_id) {
267 case SILERGY_SYR82X:
268 di->vsel_min = 712500;
269 di->vsel_step = 12500;
270 break;
271 default:
272 dev_err(di->dev,
273 "Chip ID %d not supported!\n", di->chip_id);
274 return -EINVAL;
275 }
276
277 return 0;
278}
279
280/* For 00,01,03,05 options:
281 * VOUT = 0.60V + NSELx * 10mV, from 0.60 to 1.23V.
282 * For 04 option:
283 * VOUT = 0.603V + NSELx * 12.826mV, from 0.603 to 1.411V.
284 * */
285static int fan53555_device_setup(struct fan53555_device_info *di,
286 struct fan53555_platform_data *pdata)
287{
288 int ret = 0;
289
290 /* Setup voltage control register */
291 switch (pdata->sleep_vsel_id) {
292 case FAN53555_VSEL_ID_0:
293 di->sleep_reg = FAN53555_VSEL0;
294 di->vol_reg = FAN53555_VSEL1;
295 break;
296 case FAN53555_VSEL_ID_1:
297 di->sleep_reg = FAN53555_VSEL1;
298 di->vol_reg = FAN53555_VSEL0;
299 break;
300 default:
301 dev_err(di->dev, "Invalid VSEL ID!\n");
302 return -EINVAL;
303 }
304
305 switch (di->vendor) {
306 case FAN53555_VENDOR_FAIRCHILD:
307 ret = fan53555_voltages_setup_fairchild(di);
308 break;
309 case FAN53555_VENDOR_SILERGY:
310 ret = fan53555_voltages_setup_silergy(di);
311 break;
312 default:
Axel Linfe230532014-09-18 21:48:48 +0800313 dev_err(di->dev, "vendor %d not supported!\n", di->vendor);
Heiko Stuebneree309282014-09-16 21:22:54 +0200314 return -EINVAL;
315 }
316
317 return ret;
318}
319
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700320static int fan53555_regulator_register(struct fan53555_device_info *di,
321 struct regulator_config *config)
322{
323 struct regulator_desc *rdesc = &di->desc;
324
325 rdesc->name = "fan53555-reg";
Heiko Stuebner3415d602014-09-14 21:23:01 +0200326 rdesc->supply_name = "vin";
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700327 rdesc->ops = &fan53555_regulator_ops;
328 rdesc->type = REGULATOR_VOLTAGE;
329 rdesc->n_voltages = FAN53555_NVOLTAGES;
330 rdesc->enable_reg = di->vol_reg;
331 rdesc->enable_mask = VSEL_BUCK_EN;
332 rdesc->min_uV = di->vsel_min;
333 rdesc->uV_step = di->vsel_step;
334 rdesc->vsel_reg = di->vol_reg;
335 rdesc->vsel_mask = VSEL_NSEL_MASK;
336 rdesc->owner = THIS_MODULE;
337
Axel Linb15f5f72013-09-03 14:27:56 +0800338 di->rdev = devm_regulator_register(di->dev, &di->desc, config);
Rusty Russell8c6ffba2013-07-15 11:20:32 +0930339 return PTR_ERR_OR_ZERO(di->rdev);
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700340}
341
Krzysztof Kozlowski121b5672015-01-05 10:04:19 +0100342static const struct regmap_config fan53555_regmap_config = {
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700343 .reg_bits = 8,
344 .val_bits = 8,
345};
346
Heiko Stuebner91f23d82014-09-16 21:22:53 +0200347static struct fan53555_platform_data *fan53555_parse_dt(struct device *dev,
Javier Martinez Canillas072e78b2014-11-10 14:43:53 +0100348 struct device_node *np,
349 const struct regulator_desc *desc)
Heiko Stuebner91f23d82014-09-16 21:22:53 +0200350{
351 struct fan53555_platform_data *pdata;
352 int ret;
353 u32 tmp;
354
355 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
356 if (!pdata)
357 return NULL;
358
Javier Martinez Canillas072e78b2014-11-10 14:43:53 +0100359 pdata->regulator = of_get_regulator_init_data(dev, np, desc);
Heiko Stuebner91f23d82014-09-16 21:22:53 +0200360
361 ret = of_property_read_u32(np, "fcs,suspend-voltage-selector",
362 &tmp);
363 if (!ret)
364 pdata->sleep_vsel_id = tmp;
365
366 return pdata;
367}
368
369static const struct of_device_id fan53555_dt_ids[] = {
370 {
371 .compatible = "fcs,fan53555",
Heiko Stuebneree309282014-09-16 21:22:54 +0200372 .data = (void *)FAN53555_VENDOR_FAIRCHILD
373 }, {
374 .compatible = "silergy,syr827",
375 .data = (void *)FAN53555_VENDOR_SILERGY,
376 }, {
377 .compatible = "silergy,syr828",
378 .data = (void *)FAN53555_VENDOR_SILERGY,
Heiko Stuebner91f23d82014-09-16 21:22:53 +0200379 },
380 { }
381};
382MODULE_DEVICE_TABLE(of, fan53555_dt_ids);
383
Bill Pembertona5023572012-11-19 13:22:22 -0500384static int fan53555_regulator_probe(struct i2c_client *client,
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700385 const struct i2c_device_id *id)
386{
Heiko Stuebner91f23d82014-09-16 21:22:53 +0200387 struct device_node *np = client->dev.of_node;
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700388 struct fan53555_device_info *di;
389 struct fan53555_platform_data *pdata;
390 struct regulator_config config = { };
391 unsigned int val;
392 int ret;
393
Javier Martinez Canillas072e78b2014-11-10 14:43:53 +0100394 di = devm_kzalloc(&client->dev, sizeof(struct fan53555_device_info),
395 GFP_KERNEL);
396 if (!di)
397 return -ENOMEM;
398
Jingoo Handff91d02013-07-30 17:20:47 +0900399 pdata = dev_get_platdata(&client->dev);
Heiko Stuebner91f23d82014-09-16 21:22:53 +0200400 if (!pdata)
Javier Martinez Canillas072e78b2014-11-10 14:43:53 +0100401 pdata = fan53555_parse_dt(&client->dev, np, &di->desc);
Heiko Stuebner91f23d82014-09-16 21:22:53 +0200402
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700403 if (!pdata || !pdata->regulator) {
404 dev_err(&client->dev, "Platform data not found!\n");
405 return -ENODEV;
406 }
407
Axel Line13426b2014-09-18 21:49:38 +0800408 di->regulator = pdata->regulator;
Heiko Stuebneree309282014-09-16 21:22:54 +0200409 if (client->dev.of_node) {
410 const struct of_device_id *match;
411
412 match = of_match_device(of_match_ptr(fan53555_dt_ids),
413 &client->dev);
414 if (!match)
415 return -ENODEV;
416
Heiko Stübner6f341632014-09-17 13:21:48 +0200417 di->vendor = (unsigned long) match->data;
Heiko Stuebneree309282014-09-16 21:22:54 +0200418 } else {
Heiko Stuebner91f23d82014-09-16 21:22:53 +0200419 /* if no ramp constraint set, get the pdata ramp_delay */
420 if (!di->regulator->constraints.ramp_delay) {
421 int slew_idx = (pdata->slew_rate & 0x7)
422 ? pdata->slew_rate : 0;
Heiko Stuebnerdd7e71f2014-09-16 17:54:01 +0200423
Heiko Stuebner91f23d82014-09-16 21:22:53 +0200424 di->regulator->constraints.ramp_delay
425 = slew_rates[slew_idx];
426 }
Heiko Stuebneree309282014-09-16 21:22:54 +0200427
428 di->vendor = id->driver_data;
Heiko Stuebnerdd7e71f2014-09-16 17:54:01 +0200429 }
430
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700431 di->regmap = devm_regmap_init_i2c(client, &fan53555_regmap_config);
432 if (IS_ERR(di->regmap)) {
433 dev_err(&client->dev, "Failed to allocate regmap!\n");
434 return PTR_ERR(di->regmap);
435 }
436 di->dev = &client->dev;
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700437 i2c_set_clientdata(client, di);
438 /* Get chip ID */
439 ret = regmap_read(di->regmap, FAN53555_ID1, &val);
440 if (ret < 0) {
441 dev_err(&client->dev, "Failed to get chip ID!\n");
Sachin Kamat145fe1e2014-02-18 16:11:04 +0530442 return ret;
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700443 }
444 di->chip_id = val & DIE_ID;
445 /* Get chip revision */
446 ret = regmap_read(di->regmap, FAN53555_ID2, &val);
447 if (ret < 0) {
448 dev_err(&client->dev, "Failed to get chip Rev!\n");
Sachin Kamat145fe1e2014-02-18 16:11:04 +0530449 return ret;
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700450 }
451 di->chip_rev = val & DIE_REV;
452 dev_info(&client->dev, "FAN53555 Option[%d] Rev[%d] Detected!\n",
453 di->chip_id, di->chip_rev);
454 /* Device init */
455 ret = fan53555_device_setup(di, pdata);
456 if (ret < 0) {
457 dev_err(&client->dev, "Failed to setup device!\n");
458 return ret;
459 }
460 /* Register regulator */
461 config.dev = di->dev;
462 config.init_data = di->regulator;
463 config.regmap = di->regmap;
464 config.driver_data = di;
Heiko Stuebner91f23d82014-09-16 21:22:53 +0200465 config.of_node = np;
466
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700467 ret = fan53555_regulator_register(di, &config);
468 if (ret < 0)
469 dev_err(&client->dev, "Failed to register regulator!\n");
470 return ret;
471
472}
473
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700474static const struct i2c_device_id fan53555_id[] = {
Heiko Stuebneree309282014-09-16 21:22:54 +0200475 {
476 .name = "fan53555",
477 .driver_data = FAN53555_VENDOR_FAIRCHILD
478 }, {
479 .name = "syr82x",
480 .driver_data = FAN53555_VENDOR_SILERGY
481 },
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700482 { },
483};
Javier Martinez Canillase80c47b2015-07-30 18:18:40 +0200484MODULE_DEVICE_TABLE(i2c, fan53555_id);
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700485
486static struct i2c_driver fan53555_regulator_driver = {
487 .driver = {
488 .name = "fan53555-regulator",
Heiko Stuebner91f23d82014-09-16 21:22:53 +0200489 .of_match_table = of_match_ptr(fan53555_dt_ids),
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700490 },
491 .probe = fan53555_regulator_probe,
Yunfan Zhang49d8c592012-09-08 03:52:18 -0700492 .id_table = fan53555_id,
493};
494
495module_i2c_driver(fan53555_regulator_driver);
496
497MODULE_AUTHOR("Yunfan Zhang <yfzhang@marvell.com>");
498MODULE_DESCRIPTION("FAN53555 regulator driver");
499MODULE_LICENSE("GPL v2");