ixethaccmac.c

有关ARM开发板上的IXP400网络驱动程序的源码以。

    /*disable FCS computation and appending*/
    /*Set bit 4 of Tx control register one to zero*/
    IX_ETH_ACC_VALIDATE_PORT_ID(portId);

    if (!IX_ETH_IS_PORT_INITIALIZED(portId))
    {
	return (IX_ETH_ACC_PORT_UNINITIALIZED);
    }
    
    REG_READ(ixEthAccMacBase[portId], 
	     IX_ETH_ACC_MAC_TX_CNTRL1,
	     regval);
    
    REG_WRITE(ixEthAccMacBase[portId],
	      IX_ETH_ACC_MAC_TX_CNTRL1,
	      regval & ~IX_ETH_ACC_TX_CNTRL1_FCS_EN);

    ixEthAccMacState[portId].txFCSAppend = FALSE;
    return IX_ETH_ACC_SUCCESS; 
}

PRIVATE void
ixEthAccPortRxFrameAppendFCSConfigCallback (IxNpeMhNpeId npeId,
                                            IxNpeMhMessage msg)
{
    IxEthAccPortId portId = IX_ETHNPE_NODE_AND_PORT_TO_PHYSICAL_ID(npeId,0);

#ifndef NDEBUG
    /* Prudent to at least check the port is within range */
    if (portId >= IX_ETH_ACC_NUMBER_OF_PORTS)
    {
        IX_ETH_ACC_FATAL_LOG("IXETHACC:ixEthAccPortRxFrameAppendFCSConfigCallback: Illegal port: %u\n",
            (UINT32) portId, 0, 0, 0, 0, 0);

        return;
    }
#endif

    /* unlock message reception mutex */
    ixOsalMutexUnlock(&ixEthAccMacState[portId].appendFCSConfigLock);
}


IxEthAccStatus 
ixEthAccPortRxFrameAppendFCSEnablePriv (IxEthAccPortId portId)
{
    UINT32 regval;
    IX_STATUS npeMhStatus;
    IxNpeMhMessage message;
    IxEthAccStatus status = IX_ETH_ACC_SUCCESS;

    IX_ETH_ACC_VALIDATE_PORT_ID(portId);

    if (!IX_ETH_IS_PORT_INITIALIZED(portId))
    {
	return (IX_ETH_ACC_PORT_UNINITIALIZED);
    }
    
    /*Set bit 2 of Rx control 1*/
    REG_READ(ixEthAccMacBase[portId], 
	     IX_ETH_ACC_MAC_RX_CNTRL1,
	     regval);
    
    REG_WRITE(ixEthAccMacBase[portId],
	      IX_ETH_ACC_MAC_RX_CNTRL1,
	      regval | IX_ETH_ACC_RX_CNTRL1_CRC_EN);

    ixEthAccMacState[portId].rxFCSAppend = TRUE;


    /* Send NPE message to notify of new config (enabled -> 0x01) */
    message.data[0] = (IX_ETHNPE_APPENDFCSCONFIG << IX_ETH_ACC_MAC_MSGID_SHL)
        | (IX_ETHNPE_PHYSICAL_ID_TO_LOGICAL_ID(portId) << IX_ETH_ACC_MAC_PORTID_SHL)
        | 0x01;
    message.data[1] = 0;

    npeMhStatus = ixNpeMhMessageWithResponseSend(IX_ETHNPE_PHYSICAL_ID_TO_NODE(portId),
                message,
                IX_ETHNPE_APPENDFCSCONFIG_ACK,
                ixEthAccPortRxFrameAppendFCSConfigCallback,
                IX_NPEMH_SEND_RETRIES_DEFAULT);

    if (npeMhStatus != IX_SUCCESS)
    {
        status = IX_ETH_ACC_FAIL;
    }
    else
    {
        /* wait for NPE response */
        if (ixOsalMutexLock(&ixEthAccMacState[portId].appendFCSConfigLock,
                            IX_ETH_ACC_PORT_DISABLE_DELAY_MSECS)
            != IX_SUCCESS)
        {
            status = IX_ETH_ACC_FAIL;
        }
    }

    return status;
}

IxEthAccStatus 
ixEthAccPortRxFrameAppendFCSDisablePriv (IxEthAccPortId portId)
{
    UINT32 regval;
    IX_STATUS npeMhStatus;
    IxNpeMhMessage message;
    IxEthAccStatus status = IX_ETH_ACC_SUCCESS;


    IX_ETH_ACC_VALIDATE_PORT_ID(portId);    

    if (!IX_ETH_IS_PORT_INITIALIZED(portId))
    {
	return (IX_ETH_ACC_PORT_UNINITIALIZED);
    }
    
    /*Clear bit 2 of Rx control 1*/
    REG_READ(ixEthAccMacBase[portId], 
	     IX_ETH_ACC_MAC_RX_CNTRL1,
	     regval);
    
    REG_WRITE(ixEthAccMacBase[portId],
	      IX_ETH_ACC_MAC_RX_CNTRL1,
	      regval & ~IX_ETH_ACC_RX_CNTRL1_CRC_EN);

    ixEthAccMacState[portId].rxFCSAppend = FALSE;

    /* Send NPE message to notify of new config (disabled -> 0x00) */
    message.data[0] = (IX_ETHNPE_APPENDFCSCONFIG << IX_ETH_ACC_MAC_MSGID_SHL)
        | (IX_ETHNPE_PHYSICAL_ID_TO_LOGICAL_ID(portId) << IX_ETH_ACC_MAC_PORTID_SHL)
        | 0x00;
    message.data[1] = 0;

    npeMhStatus = ixNpeMhMessageWithResponseSend(IX_ETHNPE_PHYSICAL_ID_TO_NODE(portId),
                message,
                IX_ETHNPE_APPENDFCSCONFIG_ACK,
                ixEthAccPortRxFrameAppendFCSConfigCallback,
                IX_NPEMH_SEND_RETRIES_DEFAULT);

    if (npeMhStatus != IX_SUCCESS)
    {
        status = IX_ETH_ACC_FAIL;
    }
    else
    {
        /* wait for NPE response */
        if (ixOsalMutexLock(&ixEthAccMacState[portId].appendFCSConfigLock,
                            IX_ETH_ACC_PORT_DISABLE_DELAY_MSECS)
            != IX_SUCCESS)
        {
            status = IX_ETH_ACC_FAIL;
        }
    }

    return status;
}



PRIVATE void
ixEthAccMacNpeStatsMessageCallback (IxNpeMhNpeId npeId,
				    IxNpeMhMessage msg)
{
    IxEthAccPortId portId = IX_ETHNPE_NODE_AND_PORT_TO_PHYSICAL_ID(npeId,0);
#ifndef NDEBUG
    /* Prudent to at least check the port is within range */
    if (portId >= IX_ETH_ACC_NUMBER_OF_PORTS)
    {
        IX_ETH_ACC_FATAL_LOG(
     "IXETHACC:ixEthAccMacNpeStatsMessageCallback: Illegal port: %u\n",
     (UINT32)portId, 0, 0, 0, 0, 0);
        return;
    }
#endif
    /*Unblock Stats Get call*/
    ixOsalMutexUnlock(&ixEthAccMacState[portId].ackMIBStatsLock);
}

PRIVATE void
ixEthAccMibIIStatsEndianConvert (IxEthEthObjStats *retStats)
{
    /* endianness conversion */

    /* Rx stats */
    retStats->dot3StatsAlignmentErrors = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->dot3StatsAlignmentErrors);
    retStats->dot3StatsFCSErrors = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->dot3StatsFCSErrors);
    retStats->dot3StatsInternalMacReceiveErrors = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->dot3StatsInternalMacReceiveErrors);
    retStats->RxOverrunDiscards = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxOverrunDiscards);
    retStats->RxLearnedEntryDiscards = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxLearnedEntryDiscards);
    retStats->RxLargeFramesDiscards = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxLargeFramesDiscards);
    retStats->RxSTPBlockedDiscards = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxSTPBlockedDiscards);
    retStats->RxVLANTypeFilterDiscards = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxVLANTypeFilterDiscards);
    retStats->RxVLANIdFilterDiscards = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxVLANIdFilterDiscards);
    retStats->RxInvalidSourceDiscards = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxInvalidSourceDiscards);
    retStats->RxBlackListDiscards = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxBlackListDiscards);
    retStats->RxWhiteListDiscards = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxWhiteListDiscards);
    retStats->RxUnderflowEntryDiscards = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxUnderflowEntryDiscards);

    /* Tx stats */
    retStats->dot3StatsSingleCollisionFrames = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->dot3StatsSingleCollisionFrames);
    retStats->dot3StatsMultipleCollisionFrames = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->dot3StatsMultipleCollisionFrames);
    retStats->dot3StatsDeferredTransmissions = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->dot3StatsDeferredTransmissions);
    retStats->dot3StatsLateCollisions = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->dot3StatsLateCollisions);
    retStats->dot3StatsExcessiveCollsions = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->dot3StatsExcessiveCollsions);
    retStats->dot3StatsInternalMacTransmitErrors = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->dot3StatsInternalMacTransmitErrors);
    retStats->dot3StatsCarrierSenseErrors = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->dot3StatsCarrierSenseErrors);
    retStats->TxLargeFrameDiscards = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->TxLargeFrameDiscards);
    retStats->TxVLANIdFilterDiscards = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->TxVLANIdFilterDiscards);

    /* Extended MIB-II stats */
    retStats->RxValidFramesTotalOctets = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxValidFramesTotalOctets);
    retStats->RxUcastPkts = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxUcastPkts);   
    retStats->RxBcastPkts = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxBcastPkts);
    retStats->RxMcastPkts = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxMcastPkts);
    retStats->RxPkts64Octets = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxPkts64Octets);
    retStats->RxPkts65to127Octets = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxPkts65to127Octets);
    retStats->RxPkts128to255Octets = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxPkts128to255Octets);
    retStats->RxPkts256to511Octets = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxPkts256to511Octets);
    retStats->RxPkts512to1023Octets = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxPkts512to1023Octets);
    retStats->RxPkts1024to1518Octets = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxPkts1024to1518Octets);
    retStats->RxInternalNPEReceiveErrors = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->RxInternalNPEReceiveErrors);
    retStats->TxInternalNPETransmitErrors = 
	IX_OSAL_SWAP_BE_SHARED_LONG(retStats->TxInternalNPETransmitErrors);

}

IxEthAccStatus
ixEthAccMibIIStatsGet (IxEthAccPortId portId,
		       IxEthEthObjStats *retStats )
{
    IxNpeMhMessage message;

    if (retStats == NULL)
    {
        printf("EthAcc: ixEthAccMibIIStatsGet (Mac) NULL argument\n");
	return (IX_ETH_ACC_FAIL);
    } else {
        /* always zero out the stats */
        IX_ETH_ACC_MEMSET(retStats, 0, sizeof(IxEthEthObjStats));
    }

    if (!IX_ETH_ACC_IS_SERVICE_INITIALIZED())
    {
        printf("EthAcc: ixEthAccMibIIStatsGet (Mac) EthAcc service is not initialized\n");
	return (IX_ETH_ACC_FAIL);
    }

    IX_ETH_ACC_VALIDATE_PORT_ID(portId);

    if (!IX_ETH_IS_PORT_INITIALIZED(portId))
    {
        printf("EthAcc: ixEthAccMibIIStatsGet (Mac) port %d is not initialized\n", portId);
	return (IX_ETH_ACC_PORT_UNINITIALIZED);
    }

    IX_OSAL_CACHE_INVALIDATE(retStats, sizeof(IxEthEthObjStats));

    message.data[0] = IX_ETHNPE_GETSTATS << IX_ETH_ACC_MAC_MSGID_SHL
        | (IX_ETHNPE_PHYSICAL_ID_TO_LOGICAL_ID(portId) << IX_ETH_ACC_MAC_PORTID_SHL);
    message.data[1] = (UINT32) IX_OSAL_MMU_VIRT_TO_PHYS(retStats);

    /* Permit only one task to request MIB statistics Get operation
       at a time */
    ixOsalMutexLock(&ixEthAccMacState[portId].MIBStatsGetAccessLock, IX_OSAL_WAIT_FOREVER);

    if(ixNpeMhMessageWithResponseSend(IX_ETHNPE_PHYSICAL_ID_TO_NODE(portId),
				      message,
				      IX_ETHNPE_GETSTATS,
				      ixEthAccMacNpeStatsMessageCallback,
				      IX_NPEMH_SEND_RETRIES_DEFAULT)
       != IX_SUCCESS)
    {
	ixOsalMutexUnlock(&ixEthAccMacState[portId].MIBStatsGetAccessLock);
        
        printf("EthAcc: (Mac) StatsGet failed to send NPE message\n");
        
	return IX_ETH_ACC_FAIL;
    }

    /* Wait for callback invocation indicating response to
       this request - we need this mutex in order to ensure
       that the return from this function is synchronous */
    ixOsalMutexLock(&ixEthAccMacState[portId].ackMIBStatsLock, IX_ETH_ACC_MIB_STATS_DELAY_MSECS);

    /* Permit other tasks to perform MIB statistics Get operation */
    ixOsalMutexUnlock(&ixEthAccMacState[portId].MIBStatsGetAccessLock);

    ixEthAccMibIIStatsEndianConvert (retStats);

    return IX_ETH_ACC_SUCCESS;
}


PRIVATE void
ixEthAccMacNpeStatsResetMessageCallback (IxNpeMhNpeId npeId,
					 IxNpeMhMessage msg)
{
    IxEthAccPortId portId = IX_ETHNPE_NODE_AND_PORT_TO_PHYSICAL_ID(npeId,0);
#ifndef NDEBUG
    /* Prudent to at least check the port is within range */
    if (portId >= IX_ETH_ACC_NUMBER_OF_PORTS)
    {
        IX_ETH_ACC_FATAL_LOG(
     "IXETHACC:ixEthAccMacNpeStatsResetMessageCallback: Illegal port: %u\n",
     (UINT32)portId, 0, 0, 0, 0, 0);
        return;
    }
#endif
    /*Unblock Stats Get & reset call*/
    ixOsalMutexUnlock(&ixEthAccMacState[portId].ackMIBStatsResetLock);
}



IxEthAccStatus 
ixEthAccMibIIStatsGetClear (IxEthAccPortId portId, 
			    IxEthEthObjStats *retStats)
{
    IxNpeMhMessage message;

    if (retStats == NULL)
    {
        printf("EthAcc: ixEthAccMibIIStatsGetClear (Mac) NULL argument\n");
	return (IX_ETH_ACC_FAIL);
    } else {
        /* always zero out the stats */
        IX_ETH_ACC_MEMSET(retStats, 0, sizeof(IxEthEthObjStats));
    }

    if (!IX_ETH_ACC_IS_SERVICE_INITIALIZED())
    {
        printf("EthAcc: ixEthAccMibIIStatsGetClear (Mac) EthAcc service is not initialized\n");
	return (IX_ETH_ACC_FAIL);
    }

    IX_ETH_ACC_VALIDATE_PORT_ID(portId);

    if (!IX_ETH_IS_PORT_INITIALIZED(portId))
    {
        printf("EthAcc: ixEthAccMibIIStatsGetClear (Mac) port %d is not initialized\n", portId);
	return (IX_ETH_ACC_PORT_UNINITIALIZED);
    }

    IX_OSAL_CACHE_INVALIDATE(retStats, sizeof(IxEthEthObjStats));
    
    message.data[0] = IX_ETHNPE_RESETSTATS << IX_ETH_ACC_MAC_MSGID_SHL
        | (IX_ETHNPE_PHYSICAL_ID_TO_LOGICAL_ID(portId) << IX_ETH_ACC_MAC_PORTID_SHL);
    message.data[1] = (UINT32) IX_OSAL_MMU_VIRT_TO_PHYS(retStats);
    
    /* Permit only one task to request MIB statistics Get-Reset operation at a time */
    ixOsalMutexLock(&ixEthAccMacState[portId].MIBStatsGetResetAccessLock, IX_OSAL_WAIT_FOREVER);
    
    if(ixNpeMhMessageWithResponseSend(IX_ETHNPE_PHYSICAL_ID_TO_NODE(portId), 
				      message,
				      IX_ETHNPE_RESETSTATS,
				      ixEthAccMacNpeStatsResetMessageCallback,
				      IX_NPEMH_SEND_RETRIES_DEFAULT) 
       != IX_SUCCESS)
    {
	ixOsalMutexUnlock(&ixEthAccMacState[portId].MIBStatsGetResetAccessLock);
        
        printf("EthAcc: (Mac) ixEthAccMibIIStatsGetClear failed to send NPE message\n");
        
	return IX_ETH_ACC_FAIL;
    }

    /* Wait for callback invocation indicating response to this request */
    ixOsalMutexLock(&ixEthAccMacState[portId].ackMIBStatsResetLock, IX_ETH_ACC_MIB_STATS_DELAY_MSECS);

    /* permit other tasks to get and reset MIB stats*/
    ixOsalMutexUnlock(&ixEthAccMacState[portId].MIBStatsGetResetAccessLock);

    ixEthAccMibIIStatsEndianConvert(retStats);

    return IX_ETH_ACC_SUCCESS;
}

IxEthAccStatus
ixEthAccMibIIStatsClear (IxEthAccPortId portId)
{
    static IxEthEthObjStats retStats;
    IxEthAccStatus status;

    if (!IX_ETH_ACC_IS_SERVICE_INITIALIZED())
    {
	return (IX_ETH_ACC_FAIL);
    }

    IX_ETH_ACC_VALIDATE_PORT_ID(portId);

    if (!IX_ETH_IS_PORT_INITIALIZED(portId))
    {
	return (IX_ETH_ACC_PORT_UNINITIALIZED);
    }

    /* there is no reset operation without a corresponding Get */
    status = ixEthAccMibIIStatsGetClear(portId, &retStats);

    return status;
}

/* Initialize the ethernet MAC settings */
IxEthAccStatus
ixEthAccMacInit(IxEthAccPortId portId)
{
    IX_OSAL_MBUF_POOL* portDisablePool;
    UINT8 *data;

    IX_ETH_ACC_VALIDATE_PORT_ID(portId);

    if(ixEthAccMacState[portId].macInitialised == FALSE)
    {
	ixEthAccMacState[portId].fullDuplex  = TRUE;
	ixEthAccMacState[portId].rxFCSAppend = TRUE;
	ixEthAccMacState[portId].txFCSAppend = TRUE;
	ixEthAccMacState[portId].txPADAppend = TRUE;
	ixEthAccMacState[portId].enabled     = FALSE;
	ixEthAccMacState[portId].promiscuous = TRUE;
	ixEthAccMacState[portId].joinAll     = FALSE;
	ixEthAccMacState[portId].initDone    = FALSE;
	ixEthAccMacState[portId].macInitialised = TRUE;
    
        /* initialize MIB stats mutexes */
        ixOsalMutexInit(&ixEthAccMacState[port