![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to eexpress.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 eexpress.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net |
1.1 ! root 1: /* $Id: eexpress.c,v 1.1 1999/04/26 05:52:09 tb Exp $ ! 2: * ! 3: * Intel EtherExpress device driver for Linux ! 4: * ! 5: * Original version written 1993 by Donald Becker ! 6: * Modularized by Pauline Middelink <[email protected]> ! 7: * Changed to support io= irq= by Alan Cox <[email protected]> ! 8: * Reworked 1995 by John Sullivan <[email protected]> ! 9: * More fixes by Philip Blundell <[email protected]> ! 10: * Added the Compaq LTE Alan Cox <[email protected]> ! 11: * ! 12: * Note - this driver is experimental still - it has problems on faster ! 13: * machines. Someone needs to sit down and go through it line by line with ! 14: * a databook... ! 15: */ ! 16: ! 17: /* ! 18: * The original EtherExpress driver was just about usable, but ! 19: * suffered from a long startup delay, a hard limit of 16k memory ! 20: * usage on the card (EtherExpress 16s have either 32k or 64k), ! 21: * and random locks under load. The last was particularly annoying ! 22: * and made running eXceed/W preferable to Linux/XFree. After hacking ! 23: * through the driver for a couple of days, I had fixed most of the ! 24: * card handling errors, at the expense of turning the code into ! 25: * a complete jungle, but still hadn't tracked down the lock-ups. ! 26: * I had hoped these would be an IP bug, but failed to reproduce them ! 27: * under other drivers, so decided to start from scratch and rewrite ! 28: * the driver cleanly. And here it is. ! 29: * ! 30: * It's still not quite there, but self-corrects a lot more problems. ! 31: * the 'CU wedged, resetting...' message shouldn't happen at all, but ! 32: * at least we recover. It still locks occasionally, any ideas welcome. ! 33: * ! 34: * The original startup delay experienced by some people was due to the ! 35: * first ARP request for the address of the default router getting lost. ! 36: * (mostly the reply we were getting back was arriving before our ! 37: * hardware address was set up, or before the configuration sequence ! 38: * had told the card NOT to strip of the frame header). If you a long ! 39: * startup delay, you may have lost this ARP request/reply, although ! 40: * the original cause has been fixed. However, it is more likely that ! 41: * you've just locked under this version. ! 42: * ! 43: * The main changes are in the 586 initialization procedure (which was ! 44: * just broken before - the EExp is a strange beasty and needs careful ! 45: * handling) the receive buffer handling (we now use a non-terminating ! 46: * circular list of buffers, which stops the card giving us out-of- ! 47: * resources errors), and the transmit code. The driver is also more ! 48: * structured, and I have tried to keep the kernel interface separate ! 49: * from the hardware interface (although some routines naturally want ! 50: * to do both). ! 51: * ! 52: * John Sullivan ! 53: * ! 54: * 18/5/95: ! 55: * ! 56: * The lock-ups seem to happen when you access card memory after a 586 ! 57: * reset. This happens only 1 in 12 resets, on a random basis, and ! 58: * completely locks the machine. As far as I can see there is no ! 59: * workaround possible - the only thing to be done is make sure we ! 60: * never reset the card *after* booting the kernel - once at probe time ! 61: * must be sufficient, and we'll just have to put up with that failing ! 62: * occasionally (or buy a new NIC). By the way, this looks like a ! 63: * definite card bug, since Intel's own driver for DOS does exactly the ! 64: * same. ! 65: * ! 66: * This bug makes switching in and out of promiscuous mode a risky ! 67: * business, since we must do a 586 reset each time. ! 68: */ ! 69: ! 70: /* ! 71: * Sources: ! 72: * ! 73: * The original eexpress.c by Donald Becker ! 74: * Sources: the Crynwr EtherExpress driver source. ! 75: * the Intel Microcommunications Databook Vol.1 1990 ! 76: * ! 77: * wavelan.c and i82586.h ! 78: * This was invaluable for the complete '586 configuration details ! 79: * and command format. ! 80: * ! 81: * The Crynwr sources (again) ! 82: * Not as useful as the Wavelan driver, but then I had eexpress.c to ! 83: * go off. ! 84: * ! 85: * The Intel EtherExpress 16 ethernet card ! 86: * Provided the only reason I want to see a working etherexpress driver. ! 87: * A lot of fixes came from just observing how the card (mis)behaves when ! 88: * you prod it. ! 89: * ! 90: */ ! 91: ! 92: static char version[] = ! 93: "eexpress.c: v0.10 04-May-95 John Sullivan <[email protected]>\n" ! 94: " v0.14 19-May-96 Philip Blundell <[email protected]>\n" ! 95: " v0.15 04-Aug-98 Alan Cox <[email protected]>\n"; ! 96: ! 97: #include <linux/module.h> ! 98: ! 99: #include <linux/kernel.h> ! 100: #include <linux/sched.h> ! 101: #include <linux/types.h> ! 102: #include <linux/fcntl.h> ! 103: #include <linux/interrupt.h> ! 104: #include <linux/ptrace.h> ! 105: #include <linux/ioport.h> ! 106: #include <linux/string.h> ! 107: #include <linux/in.h> ! 108: #include <asm/system.h> ! 109: #include <asm/bitops.h> ! 110: #include <asm/io.h> ! 111: #include <asm/dma.h> ! 112: #include <linux/delay.h> ! 113: #include <linux/errno.h> ! 114: ! 115: #include <linux/netdevice.h> ! 116: #include <linux/etherdevice.h> ! 117: #include <linux/skbuff.h> ! 118: #include <linux/malloc.h> ! 119: ! 120: /* ! 121: * Not actually used yet - may be implemented when the driver has ! 122: * been debugged! ! 123: * ! 124: * Debug Level Driver Status ! 125: * 0 Final release ! 126: * 1 Beta test ! 127: * 2 ! 128: * 3 ! 129: * 4 Report timeouts & 586 errors (normal debug level) ! 130: * 5 Report all major events ! 131: * 6 Dump sent/received packet contents ! 132: * 7 Report function entry/exit ! 133: */ ! 134: ! 135: #ifndef NET_DEBUG ! 136: #define NET_DEBUG 4 ! 137: #endif ! 138: static unsigned int net_debug = NET_DEBUG; ! 139: ! 140: #undef F_DEB ! 141: ! 142: #include "eth82586.h" ! 143: ! 144: #define PRIV(x) ((struct net_local *)(x)->priv) ! 145: #define EEXP_IO_EXTENT 16 ! 146: ! 147: /* ! 148: * Private data declarations ! 149: */ ! 150: ! 151: struct net_local ! 152: { ! 153: struct enet_statistics stats; ! 154: unsigned long init_time; /* jiffies when eexp_hw_init586 called */ ! 155: unsigned short rx_first; /* first rx buf, same as RX_BUF_START */ ! 156: unsigned short rx_last; /* last rx buf */ ! 157: unsigned short tx_head; /* next free tx buf */ ! 158: unsigned short tx_reap; /* first in-use tx buf */ ! 159: unsigned short tx_tail; /* previous tx buf to tx_head */ ! 160: unsigned short tx_link; /* last known-executing tx buf */ ! 161: unsigned short last_tx_restart; /* set to tx_link when we restart the CU */ ! 162: unsigned char started; ! 163: unsigned char promisc; ! 164: unsigned short rx_buf_start; ! 165: unsigned short rx_buf_end; ! 166: unsigned short num_tx_bufs; ! 167: unsigned short num_rx_bufs; ! 168: }; ! 169: ! 170: unsigned short start_code[] = { ! 171: 0x0000, /* SCP: set bus to 16 bits */ ! 172: 0x0000,0x0000, /* junk */ ! 173: 0x0000,0x0000, /* address of ISCP (lo,hi) */ ! 174: ! 175: 0x0001, /* ISCP: busy - cleared after reset */ ! 176: 0x0008,0x0000,0x0000, /* offset,address (lo,hi) of SCB */ ! 177: ! 178: 0x0000,0x0000, /* SCB: status, commands */ ! 179: 0x0000,0x0000, /* links to first command block, first receive descriptor */ ! 180: 0x0000,0x0000, /* CRC error, alignment error counts */ ! 181: 0x0000,0x0000, /* out of resources, overrun error counts */ ! 182: ! 183: 0x0000,0x0000, /* pad */ ! 184: 0x0000,0x0000, ! 185: ! 186: 0x0000,Cmd_Config, /* startup configure sequence, at 0x0020 */ ! 187: 0x0032, /* link to next command */ ! 188: 0x080c, /* 12 bytes follow : fifo threshold=8 */ ! 189: 0x2e40, /* don't rx bad frames : SRDY/ARDY => ext. sync. : preamble len=8 ! 190: * take addresses from data buffers : 6 bytes/address */ ! 191: 0x6000, /* default backoff method & priority : interframe spacing = 0x60 */ ! 192: 0xf200, /* slot time=0x200 : max collision retry = 0xf */ ! 193: 0x0000, /* no HDLC : normal CRC : enable broadcast : disable promiscuous/multicast modes */ ! 194: 0x003c, /* minimum frame length = 60 octets) */ ! 195: ! 196: 0x0000,Cmd_INT|Cmd_SetAddr, ! 197: 0x003e, /* link to next command */ ! 198: 0x0000,0x0000,0x0000, /* hardware address placed here, 0x0038 */ ! 199: 0x0000,Cmd_END|Cmd_Nop, /* end of configure sequence */ ! 200: 0x003e, ! 201: ! 202: 0x0000 ! 203: ! 204: }; ! 205: ! 206: #define CONF_LINK 0x0020 ! 207: #define CONF_HW_ADDR 0x0038 ! 208: ! 209: /* maps irq number to EtherExpress magic value */ ! 210: static char irqrmap[] = { 0,0,1,2,3,4,0,0,0,1,5,6,0,0,0,0 }; ! 211: ! 212: /* ! 213: * Prototypes for Linux interface ! 214: */ ! 215: ! 216: extern int express_probe(struct device *dev); ! 217: static int eexp_open (struct device *dev); ! 218: static int eexp_close(struct device *dev); ! 219: static struct enet_statistics *eexp_stats(struct device *dev); ! 220: static int eexp_xmit (struct sk_buff *buf, struct device *dev); ! 221: ! 222: static void eexp_irq (int irq, void *dev_addr, struct pt_regs *regs); ! 223: static void eexp_set_multicast(struct device *dev); ! 224: ! 225: /* ! 226: * Prototypes for hardware access functions ! 227: */ ! 228: ! 229: static void eexp_hw_rx (struct device *dev); ! 230: static void eexp_hw_tx (struct device *dev, unsigned short *buf, unsigned short len); ! 231: static int eexp_hw_probe (struct device *dev,unsigned short ioaddr); ! 232: static unsigned short eexp_hw_readeeprom(unsigned short ioaddr, unsigned char location); ! 233: ! 234: static unsigned short eexp_hw_lasttxstat(struct device *dev); ! 235: static void eexp_hw_txrestart (struct device *dev); ! 236: ! 237: static void eexp_hw_txinit (struct device *dev); ! 238: static void eexp_hw_rxinit (struct device *dev); ! 239: ! 240: static void eexp_hw_init586 (struct device *dev); ! 241: static void eexp_hw_ASICrst (struct device *dev); ! 242: ! 243: /* ! 244: * Linux interface ! 245: */ ! 246: ! 247: /* ! 248: * checks for presence of EtherExpress card ! 249: */ ! 250: ! 251: int express_probe(struct device *dev) ! 252: { ! 253: unsigned short *port,ports[] = { 0x0300,0x0270,0x0320,0x0340,0 }; ! 254: unsigned short ioaddr = dev->base_addr; ! 255: ! 256: if (ioaddr&0xfe00) ! 257: return eexp_hw_probe(dev,ioaddr); ! 258: else if (ioaddr) ! 259: return ENXIO; ! 260: ! 261: for ( port=&ports[0] ; *port ; port++ ) ! 262: { ! 263: unsigned short sum = 0; ! 264: int i; ! 265: for ( i=0 ; i<4 ; i++ ) ! 266: { ! 267: unsigned short t; ! 268: t = inb(*port + ID_PORT); ! 269: sum |= (t>>4) << ((t & 0x03)<<2); ! 270: } ! 271: if (sum==0xbaba && !eexp_hw_probe(dev,*port)) ! 272: return 0; ! 273: } ! 274: return ENODEV; ! 275: } ! 276: ! 277: /* ! 278: * open and initialize the adapter, ready for use ! 279: */ ! 280: ! 281: static int eexp_open(struct device *dev) ! 282: { ! 283: int irq = dev->irq; ! 284: unsigned short ioaddr = dev->base_addr; ! 285: ! 286: #if NET_DEBUG > 6 ! 287: printk(KERN_DEBUG "%s: eexp_open()\n", dev->name); ! 288: #endif ! 289: ! 290: if (!irq || !irqrmap[irq]) ! 291: return -ENXIO; ! 292: ! 293: if (irq2dev_map[irq] || ! 294: /* more consistent, surely? */ ! 295: ((irq2dev_map[irq]=dev),0) || ! 296: request_irq(irq,&eexp_irq,0,"eexpress",NULL)) ! 297: return -EAGAIN; ! 298: ! 299: request_region(ioaddr, EEXP_IO_EXTENT, "eexpress"); ! 300: dev->tbusy = 0; ! 301: dev->interrupt = 0; ! 302: eexp_hw_init586(dev); ! 303: dev->start = 1; ! 304: MOD_INC_USE_COUNT; ! 305: #if NET_DEBUG > 6 ! 306: printk(KERN_DEBUG "%s: leaving eexp_open()\n", dev->name); ! 307: #endif ! 308: return 0; ! 309: } ! 310: ! 311: /* ! 312: * close and disable the interface, leaving ! 313: * the 586 in reset ! 314: */ ! 315: static int eexp_close(struct device *dev) ! 316: { ! 317: unsigned short ioaddr = dev->base_addr; ! 318: int irq = dev->irq; ! 319: ! 320: dev->tbusy = 1; ! 321: dev->start = 0; ! 322: ! 323: outb(SIRQ_dis|irqrmap[irq],ioaddr+SET_IRQ); ! 324: PRIV(dev)->started = 0; ! 325: outw(SCB_CUsuspend|SCB_RUsuspend,ioaddr+SCB_CMD); ! 326: outb(0,ioaddr+SIGNAL_CA); ! 327: free_irq(irq,NULL); ! 328: irq2dev_map[irq] = NULL; ! 329: outb(i586_RST,ioaddr+EEPROM_Ctrl); ! 330: release_region(ioaddr,16); ! 331: MOD_DEC_USE_COUNT; ! 332: return 0; ! 333: } ! 334: ! 335: /* ! 336: * Return interface stats ! 337: */ ! 338: ! 339: static struct enet_statistics *eexp_stats(struct device *dev) ! 340: { ! 341: struct net_local *lp = (struct net_local *)dev->priv; ! 342: ! 343: /* ! 344: * Hmmm, this looks a little too easy... The card maintains ! 345: * some stats in the SCB, and I'm not convinced we're ! 346: * incrementing the most sensible statistics when the card ! 347: * returns an error (esp. slow DMA, out-of-resources) ! 348: */ ! 349: return &lp->stats; ! 350: } ! 351: ! 352: /* ! 353: * Called to transmit a packet, or to allow us to right ourselves ! 354: * if the kernel thinks we've died. ! 355: */ ! 356: ! 357: static int eexp_xmit(struct sk_buff *buf, struct device *dev) ! 358: { ! 359: struct net_local *lp = (struct net_local *)dev->priv; ! 360: unsigned short ioaddr = dev->base_addr; ! 361: ! 362: #if NET_DEBUG > 6 ! 363: printk(KERN_DEBUG "%s: eexp_xmit()\n", dev->name); ! 364: #endif ! 365: ! 366: outb(SIRQ_dis|irqrmap[dev->irq],ioaddr+SET_IRQ); ! 367: if (dev->tbusy) ! 368: { ! 369: /* This will happen, but hopefully not as often as when ! 370: * tbusy==0. If it happens too much, we probably ought ! 371: * to think about unwedging ourselves... ! 372: */ ! 373: if (test_bit(0,(void *)&PRIV(dev)->started)) ! 374: { ! 375: if ((jiffies - dev->trans_start)>5) ! 376: { ! 377: if (lp->tx_link==lp->last_tx_restart) ! 378: { ! 379: unsigned short boguscount=200,rsst; ! 380: printk(KERN_WARNING "%s: Retransmit timed out, status %04x, resetting...\n", ! 381: dev->name,inw(ioaddr+SCB_STATUS)); ! 382: eexp_hw_txinit(dev); ! 383: lp->last_tx_restart = 0; ! 384: outw(lp->tx_link,ioaddr+SCB_CBL); ! 385: outw(0,ioaddr+SCB_STATUS); ! 386: outw(SCB_CUstart,ioaddr+SCB_CMD); ! 387: outb(0,ioaddr+SIGNAL_CA); ! 388: while (!SCB_complete(rsst=inw(ioaddr+SCB_STATUS))) ! 389: { ! 390: if (!--boguscount) ! 391: { ! 392: boguscount=200; ! 393: printk(KERN_WARNING "%s: Reset timed out status %04x, retrying...\n", ! 394: dev->name,rsst); ! 395: outw(lp->tx_link,ioaddr+SCB_CBL); ! 396: outw(0,ioaddr+SCB_STATUS); ! 397: outw(SCB_CUstart,ioaddr+SCB_CMD); ! 398: outb(0,ioaddr+SIGNAL_CA); ! 399: } ! 400: } ! 401: dev->tbusy = 0; ! 402: mark_bh(NET_BH); ! 403: } ! 404: else ! 405: { ! 406: unsigned short status = inw(ioaddr+SCB_STATUS); ! 407: if (SCB_CUdead(status)) ! 408: { ! 409: unsigned short txstatus = eexp_hw_lasttxstat(dev); ! 410: printk(KERN_WARNING "%s: Transmit timed out, CU not active status %04x %04x, restarting...\n", ! 411: dev->name, status, txstatus); ! 412: eexp_hw_txrestart(dev); ! 413: } ! 414: else ! 415: { ! 416: unsigned short txstatus = eexp_hw_lasttxstat(dev); ! 417: if (dev->tbusy && !txstatus) ! 418: { ! 419: printk(KERN_WARNING "%s: CU wedged, status %04x %04x, resetting...\n", ! 420: dev->name,status,txstatus); ! 421: eexp_hw_init586(dev); ! 422: dev->tbusy = 0; ! 423: mark_bh(NET_BH); ! 424: } ! 425: } ! 426: } ! 427: } ! 428: } ! 429: else ! 430: { ! 431: if ((jiffies-lp->init_time)>10) ! 432: { ! 433: unsigned short status = inw(ioaddr+SCB_STATUS); ! 434: printk(KERN_WARNING "%s: i82586 startup timed out, status %04x, resetting...\n", ! 435: dev->name, status); ! 436: eexp_hw_init586(dev); ! 437: dev->tbusy = 0; ! 438: mark_bh(NET_BH); ! 439: } ! 440: } ! 441: } ! 442: ! 443: if (buf==NULL) ! 444: { ! 445: unsigned short status = inw(ioaddr+SCB_STATUS); ! 446: unsigned short txstatus = eexp_hw_lasttxstat(dev); ! 447: if (SCB_CUdead(status)) ! 448: { ! 449: printk(KERN_WARNING "%s: CU has died! status %04x %04x, attempting to restart...\n", ! 450: dev->name, status, txstatus); ! 451: lp->stats.tx_errors++; ! 452: eexp_hw_txrestart(dev); ! 453: } ! 454: dev_tint(dev); ! 455: outb(SIRQ_en|irqrmap[dev->irq],ioaddr+SET_IRQ); ! 456: dev_kfree_skb(buf, FREE_WRITE); ! 457: return 0; ! 458: } ! 459: ! 460: if (set_bit(0,(void *)&dev->tbusy)) ! 461: { ! 462: lp->stats.tx_dropped++; ! 463: } ! 464: else ! 465: { ! 466: unsigned short length = (ETH_ZLEN < buf->len) ? buf->len : ETH_ZLEN; ! 467: unsigned short *data = (unsigned short *)buf->data; ! 468: ! 469: outb(SIRQ_dis|irqrmap[dev->irq],ioaddr+SET_IRQ); ! 470: eexp_hw_tx(dev,data,length); ! 471: outb(SIRQ_en|irqrmap[dev->irq],ioaddr+SET_IRQ); ! 472: } ! 473: dev_kfree_skb(buf, FREE_WRITE); ! 474: outb(SIRQ_en|irqrmap[dev->irq],ioaddr+SET_IRQ); ! 475: return 0; ! 476: } ! 477: ! 478: /* ! 479: * Handle an EtherExpress interrupt ! 480: * If we've finished initializing, start the RU and CU up. ! 481: * If we've already started, reap tx buffers, handle any received packets, ! 482: * check to make sure we've not become wedged. ! 483: */ ! 484: ! 485: static void eexp_irq(int irq, void *dev_info, struct pt_regs *regs) ! 486: { ! 487: struct device *dev = irq2dev_map[irq]; ! 488: struct net_local *lp; ! 489: unsigned short ioaddr,status,ack_cmd; ! 490: unsigned short old_rp,old_wp; ! 491: ! 492: if (dev==NULL) ! 493: { ! 494: printk(KERN_WARNING "net_interrupt(): irq %d for unknown device caught by EExpress\n",irq); ! 495: return; ! 496: } ! 497: ! 498: #if NET_DEBUG > 6 ! 499: printk(KERN_DEBUG "%s: interrupt\n", dev->name); ! 500: #endif ! 501: ! 502: dev->interrupt = 1; /* should this be reset on exit? */ ! 503: ! 504: lp = (struct net_local *)dev->priv; ! 505: ioaddr = dev->base_addr; ! 506: ! 507: outb(SIRQ_dis|irqrmap[irq],ioaddr+SET_IRQ); ! 508: old_rp = inw(ioaddr+READ_PTR); ! 509: old_wp = inw(ioaddr+WRITE_PTR); ! 510: status = inw(ioaddr+SCB_STATUS); ! 511: ack_cmd = SCB_ack(status); ! 512: ! 513: if (PRIV(dev)->started==0 && SCB_complete(status)) ! 514: { ! 515: #if NET_DEBUG > 4 ! 516: printk(KERN_DEBUG "%s: SCBcomplete event received\n", dev->name); ! 517: #endif ! 518: while (SCB_CUstat(status)==2) ! 519: status = inw_p(ioaddr+SCB_STATUS); ! 520: #if NET_DEBUG > 4 ! 521: printk(KERN_DEBUG "%s: CU went non-active (status = %08x)\n", dev->name, status); ! 522: #endif ! 523: PRIV(dev)->started=1; ! 524: outw_p(lp->tx_link,ioaddr+SCB_CBL); ! 525: outw_p(PRIV(dev)->rx_buf_start,ioaddr+SCB_RFA); ! 526: ack_cmd |= SCB_CUstart | SCB_RUstart; ! 527: } ! 528: else if (PRIV(dev)->started) ! 529: { ! 530: unsigned short txstatus; ! 531: txstatus = eexp_hw_lasttxstat(dev); ! 532: } ! 533: ! 534: if (SCB_rxdframe(status)) ! 535: { ! 536: eexp_hw_rx(dev); ! 537: } ! 538: ! 539: if ((PRIV(dev)->started&2)!=0 && SCB_RUstat(status)!=4) ! 540: { ! 541: printk(KERN_WARNING "%s: RU stopped status %04x, restarting...\n", ! 542: dev->name,status); ! 543: lp->stats.rx_errors++; ! 544: eexp_hw_rxinit(dev); ! 545: outw(PRIV(dev)->rx_buf_start,ioaddr+SCB_RFA); ! 546: ack_cmd |= SCB_RUstart; ! 547: } ! 548: else if (PRIV(dev)->started==1 && SCB_RUstat(status)==4) ! 549: PRIV(dev)->started|=2; ! 550: ! 551: outw(ack_cmd,ioaddr+SCB_CMD); ! 552: outb(0,ioaddr+SIGNAL_CA); ! 553: outw(old_rp,ioaddr+READ_PTR); ! 554: outw(old_wp,ioaddr+WRITE_PTR); ! 555: outb(SIRQ_en|irqrmap[irq],ioaddr+SET_IRQ); ! 556: dev->interrupt = 0; ! 557: #if NET_DEBUG > 6 ! 558: printk(KERN_DEBUG "%s: leaving eexp_irq()\n", dev->name); ! 559: #endif ! 560: return; ! 561: } ! 562: ! 563: /* ! 564: * Hardware access functions ! 565: */ ! 566: ! 567: /* ! 568: * Check all the receive buffers, and hand any received packets ! 569: * to the upper levels. Basic sanity check on each frame ! 570: * descriptor ! 571: */ ! 572: ! 573: static void eexp_hw_rx(struct device *dev) ! 574: { ! 575: struct net_local *lp = (struct net_local *)dev->priv; ! 576: unsigned short ioaddr = dev->base_addr; ! 577: unsigned short old_wp = inw(ioaddr+WRITE_PTR); ! 578: unsigned short old_rp = inw(ioaddr+READ_PTR); ! 579: unsigned short rx_block = lp->rx_first; ! 580: unsigned short boguscount = lp->num_rx_bufs; ! 581: ! 582: #if NET_DEBUG > 6 ! 583: printk(KERN_DEBUG "%s: eexp_hw_rx()\n", dev->name); ! 584: #endif ! 585: ! 586: while (outw(rx_block,ioaddr+READ_PTR),boguscount--) ! 587: { ! 588: unsigned short status = inw(ioaddr); ! 589: unsigned short rfd_cmd = inw(ioaddr); ! 590: unsigned short rx_next = inw(ioaddr); ! 591: unsigned short pbuf = inw(ioaddr); ! 592: unsigned short pkt_len; ! 593: ! 594: if (FD_Done(status)) ! 595: { ! 596: outw(pbuf,ioaddr+READ_PTR); ! 597: pkt_len = inw(ioaddr); ! 598: ! 599: if (rfd_cmd!=0x0000 || pbuf!=rx_block+0x16 ! 600: || (pkt_len & 0xc000)!=0xc000) ! 601: { ! 602: printk(KERN_WARNING "%s: Rx frame at %04x corrupted, status %04x, cmd %04x, " ! 603: "next %04x, pbuf %04x, len %04x\n",dev->name,rx_block, ! 604: status,rfd_cmd,rx_next,pbuf,pkt_len); ! 605: boguscount++; ! 606: continue; ! 607: } ! 608: else if (!FD_OK(status)) ! 609: { ! 610: lp->stats.rx_errors++; ! 611: if (FD_CRC(status)) ! 612: lp->stats.rx_crc_errors++; ! 613: if (FD_Align(status)) ! 614: lp->stats.rx_frame_errors++; ! 615: if (FD_Resrc(status)) ! 616: lp->stats.rx_fifo_errors++; ! 617: if (FD_DMA(status)) ! 618: lp->stats.rx_over_errors++; ! 619: if (FD_Short(status)) ! 620: lp->stats.rx_length_errors++; ! 621: } ! 622: else ! 623: { ! 624: struct sk_buff *skb; ! 625: pkt_len &= 0x3fff; ! 626: skb = dev_alloc_skb(pkt_len+16); ! 627: if (skb == NULL) ! 628: { ! 629: printk(KERN_WARNING "%s: Memory squeeze, dropping packet\n",dev->name); ! 630: lp->stats.rx_dropped++; ! 631: break; ! 632: } ! 633: skb->dev = dev; ! 634: skb_reserve(skb, 2); ! 635: outw(pbuf+10,ioaddr+READ_PTR); ! 636: insw(ioaddr,skb_put(skb,pkt_len),(pkt_len+1)>>1); ! 637: skb->protocol = eth_type_trans(skb,dev); ! 638: netif_rx(skb); ! 639: lp->stats.rx_packets++; ! 640: } ! 641: outw(rx_block,ioaddr+WRITE_PTR); ! 642: outw(0x0000,ioaddr); ! 643: outw(0x0000,ioaddr); ! 644: } ! 645: rx_block = rx_next; ! 646: } ! 647: outw(old_rp,ioaddr+READ_PTR); ! 648: outw(old_wp,ioaddr+WRITE_PTR); ! 649: } ! 650: ! 651: /* ! 652: * Hand a packet to the card for transmission ! 653: * If we get here, we MUST have already checked ! 654: * to make sure there is room in the transmit ! 655: * buffer region ! 656: */ ! 657: ! 658: static void eexp_hw_tx(struct device *dev, unsigned short *buf, unsigned short len) ! 659: { ! 660: struct net_local *lp = (struct net_local *)dev->priv; ! 661: unsigned short ioaddr = dev->base_addr; ! 662: unsigned short old_wp = inw(ioaddr+WRITE_PTR); ! 663: ! 664: outw(lp->tx_head,ioaddr+WRITE_PTR); ! 665: outw(0x0000,ioaddr); ! 666: outw(Cmd_INT|Cmd_Xmit,ioaddr); ! 667: outw(lp->tx_head+0x08,ioaddr); ! 668: outw(lp->tx_head+0x0e,ioaddr); ! 669: outw(0x0000,ioaddr); ! 670: outw(0x0000,ioaddr); ! 671: outw(lp->tx_head+0x08,ioaddr); ! 672: outw(0x8000|len,ioaddr); ! 673: outw(-1,ioaddr); ! 674: outw(lp->tx_head+0x16,ioaddr); ! 675: outw(0,ioaddr); ! 676: outsw(ioaddr,buf,(len+1)>>1); ! 677: outw(lp->tx_tail+0x0c,ioaddr+WRITE_PTR); ! 678: outw(lp->tx_head,ioaddr); ! 679: dev->trans_start = jiffies; ! 680: lp->tx_tail = lp->tx_head; ! 681: if (lp->tx_head==TX_BUF_START+((lp->num_tx_bufs-1)*TX_BUF_SIZE)) ! 682: lp->tx_head = TX_BUF_START; ! 683: else ! 684: lp->tx_head += TX_BUF_SIZE; ! 685: if (lp->tx_head != lp->tx_reap) ! 686: dev->tbusy = 0; ! 687: outw(old_wp,ioaddr+WRITE_PTR); ! 688: } ! 689: ! 690: /* ! 691: * Sanity check the suspected EtherExpress card ! 692: * Read hardware address, reset card, size memory and ! 693: * initialize buffer memory pointers. These should ! 694: * probably be held in dev->priv, in case someone has 2 ! 695: * differently configured cards in their box (Arghhh!) ! 696: */ ! 697: ! 698: static int eexp_hw_probe(struct device *dev, unsigned short ioaddr) ! 699: { ! 700: unsigned short hw_addr[3]; ! 701: int i; ! 702: unsigned char *chw_addr = (unsigned char *)hw_addr; ! 703: ! 704: printk("%s: EtherExpress at %#x, ",dev->name,ioaddr); ! 705: ! 706: hw_addr[0] = eexp_hw_readeeprom(ioaddr,2); ! 707: hw_addr[1] = eexp_hw_readeeprom(ioaddr,3); ! 708: hw_addr[2] = eexp_hw_readeeprom(ioaddr,4); ! 709: ! 710: /* Standard Address or Compaq LTE Address */ ! 711: if (!((hw_addr[2]==0x00aa && ((hw_addr[1] & 0xff00)==0x0000)) || ! 712: (hw_addr[2]==0x0080 && ((hw_addr[1] & 0xff00)==0x5F00)))) ! 713: { ! 714: printk("rejected: invalid address %04x%04x%04x\n", ! 715: hw_addr[2],hw_addr[1],hw_addr[0]); ! 716: return -ENODEV; ! 717: } ! 718: ! 719: dev->base_addr = ioaddr; ! 720: for ( i=0 ; i<6 ; i++ ) ! 721: dev->dev_addr[i] = chw_addr[5-i]; ! 722: ! 723: { ! 724: char irqmap[]={0, 9, 3, 4, 5, 10, 11, 0}; ! 725: char *ifmap[]={"AUI", "BNC", "10baseT"}; ! 726: enum iftype {AUI=0, BNC=1, TP=2}; ! 727: unsigned short setupval = eexp_hw_readeeprom(ioaddr,0); ! 728: ! 729: dev->irq = irqmap[setupval>>13]; ! 730: dev->if_port = !(setupval & 0x1000) ? AUI : ! 731: eexp_hw_readeeprom(ioaddr,5) & 0x1 ? TP : BNC; ! 732: ! 733: printk("IRQ %d, Interface %s, ",dev->irq,ifmap[dev->if_port]); ! 734: ! 735: outb(SIRQ_dis|irqrmap[dev->irq],ioaddr+SET_IRQ); ! 736: outb(0,ioaddr+SET_IRQ); ! 737: } ! 738: ! 739: dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL); ! 740: if (!dev->priv) ! 741: return -ENOMEM; ! 742: ! 743: memset(dev->priv, 0, sizeof(struct net_local)); ! 744: ! 745: eexp_hw_ASICrst(dev); ! 746: ! 747: { ! 748: unsigned short i586mso = 0x023e; ! 749: unsigned short old_wp,old_rp,old_a0,old_a1; ! 750: unsigned short a0_0,a1_0,a0_1,a1_1; ! 751: ! 752: old_wp = inw(ioaddr+WRITE_PTR); ! 753: old_rp = inw(ioaddr+READ_PTR); ! 754: outw(0x8000+i586mso,ioaddr+READ_PTR); ! 755: old_a1 = inw(ioaddr); ! 756: outw(i586mso,ioaddr+READ_PTR); ! 757: old_a0 = inw(ioaddr); ! 758: outw(i586mso,ioaddr+WRITE_PTR); ! 759: outw(0x55aa,ioaddr); ! 760: outw(i586mso,ioaddr+READ_PTR); ! 761: a0_0 = inw(ioaddr); ! 762: outw(0x8000+i586mso,ioaddr+WRITE_PTR); ! 763: outw(0x5a5a,ioaddr); ! 764: outw(0x8000+i586mso,ioaddr+READ_PTR); ! 765: a1_0 = inw(ioaddr); ! 766: outw(i586mso,ioaddr+READ_PTR); ! 767: a0_1 = inw(ioaddr); ! 768: outw(i586mso,ioaddr+WRITE_PTR); ! 769: outw(0x1234,ioaddr); ! 770: outw(0x8000+i586mso,ioaddr+READ_PTR); ! 771: a1_1 = inw(ioaddr); ! 772: ! 773: if ((a0_0 != a0_1) || (a1_0 != a1_1) || ! 774: (a1_0 != 0x5a5a) || (a0_0 != 0x55aa)) ! 775: { ! 776: printk("32k\n"); ! 777: PRIV(dev)->rx_buf_end = 0x7ff6; ! 778: PRIV(dev)->num_tx_bufs = 4; ! 779: } ! 780: else ! 781: { ! 782: printk("64k\n"); ! 783: PRIV(dev)->num_tx_bufs = 8; ! 784: PRIV(dev)->rx_buf_start = TX_BUF_START + (PRIV(dev)->num_tx_bufs*TX_BUF_SIZE); ! 785: PRIV(dev)->rx_buf_end = 0xfff6; ! 786: } ! 787: ! 788: outw(0x8000+i586mso,ioaddr+WRITE_PTR); ! 789: outw(old_a1,ioaddr); ! 790: outw(i586mso,ioaddr+WRITE_PTR); ! 791: outw(old_a0,ioaddr); ! 792: outw(old_wp,ioaddr+WRITE_PTR); ! 793: outw(old_rp,ioaddr+READ_PTR); ! 794: } ! 795: ! 796: if (net_debug) ! 797: printk(version); ! 798: dev->open = eexp_open; ! 799: dev->stop = eexp_close; ! 800: dev->hard_start_xmit = eexp_xmit; ! 801: dev->get_stats = eexp_stats; ! 802: dev->set_multicast_list = &eexp_set_multicast; ! 803: ether_setup(dev); ! 804: return 0; ! 805: } ! 806: ! 807: /* ! 808: * Read a word from eeprom location (0-63?) ! 809: */ ! 810: static unsigned short eexp_hw_readeeprom(unsigned short ioaddr, unsigned char location) ! 811: { ! 812: unsigned short cmd = 0x180|(location&0x7f); ! 813: unsigned short rval = 0,wval = EC_CS|i586_RST; ! 814: int i; ! 815: ! 816: outb(EC_CS|i586_RST,ioaddr+EEPROM_Ctrl); ! 817: for ( i=0x100 ; i ; i>>=1 ) ! 818: { ! 819: if (cmd&i) ! 820: wval |= EC_Wr; ! 821: else ! 822: wval &= ~EC_Wr; ! 823: ! 824: outb(wval,ioaddr+EEPROM_Ctrl); ! 825: outb(wval|EC_Clk,ioaddr+EEPROM_Ctrl); ! 826: eeprom_delay(); ! 827: outb(wval,ioaddr+EEPROM_Ctrl); ! 828: eeprom_delay(); ! 829: } ! 830: wval &= ~EC_Wr; ! 831: outb(wval,ioaddr+EEPROM_Ctrl); ! 832: for ( i=0x8000 ; i ; i>>=1 ) ! 833: { ! 834: outb(wval|EC_Clk,ioaddr+EEPROM_Ctrl); ! 835: eeprom_delay(); ! 836: if (inb(ioaddr+EEPROM_Ctrl)&EC_Rd) ! 837: rval |= i; ! 838: outb(wval,ioaddr+EEPROM_Ctrl); ! 839: eeprom_delay(); ! 840: } ! 841: wval &= ~EC_CS; ! 842: outb(wval|EC_Clk,ioaddr+EEPROM_Ctrl); ! 843: eeprom_delay(); ! 844: outb(wval,ioaddr+EEPROM_Ctrl); ! 845: eeprom_delay(); ! 846: return rval; ! 847: } ! 848: ! 849: /* ! 850: * Reap tx buffers and return last transmit status. ! 851: * if ==0 then either: ! 852: * a) we're not transmitting anything, so why are we here? ! 853: * b) we've died. ! 854: * otherwise, Stat_Busy(return) means we've still got some packets ! 855: * to transmit, Stat_Done(return) means our buffers should be empty ! 856: * again ! 857: */ ! 858: ! 859: static unsigned short eexp_hw_lasttxstat(struct device *dev) ! 860: { ! 861: struct net_local *lp = (struct net_local *)dev->priv; ! 862: unsigned short ioaddr = dev->base_addr; ! 863: unsigned short old_rp = inw(ioaddr+READ_PTR); ! 864: unsigned short old_wp = inw(ioaddr+WRITE_PTR); ! 865: unsigned short tx_block = lp->tx_reap; ! 866: unsigned short status; ! 867: ! 868: if (!test_bit(0,(void *)&dev->tbusy) && lp->tx_head==lp->tx_reap) ! 869: return 0x0000; ! 870: ! 871: do ! 872: { ! 873: outw(tx_block,ioaddr+READ_PTR); ! 874: status = inw(ioaddr); ! 875: if (!Stat_Done(status)) ! 876: { ! 877: lp->tx_link = tx_block; ! 878: outw(old_rp,ioaddr+READ_PTR); ! 879: outw(old_wp,ioaddr+WRITE_PTR); ! 880: return status; ! 881: } ! 882: else ! 883: { ! 884: lp->last_tx_restart = 0; ! 885: lp->stats.collisions += Stat_NoColl(status); ! 886: if (!Stat_OK(status)) ! 887: { ! 888: if (Stat_Abort(status)) ! 889: lp->stats.tx_aborted_errors++; ! 890: if (Stat_TNoCar(status) || Stat_TNoCTS(status)) ! 891: lp->stats.tx_carrier_errors++; ! 892: if (Stat_TNoDMA(status)) ! 893: lp->stats.tx_fifo_errors++; ! 894: } ! 895: else ! 896: lp->stats.tx_packets++; ! 897: } ! 898: if (tx_block == TX_BUF_START+((lp->num_tx_bufs-1)*TX_BUF_SIZE)) ! 899: lp->tx_reap = tx_block = TX_BUF_START; ! 900: else ! 901: lp->tx_reap = tx_block += TX_BUF_SIZE; ! 902: dev->tbusy = 0; ! 903: mark_bh(NET_BH); ! 904: } ! 905: while (lp->tx_reap != lp->tx_head); ! 906: ! 907: lp->tx_link = lp->tx_tail + 0x08; ! 908: outw(old_rp,ioaddr+READ_PTR); ! 909: outw(old_wp,ioaddr+WRITE_PTR); ! 910: ! 911: return status; ! 912: } ! 913: ! 914: /* ! 915: * This should never happen. It is called when some higher ! 916: * routine detects the CU has stopped, to try to restart ! 917: * it from the last packet we knew we were working on, ! 918: * or the idle loop if we had finished for the time. ! 919: */ ! 920: ! 921: static void eexp_hw_txrestart(struct device *dev) ! 922: { ! 923: struct net_local *lp = (struct net_local *)dev->priv; ! 924: unsigned short ioaddr = dev->base_addr; ! 925: ! 926: lp->last_tx_restart = lp->tx_link; ! 927: outw(lp->tx_link,ioaddr+SCB_CBL); ! 928: outw(SCB_CUstart,ioaddr+SCB_CMD); ! 929: outw(0,ioaddr+SCB_STATUS); ! 930: outb(0,ioaddr+SIGNAL_CA); ! 931: ! 932: { ! 933: unsigned short boguscount=50,failcount=5; ! 934: while (!inw(ioaddr+SCB_STATUS)) ! 935: { ! 936: if (!--boguscount) ! 937: { ! 938: if (--failcount) ! 939: { ! 940: printk(KERN_WARNING "%s: CU start timed out, status %04x, cmd %04x\n", ! 941: dev->name, inw(ioaddr+SCB_STATUS), inw(ioaddr+SCB_CMD)); ! 942: outw(lp->tx_link,ioaddr+SCB_CBL); ! 943: outw(0,ioaddr+SCB_STATUS); ! 944: outw(SCB_CUstart,ioaddr+SCB_CMD); ! 945: outb(0,ioaddr+SIGNAL_CA); ! 946: boguscount = 100; ! 947: } ! 948: else ! 949: { ! 950: printk(KERN_WARNING "%s: Failed to restart CU, resetting board...\n",dev->name); ! 951: eexp_hw_init586(dev); ! 952: dev->tbusy = 0; ! 953: mark_bh(NET_BH); ! 954: return; ! 955: } ! 956: } ! 957: } ! 958: } ! 959: } ! 960: ! 961: /* ! 962: * Writes down the list of transmit buffers into card ! 963: * memory. Initial separate, repeated transmits link ! 964: * them into a circular list, such that the CU can ! 965: * be constantly active, and unlink them as we reap ! 966: * transmitted packet buffers, so the CU doesn't loop ! 967: * and endlessly transmit packets. (Try hacking the driver ! 968: * to send continuous broadcast messages, say ARP requests ! 969: * on a subnet with Windows boxes running on Novell and ! 970: * LAN Workplace with EMM386. Amusing to watch them all die ! 971: * horribly leaving the Linux boxes up!) ! 972: */ ! 973: ! 974: static void eexp_hw_txinit(struct device *dev) ! 975: { ! 976: struct net_local *lp = (struct net_local *)dev->priv; ! 977: unsigned short ioaddr = dev->base_addr; ! 978: unsigned short old_wp = inw(ioaddr+WRITE_PTR); ! 979: unsigned short tx_block = TX_BUF_START; ! 980: unsigned short curtbuf; ! 981: ! 982: for ( curtbuf=0 ; curtbuf<lp->num_tx_bufs ; curtbuf++ ) ! 983: { ! 984: outw(tx_block,ioaddr+WRITE_PTR); ! 985: outw(0x0000,ioaddr); ! 986: outw(Cmd_INT|Cmd_Xmit,ioaddr); ! 987: outw(tx_block+0x08,ioaddr); ! 988: outw(tx_block+0x0e,ioaddr); ! 989: outw(0x0000,ioaddr); ! 990: outw(0x0000,ioaddr); ! 991: outw(tx_block+0x08,ioaddr); ! 992: outw(0x8000,ioaddr); ! 993: outw(-1,ioaddr); ! 994: outw(tx_block+0x16,ioaddr); ! 995: outw(0x0000,ioaddr); ! 996: tx_block += TX_BUF_SIZE; ! 997: } ! 998: lp->tx_head = TX_BUF_START; ! 999: lp->tx_reap = TX_BUF_START; ! 1000: lp->tx_tail = tx_block - TX_BUF_SIZE; ! 1001: lp->tx_link = lp->tx_tail + 0x08; ! 1002: lp->rx_buf_start = tx_block; ! 1003: outw(old_wp,ioaddr+WRITE_PTR); ! 1004: } ! 1005: ! 1006: /* is this a standard test pattern, or dbecker randomness? */ ! 1007: ! 1008: unsigned short rx_words[] = ! 1009: { ! 1010: 0xfeed,0xf00d,0xf001,0x0505,0x2424,0x6565,0xdeaf ! 1011: }; ! 1012: ! 1013: /* ! 1014: * Write the circular list of receive buffer descriptors to ! 1015: * card memory. Note, we no longer mark the end of the list, ! 1016: * so if all the buffers fill up, the 82586 will loop until ! 1017: * we free one. This may sound dodgy, but it works, and ! 1018: * it makes the error detection in the interrupt handler ! 1019: * a lot simpler. ! 1020: */ ! 1021: ! 1022: static void eexp_hw_rxinit(struct device *dev) ! 1023: { ! 1024: struct net_local *lp = (struct net_local *)dev->priv; ! 1025: unsigned short ioaddr = dev->base_addr; ! 1026: unsigned short old_wp = inw(ioaddr+WRITE_PTR); ! 1027: unsigned short rx_block = lp->rx_buf_start; ! 1028: ! 1029: lp->num_rx_bufs = 0; ! 1030: lp->rx_first = rx_block; ! 1031: do ! 1032: { ! 1033: lp->num_rx_bufs++; ! 1034: outw(rx_block,ioaddr+WRITE_PTR); ! 1035: outw(0x0000,ioaddr); ! 1036: outw(0x0000,ioaddr); ! 1037: outw(rx_block+RX_BUF_SIZE,ioaddr); ! 1038: outw(rx_block+0x16,ioaddr); ! 1039: outsw(ioaddr, rx_words, sizeof(rx_words)>>1); ! 1040: outw(0x8000,ioaddr); ! 1041: outw(-1,ioaddr); ! 1042: outw(rx_block+0x20,ioaddr); ! 1043: outw(0x0000,ioaddr); ! 1044: outw(0x8000|(RX_BUF_SIZE-0x20),ioaddr); ! 1045: lp->rx_last = rx_block; ! 1046: rx_block += RX_BUF_SIZE; ! 1047: } while (rx_block <= lp->rx_buf_end-RX_BUF_SIZE); ! 1048: ! 1049: outw(lp->rx_last+4,ioaddr+WRITE_PTR); ! 1050: outw(lp->rx_first,ioaddr); ! 1051: ! 1052: outw(old_wp,ioaddr+WRITE_PTR); ! 1053: } ! 1054: ! 1055: /* ! 1056: * Reset the 586, fill memory (including calls to ! 1057: * eexp_hw_[(rx)(tx)]init()) unreset, and start ! 1058: * the configuration sequence. We don't wait for this ! 1059: * to finish, but allow the interrupt handler to start ! 1060: * the CU and RU for us. We can't start the receive/ ! 1061: * transmission system up before we know that the ! 1062: * hardware is configured correctly ! 1063: */ ! 1064: static void eexp_hw_init586(struct device *dev) ! 1065: { ! 1066: struct net_local *lp = (struct net_local *)dev->priv; ! 1067: unsigned short ioaddr = dev->base_addr; ! 1068: ! 1069: #if NET_DEBUG > 6 ! 1070: printk("%s: eexp_hw_init586()\n", dev->name); ! 1071: #endif ! 1072: ! 1073: lp->started = 0; ! 1074: set_loopback; ! 1075: ! 1076: outb(SIRQ_dis|irqrmap[dev->irq],ioaddr+SET_IRQ); ! 1077: outb_p(i586_RST,ioaddr+EEPROM_Ctrl); ! 1078: udelay(2000); /* delay 20ms */ ! 1079: { ! 1080: unsigned long ofs; ! 1081: for (ofs = 0; ofs < lp->rx_buf_end; ofs += 32) { ! 1082: unsigned long i; ! 1083: outw_p(ofs, ioaddr+SM_PTR); ! 1084: for (i = 0; i < 16; i++) { ! 1085: outw_p(0, ioaddr+SM_ADDR(i<<1)); ! 1086: } ! 1087: } ! 1088: } ! 1089: ! 1090: outw_p(lp->rx_buf_end,ioaddr+WRITE_PTR); ! 1091: start_code[28] = (dev->flags & IFF_PROMISC)?(start_code[28] | 1):(start_code[28] & ~1); ! 1092: lp->promisc = dev->flags & IFF_PROMISC; ! 1093: /* We may die here */ ! 1094: outsw(ioaddr, start_code, sizeof(start_code)>>1); ! 1095: outw(CONF_HW_ADDR,ioaddr+WRITE_PTR); ! 1096: outsw(ioaddr,dev->dev_addr,3); ! 1097: eexp_hw_txinit(dev); ! 1098: eexp_hw_rxinit(dev); ! 1099: outw(0,ioaddr+WRITE_PTR); ! 1100: outw(1,ioaddr); ! 1101: outb(0,ioaddr+EEPROM_Ctrl); ! 1102: outw(0,ioaddr+SCB_CMD); ! 1103: outb(0,ioaddr+SIGNAL_CA); ! 1104: { ! 1105: unsigned short rboguscount=50,rfailcount=5; ! 1106: while (outw(0,ioaddr+READ_PTR),inw(ioaddr)) ! 1107: { ! 1108: if (!--rboguscount) ! 1109: { ! 1110: printk(KERN_WARNING "%s: i82586 reset timed out, kicking...\n", ! 1111: dev->name); ! 1112: outw(0,ioaddr+SCB_CMD); ! 1113: outb(0,ioaddr+SIGNAL_CA); ! 1114: rboguscount = 100; ! 1115: if (!--rfailcount) ! 1116: { ! 1117: printk(KERN_WARNING "%s: i82586 not responding, giving up.\n", ! 1118: dev->name); ! 1119: return; ! 1120: } ! 1121: } ! 1122: } ! 1123: } ! 1124: ! 1125: outw(CONF_LINK,ioaddr+SCB_CBL); ! 1126: outw(0,ioaddr+SCB_STATUS); ! 1127: outw(0xf000|SCB_CUstart,ioaddr+SCB_CMD); ! 1128: outb(0,ioaddr+SIGNAL_CA); ! 1129: { ! 1130: unsigned short iboguscount=50,ifailcount=5; ! 1131: while (!inw(ioaddr+SCB_STATUS)) ! 1132: { ! 1133: if (!--iboguscount) ! 1134: { ! 1135: if (--ifailcount) ! 1136: { ! 1137: printk(KERN_WARNING "%s: i82586 initialization timed out, status %04x, cmd %04x\n", ! 1138: dev->name, inw(ioaddr+SCB_STATUS), inw(ioaddr+SCB_CMD)); ! 1139: outw(CONF_LINK,ioaddr+SCB_CBL); ! 1140: outw(0,ioaddr+SCB_STATUS); ! 1141: outw(0xf000|SCB_CUstart,ioaddr+SCB_CMD); ! 1142: outb(0,ioaddr+SIGNAL_CA); ! 1143: iboguscount = 100; ! 1144: } ! 1145: else ! 1146: { ! 1147: printk(KERN_WARNING "%s: Failed to initialize i82586, giving up.\n",dev->name); ! 1148: return; ! 1149: } ! 1150: } ! 1151: } ! 1152: } ! 1153: ! 1154: outb(SIRQ_en|irqrmap[dev->irq],ioaddr+SET_IRQ); ! 1155: clear_loopback; ! 1156: lp->init_time = jiffies; ! 1157: #if NET_DEBUG > 6 ! 1158: printk("%s: leaving eexp_hw_init586()\n", dev->name); ! 1159: #endif ! 1160: return; ! 1161: } ! 1162: ! 1163: /* ! 1164: * completely reset the EtherExpress hardware. We will most likely get ! 1165: * an interrupt during this whether we want one or not. It is best, ! 1166: * therefore, to call this while we don't have a request_irq() on. ! 1167: */ ! 1168: ! 1169: static void eexp_hw_ASICrst(struct device *dev) ! 1170: { ! 1171: unsigned short ioaddr = dev->base_addr; ! 1172: unsigned short wrval = 0x0001,succount=0,boguscount=500; ! 1173: ! 1174: outb(SIRQ_dis|irqrmap[dev->irq],ioaddr+SET_IRQ); ! 1175: ! 1176: PRIV(dev)->started = 0; ! 1177: outb(ASIC_RST|i586_RST,ioaddr+EEPROM_Ctrl); ! 1178: while (succount<20) ! 1179: { ! 1180: if (wrval == 0xffff) ! 1181: wrval = 0x0001; ! 1182: outw(0,ioaddr+WRITE_PTR); ! 1183: outw(wrval,ioaddr); ! 1184: outw(0,ioaddr+READ_PTR); ! 1185: if (wrval++ == inw(ioaddr)) ! 1186: succount++; ! 1187: else ! 1188: { ! 1189: succount = 0; ! 1190: if (!boguscount--) ! 1191: { ! 1192: boguscount = 500; ! 1193: printk("%s: Having problems resetting EtherExpress ASIC, continuing...\n", ! 1194: dev->name); ! 1195: wrval = 0x0001; ! 1196: outb(ASIC_RST|i586_RST,ioaddr+EEPROM_Ctrl); ! 1197: } ! 1198: } ! 1199: } ! 1200: outb(i586_RST,ioaddr+EEPROM_Ctrl); ! 1201: } ! 1202: ! 1203: ! 1204: /* ! 1205: * Set or clear the multicast filter for this adaptor. ! 1206: * We have to do a complete 586 restart for this to take effect. ! 1207: * At the moment only promiscuous mode is supported. ! 1208: */ ! 1209: static void ! 1210: eexp_set_multicast(struct device *dev) ! 1211: { ! 1212: if ((dev->flags & IFF_PROMISC) != PRIV(dev)->promisc) ! 1213: eexp_hw_init586(dev); ! 1214: } ! 1215: ! 1216: ! 1217: /* ! 1218: * MODULE stuff ! 1219: */ ! 1220: #ifdef MODULE ! 1221: ! 1222: #define EEXP_MAX_CARDS 4 /* max number of cards to support */ ! 1223: #define NAMELEN 8 /* max length of dev->name (inc null) */ ! 1224: ! 1225: static char namelist[NAMELEN * EEXP_MAX_CARDS] = { 0, }; ! 1226: ! 1227: static struct device dev_eexp[EEXP_MAX_CARDS] = ! 1228: { ! 1229: { NULL, /* will allocate dynamically */ ! 1230: 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, express_probe }, ! 1231: }; ! 1232: ! 1233: int irq[EEXP_MAX_CARDS] = {0, }; ! 1234: int io[EEXP_MAX_CARDS] = {0, }; ! 1235: ! 1236: /* Ideally the user would give us io=, irq= for every card. If any parameters ! 1237: * are specified, we verify and then use them. If no parameters are given, we ! 1238: * autoprobe for one card only. ! 1239: */ ! 1240: int init_module(void) ! 1241: { ! 1242: int this_dev, found = 0; ! 1243: ! 1244: for (this_dev = 0; this_dev < EEXP_MAX_CARDS; this_dev++) { ! 1245: struct device *dev = &dev_eexp[this_dev]; ! 1246: dev->name = namelist + (NAMELEN*this_dev); ! 1247: dev->irq = irq[this_dev]; ! 1248: dev->base_addr = io[this_dev]; ! 1249: if (io[this_dev] == 0) { ! 1250: if (this_dev) break; ! 1251: printk(KERN_NOTICE "eexpress.c: Module autoprobe not recommended, give io=xx.\n"); ! 1252: } ! 1253: if (register_netdev(dev) != 0) { ! 1254: printk(KERN_WARNING "eexpress.c: Failed to register card at 0x%x.\n", io[this_dev]); ! 1255: if (found != 0) return 0; ! 1256: return -ENXIO; ! 1257: } ! 1258: found++; ! 1259: } ! 1260: return 0; ! 1261: } ! 1262: ! 1263: void cleanup_module(void) ! 1264: { ! 1265: int this_dev; ! 1266: ! 1267: for (this_dev = 0; this_dev < EEXP_MAX_CARDS; this_dev++) { ! 1268: struct device *dev = &dev_eexp[this_dev]; ! 1269: if (dev->priv != NULL) { ! 1270: kfree(dev->priv); ! 1271: dev->priv = NULL; ! 1272: release_region(dev->base_addr, EEXP_IO_EXTENT); ! 1273: unregister_netdev(dev); ! 1274: } ! 1275: } ! 1276: } ! 1277: #endif ! 1278: ! 1279: /* ! 1280: * Local Variables: ! 1281: * c-file-style: "linux" ! 1282: * tab-width: 8 ! 1283: * compile-command: "gcc -D__KERNEL__ -I/discs/bibble/src/linux-1.3.69/include -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -fno-strength-reduce -pipe -m486 -DCPU=486 -DMODULE -c 3c505.c" ! 1284: * End: ! 1285: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.