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                 chip_type;
 180 };
 181
 182 /* This code, written by wwc@super.org, resets the adapter every
 183    TIMED_CHECKER ticks.  This recovers from an unknown error which
 184    hangs the device. */
 185 #define TIMED_CHECKER (HZ/4)
 186 #ifdef TIMED_CHECKER
 187 #include <linux/timer.h>
 188 static void atp_timed_checker(unsigned long ignored);
 189 #endif
 190
 191 /* Index to functions, as function prototypes. */
 192
 193 static int atp_probe1(long ioaddr);
 194 static void get_node_ID(struct net_device *dev);
 195 static unsigned short eeprom_op(long ioaddr, unsigned int cmd);
 196 static int net_open(struct net_device *dev);
 197 static void hardware_init(struct net_device *dev);
 198 static void write_packet(long ioaddr, int length, unsigned char *packet, int pad, int mode);
 199 static void trigger_send(long ioaddr, int length);
 200 static netdev_tx_t atp_send_packet(struct sk_buff *skb,
 201                                    struct net_device *dev);
 202 static irqreturn_t atp_interrupt(int irq, void *dev_id);
 203 static void net_rx(struct net_device *dev);
 204 static void read_block(long ioaddr, int length, unsigned char *buffer, int data_mode);
 205 static int net_close(struct net_device *dev);
 206 static void set_rx_mode(struct net_device *dev);
 207 static void tx_timeout(struct net_device *dev);
 208
 209
 210 /* A list of all installed ATP devices, for removing the driver module. */
 211 static struct net_device *root_atp_dev;
 212
 213 /* Check for a network adapter of this type, and return '0' iff one exists.
 214    If dev->base_addr == 0, probe all likely locations.
 215    If dev->base_addr == 1, always return failure.
 216    If dev->base_addr == 2, allocate space for the device and return success
 217    (detachable devices only).
 218
 219    FIXME: we should use the parport layer for this
 220    */
 221 static int __init atp_init(void)
 222 {
 223         int *port, ports[] = {0x378, 0x278, 0x3bc, 0};
 224         int base_addr = io[0];
 225
 226         if (base_addr > 0x1ff)          /* Check a single specified location. */
 227                 return atp_probe1(base_addr);
 228         else if (base_addr == 1)        /* Don't probe at all. */
 229                 return -ENXIO;
 230
 231         for (port = ports; *port; port++) {
 232                 long ioaddr = *port;
 233                 outb(0x57, ioaddr + PAR_DATA);
 234                 if (inb(ioaddr + PAR_DATA) != 0x57)
 235                         continue;
 236                 if (atp_probe1(ioaddr) == 0)
 237                         return 0;
 238         }
 239
 240         return -ENODEV;
 241 }
 242
 243 static const struct net_device_ops atp_netdev_ops = {
 244         .ndo_open               = net_open,
 245         .ndo_stop               = net_close,
 246         .ndo_start_xmit         = atp_send_packet,
 247         .ndo_set_rx_mode        = set_rx_mode,
 248         .ndo_tx_timeout         = tx_timeout,
 249         .ndo_change_mtu         = eth_change_mtu,
 250         .ndo_set_mac_address    = eth_mac_addr,
 251         .ndo_validate_addr      = eth_validate_addr,
 252 };
 253
 254 static int __init atp_probe1(long ioaddr)
 255 {
 256         struct net_device *dev = NULL;
 257         struct net_local *lp;
 258         int saved_ctrl_reg, status, i;
 259         int res;
 260
 261         outb(0xff, ioaddr + PAR_DATA);
 262         /* Save the original value of the Control register, in case we guessed
 263            wrong. */
 264         saved_ctrl_reg = inb(ioaddr + PAR_CONTROL);
 265         if (net_debug > 3)
 266                 printk("atp: Control register was %#2.2x.\n", saved_ctrl_reg);
 267         /* IRQEN=0, SLCTB=high INITB=high, AUTOFDB=high, STBB=high. */
 268         outb(0x04, ioaddr + PAR_CONTROL);
 269 #ifndef final_version
 270         if (net_debug > 3) {
 271                 /* Turn off the printer multiplexer on the 8012. */
 272                 for (i = 0; i < 8; i++)
 273                         outb(mux_8012[i], ioaddr + PAR_DATA);
 274                 write_reg(ioaddr, MODSEL, 0x00);
 275                 printk("atp: Registers are ");
 276                 for (i = 0; i < 32; i++)
 277                         printk(" %2.2x", read_nibble(ioaddr, i));
 278                 printk(".\n");
 279         }
 280 #endif
 281         /* Turn off the printer multiplexer on the 8012. */
 282         for (i = 0; i < 8; i++)
 283                 outb(mux_8012[i], ioaddr + PAR_DATA);
 284         write_reg_high(ioaddr, CMR1, CMR1h_RESET);
 285         /* udelay() here? */
 286         status = read_nibble(ioaddr, CMR1);
 287
 288         if (net_debug > 3) {
 289                 printk(KERN_DEBUG "atp: Status nibble was %#2.2x..", status);
 290                 for (i = 0; i < 32; i++)
 291                         printk(" %2.2x", read_nibble(ioaddr, i));
 292                 printk("\n");
 293         }
 294
 295         if ((status & 0x78) != 0x08) {
 296                 /* The pocket adapter probe failed, restore the control register. */
 297                 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
 298                 return -ENODEV;
 299         }
 300         status = read_nibble(ioaddr, CMR2_h);
 301         if ((status & 0x78) != 0x10) {
 302                 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
 303                 return -ENODEV;
 304         }
 305
 306         dev = alloc_etherdev(sizeof(struct net_local));
 307         if (!dev)
 308                 return -ENOMEM;
 309
 310         /* Find the IRQ used by triggering an interrupt. */
 311         write_reg_byte(ioaddr, CMR2, 0x01);                     /* No accept mode, IRQ out. */
 312         write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);  /* Enable Tx and Rx. */
 313
 314         /* Omit autoIRQ routine for now. Use "table lookup" instead.  Uhgggh. */
 315         if (irq[0])
 316                 dev->irq = irq[0];
 317         else if (ioaddr == 0x378)
 318                 dev->irq = 7;
 319         else
 320                 dev->irq = 5;
 321         write_reg_high(ioaddr, CMR1, CMR1h_TxRxOFF); /* Disable Tx and Rx units. */
 322         write_reg(ioaddr, CMR2, CMR2_NULL);
 323
 324         dev->base_addr = ioaddr;
 325
 326         /* Read the station address PROM.  */
 327         get_node_ID(dev);
 328
 329 #ifndef MODULE
 330         if (net_debug)
 331                 printk(KERN_INFO "%s", version);
 332 #endif
 333
 334         printk(KERN_NOTICE "%s: Pocket adapter found at %#3lx, IRQ %d, "
 335                "SAPROM %pM.\n",
 336                dev->name, dev->base_addr, dev->irq, dev->dev_addr);
 337
 338         /* Reset the ethernet hardware and activate the printer pass-through. */
 339         write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
 340
 341         lp = netdev_priv(dev);
 342         lp->chip_type = RTL8002;
 343         lp->addr_mode = CMR2h_Normal;
 344         spin_lock_init(&lp->lock);
 345
 346         /* For the ATP adapter the "if_port" is really the data transfer mode. */
 347         if (xcvr[0])
 348                 dev->if_port = xcvr[0];
 349         else
 350                 dev->if_port = (dev->mem_start & 0xf) ? (dev->mem_start & 0x7) : 4;
 351         if (dev->mem_end & 0xf)
 352                 net_debug = dev->mem_end & 7;
 353
 354         dev->netdev_ops         = &atp_netdev_ops;
 355         dev->watchdog_timeo     = TX_TIMEOUT;
 356
 357         res = register_netdev(dev);
 358         if (res) {
 359                 free_netdev(dev);
 360                 return res;
 361         }
 362
 363         lp->next_module = root_atp_dev;
 364         root_atp_dev = dev;
 365
 366         return 0;
 367 }
 368
 369 /* Read the station address PROM, usually a word-wide EEPROM. */
 370 static void __init get_node_ID(struct net_device *dev)
 371 {
 372         long ioaddr = dev->base_addr;
 373         int sa_offset = 0;
 374         int i;
 375
 376         write_reg(ioaddr, CMR2, CMR2_EEPROM);     /* Point to the EEPROM control registers. */
 377
 378         /* Some adapters have the station address at offset 15 instead of offset
 379            zero.  Check for it, and fix it if needed. */
 380         if (eeprom_op(ioaddr, EE_READ(0)) == 0xffff)
 381                 sa_offset = 15;
 382
 383         for (i = 0; i < 3; i++)
 384                 ((__be16 *)dev->dev_addr)[i] =
 385                         cpu_to_be16(eeprom_op(ioaddr, EE_READ(sa_offset + i)));
 386
 387         write_reg(ioaddr, CMR2, CMR2_NULL);
 388 }
 389
 390 /*
 391   An EEPROM read command starts by shifting out 0x60+address, and then
 392   shifting in the serial data. See the NatSemi databook for details.
 393  *                 ________________
 394  * CS : __|
 395  *                         ___     ___
 396  * CLK: ______|   |___|   |
 397  *               __ _______ _______
 398  * DI :  __X_______X_______X
 399  * DO :  _________X_______X
 400  */
 401
 402 static unsigned short __init eeprom_op(long ioaddr, u32 cmd)
 403 {
 404         unsigned eedata_out = 0;
 405         int num_bits = EE_CMD_SIZE;
 406
 407         while (--num_bits >= 0) {
 408                 char outval = (cmd & (1<<num_bits)) ? EE_DATA_WRITE : 0;
 409                 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_LOW);
 410                 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_HIGH);
 411                 eedata_out <<= 1;
 412                 if (read_nibble(ioaddr, PROM_DATA) & EE_DATA_READ)
 413                         eedata_out++;
 414         }
 415         write_reg_high(ioaddr, PROM_CMD, EE_CLK_LOW & ~EE_CS);
 416         return eedata_out;
 417 }
 418
 419
 420 /* Open/initialize the board.  This is called (in the current kernel)
 421    sometime after booting when the 'ifconfig' program is run.
 422
 423    This routine sets everything up anew at each open, even
 424    registers that "should" only need to be set once at boot, so that
 425    there is non-reboot way to recover if something goes wrong.
 426
 427    This is an attachable device: if there is no private entry then it wasn't
 428    probed for at boot-time, and we need to probe for it again.
 429    */
 430 static int net_open(struct net_device *dev)
 431 {
 432         struct net_local *lp = netdev_priv(dev);
 433         int ret;
 434
 435         /* The interrupt line is turned off (tri-stated) when the device isn't in
 436            use.  That's especially important for "attached" interfaces where the
 437            port or interrupt may be shared. */
 438         ret = request_irq(dev->irq, atp_interrupt, 0, dev->name, dev);
 439         if (ret)
 440                 return ret;
 441
 442         hardware_init(dev);
 443
 444         init_timer(&lp->timer);
 445         lp->timer.expires = jiffies + TIMED_CHECKER;
 446         lp->timer.data = (unsigned long)dev;
 447         lp->timer.function = atp_timed_checker;    /* timer handler */
 448         add_timer(&lp->timer);
 449
 450         netif_start_queue(dev);
 451         return 0;
 452 }
 453
 454 /* This routine resets the hardware.  We initialize everything, assuming that
 455    the hardware may have been temporarily detached. */
 456 static void hardware_init(struct net_device *dev)
 457 {
 458         struct net_local *lp = netdev_priv(dev);
 459         long ioaddr = dev->base_addr;
 460     int i;
 461
 462         /* Turn off the printer multiplexer on the 8012. */
 463         for (i = 0; i < 8; i++)
 464                 outb(mux_8012[i], ioaddr + PAR_DATA);
 465         write_reg_high(ioaddr, CMR1, CMR1h_RESET);
 466
 467     for (i = 0; i < 6; i++)
 468                 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
 469
 470         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 471
 472         if (net_debug > 2) {
 473                 printk(KERN_DEBUG "%s: Reset: current Rx mode %d.\n", dev->name,
 474                            (read_nibble(ioaddr, CMR2_h) >> 3) & 0x0f);
 475         }
 476
 477     write_reg(ioaddr, CMR2, CMR2_IRQOUT);
 478     write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
 479
 480         /* Enable the interrupt line from the serial port. */
 481         outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 482
 483         /* Unmask the interesting interrupts. */
 484     write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
 485     write_reg_high(ioaddr, IMR, ISRh_RxErr);
 486
 487         lp->tx_unit_busy = 0;
 488     lp->pac_cnt_in_tx_buf = 0;
 489         lp->saved_tx_size = 0;
 490 }
 491
 492 static void trigger_send(long ioaddr, int length)
 493 {
 494         write_reg_byte(ioaddr, TxCNT0, length & 0xff);
 495         write_reg(ioaddr, TxCNT1, length >> 8);
 496         write_reg(ioaddr, CMR1, CMR1_Xmit);
 497 }
 498
 499 static void write_packet(long ioaddr, int length, unsigned char *packet, int pad_len, int data_mode)
 500 {
 501     if (length & 1)
 502     {
 503         length++;
 504         pad_len++;
 505     }
 506
 507     outb(EOC+MAR, ioaddr + PAR_DATA);
 508     if ((data_mode & 1) == 0) {
 509                 /* Write the packet out, starting with the write addr. */
 510                 outb(WrAddr+MAR, ioaddr + PAR_DATA);
 511                 do {
 512                         write_byte_mode0(ioaddr, *packet++);
 513                 } while (--length > pad_len) ;
 514                 do {
 515                         write_byte_mode0(ioaddr, 0);
 516                 } while (--length > 0) ;
 517     } else {
 518                 /* Write the packet out in slow mode. */
 519                 unsigned char outbyte = *packet++;
 520
 521                 outb(Ctrl_LNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 522                 outb(WrAddr+MAR, ioaddr + PAR_DATA);
 523
 524                 outb((outbyte & 0x0f)|0x40, ioaddr + PAR_DATA);
 525                 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
 526                 outbyte >>= 4;
 527                 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
 528                 outb(Ctrl_HNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 529                 while (--length > pad_len)
 530                         write_byte_mode1(ioaddr, *packet++);
 531                 while (--length > 0)
 532                         write_byte_mode1(ioaddr, 0);
 533     }
 534     /* Terminate the Tx frame.  End of write: ECB. */
 535     outb(0xff, ioaddr + PAR_DATA);
 536     outb(Ctrl_HNibWrite | Ctrl_SelData | Ctrl_IRQEN, ioaddr + PAR_CONTROL);
 537 }
 538
 539 static void tx_timeout(struct net_device *dev)
 540 {
 541         long ioaddr = dev->base_addr;
 542
 543         printk(KERN_WARNING "%s: Transmit timed out, %s?\n", dev->name,
 544                    inb(ioaddr + PAR_CONTROL) & 0x10 ? "network cable problem"
 545                    :  "IRQ conflict");
 546         dev->stats.tx_errors++;
 547         /* Try to restart the adapter. */
 548         hardware_init(dev);
 549         dev->trans_start = jiffies; /* prevent tx timeout */
 550         netif_wake_queue(dev);
 551         dev->stats.tx_errors++;
 552 }
 553
 554 static netdev_tx_t atp_send_packet(struct sk_buff *skb,
 555                                    struct net_device *dev)
 556 {
 557         struct net_local *lp = netdev_priv(dev);
 558         long ioaddr = dev->base_addr;
 559         int length;
 560         unsigned long flags;
 561
 562         length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 563
 564         netif_stop_queue(dev);
 565
 566         /* Disable interrupts by writing 0x00 to the Interrupt Mask Register.
 567            This sequence must not be interrupted by an incoming packet. */
 568
 569         spin_lock_irqsave(&lp->lock, flags);
 570         write_reg(ioaddr, IMR, 0);
 571         write_reg_high(ioaddr, IMR, 0);
 572         spin_unlock_irqrestore(&lp->lock, flags);
 573
 574         write_packet(ioaddr, length, skb->data, length-skb->len, dev->if_port);
 575
 576         lp->pac_cnt_in_tx_buf++;
 577         if (lp->tx_unit_busy == 0) {
 578                 trigger_send(ioaddr, length);
 579                 lp->saved_tx_size = 0;                          /* Redundant */
 580                 lp->re_tx = 0;
 581                 lp->tx_unit_busy = 1;
 582         } else
 583                 lp->saved_tx_size = length;
 584         /* Re-enable the LPT interrupts. */
 585         write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
 586         write_reg_high(ioaddr, IMR, ISRh_RxErr);
 587
 588         dev_kfree_skb (skb);
 589         return NETDEV_TX_OK;
 590 }
 591
 592
 593 /* The typical workload of the driver:
 594    Handle the network interface interrupts. */
 595 static irqreturn_t atp_interrupt(int irq, void *dev_instance)
 596 {
 597         struct net_device *dev = dev_instance;
 598         struct net_local *lp;
 599         long ioaddr;
 600         static int num_tx_since_rx;
 601         int boguscount = max_interrupt_work;
 602         int handled = 0;
 603
 604         ioaddr = dev->base_addr;
 605         lp = netdev_priv(dev);
 606
 607         spin_lock(&lp->lock);
 608
 609         /* Disable additional spurious interrupts. */
 610         outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
 611
 612         /* The adapter's output is currently the IRQ line, switch it to data. */
 613         write_reg(ioaddr, CMR2, CMR2_NULL);
 614         write_reg(ioaddr, IMR, 0);
 615
 616         if (net_debug > 5) printk(KERN_DEBUG "%s: In interrupt ", dev->name);
 617     while (--boguscount > 0) {
 618                 int status = read_nibble(ioaddr, ISR);
 619                 if (net_debug > 5) printk("loop status %02x..", status);
 620
 621                 if (status & (ISR_RxOK<<3)) {
 622                         handled = 1;
 623                         write_reg(ioaddr, ISR, ISR_RxOK); /* Clear the Rx interrupt. */
 624                         do {
 625                                 int read_status = read_nibble(ioaddr, CMR1);
 626                                 if (net_debug > 6)
 627                                         printk("handling Rx packet %02x..", read_status);
 628                                 /* We acknowledged the normal Rx interrupt, so if the interrupt
 629                                    is still outstanding we must have a Rx error. */
 630                                 if (read_status & (CMR1_IRQ << 3)) { /* Overrun. */
 631                                         dev->stats.rx_over_errors++;
 632                                         /* Set to no-accept mode long enough to remove a packet. */
 633                                         write_reg_high(ioaddr, CMR2, CMR2h_OFF);
 634                                         net_rx(dev);
 635                                         /* Clear the interrupt and return to normal Rx mode. */
 636                                         write_reg_high(ioaddr, ISR, ISRh_RxErr);
 637                                         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 638                                 } else if ((read_status & (CMR1_BufEnb << 3)) == 0) {
 639                                         net_rx(dev);
 640                                         num_tx_since_rx = 0;
 641                                 } else
 642                                         break;
 643                         } while (--boguscount > 0);
 644                 } else if (status & ((ISR_TxErr + ISR_TxOK)<<3)) {
 645                         handled = 1;
 646                         if (net_debug > 6)  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, dev->last_rx + 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 - dev->last_rx, 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(unsigned long data)
 717 {
 718         struct net_device *dev = (struct net_device *)data;
 719         long ioaddr = dev->base_addr;
 720         struct net_local *lp = netdev_priv(dev);
 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                         printk(KERN_ERR "%s: Memory squeeze, dropping packet.\n",
 788                                    dev->name);
 789                         dev->stats.rx_dropped++;
 790                         goto done;
 791                 }
 792
 793                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
 794                 read_block(ioaddr, pkt_len, skb_put(skb,pkt_len), dev->if_port);
 795                 skb->protocol = eth_type_trans(skb, dev);
 796                 netif_rx(skb);
 797                 dev->last_rx = jiffies;
 798                 dev->stats.rx_packets++;
 799                 dev->stats.rx_bytes += pkt_len;
 800         }
 801  done:
 802         write_reg(ioaddr, CMR1, CMR1_NextPkt);
 803         lp->last_rx_time = jiffies;
 804 }
 805
 806 static void read_block(long ioaddr, int length, unsigned char *p, int data_mode)
 807 {
 808         if (data_mode <= 3) { /* Mode 0 or 1 */
 809                 outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
 810                 outb(length == 8  ?  RdAddr | HNib | MAR  :  RdAddr | MAR,
 811                          ioaddr + PAR_DATA);
 812                 if (data_mode <= 1) { /* Mode 0 or 1 */
 813                         do { *p++ = read_byte_mode0(ioaddr); } while (--length > 0);
 814                 } else { /* Mode 2 or 3 */
 815                         do { *p++ = read_byte_mode2(ioaddr); } while (--length > 0);
 816                 }
 817         } else if (data_mode <= 5) {
 818                 do { *p++ = read_byte_mode4(ioaddr); } while (--length > 0);
 819         } else {
 820                 do { *p++ = read_byte_mode6(ioaddr); } while (--length > 0);
 821         }
 822
 823         outb(EOC+HNib+MAR, ioaddr + PAR_DATA);
 824         outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
 825 }
 826
 827 /* The inverse routine to net_open(). */
 828 static int
 829 net_close(struct net_device *dev)
 830 {
 831         struct net_local *lp = netdev_priv(dev);
 832         long ioaddr = dev->base_addr;
 833
 834         netif_stop_queue(dev);
 835
 836         del_timer_sync(&lp->timer);
 837
 838         /* Flush the Tx and disable Rx here. */
 839         lp->addr_mode = CMR2h_OFF;
 840         write_reg_high(ioaddr, CMR2, CMR2h_OFF);
 841
 842         /* Free the IRQ line. */
 843         outb(0x00, ioaddr + PAR_CONTROL);
 844         free_irq(dev->irq, dev);
 845
 846         /* Reset the ethernet hardware and activate the printer pass-through. */
 847         write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
 848         return 0;
 849 }
 850
 851 /*
 852  *      Set or clear the multicast filter for this adapter.
 853  */
 854
 855 static void set_rx_mode_8002(struct net_device *dev)
 856 {
 857         struct net_local *lp = netdev_priv(dev);
 858         long ioaddr = dev->base_addr;
 859
 860         if (!netdev_mc_empty(dev) || (dev->flags & (IFF_ALLMULTI|IFF_PROMISC)))
 861                 lp->addr_mode = CMR2h_PROMISC;
 862         else
 863                 lp->addr_mode = CMR2h_Normal;
 864         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 865 }
 866
 867 static void set_rx_mode_8012(struct net_device *dev)
 868 {
 869         struct net_local *lp = netdev_priv(dev);
 870         long ioaddr = dev->base_addr;
 871         unsigned char new_mode, mc_filter[8]; /* Multicast hash filter */
 872         int i;
 873
 874         if (dev->flags & IFF_PROMISC) {                 /* Set promiscuous. */
 875                 new_mode = CMR2h_PROMISC;
 876         } else if ((netdev_mc_count(dev) > 1000) ||
 877                    (dev->flags & IFF_ALLMULTI)) {
 878                 /* Too many to filter perfectly -- accept all multicasts. */
 879                 memset(mc_filter, 0xff, sizeof(mc_filter));
 880                 new_mode = CMR2h_Normal;
 881         } else {
 882                 struct netdev_hw_addr *ha;
 883
 884                 memset(mc_filter, 0, sizeof(mc_filter));
 885                 netdev_for_each_mc_addr(ha, dev) {
 886                         int filterbit = ether_crc_le(ETH_ALEN, ha->addr) & 0x3f;
 887                         mc_filter[filterbit >> 5] |= 1 << (filterbit & 31);
 888                 }
 889                 new_mode = CMR2h_Normal;
 890         }
 891         lp->addr_mode = new_mode;
 892     write_reg(ioaddr, CMR2, CMR2_IRQOUT | 0x04); /* Switch to page 1. */
 893     for (i = 0; i < 8; i++)
 894                 write_reg_byte(ioaddr, i, mc_filter[i]);
 895         if (net_debug > 2 || 1) {
 896                 lp->addr_mode = 1;
 897                 printk(KERN_DEBUG "%s: Mode %d, setting multicast filter to",
 898                            dev->name, lp->addr_mode);
 899                 for (i = 0; i < 8; i++)
 900                         printk(" %2.2x", mc_filter[i]);
 901                 printk(".\n");
 902         }
 903
 904         write_reg_high(ioaddr, CMR2, lp->addr_mode);
 905     write_reg(ioaddr, CMR2, CMR2_IRQOUT); /* Switch back to page 0 */
 906 }
 907
 908 static void set_rx_mode(struct net_device *dev)
 909 {
 910         struct net_local *lp = netdev_priv(dev);
 911
 912         if (lp->chip_type == RTL8002)
 913                 return set_rx_mode_8002(dev);
 914         else
 915                 return set_rx_mode_8012(dev);
 916 }
 917
 918
 919 static int __init atp_init_module(void) {
 920         if (debug)                                      /* Emit version even if no cards detected. */
 921                 printk(KERN_INFO "%s", version);
 922         return atp_init();
 923 }
 924
 925 static void __exit atp_cleanup_module(void) {
 926         struct net_device *next_dev;
 927
 928         while (root_atp_dev) {
 929                 struct net_local *atp_local = netdev_priv(root_atp_dev);
 930                 next_dev = atp_local->next_module;
 931                 unregister_netdev(root_atp_dev);
 932                 /* No need to release_region(), since we never snarf it. */
 933                 free_netdev(root_atp_dev);
 934                 root_atp_dev = next_dev;
 935         }
 936 }
 937
 938 module_init(atp_init_module);
 939 module_exit(atp_cleanup_module);