iic.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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);
Cache object: 8242bd924cdcc5cbbef34ab61c542489
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/iicbus/iic.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/iicbus/iic.c
