Annotation of sys/dev/isa/gscsio.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: gscsio.c,v 1.9 2007/06/05 08:37:20 jsg Exp $ */
! 2: /*
! 3: * Copyright (c) 2004 Alexander Yurchenko <grange@openbsd.org>
! 4: *
! 5: * Permission to use, copy, modify, and distribute this software for any
! 6: * purpose with or without fee is hereby granted, provided that the above
! 7: * copyright notice and this permission notice appear in all copies.
! 8: *
! 9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 16: */
! 17:
! 18: /*
! 19: * National Semiconductor Geode SC1100 Super I/O.
! 20: * Only ACCESS.bus logical device is supported.
! 21: */
! 22:
! 23: #include <sys/param.h>
! 24: #include <sys/systm.h>
! 25: #include <sys/device.h>
! 26: #include <sys/kernel.h>
! 27: #include <sys/rwlock.h>
! 28: #include <sys/proc.h>
! 29:
! 30: #include <machine/bus.h>
! 31:
! 32: #include <dev/i2c/i2cvar.h>
! 33:
! 34: #include <dev/isa/isareg.h>
! 35: #include <dev/isa/isavar.h>
! 36:
! 37: #include <dev/isa/gscsioreg.h>
! 38:
! 39: struct gscsio_softc {
! 40: struct device sc_dev;
! 41:
! 42: bus_space_tag_t sc_iot;
! 43: bus_space_handle_t sc_ioh;
! 44:
! 45: int sc_ld_en[GSCSIO_LDNUM];
! 46: bus_space_handle_t sc_ld_ioh0[GSCSIO_LDNUM];
! 47: bus_space_handle_t sc_ld_ioh1[GSCSIO_LDNUM];
! 48:
! 49: /* ACCESS.bus */
! 50: struct gscsio_acb {
! 51: void *sc;
! 52: bus_space_handle_t ioh;
! 53: struct rwlock buslock;
! 54: } sc_acb[2];
! 55: struct i2c_controller sc_acb1_tag;
! 56: struct i2c_controller sc_acb2_tag;
! 57: };
! 58:
! 59: /* Supported logical devices description */
! 60: static const struct {
! 61: const char *ld_name;
! 62: int ld_num;
! 63: int ld_iosize0;
! 64: int ld_iosize1;
! 65: } gscsio_ld[] = {
! 66: { "ACB1", GSCSIO_LDN_ACB1, 6, 0 },
! 67: { "ACB2", GSCSIO_LDN_ACB2, 6, 0 },
! 68: };
! 69:
! 70: int gscsio_probe(struct device *, void *, void *);
! 71: void gscsio_attach(struct device *, struct device *, void *);
! 72:
! 73: void gscsio_acb_init(struct gscsio_acb *, i2c_tag_t);
! 74: int gscsio_acb_wait(struct gscsio_acb *, int, int);
! 75: void gscsio_acb_reset(struct gscsio_acb *acb);
! 76:
! 77: int gscsio_acb_acquire_bus(void *, int);
! 78: void gscsio_acb_release_bus(void *, int);
! 79: int gscsio_acb_send_start(void *, int);
! 80: int gscsio_acb_send_stop(void *, int);
! 81: int gscsio_acb_initiate_xfer(void *, uint16_t, int);
! 82: int gscsio_acb_read_byte(void *, uint8_t *, int);
! 83: int gscsio_acb_write_byte(void *, uint8_t, int);
! 84:
! 85: struct cfattach gscsio_ca = {
! 86: sizeof(struct gscsio_softc),
! 87: gscsio_probe,
! 88: gscsio_attach
! 89: };
! 90:
! 91: struct cfdriver gscsio_cd = {
! 92: NULL, "gscsio", DV_DULL
! 93: };
! 94:
! 95: #define ACB_READ(reg) \
! 96: bus_space_read_1(sc->sc_iot, acb->ioh, (reg))
! 97: #define ACB_WRITE(reg, val) \
! 98: bus_space_write_1(sc->sc_iot, acb->ioh, (reg), (val))
! 99:
! 100: static __inline u_int8_t
! 101: idxread(bus_space_tag_t iot, bus_space_handle_t ioh, int idx)
! 102: {
! 103: bus_space_write_1(iot, ioh, GSCSIO_IDX, idx);
! 104:
! 105: return (bus_space_read_1(iot, ioh, GSCSIO_DAT));
! 106: }
! 107:
! 108: static __inline void
! 109: idxwrite(bus_space_tag_t iot, bus_space_handle_t ioh, int idx, u_int8_t data)
! 110: {
! 111: bus_space_write_1(iot, ioh, GSCSIO_IDX, idx);
! 112: bus_space_write_1(iot, ioh, GSCSIO_DAT, data);
! 113: }
! 114:
! 115: int
! 116: gscsio_probe(struct device *parent, void *match, void *aux)
! 117: {
! 118: struct isa_attach_args *ia = aux;
! 119: bus_space_tag_t iot;
! 120: bus_space_handle_t ioh;
! 121: int iobase;
! 122: int rv = 0;
! 123:
! 124: iot = ia->ia_iot;
! 125: iobase = ia->ipa_io[0].base;
! 126: if (bus_space_map(iot, iobase, GSCSIO_IOSIZE, 0, &ioh))
! 127: return (0);
! 128: if (idxread(iot, ioh, GSCSIO_ID) == GSCSIO_ID_SC1100)
! 129: rv = 1;
! 130: bus_space_unmap(iot, ioh, GSCSIO_IOSIZE);
! 131:
! 132: if (rv) {
! 133: ia->ipa_nio = 1;
! 134: ia->ipa_io[0].length = GSCSIO_IOSIZE;
! 135: ia->ipa_nmem = 0;
! 136: ia->ipa_nirq = 0;
! 137: ia->ipa_ndrq = 0;
! 138: }
! 139:
! 140: return (rv);
! 141: }
! 142:
! 143: void
! 144: gscsio_attach(struct device *parent, struct device *self, void *aux)
! 145: {
! 146: struct gscsio_softc *sc = (void *)self;
! 147: struct isa_attach_args *ia = aux;
! 148: int i;
! 149: int iobase;
! 150:
! 151: sc->sc_iot = ia->ia_iot;
! 152: if (bus_space_map(sc->sc_iot, ia->ipa_io[0].base, GSCSIO_IOSIZE,
! 153: 0, &sc->sc_ioh)) {
! 154: printf(": can't map I/O space\n");
! 155: return;
! 156: }
! 157: printf(": SC1100 SIO rev %d:",
! 158: idxread(sc->sc_iot, sc->sc_ioh, GSCSIO_REV));
! 159:
! 160: /* Configure all supported logical devices */
! 161: for (i = 0; i < sizeof (gscsio_ld) / sizeof(gscsio_ld[0]); i++) {
! 162: sc->sc_ld_en[gscsio_ld[i].ld_num] = 0;
! 163:
! 164: /* Select the device and check if it's activated */
! 165: idxwrite(sc->sc_iot, sc->sc_ioh, GSCSIO_LDN,
! 166: gscsio_ld[i].ld_num);
! 167: if ((idxread(sc->sc_iot, sc->sc_ioh, GSCSIO_ACT) &
! 168: GSCSIO_ACT_EN) == 0)
! 169: continue;
! 170:
! 171: /* Map I/O space 0 if necessary */
! 172: if (gscsio_ld[i].ld_iosize0 != 0) {
! 173: iobase = idxread(sc->sc_iot, sc->sc_ioh,
! 174: GSCSIO_IO0_MSB);
! 175: iobase <<= 8;
! 176: iobase |= idxread(sc->sc_iot, sc->sc_ioh,
! 177: GSCSIO_IO0_LSB);
! 178: if (bus_space_map(sc->sc_iot, iobase,
! 179: gscsio_ld[i].ld_iosize0, 0,
! 180: &sc->sc_ld_ioh0[gscsio_ld[i].ld_num]))
! 181: continue;
! 182: }
! 183:
! 184: /* Map I/O space 1 if necessary */
! 185: if (gscsio_ld[i].ld_iosize1 != 0) {
! 186: iobase = idxread(sc->sc_iot, sc->sc_ioh,
! 187: GSCSIO_IO1_MSB);
! 188: iobase <<= 8;
! 189: iobase |= idxread(sc->sc_iot, sc->sc_ioh,
! 190: GSCSIO_IO1_LSB);
! 191: if (bus_space_map(sc->sc_iot, iobase,
! 192: gscsio_ld[i].ld_iosize1, 0,
! 193: &sc->sc_ld_ioh0[gscsio_ld[i].ld_num])) {
! 194: bus_space_unmap(sc->sc_iot,
! 195: sc->sc_ld_ioh0[gscsio_ld[i].ld_num],
! 196: gscsio_ld[i].ld_iosize0);
! 197: continue;
! 198: }
! 199: }
! 200:
! 201: sc->sc_ld_en[gscsio_ld[i].ld_num] = 1;
! 202: printf(" %s", gscsio_ld[i].ld_name);
! 203: }
! 204: printf("\n");
! 205:
! 206: /* Initialize ACCESS.bus 1 */
! 207: if (sc->sc_ld_en[GSCSIO_LDN_ACB1]) {
! 208: sc->sc_acb[0].sc = sc;
! 209: sc->sc_acb[0].ioh = sc->sc_ld_ioh0[GSCSIO_LDN_ACB1];
! 210: rw_init(&sc->sc_acb[0].buslock, "iiclk");
! 211: gscsio_acb_init(&sc->sc_acb[0], &sc->sc_acb1_tag);
! 212: }
! 213:
! 214: /* Initialize ACCESS.bus 2 */
! 215: if (sc->sc_ld_en[GSCSIO_LDN_ACB2]) {
! 216: sc->sc_acb[1].sc = sc;
! 217: sc->sc_acb[1].ioh = sc->sc_ld_ioh0[GSCSIO_LDN_ACB2];
! 218: rw_init(&sc->sc_acb[1].buslock, "iiclk");
! 219: gscsio_acb_init(&sc->sc_acb[1], &sc->sc_acb2_tag);
! 220: }
! 221: }
! 222:
! 223: void
! 224: gscsio_acb_init(struct gscsio_acb *acb, i2c_tag_t tag)
! 225: {
! 226: struct gscsio_softc *sc = acb->sc;
! 227: struct i2cbus_attach_args iba;
! 228:
! 229: /* Enable ACB and configure clock frequency */
! 230: ACB_WRITE(GSCSIO_ACB_CTL2, GSCSIO_ACB_CTL2_EN |
! 231: (GSCSIO_ACB_FREQ << GSCSIO_ACB_CTL2_FREQ_SHIFT));
! 232:
! 233: /* Select polling mode */
! 234: ACB_WRITE(GSCSIO_ACB_CTL1, ACB_READ(GSCSIO_ACB_CTL1) &
! 235: ~GSCSIO_ACB_CTL1_INTEN);
! 236:
! 237: /* Disable slave address */
! 238: ACB_WRITE(GSCSIO_ACB_ADDR, ACB_READ(GSCSIO_ACB_ADDR) &
! 239: ~GSCSIO_ACB_ADDR_SAEN);
! 240:
! 241: /* Attach I2C framework */
! 242: tag->ic_cookie = acb;
! 243: tag->ic_acquire_bus = gscsio_acb_acquire_bus;
! 244: tag->ic_release_bus = gscsio_acb_release_bus;
! 245: tag->ic_send_start = gscsio_acb_send_start;
! 246: tag->ic_send_stop = gscsio_acb_send_stop;
! 247: tag->ic_initiate_xfer = gscsio_acb_initiate_xfer;
! 248: tag->ic_read_byte = gscsio_acb_read_byte;
! 249: tag->ic_write_byte = gscsio_acb_write_byte;
! 250:
! 251: bzero(&iba, sizeof(iba));
! 252: iba.iba_name = "iic";
! 253: iba.iba_tag = tag;
! 254: config_found(&sc->sc_dev, &iba, iicbus_print);
! 255: }
! 256:
! 257: int
! 258: gscsio_acb_wait(struct gscsio_acb *acb, int bits, int flags)
! 259: {
! 260: struct gscsio_softc *sc = acb->sc;
! 261: u_int8_t st;
! 262: int i;
! 263:
! 264: for (i = 0; i < 100; i++) {
! 265: st = ACB_READ(GSCSIO_ACB_ST);
! 266: if (st & GSCSIO_ACB_ST_BER) {
! 267: printf("%s: bus error, flags=0x%x\n",
! 268: sc->sc_dev.dv_xname, flags);
! 269: gscsio_acb_reset(acb);
! 270: return (EIO);
! 271: }
! 272: if (st & GSCSIO_ACB_ST_NEGACK) {
! 273: #if 0
! 274: printf("%s: negative ack, flags=0x%x\n",
! 275: sc->sc_dev.dv_xname, flags);
! 276: #endif
! 277: gscsio_acb_reset(acb);
! 278: return (EIO);
! 279: }
! 280: if ((st & bits) == bits)
! 281: break;
! 282: delay(10);
! 283: }
! 284: if ((st & bits) != bits) {
! 285: printf("%s: timeout, flags=0x%x\n",
! 286: sc->sc_dev.dv_xname, flags);
! 287: gscsio_acb_reset(acb);
! 288: return (ETIMEDOUT);
! 289: }
! 290:
! 291: return (0);
! 292: }
! 293:
! 294: void
! 295: gscsio_acb_reset(struct gscsio_acb *acb)
! 296: {
! 297: struct gscsio_softc *sc = acb->sc;
! 298: u_int8_t st, ctl;
! 299:
! 300: /* Clear MASTER, NEGACK and BER */
! 301: st = ACB_READ(GSCSIO_ACB_ST);
! 302: st |= GSCSIO_ACB_ST_MASTER | GSCSIO_ACB_ST_NEGACK | GSCSIO_ACB_ST_BER;
! 303: ACB_WRITE(GSCSIO_ACB_ST, st);
! 304:
! 305: /* Disable and re-enable ACB */
! 306: ACB_WRITE(GSCSIO_ACB_CTL2, 0);
! 307: ACB_WRITE(GSCSIO_ACB_CTL2, GSCSIO_ACB_CTL2_EN |
! 308: (GSCSIO_ACB_FREQ << GSCSIO_ACB_CTL2_FREQ_SHIFT));
! 309:
! 310: /* Send stop */
! 311: ctl = ACB_READ(GSCSIO_ACB_CTL1);
! 312: ctl |= GSCSIO_ACB_CTL1_STOP;
! 313: ACB_WRITE(GSCSIO_ACB_CTL1, ctl);
! 314: }
! 315:
! 316: int
! 317: gscsio_acb_acquire_bus(void *cookie, int flags)
! 318: {
! 319: struct gscsio_acb *acb = cookie;
! 320:
! 321: if (cold || flags & I2C_F_POLL)
! 322: return (0);
! 323:
! 324: return (rw_enter(&acb->buslock, RW_WRITE | RW_INTR));
! 325: }
! 326:
! 327: void
! 328: gscsio_acb_release_bus(void *cookie, int flags)
! 329: {
! 330: struct gscsio_acb *acb = cookie;
! 331:
! 332: if (cold || flags & I2C_F_POLL)
! 333: return;
! 334:
! 335: rw_exit(&acb->buslock);
! 336: }
! 337:
! 338: int
! 339: gscsio_acb_send_start(void *cookie, int flags)
! 340: {
! 341: struct gscsio_acb *acb = cookie;
! 342: struct gscsio_softc *sc = acb->sc;
! 343: u_int8_t ctl;
! 344:
! 345: ctl = ACB_READ(GSCSIO_ACB_CTL1);
! 346: ctl |= GSCSIO_ACB_CTL1_START;
! 347: ACB_WRITE(GSCSIO_ACB_CTL1, ctl);
! 348:
! 349: return (0);
! 350: }
! 351:
! 352: int
! 353: gscsio_acb_send_stop(void *cookie, int flags)
! 354: {
! 355: struct gscsio_acb *acb = cookie;
! 356: struct gscsio_softc *sc = acb->sc;
! 357: u_int8_t ctl;
! 358:
! 359: ctl = ACB_READ(GSCSIO_ACB_CTL1);
! 360: ctl |= GSCSIO_ACB_CTL1_STOP;
! 361: ACB_WRITE(GSCSIO_ACB_CTL1, ctl);
! 362:
! 363: return (0);
! 364: }
! 365:
! 366: int
! 367: gscsio_acb_initiate_xfer(void *cookie, uint16_t addr, int flags)
! 368: {
! 369: struct gscsio_acb *acb = cookie;
! 370: struct gscsio_softc *sc = acb->sc;
! 371: u_int8_t ctl;
! 372: int dir;
! 373: int error;
! 374:
! 375: /* Issue start condition */
! 376: ctl = ACB_READ(GSCSIO_ACB_CTL1);
! 377: ctl |= GSCSIO_ACB_CTL1_START;
! 378: ACB_WRITE(GSCSIO_ACB_CTL1, ctl);
! 379:
! 380: /* Wait for bus mastership */
! 381: if ((error = gscsio_acb_wait(acb,
! 382: GSCSIO_ACB_ST_MASTER | GSCSIO_ACB_ST_SDAST, flags)))
! 383: return (error);
! 384:
! 385: /* Send address byte */
! 386: dir = (flags & I2C_F_READ ? 1 : 0);
! 387: ACB_WRITE(GSCSIO_ACB_SDA, (addr << 1) | dir);
! 388:
! 389: return (0);
! 390: }
! 391:
! 392: int
! 393: gscsio_acb_read_byte(void *cookie, uint8_t *bytep, int flags)
! 394: {
! 395: struct gscsio_acb *acb = cookie;
! 396: struct gscsio_softc *sc = acb->sc;
! 397: u_int8_t ctl;
! 398: int error;
! 399:
! 400: /* Wait for the bus to be ready */
! 401: if ((error = gscsio_acb_wait(acb, GSCSIO_ACB_ST_SDAST, flags)))
! 402: return (error);
! 403:
! 404: /* Acknowledge the last byte */
! 405: if (flags & I2C_F_LAST) {
! 406: ctl = ACB_READ(GSCSIO_ACB_CTL1);
! 407: ctl |= GSCSIO_ACB_CTL1_ACK;
! 408: ACB_WRITE(GSCSIO_ACB_CTL1, ctl);
! 409: }
! 410:
! 411: /* Read data byte */
! 412: *bytep = ACB_READ(GSCSIO_ACB_SDA);
! 413:
! 414: return (0);
! 415: }
! 416:
! 417: int
! 418: gscsio_acb_write_byte(void *cookie, uint8_t byte, int flags)
! 419: {
! 420: struct gscsio_acb *acb = cookie;
! 421: struct gscsio_softc *sc = acb->sc;
! 422: u_int8_t ctl;
! 423: int error;
! 424:
! 425: /* Wait for the bus to be ready */
! 426: if ((error = gscsio_acb_wait(acb, GSCSIO_ACB_ST_SDAST, flags)))
! 427: return (error);
! 428:
! 429: /* Send stop after the last byte */
! 430: if (flags & I2C_F_STOP) {
! 431: ctl = ACB_READ(GSCSIO_ACB_CTL1);
! 432: ctl |= GSCSIO_ACB_CTL1_STOP;
! 433: ACB_WRITE(GSCSIO_ACB_CTL1, ctl);
! 434: }
! 435:
! 436: /* Write data byte */
! 437: ACB_WRITE(GSCSIO_ACB_SDA, byte);
! 438:
! 439: return (0);
! 440: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to gscsio.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / isa