1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
2b652b438SRussell King /*
3b652b438SRussell King * i2c_adap_pxa.c
4b652b438SRussell King *
5b652b438SRussell King * I2C adapter for the PXA I2C bus access.
6b652b438SRussell King *
7b652b438SRussell King * Copyright (C) 2002 Intrinsyc Software Inc.
8b652b438SRussell King * Copyright (C) 2004-2005 Deep Blue Solutions Ltd.
9b652b438SRussell King *
10b652b438SRussell King * History:
11b652b438SRussell King * Apr 2002: Initial version [CS]
123ad2f3fbSDaniel Mack * Jun 2002: Properly separated algo/adap [FB]
13b652b438SRussell King * Jan 2003: Fixed several bugs concerning interrupt handling [Kai-Uwe Bloem]
14b652b438SRussell King * Jan 2003: added limited signal handling [Kai-Uwe Bloem]
15b652b438SRussell King * Sep 2004: Major rework to ensure efficient bus handling [RMK]
16b652b438SRussell King * Dec 2004: Added support for PXA27x and slave device probing [Liam Girdwood]
17b652b438SRussell King * Feb 2005: Rework slave mode handling [RMK]
18b652b438SRussell King */
198de32da2SRussell King #include <linux/clk.h>
208de32da2SRussell King #include <linux/delay.h>
218de32da2SRussell King #include <linux/err.h>
228de32da2SRussell King #include <linux/errno.h>
237c9ec2c5SRussell King #include <linux/gpio/consumer.h>
24b652b438SRussell King #include <linux/i2c.h>
25b652b438SRussell King #include <linux/init.h>
26b652b438SRussell King #include <linux/interrupt.h>
278de32da2SRussell King #include <linux/io.h>
288de32da2SRussell King #include <linux/kernel.h>
298de32da2SRussell King #include <linux/module.h>
3063fe122bSHaojian Zhuang #include <linux/of.h>
3163fe122bSHaojian Zhuang #include <linux/of_device.h>
327c9ec2c5SRussell King #include <linux/pinctrl/consumer.h>
33d052d1beSRussell King #include <linux/platform_device.h>
34f15fc9b1SWolfram Sang #include <linux/platform_data/i2c-pxa.h>
358de32da2SRussell King #include <linux/slab.h>
36b652b438SRussell King
37940695aaSRussell King /* I2C register field definitions */
38f8e5d3cbSRussell King #define IBMR_SDAS (1 << 0)
39f8e5d3cbSRussell King #define IBMR_SCLS (1 << 1)
40f8e5d3cbSRussell King
41940695aaSRussell King #define ICR_START (1 << 0) /* start bit */
42940695aaSRussell King #define ICR_STOP (1 << 1) /* stop bit */
43940695aaSRussell King #define ICR_ACKNAK (1 << 2) /* send ACK(0) or NAK(1) */
44940695aaSRussell King #define ICR_TB (1 << 3) /* transfer byte bit */
45940695aaSRussell King #define ICR_MA (1 << 4) /* master abort */
46940695aaSRussell King #define ICR_SCLE (1 << 5) /* master clock enable */
47940695aaSRussell King #define ICR_IUE (1 << 6) /* unit enable */
48940695aaSRussell King #define ICR_GCD (1 << 7) /* general call disable */
49940695aaSRussell King #define ICR_ITEIE (1 << 8) /* enable tx interrupts */
50940695aaSRussell King #define ICR_IRFIE (1 << 9) /* enable rx interrupts */
51940695aaSRussell King #define ICR_BEIE (1 << 10) /* enable bus error ints */
52940695aaSRussell King #define ICR_SSDIE (1 << 11) /* slave STOP detected int enable */
53940695aaSRussell King #define ICR_ALDIE (1 << 12) /* enable arbitration interrupt */
54940695aaSRussell King #define ICR_SADIE (1 << 13) /* slave address detected int enable */
55940695aaSRussell King #define ICR_UR (1 << 14) /* unit reset */
56940695aaSRussell King #define ICR_FM (1 << 15) /* fast mode */
57940695aaSRussell King #define ICR_HS (1 << 16) /* High Speed mode */
58940695aaSRussell King #define ICR_A3700_FM (1 << 16) /* fast mode for armada-3700 */
59940695aaSRussell King #define ICR_A3700_HS (1 << 17) /* high speed mode for armada-3700 */
60940695aaSRussell King #define ICR_GPIOEN (1 << 19) /* enable GPIO mode for SCL in HS */
61940695aaSRussell King
62940695aaSRussell King #define ISR_RWM (1 << 0) /* read/write mode */
63940695aaSRussell King #define ISR_ACKNAK (1 << 1) /* ack/nak status */
64940695aaSRussell King #define ISR_UB (1 << 2) /* unit busy */
65940695aaSRussell King #define ISR_IBB (1 << 3) /* bus busy */
66940695aaSRussell King #define ISR_SSD (1 << 4) /* slave stop detected */
67940695aaSRussell King #define ISR_ALD (1 << 5) /* arbitration loss detected */
68940695aaSRussell King #define ISR_ITE (1 << 6) /* tx buffer empty */
69940695aaSRussell King #define ISR_IRF (1 << 7) /* rx buffer full */
70940695aaSRussell King #define ISR_GCAD (1 << 8) /* general call address detected */
71940695aaSRussell King #define ISR_SAD (1 << 9) /* slave address detected */
72940695aaSRussell King #define ISR_BED (1 << 10) /* bus error no ACK/NAK */
73940695aaSRussell King
74940695aaSRussell King #define ILCR_SLV_SHIFT 0
75940695aaSRussell King #define ILCR_SLV_MASK (0x1FF << ILCR_SLV_SHIFT)
76940695aaSRussell King #define ILCR_FLV_SHIFT 9
77940695aaSRussell King #define ILCR_FLV_MASK (0x1FF << ILCR_FLV_SHIFT)
78940695aaSRussell King #define ILCR_HLVL_SHIFT 18
79940695aaSRussell King #define ILCR_HLVL_MASK (0x1FF << ILCR_HLVL_SHIFT)
80940695aaSRussell King #define ILCR_HLVH_SHIFT 27
81940695aaSRussell King #define ILCR_HLVH_MASK (0x1F << ILCR_HLVH_SHIFT)
82940695aaSRussell King
83940695aaSRussell King #define IWCR_CNT_SHIFT 0
84940695aaSRussell King #define IWCR_CNT_MASK (0x1F << IWCR_CNT_SHIFT)
85940695aaSRussell King #define IWCR_HS_CNT1_SHIFT 5
86940695aaSRussell King #define IWCR_HS_CNT1_MASK (0x1F << IWCR_HS_CNT1_SHIFT)
87940695aaSRussell King #define IWCR_HS_CNT2_SHIFT 10
88940695aaSRussell King #define IWCR_HS_CNT2_MASK (0x1F << IWCR_HS_CNT2_SHIFT)
89940695aaSRussell King
9079622f37SRussell King /* need a longer timeout if we're dealing with the fact we may well be
9179622f37SRussell King * looking at a multi-master environment
9279622f37SRussell King */
9379622f37SRussell King #define DEF_TIMEOUT 32
9479622f37SRussell King
95c25e509aSRussell King #define NO_SLAVE (-ENXIO)
9679622f37SRussell King #define BUS_ERROR (-EREMOTEIO)
9779622f37SRussell King #define XFER_NAKED (-ECONNREFUSED)
9879622f37SRussell King #define I2C_RETRY (-2000) /* an error has occurred retry transmit */
9979622f37SRussell King
10079622f37SRussell King /* ICR initialize bit values
10179622f37SRussell King *
10279622f37SRussell King * 15 FM 0 (100 kHz operation)
10379622f37SRussell King * 14 UR 0 (No unit reset)
10479622f37SRussell King * 13 SADIE 0 (Disables the unit from interrupting on slave addresses
10579622f37SRussell King * matching its slave address)
10679622f37SRussell King * 12 ALDIE 0 (Disables the unit from interrupt when it loses arbitration
10779622f37SRussell King * in master mode)
10879622f37SRussell King * 11 SSDIE 0 (Disables interrupts from a slave stop detected, in slave mode)
10979622f37SRussell King * 10 BEIE 1 (Enable interrupts from detected bus errors, no ACK sent)
11079622f37SRussell King * 9 IRFIE 1 (Enable interrupts from full buffer received)
11179622f37SRussell King * 8 ITEIE 1 (Enables the I2C unit to interrupt when transmit buffer empty)
11279622f37SRussell King * 7 GCD 1 (Disables i2c unit response to general call messages as a slave)
11379622f37SRussell King * 6 IUE 0 (Disable unit until we change settings)
11479622f37SRussell King * 5 SCLE 1 (Enables the i2c clock output for master mode (drives SCL)
11579622f37SRussell King * 4 MA 0 (Only send stop with the ICR stop bit)
11679622f37SRussell King * 3 TB 0 (We are not transmitting a byte initially)
11779622f37SRussell King * 2 ACKNAK 0 (Send an ACK after the unit receives a byte)
11879622f37SRussell King * 1 STOP 0 (Do not send a STOP)
11979622f37SRussell King * 0 START 0 (Do not send a START)
12079622f37SRussell King */
12179622f37SRussell King #define I2C_ICR_INIT (ICR_BEIE | ICR_IRFIE | ICR_ITEIE | ICR_GCD | ICR_SCLE)
12279622f37SRussell King
12379622f37SRussell King /* I2C status register init values
12479622f37SRussell King *
12579622f37SRussell King * 10 BED 1 (Clear bus error detected)
12679622f37SRussell King * 9 SAD 1 (Clear slave address detected)
12779622f37SRussell King * 7 IRF 1 (Clear IDBR Receive Full)
12879622f37SRussell King * 6 ITE 1 (Clear IDBR Transmit Empty)
12979622f37SRussell King * 5 ALD 1 (Clear Arbitration Loss Detected)
13079622f37SRussell King * 4 SSD 1 (Clear Slave Stop Detected)
13179622f37SRussell King */
13279622f37SRussell King #define I2C_ISR_INIT 0x7FF /* status register init */
13379622f37SRussell King
134d6668c7cSSebastian Andrzej Siewior struct pxa_reg_layout {
135d6668c7cSSebastian Andrzej Siewior u32 ibmr;
136d6668c7cSSebastian Andrzej Siewior u32 idbr;
137d6668c7cSSebastian Andrzej Siewior u32 icr;
138d6668c7cSSebastian Andrzej Siewior u32 isr;
139d6668c7cSSebastian Andrzej Siewior u32 isar;
140c5fa6fc7SVaibhav Hiremath u32 ilcr;
141c5fa6fc7SVaibhav Hiremath u32 iwcr;
1426c14bdacSRomain Perier u32 fm;
1436c14bdacSRomain Perier u32 hs;
144d6668c7cSSebastian Andrzej Siewior };
145d6668c7cSSebastian Andrzej Siewior
146d6668c7cSSebastian Andrzej Siewior enum pxa_i2c_types {
147d6668c7cSSebastian Andrzej Siewior REGS_PXA2XX,
148d6668c7cSSebastian Andrzej Siewior REGS_PXA3XX,
1497e94dd15SSebastian Andrzej Siewior REGS_CE4100,
150c5fa6fc7SVaibhav Hiremath REGS_PXA910,
151294be03cSRomain Perier REGS_A3700,
152d6668c7cSSebastian Andrzej Siewior };
153d6668c7cSSebastian Andrzej Siewior
154940695aaSRussell King /* I2C register layout definitions */
155d6668c7cSSebastian Andrzej Siewior static struct pxa_reg_layout pxa_reg_layout[] = {
156d6668c7cSSebastian Andrzej Siewior [REGS_PXA2XX] = {
157d6668c7cSSebastian Andrzej Siewior .ibmr = 0x00,
158d6668c7cSSebastian Andrzej Siewior .idbr = 0x08,
159d6668c7cSSebastian Andrzej Siewior .icr = 0x10,
160d6668c7cSSebastian Andrzej Siewior .isr = 0x18,
161d6668c7cSSebastian Andrzej Siewior .isar = 0x20,
162ee478936SRussell King .fm = ICR_FM,
163ee478936SRussell King .hs = ICR_HS,
164d6668c7cSSebastian Andrzej Siewior },
16523e74a86SVasily Khoruzhick [REGS_PXA3XX] = {
16623e74a86SVasily Khoruzhick .ibmr = 0x00,
16723e74a86SVasily Khoruzhick .idbr = 0x04,
16823e74a86SVasily Khoruzhick .icr = 0x08,
16923e74a86SVasily Khoruzhick .isr = 0x0c,
17023e74a86SVasily Khoruzhick .isar = 0x10,
171ee478936SRussell King .fm = ICR_FM,
172ee478936SRussell King .hs = ICR_HS,
17323e74a86SVasily Khoruzhick },
1747e94dd15SSebastian Andrzej Siewior [REGS_CE4100] = {
1757e94dd15SSebastian Andrzej Siewior .ibmr = 0x14,
1767e94dd15SSebastian Andrzej Siewior .idbr = 0x0c,
1777e94dd15SSebastian Andrzej Siewior .icr = 0x00,
1787e94dd15SSebastian Andrzej Siewior .isr = 0x04,
1797e94dd15SSebastian Andrzej Siewior /* no isar register */
180ee478936SRussell King .fm = ICR_FM,
181ee478936SRussell King .hs = ICR_HS,
1827e94dd15SSebastian Andrzej Siewior },
183c5fa6fc7SVaibhav Hiremath [REGS_PXA910] = {
184c5fa6fc7SVaibhav Hiremath .ibmr = 0x00,
185c5fa6fc7SVaibhav Hiremath .idbr = 0x08,
186c5fa6fc7SVaibhav Hiremath .icr = 0x10,
187c5fa6fc7SVaibhav Hiremath .isr = 0x18,
188c5fa6fc7SVaibhav Hiremath .isar = 0x20,
189c5fa6fc7SVaibhav Hiremath .ilcr = 0x28,
190c5fa6fc7SVaibhav Hiremath .iwcr = 0x30,
191ee478936SRussell King .fm = ICR_FM,
192ee478936SRussell King .hs = ICR_HS,
193c5fa6fc7SVaibhav Hiremath },
194294be03cSRomain Perier [REGS_A3700] = {
195294be03cSRomain Perier .ibmr = 0x00,
196294be03cSRomain Perier .idbr = 0x04,
197294be03cSRomain Perier .icr = 0x08,
198294be03cSRomain Perier .isr = 0x0c,
199294be03cSRomain Perier .isar = 0x10,
200940695aaSRussell King .fm = ICR_A3700_FM,
201940695aaSRussell King .hs = ICR_A3700_HS,
202294be03cSRomain Perier },
203d6668c7cSSebastian Andrzej Siewior };
204f23d4911SEric Miao
20570aee287SRussell King static const struct of_device_id i2c_pxa_dt_ids[] = {
20670aee287SRussell King { .compatible = "mrvl,pxa-i2c", .data = (void *)REGS_PXA2XX },
20770aee287SRussell King { .compatible = "mrvl,pwri2c", .data = (void *)REGS_PXA3XX },
20870aee287SRussell King { .compatible = "mrvl,mmp-twsi", .data = (void *)REGS_PXA910 },
20970aee287SRussell King { .compatible = "marvell,armada-3700-i2c", .data = (void *)REGS_A3700 },
21070aee287SRussell King {}
21170aee287SRussell King };
21270aee287SRussell King MODULE_DEVICE_TABLE(of, i2c_pxa_dt_ids);
21370aee287SRussell King
214f23d4911SEric Miao static const struct platform_device_id i2c_pxa_id_table[] = {
215d6668c7cSSebastian Andrzej Siewior { "pxa2xx-i2c", REGS_PXA2XX },
216d6668c7cSSebastian Andrzej Siewior { "pxa3xx-pwri2c", REGS_PXA3XX },
2177e94dd15SSebastian Andrzej Siewior { "ce4100-i2c", REGS_CE4100 },
218c5fa6fc7SVaibhav Hiremath { "pxa910-i2c", REGS_PXA910 },
219294be03cSRomain Perier { "armada-3700-i2c", REGS_A3700 },
220f23d4911SEric Miao { },
221f23d4911SEric Miao };
222f23d4911SEric Miao MODULE_DEVICE_TABLE(platform, i2c_pxa_id_table);
223f23d4911SEric Miao
224b652b438SRussell King struct pxa_i2c {
225b652b438SRussell King spinlock_t lock;
226b652b438SRussell King wait_queue_head_t wait;
227b652b438SRussell King struct i2c_msg *msg;
228b652b438SRussell King unsigned int msg_num;
229b652b438SRussell King unsigned int msg_idx;
230b652b438SRussell King unsigned int msg_ptr;
231b652b438SRussell King unsigned int slave_addr;
2323a2dc167SVaibhav Hiremath unsigned int req_slave_addr;
233b652b438SRussell King
234b652b438SRussell King struct i2c_adapter adap;
235c3cef3f3SRussell King struct clk *clk;
236b652b438SRussell King #ifdef CONFIG_I2C_PXA_SLAVE
2374d51b4ceSPatrick Williams struct i2c_client *slave;
238b652b438SRussell King #endif
239b652b438SRussell King
240b652b438SRussell King unsigned int irqlogidx;
241b652b438SRussell King u32 isrlog[32];
242b652b438SRussell King u32 icrlog[32];
243a7b4e550SGuennadi Liakhovetski
244a7b4e550SGuennadi Liakhovetski void __iomem *reg_base;
245d6668c7cSSebastian Andrzej Siewior void __iomem *reg_ibmr;
246d6668c7cSSebastian Andrzej Siewior void __iomem *reg_idbr;
247d6668c7cSSebastian Andrzej Siewior void __iomem *reg_icr;
248d6668c7cSSebastian Andrzej Siewior void __iomem *reg_isr;
249d6668c7cSSebastian Andrzej Siewior void __iomem *reg_isar;
250c5fa6fc7SVaibhav Hiremath void __iomem *reg_ilcr;
251c5fa6fc7SVaibhav Hiremath void __iomem *reg_iwcr;
252a7b4e550SGuennadi Liakhovetski
253a7b4e550SGuennadi Liakhovetski unsigned long iobase;
254a7b4e550SGuennadi Liakhovetski unsigned long iosize;
255a7b4e550SGuennadi Liakhovetski
256a7b4e550SGuennadi Liakhovetski int irq;
257c46c9482SJonathan Cameron unsigned int use_pio :1;
258c46c9482SJonathan Cameron unsigned int fast_mode :1;
2599d3dda5cSLeilei Shang unsigned int high_mode:1;
2609d3dda5cSLeilei Shang unsigned char master_code;
2619d3dda5cSLeilei Shang unsigned long rate;
2629d3dda5cSLeilei Shang bool highmode_enter;
2636c14bdacSRomain Perier u32 fm_mask;
2646c14bdacSRomain Perier u32 hs_mask;
2657c9ec2c5SRussell King
2667c9ec2c5SRussell King struct i2c_bus_recovery_info recovery;
267*ff4d0309SRobert Marko struct pinctrl *pinctrl;
268*ff4d0309SRobert Marko struct pinctrl_state *pinctrl_default;
269*ff4d0309SRobert Marko struct pinctrl_state *pinctrl_recovery;
270b652b438SRussell King };
271b652b438SRussell King
272d6668c7cSSebastian Andrzej Siewior #define _IBMR(i2c) ((i2c)->reg_ibmr)
273d6668c7cSSebastian Andrzej Siewior #define _IDBR(i2c) ((i2c)->reg_idbr)
274d6668c7cSSebastian Andrzej Siewior #define _ICR(i2c) ((i2c)->reg_icr)
275d6668c7cSSebastian Andrzej Siewior #define _ISR(i2c) ((i2c)->reg_isr)
276d6668c7cSSebastian Andrzej Siewior #define _ISAR(i2c) ((i2c)->reg_isar)
277c5fa6fc7SVaibhav Hiremath #define _ILCR(i2c) ((i2c)->reg_ilcr)
278c5fa6fc7SVaibhav Hiremath #define _IWCR(i2c) ((i2c)->reg_iwcr)
279a7b4e550SGuennadi Liakhovetski
280b652b438SRussell King /*
281b652b438SRussell King * I2C Slave mode address
282b652b438SRussell King */
283b652b438SRussell King #define I2C_PXA_SLAVE_ADDR 0x1
284b652b438SRussell King
285b652b438SRussell King #ifdef DEBUG
286b652b438SRussell King
287b652b438SRussell King struct bits {
288b652b438SRussell King u32 mask;
289b652b438SRussell King const char *set;
290b652b438SRussell King const char *unset;
291b652b438SRussell King };
292ed11399dSJiri Slaby #define PXA_BIT(m, s, u) { .mask = m, .set = s, .unset = u }
293b652b438SRussell King
294b652b438SRussell King static inline void
decode_bits(const char * prefix,const struct bits * bits,int num,u32 val)295b652b438SRussell King decode_bits(const char *prefix, const struct bits *bits, int num, u32 val)
296b652b438SRussell King {
297b652b438SRussell King printk("%s %08x:", prefix, val);
298b652b438SRussell King while (num--) {
299b652b438SRussell King const char *str = val & bits->mask ? bits->set : bits->unset;
300b652b438SRussell King if (str)
301bb82ba69SRussell King pr_cont(" %s", str);
302b652b438SRussell King bits++;
303b652b438SRussell King }
304bb82ba69SRussell King pr_cont("\n");
305b652b438SRussell King }
306b652b438SRussell King
307b652b438SRussell King static const struct bits isr_bits[] = {
308ed11399dSJiri Slaby PXA_BIT(ISR_RWM, "RX", "TX"),
309ed11399dSJiri Slaby PXA_BIT(ISR_ACKNAK, "NAK", "ACK"),
310ed11399dSJiri Slaby PXA_BIT(ISR_UB, "Bsy", "Rdy"),
311ed11399dSJiri Slaby PXA_BIT(ISR_IBB, "BusBsy", "BusRdy"),
312ed11399dSJiri Slaby PXA_BIT(ISR_SSD, "SlaveStop", NULL),
313ed11399dSJiri Slaby PXA_BIT(ISR_ALD, "ALD", NULL),
314ed11399dSJiri Slaby PXA_BIT(ISR_ITE, "TxEmpty", NULL),
315ed11399dSJiri Slaby PXA_BIT(ISR_IRF, "RxFull", NULL),
316ed11399dSJiri Slaby PXA_BIT(ISR_GCAD, "GenCall", NULL),
317ed11399dSJiri Slaby PXA_BIT(ISR_SAD, "SlaveAddr", NULL),
318ed11399dSJiri Slaby PXA_BIT(ISR_BED, "BusErr", NULL),
319b652b438SRussell King };
320b652b438SRussell King
decode_ISR(unsigned int val)321b652b438SRussell King static void decode_ISR(unsigned int val)
322b652b438SRussell King {
3236fd60fa9SRussell King decode_bits(KERN_DEBUG "ISR", isr_bits, ARRAY_SIZE(isr_bits), val);
324b652b438SRussell King }
325b652b438SRussell King
326b652b438SRussell King static const struct bits icr_bits[] = {
327ed11399dSJiri Slaby PXA_BIT(ICR_START, "START", NULL),
328ed11399dSJiri Slaby PXA_BIT(ICR_STOP, "STOP", NULL),
329ed11399dSJiri Slaby PXA_BIT(ICR_ACKNAK, "ACKNAK", NULL),
330ed11399dSJiri Slaby PXA_BIT(ICR_TB, "TB", NULL),
331ed11399dSJiri Slaby PXA_BIT(ICR_MA, "MA", NULL),
332ed11399dSJiri Slaby PXA_BIT(ICR_SCLE, "SCLE", "scle"),
333ed11399dSJiri Slaby PXA_BIT(ICR_IUE, "IUE", "iue"),
334ed11399dSJiri Slaby PXA_BIT(ICR_GCD, "GCD", NULL),
335ed11399dSJiri Slaby PXA_BIT(ICR_ITEIE, "ITEIE", NULL),
336ed11399dSJiri Slaby PXA_BIT(ICR_IRFIE, "IRFIE", NULL),
337ed11399dSJiri Slaby PXA_BIT(ICR_BEIE, "BEIE", NULL),
338ed11399dSJiri Slaby PXA_BIT(ICR_SSDIE, "SSDIE", NULL),
339ed11399dSJiri Slaby PXA_BIT(ICR_ALDIE, "ALDIE", NULL),
340ed11399dSJiri Slaby PXA_BIT(ICR_SADIE, "SADIE", NULL),
341ed11399dSJiri Slaby PXA_BIT(ICR_UR, "UR", "ur"),
342b652b438SRussell King };
343b652b438SRussell King
344d6a7b5f8SHolger Schurig #ifdef CONFIG_I2C_PXA_SLAVE
decode_ICR(unsigned int val)345b652b438SRussell King static void decode_ICR(unsigned int val)
346b652b438SRussell King {
3476fd60fa9SRussell King decode_bits(KERN_DEBUG "ICR", icr_bits, ARRAY_SIZE(icr_bits), val);
348b652b438SRussell King }
349d6a7b5f8SHolger Schurig #endif
350b652b438SRussell King
351b652b438SRussell King static unsigned int i2c_debug = DEBUG;
352b652b438SRussell King
i2c_pxa_show_state(struct pxa_i2c * i2c,int lno,const char * fname)353b652b438SRussell King static void i2c_pxa_show_state(struct pxa_i2c *i2c, int lno, const char *fname)
354b652b438SRussell King {
355a7b4e550SGuennadi Liakhovetski dev_dbg(&i2c->adap.dev, "state:%s:%d: ISR=%08x, ICR=%08x, IBMR=%02x\n", fname, lno,
356a7b4e550SGuennadi Liakhovetski readl(_ISR(i2c)), readl(_ICR(i2c)), readl(_IBMR(i2c)));
357b652b438SRussell King }
358b652b438SRussell King
35908882d20SHarvey Harrison #define show_state(i2c) i2c_pxa_show_state(i2c, __LINE__, __func__)
360b652b438SRussell King
i2c_pxa_scream_blue_murder(struct pxa_i2c * i2c,const char * why)361b652b438SRussell King static void i2c_pxa_scream_blue_murder(struct pxa_i2c *i2c, const char *why)
362b652b438SRussell King {
363b652b438SRussell King unsigned int i;
3643a2dc167SVaibhav Hiremath struct device *dev = &i2c->adap.dev;
3653a2dc167SVaibhav Hiremath
3663a2dc167SVaibhav Hiremath dev_err(dev, "slave_0x%x error: %s\n",
3673a2dc167SVaibhav Hiremath i2c->req_slave_addr >> 1, why);
3683a2dc167SVaibhav Hiremath dev_err(dev, "msg_num: %d msg_idx: %d msg_ptr: %d\n",
369b652b438SRussell King i2c->msg_num, i2c->msg_idx, i2c->msg_ptr);
3703a2dc167SVaibhav Hiremath dev_err(dev, "IBMR: %08x IDBR: %08x ICR: %08x ISR: %08x\n",
3713a2dc167SVaibhav Hiremath readl(_IBMR(i2c)), readl(_IDBR(i2c)), readl(_ICR(i2c)),
3723a2dc167SVaibhav Hiremath readl(_ISR(i2c)));
37388b73ee7SRussell King dev_err(dev, "log:");
374b652b438SRussell King for (i = 0; i < i2c->irqlogidx; i++)
37588b73ee7SRussell King pr_cont(" [%03x:%05x]", i2c->isrlog[i], i2c->icrlog[i]);
37688b73ee7SRussell King pr_cont("\n");
377b652b438SRussell King }
378b652b438SRussell King
3790d813d99SWolfram Sang #else /* ifdef DEBUG */
3800d813d99SWolfram Sang
3810d813d99SWolfram Sang #define i2c_debug 0
3820d813d99SWolfram Sang
3830d813d99SWolfram Sang #define show_state(i2c) do { } while (0)
3840d813d99SWolfram Sang #define decode_ISR(val) do { } while (0)
3850d813d99SWolfram Sang #define decode_ICR(val) do { } while (0)
3860d813d99SWolfram Sang #define i2c_pxa_scream_blue_murder(i2c, why) do { } while (0)
3870d813d99SWolfram Sang
3880d813d99SWolfram Sang #endif /* ifdef DEBUG / else */
3890d813d99SWolfram Sang
3900d813d99SWolfram Sang static void i2c_pxa_master_complete(struct pxa_i2c *i2c, int ret);
3910d813d99SWolfram Sang
i2c_pxa_is_slavemode(struct pxa_i2c * i2c)392b652b438SRussell King static inline int i2c_pxa_is_slavemode(struct pxa_i2c *i2c)
393b652b438SRussell King {
394a7b4e550SGuennadi Liakhovetski return !(readl(_ICR(i2c)) & ICR_SCLE);
395b652b438SRussell King }
396b652b438SRussell King
i2c_pxa_abort(struct pxa_i2c * i2c)397b652b438SRussell King static void i2c_pxa_abort(struct pxa_i2c *i2c)
398b652b438SRussell King {
399387fa6a5SDmitry Baryshkov int i = 250;
400b652b438SRussell King
401b652b438SRussell King if (i2c_pxa_is_slavemode(i2c)) {
4026fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "%s: called in slave mode\n", __func__);
403b652b438SRussell King return;
404b652b438SRussell King }
405b652b438SRussell King
406f8e5d3cbSRussell King while ((i > 0) && (readl(_IBMR(i2c)) & IBMR_SDAS) == 0) {
407a7b4e550SGuennadi Liakhovetski unsigned long icr = readl(_ICR(i2c));
408b652b438SRussell King
409b652b438SRussell King icr &= ~ICR_START;
410b652b438SRussell King icr |= ICR_ACKNAK | ICR_STOP | ICR_TB;
411b652b438SRussell King
412a7b4e550SGuennadi Liakhovetski writel(icr, _ICR(i2c));
413b652b438SRussell King
414b652b438SRussell King show_state(i2c);
415b652b438SRussell King
416387fa6a5SDmitry Baryshkov mdelay(1);
417387fa6a5SDmitry Baryshkov i --;
418b652b438SRussell King }
419b652b438SRussell King
420a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) & ~(ICR_MA | ICR_START | ICR_STOP),
421a7b4e550SGuennadi Liakhovetski _ICR(i2c));
422b652b438SRussell King }
423b652b438SRussell King
i2c_pxa_wait_bus_not_busy(struct pxa_i2c * i2c)424b652b438SRussell King static int i2c_pxa_wait_bus_not_busy(struct pxa_i2c *i2c)
425b652b438SRussell King {
426b652b438SRussell King int timeout = DEF_TIMEOUT;
427e896be5aSRussell King u32 isr;
428b652b438SRussell King
429e896be5aSRussell King while (1) {
430e896be5aSRussell King isr = readl(_ISR(i2c));
431e896be5aSRussell King if (!(isr & (ISR_IBB | ISR_UB)))
432e896be5aSRussell King return 0;
433e896be5aSRussell King
434e896be5aSRussell King if (isr & ISR_SAD)
435b652b438SRussell King timeout += 4;
436b652b438SRussell King
437e896be5aSRussell King if (!timeout--)
438e896be5aSRussell King break;
439e896be5aSRussell King
440b652b438SRussell King msleep(2);
441b652b438SRussell King show_state(i2c);
442b652b438SRussell King }
443b652b438SRussell King
444b652b438SRussell King show_state(i2c);
445b652b438SRussell King
446e896be5aSRussell King return I2C_RETRY;
447b652b438SRussell King }
448b652b438SRussell King
i2c_pxa_wait_master(struct pxa_i2c * i2c)449b652b438SRussell King static int i2c_pxa_wait_master(struct pxa_i2c *i2c)
450b652b438SRussell King {
451b652b438SRussell King unsigned long timeout = jiffies + HZ*4;
452b652b438SRussell King
453b652b438SRussell King while (time_before(jiffies, timeout)) {
454b652b438SRussell King if (i2c_debug > 1)
4556fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "%s: %ld: ISR=%08x, ICR=%08x, IBMR=%02x\n",
456a7b4e550SGuennadi Liakhovetski __func__, (long)jiffies, readl(_ISR(i2c)), readl(_ICR(i2c)), readl(_IBMR(i2c)));
457b652b438SRussell King
458a7b4e550SGuennadi Liakhovetski if (readl(_ISR(i2c)) & ISR_SAD) {
459b652b438SRussell King if (i2c_debug > 0)
4606fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "%s: Slave detected\n", __func__);
461b652b438SRussell King goto out;
462b652b438SRussell King }
463b652b438SRussell King
464b652b438SRussell King /* wait for unit and bus being not busy, and we also do a
465b652b438SRussell King * quick check of the i2c lines themselves to ensure they've
466b652b438SRussell King * gone high...
467b652b438SRussell King */
468f8e5d3cbSRussell King if ((readl(_ISR(i2c)) & (ISR_UB | ISR_IBB)) == 0 &&
469f8e5d3cbSRussell King readl(_IBMR(i2c)) == (IBMR_SCLS | IBMR_SDAS)) {
470b652b438SRussell King if (i2c_debug > 0)
4716fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "%s: done\n", __func__);
472b652b438SRussell King return 1;
473b652b438SRussell King }
474b652b438SRussell King
475b652b438SRussell King msleep(1);
476b652b438SRussell King }
477b652b438SRussell King
478b652b438SRussell King if (i2c_debug > 0)
4796fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "%s: did not free\n", __func__);
480b652b438SRussell King out:
481b652b438SRussell King return 0;
482b652b438SRussell King }
483b652b438SRussell King
i2c_pxa_set_master(struct pxa_i2c * i2c)484b652b438SRussell King static int i2c_pxa_set_master(struct pxa_i2c *i2c)
485b652b438SRussell King {
486b652b438SRussell King if (i2c_debug)
4876fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "setting to bus master\n");
488b652b438SRussell King
489a7b4e550SGuennadi Liakhovetski if ((readl(_ISR(i2c)) & (ISR_UB | ISR_IBB)) != 0) {
4906fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "%s: unit is busy\n", __func__);
491b652b438SRussell King if (!i2c_pxa_wait_master(i2c)) {
4926fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "%s: error: unit busy\n", __func__);
493b652b438SRussell King return I2C_RETRY;
494b652b438SRussell King }
495b652b438SRussell King }
496b652b438SRussell King
497a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) | ICR_SCLE, _ICR(i2c));
498b652b438SRussell King return 0;
499b652b438SRussell King }
500b652b438SRussell King
501b652b438SRussell King #ifdef CONFIG_I2C_PXA_SLAVE
i2c_pxa_wait_slave(struct pxa_i2c * i2c)502b652b438SRussell King static int i2c_pxa_wait_slave(struct pxa_i2c *i2c)
503b652b438SRussell King {
504b652b438SRussell King unsigned long timeout = jiffies + HZ*1;
505b652b438SRussell King
506b652b438SRussell King /* wait for stop */
507b652b438SRussell King
508b652b438SRussell King show_state(i2c);
509b652b438SRussell King
510b652b438SRussell King while (time_before(jiffies, timeout)) {
511b652b438SRussell King if (i2c_debug > 1)
5126fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "%s: %ld: ISR=%08x, ICR=%08x, IBMR=%02x\n",
513a7b4e550SGuennadi Liakhovetski __func__, (long)jiffies, readl(_ISR(i2c)), readl(_ICR(i2c)), readl(_IBMR(i2c)));
514b652b438SRussell King
515a7b4e550SGuennadi Liakhovetski if ((readl(_ISR(i2c)) & (ISR_UB|ISR_IBB)) == 0 ||
516a7b4e550SGuennadi Liakhovetski (readl(_ISR(i2c)) & ISR_SAD) != 0 ||
517a7b4e550SGuennadi Liakhovetski (readl(_ICR(i2c)) & ICR_SCLE) == 0) {
518b652b438SRussell King if (i2c_debug > 1)
5196fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "%s: done\n", __func__);
520b652b438SRussell King return 1;
521b652b438SRussell King }
522b652b438SRussell King
523b652b438SRussell King msleep(1);
524b652b438SRussell King }
525b652b438SRussell King
526b652b438SRussell King if (i2c_debug > 0)
5276fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "%s: did not free\n", __func__);
528b652b438SRussell King return 0;
529b652b438SRussell King }
530b652b438SRussell King
531b652b438SRussell King /*
532b652b438SRussell King * clear the hold on the bus, and take of anything else
533b652b438SRussell King * that has been configured
534b652b438SRussell King */
i2c_pxa_set_slave(struct pxa_i2c * i2c,int errcode)535b652b438SRussell King static void i2c_pxa_set_slave(struct pxa_i2c *i2c, int errcode)
536b652b438SRussell King {
537b652b438SRussell King show_state(i2c);
538b652b438SRussell King
539b652b438SRussell King if (errcode < 0) {
540b652b438SRussell King udelay(100); /* simple delay */
541b652b438SRussell King } else {
542b652b438SRussell King /* we need to wait for the stop condition to end */
543b652b438SRussell King
544b652b438SRussell King /* if we where in stop, then clear... */
545a7b4e550SGuennadi Liakhovetski if (readl(_ICR(i2c)) & ICR_STOP) {
546b652b438SRussell King udelay(100);
547a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) & ~ICR_STOP, _ICR(i2c));
548b652b438SRussell King }
549b652b438SRussell King
550b652b438SRussell King if (!i2c_pxa_wait_slave(i2c)) {
5516fd60fa9SRussell King dev_err(&i2c->adap.dev, "%s: wait timedout\n",
5526fd60fa9SRussell King __func__);
553b652b438SRussell King return;
554b652b438SRussell King }
555b652b438SRussell King }
556b652b438SRussell King
557a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) & ~(ICR_STOP|ICR_ACKNAK|ICR_MA), _ICR(i2c));
558a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) & ~ICR_SCLE, _ICR(i2c));
559b652b438SRussell King
560b652b438SRussell King if (i2c_debug) {
561a7b4e550SGuennadi Liakhovetski dev_dbg(&i2c->adap.dev, "ICR now %08x, ISR %08x\n", readl(_ICR(i2c)), readl(_ISR(i2c)));
562a7b4e550SGuennadi Liakhovetski decode_ICR(readl(_ICR(i2c)));
563b652b438SRussell King }
564b652b438SRussell King }
565b652b438SRussell King #else
566b652b438SRussell King #define i2c_pxa_set_slave(i2c, err) do { } while (0)
567b652b438SRussell King #endif
568b652b438SRussell King
i2c_pxa_do_reset(struct pxa_i2c * i2c)5697c9ec2c5SRussell King static void i2c_pxa_do_reset(struct pxa_i2c *i2c)
570b652b438SRussell King {
571b652b438SRussell King /* reset according to 9.8 */
572a7b4e550SGuennadi Liakhovetski writel(ICR_UR, _ICR(i2c));
573a7b4e550SGuennadi Liakhovetski writel(I2C_ISR_INIT, _ISR(i2c));
574a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) & ~ICR_UR, _ICR(i2c));
575b652b438SRussell King
576e087b427SVaibhav Hiremath if (i2c->reg_isar && IS_ENABLED(CONFIG_I2C_PXA_SLAVE))
577a7b4e550SGuennadi Liakhovetski writel(i2c->slave_addr, _ISAR(i2c));
578b652b438SRussell King
579b652b438SRussell King /* set control register values */
5806c14bdacSRomain Perier writel(I2C_ICR_INIT | (i2c->fast_mode ? i2c->fm_mask : 0), _ICR(i2c));
5816c14bdacSRomain Perier writel(readl(_ICR(i2c)) | (i2c->high_mode ? i2c->hs_mask : 0), _ICR(i2c));
582b652b438SRussell King
583b652b438SRussell King #ifdef CONFIG_I2C_PXA_SLAVE
5846fd60fa9SRussell King dev_info(&i2c->adap.dev, "Enabling slave mode\n");
585a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) | ICR_SADIE | ICR_ALDIE | ICR_SSDIE, _ICR(i2c));
586b652b438SRussell King #endif
587b652b438SRussell King
588b652b438SRussell King i2c_pxa_set_slave(i2c, 0);
5897c9ec2c5SRussell King }
590b652b438SRussell King
i2c_pxa_enable(struct pxa_i2c * i2c)5917c9ec2c5SRussell King static void i2c_pxa_enable(struct pxa_i2c *i2c)
5927c9ec2c5SRussell King {
593b652b438SRussell King /* enable unit */
594a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) | ICR_IUE, _ICR(i2c));
595b652b438SRussell King udelay(100);
596b652b438SRussell King }
597b652b438SRussell King
i2c_pxa_reset(struct pxa_i2c * i2c)5987c9ec2c5SRussell King static void i2c_pxa_reset(struct pxa_i2c *i2c)
5997c9ec2c5SRussell King {
6007c9ec2c5SRussell King pr_debug("Resetting I2C Controller Unit\n");
6017c9ec2c5SRussell King
6027c9ec2c5SRussell King /* abort any transfer currently under way */
6037c9ec2c5SRussell King i2c_pxa_abort(i2c);
6047c9ec2c5SRussell King i2c_pxa_do_reset(i2c);
6057c9ec2c5SRussell King i2c_pxa_enable(i2c);
6067c9ec2c5SRussell King }
6077c9ec2c5SRussell King
608b652b438SRussell King
609b652b438SRussell King #ifdef CONFIG_I2C_PXA_SLAVE
610b652b438SRussell King /*
611b652b438SRussell King * PXA I2C Slave mode
612b652b438SRussell King */
613b652b438SRussell King
i2c_pxa_slave_txempty(struct pxa_i2c * i2c,u32 isr)614b652b438SRussell King static void i2c_pxa_slave_txempty(struct pxa_i2c *i2c, u32 isr)
615b652b438SRussell King {
616b652b438SRussell King if (isr & ISR_BED) {
617b652b438SRussell King /* what should we do here? */
618b652b438SRussell King } else {
6194d51b4ceSPatrick Williams u8 byte = 0;
62084b5abe6SRussell King
62184b5abe6SRussell King if (i2c->slave != NULL)
6224d51b4ceSPatrick Williams i2c_slave_event(i2c->slave, I2C_SLAVE_READ_PROCESSED,
6234d51b4ceSPatrick Williams &byte);
624b652b438SRussell King
6254d51b4ceSPatrick Williams writel(byte, _IDBR(i2c));
626a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) | ICR_TB, _ICR(i2c)); /* allow next byte */
627b652b438SRussell King }
628b652b438SRussell King }
629b652b438SRussell King
i2c_pxa_slave_rxfull(struct pxa_i2c * i2c,u32 isr)630b652b438SRussell King static void i2c_pxa_slave_rxfull(struct pxa_i2c *i2c, u32 isr)
631b652b438SRussell King {
6324d51b4ceSPatrick Williams u8 byte = readl(_IDBR(i2c));
633b652b438SRussell King
634b652b438SRussell King if (i2c->slave != NULL)
6354d51b4ceSPatrick Williams i2c_slave_event(i2c->slave, I2C_SLAVE_WRITE_RECEIVED, &byte);
636b652b438SRussell King
637a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) | ICR_TB, _ICR(i2c));
638b652b438SRussell King }
639b652b438SRussell King
i2c_pxa_slave_start(struct pxa_i2c * i2c,u32 isr)640b652b438SRussell King static void i2c_pxa_slave_start(struct pxa_i2c *i2c, u32 isr)
641b652b438SRussell King {
642b652b438SRussell King int timeout;
643b652b438SRussell King
644b652b438SRussell King if (i2c_debug > 0)
6456fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "SAD, mode is slave-%cx\n",
646b652b438SRussell King (isr & ISR_RWM) ? 'r' : 't');
647b652b438SRussell King
6484d51b4ceSPatrick Williams if (i2c->slave != NULL) {
6494d51b4ceSPatrick Williams if (isr & ISR_RWM) {
6504d51b4ceSPatrick Williams u8 byte = 0;
6514d51b4ceSPatrick Williams
6524d51b4ceSPatrick Williams i2c_slave_event(i2c->slave, I2C_SLAVE_READ_REQUESTED,
6534d51b4ceSPatrick Williams &byte);
6544d51b4ceSPatrick Williams writel(byte, _IDBR(i2c));
6554d51b4ceSPatrick Williams } else {
6564d51b4ceSPatrick Williams i2c_slave_event(i2c->slave, I2C_SLAVE_WRITE_REQUESTED,
6574d51b4ceSPatrick Williams NULL);
6584d51b4ceSPatrick Williams }
6594d51b4ceSPatrick Williams }
660b652b438SRussell King
661b652b438SRussell King /*
662b652b438SRussell King * slave could interrupt in the middle of us generating a
663b652b438SRussell King * start condition... if this happens, we'd better back off
664b652b438SRussell King * and stop holding the poor thing up
665b652b438SRussell King */
666a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) & ~(ICR_START|ICR_STOP), _ICR(i2c));
667a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) | ICR_TB, _ICR(i2c));
668b652b438SRussell King
669b652b438SRussell King timeout = 0x10000;
670b652b438SRussell King
671b652b438SRussell King while (1) {
672f8e5d3cbSRussell King if ((readl(_IBMR(i2c)) & IBMR_SCLS) == IBMR_SCLS)
673b652b438SRussell King break;
674b652b438SRussell King
675b652b438SRussell King timeout--;
676b652b438SRussell King
677b652b438SRussell King if (timeout <= 0) {
6786fd60fa9SRussell King dev_err(&i2c->adap.dev, "timeout waiting for SCL high\n");
679b652b438SRussell King break;
680b652b438SRussell King }
681b652b438SRussell King }
682b652b438SRussell King
683a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) & ~ICR_SCLE, _ICR(i2c));
684b652b438SRussell King }
685b652b438SRussell King
i2c_pxa_slave_stop(struct pxa_i2c * i2c)686b652b438SRussell King static void i2c_pxa_slave_stop(struct pxa_i2c *i2c)
687b652b438SRussell King {
688b652b438SRussell King if (i2c_debug > 2)
6896fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "ISR: SSD (Slave Stop)\n");
690b652b438SRussell King
691b652b438SRussell King if (i2c->slave != NULL)
6924d51b4ceSPatrick Williams i2c_slave_event(i2c->slave, I2C_SLAVE_STOP, NULL);
693b652b438SRussell King
694b652b438SRussell King if (i2c_debug > 2)
6956fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "ISR: SSD (Slave Stop) acked\n");
696b652b438SRussell King
697b652b438SRussell King /*
698b652b438SRussell King * If we have a master-mode message waiting,
699b652b438SRussell King * kick it off now that the slave has completed.
700b652b438SRussell King */
701b652b438SRussell King if (i2c->msg)
702b652b438SRussell King i2c_pxa_master_complete(i2c, I2C_RETRY);
703b652b438SRussell King }
7044d51b4ceSPatrick Williams
i2c_pxa_slave_reg(struct i2c_client * slave)7054d51b4ceSPatrick Williams static int i2c_pxa_slave_reg(struct i2c_client *slave)
7064d51b4ceSPatrick Williams {
7074d51b4ceSPatrick Williams struct pxa_i2c *i2c = slave->adapter->algo_data;
7084d51b4ceSPatrick Williams
7094d51b4ceSPatrick Williams if (i2c->slave)
7104d51b4ceSPatrick Williams return -EBUSY;
7114d51b4ceSPatrick Williams
7124d51b4ceSPatrick Williams if (!i2c->reg_isar)
7134d51b4ceSPatrick Williams return -EAFNOSUPPORT;
7144d51b4ceSPatrick Williams
7154d51b4ceSPatrick Williams i2c->slave = slave;
7164d51b4ceSPatrick Williams i2c->slave_addr = slave->addr;
7174d51b4ceSPatrick Williams
7184d51b4ceSPatrick Williams writel(i2c->slave_addr, _ISAR(i2c));
7194d51b4ceSPatrick Williams
7204d51b4ceSPatrick Williams return 0;
7214d51b4ceSPatrick Williams }
7224d51b4ceSPatrick Williams
i2c_pxa_slave_unreg(struct i2c_client * slave)7234d51b4ceSPatrick Williams static int i2c_pxa_slave_unreg(struct i2c_client *slave)
7244d51b4ceSPatrick Williams {
7254d51b4ceSPatrick Williams struct pxa_i2c *i2c = slave->adapter->algo_data;
7264d51b4ceSPatrick Williams
7274d51b4ceSPatrick Williams WARN_ON(!i2c->slave);
7284d51b4ceSPatrick Williams
7294d51b4ceSPatrick Williams i2c->slave_addr = I2C_PXA_SLAVE_ADDR;
7304d51b4ceSPatrick Williams writel(i2c->slave_addr, _ISAR(i2c));
7314d51b4ceSPatrick Williams
7324d51b4ceSPatrick Williams i2c->slave = NULL;
7334d51b4ceSPatrick Williams
7344d51b4ceSPatrick Williams return 0;
7354d51b4ceSPatrick Williams }
736b652b438SRussell King #else
i2c_pxa_slave_txempty(struct pxa_i2c * i2c,u32 isr)737b652b438SRussell King static void i2c_pxa_slave_txempty(struct pxa_i2c *i2c, u32 isr)
738b652b438SRussell King {
739b652b438SRussell King if (isr & ISR_BED) {
740b652b438SRussell King /* what should we do here? */
741b652b438SRussell King } else {
742a7b4e550SGuennadi Liakhovetski writel(0, _IDBR(i2c));
743a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) | ICR_TB, _ICR(i2c));
744b652b438SRussell King }
745b652b438SRussell King }
746b652b438SRussell King
i2c_pxa_slave_rxfull(struct pxa_i2c * i2c,u32 isr)747b652b438SRussell King static void i2c_pxa_slave_rxfull(struct pxa_i2c *i2c, u32 isr)
748b652b438SRussell King {
749a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) | ICR_TB | ICR_ACKNAK, _ICR(i2c));
750b652b438SRussell King }
751b652b438SRussell King
i2c_pxa_slave_start(struct pxa_i2c * i2c,u32 isr)752b652b438SRussell King static void i2c_pxa_slave_start(struct pxa_i2c *i2c, u32 isr)
753b652b438SRussell King {
754b652b438SRussell King int timeout;
755b652b438SRussell King
756b652b438SRussell King /*
757b652b438SRussell King * slave could interrupt in the middle of us generating a
758b652b438SRussell King * start condition... if this happens, we'd better back off
759b652b438SRussell King * and stop holding the poor thing up
760b652b438SRussell King */
761a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) & ~(ICR_START|ICR_STOP), _ICR(i2c));
762a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) | ICR_TB | ICR_ACKNAK, _ICR(i2c));
763b652b438SRussell King
764b652b438SRussell King timeout = 0x10000;
765b652b438SRussell King
766b652b438SRussell King while (1) {
767f8e5d3cbSRussell King if ((readl(_IBMR(i2c)) & IBMR_SCLS) == IBMR_SCLS)
768b652b438SRussell King break;
769b652b438SRussell King
770b652b438SRussell King timeout--;
771b652b438SRussell King
772b652b438SRussell King if (timeout <= 0) {
7736fd60fa9SRussell King dev_err(&i2c->adap.dev, "timeout waiting for SCL high\n");
774b652b438SRussell King break;
775b652b438SRussell King }
776b652b438SRussell King }
777b652b438SRussell King
778a7b4e550SGuennadi Liakhovetski writel(readl(_ICR(i2c)) & ~ICR_SCLE, _ICR(i2c));
779b652b438SRussell King }
780b652b438SRussell King
i2c_pxa_slave_stop(struct pxa_i2c * i2c)781b652b438SRussell King static void i2c_pxa_slave_stop(struct pxa_i2c *i2c)
782b652b438SRussell King {
783b652b438SRussell King if (i2c->msg)
784b652b438SRussell King i2c_pxa_master_complete(i2c, I2C_RETRY);
785b652b438SRussell King }
786b652b438SRussell King #endif
787b652b438SRussell King
788b652b438SRussell King /*
789b652b438SRussell King * PXA I2C Master mode
790b652b438SRussell King */
791b652b438SRussell King
i2c_pxa_start_message(struct pxa_i2c * i2c)792b652b438SRussell King static inline void i2c_pxa_start_message(struct pxa_i2c *i2c)
793b652b438SRussell King {
794b652b438SRussell King u32 icr;
795b652b438SRussell King
796b652b438SRussell King /*
797b652b438SRussell King * Step 1: target slave address into IDBR
798b652b438SRussell King */
799868d4d37SRussell King i2c->req_slave_addr = i2c_8bit_addr_from_msg(i2c->msg);
800868d4d37SRussell King writel(i2c->req_slave_addr, _IDBR(i2c));
801b652b438SRussell King
802b652b438SRussell King /*
803b652b438SRussell King * Step 2: initiate the write.
804b652b438SRussell King */
805a7b4e550SGuennadi Liakhovetski icr = readl(_ICR(i2c)) & ~(ICR_STOP | ICR_ALDIE);
806a7b4e550SGuennadi Liakhovetski writel(icr | ICR_START | ICR_TB, _ICR(i2c));
807b652b438SRussell King }
808b652b438SRussell King
i2c_pxa_stop_message(struct pxa_i2c * i2c)8097d054817SJean Delvare static inline void i2c_pxa_stop_message(struct pxa_i2c *i2c)
8107d054817SJean Delvare {
8117d054817SJean Delvare u32 icr;
8127d054817SJean Delvare
813e81c979fSRussell King /* Clear the START, STOP, ACK, TB and MA flags */
8147d054817SJean Delvare icr = readl(_ICR(i2c));
815e81c979fSRussell King icr &= ~(ICR_START | ICR_STOP | ICR_ACKNAK | ICR_TB | ICR_MA);
8160cfe61e1SRussell King writel(icr, _ICR(i2c));
8177d054817SJean Delvare }
8187d054817SJean Delvare
8199d3dda5cSLeilei Shang /*
8209d3dda5cSLeilei Shang * PXA I2C send master code
8219d3dda5cSLeilei Shang * 1. Load master code to IDBR and send it.
8229d3dda5cSLeilei Shang * Note for HS mode, set ICR [GPIOEN].
8239d3dda5cSLeilei Shang * 2. Wait until win arbitration.
8249d3dda5cSLeilei Shang */
i2c_pxa_send_mastercode(struct pxa_i2c * i2c)8259d3dda5cSLeilei Shang static int i2c_pxa_send_mastercode(struct pxa_i2c *i2c)
8269d3dda5cSLeilei Shang {
8279d3dda5cSLeilei Shang u32 icr;
8289d3dda5cSLeilei Shang long timeout;
8299d3dda5cSLeilei Shang
8309d3dda5cSLeilei Shang spin_lock_irq(&i2c->lock);
8319d3dda5cSLeilei Shang i2c->highmode_enter = true;
8329d3dda5cSLeilei Shang writel(i2c->master_code, _IDBR(i2c));
8339d3dda5cSLeilei Shang
8349d3dda5cSLeilei Shang icr = readl(_ICR(i2c)) & ~(ICR_STOP | ICR_ALDIE);
8359d3dda5cSLeilei Shang icr |= ICR_GPIOEN | ICR_START | ICR_TB | ICR_ITEIE;
8369d3dda5cSLeilei Shang writel(icr, _ICR(i2c));
8379d3dda5cSLeilei Shang
8389d3dda5cSLeilei Shang spin_unlock_irq(&i2c->lock);
8399d3dda5cSLeilei Shang timeout = wait_event_timeout(i2c->wait,
8409d3dda5cSLeilei Shang i2c->highmode_enter == false, HZ * 1);
8419d3dda5cSLeilei Shang
8429d3dda5cSLeilei Shang i2c->highmode_enter = false;
8439d3dda5cSLeilei Shang
8449d3dda5cSLeilei Shang return (timeout == 0) ? I2C_RETRY : 0;
8459d3dda5cSLeilei Shang }
8469d3dda5cSLeilei Shang
847b652b438SRussell King /*
848b652b438SRussell King * i2c_pxa_master_complete - complete the message and wake up.
849b652b438SRussell King */
i2c_pxa_master_complete(struct pxa_i2c * i2c,int ret)850b652b438SRussell King static void i2c_pxa_master_complete(struct pxa_i2c *i2c, int ret)
851b652b438SRussell King {
852b652b438SRussell King i2c->msg_ptr = 0;
853b652b438SRussell King i2c->msg = NULL;
854b652b438SRussell King i2c->msg_idx ++;
855b652b438SRussell King i2c->msg_num = 0;
856b652b438SRussell King if (ret)
857b652b438SRussell King i2c->msg_idx = ret;
858b7a36701SMike Rapoport if (!i2c->use_pio)
859b652b438SRussell King wake_up(&i2c->wait);
860b652b438SRussell King }
861b652b438SRussell King
i2c_pxa_irq_txempty(struct pxa_i2c * i2c,u32 isr)862b652b438SRussell King static void i2c_pxa_irq_txempty(struct pxa_i2c *i2c, u32 isr)
863b652b438SRussell King {
864a7b4e550SGuennadi Liakhovetski u32 icr = readl(_ICR(i2c)) & ~(ICR_START|ICR_STOP|ICR_ACKNAK|ICR_TB);
865b652b438SRussell King
866b652b438SRussell King again:
867b652b438SRussell King /*
868b652b438SRussell King * If ISR_ALD is set, we lost arbitration.
869b652b438SRussell King */
870b652b438SRussell King if (isr & ISR_ALD) {
871b652b438SRussell King /*
872b652b438SRussell King * Do we need to do anything here? The PXA docs
873b652b438SRussell King * are vague about what happens.
874b652b438SRussell King */
875b652b438SRussell King i2c_pxa_scream_blue_murder(i2c, "ALD set");
876b652b438SRussell King
877b652b438SRussell King /*
878b652b438SRussell King * We ignore this error. We seem to see spurious ALDs
879b652b438SRussell King * for seemingly no reason. If we handle them as I think
880b652b438SRussell King * they should, we end up causing an I2C error, which
881b652b438SRussell King * is painful for some systems.
882b652b438SRussell King */
883b652b438SRussell King return; /* ignore */
884b652b438SRussell King }
885b652b438SRussell King
88686261fddSPetr Cvek if ((isr & ISR_BED) &&
88786261fddSPetr Cvek (!((i2c->msg->flags & I2C_M_IGNORE_NAK) &&
88886261fddSPetr Cvek (isr & ISR_ACKNAK)))) {
889b652b438SRussell King int ret = BUS_ERROR;
890b652b438SRussell King
891b652b438SRussell King /*
892b652b438SRussell King * I2C bus error - either the device NAK'd us, or
893b652b438SRussell King * something more serious happened. If we were NAK'd
894b652b438SRussell King * on the initial address phase, we can retry.
895b652b438SRussell King */
896b652b438SRussell King if (isr & ISR_ACKNAK) {
897b652b438SRussell King if (i2c->msg_ptr == 0 && i2c->msg_idx == 0)
898c25e509aSRussell King ret = NO_SLAVE;
899b652b438SRussell King else
900b652b438SRussell King ret = XFER_NAKED;
901b652b438SRussell King }
902b652b438SRussell King i2c_pxa_master_complete(i2c, ret);
903b652b438SRussell King } else if (isr & ISR_RWM) {
904b652b438SRussell King /*
905b652b438SRussell King * Read mode. We have just sent the address byte, and
906b652b438SRussell King * now we must initiate the transfer.
907b652b438SRussell King */
908b652b438SRussell King if (i2c->msg_ptr == i2c->msg->len - 1 &&
909b652b438SRussell King i2c->msg_idx == i2c->msg_num - 1)
910b652b438SRussell King icr |= ICR_STOP | ICR_ACKNAK;
911b652b438SRussell King
912b652b438SRussell King icr |= ICR_ALDIE | ICR_TB;
913b652b438SRussell King } else if (i2c->msg_ptr < i2c->msg->len) {
914b652b438SRussell King /*
915b652b438SRussell King * Write mode. Write the next data byte.
916b652b438SRussell King */
917a7b4e550SGuennadi Liakhovetski writel(i2c->msg->buf[i2c->msg_ptr++], _IDBR(i2c));
918b652b438SRussell King
919b652b438SRussell King icr |= ICR_ALDIE | ICR_TB;
920b652b438SRussell King
921b652b438SRussell King /*
92286261fddSPetr Cvek * If this is the last byte of the last message or last byte
92386261fddSPetr Cvek * of any message with I2C_M_STOP (e.g. SCCB), send a STOP.
924b652b438SRussell King */
92586261fddSPetr Cvek if ((i2c->msg_ptr == i2c->msg->len) &&
92686261fddSPetr Cvek ((i2c->msg->flags & I2C_M_STOP) ||
92786261fddSPetr Cvek (i2c->msg_idx == i2c->msg_num - 1)))
928b652b438SRussell King icr |= ICR_STOP;
92986261fddSPetr Cvek
930b652b438SRussell King } else if (i2c->msg_idx < i2c->msg_num - 1) {
931b652b438SRussell King /*
932b652b438SRussell King * Next segment of the message.
933b652b438SRussell King */
934b652b438SRussell King i2c->msg_ptr = 0;
935b652b438SRussell King i2c->msg_idx ++;
936b652b438SRussell King i2c->msg++;
937b652b438SRussell King
938b652b438SRussell King /*
939b652b438SRussell King * If we aren't doing a repeated start and address,
940b652b438SRussell King * go back and try to send the next byte. Note that
941b652b438SRussell King * we do not support switching the R/W direction here.
942b652b438SRussell King */
943b652b438SRussell King if (i2c->msg->flags & I2C_M_NOSTART)
944b652b438SRussell King goto again;
945b652b438SRussell King
946b652b438SRussell King /*
947b652b438SRussell King * Write the next address.
948b652b438SRussell King */
949868d4d37SRussell King i2c->req_slave_addr = i2c_8bit_addr_from_msg(i2c->msg);
950868d4d37SRussell King writel(i2c->req_slave_addr, _IDBR(i2c));
951b652b438SRussell King
952b652b438SRussell King /*
953b652b438SRussell King * And trigger a repeated start, and send the byte.
954b652b438SRussell King */
955b652b438SRussell King icr &= ~ICR_ALDIE;
956b652b438SRussell King icr |= ICR_START | ICR_TB;
957b652b438SRussell King } else {
9582fd6cbf4SRussell King if (i2c->msg->len == 0)
9592fd6cbf4SRussell King icr |= ICR_MA;
960b652b438SRussell King i2c_pxa_master_complete(i2c, 0);
961b652b438SRussell King }
962b652b438SRussell King
963b652b438SRussell King i2c->icrlog[i2c->irqlogidx-1] = icr;
964b652b438SRussell King
965a7b4e550SGuennadi Liakhovetski writel(icr, _ICR(i2c));
966b652b438SRussell King show_state(i2c);
967b652b438SRussell King }
968b652b438SRussell King
i2c_pxa_irq_rxfull(struct pxa_i2c * i2c,u32 isr)969b652b438SRussell King static void i2c_pxa_irq_rxfull(struct pxa_i2c *i2c, u32 isr)
970b652b438SRussell King {
971a7b4e550SGuennadi Liakhovetski u32 icr = readl(_ICR(i2c)) & ~(ICR_START|ICR_STOP|ICR_ACKNAK|ICR_TB);
972b652b438SRussell King
973b652b438SRussell King /*
974b652b438SRussell King * Read the byte.
975b652b438SRussell King */
976a7b4e550SGuennadi Liakhovetski i2c->msg->buf[i2c->msg_ptr++] = readl(_IDBR(i2c));
977b652b438SRussell King
978b652b438SRussell King if (i2c->msg_ptr < i2c->msg->len) {
979b652b438SRussell King /*
980b652b438SRussell King * If this is the last byte of the last
981b652b438SRussell King * message, send a STOP.
982b652b438SRussell King */
983b652b438SRussell King if (i2c->msg_ptr == i2c->msg->len - 1)
984b652b438SRussell King icr |= ICR_STOP | ICR_ACKNAK;
985b652b438SRussell King
986b652b438SRussell King icr |= ICR_ALDIE | ICR_TB;
987b652b438SRussell King } else {
988b652b438SRussell King i2c_pxa_master_complete(i2c, 0);
989b652b438SRussell King }
990b652b438SRussell King
991b652b438SRussell King i2c->icrlog[i2c->irqlogidx-1] = icr;
992b652b438SRussell King
993a7b4e550SGuennadi Liakhovetski writel(icr, _ICR(i2c));
994b652b438SRussell King }
995b652b438SRussell King
996c66dc529SSebastian Andrzej Siewior #define VALID_INT_SOURCE (ISR_SSD | ISR_ALD | ISR_ITE | ISR_IRF | \
997c66dc529SSebastian Andrzej Siewior ISR_SAD | ISR_BED)
i2c_pxa_handler(int this_irq,void * dev_id)9987d12e780SDavid Howells static irqreturn_t i2c_pxa_handler(int this_irq, void *dev_id)
999b652b438SRussell King {
1000b652b438SRussell King struct pxa_i2c *i2c = dev_id;
1001a7b4e550SGuennadi Liakhovetski u32 isr = readl(_ISR(i2c));
1002b652b438SRussell King
100397491ba3SVasily Khoruzhick if (!(isr & VALID_INT_SOURCE))
1004c66dc529SSebastian Andrzej Siewior return IRQ_NONE;
1005c66dc529SSebastian Andrzej Siewior
1006b652b438SRussell King if (i2c_debug > 2 && 0) {
10076fd60fa9SRussell King dev_dbg(&i2c->adap.dev, "%s: ISR=%08x, ICR=%08x, IBMR=%02x\n",
1008a7b4e550SGuennadi Liakhovetski __func__, isr, readl(_ICR(i2c)), readl(_IBMR(i2c)));
1009b652b438SRussell King decode_ISR(isr);
1010b652b438SRussell King }
1011b652b438SRussell King
10127e3d7db5STobias Klauser if (i2c->irqlogidx < ARRAY_SIZE(i2c->isrlog))
1013b652b438SRussell King i2c->isrlog[i2c->irqlogidx++] = isr;
1014b652b438SRussell King
1015b652b438SRussell King show_state(i2c);
1016b652b438SRussell King
1017b652b438SRussell King /*
1018b652b438SRussell King * Always clear all pending IRQs.
1019b652b438SRussell King */
102097491ba3SVasily Khoruzhick writel(isr & VALID_INT_SOURCE, _ISR(i2c));
1021b652b438SRussell King
1022b652b438SRussell King if (isr & ISR_SAD)
1023b652b438SRussell King i2c_pxa_slave_start(i2c, isr);
1024b652b438SRussell King if (isr & ISR_SSD)
1025b652b438SRussell King i2c_pxa_slave_stop(i2c);
1026b652b438SRussell King
1027b652b438SRussell King if (i2c_pxa_is_slavemode(i2c)) {
1028b652b438SRussell King if (isr & ISR_ITE)
1029b652b438SRussell King i2c_pxa_slave_txempty(i2c, isr);
1030b652b438SRussell King if (isr & ISR_IRF)
1031b652b438SRussell King i2c_pxa_slave_rxfull(i2c, isr);
10329d3dda5cSLeilei Shang } else if (i2c->msg && (!i2c->highmode_enter)) {
1033b652b438SRussell King if (isr & ISR_ITE)
1034b652b438SRussell King i2c_pxa_irq_txempty(i2c, isr);
1035b652b438SRussell King if (isr & ISR_IRF)
1036b652b438SRussell King i2c_pxa_irq_rxfull(i2c, isr);
10379d3dda5cSLeilei Shang } else if ((isr & ISR_ITE) && i2c->highmode_enter) {
10389d3dda5cSLeilei Shang i2c->highmode_enter = false;
10399d3dda5cSLeilei Shang wake_up(&i2c->wait);
1040b652b438SRussell King } else {
1041b652b438SRussell King i2c_pxa_scream_blue_murder(i2c, "spurious irq");
1042b652b438SRussell King }
1043b652b438SRussell King
1044b652b438SRussell King return IRQ_HANDLED;
1045b652b438SRussell King }
1046b652b438SRussell King
10471ae49a15SRussell King /*
10481ae49a15SRussell King * We are protected by the adapter bus mutex.
10491ae49a15SRussell King */
i2c_pxa_do_xfer(struct pxa_i2c * i2c,struct i2c_msg * msg,int num)10501ae49a15SRussell King static int i2c_pxa_do_xfer(struct pxa_i2c *i2c, struct i2c_msg *msg, int num)
10511ae49a15SRussell King {
10521ae49a15SRussell King long timeout;
10531ae49a15SRussell King int ret;
10541ae49a15SRussell King
10551ae49a15SRussell King /*
10561ae49a15SRussell King * Wait for the bus to become free.
10571ae49a15SRussell King */
10581ae49a15SRussell King ret = i2c_pxa_wait_bus_not_busy(i2c);
10591ae49a15SRussell King if (ret) {
10601ae49a15SRussell King dev_err(&i2c->adap.dev, "i2c_pxa: timeout waiting for bus free\n");
10617c9ec2c5SRussell King i2c_recover_bus(&i2c->adap);
10621ae49a15SRussell King goto out;
10631ae49a15SRussell King }
10641ae49a15SRussell King
10651ae49a15SRussell King /*
10661ae49a15SRussell King * Set master mode.
10671ae49a15SRussell King */
10681ae49a15SRussell King ret = i2c_pxa_set_master(i2c);
10691ae49a15SRussell King if (ret) {
10701ae49a15SRussell King dev_err(&i2c->adap.dev, "i2c_pxa_set_master: error %d\n", ret);
10711ae49a15SRussell King goto out;
10721ae49a15SRussell King }
10731ae49a15SRussell King
10741ae49a15SRussell King if (i2c->high_mode) {
10751ae49a15SRussell King ret = i2c_pxa_send_mastercode(i2c);
10761ae49a15SRussell King if (ret) {
10771ae49a15SRussell King dev_err(&i2c->adap.dev, "i2c_pxa_send_mastercode timeout\n");
10781ae49a15SRussell King goto out;
10791ae49a15SRussell King }
10801ae49a15SRussell King }
10811ae49a15SRussell King
10821ae49a15SRussell King spin_lock_irq(&i2c->lock);
10831ae49a15SRussell King
10841ae49a15SRussell King i2c->msg = msg;
10851ae49a15SRussell King i2c->msg_num = num;
10861ae49a15SRussell King i2c->msg_idx = 0;
10871ae49a15SRussell King i2c->msg_ptr = 0;
10881ae49a15SRussell King i2c->irqlogidx = 0;
10891ae49a15SRussell King
10901ae49a15SRussell King i2c_pxa_start_message(i2c);
10911ae49a15SRussell King
10921ae49a15SRussell King spin_unlock_irq(&i2c->lock);
10931ae49a15SRussell King
10941ae49a15SRussell King /*
10951ae49a15SRussell King * The rest of the processing occurs in the interrupt handler.
10961ae49a15SRussell King */
10971ae49a15SRussell King timeout = wait_event_timeout(i2c->wait, i2c->msg_num == 0, HZ * 5);
10981ae49a15SRussell King i2c_pxa_stop_message(i2c);
10991ae49a15SRussell King
11001ae49a15SRussell King /*
11011ae49a15SRussell King * We place the return code in i2c->msg_idx.
11021ae49a15SRussell King */
11031ae49a15SRussell King ret = i2c->msg_idx;
11041ae49a15SRussell King
11051ae49a15SRussell King if (!timeout && i2c->msg_num) {
1106ae1c3b73SRussell King i2c_pxa_scream_blue_murder(i2c, "timeout with active message");
11077c9ec2c5SRussell King i2c_recover_bus(&i2c->adap);
11081ae49a15SRussell King ret = I2C_RETRY;
11091ae49a15SRussell King }
11101ae49a15SRussell King
11111ae49a15SRussell King out:
11121ae49a15SRussell King return ret;
11131ae49a15SRussell King }
1114b652b438SRussell King
i2c_pxa_internal_xfer(struct pxa_i2c * i2c,struct i2c_msg * msgs,int num,int (* xfer)(struct pxa_i2c *,struct i2c_msg *,int num))11150f03c088SRussell King static int i2c_pxa_internal_xfer(struct pxa_i2c *i2c,
11160f03c088SRussell King struct i2c_msg *msgs, int num,
11170f03c088SRussell King int (*xfer)(struct pxa_i2c *,
11180f03c088SRussell King struct i2c_msg *, int num))
1119b652b438SRussell King {
1120b652b438SRussell King int ret, i;
1121b652b438SRussell King
1122c25e509aSRussell King for (i = 0; ; ) {
11230f03c088SRussell King ret = xfer(i2c, msgs, num);
1124c25e509aSRussell King if (ret != I2C_RETRY && ret != NO_SLAVE)
1125b652b438SRussell King goto out;
1126c25e509aSRussell King if (++i >= i2c->adap.retries)
1127c25e509aSRussell King break;
1128b652b438SRussell King
1129b652b438SRussell King if (i2c_debug)
11300f03c088SRussell King dev_dbg(&i2c->adap.dev, "Retrying transmission\n");
1131b652b438SRussell King udelay(100);
1132b652b438SRussell King }
1133c25e509aSRussell King if (ret != NO_SLAVE)
1134b652b438SRussell King i2c_pxa_scream_blue_murder(i2c, "exhausted retries");
1135b652b438SRussell King ret = -EREMOTEIO;
1136b652b438SRussell King out:
1137b652b438SRussell King i2c_pxa_set_slave(i2c, ret);
1138b652b438SRussell King return ret;
1139b652b438SRussell King }
1140b652b438SRussell King
i2c_pxa_xfer(struct i2c_adapter * adap,struct i2c_msg msgs[],int num)11410f03c088SRussell King static int i2c_pxa_xfer(struct i2c_adapter *adap,
11420f03c088SRussell King struct i2c_msg msgs[], int num)
11430f03c088SRussell King {
11440f03c088SRussell King struct pxa_i2c *i2c = adap->algo_data;
11450f03c088SRussell King
11460f03c088SRussell King return i2c_pxa_internal_xfer(i2c, msgs, num, i2c_pxa_do_xfer);
11470f03c088SRussell King }
11480f03c088SRussell King
i2c_pxa_functionality(struct i2c_adapter * adap)1149da16e324SRussell King static u32 i2c_pxa_functionality(struct i2c_adapter *adap)
1150da16e324SRussell King {
115186261fddSPetr Cvek return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL |
115286261fddSPetr Cvek I2C_FUNC_PROTOCOL_MANGLING | I2C_FUNC_NOSTART;
1153da16e324SRussell King }
1154da16e324SRussell King
11558f9082c5SJean Delvare static const struct i2c_algorithm i2c_pxa_algorithm = {
1156b652b438SRussell King .master_xfer = i2c_pxa_xfer,
1157da16e324SRussell King .functionality = i2c_pxa_functionality,
11584d51b4ceSPatrick Williams #ifdef CONFIG_I2C_PXA_SLAVE
11594d51b4ceSPatrick Williams .reg_slave = i2c_pxa_slave_reg,
11604d51b4ceSPatrick Williams .unreg_slave = i2c_pxa_slave_unreg,
11614d51b4ceSPatrick Williams #endif
1162b652b438SRussell King };
1163b652b438SRussell King
11641ae49a15SRussell King /* Non-interrupt mode support */
i2c_pxa_pio_set_master(struct pxa_i2c * i2c)11651ae49a15SRussell King static int i2c_pxa_pio_set_master(struct pxa_i2c *i2c)
11661ae49a15SRussell King {
11671ae49a15SRussell King /* make timeout the same as for interrupt based functions */
11681ae49a15SRussell King long timeout = 2 * DEF_TIMEOUT;
11691ae49a15SRussell King
11701ae49a15SRussell King /*
11711ae49a15SRussell King * Wait for the bus to become free.
11721ae49a15SRussell King */
117318d30c09SRussell King while (timeout-- && readl(_ISR(i2c)) & (ISR_IBB | ISR_UB))
11741ae49a15SRussell King udelay(1000);
11751ae49a15SRussell King
11761ae49a15SRussell King if (timeout < 0) {
11771ae49a15SRussell King show_state(i2c);
11781ae49a15SRussell King dev_err(&i2c->adap.dev,
1179ae1c3b73SRussell King "i2c_pxa: timeout waiting for bus free (set_master)\n");
11801ae49a15SRussell King return I2C_RETRY;
11811ae49a15SRussell King }
11821ae49a15SRussell King
11831ae49a15SRussell King /*
11841ae49a15SRussell King * Set master mode.
11851ae49a15SRussell King */
11861ae49a15SRussell King writel(readl(_ICR(i2c)) | ICR_SCLE, _ICR(i2c));
11871ae49a15SRussell King
11881ae49a15SRussell King return 0;
11891ae49a15SRussell King }
11901ae49a15SRussell King
i2c_pxa_do_pio_xfer(struct pxa_i2c * i2c,struct i2c_msg * msg,int num)11911ae49a15SRussell King static int i2c_pxa_do_pio_xfer(struct pxa_i2c *i2c,
11921ae49a15SRussell King struct i2c_msg *msg, int num)
11931ae49a15SRussell King {
11941ae49a15SRussell King unsigned long timeout = 500000; /* 5 seconds */
11951ae49a15SRussell King int ret = 0;
11961ae49a15SRussell King
11971ae49a15SRussell King ret = i2c_pxa_pio_set_master(i2c);
11981ae49a15SRussell King if (ret)
11991ae49a15SRussell King goto out;
12001ae49a15SRussell King
12011ae49a15SRussell King i2c->msg = msg;
12021ae49a15SRussell King i2c->msg_num = num;
12031ae49a15SRussell King i2c->msg_idx = 0;
12041ae49a15SRussell King i2c->msg_ptr = 0;
12051ae49a15SRussell King i2c->irqlogidx = 0;
12061ae49a15SRussell King
12071ae49a15SRussell King i2c_pxa_start_message(i2c);
12081ae49a15SRussell King
12091ae49a15SRussell King while (i2c->msg_num > 0 && --timeout) {
12101ae49a15SRussell King i2c_pxa_handler(0, i2c);
12111ae49a15SRussell King udelay(10);
12121ae49a15SRussell King }
12131ae49a15SRussell King
12141ae49a15SRussell King i2c_pxa_stop_message(i2c);
12151ae49a15SRussell King
12161ae49a15SRussell King /*
12171ae49a15SRussell King * We place the return code in i2c->msg_idx.
12181ae49a15SRussell King */
12191ae49a15SRussell King ret = i2c->msg_idx;
12201ae49a15SRussell King
12211ae49a15SRussell King out:
12221ae49a15SRussell King if (timeout == 0) {
1223ae1c3b73SRussell King i2c_pxa_scream_blue_murder(i2c, "timeout (do_pio_xfer)");
12241ae49a15SRussell King ret = I2C_RETRY;
12251ae49a15SRussell King }
12261ae49a15SRussell King
12271ae49a15SRussell King return ret;
12281ae49a15SRussell King }
12291ae49a15SRussell King
i2c_pxa_pio_xfer(struct i2c_adapter * adap,struct i2c_msg msgs[],int num)12301ae49a15SRussell King static int i2c_pxa_pio_xfer(struct i2c_adapter *adap,
12311ae49a15SRussell King struct i2c_msg msgs[], int num)
12321ae49a15SRussell King {
12331ae49a15SRussell King struct pxa_i2c *i2c = adap->algo_data;
12341ae49a15SRussell King
12351ae49a15SRussell King /* If the I2C controller is disabled we need to reset it
12361ae49a15SRussell King (probably due to a suspend/resume destroying state). We do
12371ae49a15SRussell King this here as we can then avoid worrying about resuming the
12381ae49a15SRussell King controller before its users. */
12391ae49a15SRussell King if (!(readl(_ICR(i2c)) & ICR_IUE))
12401ae49a15SRussell King i2c_pxa_reset(i2c);
12411ae49a15SRussell King
12420f03c088SRussell King return i2c_pxa_internal_xfer(i2c, msgs, num, i2c_pxa_do_pio_xfer);
12431ae49a15SRussell King }
12441ae49a15SRussell King
1245b7a36701SMike Rapoport static const struct i2c_algorithm i2c_pxa_pio_algorithm = {
1246b7a36701SMike Rapoport .master_xfer = i2c_pxa_pio_xfer,
1247b7a36701SMike Rapoport .functionality = i2c_pxa_functionality,
12484d51b4ceSPatrick Williams #ifdef CONFIG_I2C_PXA_SLAVE
12494d51b4ceSPatrick Williams .reg_slave = i2c_pxa_slave_reg,
12504d51b4ceSPatrick Williams .unreg_slave = i2c_pxa_slave_unreg,
12514d51b4ceSPatrick Williams #endif
1252b7a36701SMike Rapoport };
1253b7a36701SMike Rapoport
i2c_pxa_probe_dt(struct platform_device * pdev,struct pxa_i2c * i2c,enum pxa_i2c_types * i2c_types)125463fe122bSHaojian Zhuang static int i2c_pxa_probe_dt(struct platform_device *pdev, struct pxa_i2c *i2c,
125563fe122bSHaojian Zhuang enum pxa_i2c_types *i2c_types)
125663fe122bSHaojian Zhuang {
125763fe122bSHaojian Zhuang struct device_node *np = pdev->dev.of_node;
125863fe122bSHaojian Zhuang const struct of_device_id *of_id =
125963fe122bSHaojian Zhuang of_match_device(i2c_pxa_dt_ids, &pdev->dev);
126063fe122bSHaojian Zhuang
126163fe122bSHaojian Zhuang if (!of_id)
126263fe122bSHaojian Zhuang return 1;
1263fe69c555SDoug Anderson
1264fe69c555SDoug Anderson /* For device tree we always use the dynamic or alias-assigned ID */
1265fe69c555SDoug Anderson i2c->adap.nr = -1;
1266fe69c555SDoug Anderson
126789151f6bSRob Herring i2c->use_pio = of_property_read_bool(np, "mrvl,i2c-polling");
126889151f6bSRob Herring i2c->fast_mode = of_property_read_bool(np, "mrvl,i2c-fast-mode");
1269e2b498fdSYipeng Yao
1270e2b498fdSYipeng Yao *i2c_types = (enum pxa_i2c_types)(of_id->data);
1271e2b498fdSYipeng Yao
127263fe122bSHaojian Zhuang return 0;
127363fe122bSHaojian Zhuang }
127463fe122bSHaojian Zhuang
i2c_pxa_probe_pdata(struct platform_device * pdev,struct pxa_i2c * i2c,enum pxa_i2c_types * i2c_types)127563fe122bSHaojian Zhuang static int i2c_pxa_probe_pdata(struct platform_device *pdev,
127663fe122bSHaojian Zhuang struct pxa_i2c *i2c,
127763fe122bSHaojian Zhuang enum pxa_i2c_types *i2c_types)
127863fe122bSHaojian Zhuang {
12796d4028c6SJingoo Han struct i2c_pxa_platform_data *plat = dev_get_platdata(&pdev->dev);
128063fe122bSHaojian Zhuang const struct platform_device_id *id = platform_get_device_id(pdev);
128163fe122bSHaojian Zhuang
128263fe122bSHaojian Zhuang *i2c_types = id->driver_data;
128363fe122bSHaojian Zhuang if (plat) {
128463fe122bSHaojian Zhuang i2c->use_pio = plat->use_pio;
128563fe122bSHaojian Zhuang i2c->fast_mode = plat->fast_mode;
12869d3dda5cSLeilei Shang i2c->high_mode = plat->high_mode;
12879d3dda5cSLeilei Shang i2c->master_code = plat->master_code;
12889d3dda5cSLeilei Shang if (!i2c->master_code)
12899d3dda5cSLeilei Shang i2c->master_code = 0xe;
12909d3dda5cSLeilei Shang i2c->rate = plat->rate;
129163fe122bSHaojian Zhuang }
129263fe122bSHaojian Zhuang return 0;
129363fe122bSHaojian Zhuang }
129463fe122bSHaojian Zhuang
i2c_pxa_prepare_recovery(struct i2c_adapter * adap)12957c9ec2c5SRussell King static void i2c_pxa_prepare_recovery(struct i2c_adapter *adap)
12967c9ec2c5SRussell King {
12977c9ec2c5SRussell King struct pxa_i2c *i2c = adap->algo_data;
12987c9ec2c5SRussell King u32 ibmr = readl(_IBMR(i2c));
12997c9ec2c5SRussell King
13007c9ec2c5SRussell King /*
13017c9ec2c5SRussell King * Program the GPIOs to reflect the current I2C bus state while
13027c9ec2c5SRussell King * we transition to recovery; this avoids glitching the bus.
13037c9ec2c5SRussell King */
13047c9ec2c5SRussell King gpiod_set_value(i2c->recovery.scl_gpiod, ibmr & IBMR_SCLS);
13057c9ec2c5SRussell King gpiod_set_value(i2c->recovery.sda_gpiod, ibmr & IBMR_SDAS);
1306*ff4d0309SRobert Marko
1307*ff4d0309SRobert Marko WARN_ON(pinctrl_select_state(i2c->pinctrl, i2c->pinctrl_recovery));
13087c9ec2c5SRussell King }
13097c9ec2c5SRussell King
i2c_pxa_unprepare_recovery(struct i2c_adapter * adap)13107c9ec2c5SRussell King static void i2c_pxa_unprepare_recovery(struct i2c_adapter *adap)
13117c9ec2c5SRussell King {
13127c9ec2c5SRussell King struct pxa_i2c *i2c = adap->algo_data;
13137c9ec2c5SRussell King u32 isr;
13147c9ec2c5SRussell King
13157c9ec2c5SRussell King /*
13167c9ec2c5SRussell King * The bus should now be free. Clear up the I2C controller before
13177c9ec2c5SRussell King * handing control of the bus back to avoid the bus changing state.
13187c9ec2c5SRussell King */
13197c9ec2c5SRussell King isr = readl(_ISR(i2c));
13207c9ec2c5SRussell King if (isr & (ISR_UB | ISR_IBB)) {
13217c9ec2c5SRussell King dev_dbg(&i2c->adap.dev,
13227c9ec2c5SRussell King "recovery: resetting controller, ISR=0x%08x\n", isr);
13237c9ec2c5SRussell King i2c_pxa_do_reset(i2c);
13247c9ec2c5SRussell King }
13257c9ec2c5SRussell King
1326*ff4d0309SRobert Marko WARN_ON(pinctrl_select_state(i2c->pinctrl, i2c->pinctrl_default));
13277c9ec2c5SRussell King
13287c9ec2c5SRussell King dev_dbg(&i2c->adap.dev, "recovery: IBMR 0x%08x ISR 0x%08x\n",
13297c9ec2c5SRussell King readl(_IBMR(i2c)), readl(_ISR(i2c)));
13307c9ec2c5SRussell King
13317c9ec2c5SRussell King i2c_pxa_enable(i2c);
13327c9ec2c5SRussell King }
13337c9ec2c5SRussell King
i2c_pxa_init_recovery(struct pxa_i2c * i2c)13347c9ec2c5SRussell King static int i2c_pxa_init_recovery(struct pxa_i2c *i2c)
13357c9ec2c5SRussell King {
13367c9ec2c5SRussell King struct i2c_bus_recovery_info *bri = &i2c->recovery;
13377c9ec2c5SRussell King struct device *dev = i2c->adap.dev.parent;
13387c9ec2c5SRussell King
13397c9ec2c5SRussell King /*
13407c9ec2c5SRussell King * When slave mode is enabled, we are not the only master on the bus.
13417c9ec2c5SRussell King * Bus recovery can only be performed when we are the master, which
13427c9ec2c5SRussell King * we can't be certain of. Therefore, when slave mode is enabled, do
13437c9ec2c5SRussell King * not configure bus recovery.
13447c9ec2c5SRussell King */
13457c9ec2c5SRussell King if (IS_ENABLED(CONFIG_I2C_PXA_SLAVE))
13467c9ec2c5SRussell King return 0;
13477c9ec2c5SRussell King
1348*ff4d0309SRobert Marko i2c->pinctrl = devm_pinctrl_get(dev);
1349*ff4d0309SRobert Marko if (PTR_ERR(i2c->pinctrl) == -ENODEV)
1350*ff4d0309SRobert Marko i2c->pinctrl = NULL;
1351*ff4d0309SRobert Marko if (IS_ERR(i2c->pinctrl))
1352*ff4d0309SRobert Marko return PTR_ERR(i2c->pinctrl);
1353*ff4d0309SRobert Marko
1354*ff4d0309SRobert Marko if (!i2c->pinctrl)
1355*ff4d0309SRobert Marko return 0;
1356*ff4d0309SRobert Marko
1357*ff4d0309SRobert Marko i2c->pinctrl_default = pinctrl_lookup_state(i2c->pinctrl,
1358*ff4d0309SRobert Marko PINCTRL_STATE_DEFAULT);
1359*ff4d0309SRobert Marko i2c->pinctrl_recovery = pinctrl_lookup_state(i2c->pinctrl, "recovery");
1360*ff4d0309SRobert Marko
1361*ff4d0309SRobert Marko if (IS_ERR(i2c->pinctrl_default) || IS_ERR(i2c->pinctrl_recovery)) {
1362*ff4d0309SRobert Marko dev_info(dev, "missing pinmux recovery information: %ld %ld\n",
1363*ff4d0309SRobert Marko PTR_ERR(i2c->pinctrl_default),
1364*ff4d0309SRobert Marko PTR_ERR(i2c->pinctrl_recovery));
13657c9ec2c5SRussell King return 0;
13667c9ec2c5SRussell King }
1367*ff4d0309SRobert Marko
1368*ff4d0309SRobert Marko /*
1369*ff4d0309SRobert Marko * Claiming GPIOs can influence the pinmux state, and may glitch the
1370*ff4d0309SRobert Marko * I2C bus. Do this carefully.
1371*ff4d0309SRobert Marko */
1372*ff4d0309SRobert Marko bri->scl_gpiod = devm_gpiod_get(dev, "scl", GPIOD_OUT_HIGH_OPEN_DRAIN);
1373*ff4d0309SRobert Marko if (bri->scl_gpiod == ERR_PTR(-EPROBE_DEFER))
1374*ff4d0309SRobert Marko return -EPROBE_DEFER;
1375*ff4d0309SRobert Marko if (IS_ERR(bri->scl_gpiod)) {
1376*ff4d0309SRobert Marko dev_info(dev, "missing scl gpio recovery information: %pe\n",
1377*ff4d0309SRobert Marko bri->scl_gpiod);
1378*ff4d0309SRobert Marko return 0;
1379*ff4d0309SRobert Marko }
1380*ff4d0309SRobert Marko
1381*ff4d0309SRobert Marko /*
1382*ff4d0309SRobert Marko * We have SCL. Pull SCL low and wait a bit so that SDA glitches
1383*ff4d0309SRobert Marko * have no effect.
1384*ff4d0309SRobert Marko */
1385*ff4d0309SRobert Marko gpiod_direction_output(bri->scl_gpiod, 0);
1386*ff4d0309SRobert Marko udelay(10);
1387*ff4d0309SRobert Marko bri->sda_gpiod = devm_gpiod_get(dev, "sda", GPIOD_OUT_HIGH_OPEN_DRAIN);
1388*ff4d0309SRobert Marko
1389*ff4d0309SRobert Marko /* Wait a bit in case of a SDA glitch, and then release SCL. */
1390*ff4d0309SRobert Marko udelay(10);
1391*ff4d0309SRobert Marko gpiod_direction_output(bri->scl_gpiod, 1);
1392*ff4d0309SRobert Marko
1393*ff4d0309SRobert Marko if (bri->sda_gpiod == ERR_PTR(-EPROBE_DEFER))
1394*ff4d0309SRobert Marko return -EPROBE_DEFER;
1395*ff4d0309SRobert Marko
1396*ff4d0309SRobert Marko if (IS_ERR(bri->sda_gpiod)) {
1397*ff4d0309SRobert Marko dev_info(dev, "missing sda gpio recovery information: %pe\n",
1398*ff4d0309SRobert Marko bri->sda_gpiod);
1399*ff4d0309SRobert Marko return 0;
1400*ff4d0309SRobert Marko }
14017c9ec2c5SRussell King
14027c9ec2c5SRussell King bri->prepare_recovery = i2c_pxa_prepare_recovery;
14037c9ec2c5SRussell King bri->unprepare_recovery = i2c_pxa_unprepare_recovery;
1404*ff4d0309SRobert Marko bri->recover_bus = i2c_generic_scl_recovery;
14057c9ec2c5SRussell King
14067c9ec2c5SRussell King i2c->adap.bus_recovery_info = bri;
14077c9ec2c5SRussell King
1408*ff4d0309SRobert Marko /*
1409*ff4d0309SRobert Marko * Claiming GPIOs can change the pinmux state, which confuses the
1410*ff4d0309SRobert Marko * pinctrl since pinctrl's idea of the current setting is unaffected
1411*ff4d0309SRobert Marko * by the pinmux change caused by claiming the GPIO. Work around that
1412*ff4d0309SRobert Marko * by switching pinctrl to the GPIO state here. We do it this way to
1413*ff4d0309SRobert Marko * avoid glitching the I2C bus.
1414*ff4d0309SRobert Marko */
1415*ff4d0309SRobert Marko pinctrl_select_state(i2c->pinctrl, i2c->pinctrl_recovery);
1416*ff4d0309SRobert Marko
1417*ff4d0309SRobert Marko return pinctrl_select_state(i2c->pinctrl, i2c->pinctrl_default);
14187c9ec2c5SRussell King }
14197c9ec2c5SRussell King
i2c_pxa_probe(struct platform_device * dev)14203ae5eaecSRussell King static int i2c_pxa_probe(struct platform_device *dev)
1421b652b438SRussell King {
14226d4028c6SJingoo Han struct i2c_pxa_platform_data *plat = dev_get_platdata(&dev->dev);
142363fe122bSHaojian Zhuang enum pxa_i2c_types i2c_type;
142463fe122bSHaojian Zhuang struct pxa_i2c *i2c;
1425733f41f7SYangtao Li struct resource *res;
142663fe122bSHaojian Zhuang int ret, irq;
1427a7b4e550SGuennadi Liakhovetski
142851fcce86SVaibhav Hiremath i2c = devm_kzalloc(&dev->dev, sizeof(struct pxa_i2c), GFP_KERNEL);
142951fcce86SVaibhav Hiremath if (!i2c)
143051fcce86SVaibhav Hiremath return -ENOMEM;
143151fcce86SVaibhav Hiremath
14327c9ec2c5SRussell King /* Default adapter num to device id; i2c_pxa_probe_dt can override. */
14337c9ec2c5SRussell King i2c->adap.nr = dev->id;
14347c9ec2c5SRussell King i2c->adap.owner = THIS_MODULE;
14357c9ec2c5SRussell King i2c->adap.retries = 5;
14367c9ec2c5SRussell King i2c->adap.algo_data = i2c;
14377c9ec2c5SRussell King i2c->adap.dev.parent = &dev->dev;
14387c9ec2c5SRussell King #ifdef CONFIG_OF
14397c9ec2c5SRussell King i2c->adap.dev.of_node = dev->dev.of_node;
14407c9ec2c5SRussell King #endif
14417c9ec2c5SRussell King
1442733f41f7SYangtao Li i2c->reg_base = devm_platform_get_and_ioremap_resource(dev, 0, &res);
144351fcce86SVaibhav Hiremath if (IS_ERR(i2c->reg_base))
144451fcce86SVaibhav Hiremath return PTR_ERR(i2c->reg_base);
144551fcce86SVaibhav Hiremath
144651fcce86SVaibhav Hiremath irq = platform_get_irq(dev, 0);
1447e42688edSDejin Zheng if (irq < 0)
144851fcce86SVaibhav Hiremath return irq;
1449a7b4e550SGuennadi Liakhovetski
14507c9ec2c5SRussell King ret = i2c_pxa_init_recovery(i2c);
14517c9ec2c5SRussell King if (ret)
14527c9ec2c5SRussell King return ret;
1453fe69c555SDoug Anderson
145463fe122bSHaojian Zhuang ret = i2c_pxa_probe_dt(dev, i2c, &i2c_type);
145563fe122bSHaojian Zhuang if (ret > 0)
145663fe122bSHaojian Zhuang ret = i2c_pxa_probe_pdata(dev, i2c, &i2c_type);
145763fe122bSHaojian Zhuang if (ret < 0)
145851fcce86SVaibhav Hiremath return ret;
145963fe122bSHaojian Zhuang
14606776f3d2SEnrico Scholz spin_lock_init(&i2c->lock);
1461a7b4e550SGuennadi Liakhovetski init_waitqueue_head(&i2c->wait);
14626776f3d2SEnrico Scholz
1463ea1558ceSWolfram Sang strscpy(i2c->adap.name, "pxa_i2c-i2c", sizeof(i2c->adap.name));
1464a7b4e550SGuennadi Liakhovetski
146551fcce86SVaibhav Hiremath i2c->clk = devm_clk_get(&dev->dev, NULL);
1466d2906660SLiao Chang if (IS_ERR(i2c->clk))
1467d2906660SLiao Chang return dev_err_probe(&dev->dev, PTR_ERR(i2c->clk),
1468d2906660SLiao Chang "failed to get the clk\n");
1469d6668c7cSSebastian Andrzej Siewior
1470d6668c7cSSebastian Andrzej Siewior i2c->reg_ibmr = i2c->reg_base + pxa_reg_layout[i2c_type].ibmr;
1471d6668c7cSSebastian Andrzej Siewior i2c->reg_idbr = i2c->reg_base + pxa_reg_layout[i2c_type].idbr;
1472d6668c7cSSebastian Andrzej Siewior i2c->reg_icr = i2c->reg_base + pxa_reg_layout[i2c_type].icr;
1473d6668c7cSSebastian Andrzej Siewior i2c->reg_isr = i2c->reg_base + pxa_reg_layout[i2c_type].isr;
1474ee478936SRussell King i2c->fm_mask = pxa_reg_layout[i2c_type].fm;
1475ee478936SRussell King i2c->hs_mask = pxa_reg_layout[i2c_type].hs;
14766c14bdacSRomain Perier
14777e94dd15SSebastian Andrzej Siewior if (i2c_type != REGS_CE4100)
1478d6668c7cSSebastian Andrzej Siewior i2c->reg_isar = i2c->reg_base + pxa_reg_layout[i2c_type].isar;
1479a7b4e550SGuennadi Liakhovetski
1480c5fa6fc7SVaibhav Hiremath if (i2c_type == REGS_PXA910) {
1481c5fa6fc7SVaibhav Hiremath i2c->reg_ilcr = i2c->reg_base + pxa_reg_layout[i2c_type].ilcr;
1482c5fa6fc7SVaibhav Hiremath i2c->reg_iwcr = i2c->reg_base + pxa_reg_layout[i2c_type].iwcr;
1483c5fa6fc7SVaibhav Hiremath }
1484c5fa6fc7SVaibhav Hiremath
1485a7b4e550SGuennadi Liakhovetski i2c->iobase = res->start;
1486c6ffddeaSLinus Walleij i2c->iosize = resource_size(res);
1487a7b4e550SGuennadi Liakhovetski
1488a7b4e550SGuennadi Liakhovetski i2c->irq = irq;
1489b652b438SRussell King
1490b652b438SRussell King i2c->slave_addr = I2C_PXA_SLAVE_ADDR;
14919d3dda5cSLeilei Shang i2c->highmode_enter = false;
1492b652b438SRussell King
1493b652b438SRussell King if (plat) {
149463fe122bSHaojian Zhuang i2c->adap.class = plat->class;
149563fe122bSHaojian Zhuang }
1496b652b438SRussell King
14979d3dda5cSLeilei Shang if (i2c->high_mode) {
14989d3dda5cSLeilei Shang if (i2c->rate) {
14999d3dda5cSLeilei Shang clk_set_rate(i2c->clk, i2c->rate);
15009d3dda5cSLeilei Shang pr_info("i2c: <%s> set rate to %ld\n",
15019d3dda5cSLeilei Shang i2c->adap.name, clk_get_rate(i2c->clk));
15029d3dda5cSLeilei Shang } else
15039d3dda5cSLeilei Shang pr_warn("i2c: <%s> clock rate not set\n",
15049d3dda5cSLeilei Shang i2c->adap.name);
15059d3dda5cSLeilei Shang }
15069d3dda5cSLeilei Shang
15077a10f473SDaniel Drake clk_prepare_enable(i2c->clk);
1508a7b4e550SGuennadi Liakhovetski
1509b7a36701SMike Rapoport if (i2c->use_pio) {
1510b7a36701SMike Rapoport i2c->adap.algo = &i2c_pxa_pio_algorithm;
1511b7a36701SMike Rapoport } else {
1512b7a36701SMike Rapoport i2c->adap.algo = &i2c_pxa_algorithm;
151351fcce86SVaibhav Hiremath ret = devm_request_irq(&dev->dev, irq, i2c_pxa_handler,
1514abf8a1fbSLeilei Shang IRQF_SHARED | IRQF_NO_SUSPEND,
1515fe69c555SDoug Anderson dev_name(&dev->dev), i2c);
151651fcce86SVaibhav Hiremath if (ret) {
151751fcce86SVaibhav Hiremath dev_err(&dev->dev, "failed to request irq: %d\n", ret);
1518a7b4e550SGuennadi Liakhovetski goto ereqirq;
1519b7a36701SMike Rapoport }
152051fcce86SVaibhav Hiremath }
1521a7b4e550SGuennadi Liakhovetski
1522b652b438SRussell King i2c_pxa_reset(i2c);
1523b652b438SRussell King
1524066af983SRodolfo Giometti ret = i2c_add_numbered_adapter(&i2c->adap);
1525ea734404SWolfram Sang if (ret < 0)
152651fcce86SVaibhav Hiremath goto ereqirq;
1527b652b438SRussell King
15283ae5eaecSRussell King platform_set_drvdata(dev, i2c);
1529b652b438SRussell King
1530b652b438SRussell King #ifdef CONFIG_I2C_PXA_SLAVE
153151fcce86SVaibhav Hiremath dev_info(&i2c->adap.dev, " PXA I2C adapter, slave address %d\n",
153251fcce86SVaibhav Hiremath i2c->slave_addr);
1533b652b438SRussell King #else
153451fcce86SVaibhav Hiremath dev_info(&i2c->adap.dev, " PXA I2C adapter\n");
1535b652b438SRussell King #endif
1536b652b438SRussell King return 0;
1537b652b438SRussell King
1538a7b4e550SGuennadi Liakhovetski ereqirq:
15397a10f473SDaniel Drake clk_disable_unprepare(i2c->clk);
1540b652b438SRussell King return ret;
1541b652b438SRussell King }
1542b652b438SRussell King
i2c_pxa_remove(struct platform_device * dev)1543e190a0c3SUwe Kleine-König static void i2c_pxa_remove(struct platform_device *dev)
1544b652b438SRussell King {
15453ae5eaecSRussell King struct pxa_i2c *i2c = platform_get_drvdata(dev);
1546b652b438SRussell King
1547b652b438SRussell King i2c_del_adapter(&i2c->adap);
1548c3cef3f3SRussell King
15497a10f473SDaniel Drake clk_disable_unprepare(i2c->clk);
1550b652b438SRussell King }
1551b652b438SRussell King
i2c_pxa_suspend_noirq(struct device * dev)155257f4d4f1SMagnus Damm static int i2c_pxa_suspend_noirq(struct device *dev)
1553e7d48fa2SRussell King {
15549242e72aSMasahiro Yamada struct pxa_i2c *i2c = dev_get_drvdata(dev);
155557f4d4f1SMagnus Damm
1556e7d48fa2SRussell King clk_disable(i2c->clk);
155757f4d4f1SMagnus Damm
1558e7d48fa2SRussell King return 0;
1559e7d48fa2SRussell King }
1560e7d48fa2SRussell King
i2c_pxa_resume_noirq(struct device * dev)156157f4d4f1SMagnus Damm static int i2c_pxa_resume_noirq(struct device *dev)
1562e7d48fa2SRussell King {
15639242e72aSMasahiro Yamada struct pxa_i2c *i2c = dev_get_drvdata(dev);
1564e7d48fa2SRussell King
1565e7d48fa2SRussell King clk_enable(i2c->clk);
1566e7d48fa2SRussell King i2c_pxa_reset(i2c);
1567e7d48fa2SRussell King
1568e7d48fa2SRussell King return 0;
1569e7d48fa2SRussell King }
157057f4d4f1SMagnus Damm
157147145210SAlexey Dobriyan static const struct dev_pm_ops i2c_pxa_dev_pm_ops = {
157257f4d4f1SMagnus Damm .suspend_noirq = i2c_pxa_suspend_noirq,
157357f4d4f1SMagnus Damm .resume_noirq = i2c_pxa_resume_noirq,
157457f4d4f1SMagnus Damm };
157557f4d4f1SMagnus Damm
15763ae5eaecSRussell King static struct platform_driver i2c_pxa_driver = {
1577b652b438SRussell King .probe = i2c_pxa_probe,
1578e190a0c3SUwe Kleine-König .remove_new = i2c_pxa_remove,
15793ae5eaecSRussell King .driver = {
15803ae5eaecSRussell King .name = "pxa2xx-i2c",
15811ea4e6b5SPaul Cercueil .pm = pm_sleep_ptr(&i2c_pxa_dev_pm_ops),
158263fe122bSHaojian Zhuang .of_match_table = i2c_pxa_dt_ids,
15833ae5eaecSRussell King },
1584f23d4911SEric Miao .id_table = i2c_pxa_id_table,
1585b652b438SRussell King };
1586b652b438SRussell King
i2c_adap_pxa_init(void)1587b652b438SRussell King static int __init i2c_adap_pxa_init(void)
1588b652b438SRussell King {
15893ae5eaecSRussell King return platform_driver_register(&i2c_pxa_driver);
1590b652b438SRussell King }
1591b652b438SRussell King
i2c_adap_pxa_exit(void)1592a92b36edSWolfram Sang static void __exit i2c_adap_pxa_exit(void)
1593b652b438SRussell King {
1594d6a7b5f8SHolger Schurig platform_driver_unregister(&i2c_pxa_driver);
1595b652b438SRussell King }
1596b652b438SRussell King
1597ece5f7b3SRichard Purdie MODULE_LICENSE("GPL");
1598ece5f7b3SRichard Purdie
159947a9b137SUli Luckas subsys_initcall(i2c_adap_pxa_init);
1600b652b438SRussell King module_exit(i2c_adap_pxa_exit);
1601