838 lines
23 KiB
C
838 lines
23 KiB
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_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;
|
|
al_bool page_received = AL_FALSE;
|
|
al_bool an_completed = AL_FALSE;
|
|
al_bool error = AL_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,
|
|
AL_FALSE, AL_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 == AL_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 bool
|
|
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 bool
|
|
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 = AL_TRUE;
|
|
nextstate = DO_PRESET;
|
|
}
|
|
break;
|
|
case DO_PRESET:
|
|
/*
|
|
* Send PRESET and wait 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 = AL_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 = AL_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;
|
|
al_bool page_received = AL_FALSE;
|
|
al_bool an_completed = AL_FALSE;
|
|
al_bool error = AL_FALSE;
|
|
al_bool training_failure = AL_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) == AL_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 == AL_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 = AL_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);
|
|
}
|