sys/arm/mv/twsi.c

   1 /*-
   2  * Copyright (C) 2008 MARVELL INTERNATIONAL LTD.
   3  * All rights reserved.
   4  *
   5  * Developed by Semihalf.
   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  * 3. Neither the name of MARVELL nor the names of contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * Driver for the TWSI (aka I2C, aka IIC) bus controller found on Marvell
  34  * SoCs. Supports master operation only, and works in polling mode.
  35  *
  36  * Calls to DELAY() are needed per Application Note AN-179 "TWSI Software
  37  * Guidelines for Discovery(TM), Horizon (TM) and Feroceon(TM) Devices".
  38  */
  39
  40 #include <sys/cdefs.h>
  41 __FBSDID("$FreeBSD$");
  42
  43 #include <sys/param.h>
  44 #include <sys/systm.h>
  45 #include <sys/bus.h>
  46 #include <sys/kernel.h>
  47 #include <sys/module.h>
  48 #include <sys/resource.h>
  49
  50 #include <machine/bus.h>
  51 #include <machine/resource.h>
  52
  53 #include <sys/rman.h>
  54
  55 #include <sys/lock.h>
  56 #include <sys/mutex.h>
  57
  58 #include <dev/iicbus/iiconf.h>
  59 #include <dev/iicbus/iicbus.h>
  60 #include "iicbus_if.h"
  61
  62 #define MV_TWSI_NAME            "twsi"
  63
  64 #define TWSI_SLAVE_ADDR         0x00
  65 #define TWSI_EXT_SLAVE_ADDR     0x10
  66 #define TWSI_DATA               0x04
  67
  68 #define TWSI_CONTROL            0x08
  69 #define TWSI_CONTROL_ACK        (1 << 2)
  70 #define TWSI_CONTROL_IFLG       (1 << 3)
  71 #define TWSI_CONTROL_STOP       (1 << 4)
  72 #define TWSI_CONTROL_START      (1 << 5)
  73 #define TWSI_CONTROL_TWSIEN     (1 << 6)
  74 #define TWSI_CONTROL_INTEN      (1 << 7)
  75
  76 #define TWSI_STATUS                     0x0c
  77 #define TWSI_STATUS_START               0x08
  78 #define TWSI_STATUS_RPTD_START          0x10
  79 #define TWSI_STATUS_ADDR_W_ACK          0x18
  80 #define TWSI_STATUS_DATA_WR_ACK         0x28
  81 #define TWSI_STATUS_ADDR_R_ACK          0x40
  82 #define TWSI_STATUS_DATA_RD_ACK         0x50
  83 #define TWSI_STATUS_DATA_RD_NOACK       0x58
  84
  85 #define TWSI_BAUD_RATE          0x0c
  86 #define TWSI_BAUD_RATE_94DOT3   0x53 /* N=3, M=10 */
  87 #define TWSI_BAUD_RATE_74DOT1   0x6b /* N=3, M=13 */
  88 #define TWSI_BAUD_RATE_51DOT8   0x4c /* N=4, M=9  */
  89 #define TWSI_BAUD_RATE_99DOT7   0x66 /* N=6, M=12 */
  90
  91 #define TWSI_SOFT_RESET         0x1c
  92
  93 #define TWSI_DEBUG
  94 #undef TWSI_DEBUG
  95
  96 #ifdef  TWSI_DEBUG
  97 #define debugf(fmt, args...) do { printf("%s(): ", __func__); printf(fmt,##args); } while (0)
  98 #else
  99 #define debugf(fmt, args...)
 100 #endif
 101
 102 struct mv_twsi_softc {
 103         device_t        dev;
 104         struct resource *res[1];        /* SYS_RES_MEMORY */
 105         struct mtx      mutex;
 106         device_t        iicbus;
 107 };
 108
 109 static int mv_twsi_probe(device_t);
 110 static int mv_twsi_attach(device_t);
 111 static int mv_twsi_detach(device_t);
 112
 113 static int mv_twsi_reset(device_t dev, u_char speed, u_char addr,
 114     u_char *oldaddr);
 115 static int mv_twsi_repeated_start(device_t dev, u_char slave, int timeout);
 116 static int mv_twsi_start(device_t dev, u_char slave, int timeout);
 117 static int mv_twsi_stop(device_t dev);
 118 static int mv_twsi_read(device_t dev, char *buf, int len, int *read, int last,
 119     int delay);
 120 static int mv_twsi_write(device_t dev, const char *buf, int len, int *sent,
 121     int timeout);
 122
 123 static struct resource_spec res_spec[] = {
 124         { SYS_RES_MEMORY, 0, RF_ACTIVE },
 125         { -1, 0 }
 126 };
 127
 128 static device_method_t mv_twsi_methods[] = {
 129         /* device interface */
 130         DEVMETHOD(device_probe,         mv_twsi_probe),
 131         DEVMETHOD(device_attach,        mv_twsi_attach),
 132         DEVMETHOD(device_detach,        mv_twsi_detach),
 133
 134         /* iicbus interface */
 135         DEVMETHOD(iicbus_callback, iicbus_null_callback),
 136         DEVMETHOD(iicbus_repeated_start, mv_twsi_repeated_start),
 137         DEVMETHOD(iicbus_start,         mv_twsi_start),
 138         DEVMETHOD(iicbus_stop,          mv_twsi_stop),
 139         DEVMETHOD(iicbus_write,         mv_twsi_write),
 140         DEVMETHOD(iicbus_read,          mv_twsi_read),
 141         DEVMETHOD(iicbus_reset,         mv_twsi_reset),
 142         DEVMETHOD(iicbus_transfer,      iicbus_transfer_gen),
 143         { 0, 0 }
 144 };
 145
 146 static devclass_t mv_twsi_devclass;
 147
 148 static driver_t mv_twsi_driver = {
 149         MV_TWSI_NAME,
 150         mv_twsi_methods,
 151         sizeof(struct mv_twsi_softc),
 152 };
 153
 154 DRIVER_MODULE(twsi, mbus, mv_twsi_driver, mv_twsi_devclass, 0, 0);
 155 DRIVER_MODULE(iicbus, twsi, iicbus_driver, iicbus_devclass, 0, 0);
 156 MODULE_DEPEND(twsi, iicbus, 1, 1, 1);
 157
 158 static __inline uint32_t
 159 TWSI_READ(struct mv_twsi_softc *sc, bus_size_t off)
 160 {
 161
 162         return (bus_read_4(sc->res[0], off));
 163 }
 164
 165 static __inline void
 166 TWSI_WRITE(struct mv_twsi_softc *sc, bus_size_t off, uint32_t val)
 167 {
 168
 169         bus_write_4(sc->res[0], off, val);
 170 }
 171
 172 static __inline void
 173 twsi_control_clear(struct mv_twsi_softc *sc, uint32_t mask)
 174 {
 175         uint32_t val;
 176
 177         val = TWSI_READ(sc, TWSI_CONTROL);
 178         val &= ~mask;
 179         TWSI_WRITE(sc, TWSI_CONTROL, val);
 180 }
 181
 182 static __inline void
 183 twsi_control_set(struct mv_twsi_softc *sc, uint32_t mask)
 184 {
 185         uint32_t val;
 186
 187         val = TWSI_READ(sc, TWSI_CONTROL);
 188         val |= mask;
 189         TWSI_WRITE(sc, TWSI_CONTROL, val);
 190 }
 191
 192 static __inline void
 193 twsi_clear_iflg(struct mv_twsi_softc *sc)
 194 {
 195
 196         DELAY(1000);
 197         twsi_control_clear(sc, TWSI_CONTROL_IFLG);
 198         DELAY(1000);
 199 }
 200
 201
 202 /*
 203  * timeout given in us
 204  * returns
 205  *   0 on sucessfull mask change
 206  *   non-zero on timeout
 207  */
 208 static int
 209 twsi_poll_ctrl(struct mv_twsi_softc *sc, int timeout, uint32_t mask)
 210 {
 211
 212         timeout /= 10;
 213         while (!(TWSI_READ(sc, TWSI_CONTROL) & mask)) {
 214                 DELAY(10);
 215                 if (--timeout < 0)
 216                         return (timeout);
 217         }
 218         return (0);
 219 }
 220
 221
 222 /*
 223  * 'timeout' is given in us. Note also that timeout handling is not exact --
 224  * twsi_locked_start() total wait can be more than 2 x timeout
 225  * (twsi_poll_ctrl() is called twice). 'mask' can be either TWSI_STATUS_START
 226  * or TWSI_STATUS_RPTD_START
 227  */
 228 static int
 229 twsi_locked_start(device_t dev, struct mv_twsi_softc *sc, int32_t mask,
 230     u_char slave, int timeout)
 231 {
 232         int read_access, iflg_set = 0;
 233         uint32_t status;
 234
 235         mtx_assert(&sc->mutex, MA_OWNED);
 236
 237         if (mask == TWSI_STATUS_RPTD_START)
 238                 /* read IFLG to know if it should be cleared later; from NBSD */
 239                 iflg_set = TWSI_READ(sc, TWSI_CONTROL) & TWSI_CONTROL_IFLG;
 240
 241         twsi_control_set(sc, TWSI_CONTROL_START);
 242
 243         if (mask == TWSI_STATUS_RPTD_START && iflg_set) {
 244                 debugf("IFLG set, clearing\n");
 245                 twsi_clear_iflg(sc);
 246         }
 247
 248         /*
 249          * Without this delay we timeout checking IFLG if the timeout is 0.
 250          * NBSD driver always waits here too.
 251          */
 252         DELAY(1000);
 253
 254         if (twsi_poll_ctrl(sc, timeout, TWSI_CONTROL_IFLG)) {
 255                 debugf("timeout sending %sSTART condition\n",
 256                     mask == TWSI_STATUS_START ? "" : "repeated ");
 257                 return (IIC_ETIMEOUT);
 258         }
 259
 260         status = TWSI_READ(sc, TWSI_STATUS);
 261         if (status != mask) {
 262                 debugf("wrong status (%02x) after sending %sSTART condition\n",
 263                     status, mask == TWSI_STATUS_START ? "" : "repeated ");
 264                 return (IIC_ESTATUS);
 265         }
 266
 267         TWSI_WRITE(sc, TWSI_DATA, slave);
 268         DELAY(1000);
 269         twsi_clear_iflg(sc);
 270
 271         if (twsi_poll_ctrl(sc, timeout, TWSI_CONTROL_IFLG)) {
 272                 debugf("timeout sending slave address\n");
 273                 return (IIC_ETIMEOUT);
 274         }
 275
 276         read_access = (slave & 0x1) ? 1 : 0;
 277         status = TWSI_READ(sc, TWSI_STATUS);
 278         if (status != (read_access ?
 279             TWSI_STATUS_ADDR_R_ACK : TWSI_STATUS_ADDR_W_ACK)) {
 280                 debugf("no ACK (status: %02x) after sending slave address\n",
 281                     status);
 282                 return (IIC_ENOACK);
 283         }
 284
 285         return (IIC_NOERR);
 286 }
 287
 288 static int
 289 mv_twsi_probe(device_t dev)
 290 {
 291
 292         device_set_desc(dev, "Marvell Integrated I2C Bus Controller");
 293         return (BUS_PROBE_DEFAULT);
 294 }
 295
 296 static int
 297 mv_twsi_attach(device_t dev)
 298 {
 299         struct mv_twsi_softc *sc;
 300
 301         sc = device_get_softc(dev);
 302         sc->dev = dev;
 303
 304         mtx_init(&sc->mutex, device_get_nameunit(dev), MV_TWSI_NAME, MTX_DEF);
 305
 306         /* Allocate IO resources */
 307         if (bus_alloc_resources(dev, res_spec, sc->res)) {
 308                 device_printf(dev, "could not allocate resources\n");
 309                 mv_twsi_detach(dev);
 310                 return (ENXIO);
 311         }
 312
 313         sc->iicbus = device_add_child(dev, "iicbus", -1);
 314         if (sc->iicbus == NULL) {
 315                 device_printf(dev, "could not add iicbus child\n");
 316                 mv_twsi_detach(dev);
 317                 return (ENXIO);
 318         }
 319
 320         bus_generic_attach(dev);
 321         return (0);
 322 }
 323
 324 static int
 325 mv_twsi_detach(device_t dev)
 326 {
 327         struct mv_twsi_softc *sc;
 328         int rv;
 329
 330         sc = device_get_softc(dev);
 331
 332         if ((rv = bus_generic_detach(dev)) != 0)
 333                 return (rv);
 334
 335         if (sc->iicbus != NULL)
 336                 if ((rv = device_delete_child(dev, sc->iicbus)) != 0)
 337                         return (rv);
 338
 339         bus_release_resources(dev, res_spec, sc->res);
 340
 341         mtx_destroy(&sc->mutex);
 342         return (0);
 343 }
 344
 345 /*
 346  * Only slave mode supported, disregard [old]addr
 347  */
 348 static int
 349 mv_twsi_reset(device_t dev, u_char speed, u_char addr, u_char *oldaddr)
 350 {
 351         struct mv_twsi_softc *sc;
 352         uint32_t baud_rate;
 353
 354         sc = device_get_softc(dev);
 355
 356         switch (speed) {
 357         case IIC_SLOW:
 358                 baud_rate = TWSI_BAUD_RATE_51DOT8;
 359                 break;
 360         case IIC_FAST:
 361                 baud_rate = TWSI_BAUD_RATE_51DOT8;
 362                 break;
 363         case IIC_UNKNOWN:
 364         case IIC_FASTEST:
 365         default:
 366                 baud_rate = TWSI_BAUD_RATE_99DOT7;
 367                 break;
 368         }
 369
 370         mtx_lock(&sc->mutex);
 371         TWSI_WRITE(sc, TWSI_SOFT_RESET, 0x0);
 372         DELAY(2000);
 373         TWSI_WRITE(sc, TWSI_BAUD_RATE, baud_rate);
 374         TWSI_WRITE(sc, TWSI_CONTROL, TWSI_CONTROL_TWSIEN | TWSI_CONTROL_ACK);
 375         DELAY(1000);
 376         mtx_unlock(&sc->mutex);
 377
 378         return (0);
 379 }
 380
 381 /*
 382  * timeout is given in us
 383  */
 384 static int
 385 mv_twsi_repeated_start(device_t dev, u_char slave, int timeout)
 386 {
 387         struct mv_twsi_softc *sc;
 388         int rv;
 389
 390         sc = device_get_softc(dev);
 391
 392         mtx_lock(&sc->mutex);
 393         rv = twsi_locked_start(dev, sc, TWSI_STATUS_RPTD_START, slave,
 394             timeout);
 395         mtx_unlock(&sc->mutex);
 396
 397         if (rv) {
 398                 mv_twsi_stop(dev);
 399                 return (rv);
 400         } else
 401                 return (IIC_NOERR);
 402 }
 403
 404 /*
 405  * timeout is given in us
 406  */
 407 static int
 408 mv_twsi_start(device_t dev, u_char slave, int timeout)
 409 {
 410         struct mv_twsi_softc *sc;
 411         int rv;
 412
 413         sc = device_get_softc(dev);
 414
 415         mtx_lock(&sc->mutex);
 416         rv = twsi_locked_start(dev, sc, TWSI_STATUS_START, slave, timeout);
 417         mtx_unlock(&sc->mutex);
 418
 419         if (rv) {
 420                 mv_twsi_stop(dev);
 421                 return (rv);
 422         } else
 423                 return (IIC_NOERR);
 424 }
 425
 426 static int
 427 mv_twsi_stop(device_t dev)
 428 {
 429         struct mv_twsi_softc *sc;
 430
 431         sc = device_get_softc(dev);
 432
 433         mtx_lock(&sc->mutex);
 434         twsi_control_set(sc, TWSI_CONTROL_STOP);
 435         DELAY(1000);
 436         twsi_clear_iflg(sc);
 437         mtx_unlock(&sc->mutex);
 438
 439         return (IIC_NOERR);
 440 }
 441
 442 static int
 443 mv_twsi_read(device_t dev, char *buf, int len, int *read, int last, int delay)
 444 {
 445         struct mv_twsi_softc *sc;
 446         uint32_t status;
 447         int last_byte, rv;
 448
 449         sc = device_get_softc(dev);
 450
 451         mtx_lock(&sc->mutex);
 452         *read = 0;
 453         while (*read < len) {
 454                 /*
 455                  * Check if we are reading last byte of the last buffer,
 456                  * do not send ACK then, per I2C specs
 457                  */
 458                 last_byte = ((*read == len - 1) && last) ? 1 : 0;
 459                 if (last_byte)
 460                         twsi_control_clear(sc, TWSI_CONTROL_ACK);
 461                 else
 462                         twsi_control_set(sc, TWSI_CONTROL_ACK);
 463
 464                 DELAY (1000);
 465                 twsi_clear_iflg(sc);
 466
 467                 if (twsi_poll_ctrl(sc, delay, TWSI_CONTROL_IFLG)) {
 468                         debugf("timeout reading data\n");
 469                         rv = IIC_ETIMEOUT;
 470                         goto out;
 471                 }
 472
 473                 status = TWSI_READ(sc, TWSI_STATUS);
 474                 if (status != (last_byte ?
 475                     TWSI_STATUS_DATA_RD_NOACK : TWSI_STATUS_DATA_RD_ACK)) {
 476                         debugf("wrong status (%02x) while reading\n", status);
 477                         rv = IIC_ESTATUS;
 478                         goto out;
 479                 }
 480
 481                 *buf++ = TWSI_READ(sc, TWSI_DATA);
 482                 (*read)++;
 483         }
 484         rv = IIC_NOERR;
 485 out:
 486         mtx_unlock(&sc->mutex);
 487         return (rv);
 488 }
 489
 490 static int
 491 mv_twsi_write(device_t dev, const char *buf, int len, int *sent, int timeout)
 492 {
 493         struct mv_twsi_softc *sc;
 494         uint32_t status;
 495         int rv;
 496
 497         sc = device_get_softc(dev);
 498
 499         mtx_lock(&sc->mutex);
 500         *sent = 0;
 501         while (*sent < len) {
 502                 TWSI_WRITE(sc, TWSI_DATA, *buf++);
 503
 504                 twsi_clear_iflg(sc);
 505                 if (twsi_poll_ctrl(sc, timeout, TWSI_CONTROL_IFLG)) {
 506                         debugf("timeout writing data\n");
 507                         rv = IIC_ETIMEOUT;
 508                         goto out;
 509                 }
 510
 511                 status = TWSI_READ(sc, TWSI_STATUS);
 512                 if (status != TWSI_STATUS_DATA_WR_ACK) {
 513                         debugf("wrong status (%02x) while writing\n", status);
 514                         rv = IIC_ESTATUS;
 515                         goto out;
 516                 }
 517                 (*sent)++;
 518         }
 519         rv = IIC_NOERR;
 520 out:
 521         mtx_unlock(&sc->mutex);
 522         return (rv);
 523 }