blob: a00c09ea0793ac2bbd18799d5801e34944e3bbeb [file] [log] [blame]
Graeme Gregory27c67502011-05-02 16:19:46 -05001/*
2 * tps65910.c -- TI TPS6591x
3 *
4 * Copyright 2010 Texas Instruments Inc.
5 *
6 * Author: Graeme Gregory <gg@slimlogic.co.uk>
7 * Author: Jorge Eduardo Candelaria <jedu@slimlogic.co.uk>
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
13 *
14 */
15
16#include <linux/module.h>
17#include <linux/moduleparam.h>
18#include <linux/init.h>
Laxman Dewangandc9913a2012-02-21 18:21:34 +053019#include <linux/err.h>
Graeme Gregory27c67502011-05-02 16:19:46 -050020#include <linux/slab.h>
21#include <linux/i2c.h>
22#include <linux/gpio.h>
23#include <linux/mfd/core.h>
Laxman Dewangandc9913a2012-02-21 18:21:34 +053024#include <linux/regmap.h>
Graeme Gregory27c67502011-05-02 16:19:46 -050025#include <linux/mfd/tps65910.h>
Rhyland Kleincd4209c2012-05-11 11:36:26 +020026#include <linux/of_device.h>
Graeme Gregory27c67502011-05-02 16:19:46 -050027
28static struct mfd_cell tps65910s[] = {
29 {
30 .name = "tps65910-pmic",
31 },
32 {
33 .name = "tps65910-rtc",
34 },
35 {
36 .name = "tps65910-power",
37 },
38};
39
40
Laxman Dewangandc9913a2012-02-21 18:21:34 +053041static bool is_volatile_reg(struct device *dev, unsigned int reg)
42{
43 struct tps65910 *tps65910 = dev_get_drvdata(dev);
44
45 /*
46 * Caching all regulator registers.
47 * All regualator register address range is same for
48 * TPS65910 and TPS65911
49 */
50 if ((reg >= TPS65910_VIO) && (reg <= TPS65910_VDAC)) {
51 /* Check for non-existing register */
52 if (tps65910_chip_id(tps65910) == TPS65910)
53 if ((reg == TPS65911_VDDCTRL_OP) ||
54 (reg == TPS65911_VDDCTRL_SR))
55 return true;
56 return false;
57 }
58 return true;
59}
60
Laxman Dewangan39ecb032012-03-07 18:46:05 +053061static const struct regmap_config tps65910_regmap_config = {
Laxman Dewangandc9913a2012-02-21 18:21:34 +053062 .reg_bits = 8,
63 .val_bits = 8,
64 .volatile_reg = is_volatile_reg,
65 .max_register = TPS65910_MAX_REGISTER,
66 .num_reg_defaults_raw = TPS65910_MAX_REGISTER,
67 .cache_type = REGCACHE_RBTREE,
68};
69
Mark Brown63745d42012-05-07 10:03:19 +010070static int __devinit tps65910_sleepinit(struct tps65910 *tps65910,
Laxman Dewangan201cf052012-04-18 12:13:51 +020071 struct tps65910_board *pmic_pdata)
72{
73 struct device *dev = NULL;
74 int ret = 0;
75
76 dev = tps65910->dev;
77
78 if (!pmic_pdata->en_dev_slp)
79 return 0;
80
81 /* enabling SLEEP device state */
Rhyland Klein3f7e8272012-05-08 11:42:38 -070082 ret = tps65910_reg_set_bits(tps65910, TPS65910_DEVCTRL,
Laxman Dewangan201cf052012-04-18 12:13:51 +020083 DEVCTRL_DEV_SLP_MASK);
84 if (ret < 0) {
85 dev_err(dev, "set dev_slp failed: %d\n", ret);
86 goto err_sleep_init;
87 }
88
89 /* Return if there is no sleep keepon data. */
90 if (!pmic_pdata->slp_keepon)
91 return 0;
92
93 if (pmic_pdata->slp_keepon->therm_keepon) {
Rhyland Klein3f7e8272012-05-08 11:42:38 -070094 ret = tps65910_reg_set_bits(tps65910,
95 TPS65910_SLEEP_KEEP_RES_ON,
Laxman Dewangan201cf052012-04-18 12:13:51 +020096 SLEEP_KEEP_RES_ON_THERM_KEEPON_MASK);
97 if (ret < 0) {
98 dev_err(dev, "set therm_keepon failed: %d\n", ret);
99 goto disable_dev_slp;
100 }
101 }
102
103 if (pmic_pdata->slp_keepon->clkout32k_keepon) {
Rhyland Klein3f7e8272012-05-08 11:42:38 -0700104 ret = tps65910_reg_set_bits(tps65910,
105 TPS65910_SLEEP_KEEP_RES_ON,
Laxman Dewangan201cf052012-04-18 12:13:51 +0200106 SLEEP_KEEP_RES_ON_CLKOUT32K_KEEPON_MASK);
107 if (ret < 0) {
108 dev_err(dev, "set clkout32k_keepon failed: %d\n", ret);
109 goto disable_dev_slp;
110 }
111 }
112
113 if (pmic_pdata->slp_keepon->i2chs_keepon) {
Rhyland Klein3f7e8272012-05-08 11:42:38 -0700114 ret = tps65910_reg_set_bits(tps65910,
115 TPS65910_SLEEP_KEEP_RES_ON,
Laxman Dewangan201cf052012-04-18 12:13:51 +0200116 SLEEP_KEEP_RES_ON_I2CHS_KEEPON_MASK);
117 if (ret < 0) {
118 dev_err(dev, "set i2chs_keepon failed: %d\n", ret);
119 goto disable_dev_slp;
120 }
121 }
122
123 return 0;
124
125disable_dev_slp:
Rhyland Klein3f7e8272012-05-08 11:42:38 -0700126 tps65910_reg_clear_bits(tps65910, TPS65910_DEVCTRL,
127 DEVCTRL_DEV_SLP_MASK);
Laxman Dewangan201cf052012-04-18 12:13:51 +0200128
129err_sleep_init:
130 return ret;
131}
132
Rhyland Kleincd4209c2012-05-11 11:36:26 +0200133#ifdef CONFIG_OF
134static struct of_device_id tps65910_of_match[] = {
135 { .compatible = "ti,tps65910", .data = (void *)TPS65910},
136 { .compatible = "ti,tps65911", .data = (void *)TPS65911},
137 { },
138};
139MODULE_DEVICE_TABLE(of, tps65910_of_match);
140
141static struct tps65910_board *tps65910_parse_dt(struct i2c_client *client,
142 int *chip_id)
143{
144 struct device_node *np = client->dev.of_node;
145 struct tps65910_board *board_info;
146 unsigned int prop;
147 const struct of_device_id *match;
148 unsigned int prop_array[TPS6591X_MAX_NUM_GPIO];
149 int ret = 0;
150 int idx;
151
152 match = of_match_device(tps65910_of_match, &client->dev);
153 if (!match) {
154 dev_err(&client->dev, "Failed to find matching dt id\n");
155 return NULL;
156 }
157
158 *chip_id = (int)match->data;
159
160 board_info = devm_kzalloc(&client->dev, sizeof(*board_info),
161 GFP_KERNEL);
162 if (!board_info) {
163 dev_err(&client->dev, "Failed to allocate pdata\n");
164 return NULL;
165 }
166
167 ret = of_property_read_u32(np, "ti,vmbch-threshold", &prop);
168 if (!ret)
169 board_info->vmbch_threshold = prop;
170 else if (*chip_id == TPS65911)
171 dev_warn(&client->dev, "VMBCH-Threshold not specified");
172
173 ret = of_property_read_u32(np, "ti,vmbch2-threshold", &prop);
174 if (!ret)
175 board_info->vmbch2_threshold = prop;
176 else if (*chip_id == TPS65911)
177 dev_warn(&client->dev, "VMBCH2-Threshold not specified");
178
179 ret = of_property_read_u32_array(np, "ti,en-gpio-sleep",
180 prop_array, TPS6591X_MAX_NUM_GPIO);
181 if (!ret)
182 for (idx = 0; idx < ARRAY_SIZE(prop_array); idx++)
183 board_info->en_gpio_sleep[idx] = (prop_array[idx] != 0);
184 else if (ret != -EINVAL) {
185 dev_err(&client->dev,
186 "error reading property ti,en-gpio-sleep: %d\n.", ret);
187 return NULL;
188 }
189
190
191 board_info->irq = client->irq;
192 board_info->irq_base = -1;
193 board_info->gpio_base = -1;
194
195 return board_info;
196}
197#else
198static inline struct tps65910_board *tps65910_parse_dt(
199 struct i2c_client *client)
200{
201 return NULL;
202}
203#endif
Laxman Dewangan201cf052012-04-18 12:13:51 +0200204
Mark Brown63745d42012-05-07 10:03:19 +0100205static __devinit int tps65910_i2c_probe(struct i2c_client *i2c,
206 const struct i2c_device_id *id)
Graeme Gregory27c67502011-05-02 16:19:46 -0500207{
208 struct tps65910 *tps65910;
Graeme Gregory2537df72011-05-02 16:19:52 -0500209 struct tps65910_board *pmic_plat_data;
Graeme Gregorye3471bd2011-05-02 16:20:04 -0500210 struct tps65910_platform_data *init_data;
Graeme Gregory27c67502011-05-02 16:19:46 -0500211 int ret = 0;
Rhyland Kleincd4209c2012-05-11 11:36:26 +0200212 int chip_id = id->driver_data;
Graeme Gregory27c67502011-05-02 16:19:46 -0500213
Graeme Gregory2537df72011-05-02 16:19:52 -0500214 pmic_plat_data = dev_get_platdata(&i2c->dev);
Rhyland Kleincd4209c2012-05-11 11:36:26 +0200215
216 if (!pmic_plat_data && i2c->dev.of_node)
217 pmic_plat_data = tps65910_parse_dt(i2c, &chip_id);
218
Graeme Gregory2537df72011-05-02 16:19:52 -0500219 if (!pmic_plat_data)
220 return -EINVAL;
221
Graeme Gregorye3471bd2011-05-02 16:20:04 -0500222 init_data = kzalloc(sizeof(struct tps65910_platform_data), GFP_KERNEL);
223 if (init_data == NULL)
224 return -ENOMEM;
225
Graeme Gregory27c67502011-05-02 16:19:46 -0500226 tps65910 = kzalloc(sizeof(struct tps65910), GFP_KERNEL);
Jesper Juhldc7e4122011-07-06 00:29:07 +0200227 if (tps65910 == NULL) {
228 kfree(init_data);
Graeme Gregory27c67502011-05-02 16:19:46 -0500229 return -ENOMEM;
Jesper Juhldc7e4122011-07-06 00:29:07 +0200230 }
Graeme Gregory27c67502011-05-02 16:19:46 -0500231
232 i2c_set_clientdata(i2c, tps65910);
233 tps65910->dev = &i2c->dev;
234 tps65910->i2c_client = i2c;
Rhyland Kleincd4209c2012-05-11 11:36:26 +0200235 tps65910->id = chip_id;
Graeme Gregory27c67502011-05-02 16:19:46 -0500236 mutex_init(&tps65910->io_mutex);
237
Laxman Dewangan39ecb032012-03-07 18:46:05 +0530238 tps65910->regmap = regmap_init_i2c(i2c, &tps65910_regmap_config);
Laxman Dewangandc9913a2012-02-21 18:21:34 +0530239 if (IS_ERR(tps65910->regmap)) {
240 ret = PTR_ERR(tps65910->regmap);
241 dev_err(&i2c->dev, "regmap initialization failed: %d\n", ret);
242 goto regmap_err;
243 }
244
Graeme Gregory27c67502011-05-02 16:19:46 -0500245 ret = mfd_add_devices(tps65910->dev, -1,
246 tps65910s, ARRAY_SIZE(tps65910s),
247 NULL, 0);
248 if (ret < 0)
249 goto err;
250
Jesper Juhlb1224cd2011-07-13 23:22:26 +0200251 init_data->irq = pmic_plat_data->irq;
Laxman Dewangan17731402012-01-18 20:19:16 +0530252 init_data->irq_base = pmic_plat_data->irq_base;
Jesper Juhlb1224cd2011-07-13 23:22:26 +0200253
Graeme Gregory2537df72011-05-02 16:19:52 -0500254 tps65910_gpio_init(tps65910, pmic_plat_data->gpio_base);
255
Afzal Mohammed1e351a92011-12-14 16:05:35 +0530256 tps65910_irq_init(tps65910, init_data->irq, init_data);
Graeme Gregorye3471bd2011-05-02 16:20:04 -0500257
Laxman Dewangan201cf052012-04-18 12:13:51 +0200258 tps65910_sleepinit(tps65910, pmic_plat_data);
259
Jesper Juhldc7e4122011-07-06 00:29:07 +0200260 kfree(init_data);
Graeme Gregory27c67502011-05-02 16:19:46 -0500261 return ret;
262
263err:
Laxman Dewangandc9913a2012-02-21 18:21:34 +0530264 regmap_exit(tps65910->regmap);
265regmap_err:
Graeme Gregory27c67502011-05-02 16:19:46 -0500266 kfree(tps65910);
Jesper Juhldc7e4122011-07-06 00:29:07 +0200267 kfree(init_data);
Graeme Gregory27c67502011-05-02 16:19:46 -0500268 return ret;
269}
270
Mark Brown63745d42012-05-07 10:03:19 +0100271static __devexit int tps65910_i2c_remove(struct i2c_client *i2c)
Graeme Gregory27c67502011-05-02 16:19:46 -0500272{
273 struct tps65910 *tps65910 = i2c_get_clientdata(i2c);
274
Mark Brownec2328c2011-06-20 11:47:55 +0100275 tps65910_irq_exit(tps65910);
Afzal Mohammed1e351a92011-12-14 16:05:35 +0530276 mfd_remove_devices(tps65910->dev);
Laxman Dewangandc9913a2012-02-21 18:21:34 +0530277 regmap_exit(tps65910->regmap);
Graeme Gregory27c67502011-05-02 16:19:46 -0500278 kfree(tps65910);
279
280 return 0;
281}
282
283static const struct i2c_device_id tps65910_i2c_id[] = {
Jorge Eduardo Candelaria79557052011-05-16 18:34:59 -0500284 { "tps65910", TPS65910 },
285 { "tps65911", TPS65911 },
Graeme Gregory27c67502011-05-02 16:19:46 -0500286 { }
287};
288MODULE_DEVICE_TABLE(i2c, tps65910_i2c_id);
289
290
291static struct i2c_driver tps65910_i2c_driver = {
292 .driver = {
293 .name = "tps65910",
294 .owner = THIS_MODULE,
Rhyland Kleincd4209c2012-05-11 11:36:26 +0200295 .of_match_table = of_match_ptr(tps65910_of_match),
Graeme Gregory27c67502011-05-02 16:19:46 -0500296 },
297 .probe = tps65910_i2c_probe,
Mark Brown63745d42012-05-07 10:03:19 +0100298 .remove = __devexit_p(tps65910_i2c_remove),
Graeme Gregory27c67502011-05-02 16:19:46 -0500299 .id_table = tps65910_i2c_id,
300};
301
302static int __init tps65910_i2c_init(void)
303{
304 return i2c_add_driver(&tps65910_i2c_driver);
305}
306/* init early so consumer devices can complete system boot */
307subsys_initcall(tps65910_i2c_init);
308
309static void __exit tps65910_i2c_exit(void)
310{
311 i2c_del_driver(&tps65910_i2c_driver);
312}
313module_exit(tps65910_i2c_exit);
314
315MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
316MODULE_AUTHOR("Jorge Eduardo Candelaria <jedu@slimlogic.co.uk>");
317MODULE_DESCRIPTION("TPS6591x chip family multi-function driver");
318MODULE_LICENSE("GPL");