LXR linux/drivers/macintosh/via-maciisi.c

   1/*
   2 * Device driver for the IIsi-style ADB on some Mac LC and II-class machines
   3 *
   4 * Based on via-cuda.c and via-macii.c, as well as the original
   5 * adb-bus.c, which in turn is somewhat influenced by (but uses no
   6 * code from) the NetBSD HWDIRECT ADB code.  Original IIsi driver work
   7 * was done by Robert Thompson and integrated into the old style
   8 * driver by Michael Schmitz.
   9 *
  10 * Original sources (c) Alan Cox, Paul Mackerras, and others.
  11 *
  12 * Rewritten for Unified ADB by David Huggins-Daines <dhd@debian.org>
  13 * 
  14 * 7/13/2000- extensive changes by Andrew McPherson <andrew@macduff.dhs.org>
  15 * Works about 30% of the time now.
  16 */
  17
  18#include <linux/types.h>
  19#include <linux/errno.h>
  20#include <linux/kernel.h>
  21#include <linux/adb.h>
  22#include <linux/cuda.h>
  23#include <linux/delay.h>
  24#include <linux/interrupt.h>
  25#include <asm/macintosh.h>
  26#include <asm/macints.h>
  27#include <asm/mac_via.h>
  28
  29static volatile unsigned char *via;
  30
  31/* VIA registers - spaced 0x200 bytes apart - only the ones we actually use */
  32#define RS              0x200           /* skip between registers */
  33#define B               0               /* B-side data */
  34#define A               RS              /* A-side data */
  35#define DIRB            (2*RS)          /* B-side direction (1=output) */
  36#define DIRA            (3*RS)          /* A-side direction (1=output) */
  37#define SR              (10*RS)         /* Shift register */
  38#define ACR             (11*RS)         /* Auxiliary control register */
  39#define IFR             (13*RS)         /* Interrupt flag register */
  40#define IER             (14*RS)         /* Interrupt enable register */
  41
  42/* Bits in B data register: all active low */
  43#define TREQ            0x08            /* Transfer request (input) */
  44#define TACK            0x10            /* Transfer acknowledge (output) */
  45#define TIP             0x20            /* Transfer in progress (output) */
  46#define ST_MASK         0x30            /* mask for selecting ADB state bits */
  47
  48/* Bits in ACR */
  49#define SR_CTRL         0x1c            /* Shift register control bits */
  50#define SR_EXT          0x0c            /* Shift on external clock */
  51#define SR_OUT          0x10            /* Shift out if 1 */
  52
  53/* Bits in IFR and IER */
  54#define IER_SET         0x80            /* set bits in IER */
  55#define IER_CLR         0               /* clear bits in IER */
  56#define SR_INT          0x04            /* Shift register full/empty */
  57#define SR_DATA         0x08            /* Shift register data */
  58#define SR_CLOCK        0x10            /* Shift register clock */
  59
  60#define ADB_DELAY 150
  61
  62#undef DEBUG_MACIISI_ADB
  63
  64static struct adb_request* current_req;
  65static struct adb_request* last_req;
  66static unsigned char maciisi_rbuf[16];
  67static unsigned char *reply_ptr;
  68static int data_index;
  69static int reading_reply;
  70static int reply_len;
  71static int tmp;
  72static int need_sync;
  73
  74static enum maciisi_state {
  75    idle,
  76    sending,
  77    reading,
  78} maciisi_state;
  79
  80static int maciisi_probe(void);
  81static int maciisi_init(void);
  82static int maciisi_send_request(struct adb_request* req, int sync);
  83static void maciisi_sync(struct adb_request *req);
  84static int maciisi_write(struct adb_request* req);
  85static irqreturn_t maciisi_interrupt(int irq, void* arg);
  86static void maciisi_input(unsigned char *buf, int nb);
  87static int maciisi_init_via(void);
  88static void maciisi_poll(void);
  89static int maciisi_start(void);
  90
  91struct adb_driver via_maciisi_driver = {
  92        "Mac IIsi",
  93        maciisi_probe,
  94        maciisi_init,
  95        maciisi_send_request,
  96        NULL, /* maciisi_adb_autopoll, */
  97        maciisi_poll,
  98        NULL /* maciisi_reset_adb_bus */
  99};
 100
 101static int
 102maciisi_probe(void)
 103{
 104        if (macintosh_config->adb_type != MAC_ADB_IISI)
 105                return -ENODEV;
 106
 107        via = via1;
 108        return 0;
 109}
 110
 111static int
 112maciisi_init(void)
 113{
 114        int err;
 115
 116        if (via == NULL)
 117                return -ENODEV;
 118
 119        if ((err = maciisi_init_via())) {
 120                printk(KERN_ERR "maciisi_init: maciisi_init_via() failed, code %d\n", err);
 121                via = NULL;
 122                return err;
 123        }
 124
 125        if (request_irq(IRQ_MAC_ADB, maciisi_interrupt, 0, "ADB",
 126                        maciisi_interrupt)) {
 127                printk(KERN_ERR "maciisi_init: can't get irq %d\n", IRQ_MAC_ADB);
 128                return -EAGAIN;
 129        }
 130
 131        printk("adb: Mac IIsi driver v0.2 for Unified ADB.\n");
 132        return 0;
 133}
 134
 135/* Flush data from the ADB controller */
 136static void
 137maciisi_stfu(void)
 138{
 139        int status = via[B] & (TIP|TREQ);
 140
 141        if (status & TREQ) {
 142#ifdef DEBUG_MACIISI_ADB
 143                printk (KERN_DEBUG "maciisi_stfu called with TREQ high!\n");
 144#endif
 145                return;
 146        }
 147        
 148        udelay(ADB_DELAY);
 149        via[ACR] &= ~SR_OUT;
 150        via[IER] = IER_CLR | SR_INT;
 151
 152        udelay(ADB_DELAY);
 153
 154        status = via[B] & (TIP|TREQ);
 155
 156        if (!(status & TREQ))
 157        {
 158                via[B] |= TIP;
 159
 160                while(1)
 161                {
 162                        int poll_timeout = ADB_DELAY * 5;
 163                        /* Poll for SR interrupt */
 164                        while (!(via[IFR] & SR_INT) && poll_timeout-- > 0)
 165                                status = via[B] & (TIP|TREQ);
 166
 167                        tmp = via[SR]; /* Clear shift register */
 168#ifdef DEBUG_MACIISI_ADB
 169                        printk(KERN_DEBUG "maciisi_stfu: status %x timeout %d data %x\n",
 170                               status, poll_timeout, tmp);
 171#endif  
 172                        if(via[B] & TREQ)
 173                                break;
 174        
 175                        /* ACK on-off */
 176                        via[B] |= TACK;
 177                        udelay(ADB_DELAY);
 178                        via[B] &= ~TACK;
 179                }
 180
 181                /* end frame */
 182                via[B] &= ~TIP;
 183                udelay(ADB_DELAY);
 184        }
 185
 186        via[IER] = IER_SET | SR_INT;    
 187}
 188
 189/* All specifically VIA-related initialization goes here */
 190static int
 191maciisi_init_via(void)
 192{
 193        int     i;
 194        
 195        /* Set the lines up. We want TREQ as input TACK|TIP as output */
 196        via[DIRB] = (via[DIRB] | TACK | TIP) & ~TREQ;
 197        /* Shift register on input */
 198        via[ACR]  = (via[ACR] & ~SR_CTRL) | SR_EXT;
 199#ifdef DEBUG_MACIISI_ADB
 200        printk(KERN_DEBUG "maciisi_init_via: initial status %x\n", via[B] & (TIP|TREQ));
 201#endif
 202        /* Wipe any pending data and int */
 203        tmp = via[SR];
 204        /* Enable keyboard interrupts */
 205        via[IER] = IER_SET | SR_INT;
 206        /* Set initial state: idle */
 207        via[B] &= ~(TACK|TIP);
 208        /* Clear interrupt bit */
 209        via[IFR] = SR_INT;
 210
 211        for(i = 0; i < 60; i++) {
 212                udelay(ADB_DELAY);
 213                maciisi_stfu();
 214                udelay(ADB_DELAY);
 215                if(via[B] & TREQ)
 216                        break;
 217        }
 218        if (i == 60)
 219                printk(KERN_ERR "maciisi_init_via: bus jam?\n");
 220
 221        maciisi_state = idle;
 222        need_sync = 0;
 223
 224        return 0;
 225}
 226
 227/* Send a request, possibly waiting for a reply */
 228static int
 229maciisi_send_request(struct adb_request* req, int sync)
 230{
 231        int i;
 232
 233#ifdef DEBUG_MACIISI_ADB
 234        static int dump_packet = 0;
 235#endif
 236
 237        if (via == NULL) {
 238                req->complete = 1;
 239                return -ENXIO;
 240        }
 241
 242#ifdef DEBUG_MACIISI_ADB
 243        if (dump_packet) {
 244                printk(KERN_DEBUG "maciisi_send_request:");
 245                for (i = 0; i < req->nbytes; i++) {
 246                        printk(" %.2x", req->data[i]);
 247                }
 248                printk(" sync %d\n", sync);
 249        }
 250#endif
 251
 252        req->reply_expected = 1;
 253        
 254        i = maciisi_write(req);
 255        if (i)
 256        {
 257                /* Normally, if a packet requires syncing, that happens at the end of
 258                 * maciisi_send_request. But if the transfer fails, it will be restarted
 259                 * by maciisi_interrupt(). We use need_sync to tell maciisi_interrupt
 260                 * when to sync a packet that it sends out.
 261                 * 
 262                 * Suggestions on a better way to do this are welcome.
 263                 */
 264                if(i == -EBUSY && sync)
 265                        need_sync = 1;
 266                else
 267                        need_sync = 0;
 268                return i;
 269        }
 270        if(sync)
 271                maciisi_sync(req);
 272        
 273        return 0;
 274}
 275
 276/* Poll the ADB chip until the request completes */
 277static void maciisi_sync(struct adb_request *req)
 278{
 279        int count = 0; 
 280
 281#ifdef DEBUG_MACIISI_ADB
 282        printk(KERN_DEBUG "maciisi_sync called\n");
 283#endif
 284
 285        /* If for some reason the ADB chip shuts up on us, we want to avoid an endless loop. */
 286        while (!req->complete && count++ < 50) {
 287                maciisi_poll();
 288        }
 289        /* This could be BAD... when the ADB controller doesn't respond
 290         * for this long, it's probably not coming back :-( */
 291        if (count > 50) /* Hopefully shouldn't happen */
 292                printk(KERN_ERR "maciisi_send_request: poll timed out!\n");
 293}
 294
 295int
 296maciisi_request(struct adb_request *req, void (*done)(struct adb_request *),
 297            int nbytes, ...)
 298{
 299        va_list list;
 300        int i;
 301
 302        req->nbytes = nbytes;
 303        req->done = done;
 304        req->reply_expected = 0;
 305        va_start(list, nbytes);
 306        for (i = 0; i < nbytes; i++)
 307                req->data[i++] = va_arg(list, int);
 308        va_end(list);
 309
 310        return maciisi_send_request(req, 1);
 311}
 312
 313/* Enqueue a request, and run the queue if possible */
 314static int
 315maciisi_write(struct adb_request* req)
 316{
 317        unsigned long flags;
 318        int i;
 319
 320        /* We will accept CUDA packets - the VIA sends them to us, so
 321           it figures that we should be able to send them to it */
 322        if (req->nbytes < 2 || req->data[0] > CUDA_PACKET) {
 323                printk(KERN_ERR "maciisi_write: packet too small or not an ADB or CUDA packet\n");
 324                req->complete = 1;
 325                return -EINVAL;
 326        }
 327        req->next = NULL;
 328        req->sent = 0;
 329        req->complete = 0;
 330        req->reply_len = 0;
 331        
 332        local_irq_save(flags);
 333
 334        if (current_req) {
 335                last_req->next = req;
 336                last_req = req;
 337        } else {
 338                current_req = req;
 339                last_req = req;
 340        }
 341        if (maciisi_state == idle)
 342        {
 343                i = maciisi_start();
 344                if(i != 0)
 345                {
 346                        local_irq_restore(flags);
 347                        return i;
 348                }
 349        }
 350        else
 351        {
 352#ifdef DEBUG_MACIISI_ADB
 353                printk(KERN_DEBUG "maciisi_write: would start, but state is %d\n", maciisi_state);
 354#endif
 355                local_irq_restore(flags);
 356                return -EBUSY;
 357        }
 358
 359        local_irq_restore(flags);
 360
 361        return 0;
 362}
 363
 364static int
 365maciisi_start(void)
 366{
 367        struct adb_request* req;
 368        int status;
 369
 370#ifdef DEBUG_MACIISI_ADB
 371        status = via[B] & (TIP | TREQ);
 372
 373        printk(KERN_DEBUG "maciisi_start called, state=%d, status=%x, ifr=%x\n", maciisi_state, status, via[IFR]);
 374#endif
 375
 376        if (maciisi_state != idle) {
 377                /* shouldn't happen */
 378                printk(KERN_ERR "maciisi_start: maciisi_start called when driver busy!\n");
 379                return -EBUSY;
 380        }
 381
 382        req = current_req;
 383        if (req == NULL)
 384                return -EINVAL;
 385
 386        status = via[B] & (TIP|TREQ);
 387        if (!(status & TREQ)) {
 388#ifdef DEBUG_MACIISI_ADB
 389                printk(KERN_DEBUG "maciisi_start: bus busy - aborting\n");
 390#endif
 391                return -EBUSY;
 392        }
 393
 394        /* Okay, send */
 395#ifdef DEBUG_MACIISI_ADB
 396        printk(KERN_DEBUG "maciisi_start: sending\n");
 397#endif
 398        /* Set state to active */
 399        via[B] |= TIP;
 400        /* ACK off */
 401        via[B] &= ~TACK;
 402        /* Delay */
 403        udelay(ADB_DELAY);
 404        /* Shift out and send */
 405        via[ACR] |= SR_OUT;
 406        via[SR] = req->data[0];
 407        data_index = 1;
 408        /* ACK on */
 409        via[B] |= TACK;
 410        maciisi_state = sending;
 411
 412        return 0;
 413}
 414
 415void
 416maciisi_poll(void)
 417{
 418        unsigned long flags;
 419
 420        local_irq_save(flags);
 421        if (via[IFR] & SR_INT) {
 422                maciisi_interrupt(0, NULL);
 423        }
 424        else /* avoid calling this function too quickly in a loop */
 425                udelay(ADB_DELAY);
 426
 427        local_irq_restore(flags);
 428}
 429
 430/* Shift register interrupt - this is *supposed* to mean that the
 431   register is either full or empty. In practice, I have no idea what
 432   it means :( */
 433static irqreturn_t
 434maciisi_interrupt(int irq, void* arg)
 435{
 436        int status;
 437        struct adb_request *req;
 438#ifdef DEBUG_MACIISI_ADB
 439        static int dump_reply = 0;
 440#endif
 441        int i;
 442        unsigned long flags;
 443
 444        local_irq_save(flags);
 445
 446        status = via[B] & (TIP|TREQ);
 447#ifdef DEBUG_MACIISI_ADB
 448        printk(KERN_DEBUG "state %d status %x ifr %x\n", maciisi_state, status, via[IFR]);
 449#endif
 450
 451        if (!(via[IFR] & SR_INT)) {
 452                /* Shouldn't happen, we hope */
 453                printk(KERN_ERR "maciisi_interrupt: called without interrupt flag set\n");
 454                local_irq_restore(flags);
 455                return IRQ_NONE;
 456        }
 457
 458        /* Clear the interrupt */
 459        /* via[IFR] = SR_INT; */
 460
 461 switch_start:
 462        switch (maciisi_state) {
 463        case idle:
 464                if (status & TIP)
 465                        printk(KERN_ERR "maciisi_interrupt: state is idle but TIP asserted!\n");
 466
 467                if(!reading_reply)
 468                        udelay(ADB_DELAY);
 469                /* Shift in */
 470                via[ACR] &= ~SR_OUT;
 471                /* Signal start of frame */
 472                via[B] |= TIP;
 473                /* Clear the interrupt (throw this value on the floor, it's useless) */
 474                tmp = via[SR];
 475                /* ACK adb chip, high-low */
 476                via[B] |= TACK;
 477                udelay(ADB_DELAY);
 478                via[B] &= ~TACK;
 479                reply_len = 0;
 480                maciisi_state = reading;
 481                if (reading_reply) {
 482                        reply_ptr = current_req->reply;
 483                } else {
 484                        reply_ptr = maciisi_rbuf;
 485                }
 486                break;
 487
 488        case sending:
 489                /* via[SR]; */
 490                /* Set ACK off */
 491                via[B] &= ~TACK;
 492                req = current_req;
 493
 494                if (!(status & TREQ)) {
 495                        /* collision */
 496                        printk(KERN_ERR "maciisi_interrupt: send collision\n");
 497                        /* Set idle and input */
 498                        via[ACR] &= ~SR_OUT;
 499                        tmp = via[SR];
 500                        via[B] &= ~TIP;
 501                        /* Must re-send */
 502                        reading_reply = 0;
 503                        reply_len = 0;
 504                        maciisi_state = idle;
 505                        udelay(ADB_DELAY);
 506                        /* process this now, because the IFR has been cleared */
 507                        goto switch_start;
 508                }
 509
 510                udelay(ADB_DELAY);
 511
 512                if (data_index >= req->nbytes) {
 513                        /* Sent the whole packet, put the bus back in idle state */
 514                        /* Shift in, we are about to read a reply (hopefully) */
 515                        via[ACR] &= ~SR_OUT;
 516                        tmp = via[SR];
 517                        /* End of frame */
 518                        via[B] &= ~TIP;
 519                        req->sent = 1;
 520                        maciisi_state = idle;
 521                        if (req->reply_expected) {
 522                                /* Note: only set this once we've
 523                                   successfully sent the packet */
 524                                reading_reply = 1;
 525                        } else {
 526                                current_req = req->next;
 527                                if (req->done)
 528                                        (*req->done)(req);
 529                                /* Do any queued requests now */
 530                                i = maciisi_start();
 531                                if(i == 0 && need_sync) {
 532                                        /* Packet needs to be synced */
 533                                        maciisi_sync(current_req);
 534                                }
 535                                if(i != -EBUSY)
 536                                        need_sync = 0;
 537                        }
 538                } else {
 539                        /* Sending more stuff */
 540                        /* Shift out */
 541                        via[ACR] |= SR_OUT;
 542                        /* Write */
 543                        via[SR] = req->data[data_index++];
 544                        /* Signal 'byte ready' */
 545                        via[B] |= TACK;
 546                }
 547                break;
 548
 549        case reading:
 550                /* Shift in */
 551                /* via[ACR] &= ~SR_OUT; */ /* Not in 2.2 */
 552                if (reply_len++ > 16) {
 553                        printk(KERN_ERR "maciisi_interrupt: reply too long, aborting read\n");
 554                        via[B] |= TACK;
 555                        udelay(ADB_DELAY);
 556                        via[B] &= ~(TACK|TIP);
 557                        maciisi_state = idle;
 558                        i = maciisi_start();
 559                        if(i == 0 && need_sync) {
 560                                /* Packet needs to be synced */
 561                                maciisi_sync(current_req);
 562                        }
 563                        if(i != -EBUSY)
 564                                need_sync = 0;
 565                        break;
 566                }
 567                /* Read data */
 568                *reply_ptr++ = via[SR];
 569                status = via[B] & (TIP|TREQ);
 570                /* ACK on/off */
 571                via[B] |= TACK;
 572                udelay(ADB_DELAY);
 573                via[B] &= ~TACK;        
 574                if (!(status & TREQ))
 575                        break; /* more stuff to deal with */
 576                
 577                /* end of frame */
 578                via[B] &= ~TIP;
 579                tmp = via[SR]; /* That's what happens in 2.2 */
 580                udelay(ADB_DELAY); /* Give controller time to recover */
 581
 582                /* end of packet, deal with it */
 583                if (reading_reply) {
 584                        req = current_req;
 585                        req->reply_len = reply_ptr - req->reply;
 586                        if (req->data[0] == ADB_PACKET) {
 587                                /* Have to adjust the reply from ADB commands */
 588                                if (req->reply_len <= 2 || (req->reply[1] & 2) != 0) {
 589                                        /* the 0x2 bit indicates no response */
 590                                        req->reply_len = 0;
 591                                } else {
 592                                        /* leave just the command and result bytes in the reply */
 593                                        req->reply_len -= 2;
 594                                        memmove(req->reply, req->reply + 2, req->reply_len);
 595                                }
 596                        }
 597#ifdef DEBUG_MACIISI_ADB
 598                        if (dump_reply) {
 599                                int i;
 600                                printk(KERN_DEBUG "maciisi_interrupt: reply is ");
 601                                for (i = 0; i < req->reply_len; ++i)
 602                                        printk(" %.2x", req->reply[i]);
 603                                printk("\n");
 604                        }
 605#endif
 606                        req->complete = 1;
 607                        current_req = req->next;
 608                        if (req->done)
 609                                (*req->done)(req);
 610                        /* Obviously, we got it */
 611                        reading_reply = 0;
 612                } else {
 613                        maciisi_input(maciisi_rbuf, reply_ptr - maciisi_rbuf);
 614                }
 615                maciisi_state = idle;
 616                status = via[B] & (TIP|TREQ);
 617                if (!(status & TREQ)) {
 618                        /* Timeout?! More likely, another packet coming in already */
 619#ifdef DEBUG_MACIISI_ADB
 620                        printk(KERN_DEBUG "extra data after packet: status %x ifr %x\n",
 621                               status, via[IFR]);
 622#endif
 623#if 0
 624                        udelay(ADB_DELAY);
 625                        via[B] |= TIP;
 626
 627                        maciisi_state = reading;
 628                        reading_reply = 0;
 629                        reply_ptr = maciisi_rbuf;
 630#else
 631                        /* Process the packet now */
 632                        reading_reply = 0;
 633                        goto switch_start;
 634#endif
 635                        /* We used to do this... but the controller might actually have data for us */
 636                        /* maciisi_stfu(); */
 637                }
 638                else {
 639                        /* Do any queued requests now if possible */
 640                        i = maciisi_start();
 641                        if(i == 0 && need_sync) {
 642                                /* Packet needs to be synced */
 643                                maciisi_sync(current_req);
 644                        }
 645                        if(i != -EBUSY)
 646                                need_sync = 0;
 647                }
 648                break;
 649
 650        default:
 651                printk("maciisi_interrupt: unknown maciisi_state %d?\n", maciisi_state);
 652        }
 653        local_irq_restore(flags);
 654        return IRQ_HANDLED;
 655}
 656
 657static void
 658maciisi_input(unsigned char *buf, int nb)
 659{
 660#ifdef DEBUG_MACIISI_ADB
 661    int i;
 662#endif
 663
 664    switch (buf[0]) {
 665    case ADB_PACKET:
 666            adb_input(buf+2, nb-2, buf[1] & 0x40);
 667            break;
 668    default:
 669#ifdef DEBUG_MACIISI_ADB
 670            printk(KERN_DEBUG "data from IIsi ADB (%d bytes):", nb);
 671            for (i = 0; i < nb; ++i)
 672                    printk(" %.2x", buf[i]);
 673            printk("\n");
 674#endif
 675            break;
 676    }
 677}
 678