1 /* atp.c: Attached (pocket) ethernet adapter driver for linux. */
3 This is a driver for commonly OEM pocket (parallel port)
4 ethernet adapters based on the Realtek RTL8002 and RTL8012 chips.
6 Written 1993-2000 by Donald Becker.
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.
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.
20 The author may be reached as becker@scyld.com, or C/O
21 Scyld Computing Corporation
22 410 Severn Ave., Suite 210
25 Support information and updates available at
26 http://www.scyld.com/network/atp.html
29 Modular support/softnet added by Alan Cox.
30 _bit abuse fixed up by Alan Cox
34 static const char version[] =
35 "atp.c:v1.09=ac 2002/10/01 Donald Becker <becker@scyld.com>\n";
37 /* The user-configurable values.
38 These may be modified when a driver module is loaded.*/
40 static int debug = 1; /* 1 normal messages, 0 quiet .. 7 verbose. */
41 #define net_debug debug
43 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
44 static int max_interrupt_work = 15;
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. */
52 /* Operational parameters that are set at compile time. */
54 /* Time in jiffies before concluding the transmitter is hung. */
55 #define TX_TIMEOUT (400*HZ/1000)
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.
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.
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/
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.
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
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
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
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
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.
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.
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.
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>
143 #include <asm/system.h>
149 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
150 MODULE_DESCRIPTION("RealTek RTL8002/8012 parallel port Ethernet driver");
151 MODULE_LICENSE("GPL");
153 module_param(max_interrupt_work, int, 0);
154 module_param(debug, int, 0);
155 module_param_array(io, int, NULL, 0);
156 module_param_array(irq, int, NULL, 0);
157 module_param_array(xcvr, int, NULL, 0);
158 MODULE_PARM_DESC(max_interrupt_work, "ATP maximum events handled per interrupt");
159 MODULE_PARM_DESC(debug, "ATP debug level (0-7)");
160 MODULE_PARM_DESC(io, "ATP I/O base address(es)");
161 MODULE_PARM_DESC(irq, "ATP IRQ number(s)");
162 MODULE_PARM_DESC(xcvr, "ATP transceiver(s) (0=internal, 1=external)");
164 /* The number of low I/O ports used by the ethercard. */
165 #define ETHERCARD_TOTAL_SIZE 3
167 /* Sequence to switch an 8012 from printer mux to ethernet mode. */
168 static char mux_8012[] = { 0xff, 0xf7, 0xff, 0xfb, 0xf3, 0xfb, 0xff, 0xf7,};
172 struct net_device *next_module;
173 struct timer_list timer; /* Media selection timer. */
174 long last_rx_time; /* Last Rx, in jiffies, to handle Rx hang. */
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. */
182 /* This code, written by wwc@super.org, resets the adapter every
183 TIMED_CHECKER ticks. This recovers from an unknown error which
185 #define TIMED_CHECKER (HZ/4)
187 #include <linux/timer.h>
188 static void atp_timed_checker(unsigned long ignored);
191 /* Index to functions, as function prototypes. */
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);
210 /* A list of all installed ATP devices, for removing the driver module. */
211 static struct net_device *root_atp_dev;
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).
219 FIXME: we should use the parport layer for this
221 static int __init atp_init(void)
223 int *port, ports[] = {0x378, 0x278, 0x3bc, 0};
224 int base_addr = io[0];
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. */
231 for (port = ports; *port; port++) {
233 outb(0x57, ioaddr + PAR_DATA);
234 if (inb(ioaddr + PAR_DATA) != 0x57)
236 if (atp_probe1(ioaddr) == 0)
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,
254 static int __init atp_probe1(long ioaddr)
256 struct net_device *dev = NULL;
257 struct net_local *lp;
258 int saved_ctrl_reg, status, i;
261 outb(0xff, ioaddr + PAR_DATA);
262 /* Save the original value of the Control register, in case we guessed
264 saved_ctrl_reg = inb(ioaddr + PAR_CONTROL);
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
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));
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);
286 status = read_nibble(ioaddr, CMR1);
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));
295 if ((status & 0x78) != 0x08) {
296 /* The pocket adapter probe failed, restore the control register. */
297 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
300 status = read_nibble(ioaddr, CMR2_h);
301 if ((status & 0x78) != 0x10) {
302 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
306 dev = alloc_etherdev(sizeof(struct net_local));
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. */
314 /* Omit autoIRQ routine for now. Use "table lookup" instead. Uhgggh. */
317 else if (ioaddr == 0x378)
321 write_reg_high(ioaddr, CMR1, CMR1h_TxRxOFF); /* Disable Tx and Rx units. */
322 write_reg(ioaddr, CMR2, CMR2_NULL);
324 dev->base_addr = ioaddr;
326 /* Read the station address PROM. */
331 printk(KERN_INFO "%s", version);
334 printk(KERN_NOTICE "%s: Pocket adapter found at %#3lx, IRQ %d, "
336 dev->name, dev->base_addr, dev->irq, dev->dev_addr);
338 /* Reset the ethernet hardware and activate the printer pass-through. */
339 write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
341 lp = netdev_priv(dev);
342 lp->addr_mode = CMR2h_Normal;
343 spin_lock_init(&lp->lock);
345 /* For the ATP adapter the "if_port" is really the data transfer mode. */
347 dev->if_port = xcvr[0];
349 dev->if_port = (dev->mem_start & 0xf) ? (dev->mem_start & 0x7) : 4;
350 if (dev->mem_end & 0xf)
351 net_debug = dev->mem_end & 7;
353 dev->netdev_ops = &atp_netdev_ops;
354 dev->watchdog_timeo = TX_TIMEOUT;
356 res = register_netdev(dev);
362 lp->next_module = root_atp_dev;
368 /* Read the station address PROM, usually a word-wide EEPROM. */
369 static void __init get_node_ID(struct net_device *dev)
371 long ioaddr = dev->base_addr;
375 write_reg(ioaddr, CMR2, CMR2_EEPROM); /* Point to the EEPROM control registers. */
377 /* Some adapters have the station address at offset 15 instead of offset
378 zero. Check for it, and fix it if needed. */
379 if (eeprom_op(ioaddr, EE_READ(0)) == 0xffff)
382 for (i = 0; i < 3; i++)
383 ((__be16 *)dev->dev_addr)[i] =
384 cpu_to_be16(eeprom_op(ioaddr, EE_READ(sa_offset + i)));
386 write_reg(ioaddr, CMR2, CMR2_NULL);
390 An EEPROM read command starts by shifting out 0x60+address, and then
391 shifting in the serial data. See the NatSemi databook for details.
395 * CLK: ______| |___| |
397 * DI : __X_______X_______X
398 * DO : _________X_______X
401 static unsigned short __init eeprom_op(long ioaddr, u32 cmd)
403 unsigned eedata_out = 0;
404 int num_bits = EE_CMD_SIZE;
406 while (--num_bits >= 0) {
407 char outval = (cmd & (1<<num_bits)) ? EE_DATA_WRITE : 0;
408 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_LOW);
409 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_HIGH);
411 if (read_nibble(ioaddr, PROM_DATA) & EE_DATA_READ)
414 write_reg_high(ioaddr, PROM_CMD, EE_CLK_LOW & ~EE_CS);
419 /* Open/initialize the board. This is called (in the current kernel)
420 sometime after booting when the 'ifconfig' program is run.
422 This routine sets everything up anew at each open, even
423 registers that "should" only need to be set once at boot, so that
424 there is non-reboot way to recover if something goes wrong.
426 This is an attachable device: if there is no private entry then it wasn't
427 probed for at boot-time, and we need to probe for it again.
429 static int net_open(struct net_device *dev)
431 struct net_local *lp = netdev_priv(dev);
434 /* The interrupt line is turned off (tri-stated) when the device isn't in
435 use. That's especially important for "attached" interfaces where the
436 port or interrupt may be shared. */
437 ret = request_irq(dev->irq, atp_interrupt, 0, dev->name, dev);
443 init_timer(&lp->timer);
444 lp->timer.expires = jiffies + TIMED_CHECKER;
445 lp->timer.data = (unsigned long)dev;
446 lp->timer.function = atp_timed_checker; /* timer handler */
447 add_timer(&lp->timer);
449 netif_start_queue(dev);
453 /* This routine resets the hardware. We initialize everything, assuming that
454 the hardware may have been temporarily detached. */
455 static void hardware_init(struct net_device *dev)
457 struct net_local *lp = netdev_priv(dev);
458 long ioaddr = dev->base_addr;
461 /* Turn off the printer multiplexer on the 8012. */
462 for (i = 0; i < 8; i++)
463 outb(mux_8012[i], ioaddr + PAR_DATA);
464 write_reg_high(ioaddr, CMR1, CMR1h_RESET);
466 for (i = 0; i < 6; i++)
467 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
469 write_reg_high(ioaddr, CMR2, lp->addr_mode);
472 printk(KERN_DEBUG "%s: Reset: current Rx mode %d.\n", dev->name,
473 (read_nibble(ioaddr, CMR2_h) >> 3) & 0x0f);
476 write_reg(ioaddr, CMR2, CMR2_IRQOUT);
477 write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
479 /* Enable the interrupt line from the serial port. */
480 outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
482 /* Unmask the interesting interrupts. */
483 write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
484 write_reg_high(ioaddr, IMR, ISRh_RxErr);
486 lp->tx_unit_busy = 0;
487 lp->pac_cnt_in_tx_buf = 0;
488 lp->saved_tx_size = 0;
491 static void trigger_send(long ioaddr, int length)
493 write_reg_byte(ioaddr, TxCNT0, length & 0xff);
494 write_reg(ioaddr, TxCNT1, length >> 8);
495 write_reg(ioaddr, CMR1, CMR1_Xmit);
498 static void write_packet(long ioaddr, int length, unsigned char *packet, int pad_len, int data_mode)
506 outb(EOC+MAR, ioaddr + PAR_DATA);
507 if ((data_mode & 1) == 0) {
508 /* Write the packet out, starting with the write addr. */
509 outb(WrAddr+MAR, ioaddr + PAR_DATA);
511 write_byte_mode0(ioaddr, *packet++);
512 } while (--length > pad_len) ;
514 write_byte_mode0(ioaddr, 0);
515 } while (--length > 0) ;
517 /* Write the packet out in slow mode. */
518 unsigned char outbyte = *packet++;
520 outb(Ctrl_LNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
521 outb(WrAddr+MAR, ioaddr + PAR_DATA);
523 outb((outbyte & 0x0f)|0x40, ioaddr + PAR_DATA);
524 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
526 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
527 outb(Ctrl_HNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
528 while (--length > pad_len)
529 write_byte_mode1(ioaddr, *packet++);
531 write_byte_mode1(ioaddr, 0);
533 /* Terminate the Tx frame. End of write: ECB. */
534 outb(0xff, ioaddr + PAR_DATA);
535 outb(Ctrl_HNibWrite | Ctrl_SelData | Ctrl_IRQEN, ioaddr + PAR_CONTROL);
538 static void tx_timeout(struct net_device *dev)
540 long ioaddr = dev->base_addr;
542 printk(KERN_WARNING "%s: Transmit timed out, %s?\n", dev->name,
543 inb(ioaddr + PAR_CONTROL) & 0x10 ? "network cable problem"
545 dev->stats.tx_errors++;
546 /* Try to restart the adapter. */
548 dev->trans_start = jiffies; /* prevent tx timeout */
549 netif_wake_queue(dev);
550 dev->stats.tx_errors++;
553 static netdev_tx_t atp_send_packet(struct sk_buff *skb,
554 struct net_device *dev)
556 struct net_local *lp = netdev_priv(dev);
557 long ioaddr = dev->base_addr;
561 length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
563 netif_stop_queue(dev);
565 /* Disable interrupts by writing 0x00 to the Interrupt Mask Register.
566 This sequence must not be interrupted by an incoming packet. */
568 spin_lock_irqsave(&lp->lock, flags);
569 write_reg(ioaddr, IMR, 0);
570 write_reg_high(ioaddr, IMR, 0);
571 spin_unlock_irqrestore(&lp->lock, flags);
573 write_packet(ioaddr, length, skb->data, length-skb->len, dev->if_port);
575 lp->pac_cnt_in_tx_buf++;
576 if (lp->tx_unit_busy == 0) {
577 trigger_send(ioaddr, length);
578 lp->saved_tx_size = 0; /* Redundant */
580 lp->tx_unit_busy = 1;
582 lp->saved_tx_size = length;
583 /* Re-enable the LPT interrupts. */
584 write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
585 write_reg_high(ioaddr, IMR, ISRh_RxErr);
592 /* The typical workload of the driver:
593 Handle the network interface interrupts. */
594 static irqreturn_t atp_interrupt(int irq, void *dev_instance)
596 struct net_device *dev = dev_instance;
597 struct net_local *lp;
599 static int num_tx_since_rx;
600 int boguscount = max_interrupt_work;
603 ioaddr = dev->base_addr;
604 lp = netdev_priv(dev);
606 spin_lock(&lp->lock);
608 /* Disable additional spurious interrupts. */
609 outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
611 /* The adapter's output is currently the IRQ line, switch it to data. */
612 write_reg(ioaddr, CMR2, CMR2_NULL);
613 write_reg(ioaddr, IMR, 0);
615 if (net_debug > 5) printk(KERN_DEBUG "%s: In interrupt ", dev->name);
616 while (--boguscount > 0) {
617 int status = read_nibble(ioaddr, ISR);
618 if (net_debug > 5) printk("loop status %02x..", status);
620 if (status & (ISR_RxOK<<3)) {
622 write_reg(ioaddr, ISR, ISR_RxOK); /* Clear the Rx interrupt. */
624 int read_status = read_nibble(ioaddr, CMR1);
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);
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) {
642 } while (--boguscount > 0);
643 } else if (status & ((ISR_TxErr + ISR_TxOK)<<3)) {
645 if (net_debug > 6) printk("handling Tx done..");
646 /* Clear the Tx interrupt. We should check for too many failures
647 and reinitialize the adapter. */
648 write_reg(ioaddr, ISR, ISR_TxErr + ISR_TxOK);
649 if (status & (ISR_TxErr<<3)) {
650 dev->stats.collisions++;
651 if (++lp->re_tx > 15) {
652 dev->stats.tx_aborted_errors++;
656 /* Attempt to retransmit. */
657 if (net_debug > 6) printk("attempting to ReTx");
658 write_reg(ioaddr, CMR1, CMR1_ReXmit + CMR1_Xmit);
660 /* Finish up the transmit. */
661 dev->stats.tx_packets++;
662 lp->pac_cnt_in_tx_buf--;
663 if ( lp->saved_tx_size) {
664 trigger_send(ioaddr, lp->saved_tx_size);
665 lp->saved_tx_size = 0;
668 lp->tx_unit_busy = 0;
669 netif_wake_queue(dev); /* Inform upper layers. */
672 } else if (num_tx_since_rx > 8 &&
673 time_after(jiffies, dev->last_rx + HZ)) {
675 printk(KERN_DEBUG "%s: Missed packet? No Rx after %d Tx and "
676 "%ld jiffies status %02x CMR1 %02x.\n", dev->name,
677 num_tx_since_rx, jiffies - dev->last_rx, status,
678 (read_nibble(ioaddr, CMR1) >> 3) & 15);
679 dev->stats.rx_missed_errors++;
687 /* This following code fixes a rare (and very difficult to track down)
688 problem where the adapter forgets its ethernet address. */
691 for (i = 0; i < 6; i++)
692 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
693 #if 0 && defined(TIMED_CHECKER)
694 mod_timer(&lp->timer, jiffies + TIMED_CHECKER);
698 /* Tell the adapter that it can go back to using the output line as IRQ. */
699 write_reg(ioaddr, CMR2, CMR2_IRQOUT);
700 /* Enable the physical interrupt line, which is sure to be low until.. */
701 outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
702 /* .. we enable the interrupt sources. */
703 write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
704 write_reg_high(ioaddr, IMR, ISRh_RxErr); /* Hmmm, really needed? */
706 spin_unlock(&lp->lock);
708 if (net_debug > 5) printk("exiting interrupt.\n");
709 return IRQ_RETVAL(handled);
713 /* This following code fixes a rare (and very difficult to track down)
714 problem where the adapter forgets its ethernet address. */
715 static void atp_timed_checker(unsigned long data)
717 struct net_device *dev = (struct net_device *)data;
718 long ioaddr = dev->base_addr;
719 struct net_local *lp = netdev_priv(dev);
720 int tickssofar = jiffies - lp->last_rx_time;
723 spin_lock(&lp->lock);
724 if (tickssofar > 2*HZ) {
726 for (i = 0; i < 6; i++)
727 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
728 lp->last_rx_time = jiffies;
730 for (i = 0; i < 6; i++)
731 if (read_cmd_byte(ioaddr, PAR0 + i) != atp_timed_dev->dev_addr[i])
733 struct net_local *lp = netdev_priv(atp_timed_dev);
734 write_reg_byte(ioaddr, PAR0 + i, atp_timed_dev->dev_addr[i]);
736 dev->stats.tx_errors++;
738 dev->stats.tx_dropped++;
740 dev->stats.collisions++;
742 dev->stats.rx_errors++;
746 spin_unlock(&lp->lock);
747 lp->timer.expires = jiffies + TIMED_CHECKER;
748 add_timer(&lp->timer);
752 /* We have a good packet(s), get it/them out of the buffers. */
753 static void net_rx(struct net_device *dev)
755 struct net_local *lp = netdev_priv(dev);
756 long ioaddr = dev->base_addr;
757 struct rx_header rx_head;
759 /* Process the received packet. */
760 outb(EOC+MAR, ioaddr + PAR_DATA);
761 read_block(ioaddr, 8, (unsigned char*)&rx_head, dev->if_port);
763 printk(KERN_DEBUG " rx_count %04x %04x %04x %04x..", rx_head.pad,
764 rx_head.rx_count, rx_head.rx_status, rx_head.cur_addr);
765 if ((rx_head.rx_status & 0x77) != 0x01) {
766 dev->stats.rx_errors++;
767 if (rx_head.rx_status & 0x0004) dev->stats.rx_frame_errors++;
768 else if (rx_head.rx_status & 0x0002) dev->stats.rx_crc_errors++;
770 printk(KERN_DEBUG "%s: Unknown ATP Rx error %04x.\n",
771 dev->name, rx_head.rx_status);
772 if (rx_head.rx_status & 0x0020) {
773 dev->stats.rx_fifo_errors++;
774 write_reg_high(ioaddr, CMR1, CMR1h_TxENABLE);
775 write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
776 } else if (rx_head.rx_status & 0x0050)
780 /* Malloc up new buffer. The "-4" omits the FCS (CRC). */
781 int pkt_len = (rx_head.rx_count & 0x7ff) - 4;
784 skb = dev_alloc_skb(pkt_len + 2);
786 printk(KERN_ERR "%s: Memory squeeze, dropping packet.\n",
788 dev->stats.rx_dropped++;
792 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
793 read_block(ioaddr, pkt_len, skb_put(skb,pkt_len), dev->if_port);
794 skb->protocol = eth_type_trans(skb, dev);
796 dev->last_rx = jiffies;
797 dev->stats.rx_packets++;
798 dev->stats.rx_bytes += pkt_len;
801 write_reg(ioaddr, CMR1, CMR1_NextPkt);
802 lp->last_rx_time = jiffies;
805 static void read_block(long ioaddr, int length, unsigned char *p, int data_mode)
807 if (data_mode <= 3) { /* Mode 0 or 1 */
808 outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
809 outb(length == 8 ? RdAddr | HNib | MAR : RdAddr | MAR,
811 if (data_mode <= 1) { /* Mode 0 or 1 */
812 do { *p++ = read_byte_mode0(ioaddr); } while (--length > 0);
813 } else { /* Mode 2 or 3 */
814 do { *p++ = read_byte_mode2(ioaddr); } while (--length > 0);
816 } else if (data_mode <= 5) {
817 do { *p++ = read_byte_mode4(ioaddr); } while (--length > 0);
819 do { *p++ = read_byte_mode6(ioaddr); } while (--length > 0);
822 outb(EOC+HNib+MAR, ioaddr + PAR_DATA);
823 outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
826 /* The inverse routine to net_open(). */
828 net_close(struct net_device *dev)
830 struct net_local *lp = netdev_priv(dev);
831 long ioaddr = dev->base_addr;
833 netif_stop_queue(dev);
835 del_timer_sync(&lp->timer);
837 /* Flush the Tx and disable Rx here. */
838 lp->addr_mode = CMR2h_OFF;
839 write_reg_high(ioaddr, CMR2, CMR2h_OFF);
841 /* Free the IRQ line. */
842 outb(0x00, ioaddr + PAR_CONTROL);
843 free_irq(dev->irq, dev);
845 /* Reset the ethernet hardware and activate the printer pass-through. */
846 write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
851 * Set or clear the multicast filter for this adapter.
854 static void set_rx_mode(struct net_device *dev)
856 struct net_local *lp = netdev_priv(dev);
857 long ioaddr = dev->base_addr;
859 if (!netdev_mc_empty(dev) || (dev->flags & (IFF_ALLMULTI|IFF_PROMISC)))
860 lp->addr_mode = CMR2h_PROMISC;
862 lp->addr_mode = CMR2h_Normal;
863 write_reg_high(ioaddr, CMR2, lp->addr_mode);
866 static int __init atp_init_module(void) {
867 if (debug) /* Emit version even if no cards detected. */
868 printk(KERN_INFO "%s", version);
872 static void __exit atp_cleanup_module(void) {
873 struct net_device *next_dev;
875 while (root_atp_dev) {
876 struct net_local *atp_local = netdev_priv(root_atp_dev);
877 next_dev = atp_local->next_module;
878 unregister_netdev(root_atp_dev);
879 /* No need to release_region(), since we never snarf it. */
880 free_netdev(root_atp_dev);
881 root_atp_dev = next_dev;
885 module_init(atp_init_module);
886 module_exit(atp_cleanup_module);