1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2001 Tsubai Masanari. 5 * Copyright (c) 2012 Oleksandr Tymoshenko <gonzo@freebsd.org> 6 * Copyright (c) 2013 Luiz Otavio O Souza <loos@freebsd.org> 7 * Copyright (c) 2017 Ian Lepore <ian@freebsd.org> 8 * All rights reserved. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 */ 32 #include <sys/cdefs.h> 33 /* 34 * Driver for bcm2835 i2c-compatible two-wire bus, named 'BSC' on this SoC. 35 * 36 * This controller can only perform complete transfers, it does not provide 37 * low-level control over sending start/repeat-start/stop sequences on the bus. 38 * In addition, bugs in the silicon make it somewhat difficult to perform a 39 * repeat-start, and limit the repeat-start to a read following a write on 40 * the same slave device. (The i2c protocol allows a repeat start to change 41 * direction or not, and change slave address or not at any time.) 42 * 43 * The repeat-start bug and workaround are described in a problem report at 44 * https://github.com/raspberrypi/linux/issues/254 with the crucial part being 45 * in a comment block from a fragment of a GPU i2c driver, containing this: 46 * 47 * ----------------------------------------------------------------------------- 48 * - See i2c.v: The I2C peripheral samples the values for rw_bit and xfer_count 49 * - in the IDLE state if start is set. 50 * - 51 * - We want to generate a ReSTART not a STOP at the end of the TX phase. In 52 * - order to do that we must ensure the state machine goes RACK1 -> RACK2 -> 53 * - SRSTRT1 (not RACK1 -> RACK2 -> SSTOP1). 54 * - 55 * - So, in the RACK2 state when (TX) xfer_count==0 we must therefore have 56 * - already set, ready to be sampled: 57 * - READ ; rw_bit <= I2CC bit 0 -- must be "read" 58 * - ST; start <= I2CC bit 7 -- must be "Go" in order to not issue STOP 59 * - DLEN; xfer_count <= I2CDLEN -- must be equal to our read amount 60 * - 61 * - The plan to do this is: 62 * - 1. Start the sub-address write, but don't let it finish 63 * - (keep xfer_count > 0) 64 * - 2. Populate READ, DLEN and ST in preparation for ReSTART read sequence 65 * - 3. Let TX finish (write the rest of the data) 66 * - 4. Read back data as it arrives 67 * ----------------------------------------------------------------------------- 68 * 69 * The transfer function below scans the list of messages passed to it, looking 70 * for a read following a write to the same slave. When it finds that, it 71 * starts the write without prefilling the tx fifo, which holds xfer_count>0, 72 * then presets the direction, length, and start command for the following read, 73 * as described above. Then the tx fifo is filled and the rest of the transfer 74 * proceeds as normal, with the controller automatically supplying a 75 * repeat-start on the bus when the write operation finishes. 76 * 77 * XXX I suspect the controller may be able to do a repeat-start on any 78 * write->read or write->write transition, even when the slave addresses differ. 79 * It's unclear whether the slave address can be prestaged along with the 80 * direction and length while the write xfer_count is being held at zero. In 81 * fact, if it can't do this, then it couldn't be used to read EDID data. 82 */ 83 84 #include <sys/param.h> 85 #include <sys/systm.h> 86 #include <sys/kernel.h> 87 #include <sys/lock.h> 88 #include <sys/module.h> 89 #include <sys/mutex.h> 90 #include <sys/bus.h> 91 #include <machine/resource.h> 92 #include <machine/bus.h> 93 #include <sys/rman.h> 94 #include <sys/sysctl.h> 95 96 #include <dev/iicbus/iicbus.h> 97 #include <dev/iicbus/iiconf.h> 98 #include <dev/ofw/ofw_bus.h> 99 #include <dev/ofw/ofw_bus_subr.h> 100 101 #include <arm/broadcom/bcm2835/bcm2835_bscreg.h> 102 #include <arm/broadcom/bcm2835/bcm2835_bscvar.h> 103 104 #include "iicbus_if.h" 105 106 static struct ofw_compat_data compat_data[] = { 107 {"broadcom,bcm2835-bsc", 1}, 108 {"brcm,bcm2708-i2c", 1}, 109 {"brcm,bcm2835-i2c", 1}, 110 {NULL, 0} 111 }; 112 113 #define DEVICE_DEBUGF(sc, lvl, fmt, args...) \ 114 if ((lvl) <= (sc)->sc_debug) \ 115 device_printf((sc)->sc_dev, fmt, ##args) 116 117 #define DEBUGF(sc, lvl, fmt, args...) \ 118 if ((lvl) <= (sc)->sc_debug) \ 119 printf(fmt, ##args) 120 121 static void bcm_bsc_intr(void *); 122 static int bcm_bsc_detach(device_t); 123 124 static void 125 bcm_bsc_modifyreg(struct bcm_bsc_softc *sc, uint32_t off, uint32_t mask, 126 uint32_t value) 127 { 128 uint32_t reg; 129 130 mtx_assert(&sc->sc_mtx, MA_OWNED); 131 reg = BCM_BSC_READ(sc, off); 132 reg &= ~mask; 133 reg |= value; 134 BCM_BSC_WRITE(sc, off, reg); 135 } 136 137 static int 138 bcm_bsc_clock_proc(SYSCTL_HANDLER_ARGS) 139 { 140 struct bcm_bsc_softc *sc; 141 uint32_t clk; 142 143 sc = (struct bcm_bsc_softc *)arg1; 144 BCM_BSC_LOCK(sc); 145 clk = BCM_BSC_READ(sc, BCM_BSC_CLOCK); 146 BCM_BSC_UNLOCK(sc); 147 clk &= 0xffff; 148 if (clk == 0) 149 clk = 32768; 150 clk = BCM_BSC_CORE_CLK / clk; 151 152 return (sysctl_handle_int(oidp, &clk, 0, req)); 153 } 154 155 static int 156 bcm_bsc_clkt_proc(SYSCTL_HANDLER_ARGS) 157 { 158 struct bcm_bsc_softc *sc; 159 uint32_t clkt; 160 int error; 161 162 sc = (struct bcm_bsc_softc *)arg1; 163 164 BCM_BSC_LOCK(sc); 165 clkt = BCM_BSC_READ(sc, BCM_BSC_CLKT); 166 BCM_BSC_UNLOCK(sc); 167 clkt &= 0xffff; 168 error = sysctl_handle_int(oidp, &clkt, sizeof(clkt), req); 169 if (error != 0 || req->newptr == NULL) 170 return (error); 171 172 BCM_BSC_LOCK(sc); 173 BCM_BSC_WRITE(sc, BCM_BSC_CLKT, clkt & 0xffff); 174 BCM_BSC_UNLOCK(sc); 175 176 return (0); 177 } 178 179 static int 180 bcm_bsc_fall_proc(SYSCTL_HANDLER_ARGS) 181 { 182 struct bcm_bsc_softc *sc; 183 uint32_t clk, reg; 184 int error; 185 186 sc = (struct bcm_bsc_softc *)arg1; 187 188 BCM_BSC_LOCK(sc); 189 reg = BCM_BSC_READ(sc, BCM_BSC_DELAY); 190 BCM_BSC_UNLOCK(sc); 191 reg >>= 16; 192 error = sysctl_handle_int(oidp, ®, sizeof(reg), req); 193 if (error != 0 || req->newptr == NULL) 194 return (error); 195 196 BCM_BSC_LOCK(sc); 197 clk = BCM_BSC_READ(sc, BCM_BSC_CLOCK); 198 clk = BCM_BSC_CORE_CLK / clk; 199 if (reg > clk / 2) 200 reg = clk / 2 - 1; 201 bcm_bsc_modifyreg(sc, BCM_BSC_DELAY, 0xffff0000, reg << 16); 202 BCM_BSC_UNLOCK(sc); 203 204 return (0); 205 } 206 207 static int 208 bcm_bsc_rise_proc(SYSCTL_HANDLER_ARGS) 209 { 210 struct bcm_bsc_softc *sc; 211 uint32_t clk, reg; 212 int error; 213 214 sc = (struct bcm_bsc_softc *)arg1; 215 216 BCM_BSC_LOCK(sc); 217 reg = BCM_BSC_READ(sc, BCM_BSC_DELAY); 218 BCM_BSC_UNLOCK(sc); 219 reg &= 0xffff; 220 error = sysctl_handle_int(oidp, ®, sizeof(reg), req); 221 if (error != 0 || req->newptr == NULL) 222 return (error); 223 224 BCM_BSC_LOCK(sc); 225 clk = BCM_BSC_READ(sc, BCM_BSC_CLOCK); 226 clk = BCM_BSC_CORE_CLK / clk; 227 if (reg > clk / 2) 228 reg = clk / 2 - 1; 229 bcm_bsc_modifyreg(sc, BCM_BSC_DELAY, 0xffff, reg); 230 BCM_BSC_UNLOCK(sc); 231 232 return (0); 233 } 234 235 static void 236 bcm_bsc_sysctl_init(struct bcm_bsc_softc *sc) 237 { 238 struct sysctl_ctx_list *ctx; 239 struct sysctl_oid *tree_node; 240 struct sysctl_oid_list *tree; 241 242 /* 243 * Add system sysctl tree/handlers. 244 */ 245 ctx = device_get_sysctl_ctx(sc->sc_dev); 246 tree_node = device_get_sysctl_tree(sc->sc_dev); 247 tree = SYSCTL_CHILDREN(tree_node); 248 SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "frequency", 249 CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_NEEDGIANT, 250 sc, sizeof(*sc), 251 bcm_bsc_clock_proc, "IU", "I2C BUS clock frequency"); 252 SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "clock_stretch", 253 CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_NEEDGIANT, 254 sc, sizeof(*sc), 255 bcm_bsc_clkt_proc, "IU", "I2C BUS clock stretch timeout"); 256 SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "fall_edge_delay", 257 CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_NEEDGIANT, 258 sc, sizeof(*sc), 259 bcm_bsc_fall_proc, "IU", "I2C BUS falling edge delay"); 260 SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "rise_edge_delay", 261 CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_NEEDGIANT, 262 sc, sizeof(*sc), 263 bcm_bsc_rise_proc, "IU", "I2C BUS rising edge delay"); 264 SYSCTL_ADD_INT(ctx, tree, OID_AUTO, "debug", 265 CTLFLAG_RWTUN, &sc->sc_debug, 0, 266 "Enable debug; 1=reads/writes, 2=add starts/stops"); 267 } 268 269 static void 270 bcm_bsc_reset(struct bcm_bsc_softc *sc) 271 { 272 273 /* Enable the BSC Controller, disable interrupts. */ 274 BCM_BSC_WRITE(sc, BCM_BSC_CTRL, BCM_BSC_CTRL_I2CEN); 275 /* Clear pending interrupts. */ 276 BCM_BSC_WRITE(sc, BCM_BSC_STATUS, BCM_BSC_STATUS_CLKT | 277 BCM_BSC_STATUS_ERR | BCM_BSC_STATUS_DONE); 278 /* Clear the FIFO. */ 279 bcm_bsc_modifyreg(sc, BCM_BSC_CTRL, BCM_BSC_CTRL_CLEAR0, 280 BCM_BSC_CTRL_CLEAR0); 281 } 282 283 static int 284 bcm_bsc_probe(device_t dev) 285 { 286 287 if (!ofw_bus_status_okay(dev)) 288 return (ENXIO); 289 290 if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 0) 291 return (ENXIO); 292 293 device_set_desc(dev, "BCM2708/2835 BSC controller"); 294 295 return (BUS_PROBE_DEFAULT); 296 } 297 298 static int 299 bcm_bsc_attach(device_t dev) 300 { 301 struct bcm_bsc_softc *sc; 302 int rid; 303 304 sc = device_get_softc(dev); 305 sc->sc_dev = dev; 306 307 rid = 0; 308 sc->sc_mem_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 309 RF_ACTIVE); 310 if (!sc->sc_mem_res) { 311 device_printf(dev, "cannot allocate memory window\n"); 312 return (ENXIO); 313 } 314 315 sc->sc_bst = rman_get_bustag(sc->sc_mem_res); 316 sc->sc_bsh = rman_get_bushandle(sc->sc_mem_res); 317 318 rid = 0; 319 sc->sc_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 320 RF_ACTIVE | RF_SHAREABLE); 321 if (!sc->sc_irq_res) { 322 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res); 323 device_printf(dev, "cannot allocate interrupt\n"); 324 return (ENXIO); 325 } 326 327 /* Hook up our interrupt handler. */ 328 if (bus_setup_intr(dev, sc->sc_irq_res, INTR_TYPE_MISC | INTR_MPSAFE, 329 NULL, bcm_bsc_intr, sc, &sc->sc_intrhand)) { 330 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_irq_res); 331 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res); 332 device_printf(dev, "cannot setup the interrupt handler\n"); 333 return (ENXIO); 334 } 335 336 mtx_init(&sc->sc_mtx, "bcm_bsc", NULL, MTX_DEF); 337 338 bcm_bsc_sysctl_init(sc); 339 340 /* Enable the BSC controller. Flush the FIFO. */ 341 BCM_BSC_LOCK(sc); 342 bcm_bsc_reset(sc); 343 BCM_BSC_UNLOCK(sc); 344 345 sc->sc_iicbus = device_add_child(dev, "iicbus", DEVICE_UNIT_ANY); 346 if (sc->sc_iicbus == NULL) { 347 bcm_bsc_detach(dev); 348 return (ENXIO); 349 } 350 351 /* Probe and attach the iicbus when interrupts are available. */ 352 bus_delayed_attach_children(dev); 353 return (0); 354 } 355 356 static int 357 bcm_bsc_detach(device_t dev) 358 { 359 struct bcm_bsc_softc *sc; 360 361 bus_generic_detach(dev); 362 363 sc = device_get_softc(dev); 364 if (sc->sc_iicbus != NULL) 365 device_delete_child(dev, sc->sc_iicbus); 366 mtx_destroy(&sc->sc_mtx); 367 if (sc->sc_intrhand) 368 bus_teardown_intr(dev, sc->sc_irq_res, sc->sc_intrhand); 369 if (sc->sc_irq_res) 370 bus_release_resource(dev, SYS_RES_IRQ, 0, sc->sc_irq_res); 371 if (sc->sc_mem_res) 372 bus_release_resource(dev, SYS_RES_MEMORY, 0, sc->sc_mem_res); 373 374 return (0); 375 } 376 377 static void 378 bcm_bsc_empty_rx_fifo(struct bcm_bsc_softc *sc) 379 { 380 uint32_t status; 381 382 /* Assumes sc_totlen > 0 and BCM_BSC_STATUS_RXD is asserted on entry. */ 383 do { 384 if (sc->sc_resid == 0) { 385 sc->sc_data = sc->sc_curmsg->buf; 386 sc->sc_dlen = sc->sc_curmsg->len; 387 sc->sc_resid = sc->sc_dlen; 388 ++sc->sc_curmsg; 389 } 390 do { 391 *sc->sc_data = BCM_BSC_READ(sc, BCM_BSC_DATA); 392 DEBUGF(sc, 1, "0x%02x ", *sc->sc_data); 393 ++sc->sc_data; 394 --sc->sc_resid; 395 --sc->sc_totlen; 396 status = BCM_BSC_READ(sc, BCM_BSC_STATUS); 397 } while (sc->sc_resid > 0 && (status & BCM_BSC_STATUS_RXD)); 398 } while (sc->sc_totlen > 0 && (status & BCM_BSC_STATUS_RXD)); 399 } 400 401 static void 402 bcm_bsc_fill_tx_fifo(struct bcm_bsc_softc *sc) 403 { 404 uint32_t status; 405 406 /* Assumes sc_totlen > 0 and BCM_BSC_STATUS_TXD is asserted on entry. */ 407 do { 408 if (sc->sc_resid == 0) { 409 sc->sc_data = sc->sc_curmsg->buf; 410 sc->sc_dlen = sc->sc_curmsg->len; 411 sc->sc_resid = sc->sc_dlen; 412 ++sc->sc_curmsg; 413 } 414 do { 415 BCM_BSC_WRITE(sc, BCM_BSC_DATA, *sc->sc_data); 416 DEBUGF(sc, 1, "0x%02x ", *sc->sc_data); 417 ++sc->sc_data; 418 --sc->sc_resid; 419 --sc->sc_totlen; 420 status = BCM_BSC_READ(sc, BCM_BSC_STATUS); 421 } while (sc->sc_resid > 0 && (status & BCM_BSC_STATUS_TXD)); 422 /* 423 * If a repeat-start was pending and we just hit the end of a tx 424 * buffer, see if it's also the end of the writes that preceeded 425 * the repeat-start. If so, log the repeat-start and the start 426 * of the following read, and return because we're not writing 427 * anymore (and TXD will be true because there's room to write 428 * in the fifo). 429 */ 430 if (sc->sc_replen > 0 && sc->sc_resid == 0) { 431 sc->sc_replen -= sc->sc_dlen; 432 if (sc->sc_replen == 0) { 433 DEBUGF(sc, 1, " err=0\n"); 434 DEVICE_DEBUGF(sc, 2, "rstart 0x%02x\n", 435 sc->sc_curmsg->slave | 0x01); 436 DEVICE_DEBUGF(sc, 1, 437 "read 0x%02x len %d: ", 438 sc->sc_curmsg->slave | 0x01, 439 sc->sc_totlen); 440 sc->sc_flags |= BCM_I2C_READ; 441 return; 442 } 443 } 444 } while (sc->sc_totlen > 0 && (status & BCM_BSC_STATUS_TXD)); 445 } 446 447 static void 448 bcm_bsc_intr(void *arg) 449 { 450 struct bcm_bsc_softc *sc; 451 uint32_t status; 452 453 sc = (struct bcm_bsc_softc *)arg; 454 455 BCM_BSC_LOCK(sc); 456 457 /* The I2C interrupt is shared among all the BSC controllers. */ 458 if ((sc->sc_flags & BCM_I2C_BUSY) == 0) { 459 BCM_BSC_UNLOCK(sc); 460 return; 461 } 462 463 status = BCM_BSC_READ(sc, BCM_BSC_STATUS); 464 DEBUGF(sc, 4, " <intrstatus=0x%08x> ", status); 465 466 /* RXD and DONE can assert together, empty fifo before checking done. */ 467 if ((sc->sc_flags & BCM_I2C_READ) && (status & BCM_BSC_STATUS_RXD)) 468 bcm_bsc_empty_rx_fifo(sc); 469 470 /* Check for completion. */ 471 if (status & (BCM_BSC_STATUS_ERRBITS | BCM_BSC_STATUS_DONE)) { 472 sc->sc_flags |= BCM_I2C_DONE; 473 if (status & BCM_BSC_STATUS_ERRBITS) 474 sc->sc_flags |= BCM_I2C_ERROR; 475 /* Disable interrupts. */ 476 bcm_bsc_reset(sc); 477 wakeup(sc); 478 } else if (!(sc->sc_flags & BCM_I2C_READ)) { 479 /* 480 * Don't check for TXD until after determining whether the 481 * transfer is complete; TXD will be asserted along with ERR or 482 * DONE if there is room in the fifo. 483 */ 484 if ((status & BCM_BSC_STATUS_TXD) && sc->sc_totlen > 0) 485 bcm_bsc_fill_tx_fifo(sc); 486 } 487 488 BCM_BSC_UNLOCK(sc); 489 } 490 491 static int 492 bcm_bsc_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs) 493 { 494 struct bcm_bsc_softc *sc; 495 struct iic_msg *endmsgs, *nxtmsg; 496 uint32_t readctl, status; 497 int err; 498 uint16_t curlen; 499 uint8_t curisread, curslave, nxtisread, nxtslave; 500 501 sc = device_get_softc(dev); 502 BCM_BSC_LOCK(sc); 503 504 /* If the controller is busy wait until it is available. */ 505 while (sc->sc_flags & BCM_I2C_BUSY) 506 mtx_sleep(dev, &sc->sc_mtx, 0, "bscbusw", 0); 507 508 /* Now we have control over the BSC controller. */ 509 sc->sc_flags = BCM_I2C_BUSY; 510 511 DEVICE_DEBUGF(sc, 3, "Transfer %d msgs\n", nmsgs); 512 513 /* Clear the FIFO and the pending interrupts. */ 514 bcm_bsc_reset(sc); 515 516 /* 517 * Perform all the transfers requested in the array of msgs. Note that 518 * it is bcm_bsc_empty_rx_fifo() and bcm_bsc_fill_tx_fifo() that advance 519 * sc->sc_curmsg through the array of messages, as the data from each 520 * message is fully consumed, but it is this loop that notices when we 521 * have no more messages to process. 522 */ 523 err = 0; 524 sc->sc_resid = 0; 525 sc->sc_curmsg = msgs; 526 endmsgs = &msgs[nmsgs]; 527 while (sc->sc_curmsg < endmsgs) { 528 readctl = 0; 529 curslave = sc->sc_curmsg->slave >> 1; 530 curisread = sc->sc_curmsg->flags & IIC_M_RD; 531 sc->sc_replen = 0; 532 sc->sc_totlen = sc->sc_curmsg->len; 533 /* 534 * Scan for scatter/gather IO (same slave and direction) or 535 * repeat-start (read following write for the same slave). 536 */ 537 for (nxtmsg = sc->sc_curmsg + 1; nxtmsg < endmsgs; ++nxtmsg) { 538 nxtslave = nxtmsg->slave >> 1; 539 if (curslave == nxtslave) { 540 nxtisread = nxtmsg->flags & IIC_M_RD; 541 if (curisread == nxtisread) { 542 /* 543 * Same slave and direction, this 544 * message will be part of the same 545 * transfer as the previous one. 546 */ 547 sc->sc_totlen += nxtmsg->len; 548 continue; 549 } else if (curisread == IIC_M_WR) { 550 /* 551 * Read after write to same slave means 552 * repeat-start, remember how many bytes 553 * come before the repeat-start, switch 554 * the direction to IIC_M_RD, and gather 555 * up following reads to the same slave. 556 */ 557 curisread = IIC_M_RD; 558 sc->sc_replen = sc->sc_totlen; 559 sc->sc_totlen += nxtmsg->len; 560 continue; 561 } 562 } 563 break; 564 } 565 566 /* 567 * curslave and curisread temporaries from above may refer to 568 * the after-repstart msg, reset them to reflect sc_curmsg. 569 */ 570 curisread = (sc->sc_curmsg->flags & IIC_M_RD) ? 1 : 0; 571 curslave = sc->sc_curmsg->slave | curisread; 572 573 /* Write the slave address. */ 574 BCM_BSC_WRITE(sc, BCM_BSC_SLAVE, curslave >> 1); 575 576 DEVICE_DEBUGF(sc, 2, "start 0x%02x\n", curslave); 577 578 /* 579 * Either set up read length and direction variables for a 580 * simple transfer or get the hardware started on the first 581 * piece of a transfer that involves a repeat-start and set up 582 * the read length and direction vars for the second piece. 583 */ 584 if (sc->sc_replen == 0) { 585 DEVICE_DEBUGF(sc, 1, "%-6s 0x%02x len %d: ", 586 (curisread) ? "read" : "write", curslave, 587 sc->sc_totlen); 588 curlen = sc->sc_totlen; 589 if (curisread) { 590 readctl = BCM_BSC_CTRL_READ; 591 sc->sc_flags |= BCM_I2C_READ; 592 } else { 593 readctl = 0; 594 sc->sc_flags &= ~BCM_I2C_READ; 595 } 596 } else { 597 DEVICE_DEBUGF(sc, 1, "%-6s 0x%02x len %d: ", 598 (curisread) ? "read" : "write", curslave, 599 sc->sc_replen); 600 601 /* 602 * Start the write transfer with an empty fifo and wait 603 * for the 'transfer active' status bit to light up; 604 * that indicates that the hardware has latched the 605 * direction and length for the write, and we can safely 606 * reload those registers and issue the start for the 607 * following read; interrupts are not enabled here. 608 */ 609 BCM_BSC_WRITE(sc, BCM_BSC_DLEN, sc->sc_replen); 610 BCM_BSC_WRITE(sc, BCM_BSC_CTRL, BCM_BSC_CTRL_I2CEN | 611 BCM_BSC_CTRL_ST); 612 do { 613 status = BCM_BSC_READ(sc, BCM_BSC_STATUS); 614 if (status & BCM_BSC_STATUS_ERR) { 615 /* no ACK on slave addr */ 616 err = EIO; 617 goto xfer_done; 618 } 619 } while ((status & BCM_BSC_STATUS_TA) == 0); 620 /* 621 * Set curlen and readctl for the repeat-start read that 622 * we need to set up below, but set sc_flags to write, 623 * because that is the operation in progress right now. 624 */ 625 curlen = sc->sc_totlen - sc->sc_replen; 626 readctl = BCM_BSC_CTRL_READ; 627 sc->sc_flags &= ~BCM_I2C_READ; 628 } 629 630 /* 631 * Start the transfer with interrupts enabled, then if doing a 632 * write, fill the tx fifo. Not prefilling the fifo until after 633 * this start command is the key workaround for making 634 * repeat-start work, and it's harmless to do it in this order 635 * for a regular write too. 636 */ 637 BCM_BSC_WRITE(sc, BCM_BSC_DLEN, curlen); 638 BCM_BSC_WRITE(sc, BCM_BSC_CTRL, readctl | BCM_BSC_CTRL_I2CEN | 639 BCM_BSC_CTRL_ST | BCM_BSC_CTRL_INT_ALL); 640 641 if (!(sc->sc_curmsg->flags & IIC_M_RD)) { 642 bcm_bsc_fill_tx_fifo(sc); 643 } 644 645 /* Wait for the transaction to complete. */ 646 while (err == 0 && !(sc->sc_flags & BCM_I2C_DONE)) { 647 err = mtx_sleep(sc, &sc->sc_mtx, 0, "bsciow", hz); 648 } 649 /* Check for errors. */ 650 if (err == 0 && (sc->sc_flags & BCM_I2C_ERROR)) 651 err = EIO; 652 xfer_done: 653 DEBUGF(sc, 1, " err=%d\n", err); 654 DEVICE_DEBUGF(sc, 2, "stop\n"); 655 if (err != 0) 656 break; 657 } 658 659 /* Disable interrupts, clean fifo, etc. */ 660 bcm_bsc_reset(sc); 661 662 /* Clean the controller flags. */ 663 sc->sc_flags = 0; 664 665 /* Wake up the threads waiting for bus. */ 666 wakeup(dev); 667 668 BCM_BSC_UNLOCK(sc); 669 670 return (err); 671 } 672 673 static int 674 bcm_bsc_iicbus_reset(device_t dev, u_char speed, u_char addr, u_char *oldaddr) 675 { 676 struct bcm_bsc_softc *sc; 677 uint32_t busfreq; 678 679 sc = device_get_softc(dev); 680 BCM_BSC_LOCK(sc); 681 bcm_bsc_reset(sc); 682 if (sc->sc_iicbus == NULL) 683 busfreq = 100000; 684 else 685 busfreq = IICBUS_GET_FREQUENCY(sc->sc_iicbus, speed); 686 BCM_BSC_WRITE(sc, BCM_BSC_CLOCK, BCM_BSC_CORE_CLK / busfreq); 687 BCM_BSC_UNLOCK(sc); 688 689 return (IIC_ENOADDR); 690 } 691 692 static phandle_t 693 bcm_bsc_get_node(device_t bus, device_t dev) 694 { 695 696 /* We only have one child, the I2C bus, which needs our own node. */ 697 return (ofw_bus_get_node(bus)); 698 } 699 700 static device_method_t bcm_bsc_methods[] = { 701 /* Device interface */ 702 DEVMETHOD(device_probe, bcm_bsc_probe), 703 DEVMETHOD(device_attach, bcm_bsc_attach), 704 DEVMETHOD(device_detach, bcm_bsc_detach), 705 706 /* iicbus interface */ 707 DEVMETHOD(iicbus_reset, bcm_bsc_iicbus_reset), 708 DEVMETHOD(iicbus_callback, iicbus_null_callback), 709 DEVMETHOD(iicbus_transfer, bcm_bsc_transfer), 710 711 /* ofw_bus interface */ 712 DEVMETHOD(ofw_bus_get_node, bcm_bsc_get_node), 713 714 DEVMETHOD_END 715 }; 716 717 static driver_t bcm_bsc_driver = { 718 "iichb", 719 bcm_bsc_methods, 720 sizeof(struct bcm_bsc_softc), 721 }; 722 723 DRIVER_MODULE(iicbus, bcm2835_bsc, iicbus_driver, 0, 0); 724 DRIVER_MODULE(bcm2835_bsc, simplebus, bcm_bsc_driver, 0, 0); 725