/*- * Copyright (c) 2015,2016 Annapurna Labs Ltd. and affiliates * All rights reserved. * * Developed by Semihalf. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include "al_init_eth_lm.h" #include "al_serdes.h" #include "al_hal_eth.h" #include "al_init_eth_kr.h" /** * @{ * @file al_init_eth_lm.c * * @brief ethernet link management common utilities * */ /* delay before checking link status with new serdes parameters (uSec) */ #define AL_ETH_LM_LINK_STATUS_DELAY 1000 /* delay before checking link status after reconfiguring the retimer (uSec) */ #define AL_ETH_LM_RETIMER_LINK_STATUS_DELAY 50000 #define AL_ETH_LM_EQ_ITERATIONS 15 #define AL_ETH_LM_MAX_DCGAIN 8 /* num of link training failures till serdes reset */ #define AL_ETH_LT_FAILURES_TO_RESET 10 #define MODULE_IDENTIFIER_IDX 0 #define MODULE_IDENTIFIER_SFP 0x3 #define MODULE_IDENTIFIER_QSFP 0xd #define SFP_PRESENT 0 #define SFP_NOT_PRESENT 1 /* SFP+ module */ #define SFP_I2C_HEADER_10G_IDX 3 #define SFP_I2C_HEADER_10G_DA_IDX 8 #define SFP_I2C_HEADER_10G_DA_LEN_IDX 18 #define SFP_I2C_HEADER_1G_IDX 6 #define SFP_I2C_HEADER_SIGNAL_RATE 12 /* Nominal signaling rate, units of 100MBd. */ #define SFP_MIN_SIGNAL_RATE_25G 250 #define SFP_MIN_SIGNAL_RATE_10G 100 /* QSFP+ module */ #define QSFP_COMPLIANCE_CODE_IDX 131 /* 40GBASE-LR4 and 40GBASE-SR4 are optic modules */ #define QSFP_COMPLIANCE_CODE_OPTIC ((1 << 1) | (1 << 2)) #define QSFP_COMPLIANCE_CODE_DAC (1 << 3) #define QSFP_CABLE_LEN_IDX 146 /* TODO: need to check the necessary delay */ #define AL_ETH_LM_RETIMER_WAIT_FOR_LOCK 500 /* delay after retimer reset to lock (mSec) */ #define AL_ETH_LM_SERDES_WAIT_FOR_LOCK 50 /* delay after signal detect to lock (mSec) */ #define AL_ETH_LM_GEARBOX_RESET_DELAY 1000 /* (uSec) */ static const uint32_t al_eth_retimer_boost_addr[AL_ETH_RETIMER_CHANNEL_MAX][AL_ETH_RETIMER_TYPE_MAX] = { /* BR_210 | BR_410 */ /* AL_ETH_RETIMER_CHANNEL_A */ {0xf, 0x1a}, /* AL_ETH_RETIMER_CHANNEL_B */ {0x16, 0x18}, /* AL_ETH_RETIMER_CHANNEL_C */ {0x0, 0x16}, /* AL_ETH_RETIMER_CHANNEL_D */ {0x0, 0x14}, }; #define RETIMER_LENS_MAX 5 static const uint32_t al_eth_retimer_boost_lens[RETIMER_LENS_MAX] = {0, 1, 2, 3, 5}; static const uint32_t al_eth_retimer_boost_value[RETIMER_LENS_MAX + 1][AL_ETH_RETIMER_TYPE_MAX] = { /* BR_210 | BR_410 */ /* 0 */ {0x0, 0x0}, /* 1 */ {0x1, 0x1}, /* 2 */ {0x2, 0x1}, /* 3 */ {0x3, 0x3}, /* 5 */ {0x7, 0x3}, /* 5+ */{0xb, 0x7}, }; struct retimer_config_reg { uint8_t addr; uint8_t value; uint8_t mask; }; static struct retimer_config_reg retimer_ds25_25g_mode_tx_ch[] = { {.addr = 0x0A, .value = 0x0C, .mask = 0xff }, {.addr = 0x2F, .value = 0x54, .mask = 0xff }, {.addr = 0x31, .value = 0x20, .mask = 0xff }, {.addr = 0x1E, .value = 0xE9, .mask = 0xff }, {.addr = 0x1F, .value = 0x0B, .mask = 0xff }, {.addr = 0xA6, .value = 0x43, .mask = 0xff }, {.addr = 0x2A, .value = 0x5A, .mask = 0xff }, {.addr = 0x2B, .value = 0x0A, .mask = 0xff }, {.addr = 0x2C, .value = 0xF6, .mask = 0xff }, {.addr = 0x70, .value = 0x05, .mask = 0xff }, {.addr = 0x6A, .value = 0x21, .mask = 0xff }, {.addr = 0x35, .value = 0x0F, .mask = 0xff }, {.addr = 0x12, .value = 0x83, .mask = 0xff }, {.addr = 0x9C, .value = 0x24, .mask = 0xff }, {.addr = 0x98, .value = 0x00, .mask = 0xff }, {.addr = 0x42, .value = 0x50, .mask = 0xff }, {.addr = 0x44, .value = 0x90, .mask = 0xff }, {.addr = 0x45, .value = 0xC0, .mask = 0xff }, {.addr = 0x46, .value = 0xD0, .mask = 0xff }, {.addr = 0x47, .value = 0xD1, .mask = 0xff }, {.addr = 0x48, .value = 0xD5, .mask = 0xff }, {.addr = 0x49, .value = 0xD8, .mask = 0xff }, {.addr = 0x4A, .value = 0xEA, .mask = 0xff }, {.addr = 0x4B, .value = 0xF7, .mask = 0xff }, {.addr = 0x4C, .value = 0xFD, .mask = 0xff }, {.addr = 0x8E, .value = 0x00, .mask = 0xff }, {.addr = 0x3D, .value = 0x94, .mask = 0xff }, {.addr = 0x3F, .value = 0x40, .mask = 0xff }, {.addr = 0x3E, .value = 0x43, .mask = 0xff }, {.addr = 0x0A, .value = 0x00, .mask = 0xff }, }; static struct retimer_config_reg retimer_ds25_25g_mode_rx_ch[] = { {.addr = 0x0A, .value = 0x0C, .mask = 0xff}, {.addr = 0x2F, .value = 0x54, .mask = 0xff}, {.addr = 0x31, .value = 0x40, .mask = 0xff}, {.addr = 0x1E, .value = 0xE3, .mask = 0xff}, {.addr = 0x1F, .value = 0x0B, .mask = 0xff}, {.addr = 0xA6, .value = 0x43, .mask = 0xff}, {.addr = 0x2A, .value = 0x5A, .mask = 0xff}, {.addr = 0x2B, .value = 0x0A, .mask = 0xff}, {.addr = 0x2C, .value = 0xF6, .mask = 0xff}, {.addr = 0x70, .value = 0x05, .mask = 0xff}, {.addr = 0x6A, .value = 0x21, .mask = 0xff}, {.addr = 0x35, .value = 0x0F, .mask = 0xff}, {.addr = 0x12, .value = 0x83, .mask = 0xff}, {.addr = 0x9C, .value = 0x24, .mask = 0xff}, {.addr = 0x98, .value = 0x00, .mask = 0xff}, {.addr = 0x42, .value = 0x50, .mask = 0xff}, {.addr = 0x44, .value = 0x90, .mask = 0xff}, {.addr = 0x45, .value = 0xC0, .mask = 0xff}, {.addr = 0x46, .value = 0xD0, .mask = 0xff}, {.addr = 0x47, .value = 0xD1, .mask = 0xff}, {.addr = 0x48, .value = 0xD5, .mask = 0xff}, {.addr = 0x49, .value = 0xD8, .mask = 0xff}, {.addr = 0x4A, .value = 0xEA, .mask = 0xff}, {.addr = 0x4B, .value = 0xF7, .mask = 0xff}, {.addr = 0x4C, .value = 0xFD, .mask = 0xff}, {.addr = 0x8E, .value = 0x00, .mask = 0xff}, {.addr = 0x3D, .value = 0x94, .mask = 0xff}, {.addr = 0x3F, .value = 0x40, .mask = 0xff}, {.addr = 0x3E, .value = 0x43, .mask = 0xff}, {.addr = 0x0A, .value = 0x00, .mask = 0xff}, }; static struct retimer_config_reg retimer_ds25_10g_mode[] = { /* Assert CDR reset (6.3) */ {.addr = 0x0A, .value = 0x0C, .mask = 0x0C}, /* Select 10.3125Gbps standard rate mode (6.6) */ {.addr = 0x2F, .value = 0x00, .mask = 0xF0}, /* Enable loop filter auto-adjust */ {.addr = 0x1F, .value = 0x08, .mask = 0x08}, /* Set Adapt Mode 1 (6.13) */ {.addr = 0x31, .value = 0x20, .mask = 0x60}, /* Disable the DFE since most applications do not need it (6.18) */ {.addr = 0x1E, .value = 0x08, .mask = 0x08}, /* Release CDR reset (6.4) */ {.addr = 0x0A, .value = 0x00, .mask = 0x0C}, /* Enable FIR (6.12) */ {.addr = 0x3D, .value = 0x80, .mask = 0x80}, /* Set Main-cursor tap sign to positive (6.12) */ {.addr = 0x3D, .value = 0x00, .mask = 0x40}, /* Set Post-cursor tap sign to negative (6.12) */ {.addr = 0x3F, .value = 0x40, .mask = 0x40}, /* Set Pre-cursor tap sign to negative (6.12) */ {.addr = 0x3E, .value = 0x40, .mask = 0x40}, /* Set Main-cursor tap magnitude to 13 (6.12) */ {.addr = 0x3D, .value = 0x0D, .mask = 0x1F}, }; static int al_eth_lm_retimer_boost_config(struct al_eth_lm_context *lm_context); static int al_eth_lm_retimer_ds25_full_config(struct al_eth_lm_context *lm_context); static bool al_eth_lm_retimer_ds25_signal_detect( struct al_eth_lm_context *lm_context, uint32_t channel); static int al_eth_lm_retimer_ds25_cdr_reset(struct al_eth_lm_context *lm_context, uint32_t channel); static bool al_eth_lm_retimer_ds25_cdr_lock( struct al_eth_lm_context *lm_context, uint32_t channel); static int al_eth_lm_retimer_25g_rx_adaptation(struct al_eth_lm_context *lm_context); struct al_eth_lm_retimer { int (*config)(struct al_eth_lm_context *lm_context); int (*reset)(struct al_eth_lm_context *lm_context, uint32_t channel); bool (*signal_detect)(struct al_eth_lm_context *lm_context, uint32_t channel); bool (*cdr_lock)(struct al_eth_lm_context *lm_context, uint32_t channel); int (*rx_adaptation)(struct al_eth_lm_context *lm_context); }; static struct al_eth_lm_retimer retimer[] = { {.config = al_eth_lm_retimer_boost_config, .signal_detect = NULL, .reset = NULL, .cdr_lock = NULL, .rx_adaptation = NULL}, {.config = al_eth_lm_retimer_boost_config, .signal_detect = NULL, .reset = NULL, .cdr_lock = NULL, .rx_adaptation = NULL}, {.config = al_eth_lm_retimer_ds25_full_config, .signal_detect = al_eth_lm_retimer_ds25_signal_detect, .reset = al_eth_lm_retimer_ds25_cdr_reset, .cdr_lock = al_eth_lm_retimer_ds25_cdr_lock, .rx_adaptation = al_eth_lm_retimer_25g_rx_adaptation}, }; #define SFP_10G_DA_ACTIVE 0x8 #define SFP_10G_DA_PASSIVE 0x4 #define lm_debug(...) \ do { \ if (lm_context->debug) \ al_warn(__VA_ARGS__); \ else \ al_dbg(__VA_ARGS__); \ } while (0) static int al_eth_sfp_detect(struct al_eth_lm_context *lm_context, enum al_eth_lm_link_mode *new_mode) { int rc = 0; uint8_t sfp_10g; uint8_t sfp_1g; uint8_t sfp_cable_tech; uint8_t sfp_da_len; uint8_t signal_rate; do { rc = lm_context->i2c_read(lm_context->i2c_context, lm_context->sfp_bus_id, lm_context->sfp_i2c_addr, SFP_I2C_HEADER_10G_IDX, &sfp_10g); if (rc != 0) break; rc = lm_context->i2c_read(lm_context->i2c_context, lm_context->sfp_bus_id, lm_context->sfp_i2c_addr, SFP_I2C_HEADER_1G_IDX, &sfp_1g); if (rc != 0) break; rc = lm_context->i2c_read(lm_context->i2c_context, lm_context->sfp_bus_id, lm_context->sfp_i2c_addr, SFP_I2C_HEADER_10G_DA_IDX, &sfp_cable_tech); if (rc != 0) break; rc = lm_context->i2c_read(lm_context->i2c_context, lm_context->sfp_bus_id, lm_context->sfp_i2c_addr, SFP_I2C_HEADER_10G_DA_LEN_IDX, &sfp_da_len); if (rc != 0) break; rc = lm_context->i2c_read(lm_context->i2c_context, lm_context->sfp_bus_id, lm_context->sfp_i2c_addr, SFP_I2C_HEADER_SIGNAL_RATE, &signal_rate); } while (0); if (rc != 0) { if (rc == ETIMEDOUT) { /* ETIMEDOUT is returned when no SFP is connected */ if (lm_context->mode != AL_ETH_LM_MODE_DISCONNECTED) lm_debug("%s: SFP Disconnected\n", __func__); *new_mode = AL_ETH_LM_MODE_DISCONNECTED; } else { return (rc); } } else if ((sfp_cable_tech & (SFP_10G_DA_PASSIVE | SFP_10G_DA_ACTIVE)) != 0) { if ((signal_rate >= SFP_MIN_SIGNAL_RATE_25G) && ((lm_context->max_speed == AL_ETH_LM_MAX_SPEED_25G) || (lm_context->max_speed == AL_ETH_LM_MAX_SPEED_MAX))) *new_mode = AL_ETH_LM_MODE_25G; else if ((signal_rate >= SFP_MIN_SIGNAL_RATE_10G) && ((lm_context->max_speed == AL_ETH_LM_MAX_SPEED_10G) || (lm_context->max_speed == AL_ETH_LM_MAX_SPEED_MAX))) *new_mode = AL_ETH_LM_MODE_10G_DA; else *new_mode = AL_ETH_LM_MODE_1G; lm_debug("%s: %s DAC (%d M) detected (max signal rate %d)\n", __func__, (sfp_cable_tech & SFP_10G_DA_PASSIVE) ? "Passive" : "Active", sfp_da_len, signal_rate); /* for active direct attached need to use len 0 in the retimer configuration */ lm_context->da_len = (sfp_cable_tech & SFP_10G_DA_PASSIVE) ? sfp_da_len : 0; } else if (sfp_10g != 0) { lm_debug("%s: 10 SFP detected\n", __func__); *new_mode = AL_ETH_LM_MODE_10G_OPTIC; } else if (sfp_1g != 0) { lm_debug("%s: 1G SFP detected\n", __func__); *new_mode = AL_ETH_LM_MODE_1G; } else { al_warn("%s: unknown SFP inserted. eeprom content: 10G compliance 0x%x," " 1G compliance 0x%x, sfp+cable 0x%x. default to %s\n", __func__, sfp_10g, sfp_1g, sfp_cable_tech, al_eth_lm_mode_convert_to_str(lm_context->default_mode)); *new_mode = lm_context->default_mode; lm_context->da_len = lm_context->default_dac_len; } if ((lm_context->sfp_detect_force_mode) && (*new_mode != AL_ETH_LM_MODE_DISCONNECTED) && (*new_mode != lm_context->default_mode)) { al_warn("%s: Force mode to default (%s). mode based of the SFP EEPROM %s\n", __func__, al_eth_lm_mode_convert_to_str(lm_context->default_mode), al_eth_lm_mode_convert_to_str(*new_mode)); *new_mode = lm_context->default_mode; } lm_context->mode = *new_mode; return (0); } static int al_eth_qsfp_detect(struct al_eth_lm_context *lm_context, enum al_eth_lm_link_mode *new_mode) { int rc = 0; uint8_t qsfp_comp_code; uint8_t qsfp_da_len; do { rc = lm_context->i2c_read(lm_context->i2c_context, lm_context->sfp_bus_id, lm_context->sfp_i2c_addr, QSFP_COMPLIANCE_CODE_IDX, &qsfp_comp_code); if (rc != 0) break; rc = lm_context->i2c_read(lm_context->i2c_context, lm_context->sfp_bus_id, lm_context->sfp_i2c_addr, QSFP_CABLE_LEN_IDX, &qsfp_da_len); if (rc != 0) break; } while (0); if (rc != 0) { if (rc == ETIMEDOUT) { /* ETIMEDOUT is returned when no SFP is connected */ lm_debug("%s: SFP Disconnected\n", __func__); *new_mode = AL_ETH_LM_MODE_DISCONNECTED; } else { return (rc); } } else if ((qsfp_comp_code & QSFP_COMPLIANCE_CODE_DAC) != 0) { lm_debug("%s: 10G passive DAC (%d M) detected\n", __func__, qsfp_da_len); *new_mode = AL_ETH_LM_MODE_10G_DA; lm_context->da_len = qsfp_da_len; } else if ((qsfp_comp_code & QSFP_COMPLIANCE_CODE_OPTIC) != 0) { lm_debug("%s: 10G optic module detected\n", __func__); *new_mode = AL_ETH_LM_MODE_10G_OPTIC; } else { al_warn("%s: unknown QSFP inserted. eeprom content: 10G " "compliance 0x%x default to %s\n", __func__, qsfp_comp_code, al_eth_lm_mode_convert_to_str(lm_context->default_mode)); *new_mode = lm_context->default_mode; lm_context->da_len = lm_context->default_dac_len; } lm_context->mode = *new_mode; return (0); } static int al_eth_module_detect(struct al_eth_lm_context *lm_context, enum al_eth_lm_link_mode *new_mode) { int rc = 0; uint8_t module_idx; int sfp_present = SFP_PRESENT; if ((lm_context->gpio_get) && (lm_context->gpio_present != 0)) sfp_present = lm_context->gpio_get(lm_context->gpio_present); if (sfp_present == SFP_NOT_PRESENT) { lm_debug("%s: SFP not exist\n", __func__); *new_mode = AL_ETH_LM_MODE_DISCONNECTED; return 0; } rc = lm_context->i2c_read(lm_context->i2c_context, lm_context->sfp_bus_id, lm_context->sfp_i2c_addr, MODULE_IDENTIFIER_IDX, &module_idx); if (rc != 0) { if (rc == ETIMEDOUT) { /* ETIMEDOUT is returned when no SFP is connected */ if (lm_context->mode != AL_ETH_LM_MODE_DISCONNECTED) lm_debug("%s: SFP Disconnected\n", __func__); *new_mode = AL_ETH_LM_MODE_DISCONNECTED; return (0); } else { return (rc); } } if (module_idx == MODULE_IDENTIFIER_QSFP) return (al_eth_qsfp_detect(lm_context, new_mode)); else return (al_eth_sfp_detect(lm_context, new_mode)); return (0); } static struct al_serdes_adv_tx_params da_tx_params = { .override = AL_TRUE, .amp = 0x1, .total_driver_units = 0x13, .c_plus_1 = 0x2, .c_plus_2 = 0, .c_minus_1 = 0x2, .slew_rate = 0, }; static struct al_serdes_adv_rx_params da_rx_params = { .override = AL_TRUE, .dcgain = 0x4, .dfe_3db_freq = 0x4, .dfe_gain = 0x3, .dfe_first_tap_ctrl = 0x5, .dfe_secound_tap_ctrl = 0x1, .dfe_third_tap_ctrl = 0x8, .dfe_fourth_tap_ctrl = 0x1, .low_freq_agc_gain = 0x7, .precal_code_sel = 0, .high_freq_agc_boost = 0x1d, }; static struct al_serdes_adv_tx_params optic_tx_params = { .override = AL_TRUE, .amp = 0x1, .total_driver_units = 0x13, .c_plus_1 = 0x2, .c_plus_2 = 0, .c_minus_1 = 0, .slew_rate = 0, }; static struct al_serdes_adv_rx_params optic_rx_params = { .override = AL_TRUE, .dcgain = 0x0, .dfe_3db_freq = 0x7, .dfe_gain = 0x0, .dfe_first_tap_ctrl = 0x0, .dfe_secound_tap_ctrl = 0x8, .dfe_third_tap_ctrl = 0x0, .dfe_fourth_tap_ctrl = 0x8, .low_freq_agc_gain = 0x7, .precal_code_sel = 0, .high_freq_agc_boost = 0x4, }; static void al_eth_serdes_static_tx_params_set(struct al_eth_lm_context *lm_context) { if (lm_context->tx_param_dirty == 0) return; if (lm_context->serdes_tx_params_valid != 0) { lm_context->tx_param_dirty = 0; lm_context->tx_params_override.override = AL_TRUE; if ((lm_context->serdes_obj->tx_advanced_params_set) == 0) { al_err("tx_advanced_params_set is not supported for this serdes group\n"); return; } lm_context->serdes_obj->tx_advanced_params_set( lm_context->serdes_obj, lm_context->lane, &lm_context->tx_params_override); } else if (lm_context->static_values != 0) { lm_context->tx_param_dirty = 0; if ((lm_context->serdes_obj->tx_advanced_params_set) == 0) { al_err("tx_advanced_params_set is not supported for this serdes group\n"); return; } if ((lm_context->retimer_exist == 0) && (lm_context->mode == AL_ETH_LM_MODE_10G_DA)) lm_context->serdes_obj->tx_advanced_params_set( lm_context->serdes_obj, lm_context->lane, &da_tx_params); else lm_context->serdes_obj->tx_advanced_params_set( lm_context->serdes_obj, lm_context->lane, &optic_tx_params); } } static void al_eth_serdes_static_rx_params_set(struct al_eth_lm_context *lm_context) { if (lm_context->rx_param_dirty == 0) return; if (lm_context->serdes_rx_params_valid != 0) { lm_context->rx_param_dirty = 0; lm_context->rx_params_override.override = AL_TRUE; if ((lm_context->serdes_obj->rx_advanced_params_set) == 0) { al_err("rx_advanced_params_set is not supported for this serdes group\n"); return; } lm_context->serdes_obj->rx_advanced_params_set( lm_context->serdes_obj, lm_context->lane, &lm_context->rx_params_override); } else if (lm_context->static_values != 0) { lm_context->rx_param_dirty = 0; if ((lm_context->serdes_obj->rx_advanced_params_set) == 0) { al_err("rx_advanced_params_set is not supported for this serdes group\n"); return; } if ((lm_context->retimer_exist == 0) && (lm_context->mode == AL_ETH_LM_MODE_10G_DA)) lm_context->serdes_obj->rx_advanced_params_set( lm_context->serdes_obj, lm_context->lane, &da_rx_params); else lm_context->serdes_obj->rx_advanced_params_set( lm_context->serdes_obj, lm_context->lane, &optic_rx_params); } } static int al_eth_rx_equal_run(struct al_eth_lm_context *lm_context) { struct al_serdes_adv_rx_params rx_params; int dcgain; int best_dcgain = -1; int i; int best_score = -1; int test_score = -1; rx_params.override = AL_FALSE; lm_context->serdes_obj->rx_advanced_params_set(lm_context->serdes_obj, lm_context->lane, &rx_params); lm_debug("score | dcgain | dfe3db | dfegain | tap1 | tap2 | tap3 | " "tap4 | low freq | high freq\n"); for (dcgain = 0; dcgain < AL_ETH_LM_MAX_DCGAIN; dcgain++) { lm_context->serdes_obj->dcgain_set( lm_context->serdes_obj, dcgain); test_score = lm_context->serdes_obj->rx_equalization( lm_context->serdes_obj, lm_context->lane); if (test_score < 0) { al_warn("serdes rx equalization failed on error\n"); return (test_score); } if (test_score > best_score) { best_score = test_score; best_dcgain = dcgain; } lm_context->serdes_obj->rx_advanced_params_get( lm_context->serdes_obj, lm_context->lane, &rx_params); lm_debug("%6d|%8x|%8x|%9x|%6x|%6x|%6x|%6x|%10x|%10x|\n", test_score, rx_params.dcgain, rx_params.dfe_3db_freq, rx_params.dfe_gain, rx_params.dfe_first_tap_ctrl, rx_params.dfe_secound_tap_ctrl, rx_params.dfe_third_tap_ctrl, rx_params.dfe_fourth_tap_ctrl, rx_params.low_freq_agc_gain, rx_params.high_freq_agc_boost); } lm_context->serdes_obj->dcgain_set( lm_context->serdes_obj, best_dcgain); best_score = -1; for(i = 0; i < AL_ETH_LM_EQ_ITERATIONS; i++) { test_score = lm_context->serdes_obj->rx_equalization( lm_context->serdes_obj, lm_context->lane); if (test_score < 0) { al_warn("serdes rx equalization failed on error\n"); return (test_score); } if (test_score > best_score) { best_score = test_score; lm_context->serdes_obj->rx_advanced_params_get( lm_context->serdes_obj, lm_context->lane, &rx_params); } } rx_params.precal_code_sel = 0; rx_params.override = AL_TRUE; lm_context->serdes_obj->rx_advanced_params_set( lm_context->serdes_obj, lm_context->lane, &rx_params); lm_debug("-------------------- best dcgain %d ------------------------------------\n", best_dcgain); lm_debug("%6d|%8x|%8x|%9x|%6x|%6x|%6x|%6x|%10x|%10x|\n", best_score, rx_params.dcgain, rx_params.dfe_3db_freq, rx_params.dfe_gain, rx_params.dfe_first_tap_ctrl, rx_params.dfe_secound_tap_ctrl, rx_params.dfe_third_tap_ctrl, rx_params.dfe_fourth_tap_ctrl, rx_params.low_freq_agc_gain, rx_params.high_freq_agc_boost); return (0); } static int al_eth_lm_retimer_boost_config(struct al_eth_lm_context *lm_context) { int i; int rc = 0; uint8_t boost = 0; uint32_t boost_addr = al_eth_retimer_boost_addr[lm_context->retimer_channel][lm_context->retimer_type]; if (lm_context->mode != AL_ETH_LM_MODE_10G_DA) { boost = al_eth_retimer_boost_value[0][lm_context->retimer_type]; } else { for (i = 0; i < RETIMER_LENS_MAX; i++) { if (lm_context->da_len <= al_eth_retimer_boost_lens[i]) { boost = al_eth_retimer_boost_value[i][lm_context->retimer_type]; break; } } if (i == RETIMER_LENS_MAX) boost = al_eth_retimer_boost_value[RETIMER_LENS_MAX][lm_context->retimer_type]; } lm_debug("config retimer boost in channel %d (addr %x) to 0x%x\n", lm_context->retimer_channel, boost_addr, boost); rc = lm_context->i2c_write(lm_context->i2c_context, lm_context->retimer_bus_id, lm_context->retimer_i2c_addr, boost_addr, boost); if (rc != 0) { al_err("%s: Error occurred (%d) while writing retimer " "configuration (bus-id %x i2c-addr %x)\n", __func__, rc, lm_context->retimer_bus_id, lm_context->retimer_i2c_addr); return (rc); } return (0); } /******************************************************************************* ************************** retimer DS25 *************************************** ******************************************************************************/ #define LM_DS25_CHANNEL_EN_REG 0xff #define LM_DS25_CHANNEL_EN_MASK 0x03 #define LM_DS25_CHANNEL_EN_VAL 0x01 #define LM_DS25_CHANNEL_SEL_REG 0xfc #define LM_DS25_CHANNEL_SEL_MASK 0xff #define LM_DS25_CDR_RESET_REG 0x0a #define LM_DS25_CDR_RESET_MASK 0x0c #define LM_DS25_CDR_RESET_ASSERT 0x0c #define LM_DS25_CDR_RESET_RELEASE 0x00 #define LM_DS25_SIGNAL_DETECT_REG 0x78 #define LM_DS25_SIGNAL_DETECT_MASK 0x20 #define LM_DS25_CDR_LOCK_REG 0x78 #define LM_DS25_CDR_LOCK_MASK 0x10 #define LM_DS25_DRV_PD_REG 0x15 #define LM_DS25_DRV_PD_MASK 0x08 static int al_eth_lm_retimer_ds25_write_reg(struct al_eth_lm_context *lm_context, uint8_t reg_addr, uint8_t reg_mask, uint8_t reg_value) { uint8_t reg; int rc; rc = lm_context->i2c_read(lm_context->i2c_context, lm_context->retimer_bus_id, lm_context->retimer_i2c_addr, reg_addr, ®); if (rc != 0) return (EIO); reg &= ~(reg_mask); reg |= reg_value; rc = lm_context->i2c_write(lm_context->i2c_context, lm_context->retimer_bus_id, lm_context->retimer_i2c_addr, reg_addr, reg); if (rc != 0) return (EIO); return (0); } static int al_eth_lm_retimer_ds25_channel_select(struct al_eth_lm_context *lm_context, uint8_t channel) { int rc = 0; /* Write to specific channel */ rc = al_eth_lm_retimer_ds25_write_reg(lm_context, LM_DS25_CHANNEL_EN_REG, LM_DS25_CHANNEL_EN_MASK, LM_DS25_CHANNEL_EN_VAL); if (rc != 0) return (rc); rc = al_eth_lm_retimer_ds25_write_reg(lm_context, LM_DS25_CHANNEL_SEL_REG, LM_DS25_CHANNEL_SEL_MASK, (1 << channel)); return (rc); } static int al_eth_lm_retimer_ds25_channel_config(struct al_eth_lm_context *lm_context, uint8_t channel, struct retimer_config_reg *config, uint8_t config_size) { uint8_t i; int rc; rc = al_eth_lm_retimer_ds25_channel_select(lm_context, channel); if (rc != 0) goto config_error; for (i = 0; i < config_size; i++) { rc = al_eth_lm_retimer_ds25_write_reg(lm_context, config[i].addr, config[i].mask, config[i].value); if (rc != 0) goto config_error; } lm_debug("%s: retimer channel config done for channel %d\n", __func__, channel); return (0); config_error: al_err("%s: failed to access to the retimer\n", __func__); return (rc); } static int al_eth_lm_retimer_ds25_cdr_reset(struct al_eth_lm_context *lm_context, uint32_t channel) { int rc; lm_debug("Perform CDR reset to channel %d\n", channel); rc = al_eth_lm_retimer_ds25_channel_select(lm_context, channel); if (rc) goto config_error; rc = al_eth_lm_retimer_ds25_write_reg(lm_context, LM_DS25_CDR_RESET_REG, LM_DS25_CDR_RESET_MASK, LM_DS25_CDR_RESET_ASSERT); if (rc) goto config_error; rc = al_eth_lm_retimer_ds25_write_reg(lm_context, LM_DS25_CDR_RESET_REG, LM_DS25_CDR_RESET_MASK, LM_DS25_CDR_RESET_RELEASE); if (rc) goto config_error; return 0; config_error: al_err("%s: failed to access to the retimer\n", __func__); return rc; } static bool al_eth_lm_retimer_ds25_signal_detect(struct al_eth_lm_context *lm_context, uint32_t channel) { int rc = 0; uint8_t reg; rc = al_eth_lm_retimer_ds25_channel_select(lm_context, channel); if (rc) goto config_error; rc = lm_context->i2c_read(lm_context->i2c_context, lm_context->retimer_bus_id, lm_context->retimer_i2c_addr, LM_DS25_SIGNAL_DETECT_REG, ®); if (rc) goto config_error; if (reg & LM_DS25_SIGNAL_DETECT_MASK) return true; return false; config_error: al_err("%s: failed to access to the retimer\n", __func__); return false; } static bool al_eth_lm_retimer_ds25_cdr_lock(struct al_eth_lm_context *lm_context, uint32_t channel) { int rc = 0; uint8_t reg; rc = al_eth_lm_retimer_ds25_channel_select(lm_context, channel); if (rc) goto config_error; rc = lm_context->i2c_read(lm_context->i2c_context, lm_context->retimer_bus_id, lm_context->retimer_i2c_addr, LM_DS25_CDR_LOCK_REG, ®); if (rc) goto config_error; if (reg & LM_DS25_CDR_LOCK_MASK) return true; return false; config_error: al_err("%s: failed to access to the retimer\n", __func__); return false; } static bool al_eth_lm_wait_for_lock(struct al_eth_lm_context *lm_context, uint32_t channel) { uint32_t timeout = AL_ETH_LM_RETIMER_WAIT_FOR_LOCK; bool lock = false; while ((timeout > 0) && (!lock)) { al_msleep(10); timeout -= 10; lock = retimer[lm_context->retimer_type].cdr_lock(lm_context, channel); } lm_debug("%s: %s to achieve CDR lock in %d msec\n", __func__, (lock) ? "succeed" : "FAILED", (AL_ETH_LM_RETIMER_WAIT_FOR_LOCK - timeout)); return lock; } static void al_eth_lm_retimer_signal_lock_check(struct al_eth_lm_context *lm_context, uint32_t channel, bool *ready) { bool signal_detect = true; bool cdr_lock = true; if (retimer[lm_context->retimer_type].signal_detect) { if (!retimer[lm_context->retimer_type].signal_detect(lm_context, channel)) { lm_debug("no signal detected on retimer channel %d\n", channel); signal_detect = false; } else { if (retimer[lm_context->retimer_type].cdr_lock) { cdr_lock = retimer[lm_context->retimer_type].cdr_lock( lm_context, channel); if (!cdr_lock) { if (retimer[lm_context->retimer_type].reset) { retimer[lm_context->retimer_type].reset(lm_context, channel); cdr_lock = al_eth_lm_wait_for_lock(lm_context, channel); } } } } } al_info("%s: (channel %d) signal %d cdr lock %d\n", __func__, channel, signal_detect, (signal_detect) ? cdr_lock : 0); *ready = (cdr_lock && signal_detect); } static int al_eth_lm_retimer_ds25_full_config(struct al_eth_lm_context *lm_context) { int rc = 0; bool ready; struct retimer_config_reg *config_tx; uint32_t config_tx_size; struct retimer_config_reg *config_rx; uint32_t config_rx_size; if (lm_context->mode == AL_ETH_LM_MODE_25G) { config_tx = retimer_ds25_25g_mode_tx_ch; config_tx_size = AL_ARR_SIZE(retimer_ds25_25g_mode_tx_ch); config_rx = retimer_ds25_25g_mode_rx_ch; config_rx_size = AL_ARR_SIZE(retimer_ds25_25g_mode_rx_ch); } else { config_tx = retimer_ds25_10g_mode; config_tx_size = AL_ARR_SIZE(retimer_ds25_10g_mode); config_rx = retimer_ds25_10g_mode; config_rx_size = AL_ARR_SIZE(retimer_ds25_10g_mode); } rc = al_eth_lm_retimer_ds25_channel_config(lm_context, lm_context->retimer_channel, config_rx, config_rx_size); if (rc) return rc; rc = al_eth_lm_retimer_ds25_channel_config(lm_context, lm_context->retimer_tx_channel, config_tx, config_tx_size); if (rc) return rc; if (lm_context->serdes_obj->type_get() == AL_SRDS_TYPE_25G) { lm_debug("%s: serdes 25G - perform tx and rx gearbox reset\n", __func__); al_eth_gearbox_reset(lm_context->adapter, AL_TRUE, AL_TRUE); DELAY(AL_ETH_LM_GEARBOX_RESET_DELAY); } al_eth_lm_retimer_signal_lock_check(lm_context, lm_context->retimer_tx_channel, &ready); if (!ready) { lm_debug("%s: Failed to lock tx channel!\n", __func__); return (1); } lm_debug("%s: retimer full configuration done\n", __func__); return rc; } static int al_eth_lm_retimer_25g_rx_adaptation(struct al_eth_lm_context *lm_context) { int rc = 0; bool ready; al_eth_lm_retimer_signal_lock_check(lm_context, lm_context->retimer_channel, &ready); if (!ready) { lm_debug("%s: no signal detected on retimer Rx channel (%d)\n", __func__, lm_context->retimer_channel); return rc; } al_msleep(AL_ETH_LM_SERDES_WAIT_FOR_LOCK); return 0; } static int al_eth_lm_check_for_link(struct al_eth_lm_context *lm_context, bool *link_up) { struct al_eth_link_status status; int ret = 0; al_eth_link_status_clear(lm_context->adapter); al_eth_link_status_get(lm_context->adapter, &status); if (status.link_up == AL_TRUE) { lm_debug("%s: >>>> Link state DOWN ==> UP\n", __func__); al_eth_led_set(lm_context->adapter, AL_TRUE); lm_context->link_state = AL_ETH_LM_LINK_UP; *link_up = true; return 0; } else if (status.local_fault) { lm_context->link_state = AL_ETH_LM_LINK_DOWN; al_eth_led_set(lm_context->adapter, AL_FALSE); al_err("%s: Failed to establish link\n", __func__); ret = 1; } else { lm_debug("%s: >>>> Link state DOWN ==> DOWN_RF\n", __func__); lm_context->link_state = AL_ETH_LM_LINK_DOWN_RF; al_eth_led_set(lm_context->adapter, AL_FALSE); ret = 0; } *link_up = false; return ret; } /*****************************************************************************/ /***************************** API functions *********************************/ /*****************************************************************************/ int al_eth_lm_init(struct al_eth_lm_context *lm_context, struct al_eth_lm_init_params *params) { lm_context->adapter = params->adapter; lm_context->serdes_obj = params->serdes_obj; lm_context->lane = params->lane; lm_context->sfp_detection = params->sfp_detection; lm_context->sfp_bus_id = params->sfp_bus_id; lm_context->sfp_i2c_addr = params->sfp_i2c_addr; lm_context->retimer_exist = params->retimer_exist; lm_context->retimer_type = params->retimer_type; lm_context->retimer_bus_id = params->retimer_bus_id; lm_context->retimer_i2c_addr = params->retimer_i2c_addr; lm_context->retimer_channel = params->retimer_channel; lm_context->retimer_tx_channel = params->retimer_tx_channel; lm_context->default_mode = params->default_mode; lm_context->default_dac_len = params->default_dac_len; lm_context->link_training = params->link_training; lm_context->rx_equal = params->rx_equal; lm_context->static_values = params->static_values; lm_context->i2c_read = params->i2c_read; lm_context->i2c_write = params->i2c_write; lm_context->i2c_context = params->i2c_context; lm_context->get_random_byte = params->get_random_byte; /* eeprom_read must be provided if sfp_detection is true */ al_assert((lm_context->sfp_detection == false) || (lm_context->i2c_read != NULL)); al_assert((lm_context->retimer_exist == false) || (lm_context->i2c_write != NULL)); lm_context->local_adv.selector_field = 1; lm_context->local_adv.capability = 0; lm_context->local_adv.remote_fault = 0; lm_context->local_adv.acknowledge = 0; lm_context->local_adv.next_page = 0; lm_context->local_adv.technology = AL_ETH_AN_TECH_10GBASE_KR; lm_context->local_adv.fec_capability = params->kr_fec_enable; lm_context->mode = AL_ETH_LM_MODE_DISCONNECTED; lm_context->serdes_tx_params_valid = false; lm_context->serdes_rx_params_valid = false; lm_context->rx_param_dirty = 1; lm_context->tx_param_dirty = 1; lm_context->gpio_get = params->gpio_get; lm_context->gpio_present = params->gpio_present; lm_context->max_speed = params->max_speed; lm_context->sfp_detect_force_mode = params->sfp_detect_force_mode; lm_context->lm_pause = params->lm_pause; lm_context->led_config = params->led_config; lm_context->retimer_configured = false; lm_context->link_state = AL_ETH_LM_LINK_DOWN; return (0); } int al_eth_lm_link_detection(struct al_eth_lm_context *lm_context, bool *link_fault, enum al_eth_lm_link_mode *old_mode, enum al_eth_lm_link_mode *new_mode) { int err; struct al_eth_link_status status; al_assert(lm_context != NULL); al_assert(old_mode != NULL); al_assert(new_mode != NULL); /** * if Link management is disabled, report no link fault in case the link was up * before and set new mode to disconnected to avoid calling to link establish * if the link wasn't up. */ if (lm_context->lm_pause != NULL) { bool lm_pause = lm_context->lm_pause(lm_context->i2c_context); if (lm_pause == true) { *new_mode = AL_ETH_LM_MODE_DISCONNECTED; if (link_fault != NULL) { if (lm_context->link_state == AL_ETH_LM_LINK_UP) *link_fault = false; else *link_fault = true; } return 0; } } *old_mode = lm_context->mode; *new_mode = lm_context->mode; if (link_fault != NULL) *link_fault = true; switch (lm_context->link_state) { case AL_ETH_LM_LINK_UP: al_eth_link_status_get(lm_context->adapter, &status); if (status.link_up) { if (link_fault != NULL) *link_fault = false; al_eth_led_set(lm_context->adapter, AL_TRUE); return (0); } else if (status.local_fault) { lm_debug("%s: >>>> Link state UP ==> DOWN\n", __func__); lm_context->link_state = AL_ETH_LM_LINK_DOWN; } else { lm_debug("%s: >>>> Link state UP ==> DOWN_RF\n", __func__); lm_context->link_state = AL_ETH_LM_LINK_DOWN_RF; } break; case AL_ETH_LM_LINK_DOWN_RF: al_eth_link_status_get(lm_context->adapter, &status); if (status.local_fault) { lm_debug("%s: >>>> Link state DOWN_RF ==> DOWN\n", __func__); lm_context->link_state = AL_ETH_LM_LINK_DOWN; break; } else if (status.remote_fault == AL_FALSE) { lm_debug("%s: >>>> Link state DOWN_RF ==> UP\n", __func__); lm_context->link_state = AL_ETH_LM_LINK_UP; } /* in case of remote fault only no need to check SFP again */ return (0); case AL_ETH_LM_LINK_DOWN: break; }; al_eth_led_set(lm_context->adapter, AL_FALSE); if (lm_context->sfp_detection) { err = al_eth_module_detect(lm_context, new_mode); if (err != 0) { al_err("module_detection failed!\n"); return (err); } lm_context->mode = *new_mode; } else { lm_context->mode = lm_context->default_mode; *new_mode = lm_context->mode; } if (*old_mode != *new_mode) { al_info("%s: New SFP mode detected %s -> %s\n", __func__, al_eth_lm_mode_convert_to_str(*old_mode), al_eth_lm_mode_convert_to_str(*new_mode)); lm_context->rx_param_dirty = 1; lm_context->tx_param_dirty = 1; lm_context->new_port = true; if ((*new_mode != AL_ETH_LM_MODE_DISCONNECTED) && (lm_context->led_config)) { struct al_eth_lm_led_config_data data = {0}; switch (*new_mode) { case AL_ETH_LM_MODE_10G_OPTIC: case AL_ETH_LM_MODE_10G_DA: data.speed = AL_ETH_LM_LED_CONFIG_10G; break; case AL_ETH_LM_MODE_1G: data.speed = AL_ETH_LM_LED_CONFIG_1G; break; case AL_ETH_LM_MODE_25G: data.speed = AL_ETH_LM_LED_CONFIG_25G; break; default: al_err("%s: unknown LM mode!\n", __func__); }; lm_context->led_config(lm_context->i2c_context, &data); } } return (0); } int al_eth_lm_link_establish(struct al_eth_lm_context *lm_context, bool *link_up) { bool signal_detected; int ret = 0; switch (lm_context->link_state) { case AL_ETH_LM_LINK_UP: *link_up = true; lm_debug("%s: return link up\n", __func__); return (0); case AL_ETH_LM_LINK_DOWN_RF: *link_up = false; lm_debug("%s: return link down (DOWN_RF)\n", __func__); return (0); case AL_ETH_LM_LINK_DOWN: break; }; /** * At this point we will get LM disable only if changed to disable after link detection * finished. in this case link will not be established until LM will be enable again. */ if (lm_context->lm_pause) { bool lm_pause = lm_context->lm_pause(lm_context->i2c_context); if (lm_pause == true) { *link_up = false; return (0); } } if ((lm_context->new_port) && (lm_context->retimer_exist)) { al_eth_serdes_static_rx_params_set(lm_context); al_eth_serdes_static_tx_params_set(lm_context); #if 0 al_eth_lm_retimer_config(lm_context); DELAY(AL_ETH_LM_RETIMER_LINK_STATUS_DELAY); #endif if (retimer[lm_context->retimer_type].config(lm_context)) { al_info("%s: failed to configure the retimer\n", __func__); *link_up = false; return (1); } lm_context->new_port = false; DELAY(1000); } if (lm_context->retimer_exist) { if (retimer[lm_context->retimer_type].rx_adaptation) { ret = retimer[lm_context->retimer_type].rx_adaptation(lm_context); if (ret != 0) { lm_debug("retimer rx is not ready\n"); *link_up = false; return (0); } } } signal_detected = lm_context->serdes_obj->signal_is_detected( lm_context->serdes_obj, lm_context->lane); if (signal_detected == false) { /* if no signal detected there is nothing to do */ lm_debug("serdes signal is down\n"); *link_up = false; return 0; } if (lm_context->serdes_obj->type_get() == AL_SRDS_TYPE_25G) { lm_debug("%s: serdes 25G - perform rx gearbox reset\n", __func__); al_eth_gearbox_reset(lm_context->adapter, AL_FALSE, AL_TRUE); DELAY(AL_ETH_LM_GEARBOX_RESET_DELAY); } if (lm_context->retimer_exist) { DELAY(AL_ETH_LM_RETIMER_LINK_STATUS_DELAY); ret = al_eth_lm_check_for_link(lm_context, link_up); if (ret == 0) { lm_debug("%s: link is up with retimer\n", __func__); return 0; } return ret; } if ((lm_context->mode == AL_ETH_LM_MODE_10G_DA) && (lm_context->link_training)) { lm_context->local_adv.transmitted_nonce = lm_context->get_random_byte(); lm_context->local_adv.transmitted_nonce &= 0x1f; ret = al_eth_an_lt_execute(lm_context->adapter, lm_context->serdes_obj, lm_context->lane, &lm_context->local_adv, &lm_context->partner_adv); lm_context->rx_param_dirty = 1; lm_context->tx_param_dirty = 1; if (ret == 0) { al_info("%s: link training finished successfully\n", __func__); lm_context->link_training_failures = 0; ret = al_eth_lm_check_for_link(lm_context, link_up); if (ret == 0) { lm_debug("%s: link is up with LT\n", __func__); return (0); } } lm_context->link_training_failures++; if (lm_context->link_training_failures > AL_ETH_LT_FAILURES_TO_RESET) { lm_debug("%s: failed to establish LT %d times. reset serdes\n", __func__, AL_ETH_LT_FAILURES_TO_RESET); lm_context->serdes_obj->pma_hard_reset_lane( lm_context->serdes_obj, lm_context->lane, AL_TRUE); lm_context->serdes_obj->pma_hard_reset_lane( lm_context->serdes_obj, lm_context->lane, AL_FALSE); lm_context->link_training_failures = 0; } } al_eth_serdes_static_tx_params_set(lm_context); if ((lm_context->mode == AL_ETH_LM_MODE_10G_DA) && (lm_context->rx_equal)) { ret = al_eth_rx_equal_run(lm_context); if (ret == 0) { DELAY(AL_ETH_LM_LINK_STATUS_DELAY); ret = al_eth_lm_check_for_link(lm_context, link_up); if (ret == 0) { lm_debug("%s: link is up with Rx Equalization\n", __func__); return (0); } } } al_eth_serdes_static_rx_params_set(lm_context); DELAY(AL_ETH_LM_LINK_STATUS_DELAY); ret = al_eth_lm_check_for_link(lm_context, link_up); if (ret == 0) { lm_debug("%s: link is up with static parameters\n", __func__); return (0); } *link_up = false; return (1); } int al_eth_lm_static_parameters_override(struct al_eth_lm_context *lm_context, struct al_serdes_adv_tx_params *tx_params, struct al_serdes_adv_rx_params *rx_params) { if (tx_params != NULL) { lm_context->tx_params_override = *tx_params; lm_context->tx_param_dirty = 1; lm_context->serdes_tx_params_valid = true; } if (rx_params != NULL) { lm_context->rx_params_override = *rx_params; lm_context->rx_param_dirty = 1; lm_context->serdes_rx_params_valid = true; } return (0); } int al_eth_lm_static_parameters_override_disable(struct al_eth_lm_context *lm_context, bool tx_params, bool rx_params) { if (tx_params) lm_context->serdes_tx_params_valid = false; if (rx_params) lm_context->serdes_tx_params_valid = false; return (0); } int al_eth_lm_static_parameters_get(struct al_eth_lm_context *lm_context, struct al_serdes_adv_tx_params *tx_params, struct al_serdes_adv_rx_params *rx_params) { if (tx_params != NULL) { if (lm_context->serdes_tx_params_valid) *tx_params = lm_context->tx_params_override; else lm_context->serdes_obj->tx_advanced_params_get( lm_context->serdes_obj, lm_context->lane, tx_params); } if (rx_params != NULL) { if (lm_context->serdes_rx_params_valid) *rx_params = lm_context->rx_params_override; else lm_context->serdes_obj->rx_advanced_params_get( lm_context->serdes_obj, lm_context->lane, rx_params); } return (0); } const char * al_eth_lm_mode_convert_to_str(enum al_eth_lm_link_mode val) { switch (val) { case AL_ETH_LM_MODE_DISCONNECTED: return ("AL_ETH_LM_MODE_DISCONNECTED"); case AL_ETH_LM_MODE_10G_OPTIC: return ("AL_ETH_LM_MODE_10G_OPTIC"); case AL_ETH_LM_MODE_10G_DA: return ("AL_ETH_LM_MODE_10G_DA"); case AL_ETH_LM_MODE_1G: return ("AL_ETH_LM_MODE_1G"); case AL_ETH_LM_MODE_25G: return ("AL_ETH_LM_MODE_25G"); } return ("N/A"); } void al_eth_lm_debug_mode_set(struct al_eth_lm_context *lm_context, bool enable) { lm_context->debug = enable; }