mirror of
https://github.com/plappermaul/realtek-doc.git
synced 2025-12-10 07:44:41 +01:00
1293 lines
26 KiB
C
Executable file
1293 lines
26 KiB
C
Executable file
/*******************************************************************************
|
|
* Copyright (C), 2013, Realtek Semiconductor Corp.
|
|
* All Rights Reserved.
|
|
*
|
|
* This program is the proprietary software of Realtek Semiconductor
|
|
* Corporation and/or its licensors, and only be used, duplicated,
|
|
* modified or distributed under the authorized license from Realtek.
|
|
*
|
|
* ANY USE OF THE SOFTWARE OTHER THAN AS AUTHORIZED UNDER
|
|
* THIS LICENSE OR COPYRIGHT LAW IS PROHIBITED.
|
|
*
|
|
* File Name:
|
|
* Author : Cynthia_wang
|
|
* Version :
|
|
* Date : 2020-9-24
|
|
* Purpose : RTL8373 switch high-level API for RTL8373
|
|
* Feature : Here is a list of all functions and variables in NIC module
|
|
* Note:
|
|
*******************************************************************************/
|
|
|
|
#include <rtk_switch.h>
|
|
#include <rtk_error.h>
|
|
#include <nic.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <dal/dal_mgmt.h>
|
|
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rst_set
|
|
* Description:
|
|
* nic reset
|
|
* Input:
|
|
* enabled - enable or disable
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_ENABLE
|
|
* Note:
|
|
* nic reset
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rst_set(void)
|
|
{
|
|
rtk_api_ret_t retVal;
|
|
|
|
if (NULL == RT_MAPPER->nic_rst_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rst_set();
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_txstop_set
|
|
* Description:
|
|
* Set rtk nic buffer tx stop address
|
|
* Input:
|
|
* addr - txstop address
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_ENABLE
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_txstop_set( rtk_uint32 addr)
|
|
{
|
|
rtk_api_ret_t retVal;
|
|
|
|
if (NULL == RT_MAPPER->nic_txStopAddr_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_txStopAddr_set(addr);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_txstop_get
|
|
* Description:
|
|
* Get rtk nic buffer tx stop address
|
|
* Input:
|
|
* none
|
|
* Output:
|
|
* pAddr - the pointer of address
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_NULL_POINTER
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_txstop_get(rtk_uint32 *pAddr)
|
|
{
|
|
rtk_api_ret_t retVal;
|
|
|
|
if (NULL == RT_MAPPER->nic_txStopAddr_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_txStopAddr_get(pAddr);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxstop_set
|
|
* Description:
|
|
* Set rtk nic buffer rx stop address
|
|
* Input:
|
|
* addr - rxstop address
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_ENABLE
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxstop_set( rtk_uint32 addr)
|
|
{
|
|
rtk_api_ret_t retVal;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxStopAddr_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxStopAddr_set(addr);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxstop_get
|
|
* Description:
|
|
* Get rtk nic buffer rx stop address
|
|
* Input:
|
|
* none
|
|
* Output:
|
|
* pAddr - the pointer of address
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_NULL_POINTER
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxstop_get(rtk_uint32 *pAddr)
|
|
{
|
|
rtk_api_ret_t retVal;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxStopAddr_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxStopAddr_get(pAddr);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_swRxCurPktAddr_get
|
|
* Description:
|
|
* Get Switch Rx current packet address
|
|
* Input:
|
|
* none
|
|
* Output:
|
|
* pAddr - the pointer of address
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_NULL_POINTER
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_swRxCurPktAddr_get(rtk_uint32 *pAddr)
|
|
{
|
|
rtk_api_ret_t retVal;
|
|
|
|
if (NULL == RT_MAPPER->nic_swRxCurPktAddr_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_swRxCurPktAddr_get(pAddr);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxDataLength_get
|
|
* Description:
|
|
* Get nic rx buffer received packet length
|
|
* Input:
|
|
* none
|
|
* Output:
|
|
* pLength - rx buffer received packet length
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_NULL_POINTER
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxReceivedPktLen_get(rtk_uint32 *pLength)
|
|
{
|
|
rtk_api_ret_t retVal;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxReceivedPktLen_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxReceivedPktLen_get(pLength);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_txAvailableSpace_get
|
|
* Description:
|
|
* Get nic tx buffer available free space
|
|
* Input:
|
|
* none
|
|
* Output:
|
|
* pAddr - the pointer of address
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_NULL_POINTER
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_txAvailSpace_get(rtk_uint32 *pLength)
|
|
{
|
|
rtk_api_ret_t retVal;
|
|
|
|
if (NULL == RT_MAPPER->nic_txAvailSpace_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_txAvailSpace_get(pLength);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_moduleEn_set
|
|
* Description:
|
|
* Enable/Disable NIC module .
|
|
* Input:
|
|
* none
|
|
* Output:
|
|
* pStatus - nic status
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_CHIP_NOT_FOUND
|
|
* RT_ERR_NOT_INIT - The module is not initial
|
|
* Applicable:
|
|
*
|
|
* Note:
|
|
* None
|
|
*/
|
|
rtk_api_ret_t rtk_nic_moduleEn_set(rtk_enable_t enable)
|
|
{
|
|
rtk_api_ret_t retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_moduleEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_moduleEn_set(enable);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_moduleEn_get
|
|
* Description:
|
|
* Get NIC module status .
|
|
* Input:
|
|
* none
|
|
* Output:
|
|
* pStatus - nic module status
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_CHIP_NOT_FOUND
|
|
* RT_ERR_NOT_INIT - The module is not initial
|
|
* Applicable:
|
|
*
|
|
* Note:
|
|
* None
|
|
*/
|
|
rtk_api_ret_t rtk_nic_moduleEn_get(rtk_enable_t *pStatus)
|
|
{
|
|
rtk_api_ret_t retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_moduleEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_moduleEn_get(pStatus);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxEn_set
|
|
* Description:
|
|
* Set NIC rx status .
|
|
* Input:
|
|
* none
|
|
* Output:
|
|
* pStatus - rx status
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_CHIP_NOT_FOUND
|
|
* RT_ERR_NOT_INIT - The module is not initial
|
|
* Applicable:
|
|
*
|
|
* Note:
|
|
* None
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxEn_set(rtk_enable_t enable)
|
|
{
|
|
rtk_api_ret_t retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxEn_set(enable);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rx_en_get
|
|
* Description:
|
|
* Get NIC rx status .
|
|
* Input:
|
|
* none
|
|
* Output:
|
|
* pStatus - rx status
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_CHIP_NOT_FOUND
|
|
* RT_ERR_NOT_INIT - The module is not initial
|
|
* Applicable:
|
|
*
|
|
* Note:
|
|
* None
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxEn_get(rtk_enable_t *pStatus)
|
|
{
|
|
rtk_api_ret_t retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxEn_get(pStatus);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_txEn_set
|
|
* Description:
|
|
* Set NIC tx status .
|
|
* Input:
|
|
* none
|
|
* Output:
|
|
* pStatus - tx status
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_CHIP_NOT_FOUND
|
|
* RT_ERR_NOT_INIT - The module is not initial
|
|
* Applicable:
|
|
*
|
|
* Note:
|
|
* None
|
|
*/
|
|
rtk_api_ret_t rtk_nic_txEn_set(rtk_enable_t enable)
|
|
{
|
|
rtk_api_ret_t retVal ;
|
|
|
|
|
|
if (NULL == RT_MAPPER->nic_txEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_txEn_set(enable);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_tx_en_get
|
|
* Description:
|
|
* Get NIC tx status .
|
|
* Input:
|
|
* none
|
|
* Output:
|
|
* pStatus - tx status
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_CHIP_NOT_FOUND
|
|
* RT_ERR_NOT_INIT - The module is not initial
|
|
* Applicable:
|
|
*
|
|
* Note:
|
|
* None
|
|
*/
|
|
rtk_api_ret_t rtk_nic_txEn_get(rtk_enable_t *pStatus)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_txEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_txEn_get(pStatus);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxRemoveCrc_set
|
|
* Description:
|
|
* enable rx remove crc or not.
|
|
* Input:
|
|
* enabled - enable or disable -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxRemoveCrc_set(rtk_enable_t enabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxRemoveCrc_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxRemoveCrc_set(enabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_rxRemoveCrc_get(rtk_enable_t *pEnabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxRemoveCrc_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxRemoveCrc_get(pEnabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxPaddingEn_set
|
|
* Description:
|
|
* Setting Nic rx padding control
|
|
* Input:
|
|
* enabled - enable or disable -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxPaddingEn_set(rtk_enable_t enabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxPaddingEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxPaddingEn_set(enabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_rxPaddingEn_get(rtk_enable_t *pEnabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxPaddingEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxPaddingEn_get(pEnabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxFreeSpaceThd_set
|
|
* Description:
|
|
* Setting Nic rx buffer free space threshold.
|
|
* Input:
|
|
* val - free space threshold(uint: 8Byte) -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxFreeSpaceThd_set(rtk_uint32 val)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxFreeSpaceThd_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxFreeSpaceThd_set(val);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_rxFreeSpaceThd_get(rtk_uint32 *pVal)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxFreeSpaceThd_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxFreeSpaceThd_get(pVal);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxCrcErrEn_set
|
|
* Description:
|
|
* enable rx crc error pkt or not.
|
|
* Input:
|
|
* enabled - enable or disable -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxCrcErrEn_set(rtk_enable_t enabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxCrcErrEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxCrcErrEn_set(enabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_rxCrcErrEn_get(rtk_enable_t *pEnabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxCrcErrEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxCrcErrEn_get(pEnabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxL3CrcErrEn_set
|
|
* Description:
|
|
* enable rx l3 crc error pkt or not.
|
|
* Input:
|
|
* enabled - enable or disable -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxL3CrcErrEn_set(rtk_enable_t enabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
if (NULL == RT_MAPPER->nic_rxL3CrcErrEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxL3CrcErrEn_set(enabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_rxL3CrcErrEn_get(rtk_enable_t *pEnabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
if (NULL == RT_MAPPER->nic_rxL3CrcErrEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxL3CrcErrEn_get(pEnabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxL4CrcErrEn_set
|
|
* Description:
|
|
* enable rx l4 crc error pkt or not.
|
|
* Input:
|
|
* enabled - enable or disable -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxL4CrcErrEn_set(rtk_enable_t enabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxL4CrcErrEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxL4CrcErrEn_set(enabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_rxL4CrcErrEn_get(rtk_enable_t *pEnabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
if (NULL == RT_MAPPER->nic_rxL4CrcErrEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxL4CrcErrEn_get(pEnabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxArpPassEn_set
|
|
* Description:
|
|
* enable ARP pkt pass or not.
|
|
* Input:
|
|
* enabled - enable or disable -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxArpEn_set(rtk_enable_t enabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxArpEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxArpEn_set(enabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_rxArpEn_get(rtk_enable_t *pEnabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxArpEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxArpEn_get(pEnabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxAllPktEn_set
|
|
* Description:
|
|
* enable nic rx all pkt or not.
|
|
* Input:
|
|
* enabled - enable or disable -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxAllPktEn_set(rtk_enable_t enabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxAllPktEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxAllPktEn_set(enabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_rxAllPktEn_get(rtk_enable_t *pEnabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxAllPktEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxAllPktEn_get(pEnabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxPhyPktSel_set
|
|
* Description:
|
|
* enable nic Receive Physical Address Packet Select or not.
|
|
* Input:
|
|
* enabled - enable or disable -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxPhyPktSel_set(rtk_nic_rxpps_t behavior)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxPhyPktSel_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxPhyPktSel_set(behavior);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_rxPhyPktSel_get(rtk_nic_rxpps_t *pBehavior)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxPhyPktSel_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxPhyPktSel_get(pBehavior);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxMultiPktEn_set
|
|
* Description:
|
|
* enable nic Receive multicast packet or not.
|
|
* Input:
|
|
* enabled - enable or disable -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxMultiPktEn_set(rtk_enable_t enabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
if (NULL == RT_MAPPER->nic_rxMultiPktEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxMultiPktEn_set(enabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_rxMultiPktEn_get(rtk_enable_t *pEnabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxMultiPktEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxMultiPktEn_get(pEnabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxBcPktEn_set
|
|
* Description:
|
|
* enable nic Receive broadcast packet or not.
|
|
* Input:
|
|
* enabled - enable or disable -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxBcPktEn_set(rtk_enable_t enabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxBcPktEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxBcPktEn_set(enabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_rxBcPktEn_get(rtk_enable_t *pEnabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxBcPktEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxBcPktEn_get(pEnabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_mcHashFltrEn_set
|
|
* Description:
|
|
* enable nic Received Multicast Packets Hash Filtering or not.
|
|
* Input:
|
|
* enabled - enable or disable -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_mcHashFltrEn_set(rtk_enable_t enabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_mcHashFltrEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_mcHashFltrEn_set(enabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_mcHashFltrEn_get(rtk_enable_t *pEnabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
if (NULL == RT_MAPPER->nic_mcHashFltrEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_mcHashFltrEn_get(pEnabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
/* Function Name:
|
|
* rtk_nic_PhyPktHashFltrEn_set
|
|
* Description:
|
|
* enable nic Received unicast Packets Hash Filtering or not.
|
|
* Input:
|
|
* enabled - enable or disable -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_phyPktHashFltrEn_set(rtk_enable_t enabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_phyPktHashFltrEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_phyPktHashFltrEn_set(enabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_phyPktHashFltrEn_get(rtk_enable_t *pEnabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_phyPktHashFltrEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_phyPktHashFltrEn_get(pEnabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
|
|
/* Function Name:
|
|
* rtk_nic_mcHashTblVal_set
|
|
* Description:
|
|
* Set nic rx multicast pkt hash table value.
|
|
* Input:
|
|
* type - high 32 bits value / low 32 bits value
|
|
* val - value
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_mcHashTblVal_set(rtk_nic_hashValType_t type, rtk_uint32 val)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_mcHashTblVal_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_mcHashTblVal_set(type, val);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_mcHashTblVal_get(rtk_nic_hashValType_t type, rtk_uint32 *pVal)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_mcHashTblVal_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_mcHashTblVal_get(type, pVal);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
|
|
/* Function Name:
|
|
* rtk_nic_phyPktHashTblVal_set
|
|
* Description:
|
|
* Set nic rx unicast pkt hash table value.
|
|
* Input:
|
|
* type - high 32 bits value / low 32 bits value
|
|
* val - value
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_phyPktHashTblVal_set(rtk_nic_hashValType_t type, rtk_uint32 val)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_phyPktHashTblVal_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_phyPktHashTblVal_set(type, val);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_phyPktHashTblVal_get(rtk_nic_hashValType_t type, rtk_uint32 *pVal)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_phyPktHashTblVal_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_phyPktHashTblVal_get(type, pVal);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_rxMTU_set
|
|
* Description:
|
|
* set nic RXMTU.
|
|
* Input:
|
|
* length - max length nic could recieved -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_rxMTU_set(rtk_nic_RxMTU_t length)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxMTU_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxMTU_set(length);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_rxMTU_get(rtk_nic_RxMTU_t *pLength)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_rxMTU_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_rxMTU_get(pLength);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_LoopbackEn_set
|
|
* Description:
|
|
* enable nic loopback ablity.
|
|
* Input:
|
|
* enabled - enable or disable
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_loopbackEn_set(rtk_enable_t enabled)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_loopbackEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_loopbackEn_set(enabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_loopbackEn_get(rtk_enable_t *pEnabled)
|
|
{
|
|
rtk_uint32 retVal;
|
|
|
|
if (NULL == RT_MAPPER->nic_loopbackEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_loopbackEn_get(pEnabled);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_InterruptEn_set
|
|
* Description:
|
|
* enable nic Rx Interrupt and TX Error Interrupt.
|
|
* Input:
|
|
* enabled - enable or disable -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_interruptEn_set(rtk_enable_t rxie, rtk_enable_t txee)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_interruptEn_set)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_interruptEn_set(rxie, txee);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_interruptEn_get(rtk_enable_t * pRxie, rtk_enable_t *pTxee)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_interruptEn_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_interruptEn_get(pRxie, pTxee);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
/* Function Name:
|
|
* rtk_nic_InterruptStatus_set
|
|
* Description:
|
|
* get nic Rx Interrupt's status and TX Error Interrupt's status.
|
|
* Input:
|
|
* enabled - enable or disable -
|
|
* Output:
|
|
* none
|
|
* Return:
|
|
* RT_ERR_OK
|
|
* RT_ERR_FAILED
|
|
* RT_ERR_SMI
|
|
*
|
|
* Note:
|
|
*
|
|
*/
|
|
rtk_api_ret_t rtk_nic_interruptStatus_get(rtk_uint32 * pRxis, rtk_uint32 *pTxes)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_interruptStatus_get)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_interruptStatus_get(pRxis, pTxes);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
rtk_api_ret_t rtk_nic_interruptStatus_clear(rtk_uint32 rxis, rtk_uint32 txes)
|
|
{
|
|
rtk_uint32 retVal ;
|
|
|
|
if (NULL == RT_MAPPER->nic_interruptStatus_clear)
|
|
return RT_ERR_DRIVER_NOT_FOUND;
|
|
|
|
RTK_API_LOCK();
|
|
retVal = RT_MAPPER->nic_interruptStatus_clear(rxis, txes);
|
|
RTK_API_UNLOCK();
|
|
|
|
return retVal;
|
|
}
|
|
|
|
|
|
|
|
|