![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
1 /* atp.c: Attached (pocket) ethernet adaptor driver for linux. */
2 /*
3 Written 1993 by Donald Becker.
4 Copyright 1993 United States Government as represented by the Director,
5 National Security Agency. This software may only be used and distributed
6 according to the terms of the GNU Public License as modified by SRC,
7 incorported herein by reference.
8
9 The author may be reached as becker@super.org or
10 C/O Supercomputing Research Ctr., 17100 Science Dr., Bowie MD 20715
11
12 */
13
14 static char *version =
15 "atp.c:v0.04 2/25/94 Donald Becker (becker@super.org)\n";
16
17 /*
18 This file is a device driver for the RealTek (aka AT-Lan-Tec) pocket
19 ethernet adaptor. This is a common low-cost OEM pocket ethernet
20 adaptor, sold under many names.
21
22 Sources:
23 This driver was written from the packet driver assembly code provided by
24 Vincent Bono of AT-Lan-Tec. Ever try to figure out how a complicated
25 device works just from the assembly code? It ain't pretty. The following
26 description is written based on guesses and writing lots of special-purpose
27 code to test my theorized operation.
28
29 Theory of Operation
30
31 The RTL8002 adaptor seems to be built around a custom spin of the SEEQ
32 controller core. It probably has a 16K or 64K internal packet buffer, of
33 which the first 4K is devoted to transmit and the rest to receive.
34 The controller maintains the queue of received packet and the packet buffer
35 access pointer internally, with only 'reset to beginning' and 'skip to next
36 packet' commands visible. The transmit packet queue holds two (or more?)
37 packets: both 'retransmit this packet' (due to collision) and 'transmit next
38 packet' commands must be started by hand.
39
40 The station address is stored in a standard bit-serial EEPROM which must be
41 read (ughh) by the device driver. (Provisions have been made for
42 substituting a 74S288 PROM, but I haven't gotten reports of any models
43 using it.) Unlike built-in devices, a pocket adaptor can temporarily lose
44 power without indication to the device driver. The major effect is that
45 the station address, receive filter (promiscuous, etc.) and transceiver
46 must be reset.
47
48 The controller itself has 16 registers, some of which use only the lower
49 bits. The registers are read and written 4 bits at a time. The four bit
50 register address is presented on the data lines along with a few additional
51 timing and control bits. The data is then read from status port or written
52 to the data port.
53
54 Since the bulk data transfer of the actual packets through the slow
55 parallel port dominates the driver's running time, four distinct data
56 (non-register) transfer modes are provided by the adaptor, two in each
57 direction. In the first mode timing for the nibble transfers is
58 provided through the data port. In the second mode the same timing is
59 provided through the control port. In either case the data is read from
60 the status port and written to the data port, just as it is accessing
61 registers.
62
63 In addition to the basic data transfer methods, several more are modes are
64 created by adding some delay by doing multiple reads of the data to allow
65 it to stabilize. This delay seems to be needed on most machines.
66
67 The data transfer mode is stored in the 'dev->if_port' field. Its default
68 value is '4'. It may be overriden at boot-time using the third parameter
69 to the "ether=..." initialization.
70
71 The header file <atp.h> provides inline functions that encapsulate the
72 register and data access methods. These functions are hand-tuned to
73 generate reasonable object code. This header file also documents my
74 interpretations of the device registers.
75 */
76
77 #include <linux/config.h> /* Used only to override default values. */
78 #include <linux/kernel.h>
79 #include <linux/sched.h>
80 #include <linux/types.h>
81 #include <linux/fcntl.h>
82 #include <linux/interrupt.h>
83 #include <linux/ptrace.h>
84 #include <linux/ioport.h>
85 #include <linux/in.h>
86 #include <linux/malloc.h>
87 #include <linux/string.h>
88 #include <asm/system.h>
89 #include <asm/bitops.h>
90 #include <asm/io.h>
91 #include <asm/dma.h>
92 #include <errno.h>
93
94 #include "dev.h"
95 #include "eth.h"
96 #include "skbuff.h"
97 #include "arp.h"
98
99 #include "atp.h"
100
101 /* Compatibility definitions for earlier kernel versions. */
102 #ifndef HAVE_AUTOIRQ
103 /* From auto_irq.c, in ioport.h for later versions. */
104 extern void autoirq_setup(int waittime);
105 extern int autoirq_report(int waittime);
106 /* The map from IRQ number (as passed to the interrupt handler) to
107 'struct device'. */
108 extern struct device *irq2dev_map[16];
109 #endif
110
111 #ifndef HAVE_ALLOC_SKB
112 #define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
113 #define kfree_skbmem(addr, size) kfree_s(addr,size);
114 #endif
115
116 #ifndef HAVE_PORTRESERVE
117 #define check_region(ioaddr, size) 0
118 #define snarf_region(ioaddr, size); do ; while (0)
119 #endif
120
121 /* use 0 for production, 1 for verification, >2 for debug */
122 #ifndef NET_DEBUG
123 #define NET_DEBUG 4
124 #endif
125 static unsigned int net_debug = NET_DEBUG;
126
127 /* The number of low I/O ports used by the ethercard. */
128 #define ETHERCARD_TOTAL_SIZE 3
129
130 /* Index to functions, as function prototypes. */
131
132 extern int atp_probe(struct device *dev);
133
134 static int atp_probe1(struct device *dev, short ioaddr);
135 static void init_dev(struct device *dev);
136 static void get_node_ID(struct device *dev);
137 static unsigned short eeprom_op(short ioaddr, unsigned int cmd);
138 static int net_open(struct device *dev);
139 static void hardware_init(struct device *dev);
140 static void write_packet(short ioaddr, int length, unsigned char *packet, int mode);
141 static void trigger_send(short ioaddr, int length);
142 static int net_send_packet(struct sk_buff *skb, struct device *dev);
143 static void net_interrupt(int reg_ptr);
144 static void net_rx(struct device *dev);
145 static void read_block(short ioaddr, int length, unsigned char *buffer, int data_mode);
146 static int net_close(struct device *dev);
147 static struct enet_statistics *net_get_stats(struct device *dev);
148 #ifdef HAVE_MULTICAST
149 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
150 #endif
151
152
153 /* Check for a network adaptor of this type, and return '0' iff one exists.
154 If dev->base_addr == 0, probe all likely locations.
155 If dev->base_addr == 1, always return failure.
156 If dev->base_addr == 2, alloate space for the device and return success
157 (detachable devices only).
158 */
159 int
160 atp_init(struct device *dev)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
161 {
162 int *port, ports[] = {0x378, 0x278, 0x3bc, 0};
163 int base_addr = dev->base_addr;
164
165 if (base_addr > 0x1ff) /* Check a single specified location. */
166 return atp_probe1(dev, base_addr);
167 else if (base_addr == 1) /* Don't probe at all. */
168 return ENXIO;
169
170 for (port = ports; *port; port++) {
171 int ioaddr = *port;
172 outb(0x57, ioaddr + PAR_DATA);
173 if (inb(ioaddr + PAR_DATA) != 0x57)
174 continue;
175 if (atp_probe1(dev, ioaddr) == 0)
176 return 0;
177 }
178
179 return ENODEV;
180 }
181
182 static int atp_probe1(struct device *dev, short ioaddr)
/* ![[previous]](../icons/left.png)
*/
183 {
184 int saved_ctrl_reg, status;
185
186 outb(0xff, ioaddr + PAR_DATA);
187 /* Save the original value of the Control register, in case we guessed
188 wrong. */
189 saved_ctrl_reg = inb(ioaddr + PAR_CONTROL);
190 /* IRQEN=0, SLCTB=high INITB=high, AUTOFDB=high, STBB=high. */
191 outb(0x04, ioaddr + PAR_CONTROL);
192 write_reg_high(ioaddr, CMR1, CMR1h_RESET);
193 eeprom_delay(2048);
194 status = read_nibble(ioaddr, CMR1);
195
196 if ((status & 0x78) != 0x08) {
197 /* The pocket adaptor probe failed, restore the control register. */
198 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
199 return 1;
200 }
201 status = read_nibble(ioaddr, CMR2_h);
202 if ((status & 0x78) != 0x10) {
203 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
204 return 1;
205 }
206 /* Find the IRQ used by triggering an interrupt. */
207 write_reg_byte(ioaddr, CMR2, 0x01); /* No accept mode, IRQ out. */
208 write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE); /* Enable Tx and Rx. */
209
210 /* Omit autoIRQ routine for now. Use "table lookup" instead. Uhgggh. */
211 if (ioaddr == 0x378)
212 dev->irq = 7;
213 else
214 dev->irq = 5;
215 write_reg_high(ioaddr, CMR1, CMR1h_TxRxOFF); /* Diable Tx and Rx units. */
216 write_reg(ioaddr, CMR2, CMR2_NULL);
217
218 dev->base_addr = ioaddr;
219
220 /* Read the station address PROM. */
221 get_node_ID(dev);
222
223 printk("%s: Pocket adaptor found at %#3x, IRQ %d, SAPROM "
224 "%02X:%02X:%02X:%02X:%02X:%02X.\n", dev->name, dev->base_addr,
225 dev->irq, dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
226 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
227
228 /* Leave the hardware in a reset state. */
229 write_reg_high(ioaddr, CMR1, CMR1h_RESET);
230
231 if (net_debug)
232 printk(version);
233
234 /* Initialize the device structure. */
235 init_dev(dev);
236 dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
237 memset(dev->priv, 0, sizeof(struct net_local));
238
239
240 {
241 struct net_local *lp = (struct net_local *)dev->priv;
242 lp->addr_mode = CMR2h_Normal;
243 }
244
245 /* For the ATP adaptor the "if_port" is really the data transfer mode. */
246 dev->if_port = (dev->mem_start & 0xf) ? dev->mem_start & 0x7 : 4;
247 if (dev->mem_end & 0xf)
248 net_debug = dev->mem_end & 7;
249
250 dev->open = net_open;
251 dev->stop = net_close;
252 dev->hard_start_xmit = net_send_packet;
253 dev->get_stats = net_get_stats;
254 #ifdef HAVE_MULTICAST
255 dev->set_multicast_list = &set_multicast_list;
256 #endif
257
258 return 0;
259 }
260
261 /* Fill in the fields of the device structure with ethernet-generic values.
262 This should be in a common file instead of per-driver. */
263 static void init_dev(struct device *dev)
/* */
264 {
265 int i;
266
267 for (i = 0; i < DEV_NUMBUFFS; i++)
268 dev->buffs[i] = NULL;
269
270 dev->hard_header = eth_header;
271 dev->add_arp = eth_add_arp;
272 dev->queue_xmit = dev_queue_xmit;
273 dev->rebuild_header = eth_rebuild_header;
274 dev->type_trans = eth_type_trans;
275
276 dev->type = ARPHRD_ETHER;
277 dev->hard_header_len = ETH_HLEN;
278 dev->mtu = 1500; /* eth_mtu */
279 dev->addr_len = ETH_ALEN;
280 for (i = 0; i < ETH_ALEN; i++) {
281 dev->broadcast[i]=0xff;
282 }
283
284 /* New-style flags. */
285 dev->flags = IFF_BROADCAST;
286 dev->family = AF_INET;
287 dev->pa_addr = 0;
288 dev->pa_brdaddr = 0;
289 dev->pa_mask = 0;
290 dev->pa_alen = sizeof(unsigned long);
291 }
292
293 /* Read the station address PROM, usually a word-wide EEPROM. */
294 static void get_node_ID(struct device *dev)
/* */
295 {
296 short ioaddr = dev->base_addr;
297 int sa_offset = 0;
298 int i;
299
300 write_reg(ioaddr, CMR2, CMR2_EEPROM); /* Point to the EEPROM control registers. */
301
302 /* Some adaptors have the station address at offset 15 instead of offset
303 zero. Check for it, and fix it if needed. */
304 if (eeprom_op(ioaddr, EE_READ(0)) == 0xffff)
305 sa_offset = 15;
306
307 for (i = 0; i < 3; i++)
308 ((unsigned short *)dev->dev_addr)[i] =
309 ntohs(eeprom_op(ioaddr, EE_READ(sa_offset + i)));
310
311 write_reg(ioaddr, CMR2, CMR2_NULL);
312 }
313
314 /*
315 An EEPROM read command starts by shifting out 0x60+address, and then
316 shifting in the serial data. See the NatSemi databook for details.
317 * ________________
318 * CS : __|
319 * ___ ___
320 * CLK: ______| |___| |
321 * __ _______ _______
322 * DI : __X_______X_______X
323 * DO : _________X_______X
324 */
325
326 static unsigned short eeprom_op(short ioaddr, unsigned int cmd)
/* */
327 {
328 unsigned eedata_out = 0;
329 int num_bits = EE_CMD_SIZE;
330
331 while (--num_bits >= 0) {
332 char outval = test_bit(num_bits, &cmd) ? EE_DATA_WRITE : 0;
333 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_LOW);
334 eeprom_delay(5);
335 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_HIGH);
336 eedata_out <<= 1;
337 if (read_nibble(ioaddr, PROM_DATA) & EE_DATA_READ)
338 eedata_out++;
339 eeprom_delay(5);
340 }
341 write_reg_high(ioaddr, PROM_CMD, EE_CLK_LOW & ~EE_CS);
342 return eedata_out;
343 }
344
345
346 /* Open/initialize the board. This is called (in the current kernel)
347 sometime after booting when the 'ifconfig' program is run.
348
349 This routine sets everything up anew at each open, even
350 registers that "should" only need to be set once at boot, so that
351 there is non-reboot way to recover if something goes wrong.
352
353 This is an attachable device: if there is no dev->priv entry then it wasn't
354 probed for at boot-time, and we need to probe for it again.
355 */
356 static int net_open(struct device *dev)
/* */
357 {
358
359 /* The interrupt line is turned off (tri-stated) when the device isn't in
360 use. That's especially important for "attached" interfaces where the
361 port or interrupt may be shared. */
362 if (irq2dev_map[dev->irq] != 0
363 || (irq2dev_map[dev->irq] = dev) == 0
364 || request_irq(dev->irq, &net_interrupt)) {
365 return -EAGAIN;
366 }
367
368 hardware_init(dev);
369 dev->start = 1;
370 return 0;
371 }
372
373 /* This routine resets the hardware. We initialize everything, assuming that
374 the hardware may have been temporarily detacted. */
375 static void hardware_init(struct device *dev)
/* */
376 {
377 struct net_local *lp = (struct net_local *)dev->priv;
378 int ioaddr = dev->base_addr;
379 int i;
380
381 write_reg_high(ioaddr, CMR1, CMR1h_RESET);
382
383 for (i = 0; i < 6; i++)
384 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
385
386 write_reg_high(ioaddr, CMR2, lp->addr_mode);
387
388 if (net_debug > 2) {
389 printk("%s: Reset: current Rx mode %d.\n", dev->name,
390 (read_nibble(ioaddr, CMR2_h) >> 3) & 0x0f);
391 }
392
393 write_reg(ioaddr, CMR2, CMR2_IRQOUT);
394 write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
395
396 /* Enable the interrupt line from the serial port. */
397 outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
398
399 /* Unmask the interesting interrupts. */
400 write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
401 write_reg_high(ioaddr, IMR, ISRh_RxErr);
402
403 lp->tx_unit_busy = 0;
404 lp->pac_cnt_in_tx_buf = 0;
405 lp->saved_tx_size = 0;
406
407 dev->tbusy = 0;
408 dev->interrupt = 0;
409 }
410
411 static void trigger_send(short ioaddr, int length)
/* */
412 {
413 write_reg_byte(ioaddr, TxCNT0, length & 0xff);
414 write_reg(ioaddr, TxCNT1, length >> 8);
415 write_reg(ioaddr, CMR1, CMR1_Xmit);
416 }
417
418 static void write_packet(short ioaddr, int length, unsigned char *packet, int data_mode)
/* */
419 {
420 length = (length + 1) & ~1; /* Round up to word length. */
421 outb(EOC+MAR, ioaddr + PAR_DATA);
422 if ((data_mode & 1) == 0) {
423 /* Write the packet out, starting with the write addr. */
424 outb(WrAddr+MAR, ioaddr + PAR_DATA);
425 do {
426 write_byte_mode0(ioaddr, *packet++);
427 } while (--length > 0) ;
428 } else {
429 /* Write the packet out in slow mode. */
430 unsigned char outbyte = *packet++;
431
432 outb(Ctrl_LNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
433 outb(WrAddr+MAR, ioaddr + PAR_DATA);
434
435 outb((outbyte & 0x0f)|0x40, ioaddr + PAR_DATA);
436 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
437 outbyte >>= 4;
438 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
439 outb(Ctrl_HNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
440 while (--length > 0)
441 write_byte_mode1(ioaddr, *packet++);
442 }
443 /* Terminate the Tx frame. End of write: ECB. */
444 outb(0xff, ioaddr + PAR_DATA);
445 outb(Ctrl_HNibWrite | Ctrl_SelData | Ctrl_IRQEN, ioaddr + PAR_CONTROL);
446 }
447
448 static int
449 net_send_packet(struct sk_buff *skb, struct device *dev)
/* */
450 {
451 struct net_local *lp = (struct net_local *)dev->priv;
452 int ioaddr = dev->base_addr;
453
454 if (dev->tbusy) {
455 /* If we get here, some higher level has decided we are broken.
456 There should really be a "kick me" function call instead. */
457 int tickssofar = jiffies - dev->trans_start;
458 if (tickssofar < 5)
459 return 1;
460 printk("%s: transmit timed out, %s?\n", dev->name,
461 inb(ioaddr + PAR_CONTROL) & 0x10 ? "network cable problem"
462 : "IRQ conflict");
463 lp->stats.tx_errors++;
464 /* Try to restart the adaptor. */
465 hardware_init(dev);
466 dev->tbusy=0;
467 dev->trans_start = jiffies;
468 }
469
470 /* If some higher layer thinks we've missed an tx-done interrupt
471 we are passed NULL. Caution: dev_tint() handles the cli()/sti()
472 itself. */
473 if (skb == NULL) {
474 dev_tint(dev);
475 return 0;
476 }
477
478 /* For ethernet, fill in the header. This should really be done by a
479 higher level, rather than duplicated for each ethernet adaptor. */
480 if (!skb->arp && dev->rebuild_header(skb->data, dev)) {
481 skb->dev = dev;
482 arp_queue (skb);
483 return 0;
484 }
485 skb->arp=1;
486
487 /* Block a timer-based transmit from overlapping. This could better be
488 done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
489 if (set_bit(0, (void*)&dev->tbusy) != 0)
490 printk("%s: Transmitter access conflict.\n", dev->name);
491 else {
492 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
493 unsigned char *buf = skb->data;
494 int flags;
495
496 /* Disable interrupts by writing 0x00 to the Interrupt Mask Register.
497 This sequence must not be interrupted by an incoming packet. */
498 save_flags(flags);
499 cli();
500 write_reg(ioaddr, IMR, 0);
501 write_reg_high(ioaddr, IMR, 0);
502 restore_flags(flags);
503
504 write_packet(ioaddr, length, buf, dev->if_port);
505
506 lp->pac_cnt_in_tx_buf++;
507 if (lp->tx_unit_busy == 0) {
508 trigger_send(ioaddr, length);
509 lp->saved_tx_size = 0; /* Redundent */
510 lp->re_tx = 0;
511 lp->tx_unit_busy = 1;
512 } else
513 lp->saved_tx_size = length;
514
515 dev->trans_start = jiffies;
516 /* Re-enable the LPT interrupts. */
517 write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
518 write_reg_high(ioaddr, IMR, ISRh_RxErr);
519 }
520
521 if (skb->free)
522 kfree_skb (skb, FREE_WRITE);
523
524 return 0;
525 }
526
527 /* The typical workload of the driver:
528 Handle the network interface interrupts. */
529 static void
530 net_interrupt(int reg_ptr)
/* */
531 {
532 int irq = -(((struct pt_regs *)reg_ptr)->orig_eax+2);
533 struct device *dev = (struct device *)(irq2dev_map[irq]);
534 struct net_local *lp;
535 int ioaddr, status, boguscount = 20;
536 static int num_tx_since_rx = 0;
537
538 if (dev == NULL) {
539 printk ("ATP_interrupt(): irq %d for unknown device.\n", irq);
540 return;
541 }
542 dev->interrupt = 1;
543
544 ioaddr = dev->base_addr;
545 lp = (struct net_local *)dev->priv;
546
547 /* Disable additional spurious interrupts. */
548 outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
549
550 /* The adaptor's output is currently the IRQ line, switch it to data. */
551 write_reg(ioaddr, CMR2, CMR2_NULL);
552 write_reg(ioaddr, IMR, 0);
553
554 if (net_debug > 5) printk("%s: In interrupt ", dev->name);
555 while (--boguscount > 0) {
556 status = read_nibble(ioaddr, ISR);
557 if (net_debug > 5) printk("loop status %02x..", status);
558
559 if (status & (ISR_RxOK<<3)) {
560 write_reg(ioaddr, ISR, ISR_RxOK); /* Clear the Rx interrupt. */
561 do {
562 int read_status = read_nibble(ioaddr, CMR1);
563 if (net_debug > 6)
564 printk("handling Rx packet %02x..", read_status);
565 /* We acknowledged the normal Rx interrupt, so if the interrupt
566 is still outstanding we must have a Rx error. */
567 if (read_status & (CMR1_IRQ << 3)) { /* Overrun. */
568 lp->stats.rx_over_errors++;
569 /* Set to no-accept mode long enough to remove a packet. */
570 write_reg_high(ioaddr, CMR2, CMR2h_OFF);
571 net_rx(dev);
572 /* Clear the interrupt and return to normal Rx mode. */
573 write_reg_high(ioaddr, ISR, ISRh_RxErr);
574 write_reg_high(ioaddr, CMR2, lp->addr_mode);
575 } else if ((read_status & (CMR1_BufEnb << 3)) == 0) {
576 net_rx(dev);
577 dev->last_rx = jiffies;
578 num_tx_since_rx = 0;
579 } else
580 break;
581 } while (--boguscount > 0);
582 } else if (status & ((ISR_TxErr + ISR_TxOK)<<3)) {
583 if (net_debug > 6) printk("handling Tx done..");
584 /* Clear the Tx interrupt. We should check for too many failures
585 and reinitialize the adaptor. */
586 write_reg(ioaddr, ISR, ISR_TxErr + ISR_TxOK);
587 if (status & (ISR_TxErr<<3)) {
588 lp->stats.collisions++;
589 if (++lp->re_tx > 15) {
590 lp->stats.tx_aborted_errors++;
591 hardware_init(dev);
592 break;
593 }
594 /* Attempt to retransmit. */
595 if (net_debug > 6) printk("attempting to ReTx");
596 write_reg(ioaddr, CMR1, CMR1_ReXmit + CMR1_Xmit);
597 } else {
598 /* Finish up the transmit. */
599 lp->stats.tx_packets++;
600 lp->pac_cnt_in_tx_buf--;
601 if ( lp->saved_tx_size) {
602 trigger_send(ioaddr, lp->saved_tx_size);
603 lp->saved_tx_size = 0;
604 lp->re_tx = 0;
605 } else
606 lp->tx_unit_busy = 0;
607 dev->tbusy = 0;
608 mark_bh(INET_BH); /* Inform upper layers. */
609 }
610 num_tx_since_rx++;
611 } else if (num_tx_since_rx > 8
612 && jiffies > dev->last_rx + 100) {
613 if (net_debug > 2)
614 printk("%s: Missed packet? No Rx after %d Tx and %ld jiffies"
615 " status %02x CMR1 %02x.\n", dev->name,
616 num_tx_since_rx, jiffies - dev->last_rx, status,
617 (read_nibble(ioaddr, CMR1) >> 3) & 15);
618 lp->stats.rx_missed_errors++;
619 hardware_init(dev);
620 num_tx_since_rx = 0;
621 break;
622 } else
623 break;
624 }
625
626 /* This following code fixes a rare (and very difficult to track down)
627 problem where the adaptor forgets its ethernet address. */
628 {
629 int i;
630 for (i = 0; i < 6; i++)
631 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
632 }
633
634 /* Tell the adaptor that it can go back to using the output line as IRQ. */
635 write_reg(ioaddr, CMR2, CMR2_IRQOUT);
636 /* Enable the physical interrupt line, which is sure to be low until.. */
637 outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
638 /* .. we enable the interrupt sources. */
639 write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
640 write_reg_high(ioaddr, IMR, ISRh_RxErr); /* Hmmm, really needed? */
641
642 if (net_debug > 5) printk("exiting interrupt.\n");
643
644 dev->interrupt = 0;
645
646 return;
647 }
648
649 /* We have a good packet(s), get it/them out of the buffers. */
650 static void net_rx(struct device *dev)
/* */
651 {
652 struct net_local *lp = (struct net_local *)dev->priv;
653 int ioaddr = dev->base_addr;
654 #ifdef notdef
655 ushort header[4];
656 #else
657 struct rx_header rx_head;
658 #endif
659
660 /* Process the received packet. */
661 outb(EOC+MAR, ioaddr + PAR_DATA);
662 read_block(ioaddr, 8, (unsigned char*)&rx_head, dev->if_port);
663 if (net_debug > 5)
664 printk(" rx_count %04x %04x %04x %04x..", rx_head.pad,
665 rx_head.rx_count, rx_head.rx_status, rx_head.cur_addr);
666 if ((rx_head.rx_status & 0x77) != 0x01) {
667 lp->stats.rx_errors++;
668 /* Ackkk! I don't have any documentation on what the error bits mean!
669 The best I can do is slap the device around a bit. */
670 if (net_debug > 3) printk("%s: Unknown ATP Rx error %04x.\n",
671 dev->name, rx_head.rx_status);
672 hardware_init(dev);
673 return;
674 } else {
675 /* Malloc up new buffer. */
676 int pkt_len = (rx_head.rx_count & 0x7ff) - 4; /* The "-4" is omits the FCS (CRC). */
677 int sksize = sizeof(struct sk_buff) + pkt_len;
678 struct sk_buff *skb;
679
680 skb = alloc_skb(sksize, GFP_ATOMIC);
681 if (skb == NULL) {
682 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
683 lp->stats.rx_dropped++;
684 goto done;
685 }
686 skb->mem_len = sksize;
687 skb->mem_addr = skb;
688 skb->len = pkt_len;
689 skb->dev = dev;
690
691 read_block(ioaddr, pkt_len, skb->data, dev->if_port);
692
693 if (net_debug > 6) {
694 unsigned char *data = skb->data;
695 printk(" data %02x%02x%02x %02x%02x%02x %02x%02x%02x"
696 "%02x%02x%02x %02x%02x..",
697 data[0], data[1], data[2], data[3], data[4], data[5],
698 data[6], data[7], data[8], data[9], data[10], data[11],
699 data[12], data[13]);
700 }
701
702 #ifdef HAVE_NETIF_RX
703 netif_rx(skb);
704 #else
705 skb->lock = 0;
706 if (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) {
707 kfree_s(skb, sksize);
708 lp->stats.rx_dropped++;
709 break;
710 }
711 #endif
712 lp->stats.rx_packets++;
713 }
714 done:
715 write_reg(ioaddr, CMR1, CMR1_NextPkt);
716 return;
717 }
718
719 static void read_block(short ioaddr, int length, unsigned char *p, int data_mode)
/* */
720 {
721
722 if (data_mode <= 3) { /* Mode 0 or 1 */
723 outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
724 outb(length == 8 ? RdAddr | HNib | MAR : RdAddr | MAR,
725 ioaddr + PAR_DATA);
726 if (data_mode <= 1) { /* Mode 0 or 1 */
727 do *p++ = read_byte_mode0(ioaddr); while (--length > 0);
728 } else /* Mode 2 or 3 */
729 do *p++ = read_byte_mode2(ioaddr); while (--length > 0);
730 } else if (data_mode <= 5)
731 do *p++ = read_byte_mode4(ioaddr); while (--length > 0);
732 else
733 do *p++ = read_byte_mode6(ioaddr); while (--length > 0);
734
735 outb(EOC+HNib+MAR, ioaddr + PAR_DATA);
736 outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
737 }
738
739 /* The inverse routine to net_open(). */
740 static int
741 net_close(struct device *dev)
/* */
742 {
743 struct net_local *lp = (struct net_local *)dev->priv;
744 int ioaddr = dev->base_addr;
745
746 dev->tbusy = 1;
747 dev->start = 0;
748
749 /* Flush the Tx and disable Rx here. */
750 lp->addr_mode = CMR2h_OFF;
751 write_reg_high(ioaddr, CMR2, CMR2h_OFF);
752
753 /* Free the IRQ line. */
754 outb(0x00, ioaddr + PAR_CONTROL);
755 free_irq(dev->irq);
756 irq2dev_map[dev->irq] = 0;
757
758 /* Leave the hardware in a reset state. */
759 write_reg_high(ioaddr, CMR1, CMR1h_RESET);
760
761 return 0;
762 }
763
764 /* Get the current statistics. This may be called with the card open or
765 closed. */
766 static struct enet_statistics *
767 net_get_stats(struct device *dev)
/* */
768 {
769 struct net_local *lp = (struct net_local *)dev->priv;
770 return &lp->stats;
771 }
772
773 #ifdef HAVE_MULTICAST
774 /* Set or clear the multicast filter for this adaptor.
775 num_addrs == -1 Promiscuous mode, receive all packets
776 num_addrs == 0 Normal mode, clear multicast list
777 num_addrs > 0 Multicast mode, receive normal and MC packets, and do
778 best-effort filtering.
779 */
780 static void
781 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
/* ![[last]](../icons/n_last.png)
*/
782 {
783 struct net_local *lp = (struct net_local *)dev->priv;
784 short ioaddr = dev->base_addr;
785 lp->addr_mode = num_addrs ? CMR2h_PROMISC : CMR2h_Normal;
786 write_reg_high(ioaddr, CMR2, lp->addr_mode);
787 }
788 #endif
789
790 /*
791 * Local variables:
792 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c atp.c"
793 * version-control: t
794 * kept-new-versions: 5
795 * tab-width: 4
796 * End:
797 */
![[bottom]](../icons/n_bottom.png){kind=icon}
*/