/*
 * Copyright (c) 2012, 2015-2019, The Linux Foundation. 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.
 */

/*qca808x_start*/
/**
 * @defgroup fal_port_ctrl FAL_PORT_CONTROL
 * @{
 */
#include "sw.h"
#include "fal_port_ctrl.h"
#include "hsl_api.h"
/*qca808x_end*/
#include "adpt.h"

#include <linux/kernel.h>
#include <linux/module.h>
/*qca808x_start*/
static sw_error_t
_fal_port_duplex_set (a_uint32_t dev_id, fal_port_t port_id,
		      fal_port_duplex_t duplex)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_duplex_set != NULL) {
        rv = p_adpt_api->adpt_port_duplex_set(dev_id, port_id, duplex);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_duplex_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_duplex_set (dev_id, port_id, duplex);
  return rv;
}

static sw_error_t
_fal_port_speed_set (a_uint32_t dev_id, fal_port_t port_id,
		     fal_port_speed_t speed)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_speed_set != NULL) {
        rv = p_adpt_api->adpt_port_speed_set(dev_id, port_id, speed);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_speed_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_speed_set (dev_id, port_id, speed);
  return rv;
}
/*qca808x_end*/
static sw_error_t
_fal_port_flowctrl_set (a_uint32_t dev_id, fal_port_t port_id,
			a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
        if (NULL == p_adpt_api->adpt_port_flowctrl_set)
            return SW_NOT_SUPPORTED;

        rv = p_adpt_api->adpt_port_flowctrl_set(dev_id, port_id, enable);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_flowctrl_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_flowctrl_set (dev_id, port_id, enable);
  return rv;
}

static sw_error_t
_fal_port_flowctrl_forcemode_set (a_uint32_t dev_id, fal_port_t port_id,
				  a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
  adpt_api_t *p_adpt_api;

  if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
    if (NULL == p_adpt_api->adpt_port_flowctrl_forcemode_set)
      return SW_NOT_SUPPORTED;

  rv = p_adpt_api->adpt_port_flowctrl_forcemode_set(dev_id, port_id, enable);
  return rv;
  }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_flowctrl_forcemode_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_flowctrl_forcemode_set (dev_id, port_id, enable);
  return rv;
}
/*qca808x_start*/
static sw_error_t
_fal_port_speed_get (a_uint32_t dev_id, fal_port_t port_id,
		     fal_port_speed_t * pspeed)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_speed_get != NULL) {
        rv = p_adpt_api->adpt_port_speed_get(dev_id, port_id, pspeed);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_speed_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_speed_get (dev_id, port_id, pspeed);
  return rv;
}

static sw_error_t
_fal_port_duplex_get (a_uint32_t dev_id, fal_port_t port_id,
		      fal_port_duplex_t * pduplex)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_duplex_get != NULL) {
        rv = p_adpt_api->adpt_port_duplex_get(dev_id, port_id, pduplex);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_duplex_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_duplex_get (dev_id, port_id, pduplex);
  return rv;
}

static sw_error_t
_fal_port_autoneg_enable (a_uint32_t dev_id, fal_port_t port_id)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_autoneg_enable != NULL) {
        rv = p_adpt_api->adpt_port_autoneg_enable(dev_id, port_id);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_autoneg_enable)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_autoneg_enable (dev_id, port_id);
  return rv;
}

static sw_error_t
_fal_port_autoneg_restart (a_uint32_t dev_id, fal_port_t port_id)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_autoneg_restart != NULL) {
        rv = p_adpt_api->adpt_port_autoneg_restart(dev_id, port_id);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_autoneg_restart)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_autoneg_restart (dev_id, port_id);
  return rv;
}


static sw_error_t
_fal_port_autoneg_adv_set (a_uint32_t dev_id, fal_port_t port_id,
			   a_uint32_t autoadv)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_autoneg_adv_set != NULL) {
        rv = p_adpt_api->adpt_port_autoneg_adv_set(dev_id, port_id, autoadv);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_autoneg_adv_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_autoneg_adv_set (dev_id, port_id, autoadv);
  return rv;
}

static sw_error_t
_fal_port_autoneg_status_get (a_uint32_t dev_id, fal_port_t port_id,
			      a_bool_t * status)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_autoneg_status_get != NULL) {
        rv = p_adpt_api->adpt_port_autoneg_status_get(dev_id, port_id, status);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_autoneg_status_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_autoneg_status_get (dev_id, port_id, status);
  return rv;
}

static sw_error_t
_fal_port_autoneg_adv_get (a_uint32_t dev_id, fal_port_t port_id,
			   a_uint32_t * autoadv)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_autoneg_adv_get != NULL) {
        rv = p_adpt_api->adpt_port_autoneg_adv_get(dev_id, port_id, autoadv);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_autoneg_adv_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_autoneg_adv_get (dev_id, port_id, autoadv);
  return rv;
}
/*qca808x_end*/
#ifndef IN_PORTCONTROL_MINI
static sw_error_t
_fal_port_hdr_status_set (a_uint32_t dev_id, fal_port_t port_id,
			  a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_hdr_status_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_hdr_status_set (dev_id, port_id, enable);
  return rv;
}


static sw_error_t
_fal_port_hdr_status_get (a_uint32_t dev_id, fal_port_t port_id,
			  a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_hdr_status_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_hdr_status_get (dev_id, port_id, enable);
  return rv;
}

static sw_error_t
_fal_port_flowctrl_get (a_uint32_t dev_id, fal_port_t port_id,
			a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
        if (NULL == p_adpt_api->adpt_port_flowctrl_get)
            return SW_NOT_SUPPORTED;

        rv = p_adpt_api->adpt_port_flowctrl_get(dev_id, port_id, enable);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_flowctrl_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_flowctrl_get (dev_id, port_id, enable);
  return rv;
}


static sw_error_t
_fal_port_flowctrl_forcemode_get (a_uint32_t dev_id, fal_port_t port_id,
				  a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
  adpt_api_t *p_adpt_api;

  if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
    if (NULL == p_adpt_api->adpt_port_flowctrl_forcemode_get)
      return SW_NOT_SUPPORTED;

  rv = p_adpt_api->adpt_port_flowctrl_forcemode_get(dev_id, port_id, enable);
  return rv;
  }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_flowctrl_forcemode_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_flowctrl_forcemode_get (dev_id, port_id, enable);
  return rv;
}

static sw_error_t
_fal_port_powersave_set (a_uint32_t dev_id, fal_port_t port_id,
			 a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_powersave_set != NULL) {
        rv = p_adpt_api->adpt_port_powersave_set(dev_id, port_id, enable);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_powersave_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_powersave_set (dev_id, port_id, enable);
  return rv;
}


static sw_error_t
_fal_port_powersave_get (a_uint32_t dev_id, fal_port_t port_id,
			 a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_powersave_get != NULL) {
        rv = p_adpt_api->adpt_port_powersave_get(dev_id, port_id, enable);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_powersave_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_powersave_get (dev_id, port_id, enable);
  return rv;
}
/*qca808x_start*/
static sw_error_t
_fal_port_hibernate_set (a_uint32_t dev_id, fal_port_t port_id,
			 a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_hibernate_set != NULL) {
        rv = p_adpt_api->adpt_port_hibernate_set(dev_id, port_id, enable);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_hibernate_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_hibernate_set (dev_id, port_id, enable);
  return rv;
}


static sw_error_t
_fal_port_hibernate_get (a_uint32_t dev_id, fal_port_t port_id,
			 a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_hibernate_get != NULL) {
        rv = p_adpt_api->adpt_port_hibernate_get(dev_id, port_id, enable);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_hibernate_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_hibernate_get (dev_id, port_id, enable);
  return rv;
}

static sw_error_t
_fal_port_cdt (a_uint32_t dev_id, fal_port_t port_id, a_uint32_t mdi_pair,
	       a_uint32_t * cable_status, a_uint32_t * cable_len)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_cdt != NULL) {
        rv = p_adpt_api->adpt_port_cdt(dev_id, port_id, mdi_pair, cable_status, cable_len);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_cdt)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_cdt (dev_id, port_id, mdi_pair, cable_status, cable_len);
  return rv;
}
/*qca808x_end*/
static sw_error_t
_fal_port_rxhdr_mode_get (a_uint32_t dev_id, fal_port_t port_id,
			  fal_port_header_mode_t * mode)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_rxhdr_mode_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_rxhdr_mode_get (dev_id, port_id, mode);
  return rv;
}
static sw_error_t
_fal_port_txhdr_mode_get (a_uint32_t dev_id, fal_port_t port_id,
			  fal_port_header_mode_t * mode)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_txhdr_mode_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_txhdr_mode_get (dev_id, port_id, mode);
  return rv;
}
static sw_error_t
_fal_header_type_get (a_uint32_t dev_id, a_bool_t * enable, a_uint32_t * type)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->header_type_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->header_type_get (dev_id, enable, type);
  return rv;
}
#endif
static sw_error_t
_fal_port_rxhdr_mode_set (a_uint32_t dev_id, fal_port_t port_id,
			  fal_port_header_mode_t mode)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_rxhdr_mode_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_rxhdr_mode_set (dev_id, port_id, mode);
  return rv;
}


static sw_error_t
_fal_port_txhdr_mode_set (a_uint32_t dev_id, fal_port_t port_id,
			  fal_port_header_mode_t mode)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_txhdr_mode_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_txhdr_mode_set (dev_id, port_id, mode);
  return rv;
}


static sw_error_t
_fal_header_type_set (a_uint32_t dev_id, a_bool_t enable, a_uint32_t type)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->header_type_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->header_type_set (dev_id, enable, type);
  return rv;
}


static sw_error_t
_fal_port_txmac_status_set (a_uint32_t dev_id, fal_port_t port_id,
			    a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
        if (NULL == p_adpt_api->adpt_port_txmac_status_set)
            return SW_NOT_SUPPORTED;

        rv = p_adpt_api->adpt_port_txmac_status_set(dev_id, port_id, enable);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_txmac_status_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_txmac_status_set (dev_id, port_id, enable);
  return rv;
}


static sw_error_t
_fal_port_rxmac_status_set (a_uint32_t dev_id, fal_port_t port_id,
			    a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
        if (NULL == p_adpt_api->adpt_port_rxmac_status_set)
            return SW_NOT_SUPPORTED;

        rv = p_adpt_api->adpt_port_rxmac_status_set(dev_id, port_id, enable);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_rxmac_status_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_rxmac_status_set (dev_id, port_id, enable);
  return rv;
}


static sw_error_t
_fal_port_txfc_status_set (a_uint32_t dev_id, fal_port_t port_id,
			   a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
        if (NULL == p_adpt_api->adpt_port_txfc_status_set)
            return SW_NOT_SUPPORTED;

        rv = p_adpt_api->adpt_port_txfc_status_set(dev_id, port_id, enable);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_txfc_status_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_txfc_status_set (dev_id, port_id, enable);
  return rv;
}


static sw_error_t
_fal_port_rxfc_status_set (a_uint32_t dev_id, fal_port_t port_id,
			   a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
        if (NULL == p_adpt_api->adpt_port_rxfc_status_set)
            return SW_NOT_SUPPORTED;

        rv = p_adpt_api->adpt_port_rxfc_status_set(dev_id, port_id, enable);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_rxfc_status_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_rxfc_status_set (dev_id, port_id, enable);
  return rv;
}
static sw_error_t
_fal_port_txfc_status_get (a_uint32_t dev_id, fal_port_t port_id,
			   a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
        if (NULL == p_adpt_api->adpt_port_txfc_status_get)
            return SW_NOT_SUPPORTED;

        rv = p_adpt_api->adpt_port_txfc_status_get(dev_id, port_id, enable);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_txfc_status_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_txfc_status_get (dev_id, port_id, enable);
  return rv;
}
static sw_error_t
_fal_port_rxfc_status_get (a_uint32_t dev_id, fal_port_t port_id,
			   a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
        if (NULL == p_adpt_api->adpt_port_rxfc_status_get)
            return SW_NOT_SUPPORTED;

        rv = p_adpt_api->adpt_port_rxfc_status_get(dev_id, port_id, enable);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_rxfc_status_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_rxfc_status_get (dev_id, port_id, enable);
  return rv;
}
/*qca808x_start*/
static sw_error_t
_fal_port_link_status_get (a_uint32_t dev_id, fal_port_t port_id,
			   a_bool_t * status)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_link_status_get != NULL) {
        rv = p_adpt_api->adpt_port_link_status_get(dev_id, port_id, status);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_link_status_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_link_status_get (dev_id, port_id, status);
  return rv;
}

static sw_error_t
_fal_port_power_off (a_uint32_t dev_id, fal_port_t port_id)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_power_off != NULL) {
        rv = p_adpt_api->adpt_port_power_off(dev_id, port_id);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_power_off)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_power_off (dev_id, port_id);
  return rv;
}

static sw_error_t
_fal_port_power_on (a_uint32_t dev_id, fal_port_t port_id)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_power_on != NULL) {
        rv = p_adpt_api->adpt_port_power_on(dev_id, port_id);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_power_on)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_power_on (dev_id, port_id);
  return rv;
}
/*qca808x_end*/
static sw_error_t
_fal_port_link_forcemode_set (a_uint32_t dev_id, fal_port_t port_id,
			      a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_link_forcemode_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_link_forcemode_set (dev_id, port_id, enable);
  return rv;
}

static sw_error_t
_fal_port_link_forcemode_get (a_uint32_t dev_id, fal_port_t port_id,
			      a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_link_forcemode_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_link_forcemode_get (dev_id, port_id, enable);
  return rv;
}
#ifndef IN_PORTCONTROL_MINI
static sw_error_t
_fal_port_txmac_status_get (a_uint32_t dev_id, fal_port_t port_id,
			    a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
        if (NULL == p_adpt_api->adpt_port_txmac_status_get)
            return SW_NOT_SUPPORTED;

        rv = p_adpt_api->adpt_port_txmac_status_get(dev_id, port_id, enable);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_txmac_status_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_txmac_status_get (dev_id, port_id, enable);
  return rv;
}
static sw_error_t
_fal_port_rxmac_status_get (a_uint32_t dev_id, fal_port_t port_id,
			    a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
        if (NULL == p_adpt_api->adpt_port_rxmac_status_get)
            return SW_NOT_SUPPORTED;

        rv = p_adpt_api->adpt_port_rxmac_status_get(dev_id, port_id, enable);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_rxmac_status_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_rxmac_status_get (dev_id, port_id, enable);
  return rv;
}

static sw_error_t
_fal_port_bp_status_set (a_uint32_t dev_id, fal_port_t port_id,
			 a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_bp_status_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_bp_status_set (dev_id, port_id, enable);
  return rv;
}

static sw_error_t
_fal_port_bp_status_get (a_uint32_t dev_id, fal_port_t port_id,
			 a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_bp_status_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_bp_status_get (dev_id, port_id, enable);
  return rv;
}

static sw_error_t
_fal_ports_link_status_get (a_uint32_t dev_id, a_uint32_t * status)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_ports_link_status_get != NULL) {
        rv = p_adpt_api->adpt_ports_link_status_get(dev_id, status);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->ports_link_status_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->ports_link_status_get (dev_id, status);
  return rv;
}

static sw_error_t
_fal_port_mac_loopback_set (a_uint32_t dev_id, fal_port_t port_id,
			    a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
        if (NULL == p_adpt_api->adpt_port_mac_loopback_set)
            return SW_NOT_SUPPORTED;

        rv = p_adpt_api->adpt_port_mac_loopback_set(dev_id, port_id, enable);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_mac_loopback_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_mac_loopback_set (dev_id, port_id, enable);
  return rv;
}

static sw_error_t
_fal_port_mac_loopback_get (a_uint32_t dev_id, fal_port_t port_id,
			    a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
        if (NULL == p_adpt_api->adpt_port_mac_loopback_get)
            return SW_NOT_SUPPORTED;

        rv = p_adpt_api->adpt_port_mac_loopback_get(dev_id, port_id, enable);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_mac_loopback_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_mac_loopback_get (dev_id, port_id, enable);
  return rv;
}

static sw_error_t
_fal_port_congestion_drop_set (a_uint32_t dev_id, fal_port_t port_id,
			       a_uint32_t queue_id, a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_congestion_drop_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_congestion_drop_set (dev_id, port_id, queue_id, enable);
  return rv;
}

static sw_error_t
_fal_port_congestion_drop_get (a_uint32_t dev_id, fal_port_t port_id,
			       a_uint32_t queue_id, a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_congestion_drop_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_congestion_drop_get (dev_id, port_id, queue_id, enable);
  return rv;
}

static sw_error_t
_fal_ring_flow_ctrl_thres_set (a_uint32_t dev_id, a_uint32_t ring_id,
			       a_uint8_t on_thres, a_uint8_t off_thres)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->ring_flow_ctrl_thres_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->ring_flow_ctrl_thres_set (dev_id, ring_id, on_thres, off_thres);
  return rv;
}

static sw_error_t
_fal_ring_flow_ctrl_thres_get (a_uint32_t dev_id, a_uint32_t ring_id,
			       a_uint8_t * on_thres, a_uint8_t * off_thres)
{
  sw_error_t rv;
  hsl_api_t *p_api;

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->ring_flow_ctrl_thres_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->ring_flow_ctrl_thres_get (dev_id, ring_id, on_thres, off_thres);
  return rv;
}
/*qca808x_start*/
static sw_error_t
_fal_port_8023az_set (a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_8023az_set != NULL) {
        rv = p_adpt_api->adpt_port_8023az_set(dev_id, port_id, enable);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_8023az_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_8023az_set (dev_id, port_id, enable);
  return rv;
}


static sw_error_t
_fal_port_8023az_get (a_uint32_t dev_id, fal_port_t port_id,
		      a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_8023az_get != NULL) {
        rv = p_adpt_api->adpt_port_8023az_get(dev_id, port_id, enable);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_8023az_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_8023az_get (dev_id, port_id, enable);
  return rv;
}

static sw_error_t
_fal_port_mdix_set (a_uint32_t dev_id, fal_port_t port_id,
		    fal_port_mdix_mode_t mode)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_mdix_set != NULL) {
        rv = p_adpt_api->adpt_port_mdix_set(dev_id, port_id, mode);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_mdix_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_mdix_set (dev_id, port_id, mode);
  return rv;
}

static sw_error_t
_fal_port_mdix_get (a_uint32_t dev_id, fal_port_t port_id,
		    fal_port_mdix_mode_t * mode)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_mdix_get != NULL) {
        rv = p_adpt_api->adpt_port_mdix_get(dev_id, port_id, mode);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_mdix_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_mdix_get (dev_id, port_id, mode);
  return rv;
}

static sw_error_t
_fal_port_mdix_status_get (a_uint32_t dev_id, fal_port_t port_id,
			   fal_port_mdix_status_t * mode)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_mdix_status_get != NULL) {
        rv = p_adpt_api->adpt_port_mdix_status_get(dev_id, port_id, mode);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_mdix_status_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_mdix_status_get (dev_id, port_id, mode);
  return rv;
}
/*qca808x_end*/
static sw_error_t
_fal_port_combo_prefer_medium_set (a_uint32_t dev_id, fal_port_t port_id,
				   fal_port_medium_t medium)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_combo_prefer_medium_set != NULL) {
        rv = p_adpt_api->adpt_port_combo_prefer_medium_set(dev_id, port_id, medium);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_combo_prefer_medium_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_combo_prefer_medium_set (dev_id, port_id, medium);
  return rv;
}

static sw_error_t
_fal_port_combo_prefer_medium_get (a_uint32_t dev_id, fal_port_t port_id,
				   fal_port_medium_t * medium)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_combo_prefer_medium_get != NULL) {
        rv = p_adpt_api->adpt_port_combo_prefer_medium_get(dev_id, port_id, medium);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_combo_prefer_medium_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_combo_prefer_medium_get (dev_id, port_id, medium);
  return rv;
}

static sw_error_t
_fal_port_combo_medium_status_get (a_uint32_t dev_id, fal_port_t port_id,
				   fal_port_medium_t * medium)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_combo_medium_status_get != NULL) {
        rv = p_adpt_api->adpt_port_combo_medium_status_get(dev_id, port_id, medium);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_combo_medium_status_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_combo_medium_status_get (dev_id, port_id, medium);
  return rv;
}

static sw_error_t
_fal_port_combo_fiber_mode_set (a_uint32_t dev_id, fal_port_t port_id,
				fal_port_fiber_mode_t mode)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_combo_fiber_mode_set != NULL) {
        rv = p_adpt_api->adpt_port_combo_fiber_mode_set(dev_id, port_id, mode);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_combo_fiber_mode_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_combo_fiber_mode_set (dev_id, port_id, mode);
  return rv;
}

static sw_error_t
_fal_port_combo_fiber_mode_get (a_uint32_t dev_id, fal_port_t port_id,
				fal_port_fiber_mode_t * mode)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_combo_fiber_mode_get != NULL) {
        rv = p_adpt_api->adpt_port_combo_fiber_mode_get(dev_id, port_id, mode);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_combo_fiber_mode_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_combo_fiber_mode_get (dev_id, port_id, mode);
  return rv;
}
/*qca808x_start*/
static sw_error_t
_fal_port_local_loopback_set (a_uint32_t dev_id, fal_port_t port_id,
			      a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_local_loopback_set != NULL) {
        rv = p_adpt_api->adpt_port_local_loopback_set(dev_id, port_id, enable);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_local_loopback_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_local_loopback_set (dev_id, port_id, enable);
  return rv;
}


static sw_error_t
_fal_port_local_loopback_get (a_uint32_t dev_id, fal_port_t port_id,
			      a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_local_loopback_get != NULL) {
        rv = p_adpt_api->adpt_port_local_loopback_get(dev_id, port_id, enable);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_local_loopback_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_local_loopback_get (dev_id, port_id, enable);
  return rv;
}

static sw_error_t
_fal_port_remote_loopback_set (a_uint32_t dev_id, fal_port_t port_id,
			       a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_remote_loopback_set != NULL) {
        rv = p_adpt_api->adpt_port_remote_loopback_set(dev_id, port_id, enable);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_remote_loopback_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_remote_loopback_set (dev_id, port_id, enable);
  return rv;
}


static sw_error_t
_fal_port_remote_loopback_get (a_uint32_t dev_id, fal_port_t port_id,
			       a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_remote_loopback_get!= NULL) {
        rv = p_adpt_api->adpt_port_remote_loopback_get(dev_id, port_id, enable);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_remote_loopback_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_remote_loopback_get (dev_id, port_id, enable);
  return rv;
}

static sw_error_t
_fal_port_reset (a_uint32_t dev_id, fal_port_t port_id)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_reset != NULL) {
        rv = p_adpt_api->adpt_port_reset(dev_id, port_id);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_reset)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_reset (dev_id, port_id);
  return rv;
}


static sw_error_t
_fal_port_phy_id_get (a_uint32_t dev_id, fal_port_t port_id,a_uint16_t * org_id, a_uint16_t * rev_id)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_phy_id_get != NULL) {
        rv = p_adpt_api->adpt_port_phy_id_get(dev_id, port_id, org_id, rev_id);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_phy_id_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_phy_id_get (dev_id, port_id,org_id,rev_id);
  return rv;
}

static sw_error_t
_fal_port_wol_status_set (a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_wol_status_set != NULL) {
        rv = p_adpt_api->adpt_port_wol_status_set(dev_id, port_id, enable);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_wol_status_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_wol_status_set (dev_id, port_id,enable);
  return rv;
}

static sw_error_t
_fal_port_wol_status_get (a_uint32_t dev_id, fal_port_t port_id, a_bool_t *enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_wol_status_get != NULL) {
        rv = p_adpt_api->adpt_port_wol_status_get(dev_id, port_id, enable);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_wol_status_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_wol_status_get (dev_id, port_id,enable);
  return rv;
}

static sw_error_t
_fal_port_magic_frame_mac_set (a_uint32_t dev_id, fal_port_t port_id, fal_mac_addr_t * mac)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_magic_frame_mac_set != NULL) {
        rv = p_adpt_api->adpt_port_magic_frame_mac_set(dev_id, port_id, mac);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_magic_frame_mac_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_magic_frame_mac_set (dev_id, port_id, mac);
  return rv;
}

static sw_error_t
_fal_port_magic_frame_mac_get (a_uint32_t dev_id, fal_port_t port_id, fal_mac_addr_t * mac)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_magic_frame_mac_get != NULL) {
        rv = p_adpt_api->adpt_port_magic_frame_mac_get(dev_id, port_id, mac);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_magic_frame_mac_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_magic_frame_mac_get (dev_id, port_id, mac);
  return rv;
}
/*qca808x_end*/
static sw_error_t
_fal_port_interface_mode_set (a_uint32_t dev_id, fal_port_t port_id, fal_port_interface_mode_t  mode)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;
    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_interface_mode_set != NULL) {
        rv = p_adpt_api->adpt_port_interface_mode_set(dev_id, port_id, mode);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_interface_mode_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_interface_mode_set (dev_id, port_id, mode);
  return rv;
}

static sw_error_t
_fal_port_interface_mode_get (a_uint32_t dev_id, fal_port_t port_id, fal_port_interface_mode_t * mode)
{
  sw_error_t rv;
  hsl_api_t *p_api;
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_interface_mode_get != NULL) {
        rv = p_adpt_api->adpt_port_interface_mode_get(dev_id, port_id, mode);
        return rv;
    }

  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_interface_mode_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_interface_mode_get (dev_id, port_id, mode);
  return rv;
}
/*qca808x_start*/
static sw_error_t
_fal_port_interface_mode_status_get (a_uint32_t dev_id, fal_port_t port_id, fal_port_interface_mode_t * mode)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_interface_mode_status_get != NULL) {
        rv = p_adpt_api->adpt_port_interface_mode_status_get(dev_id, port_id, mode);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_interface_mode_status_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_interface_mode_status_get (dev_id, port_id, mode);
  return rv;
}

static sw_error_t
_fal_port_counter_set (a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_counter_set != NULL) {
        rv = p_adpt_api->adpt_port_counter_set(dev_id, port_id, enable);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_counter_set)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_counter_set (dev_id, port_id, enable);
  return rv;
}


static sw_error_t
_fal_port_counter_get (a_uint32_t dev_id, fal_port_t port_id,
		      a_bool_t * enable)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_counter_get != NULL) {
        rv = p_adpt_api->adpt_port_counter_get(dev_id, port_id, enable);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_counter_get)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_counter_get (dev_id, port_id, enable);
  return rv;
}

static sw_error_t
_fal_port_counter_show (a_uint32_t dev_id, fal_port_t port_id, fal_port_counter_info_t * counter_info)
{
  sw_error_t rv;
  hsl_api_t *p_api;
/*qca808x_end*/
    adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL &&
        p_adpt_api->adpt_port_counter_show != NULL) {
        rv = p_adpt_api->adpt_port_counter_show(dev_id, port_id, counter_info);
        return rv;
    }
/*qca808x_start*/
  SW_RTN_ON_NULL (p_api = hsl_api_ptr_get (dev_id));

  if (NULL == p_api->port_counter_show)
    return SW_NOT_SUPPORTED;

  rv = p_api->port_counter_show (dev_id, port_id, counter_info);
  return rv;
}
/*qca808x_end*/
#endif

sw_error_t
_fal_port_max_frame_size_set(a_uint32_t dev_id, fal_port_t port_id,
		a_uint32_t max_frame)
{
    adpt_api_t *p_api;
	sw_error_t rv = SW_OK;

    SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

    if (NULL == p_api->adpt_port_max_frame_size_set)
        return SW_NOT_SUPPORTED;

    rv = p_api->adpt_port_max_frame_size_set(dev_id, port_id, max_frame);
    return rv;
}

sw_error_t
_fal_port_max_frame_size_get(a_uint32_t dev_id, fal_port_t port_id,
		a_uint32_t *max_frame)
{
	adpt_api_t *p_api;
	sw_error_t rv = SW_OK;

	SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

	if (NULL == p_api->adpt_port_max_frame_size_get)
		return SW_NOT_SUPPORTED;

	rv = p_api->adpt_port_max_frame_size_get(dev_id, port_id, max_frame);
	return rv;
}

#ifndef IN_PORTCONTROL_MINI
sw_error_t
_fal_port_mru_set(a_uint32_t dev_id, fal_port_t port_id,
		fal_mru_ctrl_t *ctrl)
{
    adpt_api_t *p_api;
	sw_error_t rv = SW_OK;

    SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

    if (NULL == p_api->adpt_port_mru_set)
        return SW_NOT_SUPPORTED;

    rv = p_api->adpt_port_mru_set(dev_id, port_id, ctrl);
    return rv;
}
sw_error_t
_fal_port_mru_get(a_uint32_t dev_id, fal_port_t port_id,
		fal_mru_ctrl_t *ctrl)
{
    adpt_api_t *p_api;
	sw_error_t rv = SW_OK;

    SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

    if (NULL == p_api->adpt_port_mru_get)
        return SW_NOT_SUPPORTED;

    rv = p_api->adpt_port_mru_get(dev_id, port_id, ctrl);
    return rv;
}
sw_error_t
_fal_port_mtu_set(a_uint32_t dev_id, fal_port_t port_id,
		fal_mtu_ctrl_t *ctrl)
{
    adpt_api_t *p_api;
	sw_error_t rv = SW_OK;

    SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

    if (NULL == p_api->adpt_port_mtu_set)
        return SW_NOT_SUPPORTED;

    rv = p_api->adpt_port_mtu_set(dev_id, port_id, ctrl);
    return rv;
}

sw_error_t
_fal_port_mtu_get(a_uint32_t dev_id, fal_port_t port_id,
		fal_mtu_ctrl_t *ctrl)
{
    adpt_api_t *p_api;
	sw_error_t rv = SW_OK;

    SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

    if (NULL == p_api->adpt_port_mtu_get)
        return SW_NOT_SUPPORTED;

    rv = p_api->adpt_port_mtu_get(dev_id, port_id, ctrl);
    return rv;
}

sw_error_t
_fal_port_source_filter_get(a_uint32_t dev_id,
		fal_port_t port_id, a_bool_t * enable)
{
    adpt_api_t *p_api;
    sw_error_t rv = SW_OK;

    SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

    if (NULL == p_api->adpt_port_source_filter_get)
        return SW_NOT_SUPPORTED;

    rv = p_api->adpt_port_source_filter_get(dev_id, port_id, enable);
    return rv;
}

sw_error_t
_fal_port_source_filter_set(a_uint32_t dev_id,
		fal_port_t port_id, a_bool_t enable)
{
    adpt_api_t *p_api;
    sw_error_t rv = SW_OK;

    SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

    if (NULL == p_api->adpt_port_source_filter_set)
        return SW_NOT_SUPPORTED;

    rv = p_api->adpt_port_source_filter_set(dev_id, port_id, enable);
    return rv;
}

static sw_error_t
_fal_port_source_filter_config_set(a_uint32_t dev_id,
	fal_port_t port_id, fal_src_filter_config_t *src_filter_config)
{
	adpt_api_t *p_api;
	sw_error_t rv = SW_OK;

	SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

	if (NULL == p_api->adpt_port_source_filter_config_set)
		return SW_NOT_SUPPORTED;

	rv = p_api->adpt_port_source_filter_config_set(dev_id, port_id,
			src_filter_config);
	return rv;
}

static sw_error_t
_fal_port_source_filter_config_get(a_uint32_t dev_id,
	fal_port_t port_id, fal_src_filter_config_t *src_filter_config)
{
	adpt_api_t *p_api;
	sw_error_t rv = SW_OK;

	SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

	if (NULL == p_api->adpt_port_source_filter_config_get)
		return SW_NOT_SUPPORTED;

	rv = p_api->adpt_port_source_filter_config_get(dev_id, port_id,
			src_filter_config);
	return rv;
}

static sw_error_t
_fal_port_interface_3az_status_set(a_uint32_t dev_id, fal_port_t port_id,
		a_bool_t enable)
{

	adpt_api_t *p_api;
	sw_error_t rv = SW_OK;

	SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

	if (NULL == p_api->adpt_port_interface_3az_status_set)
		return SW_NOT_SUPPORTED;

	rv = p_api->adpt_port_interface_3az_status_set(dev_id, port_id, enable);
	return rv;

}

static sw_error_t
_fal_port_interface_3az_status_get(a_uint32_t dev_id, fal_port_t port_id,
		a_bool_t * enable)
{
	adpt_api_t *p_api;
	sw_error_t rv = SW_OK;

	SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

	if (NULL == p_api->adpt_port_interface_3az_status_get)
		return SW_NOT_SUPPORTED;

	rv = p_api->adpt_port_interface_3az_status_get(dev_id, port_id, enable);
	return rv;

}

static sw_error_t
_fal_port_promisc_mode_get(a_uint32_t dev_id, fal_port_t port_id, a_bool_t *enable)
{
	sw_error_t rv = SW_OK;
	adpt_api_t *p_adpt_api;

	if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
		if (NULL == p_adpt_api->adpt_port_promisc_mode_get) {
			return SW_NOT_SUPPORTED;
		}

		rv = p_adpt_api->adpt_port_promisc_mode_get(dev_id, port_id, enable);
		return rv;
	}

	return rv;
}
#endif

static sw_error_t
_fal_port_promisc_mode_set(a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable)
{
	sw_error_t rv = SW_OK;
	adpt_api_t *p_adpt_api;

	if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
		if (NULL == p_adpt_api->adpt_port_promisc_mode_set) {
			return SW_NOT_SUPPORTED;
		}

		rv = p_adpt_api->adpt_port_promisc_mode_set(dev_id, port_id, enable);
		return rv;
	}

	return rv;
}

static sw_error_t
_fal_port_interface_eee_cfg_set(a_uint32_t dev_id, fal_port_t port_id,
	fal_port_eee_cfg_t *port_eee_cfg)
{

	adpt_api_t *p_api;
	sw_error_t rv = SW_OK;

	SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

	if (NULL == p_api->adpt_port_interface_eee_cfg_set)
		return SW_NOT_SUPPORTED;

	rv = p_api->adpt_port_interface_eee_cfg_set(dev_id, port_id, port_eee_cfg);
	return rv;

}

static sw_error_t
_fal_port_interface_eee_cfg_get(a_uint32_t dev_id, fal_port_t port_id,
	fal_port_eee_cfg_t *port_eee_cfg)
{
	adpt_api_t *p_api;
	sw_error_t rv = SW_OK;

	SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

	if (NULL == p_api->adpt_port_interface_eee_cfg_get)
		return SW_NOT_SUPPORTED;

	rv = p_api->adpt_port_interface_eee_cfg_get(dev_id, port_id, port_eee_cfg);
	return rv;

}
static sw_error_t
_fal_switch_port_loopback_set(a_uint32_t dev_id, fal_port_t port_id,
	fal_loopback_config_t *loopback_cfg)
{

	adpt_api_t *p_api;
	sw_error_t rv = SW_OK;

	SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));

	if (NULL == p_api->adpt_switch_port_loopback_set)
		return SW_NOT_SUPPORTED;

	rv = p_api->adpt_switch_port_loopback_set(dev_id, port_id, loopback_cfg);
	return rv;

}

static sw_error_t
_fal_switch_port_loopback_get(a_uint32_t dev_id, fal_port_t port_id,
	fal_loopback_config_t *loopback_cfg)
{
	adpt_api_t *p_api;
	sw_error_t rv = SW_OK;

	SW_RTN_ON_NULL(p_api = adpt_api_ptr_get(dev_id));
	if (NULL == p_api->adpt_switch_port_loopback_get)
		return SW_NOT_SUPPORTED;

	rv = p_api->adpt_switch_port_loopback_get(dev_id, port_id, loopback_cfg);
	return rv;

}

/*qca808x_start*/
/*insert flag for inner fal, don't remove it*/
/**
 * @brief Set duplex mode on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] duplex duplex mode
 * @return SW_OK or error code
 */
sw_error_t
fal_port_duplex_set (a_uint32_t dev_id, fal_port_t port_id,
		     fal_port_duplex_t duplex)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_duplex_set (dev_id, port_id, duplex);
  FAL_API_UNLOCK;
  return rv;
}


/**
 * @brief Set speed on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] speed port speed
 * @return SW_OK or error code
 */
sw_error_t
fal_port_speed_set (a_uint32_t dev_id, fal_port_t port_id,
		    fal_port_speed_t speed)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_speed_set (dev_id, port_id, speed);
  FAL_API_UNLOCK;
  return rv;
}
/**
 * @brief Get duplex mode on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] duplex duplex mode
 * @return SW_OK or error code
 */
sw_error_t
fal_port_duplex_get (a_uint32_t dev_id, fal_port_t port_id,
		     fal_port_duplex_t * pduplex)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_duplex_get (dev_id, port_id, pduplex);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get speed on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] speed port speed
 * @return SW_OK or error code
 */
sw_error_t
fal_port_speed_get (a_uint32_t dev_id, fal_port_t port_id,
		    fal_port_speed_t * pspeed)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_speed_get (dev_id, port_id, pspeed);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Enable auto negotiation status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @return SW_OK or error code
 */
sw_error_t
fal_port_autoneg_enable (a_uint32_t dev_id, fal_port_t port_id)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_autoneg_enable (dev_id, port_id);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Restart auto negotiation procedule on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @return SW_OK or error code
 */
sw_error_t
fal_port_autoneg_restart (a_uint32_t dev_id, fal_port_t port_id)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_autoneg_restart (dev_id, port_id);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Set auto negotiation advtisement ability on a particular port.
 *   @details  Comments:
 *   auto negotiation advtisement ability is defined by macro such as
 *   FAL_PHY_ADV_10T_HD, FAL_PHY_ADV_PAUSE...
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] autoadv auto negotiation advtisement ability bit map
 * @return SW_OK or error code
 */
sw_error_t
fal_port_autoneg_adv_set (a_uint32_t dev_id, fal_port_t port_id,
			  a_uint32_t autoadv)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_autoneg_adv_set (dev_id, port_id, autoadv);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get auto negotiation status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] status A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_autoneg_status_get (a_uint32_t dev_id, fal_port_t port_id,
			     a_bool_t * status)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_autoneg_status_get (dev_id, port_id, status);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get auto negotiation advtisement ability on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] autoadv auto negotiation advtisement ability bit map
 * @return SW_OK or error code
 */
sw_error_t
fal_port_autoneg_adv_get (a_uint32_t dev_id, fal_port_t port_id,
			  a_uint32_t * autoadv)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_autoneg_adv_get (dev_id, port_id, autoadv);
  FAL_API_UNLOCK;
  return rv;
}
/*qca808x_end*/
#ifndef IN_PORTCONTROL_MINI
/**
 * @brief Set status of Atheros header packets parsed on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_hdr_status_set (a_uint32_t dev_id, fal_port_t port_id,
			 a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_hdr_status_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get status of Atheros header packets parsed on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_hdr_status_get (a_uint32_t dev_id, fal_port_t port_id,
			 a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_hdr_status_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}


/**
 * @brief Get flow control status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_flowctrl_get (a_uint32_t dev_id, fal_port_t port_id,
		       a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_flowctrl_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}


/**
 * @brief Get flow control force mode on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_flowctrl_forcemode_get (a_uint32_t dev_id, fal_port_t port_id,
				 a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_flowctrl_forcemode_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Set powersaving status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_powersave_set (a_uint32_t dev_id, fal_port_t port_id,
			a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_powersave_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get powersaving status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_powersave_get (a_uint32_t dev_id, fal_port_t port_id,
			a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_powersave_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}
/*qca808x_start*/
/**
 * @brief Set hibernate status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_hibernate_set (a_uint32_t dev_id, fal_port_t port_id,
			a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_hibernate_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get hibernate status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_hibernate_get (a_uint32_t dev_id, fal_port_t port_id,
			a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_hibernate_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief cable diagnostic test.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] mdi_pair mdi pair id
 * @param[out] cable_status cable status
 * @param[out] cable_len cable len
 * @return SW_OK or error code
 */
sw_error_t
fal_port_cdt (a_uint32_t dev_id, fal_port_t port_id, a_uint32_t mdi_pair,
	      a_uint32_t * cable_status, a_uint32_t * cable_len)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_cdt (dev_id, port_id, mdi_pair, cable_status, cable_len);
  FAL_API_UNLOCK;
  return rv;
}
/*qca808x_end*/
/**
 * @brief Get status of Atheros header packets parsed on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_rxhdr_mode_get (a_uint32_t dev_id, fal_port_t port_id,
			 fal_port_header_mode_t * mode)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_rxhdr_mode_get (dev_id, port_id, mode);
  FAL_API_UNLOCK;
  return rv;
}
/**
 * @brief Get status of Atheros header packets parsed on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_txhdr_mode_get (a_uint32_t dev_id, fal_port_t port_id,
			 fal_port_header_mode_t * mode)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_txhdr_mode_get (dev_id, port_id, mode);
  FAL_API_UNLOCK;
  return rv;
}
/**
 * @brief Get status of Atheros header type value on a particular device.
 * @param[in] dev_id device id
 * @param[out] enable A_TRUE or A_FALSE
 * @param[out] type header type value
 * @return SW_OK or error code
 */
sw_error_t
fal_header_type_get (a_uint32_t dev_id, a_bool_t * enable, a_uint32_t * type)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_header_type_get (dev_id, enable, type);
  FAL_API_UNLOCK;
  return rv;
}
/**
 * @brief Get status of txmac on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_txmac_status_get (a_uint32_t dev_id, fal_port_t port_id,
			   a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_txmac_status_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}
/**
 * @brief Get status of rxmac on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_rxmac_status_get (a_uint32_t dev_id, fal_port_t port_id,
			   a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_rxmac_status_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}
#endif
/**
 * @brief Set flow control status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_flowctrl_set (a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_flowctrl_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Set flow control force mode on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_flowctrl_forcemode_set (a_uint32_t dev_id, fal_port_t port_id,
				 a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_flowctrl_forcemode_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Set status of Atheros header packets parsed on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_rxhdr_mode_set (a_uint32_t dev_id, fal_port_t port_id,
			 fal_port_header_mode_t mode)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_rxhdr_mode_set (dev_id, port_id, mode);
  FAL_API_UNLOCK;
  return rv;
}


/**
 * @brief Set status of Atheros header packets parsed on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_txhdr_mode_set (a_uint32_t dev_id, fal_port_t port_id,
			 fal_port_header_mode_t mode)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_txhdr_mode_set (dev_id, port_id, mode);
  FAL_API_UNLOCK;
  return rv;
}


/**
 * @brief Set status of Atheros header type value on a particular device.
 * @param[in] dev_id device id
 * @param[in] enable A_TRUE or A_FALSE
 * @param[in] type header type value
 * @return SW_OK or error code
 */
sw_error_t
fal_header_type_set (a_uint32_t dev_id, a_bool_t enable, a_uint32_t type)
{
  sw_error_t rv;
  FAL_API_LOCK;
  rv = _fal_header_type_set (dev_id, enable, type);
  FAL_API_UNLOCK;
  return rv;
}


/**
 * @brief Set status of txmac on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_txmac_status_set (a_uint32_t dev_id, fal_port_t port_id,
			   a_bool_t enable)
{
  sw_error_t rv;
  FAL_API_LOCK;
  rv = _fal_port_txmac_status_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}


/**
 * @brief Set status of rxmac on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_rxmac_status_set (a_uint32_t dev_id, fal_port_t port_id,
			   a_bool_t enable)
{
  sw_error_t rv;
  FAL_API_LOCK;
  rv = _fal_port_rxmac_status_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}


/**
 * @brief Set status of tx flow control on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_txfc_status_set (a_uint32_t dev_id, fal_port_t port_id,
			  a_bool_t enable)
{
  sw_error_t rv;
  FAL_API_LOCK;
  rv = _fal_port_txfc_status_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}


/**
 * @brief Set status of rx flow control on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_rxfc_status_set (a_uint32_t dev_id, fal_port_t port_id,
			  a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_rxfc_status_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}
/**
 * @brief Set status of rx flow control on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_rxfc_status_get (a_uint32_t dev_id, fal_port_t port_id,
			  a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_rxfc_status_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}
/**
 * @brief Get status of tx flow control on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_txfc_status_get (a_uint32_t dev_id, fal_port_t port_id,
			  a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_txfc_status_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}
/*qca808x_start*/
/**
 * @brief Get link status on particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] status link status up (A_TRUE) or down (A_FALSE)
 * @return SW_OK or error code
 */
sw_error_t
fal_port_link_status_get (a_uint32_t dev_id, fal_port_t port_id,
			  a_bool_t * status)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_link_status_get (dev_id, port_id, status);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief power off on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_power_off (a_uint32_t dev_id, fal_port_t port_id)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_power_off (dev_id, port_id);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief power on on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_power_on (a_uint32_t dev_id, fal_port_t port_id)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_power_on (dev_id, port_id);
  FAL_API_UNLOCK;
  return rv;
}
/*qca808x_end*/
/**
 * @brief Set link force mode on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_link_forcemode_set (a_uint32_t dev_id, fal_port_t port_id,
			     a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_link_forcemode_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get link force mode on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_link_forcemode_get (a_uint32_t dev_id, fal_port_t port_id,
			     a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_link_forcemode_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}
#ifndef IN_PORTCONTROL_MINI
/**
 * @brief Set status of back pressure on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_bp_status_set (a_uint32_t dev_id, fal_port_t port_id,
			a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_bp_status_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Set status of back pressure on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_bp_status_get (a_uint32_t dev_id, fal_port_t port_id,
			a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_bp_status_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get link status on all ports.
 * @param[in] dev_id device id
 * @param[out] status link status bitmap and bit 0 for port 0, bit 1 for port 1, ...etc.
 * @return SW_OK or error code
 */
sw_error_t
fal_ports_link_status_get (a_uint32_t dev_id, a_uint32_t * status)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_ports_link_status_get (dev_id, status);
  FAL_API_UNLOCK;
  return rv;
}


/**
 * @brief Set loopback on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_mac_loopback_set (a_uint32_t dev_id, fal_port_t port_id,
			   a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_mac_loopback_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get link force mode on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_mac_loopback_get (a_uint32_t dev_id, fal_port_t port_id,
			   a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_mac_loopback_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Set congestion drop on a particular port queue.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_congestion_drop_set (a_uint32_t dev_id, fal_port_t port_id,
			      a_uint32_t queue_id, a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_congestion_drop_set (dev_id, port_id, queue_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get congestion drop on a particular port queue.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] queue_id queue_id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_congestion_drop_get (a_uint32_t dev_id, fal_port_t port_id,
			      a_uint32_t queue_id, a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_congestion_drop_get (dev_id, port_id, queue_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Set flow control threshold on a DMA ring.
 * @param[in] dev_id device id
 * @param[in] ring_id ring_id
 * @param[in] on_thres on_thres
 * @param[in] off_thres on_thres
 * @return SW_OK or error code
 */
sw_error_t
fal_ring_flow_ctrl_thres_set (a_uint32_t dev_id, a_uint32_t ring_id,
			      a_uint8_t on_thres, a_uint8_t off_thres)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_ring_flow_ctrl_thres_set (dev_id, ring_id, on_thres, off_thres);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get flow control threshold on a DMA ring.
 * @param[in] dev_id device id
 * @param[in] ring_id ring_id
 * @param[out] on_thres on_thres
 * @param[out] off_thres on_thres
 * @return SW_OK or error code
 */
sw_error_t
fal_ring_flow_ctrl_thres_get (a_uint32_t dev_id, a_uint32_t ring_id,
			      a_uint8_t * on_thres, a_uint8_t * off_thres)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_ring_flow_ctrl_thres_get (dev_id, ring_id, on_thres, off_thres);
  FAL_API_UNLOCK;
  return rv;
}
/*qca808x_start*/
/**
 * @brief Set 8023az status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_8023az_set (a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_8023az_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get 8023az status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_8023az_get (a_uint32_t dev_id, fal_port_t port_id, a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_8023az_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Set mdix mode on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] set mdix mode [mdx , mdix or auto]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_mdix_set (a_uint32_t dev_id, fal_port_t port_id,
		   fal_port_mdix_mode_t mode)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_mdix_set (dev_id, port_id, mode);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get mdix on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] set mdx ,mdix or auto 
 * @return SW_OK or error code
 */
sw_error_t
fal_port_mdix_get (a_uint32_t dev_id, fal_port_t port_id,
		   fal_port_mdix_mode_t * mode)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_mdix_get (dev_id, port_id, mode);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get mdix status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] set mdx ,mdix 
 * @return SW_OK or error code
 */
sw_error_t
fal_port_mdix_status_get (a_uint32_t dev_id, fal_port_t port_id,
			  fal_port_mdix_status_t * mode)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_mdix_status_get (dev_id, port_id, mode);
  FAL_API_UNLOCK;
  return rv;
}
/*qca808x_end*/
/**
 * @brief Set combo prefer medium  on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] set combo prefer medium [fiber for copper]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_combo_prefer_medium_set (a_uint32_t dev_id, a_uint32_t port_id,
				  fal_port_medium_t medium)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_combo_prefer_medium_set (dev_id, port_id, medium);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get combo prefer medium  on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] set combo prefer medium [fiber for copper]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_combo_prefer_medium_get (a_uint32_t dev_id, a_uint32_t port_id,
				  fal_port_medium_t * medium)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_combo_prefer_medium_get (dev_id, port_id, medium);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get combo  medium  status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] get combo [fiber for copper]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_combo_medium_status_get (a_uint32_t dev_id, a_uint32_t port_id,
				  fal_port_medium_t * medium)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_combo_medium_status_get (dev_id, port_id, medium);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Set combo fiber mode  on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] get combo fiber mode [1000bx or 100fx]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_combo_fiber_mode_set (a_uint32_t dev_id, a_uint32_t port_id,
			       fal_port_fiber_mode_t mode)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_combo_fiber_mode_set (dev_id, port_id, mode);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get combo fiber mode  on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] get combo fiber mode [1000bx or 100fx]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_combo_fiber_mode_get (a_uint32_t dev_id, a_uint32_t port_id,
			       fal_port_fiber_mode_t * mode)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_combo_fiber_mode_get (dev_id, port_id, mode);
  FAL_API_UNLOCK;
  return rv;
}
/*qca808x_start*/
/**
 * @brief Set local loopback  on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_local_loopback_set (a_uint32_t dev_id, fal_port_t port_id,
			     a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_local_loopback_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get local loopback status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_local_loopback_get (a_uint32_t dev_id, fal_port_t port_id,
			     a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_local_loopback_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Set remote loopback  on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_remote_loopback_set (a_uint32_t dev_id, fal_port_t port_id,
			      a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_remote_loopback_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get remote loopback status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_port_remote_loopback_get (a_uint32_t dev_id, fal_port_t port_id,
			      a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_remote_loopback_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief software reset on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_reset (a_uint32_t dev_id, fal_port_t port_id)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_reset (dev_id, port_id);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief phy id on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_phy_id_get (a_uint32_t dev_id, fal_port_t port_id, a_uint16_t * org_id, a_uint16_t * rev_id)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_phy_id_get (dev_id, port_id,org_id,rev_id);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief wol status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_wol_status_set (a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_wol_status_set (dev_id, port_id,enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief wol status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_wol_status_get (a_uint32_t dev_id, fal_port_t port_id, a_bool_t *enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_wol_status_get (dev_id, port_id,enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief magic frame mac on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_magic_frame_mac_set (a_uint32_t dev_id, fal_port_t port_id, fal_mac_addr_t * mac)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_magic_frame_mac_set (dev_id, port_id,mac);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief magic frame mac  on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_magic_frame_mac_get (a_uint32_t dev_id, fal_port_t port_id, fal_mac_addr_t * mac)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_magic_frame_mac_get (dev_id, port_id,mac);
  FAL_API_UNLOCK;
  return rv;
}
/*qca808x_end*/
/**
 * @brief interface mode  on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_interface_mode_set (a_uint32_t dev_id, fal_port_t port_id, fal_port_interface_mode_t  mode)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_interface_mode_set (dev_id, port_id,mode);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief interface mode  on a particular port.
 * @param[in] dev_id device id
 * @return SW_OK or error code
 */
 static sw_error_t
_fal_port_interface_mode_apply (a_uint32_t dev_id)
{
  sw_error_t rv = SW_OK;
  adpt_api_t *p_adpt_api;

    if((p_adpt_api = adpt_api_ptr_get(dev_id)) != NULL) {
        if (NULL == p_adpt_api->adpt_port_interface_mode_apply)
            return SW_NOT_SUPPORTED;

        rv = p_adpt_api->adpt_port_interface_mode_apply(dev_id);
        return rv;
    }

  return rv;
}

sw_error_t
fal_port_interface_mode_apply (a_uint32_t dev_id)
{
  sw_error_t rv = SW_OK;

  FAL_API_LOCK;
  rv = _fal_port_interface_mode_apply (dev_id);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief interface mode on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_interface_mode_get (a_uint32_t dev_id, fal_port_t port_id, fal_port_interface_mode_t * mode)
{
  sw_error_t rv = SW_OK;

  FAL_API_LOCK;
  rv = _fal_port_interface_mode_get (dev_id, port_id,mode);
  FAL_API_UNLOCK;
  return rv;
}
/*qca808x_start*/
/**
 * @brief interface mode status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out]
 * @return SW_OK or error code
 */
sw_error_t
fal_port_interface_mode_status_get (a_uint32_t dev_id, fal_port_t port_id, fal_port_interface_mode_t * mode)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_interface_mode_status_get (dev_id, port_id,mode);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Set counter status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[in] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_debug_phycounter_set (a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_counter_set (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get counter status on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] enable A_TRUE or A_FALSE
 * @return SW_OK or error code
 */
sw_error_t
fal_debug_phycounter_get (a_uint32_t dev_id, fal_port_t port_id, a_bool_t * enable)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_counter_get (dev_id, port_id, enable);
  FAL_API_UNLOCK;
  return rv;
}

/**
 * @brief Get counter statistics on a particular port.
 * @param[in] dev_id device id
 * @param[in] port_id port id
 * @param[out] counter frame number
 * @return SW_OK or error code
 */
sw_error_t
fal_debug_phycounter_show (a_uint32_t dev_id, fal_port_t port_id, fal_port_counter_info_t* port_counter_info)
{
  sw_error_t rv;

  FAL_API_LOCK;
  rv = _fal_port_counter_show (dev_id, port_id, port_counter_info);
  FAL_API_UNLOCK;
  return rv;
}
/*qca808x_end*/
#endif

sw_error_t
fal_port_max_frame_size_set(a_uint32_t dev_id, fal_port_t port_id,
		a_uint32_t max_frame)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_port_max_frame_size_set(dev_id, port_id, max_frame);
    FAL_API_UNLOCK;
    return rv;
}

sw_error_t
fal_port_max_frame_size_get(a_uint32_t dev_id, fal_port_t port_id,
		a_uint32_t *max_frame)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_port_max_frame_size_get(dev_id, port_id, max_frame);
    FAL_API_UNLOCK;
    return rv;
}

#ifndef IN_PORTCONTROL_MINI
sw_error_t
fal_port_mru_set(a_uint32_t dev_id, fal_port_t port_id,
		fal_mru_ctrl_t *ctrl)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_port_mru_set(dev_id, port_id, ctrl);
    FAL_API_UNLOCK;
    return rv;
}
sw_error_t
fal_port_mru_get(a_uint32_t dev_id, fal_port_t port_id,
		fal_mru_ctrl_t *ctrl)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_port_mru_get(dev_id, port_id, ctrl);
    FAL_API_UNLOCK;
    return rv;
}
sw_error_t
fal_port_mtu_set(a_uint32_t dev_id, fal_port_t port_id,
		fal_mtu_ctrl_t *ctrl)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_port_mtu_set(dev_id, port_id, ctrl);
    FAL_API_UNLOCK;
    return rv;
}
sw_error_t
fal_port_mtu_get(a_uint32_t dev_id, fal_port_t port_id,
		fal_mtu_ctrl_t *ctrl)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_port_mtu_get(dev_id, port_id, ctrl);
    FAL_API_UNLOCK;
    return rv;
}

sw_error_t
fal_port_source_filter_status_get(a_uint32_t dev_id,
		fal_port_t port_id, a_bool_t * enable)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_port_source_filter_get(dev_id,
                    port_id, enable);
    FAL_API_UNLOCK;
    return rv;
}

sw_error_t
fal_port_source_filter_enable(a_uint32_t dev_id,
		fal_port_t port_id, a_bool_t enable)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_port_source_filter_set(dev_id,
                    port_id, enable);
    FAL_API_UNLOCK;
    return rv;
}

sw_error_t
fal_port_source_filter_config_set(a_uint32_t dev_id,
		fal_port_t port_id, fal_src_filter_config_t *src_filter_config)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_port_source_filter_config_set(dev_id, port_id, src_filter_config);
    FAL_API_UNLOCK;
    return rv;
}

sw_error_t
fal_port_source_filter_config_get(a_uint32_t dev_id,
		fal_port_t port_id, fal_src_filter_config_t *src_filter_config)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_port_source_filter_config_get(dev_id, port_id, src_filter_config);
    FAL_API_UNLOCK;
    return rv;
}

sw_error_t
fal_port_interface_3az_status_set(a_uint32_t dev_id, fal_port_t port_id,
		a_bool_t enable)
{
    sw_error_t rv;

    FAL_API_LOCK;
    rv = _fal_port_interface_3az_status_set(dev_id, port_id, enable);
    FAL_API_UNLOCK;
    return rv;
}
sw_error_t
fal_port_interface_3az_status_get(a_uint32_t dev_id, fal_port_t port_id,
		a_bool_t * enable)
{
    sw_error_t rv;

    FAL_API_LOCK;
    rv = _fal_port_interface_3az_status_get(dev_id, port_id, enable);
    FAL_API_UNLOCK;
    return rv;
}

sw_error_t
fal_port_promisc_mode_get(a_uint32_t dev_id, fal_port_t port_id, a_bool_t *enable)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_port_promisc_mode_get(dev_id, port_id, enable);
    FAL_API_UNLOCK;
    return rv;
}
#endif

sw_error_t
fal_port_promisc_mode_set(a_uint32_t dev_id, fal_port_t port_id, a_bool_t enable)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_port_promisc_mode_set(dev_id, port_id, enable);
    FAL_API_UNLOCK;
    return rv;
}

sw_error_t
fal_port_interface_eee_cfg_set(a_uint32_t dev_id, fal_port_t port_id,
	fal_port_eee_cfg_t *port_eee_cfg)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_port_interface_eee_cfg_set(dev_id, port_id, port_eee_cfg);
    FAL_API_UNLOCK;
    return rv;
}

sw_error_t
fal_port_interface_eee_cfg_get(a_uint32_t dev_id, fal_port_t port_id,
	fal_port_eee_cfg_t *port_eee_cfg)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_port_interface_eee_cfg_get(dev_id, port_id, port_eee_cfg);
    FAL_API_UNLOCK;
    return rv;
}

sw_error_t
fal_switch_port_loopback_set(a_uint32_t dev_id, fal_port_t port_id,
		fal_loopback_config_t *loopback_cfg)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_switch_port_loopback_set(dev_id, port_id, loopback_cfg);
    FAL_API_UNLOCK;
    return rv;
}

sw_error_t
fal_switch_port_loopback_get(a_uint32_t dev_id, fal_port_t port_id,
	fal_loopback_config_t *loopback_cfg)
{
    sw_error_t rv = SW_OK;

    FAL_API_LOCK;
    rv = _fal_switch_port_loopback_get(dev_id, port_id, loopback_cfg);
    FAL_API_UNLOCK;
    return rv;
}

/*insert flag for outter fal, don't remove it*/
/**
 * @}
 */
 #ifndef IN_PORTCONTROL_MINI
EXPORT_SYMBOL(fal_port_mtu_set);
EXPORT_SYMBOL(fal_port_mtu_get);
EXPORT_SYMBOL(fal_port_mru_set);
EXPORT_SYMBOL(fal_port_mru_get);
#endif
EXPORT_SYMBOL(fal_port_duplex_set);
EXPORT_SYMBOL(fal_port_duplex_get);
EXPORT_SYMBOL(fal_port_speed_set);
EXPORT_SYMBOL(fal_port_speed_get);
EXPORT_SYMBOL(fal_port_autoneg_status_get);
EXPORT_SYMBOL(fal_port_autoneg_enable);
EXPORT_SYMBOL(fal_port_autoneg_restart);
EXPORT_SYMBOL(fal_port_autoneg_adv_set);
EXPORT_SYMBOL(fal_port_autoneg_adv_get);
EXPORT_SYMBOL(fal_port_flowctrl_set);
#ifndef IN_PORTCONTROL_MINI
EXPORT_SYMBOL(fal_port_flowctrl_get);
EXPORT_SYMBOL(fal_port_powersave_set);
EXPORT_SYMBOL(fal_port_powersave_get);
EXPORT_SYMBOL(fal_port_hibernate_set);
EXPORT_SYMBOL(fal_port_hibernate_get);
EXPORT_SYMBOL(fal_port_cdt);
EXPORT_SYMBOL(fal_port_txmac_status_get);
#endif
EXPORT_SYMBOL(fal_port_txmac_status_set);
EXPORT_SYMBOL(fal_port_rxmac_status_set);
#ifndef IN_PORTCONTROL_MINI
EXPORT_SYMBOL(fal_port_rxmac_status_get);
#endif
EXPORT_SYMBOL(fal_port_txfc_status_set);
EXPORT_SYMBOL(fal_port_txfc_status_get);
EXPORT_SYMBOL(fal_port_rxfc_status_set);
EXPORT_SYMBOL(fal_port_rxfc_status_get);
#ifndef IN_PORTCONTROL_MINI
EXPORT_SYMBOL(fal_port_bp_status_set);
EXPORT_SYMBOL(fal_port_bp_status_get);
#endif
EXPORT_SYMBOL(fal_port_link_status_get);
#ifndef IN_PORTCONTROL_MINI
EXPORT_SYMBOL(fal_ports_link_status_get);
EXPORT_SYMBOL(fal_port_mac_loopback_set);
EXPORT_SYMBOL(fal_port_mac_loopback_get);
EXPORT_SYMBOL(fal_port_8023az_set);
EXPORT_SYMBOL(fal_port_8023az_get);
EXPORT_SYMBOL(fal_port_mdix_set);
EXPORT_SYMBOL(fal_port_mdix_get);
EXPORT_SYMBOL(fal_port_mdix_status_get);
EXPORT_SYMBOL(fal_port_combo_prefer_medium_set);
EXPORT_SYMBOL(fal_port_combo_prefer_medium_get);
EXPORT_SYMBOL(fal_port_combo_medium_status_get);
EXPORT_SYMBOL(fal_port_combo_fiber_mode_set);
EXPORT_SYMBOL(fal_port_combo_fiber_mode_get);
EXPORT_SYMBOL(fal_port_local_loopback_set);
EXPORT_SYMBOL(fal_port_local_loopback_get);
EXPORT_SYMBOL(fal_port_remote_loopback_set);
EXPORT_SYMBOL(fal_port_remote_loopback_get);
EXPORT_SYMBOL(fal_port_reset);
#endif
EXPORT_SYMBOL(fal_port_power_off);
EXPORT_SYMBOL(fal_port_power_on);
#ifndef IN_PORTCONTROL_MINI
EXPORT_SYMBOL(fal_port_magic_frame_mac_set );
EXPORT_SYMBOL(fal_port_magic_frame_mac_get );
EXPORT_SYMBOL(fal_port_phy_id_get );
EXPORT_SYMBOL(fal_port_wol_status_set );
EXPORT_SYMBOL(fal_port_wol_status_get );
EXPORT_SYMBOL(fal_port_interface_mode_set);
EXPORT_SYMBOL(fal_port_interface_mode_apply);

EXPORT_SYMBOL(fal_port_interface_mode_get );
EXPORT_SYMBOL(fal_port_interface_mode_status_get );
EXPORT_SYMBOL(fal_port_source_filter_enable);
EXPORT_SYMBOL(fal_port_source_filter_status_get);
EXPORT_SYMBOL(fal_port_source_filter_config_get);
EXPORT_SYMBOL(fal_port_source_filter_config_set);
#endif
EXPORT_SYMBOL(fal_port_max_frame_size_set);
EXPORT_SYMBOL(fal_port_max_frame_size_get);
#ifndef IN_PORTCONTROL_MINI
EXPORT_SYMBOL(fal_port_interface_3az_status_set);
EXPORT_SYMBOL(fal_port_interface_3az_status_get);
#endif
EXPORT_SYMBOL(fal_port_flowctrl_forcemode_set);
#ifndef IN_PORTCONTROL_MINI
EXPORT_SYMBOL(fal_port_flowctrl_forcemode_get);
EXPORT_SYMBOL(fal_port_promisc_mode_set);
EXPORT_SYMBOL(fal_port_promisc_mode_get);
#endif
EXPORT_SYMBOL(fal_port_interface_eee_cfg_set);
EXPORT_SYMBOL(fal_port_interface_eee_cfg_get);
EXPORT_SYMBOL(fal_switch_port_loopback_set);
EXPORT_SYMBOL(fal_switch_port_loopback_get);