![[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 / linux / src / drivers / net|
Return to atp.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net |
1.1 root 1: /* atp.c: Attached (pocket) ethernet adapter driver for linux. */
2: /*
3: This is a driver for commonly OEMed pocket (parallel port)
4: ethernet adapters based on the Realtek RTL8002 and RTL8012 chips.
5:
6: Written 1993-95,1997 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.08 4/1/97 Donald Becker ([email protected])\n";
23:
24: /* Operational parameters that may be safely changed. */
25: /* Time in jiffies before concluding the transmitter is hung. */
26: #define TX_TIMEOUT ((400*HZ)/1000)
27:
28: /*
29: This file is a device driver for the RealTek (aka AT-Lan-Tec) pocket
30: ethernet adapter. This is a common low-cost OEM pocket ethernet
31: adapter, sold under many names.
32:
33: Sources:
34: This driver was written from the packet driver assembly code provided by
35: Vincent Bono of AT-Lan-Tec. Ever try to figure out how a complicated
36: device works just from the assembly code? It ain't pretty. The following
37: description is written based on guesses and writing lots of special-purpose
38: code to test my theorized operation.
39:
40: In 1997 Realtek made available the documentation for the second generation
41: RTL8012 chip, which has lead to several driver improvements.
42: http://www.realtek.com.tw/cn/cn.html
43:
44: Theory of Operation
45:
46: The RTL8002 adapter seems to be built around a custom spin of the SEEQ
47: controller core. It probably has a 16K or 64K internal packet buffer, of
48: which the first 4K is devoted to transmit and the rest to receive.
49: The controller maintains the queue of received packet and the packet buffer
50: access pointer internally, with only 'reset to beginning' and 'skip to next
51: packet' commands visible. The transmit packet queue holds two (or more?)
52: packets: both 'retransmit this packet' (due to collision) and 'transmit next
53: packet' commands must be started by hand.
54:
55: The station address is stored in a standard bit-serial EEPROM which must be
56: read (ughh) by the device driver. (Provisions have been made for
57: substituting a 74S288 PROM, but I haven't gotten reports of any models
58: using it.) Unlike built-in devices, a pocket adapter can temporarily lose
59: power without indication to the device driver. The major effect is that
60: the station address, receive filter (promiscuous, etc.) and transceiver
61: must be reset.
62:
63: The controller itself has 16 registers, some of which use only the lower
64: bits. The registers are read and written 4 bits at a time. The four bit
65: register address is presented on the data lines along with a few additional
66: timing and control bits. The data is then read from status port or written
67: to the data port.
68:
69: Correction: the controller has two banks of 16 registers. The second
70: bank contains only the multicast filter table (now used) and the EEPROM
71: access registers.
72:
73: Since the bulk data transfer of the actual packets through the slow
74: parallel port dominates the driver's running time, four distinct data
75: (non-register) transfer modes are provided by the adapter, two in each
76: direction. In the first mode timing for the nibble transfers is
77: provided through the data port. In the second mode the same timing is
78: provided through the control port. In either case the data is read from
79: the status port and written to the data port, just as it is accessing
80: registers.
81:
82: In addition to the basic data transfer methods, several more are modes are
83: created by adding some delay by doing multiple reads of the data to allow
84: it to stabilize. This delay seems to be needed on most machines.
85:
86: The data transfer mode is stored in the 'dev->if_port' field. Its default
87: value is '4'. It may be overridden at boot-time using the third parameter
88: to the "ether=..." initialization.
89:
90: The header file <atp.h> provides inline functions that encapsulate the
91: register and data access methods. These functions are hand-tuned to
92: generate reasonable object code. This header file also documents my
93: interpretations of the device registers.
94: */
95: #include <linux/config.h>
96: #ifdef MODULE
97: #include <linux/module.h>
98: #include <linux/version.h>
99: #else
100: #define MOD_INC_USE_COUNT
101: #define MOD_DEC_USE_COUNT
102: #endif
103:
104: #include <linux/kernel.h>
105: #include <linux/sched.h>
106: #include <linux/types.h>
107: #include <linux/fcntl.h>
108: #include <linux/interrupt.h>
109: #include <linux/ptrace.h>
110: #include <linux/ioport.h>
111: #include <linux/in.h>
112: #include <linux/malloc.h>
113: #include <linux/string.h>
114: #include <asm/system.h>
115: #include <asm/bitops.h>
116: #include <asm/io.h>
117: #include <asm/dma.h>
118: #include <linux/errno.h>
119:
120: #include <linux/netdevice.h>
121: #include <linux/etherdevice.h>
122: #include <linux/skbuff.h>
123:
124: #include "atp.h"
125:
126: /* Kernel compatibility defines, common to David Hind's PCMCIA package.
127: This is only in the support-all-kernels source code. */
128: #include <linux/version.h> /* Evil, but neccessary */
129:
130: #if defined (LINUX_VERSION_CODE) && LINUX_VERSION_CODE < 0x10300
131: #define RUN_AT(x) (x) /* What to put in timer->expires. */
132: #define DEV_ALLOC_SKB(len) alloc_skb(len, GFP_ATOMIC)
133: #define virt_to_bus(addr) ((unsigned long)addr)
134: #define bus_to_virt(addr) ((void*)addr)
135:
136: #else /* 1.3.0 and later */
137: #define RUN_AT(x) (jiffies + (x))
138: #define DEV_ALLOC_SKB(len) dev_alloc_skb(len + 2)
139: #endif
140: #if defined (LINUX_VERSION_CODE) && LINUX_VERSION_CODE < 0x10338
141: #ifdef MODULE
142: #if !defined(CONFIG_MODVERSIONS) && !defined(__NO_VERSION__)
143: char kernel_version[] = UTS_RELEASE;
144: #endif
145: #else
146: #undef MOD_INC_USE_COUNT
147: #define MOD_INC_USE_COUNT
148: #undef MOD_DEC_USE_COUNT
149: #define MOD_DEC_USE_COUNT
150: #endif
151: #endif /* 1.3.38 */
152:
153: #if (LINUX_VERSION_CODE >= 0x10344)
154: #define NEW_MULTICAST
155: #include <linux/delay.h>
156: #endif
157:
158: #ifdef SA_SHIRQ
159: #define FREE_IRQ(irqnum, dev) free_irq(irqnum, dev)
160: #define REQUEST_IRQ(i,h,f,n, instance) request_irq(i,h,f,n, instance)
161: #define IRQ(irq, dev_id, pt_regs) (irq, dev_id, pt_regs)
162: #else
163: #define FREE_IRQ(irqnum, dev) free_irq(irqnum)
164: #define REQUEST_IRQ(i,h,f,n, instance) request_irq(i,h,f,n)
165: #define IRQ(irq, dev_id, pt_regs) (irq, pt_regs)
166: #endif
167: /* End of kernel compatibility defines. */
168:
169: /* use 0 for production, 1 for verification, >2 for debug */
170: #ifndef NET_DEBUG
171: #define NET_DEBUG 1
172: #endif
173: static unsigned int net_debug = NET_DEBUG;
174:
175: /* The number of low I/O ports used by the ethercard. */
176: #define ETHERCARD_TOTAL_SIZE 3
177:
178: /* Sequence to switch an 8012 from printer mux to ethernet mode. */
179: static char mux_8012[] = { 0xff, 0xf7, 0xff, 0xfb, 0xf3, 0xfb, 0xff, 0xf7,};
180:
181: /* This code, written by [email protected], resets the adapter every
182: TIMED_CHECKER ticks. This recovers from an unknown error which
183: hangs the device. */
184: #define TIMED_CHECKER (HZ/4)
185: #ifdef TIMED_CHECKER
186: #include <linux/timer.h>
187: static void atp_timed_checker(unsigned long ignored);
188: #endif
189:
190: /* Index to functions, as function prototypes. */
191:
192: extern int atp_init(struct device *dev);
193:
194: static int atp_probe1(struct device *dev, short ioaddr);
195: static void get_node_ID(struct device *dev);
196: static unsigned short eeprom_op(short ioaddr, unsigned int cmd);
197: static int net_open(struct device *dev);
198: static void hardware_init(struct device *dev);
199: static void write_packet(short ioaddr, int length, unsigned char *packet, int mode);
200: static void trigger_send(short ioaddr, int length);
201: static int net_send_packet(struct sk_buff *skb, struct device *dev);
202: static void net_interrupt IRQ(int irq, void *dev_id, struct pt_regs *regs);
203: static void net_rx(struct device *dev);
204: static void read_block(short ioaddr, int length, unsigned char *buffer, int data_mode);
205: static int net_close(struct device *dev);
206: static struct enet_statistics *net_get_stats(struct device *dev);
207: #ifdef NEW_MULTICAST
208: static void set_rx_mode_8002(struct device *dev);
209: static void set_rx_mode_8012(struct device *dev);
210: #else
211: static void set_rx_mode_8002(struct device *dev, int num_addrs, void *addrs);
212: static void set_rx_mode_8012(struct device *dev, int num_addrs, void *addrs);
213: #endif
214:
215:
216: /* A list of all installed ATP devices, for removing the driver module. */
217: static struct device *root_atp_dev = NULL;
218:
219: /* Check for a network adapter of this type, and return '0' iff one exists.
220: If dev->base_addr == 0, probe all likely locations.
221: If dev->base_addr == 1, always return failure.
222: If dev->base_addr == 2, allocate space for the device and return success
223: (detachable devices only).
224: */
225: int
226: atp_init(struct device *dev)
227: {
228: int *port, ports[] = {0x378, 0x278, 0x3bc, 0};
229: int base_addr = dev ? dev->base_addr : 0;
230:
231: if (base_addr > 0x1ff) /* Check a single specified location. */
232: return atp_probe1(dev, base_addr);
233: else if (base_addr == 1) /* Don't probe at all. */
234: return ENXIO;
235:
236: for (port = ports; *port; port++) {
237: int ioaddr = *port;
238: outb(0x57, ioaddr + PAR_DATA);
239: if (inb(ioaddr + PAR_DATA) != 0x57)
240: continue;
241: if (atp_probe1(dev, ioaddr) == 0)
242: return 0;
243: }
244:
245: return ENODEV;
246: }
247:
248: static int atp_probe1(struct device *dev, short ioaddr)
249: {
250: struct net_local *lp;
251: int saved_ctrl_reg, status, i;
252:
253: outb(0xff, ioaddr + PAR_DATA);
254: /* Save the original value of the Control register, in case we guessed
255: wrong. */
256: saved_ctrl_reg = inb(ioaddr + PAR_CONTROL);
257: /* IRQEN=0, SLCTB=high INITB=high, AUTOFDB=high, STBB=high. */
258: outb(0x04, ioaddr + PAR_CONTROL);
259: /* Turn off the printer multiplexer on the 8012. */
260: for (i = 0; i < 8; i++)
261: outb(mux_8012[i], ioaddr + PAR_DATA);
262: write_reg_high(ioaddr, CMR1, CMR1h_RESET);
263: eeprom_delay(2048);
264: status = read_nibble(ioaddr, CMR1);
265:
266: if ((status & 0x78) != 0x08) {
267: /* The pocket adapter probe failed, restore the control register. */
268: outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
269: return 1;
270: }
271: status = read_nibble(ioaddr, CMR2_h);
272: if ((status & 0x78) != 0x10) {
273: outb(saved_ctrl_reg, ioaddr + PAR_CONTROL);
274: return 1;
275: }
276:
277: dev = init_etherdev(dev, sizeof(struct net_local));
278:
279: /* Find the IRQ used by triggering an interrupt. */
280: write_reg_byte(ioaddr, CMR2, 0x01); /* No accept mode, IRQ out. */
281: write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE); /* Enable Tx and Rx. */
282:
283: /* Omit autoIRQ routine for now. Use "table lookup" instead. Uhgggh. */
284: if (ioaddr == 0x378)
285: dev->irq = 7;
286: else
287: dev->irq = 5;
288: write_reg_high(ioaddr, CMR1, CMR1h_TxRxOFF); /* Disable Tx and Rx units. */
289: write_reg(ioaddr, CMR2, CMR2_NULL);
290:
291: dev->base_addr = ioaddr;
292:
293: /* Read the station address PROM. */
294: get_node_ID(dev);
295:
296: printk("%s: Pocket adapter found at %#3lx, IRQ %d, SAPROM "
297: "%02X:%02X:%02X:%02X:%02X:%02X.\n", dev->name, dev->base_addr,
298: dev->irq, dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
299: dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
300:
301: /* Reset the ethernet hardware and activate the printer pass-through. */
302: write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
303:
304: if (net_debug)
305: printk(version);
306:
307: /* Initialize the device structure. */
308: ether_setup(dev);
309: if (dev->priv == NULL)
310: dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
311: if (dev->priv == NULL)
312: return -ENOMEM;
313: memset(dev->priv, 0, sizeof(struct net_local));
314:
315: lp = (struct net_local *)dev->priv;
316: lp->chip_type = RTL8002;
317: lp->addr_mode = CMR2h_Normal;
318:
319: lp->next_module = root_atp_dev;
320: root_atp_dev = dev;
321:
322: /* For the ATP adapter the "if_port" is really the data transfer mode. */
323: dev->if_port = (dev->mem_start & 0xf) ? (dev->mem_start & 0x7) : 4;
324: if (dev->mem_end & 0xf)
325: net_debug = dev->mem_end & 7;
326:
327: dev->open = net_open;
328: dev->stop = net_close;
329: dev->hard_start_xmit = net_send_packet;
330: dev->get_stats = net_get_stats;
331: dev->set_multicast_list =
332: lp->chip_type == RTL8002 ? &set_rx_mode_8002 : &set_rx_mode_8012;
333:
334: return 0;
335: }
336:
337: /* Read the station address PROM, usually a word-wide EEPROM. */
338: static void get_node_ID(struct device *dev)
339: {
340: short ioaddr = dev->base_addr;
341: int sa_offset = 0;
342: int i;
343:
344: write_reg(ioaddr, CMR2, CMR2_EEPROM); /* Point to the EEPROM control registers. */
345:
346: /* Some adapters have the station address at offset 15 instead of offset
347: zero. Check for it, and fix it if needed. */
348: if (eeprom_op(ioaddr, EE_READ(0)) == 0xffff)
349: sa_offset = 15;
350:
351: for (i = 0; i < 3; i++)
352: ((unsigned short *)dev->dev_addr)[i] =
353: ntohs(eeprom_op(ioaddr, EE_READ(sa_offset + i)));
354:
355: write_reg(ioaddr, CMR2, CMR2_NULL);
356: }
357:
358: /*
359: An EEPROM read command starts by shifting out 0x60+address, and then
360: shifting in the serial data. See the NatSemi databook for details.
361: * ________________
362: * CS : __|
363: * ___ ___
364: * CLK: ______| |___| |
365: * __ _______ _______
366: * DI : __X_______X_______X
367: * DO : _________X_______X
368: */
369:
370: static unsigned short eeprom_op(short ioaddr, unsigned int cmd)
371: {
372: unsigned eedata_out = 0;
373: int num_bits = EE_CMD_SIZE;
374:
375: while (--num_bits >= 0) {
376: char outval = test_bit(num_bits, &cmd) ? EE_DATA_WRITE : 0;
377: write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_LOW);
378: eeprom_delay(5);
379: write_reg_high(ioaddr, PROM_CMD, outval | EE_CLK_HIGH);
380: eedata_out <<= 1;
381: if (read_nibble(ioaddr, PROM_DATA) & EE_DATA_READ)
382: eedata_out++;
383: eeprom_delay(5);
384: }
385: write_reg_high(ioaddr, PROM_CMD, EE_CLK_LOW & ~EE_CS);
386: return eedata_out;
387: }
388:
389:
390: /* Open/initialize the board. This is called (in the current kernel)
391: sometime after booting when the 'ifconfig' program is run.
392:
393: This routine sets everything up anew at each open, even
394: registers that "should" only need to be set once at boot, so that
395: there is non-reboot way to recover if something goes wrong.
396:
397: This is an attachable device: if there is no dev->priv entry then it wasn't
398: probed for at boot-time, and we need to probe for it again.
399: */
400: static int net_open(struct device *dev)
401: {
402: struct net_local *lp = (struct net_local *)dev->priv;
403:
404: /* The interrupt line is turned off (tri-stated) when the device isn't in
405: use. That's especially important for "attached" interfaces where the
406: port or interrupt may be shared. */
407: #ifndef SA_SHIRQ
408: if (irq2dev_map[dev->irq] != 0
409: || (irq2dev_map[dev->irq] = dev) == 0
410: || REQUEST_IRQ(dev->irq, &net_interrupt, 0, "ATP", dev)) {
411: return -EAGAIN;
412: }
413: #else
414: if (request_irq(dev->irq, &net_interrupt, 0, "ATP Ethernet", dev))
415: return -EAGAIN;
416: #endif
417:
418: MOD_INC_USE_COUNT;
419: hardware_init(dev);
420: dev->start = 1;
421:
422: init_timer(&lp->timer);
423: lp->timer.expires = RUN_AT(TIMED_CHECKER);
424: lp->timer.data = (unsigned long)dev;
425: lp->timer.function = &atp_timed_checker; /* timer handler */
426: add_timer(&lp->timer);
427:
428: return 0;
429: }
430:
431: /* This routine resets the hardware. We initialize everything, assuming that
432: the hardware may have been temporarily detached. */
433: static void hardware_init(struct device *dev)
434: {
435: struct net_local *lp = (struct net_local *)dev->priv;
436: int ioaddr = dev->base_addr;
437: int i;
438:
439: /* Turn off the printer multiplexer on the 8012. */
440: for (i = 0; i < 8; i++)
441: outb(mux_8012[i], ioaddr + PAR_DATA);
442: write_reg_high(ioaddr, CMR1, CMR1h_RESET);
443:
444: for (i = 0; i < 6; i++)
445: write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
446:
447: write_reg_high(ioaddr, CMR2, lp->addr_mode);
448:
449: if (net_debug > 2) {
450: printk("%s: Reset: current Rx mode %d.\n", dev->name,
451: (read_nibble(ioaddr, CMR2_h) >> 3) & 0x0f);
452: }
453:
454: write_reg(ioaddr, CMR2, CMR2_IRQOUT);
455: write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
456:
457: /* Enable the interrupt line from the serial port. */
458: outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
459:
460: /* Unmask the interesting interrupts. */
461: write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
462: write_reg_high(ioaddr, IMR, ISRh_RxErr);
463:
464: lp->tx_unit_busy = 0;
465: lp->pac_cnt_in_tx_buf = 0;
466: lp->saved_tx_size = 0;
467:
468: dev->tbusy = 0;
469: dev->interrupt = 0;
470: }
471:
472: static void trigger_send(short ioaddr, int length)
473: {
474: write_reg_byte(ioaddr, TxCNT0, length & 0xff);
475: write_reg(ioaddr, TxCNT1, length >> 8);
476: write_reg(ioaddr, CMR1, CMR1_Xmit);
477: }
478:
479: static void write_packet(short ioaddr, int length, unsigned char *packet, int data_mode)
480: {
481: length = (length + 1) & ~1; /* Round up to word length. */
482: outb(EOC+MAR, ioaddr + PAR_DATA);
483: if ((data_mode & 1) == 0) {
484: /* Write the packet out, starting with the write addr. */
485: outb(WrAddr+MAR, ioaddr + PAR_DATA);
486: do {
487: write_byte_mode0(ioaddr, *packet++);
488: } while (--length > 0) ;
489: } else {
490: /* Write the packet out in slow mode. */
491: unsigned char outbyte = *packet++;
492:
493: outb(Ctrl_LNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
494: outb(WrAddr+MAR, ioaddr + PAR_DATA);
495:
496: outb((outbyte & 0x0f)|0x40, ioaddr + PAR_DATA);
497: outb(outbyte & 0x0f, ioaddr + PAR_DATA);
498: outbyte >>= 4;
499: outb(outbyte & 0x0f, ioaddr + PAR_DATA);
500: outb(Ctrl_HNibWrite + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
501: while (--length > 0)
502: write_byte_mode1(ioaddr, *packet++);
503: }
504: /* Terminate the Tx frame. End of write: ECB. */
505: outb(0xff, ioaddr + PAR_DATA);
506: outb(Ctrl_HNibWrite | Ctrl_SelData | Ctrl_IRQEN, ioaddr + PAR_CONTROL);
507: }
508:
509: static int
510: net_send_packet(struct sk_buff *skb, struct device *dev)
511: {
512: struct net_local *lp = (struct net_local *)dev->priv;
513: int ioaddr = dev->base_addr;
514:
515: #ifndef final_version
516: if (skb == NULL || skb->len <= 0) {
517: printk("%s: Obsolete driver layer request made: skbuff==NULL.\n",
518: dev->name);
519: dev_tint(dev);
520: return 0;
521: }
522: #endif
523:
524: /* Use transmit-while-tbusy as a crude error timer. */
525: if (set_bit(0, (void*)&dev->tbusy) != 0) {
526: if (jiffies - dev->trans_start < TX_TIMEOUT)
527: return 1;
528: printk("%s: transmit timed out, %s?\n", dev->name,
529: inb(ioaddr + PAR_CONTROL) & 0x10 ? "network cable problem"
530: : "IRQ conflict");
531: lp->stats.tx_errors++;
532: /* Try to restart the adapter. */
533: hardware_init(dev);
534: dev->tbusy=0;
535: dev->trans_start = jiffies;
536: return 1;
537: } else {
538: short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
539: unsigned char *buf = skb->data;
540: int flags;
541:
542: /* Disable interrupts by writing 0x00 to the Interrupt Mask Register.
543: This sequence must not be interrupted by an incoming packet. */
544: save_flags(flags);
545: cli();
546: write_reg(ioaddr, IMR, 0);
547: write_reg_high(ioaddr, IMR, 0);
548: restore_flags(flags);
549:
550: write_packet(ioaddr, length, buf, dev->if_port);
551:
552: lp->pac_cnt_in_tx_buf++;
553: if (lp->tx_unit_busy == 0) {
554: trigger_send(ioaddr, length);
555: lp->saved_tx_size = 0; /* Redundant */
556: lp->re_tx = 0;
557: lp->tx_unit_busy = 1;
558: } else
559: lp->saved_tx_size = length;
560:
561: dev->trans_start = jiffies;
562: /* Re-enable the LPT interrupts. */
563: write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
564: write_reg_high(ioaddr, IMR, ISRh_RxErr);
565: }
566:
567: dev_kfree_skb (skb, FREE_WRITE);
568:
569: return 0;
570: }
571:
572: /* The typical workload of the driver:
573: Handle the network interface interrupts. */
574: static void
575: net_interrupt IRQ(int irq, void *dev_instance, struct pt_regs * regs)
576: {
577: #ifdef SA_SHIRQ
578: struct device *dev = (struct device *)dev_instance;
579: #else
580: struct device *dev = (struct device *)(irq2dev_map[irq]);
581: #endif
582: struct net_local *lp;
583: int ioaddr, status, boguscount = 20;
584: static int num_tx_since_rx = 0;
585:
586: if (dev == NULL) {
587: printk ("ATP_interrupt(): irq %d for unknown device.\n", irq);
588: return;
589: }
590: dev->interrupt = 1;
591:
592: ioaddr = dev->base_addr;
593: lp = (struct net_local *)dev->priv;
594:
595: /* Disable additional spurious interrupts. */
596: outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
597:
598: /* The adapter's output is currently the IRQ line, switch it to data. */
599: write_reg(ioaddr, CMR2, CMR2_NULL);
600: write_reg(ioaddr, IMR, 0);
601:
602: if (net_debug > 5) printk("%s: In interrupt ", dev->name);
603: while (--boguscount > 0) {
604: status = read_nibble(ioaddr, ISR);
605: if (net_debug > 5) printk("loop status %02x..", status);
606:
607: if (status & (ISR_RxOK<<3)) {
608: write_reg(ioaddr, ISR, ISR_RxOK); /* Clear the Rx interrupt. */
609: do {
610: int read_status = read_nibble(ioaddr, CMR1);
611: if (net_debug > 6)
612: printk("handling Rx packet %02x..", read_status);
613: /* We acknowledged the normal Rx interrupt, so if the interrupt
614: is still outstanding we must have a Rx error. */
615: if (read_status & (CMR1_IRQ << 3)) { /* Overrun. */
616: lp->stats.rx_over_errors++;
617: /* Set to no-accept mode long enough to remove a packet. */
618: write_reg_high(ioaddr, CMR2, CMR2h_OFF);
619: net_rx(dev);
620: /* Clear the interrupt and return to normal Rx mode. */
621: write_reg_high(ioaddr, ISR, ISRh_RxErr);
622: write_reg_high(ioaddr, CMR2, lp->addr_mode);
623: } else if ((read_status & (CMR1_BufEnb << 3)) == 0) {
624: net_rx(dev);
625: dev->last_rx = jiffies;
626: num_tx_since_rx = 0;
627: } else
628: break;
629: } while (--boguscount > 0);
630: } else if (status & ((ISR_TxErr + ISR_TxOK)<<3)) {
631: if (net_debug > 6) printk("handling Tx done..");
632: /* Clear the Tx interrupt. We should check for too many failures
633: and reinitialize the adapter. */
634: write_reg(ioaddr, ISR, ISR_TxErr + ISR_TxOK);
635: if (status & (ISR_TxErr<<3)) {
636: lp->stats.collisions++;
637: if (++lp->re_tx > 15) {
638: lp->stats.tx_aborted_errors++;
639: hardware_init(dev);
640: break;
641: }
642: /* Attempt to retransmit. */
643: if (net_debug > 6) printk("attempting to ReTx");
644: write_reg(ioaddr, CMR1, CMR1_ReXmit + CMR1_Xmit);
645: } else {
646: /* Finish up the transmit. */
647: lp->stats.tx_packets++;
648: lp->pac_cnt_in_tx_buf--;
649: if ( lp->saved_tx_size) {
650: trigger_send(ioaddr, lp->saved_tx_size);
651: lp->saved_tx_size = 0;
652: lp->re_tx = 0;
653: } else
654: lp->tx_unit_busy = 0;
655: dev->tbusy = 0;
656: mark_bh(NET_BH); /* Inform upper layers. */
657: }
658: num_tx_since_rx++;
659: } else if (num_tx_since_rx > 8
660: && jiffies > dev->last_rx + 100) {
661: if (net_debug > 2)
662: printk("%s: Missed packet? No Rx after %d Tx and %ld jiffies"
663: " status %02x CMR1 %02x.\n", dev->name,
664: num_tx_since_rx, jiffies - dev->last_rx, status,
665: (read_nibble(ioaddr, CMR1) >> 3) & 15);
666: lp->stats.rx_missed_errors++;
667: hardware_init(dev);
668: num_tx_since_rx = 0;
669: break;
670: } else
671: break;
672: }
673:
674: /* This following code fixes a rare (and very difficult to track down)
675: problem where the adapter forgets its ethernet address. */
676: {
677: int i;
678: for (i = 0; i < 6; i++)
679: write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
680: }
681:
682: /* Tell the adapter that it can go back to using the output line as IRQ. */
683: write_reg(ioaddr, CMR2, CMR2_IRQOUT);
684: /* Enable the physical interrupt line, which is sure to be low until.. */
685: outb(Ctrl_SelData + Ctrl_IRQEN, ioaddr + PAR_CONTROL);
686: /* .. we enable the interrupt sources. */
687: write_reg(ioaddr, IMR, ISR_RxOK | ISR_TxErr | ISR_TxOK);
688: write_reg_high(ioaddr, IMR, ISRh_RxErr); /* Hmmm, really needed? */
689:
690: if (net_debug > 5) printk("exiting interrupt.\n");
691:
692: dev->interrupt = 0;
693:
694: return;
695: }
696:
697: #ifdef TIMED_CHECKER
698: /* This following code fixes a rare (and very difficult to track down)
699: problem where the adapter forgets its ethernet address. */
700: static void atp_timed_checker(unsigned long data)
701: {
702: struct device *dev = (struct device *)data;
703: int ioaddr = dev->base_addr;
704: struct net_local *lp = (struct net_local *)dev->priv;
705: int tickssofar = jiffies - lp->last_rx_time;
706: int i;
707:
708: if (tickssofar > 2*HZ && dev->interrupt == 0) {
709: #if 1
710: for (i = 0; i < 6; i++)
711: write_reg_byte(ioaddr, PAR0 + i, dev->dev_addr[i]);
712: lp->last_rx_time = jiffies;
713: #else
714: for (i = 0; i < 6; i++)
715: if (read_cmd_byte(ioaddr, PAR0 + i) != atp_timed_dev->dev_addr[i])
716: {
717: struct net_local *lp = (struct net_local *)atp_timed_dev->priv;
718: write_reg_byte(ioaddr, PAR0 + i, atp_timed_dev->dev_addr[i]);
719: if (i == 2)
720: lp->stats.tx_errors++;
721: else if (i == 3)
722: lp->stats.tx_dropped++;
723: else if (i == 4)
724: lp->stats.collisions++;
725: else
726: lp->stats.rx_errors++;
727: }
728: #endif
729: }
730: lp->timer.expires = RUN_AT(TIMED_CHECKER);
731: add_timer(&lp->timer);
732: }
733: #endif
734:
735: /* We have a good packet(s), get it/them out of the buffers. */
736: static void net_rx(struct device *dev)
737: {
738: struct net_local *lp = (struct net_local *)dev->priv;
739: int ioaddr = dev->base_addr;
740: struct rx_header rx_head;
741:
742: /* Process the received packet. */
743: outb(EOC+MAR, ioaddr + PAR_DATA);
744: read_block(ioaddr, 8, (unsigned char*)&rx_head, dev->if_port);
745: if (net_debug > 5)
746: printk(" rx_count %04x %04x %04x %04x..", rx_head.pad,
747: rx_head.rx_count, rx_head.rx_status, rx_head.cur_addr);
748: if ((rx_head.rx_status & 0x77) != 0x01) {
749: lp->stats.rx_errors++;
750: if (rx_head.rx_status & 0x0004) lp->stats.rx_frame_errors++;
751: else if (rx_head.rx_status & 0x0002) lp->stats.rx_crc_errors++;
752: if (net_debug > 3) printk("%s: Unknown ATP Rx error %04x.\n",
753: dev->name, rx_head.rx_status);
754: if (rx_head.rx_status & 0x0020) {
755: lp->stats.rx_fifo_errors++;
756: write_reg_high(ioaddr, CMR1, CMR1h_TxENABLE);
757: write_reg_high(ioaddr, CMR1, CMR1h_RxENABLE | CMR1h_TxENABLE);
758: } else if (rx_head.rx_status & 0x0050)
759: hardware_init(dev);
760: return;
761: } else {
762: /* Malloc up new buffer. The "-4" is omits the FCS (CRC). */
763: int pkt_len = (rx_head.rx_count & 0x7ff) - 4;
764: struct sk_buff *skb;
765:
766: skb = DEV_ALLOC_SKB(pkt_len + 2);
767: if (skb == NULL) {
768: printk("%s: Memory squeeze, dropping packet.\n", dev->name);
769: lp->stats.rx_dropped++;
770: goto done;
771: }
772: skb->dev = dev;
773:
774: #if LINUX_VERSION_CODE >= 0x10300
775: skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
776: read_block(ioaddr, pkt_len, skb_put(skb,pkt_len), dev->if_port);
777: skb->protocol = eth_type_trans(skb, dev);
778: #else
779: read_block(ioaddr, pkt_len, skb->data, dev->if_port);
780: skb->len = pkt_len;
781: #endif
782: netif_rx(skb);
783: lp->stats.rx_packets++;
784: }
785: done:
786: write_reg(ioaddr, CMR1, CMR1_NextPkt);
787: lp->last_rx_time = jiffies;
788: return;
789: }
790:
791: static void read_block(short ioaddr, int length, unsigned char *p, int data_mode)
792: {
793:
794: if (data_mode <= 3) { /* Mode 0 or 1 */
795: outb(Ctrl_LNibRead, ioaddr + PAR_CONTROL);
796: outb(length == 8 ? RdAddr | HNib | MAR : RdAddr | MAR,
797: ioaddr + PAR_DATA);
798: if (data_mode <= 1) { /* Mode 0 or 1 */
799: do *p++ = read_byte_mode0(ioaddr); while (--length > 0);
800: } else /* Mode 2 or 3 */
801: do *p++ = read_byte_mode2(ioaddr); while (--length > 0);
802: } else if (data_mode <= 5)
803: do *p++ = read_byte_mode4(ioaddr); while (--length > 0);
804: else
805: do *p++ = read_byte_mode6(ioaddr); while (--length > 0);
806:
807: outb(EOC+HNib+MAR, ioaddr + PAR_DATA);
808: outb(Ctrl_SelData, ioaddr + PAR_CONTROL);
809: }
810:
811: /* The inverse routine to net_open(). */
812: static int
813: net_close(struct device *dev)
814: {
815: struct net_local *lp = (struct net_local *)dev->priv;
816: int ioaddr = dev->base_addr;
817:
818: dev->tbusy = 1;
819: dev->start = 0;
820:
821: del_timer(&lp->timer);
822:
823: /* Flush the Tx and disable Rx here. */
824: lp->addr_mode = CMR2h_OFF;
825: write_reg_high(ioaddr, CMR2, CMR2h_OFF);
826:
827: /* Free the IRQ line. */
828: outb(0x00, ioaddr + PAR_CONTROL);
829: FREE_IRQ(dev->irq, dev);
830: #ifndef SA_SHIRQ
831: irq2dev_map[dev->irq] = 0;
832: #endif
833:
834: /* Reset the ethernet hardware and activate the printer pass-through. */
835: write_reg_high(ioaddr, CMR1, CMR1h_RESET | CMR1h_MUX);
836:
837: MOD_DEC_USE_COUNT;
838:
839: return 0;
840: }
841:
842: /* Get the current statistics. This may be called with the card open or
843: closed. */
844: static struct enet_statistics *
845: net_get_stats(struct device *dev)
846: {
847: struct net_local *lp = (struct net_local *)dev->priv;
848: return &lp->stats;
849: }
850:
851: /*
852: * Set or clear the multicast filter for this adapter.
853: */
854:
855: /* The little-endian AUTODIN32 ethernet CRC calculation.
856: This is common code and should be moved to net/core/crc.c */
857: static unsigned const ethernet_polynomial_le = 0xedb88320U;
858: static inline unsigned ether_crc_le(int length, unsigned char *data)
859: {
860: unsigned int crc = 0xffffffff; /* Initial value. */
861: while(--length >= 0) {
862: unsigned char current_octet = *data++;
863: int bit;
864: for (bit = 8; --bit >= 0; current_octet >>= 1) {
865: if ((crc ^ current_octet) & 1) {
866: crc >>= 1;
867: crc ^= ethernet_polynomial_le;
868: } else
869: crc >>= 1;
870: }
871: }
872: return crc;
873: }
874:
875: static void
876: #ifdef NEW_MULTICAST
877: set_rx_mode_8002(struct device *dev)
878: #else
879: static void set_rx_mode_8002(struct device *dev, int num_addrs, void *addrs);
880: #endif
881: {
882: struct net_local *lp = (struct net_local *)dev->priv;
883: short ioaddr = dev->base_addr;
884:
885: if ( dev->mc_count > 0 || (dev->flags & (IFF_ALLMULTI|IFF_PROMISC))) {
886: /* We must make the kernel realise we had to move
887: * into promisc mode or we start all out war on
888: * the cable. - AC
889: */
890: dev->flags|=IFF_PROMISC;
891: lp->addr_mode = CMR2h_PROMISC;
892: } else
893: lp->addr_mode = CMR2h_Normal;
894: write_reg_high(ioaddr, CMR2, lp->addr_mode);
895: }
896:
897: static void
898: #ifdef NEW_MULTICAST
899: set_rx_mode_8012(struct device *dev)
900: #else
901: static void set_rx_mode_8012(struct device *dev, int num_addrs, void *addrs);
902: #endif
903: {
904: struct net_local *lp = (struct net_local *)dev->priv;
905: short ioaddr = dev->base_addr;
906: unsigned char new_mode, mc_filter[8]; /* Multicast hash filter */
907: int i;
908:
909: if (dev->flags & IFF_PROMISC) { /* Set promiscuous. */
910: new_mode = CMR2h_PROMISC;
911: } else if ((dev->mc_count > 1000) || (dev->flags & IFF_ALLMULTI)) {
912: /* Too many to filter perfectly -- accept all multicasts. */
913: memset(mc_filter, 0xff, sizeof(mc_filter));
914: new_mode = CMR2h_Normal;
915: } else {
916: struct dev_mc_list *mclist;
917:
918: memset(mc_filter, 0, sizeof(mc_filter));
919: for (i = 0, mclist = dev->mc_list; mclist && i < dev->mc_count;
920: i++, mclist = mclist->next)
921: set_bit(ether_crc_le(ETH_ALEN, mclist->dmi_addr) & 0x3f,
922: mc_filter);
923: new_mode = CMR2h_Normal;
924: }
925: lp->addr_mode = new_mode;
926: write_reg(ioaddr, CMR2, CMR2_IRQOUT | 0x04); /* Switch to page 1. */
927: for (i = 0; i < 8; i++)
928: write_reg_byte(ioaddr, i, mc_filter[i]);
929: if (net_debug > 2 || 1) {
930: lp->addr_mode = 1;
931: printk("%s: Mode %d, setting multicast filter to",
932: dev->name, lp->addr_mode);
933: for (i = 0; i < 8; i++)
934: printk(" %2.2x", mc_filter[i]);
935: printk(".\n");
936: }
937:
938: write_reg_high(ioaddr, CMR2, lp->addr_mode);
939: write_reg(ioaddr, CMR2, CMR2_IRQOUT); /* Switch back to page 0 */
940: }
941:
942: #ifdef MODULE
943: static int debug = 1;
944: int
945: init_module(void)
946: {
947: net_debug = debug;
948: root_atp_dev = NULL;
949: atp_init(0);
950: return 0;
951: }
952:
953: void
954: cleanup_module(void)
955: {
956: struct device *next_dev;
957:
958: /* No need to check MOD_IN_USE, as sys_delete_module() checks. */
959: /* No need to release_region(), since we never snarf it. */
960: while (root_atp_dev) {
961: next_dev = ((struct net_local *)root_atp_dev->priv)->next_module;
962: unregister_netdev(root_atp_dev);
963: kfree(root_atp_dev);
964: root_atp_dev = next_dev;
965: }
966: }
967: #endif /* MODULE */
968:
969:
970: /*
971: * Local variables:
972: * compile-command: "gcc -DMODULE -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -c atp.c"
973: * version-control: t
974: * kept-new-versions: 5
975: * tab-width: 4
976: * End:
977: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.