mfd: Convert AB3500 to new irq_ APIs
[linux-2.6.git] / drivers / mfd / ab3550-core.c
1 /*
2  * Copyright (C) 2007-2010 ST-Ericsson
3  * License terms: GNU General Public License (GPL) version 2
4  * Low-level core for exclusive access to the AB3550 IC on the I2C bus
5  * and some basic chip-configuration.
6  * Author: Bengt Jonsson <bengt.g.jonsson@stericsson.com>
7  * Author: Mattias Nilsson <mattias.i.nilsson@stericsson.com>
8  * Author: Mattias Wallin <mattias.wallin@stericsson.com>
9  * Author: Rickard Andersson <rickard.andersson@stericsson.com>
10  */
11
12 #include <linux/i2c.h>
13 #include <linux/mutex.h>
14 #include <linux/err.h>
15 #include <linux/platform_device.h>
16 #include <linux/slab.h>
17 #include <linux/device.h>
18 #include <linux/irq.h>
19 #include <linux/interrupt.h>
20 #include <linux/random.h>
21 #include <linux/workqueue.h>
22 #include <linux/debugfs.h>
23 #include <linux/seq_file.h>
24 #include <linux/uaccess.h>
25 #include <linux/mfd/abx500.h>
26 #include <linux/list.h>
27 #include <linux/bitops.h>
28 #include <linux/spinlock.h>
29 #include <linux/mfd/core.h>
30
31 #define AB3550_NAME_STRING "ab3550"
32 #define AB3550_ID_FORMAT_STRING "AB3550 %s"
33 #define AB3550_NUM_BANKS 2
34 #define AB3550_NUM_EVENT_REG 5
35
36 /* These are the only registers inside AB3550 used in this main file */
37
38 /* Chip ID register */
39 #define AB3550_CID_REG           0x20
40
41 /* Interrupt event registers */
42 #define AB3550_EVENT_BANK        0
43 #define AB3550_EVENT_REG         0x22
44
45 /* Read/write operation values. */
46 #define AB3550_PERM_RD (0x01)
47 #define AB3550_PERM_WR (0x02)
48
49 /* Read/write permissions. */
50 #define AB3550_PERM_RO (AB3550_PERM_RD)
51 #define AB3550_PERM_RW (AB3550_PERM_RD | AB3550_PERM_WR)
52
53 /**
54  * struct ab3550
55  * @access_mutex: lock out concurrent accesses to the AB registers
56  * @i2c_client: I2C client for this chip
57  * @chip_name: name of this chip variant
58  * @chip_id: 8 bit chip ID for this chip variant
59  * @mask_work: a worker for writing to mask registers
60  * @event_lock: a lock to protect the event_mask
61  * @event_mask: a local copy of the mask event registers
62  * @startup_events: a copy of the first reading of the event registers
63  * @startup_events_read: whether the first events have been read
64  */
65 struct ab3550 {
66         struct mutex access_mutex;
67         struct i2c_client *i2c_client[AB3550_NUM_BANKS];
68         char chip_name[32];
69         u8 chip_id;
70         struct work_struct mask_work;
71         spinlock_t event_lock;
72         u8 event_mask[AB3550_NUM_EVENT_REG];
73         u8 startup_events[AB3550_NUM_EVENT_REG];
74         bool startup_events_read;
75 #ifdef CONFIG_DEBUG_FS
76         unsigned int debug_bank;
77         unsigned int debug_address;
78 #endif
79 };
80
81 /**
82  * struct ab3550_reg_range
83  * @first: the first address of the range
84  * @last: the last address of the range
85  * @perm: access permissions for the range
86  */
87 struct ab3550_reg_range {
88         u8 first;
89         u8 last;
90         u8 perm;
91 };
92
93 /**
94  * struct ab3550_reg_ranges
95  * @count: the number of ranges in the list
96  * @range: the list of register ranges
97  */
98 struct ab3550_reg_ranges {
99         u8 count;
100         const struct ab3550_reg_range *range;
101 };
102
103 /*
104  * Permissible register ranges for reading and writing per device and bank.
105  *
106  * The ranges must be listed in increasing address order, and no overlaps are
107  * allowed. It is assumed that write permission implies read permission
108  * (i.e. only RO and RW permissions should be used).  Ranges with write
109  * permission must not be split up.
110  */
111
112 #define NO_RANGE {.count = 0, .range = NULL,}
113
114 static struct
115 ab3550_reg_ranges ab3550_reg_ranges[AB3550_NUM_DEVICES][AB3550_NUM_BANKS] = {
116         [AB3550_DEVID_DAC] = {
117                 NO_RANGE,
118                 {
119                         .count = 2,
120                         .range = (struct ab3550_reg_range[]) {
121                                 {
122                                         .first = 0xb0,
123                                         .last = 0xba,
124                                         .perm = AB3550_PERM_RW,
125                                 },
126                                 {
127                                         .first = 0xbc,
128                                         .last = 0xc3,
129                                         .perm = AB3550_PERM_RW,
130                                 },
131                         },
132                 },
133         },
134         [AB3550_DEVID_LEDS] = {
135                 NO_RANGE,
136                 {
137                         .count = 2,
138                         .range = (struct ab3550_reg_range[]) {
139                                 {
140                                         .first = 0x5a,
141                                         .last = 0x88,
142                                         .perm = AB3550_PERM_RW,
143                                 },
144                                 {
145                                         .first = 0x8a,
146                                         .last = 0xad,
147                                         .perm = AB3550_PERM_RW,
148                                 },
149                         }
150                 },
151         },
152         [AB3550_DEVID_POWER] = {
153                 {
154                         .count = 1,
155                         .range = (struct ab3550_reg_range[]) {
156                                 {
157                                         .first = 0x21,
158                                         .last = 0x21,
159                                         .perm = AB3550_PERM_RO,
160                                 },
161                         }
162                 },
163                 NO_RANGE,
164         },
165         [AB3550_DEVID_REGULATORS] = {
166                 {
167                         .count = 1,
168                         .range = (struct ab3550_reg_range[]) {
169                                 {
170                                         .first = 0x69,
171                                         .last = 0xa3,
172                                         .perm = AB3550_PERM_RW,
173                                 },
174                         }
175                 },
176                 {
177                         .count = 1,
178                         .range = (struct ab3550_reg_range[]) {
179                                 {
180                                         .first = 0x14,
181                                         .last = 0x16,
182                                         .perm = AB3550_PERM_RW,
183                                 },
184                         }
185                 },
186         },
187         [AB3550_DEVID_SIM] = {
188                 {
189                         .count = 1,
190                         .range = (struct ab3550_reg_range[]) {
191                                 {
192                                         .first = 0x21,
193                                         .last = 0x21,
194                                         .perm = AB3550_PERM_RO,
195                                 },
196                         }
197                 },
198                 {
199                         .count = 1,
200                         .range = (struct ab3550_reg_range[]) {
201                                 {
202                                         .first = 0x14,
203                                         .last = 0x17,
204                                         .perm = AB3550_PERM_RW,
205                                 },
206                         }
207
208                 },
209         },
210         [AB3550_DEVID_UART] = {
211                 NO_RANGE,
212                 NO_RANGE,
213         },
214         [AB3550_DEVID_RTC] = {
215                 {
216                         .count = 1,
217                         .range = (struct ab3550_reg_range[]) {
218                                 {
219                                         .first = 0x00,
220                                         .last = 0x0c,
221                                         .perm = AB3550_PERM_RW,
222                                 },
223                         }
224                 },
225                 NO_RANGE,
226         },
227         [AB3550_DEVID_CHARGER] = {
228                 {
229                         .count = 2,
230                         .range = (struct ab3550_reg_range[]) {
231                                 {
232                                         .first = 0x10,
233                                         .last = 0x1a,
234                                         .perm = AB3550_PERM_RW,
235                                 },
236                                 {
237                                         .first = 0x21,
238                                         .last = 0x21,
239                                         .perm = AB3550_PERM_RO,
240                                 },
241                         }
242                 },
243                 NO_RANGE,
244         },
245         [AB3550_DEVID_ADC] = {
246                 NO_RANGE,
247                 {
248                         .count = 1,
249                         .range = (struct ab3550_reg_range[]) {
250                                 {
251                                         .first = 0x20,
252                                         .last = 0x56,
253                                         .perm = AB3550_PERM_RW,
254                                 },
255
256                         }
257                 },
258         },
259         [AB3550_DEVID_FUELGAUGE] = {
260                 {
261                         .count = 1,
262                         .range = (struct ab3550_reg_range[]) {
263                                 {
264                                         .first = 0x21,
265                                         .last = 0x21,
266                                         .perm = AB3550_PERM_RO,
267                                 },
268                         }
269                 },
270                 {
271                         .count = 1,
272                         .range = (struct ab3550_reg_range[]) {
273                                 {
274                                         .first = 0x00,
275                                         .last = 0x0e,
276                                         .perm = AB3550_PERM_RW,
277                                 },
278                         }
279                 },
280         },
281         [AB3550_DEVID_VIBRATOR] = {
282                 NO_RANGE,
283                 {
284                         .count = 1,
285                         .range = (struct ab3550_reg_range[]) {
286                                 {
287                                         .first = 0x10,
288                                         .last = 0x13,
289                                         .perm = AB3550_PERM_RW,
290                                 },
291
292                         }
293                 },
294         },
295         [AB3550_DEVID_CODEC] = {
296                 {
297                         .count = 2,
298                         .range = (struct ab3550_reg_range[]) {
299                                 {
300                                         .first = 0x31,
301                                         .last = 0x63,
302                                         .perm = AB3550_PERM_RW,
303                                 },
304                                 {
305                                         .first = 0x65,
306                                         .last = 0x68,
307                                         .perm = AB3550_PERM_RW,
308                                 },
309                         }
310                 },
311                 NO_RANGE,
312         },
313 };
314
315 static struct mfd_cell ab3550_devs[AB3550_NUM_DEVICES] = {
316         [AB3550_DEVID_DAC] = {
317                 .name = "ab3550-dac",
318                 .id = AB3550_DEVID_DAC,
319                 .num_resources = 0,
320         },
321         [AB3550_DEVID_LEDS] = {
322                 .name = "ab3550-leds",
323                 .id = AB3550_DEVID_LEDS,
324         },
325         [AB3550_DEVID_POWER] = {
326                 .name = "ab3550-power",
327                 .id = AB3550_DEVID_POWER,
328         },
329         [AB3550_DEVID_REGULATORS] = {
330                 .name = "ab3550-regulators",
331                 .id = AB3550_DEVID_REGULATORS,
332         },
333         [AB3550_DEVID_SIM] = {
334                 .name = "ab3550-sim",
335                 .id = AB3550_DEVID_SIM,
336         },
337         [AB3550_DEVID_UART] = {
338                 .name = "ab3550-uart",
339                 .id = AB3550_DEVID_UART,
340         },
341         [AB3550_DEVID_RTC] = {
342                 .name = "ab3550-rtc",
343                 .id = AB3550_DEVID_RTC,
344         },
345         [AB3550_DEVID_CHARGER] = {
346                 .name = "ab3550-charger",
347                 .id = AB3550_DEVID_CHARGER,
348         },
349         [AB3550_DEVID_ADC] = {
350                 .name = "ab3550-adc",
351                 .id = AB3550_DEVID_ADC,
352                 .num_resources = 10,
353                 .resources = (struct resource[]) {
354                         {
355                                 .name = "TRIGGER-0",
356                                 .flags = IORESOURCE_IRQ,
357                                 .start = 16,
358                                 .end = 16,
359                         },
360                         {
361                                 .name = "TRIGGER-1",
362                                 .flags = IORESOURCE_IRQ,
363                                 .start = 17,
364                                 .end = 17,
365                         },
366                         {
367                                 .name = "TRIGGER-2",
368                                 .flags = IORESOURCE_IRQ,
369                                 .start = 18,
370                                 .end = 18,
371                         },
372                         {
373                                 .name = "TRIGGER-3",
374                                 .flags = IORESOURCE_IRQ,
375                                 .start = 19,
376                                 .end = 19,
377                         },
378                         {
379                                 .name = "TRIGGER-4",
380                                 .flags = IORESOURCE_IRQ,
381                                 .start = 20,
382                                 .end = 20,
383                         },
384                         {
385                                 .name = "TRIGGER-5",
386                                 .flags = IORESOURCE_IRQ,
387                                 .start = 21,
388                                 .end = 21,
389                         },
390                         {
391                                 .name = "TRIGGER-6",
392                                 .flags = IORESOURCE_IRQ,
393                                 .start = 22,
394                                 .end = 22,
395                         },
396                         {
397                                 .name = "TRIGGER-7",
398                                 .flags = IORESOURCE_IRQ,
399                                 .start = 23,
400                                 .end = 23,
401                         },
402                         {
403                                 .name = "TRIGGER-VBAT-TXON",
404                                 .flags = IORESOURCE_IRQ,
405                                 .start = 13,
406                                 .end = 13,
407                         },
408                         {
409                                 .name = "TRIGGER-VBAT",
410                                 .flags = IORESOURCE_IRQ,
411                                 .start = 12,
412                                 .end = 12,
413                         },
414                 },
415         },
416         [AB3550_DEVID_FUELGAUGE] = {
417                 .name = "ab3550-fuelgauge",
418                 .id = AB3550_DEVID_FUELGAUGE,
419         },
420         [AB3550_DEVID_VIBRATOR] = {
421                 .name = "ab3550-vibrator",
422                 .id = AB3550_DEVID_VIBRATOR,
423         },
424         [AB3550_DEVID_CODEC] = {
425                 .name = "ab3550-codec",
426                 .id = AB3550_DEVID_CODEC,
427         },
428 };
429
430 /*
431  * I2C transactions with error messages.
432  */
433 static int ab3550_i2c_master_send(struct ab3550 *ab, u8 bank, u8 *data,
434         u8 count)
435 {
436         int err;
437
438         err = i2c_master_send(ab->i2c_client[bank], data, count);
439         if (err < 0) {
440                 dev_err(&ab->i2c_client[0]->dev, "send error: %d\n", err);
441                 return err;
442         }
443         return 0;
444 }
445
446 static int ab3550_i2c_master_recv(struct ab3550 *ab, u8 bank, u8 *data,
447         u8 count)
448 {
449         int err;
450
451         err = i2c_master_recv(ab->i2c_client[bank], data, count);
452         if (err < 0) {
453                 dev_err(&ab->i2c_client[0]->dev, "receive error: %d\n", err);
454                 return err;
455         }
456         return 0;
457 }
458
459 /*
460  * Functionality for getting/setting register values.
461  */
462 static int get_register_interruptible(struct ab3550 *ab, u8 bank, u8 reg,
463         u8 *value)
464 {
465         int err;
466
467         err = mutex_lock_interruptible(&ab->access_mutex);
468         if (err)
469                 return err;
470
471         err = ab3550_i2c_master_send(ab, bank, &reg, 1);
472         if (!err)
473                 err = ab3550_i2c_master_recv(ab, bank, value, 1);
474
475         mutex_unlock(&ab->access_mutex);
476         return err;
477 }
478
479 static int get_register_page_interruptible(struct ab3550 *ab, u8 bank,
480         u8 first_reg, u8 *regvals, u8 numregs)
481 {
482         int err;
483
484         err = mutex_lock_interruptible(&ab->access_mutex);
485         if (err)
486                 return err;
487
488         err = ab3550_i2c_master_send(ab, bank, &first_reg, 1);
489         if (!err)
490                 err = ab3550_i2c_master_recv(ab, bank, regvals, numregs);
491
492         mutex_unlock(&ab->access_mutex);
493         return err;
494 }
495
496 static int mask_and_set_register_interruptible(struct ab3550 *ab, u8 bank,
497         u8 reg, u8 bitmask, u8 bitvalues)
498 {
499         int err = 0;
500
501         if (likely(bitmask)) {
502                 u8 reg_bits[2] = {reg, 0};
503
504                 err = mutex_lock_interruptible(&ab->access_mutex);
505                 if (err)
506                         return err;
507
508                 if (bitmask == 0xFF) /* No need to read in this case. */
509                         reg_bits[1] = bitvalues;
510                 else { /* Read and modify the register value. */
511                         u8 bits;
512
513                         err = ab3550_i2c_master_send(ab, bank, &reg, 1);
514                         if (err)
515                                 goto unlock_and_return;
516                         err = ab3550_i2c_master_recv(ab, bank, &bits, 1);
517                         if (err)
518                                 goto unlock_and_return;
519                         reg_bits[1] = ((~bitmask & bits) |
520                                 (bitmask & bitvalues));
521                 }
522                 /* Write the new value. */
523                 err = ab3550_i2c_master_send(ab, bank, reg_bits, 2);
524 unlock_and_return:
525                 mutex_unlock(&ab->access_mutex);
526         }
527         return err;
528 }
529
530 /*
531  * Read/write permission checking functions.
532  */
533 static bool page_write_allowed(const struct ab3550_reg_ranges *ranges,
534         u8 first_reg, u8 last_reg)
535 {
536         u8 i;
537
538         if (last_reg < first_reg)
539                 return false;
540
541         for (i = 0; i < ranges->count; i++) {
542                 if (first_reg < ranges->range[i].first)
543                         break;
544                 if ((last_reg <= ranges->range[i].last) &&
545                         (ranges->range[i].perm & AB3550_PERM_WR))
546                         return true;
547         }
548         return false;
549 }
550
551 static bool reg_write_allowed(const struct ab3550_reg_ranges *ranges, u8 reg)
552 {
553         return page_write_allowed(ranges, reg, reg);
554 }
555
556 static bool page_read_allowed(const struct ab3550_reg_ranges *ranges,
557         u8 first_reg, u8 last_reg)
558 {
559         u8 i;
560
561         if (last_reg < first_reg)
562                 return false;
563         /* Find the range (if it exists in the list) that includes first_reg. */
564         for (i = 0; i < ranges->count; i++) {
565                 if (first_reg < ranges->range[i].first)
566                         return false;
567                 if (first_reg <= ranges->range[i].last)
568                         break;
569         }
570         /* Make sure that the entire range up to and including last_reg is
571          * readable. This may span several of the ranges in the list.
572          */
573         while ((i < ranges->count) &&
574                 (ranges->range[i].perm & AB3550_PERM_RD)) {
575                 if (last_reg <= ranges->range[i].last)
576                         return true;
577                 if ((++i >= ranges->count) ||
578                         (ranges->range[i].first !=
579                          (ranges->range[i - 1].last + 1))) {
580                         break;
581                 }
582         }
583         return false;
584 }
585
586 static bool reg_read_allowed(const struct ab3550_reg_ranges *ranges, u8 reg)
587 {
588         return page_read_allowed(ranges, reg, reg);
589 }
590
591 /*
592  * The register access functionality.
593  */
594 static int ab3550_get_chip_id(struct device *dev)
595 {
596         struct ab3550 *ab = dev_get_drvdata(dev->parent);
597         return (int)ab->chip_id;
598 }
599
600 static int ab3550_mask_and_set_register_interruptible(struct device *dev,
601         u8 bank, u8 reg, u8 bitmask, u8 bitvalues)
602 {
603         struct ab3550 *ab;
604         struct platform_device *pdev = to_platform_device(dev);
605
606         if ((AB3550_NUM_BANKS <= bank) ||
607                 !reg_write_allowed(&ab3550_reg_ranges[pdev->id][bank], reg))
608                 return -EINVAL;
609
610         ab = dev_get_drvdata(dev->parent);
611         return mask_and_set_register_interruptible(ab, bank, reg,
612                 bitmask, bitvalues);
613 }
614
615 static int ab3550_set_register_interruptible(struct device *dev, u8 bank,
616         u8 reg, u8 value)
617 {
618         return ab3550_mask_and_set_register_interruptible(dev, bank, reg, 0xFF,
619                 value);
620 }
621
622 static int ab3550_get_register_interruptible(struct device *dev, u8 bank,
623         u8 reg, u8 *value)
624 {
625         struct ab3550 *ab;
626         struct platform_device *pdev = to_platform_device(dev);
627
628         if ((AB3550_NUM_BANKS <= bank) ||
629                 !reg_read_allowed(&ab3550_reg_ranges[pdev->id][bank], reg))
630                 return -EINVAL;
631
632         ab = dev_get_drvdata(dev->parent);
633         return get_register_interruptible(ab, bank, reg, value);
634 }
635
636 static int ab3550_get_register_page_interruptible(struct device *dev, u8 bank,
637         u8 first_reg, u8 *regvals, u8 numregs)
638 {
639         struct ab3550 *ab;
640         struct platform_device *pdev = to_platform_device(dev);
641
642         if ((AB3550_NUM_BANKS <= bank) ||
643                 !page_read_allowed(&ab3550_reg_ranges[pdev->id][bank],
644                         first_reg, (first_reg + numregs - 1)))
645                 return -EINVAL;
646
647         ab = dev_get_drvdata(dev->parent);
648         return get_register_page_interruptible(ab, bank, first_reg, regvals,
649                 numregs);
650 }
651
652 static int ab3550_event_registers_startup_state_get(struct device *dev,
653         u8 *event)
654 {
655         struct ab3550 *ab;
656
657         ab = dev_get_drvdata(dev->parent);
658         if (!ab->startup_events_read)
659                 return -EAGAIN; /* Try again later */
660
661         memcpy(event, ab->startup_events, AB3550_NUM_EVENT_REG);
662         return 0;
663 }
664
665 static int ab3550_startup_irq_enabled(struct device *dev, unsigned int irq)
666 {
667         struct ab3550 *ab;
668         struct ab3550_platform_data *plf_data;
669         bool val;
670
671         ab = get_irq_chip_data(irq);
672         plf_data = ab->i2c_client[0]->dev.platform_data;
673         irq -= plf_data->irq.base;
674         val = ((ab->startup_events[irq / 8] & BIT(irq % 8)) != 0);
675
676         return val;
677 }
678
679 static struct abx500_ops ab3550_ops = {
680         .get_chip_id = ab3550_get_chip_id,
681         .get_register = ab3550_get_register_interruptible,
682         .set_register = ab3550_set_register_interruptible,
683         .get_register_page = ab3550_get_register_page_interruptible,
684         .set_register_page = NULL,
685         .mask_and_set_register = ab3550_mask_and_set_register_interruptible,
686         .event_registers_startup_state_get =
687                 ab3550_event_registers_startup_state_get,
688         .startup_irq_enabled = ab3550_startup_irq_enabled,
689 };
690
691 static irqreturn_t ab3550_irq_handler(int irq, void *data)
692 {
693         struct ab3550 *ab = data;
694         int err;
695         unsigned int i;
696         u8 e[AB3550_NUM_EVENT_REG];
697         u8 *events;
698         unsigned long flags;
699
700         events = (ab->startup_events_read ? e : ab->startup_events);
701
702         err = get_register_page_interruptible(ab, AB3550_EVENT_BANK,
703                 AB3550_EVENT_REG, events, AB3550_NUM_EVENT_REG);
704         if (err)
705                 goto err_event_rd;
706
707         if (!ab->startup_events_read) {
708                 dev_info(&ab->i2c_client[0]->dev,
709                         "startup events 0x%x,0x%x,0x%x,0x%x,0x%x\n",
710                         ab->startup_events[0], ab->startup_events[1],
711                         ab->startup_events[2], ab->startup_events[3],
712                         ab->startup_events[4]);
713                 ab->startup_events_read = true;
714                 goto out;
715         }
716
717         /* The two highest bits in event[4] are not used. */
718         events[4] &= 0x3f;
719
720         spin_lock_irqsave(&ab->event_lock, flags);
721         for (i = 0; i < AB3550_NUM_EVENT_REG; i++)
722                 events[i] &= ~ab->event_mask[i];
723         spin_unlock_irqrestore(&ab->event_lock, flags);
724
725         for (i = 0; i < AB3550_NUM_EVENT_REG; i++) {
726                 u8 bit;
727                 u8 event_reg;
728
729                 dev_dbg(&ab->i2c_client[0]->dev, "IRQ Event[%d]: 0x%2x\n",
730                         i, events[i]);
731
732                 event_reg = events[i];
733                 for (bit = 0; event_reg; bit++, event_reg /= 2) {
734                         if (event_reg % 2) {
735                                 unsigned int irq;
736                                 struct ab3550_platform_data *plf_data;
737
738                                 plf_data = ab->i2c_client[0]->dev.platform_data;
739                                 irq = plf_data->irq.base + (i * 8) + bit;
740                                 handle_nested_irq(irq);
741                         }
742                 }
743         }
744 out:
745         return IRQ_HANDLED;
746
747 err_event_rd:
748         dev_dbg(&ab->i2c_client[0]->dev, "error reading event registers\n");
749         return IRQ_HANDLED;
750 }
751
752 #ifdef CONFIG_DEBUG_FS
753 static struct ab3550_reg_ranges debug_ranges[AB3550_NUM_BANKS] = {
754         {
755                 .count = 6,
756                 .range = (struct ab3550_reg_range[]) {
757                         {
758                                 .first = 0x00,
759                                 .last = 0x0e,
760                         },
761                         {
762                                 .first = 0x10,
763                                 .last = 0x1a,
764                         },
765                         {
766                                 .first = 0x1e,
767                                 .last = 0x4f,
768                         },
769                         {
770                                 .first = 0x51,
771                                 .last = 0x63,
772                         },
773                         {
774                                 .first = 0x65,
775                                 .last = 0xa3,
776                         },
777                         {
778                                 .first = 0xa5,
779                                 .last = 0xa8,
780                         },
781                 }
782         },
783         {
784                 .count = 8,
785                 .range = (struct ab3550_reg_range[]) {
786                         {
787                                 .first = 0x00,
788                                 .last = 0x0e,
789                         },
790                         {
791                                 .first = 0x10,
792                                 .last = 0x17,
793                         },
794                         {
795                                 .first = 0x1a,
796                                 .last = 0x1c,
797                         },
798                         {
799                                 .first = 0x20,
800                                 .last = 0x56,
801                         },
802                         {
803                                 .first = 0x5a,
804                                 .last = 0x88,
805                         },
806                         {
807                                 .first = 0x8a,
808                                 .last = 0xad,
809                         },
810                         {
811                                 .first = 0xb0,
812                                 .last = 0xba,
813                         },
814                         {
815                                 .first = 0xbc,
816                                 .last = 0xc3,
817                         },
818                 }
819         },
820 };
821
822 static int ab3550_registers_print(struct seq_file *s, void *p)
823 {
824         struct ab3550 *ab = s->private;
825         int bank;
826
827         seq_printf(s, AB3550_NAME_STRING " register values:\n");
828
829         for (bank = 0; bank < AB3550_NUM_BANKS; bank++) {
830                 unsigned int i;
831
832                 seq_printf(s, " bank %d:\n", bank);
833                 for (i = 0; i < debug_ranges[bank].count; i++) {
834                         u8 reg;
835
836                         for (reg = debug_ranges[bank].range[i].first;
837                                 reg <= debug_ranges[bank].range[i].last;
838                                 reg++) {
839                                 u8 value;
840
841                                 get_register_interruptible(ab, bank, reg,
842                                         &value);
843                                 seq_printf(s, "  [%d/0x%02X]: 0x%02X\n", bank,
844                                         reg, value);
845                         }
846                 }
847         }
848         return 0;
849 }
850
851 static int ab3550_registers_open(struct inode *inode, struct file *file)
852 {
853         return single_open(file, ab3550_registers_print, inode->i_private);
854 }
855
856 static const struct file_operations ab3550_registers_fops = {
857         .open = ab3550_registers_open,
858         .read = seq_read,
859         .llseek = seq_lseek,
860         .release = single_release,
861         .owner = THIS_MODULE,
862 };
863
864 static int ab3550_bank_print(struct seq_file *s, void *p)
865 {
866         struct ab3550 *ab = s->private;
867
868         seq_printf(s, "%d\n", ab->debug_bank);
869         return 0;
870 }
871
872 static int ab3550_bank_open(struct inode *inode, struct file *file)
873 {
874         return single_open(file, ab3550_bank_print, inode->i_private);
875 }
876
877 static ssize_t ab3550_bank_write(struct file *file,
878         const char __user *user_buf,
879         size_t count, loff_t *ppos)
880 {
881         struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
882         char buf[32];
883         int buf_size;
884         unsigned long user_bank;
885         int err;
886
887         /* Get userspace string and assure termination */
888         buf_size = min(count, (sizeof(buf) - 1));
889         if (copy_from_user(buf, user_buf, buf_size))
890                 return -EFAULT;
891         buf[buf_size] = 0;
892
893         err = strict_strtoul(buf, 0, &user_bank);
894         if (err)
895                 return -EINVAL;
896
897         if (user_bank >= AB3550_NUM_BANKS) {
898                 dev_err(&ab->i2c_client[0]->dev,
899                         "debugfs error input > number of banks\n");
900                 return -EINVAL;
901         }
902
903         ab->debug_bank = user_bank;
904
905         return buf_size;
906 }
907
908 static int ab3550_address_print(struct seq_file *s, void *p)
909 {
910         struct ab3550 *ab = s->private;
911
912         seq_printf(s, "0x%02X\n", ab->debug_address);
913         return 0;
914 }
915
916 static int ab3550_address_open(struct inode *inode, struct file *file)
917 {
918         return single_open(file, ab3550_address_print, inode->i_private);
919 }
920
921 static ssize_t ab3550_address_write(struct file *file,
922         const char __user *user_buf,
923         size_t count, loff_t *ppos)
924 {
925         struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
926         char buf[32];
927         int buf_size;
928         unsigned long user_address;
929         int err;
930
931         /* Get userspace string and assure termination */
932         buf_size = min(count, (sizeof(buf) - 1));
933         if (copy_from_user(buf, user_buf, buf_size))
934                 return -EFAULT;
935         buf[buf_size] = 0;
936
937         err = strict_strtoul(buf, 0, &user_address);
938         if (err)
939                 return -EINVAL;
940         if (user_address > 0xff) {
941                 dev_err(&ab->i2c_client[0]->dev,
942                         "debugfs error input > 0xff\n");
943                 return -EINVAL;
944         }
945         ab->debug_address = user_address;
946         return buf_size;
947 }
948
949 static int ab3550_val_print(struct seq_file *s, void *p)
950 {
951         struct ab3550 *ab = s->private;
952         int err;
953         u8 regvalue;
954
955         err = get_register_interruptible(ab, (u8)ab->debug_bank,
956                 (u8)ab->debug_address, &regvalue);
957         if (err)
958                 return -EINVAL;
959         seq_printf(s, "0x%02X\n", regvalue);
960
961         return 0;
962 }
963
964 static int ab3550_val_open(struct inode *inode, struct file *file)
965 {
966         return single_open(file, ab3550_val_print, inode->i_private);
967 }
968
969 static ssize_t ab3550_val_write(struct file *file,
970         const char __user *user_buf,
971         size_t count, loff_t *ppos)
972 {
973         struct ab3550 *ab = ((struct seq_file *)(file->private_data))->private;
974         char buf[32];
975         int buf_size;
976         unsigned long user_val;
977         int err;
978         u8 regvalue;
979
980         /* Get userspace string and assure termination */
981         buf_size = min(count, (sizeof(buf)-1));
982         if (copy_from_user(buf, user_buf, buf_size))
983                 return -EFAULT;
984         buf[buf_size] = 0;
985
986         err = strict_strtoul(buf, 0, &user_val);
987         if (err)
988                 return -EINVAL;
989         if (user_val > 0xff) {
990                 dev_err(&ab->i2c_client[0]->dev,
991                         "debugfs error input > 0xff\n");
992                 return -EINVAL;
993         }
994         err = mask_and_set_register_interruptible(
995                 ab, (u8)ab->debug_bank,
996                 (u8)ab->debug_address, 0xFF, (u8)user_val);
997         if (err)
998                 return -EINVAL;
999
1000         get_register_interruptible(ab, (u8)ab->debug_bank,
1001                 (u8)ab->debug_address, &regvalue);
1002         if (err)
1003                 return -EINVAL;
1004
1005         return buf_size;
1006 }
1007
1008 static const struct file_operations ab3550_bank_fops = {
1009         .open = ab3550_bank_open,
1010         .write = ab3550_bank_write,
1011         .read = seq_read,
1012         .llseek = seq_lseek,
1013         .release = single_release,
1014         .owner = THIS_MODULE,
1015 };
1016
1017 static const struct file_operations ab3550_address_fops = {
1018         .open = ab3550_address_open,
1019         .write = ab3550_address_write,
1020         .read = seq_read,
1021         .llseek = seq_lseek,
1022         .release = single_release,
1023         .owner = THIS_MODULE,
1024 };
1025
1026 static const struct file_operations ab3550_val_fops = {
1027         .open = ab3550_val_open,
1028         .write = ab3550_val_write,
1029         .read = seq_read,
1030         .llseek = seq_lseek,
1031         .release = single_release,
1032         .owner = THIS_MODULE,
1033 };
1034
1035 static struct dentry *ab3550_dir;
1036 static struct dentry *ab3550_reg_file;
1037 static struct dentry *ab3550_bank_file;
1038 static struct dentry *ab3550_address_file;
1039 static struct dentry *ab3550_val_file;
1040
1041 static inline void ab3550_setup_debugfs(struct ab3550 *ab)
1042 {
1043         ab->debug_bank = 0;
1044         ab->debug_address = 0x00;
1045
1046         ab3550_dir = debugfs_create_dir(AB3550_NAME_STRING, NULL);
1047         if (!ab3550_dir)
1048                 goto exit_no_debugfs;
1049
1050         ab3550_reg_file = debugfs_create_file("all-registers",
1051                 S_IRUGO, ab3550_dir, ab, &ab3550_registers_fops);
1052         if (!ab3550_reg_file)
1053                 goto exit_destroy_dir;
1054
1055         ab3550_bank_file = debugfs_create_file("register-bank",
1056                 (S_IRUGO | S_IWUGO), ab3550_dir, ab, &ab3550_bank_fops);
1057         if (!ab3550_bank_file)
1058                 goto exit_destroy_reg;
1059
1060         ab3550_address_file = debugfs_create_file("register-address",
1061                 (S_IRUGO | S_IWUGO), ab3550_dir, ab, &ab3550_address_fops);
1062         if (!ab3550_address_file)
1063                 goto exit_destroy_bank;
1064
1065         ab3550_val_file = debugfs_create_file("register-value",
1066                 (S_IRUGO | S_IWUGO), ab3550_dir, ab, &ab3550_val_fops);
1067         if (!ab3550_val_file)
1068                 goto exit_destroy_address;
1069
1070         return;
1071
1072 exit_destroy_address:
1073         debugfs_remove(ab3550_address_file);
1074 exit_destroy_bank:
1075         debugfs_remove(ab3550_bank_file);
1076 exit_destroy_reg:
1077         debugfs_remove(ab3550_reg_file);
1078 exit_destroy_dir:
1079         debugfs_remove(ab3550_dir);
1080 exit_no_debugfs:
1081         dev_err(&ab->i2c_client[0]->dev, "failed to create debugfs entries.\n");
1082         return;
1083 }
1084
1085 static inline void ab3550_remove_debugfs(void)
1086 {
1087         debugfs_remove(ab3550_val_file);
1088         debugfs_remove(ab3550_address_file);
1089         debugfs_remove(ab3550_bank_file);
1090         debugfs_remove(ab3550_reg_file);
1091         debugfs_remove(ab3550_dir);
1092 }
1093
1094 #else /* !CONFIG_DEBUG_FS */
1095 static inline void ab3550_setup_debugfs(struct ab3550 *ab)
1096 {
1097 }
1098 static inline void ab3550_remove_debugfs(void)
1099 {
1100 }
1101 #endif
1102
1103 /*
1104  * Basic set-up, datastructure creation/destruction and I2C interface.
1105  * This sets up a default config in the AB3550 chip so that it
1106  * will work as expected.
1107  */
1108 static int __init ab3550_setup(struct ab3550 *ab)
1109 {
1110         int err = 0;
1111         int i;
1112         struct ab3550_platform_data *plf_data;
1113         struct abx500_init_settings *settings;
1114
1115         plf_data = ab->i2c_client[0]->dev.platform_data;
1116         settings = plf_data->init_settings;
1117
1118         for (i = 0; i < plf_data->init_settings_sz; i++) {
1119                 err = mask_and_set_register_interruptible(ab,
1120                         settings[i].bank,
1121                         settings[i].reg,
1122                         0xFF, settings[i].setting);
1123                 if (err)
1124                         goto exit_no_setup;
1125
1126                 /* If event mask register update the event mask in ab3550 */
1127                 if ((settings[i].bank == 0) &&
1128                         (AB3550_IMR1 <= settings[i].reg) &&
1129                         (settings[i].reg <= AB3550_IMR5)) {
1130                         ab->event_mask[settings[i].reg - AB3550_IMR1] =
1131                                 settings[i].setting;
1132                 }
1133         }
1134 exit_no_setup:
1135         return err;
1136 }
1137
1138 static void ab3550_mask_work(struct work_struct *work)
1139 {
1140         struct ab3550 *ab = container_of(work, struct ab3550, mask_work);
1141         int i;
1142         unsigned long flags;
1143         u8 mask[AB3550_NUM_EVENT_REG];
1144
1145         spin_lock_irqsave(&ab->event_lock, flags);
1146         for (i = 0; i < AB3550_NUM_EVENT_REG; i++)
1147                 mask[i] = ab->event_mask[i];
1148         spin_unlock_irqrestore(&ab->event_lock, flags);
1149
1150         for (i = 0; i < AB3550_NUM_EVENT_REG; i++) {
1151                 int err;
1152
1153                 err = mask_and_set_register_interruptible(ab, 0,
1154                         (AB3550_IMR1 + i), ~0, mask[i]);
1155                 if (err)
1156                         dev_err(&ab->i2c_client[0]->dev,
1157                                 "ab3550_mask_work failed 0x%x,0x%x\n",
1158                                 (AB3550_IMR1 + i), mask[i]);
1159         }
1160 }
1161
1162 static void ab3550_mask(struct irq_data *data)
1163 {
1164         unsigned long flags;
1165         struct ab3550 *ab;
1166         struct ab3550_platform_data *plf_data;
1167         int irq;
1168
1169         ab = irq_data_get_irq_chip_data(data);
1170         plf_data = ab->i2c_client[0]->dev.platform_data;
1171         irq = data->irq - plf_data->irq.base;
1172
1173         spin_lock_irqsave(&ab->event_lock, flags);
1174         ab->event_mask[irq / 8] |= BIT(irq % 8);
1175         spin_unlock_irqrestore(&ab->event_lock, flags);
1176
1177         schedule_work(&ab->mask_work);
1178 }
1179
1180 static void ab3550_unmask(struct irq_data *data)
1181 {
1182         unsigned long flags;
1183         struct ab3550 *ab;
1184         struct ab3550_platform_data *plf_data;
1185         int irq;
1186
1187         ab = irq_data_get_irq_chip_data(data);
1188         plf_data = ab->i2c_client[0]->dev.platform_data;
1189         irq = data->irq - plf_data->irq.base;
1190
1191         spin_lock_irqsave(&ab->event_lock, flags);
1192         ab->event_mask[irq / 8] &= ~BIT(irq % 8);
1193         spin_unlock_irqrestore(&ab->event_lock, flags);
1194
1195         schedule_work(&ab->mask_work);
1196 }
1197
1198 static void noop(struct irq_data *data)
1199 {
1200 }
1201
1202 static struct irq_chip ab3550_irq_chip = {
1203         .name           = "ab3550-core", /* Keep the same name as the request */
1204         .irq_disable    = ab3550_mask, /* No default to mask in chip.c */
1205         .irq_ack        = noop,
1206         .irq_mask       = ab3550_mask,
1207         .irq_unmask     = ab3550_unmask,
1208 };
1209
1210 struct ab_family_id {
1211         u8      id;
1212         char    *name;
1213 };
1214
1215 static const struct ab_family_id ids[] __initdata = {
1216         /* AB3550 */
1217         {
1218                 .id = AB3550_P1A,
1219                 .name = "P1A"
1220         },
1221         /* Terminator */
1222         {
1223                 .id = 0x00,
1224         }
1225 };
1226
1227 static int __init ab3550_probe(struct i2c_client *client,
1228         const struct i2c_device_id *id)
1229 {
1230         struct ab3550 *ab;
1231         struct ab3550_platform_data *ab3550_plf_data =
1232                 client->dev.platform_data;
1233         int err;
1234         int i;
1235         int num_i2c_clients = 0;
1236
1237         ab = kzalloc(sizeof(struct ab3550), GFP_KERNEL);
1238         if (!ab) {
1239                 dev_err(&client->dev,
1240                         "could not allocate " AB3550_NAME_STRING " device\n");
1241                 return -ENOMEM;
1242         }
1243
1244         /* Initialize data structure */
1245         mutex_init(&ab->access_mutex);
1246         spin_lock_init(&ab->event_lock);
1247         ab->i2c_client[0] = client;
1248
1249         i2c_set_clientdata(client, ab);
1250
1251         /* Read chip ID register */
1252         err = get_register_interruptible(ab, 0, AB3550_CID_REG, &ab->chip_id);
1253         if (err) {
1254                 dev_err(&client->dev, "could not communicate with the analog "
1255                         "baseband chip\n");
1256                 goto exit_no_detect;
1257         }
1258
1259         for (i = 0; ids[i].id != 0x0; i++) {
1260                 if (ids[i].id == ab->chip_id) {
1261                         snprintf(&ab->chip_name[0], sizeof(ab->chip_name) - 1,
1262                                 AB3550_ID_FORMAT_STRING, ids[i].name);
1263                         break;
1264                 }
1265         }
1266
1267         if (ids[i].id == 0x0) {
1268                 dev_err(&client->dev, "unknown analog baseband chip id: 0x%x\n",
1269                         ab->chip_id);
1270                 dev_err(&client->dev, "driver not started!\n");
1271                 goto exit_no_detect;
1272         }
1273
1274         dev_info(&client->dev, "detected AB chip: %s\n", &ab->chip_name[0]);
1275
1276         /* Attach other dummy I2C clients. */
1277         while (++num_i2c_clients < AB3550_NUM_BANKS) {
1278                 ab->i2c_client[num_i2c_clients] =
1279                         i2c_new_dummy(client->adapter,
1280                                 (client->addr + num_i2c_clients));
1281                 if (!ab->i2c_client[num_i2c_clients]) {
1282                         err = -ENOMEM;
1283                         goto exit_no_dummy_client;
1284                 }
1285                 strlcpy(ab->i2c_client[num_i2c_clients]->name, id->name,
1286                         sizeof(ab->i2c_client[num_i2c_clients]->name));
1287         }
1288
1289         err = ab3550_setup(ab);
1290         if (err)
1291                 goto exit_no_setup;
1292
1293         INIT_WORK(&ab->mask_work, ab3550_mask_work);
1294
1295         for (i = 0; i < ab3550_plf_data->irq.count; i++) {
1296                 unsigned int irq;
1297
1298                 irq = ab3550_plf_data->irq.base + i;
1299                 set_irq_chip_data(irq, ab);
1300                 set_irq_chip_and_handler(irq, &ab3550_irq_chip,
1301                         handle_simple_irq);
1302                 set_irq_nested_thread(irq, 1);
1303 #ifdef CONFIG_ARM
1304                 set_irq_flags(irq, IRQF_VALID);
1305 #else
1306                 set_irq_noprobe(irq);
1307 #endif
1308         }
1309
1310         err = request_threaded_irq(client->irq, NULL, ab3550_irq_handler,
1311                 IRQF_ONESHOT, "ab3550-core", ab);
1312         /* This real unpredictable IRQ is of course sampled for entropy */
1313         rand_initialize_irq(client->irq);
1314
1315         if (err)
1316                 goto exit_no_irq;
1317
1318         err = abx500_register_ops(&client->dev, &ab3550_ops);
1319         if (err)
1320                 goto exit_no_ops;
1321
1322         /* Set up and register the platform devices. */
1323         for (i = 0; i < AB3550_NUM_DEVICES; i++) {
1324                 ab3550_devs[i].platform_data = ab3550_plf_data->dev_data[i];
1325                 ab3550_devs[i].data_size = ab3550_plf_data->dev_data_sz[i];
1326         }
1327
1328         err = mfd_add_devices(&client->dev, 0, ab3550_devs,
1329                 ARRAY_SIZE(ab3550_devs), NULL,
1330                 ab3550_plf_data->irq.base);
1331
1332         ab3550_setup_debugfs(ab);
1333
1334         return 0;
1335
1336 exit_no_ops:
1337 exit_no_irq:
1338 exit_no_setup:
1339 exit_no_dummy_client:
1340         /* Unregister the dummy i2c clients. */
1341         while (--num_i2c_clients)
1342                 i2c_unregister_device(ab->i2c_client[num_i2c_clients]);
1343 exit_no_detect:
1344         kfree(ab);
1345         return err;
1346 }
1347
1348 static int __exit ab3550_remove(struct i2c_client *client)
1349 {
1350         struct ab3550 *ab = i2c_get_clientdata(client);
1351         int num_i2c_clients = AB3550_NUM_BANKS;
1352
1353         mfd_remove_devices(&client->dev);
1354         ab3550_remove_debugfs();
1355
1356         while (--num_i2c_clients)
1357                 i2c_unregister_device(ab->i2c_client[num_i2c_clients]);
1358
1359         /*
1360          * At this point, all subscribers should have unregistered
1361          * their notifiers so deactivate IRQ
1362          */
1363         free_irq(client->irq, ab);
1364         kfree(ab);
1365         return 0;
1366 }
1367
1368 static const struct i2c_device_id ab3550_id[] = {
1369         {AB3550_NAME_STRING, 0},
1370         {}
1371 };
1372 MODULE_DEVICE_TABLE(i2c, ab3550_id);
1373
1374 static struct i2c_driver ab3550_driver = {
1375         .driver = {
1376                 .name   = AB3550_NAME_STRING,
1377                 .owner  = THIS_MODULE,
1378         },
1379         .id_table       = ab3550_id,
1380         .probe          = ab3550_probe,
1381         .remove         = __exit_p(ab3550_remove),
1382 };
1383
1384 static int __init ab3550_i2c_init(void)
1385 {
1386         return i2c_add_driver(&ab3550_driver);
1387 }
1388
1389 static void __exit ab3550_i2c_exit(void)
1390 {
1391         i2c_del_driver(&ab3550_driver);
1392 }
1393
1394 subsys_initcall(ab3550_i2c_init);
1395 module_exit(ab3550_i2c_exit);
1396
1397 MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
1398 MODULE_DESCRIPTION("AB3550 core driver");
1399 MODULE_LICENSE("GPL");