sys/dev/iicbus/iicbb.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1998, 2001 Nicolas Souchu
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 /*
  33  * Generic I2C bit-banging code
  34  *
  35  * Example:
  36  *
  37  *      iicbus
  38  *       /  \
  39  *    iicbb pcf
  40  *     |  \
  41  *   bti2c lpbb
  42  *
  43  * From Linux I2C generic interface
  44  * (c) 1998 Gerd Knorr <kraxel@cs.tu-berlin.de>
  45  *
  46  */
  47
  48 #include "opt_platform.h"
  49
  50 #include <sys/param.h>
  51 #include <sys/kernel.h>
  52 #include <sys/systm.h>
  53 #include <sys/module.h>
  54 #include <sys/bus.h>
  55 #include <sys/sysctl.h>
  56 #include <sys/uio.h>
  57
  58 #ifdef FDT
  59 #include <dev/ofw/ofw_bus.h>
  60 #include <dev/ofw/ofw_bus_subr.h>
  61 #include <dev/fdt/fdt_common.h>
  62 #endif
  63
  64 #include <dev/iicbus/iiconf.h>
  65 #include <dev/iicbus/iicbus.h>
  66
  67 #include <dev/smbus/smbconf.h>
  68
  69 #include "iicbus_if.h"
  70 #include "iicbb_if.h"
  71
  72 /* Based on the SMBus specification. */
  73 #define DEFAULT_SCL_LOW_TIMEOUT (25 * 1000)
  74
  75 struct iicbb_softc {
  76         device_t iicbus;
  77         u_int udelay;           /* signal toggle delay in usec */
  78         u_int scl_low_timeout;
  79 };
  80
  81 static int iicbb_attach(device_t);
  82 static void iicbb_child_detached(device_t, device_t);
  83 static int iicbb_detach(device_t);
  84 static int iicbb_print_child(device_t, device_t);
  85 static int iicbb_probe(device_t);
  86
  87 static int iicbb_callback(device_t, int, caddr_t);
  88 static int iicbb_start(device_t, u_char, int);
  89 static int iicbb_stop(device_t);
  90 static int iicbb_write(device_t, const char *, int, int *, int);
  91 static int iicbb_read(device_t, char *, int, int *, int, int);
  92 static int iicbb_reset(device_t, u_char, u_char, u_char *);
  93 static int iicbb_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs);
  94 static void iicbb_set_speed(struct iicbb_softc *sc, u_char);
  95 #ifdef FDT
  96 static phandle_t iicbb_get_node(device_t, device_t);
  97 #endif
  98
  99 static device_method_t iicbb_methods[] = {
 100         /* device interface */
 101         DEVMETHOD(device_probe,         iicbb_probe),
 102         DEVMETHOD(device_attach,        iicbb_attach),
 103         DEVMETHOD(device_detach,        iicbb_detach),
 104
 105         /* bus interface */
 106         DEVMETHOD(bus_child_detached,   iicbb_child_detached),
 107         DEVMETHOD(bus_print_child,      iicbb_print_child),
 108
 109         /* iicbus interface */
 110         DEVMETHOD(iicbus_callback,      iicbb_callback),
 111         DEVMETHOD(iicbus_start,         iicbb_start),
 112         DEVMETHOD(iicbus_repeated_start, iicbb_start),
 113         DEVMETHOD(iicbus_stop,          iicbb_stop),
 114         DEVMETHOD(iicbus_write,         iicbb_write),
 115         DEVMETHOD(iicbus_read,          iicbb_read),
 116         DEVMETHOD(iicbus_reset,         iicbb_reset),
 117         DEVMETHOD(iicbus_transfer,      iicbb_transfer),
 118
 119 #ifdef FDT
 120         /* ofw_bus interface */
 121         DEVMETHOD(ofw_bus_get_node,     iicbb_get_node),
 122 #endif
 123
 124         { 0, 0 }
 125 };
 126
 127 driver_t iicbb_driver = {
 128         "iicbb",
 129         iicbb_methods,
 130         sizeof(struct iicbb_softc),
 131 };
 132
 133 devclass_t iicbb_devclass;
 134
 135 static int
 136 iicbb_probe(device_t dev)
 137 {
 138         device_set_desc(dev, "I2C bit-banging driver");
 139
 140         return (0);
 141 }
 142
 143 static int
 144 iicbb_attach(device_t dev)
 145 {
 146         struct iicbb_softc *sc = (struct iicbb_softc *)device_get_softc(dev);
 147
 148         sc->iicbus = device_add_child(dev, "iicbus", -1);
 149         if (!sc->iicbus)
 150                 return (ENXIO);
 151
 152         sc->scl_low_timeout = DEFAULT_SCL_LOW_TIMEOUT;
 153
 154         SYSCTL_ADD_UINT(device_get_sysctl_ctx(dev),
 155             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
 156             "delay", CTLFLAG_RD, &sc->udelay,
 157             0, "Signal change delay controlled by bus frequency, microseconds");
 158
 159         SYSCTL_ADD_UINT(device_get_sysctl_ctx(dev),
 160             SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
 161             "scl_low_timeout", CTLFLAG_RWTUN, &sc->scl_low_timeout,
 162             0, "SCL low timeout, microseconds");
 163         bus_generic_attach(dev);
 164         return (0);
 165 }
 166
 167 static int
 168 iicbb_detach(device_t dev)
 169 {
 170
 171         bus_generic_detach(dev);
 172         device_delete_children(dev);
 173
 174         return (0);
 175 }
 176
 177 #ifdef FDT
 178 static phandle_t
 179 iicbb_get_node(device_t bus, device_t dev)
 180 {
 181
 182         /* We only have one child, the I2C bus, which needs our own node. */
 183         return (ofw_bus_get_node(bus));
 184 }
 185 #endif
 186
 187 static void
 188 iicbb_child_detached( device_t dev, device_t child )
 189 {
 190         struct iicbb_softc *sc = (struct iicbb_softc *)device_get_softc(dev);
 191
 192         if (child == sc->iicbus)
 193                 sc->iicbus = NULL;
 194 }
 195
 196 static int
 197 iicbb_print_child(device_t bus, device_t dev)
 198 {
 199         int error;
 200         int retval = 0;
 201         u_char oldaddr;
 202
 203         retval += bus_print_child_header(bus, dev);
 204         /* retrieve the interface I2C address */
 205         error = IICBB_RESET(device_get_parent(bus), IIC_FASTEST, 0, &oldaddr);
 206         if (error == IIC_ENOADDR) {
 207                 retval += printf(" on %s master-only\n",
 208                                  device_get_nameunit(bus));
 209         } else {
 210                 /* restore the address */
 211                 IICBB_RESET(device_get_parent(bus), IIC_FASTEST, oldaddr, NULL);
 212
 213                 retval += printf(" on %s addr 0x%x\n",
 214                                  device_get_nameunit(bus), oldaddr & 0xff);
 215         }
 216
 217         return (retval);
 218 }
 219
 220 #define I2C_GETSDA(dev)         (IICBB_GETSDA(device_get_parent(dev)))
 221 #define I2C_SETSDA(dev, x)      (IICBB_SETSDA(device_get_parent(dev), x))
 222 #define I2C_GETSCL(dev)         (IICBB_GETSCL(device_get_parent(dev)))
 223 #define I2C_SETSCL(dev, x)      (IICBB_SETSCL(device_get_parent(dev), x))
 224
 225 #define I2C_SET(sc, dev, ctrl, val) do {                \
 226         iicbb_setscl(dev, ctrl);                        \
 227         I2C_SETSDA(dev, val);                           \
 228         DELAY(sc->udelay);                              \
 229         } while (0)
 230
 231 static int i2c_debug = 0;
 232 #define I2C_DEBUG(x)    do {                                    \
 233                                 if (i2c_debug) (x);             \
 234                         } while (0)
 235
 236 #define I2C_LOG(format,args...) do {                            \
 237                                         printf(format, args);   \
 238                                 } while (0)
 239
 240 static void
 241 iicbb_setscl(device_t dev, int val)
 242 {
 243         struct iicbb_softc *sc = device_get_softc(dev);
 244         sbintime_t now, end;
 245         int fast_timeout;
 246
 247         I2C_SETSCL(dev, val);
 248         DELAY(sc->udelay);
 249
 250         /* Pulling low cannot fail. */
 251         if (!val)
 252                 return;
 253
 254         /* Use DELAY for up to 1 ms, then switch to pause. */
 255         end = sbinuptime() + sc->scl_low_timeout * SBT_1US;
 256         fast_timeout = MIN(sc->scl_low_timeout, 1000);
 257         while (fast_timeout > 0) {
 258                 if (I2C_GETSCL(dev))
 259                         return;
 260                 I2C_SETSCL(dev, 1);     /* redundant ? */
 261                 DELAY(sc->udelay);
 262                 fast_timeout -= sc->udelay;
 263         }
 264
 265         while (!I2C_GETSCL(dev)) {
 266                 now = sbinuptime();
 267                 if (now >= end)
 268                         break;
 269                 pause_sbt("iicbb-scl-low", SBT_1MS, C_PREL(8), 0);
 270         }
 271
 272 }
 273
 274 static void
 275 iicbb_one(device_t dev, int timeout)
 276 {
 277         struct iicbb_softc *sc = device_get_softc(dev);
 278
 279         I2C_SET(sc,dev,0,1);
 280         I2C_SET(sc,dev,1,1);
 281         I2C_SET(sc,dev,0,1);
 282         return;
 283 }
 284
 285 static void
 286 iicbb_zero(device_t dev, int timeout)
 287 {
 288         struct iicbb_softc *sc = device_get_softc(dev);
 289
 290         I2C_SET(sc,dev,0,0);
 291         I2C_SET(sc,dev,1,0);
 292         I2C_SET(sc,dev,0,0);
 293         return;
 294 }
 295
 296 /*
 297  * Waiting for ACKNOWLEDGE.
 298  *
 299  * When a chip is being addressed or has received data it will issue an
 300  * ACKNOWLEDGE pulse. Therefore the MASTER must release the DATA line
 301  * (set it to high level) and then release the CLOCK line.
 302  * Now it must wait for the SLAVE to pull the DATA line low.
 303  * Actually on the bus this looks like a START condition so nothing happens
 304  * because of the fact that the IC's that have not been addressed are doing
 305  * nothing.
 306  *
 307  * When the SLAVE has pulled this line low the MASTER will take the CLOCK
 308  * line low and then the SLAVE will release the SDA (data) line.
 309  */
 310 static int
 311 iicbb_ack(device_t dev, int timeout)
 312 {
 313         struct iicbb_softc *sc = device_get_softc(dev);
 314         int noack;
 315         int k = 0;
 316
 317         I2C_SET(sc,dev,0,1);
 318         I2C_SET(sc,dev,1,1);
 319
 320         /* SCL must be high now. */
 321         if (!I2C_GETSCL(dev))
 322                 return (IIC_ETIMEOUT);
 323
 324         do {
 325                 noack = I2C_GETSDA(dev);
 326                 if (!noack)
 327                         break;
 328                 DELAY(1);
 329                 k++;
 330         } while (k < timeout);
 331
 332         I2C_SET(sc,dev,0,1);
 333         I2C_DEBUG(printf("%c ",noack?'-':'+'));
 334
 335         return (noack ? IIC_ENOACK : 0);
 336 }
 337
 338 static void
 339 iicbb_sendbyte(device_t dev, u_char data, int timeout)
 340 {
 341         int i;
 342
 343         for (i=7; i>=0; i--) {
 344                 if (data&(1<<i)) {
 345                         iicbb_one(dev, timeout);
 346                 } else {
 347                         iicbb_zero(dev, timeout);
 348                 }
 349         }
 350         I2C_DEBUG(printf("w%02x",(int)data));
 351         return;
 352 }
 353
 354 static u_char
 355 iicbb_readbyte(device_t dev, int last, int timeout)
 356 {
 357         struct iicbb_softc *sc = device_get_softc(dev);
 358         int i;
 359         unsigned char data=0;
 360
 361         I2C_SET(sc,dev,0,1);
 362         for (i=7; i>=0; i--)
 363         {
 364                 I2C_SET(sc,dev,1,1);
 365                 if (I2C_GETSDA(dev))
 366                         data |= (1<<i);
 367                 I2C_SET(sc,dev,0,1);
 368         }
 369         if (last) {
 370                 iicbb_one(dev, timeout);
 371         } else {
 372                 iicbb_zero(dev, timeout);
 373         }
 374         I2C_DEBUG(printf("r%02x%c ",(int)data,last?'-':'+'));
 375         return (data);
 376 }
 377
 378 static int
 379 iicbb_callback(device_t dev, int index, caddr_t data)
 380 {
 381         return (IICBB_CALLBACK(device_get_parent(dev), index, data));
 382 }
 383
 384 static int
 385 iicbb_reset(device_t dev, u_char speed, u_char addr, u_char *oldaddr)
 386 {
 387         iicbb_set_speed(device_get_softc(dev), speed);
 388         return (IICBB_RESET(device_get_parent(dev), speed, addr, oldaddr));
 389 }
 390
 391 static int
 392 iicbb_start(device_t dev, u_char slave, int timeout)
 393 {
 394         struct iicbb_softc *sc = device_get_softc(dev);
 395         int error;
 396
 397         I2C_DEBUG(printf("<"));
 398
 399         I2C_SET(sc,dev,1,1);
 400
 401         /* SCL must be high now. */
 402         if (!I2C_GETSCL(dev))
 403                 return (IIC_ETIMEOUT);
 404
 405         I2C_SET(sc,dev,1,0);
 406         I2C_SET(sc,dev,0,0);
 407
 408         /* send address */
 409         iicbb_sendbyte(dev, slave, timeout);
 410
 411         /* check for ack */
 412         error = iicbb_ack(dev, timeout);
 413         if (error == 0)
 414                 return (0);
 415
 416         iicbb_stop(dev);
 417         return (error);
 418 }
 419
 420 static int
 421 iicbb_stop(device_t dev)
 422 {
 423         struct iicbb_softc *sc = device_get_softc(dev);
 424
 425         I2C_SET(sc,dev,0,0);
 426         I2C_SET(sc,dev,1,0);
 427         I2C_SET(sc,dev,1,1);
 428         I2C_DEBUG(printf(">"));
 429         I2C_DEBUG(printf("\n"));
 430
 431         /* SCL must be high now. */
 432         if (!I2C_GETSCL(dev))
 433                 return (IIC_ETIMEOUT);
 434         return (0);
 435 }
 436
 437 static int
 438 iicbb_write(device_t dev, const char *buf, int len, int *sent, int timeout)
 439 {
 440         int bytes, error = 0;
 441
 442         bytes = 0;
 443         while (len) {
 444                 /* send byte */
 445                 iicbb_sendbyte(dev,(u_char)*buf++, timeout);
 446
 447                 /* check for ack */
 448                 error = iicbb_ack(dev, timeout);
 449                 if (error != 0)
 450                         break;
 451                 bytes++;
 452                 len--;
 453         }
 454
 455         *sent = bytes;
 456         return (error);
 457 }
 458
 459 static int
 460 iicbb_read(device_t dev, char * buf, int len, int *read, int last, int delay)
 461 {
 462         int bytes;
 463
 464         bytes = 0;
 465         while (len) {
 466                 /* XXX should insert delay here */
 467                 *buf++ = (char)iicbb_readbyte(dev, (len == 1) ? last : 0, delay);
 468
 469                 bytes ++;
 470                 len --;
 471         }
 472
 473         *read = bytes;
 474         return (0);
 475 }
 476
 477 static int
 478 iicbb_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs)
 479 {
 480         int error;
 481
 482         error = IICBB_PRE_XFER(device_get_parent(dev));
 483         if (error)
 484                 return (error);
 485
 486         error = iicbus_transfer_gen(dev, msgs, nmsgs);
 487
 488         IICBB_POST_XFER(device_get_parent(dev));
 489         return (error);
 490 }
 491
 492 static void
 493 iicbb_set_speed(struct iicbb_softc *sc, u_char speed)
 494 {
 495         u_int busfreq, period;
 496
 497         /*
 498          * NB: the resulting frequency will be a quarter (even less) of the
 499          * configured bus frequency.  This is for historic reasons.  The default
 500          * bus frequency is 100 kHz.  And the historic default udelay is 10
 501          * microseconds.  The cycle of sending a bit takes four udelay-s plus
 502          * SCL is kept low for extra two udelay-s.  The actual I/O toggling also
 503          * has an overhead.
 504          */
 505         busfreq = IICBUS_GET_FREQUENCY(sc->iicbus, speed);
 506         period = 1000000 / busfreq;     /* Hz -> uS */
 507         sc->udelay = MAX(period, 1);
 508 }
 509
 510 DRIVER_MODULE(iicbus, iicbb, iicbus_driver, iicbus_devclass, 0, 0);
 511
 512 MODULE_DEPEND(iicbb, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER);
 513 MODULE_VERSION(iicbb, IICBB_MODVER);