1 /* atp.c: Attached (pocket) ethernet adapter driver for linux. */
3 This is a driver for commonly OEM pocket (parallel port)
4 ethernet adapters based on the Realtek RTL8002 and RTL8012 chips.
6 Written 1993-2000 by Donald Becker.
8 This software may be used and distributed according to the terms of
9 the GNU General Public License (GPL), incorporated herein by reference.
10 Drivers based on or derived from this code fall under the GPL and must
11 retain the authorship, copyright and license notice. This file is not
12 a complete program and may only be used when the entire operating
13 system is licensed under the GPL.
15 Copyright 1993 United States Government as represented by the Director,
16 National Security Agency. Copyright 1994-2000 retained by the original
17 author, Donald Becker. The timer-based reset code was supplied in 1995
18 by Bill Carlson, wwc@super.org.
20 The author may be reached as becker@scyld.com, or C/O
21 Scyld Computing Corporation
22 410 Severn Ave., Suite 210
25 Support information and updates available at
26 http://www.scyld.com/network/atp.html
29 Modular support/softnet added by Alan Cox.
30 _bit abuse fixed up by Alan Cox
34 static const char version
[] =
35 "atp.c:v1.09=ac 2002/10/01 Donald Becker <becker@scyld.com>\n";
37 /* The user-configurable values.
38 These may be modified when a driver module is loaded.*/
40 static int debug
= 1; /* 1 normal messages, 0 quiet .. 7 verbose. */
41 #define net_debug debug
43 /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
44 static int max_interrupt_work
= 15;
47 /* The standard set of ISA module parameters. */
48 static int io
[NUM_UNITS
];
49 static int irq
[NUM_UNITS
];
50 static int xcvr
[NUM_UNITS
]; /* The data transfer mode. */
52 /* Operational parameters that are set at compile time. */
54 /* Time in jiffies before concluding the transmitter is hung. */
55 #define TX_TIMEOUT (400*HZ/1000)
58 This file is a device driver for the RealTek (aka AT-Lan-Tec) pocket
59 ethernet adapter. This is a common low-cost OEM pocket ethernet
60 adapter, sold under many names.
63 This driver was written from the packet driver assembly code provided by
64 Vincent Bono of AT-Lan-Tec. Ever try to figure out how a complicated
65 device works just from the assembly code? It ain't pretty. The following
66 description is written based on guesses and writing lots of special-purpose
67 code to test my theorized operation.
69 In 1997 Realtek made available the documentation for the second generation
70 RTL8012 chip, which has lead to several driver improvements.
71 http://www.realtek.com.tw/cn/cn.html
75 The RTL8002 adapter seems to be built around a custom spin of the SEEQ
76 controller core. It probably has a 16K or 64K internal packet buffer, of
77 which the first 4K is devoted to transmit and the rest to receive.
78 The controller maintains the queue of received packet and the packet buffer
79 access pointer internally, with only 'reset to beginning' and 'skip to next
80 packet' commands visible. The transmit packet queue holds two (or more?)
81 packets: both 'retransmit this packet' (due to collision) and 'transmit next
82 packet' commands must be started by hand.
84 The station address is stored in a standard bit-serial EEPROM which must be
85 read (ughh) by the device driver. (Provisions have been made for
86 substituting a 74S288 PROM, but I haven't gotten reports of any models
87 using it.) Unlike built-in devices, a pocket adapter can temporarily lose
88 power without indication to the device driver. The major effect is that
89 the station address, receive filter (promiscuous, etc.) and transceiver
92 The controller itself has 16 registers, some of which use only the lower
93 bits. The registers are read and written 4 bits at a time. The four bit
94 register address is presented on the data lines along with a few additional
95 timing and control bits. The data is then read from status port or written
98 Correction: the controller has two banks of 16 registers. The second
99 bank contains only the multicast filter table (now used) and the EEPROM
102 Since the bulk data transfer of the actual packets through the slow
103 parallel port dominates the driver's running time, four distinct data
104 (non-register) transfer modes are provided by the adapter, two in each
105 direction. In the first mode timing for the nibble transfers is
106 provided through the data port. In the second mode the same timing is
107 provided through the control port. In either case the data is read from
108 the status port and written to the data port, just as it is accessing
111 In addition to the basic data transfer methods, several more are modes are
112 created by adding some delay by doing multiple reads of the data to allow
113 it to stabilize. This delay seems to be needed on most machines.
115 The data transfer mode is stored in the 'dev->if_port' field. Its default
116 value is '4'. It may be overridden at boot-time using the third parameter
117 to the "ether=..." initialization.
119 The header file <atp.h> provides inline functions that encapsulate the
120 register and data access methods. These functions are hand-tuned to
121 generate reasonable object code. This header file also documents my
122 interpretations of the device registers.
125 #include <linux/kernel.h>
126 #include <linux/module.h>
127 #include <linux/types.h>
128 #include <linux/fcntl.h>
129 #include <linux/interrupt.h>
130 #include <linux/ioport.h>
131 #include <linux/in.h>
132 #include <linux/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>
144 #include <asm/system.h>
150 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
151 MODULE_DESCRIPTION("RealTek RTL8002/8012 parallel port Ethernet driver");
152 MODULE_LICENSE("GPL");
154 module_param(max_interrupt_work
, int, 0);
155 module_param(debug
, int, 0);
156 module_param_array(io
, int, NULL
, 0);
157 module_param_array(irq
, int, NULL
, 0);
158 module_param_array(xcvr
, int, NULL
, 0);
159 MODULE_PARM_DESC(max_interrupt_work
, "ATP maximum events handled per interrupt");
160 MODULE_PARM_DESC(debug
, "ATP debug level (0-7)");
161 MODULE_PARM_DESC(io
, "ATP I/O base address(es)");
162 MODULE_PARM_DESC(irq
, "ATP IRQ number(s)");
163 MODULE_PARM_DESC(xcvr
, "ATP transceiver(s) (0=internal, 1=external)");
165 /* The number of low I/O ports used by the ethercard. */
166 #define ETHERCARD_TOTAL_SIZE 3
168 /* Sequence to switch an 8012 from printer mux to ethernet mode. */
169 static char mux_8012
[] = { 0xff, 0xf7, 0xff, 0xfb, 0xf3, 0xfb, 0xff, 0xf7,};
173 struct net_device
*next_module
;
174 struct timer_list timer
; /* Media selection timer. */
175 long last_rx_time
; /* Last Rx, in jiffies, to handle Rx hang. */
177 unsigned int tx_unit_busy
:1;
178 unsigned char re_tx
, /* Number of packet retransmissions. */
179 addr_mode
, /* Current Rx filter e.g. promiscuous, etc. */
184 /* This code, written by wwc@super.org, resets the adapter every
185 TIMED_CHECKER ticks. This recovers from an unknown error which
187 #define TIMED_CHECKER (HZ/4)
189 #include <linux/timer.h>
190 static void atp_timed_checker(unsigned long ignored
);
193 /* Index to functions, as function prototypes. */
195 static int atp_probe1(long ioaddr
);
196 static void get_node_ID(struct net_device
*dev
);
197 static unsigned short eeprom_op(long ioaddr
, unsigned int cmd
);
198 static int net_open(struct net_device
*dev
);
199 static void hardware_init(struct net_device
*dev
);
200 static void write_packet(long ioaddr
, int length
, unsigned char *packet
, int pad
, int mode
);
201 static void trigger_send(long ioaddr
, int length
);
202 static int atp_send_packet(struct sk_buff
*skb
, struct net_device
*dev
);
203 static irqreturn_t
atp_interrupt(int irq
, void *dev_id
);
204 static void net_rx(struct net_device
*dev
);
205 static void read_block(long ioaddr
, int length
, unsigned char *buffer
, int data_mode
);
206 static int net_close(struct net_device
*dev
);
207 static void set_rx_mode_8002(struct net_device
*dev
);
208 static void set_rx_mode_8012(struct net_device
*dev
);
209 static void tx_timeout(struct net_device
*dev
);
212 /* A list of all installed ATP devices, for removing the driver module. */
213 static struct net_device
*root_atp_dev
;
215 /* Check for a network adapter of this type, and return '0' iff one exists.
216 If dev->base_addr == 0, probe all likely locations.
217 If dev->base_addr == 1, always return failure.
218 If dev->base_addr == 2, allocate space for the device and return success
219 (detachable devices only).
221 FIXME: we should use the parport layer for this
223 static int __init
atp_init(void)
225 int *port
, ports
[] = {0x378, 0x278, 0x3bc, 0};
226 int base_addr
= io
[0];
228 if (base_addr
> 0x1ff) /* Check a single specified location. */
229 return atp_probe1(base_addr
);
230 else if (base_addr
== 1) /* Don't probe at all. */
233 for (port
= ports
; *port
; port
++) {
235 outb(0x57, ioaddr
+ PAR_DATA
);
236 if (inb(ioaddr
+ PAR_DATA
) != 0x57)
238 if (atp_probe1(ioaddr
) == 0)
245 static int __init
atp_probe1(long ioaddr
)
247 struct net_device
*dev
= NULL
;
248 struct net_local
*lp
;
249 int saved_ctrl_reg
, status
, i
;
251 DECLARE_MAC_BUF(mac
);
253 outb(0xff, ioaddr
+ PAR_DATA
);
254 /* Save the original value of the Control register, in case we guessed
256 saved_ctrl_reg
= inb(ioaddr
+ PAR_CONTROL
);
258 printk("atp: Control register was %#2.2x.\n", saved_ctrl_reg
);
259 /* IRQEN=0, SLCTB=high INITB=high, AUTOFDB=high, STBB=high. */
260 outb(0x04, ioaddr
+ PAR_CONTROL
);
261 #ifndef final_version
263 /* Turn off the printer multiplexer on the 8012. */
264 for (i
= 0; i
< 8; i
++)
265 outb(mux_8012
[i
], ioaddr
+ PAR_DATA
);
266 write_reg(ioaddr
, MODSEL
, 0x00);
267 printk("atp: Registers are ");
268 for (i
= 0; i
< 32; i
++)
269 printk(" %2.2x", read_nibble(ioaddr
, i
));
273 /* Turn off the printer multiplexer on the 8012. */
274 for (i
= 0; i
< 8; i
++)
275 outb(mux_8012
[i
], ioaddr
+ PAR_DATA
);
276 write_reg_high(ioaddr
, CMR1
, CMR1h_RESET
);
278 status
= read_nibble(ioaddr
, CMR1
);
281 printk(KERN_DEBUG
"atp: Status nibble was %#2.2x..", status
);
282 for (i
= 0; i
< 32; i
++)
283 printk(" %2.2x", read_nibble(ioaddr
, i
));
287 if ((status
& 0x78) != 0x08) {
288 /* The pocket adapter probe failed, restore the control register. */
289 outb(saved_ctrl_reg
, ioaddr
+ PAR_CONTROL
);
292 status
= read_nibble(ioaddr
, CMR2_h
);
293 if ((status
& 0x78) != 0x10) {
294 outb(saved_ctrl_reg
, ioaddr
+ PAR_CONTROL
);
298 dev
= alloc_etherdev(sizeof(struct net_local
));
302 /* Find the IRQ used by triggering an interrupt. */
303 write_reg_byte(ioaddr
, CMR2
, 0x01); /* No accept mode, IRQ out. */
304 write_reg_high(ioaddr
, CMR1
, CMR1h_RxENABLE
| CMR1h_TxENABLE
); /* Enable Tx and Rx. */
306 /* Omit autoIRQ routine for now. Use "table lookup" instead. Uhgggh. */
309 else if (ioaddr
== 0x378)
313 write_reg_high(ioaddr
, CMR1
, CMR1h_TxRxOFF
); /* Disable Tx and Rx units. */
314 write_reg(ioaddr
, CMR2
, CMR2_NULL
);
316 dev
->base_addr
= ioaddr
;
318 /* Read the station address PROM. */
323 printk(KERN_INFO
"%s", version
);
326 printk(KERN_NOTICE
"%s: Pocket adapter found at %#3lx, IRQ %d, "
328 dev
->name
, dev
->base_addr
, dev
->irq
, print_mac(mac
, dev
->dev_addr
));
330 /* Reset the ethernet hardware and activate the printer pass-through. */
331 write_reg_high(ioaddr
, CMR1
, CMR1h_RESET
| CMR1h_MUX
);
333 lp
= netdev_priv(dev
);
334 lp
->chip_type
= RTL8002
;
335 lp
->addr_mode
= CMR2h_Normal
;
336 spin_lock_init(&lp
->lock
);
338 /* For the ATP adapter the "if_port" is really the data transfer mode. */
340 dev
->if_port
= xcvr
[0];
342 dev
->if_port
= (dev
->mem_start
& 0xf) ? (dev
->mem_start
& 0x7) : 4;
343 if (dev
->mem_end
& 0xf)
344 net_debug
= dev
->mem_end
& 7;
346 dev
->open
= net_open
;
347 dev
->stop
= net_close
;
348 dev
->hard_start_xmit
= atp_send_packet
;
349 dev
->set_multicast_list
=
350 lp
->chip_type
== RTL8002
? &set_rx_mode_8002
: &set_rx_mode_8012
;
351 dev
->tx_timeout
= tx_timeout
;
352 dev
->watchdog_timeo
= TX_TIMEOUT
;
354 res
= register_netdev(dev
);
360 lp
->next_module
= root_atp_dev
;
366 /* Read the station address PROM, usually a word-wide EEPROM. */
367 static void __init
get_node_ID(struct net_device
*dev
)
369 long ioaddr
= dev
->base_addr
;
373 write_reg(ioaddr
, CMR2
, CMR2_EEPROM
); /* Point to the EEPROM control registers. */
375 /* Some adapters have the station address at offset 15 instead of offset
376 zero. Check for it, and fix it if needed. */
377 if (eeprom_op(ioaddr
, EE_READ(0)) == 0xffff)
380 for (i
= 0; i
< 3; i
++)
381 ((__be16
*)dev
->dev_addr
)[i
] =
382 cpu_to_be16(eeprom_op(ioaddr
, EE_READ(sa_offset
+ i
)));
384 write_reg(ioaddr
, CMR2
, CMR2_NULL
);
388 An EEPROM read command starts by shifting out 0x60+address, and then
389 shifting in the serial data. See the NatSemi databook for details.
393 * CLK: ______| |___| |
395 * DI : __X_______X_______X
396 * DO : _________X_______X
399 static unsigned short __init
eeprom_op(long ioaddr
, u32 cmd
)
401 unsigned eedata_out
= 0;
402 int num_bits
= EE_CMD_SIZE
;
404 while (--num_bits
>= 0) {
405 char outval
= (cmd
& (1<<num_bits
)) ? EE_DATA_WRITE
: 0;
406 write_reg_high(ioaddr
, PROM_CMD
, outval
| EE_CLK_LOW
);
407 write_reg_high(ioaddr
, PROM_CMD
, outval
| EE_CLK_HIGH
);
409 if (read_nibble(ioaddr
, PROM_DATA
) & EE_DATA_READ
)
412 write_reg_high(ioaddr
, PROM_CMD
, EE_CLK_LOW
& ~EE_CS
);
417 /* Open/initialize the board. This is called (in the current kernel)
418 sometime after booting when the 'ifconfig' program is run.
420 This routine sets everything up anew at each open, even
421 registers that "should" only need to be set once at boot, so that
422 there is non-reboot way to recover if something goes wrong.
424 This is an attachable device: if there is no dev->priv entry then it wasn't
425 probed for at boot-time, and we need to probe for it again.
427 static int net_open(struct net_device
*dev
)
429 struct net_local
*lp
= netdev_priv(dev
);
432 /* The interrupt line is turned off (tri-stated) when the device isn't in
433 use. That's especially important for "attached" interfaces where the
434 port or interrupt may be shared. */
435 ret
= request_irq(dev
->irq
, &atp_interrupt
, 0, dev
->name
, dev
);
441 init_timer(&lp
->timer
);
442 lp
->timer
.expires
= jiffies
+ TIMED_CHECKER
;
443 lp
->timer
.data
= (unsigned long)dev
;
444 lp
->timer
.function
= &atp_timed_checker
; /* timer handler */
445 add_timer(&lp
->timer
);
447 netif_start_queue(dev
);
451 /* This routine resets the hardware. We initialize everything, assuming that
452 the hardware may have been temporarily detached. */
453 static void hardware_init(struct net_device
*dev
)
455 struct net_local
*lp
= netdev_priv(dev
);
456 long ioaddr
= dev
->base_addr
;
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
);
464 for (i
= 0; i
< 6; i
++)
465 write_reg_byte(ioaddr
, PAR0
+ i
, dev
->dev_addr
[i
]);
467 write_reg_high(ioaddr
, CMR2
, lp
->addr_mode
);
470 printk(KERN_DEBUG
"%s: Reset: current Rx mode %d.\n", dev
->name
,
471 (read_nibble(ioaddr
, CMR2_h
) >> 3) & 0x0f);
474 write_reg(ioaddr
, CMR2
, CMR2_IRQOUT
);
475 write_reg_high(ioaddr
, CMR1
, CMR1h_RxENABLE
| CMR1h_TxENABLE
);
477 /* Enable the interrupt line from the serial port. */
478 outb(Ctrl_SelData
+ Ctrl_IRQEN
, ioaddr
+ PAR_CONTROL
);
480 /* Unmask the interesting interrupts. */
481 write_reg(ioaddr
, IMR
, ISR_RxOK
| ISR_TxErr
| ISR_TxOK
);
482 write_reg_high(ioaddr
, IMR
, ISRh_RxErr
);
484 lp
->tx_unit_busy
= 0;
485 lp
->pac_cnt_in_tx_buf
= 0;
486 lp
->saved_tx_size
= 0;
489 static void trigger_send(long ioaddr
, int length
)
491 write_reg_byte(ioaddr
, TxCNT0
, length
& 0xff);
492 write_reg(ioaddr
, TxCNT1
, length
>> 8);
493 write_reg(ioaddr
, CMR1
, CMR1_Xmit
);
496 static void write_packet(long ioaddr
, int length
, unsigned char *packet
, int pad_len
, int data_mode
)
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
);
509 write_byte_mode0(ioaddr
, *packet
++);
510 } while (--length
> pad_len
) ;
512 write_byte_mode0(ioaddr
, 0);
513 } while (--length
> 0) ;
515 /* Write the packet out in slow mode. */
516 unsigned char outbyte
= *packet
++;
518 outb(Ctrl_LNibWrite
+ Ctrl_IRQEN
, ioaddr
+ PAR_CONTROL
);
519 outb(WrAddr
+MAR
, ioaddr
+ PAR_DATA
);
521 outb((outbyte
& 0x0f)|0x40, ioaddr
+ PAR_DATA
);
522 outb(outbyte
& 0x0f, ioaddr
+ PAR_DATA
);
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
++);
529 write_byte_mode1(ioaddr
, 0);
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
);
536 static void tx_timeout(struct net_device
*dev
)
538 long ioaddr
= dev
->base_addr
;
540 printk(KERN_WARNING
"%s: Transmit timed out, %s?\n", dev
->name
,
541 inb(ioaddr
+ PAR_CONTROL
) & 0x10 ? "network cable problem"
543 dev
->stats
.tx_errors
++;
544 /* Try to restart the adapter. */
546 dev
->trans_start
= jiffies
;
547 netif_wake_queue(dev
);
548 dev
->stats
.tx_errors
++;
551 static int atp_send_packet(struct sk_buff
*skb
, struct net_device
*dev
)
553 struct net_local
*lp
= netdev_priv(dev
);
554 long ioaddr
= dev
->base_addr
;
558 length
= ETH_ZLEN
< skb
->len
? skb
->len
: ETH_ZLEN
;
560 netif_stop_queue(dev
);
562 /* Disable interrupts by writing 0x00 to the Interrupt Mask Register.
563 This sequence must not be interrupted by an incoming packet. */
565 spin_lock_irqsave(&lp
->lock
, flags
);
566 write_reg(ioaddr
, IMR
, 0);
567 write_reg_high(ioaddr
, IMR
, 0);
568 spin_unlock_irqrestore(&lp
->lock
, flags
);
570 write_packet(ioaddr
, length
, skb
->data
, length
-skb
->len
, dev
->if_port
);
572 lp
->pac_cnt_in_tx_buf
++;
573 if (lp
->tx_unit_busy
== 0) {
574 trigger_send(ioaddr
, length
);
575 lp
->saved_tx_size
= 0; /* Redundant */
577 lp
->tx_unit_busy
= 1;
579 lp
->saved_tx_size
= length
;
580 /* Re-enable the LPT interrupts. */
581 write_reg(ioaddr
, IMR
, ISR_RxOK
| ISR_TxErr
| ISR_TxOK
);
582 write_reg_high(ioaddr
, IMR
, ISRh_RxErr
);
584 dev
->trans_start
= jiffies
;
590 /* The typical workload of the driver:
591 Handle the network interface interrupts. */
592 static irqreturn_t
atp_interrupt(int irq
, void *dev_instance
)
594 struct net_device
*dev
= dev_instance
;
595 struct net_local
*lp
;
597 static int num_tx_since_rx
;
598 int boguscount
= max_interrupt_work
;
601 ioaddr
= dev
->base_addr
;
602 lp
= netdev_priv(dev
);
604 spin_lock(&lp
->lock
);
606 /* Disable additional spurious interrupts. */
607 outb(Ctrl_SelData
, ioaddr
+ PAR_CONTROL
);
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);
613 if (net_debug
> 5) printk(KERN_DEBUG
"%s: In interrupt ", dev
->name
);
614 while (--boguscount
> 0) {
615 int status
= read_nibble(ioaddr
, ISR
);
616 if (net_debug
> 5) printk("loop status %02x..", status
);
618 if (status
& (ISR_RxOK
<<3)) {
620 write_reg(ioaddr
, ISR
, ISR_RxOK
); /* Clear the Rx interrupt. */
622 int read_status
= read_nibble(ioaddr
, CMR1
);
624 printk("handling Rx packet %02x..", read_status
);
625 /* We acknowledged the normal Rx interrupt, so if the interrupt
626 is still outstanding we must have a Rx error. */
627 if (read_status
& (CMR1_IRQ
<< 3)) { /* Overrun. */
628 dev
->stats
.rx_over_errors
++;
629 /* Set to no-accept mode long enough to remove a packet. */
630 write_reg_high(ioaddr
, CMR2
, CMR2h_OFF
);
632 /* Clear the interrupt and return to normal Rx mode. */
633 write_reg_high(ioaddr
, ISR
, ISRh_RxErr
);
634 write_reg_high(ioaddr
, CMR2
, lp
->addr_mode
);
635 } else if ((read_status
& (CMR1_BufEnb
<< 3)) == 0) {
640 } while (--boguscount
> 0);
641 } else if (status
& ((ISR_TxErr
+ ISR_TxOK
)<<3)) {
643 if (net_debug
> 6) printk("handling Tx done..");
644 /* Clear the Tx interrupt. We should check for too many failures
645 and reinitialize the adapter. */
646 write_reg(ioaddr
, ISR
, ISR_TxErr
+ ISR_TxOK
);
647 if (status
& (ISR_TxErr
<<3)) {
648 dev
->stats
.collisions
++;
649 if (++lp
->re_tx
> 15) {
650 dev
->stats
.tx_aborted_errors
++;
654 /* Attempt to retransmit. */
655 if (net_debug
> 6) printk("attempting to ReTx");
656 write_reg(ioaddr
, CMR1
, CMR1_ReXmit
+ CMR1_Xmit
);
658 /* Finish up the transmit. */
659 dev
->stats
.tx_packets
++;
660 lp
->pac_cnt_in_tx_buf
--;
661 if ( lp
->saved_tx_size
) {
662 trigger_send(ioaddr
, lp
->saved_tx_size
);
663 lp
->saved_tx_size
= 0;
666 lp
->tx_unit_busy
= 0;
667 netif_wake_queue(dev
); /* Inform upper layers. */
670 } else if (num_tx_since_rx
> 8
671 && time_after(jiffies
, dev
->last_rx
+ HZ
)) {
673 printk(KERN_DEBUG
"%s: Missed packet? No Rx after %d Tx and "
674 "%ld jiffies status %02x CMR1 %02x.\n", dev
->name
,
675 num_tx_since_rx
, jiffies
- dev
->last_rx
, status
,
676 (read_nibble(ioaddr
, CMR1
) >> 3) & 15);
677 dev
->stats
.rx_missed_errors
++;
685 /* This following code fixes a rare (and very difficult to track down)
686 problem where the adapter forgets its ethernet address. */
689 for (i
= 0; i
< 6; i
++)
690 write_reg_byte(ioaddr
, PAR0
+ i
, dev
->dev_addr
[i
]);
691 #if 0 && defined(TIMED_CHECKER)
692 mod_timer(&lp
->timer
, jiffies
+ TIMED_CHECKER
);
696 /* Tell the adapter that it can go back to using the output line as IRQ. */
697 write_reg(ioaddr
, CMR2
, CMR2_IRQOUT
);
698 /* Enable the physical interrupt line, which is sure to be low until.. */
699 outb(Ctrl_SelData
+ Ctrl_IRQEN
, ioaddr
+ PAR_CONTROL
);
700 /* .. we enable the interrupt sources. */
701 write_reg(ioaddr
, IMR
, ISR_RxOK
| ISR_TxErr
| ISR_TxOK
);
702 write_reg_high(ioaddr
, IMR
, ISRh_RxErr
); /* Hmmm, really needed? */
704 spin_unlock(&lp
->lock
);
706 if (net_debug
> 5) printk("exiting interrupt.\n");
707 return IRQ_RETVAL(handled
);
711 /* This following code fixes a rare (and very difficult to track down)
712 problem where the adapter forgets its ethernet address. */
713 static void atp_timed_checker(unsigned long data
)
715 struct net_device
*dev
= (struct net_device
*)data
;
716 long ioaddr
= dev
->base_addr
;
717 struct net_local
*lp
= netdev_priv(dev
);
718 int tickssofar
= jiffies
- lp
->last_rx_time
;
721 spin_lock(&lp
->lock
);
722 if (tickssofar
> 2*HZ
) {
724 for (i
= 0; i
< 6; i
++)
725 write_reg_byte(ioaddr
, PAR0
+ i
, dev
->dev_addr
[i
]);
726 lp
->last_rx_time
= jiffies
;
728 for (i
= 0; i
< 6; i
++)
729 if (read_cmd_byte(ioaddr
, PAR0
+ i
) != atp_timed_dev
->dev_addr
[i
])
731 struct net_local
*lp
= netdev_priv(atp_timed_dev
);
732 write_reg_byte(ioaddr
, PAR0
+ i
, atp_timed_dev
->dev_addr
[i
]);
734 dev
->stats
.tx_errors
++;
736 dev
->stats
.tx_dropped
++;
738 dev
->stats
.collisions
++;
740 dev
->stats
.rx_errors
++;
744 spin_unlock(&lp
->lock
);
745 lp
->timer
.expires
= jiffies
+ TIMED_CHECKER
;
746 add_timer(&lp
->timer
);
750 /* We have a good packet(s), get it/them out of the buffers. */
751 static void net_rx(struct net_device
*dev
)
753 struct net_local
*lp
= netdev_priv(dev
);
754 long ioaddr
= dev
->base_addr
;
755 struct rx_header rx_head
;
757 /* Process the received packet. */
758 outb(EOC
+MAR
, ioaddr
+ PAR_DATA
);
759 read_block(ioaddr
, 8, (unsigned char*)&rx_head
, dev
->if_port
);
761 printk(KERN_DEBUG
" rx_count %04x %04x %04x %04x..", rx_head
.pad
,
762 rx_head
.rx_count
, rx_head
.rx_status
, rx_head
.cur_addr
);
763 if ((rx_head
.rx_status
& 0x77) != 0x01) {
764 dev
->stats
.rx_errors
++;
765 if (rx_head
.rx_status
& 0x0004) dev
->stats
.rx_frame_errors
++;
766 else if (rx_head
.rx_status
& 0x0002) dev
->stats
.rx_crc_errors
++;
768 printk(KERN_DEBUG
"%s: Unknown ATP Rx error %04x.\n",
769 dev
->name
, rx_head
.rx_status
);
770 if (rx_head
.rx_status
& 0x0020) {
771 dev
->stats
.rx_fifo_errors
++;
772 write_reg_high(ioaddr
, CMR1
, CMR1h_TxENABLE
);
773 write_reg_high(ioaddr
, CMR1
, CMR1h_RxENABLE
| CMR1h_TxENABLE
);
774 } else if (rx_head
.rx_status
& 0x0050)
778 /* Malloc up new buffer. The "-4" omits the FCS (CRC). */
779 int pkt_len
= (rx_head
.rx_count
& 0x7ff) - 4;
782 skb
= dev_alloc_skb(pkt_len
+ 2);
784 printk(KERN_ERR
"%s: Memory squeeze, dropping packet.\n",
786 dev
->stats
.rx_dropped
++;
790 skb_reserve(skb
, 2); /* Align IP on 16 byte boundaries */
791 read_block(ioaddr
, pkt_len
, skb_put(skb
,pkt_len
), dev
->if_port
);
792 skb
->protocol
= eth_type_trans(skb
, dev
);
794 dev
->last_rx
= jiffies
;
795 dev
->stats
.rx_packets
++;
796 dev
->stats
.rx_bytes
+= pkt_len
;
799 write_reg(ioaddr
, CMR1
, CMR1_NextPkt
);
800 lp
->last_rx_time
= jiffies
;
804 static void read_block(long ioaddr
, int length
, unsigned char *p
, int data_mode
)
807 if (data_mode
<= 3) { /* Mode 0 or 1 */
808 outb(Ctrl_LNibRead
, ioaddr
+ PAR_CONTROL
);
809 outb(length
== 8 ? RdAddr
| HNib
| MAR
: RdAddr
| MAR
,
811 if (data_mode
<= 1) { /* Mode 0 or 1 */
812 do *p
++ = read_byte_mode0(ioaddr
); while (--length
> 0);
813 } else /* Mode 2 or 3 */
814 do *p
++ = read_byte_mode2(ioaddr
); while (--length
> 0);
815 } else if (data_mode
<= 5)
816 do *p
++ = read_byte_mode4(ioaddr
); while (--length
> 0);
818 do *p
++ = read_byte_mode6(ioaddr
); while (--length
> 0);
820 outb(EOC
+HNib
+MAR
, ioaddr
+ PAR_DATA
);
821 outb(Ctrl_SelData
, ioaddr
+ PAR_CONTROL
);
824 /* The inverse routine to net_open(). */
826 net_close(struct net_device
*dev
)
828 struct net_local
*lp
= netdev_priv(dev
);
829 long ioaddr
= dev
->base_addr
;
831 netif_stop_queue(dev
);
833 del_timer_sync(&lp
->timer
);
835 /* Flush the Tx and disable Rx here. */
836 lp
->addr_mode
= CMR2h_OFF
;
837 write_reg_high(ioaddr
, CMR2
, CMR2h_OFF
);
839 /* Free the IRQ line. */
840 outb(0x00, ioaddr
+ PAR_CONTROL
);
841 free_irq(dev
->irq
, dev
);
843 /* Reset the ethernet hardware and activate the printer pass-through. */
844 write_reg_high(ioaddr
, CMR1
, CMR1h_RESET
| CMR1h_MUX
);
849 * Set or clear the multicast filter for this adapter.
852 static void set_rx_mode_8002(struct net_device
*dev
)
854 struct net_local
*lp
= netdev_priv(dev
);
855 long ioaddr
= dev
->base_addr
;
857 if ( dev
->mc_count
> 0 || (dev
->flags
& (IFF_ALLMULTI
|IFF_PROMISC
))) {
858 /* We must make the kernel realise we had to move
859 * into promisc mode or we start all out war on
862 dev
->flags
|=IFF_PROMISC
;
863 lp
->addr_mode
= CMR2h_PROMISC
;
865 lp
->addr_mode
= CMR2h_Normal
;
866 write_reg_high(ioaddr
, CMR2
, lp
->addr_mode
);
869 static void set_rx_mode_8012(struct net_device
*dev
)
871 struct net_local
*lp
= netdev_priv(dev
);
872 long ioaddr
= dev
->base_addr
;
873 unsigned char new_mode
, mc_filter
[8]; /* Multicast hash filter */
876 if (dev
->flags
& IFF_PROMISC
) { /* Set promiscuous. */
877 new_mode
= CMR2h_PROMISC
;
878 } else if ((dev
->mc_count
> 1000) || (dev
->flags
& IFF_ALLMULTI
)) {
879 /* Too many to filter perfectly -- accept all multicasts. */
880 memset(mc_filter
, 0xff, sizeof(mc_filter
));
881 new_mode
= CMR2h_Normal
;
883 struct dev_mc_list
*mclist
;
885 memset(mc_filter
, 0, sizeof(mc_filter
));
886 for (i
= 0, mclist
= dev
->mc_list
; mclist
&& i
< dev
->mc_count
;
887 i
++, mclist
= mclist
->next
)
889 int filterbit
= ether_crc_le(ETH_ALEN
, mclist
->dmi_addr
) & 0x3f;
890 mc_filter
[filterbit
>> 5] |= 1 << (filterbit
& 31);
892 new_mode
= CMR2h_Normal
;
894 lp
->addr_mode
= new_mode
;
895 write_reg(ioaddr
, CMR2
, CMR2_IRQOUT
| 0x04); /* Switch to page 1. */
896 for (i
= 0; i
< 8; i
++)
897 write_reg_byte(ioaddr
, i
, mc_filter
[i
]);
898 if (net_debug
> 2 || 1) {
900 printk(KERN_DEBUG
"%s: Mode %d, setting multicast filter to",
901 dev
->name
, lp
->addr_mode
);
902 for (i
= 0; i
< 8; i
++)
903 printk(" %2.2x", mc_filter
[i
]);
907 write_reg_high(ioaddr
, CMR2
, lp
->addr_mode
);
908 write_reg(ioaddr
, CMR2
, CMR2_IRQOUT
); /* Switch back to page 0 */
911 static int __init
atp_init_module(void) {
912 if (debug
) /* Emit version even if no cards detected. */
913 printk(KERN_INFO
"%s", version
);
917 static void __exit
atp_cleanup_module(void) {
918 struct net_device
*next_dev
;
920 while (root_atp_dev
) {
921 next_dev
= ((struct net_local
*)root_atp_dev
->priv
)->next_module
;
922 unregister_netdev(root_atp_dev
);
923 /* No need to release_region(), since we never snarf it. */
924 free_netdev(root_atp_dev
);
925 root_atp_dev
= next_dev
;
929 module_init(atp_init_module
);
930 module_exit(atp_cleanup_module
);
This page took 0.04919 seconds and 5 git commands to generate.