drivers/net/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/cn/cn.html
  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/slab.h>
 133 #include <linux/string.h>
 134 #include <linux/errno.h>
 135 #include <linux/init.h>
 136 #include <linux/crc32.h>
 137 #include <linux/netdevice.h>
 138 #include <linux/etherdevice.h>
 139 #include <linux/skbuff.h>
 140 #include <linux/spinlock.h>
 141 #include <linux/delay.h>
 142 #include <linux/bitops.h>
 143
 144 #include <asm/system.h>
 145 #include <asm/io.h>
 146 #include <asm/dma.h>
 147
 148 #include "atp.h"
 149
 150 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 151 MODULE_DESCRIPTION("RealTek RTL8002/8012 parallel port Ethernet driver");
 152 MODULE_LICENSE("GPL");
 153
 154 module_param(max_interrupt_work, int, 0);
 155 module_param(debug, int, 0);
 156 module_param_array(io, int, NULL, 0);
 157 module_param_array(irq, int, NULL, 0);
 158 module_param_array(xcvr, int, NULL, 0);
 159 MODULE_PARM_DESC(max_interrupt_work, "ATP maximum events handled per interrupt");
 160 MODULE_PARM_DESC(debug, "ATP debug level (0-7)");
 161 MODULE_PARM_DESC(io, "ATP I/O base address(es)");
 162 MODULE_PARM_DESC(irq, "ATP IRQ number(s)");
 163 MODULE_PARM_DESC(xcvr, "ATP transceiver(s) (0=internal, 1=external)");
 164
 165 /* The number of low I/O ports used by the ethercard. */
 166 #define ETHERCARD_TOTAL_SIZE    3
 167
 168 /* Sequence to switch an 8012 from printer mux to ethernet mode. */
 169 static char mux_8012[] = { 0xff, 0xf7, 0xff, 0xfb, 0xf3, 0xfb, 0xff, 0xf7,};
 170
 171 struct net_local {
 172     spinlock_t lock;
 173     struct net_device *next_module;
 174     struct net_device_stats stats;
 175     struct timer_list timer;    /* Media selection timer. */
 176     long last_rx_time;          /* Last Rx, in jiffies, to handle Rx hang. */
 177     int saved_tx_size;
 178     unsigned int tx_unit_busy:1;
 179     unsigned char re_tx,        /* Number of packet retransmissions. */
 180                 addr_mode,              /* Current Rx filter e.g. promiscuous, etc. */
 181                 pac_cnt_in_tx_buf,
 182                 chip_type;
 183 };
 184
 185 /* This code, written by wwc@super.org, resets the adapter every
 186    TIMED_CHECKER ticks.  This recovers from an unknown error which
 187    hangs the device. */
 188 #define TIMED_CHECKER (HZ/4)
 189 #ifdef TIMED_CHECKER
 190 #include <linux/timer.h>
 191 static void atp_timed_checker(unsigned long ignored);
 192 #endif
 193
 194 /* Index to functions, as function prototypes. */
 195
 196 static int atp_probe1(long ioaddr);
 197 static void get_node_ID(struct net_device *dev);
 198 static unsigned short eeprom_op(long ioaddr, unsigned int cmd);
 199 static int net_open(struct net_device *dev);
 200 static void hardware_init(struct net_device *dev);
 201 static void write_packet(long ioaddr, int length, unsigned char *packet, int pad, int mode);
 202 static void trigger_send(long ioaddr, int length);
 203 static int      atp_send_packet(struct sk_buff *skb, struct net_device *dev);
 204 static irqreturn_t atp_interrupt(int irq, void *dev_id);
 205 static void net_rx(struct net_device *dev);
 206 static void read_block(long ioaddr, int length, unsigned char *buffer, int data_mode);
 207 static int net_close(struct net_device *dev);
 208 static struct net_device_stats *net_get_stats(struct net_device *dev);
 209 static void set_rx_mode_8002(struct net_device *dev);
 210 static void set_rx_mode_8012(struct net_device *dev);
 211 static void tx_timeout(struct net_device *dev);
 212
 213
 214 /* A list of all installed ATP devices, for removing the driver module. */
 215 static struct net_device *root_atp_dev;
 216
 217 /* Check for a network adapter of this type, and return '0' iff one exists.
 218    If dev->base_addr == 0, probe all likely locations.
 219    If dev->base_addr == 1, always return failure.
 220    If dev->base_addr == 2, allocate space for the device and return success
 221    (detachable devices only).
 222
 223    FIXME: we should use the parport layer for this
 224    */
 225 static int __init atp_init(void)
 226 {
 227         int *port, ports[] = {0x378, 0x278, 0x3bc, 0};
 228         int base_addr = io[0];
 229
 230         if (base_addr > 0x1ff)          /* Check a single specified location. */
 231                 return atp_probe1(base_addr);
 232         else if (base_addr == 1)        /* Don't probe at all. */
 233                 return -ENXIO;
 234
 235         for (port = ports; *port; port++) {
 236                 long ioaddr = *port;
 237                 outb(0x57, ioaddr + PAR_DATA);
 238                 if (inb(ioaddr + PAR_DATA) != 0x57)
 239                         continue;
 240                 if (atp_probe1(ioaddr) == 0)
 241                         return 0;
 242         }
 243
 244         return -ENODEV;
 245 }
 246
 247 static int __init atp_probe1(long ioaddr)
 248 {
 249         struct net_device *dev = NULL;
 250         struct net_local *lp;
 251         int saved_ctrl_reg, status, i;
 252         int res;
 253
 254         outb(0xff, ioaddr + PAR_DATA);
 255         /* Save the original value of the Control register, in case we guessed
 256            wrong. */
 257         saved_ctrl_reg = inb(ioaddr + PAR_CONTROL);
 258         if (net_debug > 3)
 259                 printk("atp: Control register was %#2.2x.\n", saved_ctrl_reg);
 260         /* IRQEN=0, SLCTB=high INITB=high, AUTOFDB=high, STBB=high. */
 261         outb(0x04, ioaddr + PAR_CONTROL);
 262 #ifndef final_version
 263         if (net_debug > 3) {
 264                 /* Turn off the printer multiplexer on the 8012. */
 265                 for (i = 0; i < 8; i++)
 266                         outb(mux_8012[i], ioaddr + PAR_DATA);
 267                 write_reg(ioaddr, MODSEL, 0x00);
 268                 printk("atp: Registers are ");
 269                 for (i = 0; i < 32; i++)
 270                         printk(" %2.2x", read_nibble(ioaddr, i));
 271                 printk(".\n");
 272         }
 273 #endif
 274         /* Turn off the printer multiplexer on the 8012. */
 275         for (i = 0; i < 8; i++)
 276                 outb(mux_8012[i], ioaddr + PAR_DATA);
 277         write_reg_high(ioaddr, CMR1, CMR1h_RESET);
 278         /* udelay() here? */
 279         status = read_nibble(ioaddr, CMR1);
 280
 281         if (net_debug > 3) {
 282                 printk(KERN_DEBUG "atp: Status nibble was %#2.2x..", status);
 283                 for (i = 0; i < 32; i++)
 284                         printk(" %2.2x", read_nibble(ioaddr, i));
 285                 printk("\n");
 286         }
 287
 288         if ((status & 0x78) != 0x08) {
 289                 /* The pocket adapter probe failed, restore the control register. */
 290                 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
 291                 return -ENODEV;
 292         }
 293         status = read_nibble(ioaddr, CMR2_h);
 294         if ((status & 0x78) != 0x10) {
 295                 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
 296                 return -ENODEV;
 297         }
 298
 299         dev = alloc_etherdev(sizeof(struct net_local));
 300         if (!dev)
 301                 return -ENOMEM;
 302         SET_MODULE_OWNER(dev);
 303
 304         /* Find the IRQ used by triggering an interrupt. */
 305         write_reg_byte(ioaddr, CMR2, 0x01);                     /* No accept mode, IRQ out. */
 306         write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);  /* Enable Tx and Rx. */
 307
 308         /* Omit autoIRQ routine for now. Use "table lookup" instead.  Uhgggh. */
 309         if (irq[0])
 310                 dev->irq = irq[0];
 311         else if (ioaddr == 0x378)
 312                 dev->irq = 7;
 313         else
 314                 dev->irq = 5;
 315         write_reg_high(ioaddr, CMR1, CMR1h_TxRxOFF); /* Disable Tx and Rx units. */
 316         write_reg(ioaddr, CMR2, CMR2_NULL);
 317
 318         dev->base_addr = ioaddr;
 319
 320         /* Read the station address PROM.  */
 321         get_node_ID(dev);
 322
 323 #ifndef MODULE
 324         if (net_debug)
 325                 printk(KERN_INFO "%s", version);
 326 #endif
 327
 328         printk(KERN_NOTICE "%s: Pocket adapter found at %#3lx, IRQ %d, SAPROM "
 329                    "%02X:%02X:%02X:%02X:%02X:%02X.\n", dev->name, dev->base_addr,
 330                    dev->irq, dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
 331                    dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
 332
 333         /* Reset the ethernet hardware and activate the printer pass-through. */
 334         write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
 335
 336         lp = netdev_priv(dev);
 337         lp->chip_type = RTL8002;
 338         lp->addr_mode = CMR2h_Normal;
 339         spin_lock_init(&lp->lock);
 340
 341         /* For the ATP adapter the "if_port" is really the data transfer mode. */
 342         if (xcvr[0])
 343                 dev->if_port = xcvr[0];
 344         else
 345                 dev->if_port = (dev->mem_start & 0xf) ? (dev->mem_start & 0x7) : 4;
 346         if (dev->mem_end & 0xf)
 347                 net_debug = dev->mem_end & 7;
 348
 349         dev->open               = net_open;
 350         dev->stop               = net_close;
 351         dev->hard_start_xmit    = atp_send_packet;
 352         dev->get_stats          = net_get_stats;
 353         dev->set_multicast_list =
 354           lp->chip_type == RTL8002 ? &set_rx_mode_8002 : &set_rx_mode_8012;
 355         dev->tx_timeout         = tx_timeout;
 356         dev->watchdog_timeo     = TX_TIMEOUT;
 357
 358         res = register_netdev(dev);
 359         if (res) {
 360                 free_netdev(dev);
 361                 return res;
 362         }
 363
 364         lp->next_module = root_atp_dev;
 365         root_atp_dev = dev;
 366
 367         return 0;
 368 }
 369
 370 /* Read the station address PROM, usually a word-wide EEPROM. */
 371 static void __init get_node_ID(struct net_device *dev)
 372 {
 373         long ioaddr = dev->base_addr;
 374         int sa_offset = 0;
 375         int i;
 376
 377         write_reg(ioaddr, CMR2, CMR2_EEPROM);     /* Point to the EEPROM control registers. */
 378
 379         /* Some adapters have the station address at offset 15 instead of offset
 380            zero.  Check for it, and fix it if needed. */
 381         if (eeprom_op(ioaddr, EE_READ(0)) == 0xffff)
 382                 sa_offset = 15;
 383
 384         for (i = 0; i < 3; i++)
 385                 ((u16 *)dev->dev_addr)[i] =
 386                         be16_to_cpu(eeprom_op(ioaddr, EE_READ(sa_offset + i)));
 387
 388         write_reg(ioaddr, CMR2, CMR2_NULL);
 389 }
 390
 391 /*
 392   An EEPROM read command starts by shifting out 0x60+address, and then
 393   shifting in the serial data. See the NatSemi databook for details.
 394  *                 ________________
 395  * CS : __|
 396  *                         ___     ___
 397  * CLK: ______|   |___|   |
 398  *               __ _______ _______
 399  * DI :  __X_______X_______X
 400  * DO :  _________X_______X
 401  */
 402
 403 static unsigned short __init eeprom_op(long ioaddr, u32 cmd)
 404 {
 405         unsigned eedata_out = 0;
 406         int num_bits = EE_CMD_SIZE;
 407
 408         while (--num_bits >= 0) {
 409                 char outval = (cmd & (1<<num_bits)) ? EE_DATA_WRITE : 0;
 410                 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_LOW);
 411                 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_HIGH);
 412                 eedata_out <<= 1;
 413                 if (read_nibble(ioaddr, PROM_DATA) & EE_DATA_READ)
 414                         eedata_out++;
 415         }
 416         write_reg_high(ioaddr, PROM_CMD, EE_CLK_LOW & ~EE_CS);
 417         return eedata_out;
 418 }
 419
 420
 421 /* Open/initialize the board.  This is called (in the current kernel)
 422    sometime after booting when the 'ifconfig' program is run.
 423
 424    This routine sets everything up anew at each open, even
 425    registers that "should" only need to be set once at boot, so that
 426    there is non-reboot way to recover if something goes wrong.
 427
 428    This is an attachable device: if there is no dev->priv entry then it wasn't
 429    probed for at boot-time, and we need to probe for it again.
 430    */
 431 static int net_open(struct net_device *dev)
 432 {
 433         struct net_local *lp = netdev_priv(dev);
 434         int ret;
 435
 436         /* The interrupt line is turned off (tri-stated) when the device isn't in
 437            use.  That's especially important for "attached" interfaces where the
 438            port or interrupt may be shared. */
 439         ret = request_irq(dev->irq, &atp_interrupt, 0, dev->name, dev);
 440         if (ret)
 441                 return ret;
 442
 443         hardware_init(dev);
 444
 445         init_timer(&lp->timer);
 446         lp->timer.expires = jiffies + TIMED_CHECKER;
 447         lp->timer.data = (unsigned long)dev;
 448         lp->timer.function = &atp_timed_checker;    /* timer handler */
 449         add_timer(&lp->timer);
 450
 451         netif_start_queue(dev);
 452         return 0;
 453 }
 454
 455 /* This routine resets the hardware.  We initialize everything, assuming that
 456    the hardware may have been temporarily detached. */
 457 static void hardware_init(struct net_device *dev)
 458 {
 459         struct net_local *lp = netdev_priv(dev);
 460         long ioaddr = dev->base_addr;
 461     int i;
 462
 463         /* Turn off the printer multiplexer on the 8012. */
 464         for (i = 0; i < 8; i++)
 465                 outb(mux_8012[i], ioaddr + PAR_DATA);
 466         write_reg_high(ioaddr, CMR1, CMR1h_RESET);
 467
 468     for (i = 0; i < 6; i++)
 469                 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
 470
 471         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 472
 473         if (net_debug > 2) {
 474                 printk(KERN_DEBUG "%s: Reset: current Rx mode %d.\n", dev->name,
 475                            (read_nibble(ioaddr, CMR2_h) >> 3) & 0x0f);
 476         }
 477
 478     write_reg(ioaddr, CMR2, CMR2_IRQOUT);
 479     write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
 480
 481         /* Enable the interrupt line from the serial port. */
 482         outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 483
 484         /* Unmask the interesting interrupts. */
 485     write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
 486     write_reg_high(ioaddr, IMR, ISRh_RxErr);
 487
 488         lp->tx_unit_busy = 0;
 489     lp->pac_cnt_in_tx_buf = 0;
 490         lp->saved_tx_size = 0;
 491 }
 492
 493 static void trigger_send(long ioaddr, int length)
 494 {
 495         write_reg_byte(ioaddr, TxCNT0, length & 0xff);
 496         write_reg(ioaddr, TxCNT1, length >> 8);
 497         write_reg(ioaddr, CMR1, CMR1_Xmit);
 498 }
 499
 500 static void write_packet(long ioaddr, int length, unsigned char *packet, int pad_len, int data_mode)
 501 {
 502     if (length & 1)
 503     {
 504         length++;
 505         pad_len++;
 506     }
 507
 508     outb(EOC+MAR, ioaddr + PAR_DATA);
 509     if ((data_mode & 1) == 0) {
 510                 /* Write the packet out, starting with the write addr. */
 511                 outb(WrAddr+MAR, ioaddr + PAR_DATA);
 512                 do {
 513                         write_byte_mode0(ioaddr, *packet++);
 514                 } while (--length > pad_len) ;
 515                 do {
 516                         write_byte_mode0(ioaddr, 0);
 517                 } while (--length > 0) ;
 518     } else {
 519                 /* Write the packet out in slow mode. */
 520                 unsigned char outbyte = *packet++;
 521
 522                 outb(Ctrl_LNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 523                 outb(WrAddr+MAR, ioaddr + PAR_DATA);
 524
 525                 outb((outbyte & 0x0f)|0x40, ioaddr + PAR_DATA);
 526                 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
 527                 outbyte >>= 4;
 528                 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
 529                 outb(Ctrl_HNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 530                 while (--length > pad_len)
 531                         write_byte_mode1(ioaddr, *packet++);
 532                 while (--length > 0)
 533                         write_byte_mode1(ioaddr, 0);
 534     }
 535     /* Terminate the Tx frame.  End of write: ECB. */
 536     outb(0xff, ioaddr + PAR_DATA);
 537     outb(Ctrl_HNibWrite | Ctrl_SelData | Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 538 }
 539
 540 static void tx_timeout(struct net_device *dev)
 541 {
 542         struct net_local *np = netdev_priv(dev);
 543         long ioaddr = dev->base_addr;
 544
 545         printk(KERN_WARNING "%s: Transmit timed out, %s?\n", dev->name,
 546                    inb(ioaddr + PAR_CONTROL) & 0x10 ? "network cable problem"
 547                    :  "IRQ conflict");
 548         np->stats.tx_errors++;
 549         /* Try to restart the adapter. */
 550         hardware_init(dev);
 551         dev->trans_start = jiffies;
 552         netif_wake_queue(dev);
 553         np->stats.tx_errors++;
 554 }
 555
 556 static int atp_send_packet(struct sk_buff *skb, struct net_device *dev)
 557 {
 558         struct net_local *lp = netdev_priv(dev);
 559         long ioaddr = dev->base_addr;
 560         int length;
 561         unsigned long flags;
 562
 563         length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 564
 565         netif_stop_queue(dev);
 566
 567         /* Disable interrupts by writing 0x00 to the Interrupt Mask Register.
 568            This sequence must not be interrupted by an incoming packet. */
 569
 570         spin_lock_irqsave(&lp->lock, flags);
 571         write_reg(ioaddr, IMR, 0);
 572         write_reg_high(ioaddr, IMR, 0);
 573         spin_unlock_irqrestore(&lp->lock, flags);
 574
 575         write_packet(ioaddr, length, skb->data, length-skb->len, dev->if_port);
 576
 577         lp->pac_cnt_in_tx_buf++;
 578         if (lp->tx_unit_busy == 0) {
 579                 trigger_send(ioaddr, length);
 580                 lp->saved_tx_size = 0;                          /* Redundant */
 581                 lp->re_tx = 0;
 582                 lp->tx_unit_busy = 1;
 583         } else
 584                 lp->saved_tx_size = length;
 585         /* Re-enable the LPT interrupts. */
 586         write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
 587         write_reg_high(ioaddr, IMR, ISRh_RxErr);
 588
 589         dev->trans_start = jiffies;
 590         dev_kfree_skb (skb);
 591         return 0;
 592 }
 593
 594
 595 /* The typical workload of the driver:
 596    Handle the network interface interrupts. */
 597 static irqreturn_t atp_interrupt(int irq, void *dev_instance)
 598 {
 599         struct net_device *dev = dev_instance;
 600         struct net_local *lp;
 601         long ioaddr;
 602         static int num_tx_since_rx;
 603         int boguscount = max_interrupt_work;
 604         int handled = 0;
 605
 606         ioaddr = dev->base_addr;
 607         lp = netdev_priv(dev);
 608
 609         spin_lock(&lp->lock);
 610
 611         /* Disable additional spurious interrupts. */
 612         outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
 613
 614         /* The adapter's output is currently the IRQ line, switch it to data. */
 615         write_reg(ioaddr, CMR2, CMR2_NULL);
 616         write_reg(ioaddr, IMR, 0);
 617
 618         if (net_debug > 5) printk(KERN_DEBUG "%s: In interrupt ", dev->name);
 619     while (--boguscount > 0) {
 620                 int status = read_nibble(ioaddr, ISR);
 621                 if (net_debug > 5) printk("loop status %02x..", status);
 622
 623                 if (status & (ISR_RxOK<<3)) {
 624                         handled = 1;
 625                         write_reg(ioaddr, ISR, ISR_RxOK); /* Clear the Rx interrupt. */
 626                         do {
 627                                 int read_status = read_nibble(ioaddr, CMR1);
 628                                 if (net_debug > 6)
 629                                         printk("handling Rx packet %02x..", read_status);
 630                                 /* We acknowledged the normal Rx interrupt, so if the interrupt
 631                                    is still outstanding we must have a Rx error. */
 632                                 if (read_status & (CMR1_IRQ << 3)) { /* Overrun. */
 633                                         lp->stats.rx_over_errors++;
 634                                         /* Set to no-accept mode long enough to remove a packet. */
 635                                         write_reg_high(ioaddr, CMR2, CMR2h_OFF);
 636                                         net_rx(dev);
 637                                         /* Clear the interrupt and return to normal Rx mode. */
 638                                         write_reg_high(ioaddr, ISR, ISRh_RxErr);
 639                                         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 640                                 } else if ((read_status & (CMR1_BufEnb << 3)) == 0) {
 641                                         net_rx(dev);
 642                                         num_tx_since_rx = 0;
 643                                 } else
 644                                         break;
 645                         } while (--boguscount > 0);
 646                 } else if (status & ((ISR_TxErr + ISR_TxOK)<<3)) {
 647                         handled = 1;
 648                         if (net_debug > 6)  printk("handling Tx done..");
 649                         /* Clear the Tx interrupt.  We should check for too many failures
 650                            and reinitialize the adapter. */
 651                         write_reg(ioaddr, ISR, ISR_TxErr + ISR_TxOK);
 652                         if (status & (ISR_TxErr<<3)) {
 653                                 lp->stats.collisions++;
 654                                 if (++lp->re_tx > 15) {
 655                                         lp->stats.tx_aborted_errors++;
 656                                         hardware_init(dev);
 657                                         break;
 658                                 }
 659                                 /* Attempt to retransmit. */
 660                                 if (net_debug > 6)  printk("attempting to ReTx");
 661                                 write_reg(ioaddr, CMR1, CMR1_ReXmit + CMR1_Xmit);
 662                         } else {
 663                                 /* Finish up the transmit. */
 664                                 lp->stats.tx_packets++;
 665                                 lp->pac_cnt_in_tx_buf--;
 666                                 if ( lp->saved_tx_size) {
 667                                         trigger_send(ioaddr, lp->saved_tx_size);
 668                                         lp->saved_tx_size = 0;
 669                                         lp->re_tx = 0;
 670                                 } else
 671                                         lp->tx_unit_busy = 0;
 672                                 netif_wake_queue(dev);  /* Inform upper layers. */
 673                         }
 674                         num_tx_since_rx++;
 675                 } else if (num_tx_since_rx > 8
 676                                    && time_after(jiffies, dev->last_rx + HZ)) {
 677                         if (net_debug > 2)
 678                                 printk(KERN_DEBUG "%s: Missed packet? No Rx after %d Tx and "
 679                                            "%ld jiffies status %02x  CMR1 %02x.\n", dev->name,
 680                                            num_tx_since_rx, jiffies - dev->last_rx, status,
 681                                            (read_nibble(ioaddr, CMR1) >> 3) & 15);
 682                         lp->stats.rx_missed_errors++;
 683                         hardware_init(dev);
 684                         num_tx_since_rx = 0;
 685                         break;
 686                 } else
 687                         break;
 688     }
 689
 690         /* This following code fixes a rare (and very difficult to track down)
 691            problem where the adapter forgets its ethernet address. */
 692         {
 693                 int i;
 694                 for (i = 0; i < 6; i++)
 695                         write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
 696 #if 0 && defined(TIMED_CHECKER)
 697                 mod_timer(&lp->timer, jiffies + TIMED_CHECKER);
 698 #endif
 699         }
 700
 701         /* Tell the adapter that it can go back to using the output line as IRQ. */
 702     write_reg(ioaddr, CMR2, CMR2_IRQOUT);
 703         /* Enable the physical interrupt line, which is sure to be low until.. */
 704         outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 705         /* .. we enable the interrupt sources. */
 706         write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
 707         write_reg_high(ioaddr, IMR, ISRh_RxErr);                        /* Hmmm, really needed? */
 708
 709         spin_unlock(&lp->lock);
 710
 711         if (net_debug > 5) printk("exiting interrupt.\n");
 712         return IRQ_RETVAL(handled);
 713 }
 714
 715 #ifdef TIMED_CHECKER
 716 /* This following code fixes a rare (and very difficult to track down)
 717    problem where the adapter forgets its ethernet address. */
 718 static void atp_timed_checker(unsigned long data)
 719 {
 720         struct net_device *dev = (struct net_device *)data;
 721         long ioaddr = dev->base_addr;
 722         struct net_local *lp = netdev_priv(dev);
 723         int tickssofar = jiffies - lp->last_rx_time;
 724         int i;
 725
 726         spin_lock(&lp->lock);
 727         if (tickssofar > 2*HZ) {
 728 #if 1
 729                 for (i = 0; i < 6; i++)
 730                         write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
 731                 lp->last_rx_time = jiffies;
 732 #else
 733                 for (i = 0; i < 6; i++)
 734                         if (read_cmd_byte(ioaddr, PAR0 + i) != atp_timed_dev->dev_addr[i])
 735                                 {
 736                         struct net_local *lp = netdev_priv(atp_timed_dev);
 737                         write_reg_byte(ioaddr, PAR0 + i, atp_timed_dev->dev_addr[i]);
 738                         if (i == 2)
 739                           lp->stats.tx_errors++;
 740                         else if (i == 3)
 741                           lp->stats.tx_dropped++;
 742                         else if (i == 4)
 743                           lp->stats.collisions++;
 744                         else
 745                           lp->stats.rx_errors++;
 746                   }
 747 #endif
 748         }
 749         spin_unlock(&lp->lock);
 750         lp->timer.expires = jiffies + TIMED_CHECKER;
 751         add_timer(&lp->timer);
 752 }
 753 #endif
 754
 755 /* We have a good packet(s), get it/them out of the buffers. */
 756 static void net_rx(struct net_device *dev)
 757 {
 758         struct net_local *lp = netdev_priv(dev);
 759         long ioaddr = dev->base_addr;
 760         struct rx_header rx_head;
 761
 762         /* Process the received packet. */
 763         outb(EOC+MAR, ioaddr + PAR_DATA);
 764         read_block(ioaddr, 8, (unsigned char*)&rx_head, dev->if_port);
 765         if (net_debug > 5)
 766                 printk(KERN_DEBUG " rx_count %04x %04x %04x %04x..", rx_head.pad,
 767                            rx_head.rx_count, rx_head.rx_status, rx_head.cur_addr);
 768         if ((rx_head.rx_status & 0x77) != 0x01) {
 769                 lp->stats.rx_errors++;
 770                 if (rx_head.rx_status & 0x0004) lp->stats.rx_frame_errors++;
 771                 else if (rx_head.rx_status & 0x0002) lp->stats.rx_crc_errors++;
 772                 if (net_debug > 3)
 773                         printk(KERN_DEBUG "%s: Unknown ATP Rx error %04x.\n",
 774                                    dev->name, rx_head.rx_status);
 775                 if  (rx_head.rx_status & 0x0020) {
 776                         lp->stats.rx_fifo_errors++;
 777                         write_reg_high(ioaddr, CMR1, CMR1h_TxENABLE);
 778                         write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
 779                 } else if (rx_head.rx_status & 0x0050)
 780                         hardware_init(dev);
 781                 return;
 782         } else {
 783                 /* Malloc up new buffer. The "-4" omits the FCS (CRC). */
 784                 int pkt_len = (rx_head.rx_count & 0x7ff) - 4;
 785                 struct sk_buff *skb;
 786
 787                 skb = dev_alloc_skb(pkt_len + 2);
 788                 if (skb == NULL) {
 789                         printk(KERN_ERR "%s: Memory squeeze, dropping packet.\n",
 790                                    dev->name);
 791                         lp->stats.rx_dropped++;
 792                         goto done;
 793                 }
 794
 795                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
 796                 read_block(ioaddr, pkt_len, skb_put(skb,pkt_len), dev->if_port);
 797                 skb->protocol = eth_type_trans(skb, dev);
 798                 netif_rx(skb);
 799                 dev->last_rx = jiffies;
 800                 lp->stats.rx_packets++;
 801                 lp->stats.rx_bytes += pkt_len;
 802         }
 803  done:
 804         write_reg(ioaddr, CMR1, CMR1_NextPkt);
 805         lp->last_rx_time = jiffies;
 806         return;
 807 }
 808
 809 static void read_block(long ioaddr, int length, unsigned char *p, int data_mode)
 810 {
 811
 812         if (data_mode <= 3) { /* Mode 0 or 1 */
 813                 outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
 814                 outb(length == 8  ?  RdAddr | HNib | MAR  :  RdAddr | MAR,
 815                          ioaddr + PAR_DATA);
 816                 if (data_mode <= 1) { /* Mode 0 or 1 */
 817                         do  *p++ = read_byte_mode0(ioaddr);  while (--length > 0);
 818                 } else  /* Mode 2 or 3 */
 819                         do  *p++ = read_byte_mode2(ioaddr);  while (--length > 0);
 820         } else if (data_mode <= 5)
 821                 do      *p++ = read_byte_mode4(ioaddr);  while (--length > 0);
 822         else
 823                 do      *p++ = read_byte_mode6(ioaddr);  while (--length > 0);
 824
 825     outb(EOC+HNib+MAR, ioaddr + PAR_DATA);
 826         outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
 827 }
 828
 829 /* The inverse routine to net_open(). */
 830 static int
 831 net_close(struct net_device *dev)
 832 {
 833         struct net_local *lp = netdev_priv(dev);
 834         long ioaddr = dev->base_addr;
 835
 836         netif_stop_queue(dev);
 837
 838         del_timer_sync(&lp->timer);
 839
 840         /* Flush the Tx and disable Rx here. */
 841         lp->addr_mode = CMR2h_OFF;
 842         write_reg_high(ioaddr, CMR2, CMR2h_OFF);
 843
 844         /* Free the IRQ line. */
 845         outb(0x00, ioaddr + PAR_CONTROL);
 846         free_irq(dev->irq, dev);
 847
 848         /* Reset the ethernet hardware and activate the printer pass-through. */
 849         write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
 850         return 0;
 851 }
 852
 853 /* Get the current statistics.  This may be called with the card open or
 854    closed. */
 855 static struct net_device_stats *
 856 net_get_stats(struct net_device *dev)
 857 {
 858         struct net_local *lp = netdev_priv(dev);
 859         return &lp->stats;
 860 }
 861
 862 /*
 863  *      Set or clear the multicast filter for this adapter.
 864  */
 865
 866 static void set_rx_mode_8002(struct net_device *dev)
 867 {
 868         struct net_local *lp = netdev_priv(dev);
 869         long ioaddr = dev->base_addr;
 870
 871         if ( dev->mc_count > 0 || (dev->flags & (IFF_ALLMULTI|IFF_PROMISC))) {
 872                 /* We must make the kernel realise we had to move
 873                  *      into promisc mode or we start all out war on
 874                  *      the cable. - AC
 875                  */
 876                 dev->flags|=IFF_PROMISC;
 877                 lp->addr_mode = CMR2h_PROMISC;
 878         } else
 879                 lp->addr_mode = CMR2h_Normal;
 880         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 881 }
 882
 883 static void set_rx_mode_8012(struct net_device *dev)
 884 {
 885         struct net_local *lp = netdev_priv(dev);
 886         long ioaddr = dev->base_addr;
 887         unsigned char new_mode, mc_filter[8]; /* Multicast hash filter */
 888         int i;
 889
 890         if (dev->flags & IFF_PROMISC) {                 /* Set promiscuous. */
 891                 new_mode = CMR2h_PROMISC;
 892         } else if ((dev->mc_count > 1000)  ||  (dev->flags & IFF_ALLMULTI)) {
 893                 /* Too many to filter perfectly -- accept all multicasts. */
 894                 memset(mc_filter, 0xff, sizeof(mc_filter));
 895                 new_mode = CMR2h_Normal;
 896         } else {
 897                 struct dev_mc_list *mclist;
 898
 899                 memset(mc_filter, 0, sizeof(mc_filter));
 900                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
 901                          i++, mclist = mclist->next)
 902                 {
 903                         int filterbit = ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x3f;
 904                         mc_filter[filterbit >> 5] |= 1 << (filterbit & 31);
 905                 }
 906                 new_mode = CMR2h_Normal;
 907         }
 908         lp->addr_mode = new_mode;
 909     write_reg(ioaddr, CMR2, CMR2_IRQOUT | 0x04); /* Switch to page 1. */
 910     for (i = 0; i < 8; i++)
 911                 write_reg_byte(ioaddr, i, mc_filter[i]);
 912         if (net_debug > 2 || 1) {
 913                 lp->addr_mode = 1;
 914                 printk(KERN_DEBUG "%s: Mode %d, setting multicast filter to",
 915                            dev->name, lp->addr_mode);
 916                 for (i = 0; i < 8; i++)
 917                         printk(" %2.2x", mc_filter[i]);
 918                 printk(".\n");
 919         }
 920
 921         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 922     write_reg(ioaddr, CMR2, CMR2_IRQOUT); /* Switch back to page 0 */
 923 }
 924
 925 static int __init atp_init_module(void) {
 926         if (debug)                                      /* Emit version even if no cards detected. */
 927                 printk(KERN_INFO "%s", version);
 928         return atp_init();
 929 }
 930
 931 static void __exit atp_cleanup_module(void) {
 932         struct net_device *next_dev;
 933
 934         while (root_atp_dev) {
 935                 next_dev = ((struct net_local *)root_atp_dev->priv)->next_module;
 936                 unregister_netdev(root_atp_dev);
 937                 /* No need to release_region(), since we never snarf it. */
 938                 free_netdev(root_atp_dev);
 939                 root_atp_dev = next_dev;
 940         }
 941 }
 942
 943 module_init(atp_init_module);
 944 module_exit(atp_cleanup_module);