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