1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2011 Ben Gray <ben.r.gray@gmail.com>. 5 * Copyright (c) 2014 Luiz Otavio O Souza <loos@freebsd.org>. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 /** 31 * Driver for the I2C module on the TI SoC. 32 * 33 * This driver is heavily based on the TWI driver for the AT91 (at91_twi.c). 34 * 35 * CAUTION: The I2Ci registers are limited to 16 bit and 8 bit data accesses, 36 * 32 bit data access is not allowed and can corrupt register content. 37 * 38 * This driver currently doesn't use DMA for the transfer, although I hope to 39 * incorporate that sometime in the future. The idea being that for transaction 40 * larger than a certain size the DMA engine is used, for anything less the 41 * normal interrupt/fifo driven option is used. 42 */ 43 44 #include <sys/cdefs.h> 45 __FBSDID("$FreeBSD$"); 46 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/bus.h> 50 #include <sys/conf.h> 51 #include <sys/kernel.h> 52 #include <sys/lock.h> 53 #include <sys/mbuf.h> 54 #include <sys/malloc.h> 55 #include <sys/module.h> 56 #include <sys/mutex.h> 57 #include <sys/rman.h> 58 #include <sys/sysctl.h> 59 #include <machine/bus.h> 60 61 #include <dev/ofw/openfirm.h> 62 #include <dev/ofw/ofw_bus.h> 63 #include <dev/ofw/ofw_bus_subr.h> 64 65 #include <arm/ti/ti_cpuid.h> 66 #include <arm/ti/ti_sysc.h> 67 #include <arm/ti/ti_i2c.h> 68 69 #include <dev/iicbus/iiconf.h> 70 #include <dev/iicbus/iicbus.h> 71 72 #include "iicbus_if.h" 73 74 /** 75 * I2C device driver context, a pointer to this is stored in the device 76 * driver structure. 77 */ 78 struct ti_i2c_softc 79 { 80 device_t sc_dev; 81 struct resource* sc_irq_res; 82 struct resource* sc_mem_res; 83 device_t sc_iicbus; 84 85 void* sc_irq_h; 86 87 struct mtx sc_mtx; 88 89 struct iic_msg* sc_buffer; 90 int sc_bus_inuse; 91 int sc_buffer_pos; 92 int sc_error; 93 int sc_fifo_trsh; 94 int sc_timeout; 95 96 uint16_t sc_con_reg; 97 uint16_t sc_rev; 98 }; 99 100 struct ti_i2c_clock_config 101 { 102 u_int frequency; /* Bus frequency in Hz */ 103 uint8_t psc; /* Fast/Standard mode prescale divider */ 104 uint8_t scll; /* Fast/Standard mode SCL low time */ 105 uint8_t sclh; /* Fast/Standard mode SCL high time */ 106 uint8_t hsscll; /* High Speed mode SCL low time */ 107 uint8_t hssclh; /* High Speed mode SCL high time */ 108 }; 109 110 #if defined(SOC_OMAP4) 111 /* 112 * OMAP4 i2c bus clock is 96MHz / ((psc + 1) * (scll + 7 + sclh + 5)). 113 * The prescaler values for 100KHz and 400KHz modes come from the table in the 114 * OMAP4 TRM. The table doesn't list 1MHz; these values should give that speed. 115 */ 116 static struct ti_i2c_clock_config ti_omap4_i2c_clock_configs[] = { 117 { 100000, 23, 13, 15, 0, 0}, 118 { 400000, 9, 5, 7, 0, 0}, 119 { 1000000, 3, 5, 7, 0, 0}, 120 /* { 3200000, 1, 113, 115, 7, 10}, - HS mode */ 121 { 0 /* Table terminator */ } 122 }; 123 #endif 124 125 #if defined(SOC_TI_AM335X) 126 /* 127 * AM335x i2c bus clock is 48MHZ / ((psc + 1) * (scll + 7 + sclh + 5)) 128 * In all cases we prescale the clock to 24MHz as recommended in the manual. 129 */ 130 static struct ti_i2c_clock_config ti_am335x_i2c_clock_configs[] = { 131 { 100000, 1, 111, 117, 0, 0}, 132 { 400000, 1, 23, 25, 0, 0}, 133 { 1000000, 1, 5, 7, 0, 0}, 134 { 0 /* Table terminator */ } 135 }; 136 #endif 137 138 /** 139 * Locking macros used throughout the driver 140 */ 141 #define TI_I2C_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx) 142 #define TI_I2C_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx) 143 #define TI_I2C_LOCK_INIT(_sc) \ 144 mtx_init(&_sc->sc_mtx, device_get_nameunit(_sc->sc_dev), \ 145 "ti_i2c", MTX_DEF) 146 #define TI_I2C_LOCK_DESTROY(_sc) mtx_destroy(&_sc->sc_mtx) 147 #define TI_I2C_ASSERT_LOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_OWNED) 148 #define TI_I2C_ASSERT_UNLOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_NOTOWNED) 149 150 #ifdef DEBUG 151 #define ti_i2c_dbg(_sc, fmt, args...) \ 152 device_printf((_sc)->sc_dev, fmt, ##args) 153 #else 154 #define ti_i2c_dbg(_sc, fmt, args...) 155 #endif 156 157 /** 158 * ti_i2c_read_2 - reads a 16-bit value from one of the I2C registers 159 * @sc: I2C device context 160 * @off: the byte offset within the register bank to read from. 161 * 162 * 163 * LOCKING: 164 * No locking required 165 * 166 * RETURNS: 167 * 16-bit value read from the register. 168 */ 169 static inline uint16_t 170 ti_i2c_read_2(struct ti_i2c_softc *sc, bus_size_t off) 171 { 172 173 return (bus_read_2(sc->sc_mem_res, off)); 174 } 175 176 /** 177 * ti_i2c_write_2 - writes a 16-bit value to one of the I2C registers 178 * @sc: I2C device context 179 * @off: the byte offset within the register bank to read from. 180 * @val: the value to write into the register 181 * 182 * LOCKING: 183 * No locking required 184 * 185 * RETURNS: 186 * 16-bit value read from the register. 187 */ 188 static inline void 189 ti_i2c_write_2(struct ti_i2c_softc *sc, bus_size_t off, uint16_t val) 190 { 191 192 bus_write_2(sc->sc_mem_res, off, val); 193 } 194 195 static int 196 ti_i2c_transfer_intr(struct ti_i2c_softc* sc, uint16_t status) 197 { 198 int amount, done, i; 199 200 done = 0; 201 amount = 0; 202 /* Check for the error conditions. */ 203 if (status & I2C_STAT_NACK) { 204 /* No ACK from slave. */ 205 ti_i2c_dbg(sc, "NACK\n"); 206 ti_i2c_write_2(sc, I2C_REG_STATUS, I2C_STAT_NACK); 207 sc->sc_error = ENXIO; 208 } else if (status & I2C_STAT_AL) { 209 /* Arbitration lost. */ 210 ti_i2c_dbg(sc, "Arbitration lost\n"); 211 ti_i2c_write_2(sc, I2C_REG_STATUS, I2C_STAT_AL); 212 sc->sc_error = ENXIO; 213 } 214 215 /* Check if we have finished. */ 216 if (status & I2C_STAT_ARDY) { 217 /* Register access ready - transaction complete basically. */ 218 ti_i2c_dbg(sc, "ARDY transaction complete\n"); 219 if (sc->sc_error != 0 && sc->sc_buffer->flags & IIC_M_NOSTOP) { 220 ti_i2c_write_2(sc, I2C_REG_CON, 221 sc->sc_con_reg | I2C_CON_STP); 222 } 223 ti_i2c_write_2(sc, I2C_REG_STATUS, 224 I2C_STAT_ARDY | I2C_STAT_RDR | I2C_STAT_RRDY | 225 I2C_STAT_XDR | I2C_STAT_XRDY); 226 return (1); 227 } 228 229 if (sc->sc_buffer->flags & IIC_M_RD) { 230 /* Read some data. */ 231 if (status & I2C_STAT_RDR) { 232 /* 233 * Receive draining interrupt - last data received. 234 * The set FIFO threshold won't be reached to trigger 235 * RRDY. 236 */ 237 ti_i2c_dbg(sc, "Receive draining interrupt\n"); 238 239 /* 240 * Drain the FIFO. Read the pending data in the FIFO. 241 */ 242 amount = sc->sc_buffer->len - sc->sc_buffer_pos; 243 } else if (status & I2C_STAT_RRDY) { 244 /* 245 * Receive data ready interrupt - FIFO has reached the 246 * set threshold. 247 */ 248 ti_i2c_dbg(sc, "Receive data ready interrupt\n"); 249 250 amount = min(sc->sc_fifo_trsh, 251 sc->sc_buffer->len - sc->sc_buffer_pos); 252 } 253 254 /* Read the bytes from the fifo. */ 255 for (i = 0; i < amount; i++) 256 sc->sc_buffer->buf[sc->sc_buffer_pos++] = 257 (uint8_t)(ti_i2c_read_2(sc, I2C_REG_DATA) & 0xff); 258 259 if (status & I2C_STAT_RDR) 260 ti_i2c_write_2(sc, I2C_REG_STATUS, I2C_STAT_RDR); 261 if (status & I2C_STAT_RRDY) 262 ti_i2c_write_2(sc, I2C_REG_STATUS, I2C_STAT_RRDY); 263 264 } else { 265 /* Write some data. */ 266 if (status & I2C_STAT_XDR) { 267 /* 268 * Transmit draining interrupt - FIFO level is below 269 * the set threshold and the amount of data still to 270 * be transferred won't reach the set FIFO threshold. 271 */ 272 ti_i2c_dbg(sc, "Transmit draining interrupt\n"); 273 274 /* 275 * Drain the TX data. Write the pending data in the 276 * FIFO. 277 */ 278 amount = sc->sc_buffer->len - sc->sc_buffer_pos; 279 } else if (status & I2C_STAT_XRDY) { 280 /* 281 * Transmit data ready interrupt - the FIFO level 282 * is below the set threshold. 283 */ 284 ti_i2c_dbg(sc, "Transmit data ready interrupt\n"); 285 286 amount = min(sc->sc_fifo_trsh, 287 sc->sc_buffer->len - sc->sc_buffer_pos); 288 } 289 290 /* Write the bytes from the fifo. */ 291 for (i = 0; i < amount; i++) 292 ti_i2c_write_2(sc, I2C_REG_DATA, 293 sc->sc_buffer->buf[sc->sc_buffer_pos++]); 294 295 if (status & I2C_STAT_XDR) 296 ti_i2c_write_2(sc, I2C_REG_STATUS, I2C_STAT_XDR); 297 if (status & I2C_STAT_XRDY) 298 ti_i2c_write_2(sc, I2C_REG_STATUS, I2C_STAT_XRDY); 299 } 300 301 return (done); 302 } 303 304 /** 305 * ti_i2c_intr - interrupt handler for the I2C module 306 * @dev: i2c device handle 307 * 308 * 309 * 310 * LOCKING: 311 * Called from timer context 312 * 313 * RETURNS: 314 * EH_HANDLED or EH_NOT_HANDLED 315 */ 316 static void 317 ti_i2c_intr(void *arg) 318 { 319 int done; 320 struct ti_i2c_softc *sc; 321 uint16_t events, status; 322 323 sc = (struct ti_i2c_softc *)arg; 324 325 TI_I2C_LOCK(sc); 326 327 status = ti_i2c_read_2(sc, I2C_REG_STATUS); 328 if (status == 0) { 329 TI_I2C_UNLOCK(sc); 330 return; 331 } 332 333 /* Save enabled interrupts. */ 334 events = ti_i2c_read_2(sc, I2C_REG_IRQENABLE_SET); 335 336 /* We only care about enabled interrupts. */ 337 status &= events; 338 339 done = 0; 340 341 if (sc->sc_buffer != NULL) 342 done = ti_i2c_transfer_intr(sc, status); 343 else { 344 ti_i2c_dbg(sc, "Transfer interrupt without buffer\n"); 345 sc->sc_error = EINVAL; 346 done = 1; 347 } 348 349 if (done) 350 /* Wakeup the process that started the transaction. */ 351 wakeup(sc); 352 353 TI_I2C_UNLOCK(sc); 354 } 355 356 /** 357 * ti_i2c_transfer - called to perform the transfer 358 * @dev: i2c device handle 359 * @msgs: the messages to send/receive 360 * @nmsgs: the number of messages in the msgs array 361 * 362 * 363 * LOCKING: 364 * Internally locked 365 * 366 * RETURNS: 367 * 0 on function succeeded 368 * EINVAL if invalid message is passed as an arg 369 */ 370 static int 371 ti_i2c_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs) 372 { 373 int err, i, repstart, timeout; 374 struct ti_i2c_softc *sc; 375 uint16_t reg; 376 377 sc = device_get_softc(dev); 378 TI_I2C_LOCK(sc); 379 380 /* If the controller is busy wait until it is available. */ 381 while (sc->sc_bus_inuse == 1) 382 mtx_sleep(sc, &sc->sc_mtx, 0, "i2cbuswait", 0); 383 384 /* Now we have control over the I2C controller. */ 385 sc->sc_bus_inuse = 1; 386 387 err = 0; 388 repstart = 0; 389 for (i = 0; i < nmsgs; i++) { 390 391 sc->sc_buffer = &msgs[i]; 392 sc->sc_buffer_pos = 0; 393 sc->sc_error = 0; 394 395 /* Zero byte transfers aren't allowed. */ 396 if (sc->sc_buffer == NULL || sc->sc_buffer->buf == NULL || 397 sc->sc_buffer->len == 0) { 398 err = EINVAL; 399 break; 400 } 401 402 /* Check if the i2c bus is free. */ 403 if (repstart == 0) { 404 /* 405 * On repeated start we send the START condition while 406 * the bus _is_ busy. 407 */ 408 timeout = 0; 409 while (ti_i2c_read_2(sc, I2C_REG_STATUS_RAW) & I2C_STAT_BB) { 410 if (timeout++ > 100) { 411 err = EBUSY; 412 goto out; 413 } 414 DELAY(1000); 415 } 416 timeout = 0; 417 } else 418 repstart = 0; 419 420 if (sc->sc_buffer->flags & IIC_M_NOSTOP) 421 repstart = 1; 422 423 /* Set the slave address. */ 424 ti_i2c_write_2(sc, I2C_REG_SA, msgs[i].slave >> 1); 425 426 /* Write the data length. */ 427 ti_i2c_write_2(sc, I2C_REG_CNT, sc->sc_buffer->len); 428 429 /* Clear the RX and the TX FIFO. */ 430 reg = ti_i2c_read_2(sc, I2C_REG_BUF); 431 reg |= I2C_BUF_RXFIFO_CLR | I2C_BUF_TXFIFO_CLR; 432 ti_i2c_write_2(sc, I2C_REG_BUF, reg); 433 434 reg = sc->sc_con_reg | I2C_CON_STT; 435 if (repstart == 0) 436 reg |= I2C_CON_STP; 437 if ((sc->sc_buffer->flags & IIC_M_RD) == 0) 438 reg |= I2C_CON_TRX; 439 ti_i2c_write_2(sc, I2C_REG_CON, reg); 440 441 /* Wait for an event. */ 442 err = mtx_sleep(sc, &sc->sc_mtx, 0, "i2ciowait", sc->sc_timeout); 443 if (err == 0) 444 err = sc->sc_error; 445 446 if (err) 447 break; 448 } 449 450 out: 451 if (timeout == 0) { 452 while (ti_i2c_read_2(sc, I2C_REG_STATUS_RAW) & I2C_STAT_BB) { 453 if (timeout++ > 100) 454 break; 455 DELAY(1000); 456 } 457 } 458 /* Put the controller in master mode again. */ 459 if ((ti_i2c_read_2(sc, I2C_REG_CON) & I2C_CON_MST) == 0) 460 ti_i2c_write_2(sc, I2C_REG_CON, sc->sc_con_reg); 461 462 sc->sc_buffer = NULL; 463 sc->sc_bus_inuse = 0; 464 465 /* Wake up the processes that are waiting for the bus. */ 466 wakeup(sc); 467 468 TI_I2C_UNLOCK(sc); 469 470 return (err); 471 } 472 473 static int 474 ti_i2c_reset(struct ti_i2c_softc *sc, u_char speed) 475 { 476 int timeout; 477 struct ti_i2c_clock_config *clkcfg; 478 u_int busfreq; 479 uint16_t fifo_trsh, reg, scll, sclh; 480 481 switch (ti_chip()) { 482 #ifdef SOC_OMAP4 483 case CHIP_OMAP_4: 484 clkcfg = ti_omap4_i2c_clock_configs; 485 break; 486 #endif 487 #ifdef SOC_TI_AM335X 488 case CHIP_AM335X: 489 clkcfg = ti_am335x_i2c_clock_configs; 490 break; 491 #endif 492 default: 493 panic("Unknown TI SoC, unable to reset the i2c"); 494 } 495 496 /* 497 * If we haven't attached the bus yet, just init at the default slow 498 * speed. This lets us get the hardware initialized enough to attach 499 * the bus which is where the real speed configuration is handled. After 500 * the bus is attached, get the configured speed from it. Search the 501 * configuration table for the best speed we can do that doesn't exceed 502 * the requested speed. 503 */ 504 if (sc->sc_iicbus == NULL) 505 busfreq = 100000; 506 else 507 busfreq = IICBUS_GET_FREQUENCY(sc->sc_iicbus, speed); 508 for (;;) { 509 if (clkcfg[1].frequency == 0 || clkcfg[1].frequency > busfreq) 510 break; 511 clkcfg++; 512 } 513 514 /* 515 * 23.1.4.3 - HS I2C Software Reset 516 * From OMAP4 TRM at page 4068. 517 * 518 * 1. Ensure that the module is disabled. 519 */ 520 sc->sc_con_reg = 0; 521 ti_i2c_write_2(sc, I2C_REG_CON, sc->sc_con_reg); 522 523 /* 2. Issue a softreset to the controller. */ 524 bus_write_2(sc->sc_mem_res, I2C_REG_SYSC, I2C_REG_SYSC_SRST); 525 526 /* 527 * 3. Enable the module. 528 * The I2Ci.I2C_SYSS[0] RDONE bit is asserted only after the module 529 * is enabled by setting the I2Ci.I2C_CON[15] I2C_EN bit to 1. 530 */ 531 ti_i2c_write_2(sc, I2C_REG_CON, I2C_CON_I2C_EN); 532 533 /* 4. Wait for the software reset to complete. */ 534 timeout = 0; 535 while ((ti_i2c_read_2(sc, I2C_REG_SYSS) & I2C_SYSS_RDONE) == 0) { 536 if (timeout++ > 100) 537 return (EBUSY); 538 DELAY(100); 539 } 540 541 /* 542 * Disable the I2C controller once again, now that the reset has 543 * finished. 544 */ 545 ti_i2c_write_2(sc, I2C_REG_CON, sc->sc_con_reg); 546 547 /* 548 * The following sequence is taken from the OMAP4 TRM at page 4077. 549 * 550 * 1. Enable the functional and interface clocks (see Section 551 * 23.1.5.1.1.1.1). Done at ti_i2c_activate(). 552 * 553 * 2. Program the prescaler to obtain an approximately 12MHz internal 554 * sampling clock (I2Ci_INTERNAL_CLK) by programming the 555 * corresponding value in the I2Ci.I2C_PSC[3:0] PSC field. 556 * This value depends on the frequency of the functional clock 557 * (I2Ci_FCLK). Because this frequency is 96MHz, the 558 * I2Ci.I2C_PSC[7:0] PSC field value is 0x7. 559 */ 560 ti_i2c_write_2(sc, I2C_REG_PSC, clkcfg->psc); 561 562 /* 563 * 3. Program the I2Ci.I2C_SCLL[7:0] SCLL and I2Ci.I2C_SCLH[7:0] SCLH 564 * bit fields to obtain a bit rate of 100 Kbps, 400 Kbps or 1Mbps. 565 * These values depend on the internal sampling clock frequency 566 * (see Table 23-8). 567 */ 568 scll = clkcfg->scll & I2C_SCLL_MASK; 569 sclh = clkcfg->sclh & I2C_SCLH_MASK; 570 571 /* 572 * 4. (Optional) Program the I2Ci.I2C_SCLL[15:8] HSSCLL and 573 * I2Ci.I2C_SCLH[15:8] HSSCLH fields to obtain a bit rate of 574 * 400K bps or 3.4M bps (for the second phase of HS mode). These 575 * values depend on the internal sampling clock frequency (see 576 * Table 23-8). 577 * 578 * 5. (Optional) If a bit rate of 3.4M bps is used and the bus line 579 * capacitance exceeds 45 pF, (see Section 18.4.8, PAD Functional 580 * Multiplexing and Configuration). 581 */ 582 switch (ti_chip()) { 583 #ifdef SOC_OMAP4 584 case CHIP_OMAP_4: 585 if ((clkcfg->hsscll + clkcfg->hssclh) > 0) { 586 scll |= clkcfg->hsscll << I2C_HSSCLL_SHIFT; 587 sclh |= clkcfg->hssclh << I2C_HSSCLH_SHIFT; 588 sc->sc_con_reg |= I2C_CON_OPMODE_HS; 589 } 590 break; 591 #endif 592 } 593 594 /* Write the selected bit rate. */ 595 ti_i2c_write_2(sc, I2C_REG_SCLL, scll); 596 ti_i2c_write_2(sc, I2C_REG_SCLH, sclh); 597 598 /* 599 * 6. Configure the Own Address of the I2C controller by storing it in 600 * the I2Ci.I2C_OA0 register. Up to four Own Addresses can be 601 * programmed in the I2Ci.I2C_OAi registers (where i = 0, 1, 2, 3) 602 * for each I2C controller. 603 * 604 * Note: For a 10-bit address, set the corresponding expand Own Address 605 * bit in the I2Ci.I2C_CON register. 606 * 607 * Driver currently always in single master mode so ignore this step. 608 */ 609 610 /* 611 * 7. Set the TX threshold (in transmitter mode) and the RX threshold 612 * (in receiver mode) by setting the I2Ci.I2C_BUF[5:0]XTRSH field to 613 * (TX threshold - 1) and the I2Ci.I2C_BUF[13:8]RTRSH field to (RX 614 * threshold - 1), where the TX and RX thresholds are greater than 615 * or equal to 1. 616 * 617 * The threshold is set to 5 for now. 618 */ 619 fifo_trsh = (sc->sc_fifo_trsh - 1) & I2C_BUF_TRSH_MASK; 620 reg = fifo_trsh | (fifo_trsh << I2C_BUF_RXTRSH_SHIFT); 621 ti_i2c_write_2(sc, I2C_REG_BUF, reg); 622 623 /* 624 * 8. Take the I2C controller out of reset by setting the 625 * I2Ci.I2C_CON[15] I2C_EN bit to 1. 626 * 627 * 23.1.5.1.1.1.2 - Initialize the I2C Controller 628 * 629 * To initialize the I2C controller, perform the following steps: 630 * 631 * 1. Configure the I2Ci.I2C_CON register: 632 * . For master or slave mode, set the I2Ci.I2C_CON[10] MST bit 633 * (0: slave, 1: master). 634 * . For transmitter or receiver mode, set the I2Ci.I2C_CON[9] TRX 635 * bit (0: receiver, 1: transmitter). 636 */ 637 638 /* Enable the I2C controller in master mode. */ 639 sc->sc_con_reg |= I2C_CON_I2C_EN | I2C_CON_MST; 640 ti_i2c_write_2(sc, I2C_REG_CON, sc->sc_con_reg); 641 642 /* 643 * 2. If using an interrupt to transmit/receive data, set the 644 * corresponding bit in the I2Ci.I2C_IE register (the I2Ci.I2C_IE[4] 645 * XRDY_IE bit for the transmit interrupt, the I2Ci.I2C_IE[3] RRDY 646 * bit for the receive interrupt). 647 */ 648 649 /* Set the interrupts we want to be notified. */ 650 reg = I2C_IE_XDR | /* Transmit draining interrupt. */ 651 I2C_IE_XRDY | /* Transmit Data Ready interrupt. */ 652 I2C_IE_RDR | /* Receive draining interrupt. */ 653 I2C_IE_RRDY | /* Receive Data Ready interrupt. */ 654 I2C_IE_ARDY | /* Register Access Ready interrupt. */ 655 I2C_IE_NACK | /* No Acknowledgment interrupt. */ 656 I2C_IE_AL; /* Arbitration lost interrupt. */ 657 658 /* Enable the interrupts. */ 659 ti_i2c_write_2(sc, I2C_REG_IRQENABLE_SET, reg); 660 661 /* 662 * 3. If using DMA to receive/transmit data, set to 1 the corresponding 663 * bit in the I2Ci.I2C_BUF register (the I2Ci.I2C_BUF[15] RDMA_EN 664 * bit for the receive DMA channel, the I2Ci.I2C_BUF[7] XDMA_EN bit 665 * for the transmit DMA channel). 666 * 667 * Not using DMA for now, so ignore this. 668 */ 669 670 return (0); 671 } 672 673 static int 674 ti_i2c_iicbus_reset(device_t dev, u_char speed, u_char addr, u_char *oldaddr) 675 { 676 struct ti_i2c_softc *sc; 677 int err; 678 679 sc = device_get_softc(dev); 680 TI_I2C_LOCK(sc); 681 err = ti_i2c_reset(sc, speed); 682 TI_I2C_UNLOCK(sc); 683 if (err) 684 return (err); 685 686 return (IIC_ENOADDR); 687 } 688 689 static int 690 ti_i2c_activate(device_t dev) 691 { 692 int err; 693 struct ti_i2c_softc *sc; 694 695 sc = (struct ti_i2c_softc*)device_get_softc(dev); 696 697 /* 698 * 1. Enable the functional and interface clocks (see Section 699 * 23.1.5.1.1.1.1). 700 */ 701 err = ti_sysc_clock_enable(device_get_parent(dev)); 702 if (err) 703 return (err); 704 705 return (ti_i2c_reset(sc, IIC_UNKNOWN)); 706 } 707 708 /** 709 * ti_i2c_deactivate - deactivates the controller and releases resources 710 * @dev: i2c device handle 711 * 712 * 713 * 714 * LOCKING: 715 * Assumed called in an atomic context. 716 * 717 * RETURNS: 718 * nothing 719 */ 720 static void 721 ti_i2c_deactivate(device_t dev) 722 { 723 struct ti_i2c_softc *sc = device_get_softc(dev); 724 725 /* Disable the controller - cancel all transactions. */ 726 ti_i2c_write_2(sc, I2C_REG_IRQENABLE_CLR, 0xffff); 727 ti_i2c_write_2(sc, I2C_REG_STATUS, 0xffff); 728 ti_i2c_write_2(sc, I2C_REG_CON, 0); 729 730 /* Release the interrupt handler. */ 731 if (sc->sc_irq_h != NULL) { 732 bus_teardown_intr(dev, sc->sc_irq_res, sc->sc_irq_h); 733 sc->sc_irq_h = NULL; 734 } 735 736 /* Unmap the I2C controller registers. */ 737 if (sc->sc_mem_res != NULL) { 738 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res); 739 sc->sc_mem_res = NULL; 740 } 741 742 /* Release the IRQ resource. */ 743 if (sc->sc_irq_res != NULL) { 744 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_irq_res); 745 sc->sc_irq_res = NULL; 746 } 747 748 /* Finally disable the functional and interface clocks. */ 749 ti_sysc_clock_disable(device_get_parent(dev)); 750 } 751 752 static int 753 ti_i2c_sysctl_clk(SYSCTL_HANDLER_ARGS) 754 { 755 int clk, psc, sclh, scll; 756 struct ti_i2c_softc *sc; 757 758 sc = arg1; 759 760 TI_I2C_LOCK(sc); 761 /* Get the system prescaler value. */ 762 psc = (int)ti_i2c_read_2(sc, I2C_REG_PSC) + 1; 763 764 /* Get the bitrate. */ 765 scll = (int)ti_i2c_read_2(sc, I2C_REG_SCLL) & I2C_SCLL_MASK; 766 sclh = (int)ti_i2c_read_2(sc, I2C_REG_SCLH) & I2C_SCLH_MASK; 767 768 clk = I2C_CLK / psc / (scll + 7 + sclh + 5); 769 TI_I2C_UNLOCK(sc); 770 771 return (sysctl_handle_int(oidp, &clk, 0, req)); 772 } 773 774 static int 775 ti_i2c_sysctl_timeout(SYSCTL_HANDLER_ARGS) 776 { 777 struct ti_i2c_softc *sc; 778 unsigned int val; 779 int err; 780 781 sc = arg1; 782 783 /* 784 * MTX_DEF lock can't be held while doing uimove in 785 * sysctl_handle_int 786 */ 787 TI_I2C_LOCK(sc); 788 val = sc->sc_timeout; 789 TI_I2C_UNLOCK(sc); 790 791 err = sysctl_handle_int(oidp, &val, 0, req); 792 /* Write request? */ 793 if ((err == 0) && (req->newptr != NULL)) { 794 TI_I2C_LOCK(sc); 795 sc->sc_timeout = val; 796 TI_I2C_UNLOCK(sc); 797 } 798 799 return (err); 800 } 801 802 static int 803 ti_i2c_probe(device_t dev) 804 { 805 806 if (!ofw_bus_status_okay(dev)) 807 return (ENXIO); 808 if (!ofw_bus_is_compatible(dev, "ti,omap4-i2c")) 809 return (ENXIO); 810 device_set_desc(dev, "TI I2C Controller"); 811 812 return (0); 813 } 814 815 static int 816 ti_i2c_attach(device_t dev) 817 { 818 int err, rid; 819 struct ti_i2c_softc *sc; 820 struct sysctl_ctx_list *ctx; 821 struct sysctl_oid_list *tree; 822 uint16_t fifosz; 823 824 sc = device_get_softc(dev); 825 sc->sc_dev = dev; 826 827 /* Get the memory resource for the register mapping. */ 828 rid = 0; 829 sc->sc_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 830 RF_ACTIVE); 831 if (sc->sc_mem_res == NULL) { 832 device_printf(dev, "Cannot map registers.\n"); 833 return (ENXIO); 834 } 835 836 /* Allocate our IRQ resource. */ 837 rid = 0; 838 sc->sc_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 839 RF_ACTIVE | RF_SHAREABLE); 840 if (sc->sc_irq_res == NULL) { 841 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res); 842 device_printf(dev, "Cannot allocate interrupt.\n"); 843 return (ENXIO); 844 } 845 846 TI_I2C_LOCK_INIT(sc); 847 848 /* First of all, we _must_ activate the H/W. */ 849 err = ti_i2c_activate(dev); 850 if (err) { 851 device_printf(dev, "ti_i2c_activate failed\n"); 852 goto out; 853 } 854 855 /* Read the version number of the I2C module */ 856 sc->sc_rev = ti_i2c_read_2(sc, I2C_REG_REVNB_HI) & 0xff; 857 858 /* Get the fifo size. */ 859 fifosz = ti_i2c_read_2(sc, I2C_REG_BUFSTAT); 860 fifosz >>= I2C_BUFSTAT_FIFODEPTH_SHIFT; 861 fifosz &= I2C_BUFSTAT_FIFODEPTH_MASK; 862 863 device_printf(dev, "I2C revision %d.%d FIFO size: %d bytes\n", 864 sc->sc_rev >> 4, sc->sc_rev & 0xf, 8 << fifosz); 865 866 /* Set the FIFO threshold to 5 for now. */ 867 sc->sc_fifo_trsh = 5; 868 869 /* Set I2C bus timeout */ 870 sc->sc_timeout = 5*hz; 871 872 ctx = device_get_sysctl_ctx(dev); 873 tree = SYSCTL_CHILDREN(device_get_sysctl_tree(dev)); 874 SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "i2c_clock", 875 CTLFLAG_RD | CTLTYPE_UINT | CTLFLAG_MPSAFE, sc, 0, 876 ti_i2c_sysctl_clk, "IU", "I2C bus clock"); 877 878 SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "i2c_timeout", 879 CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_MPSAFE, sc, 0, 880 ti_i2c_sysctl_timeout, "IU", "I2C bus timeout (in ticks)"); 881 882 /* Activate the interrupt. */ 883 err = bus_setup_intr(dev, sc->sc_irq_res, INTR_TYPE_MISC | INTR_MPSAFE, 884 NULL, ti_i2c_intr, sc, &sc->sc_irq_h); 885 if (err) 886 goto out; 887 888 /* Attach the iicbus. */ 889 if ((sc->sc_iicbus = device_add_child(dev, "iicbus", -1)) == NULL) { 890 device_printf(dev, "could not allocate iicbus instance\n"); 891 err = ENXIO; 892 goto out; 893 } 894 895 /* Probe and attach the iicbus when interrupts are available. */ 896 err = bus_delayed_attach_children(dev); 897 898 out: 899 if (err) { 900 ti_i2c_deactivate(dev); 901 TI_I2C_LOCK_DESTROY(sc); 902 } 903 904 return (err); 905 } 906 907 static int 908 ti_i2c_detach(device_t dev) 909 { 910 struct ti_i2c_softc *sc; 911 int rv; 912 913 sc = device_get_softc(dev); 914 915 if ((rv = bus_generic_detach(dev)) != 0) { 916 device_printf(dev, "cannot detach child devices\n"); 917 return (rv); 918 } 919 920 if (sc->sc_iicbus && 921 (rv = device_delete_child(dev, sc->sc_iicbus)) != 0) 922 return (rv); 923 924 ti_i2c_deactivate(dev); 925 TI_I2C_LOCK_DESTROY(sc); 926 927 return (0); 928 } 929 930 static phandle_t 931 ti_i2c_get_node(device_t bus, device_t dev) 932 { 933 934 /* Share controller node with iibus device. */ 935 return (ofw_bus_get_node(bus)); 936 } 937 938 static device_method_t ti_i2c_methods[] = { 939 /* Device interface */ 940 DEVMETHOD(device_probe, ti_i2c_probe), 941 DEVMETHOD(device_attach, ti_i2c_attach), 942 DEVMETHOD(device_detach, ti_i2c_detach), 943 944 /* Bus interface */ 945 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr), 946 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr), 947 DEVMETHOD(bus_alloc_resource, bus_generic_alloc_resource), 948 DEVMETHOD(bus_release_resource, bus_generic_release_resource), 949 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource), 950 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource), 951 DEVMETHOD(bus_adjust_resource, bus_generic_adjust_resource), 952 DEVMETHOD(bus_set_resource, bus_generic_rl_set_resource), 953 DEVMETHOD(bus_get_resource, bus_generic_rl_get_resource), 954 955 /* OFW methods */ 956 DEVMETHOD(ofw_bus_get_node, ti_i2c_get_node), 957 958 /* iicbus interface */ 959 DEVMETHOD(iicbus_callback, iicbus_null_callback), 960 DEVMETHOD(iicbus_reset, ti_i2c_iicbus_reset), 961 DEVMETHOD(iicbus_transfer, ti_i2c_transfer), 962 963 DEVMETHOD_END 964 }; 965 966 static driver_t ti_i2c_driver = { 967 "iichb", 968 ti_i2c_methods, 969 sizeof(struct ti_i2c_softc), 970 }; 971 972 static devclass_t ti_i2c_devclass; 973 974 DRIVER_MODULE(ti_iic, simplebus, ti_i2c_driver, ti_i2c_devclass, 0, 0); 975 DRIVER_MODULE(iicbus, ti_iic, iicbus_driver, iicbus_devclass, 0, 0); 976 977 MODULE_DEPEND(ti_iic, ti_sysc, 1, 1, 1); 978 MODULE_DEPEND(ti_iic, iicbus, 1, 1, 1); 979