tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * Copyright (C) ST-Ericsson SA 2010
3 *
4 * License Terms: GNU General Public License v2
5 * Author: Srinidhi Kasagar <srinidhi.kasagar@stericsson.com>
6 * Author: Rabin Vincent <rabin.vincent@stericsson.com>
7 * Author: Mattias Wallin <mattias.wallin@stericsson.com>
8 */
9
10#include <linux/kernel.h>
11#include <linux/slab.h>
12#include <linux/init.h>
13#include <linux/irq.h>
14#include <linux/irqdomain.h>
15#include <linux/delay.h>
16#include <linux/interrupt.h>
17#include <linux/module.h>
18#include <linux/platform_device.h>
19#include <linux/mfd/core.h>
20#include <linux/mfd/abx500.h>
21#include <linux/mfd/abx500/ab8500.h>
22#include <linux/mfd/abx500/ab8500-bm.h>
23#include <linux/mfd/dbx500-prcmu.h>
24#include <linux/regulator/ab8500.h>
25#include <linux/of.h>
26#include <linux/of_device.h>
27
28/*
29 * Interrupt register offsets
30 * Bank : 0x0E
31 */
32#define AB8500_IT_SOURCE1_REG 0x00
33#define AB8500_IT_SOURCE2_REG 0x01
34#define AB8500_IT_SOURCE3_REG 0x02
35#define AB8500_IT_SOURCE4_REG 0x03
36#define AB8500_IT_SOURCE5_REG 0x04
37#define AB8500_IT_SOURCE6_REG 0x05
38#define AB8500_IT_SOURCE7_REG 0x06
39#define AB8500_IT_SOURCE8_REG 0x07
40#define AB9540_IT_SOURCE13_REG 0x0C
41#define AB8500_IT_SOURCE19_REG 0x12
42#define AB8500_IT_SOURCE20_REG 0x13
43#define AB8500_IT_SOURCE21_REG 0x14
44#define AB8500_IT_SOURCE22_REG 0x15
45#define AB8500_IT_SOURCE23_REG 0x16
46#define AB8500_IT_SOURCE24_REG 0x17
47
48/*
49 * latch registers
50 */
51#define AB8500_IT_LATCH1_REG 0x20
52#define AB8500_IT_LATCH2_REG 0x21
53#define AB8500_IT_LATCH3_REG 0x22
54#define AB8500_IT_LATCH4_REG 0x23
55#define AB8500_IT_LATCH5_REG 0x24
56#define AB8500_IT_LATCH6_REG 0x25
57#define AB8500_IT_LATCH7_REG 0x26
58#define AB8500_IT_LATCH8_REG 0x27
59#define AB8500_IT_LATCH9_REG 0x28
60#define AB8500_IT_LATCH10_REG 0x29
61#define AB8500_IT_LATCH12_REG 0x2B
62#define AB9540_IT_LATCH13_REG 0x2C
63#define AB8500_IT_LATCH19_REG 0x32
64#define AB8500_IT_LATCH20_REG 0x33
65#define AB8500_IT_LATCH21_REG 0x34
66#define AB8500_IT_LATCH22_REG 0x35
67#define AB8500_IT_LATCH23_REG 0x36
68#define AB8500_IT_LATCH24_REG 0x37
69
70/*
71 * mask registers
72 */
73
74#define AB8500_IT_MASK1_REG 0x40
75#define AB8500_IT_MASK2_REG 0x41
76#define AB8500_IT_MASK3_REG 0x42
77#define AB8500_IT_MASK4_REG 0x43
78#define AB8500_IT_MASK5_REG 0x44
79#define AB8500_IT_MASK6_REG 0x45
80#define AB8500_IT_MASK7_REG 0x46
81#define AB8500_IT_MASK8_REG 0x47
82#define AB8500_IT_MASK9_REG 0x48
83#define AB8500_IT_MASK10_REG 0x49
84#define AB8500_IT_MASK11_REG 0x4A
85#define AB8500_IT_MASK12_REG 0x4B
86#define AB8500_IT_MASK13_REG 0x4C
87#define AB8500_IT_MASK14_REG 0x4D
88#define AB8500_IT_MASK15_REG 0x4E
89#define AB8500_IT_MASK16_REG 0x4F
90#define AB8500_IT_MASK17_REG 0x50
91#define AB8500_IT_MASK18_REG 0x51
92#define AB8500_IT_MASK19_REG 0x52
93#define AB8500_IT_MASK20_REG 0x53
94#define AB8500_IT_MASK21_REG 0x54
95#define AB8500_IT_MASK22_REG 0x55
96#define AB8500_IT_MASK23_REG 0x56
97#define AB8500_IT_MASK24_REG 0x57
98
99/*
100 * latch hierarchy registers
101 */
102#define AB8500_IT_LATCHHIER1_REG 0x60
103#define AB8500_IT_LATCHHIER2_REG 0x61
104#define AB8500_IT_LATCHHIER3_REG 0x62
105
106#define AB8500_IT_LATCHHIER_NUM 3
107
108#define AB8500_REV_REG 0x80
109#define AB8500_IC_NAME_REG 0x82
110#define AB8500_SWITCH_OFF_STATUS 0x00
111
112#define AB8500_TURN_ON_STATUS 0x00
113
114static bool no_bm; /* No battery management */
115module_param(no_bm, bool, S_IRUGO);
116
117#define AB9540_MODEM_CTRL2_REG 0x23
118#define AB9540_MODEM_CTRL2_SWDBBRSTN_BIT BIT(2)
119
120/*
121 * Map interrupt numbers to the LATCH and MASK register offsets, Interrupt
122 * numbers are indexed into this array with (num / 8). The interupts are
123 * defined in linux/mfd/ab8500.h
124 *
125 * This is one off from the register names, i.e. AB8500_IT_MASK1_REG is at
126 * offset 0.
127 */
128/* AB8500 support */
129static const int ab8500_irq_regoffset[AB8500_NUM_IRQ_REGS] = {
130 0, 1, 2, 3, 4, 6, 7, 8, 9, 11, 18, 19, 20, 21,
131};
132
133/* AB9540 support */
134static const int ab9540_irq_regoffset[AB9540_NUM_IRQ_REGS] = {
135 0, 1, 2, 3, 4, 6, 7, 8, 9, 11, 18, 19, 20, 21, 12, 13, 24,
136};
137
138static const char ab8500_version_str[][7] = {
139 [AB8500_VERSION_AB8500] = "AB8500",
140 [AB8500_VERSION_AB8505] = "AB8505",
141 [AB8500_VERSION_AB9540] = "AB9540",
142 [AB8500_VERSION_AB8540] = "AB8540",
143};
144
145static int ab8500_prcmu_write(struct ab8500 *ab8500, u16 addr, u8 data)
146{
147 int ret;
148
149 ret = prcmu_abb_write((u8)(addr >> 8), (u8)(addr & 0xFF), &data, 1);
150 if (ret < 0)
151 dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
152 return ret;
153}
154
155static int ab8500_prcmu_write_masked(struct ab8500 *ab8500, u16 addr, u8 mask,
156 u8 data)
157{
158 int ret;
159
160 ret = prcmu_abb_write_masked((u8)(addr >> 8), (u8)(addr & 0xFF), &data,
161 &mask, 1);
162 if (ret < 0)
163 dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
164 return ret;
165}
166
167static int ab8500_prcmu_read(struct ab8500 *ab8500, u16 addr)
168{
169 int ret;
170 u8 data;
171
172 ret = prcmu_abb_read((u8)(addr >> 8), (u8)(addr & 0xFF), &data, 1);
173 if (ret < 0) {
174 dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
175 return ret;
176 }
177 return (int)data;
178}
179
180static int ab8500_get_chip_id(struct device *dev)
181{
182 struct ab8500 *ab8500;
183
184 if (!dev)
185 return -EINVAL;
186 ab8500 = dev_get_drvdata(dev->parent);
187 return ab8500 ? (int)ab8500->chip_id : -EINVAL;
188}
189
190static int set_register_interruptible(struct ab8500 *ab8500, u8 bank,
191 u8 reg, u8 data)
192{
193 int ret;
194 /*
195 * Put the u8 bank and u8 register together into a an u16.
196 * The bank on higher 8 bits and register in lower 8 bits.
197 * */
198 u16 addr = ((u16)bank) << 8 | reg;
199
200 dev_vdbg(ab8500->dev, "wr: addr %#x <= %#x\n", addr, data);
201
202 mutex_lock(&ab8500->lock);
203
204 ret = ab8500->write(ab8500, addr, data);
205 if (ret < 0)
206 dev_err(ab8500->dev, "failed to write reg %#x: %d\n",
207 addr, ret);
208 mutex_unlock(&ab8500->lock);
209
210 return ret;
211}
212
213static int ab8500_set_register(struct device *dev, u8 bank,
214 u8 reg, u8 value)
215{
216 int ret;
217 struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
218
219 atomic_inc(&ab8500->transfer_ongoing);
220 ret = set_register_interruptible(ab8500, bank, reg, value);
221 atomic_dec(&ab8500->transfer_ongoing);
222 return ret;
223}
224
225static int get_register_interruptible(struct ab8500 *ab8500, u8 bank,
226 u8 reg, u8 *value)
227{
228 int ret;
229 /* put the u8 bank and u8 reg together into a an u16.
230 * bank on higher 8 bits and reg in lower */
231 u16 addr = ((u16)bank) << 8 | reg;
232
233 mutex_lock(&ab8500->lock);
234
235 ret = ab8500->read(ab8500, addr);
236 if (ret < 0)
237 dev_err(ab8500->dev, "failed to read reg %#x: %d\n",
238 addr, ret);
239 else
240 *value = ret;
241
242 mutex_unlock(&ab8500->lock);
243 dev_vdbg(ab8500->dev, "rd: addr %#x => data %#x\n", addr, ret);
244
245 return ret;
246}
247
248static int ab8500_get_register(struct device *dev, u8 bank,
249 u8 reg, u8 *value)
250{
251 int ret;
252 struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
253
254 atomic_inc(&ab8500->transfer_ongoing);
255 ret = get_register_interruptible(ab8500, bank, reg, value);
256 atomic_dec(&ab8500->transfer_ongoing);
257 return ret;
258}
259
260static int mask_and_set_register_interruptible(struct ab8500 *ab8500, u8 bank,
261 u8 reg, u8 bitmask, u8 bitvalues)
262{
263 int ret;
264 /* put the u8 bank and u8 reg together into a an u16.
265 * bank on higher 8 bits and reg in lower */
266 u16 addr = ((u16)bank) << 8 | reg;
267
268 mutex_lock(&ab8500->lock);
269
270 if (ab8500->write_masked == NULL) {
271 u8 data;
272
273 ret = ab8500->read(ab8500, addr);
274 if (ret < 0) {
275 dev_err(ab8500->dev, "failed to read reg %#x: %d\n",
276 addr, ret);
277 goto out;
278 }
279
280 data = (u8)ret;
281 data = (~bitmask & data) | (bitmask & bitvalues);
282
283 ret = ab8500->write(ab8500, addr, data);
284 if (ret < 0)
285 dev_err(ab8500->dev, "failed to write reg %#x: %d\n",
286 addr, ret);
287
288 dev_vdbg(ab8500->dev, "mask: addr %#x => data %#x\n", addr,
289 data);
290 goto out;
291 }
292 ret = ab8500->write_masked(ab8500, addr, bitmask, bitvalues);
293 if (ret < 0)
294 dev_err(ab8500->dev, "failed to modify reg %#x: %d\n", addr,
295 ret);
296out:
297 mutex_unlock(&ab8500->lock);
298 return ret;
299}
300
301static int ab8500_mask_and_set_register(struct device *dev,
302 u8 bank, u8 reg, u8 bitmask, u8 bitvalues)
303{
304 int ret;
305 struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
306
307 atomic_inc(&ab8500->transfer_ongoing);
308 ret= mask_and_set_register_interruptible(ab8500, bank, reg,
309 bitmask, bitvalues);
310 atomic_dec(&ab8500->transfer_ongoing);
311 return ret;
312}
313
314static struct abx500_ops ab8500_ops = {
315 .get_chip_id = ab8500_get_chip_id,
316 .get_register = ab8500_get_register,
317 .set_register = ab8500_set_register,
318 .get_register_page = NULL,
319 .set_register_page = NULL,
320 .mask_and_set_register = ab8500_mask_and_set_register,
321 .event_registers_startup_state_get = NULL,
322 .startup_irq_enabled = NULL,
323 .dump_all_banks = ab8500_dump_all_banks,
324};
325
326static void ab8500_irq_lock(struct irq_data *data)
327{
328 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
329
330 mutex_lock(&ab8500->irq_lock);
331 atomic_inc(&ab8500->transfer_ongoing);
332}
333
334static void ab8500_irq_sync_unlock(struct irq_data *data)
335{
336 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
337 int i;
338
339 for (i = 0; i < ab8500->mask_size; i++) {
340 u8 old = ab8500->oldmask[i];
341 u8 new = ab8500->mask[i];
342 int reg;
343
344 if (new == old)
345 continue;
346
347 /*
348 * Interrupt register 12 doesn't exist prior to AB8500 version
349 * 2.0
350 */
351 if (ab8500->irq_reg_offset[i] == 11 &&
352 is_ab8500_1p1_or_earlier(ab8500))
353 continue;
354
355 ab8500->oldmask[i] = new;
356
357 reg = AB8500_IT_MASK1_REG + ab8500->irq_reg_offset[i];
358 set_register_interruptible(ab8500, AB8500_INTERRUPT, reg, new);
359 }
360 atomic_dec(&ab8500->transfer_ongoing);
361 mutex_unlock(&ab8500->irq_lock);
362}
363
364static void ab8500_irq_mask(struct irq_data *data)
365{
366 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
367 int offset = data->hwirq;
368 int index = offset / 8;
369 int mask = 1 << (offset % 8);
370
371 ab8500->mask[index] |= mask;
372
373 /* The AB8500 GPIOs have two interrupts each (rising & falling). */
374 if (offset >= AB8500_INT_GPIO6R && offset <= AB8500_INT_GPIO41R)
375 ab8500->mask[index + 2] |= mask;
376 if (offset >= AB9540_INT_GPIO50R && offset <= AB9540_INT_GPIO54R)
377 ab8500->mask[index + 1] |= mask;
378 if (offset == AB8540_INT_GPIO43R || offset == AB8540_INT_GPIO44R)
379 /* Here the falling IRQ is one bit lower */
380 ab8500->mask[index] |= (mask << 1);
381}
382
383static void ab8500_irq_unmask(struct irq_data *data)
384{
385 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
386 unsigned int type = irqd_get_trigger_type(data);
387 int offset = data->hwirq;
388 int index = offset / 8;
389 int mask = 1 << (offset % 8);
390
391 if (type & IRQ_TYPE_EDGE_RISING)
392 ab8500->mask[index] &= ~mask;
393
394 /* The AB8500 GPIOs have two interrupts each (rising & falling). */
395 if (type & IRQ_TYPE_EDGE_FALLING) {
396 if (offset >= AB8500_INT_GPIO6R && offset <= AB8500_INT_GPIO41R)
397 ab8500->mask[index + 2] &= ~mask;
398 else if (offset >= AB9540_INT_GPIO50R && offset <= AB9540_INT_GPIO54R)
399 ab8500->mask[index + 1] &= ~mask;
400 else if (offset == AB8540_INT_GPIO43R || offset == AB8540_INT_GPIO44R)
401 /* Here the falling IRQ is one bit lower */
402 ab8500->mask[index] &= ~(mask << 1);
403 else
404 ab8500->mask[index] &= ~mask;
405 } else {
406 /* Satisfies the case where type is not set. */
407 ab8500->mask[index] &= ~mask;
408 }
409}
410
411static int ab8500_irq_set_type(struct irq_data *data, unsigned int type)
412{
413 return 0;
414}
415
416static struct irq_chip ab8500_irq_chip = {
417 .name = "ab8500",
418 .irq_bus_lock = ab8500_irq_lock,
419 .irq_bus_sync_unlock = ab8500_irq_sync_unlock,
420 .irq_mask = ab8500_irq_mask,
421 .irq_disable = ab8500_irq_mask,
422 .irq_unmask = ab8500_irq_unmask,
423 .irq_set_type = ab8500_irq_set_type,
424};
425
426static int ab8500_handle_hierarchical_line(struct ab8500 *ab8500,
427 int latch_offset, u8 latch_val)
428{
429 int int_bit = __ffs(latch_val);
430 int line, i;
431
432 do {
433 int_bit = __ffs(latch_val);
434
435 for (i = 0; i < ab8500->mask_size; i++)
436 if (ab8500->irq_reg_offset[i] == latch_offset)
437 break;
438
439 if (i >= ab8500->mask_size) {
440 dev_err(ab8500->dev, "Register offset 0x%2x not declared\n",
441 latch_offset);
442 return -ENXIO;
443 }
444
445 line = (i << 3) + int_bit;
446 latch_val &= ~(1 << int_bit);
447
448 /*
449 * This handles the falling edge hwirqs from the GPIO
450 * lines. Route them back to the line registered for the
451 * rising IRQ, as this is merely a flag for the same IRQ
452 * in linux terms.
453 */
454 if (line >= AB8500_INT_GPIO6F && line <= AB8500_INT_GPIO41F)
455 line -= 16;
456 if (line >= AB9540_INT_GPIO50F && line <= AB9540_INT_GPIO54F)
457 line -= 8;
458 if (line == AB8540_INT_GPIO43F || line == AB8540_INT_GPIO44F)
459 line += 1;
460
461 handle_nested_irq(ab8500->irq_base + line);
462 } while (latch_val);
463
464 return 0;
465}
466
467static int ab8500_handle_hierarchical_latch(struct ab8500 *ab8500,
468 int hier_offset, u8 hier_val)
469{
470 int latch_bit, status;
471 u8 latch_offset, latch_val;
472
473 do {
474 latch_bit = __ffs(hier_val);
475 latch_offset = (hier_offset << 3) + latch_bit;
476
477 /* Fix inconsistent ITFromLatch25 bit mapping... */
478 if (unlikely(latch_offset == 17))
479 latch_offset = 24;
480
481 status = get_register_interruptible(ab8500,
482 AB8500_INTERRUPT,
483 AB8500_IT_LATCH1_REG + latch_offset,
484 &latch_val);
485 if (status < 0 || latch_val == 0)
486 goto discard;
487
488 status = ab8500_handle_hierarchical_line(ab8500,
489 latch_offset, latch_val);
490 if (status < 0)
491 return status;
492discard:
493 hier_val &= ~(1 << latch_bit);
494 } while (hier_val);
495
496 return 0;
497}
498
499static irqreturn_t ab8500_hierarchical_irq(int irq, void *dev)
500{
501 struct ab8500 *ab8500 = dev;
502 u8 i;
503
504 dev_vdbg(ab8500->dev, "interrupt\n");
505
506 /* Hierarchical interrupt version */
507 for (i = 0; i < AB8500_IT_LATCHHIER_NUM; i++) {
508 int status;
509 u8 hier_val;
510
511 status = get_register_interruptible(ab8500, AB8500_INTERRUPT,
512 AB8500_IT_LATCHHIER1_REG + i, &hier_val);
513 if (status < 0 || hier_val == 0)
514 continue;
515
516 status = ab8500_handle_hierarchical_latch(ab8500, i, hier_val);
517 if (status < 0)
518 break;
519 }
520 return IRQ_HANDLED;
521}
522
523/**
524 * ab8500_irq_get_virq(): Map an interrupt on a chip to a virtual IRQ
525 *
526 * @ab8500: ab8500_irq controller to operate on.
527 * @irq: index of the interrupt requested in the chip IRQs
528 *
529 * Useful for drivers to request their own IRQs.
530 */
531static int ab8500_irq_get_virq(struct ab8500 *ab8500, int irq)
532{
533 if (!ab8500)
534 return -EINVAL;
535
536 return irq_create_mapping(ab8500->domain, irq);
537}
538
539static irqreturn_t ab8500_irq(int irq, void *dev)
540{
541 struct ab8500 *ab8500 = dev;
542 int i;
543
544 dev_vdbg(ab8500->dev, "interrupt\n");
545
546 atomic_inc(&ab8500->transfer_ongoing);
547
548 for (i = 0; i < ab8500->mask_size; i++) {
549 int regoffset = ab8500->irq_reg_offset[i];
550 int status;
551 u8 value;
552
553 /*
554 * Interrupt register 12 doesn't exist prior to AB8500 version
555 * 2.0
556 */
557 if (regoffset == 11 && is_ab8500_1p1_or_earlier(ab8500))
558 continue;
559
560 status = get_register_interruptible(ab8500, AB8500_INTERRUPT,
561 AB8500_IT_LATCH1_REG + regoffset, &value);
562 if (status < 0 || value == 0)
563 continue;
564
565 do {
566 int bit = __ffs(value);
567 int line = i * 8 + bit;
568 int virq = ab8500_irq_get_virq(ab8500, line);
569
570 handle_nested_irq(virq);
571 ab8500_debug_register_interrupt(line);
572 value &= ~(1 << bit);
573
574 } while (value);
575 }
576 atomic_dec(&ab8500->transfer_ongoing);
577 return IRQ_HANDLED;
578}
579
580static int ab8500_irq_map(struct irq_domain *d, unsigned int virq,
581 irq_hw_number_t hwirq)
582{
583 struct ab8500 *ab8500 = d->host_data;
584
585 if (!ab8500)
586 return -EINVAL;
587
588 irq_set_chip_data(virq, ab8500);
589 irq_set_chip_and_handler(virq, &ab8500_irq_chip,
590 handle_simple_irq);
591 irq_set_nested_thread(virq, 1);
592#ifdef CONFIG_ARM
593 set_irq_flags(virq, IRQF_VALID);
594#else
595 irq_set_noprobe(virq);
596#endif
597
598 return 0;
599}
600
601static struct irq_domain_ops ab8500_irq_ops = {
602 .map = ab8500_irq_map,
603 .xlate = irq_domain_xlate_twocell,
604};
605
606static int ab8500_irq_init(struct ab8500 *ab8500, struct device_node *np)
607{
608 int num_irqs;
609
610 if (is_ab9540(ab8500))
611 num_irqs = AB9540_NR_IRQS;
612 else if (is_ab8505(ab8500))
613 num_irqs = AB8505_NR_IRQS;
614 else
615 num_irqs = AB8500_NR_IRQS;
616
617 /* If ->irq_base is zero this will give a linear mapping */
618 ab8500->domain = irq_domain_add_simple(NULL,
619 num_irqs, ab8500->irq_base,
620 &ab8500_irq_ops, ab8500);
621
622 if (!ab8500->domain) {
623 dev_err(ab8500->dev, "Failed to create irqdomain\n");
624 return -ENOSYS;
625 }
626
627 return 0;
628}
629
630int ab8500_suspend(struct ab8500 *ab8500)
631{
632 if (atomic_read(&ab8500->transfer_ongoing))
633 return -EINVAL;
634 else
635 return 0;
636}
637
638static struct resource ab8500_gpadc_resources[] = {
639 {
640 .name = "HW_CONV_END",
641 .start = AB8500_INT_GP_HW_ADC_CONV_END,
642 .end = AB8500_INT_GP_HW_ADC_CONV_END,
643 .flags = IORESOURCE_IRQ,
644 },
645 {
646 .name = "SW_CONV_END",
647 .start = AB8500_INT_GP_SW_ADC_CONV_END,
648 .end = AB8500_INT_GP_SW_ADC_CONV_END,
649 .flags = IORESOURCE_IRQ,
650 },
651};
652
653static struct resource ab8500_rtc_resources[] = {
654 {
655 .name = "60S",
656 .start = AB8500_INT_RTC_60S,
657 .end = AB8500_INT_RTC_60S,
658 .flags = IORESOURCE_IRQ,
659 },
660 {
661 .name = "ALARM",
662 .start = AB8500_INT_RTC_ALARM,
663 .end = AB8500_INT_RTC_ALARM,
664 .flags = IORESOURCE_IRQ,
665 },
666};
667
668static struct resource ab8500_poweronkey_db_resources[] = {
669 {
670 .name = "ONKEY_DBF",
671 .start = AB8500_INT_PON_KEY1DB_F,
672 .end = AB8500_INT_PON_KEY1DB_F,
673 .flags = IORESOURCE_IRQ,
674 },
675 {
676 .name = "ONKEY_DBR",
677 .start = AB8500_INT_PON_KEY1DB_R,
678 .end = AB8500_INT_PON_KEY1DB_R,
679 .flags = IORESOURCE_IRQ,
680 },
681};
682
683static struct resource ab8500_av_acc_detect_resources[] = {
684 {
685 .name = "ACC_DETECT_1DB_F",
686 .start = AB8500_INT_ACC_DETECT_1DB_F,
687 .end = AB8500_INT_ACC_DETECT_1DB_F,
688 .flags = IORESOURCE_IRQ,
689 },
690 {
691 .name = "ACC_DETECT_1DB_R",
692 .start = AB8500_INT_ACC_DETECT_1DB_R,
693 .end = AB8500_INT_ACC_DETECT_1DB_R,
694 .flags = IORESOURCE_IRQ,
695 },
696 {
697 .name = "ACC_DETECT_21DB_F",
698 .start = AB8500_INT_ACC_DETECT_21DB_F,
699 .end = AB8500_INT_ACC_DETECT_21DB_F,
700 .flags = IORESOURCE_IRQ,
701 },
702 {
703 .name = "ACC_DETECT_21DB_R",
704 .start = AB8500_INT_ACC_DETECT_21DB_R,
705 .end = AB8500_INT_ACC_DETECT_21DB_R,
706 .flags = IORESOURCE_IRQ,
707 },
708 {
709 .name = "ACC_DETECT_22DB_F",
710 .start = AB8500_INT_ACC_DETECT_22DB_F,
711 .end = AB8500_INT_ACC_DETECT_22DB_F,
712 .flags = IORESOURCE_IRQ,
713 },
714 {
715 .name = "ACC_DETECT_22DB_R",
716 .start = AB8500_INT_ACC_DETECT_22DB_R,
717 .end = AB8500_INT_ACC_DETECT_22DB_R,
718 .flags = IORESOURCE_IRQ,
719 },
720};
721
722static struct resource ab8500_charger_resources[] = {
723 {
724 .name = "MAIN_CH_UNPLUG_DET",
725 .start = AB8500_INT_MAIN_CH_UNPLUG_DET,
726 .end = AB8500_INT_MAIN_CH_UNPLUG_DET,
727 .flags = IORESOURCE_IRQ,
728 },
729 {
730 .name = "MAIN_CHARGE_PLUG_DET",
731 .start = AB8500_INT_MAIN_CH_PLUG_DET,
732 .end = AB8500_INT_MAIN_CH_PLUG_DET,
733 .flags = IORESOURCE_IRQ,
734 },
735 {
736 .name = "VBUS_DET_R",
737 .start = AB8500_INT_VBUS_DET_R,
738 .end = AB8500_INT_VBUS_DET_R,
739 .flags = IORESOURCE_IRQ,
740 },
741 {
742 .name = "VBUS_DET_F",
743 .start = AB8500_INT_VBUS_DET_F,
744 .end = AB8500_INT_VBUS_DET_F,
745 .flags = IORESOURCE_IRQ,
746 },
747 {
748 .name = "USB_LINK_STATUS",
749 .start = AB8500_INT_USB_LINK_STATUS,
750 .end = AB8500_INT_USB_LINK_STATUS,
751 .flags = IORESOURCE_IRQ,
752 },
753 {
754 .name = "VBUS_OVV",
755 .start = AB8500_INT_VBUS_OVV,
756 .end = AB8500_INT_VBUS_OVV,
757 .flags = IORESOURCE_IRQ,
758 },
759 {
760 .name = "USB_CH_TH_PROT_R",
761 .start = AB8500_INT_USB_CH_TH_PROT_R,
762 .end = AB8500_INT_USB_CH_TH_PROT_R,
763 .flags = IORESOURCE_IRQ,
764 },
765 {
766 .name = "USB_CH_TH_PROT_F",
767 .start = AB8500_INT_USB_CH_TH_PROT_F,
768 .end = AB8500_INT_USB_CH_TH_PROT_F,
769 .flags = IORESOURCE_IRQ,
770 },
771 {
772 .name = "MAIN_EXT_CH_NOT_OK",
773 .start = AB8500_INT_MAIN_EXT_CH_NOT_OK,
774 .end = AB8500_INT_MAIN_EXT_CH_NOT_OK,
775 .flags = IORESOURCE_IRQ,
776 },
777 {
778 .name = "MAIN_CH_TH_PROT_R",
779 .start = AB8500_INT_MAIN_CH_TH_PROT_R,
780 .end = AB8500_INT_MAIN_CH_TH_PROT_R,
781 .flags = IORESOURCE_IRQ,
782 },
783 {
784 .name = "MAIN_CH_TH_PROT_F",
785 .start = AB8500_INT_MAIN_CH_TH_PROT_F,
786 .end = AB8500_INT_MAIN_CH_TH_PROT_F,
787 .flags = IORESOURCE_IRQ,
788 },
789 {
790 .name = "USB_CHARGER_NOT_OKR",
791 .start = AB8500_INT_USB_CHARGER_NOT_OKR,
792 .end = AB8500_INT_USB_CHARGER_NOT_OKR,
793 .flags = IORESOURCE_IRQ,
794 },
795 {
796 .name = "CH_WD_EXP",
797 .start = AB8500_INT_CH_WD_EXP,
798 .end = AB8500_INT_CH_WD_EXP,
799 .flags = IORESOURCE_IRQ,
800 },
801 {
802 .name = "VBUS_CH_DROP_END",
803 .start = AB8500_INT_VBUS_CH_DROP_END,
804 .end = AB8500_INT_VBUS_CH_DROP_END,
805 .flags = IORESOURCE_IRQ,
806 },
807};
808
809static struct resource ab8500_btemp_resources[] = {
810 {
811 .name = "BAT_CTRL_INDB",
812 .start = AB8500_INT_BAT_CTRL_INDB,
813 .end = AB8500_INT_BAT_CTRL_INDB,
814 .flags = IORESOURCE_IRQ,
815 },
816 {
817 .name = "BTEMP_LOW",
818 .start = AB8500_INT_BTEMP_LOW,
819 .end = AB8500_INT_BTEMP_LOW,
820 .flags = IORESOURCE_IRQ,
821 },
822 {
823 .name = "BTEMP_HIGH",
824 .start = AB8500_INT_BTEMP_HIGH,
825 .end = AB8500_INT_BTEMP_HIGH,
826 .flags = IORESOURCE_IRQ,
827 },
828 {
829 .name = "BTEMP_LOW_MEDIUM",
830 .start = AB8500_INT_BTEMP_LOW_MEDIUM,
831 .end = AB8500_INT_BTEMP_LOW_MEDIUM,
832 .flags = IORESOURCE_IRQ,
833 },
834 {
835 .name = "BTEMP_MEDIUM_HIGH",
836 .start = AB8500_INT_BTEMP_MEDIUM_HIGH,
837 .end = AB8500_INT_BTEMP_MEDIUM_HIGH,
838 .flags = IORESOURCE_IRQ,
839 },
840};
841
842static struct resource ab8500_fg_resources[] = {
843 {
844 .name = "NCONV_ACCU",
845 .start = AB8500_INT_CCN_CONV_ACC,
846 .end = AB8500_INT_CCN_CONV_ACC,
847 .flags = IORESOURCE_IRQ,
848 },
849 {
850 .name = "BATT_OVV",
851 .start = AB8500_INT_BATT_OVV,
852 .end = AB8500_INT_BATT_OVV,
853 .flags = IORESOURCE_IRQ,
854 },
855 {
856 .name = "LOW_BAT_F",
857 .start = AB8500_INT_LOW_BAT_F,
858 .end = AB8500_INT_LOW_BAT_F,
859 .flags = IORESOURCE_IRQ,
860 },
861 {
862 .name = "LOW_BAT_R",
863 .start = AB8500_INT_LOW_BAT_R,
864 .end = AB8500_INT_LOW_BAT_R,
865 .flags = IORESOURCE_IRQ,
866 },
867 {
868 .name = "CC_INT_CALIB",
869 .start = AB8500_INT_CC_INT_CALIB,
870 .end = AB8500_INT_CC_INT_CALIB,
871 .flags = IORESOURCE_IRQ,
872 },
873 {
874 .name = "CCEOC",
875 .start = AB8500_INT_CCEOC,
876 .end = AB8500_INT_CCEOC,
877 .flags = IORESOURCE_IRQ,
878 },
879};
880
881static struct resource ab8500_chargalg_resources[] = {};
882
883#ifdef CONFIG_DEBUG_FS
884static struct resource ab8500_debug_resources[] = {
885 {
886 .name = "IRQ_FIRST",
887 .start = AB8500_INT_MAIN_EXT_CH_NOT_OK,
888 .end = AB8500_INT_MAIN_EXT_CH_NOT_OK,
889 .flags = IORESOURCE_IRQ,
890 },
891 {
892 .name = "IRQ_LAST",
893 .start = AB8500_INT_XTAL32K_KO,
894 .end = AB8500_INT_XTAL32K_KO,
895 .flags = IORESOURCE_IRQ,
896 },
897};
898#endif
899
900static struct resource ab8500_usb_resources[] = {
901 {
902 .name = "ID_WAKEUP_R",
903 .start = AB8500_INT_ID_WAKEUP_R,
904 .end = AB8500_INT_ID_WAKEUP_R,
905 .flags = IORESOURCE_IRQ,
906 },
907 {
908 .name = "ID_WAKEUP_F",
909 .start = AB8500_INT_ID_WAKEUP_F,
910 .end = AB8500_INT_ID_WAKEUP_F,
911 .flags = IORESOURCE_IRQ,
912 },
913 {
914 .name = "VBUS_DET_F",
915 .start = AB8500_INT_VBUS_DET_F,
916 .end = AB8500_INT_VBUS_DET_F,
917 .flags = IORESOURCE_IRQ,
918 },
919 {
920 .name = "VBUS_DET_R",
921 .start = AB8500_INT_VBUS_DET_R,
922 .end = AB8500_INT_VBUS_DET_R,
923 .flags = IORESOURCE_IRQ,
924 },
925 {
926 .name = "USB_LINK_STATUS",
927 .start = AB8500_INT_USB_LINK_STATUS,
928 .end = AB8500_INT_USB_LINK_STATUS,
929 .flags = IORESOURCE_IRQ,
930 },
931 {
932 .name = "USB_ADP_PROBE_PLUG",
933 .start = AB8500_INT_ADP_PROBE_PLUG,
934 .end = AB8500_INT_ADP_PROBE_PLUG,
935 .flags = IORESOURCE_IRQ,
936 },
937 {
938 .name = "USB_ADP_PROBE_UNPLUG",
939 .start = AB8500_INT_ADP_PROBE_UNPLUG,
940 .end = AB8500_INT_ADP_PROBE_UNPLUG,
941 .flags = IORESOURCE_IRQ,
942 },
943};
944
945static struct resource ab8505_iddet_resources[] = {
946 {
947 .name = "KeyDeglitch",
948 .start = AB8505_INT_KEYDEGLITCH,
949 .end = AB8505_INT_KEYDEGLITCH,
950 .flags = IORESOURCE_IRQ,
951 },
952 {
953 .name = "KP",
954 .start = AB8505_INT_KP,
955 .end = AB8505_INT_KP,
956 .flags = IORESOURCE_IRQ,
957 },
958 {
959 .name = "IKP",
960 .start = AB8505_INT_IKP,
961 .end = AB8505_INT_IKP,
962 .flags = IORESOURCE_IRQ,
963 },
964 {
965 .name = "IKR",
966 .start = AB8505_INT_IKR,
967 .end = AB8505_INT_IKR,
968 .flags = IORESOURCE_IRQ,
969 },
970 {
971 .name = "KeyStuck",
972 .start = AB8505_INT_KEYSTUCK,
973 .end = AB8505_INT_KEYSTUCK,
974 .flags = IORESOURCE_IRQ,
975 },
976};
977
978static struct resource ab8500_temp_resources[] = {
979 {
980 .name = "ABX500_TEMP_WARM",
981 .start = AB8500_INT_TEMP_WARM,
982 .end = AB8500_INT_TEMP_WARM,
983 .flags = IORESOURCE_IRQ,
984 },
985};
986
987static struct mfd_cell abx500_common_devs[] = {
988#ifdef CONFIG_DEBUG_FS
989 {
990 .name = "ab8500-debug",
991 .of_compatible = "stericsson,ab8500-debug",
992 .num_resources = ARRAY_SIZE(ab8500_debug_resources),
993 .resources = ab8500_debug_resources,
994 },
995#endif
996 {
997 .name = "ab8500-sysctrl",
998 .of_compatible = "stericsson,ab8500-sysctrl",
999 },
1000 {
1001 .name = "ab8500-regulator",
1002 .of_compatible = "stericsson,ab8500-regulator",
1003 },
1004 {
1005 .name = "abx500-clk",
1006 .of_compatible = "stericsson,abx500-clk",
1007 },
1008 {
1009 .name = "ab8500-gpadc",
1010 .of_compatible = "stericsson,ab8500-gpadc",
1011 .num_resources = ARRAY_SIZE(ab8500_gpadc_resources),
1012 .resources = ab8500_gpadc_resources,
1013 },
1014 {
1015 .name = "ab8500-rtc",
1016 .of_compatible = "stericsson,ab8500-rtc",
1017 .num_resources = ARRAY_SIZE(ab8500_rtc_resources),
1018 .resources = ab8500_rtc_resources,
1019 },
1020 {
1021 .name = "ab8500-acc-det",
1022 .of_compatible = "stericsson,ab8500-acc-det",
1023 .num_resources = ARRAY_SIZE(ab8500_av_acc_detect_resources),
1024 .resources = ab8500_av_acc_detect_resources,
1025 },
1026 {
1027 .name = "ab8500-poweron-key",
1028 .of_compatible = "stericsson,ab8500-poweron-key",
1029 .num_resources = ARRAY_SIZE(ab8500_poweronkey_db_resources),
1030 .resources = ab8500_poweronkey_db_resources,
1031 },
1032 {
1033 .name = "ab8500-pwm",
1034 .of_compatible = "stericsson,ab8500-pwm",
1035 .id = 1,
1036 },
1037 {
1038 .name = "ab8500-pwm",
1039 .of_compatible = "stericsson,ab8500-pwm",
1040 .id = 2,
1041 },
1042 {
1043 .name = "ab8500-pwm",
1044 .of_compatible = "stericsson,ab8500-pwm",
1045 .id = 3,
1046 },
1047 {
1048 .name = "ab8500-leds",
1049 .of_compatible = "stericsson,ab8500-leds",
1050 },
1051 {
1052 .name = "ab8500-denc",
1053 .of_compatible = "stericsson,ab8500-denc",
1054 },
1055 {
1056 .name = "abx500-temp",
1057 .of_compatible = "stericsson,abx500-temp",
1058 .num_resources = ARRAY_SIZE(ab8500_temp_resources),
1059 .resources = ab8500_temp_resources,
1060 },
1061};
1062
1063static struct mfd_cell ab8500_bm_devs[] = {
1064 {
1065 .name = "ab8500-charger",
1066 .of_compatible = "stericsson,ab8500-charger",
1067 .num_resources = ARRAY_SIZE(ab8500_charger_resources),
1068 .resources = ab8500_charger_resources,
1069 .platform_data = &ab8500_bm_data,
1070 .pdata_size = sizeof(ab8500_bm_data),
1071 },
1072 {
1073 .name = "ab8500-btemp",
1074 .of_compatible = "stericsson,ab8500-btemp",
1075 .num_resources = ARRAY_SIZE(ab8500_btemp_resources),
1076 .resources = ab8500_btemp_resources,
1077 .platform_data = &ab8500_bm_data,
1078 .pdata_size = sizeof(ab8500_bm_data),
1079 },
1080 {
1081 .name = "ab8500-fg",
1082 .of_compatible = "stericsson,ab8500-fg",
1083 .num_resources = ARRAY_SIZE(ab8500_fg_resources),
1084 .resources = ab8500_fg_resources,
1085 .platform_data = &ab8500_bm_data,
1086 .pdata_size = sizeof(ab8500_bm_data),
1087 },
1088 {
1089 .name = "ab8500-chargalg",
1090 .of_compatible = "stericsson,ab8500-chargalg",
1091 .num_resources = ARRAY_SIZE(ab8500_chargalg_resources),
1092 .resources = ab8500_chargalg_resources,
1093 .platform_data = &ab8500_bm_data,
1094 .pdata_size = sizeof(ab8500_bm_data),
1095 },
1096};
1097
1098static struct mfd_cell ab8500_devs[] = {
1099 {
1100 .name = "pinctrl-ab8500",
1101 .of_compatible = "stericsson,ab8500-gpio",
1102 },
1103 {
1104 .name = "ab8500-usb",
1105 .of_compatible = "stericsson,ab8500-usb",
1106 .num_resources = ARRAY_SIZE(ab8500_usb_resources),
1107 .resources = ab8500_usb_resources,
1108 },
1109 {
1110 .name = "ab8500-codec",
1111 .of_compatible = "stericsson,ab8500-codec",
1112 },
1113};
1114
1115static struct mfd_cell ab9540_devs[] = {
1116 {
1117 .name = "pinctrl-ab9540",
1118 .of_compatible = "stericsson,ab9540-gpio",
1119 },
1120 {
1121 .name = "ab9540-usb",
1122 .num_resources = ARRAY_SIZE(ab8500_usb_resources),
1123 .resources = ab8500_usb_resources,
1124 },
1125 {
1126 .name = "ab9540-codec",
1127 },
1128};
1129
1130/* Device list common to ab9540 and ab8505 */
1131static struct mfd_cell ab9540_ab8505_devs[] = {
1132 {
1133 .name = "ab-iddet",
1134 .num_resources = ARRAY_SIZE(ab8505_iddet_resources),
1135 .resources = ab8505_iddet_resources,
1136 },
1137};
1138
1139static ssize_t show_chip_id(struct device *dev,
1140 struct device_attribute *attr, char *buf)
1141{
1142 struct ab8500 *ab8500;
1143
1144 ab8500 = dev_get_drvdata(dev);
1145 return sprintf(buf, "%#x\n", ab8500 ? ab8500->chip_id : -EINVAL);
1146}
1147
1148/*
1149 * ab8500 has switched off due to (SWITCH_OFF_STATUS):
1150 * 0x01 Swoff bit programming
1151 * 0x02 Thermal protection activation
1152 * 0x04 Vbat lower then BattOk falling threshold
1153 * 0x08 Watchdog expired
1154 * 0x10 Non presence of 32kHz clock
1155 * 0x20 Battery level lower than power on reset threshold
1156 * 0x40 Power on key 1 pressed longer than 10 seconds
1157 * 0x80 DB8500 thermal shutdown
1158 */
1159static ssize_t show_switch_off_status(struct device *dev,
1160 struct device_attribute *attr, char *buf)
1161{
1162 int ret;
1163 u8 value;
1164 struct ab8500 *ab8500;
1165
1166 ab8500 = dev_get_drvdata(dev);
1167 ret = get_register_interruptible(ab8500, AB8500_RTC,
1168 AB8500_SWITCH_OFF_STATUS, &value);
1169 if (ret < 0)
1170 return ret;
1171 return sprintf(buf, "%#x\n", value);
1172}
1173
1174/*
1175 * ab8500 has turned on due to (TURN_ON_STATUS):
1176 * 0x01 PORnVbat
1177 * 0x02 PonKey1dbF
1178 * 0x04 PonKey2dbF
1179 * 0x08 RTCAlarm
1180 * 0x10 MainChDet
1181 * 0x20 VbusDet
1182 * 0x40 UsbIDDetect
1183 * 0x80 Reserved
1184 */
1185static ssize_t show_turn_on_status(struct device *dev,
1186 struct device_attribute *attr, char *buf)
1187{
1188 int ret;
1189 u8 value;
1190 struct ab8500 *ab8500;
1191
1192 ab8500 = dev_get_drvdata(dev);
1193 ret = get_register_interruptible(ab8500, AB8500_SYS_CTRL1_BLOCK,
1194 AB8500_TURN_ON_STATUS, &value);
1195 if (ret < 0)
1196 return ret;
1197 return sprintf(buf, "%#x\n", value);
1198}
1199
1200static ssize_t show_ab9540_dbbrstn(struct device *dev,
1201 struct device_attribute *attr, char *buf)
1202{
1203 struct ab8500 *ab8500;
1204 int ret;
1205 u8 value;
1206
1207 ab8500 = dev_get_drvdata(dev);
1208
1209 ret = get_register_interruptible(ab8500, AB8500_REGU_CTRL2,
1210 AB9540_MODEM_CTRL2_REG, &value);
1211 if (ret < 0)
1212 return ret;
1213
1214 return sprintf(buf, "%d\n",
1215 (value & AB9540_MODEM_CTRL2_SWDBBRSTN_BIT) ? 1 : 0);
1216}
1217
1218static ssize_t store_ab9540_dbbrstn(struct device *dev,
1219 struct device_attribute *attr, const char *buf, size_t count)
1220{
1221 struct ab8500 *ab8500;
1222 int ret = count;
1223 int err;
1224 u8 bitvalues;
1225
1226 ab8500 = dev_get_drvdata(dev);
1227
1228 if (count > 0) {
1229 switch (buf[0]) {
1230 case '0':
1231 bitvalues = 0;
1232 break;
1233 case '1':
1234 bitvalues = AB9540_MODEM_CTRL2_SWDBBRSTN_BIT;
1235 break;
1236 default:
1237 goto exit;
1238 }
1239
1240 err = mask_and_set_register_interruptible(ab8500,
1241 AB8500_REGU_CTRL2, AB9540_MODEM_CTRL2_REG,
1242 AB9540_MODEM_CTRL2_SWDBBRSTN_BIT, bitvalues);
1243 if (err)
1244 dev_info(ab8500->dev,
1245 "Failed to set DBBRSTN %c, err %#x\n",
1246 buf[0], err);
1247 }
1248
1249exit:
1250 return ret;
1251}
1252
1253static DEVICE_ATTR(chip_id, S_IRUGO, show_chip_id, NULL);
1254static DEVICE_ATTR(switch_off_status, S_IRUGO, show_switch_off_status, NULL);
1255static DEVICE_ATTR(turn_on_status, S_IRUGO, show_turn_on_status, NULL);
1256static DEVICE_ATTR(dbbrstn, S_IRUGO | S_IWUSR,
1257 show_ab9540_dbbrstn, store_ab9540_dbbrstn);
1258
1259static struct attribute *ab8500_sysfs_entries[] = {
1260 &dev_attr_chip_id.attr,
1261 &dev_attr_switch_off_status.attr,
1262 &dev_attr_turn_on_status.attr,
1263 NULL,
1264};
1265
1266static struct attribute *ab9540_sysfs_entries[] = {
1267 &dev_attr_chip_id.attr,
1268 &dev_attr_switch_off_status.attr,
1269 &dev_attr_turn_on_status.attr,
1270 &dev_attr_dbbrstn.attr,
1271 NULL,
1272};
1273
1274static struct attribute_group ab8500_attr_group = {
1275 .attrs = ab8500_sysfs_entries,
1276};
1277
1278static struct attribute_group ab9540_attr_group = {
1279 .attrs = ab9540_sysfs_entries,
1280};
1281
1282static int ab8500_probe(struct platform_device *pdev)
1283{
1284 static char *switch_off_status[] = {
1285 "Swoff bit programming",
1286 "Thermal protection activation",
1287 "Vbat lower then BattOk falling threshold",
1288 "Watchdog expired",
1289 "Non presence of 32kHz clock",
1290 "Battery level lower than power on reset threshold",
1291 "Power on key 1 pressed longer than 10 seconds",
1292 "DB8500 thermal shutdown"};
1293 struct ab8500_platform_data *plat = dev_get_platdata(&pdev->dev);
1294 const struct platform_device_id *platid = platform_get_device_id(pdev);
1295 enum ab8500_version version = AB8500_VERSION_UNDEFINED;
1296 struct device_node *np = pdev->dev.of_node;
1297 struct ab8500 *ab8500;
1298 struct resource *resource;
1299 int ret;
1300 int i;
1301 u8 value;
1302
1303 ab8500 = devm_kzalloc(&pdev->dev, sizeof *ab8500, GFP_KERNEL);
1304 if (!ab8500)
1305 return -ENOMEM;
1306
1307 if (plat)
1308 ab8500->irq_base = plat->irq_base;
1309
1310 ab8500->dev = &pdev->dev;
1311
1312 resource = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1313 if (!resource)
1314 return -ENODEV;
1315
1316 ab8500->irq = resource->start;
1317
1318 ab8500->read = ab8500_prcmu_read;
1319 ab8500->write = ab8500_prcmu_write;
1320 ab8500->write_masked = ab8500_prcmu_write_masked;
1321
1322 mutex_init(&ab8500->lock);
1323 mutex_init(&ab8500->irq_lock);
1324 atomic_set(&ab8500->transfer_ongoing, 0);
1325
1326 platform_set_drvdata(pdev, ab8500);
1327
1328 if (platid)
1329 version = platid->driver_data;
1330
1331 if (version != AB8500_VERSION_UNDEFINED)
1332 ab8500->version = version;
1333 else {
1334 ret = get_register_interruptible(ab8500, AB8500_MISC,
1335 AB8500_IC_NAME_REG, &value);
1336 if (ret < 0)
1337 return ret;
1338
1339 ab8500->version = value;
1340 }
1341
1342 ret = get_register_interruptible(ab8500, AB8500_MISC,
1343 AB8500_REV_REG, &value);
1344 if (ret < 0)
1345 return ret;
1346
1347 ab8500->chip_id = value;
1348
1349 dev_info(ab8500->dev, "detected chip, %s rev. %1x.%1x\n",
1350 ab8500_version_str[ab8500->version],
1351 ab8500->chip_id >> 4,
1352 ab8500->chip_id & 0x0F);
1353
1354 /* Configure AB8500 or AB9540 IRQ */
1355 if (is_ab9540(ab8500) || is_ab8505(ab8500)) {
1356 ab8500->mask_size = AB9540_NUM_IRQ_REGS;
1357 ab8500->irq_reg_offset = ab9540_irq_regoffset;
1358 } else {
1359 ab8500->mask_size = AB8500_NUM_IRQ_REGS;
1360 ab8500->irq_reg_offset = ab8500_irq_regoffset;
1361 }
1362 ab8500->mask = devm_kzalloc(&pdev->dev, ab8500->mask_size, GFP_KERNEL);
1363 if (!ab8500->mask)
1364 return -ENOMEM;
1365 ab8500->oldmask = devm_kzalloc(&pdev->dev, ab8500->mask_size, GFP_KERNEL);
1366 if (!ab8500->oldmask)
1367 return -ENOMEM;
1368
1369 /*
1370 * ab8500 has switched off due to (SWITCH_OFF_STATUS):
1371 * 0x01 Swoff bit programming
1372 * 0x02 Thermal protection activation
1373 * 0x04 Vbat lower then BattOk falling threshold
1374 * 0x08 Watchdog expired
1375 * 0x10 Non presence of 32kHz clock
1376 * 0x20 Battery level lower than power on reset threshold
1377 * 0x40 Power on key 1 pressed longer than 10 seconds
1378 * 0x80 DB8500 thermal shutdown
1379 */
1380
1381 ret = get_register_interruptible(ab8500, AB8500_RTC,
1382 AB8500_SWITCH_OFF_STATUS, &value);
1383 if (ret < 0)
1384 return ret;
1385 dev_info(ab8500->dev, "switch off cause(s) (%#x): ", value);
1386
1387 if (value) {
1388 for (i = 0; i < ARRAY_SIZE(switch_off_status); i++) {
1389 if (value & 1)
1390 printk(KERN_CONT " \"%s\"",
1391 switch_off_status[i]);
1392 value = value >> 1;
1393
1394 }
1395 printk(KERN_CONT "\n");
1396 } else {
1397 printk(KERN_CONT " None\n");
1398 }
1399
1400 if (plat && plat->init)
1401 plat->init(ab8500);
1402
1403 /* Clear and mask all interrupts */
1404 for (i = 0; i < ab8500->mask_size; i++) {
1405 /*
1406 * Interrupt register 12 doesn't exist prior to AB8500 version
1407 * 2.0
1408 */
1409 if (ab8500->irq_reg_offset[i] == 11 &&
1410 is_ab8500_1p1_or_earlier(ab8500))
1411 continue;
1412
1413 get_register_interruptible(ab8500, AB8500_INTERRUPT,
1414 AB8500_IT_LATCH1_REG + ab8500->irq_reg_offset[i],
1415 &value);
1416 set_register_interruptible(ab8500, AB8500_INTERRUPT,
1417 AB8500_IT_MASK1_REG + ab8500->irq_reg_offset[i], 0xff);
1418 }
1419
1420 ret = abx500_register_ops(ab8500->dev, &ab8500_ops);
1421 if (ret)
1422 return ret;
1423
1424 for (i = 0; i < ab8500->mask_size; i++)
1425 ab8500->mask[i] = ab8500->oldmask[i] = 0xff;
1426
1427 ret = ab8500_irq_init(ab8500, np);
1428 if (ret)
1429 return ret;
1430
1431 /* Activate this feature only in ab9540 */
1432 /* till tests are done on ab8500 1p2 or later*/
1433 if (is_ab9540(ab8500)) {
1434 ret = devm_request_threaded_irq(&pdev->dev, ab8500->irq, NULL,
1435 ab8500_hierarchical_irq,
1436 IRQF_ONESHOT | IRQF_NO_SUSPEND,
1437 "ab8500", ab8500);
1438 }
1439 else {
1440 ret = devm_request_threaded_irq(&pdev->dev, ab8500->irq, NULL,
1441 ab8500_irq,
1442 IRQF_ONESHOT | IRQF_NO_SUSPEND,
1443 "ab8500", ab8500);
1444 if (ret)
1445 return ret;
1446 }
1447
1448 ret = mfd_add_devices(ab8500->dev, 0, abx500_common_devs,
1449 ARRAY_SIZE(abx500_common_devs), NULL,
1450 ab8500->irq_base, ab8500->domain);
1451 if (ret)
1452 return ret;
1453
1454 if (is_ab9540(ab8500))
1455 ret = mfd_add_devices(ab8500->dev, 0, ab9540_devs,
1456 ARRAY_SIZE(ab9540_devs), NULL,
1457 ab8500->irq_base, ab8500->domain);
1458 else
1459 ret = mfd_add_devices(ab8500->dev, 0, ab8500_devs,
1460 ARRAY_SIZE(ab8500_devs), NULL,
1461 ab8500->irq_base, ab8500->domain);
1462 if (ret)
1463 return ret;
1464
1465 if (is_ab9540(ab8500) || is_ab8505(ab8500))
1466 ret = mfd_add_devices(ab8500->dev, 0, ab9540_ab8505_devs,
1467 ARRAY_SIZE(ab9540_ab8505_devs), NULL,
1468 ab8500->irq_base, ab8500->domain);
1469 if (ret)
1470 return ret;
1471
1472 if (!no_bm) {
1473 /* Add battery management devices */
1474 ret = mfd_add_devices(ab8500->dev, 0, ab8500_bm_devs,
1475 ARRAY_SIZE(ab8500_bm_devs), NULL,
1476 ab8500->irq_base, ab8500->domain);
1477 if (ret)
1478 dev_err(ab8500->dev, "error adding bm devices\n");
1479 }
1480
1481 if (is_ab9540(ab8500))
1482 ret = sysfs_create_group(&ab8500->dev->kobj,
1483 &ab9540_attr_group);
1484 else
1485 ret = sysfs_create_group(&ab8500->dev->kobj,
1486 &ab8500_attr_group);
1487 if (ret)
1488 dev_err(ab8500->dev, "error creating sysfs entries\n");
1489
1490 return ret;
1491}
1492
1493static int ab8500_remove(struct platform_device *pdev)
1494{
1495 struct ab8500 *ab8500 = platform_get_drvdata(pdev);
1496
1497 if (is_ab9540(ab8500))
1498 sysfs_remove_group(&ab8500->dev->kobj, &ab9540_attr_group);
1499 else
1500 sysfs_remove_group(&ab8500->dev->kobj, &ab8500_attr_group);
1501
1502 mfd_remove_devices(ab8500->dev);
1503
1504 return 0;
1505}
1506
1507static const struct platform_device_id ab8500_id[] = {
1508 { "ab8500-core", AB8500_VERSION_AB8500 },
1509 { "ab8505-i2c", AB8500_VERSION_AB8505 },
1510 { "ab9540-i2c", AB8500_VERSION_AB9540 },
1511 { "ab8540-i2c", AB8500_VERSION_AB8540 },
1512 { }
1513};
1514
1515static struct platform_driver ab8500_core_driver = {
1516 .driver = {
1517 .name = "ab8500-core",
1518 .owner = THIS_MODULE,
1519 },
1520 .probe = ab8500_probe,
1521 .remove = ab8500_remove,
1522 .id_table = ab8500_id,
1523};
1524
1525static int __init ab8500_core_init(void)
1526{
1527 return platform_driver_register(&ab8500_core_driver);
1528}
1529
1530static void __exit ab8500_core_exit(void)
1531{
1532 platform_driver_unregister(&ab8500_core_driver);
1533}
1534core_initcall(ab8500_core_init);
1535module_exit(ab8500_core_exit);
1536
1537MODULE_AUTHOR("Mattias Wallin, Srinidhi Kasagar, Rabin Vincent");
1538MODULE_DESCRIPTION("AB8500 MFD core");
1539MODULE_LICENSE("GPL v2");