PageRenderTime 74ms CodeModel.GetById 19ms app.highlight 47ms RepoModel.GetById 1ms app.codeStats 1ms

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

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