sys/dev/iicbus/iiconf.c

   1 /*-
   2  * Copyright (c) 1998 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
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/systm.h>
  32 #include <sys/lock.h>
  33 #include <sys/malloc.h>
  34 #include <sys/module.h>
  35 #include <sys/mutex.h>
  36 #include <sys/bus.h>
  37
  38 #include <dev/iicbus/iiconf.h>
  39 #include <dev/iicbus/iicbus.h>
  40 #include "iicbus_if.h"
  41
  42 /*
  43  * iicbus_intr()
  44  */
  45 void
  46 iicbus_intr(device_t bus, int event, char *buf)
  47 {
  48         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
  49
  50         /* call owner's intr routine */
  51         if (sc->owner)
  52                 IICBUS_INTR(sc->owner, event, buf);
  53
  54         return;
  55 }
  56
  57 static int
  58 iicbus_poll(struct iicbus_softc *sc, int how)
  59 {
  60         int error;
  61
  62         IICBUS_ASSERT_LOCKED(sc);
  63         switch (how) {
  64         case IIC_WAIT | IIC_INTR:
  65                 error = mtx_sleep(sc, &sc->lock, IICPRI|PCATCH, "iicreq", 0);
  66                 break;
  67
  68         case IIC_WAIT | IIC_NOINTR:
  69                 error = mtx_sleep(sc, &sc->lock, IICPRI, "iicreq", 0);
  70                 break;
  71
  72         default:
  73                 return (EWOULDBLOCK);
  74         }
  75
  76         return (error);
  77 }
  78
  79 /*
  80  * iicbus_request_bus()
  81  *
  82  * Allocate the device to perform transfers.
  83  *
  84  * how  : IIC_WAIT or IIC_DONTWAIT
  85  */
  86 int
  87 iicbus_request_bus(device_t bus, device_t dev, int how)
  88 {
  89         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
  90         int error = 0;
  91
  92         IICBUS_LOCK(sc);
  93
  94         while ((error == 0) && (sc->owner != NULL))
  95                 error = iicbus_poll(sc, how);
  96
  97         if (error == 0) {
  98                 sc->owner = dev;
  99                 /*
 100                  * Drop the lock around the call to the bus driver.
 101                  * This call should be allowed to sleep in the IIC_WAIT case.
 102                  * Drivers might also need to grab locks that would cause LOR
 103                  * if our lock is held.
 104                  */
 105                 IICBUS_UNLOCK(sc);
 106                 /* Ask the underlying layers if the request is ok */
 107                 error = IICBUS_CALLBACK(device_get_parent(bus),
 108                     IIC_REQUEST_BUS, (caddr_t)&how);
 109                 IICBUS_LOCK(sc);
 110
 111                 if (error != 0) {
 112                         sc->owner = NULL;
 113                         wakeup_one(sc);
 114                 }
 115         }
 116
 117
 118         IICBUS_UNLOCK(sc);
 119
 120         return (error);
 121 }
 122
 123 /*
 124  * iicbus_release_bus()
 125  *
 126  * Release the device allocated with iicbus_request_dev()
 127  */
 128 int
 129 iicbus_release_bus(device_t bus, device_t dev)
 130 {
 131         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 132         int error;
 133
 134         IICBUS_LOCK(sc);
 135
 136         if (sc->owner != dev) {
 137                 IICBUS_UNLOCK(sc);
 138                 return (EACCES);
 139         }
 140
 141         /*
 142          * Drop the lock around the call to the bus driver.
 143          * This call should be allowed to sleep in the IIC_WAIT case.
 144          * Drivers might also need to grab locks that would cause LOR
 145          * if our lock is held.
 146          */
 147         IICBUS_UNLOCK(sc);
 148         /* Ask the underlying layers if the release is ok */
 149         error = IICBUS_CALLBACK(device_get_parent(bus), IIC_RELEASE_BUS, NULL);
 150
 151         if (error == 0) {
 152                 IICBUS_LOCK(sc);
 153                 sc->owner = NULL;
 154
 155                 /* wakeup a waiting thread */
 156                 wakeup_one(sc);
 157                 IICBUS_UNLOCK(sc);
 158         }
 159
 160         return (error);
 161 }
 162
 163 /*
 164  * iicbus_started()
 165  *
 166  * Test if the iicbus is started by the controller
 167  */
 168 int
 169 iicbus_started(device_t bus)
 170 {
 171         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 172
 173         return (sc->started);
 174 }
 175
 176 /*
 177  * iicbus_start()
 178  *
 179  * Send start condition to the slave addressed by 'slave'
 180  */
 181 int
 182 iicbus_start(device_t bus, u_char slave, int timeout)
 183 {
 184         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 185         int error = 0;
 186
 187         if (sc->started)
 188                 return (EINVAL);                /* bus already started */
 189
 190         if (!(error = IICBUS_START(device_get_parent(bus), slave, timeout)))
 191                 sc->started = slave;
 192         else
 193                 sc->started = 0;
 194
 195         return (error);
 196 }
 197
 198 /*
 199  * iicbus_repeated_start()
 200  *
 201  * Send start condition to the slave addressed by 'slave'
 202  */
 203 int
 204 iicbus_repeated_start(device_t bus, u_char slave, int timeout)
 205 {
 206         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 207         int error = 0;
 208
 209         if (!sc->started)
 210                 return (EINVAL);     /* bus should have been already started */
 211
 212         if (!(error = IICBUS_REPEATED_START(device_get_parent(bus), slave, timeout)))
 213                 sc->started = slave;
 214         else
 215                 sc->started = 0;
 216
 217         return (error);
 218 }
 219
 220 /*
 221  * iicbus_stop()
 222  *
 223  * Send stop condition to the bus
 224  */
 225 int
 226 iicbus_stop(device_t bus)
 227 {
 228         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 229         int error = 0;
 230
 231         if (!sc->started)
 232                 return (EINVAL);                /* bus not started */
 233
 234         error = IICBUS_STOP(device_get_parent(bus));
 235
 236         /* refuse any further access */
 237         sc->started = 0;
 238
 239         return (error);
 240 }
 241
 242 /*
 243  * iicbus_write()
 244  *
 245  * Write a block of data to the slave previously started by
 246  * iicbus_start() call
 247  */
 248 int
 249 iicbus_write(device_t bus, const char *buf, int len, int *sent, int timeout)
 250 {
 251         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 252
 253         /* a slave must have been started for writing */
 254         if (sc->started == 0 || (sc->strict != 0 && (sc->started & LSB) != 0))
 255                 return (EINVAL);
 256
 257         return (IICBUS_WRITE(device_get_parent(bus), buf, len, sent, timeout));
 258 }
 259
 260 /*
 261  * iicbus_read()
 262  *
 263  * Read a block of data from the slave previously started by
 264  * iicbus_read() call
 265  */
 266 int
 267 iicbus_read(device_t bus, char *buf, int len, int *read, int last, int delay)
 268 {
 269         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 270
 271         /* a slave must have been started for reading */
 272         if (sc->started == 0 || (sc->strict != 0 && (sc->started & LSB) == 0))
 273                 return (EINVAL);
 274
 275         return (IICBUS_READ(device_get_parent(bus), buf, len, read, last, delay));
 276 }
 277
 278 /*
 279  * iicbus_write_byte()
 280  *
 281  * Write a byte to the slave previously started by iicbus_start() call
 282  */
 283 int
 284 iicbus_write_byte(device_t bus, char byte, int timeout)
 285 {
 286         char data = byte;
 287         int sent;
 288
 289         return (iicbus_write(bus, &data, 1, &sent, timeout));
 290 }
 291
 292 /*
 293  * iicbus_read_byte()
 294  *
 295  * Read a byte from the slave previously started by iicbus_start() call
 296  */
 297 int
 298 iicbus_read_byte(device_t bus, char *byte, int timeout)
 299 {
 300         int read;
 301
 302         return (iicbus_read(bus, byte, 1, &read, IIC_LAST_READ, timeout));
 303 }
 304
 305 /*
 306  * iicbus_block_write()
 307  *
 308  * Write a block of data to slave ; start/stop protocol managed
 309  */
 310 int
 311 iicbus_block_write(device_t bus, u_char slave, char *buf, int len, int *sent)
 312 {
 313         u_char addr = slave & ~LSB;
 314         int error;
 315
 316         if ((error = iicbus_start(bus, addr, 0)))
 317                 return (error);
 318
 319         error = iicbus_write(bus, buf, len, sent, 0);
 320
 321         iicbus_stop(bus);
 322
 323         return (error);
 324 }
 325
 326 /*
 327  * iicbus_block_read()
 328  *
 329  * Read a block of data from slave ; start/stop protocol managed
 330  */
 331 int
 332 iicbus_block_read(device_t bus, u_char slave, char *buf, int len, int *read)
 333 {
 334         u_char addr = slave | LSB;
 335         int error;
 336
 337         if ((error = iicbus_start(bus, addr, 0)))
 338                 return (error);
 339
 340         error = iicbus_read(bus, buf, len, read, IIC_LAST_READ, 0);
 341
 342         iicbus_stop(bus);
 343
 344         return (error);
 345 }
 346
 347 /*
 348  * iicbus_transfer()
 349  *
 350  * Do an aribtrary number of transfers on the iicbus.  We pass these
 351  * raw requests to the bridge driver.  If the bridge driver supports
 352  * them directly, then it manages all the details.  If not, it can use
 353  * the helper function iicbus_transfer_gen() which will do the
 354  * transfers at a low level.
 355  *
 356  * Pointers passed in as part of iic_msg must be kernel pointers.
 357  * Callers that have user addresses to manage must do so on their own.
 358  */
 359 int
 360 iicbus_transfer(device_t bus, struct iic_msg *msgs, uint32_t nmsgs)
 361 {
 362         return (IICBUS_TRANSFER(device_get_parent(bus), msgs, nmsgs));
 363 }
 364
 365 /*
 366  * Generic version of iicbus_transfer that calls the appropriate
 367  * routines to accomplish this.  See note above about acceptable
 368  * buffer addresses.
 369  */
 370 int
 371 iicbus_transfer_gen(device_t dev, struct iic_msg *msgs, uint32_t nmsgs)
 372 {
 373         int i, error, lenread, lenwrote, nkid, rpstart, addr;
 374         device_t *children, bus;
 375         bool nostop;
 376
 377         if ((error = device_get_children(dev, &children, &nkid)) != 0)
 378                 return (error);
 379         if (nkid != 1) {
 380                 free(children, M_TEMP);
 381                 return (EIO);
 382         }
 383         bus = children[0];
 384         rpstart = 0;
 385         free(children, M_TEMP);
 386         nostop = iicbus_get_nostop(dev);
 387         for (i = 0, error = 0; i < nmsgs && error == 0; i++) {
 388                 addr = msgs[i].slave;
 389                 if (msgs[i].flags & IIC_M_RD)
 390                         addr |= LSB;
 391                 else
 392                         addr &= ~LSB;
 393
 394                 if (!(msgs[i].flags & IIC_M_NOSTART)) {
 395                         if (rpstart)
 396                                 error = iicbus_repeated_start(bus, addr, 0);
 397                         else
 398                                 error = iicbus_start(bus, addr, 0);
 399                 }
 400
 401                 if (error)
 402                         break;
 403
 404                 if (msgs[i].flags & IIC_M_RD)
 405                         error = iicbus_read(bus, msgs[i].buf, msgs[i].len,
 406                             &lenread, IIC_LAST_READ, 0);
 407                 else
 408                         error = iicbus_write(bus, msgs[i].buf, msgs[i].len,
 409                             &lenwrote, 0);
 410
 411                 if ((msgs[i].flags & IIC_M_NOSTOP) != 0 ||
 412                     (nostop && i + 1 < nmsgs)) {
 413                         rpstart = 1;    /* Next message gets repeated start */
 414                 } else {
 415                         rpstart = 0;
 416                         iicbus_stop(bus);
 417                 }
 418         }
 419         return (error);
 420 }