4 * I2C adapter for the PXA I2C bus access.
6 * Copyright (C) 2002 Intrinsyc Software Inc.
7 * Copyright (C) 2004-2005 Deep Blue Solutions Ltd.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
14 * Apr 2002: Initial version [CS]
15 * Jun 2002: Properly separated algo/adap [FB]
16 * Jan 2003: Fixed several bugs concerning interrupt handling [Kai-Uwe Bloem]
17 * Jan 2003: added limited signal handling [Kai-Uwe Bloem]
18 * Sep 2004: Major rework to ensure efficient bus handling [RMK]
19 * Dec 2004: Added support for PXA27x and slave device probing [Liam Girdwood]
20 * Feb 2005: Rework slave mode handling [RMK]
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/i2c.h>
25 #include <linux/i2c-id.h>
26 #include <linux/init.h>
27 #include <linux/time.h>
28 #include <linux/sched.h>
29 #include <linux/delay.h>
30 #include <linux/errno.h>
31 #include <linux/interrupt.h>
32 #include <linux/i2c-pxa.h>
33 #include <linux/platform_device.h>
34 #include <linux/err.h>
35 #include <linux/clk.h>
36 #include <linux/slab.h>
43 * I2C register offsets will be shifted 0 or 1 bit left, depending on
46 #define REG_SHIFT_0 (0 << 0)
47 #define REG_SHIFT_1 (1 << 0)
48 #define REG_SHIFT(d) ((d) & 0x1)
50 static const struct platform_device_id i2c_pxa_id_table
[] = {
51 { "pxa2xx-i2c", REG_SHIFT_1
},
52 { "pxa3xx-pwri2c", REG_SHIFT_0
},
55 MODULE_DEVICE_TABLE(platform
, i2c_pxa_id_table
);
58 * I2C registers and bit definitions
66 #define ICR_START (1 << 0) /* start bit */
67 #define ICR_STOP (1 << 1) /* stop bit */
68 #define ICR_ACKNAK (1 << 2) /* send ACK(0) or NAK(1) */
69 #define ICR_TB (1 << 3) /* transfer byte bit */
70 #define ICR_MA (1 << 4) /* master abort */
71 #define ICR_SCLE (1 << 5) /* master clock enable */
72 #define ICR_IUE (1 << 6) /* unit enable */
73 #define ICR_GCD (1 << 7) /* general call disable */
74 #define ICR_ITEIE (1 << 8) /* enable tx interrupts */
75 #define ICR_IRFIE (1 << 9) /* enable rx interrupts */
76 #define ICR_BEIE (1 << 10) /* enable bus error ints */
77 #define ICR_SSDIE (1 << 11) /* slave STOP detected int enable */
78 #define ICR_ALDIE (1 << 12) /* enable arbitration interrupt */
79 #define ICR_SADIE (1 << 13) /* slave address detected int enable */
80 #define ICR_UR (1 << 14) /* unit reset */
81 #define ICR_FM (1 << 15) /* fast mode */
83 #define ISR_RWM (1 << 0) /* read/write mode */
84 #define ISR_ACKNAK (1 << 1) /* ack/nak status */
85 #define ISR_UB (1 << 2) /* unit busy */
86 #define ISR_IBB (1 << 3) /* bus busy */
87 #define ISR_SSD (1 << 4) /* slave stop detected */
88 #define ISR_ALD (1 << 5) /* arbitration loss detected */
89 #define ISR_ITE (1 << 6) /* tx buffer empty */
90 #define ISR_IRF (1 << 7) /* rx buffer full */
91 #define ISR_GCAD (1 << 8) /* general call address detected */
92 #define ISR_SAD (1 << 9) /* slave address detected */
93 #define ISR_BED (1 << 10) /* bus error no ACK/NAK */
97 wait_queue_head_t wait
;
100 unsigned int msg_idx
;
101 unsigned int msg_ptr
;
102 unsigned int slave_addr
;
104 struct i2c_adapter adap
;
106 #ifdef CONFIG_I2C_PXA_SLAVE
107 struct i2c_slave_client
*slave
;
110 unsigned int irqlogidx
;
114 void __iomem
*reg_base
;
115 unsigned int reg_shift
;
117 unsigned long iobase
;
118 unsigned long iosize
;
121 unsigned int use_pio
:1;
122 unsigned int fast_mode
:1;
125 #define _IBMR(i2c) ((i2c)->reg_base + (0x0 << (i2c)->reg_shift))
126 #define _IDBR(i2c) ((i2c)->reg_base + (0x4 << (i2c)->reg_shift))
127 #define _ICR(i2c) ((i2c)->reg_base + (0x8 << (i2c)->reg_shift))
128 #define _ISR(i2c) ((i2c)->reg_base + (0xc << (i2c)->reg_shift))
129 #define _ISAR(i2c) ((i2c)->reg_base + (0x10 << (i2c)->reg_shift))
132 * I2C Slave mode address
134 #define I2C_PXA_SLAVE_ADDR 0x1
143 #define PXA_BIT(m, s, u) { .mask = m, .set = s, .unset = u }
146 decode_bits(const char *prefix
, const struct bits
*bits
, int num
, u32 val
)
148 printk("%s %08x: ", prefix
, val
);
150 const char *str
= val
& bits
->mask
? bits
->set
: bits
->unset
;
157 static const struct bits isr_bits
[] = {
158 PXA_BIT(ISR_RWM
, "RX", "TX"),
159 PXA_BIT(ISR_ACKNAK
, "NAK", "ACK"),
160 PXA_BIT(ISR_UB
, "Bsy", "Rdy"),
161 PXA_BIT(ISR_IBB
, "BusBsy", "BusRdy"),
162 PXA_BIT(ISR_SSD
, "SlaveStop", NULL
),
163 PXA_BIT(ISR_ALD
, "ALD", NULL
),
164 PXA_BIT(ISR_ITE
, "TxEmpty", NULL
),
165 PXA_BIT(ISR_IRF
, "RxFull", NULL
),
166 PXA_BIT(ISR_GCAD
, "GenCall", NULL
),
167 PXA_BIT(ISR_SAD
, "SlaveAddr", NULL
),
168 PXA_BIT(ISR_BED
, "BusErr", NULL
),
171 static void decode_ISR(unsigned int val
)
173 decode_bits(KERN_DEBUG
"ISR", isr_bits
, ARRAY_SIZE(isr_bits
), val
);
177 static const struct bits icr_bits
[] = {
178 PXA_BIT(ICR_START
, "START", NULL
),
179 PXA_BIT(ICR_STOP
, "STOP", NULL
),
180 PXA_BIT(ICR_ACKNAK
, "ACKNAK", NULL
),
181 PXA_BIT(ICR_TB
, "TB", NULL
),
182 PXA_BIT(ICR_MA
, "MA", NULL
),
183 PXA_BIT(ICR_SCLE
, "SCLE", "scle"),
184 PXA_BIT(ICR_IUE
, "IUE", "iue"),
185 PXA_BIT(ICR_GCD
, "GCD", NULL
),
186 PXA_BIT(ICR_ITEIE
, "ITEIE", NULL
),
187 PXA_BIT(ICR_IRFIE
, "IRFIE", NULL
),
188 PXA_BIT(ICR_BEIE
, "BEIE", NULL
),
189 PXA_BIT(ICR_SSDIE
, "SSDIE", NULL
),
190 PXA_BIT(ICR_ALDIE
, "ALDIE", NULL
),
191 PXA_BIT(ICR_SADIE
, "SADIE", NULL
),
192 PXA_BIT(ICR_UR
, "UR", "ur"),
195 #ifdef CONFIG_I2C_PXA_SLAVE
196 static void decode_ICR(unsigned int val
)
198 decode_bits(KERN_DEBUG
"ICR", icr_bits
, ARRAY_SIZE(icr_bits
), val
);
203 static unsigned int i2c_debug
= DEBUG
;
205 static void i2c_pxa_show_state(struct pxa_i2c
*i2c
, int lno
, const char *fname
)
207 dev_dbg(&i2c
->adap
.dev
, "state:%s:%d: ISR=%08x, ICR=%08x, IBMR=%02x\n", fname
, lno
,
208 readl(_ISR(i2c
)), readl(_ICR(i2c
)), readl(_IBMR(i2c
)));
211 #define show_state(i2c) i2c_pxa_show_state(i2c, __LINE__, __func__)
213 static void i2c_pxa_scream_blue_murder(struct pxa_i2c
*i2c
, const char *why
)
216 printk(KERN_ERR
"i2c: error: %s\n", why
);
217 printk(KERN_ERR
"i2c: msg_num: %d msg_idx: %d msg_ptr: %d\n",
218 i2c
->msg_num
, i2c
->msg_idx
, i2c
->msg_ptr
);
219 printk(KERN_ERR
"i2c: ICR: %08x ISR: %08x\n",
220 readl(_ICR(i2c
)), readl(_ISR(i2c
)));
221 printk(KERN_DEBUG
"i2c: log: ");
222 for (i
= 0; i
< i2c
->irqlogidx
; i
++)
223 printk("[%08x:%08x] ", i2c
->isrlog
[i
], i2c
->icrlog
[i
]);
227 #else /* ifdef DEBUG */
231 #define show_state(i2c) do { } while (0)
232 #define decode_ISR(val) do { } while (0)
233 #define decode_ICR(val) do { } while (0)
234 #define i2c_pxa_scream_blue_murder(i2c, why) do { } while (0)
236 #endif /* ifdef DEBUG / else */
238 static void i2c_pxa_master_complete(struct pxa_i2c
*i2c
, int ret
);
239 static irqreturn_t
i2c_pxa_handler(int this_irq
, void *dev_id
);
241 static inline int i2c_pxa_is_slavemode(struct pxa_i2c
*i2c
)
243 return !(readl(_ICR(i2c
)) & ICR_SCLE
);
246 static void i2c_pxa_abort(struct pxa_i2c
*i2c
)
250 if (i2c_pxa_is_slavemode(i2c
)) {
251 dev_dbg(&i2c
->adap
.dev
, "%s: called in slave mode\n", __func__
);
255 while ((i
> 0) && (readl(_IBMR(i2c
)) & 0x1) == 0) {
256 unsigned long icr
= readl(_ICR(i2c
));
259 icr
|= ICR_ACKNAK
| ICR_STOP
| ICR_TB
;
261 writel(icr
, _ICR(i2c
));
269 writel(readl(_ICR(i2c
)) & ~(ICR_MA
| ICR_START
| ICR_STOP
),
273 static int i2c_pxa_wait_bus_not_busy(struct pxa_i2c
*i2c
)
275 int timeout
= DEF_TIMEOUT
;
277 while (timeout
-- && readl(_ISR(i2c
)) & (ISR_IBB
| ISR_UB
)) {
278 if ((readl(_ISR(i2c
)) & ISR_SAD
) != 0)
288 return timeout
< 0 ? I2C_RETRY
: 0;
291 static int i2c_pxa_wait_master(struct pxa_i2c
*i2c
)
293 unsigned long timeout
= jiffies
+ HZ
*4;
295 while (time_before(jiffies
, timeout
)) {
297 dev_dbg(&i2c
->adap
.dev
, "%s: %ld: ISR=%08x, ICR=%08x, IBMR=%02x\n",
298 __func__
, (long)jiffies
, readl(_ISR(i2c
)), readl(_ICR(i2c
)), readl(_IBMR(i2c
)));
300 if (readl(_ISR(i2c
)) & ISR_SAD
) {
302 dev_dbg(&i2c
->adap
.dev
, "%s: Slave detected\n", __func__
);
306 /* wait for unit and bus being not busy, and we also do a
307 * quick check of the i2c lines themselves to ensure they've
310 if ((readl(_ISR(i2c
)) & (ISR_UB
| ISR_IBB
)) == 0 && readl(_IBMR(i2c
)) == 3) {
312 dev_dbg(&i2c
->adap
.dev
, "%s: done\n", __func__
);
320 dev_dbg(&i2c
->adap
.dev
, "%s: did not free\n", __func__
);
325 static int i2c_pxa_set_master(struct pxa_i2c
*i2c
)
328 dev_dbg(&i2c
->adap
.dev
, "setting to bus master\n");
330 if ((readl(_ISR(i2c
)) & (ISR_UB
| ISR_IBB
)) != 0) {
331 dev_dbg(&i2c
->adap
.dev
, "%s: unit is busy\n", __func__
);
332 if (!i2c_pxa_wait_master(i2c
)) {
333 dev_dbg(&i2c
->adap
.dev
, "%s: error: unit busy\n", __func__
);
338 writel(readl(_ICR(i2c
)) | ICR_SCLE
, _ICR(i2c
));
342 #ifdef CONFIG_I2C_PXA_SLAVE
343 static int i2c_pxa_wait_slave(struct pxa_i2c
*i2c
)
345 unsigned long timeout
= jiffies
+ HZ
*1;
351 while (time_before(jiffies
, timeout
)) {
353 dev_dbg(&i2c
->adap
.dev
, "%s: %ld: ISR=%08x, ICR=%08x, IBMR=%02x\n",
354 __func__
, (long)jiffies
, readl(_ISR(i2c
)), readl(_ICR(i2c
)), readl(_IBMR(i2c
)));
356 if ((readl(_ISR(i2c
)) & (ISR_UB
|ISR_IBB
)) == 0 ||
357 (readl(_ISR(i2c
)) & ISR_SAD
) != 0 ||
358 (readl(_ICR(i2c
)) & ICR_SCLE
) == 0) {
360 dev_dbg(&i2c
->adap
.dev
, "%s: done\n", __func__
);
368 dev_dbg(&i2c
->adap
.dev
, "%s: did not free\n", __func__
);
373 * clear the hold on the bus, and take of anything else
374 * that has been configured
376 static void i2c_pxa_set_slave(struct pxa_i2c
*i2c
, int errcode
)
381 udelay(100); /* simple delay */
383 /* we need to wait for the stop condition to end */
385 /* if we where in stop, then clear... */
386 if (readl(_ICR(i2c
)) & ICR_STOP
) {
388 writel(readl(_ICR(i2c
)) & ~ICR_STOP
, _ICR(i2c
));
391 if (!i2c_pxa_wait_slave(i2c
)) {
392 dev_err(&i2c
->adap
.dev
, "%s: wait timedout\n",
398 writel(readl(_ICR(i2c
)) & ~(ICR_STOP
|ICR_ACKNAK
|ICR_MA
), _ICR(i2c
));
399 writel(readl(_ICR(i2c
)) & ~ICR_SCLE
, _ICR(i2c
));
402 dev_dbg(&i2c
->adap
.dev
, "ICR now %08x, ISR %08x\n", readl(_ICR(i2c
)), readl(_ISR(i2c
)));
403 decode_ICR(readl(_ICR(i2c
)));
407 #define i2c_pxa_set_slave(i2c, err) do { } while (0)
410 static void i2c_pxa_reset(struct pxa_i2c
*i2c
)
412 pr_debug("Resetting I2C Controller Unit\n");
414 /* abort any transfer currently under way */
417 /* reset according to 9.8 */
418 writel(ICR_UR
, _ICR(i2c
));
419 writel(I2C_ISR_INIT
, _ISR(i2c
));
420 writel(readl(_ICR(i2c
)) & ~ICR_UR
, _ICR(i2c
));
422 writel(i2c
->slave_addr
, _ISAR(i2c
));
424 /* set control register values */
425 writel(I2C_ICR_INIT
| (i2c
->fast_mode
? ICR_FM
: 0), _ICR(i2c
));
427 #ifdef CONFIG_I2C_PXA_SLAVE
428 dev_info(&i2c
->adap
.dev
, "Enabling slave mode\n");
429 writel(readl(_ICR(i2c
)) | ICR_SADIE
| ICR_ALDIE
| ICR_SSDIE
, _ICR(i2c
));
432 i2c_pxa_set_slave(i2c
, 0);
435 writel(readl(_ICR(i2c
)) | ICR_IUE
, _ICR(i2c
));
440 #ifdef CONFIG_I2C_PXA_SLAVE
445 static void i2c_pxa_slave_txempty(struct pxa_i2c
*i2c
, u32 isr
)
448 /* what should we do here? */
452 if (i2c
->slave
!= NULL
)
453 ret
= i2c
->slave
->read(i2c
->slave
->data
);
455 writel(ret
, _IDBR(i2c
));
456 writel(readl(_ICR(i2c
)) | ICR_TB
, _ICR(i2c
)); /* allow next byte */
460 static void i2c_pxa_slave_rxfull(struct pxa_i2c
*i2c
, u32 isr
)
462 unsigned int byte
= readl(_IDBR(i2c
));
464 if (i2c
->slave
!= NULL
)
465 i2c
->slave
->write(i2c
->slave
->data
, byte
);
467 writel(readl(_ICR(i2c
)) | ICR_TB
, _ICR(i2c
));
470 static void i2c_pxa_slave_start(struct pxa_i2c
*i2c
, u32 isr
)
475 dev_dbg(&i2c
->adap
.dev
, "SAD, mode is slave-%cx\n",
476 (isr
& ISR_RWM
) ? 'r' : 't');
478 if (i2c
->slave
!= NULL
)
479 i2c
->slave
->event(i2c
->slave
->data
,
480 (isr
& ISR_RWM
) ? I2C_SLAVE_EVENT_START_READ
: I2C_SLAVE_EVENT_START_WRITE
);
483 * slave could interrupt in the middle of us generating a
484 * start condition... if this happens, we'd better back off
485 * and stop holding the poor thing up
487 writel(readl(_ICR(i2c
)) & ~(ICR_START
|ICR_STOP
), _ICR(i2c
));
488 writel(readl(_ICR(i2c
)) | ICR_TB
, _ICR(i2c
));
493 if ((readl(_IBMR(i2c
)) & 2) == 2)
499 dev_err(&i2c
->adap
.dev
, "timeout waiting for SCL high\n");
504 writel(readl(_ICR(i2c
)) & ~ICR_SCLE
, _ICR(i2c
));
507 static void i2c_pxa_slave_stop(struct pxa_i2c
*i2c
)
510 dev_dbg(&i2c
->adap
.dev
, "ISR: SSD (Slave Stop)\n");
512 if (i2c
->slave
!= NULL
)
513 i2c
->slave
->event(i2c
->slave
->data
, I2C_SLAVE_EVENT_STOP
);
516 dev_dbg(&i2c
->adap
.dev
, "ISR: SSD (Slave Stop) acked\n");
519 * If we have a master-mode message waiting,
520 * kick it off now that the slave has completed.
523 i2c_pxa_master_complete(i2c
, I2C_RETRY
);
526 static void i2c_pxa_slave_txempty(struct pxa_i2c
*i2c
, u32 isr
)
529 /* what should we do here? */
531 writel(0, _IDBR(i2c
));
532 writel(readl(_ICR(i2c
)) | ICR_TB
, _ICR(i2c
));
536 static void i2c_pxa_slave_rxfull(struct pxa_i2c
*i2c
, u32 isr
)
538 writel(readl(_ICR(i2c
)) | ICR_TB
| ICR_ACKNAK
, _ICR(i2c
));
541 static void i2c_pxa_slave_start(struct pxa_i2c
*i2c
, u32 isr
)
546 * slave could interrupt in the middle of us generating a
547 * start condition... if this happens, we'd better back off
548 * and stop holding the poor thing up
550 writel(readl(_ICR(i2c
)) & ~(ICR_START
|ICR_STOP
), _ICR(i2c
));
551 writel(readl(_ICR(i2c
)) | ICR_TB
| ICR_ACKNAK
, _ICR(i2c
));
556 if ((readl(_IBMR(i2c
)) & 2) == 2)
562 dev_err(&i2c
->adap
.dev
, "timeout waiting for SCL high\n");
567 writel(readl(_ICR(i2c
)) & ~ICR_SCLE
, _ICR(i2c
));
570 static void i2c_pxa_slave_stop(struct pxa_i2c
*i2c
)
573 i2c_pxa_master_complete(i2c
, I2C_RETRY
);
578 * PXA I2C Master mode
581 static inline unsigned int i2c_pxa_addr_byte(struct i2c_msg
*msg
)
583 unsigned int addr
= (msg
->addr
& 0x7f) << 1;
585 if (msg
->flags
& I2C_M_RD
)
591 static inline void i2c_pxa_start_message(struct pxa_i2c
*i2c
)
596 * Step 1: target slave address into IDBR
598 writel(i2c_pxa_addr_byte(i2c
->msg
), _IDBR(i2c
));
601 * Step 2: initiate the write.
603 icr
= readl(_ICR(i2c
)) & ~(ICR_STOP
| ICR_ALDIE
);
604 writel(icr
| ICR_START
| ICR_TB
, _ICR(i2c
));
607 static inline void i2c_pxa_stop_message(struct pxa_i2c
*i2c
)
612 * Clear the STOP and ACK flags
614 icr
= readl(_ICR(i2c
));
615 icr
&= ~(ICR_STOP
| ICR_ACKNAK
);
616 writel(icr
, _ICR(i2c
));
619 static int i2c_pxa_pio_set_master(struct pxa_i2c
*i2c
)
621 /* make timeout the same as for interrupt based functions */
622 long timeout
= 2 * DEF_TIMEOUT
;
625 * Wait for the bus to become free.
627 while (timeout
-- && readl(_ISR(i2c
)) & (ISR_IBB
| ISR_UB
)) {
634 dev_err(&i2c
->adap
.dev
,
635 "i2c_pxa: timeout waiting for bus free\n");
642 writel(readl(_ICR(i2c
)) | ICR_SCLE
, _ICR(i2c
));
647 static int i2c_pxa_do_pio_xfer(struct pxa_i2c
*i2c
,
648 struct i2c_msg
*msg
, int num
)
650 unsigned long timeout
= 500000; /* 5 seconds */
653 ret
= i2c_pxa_pio_set_master(i2c
);
663 i2c_pxa_start_message(i2c
);
665 while (i2c
->msg_num
> 0 && --timeout
) {
666 i2c_pxa_handler(0, i2c
);
670 i2c_pxa_stop_message(i2c
);
673 * We place the return code in i2c->msg_idx.
679 i2c_pxa_scream_blue_murder(i2c
, "timeout");
685 * We are protected by the adapter bus mutex.
687 static int i2c_pxa_do_xfer(struct pxa_i2c
*i2c
, struct i2c_msg
*msg
, int num
)
693 * Wait for the bus to become free.
695 ret
= i2c_pxa_wait_bus_not_busy(i2c
);
697 dev_err(&i2c
->adap
.dev
, "i2c_pxa: timeout waiting for bus free\n");
704 ret
= i2c_pxa_set_master(i2c
);
706 dev_err(&i2c
->adap
.dev
, "i2c_pxa_set_master: error %d\n", ret
);
710 spin_lock_irq(&i2c
->lock
);
718 i2c_pxa_start_message(i2c
);
720 spin_unlock_irq(&i2c
->lock
);
723 * The rest of the processing occurs in the interrupt handler.
725 timeout
= wait_event_timeout(i2c
->wait
, i2c
->msg_num
== 0, HZ
* 5);
726 i2c_pxa_stop_message(i2c
);
729 * We place the return code in i2c->msg_idx.
734 i2c_pxa_scream_blue_murder(i2c
, "timeout");
740 static int i2c_pxa_pio_xfer(struct i2c_adapter
*adap
,
741 struct i2c_msg msgs
[], int num
)
743 struct pxa_i2c
*i2c
= adap
->algo_data
;
746 /* If the I2C controller is disabled we need to reset it
747 (probably due to a suspend/resume destroying state). We do
748 this here as we can then avoid worrying about resuming the
749 controller before its users. */
750 if (!(readl(_ICR(i2c
)) & ICR_IUE
))
753 for (i
= adap
->retries
; i
>= 0; i
--) {
754 ret
= i2c_pxa_do_pio_xfer(i2c
, msgs
, num
);
755 if (ret
!= I2C_RETRY
)
759 dev_dbg(&adap
->dev
, "Retrying transmission\n");
762 i2c_pxa_scream_blue_murder(i2c
, "exhausted retries");
765 i2c_pxa_set_slave(i2c
, ret
);
770 * i2c_pxa_master_complete - complete the message and wake up.
772 static void i2c_pxa_master_complete(struct pxa_i2c
*i2c
, int ret
)
784 static void i2c_pxa_irq_txempty(struct pxa_i2c
*i2c
, u32 isr
)
786 u32 icr
= readl(_ICR(i2c
)) & ~(ICR_START
|ICR_STOP
|ICR_ACKNAK
|ICR_TB
);
790 * If ISR_ALD is set, we lost arbitration.
794 * Do we need to do anything here? The PXA docs
795 * are vague about what happens.
797 i2c_pxa_scream_blue_murder(i2c
, "ALD set");
800 * We ignore this error. We seem to see spurious ALDs
801 * for seemingly no reason. If we handle them as I think
802 * they should, we end up causing an I2C error, which
803 * is painful for some systems.
812 * I2C bus error - either the device NAK'd us, or
813 * something more serious happened. If we were NAK'd
814 * on the initial address phase, we can retry.
816 if (isr
& ISR_ACKNAK
) {
817 if (i2c
->msg_ptr
== 0 && i2c
->msg_idx
== 0)
822 i2c_pxa_master_complete(i2c
, ret
);
823 } else if (isr
& ISR_RWM
) {
825 * Read mode. We have just sent the address byte, and
826 * now we must initiate the transfer.
828 if (i2c
->msg_ptr
== i2c
->msg
->len
- 1 &&
829 i2c
->msg_idx
== i2c
->msg_num
- 1)
830 icr
|= ICR_STOP
| ICR_ACKNAK
;
832 icr
|= ICR_ALDIE
| ICR_TB
;
833 } else if (i2c
->msg_ptr
< i2c
->msg
->len
) {
835 * Write mode. Write the next data byte.
837 writel(i2c
->msg
->buf
[i2c
->msg_ptr
++], _IDBR(i2c
));
839 icr
|= ICR_ALDIE
| ICR_TB
;
842 * If this is the last byte of the last message, send
845 if (i2c
->msg_ptr
== i2c
->msg
->len
&&
846 i2c
->msg_idx
== i2c
->msg_num
- 1)
848 } else if (i2c
->msg_idx
< i2c
->msg_num
- 1) {
850 * Next segment of the message.
857 * If we aren't doing a repeated start and address,
858 * go back and try to send the next byte. Note that
859 * we do not support switching the R/W direction here.
861 if (i2c
->msg
->flags
& I2C_M_NOSTART
)
865 * Write the next address.
867 writel(i2c_pxa_addr_byte(i2c
->msg
), _IDBR(i2c
));
870 * And trigger a repeated start, and send the byte.
873 icr
|= ICR_START
| ICR_TB
;
875 if (i2c
->msg
->len
== 0) {
877 * Device probes have a message length of zero
878 * and need the bus to be reset before it can
883 i2c_pxa_master_complete(i2c
, 0);
886 i2c
->icrlog
[i2c
->irqlogidx
-1] = icr
;
888 writel(icr
, _ICR(i2c
));
892 static void i2c_pxa_irq_rxfull(struct pxa_i2c
*i2c
, u32 isr
)
894 u32 icr
= readl(_ICR(i2c
)) & ~(ICR_START
|ICR_STOP
|ICR_ACKNAK
|ICR_TB
);
899 i2c
->msg
->buf
[i2c
->msg_ptr
++] = readl(_IDBR(i2c
));
901 if (i2c
->msg_ptr
< i2c
->msg
->len
) {
903 * If this is the last byte of the last
904 * message, send a STOP.
906 if (i2c
->msg_ptr
== i2c
->msg
->len
- 1)
907 icr
|= ICR_STOP
| ICR_ACKNAK
;
909 icr
|= ICR_ALDIE
| ICR_TB
;
911 i2c_pxa_master_complete(i2c
, 0);
914 i2c
->icrlog
[i2c
->irqlogidx
-1] = icr
;
916 writel(icr
, _ICR(i2c
));
919 static irqreturn_t
i2c_pxa_handler(int this_irq
, void *dev_id
)
921 struct pxa_i2c
*i2c
= dev_id
;
922 u32 isr
= readl(_ISR(i2c
));
924 if (i2c_debug
> 2 && 0) {
925 dev_dbg(&i2c
->adap
.dev
, "%s: ISR=%08x, ICR=%08x, IBMR=%02x\n",
926 __func__
, isr
, readl(_ICR(i2c
)), readl(_IBMR(i2c
)));
930 if (i2c
->irqlogidx
< ARRAY_SIZE(i2c
->isrlog
))
931 i2c
->isrlog
[i2c
->irqlogidx
++] = isr
;
936 * Always clear all pending IRQs.
938 writel(isr
& (ISR_SSD
|ISR_ALD
|ISR_ITE
|ISR_IRF
|ISR_SAD
|ISR_BED
), _ISR(i2c
));
941 i2c_pxa_slave_start(i2c
, isr
);
943 i2c_pxa_slave_stop(i2c
);
945 if (i2c_pxa_is_slavemode(i2c
)) {
947 i2c_pxa_slave_txempty(i2c
, isr
);
949 i2c_pxa_slave_rxfull(i2c
, isr
);
950 } else if (i2c
->msg
) {
952 i2c_pxa_irq_txempty(i2c
, isr
);
954 i2c_pxa_irq_rxfull(i2c
, isr
);
956 i2c_pxa_scream_blue_murder(i2c
, "spurious irq");
963 static int i2c_pxa_xfer(struct i2c_adapter
*adap
, struct i2c_msg msgs
[], int num
)
965 struct pxa_i2c
*i2c
= adap
->algo_data
;
968 for (i
= adap
->retries
; i
>= 0; i
--) {
969 ret
= i2c_pxa_do_xfer(i2c
, msgs
, num
);
970 if (ret
!= I2C_RETRY
)
974 dev_dbg(&adap
->dev
, "Retrying transmission\n");
977 i2c_pxa_scream_blue_murder(i2c
, "exhausted retries");
980 i2c_pxa_set_slave(i2c
, ret
);
984 static u32
i2c_pxa_functionality(struct i2c_adapter
*adap
)
986 return I2C_FUNC_I2C
| I2C_FUNC_SMBUS_EMUL
;
989 static const struct i2c_algorithm i2c_pxa_algorithm
= {
990 .master_xfer
= i2c_pxa_xfer
,
991 .functionality
= i2c_pxa_functionality
,
994 static const struct i2c_algorithm i2c_pxa_pio_algorithm
= {
995 .master_xfer
= i2c_pxa_pio_xfer
,
996 .functionality
= i2c_pxa_functionality
,
999 static int i2c_pxa_probe(struct platform_device
*dev
)
1001 struct pxa_i2c
*i2c
;
1002 struct resource
*res
;
1003 struct i2c_pxa_platform_data
*plat
= dev
->dev
.platform_data
;
1004 struct platform_device_id
*id
= platform_get_device_id(dev
);
1008 res
= platform_get_resource(dev
, IORESOURCE_MEM
, 0);
1009 irq
= platform_get_irq(dev
, 0);
1010 if (res
== NULL
|| irq
< 0)
1013 if (!request_mem_region(res
->start
, resource_size(res
), res
->name
))
1016 i2c
= kzalloc(sizeof(struct pxa_i2c
), GFP_KERNEL
);
1022 i2c
->adap
.owner
= THIS_MODULE
;
1023 i2c
->adap
.retries
= 5;
1025 spin_lock_init(&i2c
->lock
);
1026 init_waitqueue_head(&i2c
->wait
);
1029 * If "dev->id" is negative we consider it as zero.
1030 * The reason to do so is to avoid sysfs names that only make
1031 * sense when there are multiple adapters.
1033 i2c
->adap
.nr
= dev
->id
!= -1 ? dev
->id
: 0;
1034 snprintf(i2c
->adap
.name
, sizeof(i2c
->adap
.name
), "pxa_i2c-i2c.%u",
1037 i2c
->clk
= clk_get(&dev
->dev
, NULL
);
1038 if (IS_ERR(i2c
->clk
)) {
1039 ret
= PTR_ERR(i2c
->clk
);
1043 i2c
->reg_base
= ioremap(res
->start
, resource_size(res
));
1044 if (!i2c
->reg_base
) {
1048 i2c
->reg_shift
= REG_SHIFT(id
->driver_data
);
1050 i2c
->iobase
= res
->start
;
1051 i2c
->iosize
= resource_size(res
);
1055 i2c
->slave_addr
= I2C_PXA_SLAVE_ADDR
;
1057 #ifdef CONFIG_I2C_PXA_SLAVE
1059 i2c
->slave_addr
= plat
->slave_addr
;
1060 i2c
->slave
= plat
->slave
;
1064 clk_enable(i2c
->clk
);
1067 i2c
->adap
.class = plat
->class;
1068 i2c
->use_pio
= plat
->use_pio
;
1069 i2c
->fast_mode
= plat
->fast_mode
;
1073 i2c
->adap
.algo
= &i2c_pxa_pio_algorithm
;
1075 i2c
->adap
.algo
= &i2c_pxa_algorithm
;
1076 ret
= request_irq(irq
, i2c_pxa_handler
, IRQF_DISABLED
,
1077 i2c
->adap
.name
, i2c
);
1084 i2c
->adap
.algo_data
= i2c
;
1085 i2c
->adap
.dev
.parent
= &dev
->dev
;
1087 ret
= i2c_add_numbered_adapter(&i2c
->adap
);
1089 printk(KERN_INFO
"I2C: Failed to add bus\n");
1093 platform_set_drvdata(dev
, i2c
);
1095 #ifdef CONFIG_I2C_PXA_SLAVE
1096 printk(KERN_INFO
"I2C: %s: PXA I2C adapter, slave address %d\n",
1097 dev_name(&i2c
->adap
.dev
), i2c
->slave_addr
);
1099 printk(KERN_INFO
"I2C: %s: PXA I2C adapter\n",
1100 dev_name(&i2c
->adap
.dev
));
1108 clk_disable(i2c
->clk
);
1109 iounmap(i2c
->reg_base
);
1115 release_mem_region(res
->start
, resource_size(res
));
1119 static int __exit
i2c_pxa_remove(struct platform_device
*dev
)
1121 struct pxa_i2c
*i2c
= platform_get_drvdata(dev
);
1123 platform_set_drvdata(dev
, NULL
);
1125 i2c_del_adapter(&i2c
->adap
);
1127 free_irq(i2c
->irq
, i2c
);
1129 clk_disable(i2c
->clk
);
1132 iounmap(i2c
->reg_base
);
1133 release_mem_region(i2c
->iobase
, i2c
->iosize
);
1140 static int i2c_pxa_suspend_noirq(struct device
*dev
)
1142 struct platform_device
*pdev
= to_platform_device(dev
);
1143 struct pxa_i2c
*i2c
= platform_get_drvdata(pdev
);
1145 clk_disable(i2c
->clk
);
1150 static int i2c_pxa_resume_noirq(struct device
*dev
)
1152 struct platform_device
*pdev
= to_platform_device(dev
);
1153 struct pxa_i2c
*i2c
= platform_get_drvdata(pdev
);
1155 clk_enable(i2c
->clk
);
1161 static const struct dev_pm_ops i2c_pxa_dev_pm_ops
= {
1162 .suspend_noirq
= i2c_pxa_suspend_noirq
,
1163 .resume_noirq
= i2c_pxa_resume_noirq
,
1166 #define I2C_PXA_DEV_PM_OPS (&i2c_pxa_dev_pm_ops)
1168 #define I2C_PXA_DEV_PM_OPS NULL
1171 static struct platform_driver i2c_pxa_driver
= {
1172 .probe
= i2c_pxa_probe
,
1173 .remove
= __exit_p(i2c_pxa_remove
),
1175 .name
= "pxa2xx-i2c",
1176 .owner
= THIS_MODULE
,
1177 .pm
= I2C_PXA_DEV_PM_OPS
,
1179 .id_table
= i2c_pxa_id_table
,
1182 static int __init
i2c_adap_pxa_init(void)
1184 return platform_driver_register(&i2c_pxa_driver
);
1187 static void __exit
i2c_adap_pxa_exit(void)
1189 platform_driver_unregister(&i2c_pxa_driver
);
1192 MODULE_LICENSE("GPL");
1193 MODULE_ALIAS("platform:pxa2xx-i2c");
1195 subsys_initcall(i2c_adap_pxa_init
);
1196 module_exit(i2c_adap_pxa_exit
);