2 * Regulator driver for syr82x DCDC chip for rk32xx
4 * Copyright (C) 2010, 2011 ROCKCHIP, Inc.
6 * Based on syr82x.c that is work by zhangqing<zhangqing@rock-chips.com>
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.
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>
24 #include <linux/interrupt.h>
25 #include <linux/module.h>
26 #include <linux/of_irq.h>
27 #include <linux/of_gpio.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>
35 #define syr82x_NUM_REGULATORS 1
40 struct i2c_client *i2c;
42 struct regulator_dev **rdev;
46 unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
48 struct regmap *regmap;
51 struct syr82x_regulator {
53 struct regulator_desc *desc;
54 struct regulator_dev *rdev;
59 struct regulator_init_data *syr82x_init_data[syr82x_NUM_REGULATORS];
60 struct device_node *of_node[syr82x_NUM_REGULATORS];
62 unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
66 struct syr82x_regulator_subdev {
68 struct regulator_init_data *initdata;
69 struct device_node *reg_node;
72 struct syr82x_platform_data {
75 struct syr82x_regulator_subdev *regulators;
78 unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
81 struct syr82x *g_syr82x;
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
90 #define BUCK_VOL_MASK 0x3f
91 #define VOL_MIN_IDX 0x00
92 #define VOL_MAX_IDX 0x3f
94 struct syr82x_reg_data {
100 static const struct regmap_config syr82x_regmap_config = {
103 .max_register = SYR82X_CONTR_REG2,
104 .cache_type = REGCACHE_RBTREE,
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,
118 static int syr82x_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
120 if (index >= ARRAY_SIZE(buck_voltage_map))
122 return buck_voltage_map[index];
124 static int syr82x_dcdc_is_enabled(struct regulator_dev *dev)
126 struct syr82x *syr82x = rdev_get_drvdata(dev);
131 ret = regmap_read(syr82x->regmap, SYR82X_BUCK1_SET_VOL_BASE, &val);
141 static int syr82x_dcdc_enable(struct regulator_dev *dev)
143 struct syr82x *syr82x = rdev_get_drvdata(dev);
147 ret = regmap_update_bits(syr82x->regmap,
148 SYR82X_BUCK1_SET_VOL_BASE,
152 static int syr82x_dcdc_disable(struct regulator_dev *dev)
154 struct syr82x *syr82x = rdev_get_drvdata(dev);
158 ret = regmap_update_bits(syr82x->regmap,
159 SYR82X_BUCK1_SET_VOL_BASE,
163 static int syr82x_dcdc_get_voltage(struct regulator_dev *dev)
165 struct syr82x *syr82x = rdev_get_drvdata(dev);
170 ret = regmap_read(syr82x->regmap, SYR82X_BUCK1_SET_VOL_BASE, ®);
174 reg &= BUCK_VOL_MASK;
175 val = buck_voltage_map[reg];
179 static int syr82x_dcdc_set_voltage(struct regulator_dev *dev,
180 int min_uV, int max_uV,unsigned *selector)
182 struct syr82x *syr82x = rdev_get_drvdata(dev);
183 const int *vol_map = buck_voltage_map;
187 if (min_uV < vol_map[VOL_MIN_IDX] ||
188 min_uV > vol_map[VOL_MAX_IDX])
191 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
192 if (vol_map[val] >= min_uV)
196 if (vol_map[val] > max_uV)
197 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
199 ret = regmap_update_bits(syr82x->regmap,
200 SYR82X_BUCK1_SET_VOL_BASE,
203 printk("###################WARNING:set voltage is error!voltage set is %d mv %d\n",vol_map[val],ret);
208 static unsigned int syr82x_dcdc_get_mode(struct regulator_dev *dev)
210 struct syr82x *syr82x = rdev_get_drvdata(dev);
215 ret = regmap_read(syr82x->regmap, SYR82X_BUCK1_SET_VOL_BASE, &val);
221 return REGULATOR_MODE_FAST;
223 return REGULATOR_MODE_NORMAL;
226 static int syr82x_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
228 struct syr82x *syr82x = rdev_get_drvdata(dev);
233 case REGULATOR_MODE_FAST:
234 return regmap_update_bits(syr82x->regmap,
235 SYR82X_BUCK1_SET_VOL_BASE,
237 case REGULATOR_MODE_NORMAL:
238 return regmap_update_bits(syr82x->regmap,
239 SYR82X_BUCK1_SET_VOL_BASE,
242 printk("error:dcdc_syr82x only auto and pwm mode\n");
246 static int syr82x_dcdc_set_voltage_time_sel(struct regulator_dev *dev, unsigned int old_selector,
247 unsigned int new_selector)
249 int old_volt, new_volt;
251 old_volt = syr82x_dcdc_list_voltage(dev, old_selector);
255 new_volt = syr82x_dcdc_list_voltage(dev, new_selector);
259 return DIV_ROUND_UP(abs(old_volt - new_volt)*4, 10000);
261 static int syr82x_dcdc_suspend_enable(struct regulator_dev *dev)
263 struct syr82x *syr82x = rdev_get_drvdata(dev);
266 return regmap_update_bits(syr82x->regmap,
267 SYR82X_BUCK1_SLP_VOL_BASE,
270 static int syr82x_dcdc_suspend_disable(struct regulator_dev *dev)
272 struct syr82x *syr82x = rdev_get_drvdata(dev);
275 return regmap_update_bits(syr82x->regmap,
276 SYR82X_BUCK1_SLP_VOL_BASE,
279 static int syr82x_dcdc_set_sleep_voltage(struct regulator_dev *dev,
282 struct syr82x *syr82x = rdev_get_drvdata(dev);
283 const int *vol_map = buck_voltage_map;
287 if (uV < vol_map[VOL_MIN_IDX] ||
288 uV > vol_map[VOL_MAX_IDX])
291 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++){
292 if (vol_map[val] >= uV)
296 if (vol_map[val] > uV)
297 printk("WARNING:this voltage is not support!voltage set is %d mv\n",vol_map[val]);
299 ret = regmap_update_bits(syr82x->regmap,
300 SYR82X_BUCK1_SLP_VOL_BASE,
306 static int syr82x_dcdc_set_suspend_mode(struct regulator_dev *dev, unsigned int mode)
308 struct syr82x *syr82x = rdev_get_drvdata(dev);
313 case REGULATOR_MODE_FAST:
314 return regmap_update_bits(syr82x->regmap,
315 SYR82X_BUCK1_SLP_VOL_BASE,
317 case REGULATOR_MODE_NORMAL:
318 return regmap_update_bits(syr82x->regmap,
319 SYR82X_BUCK1_SLP_VOL_BASE,
322 printk("error:dcdc_syr82x only auto and pwm mode\n");
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,
342 static struct regulator_desc regulators[] = {
347 .ops = &syr82x_dcdc_ops,
348 .n_voltages = ARRAY_SIZE(buck_voltage_map),
349 .type = REGULATOR_VOLTAGE,
350 .owner = THIS_MODULE,
354 static struct of_device_id syr82x_of_match[] = {
355 { .compatible = "silergy,syr82x"},
358 MODULE_DEVICE_TABLE(of, syr82x_of_match);
360 static struct of_regulator_match syr82x_reg_matches[] = {
361 { .name = "syr82x_dcdc1" ,.driver_data = (void *)0},
364 static struct syr82x_board *syr82x_parse_dt(struct syr82x *syr82x)
366 struct syr82x_board *pdata;
367 struct device_node *regs;
368 struct device_node *syr82x_np;
371 syr82x_np = of_node_get(syr82x->dev->of_node);
373 printk("could not find pmic sub-node\n");
377 regs = of_find_node_by_name(syr82x_np, "regulators");
380 count = of_regulator_match(syr82x->dev, regs, syr82x_reg_matches,
381 syr82x_NUM_REGULATORS);
383 pdata = devm_kzalloc(syr82x->dev, sizeof(*pdata), GFP_KERNEL);
386 pdata->syr82x_init_data[0] = syr82x_reg_matches[0].init_data;
387 pdata->of_node[0] = syr82x_reg_matches[0].of_node;
392 static int syr82x_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
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;
404 if (i2c->dev.of_node) {
405 match = of_match_device(syr82x_of_match, &i2c->dev);
407 printk("Failed to find matching dt id\n");
412 syr82x = devm_kzalloc(&i2c->dev,sizeof(struct syr82x), GFP_KERNEL);
413 if (syr82x == NULL) {
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);
424 syr82x->dev = &i2c->dev;
425 i2c_set_clientdata(i2c, syr82x);
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");
434 ret = regmap_update_bits(syr82x->regmap,
438 if (syr82x->dev->of_node)
439 pdev = syr82x_parse_dt(syr82x);
442 syr82x->num_regulators = syr82x_NUM_REGULATORS;
443 syr82x->rdev = kcalloc(syr82x_NUM_REGULATORS,sizeof(struct regulator_dev *), GFP_KERNEL);
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;
456 rail_name = regulators[0].name;
457 reg_data->supply_regulator = rail_name;
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");
465 syr82x->rdev[0] = sy_rdev;
473 static int syr82x_i2c_remove(struct i2c_client *i2c)
475 struct syr82x *syr82x = i2c_get_clientdata(i2c);
478 regulator_unregister(syr82x->rdev[0]);
479 i2c_set_clientdata(i2c, NULL);
483 static const struct i2c_device_id syr82x_i2c_id[] = {
488 MODULE_DEVICE_TABLE(i2c, syr82x_i2c_id);
490 static struct i2c_driver syr82x_i2c_driver = {
493 .owner = THIS_MODULE,
494 .of_match_table =of_match_ptr(syr82x_of_match),
496 .probe = syr82x_i2c_probe,
497 .remove = syr82x_i2c_remove,
498 .id_table = syr82x_i2c_id,
501 static int __init syr82x_module_init(void)
504 ret = i2c_add_driver(&syr82x_i2c_driver);
506 pr_err("Failed to register I2C driver: %d\n", ret);
509 subsys_initcall_sync(syr82x_module_init);
511 static void __exit syr82x_module_exit(void)
513 i2c_del_driver(&syr82x_i2c_driver);
515 module_exit(syr82x_module_exit);
517 MODULE_LICENSE("GPL");
518 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
519 MODULE_DESCRIPTION("syr82x PMIC driver");