← Back to branch summary

~ubuntu-branches/ubuntu/trusty/linux-armadaxp/trusty

« back to all changes in this revision

Viewing changes to drivers/mfd/ab3550-core.c

  • Committer: Package Import Robot
  • Author(s): Michael Casadevall, Bryan Wu, Dann Frazier, Michael Casadeall
  • Date: 2012-03-10 15:00:54 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120310150054-flugb39zon8vvgwe
Tags: 3.2.0-1600.1
[ Bryan Wu ]
* UBUNTU: import debian/debian.env and debian.armadaxp

[ Dann Frazier ]
* ARM: Armada XP: remove trailing '/' in dirnames in mvRules.mk

[ Michael Casadeall ]
* tools: add some tools for Marvell Armada XP processor
* kernel: timer tick hacking from Marvell
* kernel: Sheeva Errata: add delay on Sheeva when powering down
* net: add Marvell NFP netfilter
* net: socket and skb modifications made by Marvell
* miscdevice: add minor IDs for some Marvell Armada drivers
* fs: introduce memory pool for splice()
* video: EDID detection updates from Marvell Armada XP patchset
* video: backlight: add Marvell Dove LCD backlight driver
* video: display: add THS8200 display driver
* video: framebuffer: add Marvell Dove and Armada XP processor onchip LCD controller driver
* usbtest: add Interrupt transfer testing by Marvell Armada XP code
* usb: ehci: add support for Marvell EHCI controler
* tty/serial: 8250: add support for Marvell Armada XP processor and DeviceTree work
* rtc: add support for Marvell Armada XP onchip RTC controller
* net: pppoe: add Marvell ethernet NFP hook in PPPoE networking driver
* mtd: nand: add support for Marvell Armada XP Nand Flash Controller
* mtd: maps: add Marvell Armada XP specific map driver
* mmc: add support for Marvell Armada XP MMC/SD host controller
* i2c: add support for Marvell Armada XP onchip i2c bus controller
* hwmon: add Kconfig option for Armada XP onchip thermal sensor driver
* dmaengine: add Net DMA support for splice and update Marvell XOR DMA engine driver
* ata: add support for Marvell Armada XP SATA controller and update some quirks
* ARM: add Marvell Armada XP machine to mach-types
* ARM: oprofile: add support for Marvell PJ4B core
* ARM: mm: more ARMv6 switches for Marvell Armada XP
* ARM: remove static declaration to allow compilation
* ARM: alignment access fault trick
* ARM: mm: skip some fault fixing when run on NONE SMP ARMv6 mode during early abort event
* ARM: mm: add Marvell Sheeva CPU Architecture for PJ4B
* ARM: introduce optimized copy operation for Marvell Armada XP
* ARM: SAUCE: hardware breakpoint trick for Marvell Armada XP
* ARM: big endian and little endian tricks for Marvell Armada XP
* ARM: SAUCE: Add Marvell Armada XP build rules to arch/arm/kernel/Makefile
* ARM: vfp: add special handling for Marvell Armada XP
* ARM: add support for Marvell U-Boot
* ARM: add mv_controller_num for ARM PCI drivers
* ARM: add support for local PMUs, general SMP tweaks and cache flushing
* ARM: add Marvell device identifies in glue-proc.h
* ARM: add IPC driver support for Marvell platforms
* ARM: add DMA mapping for Marvell platforms
* ARM: add Sheeva errata and PJ4B code for booting
* ARM: update Kconfig and Makefile to include Marvell Armada XP platforms
* ARM: Armada XP: import LSP from Marvell for Armada XP 3.2 kernel enablement

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 = irq_get_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_IWUSR), 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_IWUSR), 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_IWUSR), 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
 
                irq_set_chip_data(irq, ab);
1300
 
                irq_set_chip_and_handler(irq, &ab3550_irq_chip,
1301
 
                                         handle_simple_irq);
1302
 
                irq_set_nested_thread(irq, 1);
1303
 
#ifdef CONFIG_ARM
1304
 
                set_irq_flags(irq, IRQF_VALID);
1305
 
#else
1306
 
                irq_set_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].pdata_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");