1 /*
2 * Regulator driver for syr82x DCDC chip for rk32xx
3 *
4 * Copyright (C) 2010, 2011 ROCKCHIP, Inc.
5
6 * Based on syr82x.c that is work by zhangqing<zhangqing@rock-chips.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 *
12 */
13
14 #include <linux/bug.h>
15 #include <linux/err.h>
16 #include <linux/i2c.h>
17 #include <linux/kernel.h>
18 #include <linux/regulator/driver.h>
19 #include <linux/delay.h>
20 #include <linux/slab.h>
21 #include <linux/mutex.h>
22 #include <linux/mfd/core.h>
23
24 #include <linux/interrupt.h>
25 #include <linux/module.h>
26 #include <linux/of_irq.h>
27 #include <linux/of_gpio.h>
28 #include <linux/of.h>
29 #include <linux/of_device.h>
30 #include <linux/regulator/of_regulator.h>
31 #include <linux/regulator/driver.h>
32 #include <linux/regulator/machine.h>
33 #include <linux/regmap.h>
34
35 #define syr82x_NUM_REGULATORS 1
36
37 struct syr82x {
38 struct device *dev;
39 struct mutex io_lock;
40 struct i2c_client *i2c;
41 int num_regulators;
42 struct regulator_dev **rdev;
43 int irq_base;
44 int chip_irq;
45 int sleep_gpio; /* */
46 unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
47 bool pmic_sleep;
48 struct regmap *regmap;
49 };
50
51 struct syr82x_regulator {
52 struct device *dev;
53 struct regulator_desc *desc;
54 struct regulator_dev *rdev;
55 };
56 struct syr82x_board {
57 int irq;
58 int irq_base;
59 struct regulator_init_data *syr82x_init_data[syr82x_NUM_REGULATORS];
60 struct device_node *of_node[syr82x_NUM_REGULATORS];
61 int sleep_gpio; /* */
62 unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
63 bool sleep;
64 };
65
66 struct syr82x_regulator_subdev {
67 int id;
68 struct regulator_init_data *initdata;
69 struct device_node *reg_node;
70 };
71
72 struct syr82x_platform_data {
73 int ono;
74 int num_regulators;
75 struct syr82x_regulator_subdev *regulators;
76
77 int sleep_gpio; /* */
78 unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
79 bool sleep;
80 };
81 struct syr82x *g_syr82x;
82
83 #define SYR82X_BUCK1_SET_VOL_BASE 0x00
84 #define SYR82X_BUCK1_SLP_VOL_BASE 0x01
85 #define SYR82X_CONTR_REG1 0x02
86 #define SYR82X_ID1_REG 0x03
87 #define SYR82X_ID2_REG 0x04
88 #define SYR82X_CONTR_REG2 0x05
89
90 #define BUCK_VOL_MASK 0x3f
91 #define VOL_MIN_IDX 0x00
92 #define VOL_MAX_IDX 0x3f
93
94 struct syr82x_reg_data {
95 int addr;
96 int mask;
97 int value;
98 };
99
100 static const struct regmap_config syr82x_regmap_config = {
101 .reg_bits = 8,
102 .val_bits = 8,
103 .max_register = SYR82X_CONTR_REG2,
104 .cache_type = REGCACHE_RBTREE,
105 };
106
107 const static int buck_voltage_map[] = {
108 712500, 725000, 737500,750000, 762500,775000,787500,800000,
109 812500, 825000, 837500,850000, 862500,875000,887500,900000,
110 912500, 925000, 937500,950000, 962500,975000,987500,1000000,
111 1012500, 1025000, 1037500,1050000, 1062500,1075000,1087500,1100000,
112 1112500, 1125000, 1137500,1150000, 1162500,1175000,1187500,1200000,
113 1212500, 1225000, 1237500,1250000, 1262500,1275000,1287500,1300000,
114 1312500, 1325000, 1337500,1350000, 1362500,1375000,1387500,1400000,
115 1412500, 1425000, 1437500,1450000, 1462500,1475000,1487500,1500000,
116 };
117
syr82x_dcdc_list_voltage(struct regulator_dev * dev,unsigned index)118 static int syr82x_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
119 {
120 if (index >= ARRAY_SIZE(buck_voltage_map))
121 return -EINVAL;
122 return buck_voltage_map[index];
123 }
syr82x_dcdc_is_enabled(struct regulator_dev * dev)124 static int syr82x_dcdc_is_enabled(struct regulator_dev *dev)
125 {
126 struct syr82x *syr82x = rdev_get_drvdata(dev);
127 unsigned int val;
128 u16 mask = 0x80;
129 int ret = 0;
130
131 ret = regmap_read(syr82x->regmap, SYR82X_BUCK1_SET_VOL_BASE, &val);
132 if (ret != 0)
133 return ret;
134
135 val &= (~0x7f);
136 if (val & mask)
137 return 1;
138 else
139 return 0;
140 }
syr82x_dcdc_enable(struct regulator_dev * dev)141 static int syr82x_dcdc_enable(struct regulator_dev *dev)
142 {
143 struct syr82x *syr82x = rdev_get_drvdata(dev);
144 u16 mask = 0x80;
145 int ret = 0;
146
147 ret = regmap_update_bits(syr82x->regmap,
148 SYR82X_BUCK1_SET_VOL_BASE,
149 mask, 0x80);
150 return ret;
151 }
syr82x_dcdc_disable(struct regulator_dev * dev)152 static int syr82x_dcdc_disable(struct regulator_dev *dev)
153 {
154 struct syr82x *syr82x = rdev_get_drvdata(dev);
155 u16 mask = 0x80;
156 int ret = 0;
157
158 ret = regmap_update_bits(syr82x->regmap,
159 SYR82X_BUCK1_SET_VOL_BASE,
160 mask, 0);
161 return ret;
162 }
syr82x_dcdc_get_voltage(struct regulator_dev * dev)163 static int syr82x_dcdc_get_voltage(struct regulator_dev *dev)
164 {
165 struct syr82x *syr82x = rdev_get_drvdata(dev);
166 unsigned int reg;
167 int val;
168 int ret = 0;
169
170 ret = regmap_read(syr82x->regmap, SYR82X_BUCK1_SET_VOL_BASE, ®);
171 if (ret != 0)
172 return ret;
173
174 reg &= BUCK_VOL_MASK;
175 val = buck_voltage_map[reg];
176
177 return val;
178 }
syr82x_dcdc_set_voltage(struct regulator_dev * dev,int min_uV,int max_uV,unsigned * selector)179 static int syr82x_dcdc_set_voltage(struct regulator_dev *dev,
180 int min_uV, int max_uV,unsigned *selector)
181 {
182 struct syr82x *syr82x = rdev_get_drvdata(dev);
183 const int *vol_map = buck_voltage_map;
184 u16 val;
185 int ret = 0;
186
187 if (min_uV < vol_map[VOL_MIN_IDX] ||
188 min_uV > vol_map[VOL_MAX_IDX])
189 return -EINVAL;
190
191 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
192 if (vol_map[val] >= min_uV)
193 break;
194 }
195
196 if (vol_map[val] > max_uV)
197 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
198
199 ret = regmap_update_bits(syr82x->regmap,
200 SYR82X_BUCK1_SET_VOL_BASE,
201 BUCK_VOL_MASK, val);
202 if (ret != 0)
203 printk("###################WARNING:set voltage is error!voltage set is %d mv %d\n",vol_map[val],ret);
204
205 return ret;
206 }
207
syr82x_dcdc_get_mode(struct regulator_dev * dev)208 static unsigned int syr82x_dcdc_get_mode(struct regulator_dev *dev)
209 {
210 struct syr82x *syr82x = rdev_get_drvdata(dev);
211 u16 mask = 0x40;
212 unsigned int val;
213 int ret = 0;
214
215 ret = regmap_read(syr82x->regmap, SYR82X_BUCK1_SET_VOL_BASE, &val);
216 if (ret != 0)
217 return ret;
218
219 val &= mask;
220 if (val == mask)
221 return REGULATOR_MODE_FAST;
222 else
223 return REGULATOR_MODE_NORMAL;
224
225 }
syr82x_dcdc_set_mode(struct regulator_dev * dev,unsigned int mode)226 static int syr82x_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
227 {
228 struct syr82x *syr82x = rdev_get_drvdata(dev);
229 u16 mask = 0x40;
230
231 switch(mode)
232 {
233 case REGULATOR_MODE_FAST:
234 return regmap_update_bits(syr82x->regmap,
235 SYR82X_BUCK1_SET_VOL_BASE,
236 mask, mask);
237 case REGULATOR_MODE_NORMAL:
238 return regmap_update_bits(syr82x->regmap,
239 SYR82X_BUCK1_SET_VOL_BASE,
240 mask, 0);
241 default:
242 printk("error:dcdc_syr82x only auto and pwm mode\n");
243 return -EINVAL;
244 }
245 }
syr82x_dcdc_set_voltage_time_sel(struct regulator_dev * dev,unsigned int old_selector,unsigned int new_selector)246 static int syr82x_dcdc_set_voltage_time_sel(struct regulator_dev *dev, unsigned int old_selector,
247 unsigned int new_selector)
248 {
249 int old_volt, new_volt;
250
251 old_volt = syr82x_dcdc_list_voltage(dev, old_selector);
252 if (old_volt < 0)
253 return old_volt;
254
255 new_volt = syr82x_dcdc_list_voltage(dev, new_selector);
256 if (new_volt < 0)
257 return new_volt;
258
259 return DIV_ROUND_UP(abs(old_volt - new_volt)*4, 10000);
260 }
syr82x_dcdc_suspend_enable(struct regulator_dev * dev)261 static int syr82x_dcdc_suspend_enable(struct regulator_dev *dev)
262 {
263 struct syr82x *syr82x = rdev_get_drvdata(dev);
264 u16 mask = 0x80;
265
266 return regmap_update_bits(syr82x->regmap,
267 SYR82X_BUCK1_SLP_VOL_BASE,
268 mask, 0x80);
269 }
syr82x_dcdc_suspend_disable(struct regulator_dev * dev)270 static int syr82x_dcdc_suspend_disable(struct regulator_dev *dev)
271 {
272 struct syr82x *syr82x = rdev_get_drvdata(dev);
273 u16 mask=0x80;
274
275 return regmap_update_bits(syr82x->regmap,
276 SYR82X_BUCK1_SLP_VOL_BASE,
277 mask, 0);
278 }
syr82x_dcdc_set_sleep_voltage(struct regulator_dev * dev,int uV)279 static int syr82x_dcdc_set_sleep_voltage(struct regulator_dev *dev,
280 int uV)
281 {
282 struct syr82x *syr82x = rdev_get_drvdata(dev);
283 const int *vol_map = buck_voltage_map;
284 u16 val;
285 int ret = 0;
286
287 if (uV < vol_map[VOL_MIN_IDX] ||
288 uV > vol_map[VOL_MAX_IDX])
289 return -EINVAL;
290
291 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
292 if (vol_map[val] >= uV)
293 break;
294 }
295
296 if (vol_map[val] > uV)
297 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
298
299 ret = regmap_update_bits(syr82x->regmap,
300 SYR82X_BUCK1_SLP_VOL_BASE,
301 BUCK_VOL_MASK, val);
302 return ret;
303 }
304
305
syr82x_dcdc_set_suspend_mode(struct regulator_dev * dev,unsigned int mode)306 static int syr82x_dcdc_set_suspend_mode(struct regulator_dev *dev, unsigned int mode)
307 {
308 struct syr82x *syr82x = rdev_get_drvdata(dev);
309 u16 mask = 0x40;
310
311 switch(mode)
312 {
313 case REGULATOR_MODE_FAST:
314 return regmap_update_bits(syr82x->regmap,
315 SYR82X_BUCK1_SLP_VOL_BASE,
316 mask, mask);
317 case REGULATOR_MODE_NORMAL:
318 return regmap_update_bits(syr82x->regmap,
319 SYR82X_BUCK1_SLP_VOL_BASE,
320 mask, 0);
321 default:
322 printk("error:dcdc_syr82x only auto and pwm mode\n");
323 return -EINVAL;
324 }
325 }
326
327 static struct regulator_ops syr82x_dcdc_ops = {
328 .set_voltage = syr82x_dcdc_set_voltage,
329 .get_voltage = syr82x_dcdc_get_voltage,
330 .list_voltage= syr82x_dcdc_list_voltage,
331 .is_enabled = syr82x_dcdc_is_enabled,
332 .enable = syr82x_dcdc_enable,
333 .disable = syr82x_dcdc_disable,
334 .get_mode = syr82x_dcdc_get_mode,
335 .set_mode = syr82x_dcdc_set_mode,
336 .set_suspend_voltage = syr82x_dcdc_set_sleep_voltage,
337 .set_suspend_enable = syr82x_dcdc_suspend_enable,
338 .set_suspend_disable = syr82x_dcdc_suspend_disable,
339 .set_suspend_mode = syr82x_dcdc_set_suspend_mode,
340 .set_voltage_time_sel = syr82x_dcdc_set_voltage_time_sel,
341 };
342 static struct regulator_desc regulators[] = {
343
344 {
345 .name = "SY_DCDC1",
346 .id = 0,
347 .ops = &syr82x_dcdc_ops,
348 .n_voltages = ARRAY_SIZE(buck_voltage_map),
349 .type = REGULATOR_VOLTAGE,
350 .owner = THIS_MODULE,
351 },
352 };
353
354 static struct of_device_id syr82x_of_match[] = {
355 { .compatible = "silergy,syr82x"},
356 { },
357 };
358 MODULE_DEVICE_TABLE(of, syr82x_of_match);
359
360 static struct of_regulator_match syr82x_reg_matches[] = {
361 { .name = "syr82x_dcdc1" ,.driver_data = (void *)0},
362 };
363
syr82x_parse_dt(struct syr82x * syr82x)364 static struct syr82x_board *syr82x_parse_dt(struct syr82x *syr82x)
365 {
366 struct syr82x_board *pdata;
367 struct device_node *regs;
368 struct device_node *syr82x_np;
369 int count;
370
371 syr82x_np = of_node_get(syr82x->dev->of_node);
372 if (!syr82x_np) {
373 printk("could not find pmic sub-node\n");
374 return NULL;
375 }
376
377 regs = of_find_node_by_name(syr82x_np, "regulators");
378 if (!regs)
379 return NULL;
380 count = of_regulator_match(syr82x->dev, regs, syr82x_reg_matches,
381 syr82x_NUM_REGULATORS);
382 of_node_put(regs);
383 pdata = devm_kzalloc(syr82x->dev, sizeof(*pdata), GFP_KERNEL);
384 if (!pdata)
385 return NULL;
386 pdata->syr82x_init_data[0] = syr82x_reg_matches[0].init_data;
387 pdata->of_node[0] = syr82x_reg_matches[0].of_node;
388
389 return pdata;
390 }
391
syr82x_i2c_probe(struct i2c_client * i2c,const struct i2c_device_id * id)392 static int syr82x_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
393 {
394 struct syr82x *syr82x;
395 struct syr82x_board *pdev ;
396 const struct of_device_id *match;
397 struct regulator_config config = { };
398 struct regulator_dev *sy_rdev;
399 struct regulator_init_data *reg_data;
400 const char *rail_name = NULL;
401 int ret;
402 unsigned int val;
403
404 if (i2c->dev.of_node) {
405 match = of_match_device(syr82x_of_match, &i2c->dev);
406 if (!match) {
407 printk("Failed to find matching dt id\n");
408 return -EINVAL;
409 }
410 }
411
412 syr82x = devm_kzalloc(&i2c->dev,sizeof(struct syr82x), GFP_KERNEL);
413 if (syr82x == NULL) {
414 ret = -ENOMEM;
415 goto err;
416 }
417
418 syr82x->regmap = devm_regmap_init_i2c(i2c, &syr82x_regmap_config);
419 if (IS_ERR(syr82x->regmap)) {
420 dev_err(&i2c->dev, "regmap initialization failed\n");
421 return PTR_ERR(syr82x->regmap);
422 }
423 syr82x->i2c = i2c;
424 syr82x->dev = &i2c->dev;
425 i2c_set_clientdata(i2c, syr82x);
426 g_syr82x = syr82x;
427
428 mutex_init(&syr82x->io_lock);
429 ret = regmap_read(syr82x->regmap, SYR82X_ID1_REG, &val);
430 if ((ret < 0) || (val == 0xff) || (val == 0)) {
431 dev_err(&i2c->dev, "The device is not syr82x\n");
432 goto err;
433 }
434 ret = regmap_update_bits(syr82x->regmap,
435 SYR82X_CONTR_REG1,
436 (1 << 6), (1 << 6));
437
438 if (syr82x->dev->of_node)
439 pdev = syr82x_parse_dt(syr82x);
440
441 if (pdev) {
442 syr82x->num_regulators = syr82x_NUM_REGULATORS;
443 syr82x->rdev = kcalloc(syr82x_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
444 if (!syr82x->rdev) {
445 return -ENOMEM;
446 }
447 /* Instantiate the regulators */
448 reg_data = pdev->syr82x_init_data[0];
449 config.dev = syr82x->dev;
450 config.driver_data = syr82x;
451 if (syr82x->dev->of_node)
452 config.of_node = pdev->of_node[0];
453 if (reg_data && reg_data->constraints.name)
454 rail_name = reg_data->constraints.name;
455 else
456 rail_name = regulators[0].name;
457 reg_data->supply_regulator = rail_name;
458
459 config.init_data =reg_data;
460 sy_rdev = regulator_register(®ulators[0],&config);
461 if (IS_ERR(sy_rdev)) {
462 printk("failed to register regulator\n");
463 goto err;
464 }
465 syr82x->rdev[0] = sy_rdev;
466 }
467 return 0;
468 err:
469 return ret;
470
471 }
472
syr82x_i2c_remove(struct i2c_client * i2c)473 static int syr82x_i2c_remove(struct i2c_client *i2c)
474 {
475 struct syr82x *syr82x = i2c_get_clientdata(i2c);
476
477 if (syr82x->rdev[0])
478 regulator_unregister(syr82x->rdev[0]);
479 i2c_set_clientdata(i2c, NULL);
480 return 0;
481 }
482
483 static const struct i2c_device_id syr82x_i2c_id[] = {
484 { "syr82x", 0 },
485 { }
486 };
487
488 MODULE_DEVICE_TABLE(i2c, syr82x_i2c_id);
489
490 static struct i2c_driver syr82x_i2c_driver = {
491 .driver = {
492 .name = "syr82x",
493 .owner = THIS_MODULE,
494 .of_match_table =of_match_ptr(syr82x_of_match),
495 },
496 .probe = syr82x_i2c_probe,
497 .remove = syr82x_i2c_remove,
498 .id_table = syr82x_i2c_id,
499 };
500
syr82x_module_init(void)501 static int __init syr82x_module_init(void)
502 {
503 int ret;
504 ret = i2c_add_driver(&syr82x_i2c_driver);
505 if (ret != 0)
506 pr_err("Failed to register I2C driver: %d\n", ret);
507 return ret;
508 }
509 subsys_initcall_sync(syr82x_module_init);
510
syr82x_module_exit(void)511 static void __exit syr82x_module_exit(void)
512 {
513 i2c_del_driver(&syr82x_i2c_driver);
514 }
515 module_exit(syr82x_module_exit);
516
517 MODULE_LICENSE("GPL");
518 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
519 MODULE_DESCRIPTION("syr82x PMIC driver");
520
521