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> 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> 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 72e4ff525fSTroy Kisky #if defined(CONFIG_HARD_I2C) && !defined(CONFIG_SYS_I2C_BASE) 73de6f604dSTroy Kisky #error "define CONFIG_SYS_I2C_BASE to use the mxc_i2c driver" 74cdace066SSascha Hauer #endif 75cdace066SSascha Hauer 7630ea41a4SAlison Wang #ifdef I2C_QUIRK_REG 7730ea41a4SAlison Wang static u16 i2c_clk_div[60][2] = { 7830ea41a4SAlison Wang { 20, 0x00 }, { 22, 0x01 }, { 24, 0x02 }, { 26, 0x03 }, 7930ea41a4SAlison Wang { 28, 0x04 }, { 30, 0x05 }, { 32, 0x09 }, { 34, 0x06 }, 8030ea41a4SAlison Wang { 36, 0x0A }, { 40, 0x07 }, { 44, 0x0C }, { 48, 0x0D }, 8130ea41a4SAlison Wang { 52, 0x43 }, { 56, 0x0E }, { 60, 0x45 }, { 64, 0x12 }, 8230ea41a4SAlison Wang { 68, 0x0F }, { 72, 0x13 }, { 80, 0x14 }, { 88, 0x15 }, 8330ea41a4SAlison Wang { 96, 0x19 }, { 104, 0x16 }, { 112, 0x1A }, { 128, 0x17 }, 8430ea41a4SAlison Wang { 136, 0x4F }, { 144, 0x1C }, { 160, 0x1D }, { 176, 0x55 }, 8530ea41a4SAlison Wang { 192, 0x1E }, { 208, 0x56 }, { 224, 0x22 }, { 228, 0x24 }, 8630ea41a4SAlison Wang { 240, 0x1F }, { 256, 0x23 }, { 288, 0x5C }, { 320, 0x25 }, 8730ea41a4SAlison Wang { 384, 0x26 }, { 448, 0x2A }, { 480, 0x27 }, { 512, 0x2B }, 8830ea41a4SAlison Wang { 576, 0x2C }, { 640, 0x2D }, { 768, 0x31 }, { 896, 0x32 }, 8930ea41a4SAlison Wang { 960, 0x2F }, { 1024, 0x33 }, { 1152, 0x34 }, { 1280, 0x35 }, 9030ea41a4SAlison Wang { 1536, 0x36 }, { 1792, 0x3A }, { 1920, 0x37 }, { 2048, 0x3B }, 9130ea41a4SAlison Wang { 2304, 0x3C }, { 2560, 0x3D }, { 3072, 0x3E }, { 3584, 0x7A }, 9230ea41a4SAlison Wang { 3840, 0x3F }, { 4096, 0x7B }, { 5120, 0x7D }, { 6144, 0x7E }, 9330ea41a4SAlison Wang }; 9430ea41a4SAlison Wang #else 95db84140bSMarek Vasut static u16 i2c_clk_div[50][2] = { 96db84140bSMarek Vasut { 22, 0x20 }, { 24, 0x21 }, { 26, 0x22 }, { 28, 0x23 }, 97db84140bSMarek Vasut { 30, 0x00 }, { 32, 0x24 }, { 36, 0x25 }, { 40, 0x26 }, 98db84140bSMarek Vasut { 42, 0x03 }, { 44, 0x27 }, { 48, 0x28 }, { 52, 0x05 }, 99db84140bSMarek Vasut { 56, 0x29 }, { 60, 0x06 }, { 64, 0x2A }, { 72, 0x2B }, 100db84140bSMarek Vasut { 80, 0x2C }, { 88, 0x09 }, { 96, 0x2D }, { 104, 0x0A }, 101db84140bSMarek Vasut { 112, 0x2E }, { 128, 0x2F }, { 144, 0x0C }, { 160, 0x30 }, 102db84140bSMarek Vasut { 192, 0x31 }, { 224, 0x32 }, { 240, 0x0F }, { 256, 0x33 }, 103db84140bSMarek Vasut { 288, 0x10 }, { 320, 0x34 }, { 384, 0x35 }, { 448, 0x36 }, 104db84140bSMarek Vasut { 480, 0x13 }, { 512, 0x37 }, { 576, 0x14 }, { 640, 0x38 }, 105db84140bSMarek Vasut { 768, 0x39 }, { 896, 0x3A }, { 960, 0x17 }, { 1024, 0x3B }, 106db84140bSMarek Vasut { 1152, 0x18 }, { 1280, 0x3C }, { 1536, 0x3D }, { 1792, 0x3E }, 107db84140bSMarek Vasut { 1920, 0x1B }, { 2048, 0x3F }, { 2304, 0x1C }, { 2560, 0x1D }, 108db84140bSMarek Vasut { 3072, 0x1E }, { 3840, 0x1F } 109db84140bSMarek Vasut }; 11030ea41a4SAlison Wang #endif 111cdace066SSascha Hauer 112fac96408Strem #ifndef CONFIG_SYS_MXC_I2C1_SPEED 113fac96408Strem #define CONFIG_SYS_MXC_I2C1_SPEED 100000 114fac96408Strem #endif 115fac96408Strem #ifndef CONFIG_SYS_MXC_I2C2_SPEED 116fac96408Strem #define CONFIG_SYS_MXC_I2C2_SPEED 100000 117fac96408Strem #endif 118fac96408Strem #ifndef CONFIG_SYS_MXC_I2C3_SPEED 119fac96408Strem #define CONFIG_SYS_MXC_I2C3_SPEED 100000 120fac96408Strem #endif 121f8cb101eSYork Sun #ifndef CONFIG_SYS_MXC_I2C4_SPEED 122f8cb101eSYork Sun #define CONFIG_SYS_MXC_I2C4_SPEED 100000 123f8cb101eSYork Sun #endif 124fac96408Strem 125fac96408Strem #ifndef CONFIG_SYS_MXC_I2C1_SLAVE 126fac96408Strem #define CONFIG_SYS_MXC_I2C1_SLAVE 0 127fac96408Strem #endif 128fac96408Strem #ifndef CONFIG_SYS_MXC_I2C2_SLAVE 129fac96408Strem #define CONFIG_SYS_MXC_I2C2_SLAVE 0 130fac96408Strem #endif 131fac96408Strem #ifndef CONFIG_SYS_MXC_I2C3_SLAVE 132fac96408Strem #define CONFIG_SYS_MXC_I2C3_SLAVE 0 133fac96408Strem #endif 134f8cb101eSYork Sun #ifndef CONFIG_SYS_MXC_I2C4_SLAVE 135f8cb101eSYork Sun #define CONFIG_SYS_MXC_I2C4_SLAVE 0 136f8cb101eSYork Sun #endif 137fac96408Strem 138db84140bSMarek Vasut /* 139db84140bSMarek Vasut * Calculate and set proper clock divider 140db84140bSMarek Vasut */ 14171204e95SPeng Fan static uint8_t i2c_imx_get_clk(struct mxc_i2c_bus *i2c_bus, unsigned int rate) 1421d549adeSStefano Babic { 143db84140bSMarek Vasut unsigned int i2c_clk_rate; 144db84140bSMarek Vasut unsigned int div; 145bf0783dfSMarek Vasut u8 clk_div; 146cdace066SSascha Hauer 147127cec18SLiu Hui-R64343 #if defined(CONFIG_MX31) 1481d549adeSStefano Babic struct clock_control_regs *sc_regs = 1491d549adeSStefano Babic (struct clock_control_regs *)CCM_BASE; 150db84140bSMarek Vasut 151e7de18afSGuennadi Liakhovetski /* start the required I2C clock */ 152de6f604dSTroy Kisky writel(readl(&sc_regs->cgr0) | (3 << CONFIG_SYS_I2C_CLK_OFFSET), 1531d549adeSStefano Babic &sc_regs->cgr0); 154127cec18SLiu Hui-R64343 #endif 155e7de18afSGuennadi Liakhovetski 156db84140bSMarek Vasut /* Divider value calculation */ 157e7bed5c2SMatthias Weisser i2c_clk_rate = mxc_get_clock(MXC_I2C_CLK); 158db84140bSMarek Vasut div = (i2c_clk_rate + rate - 1) / rate; 159db84140bSMarek Vasut if (div < i2c_clk_div[0][0]) 160b567b8ffSMarek Vasut clk_div = 0; 161db84140bSMarek Vasut else if (div > i2c_clk_div[ARRAY_SIZE(i2c_clk_div) - 1][0]) 162b567b8ffSMarek Vasut clk_div = ARRAY_SIZE(i2c_clk_div) - 1; 163db84140bSMarek Vasut else 164b567b8ffSMarek Vasut for (clk_div = 0; i2c_clk_div[clk_div][0] < div; clk_div++) 165db84140bSMarek Vasut ; 166cdace066SSascha Hauer 167db84140bSMarek Vasut /* Store divider value */ 168bf0783dfSMarek Vasut return clk_div; 169db84140bSMarek Vasut } 170cdace066SSascha Hauer 171db84140bSMarek Vasut /* 172e4ff525fSTroy Kisky * Set I2C Bus speed 173db84140bSMarek Vasut */ 17471204e95SPeng Fan static int bus_i2c_set_bus_speed(struct mxc_i2c_bus *i2c_bus, int speed) 175db84140bSMarek Vasut { 17671204e95SPeng Fan ulong base = i2c_bus->base; 17771204e95SPeng Fan bool quirk = i2c_bus->driver_data & I2C_QUIRK_FLAG ? true : false; 17871204e95SPeng Fan u8 clk_idx = i2c_imx_get_clk(i2c_bus, speed); 179bf0783dfSMarek Vasut u8 idx = i2c_clk_div[clk_idx][1]; 18071204e95SPeng Fan int reg_shift = quirk ? VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 181bf0783dfSMarek Vasut 182e6c8b716SHeiko Schocher if (!base) 183e6c8b716SHeiko Schocher return -ENODEV; 184e6c8b716SHeiko Schocher 185bf0783dfSMarek Vasut /* Store divider value */ 18671204e95SPeng Fan writeb(idx, base + (IFDR << reg_shift)); 187bf0783dfSMarek Vasut 18883a1a190STroy Kisky /* Reset module */ 18971204e95SPeng Fan writeb(I2CR_IDIS, base + (I2CR << reg_shift)); 19071204e95SPeng Fan writeb(0, base + (I2SR << reg_shift)); 191b567b8ffSMarek Vasut return 0; 192b567b8ffSMarek Vasut } 193b567b8ffSMarek Vasut 1947aa57a01STroy Kisky #define ST_BUS_IDLE (0 | (I2SR_IBB << 8)) 1957aa57a01STroy Kisky #define ST_BUS_BUSY (I2SR_IBB | (I2SR_IBB << 8)) 1967aa57a01STroy Kisky #define ST_IIF (I2SR_IIF | (I2SR_IIF << 8)) 1977aa57a01STroy Kisky 19871204e95SPeng Fan static int wait_for_sr_state(struct mxc_i2c_bus *i2c_bus, unsigned state) 19981687212SStefano Babic { 2007aa57a01STroy Kisky unsigned sr; 2017aa57a01STroy Kisky ulong elapsed; 20271204e95SPeng Fan bool quirk = i2c_bus->driver_data & I2C_QUIRK_FLAG ? true : false; 20371204e95SPeng Fan int reg_shift = quirk ? VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 20471204e95SPeng Fan ulong base = i2c_bus->base; 2057aa57a01STroy Kisky ulong start_time = get_timer(0); 2067aa57a01STroy Kisky for (;;) { 20771204e95SPeng Fan sr = readb(base + (I2SR << reg_shift)); 208d5383a63STroy Kisky if (sr & I2SR_IAL) { 20971204e95SPeng Fan if (quirk) 21071204e95SPeng Fan writeb(sr | I2SR_IAL, base + 21171204e95SPeng Fan (I2SR << reg_shift)); 21271204e95SPeng Fan else 21371204e95SPeng Fan writeb(sr & ~I2SR_IAL, base + 21471204e95SPeng Fan (I2SR << reg_shift)); 215d5383a63STroy Kisky printf("%s: Arbitration lost sr=%x cr=%x state=%x\n", 21671204e95SPeng Fan __func__, sr, readb(base + (I2CR << reg_shift)), 21771204e95SPeng Fan state); 218d5383a63STroy Kisky return -ERESTART; 219d5383a63STroy Kisky } 2207aa57a01STroy Kisky if ((sr & (state >> 8)) == (unsigned char)state) 2217aa57a01STroy Kisky return sr; 2227aa57a01STroy Kisky WATCHDOG_RESET(); 2237aa57a01STroy Kisky elapsed = get_timer(start_time); 2247aa57a01STroy Kisky if (elapsed > (CONFIG_SYS_HZ / 10)) /* .1 seconds */ 2257aa57a01STroy Kisky break; 22681687212SStefano Babic } 2277aa57a01STroy Kisky printf("%s: failed sr=%x cr=%x state=%x\n", __func__, 22871204e95SPeng Fan sr, readb(base + (I2CR << reg_shift)), state); 229cea60b0cSTroy Kisky return -ETIMEDOUT; 230db84140bSMarek Vasut } 231db84140bSMarek Vasut 23271204e95SPeng Fan static int tx_byte(struct mxc_i2c_bus *i2c_bus, u8 byte) 233cdace066SSascha Hauer { 234cea60b0cSTroy Kisky int ret; 23571204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 23671204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 23771204e95SPeng Fan ulong base = i2c_bus->base; 238db84140bSMarek Vasut 23971204e95SPeng Fan writeb(I2SR_IIF_CLEAR, base + (I2SR << reg_shift)); 24071204e95SPeng Fan writeb(byte, base + (I2DR << reg_shift)); 24171204e95SPeng Fan 24271204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_IIF); 243cea60b0cSTroy Kisky if (ret < 0) 244cea60b0cSTroy Kisky return ret; 245cea60b0cSTroy Kisky if (ret & I2SR_RX_NO_AK) 246cea60b0cSTroy Kisky return -ENODEV; 247cea60b0cSTroy Kisky return 0; 248db84140bSMarek Vasut } 249db84140bSMarek Vasut 250db84140bSMarek Vasut /* 25171204e95SPeng Fan * Stub implementations for outer i2c slave operations. 25271204e95SPeng Fan */ 25371204e95SPeng Fan void __i2c_force_reset_slave(void) 25471204e95SPeng Fan { 25571204e95SPeng Fan } 25671204e95SPeng Fan void i2c_force_reset_slave(void) 25771204e95SPeng Fan __attribute__((weak, alias("__i2c_force_reset_slave"))); 25871204e95SPeng Fan 25971204e95SPeng Fan /* 26090a5b70fSTroy Kisky * Stop I2C transaction 261db84140bSMarek Vasut */ 26271204e95SPeng Fan static void i2c_imx_stop(struct mxc_i2c_bus *i2c_bus) 263db84140bSMarek Vasut { 2647aa57a01STroy Kisky int ret; 26571204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 26671204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 26771204e95SPeng Fan ulong base = i2c_bus->base; 26871204e95SPeng Fan unsigned int temp = readb(base + (I2CR << reg_shift)); 269db84140bSMarek Vasut 2701c076dbaSTroy Kisky temp &= ~(I2CR_MSTA | I2CR_MTX); 27171204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 27271204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_BUS_IDLE); 2737aa57a01STroy Kisky if (ret < 0) 2747aa57a01STroy Kisky printf("%s:trigger stop failed\n", __func__); 275db84140bSMarek Vasut } 276db84140bSMarek Vasut 277db84140bSMarek Vasut /* 278b230ddc2STroy Kisky * Send start signal, chip address and 279b230ddc2STroy Kisky * write register address 280db84140bSMarek Vasut */ 28171204e95SPeng Fan static int i2c_init_transfer_(struct mxc_i2c_bus *i2c_bus, u8 chip, 28271204e95SPeng Fan u32 addr, int alen) 283cdace066SSascha Hauer { 28471e9f3cbSTroy Kisky unsigned int temp; 28571e9f3cbSTroy Kisky int ret; 28671204e95SPeng Fan bool quirk = i2c_bus->driver_data & I2C_QUIRK_FLAG ? true : false; 28771204e95SPeng Fan ulong base = i2c_bus->base; 28871204e95SPeng Fan int reg_shift = quirk ? VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 28971204e95SPeng Fan 29071204e95SPeng Fan /* Reset i2c slave */ 29171204e95SPeng Fan i2c_force_reset_slave(); 29271e9f3cbSTroy Kisky 29371e9f3cbSTroy Kisky /* Enable I2C controller */ 29471204e95SPeng Fan if (quirk) 29571204e95SPeng Fan ret = readb(base + (I2CR << reg_shift)) & I2CR_IDIS; 29671204e95SPeng Fan else 29771204e95SPeng Fan ret = !(readb(base + (I2CR << reg_shift)) & I2CR_IEN); 29871204e95SPeng Fan 29971204e95SPeng Fan if (ret) { 30071204e95SPeng Fan writeb(I2CR_IEN, base + (I2CR << reg_shift)); 30171e9f3cbSTroy Kisky /* Wait for controller to be stable */ 30271e9f3cbSTroy Kisky udelay(50); 30390a5b70fSTroy Kisky } 30471204e95SPeng Fan 30571204e95SPeng Fan if (readb(base + (IADR << reg_shift)) == (chip << 1)) 30671204e95SPeng Fan writeb((chip << 1) ^ 2, base + (IADR << reg_shift)); 30771204e95SPeng Fan writeb(I2SR_IIF_CLEAR, base + (I2SR << reg_shift)); 30871204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_BUS_IDLE); 30990a5b70fSTroy Kisky if (ret < 0) 310a7f1a005STroy Kisky return ret; 31171e9f3cbSTroy Kisky 31271e9f3cbSTroy Kisky /* Start I2C transaction */ 31371204e95SPeng Fan temp = readb(base + (I2CR << reg_shift)); 31471e9f3cbSTroy Kisky temp |= I2CR_MSTA; 31571204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 31671e9f3cbSTroy Kisky 31771204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_BUS_BUSY); 31871e9f3cbSTroy Kisky if (ret < 0) 319a7f1a005STroy Kisky return ret; 320b230ddc2STroy Kisky 32171e9f3cbSTroy Kisky temp |= I2CR_MTX | I2CR_TX_NO_AK; 32271204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 32371e9f3cbSTroy Kisky 324b230ddc2STroy Kisky /* write slave address */ 32571204e95SPeng Fan ret = tx_byte(i2c_bus, chip << 1); 326b230ddc2STroy Kisky if (ret < 0) 327a7f1a005STroy Kisky return ret; 328db84140bSMarek Vasut 329bf0783dfSMarek Vasut while (alen--) { 33071204e95SPeng Fan ret = tx_byte(i2c_bus, (addr >> (alen * 8)) & 0xff); 331cea60b0cSTroy Kisky if (ret < 0) 332a7f1a005STroy Kisky return ret; 33381687212SStefano Babic } 334b230ddc2STroy Kisky return 0; 335a7f1a005STroy Kisky } 336a7f1a005STroy Kisky 33771204e95SPeng Fan #ifndef CONFIG_DM_I2C 33871204e95SPeng Fan int i2c_idle_bus(struct mxc_i2c_bus *i2c_bus) 33971204e95SPeng Fan { 34071204e95SPeng Fan if (i2c_bus && i2c_bus->idle_bus_fn) 34171204e95SPeng Fan return i2c_bus->idle_bus_fn(i2c_bus->idle_bus_data); 34271204e95SPeng Fan return 0; 34371204e95SPeng Fan } 34471204e95SPeng Fan #else 34571204e95SPeng Fan /* 346e1bed802SPeng Fan * See Linux Documentation/devicetree/bindings/i2c/i2c-imx.txt 347e1bed802SPeng Fan * " 348e1bed802SPeng Fan * scl-gpios: specify the gpio related to SCL pin 349e1bed802SPeng Fan * sda-gpios: specify the gpio related to SDA pin 350e1bed802SPeng Fan * add pinctrl to configure i2c pins to gpio function for i2c 351e1bed802SPeng Fan * bus recovery, call it "gpio" state 352e1bed802SPeng Fan * " 353e1bed802SPeng Fan * 354e1bed802SPeng Fan * The i2c_idle_bus is an implementation following Linux Kernel. 35571204e95SPeng Fan */ 356e1bed802SPeng Fan int i2c_idle_bus(struct mxc_i2c_bus *i2c_bus) 35771204e95SPeng Fan { 358e1bed802SPeng Fan struct udevice *bus = i2c_bus->bus; 359e1bed802SPeng Fan struct gpio_desc *scl_gpio = &i2c_bus->scl_gpio; 360e1bed802SPeng Fan struct gpio_desc *sda_gpio = &i2c_bus->sda_gpio; 361e1bed802SPeng Fan int sda, scl; 362e1bed802SPeng Fan int i, ret = 0; 363e1bed802SPeng Fan ulong elapsed, start_time; 364e1bed802SPeng Fan 365e1bed802SPeng Fan if (pinctrl_select_state(bus, "gpio")) { 366e1bed802SPeng Fan dev_dbg(bus, "Can not to switch to use gpio pinmux\n"); 367e1bed802SPeng Fan /* 368e1bed802SPeng Fan * GPIO pinctrl for i2c force idle is not a must, 369e1bed802SPeng Fan * but it is strongly recommended to be used. 370e1bed802SPeng Fan * Because it can help you to recover from bad 371e1bed802SPeng Fan * i2c bus state. Do not return failure, because 372e1bed802SPeng Fan * it is not a must. 373e1bed802SPeng Fan */ 37471204e95SPeng Fan return 0; 37571204e95SPeng Fan } 37696c19bd3STroy Kisky 377e1bed802SPeng Fan dm_gpio_set_dir_flags(scl_gpio, GPIOD_IS_IN); 378e1bed802SPeng Fan dm_gpio_set_dir_flags(sda_gpio, GPIOD_IS_IN); 379e1bed802SPeng Fan scl = dm_gpio_get_value(scl_gpio); 380e1bed802SPeng Fan sda = dm_gpio_get_value(sda_gpio); 381e1bed802SPeng Fan 382e1bed802SPeng Fan if ((sda & scl) == 1) 383e1bed802SPeng Fan goto exit; /* Bus is idle already */ 384e1bed802SPeng Fan 385e1bed802SPeng Fan /* Send high and low on the SCL line */ 386e1bed802SPeng Fan for (i = 0; i < 9; i++) { 387e1bed802SPeng Fan dm_gpio_set_dir_flags(scl_gpio, GPIOD_IS_OUT); 388e1bed802SPeng Fan dm_gpio_set_value(scl_gpio, 0); 389e1bed802SPeng Fan udelay(50); 390e1bed802SPeng Fan dm_gpio_set_dir_flags(scl_gpio, GPIOD_IS_IN); 391e1bed802SPeng Fan udelay(50); 392e1bed802SPeng Fan } 393e1bed802SPeng Fan start_time = get_timer(0); 394e1bed802SPeng Fan for (;;) { 395e1bed802SPeng Fan dm_gpio_set_dir_flags(scl_gpio, GPIOD_IS_IN); 396e1bed802SPeng Fan dm_gpio_set_dir_flags(sda_gpio, GPIOD_IS_IN); 397e1bed802SPeng Fan scl = dm_gpio_get_value(scl_gpio); 398e1bed802SPeng Fan sda = dm_gpio_get_value(sda_gpio); 399e1bed802SPeng Fan if ((sda & scl) == 1) 400e1bed802SPeng Fan break; 401e1bed802SPeng Fan WATCHDOG_RESET(); 402e1bed802SPeng Fan elapsed = get_timer(start_time); 403e1bed802SPeng Fan if (elapsed > (CONFIG_SYS_HZ / 5)) { /* .2 seconds */ 404e1bed802SPeng Fan ret = -EBUSY; 405e1bed802SPeng Fan printf("%s: failed to clear bus, sda=%d scl=%d\n", __func__, sda, scl); 406e1bed802SPeng Fan break; 407e1bed802SPeng Fan } 408e1bed802SPeng Fan } 409e1bed802SPeng Fan 410e1bed802SPeng Fan exit: 411e1bed802SPeng Fan pinctrl_select_state(bus, "default"); 412e1bed802SPeng Fan return ret; 413e1bed802SPeng Fan } 41471204e95SPeng Fan #endif 41571204e95SPeng Fan 41671204e95SPeng Fan static int i2c_init_transfer(struct mxc_i2c_bus *i2c_bus, u8 chip, 41771204e95SPeng Fan u32 addr, int alen) 418a7f1a005STroy Kisky { 419a7f1a005STroy Kisky int retry; 420a7f1a005STroy Kisky int ret; 42171204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 42271204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 423e6c8b716SHeiko Schocher 424e6c8b716SHeiko Schocher if (!i2c_bus->base) 425e6c8b716SHeiko Schocher return -ENODEV; 426e6c8b716SHeiko Schocher 427a7f1a005STroy Kisky for (retry = 0; retry < 3; retry++) { 42871204e95SPeng Fan ret = i2c_init_transfer_(i2c_bus, chip, addr, alen); 429a7f1a005STroy Kisky if (ret >= 0) 430a7f1a005STroy Kisky return 0; 43171204e95SPeng Fan i2c_imx_stop(i2c_bus); 432a7f1a005STroy Kisky if (ret == -ENODEV) 433a7f1a005STroy Kisky return ret; 434a7f1a005STroy Kisky 435a7f1a005STroy Kisky printf("%s: failed for chip 0x%x retry=%d\n", __func__, chip, 436a7f1a005STroy Kisky retry); 437a7f1a005STroy Kisky if (ret != -ERESTART) 43830ea41a4SAlison Wang /* Disable controller */ 43971204e95SPeng Fan writeb(I2CR_IDIS, i2c_bus->base + (I2CR << reg_shift)); 440a7f1a005STroy Kisky udelay(100); 44171204e95SPeng Fan if (i2c_idle_bus(i2c_bus) < 0) 44296c19bd3STroy Kisky break; 443a7f1a005STroy Kisky } 44471204e95SPeng Fan printf("%s: give up i2c_regs=0x%lx\n", __func__, i2c_bus->base); 445db84140bSMarek Vasut return ret; 446cdace066SSascha Hauer } 447cdace066SSascha Hauer 44871204e95SPeng Fan 44971204e95SPeng Fan static int i2c_write_data(struct mxc_i2c_bus *i2c_bus, u8 chip, const u8 *buf, 45071204e95SPeng Fan int len) 45171204e95SPeng Fan { 45271204e95SPeng Fan int i, ret = 0; 45371204e95SPeng Fan 45471204e95SPeng Fan debug("i2c_write_data: chip=0x%x, len=0x%x\n", chip, len); 45571204e95SPeng Fan debug("write_data: "); 45671204e95SPeng Fan /* use rc for counter */ 45771204e95SPeng Fan for (i = 0; i < len; ++i) 45871204e95SPeng Fan debug(" 0x%02x", buf[i]); 45971204e95SPeng Fan debug("\n"); 46071204e95SPeng Fan 46171204e95SPeng Fan for (i = 0; i < len; i++) { 46271204e95SPeng Fan ret = tx_byte(i2c_bus, buf[i]); 46371204e95SPeng Fan if (ret < 0) { 46471204e95SPeng Fan debug("i2c_write_data(): rc=%d\n", ret); 46571204e95SPeng Fan break; 46671204e95SPeng Fan } 46771204e95SPeng Fan } 46871204e95SPeng Fan 46971204e95SPeng Fan return ret; 47071204e95SPeng Fan } 47171204e95SPeng Fan 47271204e95SPeng Fan static int i2c_read_data(struct mxc_i2c_bus *i2c_bus, uchar chip, uchar *buf, 473e4ff525fSTroy Kisky int len) 474db84140bSMarek Vasut { 475db84140bSMarek Vasut int ret; 476db84140bSMarek Vasut unsigned int temp; 477db84140bSMarek Vasut int i; 47871204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 47971204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 48071204e95SPeng Fan ulong base = i2c_bus->base; 481cdace066SSascha Hauer 48271204e95SPeng Fan debug("i2c_read_data: chip=0x%x, len=0x%x\n", chip, len); 483db84140bSMarek Vasut 484db84140bSMarek Vasut /* setup bus to read data */ 48571204e95SPeng Fan temp = readb(base + (I2CR << reg_shift)); 486db84140bSMarek Vasut temp &= ~(I2CR_MTX | I2CR_TX_NO_AK); 487db84140bSMarek Vasut if (len == 1) 488db84140bSMarek Vasut temp |= I2CR_TX_NO_AK; 48971204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 49071204e95SPeng Fan writeb(I2SR_IIF_CLEAR, base + (I2SR << reg_shift)); 49171204e95SPeng Fan /* dummy read to clear ICF */ 49271204e95SPeng Fan readb(base + (I2DR << reg_shift)); 493db84140bSMarek Vasut 494db84140bSMarek Vasut /* read data */ 495db84140bSMarek Vasut for (i = 0; i < len; i++) { 49671204e95SPeng Fan ret = wait_for_sr_state(i2c_bus, ST_IIF); 4977aa57a01STroy Kisky if (ret < 0) { 49871204e95SPeng Fan debug("i2c_read_data(): ret=%d\n", ret); 49971204e95SPeng Fan i2c_imx_stop(i2c_bus); 500db84140bSMarek Vasut return ret; 501c4330d28STroy Kisky } 502db84140bSMarek Vasut 503db84140bSMarek Vasut /* 504db84140bSMarek Vasut * It must generate STOP before read I2DR to prevent 505db84140bSMarek Vasut * controller from generating another clock cycle 506db84140bSMarek Vasut */ 507db84140bSMarek Vasut if (i == (len - 1)) { 50871204e95SPeng Fan i2c_imx_stop(i2c_bus); 509db84140bSMarek Vasut } else if (i == (len - 2)) { 51071204e95SPeng Fan temp = readb(base + (I2CR << reg_shift)); 511db84140bSMarek Vasut temp |= I2CR_TX_NO_AK; 51271204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 513cdace066SSascha Hauer } 51471204e95SPeng Fan writeb(I2SR_IIF_CLEAR, base + (I2SR << reg_shift)); 51571204e95SPeng Fan buf[i] = readb(base + (I2DR << reg_shift)); 516cdace066SSascha Hauer } 51771204e95SPeng Fan 51871204e95SPeng Fan /* reuse ret for counter*/ 51971204e95SPeng Fan for (ret = 0; ret < len; ++ret) 52071204e95SPeng Fan debug(" 0x%02x", buf[ret]); 52171204e95SPeng Fan debug("\n"); 52271204e95SPeng Fan 52371204e95SPeng Fan i2c_imx_stop(i2c_bus); 5247aa57a01STroy Kisky return 0; 525db84140bSMarek Vasut } 526db84140bSMarek Vasut 52771204e95SPeng Fan #ifndef CONFIG_DM_I2C 52871204e95SPeng Fan /* 52971204e95SPeng Fan * Read data from I2C device 53071204e95SPeng Fan */ 53171204e95SPeng Fan static int bus_i2c_read(struct mxc_i2c_bus *i2c_bus, u8 chip, u32 addr, 53271204e95SPeng Fan int alen, u8 *buf, int len) 53371204e95SPeng Fan { 53471204e95SPeng Fan int ret = 0; 53571204e95SPeng Fan u32 temp; 53671204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 53771204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 53871204e95SPeng Fan ulong base = i2c_bus->base; 53971204e95SPeng Fan 54071204e95SPeng Fan ret = i2c_init_transfer(i2c_bus, chip, addr, alen); 54171204e95SPeng Fan if (ret < 0) 54271204e95SPeng Fan return ret; 54371204e95SPeng Fan 54471204e95SPeng Fan temp = readb(base + (I2CR << reg_shift)); 54571204e95SPeng Fan temp |= I2CR_RSTA; 54671204e95SPeng Fan writeb(temp, base + (I2CR << reg_shift)); 54771204e95SPeng Fan 54871204e95SPeng Fan ret = tx_byte(i2c_bus, (chip << 1) | 1); 54971204e95SPeng Fan if (ret < 0) { 55071204e95SPeng Fan i2c_imx_stop(i2c_bus); 55171204e95SPeng Fan return ret; 55271204e95SPeng Fan } 55371204e95SPeng Fan 55471204e95SPeng Fan ret = i2c_read_data(i2c_bus, chip, buf, len); 55571204e95SPeng Fan 55671204e95SPeng Fan i2c_imx_stop(i2c_bus); 55771204e95SPeng Fan return ret; 55871204e95SPeng Fan } 55971204e95SPeng Fan 560db84140bSMarek Vasut /* 561db84140bSMarek Vasut * Write data to I2C device 562db84140bSMarek Vasut */ 56371204e95SPeng Fan static int bus_i2c_write(struct mxc_i2c_bus *i2c_bus, u8 chip, u32 addr, 56471204e95SPeng Fan int alen, const u8 *buf, int len) 565cdace066SSascha Hauer { 56671204e95SPeng Fan int ret = 0; 567cdace066SSascha Hauer 56871204e95SPeng Fan ret = i2c_init_transfer(i2c_bus, chip, addr, alen); 569cea60b0cSTroy Kisky if (ret < 0) 570db84140bSMarek Vasut return ret; 571cdace066SSascha Hauer 57271204e95SPeng Fan ret = i2c_write_data(i2c_bus, chip, buf, len); 57371204e95SPeng Fan 57471204e95SPeng Fan i2c_imx_stop(i2c_bus); 57571204e95SPeng Fan 576db84140bSMarek Vasut return ret; 577db84140bSMarek Vasut } 578cfbb88d3STroy Kisky 579e6c8b716SHeiko Schocher #if !defined(I2C2_BASE_ADDR) 580e6c8b716SHeiko Schocher #define I2C2_BASE_ADDR 0 58121a26940SHeiko Schocher #endif 582e6c8b716SHeiko Schocher 583e6c8b716SHeiko Schocher #if !defined(I2C3_BASE_ADDR) 584e6c8b716SHeiko Schocher #define I2C3_BASE_ADDR 0 585e6c8b716SHeiko Schocher #endif 586e6c8b716SHeiko Schocher 587e6c8b716SHeiko Schocher #if !defined(I2C4_BASE_ADDR) 588e6c8b716SHeiko Schocher #define I2C4_BASE_ADDR 0 589e6c8b716SHeiko Schocher #endif 590e6c8b716SHeiko Schocher 591e6c8b716SHeiko Schocher static struct mxc_i2c_bus mxc_i2c_buses[] = { 5929f3183d2SMingkai Hu #if defined(CONFIG_LS102XA) || defined(CONFIG_VF610) || \ 5939f3183d2SMingkai Hu defined(CONFIG_FSL_LAYERSCAPE) 59471204e95SPeng Fan { 0, I2C1_BASE_ADDR, I2C_QUIRK_FLAG }, 59571204e95SPeng Fan { 1, I2C2_BASE_ADDR, I2C_QUIRK_FLAG }, 59671204e95SPeng Fan { 2, I2C3_BASE_ADDR, I2C_QUIRK_FLAG }, 59771204e95SPeng Fan { 3, I2C4_BASE_ADDR, I2C_QUIRK_FLAG }, 598e4ff525fSTroy Kisky #else 599e6c8b716SHeiko Schocher { 0, I2C1_BASE_ADDR, 0 }, 600e6c8b716SHeiko Schocher { 1, I2C2_BASE_ADDR, 0 }, 601e6c8b716SHeiko Schocher { 2, I2C3_BASE_ADDR, 0 }, 602e6c8b716SHeiko Schocher { 3, I2C4_BASE_ADDR, 0 }, 603e4ff525fSTroy Kisky #endif 604fac96408Strem }; 605fac96408Strem 60671204e95SPeng Fan struct mxc_i2c_bus *i2c_get_base(struct i2c_adapter *adap) 607fac96408Strem { 60871204e95SPeng Fan return &mxc_i2c_buses[adap->hwadapnr]; 60996c19bd3STroy Kisky } 61096c19bd3STroy Kisky 611fac96408Strem static int mxc_i2c_read(struct i2c_adapter *adap, uint8_t chip, 612fac96408Strem uint addr, int alen, uint8_t *buffer, 613fac96408Strem int len) 6149815326dSTroy Kisky { 615fac96408Strem return bus_i2c_read(i2c_get_base(adap), chip, addr, alen, buffer, len); 6169815326dSTroy Kisky } 6179815326dSTroy Kisky 618fac96408Strem static int mxc_i2c_write(struct i2c_adapter *adap, uint8_t chip, 619fac96408Strem uint addr, int alen, uint8_t *buffer, 620fac96408Strem int len) 6219815326dSTroy Kisky { 622fac96408Strem return bus_i2c_write(i2c_get_base(adap), chip, addr, alen, buffer, len); 623e4ff525fSTroy Kisky } 624e4ff525fSTroy Kisky 625cfbb88d3STroy Kisky /* 626cfbb88d3STroy Kisky * Test if a chip at a given address responds (probe the chip) 627cfbb88d3STroy Kisky */ 628fac96408Strem static int mxc_i2c_probe(struct i2c_adapter *adap, uint8_t chip) 629cfbb88d3STroy Kisky { 630fac96408Strem return bus_i2c_write(i2c_get_base(adap), chip, 0, 0, NULL, 0); 631e4ff525fSTroy Kisky } 632e4ff525fSTroy Kisky 63371204e95SPeng Fan int __enable_i2c_clk(unsigned char enable, unsigned i2c_num) 63471204e95SPeng Fan { 63571204e95SPeng Fan return 1; 63671204e95SPeng Fan } 63771204e95SPeng Fan int enable_i2c_clk(unsigned char enable, unsigned i2c_num) 63871204e95SPeng Fan __attribute__((weak, alias("__enable_i2c_clk"))); 63971204e95SPeng Fan 64071204e95SPeng Fan void bus_i2c_init(int index, int speed, int unused, 641e4ff525fSTroy Kisky int (*idle_bus_fn)(void *p), void *idle_bus_data) 642e4ff525fSTroy Kisky { 64371204e95SPeng Fan int ret; 64471204e95SPeng Fan 64571204e95SPeng Fan if (index >= ARRAY_SIZE(mxc_i2c_buses)) { 64671204e95SPeng Fan debug("Error i2c index\n"); 647e4ff525fSTroy Kisky return; 648e4ff525fSTroy Kisky } 64971204e95SPeng Fan 650aee3fddbSGong Qianyu /* 651aee3fddbSGong Qianyu * Warning: Be careful to allow the assignment to a static 652aee3fddbSGong Qianyu * variable here. This function could be called while U-Boot is 653aee3fddbSGong Qianyu * still running in flash memory. So such assignment is equal 654aee3fddbSGong Qianyu * to write data to flash without erasing. 655aee3fddbSGong Qianyu */ 656aee3fddbSGong Qianyu if (idle_bus_fn) 65771204e95SPeng Fan mxc_i2c_buses[index].idle_bus_fn = idle_bus_fn; 658aee3fddbSGong Qianyu if (idle_bus_data) 65971204e95SPeng Fan mxc_i2c_buses[index].idle_bus_data = idle_bus_data; 66071204e95SPeng Fan 66171204e95SPeng Fan ret = enable_i2c_clk(1, index); 66271204e95SPeng Fan if (ret < 0) { 66371204e95SPeng Fan debug("I2C-%d clk fail to enable.\n", index); 66471204e95SPeng Fan return; 66571204e95SPeng Fan } 66671204e95SPeng Fan 66771204e95SPeng Fan bus_i2c_set_bus_speed(&mxc_i2c_buses[index], speed); 668e4ff525fSTroy Kisky } 669e4ff525fSTroy Kisky 670e4ff525fSTroy Kisky /* 6719d10c2d3SYuan Yao * Early init I2C for prepare read the clk through I2C. 6729d10c2d3SYuan Yao */ 6739d10c2d3SYuan Yao void i2c_early_init_f(void) 6749d10c2d3SYuan Yao { 6759d10c2d3SYuan Yao ulong base = mxc_i2c_buses[I2C_EARLY_INIT_INDEX].base; 6769d10c2d3SYuan Yao bool quirk = mxc_i2c_buses[I2C_EARLY_INIT_INDEX].driver_data 6779d10c2d3SYuan Yao & I2C_QUIRK_FLAG ? true : false; 6789d10c2d3SYuan Yao int reg_shift = quirk ? VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 6799d10c2d3SYuan Yao 6809d10c2d3SYuan Yao /* Set I2C divider value */ 6819d10c2d3SYuan Yao writeb(I2C_IFDR_DIV_CONSERVATIVE, base + (IFDR << reg_shift)); 6829d10c2d3SYuan Yao /* Reset module */ 6839d10c2d3SYuan Yao writeb(I2CR_IDIS, base + (I2CR << reg_shift)); 6849d10c2d3SYuan Yao writeb(0, base + (I2SR << reg_shift)); 6859d10c2d3SYuan Yao /* Enable I2C */ 6869d10c2d3SYuan Yao writeb(I2CR_IEN, base + (I2CR << reg_shift)); 6879d10c2d3SYuan Yao } 6889d10c2d3SYuan Yao 6899d10c2d3SYuan Yao /* 690e4ff525fSTroy Kisky * Init I2C Bus 691e4ff525fSTroy Kisky */ 692fac96408Strem static void mxc_i2c_init(struct i2c_adapter *adap, int speed, int slaveaddr) 693e4ff525fSTroy Kisky { 69471204e95SPeng Fan bus_i2c_init(adap->hwadapnr, speed, slaveaddr, NULL, NULL); 695e4ff525fSTroy Kisky } 696e4ff525fSTroy Kisky 697e4ff525fSTroy Kisky /* 698e4ff525fSTroy Kisky * Set I2C Speed 699e4ff525fSTroy Kisky */ 70071204e95SPeng Fan static u32 mxc_i2c_set_bus_speed(struct i2c_adapter *adap, uint speed) 701e4ff525fSTroy Kisky { 702fac96408Strem return bus_i2c_set_bus_speed(i2c_get_base(adap), speed); 703e4ff525fSTroy Kisky } 704e4ff525fSTroy Kisky 705e4ff525fSTroy Kisky /* 706fac96408Strem * Register mxc i2c adapters 707e4ff525fSTroy Kisky */ 70803544c66SAlbert ARIBAUD \\(3ADEV\\) #ifdef CONFIG_SYS_I2C_MXC_I2C1 709fac96408Strem U_BOOT_I2C_ADAP_COMPLETE(mxc0, mxc_i2c_init, mxc_i2c_probe, 710fac96408Strem mxc_i2c_read, mxc_i2c_write, 711fac96408Strem mxc_i2c_set_bus_speed, 712fac96408Strem CONFIG_SYS_MXC_I2C1_SPEED, 713fac96408Strem CONFIG_SYS_MXC_I2C1_SLAVE, 0) 71403544c66SAlbert ARIBAUD \\(3ADEV\\) #endif 71503544c66SAlbert ARIBAUD \\(3ADEV\\) 71603544c66SAlbert ARIBAUD \\(3ADEV\\) #ifdef CONFIG_SYS_I2C_MXC_I2C2 717fac96408Strem U_BOOT_I2C_ADAP_COMPLETE(mxc1, mxc_i2c_init, mxc_i2c_probe, 718fac96408Strem mxc_i2c_read, mxc_i2c_write, 719fac96408Strem mxc_i2c_set_bus_speed, 720fac96408Strem CONFIG_SYS_MXC_I2C2_SPEED, 721fac96408Strem CONFIG_SYS_MXC_I2C2_SLAVE, 1) 72203544c66SAlbert ARIBAUD \\(3ADEV\\) #endif 72303544c66SAlbert ARIBAUD \\(3ADEV\\) 724f8cb101eSYork Sun #ifdef CONFIG_SYS_I2C_MXC_I2C3 725fac96408Strem U_BOOT_I2C_ADAP_COMPLETE(mxc2, mxc_i2c_init, mxc_i2c_probe, 726fac96408Strem mxc_i2c_read, mxc_i2c_write, 727fac96408Strem mxc_i2c_set_bus_speed, 728fac96408Strem CONFIG_SYS_MXC_I2C3_SPEED, 729fac96408Strem CONFIG_SYS_MXC_I2C3_SLAVE, 2) 730fac96408Strem #endif 73171204e95SPeng Fan 732f8cb101eSYork Sun #ifdef CONFIG_SYS_I2C_MXC_I2C4 733f8cb101eSYork Sun U_BOOT_I2C_ADAP_COMPLETE(mxc3, mxc_i2c_init, mxc_i2c_probe, 734f8cb101eSYork Sun mxc_i2c_read, mxc_i2c_write, 735f8cb101eSYork Sun mxc_i2c_set_bus_speed, 736f8cb101eSYork Sun CONFIG_SYS_MXC_I2C4_SPEED, 737f8cb101eSYork Sun CONFIG_SYS_MXC_I2C4_SLAVE, 3) 738f8cb101eSYork Sun #endif 73971204e95SPeng Fan 74071204e95SPeng Fan #else 74171204e95SPeng Fan 74271204e95SPeng Fan static int mxc_i2c_set_bus_speed(struct udevice *bus, unsigned int speed) 74371204e95SPeng Fan { 74471204e95SPeng Fan struct mxc_i2c_bus *i2c_bus = dev_get_priv(bus); 74571204e95SPeng Fan 74671204e95SPeng Fan return bus_i2c_set_bus_speed(i2c_bus, speed); 74771204e95SPeng Fan } 74871204e95SPeng Fan 74971204e95SPeng Fan static int mxc_i2c_probe(struct udevice *bus) 75071204e95SPeng Fan { 75171204e95SPeng Fan struct mxc_i2c_bus *i2c_bus = dev_get_priv(bus); 752e1bed802SPeng Fan const void *fdt = gd->fdt_blob; 753*e160f7d4SSimon Glass int node = dev_of_offset(bus); 75471204e95SPeng Fan fdt_addr_t addr; 755e1bed802SPeng Fan int ret, ret2; 75671204e95SPeng Fan 75771204e95SPeng Fan i2c_bus->driver_data = dev_get_driver_data(bus); 75871204e95SPeng Fan 75971204e95SPeng Fan addr = dev_get_addr(bus); 76071204e95SPeng Fan if (addr == FDT_ADDR_T_NONE) 76171204e95SPeng Fan return -ENODEV; 76271204e95SPeng Fan 76371204e95SPeng Fan i2c_bus->base = addr; 76471204e95SPeng Fan i2c_bus->index = bus->seq; 765e1bed802SPeng Fan i2c_bus->bus = bus; 76671204e95SPeng Fan 76771204e95SPeng Fan /* Enable clk */ 76871204e95SPeng Fan ret = enable_i2c_clk(1, bus->seq); 76971204e95SPeng Fan if (ret < 0) 77071204e95SPeng Fan return ret; 77171204e95SPeng Fan 772e1bed802SPeng Fan /* 773e1bed802SPeng Fan * See Documentation/devicetree/bindings/i2c/i2c-imx.txt 774e1bed802SPeng Fan * Use gpio to force bus idle when necessary. 775e1bed802SPeng Fan */ 776b02e4044SSimon Glass ret = fdt_stringlist_search(fdt, node, "pinctrl-names", "gpio"); 777e1bed802SPeng Fan if (ret < 0) { 7782da24fe5SJagan Teki debug("i2c bus %d at 0x%2lx, no gpio pinctrl state.\n", bus->seq, i2c_bus->base); 779e1bed802SPeng Fan } else { 780e1bed802SPeng Fan ret = gpio_request_by_name_nodev(fdt, node, "scl-gpios", 781e1bed802SPeng Fan 0, &i2c_bus->scl_gpio, 782e1bed802SPeng Fan GPIOD_IS_OUT); 783e1bed802SPeng Fan ret2 = gpio_request_by_name_nodev(fdt, node, "sda-gpios", 784e1bed802SPeng Fan 0, &i2c_bus->sda_gpio, 785e1bed802SPeng Fan GPIOD_IS_OUT); 786e1bed802SPeng Fan if (!dm_gpio_is_valid(&i2c_bus->sda_gpio) | 787e1bed802SPeng Fan !dm_gpio_is_valid(&i2c_bus->scl_gpio) | 788e1bed802SPeng Fan ret | ret2) { 789e1bed802SPeng Fan dev_err(dev, "i2c bus %d at %lu, fail to request scl/sda gpio\n", bus->seq, i2c_bus->base); 790e1bed802SPeng Fan return -ENODEV; 791e1bed802SPeng Fan } 792e1bed802SPeng Fan } 793e1bed802SPeng Fan 79471204e95SPeng Fan ret = i2c_idle_bus(i2c_bus); 79571204e95SPeng Fan if (ret < 0) { 79671204e95SPeng Fan /* Disable clk */ 79771204e95SPeng Fan enable_i2c_clk(0, bus->seq); 79871204e95SPeng Fan return ret; 79971204e95SPeng Fan } 80071204e95SPeng Fan 80171204e95SPeng Fan /* 80271204e95SPeng Fan * Pinmux settings are in board file now, until pinmux is supported, 80371204e95SPeng Fan * we can set pinmux here in probe function. 80471204e95SPeng Fan */ 80571204e95SPeng Fan 80671204e95SPeng Fan debug("i2c : controller bus %d at %lu , speed %d: ", 80771204e95SPeng Fan bus->seq, i2c_bus->base, 80871204e95SPeng Fan i2c_bus->speed); 80971204e95SPeng Fan 81071204e95SPeng Fan return 0; 81171204e95SPeng Fan } 81271204e95SPeng Fan 81371204e95SPeng Fan static int mxc_i2c_probe_chip(struct udevice *bus, u32 chip_addr, 81471204e95SPeng Fan u32 chip_flags) 81571204e95SPeng Fan { 81671204e95SPeng Fan int ret; 81771204e95SPeng Fan struct mxc_i2c_bus *i2c_bus = dev_get_priv(bus); 81871204e95SPeng Fan 81971204e95SPeng Fan ret = i2c_init_transfer(i2c_bus, chip_addr, 0, 0); 82071204e95SPeng Fan if (ret < 0) { 82171204e95SPeng Fan debug("%s failed, ret = %d\n", __func__, ret); 82271204e95SPeng Fan return ret; 82371204e95SPeng Fan } 82471204e95SPeng Fan 82571204e95SPeng Fan i2c_imx_stop(i2c_bus); 82671204e95SPeng Fan 82771204e95SPeng Fan return 0; 82871204e95SPeng Fan } 82971204e95SPeng Fan 83071204e95SPeng Fan static int mxc_i2c_xfer(struct udevice *bus, struct i2c_msg *msg, int nmsgs) 83171204e95SPeng Fan { 83271204e95SPeng Fan struct mxc_i2c_bus *i2c_bus = dev_get_priv(bus); 83371204e95SPeng Fan int ret = 0; 83471204e95SPeng Fan ulong base = i2c_bus->base; 83571204e95SPeng Fan int reg_shift = i2c_bus->driver_data & I2C_QUIRK_FLAG ? 83671204e95SPeng Fan VF610_I2C_REGSHIFT : IMX_I2C_REGSHIFT; 83771204e95SPeng Fan 83871204e95SPeng Fan /* 83971204e95SPeng Fan * Here the 3rd parameter addr and the 4th one alen are set to 0, 84071204e95SPeng Fan * because here we only want to send out chip address. The register 84171204e95SPeng Fan * address is wrapped in msg. 84271204e95SPeng Fan */ 84371204e95SPeng Fan ret = i2c_init_transfer(i2c_bus, msg->addr, 0, 0); 84471204e95SPeng Fan if (ret < 0) { 84571204e95SPeng Fan debug("i2c_init_transfer error: %d\n", ret); 84671204e95SPeng Fan return ret; 84771204e95SPeng Fan } 84871204e95SPeng Fan 84971204e95SPeng Fan for (; nmsgs > 0; nmsgs--, msg++) { 85071204e95SPeng Fan bool next_is_read = nmsgs > 1 && (msg[1].flags & I2C_M_RD); 85171204e95SPeng Fan debug("i2c_xfer: chip=0x%x, len=0x%x\n", msg->addr, msg->len); 85271204e95SPeng Fan if (msg->flags & I2C_M_RD) 85371204e95SPeng Fan ret = i2c_read_data(i2c_bus, msg->addr, msg->buf, 85471204e95SPeng Fan msg->len); 85571204e95SPeng Fan else { 85671204e95SPeng Fan ret = i2c_write_data(i2c_bus, msg->addr, msg->buf, 85771204e95SPeng Fan msg->len); 85871204e95SPeng Fan if (ret) 85971204e95SPeng Fan break; 86071204e95SPeng Fan if (next_is_read) { 86171204e95SPeng Fan /* Reuse ret */ 86271204e95SPeng Fan ret = readb(base + (I2CR << reg_shift)); 86371204e95SPeng Fan ret |= I2CR_RSTA; 86471204e95SPeng Fan writeb(ret, base + (I2CR << reg_shift)); 86571204e95SPeng Fan 86671204e95SPeng Fan ret = tx_byte(i2c_bus, (msg->addr << 1) | 1); 86771204e95SPeng Fan if (ret < 0) { 86871204e95SPeng Fan i2c_imx_stop(i2c_bus); 86971204e95SPeng Fan break; 87071204e95SPeng Fan } 87171204e95SPeng Fan } 87271204e95SPeng Fan } 87371204e95SPeng Fan } 87471204e95SPeng Fan 87571204e95SPeng Fan if (ret) 87671204e95SPeng Fan debug("i2c_write: error sending\n"); 87771204e95SPeng Fan 87871204e95SPeng Fan i2c_imx_stop(i2c_bus); 87971204e95SPeng Fan 88071204e95SPeng Fan return ret; 88171204e95SPeng Fan } 88271204e95SPeng Fan 88371204e95SPeng Fan static const struct dm_i2c_ops mxc_i2c_ops = { 88471204e95SPeng Fan .xfer = mxc_i2c_xfer, 88571204e95SPeng Fan .probe_chip = mxc_i2c_probe_chip, 88671204e95SPeng Fan .set_bus_speed = mxc_i2c_set_bus_speed, 88771204e95SPeng Fan }; 88871204e95SPeng Fan 88971204e95SPeng Fan static const struct udevice_id mxc_i2c_ids[] = { 89071204e95SPeng Fan { .compatible = "fsl,imx21-i2c", }, 89171204e95SPeng Fan { .compatible = "fsl,vf610-i2c", .data = I2C_QUIRK_FLAG, }, 89271204e95SPeng Fan {} 89371204e95SPeng Fan }; 89471204e95SPeng Fan 89571204e95SPeng Fan U_BOOT_DRIVER(i2c_mxc) = { 89671204e95SPeng Fan .name = "i2c_mxc", 89771204e95SPeng Fan .id = UCLASS_I2C, 89871204e95SPeng Fan .of_match = mxc_i2c_ids, 89971204e95SPeng Fan .probe = mxc_i2c_probe, 90071204e95SPeng Fan .priv_auto_alloc_size = sizeof(struct mxc_i2c_bus), 90171204e95SPeng Fan .ops = &mxc_i2c_ops, 90271204e95SPeng Fan }; 90371204e95SPeng Fan #endif 904