a00c09ea0793ac2bbd18799d5801e34944e3bbeb
[linux-2.6.git] / drivers / mfd / tps65910.c
1 /*
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>
19 #include <linux/err.h>
20 #include <linux/slab.h>
21 #include <linux/i2c.h>
22 #include <linux/gpio.h>
23 #include <linux/mfd/core.h>
24 #include <linux/regmap.h>
25 #include <linux/mfd/tps65910.h>
26 #include <linux/of_device.h>
27
28 static 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
41 static 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
61 static const struct regmap_config tps65910_regmap_config = {
62         .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
70 static int __devinit tps65910_sleepinit(struct tps65910 *tps65910,
71                 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 */
82         ret = tps65910_reg_set_bits(tps65910, TPS65910_DEVCTRL,
83                                 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) {
94                 ret = tps65910_reg_set_bits(tps65910,
95                                 TPS65910_SLEEP_KEEP_RES_ON,
96                                 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) {
104                 ret = tps65910_reg_set_bits(tps65910,
105                                 TPS65910_SLEEP_KEEP_RES_ON,
106                                 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) {
114                 ret = tps65910_reg_set_bits(tps65910,
115                                 TPS65910_SLEEP_KEEP_RES_ON,
116                                 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
125 disable_dev_slp:
126         tps65910_reg_clear_bits(tps65910, TPS65910_DEVCTRL,
127                                 DEVCTRL_DEV_SLP_MASK);
128
129 err_sleep_init:
130         return ret;
131 }
132
133 #ifdef CONFIG_OF
134 static struct of_device_id tps65910_of_match[] = {
135         { .compatible = "ti,tps65910", .data = (void *)TPS65910},
136         { .compatible = "ti,tps65911", .data = (void *)TPS65911},
137         { },
138 };
139 MODULE_DEVICE_TABLE(of, tps65910_of_match);
140
141 static 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
198 static inline struct tps65910_board *tps65910_parse_dt(
199                                         struct i2c_client *client)
200 {
201         return NULL;
202 }
203 #endif
204
205 static __devinit int tps65910_i2c_probe(struct i2c_client *i2c,
206                                         const struct i2c_device_id *id)
207 {
208         struct tps65910 *tps65910;
209         struct tps65910_board *pmic_plat_data;
210         struct tps65910_platform_data *init_data;
211         int ret = 0;
212         int chip_id = id->driver_data;
213
214         pmic_plat_data = dev_get_platdata(&i2c->dev);
215
216         if (!pmic_plat_data && i2c->dev.of_node)
217                 pmic_plat_data = tps65910_parse_dt(i2c, &chip_id);
218
219         if (!pmic_plat_data)
220                 return -EINVAL;
221
222         init_data = kzalloc(sizeof(struct tps65910_platform_data), GFP_KERNEL);
223         if (init_data == NULL)
224                 return -ENOMEM;
225
226         tps65910 = kzalloc(sizeof(struct tps65910), GFP_KERNEL);
227         if (tps65910 == NULL) {
228                 kfree(init_data);
229                 return -ENOMEM;
230         }
231
232         i2c_set_clientdata(i2c, tps65910);
233         tps65910->dev = &i2c->dev;
234         tps65910->i2c_client = i2c;
235         tps65910->id = chip_id;
236         mutex_init(&tps65910->io_mutex);
237
238         tps65910->regmap = regmap_init_i2c(i2c, &tps65910_regmap_config);
239         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
245         ret = mfd_add_devices(tps65910->dev, -1,
246                               tps65910s, ARRAY_SIZE(tps65910s),
247                               NULL, 0);
248         if (ret < 0)
249                 goto err;
250
251         init_data->irq = pmic_plat_data->irq;
252         init_data->irq_base = pmic_plat_data->irq_base;
253
254         tps65910_gpio_init(tps65910, pmic_plat_data->gpio_base);
255
256         tps65910_irq_init(tps65910, init_data->irq, init_data);
257
258         tps65910_sleepinit(tps65910, pmic_plat_data);
259
260         kfree(init_data);
261         return ret;
262
263 err:
264         regmap_exit(tps65910->regmap);
265 regmap_err:
266         kfree(tps65910);
267         kfree(init_data);
268         return ret;
269 }
270
271 static __devexit int tps65910_i2c_remove(struct i2c_client *i2c)
272 {
273         struct tps65910 *tps65910 = i2c_get_clientdata(i2c);
274
275         tps65910_irq_exit(tps65910);
276         mfd_remove_devices(tps65910->dev);
277         regmap_exit(tps65910->regmap);
278         kfree(tps65910);
279
280         return 0;
281 }
282
283 static const struct i2c_device_id tps65910_i2c_id[] = {
284        { "tps65910", TPS65910 },
285        { "tps65911", TPS65911 },
286        { }
287 };
288 MODULE_DEVICE_TABLE(i2c, tps65910_i2c_id);
289
290
291 static struct i2c_driver tps65910_i2c_driver = {
292         .driver = {
293                    .name = "tps65910",
294                    .owner = THIS_MODULE,
295                    .of_match_table = of_match_ptr(tps65910_of_match),
296         },
297         .probe = tps65910_i2c_probe,
298         .remove = __devexit_p(tps65910_i2c_remove),
299         .id_table = tps65910_i2c_id,
300 };
301
302 static 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 */
307 subsys_initcall(tps65910_i2c_init);
308
309 static void __exit tps65910_i2c_exit(void)
310 {
311         i2c_del_driver(&tps65910_i2c_driver);
312 }
313 module_exit(tps65910_i2c_exit);
314
315 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>");
316 MODULE_AUTHOR("Jorge Eduardo Candelaria <jedu@slimlogic.co.uk>");
317 MODULE_DESCRIPTION("TPS6591x chip family multi-function driver");
318 MODULE_LICENSE("GPL");