![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to eepro.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 eepro.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / net |
1.1 root 1: /* eepro.c: Intel EtherExpress Pro/10 device driver for Linux. */
2: /*
3: Written 1994, 1995 by Bao C. Ha.
4:
5: Copyright (C) 1994, 1995 by Bao C. Ha.
6:
7: This software may be used and distributed
8: according to the terms of the GNU Public License,
9: incorporated herein by reference.
10:
11: The author may be reached at [email protected]
12: or 418 Hastings Place, Martinez, GA 30907.
13:
14: Things remaining to do:
15: Better record keeping of errors.
16: Eliminate transmit interrupt to reduce overhead.
17: Implement "concurrent processing". I won't be doing it!
18: Allow changes to the partition of the transmit and receive
19: buffers, currently the ratio is 3:1 of receive to transmit
20: buffer ratio.
21:
22: Bugs:
23:
24: If you have a problem of not detecting the 82595 during a
25: reboot (warm reset), disable the FLASH memory should fix it.
26: This is a compatibility hardware problem.
27:
28: Versions:
29:
30: 0.07a Fix a stat report which counts every packet as a
31: heart-beat failure. (BCH, 6/3/95)
32:
33: 0.07 Modified to support all other 82595-based lan cards.
34: The IRQ vector of the EtherExpress Pro will be set
35: according to the value saved in the EEPROM. For other
36: cards, I will do autoirq_request() to grab the next
37: available interrupt vector. (BCH, 3/17/95)
38:
39: 0.06a,b Interim released. Minor changes in the comments and
40: print out format. (BCH, 3/9/95 and 3/14/95)
41:
42: 0.06 First stable release that I am comfortable with. (BCH,
43: 3/2/95)
44:
45: 0.05 Complete testing of multicast. (BCH, 2/23/95)
46:
47: 0.04 Adding multicast support. (BCH, 2/14/95)
48:
49: 0.03 First widely alpha release for public testing.
50: (BCH, 2/14/95)
51:
52: */
53:
54: static const char *version =
55: "eepro.c: v0.07a 6/5/95 Bao C. Ha ([email protected])\n";
56:
57: #include <linux/module.h>
58:
59: /*
60: Sources:
61:
62: This driver wouldn't have been written without the availability
63: of the Crynwr's Lan595 driver source code. It helps me to
64: familiarize with the 82595 chipset while waiting for the Intel
65: documentation. I also learned how to detect the 82595 using
66: the packet driver's technique.
67:
68: This driver is written by cutting and pasting the skeleton.c driver
69: provided by Donald Becker. I also borrowed the EEPROM routine from
70: Donald Becker's 82586 driver.
71:
72: Datasheet for the Intel 82595. It provides just enough info that
73: the casual reader might think that it documents the i82595.
74:
75: The User Manual for the 82595. It provides a lot of the missing
76: information.
77:
78: */
79:
80: #include <linux/kernel.h>
81: #include <linux/sched.h>
82: #include <linux/types.h>
83: #include <linux/fcntl.h>
84: #include <linux/interrupt.h>
85: #include <linux/ptrace.h>
86: #include <linux/ioport.h>
87: #include <linux/in.h>
88: #include <linux/malloc.h>
89: #include <linux/string.h>
90: #include <asm/system.h>
91: #include <asm/bitops.h>
92: #include <asm/io.h>
93: #include <asm/dma.h>
94: #include <linux/errno.h>
95:
96: #include <linux/netdevice.h>
97: #include <linux/etherdevice.h>
98: #include <linux/skbuff.h>
99:
100:
101: /* First, a few definitions that the brave might change. */
102: /* A zero-terminated list of I/O addresses to be probed. */
103: static unsigned int eepro_portlist[] =
104: { 0x200, 0x240, 0x280, 0x2C0, 0x300, 0x320, 0x340, 0x360, 0};
105:
106: /* use 0 for production, 1 for verification, >2 for debug */
107: #ifndef NET_DEBUG
108: #define NET_DEBUG 2
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 EEPRO_IO_EXTENT 16
114:
115: /* Information that need to be kept for each board. */
116: struct eepro_local {
117: struct enet_statistics stats;
118: unsigned rx_start;
119: unsigned tx_start; /* start of the transmit chain */
120: int tx_last; /* pointer to last packet in the transmit chain */
121: unsigned tx_end; /* end of the transmit chain (plus 1) */
122: int eepro; /* a flag, TRUE=1 for the EtherExpress Pro/10,
123: FALSE = 0 for other 82595-based lan cards. */
124: };
125:
126: /* The station (ethernet) address prefix, used for IDing the board. */
127: #define SA_ADDR0 0x00
128: #define SA_ADDR1 0xaa
129: #define SA_ADDR2 0x00
130:
131: /* Index to functions, as function prototypes. */
132:
133: extern int eepro_probe(struct device *dev);
134:
135: static int eepro_probe1(struct device *dev, short ioaddr);
136: static int eepro_open(struct device *dev);
137: static int eepro_send_packet(struct sk_buff *skb, struct device *dev);
138: static void eepro_interrupt(int irq, struct pt_regs *regs);
139: static void eepro_rx(struct device *dev);
140: static void eepro_transmit_interrupt(struct device *dev);
141: static int eepro_close(struct device *dev);
142: static struct enet_statistics *eepro_get_stats(struct device *dev);
143: static void set_multicast_list(struct device *dev);
144:
145: static int read_eeprom(int ioaddr, int location);
146: static void hardware_send_packet(struct device *dev, void *buf, short length);
147: static int eepro_grab_irq(struct device *dev);
148:
149: /*
150: Details of the i82595.
151:
152: You will need either the datasheet or the user manual to understand what
153: is going on here. The 82595 is very different from the 82586, 82593.
154:
155: The receive algorithm in eepro_rx() is just an implementation of the
156: RCV ring structure that the Intel 82595 imposes at the hardware level.
157: The receive buffer is set at 24K, and the transmit buffer is 8K. I
158: am assuming that the total buffer memory is 32K, which is true for the
159: Intel EtherExpress Pro/10. If it is less than that on a generic card,
160: the driver will be broken.
161:
162: The transmit algorithm in the hardware_send_packet() is similar to the
163: one in the eepro_rx(). The transmit buffer is a ring linked list.
164: I just queue the next available packet to the end of the list. In my
165: system, the 82595 is so fast that the list seems to always contain a
166: single packet. In other systems with faster computers and more congested
167: network traffics, the ring linked list should improve performance by
168: allowing up to 8K worth of packets to be queued.
169:
170: */
171: #define RAM_SIZE 0x8000
172: #define RCV_HEADER 8
173: #define RCV_RAM 0x6000 /* 24KB for RCV buffer */
174: #define RCV_LOWER_LIMIT 0x00 /* 0x0000 */
175: #define RCV_UPPER_LIMIT ((RCV_RAM - 2) >> 8) /* 0x5ffe */
176: #define XMT_RAM (RAM_SIZE - RCV_RAM) /* 8KB for XMT buffer */
177: #define XMT_LOWER_LIMIT (RCV_RAM >> 8) /* 0x6000 */
178: #define XMT_UPPER_LIMIT ((RAM_SIZE - 2) >> 8) /* 0x7ffe */
179: #define XMT_HEADER 8
180:
181: #define RCV_DONE 0x0008
182: #define RX_OK 0x2000
183: #define RX_ERROR 0x0d81
184:
185: #define TX_DONE_BIT 0x0080
186: #define CHAIN_BIT 0x8000
187: #define XMT_STATUS 0x02
188: #define XMT_CHAIN 0x04
189: #define XMT_COUNT 0x06
190:
191: #define BANK0_SELECT 0x00
192: #define BANK1_SELECT 0x40
193: #define BANK2_SELECT 0x80
194:
195: /* Bank 0 registers */
196: #define COMMAND_REG 0x00 /* Register 0 */
197: #define MC_SETUP 0x03
198: #define XMT_CMD 0x04
199: #define DIAGNOSE_CMD 0x07
200: #define RCV_ENABLE_CMD 0x08
201: #define RCV_DISABLE_CMD 0x0a
202: #define STOP_RCV_CMD 0x0b
203: #define RESET_CMD 0x0e
204: #define POWER_DOWN_CMD 0x18
205: #define RESUME_XMT_CMD 0x1c
206: #define SEL_RESET_CMD 0x1e
207: #define STATUS_REG 0x01 /* Register 1 */
208: #define RX_INT 0x02
209: #define TX_INT 0x04
210: #define EXEC_STATUS 0x30
211: #define ID_REG 0x02 /* Register 2 */
212: #define R_ROBIN_BITS 0xc0 /* round robin counter */
213: #define ID_REG_MASK 0x2c
214: #define ID_REG_SIG 0x24
215: #define AUTO_ENABLE 0x10
216: #define INT_MASK_REG 0x03 /* Register 3 */
217: #define RX_STOP_MASK 0x01
218: #define RX_MASK 0x02
219: #define TX_MASK 0x04
220: #define EXEC_MASK 0x08
221: #define ALL_MASK 0x0f
222: #define RCV_BAR 0x04 /* The following are word (16-bit) registers */
223: #define RCV_STOP 0x06
224: #define XMT_BAR 0x0a
225: #define HOST_ADDRESS_REG 0x0c
226: #define IO_PORT 0x0e
227:
228: /* Bank 1 registers */
229: #define REG1 0x01
230: #define WORD_WIDTH 0x02
231: #define INT_ENABLE 0x80
232: #define INT_NO_REG 0x02
233: #define RCV_LOWER_LIMIT_REG 0x08
234: #define RCV_UPPER_LIMIT_REG 0x09
235: #define XMT_LOWER_LIMIT_REG 0x0a
236: #define XMT_UPPER_LIMIT_REG 0x0b
237:
238: /* Bank 2 registers */
239: #define XMT_Chain_Int 0x20 /* Interrupt at the end of the transmit chain */
240: #define XMT_Chain_ErrStop 0x40 /* Interrupt at the end of the chain even if there are errors */
241: #define RCV_Discard_BadFrame 0x80 /* Throw bad frames away, and continue to receive others */
242: #define REG2 0x02
243: #define PRMSC_Mode 0x01
244: #define Multi_IA 0x20
245: #define REG3 0x03
246: #define TPE_BIT 0x04
247: #define BNC_BIT 0x20
248:
249: #define I_ADD_REG0 0x04
250: #define I_ADD_REG1 0x05
251: #define I_ADD_REG2 0x06
252: #define I_ADD_REG3 0x07
253: #define I_ADD_REG4 0x08
254: #define I_ADD_REG5 0x09
255:
256: #define EEPROM_REG 0x0a
257: #define EESK 0x01
258: #define EECS 0x02
259: #define EEDI 0x04
260: #define EEDO 0x08
261:
262:
263: /* Check for a network adaptor of this type, and return '0' iff one exists.
264: If dev->base_addr == 0, probe all likely locations.
265: If dev->base_addr == 1, always return failure.
266: If dev->base_addr == 2, allocate space for the device and return success
267: (detachable devices only).
268: */
269: #ifdef HAVE_DEVLIST
270: /* Support for a alternate probe manager, which will eliminate the
271: boilerplate below. */
272: struct netdev_entry netcard_drv =
273: {"eepro", eepro_probe1, EEPRO_IO_EXTENT, eepro_portlist};
274: #else
275: int
276: eepro_probe(struct device *dev)
277: {
278: int i;
279: int base_addr = dev ? dev->base_addr : 0;
280:
281: if (base_addr > 0x1ff) /* Check a single specified location. */
282: return eepro_probe1(dev, base_addr);
283: else if (base_addr != 0) /* Don't probe at all. */
284: return ENXIO;
285:
286: for (i = 0; eepro_portlist[i]; i++) {
287: int ioaddr = eepro_portlist[i];
288: if (check_region(ioaddr, EEPRO_IO_EXTENT))
289: continue;
290: if (eepro_probe1(dev, ioaddr) == 0)
291: return 0;
292: }
293:
294: return ENODEV;
295: }
296: #endif
297:
298: /* This is the real probe routine. Linux has a history of friendly device
299: probes on the ISA bus. A good device probes avoids doing writes, and
300: verifies that the correct device exists and functions. */
301:
302: int eepro_probe1(struct device *dev, short ioaddr)
303: {
304: unsigned short station_addr[6], id, counter;
305: int i;
306: int eepro; /* a flag, TRUE=1 for the EtherExpress Pro/10,
307: FALSE = 0 for other 82595-based lan cards. */
308: const char *ifmap[] = {"AUI", "10Base2", "10BaseT"};
309: enum iftype { AUI=0, BNC=1, TPE=2 };
310:
311: /* Now, we are going to check for the signature of the
312: ID_REG (register 2 of bank 0) */
313:
314: if (((id=inb(ioaddr + ID_REG)) & ID_REG_MASK) == ID_REG_SIG) {
315:
316: /* We seem to have the 82595 signature, let's
317: play with its counter (last 2 bits of
318: register 2 of bank 0) to be sure. */
319:
320: counter = (id & R_ROBIN_BITS);
321: if (((id=inb(ioaddr+ID_REG)) & R_ROBIN_BITS) ==
322: (counter + 0x40)) {
323:
324: /* Yes, the 82595 has been found */
325:
326: /* Now, get the ethernet hardware address from
327: the EEPROM */
328:
329: station_addr[0] = read_eeprom(ioaddr, 2);
330: station_addr[1] = read_eeprom(ioaddr, 3);
331: station_addr[2] = read_eeprom(ioaddr, 4);
332:
333: /* Check the station address for the manufacturer's code */
334:
335: if (station_addr[2] != 0x00aa || (station_addr[1] & 0xff00) != 0x0000) {
336: eepro = 0;
337: printk("%s: Intel 82595-based lan card at %#x,",
338: dev->name, ioaddr);
339: }
340: else {
341: eepro = 1;
342: printk("%s: Intel EtherExpress Pro/10 at %#x,",
343: dev->name, ioaddr);
344: }
345:
346: /* Fill in the 'dev' fields. */
347: dev->base_addr = ioaddr;
348:
349: for (i=0; i < 6; i++) {
350: dev->dev_addr[i] = ((unsigned char *) station_addr)[5-i];
351: printk("%c%02x", i ? ':' : ' ', dev->dev_addr[i]);
352: }
353:
354: outb(BANK2_SELECT, ioaddr); /* be CAREFUL, BANK 2 now */
355: id = inb(ioaddr + REG3);
356: if (id & TPE_BIT)
357: dev->if_port = TPE;
358: else dev->if_port = BNC;
359:
360: if (dev->irq < 2 && eepro) {
361: i = read_eeprom(ioaddr, 1);
362: switch (i & 0x07) {
363: case 0: dev->irq = 9; break;
364: case 1: dev->irq = 3; break;
365: case 2: dev->irq = 5; break;
366: case 3: dev->irq = 10; break;
367: case 4: dev->irq = 11; break;
368: default: /* should never get here !!!!! */
369: printk(" illegal interrupt vector stored in EEPROM.\n");
370: return ENODEV;
371: }
372: }
373: else if (dev->irq == 2)
374: dev->irq = 9;
375:
376: if (dev->irq > 2) {
377: printk(", IRQ %d, %s.\n", dev->irq,
378: ifmap[dev->if_port]);
379: if (request_irq(dev->irq, &eepro_interrupt, 0, "eepro")) {
380: printk("%s: unable to get IRQ %d.\n", dev->name, dev->irq);
381: return -EAGAIN;
382: }
383: }
384: else printk(", %s.\n", ifmap[dev->if_port]);
385:
386: if ((dev->mem_start & 0xf) > 0)
387: net_debug = dev->mem_start & 7;
388:
389: if (net_debug > 3) {
390: i = read_eeprom(ioaddr, 5);
391: if (i & 0x2000) /* bit 13 of EEPROM word 5 */
392: printk("%s: Concurrent Processing is enabled but not used!\n",
393: dev->name);
394: }
395:
396: if (net_debug)
397: printk(version);
398:
399: /* Grab the region so we can find another board if autoIRQ fails. */
400: request_region(ioaddr, EEPRO_IO_EXTENT, "eepro");
401:
402: /* Initialize the device structure */
403: dev->priv = kmalloc(sizeof(struct eepro_local), GFP_KERNEL);
404: if (dev->priv == NULL)
405: return -ENOMEM;
406: memset(dev->priv, 0, sizeof(struct eepro_local));
407:
408: dev->open = eepro_open;
409: dev->stop = eepro_close;
410: dev->hard_start_xmit = eepro_send_packet;
411: dev->get_stats = eepro_get_stats;
412: dev->set_multicast_list = &set_multicast_list;
413:
414: /* Fill in the fields of the device structure with
415: ethernet generic values */
416:
417: ether_setup(dev);
418:
419: outb(RESET_CMD, ioaddr); /* RESET the 82595 */
420:
421: return 0;
422: }
423: else return ENODEV;
424: }
425: else if (net_debug > 3)
426: printk ("EtherExpress Pro probed failed!\n");
427: return ENODEV;
428: }
429:
430: /* Open/initialize the board. This is called (in the current kernel)
431: sometime after booting when the 'ifconfig' program is run.
432:
433: This routine should set everything up anew at each open, even
434: registers that "should" only need to be set once at boot, so that
435: there is non-reboot way to recover if something goes wrong.
436: */
437:
438: static char irqrmap[] = {-1,-1,0,1,-1,2,-1,-1,-1,0,3,4,-1,-1,-1,-1};
439: static int eepro_grab_irq(struct device *dev)
440: {
441: int irqlist[] = { 5, 9, 10, 11, 4, 3, 0};
442: int *irqp = irqlist, temp_reg, ioaddr = dev->base_addr;
443:
444: outb(BANK1_SELECT, ioaddr); /* be CAREFUL, BANK 1 now */
445:
446: /* Enable the interrupt line. */
447: temp_reg = inb(ioaddr + REG1);
448: outb(temp_reg | INT_ENABLE, ioaddr + REG1);
449:
450: outb(BANK0_SELECT, ioaddr); /* be CAREFUL, BANK 0 now */
451:
452: /* clear all interrupts */
453: outb(ALL_MASK, ioaddr + STATUS_REG);
454: /* Let EXEC event to interrupt */
455: outb(ALL_MASK & ~(EXEC_MASK), ioaddr + INT_MASK_REG);
456:
457: do {
458: outb(BANK1_SELECT, ioaddr); /* be CAREFUL, BANK 1 now */
459:
460: temp_reg = inb(ioaddr + INT_NO_REG);
461: outb((temp_reg & 0xf8) | irqrmap[*irqp], ioaddr + INT_NO_REG);
462:
463: outb(BANK0_SELECT, ioaddr); /* Switch back to Bank 0 */
464:
465: if (request_irq (*irqp, NULL, 0, "bogus") != EBUSY) {
466: /* Twinkle the interrupt, and check if it's seen */
467: autoirq_setup(0);
468:
469: outb(DIAGNOSE_CMD, ioaddr); /* RESET the 82595 */
470:
471: if (*irqp == autoirq_report(2) && /* It's a good IRQ line */
472: (request_irq(dev->irq = *irqp, &eepro_interrupt, 0, "eepro") == 0))
473: break;
474:
475: /* clear all interrupts */
476: outb(ALL_MASK, ioaddr + STATUS_REG);
477: }
478: } while (*++irqp);
479:
480: outb(BANK1_SELECT, ioaddr); /* Switch back to Bank 1 */
481:
482: /* Disable the physical interrupt line. */
483: temp_reg = inb(ioaddr + REG1);
484: outb(temp_reg & 0x7f, ioaddr + REG1);
485:
486: outb(BANK0_SELECT, ioaddr); /* Switch back to Bank 0 */
487:
488: /* Mask all the interrupts. */
489: outb(ALL_MASK, ioaddr + INT_MASK_REG);
490:
491: /* clear all interrupts */
492: outb(ALL_MASK, ioaddr + STATUS_REG);
493:
494: return dev->irq;
495: }
496:
497: static int
498: eepro_open(struct device *dev)
499: {
500: unsigned short temp_reg;
501: int i, ioaddr = dev->base_addr;
502: struct eepro_local *lp = (struct eepro_local *)dev->priv;
503:
504: if (net_debug > 3)
505: printk("eepro: entering eepro_open routine.\n");
506:
507: if (dev->dev_addr[0] == SA_ADDR0 &&
508: dev->dev_addr[1] == SA_ADDR1 &&
509: dev->dev_addr[2] == SA_ADDR2)
510: lp->eepro = 1; /* Yes, an Intel EtherExpress Pro/10 */
511: else lp->eepro = 0; /* No, it is a generic 82585 lan card */
512:
513: /* Get the interrupt vector for the 82595 */
514: if (dev->irq < 2 && eepro_grab_irq(dev) == 0) {
515: printk("%s: unable to get IRQ %d.\n", dev->name, dev->irq);
516: return -EAGAIN;
517: }
518:
519: if (irq2dev_map[dev->irq] != 0
520: || (irq2dev_map[dev->irq] = dev) == 0)
521: return -EAGAIN;
522:
523: /* Initialize the 82595. */
524:
525: outb(BANK2_SELECT, ioaddr); /* be CAREFUL, BANK 2 now */
526: temp_reg = inb(ioaddr + EEPROM_REG);
527: if (temp_reg & 0x10) /* Check the TurnOff Enable bit */
528: outb(temp_reg & 0xef, ioaddr + EEPROM_REG);
529: for (i=0; i < 6; i++)
530: outb(dev->dev_addr[i] , ioaddr + I_ADD_REG0 + i);
531:
532: temp_reg = inb(ioaddr + REG1); /* Setup Transmit Chaining */
533: outb(temp_reg | XMT_Chain_Int | XMT_Chain_ErrStop /* and discard bad RCV frames */
534: | RCV_Discard_BadFrame, ioaddr + REG1);
535:
536: temp_reg = inb(ioaddr + REG2); /* Match broadcast */
537: outb(temp_reg | 0x14, ioaddr + REG2);
538:
539: temp_reg = inb(ioaddr + REG3);
540: outb(temp_reg & 0x3f, ioaddr + REG3); /* clear test mode */
541:
542: /* Set the receiving mode */
543: outb(BANK1_SELECT, ioaddr); /* be CAREFUL, BANK 1 now */
544:
545: temp_reg = inb(ioaddr + INT_NO_REG);
546: outb((temp_reg & 0xf8) | irqrmap[dev->irq], ioaddr + INT_NO_REG);
547:
548: /* Initialize the RCV and XMT upper and lower limits */
549: outb(RCV_LOWER_LIMIT, ioaddr + RCV_LOWER_LIMIT_REG);
550: outb(RCV_UPPER_LIMIT, ioaddr + RCV_UPPER_LIMIT_REG);
551: outb(XMT_LOWER_LIMIT, ioaddr + XMT_LOWER_LIMIT_REG);
552: outb(XMT_UPPER_LIMIT, ioaddr + XMT_UPPER_LIMIT_REG);
553:
554: /* Enable the interrupt line. */
555: temp_reg = inb(ioaddr + REG1);
556: outb(temp_reg | INT_ENABLE, ioaddr + REG1);
557:
558: outb(BANK0_SELECT, ioaddr); /* Switch back to Bank 0 */
559:
560: /* Let RX and TX events to interrupt */
561: outb(ALL_MASK & ~(RX_MASK | TX_MASK), ioaddr + INT_MASK_REG);
562: /* clear all interrupts */
563: outb(ALL_MASK, ioaddr + STATUS_REG);
564:
565: /* Initialize RCV */
566: outw(RCV_LOWER_LIMIT << 8, ioaddr + RCV_BAR);
567: lp->rx_start = (RCV_LOWER_LIMIT << 8) ;
568: outw((RCV_UPPER_LIMIT << 8) | 0xfe, ioaddr + RCV_STOP);
569:
570: /* Initialize XMT */
571: outw(XMT_LOWER_LIMIT << 8, ioaddr + XMT_BAR);
572:
573: outb(SEL_RESET_CMD, ioaddr);
574: /* We are supposed to wait for 2 us after a SEL_RESET */
575: SLOW_DOWN_IO;
576: SLOW_DOWN_IO;
577:
578: lp->tx_start = lp->tx_end = XMT_LOWER_LIMIT << 8; /* or = RCV_RAM */
579: lp->tx_last = 0;
580:
581: dev->tbusy = 0;
582: dev->interrupt = 0;
583: dev->start = 1;
584:
585: if (net_debug > 3)
586: printk("eepro: exiting eepro_open routine.\n");
587:
588: outb(RCV_ENABLE_CMD, ioaddr);
589:
590: MOD_INC_USE_COUNT;
591: return 0;
592: }
593:
594: static int
595: eepro_send_packet(struct sk_buff *skb, struct device *dev)
596: {
597: struct eepro_local *lp = (struct eepro_local *)dev->priv;
598: int ioaddr = dev->base_addr;
599:
600: if (net_debug > 5)
601: printk("eepro: entering eepro_send_packet routine.\n");
602:
603: if (dev->tbusy) {
604: /* If we get here, some higher level has decided we are broken.
605: There should really be a "kick me" function call instead. */
606: int tickssofar = jiffies - dev->trans_start;
607: if (tickssofar < 5)
608: return 1;
609: if (net_debug > 1)
610: printk("%s: transmit timed out, %s?\n", dev->name,
611: "network cable problem");
612: lp->stats.tx_errors++;
613: /* Try to restart the adaptor. */
614: outb(SEL_RESET_CMD, ioaddr);
615: /* We are supposed to wait for 2 us after a SEL_RESET */
616: SLOW_DOWN_IO;
617: SLOW_DOWN_IO;
618:
619: /* Do I also need to flush the transmit buffers here? YES? */
620: lp->tx_start = lp->tx_end = RCV_RAM;
621: lp->tx_last = 0;
622:
623: dev->tbusy=0;
624: dev->trans_start = jiffies;
625:
626: outb(RCV_ENABLE_CMD, ioaddr);
627:
628: }
629:
630: /* If some higher layer thinks we've missed an tx-done interrupt
631: we are passed NULL. Caution: dev_tint() handles the cli()/sti()
632: itself. */
633: if (skb == NULL) {
634: dev_tint(dev);
635: return 0;
636: }
637:
638: /* Block a timer-based transmit from overlapping. */
639: if (set_bit(0, (void*)&dev->tbusy) != 0)
640: printk("%s: Transmitter access conflict.\n", dev->name);
641: else {
642: short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
643: unsigned char *buf = skb->data;
644:
645: hardware_send_packet(dev, buf, length);
646: dev->trans_start = jiffies;
647: }
648:
649: dev_kfree_skb (skb, FREE_WRITE);
650:
651: /* You might need to clean up and record Tx statistics here. */
652: /* lp->stats.tx_aborted_errors++; */
653:
654: if (net_debug > 5)
655: printk("eepro: exiting eepro_send_packet routine.\n");
656:
657: return 0;
658: }
659:
660:
661: /* The typical workload of the driver:
662: Handle the network interface interrupts. */
663: static void
664: eepro_interrupt(int irq, struct pt_regs * regs)
665: {
666: struct device *dev = (struct device *)(irq2dev_map[irq]);
667: int ioaddr, status, boguscount = 0;
668:
669: if (net_debug > 5)
670: printk("eepro: entering eepro_interrupt routine.\n");
671:
672: if (dev == NULL) {
673: printk ("eepro_interrupt(): irq %d for unknown device.\n", irq);
674: return;
675: }
676: dev->interrupt = 1;
677:
678: ioaddr = dev->base_addr;
679:
680: do {
681: status = inb(ioaddr + STATUS_REG);
682:
683: if (status & RX_INT) {
684: if (net_debug > 4)
685: printk("eepro: packet received interrupt.\n");
686:
687: /* Acknowledge the RX_INT */
688: outb(RX_INT, ioaddr + STATUS_REG);
689:
690: /* Get the received packets */
691: eepro_rx(dev);
692: }
693: else if (status & TX_INT) {
694: if (net_debug > 4)
695: printk("eepro: packet transmit interrupt.\n");
696:
697: /* Acknowledge the TX_INT */
698: outb(TX_INT, ioaddr + STATUS_REG);
699:
700: /* Process the status of transmitted packets */
701: eepro_transmit_interrupt(dev);
702: dev->tbusy = 0;
703: mark_bh(NET_BH);
704: }
705: } while ((++boguscount < 10) && (status & 0x06));
706:
707: dev->interrupt = 0;
708: if (net_debug > 5)
709: printk("eepro: exiting eepro_interrupt routine.\n");
710:
711: return;
712: }
713:
714: static int
715: eepro_close(struct device *dev)
716: {
717: struct eepro_local *lp = (struct eepro_local *)dev->priv;
718: int ioaddr = dev->base_addr;
719: short temp_reg;
720:
721: dev->tbusy = 1;
722: dev->start = 0;
723:
724: outb(BANK1_SELECT, ioaddr); /* Switch back to Bank 1 */
725:
726: /* Disable the physical interrupt line. */
727: temp_reg = inb(ioaddr + REG1);
728: outb(temp_reg & 0x7f, ioaddr + REG1);
729:
730: outb(BANK0_SELECT, ioaddr); /* Switch back to Bank 0 */
731:
732: /* Flush the Tx and disable Rx. */
733: outb(STOP_RCV_CMD, ioaddr);
734: lp->tx_start = lp->tx_end = RCV_RAM ;
735: lp->tx_last = 0;
736:
737: /* Mask all the interrupts. */
738: outb(ALL_MASK, ioaddr + INT_MASK_REG);
739:
740: /* clear all interrupts */
741: outb(ALL_MASK, ioaddr + STATUS_REG);
742:
743: /* Reset the 82595 */
744: outb(RESET_CMD, ioaddr);
745:
746: /* release the interrupt */
747: free_irq(dev->irq);
748:
749: irq2dev_map[dev->irq] = 0;
750:
751: /* Update the statistics here. What statistics? */
752:
753: /* We are supposed to wait for 200 us after a RESET */
754: SLOW_DOWN_IO;
755: SLOW_DOWN_IO; /* May not be enough? */
756:
757: MOD_DEC_USE_COUNT;
758: return 0;
759: }
760:
761: /* Get the current statistics. This may be called with the card open or
762: closed. */
763: static struct enet_statistics *
764: eepro_get_stats(struct device *dev)
765: {
766: struct eepro_local *lp = (struct eepro_local *)dev->priv;
767:
768: return &lp->stats;
769: }
770:
771: /* Set or clear the multicast filter for this adaptor.
772: */
773: static void
774: set_multicast_list(struct device *dev)
775: {
776: struct eepro_local *lp = (struct eepro_local *)dev->priv;
777: short ioaddr = dev->base_addr;
778: unsigned short mode;
779: struct dev_mc_list *dmi=dev->mc_list;
780:
781: if (dev->flags&(IFF_ALLMULTI|IFF_PROMISC) || dev->mc_count > 63)
782: {
783: /*
784: * We must make the kernel realise we had to move
785: * into promisc mode or we start all out war on
786: * the cable. If it was a promisc rewquest the
787: * flag is already set. If not we assert it.
788: */
789: dev->flags|=IFF_PROMISC;
790:
791: outb(BANK2_SELECT, ioaddr); /* be CAREFUL, BANK 2 now */
792: mode = inb(ioaddr + REG2);
793: outb(mode | PRMSC_Mode, ioaddr + REG2);
794: mode = inb(ioaddr + REG3);
795: outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */
796: outb(BANK0_SELECT, ioaddr); /* Return to BANK 0 now */
797: printk("%s: promiscuous mode enabled.\n", dev->name);
798: }
799: else if (dev->mc_count==0 )
800: {
801: outb(BANK2_SELECT, ioaddr); /* be CAREFUL, BANK 2 now */
802: mode = inb(ioaddr + REG2);
803: outb(mode & 0xd6, ioaddr + REG2); /* Turn off Multi-IA and PRMSC_Mode bits */
804: mode = inb(ioaddr + REG3);
805: outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */
806: outb(BANK0_SELECT, ioaddr); /* Return to BANK 0 now */
807: }
808: else
809: {
810: unsigned short status, *eaddrs;
811: int i, boguscount = 0;
812:
813: /* Disable RX and TX interrupts. Neccessary to avoid
814: corruption of the HOST_ADDRESS_REG by interrupt
815: service routines. */
816: outb(ALL_MASK, ioaddr + INT_MASK_REG);
817:
818: outb(BANK2_SELECT, ioaddr); /* be CAREFUL, BANK 2 now */
819: mode = inb(ioaddr + REG2);
820: outb(mode | Multi_IA, ioaddr + REG2);
821: mode = inb(ioaddr + REG3);
822: outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */
823: outb(BANK0_SELECT, ioaddr); /* Return to BANK 0 now */
824: outw(lp->tx_end, ioaddr + HOST_ADDRESS_REG);
825: outw(MC_SETUP, ioaddr + IO_PORT);
826: outw(0, ioaddr + IO_PORT);
827: outw(0, ioaddr + IO_PORT);
828: outw(6*(dev->mc_count + 1), ioaddr + IO_PORT);
829: for (i = 0; i < dev->mc_count; i++)
830: {
831: eaddrs=(unsigned short *)dmi->dmi_addr;
832: dmi=dmi->next;
833: outw(*eaddrs++, ioaddr + IO_PORT);
834: outw(*eaddrs++, ioaddr + IO_PORT);
835: outw(*eaddrs++, ioaddr + IO_PORT);
836: }
837: eaddrs = (unsigned short *) dev->dev_addr;
838: outw(eaddrs[0], ioaddr + IO_PORT);
839: outw(eaddrs[1], ioaddr + IO_PORT);
840: outw(eaddrs[2], ioaddr + IO_PORT);
841: outw(lp->tx_end, ioaddr + XMT_BAR);
842: outb(MC_SETUP, ioaddr);
843:
844: /* Update the transmit queue */
845: i = lp->tx_end + XMT_HEADER + 6*(dev->mc_count + 1);
846: if (lp->tx_start != lp->tx_end)
847: {
848: /* update the next address and the chain bit in the
849: last packet */
850: outw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG);
851: outw(i, ioaddr + IO_PORT);
852: outw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG);
853: status = inw(ioaddr + IO_PORT);
854: outw(status | CHAIN_BIT, ioaddr + IO_PORT);
855: lp->tx_end = i ;
856: }
857: else lp->tx_start = lp->tx_end = i ;
858:
859: /* Acknowledge that the MC setup is done */
860: do { /* We should be doing this in the eepro_interrupt()! */
861: SLOW_DOWN_IO;
862: SLOW_DOWN_IO;
863: if (inb(ioaddr + STATUS_REG) & 0x08)
864: {
865: i = inb(ioaddr);
866: outb(0x08, ioaddr + STATUS_REG);
867: if (i & 0x20) { /* command ABORTed */
868: printk("%s: multicast setup failed.\n",
869: dev->name);
870: break;
871: } else if ((i & 0x0f) == 0x03) { /* MC-Done */
872: printk("%s: set Rx mode to %d addresses.\n",
873: dev->name, dev->mc_count);
874: break;
875: }
876: }
877: } while (++boguscount < 100);
878:
879: /* Re-enable RX and TX interrupts */
880: outb(ALL_MASK & ~(RX_MASK | TX_MASK), ioaddr + INT_MASK_REG);
881:
882: }
883: outb(RCV_ENABLE_CMD, ioaddr);
884: }
885:
886: /* The horrible routine to read a word from the serial EEPROM. */
887: /* IMPORTANT - the 82595 will be set to Bank 0 after the eeprom is read */
888:
889: /* The delay between EEPROM clock transitions. */
890: #define eeprom_delay() { int _i = 40; while (--_i > 0) { __SLOW_DOWN_IO; }}
891: #define EE_READ_CMD (6 << 6)
892:
893: int
894: read_eeprom(int ioaddr, int location)
895: {
896: int i;
897: unsigned short retval = 0;
898: short ee_addr = ioaddr + EEPROM_REG;
899: int read_cmd = location | EE_READ_CMD;
900: short ctrl_val = EECS ;
901:
902: outb(BANK2_SELECT, ioaddr);
903: outb(ctrl_val, ee_addr);
904:
905: /* Shift the read command bits out. */
906: for (i = 8; i >= 0; i--) {
907: short outval = (read_cmd & (1 << i)) ? ctrl_val | EEDI
908: : ctrl_val;
909: outb(outval, ee_addr);
910: outb(outval | EESK, ee_addr); /* EEPROM clock tick. */
911: eeprom_delay();
912: outb(outval, ee_addr); /* Finish EEPROM a clock tick. */
913: eeprom_delay();
914: }
915: outb(ctrl_val, ee_addr);
916:
917: for (i = 16; i > 0; i--) {
918: outb(ctrl_val | EESK, ee_addr); eeprom_delay();
919: retval = (retval << 1) | ((inb(ee_addr) & EEDO) ? 1 : 0);
920: outb(ctrl_val, ee_addr); eeprom_delay();
921: }
922:
923: /* Terminate the EEPROM access. */
924: ctrl_val &= ~EECS;
925: outb(ctrl_val | EESK, ee_addr);
926: eeprom_delay();
927: outb(ctrl_val, ee_addr);
928: eeprom_delay();
929: outb(BANK0_SELECT, ioaddr);
930: return retval;
931: }
932:
933: static void
934: hardware_send_packet(struct device *dev, void *buf, short length)
935: {
936: struct eepro_local *lp = (struct eepro_local *)dev->priv;
937: short ioaddr = dev->base_addr;
938: unsigned status, tx_available, last, end, boguscount = 10;
939:
940: if (net_debug > 5)
941: printk("eepro: entering hardware_send_packet routine.\n");
942:
943: while (boguscount-- > 0) {
944:
945: /* determine how much of the transmit buffer space is available */
946: if (lp->tx_end > lp->tx_start)
947: tx_available = XMT_RAM - (lp->tx_end - lp->tx_start);
948: else if (lp->tx_end < lp->tx_start)
949: tx_available = lp->tx_start - lp->tx_end;
950: else tx_available = XMT_RAM;
951:
952: /* Disable RX and TX interrupts. Neccessary to avoid
953: corruption of the HOST_ADDRESS_REG by interrupt
954: service routines. */
955: outb(ALL_MASK, ioaddr + INT_MASK_REG);
956:
957: if (((((length + 1) >> 1) << 1) + 2*XMT_HEADER)
958: >= tx_available) /* No space available ??? */
959: continue;
960:
961: last = lp->tx_end;
962: end = last + (((length + 1) >> 1) << 1) + XMT_HEADER;
963:
964: if (end >= RAM_SIZE) { /* the transmit buffer is wrapped around */
965: if ((RAM_SIZE - last) <= XMT_HEADER) {
966: /* Arrrr!!!, must keep the xmt header together,
967: several days were lost to chase this one down. */
968: last = RCV_RAM;
969: end = last + (((length + 1) >> 1) << 1) + XMT_HEADER;
970: }
971: else end = RCV_RAM + (end - RAM_SIZE);
972: }
973:
974: outw(last, ioaddr + HOST_ADDRESS_REG);
975: outw(XMT_CMD, ioaddr + IO_PORT);
976: outw(0, ioaddr + IO_PORT);
977: outw(end, ioaddr + IO_PORT);
978: outw(length, ioaddr + IO_PORT);
979: outsw(ioaddr + IO_PORT, buf, (length + 1) >> 1);
980:
981: if (lp->tx_start != lp->tx_end) {
982: /* update the next address and the chain bit in the
983: last packet */
984: if (lp->tx_end != last) {
985: outw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG);
986: outw(last, ioaddr + IO_PORT);
987: }
988: outw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG);
989: status = inw(ioaddr + IO_PORT);
990: outw(status | CHAIN_BIT, ioaddr + IO_PORT);
991: }
992:
993: /* A dummy read to flush the DRAM write pipeline */
994: status = inw(ioaddr + IO_PORT);
995:
996: /* Enable RX and TX interrupts */
997: outb(ALL_MASK & ~(RX_MASK | TX_MASK), ioaddr + INT_MASK_REG);
998:
999: if (lp->tx_start == lp->tx_end) {
1000: outw(last, ioaddr + XMT_BAR);
1001: outb(XMT_CMD, ioaddr);
1002: lp->tx_start = last; /* I don't like to change tx_start here */
1003: }
1004: else outb(RESUME_XMT_CMD, ioaddr);
1005:
1006: lp->tx_last = last;
1007: lp->tx_end = end;
1008:
1009: if (dev->tbusy) {
1010: dev->tbusy = 0;
1011: mark_bh(NET_BH);
1012: }
1013:
1014: if (net_debug > 5)
1015: printk("eepro: exiting hardware_send_packet routine.\n");
1016: return;
1017: }
1018: dev->tbusy = 1;
1019: if (net_debug > 5)
1020: printk("eepro: exiting hardware_send_packet routine.\n");
1021: }
1022:
1023: static void
1024: eepro_rx(struct device *dev)
1025: {
1026: struct eepro_local *lp = (struct eepro_local *)dev->priv;
1027: short ioaddr = dev->base_addr;
1028: short boguscount = 20;
1029: short rcv_car = lp->rx_start;
1030: unsigned rcv_event, rcv_status, rcv_next_frame, rcv_size;
1031:
1032: if (net_debug > 5)
1033: printk("eepro: entering eepro_rx routine.\n");
1034:
1035: /* Set the read pointer to the start of the RCV */
1036: outw(rcv_car, ioaddr + HOST_ADDRESS_REG);
1037: rcv_event = inw(ioaddr + IO_PORT);
1038:
1039: while (rcv_event == RCV_DONE) {
1040: rcv_status = inw(ioaddr + IO_PORT);
1041: rcv_next_frame = inw(ioaddr + IO_PORT);
1042: rcv_size = inw(ioaddr + IO_PORT);
1043:
1044: if ((rcv_status & (RX_OK | RX_ERROR)) == RX_OK) {
1045: /* Malloc up new buffer. */
1046: struct sk_buff *skb;
1047:
1048: rcv_size &= 0x3fff;
1049: skb = dev_alloc_skb(rcv_size+2);
1050: if (skb == NULL) {
1051: printk("%s: Memory squeeze, dropping packet.\n", dev->name);
1052: lp->stats.rx_dropped++;
1053: break;
1054: }
1055: skb->dev = dev;
1056: skb_reserve(skb,2);
1057:
1058: insw(ioaddr+IO_PORT, skb_put(skb,rcv_size), (rcv_size + 1) >> 1);
1059:
1060: skb->protocol = eth_type_trans(skb,dev);
1061: netif_rx(skb);
1062: lp->stats.rx_packets++;
1063: }
1064: else { /* Not sure will ever reach here,
1065: I set the 595 to discard bad received frames */
1066: lp->stats.rx_errors++;
1067: if (rcv_status & 0x0100)
1068: lp->stats.rx_over_errors++;
1069: else if (rcv_status & 0x0400)
1070: lp->stats.rx_frame_errors++;
1071: else if (rcv_status & 0x0800)
1072: lp->stats.rx_crc_errors++;
1073: printk("%s: event = %#x, status = %#x, next = %#x, size = %#x\n",
1074: dev->name, rcv_event, rcv_status, rcv_next_frame, rcv_size);
1075: }
1076: if (rcv_status & 0x1000)
1077: lp->stats.rx_length_errors++;
1078: if (--boguscount == 0)
1079: break;
1080:
1081: rcv_car = lp->rx_start + RCV_HEADER + rcv_size;
1082: lp->rx_start = rcv_next_frame;
1083: outw(rcv_next_frame, ioaddr + HOST_ADDRESS_REG);
1084: rcv_event = inw(ioaddr + IO_PORT);
1085:
1086: }
1087: if (rcv_car == 0)
1088: rcv_car = (RCV_UPPER_LIMIT << 8) | 0xff;
1089: outw(rcv_car - 1, ioaddr + RCV_STOP);
1090:
1091: if (net_debug > 5)
1092: printk("eepro: exiting eepro_rx routine.\n");
1093: }
1094:
1095: static void
1096: eepro_transmit_interrupt(struct device *dev)
1097: {
1098: struct eepro_local *lp = (struct eepro_local *)dev->priv;
1099: short ioaddr = dev->base_addr;
1100: short boguscount = 10;
1101: short xmt_status;
1102:
1103: while (lp->tx_start != lp->tx_end) {
1104:
1105: outw(lp->tx_start, ioaddr + HOST_ADDRESS_REG);
1106: xmt_status = inw(ioaddr+IO_PORT);
1107: if ((xmt_status & TX_DONE_BIT) == 0) break;
1108: xmt_status = inw(ioaddr+IO_PORT);
1109: lp->tx_start = inw(ioaddr+IO_PORT);
1110:
1111: if (dev->tbusy) {
1112: dev->tbusy = 0;
1113: mark_bh(NET_BH);
1114: }
1115:
1116: if (xmt_status & 0x2000)
1117: lp->stats.tx_packets++;
1118: else {
1119: lp->stats.tx_errors++;
1120: if (xmt_status & 0x0400)
1121: lp->stats.tx_carrier_errors++;
1122: printk("%s: XMT status = %#x\n",
1123: dev->name, xmt_status);
1124: }
1125: if (xmt_status & 0x000f)
1126: lp->stats.collisions += (xmt_status & 0x000f);
1127: if ((xmt_status & 0x0040) == 0x0)
1128: lp->stats.tx_heartbeat_errors++;
1129:
1130: if (--boguscount == 0)
1131: break;
1132: }
1133: }
1134:
1135: #ifdef MODULE
1136: static char devicename[9] = { 0, };
1137: static struct device dev_eepro = {
1138: devicename, /* device name is inserted by linux/drivers/net/net_init.c */
1139: 0, 0, 0, 0,
1140: 0, 0,
1141: 0, 0, 0, NULL, eepro_probe };
1142:
1143: static int io = 0x200;
1144: static int irq = 0;
1145:
1146: int
1147: init_module(void)
1148: {
1149: if (io == 0)
1150: printk("eepro: You should not use auto-probing with insmod!\n");
1151: dev_eepro.base_addr = io;
1152: dev_eepro.irq = irq;
1153:
1154: if (register_netdev(&dev_eepro) != 0)
1155: return -EIO;
1156: return 0;
1157: }
1158:
1159: void
1160: cleanup_module(void)
1161: {
1162: unregister_netdev(&dev_eepro);
1163: kfree_s(dev_eepro.priv,sizeof(struct eepro_local));
1164: dev_eepro.priv=NULL;
1165:
1166: /* If we don't do this, we can't re-insmod it later. */
1167: release_region(dev_eepro.base_addr, EEPRO_IO_EXTENT);
1168: }
1169: #endif /* MODULE */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.