sys/dev/pcf/pcf.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1998 Nicolas Souchu, Marc Bouget
   5  * Copyright (c) 2004 Joerg Wunsch
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <sys/param.h>
  34 #include <sys/bus.h>
  35 #include <sys/lock.h>
  36 #include <sys/kernel.h>
  37 #include <sys/module.h>
  38 #include <sys/mutex.h>
  39 #include <sys/systm.h>
  40
  41 #include <machine/bus.h>
  42 #include <machine/resource.h>
  43
  44 #include <sys/rman.h>
  45
  46 #include <dev/iicbus/iicbus.h>
  47 #include <dev/iicbus/iiconf.h>
  48 #include <dev/pcf/pcfvar.h>
  49 #include "iicbus_if.h"
  50
  51 /* Not so official debugging option. */
  52 /* #define PCFDEBUG */
  53
  54 static int pcf_wait_byte(struct pcf_softc *pcf);
  55 static int pcf_noack(struct pcf_softc *pcf, int timeout);
  56 static void pcf_stop_locked(struct pcf_softc *pcf);
  57
  58 /*
  59  * Polling mode for master operations wait for a new
  60  * byte incoming or outgoing
  61  */
  62 static int
  63 pcf_wait_byte(struct pcf_softc *sc)
  64 {
  65         int counter = TIMEOUT;
  66
  67         PCF_ASSERT_LOCKED(sc);
  68         while (counter--) {
  69
  70                 if ((pcf_get_S1(sc) & PIN) == 0)
  71                         return (0);
  72         }
  73
  74 #ifdef PCFDEBUG
  75         printf("pcf: timeout!\n");
  76 #endif
  77
  78         return (IIC_ETIMEOUT);
  79 }
  80
  81 static void
  82 pcf_stop_locked(struct pcf_softc *sc)
  83 {
  84
  85         PCF_ASSERT_LOCKED(sc);
  86 #ifdef PCFDEBUG
  87         device_printf(dev, " >> stop\n");
  88 #endif
  89         /*
  90          * Send STOP condition iff the START condition was previously sent.
  91          * STOP is sent only once even if an iicbus_stop() is called after
  92          * an iicbus_read()... see pcf_read(): the PCF needs to send the stop
  93          * before the last char is read.
  94          */
  95         if (sc->pcf_started) {
  96                 /* set stop condition and enable IT */
  97                 pcf_set_S1(sc, PIN|ESO|ENI|STO|ACK);
  98
  99                 sc->pcf_started = 0;
 100         }
 101 }
 102
 103 static int
 104 pcf_noack(struct pcf_softc *sc, int timeout)
 105 {
 106         int noack;
 107         int k = timeout/10;
 108
 109         PCF_ASSERT_LOCKED(sc);
 110         do {
 111                 noack = pcf_get_S1(sc) & LRB;
 112                 if (!noack)
 113                         break;
 114                 DELAY(10);                              /* XXX wait 10 us */
 115         } while (k--);
 116
 117         return (noack);
 118 }
 119
 120 int
 121 pcf_repeated_start(device_t dev, u_char slave, int timeout)
 122 {
 123         struct pcf_softc *sc = DEVTOSOFTC(dev);
 124         int error = 0;
 125
 126         PCF_LOCK(sc);
 127 #ifdef PCFDEBUG
 128         device_printf(dev, " >> repeated start for slave %#x\n",
 129                       (unsigned)slave);
 130 #endif
 131         /* repeated start */
 132         pcf_set_S1(sc, ESO|STA|STO|ACK);
 133
 134         /* set slave address to PCF. Last bit (LSB) must be set correctly
 135          * according to transfer direction */
 136         pcf_set_S0(sc, slave);
 137
 138         /* wait for address sent, polling */
 139         if ((error = pcf_wait_byte(sc)))
 140                 goto error;
 141
 142         /* check for ack */
 143         if (pcf_noack(sc, timeout)) {
 144                 error = IIC_ENOACK;
 145 #ifdef PCFDEBUG
 146                 printf("pcf: no ack on repeated_start!\n");
 147 #endif
 148                 goto error;
 149         }
 150
 151         PCF_UNLOCK(sc);
 152         return (0);
 153
 154 error:
 155         pcf_stop_locked(sc);
 156         PCF_UNLOCK(sc);
 157         return (error);
 158 }
 159
 160 int
 161 pcf_start(device_t dev, u_char slave, int timeout)
 162 {
 163         struct pcf_softc *sc = DEVTOSOFTC(dev);
 164         int error = 0;
 165
 166         PCF_LOCK(sc);
 167 #ifdef PCFDEBUG
 168         device_printf(dev, " >> start for slave %#x\n", (unsigned)slave);
 169 #endif
 170         if ((pcf_get_S1(sc) & nBB) == 0) {
 171 #ifdef PCFDEBUG
 172                 printf("pcf: busy!\n");
 173 #endif
 174                 PCF_UNLOCK(sc);
 175                 return (IIC_EBUSERR);
 176         }
 177
 178         /* set slave address to PCF. Last bit (LSB) must be set correctly
 179          * according to transfer direction */
 180         pcf_set_S0(sc, slave);
 181
 182         /* START only */
 183         pcf_set_S1(sc, PIN|ESO|STA|ACK);
 184
 185         sc->pcf_started = 1;
 186
 187         /* wait for address sent, polling */
 188         if ((error = pcf_wait_byte(sc)))
 189                 goto error;
 190
 191         /* check for ACK */
 192         if (pcf_noack(sc, timeout)) {
 193                 error = IIC_ENOACK;
 194 #ifdef PCFDEBUG
 195                 printf("pcf: no ack on start!\n");
 196 #endif
 197                 goto error;
 198         }
 199
 200         PCF_UNLOCK(sc);
 201         return (0);
 202
 203 error:
 204         pcf_stop_locked(sc);
 205         PCF_UNLOCK(sc);
 206         return (error);
 207 }
 208
 209 int
 210 pcf_stop(device_t dev)
 211 {
 212         struct pcf_softc *sc = DEVTOSOFTC(dev);
 213
 214 #ifdef PCFDEBUG
 215         device_printf(dev, " >> stop\n");
 216 #endif
 217         PCF_LOCK(sc);
 218         pcf_stop_locked(sc);
 219         PCF_UNLOCK(sc);
 220
 221         return (0);
 222 }
 223
 224 void
 225 pcf_intr(void *arg)
 226 {
 227         struct pcf_softc *sc = arg;
 228         char data, status, addr;
 229         char error = 0;
 230
 231         PCF_LOCK(sc);
 232         status = pcf_get_S1(sc);
 233
 234         if (status & PIN) {
 235                 printf("pcf: spurious interrupt, status=0x%x\n",
 236                        status & 0xff);
 237
 238                 goto error;
 239         }
 240
 241         if (status & LAB)
 242                 printf("pcf: bus arbitration lost!\n");
 243
 244         if (status & BER) {
 245                 error = IIC_EBUSERR;
 246                 iicbus_intr(sc->iicbus, INTR_ERROR, &error);
 247
 248                 goto error;
 249         }
 250
 251         do {
 252                 status = pcf_get_S1(sc);
 253
 254                 switch(sc->pcf_slave_mode) {
 255
 256                 case SLAVE_TRANSMITTER:
 257                         if (status & LRB) {
 258                                 /* ack interrupt line */
 259                                 dummy_write(sc);
 260
 261                                 /* no ack, don't send anymore */
 262                                 sc->pcf_slave_mode = SLAVE_RECEIVER;
 263
 264                                 iicbus_intr(sc->iicbus, INTR_NOACK, NULL);
 265                                 break;
 266                         }
 267
 268                         /* get data from upper code */
 269                         iicbus_intr(sc->iicbus, INTR_TRANSMIT, &data);
 270
 271                         pcf_set_S0(sc, data);
 272                         break;
 273
 274                 case SLAVE_RECEIVER:
 275                         if (status & AAS) {
 276                                 addr = pcf_get_S0(sc);
 277
 278                                 if (status & AD0)
 279                                         iicbus_intr(sc->iicbus, INTR_GENERAL, &addr);
 280                                 else
 281                                         iicbus_intr(sc->iicbus, INTR_START, &addr);
 282
 283                                 if (addr & LSB) {
 284                                         sc->pcf_slave_mode = SLAVE_TRANSMITTER;
 285
 286                                         /* get the first char from upper code */
 287                                         iicbus_intr(sc->iicbus, INTR_TRANSMIT, &data);
 288
 289                                         /* send first data byte */
 290                                         pcf_set_S0(sc, data);
 291                                 }
 292
 293                                 break;
 294                         }
 295
 296                         /* stop condition received? */
 297                         if (status & STS) {
 298                                 /* ack interrupt line */
 299                                 dummy_read(sc);
 300
 301                                 /* emulate intr stop condition */
 302                                 iicbus_intr(sc->iicbus, INTR_STOP, NULL);
 303
 304                         } else {
 305                                 /* get data, ack interrupt line */
 306                                 data = pcf_get_S0(sc);
 307
 308                                 /* deliver the character */
 309                                 iicbus_intr(sc->iicbus, INTR_RECEIVE, &data);
 310                         }
 311                         break;
 312
 313                     default:
 314                         panic("%s: unknown slave mode (%d)!", __func__,
 315                                 sc->pcf_slave_mode);
 316                     }
 317
 318         } while ((pcf_get_S1(sc) & PIN) == 0);
 319         PCF_UNLOCK(sc);
 320
 321         return;
 322
 323 error:
 324         /* unknown event on bus...reset PCF */
 325         pcf_set_S1(sc, PIN|ESO|ENI|ACK);
 326
 327         sc->pcf_slave_mode = SLAVE_RECEIVER;
 328         PCF_UNLOCK(sc);
 329
 330         return;
 331 }
 332
 333 int
 334 pcf_rst_card(device_t dev, u_char speed, u_char addr, u_char *oldaddr)
 335 {
 336         struct pcf_softc *sc = DEVTOSOFTC(dev);
 337
 338         PCF_LOCK(sc);
 339         if (oldaddr)
 340                 *oldaddr = sc->pcf_addr;
 341
 342         /* retrieve own address from bus level */
 343         if (!addr)
 344                 sc->pcf_addr = PCF_DEFAULT_ADDR;
 345         else
 346                 sc->pcf_addr = addr;
 347
 348         pcf_set_S1(sc, PIN);                            /* initialize S1 */
 349
 350         /* own address S'O<>0 */
 351         pcf_set_S0(sc, sc->pcf_addr >> 1);
 352
 353         /* select clock register */
 354         pcf_set_S1(sc, PIN|ES1);
 355
 356         /* select bus speed : 18=90kb, 19=45kb, 1A=11kb, 1B=1.5kb */
 357         switch (speed) {
 358         case IIC_SLOW:
 359                 pcf_set_S0(sc,  0x1b); /* XXX Sun uses 0x1f */
 360                 break;
 361
 362         case IIC_FAST:
 363                 pcf_set_S0(sc,  0x19); /* XXX Sun: 0x1d */
 364                 break;
 365
 366         case IIC_UNKNOWN:
 367         case IIC_FASTEST:
 368         default:
 369                 pcf_set_S0(sc,  0x18); /* XXX Sun: 0x1c */
 370                 break;
 371         }
 372
 373         /* set bus on, ack=yes, INT=yes */
 374         pcf_set_S1(sc, PIN|ESO|ENI|ACK);
 375
 376         sc->pcf_slave_mode = SLAVE_RECEIVER;
 377         PCF_UNLOCK(sc);
 378
 379         return (0);
 380 }
 381
 382 int
 383 pcf_write(device_t dev, const char *buf, int len, int *sent, int timeout /* us */)
 384 {
 385         struct pcf_softc *sc = DEVTOSOFTC(dev);
 386         int bytes, error = 0;
 387
 388 #ifdef PCFDEBUG
 389         device_printf(dev, " >> writing %d bytes: %#x%s\n", len,
 390                       (unsigned)buf[0], len > 1? "...": "");
 391 #endif
 392
 393         bytes = 0;
 394         PCF_LOCK(sc);
 395         while (len) {
 396
 397                 pcf_set_S0(sc, *buf++);
 398
 399                 /* wait for the byte to be send */
 400                 if ((error = pcf_wait_byte(sc)))
 401                         goto error;
 402
 403                 /* check if ack received */
 404                 if (pcf_noack(sc, timeout)) {
 405                         error = IIC_ENOACK;
 406                         goto error;
 407                 }
 408
 409                 len --;
 410                 bytes ++;
 411         }
 412
 413 error:
 414         *sent = bytes;
 415         PCF_UNLOCK(sc);
 416
 417 #ifdef PCFDEBUG
 418         device_printf(dev, " >> %d bytes written (%d)\n", bytes, error);
 419 #endif
 420
 421         return (error);
 422 }
 423
 424 int
 425 pcf_read(device_t dev, char *buf, int len, int *read, int last,
 426          int delay /* us */)
 427 {
 428         struct pcf_softc *sc = DEVTOSOFTC(dev);
 429         int bytes, error = 0;
 430 #ifdef PCFDEBUG
 431         char *obuf = buf;
 432
 433         device_printf(dev, " << reading %d bytes\n", len);
 434 #endif
 435
 436         PCF_LOCK(sc);
 437         /* trig the bus to get the first data byte in S0 */
 438         if (len) {
 439                 if (len == 1 && last)
 440                         /* just one byte to read */
 441                         pcf_set_S1(sc, ESO);            /* no ack */
 442
 443                 dummy_read(sc);
 444         }
 445
 446         bytes = 0;
 447         while (len) {
 448
 449                 /* XXX delay needed here */
 450
 451                 /* wait for trigged byte */
 452                 if ((error = pcf_wait_byte(sc))) {
 453                         pcf_stop_locked(sc);
 454                         goto error;
 455                 }
 456
 457                 if (len == 1 && last)
 458                         /* ok, last data byte already in S0, no I2C activity
 459                          * on next pcf_get_S0() */
 460                         pcf_stop_locked(sc);
 461
 462                 else if (len == 2 && last)
 463                         /* next trigged byte with no ack */
 464                         pcf_set_S1(sc, ESO);
 465
 466                 /* receive byte, trig next byte */
 467                 *buf++ = pcf_get_S0(sc);
 468
 469                 len --;
 470                 bytes ++;
 471         }
 472
 473 error:
 474         *read = bytes;
 475         PCF_UNLOCK(sc);
 476
 477 #ifdef PCFDEBUG
 478         device_printf(dev, " << %d bytes read (%d): %#x%s\n", bytes, error,
 479                       (unsigned)obuf[0], bytes > 1? "...": "");
 480 #endif
 481
 482         return (error);
 483 }
 484
 485 DRIVER_MODULE(iicbus, pcf, iicbus_driver, iicbus_devclass, 0, 0);
 486 MODULE_DEPEND(pcf, iicbus, PCF_MINVER, PCF_PREFVER, PCF_MAXVER);
 487 MODULE_VERSION(pcf, PCF_MODVER);