/* * Copyright : (C) 2022 Phytium Information Technology, Inc. * All Rights Reserved. * * This program is OPEN SOURCE software: you can redistribute it and/or modify it * under the terms of the Phytium Public License as published by the Phytium Technology Co.,Ltd, * either version 1.0 of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY; * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the Phytium Public License for more details. * * * FilePath: fxmac.c * Date: 2022-04-06 14:46:52 * LastEditTime: 2022-04-06 14:46:58 * Description:  This file is for * * Modify History: * Ver   Who        Date         Changes * ----- ------     --------    -------------------------------------- */ #include "fxmac.h" #include "ftypes.h" #include "fxmac_hw.h" #include "stdio.h" #include "fdebug.h" #define FXMAC_DEBUG_TAG "FXMAC" #define FXMAC_PRINT_E(format, ...) FT_DEBUG_PRINT_E(FXMAC_DEBUG_TAG, format, ##__VA_ARGS__) #define FXMAC_PRINT_I(format, ...) FT_DEBUG_PRINT_I(FXMAC_DEBUG_TAG, format, ##__VA_ARGS__) #define FXMAC_PRINT_D(format, ...) FT_DEBUG_PRINT_D(FXMAC_DEBUG_TAG, format, ##__VA_ARGS__) #define FXMAC_PRINT_W(format, ...) FT_DEBUG_PRINT_W(FXMAC_DEBUG_TAG, format, ##__VA_ARGS__) static void FXmacReset(FXmac *instance_p); extern FError FXmacSetTypeIdCheck(FXmac *instance_p, u32 id_check, u8 index); /** * @name: FXmacSelectClk * @msg: Determine the driver clock configuration based on the media independent interface * @param {FXmac} *instance_p is a pointer to the instance to be worked on. * @param {u32} speed interface speed * @return {*} */ void FXmacSelectClk(FXmac *instance_p) { u32 reg_value; s32 set_speed = 0; u32 speed = instance_p->config.speed; FASSERT(instance_p != NULL); FASSERT((speed == FXMAC_SPEED_10) || (speed == FXMAC_SPEED_100) || (speed == FXMAC_SPEED_1000) || (speed == FXMAC_SPEED_2500) || (speed == FXMAC_SPEED_10000)); if ((instance_p->config.interface == FXMAC_PHY_INTERFACE_MODE_USXGMII) || (instance_p->config.interface == FXMAC_PHY_INTERFACE_MODE_XGMII)) { if (speed == FXMAC_SPEED_10000) { FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_SRC_SEL_LN, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_DIV_SEL0_LN, 0x4); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_DIV_SEL1_LN, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_PMA_XCVR_POWER_STATE, 0x1); } } else if (instance_p->config.interface == FXMAC_PHY_INTERFACE_MODE_SGMII) { FXMAC_PRINT_I("FXMAC_PHY_INTERFACE_MODE_SGMII init"); if (speed == FXMAC_SPEED_2500) { FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_SRC_SEL_LN, 0); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_DIV_SEL0_LN, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_DIV_SEL1_LN, 0x2); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_PMA_XCVR_POWER_STATE, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL0, 0); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL1, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL2, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL3, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL0, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL1, 0x0); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL3_0, 0x0); /*0x1c70*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL4_0, 0x0); /*0x1c74*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL3_0, 0x0); /*0x1c78*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL4_0, 0x0); /*0x1c7c*/ } else if (speed == FXMAC_SPEED_1000) { FXMAC_PRINT_I("sgmii FXMAC_SPEED_1000 \r\n "); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_SRC_SEL_LN, 1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_DIV_SEL0_LN, 0x4); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_DIV_SEL1_LN, 0x8); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_PMA_XCVR_POWER_STATE, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL0, 0x0); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL1, 0x0); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL2, 0x0); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL3, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL0, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL1, 0x0); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL3_0, 0x0); /*0x1c70*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL4_0, 0x0); /*0x1c74*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL3_0, 0x0); /*0x1c78*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL4_0, 0x0); /*0x1c7c*/ } else if ((speed == FXMAC_SPEED_100) || (speed == FXMAC_SPEED_10)) { FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_DIV_SEL0_LN, 0x4); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_DIV_SEL1_LN, 0x8); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_PMA_XCVR_POWER_STATE, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL0, 0x0); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL1, 0x0); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL2, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL3, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL0, 0x1); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL1, 0x0); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL3_0, 0x1); /*0x1c70*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL4_0, 0x0); /*0x1c74*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL3_0, 0x0); /*0x1c78*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL4_0, 0x1); /*0x1c7c*/ } } else if (instance_p->config.interface == FXMAC_PHY_INTERFACE_MODE_RGMII) { FXMAC_PRINT_I("FXMAC_PHY_INTERFACE_MODE_RGMII init"); if (speed == FXMAC_SPEED_1000) { FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_MII_SELECT, 0x1); /*0x1c18*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_SEL_MII_ON_RGMII, 0x0); /*0x1c1c*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL0, 0x0); /*0x1c20*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL1, 0x1); /*0x1c24*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL2, 0x0); /*0x1c28*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL3, 0x0); /*0x1c2c*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL0, 0x0); /*0x1c30*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL1, 0x1); /*0x1c34*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_CLK_250M_DIV10_DIV100_SEL, 0x0); /*0x1c38*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL5, 0x1); /*0x1c48*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RGMII_TX_CLK_SEL0, 0x1); /*0x1c80*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RGMII_TX_CLK_SEL1, 0x0); /*0x1c84*/ } else if (speed == FXMAC_SPEED_100) { FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_SEL_MII_ON_RGMII, 0x0); /*0x1c1c*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL0, 0x0); /*0x1c20*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL1, 0x1); /*0x1c24*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL2, 0x0); /*0x1c28*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL3, 0x0); /*0x1c2c*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL0, 0x0); /*0x1c30*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL1, 0x1); /*0x1c34*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_CLK_250M_DIV10_DIV100_SEL, 0x0); /*0x1c38*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL5, 0x1); /*0x1c48*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RGMII_TX_CLK_SEL0, 0x0); /*0x1c80*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RGMII_TX_CLK_SEL1, 0x0); /*0x1c84*/ } else { FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_SEL_MII_ON_RGMII, 0x0); /*0x1c1c*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL0, 0x0); /*0x1c20*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL1, 0x1); /*0x1c24*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL2, 0x0); /*0x1c28*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_TX_CLK_SEL3, 0x0); /*0x1c2c*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL0, 0x0); /*0x1c30*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL1, 0x1); /*0x1c34*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_CLK_250M_DIV10_DIV100_SEL, 0x1); /*0x1c38*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL5, 0x1); /*0x1c48*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RGMII_TX_CLK_SEL0, 0x0); /*0x1c80*/ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RGMII_TX_CLK_SEL1, 0x0); /*0x1c84*/ } } else if (instance_p->config.interface == FXMAC_PHY_INTERFACE_MODE_RMII) { FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_RX_CLK_SEL5, 0x1); /*0x1c48*/ } switch (speed) { case FXMAC_SPEED_25000: set_speed = 2; break; case FXMAC_SPEED_10000: set_speed = 4; break; case FXMAC_SPEED_5000: set_speed = 3; break; case FXMAC_SPEED_2500: set_speed = 2; break; case FXMAC_SPEED_1000: set_speed = 1; break; default: set_speed = 0; break; } /*GEM_HSMAC(0x0050) provide rate to the external*/ reg_value = FXMAC_READREG32(instance_p->config.base_address, FXMAC_GEM_HSMAC); reg_value &= ~FXMAC_GEM_HSMACSPEED_MASK; reg_value |= (set_speed) &FXMAC_GEM_HSMACSPEED_MASK; FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_GEM_HSMAC, reg_value); reg_value = FXMAC_READREG32(instance_p->config.base_address, FXMAC_GEM_HSMAC); FXMAC_PRINT_I("FXMAC_GEM_HSMAC is %x \r\n ", reg_value); } /** * Start the Ethernet controller as follows: * - Enable transmitter if FXMAC_TRANSMIT_ENABLE_OPTION is set * - Enable receiver if FXMAC_RECEIVER_ENABLE_OPTION is set * - Start the SG DMA send and receive channels and enable the device * interrupt * * @param instance_p is a pointer to the instance to be worked on. * * @return N/A * * @note * Hardware is configured with scatter-gather DMA, the driver expects to start * the scatter-gather channels and expects that the user has previously set up * the buffer descriptor lists. * * This function makes use of internal resources that are shared between the * Start, Stop, and Set/ClearOptions functions. So if one task might be setting * device options while another is trying to start the device, the user is * required to provide protection of this shared data (typically using a * semaphore). * * This function must not be preempted by an interrupt that may service the * device. * */ void FXmacStart(FXmac *instance_p) { u32 reg_val; u32 reg = 0; /* Assert bad arguments and conditions */ FASSERT(instance_p != NULL); FASSERT(instance_p->is_ready == (u32)FT_COMPONENT_IS_READY); /* Start DMA */ /* When starting the DMA channels, both transmit and receive sides * need an initialized BD list. */ FASSERT(instance_p->rx_bd_queue.bdring.base_bd_addr != 0); reg = FXMAC_READREG32(instance_p->config.base_address, FXMAC_RXQBASE_OFFSET); reg = FXMAC_READREG32(instance_p->config.base_address, FXMAC_TXQBASE_OFFSET); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_RXQBASE_OFFSET, instance_p->rx_bd_queue.bdring.base_bd_addr); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_TXQBASE_OFFSET, instance_p->tx_bd_queue.bdring.base_bd_addr); reg = FXMAC_READREG32(instance_p->config.base_address, FXMAC_RXQBASE_OFFSET); reg = FXMAC_READREG32(instance_p->config.base_address, FXMAC_TXQBASE_OFFSET); /* clear any existed int status */ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_ISR_OFFSET, FXMAC_IXR_ALL_MASK); /* Enable transmitter if not already enabled */ if ((instance_p->config.network_default_config & (u32)FXMAC_TRANSMITTER_ENABLE_OPTION) != 0x00000000U) { reg_val = FXMAC_READREG32(instance_p->config.base_address, FXMAC_NWCTRL_OFFSET); if ((!(reg_val & FXMAC_NWCTRL_TXEN_MASK)) == TRUE) { FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_NWCTRL_OFFSET, reg_val | (u32)FXMAC_NWCTRL_TXEN_MASK); } } /* Enable receiver if not already enabled */ if ((instance_p->config.network_default_config & FXMAC_RECEIVER_ENABLE_OPTION) != 0x00000000U) { reg_val = FXMAC_READREG32(instance_p->config.base_address, FXMAC_NWCTRL_OFFSET); FXMAC_PRINT_I("endable receiver 0x%x \r\n ", reg_val); if ((!(reg_val & FXMAC_NWCTRL_RXEN_MASK)) == TRUE) { FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_NWCTRL_OFFSET, reg_val | (u32)FXMAC_NWCTRL_RXEN_MASK); } } FXMAC_PRINT_I("FXMAC_NWCTRL_OFFSET is 0x%x \r\n", FXMAC_READREG32(instance_p->config.base_address, FXMAC_NWCTRL_OFFSET)); /* Enable TX and RX interrupt */ FXMAC_INT_ENABLE(instance_p, FXMAC_IXR_LINKCHANGE_MASK | FXMAC_IXR_TX_ERR_MASK | FXMAC_IXR_RX_ERR_MASK | FXMAC_IXR_RXCOMPL_MASK | FXMAC_IXR_TXCOMPL_MASK); /* Mark as started */ instance_p->is_started = FT_COMPONENT_IS_STARTED; return; } /** * Gracefully stop the Ethernet MAC as follows: * - Disable all interrupts from this device * - Stop DMA channels * - Disable the tansmitter and receiver * * Device options currently in effect are not changed. * * This function will disable all interrupts. Default interrupts settings that * had been enabled will be restored when FXmacStart() is called. * * @param instance_p is a pointer to the instance to be worked on. * * @note * This function makes use of internal resources that are shared between the * Start, Stop, Setoptions, and Clearoptions functions. So if one task might be * setting device options while another is trying to start the device, the user * is required to provide protection of this shared data (typically using a * semaphore). * * Stopping the DMA channels causes this function to block until the DMA * operation is complete. * */ void FXmacStop(FXmac *instance_p) { u32 reg_val; FASSERT(instance_p != NULL); FASSERT(instance_p->is_ready == (u32)FT_COMPONENT_IS_READY); /* Disable all interrupts */ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_IDR_OFFSET, FXMAC_IXR_ALL_MASK); /* Disable the receiver & transmitter */ reg_val = FXMAC_READREG32(instance_p->config.base_address, FXMAC_NWCTRL_OFFSET); reg_val &= (u32)(~FXMAC_NWCTRL_RXEN_MASK); reg_val &= (u32)(~FXMAC_NWCTRL_TXEN_MASK); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_NWCTRL_OFFSET, reg_val); /* Mark as stopped */ instance_p->is_started = 0U; } static u32 FXmacClkDivGet(FXmac *instance_p) { FXmacConfig *config_p; config_p = &instance_p->config; if (config_p->pclk_hz <= 20000000) { return FXMAC_NWCFG_CLOCK_DIV8_MASK; } else if (config_p->pclk_hz <= 40000000) { return FXMAC_NWCFG_CLOCK_DIV16_MASK; } else if (config_p->pclk_hz <= 80000000) { return FXMAC_NWCFG_CLOCK_DIV32_MASK; } else if (instance_p->moudle_id >= 2) { if (config_p->pclk_hz <= 120000000) { return FXMAC_NWCFG_CLOCK_DIV48_MASK; } else if (config_p->pclk_hz <= 160000000) { return FXMAC_NWCFG_CLOCK_DIV64_MASK; } else if (config_p->pclk_hz <= 240000000) { return FXMAC_NWCFG_CLOCK_DIV96_MASK; } else if (config_p->pclk_hz <= 320000000) { return FXMAC_NWCFG_CLOCK_DIV128_MASK; } else { return FXMAC_NWCFG_CLOCK_DIV224_MASK; } } else { return FXMAC_NWCFG_CLOCK_DIV64_MASK; } } static u32 FXmacDmaWidth(FXmac *instance_p) { u32 read_regs = 0; FXmacConfig *config_p; config_p = &instance_p->config; if (instance_p->moudle_id < 2) { return FXMAC_NWCFG_BUS_WIDTH_32_MASK; } read_regs = FXMAC_READREG32(config_p->base_address, FXMAC_DESIGNCFG_DEBUG1_OFFSET); switch ((read_regs & FXMAC_DESIGNCFG_DEBUG1_BUS_WIDTH_MASK) >> 25) { case 4: FXMAC_PRINT_I("bus width is 128"); return FXMAC_NWCFG_BUS_WIDTH_128_MASK; case 2: FXMAC_PRINT_I("bus width is 64"); return FXMAC_NWCFG_BUS_WIDTH_64_MASK; default: FXMAC_PRINT_I("bus width is 32"); return FXMAC_NWCFG_BUS_WIDTH_32_MASK; } } static void FXmacDmaReset(FXmac *instance_p) { u32 queue = 0; FXmacConfig *config_p; config_p = &instance_p->config; u32 dmacfg = 0; u32 rx_buf_size = 0; rx_buf_size = instance_p->max_frame_size / FXMAC_RX_BUF_UNIT; rx_buf_size += ((instance_p->max_frame_size % FXMAC_RX_BUF_UNIT) != 0) ? 1 : 0; /* roundup */ if (instance_p->moudle_id >= 2) { for (queue = 0; queue < config_p->max_queue_num; queue++) { dmacfg = 0; FXmacSetQueuePtr(instance_p, (uintptr)NULL, queue, (u16)FXMAC_SEND); FXmacSetQueuePtr(instance_p, (uintptr)NULL, queue, (u16)FXMAC_RECV); if (queue) { FXMAC_WRITEREG32(config_p->base_address, FXMAC_RXBUFQX_SIZE_OFFSET(queue), rx_buf_size); } else /* queue is 0 */ { dmacfg |= ((u32)FXMAC_DMACR_RXBUF_MASK & (rx_buf_size << FXMAC_DMACR_RXBUF_SHIFT)); } } dmacfg |= (config_p->dma_brust_length & FXMAC_DMACR_BLENGTH_MASK); dmacfg &= ~FXMAC_DMACR_ENDIAN_MASK; dmacfg &= ~FXMAC_DMACR_SWAP_MANAGEMENT_MASK; /* 选择小端 */ dmacfg &= ~FXMAC_DMACR_TCPCKSUM_MASK; /* close transmitter checksum generation engine */ dmacfg &= ~FXMAC_DMACR_ADDR_WIDTH_64; dmacfg |= FXMAC_DMACR_RXSIZE_MASK | FXMAC_DMACR_TXSIZE_MASK; #if defined(__aarch64__) || defined(__arch64__) dmacfg |= FXMAC_DMACR_ADDR_WIDTH_64; #endif } else { FXmacSetQueuePtr(instance_p, (uintptr)NULL, 0, (u16)FXMAC_SEND); FXmacSetQueuePtr(instance_p, (uintptr)NULL, 0, (u16)FXMAC_RECV); dmacfg |= ((u32)FXMAC_DMACR_RXBUF_MASK & (rx_buf_size << FXMAC_DMACR_RXBUF_SHIFT)); dmacfg |= (config_p->dma_brust_length & FXMAC_DMACR_BLENGTH_MASK); dmacfg &= ~FXMAC_DMACR_ENDIAN_MASK; dmacfg &= ~FXMAC_DMACR_SWAP_MANAGEMENT_MASK; /* 选择小端 */ dmacfg &= ~FXMAC_DMACR_TCPCKSUM_MASK; /* close transmitter checksum generation engine */ dmacfg &= ~FXMAC_DMACR_ADDR_WIDTH_64; dmacfg |= FXMAC_DMACR_RXSIZE_MASK | FXMAC_DMACR_TXSIZE_MASK; #if defined(__aarch64__) || defined(__arch64__) dmacfg |= FXMAC_DMACR_ADDR_WIDTH_64; #endif } FXMAC_WRITEREG32(config_p->base_address, FXMAC_DMACR_OFFSET, dmacfg); } /** * Perform a graceful reset of the Ethernet MAC. Resets the DMA channels, the * transmitter, and the receiver. * * Steps to reset * - Stops transmit and receive channels * - Stops DMA * - Configure transmit and receive buffer size to default * - Clear transmit and receive status register and counters * - Clear all interrupt sources * - Clear phy (if there is any previously detected) address * - Clear MAC addresses (1-4) as well as Type IDs and hash value * * All options are placed in their default state. Any frames in the * descriptor lists will remain in the lists. The side effect of doing * this is that after a reset and following a restart of the device, frames * were in the list before the reset may be transmitted or received. * * The upper layer software is responsible for re-configuring (if necessary) * and restarting the MAC after the reset. Note also that driver statistics * are not cleared on reset. It is up to the upper layer software to clear the * statistics if needed. * * When a reset is required, the driver notifies the upper layer software of * this need through the ErrorHandler callback and specific status codes. * The upper layer software is responsible for calling this Reset function * and then re-configuring the device. * * @param instance_p is a pointer to the instance to be worked on. * */ static void FXmacReset(FXmac *instance_p) { u32 reg_val, write_reg = 0; u8 i; s8 mac_addr[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0}; u32 rx_buf_num; FASSERT(instance_p != NULL); /* Stop the device and reset hardware */ FXmacStop(instance_p); instance_p->moudle_id = (FXMAC_READREG32(instance_p->config.base_address, FXMAC_REVISION_REG_OFFSET) & FXMAC_IDENTIFICATION_MASK) >> 16; FXMAC_PRINT_I("instance_p->moudle_id is %d \r\n", instance_p->moudle_id); instance_p->max_mtu_size = FXMAC_MTU; instance_p->max_frame_size = FXMAC_MTU + FXMAC_HDR_SIZE + FXMAC_TRL_SIZE; FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_NWCTRL_OFFSET, ((FXMAC_NWCTRL_STATCLR_MASK) & (u32)(~FXMAC_NWCTRL_LOOPEN_MASK)) | FXMAC_NWCTRL_MDEN_MASK); write_reg = FXmacClkDivGet(instance_p); /* mdio clock division */ write_reg |= FXmacDmaWidth(instance_p); /* 位宽 */ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_NWCFG_OFFSET, write_reg); FXmacDmaReset(instance_p); /* This register, when read provides details of the status of the receive path. */ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_RXSR_OFFSET, FXMAC_SR_ALL_MASK); /* write 1 ro the relavant bit location disable that particular interrupt */ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_IDR_OFFSET, FXMAC_IXR_ALL_MASK); reg_val = FXMAC_READREG32(instance_p->config.base_address, FXMAC_ISR_OFFSET); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_ISR_OFFSET, reg_val); FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_TXSR_OFFSET, FXMAC_SR_ALL_MASK); FXmacClearHash(instance_p); /* set default mac address */ for (i = 0U; i < 4U; i++) { (void)FXmacSetMacAddress(instance_p, mac_addr, i); (void)FXmacGetMacAddress(instance_p, mac_addr, i); (void)FXmacSetTypeIdCheck(instance_p, 0x00000000U, i); } /* clear all counters */ for (i = 0U; i < (u8)((FXMAC_LAST_OFFSET - FXMAC_OCTTXL_OFFSET) / 4U); i++) { (void)FXMAC_READREG32(instance_p->config.base_address, FXMAC_OCTTXL_OFFSET + (u32)(((u32)i) * ((u32)4))); } /* Sync default options with hardware but leave receiver and * transmitter disabled. They get enabled with FXmacStart() if * FXMAC_TRANSMITTER_ENABLE_OPTION and * FXMAC_RECEIVER_ENABLE_OPTION are set. */ FXmacSetOptions(instance_p, instance_p->config.network_default_config & ~((u32)FXMAC_TRANSMITTER_ENABLE_OPTION | (u32)FXMAC_RECEIVER_ENABLE_OPTION), 0); FXmacClearOptions(instance_p, ~instance_p->config.network_default_config, 0); } /** * @name: FXmacInitInterface * @msg: Initialize the MAC controller configuration based on the PHY interface type * @note: * @param {FXmac} *instance_p is a pointer to the instance to be worked on. */ void FXmacInitInterface(FXmac *instance_p) { u32 config, control; FXmacConfig *config_p; config_p = &instance_p->config; if (config_p->interface == FXMAC_PHY_INTERFACE_MODE_XGMII) { config = FXMAC_READREG32(config_p->base_address, FXMAC_NWCFG_OFFSET); config &= ~FXMAC_NWCFG_PCSSEL_MASK; FXMAC_WRITEREG32(config_p->base_address, FXMAC_NWCFG_OFFSET, config); control = FXMAC_READREG32(config_p->base_address, FXMAC_NWCTRL_OFFSET); control |= FXMAC_NWCTRL_ENABLE_HS_MAC_MASK; /* Use high speed MAC */ FXMAC_WRITEREG32(config_p->base_address, FXMAC_NWCTRL_OFFSET, control); config_p->duplex = 1; } else if (config_p->interface == FXMAC_PHY_INTERFACE_MODE_USXGMII) { config = FXMAC_READREG32(config_p->base_address, FXMAC_NWCFG_OFFSET); config |= FXMAC_NWCFG_PCSSEL_MASK; FXMAC_WRITEREG32(config_p->base_address, FXMAC_NWCFG_OFFSET, config); control = FXMAC_READREG32(config_p->base_address, FXMAC_NWCTRL_OFFSET); control |= FXMAC_NWCTRL_ENABLE_HS_MAC_MASK; /* Use high speed MAC */ FXMAC_WRITEREG32(config_p->base_address, FXMAC_NWCTRL_OFFSET, control); control = FXMAC_READREG32(config_p->base_address, FXMAC_GEM_USX_CONTROL_OFFSET); control &= ~(FXMAC_GEM_USX_TX_SCR_BYPASS | FXMAC_GEM_USX_RX_SCR_BYPASS); control |= FXMAC_GEM_USX_RX_SYNC_RESET; FXMAC_WRITEREG32(config_p->base_address, FXMAC_GEM_USX_CONTROL_OFFSET, control); control = FXMAC_READREG32(config_p->base_address, FXMAC_GEM_USX_CONTROL_OFFSET); control &= ~FXMAC_GEM_USX_RX_SYNC_RESET; control |= FXMAC_GEM_USX_TX_DATAPATH_EN; control |= FXMAC_GEM_USX_SIGNAL_OK; if (config_p->speed == FXMAC_SPEED_10000) { control |= FXMAC_GEM_USX_HS_MAC_SPEED_10G; } else if (config_p->speed == FXMAC_SPEED_25000) { control |= FXMAC_GEM_USX_HS_MAC_SPEED_2_5G; } else if (config_p->speed == FXMAC_SPEED_1000) { control |= FXMAC_GEM_USX_HS_MAC_SPEED_1G; } else if (config_p->speed == FXMAC_SPEED_100) { control |= FXMAC_GEM_USX_HS_MAC_SPEED_100M; } FXMAC_WRITEREG32(config_p->base_address, FXMAC_GEM_USX_CONTROL_OFFSET, control); config_p->duplex = 1; } else if (config_p->interface == FXMAC_PHY_INTERFACE_MODE_SGMII) { config = FXMAC_READREG32(config_p->base_address, FXMAC_NWCFG_OFFSET); config |= FXMAC_NWCFG_PCSSEL_MASK | FXMAC_NWCFG_SGMII_MODE_ENABLE_MASK; config &= ~(FXMAC_NWCFG_100_MASK | FXMAC_NWCFG_FDEN_MASK); if (instance_p->moudle_id >= 2) { config &= ~FXMAC_NWCFG_1000_MASK; } if (config_p->duplex) { config |= FXMAC_NWCFG_FDEN_MASK; } if (config_p->speed == FXMAC_SPEED_100) { config |= FXMAC_NWCFG_100_MASK; } else if (config_p->speed == FXMAC_SPEED_1000) { config |= FXMAC_NWCFG_1000_MASK; } FXMAC_WRITEREG32(config_p->base_address, FXMAC_NWCFG_OFFSET, config); if (config_p->speed == FXMAC_SPEED_2500) { control = FXMAC_READREG32(config_p->base_address, FXMAC_NWCTRL_OFFSET); control |= FXMAC_NWCTRL_TWO_PT_FIVE_GIG_MASK; FXMAC_WRITEREG32(config_p->base_address, FXMAC_NWCTRL_OFFSET, control); } else { control = FXMAC_READREG32(config_p->base_address, FXMAC_NWCTRL_OFFSET); control &= ~FXMAC_NWCTRL_TWO_PT_FIVE_GIG_MASK; FXMAC_WRITEREG32(config_p->base_address, FXMAC_NWCTRL_OFFSET, control); } control = FXMAC_READREG32(config_p->base_address, FXMAC_NWCTRL_OFFSET); control &= ~FXMAC_NWCTRL_ENABLE_HS_MAC_MASK; FXMAC_WRITEREG32(config_p->base_address, FXMAC_NWCTRL_OFFSET, control); control = FXMAC_READREG32(config_p->base_address, FXMAC_PCS_CONTROL_OFFSET); control |= FXMAC_PCS_CONTROL_ENABLE_AUTO_NEG; FXMAC_WRITEREG32(config_p->base_address, FXMAC_PCS_CONTROL_OFFSET, control); } else { config = FXMAC_READREG32(config_p->base_address, FXMAC_NWCFG_OFFSET); FXMAC_PRINT_I("select rgmii \r\n"); config &= ~FXMAC_NWCFG_PCSSEL_MASK; config &= ~(FXMAC_NWCFG_100_MASK | FXMAC_NWCFG_FDEN_MASK); if (instance_p->moudle_id >= 2) { config &= ~FXMAC_NWCFG_1000_MASK; } if (config_p->duplex) { config |= FXMAC_NWCFG_FDEN_MASK; } if (config_p->speed == FXMAC_SPEED_100) { config |= FXMAC_NWCFG_100_MASK; } else if (config_p->speed == FXMAC_SPEED_1000) { config |= FXMAC_NWCFG_1000_MASK; } if (config_p->duplex) { config |= FXMAC_NWCFG_FDEN_MASK; } FXMAC_WRITEREG32(config_p->base_address, FXMAC_NWCFG_OFFSET, config); control = FXMAC_READREG32(config_p->base_address, FXMAC_NWCTRL_OFFSET); control &= ~FXMAC_NWCTRL_ENABLE_HS_MAC_MASK; /* Use high speed MAC */ FXMAC_WRITEREG32(config_p->base_address, FXMAC_NWCTRL_OFFSET, control); } } static void FXmacIrqStubHandler(void) { FASSERT_MSG(0, "Please register the interrupt callback function"); } /** * @name: FXmacCfgInitialize * @msg: Initialize a specific fxmac instance/driver. * @note: * @param {FXmac} *instance_p is a pointer to the instance to be worked on. * @param {FXmacConfig} *config_p is the device configuration structure containing required * hardware build data. * @return {FT_SUCCESS} if initialization was successful */ FError FXmacCfgInitialize(FXmac *instance_p, const FXmacConfig *config_p) { /* Verify arguments */ FASSERT(instance_p != NULL); FASSERT(config_p != NULL); instance_p->config = *config_p; instance_p->link_status = FXMAC_LINKDOWN; /* Reset the hardware and set default options */ instance_p->is_ready = FT_COMPONENT_IS_READY; FXmacReset(instance_p); instance_p->send_irq_handler = (FXmacIrqHandler)FXmacIrqStubHandler; instance_p->send_args = NULL; instance_p->recv_irq_handler = (FXmacIrqHandler)FXmacIrqStubHandler; instance_p->recv_args = NULL; instance_p->error_irq_handler = (FXmacErrorIrqHandler)FXmacIrqStubHandler; instance_p->error_args = NULL; instance_p->link_change_handler = (FXmacIrqHandler)FXmacIrqStubHandler; instance_p->link_change_args = NULL; instance_p->restart_handler = (FXmacIrqHandler)FXmacIrqStubHandler; instance_p->restart_args = NULL; return FT_SUCCESS; } /** * This function sets the start address of the transmit/receive buffer queue. * * @param instance_p is a pointer to the instance to be worked on. * @param queue_p is the address of the Queue to be written * @param queue_num is the Buffer Queue Index * @param direction indicates Transmit/Receive * * @note * The buffer queue addresses has to be set before starting the transfer, so * this function has to be called in prior to FXmacStart() * */ void FXmacSetQueuePtr(FXmac *instance_p, uintptr queue_p, u8 queue_num, u32 direction) { /* Assert bad arguments and conditions */ FASSERT(instance_p != NULL); FASSERT(instance_p->is_ready == (u32)FT_COMPONENT_IS_READY); /* If already started, then there is nothing to do */ if (instance_p->is_started == (u32)FT_COMPONENT_IS_STARTED) { return; } if (queue_num == 0x00U) { if (direction == FXMAC_SEND) { /* set base start address of TX buffer queue (tx buffer descriptor list) */ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_TXQBASE_OFFSET, (queue_p & ULONG64_LO_MASK) | (((queue_p == (uintptr)0)) ? 1 : 0)); } else { /* set base start address of RX buffer queue (rx buffer descriptor list) */ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_RXQBASE_OFFSET, (queue_p & ULONG64_LO_MASK) | (((queue_p == (uintptr)0)) ? 1 : 0)); } } else { if (direction == FXMAC_SEND) { FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_QUEUE_REGISTER_OFFSET(FXMAC_TXQ1BASE_OFFSET, queue_num), (queue_p & ULONG64_LO_MASK) | (((queue_p == (uintptr)0)) ? 1 : 0)); } else { FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_QUEUE_REGISTER_OFFSET(FXMAC_TXQ1BASE_OFFSET, queue_num), (queue_p & ULONG64_LO_MASK) | (((queue_p == (uintptr)0)) ? 1 : 0)); } } #ifdef __aarch64__ if (direction == FXMAC_SEND) { /* Set the MSB of TX Queue start address */ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_MSBBUF_TXQBASE_OFFSET, (u32)((queue_p & ULONG64_HI_MASK) >> 32U)); } else { /* Set the MSB of RX Queue start address */ FXMAC_WRITEREG32(instance_p->config.base_address, FXMAC_MSBBUF_RXQBASE_OFFSET, (u32)((queue_p & ULONG64_HI_MASK) >> 32U)); } #endif }