drivers/net: request_irq - Remove unnecessary leading & from second arg
[linux-2.6.git] / drivers / net / atp.c
1 /* atp.c: Attached (pocket) ethernet adapter driver for linux. */
2 /*
3         This is a driver for commonly OEM pocket (parallel port)
4         ethernet adapters based on the Realtek RTL8002 and RTL8012 chips.
5
6         Written 1993-2000 by Donald Becker.
7
8         This software may be used and distributed according to the terms of
9         the GNU General Public License (GPL), incorporated herein by reference.
10         Drivers based on or derived from this code fall under the GPL and must
11         retain the authorship, copyright and license notice.  This file is not
12         a complete program and may only be used when the entire operating
13         system is licensed under the GPL.
14
15         Copyright 1993 United States Government as represented by the Director,
16         National Security Agency.  Copyright 1994-2000 retained by the original
17         author, Donald Becker. The timer-based reset code was supplied in 1995
18         by Bill Carlson, wwc@super.org.
19
20         The author may be reached as becker@scyld.com, or C/O
21         Scyld Computing Corporation
22         410 Severn Ave., Suite 210
23         Annapolis MD 21403
24
25         Support information and updates available at
26         http://www.scyld.com/network/atp.html
27
28
29         Modular support/softnet added by Alan Cox.
30         _bit abuse fixed up by Alan Cox
31
32 */
33
34 static const char version[] =
35 "atp.c:v1.09=ac 2002/10/01 Donald Becker <becker@scyld.com>\n";
36
37 /* The user-configurable values.
38    These may be modified when a driver module is loaded.*/
39
40 static int debug = 1;                   /* 1 normal messages, 0 quiet .. 7 verbose. */
41 #define net_debug debug
42
43 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
44 static int max_interrupt_work = 15;
45
46 #define NUM_UNITS 2
47 /* The standard set of ISA module parameters. */
48 static int io[NUM_UNITS];
49 static int irq[NUM_UNITS];
50 static int xcvr[NUM_UNITS];                     /* The data transfer mode. */
51
52 /* Operational parameters that are set at compile time. */
53
54 /* Time in jiffies before concluding the transmitter is hung. */
55 #define TX_TIMEOUT  (400*HZ/1000)
56
57 /*
58         This file is a device driver for the RealTek (aka AT-Lan-Tec) pocket
59         ethernet adapter.  This is a common low-cost OEM pocket ethernet
60         adapter, sold under many names.
61
62   Sources:
63         This driver was written from the packet driver assembly code provided by
64         Vincent Bono of AT-Lan-Tec.      Ever try to figure out how a complicated
65         device works just from the assembly code?  It ain't pretty.  The following
66         description is written based on guesses and writing lots of special-purpose
67         code to test my theorized operation.
68
69         In 1997 Realtek made available the documentation for the second generation
70         RTL8012 chip, which has lead to several driver improvements.
71           http://www.realtek.com.tw/cn/cn.html
72
73                                         Theory of Operation
74
75         The RTL8002 adapter seems to be built around a custom spin of the SEEQ
76         controller core.  It probably has a 16K or 64K internal packet buffer, of
77         which the first 4K is devoted to transmit and the rest to receive.
78         The controller maintains the queue of received packet and the packet buffer
79         access pointer internally, with only 'reset to beginning' and 'skip to next
80         packet' commands visible.  The transmit packet queue holds two (or more?)
81         packets: both 'retransmit this packet' (due to collision) and 'transmit next
82         packet' commands must be started by hand.
83
84         The station address is stored in a standard bit-serial EEPROM which must be
85         read (ughh) by the device driver.  (Provisions have been made for
86         substituting a 74S288 PROM, but I haven't gotten reports of any models
87         using it.)  Unlike built-in devices, a pocket adapter can temporarily lose
88         power without indication to the device driver.  The major effect is that
89         the station address, receive filter (promiscuous, etc.) and transceiver
90         must be reset.
91
92         The controller itself has 16 registers, some of which use only the lower
93         bits.  The registers are read and written 4 bits at a time.  The four bit
94         register address is presented on the data lines along with a few additional
95         timing and control bits.  The data is then read from status port or written
96         to the data port.
97
98         Correction: the controller has two banks of 16 registers.  The second
99         bank contains only the multicast filter table (now used) and the EEPROM
100         access registers.
101
102         Since the bulk data transfer of the actual packets through the slow
103         parallel port dominates the driver's running time, four distinct data
104         (non-register) transfer modes are provided by the adapter, two in each
105         direction.  In the first mode timing for the nibble transfers is
106         provided through the data port.  In the second mode the same timing is
107         provided through the control port.  In either case the data is read from
108         the status port and written to the data port, just as it is accessing
109         registers.
110
111         In addition to the basic data transfer methods, several more are modes are
112         created by adding some delay by doing multiple reads of the data to allow
113         it to stabilize.  This delay seems to be needed on most machines.
114
115         The data transfer mode is stored in the 'dev->if_port' field.  Its default
116         value is '4'.  It may be overridden at boot-time using the third parameter
117         to the "ether=..." initialization.
118
119         The header file <atp.h> provides inline functions that encapsulate the
120         register and data access methods.  These functions are hand-tuned to
121         generate reasonable object code.  This header file also documents my
122         interpretations of the device registers.
123 */
124
125 #include <linux/kernel.h>
126 #include <linux/module.h>
127 #include <linux/types.h>
128 #include <linux/fcntl.h>
129 #include <linux/interrupt.h>
130 #include <linux/ioport.h>
131 #include <linux/in.h>
132 #include <linux/slab.h>
133 #include <linux/string.h>
134 #include <linux/errno.h>
135 #include <linux/init.h>
136 #include <linux/crc32.h>
137 #include <linux/netdevice.h>
138 #include <linux/etherdevice.h>
139 #include <linux/skbuff.h>
140 #include <linux/spinlock.h>
141 #include <linux/delay.h>
142 #include <linux/bitops.h>
143
144 #include <asm/system.h>
145 #include <asm/io.h>
146 #include <asm/dma.h>
147
148 #include "atp.h"
149
150 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
151 MODULE_DESCRIPTION("RealTek RTL8002/8012 parallel port Ethernet driver");
152 MODULE_LICENSE("GPL");
153
154 module_param(max_interrupt_work, int, 0);
155 module_param(debug, int, 0);
156 module_param_array(io, int, NULL, 0);
157 module_param_array(irq, int, NULL, 0);
158 module_param_array(xcvr, int, NULL, 0);
159 MODULE_PARM_DESC(max_interrupt_work, "ATP maximum events handled per interrupt");
160 MODULE_PARM_DESC(debug, "ATP debug level (0-7)");
161 MODULE_PARM_DESC(io, "ATP I/O base address(es)");
162 MODULE_PARM_DESC(irq, "ATP IRQ number(s)");
163 MODULE_PARM_DESC(xcvr, "ATP transceiver(s) (0=internal, 1=external)");
164
165 /* The number of low I/O ports used by the ethercard. */
166 #define ETHERCARD_TOTAL_SIZE    3
167
168 /* Sequence to switch an 8012 from printer mux to ethernet mode. */
169 static char mux_8012[] = { 0xff, 0xf7, 0xff, 0xfb, 0xf3, 0xfb, 0xff, 0xf7,};
170
171 struct net_local {
172     spinlock_t lock;
173     struct net_device *next_module;
174     struct timer_list timer;    /* Media selection timer. */
175     long last_rx_time;          /* Last Rx, in jiffies, to handle Rx hang. */
176     int saved_tx_size;
177     unsigned int tx_unit_busy:1;
178     unsigned char re_tx,        /* Number of packet retransmissions. */
179                 addr_mode,              /* Current Rx filter e.g. promiscuous, etc. */
180                 pac_cnt_in_tx_buf,
181                 chip_type;
182 };
183
184 /* This code, written by wwc@super.org, resets the adapter every
185    TIMED_CHECKER ticks.  This recovers from an unknown error which
186    hangs the device. */
187 #define TIMED_CHECKER (HZ/4)
188 #ifdef TIMED_CHECKER
189 #include <linux/timer.h>
190 static void atp_timed_checker(unsigned long ignored);
191 #endif
192
193 /* Index to functions, as function prototypes. */
194
195 static int atp_probe1(long ioaddr);
196 static void get_node_ID(struct net_device *dev);
197 static unsigned short eeprom_op(long ioaddr, unsigned int cmd);
198 static int net_open(struct net_device *dev);
199 static void hardware_init(struct net_device *dev);
200 static void write_packet(long ioaddr, int length, unsigned char *packet, int pad, int mode);
201 static void trigger_send(long ioaddr, int length);
202 static netdev_tx_t atp_send_packet(struct sk_buff *skb,
203                                    struct net_device *dev);
204 static irqreturn_t atp_interrupt(int irq, void *dev_id);
205 static void net_rx(struct net_device *dev);
206 static void read_block(long ioaddr, int length, unsigned char *buffer, int data_mode);
207 static int net_close(struct net_device *dev);
208 static void set_rx_mode(struct net_device *dev);
209 static void tx_timeout(struct net_device *dev);
210
211
212 /* A list of all installed ATP devices, for removing the driver module. */
213 static struct net_device *root_atp_dev;
214
215 /* Check for a network adapter of this type, and return '0' iff one exists.
216    If dev->base_addr == 0, probe all likely locations.
217    If dev->base_addr == 1, always return failure.
218    If dev->base_addr == 2, allocate space for the device and return success
219    (detachable devices only).
220
221    FIXME: we should use the parport layer for this
222    */
223 static int __init atp_init(void)
224 {
225         int *port, ports[] = {0x378, 0x278, 0x3bc, 0};
226         int base_addr = io[0];
227
228         if (base_addr > 0x1ff)          /* Check a single specified location. */
229                 return atp_probe1(base_addr);
230         else if (base_addr == 1)        /* Don't probe at all. */
231                 return -ENXIO;
232
233         for (port = ports; *port; port++) {
234                 long ioaddr = *port;
235                 outb(0x57, ioaddr + PAR_DATA);
236                 if (inb(ioaddr + PAR_DATA) != 0x57)
237                         continue;
238                 if (atp_probe1(ioaddr) == 0)
239                         return 0;
240         }
241
242         return -ENODEV;
243 }
244
245 static const struct net_device_ops atp_netdev_ops = {
246         .ndo_open               = net_open,
247         .ndo_stop               = net_close,
248         .ndo_start_xmit         = atp_send_packet,
249         .ndo_set_multicast_list = set_rx_mode,
250         .ndo_tx_timeout         = tx_timeout,
251         .ndo_change_mtu         = eth_change_mtu,
252         .ndo_set_mac_address    = eth_mac_addr,
253         .ndo_validate_addr      = eth_validate_addr,
254 };
255
256 static int __init atp_probe1(long ioaddr)
257 {
258         struct net_device *dev = NULL;
259         struct net_local *lp;
260         int saved_ctrl_reg, status, i;
261         int res;
262
263         outb(0xff, ioaddr + PAR_DATA);
264         /* Save the original value of the Control register, in case we guessed
265            wrong. */
266         saved_ctrl_reg = inb(ioaddr + PAR_CONTROL);
267         if (net_debug > 3)
268                 printk("atp: Control register was %#2.2x.\n", saved_ctrl_reg);
269         /* IRQEN=0, SLCTB=high INITB=high, AUTOFDB=high, STBB=high. */
270         outb(0x04, ioaddr + PAR_CONTROL);
271 #ifndef final_version
272         if (net_debug > 3) {
273                 /* Turn off the printer multiplexer on the 8012. */
274                 for (i = 0; i < 8; i++)
275                         outb(mux_8012[i], ioaddr + PAR_DATA);
276                 write_reg(ioaddr, MODSEL, 0x00);
277                 printk("atp: Registers are ");
278                 for (i = 0; i < 32; i++)
279                         printk(" %2.2x", read_nibble(ioaddr, i));
280                 printk(".\n");
281         }
282 #endif
283         /* Turn off the printer multiplexer on the 8012. */
284         for (i = 0; i < 8; i++)
285                 outb(mux_8012[i], ioaddr + PAR_DATA);
286         write_reg_high(ioaddr, CMR1, CMR1h_RESET);
287         /* udelay() here? */
288         status = read_nibble(ioaddr, CMR1);
289
290         if (net_debug > 3) {
291                 printk(KERN_DEBUG "atp: Status nibble was %#2.2x..", status);
292                 for (i = 0; i < 32; i++)
293                         printk(" %2.2x", read_nibble(ioaddr, i));
294                 printk("\n");
295         }
296
297         if ((status & 0x78) != 0x08) {
298                 /* The pocket adapter probe failed, restore the control register. */
299                 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
300                 return -ENODEV;
301         }
302         status = read_nibble(ioaddr, CMR2_h);
303         if ((status & 0x78) != 0x10) {
304                 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
305                 return -ENODEV;
306         }
307
308         dev = alloc_etherdev(sizeof(struct net_local));
309         if (!dev)
310                 return -ENOMEM;
311
312         /* Find the IRQ used by triggering an interrupt. */
313         write_reg_byte(ioaddr, CMR2, 0x01);                     /* No accept mode, IRQ out. */
314         write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);  /* Enable Tx and Rx. */
315
316         /* Omit autoIRQ routine for now. Use "table lookup" instead.  Uhgggh. */
317         if (irq[0])
318                 dev->irq = irq[0];
319         else if (ioaddr == 0x378)
320                 dev->irq = 7;
321         else
322                 dev->irq = 5;
323         write_reg_high(ioaddr, CMR1, CMR1h_TxRxOFF); /* Disable Tx and Rx units. */
324         write_reg(ioaddr, CMR2, CMR2_NULL);
325
326         dev->base_addr = ioaddr;
327
328         /* Read the station address PROM.  */
329         get_node_ID(dev);
330
331 #ifndef MODULE
332         if (net_debug)
333                 printk(KERN_INFO "%s", version);
334 #endif
335
336         printk(KERN_NOTICE "%s: Pocket adapter found at %#3lx, IRQ %d, "
337                "SAPROM %pM.\n",
338                dev->name, dev->base_addr, dev->irq, dev->dev_addr);
339
340         /* Reset the ethernet hardware and activate the printer pass-through. */
341         write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
342
343         lp = netdev_priv(dev);
344         lp->chip_type = RTL8002;
345         lp->addr_mode = CMR2h_Normal;
346         spin_lock_init(&lp->lock);
347
348         /* For the ATP adapter the "if_port" is really the data transfer mode. */
349         if (xcvr[0])
350                 dev->if_port = xcvr[0];
351         else
352                 dev->if_port = (dev->mem_start & 0xf) ? (dev->mem_start & 0x7) : 4;
353         if (dev->mem_end & 0xf)
354                 net_debug = dev->mem_end & 7;
355
356         dev->netdev_ops         = &atp_netdev_ops;
357         dev->watchdog_timeo     = TX_TIMEOUT;
358
359         res = register_netdev(dev);
360         if (res) {
361                 free_netdev(dev);
362                 return res;
363         }
364
365         lp->next_module = root_atp_dev;
366         root_atp_dev = dev;
367
368         return 0;
369 }
370
371 /* Read the station address PROM, usually a word-wide EEPROM. */
372 static void __init get_node_ID(struct net_device *dev)
373 {
374         long ioaddr = dev->base_addr;
375         int sa_offset = 0;
376         int i;
377
378         write_reg(ioaddr, CMR2, CMR2_EEPROM);     /* Point to the EEPROM control registers. */
379
380         /* Some adapters have the station address at offset 15 instead of offset
381            zero.  Check for it, and fix it if needed. */
382         if (eeprom_op(ioaddr, EE_READ(0)) == 0xffff)
383                 sa_offset = 15;
384
385         for (i = 0; i < 3; i++)
386                 ((__be16 *)dev->dev_addr)[i] =
387                         cpu_to_be16(eeprom_op(ioaddr, EE_READ(sa_offset + i)));
388
389         write_reg(ioaddr, CMR2, CMR2_NULL);
390 }
391
392 /*
393   An EEPROM read command starts by shifting out 0x60+address, and then
394   shifting in the serial data. See the NatSemi databook for details.
395  *                 ________________
396  * CS : __|
397  *                         ___     ___
398  * CLK: ______|   |___|   |
399  *               __ _______ _______
400  * DI :  __X_______X_______X
401  * DO :  _________X_______X
402  */
403
404 static unsigned short __init eeprom_op(long ioaddr, u32 cmd)
405 {
406         unsigned eedata_out = 0;
407         int num_bits = EE_CMD_SIZE;
408
409         while (--num_bits >= 0) {
410                 char outval = (cmd & (1<<num_bits)) ? EE_DATA_WRITE : 0;
411                 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_LOW);
412                 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_HIGH);
413                 eedata_out <<= 1;
414                 if (read_nibble(ioaddr, PROM_DATA) & EE_DATA_READ)
415                         eedata_out++;
416         }
417         write_reg_high(ioaddr, PROM_CMD, EE_CLK_LOW & ~EE_CS);
418         return eedata_out;
419 }
420
421
422 /* Open/initialize the board.  This is called (in the current kernel)
423    sometime after booting when the 'ifconfig' program is run.
424
425    This routine sets everything up anew at each open, even
426    registers that "should" only need to be set once at boot, so that
427    there is non-reboot way to recover if something goes wrong.
428
429    This is an attachable device: if there is no private entry then it wasn't
430    probed for at boot-time, and we need to probe for it again.
431    */
432 static int net_open(struct net_device *dev)
433 {
434         struct net_local *lp = netdev_priv(dev);
435         int ret;
436
437         /* The interrupt line is turned off (tri-stated) when the device isn't in
438            use.  That's especially important for "attached" interfaces where the
439            port or interrupt may be shared. */
440         ret = request_irq(dev->irq, atp_interrupt, 0, dev->name, dev);
441         if (ret)
442                 return ret;
443
444         hardware_init(dev);
445
446         init_timer(&lp->timer);
447         lp->timer.expires = jiffies + TIMED_CHECKER;
448         lp->timer.data = (unsigned long)dev;
449         lp->timer.function = &atp_timed_checker;    /* timer handler */
450         add_timer(&lp->timer);
451
452         netif_start_queue(dev);
453         return 0;
454 }
455
456 /* This routine resets the hardware.  We initialize everything, assuming that
457    the hardware may have been temporarily detached. */
458 static void hardware_init(struct net_device *dev)
459 {
460         struct net_local *lp = netdev_priv(dev);
461         long ioaddr = dev->base_addr;
462     int i;
463
464         /* Turn off the printer multiplexer on the 8012. */
465         for (i = 0; i < 8; i++)
466                 outb(mux_8012[i], ioaddr + PAR_DATA);
467         write_reg_high(ioaddr, CMR1, CMR1h_RESET);
468
469     for (i = 0; i < 6; i++)
470                 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
471
472         write_reg_high(ioaddr, CMR2, lp->addr_mode);
473
474         if (net_debug > 2) {
475                 printk(KERN_DEBUG "%s: Reset: current Rx mode %d.\n", dev->name,
476                            (read_nibble(ioaddr, CMR2_h) >> 3) & 0x0f);
477         }
478
479     write_reg(ioaddr, CMR2, CMR2_IRQOUT);
480     write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
481
482         /* Enable the interrupt line from the serial port. */
483         outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
484
485         /* Unmask the interesting interrupts. */
486     write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
487     write_reg_high(ioaddr, IMR, ISRh_RxErr);
488
489         lp->tx_unit_busy = 0;
490     lp->pac_cnt_in_tx_buf = 0;
491         lp->saved_tx_size = 0;
492 }
493
494 static void trigger_send(long ioaddr, int length)
495 {
496         write_reg_byte(ioaddr, TxCNT0, length & 0xff);
497         write_reg(ioaddr, TxCNT1, length >> 8);
498         write_reg(ioaddr, CMR1, CMR1_Xmit);
499 }
500
501 static void write_packet(long ioaddr, int length, unsigned char *packet, int pad_len, int data_mode)
502 {
503     if (length & 1)
504     {
505         length++;
506         pad_len++;
507     }
508
509     outb(EOC+MAR, ioaddr + PAR_DATA);
510     if ((data_mode & 1) == 0) {
511                 /* Write the packet out, starting with the write addr. */
512                 outb(WrAddr+MAR, ioaddr + PAR_DATA);
513                 do {
514                         write_byte_mode0(ioaddr, *packet++);
515                 } while (--length > pad_len) ;
516                 do {
517                         write_byte_mode0(ioaddr, 0);
518                 } while (--length > 0) ;
519     } else {
520                 /* Write the packet out in slow mode. */
521                 unsigned char outbyte = *packet++;
522
523                 outb(Ctrl_LNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
524                 outb(WrAddr+MAR, ioaddr + PAR_DATA);
525
526                 outb((outbyte & 0x0f)|0x40, ioaddr + PAR_DATA);
527                 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
528                 outbyte >>= 4;
529                 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
530                 outb(Ctrl_HNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
531                 while (--length > pad_len)
532                         write_byte_mode1(ioaddr, *packet++);
533                 while (--length > 0)
534                         write_byte_mode1(ioaddr, 0);
535     }
536     /* Terminate the Tx frame.  End of write: ECB. */
537     outb(0xff, ioaddr + PAR_DATA);
538     outb(Ctrl_HNibWrite | Ctrl_SelData | Ctrl_IRQEN, ioaddr + PAR_CONTROL);
539 }
540
541 static void tx_timeout(struct net_device *dev)
542 {
543         long ioaddr = dev->base_addr;
544
545         printk(KERN_WARNING "%s: Transmit timed out, %s?\n", dev->name,
546                    inb(ioaddr + PAR_CONTROL) & 0x10 ? "network cable problem"
547                    :  "IRQ conflict");
548         dev->stats.tx_errors++;
549         /* Try to restart the adapter. */
550         hardware_init(dev);
551         dev->trans_start = jiffies;
552         netif_wake_queue(dev);
553         dev->stats.tx_errors++;
554 }
555
556 static netdev_tx_t atp_send_packet(struct sk_buff *skb,
557                                    struct net_device *dev)
558 {
559         struct net_local *lp = netdev_priv(dev);
560         long ioaddr = dev->base_addr;
561         int length;
562         unsigned long flags;
563
564         length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
565
566         netif_stop_queue(dev);
567
568         /* Disable interrupts by writing 0x00 to the Interrupt Mask Register.
569            This sequence must not be interrupted by an incoming packet. */
570
571         spin_lock_irqsave(&lp->lock, flags);
572         write_reg(ioaddr, IMR, 0);
573         write_reg_high(ioaddr, IMR, 0);
574         spin_unlock_irqrestore(&lp->lock, flags);
575
576         write_packet(ioaddr, length, skb->data, length-skb->len, dev->if_port);
577
578         lp->pac_cnt_in_tx_buf++;
579         if (lp->tx_unit_busy == 0) {
580                 trigger_send(ioaddr, length);
581                 lp->saved_tx_size = 0;                          /* Redundant */
582                 lp->re_tx = 0;
583                 lp->tx_unit_busy = 1;
584         } else
585                 lp->saved_tx_size = length;
586         /* Re-enable the LPT interrupts. */
587         write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
588         write_reg_high(ioaddr, IMR, ISRh_RxErr);
589
590         dev->trans_start = jiffies;
591         dev_kfree_skb (skb);
592         return NETDEV_TX_OK;
593 }
594
595
596 /* The typical workload of the driver:
597    Handle the network interface interrupts. */
598 static irqreturn_t atp_interrupt(int irq, void *dev_instance)
599 {
600         struct net_device *dev = dev_instance;
601         struct net_local *lp;
602         long ioaddr;
603         static int num_tx_since_rx;
604         int boguscount = max_interrupt_work;
605         int handled = 0;
606
607         ioaddr = dev->base_addr;
608         lp = netdev_priv(dev);
609
610         spin_lock(&lp->lock);
611
612         /* Disable additional spurious interrupts. */
613         outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
614
615         /* The adapter's output is currently the IRQ line, switch it to data. */
616         write_reg(ioaddr, CMR2, CMR2_NULL);
617         write_reg(ioaddr, IMR, 0);
618
619         if (net_debug > 5) printk(KERN_DEBUG "%s: In interrupt ", dev->name);
620     while (--boguscount > 0) {
621                 int status = read_nibble(ioaddr, ISR);
622                 if (net_debug > 5) printk("loop status %02x..", status);
623
624                 if (status & (ISR_RxOK<<3)) {
625                         handled = 1;
626                         write_reg(ioaddr, ISR, ISR_RxOK); /* Clear the Rx interrupt. */
627                         do {
628                                 int read_status = read_nibble(ioaddr, CMR1);
629                                 if (net_debug > 6)
630                                         printk("handling Rx packet %02x..", read_status);
631                                 /* We acknowledged the normal Rx interrupt, so if the interrupt
632                                    is still outstanding we must have a Rx error. */
633                                 if (read_status & (CMR1_IRQ << 3)) { /* Overrun. */
634                                         dev->stats.rx_over_errors++;
635                                         /* Set to no-accept mode long enough to remove a packet. */
636                                         write_reg_high(ioaddr, CMR2, CMR2h_OFF);
637                                         net_rx(dev);
638                                         /* Clear the interrupt and return to normal Rx mode. */
639                                         write_reg_high(ioaddr, ISR, ISRh_RxErr);
640                                         write_reg_high(ioaddr, CMR2, lp->addr_mode);
641                                 } else if ((read_status & (CMR1_BufEnb << 3)) == 0) {
642                                         net_rx(dev);
643                                         num_tx_since_rx = 0;
644                                 } else
645                                         break;
646                         } while (--boguscount > 0);
647                 } else if (status & ((ISR_TxErr + ISR_TxOK)<<3)) {
648                         handled = 1;
649                         if (net_debug > 6)  printk("handling Tx done..");
650                         /* Clear the Tx interrupt.  We should check for too many failures
651                            and reinitialize the adapter. */
652                         write_reg(ioaddr, ISR, ISR_TxErr + ISR_TxOK);
653                         if (status & (ISR_TxErr<<3)) {
654                                 dev->stats.collisions++;
655                                 if (++lp->re_tx > 15) {
656                                         dev->stats.tx_aborted_errors++;
657                                         hardware_init(dev);
658                                         break;
659                                 }
660                                 /* Attempt to retransmit. */
661                                 if (net_debug > 6)  printk("attempting to ReTx");
662                                 write_reg(ioaddr, CMR1, CMR1_ReXmit + CMR1_Xmit);
663                         } else {
664                                 /* Finish up the transmit. */
665                                 dev->stats.tx_packets++;
666                                 lp->pac_cnt_in_tx_buf--;
667                                 if ( lp->saved_tx_size) {
668                                         trigger_send(ioaddr, lp->saved_tx_size);
669                                         lp->saved_tx_size = 0;
670                                         lp->re_tx = 0;
671                                 } else
672                                         lp->tx_unit_busy = 0;
673                                 netif_wake_queue(dev);  /* Inform upper layers. */
674                         }
675                         num_tx_since_rx++;
676                 } else if (num_tx_since_rx > 8
677                                    && time_after(jiffies, dev->last_rx + HZ)) {
678                         if (net_debug > 2)
679                                 printk(KERN_DEBUG "%s: Missed packet? No Rx after %d Tx and "
680                                            "%ld jiffies status %02x  CMR1 %02x.\n", dev->name,
681                                            num_tx_since_rx, jiffies - dev->last_rx, status,
682                                            (read_nibble(ioaddr, CMR1) >> 3) & 15);
683                         dev->stats.rx_missed_errors++;
684                         hardware_init(dev);
685                         num_tx_since_rx = 0;
686                         break;
687                 } else
688                         break;
689     }
690
691         /* This following code fixes a rare (and very difficult to track down)
692            problem where the adapter forgets its ethernet address. */
693         {
694                 int i;
695                 for (i = 0; i < 6; i++)
696                         write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
697 #if 0 && defined(TIMED_CHECKER)
698                 mod_timer(&lp->timer, jiffies + TIMED_CHECKER);
699 #endif
700         }
701
702         /* Tell the adapter that it can go back to using the output line as IRQ. */
703     write_reg(ioaddr, CMR2, CMR2_IRQOUT);
704         /* Enable the physical interrupt line, which is sure to be low until.. */
705         outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
706         /* .. we enable the interrupt sources. */
707         write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
708         write_reg_high(ioaddr, IMR, ISRh_RxErr);                        /* Hmmm, really needed? */
709
710         spin_unlock(&lp->lock);
711
712         if (net_debug > 5) printk("exiting interrupt.\n");
713         return IRQ_RETVAL(handled);
714 }
715
716 #ifdef TIMED_CHECKER
717 /* This following code fixes a rare (and very difficult to track down)
718    problem where the adapter forgets its ethernet address. */
719 static void atp_timed_checker(unsigned long data)
720 {
721         struct net_device *dev = (struct net_device *)data;
722         long ioaddr = dev->base_addr;
723         struct net_local *lp = netdev_priv(dev);
724         int tickssofar = jiffies - lp->last_rx_time;
725         int i;
726
727         spin_lock(&lp->lock);
728         if (tickssofar > 2*HZ) {
729 #if 1
730                 for (i = 0; i < 6; i++)
731                         write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
732                 lp->last_rx_time = jiffies;
733 #else
734                 for (i = 0; i < 6; i++)
735                         if (read_cmd_byte(ioaddr, PAR0 + i) != atp_timed_dev->dev_addr[i])
736                                 {
737                         struct net_local *lp = netdev_priv(atp_timed_dev);
738                         write_reg_byte(ioaddr, PAR0 + i, atp_timed_dev->dev_addr[i]);
739                         if (i == 2)
740                           dev->stats.tx_errors++;
741                         else if (i == 3)
742                           dev->stats.tx_dropped++;
743                         else if (i == 4)
744                           dev->stats.collisions++;
745                         else
746                           dev->stats.rx_errors++;
747                   }
748 #endif
749         }
750         spin_unlock(&lp->lock);
751         lp->timer.expires = jiffies + TIMED_CHECKER;
752         add_timer(&lp->timer);
753 }
754 #endif
755
756 /* We have a good packet(s), get it/them out of the buffers. */
757 static void net_rx(struct net_device *dev)
758 {
759         struct net_local *lp = netdev_priv(dev);
760         long ioaddr = dev->base_addr;
761         struct rx_header rx_head;
762
763         /* Process the received packet. */
764         outb(EOC+MAR, ioaddr + PAR_DATA);
765         read_block(ioaddr, 8, (unsigned char*)&rx_head, dev->if_port);
766         if (net_debug > 5)
767                 printk(KERN_DEBUG " rx_count %04x %04x %04x %04x..", rx_head.pad,
768                            rx_head.rx_count, rx_head.rx_status, rx_head.cur_addr);
769         if ((rx_head.rx_status & 0x77) != 0x01) {
770                 dev->stats.rx_errors++;
771                 if (rx_head.rx_status & 0x0004) dev->stats.rx_frame_errors++;
772                 else if (rx_head.rx_status & 0x0002) dev->stats.rx_crc_errors++;
773                 if (net_debug > 3)
774                         printk(KERN_DEBUG "%s: Unknown ATP Rx error %04x.\n",
775                                    dev->name, rx_head.rx_status);
776                 if  (rx_head.rx_status & 0x0020) {
777                         dev->stats.rx_fifo_errors++;
778                         write_reg_high(ioaddr, CMR1, CMR1h_TxENABLE);
779                         write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
780                 } else if (rx_head.rx_status & 0x0050)
781                         hardware_init(dev);
782                 return;
783         } else {
784                 /* Malloc up new buffer. The "-4" omits the FCS (CRC). */
785                 int pkt_len = (rx_head.rx_count & 0x7ff) - 4;
786                 struct sk_buff *skb;
787
788                 skb = dev_alloc_skb(pkt_len + 2);
789                 if (skb == NULL) {
790                         printk(KERN_ERR "%s: Memory squeeze, dropping packet.\n",
791                                    dev->name);
792                         dev->stats.rx_dropped++;
793                         goto done;
794                 }
795
796                 skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
797                 read_block(ioaddr, pkt_len, skb_put(skb,pkt_len), dev->if_port);
798                 skb->protocol = eth_type_trans(skb, dev);
799                 netif_rx(skb);
800                 dev->last_rx = jiffies;
801                 dev->stats.rx_packets++;
802                 dev->stats.rx_bytes += pkt_len;
803         }
804  done:
805         write_reg(ioaddr, CMR1, CMR1_NextPkt);
806         lp->last_rx_time = jiffies;
807         return;
808 }
809
810 static void read_block(long ioaddr, int length, unsigned char *p, int data_mode)
811 {
812         if (data_mode <= 3) { /* Mode 0 or 1 */
813                 outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
814                 outb(length == 8  ?  RdAddr | HNib | MAR  :  RdAddr | MAR,
815                          ioaddr + PAR_DATA);
816                 if (data_mode <= 1) { /* Mode 0 or 1 */
817                         do { *p++ = read_byte_mode0(ioaddr); } while (--length > 0);
818                 } else { /* Mode 2 or 3 */
819                         do { *p++ = read_byte_mode2(ioaddr); } while (--length > 0);
820                 }
821         } else if (data_mode <= 5) {
822                 do { *p++ = read_byte_mode4(ioaddr); } while (--length > 0);
823         } else {
824                 do { *p++ = read_byte_mode6(ioaddr); } while (--length > 0);
825         }
826
827         outb(EOC+HNib+MAR, ioaddr + PAR_DATA);
828         outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
829 }
830
831 /* The inverse routine to net_open(). */
832 static int
833 net_close(struct net_device *dev)
834 {
835         struct net_local *lp = netdev_priv(dev);
836         long ioaddr = dev->base_addr;
837
838         netif_stop_queue(dev);
839
840         del_timer_sync(&lp->timer);
841
842         /* Flush the Tx and disable Rx here. */
843         lp->addr_mode = CMR2h_OFF;
844         write_reg_high(ioaddr, CMR2, CMR2h_OFF);
845
846         /* Free the IRQ line. */
847         outb(0x00, ioaddr + PAR_CONTROL);
848         free_irq(dev->irq, dev);
849
850         /* Reset the ethernet hardware and activate the printer pass-through. */
851         write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
852         return 0;
853 }
854
855 /*
856  *      Set or clear the multicast filter for this adapter.
857  */
858
859 static void set_rx_mode_8002(struct net_device *dev)
860 {
861         struct net_local *lp = netdev_priv(dev);
862         long ioaddr = dev->base_addr;
863
864         if (dev->mc_count > 0 || (dev->flags & (IFF_ALLMULTI|IFF_PROMISC)))
865                 lp->addr_mode = CMR2h_PROMISC;
866         else
867                 lp->addr_mode = CMR2h_Normal;
868         write_reg_high(ioaddr, CMR2, lp->addr_mode);
869 }
870
871 static void set_rx_mode_8012(struct net_device *dev)
872 {
873         struct net_local *lp = netdev_priv(dev);
874         long ioaddr = dev->base_addr;
875         unsigned char new_mode, mc_filter[8]; /* Multicast hash filter */
876         int i;
877
878         if (dev->flags & IFF_PROMISC) {                 /* Set promiscuous. */
879                 new_mode = CMR2h_PROMISC;
880         } else if ((dev->mc_count > 1000)  ||  (dev->flags & IFF_ALLMULTI)) {
881                 /* Too many to filter perfectly -- accept all multicasts. */
882                 memset(mc_filter, 0xff, sizeof(mc_filter));
883                 new_mode = CMR2h_Normal;
884         } else {
885                 struct dev_mc_list *mclist;
886
887                 memset(mc_filter, 0, sizeof(mc_filter));
888                 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
889                          i++, mclist = mclist->next)
890                 {
891                         int filterbit = ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x3f;
892                         mc_filter[filterbit >> 5] |= 1 << (filterbit & 31);
893                 }
894                 new_mode = CMR2h_Normal;
895         }
896         lp->addr_mode = new_mode;
897     write_reg(ioaddr, CMR2, CMR2_IRQOUT | 0x04); /* Switch to page 1. */
898     for (i = 0; i < 8; i++)
899                 write_reg_byte(ioaddr, i, mc_filter[i]);
900         if (net_debug > 2 || 1) {
901                 lp->addr_mode = 1;
902                 printk(KERN_DEBUG "%s: Mode %d, setting multicast filter to",
903                            dev->name, lp->addr_mode);
904                 for (i = 0; i < 8; i++)
905                         printk(" %2.2x", mc_filter[i]);
906                 printk(".\n");
907         }
908
909         write_reg_high(ioaddr, CMR2, lp->addr_mode);
910     write_reg(ioaddr, CMR2, CMR2_IRQOUT); /* Switch back to page 0 */
911 }
912
913 static void set_rx_mode(struct net_device *dev)
914 {
915         struct net_local *lp = netdev_priv(dev);
916
917         if (lp->chip_type == RTL8002)
918                 return set_rx_mode_8002(dev);
919         else
920                 return set_rx_mode_8012(dev);
921 }
922
923
924 static int __init atp_init_module(void) {
925         if (debug)                                      /* Emit version even if no cards detected. */
926                 printk(KERN_INFO "%s", version);
927         return atp_init();
928 }
929
930 static void __exit atp_cleanup_module(void) {
931         struct net_device *next_dev;
932
933         while (root_atp_dev) {
934                 struct net_local *atp_local = netdev_priv(root_atp_dev);
935                 next_dev = atp_local->next_module;
936                 unregister_netdev(root_atp_dev);
937                 /* No need to release_region(), since we never snarf it. */
938                 free_netdev(root_atp_dev);
939                 root_atp_dev = next_dev;
940         }
941 }
942
943 module_init(atp_init_module);
944 module_exit(atp_cleanup_module);