drivers/net/ethernet/realtek/atp.c

   1 /* atp.c: Attached (pocket) ethernet adapter driver for linux. */
   2 /*
   3         This is a driver for commonly OEM pocket (parallel port)
   4         ethernet adapters based on the Realtek RTL8002 and RTL8012 chips.
   5
   6         Written 1993-2000 by Donald Becker.
   7
   8         This software may be used and distributed according to the terms of
   9         the GNU General Public License (GPL), incorporated herein by reference.
  10         Drivers based on or derived from this code fall under the GPL and must
  11         retain the authorship, copyright and license notice.  This file is not
  12         a complete program and may only be used when the entire operating
  13         system is licensed under the GPL.
  14
  15         Copyright 1993 United States Government as represented by the Director,
  16         National Security Agency.  Copyright 1994-2000 retained by the original
  17         author, Donald Becker. The timer-based reset code was supplied in 1995
  18         by Bill Carlson, wwc@super.org.
  19
  20         The author may be reached as becker@scyld.com, or C/O
  21         Scyld Computing Corporation
  22         410 Severn Ave., Suite 210
  23         Annapolis MD 21403
  24
  25         Support information and updates available at
  26         http://www.scyld.com/network/atp.html
  27
  28
  29         Modular support/softnet added by Alan Cox.
  30         _bit abuse fixed up by Alan Cox
  31
  32 */
  33
  34 static const char version[] =
  35 "atp.c:v1.09=ac 2002/10/01 Donald Becker <becker@scyld.com>\n";
  36
  37 /* The user-configurable values.
  38    These may be modified when a driver module is loaded.*/
  39
  40 static int debug = 1;                   /* 1 normal messages, 0 quiet .. 7 verbose. */
  41 #define net_debug debug
  42
  43 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
  44 static int max_interrupt_work = 15;
  45
  46 #define NUM_UNITS 2
  47 /* The standard set of ISA module parameters. */
  48 static int io[NUM_UNITS];
  49 static int irq[NUM_UNITS];
  50 static int xcvr[NUM_UNITS];                     /* The data transfer mode. */
  51
  52 /* Operational parameters that are set at compile time. */
  53
  54 /* Time in jiffies before concluding the transmitter is hung. */
  55 #define TX_TIMEOUT  (400*HZ/1000)
  56
  57 /*
  58         This file is a device driver for the RealTek (aka AT-Lan-Tec) pocket
  59         ethernet adapter.  This is a common low-cost OEM pocket ethernet
  60         adapter, sold under many names.
  61
  62   Sources:
  63         This driver was written from the packet driver assembly code provided by
  64         Vincent Bono of AT-Lan-Tec.      Ever try to figure out how a complicated
  65         device works just from the assembly code?  It ain't pretty.  The following
  66         description is written based on guesses and writing lots of special-purpose
  67         code to test my theorized operation.
  68
  69         In 1997 Realtek made available the documentation for the second generation
  70         RTL8012 chip, which has lead to several driver improvements.
  71           http://www.realtek.com.tw/
  72
  73                                         Theory of Operation
  74
  75         The RTL8002 adapter seems to be built around a custom spin of the SEEQ
  76         controller core.  It probably has a 16K or 64K internal packet buffer, of
  77         which the first 4K is devoted to transmit and the rest to receive.
  78         The controller maintains the queue of received packet and the packet buffer
  79         access pointer internally, with only 'reset to beginning' and 'skip to next
  80         packet' commands visible.  The transmit packet queue holds two (or more?)
  81         packets: both 'retransmit this packet' (due to collision) and 'transmit next
  82         packet' commands must be started by hand.
  83
  84         The station address is stored in a standard bit-serial EEPROM which must be
  85         read (ughh) by the device driver.  (Provisions have been made for
  86         substituting a 74S288 PROM, but I haven't gotten reports of any models
  87         using it.)  Unlike built-in devices, a pocket adapter can temporarily lose
  88         power without indication to the device driver.  The major effect is that
  89         the station address, receive filter (promiscuous, etc.) and transceiver
  90         must be reset.
  91
  92         The controller itself has 16 registers, some of which use only the lower
  93         bits.  The registers are read and written 4 bits at a time.  The four bit
  94         register address is presented on the data lines along with a few additional
  95         timing and control bits.  The data is then read from status port or written
  96         to the data port.
  97
  98         Correction: the controller has two banks of 16 registers.  The second
  99         bank contains only the multicast filter table (now used) and the EEPROM
 100         access registers.
 101
 102         Since the bulk data transfer of the actual packets through the slow
 103         parallel port dominates the driver's running time, four distinct data
 104         (non-register) transfer modes are provided by the adapter, two in each
 105         direction.  In the first mode timing for the nibble transfers is
 106         provided through the data port.  In the second mode the same timing is
 107         provided through the control port.  In either case the data is read from
 108         the status port and written to the data port, just as it is accessing
 109         registers.
 110
 111         In addition to the basic data transfer methods, several more are modes are
 112         created by adding some delay by doing multiple reads of the data to allow
 113         it to stabilize.  This delay seems to be needed on most machines.
 114
 115         The data transfer mode is stored in the 'dev->if_port' field.  Its default
 116         value is '4'.  It may be overridden at boot-time using the third parameter
 117         to the "ether=..." initialization.
 118
 119         The header file <atp.h> provides inline functions that encapsulate the
 120         register and data access methods.  These functions are hand-tuned to
 121         generate reasonable object code.  This header file also documents my
 122         interpretations of the device registers.
 123 */
 124
 125 #include <linux/kernel.h>
 126 #include <linux/module.h>
 127 #include <linux/types.h>
 128 #include <linux/fcntl.h>
 129 #include <linux/interrupt.h>
 130 #include <linux/ioport.h>
 131 #include <linux/in.h>
 132 #include <linux/string.h>
 133 #include <linux/errno.h>
 134 #include <linux/init.h>
 135 #include <linux/crc32.h>
 136 #include <linux/netdevice.h>
 137 #include <linux/etherdevice.h>
 138 #include <linux/skbuff.h>
 139 #include <linux/spinlock.h>
 140 #include <linux/delay.h>
 141 #include <linux/bitops.h>
 142
 143 #include <asm/system.h>
 144 #include <asm/io.h>
 145 #include <asm/dma.h>
 146
 147 #include "atp.h"
 148
 149 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 150 MODULE_DESCRIPTION("RealTek RTL8002/8012 parallel port Ethernet driver");
 151 MODULE_LICENSE("GPL");
 152
 153 module_param(max_interrupt_work, int, 0);
 154 module_param(debug, int, 0);
 155 module_param_array(io, int, NULL, 0);
 156 module_param_array(irq, int, NULL, 0);
 157 module_param_array(xcvr, int, NULL, 0);
 158 MODULE_PARM_DESC(max_interrupt_work, "ATP maximum events handled per interrupt");
 159 MODULE_PARM_DESC(debug, "ATP debug level (0-7)");
 160 MODULE_PARM_DESC(io, "ATP I/O base address(es)");
 161 MODULE_PARM_DESC(irq, "ATP IRQ number(s)");
 162 MODULE_PARM_DESC(xcvr, "ATP transceiver(s) (0=internal, 1=external)");
 163
 164 /* The number of low I/O ports used by the ethercard. */
 165 #define ETHERCARD_TOTAL_SIZE    3
 166
 167 /* Sequence to switch an 8012 from printer mux to ethernet mode. */
 168 static char mux_8012[] = { 0xff, 0xf7, 0xff, 0xfb, 0xf3, 0xfb, 0xff, 0xf7,};
 169
 170 struct net_local {
 171     spinlock_t lock;
 172     struct net_device *next_module;
 173     struct timer_list timer;    /* Media selection timer. */
 174     long last_rx_time;          /* Last Rx, in jiffies, to handle Rx hang. */
 175     int saved_tx_size;
 176     unsigned int tx_unit_busy:1;
 177     unsigned char re_tx,        /* Number of packet retransmissions. */
 178                 addr_mode,              /* Current Rx filter e.g. promiscuous, etc. */
 179                 pac_cnt_in_tx_buf;
 180 };
 181
 182 /* This code, written by wwc@super.org, resets the adapter every
 183    TIMED_CHECKER ticks.  This recovers from an unknown error which
 184    hangs the device. */
 185 #define TIMED_CHECKER (HZ/4)
 186 #ifdef TIMED_CHECKER
 187 #include <linux/timer.h>
 188 static void atp_timed_checker(unsigned long ignored);
 189 #endif
 190
 191 /* Index to functions, as function prototypes. */
 192
 193 static int atp_probe1(long ioaddr);
 194 static void get_node_ID(struct net_device *dev);
 195 static unsigned short eeprom_op(long ioaddr, unsigned int cmd);
 196 static int net_open(struct net_device *dev);
 197 static void hardware_init(struct net_device *dev);
 198 static void write_packet(long ioaddr, int length, unsigned char *packet, int pad, int mode);
 199 static void trigger_send(long ioaddr, int length);
 200 static netdev_tx_t atp_send_packet(struct sk_buff *skb,
 201                                    struct net_device *dev);
 202 static irqreturn_t atp_interrupt(int irq, void *dev_id);
 203 static void net_rx(struct net_device *dev);
 204 static void read_block(long ioaddr, int length, unsigned char *buffer, int data_mode);
 205 static int net_close(struct net_device *dev);
 206 static void set_rx_mode(struct net_device *dev);
 207 static void tx_timeout(struct net_device *dev);
 208
 209
 210 /* A list of all installed ATP devices, for removing the driver module. */
 211 static struct net_device *root_atp_dev;
 212
 213 /* Check for a network adapter of this type, and return '0' iff one exists.
 214    If dev->base_addr == 0, probe all likely locations.
 215    If dev->base_addr == 1, always return failure.
 216    If dev->base_addr == 2, allocate space for the device and return success
 217    (detachable devices only).
 218
 219    FIXME: we should use the parport layer for this
 220    */
 221 static int __init atp_init(void)
 222 {
 223         int *port, ports[] = {0x378, 0x278, 0x3bc, 0};
 224         int base_addr = io[0];
 225
 226         if (base_addr > 0x1ff)          /* Check a single specified location. */
 227                 return atp_probe1(base_addr);
 228         else if (base_addr == 1)        /* Don't probe at all. */
 229                 return -ENXIO;
 230
 231         for (port = ports; *port; port++) {
 232                 long ioaddr = *port;
 233                 outb(0x57, ioaddr + PAR_DATA);
 234                 if (inb(ioaddr + PAR_DATA) != 0x57)
 235                         continue;
 236                 if (atp_probe1(ioaddr) == 0)
 237                         return 0;
 238         }
 239
 240         return -ENODEV;
 241 }
 242
 243 static const struct net_device_ops atp_netdev_ops = {
 244         .ndo_open               = net_open,
 245         .ndo_stop               = net_close,
 246         .ndo_start_xmit         = atp_send_packet,
 247         .ndo_set_rx_mode        = set_rx_mode,
 248         .ndo_tx_timeout         = tx_timeout,
 249         .ndo_change_mtu         = eth_change_mtu,
 250         .ndo_set_mac_address    = eth_mac_addr,
 251         .ndo_validate_addr      = eth_validate_addr,
 252 };
 253
 254 static int __init atp_probe1(long ioaddr)
 255 {
 256         struct net_device *dev = NULL;
 257         struct net_local *lp;
 258         int saved_ctrl_reg, status, i;
 259         int res;
 260
 261         outb(0xff, ioaddr + PAR_DATA);
 262         /* Save the original value of the Control register, in case we guessed
 263            wrong. */
 264         saved_ctrl_reg = inb(ioaddr + PAR_CONTROL);
 265         if (net_debug > 3)
 266                 printk("atp: Control register was %#2.2x.\n", saved_ctrl_reg);
 267         /* IRQEN=0, SLCTB=high INITB=high, AUTOFDB=high, STBB=high. */
 268         outb(0x04, ioaddr + PAR_CONTROL);
 269 #ifndef final_version
 270         if (net_debug > 3) {
 271                 /* Turn off the printer multiplexer on the 8012. */
 272                 for (i = 0; i < 8; i++)
 273                         outb(mux_8012[i], ioaddr + PAR_DATA);
 274                 write_reg(ioaddr, MODSEL, 0x00);
 275                 printk("atp: Registers are ");
 276                 for (i = 0; i < 32; i++)
 277                         printk(" %2.2x", read_nibble(ioaddr, i));
 278                 printk(".\n");
 279         }
 280 #endif
 281         /* Turn off the printer multiplexer on the 8012. */
 282         for (i = 0; i < 8; i++)
 283                 outb(mux_8012[i], ioaddr + PAR_DATA);
 284         write_reg_high(ioaddr, CMR1, CMR1h_RESET);
 285         /* udelay() here? */
 286         status = read_nibble(ioaddr, CMR1);
 287
 288         if (net_debug > 3) {
 289                 printk(KERN_DEBUG "atp: Status nibble was %#2.2x..", status);
 290                 for (i = 0; i < 32; i++)
 291                         printk(" %2.2x", read_nibble(ioaddr, i));
 292                 printk("\n");
 293         }
 294
 295         if ((status & 0x78) != 0x08) {
 296                 /* The pocket adapter probe failed, restore the control register. */
 297                 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
 298                 return -ENODEV;
 299         }
 300         status = read_nibble(ioaddr, CMR2_h);
 301         if ((status & 0x78) != 0x10) {
 302                 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
 303                 return -ENODEV;
 304         }
 305
 306         dev = alloc_etherdev(sizeof(struct net_local));
 307         if (!dev)
 308                 return -ENOMEM;
 309
 310         /* Find the IRQ used by triggering an interrupt. */
 311         write_reg_byte(ioaddr, CMR2, 0x01);                     /* No accept mode, IRQ out. */
 312         write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);  /* Enable Tx and Rx. */
 313
 314         /* Omit autoIRQ routine for now. Use "table lookup" instead.  Uhgggh. */
 315         if (irq[0])
 316                 dev->irq = irq[0];
 317         else if (ioaddr == 0x378)
 318                 dev->irq = 7;
 319         else
 320                 dev->irq = 5;
 321         write_reg_high(ioaddr, CMR1, CMR1h_TxRxOFF); /* Disable Tx and Rx units. */
 322         write_reg(ioaddr, CMR2, CMR2_NULL);
 323
 324         dev->base_addr = ioaddr;
 325
 326         /* Read the station address PROM.  */
 327         get_node_ID(dev);
 328
 329 #ifndef MODULE
 330         if (net_debug)
 331                 printk(KERN_INFO "%s", version);
 332 #endif
 333
 334         printk(KERN_NOTICE "%s: Pocket adapter found at %#3lx, IRQ %d, "
 335                "SAPROM %pM.\n",
 336                dev->name, dev->base_addr, dev->irq, dev->dev_addr);
 337
 338         /* Reset the ethernet hardware and activate the printer pass-through. */
 339         write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
 340
 341         lp = netdev_priv(dev);
 342         lp->addr_mode = CMR2h_Normal;
 343         spin_lock_init(&lp->lock);
 344
 345         /* For the ATP adapter the "if_port" is really the data transfer mode. */
 346         if (xcvr[0])
 347                 dev->if_port = xcvr[0];
 348         else
 349                 dev->if_port = (dev->mem_start & 0xf) ? (dev->mem_start & 0x7) : 4;
 350         if (dev->mem_end & 0xf)
 351                 net_debug = dev->mem_end & 7;
 352
 353         dev->netdev_ops         = &atp_netdev_ops;
 354         dev->watchdog_timeo     = TX_TIMEOUT;
 355
 356         res = register_netdev(dev);
 357         if (res) {
 358                 free_netdev(dev);
 359                 return res;
 360         }
 361
 362         lp->next_module = root_atp_dev;
 363         root_atp_dev = dev;
 364
 365         return 0;
 366 }
 367
 368 /* Read the station address PROM, usually a word-wide EEPROM. */
 369 static void __init get_node_ID(struct net_device *dev)
 370 {
 371         long ioaddr = dev->base_addr;
 372         int sa_offset = 0;
 373         int i;
 374
 375         write_reg(ioaddr, CMR2, CMR2_EEPROM);     /* Point to the EEPROM control registers. */
 376
 377         /* Some adapters have the station address at offset 15 instead of offset
 378            zero.  Check for it, and fix it if needed. */
 379         if (eeprom_op(ioaddr, EE_READ(0)) == 0xffff)
 380                 sa_offset = 15;
 381
 382         for (i = 0; i < 3; i++)
 383                 ((__be16 *)dev->dev_addr)[i] =
 384                         cpu_to_be16(eeprom_op(ioaddr, EE_READ(sa_offset + i)));
 385
 386         write_reg(ioaddr, CMR2, CMR2_NULL);
 387 }
 388
 389 /*
 390   An EEPROM read command starts by shifting out 0x60+address, and then
 391   shifting in the serial data. See the NatSemi databook for details.
 392  *                 ________________
 393  * CS : __|
 394  *                         ___     ___
 395  * CLK: ______|   |___|   |
 396  *               __ _______ _______
 397  * DI :  __X_______X_______X
 398  * DO :  _________X_______X
 399  */
 400
 401 static unsigned short __init eeprom_op(long ioaddr, u32 cmd)
 402 {
 403         unsigned eedata_out = 0;
 404         int num_bits = EE_CMD_SIZE;
 405
 406         while (--num_bits >= 0) {
 407                 char outval = (cmd & (1<<num_bits)) ? EE_DATA_WRITE : 0;
 408                 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_LOW);
 409                 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_HIGH);
 410                 eedata_out <<= 1;
 411                 if (read_nibble(ioaddr, PROM_DATA) & EE_DATA_READ)
 412                         eedata_out++;
 413         }
 414         write_reg_high(ioaddr, PROM_CMD, EE_CLK_LOW & ~EE_CS);
 415         return eedata_out;
 416 }
 417
 418
 419 /* Open/initialize the board.  This is called (in the current kernel)
 420    sometime after booting when the 'ifconfig' program is run.
 421
 422    This routine sets everything up anew at each open, even
 423    registers that "should" only need to be set once at boot, so that
 424    there is non-reboot way to recover if something goes wrong.
 425
 426    This is an attachable device: if there is no private entry then it wasn't
 427    probed for at boot-time, and we need to probe for it again.
 428    */
 429 static int net_open(struct net_device *dev)
 430 {
 431         struct net_local *lp = netdev_priv(dev);
 432         int ret;
 433
 434         /* The interrupt line is turned off (tri-stated) when the device isn't in
 435            use.  That's especially important for "attached" interfaces where the
 436            port or interrupt may be shared. */
 437         ret = request_irq(dev->irq, atp_interrupt, 0, dev->name, dev);
 438         if (ret)
 439                 return ret;
 440
 441         hardware_init(dev);
 442
 443         init_timer(&lp->timer);
 444         lp->timer.expires = jiffies + TIMED_CHECKER;
 445         lp->timer.data = (unsigned long)dev;
 446         lp->timer.function = atp_timed_checker;    /* timer handler */
 447         add_timer(&lp->timer);
 448
 449         netif_start_queue(dev);
 450         return 0;
 451 }
 452
 453 /* This routine resets the hardware.  We initialize everything, assuming that
 454    the hardware may have been temporarily detached. */
 455 static void hardware_init(struct net_device *dev)
 456 {
 457         struct net_local *lp = netdev_priv(dev);
 458         long ioaddr = dev->base_addr;
 459     int i;
 460
 461         /* Turn off the printer multiplexer on the 8012. */
 462         for (i = 0; i < 8; i++)
 463                 outb(mux_8012[i], ioaddr + PAR_DATA);
 464         write_reg_high(ioaddr, CMR1, CMR1h_RESET);
 465
 466     for (i = 0; i < 6; i++)
 467                 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
 468
 469         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 470
 471         if (net_debug > 2) {
 472                 printk(KERN_DEBUG "%s: Reset: current Rx mode %d.\n", dev->name,
 473                            (read_nibble(ioaddr, CMR2_h) >> 3) & 0x0f);
 474         }
 475
 476     write_reg(ioaddr, CMR2, CMR2_IRQOUT);
 477     write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
 478
 479         /* Enable the interrupt line from the serial port. */
 480         outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 481
 482         /* Unmask the interesting interrupts. */
 483     write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
 484     write_reg_high(ioaddr, IMR, ISRh_RxErr);
 485
 486         lp->tx_unit_busy = 0;
 487     lp->pac_cnt_in_tx_buf = 0;
 488         lp->saved_tx_size = 0;
 489 }
 490
 491 static void trigger_send(long ioaddr, int length)
 492 {
 493         write_reg_byte(ioaddr, TxCNT0, length & 0xff);
 494         write_reg(ioaddr, TxCNT1, length >> 8);
 495         write_reg(ioaddr, CMR1, CMR1_Xmit);
 496 }
 497
 498 static void write_packet(long ioaddr, int length, unsigned char *packet, int pad_len, int data_mode)
 499 {
 500     if (length & 1)
 501     {
 502         length++;
 503         pad_len++;
 504     }
 505
 506     outb(EOC+MAR, ioaddr + PAR_DATA);
 507     if ((data_mode & 1) == 0) {
 508                 /* Write the packet out, starting with the write addr. */
 509                 outb(WrAddr+MAR, ioaddr + PAR_DATA);
 510                 do {
 511                         write_byte_mode0(ioaddr, *packet++);
 512                 } while (--length > pad_len) ;
 513                 do {
 514                         write_byte_mode0(ioaddr, 0);
 515                 } while (--length > 0) ;
 516     } else {
 517                 /* Write the packet out in slow mode. */
 518                 unsigned char outbyte = *packet++;
 519
 520                 outb(Ctrl_LNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 521                 outb(WrAddr+MAR, ioaddr + PAR_DATA);
 522
 523                 outb((outbyte & 0x0f)|0x40, ioaddr + PAR_DATA);
 524                 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
 525                 outbyte >>= 4;
 526                 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
 527                 outb(Ctrl_HNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 528                 while (--length > pad_len)
 529                         write_byte_mode1(ioaddr, *packet++);
 530                 while (--length > 0)
 531                         write_byte_mode1(ioaddr, 0);
 532     }
 533     /* Terminate the Tx frame.  End of write: ECB. */
 534     outb(0xff, ioaddr + PAR_DATA);
 535     outb(Ctrl_HNibWrite | Ctrl_SelData | Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 536 }
 537
 538 static void tx_timeout(struct net_device *dev)
 539 {
 540         long ioaddr = dev->base_addr;
 541
 542         printk(KERN_WARNING "%s: Transmit timed out, %s?\n", dev->name,
 543                    inb(ioaddr + PAR_CONTROL) & 0x10 ? "network cable problem"
 544                    :  "IRQ conflict");
 545         dev->stats.tx_errors++;
 546         /* Try to restart the adapter. */
 547         hardware_init(dev);
 548         dev->trans_start = jiffies; /* prevent tx timeout */
 549         netif_wake_queue(dev);
 550         dev->stats.tx_errors++;
 551 }
 552
 553 static netdev_tx_t atp_send_packet(struct sk_buff *skb,
 554                                    struct net_device *dev)
 555 {
 556         struct net_local *lp = netdev_priv(dev);
 557         long ioaddr = dev->base_addr;
 558         int length;
 559         unsigned long flags;
 560
 561         length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 562
 563         netif_stop_queue(dev);
 564
 565         /* Disable interrupts by writing 0x00 to the Interrupt Mask Register.
 566            This sequence must not be interrupted by an incoming packet. */
 567
 568         spin_lock_irqsave(&lp->lock, flags);
 569         write_reg(ioaddr, IMR, 0);
 570         write_reg_high(ioaddr, IMR, 0);
 571         spin_unlock_irqrestore(&lp->lock, flags);
 572
 573         write_packet(ioaddr, length, skb->data, length-skb->len, dev->if_port);
 574
 575         lp->pac_cnt_in_tx_buf++;
 576         if (lp->tx_unit_busy == 0) {
 577                 trigger_send(ioaddr, length);
 578                 lp->saved_tx_size = 0;                          /* Redundant */
 579                 lp->re_tx = 0;
 580                 lp->tx_unit_busy = 1;
 581         } else
 582                 lp->saved_tx_size = length;
 583         /* Re-enable the LPT interrupts. */
 584         write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
 585         write_reg_high(ioaddr, IMR, ISRh_RxErr);
 586
 587         dev_kfree_skb (skb);
 588         return NETDEV_TX_OK;
 589 }
 590
 591
 592 /* The typical workload of the driver:
 593    Handle the network interface interrupts. */
 594 static irqreturn_t atp_interrupt(int irq, void *dev_instance)
 595 {
 596         struct net_device *dev = dev_instance;
 597         struct net_local *lp;
 598         long ioaddr;
 599         static int num_tx_since_rx;
 600         int boguscount = max_interrupt_work;
 601         int handled = 0;
 602
 603         ioaddr = dev->base_addr;
 604         lp = netdev_priv(dev);
 605
 606         spin_lock(&lp->lock);
 607
 608         /* Disable additional spurious interrupts. */
 609         outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
 610
 611         /* The adapter's output is currently the IRQ line, switch it to data. */
 612         write_reg(ioaddr, CMR2, CMR2_NULL);
 613         write_reg(ioaddr, IMR, 0);
 614
 615         if (net_debug > 5) printk(KERN_DEBUG "%s: In interrupt ", dev->name);
 616     while (--boguscount > 0) {
 617                 int status = read_nibble(ioaddr, ISR);
 618                 if (net_debug > 5) printk("loop status %02x..", status);
 619
 620                 if (status & (ISR_RxOK<<3)) {
 621                         handled = 1;
 622                         write_reg(ioaddr, ISR, ISR_RxOK); /* Clear the Rx interrupt. */
 623                         do {
 624                                 int read_status = read_nibble(ioaddr, CMR1);
 625                                 if (net_debug > 6)
 626                                         printk("handling Rx packet %02x..", read_status);
 627                                 /* We acknowledged the normal Rx interrupt, so if the interrupt
 628                                    is still outstanding we must have a Rx error. */
 629                                 if (read_status & (CMR1_IRQ << 3)) { /* Overrun. */
 630                                         dev->stats.rx_over_errors++;
 631                                         /* Set to no-accept mode long enough to remove a packet. */
 632                                         write_reg_high(ioaddr, CMR2, CMR2h_OFF);
 633                                         net_rx(dev);
 634                                         /* Clear the interrupt and return to normal Rx mode. */
 635                                         write_reg_high(ioaddr, ISR, ISRh_RxErr);
 636                                         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 637                                 } else if ((read_status & (CMR1_BufEnb << 3)) == 0) {
 638                                         net_rx(dev);
 639                                         num_tx_since_rx = 0;
 640                                 } else
 641                                         break;
 642                         } while (--boguscount > 0);
 643                 } else if (status & ((ISR_TxErr + ISR_TxOK)<<3)) {
 644                         handled = 1;
 645                         if (net_debug > 6)  printk("handling Tx done..");
 646                         /* Clear the Tx interrupt.  We should check for too many failures
 647                            and reinitialize the adapter. */
 648                         write_reg(ioaddr, ISR, ISR_TxErr + ISR_TxOK);
 649                         if (status & (ISR_TxErr<<3)) {
 650                                 dev->stats.collisions++;
 651                                 if (++lp->re_tx > 15) {
 652                                         dev->stats.tx_aborted_errors++;
 653                                         hardware_init(dev);
 654                                         break;
 655                                 }
 656                                 /* Attempt to retransmit. */
 657                                 if (net_debug > 6)  printk("attempting to ReTx");
 658                                 write_reg(ioaddr, CMR1, CMR1_ReXmit + CMR1_Xmit);
 659                         } else {
 660                                 /* Finish up the transmit. */
 661                                 dev->stats.tx_packets++;
 662                                 lp->pac_cnt_in_tx_buf--;
 663                                 if ( lp->saved_tx_size) {
 664                                         trigger_send(ioaddr, lp->saved_tx_size);
 665                                         lp->saved_tx_size = 0;
 666                                         lp->re_tx = 0;
 667                                 } else
 668                                         lp->tx_unit_busy = 0;
 669                                 netif_wake_queue(dev);  /* Inform upper layers. */
 670                         }
 671                         num_tx_since_rx++;
 672                 } else if (num_tx_since_rx > 8 &&
 673                            time_after(jiffies, dev->last_rx + HZ)) {
 674                         if (net_debug > 2)
 675                                 printk(KERN_DEBUG "%s: Missed packet? No Rx after %d Tx and "
 676                                            "%ld jiffies status %02x  CMR1 %02x.\n", dev->name,
 677                                            num_tx_since_rx, jiffies - dev->last_rx, status,
 678                                            (read_nibble(ioaddr, CMR1) >> 3) & 15);
 679                         dev->stats.rx_missed_errors++;
 680                         hardware_init(dev);
 681                         num_tx_since_rx = 0;
 682                         break;
 683                 } else
 684                         break;
 685     }
 686
 687         /* This following code fixes a rare (and very difficult to track down)
 688            problem where the adapter forgets its ethernet address. */
 689         {
 690                 int i;
 691                 for (i = 0; i < 6; i++)
 692                         write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
 693 #if 0 && defined(TIMED_CHECKER)
 694                 mod_timer(&lp->timer, jiffies + TIMED_CHECKER);
 695 #endif
 696         }
 697
 698         /* Tell the adapter that it can go back to using the output line as IRQ. */
 699     write_reg(ioaddr, CMR2, CMR2_IRQOUT);
 700         /* Enable the physical interrupt line, which is sure to be low until.. */
 701         outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 702         /* .. we enable the interrupt sources. */
 703         write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
 704         write_reg_high(ioaddr, IMR, ISRh_RxErr);                        /* Hmmm, really needed? */
 705
 706         spin_unlock(&lp->lock);
 707
 708         if (net_debug > 5) printk("exiting interrupt.\n");
 709         return IRQ_RETVAL(handled);
 710 }
 711
 712 #ifdef TIMED_CHECKER
 713 /* This following code fixes a rare (and very difficult to track down)
 714    problem where the adapter forgets its ethernet address. */
 715 static void atp_timed_checker(unsigned long data)
 716 {
 717         struct net_device *dev = (struct net_device *)data;
 718         long ioaddr = dev->base_addr;
 719         struct net_local *lp = netdev_priv(dev);
 720         int tickssofar = jiffies - lp->last_rx_time;
 721         int i;
 722
 723         spin_lock(&lp->lock);
 724         if (tickssofar > 2*HZ) {
 725 #if 1
 726                 for (i = 0; i < 6; i++)
 727                         write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
 728                 lp->last_rx_time = jiffies;
 729 #else
 730                 for (i = 0; i < 6; i++)
 731                         if (read_cmd_byte(ioaddr, PAR0 + i) != atp_timed_dev->dev_addr[i])
 732                                 {
 733                         struct net_local *lp = netdev_priv(atp_timed_dev);
 734                         write_reg_byte(ioaddr, PAR0 + i, atp_timed_dev->dev_addr[i]);
 735                         if (i == 2)
 736                           dev->stats.tx_errors++;
 737                         else if (i == 3)
 738                           dev->stats.tx_dropped++;
 739                         else if (i == 4)
 740                           dev->stats.collisions++;
 741                         else
 742                           dev->stats.rx_errors++;
 743                   }
 744 #endif
 745         }
 746         spin_unlock(&lp->lock);
 747         lp->timer.expires = jiffies + TIMED_CHECKER;
 748         add_timer(&lp->timer);
 749 }
 750 #endif
 751
 752 /* We have a good packet(s), get it/them out of the buffers. */
 753 static void net_rx(struct net_device *dev)
 754 {
 755         struct net_local *lp = netdev_priv(dev);
 756         long ioaddr = dev->base_addr;
 757         struct rx_header rx_head;
 758
 759         /* Process the received packet. */
 760         outb(EOC+MAR, ioaddr + PAR_DATA);
 761         read_block(ioaddr, 8, (unsigned char*)&rx_head, dev->if_port);
 762         if (net_debug > 5)
 763                 printk(KERN_DEBUG " rx_count %04x %04x %04x %04x..", rx_head.pad,
 764                            rx_head.rx_count, rx_head.rx_status, rx_head.cur_addr);
 765         if ((rx_head.rx_status & 0x77) != 0x01) {
 766                 dev->stats.rx_errors++;
 767                 if (rx_head.rx_status & 0x0004) dev->stats.rx_frame_errors++;
 768                 else if (rx_head.rx_status & 0x0002) dev->stats.rx_crc_errors++;
 769                 if (net_debug > 3)
 770                         printk(KERN_DEBUG "%s: Unknown ATP Rx error %04x.\n",
 771                                    dev->name, rx_head.rx_status);
 772                 if  (rx_head.rx_status & 0x0020) {
 773                         dev->stats.rx_fifo_errors++;
 774                         write_reg_high(ioaddr, CMR1, CMR1h_TxENABLE);
 775                         write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
 776                 } else if (rx_head.rx_status & 0x0050)
 777                         hardware_init(dev);
 778                 return;
 779         } else {
 780                 /* Malloc up new buffer. The "-4" omits the FCS (CRC). */
 781                 int pkt_len = (rx_head.rx_count & 0x7ff) - 4;
 782                 struct sk_buff *skb;
 783
 784                 skb = dev_alloc_skb(pkt_len + 2);
 785                 if (skb == NULL) {
 786                         printk(KERN_ERR "%s: Memory squeeze, dropping packet.\n",
 787                                    dev->name);
 788                         dev->stats.rx_dropped++;
 789                         goto done;
 790                 }
 791
 792                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
 793                 read_block(ioaddr, pkt_len, skb_put(skb,pkt_len), dev->if_port);
 794                 skb->protocol = eth_type_trans(skb, dev);
 795                 netif_rx(skb);
 796                 dev->last_rx = jiffies;
 797                 dev->stats.rx_packets++;
 798                 dev->stats.rx_bytes += pkt_len;
 799         }
 800  done:
 801         write_reg(ioaddr, CMR1, CMR1_NextPkt);
 802         lp->last_rx_time = jiffies;
 803 }
 804
 805 static void read_block(long ioaddr, int length, unsigned char *p, int data_mode)
 806 {
 807         if (data_mode <= 3) { /* Mode 0 or 1 */
 808                 outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
 809                 outb(length == 8  ?  RdAddr | HNib | MAR  :  RdAddr | MAR,
 810                          ioaddr + PAR_DATA);
 811                 if (data_mode <= 1) { /* Mode 0 or 1 */
 812                         do { *p++ = read_byte_mode0(ioaddr); } while (--length > 0);
 813                 } else { /* Mode 2 or 3 */
 814                         do { *p++ = read_byte_mode2(ioaddr); } while (--length > 0);
 815                 }
 816         } else if (data_mode <= 5) {
 817                 do { *p++ = read_byte_mode4(ioaddr); } while (--length > 0);
 818         } else {
 819                 do { *p++ = read_byte_mode6(ioaddr); } while (--length > 0);
 820         }
 821
 822         outb(EOC+HNib+MAR, ioaddr + PAR_DATA);
 823         outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
 824 }
 825
 826 /* The inverse routine to net_open(). */
 827 static int
 828 net_close(struct net_device *dev)
 829 {
 830         struct net_local *lp = netdev_priv(dev);
 831         long ioaddr = dev->base_addr;
 832
 833         netif_stop_queue(dev);
 834
 835         del_timer_sync(&lp->timer);
 836
 837         /* Flush the Tx and disable Rx here. */
 838         lp->addr_mode = CMR2h_OFF;
 839         write_reg_high(ioaddr, CMR2, CMR2h_OFF);
 840
 841         /* Free the IRQ line. */
 842         outb(0x00, ioaddr + PAR_CONTROL);
 843         free_irq(dev->irq, dev);
 844
 845         /* Reset the ethernet hardware and activate the printer pass-through. */
 846         write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
 847         return 0;
 848 }
 849
 850 /*
 851  *      Set or clear the multicast filter for this adapter.
 852  */
 853
 854 static void set_rx_mode(struct net_device *dev)
 855 {
 856         struct net_local *lp = netdev_priv(dev);
 857         long ioaddr = dev->base_addr;
 858
 859         if (!netdev_mc_empty(dev) || (dev->flags & (IFF_ALLMULTI|IFF_PROMISC)))
 860                 lp->addr_mode = CMR2h_PROMISC;
 861         else
 862                 lp->addr_mode = CMR2h_Normal;
 863         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 864 }
 865
 866 static int __init atp_init_module(void) {
 867         if (debug)                                      /* Emit version even if no cards detected. */
 868                 printk(KERN_INFO "%s", version);
 869         return atp_init();
 870 }
 871
 872 static void __exit atp_cleanup_module(void) {
 873         struct net_device *next_dev;
 874
 875         while (root_atp_dev) {
 876                 struct net_local *atp_local = netdev_priv(root_atp_dev);
 877                 next_dev = atp_local->next_module;
 878                 unregister_netdev(root_atp_dev);
 879                 /* No need to release_region(), since we never snarf it. */
 880                 free_netdev(root_atp_dev);
 881                 root_atp_dev = next_dev;
 882         }
 883 }
 884
 885 module_init(atp_init_module);
 886 module_exit(atp_cleanup_module);