linux/drivers/net/ethernet/realtek/atp.c
<<
>>
Prefs
   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
  34static 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
  40static 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. */
  44static int max_interrupt_work = 15;
  45
  46#define NUM_UNITS 2
  47/* The standard set of ISA module parameters. */
  48static int io[NUM_UNITS];
  49static int irq[NUM_UNITS];
  50static 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
 148MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
 149MODULE_DESCRIPTION("RealTek RTL8002/8012 parallel port Ethernet driver");
 150MODULE_LICENSE("GPL");
 151
 152module_param(max_interrupt_work, int, 0);
 153module_param(debug, int, 0);
 154module_param_hw_array(io, int, ioport, NULL, 0);
 155module_param_hw_array(irq, int, irq, NULL, 0);
 156module_param_array(xcvr, int, NULL, 0);
 157MODULE_PARM_DESC(max_interrupt_work, "ATP maximum events handled per interrupt");
 158MODULE_PARM_DESC(debug, "ATP debug level (0-7)");
 159MODULE_PARM_DESC(io, "ATP I/O base address(es)");
 160MODULE_PARM_DESC(irq, "ATP IRQ number(s)");
 161MODULE_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. */
 167static char mux_8012[] = { 0xff, 0xf7, 0xff, 0xfb, 0xf3, 0xfb, 0xff, 0xf7,};
 168
 169struct 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>
 188static void atp_timed_checker(struct timer_list *t);
 189#endif
 190
 191/* Index to functions, as function prototypes. */
 192
 193static int atp_probe1(long ioaddr);
 194static void get_node_ID(struct net_device *dev);
 195static unsigned short eeprom_op(long ioaddr, unsigned int cmd);
 196static int net_open(struct net_device *dev);
 197static void hardware_init(struct net_device *dev);
 198static void write_packet(long ioaddr, int length, unsigned char *packet, int pad, int mode);
 199static void trigger_send(long ioaddr, int length);
 200static netdev_tx_t atp_send_packet(struct sk_buff *skb,
 201                                   struct net_device *dev);
 202static irqreturn_t atp_interrupt(int irq, void *dev_id);
 203static void net_rx(struct net_device *dev);
 204static void read_block(long ioaddr, int length, unsigned char *buffer, int data_mode);
 205static int net_close(struct net_device *dev);
 206static void set_rx_mode(struct net_device *dev);
 207static void tx_timeout(struct net_device *dev, unsigned int txqueue);
 208
 209
 210/* A list of all installed ATP devices, for removing the driver module. */
 211static 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   */
 221static 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
 243static 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
 253static 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. */
 368static 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
 400static 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   */
 428static 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. */
 453static 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
 489static 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
 496static 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
 536static void tx_timeout(struct net_device *dev, unsigned int txqueue)
 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
 551static 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. */
 592static 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. */
 716static 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. */
 754static 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
 803static 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(). */
 825static int
 826net_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
 852static 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
 864static 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
 870static 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
 883module_init(atp_init_module);
 884module_exit(atp_cleanup_module);
 885