if (pDrvCtrl->byteAccess)	SYS_OUT_CHAR (pDrvCtrl, ENE_DCON, DCON_BSIZE1 | DCON_BUS_8 			| DCON_LOOPBK_OFF);    else	SYS_OUT_CHAR (pDrvCtrl, ENE_DCON, DCON_BSIZE1 | DCON_BUS16 			| DCON_LOOPBK_OFF);    SYS_ENET_ADDR_GET (pDrvCtrl);    /* 3. clear Remote Byte Count Register */    SYS_OUT_CHAR (pDrvCtrl, ENE_RBCR0, 0x00);    SYS_OUT_CHAR (pDrvCtrl, ENE_RBCR1, 0x00);    /* 4. initialize Receive Configuration Register */    /* Always accept broadcast packets. */    rxFilter = RCON_BROAD;    /* Set multicast mode if it's asked for. */    if (END_MULTI_LST_CNT(&pDrvCtrl->endObj) > 0)	{	rxFilter |= RCON_GROUP;	}    ENDLOGMSG (("\tMulticast mode %s\n",	    (rxFilter & RCON_GROUP) ? "on" : "off",	    0, 0, 0, 0, 0));    /* Set promiscuous mode if it's asked for. */    if (END_FLAGS_GET(&pDrvCtrl->endObj) & IFF_PROMISC)	{	rxFilter |= RCON_PROM;	}    ENDLOGMSG (("\tPromiscuous mode %s\n",	    (rxFilter & RCON_PROM) ? "on" : "off",	    0, 0, 0, 0, 0));    ENDLOGMSG (("\tsetting rxFilter = 0x%x\n", rxFilter,2,3,4,5,6));    SYS_OUT_CHAR (pDrvCtrl, ENE_RCON, rxFilter);    /* 5. place the ENE in LOOPBACK mode 1 or 2 */    SYS_OUT_CHAR (pDrvCtrl, ENE_TCON, TCON_LB1);    /* 6. initialize Receive Buffer Ring */    SYS_OUT_CHAR (pDrvCtrl, ENE_RSTART, NE2000_PSTART);    SYS_OUT_CHAR (pDrvCtrl, ENE_RSTOP, NE2000_PSTOP);    SYS_OUT_CHAR (pDrvCtrl, ENE_BOUND, NE2000_PSTART);    /* 7. clear Interrupt Status Register */    SYS_OUT_CHAR (pDrvCtrl, ENE_INTSTAT, (char)0xff);    /* 8. initialize Interrupt Mask Register */    pDrvCtrl->imask = 0;    SYS_OUT_CHAR (pDrvCtrl, ENE_INTMASK, pDrvCtrl->imask);    /* 9. program Command Register for page 1 */    SYS_OUT_CHAR (pDrvCtrl, ENE_CMD, CMD_PAGE1 | CMD_STOP);    /* i) initialize physical address registers */    SYS_OUT_CHAR (pDrvCtrl, ENE_STA0, pDrvCtrl->enetAddr[0]);    SYS_OUT_CHAR (pDrvCtrl, ENE_STA1, pDrvCtrl->enetAddr[1]);    SYS_OUT_CHAR (pDrvCtrl, ENE_STA2, pDrvCtrl->enetAddr[2]);    SYS_OUT_CHAR (pDrvCtrl, ENE_STA3, pDrvCtrl->enetAddr[3]);    SYS_OUT_CHAR (pDrvCtrl, ENE_STA4, pDrvCtrl->enetAddr[4]);    SYS_OUT_CHAR (pDrvCtrl, ENE_STA5, pDrvCtrl->enetAddr[5]);    ENDLOGMSG (("enet addr %02x:%02x:%02x:%02x:%02x:%02x\n",		pDrvCtrl->enetAddr[0] & 0xff,		pDrvCtrl->enetAddr[1] & 0xff,		pDrvCtrl->enetAddr[2] & 0xff,		pDrvCtrl->enetAddr[3] & 0xff,		pDrvCtrl->enetAddr[4] & 0xff,		pDrvCtrl->enetAddr[5] & 0xff));    /* ii) initialize multicast address registers */    ne2000AddrFilterSet (pDrvCtrl);    SYS_OUT_CHAR (pDrvCtrl, ENE_MAR0, pDrvCtrl->mcastFilter[0]);    SYS_OUT_CHAR (pDrvCtrl, ENE_MAR1, pDrvCtrl->mcastFilter[1]);    SYS_OUT_CHAR (pDrvCtrl, ENE_MAR2, pDrvCtrl->mcastFilter[2]);    SYS_OUT_CHAR (pDrvCtrl, ENE_MAR3, pDrvCtrl->mcastFilter[3]);    SYS_OUT_CHAR (pDrvCtrl, ENE_MAR4, pDrvCtrl->mcastFilter[4]);    SYS_OUT_CHAR (pDrvCtrl, ENE_MAR5, pDrvCtrl->mcastFilter[5]);    SYS_OUT_CHAR (pDrvCtrl, ENE_MAR6, pDrvCtrl->mcastFilter[6]);    SYS_OUT_CHAR (pDrvCtrl, ENE_MAR7, pDrvCtrl->mcastFilter[7]);#ifdef DEBUG   ENDLOGMSG ((("Setting multicast addresses to:\n"),1,2,3,4,5,6));    sprintf(buf, "enet mcast %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",	    pDrvCtrl->mcastFilter[0] & 0xff,	    pDrvCtrl->mcastFilter[1] & 0xff,	    pDrvCtrl->mcastFilter[2] & 0xff,	    pDrvCtrl->mcastFilter[3] & 0xff,	    pDrvCtrl->mcastFilter[4] & 0xff,	    pDrvCtrl->mcastFilter[5] & 0xff,	    pDrvCtrl->mcastFilter[6] & 0xff,	    pDrvCtrl->mcastFilter[7] & 0xff);    ENDLOGMSG (((buf),1,2,3,4,5,6));#endif /* DEBUG */    /* iii) initialize current page pointer */    SYS_OUT_CHAR (pDrvCtrl, ENE_CURR, NE2000_PSTART + 1);    pDrvCtrl->nextPacket = NE2000_PSTART + 1;    /* set memory parameters */    SYS_OUT_CHAR (pDrvCtrl, ENE_CMD, CMD_NODMA | CMD_PAGE2 | CMD_STOP);    /*     * HELP: DP 83905 manual says thas ENE_ENH is address counter lower,     * ENE_BLOCK is address counter upper.  not wait states, or anything     * else. What is with these comments?     */    SYS_OUT_CHAR (pDrvCtrl, ENE_ENH, 0x00);       /* 0 wait states */    SYS_OUT_CHAR (pDrvCtrl, ENE_BLOCK, 0x00);     /* 0x00xxxx */    /* 10. put the ENE in START mode */    SYS_OUT_CHAR (pDrvCtrl, ENE_CMD, CMD_NODMA | CMD_PAGE0 | CMD_START);    /* 11. initialize Transmit Configuration Register */    SYS_OUT_CHAR (pDrvCtrl, ENE_TCON, TCON_NORMAL);    ENDLOGMSG (("ne2000Config: done\n", 0, 0, 0, 0, 0, 0));    pDrvCtrl->imask = ((pDrvCtrl->flags & END_POLLING) ? 0 : NE2000_ALL_INTS);    /* Only actually enable interrupts if not polling */    if (intEnable)	SYS_OUT_CHAR (pDrvCtrl, ENE_INTMASK, pDrvCtrl->imask);    }/********************************************************************************* ne2000OverwriteRecover - recover from receive buffer ring overflow** This procedure is mandated by National Semiconductor as the only safe* way to recover from an Overwrite Warning Error.  The first two steps* of their procedure, reading the Command Register and stopping the NIC,* were accomplished in the interrupt handler.  The rest occurs here.** This routine is scheduled to run in the net task since it must delay* to allow the STOP command to take effect.*/LOCAL void ne2000OverwriteRecover    (    NE2000END_DEVICE  *pDrvCtrl,    UCHAR cmdStatus    )    {    UCHAR stat;    BOOL  reSend;    ENDLOGMSG (("ne2000OverwriteRecover: enter (flags=%x, imask=%x)\n",		pDrvCtrl->flags,pDrvCtrl->imask,0,0,0,0));    /* We shouldn't get here without the OVERWRITE flags set */    if (!(pDrvCtrl->flags & END_OVERWRITE2))	{	ENDLOGMSG (("ne2000OverwriteRecover: bad flags\n",		    0,0,0,0,0,0));#ifdef DEBUG	SYS_OUT_CHAR (pDrvCtrl, ENE_INTMASK, 0);	taskSuspend (0);#else	return;#endif	}    /* 1. read the TXP bit in the command register (already in cmdStatus) */    /* 2. issue the STOP command (done in the interrupt handler) */    /* 3. delay at least 1.6 milliseconds (1/625 second) */    taskDelay ((sysClkRateGet() + 624)/ 625);    /* we are now supposedly sure the NIC is stopped */    /* 4. clear Remote Byte Count Register */    SYS_OUT_CHAR (pDrvCtrl, ENE_RBCR0, 0x00);    SYS_OUT_CHAR (pDrvCtrl, ENE_RBCR1, 0x00);    /* 5. read the stored value of the TXP bit (in cmdStatus) */    if ((cmdStatus & CMD_TXP) == 0)        reSend = FALSE;    else        {	SYS_IN_CHAR (pDrvCtrl, ENE_INTSTAT, &stat);        if ((stat & (ISTAT_PTX | ISTAT_TXE)) == 0)	    {	    /* transmit was in progress but probably deferring */            reSend = TRUE;	    }        else	    {            /* transmit was completed (probably), don't repeat it */            reSend = FALSE;	    }        }    /* 6. place the NIC in loopback mode */    SYS_OUT_CHAR (pDrvCtrl, ENE_TCON, TCON_LB1);    /* 7. issue the START command to the NIC */    SYS_OUT_CHAR (pDrvCtrl, ENE_CMD, CMD_NODMA | CMD_PAGE0 | CMD_START);    /* 8. remove one or more packets from the receive buffer ring */    /* clear overwrite flag */    pDrvCtrl->flags &= ~END_OVERWRITE;    pDrvCtrl->current = ne2000GetCurr (pDrvCtrl);    ne2000HandleRcvInt (pDrvCtrl);    /* 9. reset the overwrite warning bit in the ISR */    /* reset all active interrupt conditions */    SYS_IN_CHAR (pDrvCtrl, ENE_INTSTAT, &stat);    SYS_OUT_CHAR (pDrvCtrl, ENE_INTSTAT, stat);    /* 10. take the NIC out of loopback */    SYS_OUT_CHAR (pDrvCtrl, ENE_TCON, 0x00);    /* 10a. re-enable all device interrupts */    pDrvCtrl->imask = NE2000_ALL_INTS;    SYS_OUT_CHAR (pDrvCtrl, ENE_INTMASK, pDrvCtrl->imask);    /* 11. if need to resend, do so, otherwise if anything queued, send that */    pDrvCtrl->flags &= ~END_OVERWRITE2;    if (reSend)        SYS_OUT_CHAR (pDrvCtrl, ENE_CMD, CMD_TXP);    else	muxTxRestart (&pDrvCtrl->endObj);    ENDLOGMSG (("ne2000OverwriteRecover: done (flags=%x, imask=%x)\n",		pDrvCtrl->flags,pDrvCtrl->imask,0,0,0,0));    }/********************************************************************************* ne2000Int - handle controller interrupt** This routine is called at interrupt level in response to an interrupt from* the controller.** RETURNS: N/A.*/LOCAL void ne2000Int    (    NE2000END_DEVICE  *pDrvCtrl    )    {    UCHAR val;    UCHAR intStat;    UCHAR txStat;    UCHAR rxStat;    pDrvCtrl->stats.interrupts++;    /* Read status and Acknowlegde interrupt */    SYS_IN_CHAR (pDrvCtrl, ENE_INTSTAT, &intStat);    intStat &= pDrvCtrl->imask;    SYS_OUT_CHAR (pDrvCtrl, ENE_INTSTAT, intStat);    /* Get TX and RX status */    SYS_IN_CHAR (pDrvCtrl, ENE_TSTAT, &txStat);    SYS_IN_CHAR (pDrvCtrl, ENE_RSTAT, &rxStat);    ENDLOGMSG (("ne2000Int: intStat=%02x imask=%02x txStat=%02x rxStat=%02x\n",		intStat, pDrvCtrl->imask, txStat, rxStat, 0, 0));    /* Update count registers */    SYS_IN_CHAR (pDrvCtrl, ENE_COLCNT, &val);    pDrvCtrl->stats.collisions += val;    SYS_IN_CHAR (pDrvCtrl, ENE_ALICNT, &val);    pDrvCtrl->stats.aligns += val;    SYS_IN_CHAR (pDrvCtrl, ENE_CRCCNT, &val);    pDrvCtrl->stats.crcs += val;    SYS_IN_CHAR (pDrvCtrl, ENE_MPCNT, &val);    pDrvCtrl->stats.missed += val;    /*     * enable interrupts, clear receive and/or transmit interrupts, and clear     * any errors that may be set.     */    /* Check for errors */    if (intStat & ISTAT_OVW) /* Overwrite */        {	UCHAR cmdStat;	END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);	if (!(pDrvCtrl->flags & END_OVERWRITE2))	    {	    pDrvCtrl->flags |= (END_OVERWRITE | END_OVERWRITE2);	    pDrvCtrl->lastError.errCode = END_ERR_WARN;	    pDrvCtrl->lastError.pMesg = "Overwrite";	    netJobAdd ((FUNCPTR) muxError, (int) &pDrvCtrl->endObj,		       (int) &pDrvCtrl->lastError,		       0, 0, 0);	    pDrvCtrl->stats.overwrite++;	    SYS_IN_CHAR (pDrvCtrl, ENE_COLCNT, &cmdStat);	    SYS_OUT_CHAR (pDrvCtrl, ENE_CMD, CMD_NODMA | CMD_PAGE0 | CMD_STOP);	    ENDLOGMSG (("ne2000Int: overwrite detected\n",			0, 0, 0, 0, 0, 0));	    netJobAdd ((FUNCPTR) ne2000OverwriteRecover, (int) pDrvCtrl,			      cmdStat, 0, 0, 0);	    }	/* no further interrupt processing */	pDrvCtrl->imask = 0;	SYS_OUT_CHAR (pDrvCtrl, ENE_INTMASK, pDrvCtrl->imask);	return;        }    /* Receive handling */    if (intStat & ISTAT_RXE) /* Receive-error */        {	if (!pDrvCtrl->lastIntError)	    {	    END_ERR_ADD (&pDrvCtrl->endObj, MIB2_IN_ERRS, +1);	    pDrvCtrl->lastError.errCode = END_ERR_WARN;	    pDrvCtrl->lastError.pMesg = "receive error";	    netJobAdd ((FUNCPTR) muxError, (int) &pDrvCtrl->endObj,		       (int) &pDrvCtrl->lastError,		       0, 0, 0);	    }	++pDrvCtrl->lastIntError;        pDrvCtrl->stats.rerror++;        if (rxStat & RSTAT_OVER)            pDrvCtrl->stats.overruns++;        if (rxStat & RSTAT_DIS)            pDrvCtrl->stats.disabled++;        if (rxStat & RSTAT_DFR)            pDrvCtrl->stats.deferring++;        }    if (intStat & ISTAT_TXE)    /* Transmit error-packet not sent */        {	if (!pDrvCtrl->lastIntError)	    {	    END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_ERRS,  +1);	    END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_UCAST, -1);	    pDrvCtrl->lastError.errCode = END_ERR_WARN;	    pDrvCtrl->lastError.pMesg = "transmit error";	    netJobAdd ((FUNCPTR) muxError, (int) &pDrvCtrl->endObj,		       (int) &pDrvCtrl->lastError,		       0, 0, 0);	    }	++pDrvCtrl->lastIntError;        pDrvCtrl->stats.terror++;        if (txStat & TSTAT_ABORT)            {            pDrvCtrl->stats.aborts++;            pDrvCtrl->stats.collisions += 16;            }        if (txStat & TSTAT_UNDER)            pDrvCtrl->stats.underruns++;        }    /* Transmit handling */    if (intStat & ISTAT_PTX)    /* Transmit-packet sent */        {	END_ERR_ADD (&pDrvCtrl->endObj, MIB2_OUT_ERRS, +1);        if (txStat & TSTAT_CDH)            pDrvCtrl->stats.heartbeats++;        if (txStat & TSTAT_OWC)            pDrvCtrl->stats.outofwindow++;        if (txStat & TSTAT_PTX)            pDrvCtrl->stats.tnoerror++;        }    /* Check for lack of errors */    if (!(intStat & (ISTAT_RXE | ISTAT_TXE)))	pDrvCtrl->lastIntError = 0;    /* Have netTask handle any input packets */    if (intStat & ISTAT_PRX)        {        pDrvCtrl->current = ne2000GetCurr (pDrvCtrl);	ENDLOGMSG(("ne2000Int: input packet (flags=%x, current=%d)\n",		   pDrvCtrl->flags, pDrvCtrl->current, 0, 0, 0, 0));        if (!(pDrvCtrl->flags & END_RECV_HANDLING_FLAG))            {	    /* Disable RX int */	    pDrvCtrl->imask &= ~IM_PRXE;	    SYS_OUT_CHAR (pDrvCtrl, ENE_INTMASK, pDrvCtrl->imask);            pDrvCtrl->flags |= END_RECV_HANDLING_FLAG;            (void)netJobAdd ((FUNCPTR)ne2000HandleRcvInt, (int)pDrvCtrl,                              0,0,0,0);            }        }    /* Check for transmit complete */    if ((intStat & (ISTAT_TXE | ISTAT_PTX)) != 0)	{	pDrvCtrl->flags &= ~END_TX_IN_PROGRESS;	ENDLOGMSG (("ne2000Int: Tx complete, blocked=%d\n",		    (pDrvCtrl->flags & END_TX_BLOCKED) ? 1 : 0,0,0,0,0,0));	if (pDrvCtrl->flags & END_TX_BLOCKED)	    {	    /* Disable TX ints */	    pDrvCtrl->imask &= ~(IM_TXEE | IM_PTXE);	    SYS_OUT_CHAR (pDrvCtrl, ENE_INTMASK, pDrvCtrl->imask);	    pDrvCtrl->flags &= ~END_TX_BLOCKED;	    netJobAdd ((FUNCPTR)muxTxRestart, (int)&pDrvCtrl->endObj,		       0, 0, 0, 0);	    }	}    /* Flush the write pipe */    CACHE_PIPE_FLUSH ();    }/********************************************************************************* ne2000HandleRcvInt - task level interrupt service for input packets** This routine is called at task level indirectly by the interrupt* service routine to do any message received processing.** RETURNS: N/A.*/LOCAL void ne2000HandleRcvInt    (    NE2000END_DEVICE *pDrvCtrl