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