sys/bus/iicbus/i386/pcf.c

   1 /*-
   2  * Copyright (c) 1998 Nicolas Souchu, Marc Bouget
   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/i386/isa/pcf.c,v 1.14 2000/01/14 00:18:05 nsouch Exp $
  27  *
  28  */
  29 #include <sys/param.h>
  30 #include <sys/systm.h>
  31 #include <sys/kernel.h>
  32 #include <sys/module.h>
  33 #include <sys/bus.h>
  34 #include <sys/malloc.h>
  35
  36 #include <machine/clock.h>
  37 #include <machine/bus.h>
  38 #include <machine/resource.h>
  39 #include <sys/rman.h>
  40
  41 #include <isa/isareg.h>
  42 #include <isa/isavar.h>
  43
  44 #include <i386/isa/isa_device.h>
  45
  46 #include <dev/iicbus/iiconf.h>
  47 #include "iicbus_if.h"
  48
  49 #define IO_PCFSIZE      2
  50
  51 #define TIMEOUT 9999                                    /* XXX */
  52
  53 /* Status bits of S1 register (read only) */
  54 #define nBB     0x01            /* busy when low set/reset by STOP/START*/
  55 #define LAB     0x02            /* lost arbitration bit in multi-master mode */
  56 #define AAS     0x04            /* addressed as slave */
  57 #define LRB     0x08            /* last received byte when not AAS */
  58 #define AD0     0x08            /* general call received when AAS */
  59 #define BER     0x10            /* bus error, misplaced START or STOP */
  60 #define STS     0x20            /* STOP detected in slave receiver mode */
  61 #define PIN     0x80            /* pending interrupt not (r/w) */
  62
  63 /* Control bits of S1 register (write only) */
  64 #define ACK     0x01
  65 #define STO     0x02
  66 #define STA     0x04
  67 #define ENI     0x08
  68 #define ES2     0x10
  69 #define ES1     0x20
  70 #define ES0     0x40
  71
  72 #define BUFSIZE 2048
  73
  74 #define SLAVE_TRANSMITTER       0x1
  75 #define SLAVE_RECEIVER          0x2
  76
  77 #define PCF_DEFAULT_ADDR        0xaa
  78
  79 struct pcf_softc {
  80
  81         int pcf_base;                   /* isa port */
  82         int pcf_flags;
  83         u_char pcf_addr;                /* interface I2C address */
  84
  85         int pcf_slave_mode;             /* receiver or transmitter */
  86         int pcf_started;                /* 1 if start condition sent */
  87
  88         device_t iicbus;                /* the corresponding iicbus */
  89
  90         int rid_irq, rid_ioport;
  91         struct resource *res_irq, *res_ioport;
  92         void *intr_cookie;
  93 };
  94
  95 static int pcf_probe(device_t);
  96 static int pcf_attach(device_t);
  97 static void pcfintr(void *arg);
  98
  99 static int pcf_print_child(device_t, device_t);
 100
 101 static int pcf_repeated_start(device_t, u_char, int);
 102 static int pcf_start(device_t, u_char, int);
 103 static int pcf_stop(device_t);
 104 static int pcf_write(device_t, char *, int, int *, int);
 105 static int pcf_read(device_t, char *, int, int *, int, int);
 106 static int pcf_rst_card(device_t, u_char, u_char, u_char *);
 107
 108 static device_method_t pcf_methods[] = {
 109         /* device interface */
 110         DEVMETHOD(device_probe,         pcf_probe),
 111         DEVMETHOD(device_attach,        pcf_attach),
 112
 113         /* bus interface */
 114         DEVMETHOD(bus_print_child,      pcf_print_child),
 115
 116         /* iicbus interface */
 117         DEVMETHOD(iicbus_callback,      iicbus_null_callback),
 118         DEVMETHOD(iicbus_repeated_start, pcf_repeated_start),
 119         DEVMETHOD(iicbus_start,         pcf_start),
 120         DEVMETHOD(iicbus_stop,          pcf_stop),
 121         DEVMETHOD(iicbus_write,         pcf_write),
 122         DEVMETHOD(iicbus_read,          pcf_read),
 123         DEVMETHOD(iicbus_reset,         pcf_rst_card),
 124
 125         { 0, 0 }
 126 };
 127
 128 static driver_t pcf_driver = {
 129         "pcf",
 130         pcf_methods,
 131         sizeof(struct pcf_softc),
 132 };
 133
 134 static devclass_t pcf_devclass;
 135
 136 #define DEVTOSOFTC(dev) ((struct pcf_softc *)device_get_softc(dev))
 137
 138 static int
 139 pcf_probe(device_t pcfdev)
 140 {
 141         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
 142         device_t parent = device_get_parent(pcfdev);
 143
 144         device_set_desc(pcfdev, "PCF8584 I2C bus controller");
 145
 146         pcf = DEVTOSOFTC(pcfdev);
 147         bzero(pcf, sizeof(struct pcf_softc));
 148
 149         pcf->rid_irq = pcf->rid_ioport = 0;
 150         pcf->res_irq = pcf->res_ioport = 0;
 151
 152         /* IO port is mandatory */
 153         pcf->res_ioport = bus_alloc_resource(pcfdev, SYS_RES_IOPORT,
 154                                              &pcf->rid_ioport, 0ul, ~0ul,
 155                                              IO_PCFSIZE, RF_ACTIVE);
 156         if (pcf->res_ioport == 0) {
 157                 device_printf(pcfdev, "cannot reserve I/O port range\n");
 158                 goto error;
 159         }
 160         BUS_READ_IVAR(parent, pcfdev, ISA_IVAR_PORT, &pcf->pcf_base);
 161
 162         pcf->pcf_flags = device_get_flags(pcfdev);
 163
 164         if (!(pcf->pcf_flags & IIC_POLLED)) {
 165                 pcf->res_irq = bus_alloc_resource(pcfdev, SYS_RES_IRQ, &pcf->rid_irq,
 166                                                   0ul, ~0ul, 1, RF_ACTIVE);
 167                 if (pcf->res_irq == 0) {
 168                         device_printf(pcfdev, "can't reserve irq, polled mode.\n");
 169                         pcf->pcf_flags |= IIC_POLLED;
 170                 }
 171         }
 172
 173         /* reset the chip */
 174         pcf_rst_card(pcfdev, IIC_FASTEST, PCF_DEFAULT_ADDR, NULL);
 175
 176         return (0);
 177 error:
 178         if (pcf->res_ioport != 0) {
 179                 bus_deactivate_resource(pcfdev, SYS_RES_IOPORT, pcf->rid_ioport,
 180                                         pcf->res_ioport);
 181                 bus_release_resource(pcfdev, SYS_RES_IOPORT, pcf->rid_ioport,
 182                                      pcf->res_ioport);
 183         }
 184         return (ENXIO);
 185 }
 186
 187 static int
 188 pcf_attach(device_t pcfdev)
 189 {
 190         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
 191         device_t parent = device_get_parent(pcfdev);
 192         int error = 0;
 193
 194         if (pcf->res_irq) {
 195                 /* default to the tty mask for registration */  /* XXX */
 196                 error = BUS_SETUP_INTR(parent, pcfdev, pcf->res_irq, INTR_TYPE_NET,
 197                                             pcfintr, pcfdev, &pcf->intr_cookie);
 198                 if (error)
 199                         return (error);
 200         }
 201
 202         pcf->iicbus = iicbus_alloc_bus(pcfdev);
 203
 204         /* probe and attach the iicbus */
 205         device_probe_and_attach(pcf->iicbus);
 206
 207         return (0);
 208 }
 209
 210 static int
 211 pcf_print_child(device_t bus, device_t dev)
 212 {
 213         struct pcf_softc *pcf = (struct pcf_softc *)device_get_softc(bus);
 214         int retval = 0;
 215
 216         retval += bus_print_child_header(bus, dev);
 217         retval += printf(" on %s addr 0x%x\n", device_get_nameunit(bus),
 218                          (int)pcf->pcf_addr);
 219
 220         return (retval);
 221 }
 222
 223 /*
 224  * PCF8584 datasheet : when operate at 8 MHz or more, a minimun time of
 225  * 6 clocks cycles must be left between two consecutives access
 226  */
 227 #define pcf_nops()      DELAY(10)
 228
 229 #define dummy_read(pcf)         PCF_GET_S0(pcf)
 230 #define dummy_write(pcf)        PCF_SET_S0(pcf, 0)
 231
 232 /*
 233  * Specific register access to PCF8584
 234  */
 235 static void PCF_SET_S0(struct pcf_softc *pcf, int data)
 236 {
 237         outb(pcf->pcf_base, data);
 238         pcf_nops();
 239 }
 240
 241 static void PCF_SET_S1(struct pcf_softc *pcf, int data)
 242 {
 243         outb(pcf->pcf_base+1, data);
 244         pcf_nops();
 245 }
 246
 247 static char PCF_GET_S0(struct pcf_softc *pcf)
 248 {
 249         char data;
 250
 251         data = inb(pcf->pcf_base);
 252         pcf_nops();
 253
 254         return (data);
 255 }
 256
 257 static char PCF_GET_S1(struct pcf_softc *pcf)
 258 {
 259         char data;
 260
 261         data = inb(pcf->pcf_base+1);
 262         pcf_nops();
 263
 264         return (data);
 265 }
 266
 267 /*
 268  * Polling mode for master operations wait for a new
 269  * byte incomming or outgoing
 270  */
 271 static int pcf_wait_byte(struct pcf_softc *pcf)
 272 {
 273         int counter = TIMEOUT;
 274
 275         while (counter--) {
 276
 277                 if ((PCF_GET_S1(pcf) & PIN) == 0)
 278                         return (0);
 279         }
 280
 281         return (IIC_ETIMEOUT);
 282 }
 283
 284 static int pcf_stop(device_t pcfdev)
 285 {
 286         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
 287
 288         /*
 289          * Send STOP condition iff the START condition was previously sent.
 290          * STOP is sent only once even if a iicbus_stop() is called after
 291          * an iicbus_read()... see pcf_read(): the pcf needs to send the stop
 292          * before the last char is read.
 293          */
 294         if (pcf->pcf_started) {
 295                 /* set stop condition and enable IT */
 296                 PCF_SET_S1(pcf, PIN|ES0|ENI|STO|ACK);
 297
 298                 pcf->pcf_started = 0;
 299         }
 300
 301         return (0);
 302 }
 303
 304
 305 static int pcf_noack(struct pcf_softc *pcf, int timeout)
 306 {
 307         int noack;
 308         int k = timeout/10;
 309
 310         do {
 311                 noack = PCF_GET_S1(pcf) & LRB;
 312                 if (!noack)
 313                         break;
 314                 DELAY(10);                              /* XXX wait 10 us */
 315         } while (k--);
 316
 317         return (noack);
 318 }
 319
 320 static int pcf_repeated_start(device_t pcfdev, u_char slave, int timeout)
 321 {
 322         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
 323         int error = 0;
 324
 325         /* repeated start */
 326         PCF_SET_S1(pcf, ES0|STA|STO|ACK);
 327
 328         /* set slave address to PCF. Last bit (LSB) must be set correctly
 329          * according to transfer direction */
 330         PCF_SET_S0(pcf, slave);
 331
 332         /* wait for address sent, polling */
 333         if ((error = pcf_wait_byte(pcf)))
 334                 goto error;
 335
 336         /* check for ack */
 337         if (pcf_noack(pcf, timeout)) {
 338                 error = IIC_ENOACK;
 339                 goto error;
 340         }
 341
 342         return (0);
 343
 344 error:
 345         pcf_stop(pcfdev);
 346         return (error);
 347 }
 348
 349 static int pcf_start(device_t pcfdev, u_char slave, int timeout)
 350 {
 351         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
 352         int error = 0;
 353
 354         if ((PCF_GET_S1(pcf) & nBB) == 0)
 355                 return (IIC_EBUSBSY);
 356
 357         /* set slave address to PCF. Last bit (LSB) must be set correctly
 358          * according to transfer direction */
 359         PCF_SET_S0(pcf, slave);
 360
 361         /* START only */
 362         PCF_SET_S1(pcf, PIN|ES0|STA|ACK);
 363
 364         pcf->pcf_started = 1;
 365
 366         /* wait for address sent, polling */
 367         if ((error = pcf_wait_byte(pcf)))
 368                 goto error;
 369
 370         /* check for ACK */
 371         if (pcf_noack(pcf, timeout)) {
 372                 error = IIC_ENOACK;
 373                 goto error;
 374         }
 375
 376         return (0);
 377
 378 error:
 379         pcf_stop(pcfdev);
 380         return (error);
 381 }
 382
 383 static void
 384 pcfintr(void *arg)
 385 {
 386         device_t pcfdev = (device_t)arg;
 387         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
 388
 389         char data, status, addr;
 390         char error = 0;
 391
 392         status = PCF_GET_S1(pcf);
 393
 394         if (status & PIN) {
 395                 device_printf(pcfdev, "spurious interrupt, status=0x%x\n", status & 0xff);
 396
 397                 goto error;
 398         }
 399
 400         if (status & LAB)
 401                 device_printf(pcfdev, "bus arbitration lost!\n");
 402
 403         if (status & BER) {
 404                 error = IIC_EBUSERR;
 405                 iicbus_intr(pcf->iicbus, INTR_ERROR, &error);
 406
 407                 goto error;
 408         }
 409
 410         do {
 411                 status = PCF_GET_S1(pcf);
 412
 413                 switch(pcf->pcf_slave_mode) {
 414
 415                 case SLAVE_TRANSMITTER:
 416                         if (status & LRB) {
 417                                 /* ack interrupt line */
 418                                 dummy_write(pcf);
 419
 420                                 /* no ack, don't send anymore */
 421                                 pcf->pcf_slave_mode = SLAVE_RECEIVER;
 422
 423                                 iicbus_intr(pcf->iicbus, INTR_NOACK, NULL);
 424                                 break;
 425                         }
 426
 427                         /* get data from upper code */
 428                         iicbus_intr(pcf->iicbus, INTR_TRANSMIT, &data);
 429
 430                         PCF_SET_S0(pcf, data);
 431                         break;
 432
 433                 case SLAVE_RECEIVER:
 434                         if (status & AAS) {
 435                                 addr = PCF_GET_S0(pcf);
 436
 437                                 if (status & AD0)
 438                                         iicbus_intr(pcf->iicbus, INTR_GENERAL, &addr);
 439                                 else
 440                                         iicbus_intr(pcf->iicbus, INTR_START, &addr);
 441
 442                                 if (addr & LSB) {
 443                                         pcf->pcf_slave_mode = SLAVE_TRANSMITTER;
 444
 445                                         /* get the first char from upper code */
 446                                         iicbus_intr(pcf->iicbus, INTR_TRANSMIT, &data);
 447
 448                                         /* send first data byte */
 449                                         PCF_SET_S0(pcf, data);
 450                                 }
 451
 452                                 break;
 453                         }
 454
 455                         /* stop condition received? */
 456                         if (status & STS) {
 457                                 /* ack interrupt line */
 458                                 dummy_read(pcf);
 459
 460                                 /* emulate intr stop condition */
 461                                 iicbus_intr(pcf->iicbus, INTR_STOP, NULL);
 462
 463                         } else {
 464                                 /* get data, ack interrupt line */
 465                                 data = PCF_GET_S0(pcf);
 466
 467                                 /* deliver the character */
 468                                 iicbus_intr(pcf->iicbus, INTR_RECEIVE, &data);
 469                         }
 470                         break;
 471
 472                     default:
 473                         panic("%s: unknown slave mode (%d)!", __FUNCTION__,
 474                                 pcf->pcf_slave_mode);
 475                     }
 476
 477         } while ((PCF_GET_S1(pcf) & PIN) == 0);
 478
 479         return;
 480
 481 error:
 482         /* unknown event on bus...reset PCF */
 483         PCF_SET_S1(pcf, PIN|ES0|ENI|ACK);
 484
 485         pcf->pcf_slave_mode = SLAVE_RECEIVER;
 486
 487         return;
 488 }
 489
 490 static int pcf_rst_card(device_t pcfdev, u_char speed, u_char addr, u_char *oldaddr)
 491 {
 492         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
 493
 494         if (oldaddr)
 495                 *oldaddr = pcf->pcf_addr;
 496
 497         /* retrieve own address from bus level */
 498         if (!addr)
 499                 pcf->pcf_addr = PCF_DEFAULT_ADDR;
 500         else
 501                 pcf->pcf_addr = addr;
 502
 503         PCF_SET_S1(pcf, PIN);                           /* initialize S1 */
 504
 505         /* own address S'O<>0 */
 506         PCF_SET_S0(pcf, pcf->pcf_addr >> 1);
 507
 508         /* select clock register */
 509         PCF_SET_S1(pcf, PIN|ES1);
 510
 511         /* select bus speed : 18=90kb, 19=45kb, 1A=11kb, 1B=1.5kb */
 512         switch (speed) {
 513         case IIC_SLOW:
 514                 PCF_SET_S0(pcf,  0x1b);
 515                 break;
 516
 517         case IIC_FAST:
 518                 PCF_SET_S0(pcf,  0x19);
 519                 break;
 520
 521         case IIC_UNKNOWN:
 522         case IIC_FASTEST:
 523         default:
 524                 PCF_SET_S0(pcf,  0x18);
 525                 break;
 526         }
 527
 528         /* set bus on, ack=yes, INT=yes */
 529         PCF_SET_S1(pcf, PIN|ES0|ENI|ACK);
 530
 531         pcf->pcf_slave_mode = SLAVE_RECEIVER;
 532
 533         return (0);
 534 }
 535
 536 static int
 537 pcf_write(device_t pcfdev, char *buf, int len, int *sent, int timeout /* us */)
 538 {
 539         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
 540         int bytes, error = 0;
 541
 542 #ifdef PCFDEBUG
 543         printf("pcf%d: >> writing %d bytes\n", device_get_unit(pcfdev), len);
 544 #endif
 545
 546         bytes = 0;
 547         while (len) {
 548
 549                 PCF_SET_S0(pcf, *buf++);
 550
 551                 /* wait for the byte to be send */
 552                 if ((error = pcf_wait_byte(pcf)))
 553                         goto error;
 554
 555                 /* check if ack received */
 556                 if (pcf_noack(pcf, timeout)) {
 557                         error = IIC_ENOACK;
 558                         goto error;
 559                 }
 560
 561                 len --;
 562                 bytes ++;
 563         }
 564
 565 error:
 566         *sent = bytes;
 567
 568 #ifdef PCFDEBUG
 569         printf("pcf%d: >> %d bytes written (%d)\n",
 570                 device_get_unit(pcfdev), bytes, error);
 571 #endif
 572
 573         return (error);
 574 }
 575
 576 static int
 577 pcf_read(device_t pcfdev, char *buf, int len, int *read, int last,
 578                                                         int delay /* us */)
 579 {
 580         struct pcf_softc *pcf = DEVTOSOFTC(pcfdev);
 581         int bytes, error = 0;
 582
 583 #ifdef PCFDEBUG
 584         printf("pcf%d: << reading %d bytes\n", device_get_unit(pcfdev), len);
 585 #endif
 586
 587         /* trig the bus to get the first data byte in S0 */
 588         if (len) {
 589                 if (len == 1 && last)
 590                         /* just one byte to read */
 591                         PCF_SET_S1(pcf, ES0);           /* no ack */
 592
 593                 dummy_read(pcf);
 594         }
 595
 596         bytes = 0;
 597         while (len) {
 598
 599                 /* XXX delay needed here */
 600
 601                 /* wait for trigged byte */
 602                 if ((error = pcf_wait_byte(pcf))) {
 603                         pcf_stop(pcfdev);
 604                         goto error;
 605                 }
 606
 607                 if (len == 1 && last)
 608                         /* ok, last data byte already in S0, no I2C activity
 609                          * on next PCF_GET_S0() */
 610                         pcf_stop(pcfdev);
 611
 612                 else if (len == 2 && last)
 613                         /* next trigged byte with no ack */
 614                         PCF_SET_S1(pcf, ES0);
 615
 616                 /* receive byte, trig next byte */
 617                 *buf++ = PCF_GET_S0(pcf);
 618
 619                 len --;
 620                 bytes ++;
 621         };
 622
 623 error:
 624         *read = bytes;
 625
 626 #ifdef PCFDEBUG
 627         printf("pcf%d: << %d bytes read (%d)\n",
 628                 device_get_unit(pcfdev), bytes, error);
 629 #endif
 630
 631         return (error);
 632 }
 633
 634 DRIVER_MODULE(pcf, isa, pcf_driver, pcf_devclass, 0, 0);