/*
 * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
 *
 * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software for
 * any purpose with or without fee is hereby granted, provided that the
 * above copyright notice and this permission notice appear in all copies.
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "sw.h"
#include "fal_port_ctrl.h"
#include "hsl_api.h"
#include "hsl.h"
#include "aquantia_phy.h"
#include "hsl_phy.h"
#include "ssdk_plat.h"

/* #define aquantia_phy_reg_read _phy_reg_read  */
/* #define aquantia_phy_reg_write _phy_reg_write */

/******************************************************************************
*
* aquantia_phy_mii_read - mii register read
*
* mii register read
*/
static sw_error_t
aquantia_phy_reg_read(a_uint32_t dev_id, a_uint32_t phy_id, a_uint32_t reg_mmd,
	a_uint32_t reg_id, a_uint16_t *phy_data)
{
	sw_error_t rv;

	reg_id = AQUANTIA_REG_ADDRESS(reg_mmd, reg_id);
	HSL_PHY_GET(rv, dev_id, phy_id, reg_id, phy_data);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_mii_write - mii register write
*
* mii register write
*/
static sw_error_t
aquantia_phy_reg_write(a_uint32_t dev_id, a_uint32_t phy_id, a_uint32_t reg_mmd,
	a_uint32_t reg_id, a_uint16_t reg_val)
{
	sw_error_t rv;

	reg_id = AQUANTIA_REG_ADDRESS(reg_mmd, reg_id);
	HSL_PHY_SET(rv, dev_id,  phy_id, reg_id, reg_val);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_get_phy_id - get the phy id
*
*/
sw_error_t
aquantia_phy_get_phy_id(a_uint32_t dev_id, a_uint32_t phy_id,
		a_uint32_t *phy_data)
{
	sw_error_t rv;
	a_uint16_t org_id, rev_id;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PHY_XS_REGISTERS,
		AQUANTIA_PHY_ID1, &org_id);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PHY_XS_REGISTERS,
		AQUANTIA_PHY_ID2, &rev_id);
	SW_RTN_ON_ERROR(rv);

	*phy_data = ((org_id & 0xffff) << 16) | (rev_id & 0xffff);

	return rv;
}

sw_error_t
aquantia_phy_get_speed(a_uint32_t dev_id, a_uint32_t phy_id,
		     fal_port_speed_t * speed)
{
	a_uint16_t phy_data;
	sw_error_t rv = SW_OK;
	a_bool_t link_status;

	link_status = aquantia_phy_get_link_status(dev_id, phy_id);
	if (link_status != A_TRUE) {
		/*the speed register(0x4007c800) is not stable when aquantia phy is down,
		 but some APIs such as aquantia_phy_set_duplex() aquantia_phy_interface_set_mode()
		 need to get the speed, so set the speed default value as 100M when link down*/
		*speed = FAL_SPEED_100;
		return SW_OK;
	}

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_REG_AUTONEG_VENDOR_STATUS, &phy_data);
	SW_RTN_ON_ERROR(rv);
	switch ((phy_data & AQUANTIA_STATUS_SPEED_MASK) >> 1) {
		case AQUANTIA_STATUS_SPEED_10MBS:
			*speed = FAL_SPEED_10;
			break;
		case AQUANTIA_STATUS_SPEED_100MBS:
			*speed = FAL_SPEED_100;
			break;
		case AQUANTIA_STATUS_SPEED_1000MBS:
			*speed = FAL_SPEED_1000;
			break;
		case AQUANTIA_STATUS_SPEED_10000MBS:
			*speed = FAL_SPEED_10000;
			break;
		case AQUANTIA_STATUS_SPEED_2500MBS:
			*speed = FAL_SPEED_2500;
			break;
		case AQUANTIA_STATUS_SPEED_5000MBS:
			*speed = FAL_SPEED_5000;
			break;
		default:
			return SW_READ_ERROR;
	}

	return rv;
}

/******************************************************************************
*
* aquantia_phy_get_duplex - Determines the speed of phy ports associated with the
* specified device.
*/
sw_error_t
aquantia_phy_get_duplex(a_uint32_t dev_id, a_uint32_t phy_id,
		      fal_port_duplex_t * duplex)
{
	a_uint16_t phy_data;
	sw_error_t rv = SW_OK;
	a_bool_t link_status;

	link_status = aquantia_phy_get_link_status(dev_id, phy_id);
	if (link_status != A_TRUE)
	{
		return SW_OK;
	}

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_REG_AUTONEG_VENDOR_STATUS, &phy_data);
	SW_RTN_ON_ERROR(rv);
	//read duplex
	if (phy_data & AQUANTIA_STATUS_FULL_DUPLEX)
	{
		*duplex = FAL_FULL_DUPLEX;
	}
	else
	{
		*duplex = FAL_HALF_DUPLEX;
	}

	return rv;
}
#ifndef IN_PORTCONTROL_MINI
/******************************************************************************
*
* aquantia_phy_reset - reset the phy
*
* reset the phy
*/
sw_error_t aquantia_phy_reset(a_uint32_t dev_id, a_uint32_t phy_id)
{
	a_uint16_t phy_data;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_GLOBAL_STANDARD_CONTROL1, &phy_data);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
	AQUANTIA_GLOBAL_STANDARD_CONTROL1, phy_data | AQUANTIA_CTRL_SOFTWARE_RESET);
	aos_mdelay(100);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_set_powersave - set power saving status
*
* set power saving status
*/
sw_error_t
aquantia_phy_set_powersave(a_uint32_t dev_id, a_uint32_t phy_id, a_bool_t enable)
{
	a_uint16_t phy_data;
	sw_error_t rv;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_GLOBAL_RESERVED_PROVISIONING6, &phy_data);
	SW_RTN_ON_ERROR(rv);
	if (enable == A_TRUE)
	{
		phy_data |= AQUANTIA_POWER_SAVE;
	}
	else
	{
		phy_data &= ~AQUANTIA_POWER_SAVE;
	}
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_GLOBAL_RESERVED_PROVISIONING6,phy_data);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_restart_autoneg(dev_id, phy_id);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_get_powersave - get power saving status
*
* set power saving status
*/
sw_error_t
aquantia_phy_get_powersave(a_uint32_t dev_id, a_uint32_t phy_id,
			 a_bool_t * enable)
{
	a_uint16_t phy_data;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_GLOBAL_RESERVED_PROVISIONING6, &phy_data);
	SW_RTN_ON_ERROR(rv);
	if (phy_data& AQUANTIA_POWER_SAVE)
	{
		*enable = A_TRUE;
	}
	else
	{
		*enable = A_FALSE;
	}

	return rv;
}

/******************************************************************************
*
* aquantia_phy_set_mdix -
*
* set phy mdix configuraiton
*/
sw_error_t
aquantia_phy_set_mdix(a_uint32_t dev_id, a_uint32_t phy_id,
		    fal_port_mdix_mode_t mode)
{
	a_uint16_t phy_data;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_RESERVED_VENDOR_PROVISIONING1, &phy_data);
	SW_RTN_ON_ERROR(rv);
	phy_data &= ~(BITS(0,2));
	switch(mode)
	{
		case PHY_MDIX_AUTO:
			phy_data |= AQUANTIA_PHY_MDIX_AUTO;
			break;
		case PHY_MDIX_MDIX:
			phy_data |= AQUANTIA_PHY_MDIX;
			break;
		case PHY_MDIX_MDI:
			phy_data |= AQUANTIA_PHY_MDI;
			break;
		default:
			return SW_BAD_PARAM;
	}
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_RESERVED_VENDOR_PROVISIONING1,phy_data);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_restart_autoneg(dev_id, phy_id);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_get_mdix
*
* get phy mdix configuration
*/
sw_error_t
aquantia_phy_get_mdix(a_uint32_t dev_id, a_uint32_t phy_id,
		    fal_port_mdix_mode_t * mode)
{
	a_uint16_t phy_data;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_RESERVED_VENDOR_PROVISIONING1,&phy_data);
	SW_RTN_ON_ERROR(rv);
	phy_data  &= BITS(0,2);
	switch(phy_data)
	{
		case AQUANTIA_PHY_MDIX_AUTO:
			*mode = PHY_MDIX_AUTO;
			break;
		case AQUANTIA_PHY_MDIX:
			*mode = PHY_MDIX_MDIX;
			break;
		case AQUANTIA_PHY_MDI:
			*mode = PHY_MDIX_MDI;
			break;
		default:
			return SW_NOT_SUPPORTED;
	}

	return rv;
}

/******************************************************************************
*
* aquantia_phy_get_mdix status
*
* get phy mdix status
*/
sw_error_t
aquantia_phy_get_mdix_status(a_uint32_t dev_id, a_uint32_t phy_id,
			   fal_port_mdix_status_t * mode)
{
	a_uint16_t phy_data;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_RESERVED_VENDOR_STATUS1, &phy_data);
	SW_RTN_ON_ERROR(rv);
	*mode = (phy_data &  AQUANTIA_PHY_MDIX_STATUS) ? PHY_MDIX_STATUS_MDIX :
	    PHY_MDIX_STATUS_MDI;

	return rv;
}

/******************************************************************************
*
* aquantia_phy_set_local_loopback
*
* set phy local loopback
*/
sw_error_t
aquantia_phy_set_local_loopback(a_uint32_t dev_id, a_uint32_t phy_id,
			      a_bool_t enable)
{
	a_uint16_t phy_data;
	fal_port_speed_t old_speed;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PHY_XS_REGISTERS,
		AQUANTIA_PHY_XS_TRANAMIT_RESERVED_VENDOR_PROVISION5, &phy_data);
	SW_RTN_ON_ERROR(rv);
	if (enable == A_TRUE)
	{
		phy_data |= AQUANTIA_INTERNAL_LOOPBACK;
		rv = aquantia_phy_get_speed(dev_id, phy_id, &old_speed);
		SW_RTN_ON_ERROR(rv);
		switch(old_speed)
		{
			case FAL_SPEED_10:
				phy_data |= AQUANTIA_10M_LOOPBACK;
				break;
			case FAL_SPEED_100:
				phy_data |= AQUANTIA_100M_LOOPBACK;
				break;
			case FAL_SPEED_1000:
				 phy_data |= AQUANTIA_1000M_LOOPBACK;
				 break;
			case FAL_SPEED_10000:
				phy_data |= AQUANTIA_10000M_LOOPBACK;
				break;
			case FAL_SPEED_2500:
				 phy_data |= AQUANTIA_2500M_LOOPBACK;
				 break;
			case FAL_SPEED_5000:
				phy_data |= AQUANTIA_5000M_LOOPBACK;
				break;
			default:
				return SW_FAIL;
		}
	}
	else
	{
		phy_data &= ~(AQUANTIA_INTERNAL_LOOPBACK | AQUANTIA_ALL_SPEED_LOOPBACK);
	}
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_PHY_XS_REGISTERS,
		AQUANTIA_PHY_XS_TRANAMIT_RESERVED_VENDOR_PROVISION5,phy_data);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_get_local_loopback
*
* get phy local loopback
*/
sw_error_t
aquantia_phy_get_local_loopback(a_uint32_t dev_id, a_uint32_t phy_id,
			      a_bool_t * enable)
{
	a_uint16_t phy_data;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PHY_XS_REGISTERS,
		AQUANTIA_PHY_XS_TRANAMIT_RESERVED_VENDOR_PROVISION5, &phy_data);
	SW_RTN_ON_ERROR(rv);
	if (phy_data & AQUANTIA_INTERNAL_LOOPBACK)
	{
		*enable = A_TRUE;
	}
	else
	{
		*enable = A_FALSE;
	}

	return rv;
}

sw_error_t
aquantia_phy_set_remote_loopback(a_uint32_t dev_id, a_uint32_t phy_id,
				   a_bool_t enable)
{
	a_uint16_t phy_data;
	fal_port_speed_t speed;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PHY_XS_REGISTERS,
		AQUANTIA_PHY_XS_TRANAMIT_RESERVED_VENDOR_PROVISION5, &phy_data);
	SW_RTN_ON_ERROR(rv);

	if (enable == A_TRUE)
	{
		rv = aquantia_phy_get_speed(dev_id,  phy_id, &speed);
		SW_RTN_ON_ERROR(rv);
		switch(speed)
		{
			case FAL_SPEED_10:
				phy_data |= AQUANTIA_10M_LOOPBACK;
				break;
			case FAL_SPEED_100:
				phy_data |= AQUANTIA_100M_LOOPBACK;
				break;
			case FAL_SPEED_1000:
				phy_data |= AQUANTIA_1000M_LOOPBACK;
				break;
			case FAL_SPEED_2500:
				phy_data |= AQUANTIA_2500M_LOOPBACK;
				break;
			case FAL_SPEED_5000:
				phy_data |= AQUANTIA_5000M_LOOPBACK;
				break;
			case FAL_SPEED_10000:
				phy_data |= AQUANTIA_10000M_LOOPBACK;
				break;
			default:
				break;
		}
		phy_data |= AQUANTIA_PHY_REMOTE_LOOPBACK;
	}
	else
	{
		phy_data &= ~(AQUANTIA_PHY_REMOTE_LOOPBACK |AQUANTIA_ALL_SPEED_LOOPBACK);
	}
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_PHY_XS_REGISTERS,
		AQUANTIA_PHY_XS_TRANAMIT_RESERVED_VENDOR_PROVISION5, phy_data);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_get_remote_loopback
*
* get phy remote loopback
*/
sw_error_t
aquantia_phy_get_remote_loopback(a_uint32_t dev_id, a_uint32_t phy_id,
				   a_bool_t * enable)
{
	a_uint16_t phy_data;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PHY_XS_REGISTERS,
		AQUANTIA_PHY_XS_TRANAMIT_RESERVED_VENDOR_PROVISION5, &phy_data);
	SW_RTN_ON_ERROR(rv);
	if (phy_data & AQUANTIA_PHY_REMOTE_LOOPBACK)
	{
		*enable = A_TRUE;
	}
	else
	{
		*enable = A_FALSE;
	}

	return rv;
}
#endif
/******************************************************************************
*
* aquantia_phy_cdt - cable diagnostic test
*
* cable diagnostic test
*/
static inline fal_cable_status_t _phy_cdt_status_mapping(a_uint32_t pair_type, a_uint16_t status)
{
	fal_cable_status_t status_mapping = FAL_CABLE_STATUS_INVALID;

	switch(status)
	{
		case 0:
			status_mapping = FAL_CABLE_STATUS_NORMAL;
			break;
		case 1:
			if(pair_type == CABLE_PAIR_B)
				status_mapping = FAL_CABLE_STATUS_CROSSOVERA;
			else if(pair_type == CABLE_PAIR_C)
				status_mapping = FAL_CABLE_STATUS_CROSSOVERB;
			else if(pair_type == CABLE_PAIR_D)
				status_mapping = FAL_CABLE_STATUS_CROSSOVERC;
			else
				status_mapping = FAL_CABLE_STATUS_INVALID;
			break;
		case 2:
			if(pair_type == CABLE_PAIR_C)
				status_mapping = FAL_CABLE_STATUS_CROSSOVERA;
			else if(pair_type == CABLE_PAIR_D)
				status_mapping = FAL_CABLE_STATUS_CROSSOVERB;
			else
				status_mapping = FAL_CABLE_STATUS_INVALID;
			break;
		case 3:
			if(pair_type == CABLE_PAIR_D)
				status_mapping = FAL_CABLE_STATUS_CROSSOVERA;
			else
				status_mapping = FAL_CABLE_STATUS_INVALID;
			break;
		case 4:
			status_mapping = FAL_CABLE_STATUS_SHORT;
			break;
		case 5:
			status_mapping = FAL_CABLE_STATUS_LOW_MISMATCH;
			break;
		case 6:
			status_mapping = FAL_CABLE_STATUS_HIGH_MISMATCH;
			break;
		case 7:
			status_mapping = FAL_CABLE_STATUS_OPENED;
			break;
		default:
			status_mapping = FAL_CABLE_STATUS_INVALID;
			break;
	}

	return status_mapping;
}

sw_error_t
aquantia_phy_cdt_get(a_uint32_t dev_id, a_uint32_t phy_id,
		   fal_port_cdt_t * port_cdt)
{
	a_uint16_t status = 0;
	sw_error_t rv = SW_OK;
	a_uint16_t phy_data;

	if (!port_cdt) {
		return SW_FAIL;
	}
	/* Get cable status */
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_CABLE_DIAGNOSTIC_STATUS1, &status);
	SW_RTN_ON_ERROR(rv);
	port_cdt->pair_a_status =  (status & AQUANTIA_CABLE_DIAGNOSTIC_STATUS_PAIRA) >> 12
		& BITS(0, 3);
	port_cdt->pair_b_status = (status & AQUANTIA_CABLE_DIAGNOSTIC_STATUS_PAIRB) >> 8
		& BITS(0, 3);
	port_cdt->pair_c_status = (status & AQUANTIA_CABLE_DIAGNOSTIC_STATUS_PAIRC) >> 4
		& BITS(0, 3);
	port_cdt->pair_d_status = (status & AQUANTIA_CABLE_DIAGNOSTIC_STATUS_PAIRD)
		& BITS(0, 3);
	SSDK_DEBUG("status:%x, pair_a_status:%x,pair_b_status:%x,pair_c_status:%x, pair_d_status:%x\n",
		status, port_cdt->pair_a_status,port_cdt->pair_b_status,
		port_cdt->pair_c_status, port_cdt->pair_d_status);
	/* Get Cable Length value */
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_CABLE_DIAGNOSTIC_STATUS2, &phy_data);
	SW_RTN_ON_ERROR(rv);
	port_cdt->pair_a_len = phy_data >> 8 & BITS(0, 8);

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_CABLE_DIAGNOSTIC_STATUS4, &phy_data);
	SW_RTN_ON_ERROR(rv);
	port_cdt->pair_b_len = phy_data >> 8 & BITS(0, 8);

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_CABLE_DIAGNOSTIC_STATUS6, &phy_data);
	SW_RTN_ON_ERROR(rv);
	port_cdt->pair_c_len = phy_data >> 8 & BITS(0, 8);

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_CABLE_DIAGNOSTIC_STATUS8, &phy_data);
	SW_RTN_ON_ERROR(rv);
	port_cdt->pair_d_len = phy_data >> 8 & BITS(0, 8);

	return rv;
}

sw_error_t aquatia_phy_cdt_start(a_uint32_t dev_id, a_uint32_t phy_id)
{
	a_uint16_t status = 0, phy_data = 0;
	a_uint32_t aq_phy_id;
	a_uint16_t ii = 300;
	sw_error_t rv = SW_OK;

	/*select mode0 if aq107, and select mode2 if aq109*/
	rv = aquantia_phy_get_phy_id(dev_id, phy_id, &aq_phy_id);
	SW_RTN_ON_ERROR(rv);
	rv  = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_GLOBAL_CDT_CONTROL, &phy_data);
	SW_RTN_ON_ERROR(rv);
	if(aq_phy_id == AQUANTIA_PHY_109 || aq_phy_id == AQUANTIA_PHY_113C_B0 ||
		aq_phy_id == AQUANTIA_PHY_113C_B1)
	{
		phy_data |= AQUANTIA_PHY_CDT_MODE2;
	}
	else
	{
		phy_data |= AQUANTIA_PHY_CDT_MODE0;
	}

	phy_data |= AQUANTIA_NORMAL_CABLE_DIAGNOSTICS;
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		 AQUANTIA_GLOBAL_CDT_CONTROL, phy_data);
	SW_RTN_ON_ERROR(rv);
	do {
		aos_mdelay(30);
		rv  = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
			AQUANTIA_GLOBAL_GENERAL_STATUS, &status);
		SW_RTN_ON_ERROR(rv);
	}
	while ((status & AQUANTIA_CABLE_DIAGNOSTICS_STATUS) && (--ii));

	return rv;
}

sw_error_t
aquantia_phy_cdt(a_uint32_t dev_id, a_uint32_t phy_id, a_uint32_t mdi_pair,
	       fal_cable_status_t * cable_status, a_uint32_t * cable_len)
{
	fal_port_cdt_t aquantia_port_cdt;
	sw_error_t rv = SW_OK;

	if (mdi_pair >= 4) {
		return SW_BAD_PARAM;
	}
	rv = aquatia_phy_cdt_start(dev_id, phy_id);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_cdt_get(dev_id, phy_id, &aquantia_port_cdt);
	SW_RTN_ON_ERROR(rv);
	switch (mdi_pair)
	{
		case 0:
			*cable_status =
				 _phy_cdt_status_mapping(CABLE_PAIR_A, aquantia_port_cdt.pair_a_status);
			/* Get Cable Length value */
			*cable_len = aquantia_port_cdt.pair_a_len;
			break;
		case 1:
			*cable_status =
				 _phy_cdt_status_mapping(CABLE_PAIR_B, aquantia_port_cdt.pair_b_status);
			/* Get Cable Length value */
			*cable_len = aquantia_port_cdt.pair_b_len;
			break;
		case 2:
			*cable_status =
				_phy_cdt_status_mapping(CABLE_PAIR_C, aquantia_port_cdt.pair_c_status);
			/* Get Cable Length value */
			*cable_len = aquantia_port_cdt.pair_c_len;
			break;
		case 3:
			*cable_status =
				 _phy_cdt_status_mapping(CABLE_PAIR_D, aquantia_port_cdt.pair_d_status);
			/* Get Cable Length value */
			*cable_len = aquantia_port_cdt.pair_d_len;
			break;
		default:
			break;
	}

	return rv;
}
/******************************************************************************
*
* AQUANTIA_autoneg_done
*
* AQUANTIA_autoneg_done
*/
a_bool_t aquantia_autoneg_done(a_uint32_t dev_id, a_uint32_t phy_id)
{
	a_uint16_t phy_data;
	a_uint16_t ii = 200;
	sw_error_t rv = SW_OK;

	do {
		rv =  aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
			AQUANTIA_AUTONEG_STANDARD_STATUS1, &phy_data);
		SW_RTN_ON_ERROR(rv);
		aos_mdelay(10);
	}
	while ((!AQUANTIA_AUTONEG_DONE(phy_data)) && --ii);

	if (ii == 0)
		return A_FALSE;

	return A_TRUE;
}
#if 0
#ifndef IN_PORTCONTROL_MINI
/******************************************************************************
*
* aquantia_phy_get_ability - get the phy ability
*
*
*/
sw_error_t
aquantia_phy_get_partner_ability(a_uint32_t dev_id, a_uint32_t phy_id,
			       a_uint32_t * ability)
{
	a_uint16_t phy_data;
	sw_error_t rv = SW_OK;

	*ability = 0;
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_LINK_PARTNER_ABILITY, &phy_data);
	SW_RTN_ON_ERROR(rv);
	if (phy_data & AQUANTIA_LINK_10BASETX_HALF_DUPLEX)
	{
		*ability |= FAL_PHY_PART_10T_HD;
	}
	if (phy_data & AQUANTIA_LINK_10BASETX_FULL_DUPLEX)
	{
		*ability |= FAL_PHY_PART_10T_FD;
	}
	if (phy_data & AQUANTIA_LINK_100BASETX_HALF_DUPLEX)
	{
		*ability |= FAL_PHY_PART_100TX_HD;
	}
	if (phy_data & AQUANTIA_LINK_100BASETX_FULL_DUPLEX)
	{
		*ability |= FAL_PHY_PART_100TX_FD;
	}

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_LINK_PARTNER_5G_ABILITY, &phy_data);
	SW_RTN_ON_ERROR(rv);
	if (phy_data & AQUANTIA_LINK_1000BASETX_FULL_DUPLEX)
	{
		*ability |= FAL_PHY_PART_1000T_FD;
	}
	if (phy_data & AQUANTIA_LINK_5000BASETX_FULL_DUPLEX)
	{
		*ability |= FAL_PHY_PART_5000T_FD;
	}
	if (phy_data & AQUANTIA_LINK_2500BASETX_FULL_DUPLEX)
	{
		*ability |= FAL_PHY_PART_2500T_FD;
	}

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_LINK_PARTNER_10G_ABILITY, &phy_data);
	if (phy_data & AQUANTIA_LINK_10000BASETX_FULL_DUPLEX)
	{
		*ability |= FAL_PHY_PART_10000T_FD;
	}

	return rv;
}
#endif
#endif
/******************************************************************************
*
* aquantia_phy_status - test to see if the specified phy link is alive
*
* RETURNS:
*    A_TRUE  --> link is alive
*    A_FALSE --> link is down
*/
a_bool_t aquantia_phy_get_link_status(a_uint32_t dev_id, a_uint32_t phy_id)
{
	a_uint16_t phy_data;
	sw_error_t rv = SW_OK;

	/*in order to get the  link status of real time, need to read the link status two times */
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_STANDARD_STATUS1, &phy_data);
	if(rv != SW_OK)
	{
		return A_FALSE;
	}
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_STANDARD_STATUS1, &phy_data);
	if(rv != SW_OK)
	{
		return A_FALSE;
	}
	if (phy_data & AQUANTIA_STATUS_LINK)
	{
		return A_TRUE;
	}

	return A_FALSE;
}

/******************************************************************************
*
* AQUANTIA_set_autoneg_adv - set the phy autoneg Advertisement
*
*/
sw_error_t
aquantia_phy_set_autoneg_adv(a_uint32_t dev_id, a_uint32_t phy_addr,
			   a_uint32_t autoneg)
{
	a_uint16_t phy_data = 0, phy_data1 = 0 ;
	sw_error_t rv = SW_OK;

	if ((autoneg & FAL_PHY_ADV_10T_HD) || (autoneg & FAL_PHY_ADV_100TX_HD))
	{
		return SW_NOT_SUPPORTED;
	}

	rv = hsl_phy_phydev_autoneg_update(dev_id, phy_addr, A_TRUE, autoneg);
	SW_RTN_ON_ERROR(rv);

	rv = aquantia_phy_reg_read(dev_id, phy_addr, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_ADVERTISEMENT_REGISTER, &phy_data);
	SW_RTN_ON_ERROR(rv);
	phy_data &= ~AQUANTIA_ADVERTISE_MEGA_ALL;
	phy_data &=
	    ~(AQUANTIA_ADVERTISE_PAUSE | AQUANTIA_ADVERTISE_ASYM_PAUSE);
	if (autoneg & FAL_PHY_ADV_10T_FD)
	{
		phy_data |= AQUANTIA_ADVERTISE_10FULL;
	}
	if (autoneg & FAL_PHY_ADV_100TX_FD)
	{
		phy_data |= AQUANTIA_ADVERTISE_100FULL;
	}
	if (autoneg & FAL_PHY_ADV_PAUSE)
	{
		phy_data |= AQUANTIA_ADVERTISE_PAUSE;
	}
	if (autoneg & FAL_PHY_ADV_ASY_PAUSE)
	{
		phy_data |= AQUANTIA_ADVERTISE_ASYM_PAUSE;
	}
	rv = aquantia_phy_reg_write(dev_id, phy_addr, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_ADVERTISEMENT_REGISTER, phy_data);
	SW_RTN_ON_ERROR(rv);

	rv = aquantia_phy_reg_read(dev_id, phy_addr, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_VENDOR_PROVISION1, &phy_data);
	SW_RTN_ON_ERROR(rv);
	phy_data &= ~AQUANTIA_ADVERTISE_GIGA_ALL;

	rv = aquantia_phy_reg_read(dev_id, phy_addr, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_10GBASE_T_CONTROL_REGISTER, &phy_data1);
	SW_RTN_ON_ERROR(rv);
	phy_data1 &= ~AQUANTIA_ADVERTISE_GIGA_PLUS_ALL;
	if (autoneg & FAL_PHY_ADV_1000T_FD)
	{
		phy_data |= AQUANTIA_ADVERTISE_1000FULL;
	}
	if (autoneg & FAL_PHY_ADV_2500T_FD)
	{
		phy_data |= AQUANTIA_ADVERTISE_2500FULL;
		phy_data1 |= AQUANTIA_ADVERTISE_8023BZ_2500FULL;
	}
	if (autoneg & FAL_PHY_ADV_5000T_FD)
	{
		phy_data |= AQUANTIA_ADVERTISE_5000FULL;
		phy_data1 |= AQUANTIA_ADVERTISE_8023BZ_5000FULL;
	}
	rv = aquantia_phy_reg_write(dev_id, phy_addr, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_VENDOR_PROVISION1, phy_data);
	SW_RTN_ON_ERROR(rv);

	if (autoneg & FAL_PHY_ADV_10000T_FD)
		phy_data1 |= AQUANTIA_ADVERTISE_10000FULL;
	rv = aquantia_phy_reg_write(dev_id, phy_addr, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_10GBASE_T_CONTROL_REGISTER,phy_data1);

	return rv;
}

/******************************************************************************
*
* AQUANTIA_get_autoneg_adv - get the phy autoneg Advertisement
*
*/
sw_error_t
aquantia_phy_get_autoneg_adv(a_uint32_t dev_id, a_uint32_t phy_id,
			   a_uint32_t * autoneg)
{
	a_uint16_t phy_data = 0, phy_data1 = 0;
	sw_error_t rv = SW_OK;

	*autoneg = 0;
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_ADVERTISEMENT_REGISTER, &phy_data);
	SW_RTN_ON_ERROR(rv);
	if (phy_data & AQUANTIA_ADVERTISE_10FULL)
	{
		*autoneg |= FAL_PHY_ADV_10T_FD;
	}
	if (phy_data & AQUANTIA_ADVERTISE_100FULL)
	{
		*autoneg |= FAL_PHY_ADV_100TX_FD;
	}
	if (phy_data & AQUANTIA_ADVERTISE_PAUSE)
	{
		*autoneg |= FAL_PHY_ADV_PAUSE;
	}
	if (phy_data & AQUANTIA_ADVERTISE_ASYM_PAUSE)
	{
		*autoneg |= FAL_PHY_ADV_ASY_PAUSE;
	}

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_VENDOR_PROVISION1, &phy_data);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_10GBASE_T_CONTROL_REGISTER, &phy_data1);
	SW_RTN_ON_ERROR(rv);
	if (phy_data & AQUANTIA_ADVERTISE_1000FULL)
	{
		*autoneg |= FAL_PHY_ADV_1000T_FD;
	}
	if ((phy_data & AQUANTIA_ADVERTISE_2500FULL) &&
		(phy_data1 & AQUANTIA_ADVERTISE_8023BZ_2500FULL))
	{
		*autoneg |= FAL_PHY_ADV_2500T_FD;
	}
	if ((phy_data & AQUANTIA_ADVERTISE_5000FULL) &&
		(phy_data1 & AQUANTIA_ADVERTISE_8023BZ_5000FULL))
	{
		*autoneg |= FAL_PHY_ADV_5000T_FD;
	}

	if (phy_data1 & AQUANTIA_ADVERTISE_10000FULL)
	{
		*autoneg |= FAL_PHY_ADV_10000T_FD;
	}

	return rv;
}

/******************************************************************************
*
* aquantia_phy_enable_autonego
*
*/
a_bool_t aquantia_phy_autoneg_status(a_uint32_t dev_id, a_uint32_t phy_id)
{
	a_uint16_t phy_data;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_STANDARD_CONTROL1, &phy_data);
	SW_RTN_ON_ERROR(rv);
	if (phy_data & AQUANTIA_CTRL_AUTONEGOTIATION_ENABLE)
	{
		return A_TRUE;
	}

	return A_FALSE;
}
/******************************************************************************
*
* AQUANTIA_restart_autoneg - restart the phy autoneg
*
*/
sw_error_t aquantia_phy_restart_autoneg(a_uint32_t dev_id, a_uint32_t phy_addr)
{
	a_uint16_t phy_data = 0;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_addr, AQUANTIA_MMD_PHY_XS_REGISTERS,
		AQUANTIA_PHY_XS_USX_TRANSMIT, &phy_data);
	SW_RTN_ON_ERROR(rv);
	if (!(phy_data & AQUANTIA_PHY_USX_AUTONEG_ENABLE))
	{
		rv = aquantia_phy_reg_write(dev_id, phy_addr, AQUANTIA_MMD_PHY_XS_REGISTERS,
			AQUANTIA_PHY_XS_USX_TRANSMIT,
			phy_data | AQUANTIA_PHY_USX_AUTONEG_ENABLE);
		SW_RTN_ON_ERROR(rv);
	}

	rv = hsl_phy_phydev_autoneg_update(dev_id, phy_addr, A_TRUE, 0);
	SW_RTN_ON_ERROR(rv);

	rv = aquantia_phy_reg_read(dev_id, phy_addr, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_STANDARD_CONTROL1, &phy_data);
	phy_data |= AQUANTIA_CTRL_AUTONEGOTIATION_ENABLE;
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_write(dev_id, phy_addr, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_STANDARD_CONTROL1,
		phy_data | AQUANTIA_CTRL_RESTART_AUTONEGOTIATION);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_enable_autonego
*
*/
sw_error_t aquantia_phy_autoneg_set(a_uint32_t dev_id, a_uint32_t phy_addr,
	a_bool_t enable)
{
	a_uint16_t phy_data = 0;
	sw_error_t rv = SW_OK;

	rv = hsl_phy_phydev_autoneg_update(dev_id, phy_addr, enable, 0);
	SW_RTN_ON_ERROR(rv);

	rv = aquantia_phy_reg_read(dev_id, phy_addr, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_STANDARD_CONTROL1, &phy_data);
	SW_RTN_ON_ERROR(rv);
	if(enable)
		phy_data |= AQUANTIA_CTRL_AUTONEGOTIATION_ENABLE;
	else
		phy_data &= ~AQUANTIA_CTRL_AUTONEGOTIATION_ENABLE;
	rv = aquantia_phy_reg_write(dev_id, phy_addr, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_STANDARD_CONTROL1, phy_data);

	return rv;
}

sw_error_t aquantia_phy_enable_autoneg(a_uint32_t dev_id, a_uint32_t phy_addr)
{
	return aquantia_phy_autoneg_set(dev_id, phy_addr, A_TRUE);
}
#ifndef IN_PORTCONTROL_MINI
/******************************************************************************
*
* aquantia_phy_set_802.3az
*
* set 802.3az status
*/
sw_error_t
aquantia_phy_set_8023az(a_uint32_t dev_id, a_uint32_t phy_id, a_bool_t enable)
{
	a_uint16_t phy_data = 0, phy_data1 = 0;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_EEE_ADVERTISTMENT_REGISTER, &phy_data);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_EEE_ADVERTISTMENT_REGISTER1, &phy_data1);
	SW_RTN_ON_ERROR(rv);
	if(enable == A_TRUE)
	{
		phy_data |= (AQUANTIA_EEE_ADV_10000M | AQUANTIA_EEE_ADV_1000M);
		phy_data1 |= (AQUANTIA_EEE_ADV_2500M | AQUANTIA_EEE_ADV_5000M);
	}
	else
	{
		phy_data &= ~(AQUANTIA_EEE_ADV_10000M | AQUANTIA_EEE_ADV_1000M);
		phy_data1 &= ~(AQUANTIA_EEE_ADV_2500M | AQUANTIA_EEE_ADV_5000M);
	}
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_EEE_ADVERTISTMENT_REGISTER, phy_data);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_EEE_ADVERTISTMENT_REGISTER1, phy_data1);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_restart_autoneg(dev_id, phy_id);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_get_8023az status
*
* get 8023az status
*/
sw_error_t
aquantia_phy_get_8023az(a_uint32_t dev_id, a_uint32_t phy_id, a_bool_t * enable)
{
	a_uint16_t phy_data = 0, phy_data1 = 0;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_EEE_ADVERTISTMENT_REGISTER, &phy_data);
	SW_RTN_ON_ERROR(rv);

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_EEE_ADVERTISTMENT_REGISTER1, &phy_data1);
	SW_RTN_ON_ERROR(rv);

	if((phy_data & (AQUANTIA_EEE_ADV_1000M | AQUANTIA_EEE_ADV_10000M)) &&
		(phy_data1 & (AQUANTIA_EEE_ADV_2500M | AQUANTIA_EEE_ADV_5000M)))
	{
		*enable = A_TRUE;
	}
	else
	{
		*enable = A_FALSE;
	}

	return rv;
}
#endif
/******************************************************************************
*
* aquantia_phy_set_speed - Determines the speed of phy ports associated with the
* specified device.
*/
static sw_error_t
aquantia_phy_force_speed_set(a_uint32_t dev_id, a_uint32_t phy_addr,
	fal_port_speed_t speed)
{
	a_uint16_t phy_speed_ctrl = 0, phy_speed_type = 0;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_addr, AQUANTIA_MMD_PMA_REGISTERS,
		AQUANTIA_PMA_SPEED_CONTROL1, &phy_speed_ctrl);
	SW_RTN_ON_ERROR(rv);
	phy_speed_ctrl &= ~AQUANTIA_PHY_PMA_SPEED_MASK;

	rv = aquantia_phy_reg_read(dev_id, phy_addr, AQUANTIA_MMD_PMA_REGISTERS,
		AQUANTIA_PMA_SPEED_CONTROL2, &phy_speed_type);
	SW_RTN_ON_ERROR(rv);
	phy_speed_type &= ~AQUANTIA_PHY_PMA_SPEED_TYPE_MASK;

	switch(speed)
	{
		case FAL_SPEED_100:
			phy_speed_ctrl = AQUANTIA_PHY_PMA_SPEED_100;
			phy_speed_type = AQUANTIA_PHY_PMA_SPEED_TYPE_100;
			break;
		case FAL_SPEED_10:
			phy_speed_ctrl = AQUANTIA_PHY_PMA_SPEED_10;
			phy_speed_type = AQUANTIA_PHY_PMA_SPEED_TYPE_10;
			break;
		default:
			return SW_NOT_SUPPORTED;
	}

	rv = aquantia_phy_reg_write(dev_id, phy_addr, AQUANTIA_MMD_PMA_REGISTERS,
		AQUANTIA_PMA_SPEED_CONTROL1, phy_speed_ctrl);
	SW_RTN_ON_ERROR(rv);

	rv = aquantia_phy_reg_write(dev_id, phy_addr, AQUANTIA_MMD_PMA_REGISTERS,
		AQUANTIA_PMA_SPEED_CONTROL2, phy_speed_type);
	SW_RTN_ON_ERROR(rv);

	rv = aquantia_phy_autoneg_set(dev_id, phy_addr, A_FALSE);

	return rv;
}

static sw_error_t _aquantia_phy_set_giga_speed(a_uint32_t dev_id, a_uint32_t phy_id, fal_port_speed_t speed)
{
	a_uint16_t phy_data = 0, phy_data1 = 0;
	sw_error_t rv = SW_OK;
	/*set 1000M and disable 2500M, 5000M */
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_VENDOR_PROVISION1, &phy_data);
	SW_RTN_ON_ERROR(rv);
	phy_data &= ~(AQUANTIA_ADVERTISE_GIGA_ALL);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_10GBASE_T_CONTROL_REGISTER, &phy_data1);
	SW_RTN_ON_ERROR(rv);
	phy_data1 &= ~(AQUANTIA_ADVERTISE_GIGA_PLUS_ALL);
	switch(speed)
	{
		case FAL_SPEED_1000:
			phy_data |= AQUANTIA_ADVERTISE_1000FULL;
			break;
		case FAL_SPEED_2500:
			phy_data |= AQUANTIA_ADVERTISE_2500FULL;
			phy_data1 |= AQUANTIA_ADVERTISE_8023BZ_2500FULL;
			break;
		case FAL_SPEED_5000:
			phy_data |= AQUANTIA_ADVERTISE_5000FULL;
			phy_data1 |= AQUANTIA_ADVERTISE_8023BZ_5000FULL;
			break;
		default:
			return SW_NOT_SUPPORTED;
	}
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_VENDOR_PROVISION1, phy_data);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_10GBASE_T_CONTROL_REGISTER, phy_data1);
	SW_RTN_ON_ERROR(rv);

	/*disable 100M speed*/
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_ADVERTISEMENT_REGISTER, &phy_data);
	SW_RTN_ON_ERROR(rv);
	phy_data &= ~(AQUANTIA_ADVERTISE_MEGA_ALL);
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_ADVERTISEMENT_REGISTER, phy_data);

	return rv;
}

static sw_error_t _aquantia_phy_set_10g_speed(a_uint32_t dev_id, a_uint32_t phy_id)
{
	a_uint16_t phy_data = 0;
	sw_error_t rv = SW_OK;
	/*set giga speed */
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_10GBASE_T_CONTROL_REGISTER,&phy_data);
	SW_RTN_ON_ERROR(rv);
	phy_data &= ~(AQUANTIA_ADVERTISE_GIGA_PLUS_ALL);
	phy_data |= AQUANTIA_ADVERTISE_10000FULL;
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_10GBASE_T_CONTROL_REGISTER, phy_data);
	SW_RTN_ON_ERROR(rv);

	/*disable 100M speed*/
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_ADVERTISEMENT_REGISTER, &phy_data);
	SW_RTN_ON_ERROR(rv);
	phy_data &= ~(AQUANTIA_ADVERTISE_MEGA_ALL);
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_ADVERTISEMENT_REGISTER, phy_data);
	SW_RTN_ON_ERROR(rv);

	/*disable 1000M 2500M 5000M speed*/
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_VENDOR_PROVISION1, &phy_data);
	SW_RTN_ON_ERROR(rv);
	phy_data &= ~(AQUANTIA_ADVERTISE_GIGA_ALL);
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_VENDOR_PROVISION1, phy_data);

	return rv;
}

sw_error_t
aquantia_phy_set_speed(a_uint32_t dev_id, a_uint32_t phy_addr,
		     fal_port_speed_t speed)
{
	sw_error_t rv = SW_OK;

	switch(speed)
	{
		case FAL_SPEED_10000:
			rv = _aquantia_phy_set_10g_speed(dev_id, phy_addr);
			SW_RTN_ON_ERROR(rv);
			break;
		case FAL_SPEED_5000:
		case FAL_SPEED_2500:
		case FAL_SPEED_1000:
			rv = _aquantia_phy_set_giga_speed(dev_id, phy_addr, speed);
			SW_RTN_ON_ERROR(rv);
			break;
		case FAL_SPEED_100:
		case FAL_SPEED_10:
			rv = aquantia_phy_force_speed_set(dev_id, phy_addr, speed);
			SW_RTN_ON_ERROR(rv);
			break;
		default:
			return SW_NOT_SUPPORTED;
	}

	if(speed >= FAL_SPEED_1000)
	{
		rv = hsl_phy_phydev_autoneg_update(dev_id, phy_addr, A_TRUE,
			hsl_phy_speed_duplex_to_auto_adv(dev_id, speed, FAL_FULL_DUPLEX));
		SW_RTN_ON_ERROR(rv);
		rv = aquantia_phy_restart_autoneg(dev_id, phy_addr);
		SW_RTN_ON_ERROR(rv);
	}

	return SW_OK;
}

/******************************************************************************
*
* aquantia_phy_set_duplex - Determines the speed of phy ports associated with the
* specified device.
*/
sw_error_t
aquantia_phy_set_duplex(a_uint32_t dev_id, a_uint32_t phy_addr,
		      fal_port_duplex_t duplex)
{
	fal_port_speed_t old_speed;
	sw_error_t rv = SW_OK;

	if(duplex != FAL_FULL_DUPLEX)
		return SW_NOT_SUPPORTED;

	rv = aquantia_phy_get_speed(dev_id, phy_addr, &old_speed);
	SW_RTN_ON_ERROR(rv);

	return aquantia_phy_set_speed(dev_id, phy_addr, old_speed);
}
#ifndef IN_PORTCONTROL_MINI
/******************************************************************************
*
* aquantia_phy_set wol enable or disable
*
* set phy wol enable or disable
*/
sw_error_t
aquantia_phy_set_wol_status(a_uint32_t dev_id, a_uint32_t phy_id, a_bool_t enable)
{
	a_uint16_t phy_data0, phy_data1, phy_data2;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_RESERVED_VENDOR_PROVISIONING1, &phy_data0);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GBE_STANDARD_REGISTERS,
		AQUANTIA_MAGIC_ENGINE_REGISTER1, &phy_data1);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GBE_STANDARD_REGISTERS,
		AQUANTIA_MAGIC_ENGINE_REGISTER2, &phy_data2);

	if (enable == A_TRUE)
	{
		phy_data0 |= AQUANTIA_PHY_WOL_ENABLE;
		phy_data1 |= AQUANTIA_MAGIC_PACKETS_ENABLE;
		phy_data2 |= AQUANTIA_MAGIC_PACKETS_ENABLE;
	}
	else
	{
		phy_data0 &= ~AQUANTIA_PHY_WOL_ENABLE;
		phy_data1 &= ~AQUANTIA_MAGIC_PACKETS_ENABLE;
		phy_data2 &= ~AQUANTIA_MAGIC_PACKETS_ENABLE;
	}
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_RESERVED_VENDOR_PROVISIONING1, phy_data0);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_GBE_STANDARD_REGISTERS,
		AQUANTIA_MAGIC_ENGINE_REGISTER1, phy_data1);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_GBE_STANDARD_REGISTERS,
		AQUANTIA_MAGIC_ENGINE_REGISTER2, phy_data2);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_get_wol status
*
* get wol status
*/
sw_error_t
aquantia_phy_get_wol_status(a_uint32_t dev_id, a_uint32_t phy_id, a_bool_t * enable)
{
	a_uint16_t phy_data;
	sw_error_t rv = SW_OK;

	*enable = A_FALSE;
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_RESERVED_VENDOR_PROVISIONING1, &phy_data);
	SW_RTN_ON_ERROR(rv);
	if (phy_data & AQUANTIA_PHY_WOL_ENABLE)
	{
		*enable = A_TRUE;
	}

	return rv;
}

/******************************************************************************
*
* aquantia_phy_set wol frame mac address
*
* set phy wol frame mac address
*/
sw_error_t
aquantia_phy_set_magic_frame_mac(a_uint32_t dev_id, a_uint32_t phy_id,
			       fal_mac_addr_t * mac)
{
	a_uint16_t phy_data1;
	a_uint16_t phy_data2;
	a_uint16_t phy_data3;
	sw_error_t rv = SW_OK;

	phy_data1 = (mac->uc[1] << 8) | mac->uc[0];
	phy_data2 = (mac->uc[3] << 8) | mac->uc[2];
	phy_data3 = (mac->uc[5] << 8) | mac->uc[4];
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_GBE_STANDARD_REGISTERS,
		AQUANTIA_MAGIC_FRAME_MAC0, phy_data1);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_GBE_STANDARD_REGISTERS,
		AQUANTIA_MAGIC_FRAME_MAC1, phy_data2);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_GBE_STANDARD_REGISTERS,
		AQUANTIA_MAGIC_FRAME_MAC2, phy_data3);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_get wol frame mac address
*
* get phy wol frame mac address
*/
sw_error_t
aquantia_phy_get_magic_frame_mac(a_uint32_t dev_id, a_uint32_t phy_id,
			       fal_mac_addr_t * mac)
{
	a_uint16_t phy_data1;
	a_uint16_t phy_data2;
	a_uint16_t phy_data3;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GBE_STANDARD_REGISTERS,
		AQUANTIA_MAGIC_FRAME_MAC0, &phy_data1);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GBE_STANDARD_REGISTERS,
		AQUANTIA_MAGIC_FRAME_MAC1, &phy_data2);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GBE_STANDARD_REGISTERS,
		AQUANTIA_MAGIC_FRAME_MAC2, &phy_data3);
	SW_RTN_ON_ERROR(rv);
	mac->uc[0] = (phy_data1 & BITS(0, 8));
	mac->uc[1] = (phy_data1 >> 8) & BITS(0, 8);
	mac->uc[2] = (phy_data2 & BITS(0, 8));
	mac->uc[3] = (phy_data2 >> 8) & BITS(0, 8);
	mac->uc[4] = (phy_data3 & BITS(0, 8));
	mac->uc[5] = (phy_data3 >> 8) & BITS(0, 8);

	return rv;
}
#endif
sw_error_t
aquantia_phy_interface_set_mode(a_uint32_t dev_id, a_uint32_t phy_id, fal_port_interface_mode_t interface_mode)
{
	a_uint16_t phy_data;
	a_uint32_t phy_register;
	fal_port_speed_t speed;
	sw_error_t rv =SW_OK;

	rv = aquantia_phy_get_speed(dev_id, phy_id, &speed);
	SW_RTN_ON_ERROR(rv);
	switch (speed)
	{
		case FAL_SPEED_10:
			phy_register = AQUANTIA_GLOBAL_SYS_CONFIG_FOR_10M;
			break;
		case FAL_SPEED_100:
			phy_register = AQUANTIA_GLOBAL_SYS_CONFIG_FOR_100M;
			break;
		case FAL_SPEED_1000:
			phy_register = AQUANTIA_GLOBAL_SYS_CONFIG_FOR_1000M;
			break;
		case FAL_SPEED_2500:
			phy_register = AQUANTIA_GLOBAL_SYS_CONFIG_FOR_2500M;
			break;
		case FAL_SPEED_5000:
			phy_register = AQUANTIA_GLOBAL_SYS_CONFIG_FOR_5000M;
			break;
		case FAL_SPEED_10000:
			phy_register = AQUANTIA_GLOBAL_SYS_CONFIG_FOR_10000M;
			break;
		default:
			return SW_NOT_SUPPORTED;
	}
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
					phy_register, &phy_data);
	SW_RTN_ON_ERROR(rv);
	phy_data &= ~(BITS(0, 3));
	switch(interface_mode)
	{
		case PHY_SGMII_BASET:
			if(speed == FAL_SPEED_10 || speed == FAL_SPEED_100 ||
				speed == FAL_SPEED_1000)
			{
				phy_data |= AQUANTIA_SERDES_MODE_SGMII;
			}
			else
			{
				return SW_NOT_SUPPORTED;
			}
			break;
		case PORT_USXGMII:
			phy_data |= AQUANTIA_SERDES_MODE_XFI;
			break;
		case PORT_SGMII_PLUS:
			if(speed == FAL_SPEED_2500)
			{
				phy_data |= AQUANTIA_SERDES_MODE_OCSGMII;
			}
			else
			{
				return SW_NOT_SUPPORTED;
			}
			break;
		default:
			return SW_NOT_SUPPORTED;
	}
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		phy_register, phy_data);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_interface mode status get
*
* get aquantia phy interface mode status
*/
sw_error_t
aquantia_phy_interface_get_mode_status(a_uint32_t dev_id, a_uint32_t phy_id,
		fal_port_interface_mode_t *interface_mode_status)
{
	a_uint16_t phy_data;
	a_uint32_t phy_register;
	fal_port_speed_t speed;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_get_speed(dev_id, phy_id, &speed);
	SW_RTN_ON_ERROR(rv);
	switch (speed)
	{
		case FAL_SPEED_10:
			phy_register = AQUANTIA_GLOBAL_SYS_CONFIG_FOR_10M;
			break;
		case FAL_SPEED_100:
			phy_register = AQUANTIA_GLOBAL_SYS_CONFIG_FOR_100M;
			break;
		case FAL_SPEED_1000:
			phy_register = AQUANTIA_GLOBAL_SYS_CONFIG_FOR_1000M;
			break;
		case FAL_SPEED_2500:
			phy_register = AQUANTIA_GLOBAL_SYS_CONFIG_FOR_2500M;
			break;
		case FAL_SPEED_5000:
			phy_register = AQUANTIA_GLOBAL_SYS_CONFIG_FOR_5000M;
			break;
		case FAL_SPEED_10000:
			phy_register = AQUANTIA_GLOBAL_SYS_CONFIG_FOR_10000M;
			break;
		default:
			return SW_NOT_SUPPORTED;
	}
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		phy_register, &phy_data);
	SW_RTN_ON_ERROR(rv);
	phy_data &= (BITS(0, 3));
	switch(phy_data)
	{
		case AQUANTIA_SERDES_MODE_SGMII:
			*interface_mode_status = PHY_SGMII_BASET;
			break;
		case AQUANTIA_SERDES_MODE_XFI:
			*interface_mode_status = PORT_USXGMII;
			break;
		case AQUANTIA_SERDES_MODE_OCSGMII:
			*interface_mode_status = PORT_SGMII_PLUS;
			break;
		default:
			return SW_NOT_SUPPORTED;
	}

	return rv;
}
#ifndef IN_PORTCONTROL_MINI
/******************************************************************************
*
* aquantia_phy_intr_mask_set - Set interrupt mask with the
* specified device.
*/
sw_error_t
aquantia_phy_intr_mask_set(a_uint32_t dev_id, a_uint32_t phy_id,
			 a_uint32_t intr_mask_flag)
{
	a_uint16_t phy_data = 0;
	sw_error_t rv = SW_OK;

	if ((FAL_PHY_INTR_STATUS_DOWN_CHANGE |FAL_PHY_INTR_STATUS_UP_CHANGE)
		& intr_mask_flag)
	{
		rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
			AQUANTIA_AUTONEG_TRANSMIT_VENDOR_INTR_MASK, &phy_data);
		SW_RTN_ON_ERROR(rv);
		phy_data |= AQUANTIA_INTR_LINK_STATUS_CHANGE;
		rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
			AQUANTIA_AUTONEG_TRANSMIT_VENDOR_INTR_MASK, phy_data);
		SW_RTN_ON_ERROR(rv);

		rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
			AQUANTIA_GLOBAL_INTR_VENDOR_MASK, &phy_data);
		SW_RTN_ON_ERROR(rv);
		phy_data |= AQUANTIA_AUTO_AND_ALARMS_INTR_MASK;
		rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
			AQUANTIA_GLOBAL_INTR_VENDOR_MASK, phy_data);
		SW_RTN_ON_ERROR(rv);

		rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
			AQUANTIA_GLOBAL_INTR_STANDARD_MASK, &phy_data);
		SW_RTN_ON_ERROR(rv);
		phy_data |= AQUANTIA_ALL_VENDOR_ALARMS_INTR_MASK;
		rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
			AQUANTIA_GLOBAL_INTR_STANDARD_MASK, phy_data);
	}

	return rv;
}

/******************************************************************************
*
* aquantia_phy_intr_mask_get - Get interrupt mask with the
* specified device.
*/
sw_error_t
aquantia_phy_intr_mask_get(a_uint32_t dev_id, a_uint32_t phy_id,
			 a_uint32_t * intr_mask_flag)
{
	a_uint16_t phy_data1 = 0, phy_data2 = 0, phy_data3 = 0;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_AUTONEG_TRANSMIT_VENDOR_INTR_MASK, &phy_data1);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_GLOBAL_INTR_VENDOR_MASK, &phy_data2);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_GLOBAL_INTR_STANDARD_MASK, &phy_data3);
	if ((AQUANTIA_INTR_LINK_STATUS_CHANGE & phy_data1) &&
		(AQUANTIA_AUTO_AND_ALARMS_INTR_MASK & phy_data2) &&
		(AQUANTIA_ALL_VENDOR_ALARMS_INTR_MASK & phy_data3))
	{
		*intr_mask_flag = FAL_PHY_INTR_STATUS_DOWN_CHANGE |
			FAL_PHY_INTR_STATUS_UP_CHANGE;
	}

	return rv;
}
#endif
/******************************************************************************
*
* aquantia_phy_off - power off the phy
*
* Power off the phy
*/
sw_error_t aquantia_phy_poweroff(a_uint32_t dev_id, a_uint32_t phy_id)
{
	a_uint16_t phy_data;
	sw_error_t rv;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_GLOBAL_STANDARD_CONTROL1, &phy_data);
	SW_RTN_ON_ERROR(rv);
	phy_data |= AQUANTIA_POWER_DOWN;
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_GLOBAL_STANDARD_CONTROL1,phy_data);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_on - power on the phy
*
* Power on the phy
*/
sw_error_t aquantia_phy_poweron(a_uint32_t dev_id, a_uint32_t phy_id)
{
	a_uint16_t phy_data;
	sw_error_t rv;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_GLOBAL_STANDARD_CONTROL1, &phy_data);
	SW_RTN_ON_ERROR(rv);
	phy_data &= ~AQUANTIA_POWER_DOWN;
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_GLOBAL_REGISTERS,
		AQUANTIA_GLOBAL_STANDARD_CONTROL1,phy_data);

	return rv;
}
#ifndef IN_PORTCONTROL_MINI
static sw_error_t
_aquantia_phy_line_side_counter_get(a_uint32_t dev_id, a_uint32_t phy_id,
			 fal_port_counter_info_t * counter_infor)
{
	a_uint16_t msw_counter;
	a_uint16_t lsw_counter;
	sw_error_t rv = SW_OK;

	/*get line side tx good packets*/
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_LINE_SIDE_TRANSMIT_GOOD_FRAME_COUNTER2, &msw_counter);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_LINE_SIDE_TRANSMIT_GOOD_FRAME_COUNTER1, &lsw_counter);
	SW_RTN_ON_ERROR(rv);
	counter_infor->TxGoodFrame = (msw_counter << 16) | lsw_counter;

	/*get line side tx bad packets*/
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_LINE_SIDE_TRANSMIT_ERROR_FRAME_COUNTER2, &msw_counter);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_LINE_SIDE_TRANSMIT_ERROR_FRAME_COUNTER1, &lsw_counter);
	SW_RTN_ON_ERROR(rv);
	counter_infor->TxBadCRC = (msw_counter << 16) | lsw_counter;

	/*get line side rx good packets*/
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_LINE_SIDE_RECEIVE_GOOD_FRAME_COUNTER2, &msw_counter);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_LINE_SIDE_RECEIVE_GOOD_FRAME_COUNTER1, &lsw_counter);
	SW_RTN_ON_ERROR(rv);
	counter_infor->RxGoodFrame = (msw_counter << 16) | lsw_counter;

	/*get line side rx bad packets*/
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_LINE_SIDE_RECEIVE_ERROR_FRAME_COUNTER2, &msw_counter);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_LINE_SIDE_RECEIVE_ERROR_FRAME_COUNTER1, &lsw_counter);
	SW_RTN_ON_ERROR(rv);
	counter_infor->RxBadCRC = (msw_counter << 16) | lsw_counter;

	return rv;
}

static sw_error_t
_aquantia_phy_system_side_counter_get(a_uint32_t dev_id, a_uint32_t phy_id,
			 fal_port_counter_info_t * counter_infor)
{
	a_uint16_t msw_counter;
	a_uint16_t lsw_counter;
	sw_error_t rv = SW_OK;

	/*get system tx good packets*/
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_SYSTEM_SIDE_TRANSMIT_GOOD_FRAME_COUNTER2, &msw_counter);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_SYSTEM_SIDE_TRANSMIT_GOOD_FRAME_COUNTER1, &lsw_counter);
	SW_RTN_ON_ERROR(rv);
	counter_infor->SysTxGoodFrame = (msw_counter << 16) | lsw_counter;

	/*get system tx bad packets*/
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_SYSTEM_SIDE_TRANSMIT_ERROR_FRAME_COUNTER2, &msw_counter);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_SYSTEM_SIDE_TRANSMIT_ERROR_FRAME_COUNTER1, &lsw_counter);
	SW_RTN_ON_ERROR(rv);
	counter_infor->SysTxBadCRC = (msw_counter << 16) | lsw_counter;

	/*get system rx good packets*/
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_SYSTEM_SIDE_RECEIVE_GOOD_FRAME_COUNTER2, &msw_counter);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_SYSTEM_SIDE_RECEIVE_GOOD_FRAME_COUNTER1, &lsw_counter);
	SW_RTN_ON_ERROR(rv);
	counter_infor->SysRxGoodFrame = (msw_counter << 16) | lsw_counter;

	/*get system rx bad packets*/
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_SYSTEM_SIDE_RECEIVE_ERROR_FRAME_COUNTER2, &msw_counter);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_SYSTEM_SIDE_RECEIVE_ERROR_FRAME_COUNTER1, &lsw_counter);
	SW_RTN_ON_ERROR(rv);
	counter_infor->SysRxBadCRC = (msw_counter << 16) | lsw_counter;

	return rv;
}

/******************************************************************************
*
* aquantia_phy_show show counter statistics
*
* show counter statistics
*/
sw_error_t
aquantia_phy_show_counter(a_uint32_t dev_id, a_uint32_t phy_id,
			 fal_port_counter_info_t * counter_infor)
{
	sw_error_t rv = SW_OK;
	fal_port_speed_t speed;

	rv = aquantia_phy_get_speed(dev_id, phy_id, &speed);
	SW_RTN_ON_ERROR(rv);
	if(speed == FAL_SPEED_2500 || speed == FAL_SPEED_5000 || speed == FAL_SPEED_10000)
	{
		rv = _aquantia_phy_line_side_counter_get(dev_id, phy_id, counter_infor);
		SW_RTN_ON_ERROR(rv);
	}
	rv = _aquantia_phy_system_side_counter_get(dev_id, phy_id, counter_infor);

	return rv;
}
#endif
/******************************************************************************
*
* aquantia_phy_get_status
*
* get phy status
*/
sw_error_t
aquantia_phy_get_status(a_uint32_t dev_id, a_uint32_t phy_id,
		struct port_phy_status *phy_status)
{
	sw_error_t rv = SW_OK;
	a_uint16_t phy_data;

	/*get phy link status*/
	phy_status->link_status = aquantia_phy_get_link_status(dev_id, phy_id);
	if(phy_status->link_status != A_TRUE)
	{
		return SW_OK;
	}
	/*get phy speed and duplex*/
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_REG_AUTONEG_VENDOR_STATUS, &phy_data);
	SW_RTN_ON_ERROR(rv);
	switch ((phy_data & AQUANTIA_STATUS_SPEED_MASK) >>1)
	{
		case AQUANTIA_STATUS_SPEED_10MBS:
			phy_status->speed = FAL_SPEED_10;
			break;
		case AQUANTIA_STATUS_SPEED_100MBS:
			phy_status->speed = FAL_SPEED_100;
			break;
		case AQUANTIA_STATUS_SPEED_1000MBS:
			phy_status->speed = FAL_SPEED_1000;
			break;
		case AQUANTIA_STATUS_SPEED_2500MBS:
			phy_status->speed = FAL_SPEED_2500;
			break;
		case AQUANTIA_STATUS_SPEED_5000MBS:
			phy_status->speed = FAL_SPEED_5000;
			break;
		case AQUANTIA_STATUS_SPEED_10000MBS:
			phy_status->speed = FAL_SPEED_10000;
			break;
		default:
			return SW_READ_ERROR;
	}
	if (phy_data & AQUANTIA_STATUS_FULL_DUPLEX)
	{
		phy_status->duplex = FAL_FULL_DUPLEX;
	}
	else
	{
		phy_status->duplex = FAL_HALF_DUPLEX;
	}
	/* get phy tx flowctrl and rx flowctrl resolution status */
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_RESERVED_VENDOR_STATUS1, &phy_data);
	SW_RTN_ON_ERROR(rv);
	if(phy_data & AQUANTIA_PHY_TX_FLOWCTRL_STATUS)
	{
		phy_status->tx_flowctrl = A_TRUE;
	}
	else
	{
		phy_status->tx_flowctrl = A_FALSE;
	}
	if(phy_data & AQUANTIA_PHY_RX_FLOWCTRL_STATUS)
	{
		phy_status->rx_flowctrl = A_TRUE;
	}
	else
	{
		phy_status->rx_flowctrl = A_FALSE;
	}

	return rv;
}

/******************************************************************************
*
* aquantia_phy_set_eee_advertisement
*
* set eee advertisement
*/
sw_error_t
aquantia_phy_set_eee_adv(a_uint32_t dev_id, a_uint32_t phy_id,
	a_uint32_t adv)
{
	a_uint16_t phy_data = 0, phy_data1 = 0;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_EEE_ADVERTISTMENT_REGISTER, &phy_data);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_EEE_ADVERTISTMENT_REGISTER1, &phy_data1);
	SW_RTN_ON_ERROR(rv);

	phy_data &= ~(AQUANTIA_EEE_ADV_1000M | AQUANTIA_EEE_ADV_10000M);
	if (adv & FAL_PHY_EEE_1000BASE_T) {
		phy_data |= AQUANTIA_EEE_ADV_1000M;
	}
	if (adv & FAL_PHY_EEE_10000BASE_T) {
		phy_data |= AQUANTIA_EEE_ADV_10000M;
	}

	phy_data1 &= ~(AQUANTIA_EEE_ADV_2500M | AQUANTIA_EEE_ADV_5000M);
	if (adv & FAL_PHY_EEE_2500BASE_T) {
		phy_data1 |= AQUANTIA_EEE_ADV_2500M;
	}
	if (adv & FAL_PHY_EEE_5000BASE_T) {
		phy_data1 |= AQUANTIA_EEE_ADV_5000M;
	}

	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_EEE_ADVERTISTMENT_REGISTER, phy_data);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_reg_write(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_EEE_ADVERTISTMENT_REGISTER1, phy_data1);
	SW_RTN_ON_ERROR(rv);
	rv = aquantia_phy_restart_autoneg(dev_id, phy_id);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_get_eee_advertisement
*
* get eee advertisement
*/
sw_error_t
aquantia_phy_get_eee_adv(a_uint32_t dev_id, a_uint32_t phy_id,
	a_uint32_t *adv)
{
	a_uint16_t phy_data = 0;
	sw_error_t rv = SW_OK;

	*adv = 0;
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_EEE_ADVERTISTMENT_REGISTER, &phy_data);
	SW_RTN_ON_ERROR(rv);

	if (phy_data & AQUANTIA_EEE_ADV_1000M) {
		*adv |= FAL_PHY_EEE_1000BASE_T;
	}
	if (phy_data & AQUANTIA_EEE_ADV_10000M){
		*adv |= FAL_PHY_EEE_10000BASE_T;
	}
	phy_data = 0;
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_EEE_ADVERTISTMENT_REGISTER1, &phy_data);
	SW_RTN_ON_ERROR(rv);

	if (phy_data & AQUANTIA_EEE_ADV_2500M) {
		*adv |= FAL_PHY_EEE_2500BASE_T;
	}
	if (phy_data & AQUANTIA_EEE_ADV_5000M) {
		*adv |= FAL_PHY_EEE_5000BASE_T;
	}

	return rv;
}
/******************************************************************************
*
* aquantia_phy_get_eee_partner_advertisement
*
* get eee partner advertisement
*/
sw_error_t
aquantia_phy_get_eee_partner_adv(a_uint32_t dev_id, a_uint32_t phy_id,
	a_uint32_t *adv)
{
	a_uint16_t phy_data = 0;
	sw_error_t rv = SW_OK;

	*adv = 0;
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_EEE_PARTNER_ADVERTISTMENT_REGISTER, &phy_data);
	SW_RTN_ON_ERROR(rv);

	if (phy_data & AQUANTIA_EEE_PARTNER_ADV_1000M) {
		*adv |= FAL_PHY_EEE_1000BASE_T;
	}
	if (phy_data & AQUANTIA_EEE_PARTNER_ADV_10000M){
		*adv |= FAL_PHY_EEE_10000BASE_T;
	}
	phy_data = 0;
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_AUTONEG,
		AQUANTIA_EEE_PARTNER_ADVERTISTMENT_REGISTER1, &phy_data);
	SW_RTN_ON_ERROR(rv);

	if (phy_data & AQUANTIA_EEE_PARTNER_ADV_2500M) {
		*adv |= FAL_PHY_EEE_2500BASE_T;
	}
	if (phy_data & AQUANTIA_EEE_PARTNER_ADV_5000M) {
		*adv |= FAL_PHY_EEE_5000BASE_T;
	}

	return rv;
}
/******************************************************************************
*
* aquantia_phy_get_eee_capability
*
* get eee capability
*/
sw_error_t
aquantia_phy_get_eee_cap(a_uint32_t dev_id, a_uint32_t phy_id,
	a_uint32_t *cap)
{
	a_uint16_t phy_data = 0;
	sw_error_t rv = SW_OK;

	*cap = 0;
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_EEE_CAPABILITY_REGISTER, &phy_data);
	SW_RTN_ON_ERROR(rv);

	if (phy_data & AQUANTIA_EEE_CAPABILITY_1000M) {
		*cap |= FAL_PHY_EEE_1000BASE_T;
	}
	if (phy_data & AQUANTIA_EEE_CAPABILITY_10000M){
		*cap |= FAL_PHY_EEE_10000BASE_T;
	}
	phy_data = 0;
	rv = aquantia_phy_reg_read(dev_id, phy_id, AQUANTIA_MMD_PCS_REGISTERS,
		AQUANTIA_EEE_CAPABILITY_REGISTER1, &phy_data);
	SW_RTN_ON_ERROR(rv);

	if (phy_data & AQUANTIA_EEE_CAPABILITY_2500M) {
		*cap |= FAL_PHY_EEE_2500BASE_T;
	}
	if (phy_data & AQUANTIA_EEE_CAPABILITY_5000M) {
		*cap |= FAL_PHY_EEE_5000BASE_T;
	}

	return rv;
}
/******************************************************************************
*
* aquantia_phy_get_eee_status
*
* get eee status
*/
sw_error_t
aquantia_phy_get_eee_status(a_uint32_t dev_id, a_uint32_t phy_id,
	a_uint32_t *status)
{
	a_uint32_t adv = 0, lp_adv = 0;
	sw_error_t rv = SW_OK;

	rv = aquantia_phy_get_eee_adv(dev_id, phy_id, &adv);
	SW_RTN_ON_ERROR(rv);

	rv = aquantia_phy_get_eee_partner_adv(dev_id, phy_id, &lp_adv);
	SW_RTN_ON_ERROR(rv);

	*status = (adv & lp_adv);

	return rv;
}

/******************************************************************************
*
* aquantia_phy_hw_register init to avoid packet loss
*
*/
sw_error_t
aquantia_phy_hw_init(a_uint32_t dev_id,  a_uint32_t port_bmp)
{
	a_uint16_t phy_data = 0;
	a_uint32_t port_id = 0, phy_addr = 0, aq_phy_id = 0;
	sw_error_t rv = SW_OK;

	for (port_id = 0; port_id < SW_MAX_NR_PORT; port_id ++)
	{
		if (port_bmp & (0x1 << port_id))
		{
			phy_addr = qca_ssdk_port_to_phy_addr(dev_id, port_id);
			/*set auto neg of aq*/
			rv = aquantia_phy_reg_read(dev_id, phy_addr, AQUANTIA_MMD_PHY_XS_REGISTERS,
				AQUANTIA_PHY_XS_USX_TRANSMIT, &phy_data);
			SW_RTN_ON_ERROR(rv);
			phy_data |= AQUANTIA_PHY_USX_AUTONEG_ENABLE;
			rv = aquantia_phy_reg_write(dev_id, phy_addr, AQUANTIA_MMD_PHY_XS_REGISTERS,
				AQUANTIA_PHY_XS_USX_TRANSMIT,phy_data);
			SW_RTN_ON_ERROR(rv);
			/*config interrupt of aq*/
			rv = aquantia_phy_reg_read(dev_id, phy_addr, AQUANTIA_MMD_AUTONEG,
				AQUANTIA_AUTONEG_TRANSMIT_VENDOR_INTR_MASK, &phy_data);
			SW_RTN_ON_ERROR(rv);
			phy_data |= AQUANTIA_INTR_LINK_STATUS_CHANGE;
			rv = aquantia_phy_reg_write(dev_id, phy_addr, AQUANTIA_MMD_AUTONEG,
				AQUANTIA_AUTONEG_TRANSMIT_VENDOR_INTR_MASK, phy_data);
			SW_RTN_ON_ERROR(rv);
			rv = aquantia_phy_reg_read(dev_id, phy_addr, AQUANTIA_MMD_GLOBAL_REGISTERS,
				AQUANTIA_GLOBAL_INTR_STANDARD_MASK, &phy_data);
			SW_RTN_ON_ERROR(rv);
			phy_data |= AQUANTIA_ALL_VENDOR_ALARMS_INTR_MASK;
			rv = aquantia_phy_reg_write(dev_id, phy_addr, AQUANTIA_MMD_GLOBAL_REGISTERS,
				AQUANTIA_GLOBAL_INTR_STANDARD_MASK, phy_data);
			SW_RTN_ON_ERROR(rv);
			rv = aquantia_phy_reg_read(dev_id, phy_addr, AQUANTIA_MMD_GLOBAL_REGISTERS,
				AQUANTIA_GLOBAL_INTR_VENDOR_MASK, &phy_data);
			SW_RTN_ON_ERROR(rv);
			phy_data |= AQUANTIA_AUTO_AND_ALARMS_INTR_MASK;
			rv = aquantia_phy_reg_write(dev_id, phy_addr, AQUANTIA_MMD_GLOBAL_REGISTERS,
				AQUANTIA_GLOBAL_INTR_VENDOR_MASK, phy_data);
			SW_RTN_ON_ERROR(rv);

			/* config aq phy ACT and LINK led behavior*/
			rv = aquantia_phy_get_phy_id (dev_id, phy_addr, &aq_phy_id);
			SW_RTN_ON_ERROR(rv);
			if(aq_phy_id == AQUANTIA_PHY_113C_B0 || aq_phy_id == AQUANTIA_PHY_113C_B1)
			{
				rv = aquantia_phy_reg_write(dev_id, phy_addr,
					AQUANTIA_MMD_GLOBAL_REGISTERS,
					AQUANTIA_PROVISIONING_LED0_STATUS,
					AQUANTIA_LINK_ACT_LED_DISABLE_VALUE);
				SW_RTN_ON_ERROR(rv);
				rv = aquantia_phy_reg_write(dev_id, phy_addr,
					AQUANTIA_MMD_GLOBAL_REGISTERS,
					AQUANTIA_PROVISIONING_LED1_STATUS,
					AQUANTIA_LINK_ACT_LED_VALUE);
				SW_RTN_ON_ERROR(rv);
				rv = aquantia_phy_reg_write(dev_id, phy_addr,
					AQUANTIA_MMD_GLOBAL_REGISTERS,
					AQUANTIA_PROVISIONING_LED2_STATUS,
					AQUANTIA_LINK_ACT_LED_DISABLE_VALUE);
				SW_RTN_ON_ERROR(rv);
			}
			else
			{
				rv = aquantia_phy_reg_write(dev_id, phy_addr,
					AQUANTIA_MMD_GLOBAL_REGISTERS,
					AQUANTIA_PROVISIONING_LED0_STATUS,
					AQUANTIA_LINK_ACT_LED_VALUE);
				SW_RTN_ON_ERROR(rv);
				rv = aquantia_phy_reg_write(dev_id, phy_addr,
					AQUANTIA_MMD_GLOBAL_REGISTERS,
					AQUANTIA_PROVISIONING_LED1_STATUS,
					AQUANTIA_LINK_LED_VALUE);
				SW_RTN_ON_ERROR(rv);
			}
			/*add all ability of aq phy*/
			rv = aquantia_phy_set_autoneg_adv(dev_id, phy_addr,
				FAL_PHY_ADV_XGE_SPEED_ALL | FAL_PHY_ADV_100TX_FD |
				FAL_PHY_ADV_10T_FD | FAL_PHY_ADV_1000T_FD);
			SW_RTN_ON_ERROR(rv);
#if 0
			rv = aquantia_phy_set_eee_adv(dev_id, phy_addr, FAL_PHY_EEE_1000BASE_T
				| FAL_PHY_EEE_2500BASE_T | FAL_PHY_EEE_5000BASE_T |
				FAL_PHY_EEE_10000BASE_T);
			SW_RTN_ON_ERROR(rv);
#endif
		}
	}

	return rv;
}

static int aquantia_phy_api_ops_init(void)
{
	int ret;
	hsl_phy_ops_t *aquantia_phy_api_ops = NULL;

	aquantia_phy_api_ops = kzalloc(sizeof(hsl_phy_ops_t), GFP_KERNEL);
	if (aquantia_phy_api_ops == NULL) {
		SSDK_ERROR("aquantia phy ops kzalloc failed!\n");
		return -ENOMEM;
	}

	phy_api_ops_init(AQUANTIA_PHY_CHIP);

	aquantia_phy_api_ops->phy_speed_get = aquantia_phy_get_speed;
	aquantia_phy_api_ops->phy_speed_set = aquantia_phy_set_speed;
	aquantia_phy_api_ops->phy_duplex_get = aquantia_phy_get_duplex;
	aquantia_phy_api_ops->phy_duplex_set = aquantia_phy_set_duplex;
	aquantia_phy_api_ops->phy_autoneg_enable_set = aquantia_phy_enable_autoneg;
	aquantia_phy_api_ops->phy_restart_autoneg = aquantia_phy_restart_autoneg;
	aquantia_phy_api_ops->phy_autoneg_status_get = aquantia_phy_autoneg_status;
	aquantia_phy_api_ops->phy_autoneg_adv_set = aquantia_phy_set_autoneg_adv;
	aquantia_phy_api_ops->phy_autoneg_adv_get = aquantia_phy_get_autoneg_adv;
#ifndef IN_PORTCONTROL_MINI
	aquantia_phy_api_ops->phy_powersave_set = aquantia_phy_set_powersave;
	aquantia_phy_api_ops->phy_powersave_get = aquantia_phy_get_powersave;
	aquantia_phy_api_ops->phy_8023az_set = aquantia_phy_set_8023az;
	aquantia_phy_api_ops->phy_8023az_get = aquantia_phy_get_8023az;
#endif
	aquantia_phy_api_ops->phy_power_on = aquantia_phy_poweron;
	aquantia_phy_api_ops->phy_power_off = aquantia_phy_poweroff;
	aquantia_phy_api_ops->phy_cdt = aquantia_phy_cdt;
	aquantia_phy_api_ops->phy_link_status_get = aquantia_phy_get_link_status;
#ifndef IN_PORTCONTROL_MINI
	aquantia_phy_api_ops->phy_mdix_set = aquantia_phy_set_mdix;
	aquantia_phy_api_ops->phy_mdix_get = aquantia_phy_get_mdix;
	aquantia_phy_api_ops->phy_mdix_status_get = aquantia_phy_get_mdix_status;
	aquantia_phy_api_ops->phy_local_loopback_set = aquantia_phy_set_local_loopback;
	aquantia_phy_api_ops->phy_local_loopback_get = aquantia_phy_get_local_loopback;
	aquantia_phy_api_ops->phy_remote_loopback_set = aquantia_phy_set_remote_loopback;
	aquantia_phy_api_ops->phy_remote_loopback_get = aquantia_phy_get_remote_loopback;
	aquantia_phy_api_ops->phy_reset = aquantia_phy_reset;
	aquantia_phy_api_ops->phy_wol_status_set = aquantia_phy_set_wol_status;
	aquantia_phy_api_ops->phy_wol_status_get = aquantia_phy_get_wol_status;
	aquantia_phy_api_ops->phy_magic_frame_mac_get = aquantia_phy_get_magic_frame_mac;
	aquantia_phy_api_ops->phy_magic_frame_mac_set = aquantia_phy_set_magic_frame_mac;
	aquantia_phy_api_ops->phy_intr_mask_set = aquantia_phy_intr_mask_set;
	aquantia_phy_api_ops->phy_intr_mask_get = aquantia_phy_intr_mask_get;
	aquantia_phy_api_ops->phy_id_get = aquantia_phy_get_phy_id;
#endif
	aquantia_phy_api_ops->phy_interface_mode_set = aquantia_phy_interface_set_mode;
	aquantia_phy_api_ops->phy_interface_mode_status_get=aquantia_phy_interface_get_mode_status;
	aquantia_phy_api_ops->phy_get_status = aquantia_phy_get_status;
#ifndef IN_PORTCONTROL_MINI
	aquantia_phy_api_ops->phy_counter_show = aquantia_phy_show_counter;
#endif
	aquantia_phy_api_ops->phy_eee_adv_set = aquantia_phy_set_eee_adv;
	aquantia_phy_api_ops->phy_eee_adv_get = aquantia_phy_get_eee_adv;
	aquantia_phy_api_ops->phy_eee_partner_adv_get = aquantia_phy_get_eee_partner_adv;
	aquantia_phy_api_ops->phy_eee_cap_get = aquantia_phy_get_eee_cap;
	aquantia_phy_api_ops->phy_eee_status_get = aquantia_phy_get_eee_status;
	ret = hsl_phy_api_ops_register(AQUANTIA_PHY_CHIP, aquantia_phy_api_ops);
	if (ret == 0)
		SSDK_INFO("qca probe aquantia phy driver succeeded!\n");
	else
		SSDK_ERROR("qca probe aquantia phy driver failed! (code: %d)\n", ret);

	return ret;
}

/******************************************************************************
*
* aquantia_phy_init -
*
*/
int aquantia_phy_init(a_uint32_t dev_id, a_uint32_t port_bmp)
{
	static a_uint32_t phy_ops_flag = 0;

	if(phy_ops_flag == 0) {
		aquantia_phy_api_ops_init();
		phy_ops_flag = 1;
	}
	aquantia_phy_hw_init(dev_id, port_bmp);

	return 0;

}

