?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
proc: use seq_puts()/seq_putc() where possible
[linux-2.6/next.git] / drivers / mfd / tps6586x.c
blobb4931ab349299e1205ebd70c9023a9bba344f366
1 /*
2 * Core driver for TI TPS6586x PMIC family
3 *
4 * Copyright (c) 2010 CompuLab Ltd.
5 * Mike Rapoport <mike@compulab.co.il>
6 *
7 * Based on da903x.c.
8 * Copyright (C) 2008 Compulab, Ltd.
9 * Mike Rapoport <mike@compulab.co.il>
10 * Copyright (C) 2006-2008 Marvell International Ltd.
11 * Eric Miao <eric.miao@marvell.com>
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License version 2 as
15 * published by the Free Software Foundation.
16 */
17
18 #include <linux/interrupt.h>
19 #include <linux/irq.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/mutex.h>
23 #include <linux/slab.h>
24 #include <linux/gpio.h>
25 #include <linux/i2c.h>
26
27 #include <linux/mfd/core.h>
28 #include <linux/mfd/tps6586x.h>
29
30 /* GPIO control registers */
31 #define TPS6586X_GPIOSET1 0x5d
32 #define TPS6586X_GPIOSET2 0x5e
33
34 /* interrupt control registers */
35 #define TPS6586X_INT_ACK1 0xb5
36 #define TPS6586X_INT_ACK2 0xb6
37 #define TPS6586X_INT_ACK3 0xb7
38 #define TPS6586X_INT_ACK4 0xb8
39
40 /* interrupt mask registers */
41 #define TPS6586X_INT_MASK1 0xb0
42 #define TPS6586X_INT_MASK2 0xb1
43 #define TPS6586X_INT_MASK3 0xb2
44 #define TPS6586X_INT_MASK4 0xb3
45 #define TPS6586X_INT_MASK5 0xb4
46
47 /* device id */
48 #define TPS6586X_VERSIONCRC 0xcd
49 #define TPS658621A_VERSIONCRC 0x15
50 #define TPS658621C_VERSIONCRC 0x2c
51
52 struct tps6586x_irq_data {
53 u8 mask_reg;
54 u8 mask_mask;
55 };
56
57 #define TPS6586X_IRQ(_reg, _mask) \
58 { \
59 .mask_reg = (_reg) - TPS6586X_INT_MASK1, \
60 .mask_mask = (_mask), \
61 }
62
63 static const struct tps6586x_irq_data tps6586x_irqs[] = {
64 [TPS6586X_INT_PLDO_0] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 0),
65 [TPS6586X_INT_PLDO_1] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 1),
66 [TPS6586X_INT_PLDO_2] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 2),
67 [TPS6586X_INT_PLDO_3] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 3),
68 [TPS6586X_INT_PLDO_4] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 4),
69 [TPS6586X_INT_PLDO_5] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 5),
70 [TPS6586X_INT_PLDO_6] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 6),
71 [TPS6586X_INT_PLDO_7] = TPS6586X_IRQ(TPS6586X_INT_MASK1, 1 << 7),
72 [TPS6586X_INT_COMP_DET] = TPS6586X_IRQ(TPS6586X_INT_MASK4, 1 << 0),
73 [TPS6586X_INT_ADC] = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 1),
74 [TPS6586X_INT_PLDO_8] = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 2),
75 [TPS6586X_INT_PLDO_9] = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 3),
76 [TPS6586X_INT_PSM_0] = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 4),
77 [TPS6586X_INT_PSM_1] = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 5),
78 [TPS6586X_INT_PSM_2] = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 6),
79 [TPS6586X_INT_PSM_3] = TPS6586X_IRQ(TPS6586X_INT_MASK2, 1 << 7),
80 [TPS6586X_INT_RTC_ALM1] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 4),
81 [TPS6586X_INT_ACUSB_OVP] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 0x03),
82 [TPS6586X_INT_USB_DET] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 2),
83 [TPS6586X_INT_AC_DET] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 3),
84 [TPS6586X_INT_BAT_DET] = TPS6586X_IRQ(TPS6586X_INT_MASK3, 1 << 0),
85 [TPS6586X_INT_CHG_STAT] = TPS6586X_IRQ(TPS6586X_INT_MASK4, 0xfc),
86 [TPS6586X_INT_CHG_TEMP] = TPS6586X_IRQ(TPS6586X_INT_MASK3, 0x06),
87 [TPS6586X_INT_PP] = TPS6586X_IRQ(TPS6586X_INT_MASK3, 0xf0),
88 [TPS6586X_INT_RESUME] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 5),
89 [TPS6586X_INT_LOW_SYS] = TPS6586X_IRQ(TPS6586X_INT_MASK5, 1 << 6),
90 [TPS6586X_INT_RTC_ALM2] = TPS6586X_IRQ(TPS6586X_INT_MASK4, 1 << 1),
91 };
92
93 struct tps6586x {
94 struct mutex lock;
95 struct device *dev;
96 struct i2c_client *client;
97
98 struct gpio_chip gpio;
99 struct irq_chip irq_chip;
100 struct mutex irq_lock;
101 int irq_base;
102 u32 irq_en;
103 u8 mask_cache[5];
104 u8 mask_reg[5];
105 };
106
107 static inline int __tps6586x_read(struct i2c_client *client,
108 int reg, uint8_t *val)
109 {
110 int ret;
111
112 ret = i2c_smbus_read_byte_data(client, reg);
113 if (ret < 0) {
114 dev_err(&client->dev, "failed reading at 0x%02x\n", reg);
115 return ret;
116 }
117
118 *val = (uint8_t)ret;
119
120 return 0;
121 }
122
123 static inline int __tps6586x_reads(struct i2c_client *client, int reg,
124 int len, uint8_t *val)
125 {
126 int ret;
127
128 ret = i2c_smbus_read_i2c_block_data(client, reg, len, val);
129 if (ret < 0) {
130 dev_err(&client->dev, "failed reading from 0x%02x\n", reg);
131 return ret;
132 }
133
134 return 0;
135 }
136
137 static inline int __tps6586x_write(struct i2c_client *client,
138 int reg, uint8_t val)
139 {
140 int ret;
141
142 ret = i2c_smbus_write_byte_data(client, reg, val);
143 if (ret < 0) {
144 dev_err(&client->dev, "failed writing 0x%02x to 0x%02x\n",
145 val, reg);
146 return ret;
147 }
148
149 return 0;
150 }
151
152 static inline int __tps6586x_writes(struct i2c_client *client, int reg,
153 int len, uint8_t *val)
154 {
155 int ret;
156
157 ret = i2c_smbus_write_i2c_block_data(client, reg, len, val);
158 if (ret < 0) {
159 dev_err(&client->dev, "failed writings to 0x%02x\n", reg);
160 return ret;
161 }
162
163 return 0;
164 }
165
166 int tps6586x_write(struct device *dev, int reg, uint8_t val)
167 {
168 return __tps6586x_write(to_i2c_client(dev), reg, val);
169 }
170 EXPORT_SYMBOL_GPL(tps6586x_write);
171
172 int tps6586x_writes(struct device *dev, int reg, int len, uint8_t *val)
173 {
174 return __tps6586x_writes(to_i2c_client(dev), reg, len, val);
175 }
176 EXPORT_SYMBOL_GPL(tps6586x_writes);
177
178 int tps6586x_read(struct device *dev, int reg, uint8_t *val)
179 {
180 return __tps6586x_read(to_i2c_client(dev), reg, val);
181 }
182 EXPORT_SYMBOL_GPL(tps6586x_read);
183
184 int tps6586x_reads(struct device *dev, int reg, int len, uint8_t *val)
185 {
186 return __tps6586x_reads(to_i2c_client(dev), reg, len, val);
187 }
188 EXPORT_SYMBOL_GPL(tps6586x_reads);
189
190 int tps6586x_set_bits(struct device *dev, int reg, uint8_t bit_mask)
191 {
192 struct tps6586x *tps6586x = dev_get_drvdata(dev);
193 uint8_t reg_val;
194 int ret = 0;
195
196 mutex_lock(&tps6586x->lock);
197
198 ret = __tps6586x_read(to_i2c_client(dev), reg, &reg_val);
199 if (ret)
200 goto out;
201
202 if ((reg_val & bit_mask) == 0) {
203 reg_val |= bit_mask;
204 ret = __tps6586x_write(to_i2c_client(dev), reg, reg_val);
205 }
206 out:
207 mutex_unlock(&tps6586x->lock);
208 return ret;
209 }
210 EXPORT_SYMBOL_GPL(tps6586x_set_bits);
211
212 int tps6586x_clr_bits(struct device *dev, int reg, uint8_t bit_mask)
213 {
214 struct tps6586x *tps6586x = dev_get_drvdata(dev);
215 uint8_t reg_val;
216 int ret = 0;
217
218 mutex_lock(&tps6586x->lock);
219
220 ret = __tps6586x_read(to_i2c_client(dev), reg, &reg_val);
221 if (ret)
222 goto out;
223
224 if (reg_val & bit_mask) {
225 reg_val &= ~bit_mask;
226 ret = __tps6586x_write(to_i2c_client(dev), reg, reg_val);
227 }
228 out:
229 mutex_unlock(&tps6586x->lock);
230 return ret;
231 }
232 EXPORT_SYMBOL_GPL(tps6586x_clr_bits);
233
234 int tps6586x_update(struct device *dev, int reg, uint8_t val, uint8_t mask)
235 {
236 struct tps6586x *tps6586x = dev_get_drvdata(dev);
237 uint8_t reg_val;
238 int ret = 0;
239
240 mutex_lock(&tps6586x->lock);
241
242 ret = __tps6586x_read(tps6586x->client, reg, &reg_val);
243 if (ret)
244 goto out;
245
246 if ((reg_val & mask) != val) {
247 reg_val = (reg_val & ~mask) | val;
248 ret = __tps6586x_write(tps6586x->client, reg, reg_val);
249 }
250 out:
251 mutex_unlock(&tps6586x->lock);
252 return ret;
253 }
254 EXPORT_SYMBOL_GPL(tps6586x_update);
255
256 static int tps6586x_gpio_get(struct gpio_chip *gc, unsigned offset)
257 {
258 struct tps6586x *tps6586x = container_of(gc, struct tps6586x, gpio);
259 uint8_t val;
260 int ret;
261
262 ret = __tps6586x_read(tps6586x->client, TPS6586X_GPIOSET2, &val);
263 if (ret)
264 return ret;
265
266 return !!(val & (1 << offset));
267 }
268
269
270 static void tps6586x_gpio_set(struct gpio_chip *chip, unsigned offset,
271 int value)
272 {
273 struct tps6586x *tps6586x = container_of(chip, struct tps6586x, gpio);
274
275 __tps6586x_write(tps6586x->client, TPS6586X_GPIOSET2,
276 value << offset);
277 }
278
279 static int tps6586x_gpio_output(struct gpio_chip *gc, unsigned offset,
280 int value)
281 {
282 struct tps6586x *tps6586x = container_of(gc, struct tps6586x, gpio);
283 uint8_t val, mask;
284
285 tps6586x_gpio_set(gc, offset, value);
286
287 val = 0x1 << (offset * 2);
288 mask = 0x3 << (offset * 2);
289
290 return tps6586x_update(tps6586x->dev, TPS6586X_GPIOSET1, val, mask);
291 }
292
293 static void tps6586x_gpio_init(struct tps6586x *tps6586x, int gpio_base)
294 {
295 int ret;
296
297 if (!gpio_base)
298 return;
299
300 tps6586x->gpio.owner = THIS_MODULE;
301 tps6586x->gpio.label = tps6586x->client->name;
302 tps6586x->gpio.dev = tps6586x->dev;
303 tps6586x->gpio.base = gpio_base;
304 tps6586x->gpio.ngpio = 4;
305 tps6586x->gpio.can_sleep = 1;
306
307 /* FIXME: add handling of GPIOs as dedicated inputs */
308 tps6586x->gpio.direction_output = tps6586x_gpio_output;
309 tps6586x->gpio.set = tps6586x_gpio_set;
310 tps6586x->gpio.get = tps6586x_gpio_get;
311
312 ret = gpiochip_add(&tps6586x->gpio);
313 if (ret)
314 dev_warn(tps6586x->dev, "GPIO registration failed: %d\n", ret);
315 }
316
317 static int __remove_subdev(struct device *dev, void *unused)
318 {
319 platform_device_unregister(to_platform_device(dev));
320 return 0;
321 }
322
323 static int tps6586x_remove_subdevs(struct tps6586x *tps6586x)
324 {
325 return device_for_each_child(tps6586x->dev, NULL, __remove_subdev);
326 }
327
328 static void tps6586x_irq_lock(unsigned int irq)
329 {
330 struct tps6586x *tps6586x = get_irq_chip_data(irq);
331
332 mutex_lock(&tps6586x->irq_lock);
333 }
334
335 static void tps6586x_irq_enable(unsigned int irq)
336 {
337 struct tps6586x *tps6586x = get_irq_chip_data(irq);
338 unsigned int __irq = irq - tps6586x->irq_base;
339 const struct tps6586x_irq_data *data = &tps6586x_irqs[__irq];
340
341 tps6586x->mask_reg[data->mask_reg] &= ~data->mask_mask;
342 tps6586x->irq_en |= (1 << __irq);
343 }
344
345 static void tps6586x_irq_disable(unsigned int irq)
346 {
347 struct tps6586x *tps6586x = get_irq_chip_data(irq);
348
349 unsigned int __irq = irq - tps6586x->irq_base;
350 const struct tps6586x_irq_data *data = &tps6586x_irqs[__irq];
351
352 tps6586x->mask_reg[data->mask_reg] |= data->mask_mask;
353 tps6586x->irq_en &= ~(1 << __irq);
354 }
355
356 static void tps6586x_irq_sync_unlock(unsigned int irq)
357 {
358 struct tps6586x *tps6586x = get_irq_chip_data(irq);
359 int i;
360
361 for (i = 0; i < ARRAY_SIZE(tps6586x->mask_reg); i++) {
362 if (tps6586x->mask_reg[i] != tps6586x->mask_cache[i]) {
363 if (!WARN_ON(tps6586x_write(tps6586x->dev,
364 TPS6586X_INT_MASK1 + i,
365 tps6586x->mask_reg[i])))
366 tps6586x->mask_cache[i] = tps6586x->mask_reg[i];
367 }
368 }
369
370 mutex_unlock(&tps6586x->irq_lock);
371 }
372
373 static irqreturn_t tps6586x_irq(int irq, void *data)
374 {
375 struct tps6586x *tps6586x = data;
376 u32 acks;
377 int ret = 0;
378
379 ret = tps6586x_reads(tps6586x->dev, TPS6586X_INT_ACK1,
380 sizeof(acks), (uint8_t *)&acks);
381
382 if (ret < 0) {
383 dev_err(tps6586x->dev, "failed to read interrupt status\n");
384 return IRQ_NONE;
385 }
386
387 acks = le32_to_cpu(acks);
388
389 while (acks) {
390 int i = __ffs(acks);
391
392 if (tps6586x->irq_en & (1 << i))
393 handle_nested_irq(tps6586x->irq_base + i);
394
395 acks &= ~(1 << i);
396 }
397
398 return IRQ_HANDLED;
399 }
400
401 static int __devinit tps6586x_irq_init(struct tps6586x *tps6586x, int irq,
402 int irq_base)
403 {
404 int i, ret;
405 u8 tmp[4];
406
407 if (!irq_base) {
408 dev_warn(tps6586x->dev, "No interrupt support on IRQ base\n");
409 return -EINVAL;
410 }
411
412 mutex_init(&tps6586x->irq_lock);
413 for (i = 0; i < 5; i++) {
414 tps6586x->mask_cache[i] = 0xff;
415 tps6586x->mask_reg[i] = 0xff;
416 tps6586x_write(tps6586x->dev, TPS6586X_INT_MASK1 + i, 0xff);
417 }
418
419 tps6586x_reads(tps6586x->dev, TPS6586X_INT_ACK1, sizeof(tmp), tmp);
420
421 tps6586x->irq_base = irq_base;
422
423 tps6586x->irq_chip.name = "tps6586x";
424 tps6586x->irq_chip.enable = tps6586x_irq_enable;
425 tps6586x->irq_chip.disable = tps6586x_irq_disable;
426 tps6586x->irq_chip.bus_lock = tps6586x_irq_lock;
427 tps6586x->irq_chip.bus_sync_unlock = tps6586x_irq_sync_unlock;
428
429 for (i = 0; i < ARRAY_SIZE(tps6586x_irqs); i++) {
430 int __irq = i + tps6586x->irq_base;
431 set_irq_chip_data(__irq, tps6586x);
432 set_irq_chip_and_handler(__irq, &tps6586x->irq_chip,
433 handle_simple_irq);
434 set_irq_nested_thread(__irq, 1);
435 #ifdef CONFIG_ARM
436 set_irq_flags(__irq, IRQF_VALID);
437 #endif
438 }
439
440 ret = request_threaded_irq(irq, NULL, tps6586x_irq, IRQF_ONESHOT,
441 "tps6586x", tps6586x);
442
443 if (!ret) {
444 device_init_wakeup(tps6586x->dev, 1);
445 enable_irq_wake(irq);
446 }
447
448 return ret;
449 }
450
451 static int __devinit tps6586x_add_subdevs(struct tps6586x *tps6586x,
452 struct tps6586x_platform_data *pdata)
453 {
454 struct tps6586x_subdev_info *subdev;
455 struct platform_device *pdev;
456 int i, ret = 0;
457
458 for (i = 0; i < pdata->num_subdevs; i++) {
459 subdev = &pdata->subdevs[i];
460
461 pdev = platform_device_alloc(subdev->name, subdev->id);
462 if (!pdev) {
463 ret = -ENOMEM;
464 goto failed;
465 }
466
467 pdev->dev.parent = tps6586x->dev;
468 pdev->dev.platform_data = subdev->platform_data;
469
470 ret = platform_device_add(pdev);
471 if (ret) {
472 platform_device_put(pdev);
473 goto failed;
474 }
475 }
476 return 0;
477
478 failed:
479 tps6586x_remove_subdevs(tps6586x);
480 return ret;
481 }
482
483 static int __devinit tps6586x_i2c_probe(struct i2c_client *client,
484 const struct i2c_device_id *id)
485 {
486 struct tps6586x_platform_data *pdata = client->dev.platform_data;
487 struct tps6586x *tps6586x;
488 int ret;
489
490 if (!pdata) {
491 dev_err(&client->dev, "tps6586x requires platform data\n");
492 return -ENOTSUPP;
493 }
494
495 ret = i2c_smbus_read_byte_data(client, TPS6586X_VERSIONCRC);
496 if (ret < 0) {
497 dev_err(&client->dev, "Chip ID read failed: %d\n", ret);
498 return -EIO;
499 }
500
501 if ((ret != TPS658621A_VERSIONCRC) &&
502 (ret != TPS658621C_VERSIONCRC)) {
503 dev_err(&client->dev, "Unsupported chip ID: %x\n", ret);
504 return -ENODEV;
505 }
506
507 tps6586x = kzalloc(sizeof(struct tps6586x), GFP_KERNEL);
508 if (tps6586x == NULL)
509 return -ENOMEM;
510
511 tps6586x->client = client;
512 tps6586x->dev = &client->dev;
513 i2c_set_clientdata(client, tps6586x);
514
515 mutex_init(&tps6586x->lock);
516
517 if (client->irq) {
518 ret = tps6586x_irq_init(tps6586x, client->irq,
519 pdata->irq_base);
520 if (ret) {
521 dev_err(&client->dev, "IRQ init failed: %d\n", ret);
522 goto err_irq_init;
523 }
524 }
525
526 ret = tps6586x_add_subdevs(tps6586x, pdata);
527 if (ret) {
528 dev_err(&client->dev, "add devices failed: %d\n", ret);
529 goto err_add_devs;
530 }
531
532 tps6586x_gpio_init(tps6586x, pdata->gpio_base);
533
534 return 0;
535
536 err_add_devs:
537 if (client->irq)
538 free_irq(client->irq, tps6586x);
539 err_irq_init:
540 kfree(tps6586x);
541 return ret;
542 }
543
544 static int __devexit tps6586x_i2c_remove(struct i2c_client *client)
545 {
546 struct tps6586x *tps6586x = i2c_get_clientdata(client);
547 struct tps6586x_platform_data *pdata = client->dev.platform_data;
548 int ret;
549
550 if (client->irq)
551 free_irq(client->irq, tps6586x);
552
553 if (pdata->gpio_base) {
554 ret = gpiochip_remove(&tps6586x->gpio);
555 if (ret)
556 dev_err(&client->dev, "Can't remove gpio chip: %d\n",
557 ret);
558 }
559
560 tps6586x_remove_subdevs(tps6586x);
561 kfree(tps6586x);
562 return 0;
563 }
564
565 static const struct i2c_device_id tps6586x_id_table[] = {
566 { "tps6586x", 0 },
567 { },
568 };
569 MODULE_DEVICE_TABLE(i2c, tps6586x_id_table);
570
571 static struct i2c_driver tps6586x_driver = {
572 .driver = {
573 .name = "tps6586x",
574 .owner = THIS_MODULE,
575 },
576 .probe = tps6586x_i2c_probe,
577 .remove = __devexit_p(tps6586x_i2c_remove),
578 .id_table = tps6586x_id_table,
579 };
580
581 static int __init tps6586x_init(void)
582 {
583 return i2c_add_driver(&tps6586x_driver);
584 }
585 subsys_initcall(tps6586x_init);
586
587 static void __exit tps6586x_exit(void)
588 {
589 i2c_del_driver(&tps6586x_driver);
590 }
591 module_exit(tps6586x_exit);
592
593 MODULE_DESCRIPTION("TPS6586X core driver");
594 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
595 MODULE_LICENSE("GPL");
596
linux-next