Annotation of sys/dev/gpio/gpioiic.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: gpioiic.c,v 1.7 2007/06/05 08:37:20 jsg Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 2006 Alexander Yurchenko <grange@openbsd.org>
! 5: *
! 6: * Permission to use, copy, modify, and distribute this software for any
! 7: * purpose with or without fee is hereby granted, provided that the above
! 8: * copyright notice and this permission notice appear in all copies.
! 9: *
! 10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 17: */
! 18:
! 19: /*
! 20: * I2C bus bit-banging through GPIO pins.
! 21: */
! 22:
! 23: #include <sys/param.h>
! 24: #include <sys/systm.h>
! 25: #include <sys/device.h>
! 26: #include <sys/gpio.h>
! 27: #include <sys/rwlock.h>
! 28:
! 29: #include <dev/gpio/gpiovar.h>
! 30:
! 31: #include <dev/i2c/i2cvar.h>
! 32: #include <dev/i2c/i2c_bitbang.h>
! 33:
! 34: #define GPIOIIC_PIN_SDA 0
! 35: #define GPIOIIC_PIN_SCL 1
! 36: #define GPIOIIC_NPINS 2
! 37:
! 38: #define GPIOIIC_SDA 0x01
! 39: #define GPIOIIC_SCL 0x02
! 40:
! 41: struct gpioiic_softc {
! 42: struct device sc_dev;
! 43:
! 44: void * sc_gpio;
! 45: struct gpio_pinmap sc_map;
! 46: int __map[GPIOIIC_NPINS];
! 47:
! 48: struct i2c_controller sc_i2c_tag;
! 49: struct rwlock sc_i2c_lock;
! 50:
! 51: int sc_sda;
! 52: int sc_scl;
! 53: };
! 54:
! 55: int gpioiic_match(struct device *, void *, void *);
! 56: void gpioiic_attach(struct device *, struct device *, void *);
! 57: int gpioiic_detach(struct device *, int);
! 58:
! 59: int gpioiic_i2c_acquire_bus(void *, int);
! 60: void gpioiic_i2c_release_bus(void *, int);
! 61: int gpioiic_i2c_send_start(void *, int);
! 62: int gpioiic_i2c_send_stop(void *, int);
! 63: int gpioiic_i2c_initiate_xfer(void *, i2c_addr_t, int);
! 64: int gpioiic_i2c_read_byte(void *, u_int8_t *, int);
! 65: int gpioiic_i2c_write_byte(void *, u_int8_t, int);
! 66:
! 67: void gpioiic_bb_set_bits(void *, u_int32_t);
! 68: void gpioiic_bb_set_dir(void *, u_int32_t);
! 69: u_int32_t gpioiic_bb_read_bits(void *);
! 70:
! 71: struct cfattach gpioiic_ca = {
! 72: sizeof(struct gpioiic_softc),
! 73: gpioiic_match,
! 74: gpioiic_attach,
! 75: gpioiic_detach
! 76: };
! 77:
! 78: struct cfdriver gpioiic_cd = {
! 79: NULL, "gpioiic", DV_DULL
! 80: };
! 81:
! 82: static const struct i2c_bitbang_ops gpioiic_bbops = {
! 83: gpioiic_bb_set_bits,
! 84: gpioiic_bb_set_dir,
! 85: gpioiic_bb_read_bits,
! 86: { GPIOIIC_SDA, GPIOIIC_SCL, GPIOIIC_SDA, 0 }
! 87: };
! 88:
! 89: int
! 90: gpioiic_match(struct device *parent, void *match, void *aux)
! 91: {
! 92: struct cfdata *cf = match;
! 93:
! 94: return (strcmp(cf->cf_driver->cd_name, "gpioiic") == 0);
! 95: }
! 96:
! 97: void
! 98: gpioiic_attach(struct device *parent, struct device *self, void *aux)
! 99: {
! 100: struct gpioiic_softc *sc = (struct gpioiic_softc *)self;
! 101: struct gpio_attach_args *ga = aux;
! 102: struct i2cbus_attach_args iba;
! 103: int caps;
! 104:
! 105: /* Check that we have enough pins */
! 106: if (gpio_npins(ga->ga_mask) != GPIOIIC_NPINS) {
! 107: printf(": invalid pin mask\n");
! 108: return;
! 109: }
! 110:
! 111: /* Map pins */
! 112: sc->sc_gpio = ga->ga_gpio;
! 113: sc->sc_map.pm_map = sc->__map;
! 114: if (gpio_pin_map(sc->sc_gpio, ga->ga_offset, ga->ga_mask,
! 115: &sc->sc_map)) {
! 116: printf(": can't map pins\n");
! 117: return;
! 118: }
! 119:
! 120: /* Configure SDA pin */
! 121: caps = gpio_pin_caps(sc->sc_gpio, &sc->sc_map, GPIOIIC_PIN_SDA);
! 122: if (!(caps & GPIO_PIN_OUTPUT)) {
! 123: printf(": SDA pin is unable to drive output\n");
! 124: goto fail;
! 125: }
! 126: if (!(caps & GPIO_PIN_INPUT)) {
! 127: printf(": SDA pin is unable to read input\n");
! 128: goto fail;
! 129: }
! 130: printf(": SDA[%d]", sc->sc_map.pm_map[GPIOIIC_PIN_SDA]);
! 131: sc->sc_sda = GPIO_PIN_OUTPUT;
! 132: if (caps & GPIO_PIN_OPENDRAIN) {
! 133: printf(" open-drain");
! 134: sc->sc_sda |= GPIO_PIN_OPENDRAIN;
! 135: } else if ((caps & GPIO_PIN_PUSHPULL) && (caps & GPIO_PIN_TRISTATE)) {
! 136: printf(" push-pull tri-state");
! 137: sc->sc_sda |= GPIO_PIN_PUSHPULL;
! 138: }
! 139: if (caps & GPIO_PIN_PULLUP) {
! 140: printf(" pull-up");
! 141: sc->sc_sda |= GPIO_PIN_PULLUP;
! 142: }
! 143: gpio_pin_ctl(sc->sc_gpio, &sc->sc_map, GPIOIIC_PIN_SDA, sc->sc_sda);
! 144:
! 145: /* Configure SCL pin */
! 146: caps = gpio_pin_caps(sc->sc_gpio, &sc->sc_map, GPIOIIC_PIN_SCL);
! 147: if (!(caps & GPIO_PIN_OUTPUT)) {
! 148: printf(": SCL pin is unable to drive output\n");
! 149: goto fail;
! 150: }
! 151: printf(", SCL[%d]", sc->sc_map.pm_map[GPIOIIC_PIN_SCL]);
! 152: sc->sc_scl = GPIO_PIN_OUTPUT;
! 153: if (caps & GPIO_PIN_OPENDRAIN) {
! 154: printf(" open-drain");
! 155: sc->sc_scl |= GPIO_PIN_OPENDRAIN;
! 156: if (caps & GPIO_PIN_PULLUP) {
! 157: printf(" pull-up");
! 158: sc->sc_scl |= GPIO_PIN_PULLUP;
! 159: }
! 160: } else if (caps & GPIO_PIN_PUSHPULL) {
! 161: printf(" push-pull");
! 162: sc->sc_scl |= GPIO_PIN_PUSHPULL;
! 163: }
! 164: gpio_pin_ctl(sc->sc_gpio, &sc->sc_map, GPIOIIC_PIN_SCL, sc->sc_scl);
! 165:
! 166: printf("\n");
! 167:
! 168: /* Attach I2C bus */
! 169: rw_init(&sc->sc_i2c_lock, "iiclk");
! 170: sc->sc_i2c_tag.ic_cookie = sc;
! 171: sc->sc_i2c_tag.ic_acquire_bus = gpioiic_i2c_acquire_bus;
! 172: sc->sc_i2c_tag.ic_release_bus = gpioiic_i2c_release_bus;
! 173: sc->sc_i2c_tag.ic_send_start = gpioiic_i2c_send_start;
! 174: sc->sc_i2c_tag.ic_send_stop = gpioiic_i2c_send_stop;
! 175: sc->sc_i2c_tag.ic_initiate_xfer = gpioiic_i2c_initiate_xfer;
! 176: sc->sc_i2c_tag.ic_read_byte = gpioiic_i2c_read_byte;
! 177: sc->sc_i2c_tag.ic_write_byte = gpioiic_i2c_write_byte;
! 178:
! 179: bzero(&iba, sizeof(iba));
! 180: iba.iba_name = "iic";
! 181: iba.iba_tag = &sc->sc_i2c_tag;
! 182: config_found(self, &iba, iicbus_print);
! 183:
! 184: return;
! 185:
! 186: fail:
! 187: gpio_pin_unmap(sc->sc_gpio, &sc->sc_map);
! 188: }
! 189:
! 190: int
! 191: gpioiic_detach(struct device *self, int flags)
! 192: {
! 193: return (0);
! 194: }
! 195:
! 196: int
! 197: gpioiic_i2c_acquire_bus(void *cookie, int flags)
! 198: {
! 199: struct gpioiic_softc *sc = cookie;
! 200:
! 201: if (cold || (flags & I2C_F_POLL))
! 202: return (0);
! 203:
! 204: return (rw_enter(&sc->sc_i2c_lock, RW_WRITE | RW_INTR));
! 205: }
! 206:
! 207: void
! 208: gpioiic_i2c_release_bus(void *cookie, int flags)
! 209: {
! 210: struct gpioiic_softc *sc = cookie;
! 211:
! 212: if (cold || (flags & I2C_F_POLL))
! 213: return;
! 214:
! 215: rw_exit(&sc->sc_i2c_lock);
! 216: }
! 217:
! 218: int
! 219: gpioiic_i2c_send_start(void *cookie, int flags)
! 220: {
! 221: return (i2c_bitbang_send_start(cookie, flags, &gpioiic_bbops));
! 222: }
! 223:
! 224: int
! 225: gpioiic_i2c_send_stop(void *cookie, int flags)
! 226: {
! 227: return (i2c_bitbang_send_stop(cookie, flags, &gpioiic_bbops));
! 228: }
! 229:
! 230: int
! 231: gpioiic_i2c_initiate_xfer(void *cookie, i2c_addr_t addr, int flags)
! 232: {
! 233: return (i2c_bitbang_initiate_xfer(cookie, addr, flags, &gpioiic_bbops));
! 234: }
! 235:
! 236: int
! 237: gpioiic_i2c_read_byte(void *cookie, u_int8_t *bytep, int flags)
! 238: {
! 239: return (i2c_bitbang_read_byte(cookie, bytep, flags, &gpioiic_bbops));
! 240: }
! 241:
! 242: int
! 243: gpioiic_i2c_write_byte(void *cookie, u_int8_t byte, int flags)
! 244: {
! 245: return (i2c_bitbang_write_byte(cookie, byte, flags, &gpioiic_bbops));
! 246: }
! 247:
! 248: void
! 249: gpioiic_bb_set_bits(void *cookie, u_int32_t bits)
! 250: {
! 251: struct gpioiic_softc *sc = cookie;
! 252:
! 253: gpio_pin_write(sc->sc_gpio, &sc->sc_map, GPIOIIC_PIN_SDA,
! 254: bits & GPIOIIC_SDA ? GPIO_PIN_HIGH : GPIO_PIN_LOW);
! 255: gpio_pin_write(sc->sc_gpio, &sc->sc_map, GPIOIIC_PIN_SCL,
! 256: bits & GPIOIIC_SCL ? GPIO_PIN_HIGH : GPIO_PIN_LOW);
! 257: }
! 258:
! 259: void
! 260: gpioiic_bb_set_dir(void *cookie, u_int32_t bits)
! 261: {
! 262: struct gpioiic_softc *sc = cookie;
! 263: int sda = sc->sc_sda;
! 264:
! 265: sda &= ~(GPIO_PIN_INPUT | GPIO_PIN_OUTPUT | GPIO_PIN_TRISTATE);
! 266: sda |= (bits & GPIOIIC_SDA ? GPIO_PIN_OUTPUT : GPIO_PIN_INPUT);
! 267: if ((sda & GPIO_PIN_PUSHPULL) && !(bits & GPIOIIC_SDA))
! 268: sda |= GPIO_PIN_TRISTATE;
! 269: if (sc->sc_sda != sda) {
! 270: sc->sc_sda = sda;
! 271: gpio_pin_ctl(sc->sc_gpio, &sc->sc_map, GPIOIIC_PIN_SDA,
! 272: sc->sc_sda);
! 273: }
! 274: }
! 275:
! 276: u_int32_t
! 277: gpioiic_bb_read_bits(void *cookie)
! 278: {
! 279: struct gpioiic_softc *sc = cookie;
! 280:
! 281: return (gpio_pin_read(sc->sc_gpio, &sc->sc_map,
! 282: GPIOIIC_PIN_SDA) == GPIO_PIN_HIGH ? GPIOIIC_SDA : 0);
! 283: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to gpioiic.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / gpio