linux/drivers/macintosh/via-maciisi.c
<<
>>
Prefs
   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
 290         * for this long, it's probably not coming back :-( */
 291        if (count > 50) ivers/macintosh/via-maciiHopefully sh84 7n'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 sh84 7 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: w84 7 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                /* sh84 7n'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}
 31414"> 493vers/macintosh/vivers/maci4tosh/via-maciisi.c#L315"4id="L415" clclase" name="L314"> 31414"> 493vers/macintosh/vivers/macintosh/via-maciisi.c#L316"4id="L416" class="line" name="L296">        maciisi_start(void)
TREQ)) {
 317        unsigned long flags;
 319
 332        local_irq_save(flags);
 341ef">status, via[sef=INCR] |= idle) {
 292ode=maciiuse need    req == flags);
 413}
 408  hip sht;malongclassfuncmentng">&quickly i    s, w/* ACK on */
 403        udelay(ADB_DELAY);
 236
 359        local_irq_restore(flags);
 413}
 319
        regis    iuse need>/* Wassass*supposed*an cmean"commethean class="comment">/* ACK on */
 3regis    is either ) iv pacempty. In prlassce, I h_sa nos/mea womman class="comment">/* ACK on */
 2itcmeans :9;s probably not coming back :-( */
maciisrqe" nam_d     319
 292ode=maciiuse need     368srq    a">i++] = maciisi_start(void)
idle) {
 368        int status;
 367        struct adb_request *status;
 388#ifdef DEBUG_MACIISI_ADB
 ump_"+cod       412        return 0;
 390#endif
 318        int i;
 317        unsigned long flags;
 393
 332        local_irq_save(flags);
 385
 386        status = via[B] & (TIP|TREQ85
 388#ifdef DEBUG_MACIISI_ADB
 396        printk(KERN_DEBUG<  , maciisi_state, status, via[IFR]);
 390#endif
 360
 387status, via[sef=INCR] |= idle) {
        /* Set state to active */
 353                printk(KERN_ERR ref= small or not an ADB or CUDA packet\n");
 324 359        local_irq_restore(flags);
               IRQ_NONEref">via[flags;
 326        }
 326        }
 408  Clear* We iuse need>omment">/* Set state to active */
 408  an>[ hr="+cef=INC;>omment">/* Set state to active */
 360
macisitch> 365 360
 376        if (idle) {
 318 !=  360
 376a>        if (!(st>B] & (maciisi_start(void)
 353                printk(KERN_ERR );
 236
 286  a+cod_"+cod      maciisi_start(void)
 353 403        udelay(ADB_DELAY);
        i /* ACK on */
 324 405        via[ACR] |= SR_OUT;
   ignaling">& of fr#L3/* ACK on */
 292 399        via[B] |= TIP;
 408  Clear* We iuse need>(throw* Wassvalue s="commfloormment">    use on )/* ACK on */
 324tmpf">B] |= status = via[TIP;
 408      adb">/* , high-low*span class="comment">/* ACK on */
 336 409        via[B] |= TACK;
 353 403        udelay(ADB_DELAY);
 378 401        via[B] &= ~TACK;
 286  ">req->reply_len = 0;
 324        if (TACK;
 383idle) {
 286  ">reptra>->req = ra>->TACK;
 337        } else {
 286  ">reptra>->TACK;
 326        }
TACK;
 326        }
 318isi_state =  360
 408  an>[SR];>omment">/* Set state to active */
 398            /* ACK off */
 378 401        via[B] &= ~TACK;
 292 382        req = current_req;
 393
 387        if (!(status & TREQ)) {
 398  collref  /* ACK on */
 346                        printk(KERN_ERR  "" name="L398"> 398      hrefun clinpud>omment">/* Set state to active */
 353 405        via[ACR] |= SR_OUT;
 353tmpf">B] |= status = via[TIP;
 353 405        via[ref">B] |= TIP;
 "" name="L398"> 398  Mus  re-ass="comment">/* Shift out and send */
 286  a+cod_"+cod      reply_len = 0;
 286  ">req->reply_len = 0;
 286        if (reply_len = 0;
 353 403        udelay(ADB_DELAY);
 3" name="L398"> 398  process* Wassnow, becauamecommIFR has beeame=eare="comment">/* Shift out and send */
 gotoalass="sref">macisitch> 365ADB_DELAY);
 348                }
 319
 324 403        udelay(ADB_DELAY);
 411
 383 407        SR] = idle) {
 398    nmethe whoefuoo sma, pud>the ="stro s i /* Shift out and send */
        i son tare&quoud>to   a+ a "+cod (hop") ivy)/* ACK on */
 353 405        via[ACR] |= SR_OUT;
 346        tmpf">B] |= status = via[TIP;
 "" name="L398"> 398  Es="of fr#L3/* ACK on */
 353 405        via[ref">B] |= TIP;
 353sref">SR] = data_index = 1;
 353        if (reply_len = 0;
 e" name="L383"> 383        if (r_expecteda>->idle) {
 "" name="L398"> 398  Nolassonod set* Wassonce wet">  vean class="comment">/* ACK on */
 222222222222222222222222222222222success) ivyoassd>the oo sma/* ACK on */
 353  a+cod_"+cod      data_index = 1;
 337        } else {
 e" name="L353"> 353                current_req = reply_len = 0;
         e" name="L383"> 383        if (reply_len = 0;
adb_request * 383        if (ADB_DELAY);
 402   o any queued =adb_ressnow/* ACK on */
 353             if(ADB_DELAY);
         e"name="L383"> 383             if(sneed_sync/e = idle) {
 e" name="" name="L402"> 402  Po smato bfuaynce="comment">/* Shift out and send */
 353de=maciisync/e = ADB_DELAY);
 348                }
 383             if( 391                return -reply_len = 0;
 e" name=e" name="L353"> 353need_sync/e = reply_len = 0;
 "L348"> 348                }
 337        } else {
 398    n+cod morfuacu /* ACK off */
 404        /* ACK off */
 "L353"> 353 405        via[ACR] |= SR_OUT;
 404  Wriisicomment">/* Shift out and send */
 286f">status = via[SR] = req-> 383 407        TIP;
   ignalit">  byte   a+yt">  icomment">/* Shift out and send */
 353 405        via[B] |= TACK;
 348                }
TACK;
TACK;
 318sra_state =  360
 398        i /* ACK on */
 408  an>[ href="+code=ef="+c icomment"> "" name="L398"> 398  Nol i <2.2/* ACK on */
 383req->idle) {
 353                printk(KERN_ERR &L317,"mac   a+_start called when driver busy!\n");
 353 405        via[B] |= TACK;
 353 403        udelay(ADB_DELAY);
 346         405        via[B] |= B] & (ADB_DELAY);
 "L353"> 353        if (reply_len = 0;
 353             if(ADB_DELAY);
 383             if(sneed_sync/e = idle) {
 402  Po smato bfuaynce="comment">/* Shift out and send */
         "L353"> 353de=maciisync/e = ADB_DELAY);
 348                }
 383             if( 391                return -reply_len = 0;
         "L353"> 353need_sync/e = reply_len = 0;
TACK;
 348                }
 402  R a+ +cod"comment">/* Shift out and send */
adb">reptra>->status = via[TIP;
status = via[B] & (TIP|TREQ85
 408        /  /* ACK off */
 353 405        via[B] |= TACK;
 292 403        udelay(ADB_DELAY);
via[B] |= ADB_DELAY);
 387        if (!(status & ADB_DELAY);
 408  morfuacu /* ACK off */
/* ACK off */
 408  es="of fr#L3/* ACK on */
 378 401        via[ref">B] |= TIP;
 286tmpf">B] |= status = via[ 408  Thant">    wommlass="cs i <2.2/* ACK on */
 324 403        udelay( 408  G/*  controller tiL3/* ACK on */
 411
 408  es="of oo sma, dealisithsipapan class="comment">/* ACK off */
 383idle) {
 286  82        req = current_req;
 286  82        r_q->adb">reptra>-> 286  82        ra>->current_req;
 383SR] = req->] |= idle) {
         "" name="L408"> 408  H_sa to adjus  the "+cod from ref "> 4andsapan class="comment">/* ACK off */
 383        if (r_q-> 383        if (ra>->0sde=idle" class="sref">idle) {
         "" name="L408"> 408  the 0x2 bil i dicatessno "+spons3/* ACK on */
         "L286"> 286  82        r_q->reply_len = 0;
 337        } else {
         "" name="L408"> 408  le_sa jus  the "> 4andun cl"+sult byte  i /* ACK on */
 353  82        r_q->reply_len = 0;
 353memmo    ra>->ra>->r_q->ADB_DELAY);
 348                }
 "L348"> 348                }
 388#ifdef DEBUG_MACIISI_ADB
 383 ump_"+cod      idle) {
 318        int i;
 353                printk(KERN_DEBUG );
         for name="L383"> 383             if(s             if(r_q->s             if(ADB_DELAY);
 353                KERN_DEBUG< ate=&.2x;d, status=%x, ifr=%x\        if (ra>->s             if(IFR]);
 353                KERN_DEBUG<_start called when driver busy!\n");
 348                }
 390#endif
 3x, ifr=%x\        if ( ple if ( ple ia hre+c class="sref">data_index = 1;
 de=req" class="sref">req = current_req = reply_len = 0;
 383        if (reply_len = 0;
adb_request * 383        if (ADB_DELAY);
 d" name="L408"> 408  Obviouslyson tgol ipapan class="comment">/* ACK off */
 "L353"> 353  a+cod_"+cod      reply_len = 0;
 337        } else {
 353ma> reptra>-> 286de=maciirbuff (ADB_DELAY);
 348                }
 286de=macii    if (reply_len = 0;
status = via[B] & (TIP|TREQ85
 387        if (!(status & TREQ)) {
 408  Timeout?! Morfulikelysoanother oo sma<"> mac in al  a+yapan class="comment">/* ACK off */
 388#ifdef DEBUG_MACIISI_ADB
 353                printk(KERN_DEBUGDEBUG_MACIISI_ADB
 " name="req" class="srs386        status = via[IFR]);
 390#endif
 390#endif
 324 403        udelay( 390#endif
status = via[B] |= TIP;
 236
 "L286"> 286de=macii    if (TACK;
 353  a+cod_"+cod      reply_len = 0;
reptra>->TACK;
TACK;
 "" name="L402"> 402  Process* We oo sma/* ACK on */
 353  a+cod_"+cod      reply_len = 0;
macisitch> 365ADB_DELAY);
 390#endif
 404  We usedsto do* Was... bu  the ">ntroller might actuaivyoh_sa +cod"for usapan class="comment">/* ACK off */
 "" name="L408"> 408  me=maciisifu() icomment">/* Shift out and send */
 348                }
 337        } else {
 398   o any queued =adb_ressnow/* ACK on */
 383             if( 286de=macii   5ADB_DELAY);
 e"name="L383"> 383             if(sneed_sync/e = idle) {
 398  Po smato bfuaynce="comment">/* Shift out and send */
 383de=maciisync/e = ADB_DELAY);
 348                }
 383             if( 391                return -reply_len = 0;
 383need_sync/e = reply_len = 0;
 348                }
TACK;
 319
 360
 353                KERN_DEBUG  286de=macii    if (ADB_DELAY);
 348                }
 286local_irqrrestorif (ADB_DELAY);
 286IRQ_HANDLEDsref">via[ADB_DELAY);
 348                }
 236
 236
 353ma> abuff ( 318nb/e = reply_len = 0;
idle) {
 388#ifdef DEBUG_MACIISI_ADB
 318        int i;
 390#endif
 390#endif
idle) {
 318ref"PrefECR] |=  360
 318adbaiupuADB_DELAY);
TACK;
 360
 388#ifdef DEBUG_MACIISI_ADB
 353                printk(KERN_DEBUG<+cod"from IIsi ref (ate=&d byte ):tart called w, "L286"> 286nb/e = TACK;
 383             if(s             if(s             if(ADB_DELAY);
 353                KERN_DEBUG< ate=&.2x;d, status=%x, ifr=%x\buff (s             if(IFR]);
 353                KERN_DEBUG<_start called when driver busy!\n");
 390#endif
TACK;
 348                }
 348                }



The originaliLXR software&by the 348"> 348http://sourceforge.net/projects/lxr">LXR "> 3unitdt_rest Wassexperi398 ion&by 348"> 348mailto:lxr@ciiux.nocolxr@ciiux.not_re.
lxr.ciiux.no kindvyohosted&by 348"> 348http://www.redpill-ciipro.nocoRedpill Liipro ASt_restprovider"of Liiux ">nsultmac n cloper_si>ns services since 1995.