1 /*- 2 * Copyright (c) 2016 Michal Meloun <mmel@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 /* 31 * I2C driver for Tegra SoCs. 32 */ 33 #include <sys/param.h> 34 #include <sys/systm.h> 35 #include <sys/bus.h> 36 #include <sys/kernel.h> 37 #include <sys/limits.h> 38 #include <sys/module.h> 39 #include <sys/resource.h> 40 41 #include <machine/bus.h> 42 #include <machine/resource.h> 43 #include <sys/rman.h> 44 45 #include <sys/lock.h> 46 #include <sys/mutex.h> 47 48 #include <dev/extres/clk/clk.h> 49 #include <dev/extres/hwreset/hwreset.h> 50 #include <dev/iicbus/iiconf.h> 51 #include <dev/iicbus/iicbus.h> 52 #include <dev/ofw/ofw_bus.h> 53 #include <dev/ofw/ofw_bus_subr.h> 54 55 #include "iicbus_if.h" 56 57 #define I2C_CNFG 0x000 58 #define I2C_CNFG_MSTR_CLR_BUS_ON_TIMEOUT (1 << 15) 59 #define I2C_CNFG_DEBOUNCE_CNT(x) (((x) & 0x07) << 12) 60 #define I2C_CNFG_NEW_MASTER_FSM (1 << 11) 61 #define I2C_CNFG_PACKET_MODE_EN (1 << 10) 62 #define I2C_CNFG_SEND (1 << 9) 63 #define I2C_CNFG_NOACK (1 << 8) 64 #define I2C_CNFG_CMD2 (1 << 7) 65 #define I2C_CNFG_CMD1 (1 << 6) 66 #define I2C_CNFG_START (1 << 5) 67 #define I2C_CNFG_SLV2 (1 << 4) 68 #define I2C_CNFG_LENGTH_SHIFT 1 69 #define I2C_CNFG_LENGTH_MASK 0x7 70 #define I2C_CNFG_A_MOD (1 << 0) 71 72 #define I2C_CMD_ADDR0 0x004 73 #define I2C_CMD_ADDR1 0x008 74 #define I2C_CMD_DATA1 0x00c 75 #define I2C_CMD_DATA2 0x010 76 #define I2C_STATUS 0x01c 77 #define I2C_SL_CNFG 0x020 78 #define I2C_SL_RCVD 0x024 79 #define I2C_SL_STATUS 0x028 80 #define I2C_SL_ADDR1 0x02c 81 #define I2C_SL_ADDR2 0x030 82 #define I2C_TLOW_SEXT 0x034 83 #define I2C_SL_DELAY_COUNT 0x03c 84 #define I2C_SL_INT_MASK 0x040 85 #define I2C_SL_INT_SOURCE 0x044 86 #define I2C_SL_INT_SET 0x048 87 #define I2C_TX_PACKET_FIFO 0x050 88 #define I2C_RX_FIFO 0x054 89 #define I2C_PACKET_TRANSFER_STATUS 0x058 90 #define I2C_FIFO_CONTROL 0x05c 91 #define I2C_FIFO_CONTROL_SLV_TX_FIFO_TRIG(x) (((x) & 0x07) << 13) 92 #define I2C_FIFO_CONTROL_SLV_RX_FIFO_TRIG(x) (((x) & 0x07) << 10) 93 #define I2C_FIFO_CONTROL_SLV_TX_FIFO_FLUSH (1 << 9) 94 #define I2C_FIFO_CONTROL_SLV_RX_FIFO_FLUSH (1 << 8) 95 #define I2C_FIFO_CONTROL_TX_FIFO_TRIG(x) (((x) & 0x07) << 5) 96 #define I2C_FIFO_CONTROL_RX_FIFO_TRIG(x) (((x) & 0x07) << 2) 97 #define I2C_FIFO_CONTROL_TX_FIFO_FLUSH (1 << 1) 98 #define I2C_FIFO_CONTROL_RX_FIFO_FLUSH (1 << 0) 99 100 #define I2C_FIFO_STATUS 0x060 101 #define I2C_FIFO_STATUS_SLV_XFER_ERR_REASON (1 << 25) 102 #define I2C_FIFO_STATUS_TX_FIFO_SLV_EMPTY_CNT(x) (((x) >> 20) & 0xF) 103 #define I2C_FIFO_STATUS_RX_FIFO_SLV_FULL_CNT(x) (((x) >> 16) & 0xF) 104 #define I2C_FIFO_STATUS_TX_FIFO_EMPTY_CNT(x) (((x) >> 4) & 0xF) 105 #define I2C_FIFO_STATUS_RX_FIFO_FULL_CNT(x) (((x) >> 0) & 0xF) 106 107 #define I2C_INTERRUPT_MASK_REGISTER 0x064 108 #define I2C_INTERRUPT_STATUS_REGISTER 0x068 109 #define I2C_INT_SLV_ACK_WITHHELD (1 << 28) 110 #define I2C_INT_SLV_RD2WR (1 << 27) 111 #define I2C_INT_SLV_WR2RD (1 << 26) 112 #define I2C_INT_SLV_PKT_XFER_ERR (1 << 25) 113 #define I2C_INT_SLV_TX_BUFFER_REQ (1 << 24) 114 #define I2C_INT_SLV_RX_BUFFER_FILLED (1 << 23) 115 #define I2C_INT_SLV_PACKET_XFER_COMPLETE (1 << 22) 116 #define I2C_INT_SLV_TFIFO_OVF (1 << 21) 117 #define I2C_INT_SLV_RFIFO_UNF (1 << 20) 118 #define I2C_INT_SLV_TFIFO_DATA_REQ (1 << 17) 119 #define I2C_INT_SLV_RFIFO_DATA_REQ (1 << 16) 120 #define I2C_INT_BUS_CLEAR_DONE (1 << 11) 121 #define I2C_INT_TLOW_MEXT_TIMEOUT (1 << 10) 122 #define I2C_INT_TLOW_SEXT_TIMEOUT (1 << 9) 123 #define I2C_INT_TIMEOUT (1 << 8) 124 #define I2C_INT_PACKET_XFER_COMPLETE (1 << 7) 125 #define I2C_INT_ALL_PACKETS_XFER_COMPLETE (1 << 6) 126 #define I2C_INT_TFIFO_OVR (1 << 5) 127 #define I2C_INT_RFIFO_UNF (1 << 4) 128 #define I2C_INT_NOACK (1 << 3) 129 #define I2C_INT_ARB_LOST (1 << 2) 130 #define I2C_INT_TFIFO_DATA_REQ (1 << 1) 131 #define I2C_INT_RFIFO_DATA_REQ (1 << 0) 132 #define I2C_ERROR_MASK (I2C_INT_ARB_LOST | I2C_INT_NOACK | \ 133 I2C_INT_RFIFO_UNF | I2C_INT_TFIFO_OVR) 134 135 #define I2C_CLK_DIVISOR 0x06c 136 #define I2C_CLK_DIVISOR_STD_FAST_MODE_SHIFT 16 137 #define I2C_CLK_DIVISOR_STD_FAST_MODE_MASK 0xffff 138 #define I2C_CLK_DIVISOR_HSMODE_SHIFT 0 139 #define I2C_CLK_DIVISOR_HSMODE_MASK 0xffff 140 #define I2C_INTERRUPT_SOURCE_REGISTER 0x070 141 #define I2C_INTERRUPT_SET_REGISTER 0x074 142 #define I2C_SLV_TX_PACKET_FIFO 0x07c 143 #define I2C_SLV_PACKET_STATUS 0x080 144 #define I2C_BUS_CLEAR_CONFIG 0x084 145 #define I2C_BUS_CLEAR_CONFIG_BC_SCLK_THRESHOLD(x) (((x) & 0xFF) << 16) 146 #define I2C_BUS_CLEAR_CONFIG_BC_STOP_COND (1 << 2) 147 #define I2C_BUS_CLEAR_CONFIG_BC_TERMINATE (1 << 1) 148 #define I2C_BUS_CLEAR_CONFIG_BC_ENABLE (1 << 0) 149 150 #define I2C_BUS_CLEAR_STATUS 0x088 151 #define I2C_BUS_CLEAR_STATUS_BC_STATUS (1 << 0) 152 153 #define I2C_CONFIG_LOAD 0x08c 154 #define I2C_CONFIG_LOAD_TIMEOUT_CONFIG_LOAD (1 << 2) 155 #define I2C_CONFIG_LOAD_SLV_CONFIG_LOAD (1 << 1) 156 #define I2C_CONFIG_LOAD_MSTR_CONFIG_LOAD (1 << 0) 157 158 #define I2C_INTERFACE_TIMING_0 0x094 159 #define I2C_INTERFACE_TIMING_1 0x098 160 #define I2C_HS_INTERFACE_TIMING_0 0x09c 161 #define I2C_HS_INTERFACE_TIMING_1 0x0a0 162 163 /* Protocol header 0 */ 164 #define PACKET_HEADER0_HEADER_SIZE_SHIFT 28 165 #define PACKET_HEADER0_HEADER_SIZE_MASK 0x3 166 #define PACKET_HEADER0_PACKET_ID_SHIFT 16 167 #define PACKET_HEADER0_PACKET_ID_MASK 0xff 168 #define PACKET_HEADER0_CONT_ID_SHIFT 12 169 #define PACKET_HEADER0_CONT_ID_MASK 0xf 170 #define PACKET_HEADER0_PROTOCOL_I2C (1 << 4) 171 #define PACKET_HEADER0_TYPE_SHIFT 0 172 #define PACKET_HEADER0_TYPE_MASK 0x7 173 174 /* I2C header */ 175 #define I2C_HEADER_HIGHSPEED_MODE (1 << 22) 176 #define I2C_HEADER_CONT_ON_NAK (1 << 21) 177 #define I2C_HEADER_SEND_START_BYTE (1 << 20) 178 #define I2C_HEADER_READ (1 << 19) 179 #define I2C_HEADER_10BIT_ADDR (1 << 18) 180 #define I2C_HEADER_IE_ENABLE (1 << 17) 181 #define I2C_HEADER_REPEAT_START (1 << 16) 182 #define I2C_HEADER_CONTINUE_XFER (1 << 15) 183 #define I2C_HEADER_MASTER_ADDR_SHIFT 12 184 #define I2C_HEADER_MASTER_ADDR_MASK 0x7 185 #define I2C_HEADER_SLAVE_ADDR_SHIFT 0 186 #define I2C_HEADER_SLAVE_ADDR_MASK 0x3ff 187 188 #define I2C_CLK_DIVISOR_STD_FAST_MODE 0x19 189 #define I2C_CLK_MULTIPLIER_STD_FAST_MODE 8 190 191 #define I2C_REQUEST_TIMEOUT (5 * hz) 192 193 #define WR4(_sc, _r, _v) bus_write_4((_sc)->mem_res, (_r), (_v)) 194 #define RD4(_sc, _r) bus_read_4((_sc)->mem_res, (_r)) 195 196 #define LOCK(_sc) mtx_lock(&(_sc)->mtx) 197 #define UNLOCK(_sc) mtx_unlock(&(_sc)->mtx) 198 #define SLEEP(_sc, timeout) \ 199 mtx_sleep(sc, &sc->mtx, 0, "i2cbuswait", timeout); 200 #define LOCK_INIT(_sc) \ 201 mtx_init(&_sc->mtx, device_get_nameunit(_sc->dev), "tegra_i2c", MTX_DEF) 202 #define LOCK_DESTROY(_sc) mtx_destroy(&_sc->mtx) 203 #define ASSERT_LOCKED(_sc) mtx_assert(&_sc->mtx, MA_OWNED) 204 #define ASSERT_UNLOCKED(_sc) mtx_assert(&_sc->mtx, MA_NOTOWNED) 205 206 static struct ofw_compat_data compat_data[] = { 207 {"nvidia,tegra124-i2c", 1}, 208 {NULL, 0} 209 }; 210 enum tegra_i2c_xfer_type { 211 XFER_STOP, /* Send stop condition after xfer */ 212 XFER_REPEAT_START, /* Send repeated start after xfer */ 213 XFER_CONTINUE /* Don't send nothing */ 214 } ; 215 216 struct tegra_i2c_softc { 217 device_t dev; 218 struct mtx mtx; 219 220 struct resource *mem_res; 221 struct resource *irq_res; 222 void *irq_h; 223 224 device_t iicbus; 225 clk_t clk; 226 hwreset_t reset; 227 uint32_t core_freq; 228 uint32_t bus_freq; 229 int bus_inuse; 230 231 struct iic_msg *msg; 232 int msg_idx; 233 uint32_t bus_err; 234 int done; 235 }; 236 237 static int 238 tegra_i2c_flush_fifo(struct tegra_i2c_softc *sc) 239 { 240 int timeout; 241 uint32_t reg; 242 243 reg = RD4(sc, I2C_FIFO_CONTROL); 244 reg |= I2C_FIFO_CONTROL_TX_FIFO_FLUSH | I2C_FIFO_CONTROL_RX_FIFO_FLUSH; 245 WR4(sc, I2C_FIFO_CONTROL, reg); 246 247 timeout = 10; 248 while (timeout > 0) { 249 reg = RD4(sc, I2C_FIFO_CONTROL); 250 reg &= I2C_FIFO_CONTROL_TX_FIFO_FLUSH | 251 I2C_FIFO_CONTROL_RX_FIFO_FLUSH; 252 if (reg == 0) 253 break; 254 DELAY(10); 255 } 256 if (timeout <= 0) { 257 device_printf(sc->dev, "FIFO flush timedout\n"); 258 return (ETIMEDOUT); 259 } 260 return (0); 261 } 262 263 static void 264 tegra_i2c_setup_clk(struct tegra_i2c_softc *sc, int clk_freq) 265 { 266 int div; 267 268 div = ((sc->core_freq / clk_freq) / 10) - 1; 269 if ((sc->core_freq / (10 * (div + 1))) > clk_freq) 270 div++; 271 if (div > 65535) 272 div = 65535; 273 WR4(sc, I2C_CLK_DIVISOR, 274 (1 << I2C_CLK_DIVISOR_HSMODE_SHIFT) | 275 (div << I2C_CLK_DIVISOR_STD_FAST_MODE_SHIFT)); 276 } 277 278 static void 279 tegra_i2c_bus_clear(struct tegra_i2c_softc *sc) 280 { 281 int timeout; 282 uint32_t reg, status; 283 284 WR4(sc, I2C_BUS_CLEAR_CONFIG, 285 I2C_BUS_CLEAR_CONFIG_BC_SCLK_THRESHOLD(18) | 286 I2C_BUS_CLEAR_CONFIG_BC_STOP_COND | 287 I2C_BUS_CLEAR_CONFIG_BC_TERMINATE); 288 289 WR4(sc, I2C_CONFIG_LOAD, I2C_CONFIG_LOAD_MSTR_CONFIG_LOAD); 290 for (timeout = 1000; timeout > 0; timeout--) { 291 if (RD4(sc, I2C_CONFIG_LOAD) == 0) 292 break; 293 DELAY(10); 294 } 295 if (timeout <= 0) 296 device_printf(sc->dev, "config load timeouted\n"); 297 reg = RD4(sc, I2C_BUS_CLEAR_CONFIG); 298 reg |= I2C_BUS_CLEAR_CONFIG_BC_ENABLE; 299 WR4(sc, I2C_BUS_CLEAR_CONFIG,reg); 300 301 for (timeout = 1000; timeout > 0; timeout--) { 302 if ((RD4(sc, I2C_BUS_CLEAR_CONFIG) & 303 I2C_BUS_CLEAR_CONFIG_BC_ENABLE) == 0) 304 break; 305 DELAY(10); 306 } 307 if (timeout <= 0) 308 device_printf(sc->dev, "bus clear timeouted\n"); 309 310 status = RD4(sc, I2C_BUS_CLEAR_STATUS); 311 if ((status & I2C_BUS_CLEAR_STATUS_BC_STATUS) == 0) 312 device_printf(sc->dev, "bus clear failed\n"); 313 } 314 315 static int 316 tegra_i2c_hw_init(struct tegra_i2c_softc *sc) 317 { 318 int rv, timeout; 319 320 /* Reset the core. */ 321 rv = hwreset_assert(sc->reset); 322 if (rv != 0) { 323 device_printf(sc->dev, "Cannot assert reset\n"); 324 return (rv); 325 } 326 DELAY(10); 327 rv = hwreset_deassert(sc->reset); 328 if (rv != 0) { 329 device_printf(sc->dev, "Cannot clear reset\n"); 330 return (rv); 331 } 332 333 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, 0); 334 WR4(sc, I2C_INTERRUPT_STATUS_REGISTER, 0xFFFFFFFF); 335 WR4(sc, I2C_CNFG, I2C_CNFG_NEW_MASTER_FSM | I2C_CNFG_PACKET_MODE_EN | 336 I2C_CNFG_DEBOUNCE_CNT(2)); 337 338 tegra_i2c_setup_clk(sc, sc->bus_freq); 339 340 WR4(sc, I2C_FIFO_CONTROL, I2C_FIFO_CONTROL_TX_FIFO_TRIG(7) | 341 I2C_FIFO_CONTROL_RX_FIFO_TRIG(0)); 342 343 WR4(sc, I2C_CONFIG_LOAD, I2C_CONFIG_LOAD_MSTR_CONFIG_LOAD); 344 for (timeout = 1000; timeout > 0; timeout--) { 345 if (RD4(sc, I2C_CONFIG_LOAD) == 0) 346 break; 347 DELAY(10); 348 } 349 if (timeout <= 0) 350 device_printf(sc->dev, "config load timeouted\n"); 351 352 tegra_i2c_bus_clear(sc); 353 return (0); 354 } 355 356 static int 357 tegra_i2c_tx(struct tegra_i2c_softc *sc) 358 { 359 uint32_t reg; 360 int cnt, i; 361 362 if (sc->msg_idx >= sc->msg->len) 363 panic("Invalid call to tegra_i2c_tx\n"); 364 365 while(sc->msg_idx < sc->msg->len) { 366 reg = RD4(sc, I2C_FIFO_STATUS); 367 if (I2C_FIFO_STATUS_TX_FIFO_EMPTY_CNT(reg) == 0) 368 break; 369 cnt = min(4, sc->msg->len - sc->msg_idx); 370 reg = 0; 371 for (i = 0; i < cnt; i++) { 372 reg |= sc->msg->buf[sc->msg_idx] << (i * 8); 373 sc->msg_idx++; 374 } 375 WR4(sc, I2C_TX_PACKET_FIFO, reg); 376 } 377 if (sc->msg_idx >= sc->msg->len) 378 return (0); 379 return (sc->msg->len - sc->msg_idx - 1); 380 } 381 382 static int 383 tegra_i2c_rx(struct tegra_i2c_softc *sc) 384 { 385 uint32_t reg; 386 int cnt, i; 387 388 if (sc->msg_idx >= sc->msg->len) 389 panic("Invalid call to tegra_i2c_rx\n"); 390 391 while(sc->msg_idx < sc->msg->len) { 392 reg = RD4(sc, I2C_FIFO_STATUS); 393 if (I2C_FIFO_STATUS_RX_FIFO_FULL_CNT(reg) == 0) 394 break; 395 cnt = min(4, sc->msg->len - sc->msg_idx); 396 reg = RD4(sc, I2C_RX_FIFO); 397 for (i = 0; i < cnt; i++) { 398 sc->msg->buf[sc->msg_idx] = (reg >> (i * 8)) & 0xFF; 399 sc->msg_idx++; 400 } 401 } 402 403 if (sc->msg_idx >= sc->msg->len) 404 return (0); 405 return (sc->msg->len - sc->msg_idx - 1); 406 } 407 408 static void 409 tegra_i2c_intr(void *arg) 410 { 411 struct tegra_i2c_softc *sc; 412 uint32_t status, reg; 413 int rv; 414 415 sc = (struct tegra_i2c_softc *)arg; 416 417 LOCK(sc); 418 status = RD4(sc, I2C_INTERRUPT_SOURCE_REGISTER); 419 if (sc->msg == NULL) { 420 /* Unexpected interrupt - disable FIFOs, clear reset. */ 421 reg = RD4(sc, I2C_INTERRUPT_MASK_REGISTER); 422 reg &= ~I2C_INT_TFIFO_DATA_REQ; 423 reg &= ~I2C_INT_RFIFO_DATA_REQ; 424 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, 0); 425 WR4(sc, I2C_INTERRUPT_STATUS_REGISTER, status); 426 UNLOCK(sc); 427 return; 428 } 429 430 if ((status & I2C_ERROR_MASK) != 0) { 431 if (status & I2C_INT_NOACK) 432 sc->bus_err = IIC_ENOACK; 433 if (status & I2C_INT_ARB_LOST) 434 sc->bus_err = IIC_EBUSERR; 435 if ((status & I2C_INT_TFIFO_OVR) || 436 (status & I2C_INT_RFIFO_UNF)) 437 sc->bus_err = IIC_EBUSERR; 438 sc->done = 1; 439 } else if ((status & I2C_INT_RFIFO_DATA_REQ) && 440 (sc->msg != NULL) && (sc->msg->flags & IIC_M_RD)) { 441 rv = tegra_i2c_rx(sc); 442 if (rv == 0) { 443 reg = RD4(sc, I2C_INTERRUPT_MASK_REGISTER); 444 reg &= ~I2C_INT_RFIFO_DATA_REQ; 445 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, reg); 446 } 447 } else if ((status & I2C_INT_TFIFO_DATA_REQ) && 448 (sc->msg != NULL) && !(sc->msg->flags & IIC_M_RD)) { 449 rv = tegra_i2c_tx(sc); 450 if (rv == 0) { 451 reg = RD4(sc, I2C_INTERRUPT_MASK_REGISTER); 452 reg &= ~I2C_INT_TFIFO_DATA_REQ; 453 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, reg); 454 } 455 } else if ((status & I2C_INT_RFIFO_DATA_REQ) || 456 (status & I2C_INT_TFIFO_DATA_REQ)) { 457 device_printf(sc->dev, "Unexpected data interrupt: 0x%08X\n", 458 status); 459 reg = RD4(sc, I2C_INTERRUPT_MASK_REGISTER); 460 reg &= ~I2C_INT_TFIFO_DATA_REQ; 461 reg &= ~I2C_INT_RFIFO_DATA_REQ; 462 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, reg); 463 } 464 if (status & I2C_INT_PACKET_XFER_COMPLETE) 465 sc->done = 1; 466 WR4(sc, I2C_INTERRUPT_STATUS_REGISTER, status); 467 if (sc->done) { 468 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, 0); 469 wakeup(&(sc->done)); 470 } 471 UNLOCK(sc); 472 } 473 474 static void 475 tegra_i2c_start_msg(struct tegra_i2c_softc *sc, struct iic_msg *msg, 476 enum tegra_i2c_xfer_type xtype) 477 { 478 uint32_t tmp, mask; 479 480 /* Packet header. */ 481 tmp = (0 << PACKET_HEADER0_HEADER_SIZE_SHIFT) | 482 PACKET_HEADER0_PROTOCOL_I2C | 483 (1 << PACKET_HEADER0_CONT_ID_SHIFT) | 484 (1 << PACKET_HEADER0_PACKET_ID_SHIFT); 485 WR4(sc, I2C_TX_PACKET_FIFO, tmp); 486 487 488 /* Packet size. */ 489 WR4(sc, I2C_TX_PACKET_FIFO, msg->len - 1); 490 491 /* I2C header. */ 492 tmp = I2C_HEADER_IE_ENABLE; 493 if (xtype == XFER_CONTINUE) 494 tmp |= I2C_HEADER_CONTINUE_XFER; 495 else if (xtype == XFER_REPEAT_START) 496 tmp |= I2C_HEADER_REPEAT_START; 497 tmp |= msg->slave << I2C_HEADER_SLAVE_ADDR_SHIFT; 498 if (msg->flags & IIC_M_RD) { 499 tmp |= I2C_HEADER_READ; 500 tmp |= 1 << I2C_HEADER_SLAVE_ADDR_SHIFT; 501 } else 502 tmp &= ~(1 << I2C_HEADER_SLAVE_ADDR_SHIFT); 503 504 WR4(sc, I2C_TX_PACKET_FIFO, tmp); 505 506 /* Interrupt mask. */ 507 mask = I2C_INT_NOACK | I2C_INT_ARB_LOST | I2C_INT_PACKET_XFER_COMPLETE; 508 if (msg->flags & IIC_M_RD) 509 mask |= I2C_INT_RFIFO_DATA_REQ; 510 else 511 mask |= I2C_INT_TFIFO_DATA_REQ; 512 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, mask); 513 } 514 515 static int 516 tegra_i2c_poll(struct tegra_i2c_softc *sc) 517 { 518 int timeout; 519 520 for(timeout = 10000; timeout > 0; timeout--) { 521 UNLOCK(sc); 522 tegra_i2c_intr(sc); 523 LOCK(sc); 524 if (sc->done != 0) 525 break; 526 DELAY(1); 527 } 528 if (timeout <= 0) 529 return (ETIMEDOUT); 530 return (0); 531 } 532 533 static int 534 tegra_i2c_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs) 535 { 536 int rv, i; 537 struct tegra_i2c_softc *sc; 538 enum tegra_i2c_xfer_type xtype; 539 540 sc = device_get_softc(dev); 541 LOCK(sc); 542 543 /* Get the bus. */ 544 while (sc->bus_inuse == 1) 545 SLEEP(sc, 0); 546 sc->bus_inuse = 1; 547 548 rv = 0; 549 for (i = 0; i < nmsgs; i++) { 550 sc->msg = &msgs[i]; 551 sc->msg_idx = 0; 552 sc->bus_err = 0; 553 sc->done = 0; 554 /* Check for valid parameters. */ 555 if (sc->msg == NULL || sc->msg->buf == NULL || 556 sc->msg->len == 0) { 557 rv = EINVAL; 558 break; 559 } 560 561 /* Get flags for next transfer. */ 562 if (i == (nmsgs - 1)) { 563 if (msgs[i].flags & IIC_M_NOSTOP) 564 xtype = XFER_CONTINUE; 565 else 566 xtype = XFER_STOP; 567 } else { 568 if (msgs[i + 1].flags & IIC_M_NOSTART) 569 xtype = XFER_CONTINUE; 570 else 571 xtype = XFER_REPEAT_START; 572 } 573 tegra_i2c_start_msg(sc, sc->msg, xtype); 574 if (cold) 575 rv = tegra_i2c_poll(sc); 576 else 577 rv = msleep(&sc->done, &sc->mtx, PZERO, "iic", 578 I2C_REQUEST_TIMEOUT); 579 580 WR4(sc, I2C_INTERRUPT_MASK_REGISTER, 0); 581 WR4(sc, I2C_INTERRUPT_STATUS_REGISTER, 0xFFFFFFFF); 582 if (rv == 0) 583 rv = sc->bus_err; 584 if (rv != 0) 585 break; 586 } 587 588 if (rv != 0) { 589 tegra_i2c_hw_init(sc); 590 tegra_i2c_flush_fifo(sc); 591 } 592 593 sc->msg = NULL; 594 sc->msg_idx = 0; 595 sc->bus_err = 0; 596 sc->done = 0; 597 598 /* Wake up the processes that are waiting for the bus. */ 599 sc->bus_inuse = 0; 600 wakeup(sc); 601 UNLOCK(sc); 602 603 return (rv); 604 } 605 606 static int 607 tegra_i2c_iicbus_reset(device_t dev, u_char speed, u_char addr, u_char *oldaddr) 608 { 609 struct tegra_i2c_softc *sc; 610 int busfreq; 611 612 sc = device_get_softc(dev); 613 busfreq = IICBUS_GET_FREQUENCY(sc->iicbus, speed); 614 sc = device_get_softc(dev); 615 LOCK(sc); 616 tegra_i2c_setup_clk(sc, busfreq); 617 UNLOCK(sc); 618 return (0); 619 } 620 621 static int 622 tegra_i2c_probe(device_t dev) 623 { 624 if (!ofw_bus_status_okay(dev)) 625 return (ENXIO); 626 627 if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0) 628 return (ENXIO); 629 630 return (BUS_PROBE_DEFAULT); 631 } 632 633 static int 634 tegra_i2c_attach(device_t dev) 635 { 636 int rv, rid; 637 phandle_t node; 638 struct tegra_i2c_softc *sc; 639 uint64_t freq; 640 641 sc = device_get_softc(dev); 642 sc->dev = dev; 643 node = ofw_bus_get_node(dev); 644 645 LOCK_INIT(sc); 646 647 /* Get the memory resource for the register mapping. */ 648 rid = 0; 649 sc->mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 650 RF_ACTIVE); 651 if (sc->mem_res == NULL) { 652 device_printf(dev, "Cannot map registers.\n"); 653 rv = ENXIO; 654 goto fail; 655 } 656 657 /* Allocate our IRQ resource. */ 658 rid = 0; 659 sc->irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 660 RF_ACTIVE); 661 if (sc->irq_res == NULL) { 662 device_printf(dev, "Cannot allocate interrupt.\n"); 663 rv = ENXIO; 664 goto fail; 665 } 666 667 /* FDT resources. */ 668 rv = clk_get_by_ofw_name(dev, 0, "div-clk", &sc->clk); 669 if (rv != 0) { 670 device_printf(dev, "Cannot get i2c clock: %d\n", rv); 671 goto fail; 672 } 673 rv = hwreset_get_by_ofw_name(sc->dev, 0, "i2c", &sc->reset); 674 if (rv != 0) { 675 device_printf(sc->dev, "Cannot get i2c reset\n"); 676 return (ENXIO); 677 } 678 rv = OF_getencprop(node, "clock-frequency", &sc->bus_freq, 679 sizeof(sc->bus_freq)); 680 if (rv != sizeof(sc->bus_freq)) { 681 sc->bus_freq = 100000; 682 goto fail; 683 } 684 685 /* Request maximum frequency for I2C block 136MHz (408MHz / 3). */ 686 rv = clk_set_freq(sc->clk, 136000000, CLK_SET_ROUND_DOWN); 687 if (rv != 0) { 688 device_printf(dev, "Cannot set clock frequency\n"); 689 goto fail; 690 } 691 rv = clk_get_freq(sc->clk, &freq); 692 if (rv != 0) { 693 device_printf(dev, "Cannot get clock frequency\n"); 694 goto fail; 695 } 696 sc->core_freq = (uint32_t)freq; 697 698 rv = clk_enable(sc->clk); 699 if (rv != 0) { 700 device_printf(dev, "Cannot enable clock: %d\n", rv); 701 goto fail; 702 } 703 704 /* Init hardware. */ 705 rv = tegra_i2c_hw_init(sc); 706 if (rv) { 707 device_printf(dev, "tegra_i2c_activate failed\n"); 708 goto fail; 709 } 710 711 /* Setup interrupt. */ 712 rv = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_MISC | INTR_MPSAFE, 713 NULL, tegra_i2c_intr, sc, &sc->irq_h); 714 if (rv) { 715 device_printf(dev, "Cannot setup interrupt.\n"); 716 goto fail; 717 } 718 719 /* Attach the iicbus. */ 720 sc->iicbus = device_add_child(dev, "iicbus", -1); 721 if (sc->iicbus == NULL) { 722 device_printf(dev, "Could not allocate iicbus instance.\n"); 723 rv = ENXIO; 724 goto fail; 725 } 726 727 /* Probe and attach the iicbus. */ 728 return (bus_generic_attach(dev)); 729 730 fail: 731 if (sc->irq_h != NULL) 732 bus_teardown_intr(dev, sc->irq_res, sc->irq_h); 733 if (sc->irq_res != NULL) 734 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq_res); 735 if (sc->mem_res != NULL) 736 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res); 737 LOCK_DESTROY(sc); 738 739 return (rv); 740 } 741 742 static int 743 tegra_i2c_detach(device_t dev) 744 { 745 struct tegra_i2c_softc *sc; 746 int rv; 747 748 sc = device_get_softc(dev); 749 tegra_i2c_hw_init(sc); 750 if (sc->irq_h != NULL) 751 bus_teardown_intr(dev, sc->irq_res, sc->irq_h); 752 if (sc->irq_res != NULL) 753 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->irq_res); 754 if (sc->mem_res != NULL) 755 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->mem_res); 756 757 LOCK_DESTROY(sc); 758 if (sc->iicbus) 759 rv = device_delete_child(dev, sc->iicbus); 760 return (bus_generic_detach(dev)); 761 } 762 763 static phandle_t 764 tegra_i2c_get_node(device_t bus, device_t dev) 765 { 766 767 /* Share controller node with iibus device. */ 768 return (ofw_bus_get_node(bus)); 769 } 770 771 static device_method_t tegra_i2c_methods[] = { 772 /* Device interface */ 773 DEVMETHOD(device_probe, tegra_i2c_probe), 774 DEVMETHOD(device_attach, tegra_i2c_attach), 775 DEVMETHOD(device_detach, tegra_i2c_detach), 776 777 /* Bus interface */ 778 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr), 779 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr), 780 DEVMETHOD(bus_alloc_resource, bus_generic_alloc_resource), 781 DEVMETHOD(bus_release_resource, bus_generic_release_resource), 782 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource), 783 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource), 784 DEVMETHOD(bus_adjust_resource, bus_generic_adjust_resource), 785 DEVMETHOD(bus_set_resource, bus_generic_rl_set_resource), 786 DEVMETHOD(bus_get_resource, bus_generic_rl_get_resource), 787 788 /* OFW methods */ 789 DEVMETHOD(ofw_bus_get_node, tegra_i2c_get_node), 790 791 /* iicbus interface */ 792 DEVMETHOD(iicbus_callback, iicbus_null_callback), 793 DEVMETHOD(iicbus_reset, tegra_i2c_iicbus_reset), 794 DEVMETHOD(iicbus_transfer, tegra_i2c_transfer), 795 796 DEVMETHOD_END 797 }; 798 799 static devclass_t tegra_i2c_devclass; 800 static DEFINE_CLASS_0(iichb, tegra_i2c_driver, tegra_i2c_methods, 801 sizeof(struct tegra_i2c_softc)); 802 EARLY_DRIVER_MODULE(tegra_iic, simplebus, tegra_i2c_driver, tegra_i2c_devclass, 803 NULL, NULL, 73); 804