1 /* 2 * Copyright (c) 2014 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Matthew Dillon <dillon@backplane.com> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 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 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 3. Neither the name of The DragonFly Project nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific, prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 /* 35 * Intel 4th generation mobile cpus integrated I2C device, smbus driver. 36 * 37 * See ig4_reg.h for datasheet reference and notes. 38 */ 39 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/kernel.h> 43 #include <sys/module.h> 44 #include <sys/errno.h> 45 #include <sys/lock.h> 46 #include <sys/syslog.h> 47 #include <sys/bus.h> 48 #include <sys/sysctl.h> 49 50 #include <sys/rman.h> 51 52 #include <bus/pci/pcivar.h> 53 #include <bus/pci/pcireg.h> 54 #include <bus/smbus/smbconf.h> 55 56 #include "smbus_if.h" 57 58 #include "ig4_reg.h" 59 #include "ig4_var.h" 60 61 #define TRANS_NORMAL 1 62 #define TRANS_PCALL 2 63 #define TRANS_BLOCK 3 64 65 static void ig4iic_intr(void *cookie); 66 static void ig4iic_dump(ig4iic_softc_t *sc); 67 68 static int ig4_dump; 69 SYSCTL_INT(_debug, OID_AUTO, ig4_dump, CTLTYPE_INT | CTLFLAG_RW, 70 &ig4_dump, 0, ""); 71 72 /* 73 * Low-level inline support functions 74 */ 75 static __inline 76 void 77 reg_write(ig4iic_softc_t *sc, uint32_t reg, uint32_t value) 78 { 79 bus_space_write_4(sc->regs_t, sc->regs_h, reg, value); 80 bus_space_barrier(sc->regs_t, sc->regs_h, reg, 4, 81 BUS_SPACE_BARRIER_WRITE); 82 } 83 84 static __inline 85 uint32_t 86 reg_read(ig4iic_softc_t *sc, uint32_t reg) 87 { 88 uint32_t value; 89 90 bus_space_barrier(sc->regs_t, sc->regs_h, reg, 4, 91 BUS_SPACE_BARRIER_READ); 92 value = bus_space_read_4(sc->regs_t, sc->regs_h, reg); 93 return value; 94 } 95 96 /* 97 * Enable or disable the controller and wait for the controller to acknowledge 98 * the state change. 99 */ 100 static 101 int 102 set_controller(ig4iic_softc_t *sc, uint32_t ctl) 103 { 104 int retry; 105 int error; 106 uint32_t v; 107 108 if (ctl & IG4_I2C_ENABLE) { 109 reg_write(sc, IG4_REG_INTR_MASK, IG4_INTR_STOP_DET | 110 IG4_INTR_RX_FULL); 111 reg_read(sc, IG4_REG_CLR_INTR); 112 } else { 113 reg_write(sc, IG4_REG_INTR_MASK, 0); 114 } 115 reg_write(sc, IG4_REG_I2C_EN, ctl); 116 error = SMB_ETIMEOUT; 117 118 for (retry = 100; retry > 0; --retry) { 119 v = reg_read(sc, IG4_REG_ENABLE_STATUS); 120 if (((v ^ ctl) & IG4_I2C_ENABLE) == 0) { 121 error = 0; 122 break; 123 } 124 tsleep(sc, 0, "i2cslv", 1); 125 } 126 return error; 127 } 128 129 /* 130 * Wait up to 25ms for the requested status using a 25uS polling loop. 131 */ 132 static 133 int 134 wait_status(ig4iic_softc_t *sc, uint32_t status) 135 { 136 uint32_t v; 137 int error; 138 int txlvl = -1; 139 sysclock_t count; 140 sysclock_t limit; 141 142 error = SMB_ETIMEOUT; 143 count = sys_cputimer->count(); 144 limit = sys_cputimer->freq / 40; 145 146 for (;;) { 147 /* 148 * Check requested status 149 */ 150 v = reg_read(sc, IG4_REG_I2C_STA); 151 if (v & status) { 152 error = 0; 153 break; 154 } 155 156 /* 157 * When waiting for receive data break-out if the interrupt 158 * loaded data into the FIFO. 159 */ 160 if (status & IG4_STATUS_RX_NOTEMPTY) { 161 if (sc->rpos != sc->rnext) { 162 error = 0; 163 break; 164 } 165 } 166 167 /* 168 * When waiting for the transmit FIFO to become empty, 169 * reset the timeout if we see a change in the transmit 170 * FIFO level as progress is being made. 171 */ 172 if (status & IG4_STATUS_TX_EMPTY) { 173 v = reg_read(sc, IG4_REG_TXFLR) & IG4_FIFOLVL_MASK; 174 if (txlvl != v) { 175 txlvl = v; 176 count = sys_cputimer->count(); 177 } 178 } 179 180 /* 181 * Stop if we've run out of time. 182 */ 183 if (sys_cputimer->count() - count > limit) 184 break; 185 186 /* 187 * When waiting for receive data let the interrupt do its 188 * work, otherwise poll with the lock held. 189 */ 190 if (status & IG4_STATUS_RX_NOTEMPTY) { 191 lksleep(sc, &sc->lk, 0, "i2cwait", (hz + 99) / 100); 192 } else { 193 DELAY(25); 194 } 195 } 196 197 return error; 198 } 199 200 /* 201 * Read I2C data. The data might have already been read by 202 * the interrupt code, otherwise it is sitting in the data 203 * register. 204 */ 205 static 206 uint8_t 207 data_read(ig4iic_softc_t *sc) 208 { 209 uint8_t c; 210 211 if (sc->rpos == sc->rnext) { 212 c = (uint8_t)reg_read(sc, IG4_REG_DATA_CMD); 213 } else { 214 c = sc->rbuf[sc->rpos & IG4_RBUFMASK]; 215 ++sc->rpos; 216 } 217 return c; 218 } 219 220 /* 221 * Set the slave address. The controller must be disabled when 222 * changing the address. 223 * 224 * This operation does not issue anything to the I2C bus but sets 225 * the target address for when the controller later issues a START. 226 */ 227 static 228 void 229 set_slave_addr(ig4iic_softc_t *sc, uint8_t slave, int trans_op) 230 { 231 uint32_t tar; 232 uint32_t ctl; 233 int use_10bit; 234 235 use_10bit = sc->use_10bit; 236 if (trans_op & SMB_TRANS_7BIT) 237 use_10bit = 0; 238 if (trans_op & SMB_TRANS_10BIT) 239 use_10bit = 1; 240 241 if (sc->slave_valid && sc->last_slave == slave && 242 sc->use_10bit == use_10bit) { 243 return; 244 } 245 sc->use_10bit = use_10bit; 246 247 /* 248 * Wait for TXFIFO to drain before disabling the controller. 249 * 250 * If a write message has not been completed it's really a 251 * programming error, but for now in that case issue an extra 252 * byte + STOP. 253 * 254 * If a read message has not been completed it's also a programming 255 * error, for now just ignore it. 256 */ 257 wait_status(sc, IG4_STATUS_TX_NOTFULL); 258 if (sc->write_started) { 259 reg_write(sc, IG4_REG_DATA_CMD, IG4_DATA_STOP); 260 sc->write_started = 0; 261 } 262 if (sc->read_started) 263 sc->read_started = 0; 264 wait_status(sc, IG4_STATUS_TX_EMPTY); 265 266 set_controller(sc, 0); 267 ctl = reg_read(sc, IG4_REG_CTL); 268 ctl &= ~IG4_CTL_10BIT; 269 ctl |= IG4_CTL_RESTARTEN; 270 271 tar = slave; 272 if (sc->use_10bit) { 273 tar |= IG4_TAR_10BIT; 274 ctl |= IG4_CTL_10BIT; 275 } 276 reg_write(sc, IG4_REG_CTL, ctl); 277 reg_write(sc, IG4_REG_TAR_ADD, tar); 278 set_controller(sc, IG4_I2C_ENABLE); 279 sc->slave_valid = 1; 280 sc->last_slave = slave; 281 } 282 283 /* 284 * Issue START with byte command, possible count, and a variable length 285 * read or write buffer, then possible turn-around read. The read also 286 * has a possible count received. 287 * 288 * For SMBUS - 289 * 290 * Quick: START+ADDR+RD/WR STOP 291 * 292 * Normal: START+ADDR+WR CMD DATA..DATA STOP 293 * 294 * START+ADDR+RD CMD 295 * RESTART+ADDR RDATA..RDATA STOP 296 * (can also be used for I2C transactions) 297 * 298 * Process Call: START+ADDR+WR CMD DATAL DATAH 299 * RESTART+ADDR+RD RDATAL RDATAH STOP 300 * 301 * Block: START+ADDR+RD CMD 302 * RESTART+ADDR+RD RCOUNT DATA... STOP 303 * 304 * START+ADDR+WR CMD 305 * RESTART+ADDR+WR WCOUNT DATA... STOP 306 * 307 * For I2C - basically, no *COUNT fields, possibly no *CMD field. If the 308 * sender needs to issue a 2-byte command it will incorporate it 309 * into the write buffer and also set NOCMD. 310 * 311 * Generally speaking, the START+ADDR / RESTART+ADDR is handled automatically 312 * by the controller at the beginning of a command sequence or on a data 313 * direction turn-around, and we only need to tell it when to issue the STOP. 314 */ 315 static int 316 smb_transaction(ig4iic_softc_t *sc, char cmd, int op, 317 char *wbuf, int wcount, char *rbuf, int rcount, int *actualp) 318 { 319 int error; 320 int unit; 321 uint32_t last; 322 323 /* 324 * Debugging - dump registers 325 */ 326 if (ig4_dump) { 327 unit = device_get_unit(sc->dev); 328 if (ig4_dump & (1 << unit)) { 329 ig4_dump &= ~(1 << unit); 330 ig4iic_dump(sc); 331 } 332 } 333 334 /* 335 * Issue START or RESTART with next data byte, clear any previous 336 * abort condition that may have been holding the txfifo in reset. 337 */ 338 last = IG4_DATA_RESTART; 339 reg_read(sc, IG4_REG_CLR_TX_ABORT); 340 if (actualp) 341 *actualp = 0; 342 343 /* 344 * Issue command if not told otherwise (smbus). 345 */ 346 if ((op & SMB_TRANS_NOCMD) == 0) { 347 error = wait_status(sc, IG4_STATUS_TX_NOTFULL); 348 if (error) 349 goto done; 350 last |= (u_char)cmd; 351 if (wcount == 0 && rcount == 0 && (op & SMB_TRANS_NOSTOP) == 0) 352 last |= IG4_DATA_STOP; 353 reg_write(sc, IG4_REG_DATA_CMD, last); 354 last = 0; 355 } 356 357 /* 358 * Clean out any previously received data. 359 */ 360 if (sc->rpos != sc->rnext && 361 (op & SMB_TRANS_NOREPORT) == 0) { 362 device_printf(sc->dev, 363 "discarding %d bytes of spurious data\n", 364 sc->rnext - sc->rpos); 365 } 366 sc->rpos = 0; 367 sc->rnext = 0; 368 369 /* 370 * If writing and not told otherwise, issue the write count (smbus). 371 */ 372 if (wcount && (op & SMB_TRANS_NOCNT) == 0) { 373 error = wait_status(sc, IG4_STATUS_TX_NOTFULL); 374 if (error) 375 goto done; 376 last |= (u_char)cmd; 377 reg_write(sc, IG4_REG_DATA_CMD, last); 378 last = 0; 379 } 380 381 /* 382 * Bulk write (i2c) 383 */ 384 while (wcount) { 385 error = wait_status(sc, IG4_STATUS_TX_NOTFULL); 386 if (error) 387 goto done; 388 last |= (u_char)*wbuf; 389 if (wcount == 1 && rcount == 0 && (op & SMB_TRANS_NOSTOP) == 0) 390 last |= IG4_DATA_STOP; 391 reg_write(sc, IG4_REG_DATA_CMD, last); 392 --wcount; 393 ++wbuf; 394 last = 0; 395 } 396 397 /* 398 * Issue reads to xmit FIFO (strange, I know) to tell the controller 399 * to clock in data. At the moment just issue one read ahead to 400 * pipeline the incoming data. 401 * 402 * NOTE: In the case of NOCMD and wcount == 0 we still issue a 403 * RESTART here, even if the data direction has not changed 404 * from the previous CHAINing call. This we force the RESTART. 405 * (A new START is issued automatically by the controller in 406 * the other nominal cases such as a data direction change or 407 * a previous STOP was issued). 408 * 409 * If this will be the last byte read we must also issue the STOP 410 * at the end of the read. 411 */ 412 if (rcount) { 413 last = IG4_DATA_RESTART | IG4_DATA_COMMAND_RD; 414 if (rcount == 1 && 415 (op & (SMB_TRANS_NOSTOP | SMB_TRANS_NOCNT)) == 416 SMB_TRANS_NOCNT) { 417 last |= IG4_DATA_STOP; 418 } 419 reg_write(sc, IG4_REG_DATA_CMD, last); 420 last = IG4_DATA_COMMAND_RD; 421 } 422 423 /* 424 * Bulk read (i2c) and count field handling (smbus) 425 */ 426 while (rcount) { 427 /* 428 * Maintain a pipeline by queueing the allowance for the next 429 * read before waiting for the current read. 430 */ 431 if (rcount > 1) { 432 if (op & SMB_TRANS_NOCNT) 433 last = (rcount == 2) ? IG4_DATA_STOP : 0; 434 else 435 last = 0; 436 reg_write(sc, IG4_REG_DATA_CMD, IG4_DATA_COMMAND_RD | 437 last); 438 } 439 error = wait_status(sc, IG4_STATUS_RX_NOTEMPTY); 440 if (error) { 441 if ((op & SMB_TRANS_NOREPORT) == 0) { 442 device_printf(sc->dev, 443 "rx timeout addr 0x%02x\n", 444 sc->last_slave); 445 } 446 goto done; 447 } 448 last = data_read(sc); 449 450 if (op & SMB_TRANS_NOCNT) { 451 *rbuf = (u_char)last; 452 ++rbuf; 453 --rcount; 454 if (actualp) 455 ++*actualp; 456 } else { 457 /* 458 * Handle count field (smbus), which is not part of 459 * the rcount'ed buffer. The first read data in a 460 * bulk transfer is the count. 461 * 462 * XXX if rcount is loaded as 0 how do I generate a 463 * STOP now without issuing another RD or WR? 464 */ 465 if (rcount > (u_char)last) 466 rcount = (u_char)last; 467 op |= SMB_TRANS_NOCNT; 468 } 469 } 470 error = 0; 471 done: 472 /* XXX wait for xmit buffer to become empty */ 473 last = reg_read(sc, IG4_REG_TX_ABRT_SOURCE); 474 475 return error; 476 } 477 478 /* 479 * SMBUS API FUNCTIONS 480 * 481 * Called from ig4iic_pci_attach/detach() 482 */ 483 int 484 ig4iic_attach(ig4iic_softc_t *sc) 485 { 486 int error; 487 uint32_t v; 488 489 lockmgr(&sc->lk, LK_EXCLUSIVE); 490 491 v = reg_read(sc, IG4_REG_COMP_TYPE); 492 kprintf("type %08x", v); 493 v = reg_read(sc, IG4_REG_COMP_PARAM1); 494 kprintf(" params %08x", v); 495 v = reg_read(sc, IG4_REG_GENERAL); 496 kprintf(" general %08x", v); 497 if ((v & IG4_GENERAL_SWMODE) == 0) { 498 v |= IG4_GENERAL_SWMODE; 499 reg_write(sc, IG4_REG_GENERAL, v); 500 v = reg_read(sc, IG4_REG_GENERAL); 501 kprintf(" (updated %08x)", v); 502 } 503 504 v = reg_read(sc, IG4_REG_SW_LTR_VALUE); 505 kprintf(" swltr %08x", v); 506 v = reg_read(sc, IG4_REG_AUTO_LTR_VALUE); 507 kprintf(" autoltr %08x", v); 508 509 v = reg_read(sc, IG4_REG_COMP_VER); 510 kprintf(" version %08x\n", v); 511 if (v != IG4_COMP_VER) { 512 error = ENXIO; 513 goto done; 514 } 515 #if 1 516 v = reg_read(sc, IG4_REG_SS_SCL_HCNT); 517 kprintf("SS_SCL_HCNT=%08x", v); 518 v = reg_read(sc, IG4_REG_SS_SCL_LCNT); 519 kprintf(" LCNT=%08x", v); 520 v = reg_read(sc, IG4_REG_FS_SCL_HCNT); 521 kprintf(" FS_SCL_HCNT=%08x", v); 522 v = reg_read(sc, IG4_REG_FS_SCL_LCNT); 523 kprintf(" LCNT=%08x\n", v); 524 v = reg_read(sc, IG4_REG_SDA_HOLD); 525 kprintf("HOLD %08x\n", v); 526 527 v = reg_read(sc, IG4_REG_SS_SCL_HCNT); 528 reg_write(sc, IG4_REG_FS_SCL_HCNT, v); 529 v = reg_read(sc, IG4_REG_SS_SCL_LCNT); 530 reg_write(sc, IG4_REG_FS_SCL_LCNT, v); 531 #endif 532 /* 533 * Program based on a 25000 Hz clock. This is a bit of a 534 * hack (obviously). The defaults are 400 and 470 for standard 535 * and 60 and 130 for fast. The defaults for standard fail 536 * utterly (presumably cause an abort) because the clock time 537 * is ~18.8ms by default. This brings it down to ~4ms (for now). 538 */ 539 reg_write(sc, IG4_REG_SS_SCL_HCNT, 100); 540 reg_write(sc, IG4_REG_SS_SCL_LCNT, 125); 541 reg_write(sc, IG4_REG_FS_SCL_HCNT, 100); 542 reg_write(sc, IG4_REG_FS_SCL_LCNT, 125); 543 544 /* 545 * Use a threshold of 1 so we get interrupted on each character, 546 * allowing us to use lksleep() in our poll code. Not perfect 547 * but this is better than using DELAY() for receiving data. 548 */ 549 reg_write(sc, IG4_REG_RX_TL, 1); 550 551 reg_write(sc, IG4_REG_CTL, 552 IG4_CTL_MASTER | 553 IG4_CTL_SLAVE_DISABLE | 554 IG4_CTL_RESTARTEN | 555 IG4_CTL_SPEED_STD); 556 /* 557 * When ig4 is attached via ACPI, (child) devices should access the 558 * smbus via I2cSerialBus ACPI resources instead. 559 */ 560 if (strcmp("acpi", device_get_name(device_get_parent(sc->dev))) != 0) { 561 sc->smb = device_add_child(sc->dev, "smbus", -1); 562 if (sc->smb == NULL) { 563 device_printf(sc->dev, "smbus driver not found\n"); 564 error = ENXIO; 565 goto done; 566 } 567 } 568 569 sc->acpismb = device_add_child(sc->dev, "smbacpi", -1); 570 if (sc->acpismb == NULL) { 571 device_printf(sc->dev, "smbacpi driver not found\n"); 572 if (sc->smb == NULL) { 573 error = ENXIO; 574 goto done; 575 } 576 } 577 578 #if 0 579 /* 580 * Don't do this, it blows up the PCI config 581 */ 582 reg_write(sc, IG4_REG_RESETS, IG4_RESETS_ASSERT); 583 reg_write(sc, IG4_REG_RESETS, IG4_RESETS_DEASSERT); 584 #endif 585 586 /* 587 * Interrupt on STOP detect or receive character ready 588 */ 589 if (set_controller(sc, 0)) 590 device_printf(sc->dev, "controller error during attach-1\n"); 591 if (set_controller(sc, IG4_I2C_ENABLE)) 592 device_printf(sc->dev, "controller error during attach-2\n"); 593 error = bus_setup_intr(sc->dev, sc->intr_res, 0, 594 ig4iic_intr, sc, &sc->intr_handle, NULL); 595 if (error) { 596 device_printf(sc->dev, 597 "Unable to setup irq: error %d\n", error); 598 goto done; 599 } 600 601 /* Attach us to the smbus */ 602 lockmgr(&sc->lk, LK_RELEASE); 603 error = bus_generic_attach(sc->dev); 604 lockmgr(&sc->lk, LK_EXCLUSIVE); 605 if (error) { 606 device_printf(sc->dev, 607 "failed to attach child: error %d\n", error); 608 goto done; 609 } 610 sc->generic_attached = 1; 611 612 done: 613 lockmgr(&sc->lk, LK_RELEASE); 614 return error; 615 } 616 617 int 618 ig4iic_detach(ig4iic_softc_t *sc) 619 { 620 int error; 621 622 lockmgr(&sc->lk, LK_EXCLUSIVE); 623 624 reg_write(sc, IG4_REG_INTR_MASK, 0); 625 set_controller(sc, 0); 626 627 if (sc->generic_attached) { 628 error = bus_generic_detach(sc->dev); 629 if (error) 630 goto done; 631 sc->generic_attached = 0; 632 } 633 if (sc->smb) { 634 device_delete_child(sc->dev, sc->smb); 635 sc->smb = NULL; 636 } 637 if (sc->acpismb) { 638 device_delete_child(sc->dev, sc->acpismb); 639 sc->acpismb = NULL; 640 } 641 if (sc->intr_handle) { 642 bus_teardown_intr(sc->dev, sc->intr_res, sc->intr_handle); 643 sc->intr_handle = NULL; 644 } 645 646 error = 0; 647 done: 648 lockmgr(&sc->lk, LK_RELEASE); 649 return error; 650 } 651 652 int 653 ig4iic_smb_callback(device_t dev, int index, void *data) 654 { 655 ig4iic_softc_t *sc = device_get_softc(dev); 656 int error; 657 658 lockmgr(&sc->lk, LK_EXCLUSIVE); 659 660 switch (index) { 661 case SMB_REQUEST_BUS: 662 error = 0; 663 break; 664 case SMB_RELEASE_BUS: 665 error = 0; 666 break; 667 default: 668 error = SMB_EABORT; 669 break; 670 } 671 672 lockmgr(&sc->lk, LK_RELEASE); 673 674 return error; 675 } 676 677 /* 678 * Quick command. i.e. START + cmd + R/W + STOP and no data. It is 679 * unclear to me how I could implement this with the intel i2c controller 680 * because the controler sends STARTs and STOPs automatically with data. 681 */ 682 int 683 ig4iic_smb_quick(device_t dev, u_char slave, int how) 684 { 685 ig4iic_softc_t *sc = device_get_softc(dev); 686 int error; 687 688 lockmgr(&sc->lk, LK_EXCLUSIVE); 689 690 switch (how) { 691 case SMB_QREAD: 692 error = SMB_ENOTSUPP; 693 break; 694 case SMB_QWRITE: 695 error = SMB_ENOTSUPP; 696 break; 697 default: 698 error = SMB_ENOTSUPP; 699 break; 700 } 701 lockmgr(&sc->lk, LK_RELEASE); 702 703 return error; 704 } 705 706 /* 707 * Incremental send byte without stop (?). It is unclear why the slave 708 * address is specified if this presumably is used in combination with 709 * ig4iic_smb_quick(). 710 * 711 * (Also, how would this work anyway? Issue the last byte with writeb()?) 712 */ 713 int 714 ig4iic_smb_sendb(device_t dev, u_char slave, char byte) 715 { 716 ig4iic_softc_t *sc = device_get_softc(dev); 717 uint32_t cmd; 718 int error; 719 720 lockmgr(&sc->lk, LK_EXCLUSIVE); 721 722 set_slave_addr(sc, slave, 0); 723 cmd = byte; 724 if (wait_status(sc, IG4_STATUS_TX_NOTFULL) == 0) { 725 reg_write(sc, IG4_REG_DATA_CMD, cmd); 726 error = 0; 727 } else { 728 error = SMB_ETIMEOUT; 729 } 730 731 lockmgr(&sc->lk, LK_RELEASE); 732 return error; 733 } 734 735 /* 736 * Incremental receive byte without stop (?). It is unclear why the slave 737 * address is specified if this presumably is used in combination with 738 * ig4iic_smb_quick(). 739 */ 740 int 741 ig4iic_smb_recvb(device_t dev, u_char slave, char *byte) 742 { 743 ig4iic_softc_t *sc = device_get_softc(dev); 744 int error; 745 746 lockmgr(&sc->lk, LK_EXCLUSIVE); 747 748 set_slave_addr(sc, slave, 0); 749 reg_write(sc, IG4_REG_DATA_CMD, IG4_DATA_COMMAND_RD); 750 if (wait_status(sc, IG4_STATUS_RX_NOTEMPTY) == 0) { 751 *byte = data_read(sc); 752 error = 0; 753 } else { 754 *byte = 0; 755 error = SMB_ETIMEOUT; 756 } 757 758 lockmgr(&sc->lk, LK_RELEASE); 759 return error; 760 } 761 762 /* 763 * Write command and single byte in transaction. 764 */ 765 int 766 ig4iic_smb_writeb(device_t dev, u_char slave, char cmd, char byte) 767 { 768 ig4iic_softc_t *sc = device_get_softc(dev); 769 int error; 770 771 lockmgr(&sc->lk, LK_EXCLUSIVE); 772 773 set_slave_addr(sc, slave, 0); 774 error = smb_transaction(sc, cmd, SMB_TRANS_NOCNT, 775 &byte, 1, NULL, 0, NULL); 776 777 lockmgr(&sc->lk, LK_RELEASE); 778 return error; 779 } 780 781 /* 782 * Write command and single word in transaction. 783 */ 784 int 785 ig4iic_smb_writew(device_t dev, u_char slave, char cmd, short word) 786 { 787 ig4iic_softc_t *sc = device_get_softc(dev); 788 char buf[2]; 789 int error; 790 791 lockmgr(&sc->lk, LK_EXCLUSIVE); 792 793 set_slave_addr(sc, slave, 0); 794 buf[0] = word & 0xFF; 795 buf[1] = word >> 8; 796 error = smb_transaction(sc, cmd, SMB_TRANS_NOCNT, 797 buf, 2, NULL, 0, NULL); 798 799 lockmgr(&sc->lk, LK_RELEASE); 800 return error; 801 } 802 803 /* 804 * write command and read single byte in transaction. 805 */ 806 int 807 ig4iic_smb_readb(device_t dev, u_char slave, char cmd, char *byte) 808 { 809 ig4iic_softc_t *sc = device_get_softc(dev); 810 int error; 811 812 lockmgr(&sc->lk, LK_EXCLUSIVE); 813 814 set_slave_addr(sc, slave, 0); 815 error = smb_transaction(sc, cmd, SMB_TRANS_NOCNT, 816 NULL, 0, byte, 1, NULL); 817 818 lockmgr(&sc->lk, LK_RELEASE); 819 return error; 820 } 821 822 /* 823 * write command and read word in transaction. 824 */ 825 int 826 ig4iic_smb_readw(device_t dev, u_char slave, char cmd, short *word) 827 { 828 ig4iic_softc_t *sc = device_get_softc(dev); 829 char buf[2]; 830 int error; 831 832 lockmgr(&sc->lk, LK_EXCLUSIVE); 833 834 set_slave_addr(sc, slave, 0); 835 if ((error = smb_transaction(sc, cmd, SMB_TRANS_NOCNT, 836 NULL, 0, buf, 2, NULL)) == 0) { 837 *word = (u_char)buf[0] | ((u_char)buf[1] << 8); 838 } 839 840 lockmgr(&sc->lk, LK_RELEASE); 841 return error; 842 } 843 844 /* 845 * write command and word and read word in transaction 846 */ 847 int 848 ig4iic_smb_pcall(device_t dev, u_char slave, char cmd, 849 short sdata, short *rdata) 850 { 851 ig4iic_softc_t *sc = device_get_softc(dev); 852 char rbuf[2]; 853 char wbuf[2]; 854 int error; 855 856 lockmgr(&sc->lk, LK_EXCLUSIVE); 857 858 set_slave_addr(sc, slave, 0); 859 wbuf[0] = sdata & 0xFF; 860 wbuf[1] = sdata >> 8; 861 if ((error = smb_transaction(sc, cmd, SMB_TRANS_NOCNT, 862 wbuf, 2, rbuf, 2, NULL)) == 0) { 863 *rdata = (u_char)rbuf[0] | ((u_char)rbuf[1] << 8); 864 } 865 866 lockmgr(&sc->lk, LK_RELEASE); 867 return error; 868 } 869 870 int 871 ig4iic_smb_bwrite(device_t dev, u_char slave, char cmd, 872 u_char wcount, char *buf) 873 { 874 ig4iic_softc_t *sc = device_get_softc(dev); 875 int error; 876 877 lockmgr(&sc->lk, LK_EXCLUSIVE); 878 879 set_slave_addr(sc, slave, 0); 880 error = smb_transaction(sc, cmd, 0, 881 buf, wcount, NULL, 0, NULL); 882 883 lockmgr(&sc->lk, LK_RELEASE); 884 return error; 885 } 886 887 int 888 ig4iic_smb_bread(device_t dev, u_char slave, char cmd, 889 u_char *countp_char, char *buf) 890 { 891 ig4iic_softc_t *sc = device_get_softc(dev); 892 int rcount = *countp_char; 893 int error; 894 895 lockmgr(&sc->lk, LK_EXCLUSIVE); 896 897 set_slave_addr(sc, slave, 0); 898 error = smb_transaction(sc, cmd, 0, 899 NULL, 0, buf, rcount, &rcount); 900 *countp_char = rcount; 901 902 lockmgr(&sc->lk, LK_RELEASE); 903 return error; 904 } 905 906 int 907 ig4iic_smb_trans(device_t dev, int slave, char cmd, int op, 908 char *wbuf, int wcount, char *rbuf, int rcount, 909 int *actualp) 910 { 911 ig4iic_softc_t *sc = device_get_softc(dev); 912 int error; 913 914 lockmgr(&sc->lk, LK_EXCLUSIVE); 915 916 set_slave_addr(sc, slave, op); 917 error = smb_transaction(sc, cmd, op, 918 wbuf, wcount, rbuf, rcount, actualp); 919 920 lockmgr(&sc->lk, LK_RELEASE); 921 return error; 922 } 923 924 /* 925 * Interrupt Operation 926 */ 927 static 928 void 929 ig4iic_intr(void *cookie) 930 { 931 ig4iic_softc_t *sc = cookie; 932 uint32_t status; 933 934 lockmgr(&sc->lk, LK_EXCLUSIVE); 935 /* reg_write(sc, IG4_REG_INTR_MASK, IG4_INTR_STOP_DET);*/ 936 reg_read(sc, IG4_REG_CLR_INTR); 937 status = reg_read(sc, IG4_REG_I2C_STA); 938 while (status & IG4_STATUS_RX_NOTEMPTY) { 939 sc->rbuf[sc->rnext & IG4_RBUFMASK] = 940 (uint8_t)reg_read(sc, IG4_REG_DATA_CMD); 941 ++sc->rnext; 942 status = reg_read(sc, IG4_REG_I2C_STA); 943 } 944 wakeup(sc); 945 lockmgr(&sc->lk, LK_RELEASE); 946 } 947 948 #define REGDUMP(sc, reg) \ 949 device_printf(sc->dev, " %-23s %08x\n", #reg, reg_read(sc, reg)) 950 951 static 952 void 953 ig4iic_dump(ig4iic_softc_t *sc) 954 { 955 device_printf(sc->dev, "ig4iic register dump:\n"); 956 REGDUMP(sc, IG4_REG_CTL); 957 REGDUMP(sc, IG4_REG_TAR_ADD); 958 REGDUMP(sc, IG4_REG_SS_SCL_HCNT); 959 REGDUMP(sc, IG4_REG_SS_SCL_LCNT); 960 REGDUMP(sc, IG4_REG_FS_SCL_HCNT); 961 REGDUMP(sc, IG4_REG_FS_SCL_LCNT); 962 REGDUMP(sc, IG4_REG_INTR_STAT); 963 REGDUMP(sc, IG4_REG_INTR_MASK); 964 REGDUMP(sc, IG4_REG_RAW_INTR_STAT); 965 REGDUMP(sc, IG4_REG_RX_TL); 966 REGDUMP(sc, IG4_REG_TX_TL); 967 REGDUMP(sc, IG4_REG_I2C_EN); 968 REGDUMP(sc, IG4_REG_I2C_STA); 969 REGDUMP(sc, IG4_REG_TXFLR); 970 REGDUMP(sc, IG4_REG_RXFLR); 971 REGDUMP(sc, IG4_REG_SDA_HOLD); 972 REGDUMP(sc, IG4_REG_TX_ABRT_SOURCE); 973 REGDUMP(sc, IG4_REG_SLV_DATA_NACK); 974 REGDUMP(sc, IG4_REG_DMA_CTRL); 975 REGDUMP(sc, IG4_REG_DMA_TDLR); 976 REGDUMP(sc, IG4_REG_DMA_RDLR); 977 REGDUMP(sc, IG4_REG_SDA_SETUP); 978 REGDUMP(sc, IG4_REG_ENABLE_STATUS); 979 REGDUMP(sc, IG4_REG_COMP_PARAM1); 980 REGDUMP(sc, IG4_REG_COMP_VER); 981 REGDUMP(sc, IG4_REG_COMP_TYPE); 982 REGDUMP(sc, IG4_REG_CLK_PARMS); 983 REGDUMP(sc, IG4_REG_RESETS); 984 REGDUMP(sc, IG4_REG_GENERAL); 985 REGDUMP(sc, IG4_REG_SW_LTR_VALUE); 986 REGDUMP(sc, IG4_REG_AUTO_LTR_VALUE); 987 } 988 #undef REGDUMP 989 990 DRIVER_MODULE(smbus, ig4iic, smbus_driver, smbus_devclass, NULL, NULL); 991