al_init_eth_lm.c

/*-
 * 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 <sys/cdefs.h>
#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,
				  &reg);

	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,
				  &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,
				  &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;
}