1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Copyright 2016 Freescale Semiconductors, Inc. 4 */ 5 6 #include <common.h> 7 #include <errno.h> 8 #include <asm/io.h> 9 #include <asm/arch/clock.h> 10 #include <asm/arch/imx-regs.h> 11 #include <imx_lpi2c.h> 12 #include <asm/arch/sys_proto.h> 13 #include <dm.h> 14 #include <fdtdec.h> 15 #include <i2c.h> 16 17 #define LPI2C_FIFO_SIZE 4 18 #define LPI2C_NACK_TOUT_MS 1 19 #define LPI2C_TIMEOUT_MS 100 20 21 static int bus_i2c_init(struct udevice *bus, int speed); 22 23 /* Weak linked function for overridden by some SoC power function */ 24 int __weak init_i2c_power(unsigned i2c_num) 25 { 26 return 0; 27 } 28 29 static int imx_lpci2c_check_busy_bus(const struct imx_lpi2c_reg *regs) 30 { 31 lpi2c_status_t result = LPI2C_SUCESS; 32 u32 status; 33 34 status = readl(®s->msr); 35 36 if ((status & LPI2C_MSR_BBF_MASK) && !(status & LPI2C_MSR_MBF_MASK)) 37 result = LPI2C_BUSY; 38 39 return result; 40 } 41 42 static int imx_lpci2c_check_clear_error(struct imx_lpi2c_reg *regs) 43 { 44 lpi2c_status_t result = LPI2C_SUCESS; 45 u32 val, status; 46 47 status = readl(®s->msr); 48 /* errors to check for */ 49 status &= LPI2C_MSR_NDF_MASK | LPI2C_MSR_ALF_MASK | 50 LPI2C_MSR_FEF_MASK | LPI2C_MSR_PLTF_MASK; 51 52 if (status) { 53 if (status & LPI2C_MSR_PLTF_MASK) 54 result = LPI2C_PIN_LOW_TIMEOUT_ERR; 55 else if (status & LPI2C_MSR_ALF_MASK) 56 result = LPI2C_ARB_LOST_ERR; 57 else if (status & LPI2C_MSR_NDF_MASK) 58 result = LPI2C_NAK_ERR; 59 else if (status & LPI2C_MSR_FEF_MASK) 60 result = LPI2C_FIFO_ERR; 61 62 /* clear status flags */ 63 writel(0x7f00, ®s->msr); 64 /* reset fifos */ 65 val = readl(®s->mcr); 66 val |= LPI2C_MCR_RRF_MASK | LPI2C_MCR_RTF_MASK; 67 writel(val, ®s->mcr); 68 } 69 70 return result; 71 } 72 73 static int bus_i2c_wait_for_tx_ready(struct imx_lpi2c_reg *regs) 74 { 75 lpi2c_status_t result = LPI2C_SUCESS; 76 u32 txcount = 0; 77 ulong start_time = get_timer(0); 78 79 do { 80 txcount = LPI2C_MFSR_TXCOUNT(readl(®s->mfsr)); 81 txcount = LPI2C_FIFO_SIZE - txcount; 82 result = imx_lpci2c_check_clear_error(regs); 83 if (result) { 84 debug("i2c: wait for tx ready: result 0x%x\n", result); 85 return result; 86 } 87 if (get_timer(start_time) > LPI2C_TIMEOUT_MS) { 88 debug("i2c: wait for tx ready: timeout\n"); 89 return -1; 90 } 91 } while (!txcount); 92 93 return result; 94 } 95 96 static int bus_i2c_send(struct udevice *bus, u8 *txbuf, int len) 97 { 98 struct imx_lpi2c_reg *regs = (struct imx_lpi2c_reg *)devfdt_get_addr(bus); 99 lpi2c_status_t result = LPI2C_SUCESS; 100 101 /* empty tx */ 102 if (!len) 103 return result; 104 105 while (len--) { 106 result = bus_i2c_wait_for_tx_ready(regs); 107 if (result) { 108 debug("i2c: send wait fot tx ready: %d\n", result); 109 return result; 110 } 111 writel(*txbuf++, ®s->mtdr); 112 } 113 114 return result; 115 } 116 117 static int bus_i2c_receive(struct udevice *bus, u8 *rxbuf, int len) 118 { 119 struct imx_lpi2c_reg *regs = (struct imx_lpi2c_reg *)devfdt_get_addr(bus); 120 lpi2c_status_t result = LPI2C_SUCESS; 121 u32 val; 122 ulong start_time = get_timer(0); 123 124 /* empty read */ 125 if (!len) 126 return result; 127 128 result = bus_i2c_wait_for_tx_ready(regs); 129 if (result) { 130 debug("i2c: receive wait fot tx ready: %d\n", result); 131 return result; 132 } 133 134 /* clear all status flags */ 135 writel(0x7f00, ®s->msr); 136 /* send receive command */ 137 val = LPI2C_MTDR_CMD(0x1) | LPI2C_MTDR_DATA(len - 1); 138 writel(val, ®s->mtdr); 139 140 while (len--) { 141 do { 142 result = imx_lpci2c_check_clear_error(regs); 143 if (result) { 144 debug("i2c: receive check clear error: %d\n", 145 result); 146 return result; 147 } 148 if (get_timer(start_time) > LPI2C_TIMEOUT_MS) { 149 debug("i2c: receive mrdr: timeout\n"); 150 return -1; 151 } 152 val = readl(®s->mrdr); 153 } while (val & LPI2C_MRDR_RXEMPTY_MASK); 154 *rxbuf++ = LPI2C_MRDR_DATA(val); 155 } 156 157 return result; 158 } 159 160 static int bus_i2c_start(struct udevice *bus, u8 addr, u8 dir) 161 { 162 lpi2c_status_t result; 163 struct imx_lpi2c_reg *regs = 164 (struct imx_lpi2c_reg *)devfdt_get_addr(bus); 165 u32 val; 166 167 result = imx_lpci2c_check_busy_bus(regs); 168 if (result) { 169 debug("i2c: start check busy bus: 0x%x\n", result); 170 171 /* Try to init the lpi2c then check the bus busy again */ 172 bus_i2c_init(bus, 100000); 173 result = imx_lpci2c_check_busy_bus(regs); 174 if (result) { 175 printf("i2c: Error check busy bus: 0x%x\n", result); 176 return result; 177 } 178 } 179 /* clear all status flags */ 180 writel(0x7f00, ®s->msr); 181 /* turn off auto-stop condition */ 182 val = readl(®s->mcfgr1) & ~LPI2C_MCFGR1_AUTOSTOP_MASK; 183 writel(val, ®s->mcfgr1); 184 /* wait tx fifo ready */ 185 result = bus_i2c_wait_for_tx_ready(regs); 186 if (result) { 187 debug("i2c: start wait for tx ready: 0x%x\n", result); 188 return result; 189 } 190 /* issue start command */ 191 val = LPI2C_MTDR_CMD(0x4) | (addr << 0x1) | dir; 192 writel(val, ®s->mtdr); 193 194 return result; 195 } 196 197 static int bus_i2c_stop(struct udevice *bus) 198 { 199 lpi2c_status_t result; 200 struct imx_lpi2c_reg *regs = 201 (struct imx_lpi2c_reg *)devfdt_get_addr(bus); 202 u32 status; 203 ulong start_time; 204 205 result = bus_i2c_wait_for_tx_ready(regs); 206 if (result) { 207 debug("i2c: stop wait for tx ready: 0x%x\n", result); 208 return result; 209 } 210 211 /* send stop command */ 212 writel(LPI2C_MTDR_CMD(0x2), ®s->mtdr); 213 214 start_time = get_timer(0); 215 while (1) { 216 status = readl(®s->msr); 217 result = imx_lpci2c_check_clear_error(regs); 218 /* stop detect flag */ 219 if (status & LPI2C_MSR_SDF_MASK) { 220 /* clear stop flag */ 221 status &= LPI2C_MSR_SDF_MASK; 222 writel(status, ®s->msr); 223 break; 224 } 225 226 if (get_timer(start_time) > LPI2C_NACK_TOUT_MS) { 227 debug("stop timeout\n"); 228 return -ETIMEDOUT; 229 } 230 } 231 232 return result; 233 } 234 235 static int bus_i2c_read(struct udevice *bus, u32 chip, u8 *buf, int len) 236 { 237 lpi2c_status_t result; 238 239 result = bus_i2c_start(bus, chip, 1); 240 if (result) 241 return result; 242 result = bus_i2c_receive(bus, buf, len); 243 if (result) 244 return result; 245 246 return result; 247 } 248 249 static int bus_i2c_write(struct udevice *bus, u32 chip, u8 *buf, int len) 250 { 251 lpi2c_status_t result; 252 253 result = bus_i2c_start(bus, chip, 0); 254 if (result) 255 return result; 256 result = bus_i2c_send(bus, buf, len); 257 if (result) 258 return result; 259 260 return result; 261 } 262 263 264 u32 __weak imx_get_i2cclk(u32 i2c_num) 265 { 266 return 0; 267 } 268 269 static int bus_i2c_set_bus_speed(struct udevice *bus, int speed) 270 { 271 struct imx_lpi2c_bus *i2c_bus = dev_get_priv(bus); 272 struct imx_lpi2c_reg *regs; 273 u32 val; 274 u32 preescale = 0, best_pre = 0, clkhi = 0; 275 u32 best_clkhi = 0, abs_error = 0, rate; 276 u32 error = 0xffffffff; 277 u32 clock_rate; 278 bool mode; 279 int i; 280 281 regs = (struct imx_lpi2c_reg *)devfdt_get_addr(bus); 282 283 if (IS_ENABLED(CONFIG_CLK)) { 284 clock_rate = clk_get_rate(&i2c_bus->per_clk); 285 if (clock_rate <= 0) { 286 dev_err(bus, "Failed to get i2c clk: %d\n", clock_rate); 287 return clock_rate; 288 } 289 } else { 290 clock_rate = imx_get_i2cclk(bus->seq); 291 if (!clock_rate) 292 return -EPERM; 293 } 294 295 mode = (readl(®s->mcr) & LPI2C_MCR_MEN_MASK) >> LPI2C_MCR_MEN_SHIFT; 296 /* disable master mode */ 297 val = readl(®s->mcr) & ~LPI2C_MCR_MEN_MASK; 298 writel(val | LPI2C_MCR_MEN(0), ®s->mcr); 299 300 for (preescale = 1; (preescale <= 128) && 301 (error != 0); preescale = 2 * preescale) { 302 for (clkhi = 1; clkhi < 32; clkhi++) { 303 if (clkhi == 1) 304 rate = (clock_rate / preescale) / (1 + 3 + 2 + 2 / preescale); 305 else 306 rate = (clock_rate / preescale / (3 * clkhi + 2 + 2 / preescale)); 307 308 abs_error = speed > rate ? speed - rate : rate - speed; 309 310 if (abs_error < error) { 311 best_pre = preescale; 312 best_clkhi = clkhi; 313 error = abs_error; 314 if (abs_error == 0) 315 break; 316 } 317 } 318 } 319 320 /* Standard, fast, fast mode plus and ultra-fast transfers. */ 321 val = LPI2C_MCCR0_CLKHI(best_clkhi); 322 if (best_clkhi < 2) 323 val |= LPI2C_MCCR0_CLKLO(3) | LPI2C_MCCR0_SETHOLD(2) | LPI2C_MCCR0_DATAVD(1); 324 else 325 val |= LPI2C_MCCR0_CLKLO(2 * best_clkhi) | LPI2C_MCCR0_SETHOLD(best_clkhi) | 326 LPI2C_MCCR0_DATAVD(best_clkhi / 2); 327 writel(val, ®s->mccr0); 328 329 for (i = 0; i < 8; i++) { 330 if (best_pre == (1 << i)) { 331 best_pre = i; 332 break; 333 } 334 } 335 336 val = readl(®s->mcfgr1) & ~LPI2C_MCFGR1_PRESCALE_MASK; 337 writel(val | LPI2C_MCFGR1_PRESCALE(best_pre), ®s->mcfgr1); 338 339 if (mode) { 340 val = readl(®s->mcr) & ~LPI2C_MCR_MEN_MASK; 341 writel(val | LPI2C_MCR_MEN(1), ®s->mcr); 342 } 343 344 return 0; 345 } 346 347 static int bus_i2c_init(struct udevice *bus, int speed) 348 { 349 struct imx_lpi2c_reg *regs; 350 u32 val; 351 int ret; 352 353 regs = (struct imx_lpi2c_reg *)devfdt_get_addr(bus); 354 /* reset peripheral */ 355 writel(LPI2C_MCR_RST_MASK, ®s->mcr); 356 writel(0x0, ®s->mcr); 357 /* Disable Dozen mode */ 358 writel(LPI2C_MCR_DBGEN(0) | LPI2C_MCR_DOZEN(1), ®s->mcr); 359 /* host request disable, active high, external pin */ 360 val = readl(®s->mcfgr0); 361 val &= (~(LPI2C_MCFGR0_HREN_MASK | LPI2C_MCFGR0_HRPOL_MASK | 362 LPI2C_MCFGR0_HRSEL_MASK)); 363 val |= LPI2C_MCFGR0_HRPOL(0x1); 364 writel(val, ®s->mcfgr0); 365 /* pincfg and ignore ack */ 366 val = readl(®s->mcfgr1); 367 val &= ~(LPI2C_MCFGR1_PINCFG_MASK | LPI2C_MCFGR1_IGNACK_MASK); 368 val |= LPI2C_MCFGR1_PINCFG(0x0); /* 2 pin open drain */ 369 val |= LPI2C_MCFGR1_IGNACK(0x0); /* ignore nack */ 370 writel(val, ®s->mcfgr1); 371 372 ret = bus_i2c_set_bus_speed(bus, speed); 373 374 /* enable lpi2c in master mode */ 375 val = readl(®s->mcr) & ~LPI2C_MCR_MEN_MASK; 376 writel(val | LPI2C_MCR_MEN(1), ®s->mcr); 377 378 debug("i2c : controller bus %d, speed %d:\n", bus->seq, speed); 379 380 return ret; 381 } 382 383 static int imx_lpi2c_probe_chip(struct udevice *bus, u32 chip, 384 u32 chip_flags) 385 { 386 lpi2c_status_t result; 387 388 result = bus_i2c_start(bus, chip, 0); 389 if (result) { 390 bus_i2c_stop(bus); 391 bus_i2c_init(bus, 100000); 392 return result; 393 } 394 395 result = bus_i2c_stop(bus); 396 if (result) 397 bus_i2c_init(bus, 100000); 398 399 return result; 400 } 401 402 static int imx_lpi2c_xfer(struct udevice *bus, struct i2c_msg *msg, int nmsgs) 403 { 404 int ret = 0, ret_stop; 405 406 for (; nmsgs > 0; nmsgs--, msg++) { 407 debug("i2c_xfer: chip=0x%x, len=0x%x\n", msg->addr, msg->len); 408 if (msg->flags & I2C_M_RD) 409 ret = bus_i2c_read(bus, msg->addr, msg->buf, msg->len); 410 else { 411 ret = bus_i2c_write(bus, msg->addr, msg->buf, 412 msg->len); 413 if (ret) 414 break; 415 } 416 } 417 418 if (ret) 419 debug("i2c_write: error sending\n"); 420 421 ret_stop = bus_i2c_stop(bus); 422 if (ret_stop) 423 debug("i2c_xfer: stop bus error\n"); 424 425 ret |= ret_stop; 426 427 return ret; 428 } 429 430 static int imx_lpi2c_set_bus_speed(struct udevice *bus, unsigned int speed) 431 { 432 return bus_i2c_set_bus_speed(bus, speed); 433 } 434 435 __weak int enable_i2c_clk(unsigned char enable, unsigned int i2c_num) 436 { 437 return 0; 438 } 439 440 static int imx_lpi2c_probe(struct udevice *bus) 441 { 442 struct imx_lpi2c_bus *i2c_bus = dev_get_priv(bus); 443 fdt_addr_t addr; 444 int ret; 445 446 i2c_bus->driver_data = dev_get_driver_data(bus); 447 448 addr = devfdt_get_addr(bus); 449 if (addr == FDT_ADDR_T_NONE) 450 return -EINVAL; 451 452 i2c_bus->base = addr; 453 i2c_bus->index = bus->seq; 454 i2c_bus->bus = bus; 455 456 /* power up i2c resource */ 457 ret = init_i2c_power(bus->seq); 458 if (ret) { 459 debug("init_i2c_power err = %d\n", ret); 460 return ret; 461 } 462 463 if (IS_ENABLED(CONFIG_CLK)) { 464 ret = clk_get_by_name(bus, "per", &i2c_bus->per_clk); 465 if (ret) { 466 dev_err(bus, "Failed to get per clk\n"); 467 return ret; 468 } 469 ret = clk_enable(&i2c_bus->per_clk); 470 if (ret) { 471 dev_err(bus, "Failed to enable per clk\n"); 472 return ret; 473 } 474 } else { 475 /* To i.MX7ULP, only i2c4-7 can be handled by A7 core */ 476 ret = enable_i2c_clk(1, bus->seq); 477 if (ret < 0) 478 return ret; 479 } 480 481 ret = bus_i2c_init(bus, 100000); 482 if (ret < 0) 483 return ret; 484 485 debug("i2c : controller bus %d at %lu , speed %d: ", 486 bus->seq, i2c_bus->base, 487 i2c_bus->speed); 488 489 return 0; 490 } 491 492 static const struct dm_i2c_ops imx_lpi2c_ops = { 493 .xfer = imx_lpi2c_xfer, 494 .probe_chip = imx_lpi2c_probe_chip, 495 .set_bus_speed = imx_lpi2c_set_bus_speed, 496 }; 497 498 static const struct udevice_id imx_lpi2c_ids[] = { 499 { .compatible = "fsl,imx7ulp-lpi2c", }, 500 { .compatible = "fsl,imx8qm-lpi2c", }, 501 {} 502 }; 503 504 U_BOOT_DRIVER(imx_lpi2c) = { 505 .name = "imx_lpi2c", 506 .id = UCLASS_I2C, 507 .of_match = imx_lpi2c_ids, 508 .probe = imx_lpi2c_probe, 509 .priv_auto_alloc_size = sizeof(struct imx_lpi2c_bus), 510 .ops = &imx_lpi2c_ops, 511 }; 512