text: /*-
   * Copyright(c) 2002-2011 Exar Corp.
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification are permitted provided the following conditions are met:
   *
   *    1. Redistributions of source code must retain the above copyright notice,
   *       this list of conditions and the following disclaimer.
   *
   *    2. Redistributions in binary form must reproduce the above copyright
   *       notice, this list of conditions and the following disclaimer in the
   *       documentation and/or other materials provided with the distribution.
   *
   *    3. Neither the name of the Exar Corporation nor the names of its
   *       contributors may be used to endorse or promote products derived from
   *       this software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   */
  /*$FreeBSD: releng/9.3/sys/dev/vxge/vxgehal/vxgehal-virtualpath.c 221167 2011-04-28 14:33:15Z gnn $*/
  #include <dev/vxge/vxgehal/vxgehal.h>
  
  
  /*
   * __hal_vpath_fw_memo_get - Get the fw memo interface parameters
   * @pdev: PCI device object.
   * @regh0: BAR0 mapped memory handle, or simply PCI device @pdev
   * (Linux and the rest.)
   * @vp_id: Vpath id
   * @vpath_reg: Pointer to vpath registers
   * @action: Action for FW Interface
   * @param_index: Index of the parameter
   * @data0: Buffer to return data 0 register contents
   * @data1: Buffer to return data 1 register contents
   *
   * Returns FW memo interface parameters
   *
   */
  vxge_hal_status_e
  __hal_vpath_fw_memo_get(
      pci_dev_h pdev,
      pci_reg_h regh0,
      u32 vp_id,
      vxge_hal_vpath_reg_t *vpath_reg,
      u32 action,
      u64 param_index,
      u64 *data0,
      u64 *data1)
  {
  	u64 val64;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert((vpath_reg != NULL) && (data0 != NULL) && (data1 != NULL));
  
  	vxge_hal_trace_log_driver("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_driver(
  	    "pdev = 0x"VXGE_OS_STXFMT", regh0 = 0x"VXGE_OS_STXFMT", "
  	    "vp_id = %d, vpath_reg = 0x"VXGE_OS_STXFMT", action = %d, "
  	    "param_index = %lld, data0 = 0x"VXGE_OS_STXFMT", "
  	    "data1 = 0x"VXGE_OS_STXFMT, (ptr_t) pdev, (ptr_t) regh0,
  	    vp_id, (ptr_t) vpath_reg, action, param_index,
  	    (ptr_t) data0, (ptr_t) data1);
  
  	vxge_os_pio_mem_write64(pdev,
  	    regh0,
  	    0,
  	    &vpath_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_os_pio_mem_write64(pdev,
  	    regh0,
  	    param_index,
  	    &vpath_reg->rts_access_steer_data0);
  
  	vxge_os_pio_mem_write64(pdev,
  	    regh0,
  	    0,
  	    &vpath_reg->rts_access_steer_data1);
  
  	vxge_os_wmb();
  
  	val64 = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION(action) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET(0);
  
  	vxge_hal_pio_mem_write32_lower(pdev,
  	    regh0,
  	    (u32) bVAL32(val64, 32),
  	    &vpath_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_hal_pio_mem_write32_upper(pdev,
  	    regh0,
  	    (u32) bVAL32(val64, 0),
  	    &vpath_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	status = vxge_hal_device_register_poll(pdev, regh0,
  	    &vpath_reg->rts_access_steer_ctrl, 0,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE,
  	    WAIT_FACTOR * VXGE_HAL_DEF_DEVICE_POLL_MILLIS);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	val64 = vxge_os_pio_mem_read64(pdev, regh0,
  	    &vpath_reg->rts_access_steer_ctrl);
  
  	if (val64 & VXGE_HAL_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
  
  		*data0 = vxge_os_pio_mem_read64(pdev, regh0,
  		    &vpath_reg->rts_access_steer_data0);
  
  		*data1 = vxge_os_pio_mem_read64(pdev, regh0,
  		    &vpath_reg->rts_access_steer_data1);
  
  		status = VXGE_HAL_OK;
  
  	} else {
  		status = VXGE_HAL_FAIL;
  	}
  
  
  	vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * __hal_vpath_fw_flash_ver_get - Get the fw version
   * @pdev: PCI device object.
   * @regh0: BAR0 mapped memory handle, or simply PCI device @pdev
   * (Linux and the rest.)
   * @vp_id: Vpath id
   * @vpath_reg: Pointer to vpath registers
   * @fw_version: Buffer to return FW Version (Major)
   * @fw_date: Buffer to return FW Version (date)
   * @flash_version: Buffer to return FW Version (Major)
   * @flash_date: Buffer to return FW Version (date)
   *
   * Returns FW Version
   *
   */
  vxge_hal_status_e
  __hal_vpath_fw_flash_ver_get(
      pci_dev_h pdev,
      pci_reg_h regh0,
      u32 vp_id,
      vxge_hal_vpath_reg_t *vpath_reg,
      vxge_hal_device_version_t *fw_version,
      vxge_hal_device_date_t *fw_date,
      vxge_hal_device_version_t *flash_version,
      vxge_hal_device_date_t *flash_date)
  {
  	u64 data1 = 0ULL;
  	u64 data2 = 0ULL;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert((vpath_reg != NULL) && (fw_version != NULL) &&
  	    (fw_date != NULL) && (flash_version != NULL) &&
  	    (flash_date != NULL));
  
  	vxge_hal_trace_log_driver("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_driver(
  	    "pdev = 0x"VXGE_OS_STXFMT", regh0 = 0x"VXGE_OS_STXFMT", "
  	    "vp_id = %d, vpath_reg = 0x"VXGE_OS_STXFMT", "
  	    "fw_version = 0x"VXGE_OS_STXFMT", "
  	    "fw_date = 0x"VXGE_OS_STXFMT", "
  	    "flash_version = 0x"VXGE_OS_STXFMT", "
  	    "flash_date = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) pdev, (ptr_t) regh0, vp_id, (ptr_t) vpath_reg,
  	    (ptr_t) fw_version, (ptr_t) fw_date,
  	    (ptr_t) flash_version, (ptr_t) flash_date);
  
  	status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_MEMO_VERSION,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_FW_VERSION,
  	    &data1, &data2);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	fw_date->day =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_FW_VER_DAY(data1);
  	fw_date->month =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MONTH(data1);
  	fw_date->year =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_FW_VER_YEAR(data1);
  
  	(void) vxge_os_snprintf(fw_date->date, sizeof(fw_date->date),
  	    "%2.2d/%2.2d/%4.4d",
  	    fw_date->month, fw_date->day, fw_date->year);
  
  	fw_version->major =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MAJOR(data1);
  	fw_version->minor =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MINOR(data1);
  	fw_version->build =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_FW_VER_BUILD(data1);
  
  	(void) vxge_os_snprintf(fw_version->version,
  	    sizeof(fw_version->version),
  	    "%d.%d.%d", fw_version->major,
  	    fw_version->minor, fw_version->build);
  
  	status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_MEMO_CARD_INFO,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_FLASH_VERSION,
  	    &data1, &data2);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	flash_date->day =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_FLASH_VER_DAY(data1);
  	flash_date->month =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_FLASH_VER_MONTH(data1);
  	flash_date->year =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_FLASH_VER_YEAR(data1);
  
  	(void) vxge_os_snprintf(flash_date->date, sizeof(flash_date->date),
  	    "%2.2d/%2.2d/%4.4d", flash_date->month, flash_date->day,
  	    flash_date->year);
  
  	flash_version->major =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_FLASH_VER_MAJOR(data1);
  	flash_version->minor =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_FLASH_VER_MINOR(data1);
  	flash_version->build =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_FLASH_VER_BUILD(data1);
  
  	(void) vxge_os_snprintf(flash_version->version,
  	    sizeof(flash_version->version),
  	    "%d.%d.%d", flash_version->major,
  	    flash_version->minor, flash_version->build);
  
  	vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * __hal_vpath_card_info_get - Get the card infor
   * @pdev: PCI device object.
   * @regh0: BAR0 mapped memory handle, or simply PCI device @pdev
   * (Linux and the rest.)
   * @vp_id: Vpath id
   * @vpath_reg: Pointer to vpath registers
   * @serial_number: Buffer to return card serial number
   * @part_number: Buffer to return card part number
   * @product_description: Buffer to return card description
   *
   * Returns Card Info
   *
   */
  vxge_hal_status_e
  __hal_vpath_card_info_get(
      pci_dev_h pdev,
      pci_reg_h regh0,
      u32 vp_id,
      vxge_hal_vpath_reg_t *vpath_reg,
      u8 *serial_number,
      u8 *part_number,
      u8 *product_description)
  {
  	u32 i, j;
  	u64 data1 = 0ULL;
  	u64 data2 = 0ULL;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert((vpath_reg != NULL) && (serial_number != NULL) &&
  	    (part_number != NULL) && (product_description != NULL));
  
  	vxge_hal_trace_log_driver("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_driver(
  	    "pdev = 0x"VXGE_OS_STXFMT", regh0 = 0x"VXGE_OS_STXFMT", "
  	    "vp_id = %d, vpath_reg = 0x"VXGE_OS_STXFMT", "
  	    "serial_number = 0x"VXGE_OS_STXFMT", "
  	    "part_number = 0x"VXGE_OS_STXFMT", "
  	    "product_description = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) pdev, (ptr_t) regh0, vp_id, (ptr_t) vpath_reg,
  	    (ptr_t) serial_number, (ptr_t) part_number,
  	    (ptr_t) product_description);
  
  	*serial_number = 0;
  	*part_number = 0;
  	*product_description = 0;
  
  	status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_MEMO_CARD_INFO,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_SERIAL_NUMBER,
  	    &data1, &data2);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	/* LINTED */
  	((u64 *) serial_number)[0] = vxge_os_ntohll(data1);
  
  	/* LINTED */
  	((u64 *) serial_number)[1] = vxge_os_ntohll(data2);
  
  	status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_MEMO_CARD_INFO,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PART_NUMBER,
  	    &data1, &data2);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	/* LINTED */
  	((u64 *) part_number)[0] = vxge_os_ntohll(data1);
  
  	/* LINTED */
  	((u64 *) part_number)[1] = vxge_os_ntohll(data2);
  
  	j = 0;
  
  	for (i = VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_DESC_0;
  	    i <= VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_DESC_3;
  	    i++) {
  
  		status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_MEMO_CARD_INFO,
  		    i,
  		    &data1, &data2);
  
  		if (status != VXGE_HAL_OK) {
  
  			vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, status);
  			return (status);
  		}
  
  		/* LINTED */
  		((u64 *) product_description)[j++] = vxge_os_ntohll(data1);
  
  		/* LINTED */
  		((u64 *) product_description)[j++] = vxge_os_ntohll(data2);
  
  	}
  
  	vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * __hal_vpath_pmd_info_get - Get the PMD info
   * @pdev: PCI device object.
   * @regh0: BAR0 mapped memory handle, or simply PCI device @pdev
   * (Linux and the rest.)
   * @vp_id: Vpath id
   * @vpath_reg: Pointer to vpath registers
   * @ports: Number of ports supported
   * @pmd_port0: Buffer to return PMD info for port 0
   * @pmd_port1: Buffer to return PMD info for port 1
   *
   * Returns PMD Info
   *
   */
  vxge_hal_status_e
  __hal_vpath_pmd_info_get(
      pci_dev_h pdev,
      pci_reg_h regh0,
      u32 vp_id,
      vxge_hal_vpath_reg_t *vpath_reg,
      u32 *ports,
      vxge_hal_device_pmd_info_t *pmd_port0,
      vxge_hal_device_pmd_info_t *pmd_port1)
  {
  	u64 data1 = 0ULL;
  	u64 data2 = 0ULL;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert((vpath_reg != NULL) &&
  	    (pmd_port0 != NULL) && (pmd_port1 != NULL));
  
  	vxge_hal_trace_log_driver("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_driver(
  	    "pdev = 0x"VXGE_OS_STXFMT", regh0 = 0x"VXGE_OS_STXFMT", "
  	    "vp_id = %d, vpath_reg = 0x"VXGE_OS_STXFMT", "
  	    "ports = 0x"VXGE_OS_STXFMT", "
  	    "pmd_port0 = 0x"VXGE_OS_STXFMT", "
  	    "pmd_port1 = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) pdev, (ptr_t) regh0, vp_id, (ptr_t) vpath_reg,
  	    (ptr_t) ports, (ptr_t) pmd_port0, (ptr_t) pmd_port1);
  
  	status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_MEMO_CARD_INFO,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PORTS,
  	    &data1, &data2);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	*ports = (u32) data1;
  
  	status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_MEMO_CARD_INFO,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PORT0_PMD_TYPE,
  	    &data1, &data2);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	if (data1) {
  
  		pmd_port0->type = (u32) data1;
  
  		status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_MEMO_CARD_INFO,
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PORT0_PMD_VENDOR,
  		    &data1, &data2);
  
  		if (status != VXGE_HAL_OK) {
  
  			vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, status);
  			return (status);
  		}
  
  		/* LINTED */
  		((u64 *) pmd_port0->vendor)[0] = vxge_os_ntohll(data1);
  
  		/* LINTED */
  		((u64 *) pmd_port0->vendor)[1] = vxge_os_ntohll(data2);
  
  		status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_MEMO_CARD_INFO,
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PORT0_PMD_PARTNO,
  		    &data1, &data2);
  
  		if (status != VXGE_HAL_OK) {
  
  			vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, status);
  			return (status);
  		}
  
  		/* LINTED */
  		((u64 *) pmd_port0->part_num)[0] = vxge_os_ntohll(data1);
  
  		/* LINTED */
  		((u64 *) pmd_port0->part_num)[1] = vxge_os_ntohll(data2);
  
  		status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_MEMO_CARD_INFO,
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PORT0_PMD_SERNO,
  		    &data1, &data2);
  
  		if (status != VXGE_HAL_OK) {
  
  			vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, status);
  			return (status);
  		}
  
  		/* LINTED */
  		((u64 *) pmd_port0->ser_num)[0] = vxge_os_ntohll(data1);
  
  		/* LINTED */
  		((u64 *) pmd_port0->ser_num)[1] = vxge_os_ntohll(data2);
  	} else {
  		vxge_os_memzero(pmd_port0, sizeof(vxge_hal_device_pmd_info_t));
  	}
  
  	status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_MEMO_CARD_INFO,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PORT1_PMD_TYPE,
  	    &data1, &data2);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	if (data1) {
  
  		pmd_port1->type = (u32) data1;
  
  		status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_MEMO_CARD_INFO,
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PORT1_PMD_VENDOR,
  		    &data1, &data2);
  
  		if (status != VXGE_HAL_OK) {
  
  			vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, status);
  			return (status);
  		}
  
  		/* LINTED */
  		((u64 *) pmd_port1->vendor)[0] = vxge_os_ntohll(data1);
  
  		/* LINTED */
  		((u64 *) pmd_port1->vendor)[1] = vxge_os_ntohll(data2);
  
  		status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_MEMO_CARD_INFO,
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PORT1_PMD_PARTNO,
  		    &data1, &data2);
  
  		if (status != VXGE_HAL_OK) {
  
  			vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, status);
  			return (status);
  		}
  
  		/* LINTED */
  		((u64 *) pmd_port1->part_num)[0] = vxge_os_ntohll(data1);
  
  		/* LINTED */
  		((u64 *) pmd_port1->part_num)[1] = vxge_os_ntohll(data2);
  
  		status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_MEMO_CARD_INFO,
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PORT1_PMD_SERNO,
  		    &data1, &data2);
  
  		if (status != VXGE_HAL_OK) {
  
  			vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, status);
  			return (status);
  		}
  
  		/* LINTED */
  		((u64 *) pmd_port1->ser_num)[0] = vxge_os_ntohll(data1);
  
  		/* LINTED */
  		((u64 *) pmd_port1->ser_num)[1] = vxge_os_ntohll(data2);
  
  	} else {
  		vxge_os_memzero(pmd_port1, sizeof(vxge_hal_device_pmd_info_t));
  	}
  
  	vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * __hal_vpath_pci_func_mode_get - Get the pci mode
   * @pdev: PCI device object.
   * @regh0: BAR0 mapped memory handle, or simply PCI device @pdev
   * (Linux and the rest.)
   * @vp_id: Vpath id
   * @vpath_reg: Pointer to vpath registers
   *
   * Returns pci function mode
   *
   */
  u64
  __hal_vpath_pci_func_mode_get(
      pci_dev_h pdev,
      pci_reg_h regh0,
      u32 vp_id,
      vxge_hal_vpath_reg_t *vpath_reg)
  {
  	u64 data1 = 0ULL;
  	u64 data2 = 0ULL;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert(vpath_reg != NULL);
  
  	vxge_hal_trace_log_driver("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_driver(
  	    "pdev = 0x"VXGE_OS_STXFMT", regh0 = 0x"VXGE_OS_STXFMT", "
  	    "vp_id = %d, vpath_reg = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) pdev, (ptr_t) regh0, vp_id, (ptr_t) vpath_reg);
  
  	status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_GET_FUNC_MODE,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PCI_MODE,
  	    &data1, &data2);
  
  	vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (data1);
  }
  
  /*
   * __hal_vpath_lag_mode_get - Get the LAG mode
   * @vpath: VIrtual Path
   *
   * Returns the LAG mode in use
   */
  vxge_hal_device_lag_mode_e
  __hal_vpath_lag_mode_get(__hal_virtualpath_t *vpath)
  {
  	u64 data1 = 0ULL;
  	u64 data2 = 0ULL;
  	u32 lag_mode = VXGE_HAL_DEVICE_LAG_MODE_UNKNOWN;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert(vpath != NULL);
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath);
  
  	(void) __hal_vpath_fw_memo_get(hldev->header.pdev, hldev->header.regh0,
  	    vpath->vp_id, vpath->vp_reg,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_PORT_INFO,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_LAG_MODE,
  	    &data1, &data2);
  
  	if (VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_MEMO_ITEM_STATUS(data1) ==
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_STATUS_SUCCESS) {
  		lag_mode = (u32)
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA1_MEMO_ITEM_GET_LAG_MODE(data2);
  		status = VXGE_HAL_OK;
  	} else {
  		status = VXGE_HAL_FAIL;
  	}
  
  	vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return ((vxge_hal_device_lag_mode_e) lag_mode);
  }
  
  /*
   * __hal_vpath_vpath_map_get - Get the vpath map
   * @pdev: PCI device object.
   * @regh0: BAR0 mapped memory handle, or simply PCI device @pdev
   * (Linux and the rest.)
   * @vp_id: Vpath id
   * @vh: Virtual Hierrachy
   * @func: Function number
   * @vpath_reg: Pointer to vpath registers
   *
   * Returns vpath map for a give hierarchy and function
   *
   */
  u64
  __hal_vpath_vpath_map_get(pci_dev_h pdev, pci_reg_h regh0,
      u32 vp_id, u32 vh, u32 func,
      vxge_hal_vpath_reg_t *vpath_reg)
  {
  	u64 i;
  	u64 val64 = 0ULL;
  	u64 data1 = 0ULL;
  	u64 data2 = 0ULL;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert(vpath_reg != NULL);
  
  	vxge_hal_trace_log_driver("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_driver(
  	    "pdev = 0x"VXGE_OS_STXFMT", regh0 = 0x"VXGE_OS_STXFMT", "
  	    "vp_id = %d, vh = %d, func = %d, vpath_reg = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) pdev, (ptr_t) regh0, vp_id, vh, func, (ptr_t) vpath_reg);
  
  	status = __hal_vpath_fw_memo_get(pdev, regh0, vp_id, vpath_reg,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_VPATH_MAP,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_VH(vh) |
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_FUNCTION(func),
  	    &data1, &data2);
  
  	for (i = 0; i < VXGE_HAL_MAX_VIRTUAL_PATHS; i++) {
  		if (data2 & VXGE_HAL_RTS_ACCESS_STEER_DATA1_IS_VPATH_ASSIGNED(i))
  			val64 |= mBIT(i);
  	}
  
  	vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (val64);
  }
  
  /*
   * __hal_vpath_pci_read - Read the content of given address
   *			 in pci config space.
   * @vpath: Virtual Path object.
   * @offset: Configuration address(offset)to read from
   * @length: Length of the data (1, 2 or 4 bytes)
   * @val: Pointer to a buffer to return the content of the address
   *
   * Read from the vpath pci config space.
   *
   */
  vxge_hal_status_e
  __hal_vpath_pci_read(struct __hal_device_t *hldev,
      u32 vp_id, u32 offset,
      u32 length, void *val)
  {
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert((hldev != NULL) && (val != NULL));
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("hldev = 0x"VXGE_OS_STXFMT", vp_id = %d, "
  	    "offset = %d, val = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) hldev, vp_id, offset, (ptr_t) val);
  
  	switch (length) {
  	case 1:
  		vxge_os_pci_read8(hldev->header.pdev,
  		    hldev->header.cfgh,
  		    offset,
  		    ((u8 *) val));
  		break;
  	case 2:
  		vxge_os_pci_read16(hldev->header.pdev,
  		    hldev->header.cfgh,
  		    offset,
  		    ((u16 *) val));
  		break;
  	case 4:
  		vxge_os_pci_read32(hldev->header.pdev,
  		    hldev->header.cfgh,
  		    offset,
  		    ((u32 *) val));
  		break;
  	default:
  		status = VXGE_HAL_FAIL;
  		vxge_os_memzero(val, length);
  		break;
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * __hal_vpath_fw_upgrade - Upgrade the firmware
   * @pdev: PCI device object.
   * @regh0: BAR0 mapped memory handle, or simply PCI device @pdev
   * (Linux and the rest.)
   * @vp_id: Vpath id
   * @vpath_reg: Pointer to vpath registers
   * @buffer: Buffer containing F/W image
   * @length: Length of F/W image
   *
   * Upgrade the firmware
   *
   */
  vxge_hal_status_e
  __hal_vpath_fw_upgrade(
      pci_dev_h pdev,
      pci_reg_h regh0,
      u32 vp_id,
      vxge_hal_vpath_reg_t *vpath_reg,
      u8 *buffer,
      u32 length)
  {
  	u32 i = 0;
  	u64 val64;
  	u32 not_done = TRUE;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert((vpath_reg != NULL) && (buffer != NULL));
  
  	vxge_hal_trace_log_driver("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_driver(
  	    "pdev = 0x"VXGE_OS_STXFMT", regh0 = 0x"VXGE_OS_STXFMT", "
  	    "vp_id = %d, vpath_reg = 0x"VXGE_OS_STXFMT", "
  	    "buffer = 0x"VXGE_OS_STXFMT", length = %d\n",
  	    (ptr_t) pdev, (ptr_t) regh0, vp_id, (ptr_t) vpath_reg,
  	    (ptr_t) buffer, length);
  
  	vxge_os_pio_mem_write64(pdev,
  	    regh0,
  	    0,
  	    &vpath_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_os_pio_mem_write64(pdev,
  	    regh0,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_FW_UPGRADE_STREAM_SKIP,
  	    &vpath_reg->rts_access_steer_data0);
  
  	vxge_os_pio_mem_write64(pdev,
  	    regh0,
  	    0,
  	    &vpath_reg->rts_access_steer_data1);
  
  	vxge_os_wmb();
  
  	val64 = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_UPGRADE) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET_FW_UPGRADE_MODE);
  
  	vxge_hal_pio_mem_write32_lower(pdev, regh0,
  	    (u32) bVAL32(val64, 32),
  	    &vpath_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_hal_pio_mem_write32_upper(pdev, regh0,
  	    (u32) bVAL32(val64, 0),
  	    &vpath_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	status = __hal_device_register_stall(pdev, regh0,
  	    &vpath_reg->rts_access_steer_ctrl, 0,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE,
  	    WAIT_FACTOR * VXGE_HAL_DEF_DEVICE_POLL_MILLIS);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	val64 = vxge_os_pio_mem_read64(pdev, regh0,
  	    &vpath_reg->rts_access_steer_ctrl);
  
  	if (!(val64 & VXGE_HAL_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS)) {
  
  		vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_FAIL);
  		return (VXGE_HAL_FAIL);
  	}
  
  	while (not_done) {
  		if ((i + 16) > length) {
  			vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, VXGE_HAL_FAIL);
  			return (VXGE_HAL_FAIL);
  		}
  		vxge_os_pio_mem_write64(pdev, regh0, ((u64) (buffer[i])) |
  		    ((u64) (buffer[i + 1]) << 8) |
  		    ((u64) (buffer[i + 2]) << 16) |
  		    ((u64) (buffer[i + 3]) << 24) |
  		    ((u64) (buffer[i + 4]) << 32) |
  		    ((u64) (buffer[i + 5]) << 40) |
  		    ((u64) (buffer[i + 6]) << 48) |
  		    ((u64) (buffer[i + 7]) << 56),
  		    &vpath_reg->rts_access_steer_data0);
  
  		vxge_os_pio_mem_write64(pdev, regh0,
  		    ((u64) (buffer[i + 8])) |
  		    ((u64) (buffer[i + 9]) << 8) |
  		    ((u64) (buffer[i + 10]) << 16) |
  		    ((u64) (buffer[i + 11]) << 24) |
  		    ((u64) (buffer[i + 12]) << 32) |
  		    ((u64) (buffer[i + 13]) << 40) |
  		    ((u64) (buffer[i + 14]) << 48) |
  		    ((u64) (buffer[i + 15]) << 56),
  		    &vpath_reg->rts_access_steer_data1);
  		vxge_os_wmb();
  
  		val64 = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION(
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_UPGRADE) |
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE |
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET(
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET_FW_UPGRADE_DATA);
  		vxge_hal_pio_mem_write32_lower(pdev, regh0,
  		    (u32) bVAL32(val64, 32),
  		    &vpath_reg->rts_access_steer_ctrl);
  
  		vxge_os_wmb();
  
  		vxge_hal_pio_mem_write32_upper(pdev, regh0,
  		    (u32) bVAL32(val64, 0), &vpath_reg->rts_access_steer_ctrl);
  		vxge_os_wmb();
  
  		status = __hal_device_register_stall(pdev, regh0,
  		    &vpath_reg->rts_access_steer_ctrl, 0,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE,
  		    WAIT_FACTOR * VXGE_HAL_DEF_DEVICE_POLL_MILLIS);
  		if (status != VXGE_HAL_OK) {
  
  			vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, status);
  			return (status);
  		}
  
  		val64 = vxge_os_pio_mem_read64(pdev, regh0,
  		    &vpath_reg->rts_access_steer_ctrl);
  		if (!(val64 & VXGE_HAL_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS)) {
  			vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, VXGE_HAL_FAIL);
  			return (VXGE_HAL_FAIL);
  		}
  
  		val64 = vxge_os_pio_mem_read64(pdev, regh0,
  		    &vpath_reg->rts_access_steer_data0);
  		switch (VXGE_HAL_RTS_ACCESS_STEER_DATA0_FW_UPGRADE_GET_RET_CODE(val64)) {
  		case VXGE_HAL_RTS_ACCESS_STEER_DATA0_FW_UPGRADE_GET_RET_CODE_OK:
  			i += 16;
  			break;
  		case VXGE_HAL_RTS_ACCESS_STEER_DATA0_FW_UPGRADE_GET_RET_CODE_DONE:
  			not_done = FALSE;
  			break;
  		case VXGE_HAL_RTS_ACCESS_STEER_DATA0_FW_UPGRADE_GET_RET_CODE_SKIP:
  			i += 16;
  			i += (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_FW_UPGRADE_GET_SKIP_BYTES(val64);
  			break;
  		case VXGE_HAL_RTS_ACCESS_STEER_DATA0_FW_UPGRADE_GET_RET_CODE_ERROR:
  		default:
  			vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, VXGE_HAL_FAIL);
  			return (VXGE_HAL_FAIL);
  		}
  	}
  
  	vxge_os_pio_mem_write64(pdev,
  	    regh0,
  	    0,
  	    &vpath_reg->rts_access_steer_data0);
  
  	vxge_os_pio_mem_write64(pdev,
  	    regh0,
  	    0,
  	    &vpath_reg->rts_access_steer_data1);
  
  	vxge_os_wmb();
  
  	val64 = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FW_UPGRADE) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET_FW_UPGRADE_COMMIT);
  
  	vxge_hal_pio_mem_write32_lower(pdev,
  	    regh0,
  	    (u32) bVAL32(val64, 32),
  	    &vpath_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_hal_pio_mem_write32_upper(pdev,
  	    regh0,
  	    (u32) bVAL32(val64, 0),
  	    &vpath_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	status = __hal_device_register_stall(pdev, regh0,
  	    &vpath_reg->rts_access_steer_ctrl, 0,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE,
  	    100 * VXGE_HAL_DEF_DEVICE_POLL_MILLIS);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	val64 = vxge_os_pio_mem_read64(pdev, regh0,
  	    &vpath_reg->rts_access_steer_ctrl);
  
  	if (!(val64 & VXGE_HAL_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS)) {
  
  		vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_FAIL);
  		return (VXGE_HAL_FAIL);
  	}
  
  	vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, VXGE_HAL_OK);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * __hal_vpath_flick_link_led - Flick (blink) link LED.
   * @hldev: HAL device.
   * @vp_id: Vpath Id
   * @port : Port number 0, or 1
   * @on_off: TRUE if flickering to be on, FALSE to be off
   *
   * Flicker the link LED.
   */
  vxge_hal_status_e
  __hal_vpath_flick_link_led(struct __hal_device_t *hldev,
      u32 vp_id, u32 port, u32 on_off)
  {
  	u64 val64;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	vxge_hal_vpath_reg_t *vp_reg;
  
  	vxge_assert(hldev != NULL);
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "hldev = 0x"VXGE_OS_STXFMT", vp_id = %d, port = %d, on_off = %d",
  	    (ptr_t) hldev, vp_id, port, on_off);
  
  	vp_reg = hldev->vpath_reg[vp_id];
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u64) on_off,
  	    &vp_reg->rts_access_steer_data0);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vp_reg->rts_access_steer_data1);
  
  	vxge_os_wmb();
  
  	val64 = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_LED_CONTROL) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET(0);
  
  	vxge_hal_pio_mem_write32_lower(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 32),
  	    &vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 0),
  	    &vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	status = vxge_hal_device_register_poll(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp_reg->rts_access_steer_ctrl, 0,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE,
  	    WAIT_FACTOR * hldev->header.config.device_poll_millis);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * __hal_vpath_udp_rth_set - Enable or Disable UDP/RTH.
   * @hldev: HAL device.
   * @vp_id: Vpath Id
   * @on_off: TRUE if UDP/RTH to be enabled, FALSE to be disabled
   *
   * Enable or Disable UDP/RTH.
   */
  vxge_hal_status_e
  __hal_vpath_udp_rth_set(
      struct __hal_device_t *hldev,
      u32 vp_id,
      u32 on_off)
  {
  	u64 val64;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	vxge_hal_vpath_reg_t *vp_reg;
  
  	vxge_assert(hldev != NULL);
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "hldev = 0x"VXGE_OS_STXFMT", vp_id = %d, on_off = %d",
  	    (ptr_t) hldev, vp_id, on_off);
  
  	vp_reg = hldev->vpath_reg[vp_id];
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    ((on_off) ? VXGE_HAL_RTS_ACCESS_STEER_DATA0_UDP_RTH_ENABLE : 0),
  	    &vp_reg->rts_access_steer_data0);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vp_reg->rts_access_steer_data1);
  
  	vxge_os_wmb();
  
  	val64 = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_UDP_RTH) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET(0);
  
  	vxge_hal_pio_mem_write32_lower(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 32),
  	    &vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 0),
  	    &vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	status = vxge_hal_device_register_poll(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp_reg->rts_access_steer_ctrl, 0,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE,
  	    WAIT_FACTOR * hldev->header.config.device_poll_millis);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * __hal_vpath_pcie_func_mode_set - Set PCI-E function mode.
   * @hldev: HAL device.
   * @vp_id: Vpath Id
   * @func_mode: func_mode to be set
   *
   * Set PCI-E function mode.
   */
  vxge_hal_status_e
  __hal_vpath_pcie_func_mode_set(struct __hal_device_t *hldev,
      u32 vp_id, u32 func_mode)
  {
  	u64 val64;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	vxge_hal_vpath_reg_t *vp_reg;
  
  	vxge_assert(hldev != NULL);
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "hldev = 0x"VXGE_OS_STXFMT", vp_id = %d, func_mode = %d",
  	    (ptr_t) hldev, vp_id, func_mode);
  
  	vp_reg = hldev->vpath_reg[vp_id];
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_FUNC_MODE(func_mode),
  	    &vp_reg->rts_access_steer_data0);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vp_reg->rts_access_steer_data1);
  
  	vxge_os_wmb();
  
  	val64 = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_FUNC_MODE) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET(0);
  
  	vxge_hal_pio_mem_write32_lower(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 32),
  	    &vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 0),
  	    &vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	status = vxge_hal_device_register_poll(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp_reg->rts_access_steer_ctrl, 0,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE,
  	    WAIT_FACTOR * hldev->header.config.device_poll_millis);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp_reg->rts_access_steer_ctrl);
  
  	if (!(val64 & VXGE_HAL_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS)) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_FAIL);
  		return (VXGE_HAL_FAIL);
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vp_reg->rts_access_steer_data0);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vp_reg->rts_access_steer_data1);
  
  	vxge_os_wmb();
  
  	val64 = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_COMMIT) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET(0);
  
  	vxge_hal_pio_mem_write32_lower(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 32),
  	    &vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 0),
  	    &vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	status = vxge_hal_device_register_poll(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp_reg->rts_access_steer_ctrl, 0,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE,
  	    WAIT_FACTOR * hldev->header.config.device_poll_millis);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp_reg->rts_access_steer_ctrl);
  
  	if (val64 & VXGE_HAL_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
  		status = VXGE_HAL_OK;
  	} else {
  		status = VXGE_HAL_FAIL;
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_udp_rth_disable - Enable UDP/RTH.
   * @vpath_handle: Vpath handle.
   *
   * Disable udp rth
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_udp_rth_disable(vxge_hal_vpath_h vpath_handle)
  {
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	status = __hal_vpath_udp_rth_set(hldev,
  	    vpath->vp_id,
  	    FALSE);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__,
  	    status);
  
  	return (status);
  }
  
  /*
   * __hal_vpath_rts_table_get - Get the entries from RTS access tables
   * @vpath_handle: Vpath handle.
   * @action: Identifies the action to take on the specified entry. The
   *	    interpretation of this field depends on the DATA_STRUCT_SEL field
   *	    DA, VID, ETYPE, PN, RANGE_PN:
   *		8'd0 - ADD_ENTRY (Add an entry to the table. This command may be
   *		rejected by management/administration).
   *		8'd1 - DELETE_ENTRY (Add an entry to the table. This command may
   *		be rejected by management/administration)
   *		8'd2 - LIST_FIRST_ENTRY
   *		8'd3 - LIST_NEXT_ENTRY
   *		RTH_GEN_CFG, RTH_IT, RTH_JHASH_CFG, RTH_MASK, RTH_KEY, QOS, DS:
   *		8'd0 - READ_ENTRY
   *		  8'd1 - WRITE_ENTRY
   *		Note: This field is updated by the H/W during an operation and
   *		is used to report additional TBD status information back to the
   *		host.
   * @rts_table: Identifies the RTS data structure (i.e. lookup table) to access.
   *		0; DA; Destination Address 1; VID; VLAN ID 2; ETYPE; Ethertype
   *		3; PN; Layer 4 Port Number 4; Reserved 5; RTH_GEN_CFG; Receive
   *		Traffic Hashing General Configuration 6; RTH_IT; Receive Traffic
   *		Hashing Indirection Table 7; RTH_JHASH_CFG; Receive-Traffic
   *		Hashing Jenkins Hash Configuration 8; RTH_MASK; Receive Traffic
   *		Hashing Mask 9; RTH_KEY; Receive-Traffic Hashing Key 10; QOS;
   *		VLAN Quality of Service 11; DS; IP Differentiated Services
   * @offset: Applies to RTH_IT, RTH_MASK, RTH_KEY, QOS, DS structures only.
   *		The interpretation of this field depends on the DATA_STRUCT_SEL
   *		field:
   *		RTH_IT - {BUCKET_NUM[0:7]} (Bucket Number)
   *		RTH_MASK - {5'b0,
   *		INDEX_8BYTE} (8-byte Index)
   *		RTH_KEY - {5'b0, INDEX_8BYTE} (8-byte Index)
   *		QOS - {5'b0, PRI} (Priority)
   *		DS - {5'b0, CP} (Codepoint)
   * @data1: Pointer to the data 1 to be read from the table
   * @data2: Pointer to the data 2 to be read from the table
   *
   * Read from the RTS table
   *
   */
  vxge_hal_status_e
  __hal_vpath_rts_table_get(
      vxge_hal_vpath_h vpath_handle,
      u32 action,
      u32 rts_table,
      u32 offset,
      u64 *data1,
      u64 *data2)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert((vpath_handle != NULL) &&
  	    (data1 != NULL) && (data2 != NULL));
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", action = %d, rts_table = %d, "
  	    "offset = %d, data1 = 0x"VXGE_OS_STXFMT", data2 = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, action, rts_table, offset, (ptr_t) data1,
  	    (ptr_t) data2);
  
  	val64 = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION(action) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(rts_table) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET(offset);
  
  
  	if ((rts_table ==
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_SOLO_IT) ||
  	    (rts_table ==
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT) ||
  	    (rts_table ==
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MASK) ||
  	    (rts_table ==
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_KEY)) {
  		val64 |= VXGE_HAL_RTS_ACCESS_STEER_CTRL_TABLE_SEL;
  	}
  
  	vxge_hal_pio_mem_write32_lower(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 32),
  	    &vpath->vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 0),
  	    &vpath->vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	status = vxge_hal_device_register_poll(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rts_access_steer_ctrl, 0,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE,
  	    WAIT_FACTOR * hldev->header.config.device_poll_millis);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	val64 = vxge_os_pio_mem_read64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rts_access_steer_ctrl);
  
  	if (!(val64 & VXGE_HAL_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS)) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_FAIL);
  		return (VXGE_HAL_FAIL);
  	}
  
  	*data1 = vxge_os_pio_mem_read64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rts_access_steer_data0);
  
  	if ((rts_table ==
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DA) ||
  	    (rts_table ==
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT)) {
  		*data2 = vxge_os_pio_mem_read64(
  		    hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->rts_access_steer_data1);
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * __hal_vpath_rts_table_set - Set the entries of RTS access tables
   * @vpath_handle: Vpath handle.
   * @action: Identifies the action to take on the specified entry. The
   *		interpretation of this field depends on DATA_STRUCT_SEL field
   *		DA, VID, ETYPE, PN, RANGE_PN:
   *		8'd0 - ADD_ENTRY (Add an entry to the table. This command may be
   *		   rejected by management/administration).
   *		8'd1 - DELETE_ENTRY (Add an entry to the table. This command may
   *		   be rejected by management/administration)
   *		8'd2 - LIST_FIRST_ENTRY
   *		8'd3 - LIST_NEXT_ENTRY
   *		RTH_GEN_CFG, RTH_IT, RTH_JHASH_CFG, RTH_MASK, RTH_KEY, QOS, DS:
   *		8'd0 - READ_ENTRY
   *		  8'd1 - WRITE_ENTRY
   *		Note: This field is updated by the H/W during an operation and
   *		is used to report additional TBD status information back to the
   *		host.
   * @rts_table: Identifies the RTS data structure (i.e. lookup table) to access.
   *		0; DA; Destination Address 1; VID; VLAN ID 2; ETYPE; Ethertype
   *		3; PN; Layer 4 Port Number 4; Reserved 5; RTH_GEN_CFG; Receive
   *		Traffic Hashing General Configuration 6; RTH_IT; Receive Traffic
   *		Hashing Indirection Table 7; RTH_JHASH_CFG; Receive-Traffic
   *		Hashing Jenkins Hash Configuration 8; RTH_MASK; Receive Traffic
   *		Hashing Mask 9; RTH_KEY; Receive-Traffic Hashing Key 10; QOS;
   *		VLAN Quality of Service 11; DS; IP Differentiated Services
   * @offset: Applies to RTH_IT, RTH_MASK, RTH_KEY, QOS, DS structures only.
   *		The interpretation of this field depends on the DATA_STRUCT_SEL
   *		field:
   *		RTH_IT - {BUCKET_NUM[0:7]} (Bucket Number)
   *		RTH_MASK - {5'b0,
   *		INDEX_8BYTE} (8-byte Index)
   *		RTH_KEY - {5'b0, INDEX_8BYTE} (8-byte Index)
   *		QOS - {5'b0, PRI} (Priority)
   *		DS - {5'b0, CP} (Codepoint)
   * @data1: data 1 to be written to the table
   * @data2: data 2 to be written to the table
   *
   * Read from the RTS table
   *
   */
  vxge_hal_status_e
  __hal_vpath_rts_table_set(
      vxge_hal_vpath_h vpath_handle,
      u32 action,
      u32 rts_table,
      u32 offset,
      u64 data1,
      u64 data2)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", action = %d, rts_table = %d, "
  	    "offset = %d, data1 = 0x"VXGE_OS_LLXFMT", data2 = 0x"VXGE_OS_LLXFMT,
  	    (ptr_t) vpath_handle, action, rts_table, offset, data1, data2);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    data1,
  	    &vpath->vp_reg->rts_access_steer_data0);
  	vxge_os_wmb();
  
  	if ((rts_table ==
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DA) ||
  	    (rts_table ==
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT)) {
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    data2,
  		    &vpath->vp_reg->rts_access_steer_data1);
  		vxge_os_wmb();
  
  	}
  
  	val64 = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION(action) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(rts_table) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET(offset);
  
  	vxge_hal_pio_mem_write32_lower(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 32),
  	    &vpath->vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 0),
  	    &vpath->vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	status = vxge_hal_device_register_poll(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rts_access_steer_ctrl, 0,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE,
  	    WAIT_FACTOR * hldev->header.config.device_poll_millis);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	val64 = vxge_os_pio_mem_read64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rts_access_steer_ctrl);
  
  	if (val64 & VXGE_HAL_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
  
  		status = VXGE_HAL_OK;
  
  	} else {
  		status = VXGE_HAL_FAIL;
  	}
  
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  
  /*
   * vxge_hal_vpath_mac_addr_add - Add the mac address entry for this vpath
   *		  to MAC address table.
   * @vpath_handle: Vpath handle.
   * @macaddr: MAC address to be added for this vpath into the list
   * @macaddr_mask: MAC address mask for macaddr
   * @duplicate_mode: Duplicate MAC address add mode. Please see
   *		vxge_hal_vpath_mac_addr_add_mode_e {}
   *
   * Adds the given mac address and mac address mask into the list for this
   * vpath.
   * see also: vxge_hal_vpath_mac_addr_delete, vxge_hal_vpath_mac_addr_get and
   * vxge_hal_vpath_mac_addr_get_next
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_mac_addr_add(
      vxge_hal_vpath_h vpath_handle,
      macaddr_t macaddr,
      macaddr_t macaddr_mask,
      vxge_hal_vpath_mac_addr_add_mode_e duplicate_mode)
  {
  	u32 i;
  	u64 data1 = 0ULL;
  	u64 data2 = 0ULL;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT", "
  	    "macaddr = %02x-%02x-%02x-%02x-%02x-%02x, "
  	    "macaddr_mask = %02x-%02x-%02x-%02x-%02x-%02x",
  	    (ptr_t) vpath_handle, macaddr[0], macaddr[1], macaddr[2],
  	    macaddr[3], macaddr[4], macaddr[5], macaddr_mask[0],
  	    macaddr_mask[1], macaddr_mask[2], macaddr_mask[3],
  	    macaddr_mask[4], macaddr_mask[5]);
  
  	for (i = 0; i < VXGE_HAL_ETH_ALEN; i++) {
  		data1 <<= 8;
  		data1 |= (u8) macaddr[i];
  	}
  
  	for (i = 0; i < VXGE_HAL_ETH_ALEN; i++) {
  		data2 <<= 8;
  		data2 |= (u8) macaddr_mask[i];
  	}
  
  	switch (duplicate_mode) {
  	case VXGE_HAL_VPATH_MAC_ADDR_ADD_DUPLICATE:
  		i = 0;
  		break;
  
  	case VXGE_HAL_VPATH_MAC_ADDR_DISCARD_DUPLICATE:
  		i = 1;
  		break;
  
  	case VXGE_HAL_VPATH_MAC_ADDR_REPLACE_DUPLICATE:
  		i = 2;
  		break;
  
  	default:
  		i = 0;
  		break;
  	}
  
  	status = __hal_vpath_rts_table_set(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_ADD_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DA,
  	    0,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_DA_MAC_ADDR(data1),
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA1_DA_MAC_ADDR_MASK(data2) |
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA1_DA_MAC_ADDR_MODE(i));
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__,
  	    status);
  
  	return (status);
  }
  
  /*
   * __hal_vpath_hw_addr_get - Get the hw address entry for this vpath
   *		  from MAC address table.
   * @pdev: PCI device object.
   * @regh0: BAR0 mapped memory handle, or simply PCI device @pdev
   * (Linux and the rest.)
   * @vp_id: Vpath id
   * @vpath_reg: Pointer to vpath registers
   * @macaddr: First MAC address entry for this vpath in the list
   * @macaddr_mask: MAC address mask for macaddr
   *
   * Returns the first mac address and mac address mask in the list for this
   * vpath.
   * see also: vxge_hal_vpath_mac_addr_get_next
   *
   */
  vxge_hal_status_e
  __hal_vpath_hw_addr_get(
      pci_dev_h pdev,
      pci_reg_h regh0,
      u32 vp_id,
      vxge_hal_vpath_reg_t *vpath_reg,
      macaddr_t macaddr,
      macaddr_t macaddr_mask)
  {
  	u32 i;
  	u64 val64;
  	u64 data1 = 0ULL;
  	u64 data2 = 0ULL;
  	u64 action = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_LIST_FIRST_ENTRY;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert((vpath_reg != NULL) && (macaddr != NULL) &&
  	    (macaddr_mask != NULL));
  
  	vxge_hal_trace_log_driver("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_driver(
  	    "pdev = 0x"VXGE_OS_STXFMT", regh0 = 0x"VXGE_OS_STXFMT", "
  	    "vp_id = %d, vpath_reg = 0x"VXGE_OS_STXFMT", "
  	    "macaddr = 0x"VXGE_OS_STXFMT", macaddr_mask = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) pdev, (ptr_t) regh0, vp_id, (ptr_t) vpath_reg,
  	    (ptr_t) macaddr, (ptr_t) macaddr_mask);
  
  	/* CONSTCOND */
  	while (TRUE) {
  
  		val64 = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION(action) |
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DA) |
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE |
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET(0);
  
  		vxge_hal_pio_mem_write32_lower(pdev,
  		    regh0,
  		    (u32) bVAL32(val64, 32),
  		    &vpath_reg->rts_access_steer_ctrl);
  
  		vxge_os_wmb();
  
  		vxge_hal_pio_mem_write32_upper(pdev,
  		    regh0,
  		    (u32) bVAL32(val64, 0),
  		    &vpath_reg->rts_access_steer_ctrl);
  
  		vxge_os_wmb();
  
  		status = vxge_hal_device_register_poll(pdev, regh0,
  		    &vpath_reg->rts_access_steer_ctrl, 0,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE,
  		    WAIT_FACTOR * VXGE_HAL_DEF_DEVICE_POLL_MILLIS);
  
  		if (status != VXGE_HAL_OK) {
  
  			vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, status);
  			return (status);
  		}
  
  		val64 = vxge_os_pio_mem_read64(pdev, regh0,
  		    &vpath_reg->rts_access_steer_ctrl);
  
  		if (val64 & VXGE_HAL_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
  			data1 = vxge_os_pio_mem_read64(pdev, regh0,
  			    &vpath_reg->rts_access_steer_data0);
  			data2 = vxge_os_pio_mem_read64(pdev, regh0,
  			    &vpath_reg->rts_access_steer_data1);
  			data1 =
  			    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_DA_MAC_ADDR(data1);
  			data2 =
  			    VXGE_HAL_RTS_ACCESS_STEER_DATA1_GET_DA_MAC_ADDR_MASK(data2);
  
  			if (VXGE_HAL_IS_UNICAST(data1)) {
  
  				for (i = VXGE_HAL_ETH_ALEN; i > 0; i--) {
  					macaddr[i - 1] = (u8) (data1 & 0xFF);
  					data1 >>= 8;
  				}
  				for (i = VXGE_HAL_ETH_ALEN; i > 0; i--) {
  				    macaddr_mask[i - 1] = (u8) (data2 & 0xFF);
  				    data2 >>= 8;
  				}
  				status = VXGE_HAL_OK;
  				break;
  			}
  			action = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_LIST_NEXT_ENTRY;
  		} else {
  			status = VXGE_HAL_FAIL;
  			break;
  		}
  	}
  
  	vxge_hal_trace_log_driver("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_mac_addr_get - Get the first mac address entry for this vpath
   *		  from MAC address table.
   * @vpath_handle: Vpath handle.
   * @macaddr: First MAC address entry for this vpath in the list
   * @macaddr_mask: MAC address mask for macaddr
   *
   * Returns the first mac address and mac address mask in the list for this
   * vpath.
   * see also: vxge_hal_vpath_mac_addr_get_next
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_mac_addr_get(
      vxge_hal_vpath_h vpath_handle,
      macaddr_t macaddr,
      macaddr_t macaddr_mask)
  {
  	u32 i;
  	u64 data1 = 0ULL;
  	u64 data2 = 0ULL;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	status = __hal_vpath_rts_table_get(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_LIST_FIRST_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DA,
  	    0,
  	    &data1,
  	    &data2);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	data1 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_DA_MAC_ADDR(data1);
  
  	data2 = VXGE_HAL_RTS_ACCESS_STEER_DATA1_GET_DA_MAC_ADDR_MASK(data2);
  
  	for (i = VXGE_HAL_ETH_ALEN; i > 0; i--) {
  		macaddr[i - 1] = (u8) (data1 & 0xFF);
  		data1 >>= 8;
  	}
  
  	for (i = VXGE_HAL_ETH_ALEN; i > 0; i--) {
  		macaddr_mask[i - 1] = (u8) (data2 & 0xFF);
  		data2 >>= 8;
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__,
  	    status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_mac_addr_get_next - Get the next mac address entry for vpath
   *		  from MAC address table.
   * @vpath_handle: Vpath handle.
   * @macaddr: Next MAC address entry for this vpath in the list
   * @macaddr_mask: MAC address mask for macaddr
   *
   * Returns the next mac address and mac address mask in the list for this
   * vpath.
   * see also: vxge_hal_vpath_mac_addr_get
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_mac_addr_get_next(
      vxge_hal_vpath_h vpath_handle,
      macaddr_t macaddr,
      macaddr_t macaddr_mask)
  {
  	u32 i;
  	u64 data1 = 0ULL;
  	u64 data2 = 0ULL;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	status = __hal_vpath_rts_table_get(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_LIST_NEXT_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DA,
  	    0,
  	    &data1,
  	    &data2);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	data1 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_DA_MAC_ADDR(data1);
  
  	data2 = VXGE_HAL_RTS_ACCESS_STEER_DATA1_GET_DA_MAC_ADDR_MASK(data2);
  
  	for (i = VXGE_HAL_ETH_ALEN; i > 0; i--) {
  		macaddr[i - 1] = (u8) (data1 & 0xFF);
  		data1 >>= 8;
  	}
  
  	for (i = VXGE_HAL_ETH_ALEN; i > 0; i--) {
  		macaddr_mask[i - 1] = (u8) (data2 & 0xFF);
  		data2 >>= 8;
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  
  /*
   * vxge_hal_vpath_mac_addr_delete - Delete the mac address entry for this vpath
   *		  to MAC address table.
   * @vpath_handle: Vpath handle.
   * @macaddr: MAC address to be added for this vpath into the list
   * @macaddr_mask: MAC address mask for macaddr
   *
   * Delete the given mac address and mac address mask into the list for this
   * vpath.
   * see also: vxge_hal_vpath_mac_addr_add, vxge_hal_vpath_mac_addr_get and
   * vxge_hal_vpath_mac_addr_get_next
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_mac_addr_delete(
      vxge_hal_vpath_h vpath_handle,
      macaddr_t macaddr,
      macaddr_t macaddr_mask)
  {
  	u32 i;
  	u64 data1 = 0ULL;
  	u64 data2 = 0ULL;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT", "
  	    "macaddr = %02x-%02x-%02x-%02x-%02x-%02x, "
  	    "macaddr_mask = %02x-%02x-%02x-%02x-%02x-%02x",
  	    (ptr_t) vpath_handle, macaddr[0], macaddr[1], macaddr[2],
  	    macaddr[3], macaddr[4], macaddr[5], macaddr_mask[0],
  	    macaddr_mask[1], macaddr_mask[2], macaddr_mask[3],
  	    macaddr_mask[4], macaddr_mask[5]);
  
  	for (i = 0; i < VXGE_HAL_ETH_ALEN; i++) {
  		data1 <<= 8;
  		data1 |= (u8) macaddr[i];
  	}
  
  	for (i = 0; i < VXGE_HAL_ETH_ALEN; i++) {
  		data2 <<= 8;
  		data2 |= (u8) macaddr_mask[i];
  	}
  
  	status = __hal_vpath_rts_table_set(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_DELETE_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DA,
  	    0,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_DA_MAC_ADDR(data1),
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA1_DA_MAC_ADDR_MASK(data2));
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_vid_add - Add the vlan id entry for this vpath
   *		  to vlan id table.
   * @vpath_handle: Vpath handle.
   * @vid: vlan id to be added for this vpath into the list
   *
   * Adds the given vlan id into the list for this  vpath.
   * see also: vxge_hal_vpath_vid_delete, vxge_hal_vpath_vid_get and
   * vxge_hal_vpath_vid_get_next
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_vid_add(
      vxge_hal_vpath_h vpath_handle,
      u64 vid)
  {
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT", vid = %d",
  	    (ptr_t) vpath_handle, (u32) vid);
  
  	status = __hal_vpath_rts_table_set(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_ADD_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_VID,
  	    0,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_VLAN_ID(vid),
  	    0);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_vid_get - Get the first vid entry for this vpath
   *		  from vlan id table.
   * @vpath_handle: Vpath handle.
   * @vid: Buffer to return vlan id
   *
   * Returns the first vlan id in the list for this vpath.
   * see also: vxge_hal_vpath_vid_get_next
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_vid_get(
      vxge_hal_vpath_h vpath_handle,
      u64 *vid)
  {
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert((vpath_handle != NULL) && (vid != NULL));
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", vid = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, (ptr_t) vid);
  
  	status = __hal_vpath_rts_table_get(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_LIST_FIRST_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_VID,
  	    0,
  	    vid,
  	    NULL);
  
  	*vid = VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_VLAN_ID(*vid);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__,
  	    status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_vid_get_next - Get the next vid entry for this vpath
   *		  from vlan id table.
   * @vpath_handle: Vpath handle.
   * @vid: Buffer to return vlan id
   *
   * Returns the next vlan id in the list for this vpath.
   * see also: vxge_hal_vpath_vid_get
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_vid_get_next(
      vxge_hal_vpath_h vpath_handle,
      u64 *vid)
  {
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert((vpath_handle != NULL) && (vid != NULL));
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", vid = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, (ptr_t) vid);
  
  	status = __hal_vpath_rts_table_get(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_LIST_NEXT_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_VID,
  	    0,
  	    vid,
  	    NULL);
  
  	*vid = VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_VLAN_ID(*vid);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_vid_delete - Delete the vlan id entry for this vpath
   *		  to vlan id table.
   * @vpath_handle: Vpath handle.
   * @vid: vlan id to be added for this vpath into the list
   *
   * Adds the given vlan id into the list for this  vpath.
   * see also: vxge_hal_vpath_vid_add, vxge_hal_vpath_vid_get and
   * vxge_hal_vpath_vid_get_next
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_vid_delete(
      vxge_hal_vpath_h vpath_handle,
      u64 vid)
  {
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT", vid = %d",
  	    (ptr_t) vpath_handle, (u32) vid);
  
  	status = __hal_vpath_rts_table_set(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_DELETE_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_VID,
  	    0,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_VLAN_ID(vid),
  	    0);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__,
  	    status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_etype_add - Add the Ethertype entry for this vpath
   *		  to Ethertype table.
   * @vpath_handle: Vpath handle.
   * @etype: ethertype to be added for this vpath into the list
   *
   * Adds the given Ethertype into the list for this  vpath.
   * see also: vxge_hal_vpath_etype_delete, vxge_hal_vpath_etype_get and
   * vxge_hal_vpath_etype_get_next
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_etype_add(
      vxge_hal_vpath_h vpath_handle,
      u64 etype)
  {
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"
  	    VXGE_OS_STXFMT", etype = %d",
  	    (ptr_t) vpath_handle, (u32) etype);
  
  	status = __hal_vpath_rts_table_set(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_ADD_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_ETYPE,
  	    0,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_ETYPE(etype),
  	    0);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_etype_get - Get the first ethertype entry for this vpath
   *		  from Ethertype table.
   * @vpath_handle: Vpath handle.
   * @etype: Buffer to return Ethertype
   *
   * Returns the first ethype entry in the list for this vpath.
   * see also: vxge_hal_vpath_etype_get_next
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_etype_get(
      vxge_hal_vpath_h vpath_handle,
      u64 *etype)
  {
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert((vpath_handle != NULL) && (etype != NULL));
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", etype = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, (ptr_t) etype);
  
  	status = __hal_vpath_rts_table_get(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_LIST_FIRST_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_ETYPE,
  	    0,
  	    etype,
  	    NULL);
  
  	*etype = VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_ETYPE(*etype);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_etype_get_next - Get the next Ethertype entry for this vpath
   *		  from Ethertype table.
   * @vpath_handle: Vpath handle.
   * @etype: Buffer to return Ethwrtype
   *
   * Returns the next Ethwrtype in the list for this vpath.
   * see also: vxge_hal_vpath_etype_get
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_etype_get_next(
      vxge_hal_vpath_h vpath_handle,
      u64 *etype)
  {
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert((vpath_handle != NULL) && (etype != NULL));
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", etype = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, (ptr_t) etype);
  
  	status = __hal_vpath_rts_table_get(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_LIST_NEXT_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_ETYPE,
  	    0,
  	    etype,
  	    NULL);
  
  	*etype = VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_ETYPE(*etype);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__,
  	    status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_etype_delete - Delete the Ethertype entry for this vpath
   *		  to Ethertype table.
   * @vpath_handle: Vpath handle.
   * @etype: ethertype to be added for this vpath into the list
   *
   * Adds the given Ethertype into the list for this  vpath.
   * see also: vxge_hal_vpath_etype_add, vxge_hal_vpath_etype_get and
   * vxge_hal_vpath_etype_get_next
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_etype_delete(vxge_hal_vpath_h vpath_handle, u64 etype)
  {
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"
  	    VXGE_OS_STXFMT", etype = %d",
  	    (ptr_t) vpath_handle, (u32) etype);
  
  	status = __hal_vpath_rts_table_set(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_DELETE_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_ETYPE,
  	    0,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_ETYPE(etype),
  	    0);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_port_add - Add the port entry for this vpath
   *		  to port number table.
   * @vpath_handle: Vpath handle.
   * @port_type: if 0 - Src port or 1 - Dest port
   * @protocol: if 0 - TCP or 1 - UDP
   * @port: port to be added for this vpath into the list
   *
   * Adds the given port into the list for this  vpath.
   * see also: vxge_hal_vpath_port_delete, vxge_hal_vpath_port_get and
   * vxge_hal_vpath_port_get_next
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_port_add(
      vxge_hal_vpath_h vpath_handle,
      u32 port_type,
      u32 protocol,
      u32 port)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", port_type = %d, "
  	    "protocol = %d, port = %d", (ptr_t) vpath_handle, port_type,
  	    protocol, port);
  
  	val64 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_PN_PORT_NUM(port);
  
  	if (port_type)
  		val64 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_PN_SRC_DEST_SEL;
  
  	if (protocol)
  		val64 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_PN_TCP_UDP_SEL;
  
  	status = __hal_vpath_rts_table_set(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_ADD_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_PN,
  	    0,
  	    val64,
  	    0);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__,
  	    status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_port_get
   * Get the first port number entry for this vpath from port number table.
   * @vpath_handle: Vpath handle.
   * @port_type: Buffer to return if 0 - Src port or 1 - Dest port
   * @protocol: Buffer to return if 0 - TCP or 1 - UDP
   * @port: Buffer to return port number
   *
   * Returns the first port number entry in the list for this vpath.
   * see also: vxge_hal_vpath_port_get_next
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_port_get(
      vxge_hal_vpath_h vpath_handle,
      u32 *port_type,
      u32 *protocol,
      u32 *port)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert((vpath_handle != NULL) && (port_type != NULL) &&
  	    (protocol != NULL) && (port != NULL));
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", port_type = 0x"VXGE_OS_STXFMT
  	    ", protocol = 0x"VXGE_OS_STXFMT", port = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, (ptr_t) port_type, (ptr_t) protocol,
  	    (ptr_t) port);
  
  	status = __hal_vpath_rts_table_get(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_LIST_FIRST_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_PN,
  	    0,
  	    &val64,
  	    NULL);
  
  	*port_type =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_PN_SRC_DEST_SEL(val64);
  	*protocol =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_PN_TCP_UDP_SEL(val64);
  	*port = (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_PN_PORT_NUM(val64);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__,
  	    status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_port_get_next
   * Get the next port number entry for this vpath from port number table.
   * @vpath_handle: Vpath handle.
   * @port_type: Buffer to return if 0 - Src port or 1 - Dest port
   * @protocol: Buffer to return if 0 - TCP or 1 - UDP
   * @port: Buffer to return port number
   *
   * Returns the next port number entry in the list for this vpath.
   * see also: vxge_hal_vpath_port_get
   */
  vxge_hal_status_e
  vxge_hal_vpath_port_get_next(
      vxge_hal_vpath_h vpath_handle,
      u32 *port_type,
      u32 *protocol,
      u32 *port)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert((vpath_handle != NULL) && (port_type != NULL) &&
  	    (protocol != NULL) && (port != NULL));
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", port_type = 0x"VXGE_OS_STXFMT
  	    ", protocol = 0x"VXGE_OS_STXFMT", port = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, (ptr_t) port_type, (ptr_t) protocol,
  	    (ptr_t) port);
  
  	status = __hal_vpath_rts_table_get(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_LIST_NEXT_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_PN,
  	    0,
  	    &val64,
  	    NULL);
  
  	*port_type =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_PN_SRC_DEST_SEL(val64);
  
  	*protocol =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_PN_TCP_UDP_SEL(val64);
  
  	*port = (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_PN_PORT_NUM(val64);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__,
  	    status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_port_delete
   * Delete the port entry for this vpath to port number table.
   * @vpath_handle: Vpath handle.
   * @port_type: if 0 - Src port or 1 - Dest port
   * @protocol: if 0 - TCP or 1 - UDP
   * @port: port to be added for this vpath into the list
   *
   * Adds the given port into the list for this  vpath.
   * see also: vxge_hal_vpath_port_add, vxge_hal_vpath_port_get and
   * vxge_hal_vpath_port_get_next
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_port_delete(
      vxge_hal_vpath_h vpath_handle,
      u32 port_type,
      u32 protocol,
      u32 port)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", port_type = %d, "
  	    "protocol = %d, port = %d", (ptr_t) vpath_handle, port_type,
  	    protocol, port);
  
  	val64 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_PN_PORT_NUM(port);
  
  	if (port_type)
  		val64 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_PN_SRC_DEST_SEL;
  
  	if (protocol)
  		val64 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_PN_TCP_UDP_SEL;
  
  	status = __hal_vpath_rts_table_set(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_DELETE_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_PN,
  	    0,
  	    val64,
  	    0);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_rts_rth_set - Set/configure RTS hashing.
   * @vpath_handle: Virtual Path handle.
   * @algorithm: Algorithm Select
   * @hash_type: Hash Type
   * @bucket_size: no of least significant bits to be used for hashing.
   * @it_switch: Itable switch required
   *
   * Used to set/configure all RTS hashing related stuff.
   *
   * See also: vxge_hal_vpath_rts_rth_clr(), vxge_hal_vpath_rts_rth_itable_set().
   */
  vxge_hal_status_e
  vxge_hal_vpath_rts_rth_set(vxge_hal_vpath_h vpath_handle,
      vxge_hal_rth_algoritms_t algorithm,
      vxge_hal_rth_hash_types_t *hash_type,
      u16 bucket_size,
      u16 it_switch)
  {
  	u64 data0, data1;
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp;
  
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vp = (__hal_vpath_handle_t *) vpath_handle;
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", algorithm = %d, "
  	    "hash_type = 0x"VXGE_OS_STXFMT", bucket_size = %d",
  	    (ptr_t) vpath_handle, algorithm, (ptr_t) hash_type,
  	    bucket_size);
  
  	(void) __hal_vpath_rts_table_get(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_READ_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_GEN_CFG,
  	    0,
  	    &data0,
  	    &data1);
  
  	if (algorithm == RTH_ALG_NONE) {
  
  		data0 &= ~VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_GEN_RTH_EN;
  
  	} else {
  
  		if (it_switch) {
  
  			if (VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_GEN_ACTIVE_TABLE(
  			    data0))
  				data0 = 0;
  			else
  				data0 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_GEN_ACTIVE_TABLE;
  
  		} else {
  			data0 &= VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_GEN_ACTIVE_TABLE;
  
  		}
  
  		data0 |= VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_GEN_RTH_EN |
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_GEN_BUCKET_SIZE(bucket_size) |
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_GEN_ALG_SEL(algorithm);
  
  		if (hash_type->hash_type_tcpipv4_en)
  			data0 |=
  			    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_GEN_RTH_TCP_IPV4_EN;
  
  		if (hash_type->hash_type_ipv4_en)
  			data0 |= VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_GEN_RTH_IPV4_EN;
  
  		if (hash_type->hash_type_tcpipv6_en)
  			data0 |=
  			    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_GEN_RTH_TCP_IPV6_EN;
  
  		if (hash_type->hash_type_ipv6_en)
  			data0 |= VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_GEN_RTH_IPV6_EN;
  
  		if (hash_type->hash_type_tcpipv6ex_en)
  			data0 |=
  			    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_GEN_RTH_TCP_IPV6_EX_EN;
  
  		if (hash_type->hash_type_ipv6ex_en)
  			data0 |= VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_GEN_RTH_IPV6_EX_EN;
  
  	}
  
  	status = __hal_vpath_rts_table_set(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_WRITE_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_GEN_CFG,
  	    0,
  	    data0,
  	    0);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_rts_rth_get - Read RTS hashing.
   * @vpath_handle: Virtual Path handle.
   * @algorithm: Buffer to return Algorithm Select
   * @hash_type: Buffer to return Hash Type
   * @table_select: Buffer to return active Table
   * @bucket_size: Buffer to return no of least significant bits used for hashing.
   *
   * Used to read all RTS hashing related stuff.
   *
   * See also: vxge_hal_vpath_rts_rth_clr(), vxge_hal_vpath_rts_rth_itable_set(),
   *		vxge_hal_vpath_rts_rth_set().
   */
  vxge_hal_status_e
  vxge_hal_vpath_rts_rth_get(vxge_hal_vpath_h vpath_handle,
      vxge_hal_rth_algoritms_t *algorithm,
      vxge_hal_rth_hash_types_t *hash_type,
      u8 *table_select,
      u16 *bucket_size)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", algorithm = 0x"VXGE_OS_STXFMT
  	    ", hash_type = 0x"VXGE_OS_STXFMT", "
  	    "table_select = 0x"VXGE_OS_STXFMT", "
  	    "bucket_size = 0x"VXGE_OS_STXFMT, (ptr_t) vpath_handle,
  	    (ptr_t) algorithm, (ptr_t) hash_type,
  	    (ptr_t) table_select, (ptr_t) bucket_size);
  
  	status = __hal_vpath_rts_table_get(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_READ_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_GEN_CFG,
  	    0,
  	    &val64,
  	    NULL);
  
  	*algorithm = (vxge_hal_rth_algoritms_t)
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_GEN_ALG_SEL(val64);
  
  	hash_type->hash_type_tcpipv4_en = ((u32)
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_GEN_RTH_TCP_IPV4_EN(val64))
  	    ? 1 : 0;
  
  	hash_type->hash_type_ipv4_en = ((u32)
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_GEN_RTH_IPV4_EN(val64))
  	    ? 1 : 0;
  
  	hash_type->hash_type_tcpipv6_en = ((u32)
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_GEN_RTH_TCP_IPV6_EN(val64))
  	    ? 1 : 0;
  
  	hash_type->hash_type_ipv6_en = ((u32)
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_GEN_RTH_IPV6_EN(val64))
  	    ? 1 : 0;
  
  	hash_type->hash_type_tcpipv6ex_en = ((u32)
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_GEN_RTH_TCP_IPV6_EX_EN(
  	    val64)) ? 1 : 0;
  
  	hash_type->hash_type_ipv6ex_en = ((u32)
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_GEN_RTH_IPV6_EX_EN(val64))
  	    ? 1 : 0;
  
  	*table_select = ((u32)
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_GEN_ACTIVE_TABLE(val64))
  	    ? 1 : 0;
  
  	*bucket_size = (u16)
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_GEN_BUCKET_SIZE(val64);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_rts_rth_key_set - Configure 40byte secret for hash calc.
   *
   * @vpath_handle: Virtual Path ahandle.
   * @KeySize: Number of 64-bit words
   * @Key: upto 40-byte array of 64-bit values
   * This function configures the 40-byte secret which is used for hash
   * calculation.
   *
   * See also: vxge_hal_vpath_rts_rth_clr(), vxge_hal_vpath_rts_rth_set().
   */
  vxge_hal_status_e
  vxge_hal_vpath_rts_rth_key_set(vxge_hal_vpath_h vpath_handle,
      u8 KeySize, u64 *Key)
  {
  	u32 i;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert((vpath_handle != NULL) && (Key != NULL));
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", KeySize = %d"
  	    ", Key = 0x"VXGE_OS_STXFMT, (ptr_t) vpath_handle, KeySize,
  	    (ptr_t) Key);
  
  	for (i = 0; i < KeySize; i++) {
  
  		status = __hal_vpath_rts_table_set(vpath_handle,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_WRITE_ENTRY,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_KEY,
  		    i,
  		    vxge_os_htonll(*Key++),
  		    0);
  
  		if (status != VXGE_HAL_OK)
  			break;
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_rts_rth_key_get - Read 40byte secret for hash calc.
   *
   * @vpath_handle: Virtual Path ahandle.
   * @KeySize: Number of 64-bit words
   * @Key: Buffer to return the key
   * This function reads the 40-byte secret which is used for hash
   * calculation.
   *
   * See also: vxge_hal_vpath_rts_rth_clr(), vxge_hal_vpath_rts_rth_set(),
   *		vxge_hal_vpath_rts_rth_key_set().
   */
  vxge_hal_status_e
  vxge_hal_vpath_rts_rth_key_get(vxge_hal_vpath_h vpath_handle,
      u8 KeySize, u64 *Key)
  {
  	u32 i;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert((vpath_handle != NULL) && (Key != NULL));
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", KeySize = %d"
  	    ", Key = 0x"VXGE_OS_STXFMT, (ptr_t) vpath_handle, KeySize,
  	    (ptr_t) Key);
  
  	for (i = 0; i < KeySize; i++) {
  
  		status = __hal_vpath_rts_table_get(vpath_handle,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_READ_ENTRY,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_KEY,
  		    i,
  		    Key++,
  		    NULL);
  
  		if (status != VXGE_HAL_OK)
  			break;
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_rts_rth_jhash_cfg_set - Configure JHASH algorithm
   *
   * @vpath_handle: Virtual Path ahandle.
   * @golden_ratio: Golden ratio
   * @init_value: Initial value
   * This function configures JENKIN's HASH algorithm
   *
   * See also: vxge_hal_vpath_rts_rth_clr(), vxge_hal_vpath_rts_rth_set().
   */
  vxge_hal_status_e
  vxge_hal_vpath_rts_rth_jhash_cfg_set(vxge_hal_vpath_h vpath_handle,
      u32 golden_ratio, u32 init_value)
  {
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", golden_ratio = %d"
  	    ", init_value = %d", (ptr_t) vpath_handle, golden_ratio,
  	    init_value);
  
  	status = __hal_vpath_rts_table_set(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_WRITE_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_JHASH_CFG,
  	    0,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_JHASH_CFG_GOLDEN_RATIO(
  	    golden_ratio) |
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_JHASH_CFG_INIT_VALUE(
  	    init_value),
  	    0);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_rts_rth_jhash_cfg_get - Read JHASH algorithm
   *
   * @vpath_handle: Virtual Path ahandle.
   * @golden_ratio: Buffer to return Golden ratio
   * @init_value: Buffer to return Initial value
   * This function reads JENKIN's HASH algorithm
   *
   * See also: vxge_hal_vpath_rts_rth_clr(), vxge_hal_vpath_rts_rth_set(),
   *		vxge_hal_vpath_rts_rth_jhash_cfg_set().
   */
  vxge_hal_status_e
  vxge_hal_vpath_rts_rth_jhash_cfg_get(vxge_hal_vpath_h vpath_handle,
      u32 * golden_ratio, u32 *init_value)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", "
  	    "golden_ratio = 0x"VXGE_OS_STXFMT", init_value = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, (ptr_t) golden_ratio, (ptr_t) init_value);
  
  	status = __hal_vpath_rts_table_get(vpath_handle,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_READ_ENTRY,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_JHASH_CFG,
  	    0,
  	    &val64,
  	    NULL);
  
  	if (status != VXGE_HAL_OK) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	*golden_ratio = (u32)
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_JHASH_CFG_GOLDEN_RATIO(
  	    val64);
  
  	*init_value = (u32)
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_JHASH_CFG_INIT_VALUE(
  	    val64);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_rts_rth_mask_set - Set/configure JHASH mask.
   * @vpath_handle: Virtual Path ahandle.
   * @table_size: Size of the mask table
   * @hash_mask_ipv6sa: IPv6SA Hash Mask
   * @hash_mask_ipv6da: IPv6DA Hash Mask
   * @hash_mask_ipv4sa: IPv4SA Hash Mask
   * @hash_mask_ipv4da: IPv4DA Hash Mask
   * @hash_mask_l4sp: L4SP Hash Mask
   * @hash_mask_l4dp: L4DP Hash Mask
   *
   * Used to set/configure indirection table.
   * It enables the required no of entries in the IT.
   * It adds entries to the IT.
   *
   * See also: vxge_hal_vpath_rts_rth_clr(), vxge_hal_vpath_rts_rth_set().
   */
  vxge_hal_status_e
  vxge_hal_vpath_rts_rth_mask_set(vxge_hal_vpath_h vpath_handle,
      u32 table_size,
      u32 *hash_mask_ipv6sa,
      u32 *hash_mask_ipv6da,
      u32 *hash_mask_ipv4sa,
      u32 *hash_mask_ipv4da,
      u32 *hash_mask_l4sp,
      u32 *hash_mask_l4dp)
  {
  	u32 i;
  	u64 val64;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert((vpath_handle != NULL) && (hash_mask_ipv6sa != NULL) &&
  	    (hash_mask_ipv6da != NULL) && (hash_mask_ipv4sa != NULL) &&
  	    (hash_mask_ipv4da != NULL) && (hash_mask_l4sp != NULL) &&
  	    (hash_mask_l4dp != NULL));
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", "
  	    "table_size = %d, hash_mask_ipv6sa = 0x"VXGE_OS_STXFMT
  	    ", hash_mask_ipv6da = 0x"VXGE_OS_STXFMT
  	    ", hash_mask_ipv4sa = 0x"VXGE_OS_STXFMT
  	    ", hash_mask_ipv4da = 0x"VXGE_OS_STXFMT
  	    ", hash_mask_l4sp = 0x"VXGE_OS_STXFMT
  	    ", hash_mask_l4dp = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, table_size, (ptr_t) hash_mask_ipv6sa,
  	    (ptr_t) hash_mask_ipv6da, (ptr_t) hash_mask_ipv4sa,
  	    (ptr_t) hash_mask_ipv4da, (ptr_t) hash_mask_l4sp,
  	    (ptr_t) hash_mask_l4dp);
  
  	for (i = 0; i < table_size; i++) {
  
  		val64 =
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_MASK_IPV6_SA_MASK(
  		    *hash_mask_ipv6sa++) |
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_MASK_IPV6_DA_MASK(
  		    *hash_mask_ipv6da++) |
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_MASK_IPV4_SA_MASK(
  		    *hash_mask_ipv4sa++) |
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_MASK_IPV4_DA_MASK(
  		    *hash_mask_ipv4da++) |
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_MASK_L4SP_MASK(
  		    *hash_mask_l4sp++) |
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_MASK_L4DP_MASK(
  		    *hash_mask_l4dp++);
  
  		status = __hal_vpath_rts_table_set(vpath_handle,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_WRITE_ENTRY,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MASK,
  		    i,
  		    val64,
  		    0);
  
  		if (status != VXGE_HAL_OK)
  			break;
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_rts_rth_mask_get - Read JHASH mask.
   * @vpath_handle: Virtual Path ahandle.
   * @table_size: Size of the mask table
   * @hash_mask_ipv6sa: Buffer to return IPv6SA Hash Mask
   * @hash_mask_ipv6da: Buffer to return IPv6DA Hash Mask
   * @hash_mask_ipv4sa: Buffer to return IPv4SA Hash Mask
   * @hash_mask_ipv4da: Buffer to return IPv4DA Hash Mask
   * @hash_mask_l4sp: Buffer to return L4SP Hash Mask
   * @hash_mask_l4dp: Buffer to return L4DP Hash Mask
   *
   * Used to read rth mask.
   *
   * See also: vxge_hal_vpath_rts_rth_clr(), vxge_hal_vpath_rts_rth_set(),
   *	  vxge_hal_vpath_rts_rth_mask_set().
   */
  vxge_hal_status_e
  vxge_hal_vpath_rts_rth_mask_get(vxge_hal_vpath_h vpath_handle,
      u32 table_size,
      u32 *hash_mask_ipv6sa,
      u32 *hash_mask_ipv6da,
      u32 *hash_mask_ipv4sa,
      u32 *hash_mask_ipv4da,
      u32 *hash_mask_l4sp,
      u32 *hash_mask_l4dp)
  {
  	u32 i;
  	u64 val64;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert((vpath_handle != NULL) && (hash_mask_ipv6sa != NULL) &&
  	    (hash_mask_ipv6da != NULL) && (hash_mask_ipv4sa != NULL) &&
  	    (hash_mask_ipv4da != NULL) && (hash_mask_l4sp != NULL) &&
  	    (hash_mask_l4dp != NULL));
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", "
  	    "table_size = %d, hash_mask_ipv6sa = 0x"VXGE_OS_STXFMT
  	    ", hash_mask_ipv6da = 0x"VXGE_OS_STXFMT
  	    ", hash_mask_ipv4sa = 0x"VXGE_OS_STXFMT
  	    ", hash_mask_ipv4da = 0x"VXGE_OS_STXFMT
  	    ", hash_mask_l4sp = 0x"VXGE_OS_STXFMT
  	    ", hash_mask_l4dp = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, table_size, (ptr_t) hash_mask_ipv6sa,
  	    (ptr_t) hash_mask_ipv6da, (ptr_t) hash_mask_ipv4sa,
  	    (ptr_t) hash_mask_ipv4da, (ptr_t) hash_mask_l4sp,
  	    (ptr_t) hash_mask_l4dp);
  
  	for (i = 0; i < table_size; i++) {
  
  		status = __hal_vpath_rts_table_get(vpath_handle,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_READ_ENTRY,
  		    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MASK,
  		    i,
  		    &val64,
  		    NULL);
  
  		if (status != VXGE_HAL_OK)
  			break;
  
  		*hash_mask_ipv6sa++ = (u32)
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_MASK_IPV6_SA_MASK(
  		    val64);
  
  		*hash_mask_ipv6da++ = (u32)
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_MASK_IPV6_DA_MASK(
  		    val64);
  
  		*hash_mask_ipv4sa++ = (u32)
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_MASK_IPV4_SA_MASK(
  		    val64);
  
  		*hash_mask_ipv4da++ = (u32)
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_MASK_IPV4_DA_MASK(
  		    val64);
  
  		*hash_mask_l4sp++ = (u32)
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_MASK_L4SP_MASK(val64);
  
  		*hash_mask_l4dp++ = (u32)
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_MASK_L4DP_MASK(val64);
  
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_rts_rth_itable_set - Set/configure indirection table (IT).
   * @vpath_handles: Virtual Path handles.
   * @vpath_count: Number of vpath handles passed in vpath_handles
   * @itable: Pointer to indirection table
   * @itable_size: Number of entries in itable
   *
   * Used to set/configure indirection table.
   * It enables the required no of entries in the IT.
   * It adds entries to the IT.
   *
   * See also: vxge_hal_vpath_rts_rth_clr(), vxge_hal_vpath_rts_rth_set().
   */
  vxge_hal_status_e
  vxge_hal_vpath_rts_rth_itable_set(vxge_hal_vpath_h *vpath_handles,
      u32 vpath_count,
      u8 *itable,
      u32 itable_size)
  {
  	u32 i, j, k, l, items[4];
  	u64 data0;
  	u64 data1;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handles[0];
  
  	vxge_assert((vpath_handles != NULL) && (itable != NULL));
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", vpath_count = %d, "
  	    "itable = 0x"VXGE_OS_STXFMT", itable_size = %d",
  	    (ptr_t) vpath_handles, vpath_count, (ptr_t) itable, itable_size);
  
  	if (hldev->header.config.rth_it_type == VXGE_HAL_RTH_IT_TYPE_SOLO_IT) {
  
  		for (j = 0; j < itable_size; j++) {
  
  			data1 = 0;
  
  			data0 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_SOLO_IT_BUCKET_DATA(
  			    itable[j]);
  
  			status = __hal_vpath_rts_table_set(vpath_handles[0],
  			    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_WRITE_ENTRY,
  			    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_SOLO_IT,
  			    j,
  			    data0,
  			    data1);
  
  			if (status != VXGE_HAL_OK) {
  				vxge_hal_trace_log_vpath(
  				    "<== %s:%s:%d Result: %d",
  				    __FILE__, __func__, __LINE__,
  				    status);
  
  				return (status);
  			}
  		}
  
  		for (j = 0; j < itable_size; j++) {
  
  			data1 = 0;
  
  			data0 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_SOLO_IT_ENTRY_EN |
  			    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_SOLO_IT_BUCKET_DATA(itable[j]);
  
  			status = __hal_vpath_rts_table_set(vpath_handles[itable[j]],
  			    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_WRITE_ENTRY,
  			    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_SOLO_IT,
  			    j, data0, data1);
  
  			if (status != VXGE_HAL_OK) {
  				vxge_hal_trace_log_vpath(
  				    "<== %s:%s:%d Result: %d",
  				    __FILE__, __func__, __LINE__,
  				    status);
  				return (status);
  			}
  		}
  
  	} else {
  		for (i = 0; i < vpath_count; i++) {
  
  			for (k = 0, j = 0; k < itable_size; k++) {
  
  				if (itable[k] != i)
  					continue;
  
  				for (l = j; l < 4; l++)
  					items[l] = k;
  
  				if ((j++ == 3) || (k == (itable_size - 1))) {
  
  					data0 =
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_ITEM0_BUCKET_NUM(
  					    items[0]) |
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_ITEM0_ENTRY_EN |
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_ITEM0_BUCKET_DATA(
  					    itable[items[0]]) |
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_ITEM1_BUCKET_NUM(
  					    items[1]) |
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_ITEM1_ENTRY_EN |
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_ITEM1_BUCKET_DATA(
  					    itable[items[1]]);
  
  					data1 =
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA1_RTH_ITEM0_BUCKET_NUM(
  					    items[2]) |
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA1_RTH_ITEM0_ENTRY_EN |
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA1_RTH_ITEM0_BUCKET_DATA(
  					    itable[items[2]]) |
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA1_RTH_ITEM1_BUCKET_NUM(
  					    items[3]) |
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA1_RTH_ITEM1_ENTRY_EN |
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA1_RTH_ITEM1_BUCKET_DATA(
  					    itable[items[3]]);
  
  					status =
  					    __hal_vpath_rts_table_set(vpath_handles[i],
  					    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_WRITE_ENTRY,
  					    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT,
  					    0,
  					    data0,
  					    data1);
  
  					if (status != VXGE_HAL_OK) {
  						vxge_hal_trace_log_vpath(
  						    "<== %s:%s:%d  Result: %d",
  						    __FILE__, __func__,
  						    __LINE__, status);
  
  						return (status);
  					}
  
  					j = 0;
  				}
  			}
  		}
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_rts_rth_itable_get - Read indirection table(IT).
   * @vpath_handles: Virtual Path handles.
   * @vpath_count: Number of vpath handles passed in vpath_handles
   * @itable: Pointer to the buffer to return indirection table
   * @itable_size: pointer to buffer to return Number of entries in itable
   *
   * Used to read indirection table.
   *
   * See also: vxge_hal_vpath_rts_rth_clr(), vxge_hal_vpath_rts_rth_set(),
   *		vxge_hal_vpath_rts_rth_itable_set().
   */
  vxge_hal_status_e
  vxge_hal_vpath_rts_rth_itable_get(vxge_hal_vpath_h *vpath_handles,
      u32 vpath_count,
      u8 *itable,
      u32 itable_size)
  {
  	u32 i, j;
  	u64 data0;
  	u64 data1;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handles[0];
  
  	vxge_assert((vpath_handles != NULL) && (itable != NULL));
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", vpath_count = %d, "
  	    "itable = 0x"VXGE_OS_STXFMT", itable_size = %d",
  	    (ptr_t) vpath_handles, vpath_count, (ptr_t) itable, itable_size);
  
  	if (hldev->header.config.rth_it_type == VXGE_HAL_RTH_IT_TYPE_SOLO_IT) {
  
  		for (i = 0; i < vpath_count; i++) {
  
  			for (j = 0; j < itable_size; j++) {
  
  				status = __hal_vpath_rts_table_get(vpath_handles[i],
  				    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_READ_ENTRY,
  				    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_SOLO_IT,
  				    j,
  				    &data0,
  				    &data1);
  
  				if (status != VXGE_HAL_OK) {
  					vxge_hal_trace_log_vpath(
  					    "<== %s:%s:%d Result: %d",
  					    __FILE__, __func__, __LINE__,
  					    status);
  
  					return (status);
  				}
  
  				if ((u8) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_SOLO_IT_ENTRY_EN(data0)) {
  					itable[j] = (u8) i;
  				}
  			}
  		}
  	} else {
  
  		for (i = 0; i < vpath_count; i++) {
  
  			for (j = 0; j < itable_size; ) {
  
  				data0 = 0;
  				data1 = 0;
  
  				if (j < itable_size)
  					data0 =
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_ITEM0_BUCKET_NUM(j);
  
  				if (j + 1 < itable_size)
  					data0 |= VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_ITEM1_BUCKET_NUM(j + 1);
  
  				if (j + 2 < itable_size)
  					data1 = VXGE_HAL_RTS_ACCESS_STEER_DATA1_RTH_ITEM0_BUCKET_NUM(j + 2);
  
  				if (j + 3 < itable_size)
  					data1 |= VXGE_HAL_RTS_ACCESS_STEER_DATA1_RTH_ITEM1_BUCKET_NUM(j + 3);
  
  				status = __hal_vpath_rts_table_get(
  				    vpath_handles[i],
  				    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_READ_ENTRY,
  				    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT,
  				    0, &data0, &data1);
  
  				if (status != VXGE_HAL_OK) {
  					vxge_hal_trace_log_vpath(
  					    "<== %s:%s:%d Result: %d",
  					    __FILE__, __func__, __LINE__,
  					    status);
  
  					return (status);
  				}
  
  				if (j < itable_size) {
  					if ((u8)
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_ITEM0_ENTRY_EN(data0)) {
  						itable[j] = (u8) i;
  					}
  
  					j++;
  				}
  
  				if (j < itable_size) {
  					if ((u8)
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_RTH_ITEM1_ENTRY_EN(data0)) {
  						itable[j] = (u8) i;
  					}
  					j++;
  				}
  
  				if (j < itable_size) {
  					if ((u8)
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA1_GET_RTH_ITEM0_ENTRY_EN(data1)) {
  						itable[j] = (u8) i;
  					}
  					j++;
  				}
  
  				if (j < itable_size) {
  					if ((u8)
  					    VXGE_HAL_RTS_ACCESS_STEER_DATA1_GET_RTH_ITEM1_ENTRY_EN(data1)) {
  						itable[j] = (u8) i;
  					}
  					j++;
  				}
  			}
  		}
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_rts_rth_clr - Clear RTS hashing.
   * @vpath_handles: Virtual Path handles.
   * @vpath_count: Number of vpath handles passed in vpath_handles
   *
   * This function is used to clear all RTS hashing related stuff.
   *
   * See also: vxge_hal_vpath_rts_rth_set(), vxge_hal_vpath_rts_rth_itable_set().
   */
  vxge_hal_status_e
  vxge_hal_vpath_rts_rth_clr(
      vxge_hal_vpath_h *vpath_handles,
      u32 vpath_count)
  {
  	u64 data0, data1;
  	u32 i, j;
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert(vpath_handles != NULL);
  
  	vp = (__hal_vpath_handle_t *) vpath_handles[0];
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handles = 0x"VXGE_OS_STXFMT", vpath_count = %d",
  	    (ptr_t) vpath_handles, vpath_count);
  
  	if (hldev->header.config.rth_it_type == VXGE_HAL_RTH_IT_TYPE_SOLO_IT) {
  
  		for (j = 0; j < VXGE_HAL_MAX_ITABLE_ENTRIES; j++) {
  
  			data0 = 0;
  			data1 = 0;
  
  			status = __hal_vpath_rts_table_set(vpath_handles[0],
  			    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_WRITE_ENTRY,
  			    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_SOLO_IT,
  			    j,
  			    data0,
  			    data1);
  
  			if (status != VXGE_HAL_OK) {
  				vxge_hal_trace_log_vpath(
  				    "<== %s:%s:%d Result: %d",
  				    __FILE__, __func__, __LINE__,
  				    status);
  
  				return (status);
  			}
  		}
  	} else {
  		for (i = 0; i < vpath_count; i++) {
  
  			for (j = 0; j < VXGE_HAL_MAX_ITABLE_ENTRIES; j += 4) {
  
  				data0 =
  				    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_ITEM0_BUCKET_NUM(j) |
  				    VXGE_HAL_RTS_ACCESS_STEER_DATA0_RTH_ITEM1_BUCKET_NUM(j + 1);
  
  				data1 =
  				    VXGE_HAL_RTS_ACCESS_STEER_DATA1_RTH_ITEM0_BUCKET_NUM(j + 2) |
  				    VXGE_HAL_RTS_ACCESS_STEER_DATA1_RTH_ITEM1_BUCKET_NUM(j + 3);
  
  				status = __hal_vpath_rts_table_set(vpath_handles[i],
  				    VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_WRITE_ENTRY,
  				    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT,
  				    0,
  				    data0,
  				    data1);
  
  				if (status != VXGE_HAL_OK) {
  					vxge_hal_trace_log_vpath(
  					    "<== %s:%s:%d Result: %d",
  					    __FILE__, __func__, __LINE__,
  					    status);
  					return (status);
  				}
  			}
  		}
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_promisc_enable - Enable promiscuous mode.
   * @vpath_handle: Vpath handle.
   *
   * Enable promiscuous mode of X3100 operation.
   *
   * See also: vxge_hal_vpath_promisc_disable().
   */
  vxge_hal_status_e
  vxge_hal_vpath_promisc_enable(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	if (vpath->promisc_en == VXGE_HAL_VP_PROMISC_ENABLE) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  		    __FILE__, __func__, __LINE__);
  		return (VXGE_HAL_OK);
  	}
  
  	val64 = vxge_os_pio_mem_read64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	val64 |= VXGE_HAL_RXMAC_VCFG0_UCAST_ALL_ADDR_EN |
  	    VXGE_HAL_RXMAC_VCFG0_MCAST_ALL_ADDR_EN |
  	    VXGE_HAL_RXMAC_VCFG0_BCAST_EN |
  	    VXGE_HAL_RXMAC_VCFG0_ALL_VID_EN;
  
  	vxge_os_pio_mem_write64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	vpath->promisc_en = VXGE_HAL_VP_PROMISC_ENABLE;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_promisc_disable - Disable promiscuous mode.
   * @vpath_handle: Vpath handle.
   *
   * Disable promiscuous mode of X3100 operation.
   *
   * See also: vxge_hal_vpath_promisc_enable().
   */
  vxge_hal_status_e
  vxge_hal_vpath_promisc_disable(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	if (vpath->promisc_en == VXGE_HAL_VP_PROMISC_DISABLE) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  		    __FILE__, __func__, __LINE__);
  		return (VXGE_HAL_OK);
  	}
  
  	val64 = vxge_os_pio_mem_read64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	if (vpath->vp_config->rpa_ucast_all_addr_en ==
  	    VXGE_HAL_VPATH_RPA_UCAST_ALL_ADDR_DISABLE) {
  		val64 &= ~VXGE_HAL_RXMAC_VCFG0_UCAST_ALL_ADDR_EN;
  	}
  
  	if (vpath->vp_config->rpa_mcast_all_addr_en ==
  	    VXGE_HAL_VPATH_RPA_MCAST_ALL_ADDR_DISABLE) {
  		val64 &= ~VXGE_HAL_RXMAC_VCFG0_MCAST_ALL_ADDR_EN;
  	}
  
  	if (vpath->vp_config->rpa_bcast_en ==
  	    VXGE_HAL_VPATH_RPA_BCAST_DISABLE) {
  		val64 &= ~VXGE_HAL_RXMAC_VCFG0_BCAST_EN;
  	}
  
  	if (vpath->vp_config->rpa_all_vid_en ==
  	    VXGE_HAL_VPATH_RPA_ALL_VID_DISABLE) {
  		val64 &= ~VXGE_HAL_RXMAC_VCFG0_ALL_VID_EN;
  	}
  
  	vxge_os_pio_mem_write64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	vpath->promisc_en = VXGE_HAL_VP_PROMISC_DISABLE;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_bcast_enable - Enable broadcast
   * @vpath_handle: Vpath handle.
   *
   * Enable receiving broadcasts.
   */
  vxge_hal_status_e
  vxge_hal_vpath_bcast_enable(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_INVALID_HANDLE);
  
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	if (vpath->vp_config->rpa_bcast_en ==
  	    VXGE_HAL_VPATH_RPA_BCAST_ENABLE) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  		    __FILE__, __func__, __LINE__);
  		return (VXGE_HAL_OK);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	val64 |= VXGE_HAL_RXMAC_VCFG0_BCAST_EN;
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	vpath->vp_config->rpa_bcast_en = VXGE_HAL_VPATH_RPA_BCAST_ENABLE;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_bcast_disable - Disable broadcast
   * @vpath_handle: Vpath handle.
   *
   * Disable receiving broadcasts.
   */
  vxge_hal_status_e
  vxge_hal_vpath_bcast_disable(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	if (vpath->vp_config->rpa_bcast_en ==
  	    VXGE_HAL_VPATH_RPA_BCAST_DISABLE) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  		    __FILE__, __func__, __LINE__);
  		return (VXGE_HAL_OK);
  	}
  
  	val64 = vxge_os_pio_mem_read64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	val64 &= ~VXGE_HAL_RXMAC_VCFG0_BCAST_EN;
  
  	vxge_os_pio_mem_write64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	vpath->vp_config->rpa_bcast_en = VXGE_HAL_VPATH_RPA_BCAST_DISABLE;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_mcast_enable - Enable multicast addresses.
   * @vpath_handle: Vpath handle.
   *
   * Enable X3100 multicast addresses.
   * Returns: VXGE_HAL_OK on success.
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_mcast_enable(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	if (vpath->vp_config->rpa_mcast_all_addr_en ==
  	    VXGE_HAL_VPATH_RPA_MCAST_ALL_ADDR_ENABLE) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  		    __FILE__, __func__, __LINE__);
  		return (VXGE_HAL_OK);
  	}
  
  	val64 = vxge_os_pio_mem_read64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	val64 |= VXGE_HAL_RXMAC_VCFG0_MCAST_ALL_ADDR_EN;
  
  	vxge_os_pio_mem_write64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	vpath->vp_config->rpa_mcast_all_addr_en =
  	    VXGE_HAL_VPATH_RPA_MCAST_ALL_ADDR_ENABLE;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_mcast_disable - Disable  multicast addresses.
   * @vpath_handle: Vpath handle.
   *
   * Disable X3100 multicast addresses.
   * Returns: VXGE_HAL_OK - success.
   * VXGE_HAL_INF_MEM_STROBE_CMD_EXECUTING - Failed to disable mcast
   * feature within the time(timeout).
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_mcast_disable(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	if (vpath->vp_config->rpa_mcast_all_addr_en ==
  	    VXGE_HAL_VPATH_RPA_MCAST_ALL_ADDR_DISABLE) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  		    __FILE__, __func__, __LINE__);
  		return (VXGE_HAL_OK);
  	}
  
  	val64 = vxge_os_pio_mem_read64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	val64 &= ~VXGE_HAL_RXMAC_VCFG0_MCAST_ALL_ADDR_EN;
  
  	vxge_os_pio_mem_write64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	vpath->vp_config->rpa_mcast_all_addr_en =
  	    VXGE_HAL_VPATH_RPA_MCAST_ALL_ADDR_DISABLE;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_ucast_enable - Enable unicast addresses.
   * @vpath_handle: Vpath handle.
   *
   * Enable X3100 unicast addresses.
   * Returns: VXGE_HAL_OK on success.
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_ucast_enable(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	if (vpath->vp_config->rpa_ucast_all_addr_en ==
  	    VXGE_HAL_VPATH_RPA_UCAST_ALL_ADDR_ENABLE) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  		    __FILE__, __func__, __LINE__);
  		return (VXGE_HAL_OK);
  	}
  
  	val64 = vxge_os_pio_mem_read64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	val64 |= VXGE_HAL_RXMAC_VCFG0_UCAST_ALL_ADDR_EN;
  
  	vxge_os_pio_mem_write64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	vpath->vp_config->rpa_ucast_all_addr_en =
  	    VXGE_HAL_VPATH_RPA_UCAST_ALL_ADDR_ENABLE;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_ucast_disable - Disable  unicast addresses.
   * @vpath_handle: Vpath handle.
   *
   * Disable X3100 unicast addresses.
   * Returns: VXGE_HAL_OK - success.
   * VXGE_HAL_INF_MEM_STROBE_CMD_EXECUTING - Failed to disable mcast
   * feature within the time(timeout).
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_ucast_disable(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	if (vpath->vp_config->rpa_ucast_all_addr_en ==
  	    VXGE_HAL_VPATH_RPA_UCAST_ALL_ADDR_DISABLE) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  		    __FILE__, __func__, __LINE__);
  		return (VXGE_HAL_OK);
  	}
  
  	val64 = vxge_os_pio_mem_read64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	val64 &= ~VXGE_HAL_RXMAC_VCFG0_UCAST_ALL_ADDR_EN;
  
  	vxge_os_pio_mem_write64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	vpath->vp_config->rpa_ucast_all_addr_en =
  	    VXGE_HAL_VPATH_RPA_UCAST_ALL_ADDR_DISABLE;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_all_vid_enable - Enable all Vlan Ids.
   * @vpath_handle: Vpath handle.
   *
   * Enable X3100 vlan ids.
   * Returns: VXGE_HAL_OK on success.
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_all_vid_enable(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	if (vpath->vp_config->rpa_all_vid_en ==
  	    VXGE_HAL_VPATH_RPA_ALL_VID_ENABLE) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  		    __FILE__, __func__, __LINE__);
  		return (VXGE_HAL_OK);
  	}
  
  	val64 = vxge_os_pio_mem_read64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	val64 |= VXGE_HAL_RXMAC_VCFG0_ALL_VID_EN;
  
  	vxge_os_pio_mem_write64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	vpath->vp_config->rpa_all_vid_en = VXGE_HAL_VPATH_RPA_ALL_VID_ENABLE;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_all_vid_disable - Disable all Vlan Ids.
   * @vpath_handle: Vpath handle.
   *
   * Disable X3100  vlan ids.
   * Returns: VXGE_HAL_OK - success.
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_all_vid_disable(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	if (vpath->vp_config->rpa_all_vid_en ==
  	    VXGE_HAL_VPATH_RPA_ALL_VID_DISABLE) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  		    __FILE__, __func__, __LINE__);
  		return (VXGE_HAL_OK);
  	}
  
  	val64 = vxge_os_pio_mem_read64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	val64 &= ~VXGE_HAL_RXMAC_VCFG0_ALL_VID_EN;
  
  	vxge_os_pio_mem_write64(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	vpath->vp_config->rpa_all_vid_en = VXGE_HAL_VPATH_RPA_ALL_VID_DISABLE;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_strip_vlan_tag_enable - Enable strip vlan tag.
   * @vpath_handle: Vpath handle.
   *
   * Enable X3100  strip vlan tag.
   * Returns: VXGE_HAL_OK on success.
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_strip_vlan_tag_enable(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	if (vpath->vp_config->rpa_strip_vlan_tag ==
  	    VXGE_HAL_VPATH_RPA_STRIP_VLAN_TAG_ENABLE) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  		    __FILE__, __func__, __LINE__);
  		return (VXGE_HAL_OK);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->xmac_rpa_vcfg);
  
  	val64 |= VXGE_HAL_XMAC_RPA_VCFG_STRIP_VLAN_TAG;
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->xmac_rpa_vcfg);
  
  	vpath->vp_config->rpa_strip_vlan_tag =
  	    VXGE_HAL_VPATH_RPA_STRIP_VLAN_TAG_ENABLE;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_strip_vlan_tag_disable - Disable strip vlan tag.
   * @vpath_handle: Vpath handle.
   *
   * Disable X3100  strip vlan tag.
   * Returns: VXGE_HAL_OK - success.
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_strip_vlan_tag_disable(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	if (vpath->vp_config->rpa_strip_vlan_tag ==
  	    VXGE_HAL_VPATH_RPA_STRIP_VLAN_TAG_DISABLE) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  		    __FILE__, __func__, __LINE__);
  		return (VXGE_HAL_OK);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->xmac_rpa_vcfg);
  
  	val64 &= ~VXGE_HAL_XMAC_RPA_VCFG_STRIP_VLAN_TAG;
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->xmac_rpa_vcfg);
  
  	vpath->vp_config->rpa_strip_vlan_tag =
  	    VXGE_HAL_VPATH_RPA_STRIP_VLAN_TAG_DISABLE;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_tpa_set - Set tpa parameters.
   * @vpath_handle: Virtual Path ahandle.
   * @params: vxge_hal_vpath_tpa_params {} structure with parameters
   *
   * The function	sets the tpa parametrs for the vpath.
   *
   * See also: vxge_hal_vpath_tpa_params {}
   */
  vxge_hal_status_e
  vxge_hal_vpath_tpa_set(vxge_hal_vpath_h vpath_handle,
      vxge_hal_vpath_tpa_params *params)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert((vpath_handle != NULL) && (params != NULL));
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", params = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, (ptr_t) params);
  
  	if (vpath->fifoh == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->tpa_cfg);
  
  	if (params->tpa_ignore_frame_error != VXGE_HAL_DEFAULT_32) {
  		if (params->tpa_ignore_frame_error)
  			val64 |= VXGE_HAL_TPA_CFG_IGNORE_FRAME_ERR;
  		else
  			val64 &= ~VXGE_HAL_TPA_CFG_IGNORE_FRAME_ERR;
  	}
  
  	if (params->tpa_ipv6_keep_searching != VXGE_HAL_DEFAULT_32) {
  		if (params->tpa_ipv6_keep_searching)
  			val64 &= ~VXGE_HAL_TPA_CFG_IPV6_STOP_SEARCHING;
  		else
  			val64 |= VXGE_HAL_TPA_CFG_IPV6_STOP_SEARCHING;
  	}
  
  	if (params->tpa_l4_pshdr_present != VXGE_HAL_DEFAULT_32) {
  		if (params->tpa_l4_pshdr_present)
  			val64 |= VXGE_HAL_TPA_CFG_L4_PSHDR_PRESENT;
  		else
  			val64 &= ~VXGE_HAL_TPA_CFG_L4_PSHDR_PRESENT;
  	}
  
  	if (params->tpa_support_mobile_ipv6_hdrs != VXGE_HAL_DEFAULT_32) {
  		if (params->tpa_support_mobile_ipv6_hdrs)
  			val64 |= VXGE_HAL_TPA_CFG_SUPPORT_MOBILE_IPV6_HDRS;
  		else
  			val64 &= ~VXGE_HAL_TPA_CFG_SUPPORT_MOBILE_IPV6_HDRS;
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->tpa_cfg);
  
  	vpath->vp_config->tpa_ignore_frame_error =
  	    params->tpa_ignore_frame_error;
  	vpath->vp_config->tpa_l4_pshdr_present =
  	    params->tpa_l4_pshdr_present;
  	vpath->vp_config->tpa_support_mobile_ipv6_hdrs =
  	    params->tpa_support_mobile_ipv6_hdrs;
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->tx_protocol_assist_cfg);
  
  	if (params->tpa_lsov2_en != VXGE_HAL_DEFAULT_32) {
  		if (params->tpa_lsov2_en)
  			val64 |= VXGE_HAL_TX_PROTOCOL_ASSIST_CFG_LSOV2_EN;
  		else
  			val64 &= ~VXGE_HAL_TX_PROTOCOL_ASSIST_CFG_LSOV2_EN;
  	}
  
  	if (params->tpa_ipv6_keep_searching != VXGE_HAL_DEFAULT_32) {
  		if (params->tpa_ipv6_keep_searching)
  			val64 |=
  			    VXGE_HAL_TX_PROTOCOL_ASSIST_CFG_IPV6_KEEP_SEARCHING;
  		else
  			val64 &=
  			    ~VXGE_HAL_TX_PROTOCOL_ASSIST_CFG_IPV6_KEEP_SEARCHING;
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->tx_protocol_assist_cfg);
  
  	vpath->vp_config->tpa_lsov2_en = params->tpa_lsov2_en;
  	vpath->vp_config->tpa_ipv6_keep_searching =
  	    params->tpa_ipv6_keep_searching;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_rpa_set - Set rpa parameters.
   * @vpath_handle: Virtual Path ahandle.
   * @params: vxge_hal_vpath_rpa_params {} structure with parameters
   *
   * The function	sets the rpa parametrs for the vpath.
   *
   * See also: vxge_hal_vpath_rpa_params {}
   */
  vxge_hal_status_e
  vxge_hal_vpath_rpa_set(vxge_hal_vpath_h vpath_handle,
      vxge_hal_vpath_rpa_params *params)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert((vpath_handle != NULL) && (params != NULL));
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", params = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, (ptr_t) params);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->xmac_rpa_vcfg);
  
  	if (params->rpa_ipv4_tcp_incl_ph != VXGE_HAL_DEFAULT_32) {
  		if (params->rpa_ipv4_tcp_incl_ph)
  			val64 |= VXGE_HAL_XMAC_RPA_VCFG_IPV4_TCP_INCL_PH;
  		else
  			val64 &= ~VXGE_HAL_XMAC_RPA_VCFG_IPV4_TCP_INCL_PH;
  	}
  
  	if (params->rpa_ipv6_tcp_incl_ph != VXGE_HAL_DEFAULT_32) {
  		if (params->rpa_ipv6_tcp_incl_ph)
  			val64 |= VXGE_HAL_XMAC_RPA_VCFG_IPV6_TCP_INCL_PH;
  		else
  			val64 &= ~VXGE_HAL_XMAC_RPA_VCFG_IPV6_TCP_INCL_PH;
  	}
  
  	if (params->rpa_ipv4_udp_incl_ph != VXGE_HAL_DEFAULT_32) {
  		if (params->rpa_ipv4_udp_incl_ph)
  			val64 |= VXGE_HAL_XMAC_RPA_VCFG_IPV4_UDP_INCL_PH;
  		else
  			val64 &= ~VXGE_HAL_XMAC_RPA_VCFG_IPV4_UDP_INCL_PH;
  	}
  
  	if (params->rpa_ipv6_udp_incl_ph != VXGE_HAL_DEFAULT_32) {
  		if (params->rpa_ipv6_udp_incl_ph)
  			val64 |= VXGE_HAL_XMAC_RPA_VCFG_IPV6_UDP_INCL_PH;
  		else
  			val64 &= ~VXGE_HAL_XMAC_RPA_VCFG_IPV6_UDP_INCL_PH;
  	}
  
  	if (params->rpa_l4_incl_cf != VXGE_HAL_DEFAULT_32) {
  		if (params->rpa_l4_incl_cf)
  			val64 |= VXGE_HAL_XMAC_RPA_VCFG_L4_INCL_CF;
  		else
  			val64 &= ~VXGE_HAL_XMAC_RPA_VCFG_L4_INCL_CF;
  	}
  
  	if (params->rpa_strip_vlan_tag != VXGE_HAL_DEFAULT_32) {
  		if (params->rpa_strip_vlan_tag)
  			val64 |= VXGE_HAL_XMAC_RPA_VCFG_STRIP_VLAN_TAG;
  		else
  			val64 &= ~VXGE_HAL_XMAC_RPA_VCFG_STRIP_VLAN_TAG;
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->xmac_rpa_vcfg);
  
  	vpath->vp_config->rpa_ipv4_tcp_incl_ph = params->rpa_ipv4_tcp_incl_ph;
  	vpath->vp_config->rpa_ipv6_tcp_incl_ph = params->rpa_ipv6_tcp_incl_ph;
  	vpath->vp_config->rpa_ipv4_udp_incl_ph = params->rpa_ipv4_udp_incl_ph;
  	vpath->vp_config->rpa_ipv6_udp_incl_ph = params->rpa_ipv6_udp_incl_ph;
  	vpath->vp_config->rpa_l4_incl_cf = params->rpa_l4_incl_cf;
  	vpath->vp_config->rpa_strip_vlan_tag = params->rpa_strip_vlan_tag;
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	if (params->rpa_ucast_all_addr_en != VXGE_HAL_DEFAULT_32) {
  		if (params->rpa_ucast_all_addr_en)
  			val64 |= VXGE_HAL_RXMAC_VCFG0_UCAST_ALL_ADDR_EN;
  		else
  			val64 &= ~VXGE_HAL_RXMAC_VCFG0_UCAST_ALL_ADDR_EN;
  	}
  
  	if (params->rpa_mcast_all_addr_en != VXGE_HAL_DEFAULT_32) {
  		if (params->rpa_mcast_all_addr_en)
  			val64 |= VXGE_HAL_RXMAC_VCFG0_MCAST_ALL_ADDR_EN;
  		else
  			val64 &= ~VXGE_HAL_RXMAC_VCFG0_MCAST_ALL_ADDR_EN;
  	}
  
  	if (params->rpa_bcast_en != VXGE_HAL_DEFAULT_32) {
  		if (params->rpa_bcast_en)
  			val64 |= VXGE_HAL_RXMAC_VCFG0_BCAST_EN;
  		else
  			val64 &= ~VXGE_HAL_RXMAC_VCFG0_BCAST_EN;
  	}
  
  	if (params->rpa_all_vid_en != VXGE_HAL_DEFAULT_32) {
  		if (params->rpa_all_vid_en)
  			val64 |= VXGE_HAL_RXMAC_VCFG0_ALL_VID_EN;
  		else
  			val64 &= ~VXGE_HAL_RXMAC_VCFG0_ALL_VID_EN;
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->rxmac_vcfg0);
  
  	vpath->vp_config->rpa_ucast_all_addr_en = params->rpa_ucast_all_addr_en;
  	vpath->vp_config->rpa_mcast_all_addr_en = params->rpa_mcast_all_addr_en;
  	vpath->vp_config->rpa_bcast_en = params->rpa_bcast_en;
  	vpath->vp_config->rpa_all_vid_en = params->rpa_all_vid_en;
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->fau_rpa_vcfg);
  
  	if (params->rpa_l4_comp_csum != VXGE_HAL_DEFAULT_32) {
  		if (params->rpa_l4_comp_csum)
  			val64 |= VXGE_HAL_FAU_RPA_VCFG_L4_COMP_CSUM;
  		else
  			val64 &= ~VXGE_HAL_FAU_RPA_VCFG_L4_COMP_CSUM;
  	}
  
  	if (params->rpa_l3_incl_cf != VXGE_HAL_DEFAULT_32) {
  		if (params->rpa_l3_incl_cf)
  			val64 |= VXGE_HAL_FAU_RPA_VCFG_L3_INCL_CF;
  		else
  			val64 &= ~VXGE_HAL_FAU_RPA_VCFG_L3_INCL_CF;
  	}
  
  	if (params->rpa_l3_comp_csum != VXGE_HAL_DEFAULT_32) {
  		if (params->rpa_l3_comp_csum)
  			val64 |= VXGE_HAL_FAU_RPA_VCFG_L3_COMP_CSUM;
  		else
  			val64 &= ~VXGE_HAL_FAU_RPA_VCFG_L3_COMP_CSUM;
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->fau_rpa_vcfg);
  
  	vpath->vp_config->rpa_l4_comp_csum = params->rpa_l4_comp_csum;
  	vpath->vp_config->rpa_l3_incl_cf = params->rpa_l3_incl_cf;
  	vpath->vp_config->rpa_l3_comp_csum = params->rpa_l3_comp_csum;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * __hal_vpath_intr_enable - Enable vpath interrupts.
   * @vpath: Virtual Path.
   * @op: One of the vxge_hal_vpath_intr_e enumerated values specifying
   *	  the type(s) of interrupts to enable.
   *
   * Enable vpath interrupts. The function is to be executed the last in
   * vpath initialization sequence.
   *
   * See also: __hal_vpath_intr_disable()
   */
  vxge_hal_status_e
  __hal_vpath_intr_enable(__hal_virtualpath_t *vpath)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  
  	vxge_assert(vpath != NULL);
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath);
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->kdfcctl_errors_reg);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->general_errors_reg);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->pci_config_errors_reg);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->mrpcim_to_vpath_alarm_reg);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->srpcim_to_vpath_alarm_reg);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->vpath_ppif_int_status);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->srpcim_msg_to_vpath_reg);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->vpath_pcipif_int_status);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->prc_alarm_reg);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->wrdma_alarm_status);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->asic_ntwk_vp_err_reg);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->xgmac_vp_int_status);
  
  	vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_general_int_status);
  
  	/* Unmask the individual interrupts. */
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vpath->vp_reg->kdfcctl_errors_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vpath->vp_reg->general_errors_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->pci_config_errors_mask);
  
  	if (hldev->first_vp_id != vpath->vp_id) {
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) VXGE_HAL_INTR_MASK_ALL,
  		    &vpath->vp_reg->mrpcim_to_vpath_alarm_mask);
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) VXGE_HAL_INTR_MASK_ALL,
  		    &vpath->vp_reg->srpcim_to_vpath_alarm_mask);
  	} else {
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    0,
  		    &vpath->vp_reg->mrpcim_to_vpath_alarm_mask);
  
  		if (hldev->access_rights &
  		    VXGE_HAL_DEVICE_ACCESS_RIGHT_SRPCIM) {
  			vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  			    hldev->header.regh0,
  			    0,
  			    &vpath->vp_reg->srpcim_to_vpath_alarm_mask);
  		}
  	}
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vpath->vp_reg->vpath_ppif_int_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->srpcim_msg_to_vpath_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vpath->vp_reg->vpath_pcipif_int_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(VXGE_HAL_PRC_ALARM_REG_PRC_RING_BUMP, 0),
  	    &vpath->vp_reg->prc_alarm_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vpath->vp_reg->wrdma_alarm_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vpath->vp_reg->xgmac_vp_int_mask);
  
  	if (hldev->first_vp_id != vpath->vp_id) {
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) VXGE_HAL_INTR_MASK_ALL,
  		    &vpath->vp_reg->asic_ntwk_vp_err_mask);
  	} else {
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0, (u32) bVAL32((
  		    VXGE_HAL_ASIC_NTWK_VP_ERR_REG_REAF_FAULT |
  		    VXGE_HAL_ASIC_NTWK_VP_ERR_REG_REAF_OK), 0),
  		    &vpath->vp_reg->asic_ntwk_vp_err_mask);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &hldev->common_reg->tim_int_en);
  
  	/* val64 |= VXGE_HAL_TIM_SET_INT_EN_VP(1 << (16 - vpath->vp_id)); */
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 0),
  	    &hldev->common_reg->tim_set_int_en);
  
  	vxge_hal_pio_mem_write32_upper(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vpath->vp_reg->vpath_general_int_mask);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  
  }
  
  /*
   * vxge_hal_vpath_intr_enable - Enable vpath interrupts.
   * @vpath_handle: Virtual Path handle.
   * @op: One of the vxge_hal_vpath_intr_e enumerated values specifying
   *	  the type(s) of interrupts to enable.
   *
   * Enable vpath interrupts. The function is to be executed the last in
   * vpath initialization sequence.
   *
   * See also: vxge_hal_vpath_intr_disable()
   */
  vxge_hal_status_e
  vxge_hal_vpath_intr_enable(vxge_hal_vpath_h vpath_handle)
  {
  	vxge_hal_status_e status;
  
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vp = (__hal_vpath_handle_t *) vpath_handle;
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	status = __hal_vpath_intr_enable((__hal_virtualpath_t *) vp->vpath);
  
  	vxge_hal_vpath_unmask_all(vpath_handle);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  
  }
  
  /*
   * __hal_vpath_intr_disable - Disable vpath interrupts.
   * @vpath: Virtual Path.
   * @op: One of the vxge_hal_vpath_intr_e enumerated values specifying
   *	  the type(s) of interrupts to enable.
   *
   * Disable vpath interrupts. The function is to be executed the last in
   * vpath initialization sequence.
   *
   * See also: __hal_vpath_intr_enable()
   */
  vxge_hal_status_e
  __hal_vpath_intr_disable(__hal_virtualpath_t *vpath)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  
  	vxge_assert(vpath != NULL);
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath);
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_VPATH_NOT_OPEN);
  
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->vpath_general_int_mask);
  
  	val64 = VXGE_HAL_TIM_CLR_INT_EN_VP(1 << (16 - vpath->vp_id));
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 0),
  	    &hldev->common_reg->tim_clr_int_en);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->kdfcctl_errors_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->general_errors_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->pci_config_errors_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->mrpcim_to_vpath_alarm_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->srpcim_to_vpath_alarm_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->vpath_ppif_int_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->srpcim_msg_to_vpath_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->vpath_pcipif_int_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->prc_alarm_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->wrdma_alarm_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->asic_ntwk_vp_err_mask);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) VXGE_HAL_INTR_MASK_ALL,
  	    &vpath->vp_reg->xgmac_vp_int_mask);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  
  }
  /*
   * vxge_hal_vpath_intr_disable - Disable vpath interrupts.
   * @vpath_handle: Virtual Path handle.
   * @op: One of the vxge_hal_vpath_intr_e enumerated values specifying
   *	  the type(s) of interrupts to disable.
   *
   * Disable vpath interrupts.
   *
   * See also: vxge_hal_vpath_intr_enable()
   */
  vxge_hal_status_e
  vxge_hal_vpath_intr_disable(vxge_hal_vpath_h vpath_handle)
  {
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	vxge_hal_vpath_mask_all(vpath_handle);
  
  	(void) __hal_vpath_intr_disable(vpath);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_mask_all - Mask all vpath interrupts.
   * @vpath_handle: Virtual Path handle.
   *
   * Mask	all vpath interrupts.
   *
   * See also: vxge_hal_vpath_unmask_all()
   */
  void
  vxge_hal_vpath_mask_all(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vp = (__hal_vpath_handle_t *) vpath_handle;
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	val64 = VXGE_HAL_VPATH_GENERAL_INT_MASK_PIC_INT |
  	    VXGE_HAL_VPATH_GENERAL_INT_MASK_PCI_INT |
  	    VXGE_HAL_VPATH_GENERAL_INT_MASK_WRDMA_INT |
  	    VXGE_HAL_VPATH_GENERAL_INT_MASK_XMAC_INT;
  
  	vxge_hal_pio_mem_write32_upper(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 0),
  	    &vp->vpath->vp_reg->vpath_general_int_mask);
  
  	if (vp->vpath->vp_id < 16) {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->tim_int_mask0);
  
  		val64 |= vBIT(0xf, (vp->vpath->vp_id * 4), 4);
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &hldev->common_reg->tim_int_mask0);
  
  	} else {
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) bVAL32(VXGE_HAL_TIM_INT_MASK1_TIM_INT_MASK1(0xf), 0),
  		    &hldev->common_reg->tim_int_mask1);
  
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  /*
   * vxge_hal_vpath_unmask_all - Unmask all vpath interrupts.
   * @vpath_handle: Virtual Path handle.
   *
   * Unmask all vpath interrupts.
   *
   * See also: vxge_hal_vpath_mask_all()
   */
  void
  vxge_hal_vpath_unmask_all(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vp == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return;
  	}
  
  	vxge_hal_pio_mem_write32_upper(
  	    hldev->header.pdev,
  	    hldev->header.regh0,
  	    0,
  	    &vp->vpath->vp_reg->vpath_general_int_mask);
  
  	if (vp->vpath->vp_id < 16) {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->tim_int_mask0);
  
  		val64 &= ~(vBIT(0xf, (vp->vpath->vp_id * 4), 4));
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &hldev->common_reg->tim_int_mask0);
  
  	} else {
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    0,
  		    &hldev->common_reg->tim_int_mask1);
  
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  /*
   * __hal_vpath_link_state_test - Test for the link state.
   * @vpath: Virtual Path.
   *
   * Test link state.
   * Returns: link state.
   */
  vxge_hal_device_link_state_e
  __hal_vpath_link_state_test(__hal_virtualpath_t *vpath)
  {
  	__hal_device_t *hldev;
  
  	vxge_assert(vpath != NULL);
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    VXGE_HAL_ASIC_NTWK_VP_CTRL_REQ_TEST_NTWK,
  	    &vpath->vp_reg->asic_ntwk_vp_ctrl);
  
  	(void) vxge_hal_device_register_poll(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->asic_ntwk_vp_ctrl,
  	    0,
  	    VXGE_HAL_ASIC_NTWK_VP_CTRL_REQ_TEST_NTWK,
  	    hldev->header.config.device_poll_millis);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (hldev->header.link_state);
  }
  
  /*
   * __hal_vpath_link_state_poll - Poll for the link state.
   * @vpath: Virtual Path.
   *
   * Get link state.
   * Returns: link state.
   */
  vxge_hal_device_link_state_e
  __hal_vpath_link_state_poll(__hal_virtualpath_t *vpath)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  
  	vxge_assert(vpath != NULL);
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath);
  
  	if (vpath == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_LINK_NONE);
  		return (VXGE_HAL_LINK_NONE);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vpmgmt_reg->xgmac_gen_status_vpmgmt_clone);
  
  	if (val64 & VXGE_HAL_XGMAC_GEN_STATUS_VPMGMT_CLONE_XMACJ_NTWK_OK) {
  
  		(void) __hal_device_handle_link_up_ind(vpath->hldev);
  
  		if (val64 &
  		    VXGE_HAL_XGMAC_GEN_STATUS_VPMGMT_CLONE_XMACJ_NTWK_DATA_RATE) {
  			VXGE_HAL_DEVICE_DATA_RATE_SET(vpath->hldev,
  			    VXGE_HAL_DATA_RATE_10G);
  
  		} else {
  			VXGE_HAL_DEVICE_DATA_RATE_SET(vpath->hldev,
  			    VXGE_HAL_DATA_RATE_1G);
  
  		}
  	} else {
  		(void) __hal_device_handle_link_down_ind(vpath->hldev);
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (vpath->hldev->header.link_state);
  }
  
  /*
   * __hal_vpath_data_rate_poll - Poll for the data rate.
   * @vpath: Virtual Path.
   *
   * Get data rate.
   * Returns: data rate.
   */
  vxge_hal_device_data_rate_e
  __hal_vpath_data_rate_poll(
      __hal_virtualpath_t *vpath)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  
  	vxge_assert(vpath != NULL);
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath);
  
  	if (vpath == NULL) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_DATA_RATE_UNKNOWN);
  		return (VXGE_HAL_DATA_RATE_UNKNOWN);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vpmgmt_reg->xgmac_gen_status_vpmgmt_clone);
  
  	if (val64 &
  	    VXGE_HAL_XGMAC_GEN_STATUS_VPMGMT_CLONE_XMACJ_NTWK_DATA_RATE) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  		    __FILE__, __func__, __LINE__);
  
  		return (VXGE_HAL_DATA_RATE_10G);
  
  	} else {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  		    __FILE__, __func__, __LINE__);
  
  		return (VXGE_HAL_DATA_RATE_1G);
  
  	}
  }
  
  /*
   * __hal_vpath_alarm_process - Process Alarms.
   * @vpath: Virtual Path.
   * @skip_alarms: Do not clear the alarms
   *
   * Process vpath alarms.
   *
   */
  vxge_hal_status_e
  __hal_vpath_alarm_process(__hal_virtualpath_t *vpath, u32 skip_alarms)
  {
  	u64 val64;
  	u64 alarm_status;
  	u64 pic_status = 0;
  	u64 pif_status;
  	u64 wrdma_status;
  	u64 xgmac_status;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status;
  
  	vxge_assert(vpath != NULL);
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq("vpath = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath);
  
  	alarm_status = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_general_int_status);
  
  	vxge_hal_info_log_vpath_irq(
  	    "alarm_status = 0x"VXGE_OS_STXFMT, (ptr_t) alarm_status);
  
  	if (vxge_os_unlikely(!alarm_status)) {
  		status = VXGE_HAL_ERR_WRONG_IRQ;
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	if (alarm_status & VXGE_HAL_VPATH_GENERAL_INT_STATUS_PIC_INT) {
  
  		pic_status = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->vpath_ppif_int_status);
  
  		vxge_hal_info_log_vpath_irq(
  		    "pic_status = 0x"VXGE_OS_STXFMT, (ptr_t) pic_status);
  
  		if (pic_status &
  		    VXGE_HAL_VPATH_PPIF_INT_STATUS_GENERAL_ERRORS_INT) {
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &vpath->vp_reg->general_errors_reg);
  
  			vxge_hal_info_log_vpath_irq(
  			    "general_errors_reg = 0x"VXGE_OS_STXFMT,
  			    (ptr_t) val64);
  			if (val64 & VXGE_HAL_GENERAL_ERRORS_REG_INI_SERR_DET) {
  
  				vpath->sw_stats->error_stats.ini_serr_det++;
  				vxge_hal_info_log_vpath_irq("%s:"
  				    "VXGE_HAL_GENERAL_ERRORS_REG_INI_SERR_DET",
  				    __func__);
  
  				__hal_device_handle_error(hldev, vpath->vp_id,
  				    VXGE_HAL_EVENT_SERR);
  
  				if (!skip_alarms) {
  					vxge_os_pio_mem_write64(hldev->header.pdev,
  					    hldev->header.regh0,
  					    VXGE_HAL_GENERAL_ERRORS_REG_INI_SERR_DET,
  					    &vpath->vp_reg->general_errors_reg);
  				}
  
  				vxge_hal_trace_log_vpath_irq("<== %s:%s:%d \
  				    Result = 0", __FILE__, __func__, __LINE__);
  
  				return (VXGE_HAL_ERR_EVENT_SERR);
  			}
  		}
  
  		if (pic_status & VXGE_HAL_VPATH_PPIF_INT_STATUS_PCI_CONFIG_ERRORS_INT) {
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &vpath->vp_reg->pci_config_errors_reg);
  
  			vxge_hal_info_log_vpath_irq(
  			    "pci_config_errors_reg = 0x"VXGE_OS_STXFMT,
  			    (ptr_t) val64);
  
  			if (val64 &
  			    VXGE_HAL_PCI_CONFIG_ERRORS_REG_STATUS_ERR) {
  				vpath->sw_stats->error_stats.pci_config_status_err++;
  				vxge_hal_info_log_vpath_irq("%s: \
  				    VXGE_HAL_PCI_CONFIG_ERRORS_REG_STATUS_ERR",
  				    __func__);
  			}
  
  			if (val64 & VXGE_HAL_PCI_CONFIG_ERRORS_REG_UNCOR_ERR) {
  				vpath->sw_stats->error_stats.pci_config_uncor_err++;
  				vxge_hal_info_log_vpath_irq("%s: \
  				    VXGE_HAL_PCI_CONFIG_ERRORS_REG_UNCOR_ERR",
  				    __func__);
  			}
  
  			if (val64 & VXGE_HAL_PCI_CONFIG_ERRORS_REG_COR_ERR) {
  				vpath->sw_stats->error_stats.pci_config_cor_err++;
  				vxge_hal_info_log_vpath_irq("%s: \
  				    VXGE_HAL_PCI_CONFIG_ERRORS_REG_COR_ERR",
  				    __func__);
  			}
  
  			if (!skip_alarms)
  				vxge_os_pio_mem_write64(hldev->header.pdev,
  				    hldev->header.regh0, VXGE_HAL_INTR_MASK_ALL,
  				    &vpath->vp_reg->pci_config_errors_reg);
  		}
  
  		if (pic_status &
  		    VXGE_HAL_VPATH_PPIF_INT_STATUS_MRPCIM_TO_VPATH_ALARM_INT) {
  
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &vpath->vp_reg->mrpcim_to_vpath_alarm_reg);
  
  			vxge_hal_info_log_vpath_irq(
  			    "mrpcim_to_vpath_alarm_reg = 0x"VXGE_OS_STXFMT,
  			    (ptr_t) val64);
  
  			if (val64 &
  			    VXGE_HAL_MRPCIM_TO_VPATH_ALARM_REG_ALARM) {
  
  				vpath->sw_stats->error_stats.mrpcim_to_vpath_alarms++;
  				hldev->stats.sw_dev_err_stats.mrpcim_alarms++;
  				vxge_hal_info_log_vpath_irq(
  				    "%s:VXGE_HAL_MRPCIM_TO_VPATH_ALARM_REG_ALARM",
  				    __func__);
  
  				__hal_device_handle_error(hldev, vpath->vp_id,
  				    VXGE_HAL_EVENT_MRPCIM_CRITICAL);
  
  				if (!skip_alarms)
  					vxge_os_pio_mem_write64(hldev->header.pdev,
  					    hldev->header.regh0,
  					    VXGE_HAL_MRPCIM_TO_VPATH_ALARM_REG_ALARM,
  					    &vpath->vp_reg->mrpcim_to_vpath_alarm_reg);
  					return (VXGE_HAL_ERR_EVENT_MRPCIM_CRITICAL);
  			}
  
  			if (!skip_alarms)
  				vxge_os_pio_mem_write64(hldev->header.pdev,
  				    hldev->header.regh0,
  				    VXGE_HAL_INTR_MASK_ALL,
  				    &vpath->vp_reg->mrpcim_to_vpath_alarm_reg);
  		}
  
  		if (pic_status &
  		    VXGE_HAL_VPATH_PPIF_INT_STATUS_SRPCIM_TO_VPATH_ALARM_INT) {
  
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &vpath->vp_reg->srpcim_to_vpath_alarm_reg);
  
  			vxge_hal_info_log_vpath_irq(
  			    "srpcim_to_vpath_alarm_reg = 0x"VXGE_OS_STXFMT,
  			    (ptr_t) val64);
  
  			vpath->sw_stats->error_stats.srpcim_to_vpath_alarms++;
  			hldev->stats.sw_dev_err_stats.srpcim_alarms++;
  
  			vxge_hal_info_log_vpath_irq(
  			    "%s:VXGE_HAL_SRPCIM_TO_VPATH_ALARM_REG_GET_ALARM",
  			    __func__);
  
  			status = vxge_hal_srpcim_alarm_process(
  			    (vxge_hal_device_h) hldev, skip_alarms);
  
  			if (!skip_alarms)
  				vxge_os_pio_mem_write64(hldev->header.pdev,
  				    hldev->header.regh0,
  				    VXGE_HAL_INTR_MASK_ALL,
  				    &vpath->vp_reg->srpcim_to_vpath_alarm_reg);
  
  			if (status == VXGE_HAL_ERR_EVENT_SRPCIM_CRITICAL)
  				return (status);
  		}
  	}
  
  	if (alarm_status & VXGE_HAL_VPATH_GENERAL_INT_STATUS_WRDMA_INT) {
  
  		wrdma_status = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->wrdma_alarm_status);
  
  		vxge_hal_info_log_vpath_irq(
  		    "wrdma_alarm_status = 0x"VXGE_OS_STXFMT,
  		    (ptr_t) wrdma_status);
  
  		if (wrdma_status &
  		    VXGE_HAL_WRDMA_ALARM_STATUS_PRC_ALARM_PRC_INT) {
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &vpath->vp_reg->prc_alarm_reg);
  
  			vxge_hal_info_log_vpath_irq(
  			    "prc_alarm_reg = 0x"VXGE_OS_STXFMT, (ptr_t) val64);
  
  			if (val64 & VXGE_HAL_PRC_ALARM_REG_PRC_RING_BUMP) {
  				vpath->sw_stats->error_stats.prc_ring_bumps++;
  				vxge_hal_info_log_vpath_irq(
  				    "%s:VXGE_HAL_PRC_ALARM_REG_PRC_RING_BUMP",
  				    __func__);
  			}
  
  			if (val64 & VXGE_HAL_PRC_ALARM_REG_PRC_RXDCM_SC_ERR) {
  				vpath->sw_stats->error_stats.prc_rxdcm_sc_err++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_PRC_ALARM_REG_PRC_RXDCM_SC_ERR",
  				    __func__);
  				__hal_device_handle_error(hldev,
  				    vpath->vp_id,
  				    VXGE_HAL_EVENT_CRITICAL);
  
  				if (!skip_alarms) {
  					vxge_os_pio_mem_write64(hldev->header.pdev,
  					    hldev->header.regh0,
  					    VXGE_HAL_PRC_ALARM_REG_PRC_RXDCM_SC_ERR,
  					    &vpath->vp_reg->prc_alarm_reg);
  				}
  
  				vxge_hal_trace_log_vpath_irq(
  				    "<== %s:%s:%d Result = %d",
  				    __FILE__, __func__, __LINE__,
  				    VXGE_HAL_ERR_EVENT_CRITICAL);
  
  				return (VXGE_HAL_ERR_EVENT_CRITICAL);
  			}
  
  			if (val64 & VXGE_HAL_PRC_ALARM_REG_PRC_RXDCM_SC_ABORT) {
  				vpath->sw_stats->error_stats.prc_rxdcm_sc_abort++;
  				vxge_hal_info_log_vpath_irq("%s: \
  				    VXGE_HAL_PRC_ALARM_REG_PRC_RXDCM_SC_ABORT",
  				    __func__);
  
  				__hal_device_handle_error(hldev, vpath->vp_id,
  				    VXGE_HAL_EVENT_CRITICAL);
  
  				if (!skip_alarms)
  					vxge_os_pio_mem_write64(hldev->header.pdev,
  					    hldev->header.regh0,
  					    VXGE_HAL_PRC_ALARM_REG_PRC_RXDCM_SC_ABORT,
  					    &vpath->vp_reg->prc_alarm_reg);
  
  				vxge_hal_trace_log_vpath_irq(
  				    "<== %s:%s:%d Result = %d",
  				    __FILE__, __func__, __LINE__,
  				    VXGE_HAL_ERR_EVENT_CRITICAL);
  
  				return (VXGE_HAL_ERR_EVENT_CRITICAL);
  			}
  
  			if (val64 & VXGE_HAL_PRC_ALARM_REG_PRC_QUANTA_SIZE_ERR) {
  				vpath->sw_stats->error_stats.prc_quanta_size_err++;
  				vxge_hal_info_log_vpath_irq("%s: \
  				    VXGE_HAL_PRC_ALARM_REG_PRC_QUANTA_SIZE_ERR",
  				    __func__);
  			}
  
  			if (!skip_alarms)
  				vxge_os_pio_mem_write64(hldev->header.pdev,
  				    hldev->header.regh0, VXGE_HAL_INTR_MASK_ALL,
  				    &vpath->vp_reg->prc_alarm_reg);
  			}
  	}
  
  	if (alarm_status & VXGE_HAL_VPATH_GENERAL_INT_STATUS_PIC_INT) {
  
  		if (pic_status &
  		    VXGE_HAL_VPATH_PPIF_INT_STATUS_GENERAL_ERRORS_INT) {
  
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &vpath->vp_reg->general_errors_reg);
  
  			vxge_hal_info_log_vpath_irq(
  			    "general_errors_reg = 0x"VXGE_OS_STXFMT,
  			    (ptr_t) val64);
  
  			if (val64 &
  			    VXGE_HAL_GENERAL_ERRORS_REG_DBLGEN_FIFO0_OVRFLOW) {
  
  				vpath->sw_stats->error_stats.dblgen_fifo0_overflow++;
  				vxge_hal_info_log_vpath_irq(
  				    "%s:"
  				    "VXGE_HAL_GENERAL_ERRORS_REG_DBLGEN_FIFO0_OVRFLOW",
  				    __func__);
  
  				__hal_device_handle_error(hldev, vpath->vp_id,
  				    VXGE_HAL_EVENT_KDFCCTL);
  
  				if (!skip_alarms) {
  					vxge_os_pio_mem_write64(hldev->header.pdev,
  					    hldev->header.regh0,
  					    VXGE_HAL_GENERAL_ERRORS_REG_DBLGEN_FIFO0_OVRFLOW,
  					    &vpath->vp_reg->general_errors_reg);
  				}
  
  				vxge_hal_trace_log_vpath_irq("<== %s:%s:%d \
  				    Result = %d",
  				    __FILE__, __func__, __LINE__,
  				    VXGE_HAL_ERR_EVENT_KDFCCTL);
  				return (VXGE_HAL_ERR_EVENT_KDFCCTL);
  			}
  
  			if (val64 & VXGE_HAL_GENERAL_ERRORS_REG_DBLGEN_FIFO1_OVRFLOW) {
  				vpath->sw_stats->error_stats.dblgen_fifo1_overflow++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_GENERAL_ERRORS_REG_DBLGEN_FIFO1_OVRFLOW",
  				    __func__);
  
  			}
  
  			if (val64 &
  			    VXGE_HAL_GENERAL_ERRORS_REG_DBLGEN_FIFO2_OVRFLOW) {
  				vpath->sw_stats->error_stats.dblgen_fifo2_overflow++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_GENERAL_ERRORS_REG_DBLGEN_FIFO2_OVRFLOW",
  				    __func__);
  			}
  
  			if (val64 &
  			    VXGE_HAL_GENERAL_ERRORS_REG_STATSB_PIF_CHAIN_ERR) {
  				vpath->sw_stats->error_stats.statsb_pif_chain_error++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_GENERAL_ERRORS_REG_STATSB_PIF_CHAIN_ERR",
  				    __func__);
  			}
  
  			if (val64 &
  			    VXGE_HAL_GENERAL_ERRORS_REG_STATSB_DROP_TIMEOUT) {
  				vpath->sw_stats->error_stats.statsb_drop_timeout++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_GENERAL_ERRORS_REG_STATSB_DROP_TIMEOUT",
  				    __func__);
  			}
  
  			if (val64 & VXGE_HAL_GENERAL_ERRORS_REG_TGT_ILLEGAL_ACCESS) {
  				vpath->sw_stats->error_stats.target_illegal_access++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_GENERAL_ERRORS_REG_TGT_ILLEGAL_ACCESS",
  				    __func__);
  			}
  
  			if (!skip_alarms)
  				vxge_os_pio_mem_write64(hldev->header.pdev,
  				    hldev->header.regh0,
  				    VXGE_HAL_INTR_MASK_ALL,
  				    &vpath->vp_reg->general_errors_reg);
  		}
  
  		if (pic_status &
  		    VXGE_HAL_VPATH_PPIF_INT_STATUS_KDFCCTL_ERRORS_INT) {
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &vpath->vp_reg->kdfcctl_errors_reg);
  
  			vxge_hal_info_log_vpath_irq(
  			    "kdfcctl_errors_reg = 0x"VXGE_OS_STXFMT,
  			    (ptr_t) val64);
  
  			if (val64 &
  			    VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_OVRWR) {
  				vpath->sw_stats->error_stats.kdfcctl_fifo0_overwrite++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_OVRWR",
  				    __func__);
  				__hal_device_handle_error(hldev, vpath->vp_id,
  				    VXGE_HAL_EVENT_KDFCCTL);
  
  				if (!skip_alarms) {
  					vxge_os_pio_mem_write64(hldev->header.pdev,
  					    hldev->header.regh0,
  					    VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_OVRWR,
  					    &vpath->vp_reg->kdfcctl_errors_reg);
  				}
  
  				vxge_hal_trace_log_vpath_irq("<== %s:%s:%d \
  				    Result = %d", __FILE__, __func__, __LINE__,
  				    VXGE_HAL_ERR_EVENT_KDFCCTL);
  				return (VXGE_HAL_ERR_EVENT_KDFCCTL);
  			}
  
  			if (val64 &
  			    VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO1_OVRWR) {
  				vpath->sw_stats->error_stats.kdfcctl_fifo1_overwrite++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO1_OVRWR",
  				    __func__);
  
  			}
  
  			if (val64 &
  			    VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO2_OVRWR) {
  				vpath->sw_stats->error_stats.kdfcctl_fifo2_overwrite++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO2_OVRWR",
  				    __func__);
  			}
  
  			if (val64 &
  			    VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_POISON) {
  				vpath->sw_stats->error_stats.kdfcctl_fifo0_poison++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_POISON",
  				    __func__);
  				__hal_device_handle_error(hldev, vpath->vp_id,
  				    VXGE_HAL_EVENT_KDFCCTL);
  
  				if (!skip_alarms) {
  					vxge_os_pio_mem_write64(hldev->header.pdev,
  					    hldev->header.regh0,
  					    VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_POISON,
  					    &vpath->vp_reg->kdfcctl_errors_reg);
  				}
  
  				vxge_hal_trace_log_vpath_irq("<== %s:%s:%d \
  				    Result = %d", __FILE__, __func__, __LINE__,
  				    VXGE_HAL_ERR_EVENT_KDFCCTL);
  				return (VXGE_HAL_ERR_EVENT_KDFCCTL);
  			}
  
  			if (val64 &
  			    VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO1_POISON) {
  				vpath->sw_stats->error_stats.kdfcctl_fifo1_poison++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO1_POISON",
  				    __func__);
  
  			}
  
  			if (val64 &
  			    VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO2_POISON) {
  				vpath->sw_stats->error_stats.kdfcctl_fifo2_poison++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO2_POISON",
  				    __func__);
  			}
  
  			if (val64 &
  			    VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_DMA_ERR) {
  				vpath->sw_stats->error_stats.kdfcctl_fifo0_dma_error++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_DMA_ERR",
  				    __func__);
  
  				__hal_device_handle_error(hldev, vpath->vp_id,
  				    VXGE_HAL_EVENT_KDFCCTL);
  
  				if (!skip_alarms) {
  					vxge_os_pio_mem_write64(hldev->header.pdev,
  					    hldev->header.regh0,
  					    VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_DMA_ERR,
  					    &vpath->vp_reg->kdfcctl_errors_reg);
  				}
  
  				vxge_hal_trace_log_vpath_irq("<== %s:%s:%d \
  				    Result = %d", __FILE__, __func__, __LINE__,
  				    VXGE_HAL_ERR_EVENT_KDFCCTL);
  				return (VXGE_HAL_ERR_EVENT_KDFCCTL);
  			}
  
  			if (val64 &
  			    VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO1_DMA_ERR) {
  				vpath->sw_stats->error_stats.kdfcctl_fifo1_dma_error++;
  				vxge_hal_info_log_vpath_irq("%s:"
  				    "VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO1_DMA_ERR",
  				    __func__);
  			}
  
  			if (val64 &
  			    VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO2_DMA_ERR) {
  				vpath->sw_stats->error_stats.kdfcctl_fifo2_dma_error++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO2_DMA_ERR",
  				    __func__);
  			}
  
  			if (!skip_alarms) {
  				vxge_os_pio_mem_write64(hldev->header.pdev,
  				    hldev->header.regh0,
  				    VXGE_HAL_INTR_MASK_ALL,
  				    &vpath->vp_reg->kdfcctl_errors_reg);
  			}
  		}
  	}
  
  	if (alarm_status & VXGE_HAL_VPATH_GENERAL_INT_STATUS_PCI_INT) {
  
  		pif_status = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->vpath_pcipif_int_status);
  
  		vxge_hal_info_log_vpath_irq(
  		    "vpath_pcipif_int_status = 0x"VXGE_OS_STXFMT,
  		    (ptr_t) pif_status);
  
  		if (pif_status &
  		    VXGE_HAL_VPATH_PCIPIF_INT_STATUS_SRPCIM_MSG_TO_VPATH_INT) {
  
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &vpath->vp_reg->srpcim_msg_to_vpath_reg);
  
  			vxge_hal_info_log_vpath_irq(
  			    "srpcim_msg_to_vpath_reg = 0x"VXGE_OS_STXFMT,
  			    (ptr_t) val64);
  
  			if (val64 &
  			    VXGE_HAL_SRPCIM_MSG_TO_VPATH_REG_INT) {
  
  				val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  				    hldev->header.regh0,
  				    &vpath->vpmgmt_reg->srpcim_to_vpath_wmsg);
  
  				__hal_ifmsg_wmsg_process(vpath, val64);
  
  				vpath->sw_stats->error_stats.srpcim_msg_to_vpath++;
  
  				vxge_os_pio_mem_write64(hldev->header.pdev,
  				    hldev->header.regh0,
  				    0,
  				    &vpath->vpmgmt_reg->srpcim_to_vpath_wmsg);
  
  				vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  				    hldev->header.regh0,
  				    (u32) VXGE_HAL_INTR_MASK_ALL,
  				    &vpath->vp_reg->srpcim_msg_to_vpath_mask);
  
  				vxge_hal_info_log_vpath_irq("%s:"
  				    "VXGE_HAL_SRPCIM_MSG_TO_VPATH_REG_INT",
  				    __func__);
  			}
  
  			vxge_os_pio_mem_write64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    VXGE_HAL_INTR_MASK_ALL,
  			    &vpath->vp_reg->srpcim_msg_to_vpath_reg);
  		}
  	}
  
  	if (alarm_status & VXGE_HAL_VPATH_GENERAL_INT_STATUS_XMAC_INT) {
  
  		xgmac_status = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->xgmac_vp_int_status);
  
  		vxge_hal_info_log_vpath_irq("xgmac_status = 0x"VXGE_OS_STXFMT,
  		    (ptr_t) xgmac_status);
  
  		if (xgmac_status &
  		    VXGE_HAL_XGMAC_VP_INT_STATUS_ASIC_NTWK_VP_ERR_INT) {
  
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &vpath->vp_reg->asic_ntwk_vp_err_reg);
  
  			vxge_hal_info_log_vpath_irq(
  			    "asic_ntwk_vp_err_reg = 0x"VXGE_OS_STXFMT,
  			    (ptr_t) val64);
  
  			if (((val64 & VXGE_HAL_ASIC_NTWK_VP_ERR_REG_SUS_FAULT) &&
  			    (!(val64 & VXGE_HAL_ASIC_NTWK_VP_ERR_REG_SUS_OK))) ||
  			    ((val64 & VXGE_HAL_ASIC_NTWK_VP_ERR_REG_SUS_FAULT_OCCURRED) &&
  			    (!(val64 & VXGE_HAL_ASIC_NTWK_VP_ERR_REG_SUS_OK_OCCURRED)))) {
  				vpath->sw_stats->error_stats.network_sustained_fault++;
  				vxge_hal_info_log_vpath_irq("%s:" \
  				    "VXGE_HAL_ASIC_NTWK_VP_ERR_REG_SUS_FAULT",
  				    __func__);
  				vxge_os_pio_mem_write64(vpath->hldev->header.pdev,
  				    hldev->header.regh0,
  				    VXGE_HAL_ASIC_NTWK_VP_ERR_REG_SUS_FAULT,
  				    &vpath->vp_reg->asic_ntwk_vp_err_mask);
  
  				(void) __hal_device_handle_link_down_ind(hldev);
  			}
  
  			if (((val64 & VXGE_HAL_ASIC_NTWK_VP_ERR_REG_SUS_OK) &&
  			    (!(val64 & VXGE_HAL_ASIC_NTWK_VP_ERR_REG_SUS_FAULT))) ||
  			    ((val64 & VXGE_HAL_ASIC_NTWK_VP_ERR_REG_SUS_OK_OCCURRED) &&
  			    (!(val64 & VXGE_HAL_ASIC_NTWK_VP_ERR_REG_SUS_FAULT_OCCURRED)))) {
  				vpath->sw_stats->error_stats.network_sustained_ok++;
  				vxge_hal_info_log_vpath_irq(
  				    "%s:VXGE_HAL_ASIC_NTWK_VP_ERR_REG_SUS_OK",
  				    __func__);
  
  				vxge_os_pio_mem_write64(hldev->header.pdev,
  				    hldev->header.regh0,
  				    VXGE_HAL_ASIC_NTWK_VP_ERR_REG_SUS_OK,
  				    &vpath->vp_reg->asic_ntwk_vp_err_mask);
  
  				(void) __hal_device_handle_link_up_ind(hldev);
  			}
  
  			vxge_os_pio_mem_write64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    VXGE_HAL_INTR_MASK_ALL,
  			    &vpath->vp_reg->asic_ntwk_vp_err_reg);
  			return (VXGE_HAL_INF_LINK_UP_DOWN);
  		}
  	}
  
  	if (alarm_status & ~(
  	    VXGE_HAL_VPATH_GENERAL_INT_STATUS_PIC_INT |
  	    VXGE_HAL_VPATH_GENERAL_INT_STATUS_PCI_INT |
  	    VXGE_HAL_VPATH_GENERAL_INT_STATUS_WRDMA_INT |
  	    VXGE_HAL_VPATH_GENERAL_INT_STATUS_XMAC_INT)) {
  
  		vpath->sw_stats->error_stats.unknown_alarms++;
  		vxge_hal_info_log_vpath_irq(
  		    "%s:%s:%d Unknown Alarm", __FILE__, __func__, __LINE__);
  
  		__hal_device_handle_error(hldev, vpath->vp_id,
  		    VXGE_HAL_EVENT_UNKNOWN);
  		status = VXGE_HAL_ERR_EVENT_UNKNOWN;
  
  	} else {
  		hldev->stats.sw_dev_err_stats.vpath_alarms++;
  		status = VXGE_HAL_OK;
  	}
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_begin_irq - Begin IRQ processing.
   * @vpath_handle: Virtual Path handle.
   * @skip_alarms: Do not clear the alarms
   * @reason: "Reason" for the interrupt,	the value of vpath's
   *			general_int_status register.
   *
   * The function	performs two actions, It first checks whether (shared IRQ) the
   * interrupt was raised	by the device. Next, it	masks the device interrupts.
   *
   * Note:
   * vxge_hal_vpath_begin_irq() does not flush MMIO writes through the
   * bridge. Therefore, two back-to-back interrupts are potentially possible.
   * It is the responsibility	of the ULD to make sure	that only one
   * vxge_hal_vpath_continue_irq() runs at a time.
   *
   * Returns: 0, if the interrupt	is not "ours" (note that in this case the
   * vpath remain enabled).
   * Otherwise, vxge_hal_vpath_begin_irq() returns 64bit general adapter
   * status.
   * See also: vxge_hal_vpath_handle_irq()
   */
  vxge_hal_status_e
  vxge_hal_vpath_begin_irq(vxge_hal_vpath_h vpath_handle,
      u32 skip_alarms, u64 *reason)
  {
  	u64 val64;
  	u64 adapter_status;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  	vxge_hal_status_e ret_val = VXGE_HAL_OK;
  
  	vxge_assert((vpath_handle != NULL) && (reason != NULL));
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", skip_alarms = %d, "
  	    "reason = 0x"VXGE_OS_STXFMT, (ptr_t) vpath_handle,
  	    skip_alarms, (ptr_t) reason);
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &hldev->common_reg->titan_general_int_status);
  
  	if (vxge_os_unlikely(!val64)) {
  		/* not Titan interrupt	 */
  		*reason = 0;
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_WRONG_IRQ);
  		return (VXGE_HAL_ERR_WRONG_IRQ);
  	}
  
  	if (vxge_os_unlikely(val64 == VXGE_HAL_ALL_FOXES)) {
  
  		adapter_status = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->adapter_status);
  
  		if (adapter_status == VXGE_HAL_ALL_FOXES) {
  			__hal_device_handle_error(hldev,
  			    vpath->vp_id,
  			    VXGE_HAL_EVENT_SLOT_FREEZE);
  
  			*reason = 0;
  			ret_val = VXGE_HAL_ERR_SLOT_FREEZE;
  			goto exit;
  		}
  	}
  
  	if (val64 &
  	    VXGE_HAL_TITAN_GENERAL_INT_STATUS_VPATH_TRAFFIC_INT(
  	    1 << (16 - vpath->vp_id))) {
  
  		if (vpath->vp_id < 16) {
  
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &hldev->common_reg->tim_int_mask0);
  
  			*reason = bVAL4(val64, (vpath->vp_id * 4));
  		} else {
  
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &hldev->common_reg->tim_int_mask1);
  
  			*reason = bVAL4(val64, 0);
  		}
  
  		return (VXGE_HAL_OK);
  	}
  
  	*reason = VXGE_HAL_INTR_ALARM;
  
  	if (vxge_os_unlikely(val64 &
  	    VXGE_HAL_TITAN_GENERAL_INT_STATUS_MRPCIM_ALARM_INT)) {
  		vxge_hal_info_log_vpath_irq(
  		    "%s:VXGE_HAL_TITAN_GENERAL_INT_STATUS_MRPCIM_ALARM_INT",
  		    __func__);
  		ret_val = VXGE_HAL_ERR_CRITICAL;
  		goto exit;
  	}
  
  	if (vxge_os_unlikely(val64 &
  	    VXGE_HAL_TITAN_GENERAL_INT_STATUS_SRPCIM_ALARM_INT)) {
  		vxge_hal_info_log_vpath_irq(
  		    "%s:VXGE_HAL_TITAN_GENERAL_INT_STATUS_SRPCIM_ALARM_INT",
  		    __func__);
  		ret_val = VXGE_HAL_ERR_CRITICAL;
  		goto exit;
  	}
  
  	if (vxge_os_unlikely(val64 &
  	    VXGE_HAL_TITAN_GENERAL_INT_STATUS_VPATH_ALARM_INT)) {
  		vxge_hal_info_log_vpath_irq(
  		    "%s:VXGE_HAL_TITAN_GENERAL_INT_STATUS_VPATH_ALARM_INT",
  		    __func__);
  		ret_val = __hal_vpath_alarm_process(vpath, skip_alarms);
  	}
  
  exit:
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (ret_val);
  
  }
  
  /*
   * vxge_hal_vpath_continue_irq - Continue handling IRQ:	process	all
   *				completed descriptors.
   * @vpath_handle: Virtual Path handle.
   *
   * Process completed descriptors and unmask the	vpath interrupts.
   *
   * The vxge_hal_vpath_continue_irq() calls upper-layer driver (ULD)
   * via supplied completion callback.
   *
   * Note	that the vxge_hal_vpath_continue_irq is	part of	the _fast_ path.
   * To optimize the processing, the function does _not_ check for
   * errors and alarms.
   *
   * Returns: VXGE_HAL_OK.
   *
   * See also: vxge_hal_vpath_handle_irq()
   * vxge_hal_ring_rxd_next_completed(),
   * vxge_hal_fifo_txdl_next_completed(), vxge_hal_ring_callback_f {},
   * vxge_hal_fifo_callback_f {}.
   */
  vxge_hal_status_e
  vxge_hal_vpath_continue_irq(vxge_hal_vpath_h vpath_handle)
  {
  	u32 got_rx = 1, got_tx = 1;
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  	u32 isr_polling_cnt;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	isr_polling_cnt = hldev->header.config.isr_polling_cnt;
  
  	do {
  		if (got_rx && (vp->vpath->ringh != NULL))
  			(void) vxge_hal_vpath_poll_rx(vpath_handle, &got_rx);
  
  		if (got_tx && (vp->vpath->fifoh != NULL))
  			(void) vxge_hal_vpath_poll_tx(vpath_handle, &got_tx);
  
  		if (!got_rx && !got_tx)
  			break;
  
  	} while (isr_polling_cnt--);
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_handle_irq - Handle vpath IRQ.
   * @vpath_handle: Virtual Path handle.
   * @skip_alarms: Do not clear the alarms
   *
   * Perform the complete	handling of the	line interrupt.	The function
   * performs two	calls.
   * First it uses vxge_hal_vpath_begin_irq() to check the reason for
   * the interrupt and mask the vpath interrupts.
   * Second, it calls vxge_hal_vpath_continue_irq() to process all
   * completed descriptors and re-enable the interrupts.
   *
   * Returns: VXGE_HAL_OK - success;
   * VXGE_HAL_ERR_WRONG_IRQ - (shared) IRQ produced by other device.
   *
   * See also: vxge_hal_vpath_begin_irq(), vxge_hal_vpath_continue_irq().
   */
  vxge_hal_status_e
  vxge_hal_vpath_handle_irq(vxge_hal_vpath_h vpath_handle, u32 skip_alarms)
  {
  	u64 reason;
  	vxge_hal_status_e status;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  	vxge_hal_vpath_mask_all(vpath_handle);
  
  	status = vxge_hal_vpath_begin_irq(vpath_handle,
  	    skip_alarms, &reason);
  
  	if (status != VXGE_HAL_OK) {
  		vxge_hal_vpath_unmask_all(vpath_handle);
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	if (reason & VXGE_HAL_INTR_ALARM) {
  		if (skip_alarms) {
  			/* ULD needs to unmask explicitely */
  			vxge_hal_trace_log_vpath_irq(
  			    "<== %s:%s:%d Result = %d",
  			    __FILE__, __func__, __LINE__,
  			    VXGE_HAL_ERR_CRITICAL);
  			return (VXGE_HAL_ERR_CRITICAL);
  		} else {
  			vxge_hal_vpath_unmask_all(vpath_handle);
  			vxge_hal_trace_log_vpath_irq(
  			    "<== %s:%s:%d Result = %d",
  			    __FILE__, __func__, __LINE__, status);
  			return (status);
  		}
  	}
  
  	if (reason & VXGE_HAL_INTR_RX)
  		vxge_hal_vpath_clear_rx(vpath_handle);
  
  	status = vxge_hal_vpath_continue_irq(vpath_handle);
  
  	vxge_hal_vpath_clear_tx(vpath_handle);
  
  	vxge_hal_vpath_unmask_all(vpath_handle);
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_mask_tx - Mask Tx interrupts.
   * @vpath_handle: Virtual Path handle.
   *
   * Mask	Tx device interrupts.
   *
   * See also: vxge_hal_vpath_unmask_tx(), vxge_hal_vpath_mask_rx(),
   * vxge_hal_vpath_clear_tx().
   */
  void
  vxge_hal_vpath_mask_tx(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->fifoh == NULL) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_INVALID_HANDLE);
  		return;
  	}
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return;
  	}
  
  	if (vpath->vp_id < 16) {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->tim_int_mask0);
  
  		val64 |= vBIT(VXGE_HAL_INTR_TX, (vpath->vp_id * 4), 4);
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &hldev->common_reg->tim_int_mask0);
  
  	} else {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->tim_int_mask1);
  
  		val64 |= VXGE_HAL_TIM_INT_MASK1_TIM_INT_MASK1(VXGE_HAL_INTR_TX);
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) bVAL32(val64, 0),
  		    &hldev->common_reg->tim_int_mask1);
  	}
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  /*
   * vxge_hal_vpath_clear_tx - Acknowledge (that is, clear) the
   * condition that has caused the TX interrupt.
   * @vpath_handle: Virtual Path handle.
   *
   * Acknowledge (that is, clear)	the condition that has caused
   * the Tx interrupt.
   * See also: vxge_hal_vpath_begin_irq(), vxge_hal_vpath_continue_irq(),
   * vxge_hal_vpath_clear_rx(), vxge_hal_vpath_mask_tx().
   */
  void
  vxge_hal_vpath_clear_tx(vxge_hal_vpath_h vpath_handle)
  {
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->fifoh == NULL) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_INVALID_HANDLE);
  		return;
  	}
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return;
  	}
  
  	if (vpath->vp_id < 16) {
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    vBIT(VXGE_HAL_INTR_TX, (vpath->vp_id * 4), 4),
  		    &hldev->common_reg->tim_int_status0);
  
  	} else {
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0, (u32) bVAL32(
  		    vBIT(VXGE_HAL_INTR_TX, 0, 4),
  		    0),
  		    &hldev->common_reg->tim_int_status1);
  
  	}
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  /*
   * vxge_hal_vpath_unmask_tx - Unmask Tx	interrupts.
   * @vpath_handle: Virtual Path handle.
   *
   * Unmask Tx vpath interrupts.
   *
   * See also: vxge_hal_vpath_mask_tx(), vxge_hal_vpath_clear_tx().
   */
  void
  vxge_hal_vpath_unmask_tx(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->fifoh == NULL) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_INVALID_HANDLE);
  		return;
  	}
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_VPATH_NOT_AVAILABLE);
  		return;
  	}
  
  	if (vpath->vp_id < 16) {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->tim_int_mask0);
  
  		val64 &= ~vBIT(VXGE_HAL_INTR_TX, (vpath->vp_id * 4), 4);
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &hldev->common_reg->tim_int_mask0);
  
  	} else {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->tim_int_mask1);
  
  		val64 &=
  		    ~VXGE_HAL_TIM_INT_MASK1_TIM_INT_MASK1(VXGE_HAL_INTR_TX);
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) bVAL32(val64, 0),
  		    &hldev->common_reg->tim_int_mask1);
  
  	}
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  /*
   * vxge_hal_vpath_mask_rx - Mask Rx	interrupts.
   * @vpath_handle: Virtual Path handle.
   *
   * Mask	Rx vpath interrupts.
   *
   * See also: vxge_hal_vpath_unmask_rx(), vxge_hal_vpath_mask_tx(),
   * vxge_hal_vpath_clear_rx().
   */
  void
  vxge_hal_vpath_mask_rx(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return;
  	}
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return;
  	}
  
  	if (vpath->vp_id < 16) {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->tim_int_mask0);
  
  		val64 |= vBIT(VXGE_HAL_INTR_RX, (vpath->vp_id * 4), 4);
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &hldev->common_reg->tim_int_mask0);
  
  	} else {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->tim_int_mask1);
  
  		val64 |= VXGE_HAL_TIM_INT_MASK1_TIM_INT_MASK1(VXGE_HAL_INTR_RX);
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) bVAL32(val64, 0),
  		    &hldev->common_reg->tim_int_mask1);
  
  	}
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  
  /*
   * vxge_hal_vpath_clear_rx - Acknowledge (that is, clear) the
   * condition that has caused the RX	interrupt.
   * @vpath_handle: Virtual Path handle.
   *
   * Acknowledge (that is, clear)	the condition that has caused
   * the Rx interrupt.
   * See also: vxge_hal_vpath_begin_irq(), vxge_hal_vpath_continue_irq(),
   * vxge_hal_vpath_clear_tx(), vxge_hal_vpath_mask_rx().
   */
  void
  vxge_hal_vpath_clear_rx(vxge_hal_vpath_h vpath_handle)
  {
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return;
  	}
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return;
  	}
  
  	if (vpath->vp_id < 16) {
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    vBIT(VXGE_HAL_INTR_RX, (vpath->vp_id * 4), 4),
  		    &hldev->common_reg->tim_int_status0);
  
  	} else {
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) bVAL32(vBIT(VXGE_HAL_INTR_RX, 0, 4), 0),
  		    &hldev->common_reg->tim_int_status1);
  
  	}
  
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  /*
   * vxge_hal_vpath_unmask_rx - Unmask Rx	interrupts.
   * @vpath_handle: Virtual Path handle.
   *
   * Unmask Rx vpath interrupts.
   *
   * See also: vxge_hal_vpath_mask_rx(), vxge_hal_vpath_clear_rx().
   */
  void
  vxge_hal_vpath_unmask_rx(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->ringh == NULL) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return;
  	}
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return;
  	}
  
  	if (vpath->vp_id < 16) {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->tim_int_mask0);
  
  		val64 &= ~vBIT(VXGE_HAL_INTR_RX, (vpath->vp_id * 4), 4);
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &hldev->common_reg->tim_int_mask0);
  
  	} else {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->tim_int_mask1);
  
  		val64 &=
  		    ~VXGE_HAL_TIM_INT_MASK1_TIM_INT_MASK1(VXGE_HAL_INTR_RX);
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) bVAL32(val64, 0),
  		    &hldev->common_reg->tim_int_mask1);
  
  	}
  
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  /*
   * vxge_hal_vpath_mask_tx_rx - Mask Tx and Rx interrupts.
   * @vpath_handle: Virtual Path handle.
   *
   * Mask	Tx and Rx vpath interrupts.
   *
   * See also: vxge_hal_vpath_unmask_tx_rx(), vxge_hal_vpath_clear_tx_rx().
   */
  void
  vxge_hal_vpath_mask_tx_rx(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return;
  	}
  
  	if (vpath->vp_id < 16) {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->tim_int_mask0);
  
  		val64 |= vBIT(VXGE_HAL_INTR_TX, (vpath->vp_id * 4), 4) |
  		    vBIT(VXGE_HAL_INTR_RX, (vpath->vp_id * 4), 4);
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &hldev->common_reg->tim_int_mask0);
  
  	} else {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->tim_int_mask1);
  
  		val64 |=
  		    VXGE_HAL_TIM_INT_MASK1_TIM_INT_MASK1(VXGE_HAL_INTR_TX) |
  		    VXGE_HAL_TIM_INT_MASK1_TIM_INT_MASK1(VXGE_HAL_INTR_RX);
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) bVAL32(val64, 0),
  		    &hldev->common_reg->tim_int_mask1);
  
  	}
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  
  /*
   * vxge_hal_vpath_clear_tx_rx - Acknowledge (that is, clear) the
   * condition that has caused the Tx and RX interrupt.
   * @vpath_handle: Virtual Path handle.
   *
   * Acknowledge (that is, clear)	the condition that has caused
   * the Tx and Rx interrupt.
   * See also: vxge_hal_vpath_begin_irq(), vxge_hal_vpath_continue_irq(),
   * vxge_hal_vpath_clear_tx_rx(), vxge_hal_vpath_mask_tx_rx().
   */
  void
  vxge_hal_vpath_clear_tx_rx(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return;
  	}
  
  	val64 = 0;
  
  	if (vpath->vp_id < 16) {
  
  		if (vpath->fifoh != NULL)
  			val64 |= vBIT(VXGE_HAL_INTR_TX, (vpath->vp_id * 4), 4);
  		else
  			val64 &= ~vBIT(VXGE_HAL_INTR_TX, (vpath->vp_id * 4), 4);
  
  		if (vpath->ringh != NULL)
  			val64 |= vBIT(VXGE_HAL_INTR_RX, (vpath->vp_id * 4), 4);
  		else
  			val64 &= ~vBIT(VXGE_HAL_INTR_RX, (vpath->vp_id * 4), 4);
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &hldev->common_reg->tim_int_status0);
  
  	} else {
  
  		if (vpath->fifoh != NULL)
  			val64 |= vBIT(VXGE_HAL_INTR_TX, 0, 4);
  
  		if (vpath->ringh != NULL)
  			val64 |= vBIT(VXGE_HAL_INTR_RX, 0, 4);
  		else
  			val64 &= ~vBIT(VXGE_HAL_INTR_RX, 0, 4);
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) bVAL32(val64, 0),
  		    &hldev->common_reg->tim_int_status1);
  
  	}
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  /*
   * vxge_hal_vpath_unmask_tx_rx - Unmask Tx and Rx interrupts.
   * @vpath_handle: Virtual Path handle.
   *
   * Unmask Tx and Rx vpath interrupts.
   *
   * See also: vxge_hal_vpath_mask_tx_rx(), vxge_hal_vpath_clear_tx_rx().
   */
  void
  vxge_hal_vpath_unmask_tx_rx(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return;
  	}
  
  	if (vpath->vp_id < 16) {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->tim_int_mask0);
  
  		if (vpath->fifoh != NULL)
  			val64 &= ~vBIT(VXGE_HAL_INTR_TX, (vpath->vp_id * 4), 4);
  		else
  			val64 |= vBIT(VXGE_HAL_INTR_TX, (vpath->vp_id * 4), 4);
  
  		if (vpath->ringh != NULL)
  			val64 &= ~vBIT(VXGE_HAL_INTR_RX, (vpath->vp_id * 4), 4);
  		else
  			val64 |= vBIT(VXGE_HAL_INTR_RX, (vpath->vp_id * 4), 4);
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &hldev->common_reg->tim_int_mask0);
  
  	} else {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->tim_int_mask1);
  
  		if (vpath->fifoh != NULL)
  			val64 &= ~VXGE_HAL_TIM_INT_MASK1_TIM_INT_MASK1(
  			    VXGE_HAL_INTR_TX);
  		else
  			val64 |= VXGE_HAL_TIM_INT_MASK1_TIM_INT_MASK1(
  			    VXGE_HAL_INTR_TX);
  
  		if (vpath->ringh != NULL)
  			val64 &= ~VXGE_HAL_TIM_INT_MASK1_TIM_INT_MASK1(
  			    VXGE_HAL_INTR_RX);
  		else
  			val64 |= VXGE_HAL_TIM_INT_MASK1_TIM_INT_MASK1(
  			    VXGE_HAL_INTR_RX);
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) bVAL32(val64, 0),
  		    &hldev->common_reg->tim_int_mask1);
  
  	}
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  /*
   * vxge_hal_vpath_alarm_process - Process Alarms.
   * @vpath: Virtual Path.
   * @skip_alarms: Do not clear the alarms
   *
   * Process vpath alarms.
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_alarm_process(vxge_hal_vpath_h vpath_handle, u32 skip_alarms)
  {
  	vxge_hal_status_e status;
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	status = __hal_vpath_alarm_process(
  	    vp->vpath,
  	    skip_alarms);
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_msix_mode - Is MSIX enabled?
   * @vpath_handle: Virtual Path handle.
   *
   * Returns 0 if MSI is enabled for the specified device,
   * non-zero otherwise.
   */
  u32
  vxge_hal_vpath_msix_mode(vxge_hal_vpath_h vpath_handle)
  {
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (hldev->header.msix_enabled);
  }
  
  /*
   * vxge_hal_vpath_msix_set
   * Associate MSIX vectors with TIM interrupts and alrms
   * @vpath_handle: Virtual Path handle.
   * @tim_msix_id: MSIX vectors associated with VXGE_HAL_VPATH_MSIX_MAX number of
   *		interrupts(Can be repeated). If fifo or ring are not enabled
   *		the MSIX vector for that should be set to 0
   * @alarm_msix_id: MSIX vector for alarm.
   *
   * This API will associate a given MSIX vector numbers with the four TIM
   * interrupts and alarm interrupt.
   */
  vxge_hal_status_e
  vxge_hal_vpath_msix_set(vxge_hal_vpath_h vpath_handle,
      int *tim_msix_id,
      int alarm_msix_id)
  {
  	u32 i;
  	u32 j;
  	u32 rvp_id;
  	u32 msix_id;
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vp != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT", "
  	    "tim_msix_id0 = %d, tim_msix_id1 = %d, tim_msix_id2 = %d, "
  	    "tim_msix_id3 = %d, alarm_msix_id = %d", (ptr_t) vpath_handle,
  	    tim_msix_id[0], tim_msix_id[1], tim_msix_id[2], tim_msix_id[3],
  	    alarm_msix_id);
  
  	for (i = 0; i < VXGE_HAL_VPATH_MSIX_MAX + 1; i++) {
  
  		if (i == VXGE_HAL_VPATH_MSIX_MAX)
  			msix_id = alarm_msix_id;
  		else
  			msix_id = tim_msix_id[i];
  
  		rvp_id = msix_id / VXGE_HAL_VPATH_MSIX_MAX;
  
  		for (j = 0; j < VXGE_HAL_MAX_VIRTUAL_PATHS; j++) {
  
  			if (!(hldev->vpath_assignments & mBIT(j)))
  				continue;
  
  			if (rvp_id-- == 0) {
  				hldev->msix_map[msix_id].vp_id = j;
  				hldev->msix_map[msix_id].int_num =
  				    msix_id % VXGE_HAL_VPATH_MSIX_MAX;
  				break;
  			}
  		}
  	}
  
  	val64 = VXGE_HAL_INTERRUPT_CFG0_GROUP0_MSIX_FOR_TXTI(
  	    hldev->msix_map[tim_msix_id[0]].vp_id * VXGE_HAL_VPATH_MSIX_MAX +
  	    hldev->msix_map[tim_msix_id[0]].int_num) |
  	    VXGE_HAL_INTERRUPT_CFG0_GROUP1_MSIX_FOR_TXTI(
  	    hldev->msix_map[tim_msix_id[1]].vp_id * VXGE_HAL_VPATH_MSIX_MAX +
  	    hldev->msix_map[tim_msix_id[1]].int_num) |
  	    VXGE_HAL_INTERRUPT_CFG0_GROUP2_MSIX_FOR_TXTI(
  	    hldev->msix_map[tim_msix_id[2]].vp_id * VXGE_HAL_VPATH_MSIX_MAX +
  	    hldev->msix_map[tim_msix_id[2]].int_num) |
  	    VXGE_HAL_INTERRUPT_CFG0_GROUP3_MSIX_FOR_TXTI(
  	    hldev->msix_map[tim_msix_id[3]].vp_id * VXGE_HAL_VPATH_MSIX_MAX +
  	    hldev->msix_map[tim_msix_id[3]].int_num);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vp->vpath->vp_reg->interrupt_cfg0);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    VXGE_HAL_INTERRUPT_CFG2_ALARM_MAP_TO_MSG(
  	    hldev->msix_map[alarm_msix_id].vp_id * VXGE_HAL_VPATH_MSIX_MAX +
  	    hldev->msix_map[alarm_msix_id].int_num),
  	    &vp->vpath->vp_reg->interrupt_cfg2);
  
  	if (hldev->header.config.intr_mode ==
  	    VXGE_HAL_INTR_MODE_MSIX_ONE_SHOT) {
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0, (u32) bVAL32(
  		    VXGE_HAL_ONE_SHOT_VECT0_EN_ONE_SHOT_VECT0_EN, 0),
  		    &vp->vpath->vp_reg->one_shot_vect0_en);
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0, (u32) bVAL32(
  		    VXGE_HAL_ONE_SHOT_VECT1_EN_ONE_SHOT_VECT1_EN, 0),
  		    &vp->vpath->vp_reg->one_shot_vect1_en);
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0, (u32) bVAL32(
  		    VXGE_HAL_ONE_SHOT_VECT2_EN_ONE_SHOT_VECT2_EN, 0),
  		    &vp->vpath->vp_reg->one_shot_vect2_en);
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0, (u32) bVAL32(
  		    VXGE_HAL_ONE_SHOT_VECT3_EN_ONE_SHOT_VECT3_EN, 0),
  		    &vp->vpath->vp_reg->one_shot_vect3_en);
  
  	} else if (hldev->header.config.intr_mode ==
  	    VXGE_HAL_INTR_MODE_EMULATED_INTA) {
  		/* For emulated-INTA we are only using MSI-X 1 to be one shot */
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0, (u32) bVAL32(
  		    VXGE_HAL_ONE_SHOT_VECT1_EN_ONE_SHOT_VECT1_EN, 0),
  		    &vp->vpath->vp_reg->one_shot_vect1_en);
  
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_msix_mask - Mask MSIX Vector.
   * @vpath_handle: Virtual Path handle.
   * @msix_id:  MSIX ID
   *
   * The function masks the msix interrupt for the given msix_id
   *
   * Note:
   *
   * Returns: 0,
   * Otherwise, VXGE_HAL_ERR_WRONG_IRQ if the msix index is out of range
   * status.
   * See also:
   */
  void
  vxge_hal_vpath_msix_mask(vxge_hal_vpath_h vpath_handle, int msix_id)
  {
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", msix_id = %d",
  	    (ptr_t) vpath_handle, msix_id);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(mBIT(hldev->msix_map[msix_id].vp_id), 0),
  	    &hldev->common_reg->set_msix_mask_vect[
  	    hldev->msix_map[msix_id].int_num]);
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  /*
   * vxge_hal_vpath_msix_clear - Clear MSIX Vector.
   * @vpath_handle: Virtual Path handle.
   * @msix_id:  MSI ID
   *
   * The function clears the msix interrupt for the given msix_id
   *
   * Note:
   *
   * Returns: 0,
   * Otherwise, VXGE_HAL_ERR_WRONG_IRQ if the msix index is out of range
   * status.
   * See also:
   */
  void
  vxge_hal_vpath_msix_clear(vxge_hal_vpath_h vpath_handle, int msix_id)
  {
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vp = (__hal_vpath_handle_t *) vpath_handle;
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", msix_id = %d",
  	    (ptr_t) vpath_handle, msix_id);
  
  	if ((hldev->header.config.intr_mode ==
  	    VXGE_HAL_INTR_MODE_MSIX_ONE_SHOT) ||
  	    (hldev->header.config.intr_mode ==
  	    VXGE_HAL_INTR_MODE_EMULATED_INTA)) {
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) bVAL32(mBIT(hldev->msix_map[msix_id].vp_id), 0),
  		    &hldev->common_reg->clr_msix_one_shot_vec[
  		    hldev->msix_map[msix_id].int_num]);
  
  		if (hldev->header.config.intr_mode ==
  		    VXGE_HAL_INTR_MODE_EMULATED_INTA) {
  			/* Adding read to flush the write,
  			 * for HP-ISS platform
  			 */
  			vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &hldev->common_reg->titan_general_int_status);
  		}
  	} else {
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) bVAL32(mBIT(hldev->msix_map[msix_id].vp_id), 0),
  		    &hldev->common_reg->clear_msix_mask_vect[
  		    hldev->msix_map[msix_id].int_num]);
  	}
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  /* NEW CODE BEGIN */
  
  vxge_hal_status_e
  vxge_hal_vpath_mf_msix_set(vxge_hal_vpath_h vpath_handle,
      int *tim_msix_id,
      int alarm_msix_id)
  {
  
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vp = (__hal_vpath_handle_t *) vpath_handle;
  	hldev = vp->vpath->hldev;
  
  	/* Write the internal msi-x vectors numbers */
  	val64 = VXGE_HAL_INTERRUPT_CFG0_GROUP0_MSIX_FOR_TXTI(tim_msix_id[0]) |
  	    VXGE_HAL_INTERRUPT_CFG0_GROUP1_MSIX_FOR_TXTI(tim_msix_id[1]);
  
  #if defined(VXGE_EMULATED_INTA)
  	if (hldev->config.intr_mode ==
  	    VXGE_HAL_INTR_MODE_EMULATED_INTA)
  		val64 |= VXGE_HAL_INTERRUPT_CFG0_GROUP2_MSIX_FOR_TXTI(
  		    (vp->vpath->vp_id * 4) + tim_msix_id[2]);
  #endif
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vp->vpath->vp_reg->interrupt_cfg0);
  
  	vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp->vpath->vp_reg->interrupt_cfg0);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    VXGE_HAL_INTERRUPT_CFG2_ALARM_MAP_TO_MSG(
  	    (hldev->first_vp_id * 4) + alarm_msix_id),
  	    &vp->vpath->vp_reg->interrupt_cfg2);
  
  	if (
  #if defined(VXGE_EMULATED_INTA)
  	    (hldev->header.config.intr_mode ==
  	    VXGE_HAL_INTR_MODE_EMULATED_INTA) ||
  #endif
  	    (hldev->header.config.intr_mode ==
  	    VXGE_HAL_INTR_MODE_MSIX_ONE_SHOT)) {
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0, (u32) bVAL32(
  		    VXGE_HAL_ONE_SHOT_VECT1_EN_ONE_SHOT_VECT1_EN, 0),
  		    &vp->vpath->vp_reg->one_shot_vect1_en);
  	}
  
  	if (hldev->header.config.intr_mode ==
  	    VXGE_HAL_INTR_MODE_MSIX_ONE_SHOT) {
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0, (u32) bVAL32(
  		    VXGE_HAL_ONE_SHOT_VECT2_EN_ONE_SHOT_VECT2_EN, 0),
  		    &vp->vpath->vp_reg->one_shot_vect2_en);
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0, (u32) bVAL32(
  		    VXGE_HAL_ONE_SHOT_VECT3_EN_ONE_SHOT_VECT3_EN, 0),
  		    &vp->vpath->vp_reg->one_shot_vect3_en);
  	}
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_mf_msix_mask - Mask MSIX Vector.
   * @vp: Virtual Path handle.
   * @msix_id:  MSIX ID
   *
   * The function masks the msix interrupt for the given msix_id
   *
   * Returns: 0,
   * Otherwise, VXGE_HW_ERR_WRONG_IRQ if the msix index is out of range
   * status.
   * See also:
   */
  void
  vxge_hal_vpath_mf_msix_mask(vxge_hal_vpath_h vpath_handle, int msix_id)
  {
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_hal_pio_mem_write32_upper(vp->vpath->hldev->header.pdev,
  	    vp->vpath->hldev->header.regh0, (u32) bVAL32(mBIT(msix_id >> 2), 0),
  	    &vp->vpath->hldev->common_reg->set_msix_mask_vect[msix_id % 4]);
  }
  
  /*
   * vxge_hal_vpath_mf_msix_clear - Clear MSIX Vector.
   * @vp: Virtual Path handle.
   * @msix_id:  MSI ID
   *
   * The function clears the msix interrupt for the given msix_id
   *
   * Returns: 0,
   * Otherwise, VXGE_HW_ERR_WRONG_IRQ if the msix index is out of range
   * status.
   * See also:
   */
  void
  vxge_hal_vpath_mf_msix_clear(vxge_hal_vpath_h vpath_handle, int msix_id)
  {
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	if (
  #if defined(VXGE_EMULATED_INTA)
  	    (hldev->header.config.intr_mode ==
  	    VXGE_HAL_INTR_MODE_EMULATED_INTA) ||
  #endif
  	    (hldev->header.config.intr_mode ==
  	    VXGE_HAL_INTR_MODE_MSIX_ONE_SHOT)) {
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) bVAL32(mBIT((msix_id >> 2)), 0),
  		    &hldev->common_reg->clr_msix_one_shot_vec[msix_id % 4]);
  	} else {
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) bVAL32(mBIT((msix_id >> 2)), 0),
  		    &hldev->common_reg->clear_msix_mask_vect[msix_id % 4]);
  	}
  }
  
  /*
   * vxge_hal_vpath_mf_msix_unmask - Unmask the MSIX Vector.
   * @vp: Virtual Path handle.
   * @msix_id:  MSI ID
   *
   * The function unmasks the msix interrupt for the given msix_id
   *
   * Returns: 0,
   * Otherwise, VXGE_HW_ERR_WRONG_IRQ if the msix index is out of range
   * status.
   * See also:
   */
  void
  vxge_hal_vpath_mf_msix_unmask(vxge_hal_vpath_h vpath_handle, int msix_id)
  {
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  	vxge_hal_pio_mem_write32_upper(vp->vpath->hldev->header.pdev,
  	    vp->vpath->hldev->header.regh0,
  	    (u32) bVAL32(mBIT(msix_id >> 2), 0),
  	    &vp->vpath->hldev->common_reg->
  	    clear_msix_mask_vect[msix_id % 4]);
  }
  
  /* NEW CODE ENDS */
  
  /*
   * vxge_hal_vpath_msix_unmask - Unmask the MSIX Vector.
   * @vpath_handle: Virtual Path handle.
   * @msix_id:  MSI ID
   *
   * The function unmasks the msix interrupt for the given msix_id
   *
   * Note:
   *
   * Returns: 0,
   * Otherwise, VXGE_HAL_ERR_WRONG_IRQ if the msix index is out of range
   * status.
   * See also:
   */
  void
  vxge_hal_vpath_msix_unmask(vxge_hal_vpath_h vpath_handle, int msix_id)
  {
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT", msix_id = %d",
  	    (ptr_t) vpath_handle, msix_id);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(mBIT(hldev->msix_map[msix_id].vp_id), 0),
  	    &hldev->common_reg->clear_msix_mask_vect[
  	    hldev->msix_map[msix_id].int_num]);
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  /*
   * vxge_hal_vpath_msix_mask_all - Mask all MSIX vectors for the vpath.
   * @vpath_handle: Virtual Path handle.
   *
   * The function masks all msix interrupt for the given vpath
   *
   */
  void
  vxge_hal_vpath_msix_mask_all(vxge_hal_vpath_h vpath_handle)
  {
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT, (ptr_t) vpath_handle);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(mBIT(vp->vpath->vp_id), 0),
  	    &hldev->common_reg->set_msix_mask_all_vect);
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  
  }
  
  /*
   * vxge_hal_vpath_msix_unmask_all - Unmask all MSIX vectors for the vpath.
   * @vpath_handle: Virtual Path handle.
   *
   * The function unmasks the msix interrupt for the given vpath
   *
   */
  void
  vxge_hal_vpath_msix_unmask_all(vxge_hal_vpath_h vpath_handle)
  {
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(mBIT(vp->vpath->vp_id), 0),
  	    &hldev->common_reg->clear_msix_mask_all_vect);
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d Result = 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  /*
   * vxge_hal_vpath_poll_rx - Poll Rx Virtual Path for completed
   *			descriptors and process the same.
   * @vpath_handle: Virtual Path ahandle.
   * @got_rx: Buffer to return the flag set if receive interrupt is occured
   *
   * The function	polls the Rx for the completed	descriptors and	calls
   * the upper-layer driver (ULD)	via supplied completion	callback.
   *
   * Returns: VXGE_HAL_OK, if the polling is completed successful.
   * VXGE_HAL_COMPLETIONS_REMAIN: There are still more completed
   * descriptors available which are yet to be processed.
   *
   * See also: vxge_hal_vpath_poll_tx()
   */
  vxge_hal_status_e
  vxge_hal_vpath_poll_rx(vxge_hal_vpath_h vpath_handle, u32 *got_rx)
  {
  	u8 t_code;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	vxge_hal_rxd_h first_rxdh;
  	void *rxd_priv;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  	__hal_ring_t *ring;
  
  	vxge_assert((vpath_handle != NULL) && (got_rx != NULL));
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq(
  	    "vpathh = 0x"VXGE_OS_STXFMT", got_rx = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, (ptr_t) got_rx);
  
  	ring = (__hal_ring_t *) vpath->ringh;
  	if (ring == NULL) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	ring->cmpl_cnt = 0;
  	ring->channel.poll_bytes = 0;
  	*got_rx = 0;
  
  	if ((status = vxge_hal_ring_rxd_next_completed(vpath_handle,
  	    &first_rxdh, &rxd_priv, &t_code)) == VXGE_HAL_OK) {
  		if (ring->callback(vpath_handle, first_rxdh, rxd_priv,
  		    t_code, ring->channel.userdata) != VXGE_HAL_OK) {
  			status = VXGE_HAL_COMPLETIONS_REMAIN;
  		}
  
  		(*got_rx)++;
  	}
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_poll_tx - Poll Tx for completed descriptors and process
   *			the same.
   * @vpath_handle: Virtual Path ahandle.
   * @got_tx: Buffer to return the flag set if transmit interrupt is occured
   *
   * The function	polls the Tx for the completed	descriptors and	calls
   * the upper-layer driver (ULD)	via supplied completion callback.
   *
   * Returns: VXGE_HAL_OK, if the polling is completed successful.
   * VXGE_HAL_COMPLETIONS_REMAIN: There are still more completed
   * descriptors available which are yet to be processed.
   *
   * See also: vxge_hal_vpath_poll_rx().
   */
  vxge_hal_status_e
  vxge_hal_vpath_poll_tx(vxge_hal_vpath_h vpath_handle, u32 *got_tx)
  {
  	vxge_hal_fifo_tcode_e t_code;
  	vxge_hal_txdl_h first_txdlh;
  	void *txdl_priv;
  	__hal_virtualpath_t *vpath;
  	__hal_fifo_t *fifo;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert((vpath_handle != NULL) && (got_tx != NULL));
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath_irq("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath_irq(
  	    "vpathh = 0x"VXGE_OS_STXFMT", got_tx = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, (ptr_t) got_tx);
  
  	fifo = (__hal_fifo_t *) vpath->fifoh;
  	if (fifo == NULL) {
  		vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	fifo->channel.poll_bytes = 0;
  	*got_tx = 0;
  
  	if ((status = vxge_hal_fifo_txdl_next_completed(vpath_handle,
  	    &first_txdlh, &txdl_priv, &t_code)) == VXGE_HAL_OK) {
  		if (fifo->callback(vpath_handle, first_txdlh, txdl_priv,
  		    t_code, fifo->channel.userdata) != VXGE_HAL_OK) {
  			status = VXGE_HAL_COMPLETIONS_REMAIN;
  		}
  
  		(*got_tx)++;
  	}
  
  	vxge_hal_trace_log_vpath_irq("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  
  /*
   * __hal_vpath_mgmt_read
   * @hldev: HAL device
   * @vpath: Virtual path structure
   *
   * This routine reads the vpath_mgmt registers
   */
  vxge_hal_status_e
  __hal_vpath_mgmt_read(
      __hal_device_t *hldev,
      __hal_virtualpath_t *vpath)
  {
  	u32 i, mtu;
  	u64 val64;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert((hldev != NULL) && (vpath != NULL));
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "hldev = 0x"VXGE_OS_STXFMT", vpath = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) hldev, (ptr_t) vpath);
  
  	vpath->sess_grps_available = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vpmgmt_reg->sgrp_own);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vpmgmt_reg->vpath_is_first);
  
  	vpath->is_first_vpath =
  	    (u32) VXGE_HAL_VPATH_IS_FIRST_GET_VPATH_IS_FIRST(val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vpmgmt_reg->tim_vpath_assignment);
  
  	vpath->bmap_root_assigned =
  	    (u32) VXGE_HAL_TIM_VPATH_ASSIGNMENT_GET_BMAP_ROOT(val64);
  
  	mtu = 0;
  
  	for (i = 0; i < VXGE_HAL_MAC_MAX_WIRE_PORTS; i++) {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vpmgmt_reg->rxmac_cfg0_port_vpmgmt_clone[i]);
  
  		if (mtu < (u32)
  		    VXGE_HAL_RXMAC_CFG0_PORT_VPMGMT_CLONE_GET_MAX_PYLD_LEN(
  		    val64)) {
  			mtu = (u32)
  			    VXGE_HAL_RXMAC_CFG0_PORT_VPMGMT_CLONE_GET_MAX_PYLD_LEN(
  			    val64);
  		}
  	}
  
  	vpath->max_mtu = mtu + VXGE_HAL_MAC_HEADER_MAX_SIZE;
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vpmgmt_reg->xmac_vsport_choices_vp);
  
  	vpath->vsport_choices =
  	    (u32) VXGE_HAL_XMAC_VSPORT_CHOICES_VP_GET_VSPORT_VECTOR(val64);
  
  	for (i = 0; i < VXGE_HAL_MAX_VIRTUAL_PATHS; i++) {
  
  		if (val64 & mBIT(i))
  			vpath->vsport_number = i;
  
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vpmgmt_reg->xgmac_gen_status_vpmgmt_clone);
  
  	if (val64 & VXGE_HAL_XGMAC_GEN_STATUS_VPMGMT_CLONE_XMACJ_NTWK_OK) {
  
  		VXGE_HAL_DEVICE_LINK_STATE_SET(vpath->hldev, VXGE_HAL_LINK_UP);
  
  	} else {
  
  		VXGE_HAL_DEVICE_LINK_STATE_SET(vpath->hldev,
  		    VXGE_HAL_LINK_DOWN);
  
  	}
  
  	if (val64 &
  	    VXGE_HAL_XGMAC_GEN_STATUS_VPMGMT_CLONE_XMACJ_NTWK_DATA_RATE) {
  
  		VXGE_HAL_DEVICE_DATA_RATE_SET(vpath->hldev,
  		    VXGE_HAL_DATA_RATE_10G);
  
  	} else {
  
  		VXGE_HAL_DEVICE_DATA_RATE_SET(vpath->hldev,
  		    VXGE_HAL_DATA_RATE_1G);
  
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * __hal_vpath_reset_check - Check if resetting the vpath completed
   *
   * @vpath: Virtual Path
   *
   * This routine checks the vpath_rst_in_prog register to see if adapter
   * completed the reset process for the vpath
   */
  vxge_hal_status_e
  __hal_vpath_reset_check(
      __hal_virtualpath_t *vpath)
  {
  	__hal_device_t *hldev;
  	vxge_hal_status_e status;
  
  	vxge_assert(vpath != NULL);
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath);
  
  	status = vxge_hal_device_register_poll(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &hldev->common_reg->vpath_rst_in_prog,
  	    0,
  	    VXGE_HAL_VPATH_RST_IN_PROG_VPATH_RST_IN_PROG(
  	    1 << (16 - vpath->vp_id)),
  	    WAIT_FACTOR * hldev->header.config.device_poll_millis);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d Result = %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * __hal_vpath_hw_reset
   * @hldev: Handle to the device object
   * @vp_id: Virtual Path Id
   *
   * This routine resets the vpath on the device
   */
  vxge_hal_status_e
  __hal_vpath_hw_reset(vxge_hal_device_h devh, u32 vp_id)
  {
  	u64 val64;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	__hal_device_t *hldev;
  
  	vxge_assert(devh != NULL);
  
  	hldev = (__hal_device_t *) devh;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("devh = 0x"VXGE_OS_STXFMT", vp_id = %d",
  	    (ptr_t) devh, vp_id);
  
  	val64 = VXGE_HAL_CMN_RSTHDLR_CFG0_SW_RESET_VPATH(1 << (16 - vp_id));
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 0),
  	    &hldev->common_reg->cmn_rsthdlr_cfg0);
  
  	(void) __hal_ifmsg_wmsg_post(hldev,
  	    vp_id,
  	    VXGE_HAL_RTS_ACCESS_STEER_MSG_DEST_BROADCAST,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_TYPE_VPATH_RESET_BEGIN,
  	    0);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * __hal_vpath_sw_reset
   * @hldev: Handle to the device object
   * @vp_id: Virtual Path Id
   *
   * This routine resets the vpath structures
   */
  vxge_hal_status_e
  __hal_vpath_sw_reset(
      vxge_hal_device_h devh,
      u32 vp_id)
  {
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(devh != NULL);
  
  	vpath = (__hal_virtualpath_t *) &hldev->virtual_paths[vp_id];
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("devh = 0x"VXGE_OS_STXFMT", vp_id = %d",
  	    (ptr_t) devh, vp_id);
  
  	if (vpath->ringh) {
  
  		status = __hal_ring_reset(vpath->ringh);
  
  		if (status != VXGE_HAL_OK) {
  			vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, status);
  			return (status);
  		}
  	}
  
  	if (vpath->fifoh) {
  
  		status = __hal_fifo_reset(vpath->fifoh);
  
  		if (status != VXGE_HAL_OK) {
  			vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, status);
  			return (status);
  		}
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_enable
   * @vpath_handle: Handle to the vpath object
   *
   * This routine clears the vpath reset and puts vpath in service
   */
  vxge_hal_status_e
  vxge_hal_vpath_enable(
      vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	val64 = VXGE_HAL_CMN_RSTHDLR_CFG1_CLR_VPATH_RESET(
  	    1 << (16 - vpath->vp_id));
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 0),
  	    &hldev->common_reg->cmn_rsthdlr_cfg1);
  
  	(void) __hal_ifmsg_wmsg_post(hldev,
  	    vpath->vp_id,
  	    VXGE_HAL_RTS_ACCESS_STEER_MSG_DEST_BROADCAST,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_TYPE_VPATH_RESET_END,
  	    0);
  
  	VXGE_HAL_RING_POST_DOORBELL(vpath_handle, vpath->ringh);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  
  /*
   * __hal_vpath_prc_configure
   * @hldev: Handle to the device object
   * @vp_id: Virtual Path Id
   *
   * This routine configures the prc registers of virtual path
   * using the config passed
   */
  vxge_hal_status_e
  __hal_vpath_prc_configure(
      vxge_hal_device_h devh,
      u32 vp_id)
  {
  	u64 val64;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  	__hal_virtualpath_t *vpath;
  	vxge_hal_vp_config_t *vp_config;
  
  	vxge_assert(devh != NULL);
  
  	vpath = (__hal_virtualpath_t *) &hldev->virtual_paths[vp_id];
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("devh = 0x"VXGE_OS_STXFMT", vp_id = %d",
  	    (ptr_t) devh, vp_id);
  
  	vp_config = vpath->vp_config;
  
  	if (vp_config->ring.enable == VXGE_HAL_RING_DISABLE) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->prc_cfg1);
  
  	if (vp_config->ring.rx_timer_val !=
  	    VXGE_HAL_RING_USE_FLASH_DEFAULT_RX_TIMER_VAL) {
  		val64 &= ~VXGE_HAL_PRC_CFG1_RX_TIMER_VAL(0x1fffffff);
  		val64 |= VXGE_HAL_PRC_CFG1_RX_TIMER_VAL(
  		    vp_config->ring.rx_timer_val);
  	}
  
  	val64 |= VXGE_HAL_PRC_CFG1_RTI_TINT_DISABLE;
  
  	if (vp_config->ring.greedy_return !=
  	    VXGE_HAL_RING_GREEDY_RETURN_USE_FLASH_DEFAULT) {
  		if (vp_config->ring.greedy_return)
  			val64 |= VXGE_HAL_PRC_CFG1_GREEDY_RETURN;
  		else
  			val64 &= ~VXGE_HAL_PRC_CFG1_GREEDY_RETURN;
  	}
  
  	if (vp_config->ring.rx_timer_ci !=
  	    VXGE_HAL_RING_RX_TIMER_CI_USE_FLASH_DEFAULT) {
  		if (vp_config->ring.rx_timer_ci)
  			val64 |= VXGE_HAL_PRC_CFG1_RX_TIMER_CI;
  		else
  			val64 &= ~VXGE_HAL_PRC_CFG1_RX_TIMER_CI;
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->prc_cfg1);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->prc_cfg7);
  
  	if (vpath->vp_config->ring.scatter_mode !=
  	    VXGE_HAL_RING_SCATTER_MODE_USE_FLASH_DEFAULT) {
  
  		val64 &= ~VXGE_HAL_PRC_CFG7_SCATTER_MODE(0x3);
  
  		switch (vpath->vp_config->ring.scatter_mode) {
  		case VXGE_HAL_RING_SCATTER_MODE_A:
  			val64 |= VXGE_HAL_PRC_CFG7_SCATTER_MODE(
  			    VXGE_HAL_PRC_CFG7_SCATTER_MODE_A);
  			break;
  		case VXGE_HAL_RING_SCATTER_MODE_B:
  			val64 |= VXGE_HAL_PRC_CFG7_SCATTER_MODE(
  			    VXGE_HAL_PRC_CFG7_SCATTER_MODE_B);
  			break;
  		case VXGE_HAL_RING_SCATTER_MODE_C:
  			val64 |= VXGE_HAL_PRC_CFG7_SCATTER_MODE(
  			    VXGE_HAL_PRC_CFG7_SCATTER_MODE_C);
  			break;
  		}
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->prc_cfg7);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->prc_cfg6);
  
  	if (vpath->vp_config->ring.post_mode !=
  	    VXGE_HAL_RING_POST_MODE_USE_FLASH_DEFAULT) {
  
  		if (vpath->vp_config->ring.post_mode ==
  		    VXGE_HAL_RING_POST_MODE_DOORBELL)
  			val64 |= VXGE_HAL_PRC_CFG6_DOORBELL_MODE_EN;
  		else
  			val64 &= ~VXGE_HAL_PRC_CFG6_DOORBELL_MODE_EN;
  
  	} else {
  
  		vpath->vp_config->ring.post_mode =
  		    ((val64 & VXGE_HAL_PRC_CFG6_DOORBELL_MODE_EN) ?
  		    VXGE_HAL_RING_POST_MODE_DOORBELL :
  		    VXGE_HAL_RING_POST_MODE_LEGACY);
  
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->prc_cfg6);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    VXGE_HAL_PRC_CFG5_RXD0_ADD(
  	    __hal_ring_first_block_address_get(vpath->ringh) >> 3),
  	    &vpath->vp_reg->prc_cfg5);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->prc_cfg4);
  
  	val64 |= VXGE_HAL_PRC_CFG4_IN_SVC;
  
  	val64 &= ~VXGE_HAL_PRC_CFG4_RING_MODE(0x3);
  
  	if (vp_config->ring.buffer_mode == VXGE_HAL_RING_RXD_BUFFER_MODE_1) {
  		val64 |= VXGE_HAL_PRC_CFG4_RING_MODE(
  		    VXGE_HAL_PRC_CFG4_RING_MODE_ONE_BUFFER);
  	} else {
  		if (vp_config->ring.buffer_mode ==
  		    VXGE_HAL_RING_RXD_BUFFER_MODE_3) {
  			val64 |= VXGE_HAL_PRC_CFG4_RING_MODE(
  			    VXGE_HAL_PRC_CFG4_RING_MODE_THREE_BUFFER);
  		} else {
  			val64 |= VXGE_HAL_PRC_CFG4_RING_MODE(
  			    VXGE_HAL_PRC_CFG4_RING_MODE_FIVE_BUFFER);
  		}
  	}
  
  	if (vp_config->ring.no_snoop_bits !=
  	    VXGE_HAL_RING_NO_SNOOP_USE_FLASH_DEFAULT) {
  
  		val64 &= ~(VXGE_HAL_PRC_CFG4_FRM_NO_SNOOP |
  		    VXGE_HAL_PRC_CFG4_RXD_NO_SNOOP);
  
  		if (vp_config->ring.no_snoop_bits ==
  		    VXGE_HAL_RING_NO_SNOOP_RXD) {
  			val64 |= VXGE_HAL_PRC_CFG4_RXD_NO_SNOOP;
  		} else {
  			if (vp_config->ring.no_snoop_bits ==
  			    VXGE_HAL_RING_NO_SNOOP_FRM) {
  				val64 |= VXGE_HAL_PRC_CFG4_FRM_NO_SNOOP;
  			} else {
  				if (vp_config->ring.no_snoop_bits ==
  				    VXGE_HAL_RING_NO_SNOOP_ALL) {
  					val64 |= VXGE_HAL_PRC_CFG4_FRM_NO_SNOOP;
  					val64 |= VXGE_HAL_PRC_CFG4_RXD_NO_SNOOP;
  				}
  			}
  		}
  
  	}
  
  	if (hldev->header.config.rth_en == VXGE_HAL_RTH_DISABLE)
  		val64 |= VXGE_HAL_PRC_CFG4_RTH_DISABLE;
  	else
  		val64 &= ~VXGE_HAL_PRC_CFG4_RTH_DISABLE;
  
  	val64 |= VXGE_HAL_PRC_CFG4_SIGNAL_BENIGN_OVFLW;
  
  	val64 |= VXGE_HAL_PRC_CFG4_BIMODAL_INTERRUPT;
  
  	if (vp_config->ring.backoff_interval_us !=
  	    VXGE_HAL_USE_FLASH_DEFAULT_BACKOFF_INTERVAL_US) {
  
  		val64 &= ~VXGE_HAL_PRC_CFG4_BACKOFF_INTERVAL(0xffffff);
  
  		val64 |= VXGE_HAL_PRC_CFG4_BACKOFF_INTERVAL(
  		    vp_config->ring.backoff_interval_us * 1000 / 4);
  
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->prc_cfg4);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  /*
   * __hal_vpath_kdfc_configure
   * @hldev: Handle to the device object
   * @vp_id: Virtual Path Id
   *
   * This routine configures the kdfc registers of virtual path
   * using the config passed
   */
  vxge_hal_status_e
  __hal_vpath_kdfc_configure(
      vxge_hal_device_h devh,
      u32 vp_id)
  {
  	u64 val64;
  	u64 vpath_stride;
  	u64 fifo_stride;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(devh != NULL);
  
  	vpath = (__hal_virtualpath_t *) &hldev->virtual_paths[vp_id];
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("devh = 0x"VXGE_OS_STXFMT", vp_id = %d",
  	    (ptr_t) devh, vp_id);
  
  	status = __hal_kdfc_swapper_set((vxge_hal_device_t *) hldev, vp_id);
  
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  
  	}
  
  	if ((vpath->vp_config->ring.post_mode ==
  	    VXGE_HAL_RING_POST_MODE_DOORBELL) &&
  	    (vxge_hal_device_check_id(devh) == VXGE_HAL_CARD_TITAN_1)) {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->rxdmem_size);
  
  		vpath->rxd_mem_size =
  		    (u32) VXGE_HAL_RXDMEM_SIZE_PRC_RXDMEM_SIZE(val64) * 8;
  
  	} else {
  
  		vpath->rxd_mem_size = (VXGE_HAL_MAX_RING_LENGTH /
  		    vxge_hal_ring_rxds_per_block_get(
  		    vpath->vp_config->ring.buffer_mode)) *
  		    VXGE_OS_HOST_PAGE_SIZE;
  
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->kdfc_drbl_triplet_total);
  
  	vpath->max_kdfc_db =
  	    (u32) VXGE_HAL_KDFC_DRBL_TRIPLET_TOTAL_GET_KDFC_MAX_SIZE(val64 + 1) / 2;
  
  	vpath->max_ofl_db = 0;
  
  	if (vpath->vp_config->fifo.enable == VXGE_HAL_FIFO_ENABLE) {
  
  		vpath->max_nofl_db = vpath->max_kdfc_db - 1;
  		vpath->max_msg_db = 0;
  
  		if (vpath->max_nofl_db < vpath->vp_config->fifo.fifo_length) {
  
  			vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__,
  			    VXGE_HAL_BADCFG_FIFO_LENGTH);
  			return (VXGE_HAL_BADCFG_FIFO_LENGTH);
  		}
  
  	} else {
  
  		vpath->max_nofl_db = 0;
  		vpath->max_msg_db = vpath->max_kdfc_db;
  	}
  
  	val64 = 0;
  
  	if (vpath->max_nofl_db)
  		val64 |= VXGE_HAL_KDFC_FIFO_TRPL_PARTITION_LENGTH_0(
  		    (vpath->max_nofl_db * 2) - 1);
  
  	if (vpath->max_msg_db)
  		val64 |= VXGE_HAL_KDFC_FIFO_TRPL_PARTITION_LENGTH_1(
  		    (vpath->max_msg_db * 2) - 1);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->kdfc_fifo_trpl_partition);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    VXGE_HAL_KDFC_FIFO_TRPL_CTRL_TRIPLET_ENABLE,
  	    &vpath->vp_reg->kdfc_fifo_trpl_ctrl);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->kdfc_trpl_fifo_0_ctrl);
  
  	if (vpath->max_nofl_db) {
  
  		val64 &= ~(VXGE_HAL_KDFC_TRPL_FIFO_0_CTRL_MODE(0x3) |
  		    VXGE_HAL_KDFC_TRPL_FIFO_0_CTRL_SELECT(0xFF));
  
  		val64 |= VXGE_HAL_KDFC_TRPL_FIFO_0_CTRL_MODE(
  		    VXGE_HAL_KDFC_TRPL_FIFO_0_CTRL_MODE_NON_OFFLOAD_ONLY) |
  #if !defined(VXGE_OS_HOST_BIG_ENDIAN)
  		    VXGE_HAL_KDFC_TRPL_FIFO_0_CTRL_SWAP_EN |
  #endif
  		    VXGE_HAL_KDFC_TRPL_FIFO_0_CTRL_SELECT(0);
  
  		if (vpath->vp_config->no_snoop !=
  		    VXGE_HAL_VPATH_NO_SNOOP_USE_FLASH_DEFAULT) {
  			if (vpath->vp_config->no_snoop)
  				val64 |=
  				    VXGE_HAL_KDFC_TRPL_FIFO_0_CTRL_NO_SNOOP;
  			else
  				val64 &=
  				    ~VXGE_HAL_KDFC_TRPL_FIFO_0_CTRL_NO_SNOOP;
  		}
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->kdfc_trpl_fifo_0_ctrl);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->kdfc_trpl_fifo_1_ctrl);
  
  	if (vpath->max_msg_db) {
  
  		val64 &= ~(VXGE_HAL_KDFC_TRPL_FIFO_1_CTRL_MODE(0x3) |
  		    VXGE_HAL_KDFC_TRPL_FIFO_1_CTRL_SELECT(0xFF));
  
  		val64 |= VXGE_HAL_KDFC_TRPL_FIFO_1_CTRL_MODE(
  		    VXGE_HAL_KDFC_TRPL_FIFO_1_CTRL_MODE_MESSAGES_ONLY) |
  #if !defined(VXGE_OS_HOST_BIG_ENDIAN)
  		    VXGE_HAL_KDFC_TRPL_FIFO_1_CTRL_SWAP_EN |
  #endif
  		    VXGE_HAL_KDFC_TRPL_FIFO_1_CTRL_SELECT(0);
  
  		if (vpath->vp_config->no_snoop !=
  		    VXGE_HAL_VPATH_NO_SNOOP_USE_FLASH_DEFAULT) {
  			if (vpath->vp_config->no_snoop)
  				val64 |=
  				    VXGE_HAL_KDFC_TRPL_FIFO_1_CTRL_NO_SNOOP;
  			else
  				val64 &=
  				    ~VXGE_HAL_KDFC_TRPL_FIFO_1_CTRL_NO_SNOOP;
  		}
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->kdfc_trpl_fifo_1_ctrl);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u64) 0,
  	    &vpath->vp_reg->kdfc_trpl_fifo_2_ctrl);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u64) 0,
  	    &vpath->vp_reg->kdfc_trpl_fifo_0_wb_address);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u64) 0,
  	    &vpath->vp_reg->kdfc_trpl_fifo_1_wb_address);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u64) 0,
  	    &vpath->vp_reg->kdfc_trpl_fifo_2_wb_address);
  
  
  	vxge_os_wmb();
  
  	vpath_stride = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &hldev->toc_reg->toc_kdfc_vpath_stride);
  
  	fifo_stride = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &hldev->toc_reg->toc_kdfc_fifo_stride);
  
  	vpath->nofl_db = (__hal_non_offload_db_wrapper_t *) ((void *)(hldev->kdfc +
  	    (vp_id * VXGE_HAL_TOC_KDFC_VPATH_STRIDE_GET_TOC_KDFC_VPATH_STRIDE(
  	    vpath_stride))));
  
  	vpath->msg_db = (__hal_messaging_db_wrapper_t *) ((void *)(hldev->kdfc +
  	    (vp_id * VXGE_HAL_TOC_KDFC_VPATH_STRIDE_GET_TOC_KDFC_VPATH_STRIDE(
  	    vpath_stride)) +
  	    VXGE_HAL_TOC_KDFC_FIFO_STRIDE_GET_TOC_KDFC_FIFO_STRIDE(
  	    fifo_stride)));
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  /*
   * __hal_vpath_mac_configure
   * @hldev: Handle to the device object
   * @vp_id: Virtual Path Id
   *
   * This routine configures the mac of virtual path using the config passed
   */
  vxge_hal_status_e
  __hal_vpath_mac_configure(
      vxge_hal_device_h devh,
      u32 vp_id)
  {
  	u64 val64;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  	__hal_virtualpath_t *vpath;
  	vxge_hal_vp_config_t *vp_config;
  
  	vxge_assert(devh != NULL);
  
  	vpath = (__hal_virtualpath_t *) &hldev->virtual_paths[vp_id];
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("devh = 0x"VXGE_OS_STXFMT", vp_id = %d",
  	    (ptr_t) devh, vp_id);
  
  	vp_config = vpath->vp_config;
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    VXGE_HAL_XMAC_VSPORT_CHOICE_VSPORT_NUMBER(vpath->vsport_number),
  	    &vpath->vp_reg->xmac_vsport_choice);
  
  	if (vp_config->ring.enable == VXGE_HAL_RING_ENABLE) {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->xmac_rpa_vcfg);
  
  		if (vp_config->rpa_ipv4_tcp_incl_ph !=
  		    VXGE_HAL_VPATH_RPA_IPV4_TCP_INCL_PH_USE_FLASH_DEFAULT) {
  			if (vp_config->rpa_ipv4_tcp_incl_ph)
  				val64 |=
  				    VXGE_HAL_XMAC_RPA_VCFG_IPV4_TCP_INCL_PH;
  			else
  				val64 &=
  				    ~VXGE_HAL_XMAC_RPA_VCFG_IPV4_TCP_INCL_PH;
  		}
  
  		if (vp_config->rpa_ipv6_tcp_incl_ph !=
  		    VXGE_HAL_VPATH_RPA_IPV6_TCP_INCL_PH_USE_FLASH_DEFAULT) {
  			if (vp_config->rpa_ipv6_tcp_incl_ph)
  				val64 |=
  				    VXGE_HAL_XMAC_RPA_VCFG_IPV6_TCP_INCL_PH;
  			else
  				val64 &=
  				    ~VXGE_HAL_XMAC_RPA_VCFG_IPV6_TCP_INCL_PH;
  		}
  
  		if (vp_config->rpa_ipv4_udp_incl_ph !=
  		    VXGE_HAL_VPATH_RPA_IPV4_UDP_INCL_PH_USE_FLASH_DEFAULT) {
  			if (vp_config->rpa_ipv4_udp_incl_ph)
  				val64 |=
  				    VXGE_HAL_XMAC_RPA_VCFG_IPV4_UDP_INCL_PH;
  			else
  				val64 &=
  				    ~VXGE_HAL_XMAC_RPA_VCFG_IPV4_UDP_INCL_PH;
  		}
  
  		if (vp_config->rpa_ipv6_udp_incl_ph !=
  		    VXGE_HAL_VPATH_RPA_IPV6_UDP_INCL_PH_USE_FLASH_DEFAULT) {
  			if (vp_config->rpa_ipv6_udp_incl_ph)
  				val64 |=
  				    VXGE_HAL_XMAC_RPA_VCFG_IPV6_UDP_INCL_PH;
  			else
  				val64 &=
  				    ~VXGE_HAL_XMAC_RPA_VCFG_IPV6_UDP_INCL_PH;
  		}
  
  		if (vp_config->rpa_l4_incl_cf !=
  		    VXGE_HAL_VPATH_RPA_L4_INCL_CF_USE_FLASH_DEFAULT) {
  			if (vp_config->rpa_l4_incl_cf)
  				val64 |= VXGE_HAL_XMAC_RPA_VCFG_L4_INCL_CF;
  			else
  				val64 &= ~VXGE_HAL_XMAC_RPA_VCFG_L4_INCL_CF;
  		}
  
  		if (vp_config->rpa_strip_vlan_tag !=
  		    VXGE_HAL_VPATH_RPA_STRIP_VLAN_TAG_USE_FLASH_DEFAULT) {
  			if (vp_config->rpa_strip_vlan_tag)
  				val64 |= VXGE_HAL_XMAC_RPA_VCFG_STRIP_VLAN_TAG;
  			else
  				val64 &= ~VXGE_HAL_XMAC_RPA_VCFG_STRIP_VLAN_TAG;
  		}
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &vpath->vp_reg->xmac_rpa_vcfg);
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->rxmac_vcfg0);
  
  		if (vp_config->mtu !=
  		    VXGE_HAL_VPATH_USE_FLASH_DEFAULT_INITIAL_MTU) {
  			val64 &= ~VXGE_HAL_RXMAC_VCFG0_RTS_MAX_FRM_LEN(0x3fff);
  			if ((vp_config->mtu + VXGE_HAL_MAC_HEADER_MAX_SIZE) <
  			    vpath->max_mtu)
  				val64 |= VXGE_HAL_RXMAC_VCFG0_RTS_MAX_FRM_LEN(
  				    vp_config->mtu +
  				    VXGE_HAL_MAC_HEADER_MAX_SIZE);
  			else
  				val64 |= VXGE_HAL_RXMAC_VCFG0_RTS_MAX_FRM_LEN(
  				    vpath->max_mtu);
  		}
  
  		if (vp_config->rpa_ucast_all_addr_en !=
  		    VXGE_HAL_VPATH_RPA_UCAST_ALL_ADDR_USE_FLASH_DEFAULT) {
  			if (vp_config->rpa_ucast_all_addr_en)
  				val64 |= VXGE_HAL_RXMAC_VCFG0_UCAST_ALL_ADDR_EN;
  			else
  				val64 &=
  				    ~VXGE_HAL_RXMAC_VCFG0_UCAST_ALL_ADDR_EN;
  		} else {
  			if (val64 & VXGE_HAL_RXMAC_VCFG0_UCAST_ALL_ADDR_EN) {
  				vp_config->rpa_ucast_all_addr_en =
  				    VXGE_HAL_VPATH_RPA_UCAST_ALL_ADDR_ENABLE;
  			} else {
  				vp_config->rpa_ucast_all_addr_en =
  				    VXGE_HAL_VPATH_RPA_UCAST_ALL_ADDR_DISABLE;
  			}
  		}
  
  		if (vp_config->rpa_mcast_all_addr_en !=
  		    VXGE_HAL_VPATH_RPA_MCAST_ALL_ADDR_USE_FLASH_DEFAULT) {
  			if (vp_config->rpa_mcast_all_addr_en)
  				val64 |= VXGE_HAL_RXMAC_VCFG0_MCAST_ALL_ADDR_EN;
  			else
  				val64 &=
  				    ~VXGE_HAL_RXMAC_VCFG0_MCAST_ALL_ADDR_EN;
  		} else {
  			if (val64 & VXGE_HAL_RXMAC_VCFG0_MCAST_ALL_ADDR_EN) {
  				vp_config->rpa_mcast_all_addr_en =
  				    VXGE_HAL_VPATH_RPA_MCAST_ALL_ADDR_ENABLE;
  			} else {
  				vp_config->rpa_mcast_all_addr_en =
  				    VXGE_HAL_VPATH_RPA_MCAST_ALL_ADDR_DISABLE;
  			}
  		}
  
  		if (vp_config->rpa_bcast_en !=
  		    VXGE_HAL_VPATH_RPA_BCAST_USE_FLASH_DEFAULT) {
  			if (vp_config->rpa_bcast_en)
  				val64 |= VXGE_HAL_RXMAC_VCFG0_BCAST_EN;
  			else
  				val64 &= ~VXGE_HAL_RXMAC_VCFG0_BCAST_EN;
  		} else {
  			if (val64 & VXGE_HAL_RXMAC_VCFG0_BCAST_EN) {
  				vp_config->rpa_bcast_en =
  				    VXGE_HAL_VPATH_RPA_BCAST_ENABLE;
  			} else {
  				vp_config->rpa_bcast_en =
  				    VXGE_HAL_VPATH_RPA_BCAST_DISABLE;
  			}
  		}
  
  		if (vp_config->rpa_all_vid_en !=
  		    VXGE_HAL_VPATH_RPA_ALL_VID_USE_FLASH_DEFAULT) {
  			if (vp_config->rpa_all_vid_en)
  				val64 |= VXGE_HAL_RXMAC_VCFG0_ALL_VID_EN;
  			else
  				val64 &= ~VXGE_HAL_RXMAC_VCFG0_ALL_VID_EN;
  		} else {
  			if (val64 & VXGE_HAL_RXMAC_VCFG0_ALL_VID_EN) {
  				vp_config->rpa_all_vid_en =
  				    VXGE_HAL_VPATH_RPA_ALL_VID_ENABLE;
  			} else {
  				vp_config->rpa_all_vid_en =
  				    VXGE_HAL_VPATH_RPA_ALL_VID_DISABLE;
  			}
  		}
  
  		if (vpath->promisc_en == VXGE_HAL_VP_PROMISC_ENABLE) {
  			val64 |= VXGE_HAL_RXMAC_VCFG0_UCAST_ALL_ADDR_EN |
  			    VXGE_HAL_RXMAC_VCFG0_MCAST_ALL_ADDR_EN |
  			    VXGE_HAL_RXMAC_VCFG0_BCAST_EN |
  			    VXGE_HAL_RXMAC_VCFG0_ALL_VID_EN;
  		}
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &vpath->vp_reg->rxmac_vcfg0);
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->rxmac_vcfg1);
  
  		val64 &= ~(VXGE_HAL_RXMAC_VCFG1_RTS_RTH_MULTI_IT_BD_MODE(0x3) |
  		    VXGE_HAL_RXMAC_VCFG1_RTS_RTH_MULTI_IT_EN_MODE);
  
  		if (hldev->header.config.rth_it_type ==
  		    VXGE_HAL_RTH_IT_TYPE_MULTI_IT) {
  			val64 |=
  			    VXGE_HAL_RXMAC_VCFG1_RTS_RTH_MULTI_IT_BD_MODE(0x2) |
  			    VXGE_HAL_RXMAC_VCFG1_RTS_RTH_MULTI_IT_EN_MODE;
  		}
  
  		if (vp_config->vp_queue_l2_flow !=
  		    VXGE_HAL_VPATH_VP_Q_L2_FLOW_USE_FLASH_DEFAULT) {
  			if (vp_config->vp_queue_l2_flow)
  				val64 |= VXGE_HAL_RXMAC_VCFG1_CONTRIB_L2_FLOW;
  			else
  				val64 &= ~VXGE_HAL_RXMAC_VCFG1_CONTRIB_L2_FLOW;
  		}
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &vpath->vp_reg->rxmac_vcfg1);
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->fau_rpa_vcfg);
  
  		if (vp_config->rpa_l4_comp_csum !=
  		    VXGE_HAL_VPATH_RPA_L4_COMP_CSUM_USE_FLASH_DEFAULT) {
  			if (vp_config->rpa_l4_comp_csum)
  				val64 |= VXGE_HAL_FAU_RPA_VCFG_L4_COMP_CSUM;
  			else
  				val64 &= ~VXGE_HAL_FAU_RPA_VCFG_L4_COMP_CSUM;
  		}
  
  		if (vp_config->rpa_l3_incl_cf !=
  		    VXGE_HAL_VPATH_RPA_L3_INCL_CF_USE_FLASH_DEFAULT) {
  			if (vp_config->rpa_l3_incl_cf)
  				val64 |= VXGE_HAL_FAU_RPA_VCFG_L3_INCL_CF;
  			else
  				val64 &= ~VXGE_HAL_FAU_RPA_VCFG_L3_INCL_CF;
  		}
  
  		if (vp_config->rpa_l3_comp_csum !=
  		    VXGE_HAL_VPATH_RPA_L3_COMP_CSUM_USE_FLASH_DEFAULT) {
  			if (vp_config->rpa_l3_comp_csum)
  				val64 |= VXGE_HAL_FAU_RPA_VCFG_L3_COMP_CSUM;
  			else
  				val64 &= ~VXGE_HAL_FAU_RPA_VCFG_L3_COMP_CSUM;
  		}
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &vpath->vp_reg->fau_rpa_vcfg);
  	}
  
  	if (vp_config->fifo.enable == VXGE_HAL_FIFO_ENABLE) {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->tpa_cfg);
  
  		if (vp_config->tpa_ignore_frame_error !=
  		    VXGE_HAL_VPATH_TPA_IGNORE_FRAME_ERROR_USE_FLASH_DEFAULT) {
  			if (vp_config->tpa_ignore_frame_error)
  				val64 |= VXGE_HAL_TPA_CFG_IGNORE_FRAME_ERR;
  			else
  				val64 &= ~VXGE_HAL_TPA_CFG_IGNORE_FRAME_ERR;
  		}
  
  		if (vp_config->tpa_ipv6_keep_searching !=
  		    VXGE_HAL_VPATH_TPA_IPV6_KEEP_SEARCHING_USE_FLASH_DEFAULT) {
  			if (vp_config->tpa_ipv6_keep_searching)
  				val64 |= VXGE_HAL_TPA_CFG_IPV6_STOP_SEARCHING;
  			else
  				val64 &= ~VXGE_HAL_TPA_CFG_IPV6_STOP_SEARCHING;
  		}
  
  		if (vp_config->tpa_l4_pshdr_present !=
  		    VXGE_HAL_VPATH_TPA_L4_PSHDR_PRESENT_USE_FLASH_DEFAULT) {
  			if (vp_config->tpa_l4_pshdr_present)
  				val64 |= VXGE_HAL_TPA_CFG_L4_PSHDR_PRESENT;
  			else
  				val64 &= ~VXGE_HAL_TPA_CFG_L4_PSHDR_PRESENT;
  		}
  
  		if (vp_config->tpa_support_mobile_ipv6_hdrs !=
  		    VXGE_HAL_VPATH_TPA_SUPPORT_MOBILE_IPV6_HDRS_DEFAULT) {
  			if (vp_config->tpa_support_mobile_ipv6_hdrs)
  				val64 |=
  				    VXGE_HAL_TPA_CFG_SUPPORT_MOBILE_IPV6_HDRS;
  			else
  				val64 &=
  				    ~VXGE_HAL_TPA_CFG_SUPPORT_MOBILE_IPV6_HDRS;
  		}
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &vpath->vp_reg->tpa_cfg);
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->tx_protocol_assist_cfg);
  
  		if (vp_config->tpa_lsov2_en !=
  		    VXGE_HAL_VPATH_TPA_LSOV2_EN_USE_FLASH_DEFAULT) {
  			if (vp_config->tpa_lsov2_en)
  				val64 |=
  				    VXGE_HAL_TX_PROTOCOL_ASSIST_CFG_LSOV2_EN;
  			else
  				val64 &=
  				    ~VXGE_HAL_TX_PROTOCOL_ASSIST_CFG_LSOV2_EN;
  		}
  
  		if (vp_config->tpa_ipv6_keep_searching !=
  		    VXGE_HAL_VPATH_TPA_IPV6_KEEP_SEARCHING_USE_FLASH_DEFAULT) {
  			if (vp_config->tpa_ipv6_keep_searching)
  				val64 |= VXGE_HAL_TX_PROTOCOL_ASSIST_CFG_IPV6_KEEP_SEARCHING;
  			else
  				val64 &= ~VXGE_HAL_TX_PROTOCOL_ASSIST_CFG_IPV6_KEEP_SEARCHING;
  		}
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &vpath->vp_reg->tx_protocol_assist_cfg);
  
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  /*
   * __hal_vpath_tim_configure
   * @hldev: Handle to the device object
   * @vp_id: Virtual Path Id
   *
   * This routine configures the tim registers of virtual path
   * using the config passed
   */
  vxge_hal_status_e
  __hal_vpath_tim_configure(
      vxge_hal_device_h devh,
      u32 vp_id)
  {
  	u64 val64;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(devh != NULL);
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("devh = 0x"VXGE_OS_STXFMT", vp_id = %d",
  	    (ptr_t) devh, vp_id);
  
  	vpath = (__hal_virtualpath_t *) &hldev->virtual_paths[vp_id];
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u64) 0,
  	    &vpath->vp_reg->tim_dest_addr);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u64) 0,
  	    &vpath->vp_reg->tim_vpath_map);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u64) 0,
  	    &vpath->vp_reg->tim_bitmap);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u64) 0,
  	    &vpath->vp_reg->tim_remap);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rtdma_rd_optimization_ctrl);
  
  	val64 |= VXGE_HAL_RTDMA_RD_OPTIMIZATION_CTRL_FB_ADDR_BDRY_EN;
  
  	if (hldev->header.config.intr_mode == VXGE_HAL_INTR_MODE_EMULATED_INTA)
  		val64 = 0x1000150012000100ULL;	/* override for HPISS */
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->rtdma_rd_optimization_ctrl);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->tim_wrkld_clc);
  
  	val64 |= VXGE_HAL_TIM_WRKLD_CLC_WRKLD_EVAL_PRD(0x5BE9) |
  	    VXGE_HAL_TIM_WRKLD_CLC_CNT_FRM_BYTE |
  	    VXGE_HAL_TIM_WRKLD_CLC_WRKLD_EVAL_DIV(0x15) |
  	    VXGE_HAL_TIM_WRKLD_CLC_CNT_RX_TX(3);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->tim_wrkld_clc);
  
  	if (vpath->vp_config->ring.enable == VXGE_HAL_RING_ENABLE) {
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    VXGE_HAL_TIM_RING_ASSN_INT_NUM(vpath->rx_intr_num),
  		    &vpath->vp_reg->tim_ring_assn);
  
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->tim_pci_cfg);
  
  	val64 |= VXGE_HAL_TIM_PCI_CFG_ADD_PAD;
  
  	if (vpath->vp_config->no_snoop !=
  	    VXGE_HAL_VPATH_NO_SNOOP_USE_FLASH_DEFAULT) {
  		if (vpath->vp_config->no_snoop)
  			val64 |= VXGE_HAL_TIM_PCI_CFG_NO_SNOOP;
  		else
  			val64 &= ~VXGE_HAL_TIM_PCI_CFG_NO_SNOOP;
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->tim_pci_cfg);
  
  	if (vpath->vp_config->fifo.enable == VXGE_HAL_FIFO_ENABLE) {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->tim_cfg1_int_num[VXGE_HAL_VPATH_INTR_TX]);
  
  		if (vpath->vp_config->tti.btimer_val !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_BTIMER_VAL) {
  			val64 &=
  			    ~VXGE_HAL_TIM_CFG1_INT_NUM_BTIMER_VAL(0x3ffffff);
  			val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_BTIMER_VAL(
  			    vpath->vp_config->tti.btimer_val);
  		}
  
  		val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_BITMP_EN;
  
  		if (vpath->vp_config->tti.txfrm_cnt_en !=
  		    VXGE_HAL_TXFRM_CNT_EN_USE_FLASH_DEFAULT) {
  			if (vpath->vp_config->tti.txfrm_cnt_en)
  				val64 |=
  				    VXGE_HAL_TIM_CFG1_INT_NUM_TXFRM_CNT_EN;
  			else
  				val64 &=
  				    ~VXGE_HAL_TIM_CFG1_INT_NUM_TXFRM_CNT_EN;
  		}
  
  		if (vpath->vp_config->tti.txd_cnt_en !=
  		    VXGE_HAL_TXD_CNT_EN_USE_FLASH_DEFAULT) {
  			if (vpath->vp_config->tti.txd_cnt_en)
  				val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_TXD_CNT_EN;
  			else
  				val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_TXD_CNT_EN;
  		}
  
  		if (vpath->vp_config->tti.timer_ac_en !=
  		    VXGE_HAL_TIM_TIMER_AC_USE_FLASH_DEFAULT) {
  			if (vpath->vp_config->tti.timer_ac_en)
  				val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_TIMER_AC;
  			else
  				val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_TIMER_AC;
  		}
  
  		if (vpath->vp_config->tti.timer_ci_en !=
  		    VXGE_HAL_TIM_TIMER_CI_USE_FLASH_DEFAULT) {
  			if (vpath->vp_config->tti.timer_ci_en)
  				val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_TIMER_CI;
  			else
  				val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_TIMER_CI;
  		}
  
  		if (vpath->vp_config->tti.urange_a !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_URANGE_A) {
  			val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_URNG_A(0x3f);
  			val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_URNG_A(
  			    vpath->vp_config->tti.urange_a);
  		}
  
  		if (vpath->vp_config->tti.urange_b !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_URANGE_B) {
  			val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_URNG_B(0x3f);
  			val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_URNG_B(
  			    vpath->vp_config->tti.urange_b);
  		}
  
  		if (vpath->vp_config->tti.urange_c !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_URANGE_C) {
  			val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_URNG_C(0x3f);
  			val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_URNG_C(
  			    vpath->vp_config->tti.urange_c);
  		}
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &vpath->vp_reg->tim_cfg1_int_num[VXGE_HAL_VPATH_INTR_TX]);
  
  		vpath->tim_tti_cfg1_saved = val64;
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->tim_cfg2_int_num[VXGE_HAL_VPATH_INTR_TX]);
  
  		if (vpath->vp_config->tti.uec_a !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_UEC_A) {
  			val64 &= ~VXGE_HAL_TIM_CFG2_INT_NUM_UEC_A(0xffff);
  			val64 |= VXGE_HAL_TIM_CFG2_INT_NUM_UEC_A(
  			    vpath->vp_config->tti.uec_a);
  		}
  
  		if (vpath->vp_config->tti.uec_b !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_UEC_B) {
  			val64 &= ~VXGE_HAL_TIM_CFG2_INT_NUM_UEC_B(0xffff);
  			val64 |= VXGE_HAL_TIM_CFG2_INT_NUM_UEC_B(
  			    vpath->vp_config->tti.uec_b);
  		}
  
  		if (vpath->vp_config->tti.uec_c !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_UEC_C) {
  			val64 &= ~VXGE_HAL_TIM_CFG2_INT_NUM_UEC_C(0xffff);
  			val64 |= VXGE_HAL_TIM_CFG2_INT_NUM_UEC_C(
  			    vpath->vp_config->tti.uec_c);
  		}
  
  		if (vpath->vp_config->tti.uec_d !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_UEC_D) {
  			val64 &= ~VXGE_HAL_TIM_CFG2_INT_NUM_UEC_D(0xffff);
  			val64 |= VXGE_HAL_TIM_CFG2_INT_NUM_UEC_D(
  			    vpath->vp_config->tti.uec_d);
  		}
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &vpath->vp_reg->tim_cfg2_int_num[VXGE_HAL_VPATH_INTR_TX]);
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->tim_cfg3_int_num[VXGE_HAL_VPATH_INTR_TX]);
  
  		if (vpath->vp_config->tti.timer_ri_en !=
  		    VXGE_HAL_TIM_TIMER_RI_USE_FLASH_DEFAULT) {
  			if (vpath->vp_config->tti.timer_ri_en)
  				val64 |= VXGE_HAL_TIM_CFG3_INT_NUM_TIMER_RI;
  			else
  				val64 &= ~VXGE_HAL_TIM_CFG3_INT_NUM_TIMER_RI;
  		}
  
  		if (vpath->vp_config->tti.rtimer_event_sf !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_RTIMER_EVENT_SF) {
  			val64 &=
  			    ~VXGE_HAL_TIM_CFG3_INT_NUM_RTIMER_EVENT_SF(0xf);
  			val64 |= VXGE_HAL_TIM_CFG3_INT_NUM_RTIMER_EVENT_SF(
  			    vpath->vp_config->tti.rtimer_event_sf);
  		}
  
  		if (vpath->vp_config->tti.rtimer_val !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_RTIMER_VAL) {
  			val64 &= ~VXGE_HAL_TIM_CFG3_INT_NUM_RTIMER_VAL(
  			    0x3ffffff);
  			val64 |= VXGE_HAL_TIM_CFG3_INT_NUM_RTIMER_VAL(
  			    vpath->vp_config->tti.rtimer_val);
  		}
  
  		if (vpath->vp_config->tti.util_sel !=
  		    VXGE_HAL_TIM_UTIL_SEL_USE_FLASH_DEFAULT) {
  			val64 &= ~VXGE_HAL_TIM_CFG3_INT_NUM_UTIL_SEL(0x3f);
  			val64 |= VXGE_HAL_TIM_CFG3_INT_NUM_UTIL_SEL(
  			    vpath->vp_config->tti.util_sel);
  		}
  
  		if (vpath->vp_config->tti.ltimer_val !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_LTIMER_VAL) {
  			val64 &=
  			    ~VXGE_HAL_TIM_CFG3_INT_NUM_LTIMER_VAL(0x3ffffff);
  			val64 |= VXGE_HAL_TIM_CFG3_INT_NUM_LTIMER_VAL(
  			    vpath->vp_config->tti.ltimer_val);
  		}
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &vpath->vp_reg->tim_cfg3_int_num[VXGE_HAL_VPATH_INTR_TX]);
  
  		vpath->tim_tti_cfg3_saved = val64;
  	}
  
  	if (vpath->vp_config->ring.enable == VXGE_HAL_RING_ENABLE) {
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->tim_cfg1_int_num[VXGE_HAL_VPATH_INTR_RX]);
  
  		if (vpath->vp_config->rti.btimer_val !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_BTIMER_VAL) {
  			val64 &=
  			    ~VXGE_HAL_TIM_CFG1_INT_NUM_BTIMER_VAL(0x3ffffff);
  			val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_BTIMER_VAL(
  			    vpath->vp_config->rti.btimer_val);
  		}
  
  		val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_BITMP_EN;
  
  		if (vpath->vp_config->rti.txfrm_cnt_en !=
  		    VXGE_HAL_TXFRM_CNT_EN_USE_FLASH_DEFAULT) {
  			if (vpath->vp_config->rti.txfrm_cnt_en)
  				val64 |=
  				    VXGE_HAL_TIM_CFG1_INT_NUM_TXFRM_CNT_EN;
  			else
  				val64 &=
  				    ~VXGE_HAL_TIM_CFG1_INT_NUM_TXFRM_CNT_EN;
  		}
  
  		if (vpath->vp_config->rti.txd_cnt_en !=
  		    VXGE_HAL_TXD_CNT_EN_USE_FLASH_DEFAULT) {
  			if (vpath->vp_config->rti.txd_cnt_en)
  				val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_TXD_CNT_EN;
  			else
  				val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_TXD_CNT_EN;
  		}
  
  		if (vpath->vp_config->rti.timer_ac_en !=
  		    VXGE_HAL_TIM_TIMER_AC_USE_FLASH_DEFAULT) {
  			if (vpath->vp_config->rti.timer_ac_en)
  				val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_TIMER_AC;
  			else
  				val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_TIMER_AC;
  		}
  
  		if (vpath->vp_config->rti.timer_ci_en !=
  		    VXGE_HAL_TIM_TIMER_CI_USE_FLASH_DEFAULT) {
  			if (vpath->vp_config->rti.timer_ci_en)
  				val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_TIMER_CI;
  			else
  				val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_TIMER_CI;
  		}
  
  		if (vpath->vp_config->rti.urange_a !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_URANGE_A) {
  			val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_URNG_A(0x3f);
  			val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_URNG_A(
  			    vpath->vp_config->rti.urange_a);
  		}
  
  		if (vpath->vp_config->rti.urange_b !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_URANGE_B) {
  			val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_URNG_B(0x3f);
  			val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_URNG_B(
  			    vpath->vp_config->rti.urange_b);
  		}
  
  		if (vpath->vp_config->rti.urange_c !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_URANGE_C) {
  			val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_URNG_C(0x3f);
  			val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_URNG_C(
  			    vpath->vp_config->rti.urange_c);
  		}
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &vpath->vp_reg->tim_cfg1_int_num[VXGE_HAL_VPATH_INTR_RX]);
  
  		vpath->tim_rti_cfg1_saved = val64;
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->tim_cfg2_int_num[VXGE_HAL_VPATH_INTR_RX]);
  
  		if (vpath->vp_config->rti.uec_a !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_UEC_A) {
  			val64 &= ~VXGE_HAL_TIM_CFG2_INT_NUM_UEC_A(0xffff);
  			val64 |= VXGE_HAL_TIM_CFG2_INT_NUM_UEC_A(
  			    vpath->vp_config->rti.uec_a);
  		}
  
  		if (vpath->vp_config->rti.uec_b !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_UEC_B) {
  			val64 &= ~VXGE_HAL_TIM_CFG2_INT_NUM_UEC_B(0xffff);
  			val64 |= VXGE_HAL_TIM_CFG2_INT_NUM_UEC_B(
  			    vpath->vp_config->rti.uec_b);
  		}
  
  		if (vpath->vp_config->rti.uec_c !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_UEC_C) {
  			val64 &= ~VXGE_HAL_TIM_CFG2_INT_NUM_UEC_C(0xffff);
  			val64 |= VXGE_HAL_TIM_CFG2_INT_NUM_UEC_C(
  			    vpath->vp_config->rti.uec_c);
  		}
  
  		if (vpath->vp_config->rti.uec_d !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_UEC_D) {
  			val64 &= ~VXGE_HAL_TIM_CFG2_INT_NUM_UEC_D(0xffff);
  			val64 |= VXGE_HAL_TIM_CFG2_INT_NUM_UEC_D(
  			    vpath->vp_config->rti.uec_d);
  		}
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &vpath->vp_reg->tim_cfg2_int_num[VXGE_HAL_VPATH_INTR_RX]);
  
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->tim_cfg3_int_num[VXGE_HAL_VPATH_INTR_RX]);
  
  		if (vpath->vp_config->rti.timer_ri_en !=
  		    VXGE_HAL_TIM_TIMER_RI_USE_FLASH_DEFAULT) {
  			if (vpath->vp_config->rti.timer_ri_en)
  				val64 |= VXGE_HAL_TIM_CFG3_INT_NUM_TIMER_RI;
  			else
  				val64 &= ~VXGE_HAL_TIM_CFG3_INT_NUM_TIMER_RI;
  		}
  
  		if (vpath->vp_config->rti.rtimer_event_sf !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_RTIMER_EVENT_SF) {
  			val64 &=
  			    ~VXGE_HAL_TIM_CFG3_INT_NUM_RTIMER_EVENT_SF(0xf);
  			val64 |= VXGE_HAL_TIM_CFG3_INT_NUM_RTIMER_EVENT_SF(
  			    vpath->vp_config->rti.rtimer_event_sf);
  		}
  
  		if (vpath->vp_config->rti.rtimer_val !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_RTIMER_VAL) {
  			val64 &=
  			    ~VXGE_HAL_TIM_CFG3_INT_NUM_RTIMER_VAL(0x3ffffff);
  			val64 |= VXGE_HAL_TIM_CFG3_INT_NUM_RTIMER_VAL(
  			    vpath->vp_config->rti.rtimer_val);
  		}
  
  		if (vpath->vp_config->rti.util_sel !=
  		    VXGE_HAL_TIM_UTIL_SEL_USE_FLASH_DEFAULT) {
  			val64 &= ~VXGE_HAL_TIM_CFG3_INT_NUM_UTIL_SEL(0x3f);
  			val64 |= VXGE_HAL_TIM_CFG3_INT_NUM_UTIL_SEL(
  			    vpath->vp_config->rti.util_sel);
  		}
  
  		if (vpath->vp_config->rti.ltimer_val !=
  		    VXGE_HAL_USE_FLASH_DEFAULT_TIM_LTIMER_VAL) {
  			val64 &=
  			    ~VXGE_HAL_TIM_CFG3_INT_NUM_LTIMER_VAL(0x3ffffff);
  			val64 |= VXGE_HAL_TIM_CFG3_INT_NUM_LTIMER_VAL(
  			    vpath->vp_config->rti.ltimer_val);
  		}
  
  		vxge_os_pio_mem_write64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    val64,
  		    &vpath->vp_reg->tim_cfg3_int_num[VXGE_HAL_VPATH_INTR_RX]);
  
  		vpath->tim_rti_cfg3_saved = val64;
  	}
  
  	val64 = 0;
  
  	if (hldev->header.config.intr_mode ==
  	    VXGE_HAL_INTR_MODE_EMULATED_INTA) {
  
  		val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_BTIMER_VAL(1) |
  		    VXGE_HAL_TIM_CFG1_INT_NUM_TIMER_CI;
  
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->tim_cfg1_int_num[VXGE_HAL_VPATH_INTR_EINTA]);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u64) 0,
  	    &vpath->vp_reg->tim_cfg2_int_num[VXGE_HAL_VPATH_INTR_EINTA]);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u64) 0,
  	    &vpath->vp_reg->tim_cfg3_int_num[VXGE_HAL_VPATH_INTR_EINTA]);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u64) 0,
  	    &vpath->vp_reg->tim_cfg1_int_num[VXGE_HAL_VPATH_INTR_BMAP]);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u64) 0,
  	    &vpath->vp_reg->tim_cfg2_int_num[VXGE_HAL_VPATH_INTR_BMAP]);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u64) 0,
  	    &vpath->vp_reg->tim_cfg3_int_num[VXGE_HAL_VPATH_INTR_BMAP]);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_is_rxdmem_leak - Check for the rxd memory leak.
   * @vpath_handle: Virtual Path handle.
   *
   * The function checks for the rxd memory leak.
   *
   */
  u32
  vxge_hal_vpath_is_rxdmem_leak(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	u32 new_qw_count, rxd_spat, bRet = 0;
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vp != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vp->vpath->vp_config->ring.enable == VXGE_HAL_RING_DISABLE) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, bRet);
  		return (bRet);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp->vpath->vp_reg->prc_rxd_doorbell);
  
  	new_qw_count = (u32) VXGE_HAL_PRC_RXD_DOORBELL_GET_NEW_QW_CNT(val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp->vpath->vp_reg->prc_cfg6);
  
  	rxd_spat = (u32) VXGE_HAL_PRC_CFG6_GET_RXD_SPAT(val64);
  
  	bRet = (new_qw_count > (rxd_spat * 3 / 2));
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, bRet);
  
  	return (bRet);
  }
  
  /*
   * vxge_hal_vpath_mtu_check - check MTU value for ranges
   * @vpath_handle: Virtal path handle
   * @new_mtu: new MTU value to check
   *
   * Will do sanity check for new MTU value.
   *
   * Returns: VXGE_HAL_OK - success.
   * VXGE_HAL_ERR_INVALID_MTU_SIZE - MTU is invalid.
   *
   * See also: vxge_hal_vpath_mtu_set()
   */
  vxge_hal_status_e
  vxge_hal_device_mtu_check(vxge_hal_vpath_h vpath_handle,
      unsigned long new_mtu)
  {
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vp == NULL) {
  		vxge_hal_trace_log_vpath(
  		    "<== %s:%s:%d  Result: %d", __FILE__, __func__,
  		    __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	new_mtu += VXGE_HAL_MAC_HEADER_MAX_SIZE;
  
  	if ((new_mtu < VXGE_HAL_MIN_MTU) || (new_mtu > vp->vpath->max_mtu)) {
  		status = VXGE_HAL_ERR_INVALID_MTU_SIZE;
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_mtu_set - Set MTU.
   * @vpath_handle: Virtal path handle
   * @new_mtu: New MTU size to configure.
   *
   * Set new MTU value. Example, to use jumbo frames:
   * vxge_hal_vpath_mtu_set(my_device, 9600);
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_mtu_set(vxge_hal_vpath_h vpath_handle,
      unsigned long new_mtu)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vp == NULL) {
  		vxge_hal_trace_log_vpath(
  		    "<== %s:%s:%d  Result: %d", __FILE__, __func__,
  		    __LINE__, VXGE_HAL_ERR_INVALID_HANDLE);
  		return (VXGE_HAL_ERR_INVALID_HANDLE);
  	}
  
  	new_mtu += VXGE_HAL_MAC_HEADER_MAX_SIZE;
  
  	if ((new_mtu < VXGE_HAL_MIN_MTU) || (new_mtu > vp->vpath->max_mtu)) {
  		status = VXGE_HAL_ERR_INVALID_MTU_SIZE;
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp->vpath->vp_reg->rxmac_vcfg0);
  
  	val64 &= ~VXGE_HAL_RXMAC_VCFG0_RTS_MAX_FRM_LEN(0x3fff);
  	val64 |= VXGE_HAL_RXMAC_VCFG0_RTS_MAX_FRM_LEN(new_mtu);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vp->vpath->vp_reg->rxmac_vcfg0);
  
  	vp->vpath->vp_config->mtu = new_mtu - VXGE_HAL_MAC_HEADER_MAX_SIZE;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  
  /*
   * __hal_vpath_size_quantum_set
   * @hldev: Handle to the device object
   * @vp_id: Virtual Path Id
   *
   * This routine configures the size quantum of virtual path
   * using the config passed
   */
  vxge_hal_status_e
  __hal_vpath_size_quantum_set(
      vxge_hal_device_h devh,
      u32 vp_id)
  {
  	u64 val64;
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  	__hal_virtualpath_t *vpath;
  
  	vxge_assert(devh != NULL);
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("devh = 0x"VXGE_OS_STXFMT", vp_id = %d",
  	    (ptr_t) devh, vp_id);
  
  	vpath = (__hal_virtualpath_t *) &hldev->virtual_paths[vp_id];
  
  	switch (__vxge_os_cacheline_size) {
  	case 8:
  		val64 = 0;
  		break;
  	case 16:
  		val64 = 1;
  		break;
  	case 32:
  		val64 = 2;
  		break;
  	case 64:
  		val64 = 3;
  		break;
  	default:
  	case 128:
  		val64 = 4;
  		break;
  	case 256:
  		val64 = 5;
  		break;
  	case 512:
  		val64 = 6;
  		break;
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev, hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->vpath_general_cfg2);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: 0",
  	    __FILE__, __func__, __LINE__);
  	return (VXGE_HAL_OK);
  }
  
  /*
   * __hal_vpath_hw_initialize
   * @hldev: Handle to the device object
   * @vp_id: Virtual Path Id
   *
   * This routine initializes the registers of virtual path
   * using the config passed
   */
  vxge_hal_status_e
  __hal_vpath_hw_initialize(
      vxge_hal_device_h devh,
      u32 vp_id)
  {
  	u64 val64;
  	u32 mrrs;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_virtualpath_t *vpath;
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  	vxge_hal_pci_e_capability_t *pci_e_cap;
  
  	vxge_assert(devh != NULL);
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("devh = 0x"VXGE_OS_STXFMT", vp_id = %d",
  	    (ptr_t) devh, vp_id);
  
  	vpath = (__hal_virtualpath_t *) &hldev->virtual_paths[vp_id];
  
  	if (!(hldev->vpath_assignments & mBIT(vp_id))) {
  
  		vxge_hal_trace_log_vpath(
  		    "<== %s:%s:%d  Result: %d", __FILE__, __func__,
  		    __LINE__, VXGE_HAL_ERR_VPATH_NOT_AVAILABLE);
  		return (VXGE_HAL_ERR_VPATH_NOT_AVAILABLE);
  	}
  
  	status = __hal_vpath_swapper_set((vxge_hal_device_t *) hldev, vp_id);
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	status = __hal_vpath_size_quantum_set(hldev, vp_id);
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	status = __hal_vpath_mac_configure(hldev, vp_id);
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	status = __hal_vpath_kdfc_configure(hldev, vp_id);
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  
  	status = __hal_vpath_tim_configure(hldev, vp_id);
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev, hldev->header.regh0,
  	    VXGE_HAL_USDC_VPATH_SGRP_ASSIGN(
  	    vpath->sess_grps_available),
  	    &vpath->vp_reg->usdc_vpath);
  
  	vxge_os_wmb();
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->qcc_pci_cfg);
  
  	val64 |= VXGE_HAL_QCC_PCI_CFG_ADD_PAD_CQE_SPACE |
  	    VXGE_HAL_QCC_PCI_CFG_ADD_PAD_WQE |
  	    VXGE_HAL_QCC_PCI_CFG_ADD_PAD_SRQIR |
  	    VXGE_HAL_QCC_PCI_CFG_CTL_STR_CQE_SPACE |
  	    VXGE_HAL_QCC_PCI_CFG_CTL_STR_WQE |
  	    VXGE_HAL_QCC_PCI_CFG_CTL_STR_SRQIR;
  
  	if (vpath->vp_config->no_snoop !=
  	    VXGE_HAL_VPATH_NO_SNOOP_USE_FLASH_DEFAULT) {
  		if (vpath->vp_config->no_snoop) {
  			val64 |= VXGE_HAL_QCC_PCI_CFG_NO_SNOOP_CQE_SPACE |
  			    VXGE_HAL_QCC_PCI_CFG_NO_SNOOP_WQE |
  			    VXGE_HAL_QCC_PCI_CFG_NO_SNOOP_SRQIR;
  		} else {
  			val64 &= ~(VXGE_HAL_QCC_PCI_CFG_NO_SNOOP_CQE_SPACE |
  			    VXGE_HAL_QCC_PCI_CFG_NO_SNOOP_WQE |
  			    VXGE_HAL_QCC_PCI_CFG_NO_SNOOP_SRQIR);
  		}
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev, hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->qcc_pci_cfg);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->h2l_vpath_config);
  
  	if (vpath->vp_config->no_snoop !=
  	    VXGE_HAL_VPATH_NO_SNOOP_USE_FLASH_DEFAULT) {
  		if (vpath->vp_config->no_snoop) {
  			val64 |= VXGE_HAL_H2L_VPATH_CONFIG_OD_NO_SNOOP;
  		} else {
  			val64 &= ~VXGE_HAL_H2L_VPATH_CONFIG_OD_NO_SNOOP;
  		}
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev, hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->h2l_vpath_config);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->ph2l_vp_cfg0);
  
  	if (vpath->vp_config->no_snoop !=
  	    VXGE_HAL_VPATH_NO_SNOOP_USE_FLASH_DEFAULT) {
  		if (vpath->vp_config->no_snoop) {
  			val64 |= VXGE_HAL_PH2L_VP_CFG0_NOSNOOP_DATA;
  		} else {
  			val64 &= ~VXGE_HAL_PH2L_VP_CFG0_NOSNOOP_DATA;
  		}
  	}
  
  	vxge_os_pio_mem_write64(hldev->header.pdev, hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->ph2l_vp_cfg0);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev, hldev->header.regh0,
  	    0,
  	    &vpath->vp_reg->gendma_int);
  
  	pci_e_cap = (vxge_hal_pci_e_capability_t *)
  	    (((char *)&hldev->pci_config_space_bios) + hldev->pci_e_caps);
  
  	mrrs = pci_e_cap->pci_e_devctl >> 12;
  
  	val64 = VXGE_HAL_RTDMA_RD_OPTIMIZATION_CTRL_GEN_INT_AFTER_ABORT |
  	    VXGE_HAL_RTDMA_RD_OPTIMIZATION_CTRL_FB_FILL_THRESH(mrrs) |
  	    VXGE_HAL_RTDMA_RD_OPTIMIZATION_CTRL_FB_ADDR_BDRY_EN |
  	    VXGE_HAL_RTDMA_RD_OPTIMIZATION_CTRL_TXD_FILL_THRESH(1);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev, hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->rtdma_rd_optimization_ctrl);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  /*
   * __hal_vp_initialize - Initialize Virtual Path structure
   * @hldev: Handle to the device object
   * @vp_id: Virtual Path Id
   * @config: Configuration for the virtual path
   *
   * This routine initializes virtual path using the config passed
   */
  vxge_hal_status_e
  __hal_vp_initialize(vxge_hal_device_h devh,
      u32 vp_id,
      vxge_hal_vp_config_t *config)
  {
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  	__hal_virtualpath_t *vpath;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert((hldev != NULL) && (config != NULL));
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "devh = 0x"VXGE_OS_STXFMT", vp_id = %d, config = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) devh, vp_id, (ptr_t) config);
  
  	if (!(hldev->vpath_assignments & mBIT(vp_id))) {
  
  		vxge_hal_trace_log_vpath(
  		    "<== %s:%s:%d  Result: %d", __FILE__, __func__,
  		    __LINE__, VXGE_HAL_ERR_VPATH_NOT_AVAILABLE);
  		return (VXGE_HAL_ERR_VPATH_NOT_AVAILABLE);
  	}
  
  	vpath = (__hal_virtualpath_t *) &hldev->virtual_paths[vp_id];
  	vpath->vp_id = vp_id;
  
  	vpath->vp_open = VXGE_HAL_VP_OPEN;
  
  	vpath->hldev = (__hal_device_t *) devh;
  
  	vpath->vp_config = config;
  
  	vpath->vp_reg = hldev->vpath_reg[vp_id];
  
  	vpath->vpmgmt_reg = hldev->vpmgmt_reg[vp_id];
  
  	status = __hal_vpath_hw_reset(devh, vp_id);
  
  	if (status != VXGE_HAL_OK) {
  		vxge_hal_trace_log_vpath(
  		    "vpath is already in reset  %s:%s:%d",
  		    __FILE__, __func__, __LINE__);
  	}
  
  	status = __hal_vpath_reset_check(vpath);
  
  	if (status != VXGE_HAL_OK) {
  		vxge_os_memzero(vpath, sizeof(__hal_virtualpath_t));
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = %d",
  		    __FILE__, __func__, __LINE__, status);
  
  		return (status);
  	}
  
  	status = __hal_vpath_mgmt_read(hldev, vpath);
  
  	if (status != VXGE_HAL_OK) {
  		vxge_os_memzero(vpath, sizeof(__hal_virtualpath_t));
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	vpath->tx_intr_num =
  	    (vp_id * VXGE_HAL_MAX_INTR_PER_VP) + VXGE_HAL_VPATH_INTR_TX;
  
  	vpath->rx_intr_num =
  	    (vp_id * VXGE_HAL_MAX_INTR_PER_VP) + VXGE_HAL_VPATH_INTR_RX;
  
  	vpath->einta_intr_num =
  	    (vp_id * VXGE_HAL_MAX_INTR_PER_VP) + VXGE_HAL_VPATH_INTR_EINTA;
  
  	vpath->bmap_intr_num =
  	    (vp_id * VXGE_HAL_MAX_INTR_PER_VP) + VXGE_HAL_VPATH_INTR_BMAP;
  
  
  #if defined(VXGE_HAL_VP_CBS)
  	vxge_os_spin_lock_init(&vpath->vpath_handles_lock, hldev->pdev);
  #elif defined(VXGE_HAL_VP_CBS_IRQ)
  	vxge_os_spin_lock_init_irq(&vpath->vpath_handles_lock, hldev->irqh);
  #endif
  
  	vxge_list_init(&vpath->vpath_handles);
  
  	vpath->sw_stats = &hldev->stats.sw_dev_info_stats.vpath_info[vp_id];
  
  	vxge_os_memzero(&vpath->sw_stats->obj_counts,
  	    sizeof(vxge_hal_vpath_sw_obj_count_t));
  
  	VXGE_HAL_DEVICE_TIM_INT_MASK_SET(vpath->hldev, vpath->vp_id);
  
  	status = __hal_vpath_hw_initialize(vpath->hldev, vpath->vp_id);
  
  	if (status != VXGE_HAL_OK) {
  		__hal_vp_terminate(devh, vp_id);
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  /*
   * __hal_vp_terminate - Terminate Virtual Path structure
   * @hldev: Handle to the device object
   * @vp_id: Virtual Path Id
   *
   * This routine closes all channels it opened and freeup memory
   */
  void
  __hal_vp_terminate(vxge_hal_device_h devh, u32 vp_id)
  {
  	__hal_virtualpath_t *vpath;
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  
  	vxge_assert(devh != NULL);
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "devh = 0x"VXGE_OS_STXFMT", vp_id = %d", (ptr_t) devh, vp_id);
  
  	vpath = (__hal_virtualpath_t *) &hldev->virtual_paths[vp_id];
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  
  		vxge_hal_trace_log_vpath(
  		    "<== %s:%s:%d  Result: %d", __FILE__, __func__,
  		    __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return;
  
  	}
  
  	VXGE_HAL_DEVICE_TIM_INT_MASK_RESET(vpath->hldev, vpath->vp_id);
  
  
  #if defined(VXGE_HAL_VP_CBS)
  	vxge_os_spin_lock_destroy(
  	    &vpath->vpath_handles_lock, hldev->header.pdev);
  #elif defined(VXGE_HAL_VP_CBS_IRQ)
  	vxge_os_spin_lock_destroy_irq(
  	    &vpath->vpath_handles_lock, hldev->header.pdev);
  #endif
  
  	vxge_os_memzero(vpath, sizeof(__hal_virtualpath_t));
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: 0",
  	    __FILE__, __func__, __LINE__);
  }
  
  
  /*
   * vxge_hal_vpath_obj_count_get - Get the Object usage count for a given
   *		 virtual path
   * @vpath_handle: Virtal path handle
   * @obj_counts: Buffer to return object counts
   *
   * This function returns the object counts for virtual path.
   */
  vxge_hal_status_e
  vxge_hal_vpath_obj_count_get(
      vxge_hal_vpath_h vpath_handle,
      vxge_hal_vpath_sw_obj_count_t *obj_count)
  {
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	if ((vpath_handle == NULL) || (obj_count == NULL))
  		return (VXGE_HAL_FAIL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT", "
  	    "obj_count = 0x"VXGE_OS_STXFMT, (ptr_t) vpath_handle,
  	    (ptr_t) obj_count);
  
  	vxge_os_memcpy(obj_count, &vp->vpath->sw_stats->obj_counts,
  	    sizeof(vxge_hal_vpath_sw_obj_count_t));
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_open - Open a virtual path on a given adapter
   * @devh: handle to device object
   * @attr: Virtual path attributes
   * @cb_fn: Call back to be called to complete an asynchronous function call
   * @client_handle: handle to be returned in the callback
   * @vpath_handle: Buffer to return a handle to the vpath
   *
   * This function is used to open access to virtual path of an
   * adapter for offload, LRO and SPDM operations. This function returns
   * synchronously.
   */
  vxge_hal_status_e
  vxge_hal_vpath_open(vxge_hal_device_h devh,
      vxge_hal_vpath_attr_t *attr,
      vxge_hal_vpath_callback_f cb_fn,
      vxge_hal_client_h client_handle,
      vxge_hal_vpath_h *vpath_handle)
  {
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  	__hal_virtualpath_t *vpath;
  	__hal_vpath_handle_t *vp;
  	vxge_hal_status_e status;
  
  	vxge_assert((devh != NULL) && (attr != NULL) && (cb_fn != NULL) &&
  	    (vpath_handle != NULL));
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("devh = 0x"VXGE_OS_STXFMT", "
  	    "attr = 0x"VXGE_OS_STXFMT", cb_fn = 0x"VXGE_OS_STXFMT", "
  	    "client_handle = 0x"VXGE_OS_STXFMT", "
  	    "vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) devh, (ptr_t) attr, (ptr_t) cb_fn,
  	    (ptr_t) client_handle, (ptr_t) vpath_handle);
  
  
  	vpath = (__hal_virtualpath_t *) &hldev->virtual_paths[attr->vp_id];
  
  	if (vpath->vp_open == VXGE_HAL_VP_OPEN) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_INVALID_STATE);
  		return (VXGE_HAL_ERR_INVALID_STATE);
  	}
  
  	status = __hal_vp_initialize(hldev, attr->vp_id,
  	    &hldev->header.config.vp_config[attr->vp_id]);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_err_log_vpath(
  		    "virtual Paths: __hal_vp_initialize failed == > %s : %d",
  		    __func__, __LINE__);
  
  		goto vpath_open_exit1;
  
  	}
  
  	vp = (__hal_vpath_handle_t *) vxge_os_malloc(hldev->header.pdev,
  	    sizeof(__hal_vpath_handle_t));
  
  	if (vp == NULL) {
  
  		status = VXGE_HAL_ERR_OUT_OF_MEMORY;
  
  		goto vpath_open_exit2;
  
  	}
  
  	vxge_os_memzero(vp, sizeof(__hal_vpath_handle_t));
  
  	vp->vpath = vpath;
  	vp->cb_fn = cb_fn;
  	vp->client_handle = client_handle;
  
  
  	if (vp->vpath->vp_config->fifo.enable == VXGE_HAL_FIFO_ENABLE) {
  
  		status = __hal_fifo_create(vp, &attr->fifo_attr);
  		if (status != VXGE_HAL_OK) {
  			goto vpath_open_exit6;
  		}
  	}
  
  	if (vp->vpath->vp_config->ring.enable == VXGE_HAL_RING_ENABLE) {
  
  		status = __hal_ring_create(vp, &attr->ring_attr);
  		if (status != VXGE_HAL_OK) {
  			goto vpath_open_exit7;
  		}
  
  		status = __hal_vpath_prc_configure(devh, attr->vp_id);
  		if (status != VXGE_HAL_OK) {
  			goto vpath_open_exit8;
  		}
  	}
  
  
  
  	vp->vpath->stats_block = __hal_blockpool_block_allocate(devh,
  	    VXGE_OS_HOST_PAGE_SIZE);
  
  	if (vp->vpath->stats_block == NULL) {
  
  		status = VXGE_HAL_ERR_OUT_OF_MEMORY;
  
  		goto vpath_open_exit8;
  
  	}
  
  	vp->vpath->hw_stats =
  	    (vxge_hal_vpath_stats_hw_info_t *) vp->vpath->stats_block->memblock;
  
  	vxge_os_memzero(vp->vpath->hw_stats,
  	    sizeof(vxge_hal_vpath_stats_hw_info_t));
  
  	hldev->stats.hw_dev_info_stats.vpath_info[attr->vp_id] =
  	    vp->vpath->hw_stats;
  
  	vp->vpath->hw_stats_sav =
  	    &hldev->stats.hw_dev_info_stats.vpath_info_sav[attr->vp_id];
  
  	vxge_os_memzero(vp->vpath->hw_stats_sav,
  	    sizeof(vxge_hal_vpath_stats_hw_info_t));
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    vp->vpath->stats_block->dma_addr,
  	    &vpath->vp_reg->stats_cfg);
  
  	status = vxge_hal_vpath_hw_stats_enable(vp);
  
  	if (status != VXGE_HAL_OK) {
  
  		goto vpath_open_exit8;
  
  	}
  
  	vxge_list_insert(&vp->item, &vpath->vpath_handles);
  
  	hldev->vpaths_deployed |= mBIT(vpath->vp_id);
  	*vpath_handle = vp;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: 0",
  	    __FILE__, __func__, __LINE__);
  	return (VXGE_HAL_OK);
  
  vpath_open_exit8:
  	if (vpath->ringh != NULL)
  		__hal_ring_delete(vp);
  vpath_open_exit7:
  	if (vpath->fifoh != NULL)
  		__hal_fifo_delete(vp);
  vpath_open_exit6:
  
  	vxge_os_free(hldev->header.pdev, vp,
  	    sizeof(__hal_vpath_handle_t));
  vpath_open_exit2:
  	__hal_vp_terminate(devh, attr->vp_id);
  vpath_open_exit1:
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_id - Get virtual path ID
   * @vpath_handle: Handle got from previous vpath open
   *
   * This function returns virtual path id
   */
  u32
  vxge_hal_vpath_id(
      vxge_hal_vpath_h vpath_handle)
  {
  	u32 id;
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	id = ((__hal_vpath_handle_t *) vpath_handle)->vpath->vp_id;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (id);
  }
  
  /*
   * vxge_hal_vpath_close - Close the handle got from previous vpath (vpath) open
   * @vpath_handle: Handle got from previous vpath open
   *
   * This function is used to close access to virtual path opened
   * earlier.
   */
  vxge_hal_status_e
  vxge_hal_vpath_close(
      vxge_hal_vpath_h vpath_handle)
  {
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  	__hal_virtualpath_t *vpath;
  	__hal_device_t *hldev;
  	u32 vp_id;
  	u32 is_empty = TRUE;
  
  	vxge_assert(vpath_handle != NULL);
  
  	vpath = (__hal_virtualpath_t *) vp->vpath;
  
  	hldev = (__hal_device_t *) vpath->hldev;
  
  	vp_id = vpath->vp_id;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT, (ptr_t) vpath_handle);
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  #if defined(VXGE_HAL_VP_CBS)
  	vxge_os_spin_lock(&vpath->vpath_handles_lock);
  #elif defined(VXGE_HAL_VP_CBS_IRQ)
  	vxge_os_spin_lock_irq(&vpath->vpath_handles_lock, flags);
  #endif
  
  	vxge_list_remove(&vp->item);
  
  	if (!vxge_list_is_empty(&vpath->vpath_handles)) {
  		vxge_list_insert(&vp->item, &vpath->vpath_handles);
  		is_empty = FALSE;
  	}
  
  #if defined(VXGE_HAL_VP_CBS)
  	vxge_os_spin_unlock(&vpath->vpath_handles_lock);
  #elif defined(VXGE_HAL_VP_CBS_IRQ)
  	vxge_os_spin_unlock_irq(&vpath->vpath_handles_lock, flags);
  #endif
  
  	if (!is_empty) {
  		vxge_hal_err_log_vpath("clients are still attached == > %s : %d",
  		    __func__, __LINE__);
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: 1",
  		    __FILE__, __func__, __LINE__);
  		return (VXGE_HAL_FAIL);
  	}
  
  	vpath->hldev->vpaths_deployed &= ~mBIT(vp_id);
  
  	if (vpath->ringh != NULL)
  		__hal_ring_delete(vpath_handle);
  
  	if (vpath->fifoh != NULL)
  		__hal_fifo_delete(vpath_handle);
  
  
  	if (vpath->stats_block != NULL) {
  		__hal_blockpool_block_free(hldev, vpath->stats_block);
  	}
  
  	vxge_os_free(hldev->header.pdev,
  	    vpath_handle, sizeof(__hal_vpath_handle_t));
  
  	__hal_vp_terminate(hldev, vp_id);
  
  	vpath->vp_open = VXGE_HAL_VP_NOT_OPEN;
  
  	(void) __hal_ifmsg_wmsg_post(hldev,
  	    vp_id,
  	    VXGE_HAL_RTS_ACCESS_STEER_MSG_DEST_BROADCAST,
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_MSG_TYPE_VPATH_RESET_END,
  	    0);
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: 0",
  	    __FILE__, __func__, __LINE__);
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_reset - Resets vpath
   * @vpath_handle: Handle got from previous vpath open
   *
   * This function is used to request a reset of vpath
   */
  vxge_hal_status_e
  vxge_hal_vpath_reset(
      vxge_hal_vpath_h vpath_handle)
  {
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status;
  	u32 count = 0, total_count = 0;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vp->vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  	vxge_hw_vpath_set_zero_rx_frm_len(hldev, vp->vpath->vp_id);
  
  	vxge_hw_vpath_wait_receive_idle(hldev, vp->vpath->vp_id,
  	    &count, &total_count);
  
  	status = __hal_vpath_hw_reset((vxge_hal_device_h) hldev,
  	    vp->vpath->vp_id);
  
  	if (status == VXGE_HAL_OK)
  		vp->vpath->sw_stats->soft_reset_cnt++;
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_reset_poll - Poll for reset complete
   * @vpath_handle: Handle got from previous vpath open
   *
   * This function is used to poll for the vpath reset completion
   */
  vxge_hal_status_e
  vxge_hal_vpath_reset_poll(
      vxge_hal_vpath_h vpath_handle)
  {
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_vpath("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_vpath("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	if (vp->vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  	status = __hal_vpath_reset_check(vp->vpath);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d Result = %d",
  		    __FILE__, __func__, __LINE__, status);
  
  		return (status);
  	}
  
  	status = __hal_vpath_sw_reset((vxge_hal_device_h) hldev,
  	    vp->vpath->vp_id);
  
  	if (status != VXGE_HAL_OK) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	vxge_os_memzero(vp->vpath->sw_stats,
  	    sizeof(vxge_hal_vpath_stats_sw_info_t));
  
  	status = __hal_vpath_hw_initialize((vxge_hal_device_h) hldev,
  	    vp->vpath->vp_id);
  
  	if (status != VXGE_HAL_OK) {
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	if (vp->vpath->ringh != NULL) {
  
  		status = __hal_vpath_prc_configure(
  		    (vxge_hal_device_h) hldev,
  		    vp->vpath->vp_id);
  
  		if (status != VXGE_HAL_OK) {
  			vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  			    __FILE__, __func__, __LINE__, status);
  			return (status);
  		}
  	}
  
  	vxge_os_memzero(vp->vpath->hw_stats,
  	    sizeof(vxge_hal_vpath_stats_hw_info_t));
  
  	vxge_os_memzero(vp->vpath->hw_stats_sav,
  	    sizeof(vxge_hal_vpath_stats_hw_info_t));
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    vp->vpath->stats_block->dma_addr,
  	    &vp->vpath->vp_reg->stats_cfg);
  
  
  	status = vxge_hal_vpath_hw_stats_enable(vp);
  
  	if (status != VXGE_HAL_OK) {
  
  		vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  
  	}
  
  	vxge_hal_trace_log_vpath("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_hw_stats_enable - Enable vpath h/wstatistics.
   * @vpath_handle: Virtual Path handle.
   *
   * Enable the DMA vpath statistics. The function is to be called to re-enable
   * the adapter to update stats into the host memory
   *
   * See also: vxge_hal_vpath_hw_stats_disable(), vxge_hal_vpath_hw_stats_get()
   */
  vxge_hal_status_e
  vxge_hal_vpath_hw_stats_enable(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_stats("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_stats("vpath = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	vpath = vp->vpath;
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  	vxge_os_memcpy(vpath->hw_stats_sav,
  	    vpath->hw_stats,
  	    sizeof(vxge_hal_vpath_stats_hw_info_t));
  
  	if (hldev->header.config.stats_read_method ==
  	    VXGE_HAL_STATS_READ_METHOD_DMA) {
  		val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &hldev->common_reg->stats_cfg0);
  
  		val64 |= VXGE_HAL_STATS_CFG0_STATS_ENABLE(
  		    (1 << (16 - vpath->vp_id)));
  
  		vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  		    hldev->header.regh0,
  		    (u32) bVAL32(val64, 0),
  		    &hldev->common_reg->stats_cfg0);
  	} else {
  		status = __hal_vpath_hw_stats_get(
  		    vpath,
  		    vpath->hw_stats);
  	}
  
  	vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_hw_stats_disable - Disable vpath h/w statistics.
   * @vpath_handle: Virtual Path handle.
   *
   * Enable the DMA vpath statistics. The function is to be called to disable
   * the adapter to update stats into the host memory. This function is not
   * needed to be called, normally.
   *
   * See also: vxge_hal_vpath_hw_stats_enable(), vxge_hal_vpath_hw_stats_get()
   */
  vxge_hal_status_e
  vxge_hal_vpath_hw_stats_disable(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_stats("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_stats(
  	    "vpath = 0x"VXGE_OS_STXFMT, (ptr_t) vpath_handle);
  
  	vpath = (__hal_virtualpath_t *)
  	    ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &hldev->common_reg->stats_cfg0);
  
  	val64 &= ~VXGE_HAL_STATS_CFG0_STATS_ENABLE((1 << (16 - vpath->vp_id)));
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 0),
  	    &hldev->common_reg->stats_cfg0);
  
  	vxge_hal_trace_log_stats("<== %s:%s:%d  Result: 0",
  	    __FILE__, __func__, __LINE__);
  
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_hw_stats_get - Get the vpath hw statistics.
   * @vpath_handle: Virtual Path handle.
   * @hw_stats: Hardware stats
   *
   * Returns the vpath h/w stats.
   *
   * See also: vxge_hal_vpath_hw_stats_enable(),
   * vxge_hal_vpath_hw_stats_disable()
   */
  vxge_hal_status_e
  vxge_hal_vpath_hw_stats_get(vxge_hal_vpath_h vpath_handle,
      vxge_hal_vpath_stats_hw_info_t *hw_stats)
  {
  	__hal_virtualpath_t *vpath;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert((vpath_handle != NULL) && (hw_stats != NULL));
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_stats("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_stats(
  	    "vpath = 0x"VXGE_OS_STXFMT", hw_stats = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, (ptr_t) hw_stats);
  
  	vpath = (__hal_virtualpath_t *)
  	    ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  	status = vxge_hal_device_register_poll(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &hldev->common_reg->stats_cfg0,
  	    0,
  	    VXGE_HAL_STATS_CFG0_STATS_ENABLE((1 << (16 - vpath->vp_id))),
  	    hldev->header.config.device_poll_millis);
  
  	if (status == VXGE_HAL_OK) {
  		vxge_os_memcpy(hw_stats,
  		    vpath->hw_stats,
  		    sizeof(vxge_hal_vpath_stats_hw_info_t));
  	}
  
  	vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_sw_stats_get - Get the vpath sw statistics.
   * @vpath_handle: Virtual Path handle.
   * @sw_stats: Software stats
   *
   * Returns the vpath s/w stats.
   *
   * See also: vxge_hal_vpath_hw_stats_get()
   */
  vxge_hal_status_e
  vxge_hal_vpath_sw_stats_get(vxge_hal_vpath_h vpath_handle,
      vxge_hal_vpath_stats_sw_info_t *sw_stats)
  {
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert((vpath_handle != NULL) && (sw_stats != NULL));
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_stats("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_stats(
  	    "vpath = 0x"VXGE_OS_STXFMT", sw_stats = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle, (ptr_t) sw_stats);
  
  	vpath = (__hal_virtualpath_t *)
  	    ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  	if (hldev->header.traffic_intr_cnt) {
  		int intrcnt = hldev->header.traffic_intr_cnt;
  
  		if (!intrcnt)
  			intrcnt = 1;
  
  		vpath->sw_stats->fifo_stats.common_stats.avg_compl_per_intr_cnt =
  		    vpath->sw_stats->fifo_stats.common_stats.total_compl_cnt / intrcnt;
  
  		if (vpath->sw_stats->fifo_stats.common_stats.avg_compl_per_intr_cnt ==
  		    0) {
  			/* to not confuse user */
  			vpath->sw_stats->fifo_stats.common_stats.avg_compl_per_intr_cnt = 1;
  		}
  
  		vpath->sw_stats->ring_stats.common_stats.avg_compl_per_intr_cnt =
  		    vpath->sw_stats->ring_stats.common_stats.total_compl_cnt / intrcnt;
  
  		if (vpath->sw_stats->ring_stats.common_stats.avg_compl_per_intr_cnt ==
  		    0) {
  			/* to not confuse user */
  			vpath->sw_stats->ring_stats.common_stats.avg_compl_per_intr_cnt = 1;
  		}
  	}
  
  	if (vpath->sw_stats->fifo_stats.total_posts) {
  		vpath->sw_stats->fifo_stats.avg_buffers_per_post =
  		    vpath->sw_stats->fifo_stats.total_buffers /
  		    vpath->sw_stats->fifo_stats.total_posts;
  
  		vpath->sw_stats->fifo_stats.avg_post_size =
  		    (u32) (vpath->hw_stats->tx_stats.tx_ttl_eth_octets /
  		    vpath->sw_stats->fifo_stats.total_posts);
  	}
  
  	if (vpath->sw_stats->fifo_stats.total_buffers) {
  		vpath->sw_stats->fifo_stats.avg_buffer_size =
  		    (u32) (vpath->hw_stats->tx_stats.tx_ttl_eth_octets /
  		    vpath->sw_stats->fifo_stats.total_buffers);
  	}
  
  	vxge_os_memcpy(sw_stats,
  	    vpath->sw_stats,
  	    sizeof(vxge_hal_vpath_stats_sw_info_t));
  
  	vxge_hal_trace_log_stats("<== %s:%s:%d  Result: 0",
  	    __FILE__, __func__, __LINE__);
  	return (VXGE_HAL_OK);
  }
  
  /*
   * __hal_vpath_stats_access - Get the statistics from the given location
   *			  and offset and perform an operation
   * @vpath: Virtual path.
   * @operation: Operation to be performed
   * @location: Location (one of vpath id, aggregate or port)
   * @offset: Offset with in the location
   * @stat: Pointer to a buffer to return the value
   *
   * Get the statistics from the given location and offset.
   *
   */
  vxge_hal_status_e
  __hal_vpath_stats_access(
      __hal_virtualpath_t *vpath,
      u32 operation,
      u32 offset,
      u64 *stat)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vxge_assert(vpath != NULL);
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_stats("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_stats("vpath = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath);
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_VPATH_NOT_OPEN);
  
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  	val64 = VXGE_HAL_XMAC_STATS_ACCESS_CMD_OP(operation) |
  	    VXGE_HAL_XMAC_STATS_ACCESS_CMD_STROBE |
  	    VXGE_HAL_XMAC_STATS_ACCESS_CMD_OFFSET_SEL(offset);
  
  	vxge_hal_pio_mem_write32_lower(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 32),
  	    &vpath->vp_reg->xmac_stats_access_cmd);
  	vxge_os_wmb();
  
  	vxge_hal_pio_mem_write32_upper(hldev->header.pdev,
  	    hldev->header.regh0,
  	    (u32) bVAL32(val64, 0),
  	    &vpath->vp_reg->xmac_stats_access_cmd);
  	vxge_os_wmb();
  
  	status = vxge_hal_device_register_poll(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->xmac_stats_access_cmd,
  	    0,
  	    VXGE_HAL_XMAC_STATS_ACCESS_CMD_STROBE,
  	    hldev->header.config.device_poll_millis);
  
  	if ((status == VXGE_HAL_OK) && (operation == VXGE_HAL_STATS_OP_READ)) {
  
  		*stat = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vpath->vp_reg->xmac_stats_access_data);
  
  	} else {
  		*stat = 0;
  	}
  
  	vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_stats_access
   * Get statistics from given location and offset to perform an operation
   * @vpath_handle: Virtual path handle.
   * @operation: Operation to be performed
   * @offset: Offset with in the location
   * @stat: Pointer to a buffer to return the value
   *
   * Get the statistics from the given location and offset.
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_stats_access(
      vxge_hal_vpath_h vpath_handle,
      u32 operation,
      u32 offset,
      u64 *stat)
  {
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  	vxge_hal_status_e status;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_stats("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_stats(
  	    "vpath_handle = 0x"VXGE_OS_STXFMT, (ptr_t) vpath_handle);
  
  	status = __hal_vpath_stats_access(vp->vpath,
  	    operation,
  	    offset,
  	    stat);
  
  	vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * __hal_vpath_xmac_tx_stats_get - Get the TX Statistics of a vpath
   * @vpath: vpath
   * @vpath_tx_stats: Buffer to return TX Statistics of vpath.
   *
   * Get the TX Statistics of a vpath
   *
   */
  vxge_hal_status_e
  __hal_vpath_xmac_tx_stats_get(__hal_virtualpath_t *vpath,
      vxge_hal_xmac_vpath_tx_stats_t *vpath_tx_stats)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status;
  
  	vxge_assert(vpath != NULL);
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_stats("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_stats("vpath = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath);
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__,
  		    __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_TTL_ETH_FRMS_OFFSET);
  
  	vpath_tx_stats->tx_ttl_eth_frms =
  	    VXGE_HAL_STATS_GET_VPATH_TX_TTL_ETH_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_TTL_ETH_OCTETS_OFFSET);
  
  	vpath_tx_stats->tx_ttl_eth_octets =
  	    VXGE_HAL_STATS_GET_VPATH_TX_TTL_ETH_OCTETS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_DATA_OCTETS_OFFSET);
  
  	vpath_tx_stats->tx_data_octets =
  	    VXGE_HAL_STATS_GET_VPATH_TX_DATA_OCTETS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_MCAST_FRMS_OFFSET);
  
  	vpath_tx_stats->tx_mcast_frms =
  	    VXGE_HAL_STATS_GET_VPATH_TX_MCAST_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_BCAST_FRMS_OFFSET);
  
  	vpath_tx_stats->tx_bcast_frms =
  	    VXGE_HAL_STATS_GET_VPATH_TX_BCAST_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_UCAST_FRMS_OFFSET);
  
  	vpath_tx_stats->tx_ucast_frms =
  	    VXGE_HAL_STATS_GET_VPATH_TX_UCAST_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_TAGGED_FRMS_OFFSET);
  
  	vpath_tx_stats->tx_tagged_frms =
  	    VXGE_HAL_STATS_GET_VPATH_TX_TAGGED_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(VXGE_HAL_STATS_VPATH_TX_VLD_IP_OFFSET);
  
  	vpath_tx_stats->tx_vld_ip =
  	    VXGE_HAL_STATS_GET_VPATH_TX_VLD_IP(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_VLD_IP_OCTETS_OFFSET);
  
  	vpath_tx_stats->tx_vld_ip_octets =
  	    VXGE_HAL_STATS_GET_VPATH_TX_VLD_IP_OCTETS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(VXGE_HAL_STATS_VPATH_TX_ICMP_OFFSET);
  
  	vpath_tx_stats->tx_icmp =
  	    VXGE_HAL_STATS_GET_VPATH_TX_ICMP(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(VXGE_HAL_STATS_VPATH_TX_TCP_OFFSET);
  
  	vpath_tx_stats->tx_tcp =
  	    VXGE_HAL_STATS_GET_VPATH_TX_TCP(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_RST_TCP_OFFSET);
  
  	vpath_tx_stats->tx_rst_tcp =
  	    VXGE_HAL_STATS_GET_VPATH_TX_RST_TCP(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_UDP_OFFSET);
  
  	vpath_tx_stats->tx_udp =
  	    VXGE_HAL_STATS_GET_VPATH_TX_UDP(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_LOST_IP_OFFSET);
  
  	vpath_tx_stats->tx_lost_ip =
  	    (u32) VXGE_HAL_STATS_GET_VPATH_TX_LOST_IP(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_UNKNOWN_PROTOCOL_OFFSET);
  
  	vpath_tx_stats->tx_unknown_protocol =
  	    (u32) VXGE_HAL_STATS_GET_VPATH_TX_UNKNOWN_PROTOCOL(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_PARSE_ERROR_OFFSET);
  
  	vpath_tx_stats->tx_parse_error =
  	    (u32) VXGE_HAL_STATS_GET_VPATH_TX_PARSE_ERROR(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_TCP_OFFLOAD_OFFSET);
  
  	vpath_tx_stats->tx_tcp_offload =
  	    VXGE_HAL_STATS_GET_VPATH_TX_TCP_OFFLOAD(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_RETX_TCP_OFFLOAD_OFFSET);
  
  	vpath_tx_stats->tx_retx_tcp_offload =
  	    VXGE_HAL_STATS_GET_VPATH_TX_RETX_TCP_OFFLOAD(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_TX_LOST_IP_OFFLOAD_OFFSET);
  
  	vpath_tx_stats->tx_lost_ip_offload =
  	    VXGE_HAL_STATS_GET_VPATH_TX_LOST_IP_OFFLOAD(val64);
  
  	vxge_hal_trace_log_stats("<== %s:%s:%d  Result: 0",
  	    __FILE__, __func__, __LINE__);
  	return (VXGE_HAL_OK);
  }
  
  /*
   * __hal_vpath_xmac_rx_stats_get - Get the RX Statistics of a vpath
   * @vpath: vpath
   * @vpath_rx_stats: Buffer to return RX Statistics of vpath.
   *
   * Get the RX Statistics of a vpath
   *
   */
  vxge_hal_status_e
  __hal_vpath_xmac_rx_stats_get(__hal_virtualpath_t *vpath,
      vxge_hal_xmac_vpath_rx_stats_t *vpath_rx_stats)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status;
  
  	vxge_assert(vpath != NULL);
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_stats("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_stats("vpath = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath);
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__,
  		    VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_TTL_ETH_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_ttl_eth_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_TTL_ETH_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(VXGE_HAL_STATS_VPATH_RX_VLD_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_vld_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_VLD_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_OFFLOAD_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_offload_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_OFFLOAD_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_TTL_ETH_OCTETS_OFFSET);
  
  	vpath_rx_stats->rx_ttl_eth_octets =
  	    VXGE_HAL_STATS_GET_VPATH_RX_TTL_ETH_OCTETS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_DATA_OCTETS_OFFSET);
  
  	vpath_rx_stats->rx_data_octets =
  	    VXGE_HAL_STATS_GET_VPATH_RX_DATA_OCTETS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_OFFLOAD_OCTETS_OFFSET);
  
  	vpath_rx_stats->rx_offload_octets =
  	    VXGE_HAL_STATS_GET_VPATH_RX_OFFLOAD_OCTETS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_VLD_MCAST_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_vld_mcast_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_VLD_MCAST_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_VLD_BCAST_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_vld_bcast_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_VLD_BCAST_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_ACC_UCAST_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_accepted_ucast_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_ACC_UCAST_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_ACC_NUCAST_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_accepted_nucast_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_ACC_NUCAST_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_TAGGED_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_tagged_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_TAGGED_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_LONG_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_long_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_LONG_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_USIZED_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_usized_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_USIZED_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_OSIZED_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_osized_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_OSIZED_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_FRAG_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_frag_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_FRAG_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_JABBER_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_jabber_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_JABBER_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_TTL_64_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_ttl_64_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_TTL_64_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_TTL_65_127_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_ttl_65_127_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_TTL_65_127_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_TTL_128_255_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_ttl_128_255_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_TTL_128_255_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_TTL_256_511_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_ttl_256_511_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_TTL_256_511_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_TTL_512_1023_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_ttl_512_1023_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_TTL_512_1023_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_TTL_1024_1518_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_ttl_1024_1518_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_TTL_1024_1518_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_TTL_1519_4095_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_ttl_1519_4095_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_TTL_1519_4095_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_TTL_4096_8191_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_ttl_4096_8191_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_TTL_4096_8191_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_TTL_8192_MAX_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_ttl_8192_max_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_TTL_8192_MAX_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_TTL_GT_MAX_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_ttl_gt_max_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_TTL_GT_MAX_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(VXGE_HAL_STATS_VPATH_RX_IP_OFFSET);
  
  	vpath_rx_stats->rx_ip =
  	    VXGE_HAL_STATS_GET_VPATH_RX_IP(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(VXGE_HAL_STATS_VPATH_RX_ACC_IP_OFFSET);
  
  	vpath_rx_stats->rx_accepted_ip =
  	    VXGE_HAL_STATS_GET_VPATH_RX_ACC_IP(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(VXGE_HAL_STATS_VPATH_RX_IP_OCTETS_OFFSET);
  
  	vpath_rx_stats->rx_ip_octets =
  	    VXGE_HAL_STATS_GET_VPATH_RX_IP_OCTETS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(VXGE_HAL_STATS_VPATH_RX_ERR_IP_OFFSET);
  
  	vpath_rx_stats->rx_err_ip =
  	    VXGE_HAL_STATS_GET_VPATH_RX_ERR_IP(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(VXGE_HAL_STATS_VPATH_RX_ICMP_OFFSET);
  
  	vpath_rx_stats->rx_icmp =
  	    VXGE_HAL_STATS_GET_VPATH_RX_ICMP(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(VXGE_HAL_STATS_VPATH_RX_TCP_OFFSET);
  
  	vpath_rx_stats->rx_tcp =
  	    VXGE_HAL_STATS_GET_VPATH_RX_TCP(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(VXGE_HAL_STATS_VPATH_RX_UDP_OFFSET);
  
  	vpath_rx_stats->rx_udp =
  	    VXGE_HAL_STATS_GET_VPATH_RX_UDP(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(VXGE_HAL_STATS_VPATH_RX_ERR_TCP_OFFSET);
  
  	vpath_rx_stats->rx_err_tcp =
  	    VXGE_HAL_STATS_GET_VPATH_RX_ERR_TCP(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_LOST_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_lost_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_LOST_FRMS(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(VXGE_HAL_STATS_VPATH_RX_LOST_IP_OFFSET);
  
  	vpath_rx_stats->rx_lost_ip =
  	    VXGE_HAL_STATS_GET_VPATH_RX_LOST_IP(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_LOST_IP_OFFLOAD_OFFSET);
  
  	vpath_rx_stats->rx_lost_ip_offload =
  	    VXGE_HAL_STATS_GET_VPATH_RX_LOST_IP_OFFLOAD(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_QUEUE_FULL_DISCARD_OFFSET);
  
  	vpath_rx_stats->rx_queue_full_discard =
  	    (u16) VXGE_HAL_STATS_GET_VPATH_RX_QUEUE_FULL_DISCARD(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_RED_DISCARD_OFFSET);
  
  	vpath_rx_stats->rx_red_discard =
  	    (u16) VXGE_HAL_STATS_GET_VPATH_RX_RED_DISCARD(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_SLEEP_DISCARD_OFFSET);
  
  	vpath_rx_stats->rx_sleep_discard =
  	    (u16) VXGE_HAL_STATS_GET_VPATH_RX_SLEEP_DISCARD(val64);
  
  	vpath_rx_stats->rx_various_discard =
  	    vpath_rx_stats->rx_queue_full_discard;
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_RX_MPA_OK_FRMS_OFFSET);
  
  	vpath_rx_stats->rx_mpa_ok_frms =
  	    VXGE_HAL_STATS_GET_VPATH_RX_MPA_OK_FRMS(val64);
  
  	vxge_hal_trace_log_stats("<== %s:%s:%d  Result: 0",
  	    __FILE__, __func__, __LINE__);
  	return (VXGE_HAL_OK);
  }
  
  /*
   * vxge_hal_vpath_xmac_tx_stats_get - Get the TX Statistics of a vpath
   * @vpath_handle: vpath handle.
   * @vpath_tx_stats: Buffer to return TX Statistics of vpath.
   *
   * Get the TX Statistics of a vpath
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_xmac_tx_stats_get(vxge_hal_vpath_h vpath_handle,
      vxge_hal_xmac_vpath_tx_stats_t *vpath_tx_stats)
  {
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_stats("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_stats("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	status = __hal_vpath_xmac_tx_stats_get(vp->vpath, vpath_tx_stats);
  
  	vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_xmac_rx_stats_get - Get the RX Statistics of a vpath
   * @vpath_handle: vpath handle.
   * @vpath_rx_stats: Buffer to return RX Statistics of vpath.
   *
   * Get the RX Statistics of a vpath
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_xmac_rx_stats_get(vxge_hal_vpath_h vpath_handle,
      vxge_hal_xmac_vpath_rx_stats_t *vpath_rx_stats)
  {
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status;
  
  	vxge_assert(vpath_handle != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_stats("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_stats("vpath_handle = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	status = __hal_vpath_xmac_rx_stats_get(vp->vpath, vpath_rx_stats);
  
  	vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * __hal_vpath_hw_stats_get - Get the vpath hw statistics.
   * @vpath: Virtual Path.
   * @hw_stats: Hardware stats
   *
   * Returns the vpath h/w stats.
   *
   * See also: vxge_hal_vpath_hw_stats_enable(),
   * vxge_hal_vpath_hw_stats_disable()
   */
  vxge_hal_status_e
  __hal_vpath_hw_stats_get(__hal_virtualpath_t *vpath,
      vxge_hal_vpath_stats_hw_info_t *hw_stats)
  {
  	u64 val64;
  	__hal_device_t *hldev;
  	vxge_hal_status_e status;
  
  	vxge_assert((vpath != NULL) && (hw_stats != NULL));
  
  	hldev = vpath->hldev;
  
  	vxge_hal_trace_log_stats("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_stats(
  	    "vpath = 0x"VXGE_OS_STXFMT", hw_stats = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath, (ptr_t) hw_stats);
  
  	if (vpath->vp_open == VXGE_HAL_VP_NOT_OPEN) {
  		vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, VXGE_HAL_ERR_VPATH_NOT_OPEN);
  		return (VXGE_HAL_ERR_VPATH_NOT_OPEN);
  	}
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_debug_stats0);
  
  	hw_stats->ini_num_mwr_sent =
  	    (u32) VXGE_HAL_VPATH_DEBUG_STATS0_GET_INI_NUM_MWR_SENT(val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_debug_stats1);
  
  	hw_stats->ini_num_mrd_sent =
  	    (u32) VXGE_HAL_VPATH_DEBUG_STATS1_GET_INI_NUM_MRD_SENT(val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_debug_stats2);
  
  	hw_stats->ini_num_cpl_rcvd =
  	    (u32) VXGE_HAL_VPATH_DEBUG_STATS2_GET_INI_NUM_CPL_RCVD(val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_debug_stats3);
  
  	hw_stats->ini_num_mwr_byte_sent =
  	    VXGE_HAL_VPATH_DEBUG_STATS3_GET_INI_NUM_MWR_BYTE_SENT(val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_debug_stats4);
  
  	hw_stats->ini_num_cpl_byte_rcvd =
  	    VXGE_HAL_VPATH_DEBUG_STATS4_GET_INI_NUM_CPL_BYTE_RCVD(val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_debug_stats5);
  
  	hw_stats->wrcrdtarb_xoff =
  	    (u32) VXGE_HAL_VPATH_DEBUG_STATS5_GET_WRCRDTARB_XOFF(val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_debug_stats6);
  
  	hw_stats->rdcrdtarb_xoff =
  	    (u32) VXGE_HAL_VPATH_DEBUG_STATS6_GET_RDCRDTARB_XOFF(val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_genstats_count01);
  
  	hw_stats->vpath_genstats_count0 =
  	    (u32) VXGE_HAL_VPATH_GENSTATS_COUNT01_GET_PPIF_VPATH_GENSTATS_COUNT0(
  	    val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_genstats_count01);
  
  	hw_stats->vpath_genstats_count1 =
  	    (u32) VXGE_HAL_VPATH_GENSTATS_COUNT01_GET_PPIF_VPATH_GENSTATS_COUNT1(
  	    val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_genstats_count23);
  
  	hw_stats->vpath_genstats_count2 =
  	    (u32) VXGE_HAL_VPATH_GENSTATS_COUNT23_GET_PPIF_VPATH_GENSTATS_COUNT2(
  	    val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_genstats_count01);
  
  	hw_stats->vpath_genstats_count3 =
  	    (u32) VXGE_HAL_VPATH_GENSTATS_COUNT23_GET_PPIF_VPATH_GENSTATS_COUNT3(
  	    val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_genstats_count4);
  
  	hw_stats->vpath_genstats_count4 =
  	    (u32) VXGE_HAL_VPATH_GENSTATS_COUNT4_GET_PPIF_VPATH_GENSTATS_COUNT4(
  	    val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->vpath_genstats_count5);
  
  	hw_stats->vpath_genstats_count5 = (u32)
  	    VXGE_HAL_VPATH_GENSTATS_COUNT5_GET_PPIF_VPATH_GENSTATS_COUNT5(
  	    val64);
  
  	status = __hal_vpath_xmac_tx_stats_get(vpath, &hw_stats->tx_stats);
  	if (status != VXGE_HAL_OK) {
  		vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	status = __hal_vpath_xmac_rx_stats_get(vpath, &hw_stats->rx_stats);
  	if (status != VXGE_HAL_OK) {
  		vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  		    __FILE__, __func__, __LINE__, status);
  		return (status);
  	}
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_PROG_EVENT_VNUM0_OFFSET);
  
  	hw_stats->prog_event_vnum0 =
  	    (u32) VXGE_HAL_STATS_GET_VPATH_PROG_EVENT_VNUM0(val64);
  
  	hw_stats->prog_event_vnum1 =
  	    (u32) VXGE_HAL_STATS_GET_VPATH_PROG_EVENT_VNUM1(val64);
  
  	VXGE_HAL_VPATH_STATS_PIO_READ(
  	    VXGE_HAL_STATS_VPATH_PROG_EVENT_VNUM2_OFFSET);
  
  	hw_stats->prog_event_vnum2 =
  	    (u32) VXGE_HAL_STATS_GET_VPATH_PROG_EVENT_VNUM2(val64);
  
  	hw_stats->prog_event_vnum3 =
  	    (u32) VXGE_HAL_STATS_GET_VPATH_PROG_EVENT_VNUM3(val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rx_multi_cast_stats);
  
  	hw_stats->rx_multi_cast_frame_discard =
  	    (u16) VXGE_HAL_RX_MULTI_CAST_STATS_GET_FRAME_DISCARD(val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rx_frm_transferred);
  
  	hw_stats->rx_frm_transferred =
  	    (u32) VXGE_HAL_RX_FRM_TRANSFERRED_GET_RX_FRM_TRANSFERRED(val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->rxd_returned);
  
  	hw_stats->rxd_returned =
  	    (u16) VXGE_HAL_RXD_RETURNED_GET_RXD_RETURNED(val64);
  
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->dbg_stats_rx_mpa);
  
  	hw_stats->rx_mpa_len_fail_frms =
  	    (u16) VXGE_HAL_DBG_STATS_GET_RX_MPA_LEN_FAIL_FRMS(val64);
  	hw_stats->rx_mpa_mrk_fail_frms =
  	    (u16) VXGE_HAL_DBG_STATS_GET_RX_MPA_MRK_FAIL_FRMS(val64);
  	hw_stats->rx_mpa_crc_fail_frms =
  	    (u16) VXGE_HAL_DBG_STATS_GET_RX_MPA_CRC_FAIL_FRMS(val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->dbg_stats_rx_fau);
  
  	hw_stats->rx_permitted_frms =
  	    (u16) VXGE_HAL_DBG_STATS_GET_RX_FAU_RX_PERMITTED_FRMS(val64);
  	hw_stats->rx_vp_reset_discarded_frms = (u16)
  	    VXGE_HAL_DBG_STATS_GET_RX_FAU_RX_VP_RESET_DISCARDED_FRMS(val64);
  	hw_stats->rx_wol_frms =
  	    (u16) VXGE_HAL_DBG_STATS_GET_RX_FAU_RX_WOL_FRMS(val64);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vpath->vp_reg->tx_vp_reset_discarded_frms);
  
  	hw_stats->tx_vp_reset_discarded_frms = (u16)
  	    VXGE_HAL_TX_VP_RESET_DISCARDED_FRMS_GET_TX_VP_RESET_DISCARDED_FRMS(
  	    val64);
  
  	vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  /*
   * vxge_hal_vpath_stats_clear - Clear all the statistics of vpath
   * @vpath_handle: Virtual path handle.
   *
   * Clear the statistics of the given vpath.
   *
   */
  vxge_hal_status_e
  vxge_hal_vpath_stats_clear(vxge_hal_vpath_h vpath_handle)
  {
  	u64 stat;
  	vxge_hal_status_e status;
  	__hal_device_t *hldev;
  	__hal_vpath_handle_t *vp = (__hal_vpath_handle_t *) vpath_handle;
  
  	vxge_assert(vp != NULL);
  
  	hldev = vp->vpath->hldev;
  
  	vxge_hal_trace_log_stats("==> %s:%s:%d",
  	    __FILE__, __func__, __LINE__);
  
  	vxge_hal_trace_log_stats("vpath = 0x"VXGE_OS_STXFMT,
  	    (ptr_t) vpath_handle);
  
  	vxge_os_memcpy(vp->vpath->hw_stats_sav,
  	    vp->vpath->hw_stats,
  	    sizeof(vxge_hal_vpath_stats_hw_info_t));
  
  	vxge_os_memzero(vp->vpath->hw_stats,
  	    sizeof(vxge_hal_vpath_stats_hw_info_t));
  
  	vxge_os_memzero(vp->vpath->sw_stats,
  	    sizeof(vxge_hal_vpath_stats_sw_info_t));
  
  	status = vxge_hal_vpath_stats_access(
  	    vpath_handle,
  	    VXGE_HAL_STATS_OP_CLEAR_ALL_VPATH_STATS,
  	    0,
  	    &stat);
  
  	vxge_hal_trace_log_stats("<== %s:%s:%d  Result: %d",
  	    __FILE__, __func__, __LINE__, status);
  
  	return (status);
  }
  
  
  /*
   * vxge_hal_set_fw_api - Setup FW api
   * @devh: Device Handle.
   *
   */
  vxge_hal_status_e
  vxge_hal_set_fw_api(vxge_hal_device_h devh,
      u64 vp_id, u32 action, u32 offset,
      u64 data0, u64 data1)
  {
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	u64 val64;
  	u32 fw_memo = VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO;
  
  	vxge_hal_vpath_reg_t *vp_reg;
  
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  	vxge_assert(hldev != NULL);
  
  	/* Assumption: Privileged vpath is zero */
  	vp_reg = hldev->vpath_reg[vp_id];
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0, data0,
  	    &vp_reg->rts_access_steer_data0);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0, data1,
  	    &vp_reg->rts_access_steer_data1);
  
  	vxge_os_wmb();
  
  	val64 = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION(action) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(fw_memo) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_OFFSET(offset) |
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE;
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0, val64,
  	    &vp_reg->rts_access_steer_ctrl);
  
  	vxge_os_wmb();
  
  	status =
  	    vxge_hal_device_register_poll(
  	    hldev->header.pdev, hldev->header.regh0,
  	    &vp_reg->rts_access_steer_ctrl, 0,
  	    VXGE_HAL_RTS_ACCESS_STEER_CTRL_STROBE,
  	    WAIT_FACTOR * hldev->header.config.device_poll_millis);
  
  	if (status != VXGE_HAL_OK)
  		return (VXGE_HAL_FAIL);
  
  	val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp_reg->rts_access_steer_ctrl);
  
  	if (val64 & VXGE_HAL_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS)
  		status = VXGE_HAL_OK;
  	else
  		status = VXGE_HAL_FAIL;
  
  	return (status);
  }
  
  /*
   * vxge_hal_get_active_config - Get active configuration
   * @devh: Device Handle.
   *
   */
  vxge_hal_status_e
  vxge_hal_get_active_config(vxge_hal_device_h devh,
      vxge_hal_xmac_nwif_actconfig req_config,
      u64 *cur_config)
  {
  	u32 action;
  	u64 data0 = 0x0, data1 = 0x0;
  	u32 cmd = VXGE_HAL_XMAC_NWIF_Cmd_Get_Active_Config;
  
  	vxge_hal_vpath_reg_t *vp_reg;
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	vxge_assert(hldev != NULL);
  
  	/* Assumption: Privileged vpath is zero */
  	vp_reg = hldev->vpath_reg[0];
  
  	/* get port mode */
  	data0 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_SET_NWIF_CMD(cmd) | req_config;
  	action = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_PORT_CTRL;
  
  	status = vxge_hal_set_fw_api(devh, 0, action, 0x0, data0, data1);
  	if (status == VXGE_HAL_OK) {
  		*cur_config = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vp_reg->rts_access_steer_data1);
  	}
  
  	return (status);
  }
  
  /*
   * vxge_hal_set_port_mode - Set dual port mode
   * override the default dual port mode
   * @devh: Device Handle.
   *
   */
  vxge_hal_status_e
  vxge_hal_set_port_mode(vxge_hal_device_h devh,
      vxge_hal_xmac_nwif_dp_mode port_mode)
  {
  	u32 action;
  	u64 data0 = 0x0, data1 = 0x0;
  	u32 cmd = VXGE_HAL_XMAC_NWIF_Cmd_SetMode;
  
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	if ((port_mode < VXGE_HAL_DP_NP_MODE_DEFAULT) ||
  	    (port_mode > VXGE_HAL_DP_NP_MODE_DISABLE_PORT_MGMT)) {
  
  		vxge_os_printf("Invalid port mode : %d\n", port_mode);
  		return (VXGE_HAL_ERR_INVALID_DP_MODE);
  	}
  
  	data0 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_SET_NWIF_CMD(cmd);
  	data1 = port_mode;
  	action = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_PORT_CTRL;
  
  	status = vxge_hal_set_fw_api(devh, 0, action, 0x0, data0, data1);
  
  	return (status);
  }
  
  /*
   * vxge_hal_set_port_mode - Set dual port mode
   * change behavior on failure *
   * @devh: Device Handle.
   */
  vxge_hal_status_e
  vxge_hal_set_behavior_on_failure(vxge_hal_device_h devh,
      vxge_hal_xmac_nwif_behavior_on_failure behave_on_failure)
  {
  	u32 action;
  	u64 data0 = 0x0, data1 = 0x0;
  	u32 cmd = VXGE_HAL_XMAC_NWIF_Cmd_CfgSetBehaviourOnFailure;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	if ((behave_on_failure < VXGE_HAL_XMAC_NWIF_OnFailure_NoMove) ||
  	    (behave_on_failure >
  	    VXGE_HAL_XMAC_NWIF_OnFailure_OtherPortBackOnRestore)) {
  		vxge_os_printf("Invalid setting for failure behavior : %d\n",
  		    behave_on_failure);
  
  		return (VXGE_HAL_FAIL);
  	}
  
  	data0 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_SET_NWIF_CMD(cmd);
  	data1 = behave_on_failure;
  	action = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_PORT_CTRL;
  
  	status = vxge_hal_set_fw_api(devh, 0, action, 0x0, data0, data1);
  
  	return (status);
  }
  
  vxge_hal_status_e
  vxge_hal_set_l2switch_mode(vxge_hal_device_h devh,
      enum vxge_hal_xmac_nwif_l2_switch_status l2_switch)
  {
  	u32 action;
  	u64 data0 = 0x0, data1 = 0x0;
  	u32 cmd = VXGE_HAL_XMAC_NWIF_Cmd_CfgDualPort_L2SwitchEnable;
  
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	if ((l2_switch < VXGE_HAL_XMAC_NWIF_L2_SWITCH_DISABLE) ||
  	    (l2_switch > VXGE_HAL_XMAC_NWIF_L2_SWITCH_ENABLE)) {
  		vxge_os_printf("Invalid setting for failure behavior : %d\n",
  		    l2_switch);
  
  		return (VXGE_HAL_ERR_INVALID_L2_SWITCH_STATE);
  	}
  
  	data0 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_SET_NWIF_CMD(cmd);
  	data1 = l2_switch;
  	action = VXGE_HAL_RTS_ACCESS_FW_MEMO_ACTION_PRIV_NWIF;
  
  	status = vxge_hal_set_fw_api(devh, 0, action, 0x0, data0, data1);
  
  	return (status);
  }
  
  /* Get function mode */
  vxge_hal_status_e
  vxge_hal_func_mode_get(vxge_hal_device_h devh, u32 *func_mode)
  {
  	int vp_id;
  	u32 action;
  	u64 val64;
  
  	vxge_hal_status_e status = VXGE_HAL_OK;
  	vxge_hal_vpath_reg_t *vp_reg;
  
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  
  	vxge_assert(hldev != NULL);
  	/* get the first vpath number assigned to this function */
  	vp_id = hldev->first_vp_id;
  
  	vp_reg = hldev->vpath_reg[vp_id];
  	action = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_GET_FUNC_MODE;
  
  	status = vxge_hal_set_fw_api(devh, vp_id, action, 0x0, 0x0, 0x0);
  	if (status == VXGE_HAL_OK) {
  		val64 = vxge_os_pio_mem_read64(
  		    hldev->header.pdev, hldev->header.regh0,
  		    &vp_reg->rts_access_steer_data0);
  
  		*func_mode =
  		    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_FUNC_MODE(val64);
  	}
  
  	return (status);
  }
  
  vxge_hal_status_e
  vxge_hal_func_mode_count(vxge_hal_device_h devh, u32 func_mode, u32 *num_funcs)
  {
  	int vp_id;
  	u32 action;
  	u64 val64, data0;
  
  	vxge_hal_vpath_reg_t *vp_reg;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  
  	vp_id = hldev->first_vp_id;
  	vp_reg = hldev->vpath_reg[0];
  
  	data0 = func_mode;
  	action = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_GET_FUNC_COUNT;
  
  	status = vxge_hal_set_fw_api(devh, vp_id, action, 0x0, data0, 0x0);
  	if (status == VXGE_HAL_OK) {
  
  		val64 = vxge_os_pio_mem_read64(
  		    hldev->header.pdev, hldev->header.regh0,
  		    &vp_reg->rts_access_steer_data0);
  
  		*num_funcs = (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA0_GET_NUM_FUNC(val64);
  	}
  
  	return (status);
  }
  
  vxge_hal_status_e
  vxge_hal_config_vpath_map(vxge_hal_device_h devh, u64 port_map)
  {
  	u32 action;
  	u64 data0 = 0x0, data1 = 0x0;
  	u32 cmd = VXGE_HAL_XMAC_NWIF_Cmd_CfgDualPort_VPathVector;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	action = VXGE_HAL_RTS_ACCESS_FW_MEMO_ACTION_PRIV_NWIF;
  	data0 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_SET_NWIF_CMD(cmd);
  	data1 = port_map;
  
  	status = vxge_hal_set_fw_api(devh, 0, action, 0x0, data0, data1);
  
  	return (status);
  }
  
  vxge_hal_status_e
  vxge_hal_get_vpath_mask(vxge_hal_device_h devh,
      u32 vf_id, u32 * num_vp, u64 * data1)
  {
  	u32 action, vhn = 0;
  	u64 data0 = 0x0;
  
  	vxge_hal_vpath_reg_t *vp_reg;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  	vp_reg = hldev->vpath_reg[0];
  
  	data0 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_VFID(vf_id) |
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_VHN(vhn);
  
  	action = VXGE_HAL_PRIV_VPATH_ACTION;
  	status = vxge_hal_set_fw_api(devh, 0, action, 0x0, data0, 0x0);
  	if (status == VXGE_HAL_OK) {
  
  		data0 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vp_reg->rts_access_steer_data0);
  
  		*num_vp = (u32) ((data0 >> 16) & 0xFF);
  		*data1 = vxge_os_pio_mem_read64(hldev->header.pdev,
  		    hldev->header.regh0,
  		    &vp_reg->rts_access_steer_data1);
  	}
  
  	return (status);
  }
  
  vxge_hal_status_e
  vxge_hal_get_vpath_list(vxge_hal_device_h devh, u32 vf_id,
      u64 *vpath_list, u32 *vpath_count)
  {
  	u32 i, j = 0;
  	u64 pos, vpath_mask;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	*vpath_count = 0;
  
  	status = vxge_hal_get_vpath_mask(devh, vf_id, vpath_count, &vpath_mask);
  	if (status == VXGE_HAL_OK) {
  		for (i = VXGE_HAL_VPATH_BMAP_END;
  		    i >= VXGE_HAL_VPATH_BMAP_START; i--) {
  			if (bVAL1(vpath_mask, i)) {
  				pos = VXGE_HAL_VPATH_BMAP_END - i;
  				vpath_list[j] = pos;
  				j++;
  			}
  		}
  	}
  
  	return (status);
  }
  
  vxge_hal_status_e
  vxge_hal_rx_bw_priority_set(vxge_hal_device_h devh, u64 vp_id)
  {
  	u64 data0 = 0x0, data1 = 0x0;
  	u32 action, bandwidth, priority, set = 0;
  
  	vxge_hal_vpath_reg_t *vp_reg;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  	vp_reg = hldev->vpath_reg[0];
  	action = VXGE_HAL_BW_CONTROL;
  
  	bandwidth =
  	    ((vxge_hal_device_t *) (devh))->config.vp_config[vp_id].bandwidth;
  
  	priority =
  	    ((vxge_hal_device_t *) (devh))->config.vp_config[vp_id].priority;
  
  	/*
  	 * Get bandwidth and priority settings
  	 * and perform read-modify-write operation
  	 */
  	data0 = 1;
  	data0 |= vp_id << 32;
  
  	status = vxge_hal_set_fw_api(devh, 0, action, 0x0, data0, data1);
  	if (status != VXGE_HAL_OK)
  		goto _exit;
  
  	data1 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp_reg->rts_access_steer_data1);
  
  	/* Set */
  	data0 = 0;
  	data0 |= vp_id << 32;
  
  	/* Rx Bandwidth */
  	if (bandwidth != VXGE_HAL_VPATH_BW_LIMIT_DEFAULT) {
  		set = 1;
  		data1 &= ~VXGE_HAL_RTS_ACCESS_STEER_DATA1_SET_RX_MAX_BW(0xff);
  		bandwidth = (bandwidth * 256) / 10000;
  		data1 |=
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA1_SET_RX_MAX_BW(bandwidth);
  		data1 |= VXGE_HAL_RTS_ACCESS_STEER_DATA1_SET_VPATH_OR_FUNC(1);
  	}
  
  	/* Priority */
  	if (priority != VXGE_HAL_VPATH_PRIORITY_DEFAULT) {
  		set = 1;
  		data1 &= ~VXGE_HAL_RTS_ACCESS_STEER_DATA1_SET_RX_PRIORITY(0x7);
  		data1 |=
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA1_SET_RX_PRIORITY(priority);
  	}
  
  	if (set == 1)
  		status = vxge_hal_set_fw_api(devh, 0, action,
  		    0x0, data0, data1);
  
  _exit:
  	return (status);
  }
  
  vxge_hal_status_e
  vxge_hal_tx_bw_priority_set(vxge_hal_device_h devh, u64 vp_id)
  {
  	u64 data0 = 0x0, data1 = 0x0;
  	u32 action, bandwidth, priority, set = 0;
  
  	vxge_hal_vpath_reg_t *vp_reg;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  	vp_reg = hldev->vpath_reg[0];
  	action = VXGE_HAL_BW_CONTROL;
  
  	bandwidth =
  	    ((vxge_hal_device_t *) (devh))->config.vp_config[vp_id].bandwidth;
  
  	priority =
  	    ((vxge_hal_device_t *) (devh))->config.vp_config[vp_id].priority;
  
  	/*
  	 * Get bandwidth and priority settings and
  	 * perform a read-modify-write operation
  	 */
  	data0 = 1;
  	data0 |= vp_id << 32;
  
  	status = vxge_hal_set_fw_api(devh, 0, action, 0x0, data0, data1);
  	if (status != VXGE_HAL_OK)
  		goto _exit;
  
  	data1 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp_reg->rts_access_steer_data1);
  
  	/* Set */
  	data0 = 0;
  	data0 |= vp_id << 32;
  
  	/* Tx Bandwidth */
  	if (bandwidth != VXGE_HAL_VPATH_BW_LIMIT_DEFAULT) {
  		set = 1;
  		data1 &= ~VXGE_HAL_RTS_ACCESS_STEER_DATA1_SET_TX_MAX_BW(0xff);
  		bandwidth = (bandwidth * 256) / 10000;
  		data1 |=
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA1_SET_TX_MAX_BW(bandwidth);
  	}
  
  	/* Priority */
  	if (priority != VXGE_HAL_VPATH_PRIORITY_DEFAULT) {
  		set = 1;
  		data1 &= ~VXGE_HAL_RTS_ACCESS_STEER_DATA1_SET_TX_PRIORITY(0x7);
  		data1 |=
  		    VXGE_HAL_RTS_ACCESS_STEER_DATA1_SET_TX_PRIORITY(priority);
  	}
  
  	if (set == 1)
  		status = vxge_hal_set_fw_api(devh, 0, action,
  		    0x0, data0, data1);
  
  _exit:
  	return (status);
  }
  
  vxge_hal_status_e
  vxge_hal_bw_priority_get(vxge_hal_device_h devh, u64 vp_id,
      u32 *bandwidth, u32 *priority)
  {
  	u32 action;
  	u64 data0 = 0x0, data1 = 0x0;
  
  	vxge_hal_vpath_reg_t *vp_reg;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  	vp_reg = hldev->vpath_reg[0];
  	action = VXGE_HAL_BW_CONTROL;
  
  	/* Get rx bandwidth and rx priority settings */
  	data0 = 1;
  	data0 |= vp_id << 32;
  
  	status = vxge_hal_set_fw_api(devh, 0, action, 0x0, data0, data1);
  	if (status != VXGE_HAL_OK)
  		return (status);
  
  	data1 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp_reg->rts_access_steer_data1);
  
  	*priority = (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA1_GET_RX_PRIORITY(data1);
  
  	/*
  	 * Bandwidth setting is stored in increments of approx. 39 Mb/s
  	 * so revert it back to get the b/w value
  	 */
  	*bandwidth = (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA1_GET_RX_MAX_BW(data1);
  	*bandwidth = ((*bandwidth) * 10000) / 256;
  
  	return (status);
  }
  
  vxge_hal_status_e
  vxge_hal_vf_rx_bw_get(vxge_hal_device_h devh, u64 func_id,
      u32 *bandwidth, u32 *priority)
  {
  	u32 action;
  	u64 data0 = 0x0, data1 = 0x0;
  	__hal_device_t *hldev = (__hal_device_t *) devh;
  
  	vxge_hal_vpath_reg_t *vp_reg;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	vp_reg = hldev->vpath_reg[func_id];
  	action = VXGE_HAL_RTS_ACCESS_FW_MEMO_ACTION_NON_PRIV_BANDWIDTH_CTRL;
  
  	/* Get rx bandwidth and rx priority settings */
  	data0 = 3;
  	data0 |= func_id << 32;
  
  	status = vxge_hal_set_fw_api(devh, func_id, action, 0x0, data0, data1);
  	if (status != VXGE_HAL_OK)
  		return (status);
  
  	data1 = vxge_os_pio_mem_read64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    &vp_reg->rts_access_steer_data1);
  
  	*priority =
  	    (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA1_GET_RX_PRIORITY(data1);
  
  	/*
  	 * Bandwidth setting is stored in increments of approx. 39 Mb/s
  	 * so revert it back to get the b/w value
  	 */
  	*bandwidth = (u32) VXGE_HAL_RTS_ACCESS_STEER_DATA1_GET_RX_MAX_BW(data1);
  	*bandwidth = ((*bandwidth) * 10000) / 256;
  
  	return (status);
  }
  
  void
  vxge_hal_vpath_dynamic_tti_rtimer_set(vxge_hal_vpath_h vpath_handle,
      u32 timer_val)
  {
  	u64 val64, timer;
  
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  	hldev = vpath->hldev;
  
  	val64 = vpath->tim_tti_cfg3_saved;
  	timer = (timer_val * 1000) / 272;
  
  	val64 &= ~VXGE_HAL_TIM_CFG3_INT_NUM_RTIMER_VAL(0x3ffffff);
  	if (timer)
  		val64 |= VXGE_HAL_TIM_CFG3_INT_NUM_RTIMER_VAL(timer) |
  		    VXGE_HAL_TIM_CFG3_INT_NUM_RTIMER_EVENT_SF(5);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->tim_cfg3_int_num[VXGE_HAL_VPATH_INTR_TX]);
  
  	/*
  	 * tti_cfg3_saved is not updated again because it is
  	 * initialized at one place only - init time.
  	 */
  }
  
  void
  vxge_hal_vpath_dynamic_rti_rtimer_set(vxge_hal_vpath_h vpath_handle,
      u32 timer_val)
  {
  	u64 val64, timer;
  
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  	hldev = vpath->hldev;
  
  	val64 = vpath->tim_rti_cfg3_saved;
  	timer = (timer_val * 1000) / 272;
  
  	val64 &= ~VXGE_HAL_TIM_CFG3_INT_NUM_RTIMER_VAL(0x3ffffff);
  	if (timer)
  		val64 |= VXGE_HAL_TIM_CFG3_INT_NUM_RTIMER_VAL(timer) |
  		    VXGE_HAL_TIM_CFG3_INT_NUM_RTIMER_EVENT_SF(4);
  
  	vxge_os_pio_mem_write64(hldev->header.pdev,
  	    hldev->header.regh0,
  	    val64,
  	    &vpath->vp_reg->tim_cfg3_int_num[VXGE_HAL_VPATH_INTR_RX]);
  
  	/*
  	 * rti_cfg3_saved is not updated again because it is
  	 * initialized at one place only - init time.
  	 */
  }
  
  void
  vxge_hal_vpath_tti_ci_set(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  	hldev = vpath->hldev;
  
  	if (vpath->vp_config->fifo.enable == VXGE_HAL_FIFO_ENABLE) {
  		if (vpath->vp_config->tti.timer_ci_en != VXGE_HAL_TIM_TIMER_CI_ENABLE) {
  			vpath->vp_config->tti.timer_ci_en = VXGE_HAL_TIM_TIMER_CI_ENABLE;
  
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &vpath->vp_reg->tim_cfg1_int_num[VXGE_HAL_VPATH_INTR_TX]);
  
  			val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_TIMER_CI;
  			vpath->tim_rti_cfg1_saved = val64;
  
  			vxge_os_pio_mem_write64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    val64,
  			    &vpath->vp_reg->tim_cfg1_int_num[VXGE_HAL_VPATH_INTR_TX]);
  		}
  	}
  }
  
  void
  vxge_hal_vpath_tti_ci_reset(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  	hldev = vpath->hldev;
  
  	if (vpath->vp_config->fifo.enable == VXGE_HAL_FIFO_ENABLE) {
  		if (vpath->vp_config->tti.timer_ci_en != VXGE_HAL_TIM_TIMER_CI_DISABLE) {
  			vpath->vp_config->tti.timer_ci_en = VXGE_HAL_TIM_TIMER_CI_DISABLE;
  
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &vpath->vp_reg->tim_cfg1_int_num[VXGE_HAL_VPATH_INTR_TX]);
  
  			val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_TIMER_CI;
  			vpath->tim_rti_cfg1_saved = val64;
  
  			vxge_os_pio_mem_write64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    val64,
  			    &vpath->vp_reg->tim_cfg1_int_num[VXGE_HAL_VPATH_INTR_TX]);
  		}
  	}
  }
  
  void
  vxge_hal_vpath_rti_ci_set(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  	hldev = vpath->hldev;
  
  	if (vpath->vp_config->ring.enable == VXGE_HAL_RING_ENABLE) {
  		if (vpath->vp_config->rti.timer_ci_en != VXGE_HAL_TIM_TIMER_CI_ENABLE) {
  			vpath->vp_config->rti.timer_ci_en = VXGE_HAL_TIM_TIMER_CI_ENABLE;
  
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &vpath->vp_reg->tim_cfg1_int_num[VXGE_HAL_VPATH_INTR_RX]);
  
  			val64 |= VXGE_HAL_TIM_CFG1_INT_NUM_TIMER_CI;
  			vpath->tim_rti_cfg1_saved = val64;
  
  			vxge_os_pio_mem_write64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    val64,
  			    &vpath->vp_reg->tim_cfg1_int_num[VXGE_HAL_VPATH_INTR_RX]);
  		}
  	}
  }
  
  void
  vxge_hal_vpath_rti_ci_reset(vxge_hal_vpath_h vpath_handle)
  {
  	u64 val64;
  
  	__hal_device_t *hldev;
  	__hal_virtualpath_t *vpath;
  
  	vpath = ((__hal_vpath_handle_t *) vpath_handle)->vpath;
  	hldev = vpath->hldev;
  
  	if (vpath->vp_config->ring.enable == VXGE_HAL_RING_ENABLE) {
  		if (vpath->vp_config->rti.timer_ci_en != VXGE_HAL_TIM_TIMER_CI_DISABLE) {
  			vpath->vp_config->rti.timer_ci_en = VXGE_HAL_TIM_TIMER_CI_DISABLE;
  
  			val64 = vxge_os_pio_mem_read64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    &vpath->vp_reg->tim_cfg1_int_num[VXGE_HAL_VPATH_INTR_RX]);
  
  			val64 &= ~VXGE_HAL_TIM_CFG1_INT_NUM_TIMER_CI;
  			vpath->tim_rti_cfg1_saved = val64;
  
  			vxge_os_pio_mem_write64(hldev->header.pdev,
  			    hldev->header.regh0,
  			    val64,
  			    &vpath->vp_reg->tim_cfg1_int_num[VXGE_HAL_VPATH_INTR_RX]);
  		}
  	}
  }
  
  vxge_hal_status_e
  vxge_hal_send_message(vxge_hal_device_h devh, u64 vp_id, u8 msg_type,
      u8 msg_dst, u32 msg_data, u64 *msg_sent_to_vpaths)
  {
  	u32 action;
  	u64 data0 = 0x0, data1 = 0x0;
  	u32 attempts = VXGE_HAL_MSG_SEND_RETRY;
  	vxge_hal_status_e status = VXGE_HAL_OK;
  
  	data0 = VXGE_HAL_RTS_ACCESS_STEER_DATA0_SEND_MSG_TYPE(msg_type) |
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_SEND_MSG_DEST(msg_dst) |
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_SEND_MSG_SRC(vp_id) |
  	    VXGE_HAL_RTS_ACCESS_STEER_DATA0_SEND_MSG_DATA(msg_data);
  
  	action = VXGE_HAL_RTS_ACCESS_STEER_CTRL_ACTION_SEND_MSG;
  
  	do {
  		status = vxge_hal_set_fw_api(devh, vp_id, action, 0x0,
  		    data0, data1);
  		if (status != VXGE_HAL_OK) {
  			attempts--;
  			if (attempts == 0)
  			return (status);
  		}
  	} while (status != VXGE_HAL_OK);
  
  	if (msg_sent_to_vpaths != NULL) {
  		/* The API returns a vector of VPATHs the message
  		* was sent to in the event the destination is a
  		* broadcast message or being sent to the privileged VPATH
  		*/
  		*msg_sent_to_vpaths = data0 & VXGE_HAL_MSG_SEND_TO_VPATH_MASK;
  	}
  
  	return (status);
  }
  