2 * Regulator driver for xz3216 DCDC chip for rk32xx
4 * Copyright (C) 2010, 2011 ROCKCHIP, Inc.
6 * Based on xz3216.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>
36 #define DBG(x...) pr_info(x)
42 #define DBG_ERR(x...) pr_err(x)
45 #define XZ3216_SPEED (200 * 1000)
46 #define XZ3216_NUM_REGULATORS 1
51 struct i2c_client *i2c;
53 struct regulator_dev **rdev;
57 unsigned int dcdc_slp_voltage[3];
59 struct regmap *regmap;
62 struct xz3216_regulator {
64 struct regulator_desc *desc;
65 struct regulator_dev *rdev;
72 struct regulator_init_data *xz3216_init_data[XZ3216_NUM_REGULATORS];
73 struct device_node *of_node[XZ3216_NUM_REGULATORS];
75 unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
79 struct xz3216_regulator_subdev {
81 struct regulator_init_data *initdata;
82 struct device_node *reg_node;
85 struct xz3216_platform_data {
88 struct xz3216_regulator_subdev *regulators;
90 unsigned int dcdc_slp_voltage[3]; /* buckx_voltage in uV */
94 static int xz3216_reg_read(struct xz3216 *xz3216, u8 reg);
95 static int xz3216_set_bits(struct xz3216 *xz3216, u8 reg, u16 mask, u16 val);
98 #define XZ3216_BUCK1_SET_VOL_BASE 0x00
99 #define XZ3216_BUCK1_SLP_VOL_BASE 0x01
100 #define XZ3216_CONTR_REG1 0x02
101 /*#define XZ3216_ID1_REG 0x03*/
102 /*#define XZ3216_ID2_REG 0x04*/
103 #define XZ3216_CONTR_REG2 0x05
104 #define BUCK_VOL_MASK 0x3f
105 #define VOL_MIN_IDX 0x00
106 #define VOL_MAX_IDX 0x3f
108 const static int buck_voltage_map[] = {
109 603000, 615750, 628500, 641250, 654000, 666750, 679500, 692250,
110 705000, 717750, 730500, 743250, 756000, 768750, 781500, 794250,
111 807000, 819750, 832500, 845250, 858000, 870750, 883500, 896250,
112 909000, 921750, 934500, 947250, 960000, 972750, 985500, 998250,
113 1011000, 1023750, 1036500, 1049250, 1062000, 1074750, 1087500, 1100250,
114 1113000, 1125750, 1138500, 1151250, 1164000, 1176750, 1189500, 1202250,
115 1215000, 1227750, 1240500, 1253250, 1266000, 1278750, 1291500, 1304250,
116 1317000, 1329750, 1342500, 1355250, 1368000, 1380750, 1393500, 1406250
118 712500, 725000, 737500, 750000, 762500, 775000, 787500, 800000,
119 812500, 825000, 837500,850000, 862500,875000,887500,900000,
120 912500, 925000, 937500,950000, 962500,975000,987500,1000000,
121 1012500, 1025000, 1037500,1050000, 1062500,1075000,1087500,1100000,
122 1112500, 1125000, 1137500,1150000, 1162500,1175000,1187500,1200000,
123 1212500, 1225000, 1237500,1250000, 1262500,1275000,1287500,1300000,
124 1312500, 1325000, 1337500,1350000, 1362500,1375000,1387500,1400000,
125 1412500, 1425000, 1437500,1450000, 1462500,1475000,1487500,1500000,
129 static int xz3216_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
131 if (index >= ARRAY_SIZE(buck_voltage_map))
133 return buck_voltage_map[index];
137 static int xz3216_dcdc_is_enabled(struct regulator_dev *dev)
139 struct xz3216 *xz3216 = rdev_get_drvdata(dev);
143 val = xz3216_reg_read(xz3216, XZ3216_BUCK1_SET_VOL_BASE);
154 static int xz3216_dcdc_enable(struct regulator_dev *dev)
156 struct xz3216 *xz3216 = rdev_get_drvdata(dev);
159 return xz3216_set_bits(xz3216, XZ3216_BUCK1_SET_VOL_BASE, mask,
164 static int xz3216_dcdc_disable(struct regulator_dev *dev)
166 struct xz3216 *xz3216 = rdev_get_drvdata(dev);
169 return xz3216_set_bits(xz3216, XZ3216_BUCK1_SET_VOL_BASE, mask, 0);
173 static int xz3216_dcdc_get_voltage(struct regulator_dev *dev)
175 struct xz3216 *xz3216 = rdev_get_drvdata(dev);
179 reg = xz3216_reg_read(xz3216, XZ3216_BUCK1_SET_VOL_BASE);
180 reg &= BUCK_VOL_MASK;
181 val = buck_voltage_map[reg];
186 static int xz3216_dcdc_set_voltage(struct regulator_dev *dev,
187 int min_uV, int max_uV,
190 struct xz3216 *xz3216 = rdev_get_drvdata(dev);
191 const int *vol_map = buck_voltage_map;
195 if (min_uV < vol_map[VOL_MIN_IDX] ||
196 min_uV > vol_map[VOL_MAX_IDX])
198 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++) {
199 if (vol_map[val] >= min_uV)
202 if (vol_map[val] > max_uV) {
203 DBG_ERR("WARNING:this voltage is not support!voltage set");
204 DBG_ERR(" is %d mv\n", vol_map[val]);
206 ret = xz3216_set_bits(xz3216, XZ3216_BUCK1_SET_VOL_BASE,
209 DBG_ERR("###################WARNING:set voltage is error!");
210 DBG_ERR("voltage set is %d mv %d\n", vol_map[val], ret);
216 static unsigned int xz3216_dcdc_get_mode(struct regulator_dev *dev)
218 struct xz3216 *xz3216 = rdev_get_drvdata(dev);
222 val = xz3216_reg_read(xz3216, XZ3216_BUCK1_SET_VOL_BASE);
227 return REGULATOR_MODE_FAST;
229 return REGULATOR_MODE_NORMAL;
233 static int xz3216_dcdc_set_mode(struct regulator_dev *dev, unsigned int mode)
235 struct xz3216 *xz3216 = rdev_get_drvdata(dev);
239 case REGULATOR_MODE_FAST:
240 return xz3216_set_bits(xz3216, XZ3216_BUCK1_SET_VOL_BASE,
242 case REGULATOR_MODE_NORMAL:
243 return xz3216_set_bits(xz3216, XZ3216_BUCK1_SET_VOL_BASE,
246 DBG("error:dcdc_xz3216 only auto and pwm mode\n");
252 static int xz3216_dcdc_set_voltage_time_sel(struct regulator_dev *dev,
253 unsigned int old_selector,
254 unsigned int new_selector)
259 old_volt = xz3216_dcdc_list_voltage(dev, old_selector);
262 new_volt = xz3216_dcdc_list_voltage(dev, new_selector);
265 return DIV_ROUND_UP(abs(old_volt - new_volt)*4, 10000);
269 static int xz3216_dcdc_suspend_enable(struct regulator_dev *dev)
271 struct xz3216 *xz3216 = rdev_get_drvdata(dev);
274 return xz3216_set_bits(xz3216, XZ3216_BUCK1_SLP_VOL_BASE,
279 static int xz3216_dcdc_suspend_disable(struct regulator_dev *dev)
281 struct xz3216 *xz3216 = rdev_get_drvdata(dev);
284 return xz3216_set_bits(xz3216, XZ3216_BUCK1_SLP_VOL_BASE, mask,
288 static int xz3216_dcdc_set_sleep_voltage(struct regulator_dev *dev,
291 struct xz3216 *xz3216 = rdev_get_drvdata(dev);
292 const int *vol_map = buck_voltage_map;
296 if (uV < vol_map[VOL_MIN_IDX] ||
297 uV > vol_map[VOL_MAX_IDX])
299 for (val = VOL_MIN_IDX; val <= VOL_MAX_IDX; val++) {
300 if (vol_map[val] >= uV)
303 if (vol_map[val] > uV) {
304 DBG("WARNING:this voltage is not support!voltage set");
305 DBG("is %d mv\n", vol_map[val]);
307 ret = xz3216_set_bits(xz3216, XZ3216_BUCK1_SLP_VOL_BASE,
313 static int xz3216_dcdc_set_suspend_mode(struct regulator_dev *dev,
316 struct xz3216 *xz3216 = rdev_get_drvdata(dev);
320 case REGULATOR_MODE_FAST:
321 return xz3216_set_bits(xz3216, XZ3216_BUCK1_SLP_VOL_BASE,
323 case REGULATOR_MODE_NORMAL:
324 return xz3216_set_bits(xz3216, XZ3216_BUCK1_SLP_VOL_BASE,
327 DBG_ERR("error:dcdc_xz3216 only auto and pwm mode\n");
332 static struct regulator_ops xz3216_dcdc_ops = {
333 .set_voltage = xz3216_dcdc_set_voltage,
334 .get_voltage = xz3216_dcdc_get_voltage,
335 .list_voltage = xz3216_dcdc_list_voltage,
336 .is_enabled = xz3216_dcdc_is_enabled,
337 .enable = xz3216_dcdc_enable,
338 .disable = xz3216_dcdc_disable,
339 .get_mode = xz3216_dcdc_get_mode,
340 .set_mode = xz3216_dcdc_set_mode,
341 .set_suspend_voltage = xz3216_dcdc_set_sleep_voltage,
342 .set_suspend_enable = xz3216_dcdc_suspend_enable,
343 .set_suspend_disable = xz3216_dcdc_suspend_disable,
344 .set_suspend_mode = xz3216_dcdc_set_suspend_mode,
345 .set_voltage_time_sel = xz3216_dcdc_set_voltage_time_sel,
349 static struct regulator_desc regulators[] = {
353 .ops = &xz3216_dcdc_ops,
354 .n_voltages = ARRAY_SIZE(buck_voltage_map),
355 .type = REGULATOR_VOLTAGE,
356 .owner = THIS_MODULE,
360 static int xz3216_i2c_read(struct i2c_client *i2c, char reg, int count,
364 struct i2c_adapter *adap;
365 struct i2c_msg msgs[2];
372 msgs[0].addr = i2c->addr;
374 msgs[0].flags = i2c->flags;
376 msgs[0].scl_rate = XZ3216_SPEED;
377 msgs[1].buf = (u8 *)dest;
378 msgs[1].addr = i2c->addr;
379 msgs[1].flags = i2c->flags | I2C_M_RD;
381 msgs[1].scl_rate = XZ3216_SPEED;
382 ret = i2c_transfer(adap, msgs, 2);
383 DBG("***run in %s %d msgs[1].buf = %d\n", __func__,
384 __LINE__, *(msgs[1].buf));
388 static int xz3216_i2c_write(struct i2c_client *i2c, char reg,
389 int count, const u16 src)
392 struct i2c_adapter *adap;
403 msg.addr = i2c->addr;
404 msg.buf = &tx_buf[0];
406 msg.flags = i2c->flags;
407 msg.scl_rate = XZ3216_SPEED;
408 ret = i2c_transfer(adap, &msg, 1);
412 static int xz3216_reg_read(struct xz3216 *xz3216, u8 reg)
417 mutex_lock(&xz3216->io_lock);
418 ret = xz3216_i2c_read(xz3216->i2c, reg, 1, &val);
419 DBG("reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val&0xff);
421 mutex_unlock(&xz3216->io_lock);
424 mutex_unlock(&xz3216->io_lock);
428 static int xz3216_set_bits(struct xz3216 *xz3216, u8 reg, u16 mask, u16 val)
433 mutex_lock(&xz3216->io_lock);
434 ret = xz3216_i2c_read(xz3216->i2c, reg, 1, &tmp);
435 DBG("1 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp&0xff);
437 mutex_unlock(&xz3216->io_lock);
440 tmp = (tmp & ~mask) | val;
441 ret = xz3216_i2c_write(xz3216->i2c, reg, 1, tmp);
442 DBG("reg write 0x%02x -> 0x%02x\n", (int)reg, (unsigned)val & 0xff);
444 mutex_unlock(&xz3216->io_lock);
447 ret = xz3216_i2c_read(xz3216->i2c, reg, 1, &tmp);
448 DBG("2 reg read 0x%02x -> 0x%02x\n", (int)reg, (unsigned)tmp & 0xff);
450 mutex_unlock(&xz3216->io_lock);
453 mutex_unlock(&xz3216->io_lock);
458 static struct of_device_id xz3216_of_match[] = {
459 { .compatible = "xz3216"},
462 MODULE_DEVICE_TABLE(of, xz3216_of_match);
465 static struct of_regulator_match xz3216_reg_matches[] = {
466 { .name = "xz_dcdc1", .driver_data = (void *)0},
469 static struct xz3216_board *xz3216_parse_dt(struct xz3216 *xz3216)
471 struct xz3216_board *pdata;
472 struct device_node *regs;
473 struct device_node *xz3216_np;
476 DBG("%s,line=%d\n", __func__, __LINE__);
477 xz3216_np = of_node_get(xz3216->dev->of_node);
479 DBG_ERR("could not find pmic sub-node\n");
482 regs = of_find_node_by_name(xz3216_np, "regulators");
485 count = of_regulator_match(xz3216->dev, regs, xz3216_reg_matches,
486 XZ3216_NUM_REGULATORS);
488 pdata = devm_kzalloc(xz3216->dev, sizeof(*pdata), GFP_KERNEL);
491 pdata->xz3216_init_data[0] = xz3216_reg_matches[0].init_data;
492 pdata->of_node[0] = xz3216_reg_matches[0].of_node;
497 static struct xz3216_board *xz3216_parse_dt(struct i2c_client *i2c)
503 static int xz3216_i2c_probe(struct i2c_client *i2c,
504 const struct i2c_device_id *id)
506 struct xz3216 *xz3216;
507 struct xz3216_board *pdev;
508 const struct of_device_id *match;
509 struct regulator_config config = { };
510 struct regulator_dev *xz_rdev;
511 struct regulator_init_data *reg_data;
512 const char *rail_name = NULL;
515 DBG("%s, line=%d\n", __func__, __LINE__);
516 if (i2c->dev.of_node) {
517 match = of_match_device(xz3216_of_match, &i2c->dev);
519 DBG_ERR("Failed to find matching dt id\n");
524 xz3216 = devm_kzalloc(&i2c->dev, sizeof(struct xz3216),
526 if (xz3216 == NULL) {
531 xz3216->dev = &i2c->dev;
532 i2c_set_clientdata(i2c, xz3216);
533 mutex_init(&xz3216->io_lock);
534 if (xz3216->dev->of_node)
535 pdev = xz3216_parse_dt(xz3216);
538 xz3216->num_regulators = XZ3216_NUM_REGULATORS;
539 xz3216->rdev = kcalloc(XZ3216_NUM_REGULATORS,
540 sizeof(struct regulator_dev *),
544 /* Instantiate the regulators */
545 reg_data = pdev->xz3216_init_data[0];
546 config.dev = xz3216->dev;
547 config.driver_data = xz3216;
548 if (xz3216->dev->of_node)
549 config.of_node = pdev->of_node[0];
550 if (reg_data && reg_data->constraints.name)
551 rail_name = reg_data->constraints.name;
553 rail_name = regulators[0].name;
554 reg_data->supply_regulator = rail_name;
556 config.init_data = reg_data;
557 xz_rdev = regulator_register(®ulators[0], &config);
558 if (IS_ERR(xz_rdev)) {
559 DBG_ERR("failed to register xz3216\n");
562 xz3216->rdev[0] = xz_rdev;
569 static int xz3216_i2c_remove(struct i2c_client *i2c)
571 struct xz3216 *xz3216 = i2c_get_clientdata(i2c);
574 regulator_unregister(xz3216->rdev[0]);
575 i2c_set_clientdata(i2c, NULL);
579 static const struct i2c_device_id xz3216_i2c_id[] = {
583 MODULE_DEVICE_TABLE(i2c, xz3216_i2c_id);
585 static struct i2c_driver xz3216_i2c_driver = {
588 .owner = THIS_MODULE,
589 .of_match_table = of_match_ptr(xz3216_of_match),
591 .probe = xz3216_i2c_probe,
592 .remove = xz3216_i2c_remove,
593 .id_table = xz3216_i2c_id,
596 static int __init xz3216_module_init(void)
600 ret = i2c_add_driver(&xz3216_i2c_driver);
602 pr_err("Failed to register I2C driver: %d\n", ret);
605 subsys_initcall_sync(xz3216_module_init);
607 static void __exit xz3216_module_exit(void)
609 i2c_del_driver(&xz3216_i2c_driver);
611 module_exit(xz3216_module_exit);
613 MODULE_LICENSE("GPL");
614 MODULE_AUTHOR("zhangqing <zhangqing@rock-chips.com>");
615 MODULE_DESCRIPTION("xz3216 PMIC driver");