sngks32cend.c

Vxworks下BSP源码

else
        return ERROR;

    END_TX_SEM_GIVE (&pDrvCtrl->end);
    
    /* Bump the statistic counter. */

    END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_UCAST, +1);

    /*
     * Cleanup.  The driver must either free the packet now or
     * set up a structure so it can be freed later after a transmit
     * interrupt occurs.
     */

    netMblkClChainFree (pNBuff);

    return (OK);
#if 0
	
    int         len;
    int         oldLevel;
    UCHAR *pTx;
    UINT32 stat;

    if (pDrvCtrl->resetting)
        {
        return ERROR;
        }

    stat = *(volatile UINT32 *)AT91C_EMAC_TSR;
    if (!(stat & AT91C_EMAC_BNQ))
        return ERROR;
	
    pTx = pDrvCtrl->pTxBuf;
    /*
     * Obtain exclusive access to transmitter.  This is necessary because
     * we might have more than one stack transmitting at once.
     */
    END_TX_SEM_TAKE (&pDrvCtrl->end, WAIT_FOREVER);

    /* Set pointers in local structures to point to data. */
    len = netMblkToBufCopy(pNBuff,
                          (void *)pTx, NULL) ;


/*	printf("send ptr=%08x,length=%d\n",pTx,len); */
    *(volatile UINT32 *)AT91C_EMAC_TSR = stat;/* Reset stat word */
    /* place a transmit request */

    oldLevel = intLock ();   /* now at91cEndInt won't get confused */
    /* initiate device transmit */
	
    *(volatile UINT32 *)(AT91C_EMAC_TAR) = pTx;
    *(volatile UINT32 *)(AT91C_EMAC_TCR) = len;
    *(volatile UINT32 *)AT91C_EMAC_CTL |= AT91C_EMAC_TE;
    intUnlock (oldLevel);   /* now at91cEndInt won't get confused */
    while(((*(volatile UINT32 *)AT91C_EMAC_TSR)&AT91C_EMAC_BNQ)==0);
    END_TX_SEM_GIVE (&pDrvCtrl->end);
    
    /* Bump the statistic counter. */

    END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_UCAST, +1);

    /*
     * Cleanup.  The driver must either free the packet now or
     * set up a structure so it can be freed later after a transmit
     * interrupt occurs.
     */

    netMblkClChainFree (pNBuff);

    return (OK);
#endif




    }

/******************************************************************************
*
* at91cEndIoctl - the driver I/O control routine
*
* Process an ioctl request.
*
* RETURNS: A command specific response, usually OK or ERROR.
*/

LOCAL int at91cEndIoctl
    (
    END_DEVICE *pDrvCtrl,    /* device receiving command */
    int cmd,            /* ioctl command code */
    caddr_t data        /* command argument */
    )
    {
    int error = 0;
    long value;
/*
    DRV_LOG (DRV_DEBUG_IOCTL,
             "Ioctl unit=0x%x cmd=%d data=0x%x\n",
             pDrvCtrl->unit, cmd, (int)data, 0, 0, 0);
*/
    switch ((unsigned int)cmd)
        {
        case EIOCSADDR:
            if (data == NULL)
                return (EINVAL);
            bcopy ((char *)data, (char *)END_HADDR(&pDrvCtrl->end),
                   END_HADDR_LEN(&pDrvCtrl->end));
            break;

        case EIOCGADDR:
            if (data == NULL)
                return (EINVAL);
            bcopy ((char *)END_HADDR(&pDrvCtrl->end), (char *)data,
                   END_HADDR_LEN(&pDrvCtrl->end));
            break;

        case EIOCSFLAGS:
            value = (long)data;
            if (value < 0)
                {
                value = ~value;
                END_FLAGS_CLR (&pDrvCtrl->end, value);
                }
            else
                {
                END_FLAGS_SET (&pDrvCtrl->end, value);
                }
            at91cEndConfig (pDrvCtrl);
            break;

        case EIOCGFLAGS:
            *(int *)data = END_FLAGS_GET(&pDrvCtrl->end);
            break;

    case EIOCPOLLSTART:
        at91cEndPollStart (pDrvCtrl);
        break;

    case EIOCPOLLSTOP:
        at91cEndPollStop (pDrvCtrl);
        break;

    case EIOCGMIB2:
         if (data == NULL)
             return (EINVAL);
         bcopy((char *)&pDrvCtrl->end.mib2Tbl, (char *)data,
               sizeof(pDrvCtrl->end.mib2Tbl));
         break;
    
    case EIOCGFBUF:
        if (data == NULL)
            return (EINVAL);
        *(int *)data = 0;    /**END_MIN_FBUF;**/
        break;

    default:
        error = EINVAL;
        }

    return (error);
    }

/******************************************************************************
*
* at91cEndConfig - reconfigure the interface under us.
*
* Reconfigure the interface setting promiscuous mode
*
* RETURNS: N/A.
*/

LOCAL void at91cEndConfig
    (
    END_DEVICE *pDrvCtrl    /* device to be re-configured */
    )
    {


    at91cEndPIOConfig();		/*PIO pins config for EMAC */

    at91cEndReset(pDrvCtrl);    /* reset the chip */

    pDrvCtrl->rxHandling = FALSE;

    /* Set up address filter for multicasting. */
    
    if (END_MULTI_LST_CNT(&pDrvCtrl->end) > 0)
        at91cEndAddrFilterSet (pDrvCtrl);

#if 0
    if (pDrvCtrl->fdInitialized == TRUE)
        at91cEndFdFree(pDrvCtrl);    /* Free the FDs */

    /* Reinitialize FDs */
    if (at91cEndFdInitialize(pDrvCtrl) == ERROR)
        {
        DRV_LOG (DRV_DEBUG_LOAD, 
                 "at91cEndFdInitialize failed \n", 0, 0, 0, 0, 0, 0);
        return;
        }
#endif 

    at91cEndMacInitialize(pDrvCtrl);    /* Initialize MAC */


    /* Was started before in interrupt mode? */
    if ((END_FLAGS_GET(&pDrvCtrl->end) & IFF_RUNNING) &&
        ((pDrvCtrl->flags & LS_POLLING) == 0))
       		 at91cEndStart(pDrvCtrl);    /* Start again */


    return;
    }


#if 1
/******************************************************************************
*
* at91cEndPollStart - start polled mode operations
*
* RETURNS: OK or ERROR.
*/

LOCAL STATUS at91cEndPollStart
    (
    END_DEVICE* pDrvCtrl    /* device to be polled */
    )
    {

    int         oldLevel;

    oldLevel = intLock ();          /* disable ints during update */

    intDisable (pDrvCtrl->ivecEMAC);

    pDrvCtrl->flags |= LS_POLLING;

    intUnlock (oldLevel);   /* now at91cEndInt won't get confused */

    ENDLOGMSG (("Poll STARTED\n", 1, 2, 3, 4, 5, 6));

    at91cEndConfig (pDrvCtrl);    /* reconfigure device */

    /*Enable Rx */
    *(volatile UINT32 *)AT91C_EMAC_CTL |= AT91C_EMAC_RE ;
	
    /* Set the flags to indicate that the device is up */
    END_FLAGS_SET (&pDrvCtrl->end, IFF_UP | IFF_RUNNING);

    return (OK);
    }

/******************************************************************************
*
* at91cEndPollStop - stop polled mode operations
*
* This function terminates polled mode operation.  The device returns to
* interrupt mode.
*
* The device interrupts are enabled, the current mode flag is switched
* to indicate interrupt mode and the device is then reconfigured for
* interrupt operation.
*
* RETURNS: OK or ERROR.
*/

LOCAL STATUS at91cEndPollStop
    (
    END_DEVICE* pDrvCtrl    /* device to be changed */
    )
    {
    *(volatile UINT32 *)AT91C_EMAC_CTL &= ~(AT91C_EMAC_RE | AT91C_EMAC_TE);
	
    pDrvCtrl->flags &= ~LS_POLLING;

    pDrvCtrl->rxHandling = TRUE;

    /*
     * Restart in interrupt mode.  Calling at91cEndConfig without clearing
     * IFF_RUNNING flag will result in calling at91cEndStart automatically
     */
    netJobAdd ((FUNCPTR) at91cEndConfig, (int) pDrvCtrl,
			    0, 0, 0, 0);

    ENDLOGMSG (("Poll STOPPED\n", 1, 2, 3, 4, 5, 6));
    return (OK);
    }

/******************************************************************************
*
* at91cEndPollRcv - routine to receive a packet in polled mode.
*
* This routine is called by a user to try and get a packet from the
* device.
*
* RETURNS: OK upon success.  EAGAIN is returned when no packet is available.
*/

LOCAL STATUS at91cEndPollRcv
    (
    END_DEVICE *pDrvCtrl,    /* device to be polled */
    M_BLK_ID pMblk        /* ptr to buffer */
    )
    {

    UINT32 stat;
    char* pPacket;
   /* int len;*/
    UINT32 len;
    STATUS retVal = EAGAIN;

#ifdef ENDDEBUG
    if (endDebug)
        nvLogMsg ("at91cEndPollRcv\n", 1, 2, 3, 4, 5, 6);
#endif /* ENDDEBUG */

    if (pDrvCtrl->rxHandling)
        {
#ifdef ENDDEBUG
        if (endDebug)
            nvLogMsg ("at91cEndPollRcv rxHandling\n", 1, 2, 3, 4, 5, 6);
#endif /* ENDDEBUG */
        return EAGAIN;
        }

if(pDrvCtrl->pRxBufDesc->w0.ownerShip!=OWNED_BY_CPU)
        return EAGAIN;	

    stat = *(volatile UINT32 *)AT91C_EMAC_RSR;
    if ((stat & AT91C_EMAC_REC) == 0)
        {
#ifdef ENDDEBUG
        if (endDebug)
            nvLogMsg ("at91cEndPollRcv done every\n", 1, 2, 3, 4, 5, 6);
#endif /* ENDDEBUG */
        return EAGAIN;
        }

    /* Reset the status bit */
    *(volatile UINT32 *)AT91C_EMAC_RSR = stat;

    pDrvCtrl->statistics.rxOK = *(volatile UINT32*)AT91C_EMAC_OK;
    if (pDrvCtrl->statistics.rxOK == 0)
        goto pollRcvExit;

    /* Upper layer must provide a valid buffer. */

    len = (pDrvCtrl->pRxBufDesc->w1.frameLength);

    if ((pMblk->mBlkHdr.mLen < len) || (!(pMblk->mBlkHdr.mFlags & M_EXT)))
        goto pollRcvExit;

    END_ERR_ADD (&pDrvCtrl->end, MIB2_IN_UCAST, +1);

    pPacket = (UINT32)((char *)pDrvCtrl->pRxBufDesc->w0.baseAddrRecBuf)<<2;

    bcopy (pPacket, pMblk->mBlkHdr.mData, len + AT91C_DATA_OFFSET);

    pMblk->mBlkHdr.mData += AT91C_DATA_OFFSET;

    pMblk->mBlkHdr.mFlags |= M_PKTHDR;
    pMblk->mBlkHdr.mLen = len;
    pMblk->mBlkPktHdr.len = len;


    retVal = OK;

#ifdef ENDDEBUG
    if (endDebug)
        nvLogMsg ("at91cEndPollRcv OK\n", 1, 2, 3, 4, 5, 6);
#endif /* ENDDEBUG */

pollRcvExit:
    /* Rx status length field */
    pDrvCtrl->pRxBufDesc->w1.frameLength = 0;

    /* Ownership back to BDMA */
    pDrvCtrl->pRxBufDesc->w0.ownerShip = OWNED_BY_DMA;

#ifdef ENDDEBUG
    if (endDebug)
        nvLogMsg ("at91cEndPollRcv EXIT\n", 1, 2, 3, 4, 5, 6);
#endif /* ENDDEBUG */

    return retVal;
    
    }

/******************************************************************************
*
* at91cEndPollSend - routine to send a packet in polled mode.
*
* This routine is called by a user to try and send a packet on the
* device.
*
* RETURNS: OK upon success.  EAGAIN if device is busy.
*/

LOCAL STATUS at91cEndPollSend
    (
    END_DEVICE* pDrvCtrl,    /* device to be polled */
    M_BLK_ID pMblk        /* packet to send */
    )
    {
    UCHAR *pTx;
    int         len;
    UINT32 stat;

#ifdef ENDDEBUG
    if (endDebug)
        nvLogMsg ("at91cEndPollSend\n", 1, 2, 3, 4, 5, 6);
#endif /* ENDDEBUG */

    if (pDrvCtrl->resetting)
        {
        return EAGAIN;
        }

    /* Ownership  */
    stat = *(volatile UINT32 *)AT91C_EMAC_TSR;
    if (!(stat & AT91C_EMAC_BNQ))
        return EAGAIN;
    pTx = pDrvCtrl->pTxBuf;

    /* Set pointers in local structures to point to data. */
    len = netMblkToBufCopy(pMblk, (void *)pTx,
                           NULL) ;

    *(volatile UINT32 *)AT91C_EMAC_TSR = stat;/* Reset control word */

    /* initiate device transmit */
    *(volatile UINT32 *)(AT91C_EMAC_TAR) = pTx;
    *(volatile UINT32 *)(AT91C_EMAC_TCR) = len;
	

    *(volatile UINT32 *)AT91C_EMAC_CTL |= AT91C_EMAC_TE;
	
    /* Bump the statistic counter. */

    END_ERR_ADD (&pDrvCtrl->end, MIB2_OUT_UCAST, +1);
#if 0
    /* Advance our management index */
    pDrvCtrl->pTxBufDesc = pDrvCtrl->pTxBufDesc->nextTxBufDesc;
#endif
    /*
     * Cleanup.  The driver must either free the packet now or
     * set up a structure so it can be freed later after a transmit
     * interrupt occurs.
     */
    netMblkClChainFree (pMblk);

#ifdef ENDDEBUG
    if (endDebug)
        nvLogMsg ("leaving at91cEndPollSend\n", 1, 2, 3, 4, 5, 6);
#endif /* ENDDEBUG */

    return (OK);
    }


#endif

/******************************************************************************
*
* at91cEndAddrFilterSet - set the address filter for multicast addresses
*
* This routine goes through all of the multicast addresses on the list
* of addresses (added with the endAddrAdd() routine) and sets the
* device's filter correctly.
*
* RETURNS: N/A.
*/

LOCAL void at91cEndAddrFilterSet
    (
    END_DEVICE *pDrvCtrl    /* device to be updated */
    )
    {
    ETHER_MULTI* pCurr;
    UINT32 count;
    UCHAR *pAddr;
#if (_BYTE_ORDER != _LITTLE_ENDIAN)
    UCHAR *pEnetAddr;
#endif

    for (count = 0; count < 6; count++)