/*-
 * 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);
}