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