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