![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 3c503.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 3c503.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net |
1.1 root 1: /* 3c503.c: A shared-memory NS8390 ethernet driver for linux. */
2: /*
3: Written 1992-94 by Donald Becker.
4:
5: Copyright 1993 United States Government as represented by the
6: Director, National Security Agency. This software may be used and
7: distributed according to the terms of the GNU Public License,
8: incorporated herein by reference.
9:
10: The author may be reached as [email protected], or C/O
11: Center of Excellence in Space Data and Information Sciences
12: Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
13:
14: This driver should work with the 3c503 and 3c503/16. It should be used
15: in shared memory mode for best performance, although it may also work
16: in programmed-I/O mode.
17:
18: Sources:
19: EtherLink II Technical Reference Manual,
20: EtherLink II/16 Technical Reference Manual Supplement,
21: 3Com Corporation, 5400 Bayfront Plaza, Santa Clara CA 95052-8145
22:
23: The Crynwr 3c503 packet driver.
24:
25: Changelog:
26:
27: Paul Gortmaker : add support for the 2nd 8kB of RAM on 16 bit cards.
28: Paul Gortmaker : multiple card support for module users.
29: [email protected] : Fix up PIO interface for efficient operation.
30:
31: */
32:
33: static const char *version =
34: "3c503.c:v1.10 9/23/93 Donald Becker ([email protected])\n";
35:
36: #include <linux/module.h>
37:
38: #include <linux/kernel.h>
39: #include <linux/sched.h>
40: #include <linux/errno.h>
41: #include <linux/string.h>
42: #include <linux/delay.h>
43: #include <linux/netdevice.h>
44: #include <linux/etherdevice.h>
45:
46: #include <asm/io.h>
47: #include <asm/system.h>
48: #include <asm/byteorder.h>
49:
50: #include "8390.h"
51: #include "3c503.h"
52: #define WRD_COUNT 4
53:
54: int el2_probe(struct device *dev);
55: int el2_pio_probe(struct device *dev);
56: int el2_probe1(struct device *dev, int ioaddr);
57:
58: /* A zero-terminated list of I/O addresses to be probed in PIO mode. */
59: static unsigned int netcard_portlist[] =
60: { 0x300,0x310,0x330,0x350,0x250,0x280,0x2a0,0x2e0,0};
61:
62: #define EL2_IO_EXTENT 16
63:
64: #ifdef HAVE_DEVLIST
65: /* The 3c503 uses two entries, one for the safe memory-mapped probe and
66: the other for the typical I/O probe. */
67: struct netdev_entry el2_drv =
68: {"3c503", el2_probe, EL1_IO_EXTENT, 0};
69: struct netdev_entry el2pio_drv =
70: {"3c503pio", el2_pioprobe1, EL1_IO_EXTENT, netcard_portlist};
71: #endif
72:
73: static int el2_open(struct device *dev);
74: static int el2_close(struct device *dev);
75: static void el2_reset_8390(struct device *dev);
76: static void el2_init_card(struct device *dev);
77: static void el2_block_output(struct device *dev, int count,
78: const unsigned char *buf, const int start_page);
79: static void el2_block_input(struct device *dev, int count, struct sk_buff *skb,
80: int ring_offset);
81: static void el2_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr,
82: int ring_page);
83:
84:
85: /* This routine probes for a memory-mapped 3c503 board by looking for
86: the "location register" at the end of the jumpered boot PROM space.
87: This works even if a PROM isn't there.
88:
89: If the ethercard isn't found there is an optional probe for
90: ethercard jumpered to programmed-I/O mode.
91: */
92: int
93: el2_probe(struct device *dev)
94: {
95: int *addr, addrs[] = { 0xddffe, 0xd9ffe, 0xcdffe, 0xc9ffe, 0};
96: int base_addr = dev->base_addr;
97:
98: if (base_addr > 0x1ff) /* Check a single specified location. */
99: return el2_probe1(dev, base_addr);
100: else if (base_addr != 0) /* Don't probe at all. */
101: return ENXIO;
102:
103: for (addr = addrs; *addr; addr++) {
104: int i;
105: unsigned int base_bits = readb(*addr);
106: /* Find first set bit. */
107: for(i = 7; i >= 0; i--, base_bits >>= 1)
108: if (base_bits & 0x1)
109: break;
110: if (base_bits != 1)
111: continue;
112: if (check_region(netcard_portlist[i], EL2_IO_EXTENT))
113: continue;
114: if (el2_probe1(dev, netcard_portlist[i]) == 0)
115: return 0;
116: }
117: #if ! defined(no_probe_nonshared_memory) && ! defined (HAVE_DEVLIST)
118: return el2_pio_probe(dev);
119: #else
120: return ENODEV;
121: #endif
122: }
123:
124: #ifndef HAVE_DEVLIST
125: /* Try all of the locations that aren't obviously empty. This touches
126: a lot of locations, and is much riskier than the code above. */
127: int
128: el2_pio_probe(struct device *dev)
129: {
130: int i;
131: int base_addr = dev ? dev->base_addr : 0;
132:
133: if (base_addr > 0x1ff) /* Check a single specified location. */
134: return el2_probe1(dev, base_addr);
135: else if (base_addr != 0) /* Don't probe at all. */
136: return ENXIO;
137:
138: for (i = 0; netcard_portlist[i]; i++) {
139: int ioaddr = netcard_portlist[i];
140: if (check_region(ioaddr, EL2_IO_EXTENT))
141: continue;
142: if (el2_probe1(dev, ioaddr) == 0)
143: return 0;
144: }
145:
146: return ENODEV;
147: }
148: #endif
149:
150: /* Probe for the Etherlink II card at I/O port base IOADDR,
151: returning non-zero on success. If found, set the station
152: address and memory parameters in DEVICE. */
153: int
154: el2_probe1(struct device *dev, int ioaddr)
155: {
156: int i, iobase_reg, membase_reg, saved_406, wordlength;
157: static unsigned version_printed = 0;
158: unsigned long vendor_id;
159:
160: /* Reset and/or avoid any lurking NE2000 */
161: if (inb(ioaddr + 0x408) == 0xff) {
162: udelay(1000);
163: return ENODEV;
164: }
165:
166: /* We verify that it's a 3C503 board by checking the first three octets
167: of its ethernet address. */
168: iobase_reg = inb(ioaddr+0x403);
169: membase_reg = inb(ioaddr+0x404);
170: /* ASIC location registers should be 0 or have only a single bit set. */
171: if ( (iobase_reg & (iobase_reg - 1))
172: || (membase_reg & (membase_reg - 1))) {
173: return ENODEV;
174: }
175: saved_406 = inb_p(ioaddr + 0x406);
176: outb_p(ECNTRL_RESET|ECNTRL_THIN, ioaddr + 0x406); /* Reset it... */
177: outb_p(ECNTRL_THIN, ioaddr + 0x406);
178: /* Map the station addr PROM into the lower I/O ports. We now check
179: for both the old and new 3Com prefix */
180: outb(ECNTRL_SAPROM|ECNTRL_THIN, ioaddr + 0x406);
181: vendor_id = inb(ioaddr)*0x10000 + inb(ioaddr + 1)*0x100 + inb(ioaddr + 2);
182: if ((vendor_id != OLD_3COM_ID) && (vendor_id != NEW_3COM_ID)) {
183: /* Restore the register we frobbed. */
184: outb(saved_406, ioaddr + 0x406);
185: return ENODEV;
186: }
187:
188: /* We should have a "dev" from Space.c or the static module table. */
189: if (dev == NULL) {
190: printk("3c503.c: Passed a NULL device.\n");
191: dev = init_etherdev(0, 0);
192: }
193:
194: if (ei_debug && version_printed++ == 0)
195: printk(version);
196:
197: dev->base_addr = ioaddr;
198: /* Allocate dev->priv and fill in 8390 specific dev fields. */
199: if (ethdev_init(dev)) {
200: printk ("3c503: unable to allocate memory for dev->priv.\n");
201: return -ENOMEM;
202: }
203:
204: printk("%s: 3c503 at i/o base %#3x, node ", dev->name, ioaddr);
205:
206: /* Retrieve and print the ethernet address. */
207: for (i = 0; i < 6; i++)
208: printk(" %2.2x", dev->dev_addr[i] = inb(ioaddr + i));
209:
210: /* Map the 8390 back into the window. */
211: outb(ECNTRL_THIN, ioaddr + 0x406);
212:
213: /* Check for EL2/16 as described in tech. man. */
214: outb_p(E8390_PAGE0, ioaddr + E8390_CMD);
215: outb_p(0, ioaddr + EN0_DCFG);
216: outb_p(E8390_PAGE2, ioaddr + E8390_CMD);
217: wordlength = inb_p(ioaddr + EN0_DCFG) & ENDCFG_WTS;
218: outb_p(E8390_PAGE0, ioaddr + E8390_CMD);
219:
220: /* Probe for, turn on and clear the board's shared memory. */
221: if (ei_debug > 2) printk(" memory jumpers %2.2x ", membase_reg);
222: outb(EGACFR_NORM, ioaddr + 0x405); /* Enable RAM */
223:
224: /* This should be probed for (or set via an ioctl()) at run-time.
225: Right now we use a sleazy hack to pass in the interface number
226: at boot-time via the low bits of the mem_end field. That value is
227: unused, and the low bits would be discarded even if it was used. */
228: #if defined(EI8390_THICK) || defined(EL2_AUI)
229: ei_status.interface_num = 1;
230: #else
231: ei_status.interface_num = dev->mem_end & 0xf;
232: #endif
233: printk(", using %sternal xcvr.\n", ei_status.interface_num == 0 ? "in" : "ex");
234:
235: if ((membase_reg & 0xf0) == 0) {
236: dev->mem_start = 0;
237: ei_status.name = "3c503-PIO";
238: } else {
239: dev->mem_start = ((membase_reg & 0xc0) ? 0xD8000 : 0xC8000) +
240: ((membase_reg & 0xA0) ? 0x4000 : 0);
241:
242: #define EL2_MEMSIZE (EL2_MB1_STOP_PG - EL2_MB1_START_PG)*256
243: #ifdef EL2MEMTEST
244: /* This has never found an error, but someone might care.
245: Note that it only tests the 2nd 8kB on 16kB 3c503/16
246: cards between card addr. 0x2000 and 0x3fff. */
247: { /* Check the card's memory. */
248: unsigned long mem_base = dev->mem_start;
249: unsigned int test_val = 0xbbadf00d;
250: writel(0xba5eba5e, mem_base);
251: for (i = sizeof(test_val); i < EL2_MEMSIZE; i+=sizeof(test_val)) {
252: writel(test_val, mem_base + i);
253: if (readl(mem_base) != 0xba5eba5e
254: || readl(mem_base + i) != test_val) {
255: printk("3c503: memory failure or memory address conflict.\n");
256: dev->mem_start = 0;
257: ei_status.name = "3c503-PIO";
258: break;
259: }
260: test_val += 0x55555555;
261: writel(0, mem_base + i);
262: }
263: }
264: #endif /* EL2MEMTEST */
265:
266: dev->mem_end = dev->rmem_end = dev->mem_start + EL2_MEMSIZE;
267:
268: if (wordlength) { /* No Tx pages to skip over to get to Rx */
269: dev->rmem_start = dev->mem_start;
270: ei_status.name = "3c503/16";
271: } else {
272: dev->rmem_start = TX_PAGES*256 + dev->mem_start;
273: ei_status.name = "3c503";
274: }
275: }
276:
277: /*
278: Divide up the memory on the card. This is the same regardless of
279: whether shared-mem or PIO is used. For 16 bit cards (16kB RAM),
280: we use the entire 8k of bank1 for an Rx ring. We only use 3k
281: of the bank0 for 2 full size Tx packet slots. For 8 bit cards,
282: (8kB RAM) we use 3kB of bank1 for two Tx slots, and the remaining
283: 5kB for an Rx ring. */
284:
285: if (wordlength) {
286: ei_status.tx_start_page = EL2_MB0_START_PG;
287: ei_status.rx_start_page = EL2_MB1_START_PG;
288: } else {
289: ei_status.tx_start_page = EL2_MB1_START_PG;
290: ei_status.rx_start_page = EL2_MB1_START_PG + TX_PAGES;
291: }
292:
293: /* Finish setting the board's parameters. */
294: ei_status.stop_page = EL2_MB1_STOP_PG;
295: ei_status.word16 = wordlength;
296: ei_status.reset_8390 = &el2_reset_8390;
297: ei_status.get_8390_hdr = &el2_get_8390_hdr;
298: ei_status.block_input = &el2_block_input;
299: ei_status.block_output = &el2_block_output;
300:
301: request_region(ioaddr, EL2_IO_EXTENT, ei_status.name);
302:
303: if (dev->irq == 2)
304: dev->irq = 9;
305: else if (dev->irq > 5 && dev->irq != 9) {
306: printk("3c503: configured interrupt %d invalid, will use autoIRQ.\n",
307: dev->irq);
308: dev->irq = 0;
309: }
310:
311: ei_status.saved_irq = dev->irq;
312:
313: dev->start = 0;
314: dev->open = &el2_open;
315: dev->stop = &el2_close;
316:
317: if (dev->mem_start)
318: printk("%s: %s - %dkB RAM, 8kB shared mem window at %#6lx-%#6lx.\n",
319: dev->name, ei_status.name, (wordlength+1)<<3,
320: dev->mem_start, dev->mem_end-1);
321:
322: else
323: {
324: ei_status.tx_start_page = EL2_MB1_START_PG;
325: ei_status.rx_start_page = EL2_MB1_START_PG + TX_PAGES;
326: printk("\n%s: %s, %dkB RAM, using programmed I/O (REJUMPER for SHARED MEMORY).\n",
327: dev->name, ei_status.name, (wordlength+1)<<3);
328: }
329: return 0;
330: }
331:
332: static int
333: el2_open(struct device *dev)
334: {
335:
336: if (dev->irq < 2) {
337: int irqlist[] = {5, 9, 3, 4, 0};
338: int *irqp = irqlist;
339:
340: outb(EGACFR_NORM, E33G_GACFR); /* Enable RAM and interrupts. */
341: do {
342: if (request_irq (*irqp, NULL, 0, "bogus", NULL) != -EBUSY) {
343: /* Twinkle the interrupt, and check if it's seen. */
344: autoirq_setup(0);
345: outb_p(0x04 << ((*irqp == 9) ? 2 : *irqp), E33G_IDCFR);
346: outb_p(0x00, E33G_IDCFR);
347: if (*irqp == autoirq_report(0) /* It's a good IRQ line! */
348: && request_irq (dev->irq = *irqp, &ei_interrupt, 0, ei_status.name, NULL) == 0)
349: break;
350: }
351: } while (*++irqp);
352: if (*irqp == 0) {
353: outb(EGACFR_IRQOFF, E33G_GACFR); /* disable interrupts. */
354: return -EAGAIN;
355: }
356: } else {
357: if (request_irq(dev->irq, &ei_interrupt, 0, ei_status.name, NULL)) {
358: return -EAGAIN;
359: }
360: }
361:
362: el2_init_card(dev);
363: ei_open(dev);
364: MOD_INC_USE_COUNT;
365: return 0;
366: }
367:
368: static int
369: el2_close(struct device *dev)
370: {
371: free_irq(dev->irq, NULL);
372: dev->irq = ei_status.saved_irq;
373: irq2dev_map[dev->irq] = NULL;
374: outb(EGACFR_IRQOFF, E33G_GACFR); /* disable interrupts. */
375:
376: ei_close(dev);
377: MOD_DEC_USE_COUNT;
378: return 0;
379: }
380:
381: /* This is called whenever we have a unrecoverable failure:
382: transmit timeout
383: Bad ring buffer packet header
384: */
385: static void
386: el2_reset_8390(struct device *dev)
387: {
388: if (ei_debug > 1) {
389: printk("%s: Resetting the 3c503 board...", dev->name);
390: printk("%#lx=%#02x %#lx=%#02x %#lx=%#02x...", E33G_IDCFR, inb(E33G_IDCFR),
391: E33G_CNTRL, inb(E33G_CNTRL), E33G_GACFR, inb(E33G_GACFR));
392: }
393: outb_p(ECNTRL_RESET|ECNTRL_THIN, E33G_CNTRL);
394: ei_status.txing = 0;
395: outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
396: el2_init_card(dev);
397: if (ei_debug > 1) printk("done\n");
398: }
399:
400: /* Initialize the 3c503 GA registers after a reset. */
401: static void
402: el2_init_card(struct device *dev)
403: {
404: /* Unmap the station PROM and select the DIX or BNC connector. */
405: outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
406:
407: /* Set ASIC copy of rx's first and last+1 buffer pages */
408: /* These must be the same as in the 8390. */
409: outb(ei_status.rx_start_page, E33G_STARTPG);
410: outb(ei_status.stop_page, E33G_STOPPG);
411:
412: /* Point the vector pointer registers somewhere ?harmless?. */
413: outb(0xff, E33G_VP2); /* Point at the ROM restart location 0xffff0 */
414: outb(0xff, E33G_VP1);
415: outb(0x00, E33G_VP0);
416: /* Turn off all interrupts until we're opened. */
417: outb_p(0x00, dev->base_addr + EN0_IMR);
418: /* Enable IRQs iff started. */
419: outb(EGACFR_NORM, E33G_GACFR);
420:
421: /* Set the interrupt line. */
422: outb_p((0x04 << (dev->irq == 9 ? 2 : dev->irq)), E33G_IDCFR);
423: outb_p((WRD_COUNT << 1), E33G_DRQCNT); /* Set burst size to 8 */
424: outb_p(0x20, E33G_DMAAH); /* Put a valid addr in the GA DMA */
425: outb_p(0x00, E33G_DMAAL);
426: return; /* We always succeed */
427: }
428:
429: /*
430: * Either use the shared memory (if enabled on the board) or put the packet
431: * out through the ASIC FIFO.
432: */
433: static void
434: el2_block_output(struct device *dev, int count,
435: const unsigned char *buf, const int start_page)
436: {
437: unsigned short int *wrd;
438: int boguscount; /* timeout counter */
439: unsigned short word; /* temporary for better machine code */
440:
441: if (ei_status.word16) /* Tx packets go into bank 0 on EL2/16 card */
442: outb(EGACFR_RSEL|EGACFR_TCM, E33G_GACFR);
443: else
444: outb(EGACFR_NORM, E33G_GACFR);
445:
446: if (dev->mem_start) { /* Shared memory transfer */
447: unsigned long dest_addr = dev->mem_start +
448: ((start_page - ei_status.tx_start_page) << 8);
449: memcpy_toio(dest_addr, buf, count);
450: outb(EGACFR_NORM, E33G_GACFR); /* Back to bank1 in case on bank0 */
451: return;
452: }
453:
454: /*
455: * No shared memory, put the packet out the other way.
456: * Set up then start the internal memory transfer to Tx Start Page
457: */
458:
459: word = (unsigned short)start_page;
460: outb(word&0xFF, E33G_DMAAH);
461: outb(word>>8, E33G_DMAAL);
462:
463: outb_p((ei_status.interface_num ? ECNTRL_AUI : ECNTRL_THIN ) | ECNTRL_OUTPUT
464: | ECNTRL_START, E33G_CNTRL);
465:
466: /*
467: * Here I am going to write data to the FIFO as quickly as possible.
468: * Note that E33G_FIFOH is defined incorrectly. It is really
469: * E33G_FIFOL, the lowest port address for both the byte and
470: * word write. Variable 'count' is NOT checked. Caller must supply a
471: * valid count. Note that I may write a harmless extra byte to the
472: * 8390 if the byte-count was not even.
473: */
474: wrd = (unsigned short int *) buf;
475: count = (count + 1) >> 1;
476: for(;;)
477: {
478: boguscount = 0x1000;
479: while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
480: {
481: if(!boguscount--)
482: {
483: printk("%s: FIFO blocked in el2_block_output.\n", dev->name);
484: el2_reset_8390(dev);
485: goto blocked;
486: }
487: }
488: if(count > WRD_COUNT)
489: {
490: outsw(E33G_FIFOH, wrd, WRD_COUNT);
491: wrd += WRD_COUNT;
492: count -= WRD_COUNT;
493: }
494: else
495: {
496: outsw(E33G_FIFOH, wrd, count);
497: break;
498: }
499: }
500: blocked:;
501: outb_p(ei_status.interface_num==0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
502: return;
503: }
504:
505: /* Read the 4 byte, page aligned 8390 specific header. */
506: static void
507: el2_get_8390_hdr(struct device *dev, struct e8390_pkt_hdr *hdr, int ring_page)
508: {
509: int boguscount;
510: unsigned long hdr_start = dev->mem_start + ((ring_page - EL2_MB1_START_PG)<<8);
511: unsigned short word;
512:
513: if (dev->mem_start) { /* Use the shared memory. */
514: memcpy_fromio(hdr, hdr_start, sizeof(struct e8390_pkt_hdr));
515: return;
516: }
517:
518: /*
519: * No shared memory, use programmed I/O.
520: */
521:
522: word = (unsigned short)ring_page;
523: outb(word&0xFF, E33G_DMAAH);
524: outb(word>>8, E33G_DMAAL);
525:
526: outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
527: | ECNTRL_START, E33G_CNTRL);
528: boguscount = 0x1000;
529: while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
530: {
531: if(!boguscount--)
532: {
533: printk("%s: FIFO blocked in el2_get_8390_hdr.\n", dev->name);
534: memset(hdr, 0x00, sizeof(struct e8390_pkt_hdr));
535: el2_reset_8390(dev);
536: goto blocked;
537: }
538: }
539: insw(E33G_FIFOH, hdr, (sizeof(struct e8390_pkt_hdr))>> 1);
540: blocked:;
541: outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
542: }
543:
544:
545: static void
546: el2_block_input(struct device *dev, int count, struct sk_buff *skb, int ring_offset)
547: {
548: int boguscount = 0;
549: unsigned short int *buf;
550: unsigned short word;
551:
552: int end_of_ring = dev->rmem_end;
553:
554: /* Maybe enable shared memory just be to be safe... nahh.*/
555: if (dev->mem_start) { /* Use the shared memory. */
556: ring_offset -= (EL2_MB1_START_PG<<8);
557: if (dev->mem_start + ring_offset + count > end_of_ring) {
558: /* We must wrap the input move. */
559: int semi_count = end_of_ring - (dev->mem_start + ring_offset);
560: memcpy_fromio(skb->data, dev->mem_start + ring_offset, semi_count);
561: count -= semi_count;
562: memcpy_fromio(skb->data + semi_count, dev->rmem_start, count);
563: } else {
564: /* Packet is in one chunk -- we can copy + cksum. */
565: eth_io_copy_and_sum(skb, dev->mem_start + ring_offset, count, 0);
566: }
567: return;
568: }
569:
570: /*
571: * No shared memory, use programmed I/O.
572: */
573: word = (unsigned short) ring_offset;
574: outb(word>>8, E33G_DMAAH);
575: outb(word&0xFF, E33G_DMAAL);
576:
577: outb_p((ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI) | ECNTRL_INPUT
578: | ECNTRL_START, E33G_CNTRL);
579:
580: /*
581: * Here I also try to get data as fast as possible. I am betting that I
582: * can read one extra byte without clobbering anything in the kernel because
583: * this would only occur on an odd byte-count and allocation of skb->data
584: * is word-aligned. Variable 'count' is NOT checked. Caller must check
585: * for a valid count.
586: * [This is currently quite safe.... but if one day the 3c503 explodes
587: * you know where to come looking ;)]
588: */
589:
590: buf = (unsigned short int *) skb->data;
591: count = (count + 1) >> 1;
592: for(;;)
593: {
594: boguscount = 0x1000;
595: while ((inb(E33G_STATUS) & ESTAT_DPRDY) == 0)
596: {
597: if(!boguscount--)
598: {
599: printk("%s: FIFO blocked in el2_block_input.\n", dev->name);
600: el2_reset_8390(dev);
601: goto blocked;
602: }
603: }
604: if(count > WRD_COUNT)
605: {
606: insw(E33G_FIFOH, buf, WRD_COUNT);
607: buf += WRD_COUNT;
608: count -= WRD_COUNT;
609: }
610: else
611: {
612: insw(E33G_FIFOH, buf, count);
613: break;
614: }
615: }
616: blocked:;
617: outb_p(ei_status.interface_num == 0 ? ECNTRL_THIN : ECNTRL_AUI, E33G_CNTRL);
618: return;
619: }
620: #ifdef MODULE
621: #define MAX_EL2_CARDS 4 /* Max number of EL2 cards per module */
622: #define NAMELEN 8 /* #of chars for storing dev->name */
623:
624: static char namelist[NAMELEN * MAX_EL2_CARDS] = { 0, };
625: static struct device dev_el2[MAX_EL2_CARDS] = {
626: {
627: NULL, /* assign a chunk of namelist[] below */
628: 0, 0, 0, 0,
629: 0, 0,
630: 0, 0, 0, NULL, NULL
631: },
632: };
633:
634: static int io[MAX_EL2_CARDS] = { 0, };
635: static int irq[MAX_EL2_CARDS] = { 0, };
636: static int xcvr[MAX_EL2_CARDS] = { 0, }; /* choose int. or ext. xcvr */
637:
638: /* This is set up so that only a single autoprobe takes place per call.
639: ISA device autoprobes on a running machine are not recommended. */
640: int
641: init_module(void)
642: {
643: int this_dev, found = 0;
644:
645: for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) {
646: struct device *dev = &dev_el2[this_dev];
647: dev->name = namelist+(NAMELEN*this_dev);
648: dev->irq = irq[this_dev];
649: dev->base_addr = io[this_dev];
650: dev->mem_end = xcvr[this_dev]; /* low 4bits = xcvr sel. */
651: dev->init = el2_probe;
652: if (io[this_dev] == 0) {
653: if (this_dev != 0) break; /* only autoprobe 1st one */
654: printk(KERN_NOTICE "3c503.c: Presently autoprobing (not recommended) for a single card.\n");
655: }
656: if (register_netdev(dev) != 0) {
657: printk(KERN_WARNING "3c503.c: No 3c503 card found (i/o = 0x%x).\n", io[this_dev]);
658: if (found != 0) return 0; /* Got at least one. */
659: return -ENXIO;
660: }
661: found++;
662: }
663: return 0;
664: }
665:
666: void
667: cleanup_module(void)
668: {
669: int this_dev;
670:
671: for (this_dev = 0; this_dev < MAX_EL2_CARDS; this_dev++) {
672: struct device *dev = &dev_el2[this_dev];
673: if (dev->priv != NULL) {
674: /* NB: el2_close() handles free_irq + irq2dev map */
675: kfree(dev->priv);
676: dev->priv = NULL;
677: release_region(dev->base_addr, EL2_IO_EXTENT);
678: unregister_netdev(dev);
679: }
680: }
681: }
682: #endif /* MODULE */
683:
684: /*
685: * Local variables:
686: * version-control: t
687: * kept-new-versions: 5
688: * c-indent-level: 4
689: * End:
690: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.