blob: 82d78ff8399bbeea1046b1efa241e3bf2fd181bd [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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
Markus Dahms2c2a8c52007-05-09 07:58:10 +020034static const char version[] =
Linus Torvalds1da177e2005-04-16 15:20:36 -070035"atp.c:v1.09=ac 2002/10/01 Donald Becker <becker@scyld.com>\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
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/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
150MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
151MODULE_DESCRIPTION("RealTek RTL8002/8012 parallel port Ethernet driver");
152MODULE_LICENSE("GPL");
153
154module_param(max_interrupt_work, int, 0);
155module_param(debug, int, 0);
156module_param_array(io, int, NULL, 0);
157module_param_array(irq, int, NULL, 0);
158module_param_array(xcvr, int, NULL, 0);
159MODULE_PARM_DESC(max_interrupt_work, "ATP maximum events handled per interrupt");
160MODULE_PARM_DESC(debug, "ATP debug level (0-7)");
161MODULE_PARM_DESC(io, "ATP I/O base address(es)");
162MODULE_PARM_DESC(irq, "ATP IRQ number(s)");
163MODULE_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. */
169static char mux_8012[] = { 0xff, 0xf7, 0xff, 0xfb, 0xf3, 0xfb, 0xff, 0xf7,};
170
171struct net_local {
172 spinlock_t lock;
173 struct net_device *next_module;
174 struct net_device_stats stats;
175 struct timer_list timer; /* Media selection timer. */
176 long last_rx_time; /* Last Rx, in jiffies, to handle Rx hang. */
177 int saved_tx_size;
178 unsigned int tx_unit_busy:1;
179 unsigned char re_tx, /* Number of packet retransmissions. */
180 addr_mode, /* Current Rx filter e.g. promiscuous, etc. */
181 pac_cnt_in_tx_buf,
182 chip_type;
183};
184
185/* This code, written by wwc@super.org, resets the adapter every
186 TIMED_CHECKER ticks. This recovers from an unknown error which
187 hangs the device. */
188#define TIMED_CHECKER (HZ/4)
189#ifdef TIMED_CHECKER
190#include <linux/timer.h>
191static void atp_timed_checker(unsigned long ignored);
192#endif
193
194/* Index to functions, as function prototypes. */
195
196static int atp_probe1(long ioaddr);
197static void get_node_ID(struct net_device *dev);
198static unsigned short eeprom_op(long ioaddr, unsigned int cmd);
199static int net_open(struct net_device *dev);
200static void hardware_init(struct net_device *dev);
201static void write_packet(long ioaddr, int length, unsigned char *packet, int pad, int mode);
202static void trigger_send(long ioaddr, int length);
203static int atp_send_packet(struct sk_buff *skb, struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100204static irqreturn_t atp_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205static void net_rx(struct net_device *dev);
206static void read_block(long ioaddr, int length, unsigned char *buffer, int data_mode);
207static int net_close(struct net_device *dev);
208static struct net_device_stats *net_get_stats(struct net_device *dev);
209static void set_rx_mode_8002(struct net_device *dev);
210static void set_rx_mode_8012(struct net_device *dev);
211static void tx_timeout(struct net_device *dev);
212
213
214/* A list of all installed ATP devices, for removing the driver module. */
215static struct net_device *root_atp_dev;
216
217/* Check for a network adapter of this type, and return '0' iff one exists.
218 If dev->base_addr == 0, probe all likely locations.
219 If dev->base_addr == 1, always return failure.
220 If dev->base_addr == 2, allocate space for the device and return success
221 (detachable devices only).
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400222
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 FIXME: we should use the parport layer for this
224 */
225static int __init atp_init(void)
226{
227 int *port, ports[] = {0x378, 0x278, 0x3bc, 0};
228 int base_addr = io[0];
229
230 if (base_addr > 0x1ff) /* Check a single specified location. */
231 return atp_probe1(base_addr);
232 else if (base_addr == 1) /* Don't probe at all. */
233 return -ENXIO;
234
235 for (port = ports; *port; port++) {
236 long ioaddr = *port;
237 outb(0x57, ioaddr + PAR_DATA);
238 if (inb(ioaddr + PAR_DATA) != 0x57)
239 continue;
240 if (atp_probe1(ioaddr) == 0)
241 return 0;
242 }
243
244 return -ENODEV;
245}
246
247static int __init atp_probe1(long ioaddr)
248{
249 struct net_device *dev = NULL;
250 struct net_local *lp;
251 int saved_ctrl_reg, status, i;
252 int res;
253
254 outb(0xff, ioaddr + PAR_DATA);
255 /* Save the original value of the Control register, in case we guessed
256 wrong. */
257 saved_ctrl_reg = inb(ioaddr + PAR_CONTROL);
258 if (net_debug > 3)
259 printk("atp: Control register was %#2.2x.\n", saved_ctrl_reg);
260 /* IRQEN=0, SLCTB=high INITB=high, AUTOFDB=high, STBB=high. */
261 outb(0x04, ioaddr + PAR_CONTROL);
262#ifndef final_version
263 if (net_debug > 3) {
264 /* Turn off the printer multiplexer on the 8012. */
265 for (i = 0; i < 8; i++)
266 outb(mux_8012[i], ioaddr + PAR_DATA);
267 write_reg(ioaddr, MODSEL, 0x00);
268 printk("atp: Registers are ");
269 for (i = 0; i < 32; i++)
270 printk(" %2.2x", read_nibble(ioaddr, i));
271 printk(".\n");
272 }
273#endif
274 /* Turn off the printer multiplexer on the 8012. */
275 for (i = 0; i < 8; i++)
276 outb(mux_8012[i], ioaddr + PAR_DATA);
277 write_reg_high(ioaddr, CMR1, CMR1h_RESET);
278 /* udelay() here? */
279 status = read_nibble(ioaddr, CMR1);
280
281 if (net_debug > 3) {
282 printk(KERN_DEBUG "atp: Status nibble was %#2.2x..", status);
283 for (i = 0; i < 32; i++)
284 printk(" %2.2x", read_nibble(ioaddr, i));
285 printk("\n");
286 }
287
288 if ((status & 0x78) != 0x08) {
289 /* The pocket adapter probe failed, restore the control register. */
290 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
291 return -ENODEV;
292 }
293 status = read_nibble(ioaddr, CMR2_h);
294 if ((status & 0x78) != 0x10) {
295 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
296 return -ENODEV;
297 }
298
299 dev = alloc_etherdev(sizeof(struct net_local));
300 if (!dev)
301 return -ENOMEM;
302 SET_MODULE_OWNER(dev);
303
304 /* Find the IRQ used by triggering an interrupt. */
305 write_reg_byte(ioaddr, CMR2, 0x01); /* No accept mode, IRQ out. */
306 write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE); /* Enable Tx and Rx. */
307
308 /* Omit autoIRQ routine for now. Use "table lookup" instead. Uhgggh. */
309 if (irq[0])
310 dev->irq = irq[0];
311 else if (ioaddr == 0x378)
312 dev->irq = 7;
313 else
314 dev->irq = 5;
315 write_reg_high(ioaddr, CMR1, CMR1h_TxRxOFF); /* Disable Tx and Rx units. */
316 write_reg(ioaddr, CMR2, CMR2_NULL);
317
318 dev->base_addr = ioaddr;
319
320 /* Read the station address PROM. */
321 get_node_ID(dev);
322
323#ifndef MODULE
324 if (net_debug)
Markus Dahms2c2a8c52007-05-09 07:58:10 +0200325 printk(KERN_INFO "%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326#endif
327
328 printk(KERN_NOTICE "%s: Pocket adapter found at %#3lx, IRQ %d, SAPROM "
329 "%02X:%02X:%02X:%02X:%02X:%02X.\n", dev->name, dev->base_addr,
330 dev->irq, dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
331 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
332
333 /* Reset the ethernet hardware and activate the printer pass-through. */
334 write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
335
336 lp = netdev_priv(dev);
337 lp->chip_type = RTL8002;
338 lp->addr_mode = CMR2h_Normal;
339 spin_lock_init(&lp->lock);
340
341 /* For the ATP adapter the "if_port" is really the data transfer mode. */
342 if (xcvr[0])
343 dev->if_port = xcvr[0];
344 else
345 dev->if_port = (dev->mem_start & 0xf) ? (dev->mem_start & 0x7) : 4;
346 if (dev->mem_end & 0xf)
347 net_debug = dev->mem_end & 7;
348
349 dev->open = net_open;
350 dev->stop = net_close;
351 dev->hard_start_xmit = atp_send_packet;
352 dev->get_stats = net_get_stats;
353 dev->set_multicast_list =
354 lp->chip_type == RTL8002 ? &set_rx_mode_8002 : &set_rx_mode_8012;
355 dev->tx_timeout = tx_timeout;
356 dev->watchdog_timeo = TX_TIMEOUT;
357
358 res = register_netdev(dev);
359 if (res) {
360 free_netdev(dev);
361 return res;
362 }
363
364 lp->next_module = root_atp_dev;
365 root_atp_dev = dev;
366
367 return 0;
368}
369
370/* Read the station address PROM, usually a word-wide EEPROM. */
371static void __init get_node_ID(struct net_device *dev)
372{
373 long ioaddr = dev->base_addr;
374 int sa_offset = 0;
375 int i;
376
377 write_reg(ioaddr, CMR2, CMR2_EEPROM); /* Point to the EEPROM control registers. */
378
379 /* Some adapters have the station address at offset 15 instead of offset
380 zero. Check for it, and fix it if needed. */
381 if (eeprom_op(ioaddr, EE_READ(0)) == 0xffff)
382 sa_offset = 15;
383
384 for (i = 0; i < 3; i++)
385 ((u16 *)dev->dev_addr)[i] =
386 be16_to_cpu(eeprom_op(ioaddr, EE_READ(sa_offset + i)));
387
388 write_reg(ioaddr, CMR2, CMR2_NULL);
389}
390
391/*
392 An EEPROM read command starts by shifting out 0x60+address, and then
393 shifting in the serial data. See the NatSemi databook for details.
394 * ________________
395 * CS : __|
396 * ___ ___
397 * CLK: ______| |___| |
398 * __ _______ _______
399 * DI : __X_______X_______X
400 * DO : _________X_______X
401 */
402
403static unsigned short __init eeprom_op(long ioaddr, u32 cmd)
404{
405 unsigned eedata_out = 0;
406 int num_bits = EE_CMD_SIZE;
407
408 while (--num_bits >= 0) {
409 char outval = (cmd & (1<<num_bits)) ? EE_DATA_WRITE : 0;
410 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_LOW);
411 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_HIGH);
412 eedata_out <<= 1;
413 if (read_nibble(ioaddr, PROM_DATA) & EE_DATA_READ)
414 eedata_out++;
415 }
416 write_reg_high(ioaddr, PROM_CMD, EE_CLK_LOW & ~EE_CS);
417 return eedata_out;
418}
419
420
421/* Open/initialize the board. This is called (in the current kernel)
422 sometime after booting when the 'ifconfig' program is run.
423
424 This routine sets everything up anew at each open, even
425 registers that "should" only need to be set once at boot, so that
426 there is non-reboot way to recover if something goes wrong.
427
428 This is an attachable device: if there is no dev->priv entry then it wasn't
429 probed for at boot-time, and we need to probe for it again.
430 */
431static int net_open(struct net_device *dev)
432{
433 struct net_local *lp = netdev_priv(dev);
434 int ret;
435
436 /* The interrupt line is turned off (tri-stated) when the device isn't in
437 use. That's especially important for "attached" interfaces where the
438 port or interrupt may be shared. */
439 ret = request_irq(dev->irq, &atp_interrupt, 0, dev->name, dev);
440 if (ret)
441 return ret;
442
443 hardware_init(dev);
444
445 init_timer(&lp->timer);
446 lp->timer.expires = jiffies + TIMED_CHECKER;
447 lp->timer.data = (unsigned long)dev;
448 lp->timer.function = &atp_timed_checker; /* timer handler */
449 add_timer(&lp->timer);
450
451 netif_start_queue(dev);
452 return 0;
453}
454
455/* This routine resets the hardware. We initialize everything, assuming that
456 the hardware may have been temporarily detached. */
457static void hardware_init(struct net_device *dev)
458{
459 struct net_local *lp = netdev_priv(dev);
460 long ioaddr = dev->base_addr;
461 int i;
462
463 /* Turn off the printer multiplexer on the 8012. */
464 for (i = 0; i < 8; i++)
465 outb(mux_8012[i], ioaddr + PAR_DATA);
466 write_reg_high(ioaddr, CMR1, CMR1h_RESET);
467
468 for (i = 0; i < 6; i++)
469 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
470
471 write_reg_high(ioaddr, CMR2, lp->addr_mode);
472
473 if (net_debug > 2) {
474 printk(KERN_DEBUG "%s: Reset: current Rx mode %d.\n", dev->name,
475 (read_nibble(ioaddr, CMR2_h) >> 3) & 0x0f);
476 }
477
478 write_reg(ioaddr, CMR2, CMR2_IRQOUT);
479 write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
480
481 /* Enable the interrupt line from the serial port. */
482 outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
483
484 /* Unmask the interesting interrupts. */
485 write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
486 write_reg_high(ioaddr, IMR, ISRh_RxErr);
487
488 lp->tx_unit_busy = 0;
489 lp->pac_cnt_in_tx_buf = 0;
490 lp->saved_tx_size = 0;
491}
492
493static void trigger_send(long ioaddr, int length)
494{
495 write_reg_byte(ioaddr, TxCNT0, length & 0xff);
496 write_reg(ioaddr, TxCNT1, length >> 8);
497 write_reg(ioaddr, CMR1, CMR1_Xmit);
498}
499
500static void write_packet(long ioaddr, int length, unsigned char *packet, int pad_len, int data_mode)
501{
502 if (length & 1)
503 {
504 length++;
505 pad_len++;
506 }
507
508 outb(EOC+MAR, ioaddr + PAR_DATA);
509 if ((data_mode & 1) == 0) {
510 /* Write the packet out, starting with the write addr. */
511 outb(WrAddr+MAR, ioaddr + PAR_DATA);
512 do {
513 write_byte_mode0(ioaddr, *packet++);
514 } while (--length > pad_len) ;
515 do {
516 write_byte_mode0(ioaddr, 0);
517 } while (--length > 0) ;
518 } else {
519 /* Write the packet out in slow mode. */
520 unsigned char outbyte = *packet++;
521
522 outb(Ctrl_LNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
523 outb(WrAddr+MAR, ioaddr + PAR_DATA);
524
525 outb((outbyte & 0x0f)|0x40, ioaddr + PAR_DATA);
526 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
527 outbyte >>= 4;
528 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
529 outb(Ctrl_HNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
530 while (--length > pad_len)
531 write_byte_mode1(ioaddr, *packet++);
532 while (--length > 0)
533 write_byte_mode1(ioaddr, 0);
534 }
535 /* Terminate the Tx frame. End of write: ECB. */
536 outb(0xff, ioaddr + PAR_DATA);
537 outb(Ctrl_HNibWrite | Ctrl_SelData | Ctrl_IRQEN, ioaddr + PAR_CONTROL);
538}
539
540static void tx_timeout(struct net_device *dev)
541{
542 struct net_local *np = netdev_priv(dev);
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 np->stats.tx_errors++;
549 /* Try to restart the adapter. */
550 hardware_init(dev);
551 dev->trans_start = jiffies;
552 netif_wake_queue(dev);
553 np->stats.tx_errors++;
554}
555
556static int atp_send_packet(struct sk_buff *skb, struct net_device *dev)
557{
558 struct net_local *lp = netdev_priv(dev);
559 long ioaddr = dev->base_addr;
560 int length;
561 unsigned long flags;
562
563 length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
564
565 netif_stop_queue(dev);
566
567 /* Disable interrupts by writing 0x00 to the Interrupt Mask Register.
568 This sequence must not be interrupted by an incoming packet. */
569
570 spin_lock_irqsave(&lp->lock, flags);
571 write_reg(ioaddr, IMR, 0);
572 write_reg_high(ioaddr, IMR, 0);
573 spin_unlock_irqrestore(&lp->lock, flags);
574
575 write_packet(ioaddr, length, skb->data, length-skb->len, dev->if_port);
576
577 lp->pac_cnt_in_tx_buf++;
578 if (lp->tx_unit_busy == 0) {
579 trigger_send(ioaddr, length);
580 lp->saved_tx_size = 0; /* Redundant */
581 lp->re_tx = 0;
582 lp->tx_unit_busy = 1;
583 } else
584 lp->saved_tx_size = length;
585 /* Re-enable the LPT interrupts. */
586 write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
587 write_reg_high(ioaddr, IMR, ISRh_RxErr);
588
589 dev->trans_start = jiffies;
590 dev_kfree_skb (skb);
591 return 0;
592}
593
594
595/* The typical workload of the driver:
596 Handle the network interface interrupts. */
David Howells7d12e782006-10-05 14:55:46 +0100597static irqreturn_t atp_interrupt(int irq, void *dev_instance)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598{
Jeff Garzikc31f28e2006-10-06 14:56:04 -0400599 struct net_device *dev = dev_instance;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 struct net_local *lp;
601 long ioaddr;
602 static int num_tx_since_rx;
603 int boguscount = max_interrupt_work;
604 int handled = 0;
605
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 ioaddr = dev->base_addr;
607 lp = netdev_priv(dev);
608
609 spin_lock(&lp->lock);
610
611 /* Disable additional spurious interrupts. */
612 outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
613
614 /* The adapter's output is currently the IRQ line, switch it to data. */
615 write_reg(ioaddr, CMR2, CMR2_NULL);
616 write_reg(ioaddr, IMR, 0);
617
618 if (net_debug > 5) printk(KERN_DEBUG "%s: In interrupt ", dev->name);
619 while (--boguscount > 0) {
620 int status = read_nibble(ioaddr, ISR);
621 if (net_debug > 5) printk("loop status %02x..", status);
622
623 if (status & (ISR_RxOK<<3)) {
624 handled = 1;
625 write_reg(ioaddr, ISR, ISR_RxOK); /* Clear the Rx interrupt. */
626 do {
627 int read_status = read_nibble(ioaddr, CMR1);
628 if (net_debug > 6)
629 printk("handling Rx packet %02x..", read_status);
630 /* We acknowledged the normal Rx interrupt, so if the interrupt
631 is still outstanding we must have a Rx error. */
632 if (read_status & (CMR1_IRQ << 3)) { /* Overrun. */
633 lp->stats.rx_over_errors++;
634 /* Set to no-accept mode long enough to remove a packet. */
635 write_reg_high(ioaddr, CMR2, CMR2h_OFF);
636 net_rx(dev);
637 /* Clear the interrupt and return to normal Rx mode. */
638 write_reg_high(ioaddr, ISR, ISRh_RxErr);
639 write_reg_high(ioaddr, CMR2, lp->addr_mode);
640 } else if ((read_status & (CMR1_BufEnb << 3)) == 0) {
641 net_rx(dev);
642 num_tx_since_rx = 0;
643 } else
644 break;
645 } while (--boguscount > 0);
646 } else if (status & ((ISR_TxErr + ISR_TxOK)<<3)) {
647 handled = 1;
648 if (net_debug > 6) printk("handling Tx done..");
649 /* Clear the Tx interrupt. We should check for too many failures
650 and reinitialize the adapter. */
651 write_reg(ioaddr, ISR, ISR_TxErr + ISR_TxOK);
652 if (status & (ISR_TxErr<<3)) {
653 lp->stats.collisions++;
654 if (++lp->re_tx > 15) {
655 lp->stats.tx_aborted_errors++;
656 hardware_init(dev);
657 break;
658 }
659 /* Attempt to retransmit. */
660 if (net_debug > 6) printk("attempting to ReTx");
661 write_reg(ioaddr, CMR1, CMR1_ReXmit + CMR1_Xmit);
662 } else {
663 /* Finish up the transmit. */
664 lp->stats.tx_packets++;
665 lp->pac_cnt_in_tx_buf--;
666 if ( lp->saved_tx_size) {
667 trigger_send(ioaddr, lp->saved_tx_size);
668 lp->saved_tx_size = 0;
669 lp->re_tx = 0;
670 } else
671 lp->tx_unit_busy = 0;
672 netif_wake_queue(dev); /* Inform upper layers. */
673 }
674 num_tx_since_rx++;
675 } else if (num_tx_since_rx > 8
676 && time_after(jiffies, dev->last_rx + HZ)) {
677 if (net_debug > 2)
678 printk(KERN_DEBUG "%s: Missed packet? No Rx after %d Tx and "
679 "%ld jiffies status %02x CMR1 %02x.\n", dev->name,
680 num_tx_since_rx, jiffies - dev->last_rx, status,
681 (read_nibble(ioaddr, CMR1) >> 3) & 15);
682 lp->stats.rx_missed_errors++;
683 hardware_init(dev);
684 num_tx_since_rx = 0;
685 break;
686 } else
687 break;
688 }
689
690 /* This following code fixes a rare (and very difficult to track down)
691 problem where the adapter forgets its ethernet address. */
692 {
693 int i;
694 for (i = 0; i < 6; i++)
695 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
696#if 0 && defined(TIMED_CHECKER)
697 mod_timer(&lp->timer, jiffies + TIMED_CHECKER);
698#endif
699 }
700
701 /* Tell the adapter that it can go back to using the output line as IRQ. */
702 write_reg(ioaddr, CMR2, CMR2_IRQOUT);
703 /* Enable the physical interrupt line, which is sure to be low until.. */
704 outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
705 /* .. we enable the interrupt sources. */
706 write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
707 write_reg_high(ioaddr, IMR, ISRh_RxErr); /* Hmmm, really needed? */
708
709 spin_unlock(&lp->lock);
710
711 if (net_debug > 5) printk("exiting interrupt.\n");
712 return IRQ_RETVAL(handled);
713}
714
715#ifdef TIMED_CHECKER
716/* This following code fixes a rare (and very difficult to track down)
717 problem where the adapter forgets its ethernet address. */
718static void atp_timed_checker(unsigned long data)
719{
720 struct net_device *dev = (struct net_device *)data;
721 long ioaddr = dev->base_addr;
722 struct net_local *lp = netdev_priv(dev);
723 int tickssofar = jiffies - lp->last_rx_time;
724 int i;
725
726 spin_lock(&lp->lock);
727 if (tickssofar > 2*HZ) {
728#if 1
729 for (i = 0; i < 6; i++)
730 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
731 lp->last_rx_time = jiffies;
732#else
733 for (i = 0; i < 6; i++)
734 if (read_cmd_byte(ioaddr, PAR0 + i) != atp_timed_dev->dev_addr[i])
735 {
736 struct net_local *lp = netdev_priv(atp_timed_dev);
737 write_reg_byte(ioaddr, PAR0 + i, atp_timed_dev->dev_addr[i]);
738 if (i == 2)
739 lp->stats.tx_errors++;
740 else if (i == 3)
741 lp->stats.tx_dropped++;
742 else if (i == 4)
743 lp->stats.collisions++;
744 else
745 lp->stats.rx_errors++;
746 }
747#endif
748 }
749 spin_unlock(&lp->lock);
750 lp->timer.expires = jiffies + TIMED_CHECKER;
751 add_timer(&lp->timer);
752}
753#endif
754
755/* We have a good packet(s), get it/them out of the buffers. */
756static void net_rx(struct net_device *dev)
757{
758 struct net_local *lp = netdev_priv(dev);
759 long ioaddr = dev->base_addr;
760 struct rx_header rx_head;
761
762 /* Process the received packet. */
763 outb(EOC+MAR, ioaddr + PAR_DATA);
764 read_block(ioaddr, 8, (unsigned char*)&rx_head, dev->if_port);
765 if (net_debug > 5)
766 printk(KERN_DEBUG " rx_count %04x %04x %04x %04x..", rx_head.pad,
767 rx_head.rx_count, rx_head.rx_status, rx_head.cur_addr);
768 if ((rx_head.rx_status & 0x77) != 0x01) {
769 lp->stats.rx_errors++;
770 if (rx_head.rx_status & 0x0004) lp->stats.rx_frame_errors++;
771 else if (rx_head.rx_status & 0x0002) lp->stats.rx_crc_errors++;
772 if (net_debug > 3)
773 printk(KERN_DEBUG "%s: Unknown ATP Rx error %04x.\n",
774 dev->name, rx_head.rx_status);
775 if (rx_head.rx_status & 0x0020) {
776 lp->stats.rx_fifo_errors++;
777 write_reg_high(ioaddr, CMR1, CMR1h_TxENABLE);
778 write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
779 } else if (rx_head.rx_status & 0x0050)
780 hardware_init(dev);
781 return;
782 } else {
783 /* Malloc up new buffer. The "-4" omits the FCS (CRC). */
784 int pkt_len = (rx_head.rx_count & 0x7ff) - 4;
785 struct sk_buff *skb;
786
787 skb = dev_alloc_skb(pkt_len + 2);
788 if (skb == NULL) {
789 printk(KERN_ERR "%s: Memory squeeze, dropping packet.\n",
790 dev->name);
791 lp->stats.rx_dropped++;
792 goto done;
793 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
795 skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
796 read_block(ioaddr, pkt_len, skb_put(skb,pkt_len), dev->if_port);
797 skb->protocol = eth_type_trans(skb, dev);
798 netif_rx(skb);
799 dev->last_rx = jiffies;
800 lp->stats.rx_packets++;
801 lp->stats.rx_bytes += pkt_len;
802 }
803 done:
804 write_reg(ioaddr, CMR1, CMR1_NextPkt);
805 lp->last_rx_time = jiffies;
806 return;
807}
808
809static void read_block(long ioaddr, int length, unsigned char *p, int data_mode)
810{
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 } else if (data_mode <= 5)
821 do *p++ = read_byte_mode4(ioaddr); while (--length > 0);
822 else
823 do *p++ = read_byte_mode6(ioaddr); while (--length > 0);
824
825 outb(EOC+HNib+MAR, ioaddr + PAR_DATA);
826 outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
827}
828
829/* The inverse routine to net_open(). */
830static int
831net_close(struct net_device *dev)
832{
833 struct net_local *lp = netdev_priv(dev);
834 long ioaddr = dev->base_addr;
835
836 netif_stop_queue(dev);
837
838 del_timer_sync(&lp->timer);
839
840 /* Flush the Tx and disable Rx here. */
841 lp->addr_mode = CMR2h_OFF;
842 write_reg_high(ioaddr, CMR2, CMR2h_OFF);
843
844 /* Free the IRQ line. */
845 outb(0x00, ioaddr + PAR_CONTROL);
846 free_irq(dev->irq, dev);
847
848 /* Reset the ethernet hardware and activate the printer pass-through. */
849 write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
850 return 0;
851}
852
853/* Get the current statistics. This may be called with the card open or
854 closed. */
855static struct net_device_stats *
856net_get_stats(struct net_device *dev)
857{
858 struct net_local *lp = netdev_priv(dev);
859 return &lp->stats;
860}
861
862/*
863 * Set or clear the multicast filter for this adapter.
864 */
865
866static void set_rx_mode_8002(struct net_device *dev)
867{
868 struct net_local *lp = netdev_priv(dev);
869 long ioaddr = dev->base_addr;
870
871 if ( dev->mc_count > 0 || (dev->flags & (IFF_ALLMULTI|IFF_PROMISC))) {
872 /* We must make the kernel realise we had to move
873 * into promisc mode or we start all out war on
874 * the cable. - AC
875 */
876 dev->flags|=IFF_PROMISC;
877 lp->addr_mode = CMR2h_PROMISC;
878 } else
879 lp->addr_mode = CMR2h_Normal;
880 write_reg_high(ioaddr, CMR2, lp->addr_mode);
881}
882
883static void set_rx_mode_8012(struct net_device *dev)
884{
885 struct net_local *lp = netdev_priv(dev);
886 long ioaddr = dev->base_addr;
887 unsigned char new_mode, mc_filter[8]; /* Multicast hash filter */
888 int i;
889
890 if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
891 new_mode = CMR2h_PROMISC;
892 } else if ((dev->mc_count > 1000) || (dev->flags & IFF_ALLMULTI)) {
893 /* Too many to filter perfectly -- accept all multicasts. */
894 memset(mc_filter, 0xff, sizeof(mc_filter));
895 new_mode = CMR2h_Normal;
896 } else {
897 struct dev_mc_list *mclist;
898
899 memset(mc_filter, 0, sizeof(mc_filter));
900 for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
901 i++, mclist = mclist->next)
902 {
903 int filterbit = ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x3f;
904 mc_filter[filterbit >> 5] |= 1 << (filterbit & 31);
905 }
906 new_mode = CMR2h_Normal;
907 }
908 lp->addr_mode = new_mode;
909 write_reg(ioaddr, CMR2, CMR2_IRQOUT | 0x04); /* Switch to page 1. */
910 for (i = 0; i < 8; i++)
911 write_reg_byte(ioaddr, i, mc_filter[i]);
912 if (net_debug > 2 || 1) {
913 lp->addr_mode = 1;
914 printk(KERN_DEBUG "%s: Mode %d, setting multicast filter to",
915 dev->name, lp->addr_mode);
916 for (i = 0; i < 8; i++)
917 printk(" %2.2x", mc_filter[i]);
918 printk(".\n");
919 }
920
921 write_reg_high(ioaddr, CMR2, lp->addr_mode);
922 write_reg(ioaddr, CMR2, CMR2_IRQOUT); /* Switch back to page 0 */
923}
924
925static int __init atp_init_module(void) {
926 if (debug) /* Emit version even if no cards detected. */
Markus Dahms2c2a8c52007-05-09 07:58:10 +0200927 printk(KERN_INFO "%s", version);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 return atp_init();
929}
930
931static void __exit atp_cleanup_module(void) {
932 struct net_device *next_dev;
933
934 while (root_atp_dev) {
935 next_dev = ((struct net_local *)root_atp_dev->priv)->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
943module_init(atp_init_module);
944module_exit(atp_cleanup_module);