freebsd-nq/sys/dev/al_eth/al_init_eth_kr.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>
__FBSDID("$FreeBSD$");

#include "al_init_eth_kr.h"
#include "al_serdes.h"

/**
 *  Ethernet
 *  @{
 * @file   al_init_eth_kr.c
 *
 * @brief  auto-negotiation and link training algorithms and state machines
 *
 * The link training algorithm implemented in this file going over the
 * coefficients and looking for the best eye measurement possible for every one
 * of them. it's using state machine to move between the different states.
 * the state machine has 3 parts:
 *	- preparation - waiting till the link partner (lp) will be ready and
 *			change his state to preset.
 *	- measurement (per coefficient) - issue decrement for the coefficient
 *			under control till the eye measurement not increasing
 *			and remains in the optimum.
 *	- completion - indicate the receiver is ready and wait for the lp to
 *		       finish his work.
 */

/* TODO: fix with more reasonable numbers */
/* timeout in mSec before auto-negotiation will be terminated */
#define AL_ETH_KR_AN_TIMEOUT		(500)
#define AL_ETH_KR_EYE_MEASURE_TIMEOUT	(100)
/* timeout in uSec before the process will be terminated */
#define AL_ETH_KR_FRAME_LOCK_TIMEOUT	(500 * 1000)
#define AL_ETH_KR_LT_DONE_TIMEOUT	(500 * 1000)
/* number of times the receiver and transmitter tasks will be called before the
 * algorithm will be terminated */
#define AL_ETH_KR_LT_MAX_ROUNDS		(50000)

/* mac algorithm state machine */
enum al_eth_kr_mac_lt_state {
	TX_INIT = 0,	/* start of all */
	WAIT_BEGIN,	/* wait for initial training lock */
	DO_PRESET,	/* issue PRESET to link partner */
	DO_HOLD,	/* issue HOLD to link partner */
	/* preparation is done, start testing the coefficient. */
	QMEASURE,	/* EyeQ measurement. */
	QCHECK,		/* Check if measurement shows best value. */
	DO_NEXT_TRY,	/* issue DEC command to coeff for next measurement. */
	END_STEPS,	/* perform last steps to go back to optimum. */
	END_STEPS_HOLD,	/* perform last steps HOLD command. */
	COEFF_DONE,	/* done with the current coefficient updates.
			 * Check if another should be done. */
	/* end of training to all coefficients */
	SET_READY,	/* indicate local receiver ready */
	TX_DONE		/* transmit process completed, training can end. */
};

static const char * const al_eth_kr_mac_sm_name[] = {
	"TX_INIT", "WAIT_BEGIN", "DO_PRESET",
	"DO_HOLD", "QMEASURE", "QCHECK",
	"DO_NEXT_TRY", "END_STEPS", "END_STEPS_HOLD",
	"COEFF_DONE", "SET_READY", "TX_DONE"
};

/* Constants used for the measurement. */
enum al_eth_kr_coef {
	AL_ETH_KR_COEF_C_MINUS,
	AL_ETH_KR_COEF_C_ZERO,
	AL_ETH_KR_COEF_C_PLUS,
};

/*
 * test coefficients from COEFF_TO_MANIPULATE to COEFF_TO_MANIPULATE_LAST.
 */
#define COEFF_TO_MANIPULATE AL_ETH_KR_COEF_C_MINUS
#define COEFF_TO_MANIPULATE_LAST AL_ETH_KR_COEF_C_MINUS
#define QARRAY_SIZE	3 /**< how many entries we want in our history array. */

struct al_eth_kr_data {
	struct al_hal_eth_adapter	*adapter;
	struct al_serdes_grp_obj	*serdes_obj;
	enum al_serdes_lane		lane;

	/* Receiver side data */
	struct al_eth_kr_status_report_data status_report; /* report to response */
	struct al_eth_kr_coef_up_data last_lpcoeff; /* last coeff received */

	/* Transmitter side data */
	enum al_eth_kr_mac_lt_state algo_state;	/* Statemachine. */
	unsigned int qarray[QARRAY_SIZE];	/* EyeQ measurements history */
	/* How many entries in the array are valid for compares yet. */
	unsigned int qarray_cnt;
	enum al_eth_kr_coef curr_coeff;
	/*
	 * Status of coefficient during the last
	 * DEC/INC command (before issuing HOLD again).
	 */
	unsigned int coeff_status_step;
	unsigned int end_steps_cnt;     /* Number of end steps needed */
};

static int
al_eth_kr_an_run(struct al_eth_kr_data *kr_data, struct al_eth_an_adv *an_adv,
    struct al_eth_an_adv *an_partner_adv)
{
	int rc;
	boolean_t page_received = FALSE;
	boolean_t an_completed = FALSE;
	boolean_t error = FALSE;
	int timeout = AL_ETH_KR_AN_TIMEOUT;

	rc = al_eth_kr_an_init(kr_data->adapter, an_adv);
	if (rc != 0) {
		al_err("%s %s autonegotiation init failed\n",
		    kr_data->adapter->name, __func__);
		return (rc);
	}

	rc = al_eth_kr_an_start(kr_data->adapter, AL_ETH_AN__LT_LANE_0,
	    FALSE, TRUE);
	if (rc != 0) {
		al_err("%s %s autonegotiation enable failed\n",
		    kr_data->adapter->name, __func__);
		return (rc);
	}

	do {
		DELAY(10000);
		timeout -= 10;
		if (timeout <= 0) {
			al_info("%s %s autonegotiation failed on timeout\n",
			    kr_data->adapter->name, __func__);

			return (ETIMEDOUT);
		}

		al_eth_kr_an_status_check(kr_data->adapter, &page_received,
		    &an_completed, &error);
	} while (page_received == FALSE);

	if (error != 0) {
		al_info("%s %s autonegotiation failed (status error)\n",
		    kr_data->adapter->name, __func__);

		return (EIO);
	}

	al_eth_kr_an_read_adv(kr_data->adapter, an_partner_adv);

	al_dbg("%s %s autonegotiation completed. error = %d\n",
	    kr_data->adapter->name, __func__, error);

	return (0);
}

/***************************** receiver side *********************************/
static enum al_eth_kr_cl72_cstate
al_eth_lt_coeff_set(struct al_eth_kr_data *kr_data,
    enum al_serdes_tx_deemph_param param, uint32_t op)
{
	enum al_eth_kr_cl72_cstate status = 0;

	switch (op) {
	case AL_PHY_KR_COEF_UP_HOLD:
		/* no need to update the serdes - return not updated*/
		status = C72_CSTATE_NOT_UPDATED;
		break;
	case AL_PHY_KR_COEF_UP_INC:
		status = C72_CSTATE_UPDATED;

		if (kr_data->serdes_obj->tx_deemph_inc(
					kr_data->serdes_obj,
					kr_data->lane,
					param) == 0)
			status = C72_CSTATE_MAX;
		break;
	case AL_PHY_KR_COEF_UP_DEC:
		status = C72_CSTATE_UPDATED;

		if (kr_data->serdes_obj->tx_deemph_dec(
					kr_data->serdes_obj,
					kr_data->lane,
					param) == 0)
			status = C72_CSTATE_MIN;
		break;
	default: /* 3=reserved */
		break;
	}

	return (status);
}

/*
 * Inspect the received coefficient update request and update all coefficients
 * in the serdes accordingly.
 */
static void
al_eth_coeff_req_handle(struct al_eth_kr_data *kr_data,
    struct al_eth_kr_coef_up_data *lpcoeff)
{
	struct al_eth_kr_status_report_data *report = &kr_data->status_report;

	/* First check for Init and Preset commands. */
	if ((lpcoeff->preset != 0) || (lpcoeff->initialize) != 0) {
		kr_data->serdes_obj->tx_deemph_preset(
					kr_data->serdes_obj,
					kr_data->lane);

		/*
		 * in case of preset c(0) should be set to maximum and both c(1)
		 * and c(-1) should be updated
		 */
		report->c_minus = C72_CSTATE_UPDATED;

		report->c_plus = C72_CSTATE_UPDATED;

		report->c_zero = C72_CSTATE_MAX;

		return;
	}

	/*
	 * in case preset and initialize are false need to perform per
	 * coefficient action.
	 */
	report->c_minus = al_eth_lt_coeff_set(kr_data,
	    AL_SERDES_TX_DEEMP_C_MINUS, lpcoeff->c_minus);

	report->c_zero = al_eth_lt_coeff_set(kr_data,
	    AL_SERDES_TX_DEEMP_C_ZERO, lpcoeff->c_zero);

	report->c_plus = al_eth_lt_coeff_set(kr_data,
	    AL_SERDES_TX_DEEMP_C_PLUS, lpcoeff->c_plus);

	al_dbg("%s: c(0) = 0x%x c(-1) = 0x%x c(1) = 0x%x\n",
	    __func__, report->c_zero, report->c_plus, report->c_minus);
}

static void
al_eth_kr_lt_receiver_task_init(struct al_eth_kr_data *kr_data)
{

	al_memset(&kr_data->last_lpcoeff, 0,
	    sizeof(struct al_eth_kr_coef_up_data));
	al_memset(&kr_data->status_report, 0,
	    sizeof(struct al_eth_kr_status_report_data));
}

static boolean_t
al_eth_lp_coeff_up_change(struct al_eth_kr_data *kr_data,
    struct al_eth_kr_coef_up_data *lpcoeff)
{
	struct al_eth_kr_coef_up_data *last_lpcoeff = &kr_data->last_lpcoeff;

	if (al_memcmp(last_lpcoeff, lpcoeff,
	    sizeof(struct al_eth_kr_coef_up_data)) == 0) {
		return (FALSE);
	}

	al_memcpy(last_lpcoeff, lpcoeff, sizeof(struct al_eth_kr_coef_up_data));

	return (TRUE);
}

/*
 * Run the receiver task for one cycle.
 * The receiver task continuously inspects the received coefficient update
 * requests and acts upon.
 *
 * @return <0 if error occur
 */
static int
al_eth_kr_lt_receiver_task_run(struct al_eth_kr_data *kr_data)
{
	struct al_eth_kr_coef_up_data new_lpcoeff;

	/*
	 * First inspect status of the link. It may have dropped frame lock as
	 * the remote did some reconfiguration of its serdes.
	 * Then we simply have nothing to do and return immediately as caller
	 * will call us continuously until lock comes back.
	 */

	if (al_eth_kr_receiver_frame_lock_get(kr_data->adapter,
	    AL_ETH_AN__LT_LANE_0) != 0) {
		return (0);
	}

	/* check if a new update command was received */
	al_eth_lp_coeff_up_get(kr_data->adapter,
	    AL_ETH_AN__LT_LANE_0, &new_lpcoeff);

	if (al_eth_lp_coeff_up_change(kr_data, &new_lpcoeff) != 0) {
		/* got some new coefficient update request. */
		al_eth_coeff_req_handle(kr_data, &new_lpcoeff);
	}

	return (0);
}

/******************************** transmitter side ***************************/
static int
al_eth_kr_lt_transmitter_task_init(struct al_eth_kr_data *kr_data)
{
	int i;
	int rc;
	unsigned int temp_val;

	for (i = 0; i < QARRAY_SIZE; i++)
		kr_data->qarray[i] = 0;

	kr_data->qarray_cnt = 0;
	kr_data->algo_state = TX_INIT;
	kr_data->curr_coeff = COEFF_TO_MANIPULATE;  /* first coeff to test. */
	kr_data->coeff_status_step  = C72_CSTATE_NOT_UPDATED;
	kr_data->end_steps_cnt = QARRAY_SIZE-1;  /* go back to first entry */

	/*
	 * Perform measure eye here to run the rx equalizer
	 * for the first time to get init values
	 */
	rc = kr_data->serdes_obj->eye_measure_run(
				kr_data->serdes_obj,
				kr_data->lane,
				AL_ETH_KR_EYE_MEASURE_TIMEOUT,
				&temp_val);
	if (rc != 0) {
		al_warn("%s: Failed to run Rx equalizer (rc = 0x%x)\n",
		    __func__, rc);

		return (rc);
	}

	return (0);
}

static boolean_t
al_eth_kr_lt_all_not_updated(struct al_eth_kr_status_report_data *report)
{

	if ((report->c_zero == C72_CSTATE_NOT_UPDATED) &&
	    (report->c_minus == C72_CSTATE_NOT_UPDATED) &&
	    (report->c_plus == C72_CSTATE_NOT_UPDATED)) {
		return (TRUE);
	}

	return (FALSE);
}

static void
al_eth_kr_lt_coef_set(struct al_eth_kr_coef_up_data *ldcoeff,
    enum al_eth_kr_coef coef, enum al_eth_kr_cl72_coef_op op)
{

	switch (coef) {
	case AL_ETH_KR_COEF_C_MINUS:
		ldcoeff->c_minus = op;
		break;
	case AL_ETH_KR_COEF_C_PLUS:
		ldcoeff->c_plus = op;
		break;
	case AL_ETH_KR_COEF_C_ZERO:
		ldcoeff->c_zero = op;
		break;
	}
}

static enum al_eth_kr_cl72_cstate
al_eth_kr_lt_coef_report_get(struct al_eth_kr_status_report_data *report,
    enum al_eth_kr_coef coef)
{

	switch (coef) {
	case AL_ETH_KR_COEF_C_MINUS:
		return (report->c_minus);
	case AL_ETH_KR_COEF_C_PLUS:
		return (report->c_plus);
	case AL_ETH_KR_COEF_C_ZERO:
		return (report->c_zero);
	}

	return (0);
}

/*
 * Run the transmitter_task for one cycle.
 *
 * @return <0 if error occurs
 */
static int
al_eth_kr_lt_transmitter_task_run(struct al_eth_kr_data *kr_data)
{
	struct al_eth_kr_status_report_data report;
	unsigned int coeff_status_cur;
	struct al_eth_kr_coef_up_data ldcoeff = { 0, 0, 0, 0, 0 };
	unsigned int val;
	int i;
	enum al_eth_kr_mac_lt_state nextstate;
	int rc = 0;

	/*
	 * do nothing if currently there is no frame lock (which may happen
	 * when remote updates its analogs).
	 */
	if (al_eth_kr_receiver_frame_lock_get(kr_data->adapter,
	    AL_ETH_AN__LT_LANE_0) == 0) {
		return (0);
	}

	al_eth_lp_status_report_get(kr_data->adapter,
	    AL_ETH_AN__LT_LANE_0, &report);

	/* extract curr status of the coefficient in use */
	coeff_status_cur = al_eth_kr_lt_coef_report_get(&report,
	    kr_data->curr_coeff);

	nextstate = kr_data->algo_state; /* default we stay in curr state; */

	switch (kr_data->algo_state) {
	case TX_INIT:
		/* waiting for start */
		if (al_eth_kr_startup_proto_prog_get(kr_data->adapter,
		    AL_ETH_AN__LT_LANE_0) != 0) {
			/* training is on and frame lock */
			nextstate = WAIT_BEGIN;
		}
		break;
	case WAIT_BEGIN:
		kr_data->qarray_cnt = 0;
		kr_data->curr_coeff = COEFF_TO_MANIPULATE;
		kr_data->coeff_status_step = C72_CSTATE_NOT_UPDATED;
		coeff_status_cur = C72_CSTATE_NOT_UPDATED;
		kr_data->end_steps_cnt = QARRAY_SIZE-1;

		/* Wait for not_updated for all coefficients from remote */
		if (al_eth_kr_lt_all_not_updated(&report) != 0) {
			ldcoeff.preset = TRUE;
			nextstate = DO_PRESET;
		}
		break;
	case DO_PRESET:
		/*
		 * Send PRESET and wait for for updated for all
		 * coefficients from remote
		 */
		if (al_eth_kr_lt_all_not_updated(&report) == 0)
			nextstate = DO_HOLD;
		else /* as long as the lp didn't response to the preset
		      * we should continue sending it */
			ldcoeff.preset = TRUE;
		break;
	case DO_HOLD:
		/*
		 * clear the PRESET, issue HOLD command and wait for
		 * hold handshake
		 */
		if (al_eth_kr_lt_all_not_updated(&report) != 0)
			nextstate = QMEASURE;
		break;

	case QMEASURE:
		/* makes a measurement and fills the new value into the array */
		rc = kr_data->serdes_obj->eye_measure_run(
					kr_data->serdes_obj,
					kr_data->lane,
					AL_ETH_KR_EYE_MEASURE_TIMEOUT,
					&val);
		if (rc != 0) {
			al_warn("%s: Rx eye measurement failed\n", __func__);

			return (rc);
		}

		al_dbg("%s: Rx Measure eye returned 0x%x\n", __func__, val);

		/* put the new value into the array at the top. */
		for (i = 0; i < QARRAY_SIZE-1; i++)
			kr_data->qarray[i] = kr_data->qarray[i+1];

		kr_data->qarray[QARRAY_SIZE-1] = val;

		if (kr_data->qarray_cnt < QARRAY_SIZE)
			kr_data->qarray_cnt++;

		nextstate = QCHECK;
		break;
	case QCHECK:
		/* check if we reached the best link quality yet. */
		if (kr_data->qarray_cnt < QARRAY_SIZE) {
			/* keep going until at least the history is
			 * filled. check that we can keep going or if
			 * coefficient has already reached minimum.
			 */

			if (kr_data->coeff_status_step == C72_CSTATE_MIN)
				nextstate = COEFF_DONE;
			else {
				/*
				 * request a DECREMENT of the
				 * coefficient under control
				 */
				al_eth_kr_lt_coef_set(&ldcoeff,
				    kr_data->curr_coeff, AL_PHY_KR_COEF_UP_DEC);

				nextstate = DO_NEXT_TRY;
			}
		} else {
			/*
			 * check if current value and last both are worse than
			 * the 2nd last. This we take as an ending condition
			 * assuming the minimum was reached two tries before
			 * so we will now go back to that point.
			 */
			if ((kr_data->qarray[0] < kr_data->qarray[1]) &&
			    (kr_data->qarray[0] < kr_data->qarray[2])) {
				/*
				 * request a INCREMENT of the
				 * coefficient under control
				 */
				al_eth_kr_lt_coef_set(&ldcoeff,
				    kr_data->curr_coeff, AL_PHY_KR_COEF_UP_INC);

				/* start going back to the maximum */
				nextstate = END_STEPS;
				if (kr_data->end_steps_cnt > 0)
					kr_data->end_steps_cnt--;
			} else {
				if (kr_data->coeff_status_step ==
				    C72_CSTATE_MIN) {
					nextstate = COEFF_DONE;
				} else {
					/*
					 * request a DECREMENT of the
					 * coefficient under control
					 */
					al_eth_kr_lt_coef_set(&ldcoeff,
					    kr_data->curr_coeff,
					    AL_PHY_KR_COEF_UP_DEC);

					nextstate = DO_NEXT_TRY;
				}
			}
		}
		break;
	case DO_NEXT_TRY:
		/*
		 * save the status when we issue the DEC step to the remote,
		 * before the HOLD is done again.
		 */
		kr_data->coeff_status_step = coeff_status_cur;

		if (coeff_status_cur != C72_CSTATE_NOT_UPDATED)
			nextstate = DO_HOLD;  /* go to next measurement round */
		else
			al_eth_kr_lt_coef_set(&ldcoeff,
			    kr_data->curr_coeff, AL_PHY_KR_COEF_UP_DEC);
		break;
	/*
	 * Coefficient iteration completed, go back to the optimum step
	 * In this algorithm we assume 2 before curr was best hence need to do
	 * two INC runs.
	 */
	case END_STEPS:
		if (coeff_status_cur != C72_CSTATE_NOT_UPDATED)
			nextstate = END_STEPS_HOLD;
		else
			al_eth_kr_lt_coef_set(&ldcoeff,
			    kr_data->curr_coeff, AL_PHY_KR_COEF_UP_INC);
		break;
	case END_STEPS_HOLD:
		if (coeff_status_cur == C72_CSTATE_NOT_UPDATED) {
			if (kr_data->end_steps_cnt != 0) {
				/*
				 * request a INCREMENT of the
				 * coefficient under control
				 */
				al_eth_kr_lt_coef_set(&ldcoeff,
				    kr_data->curr_coeff, AL_PHY_KR_COEF_UP_INC);

				/* go 2nd time - dec the end step count */
				nextstate = END_STEPS;

				if (kr_data->end_steps_cnt > 0)
					kr_data->end_steps_cnt--;

			} else {
				nextstate = COEFF_DONE;
			}
		}
		break;
	case COEFF_DONE:
		/*
		 * now this coefficient is done.
		 * We can now either choose to finish here,
		 * or keep going with another coefficient.
		 */
		if ((int)kr_data->curr_coeff < COEFF_TO_MANIPULATE_LAST) {
			int i;

			for (i = 0; i < QARRAY_SIZE; i++)
				kr_data->qarray[i] = 0;

			kr_data->qarray_cnt = 0;
			kr_data->end_steps_cnt = QARRAY_SIZE-1;
			kr_data->coeff_status_step = C72_CSTATE_NOT_UPDATED;
			kr_data->curr_coeff++;

			al_dbg("[%s]: doing next coefficient: %d ---\n\n",
			    kr_data->adapter->name, kr_data->curr_coeff);

			nextstate = QMEASURE;
		} else {
			nextstate = SET_READY;
		}
		break;
	case SET_READY:
		/*
		 * our receiver is ready for data.
		 * no training will occur any more.
		 */
		kr_data->status_report.receiver_ready = TRUE;
		/*
		 * in addition to the status we transmit, we also must tell our
		 * local hardware state-machine that we are done, so the
		 * training can eventually complete when the remote indicates
		 * it is ready also. The hardware will then automatically
		 * give control to the PCS layer completing training.
		 */
		al_eth_receiver_ready_set(kr_data->adapter,
		    AL_ETH_AN__LT_LANE_0);

		nextstate = TX_DONE;
		break;
	case TX_DONE:
		break;  /* nothing else to do */
	default:
		nextstate = kr_data->algo_state;
		break;
	}

	/*
	 * The status we want to transmit to remote.
	 * Note that the status combines the receiver status of all coefficients
	 * with the transmitter's rx ready status.
	 */
	if (kr_data->algo_state != nextstate) {
		al_dbg("[%s] [al_eth_kr_lt_transmit_run] STM changes %s -> %s: "
		    " Qarray=%d/%d/%d\n", kr_data->adapter->name,
		    al_eth_kr_mac_sm_name[kr_data->algo_state],
		    al_eth_kr_mac_sm_name[nextstate],
		    kr_data->qarray[0], kr_data->qarray[1], kr_data->qarray[2]);
	}

	kr_data->algo_state = nextstate;

	/*
	 * write fields for transmission into hardware.
	 * Important: this must be done always, as the receiver may have
	 * received update commands and wants to return its status.
	 */
	al_eth_ld_coeff_up_set(kr_data->adapter, AL_ETH_AN__LT_LANE_0, &ldcoeff);
	al_eth_ld_status_report_set(kr_data->adapter, AL_ETH_AN__LT_LANE_0,
	    &kr_data->status_report);

	return (0);
}

/*****************************************************************************/
static int
al_eth_kr_run_lt(struct al_eth_kr_data *kr_data)
{
	unsigned int cnt;
	int ret = 0;
	boolean_t page_received = FALSE;
	boolean_t an_completed = FALSE;
	boolean_t error = FALSE;
	boolean_t training_failure = FALSE;

	al_eth_kr_lt_initialize(kr_data->adapter, AL_ETH_AN__LT_LANE_0);

	if (al_eth_kr_lt_frame_lock_wait(kr_data->adapter, AL_ETH_AN__LT_LANE_0,
	    AL_ETH_KR_FRAME_LOCK_TIMEOUT) == TRUE) {

		/*
		 * when locked, for the first time initialize the receiver and
		 * transmitter tasks to prepare it for detecting coefficient
		 * update requests.
		 */
		al_eth_kr_lt_receiver_task_init(kr_data);
		ret = al_eth_kr_lt_transmitter_task_init(kr_data);
		if (ret != 0)
			goto error;

		cnt = 0;
		do {
			ret = al_eth_kr_lt_receiver_task_run(kr_data);
			if (ret != 0)
				break; /* stop the link training */

			ret = al_eth_kr_lt_transmitter_task_run(kr_data);
			if (ret != 0)
				break;  /* stop the link training */

			cnt++;
			DELAY(100);

		} while ((al_eth_kr_startup_proto_prog_get(kr_data->adapter,
		    AL_ETH_AN__LT_LANE_0)) && (cnt <= AL_ETH_KR_LT_MAX_ROUNDS));

		training_failure =
		    al_eth_kr_training_status_fail_get(kr_data->adapter,
		    AL_ETH_AN__LT_LANE_0);
		al_dbg("[%s] training ended after %d rounds, failed = %s\n",
		    kr_data->adapter->name, cnt,
		    (training_failure) ? "Yes" : "No");
		if (training_failure || cnt > AL_ETH_KR_LT_MAX_ROUNDS) {
			al_warn("[%s] Training Fail: status: %s, timeout: %s\n",
			    kr_data->adapter->name,
			    (training_failure) ? "Failed" : "OK",
			    (cnt > AL_ETH_KR_LT_MAX_ROUNDS) ? "Yes" : "No");

			/*
			 * note: link is now disabled,
			 * until training becomes disabled (see below).
			 */
			ret = EIO;
			goto error;
		}

	} else {

		al_info("[%s] FAILED: did not achieve initial frame lock...\n",
		    kr_data->adapter->name);

		ret = EIO;
		goto error;
	}

	/*
	 * ensure to stop link training at the end to allow normal PCS
	 * datapath to operate in case of training failure.
	 */
	al_eth_kr_lt_stop(kr_data->adapter, AL_ETH_AN__LT_LANE_0);

	cnt = AL_ETH_KR_LT_DONE_TIMEOUT;
	while (an_completed == FALSE) {
		al_eth_kr_an_status_check(kr_data->adapter, &page_received,
		    &an_completed, &error);
		DELAY(1);
		if ((cnt--) == 0) {
			al_info("%s: wait for an complete timeout!\n", __func__);
			ret = ETIMEDOUT;
			goto error;
		}
	}

error:
	al_eth_kr_an_stop(kr_data->adapter);

	return (ret);
}

/* execute Autonegotiation process */
int al_eth_an_lt_execute(struct al_hal_eth_adapter	*adapter,
			 struct al_serdes_grp_obj	*serdes_obj,
			 enum al_serdes_lane		lane,
			 struct al_eth_an_adv		*an_adv,
			 struct al_eth_an_adv		*partner_adv)
{
	struct al_eth_kr_data kr_data;
	int rc;
	struct al_serdes_adv_rx_params rx_params;

	al_memset(&kr_data, 0, sizeof(struct al_eth_kr_data));

	kr_data.adapter = adapter;
	kr_data.serdes_obj = serdes_obj;
	kr_data.lane = lane;

	/*
	 * the link training progress will run rx equalization so need to make
	 * sure rx parameters is not been override
	 */
	rx_params.override = FALSE;
	kr_data.serdes_obj->rx_advanced_params_set(
					kr_data.serdes_obj,
					kr_data.lane,
					&rx_params);

	rc = al_eth_kr_an_run(&kr_data, an_adv, partner_adv);
	if (rc != 0) {
		al_eth_kr_lt_stop(adapter, AL_ETH_AN__LT_LANE_0);
		al_eth_kr_an_stop(adapter);
		al_dbg("%s: auto-negotiation failed!\n", __func__);
		return (rc);
	}

	if (partner_adv->technology != AL_ETH_AN_TECH_10GBASE_KR) {
		al_eth_kr_lt_stop(adapter, AL_ETH_AN__LT_LANE_0);
		al_eth_kr_an_stop(adapter);
		al_dbg("%s: link partner isn't 10GBASE_KR.\n", __func__);
		return (rc);
	}

	rc = al_eth_kr_run_lt(&kr_data);
	if (rc != 0) {
		al_eth_kr_lt_stop(adapter, AL_ETH_AN__LT_LANE_0);
		al_eth_kr_an_stop(adapter);
		al_dbg("%s: Link-training failed!\n", __func__);
		return (rc);
	}

	return (0);
}