config: tegra3: enable /dev mount with ACL
[linux-2.6.git] / drivers / mfd / max77665.c
1 /*
2  * Core driver for MAXIM MAX77665
3  *
4  * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
5
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include <linux/err.h>
20 #include <linux/i2c.h>
21 #include <linux/interrupt.h>
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/mutex.h>
25 #include <linux/mfd/core.h>
26 #include <linux/mfd/max77665.h>
27 #include <linux/slab.h>
28
29 #define MAX77665_INT_STS        0x22
30 #define MAX77665_INT_MSK        0x23
31 #define MAX77665_PMIC_FLASH     0x00 ... 0x10
32 #define MAX77665_PMIC_PMIC      0x20 ... 0x2D
33 #define MAX77665_PMIC_CHARGER   0xB0 ... 0xC6
34 #define MAX77665_MUIC           0x00 ... 0x0E
35 #define MAX77665_HAPTIC         0x00 ... 0x10
36
37 static u8 max77665_i2c_slave_address[] = {
38         [MAX77665_I2C_SLAVE_PMIC] = 0x66,
39         [MAX77665_I2C_SLAVE_MUIC] = 0x25,
40         [MAX77665_I2C_SLAVE_HAPTIC] = 0x48,
41 };
42
43 struct max77665_irq_data {
44         int bit;
45 };
46
47 #define MAX77665_IRQ(_id, _bit_pos)                             \
48         [MAX77665_IRQ_##_id] =  {                               \
49                                         .bit    = (_bit_pos),   \
50                                 }
51
52 static const struct max77665_irq_data max77665_irqs[] = {
53         MAX77665_IRQ(CHARGER, 0),
54         MAX77665_IRQ(TOP_SYS, 1),
55         MAX77665_IRQ(FLASH, 2),
56         MAX77665_IRQ(MUIC, 3),
57 };
58
59 static struct mfd_cell max77665s[] = {
60         {.name = "max77665-charger",},
61         {.name = "max77665-flash",},
62         {.name = "max77665-muic",},
63         {.name = "max77665-haptic",},
64 };
65
66 static void max77665_irq_lock(struct irq_data *data)
67 {
68         struct max77665 *max77665 = irq_data_get_irq_chip_data(data);
69
70         mutex_lock(&max77665->irq_lock);
71 }
72
73 static void max77665_irq_mask(struct irq_data *irq_data)
74 {
75         struct max77665 *max77665 = irq_data_get_irq_chip_data(irq_data);
76         unsigned int __irq = irq_data->irq - max77665->irq_base;
77         const struct max77665_irq_data *data = &max77665_irqs[__irq];
78         int ret;
79
80         ret = max77665_set_bits(max77665->dev, MAX77665_I2C_SLAVE_PMIC,
81                                 MAX77665_INT_MSK, data->bit);
82         if (ret < 0)
83                 dev_err(max77665->dev,
84                         "Clearing mask reg failed e = %d\n", ret);
85 }
86
87 static void max77665_irq_unmask(struct irq_data *irq_data)
88 {
89         struct max77665 *max77665 = irq_data_get_irq_chip_data(irq_data);
90         unsigned int __irq = irq_data->irq - max77665->irq_base;
91         const struct max77665_irq_data *data = &max77665_irqs[__irq];
92         int ret;
93
94         ret = max77665_clr_bits(max77665->dev, MAX77665_I2C_SLAVE_PMIC,
95                                 MAX77665_INT_MSK, data->bit);
96         if (ret < 0)
97                 dev_err(max77665->dev,
98                         "Setting mask reg failed e = %d\n", ret);
99 }
100
101 static void max77665_irq_sync_unlock(struct irq_data *data)
102 {
103         struct max77665 *max77665 = irq_data_get_irq_chip_data(data);
104
105         mutex_unlock(&max77665->irq_lock);
106 }
107
108 static irqreturn_t max77665_irq(int irq, void *data)
109 {
110         struct max77665 *max77665 = data;
111         int ret = 0;
112         u8 status = 0;
113         unsigned long int acks = 0;
114         int i;
115
116         ret = max77665_read(max77665->dev, MAX77665_I2C_SLAVE_PMIC,
117                                         MAX77665_INT_STS, &status);
118         if (ret < 0) {
119                 dev_err(max77665->dev,
120                                 "failed to read status regi, e %d\n", ret);
121                 return IRQ_NONE;
122         }
123         acks = status;
124         for_each_set_bit(i, &acks, ARRAY_SIZE(max77665_irqs))
125                 handle_nested_irq(max77665->irq_base + i);
126         return acks ? IRQ_HANDLED : IRQ_NONE;
127 }
128
129 #ifdef CONFIG_PM_SLEEP
130 static int max77665_irq_set_wake(struct irq_data *data, unsigned int enable)
131 {
132         struct max77665 *max77665 = irq_data_get_irq_chip_data(data);
133
134         return irq_set_irq_wake(max77665->irq_base, enable);
135 }
136
137 #else
138 #define max77665_irq_set_wake NULL
139 #endif
140
141 static int __devinit max77665_irq_init(struct max77665 *max77665, int irq,
142         int irq_base)
143 {
144         int i, ret;
145
146         if (irq_base <= 0) {
147                 dev_err(max77665->dev, "IRQ base not set, int not supported\n");
148                 return -EINVAL;
149         }
150
151         mutex_init(&max77665->irq_lock);
152
153         ret = max77665_write(max77665->dev, MAX77665_I2C_SLAVE_PMIC,
154                                         MAX77665_INT_MSK, 0xFF);
155         if (ret < 0) {
156                 dev_err(max77665->dev,
157                         "Int mask reg write failed, e %d\n", ret);
158                 return ret;
159         }
160
161         max77665->irq_base = irq_base;
162         max77665->irq_chip.name = "max77665";
163         max77665->irq_chip.irq_mask = max77665_irq_mask;
164         max77665->irq_chip.irq_unmask = max77665_irq_unmask;
165         max77665->irq_chip.irq_bus_lock = max77665_irq_lock;
166         max77665->irq_chip.irq_bus_sync_unlock = max77665_irq_sync_unlock;
167         max77665->irq_chip.irq_set_wake = max77665_irq_set_wake;
168
169         for (i = 0; i < ARRAY_SIZE(max77665_irqs); i++) {
170                 int __irq = i + max77665->irq_base;
171                 irq_set_chip_data(__irq, max77665);
172                 irq_set_chip_and_handler(__irq, &max77665->irq_chip,
173                                          handle_simple_irq);
174                 irq_set_nested_thread(__irq, 1);
175 #ifdef CONFIG_ARM
176                 set_irq_flags(__irq, IRQF_VALID);
177 #endif
178         }
179
180         ret = request_threaded_irq(irq, NULL, max77665_irq, IRQF_ONESHOT,
181                                 "max77665", max77665);
182         if (ret < 0) {
183                 dev_err(max77665->dev, "Int registration failed, e %d\n", ret);
184                 return ret;
185         }
186
187         device_init_wakeup(max77665->dev, 1);
188         return ret;
189 }
190
191 static bool rd_wr_reg_pmic(struct device *dev, unsigned int reg)
192 {
193         switch (reg) {
194         case MAX77665_PMIC_FLASH:
195         case MAX77665_PMIC_PMIC:
196         case MAX77665_PMIC_CHARGER:
197                 return true;
198         default:
199                 dev_err(dev, "non-existing reg %s() reg 0x%x\n", __func__, reg);
200                 return false;
201         }
202 }
203
204 static bool rd_wr_reg_muic(struct device *dev, unsigned int reg)
205 {
206         switch (reg) {
207         case MAX77665_MUIC:
208                 return true;
209         default:
210                 dev_err(dev, "non-existing reg %s() reg 0x%x\n", __func__, reg);
211                 return false;
212         }
213 }
214
215 static bool rd_wr_reg_haptic(struct device *dev, unsigned int reg)
216 {
217         switch (reg) {
218         case MAX77665_HAPTIC:
219                 return true;
220         default:
221                 dev_err(dev, "non-existing reg %s() reg 0x%x\n", __func__, reg);
222                 return false;
223         }
224 }
225
226 static const struct regmap_config max77665_regmap_config[] = {
227         {
228                 .reg_bits = 8,
229                 .val_bits = 8,
230                 .max_register = 0xFF,
231                 .writeable_reg = rd_wr_reg_pmic,
232                 .readable_reg = rd_wr_reg_pmic,
233                 .cache_type = REGCACHE_RBTREE,
234         }, {
235                 .reg_bits = 8,
236                 .val_bits = 8,
237                 .max_register = 0x0E,
238                 .writeable_reg = rd_wr_reg_muic,
239                 .readable_reg = rd_wr_reg_muic,
240                 .cache_type = REGCACHE_RBTREE,
241         }, {
242                 .reg_bits = 8,
243                 .val_bits = 8,
244                 .max_register = 0x10,
245                 .writeable_reg = rd_wr_reg_haptic,
246                 .readable_reg = rd_wr_reg_haptic,
247                 .cache_type = REGCACHE_RBTREE,
248         },
249 };
250
251 static int __devinit max77665_i2c_probe(struct i2c_client *client,
252                                         const struct i2c_device_id *id)
253 {
254         struct max77665_platform_data *pdata = client->dev.platform_data;
255         struct max77665 *max77665;
256         struct i2c_client *slv_client;
257         int ret;
258         int i;
259
260         if (!pdata) {
261                 dev_err(&client->dev, "max77665 requires platform data\n");
262                 return -EINVAL;
263         }
264
265         max77665 = devm_kzalloc(&client->dev, sizeof(*max77665), GFP_KERNEL);
266         if (!max77665) {
267                 dev_err(&client->dev, "mem alloc for max77665 failed\n");
268                 return -ENOMEM;
269         }
270
271         max77665->dev = &client->dev;
272
273         for (i = 0; i < MAX77665_I2C_SLAVE_MAX; ++i) {
274                 slv_client = max77665->client[i];
275                 if (i == 0)
276                         slv_client = client;
277                 else
278                         slv_client = i2c_new_dummy(client->adapter,
279                                                 max77665_i2c_slave_address[i]);
280                 if (!slv_client) {
281                         dev_err(&client->dev, "can't attach client %d\n", i);
282                         ret = -ENOMEM;
283                         goto err_exit;
284                 }
285                 i2c_set_clientdata(slv_client, max77665);
286
287                 max77665->regmap[i] = devm_regmap_init_i2c(slv_client,
288                                         &max77665_regmap_config[i]);
289                 if (IS_ERR(max77665->regmap[i])) {
290                         ret = PTR_ERR(max77665->regmap[i]);
291                         dev_err(&client->dev,
292                                 "regmap %d init failed with err: %d\n", i, ret);
293                         goto err_exit;
294                 }
295         }
296
297         if (client->irq > 0)
298                 max77665_irq_init(max77665, client->irq, pdata->irq_base);
299
300         ret = mfd_add_devices(max77665->dev, -1, max77665s,
301                 ARRAY_SIZE(max77665s), NULL, 0);
302         if (ret) {
303                 dev_err(&client->dev, "add mfd devices failed with err: %d\n",
304                         ret);
305                 goto err_irq_exit;
306         }
307
308         return 0;
309
310 err_irq_exit:
311         if (client->irq > 0)
312                 free_irq(client->irq, max77665);
313 err_exit:
314         for (i = 0; i < MAX77665_I2C_SLAVE_MAX; ++i) {
315                 slv_client = max77665->client[i];
316                 if (slv_client && slv_client != client)
317                         i2c_unregister_device(slv_client);
318         }
319         return ret;
320 }
321
322 static int __devexit max77665_i2c_remove(struct i2c_client *client)
323 {
324         struct max77665 *max77665 = i2c_get_clientdata(client);
325         int i;
326         struct i2c_client *slv_client;
327
328         mfd_remove_devices(max77665->dev);
329         if (client->irq > 0)
330                 free_irq(client->irq, max77665);
331
332         for (i = 0; i < MAX77665_I2C_SLAVE_MAX; ++i) {
333                 slv_client = max77665->client[i];
334                 if (slv_client && slv_client != client)
335                         i2c_unregister_device(slv_client);
336         }
337
338         return 0;
339 }
340
341 static const struct i2c_device_id max77665_id_table[] = {
342         { "max77665", 0 },
343         { },
344 };
345 MODULE_DEVICE_TABLE(i2c, max77665_id_table);
346
347 static struct i2c_driver max77665_driver = {
348         .driver = {
349                 .name   = "max77665",
350                 .owner  = THIS_MODULE,
351         },
352         .probe          = max77665_i2c_probe,
353         .remove         = __devexit_p(max77665_i2c_remove),
354         .id_table       = max77665_id_table,
355 };
356
357 static int __init max77665_init(void)
358 {
359         return i2c_add_driver(&max77665_driver);
360 }
361 subsys_initcall(max77665_init);
362
363 static void __exit max77665_exit(void)
364 {
365         i2c_del_driver(&max77665_driver);
366 }
367 module_exit(max77665_exit);
368
369 MODULE_DESCRIPTION("MAXIM MAX77665 core driver");
370 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
371 MODULE_LICENSE("GPL v2");