![[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 incorporated 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 overridden 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 <linux/netdevice.h>
95 #include <linux/etherdevice.h>
96 #include <linux/skbuff.h>
97
98 #include "atp.h"
99
100 /* Compatibility definitions for earlier kernel versions. */
101 #ifndef HAVE_AUTOIRQ
102 /* From auto_irq.c, in ioport.h for later versions. */
103 extern void autoirq_setup(int waittime);
104 extern int autoirq_report(int waittime);
105 /* The map from IRQ number (as passed to the interrupt handler) to
106 'struct device'. */
107 extern struct device *irq2dev_map[16];
108 #endif
109
110 #ifndef HAVE_ALLOC_SKB
111 #define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
112 #define kfree_skbmem(addr, size) kfree_s(addr,size);
113 #endif
114
115 #ifndef HAVE_PORTRESERVE
116 #define check_region(ioaddr, size) 0
117 #define snarf_region(ioaddr, size); do ; while (0)
118 #endif
119
120 /* use 0 for production, 1 for verification, >2 for debug */
121 #ifndef NET_DEBUG
122 #define NET_DEBUG 4
123 #endif
124 static unsigned int net_debug = NET_DEBUG;
125
126 /* The number of low I/O ports used by the ethercard. */
127 #define ETHERCARD_TOTAL_SIZE 3
128
129 /* Index to functions, as function prototypes. */
130
131 extern int atp_probe(struct device *dev);
132
133 static int atp_probe1(struct device *dev, short ioaddr);
134 static void get_node_ID(struct device *dev);
135 static unsigned short eeprom_op(short ioaddr, unsigned int cmd);
136 static int net_open(struct device *dev);
137 static void hardware_init(struct device *dev);
138 static void write_packet(short ioaddr, int length, unsigned char *packet, int mode);
139 static void trigger_send(short ioaddr, int length);
140 static int net_send_packet(struct sk_buff *skb, struct device *dev);
141 static void net_interrupt(int reg_ptr);
142 static void net_rx(struct device *dev);
143 static void read_block(short ioaddr, int length, unsigned char *buffer, int data_mode);
144 static int net_close(struct device *dev);
145 static struct enet_statistics *net_get_stats(struct device *dev);
146 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
147
148
149 /* Check for a network adaptor of this type, and return '0' iff one exists.
150 If dev->base_addr == 0, probe all likely locations.
151 If dev->base_addr == 1, always return failure.
152 If dev->base_addr == 2, allocate space for the device and return success
153 (detachable devices only).
154 */
155 int
156 atp_init(struct device *dev)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
157 {
158 int *port, ports[] = {0x378, 0x278, 0x3bc, 0};
159 int base_addr = dev->base_addr;
160
161 if (base_addr > 0x1ff) /* Check a single specified location. */
162 return atp_probe1(dev, base_addr);
163 else if (base_addr == 1) /* Don't probe at all. */
164 return ENXIO;
165
166 for (port = ports; *port; port++) {
167 int ioaddr = *port;
168 outb(0x57, ioaddr + PAR_DATA);
169 if (inb(ioaddr + PAR_DATA) != 0x57)
170 continue;
171 if (atp_probe1(dev, ioaddr) == 0)
172 return 0;
173 }
174
175 return ENODEV;
176 }
177
178 static int atp_probe1(struct device *dev, short ioaddr)
/* ![[previous]](../icons/left.png)
*/
179 {
180 int saved_ctrl_reg, status;
181
182 outb(0xff, ioaddr + PAR_DATA);
183 /* Save the original value of the Control register, in case we guessed
184 wrong. */
185 saved_ctrl_reg = inb(ioaddr + PAR_CONTROL);
186 /* IRQEN=0, SLCTB=high INITB=high, AUTOFDB=high, STBB=high. */
187 outb(0x04, ioaddr + PAR_CONTROL);
188 write_reg_high(ioaddr, CMR1, CMR1h_RESET);
189 eeprom_delay(2048);
190 status = read_nibble(ioaddr, CMR1);
191
192 if ((status & 0x78) != 0x08) {
193 /* The pocket adaptor probe failed, restore the control register. */
194 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
195 return 1;
196 }
197 status = read_nibble(ioaddr, CMR2_h);
198 if ((status & 0x78) != 0x10) {
199 outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
200 return 1;
201 }
202 /* Find the IRQ used by triggering an interrupt. */
203 write_reg_byte(ioaddr, CMR2, 0x01); /* No accept mode, IRQ out. */
204 write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE); /* Enable Tx and Rx. */
205
206 /* Omit autoIRQ routine for now. Use "table lookup" instead. Uhgggh. */
207 if (ioaddr == 0x378)
208 dev->irq = 7;
209 else
210 dev->irq = 5;
211 write_reg_high(ioaddr, CMR1, CMR1h_TxRxOFF); /* Disable Tx and Rx units. */
212 write_reg(ioaddr, CMR2, CMR2_NULL);
213
214 dev->base_addr = ioaddr;
215
216 /* Read the station address PROM. */
217 get_node_ID(dev);
218
219 printk("%s: Pocket adaptor found at %#3x, IRQ %d, SAPROM "
220 "%02X:%02X:%02X:%02X:%02X:%02X.\n", dev->name, dev->base_addr,
221 dev->irq, dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
222 dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
223
224 /* Leave the hardware in a reset state. */
225 write_reg_high(ioaddr, CMR1, CMR1h_RESET);
226
227 if (net_debug)
228 printk(version);
229
230 /* Initialize the device structure. */
231 ether_setup(dev);
232 dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
233 memset(dev->priv, 0, sizeof(struct net_local));
234
235
236 {
237 struct net_local *lp = (struct net_local *)dev->priv;
238 lp->addr_mode = CMR2h_Normal;
239 }
240
241 /* For the ATP adaptor the "if_port" is really the data transfer mode. */
242 dev->if_port = (dev->mem_start & 0xf) ? dev->mem_start & 0x7 : 4;
243 if (dev->mem_end & 0xf)
244 net_debug = dev->mem_end & 7;
245
246 dev->open = net_open;
247 dev->stop = net_close;
248 dev->hard_start_xmit = net_send_packet;
249 dev->get_stats = net_get_stats;
250 dev->set_multicast_list = &set_multicast_list;
251
252 return 0;
253 }
254
255 /* Read the station address PROM, usually a word-wide EEPROM. */
256 static void get_node_ID(struct device *dev)
/* */
257 {
258 short ioaddr = dev->base_addr;
259 int sa_offset = 0;
260 int i;
261
262 write_reg(ioaddr, CMR2, CMR2_EEPROM); /* Point to the EEPROM control registers. */
263
264 /* Some adaptors have the station address at offset 15 instead of offset
265 zero. Check for it, and fix it if needed. */
266 if (eeprom_op(ioaddr, EE_READ(0)) == 0xffff)
267 sa_offset = 15;
268
269 for (i = 0; i < 3; i++)
270 ((unsigned short *)dev->dev_addr)[i] =
271 ntohs(eeprom_op(ioaddr, EE_READ(sa_offset + i)));
272
273 write_reg(ioaddr, CMR2, CMR2_NULL);
274 }
275
276 /*
277 An EEPROM read command starts by shifting out 0x60+address, and then
278 shifting in the serial data. See the NatSemi databook for details.
279 * ________________
280 * CS : __|
281 * ___ ___
282 * CLK: ______| |___| |
283 * __ _______ _______
284 * DI : __X_______X_______X
285 * DO : _________X_______X
286 */
287
288 static unsigned short eeprom_op(short ioaddr, unsigned int cmd)
/* */
289 {
290 unsigned eedata_out = 0;
291 int num_bits = EE_CMD_SIZE;
292
293 while (--num_bits >= 0) {
294 char outval = test_bit(num_bits, &cmd) ? EE_DATA_WRITE : 0;
295 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_LOW);
296 eeprom_delay(5);
297 write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_HIGH);
298 eedata_out <<= 1;
299 if (read_nibble(ioaddr, PROM_DATA) & EE_DATA_READ)
300 eedata_out++;
301 eeprom_delay(5);
302 }
303 write_reg_high(ioaddr, PROM_CMD, EE_CLK_LOW & ~EE_CS);
304 return eedata_out;
305 }
306
307
308 /* Open/initialize the board. This is called (in the current kernel)
309 sometime after booting when the 'ifconfig' program is run.
310
311 This routine sets everything up anew at each open, even
312 registers that "should" only need to be set once at boot, so that
313 there is non-reboot way to recover if something goes wrong.
314
315 This is an attachable device: if there is no dev->priv entry then it wasn't
316 probed for at boot-time, and we need to probe for it again.
317 */
318 static int net_open(struct device *dev)
/* */
319 {
320
321 /* The interrupt line is turned off (tri-stated) when the device isn't in
322 use. That's especially important for "attached" interfaces where the
323 port or interrupt may be shared. */
324 if (irq2dev_map[dev->irq] != 0
325 || (irq2dev_map[dev->irq] = dev) == 0
326 || request_irq(dev->irq, &net_interrupt, 0, "atp")) {
327 return -EAGAIN;
328 }
329
330 hardware_init(dev);
331 dev->start = 1;
332 return 0;
333 }
334
335 /* This routine resets the hardware. We initialize everything, assuming that
336 the hardware may have been temporarily detached. */
337 static void hardware_init(struct device *dev)
/* */
338 {
339 struct net_local *lp = (struct net_local *)dev->priv;
340 int ioaddr = dev->base_addr;
341 int i;
342
343 write_reg_high(ioaddr, CMR1, CMR1h_RESET);
344
345 for (i = 0; i < 6; i++)
346 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
347
348 write_reg_high(ioaddr, CMR2, lp->addr_mode);
349
350 if (net_debug > 2) {
351 printk("%s: Reset: current Rx mode %d.\n", dev->name,
352 (read_nibble(ioaddr, CMR2_h) >> 3) & 0x0f);
353 }
354
355 write_reg(ioaddr, CMR2, CMR2_IRQOUT);
356 write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
357
358 /* Enable the interrupt line from the serial port. */
359 outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
360
361 /* Unmask the interesting interrupts. */
362 write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
363 write_reg_high(ioaddr, IMR, ISRh_RxErr);
364
365 lp->tx_unit_busy = 0;
366 lp->pac_cnt_in_tx_buf = 0;
367 lp->saved_tx_size = 0;
368
369 dev->tbusy = 0;
370 dev->interrupt = 0;
371 }
372
373 static void trigger_send(short ioaddr, int length)
/* */
374 {
375 write_reg_byte(ioaddr, TxCNT0, length & 0xff);
376 write_reg(ioaddr, TxCNT1, length >> 8);
377 write_reg(ioaddr, CMR1, CMR1_Xmit);
378 }
379
380 static void write_packet(short ioaddr, int length, unsigned char *packet, int data_mode)
/* */
381 {
382 length = (length + 1) & ~1; /* Round up to word length. */
383 outb(EOC+MAR, ioaddr + PAR_DATA);
384 if ((data_mode & 1) == 0) {
385 /* Write the packet out, starting with the write addr. */
386 outb(WrAddr+MAR, ioaddr + PAR_DATA);
387 do {
388 write_byte_mode0(ioaddr, *packet++);
389 } while (--length > 0) ;
390 } else {
391 /* Write the packet out in slow mode. */
392 unsigned char outbyte = *packet++;
393
394 outb(Ctrl_LNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
395 outb(WrAddr+MAR, ioaddr + PAR_DATA);
396
397 outb((outbyte & 0x0f)|0x40, ioaddr + PAR_DATA);
398 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
399 outbyte >>= 4;
400 outb(outbyte & 0x0f, ioaddr + PAR_DATA);
401 outb(Ctrl_HNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
402 while (--length > 0)
403 write_byte_mode1(ioaddr, *packet++);
404 }
405 /* Terminate the Tx frame. End of write: ECB. */
406 outb(0xff, ioaddr + PAR_DATA);
407 outb(Ctrl_HNibWrite | Ctrl_SelData | Ctrl_IRQEN, ioaddr + PAR_CONTROL);
408 }
409
410 static int
411 net_send_packet(struct sk_buff *skb, struct device *dev)
/* */
412 {
413 struct net_local *lp = (struct net_local *)dev->priv;
414 int ioaddr = dev->base_addr;
415
416 if (dev->tbusy) {
417 /* If we get here, some higher level has decided we are broken.
418 There should really be a "kick me" function call instead. */
419 int tickssofar = jiffies - dev->trans_start;
420 if (tickssofar < 5)
421 return 1;
422 printk("%s: transmit timed out, %s?\n", dev->name,
423 inb(ioaddr + PAR_CONTROL) & 0x10 ? "network cable problem"
424 : "IRQ conflict");
425 lp->stats.tx_errors++;
426 /* Try to restart the adaptor. */
427 hardware_init(dev);
428 dev->tbusy=0;
429 dev->trans_start = jiffies;
430 }
431
432 /* If some higher layer thinks we've missed an tx-done interrupt
433 we are passed NULL. Caution: dev_tint() handles the cli()/sti()
434 itself. */
435 if (skb == NULL) {
436 dev_tint(dev);
437 return 0;
438 }
439
440 /* Block a timer-based transmit from overlapping. This could better be
441 done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
442 if (set_bit(0, (void*)&dev->tbusy) != 0)
443 printk("%s: Transmitter access conflict.\n", dev->name);
444 else {
445 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
446 unsigned char *buf = skb->data;
447 int flags;
448
449 /* Disable interrupts by writing 0x00 to the Interrupt Mask Register.
450 This sequence must not be interrupted by an incoming packet. */
451 save_flags(flags);
452 cli();
453 write_reg(ioaddr, IMR, 0);
454 write_reg_high(ioaddr, IMR, 0);
455 restore_flags(flags);
456
457 write_packet(ioaddr, length, buf, dev->if_port);
458
459 lp->pac_cnt_in_tx_buf++;
460 if (lp->tx_unit_busy == 0) {
461 trigger_send(ioaddr, length);
462 lp->saved_tx_size = 0; /* Redundant */
463 lp->re_tx = 0;
464 lp->tx_unit_busy = 1;
465 } else
466 lp->saved_tx_size = length;
467
468 dev->trans_start = jiffies;
469 /* Re-enable the LPT interrupts. */
470 write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
471 write_reg_high(ioaddr, IMR, ISRh_RxErr);
472 }
473
474 dev_kfree_skb (skb, FREE_WRITE);
475
476 return 0;
477 }
478
479 /* The typical workload of the driver:
480 Handle the network interface interrupts. */
481 static void
482 net_interrupt(int reg_ptr)
/* */
483 {
484 int irq = -(((struct pt_regs *)reg_ptr)->orig_eax+2);
485 struct device *dev = (struct device *)(irq2dev_map[irq]);
486 struct net_local *lp;
487 int ioaddr, status, boguscount = 20;
488 static int num_tx_since_rx = 0;
489
490 if (dev == NULL) {
491 printk ("ATP_interrupt(): irq %d for unknown device.\n", irq);
492 return;
493 }
494 dev->interrupt = 1;
495
496 ioaddr = dev->base_addr;
497 lp = (struct net_local *)dev->priv;
498
499 /* Disable additional spurious interrupts. */
500 outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
501
502 /* The adaptor's output is currently the IRQ line, switch it to data. */
503 write_reg(ioaddr, CMR2, CMR2_NULL);
504 write_reg(ioaddr, IMR, 0);
505
506 if (net_debug > 5) printk("%s: In interrupt ", dev->name);
507 while (--boguscount > 0) {
508 status = read_nibble(ioaddr, ISR);
509 if (net_debug > 5) printk("loop status %02x..", status);
510
511 if (status & (ISR_RxOK<<3)) {
512 write_reg(ioaddr, ISR, ISR_RxOK); /* Clear the Rx interrupt. */
513 do {
514 int read_status = read_nibble(ioaddr, CMR1);
515 if (net_debug > 6)
516 printk("handling Rx packet %02x..", read_status);
517 /* We acknowledged the normal Rx interrupt, so if the interrupt
518 is still outstanding we must have a Rx error. */
519 if (read_status & (CMR1_IRQ << 3)) { /* Overrun. */
520 lp->stats.rx_over_errors++;
521 /* Set to no-accept mode long enough to remove a packet. */
522 write_reg_high(ioaddr, CMR2, CMR2h_OFF);
523 net_rx(dev);
524 /* Clear the interrupt and return to normal Rx mode. */
525 write_reg_high(ioaddr, ISR, ISRh_RxErr);
526 write_reg_high(ioaddr, CMR2, lp->addr_mode);
527 } else if ((read_status & (CMR1_BufEnb << 3)) == 0) {
528 net_rx(dev);
529 dev->last_rx = jiffies;
530 num_tx_since_rx = 0;
531 } else
532 break;
533 } while (--boguscount > 0);
534 } else if (status & ((ISR_TxErr + ISR_TxOK)<<3)) {
535 if (net_debug > 6) printk("handling Tx done..");
536 /* Clear the Tx interrupt. We should check for too many failures
537 and reinitialize the adaptor. */
538 write_reg(ioaddr, ISR, ISR_TxErr + ISR_TxOK);
539 if (status & (ISR_TxErr<<3)) {
540 lp->stats.collisions++;
541 if (++lp->re_tx > 15) {
542 lp->stats.tx_aborted_errors++;
543 hardware_init(dev);
544 break;
545 }
546 /* Attempt to retransmit. */
547 if (net_debug > 6) printk("attempting to ReTx");
548 write_reg(ioaddr, CMR1, CMR1_ReXmit + CMR1_Xmit);
549 } else {
550 /* Finish up the transmit. */
551 lp->stats.tx_packets++;
552 lp->pac_cnt_in_tx_buf--;
553 if ( lp->saved_tx_size) {
554 trigger_send(ioaddr, lp->saved_tx_size);
555 lp->saved_tx_size = 0;
556 lp->re_tx = 0;
557 } else
558 lp->tx_unit_busy = 0;
559 dev->tbusy = 0;
560 mark_bh(NET_BH); /* Inform upper layers. */
561 }
562 num_tx_since_rx++;
563 } else if (num_tx_since_rx > 8
564 && jiffies > dev->last_rx + 100) {
565 if (net_debug > 2)
566 printk("%s: Missed packet? No Rx after %d Tx and %ld jiffies"
567 " status %02x CMR1 %02x.\n", dev->name,
568 num_tx_since_rx, jiffies - dev->last_rx, status,
569 (read_nibble(ioaddr, CMR1) >> 3) & 15);
570 lp->stats.rx_missed_errors++;
571 hardware_init(dev);
572 num_tx_since_rx = 0;
573 break;
574 } else
575 break;
576 }
577
578 /* This following code fixes a rare (and very difficult to track down)
579 problem where the adaptor forgets its ethernet address. */
580 {
581 int i;
582 for (i = 0; i < 6; i++)
583 write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
584 }
585
586 /* Tell the adaptor that it can go back to using the output line as IRQ. */
587 write_reg(ioaddr, CMR2, CMR2_IRQOUT);
588 /* Enable the physical interrupt line, which is sure to be low until.. */
589 outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
590 /* .. we enable the interrupt sources. */
591 write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
592 write_reg_high(ioaddr, IMR, ISRh_RxErr); /* Hmmm, really needed? */
593
594 if (net_debug > 5) printk("exiting interrupt.\n");
595
596 dev->interrupt = 0;
597
598 return;
599 }
600
601 /* We have a good packet(s), get it/them out of the buffers. */
602 static void net_rx(struct device *dev)
/* */
603 {
604 struct net_local *lp = (struct net_local *)dev->priv;
605 int ioaddr = dev->base_addr;
606 #ifdef notdef
607 ushort header[4];
608 #else
609 struct rx_header rx_head;
610 #endif
611
612 /* Process the received packet. */
613 outb(EOC+MAR, ioaddr + PAR_DATA);
614 read_block(ioaddr, 8, (unsigned char*)&rx_head, dev->if_port);
615 if (net_debug > 5)
616 printk(" rx_count %04x %04x %04x %04x..", rx_head.pad,
617 rx_head.rx_count, rx_head.rx_status, rx_head.cur_addr);
618 if ((rx_head.rx_status & 0x77) != 0x01) {
619 lp->stats.rx_errors++;
620 /* Ackkk! I don't have any documentation on what the error bits mean!
621 The best I can do is slap the device around a bit. */
622 if (net_debug > 3) printk("%s: Unknown ATP Rx error %04x.\n",
623 dev->name, rx_head.rx_status);
624 hardware_init(dev);
625 return;
626 } else {
627 /* Malloc up new buffer. */
628 int pkt_len = (rx_head.rx_count & 0x7ff) - 4; /* The "-4" is omits the FCS (CRC). */
629 struct sk_buff *skb;
630
631 skb = alloc_skb(pkt_len, GFP_ATOMIC);
632 if (skb == NULL) {
633 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
634 lp->stats.rx_dropped++;
635 goto done;
636 }
637 skb->len = pkt_len;
638 skb->dev = dev;
639
640 read_block(ioaddr, pkt_len, skb->data, dev->if_port);
641
642 if (net_debug > 6) {
643 unsigned char *data = skb->data;
644 printk(" data %02x%02x%02x %02x%02x%02x %02x%02x%02x"
645 "%02x%02x%02x %02x%02x..",
646 data[0], data[1], data[2], data[3], data[4], data[5],
647 data[6], data[7], data[8], data[9], data[10], data[11],
648 data[12], data[13]);
649 }
650
651 netif_rx(skb);
652 lp->stats.rx_packets++;
653 }
654 done:
655 write_reg(ioaddr, CMR1, CMR1_NextPkt);
656 return;
657 }
658
659 static void read_block(short ioaddr, int length, unsigned char *p, int data_mode)
/* */
660 {
661
662 if (data_mode <= 3) { /* Mode 0 or 1 */
663 outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
664 outb(length == 8 ? RdAddr | HNib | MAR : RdAddr | MAR,
665 ioaddr + PAR_DATA);
666 if (data_mode <= 1) { /* Mode 0 or 1 */
667 do *p++ = read_byte_mode0(ioaddr); while (--length > 0);
668 } else /* Mode 2 or 3 */
669 do *p++ = read_byte_mode2(ioaddr); while (--length > 0);
670 } else if (data_mode <= 5)
671 do *p++ = read_byte_mode4(ioaddr); while (--length > 0);
672 else
673 do *p++ = read_byte_mode6(ioaddr); while (--length > 0);
674
675 outb(EOC+HNib+MAR, ioaddr + PAR_DATA);
676 outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
677 }
678
679 /* The inverse routine to net_open(). */
680 static int
681 net_close(struct device *dev)
/* */
682 {
683 struct net_local *lp = (struct net_local *)dev->priv;
684 int ioaddr = dev->base_addr;
685
686 dev->tbusy = 1;
687 dev->start = 0;
688
689 /* Flush the Tx and disable Rx here. */
690 lp->addr_mode = CMR2h_OFF;
691 write_reg_high(ioaddr, CMR2, CMR2h_OFF);
692
693 /* Free the IRQ line. */
694 outb(0x00, ioaddr + PAR_CONTROL);
695 free_irq(dev->irq);
696 irq2dev_map[dev->irq] = 0;
697
698 /* Leave the hardware in a reset state. */
699 write_reg_high(ioaddr, CMR1, CMR1h_RESET);
700
701 return 0;
702 }
703
704 /* Get the current statistics. This may be called with the card open or
705 closed. */
706 static struct enet_statistics *
707 net_get_stats(struct device *dev)
/* */
708 {
709 struct net_local *lp = (struct net_local *)dev->priv;
710 return &lp->stats;
711 }
712
713 /* Set or clear the multicast filter for this adaptor.
714 num_addrs == -1 Promiscuous mode, receive all packets
715 num_addrs == 0 Normal mode, clear multicast list
716 num_addrs > 0 Multicast mode, receive normal and MC packets, and do
717 best-effort filtering.
718 */
719 static void
720 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
/* ![[last]](../icons/n_last.png)
*/
721 {
722 struct net_local *lp = (struct net_local *)dev->priv;
723 short ioaddr = dev->base_addr;
724 lp->addr_mode = num_addrs ? CMR2h_PROMISC : CMR2h_Normal;
725 write_reg_high(ioaddr, CMR2, lp->addr_mode);
726 }
727
728 /*
729 * Local variables:
730 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c atp.c"
731 * version-control: t
732 * kept-new-versions: 5
733 * tab-width: 4
734 * End:
735 */
![[bottom]](../icons/n_bottom.png){kind=icon}
*/