1cdace066SSascha Hauer /* 2db84140bSMarek Vasut * i2c driver for Freescale i.MX series 3cdace066SSascha Hauer * 4cdace066SSascha Hauer * (c) 2007 Pengutronix, Sascha Hauer <s.hauer@pengutronix.de> 5db84140bSMarek Vasut * (c) 2011 Marek Vasut <marek.vasut@gmail.com> 6db84140bSMarek Vasut * 7db84140bSMarek Vasut * Based on i2c-imx.c from linux kernel: 8db84140bSMarek Vasut * Copyright (C) 2005 Torsten Koschorrek <koschorrek at synertronixx.de> 9db84140bSMarek Vasut * Copyright (C) 2005 Matthias Blaschke <blaschke at synertronixx.de> 10db84140bSMarek Vasut * Copyright (C) 2007 RightHand Technologies, Inc. 11db84140bSMarek Vasut * Copyright (C) 2008 Darius Augulis <darius.augulis at teltonika.lt> 12db84140bSMarek Vasut * 13cdace066SSascha Hauer * 141a459660SWolfgang Denk * SPDX-License-Identifier: GPL-2.0+ 15cdace066SSascha Hauer */ 16cdace066SSascha Hauer 17cdace066SSascha Hauer #include <common.h> 18127cec18SLiu Hui-R64343 #include <asm/arch/clock.h> 1986271115SStefano Babic #include <asm/arch/imx-regs.h> 20cea60b0cSTroy Kisky #include <asm/errno.h> 2171204e95SPeng Fan #include <asm/imx-common/mxc_i2c.h> 2224cd738bSTroy Kisky #include <asm/io.h> 23bf0783dfSMarek Vasut #include <i2c.h> 247aa57a01STroy Kisky #include <watchdog.h> 2571204e95SPeng Fan #include <dm.h> 2671204e95SPeng Fan #include <fdtdec.h> 27cdace066SSascha Hauer 28dec1861bSYork Sun DECLARE_GLOBAL_DATA_PTR; 29dec1861bSYork Sun 3071204e95SPeng Fan #define I2C_QUIRK_FLAG (1 << 0) 3171204e95SPeng Fan 3271204e95SPeng Fan #define IMX_I2C_REGSHIFT 2 3371204e95SPeng Fan #define VF610_I2C_REGSHIFT 0 3471204e95SPeng Fan /* Register index */ 3571204e95SPeng Fan #define IADR 0 3671204e95SPeng Fan #define IFDR 1 3771204e95SPeng Fan #define I2CR 2 3871204e95SPeng Fan #define I2SR 3 3971204e95SPeng Fan #define I2DR 4 40cdace066SSascha Hauer 41cdace066SSascha Hauer #define I2CR_IIEN (1 << 6) 42cdace066SSascha Hauer #define I2CR_MSTA (1 << 5) 43cdace066SSascha Hauer #define I2CR_MTX (1 << 4) 44cdace066SSascha Hauer #define I2CR_TX_NO_AK (1 << 3) 45cdace066SSascha Hauer #define I2CR_RSTA (1 << 2) 46cdace066SSascha Hauer 47cdace066SSascha Hauer #define I2SR_ICF (1 << 7) 48cdace066SSascha Hauer #define I2SR_IBB (1 << 5) 49d5383a63STroy Kisky #define I2SR_IAL (1 << 4) 50cdace066SSascha Hauer #define I2SR_IIF (1 << 1) 51cdace066SSascha Hauer #define I2SR_RX_NO_AK (1 << 0) 52cdace066SSascha Hauer 5330ea41a4SAlison Wang #ifdef I2C_QUIRK_REG 5430ea41a4SAlison Wang #define I2CR_IEN (0 << 7) 5530ea41a4SAlison Wang #define I2CR_IDIS (1 << 7) 5630ea41a4SAlison Wang #define I2SR_IIF_CLEAR (1 << 1) 5730ea41a4SAlison Wang #else 5830ea41a4SAlison Wang #define I2CR_IEN (1 << 7) 5930ea41a4SAlison Wang #define I2CR_IDIS (0 << 7) 6030ea41a4SAlison Wang #define I2SR_IIF_CLEAR (0 << 1) 6130ea41a4SAlison Wang #endif 6230ea41a4SAlison Wang 63e4ff525fSTroy Kisky #if defined(CONFIG_HARD_I2C) && !defined(CONFIG_SYS_I2C_BASE) 64de6f604dSTroy Kisky #error "define CONFIG_SYS_I2C_BASE to use the mxc_i2c driver" 65cdace066SSascha Hauer #endif 66cdace066SSascha Hauer 6730ea41a4SAlison Wang #ifdef I2C_QUIRK_REG 6830ea41a4SAlison Wang static u16 i2c_clk_div[60][2] = { 6930ea41a4SAlison Wang { 20, 0x00 }, { 22, 0x01 }, { 24, 0x02 }, { 26, 0x03 }, 7030ea41a4SAlison Wang { 28, 0x04 }, { 30, 0x05 }, { 32, 0x09 }, { 34, 0x06 }, 7130ea41a4SAlison Wang { 36, 0x0A }, { 40, 0x07 }, { 44, 0x0C }, { 48, 0x0D }, 7230ea41a4SAlison Wang { 52, 0x43 }, { 56, 0x0E }, { 60, 0x45 }, { 64, 0x12 }, 7330ea41a4SAlison Wang { 68, 0x0F }, { 72, 0x13 }, { 80, 0x14 }, { 88, 0x15 }, 7430ea41a4SAlison Wang { 96, 0x19 }, { 104, 0x16 }, { 112, 0x1A }, { 128, 0x17 }, 7530ea41a4SAlison Wang { 136, 0x4F }, { 144, 0x1C }, { 160, 0x1D }, { 176, 0x55 }, 7630ea41a4SAlison Wang { 192, 0x1E }, { 208, 0x56 }, { 224, 0x22 }, { 228, 0x24 }, 7730ea41a4SAlison Wang { 240, 0x1F }, { 256, 0x23 }, { 288, 0x5C }, { 320, 0x25 }, 7830ea41a4SAlison Wang { 384, 0x26 }, { 448, 0x2A }, { 480, 0x27 }, { 512, 0x2B }, 7930ea41a4SAlison Wang { 576, 0x2C }, { 640, 0x2D }, { 768, 0x31 }, { 896, 0x32 }, 8030ea41a4SAlison Wang { 960, 0x2F }, { 1024, 0x33 }, { 1152, 0x34 }, { 1280, 0x35 }, 8130ea41a4SAlison Wang { 1536, 0x36 }, { 1792, 0x3A }, { 1920, 0x37 }, { 2048, 0x3B }, 8230ea41a4SAlison Wang { 2304, 0x3C }, { 2560, 0x3D }, { 3072, 0x3E }, { 3584, 0x7A }, 8330ea41a4SAlison Wang { 3840, 0x3F }, { 4096, 0x7B }, { 5120, 0x7D }, { 6144, 0x7E }, 8430ea41a4SAlison Wang }; 8530ea41a4SAlison Wang #else 86db84140bSMarek Vasut static u16 i2c_clk_div[50][2] = { 87db84140bSMarek Vasut { 22, 0x20 }, { 24, 0x21 }, { 26, 0x22 }, { 28, 0x23 }, 88db84140bSMarek Vasut { 30, 0x00 }, { 32, 0x24 }, { 36, 0x25 }, { 40, 0x26 }, 89db84140bSMarek Vasut { 42, 0x03 }, { 44, 0x27 }, { 48, 0x28 }, { 52, 0x05 }, 90db84140bSMarek Vasut { 56, 0x29 }, { 60, 0x06 }, { 64, 0x2A }, { 72, 0x2B }, 91db84140bSMarek Vasut { 80, 0x2C }, { 88, 0x09 }, { 96, 0x2D }, { 104, 0x0A }, 92db84140bSMarek Vasut { 112, 0x2E }, { 128, 0x2F }, { 144, 0x0C }, { 160, 0x30 }, 93db84140bSMarek Vasut { 192, 0x31 }, { 224, 0x32 }, { 240, 0x0F }, { 256, 0x33 }, 94db84140bSMarek Vasut { 288, 0x10 }, { 320, 0x34 }, { 384, 0x35 }, { 448, 0x36 }, 95db84140bSMarek Vasut { 480, 0x13 }, { 512, 0x37 }, { 576, 0x14 }, { 640, 0x38 }, 96db84140bSMarek Vasut { 768, 0x39 }, { 896, 0x3A }, { 960, 0x17 }, { 1024, 0x3B }, 97db84140bSMarek Vasut { 1152, 0x18 }, { 1280, 0x3C }, { 1536, 0x3D }, { 1792, 0x3E }, 98db84140bSMarek Vasut { 1920, 0x1B }, { 2048, 0x3F }, { 2304, 0x1C }, { 2560, 0x1D }, 99db84140bSMarek Vasut { 3072, 0x1E }, { 3840, 0x1F } 100db84140bSMarek Vasut }; 10130ea41a4SAlison Wang #endif 102cdace066SSascha Hauer 103fac96408Strem #ifndef CONFIG_SYS_MXC_I2C1_SPEED 104fac96408Strem #define CONFIG_SYS_MXC_I2C1_SPEED 100000 105fac96408Strem #endif 106fac96408Strem #ifndef CONFIG_SYS_MXC_I2C2_SPEED 107fac96408Strem #define CONFIG_SYS_MXC_I2C2_SPEED 100000 108fac96408Strem #endif 109fac96408Strem #ifndef CONFIG_SYS_MXC_I2C3_SPEED 110fac96408Strem #define CONFIG_SYS_MXC_I2C3_SPEED 100000 111fac96408Strem #endif 112f8cb101eSYork Sun #ifndef CONFIG_SYS_MXC_I2C4_SPEED 113f8cb101eSYork Sun #define CONFIG_SYS_MXC_I2C4_SPEED 100000 114f8cb101eSYork Sun #endif 115fac96408Strem 116fac96408Strem #ifndef CONFIG_SYS_MXC_I2C1_SLAVE 117fac96408Strem #define CONFIG_SYS_MXC_I2C1_SLAVE 0 118fac96408Strem #endif 119fac96408Strem #ifndef CONFIG_SYS_MXC_I2C2_SLAVE 120fac96408Strem #define CONFIG_SYS_MXC_I2C2_SLAVE 0 121fac96408Strem #endif 122fac96408Strem #ifndef CONFIG_SYS_MXC_I2C3_SLAVE 123fac96408Strem #define CONFIG_SYS_MXC_I2C3_SLAVE 0 124fac96408Strem #endif 125f8cb101eSYork Sun #ifndef CONFIG_SYS_MXC_I2C4_SLAVE 126f8cb101eSYork Sun #define CONFIG_SYS_MXC_I2C4_SLAVE 0 127f8cb101eSYork Sun #endif 128fac96408Strem 129db84140bSMarek Vasut /* 130db84140bSMarek Vasut * Calculate and set proper clock divider 131db84140bSMarek Vasut */ 13271204e95SPeng Fan static uint8_t i2c_imx_get_clk(struct mxc_i2c_bus *i2c_bus, unsigned int rate) 1331d549adeSStefano Babic { 134db84140bSMarek Vasut unsigned int i2c_clk_rate; 135db84140bSMarek Vasut unsigned int div; 136bf0783dfSMarek Vasut u8 clk_div; 137cdace066SSascha Hauer 138127cec18SLiu Hui-R64343 #if defined(CONFIG_MX31) 1391d549adeSStefano Babic struct clock_control_regs *sc_regs = 1401d549adeSStefano Babic (struct clock_control_regs *)CCM_BASE; 141db84140bSMarek Vasut 142e7de18afSGuennadi Liakhovetski /* start the required I2C clock */ 143de6f604dSTroy Kisky writel(readl(&sc_regs->cgr0) | (3 << CONFIG_SYS_I2C_CLK_OFFSET), 1441d549adeSStefano Babic &sc_regs->cgr0); 145127cec18SLiu Hui-R64343 #endif 146e7de18afSGuennadi Liakhovetski 147db84140bSMarek Vasut /* Divider value calculation */ 148e7bed5c2SMatthias Weisser i2c_clk_rate = mxc_get_clock(MXC_I2C_CLK); 149db84140bSMarek Vasut div = (i2c_clk_rate + rate - 1) / rate; 150db84140bSMarek Vasut if (div < i2c_clk_div[0][0]) 151b567b8ffSMarek Vasut clk_div = 0; 152db84140bSMarek Vasut else if (div > i2c_clk_div[ARRAY_SIZE(i2c_clk_div) - 1][0]) 153b567b8ffSMarek Vasut clk_div = ARRAY_SIZE(i2c_clk_div) - 1; 154db84140bSMarek Vasut else 155b567b8ffSMarek Vasut for (clk_div = 0; i2c_clk_div[clk_div][0] < div; clk_div++) 156db84140bSMarek Vasut ; 157cdace066SSascha Hauer 158db84140bSMarek Vasut /* Store divider value */ 159bf0783dfSMarek Vasut return clk_div; 160db84140bSMarek Vasut } 161cdace066SSascha Hauer 162db84140bSMarek Vasut /* 163e4ff525fSTroy Kisky * Set I2C Bus speed 164db84140bSMarek Vasut */ 16571204e95SPeng Fan static int bus_i2c_set_bus_speed(struct mxc_i2c_bus *i2c_bus, int speed) 166db84140bSMarek Vasut { 16771204e95SPeng Fan ulong base = i2c_bus->base; 16871204e95SPeng Fan bool quirk = i2c_bus->driver_data & I2C_QUIRK_FLAG ? true : false; 16971204e95SPeng Fan u8 clk_idx = i2c_imx_get_clk(i2c_bus, speed); 170bf0783dfSMarek Vasut u8 idx = i2c_clk_div[clk_idx][1]; 17171204e95SPeng Fan int reg_shift = quirk ? VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 172bf0783dfSMarek Vasut 173bf0783dfSMarek Vasut /* Store divider value */ 17471204e95SPeng Fan writeb(idx, base + (IFDR << reg_shift)); 175bf0783dfSMarek Vasut 17683a1a190STroy Kisky /* Reset module */ 17771204e95SPeng Fan writeb(I2CR_IDIS, base + (I2CR << reg_shift)); 17871204e95SPeng Fan writeb(0, base + (I2SR << reg_shift)); 179b567b8ffSMarek Vasut return 0; 180b567b8ffSMarek Vasut } 181b567b8ffSMarek Vasut 1827aa57a01STroy Kisky #define ST_BUS_IDLE (0 | (I2SR_IBB << 8)) 1837aa57a01STroy Kisky #define ST_BUS_BUSY (I2SR_IBB | (I2SR_IBB << 8)) 1847aa57a01STroy Kisky #define ST_IIF (I2SR_IIF | (I2SR_IIF << 8)) 1857aa57a01STroy Kisky 18671204e95SPeng Fan static int wait_for_sr_state(struct mxc_i2c_bus *i2c_bus, unsigned state) 18781687212SStefano Babic { 1887aa57a01STroy Kisky unsigned sr; 1897aa57a01STroy Kisky ulong elapsed; 19071204e95SPeng Fan bool quirk = i2c_bus->driver_data & I2C_QUIRK_FLAG ? true : false; 19171204e95SPeng Fan int reg_shift = quirk ? VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 19271204e95SPeng Fan ulong base = i2c_bus->base; 1937aa57a01STroy Kisky ulong start_time = get_timer(0); 1947aa57a01STroy Kisky for (;;) { 19571204e95SPeng Fan sr = readb(base + (I2SR << reg_shift)); 196d5383a63STroy Kisky if (sr & I2SR_IAL) { 19771204e95SPeng Fan if (quirk) 19871204e95SPeng Fan writeb(sr | I2SR_IAL, base + 19971204e95SPeng Fan (I2SR << reg_shift)); 20071204e95SPeng Fan else 20171204e95SPeng Fan writeb(sr & ~I2SR_IAL, base + 20271204e95SPeng Fan (I2SR << reg_shift)); 203d5383a63STroy Kisky printf("%s: Arbitration lost sr=%x cr=%x state=%x\n", 20471204e95SPeng Fan __func__, sr, readb(base + (I2CR << reg_shift)), 20571204e95SPeng Fan state); 206d5383a63STroy Kisky return -ERESTART; 207d5383a63STroy Kisky } 2087aa57a01STroy Kisky if ((sr & (state >> 8)) == (unsigned char)state) 2097aa57a01STroy Kisky return sr; 2107aa57a01STroy Kisky WATCHDOG_RESET(); 2117aa57a01STroy Kisky elapsed = get_timer(start_time); 2127aa57a01STroy Kisky if (elapsed > (CONFIG_SYS_HZ / 10)) /* .1 seconds */ 2137aa57a01STroy Kisky break; 21481687212SStefano Babic } 2157aa57a01STroy Kisky printf("%s: failed sr=%x cr=%x state=%x\n", __func__, 21671204e95SPeng Fan sr, readb(base + (I2CR << reg_shift)), state); 217cea60b0cSTroy Kisky return -ETIMEDOUT; 218db84140bSMarek Vasut } 219db84140bSMarek Vasut 22071204e95SPeng Fan static int tx_byte(struct mxc_i2c_bus *i2c_bus, u8 byte) 221cdace066SSascha Hauer { 222cea60b0cSTroy Kisky int ret; 22371204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 22471204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 22571204e95SPeng Fan ulong base = i2c_bus->base; 226db84140bSMarek Vasut 22771204e95SPeng Fan writeb(I2SR_IIF_CLEAR, base + (I2SR << reg_shift)); 22871204e95SPeng Fan writeb(byte, base + (I2DR << reg_shift)); 22971204e95SPeng Fan 23071204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_IIF); 231cea60b0cSTroy Kisky if (ret < 0) 232cea60b0cSTroy Kisky return ret; 233cea60b0cSTroy Kisky if (ret & I2SR_RX_NO_AK) 234cea60b0cSTroy Kisky return -ENODEV; 235cea60b0cSTroy Kisky return 0; 236db84140bSMarek Vasut } 237db84140bSMarek Vasut 238db84140bSMarek Vasut /* 23971204e95SPeng Fan * Stub implementations for outer i2c slave operations. 24071204e95SPeng Fan */ 24171204e95SPeng Fan void __i2c_force_reset_slave(void) 24271204e95SPeng Fan { 24371204e95SPeng Fan } 24471204e95SPeng Fan void i2c_force_reset_slave(void) 24571204e95SPeng Fan __attribute__((weak, alias("__i2c_force_reset_slave"))); 24671204e95SPeng Fan 24771204e95SPeng Fan /* 24890a5b70fSTroy Kisky * Stop I2C transaction 249db84140bSMarek Vasut */ 25071204e95SPeng Fan static void i2c_imx_stop(struct mxc_i2c_bus *i2c_bus) 251db84140bSMarek Vasut { 2527aa57a01STroy Kisky int ret; 25371204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 25471204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 25571204e95SPeng Fan ulong base = i2c_bus->base; 25671204e95SPeng Fan unsigned int temp = readb(base + (I2CR << reg_shift)); 257db84140bSMarek Vasut 2581c076dbaSTroy Kisky temp &= ~(I2CR_MSTA | I2CR_MTX); 25971204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 26071204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_BUS_IDLE); 2617aa57a01STroy Kisky if (ret < 0) 2627aa57a01STroy Kisky printf("%s:trigger stop failed\n", __func__); 263db84140bSMarek Vasut } 264db84140bSMarek Vasut 265db84140bSMarek Vasut /* 266b230ddc2STroy Kisky * Send start signal, chip address and 267b230ddc2STroy Kisky * write register address 268db84140bSMarek Vasut */ 26971204e95SPeng Fan static int i2c_init_transfer_(struct mxc_i2c_bus *i2c_bus, u8 chip, 27071204e95SPeng Fan u32 addr, int alen) 271cdace066SSascha Hauer { 27271e9f3cbSTroy Kisky unsigned int temp; 27371e9f3cbSTroy Kisky int ret; 27471204e95SPeng Fan bool quirk = i2c_bus->driver_data & I2C_QUIRK_FLAG ? true : false; 27571204e95SPeng Fan ulong base = i2c_bus->base; 27671204e95SPeng Fan int reg_shift = quirk ? VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 27771204e95SPeng Fan 27871204e95SPeng Fan /* Reset i2c slave */ 27971204e95SPeng Fan i2c_force_reset_slave(); 28071e9f3cbSTroy Kisky 28171e9f3cbSTroy Kisky /* Enable I2C controller */ 28271204e95SPeng Fan if (quirk) 28371204e95SPeng Fan ret = readb(base + (I2CR << reg_shift)) & I2CR_IDIS; 28471204e95SPeng Fan else 28571204e95SPeng Fan ret = !(readb(base + (I2CR << reg_shift)) & I2CR_IEN); 28671204e95SPeng Fan 28771204e95SPeng Fan if (ret) { 28871204e95SPeng Fan writeb(I2CR_IEN, base + (I2CR << reg_shift)); 28971e9f3cbSTroy Kisky /* Wait for controller to be stable */ 29071e9f3cbSTroy Kisky udelay(50); 29190a5b70fSTroy Kisky } 29271204e95SPeng Fan 29371204e95SPeng Fan if (readb(base + (IADR << reg_shift)) == (chip << 1)) 29471204e95SPeng Fan writeb((chip << 1) ^ 2, base + (IADR << reg_shift)); 29571204e95SPeng Fan writeb(I2SR_IIF_CLEAR, base + (I2SR << reg_shift)); 29671204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_BUS_IDLE); 29790a5b70fSTroy Kisky if (ret < 0) 298a7f1a005STroy Kisky return ret; 29971e9f3cbSTroy Kisky 30071e9f3cbSTroy Kisky /* Start I2C transaction */ 30171204e95SPeng Fan temp = readb(base + (I2CR << reg_shift)); 30271e9f3cbSTroy Kisky temp |= I2CR_MSTA; 30371204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 30471e9f3cbSTroy Kisky 30571204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_BUS_BUSY); 30671e9f3cbSTroy Kisky if (ret < 0) 307a7f1a005STroy Kisky return ret; 308b230ddc2STroy Kisky 30971e9f3cbSTroy Kisky temp |= I2CR_MTX | I2CR_TX_NO_AK; 31071204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 31171e9f3cbSTroy Kisky 312b230ddc2STroy Kisky /* write slave address */ 31371204e95SPeng Fan ret = tx_byte(i2c_bus, chip << 1); 314b230ddc2STroy Kisky if (ret < 0) 315a7f1a005STroy Kisky return ret; 316db84140bSMarek Vasut 317bf0783dfSMarek Vasut while (alen--) { 31871204e95SPeng Fan ret = tx_byte(i2c_bus, (addr >> (alen * 8)) & 0xff); 319cea60b0cSTroy Kisky if (ret < 0) 320a7f1a005STroy Kisky return ret; 32181687212SStefano Babic } 322b230ddc2STroy Kisky return 0; 323a7f1a005STroy Kisky } 324a7f1a005STroy Kisky 32571204e95SPeng Fan #ifndef CONFIG_DM_I2C 32671204e95SPeng Fan int i2c_idle_bus(struct mxc_i2c_bus *i2c_bus) 32771204e95SPeng Fan { 32871204e95SPeng Fan if (i2c_bus && i2c_bus->idle_bus_fn) 32971204e95SPeng Fan return i2c_bus->idle_bus_fn(i2c_bus->idle_bus_data); 33071204e95SPeng Fan return 0; 33171204e95SPeng Fan } 33271204e95SPeng Fan #else 33371204e95SPeng Fan /* 33471204e95SPeng Fan * Since pinmux is not supported, implement a weak function here. 33571204e95SPeng Fan * You can implement your i2c_bus_idle in board file. When pinctrl 33671204e95SPeng Fan * is supported, this can be removed. 33771204e95SPeng Fan */ 33871204e95SPeng Fan int __i2c_idle_bus(struct mxc_i2c_bus *i2c_bus) 33971204e95SPeng Fan { 34071204e95SPeng Fan return 0; 34171204e95SPeng Fan } 34296c19bd3STroy Kisky 34371204e95SPeng Fan int i2c_idle_bus(struct mxc_i2c_bus *i2c_bus) 34471204e95SPeng Fan __attribute__((weak, alias("__i2c_idle_bus"))); 34571204e95SPeng Fan #endif 34671204e95SPeng Fan 34771204e95SPeng Fan static int i2c_init_transfer(struct mxc_i2c_bus *i2c_bus, u8 chip, 34871204e95SPeng Fan u32 addr, int alen) 349a7f1a005STroy Kisky { 350a7f1a005STroy Kisky int retry; 351a7f1a005STroy Kisky int ret; 35271204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 35371204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 354a7f1a005STroy Kisky for (retry = 0; retry < 3; retry++) { 35571204e95SPeng Fan ret = i2c_init_transfer_(i2c_bus, chip, addr, alen); 356a7f1a005STroy Kisky if (ret >= 0) 357a7f1a005STroy Kisky return 0; 35871204e95SPeng Fan i2c_imx_stop(i2c_bus); 359a7f1a005STroy Kisky if (ret == -ENODEV) 360a7f1a005STroy Kisky return ret; 361a7f1a005STroy Kisky 362a7f1a005STroy Kisky printf("%s: failed for chip 0x%x retry=%d\n", __func__, chip, 363a7f1a005STroy Kisky retry); 364a7f1a005STroy Kisky if (ret != -ERESTART) 36530ea41a4SAlison Wang /* Disable controller */ 36671204e95SPeng Fan writeb(I2CR_IDIS, i2c_bus->base + (I2CR << reg_shift)); 367a7f1a005STroy Kisky udelay(100); 36871204e95SPeng Fan if (i2c_idle_bus(i2c_bus) < 0) 36996c19bd3STroy Kisky break; 370a7f1a005STroy Kisky } 37171204e95SPeng Fan printf("%s: give up i2c_regs=0x%lx\n", __func__, i2c_bus->base); 372db84140bSMarek Vasut return ret; 373cdace066SSascha Hauer } 374cdace066SSascha Hauer 37571204e95SPeng Fan 37671204e95SPeng Fan static int i2c_write_data(struct mxc_i2c_bus *i2c_bus, u8 chip, const u8 *buf, 37771204e95SPeng Fan int len) 37871204e95SPeng Fan { 37971204e95SPeng Fan int i, ret = 0; 38071204e95SPeng Fan 38171204e95SPeng Fan debug("i2c_write_data: chip=0x%x, len=0x%x\n", chip, len); 38271204e95SPeng Fan debug("write_data: "); 38371204e95SPeng Fan /* use rc for counter */ 38471204e95SPeng Fan for (i = 0; i < len; ++i) 38571204e95SPeng Fan debug(" 0x%02x", buf[i]); 38671204e95SPeng Fan debug("\n"); 38771204e95SPeng Fan 38871204e95SPeng Fan for (i = 0; i < len; i++) { 38971204e95SPeng Fan ret = tx_byte(i2c_bus, buf[i]); 39071204e95SPeng Fan if (ret < 0) { 39171204e95SPeng Fan debug("i2c_write_data(): rc=%d\n", ret); 39271204e95SPeng Fan break; 39371204e95SPeng Fan } 39471204e95SPeng Fan } 39571204e95SPeng Fan 39671204e95SPeng Fan return ret; 39771204e95SPeng Fan } 39871204e95SPeng Fan 39971204e95SPeng Fan static int i2c_read_data(struct mxc_i2c_bus *i2c_bus, uchar chip, uchar *buf, 400e4ff525fSTroy Kisky int len) 401db84140bSMarek Vasut { 402db84140bSMarek Vasut int ret; 403db84140bSMarek Vasut unsigned int temp; 404db84140bSMarek Vasut int i; 40571204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 40671204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 40771204e95SPeng Fan ulong base = i2c_bus->base; 408cdace066SSascha Hauer 40971204e95SPeng Fan debug("i2c_read_data: chip=0x%x, len=0x%x\n", chip, len); 410db84140bSMarek Vasut 411db84140bSMarek Vasut /* setup bus to read data */ 41271204e95SPeng Fan temp = readb(base + (I2CR << reg_shift)); 413db84140bSMarek Vasut temp &= ~(I2CR_MTX | I2CR_TX_NO_AK); 414db84140bSMarek Vasut if (len == 1) 415db84140bSMarek Vasut temp |= I2CR_TX_NO_AK; 41671204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 41771204e95SPeng Fan writeb(I2SR_IIF_CLEAR, base + (I2SR << reg_shift)); 41871204e95SPeng Fan /* dummy read to clear ICF */ 41971204e95SPeng Fan readb(base + (I2DR << reg_shift)); 420db84140bSMarek Vasut 421db84140bSMarek Vasut /* read data */ 422db84140bSMarek Vasut for (i = 0; i < len; i++) { 42371204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_IIF); 4247aa57a01STroy Kisky if (ret < 0) { 42571204e95SPeng Fan debug("i2c_read_data(): ret=%d\n", ret); 42671204e95SPeng Fan i2c_imx_stop(i2c_bus); 427db84140bSMarek Vasut return ret; 428c4330d28STroy Kisky } 429db84140bSMarek Vasut 430db84140bSMarek Vasut /* 431db84140bSMarek Vasut * It must generate STOP before read I2DR to prevent 432db84140bSMarek Vasut * controller from generating another clock cycle 433db84140bSMarek Vasut */ 434db84140bSMarek Vasut if (i == (len - 1)) { 43571204e95SPeng Fan i2c_imx_stop(i2c_bus); 436db84140bSMarek Vasut } else if (i == (len - 2)) { 43771204e95SPeng Fan temp = readb(base + (I2CR << reg_shift)); 438db84140bSMarek Vasut temp |= I2CR_TX_NO_AK; 43971204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 440cdace066SSascha Hauer } 44171204e95SPeng Fan writeb(I2SR_IIF_CLEAR, base + (I2SR << reg_shift)); 44271204e95SPeng Fan buf[i] = readb(base + (I2DR << reg_shift)); 443cdace066SSascha Hauer } 44471204e95SPeng Fan 44571204e95SPeng Fan /* reuse ret for counter*/ 44671204e95SPeng Fan for (ret = 0; ret < len; ++ret) 44771204e95SPeng Fan debug(" 0x%02x", buf[ret]); 44871204e95SPeng Fan debug("\n"); 44971204e95SPeng Fan 45071204e95SPeng Fan i2c_imx_stop(i2c_bus); 4517aa57a01STroy Kisky return 0; 452db84140bSMarek Vasut } 453db84140bSMarek Vasut 45471204e95SPeng Fan #ifndef CONFIG_DM_I2C 45571204e95SPeng Fan /* 45671204e95SPeng Fan * Read data from I2C device 45771204e95SPeng Fan */ 45871204e95SPeng Fan static int bus_i2c_read(struct mxc_i2c_bus *i2c_bus, u8 chip, u32 addr, 45971204e95SPeng Fan int alen, u8 *buf, int len) 46071204e95SPeng Fan { 46171204e95SPeng Fan int ret = 0; 46271204e95SPeng Fan u32 temp; 46371204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 46471204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 46571204e95SPeng Fan ulong base = i2c_bus->base; 46671204e95SPeng Fan 46771204e95SPeng Fan ret = i2c_init_transfer(i2c_bus, chip, addr, alen); 46871204e95SPeng Fan if (ret < 0) 46971204e95SPeng Fan return ret; 47071204e95SPeng Fan 47171204e95SPeng Fan temp = readb(base + (I2CR << reg_shift)); 47271204e95SPeng Fan temp |= I2CR_RSTA; 47371204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 47471204e95SPeng Fan 47571204e95SPeng Fan ret = tx_byte(i2c_bus, (chip << 1) | 1); 47671204e95SPeng Fan if (ret < 0) { 47771204e95SPeng Fan i2c_imx_stop(i2c_bus); 47871204e95SPeng Fan return ret; 47971204e95SPeng Fan } 48071204e95SPeng Fan 48171204e95SPeng Fan ret = i2c_read_data(i2c_bus, chip, buf, len); 48271204e95SPeng Fan 48371204e95SPeng Fan i2c_imx_stop(i2c_bus); 48471204e95SPeng Fan return ret; 48571204e95SPeng Fan } 48671204e95SPeng Fan 487db84140bSMarek Vasut /* 488db84140bSMarek Vasut * Write data to I2C device 489db84140bSMarek Vasut */ 49071204e95SPeng Fan static int bus_i2c_write(struct mxc_i2c_bus *i2c_bus, u8 chip, u32 addr, 49171204e95SPeng Fan int alen, const u8 *buf, int len) 492cdace066SSascha Hauer { 49371204e95SPeng Fan int ret = 0; 494cdace066SSascha Hauer 49571204e95SPeng Fan ret = i2c_init_transfer(i2c_bus, chip, addr, alen); 496cea60b0cSTroy Kisky if (ret < 0) 497db84140bSMarek Vasut return ret; 498cdace066SSascha Hauer 49971204e95SPeng Fan ret = i2c_write_data(i2c_bus, chip, buf, len); 50071204e95SPeng Fan 50171204e95SPeng Fan i2c_imx_stop(i2c_bus); 50271204e95SPeng Fan 503db84140bSMarek Vasut return ret; 504db84140bSMarek Vasut } 505cfbb88d3STroy Kisky 50671204e95SPeng Fan static struct mxc_i2c_bus mxc_i2c_buses[] = { 507fac96408Strem #if defined(CONFIG_MX25) 50871204e95SPeng Fan { 0, IMX_I2C_BASE }, 50971204e95SPeng Fan { 1, IMX_I2C2_BASE }, 51071204e95SPeng Fan { 2, IMX_I2C3_BASE }, 511fac96408Strem #elif defined(CONFIG_MX27) 51271204e95SPeng Fan { 0, IMX_I2C1_BASE }, 51371204e95SPeng Fan { 1, IMX_I2C2_BASE }, 514fac96408Strem #elif defined(CONFIG_MX31) || defined(CONFIG_MX35) || \ 515fac96408Strem defined(CONFIG_MX51) || defined(CONFIG_MX53) || \ 51671204e95SPeng Fan defined(CONFIG_MX6) 51771204e95SPeng Fan { 0, I2C1_BASE_ADDR }, 51871204e95SPeng Fan { 1, I2C2_BASE_ADDR }, 51971204e95SPeng Fan { 2, I2C3_BASE_ADDR }, 520*21a26940SHeiko Schocher #if defined(CONFIG_MX6DL) 521*21a26940SHeiko Schocher { 3, I2C4_BASE_ADDR }, 522*21a26940SHeiko Schocher #endif 52371204e95SPeng Fan #elif defined(CONFIG_LS102XA) 52471204e95SPeng Fan { 0, I2C1_BASE_ADDR, I2C_QUIRK_FLAG }, 52571204e95SPeng Fan { 1, I2C2_BASE_ADDR, I2C_QUIRK_FLAG }, 52671204e95SPeng Fan { 2, I2C3_BASE_ADDR, I2C_QUIRK_FLAG }, 527fac96408Strem #elif defined(CONFIG_VF610) 52871204e95SPeng Fan { 0, I2C0_BASE_ADDR, I2C_QUIRK_FLAG }, 5292f78eae5SYork Sun #elif defined(CONFIG_FSL_LSCH3) 53071204e95SPeng Fan { 0, I2C1_BASE_ADDR, I2C_QUIRK_FLAG }, 53171204e95SPeng Fan { 1, I2C2_BASE_ADDR, I2C_QUIRK_FLAG }, 53271204e95SPeng Fan { 2, I2C3_BASE_ADDR, I2C_QUIRK_FLAG }, 53371204e95SPeng Fan { 3, I2C4_BASE_ADDR, I2C_QUIRK_FLAG }, 534e4ff525fSTroy Kisky #else 535fac96408Strem #error "architecture not supported" 536e4ff525fSTroy Kisky #endif 53771204e95SPeng Fan { } 538fac96408Strem }; 539fac96408Strem 54071204e95SPeng Fan struct mxc_i2c_bus *i2c_get_base(struct i2c_adapter *adap) 541fac96408Strem { 54271204e95SPeng Fan return &mxc_i2c_buses[adap->hwadapnr]; 54396c19bd3STroy Kisky } 54496c19bd3STroy Kisky 545fac96408Strem static int mxc_i2c_read(struct i2c_adapter *adap, uint8_t chip, 546fac96408Strem uint addr, int alen, uint8_t *buffer, 547fac96408Strem int len) 5489815326dSTroy Kisky { 549fac96408Strem return bus_i2c_read(i2c_get_base(adap), chip, addr, alen, buffer, len); 5509815326dSTroy Kisky } 5519815326dSTroy Kisky 552fac96408Strem static int mxc_i2c_write(struct i2c_adapter *adap, uint8_t chip, 553fac96408Strem uint addr, int alen, uint8_t *buffer, 554fac96408Strem int len) 5559815326dSTroy Kisky { 556fac96408Strem return bus_i2c_write(i2c_get_base(adap), chip, addr, alen, buffer, len); 557e4ff525fSTroy Kisky } 558e4ff525fSTroy Kisky 559cfbb88d3STroy Kisky /* 560cfbb88d3STroy Kisky * Test if a chip at a given address responds (probe the chip) 561cfbb88d3STroy Kisky */ 562fac96408Strem static int mxc_i2c_probe(struct i2c_adapter *adap, uint8_t chip) 563cfbb88d3STroy Kisky { 564fac96408Strem return bus_i2c_write(i2c_get_base(adap), chip, 0, 0, NULL, 0); 565e4ff525fSTroy Kisky } 566e4ff525fSTroy Kisky 56771204e95SPeng Fan int __enable_i2c_clk(unsigned char enable, unsigned i2c_num) 56871204e95SPeng Fan { 56971204e95SPeng Fan return 1; 57071204e95SPeng Fan } 57171204e95SPeng Fan int enable_i2c_clk(unsigned char enable, unsigned i2c_num) 57271204e95SPeng Fan __attribute__((weak, alias("__enable_i2c_clk"))); 57371204e95SPeng Fan 57471204e95SPeng Fan void bus_i2c_init(int index, int speed, int unused, 575e4ff525fSTroy Kisky int (*idle_bus_fn)(void *p), void *idle_bus_data) 576e4ff525fSTroy Kisky { 57771204e95SPeng Fan int ret; 57871204e95SPeng Fan 57971204e95SPeng Fan if (index >= ARRAY_SIZE(mxc_i2c_buses)) { 58071204e95SPeng Fan debug("Error i2c index\n"); 581e4ff525fSTroy Kisky return; 582e4ff525fSTroy Kisky } 58371204e95SPeng Fan 58471204e95SPeng Fan mxc_i2c_buses[index].idle_bus_fn = idle_bus_fn; 58571204e95SPeng Fan mxc_i2c_buses[index].idle_bus_data = idle_bus_data; 58671204e95SPeng Fan 58771204e95SPeng Fan ret = enable_i2c_clk(1, index); 58871204e95SPeng Fan if (ret < 0) { 58971204e95SPeng Fan debug("I2C-%d clk fail to enable.\n", index); 59071204e95SPeng Fan return; 59171204e95SPeng Fan } 59271204e95SPeng Fan 59371204e95SPeng Fan bus_i2c_set_bus_speed(&mxc_i2c_buses[index], speed); 594e4ff525fSTroy Kisky } 595e4ff525fSTroy Kisky 596e4ff525fSTroy Kisky /* 597e4ff525fSTroy Kisky * Init I2C Bus 598e4ff525fSTroy Kisky */ 599fac96408Strem static void mxc_i2c_init(struct i2c_adapter *adap, int speed, int slaveaddr) 600e4ff525fSTroy Kisky { 60171204e95SPeng Fan bus_i2c_init(adap->hwadapnr, speed, slaveaddr, NULL, NULL); 602e4ff525fSTroy Kisky } 603e4ff525fSTroy Kisky 604e4ff525fSTroy Kisky /* 605e4ff525fSTroy Kisky * Set I2C Speed 606e4ff525fSTroy Kisky */ 60771204e95SPeng Fan static u32 mxc_i2c_set_bus_speed(struct i2c_adapter *adap, uint speed) 608e4ff525fSTroy Kisky { 609fac96408Strem return bus_i2c_set_bus_speed(i2c_get_base(adap), speed); 610e4ff525fSTroy Kisky } 611e4ff525fSTroy Kisky 612e4ff525fSTroy Kisky /* 613fac96408Strem * Register mxc i2c adapters 614e4ff525fSTroy Kisky */ 615fac96408Strem U_BOOT_I2C_ADAP_COMPLETE(mxc0, mxc_i2c_init, mxc_i2c_probe, 616fac96408Strem mxc_i2c_read, mxc_i2c_write, 617fac96408Strem mxc_i2c_set_bus_speed, 618fac96408Strem CONFIG_SYS_MXC_I2C1_SPEED, 619fac96408Strem CONFIG_SYS_MXC_I2C1_SLAVE, 0) 620fac96408Strem U_BOOT_I2C_ADAP_COMPLETE(mxc1, mxc_i2c_init, mxc_i2c_probe, 621fac96408Strem mxc_i2c_read, mxc_i2c_write, 622fac96408Strem mxc_i2c_set_bus_speed, 623fac96408Strem CONFIG_SYS_MXC_I2C2_SPEED, 624fac96408Strem CONFIG_SYS_MXC_I2C2_SLAVE, 1) 625f8cb101eSYork Sun #ifdef CONFIG_SYS_I2C_MXC_I2C3 626fac96408Strem U_BOOT_I2C_ADAP_COMPLETE(mxc2, mxc_i2c_init, mxc_i2c_probe, 627fac96408Strem mxc_i2c_read, mxc_i2c_write, 628fac96408Strem mxc_i2c_set_bus_speed, 629fac96408Strem CONFIG_SYS_MXC_I2C3_SPEED, 630fac96408Strem CONFIG_SYS_MXC_I2C3_SLAVE, 2) 631fac96408Strem #endif 63271204e95SPeng Fan 633f8cb101eSYork Sun #ifdef CONFIG_SYS_I2C_MXC_I2C4 634f8cb101eSYork Sun U_BOOT_I2C_ADAP_COMPLETE(mxc3, mxc_i2c_init, mxc_i2c_probe, 635f8cb101eSYork Sun mxc_i2c_read, mxc_i2c_write, 636f8cb101eSYork Sun mxc_i2c_set_bus_speed, 637f8cb101eSYork Sun CONFIG_SYS_MXC_I2C4_SPEED, 638f8cb101eSYork Sun CONFIG_SYS_MXC_I2C4_SLAVE, 3) 639f8cb101eSYork Sun #endif 64071204e95SPeng Fan 64171204e95SPeng Fan #else 64271204e95SPeng Fan 64371204e95SPeng Fan static int mxc_i2c_set_bus_speed(struct udevice *bus, unsigned int speed) 64471204e95SPeng Fan { 64571204e95SPeng Fan struct mxc_i2c_bus *i2c_bus = dev_get_priv(bus); 64671204e95SPeng Fan 64771204e95SPeng Fan return bus_i2c_set_bus_speed(i2c_bus, speed); 64871204e95SPeng Fan } 64971204e95SPeng Fan 65071204e95SPeng Fan static int mxc_i2c_probe(struct udevice *bus) 65171204e95SPeng Fan { 65271204e95SPeng Fan struct mxc_i2c_bus *i2c_bus = dev_get_priv(bus); 65371204e95SPeng Fan fdt_addr_t addr; 65471204e95SPeng Fan int ret; 65571204e95SPeng Fan 65671204e95SPeng Fan i2c_bus->driver_data = dev_get_driver_data(bus); 65771204e95SPeng Fan 65871204e95SPeng Fan addr = dev_get_addr(bus); 65971204e95SPeng Fan if (addr == FDT_ADDR_T_NONE) 66071204e95SPeng Fan return -ENODEV; 66171204e95SPeng Fan 66271204e95SPeng Fan i2c_bus->base = addr; 66371204e95SPeng Fan i2c_bus->index = bus->seq; 66471204e95SPeng Fan 66571204e95SPeng Fan /* Enable clk */ 66671204e95SPeng Fan ret = enable_i2c_clk(1, bus->seq); 66771204e95SPeng Fan if (ret < 0) 66871204e95SPeng Fan return ret; 66971204e95SPeng Fan 67071204e95SPeng Fan ret = i2c_idle_bus(i2c_bus); 67171204e95SPeng Fan if (ret < 0) { 67271204e95SPeng Fan /* Disable clk */ 67371204e95SPeng Fan enable_i2c_clk(0, bus->seq); 67471204e95SPeng Fan return ret; 67571204e95SPeng Fan } 67671204e95SPeng Fan 67771204e95SPeng Fan /* 67871204e95SPeng Fan * Pinmux settings are in board file now, until pinmux is supported, 67971204e95SPeng Fan * we can set pinmux here in probe function. 68071204e95SPeng Fan */ 68171204e95SPeng Fan 68271204e95SPeng Fan debug("i2c : controller bus %d at %lu , speed %d: ", 68371204e95SPeng Fan bus->seq, i2c_bus->base, 68471204e95SPeng Fan i2c_bus->speed); 68571204e95SPeng Fan 68671204e95SPeng Fan return 0; 68771204e95SPeng Fan } 68871204e95SPeng Fan 68971204e95SPeng Fan static int mxc_i2c_probe_chip(struct udevice *bus, u32 chip_addr, 69071204e95SPeng Fan u32 chip_flags) 69171204e95SPeng Fan { 69271204e95SPeng Fan int ret; 69371204e95SPeng Fan struct mxc_i2c_bus *i2c_bus = dev_get_priv(bus); 69471204e95SPeng Fan 69571204e95SPeng Fan ret = i2c_init_transfer(i2c_bus, chip_addr, 0, 0); 69671204e95SPeng Fan if (ret < 0) { 69771204e95SPeng Fan debug("%s failed, ret = %d\n", __func__, ret); 69871204e95SPeng Fan return ret; 69971204e95SPeng Fan } 70071204e95SPeng Fan 70171204e95SPeng Fan i2c_imx_stop(i2c_bus); 70271204e95SPeng Fan 70371204e95SPeng Fan return 0; 70471204e95SPeng Fan } 70571204e95SPeng Fan 70671204e95SPeng Fan static int mxc_i2c_xfer(struct udevice *bus, struct i2c_msg *msg, int nmsgs) 70771204e95SPeng Fan { 70871204e95SPeng Fan struct mxc_i2c_bus *i2c_bus = dev_get_priv(bus); 70971204e95SPeng Fan int ret = 0; 71071204e95SPeng Fan ulong base = i2c_bus->base; 71171204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 71271204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 71371204e95SPeng Fan 71471204e95SPeng Fan /* 71571204e95SPeng Fan * Here the 3rd parameter addr and the 4th one alen are set to 0, 71671204e95SPeng Fan * because here we only want to send out chip address. The register 71771204e95SPeng Fan * address is wrapped in msg. 71871204e95SPeng Fan */ 71971204e95SPeng Fan ret = i2c_init_transfer(i2c_bus, msg->addr, 0, 0); 72071204e95SPeng Fan if (ret < 0) { 72171204e95SPeng Fan debug("i2c_init_transfer error: %d\n", ret); 72271204e95SPeng Fan return ret; 72371204e95SPeng Fan } 72471204e95SPeng Fan 72571204e95SPeng Fan for (; nmsgs > 0; nmsgs--, msg++) { 72671204e95SPeng Fan bool next_is_read = nmsgs > 1 && (msg[1].flags & I2C_M_RD); 72771204e95SPeng Fan debug("i2c_xfer: chip=0x%x, len=0x%x\n", msg->addr, msg->len); 72871204e95SPeng Fan if (msg->flags & I2C_M_RD) 72971204e95SPeng Fan ret = i2c_read_data(i2c_bus, msg->addr, msg->buf, 73071204e95SPeng Fan msg->len); 73171204e95SPeng Fan else { 73271204e95SPeng Fan ret = i2c_write_data(i2c_bus, msg->addr, msg->buf, 73371204e95SPeng Fan msg->len); 73471204e95SPeng Fan if (ret) 73571204e95SPeng Fan break; 73671204e95SPeng Fan if (next_is_read) { 73771204e95SPeng Fan /* Reuse ret */ 73871204e95SPeng Fan ret = readb(base + (I2CR << reg_shift)); 73971204e95SPeng Fan ret |= I2CR_RSTA; 74071204e95SPeng Fan writeb(ret, base + (I2CR << reg_shift)); 74171204e95SPeng Fan 74271204e95SPeng Fan ret = tx_byte(i2c_bus, (msg->addr << 1) | 1); 74371204e95SPeng Fan if (ret < 0) { 74471204e95SPeng Fan i2c_imx_stop(i2c_bus); 74571204e95SPeng Fan break; 74671204e95SPeng Fan } 74771204e95SPeng Fan } 74871204e95SPeng Fan } 74971204e95SPeng Fan } 75071204e95SPeng Fan 75171204e95SPeng Fan if (ret) 75271204e95SPeng Fan debug("i2c_write: error sending\n"); 75371204e95SPeng Fan 75471204e95SPeng Fan i2c_imx_stop(i2c_bus); 75571204e95SPeng Fan 75671204e95SPeng Fan return ret; 75771204e95SPeng Fan } 75871204e95SPeng Fan 75971204e95SPeng Fan static const struct dm_i2c_ops mxc_i2c_ops = { 76071204e95SPeng Fan .xfer = mxc_i2c_xfer, 76171204e95SPeng Fan .probe_chip = mxc_i2c_probe_chip, 76271204e95SPeng Fan .set_bus_speed = mxc_i2c_set_bus_speed, 76371204e95SPeng Fan }; 76471204e95SPeng Fan 76571204e95SPeng Fan static const struct udevice_id mxc_i2c_ids[] = { 76671204e95SPeng Fan { .compatible = "fsl,imx21-i2c", }, 76771204e95SPeng Fan { .compatible = "fsl,vf610-i2c", .data = I2C_QUIRK_FLAG, }, 76871204e95SPeng Fan {} 76971204e95SPeng Fan }; 77071204e95SPeng Fan 77171204e95SPeng Fan U_BOOT_DRIVER(i2c_mxc) = { 77271204e95SPeng Fan .name = "i2c_mxc", 77371204e95SPeng Fan .id = UCLASS_I2C, 77471204e95SPeng Fan .of_match = mxc_i2c_ids, 77571204e95SPeng Fan .probe = mxc_i2c_probe, 77671204e95SPeng Fan .priv_auto_alloc_size = sizeof(struct mxc_i2c_bus), 77771204e95SPeng Fan .ops = &mxc_i2c_ops, 77871204e95SPeng Fan }; 77971204e95SPeng Fan #endif 780