2 * Copyright (C) ST Ericsson SA 2010
4 * License Terms: GNU General Public License v2
5 * Author: Mattias Nilsson <mattias.i.nilsson@stericsson.com>
9 #include <linux/kernel.h>
10 #include <linux/module.h>
11 #include <linux/errno.h>
12 #include <linux/err.h>
14 #include <linux/mutex.h>
15 #include <linux/completion.h>
16 #include <linux/jiffies.h>
17 #include <linux/bitops.h>
18 #include <linux/interrupt.h>
20 #include <mach/hardware.h>
21 #include <mach/prcmu-regs.h>
23 #define PRCMU_TCDM_BASE __io_address(U8500_PRCMU_TCDM_BASE)
25 #define REQ_MB5 (PRCMU_TCDM_BASE + 0xE44)
26 #define ACK_MB5 (PRCMU_TCDM_BASE + 0xDF4)
28 #define REQ_MB5_I2C_SLAVE_OP (REQ_MB5)
29 #define REQ_MB5_I2C_HW_BITS (REQ_MB5 + 1)
30 #define REQ_MB5_I2C_REG (REQ_MB5 + 2)
31 #define REQ_MB5_I2C_VAL (REQ_MB5 + 3)
33 #define ACK_MB5_I2C_STATUS (ACK_MB5 + 1)
34 #define ACK_MB5_I2C_VAL (ACK_MB5 + 3)
36 #define I2C_WRITE(slave) ((slave) << 1)
37 #define I2C_READ(slave) (((slave) << 1) | BIT(0))
38 #define I2C_STOP_EN BIT(3)
50 struct completion work;
59 * prcmu_abb_read() - Read register value(s) from the ABB.
60 * @slave: The I2C slave address.
61 * @reg: The (start) register address.
62 * @value: The read out value(s).
63 * @size: The number of registers to read.
65 * Reads register value(s) from the ABB.
66 * @size has to be 1 for the current firmware version.
68 int prcmu_abb_read(u8 slave, u8 reg, u8 *value, u8 size)
75 r = mutex_lock_interruptible(&mb5_transfer.lock);
79 while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(5))
82 writeb(I2C_READ(slave), REQ_MB5_I2C_SLAVE_OP);
83 writeb(I2C_STOP_EN, REQ_MB5_I2C_HW_BITS);
84 writeb(reg, REQ_MB5_I2C_REG);
86 writel(MBOX_BIT(5), PRCM_MBOX_CPU_SET);
87 if (!wait_for_completion_timeout(&mb5_transfer.work,
88 msecs_to_jiffies(500))) {
89 pr_err("prcmu: prcmu_abb_read timed out.\n");
91 goto unlock_and_return;
93 r = ((mb5_transfer.ack.status == I2C_RD_OK) ? 0 : -EIO);
95 *value = mb5_transfer.ack.value;
98 mutex_unlock(&mb5_transfer.lock);
101 EXPORT_SYMBOL(prcmu_abb_read);
104 * prcmu_abb_write() - Write register value(s) to the ABB.
105 * @slave: The I2C slave address.
106 * @reg: The (start) register address.
107 * @value: The value(s) to write.
108 * @size: The number of registers to write.
110 * Reads register value(s) from the ABB.
111 * @size has to be 1 for the current firmware version.
113 int prcmu_abb_write(u8 slave, u8 reg, u8 *value, u8 size)
120 r = mutex_lock_interruptible(&mb5_transfer.lock);
125 while (readl(PRCM_MBOX_CPU_VAL) & MBOX_BIT(5))
128 writeb(I2C_WRITE(slave), REQ_MB5_I2C_SLAVE_OP);
129 writeb(I2C_STOP_EN, REQ_MB5_I2C_HW_BITS);
130 writeb(reg, REQ_MB5_I2C_REG);
131 writeb(*value, REQ_MB5_I2C_VAL);
133 writel(MBOX_BIT(5), PRCM_MBOX_CPU_SET);
134 if (!wait_for_completion_timeout(&mb5_transfer.work,
135 msecs_to_jiffies(500))) {
136 pr_err("prcmu: prcmu_abb_write timed out.\n");
138 goto unlock_and_return;
140 r = ((mb5_transfer.ack.status == I2C_WR_OK) ? 0 : -EIO);
143 mutex_unlock(&mb5_transfer.lock);
146 EXPORT_SYMBOL(prcmu_abb_write);
148 static void read_mailbox_0(void)
150 writel(MBOX_BIT(0), PRCM_ARM_IT1_CLEAR);
153 static void read_mailbox_1(void)
155 writel(MBOX_BIT(1), PRCM_ARM_IT1_CLEAR);
158 static void read_mailbox_2(void)
160 writel(MBOX_BIT(2), PRCM_ARM_IT1_CLEAR);
163 static void read_mailbox_3(void)
165 writel(MBOX_BIT(3), PRCM_ARM_IT1_CLEAR);
168 static void read_mailbox_4(void)
170 writel(MBOX_BIT(4), PRCM_ARM_IT1_CLEAR);
173 static void read_mailbox_5(void)
175 mb5_transfer.ack.status = readb(ACK_MB5_I2C_STATUS);
176 mb5_transfer.ack.value = readb(ACK_MB5_I2C_VAL);
177 complete(&mb5_transfer.work);
178 writel(MBOX_BIT(5), PRCM_ARM_IT1_CLEAR);
181 static void read_mailbox_6(void)
183 writel(MBOX_BIT(6), PRCM_ARM_IT1_CLEAR);
186 static void read_mailbox_7(void)
188 writel(MBOX_BIT(7), PRCM_ARM_IT1_CLEAR);
191 static void (* const read_mailbox[NUM_MBOX])(void) = {
202 static irqreturn_t prcmu_irq_handler(int irq, void *data)
207 bits = (readl(PRCM_ARM_IT1_VAL) & (MBOX_BIT(NUM_MBOX) - 1));
211 for (n = 0; bits; n++) {
212 if (bits & MBOX_BIT(n)) {
220 static int __init prcmu_init(void)
222 mutex_init(&mb5_transfer.lock);
223 init_completion(&mb5_transfer.work);
225 /* Clean up the mailbox interrupts after pre-kernel code. */
226 writel((MBOX_BIT(NUM_MBOX) - 1), PRCM_ARM_IT1_CLEAR);
228 return request_irq(IRQ_PRCMU, prcmu_irq_handler, 0, "prcmu", NULL);
231 arch_initcall(prcmu_init);