![[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.02 12/22/93 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+1, 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 = (void *)(skb+1);
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 %d 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 /* Tell the adaptor that it can go back to using the output line as IRQ. */
627 write_reg(ioaddr, CMR2, CMR2_IRQOUT);
628 /* Enable the physical interrupt line, which is sure to be low until.. */
629 outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
630 /* .. we enable the interrupt sources. */
631 write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
632 write_reg_high(ioaddr, IMR, ISRh_RxErr); /* Hmmm, really needed? */
633
634 if (net_debug > 5) printk("exiting interrupt.\n");
635
636 dev->interrupt = 0;
637
638 return;
639 }
640
641 /* We have a good packet(s), get it/them out of the buffers. */
642 static void net_rx(struct device *dev)
/* */
643 {
644 struct net_local *lp = (struct net_local *)dev->priv;
645 int ioaddr = dev->base_addr;
646 #ifdef notdef
647 ushort header[4];
648 #else
649 struct rx_header rx_head;
650 #endif
651
652 /* Process the received packet. */
653 outb(EOC+MAR, ioaddr + PAR_DATA);
654 read_block(ioaddr, 8, (unsigned char*)&rx_head, dev->if_port);
655 if (net_debug > 5)
656 printk(" rx_count %04x %04x %04x %04x..", rx_head.pad,
657 rx_head.rx_count, rx_head.rx_status, rx_head.cur_addr);
658 if ((rx_head.rx_status & 0x77) != 0x01) {
659 lp->stats.rx_errors++;
660 /* Ackkk! I don't have any documentation on what the error bits mean!
661 The best I can do is slap the device around a bit. */
662 if (net_debug > 3) printk("%s: Unknown ATP Rx error %04x.\n",
663 dev->name, rx_head.rx_status);
664 hardware_init(dev);
665 return;
666 } else {
667 /* Malloc up new buffer. */
668 int pkt_len = (rx_head.rx_count & 0x7ff) - 4; /* The "-4" is omits the FCS (CRC). */
669 int sksize = sizeof(struct sk_buff) + pkt_len;
670 struct sk_buff *skb;
671
672 skb = alloc_skb(sksize, GFP_ATOMIC);
673 if (skb == NULL) {
674 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
675 lp->stats.rx_dropped++;
676 goto done;
677 }
678 skb->mem_len = sksize;
679 skb->mem_addr = skb;
680 skb->len = pkt_len;
681 skb->dev = dev;
682
683 /* 'skb+1' points to the start of sk_buff data area. */
684 read_block(ioaddr, pkt_len, (unsigned char *)(skb + 1), dev->if_port);
685
686 if (net_debug > 6) {
687 unsigned char *data = (unsigned char *)(skb + 1);
688 printk(" data %02x%02x%02x %02x%02x%02x %02x%02x%02x %02x%02x%02x %02x%02x..",
689 data[0], data[1], data[2], data[3], data[4], data[5],
690 data[6], data[7], data[8], data[9], data[10], data[11],
691 data[12], data[13]);
692 }
693
694 #ifdef HAVE_NETIF_RX
695 netif_rx(skb);
696 #else
697 skb->lock = 0;
698 if (dev_rint((unsigned char*)skb, pkt_len, IN_SKBUFF, dev) != 0) {
699 kfree_s(skb, sksize);
700 lp->stats.rx_dropped++;
701 break;
702 }
703 #endif
704 lp->stats.rx_packets++;
705 }
706 done:
707 write_reg(ioaddr, CMR1, CMR1_NextPkt);
708 return;
709 }
710
711 static void read_block(short ioaddr, int length, unsigned char *p, int data_mode)
/* */
712 {
713
714 if (data_mode <= 3) { /* Mode 0 or 1 */
715 outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
716 outb(length == 8 ? RdAddr | HNib | MAR : RdAddr | MAR,
717 ioaddr + PAR_DATA);
718 if (data_mode <= 1) { /* Mode 0 or 1 */
719 do *p++ = read_byte_mode0(ioaddr); while (--length > 0);
720 } else /* Mode 2 or 3 */
721 do *p++ = read_byte_mode2(ioaddr); while (--length > 0);
722 } else if (data_mode <= 5)
723 do *p++ = read_byte_mode4(ioaddr); while (--length > 0);
724 else
725 do *p++ = read_byte_mode6(ioaddr); while (--length > 0);
726
727 outb(EOC+HNib+MAR, ioaddr + PAR_DATA);
728 outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
729 }
730
731 /* The inverse routine to net_open(). */
732 static int
733 net_close(struct device *dev)
/* */
734 {
735 struct net_local *lp = (struct net_local *)dev->priv;
736 int ioaddr = dev->base_addr;
737
738 dev->tbusy = 1;
739 dev->start = 0;
740
741 /* Flush the Tx and disable Rx here. */
742 lp->addr_mode = CMR2h_OFF;
743 write_reg_high(ioaddr, CMR2, CMR2h_OFF);
744
745 /* Free the IRQ line. */
746 outb(0x00, ioaddr + PAR_CONTROL);
747 free_irq(dev->irq);
748 irq2dev_map[dev->irq] = 0;
749
750 /* Leave the hardware in a reset state. */
751 write_reg_high(ioaddr, CMR1, CMR1h_RESET);
752
753 return 0;
754 }
755
756 /* Get the current statistics. This may be called with the card open or
757 closed. */
758 static struct enet_statistics *
759 net_get_stats(struct device *dev)
/* */
760 {
761 struct net_local *lp = (struct net_local *)dev->priv;
762 return &lp->stats;
763 }
764
765 #ifdef HAVE_MULTICAST
766 /* Set or clear the multicast filter for this adaptor.
767 num_addrs == -1 Promiscuous mode, receive all packets
768 num_addrs == 0 Normal mode, clear multicast list
769 num_addrs > 0 Multicast mode, receive normal and MC packets, and do
770 best-effort filtering.
771 */
772 static void
773 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
/* ![[last]](../icons/n_last.png)
*/
774 {
775 struct net_local *lp = (struct net_local *)dev->priv;
776 short ioaddr = dev->base_addr;
777 lp->addr_mode = num_addrs ? CMR2h_PROMISC : CMR2h_Normal;
778 write_reg_high(ioaddr, CMR2, lp->addr_mode);
779 }
780 #endif
781
782 /*
783 * Local variables:
784 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c atp.c"
785 * version-control: t
786 * kept-new-versions: 5
787 * tab-width: 4
788 * End:
789 */
![[bottom]](../icons/n_bottom.png){kind=icon}
*/