root/drivers/net/ethernet/realtek/atp.c

DEFINITIONS

1. atp_init
2. atp_probe1
3. get_node_ID
4. eeprom_op
5. net_open
6. hardware_init
7. trigger_send
8. write_packet
9. tx_timeout
10. atp_send_packet
11. atp_interrupt
12. atp_timed_checker
13. net_rx
14. read_block
15. net_close
16. set_rx_mode
17. atp_init_module
18. atp_cleanup_module

   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_hw_array(io, int, ioport, NULL, 0);
 155 module_param_hw_array(irq, int, irq, 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     struct net_device *dev;     /* Timer dev. */
 174     unsigned 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(struct timer_list *t);
 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_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         lp->dev = dev;
 443         timer_setup(&lp->timer, atp_timed_checker, 0);
 444         lp->timer.expires = jiffies + TIMED_CHECKER;
 445         add_timer(&lp->timer);
 446 
 447         netif_start_queue(dev);
 448         return 0;
 449 }
 450 
 451 /* This routine resets the hardware.  We initialize everything, assuming that
 452    the hardware may have been temporarily detached. */
 453 static void hardware_init(struct net_device *dev)
 454 {
 455         struct net_local *lp = netdev_priv(dev);
 456         long ioaddr = dev->base_addr;
 457         int i;
 458 
 459         /* Turn off the printer multiplexer on the 8012. */
 460         for (i = 0; i < 8; i++)
 461                 outb(mux_8012[i], ioaddr + PAR_DATA);
 462         write_reg_high(ioaddr, CMR1, CMR1h_RESET);
 463 
 464         for (i = 0; i < 6; i++)
 465                 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
 466 
 467         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 468 
 469         if (net_debug > 2) {
 470                 printk(KERN_DEBUG "%s: Reset: current Rx mode %d.\n", dev->name,
 471                            (read_nibble(ioaddr, CMR2_h) >> 3) & 0x0f);
 472         }
 473 
 474         write_reg(ioaddr, CMR2, CMR2_IRQOUT);
 475         write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
 476 
 477         /* Enable the interrupt line from the serial port. */
 478         outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 479 
 480         /* Unmask the interesting interrupts. */
 481         write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
 482         write_reg_high(ioaddr, IMR, ISRh_RxErr);
 483 
 484         lp->tx_unit_busy = 0;
 485         lp->pac_cnt_in_tx_buf = 0;
 486         lp->saved_tx_size = 0;
 487 }
 488 
 489 static void trigger_send(long ioaddr, int length)
 490 {
 491         write_reg_byte(ioaddr, TxCNT0, length & 0xff);
 492         write_reg(ioaddr, TxCNT1, length >> 8);
 493         write_reg(ioaddr, CMR1, CMR1_Xmit);
 494 }
 495 
 496 static void write_packet(long ioaddr, int length, unsigned char *packet, int pad_len, int data_mode)
 497 {
 498     if (length & 1)
 499     {
 500         length++;
 501         pad_len++;
 502     }
 503 
 504     outb(EOC+MAR, ioaddr + PAR_DATA);
 505     if ((data_mode & 1) == 0) {
 506                 /* Write the packet out, starting with the write addr. */
 507                 outb(WrAddr+MAR, ioaddr + PAR_DATA);
 508                 do {
 509                         write_byte_mode0(ioaddr, *packet++);
 510                 } while (--length > pad_len) ;
 511                 do {
 512                         write_byte_mode0(ioaddr, 0);
 513                 } while (--length > 0) ;
 514     } else {
 515                 /* Write the packet out in slow mode. */
 516                 unsigned char outbyte = *packet++;
 517 
 518                 outb(Ctrl_LNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 519                 outb(WrAddr+MAR, ioaddr + PAR_DATA);
 520 
 521                 outb((outbyte & 0x0f)|0x40, ioaddr + PAR_DATA);
 522                 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
 523                 outbyte >>= 4;
 524                 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
 525                 outb(Ctrl_HNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 526                 while (--length > pad_len)
 527                         write_byte_mode1(ioaddr, *packet++);
 528                 while (--length > 0)
 529                         write_byte_mode1(ioaddr, 0);
 530     }
 531     /* Terminate the Tx frame.  End of write: ECB. */
 532     outb(0xff, ioaddr + PAR_DATA);
 533     outb(Ctrl_HNibWrite | Ctrl_SelData | Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 534 }
 535 
 536 static void tx_timeout(struct net_device *dev)
 537 {
 538         long ioaddr = dev->base_addr;
 539 
 540         printk(KERN_WARNING "%s: Transmit timed out, %s?\n", dev->name,
 541                    inb(ioaddr + PAR_CONTROL) & 0x10 ? "network cable problem"
 542                    :  "IRQ conflict");
 543         dev->stats.tx_errors++;
 544         /* Try to restart the adapter. */
 545         hardware_init(dev);
 546         netif_trans_update(dev); /* prevent tx timeout */
 547         netif_wake_queue(dev);
 548         dev->stats.tx_errors++;
 549 }
 550 
 551 static netdev_tx_t atp_send_packet(struct sk_buff *skb,
 552                                    struct net_device *dev)
 553 {
 554         struct net_local *lp = netdev_priv(dev);
 555         long ioaddr = dev->base_addr;
 556         int length;
 557         unsigned long flags;
 558 
 559         length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 560 
 561         netif_stop_queue(dev);
 562 
 563         /* Disable interrupts by writing 0x00 to the Interrupt Mask Register.
 564            This sequence must not be interrupted by an incoming packet. */
 565 
 566         spin_lock_irqsave(&lp->lock, flags);
 567         write_reg(ioaddr, IMR, 0);
 568         write_reg_high(ioaddr, IMR, 0);
 569         spin_unlock_irqrestore(&lp->lock, flags);
 570 
 571         write_packet(ioaddr, length, skb->data, length-skb->len, dev->if_port);
 572 
 573         lp->pac_cnt_in_tx_buf++;
 574         if (lp->tx_unit_busy == 0) {
 575                 trigger_send(ioaddr, length);
 576                 lp->saved_tx_size = 0;                          /* Redundant */
 577                 lp->re_tx = 0;
 578                 lp->tx_unit_busy = 1;
 579         } else
 580                 lp->saved_tx_size = length;
 581         /* Re-enable the LPT interrupts. */
 582         write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
 583         write_reg_high(ioaddr, IMR, ISRh_RxErr);
 584 
 585         dev_kfree_skb (skb);
 586         return NETDEV_TX_OK;
 587 }
 588 
 589 
 590 /* The typical workload of the driver:
 591    Handle the network interface interrupts. */
 592 static irqreturn_t atp_interrupt(int irq, void *dev_instance)
 593 {
 594         struct net_device *dev = dev_instance;
 595         struct net_local *lp;
 596         long ioaddr;
 597         static int num_tx_since_rx;
 598         int boguscount = max_interrupt_work;
 599         int handled = 0;
 600 
 601         ioaddr = dev->base_addr;
 602         lp = netdev_priv(dev);
 603 
 604         spin_lock(&lp->lock);
 605 
 606         /* Disable additional spurious interrupts. */
 607         outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
 608 
 609         /* The adapter's output is currently the IRQ line, switch it to data. */
 610         write_reg(ioaddr, CMR2, CMR2_NULL);
 611         write_reg(ioaddr, IMR, 0);
 612 
 613         if (net_debug > 5)
 614                 printk(KERN_DEBUG "%s: In interrupt ", dev->name);
 615         while (--boguscount > 0) {
 616                 int status = read_nibble(ioaddr, ISR);
 617                 if (net_debug > 5)
 618                         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)
 646                                 printk("handling Tx done..");
 647                         /* Clear the Tx interrupt.  We should check for too many failures
 648                            and reinitialize the adapter. */
 649                         write_reg(ioaddr, ISR, ISR_TxErr + ISR_TxOK);
 650                         if (status & (ISR_TxErr<<3)) {
 651                                 dev->stats.collisions++;
 652                                 if (++lp->re_tx > 15) {
 653                                         dev->stats.tx_aborted_errors++;
 654                                         hardware_init(dev);
 655                                         break;
 656                                 }
 657                                 /* Attempt to retransmit. */
 658                                 if (net_debug > 6)  printk("attempting to ReTx");
 659                                 write_reg(ioaddr, CMR1, CMR1_ReXmit + CMR1_Xmit);
 660                         } else {
 661                                 /* Finish up the transmit. */
 662                                 dev->stats.tx_packets++;
 663                                 lp->pac_cnt_in_tx_buf--;
 664                                 if ( lp->saved_tx_size) {
 665                                         trigger_send(ioaddr, lp->saved_tx_size);
 666                                         lp->saved_tx_size = 0;
 667                                         lp->re_tx = 0;
 668                                 } else
 669                                         lp->tx_unit_busy = 0;
 670                                 netif_wake_queue(dev);  /* Inform upper layers. */
 671                         }
 672                         num_tx_since_rx++;
 673                 } else if (num_tx_since_rx > 8 &&
 674                            time_after(jiffies, lp->last_rx_time + HZ)) {
 675                         if (net_debug > 2)
 676                                 printk(KERN_DEBUG "%s: Missed packet? No Rx after %d Tx and "
 677                                            "%ld jiffies status %02x  CMR1 %02x.\n", dev->name,
 678                                            num_tx_since_rx, jiffies - lp->last_rx_time, status,
 679                                            (read_nibble(ioaddr, CMR1) >> 3) & 15);
 680                         dev->stats.rx_missed_errors++;
 681                         hardware_init(dev);
 682                         num_tx_since_rx = 0;
 683                         break;
 684                 } else
 685                         break;
 686         }
 687 
 688         /* This following code fixes a rare (and very difficult to track down)
 689            problem where the adapter forgets its ethernet address. */
 690         {
 691                 int i;
 692                 for (i = 0; i < 6; i++)
 693                         write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
 694 #if 0 && defined(TIMED_CHECKER)
 695                 mod_timer(&lp->timer, jiffies + TIMED_CHECKER);
 696 #endif
 697         }
 698 
 699         /* Tell the adapter that it can go back to using the output line as IRQ. */
 700         write_reg(ioaddr, CMR2, CMR2_IRQOUT);
 701         /* Enable the physical interrupt line, which is sure to be low until.. */
 702         outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 703         /* .. we enable the interrupt sources. */
 704         write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
 705         write_reg_high(ioaddr, IMR, ISRh_RxErr);                        /* Hmmm, really needed? */
 706 
 707         spin_unlock(&lp->lock);
 708 
 709         if (net_debug > 5) printk("exiting interrupt.\n");
 710         return IRQ_RETVAL(handled);
 711 }
 712 
 713 #ifdef TIMED_CHECKER
 714 /* This following code fixes a rare (and very difficult to track down)
 715    problem where the adapter forgets its ethernet address. */
 716 static void atp_timed_checker(struct timer_list *t)
 717 {
 718         struct net_local *lp = from_timer(lp, t, timer);
 719         struct net_device *dev = lp->dev;
 720         long ioaddr = dev->base_addr;
 721         int tickssofar = jiffies - lp->last_rx_time;
 722         int i;
 723 
 724         spin_lock(&lp->lock);
 725         if (tickssofar > 2*HZ) {
 726 #if 1
 727                 for (i = 0; i < 6; i++)
 728                         write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
 729                 lp->last_rx_time = jiffies;
 730 #else
 731                 for (i = 0; i < 6; i++)
 732                         if (read_cmd_byte(ioaddr, PAR0 + i) != atp_timed_dev->dev_addr[i])
 733                                 {
 734                         struct net_local *lp = netdev_priv(atp_timed_dev);
 735                         write_reg_byte(ioaddr, PAR0 + i, atp_timed_dev->dev_addr[i]);
 736                         if (i == 2)
 737                           dev->stats.tx_errors++;
 738                         else if (i == 3)
 739                           dev->stats.tx_dropped++;
 740                         else if (i == 4)
 741                           dev->stats.collisions++;
 742                         else
 743                           dev->stats.rx_errors++;
 744                   }
 745 #endif
 746         }
 747         spin_unlock(&lp->lock);
 748         lp->timer.expires = jiffies + TIMED_CHECKER;
 749         add_timer(&lp->timer);
 750 }
 751 #endif
 752 
 753 /* We have a good packet(s), get it/them out of the buffers. */
 754 static void net_rx(struct net_device *dev)
 755 {
 756         struct net_local *lp = netdev_priv(dev);
 757         long ioaddr = dev->base_addr;
 758         struct rx_header rx_head;
 759 
 760         /* Process the received packet. */
 761         outb(EOC+MAR, ioaddr + PAR_DATA);
 762         read_block(ioaddr, 8, (unsigned char*)&rx_head, dev->if_port);
 763         if (net_debug > 5)
 764                 printk(KERN_DEBUG " rx_count %04x %04x %04x %04x..", rx_head.pad,
 765                            rx_head.rx_count, rx_head.rx_status, rx_head.cur_addr);
 766         if ((rx_head.rx_status & 0x77) != 0x01) {
 767                 dev->stats.rx_errors++;
 768                 if (rx_head.rx_status & 0x0004) dev->stats.rx_frame_errors++;
 769                 else if (rx_head.rx_status & 0x0002) dev->stats.rx_crc_errors++;
 770                 if (net_debug > 3)
 771                         printk(KERN_DEBUG "%s: Unknown ATP Rx error %04x.\n",
 772                                    dev->name, rx_head.rx_status);
 773                 if  (rx_head.rx_status & 0x0020) {
 774                         dev->stats.rx_fifo_errors++;
 775                         write_reg_high(ioaddr, CMR1, CMR1h_TxENABLE);
 776                         write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
 777                 } else if (rx_head.rx_status & 0x0050)
 778                         hardware_init(dev);
 779                 return;
 780         } else {
 781                 /* Malloc up new buffer. The "-4" omits the FCS (CRC). */
 782                 int pkt_len = (rx_head.rx_count & 0x7ff) - 4;
 783                 struct sk_buff *skb;
 784 
 785                 skb = netdev_alloc_skb(dev, pkt_len + 2);
 786                 if (skb == NULL) {
 787                         dev->stats.rx_dropped++;
 788                         goto done;
 789                 }
 790 
 791                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
 792                 read_block(ioaddr, pkt_len, skb_put(skb,pkt_len), dev->if_port);
 793                 skb->protocol = eth_type_trans(skb, dev);
 794                 netif_rx(skb);
 795                 dev->stats.rx_packets++;
 796                 dev->stats.rx_bytes += pkt_len;
 797         }
 798  done:
 799         write_reg(ioaddr, CMR1, CMR1_NextPkt);
 800         lp->last_rx_time = jiffies;
 801 }
 802 
 803 static void read_block(long ioaddr, int length, unsigned char *p, int data_mode)
 804 {
 805         if (data_mode <= 3) { /* Mode 0 or 1 */
 806                 outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
 807                 outb(length == 8  ?  RdAddr | HNib | MAR  :  RdAddr | MAR,
 808                          ioaddr + PAR_DATA);
 809                 if (data_mode <= 1) { /* Mode 0 or 1 */
 810                         do { *p++ = read_byte_mode0(ioaddr); } while (--length > 0);
 811                 } else { /* Mode 2 or 3 */
 812                         do { *p++ = read_byte_mode2(ioaddr); } while (--length > 0);
 813                 }
 814         } else if (data_mode <= 5) {
 815                 do { *p++ = read_byte_mode4(ioaddr); } while (--length > 0);
 816         } else {
 817                 do { *p++ = read_byte_mode6(ioaddr); } while (--length > 0);
 818         }
 819 
 820         outb(EOC+HNib+MAR, ioaddr + PAR_DATA);
 821         outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
 822 }
 823 
 824 /* The inverse routine to net_open(). */
 825 static int
 826 net_close(struct net_device *dev)
 827 {
 828         struct net_local *lp = netdev_priv(dev);
 829         long ioaddr = dev->base_addr;
 830 
 831         netif_stop_queue(dev);
 832 
 833         del_timer_sync(&lp->timer);
 834 
 835         /* Flush the Tx and disable Rx here. */
 836         lp->addr_mode = CMR2h_OFF;
 837         write_reg_high(ioaddr, CMR2, CMR2h_OFF);
 838 
 839         /* Free the IRQ line. */
 840         outb(0x00, ioaddr + PAR_CONTROL);
 841         free_irq(dev->irq, dev);
 842 
 843         /* Reset the ethernet hardware and activate the printer pass-through. */
 844         write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
 845         return 0;
 846 }
 847 
 848 /*
 849  *      Set or clear the multicast filter for this adapter.
 850  */
 851 
 852 static void set_rx_mode(struct net_device *dev)
 853 {
 854         struct net_local *lp = netdev_priv(dev);
 855         long ioaddr = dev->base_addr;
 856 
 857         if (!netdev_mc_empty(dev) || (dev->flags & (IFF_ALLMULTI|IFF_PROMISC)))
 858                 lp->addr_mode = CMR2h_PROMISC;
 859         else
 860                 lp->addr_mode = CMR2h_Normal;
 861         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 862 }
 863 
 864 static int __init atp_init_module(void) {
 865         if (debug)                                      /* Emit version even if no cards detected. */
 866                 printk(KERN_INFO "%s", version);
 867         return atp_init();
 868 }
 869 
 870 static void __exit atp_cleanup_module(void) {
 871         struct net_device *next_dev;
 872 
 873         while (root_atp_dev) {
 874                 struct net_local *atp_local = netdev_priv(root_atp_dev);
 875                 next_dev = atp_local->next_module;
 876                 unregister_netdev(root_atp_dev);
 877                 /* No need to release_region(), since we never snarf it. */
 878                 free_netdev(root_atp_dev);
 879                 root_atp_dev = next_dev;
 880         }
 881 }
 882 
 883 module_init(atp_init_module);
 884 module_exit(atp_cleanup_module);