sys/dev/iicbus/iic.c

   1 /*-
   2  * Copyright (c) 1998, 2001 Nicolas Souchu
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  *
  28  */
  29 #include <sys/param.h>
  30 #include <sys/bus.h>
  31 #include <sys/conf.h>
  32 #include <sys/fcntl.h>
  33 #include <sys/lock.h>
  34 #include <sys/kernel.h>
  35 #include <sys/malloc.h>
  36 #include <sys/module.h>
  37 #include <sys/sx.h>
  38 #include <sys/systm.h>
  39 #include <sys/uio.h>
  40
  41 #include <dev/iicbus/iiconf.h>
  42 #include <dev/iicbus/iicbus.h>
  43 #include <dev/iicbus/iic.h>
  44
  45 #include "iicbus_if.h"
  46
  47 #define BUFSIZE 1024
  48
  49 struct iic_softc {
  50
  51         device_t sc_dev;
  52         u_char sc_addr;                 /* 7 bit address on iicbus */
  53         int sc_count;                   /* >0 if device opened */
  54
  55         char sc_buffer[BUFSIZE];        /* output buffer */
  56         char sc_inbuf[BUFSIZE];         /* input buffer */
  57
  58         struct cdev *sc_devnode;
  59         struct sx sc_lock;
  60 };
  61
  62 #define IIC_LOCK(sc)                    sx_xlock(&(sc)->sc_lock)
  63 #define IIC_UNLOCK(sc)                  sx_xunlock(&(sc)->sc_lock)
  64
  65 static int iic_probe(device_t);
  66 static int iic_attach(device_t);
  67 static int iic_detach(device_t);
  68 static void iic_identify(driver_t *driver, device_t parent);
  69
  70 static devclass_t iic_devclass;
  71
  72 static device_method_t iic_methods[] = {
  73         /* device interface */
  74         DEVMETHOD(device_identify,      iic_identify),
  75         DEVMETHOD(device_probe,         iic_probe),
  76         DEVMETHOD(device_attach,        iic_attach),
  77         DEVMETHOD(device_detach,        iic_detach),
  78
  79         /* iicbus interface */
  80         DEVMETHOD(iicbus_intr,          iicbus_generic_intr),
  81
  82         { 0, 0 }
  83 };
  84
  85 static driver_t iic_driver = {
  86         "iic",
  87         iic_methods,
  88         sizeof(struct iic_softc),
  89 };
  90
  91 static  d_open_t        iicopen;
  92 static  d_close_t       iicclose;
  93 static  d_write_t       iicwrite;
  94 static  d_read_t        iicread;
  95 static  d_ioctl_t       iicioctl;
  96
  97 static struct cdevsw iic_cdevsw = {
  98         .d_version =    D_VERSION,
  99         .d_flags =      D_TRACKCLOSE,
 100         .d_open =       iicopen,
 101         .d_close =      iicclose,
 102         .d_read =       iicread,
 103         .d_write =      iicwrite,
 104         .d_ioctl =      iicioctl,
 105         .d_name =       "iic",
 106 };
 107
 108 static void
 109 iic_identify(driver_t *driver, device_t parent)
 110 {
 111
 112         if (device_find_child(parent, "iic", -1) == NULL)
 113                 BUS_ADD_CHILD(parent, 0, "iic", -1);
 114 }
 115
 116 static int
 117 iic_probe(device_t dev)
 118 {
 119         if (iicbus_get_addr(dev) > 0)
 120                 return (ENXIO);
 121
 122         device_set_desc(dev, "I2C generic I/O");
 123
 124         return (0);
 125 }
 126
 127 static int
 128 iic_attach(device_t dev)
 129 {
 130         struct iic_softc *sc = (struct iic_softc *)device_get_softc(dev);
 131
 132         sc->sc_dev = dev;
 133         sx_init(&sc->sc_lock, "iic");
 134         sc->sc_devnode = make_dev(&iic_cdevsw, device_get_unit(dev),
 135                         UID_ROOT, GID_WHEEL,
 136                         0600, "iic%d", device_get_unit(dev));
 137         if (sc->sc_devnode == NULL) {
 138                 device_printf(dev, "failed to create character device\n");
 139                 sx_destroy(&sc->sc_lock);
 140                 return (ENXIO);
 141         }
 142         sc->sc_devnode->si_drv1 = sc;
 143
 144         return (0);
 145 }
 146
 147 static int
 148 iic_detach(device_t dev)
 149 {
 150         struct iic_softc *sc = (struct iic_softc *)device_get_softc(dev);
 151
 152         if (sc->sc_devnode)
 153                 destroy_dev(sc->sc_devnode);
 154         sx_destroy(&sc->sc_lock);
 155
 156         return (0);
 157 }
 158
 159 static int
 160 iicopen(struct cdev *dev, int flags, int fmt, struct thread *td)
 161 {
 162         struct iic_softc *sc = dev->si_drv1;
 163
 164         IIC_LOCK(sc);
 165         if (sc->sc_count > 0) {
 166                 IIC_UNLOCK(sc);
 167                 return (EBUSY);
 168         }
 169
 170         sc->sc_count++;
 171         IIC_UNLOCK(sc);
 172
 173         return (0);
 174 }
 175
 176 static int
 177 iicclose(struct cdev *dev, int flags, int fmt, struct thread *td)
 178 {
 179         struct iic_softc *sc = dev->si_drv1;
 180
 181         IIC_LOCK(sc);
 182         if (!sc->sc_count) {
 183                 /* XXX: I don't think this can happen. */
 184                 IIC_UNLOCK(sc);
 185                 return (EINVAL);
 186         }
 187
 188         sc->sc_count--;
 189
 190         if (sc->sc_count < 0)
 191                 panic("%s: iic_count < 0!", __func__);
 192         IIC_UNLOCK(sc);
 193
 194         return (0);
 195 }
 196
 197 static int
 198 iicwrite(struct cdev *dev, struct uio * uio, int ioflag)
 199 {
 200         struct iic_softc *sc = dev->si_drv1;
 201         device_t iicdev = sc->sc_dev;
 202         int sent, error, count;
 203
 204         IIC_LOCK(sc);
 205         if (!sc->sc_addr) {
 206                 IIC_UNLOCK(sc);
 207                 return (EINVAL);
 208         }
 209
 210         if (sc->sc_count == 0) {
 211                 /* XXX: I don't think this can happen. */
 212                 IIC_UNLOCK(sc);
 213                 return (EINVAL);
 214         }
 215
 216         error = iicbus_request_bus(device_get_parent(iicdev), iicdev,
 217             IIC_DONTWAIT);
 218         if (error) {
 219                 IIC_UNLOCK(sc);
 220                 return (error);
 221         }
 222
 223         count = min(uio->uio_resid, BUFSIZE);
 224         uiomove(sc->sc_buffer, count, uio);
 225
 226         error = iicbus_block_write(device_get_parent(iicdev), sc->sc_addr,
 227                                         sc->sc_buffer, count, &sent);
 228
 229         iicbus_release_bus(device_get_parent(iicdev), iicdev);
 230         IIC_UNLOCK(sc);
 231
 232         return (error);
 233 }
 234
 235 static int
 236 iicread(struct cdev *dev, struct uio * uio, int ioflag)
 237 {
 238         struct iic_softc *sc = dev->si_drv1;
 239         device_t iicdev = sc->sc_dev;
 240         int len, error = 0;
 241         int bufsize;
 242
 243         IIC_LOCK(sc);
 244         if (!sc->sc_addr) {
 245                 IIC_UNLOCK(sc);
 246                 return (EINVAL);
 247         }
 248
 249         if (sc->sc_count == 0) {
 250                 /* XXX: I don't think this can happen. */
 251                 IIC_UNLOCK(sc);
 252                 return (EINVAL);
 253         }
 254
 255         error = iicbus_request_bus(device_get_parent(iicdev), iicdev,
 256             IIC_DONTWAIT);
 257         if (error) {
 258                 IIC_UNLOCK(sc);
 259                 return (error);
 260         }
 261
 262         /* max amount of data to read */
 263         len = min(uio->uio_resid, BUFSIZE);
 264
 265         error = iicbus_block_read(device_get_parent(iicdev), sc->sc_addr,
 266             sc->sc_inbuf, len, &bufsize);
 267         if (error) {
 268                 IIC_UNLOCK(sc);
 269                 return (error);
 270         }
 271
 272         if (bufsize > uio->uio_resid)
 273                 panic("%s: too much data read!", __func__);
 274
 275         iicbus_release_bus(device_get_parent(iicdev), iicdev);
 276
 277         error = uiomove(sc->sc_inbuf, bufsize, uio);
 278         IIC_UNLOCK(sc);
 279         return (error);
 280 }
 281
 282 static int
 283 iicioctl(struct cdev *dev, u_long cmd, caddr_t data, int flags, struct thread *td)
 284 {
 285         struct iic_softc *sc = dev->si_drv1;
 286         device_t iicdev = sc->sc_dev;
 287         device_t parent = device_get_parent(iicdev);
 288         struct iiccmd *s = (struct iiccmd *)data;
 289         struct iic_rdwr_data *d = (struct iic_rdwr_data *)data;
 290         struct iic_msg *m;
 291         int error, count, i;
 292         char *buf = NULL;
 293         void **usrbufs = NULL;
 294
 295         if ((error = iicbus_request_bus(parent, iicdev,
 296             (flags & O_NONBLOCK) ? IIC_DONTWAIT : (IIC_WAIT | IIC_INTR))))
 297                 return (error);
 298
 299         switch (cmd) {
 300         case I2CSTART:
 301                 IIC_LOCK(sc);
 302                 error = iicbus_start(parent, s->slave, 0);
 303
 304                 /*
 305                  * Implicitly set the chip addr to the slave addr passed as
 306                  * parameter. Consequently, start/stop shall be called before
 307                  * the read or the write of a block.
 308                  */
 309                 if (!error)
 310                         sc->sc_addr = s->slave;
 311                 IIC_UNLOCK(sc);
 312
 313                 break;
 314
 315         case I2CSTOP:
 316                 error = iicbus_stop(parent);
 317                 break;
 318
 319         case I2CRSTCARD:
 320                 error = iicbus_reset(parent, IIC_UNKNOWN, 0, NULL);
 321                 break;
 322
 323         case I2CWRITE:
 324                 if (s->count <= 0) {
 325                         error = EINVAL;
 326                         break;
 327                 }
 328                 buf = malloc((unsigned long)s->count, M_TEMP, M_WAITOK);
 329                 error = copyin(s->buf, buf, s->count);
 330                 if (error)
 331                         break;
 332                 error = iicbus_write(parent, buf, s->count, &count, 10);
 333                 break;
 334
 335         case I2CREAD:
 336                 if (s->count <= 0) {
 337                         error = EINVAL;
 338                         break;
 339                 }
 340                 buf = malloc((unsigned long)s->count, M_TEMP, M_WAITOK);
 341                 error = iicbus_read(parent, buf, s->count, &count, s->last, 10);
 342                 if (error)
 343                         break;
 344                 error = copyout(buf, s->buf, s->count);
 345                 break;
 346
 347         case I2CRDWR:
 348                 buf = malloc(sizeof(*d->msgs) * d->nmsgs, M_TEMP, M_WAITOK);
 349                 error = copyin(d->msgs, buf, sizeof(*d->msgs) * d->nmsgs);
 350                 if (error)
 351                         break;
 352                 /* Alloc kernel buffers for userland data, copyin write data */
 353                 usrbufs = malloc(sizeof(void *) * d->nmsgs, M_TEMP, M_ZERO | M_WAITOK);
 354                 for (i = 0; i < d->nmsgs; i++) {
 355                         m = &((struct iic_msg *)buf)[i];
 356                         usrbufs[i] = m->buf;
 357                         m->buf = malloc(m->len, M_TEMP, M_WAITOK);
 358                         if (!(m->flags & IIC_M_RD))
 359                                 copyin(usrbufs[i], m->buf, m->len);
 360                 }
 361                 error = iicbus_transfer(iicdev, (struct iic_msg *)buf, d->nmsgs);
 362                 /* Copyout all read segments, free up kernel buffers */
 363                 for (i = 0; i < d->nmsgs; i++) {
 364                         m = &((struct iic_msg *)buf)[i];
 365                         if (m->flags & IIC_M_RD)
 366                                 copyout(m->buf, usrbufs[i], m->len);
 367                         free(m->buf, M_TEMP);
 368                 }
 369                 free(usrbufs, M_TEMP);
 370                 break;
 371
 372         case I2CRPTSTART:
 373                 error = iicbus_repeated_start(parent, s->slave, 0);
 374                 break;
 375
 376         default:
 377                 error = ENOTTY;
 378         }
 379
 380         iicbus_release_bus(parent, iicdev);
 381
 382         if (buf != NULL)
 383                 free(buf, M_TEMP);
 384         return (error);
 385 }
 386
 387 DRIVER_MODULE(iic, iicbus, iic_driver, iic_devclass, 0, 0);
 388 MODULE_DEPEND(iic, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER);
 389 MODULE_VERSION(iic, 1);