2 * Copyright (C) ST-Ericsson SA 2010
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>
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>
26 #include <linux/of_device.h>
29 * Interrupt register offsets
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
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
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 #define AB8500_IT_MASK25_REG 0x58
101 * latch hierarchy registers
103 #define AB8500_IT_LATCHHIER1_REG 0x60
104 #define AB8500_IT_LATCHHIER2_REG 0x61
105 #define AB8500_IT_LATCHHIER3_REG 0x62
106 #define AB8540_IT_LATCHHIER4_REG 0x63
108 #define AB8500_IT_LATCHHIER_NUM 3
109 #define AB8540_IT_LATCHHIER_NUM 4
111 #define AB8500_REV_REG 0x80
112 #define AB8500_IC_NAME_REG 0x82
113 #define AB8500_SWITCH_OFF_STATUS 0x00
115 #define AB8500_TURN_ON_STATUS 0x00
116 #define AB8505_TURN_ON_STATUS_2 0x04
118 #define AB8500_CH_USBCH_STAT1_REG 0x02
119 #define VBUS_DET_DBNC100 0x02
120 #define VBUS_DET_DBNC1 0x01
122 static DEFINE_SPINLOCK(on_stat_lock);
123 static u8 turn_on_stat_mask = 0xFF;
124 static u8 turn_on_stat_set;
125 static bool no_bm; /* No battery management */
126 module_param(no_bm, bool, S_IRUGO);
128 #define AB9540_MODEM_CTRL2_REG 0x23
129 #define AB9540_MODEM_CTRL2_SWDBBRSTN_BIT BIT(2)
132 * Map interrupt numbers to the LATCH and MASK register offsets, Interrupt
133 * numbers are indexed into this array with (num / 8). The interupts are
134 * defined in linux/mfd/ab8500.h
136 * This is one off from the register names, i.e. AB8500_IT_MASK1_REG is at
140 static const int ab8500_irq_regoffset[AB8500_NUM_IRQ_REGS] = {
141 0, 1, 2, 3, 4, 6, 7, 8, 9, 11, 18, 19, 20, 21,
144 /* AB9540 / AB8505 support */
145 static const int ab9540_irq_regoffset[AB9540_NUM_IRQ_REGS] = {
146 0, 1, 2, 3, 4, 6, 7, 8, 9, 11, 18, 19, 20, 21, 12, 13, 24, 5, 22, 23
150 static const int ab8540_irq_regoffset[AB8540_NUM_IRQ_REGS] = {
151 0, 1, 2, 3, 4, -1, -1, -1, -1, 11, 18, 19, 20, 21, 12, 13, 24, 5, 22,
152 23, 25, 26, 27, 28, 29, 30, 31,
155 static const char ab8500_version_str[][7] = {
156 [AB8500_VERSION_AB8500] = "AB8500",
157 [AB8500_VERSION_AB8505] = "AB8505",
158 [AB8500_VERSION_AB9540] = "AB9540",
159 [AB8500_VERSION_AB8540] = "AB8540",
162 static int ab8500_prcmu_write(struct ab8500 *ab8500, u16 addr, u8 data)
166 ret = prcmu_abb_write((u8)(addr >> 8), (u8)(addr & 0xFF), &data, 1);
168 dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
172 static int ab8500_prcmu_write_masked(struct ab8500 *ab8500, u16 addr, u8 mask,
177 ret = prcmu_abb_write_masked((u8)(addr >> 8), (u8)(addr & 0xFF), &data,
180 dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
184 static int ab8500_prcmu_read(struct ab8500 *ab8500, u16 addr)
189 ret = prcmu_abb_read((u8)(addr >> 8), (u8)(addr & 0xFF), &data, 1);
191 dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
197 static int ab8500_get_chip_id(struct device *dev)
199 struct ab8500 *ab8500;
203 ab8500 = dev_get_drvdata(dev->parent);
204 return ab8500 ? (int)ab8500->chip_id : -EINVAL;
207 static int set_register_interruptible(struct ab8500 *ab8500, u8 bank,
212 * Put the u8 bank and u8 register together into a an u16.
213 * The bank on higher 8 bits and register in lower 8 bits.
215 u16 addr = ((u16)bank) << 8 | reg;
217 dev_vdbg(ab8500->dev, "wr: addr %#x <= %#x\n", addr, data);
219 mutex_lock(&ab8500->lock);
221 ret = ab8500->write(ab8500, addr, data);
223 dev_err(ab8500->dev, "failed to write reg %#x: %d\n",
225 mutex_unlock(&ab8500->lock);
230 static int ab8500_set_register(struct device *dev, u8 bank,
234 struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
236 atomic_inc(&ab8500->transfer_ongoing);
237 ret = set_register_interruptible(ab8500, bank, reg, value);
238 atomic_dec(&ab8500->transfer_ongoing);
242 static int get_register_interruptible(struct ab8500 *ab8500, u8 bank,
246 u16 addr = ((u16)bank) << 8 | reg;
248 mutex_lock(&ab8500->lock);
250 ret = ab8500->read(ab8500, addr);
252 dev_err(ab8500->dev, "failed to read reg %#x: %d\n",
257 mutex_unlock(&ab8500->lock);
258 dev_vdbg(ab8500->dev, "rd: addr %#x => data %#x\n", addr, ret);
263 static int ab8500_get_register(struct device *dev, u8 bank,
267 struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
269 atomic_inc(&ab8500->transfer_ongoing);
270 ret = get_register_interruptible(ab8500, bank, reg, value);
271 atomic_dec(&ab8500->transfer_ongoing);
275 static int mask_and_set_register_interruptible(struct ab8500 *ab8500, u8 bank,
276 u8 reg, u8 bitmask, u8 bitvalues)
279 u16 addr = ((u16)bank) << 8 | reg;
281 mutex_lock(&ab8500->lock);
283 if (ab8500->write_masked == NULL) {
286 ret = ab8500->read(ab8500, addr);
288 dev_err(ab8500->dev, "failed to read reg %#x: %d\n",
294 data = (~bitmask & data) | (bitmask & bitvalues);
296 ret = ab8500->write(ab8500, addr, data);
298 dev_err(ab8500->dev, "failed to write reg %#x: %d\n",
301 dev_vdbg(ab8500->dev, "mask: addr %#x => data %#x\n", addr,
305 ret = ab8500->write_masked(ab8500, addr, bitmask, bitvalues);
307 dev_err(ab8500->dev, "failed to modify reg %#x: %d\n", addr,
310 mutex_unlock(&ab8500->lock);
314 static int ab8500_mask_and_set_register(struct device *dev,
315 u8 bank, u8 reg, u8 bitmask, u8 bitvalues)
318 struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
320 atomic_inc(&ab8500->transfer_ongoing);
321 ret = mask_and_set_register_interruptible(ab8500, bank, reg,
323 atomic_dec(&ab8500->transfer_ongoing);
327 static struct abx500_ops ab8500_ops = {
328 .get_chip_id = ab8500_get_chip_id,
329 .get_register = ab8500_get_register,
330 .set_register = ab8500_set_register,
331 .get_register_page = NULL,
332 .set_register_page = NULL,
333 .mask_and_set_register = ab8500_mask_and_set_register,
334 .event_registers_startup_state_get = NULL,
335 .startup_irq_enabled = NULL,
336 .dump_all_banks = ab8500_dump_all_banks,
339 static void ab8500_irq_lock(struct irq_data *data)
341 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
343 mutex_lock(&ab8500->irq_lock);
344 atomic_inc(&ab8500->transfer_ongoing);
347 static void ab8500_irq_sync_unlock(struct irq_data *data)
349 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
352 for (i = 0; i < ab8500->mask_size; i++) {
353 u8 old = ab8500->oldmask[i];
354 u8 new = ab8500->mask[i];
361 * Interrupt register 12 doesn't exist prior to AB8500 version
364 if (ab8500->irq_reg_offset[i] == 11 &&
365 is_ab8500_1p1_or_earlier(ab8500))
368 if (ab8500->irq_reg_offset[i] < 0)
371 ab8500->oldmask[i] = new;
373 reg = AB8500_IT_MASK1_REG + ab8500->irq_reg_offset[i];
374 set_register_interruptible(ab8500, AB8500_INTERRUPT, reg, new);
376 atomic_dec(&ab8500->transfer_ongoing);
377 mutex_unlock(&ab8500->irq_lock);
380 static void ab8500_irq_mask(struct irq_data *data)
382 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
383 int offset = data->hwirq;
384 int index = offset / 8;
385 int mask = 1 << (offset % 8);
387 ab8500->mask[index] |= mask;
389 /* The AB8500 GPIOs have two interrupts each (rising & falling). */
390 if (offset >= AB8500_INT_GPIO6R && offset <= AB8500_INT_GPIO41R)
391 ab8500->mask[index + 2] |= mask;
392 if (offset >= AB9540_INT_GPIO50R && offset <= AB9540_INT_GPIO54R)
393 ab8500->mask[index + 1] |= mask;
394 if (offset == AB8540_INT_GPIO43R || offset == AB8540_INT_GPIO44R)
395 /* Here the falling IRQ is one bit lower */
396 ab8500->mask[index] |= (mask << 1);
399 static void ab8500_irq_unmask(struct irq_data *data)
401 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
402 unsigned int type = irqd_get_trigger_type(data);
403 int offset = data->hwirq;
404 int index = offset / 8;
405 int mask = 1 << (offset % 8);
407 if (type & IRQ_TYPE_EDGE_RISING)
408 ab8500->mask[index] &= ~mask;
410 /* The AB8500 GPIOs have two interrupts each (rising & falling). */
411 if (type & IRQ_TYPE_EDGE_FALLING) {
412 if (offset >= AB8500_INT_GPIO6R && offset <= AB8500_INT_GPIO41R)
413 ab8500->mask[index + 2] &= ~mask;
414 else if (offset >= AB9540_INT_GPIO50R &&
415 offset <= AB9540_INT_GPIO54R)
416 ab8500->mask[index + 1] &= ~mask;
417 else if (offset == AB8540_INT_GPIO43R ||
418 offset == AB8540_INT_GPIO44R)
419 /* Here the falling IRQ is one bit lower */
420 ab8500->mask[index] &= ~(mask << 1);
422 ab8500->mask[index] &= ~mask;
424 /* Satisfies the case where type is not set. */
425 ab8500->mask[index] &= ~mask;
429 static int ab8500_irq_set_type(struct irq_data *data, unsigned int type)
434 static struct irq_chip ab8500_irq_chip = {
436 .irq_bus_lock = ab8500_irq_lock,
437 .irq_bus_sync_unlock = ab8500_irq_sync_unlock,
438 .irq_mask = ab8500_irq_mask,
439 .irq_disable = ab8500_irq_mask,
440 .irq_unmask = ab8500_irq_unmask,
441 .irq_set_type = ab8500_irq_set_type,
444 static void update_latch_offset(u8 *offset, int i)
446 /* Fix inconsistent ITFromLatch25 bit mapping... */
447 if (unlikely(*offset == 17))
449 /* Fix inconsistent ab8540 bit mapping... */
450 if (unlikely(*offset == 16))
452 if ((i == 3) && (*offset >= 24))
456 static int ab8500_handle_hierarchical_line(struct ab8500 *ab8500,
457 int latch_offset, u8 latch_val)
459 int int_bit, line, i;
461 for (i = 0; i < ab8500->mask_size; i++)
462 if (ab8500->irq_reg_offset[i] == latch_offset)
465 if (i >= ab8500->mask_size) {
466 dev_err(ab8500->dev, "Register offset 0x%2x not declared\n",
471 /* ignore masked out interrupts */
472 latch_val &= ~ab8500->mask[i];
475 int_bit = __ffs(latch_val);
476 line = (i << 3) + int_bit;
477 latch_val &= ~(1 << int_bit);
480 * This handles the falling edge hwirqs from the GPIO
481 * lines. Route them back to the line registered for the
482 * rising IRQ, as this is merely a flag for the same IRQ
485 if (line >= AB8500_INT_GPIO6F && line <= AB8500_INT_GPIO41F)
487 if (line >= AB9540_INT_GPIO50F && line <= AB9540_INT_GPIO54F)
489 if (line == AB8540_INT_GPIO43F || line == AB8540_INT_GPIO44F)
492 handle_nested_irq(irq_create_mapping(ab8500->domain, line));
498 static int ab8500_handle_hierarchical_latch(struct ab8500 *ab8500,
499 int hier_offset, u8 hier_val)
501 int latch_bit, status;
502 u8 latch_offset, latch_val;
505 latch_bit = __ffs(hier_val);
506 latch_offset = (hier_offset << 3) + latch_bit;
508 update_latch_offset(&latch_offset, hier_offset);
510 status = get_register_interruptible(ab8500,
512 AB8500_IT_LATCH1_REG + latch_offset,
514 if (status < 0 || latch_val == 0)
517 status = ab8500_handle_hierarchical_line(ab8500,
518 latch_offset, latch_val);
522 hier_val &= ~(1 << latch_bit);
528 static irqreturn_t ab8500_hierarchical_irq(int irq, void *dev)
530 struct ab8500 *ab8500 = dev;
533 dev_vdbg(ab8500->dev, "interrupt\n");
535 /* Hierarchical interrupt version */
536 for (i = 0; i < (ab8500->it_latchhier_num); i++) {
540 status = get_register_interruptible(ab8500, AB8500_INTERRUPT,
541 AB8500_IT_LATCHHIER1_REG + i, &hier_val);
542 if (status < 0 || hier_val == 0)
545 status = ab8500_handle_hierarchical_latch(ab8500, i, hier_val);
552 static int ab8500_irq_map(struct irq_domain *d, unsigned int virq,
553 irq_hw_number_t hwirq)
555 struct ab8500 *ab8500 = d->host_data;
560 irq_set_chip_data(virq, ab8500);
561 irq_set_chip_and_handler(virq, &ab8500_irq_chip,
563 irq_set_nested_thread(virq, 1);
564 irq_set_noprobe(virq);
569 static const struct irq_domain_ops ab8500_irq_ops = {
570 .map = ab8500_irq_map,
571 .xlate = irq_domain_xlate_twocell,
574 static int ab8500_irq_init(struct ab8500 *ab8500, struct device_node *np)
578 if (is_ab8540(ab8500))
579 num_irqs = AB8540_NR_IRQS;
580 else if (is_ab9540(ab8500))
581 num_irqs = AB9540_NR_IRQS;
582 else if (is_ab8505(ab8500))
583 num_irqs = AB8505_NR_IRQS;
585 num_irqs = AB8500_NR_IRQS;
587 /* If ->irq_base is zero this will give a linear mapping */
588 ab8500->domain = irq_domain_add_simple(ab8500->dev->of_node,
590 &ab8500_irq_ops, ab8500);
592 if (!ab8500->domain) {
593 dev_err(ab8500->dev, "Failed to create irqdomain\n");
600 int ab8500_suspend(struct ab8500 *ab8500)
602 if (atomic_read(&ab8500->transfer_ongoing))
608 static const struct mfd_cell ab8500_bm_devs[] = {
610 .name = "ab8500-charger",
611 .of_compatible = "stericsson,ab8500-charger",
612 .platform_data = &ab8500_bm_data,
613 .pdata_size = sizeof(ab8500_bm_data),
616 .name = "ab8500-btemp",
617 .of_compatible = "stericsson,ab8500-btemp",
618 .platform_data = &ab8500_bm_data,
619 .pdata_size = sizeof(ab8500_bm_data),
623 .of_compatible = "stericsson,ab8500-fg",
624 .platform_data = &ab8500_bm_data,
625 .pdata_size = sizeof(ab8500_bm_data),
628 .name = "ab8500-chargalg",
629 .of_compatible = "stericsson,ab8500-chargalg",
630 .platform_data = &ab8500_bm_data,
631 .pdata_size = sizeof(ab8500_bm_data),
635 static const struct mfd_cell ab8500_devs[] = {
636 #ifdef CONFIG_DEBUG_FS
637 OF_MFD_CELL("ab8500-debug",
638 NULL, NULL, 0, "stericsson,ab8500-debug"),
640 OF_MFD_CELL("ab8500-sysctrl",
641 NULL, NULL, 0, "stericsson,ab8500-sysctrl"),
642 OF_MFD_CELL("ab8500-ext-regulator",
643 NULL, NULL, 0, "stericsson,ab8500-ext-regulator"),
644 OF_MFD_CELL("ab8500-regulator",
645 NULL, NULL, 0, "stericsson,ab8500-regulator"),
646 OF_MFD_CELL("abx500-clk",
647 NULL, NULL, 0, "stericsson,abx500-clk"),
648 OF_MFD_CELL("ab8500-gpadc",
649 NULL, NULL, 0, "stericsson,ab8500-gpadc"),
650 OF_MFD_CELL("ab8500-rtc",
651 NULL, NULL, 0, "stericsson,ab8500-rtc"),
652 OF_MFD_CELL("ab8500-acc-det",
653 NULL, NULL, 0, "stericsson,ab8500-acc-det"),
654 OF_MFD_CELL("ab8500-poweron-key",
655 NULL, NULL, 0, "stericsson,ab8500-poweron-key"),
656 OF_MFD_CELL("ab8500-pwm",
657 NULL, NULL, 1, "stericsson,ab8500-pwm"),
658 OF_MFD_CELL("ab8500-pwm",
659 NULL, NULL, 2, "stericsson,ab8500-pwm"),
660 OF_MFD_CELL("ab8500-pwm",
661 NULL, NULL, 3, "stericsson,ab8500-pwm"),
662 OF_MFD_CELL("ab8500-denc",
663 NULL, NULL, 0, "stericsson,ab8500-denc"),
664 OF_MFD_CELL("pinctrl-ab8500",
665 NULL, NULL, 0, "stericsson,ab8500-gpio"),
666 OF_MFD_CELL("abx500-temp",
667 NULL, NULL, 0, "stericsson,abx500-temp"),
668 OF_MFD_CELL("ab8500-usb",
669 NULL, NULL, 0, "stericsson,ab8500-usb"),
670 OF_MFD_CELL("ab8500-codec",
671 NULL, NULL, 0, "stericsson,ab8500-codec"),
674 static const struct mfd_cell ab9540_devs[] = {
675 #ifdef CONFIG_DEBUG_FS
677 .name = "ab8500-debug",
681 .name = "ab8500-sysctrl",
684 .name = "ab8500-ext-regulator",
687 .name = "ab8500-regulator",
690 .name = "abx500-clk",
691 .of_compatible = "stericsson,abx500-clk",
694 .name = "ab8500-gpadc",
695 .of_compatible = "stericsson,ab8500-gpadc",
698 .name = "ab8500-rtc",
701 .name = "ab8500-acc-det",
704 .name = "ab8500-poweron-key",
707 .name = "ab8500-pwm",
711 .name = "abx500-temp",
714 .name = "pinctrl-ab9540",
715 .of_compatible = "stericsson,ab9540-gpio",
718 .name = "ab9540-usb",
721 .name = "ab9540-codec",
728 /* Device list for ab8505 */
729 static const struct mfd_cell ab8505_devs[] = {
730 #ifdef CONFIG_DEBUG_FS
732 .name = "ab8500-debug",
736 .name = "ab8500-sysctrl",
739 .name = "ab8500-regulator",
742 .name = "abx500-clk",
743 .of_compatible = "stericsson,abx500-clk",
746 .name = "ab8500-gpadc",
747 .of_compatible = "stericsson,ab8500-gpadc",
750 .name = "ab8500-rtc",
753 .name = "ab8500-acc-det",
756 .name = "ab8500-poweron-key",
759 .name = "ab8500-pwm",
763 .name = "pinctrl-ab8505",
766 .name = "ab8500-usb",
769 .name = "ab8500-codec",
776 static const struct mfd_cell ab8540_devs[] = {
777 #ifdef CONFIG_DEBUG_FS
779 .name = "ab8500-debug",
783 .name = "ab8500-sysctrl",
786 .name = "ab8500-ext-regulator",
789 .name = "ab8500-regulator",
792 .name = "abx500-clk",
793 .of_compatible = "stericsson,abx500-clk",
796 .name = "ab8500-gpadc",
797 .of_compatible = "stericsson,ab8500-gpadc",
800 .name = "ab8500-acc-det",
803 .name = "ab8500-poweron-key",
806 .name = "ab8500-pwm",
810 .name = "abx500-temp",
813 .name = "pinctrl-ab8540",
816 .name = "ab8540-usb",
819 .name = "ab8540-codec",
826 static const struct mfd_cell ab8540_cut1_devs[] = {
828 .name = "ab8500-rtc",
829 .of_compatible = "stericsson,ab8500-rtc",
833 static const struct mfd_cell ab8540_cut2_devs[] = {
835 .name = "ab8540-rtc",
836 .of_compatible = "stericsson,ab8540-rtc",
840 static ssize_t show_chip_id(struct device *dev,
841 struct device_attribute *attr, char *buf)
843 struct ab8500 *ab8500;
845 ab8500 = dev_get_drvdata(dev);
847 return sprintf(buf, "%#x\n", ab8500 ? ab8500->chip_id : -EINVAL);
851 * ab8500 has switched off due to (SWITCH_OFF_STATUS):
852 * 0x01 Swoff bit programming
853 * 0x02 Thermal protection activation
854 * 0x04 Vbat lower then BattOk falling threshold
855 * 0x08 Watchdog expired
856 * 0x10 Non presence of 32kHz clock
857 * 0x20 Battery level lower than power on reset threshold
858 * 0x40 Power on key 1 pressed longer than 10 seconds
859 * 0x80 DB8500 thermal shutdown
861 static ssize_t show_switch_off_status(struct device *dev,
862 struct device_attribute *attr, char *buf)
866 struct ab8500 *ab8500;
868 ab8500 = dev_get_drvdata(dev);
869 ret = get_register_interruptible(ab8500, AB8500_RTC,
870 AB8500_SWITCH_OFF_STATUS, &value);
873 return sprintf(buf, "%#x\n", value);
876 /* use mask and set to override the register turn_on_stat value */
877 void ab8500_override_turn_on_stat(u8 mask, u8 set)
879 spin_lock(&on_stat_lock);
880 turn_on_stat_mask = mask;
881 turn_on_stat_set = set;
882 spin_unlock(&on_stat_lock);
886 * ab8500 has turned on due to (TURN_ON_STATUS):
896 static ssize_t show_turn_on_status(struct device *dev,
897 struct device_attribute *attr, char *buf)
901 struct ab8500 *ab8500;
903 ab8500 = dev_get_drvdata(dev);
904 ret = get_register_interruptible(ab8500, AB8500_SYS_CTRL1_BLOCK,
905 AB8500_TURN_ON_STATUS, &value);
910 * In L9540, turn_on_status register is not updated correctly if
911 * the device is rebooted with AC/USB charger connected. Due to
912 * this, the device boots android instead of entering into charge
913 * only mode. Read the AC/USB status register to detect the charger
914 * presence and update the turn on status manually.
916 if (is_ab9540(ab8500)) {
917 spin_lock(&on_stat_lock);
918 value = (value & turn_on_stat_mask) | turn_on_stat_set;
919 spin_unlock(&on_stat_lock);
922 return sprintf(buf, "%#x\n", value);
925 static ssize_t show_turn_on_status_2(struct device *dev,
926 struct device_attribute *attr, char *buf)
930 struct ab8500 *ab8500;
932 ab8500 = dev_get_drvdata(dev);
933 ret = get_register_interruptible(ab8500, AB8500_SYS_CTRL1_BLOCK,
934 AB8505_TURN_ON_STATUS_2, &value);
937 return sprintf(buf, "%#x\n", (value & 0x1));
940 static ssize_t show_ab9540_dbbrstn(struct device *dev,
941 struct device_attribute *attr, char *buf)
943 struct ab8500 *ab8500;
947 ab8500 = dev_get_drvdata(dev);
949 ret = get_register_interruptible(ab8500, AB8500_REGU_CTRL2,
950 AB9540_MODEM_CTRL2_REG, &value);
954 return sprintf(buf, "%d\n",
955 (value & AB9540_MODEM_CTRL2_SWDBBRSTN_BIT) ? 1 : 0);
958 static ssize_t store_ab9540_dbbrstn(struct device *dev,
959 struct device_attribute *attr, const char *buf, size_t count)
961 struct ab8500 *ab8500;
966 ab8500 = dev_get_drvdata(dev);
974 bitvalues = AB9540_MODEM_CTRL2_SWDBBRSTN_BIT;
980 err = mask_and_set_register_interruptible(ab8500,
981 AB8500_REGU_CTRL2, AB9540_MODEM_CTRL2_REG,
982 AB9540_MODEM_CTRL2_SWDBBRSTN_BIT, bitvalues);
984 dev_info(ab8500->dev,
985 "Failed to set DBBRSTN %c, err %#x\n",
993 static DEVICE_ATTR(chip_id, S_IRUGO, show_chip_id, NULL);
994 static DEVICE_ATTR(switch_off_status, S_IRUGO, show_switch_off_status, NULL);
995 static DEVICE_ATTR(turn_on_status, S_IRUGO, show_turn_on_status, NULL);
996 static DEVICE_ATTR(turn_on_status_2, S_IRUGO, show_turn_on_status_2, NULL);
997 static DEVICE_ATTR(dbbrstn, S_IRUGO | S_IWUSR,
998 show_ab9540_dbbrstn, store_ab9540_dbbrstn);
1000 static struct attribute *ab8500_sysfs_entries[] = {
1001 &dev_attr_chip_id.attr,
1002 &dev_attr_switch_off_status.attr,
1003 &dev_attr_turn_on_status.attr,
1007 static struct attribute *ab8505_sysfs_entries[] = {
1008 &dev_attr_turn_on_status_2.attr,
1012 static struct attribute *ab9540_sysfs_entries[] = {
1013 &dev_attr_chip_id.attr,
1014 &dev_attr_switch_off_status.attr,
1015 &dev_attr_turn_on_status.attr,
1016 &dev_attr_dbbrstn.attr,
1020 static struct attribute_group ab8500_attr_group = {
1021 .attrs = ab8500_sysfs_entries,
1024 static struct attribute_group ab8505_attr_group = {
1025 .attrs = ab8505_sysfs_entries,
1028 static struct attribute_group ab9540_attr_group = {
1029 .attrs = ab9540_sysfs_entries,
1032 static int ab8500_probe(struct platform_device *pdev)
1034 static const char * const switch_off_status[] = {
1035 "Swoff bit programming",
1036 "Thermal protection activation",
1037 "Vbat lower then BattOk falling threshold",
1039 "Non presence of 32kHz clock",
1040 "Battery level lower than power on reset threshold",
1041 "Power on key 1 pressed longer than 10 seconds",
1042 "DB8500 thermal shutdown"};
1043 static const char * const turn_on_status[] = {
1044 "Battery rising (Vbat)",
1045 "Power On Key 1 dbF",
1046 "Power On Key 2 dbF",
1048 "Main Charger Detect",
1049 "Vbus Detect (USB)",
1051 "UART Factory Mode Detect"};
1052 struct ab8500_platform_data *plat = dev_get_platdata(&pdev->dev);
1053 const struct platform_device_id *platid = platform_get_device_id(pdev);
1054 enum ab8500_version version = AB8500_VERSION_UNDEFINED;
1055 struct device_node *np = pdev->dev.of_node;
1056 struct ab8500 *ab8500;
1057 struct resource *resource;
1062 ab8500 = devm_kzalloc(&pdev->dev, sizeof(*ab8500), GFP_KERNEL);
1066 ab8500->dev = &pdev->dev;
1068 resource = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1070 dev_err(&pdev->dev, "no IRQ resource\n");
1074 ab8500->irq = resource->start;
1076 ab8500->read = ab8500_prcmu_read;
1077 ab8500->write = ab8500_prcmu_write;
1078 ab8500->write_masked = ab8500_prcmu_write_masked;
1080 mutex_init(&ab8500->lock);
1081 mutex_init(&ab8500->irq_lock);
1082 atomic_set(&ab8500->transfer_ongoing, 0);
1084 platform_set_drvdata(pdev, ab8500);
1087 version = platid->driver_data;
1089 if (version != AB8500_VERSION_UNDEFINED)
1090 ab8500->version = version;
1092 ret = get_register_interruptible(ab8500, AB8500_MISC,
1093 AB8500_IC_NAME_REG, &value);
1095 dev_err(&pdev->dev, "could not probe HW\n");
1099 ab8500->version = value;
1102 ret = get_register_interruptible(ab8500, AB8500_MISC,
1103 AB8500_REV_REG, &value);
1107 ab8500->chip_id = value;
1109 dev_info(ab8500->dev, "detected chip, %s rev. %1x.%1x\n",
1110 ab8500_version_str[ab8500->version],
1111 ab8500->chip_id >> 4,
1112 ab8500->chip_id & 0x0F);
1114 /* Configure AB8540 */
1115 if (is_ab8540(ab8500)) {
1116 ab8500->mask_size = AB8540_NUM_IRQ_REGS;
1117 ab8500->irq_reg_offset = ab8540_irq_regoffset;
1118 ab8500->it_latchhier_num = AB8540_IT_LATCHHIER_NUM;
1119 } /* Configure AB8500 or AB9540 IRQ */
1120 else if (is_ab9540(ab8500) || is_ab8505(ab8500)) {
1121 ab8500->mask_size = AB9540_NUM_IRQ_REGS;
1122 ab8500->irq_reg_offset = ab9540_irq_regoffset;
1123 ab8500->it_latchhier_num = AB8500_IT_LATCHHIER_NUM;
1125 ab8500->mask_size = AB8500_NUM_IRQ_REGS;
1126 ab8500->irq_reg_offset = ab8500_irq_regoffset;
1127 ab8500->it_latchhier_num = AB8500_IT_LATCHHIER_NUM;
1129 ab8500->mask = devm_kzalloc(&pdev->dev, ab8500->mask_size,
1133 ab8500->oldmask = devm_kzalloc(&pdev->dev, ab8500->mask_size,
1135 if (!ab8500->oldmask)
1139 * ab8500 has switched off due to (SWITCH_OFF_STATUS):
1140 * 0x01 Swoff bit programming
1141 * 0x02 Thermal protection activation
1142 * 0x04 Vbat lower then BattOk falling threshold
1143 * 0x08 Watchdog expired
1144 * 0x10 Non presence of 32kHz clock
1145 * 0x20 Battery level lower than power on reset threshold
1146 * 0x40 Power on key 1 pressed longer than 10 seconds
1147 * 0x80 DB8500 thermal shutdown
1150 ret = get_register_interruptible(ab8500, AB8500_RTC,
1151 AB8500_SWITCH_OFF_STATUS, &value);
1154 dev_info(ab8500->dev, "switch off cause(s) (%#x): ", value);
1157 for (i = 0; i < ARRAY_SIZE(switch_off_status); i++) {
1159 pr_cont(" \"%s\"", switch_off_status[i]);
1167 ret = get_register_interruptible(ab8500, AB8500_SYS_CTRL1_BLOCK,
1168 AB8500_TURN_ON_STATUS, &value);
1171 dev_info(ab8500->dev, "turn on reason(s) (%#x): ", value);
1174 for (i = 0; i < ARRAY_SIZE(turn_on_status); i++) {
1176 pr_cont("\"%s\" ", turn_on_status[i]);
1184 if (plat && plat->init)
1187 if (is_ab9540(ab8500)) {
1188 ret = get_register_interruptible(ab8500, AB8500_CHARGER,
1189 AB8500_CH_USBCH_STAT1_REG, &value);
1192 if ((value & VBUS_DET_DBNC1) && (value & VBUS_DET_DBNC100))
1193 ab8500_override_turn_on_stat(~AB8500_POW_KEY_1_ON,
1197 /* Clear and mask all interrupts */
1198 for (i = 0; i < ab8500->mask_size; i++) {
1200 * Interrupt register 12 doesn't exist prior to AB8500 version
1203 if (ab8500->irq_reg_offset[i] == 11 &&
1204 is_ab8500_1p1_or_earlier(ab8500))
1207 if (ab8500->irq_reg_offset[i] < 0)
1210 get_register_interruptible(ab8500, AB8500_INTERRUPT,
1211 AB8500_IT_LATCH1_REG + ab8500->irq_reg_offset[i],
1213 set_register_interruptible(ab8500, AB8500_INTERRUPT,
1214 AB8500_IT_MASK1_REG + ab8500->irq_reg_offset[i], 0xff);
1217 ret = abx500_register_ops(ab8500->dev, &ab8500_ops);
1221 for (i = 0; i < ab8500->mask_size; i++)
1222 ab8500->mask[i] = ab8500->oldmask[i] = 0xff;
1224 ret = ab8500_irq_init(ab8500, np);
1228 ret = devm_request_threaded_irq(&pdev->dev, ab8500->irq, NULL,
1229 ab8500_hierarchical_irq,
1230 IRQF_ONESHOT | IRQF_NO_SUSPEND,
1235 if (is_ab9540(ab8500))
1236 ret = mfd_add_devices(ab8500->dev, 0, ab9540_devs,
1237 ARRAY_SIZE(ab9540_devs), NULL,
1239 else if (is_ab8540(ab8500)) {
1240 ret = mfd_add_devices(ab8500->dev, 0, ab8540_devs,
1241 ARRAY_SIZE(ab8540_devs), NULL,
1246 if (is_ab8540_1p2_or_earlier(ab8500))
1247 ret = mfd_add_devices(ab8500->dev, 0, ab8540_cut1_devs,
1248 ARRAY_SIZE(ab8540_cut1_devs), NULL,
1250 else /* ab8540 >= cut2 */
1251 ret = mfd_add_devices(ab8500->dev, 0, ab8540_cut2_devs,
1252 ARRAY_SIZE(ab8540_cut2_devs), NULL,
1254 } else if (is_ab8505(ab8500))
1255 ret = mfd_add_devices(ab8500->dev, 0, ab8505_devs,
1256 ARRAY_SIZE(ab8505_devs), NULL,
1259 ret = mfd_add_devices(ab8500->dev, 0, ab8500_devs,
1260 ARRAY_SIZE(ab8500_devs), NULL,
1266 /* Add battery management devices */
1267 ret = mfd_add_devices(ab8500->dev, 0, ab8500_bm_devs,
1268 ARRAY_SIZE(ab8500_bm_devs), NULL,
1271 dev_err(ab8500->dev, "error adding bm devices\n");
1274 if (((is_ab8505(ab8500) || is_ab9540(ab8500)) &&
1275 ab8500->chip_id >= AB8500_CUT2P0) || is_ab8540(ab8500))
1276 ret = sysfs_create_group(&ab8500->dev->kobj,
1277 &ab9540_attr_group);
1279 ret = sysfs_create_group(&ab8500->dev->kobj,
1280 &ab8500_attr_group);
1282 if ((is_ab8505(ab8500) || is_ab9540(ab8500)) &&
1283 ab8500->chip_id >= AB8500_CUT2P0)
1284 ret = sysfs_create_group(&ab8500->dev->kobj,
1285 &ab8505_attr_group);
1288 dev_err(ab8500->dev, "error creating sysfs entries\n");
1293 static int ab8500_remove(struct platform_device *pdev)
1295 struct ab8500 *ab8500 = platform_get_drvdata(pdev);
1297 if (((is_ab8505(ab8500) || is_ab9540(ab8500)) &&
1298 ab8500->chip_id >= AB8500_CUT2P0) || is_ab8540(ab8500))
1299 sysfs_remove_group(&ab8500->dev->kobj, &ab9540_attr_group);
1301 sysfs_remove_group(&ab8500->dev->kobj, &ab8500_attr_group);
1303 if ((is_ab8505(ab8500) || is_ab9540(ab8500)) &&
1304 ab8500->chip_id >= AB8500_CUT2P0)
1305 sysfs_remove_group(&ab8500->dev->kobj, &ab8505_attr_group);
1307 mfd_remove_devices(ab8500->dev);
1312 static const struct platform_device_id ab8500_id[] = {
1313 { "ab8500-core", AB8500_VERSION_AB8500 },
1314 { "ab8505-i2c", AB8500_VERSION_AB8505 },
1315 { "ab9540-i2c", AB8500_VERSION_AB9540 },
1316 { "ab8540-i2c", AB8500_VERSION_AB8540 },
1320 static struct platform_driver ab8500_core_driver = {
1322 .name = "ab8500-core",
1324 .probe = ab8500_probe,
1325 .remove = ab8500_remove,
1326 .id_table = ab8500_id,
1329 static int __init ab8500_core_init(void)
1331 return platform_driver_register(&ab8500_core_driver);
1334 static void __exit ab8500_core_exit(void)
1336 platform_driver_unregister(&ab8500_core_driver);
1338 core_initcall(ab8500_core_init);
1339 module_exit(ab8500_core_exit);
1341 MODULE_AUTHOR("Mattias Wallin, Srinidhi Kasagar, Rabin Vincent");
1342 MODULE_DESCRIPTION("AB8500 MFD core");
1343 MODULE_LICENSE("GPL v2");