sys/bus/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  * $FreeBSD: src/sys/dev/iicbus/iiconf.c,v 1.10 1999/12/03 08:41:02 mdodd Exp $
  27  *
  28  */
  29 #include <sys/param.h>
  30 #include <sys/systm.h>
  31 #include <sys/kernel.h>
  32 #include <sys/malloc.h>
  33 #include <sys/module.h>
  34 #include <sys/bus.h>
  35
  36 #include <dev/iicbus/iiconf.h>
  37 #include <dev/iicbus/iicbus.h>
  38 #include "iicbus_if.h"
  39
  40 /*
  41  * iicbus_intr()
  42  */
  43 void
  44 iicbus_intr(device_t bus, int event, char *buf)
  45 {
  46         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
  47
  48         /* call owner's intr routine */
  49         if (sc->owner)
  50                 IICBUS_INTR(sc->owner, event, buf);
  51
  52         return;
  53 }
  54
  55 /*
  56  * iicbus_alloc_bus()
  57  *
  58  * Allocate a new bus connected to the given parent device
  59  */
  60 device_t
  61 iicbus_alloc_bus(device_t parent)
  62 {
  63         device_t child;
  64
  65         /* add the bus to the parent */
  66         child = device_add_child(parent, "iicbus", -1);
  67
  68         return (child);
  69 }
  70
  71 static int
  72 iicbus_poll(struct iicbus_softc *sc, int how)
  73 {
  74         int error;
  75
  76         switch (how) {
  77         case (IIC_WAIT | IIC_INTR):
  78                 error = tsleep(sc, IICPRI|PCATCH, "iicreq", 0);
  79                 break;
  80
  81         case (IIC_WAIT | IIC_NOINTR):
  82                 error = tsleep(sc, IICPRI, "iicreq", 0);
  83                 break;
  84
  85         default:
  86                 return (EWOULDBLOCK);
  87                 break;
  88         }
  89
  90         return (error);
  91 }
  92
  93 /*
  94  * iicbus_request_bus()
  95  *
  96  * Allocate the device to perform transfers.
  97  *
  98  * how  : IIC_WAIT or IIC_DONTWAIT
  99  */
 100 int
 101 iicbus_request_bus(device_t bus, device_t dev, int how)
 102 {
 103         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 104         int s, error = 0;
 105
 106         /* first, ask the underlying layers if the request is ok */
 107         do {
 108                 error = IICBUS_CALLBACK(device_get_parent(bus),
 109                                                 IIC_REQUEST_BUS, (caddr_t)&how);
 110                 if (error)
 111                         error = iicbus_poll(sc, how);
 112         } while (error == EWOULDBLOCK);
 113
 114         while (!error) {
 115                 s = splhigh();
 116                 if (sc->owner && sc->owner != dev) {
 117                         splx(s);
 118
 119                         error = iicbus_poll(sc, how);
 120                 } else {
 121                         sc->owner = dev;
 122
 123                         splx(s);
 124                         return (0);
 125                 }
 126
 127                 /* free any allocated resource */
 128                 if (error)
 129                         IICBUS_CALLBACK(device_get_parent(bus), IIC_RELEASE_BUS,
 130                                         (caddr_t)&how);
 131         }
 132
 133         return (error);
 134 }
 135
 136 /*
 137  * iicbus_release_bus()
 138  *
 139  * Release the device allocated with iicbus_request_dev()
 140  */
 141 int
 142 iicbus_release_bus(device_t bus, device_t dev)
 143 {
 144         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 145         int s, error;
 146
 147         /* first, ask the underlying layers if the release is ok */
 148         error = IICBUS_CALLBACK(device_get_parent(bus), IIC_RELEASE_BUS, NULL);
 149
 150         if (error)
 151                 return (error);
 152
 153         s = splhigh();
 154         if (sc->owner != dev) {
 155                 splx(s);
 156                 return (EACCES);
 157         }
 158
 159         sc->owner = 0;
 160         splx(s);
 161
 162         /* wakeup waiting processes */
 163         wakeup(sc);
 164
 165         return (0);
 166 }
 167
 168 /*
 169  * iicbus_started()
 170  *
 171  * Test if the iicbus is started by the controller
 172  */
 173 int
 174 iicbus_started(device_t bus)
 175 {
 176         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 177
 178         return (sc->started);
 179 }
 180
 181 /*
 182  * iicbus_start()
 183  *
 184  * Send start condition to the slave addressed by 'slave'
 185  */
 186 int
 187 iicbus_start(device_t bus, u_char slave, int timeout)
 188 {
 189         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 190         int error = 0;
 191
 192         if (sc->started)
 193                 return (EINVAL);                /* bus already started */
 194
 195         if (!(error = IICBUS_START(device_get_parent(bus), slave, timeout)))
 196                 sc->started = slave;
 197         else
 198                 sc->started = 0;
 199
 200         return (error);
 201 }
 202
 203 /*
 204  * iicbus_repeated_start()
 205  *
 206  * Send start condition to the slave addressed by 'slave'
 207  */
 208 int
 209 iicbus_repeated_start(device_t bus, u_char slave, int timeout)
 210 {
 211         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 212         int error = 0;
 213
 214         if (!sc->started)
 215                 return (EINVAL);     /* bus should have been already started */
 216
 217         if (!(error = IICBUS_REPEATED_START(device_get_parent(bus), slave, timeout)))
 218                 sc->started = slave;
 219         else
 220                 sc->started = 0;
 221
 222         return (error);
 223 }
 224
 225 /*
 226  * iicbus_stop()
 227  *
 228  * Send stop condition to the bus
 229  */
 230 int
 231 iicbus_stop(device_t bus)
 232 {
 233         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 234         int error = 0;
 235
 236         if (!sc->started)
 237                 return (EINVAL);                /* bus not started */
 238
 239         error = IICBUS_STOP(device_get_parent(bus));
 240
 241         /* refuse any further access */
 242         sc->started = 0;
 243
 244         return (error);
 245 }
 246
 247 /*
 248  * iicbus_write()
 249  *
 250  * Write a block of data to the slave previously started by
 251  * iicbus_start() call
 252  */
 253 int
 254 iicbus_write(device_t bus, char *buf, int len, int *sent, int timeout)
 255 {
 256         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 257
 258         /* a slave must have been started with the appropriate address */
 259         if (!sc->started || (sc->started & LSB))
 260                 return (EINVAL);
 261
 262         return (IICBUS_WRITE(device_get_parent(bus), buf, len, sent, timeout));
 263 }
 264
 265 /*
 266  * iicbus_read()
 267  *
 268  * Read a block of data from the slave previously started by
 269  * iicbus_read() call
 270  */
 271 int
 272 iicbus_read(device_t bus, char *buf, int len, int *read, int last, int delay)
 273 {
 274         struct iicbus_softc *sc = (struct iicbus_softc *)device_get_softc(bus);
 275
 276         /* a slave must have been started with the appropriate address */
 277         if (!sc->started || !(sc->started & LSB))
 278                 return (EINVAL);
 279
 280         return (IICBUS_READ(device_get_parent(bus), buf, len, read, last, delay));
 281 }
 282
 283 /*
 284  * iicbus_write_byte()
 285  *
 286  * Write a byte to the slave previously started by iicbus_start() call
 287  */
 288 int
 289 iicbus_write_byte(device_t bus, char byte, int timeout)
 290 {
 291         char data = byte;
 292         int sent;
 293
 294         return (iicbus_write(bus, &data, 1, &sent, timeout));
 295 }
 296
 297 /*
 298  * iicbus_read_byte()
 299  *
 300  * Read a byte from the slave previously started by iicbus_start() call
 301  */
 302 int
 303 iicbus_read_byte(device_t bus, char *byte, int timeout)
 304 {
 305         int read;
 306
 307         return (iicbus_read(bus, byte, 1, &read, IIC_LAST_READ, timeout));
 308 }
 309
 310 /*
 311  * iicbus_block_write()
 312  *
 313  * Write a block of data to slave ; start/stop protocol managed
 314  */
 315 int
 316 iicbus_block_write(device_t bus, u_char slave, char *buf, int len, int *sent)
 317 {
 318         u_char addr = slave & ~LSB;
 319         int error;
 320
 321         if ((error = iicbus_start(bus, addr, 0)))
 322                 return (error);
 323
 324         error = iicbus_write(bus, buf, len, sent, 0);
 325
 326         iicbus_stop(bus);
 327
 328         return (error);
 329 }
 330
 331 /*
 332  * iicbus_block_read()
 333  *
 334  * Read a block of data from slave ; start/stop protocol managed
 335  */
 336 int
 337 iicbus_block_read(device_t bus, u_char slave, char *buf, int len, int *read)
 338 {
 339         u_char addr = slave | LSB;
 340         int error;
 341
 342         if ((error = iicbus_start(bus, addr, 0)))
 343                 return (error);
 344
 345         error = iicbus_read(bus, buf, len, read, IIC_LAST_READ, 0);
 346
 347         iicbus_stop(bus);
 348
 349         return (error);
 350 }
 351
 352 /*
 353  * iicbus_get_addr()
 354  *
 355  * Get the I2C 7 bits address of the device
 356  */
 357 u_char
 358 iicbus_get_addr(device_t dev)
 359 {
 360         uintptr_t addr;
 361         device_t parent = device_get_parent(dev);
 362
 363         BUS_READ_IVAR(parent, dev, IICBUS_IVAR_ADDR, &addr);
 364
 365         return ((u_char)addr);
 366 }
 367