drivers/net/wan/z85230.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *
   4  *      (c) Copyright 1998 Alan Cox <[email protected]>
   5  *      (c) Copyright 2000, 2001 Red Hat Inc
   6  *
   7  *      Development of this driver was funded by Equiinet Ltd
   8  *                      http://www.equiinet.com
   9  *
  10  *      ChangeLog:
  11  *
  12  *      Asynchronous mode dropped for 2.2. For 2.5 we will attempt the
  13  *      unification of all the Z85x30 asynchronous drivers for real.
  14  *
  15  *      DMA now uses get_free_page as kmalloc buffers may span a 64K
  16  *      boundary.
  17  *
  18  *      Modified for SMP safety and SMP locking by Alan Cox
  19  *                                      <[email protected]>
  20  *
  21  *      Performance
  22  *
  23  *      Z85230:
  24  *      Non DMA you want a 486DX50 or better to do 64Kbits. 9600 baud
  25  *      X.25 is not unrealistic on all machines. DMA mode can in theory
  26  *      handle T1/E1 quite nicely. In practice the limit seems to be about
  27  *      512Kbit->1Mbit depending on motherboard.
  28  *
  29  *      Z85C30:
  30  *      64K will take DMA, 9600 baud X.25 should be ok.
  31  *
  32  *      Z8530:
  33  *      Synchronous mode without DMA is unlikely to pass about 2400 baud.
  34  */
  35
  36 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  37
  38 #include <linux/module.h>
  39 #include <linux/kernel.h>
  40 #include <linux/mm.h>
  41 #include <linux/net.h>
  42 #include <linux/skbuff.h>
  43 #include <linux/netdevice.h>
  44 #include <linux/if_arp.h>
  45 #include <linux/delay.h>
  46 #include <linux/hdlc.h>
  47 #include <linux/ioport.h>
  48 #include <linux/init.h>
  49 #include <linux/gfp.h>
  50 #include <asm/dma.h>
  51 #include <asm/io.h>
  52 #define RT_LOCK
  53 #define RT_UNLOCK
  54 #include <linux/spinlock.h>
  55
  56 #include "z85230.h"
  57
  58
  59 /**
  60  *      z8530_read_port - Architecture specific interface function
  61  *      @p: port to read
  62  *
  63  *      Provided port access methods. The Comtrol SV11 requires no delays
  64  *      between accesses and uses PC I/O. Some drivers may need a 5uS delay
  65  *
  66  *      In the longer term this should become an architecture specific
  67  *      section so that this can become a generic driver interface for all
  68  *      platforms. For now we only handle PC I/O ports with or without the
  69  *      dread 5uS sanity delay.
  70  *
  71  *      The caller must hold sufficient locks to avoid violating the horrible
  72  *      5uS delay rule.
  73  */
  74
  75 static inline int z8530_read_port(unsigned long p)
  76 {
  77         u8 r=inb(Z8530_PORT_OF(p));
  78         if(p&Z8530_PORT_SLEEP)  /* gcc should figure this out efficiently ! */
  79                 udelay(5);
  80         return r;
  81 }
  82
  83 /**
  84  *      z8530_write_port - Architecture specific interface function
  85  *      @p: port to write
  86  *      @d: value to write
  87  *
  88  *      Write a value to a port with delays if need be. Note that the
  89  *      caller must hold locks to avoid read/writes from other contexts
  90  *      violating the 5uS rule
  91  *
  92  *      In the longer term this should become an architecture specific
  93  *      section so that this can become a generic driver interface for all
  94  *      platforms. For now we only handle PC I/O ports with or without the
  95  *      dread 5uS sanity delay.
  96  */
  97
  98
  99 static inline void z8530_write_port(unsigned long p, u8 d)
 100 {
 101         outb(d,Z8530_PORT_OF(p));
 102         if(p&Z8530_PORT_SLEEP)
 103                 udelay(5);
 104 }
 105
 106
 107
 108 static void z8530_rx_done(struct z8530_channel *c);
 109 static void z8530_tx_done(struct z8530_channel *c);
 110
 111
 112 /**
 113  *      read_zsreg - Read a register from a Z85230
 114  *      @c: Z8530 channel to read from (2 per chip)
 115  *      @reg: Register to read
 116  *      FIXME: Use a spinlock.
 117  *
 118  *      Most of the Z8530 registers are indexed off the control registers.
 119  *      A read is done by writing to the control register and reading the
 120  *      register back.  The caller must hold the lock
 121  */
 122
 123 static inline u8 read_zsreg(struct z8530_channel *c, u8 reg)
 124 {
 125         if(reg)
 126                 z8530_write_port(c->ctrlio, reg);
 127         return z8530_read_port(c->ctrlio);
 128 }
 129
 130 /**
 131  *      read_zsdata - Read the data port of a Z8530 channel
 132  *      @c: The Z8530 channel to read the data port from
 133  *
 134  *      The data port provides fast access to some things. We still
 135  *      have all the 5uS delays to worry about.
 136  */
 137
 138 static inline u8 read_zsdata(struct z8530_channel *c)
 139 {
 140         u8 r;
 141         r=z8530_read_port(c->dataio);
 142         return r;
 143 }
 144
 145 /**
 146  *      write_zsreg - Write to a Z8530 channel register
 147  *      @c: The Z8530 channel
 148  *      @reg: Register number
 149  *      @val: Value to write
 150  *
 151  *      Write a value to an indexed register. The caller must hold the lock
 152  *      to honour the irritating delay rules. We know about register 0
 153  *      being fast to access.
 154  *
 155  *      Assumes c->lock is held.
 156  */
 157 static inline void write_zsreg(struct z8530_channel *c, u8 reg, u8 val)
 158 {
 159         if(reg)
 160                 z8530_write_port(c->ctrlio, reg);
 161         z8530_write_port(c->ctrlio, val);
 162
 163 }
 164
 165 /**
 166  *      write_zsctrl - Write to a Z8530 control register
 167  *      @c: The Z8530 channel
 168  *      @val: Value to write
 169  *
 170  *      Write directly to the control register on the Z8530
 171  */
 172
 173 static inline void write_zsctrl(struct z8530_channel *c, u8 val)
 174 {
 175         z8530_write_port(c->ctrlio, val);
 176 }
 177
 178 /**
 179  *      write_zsdata - Write to a Z8530 control register
 180  *      @c: The Z8530 channel
 181  *      @val: Value to write
 182  *
 183  *      Write directly to the data register on the Z8530
 184  */
 185
 186
 187 static inline void write_zsdata(struct z8530_channel *c, u8 val)
 188 {
 189         z8530_write_port(c->dataio, val);
 190 }
 191
 192 /*
 193  *      Register loading parameters for a dead port
 194  */
 195
 196 u8 z8530_dead_port[]=
 197 {
 198         255
 199 };
 200
 201 EXPORT_SYMBOL(z8530_dead_port);
 202
 203 /*
 204  *      Register loading parameters for currently supported circuit types
 205  */
 206
 207
 208 /*
 209  *      Data clocked by telco end. This is the correct data for the UK
 210  *      "kilostream" service, and most other similar services.
 211  */
 212
 213 u8 z8530_hdlc_kilostream[]=
 214 {
 215         4,      SYNC_ENAB|SDLC|X1CLK,
 216         2,      0,      /* No vector */
 217         1,      0,
 218         3,      ENT_HM|RxCRC_ENAB|Rx8,
 219         5,      TxCRC_ENAB|RTS|TxENAB|Tx8|DTR,
 220         9,      0,              /* Disable interrupts */
 221         6,      0xFF,
 222         7,      FLAG,
 223         10,     ABUNDER|NRZ|CRCPS,/*MARKIDLE ??*/
 224         11,     TCTRxCP,
 225         14,     DISDPLL,
 226         15,     DCDIE|SYNCIE|CTSIE|TxUIE|BRKIE,
 227         1,      EXT_INT_ENAB|TxINT_ENAB|INT_ALL_Rx,
 228         9,      NV|MIE|NORESET,
 229         255
 230 };
 231
 232 EXPORT_SYMBOL(z8530_hdlc_kilostream);
 233
 234 /*
 235  *      As above but for enhanced chips.
 236  */
 237
 238 u8 z8530_hdlc_kilostream_85230[]=
 239 {
 240         4,      SYNC_ENAB|SDLC|X1CLK,
 241         2,      0,      /* No vector */
 242         1,      0,
 243         3,      ENT_HM|RxCRC_ENAB|Rx8,
 244         5,      TxCRC_ENAB|RTS|TxENAB|Tx8|DTR,
 245         9,      0,              /* Disable interrupts */
 246         6,      0xFF,
 247         7,      FLAG,
 248         10,     ABUNDER|NRZ|CRCPS,      /* MARKIDLE?? */
 249         11,     TCTRxCP,
 250         14,     DISDPLL,
 251         15,     DCDIE|SYNCIE|CTSIE|TxUIE|BRKIE,
 252         1,      EXT_INT_ENAB|TxINT_ENAB|INT_ALL_Rx,
 253         9,      NV|MIE|NORESET,
 254         23,     3,              /* Extended mode AUTO TX and EOM*/
 255
 256         255
 257 };
 258
 259 EXPORT_SYMBOL(z8530_hdlc_kilostream_85230);
 260
 261 /**
 262  *      z8530_flush_fifo - Flush on chip RX FIFO
 263  *      @c: Channel to flush
 264  *
 265  *      Flush the receive FIFO. There is no specific option for this, we
 266  *      blindly read bytes and discard them. Reading when there is no data
 267  *      is harmless. The 8530 has a 4 byte FIFO, the 85230 has 8 bytes.
 268  *
 269  *      All locking is handled for the caller. On return data may still be
 270  *      present if it arrived during the flush.
 271  */
 272
 273 static void z8530_flush_fifo(struct z8530_channel *c)
 274 {
 275         read_zsreg(c, R1);
 276         read_zsreg(c, R1);
 277         read_zsreg(c, R1);
 278         read_zsreg(c, R1);
 279         if(c->dev->type==Z85230)
 280         {
 281                 read_zsreg(c, R1);
 282                 read_zsreg(c, R1);
 283                 read_zsreg(c, R1);
 284                 read_zsreg(c, R1);
 285         }
 286 }
 287
 288 /**
 289  *      z8530_rtsdtr - Control the outgoing DTS/RTS line
 290  *      @c: The Z8530 channel to control;
 291  *      @set: 1 to set, 0 to clear
 292  *
 293  *      Sets or clears DTR/RTS on the requested line. All locking is handled
 294  *      by the caller. For now we assume all boards use the actual RTS/DTR
 295  *      on the chip. Apparently one or two don't. We'll scream about them
 296  *      later.
 297  */
 298
 299 static void z8530_rtsdtr(struct z8530_channel *c, int set)
 300 {
 301         if (set)
 302                 c->regs[5] |= (RTS | DTR);
 303         else
 304                 c->regs[5] &= ~(RTS | DTR);
 305         write_zsreg(c, R5, c->regs[5]);
 306 }
 307
 308 /**
 309  *      z8530_rx - Handle a PIO receive event
 310  *      @c: Z8530 channel to process
 311  *
 312  *      Receive handler for receiving in PIO mode. This is much like the
 313  *      async one but not quite the same or as complex
 314  *
 315  *      Note: Its intended that this handler can easily be separated from
 316  *      the main code to run realtime. That'll be needed for some machines
 317  *      (eg to ever clock 64kbits on a sparc ;)).
 318  *
 319  *      The RT_LOCK macros don't do anything now. Keep the code covered
 320  *      by them as short as possible in all circumstances - clocks cost
 321  *      baud. The interrupt handler is assumed to be atomic w.r.t. to
 322  *      other code - this is true in the RT case too.
 323  *
 324  *      We only cover the sync cases for this. If you want 2Mbit async
 325  *      do it yourself but consider medical assistance first. This non DMA
 326  *      synchronous mode is portable code. The DMA mode assumes PCI like
 327  *      ISA DMA
 328  *
 329  *      Called with the device lock held
 330  */
 331
 332 static void z8530_rx(struct z8530_channel *c)
 333 {
 334         u8 ch,stat;
 335
 336         while(1)
 337         {
 338                 /* FIFO empty ? */
 339                 if(!(read_zsreg(c, R0)&1))
 340                         break;
 341                 ch=read_zsdata(c);
 342                 stat=read_zsreg(c, R1);
 343
 344                 /*
 345                  *      Overrun ?
 346                  */
 347                 if(c->count < c->max)
 348                 {
 349                         *c->dptr++=ch;
 350                         c->count++;
 351                 }
 352
 353                 if(stat&END_FR)
 354                 {
 355
 356                         /*
 357                          *      Error ?
 358                          */
 359                         if(stat&(Rx_OVR|CRC_ERR))
 360                         {
 361                                 /* Rewind the buffer and return */
 362                                 if(c->skb)
 363                                         c->dptr=c->skb->data;
 364                                 c->count=0;
 365                                 if(stat&Rx_OVR)
 366                                 {
 367                                         pr_warn("%s: overrun\n", c->dev->name);
 368                                         c->rx_overrun++;
 369                                 }
 370                                 if(stat&CRC_ERR)
 371                                 {
 372                                         c->rx_crc_err++;
 373                                         /* printk("crc error\n"); */
 374                                 }
 375                                 /* Shove the frame upstream */
 376                         }
 377                         else
 378                         {
 379                                 /*
 380                                  *      Drop the lock for RX processing, or
 381                                  *      there are deadlocks
 382                                  */
 383                                 z8530_rx_done(c);
 384                                 write_zsctrl(c, RES_Rx_CRC);
 385                         }
 386                 }
 387         }
 388         /*
 389          *      Clear irq
 390          */
 391         write_zsctrl(c, ERR_RES);
 392         write_zsctrl(c, RES_H_IUS);
 393 }
 394
 395
 396 /**
 397  *      z8530_tx - Handle a PIO transmit event
 398  *      @c: Z8530 channel to process
 399  *
 400  *      Z8530 transmit interrupt handler for the PIO mode. The basic
 401  *      idea is to attempt to keep the FIFO fed. We fill as many bytes
 402  *      in as possible, its quite possible that we won't keep up with the
 403  *      data rate otherwise.
 404  */
 405
 406 static void z8530_tx(struct z8530_channel *c)
 407 {
 408         while(c->txcount) {
 409                 /* FIFO full ? */
 410                 if(!(read_zsreg(c, R0)&4))
 411                         return;
 412                 c->txcount--;
 413                 /*
 414                  *      Shovel out the byte
 415                  */
 416                 write_zsreg(c, R8, *c->tx_ptr++);
 417                 write_zsctrl(c, RES_H_IUS);
 418                 /* We are about to underflow */
 419                 if(c->txcount==0)
 420                 {
 421                         write_zsctrl(c, RES_EOM_L);
 422                         write_zsreg(c, R10, c->regs[10]&~ABUNDER);
 423                 }
 424         }
 425
 426
 427         /*
 428          *      End of frame TX - fire another one
 429          */
 430
 431         write_zsctrl(c, RES_Tx_P);
 432
 433         z8530_tx_done(c);
 434         write_zsctrl(c, RES_H_IUS);
 435 }
 436
 437 /**
 438  *      z8530_status - Handle a PIO status exception
 439  *      @chan: Z8530 channel to process
 440  *
 441  *      A status event occurred in PIO synchronous mode. There are several
 442  *      reasons the chip will bother us here. A transmit underrun means we
 443  *      failed to feed the chip fast enough and just broke a packet. A DCD
 444  *      change is a line up or down.
 445  */
 446
 447 static void z8530_status(struct z8530_channel *chan)
 448 {
 449         u8 status, altered;
 450
 451         status = read_zsreg(chan, R0);
 452         altered = chan->status ^ status;
 453
 454         chan->status = status;
 455
 456         if (status & TxEOM) {
 457 /*              printk("%s: Tx underrun.\n", chan->dev->name); */
 458                 chan->netdevice->stats.tx_fifo_errors++;
 459                 write_zsctrl(chan, ERR_RES);
 460                 z8530_tx_done(chan);
 461         }
 462
 463         if (altered & chan->dcdcheck)
 464         {
 465                 if (status & chan->dcdcheck) {
 466                         pr_info("%s: DCD raised\n", chan->dev->name);
 467                         write_zsreg(chan, R3, chan->regs[3] | RxENABLE);
 468                         if (chan->netdevice)
 469                                 netif_carrier_on(chan->netdevice);
 470                 } else {
 471                         pr_info("%s: DCD lost\n", chan->dev->name);
 472                         write_zsreg(chan, R3, chan->regs[3] & ~RxENABLE);
 473                         z8530_flush_fifo(chan);
 474                         if (chan->netdevice)
 475                                 netif_carrier_off(chan->netdevice);
 476                 }
 477
 478         }
 479         write_zsctrl(chan, RES_EXT_INT);
 480         write_zsctrl(chan, RES_H_IUS);
 481 }
 482
 483 struct z8530_irqhandler z8530_sync = {
 484         .rx = z8530_rx,
 485         .tx = z8530_tx,
 486         .status = z8530_status,
 487 };
 488
 489 EXPORT_SYMBOL(z8530_sync);
 490
 491 /**
 492  *      z8530_dma_rx - Handle a DMA RX event
 493  *      @chan: Channel to handle
 494  *
 495  *      Non bus mastering DMA interfaces for the Z8x30 devices. This
 496  *      is really pretty PC specific. The DMA mode means that most receive
 497  *      events are handled by the DMA hardware. We get a kick here only if
 498  *      a frame ended.
 499  */
 500
 501 static void z8530_dma_rx(struct z8530_channel *chan)
 502 {
 503         if(chan->rxdma_on)
 504         {
 505                 /* Special condition check only */
 506                 u8 status;
 507
 508                 read_zsreg(chan, R7);
 509                 read_zsreg(chan, R6);
 510
 511                 status=read_zsreg(chan, R1);
 512
 513                 if(status&END_FR)
 514                 {
 515                         z8530_rx_done(chan);    /* Fire up the next one */
 516                 }
 517                 write_zsctrl(chan, ERR_RES);
 518                 write_zsctrl(chan, RES_H_IUS);
 519         }
 520         else
 521         {
 522                 /* DMA is off right now, drain the slow way */
 523                 z8530_rx(chan);
 524         }
 525 }
 526
 527 /**
 528  *      z8530_dma_tx - Handle a DMA TX event
 529  *      @chan:  The Z8530 channel to handle
 530  *
 531  *      We have received an interrupt while doing DMA transmissions. It
 532  *      shouldn't happen. Scream loudly if it does.
 533  */
 534
 535 static void z8530_dma_tx(struct z8530_channel *chan)
 536 {
 537         if(!chan->dma_tx)
 538         {
 539                 pr_warn("Hey who turned the DMA off?\n");
 540                 z8530_tx(chan);
 541                 return;
 542         }
 543         /* This shouldn't occur in DMA mode */
 544         pr_err("DMA tx - bogus event!\n");
 545         z8530_tx(chan);
 546 }
 547
 548 /**
 549  *      z8530_dma_status - Handle a DMA status exception
 550  *      @chan: Z8530 channel to process
 551  *
 552  *      A status event occurred on the Z8530. We receive these for two reasons
 553  *      when in DMA mode. Firstly if we finished a packet transfer we get one
 554  *      and kick the next packet out. Secondly we may see a DCD change.
 555  *
 556  */
 557
 558 static void z8530_dma_status(struct z8530_channel *chan)
 559 {
 560         u8 status, altered;
 561
 562         status=read_zsreg(chan, R0);
 563         altered=chan->status^status;
 564
 565         chan->status=status;
 566
 567
 568         if(chan->dma_tx)
 569         {
 570                 if(status&TxEOM)
 571                 {
 572                         unsigned long flags;
 573
 574                         flags=claim_dma_lock();
 575                         disable_dma(chan->txdma);
 576                         clear_dma_ff(chan->txdma);
 577                         chan->txdma_on=0;
 578                         release_dma_lock(flags);
 579                         z8530_tx_done(chan);
 580                 }
 581         }
 582
 583         if (altered & chan->dcdcheck)
 584         {
 585                 if (status & chan->dcdcheck) {
 586                         pr_info("%s: DCD raised\n", chan->dev->name);
 587                         write_zsreg(chan, R3, chan->regs[3] | RxENABLE);
 588                         if (chan->netdevice)
 589                                 netif_carrier_on(chan->netdevice);
 590                 } else {
 591                         pr_info("%s: DCD lost\n", chan->dev->name);
 592                         write_zsreg(chan, R3, chan->regs[3] & ~RxENABLE);
 593                         z8530_flush_fifo(chan);
 594                         if (chan->netdevice)
 595                                 netif_carrier_off(chan->netdevice);
 596                 }
 597         }
 598
 599         write_zsctrl(chan, RES_EXT_INT);
 600         write_zsctrl(chan, RES_H_IUS);
 601 }
 602
 603 static struct z8530_irqhandler z8530_dma_sync = {
 604         .rx = z8530_dma_rx,
 605         .tx = z8530_dma_tx,
 606         .status = z8530_dma_status,
 607 };
 608
 609 static struct z8530_irqhandler z8530_txdma_sync = {
 610         .rx = z8530_rx,
 611         .tx = z8530_dma_tx,
 612         .status = z8530_dma_status,
 613 };
 614
 615 /**
 616  *      z8530_rx_clear - Handle RX events from a stopped chip
 617  *      @c: Z8530 channel to shut up
 618  *
 619  *      Receive interrupt vectors for a Z8530 that is in 'parked' mode.
 620  *      For machines with PCI Z85x30 cards, or level triggered interrupts
 621  *      (eg the MacII) we must clear the interrupt cause or die.
 622  */
 623
 624
 625 static void z8530_rx_clear(struct z8530_channel *c)
 626 {
 627         /*
 628          *      Data and status bytes
 629          */
 630         u8 stat;
 631
 632         read_zsdata(c);
 633         stat=read_zsreg(c, R1);
 634
 635         if(stat&END_FR)
 636                 write_zsctrl(c, RES_Rx_CRC);
 637         /*
 638          *      Clear irq
 639          */
 640         write_zsctrl(c, ERR_RES);
 641         write_zsctrl(c, RES_H_IUS);
 642 }
 643
 644 /**
 645  *      z8530_tx_clear - Handle TX events from a stopped chip
 646  *      @c: Z8530 channel to shut up
 647  *
 648  *      Transmit interrupt vectors for a Z8530 that is in 'parked' mode.
 649  *      For machines with PCI Z85x30 cards, or level triggered interrupts
 650  *      (eg the MacII) we must clear the interrupt cause or die.
 651  */
 652
 653 static void z8530_tx_clear(struct z8530_channel *c)
 654 {
 655         write_zsctrl(c, RES_Tx_P);
 656         write_zsctrl(c, RES_H_IUS);
 657 }
 658
 659 /**
 660  *      z8530_status_clear - Handle status events from a stopped chip
 661  *      @chan: Z8530 channel to shut up
 662  *
 663  *      Status interrupt vectors for a Z8530 that is in 'parked' mode.
 664  *      For machines with PCI Z85x30 cards, or level triggered interrupts
 665  *      (eg the MacII) we must clear the interrupt cause or die.
 666  */
 667
 668 static void z8530_status_clear(struct z8530_channel *chan)
 669 {
 670         u8 status=read_zsreg(chan, R0);
 671         if(status&TxEOM)
 672                 write_zsctrl(chan, ERR_RES);
 673         write_zsctrl(chan, RES_EXT_INT);
 674         write_zsctrl(chan, RES_H_IUS);
 675 }
 676
 677 struct z8530_irqhandler z8530_nop = {
 678         .rx = z8530_rx_clear,
 679         .tx = z8530_tx_clear,
 680         .status = z8530_status_clear,
 681 };
 682
 683
 684 EXPORT_SYMBOL(z8530_nop);
 685
 686 /**
 687  *      z8530_interrupt - Handle an interrupt from a Z8530
 688  *      @irq:   Interrupt number
 689  *      @dev_id: The Z8530 device that is interrupting.
 690  *
 691  *      A Z85[2]30 device has stuck its hand in the air for attention.
 692  *      We scan both the channels on the chip for events and then call
 693  *      the channel specific call backs for each channel that has events.
 694  *      We have to use callback functions because the two channels can be
 695  *      in different modes.
 696  *
 697  *      Locking is done for the handlers. Note that locking is done
 698  *      at the chip level (the 5uS delay issue is per chip not per
 699  *      channel). c->lock for both channels points to dev->lock
 700  */
 701
 702 irqreturn_t z8530_interrupt(int irq, void *dev_id)
 703 {
 704         struct z8530_dev *dev=dev_id;
 705         u8 intr;
 706         static volatile int locker=0;
 707         int work=0;
 708         struct z8530_irqhandler *irqs;
 709
 710         if(locker)
 711         {
 712                 pr_err("IRQ re-enter\n");
 713                 return IRQ_NONE;
 714         }
 715         locker=1;
 716
 717         spin_lock(&dev->lock);
 718
 719         while(++work<5000)
 720         {
 721
 722                 intr = read_zsreg(&dev->chanA, R3);
 723                 if(!(intr & (CHARxIP|CHATxIP|CHAEXT|CHBRxIP|CHBTxIP|CHBEXT)))
 724                         break;
 725
 726                 /* This holds the IRQ status. On the 8530 you must read it from chan
 727                    A even though it applies to the whole chip */
 728
 729                 /* Now walk the chip and see what it is wanting - it may be
 730                    an IRQ for someone else remember */
 731
 732                 irqs=dev->chanA.irqs;
 733
 734                 if(intr & (CHARxIP|CHATxIP|CHAEXT))
 735                 {
 736                         if(intr&CHARxIP)
 737                                 irqs->rx(&dev->chanA);
 738                         if(intr&CHATxIP)
 739                                 irqs->tx(&dev->chanA);
 740                         if(intr&CHAEXT)
 741                                 irqs->status(&dev->chanA);
 742                 }
 743
 744                 irqs=dev->chanB.irqs;
 745
 746                 if(intr & (CHBRxIP|CHBTxIP|CHBEXT))
 747                 {
 748                         if(intr&CHBRxIP)
 749                                 irqs->rx(&dev->chanB);
 750                         if(intr&CHBTxIP)
 751                                 irqs->tx(&dev->chanB);
 752                         if(intr&CHBEXT)
 753                                 irqs->status(&dev->chanB);
 754                 }
 755         }
 756         spin_unlock(&dev->lock);
 757         if(work==5000)
 758                 pr_err("%s: interrupt jammed - abort(0x%X)!\n",
 759                        dev->name, intr);
 760         /* Ok all done */
 761         locker=0;
 762         return IRQ_HANDLED;
 763 }
 764
 765 EXPORT_SYMBOL(z8530_interrupt);
 766
 767 static const u8 reg_init[16]=
 768 {
 769         0,0,0,0,
 770         0,0,0,0,
 771         0,0,0,0,
 772         0x55,0,0,0
 773 };
 774
 775
 776 /**
 777  *      z8530_sync_open - Open a Z8530 channel for PIO
 778  *      @dev:   The network interface we are using
 779  *      @c:     The Z8530 channel to open in synchronous PIO mode
 780  *
 781  *      Switch a Z8530 into synchronous mode without DMA assist. We
 782  *      raise the RTS/DTR and commence network operation.
 783  */
 784
 785 int z8530_sync_open(struct net_device *dev, struct z8530_channel *c)
 786 {
 787         unsigned long flags;
 788
 789         spin_lock_irqsave(c->lock, flags);
 790
 791         c->sync = 1;
 792         c->mtu = dev->mtu+64;
 793         c->count = 0;
 794         c->skb = NULL;
 795         c->skb2 = NULL;
 796         c->irqs = &z8530_sync;
 797
 798         /* This loads the double buffer up */
 799         z8530_rx_done(c);       /* Load the frame ring */
 800         z8530_rx_done(c);       /* Load the backup frame */
 801         z8530_rtsdtr(c,1);
 802         c->dma_tx = 0;
 803         c->regs[R1]|=TxINT_ENAB;
 804         write_zsreg(c, R1, c->regs[R1]);
 805         write_zsreg(c, R3, c->regs[R3]|RxENABLE);
 806
 807         spin_unlock_irqrestore(c->lock, flags);
 808         return 0;
 809 }
 810
 811
 812 EXPORT_SYMBOL(z8530_sync_open);
 813
 814 /**
 815  *      z8530_sync_close - Close a PIO Z8530 channel
 816  *      @dev: Network device to close
 817  *      @c: Z8530 channel to disassociate and move to idle
 818  *
 819  *      Close down a Z8530 interface and switch its interrupt handlers
 820  *      to discard future events.
 821  */
 822
 823 int z8530_sync_close(struct net_device *dev, struct z8530_channel *c)
 824 {
 825         u8 chk;
 826         unsigned long flags;
 827
 828         spin_lock_irqsave(c->lock, flags);
 829         c->irqs = &z8530_nop;
 830         c->max = 0;
 831         c->sync = 0;
 832
 833         chk=read_zsreg(c,R0);
 834         write_zsreg(c, R3, c->regs[R3]);
 835         z8530_rtsdtr(c,0);
 836
 837         spin_unlock_irqrestore(c->lock, flags);
 838         return 0;
 839 }
 840
 841 EXPORT_SYMBOL(z8530_sync_close);
 842
 843 /**
 844  *      z8530_sync_dma_open - Open a Z8530 for DMA I/O
 845  *      @dev: The network device to attach
 846  *      @c: The Z8530 channel to configure in sync DMA mode.
 847  *
 848  *      Set up a Z85x30 device for synchronous DMA in both directions. Two
 849  *      ISA DMA channels must be available for this to work. We assume ISA
 850  *      DMA driven I/O and PC limits on access.
 851  */
 852
 853 int z8530_sync_dma_open(struct net_device *dev, struct z8530_channel *c)
 854 {
 855         unsigned long cflags, dflags;
 856
 857         c->sync = 1;
 858         c->mtu = dev->mtu+64;
 859         c->count = 0;
 860         c->skb = NULL;
 861         c->skb2 = NULL;
 862         /*
 863          *      Load the DMA interfaces up
 864          */
 865         c->rxdma_on = 0;
 866         c->txdma_on = 0;
 867
 868         /*
 869          *      Allocate the DMA flip buffers. Limit by page size.
 870          *      Everyone runs 1500 mtu or less on wan links so this
 871          *      should be fine.
 872          */
 873
 874         if(c->mtu  > PAGE_SIZE/2)
 875                 return -EMSGSIZE;
 876
 877         c->rx_buf[0]=(void *)get_zeroed_page(GFP_KERNEL|GFP_DMA);
 878         if(c->rx_buf[0]==NULL)
 879                 return -ENOBUFS;
 880         c->rx_buf[1]=c->rx_buf[0]+PAGE_SIZE/2;
 881
 882         c->tx_dma_buf[0]=(void *)get_zeroed_page(GFP_KERNEL|GFP_DMA);
 883         if(c->tx_dma_buf[0]==NULL)
 884         {
 885                 free_page((unsigned long)c->rx_buf[0]);
 886                 c->rx_buf[0]=NULL;
 887                 return -ENOBUFS;
 888         }
 889         c->tx_dma_buf[1]=c->tx_dma_buf[0]+PAGE_SIZE/2;
 890
 891         c->tx_dma_used=0;
 892         c->dma_tx = 1;
 893         c->dma_num=0;
 894         c->dma_ready=1;
 895
 896         /*
 897          *      Enable DMA control mode
 898          */
 899
 900         spin_lock_irqsave(c->lock, cflags);
 901
 902         /*
 903          *      TX DMA via DIR/REQ
 904          */
 905
 906         c->regs[R14]|= DTRREQ;
 907         write_zsreg(c, R14, c->regs[R14]);
 908
 909         c->regs[R1]&= ~TxINT_ENAB;
 910         write_zsreg(c, R1, c->regs[R1]);
 911
 912         /*
 913          *      RX DMA via W/Req
 914          */
 915
 916         c->regs[R1]|= WT_FN_RDYFN;
 917         c->regs[R1]|= WT_RDY_RT;
 918         c->regs[R1]|= INT_ERR_Rx;
 919         c->regs[R1]&= ~TxINT_ENAB;
 920         write_zsreg(c, R1, c->regs[R1]);
 921         c->regs[R1]|= WT_RDY_ENAB;
 922         write_zsreg(c, R1, c->regs[R1]);
 923
 924         /*
 925          *      DMA interrupts
 926          */
 927
 928         /*
 929          *      Set up the DMA configuration
 930          */
 931
 932         dflags=claim_dma_lock();
 933
 934         disable_dma(c->rxdma);
 935         clear_dma_ff(c->rxdma);
 936         set_dma_mode(c->rxdma, DMA_MODE_READ|0x10);
 937         set_dma_addr(c->rxdma, virt_to_bus(c->rx_buf[0]));
 938         set_dma_count(c->rxdma, c->mtu);
 939         enable_dma(c->rxdma);
 940
 941         disable_dma(c->txdma);
 942         clear_dma_ff(c->txdma);
 943         set_dma_mode(c->txdma, DMA_MODE_WRITE);
 944         disable_dma(c->txdma);
 945
 946         release_dma_lock(dflags);
 947
 948         /*
 949          *      Select the DMA interrupt handlers
 950          */
 951
 952         c->rxdma_on = 1;
 953         c->txdma_on = 1;
 954         c->tx_dma_used = 1;
 955
 956         c->irqs = &z8530_dma_sync;
 957         z8530_rtsdtr(c,1);
 958         write_zsreg(c, R3, c->regs[R3]|RxENABLE);
 959
 960         spin_unlock_irqrestore(c->lock, cflags);
 961
 962         return 0;
 963 }
 964
 965 EXPORT_SYMBOL(z8530_sync_dma_open);
 966
 967 /**
 968  *      z8530_sync_dma_close - Close down DMA I/O
 969  *      @dev: Network device to detach
 970  *      @c: Z8530 channel to move into discard mode
 971  *
 972  *      Shut down a DMA mode synchronous interface. Halt the DMA, and
 973  *      free the buffers.
 974  */
 975
 976 int z8530_sync_dma_close(struct net_device *dev, struct z8530_channel *c)
 977 {
 978         u8 chk;
 979         unsigned long flags;
 980
 981         c->irqs = &z8530_nop;
 982         c->max = 0;
 983         c->sync = 0;
 984
 985         /*
 986          *      Disable the PC DMA channels
 987          */
 988
 989         flags=claim_dma_lock();
 990         disable_dma(c->rxdma);
 991         clear_dma_ff(c->rxdma);
 992
 993         c->rxdma_on = 0;
 994
 995         disable_dma(c->txdma);
 996         clear_dma_ff(c->txdma);
 997         release_dma_lock(flags);
 998
 999         c->txdma_on = 0;
1000         c->tx_dma_used = 0;
1001
1002         spin_lock_irqsave(c->lock, flags);
1003
1004         /*
1005          *      Disable DMA control mode
1006          */
1007
1008         c->regs[R1]&= ~WT_RDY_ENAB;
1009         write_zsreg(c, R1, c->regs[R1]);
1010         c->regs[R1]&= ~(WT_RDY_RT|WT_FN_RDYFN|INT_ERR_Rx);
1011         c->regs[R1]|= INT_ALL_Rx;
1012         write_zsreg(c, R1, c->regs[R1]);
1013         c->regs[R14]&= ~DTRREQ;
1014         write_zsreg(c, R14, c->regs[R14]);
1015
1016         if(c->rx_buf[0])
1017         {
1018                 free_page((unsigned long)c->rx_buf[0]);
1019                 c->rx_buf[0]=NULL;
1020         }
1021         if(c->tx_dma_buf[0])
1022         {
1023                 free_page((unsigned  long)c->tx_dma_buf[0]);
1024                 c->tx_dma_buf[0]=NULL;
1025         }
1026         chk=read_zsreg(c,R0);
1027         write_zsreg(c, R3, c->regs[R3]);
1028         z8530_rtsdtr(c,0);
1029
1030         spin_unlock_irqrestore(c->lock, flags);
1031
1032         return 0;
1033 }
1034
1035 EXPORT_SYMBOL(z8530_sync_dma_close);
1036
1037 /**
1038  *      z8530_sync_txdma_open - Open a Z8530 for TX driven DMA
1039  *      @dev: The network device to attach
1040  *      @c: The Z8530 channel to configure in sync DMA mode.
1041  *
1042  *      Set up a Z85x30 device for synchronous DMA transmission. One
1043  *      ISA DMA channel must be available for this to work. The receive
1044  *      side is run in PIO mode, but then it has the bigger FIFO.
1045  */
1046
1047 int z8530_sync_txdma_open(struct net_device *dev, struct z8530_channel *c)
1048 {
1049         unsigned long cflags, dflags;
1050
1051         printk("Opening sync interface for TX-DMA\n");
1052         c->sync = 1;
1053         c->mtu = dev->mtu+64;
1054         c->count = 0;
1055         c->skb = NULL;
1056         c->skb2 = NULL;
1057
1058         /*
1059          *      Allocate the DMA flip buffers. Limit by page size.
1060          *      Everyone runs 1500 mtu or less on wan links so this
1061          *      should be fine.
1062          */
1063
1064         if(c->mtu  > PAGE_SIZE/2)
1065                 return -EMSGSIZE;
1066
1067         c->tx_dma_buf[0]=(void *)get_zeroed_page(GFP_KERNEL|GFP_DMA);
1068         if(c->tx_dma_buf[0]==NULL)
1069                 return -ENOBUFS;
1070
1071         c->tx_dma_buf[1] = c->tx_dma_buf[0] + PAGE_SIZE/2;
1072
1073
1074         spin_lock_irqsave(c->lock, cflags);
1075
1076         /*
1077          *      Load the PIO receive ring
1078          */
1079
1080         z8530_rx_done(c);
1081         z8530_rx_done(c);
1082
1083         /*
1084          *      Load the DMA interfaces up
1085          */
1086
1087         c->rxdma_on = 0;
1088         c->txdma_on = 0;
1089
1090         c->tx_dma_used=0;
1091         c->dma_num=0;
1092         c->dma_ready=1;
1093         c->dma_tx = 1;
1094
1095         /*
1096          *      Enable DMA control mode
1097          */
1098
1099         /*
1100          *      TX DMA via DIR/REQ
1101          */
1102         c->regs[R14]|= DTRREQ;
1103         write_zsreg(c, R14, c->regs[R14]);
1104
1105         c->regs[R1]&= ~TxINT_ENAB;
1106         write_zsreg(c, R1, c->regs[R1]);
1107
1108         /*
1109          *      Set up the DMA configuration
1110          */
1111
1112         dflags = claim_dma_lock();
1113
1114         disable_dma(c->txdma);
1115         clear_dma_ff(c->txdma);
1116         set_dma_mode(c->txdma, DMA_MODE_WRITE);
1117         disable_dma(c->txdma);
1118
1119         release_dma_lock(dflags);
1120
1121         /*
1122          *      Select the DMA interrupt handlers
1123          */
1124
1125         c->rxdma_on = 0;
1126         c->txdma_on = 1;
1127         c->tx_dma_used = 1;
1128
1129         c->irqs = &z8530_txdma_sync;
1130         z8530_rtsdtr(c,1);
1131         write_zsreg(c, R3, c->regs[R3]|RxENABLE);
1132         spin_unlock_irqrestore(c->lock, cflags);
1133
1134         return 0;
1135 }
1136
1137 EXPORT_SYMBOL(z8530_sync_txdma_open);
1138
1139 /**
1140  *      z8530_sync_txdma_close - Close down a TX driven DMA channel
1141  *      @dev: Network device to detach
1142  *      @c: Z8530 channel to move into discard mode
1143  *
1144  *      Shut down a DMA/PIO split mode synchronous interface. Halt the DMA,
1145  *      and  free the buffers.
1146  */
1147
1148 int z8530_sync_txdma_close(struct net_device *dev, struct z8530_channel *c)
1149 {
1150         unsigned long dflags, cflags;
1151         u8 chk;
1152
1153
1154         spin_lock_irqsave(c->lock, cflags);
1155
1156         c->irqs = &z8530_nop;
1157         c->max = 0;
1158         c->sync = 0;
1159
1160         /*
1161          *      Disable the PC DMA channels
1162          */
1163
1164         dflags = claim_dma_lock();
1165
1166         disable_dma(c->txdma);
1167         clear_dma_ff(c->txdma);
1168         c->txdma_on = 0;
1169         c->tx_dma_used = 0;
1170
1171         release_dma_lock(dflags);
1172
1173         /*
1174          *      Disable DMA control mode
1175          */
1176
1177         c->regs[R1]&= ~WT_RDY_ENAB;
1178         write_zsreg(c, R1, c->regs[R1]);
1179         c->regs[R1]&= ~(WT_RDY_RT|WT_FN_RDYFN|INT_ERR_Rx);
1180         c->regs[R1]|= INT_ALL_Rx;
1181         write_zsreg(c, R1, c->regs[R1]);
1182         c->regs[R14]&= ~DTRREQ;
1183         write_zsreg(c, R14, c->regs[R14]);
1184
1185         if(c->tx_dma_buf[0])
1186         {
1187                 free_page((unsigned long)c->tx_dma_buf[0]);
1188                 c->tx_dma_buf[0]=NULL;
1189         }
1190         chk=read_zsreg(c,R0);
1191         write_zsreg(c, R3, c->regs[R3]);
1192         z8530_rtsdtr(c,0);
1193
1194         spin_unlock_irqrestore(c->lock, cflags);
1195         return 0;
1196 }
1197
1198
1199 EXPORT_SYMBOL(z8530_sync_txdma_close);
1200
1201
1202 /*
1203  *      Name strings for Z8530 chips. SGI claim to have a 130, Zilog deny
1204  *      it exists...
1205  */
1206
1207 static const char *z8530_type_name[]={
1208         "Z8530",
1209         "Z85C30",
1210         "Z85230"
1211 };
1212
1213 /**
1214  *      z8530_describe - Uniformly describe a Z8530 port
1215  *      @dev: Z8530 device to describe
1216  *      @mapping: string holding mapping type (eg "I/O" or "Mem")
1217  *      @io: the port value in question
1218  *
1219  *      Describe a Z8530 in a standard format. We must pass the I/O as
1220  *      the port offset isn't predictable. The main reason for this function
1221  *      is to try and get a common format of report.
1222  */
1223
1224 void z8530_describe(struct z8530_dev *dev, char *mapping, unsigned long io)
1225 {
1226         pr_info("%s: %s found at %s 0x%lX, IRQ %d\n",
1227                 dev->name,
1228                 z8530_type_name[dev->type],
1229                 mapping,
1230                 Z8530_PORT_OF(io),
1231                 dev->irq);
1232 }
1233
1234 EXPORT_SYMBOL(z8530_describe);
1235
1236 /*
1237  *      Locked operation part of the z8530 init code
1238  */
1239
1240 static inline int do_z8530_init(struct z8530_dev *dev)
1241 {
1242         /* NOP the interrupt handlers first - we might get a
1243            floating IRQ transition when we reset the chip */
1244         dev->chanA.irqs=&z8530_nop;
1245         dev->chanB.irqs=&z8530_nop;
1246         dev->chanA.dcdcheck=DCD;
1247         dev->chanB.dcdcheck=DCD;
1248
1249         /* Reset the chip */
1250         write_zsreg(&dev->chanA, R9, 0xC0);
1251         udelay(200);
1252         /* Now check its valid */
1253         write_zsreg(&dev->chanA, R12, 0xAA);
1254         if(read_zsreg(&dev->chanA, R12)!=0xAA)
1255                 return -ENODEV;
1256         write_zsreg(&dev->chanA, R12, 0x55);
1257         if(read_zsreg(&dev->chanA, R12)!=0x55)
1258                 return -ENODEV;
1259
1260         dev->type=Z8530;
1261
1262         /*
1263          *      See the application note.
1264          */
1265
1266         write_zsreg(&dev->chanA, R15, 0x01);
1267
1268         /*
1269          *      If we can set the low bit of R15 then
1270          *      the chip is enhanced.
1271          */
1272
1273         if(read_zsreg(&dev->chanA, R15)==0x01)
1274         {
1275                 /* This C30 versus 230 detect is from Klaus Kudielka's dmascc */
1276                 /* Put a char in the fifo */
1277                 write_zsreg(&dev->chanA, R8, 0);
1278                 if(read_zsreg(&dev->chanA, R0)&Tx_BUF_EMP)
1279                         dev->type = Z85230;     /* Has a FIFO */
1280                 else
1281                         dev->type = Z85C30;     /* Z85C30, 1 byte FIFO */
1282         }
1283
1284         /*
1285          *      The code assumes R7' and friends are
1286          *      off. Use write_zsext() for these and keep
1287          *      this bit clear.
1288          */
1289
1290         write_zsreg(&dev->chanA, R15, 0);
1291
1292         /*
1293          *      At this point it looks like the chip is behaving
1294          */
1295
1296         memcpy(dev->chanA.regs, reg_init, 16);
1297         memcpy(dev->chanB.regs, reg_init ,16);
1298
1299         return 0;
1300 }
1301
1302 /**
1303  *      z8530_init - Initialise a Z8530 device
1304  *      @dev: Z8530 device to initialise.
1305  *
1306  *      Configure up a Z8530/Z85C30 or Z85230 chip. We check the device
1307  *      is present, identify the type and then program it to hopefully
1308  *      keep quite and behave. This matters a lot, a Z8530 in the wrong
1309  *      state will sometimes get into stupid modes generating 10Khz
1310  *      interrupt streams and the like.
1311  *
1312  *      We set the interrupt handler up to discard any events, in case
1313  *      we get them during reset or setp.
1314  *
1315  *      Return 0 for success, or a negative value indicating the problem
1316  *      in errno form.
1317  */
1318
1319 int z8530_init(struct z8530_dev *dev)
1320 {
1321         unsigned long flags;
1322         int ret;
1323
1324         /* Set up the chip level lock */
1325         spin_lock_init(&dev->lock);
1326         dev->chanA.lock = &dev->lock;
1327         dev->chanB.lock = &dev->lock;
1328
1329         spin_lock_irqsave(&dev->lock, flags);
1330         ret = do_z8530_init(dev);
1331         spin_unlock_irqrestore(&dev->lock, flags);
1332
1333         return ret;
1334 }
1335
1336
1337 EXPORT_SYMBOL(z8530_init);
1338
1339 /**
1340  *      z8530_shutdown - Shutdown a Z8530 device
1341  *      @dev: The Z8530 chip to shutdown
1342  *
1343  *      We set the interrupt handlers to silence any interrupts. We then
1344  *      reset the chip and wait 100uS to be sure the reset completed. Just
1345  *      in case the caller then tries to do stuff.
1346  *
1347  *      This is called without the lock held
1348  */
1349
1350 int z8530_shutdown(struct z8530_dev *dev)
1351 {
1352         unsigned long flags;
1353         /* Reset the chip */
1354
1355         spin_lock_irqsave(&dev->lock, flags);
1356         dev->chanA.irqs=&z8530_nop;
1357         dev->chanB.irqs=&z8530_nop;
1358         write_zsreg(&dev->chanA, R9, 0xC0);
1359         /* We must lock the udelay, the chip is offlimits here */
1360         udelay(100);
1361         spin_unlock_irqrestore(&dev->lock, flags);
1362         return 0;
1363 }
1364
1365 EXPORT_SYMBOL(z8530_shutdown);
1366
1367 /**
1368  *      z8530_channel_load - Load channel data
1369  *      @c: Z8530 channel to configure
1370  *      @rtable: table of register, value pairs
1371  *      FIXME: ioctl to allow user uploaded tables
1372  *
1373  *      Load a Z8530 channel up from the system data. We use +16 to
1374  *      indicate the "prime" registers. The value 255 terminates the
1375  *      table.
1376  */
1377
1378 int z8530_channel_load(struct z8530_channel *c, u8 *rtable)
1379 {
1380         unsigned long flags;
1381
1382         spin_lock_irqsave(c->lock, flags);
1383
1384         while(*rtable!=255)
1385         {
1386                 int reg=*rtable++;
1387                 if(reg>0x0F)
1388                         write_zsreg(c, R15, c->regs[15]|1);
1389                 write_zsreg(c, reg&0x0F, *rtable);
1390                 if(reg>0x0F)
1391                         write_zsreg(c, R15, c->regs[15]&~1);
1392                 c->regs[reg]=*rtable++;
1393         }
1394         c->rx_function=z8530_null_rx;
1395         c->skb=NULL;
1396         c->tx_skb=NULL;
1397         c->tx_next_skb=NULL;
1398         c->mtu=1500;
1399         c->max=0;
1400         c->count=0;
1401         c->status=read_zsreg(c, R0);
1402         c->sync=1;
1403         write_zsreg(c, R3, c->regs[R3]|RxENABLE);
1404
1405         spin_unlock_irqrestore(c->lock, flags);
1406         return 0;
1407 }
1408
1409 EXPORT_SYMBOL(z8530_channel_load);
1410
1411
1412 /**
1413  *      z8530_tx_begin - Begin packet transmission
1414  *      @c: The Z8530 channel to kick
1415  *
1416  *      This is the speed sensitive side of transmission. If we are called
1417  *      and no buffer is being transmitted we commence the next buffer. If
1418  *      nothing is queued we idle the sync.
1419  *
1420  *      Note: We are handling this code path in the interrupt path, keep it
1421  *      fast or bad things will happen.
1422  *
1423  *      Called with the lock held.
1424  */
1425
1426 static void z8530_tx_begin(struct z8530_channel *c)
1427 {
1428         unsigned long flags;
1429         if(c->tx_skb)
1430                 return;
1431
1432         c->tx_skb=c->tx_next_skb;
1433         c->tx_next_skb=NULL;
1434         c->tx_ptr=c->tx_next_ptr;
1435
1436         if(c->tx_skb==NULL)
1437         {
1438                 /* Idle on */
1439                 if(c->dma_tx)
1440                 {
1441                         flags=claim_dma_lock();
1442                         disable_dma(c->txdma);
1443                         /*
1444                          *      Check if we crapped out.
1445                          */
1446                         if (get_dma_residue(c->txdma))
1447                         {
1448                                 c->netdevice->stats.tx_dropped++;
1449                                 c->netdevice->stats.tx_fifo_errors++;
1450                         }
1451                         release_dma_lock(flags);
1452                 }
1453                 c->txcount=0;
1454         }
1455         else
1456         {
1457                 c->txcount=c->tx_skb->len;
1458
1459
1460                 if(c->dma_tx)
1461                 {
1462                         /*
1463                          *      FIXME. DMA is broken for the original 8530,
1464                          *      on the older parts we need to set a flag and
1465                          *      wait for a further TX interrupt to fire this
1466                          *      stage off
1467                          */
1468
1469                         flags=claim_dma_lock();
1470                         disable_dma(c->txdma);
1471
1472                         /*
1473                          *      These two are needed by the 8530/85C30
1474                          *      and must be issued when idling.
1475                          */
1476
1477                         if(c->dev->type!=Z85230)
1478                         {
1479                                 write_zsctrl(c, RES_Tx_CRC);
1480                                 write_zsctrl(c, RES_EOM_L);
1481                         }
1482                         write_zsreg(c, R10, c->regs[10]&~ABUNDER);
1483                         clear_dma_ff(c->txdma);
1484                         set_dma_addr(c->txdma, virt_to_bus(c->tx_ptr));
1485                         set_dma_count(c->txdma, c->txcount);
1486                         enable_dma(c->txdma);
1487                         release_dma_lock(flags);
1488                         write_zsctrl(c, RES_EOM_L);
1489                         write_zsreg(c, R5, c->regs[R5]|TxENAB);
1490                 }
1491                 else
1492                 {
1493
1494                         /* ABUNDER off */
1495                         write_zsreg(c, R10, c->regs[10]);
1496                         write_zsctrl(c, RES_Tx_CRC);
1497
1498                         while(c->txcount && (read_zsreg(c,R0)&Tx_BUF_EMP))
1499                         {
1500                                 write_zsreg(c, R8, *c->tx_ptr++);
1501                                 c->txcount--;
1502                         }
1503
1504                 }
1505         }
1506         /*
1507          *      Since we emptied tx_skb we can ask for more
1508          */
1509         netif_wake_queue(c->netdevice);
1510 }
1511
1512 /**
1513  *      z8530_tx_done - TX complete callback
1514  *      @c: The channel that completed a transmit.
1515  *
1516  *      This is called when we complete a packet send. We wake the queue,
1517  *      start the next packet going and then free the buffer of the existing
1518  *      packet. This code is fairly timing sensitive.
1519  *
1520  *      Called with the register lock held.
1521  */
1522
1523 static void z8530_tx_done(struct z8530_channel *c)
1524 {
1525         struct sk_buff *skb;
1526
1527         /* Actually this can happen.*/
1528         if (c->tx_skb == NULL)
1529                 return;
1530
1531         skb = c->tx_skb;
1532         c->tx_skb = NULL;
1533         z8530_tx_begin(c);
1534         c->netdevice->stats.tx_packets++;
1535         c->netdevice->stats.tx_bytes += skb->len;
1536         dev_consume_skb_irq(skb);
1537 }
1538
1539 /**
1540  *      z8530_null_rx - Discard a packet
1541  *      @c: The channel the packet arrived on
1542  *      @skb: The buffer
1543  *
1544  *      We point the receive handler at this function when idle. Instead
1545  *      of processing the frames we get to throw them away.
1546  */
1547
1548 void z8530_null_rx(struct z8530_channel *c, struct sk_buff *skb)
1549 {
1550         dev_kfree_skb_any(skb);
1551 }
1552
1553 EXPORT_SYMBOL(z8530_null_rx);
1554
1555 /**
1556  *      z8530_rx_done - Receive completion callback
1557  *      @c: The channel that completed a receive
1558  *
1559  *      A new packet is complete. Our goal here is to get back into receive
1560  *      mode as fast as possible. On the Z85230 we could change to using
1561  *      ESCC mode, but on the older chips we have no choice. We flip to the
1562  *      new buffer immediately in DMA mode so that the DMA of the next
1563  *      frame can occur while we are copying the previous buffer to an sk_buff
1564  *
1565  *      Called with the lock held
1566  */
1567
1568 static void z8530_rx_done(struct z8530_channel *c)
1569 {
1570         struct sk_buff *skb;
1571         int ct;
1572
1573         /*
1574          *      Is our receive engine in DMA mode
1575          */
1576
1577         if(c->rxdma_on)
1578         {
1579                 /*
1580                  *      Save the ready state and the buffer currently
1581                  *      being used as the DMA target
1582                  */
1583
1584                 int ready=c->dma_ready;
1585                 unsigned char *rxb=c->rx_buf[c->dma_num];
1586                 unsigned long flags;
1587
1588                 /*
1589                  *      Complete this DMA. Necessary to find the length
1590                  */
1591
1592                 flags=claim_dma_lock();
1593
1594                 disable_dma(c->rxdma);
1595                 clear_dma_ff(c->rxdma);
1596                 c->rxdma_on=0;
1597                 ct=c->mtu-get_dma_residue(c->rxdma);
1598                 if(ct<0)
1599                         ct=2;   /* Shit happens.. */
1600                 c->dma_ready=0;
1601
1602                 /*
1603                  *      Normal case: the other slot is free, start the next DMA
1604                  *      into it immediately.
1605                  */
1606
1607                 if(ready)
1608                 {
1609                         c->dma_num^=1;
1610                         set_dma_mode(c->rxdma, DMA_MODE_READ|0x10);
1611                         set_dma_addr(c->rxdma, virt_to_bus(c->rx_buf[c->dma_num]));
1612                         set_dma_count(c->rxdma, c->mtu);
1613                         c->rxdma_on = 1;
1614                         enable_dma(c->rxdma);
1615                         /* Stop any frames that we missed the head of
1616                            from passing */
1617                         write_zsreg(c, R0, RES_Rx_CRC);
1618                 }
1619                 else
1620                         /* Can't occur as we dont reenable the DMA irq until
1621                            after the flip is done */
1622                         netdev_warn(c->netdevice, "DMA flip overrun!\n");
1623
1624                 release_dma_lock(flags);
1625
1626                 /*
1627                  *      Shove the old buffer into an sk_buff. We can't DMA
1628                  *      directly into one on a PC - it might be above the 16Mb
1629                  *      boundary. Optimisation - we could check to see if we
1630                  *      can avoid the copy. Optimisation 2 - make the memcpy
1631                  *      a copychecksum.
1632                  */
1633
1634                 skb = dev_alloc_skb(ct);
1635                 if (skb == NULL) {
1636                         c->netdevice->stats.rx_dropped++;
1637                         netdev_warn(c->netdevice, "Memory squeeze\n");
1638                 } else {
1639                         skb_put(skb, ct);
1640                         skb_copy_to_linear_data(skb, rxb, ct);
1641                         c->netdevice->stats.rx_packets++;
1642                         c->netdevice->stats.rx_bytes += ct;
1643                 }
1644                 c->dma_ready = 1;
1645         } else {
1646                 RT_LOCK;
1647                 skb = c->skb;
1648
1649                 /*
1650                  *      The game we play for non DMA is similar. We want to
1651                  *      get the controller set up for the next packet as fast
1652                  *      as possible. We potentially only have one byte + the
1653                  *      fifo length for this. Thus we want to flip to the new
1654                  *      buffer and then mess around copying and allocating
1655                  *      things. For the current case it doesn't matter but
1656                  *      if you build a system where the sync irq isn't blocked
1657                  *      by the kernel IRQ disable then you need only block the
1658                  *      sync IRQ for the RT_LOCK area.
1659                  *
1660                  */
1661                 ct=c->count;
1662
1663                 c->skb = c->skb2;
1664                 c->count = 0;
1665                 c->max = c->mtu;
1666                 if (c->skb) {
1667                         c->dptr = c->skb->data;
1668                         c->max = c->mtu;
1669                 } else {
1670                         c->count = 0;
1671                         c->max = 0;
1672                 }
1673                 RT_UNLOCK;
1674
1675                 c->skb2 = dev_alloc_skb(c->mtu);
1676                 if (c->skb2 == NULL)
1677                         netdev_warn(c->netdevice, "memory squeeze\n");
1678                 else
1679                         skb_put(c->skb2, c->mtu);
1680                 c->netdevice->stats.rx_packets++;
1681                 c->netdevice->stats.rx_bytes += ct;
1682         }
1683         /*
1684          *      If we received a frame we must now process it.
1685          */
1686         if (skb) {
1687                 skb_trim(skb, ct);
1688                 c->rx_function(c, skb);
1689         } else {
1690                 c->netdevice->stats.rx_dropped++;
1691                 netdev_err(c->netdevice, "Lost a frame\n");
1692         }
1693 }
1694
1695 /**
1696  *      spans_boundary - Check a packet can be ISA DMA'd
1697  *      @skb: The buffer to check
1698  *
1699  *      Returns true if the buffer cross a DMA boundary on a PC. The poor
1700  *      thing can only DMA within a 64K block not across the edges of it.
1701  */
1702
1703 static inline int spans_boundary(struct sk_buff *skb)
1704 {
1705         unsigned long a=(unsigned long)skb->data;
1706         a^=(a+skb->len);
1707         if(a&0x00010000)        /* If the 64K bit is different.. */
1708                 return 1;
1709         return 0;
1710 }
1711
1712 /**
1713  *      z8530_queue_xmit - Queue a packet
1714  *      @c: The channel to use
1715  *      @skb: The packet to kick down the channel
1716  *
1717  *      Queue a packet for transmission. Because we have rather
1718  *      hard to hit interrupt latencies for the Z85230 per packet
1719  *      even in DMA mode we do the flip to DMA buffer if needed here
1720  *      not in the IRQ.
1721  *
1722  *      Called from the network code. The lock is not held at this
1723  *      point.
1724  */
1725
1726 netdev_tx_t z8530_queue_xmit(struct z8530_channel *c, struct sk_buff *skb)
1727 {
1728         unsigned long flags;
1729
1730         netif_stop_queue(c->netdevice);
1731         if(c->tx_next_skb)
1732                 return NETDEV_TX_BUSY;
1733
1734
1735         /* PC SPECIFIC - DMA limits */
1736
1737         /*
1738          *      If we will DMA the transmit and its gone over the ISA bus
1739          *      limit, then copy to the flip buffer
1740          */
1741
1742         if(c->dma_tx && ((unsigned long)(virt_to_bus(skb->data+skb->len))>=16*1024*1024 || spans_boundary(skb)))
1743         {
1744                 /*
1745                  *      Send the flip buffer, and flip the flippy bit.
1746                  *      We don't care which is used when just so long as
1747                  *      we never use the same buffer twice in a row. Since
1748                  *      only one buffer can be going out at a time the other
1749                  *      has to be safe.
1750                  */
1751                 c->tx_next_ptr=c->tx_dma_buf[c->tx_dma_used];
1752                 c->tx_dma_used^=1;      /* Flip temp buffer */
1753                 skb_copy_from_linear_data(skb, c->tx_next_ptr, skb->len);
1754         }
1755         else
1756                 c->tx_next_ptr=skb->data;
1757         RT_LOCK;
1758         c->tx_next_skb=skb;
1759         RT_UNLOCK;
1760
1761         spin_lock_irqsave(c->lock, flags);
1762         z8530_tx_begin(c);
1763         spin_unlock_irqrestore(c->lock, flags);
1764
1765         return NETDEV_TX_OK;
1766 }
1767
1768 EXPORT_SYMBOL(z8530_queue_xmit);
1769
1770 /*
1771  *      Module support
1772  */
1773 static const char banner[] __initconst =
1774         KERN_INFO "Generic Z85C30/Z85230 interface driver v0.02\n";
1775
1776 static int __init z85230_init_driver(void)
1777 {
1778         printk(banner);
1779         return 0;
1780 }
1781 module_init(z85230_init_driver);
1782
1783 static void __exit z85230_cleanup_driver(void)
1784 {
1785 }
1786 module_exit(z85230_cleanup_driver);
1787
1788 MODULE_AUTHOR("Red Hat Inc.");
1789 MODULE_DESCRIPTION("Z85x30 synchronous driver core");
1790 MODULE_LICENSE("GPL");