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> 201221ce45SMasahiro Yamada #include <linux/errno.h> 21552a848eSStefano Babic #include <asm/mach-imx/mxc_i2c.h> 2224cd738bSTroy Kisky #include <asm/io.h> 23bf0783dfSMarek Vasut #include <i2c.h> 247aa57a01STroy Kisky #include <watchdog.h> 2571204e95SPeng Fan #include <dm.h> 26e1bed802SPeng Fan #include <dm/pinctrl.h> 2771204e95SPeng Fan #include <fdtdec.h> 28cdace066SSascha Hauer 29dec1861bSYork Sun DECLARE_GLOBAL_DATA_PTR; 30dec1861bSYork Sun 3171204e95SPeng Fan #define I2C_QUIRK_FLAG (1 << 0) 3271204e95SPeng Fan 3371204e95SPeng Fan #define IMX_I2C_REGSHIFT 2 3471204e95SPeng Fan #define VF610_I2C_REGSHIFT 0 359d10c2d3SYuan Yao 369d10c2d3SYuan Yao #define I2C_EARLY_INIT_INDEX 0 379d10c2d3SYuan Yao #ifdef CONFIG_SYS_I2C_IFDR_DIV 389d10c2d3SYuan Yao #define I2C_IFDR_DIV_CONSERVATIVE CONFIG_SYS_I2C_IFDR_DIV 399d10c2d3SYuan Yao #else 409d10c2d3SYuan Yao #define I2C_IFDR_DIV_CONSERVATIVE 0x7e 419d10c2d3SYuan Yao #endif 429d10c2d3SYuan Yao 4371204e95SPeng Fan /* Register index */ 4471204e95SPeng Fan #define IADR 0 4571204e95SPeng Fan #define IFDR 1 4671204e95SPeng Fan #define I2CR 2 4771204e95SPeng Fan #define I2SR 3 4871204e95SPeng Fan #define I2DR 4 49cdace066SSascha Hauer 50cdace066SSascha Hauer #define I2CR_IIEN (1 << 6) 51cdace066SSascha Hauer #define I2CR_MSTA (1 << 5) 52cdace066SSascha Hauer #define I2CR_MTX (1 << 4) 53cdace066SSascha Hauer #define I2CR_TX_NO_AK (1 << 3) 54cdace066SSascha Hauer #define I2CR_RSTA (1 << 2) 55cdace066SSascha Hauer 56cdace066SSascha Hauer #define I2SR_ICF (1 << 7) 57cdace066SSascha Hauer #define I2SR_IBB (1 << 5) 58d5383a63STroy Kisky #define I2SR_IAL (1 << 4) 59cdace066SSascha Hauer #define I2SR_IIF (1 << 1) 60cdace066SSascha Hauer #define I2SR_RX_NO_AK (1 << 0) 61cdace066SSascha Hauer 6230ea41a4SAlison Wang #ifdef I2C_QUIRK_REG 6330ea41a4SAlison Wang #define I2CR_IEN (0 << 7) 6430ea41a4SAlison Wang #define I2CR_IDIS (1 << 7) 6530ea41a4SAlison Wang #define I2SR_IIF_CLEAR (1 << 1) 6630ea41a4SAlison Wang #else 6730ea41a4SAlison Wang #define I2CR_IEN (1 << 7) 6830ea41a4SAlison Wang #define I2CR_IDIS (0 << 7) 6930ea41a4SAlison Wang #define I2SR_IIF_CLEAR (0 << 1) 7030ea41a4SAlison Wang #endif 7130ea41a4SAlison Wang 7230ea41a4SAlison Wang #ifdef I2C_QUIRK_REG 7330ea41a4SAlison Wang static u16 i2c_clk_div[60][2] = { 7430ea41a4SAlison Wang { 20, 0x00 }, { 22, 0x01 }, { 24, 0x02 }, { 26, 0x03 }, 7530ea41a4SAlison Wang { 28, 0x04 }, { 30, 0x05 }, { 32, 0x09 }, { 34, 0x06 }, 7630ea41a4SAlison Wang { 36, 0x0A }, { 40, 0x07 }, { 44, 0x0C }, { 48, 0x0D }, 7730ea41a4SAlison Wang { 52, 0x43 }, { 56, 0x0E }, { 60, 0x45 }, { 64, 0x12 }, 7830ea41a4SAlison Wang { 68, 0x0F }, { 72, 0x13 }, { 80, 0x14 }, { 88, 0x15 }, 7930ea41a4SAlison Wang { 96, 0x19 }, { 104, 0x16 }, { 112, 0x1A }, { 128, 0x17 }, 8030ea41a4SAlison Wang { 136, 0x4F }, { 144, 0x1C }, { 160, 0x1D }, { 176, 0x55 }, 8130ea41a4SAlison Wang { 192, 0x1E }, { 208, 0x56 }, { 224, 0x22 }, { 228, 0x24 }, 8230ea41a4SAlison Wang { 240, 0x1F }, { 256, 0x23 }, { 288, 0x5C }, { 320, 0x25 }, 8330ea41a4SAlison Wang { 384, 0x26 }, { 448, 0x2A }, { 480, 0x27 }, { 512, 0x2B }, 8430ea41a4SAlison Wang { 576, 0x2C }, { 640, 0x2D }, { 768, 0x31 }, { 896, 0x32 }, 8530ea41a4SAlison Wang { 960, 0x2F }, { 1024, 0x33 }, { 1152, 0x34 }, { 1280, 0x35 }, 8630ea41a4SAlison Wang { 1536, 0x36 }, { 1792, 0x3A }, { 1920, 0x37 }, { 2048, 0x3B }, 8730ea41a4SAlison Wang { 2304, 0x3C }, { 2560, 0x3D }, { 3072, 0x3E }, { 3584, 0x7A }, 8830ea41a4SAlison Wang { 3840, 0x3F }, { 4096, 0x7B }, { 5120, 0x7D }, { 6144, 0x7E }, 8930ea41a4SAlison Wang }; 9030ea41a4SAlison Wang #else 91db84140bSMarek Vasut static u16 i2c_clk_div[50][2] = { 92db84140bSMarek Vasut { 22, 0x20 }, { 24, 0x21 }, { 26, 0x22 }, { 28, 0x23 }, 93db84140bSMarek Vasut { 30, 0x00 }, { 32, 0x24 }, { 36, 0x25 }, { 40, 0x26 }, 94db84140bSMarek Vasut { 42, 0x03 }, { 44, 0x27 }, { 48, 0x28 }, { 52, 0x05 }, 95db84140bSMarek Vasut { 56, 0x29 }, { 60, 0x06 }, { 64, 0x2A }, { 72, 0x2B }, 96db84140bSMarek Vasut { 80, 0x2C }, { 88, 0x09 }, { 96, 0x2D }, { 104, 0x0A }, 97db84140bSMarek Vasut { 112, 0x2E }, { 128, 0x2F }, { 144, 0x0C }, { 160, 0x30 }, 98db84140bSMarek Vasut { 192, 0x31 }, { 224, 0x32 }, { 240, 0x0F }, { 256, 0x33 }, 99db84140bSMarek Vasut { 288, 0x10 }, { 320, 0x34 }, { 384, 0x35 }, { 448, 0x36 }, 100db84140bSMarek Vasut { 480, 0x13 }, { 512, 0x37 }, { 576, 0x14 }, { 640, 0x38 }, 101db84140bSMarek Vasut { 768, 0x39 }, { 896, 0x3A }, { 960, 0x17 }, { 1024, 0x3B }, 102db84140bSMarek Vasut { 1152, 0x18 }, { 1280, 0x3C }, { 1536, 0x3D }, { 1792, 0x3E }, 103db84140bSMarek Vasut { 1920, 0x1B }, { 2048, 0x3F }, { 2304, 0x1C }, { 2560, 0x1D }, 104db84140bSMarek Vasut { 3072, 0x1E }, { 3840, 0x1F } 105db84140bSMarek Vasut }; 10630ea41a4SAlison Wang #endif 107cdace066SSascha Hauer 108fac96408Strem #ifndef CONFIG_SYS_MXC_I2C1_SPEED 109fac96408Strem #define CONFIG_SYS_MXC_I2C1_SPEED 100000 110fac96408Strem #endif 111fac96408Strem #ifndef CONFIG_SYS_MXC_I2C2_SPEED 112fac96408Strem #define CONFIG_SYS_MXC_I2C2_SPEED 100000 113fac96408Strem #endif 114fac96408Strem #ifndef CONFIG_SYS_MXC_I2C3_SPEED 115fac96408Strem #define CONFIG_SYS_MXC_I2C3_SPEED 100000 116fac96408Strem #endif 117f8cb101eSYork Sun #ifndef CONFIG_SYS_MXC_I2C4_SPEED 118f8cb101eSYork Sun #define CONFIG_SYS_MXC_I2C4_SPEED 100000 119f8cb101eSYork Sun #endif 120fac96408Strem 121fac96408Strem #ifndef CONFIG_SYS_MXC_I2C1_SLAVE 122fac96408Strem #define CONFIG_SYS_MXC_I2C1_SLAVE 0 123fac96408Strem #endif 124fac96408Strem #ifndef CONFIG_SYS_MXC_I2C2_SLAVE 125fac96408Strem #define CONFIG_SYS_MXC_I2C2_SLAVE 0 126fac96408Strem #endif 127fac96408Strem #ifndef CONFIG_SYS_MXC_I2C3_SLAVE 128fac96408Strem #define CONFIG_SYS_MXC_I2C3_SLAVE 0 129fac96408Strem #endif 130f8cb101eSYork Sun #ifndef CONFIG_SYS_MXC_I2C4_SLAVE 131f8cb101eSYork Sun #define CONFIG_SYS_MXC_I2C4_SLAVE 0 132f8cb101eSYork Sun #endif 133fac96408Strem 134db84140bSMarek Vasut /* 135db84140bSMarek Vasut * Calculate and set proper clock divider 136db84140bSMarek Vasut */ 13771204e95SPeng Fan static uint8_t i2c_imx_get_clk(struct mxc_i2c_bus *i2c_bus, unsigned int rate) 1381d549adeSStefano Babic { 139db84140bSMarek Vasut unsigned int i2c_clk_rate; 140db84140bSMarek Vasut unsigned int div; 141bf0783dfSMarek Vasut u8 clk_div; 142cdace066SSascha Hauer 143127cec18SLiu Hui-R64343 #if defined(CONFIG_MX31) 1441d549adeSStefano Babic struct clock_control_regs *sc_regs = 1451d549adeSStefano Babic (struct clock_control_regs *)CCM_BASE; 146db84140bSMarek Vasut 147e7de18afSGuennadi Liakhovetski /* start the required I2C clock */ 148de6f604dSTroy Kisky writel(readl(&sc_regs->cgr0) | (3 << CONFIG_SYS_I2C_CLK_OFFSET), 1491d549adeSStefano Babic &sc_regs->cgr0); 150127cec18SLiu Hui-R64343 #endif 151e7de18afSGuennadi Liakhovetski 152db84140bSMarek Vasut /* Divider value calculation */ 153e7bed5c2SMatthias Weisser i2c_clk_rate = mxc_get_clock(MXC_I2C_CLK); 154db84140bSMarek Vasut div = (i2c_clk_rate + rate - 1) / rate; 155db84140bSMarek Vasut if (div < i2c_clk_div[0][0]) 156b567b8ffSMarek Vasut clk_div = 0; 157db84140bSMarek Vasut else if (div > i2c_clk_div[ARRAY_SIZE(i2c_clk_div) - 1][0]) 158b567b8ffSMarek Vasut clk_div = ARRAY_SIZE(i2c_clk_div) - 1; 159db84140bSMarek Vasut else 160b567b8ffSMarek Vasut for (clk_div = 0; i2c_clk_div[clk_div][0] < div; clk_div++) 161db84140bSMarek Vasut ; 162cdace066SSascha Hauer 163db84140bSMarek Vasut /* Store divider value */ 164bf0783dfSMarek Vasut return clk_div; 165db84140bSMarek Vasut } 166cdace066SSascha Hauer 167db84140bSMarek Vasut /* 168e4ff525fSTroy Kisky * Set I2C Bus speed 169db84140bSMarek Vasut */ 17071204e95SPeng Fan static int bus_i2c_set_bus_speed(struct mxc_i2c_bus *i2c_bus, int speed) 171db84140bSMarek Vasut { 17271204e95SPeng Fan ulong base = i2c_bus->base; 17371204e95SPeng Fan bool quirk = i2c_bus->driver_data & I2C_QUIRK_FLAG ? true : false; 17471204e95SPeng Fan u8 clk_idx = i2c_imx_get_clk(i2c_bus, speed); 175bf0783dfSMarek Vasut u8 idx = i2c_clk_div[clk_idx][1]; 17671204e95SPeng Fan int reg_shift = quirk ? VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 177bf0783dfSMarek Vasut 178e6c8b716SHeiko Schocher if (!base) 1797c84319aSSimon Glass return -EINVAL; 180e6c8b716SHeiko Schocher 181bf0783dfSMarek Vasut /* Store divider value */ 18271204e95SPeng Fan writeb(idx, base + (IFDR << reg_shift)); 183bf0783dfSMarek Vasut 18483a1a190STroy Kisky /* Reset module */ 18571204e95SPeng Fan writeb(I2CR_IDIS, base + (I2CR << reg_shift)); 18671204e95SPeng Fan writeb(0, base + (I2SR << reg_shift)); 187b567b8ffSMarek Vasut return 0; 188b567b8ffSMarek Vasut } 189b567b8ffSMarek Vasut 1907aa57a01STroy Kisky #define ST_BUS_IDLE (0 | (I2SR_IBB << 8)) 1917aa57a01STroy Kisky #define ST_BUS_BUSY (I2SR_IBB | (I2SR_IBB << 8)) 1927aa57a01STroy Kisky #define ST_IIF (I2SR_IIF | (I2SR_IIF << 8)) 1937aa57a01STroy Kisky 19471204e95SPeng Fan static int wait_for_sr_state(struct mxc_i2c_bus *i2c_bus, unsigned state) 19581687212SStefano Babic { 1967aa57a01STroy Kisky unsigned sr; 1977aa57a01STroy Kisky ulong elapsed; 19871204e95SPeng Fan bool quirk = i2c_bus->driver_data & I2C_QUIRK_FLAG ? true : false; 19971204e95SPeng Fan int reg_shift = quirk ? VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 20071204e95SPeng Fan ulong base = i2c_bus->base; 2017aa57a01STroy Kisky ulong start_time = get_timer(0); 2027aa57a01STroy Kisky for (;;) { 20371204e95SPeng Fan sr = readb(base + (I2SR << reg_shift)); 204d5383a63STroy Kisky if (sr & I2SR_IAL) { 20571204e95SPeng Fan if (quirk) 20671204e95SPeng Fan writeb(sr | I2SR_IAL, base + 20771204e95SPeng Fan (I2SR << reg_shift)); 20871204e95SPeng Fan else 20971204e95SPeng Fan writeb(sr & ~I2SR_IAL, base + 21071204e95SPeng Fan (I2SR << reg_shift)); 211d5383a63STroy Kisky printf("%s: Arbitration lost sr=%x cr=%x state=%x\n", 21271204e95SPeng Fan __func__, sr, readb(base + (I2CR << reg_shift)), 21371204e95SPeng Fan state); 214d5383a63STroy Kisky return -ERESTART; 215d5383a63STroy Kisky } 2167aa57a01STroy Kisky if ((sr & (state >> 8)) == (unsigned char)state) 2177aa57a01STroy Kisky return sr; 2187aa57a01STroy Kisky WATCHDOG_RESET(); 2197aa57a01STroy Kisky elapsed = get_timer(start_time); 2207aa57a01STroy Kisky if (elapsed > (CONFIG_SYS_HZ / 10)) /* .1 seconds */ 2217aa57a01STroy Kisky break; 22281687212SStefano Babic } 2237aa57a01STroy Kisky printf("%s: failed sr=%x cr=%x state=%x\n", __func__, 22471204e95SPeng Fan sr, readb(base + (I2CR << reg_shift)), state); 225cea60b0cSTroy Kisky return -ETIMEDOUT; 226db84140bSMarek Vasut } 227db84140bSMarek Vasut 22871204e95SPeng Fan static int tx_byte(struct mxc_i2c_bus *i2c_bus, u8 byte) 229cdace066SSascha Hauer { 230cea60b0cSTroy Kisky int ret; 23171204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 23271204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 23371204e95SPeng Fan ulong base = i2c_bus->base; 234db84140bSMarek Vasut 23571204e95SPeng Fan writeb(I2SR_IIF_CLEAR, base + (I2SR << reg_shift)); 23671204e95SPeng Fan writeb(byte, base + (I2DR << reg_shift)); 23771204e95SPeng Fan 23871204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_IIF); 239cea60b0cSTroy Kisky if (ret < 0) 240cea60b0cSTroy Kisky return ret; 241cea60b0cSTroy Kisky if (ret & I2SR_RX_NO_AK) 2427c84319aSSimon Glass return -EREMOTEIO; 243cea60b0cSTroy Kisky return 0; 244db84140bSMarek Vasut } 245db84140bSMarek Vasut 246db84140bSMarek Vasut /* 24771204e95SPeng Fan * Stub implementations for outer i2c slave operations. 24871204e95SPeng Fan */ 24971204e95SPeng Fan void __i2c_force_reset_slave(void) 25071204e95SPeng Fan { 25171204e95SPeng Fan } 25271204e95SPeng Fan void i2c_force_reset_slave(void) 25371204e95SPeng Fan __attribute__((weak, alias("__i2c_force_reset_slave"))); 25471204e95SPeng Fan 25571204e95SPeng Fan /* 25690a5b70fSTroy Kisky * Stop I2C transaction 257db84140bSMarek Vasut */ 25871204e95SPeng Fan static void i2c_imx_stop(struct mxc_i2c_bus *i2c_bus) 259db84140bSMarek Vasut { 2607aa57a01STroy Kisky int ret; 26171204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 26271204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 26371204e95SPeng Fan ulong base = i2c_bus->base; 26471204e95SPeng Fan unsigned int temp = readb(base + (I2CR << reg_shift)); 265db84140bSMarek Vasut 2661c076dbaSTroy Kisky temp &= ~(I2CR_MSTA | I2CR_MTX); 26771204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 26871204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_BUS_IDLE); 2697aa57a01STroy Kisky if (ret < 0) 2707aa57a01STroy Kisky printf("%s:trigger stop failed\n", __func__); 271db84140bSMarek Vasut } 272db84140bSMarek Vasut 273db84140bSMarek Vasut /* 274b230ddc2STroy Kisky * Send start signal, chip address and 275b230ddc2STroy Kisky * write register address 276db84140bSMarek Vasut */ 27771204e95SPeng Fan static int i2c_init_transfer_(struct mxc_i2c_bus *i2c_bus, u8 chip, 27871204e95SPeng Fan u32 addr, int alen) 279cdace066SSascha Hauer { 28071e9f3cbSTroy Kisky unsigned int temp; 28171e9f3cbSTroy Kisky int ret; 28271204e95SPeng Fan bool quirk = i2c_bus->driver_data & I2C_QUIRK_FLAG ? true : false; 28371204e95SPeng Fan ulong base = i2c_bus->base; 28471204e95SPeng Fan int reg_shift = quirk ? VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 28571204e95SPeng Fan 28671204e95SPeng Fan /* Reset i2c slave */ 28771204e95SPeng Fan i2c_force_reset_slave(); 28871e9f3cbSTroy Kisky 28971e9f3cbSTroy Kisky /* Enable I2C controller */ 29071204e95SPeng Fan if (quirk) 29171204e95SPeng Fan ret = readb(base + (I2CR << reg_shift)) & I2CR_IDIS; 29271204e95SPeng Fan else 29371204e95SPeng Fan ret = !(readb(base + (I2CR << reg_shift)) & I2CR_IEN); 29471204e95SPeng Fan 29571204e95SPeng Fan if (ret) { 29671204e95SPeng Fan writeb(I2CR_IEN, base + (I2CR << reg_shift)); 29771e9f3cbSTroy Kisky /* Wait for controller to be stable */ 29871e9f3cbSTroy Kisky udelay(50); 29990a5b70fSTroy Kisky } 30071204e95SPeng Fan 30171204e95SPeng Fan if (readb(base + (IADR << reg_shift)) == (chip << 1)) 30271204e95SPeng Fan writeb((chip << 1) ^ 2, base + (IADR << reg_shift)); 30371204e95SPeng Fan writeb(I2SR_IIF_CLEAR, base + (I2SR << reg_shift)); 30471204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_BUS_IDLE); 30590a5b70fSTroy Kisky if (ret < 0) 306a7f1a005STroy Kisky return ret; 30771e9f3cbSTroy Kisky 30871e9f3cbSTroy Kisky /* Start I2C transaction */ 30971204e95SPeng Fan temp = readb(base + (I2CR << reg_shift)); 31071e9f3cbSTroy Kisky temp |= I2CR_MSTA; 31171204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 31271e9f3cbSTroy Kisky 31371204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_BUS_BUSY); 31471e9f3cbSTroy Kisky if (ret < 0) 315a7f1a005STroy Kisky return ret; 316b230ddc2STroy Kisky 31771e9f3cbSTroy Kisky temp |= I2CR_MTX | I2CR_TX_NO_AK; 31871204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 31971e9f3cbSTroy Kisky 3202feec4eaSNandor Han if (alen >= 0) { 321b230ddc2STroy Kisky /* write slave address */ 32271204e95SPeng Fan ret = tx_byte(i2c_bus, chip << 1); 323b230ddc2STroy Kisky if (ret < 0) 324a7f1a005STroy Kisky return ret; 325db84140bSMarek Vasut 326bf0783dfSMarek Vasut while (alen--) { 32771204e95SPeng Fan ret = tx_byte(i2c_bus, (addr >> (alen * 8)) & 0xff); 328cea60b0cSTroy Kisky if (ret < 0) 329a7f1a005STroy Kisky return ret; 33081687212SStefano Babic } 3312feec4eaSNandor Han } 3322feec4eaSNandor Han 333b230ddc2STroy Kisky return 0; 334a7f1a005STroy Kisky } 335a7f1a005STroy Kisky 33671204e95SPeng Fan #ifndef CONFIG_DM_I2C 33771204e95SPeng Fan int i2c_idle_bus(struct mxc_i2c_bus *i2c_bus) 33871204e95SPeng Fan { 33971204e95SPeng Fan if (i2c_bus && i2c_bus->idle_bus_fn) 34071204e95SPeng Fan return i2c_bus->idle_bus_fn(i2c_bus->idle_bus_data); 34171204e95SPeng Fan return 0; 34271204e95SPeng Fan } 34371204e95SPeng Fan #else 34471204e95SPeng Fan /* 345e1bed802SPeng Fan * See Linux Documentation/devicetree/bindings/i2c/i2c-imx.txt 346e1bed802SPeng Fan * " 347e1bed802SPeng Fan * scl-gpios: specify the gpio related to SCL pin 348e1bed802SPeng Fan * sda-gpios: specify the gpio related to SDA pin 349e1bed802SPeng Fan * add pinctrl to configure i2c pins to gpio function for i2c 350e1bed802SPeng Fan * bus recovery, call it "gpio" state 351e1bed802SPeng Fan * " 352e1bed802SPeng Fan * 353e1bed802SPeng Fan * The i2c_idle_bus is an implementation following Linux Kernel. 35471204e95SPeng Fan */ 355e1bed802SPeng Fan int i2c_idle_bus(struct mxc_i2c_bus *i2c_bus) 35671204e95SPeng Fan { 357e1bed802SPeng Fan struct udevice *bus = i2c_bus->bus; 358e1bed802SPeng Fan struct gpio_desc *scl_gpio = &i2c_bus->scl_gpio; 359e1bed802SPeng Fan struct gpio_desc *sda_gpio = &i2c_bus->sda_gpio; 360e1bed802SPeng Fan int sda, scl; 361e1bed802SPeng Fan int i, ret = 0; 362e1bed802SPeng Fan ulong elapsed, start_time; 363e1bed802SPeng Fan 364e1bed802SPeng Fan if (pinctrl_select_state(bus, "gpio")) { 365e1bed802SPeng Fan dev_dbg(bus, "Can not to switch to use gpio pinmux\n"); 366e1bed802SPeng Fan /* 367e1bed802SPeng Fan * GPIO pinctrl for i2c force idle is not a must, 368e1bed802SPeng Fan * but it is strongly recommended to be used. 369e1bed802SPeng Fan * Because it can help you to recover from bad 370e1bed802SPeng Fan * i2c bus state. Do not return failure, because 371e1bed802SPeng Fan * it is not a must. 372e1bed802SPeng Fan */ 37371204e95SPeng Fan return 0; 37471204e95SPeng Fan } 37596c19bd3STroy Kisky 376e1bed802SPeng Fan dm_gpio_set_dir_flags(scl_gpio, GPIOD_IS_IN); 377e1bed802SPeng Fan dm_gpio_set_dir_flags(sda_gpio, GPIOD_IS_IN); 378e1bed802SPeng Fan scl = dm_gpio_get_value(scl_gpio); 379e1bed802SPeng Fan sda = dm_gpio_get_value(sda_gpio); 380e1bed802SPeng Fan 381e1bed802SPeng Fan if ((sda & scl) == 1) 382e1bed802SPeng Fan goto exit; /* Bus is idle already */ 383e1bed802SPeng Fan 384e1bed802SPeng Fan /* Send high and low on the SCL line */ 385e1bed802SPeng Fan for (i = 0; i < 9; i++) { 386e1bed802SPeng Fan dm_gpio_set_dir_flags(scl_gpio, GPIOD_IS_OUT); 387e1bed802SPeng Fan dm_gpio_set_value(scl_gpio, 0); 388e1bed802SPeng Fan udelay(50); 389e1bed802SPeng Fan dm_gpio_set_dir_flags(scl_gpio, GPIOD_IS_IN); 390e1bed802SPeng Fan udelay(50); 391e1bed802SPeng Fan } 392e1bed802SPeng Fan start_time = get_timer(0); 393e1bed802SPeng Fan for (;;) { 394e1bed802SPeng Fan dm_gpio_set_dir_flags(scl_gpio, GPIOD_IS_IN); 395e1bed802SPeng Fan dm_gpio_set_dir_flags(sda_gpio, GPIOD_IS_IN); 396e1bed802SPeng Fan scl = dm_gpio_get_value(scl_gpio); 397e1bed802SPeng Fan sda = dm_gpio_get_value(sda_gpio); 398e1bed802SPeng Fan if ((sda & scl) == 1) 399e1bed802SPeng Fan break; 400e1bed802SPeng Fan WATCHDOG_RESET(); 401e1bed802SPeng Fan elapsed = get_timer(start_time); 402e1bed802SPeng Fan if (elapsed > (CONFIG_SYS_HZ / 5)) { /* .2 seconds */ 403e1bed802SPeng Fan ret = -EBUSY; 404e1bed802SPeng Fan printf("%s: failed to clear bus, sda=%d scl=%d\n", __func__, sda, scl); 405e1bed802SPeng Fan break; 406e1bed802SPeng Fan } 407e1bed802SPeng Fan } 408e1bed802SPeng Fan 409e1bed802SPeng Fan exit: 410e1bed802SPeng Fan pinctrl_select_state(bus, "default"); 411e1bed802SPeng Fan return ret; 412e1bed802SPeng Fan } 41371204e95SPeng Fan #endif 41471204e95SPeng Fan 41571204e95SPeng Fan static int i2c_init_transfer(struct mxc_i2c_bus *i2c_bus, u8 chip, 41671204e95SPeng Fan u32 addr, int alen) 417a7f1a005STroy Kisky { 418a7f1a005STroy Kisky int retry; 419a7f1a005STroy Kisky int ret; 42071204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 42171204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 422e6c8b716SHeiko Schocher 423e6c8b716SHeiko Schocher if (!i2c_bus->base) 4247c84319aSSimon Glass return -EINVAL; 425e6c8b716SHeiko Schocher 426a7f1a005STroy Kisky for (retry = 0; retry < 3; retry++) { 42771204e95SPeng Fan ret = i2c_init_transfer_(i2c_bus, chip, addr, alen); 428a7f1a005STroy Kisky if (ret >= 0) 429a7f1a005STroy Kisky return 0; 43071204e95SPeng Fan i2c_imx_stop(i2c_bus); 4317c84319aSSimon Glass if (ret == -EREMOTEIO) 432a7f1a005STroy Kisky return ret; 433a7f1a005STroy Kisky 434a7f1a005STroy Kisky printf("%s: failed for chip 0x%x retry=%d\n", __func__, chip, 435a7f1a005STroy Kisky retry); 436a7f1a005STroy Kisky if (ret != -ERESTART) 43730ea41a4SAlison Wang /* Disable controller */ 43871204e95SPeng Fan writeb(I2CR_IDIS, i2c_bus->base + (I2CR << reg_shift)); 439a7f1a005STroy Kisky udelay(100); 44071204e95SPeng Fan if (i2c_idle_bus(i2c_bus) < 0) 44196c19bd3STroy Kisky break; 442a7f1a005STroy Kisky } 44371204e95SPeng Fan printf("%s: give up i2c_regs=0x%lx\n", __func__, i2c_bus->base); 444db84140bSMarek Vasut return ret; 445cdace066SSascha Hauer } 446cdace066SSascha Hauer 44771204e95SPeng Fan 44871204e95SPeng Fan static int i2c_write_data(struct mxc_i2c_bus *i2c_bus, u8 chip, const u8 *buf, 44971204e95SPeng Fan int len) 45071204e95SPeng Fan { 45171204e95SPeng Fan int i, ret = 0; 45271204e95SPeng Fan 45371204e95SPeng Fan debug("i2c_write_data: chip=0x%x, len=0x%x\n", chip, len); 45471204e95SPeng Fan debug("write_data: "); 45571204e95SPeng Fan /* use rc for counter */ 45671204e95SPeng Fan for (i = 0; i < len; ++i) 45771204e95SPeng Fan debug(" 0x%02x", buf[i]); 45871204e95SPeng Fan debug("\n"); 45971204e95SPeng Fan 46071204e95SPeng Fan for (i = 0; i < len; i++) { 46171204e95SPeng Fan ret = tx_byte(i2c_bus, buf[i]); 46271204e95SPeng Fan if (ret < 0) { 46371204e95SPeng Fan debug("i2c_write_data(): rc=%d\n", ret); 46471204e95SPeng Fan break; 46571204e95SPeng Fan } 46671204e95SPeng Fan } 46771204e95SPeng Fan 46871204e95SPeng Fan return ret; 46971204e95SPeng Fan } 47071204e95SPeng Fan 47171204e95SPeng Fan static int i2c_read_data(struct mxc_i2c_bus *i2c_bus, uchar chip, uchar *buf, 472e4ff525fSTroy Kisky int len) 473db84140bSMarek Vasut { 474db84140bSMarek Vasut int ret; 475db84140bSMarek Vasut unsigned int temp; 476db84140bSMarek Vasut int i; 47771204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 47871204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 47971204e95SPeng Fan ulong base = i2c_bus->base; 480cdace066SSascha Hauer 48171204e95SPeng Fan debug("i2c_read_data: chip=0x%x, len=0x%x\n", chip, len); 482db84140bSMarek Vasut 483db84140bSMarek Vasut /* setup bus to read data */ 48471204e95SPeng Fan temp = readb(base + (I2CR << reg_shift)); 485db84140bSMarek Vasut temp &= ~(I2CR_MTX | I2CR_TX_NO_AK); 486db84140bSMarek Vasut if (len == 1) 487db84140bSMarek Vasut temp |= I2CR_TX_NO_AK; 48871204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 48971204e95SPeng Fan writeb(I2SR_IIF_CLEAR, base + (I2SR << reg_shift)); 49071204e95SPeng Fan /* dummy read to clear ICF */ 49171204e95SPeng Fan readb(base + (I2DR << reg_shift)); 492db84140bSMarek Vasut 493db84140bSMarek Vasut /* read data */ 494db84140bSMarek Vasut for (i = 0; i < len; i++) { 49571204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_IIF); 4967aa57a01STroy Kisky if (ret < 0) { 49771204e95SPeng Fan debug("i2c_read_data(): ret=%d\n", ret); 49871204e95SPeng Fan i2c_imx_stop(i2c_bus); 499db84140bSMarek Vasut return ret; 500c4330d28STroy Kisky } 501db84140bSMarek Vasut 502db84140bSMarek Vasut /* 503db84140bSMarek Vasut * It must generate STOP before read I2DR to prevent 504db84140bSMarek Vasut * controller from generating another clock cycle 505db84140bSMarek Vasut */ 506db84140bSMarek Vasut if (i == (len - 1)) { 50771204e95SPeng Fan i2c_imx_stop(i2c_bus); 508db84140bSMarek Vasut } else if (i == (len - 2)) { 50971204e95SPeng Fan temp = readb(base + (I2CR << reg_shift)); 510db84140bSMarek Vasut temp |= I2CR_TX_NO_AK; 51171204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 512cdace066SSascha Hauer } 51371204e95SPeng Fan writeb(I2SR_IIF_CLEAR, base + (I2SR << reg_shift)); 51471204e95SPeng Fan buf[i] = readb(base + (I2DR << reg_shift)); 515cdace066SSascha Hauer } 51671204e95SPeng Fan 51771204e95SPeng Fan /* reuse ret for counter*/ 51871204e95SPeng Fan for (ret = 0; ret < len; ++ret) 51971204e95SPeng Fan debug(" 0x%02x", buf[ret]); 52071204e95SPeng Fan debug("\n"); 52171204e95SPeng Fan 52271204e95SPeng Fan i2c_imx_stop(i2c_bus); 5237aa57a01STroy Kisky return 0; 524db84140bSMarek Vasut } 525db84140bSMarek Vasut 52671204e95SPeng Fan #ifndef CONFIG_DM_I2C 52771204e95SPeng Fan /* 52871204e95SPeng Fan * Read data from I2C device 52971204e95SPeng Fan */ 53071204e95SPeng Fan static int bus_i2c_read(struct mxc_i2c_bus *i2c_bus, u8 chip, u32 addr, 53171204e95SPeng Fan int alen, u8 *buf, int len) 53271204e95SPeng Fan { 53371204e95SPeng Fan int ret = 0; 53471204e95SPeng Fan u32 temp; 53571204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 53671204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 53771204e95SPeng Fan ulong base = i2c_bus->base; 53871204e95SPeng Fan 53971204e95SPeng Fan ret = i2c_init_transfer(i2c_bus, chip, addr, alen); 54071204e95SPeng Fan if (ret < 0) 54171204e95SPeng Fan return ret; 54271204e95SPeng Fan 5432feec4eaSNandor Han if (alen >= 0) { 54471204e95SPeng Fan temp = readb(base + (I2CR << reg_shift)); 54571204e95SPeng Fan temp |= I2CR_RSTA; 54671204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 5472feec4eaSNandor Han } 54871204e95SPeng Fan 54971204e95SPeng Fan ret = tx_byte(i2c_bus, (chip << 1) | 1); 55071204e95SPeng Fan if (ret < 0) { 55171204e95SPeng Fan i2c_imx_stop(i2c_bus); 55271204e95SPeng Fan return ret; 55371204e95SPeng Fan } 55471204e95SPeng Fan 55571204e95SPeng Fan ret = i2c_read_data(i2c_bus, chip, buf, len); 55671204e95SPeng Fan 55771204e95SPeng Fan i2c_imx_stop(i2c_bus); 55871204e95SPeng Fan return ret; 55971204e95SPeng Fan } 56071204e95SPeng Fan 561db84140bSMarek Vasut /* 562db84140bSMarek Vasut * Write data to I2C device 563db84140bSMarek Vasut */ 56471204e95SPeng Fan static int bus_i2c_write(struct mxc_i2c_bus *i2c_bus, u8 chip, u32 addr, 56571204e95SPeng Fan int alen, const u8 *buf, int len) 566cdace066SSascha Hauer { 56771204e95SPeng Fan int ret = 0; 568cdace066SSascha Hauer 56971204e95SPeng Fan ret = i2c_init_transfer(i2c_bus, chip, addr, alen); 570cea60b0cSTroy Kisky if (ret < 0) 571db84140bSMarek Vasut return ret; 572cdace066SSascha Hauer 57371204e95SPeng Fan ret = i2c_write_data(i2c_bus, chip, buf, len); 57471204e95SPeng Fan 57571204e95SPeng Fan i2c_imx_stop(i2c_bus); 57671204e95SPeng Fan 577db84140bSMarek Vasut return ret; 578db84140bSMarek Vasut } 579cfbb88d3STroy Kisky 580e6c8b716SHeiko Schocher #if !defined(I2C2_BASE_ADDR) 581e6c8b716SHeiko Schocher #define I2C2_BASE_ADDR 0 58221a26940SHeiko Schocher #endif 583e6c8b716SHeiko Schocher 584e6c8b716SHeiko Schocher #if !defined(I2C3_BASE_ADDR) 585e6c8b716SHeiko Schocher #define I2C3_BASE_ADDR 0 586e6c8b716SHeiko Schocher #endif 587e6c8b716SHeiko Schocher 588e6c8b716SHeiko Schocher #if !defined(I2C4_BASE_ADDR) 589e6c8b716SHeiko Schocher #define I2C4_BASE_ADDR 0 590e6c8b716SHeiko Schocher #endif 591e6c8b716SHeiko Schocher 592e6c8b716SHeiko Schocher static struct mxc_i2c_bus mxc_i2c_buses[] = { 59373fb5838SYork Sun #if defined(CONFIG_ARCH_LS1021A) || defined(CONFIG_VF610) || \ 5949f3183d2SMingkai Hu defined(CONFIG_FSL_LAYERSCAPE) 59571204e95SPeng Fan { 0, I2C1_BASE_ADDR, I2C_QUIRK_FLAG }, 59671204e95SPeng Fan { 1, I2C2_BASE_ADDR, I2C_QUIRK_FLAG }, 59771204e95SPeng Fan { 2, I2C3_BASE_ADDR, I2C_QUIRK_FLAG }, 59871204e95SPeng Fan { 3, I2C4_BASE_ADDR, I2C_QUIRK_FLAG }, 599e4ff525fSTroy Kisky #else 600e6c8b716SHeiko Schocher { 0, I2C1_BASE_ADDR, 0 }, 601e6c8b716SHeiko Schocher { 1, I2C2_BASE_ADDR, 0 }, 602e6c8b716SHeiko Schocher { 2, I2C3_BASE_ADDR, 0 }, 603e6c8b716SHeiko Schocher { 3, I2C4_BASE_ADDR, 0 }, 604e4ff525fSTroy Kisky #endif 605fac96408Strem }; 606fac96408Strem 60771204e95SPeng Fan struct mxc_i2c_bus *i2c_get_base(struct i2c_adapter *adap) 608fac96408Strem { 60971204e95SPeng Fan return &mxc_i2c_buses[adap->hwadapnr]; 61096c19bd3STroy Kisky } 61196c19bd3STroy Kisky 612fac96408Strem static int mxc_i2c_read(struct i2c_adapter *adap, uint8_t chip, 613fac96408Strem uint addr, int alen, uint8_t *buffer, 614fac96408Strem int len) 6159815326dSTroy Kisky { 616fac96408Strem return bus_i2c_read(i2c_get_base(adap), chip, addr, alen, buffer, len); 6179815326dSTroy Kisky } 6189815326dSTroy Kisky 619fac96408Strem static int mxc_i2c_write(struct i2c_adapter *adap, uint8_t chip, 620fac96408Strem uint addr, int alen, uint8_t *buffer, 621fac96408Strem int len) 6229815326dSTroy Kisky { 623fac96408Strem return bus_i2c_write(i2c_get_base(adap), chip, addr, alen, buffer, len); 624e4ff525fSTroy Kisky } 625e4ff525fSTroy Kisky 626cfbb88d3STroy Kisky /* 627cfbb88d3STroy Kisky * Test if a chip at a given address responds (probe the chip) 628cfbb88d3STroy Kisky */ 629fac96408Strem static int mxc_i2c_probe(struct i2c_adapter *adap, uint8_t chip) 630cfbb88d3STroy Kisky { 631fac96408Strem return bus_i2c_write(i2c_get_base(adap), chip, 0, 0, NULL, 0); 632e4ff525fSTroy Kisky } 633e4ff525fSTroy Kisky 63471204e95SPeng Fan int __enable_i2c_clk(unsigned char enable, unsigned i2c_num) 63571204e95SPeng Fan { 63671204e95SPeng Fan return 1; 63771204e95SPeng Fan } 63871204e95SPeng Fan int enable_i2c_clk(unsigned char enable, unsigned i2c_num) 63971204e95SPeng Fan __attribute__((weak, alias("__enable_i2c_clk"))); 64071204e95SPeng Fan 64171204e95SPeng Fan void bus_i2c_init(int index, int speed, int unused, 642e4ff525fSTroy Kisky int (*idle_bus_fn)(void *p), void *idle_bus_data) 643e4ff525fSTroy Kisky { 64471204e95SPeng Fan int ret; 64571204e95SPeng Fan 64671204e95SPeng Fan if (index >= ARRAY_SIZE(mxc_i2c_buses)) { 64771204e95SPeng Fan debug("Error i2c index\n"); 648e4ff525fSTroy Kisky return; 649e4ff525fSTroy Kisky } 65071204e95SPeng Fan 651aee3fddbSGong Qianyu /* 652aee3fddbSGong Qianyu * Warning: Be careful to allow the assignment to a static 653aee3fddbSGong Qianyu * variable here. This function could be called while U-Boot is 654aee3fddbSGong Qianyu * still running in flash memory. So such assignment is equal 655aee3fddbSGong Qianyu * to write data to flash without erasing. 656aee3fddbSGong Qianyu */ 657aee3fddbSGong Qianyu if (idle_bus_fn) 65871204e95SPeng Fan mxc_i2c_buses[index].idle_bus_fn = idle_bus_fn; 659aee3fddbSGong Qianyu if (idle_bus_data) 66071204e95SPeng Fan mxc_i2c_buses[index].idle_bus_data = idle_bus_data; 66171204e95SPeng Fan 66271204e95SPeng Fan ret = enable_i2c_clk(1, index); 66371204e95SPeng Fan if (ret < 0) { 66471204e95SPeng Fan debug("I2C-%d clk fail to enable.\n", index); 66571204e95SPeng Fan return; 66671204e95SPeng Fan } 66771204e95SPeng Fan 66871204e95SPeng Fan bus_i2c_set_bus_speed(&mxc_i2c_buses[index], speed); 669e4ff525fSTroy Kisky } 670e4ff525fSTroy Kisky 671e4ff525fSTroy Kisky /* 6729d10c2d3SYuan Yao * Early init I2C for prepare read the clk through I2C. 6739d10c2d3SYuan Yao */ 6749d10c2d3SYuan Yao void i2c_early_init_f(void) 6759d10c2d3SYuan Yao { 6769d10c2d3SYuan Yao ulong base = mxc_i2c_buses[I2C_EARLY_INIT_INDEX].base; 6779d10c2d3SYuan Yao bool quirk = mxc_i2c_buses[I2C_EARLY_INIT_INDEX].driver_data 6789d10c2d3SYuan Yao & I2C_QUIRK_FLAG ? true : false; 6799d10c2d3SYuan Yao int reg_shift = quirk ? VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 6809d10c2d3SYuan Yao 6819d10c2d3SYuan Yao /* Set I2C divider value */ 6829d10c2d3SYuan Yao writeb(I2C_IFDR_DIV_CONSERVATIVE, base + (IFDR << reg_shift)); 6839d10c2d3SYuan Yao /* Reset module */ 6849d10c2d3SYuan Yao writeb(I2CR_IDIS, base + (I2CR << reg_shift)); 6859d10c2d3SYuan Yao writeb(0, base + (I2SR << reg_shift)); 6869d10c2d3SYuan Yao /* Enable I2C */ 6879d10c2d3SYuan Yao writeb(I2CR_IEN, base + (I2CR << reg_shift)); 6889d10c2d3SYuan Yao } 6899d10c2d3SYuan Yao 6909d10c2d3SYuan Yao /* 691e4ff525fSTroy Kisky * Init I2C Bus 692e4ff525fSTroy Kisky */ 693fac96408Strem static void mxc_i2c_init(struct i2c_adapter *adap, int speed, int slaveaddr) 694e4ff525fSTroy Kisky { 69571204e95SPeng Fan bus_i2c_init(adap->hwadapnr, speed, slaveaddr, NULL, NULL); 696e4ff525fSTroy Kisky } 697e4ff525fSTroy Kisky 698e4ff525fSTroy Kisky /* 699e4ff525fSTroy Kisky * Set I2C Speed 700e4ff525fSTroy Kisky */ 70171204e95SPeng Fan static u32 mxc_i2c_set_bus_speed(struct i2c_adapter *adap, uint speed) 702e4ff525fSTroy Kisky { 703fac96408Strem return bus_i2c_set_bus_speed(i2c_get_base(adap), speed); 704e4ff525fSTroy Kisky } 705e4ff525fSTroy Kisky 706e4ff525fSTroy Kisky /* 707fac96408Strem * Register mxc i2c adapters 708e4ff525fSTroy Kisky */ 70903544c66SAlbert ARIBAUD \\(3ADEV\\) #ifdef CONFIG_SYS_I2C_MXC_I2C1 710fac96408Strem U_BOOT_I2C_ADAP_COMPLETE(mxc0, mxc_i2c_init, mxc_i2c_probe, 711fac96408Strem mxc_i2c_read, mxc_i2c_write, 712fac96408Strem mxc_i2c_set_bus_speed, 713fac96408Strem CONFIG_SYS_MXC_I2C1_SPEED, 714fac96408Strem CONFIG_SYS_MXC_I2C1_SLAVE, 0) 71503544c66SAlbert ARIBAUD \\(3ADEV\\) #endif 71603544c66SAlbert ARIBAUD \\(3ADEV\\) 71703544c66SAlbert ARIBAUD \\(3ADEV\\) #ifdef CONFIG_SYS_I2C_MXC_I2C2 718fac96408Strem U_BOOT_I2C_ADAP_COMPLETE(mxc1, mxc_i2c_init, mxc_i2c_probe, 719fac96408Strem mxc_i2c_read, mxc_i2c_write, 720fac96408Strem mxc_i2c_set_bus_speed, 721fac96408Strem CONFIG_SYS_MXC_I2C2_SPEED, 722fac96408Strem CONFIG_SYS_MXC_I2C2_SLAVE, 1) 72303544c66SAlbert ARIBAUD \\(3ADEV\\) #endif 72403544c66SAlbert ARIBAUD \\(3ADEV\\) 725f8cb101eSYork Sun #ifdef CONFIG_SYS_I2C_MXC_I2C3 726fac96408Strem U_BOOT_I2C_ADAP_COMPLETE(mxc2, mxc_i2c_init, mxc_i2c_probe, 727fac96408Strem mxc_i2c_read, mxc_i2c_write, 728fac96408Strem mxc_i2c_set_bus_speed, 729fac96408Strem CONFIG_SYS_MXC_I2C3_SPEED, 730fac96408Strem CONFIG_SYS_MXC_I2C3_SLAVE, 2) 731fac96408Strem #endif 73271204e95SPeng Fan 733f8cb101eSYork Sun #ifdef CONFIG_SYS_I2C_MXC_I2C4 734f8cb101eSYork Sun U_BOOT_I2C_ADAP_COMPLETE(mxc3, mxc_i2c_init, mxc_i2c_probe, 735f8cb101eSYork Sun mxc_i2c_read, mxc_i2c_write, 736f8cb101eSYork Sun mxc_i2c_set_bus_speed, 737f8cb101eSYork Sun CONFIG_SYS_MXC_I2C4_SPEED, 738f8cb101eSYork Sun CONFIG_SYS_MXC_I2C4_SLAVE, 3) 739f8cb101eSYork Sun #endif 74071204e95SPeng Fan 74171204e95SPeng Fan #else 74271204e95SPeng Fan 74371204e95SPeng Fan static int mxc_i2c_set_bus_speed(struct udevice *bus, unsigned int speed) 74471204e95SPeng Fan { 74571204e95SPeng Fan struct mxc_i2c_bus *i2c_bus = dev_get_priv(bus); 74671204e95SPeng Fan 74771204e95SPeng Fan return bus_i2c_set_bus_speed(i2c_bus, speed); 74871204e95SPeng Fan } 74971204e95SPeng Fan 75071204e95SPeng Fan static int mxc_i2c_probe(struct udevice *bus) 75171204e95SPeng Fan { 75271204e95SPeng Fan struct mxc_i2c_bus *i2c_bus = dev_get_priv(bus); 753e1bed802SPeng Fan const void *fdt = gd->fdt_blob; 754e160f7d4SSimon Glass int node = dev_of_offset(bus); 75571204e95SPeng Fan fdt_addr_t addr; 756e1bed802SPeng Fan int ret, ret2; 75771204e95SPeng Fan 75871204e95SPeng Fan i2c_bus->driver_data = dev_get_driver_data(bus); 75971204e95SPeng Fan 760a821c4afSSimon Glass addr = devfdt_get_addr(bus); 76171204e95SPeng Fan if (addr == FDT_ADDR_T_NONE) 7627c84319aSSimon Glass return -EINVAL; 76371204e95SPeng Fan 76471204e95SPeng Fan i2c_bus->base = addr; 76571204e95SPeng Fan i2c_bus->index = bus->seq; 766e1bed802SPeng Fan i2c_bus->bus = bus; 76771204e95SPeng Fan 76871204e95SPeng Fan /* Enable clk */ 76971204e95SPeng Fan ret = enable_i2c_clk(1, bus->seq); 77071204e95SPeng Fan if (ret < 0) 77171204e95SPeng Fan return ret; 77271204e95SPeng Fan 773e1bed802SPeng Fan /* 774e1bed802SPeng Fan * See Documentation/devicetree/bindings/i2c/i2c-imx.txt 775e1bed802SPeng Fan * Use gpio to force bus idle when necessary. 776e1bed802SPeng Fan */ 777b02e4044SSimon Glass ret = fdt_stringlist_search(fdt, node, "pinctrl-names", "gpio"); 778e1bed802SPeng Fan if (ret < 0) { 7792da24fe5SJagan Teki debug("i2c bus %d at 0x%2lx, no gpio pinctrl state.\n", bus->seq, i2c_bus->base); 780e1bed802SPeng Fan } else { 781150c5afeSSimon Glass ret = gpio_request_by_name_nodev(offset_to_ofnode(node), 782150c5afeSSimon Glass "scl-gpios", 0, &i2c_bus->scl_gpio, 783e1bed802SPeng Fan GPIOD_IS_OUT); 784150c5afeSSimon Glass ret2 = gpio_request_by_name_nodev(offset_to_ofnode(node), 785150c5afeSSimon Glass "sda-gpios", 0, &i2c_bus->sda_gpio, 786e1bed802SPeng Fan GPIOD_IS_OUT); 787*fb012873SPeng Fan if (!dm_gpio_is_valid(&i2c_bus->sda_gpio) || 788*fb012873SPeng Fan !dm_gpio_is_valid(&i2c_bus->scl_gpio) || 789*fb012873SPeng Fan ret || ret2) { 790e1bed802SPeng Fan dev_err(dev, "i2c bus %d at %lu, fail to request scl/sda gpio\n", bus->seq, i2c_bus->base); 7917c84319aSSimon Glass return -EINVAL; 792e1bed802SPeng Fan } 793e1bed802SPeng Fan } 794e1bed802SPeng Fan 79571204e95SPeng Fan ret = i2c_idle_bus(i2c_bus); 79671204e95SPeng Fan if (ret < 0) { 79771204e95SPeng Fan /* Disable clk */ 79871204e95SPeng Fan enable_i2c_clk(0, bus->seq); 79971204e95SPeng Fan return ret; 80071204e95SPeng Fan } 80171204e95SPeng Fan 80271204e95SPeng Fan /* 80371204e95SPeng Fan * Pinmux settings are in board file now, until pinmux is supported, 80471204e95SPeng Fan * we can set pinmux here in probe function. 80571204e95SPeng Fan */ 80671204e95SPeng Fan 80771204e95SPeng Fan debug("i2c : controller bus %d at %lu , speed %d: ", 80871204e95SPeng Fan bus->seq, i2c_bus->base, 80971204e95SPeng Fan i2c_bus->speed); 81071204e95SPeng Fan 81171204e95SPeng Fan return 0; 81271204e95SPeng Fan } 81371204e95SPeng Fan 81471204e95SPeng Fan static int mxc_i2c_probe_chip(struct udevice *bus, u32 chip_addr, 81571204e95SPeng Fan u32 chip_flags) 81671204e95SPeng Fan { 81771204e95SPeng Fan int ret; 81871204e95SPeng Fan struct mxc_i2c_bus *i2c_bus = dev_get_priv(bus); 81971204e95SPeng Fan 82071204e95SPeng Fan ret = i2c_init_transfer(i2c_bus, chip_addr, 0, 0); 82171204e95SPeng Fan if (ret < 0) { 82271204e95SPeng Fan debug("%s failed, ret = %d\n", __func__, ret); 82371204e95SPeng Fan return ret; 82471204e95SPeng Fan } 82571204e95SPeng Fan 82671204e95SPeng Fan i2c_imx_stop(i2c_bus); 82771204e95SPeng Fan 82871204e95SPeng Fan return 0; 82971204e95SPeng Fan } 83071204e95SPeng Fan 83171204e95SPeng Fan static int mxc_i2c_xfer(struct udevice *bus, struct i2c_msg *msg, int nmsgs) 83271204e95SPeng Fan { 83371204e95SPeng Fan struct mxc_i2c_bus *i2c_bus = dev_get_priv(bus); 83471204e95SPeng Fan int ret = 0; 83571204e95SPeng Fan ulong base = i2c_bus->base; 83671204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 83771204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 83871204e95SPeng Fan 83971204e95SPeng Fan /* 84071204e95SPeng Fan * Here the 3rd parameter addr and the 4th one alen are set to 0, 84171204e95SPeng Fan * because here we only want to send out chip address. The register 84271204e95SPeng Fan * address is wrapped in msg. 84371204e95SPeng Fan */ 84471204e95SPeng Fan ret = i2c_init_transfer(i2c_bus, msg->addr, 0, 0); 84571204e95SPeng Fan if (ret < 0) { 84671204e95SPeng Fan debug("i2c_init_transfer error: %d\n", ret); 84771204e95SPeng Fan return ret; 84871204e95SPeng Fan } 84971204e95SPeng Fan 85071204e95SPeng Fan for (; nmsgs > 0; nmsgs--, msg++) { 85171204e95SPeng Fan bool next_is_read = nmsgs > 1 && (msg[1].flags & I2C_M_RD); 85271204e95SPeng Fan debug("i2c_xfer: chip=0x%x, len=0x%x\n", msg->addr, msg->len); 85371204e95SPeng Fan if (msg->flags & I2C_M_RD) 85471204e95SPeng Fan ret = i2c_read_data(i2c_bus, msg->addr, msg->buf, 85571204e95SPeng Fan msg->len); 85671204e95SPeng Fan else { 85771204e95SPeng Fan ret = i2c_write_data(i2c_bus, msg->addr, msg->buf, 85871204e95SPeng Fan msg->len); 85971204e95SPeng Fan if (ret) 86071204e95SPeng Fan break; 86171204e95SPeng Fan if (next_is_read) { 86271204e95SPeng Fan /* Reuse ret */ 86371204e95SPeng Fan ret = readb(base + (I2CR << reg_shift)); 86471204e95SPeng Fan ret |= I2CR_RSTA; 86571204e95SPeng Fan writeb(ret, base + (I2CR << reg_shift)); 86671204e95SPeng Fan 86771204e95SPeng Fan ret = tx_byte(i2c_bus, (msg->addr << 1) | 1); 86871204e95SPeng Fan if (ret < 0) { 86971204e95SPeng Fan i2c_imx_stop(i2c_bus); 87071204e95SPeng Fan break; 87171204e95SPeng Fan } 87271204e95SPeng Fan } 87371204e95SPeng Fan } 87471204e95SPeng Fan } 87571204e95SPeng Fan 87671204e95SPeng Fan if (ret) 87771204e95SPeng Fan debug("i2c_write: error sending\n"); 87871204e95SPeng Fan 87971204e95SPeng Fan i2c_imx_stop(i2c_bus); 88071204e95SPeng Fan 88171204e95SPeng Fan return ret; 88271204e95SPeng Fan } 88371204e95SPeng Fan 88471204e95SPeng Fan static const struct dm_i2c_ops mxc_i2c_ops = { 88571204e95SPeng Fan .xfer = mxc_i2c_xfer, 88671204e95SPeng Fan .probe_chip = mxc_i2c_probe_chip, 88771204e95SPeng Fan .set_bus_speed = mxc_i2c_set_bus_speed, 88871204e95SPeng Fan }; 88971204e95SPeng Fan 89071204e95SPeng Fan static const struct udevice_id mxc_i2c_ids[] = { 89171204e95SPeng Fan { .compatible = "fsl,imx21-i2c", }, 89271204e95SPeng Fan { .compatible = "fsl,vf610-i2c", .data = I2C_QUIRK_FLAG, }, 89371204e95SPeng Fan {} 89471204e95SPeng Fan }; 89571204e95SPeng Fan 89671204e95SPeng Fan U_BOOT_DRIVER(i2c_mxc) = { 89771204e95SPeng Fan .name = "i2c_mxc", 89871204e95SPeng Fan .id = UCLASS_I2C, 89971204e95SPeng Fan .of_match = mxc_i2c_ids, 90071204e95SPeng Fan .probe = mxc_i2c_probe, 90171204e95SPeng Fan .priv_auto_alloc_size = sizeof(struct mxc_i2c_bus), 90271204e95SPeng Fan .ops = &mxc_i2c_ops, 90371204e95SPeng Fan }; 90471204e95SPeng Fan #endif 905