else            isrClear = EMAC_ISR_TX_INTS | EMAC_ISR_DB0;        EMAC_REG_WRITE(pDrvCtrl, EMAC_ISR, isrClear);        }    /*     * Check to see if there was a RX error.  Clear the status bits for the     * RX error.  Keep count of these errors in the main device structure.     *     * Note that non-zero values of EMAC_ISR_RX_INTS are used primarily     * for debugging.  When EMAC_ISR_RX_INTS is zero, some compilers     * may warn about an always-false conditional expression.     */    if (isrReg & EMAC_ISR_RX_INTS)        {        pDrvCtrl->intErrorRX++;        EMAC_REG_WRITE(pDrvCtrl, EMAC_ISR, EMAC_ISR_RX_INTS);        }    return;    }/********************************************************************************* ibmEmacTxeobInt - handle controller TX end-of-buffer interrupt** This routine is called at interrupt level in response to an interrupt from* the MAL.*/LOCAL void ibmEmacTxeobInt    (    EMAC_DRV_CTRL *   pDrvCtrl    )    {    DRV_LOG (DRV_DEBUG_TX, "EMAC TX EOB int\n", 1, 2, 3, 4, 5, 6);    /* Start the cleanup job */    if ((pDrvCtrl->localFlags & EMAC_TX_CLEAN_RUNNING) == 0)        {        if (netTaskId && netTaskId != ERROR)            {            pDrvCtrl->localFlags |= EMAC_TX_CLEAN_RUNNING;            netJobAdd((FUNCPTR)ibmEmacSendCleanup, (int)pDrvCtrl, 0, 0, 0, 0);            }        else            ibmEmacSendCleanup(pDrvCtrl);        }    if (pDrvCtrl->localFlags & EMAC_TX_BLOCKED)        {        DRV_LOG (DRV_DEBUG_ERROR, "TX blocked.  Call muxRestart\n",                                  1 , 2, 3, 4, 5, 6);        pDrvCtrl->localFlags &= ~EMAC_TX_BLOCKED;        if (netTaskId && netTaskId != ERROR)            netJobAdd((FUNCPTR)muxTxRestart, (int)&pDrvCtrl->end, 0, 0, 0, 0);        else            muxTxRestart(&pDrvCtrl->end);        }    return;    }/********************************************************************************* ibmEmacWdRestart - handle restart in case MUX blocks or driver fails** This routine is called at interrupt level (WatchDog) in case the MUX is blocked* or the hardware fails.*/LOCAL void ibmEmacWdRestart    (    EMAC_DRV_CTRL *   pDrvCtrl    ){    DRV_LOG(DRV_DEBUG_ERROR, "INFO: RestartWatchdog kicks driver\n", 1, 2, 3, 4, 5, 6);    /* Now that status from the packet just transmitted has been copied back     * to the main TX ring, it is safe to allow another TX operation. */	/* semGive (pDrvCtrl->txSem2nd); */    /* Start the cleanup job */    if ((pDrvCtrl->localFlags & EMAC_TX_CLEAN_RUNNING) == 0)	{        pDrvCtrl->localFlags |= EMAC_TX_CLEAN_RUNNING;        if ( netJobAdd((FUNCPTR)ibmEmacSendCleanup, (int)pDrvCtrl, 0, 0, 0, 0) == ERROR )			DRV_LOG (DRV_DEBUG_ERROR, "FATAL: netJobAdd ibmEmacSendCleanup failed\n",1,2,3,4,5,6); 	}	/* check if TX is/was blocked, unblock it*/    if (pDrvCtrl->localFlags & EMAC_TX_BLOCKED)	{		DRV_LOG (DRV_DEBUG_ERROR, "INFO: Watchdog expired: MUX blocked, unblocking, calling muxRestart\n",1,2,3,4,5,6);        pDrvCtrl->localFlags &= ~EMAC_TX_BLOCKED;        if ( netJobAdd((FUNCPTR)muxTxRestart, (int)&pDrvCtrl->end, 0, 0, 0, 0) == ERROR )			DRV_LOG (DRV_DEBUG_ERROR, "FATAL: netJobAdd muxTxRestart failed\n",1,2,3,4,5,6);	}    return;}/********************************************************************************* ibmEmacRxeobInt - handle controller RX end-of-buffer interrupt** This routine is called at interrupt level in response to an interrupt from* the MAL.*/LOCAL void ibmEmacRxeobInt    (    EMAC_DRV_CTRL *   pDrvCtrl    )    {    DRV_LOG (DRV_DEBUG_INT, "EMAC RX EOB int: 0x%x 0x%x\n", pDrvCtrl->indexRxD,        (pDrvCtrl->pRxDesc + pDrvCtrl->indexRxD)->statusControl, 3, 4, 5, 6);    /*     * If tnetTask is running and not already handling received packets     * for this interface, arrange to process the received packets at     * task level.     */    if (!(pDrvCtrl->localFlags & EMAC_HANDLE_RX_RUNNING))        {        if (netTaskId && netTaskId != ERROR)            {            pDrvCtrl->localFlags |= EMAC_HANDLE_RX_RUNNING;            netJobAdd((FUNCPTR)ibmEmacHandleRecvInt, (int)pDrvCtrl,FALSE,0,0,0);            }        else            ibmEmacHandleRecvInt(pDrvCtrl, FALSE);        }    return;    }/********************************************************************************* ibmEmacTxdeInt - handle TX descriptor error interrupt** This routine is called at interrupt level in response to an interrupt from* the MAL.*/LOCAL void ibmEmacTxdeInt    (    EMAC_DRV_CTRL *   pDrvCtrl    )    {    DRV_LOG (DRV_DEBUG_ERROR, "EMAC TX DE int\n", 1, 2, 3, 4, 5, 6);    /*     * The send routines check to be sure that enough TX descriptors are     * available to send a packet, and initialize all descriptors required     * to transmit the packet before kicking the transmitter.     * This interrupt should never occur.  If it does, restart.     */    ibmEmacRestart(pDrvCtrl);    return;    }/********************************************************************************* ibmEmacRxdeInt - handle RX descriptor error interrupt** This routine is called at interrupt level in response to an interrupt from* the MAL.*/LOCAL void ibmEmacRxdeInt    (    EMAC_DRV_CTRL *   pDrvCtrl    )    {    DRV_LOG (DRV_DEBUG_ERROR, "EMAC RX DE int\n", 1, 2, 3, 4, 5, 6);    /*     * Start ibmEmacHandleRecvInt running (at task level if tnetTask     * is available), and tell it to restart the RX channel when it is     * finished because MAL automatically disables the channel when     * this interrupt occurred.     */    if (netTaskId && netTaskId != ERROR)        {        pDrvCtrl->localFlags |= EMAC_HANDLE_RX_RUNNING;        netJobAdd((FUNCPTR)ibmEmacHandleRecvInt, (int)pDrvCtrl, TRUE,0,0,0);        }    else        ibmEmacHandleRecvInt(pDrvCtrl, TRUE);    return;    }/********************************************************************************* ibmEmacMalSerrInt - handle MAL SERR (system error) interrupt** This routine is called at interrupt level in response to an interrupt from* the controller.*/LOCAL void ibmEmacMalSerrInt    (    EMAC_DRV_CTRL *   pDrvCtrl    )    {    DRV_LOG (DRV_DEBUG_ERROR, "EMAC-MAL SERR int\n", 1, 2, 3, 4, 5, 6);    /* MAL should have already reset the channel */    /* SERR is fatal, just restart the EMAC */    pDrvCtrl->lastError.errCode = END_ERR_RESET;    pDrvCtrl->lastError.pMesg = "MAL System Error.";    if (netTaskId && netTaskId != ERROR)        netJobAdd ((FUNCPTR)muxError, (int)&pDrvCtrl->end,                   (int)&pDrvCtrl->lastError,                   0, 0, 0);    else        muxError (&pDrvCtrl->end, &pDrvCtrl->lastError);    END_FLAGS_CLR (&pDrvCtrl->end, (IFF_UP | IFF_RUNNING));    ibmEmacRestart(pDrvCtrl);    return;    }/********************************************************************************* ibmEmacHandleRecvInt - task level interrupt service for received packets** This routine is called at task level indirectly by the interrupt* service routine to process received messages.** The double loop is to protect against a race condition where the interrupt* code sees EMAC_HANDLE_RX_RUNNING as TRUE, but it is then turned off by the* task code.*/LOCAL void ibmEmacHandleRecvInt    (    EMAC_DRV_CTRL *   pDrvCtrl,    int               resetChan    )    {    MAL_BD * pRxDesc;    /*     * Keep getting RX descriptors and calling the receive function until     * there are no more ready to handle.     */    pRxDesc = (MAL_BD *)NULL;    do        {        pDrvCtrl->localFlags |= EMAC_HANDLE_RX_RUNNING;        while ((pRxDesc = ibmEmacRecvDescGet(pDrvCtrl)) != (MAL_BD *)NULL)            {            ibmEmacRecv(pDrvCtrl, pRxDesc);            };        pDrvCtrl->localFlags &= ~EMAC_HANDLE_RX_RUNNING;        }    while (ibmEmacRecvDescGet(pDrvCtrl) != NULL);    /*     * This function may have been run as a result of an RX descriptor error     * interrupt (RXDE).  If so, the RX channel was disabled by MAL and must     * be re-activated for RX operation to continue. When a channel is     * reactivated, it begins to process descriptors from the beginning of the     * descriptor table, so the current RX descriptor index must be reset.     */    if (resetChan == TRUE)        {        pDrvCtrl->indexRxD = 0;        malChannelActivate(pDrvCtrl->pMalData, MAL_RX_TYPE,                           pDrvCtrl->rxChn0MalChannel);        }    }/********************************************************************************* ibmEmacRecvDescGet - get the next receive descriptor** Returns a ptr to next RX descriptor to process, or NULL if none are ready.*/LOCAL MAL_BD * ibmEmacRecvDescGet    (    EMAC_DRV_CTRL *   pDrvCtrl    )    {    volatile MAL_BD *            pRxDesc;    /* Point to the next RX descriptor */    pRxDesc = pDrvCtrl->pRxDesc + pDrvCtrl->indexRxD;    /*     * If the descriptor says the buffer is no longer empty, return the     * pointer to the descriptor, else return NULL (buffer is still empty).     */    if ((pRxDesc->statusControl & MAL_RX_CTRL_EMPTY) == 0)        {        DRV_LOG (DRV_DEBUG_RX, "RX desc got data\n", 1, 2, 3, 4, 5, 6);        return((MAL_BD *)pRxDesc);        }    else        {        DRV_LOG (DRV_DEBUG_RX, "RX desc no data yet\n", 1, 2, 3, 4, 5, 6);        return ((MAL_BD *)NULL);        }    }/********************************************************************************* ibmEmacRecv - process the next incoming packet** RETURNS: OK/ERROR*/LOCAL STATUS ibmEmacRecv    (    EMAC_DRV_CTRL *   pDrvCtrl,    MAL_BD *          pRxDesc    )    {    int                 len;    char *              pCluster;    char *              pNewCluster = NULL;    CL_BLK_ID           pClBlk;    M_BLK_ID            pMblk;    USHORT              statusRx;    int                 index;    DRV_LOG (DRV_DEBUG_RECV, "->ibmEmacRecv \n", 1, 2, 3, 4, 5, 6);    index = pDrvCtrl->indexRxD;    /* Bump the RX descriptor ring placeholder to the next position. */    pDrvCtrl->indexRxD = (index + 1) % pDrvCtrl->numRxD;    /* Check packet for errors */    statusRx = pRxDesc->statusControl;    DRV_LOG (DRV_DEBUG_RX, "EmacRecv : RxDesc = %X index = %d\n", statusRx,                            index, 3, 4, 5, 6);    /* If any of the error bits are set in the RX descriptor bump error count */    if (statusRx & EMAC_RX_ERRORS)        {        DRV_LOG (DRV_DEBUG_ERROR, "Status in RX Desc = 0x%x\n",                                   statusRx, 2, 3, 4, 5, 6);        END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);        /* Toss the packet, but reuse the cluster */        goto cleanRXD;        }    /* If the packet spans more than one buffer, this is also an error. */    if ((statusRx & MAL_RX_ONE_BUFFER) != MAL_RX_ONE_BUFFER)        {        DRV_LOG (DRV_DEBUG_ERROR, "RX packet spans >1 buffer\n",                                   1, 2, 3, 4, 5, 6);        END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_ERRS, +1);        /* Toss the packet, but reuse the cluster */        goto cleanRXD;        }    /* If we cannot get a new cluster to replace the full one, then bail out. */    pNewCluster = netClusterGet (pDrvCtrl->end.pNetPool,                                 pDrvCtrl->pClPoolId);