520 lines
14 KiB
C
520 lines
14 KiB
C
/****************************************************************************
|
|
|
|
Copyright(c) 2019 by Aerospace C.Power (Chongqing) Microelectronics. ALL RIGHTS RESERVED.
|
|
|
|
This Information is proprietary to Aerospace C.Power (Chongqing) Microelectronics and MAY NOT
|
|
be copied by any method or incorporated into another program without
|
|
the express written consent of Aerospace C.Power. This Information or any portion
|
|
thereof remains the property of Aerospace C.Power. The Information contained herein
|
|
is believed to be accurate and Aerospace C.Power assumes no responsibility or
|
|
liability for its use in any way and conveys no license or title under
|
|
any patent or copyright and makes no representation or warranty that this
|
|
Information is free from patent or copyright infringement.
|
|
|
|
****************************************************************************/
|
|
#include "chip_reg_base.h"
|
|
#include "hw_reg_api.h"
|
|
#include "plc_fr.h"
|
|
#include "mac_reset.h"
|
|
#include "mac_sys_reg.h"
|
|
#include "ahb.h"
|
|
#include "hw_desc.h"
|
|
#include "hw_phy_init.h"
|
|
#include "mac_raw_reg.h"
|
|
#include "mac_tmr_reg.h"
|
|
#include "mac_hwq_reg.h"
|
|
#include "mac_init_api.h"
|
|
/* HW WAR for cfg reg not take effect */
|
|
#include "mac_txq_hw.h"
|
|
#include "mac_status.h"
|
|
#include "mac_rx_buf_ring.h"
|
|
#include "os_utils_api.h"
|
|
#include "os_task.h"
|
|
#include "mac_rf_common_hw.h"
|
|
#include "phy_phase.h"
|
|
#include "phy_reg.h"
|
|
#include "mac_tx_descriptor_reg.h"
|
|
#include "mac_sched_hw.h"
|
|
|
|
void enable_mac(uint32_t enable) {
|
|
#if HW_PLATFORM != HW_PLATFORM_SIMU
|
|
if (enable) {
|
|
ahb_mac_enable();
|
|
} else {
|
|
ahb_mac_disable();
|
|
}
|
|
#else
|
|
(void)enable;
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
void warm_rst_mac_hold() {
|
|
#if HW_PLATFORM != HW_PLATFORM_SIMU
|
|
ahb_mac_reset_hold();
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
void warm_rst_mac_release() {
|
|
#if HW_PLATFORM != HW_PLATFORM_SIMU
|
|
ahb_mac_reset_release();
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
void mac_cfg_reg_reset()
|
|
{
|
|
#if HW_PLATFORM >= HW_PLATFORM_FPGA
|
|
ahb_mac_reset();
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
void mac_reset(MAC_RST_REASON_ID rst_reason) {
|
|
(void)rst_reason;
|
|
enable_mac(true);
|
|
|
|
/* reset mac's logic */
|
|
warm_rst_mac_hold();
|
|
|
|
if (rst_reason == MAC_RST_REASON_COLD) {
|
|
/* reset mac's reg
|
|
* not reset all reg here, as the cfg reg reset
|
|
* not only reset mac reg, put it at phy_reset()
|
|
* kunlun2, we should able to reset mac's reg
|
|
*/
|
|
mac_cfg_reg_reset();
|
|
}
|
|
|
|
warm_rst_mac_release();
|
|
|
|
return;
|
|
}
|
|
|
|
void mac_warm_reset_war(uint32_t flag) {
|
|
(void)flag;
|
|
|
|
if (flag == CONT_RX_ABORT4) {
|
|
#if ENA_WAR_244
|
|
/* disable MAC RAW DATA MODE */
|
|
RGF_RAW_WRITE_REG(CFG_RAW_DATA_MODE_ADDR, 0);
|
|
/* clear pb size BB */
|
|
phy_rawdata_mode_bb_set_ps_tr(0,0,0);
|
|
#endif
|
|
} else if (flag == PHY_TX_HANG){
|
|
mac_new_phy_cfg_apply();
|
|
|
|
/* clear mac status cnt */
|
|
mac_status_cnt_clr();
|
|
}
|
|
}
|
|
|
|
void mac_set_sw_idle_mode(uint32_t ena, uint32_t is_idle) {
|
|
#if HW_PLATFORM >= HW_PLATFORM_FPGA
|
|
uint32_t tmp;
|
|
tmp = RGF_MAC_READ_REG(CFG_PHASE_BAND_SEL_ADDR);
|
|
REG_FIELD_SET(CFG_SW_IDLE_MODE_EN, tmp, ena);
|
|
REG_FIELD_SET(CFG_SW_IDLE_MODE, tmp, is_idle);
|
|
RGF_MAC_WRITE_REG(CFG_PHASE_BAND_SEL_ADDR, tmp);
|
|
#else
|
|
(void)ena;
|
|
(void)is_idle;
|
|
#endif
|
|
}
|
|
|
|
uint32_t mac_wait_phy_txrx_idle() {
|
|
#if HW_PLATFORM >= HW_PLATFORM_FPGA
|
|
/* return 0 for wait idle successful
|
|
* 1 for wait failed if timeout
|
|
*/
|
|
/* TODO: support timeout */
|
|
uint32_t tmp;
|
|
uint32_t tx_active;
|
|
uint32_t rx_active;
|
|
do {
|
|
tmp = RGF_MAC_READ_REG(CFG_RD_MACPHY_INTF_0_ADDR);
|
|
rx_active = REG_FIELD_GET(PHY_RX_ENABLE, tmp);
|
|
tx_active = REG_FIELD_GET(PHY_TX_ENABLE, tmp);
|
|
} while (tx_active && rx_active);
|
|
#else
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
void mac_force_phy_tx_ready(uint32_t ena, uint32_t is_force_ready) {
|
|
#if HW_PLATFORM >= HW_PLATFORM_FPGA
|
|
/* make phy tx ready to 1 before mac disable hwq */
|
|
uint32_t tmp;
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_FORCE_2_ADDR);
|
|
REG_FIELD_SET(CFG_PHY_TX_READY_FORCE_EN, tmp, ena);
|
|
REG_FIELD_SET(CFG_PHY_TX_READY, tmp, is_force_ready);
|
|
RGF_MAC_WRITE_REG(CFG_PHY_FORCE_2_ADDR, tmp);
|
|
#else
|
|
(void)ena;
|
|
(void)is_force_ready;
|
|
#endif
|
|
|
|
return;
|
|
}
|
|
|
|
uint32_t mac_dbg_bus_is_in_tx()
|
|
{
|
|
#define TX_FSM_IS_TX_MASK (0x2 << 23)
|
|
uint32_t debug_tmp;
|
|
mac_set_debug_reg(0xB00);
|
|
debug_tmp = mac_rx_get_debug_reg();
|
|
/* if (bit25:23) = 2, then means tx */
|
|
return debug_tmp & TX_FSM_IS_TX_MASK;
|
|
}
|
|
|
|
void mac_tx_wait_all_queue_idle(uint32_t iscco, uint32_t time_ms)
|
|
{
|
|
uint32_t start_ts = os_boot_time32();
|
|
volatile uint32_t is_tx_busy = mac_dbg_bus_is_in_tx();
|
|
#if DEBUG_HWQ_SHCED_HANG
|
|
uint32_t try_cnt = 0;
|
|
#endif
|
|
|
|
uint32_t start_ntb = mac_sched_get_lts();
|
|
while (is_tx_busy) {
|
|
if ((os_boot_time32() - start_ts) > time_ms) {
|
|
#if DEBUG_HWQ_SHCED_HANG
|
|
try_cnt++;
|
|
/* war for stop sched hang */
|
|
if (try_cnt < 2) {
|
|
/* force mac phy interface */
|
|
mac_force_mac_phy_interface(1);
|
|
os_delay(1);
|
|
mac_force_mac_phy_interface(0);
|
|
phy_reset(PHY_RST_REASON_WARM);
|
|
} else
|
|
#endif
|
|
{
|
|
#if WAR_HWQ_SHCED_HANG
|
|
/* reset chip */
|
|
iot_system_restart(IOT_SYS_RST_REASON_MAC_TX_HANG);
|
|
#endif
|
|
/* if try_cnt >= 2 then assert */
|
|
uint32_t dump_buf[5];
|
|
dump_buf[0] = start_ts;
|
|
dump_buf[1] = os_boot_time32();
|
|
dump_buf[2] = start_ntb;
|
|
dump_buf[3] = mac_sched_get_lts();
|
|
while (mac_dbg_bus_is_in_tx()) {
|
|
if ((os_boot_time32() - dump_buf[1]) > 500) {
|
|
break;
|
|
}
|
|
os_delay(1);
|
|
}
|
|
dump_buf[4] = os_boot_time32();
|
|
mac_dump_buf(MAC_DUMP_TYPE_4,
|
|
dump_buf,
|
|
5,
|
|
(uint32_t *)RGF_HWQ_BASEADDR, 108,
|
|
(uint32_t *)(PHY_BASEADDR + CFG_BB_DBG_BUS_SEL_ADDR),
|
|
39, true);
|
|
}
|
|
}
|
|
os_delay(1);
|
|
is_tx_busy = mac_dbg_bus_is_in_tx();
|
|
}
|
|
return;
|
|
}
|
|
|
|
void mac_sw_trig_need_en(bool_t ena)
|
|
{
|
|
#if HW_PLATFORM >= HW_PLATFORM_FPGA
|
|
uint32_t tmp;
|
|
tmp = RGF_MAC_READ_REG(CFG_MAC_TRX_START_ADDR);
|
|
REG_FIELD_SET(CFG_MAC_TRX_START_NEED_TRIG, tmp, ena);
|
|
RGF_MAC_WRITE_REG(CFG_MAC_TRX_START_ADDR, tmp);
|
|
#else
|
|
(void)ena;
|
|
(void)is_idle;
|
|
#endif
|
|
}
|
|
|
|
void mac_sw_trig_start(bool_t ena)
|
|
{
|
|
#if HW_PLATFORM >= HW_PLATFORM_FPGA
|
|
uint32_t tmp;
|
|
tmp = RGF_MAC_READ_REG(CFG_MAC_TRX_START_ADDR);
|
|
REG_FIELD_SET(CFG_MAC_TRX_START_TRIG, tmp, ena);
|
|
RGF_MAC_WRITE_REG(CFG_MAC_TRX_START_ADDR, tmp);
|
|
#else
|
|
(void)ena;
|
|
#endif
|
|
}
|
|
|
|
/* 1'b0: AHB clk and mac clk 1:1; 1'b1: 2:1 */
|
|
void mac_dma_ckl_sel(bool_t ena)
|
|
{
|
|
/* NOTE: this function is inoperative on kl3 */
|
|
return;
|
|
#if HW_PLATFORM > HW_PLATFORM_FPGA
|
|
uint32_t tmp = RGF_TMR_READ_REG(CFG_NTB_CFG_ADDR);
|
|
REG_FIELD_SET(CFG_DMA_CLK_SEL, tmp, ena);
|
|
RGF_TMR_WRITE_REG(CFG_NTB_CFG_ADDR, tmp);
|
|
#else
|
|
(void)ena;
|
|
#endif
|
|
}
|
|
|
|
uint32_t mac_get_phy_txrx_sts()
|
|
{
|
|
#if HW_PLATFORM >= HW_PLATFORM_FPGA
|
|
uint32_t tmp;
|
|
uint32_t tx_active;
|
|
uint32_t rx_active;
|
|
tmp = RGF_MAC_READ_REG(CFG_RD_MACPHY_INTF_0_ADDR);
|
|
rx_active = REG_FIELD_GET(PHY_RX_ENABLE, tmp);
|
|
tx_active = REG_FIELD_GET(PHY_TX_ENABLE, tmp);
|
|
if (rx_active == 0 && tx_active == 0) {
|
|
return MAC_PHY_IDLE_STS;
|
|
}
|
|
else if (rx_active == 1 && tx_active == 0) {
|
|
return MAC_PHY_RX_STS;
|
|
}
|
|
else if (rx_active == 0 && tx_active == 1) {
|
|
return MAC_PHY_TX_STS;
|
|
}
|
|
else if (rx_active == 1 && tx_active == 1) {
|
|
IOT_ASSERT(0);
|
|
return MAC_PHY_UNKNOW_STS;
|
|
}
|
|
#else
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/* NOTE: this function cannot call in interrupt */
|
|
uint32_t mac_set_sts_idle()
|
|
{
|
|
#if HW_PLATFORM >= HW_PLATFORM_FPGA
|
|
|
|
uint32_t tmp;
|
|
|
|
phy_force_0_access_require();
|
|
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_FORCE_0_ADDR);
|
|
|
|
REG_FIELD_SET(CFG_PHY_RX_FRAME_FORCE_EN, tmp, 1);
|
|
REG_FIELD_SET(CFG_PHY_RX_FRAME, tmp, 0);
|
|
|
|
REG_FIELD_SET(CFG_PHY_RX_VLD_FORCE_EN, tmp, 1);
|
|
REG_FIELD_SET(CFG_PHY_RX_VLD, tmp, 0);
|
|
|
|
REG_FIELD_SET(CFG_PHY_FC_CRC_DONE_FORCE_EN, tmp, 1);
|
|
REG_FIELD_SET(CFG_PHY_FC_CRC_DONE, tmp, 0);
|
|
|
|
REG_FIELD_SET(CFG_PHY_PB_CRC_DONE_FORCE_EN, tmp, 1);
|
|
REG_FIELD_SET(CFG_PHY_PB_CRC_DONE, tmp, 0);
|
|
|
|
RGF_MAC_WRITE_REG(CFG_PHY_FORCE_0_ADDR, tmp);
|
|
|
|
phy_force_0_access_release();
|
|
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_FORCE_1_ADDR);
|
|
|
|
REG_FIELD_SET(CFG_PHY_PB_RCV_DONE_FORCE_EN, tmp, 1);
|
|
REG_FIELD_SET(CFG_PHY_PB_RCV_DONE, tmp, 0);
|
|
|
|
REG_FIELD_SET(CFG_PHY_FC_RCV_DONE_FORCE_EN, tmp, 1);
|
|
REG_FIELD_SET(CFG_PHY_FC_RCV_DONE, tmp, 0);
|
|
|
|
RGF_MAC_WRITE_REG(CFG_PHY_FORCE_1_ADDR, tmp);
|
|
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_FORCE_2_ADDR);
|
|
REG_FIELD_SET(CFG_PHY_TX_READY_FORCE_EN, tmp, 1);
|
|
REG_FIELD_SET(CFG_PHY_TX_READY, tmp, 1);
|
|
RGF_MAC_WRITE_REG(CFG_PHY_FORCE_2_ADDR, tmp);
|
|
|
|
#else
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/* NOTE: this function cannot call in interrupt */
|
|
uint32_t mac_free_sts_idle()
|
|
{
|
|
#if HW_PLATFORM >= HW_PLATFORM_FPGA
|
|
|
|
uint32_t tmp;
|
|
|
|
phy_force_0_access_require();
|
|
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_FORCE_0_ADDR);
|
|
|
|
REG_FIELD_SET(CFG_PHY_RX_FRAME_FORCE_EN, tmp, 0);
|
|
REG_FIELD_SET(CFG_PHY_RX_FRAME, tmp, 0);
|
|
|
|
REG_FIELD_SET(CFG_PHY_RX_VLD_FORCE_EN, tmp, 0);
|
|
REG_FIELD_SET(CFG_PHY_RX_VLD, tmp, 0);
|
|
|
|
REG_FIELD_SET(CFG_PHY_FC_CRC_DONE_FORCE_EN, tmp, 0);
|
|
REG_FIELD_SET(CFG_PHY_FC_CRC_DONE, tmp, 0);
|
|
|
|
REG_FIELD_SET(CFG_PHY_PB_CRC_DONE_FORCE_EN, tmp, 0);
|
|
REG_FIELD_SET(CFG_PHY_PB_CRC_DONE, tmp, 0);
|
|
|
|
RGF_MAC_WRITE_REG(CFG_PHY_FORCE_0_ADDR, tmp);
|
|
|
|
phy_force_0_access_release();
|
|
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_FORCE_1_ADDR);
|
|
|
|
REG_FIELD_SET(CFG_PHY_PB_RCV_DONE_FORCE_EN, tmp, 0);
|
|
REG_FIELD_SET(CFG_PHY_PB_RCV_DONE, tmp, 0);
|
|
|
|
REG_FIELD_SET(CFG_PHY_FC_RCV_DONE_FORCE_EN, tmp, 0);
|
|
REG_FIELD_SET(CFG_PHY_FC_RCV_DONE, tmp, 0);
|
|
|
|
RGF_MAC_WRITE_REG(CFG_PHY_FORCE_1_ADDR, tmp);
|
|
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_FORCE_2_ADDR);
|
|
|
|
REG_FIELD_SET(CFG_PHY_TX_READY_FORCE_EN, tmp, 0);
|
|
REG_FIELD_SET(CFG_PHY_TX_READY, tmp, 0);
|
|
|
|
RGF_MAC_WRITE_REG(CFG_PHY_FORCE_2_ADDR, tmp);
|
|
#else
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
uint32_t mac_dbg_bus_get_mac_sts(uint32_t value, uint32_t mask)
|
|
{
|
|
uint32_t debug_tmp;
|
|
mac_set_debug_reg(value);
|
|
debug_tmp = mac_rx_get_debug_reg();
|
|
/* if 0, then means idle */
|
|
return debug_tmp & mask;
|
|
}
|
|
|
|
/* flag of plc cpu to handle pcs reg */
|
|
static void mac_set_hplc_set_pcs_flag(uint32_t set_pcs)
|
|
{
|
|
uint32_t tmp = RGF_HWQ_READ_REG(CFG_HWQ8_PTR_ADDR);
|
|
tmp &= ~(0x1 << 0);
|
|
tmp |= (!!set_pcs << 0);
|
|
RGF_HWQ_WRITE_REG(CFG_HWQ8_PTR_ADDR, tmp);
|
|
}
|
|
|
|
static uint32_t mac_get_hplc_set_pcs_flag()
|
|
{
|
|
uint32_t tmp = RGF_HWQ_READ_REG(CFG_HWQ8_PTR_ADDR);
|
|
return (tmp & (0x1 << 0));
|
|
}
|
|
|
|
/* NOTE: this function cannot call in interrupt */
|
|
uint32_t mac_set_pcs_busy(uint32_t enable, uint32_t value)
|
|
{
|
|
#if HW_PLATFORM >= HW_PLATFORM_FPGA
|
|
uint32_t tmp;
|
|
|
|
phy_force_0_access_require();
|
|
/* NOTE: enable and mac_get_hplc_set_pcs_flag() must be opposite values*/
|
|
IOT_ASSERT((!!enable) != (!!mac_get_hplc_set_pcs_flag()));
|
|
if (enable) {
|
|
mac_set_hplc_set_pcs_flag(1);
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_FORCE_0_ADDR);
|
|
REG_FIELD_SET(CFG_PHY_PCS_BUSY_FORCE_EN, tmp, enable);
|
|
REG_FIELD_SET(CFG_PHY_PCS_BUSY, tmp, value);
|
|
RGF_MAC_WRITE_REG(CFG_PHY_FORCE_0_ADDR, tmp);
|
|
} else {
|
|
mac_set_hplc_set_pcs_flag(0);
|
|
if (!mac_rf_get_hplc_pcs_reg()) {
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_FORCE_0_ADDR);
|
|
REG_FIELD_SET(CFG_PHY_PCS_BUSY_FORCE_EN, tmp, enable);
|
|
REG_FIELD_SET(CFG_PHY_PCS_BUSY, tmp, value);
|
|
RGF_MAC_WRITE_REG(CFG_PHY_FORCE_0_ADDR, tmp);
|
|
}
|
|
}
|
|
phy_force_0_access_release();
|
|
#else
|
|
(void)enable;
|
|
(void)value;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
uint32_t IRAM_ATTR mac_set_pcs_busy_from_isr(uint32_t enable, uint32_t value)
|
|
{
|
|
#if HW_PLATFORM >= HW_PLATFORM_FPGA
|
|
uint32_t tmp;
|
|
|
|
phy_force_0_access_require_from_isr();
|
|
|
|
if (enable) {
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_FORCE_0_ADDR);
|
|
REG_FIELD_SET(CFG_PHY_PCS_BUSY_FORCE_EN, tmp, enable);
|
|
REG_FIELD_SET(CFG_PHY_PCS_BUSY, tmp, value);
|
|
RGF_MAC_WRITE_REG(CFG_PHY_FORCE_0_ADDR, tmp);
|
|
} else {
|
|
if (mac_get_hplc_set_pcs_flag() == 0) {
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_FORCE_0_ADDR);
|
|
REG_FIELD_SET(CFG_PHY_PCS_BUSY_FORCE_EN, tmp, enable);
|
|
REG_FIELD_SET(CFG_PHY_PCS_BUSY, tmp, value);
|
|
RGF_MAC_WRITE_REG(CFG_PHY_FORCE_0_ADDR, tmp);
|
|
}
|
|
}
|
|
|
|
phy_force_0_access_release_from_isr();
|
|
#else
|
|
(void)enable;
|
|
(void)value;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
/* NOTE: this function cannot call in interrupt */
|
|
uint32_t mac_set_fc_crc_done(uint32_t enable, uint32_t value)
|
|
{
|
|
#if HW_PLATFORM >= HW_PLATFORM_FPGA
|
|
uint32_t tmp;
|
|
phy_force_0_access_require();
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_FORCE_0_ADDR);
|
|
REG_FIELD_SET(CFG_PHY_FC_CRC_DONE_FORCE_EN, tmp, enable);
|
|
REG_FIELD_SET(CFG_PHY_FC_CRC_DONE, tmp, value);
|
|
RGF_MAC_WRITE_REG(CFG_PHY_FORCE_0_ADDR, tmp);
|
|
phy_force_0_access_release();
|
|
#else
|
|
(void)enable;
|
|
(void)value;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
uint32_t mac_set_reg_tx_abort_debug_value()
|
|
{
|
|
#if HW_PLATFORM >= HW_PLATFORM_FPGA
|
|
uint32_t tmp;
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_FORCE_1_ADDR);
|
|
REG_FIELD_SET(CFG_PHY_TX_ABORT_FORCE_EN, tmp, 1);
|
|
REG_FIELD_SET(CFG_PHY_TX_ABORT, tmp, 0);
|
|
RGF_MAC_WRITE_REG(CFG_PHY_FORCE_1_ADDR, tmp);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
uint32_t mac_force_mac_phy_interface(uint32_t value)
|
|
{
|
|
#if HW_PLATFORM >= HW_PLATFORM_FPGA
|
|
uint32_t tmp;
|
|
tmp = RGF_MAC_READ_REG(CFG_PHY_FORCE_2_ADDR);
|
|
|
|
REG_FIELD_SET(CFG_PHY_TX_READY_FORCE_EN, tmp, value);
|
|
REG_FIELD_SET(CFG_PHY_TX_READY, tmp, value);
|
|
|
|
REG_FIELD_SET(CFG_PHY_TX_PROCESSING_FORCE_EN, tmp, value);
|
|
REG_FIELD_SET(CFG_PHY_TX_PROCESSING, tmp, value);
|
|
|
|
RGF_MAC_WRITE_REG(CFG_PHY_FORCE_2_ADDR, tmp);
|
|
#else
|
|
(void)value;
|
|
#endif
|
|
return 0;
|
|
}
|
|
|