Annotation of sys/arch/macppc/dev/kiic.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: kiic.c,v 1.2 2007/05/20 23:38:52 thib Exp $ */
! 2: /* $NetBSD: kiic.c,v 1.1 2003/12/27 02:19:34 grant Exp $ */
! 3:
! 4: /*-
! 5: * Copyright (c) 2001 Tsubai Masanari. All rights reserved.
! 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: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: * 3. The name of the author may not be used to endorse or promote products
! 16: * derived from this software without specific prior written permission.
! 17: *
! 18: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 19: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 20: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 21: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 22: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 23: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 24: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 25: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 26: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
! 27: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 28: */
! 29:
! 30: #include <sys/param.h>
! 31: #include <sys/device.h>
! 32: #include <sys/systm.h>
! 33:
! 34: #include <dev/ofw/openfirm.h>
! 35: #include <uvm/uvm_extern.h>
! 36: #include <machine/autoconf.h>
! 37:
! 38: #include <macppc/dev/kiicvar.h>
! 39: #include <macppc/dev/maci2cvar.h>
! 40:
! 41: int kiic_match(struct device *, void *, void *);
! 42: void kiic_attach(struct device *, struct device *, void *);
! 43: void kiic_attach_bus(struct kiic_softc *, struct kiic_bus *, int);
! 44: inline u_int kiic_readreg(struct kiic_softc *, int);
! 45: inline void kiic_writereg(struct kiic_softc *, int, u_int);
! 46: u_int kiic_getmode(struct kiic_softc *);
! 47: void kiic_setmode(struct kiic_softc *, u_int, u_int);
! 48: u_int kiic_getspeed(struct kiic_softc *);
! 49: void kiic_setspeed(struct kiic_softc *, u_int);
! 50: int kiic_intr(struct kiic_softc *);
! 51: int kiic_poll(struct kiic_softc *, int);
! 52: int kiic_start(struct kiic_softc *, int, int, void *, int);
! 53: int kiic_read(struct kiic_softc *, int, int, void *, int);
! 54: int kiic_write(struct kiic_softc *, int, int, const void *, int);
! 55:
! 56: /* I2C glue */
! 57: int kiic_i2c_acquire_bus(void *, int);
! 58: void kiic_i2c_release_bus(void *, int);
! 59: int kiic_i2c_exec(void *, i2c_op_t, i2c_addr_t, const void *, size_t,
! 60: void *, size_t, int);
! 61:
! 62: struct cfattach kiic_ca = {
! 63: sizeof(struct kiic_softc), kiic_match, kiic_attach
! 64: };
! 65: struct cfattach kiic_memc_ca = {
! 66: sizeof(struct kiic_softc), kiic_match, kiic_attach
! 67: };
! 68:
! 69: struct cfdriver kiic_cd = {
! 70: NULL, "kiic", DV_DULL
! 71: };
! 72:
! 73: int
! 74: kiic_match(struct device *parent, void *match, void *aux)
! 75: {
! 76: struct confargs *ca = aux;
! 77:
! 78: if (strcmp(ca->ca_name, "i2c") == 0 &&
! 79: ca->ca_nreg >= 4)
! 80: return (1);
! 81:
! 82: return (0);
! 83: }
! 84:
! 85: void
! 86: kiic_attach(struct device *parent, struct device *self, void *aux)
! 87: {
! 88: struct kiic_softc *sc = (struct kiic_softc *)self;
! 89: struct confargs *ca = aux;
! 90: int node = ca->ca_node;
! 91: int rate, count = 0;
! 92: char name[32];
! 93:
! 94: ca->ca_reg[0] += ca->ca_baseaddr;
! 95:
! 96: if (OF_getprop(node, "AAPL,i2c-rate", &rate, 4) != 4) {
! 97: printf(": cannot get i2c-rate\n");
! 98: return;
! 99: }
! 100: if (OF_getprop(node, "AAPL,address", &sc->sc_paddr, 4) != 4) {
! 101: printf(": unable to find i2c address\n");
! 102: return;
! 103: }
! 104: if (OF_getprop(node, "AAPL,address-step", &sc->sc_regstep, 4) != 4) {
! 105: printf(": unable to find i2c address step\n");
! 106: return;
! 107: }
! 108: sc->sc_reg = mapiodev(sc->sc_paddr, (DATA+1)*sc->sc_regstep);
! 109:
! 110: printf("\n");
! 111:
! 112: kiic_writereg(sc, STATUS, 0);
! 113: kiic_writereg(sc, ISR, 0);
! 114: kiic_writereg(sc, IER, 0);
! 115:
! 116: kiic_setmode(sc, I2C_STDSUBMODE, 0);
! 117: kiic_setspeed(sc, I2C_100kHz); /* XXX rate */
! 118:
! 119: rw_init(&sc->sc_buslock, sc->sc_dev.dv_xname);
! 120: kiic_writereg(sc, IER,I2C_INT_DATA|I2C_INT_ADDR|I2C_INT_STOP);
! 121:
! 122: for (node = OF_child(ca->ca_node); node; node = OF_peer(node)) {
! 123: if (OF_getprop(node, "name", &name, sizeof name) > 0) {
! 124: if (strcmp(name, "i2c-bus") == 0) {
! 125: kiic_attach_bus(sc, &sc->sc_bus[count], node);
! 126: if (++count >= KIIC_MAX_BUSSES)
! 127: break;
! 128: }
! 129: }
! 130: }
! 131:
! 132: /*
! 133: * If we didn't find any i2c-bus nodes, there is only a single
! 134: * i2c bus.
! 135: */
! 136:
! 137: if (count == 0)
! 138: kiic_attach_bus(sc, &sc->sc_bus[0], ca->ca_node);
! 139: }
! 140:
! 141: void
! 142: kiic_attach_bus(struct kiic_softc *sc, struct kiic_bus *bus, int node)
! 143: {
! 144: struct i2cbus_attach_args iba;
! 145: u_int32_t reg;
! 146:
! 147: if (OF_getprop(node, "reg", ®, sizeof reg) != sizeof reg)
! 148: return;
! 149:
! 150: bus->sc = sc;
! 151: bus->i2c_tag.ic_cookie = bus;
! 152: bus->i2c_tag.ic_acquire_bus = kiic_i2c_acquire_bus;
! 153: bus->i2c_tag.ic_release_bus = kiic_i2c_release_bus;
! 154: bus->i2c_tag.ic_exec = kiic_i2c_exec;
! 155: bus->reg = reg;
! 156:
! 157: bzero(&iba, sizeof iba);
! 158: iba.iba_name = "iic";
! 159: iba.iba_tag = &bus->i2c_tag;
! 160: iba.iba_bus_scan = maciic_scan;
! 161: iba.iba_bus_scan_arg = &node;
! 162: config_found(&sc->sc_dev, &iba, NULL);
! 163: }
! 164:
! 165: u_int
! 166: kiic_readreg(struct kiic_softc *sc, int reg)
! 167: {
! 168: u_char *addr = sc->sc_reg + sc->sc_regstep * reg;
! 169:
! 170: return (*addr);
! 171: }
! 172:
! 173: void
! 174: kiic_writereg(struct kiic_softc *sc, int reg, u_int val)
! 175: {
! 176: u_char *addr = sc->sc_reg + sc->sc_regstep * reg;
! 177:
! 178: *addr = val;
! 179: asm volatile ("eieio");
! 180: delay(10);
! 181: }
! 182:
! 183: u_int
! 184: kiic_getmode(struct kiic_softc *sc)
! 185: {
! 186: return kiic_readreg(sc, MODE) & I2C_MODE;
! 187: }
! 188:
! 189: void
! 190: kiic_setmode(struct kiic_softc *sc, u_int mode, u_int bus)
! 191: {
! 192: u_int x;
! 193:
! 194: KASSERT((mode & ~I2C_MODE) == 0);
! 195: x = kiic_readreg(sc, MODE);
! 196: x &= ~(I2C_MODE);
! 197: if (bus)
! 198: x |= I2C_BUS1;
! 199: else
! 200: x &= ~I2C_BUS1;
! 201: x |= mode;
! 202: kiic_writereg(sc, MODE, x);
! 203: }
! 204:
! 205: u_int
! 206: kiic_getspeed(struct kiic_softc *sc)
! 207: {
! 208: return kiic_readreg(sc, MODE) & I2C_SPEED;
! 209: }
! 210:
! 211: void
! 212: kiic_setspeed(struct kiic_softc *sc, u_int speed)
! 213: {
! 214: u_int x;
! 215:
! 216: KASSERT((speed & ~I2C_SPEED) == 0);
! 217: x = kiic_readreg(sc, MODE);
! 218: x &= ~I2C_SPEED;
! 219: x |= speed;
! 220: kiic_writereg(sc, MODE, x);
! 221: }
! 222:
! 223: int
! 224: kiic_intr(struct kiic_softc *sc)
! 225: {
! 226: u_int isr, x;
! 227:
! 228: isr = kiic_readreg(sc, ISR);
! 229: if (isr & I2C_INT_ADDR) {
! 230: #if 0
! 231: if ((kiic_readreg(sc, STATUS) & I2C_ST_LASTAAK) == 0) {
! 232: /* No slave responded. */
! 233: sc->sc_flags |= I2C_ERROR;
! 234: goto out;
! 235: }
! 236: #endif
! 237:
! 238: if (sc->sc_flags & I2C_READING) {
! 239: if (sc->sc_resid > 1) {
! 240: x = kiic_readreg(sc, CONTROL);
! 241: x |= I2C_CT_AAK;
! 242: kiic_writereg(sc, CONTROL, x);
! 243: }
! 244: } else {
! 245: kiic_writereg(sc, DATA, *sc->sc_data++);
! 246: sc->sc_resid--;
! 247: }
! 248: }
! 249:
! 250: if (isr & I2C_INT_DATA) {
! 251: if (sc->sc_flags & I2C_READING) {
! 252: *sc->sc_data++ = kiic_readreg(sc, DATA);
! 253: sc->sc_resid--;
! 254:
! 255: if (sc->sc_resid == 0) { /* Completed */
! 256: kiic_writereg(sc, CONTROL, 0);
! 257: goto out;
! 258: }
! 259: } else {
! 260: #if 0
! 261: if ((kiic_readreg(sc, STATUS) & I2C_ST_LASTAAK) == 0) {
! 262: /* No slave responded. */
! 263: sc->sc_flags |= I2C_ERROR;
! 264: goto out;
! 265: }
! 266: #endif
! 267:
! 268: if (sc->sc_resid == 0) {
! 269: x = kiic_readreg(sc, CONTROL) | I2C_CT_STOP;
! 270: kiic_writereg(sc, CONTROL, x);
! 271: } else {
! 272: kiic_writereg(sc, DATA, *sc->sc_data++);
! 273: sc->sc_resid--;
! 274: }
! 275: }
! 276: }
! 277:
! 278: out:
! 279: if (isr & I2C_INT_STOP) {
! 280: kiic_writereg(sc, CONTROL, 0);
! 281: sc->sc_flags &= ~I2C_BUSY;
! 282: }
! 283:
! 284: kiic_writereg(sc, ISR, isr);
! 285:
! 286: return (1);
! 287: }
! 288:
! 289: int
! 290: kiic_poll(struct kiic_softc *sc, int timo)
! 291: {
! 292: while (sc->sc_flags & I2C_BUSY) {
! 293: if (kiic_readreg(sc, ISR))
! 294: kiic_intr(sc);
! 295: timo -= 100;
! 296: if (timo < 0) {
! 297: printf("i2c_poll: timeout\n");
! 298: return (-1);
! 299: }
! 300: delay(100);
! 301: }
! 302: return (0);
! 303: }
! 304:
! 305: int
! 306: kiic_start(struct kiic_softc *sc, int addr, int subaddr, void *data, int len)
! 307: {
! 308: int rw = (sc->sc_flags & I2C_READING) ? 1 : 0;
! 309: int timo, x;
! 310:
! 311: KASSERT((addr & 1) == 0);
! 312:
! 313: sc->sc_data = data;
! 314: sc->sc_resid = len;
! 315: sc->sc_flags |= I2C_BUSY;
! 316:
! 317: timo = 1000 + len * 200;
! 318:
! 319: /* XXX TAS3001 sometimes takes 50ms to finish writing registers. */
! 320: /* if (addr == 0x68) */
! 321: timo += 100000;
! 322:
! 323: kiic_writereg(sc, ADDR, addr | rw);
! 324: kiic_writereg(sc, SUBADDR, subaddr);
! 325:
! 326: x = kiic_readreg(sc, CONTROL) | I2C_CT_ADDR;
! 327: kiic_writereg(sc, CONTROL, x);
! 328:
! 329: if (kiic_poll(sc, timo))
! 330: return (-1);
! 331: if (sc->sc_flags & I2C_ERROR) {
! 332: printf("I2C_ERROR\n");
! 333: return (-1);
! 334: }
! 335: return (0);
! 336: }
! 337:
! 338: int
! 339: kiic_read(struct kiic_softc *sc, int addr, int subaddr, void *data, int len)
! 340: {
! 341: sc->sc_flags = I2C_READING;
! 342: return kiic_start(sc, addr, subaddr, data, len);
! 343: }
! 344:
! 345: int
! 346: kiic_write(struct kiic_softc *sc, int addr, int subaddr, const void *data, int len)
! 347: {
! 348: sc->sc_flags = 0;
! 349: return kiic_start(sc, addr, subaddr, (void *)data, len);
! 350: }
! 351:
! 352: int
! 353: kiic_i2c_acquire_bus(void *cookie, int flags)
! 354: {
! 355: struct kiic_bus *bus = cookie;
! 356:
! 357: return (rw_enter(&bus->sc->sc_buslock, RW_WRITE));
! 358: }
! 359:
! 360: void
! 361: kiic_i2c_release_bus(void *cookie, int flags)
! 362: {
! 363: struct kiic_bus *bus = cookie;
! 364:
! 365: (void) rw_exit(&bus->sc->sc_buslock);
! 366: }
! 367:
! 368: int
! 369: kiic_i2c_exec(void *cookie, i2c_op_t op, i2c_addr_t addr,
! 370: const void *cmdbuf, size_t cmdlen, void *buf, size_t len, int flags)
! 371: {
! 372: struct kiic_bus *bus = cookie;
! 373: u_int mode = I2C_STDSUBMODE;
! 374: u_int8_t cmd = 0;
! 375:
! 376: if (!I2C_OP_STOP_P(op) || cmdlen > 1)
! 377: return (EINVAL);
! 378:
! 379: if (cmdlen == 0)
! 380: mode = I2C_STDMODE;
! 381: else if (I2C_OP_READ_P(op))
! 382: mode = I2C_COMBMODE;
! 383:
! 384: if (cmdlen > 0)
! 385: cmd = *(u_int8_t *)cmdbuf;
! 386:
! 387: kiic_setmode(bus->sc, mode, bus->reg || addr & 0x80);
! 388: addr &= 0x7f;
! 389:
! 390: if (I2C_OP_READ_P(op)) {
! 391: if (kiic_read(bus->sc, (addr << 1), cmd, buf, len) != 0)
! 392: return (EIO);
! 393: } else {
! 394: if (kiic_write(bus->sc, (addr << 1), cmd, buf, len) != 0)
! 395: return (EIO);
! 396: }
! 397: return (0);
! 398: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to kiic.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / macppc / dev