Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

9 files changed, 3611 insertions, 3409 deletions

diff --git a/drivers/net/vxge/vxge-config.c b/drivers/net/vxge/vxge-config.c
index 0e6db5935609..32763b2dd73f 100644
--- a/drivers/net/vxge/vxge-config.c
+++ b/drivers/net/vxge/vxge-config.c
@@ -19,76 +19,386 @@
 
 #include "vxge-traffic.h"
 #include "vxge-config.h"
+#include "vxge-main.h"
+
+#define VXGE_HW_VPATH_STATS_PIO_READ(offset) {                          \
+        status = __vxge_hw_vpath_stats_access(vpath,                    \
+                                              VXGE_HW_STATS_OP_READ,    \
+                                              offset,                   \
+                                              &val64);                  \
+        if (status != VXGE_HW_OK)                                       \
+                return status;                                          \
+}
+
+static void
+vxge_hw_vpath_set_zero_rx_frm_len(struct vxge_hw_vpath_reg __iomem *vp_reg)
+{
+        u64 val64;
+
+        val64 = readq(&vp_reg->rxmac_vcfg0);
+        val64 &= ~VXGE_HW_RXMAC_VCFG0_RTS_MAX_FRM_LEN(0x3fff);
+        writeq(val64, &vp_reg->rxmac_vcfg0);
+        val64 = readq(&vp_reg->rxmac_vcfg0);
+}
 
 /*
- * __vxge_hw_channel_allocate - Allocate memory for channel
- * This function allocates required memory for the channel and various arrays
- * in the channel
+ * vxge_hw_vpath_wait_receive_idle - Wait for Rx to become idle
  */
-struct __vxge_hw_channel*
-__vxge_hw_channel_allocate(struct __vxge_hw_vpath_handle *vph,
-                           enum __vxge_hw_channel_type type,
-        u32 length, u32 per_dtr_space, void *userdata)
+int vxge_hw_vpath_wait_receive_idle(struct __vxge_hw_device *hldev, u32 vp_id)
 {
-        struct __vxge_hw_channel *channel;
-        struct __vxge_hw_device *hldev;
-        int size = 0;
-        u32 vp_id;
+        struct vxge_hw_vpath_reg __iomem *vp_reg;
+        struct __vxge_hw_virtualpath *vpath;
+        u64 val64, rxd_count, rxd_spat;
+        int count = 0, total_count = 0;
 
-        hldev = vph->vpath->hldev;
-        vp_id = vph->vpath->vp_id;
+        vpath = &hldev->virtual_paths[vp_id];
+        vp_reg = vpath->vp_reg;
 
-        switch (type) {
-        case VXGE_HW_CHANNEL_TYPE_FIFO:
-                size = sizeof(struct __vxge_hw_fifo);
-                break;
-        case VXGE_HW_CHANNEL_TYPE_RING:
-                size = sizeof(struct __vxge_hw_ring);
-                break;
-        default:
-                break;
+        vxge_hw_vpath_set_zero_rx_frm_len(vp_reg);
+
+        /* Check that the ring controller for this vpath has enough free RxDs
+         * to send frames to the host.  This is done by reading the
+         * PRC_RXD_DOORBELL_VPn register and comparing the read value to the
+         * RXD_SPAT value for the vpath.
+         */
+        val64 = readq(&vp_reg->prc_cfg6);
+        rxd_spat = VXGE_HW_PRC_CFG6_GET_RXD_SPAT(val64) + 1;
+        /* Use a factor of 2 when comparing rxd_count against rxd_spat for some
+         * leg room.
+         */
+        rxd_spat *= 2;
+
+        do {
+                mdelay(1);
+
+                rxd_count = readq(&vp_reg->prc_rxd_doorbell);
+
+                /* Check that the ring controller for this vpath does
+                 * not have any frame in its pipeline.
+                 */
+                val64 = readq(&vp_reg->frm_in_progress_cnt);
+                if ((rxd_count <= rxd_spat) || (val64 > 0))
+                        count = 0;
+                else
+                        count++;
+                total_count++;
+        } while ((count < VXGE_HW_MIN_SUCCESSIVE_IDLE_COUNT) &&
+                        (total_count < VXGE_HW_MAX_POLLING_COUNT));
+
+        if (total_count >= VXGE_HW_MAX_POLLING_COUNT)
+                printk(KERN_ALERT "%s: Still Receiving traffic. Abort wait\n",
+                        __func__);
+
+        return total_count;
+}
+
+/* vxge_hw_device_wait_receive_idle - This function waits until all frames
+ * stored in the frame buffer for each vpath assigned to the given
+ * function (hldev) have been sent to the host.
+ */
+void vxge_hw_device_wait_receive_idle(struct __vxge_hw_device *hldev)
+{
+        int i, total_count = 0;
+
+        for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
+                if (!(hldev->vpaths_deployed & vxge_mBIT(i)))
+                        continue;
+
+                total_count += vxge_hw_vpath_wait_receive_idle(hldev, i);
+                if (total_count >= VXGE_HW_MAX_POLLING_COUNT)
+                        break;
         }
+}
 
-        channel = kzalloc(size, GFP_KERNEL);
-        if (channel == NULL)
-                goto exit0;
-        INIT_LIST_HEAD(&channel->item);
+/*
+ * __vxge_hw_device_register_poll
+ * Will poll certain register for specified amount of time.
+ * Will poll until masked bit is not cleared.
+ */
+static enum vxge_hw_status
+__vxge_hw_device_register_poll(void __iomem *reg, u64 mask, u32 max_millis)
+{
+        u64 val64;
+        u32 i = 0;
+        enum vxge_hw_status ret = VXGE_HW_FAIL;
 
-        channel->common_reg = hldev->common_reg;
-        channel->first_vp_id = hldev->first_vp_id;
-        channel->type = type;
-        channel->devh = hldev;
-        channel->vph = vph;
-        channel->userdata = userdata;
-        channel->per_dtr_space = per_dtr_space;
-        channel->length = length;
-        channel->vp_id = vp_id;
+        udelay(10);
 
-        channel->work_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL);
-        if (channel->work_arr == NULL)
-                goto exit1;
+        do {
+                val64 = readq(reg);
+                if (!(val64 & mask))
+                        return VXGE_HW_OK;
+                udelay(100);
+        } while (++i <= 9);
 
-        channel->free_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL);
-        if (channel->free_arr == NULL)
-                goto exit1;
-        channel->free_ptr = length;
+        i = 0;
+        do {
+                val64 = readq(reg);
+                if (!(val64 & mask))
+                        return VXGE_HW_OK;
+                mdelay(1);
+        } while (++i <= max_millis);
 
-        channel->reserve_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL);
-        if (channel->reserve_arr == NULL)
-                goto exit1;
-        channel->reserve_ptr = length;
-        channel->reserve_top = 0;
+        return ret;
+}
 
-        channel->orig_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL);
-        if (channel->orig_arr == NULL)
-                goto exit1;
+static inline enum vxge_hw_status
+__vxge_hw_pio_mem_write64(u64 val64, void __iomem *addr,
+                          u64 mask, u32 max_millis)
+{
+        __vxge_hw_pio_mem_write32_lower((u32)vxge_bVALn(val64, 32, 32), addr);
+        wmb();
+        __vxge_hw_pio_mem_write32_upper((u32)vxge_bVALn(val64, 0, 32), addr);
+        wmb();
 
-        return channel;
-exit1:
-        __vxge_hw_channel_free(channel);
+        return __vxge_hw_device_register_poll(addr, mask, max_millis);
+}
 
-exit0:
-        return NULL;
+static enum vxge_hw_status
+vxge_hw_vpath_fw_api(struct __vxge_hw_virtualpath *vpath, u32 action,
+                     u32 fw_memo, u32 offset, u64 *data0, u64 *data1,
+                     u64 *steer_ctrl)
+{
+        struct vxge_hw_vpath_reg __iomem *vp_reg = vpath->vp_reg;
+        enum vxge_hw_status status;
+        u64 val64;
+        u32 retry = 0, max_retry = 3;
+
+        spin_lock(&vpath->lock);
+        if (!vpath->vp_open) {
+                spin_unlock(&vpath->lock);
+                max_retry = 100;
+        }
+
+        writeq(*data0, &vp_reg->rts_access_steer_data0);
+        writeq(*data1, &vp_reg->rts_access_steer_data1);
+        wmb();
+
+        val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(action) |
+                VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(fw_memo) |
+                VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(offset) |
+                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
+                *steer_ctrl;
+
+        status = __vxge_hw_pio_mem_write64(val64,
+                                           &vp_reg->rts_access_steer_ctrl,
+                                           VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
+                                           VXGE_HW_DEF_DEVICE_POLL_MILLIS);
+
+        /* The __vxge_hw_device_register_poll can udelay for a significant
+         * amount of time, blocking other process from the CPU.  If it delays
+         * for ~5secs, a NMI error can occur.  A way around this is to give up
+         * the processor via msleep, but this is not allowed is under lock.
+         * So, only allow it to sleep for ~4secs if open.  Otherwise, delay for
+         * 1sec and sleep for 10ms until the firmware operation has completed
+         * or timed-out.
+         */
+        while ((status != VXGE_HW_OK) && retry++ < max_retry) {
+                if (!vpath->vp_open)
+                        msleep(20);
+                status = __vxge_hw_device_register_poll(
+                                        &vp_reg->rts_access_steer_ctrl,
+                                        VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
+                                        VXGE_HW_DEF_DEVICE_POLL_MILLIS);
+        }
+
+        if (status != VXGE_HW_OK)
+                goto out;
+
+        val64 = readq(&vp_reg->rts_access_steer_ctrl);
+        if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
+                *data0 = readq(&vp_reg->rts_access_steer_data0);
+                *data1 = readq(&vp_reg->rts_access_steer_data1);
+                *steer_ctrl = val64;
+        } else
+                status = VXGE_HW_FAIL;
+
+out:
+        if (vpath->vp_open)
+                spin_unlock(&vpath->lock);
+        return status;
+}
+
+enum vxge_hw_status
+vxge_hw_upgrade_read_version(struct __vxge_hw_device *hldev, u32 *major,
+                             u32 *minor, u32 *build)
+{
+        u64 data0 = 0, data1 = 0, steer_ctrl = 0;
+        struct __vxge_hw_virtualpath *vpath;
+        enum vxge_hw_status status;
+
+        vpath = &hldev->virtual_paths[hldev->first_vp_id];
+
+        status = vxge_hw_vpath_fw_api(vpath,
+                                      VXGE_HW_FW_UPGRADE_ACTION,
+                                      VXGE_HW_FW_UPGRADE_MEMO,
+                                      VXGE_HW_FW_UPGRADE_OFFSET_READ,
+                                      &data0, &data1, &steer_ctrl);
+        if (status != VXGE_HW_OK)
+                return status;
+
+        *major = VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MAJOR(data0);
+        *minor = VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MINOR(data0);
+        *build = VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_BUILD(data0);
+
+        return status;
+}
+
+enum vxge_hw_status vxge_hw_flash_fw(struct __vxge_hw_device *hldev)
+{
+        u64 data0 = 0, data1 = 0, steer_ctrl = 0;
+        struct __vxge_hw_virtualpath *vpath;
+        enum vxge_hw_status status;
+        u32 ret;
+
+        vpath = &hldev->virtual_paths[hldev->first_vp_id];
+
+        status = vxge_hw_vpath_fw_api(vpath,
+                                      VXGE_HW_FW_UPGRADE_ACTION,
+                                      VXGE_HW_FW_UPGRADE_MEMO,
+                                      VXGE_HW_FW_UPGRADE_OFFSET_COMMIT,
+                                      &data0, &data1, &steer_ctrl);
+        if (status != VXGE_HW_OK) {
+                vxge_debug_init(VXGE_ERR, "%s: FW upgrade failed", __func__);
+                goto exit;
+        }
+
+        ret = VXGE_HW_RTS_ACCESS_STEER_CTRL_GET_ACTION(steer_ctrl) & 0x7F;
+        if (ret != 1) {
+                vxge_debug_init(VXGE_ERR, "%s: FW commit failed with error %d",
+                                __func__, ret);
+                status = VXGE_HW_FAIL;
+        }
+
+exit:
+        return status;
+}
+
+enum vxge_hw_status
+vxge_update_fw_image(struct __vxge_hw_device *hldev, const u8 *fwdata, int size)
+{
+        u64 data0 = 0, data1 = 0, steer_ctrl = 0;
+        struct __vxge_hw_virtualpath *vpath;
+        enum vxge_hw_status status;
+        int ret_code, sec_code;
+
+        vpath = &hldev->virtual_paths[hldev->first_vp_id];
+
+        /* send upgrade start command */
+        status = vxge_hw_vpath_fw_api(vpath,
+                                      VXGE_HW_FW_UPGRADE_ACTION,
+                                      VXGE_HW_FW_UPGRADE_MEMO,
+                                      VXGE_HW_FW_UPGRADE_OFFSET_START,
+                                      &data0, &data1, &steer_ctrl);
+        if (status != VXGE_HW_OK) {
+                vxge_debug_init(VXGE_ERR, " %s: Upgrade start cmd failed",
+                                __func__);
+                return status;
+        }
+
+        /* Transfer fw image to adapter 16 bytes at a time */
+        for (; size > 0; size -= VXGE_HW_FW_UPGRADE_BLK_SIZE) {
+                steer_ctrl = 0;
+
+                /* The next 128bits of fwdata to be loaded onto the adapter */
+                data0 = *((u64 *)fwdata);
+                data1 = *((u64 *)fwdata + 1);
+
+                status = vxge_hw_vpath_fw_api(vpath,
+                                              VXGE_HW_FW_UPGRADE_ACTION,
+                                              VXGE_HW_FW_UPGRADE_MEMO,
+                                              VXGE_HW_FW_UPGRADE_OFFSET_SEND,
+                                              &data0, &data1, &steer_ctrl);
+                if (status != VXGE_HW_OK) {
+                        vxge_debug_init(VXGE_ERR, "%s: Upgrade send failed",
+                                        __func__);
+                        goto out;
+                }
+
+                ret_code = VXGE_HW_UPGRADE_GET_RET_ERR_CODE(data0);
+                switch (ret_code) {
+                case VXGE_HW_FW_UPGRADE_OK:
+                        /* All OK, send next 16 bytes. */
+                        break;
+                case VXGE_FW_UPGRADE_BYTES2SKIP:
+                        /* skip bytes in the stream */
+                        fwdata += (data0 >> 8) & 0xFFFFFFFF;
+                        break;
+                case VXGE_HW_FW_UPGRADE_DONE:
+                        goto out;
+                case VXGE_HW_FW_UPGRADE_ERR:
+                        sec_code = VXGE_HW_UPGRADE_GET_SEC_ERR_CODE(data0);
+                        switch (sec_code) {
+                        case VXGE_HW_FW_UPGRADE_ERR_CORRUPT_DATA_1:
+                        case VXGE_HW_FW_UPGRADE_ERR_CORRUPT_DATA_7:
+                                printk(KERN_ERR
+                                       "corrupted data from .ncf file\n");
+                                break;
+                        case VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_3:
+                        case VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_4:
+                        case VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_5:
+                        case VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_6:
+                        case VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_8:
+                                printk(KERN_ERR "invalid .ncf file\n");
+                                break;
+                        case VXGE_HW_FW_UPGRADE_ERR_BUFFER_OVERFLOW:
+                                printk(KERN_ERR "buffer overflow\n");
+                                break;
+                        case VXGE_HW_FW_UPGRADE_ERR_FAILED_TO_FLASH:
+                                printk(KERN_ERR "failed to flash the image\n");
+                                break;
+                        case VXGE_HW_FW_UPGRADE_ERR_GENERIC_ERROR_UNKNOWN:
+                                printk(KERN_ERR
+                                       "generic error. Unknown error type\n");
+                                break;
+                        default:
+                                printk(KERN_ERR "Unknown error of type %d\n",
+                                       sec_code);
+                                break;
+                        }
+                        status = VXGE_HW_FAIL;
+                        goto out;
+                default:
+                        printk(KERN_ERR "Unknown FW error: %d\n", ret_code);
+                        status = VXGE_HW_FAIL;
+                        goto out;
+                }
+                /* point to next 16 bytes */
+                fwdata += VXGE_HW_FW_UPGRADE_BLK_SIZE;
+        }
+out:
+        return status;
+}
+
+enum vxge_hw_status
+vxge_hw_vpath_eprom_img_ver_get(struct __vxge_hw_device *hldev,
+                                struct eprom_image *img)
+{
+        u64 data0 = 0, data1 = 0, steer_ctrl = 0;
+        struct __vxge_hw_virtualpath *vpath;
+        enum vxge_hw_status status;
+        int i;
+
+        vpath = &hldev->virtual_paths[hldev->first_vp_id];
+
+        for (i = 0; i < VXGE_HW_MAX_ROM_IMAGES; i++) {
+                data0 = VXGE_HW_RTS_ACCESS_STEER_ROM_IMAGE_INDEX(i);
+                data1 = steer_ctrl = 0;
+
+                status = vxge_hw_vpath_fw_api(vpath,
+                        VXGE_HW_FW_API_GET_EPROM_REV,
+                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO,
+                        0, &data0, &data1, &steer_ctrl);
+                if (status != VXGE_HW_OK)
+                        break;
+
+                img[i].is_valid = VXGE_HW_GET_EPROM_IMAGE_VALID(data0);
+                img[i].index = VXGE_HW_GET_EPROM_IMAGE_INDEX(data0);
+                img[i].type = VXGE_HW_GET_EPROM_IMAGE_TYPE(data0);
+                img[i].version = VXGE_HW_GET_EPROM_IMAGE_REV(data0);
+        }
+
+        return status;
 }
 
 /*
@@ -96,7 +406,7 @@ exit0:
  * This function deallocates memory from the channel and various arrays
  * in the channel
  */
-void __vxge_hw_channel_free(struct __vxge_hw_channel *channel)
+static void __vxge_hw_channel_free(struct __vxge_hw_channel *channel)
 {
         kfree(channel->work_arr);
         kfree(channel->free_arr);
@@ -110,7 +420,7 @@ void __vxge_hw_channel_free(struct __vxge_hw_channel *channel)
  * This function initializes a channel by properly setting the
  * various references
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_channel_initialize(struct __vxge_hw_channel *channel)
 {
         u32 i;
@@ -145,7 +455,7 @@ __vxge_hw_channel_initialize(struct __vxge_hw_channel *channel)
  * __vxge_hw_channel_reset - Resets a channel
  * This function resets a channel by properly setting the various references
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_channel_reset(struct __vxge_hw_channel *channel)
 {
         u32 i;
@@ -172,8 +482,7 @@ __vxge_hw_channel_reset(struct __vxge_hw_channel *channel)
  * Initialize certain PCI/PCI-X configuration registers
  * with recommended values. Save config space for future hw resets.
  */
-void
-__vxge_hw_device_pci_e_init(struct __vxge_hw_device *hldev)
+static void __vxge_hw_device_pci_e_init(struct __vxge_hw_device *hldev)
 {
         u16 cmd = 0;
 
@@ -185,43 +494,11 @@ __vxge_hw_device_pci_e_init(struct __vxge_hw_device *hldev)
         pci_save_state(hldev->pdev);
 }
 
-/*
- * __vxge_hw_device_register_poll
- * Will poll certain register for specified amount of time.
- * Will poll until masked bit is not cleared.
- */
-enum vxge_hw_status
-__vxge_hw_device_register_poll(void __iomem *reg, u64 mask, u32 max_millis)
-{
-        u64 val64;
-        u32 i = 0;
-        enum vxge_hw_status ret = VXGE_HW_FAIL;
-
-        udelay(10);
-
-        do {
-                val64 = readq(reg);
-                if (!(val64 & mask))
-                        return VXGE_HW_OK;
-                udelay(100);
-        } while (++i <= 9);
-
-        i = 0;
-        do {
-                val64 = readq(reg);
-                if (!(val64 & mask))
-                        return VXGE_HW_OK;
-                mdelay(1);
-        } while (++i <= max_millis);
-
-        return ret;
-}
-
- /* __vxge_hw_device_vpath_reset_in_prog_check - Check if vpath reset
+/* __vxge_hw_device_vpath_reset_in_prog_check - Check if vpath reset
  * in progress
  * This routine checks the vpath reset in progress register is turned zero
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_device_vpath_reset_in_prog_check(u64 __iomem *vpath_rst_in_prog)
 {
         enum vxge_hw_status status;
@@ -232,11 +509,65 @@ __vxge_hw_device_vpath_reset_in_prog_check(u64 __iomem *vpath_rst_in_prog)
 }
 
 /*
+ * _hw_legacy_swapper_set - Set the swapper bits for the legacy secion.
+ * Set the swapper bits appropriately for the lagacy section.
+ */
+static enum vxge_hw_status
+__vxge_hw_legacy_swapper_set(struct vxge_hw_legacy_reg __iomem *legacy_reg)
+{
+        u64 val64;
+        enum vxge_hw_status status = VXGE_HW_OK;
+
+        val64 = readq(&legacy_reg->toc_swapper_fb);
+
+        wmb();
+
+        switch (val64) {
+        case VXGE_HW_SWAPPER_INITIAL_VALUE:
+                return status;
+
+        case VXGE_HW_SWAPPER_BYTE_SWAPPED_BIT_FLIPPED:
+                writeq(VXGE_HW_SWAPPER_READ_BYTE_SWAP_ENABLE,
+                        &legacy_reg->pifm_rd_swap_en);
+                writeq(VXGE_HW_SWAPPER_READ_BIT_FLAP_ENABLE,
+                        &legacy_reg->pifm_rd_flip_en);
+                writeq(VXGE_HW_SWAPPER_WRITE_BYTE_SWAP_ENABLE,
+                        &legacy_reg->pifm_wr_swap_en);
+                writeq(VXGE_HW_SWAPPER_WRITE_BIT_FLAP_ENABLE,
+                        &legacy_reg->pifm_wr_flip_en);
+                break;
+
+        case VXGE_HW_SWAPPER_BYTE_SWAPPED:
+                writeq(VXGE_HW_SWAPPER_READ_BYTE_SWAP_ENABLE,
+                        &legacy_reg->pifm_rd_swap_en);
+                writeq(VXGE_HW_SWAPPER_WRITE_BYTE_SWAP_ENABLE,
+                        &legacy_reg->pifm_wr_swap_en);
+                break;
+
+        case VXGE_HW_SWAPPER_BIT_FLIPPED:
+                writeq(VXGE_HW_SWAPPER_READ_BIT_FLAP_ENABLE,
+                        &legacy_reg->pifm_rd_flip_en);
+                writeq(VXGE_HW_SWAPPER_WRITE_BIT_FLAP_ENABLE,
+                        &legacy_reg->pifm_wr_flip_en);
+                break;
+        }
+
+        wmb();
+
+        val64 = readq(&legacy_reg->toc_swapper_fb);
+
+        if (val64 != VXGE_HW_SWAPPER_INITIAL_VALUE)
+                status = VXGE_HW_ERR_SWAPPER_CTRL;
+
+        return status;
+}
+
+/*
  * __vxge_hw_device_toc_get
  * This routine sets the swapper and reads the toc pointer and returns the
  * memory mapped address of the toc
  */
-struct vxge_hw_toc_reg __iomem *
+static struct vxge_hw_toc_reg __iomem *
 __vxge_hw_device_toc_get(void __iomem *bar0)
 {
         u64 val64;
@@ -262,7 +593,7 @@ exit:
  * register location pointers in the device object. It waits until the ric is
  * completed initializing registers.
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_device_reg_addr_get(struct __vxge_hw_device *hldev)
 {
         u64 val64;
@@ -323,26 +654,6 @@ exit:
 }
 
 /*
- * __vxge_hw_device_id_get
- * This routine returns sets the device id and revision numbers into the device
- * structure
- */
-void __vxge_hw_device_id_get(struct __vxge_hw_device *hldev)
-{
-        u64 val64;
-
-        val64 = readq(&hldev->common_reg->titan_asic_id);
-        hldev->device_id =
-                (u16)VXGE_HW_TITAN_ASIC_ID_GET_INITIAL_DEVICE_ID(val64);
-
-        hldev->major_revision =
-                (u8)VXGE_HW_TITAN_ASIC_ID_GET_INITIAL_MAJOR_REVISION(val64);
-
-        hldev->minor_revision =
-                (u8)VXGE_HW_TITAN_ASIC_ID_GET_INITIAL_MINOR_REVISION(val64);
-}
-
-/*
  * __vxge_hw_device_access_rights_get: Get Access Rights of the driver
  * This routine returns the Access Rights of the driver
  */
@@ -395,10 +706,25 @@ __vxge_hw_device_is_privilaged(u32 host_type, u32 func_id)
 }
 
 /*
+ * __vxge_hw_vpath_func_id_get - Get the function id of the vpath.
+ * Returns the function number of the vpath.
+ */
+static u32
+__vxge_hw_vpath_func_id_get(struct vxge_hw_vpmgmt_reg __iomem *vpmgmt_reg)
+{
+        u64 val64;
+
+        val64 = readq(&vpmgmt_reg->vpath_to_func_map_cfg1);
+
+        return
+         (u32)VXGE_HW_VPATH_TO_FUNC_MAP_CFG1_GET_VPATH_TO_FUNC_MAP_CFG1(val64);
+}
+
+/*
  * __vxge_hw_device_host_info_get
  * This routine returns the host type assignments
  */
-void __vxge_hw_device_host_info_get(struct __vxge_hw_device *hldev)
+static void __vxge_hw_device_host_info_get(struct __vxge_hw_device *hldev)
 {
         u64 val64;
         u32 i;
@@ -411,16 +737,18 @@ void __vxge_hw_device_host_info_get(struct __vxge_hw_device *hldev)
         hldev->vpath_assignments = readq(&hldev->common_reg->vpath_assignments);
 
         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
-
                 if (!(hldev->vpath_assignments & vxge_mBIT(i)))
                         continue;
 
                 hldev->func_id =
-                        __vxge_hw_vpath_func_id_get(i, hldev->vpmgmt_reg[i]);
+                        __vxge_hw_vpath_func_id_get(hldev->vpmgmt_reg[i]);
 
                 hldev->access_rights = __vxge_hw_device_access_rights_get(
                         hldev->host_type, hldev->func_id);
 
+                hldev->virtual_paths[i].vp_open = VXGE_HW_VP_NOT_OPEN;
+                hldev->virtual_paths[i].vp_reg = hldev->vpath_reg[i];
+
                 hldev->first_vp_id = i;
                 break;
         }
@@ -461,7 +789,8 @@ __vxge_hw_verify_pci_e_info(struct __vxge_hw_device *hldev)
  * __vxge_hw_device_initialize
  * Initialize Titan-V hardware.
  */
-enum vxge_hw_status __vxge_hw_device_initialize(struct __vxge_hw_device *hldev)
+static enum vxge_hw_status
+__vxge_hw_device_initialize(struct __vxge_hw_device *hldev)
 {
         enum vxge_hw_status status = VXGE_HW_OK;
 
@@ -477,10 +806,200 @@ exit:
         return status;
 }
 
+/*
+ * __vxge_hw_vpath_fw_ver_get - Get the fw version
+ * Returns FW Version
+ */
+static enum vxge_hw_status
+__vxge_hw_vpath_fw_ver_get(struct __vxge_hw_virtualpath *vpath,
+                           struct vxge_hw_device_hw_info *hw_info)
+{
+        struct vxge_hw_device_version *fw_version = &hw_info->fw_version;
+        struct vxge_hw_device_date *fw_date = &hw_info->fw_date;
+        struct vxge_hw_device_version *flash_version = &hw_info->flash_version;
+        struct vxge_hw_device_date *flash_date = &hw_info->flash_date;
+        u64 data0, data1 = 0, steer_ctrl = 0;
+        enum vxge_hw_status status;
+
+        status = vxge_hw_vpath_fw_api(vpath,
+                        VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_ENTRY,
+                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO,
+                        0, &data0, &data1, &steer_ctrl);
+        if (status != VXGE_HW_OK)
+                goto exit;
+
+        fw_date->day =
+            (u32) VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_DAY(data0);
+        fw_date->month =
+            (u32) VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MONTH(data0);
+        fw_date->year =
+            (u32) VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_YEAR(data0);
+
+        snprintf(fw_date->date, VXGE_HW_FW_STRLEN, "%2.2d/%2.2d/%4.4d",
+                 fw_date->month, fw_date->day, fw_date->year);
+
+        fw_version->major =
+            (u32) VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MAJOR(data0);
+        fw_version->minor =
+            (u32) VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MINOR(data0);
+        fw_version->build =
+            (u32) VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_BUILD(data0);
+
+        snprintf(fw_version->version, VXGE_HW_FW_STRLEN, "%d.%d.%d",
+                 fw_version->major, fw_version->minor, fw_version->build);
+
+        flash_date->day =
+            (u32) VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_DAY(data1);
+        flash_date->month =
+            (u32) VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_MONTH(data1);
+        flash_date->year =
+            (u32) VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_YEAR(data1);
+
+        snprintf(flash_date->date, VXGE_HW_FW_STRLEN, "%2.2d/%2.2d/%4.4d",
+                 flash_date->month, flash_date->day, flash_date->year);
+
+        flash_version->major =
+            (u32) VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_MAJOR(data1);
+        flash_version->minor =
+            (u32) VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_MINOR(data1);
+        flash_version->build =
+            (u32) VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_BUILD(data1);
+
+        snprintf(flash_version->version, VXGE_HW_FW_STRLEN, "%d.%d.%d",
+                 flash_version->major, flash_version->minor,
+                 flash_version->build);
+
+exit:
+        return status;
+}
+
+/*
+ * __vxge_hw_vpath_card_info_get - Get the serial numbers,
+ * part number and product description.
+ */
+static enum vxge_hw_status
+__vxge_hw_vpath_card_info_get(struct __vxge_hw_virtualpath *vpath,
+                              struct vxge_hw_device_hw_info *hw_info)
+{
+        enum vxge_hw_status status;
+        u64 data0, data1 = 0, steer_ctrl = 0;
+        u8 *serial_number = hw_info->serial_number;
+        u8 *part_number = hw_info->part_number;
+        u8 *product_desc = hw_info->product_desc;
+        u32 i, j = 0;
+
+        data0 = VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_SERIAL_NUMBER;
+
+        status = vxge_hw_vpath_fw_api(vpath,
+                        VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_MEMO_ENTRY,
+                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO,
+                        0, &data0, &data1, &steer_ctrl);
+        if (status != VXGE_HW_OK)
+                return status;
+
+        ((u64 *)serial_number)[0] = be64_to_cpu(data0);
+        ((u64 *)serial_number)[1] = be64_to_cpu(data1);
+
+        data0 = VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PART_NUMBER;
+        data1 = steer_ctrl = 0;
+
+        status = vxge_hw_vpath_fw_api(vpath,
+                        VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_MEMO_ENTRY,
+                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO,
+                        0, &data0, &data1, &steer_ctrl);
+        if (status != VXGE_HW_OK)
+                return status;
+
+        ((u64 *)part_number)[0] = be64_to_cpu(data0);
+        ((u64 *)part_number)[1] = be64_to_cpu(data1);
+
+        for (i = VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_DESC_0;
+             i <= VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_DESC_3; i++) {
+                data0 = i;
+                data1 = steer_ctrl = 0;
+
+                status = vxge_hw_vpath_fw_api(vpath,
+                        VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_MEMO_ENTRY,
+                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO,
+                        0, &data0, &data1, &steer_ctrl);
+                if (status != VXGE_HW_OK)
+                        return status;
+
+                ((u64 *)product_desc)[j++] = be64_to_cpu(data0);
+                ((u64 *)product_desc)[j++] = be64_to_cpu(data1);
+        }
+
+        return status;
+}
+
+/*
+ * __vxge_hw_vpath_pci_func_mode_get - Get the pci mode
+ * Returns pci function mode
+ */
+static enum vxge_hw_status
+__vxge_hw_vpath_pci_func_mode_get(struct __vxge_hw_virtualpath *vpath,
+                                  struct vxge_hw_device_hw_info *hw_info)
+{
+        u64 data0, data1 = 0, steer_ctrl = 0;
+        enum vxge_hw_status status;
+
+        data0 = 0;
+
+        status = vxge_hw_vpath_fw_api(vpath,
+                        VXGE_HW_FW_API_GET_FUNC_MODE,
+                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO,
+                        0, &data0, &data1, &steer_ctrl);
+        if (status != VXGE_HW_OK)
+                return status;
+
+        hw_info->function_mode = VXGE_HW_GET_FUNC_MODE_VAL(data0);
+        return status;
+}
+
+/*
+ * __vxge_hw_vpath_addr_get - Get the hw address entry for this vpath
+ *               from MAC address table.
+ */
+static enum vxge_hw_status
+__vxge_hw_vpath_addr_get(struct __vxge_hw_virtualpath *vpath,
+                         u8 *macaddr, u8 *macaddr_mask)
+{
+        u64 action = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_LIST_FIRST_ENTRY,
+            data0 = 0, data1 = 0, steer_ctrl = 0;
+        enum vxge_hw_status status;
+        int i;
+
+        do {
+                status = vxge_hw_vpath_fw_api(vpath, action,
+                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DA,
+                        0, &data0, &data1, &steer_ctrl);
+                if (status != VXGE_HW_OK)
+                        goto exit;
+
+                data0 = VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_DA_MAC_ADDR(data0);
+                data1 = VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_DA_MAC_ADDR_MASK(
+                                                                        data1);
+
+                for (i = ETH_ALEN; i > 0; i--) {
+                        macaddr[i - 1] = (u8) (data0 & 0xFF);
+                        data0 >>= 8;
+
+                        macaddr_mask[i - 1] = (u8) (data1 & 0xFF);
+                        data1 >>= 8;
+                }
+
+                action = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_LIST_NEXT_ENTRY;
+                data0 = 0, data1 = 0, steer_ctrl = 0;
+
+        } while (!is_valid_ether_addr(macaddr));
+exit:
+        return status;
+}
+
 /**
  * vxge_hw_device_hw_info_get - Get the hw information
  * Returns the vpath mask that has the bits set for each vpath allocated
- * for the driver, FW version information and the first mac addresse for
+ * for the driver, FW version information, and the first mac address for
  * each vpath
  */
 enum vxge_hw_status __devinit
@@ -492,9 +1011,9 @@ vxge_hw_device_hw_info_get(void __iomem *bar0,
         struct vxge_hw_toc_reg __iomem *toc;
         struct vxge_hw_mrpcim_reg __iomem *mrpcim_reg;
         struct vxge_hw_common_reg __iomem *common_reg;
-        struct vxge_hw_vpath_reg __iomem *vpath_reg;
         struct vxge_hw_vpmgmt_reg __iomem *vpmgmt_reg;
         enum vxge_hw_status status;
+        struct __vxge_hw_virtualpath vpath;
 
         memset(hw_info, 0, sizeof(struct vxge_hw_device_hw_info));
 
@@ -520,7 +1039,6 @@ vxge_hw_device_hw_info_get(void __iomem *bar0,
            (u32)VXGE_HW_HOST_TYPE_ASSIGNMENTS_GET_HOST_TYPE_ASSIGNMENTS(val64);
 
         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
-
                 if (!((hw_info->vpath_mask) & vxge_mBIT(i)))
                         continue;
 
@@ -529,7 +1047,7 @@ vxge_hw_device_hw_info_get(void __iomem *bar0,
                 vpmgmt_reg = (struct vxge_hw_vpmgmt_reg __iomem *)
                                 (bar0 + val64);
 
-                hw_info->func_id = __vxge_hw_vpath_func_id_get(i, vpmgmt_reg);
+                hw_info->func_id = __vxge_hw_vpath_func_id_get(vpmgmt_reg);
                 if (__vxge_hw_device_access_rights_get(hw_info->host_type,
                         hw_info->func_id) &
                         VXGE_HW_DEVICE_ACCESS_RIGHT_MRPCIM) {
@@ -545,16 +1063,20 @@ vxge_hw_device_hw_info_get(void __iomem *bar0,
 
                 val64 = readq(&toc->toc_vpath_pointer[i]);
 
-                vpath_reg = (struct vxge_hw_vpath_reg __iomem *)(bar0 + val64);
+                spin_lock_init(&vpath.lock);
+                vpath.vp_reg = (struct vxge_hw_vpath_reg __iomem *)
+                               (bar0 + val64);
+                vpath.vp_open = VXGE_HW_VP_NOT_OPEN;
 
-                hw_info->function_mode =
-                        __vxge_hw_vpath_pci_func_mode_get(i, vpath_reg);
+                status = __vxge_hw_vpath_pci_func_mode_get(&vpath, hw_info);
+                if (status != VXGE_HW_OK)
+                        goto exit;
 
-                status = __vxge_hw_vpath_fw_ver_get(i, vpath_reg, hw_info);
+                status = __vxge_hw_vpath_fw_ver_get(&vpath, hw_info);
                 if (status != VXGE_HW_OK)
                         goto exit;
 
-                status = __vxge_hw_vpath_card_info_get(i, vpath_reg, hw_info);
+                status = __vxge_hw_vpath_card_info_get(&vpath, hw_info);
                 if (status != VXGE_HW_OK)
                         goto exit;
 
@@ -562,14 +1084,15 @@ vxge_hw_device_hw_info_get(void __iomem *bar0,
         }
 
         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
-
                 if (!((hw_info->vpath_mask) & vxge_mBIT(i)))
                         continue;
 
                 val64 = readq(&toc->toc_vpath_pointer[i]);
-                vpath_reg = (struct vxge_hw_vpath_reg __iomem *)(bar0 + val64);
+                vpath.vp_reg = (struct vxge_hw_vpath_reg __iomem *)
+                               (bar0 + val64);
+                vpath.vp_open = VXGE_HW_VP_NOT_OPEN;
 
-                status =  __vxge_hw_vpath_addr_get(i, vpath_reg,
+                status =  __vxge_hw_vpath_addr_get(&vpath,
                                 hw_info->mac_addrs[i],
                                 hw_info->mac_addr_masks[i]);
                 if (status != VXGE_HW_OK)
@@ -580,6 +1103,218 @@ exit:
 }
 
 /*
+ * __vxge_hw_blockpool_destroy - Deallocates the block pool
+ */
+static void __vxge_hw_blockpool_destroy(struct __vxge_hw_blockpool *blockpool)
+{
+        struct __vxge_hw_device *hldev;
+        struct list_head *p, *n;
+        u16 ret;
+
+        if (blockpool == NULL) {
+                ret = 1;
+                goto exit;
+        }
+
+        hldev = blockpool->hldev;
+
+        list_for_each_safe(p, n, &blockpool->free_block_list) {
+                pci_unmap_single(hldev->pdev,
+                        ((struct __vxge_hw_blockpool_entry *)p)->dma_addr,
+                        ((struct __vxge_hw_blockpool_entry *)p)->length,
+                        PCI_DMA_BIDIRECTIONAL);
+
+                vxge_os_dma_free(hldev->pdev,
+                        ((struct __vxge_hw_blockpool_entry *)p)->memblock,
+                        &((struct __vxge_hw_blockpool_entry *)p)->acc_handle);
+
+                list_del(&((struct __vxge_hw_blockpool_entry *)p)->item);
+                kfree(p);
+                blockpool->pool_size--;
+        }
+
+        list_for_each_safe(p, n, &blockpool->free_entry_list) {
+                list_del(&((struct __vxge_hw_blockpool_entry *)p)->item);
+                kfree((void *)p);
+        }
+        ret = 0;
+exit:
+        return;
+}
+
+/*
+ * __vxge_hw_blockpool_create - Create block pool
+ */
+static enum vxge_hw_status
+__vxge_hw_blockpool_create(struct __vxge_hw_device *hldev,
+                           struct __vxge_hw_blockpool *blockpool,
+                           u32 pool_size,
+                           u32 pool_max)
+{
+        u32 i;
+        struct __vxge_hw_blockpool_entry *entry = NULL;
+        void *memblock;
+        dma_addr_t dma_addr;
+        struct pci_dev *dma_handle;
+        struct pci_dev *acc_handle;
+        enum vxge_hw_status status = VXGE_HW_OK;
+
+        if (blockpool == NULL) {
+                status = VXGE_HW_FAIL;
+                goto blockpool_create_exit;
+        }
+
+        blockpool->hldev = hldev;
+        blockpool->block_size = VXGE_HW_BLOCK_SIZE;
+        blockpool->pool_size = 0;
+        blockpool->pool_max = pool_max;
+        blockpool->req_out = 0;
+
+        INIT_LIST_HEAD(&blockpool->free_block_list);
+        INIT_LIST_HEAD(&blockpool->free_entry_list);
+
+        for (i = 0; i < pool_size + pool_max; i++) {
+                entry = kzalloc(sizeof(struct __vxge_hw_blockpool_entry),
+                                GFP_KERNEL);
+                if (entry == NULL) {
+                        __vxge_hw_blockpool_destroy(blockpool);
+                        status = VXGE_HW_ERR_OUT_OF_MEMORY;
+                        goto blockpool_create_exit;
+                }
+                list_add(&entry->item, &blockpool->free_entry_list);
+        }
+
+        for (i = 0; i < pool_size; i++) {
+                memblock = vxge_os_dma_malloc(
+                                hldev->pdev,
+                                VXGE_HW_BLOCK_SIZE,
+                                &dma_handle,
+                                &acc_handle);
+                if (memblock == NULL) {
+                        __vxge_hw_blockpool_destroy(blockpool);
+                        status = VXGE_HW_ERR_OUT_OF_MEMORY;
+                        goto blockpool_create_exit;
+                }
+
+                dma_addr = pci_map_single(hldev->pdev, memblock,
+                                VXGE_HW_BLOCK_SIZE, PCI_DMA_BIDIRECTIONAL);
+                if (unlikely(pci_dma_mapping_error(hldev->pdev,
+                                dma_addr))) {
+                        vxge_os_dma_free(hldev->pdev, memblock, &acc_handle);
+                        __vxge_hw_blockpool_destroy(blockpool);
+                        status = VXGE_HW_ERR_OUT_OF_MEMORY;
+                        goto blockpool_create_exit;
+                }
+
+                if (!list_empty(&blockpool->free_entry_list))
+                        entry = (struct __vxge_hw_blockpool_entry *)
+                                list_first_entry(&blockpool->free_entry_list,
+                                        struct __vxge_hw_blockpool_entry,
+                                        item);
+
+                if (entry == NULL)
+                        entry =
+                            kzalloc(sizeof(struct __vxge_hw_blockpool_entry),
+                                        GFP_KERNEL);
+                if (entry != NULL) {
+                        list_del(&entry->item);
+                        entry->length = VXGE_HW_BLOCK_SIZE;
+                        entry->memblock = memblock;
+                        entry->dma_addr = dma_addr;
+                        entry->acc_handle = acc_handle;
+                        entry->dma_handle = dma_handle;
+                        list_add(&entry->item,
+                                          &blockpool->free_block_list);
+                        blockpool->pool_size++;
+                } else {
+                        __vxge_hw_blockpool_destroy(blockpool);
+                        status = VXGE_HW_ERR_OUT_OF_MEMORY;
+                        goto blockpool_create_exit;
+                }
+        }
+
+blockpool_create_exit:
+        return status;
+}
+
+/*
+ * __vxge_hw_device_fifo_config_check - Check fifo configuration.
+ * Check the fifo configuration
+ */
+static enum vxge_hw_status
+__vxge_hw_device_fifo_config_check(struct vxge_hw_fifo_config *fifo_config)
+{
+        if ((fifo_config->fifo_blocks < VXGE_HW_MIN_FIFO_BLOCKS) ||
+            (fifo_config->fifo_blocks > VXGE_HW_MAX_FIFO_BLOCKS))
+                return VXGE_HW_BADCFG_FIFO_BLOCKS;
+
+        return VXGE_HW_OK;
+}
+
+/*
+ * __vxge_hw_device_vpath_config_check - Check vpath configuration.
+ * Check the vpath configuration
+ */
+static enum vxge_hw_status
+__vxge_hw_device_vpath_config_check(struct vxge_hw_vp_config *vp_config)
+{
+        enum vxge_hw_status status;
+
+        if ((vp_config->min_bandwidth < VXGE_HW_VPATH_BANDWIDTH_MIN) ||
+            (vp_config->min_bandwidth > VXGE_HW_VPATH_BANDWIDTH_MAX))
+                return VXGE_HW_BADCFG_VPATH_MIN_BANDWIDTH;
+
+        status = __vxge_hw_device_fifo_config_check(&vp_config->fifo);
+        if (status != VXGE_HW_OK)
+                return status;
+
+        if ((vp_config->mtu != VXGE_HW_VPATH_USE_FLASH_DEFAULT_INITIAL_MTU) &&
+                ((vp_config->mtu < VXGE_HW_VPATH_MIN_INITIAL_MTU) ||
+                (vp_config->mtu > VXGE_HW_VPATH_MAX_INITIAL_MTU)))
+                return VXGE_HW_BADCFG_VPATH_MTU;
+
+        if ((vp_config->rpa_strip_vlan_tag !=
+                VXGE_HW_VPATH_RPA_STRIP_VLAN_TAG_USE_FLASH_DEFAULT) &&
+                (vp_config->rpa_strip_vlan_tag !=
+                VXGE_HW_VPATH_RPA_STRIP_VLAN_TAG_ENABLE) &&
+                (vp_config->rpa_strip_vlan_tag !=
+                VXGE_HW_VPATH_RPA_STRIP_VLAN_TAG_DISABLE))
+                return VXGE_HW_BADCFG_VPATH_RPA_STRIP_VLAN_TAG;
+
+        return VXGE_HW_OK;
+}
+
+/*
+ * __vxge_hw_device_config_check - Check device configuration.
+ * Check the device configuration
+ */
+static enum vxge_hw_status
+__vxge_hw_device_config_check(struct vxge_hw_device_config *new_config)
+{
+        u32 i;
+        enum vxge_hw_status status;
+
+        if ((new_config->intr_mode != VXGE_HW_INTR_MODE_IRQLINE) &&
+            (new_config->intr_mode != VXGE_HW_INTR_MODE_MSIX) &&
+            (new_config->intr_mode != VXGE_HW_INTR_MODE_MSIX_ONE_SHOT) &&
+            (new_config->intr_mode != VXGE_HW_INTR_MODE_DEF))
+                return VXGE_HW_BADCFG_INTR_MODE;
+
+        if ((new_config->rts_mac_en != VXGE_HW_RTS_MAC_DISABLE) &&
+            (new_config->rts_mac_en != VXGE_HW_RTS_MAC_ENABLE))
+                return VXGE_HW_BADCFG_RTS_MAC_EN;
+
+        for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
+                status = __vxge_hw_device_vpath_config_check(
+                                &new_config->vp_config[i]);
+                if (status != VXGE_HW_OK)
+                        return status;
+        }
+
+        return VXGE_HW_OK;
+}
+
+/*
  * vxge_hw_device_initialize - Initialize Titan device.
  * Initialize Titan device. Note that all the arguments of this public API
  * are 'IN', including @hldev. Driver cooperates with
@@ -603,14 +1338,12 @@ vxge_hw_device_initialize(
         if (status != VXGE_HW_OK)
                 goto exit;
 
-        hldev = (struct __vxge_hw_device *)
-                        vmalloc(sizeof(struct __vxge_hw_device));
+        hldev = vzalloc(sizeof(struct __vxge_hw_device));
         if (hldev == NULL) {
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 goto exit;
         }
 
-        memset(hldev, 0, sizeof(struct __vxge_hw_device));
         hldev->magic = VXGE_HW_DEVICE_MAGIC;
 
         vxge_hw_device_debug_set(hldev, VXGE_ERR, VXGE_COMPONENT_ALL);
@@ -633,7 +1366,6 @@ vxge_hw_device_initialize(
                 vfree(hldev);
                 goto exit;
         }
-        __vxge_hw_device_id_get(hldev);
 
         __vxge_hw_device_host_info_get(hldev);
 
@@ -641,7 +1373,6 @@ vxge_hw_device_initialize(
         nblocks++;
 
         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
-
                 if (!(hldev->vpath_assignments & vxge_mBIT(i)))
                         continue;
 
@@ -666,7 +1397,6 @@ vxge_hw_device_initialize(
         }
 
         status = __vxge_hw_device_initialize(hldev);
-
         if (status != VXGE_HW_OK) {
                 vxge_hw_device_terminate(hldev);
                 goto exit;
@@ -692,6 +1422,242 @@ vxge_hw_device_terminate(struct __vxge_hw_device *hldev)
 }
 
 /*
+ * __vxge_hw_vpath_stats_access - Get the statistics from the given location
+ *                           and offset and perform an operation
+ */
+static enum vxge_hw_status
+__vxge_hw_vpath_stats_access(struct __vxge_hw_virtualpath *vpath,
+                             u32 operation, u32 offset, u64 *stat)
+{
+        u64 val64;
+        enum vxge_hw_status status = VXGE_HW_OK;
+        struct vxge_hw_vpath_reg __iomem *vp_reg;
+
+        if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
+                status = VXGE_HW_ERR_VPATH_NOT_OPEN;
+                goto vpath_stats_access_exit;
+        }
+
+        vp_reg = vpath->vp_reg;
+
+        val64 =  VXGE_HW_XMAC_STATS_ACCESS_CMD_OP(operation) |
+                 VXGE_HW_XMAC_STATS_ACCESS_CMD_STROBE |
+                 VXGE_HW_XMAC_STATS_ACCESS_CMD_OFFSET_SEL(offset);
+
+        status = __vxge_hw_pio_mem_write64(val64,
+                                &vp_reg->xmac_stats_access_cmd,
+                                VXGE_HW_XMAC_STATS_ACCESS_CMD_STROBE,
+                                vpath->hldev->config.device_poll_millis);
+        if ((status == VXGE_HW_OK) && (operation == VXGE_HW_STATS_OP_READ))
+                *stat = readq(&vp_reg->xmac_stats_access_data);
+        else
+                *stat = 0;
+
+vpath_stats_access_exit:
+        return status;
+}
+
+/*
+ * __vxge_hw_vpath_xmac_tx_stats_get - Get the TX Statistics of a vpath
+ */
+static enum vxge_hw_status
+__vxge_hw_vpath_xmac_tx_stats_get(struct __vxge_hw_virtualpath *vpath,
+                        struct vxge_hw_xmac_vpath_tx_stats *vpath_tx_stats)
+{
+        u64 *val64;
+        int i;
+        u32 offset = VXGE_HW_STATS_VPATH_TX_OFFSET;
+        enum vxge_hw_status status = VXGE_HW_OK;
+
+        val64 = (u64 *)vpath_tx_stats;
+
+        if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
+                status = VXGE_HW_ERR_VPATH_NOT_OPEN;
+                goto exit;
+        }
+
+        for (i = 0; i < sizeof(struct vxge_hw_xmac_vpath_tx_stats) / 8; i++) {
+                status = __vxge_hw_vpath_stats_access(vpath,
+                                        VXGE_HW_STATS_OP_READ,
+                                        offset, val64);
+                if (status != VXGE_HW_OK)
+                        goto exit;
+                offset++;
+                val64++;
+        }
+exit:
+        return status;
+}
+
+/*
+ * __vxge_hw_vpath_xmac_rx_stats_get - Get the RX Statistics of a vpath
+ */
+static enum vxge_hw_status
+__vxge_hw_vpath_xmac_rx_stats_get(struct __vxge_hw_virtualpath *vpath,
+                        struct vxge_hw_xmac_vpath_rx_stats *vpath_rx_stats)
+{
+        u64 *val64;
+        enum vxge_hw_status status = VXGE_HW_OK;
+        int i;
+        u32 offset = VXGE_HW_STATS_VPATH_RX_OFFSET;
+        val64 = (u64 *) vpath_rx_stats;
+
+        if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
+                status = VXGE_HW_ERR_VPATH_NOT_OPEN;
+                goto exit;
+        }
+        for (i = 0; i < sizeof(struct vxge_hw_xmac_vpath_rx_stats) / 8; i++) {
+                status = __vxge_hw_vpath_stats_access(vpath,
+                                        VXGE_HW_STATS_OP_READ,
+                                        offset >> 3, val64);
+                if (status != VXGE_HW_OK)
+                        goto exit;
+
+                offset += 8;
+                val64++;
+        }
+exit:
+        return status;
+}
+
+/*
+ * __vxge_hw_vpath_stats_get - Get the vpath hw statistics.
+ */
+static enum vxge_hw_status
+__vxge_hw_vpath_stats_get(struct __vxge_hw_virtualpath *vpath,
+                          struct vxge_hw_vpath_stats_hw_info *hw_stats)
+{
+        u64 val64;
+        enum vxge_hw_status status = VXGE_HW_OK;
+        struct vxge_hw_vpath_reg __iomem *vp_reg;
+
+        if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
+                status = VXGE_HW_ERR_VPATH_NOT_OPEN;
+                goto exit;
+        }
+        vp_reg = vpath->vp_reg;
+
+        val64 = readq(&vp_reg->vpath_debug_stats0);
+        hw_stats->ini_num_mwr_sent =
+                (u32)VXGE_HW_VPATH_DEBUG_STATS0_GET_INI_NUM_MWR_SENT(val64);
+
+        val64 = readq(&vp_reg->vpath_debug_stats1);
+        hw_stats->ini_num_mrd_sent =
+                (u32)VXGE_HW_VPATH_DEBUG_STATS1_GET_INI_NUM_MRD_SENT(val64);
+
+        val64 = readq(&vp_reg->vpath_debug_stats2);
+        hw_stats->ini_num_cpl_rcvd =
+                (u32)VXGE_HW_VPATH_DEBUG_STATS2_GET_INI_NUM_CPL_RCVD(val64);
+
+        val64 = readq(&vp_reg->vpath_debug_stats3);
+        hw_stats->ini_num_mwr_byte_sent =
+                VXGE_HW_VPATH_DEBUG_STATS3_GET_INI_NUM_MWR_BYTE_SENT(val64);
+
+        val64 = readq(&vp_reg->vpath_debug_stats4);
+        hw_stats->ini_num_cpl_byte_rcvd =
+                VXGE_HW_VPATH_DEBUG_STATS4_GET_INI_NUM_CPL_BYTE_RCVD(val64);
+
+        val64 = readq(&vp_reg->vpath_debug_stats5);
+        hw_stats->wrcrdtarb_xoff =
+                (u32)VXGE_HW_VPATH_DEBUG_STATS5_GET_WRCRDTARB_XOFF(val64);
+
+        val64 = readq(&vp_reg->vpath_debug_stats6);
+        hw_stats->rdcrdtarb_xoff =
+                (u32)VXGE_HW_VPATH_DEBUG_STATS6_GET_RDCRDTARB_XOFF(val64);
+
+        val64 = readq(&vp_reg->vpath_genstats_count01);
+        hw_stats->vpath_genstats_count0 =
+        (u32)VXGE_HW_VPATH_GENSTATS_COUNT01_GET_PPIF_VPATH_GENSTATS_COUNT0(
+                val64);
+
+        val64 = readq(&vp_reg->vpath_genstats_count01);
+        hw_stats->vpath_genstats_count1 =
+        (u32)VXGE_HW_VPATH_GENSTATS_COUNT01_GET_PPIF_VPATH_GENSTATS_COUNT1(
+                val64);
+
+        val64 = readq(&vp_reg->vpath_genstats_count23);
+        hw_stats->vpath_genstats_count2 =
+        (u32)VXGE_HW_VPATH_GENSTATS_COUNT23_GET_PPIF_VPATH_GENSTATS_COUNT2(
+                val64);
+
+        val64 = readq(&vp_reg->vpath_genstats_count01);
+        hw_stats->vpath_genstats_count3 =
+        (u32)VXGE_HW_VPATH_GENSTATS_COUNT23_GET_PPIF_VPATH_GENSTATS_COUNT3(
+                val64);
+
+        val64 = readq(&vp_reg->vpath_genstats_count4);
+        hw_stats->vpath_genstats_count4 =
+        (u32)VXGE_HW_VPATH_GENSTATS_COUNT4_GET_PPIF_VPATH_GENSTATS_COUNT4(
+                val64);
+
+        val64 = readq(&vp_reg->vpath_genstats_count5);
+        hw_stats->vpath_genstats_count5 =
+        (u32)VXGE_HW_VPATH_GENSTATS_COUNT5_GET_PPIF_VPATH_GENSTATS_COUNT5(
+                val64);
+
+        status = __vxge_hw_vpath_xmac_tx_stats_get(vpath, &hw_stats->tx_stats);
+        if (status != VXGE_HW_OK)
+                goto exit;
+
+        status = __vxge_hw_vpath_xmac_rx_stats_get(vpath, &hw_stats->rx_stats);
+        if (status != VXGE_HW_OK)
+                goto exit;
+
+        VXGE_HW_VPATH_STATS_PIO_READ(
+                VXGE_HW_STATS_VPATH_PROG_EVENT_VNUM0_OFFSET);
+
+        hw_stats->prog_event_vnum0 =
+                        (u32)VXGE_HW_STATS_GET_VPATH_PROG_EVENT_VNUM0(val64);
+
+        hw_stats->prog_event_vnum1 =
+                        (u32)VXGE_HW_STATS_GET_VPATH_PROG_EVENT_VNUM1(val64);
+
+        VXGE_HW_VPATH_STATS_PIO_READ(
+                VXGE_HW_STATS_VPATH_PROG_EVENT_VNUM2_OFFSET);
+
+        hw_stats->prog_event_vnum2 =
+                        (u32)VXGE_HW_STATS_GET_VPATH_PROG_EVENT_VNUM2(val64);
+
+        hw_stats->prog_event_vnum3 =
+                        (u32)VXGE_HW_STATS_GET_VPATH_PROG_EVENT_VNUM3(val64);
+
+        val64 = readq(&vp_reg->rx_multi_cast_stats);
+        hw_stats->rx_multi_cast_frame_discard =
+                (u16)VXGE_HW_RX_MULTI_CAST_STATS_GET_FRAME_DISCARD(val64);
+
+        val64 = readq(&vp_reg->rx_frm_transferred);
+        hw_stats->rx_frm_transferred =
+                (u32)VXGE_HW_RX_FRM_TRANSFERRED_GET_RX_FRM_TRANSFERRED(val64);
+
+        val64 = readq(&vp_reg->rxd_returned);
+        hw_stats->rxd_returned =
+                (u16)VXGE_HW_RXD_RETURNED_GET_RXD_RETURNED(val64);
+
+        val64 = readq(&vp_reg->dbg_stats_rx_mpa);
+        hw_stats->rx_mpa_len_fail_frms =
+                (u16)VXGE_HW_DBG_STATS_GET_RX_MPA_LEN_FAIL_FRMS(val64);
+        hw_stats->rx_mpa_mrk_fail_frms =
+                (u16)VXGE_HW_DBG_STATS_GET_RX_MPA_MRK_FAIL_FRMS(val64);
+        hw_stats->rx_mpa_crc_fail_frms =
+                (u16)VXGE_HW_DBG_STATS_GET_RX_MPA_CRC_FAIL_FRMS(val64);
+
+        val64 = readq(&vp_reg->dbg_stats_rx_fau);
+        hw_stats->rx_permitted_frms =
+                (u16)VXGE_HW_DBG_STATS_GET_RX_FAU_RX_PERMITTED_FRMS(val64);
+        hw_stats->rx_vp_reset_discarded_frms =
+        (u16)VXGE_HW_DBG_STATS_GET_RX_FAU_RX_VP_RESET_DISCARDED_FRMS(val64);
+        hw_stats->rx_wol_frms =
+                (u16)VXGE_HW_DBG_STATS_GET_RX_FAU_RX_WOL_FRMS(val64);
+
+        val64 = readq(&vp_reg->tx_vp_reset_discarded_frms);
+        hw_stats->tx_vp_reset_discarded_frms =
+        (u16)VXGE_HW_TX_VP_RESET_DISCARDED_FRMS_GET_TX_VP_RESET_DISCARDED_FRMS(
+                val64);
+exit:
+        return status;
+}
+
+/*
  * vxge_hw_device_stats_get - Get the device hw statistics.
  * Returns the vpath h/w stats for the device.
  */
@@ -703,7 +1669,6 @@ vxge_hw_device_stats_get(struct __vxge_hw_device *hldev,
         enum vxge_hw_status status = VXGE_HW_OK;
 
         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
-
                 if (!(hldev->vpaths_deployed & vxge_mBIT(i)) ||
                         (hldev->virtual_paths[i].vp_open ==
                                 VXGE_HW_VP_NOT_OPEN))
@@ -779,7 +1744,7 @@ exit:
  * vxge_hw_device_xmac_aggr_stats_get - Get the Statistics on aggregate port
  * Get the Statistics on aggregate port
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 vxge_hw_device_xmac_aggr_stats_get(struct __vxge_hw_device *hldev, u32 port,
                                    struct vxge_hw_xmac_aggr_stats *aggr_stats)
 {
@@ -814,7 +1779,7 @@ exit:
  * vxge_hw_device_xmac_port_stats_get - Get the Statistics on a port
  * Get the Statistics on port
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 vxge_hw_device_xmac_port_stats_get(struct __vxge_hw_device *hldev, u32 port,
                                    struct vxge_hw_xmac_port_stats *port_stats)
 {
@@ -858,7 +1823,6 @@ vxge_hw_device_xmac_stats_get(struct __vxge_hw_device *hldev,
 
         status = vxge_hw_device_xmac_aggr_stats_get(hldev,
                                         0, &xmac_stats->aggr_stats[0]);
-
         if (status != VXGE_HW_OK)
                 goto exit;
 
@@ -952,20 +1916,6 @@ u32 vxge_hw_device_trace_level_get(struct __vxge_hw_device *hldev)
         return 0;
 #endif
 }
-/*
- * vxge_hw_device_debug_mask_get - Get the debug mask
- * This routine returns the current debug mask set
- */
-u32 vxge_hw_device_debug_mask_get(struct __vxge_hw_device *hldev)
-{
-#if defined(VXGE_DEBUG_TRACE_MASK) || defined(VXGE_DEBUG_ERR_MASK)
-        if (hldev == NULL)
-                return 0;
-        return hldev->debug_module_mask;
-#else
-        return 0;
-#endif
-}
 
 /*
  * vxge_hw_getpause_data -Pause frame frame generation and reception.
@@ -1006,7 +1956,6 @@ exit:
  * It can be used to set or reset Pause frame generation or reception
  * support of the NIC.
  */
-
 enum vxge_hw_status vxge_hw_device_setpause_data(struct __vxge_hw_device *hldev,
                                                  u32 port, u32 tx, u32 rx)
 {
@@ -1090,7 +2039,7 @@ __vxge_hw_ring_block_next_pointer_set(u8 *block, dma_addr_t dma_next)
  *             first block
  * Returns the dma address of the first RxD block
  */
-u64 __vxge_hw_ring_first_block_address_get(struct __vxge_hw_ring *ring)
+static u64 __vxge_hw_ring_first_block_address_get(struct __vxge_hw_ring *ring)
 {
         struct vxge_hw_mempool_dma *dma_object;
 
@@ -1248,197 +2197,366 @@ exit:
 }
 
 /*
- * __vxge_hw_ring_create - Create a Ring
- * This function creates Ring and initializes it.
- *
+ * __vxge_hw_channel_allocate - Allocate memory for channel
+ * This function allocates required memory for the channel and various arrays
+ * in the channel
  */
-enum vxge_hw_status
-__vxge_hw_ring_create(struct __vxge_hw_vpath_handle *vp,
-                      struct vxge_hw_ring_attr *attr)
+static struct __vxge_hw_channel *
+__vxge_hw_channel_allocate(struct __vxge_hw_vpath_handle *vph,
+                           enum __vxge_hw_channel_type type,
+                           u32 length, u32 per_dtr_space,
+                           void *userdata)
 {
-        enum vxge_hw_status status = VXGE_HW_OK;
-        struct __vxge_hw_ring *ring;
-        u32 ring_length;
-        struct vxge_hw_ring_config *config;
+        struct __vxge_hw_channel *channel;
         struct __vxge_hw_device *hldev;
+        int size = 0;
         u32 vp_id;
-        struct vxge_hw_mempool_cbs ring_mp_callback;
 
-        if ((vp == NULL) || (attr == NULL)) {
+        hldev = vph->vpath->hldev;
+        vp_id = vph->vpath->vp_id;
+
+        switch (type) {
+        case VXGE_HW_CHANNEL_TYPE_FIFO:
+                size = sizeof(struct __vxge_hw_fifo);
+                break;
+        case VXGE_HW_CHANNEL_TYPE_RING:
+                size = sizeof(struct __vxge_hw_ring);
+                break;
+        default:
+                break;
+        }
+
+        channel = kzalloc(size, GFP_KERNEL);
+        if (channel == NULL)
+                goto exit0;
+        INIT_LIST_HEAD(&channel->item);
+
+        channel->common_reg = hldev->common_reg;
+        channel->first_vp_id = hldev->first_vp_id;
+        channel->type = type;
+        channel->devh = hldev;
+        channel->vph = vph;
+        channel->userdata = userdata;
+        channel->per_dtr_space = per_dtr_space;
+        channel->length = length;
+        channel->vp_id = vp_id;
+
+        channel->work_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL);
+        if (channel->work_arr == NULL)
+                goto exit1;
+
+        channel->free_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL);
+        if (channel->free_arr == NULL)
+                goto exit1;
+        channel->free_ptr = length;
+
+        channel->reserve_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL);
+        if (channel->reserve_arr == NULL)
+                goto exit1;
+        channel->reserve_ptr = length;
+        channel->reserve_top = 0;
+
+        channel->orig_arr = kzalloc(sizeof(void *)*length, GFP_KERNEL);
+        if (channel->orig_arr == NULL)
+                goto exit1;
+
+        return channel;
+exit1:
+        __vxge_hw_channel_free(channel);
+
+exit0:
+        return NULL;
+}
+
+/*
+ * vxge_hw_blockpool_block_add - callback for vxge_os_dma_malloc_async
+ * Adds a block to block pool
+ */
+static void vxge_hw_blockpool_block_add(struct __vxge_hw_device *devh,
+                                        void *block_addr,
+                                        u32 length,
+                                        struct pci_dev *dma_h,
+                                        struct pci_dev *acc_handle)
+{
+        struct __vxge_hw_blockpool *blockpool;
+        struct __vxge_hw_blockpool_entry *entry = NULL;
+        dma_addr_t dma_addr;
+        enum vxge_hw_status status = VXGE_HW_OK;
+        u32 req_out;
+
+        blockpool = &devh->block_pool;
+
+        if (block_addr == NULL) {
+                blockpool->req_out--;
                 status = VXGE_HW_FAIL;
                 goto exit;
         }
 
-        hldev = vp->vpath->hldev;
-        vp_id = vp->vpath->vp_id;
+        dma_addr = pci_map_single(devh->pdev, block_addr, length,
+                                PCI_DMA_BIDIRECTIONAL);
 
-        config = &hldev->config.vp_config[vp_id].ring;
+        if (unlikely(pci_dma_mapping_error(devh->pdev, dma_addr))) {
+                vxge_os_dma_free(devh->pdev, block_addr, &acc_handle);
+                blockpool->req_out--;
+                status = VXGE_HW_FAIL;
+                goto exit;
+        }
 
-        ring_length = config->ring_blocks *
-                        vxge_hw_ring_rxds_per_block_get(config->buffer_mode);
+        if (!list_empty(&blockpool->free_entry_list))
+                entry = (struct __vxge_hw_blockpool_entry *)
+                        list_first_entry(&blockpool->free_entry_list,
+                                struct __vxge_hw_blockpool_entry,
+                                item);
 
-        ring = (struct __vxge_hw_ring *)__vxge_hw_channel_allocate(vp,
-                                                VXGE_HW_CHANNEL_TYPE_RING,
-                                                ring_length,
-                                                attr->per_rxd_space,
-                                                attr->userdata);
+        if (entry == NULL)
+                entry = vmalloc(sizeof(struct __vxge_hw_blockpool_entry));
+        else
+                list_del(&entry->item);
 
-        if (ring == NULL) {
+        if (entry != NULL) {
+                entry->length = length;
+                entry->memblock = block_addr;
+                entry->dma_addr = dma_addr;
+                entry->acc_handle = acc_handle;
+                entry->dma_handle = dma_h;
+                list_add(&entry->item, &blockpool->free_block_list);
+                blockpool->pool_size++;
+                status = VXGE_HW_OK;
+        } else
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
-                goto exit;
-        }
 
-        vp->vpath->ringh = ring;
-        ring->vp_id = vp_id;
-        ring->vp_reg = vp->vpath->vp_reg;
-        ring->common_reg = hldev->common_reg;
-        ring->stats = &vp->vpath->sw_stats->ring_stats;
-        ring->config = config;
-        ring->callback = attr->callback;
-        ring->rxd_init = attr->rxd_init;
-        ring->rxd_term = attr->rxd_term;
-        ring->buffer_mode = config->buffer_mode;
-        ring->rxds_limit = config->rxds_limit;
+        blockpool->req_out--;
 
-        ring->rxd_size = vxge_hw_ring_rxd_size_get(config->buffer_mode);
-        ring->rxd_priv_size =
-                sizeof(struct __vxge_hw_ring_rxd_priv) + attr->per_rxd_space;
-        ring->per_rxd_space = attr->per_rxd_space;
+        req_out = blockpool->req_out;
+exit:
+        return;
+}
 
-        ring->rxd_priv_size =
-                ((ring->rxd_priv_size + VXGE_CACHE_LINE_SIZE - 1) /
-                VXGE_CACHE_LINE_SIZE) * VXGE_CACHE_LINE_SIZE;
+static inline void
+vxge_os_dma_malloc_async(struct pci_dev *pdev, void *devh, unsigned long size)
+{
+        gfp_t flags;
+        void *vaddr;
 
-        /* how many RxDs can fit into one block. Depends on configured
-         * buffer_mode. */
-        ring->rxds_per_block =
-                vxge_hw_ring_rxds_per_block_get(config->buffer_mode);
+        if (in_interrupt())
+                flags = GFP_ATOMIC | GFP_DMA;
+        else
+                flags = GFP_KERNEL | GFP_DMA;
 
-        /* calculate actual RxD block private size */
-        ring->rxdblock_priv_size = ring->rxd_priv_size * ring->rxds_per_block;
-        ring_mp_callback.item_func_alloc = __vxge_hw_ring_mempool_item_alloc;
-        ring->mempool = __vxge_hw_mempool_create(hldev,
-                                VXGE_HW_BLOCK_SIZE,
-                                VXGE_HW_BLOCK_SIZE,
-                                ring->rxdblock_priv_size,
-                                ring->config->ring_blocks,
-                                ring->config->ring_blocks,
-                                &ring_mp_callback,
-                                ring);
+        vaddr = kmalloc((size), flags);
 
-        if (ring->mempool == NULL) {
-                __vxge_hw_ring_delete(vp);
-                return VXGE_HW_ERR_OUT_OF_MEMORY;
-        }
+        vxge_hw_blockpool_block_add(devh, vaddr, size, pdev, pdev);
+}
 
-        status = __vxge_hw_channel_initialize(&ring->channel);
-        if (status != VXGE_HW_OK) {
-                __vxge_hw_ring_delete(vp);
-                goto exit;
+/*
+ * __vxge_hw_blockpool_blocks_add - Request additional blocks
+ */
+static
+void __vxge_hw_blockpool_blocks_add(struct __vxge_hw_blockpool *blockpool)
+{
+        u32 nreq = 0, i;
+
+        if ((blockpool->pool_size  +  blockpool->req_out) <
+                VXGE_HW_MIN_DMA_BLOCK_POOL_SIZE) {
+                nreq = VXGE_HW_INCR_DMA_BLOCK_POOL_SIZE;
+                blockpool->req_out += nreq;
         }
 
-        /* Note:
-         * Specifying rxd_init callback means two things:
-         * 1) rxds need to be initialized by driver at channel-open time;
-         * 2) rxds need to be posted at channel-open time
-         *    (that's what the initial_replenish() below does)
-         * Currently we don't have a case when the 1) is done without the 2).
-         */
-        if (ring->rxd_init) {
-                status = vxge_hw_ring_replenish(ring);
-                if (status != VXGE_HW_OK) {
-                        __vxge_hw_ring_delete(vp);
+        for (i = 0; i < nreq; i++)
+                vxge_os_dma_malloc_async(
+                        ((struct __vxge_hw_device *)blockpool->hldev)->pdev,
+                        blockpool->hldev, VXGE_HW_BLOCK_SIZE);
+}
+
+/*
+ * __vxge_hw_blockpool_malloc - Allocate a memory block from pool
+ * Allocates a block of memory of given size, either from block pool
+ * or by calling vxge_os_dma_malloc()
+ */
+static void *__vxge_hw_blockpool_malloc(struct __vxge_hw_device *devh, u32 size,
+                                        struct vxge_hw_mempool_dma *dma_object)
+{
+        struct __vxge_hw_blockpool_entry *entry = NULL;
+        struct __vxge_hw_blockpool  *blockpool;
+        void *memblock = NULL;
+        enum vxge_hw_status status = VXGE_HW_OK;
+
+        blockpool = &devh->block_pool;
+
+        if (size != blockpool->block_size) {
+
+                memblock = vxge_os_dma_malloc(devh->pdev, size,
+                                                &dma_object->handle,
+                                                &dma_object->acc_handle);
+
+                if (memblock == NULL) {
+                        status = VXGE_HW_ERR_OUT_OF_MEMORY;
                         goto exit;
                 }
-        }
 
-        /* initial replenish will increment the counter in its post() routine,
-         * we have to reset it */
-        ring->stats->common_stats.usage_cnt = 0;
+                dma_object->addr = pci_map_single(devh->pdev, memblock, size,
+                                        PCI_DMA_BIDIRECTIONAL);
+
+                if (unlikely(pci_dma_mapping_error(devh->pdev,
+                                dma_object->addr))) {
+                        vxge_os_dma_free(devh->pdev, memblock,
+                                &dma_object->acc_handle);
+                        status = VXGE_HW_ERR_OUT_OF_MEMORY;
+                        goto exit;
+                }
+
+        } else {
+
+                if (!list_empty(&blockpool->free_block_list))
+                        entry = (struct __vxge_hw_blockpool_entry *)
+                                list_first_entry(&blockpool->free_block_list,
+                                        struct __vxge_hw_blockpool_entry,
+                                        item);
+
+                if (entry != NULL) {
+                        list_del(&entry->item);
+                        dma_object->addr = entry->dma_addr;
+                        dma_object->handle = entry->dma_handle;
+                        dma_object->acc_handle = entry->acc_handle;
+                        memblock = entry->memblock;
+
+                        list_add(&entry->item,
+                                &blockpool->free_entry_list);
+                        blockpool->pool_size--;
+                }
+
+                if (memblock != NULL)
+                        __vxge_hw_blockpool_blocks_add(blockpool);
+        }
 exit:
-        return status;
+        return memblock;
 }
 
 /*
- * __vxge_hw_ring_abort - Returns the RxD
- * This function terminates the RxDs of ring
+ * __vxge_hw_blockpool_blocks_remove - Free additional blocks
  */
-enum vxge_hw_status __vxge_hw_ring_abort(struct __vxge_hw_ring *ring)
+static void
+__vxge_hw_blockpool_blocks_remove(struct __vxge_hw_blockpool *blockpool)
 {
-        void *rxdh;
-        struct __vxge_hw_channel *channel;
-
-        channel = &ring->channel;
+        struct list_head *p, *n;
 
-        for (;;) {
-                vxge_hw_channel_dtr_try_complete(channel, &rxdh);
+        list_for_each_safe(p, n, &blockpool->free_block_list) {
 
-                if (rxdh == NULL)
+                if (blockpool->pool_size < blockpool->pool_max)
                         break;
 
-                vxge_hw_channel_dtr_complete(channel);
+                pci_unmap_single(
+                        ((struct __vxge_hw_device *)blockpool->hldev)->pdev,
+                        ((struct __vxge_hw_blockpool_entry *)p)->dma_addr,
+                        ((struct __vxge_hw_blockpool_entry *)p)->length,
+                        PCI_DMA_BIDIRECTIONAL);
 
-                if (ring->rxd_term)
-                        ring->rxd_term(rxdh, VXGE_HW_RXD_STATE_POSTED,
-                                channel->userdata);
+                vxge_os_dma_free(
+                        ((struct __vxge_hw_device *)blockpool->hldev)->pdev,
+                        ((struct __vxge_hw_blockpool_entry *)p)->memblock,
+                        &((struct __vxge_hw_blockpool_entry *)p)->acc_handle);
 
-                vxge_hw_channel_dtr_free(channel, rxdh);
-        }
+                list_del(&((struct __vxge_hw_blockpool_entry *)p)->item);
 
-        return VXGE_HW_OK;
+                list_add(p, &blockpool->free_entry_list);
+
+                blockpool->pool_size--;
+
+        }
 }
 
 /*
- * __vxge_hw_ring_reset - Resets the ring
- * This function resets the ring during vpath reset operation
+ * __vxge_hw_blockpool_free - Frees the memory allcoated with
+ *                              __vxge_hw_blockpool_malloc
  */
-enum vxge_hw_status __vxge_hw_ring_reset(struct __vxge_hw_ring *ring)
+static void __vxge_hw_blockpool_free(struct __vxge_hw_device *devh,
+                                     void *memblock, u32 size,
+                                     struct vxge_hw_mempool_dma *dma_object)
 {
+        struct __vxge_hw_blockpool_entry *entry = NULL;
+        struct __vxge_hw_blockpool  *blockpool;
         enum vxge_hw_status status = VXGE_HW_OK;
-        struct __vxge_hw_channel *channel;
 
-        channel = &ring->channel;
+        blockpool = &devh->block_pool;
 
-        __vxge_hw_ring_abort(ring);
+        if (size != blockpool->block_size) {
+                pci_unmap_single(devh->pdev, dma_object->addr, size,
+                        PCI_DMA_BIDIRECTIONAL);
+                vxge_os_dma_free(devh->pdev, memblock, &dma_object->acc_handle);
+        } else {
 
-        status = __vxge_hw_channel_reset(channel);
+                if (!list_empty(&blockpool->free_entry_list))
+                        entry = (struct __vxge_hw_blockpool_entry *)
+                                list_first_entry(&blockpool->free_entry_list,
+                                        struct __vxge_hw_blockpool_entry,
+                                        item);
 
-        if (status != VXGE_HW_OK)
-                goto exit;
+                if (entry == NULL)
+                        entry = vmalloc(sizeof(
+                                        struct __vxge_hw_blockpool_entry));
+                else
+                        list_del(&entry->item);
 
-        if (ring->rxd_init) {
-                status = vxge_hw_ring_replenish(ring);
-                if (status != VXGE_HW_OK)
-                        goto exit;
+                if (entry != NULL) {
+                        entry->length = size;
+                        entry->memblock = memblock;
+                        entry->dma_addr = dma_object->addr;
+                        entry->acc_handle = dma_object->acc_handle;
+                        entry->dma_handle = dma_object->handle;
+                        list_add(&entry->item,
+                                        &blockpool->free_block_list);
+                        blockpool->pool_size++;
+                        status = VXGE_HW_OK;
+                } else
+                        status = VXGE_HW_ERR_OUT_OF_MEMORY;
+
+                if (status == VXGE_HW_OK)
+                        __vxge_hw_blockpool_blocks_remove(blockpool);
         }
-exit:
-        return status;
 }
 
 /*
- * __vxge_hw_ring_delete - Removes the ring
- * This function freeup the memory pool and removes the ring
+ * vxge_hw_mempool_destroy
  */
-enum vxge_hw_status __vxge_hw_ring_delete(struct __vxge_hw_vpath_handle *vp)
+static void __vxge_hw_mempool_destroy(struct vxge_hw_mempool *mempool)
 {
-        struct __vxge_hw_ring *ring = vp->vpath->ringh;
+        u32 i, j;
+        struct __vxge_hw_device *devh = mempool->devh;
 
-        __vxge_hw_ring_abort(ring);
+        for (i = 0; i < mempool->memblocks_allocated; i++) {
+                struct vxge_hw_mempool_dma *dma_object;
 
-        if (ring->mempool)
-                __vxge_hw_mempool_destroy(ring->mempool);
+                vxge_assert(mempool->memblocks_arr[i]);
+                vxge_assert(mempool->memblocks_dma_arr + i);
 
-        vp->vpath->ringh = NULL;
-        __vxge_hw_channel_free(&ring->channel);
+                dma_object = mempool->memblocks_dma_arr + i;
 
-        return VXGE_HW_OK;
+                for (j = 0; j < mempool->items_per_memblock; j++) {
+                        u32 index = i * mempool->items_per_memblock + j;
+
+                        /* to skip last partially filled(if any) memblock */
+                        if (index >= mempool->items_current)
+                                break;
+                }
+
+                vfree(mempool->memblocks_priv_arr[i]);
+
+                __vxge_hw_blockpool_free(devh, mempool->memblocks_arr[i],
+                                mempool->memblock_size, dma_object);
+        }
+
+        vfree(mempool->items_arr);
+        vfree(mempool->memblocks_dma_arr);
+        vfree(mempool->memblocks_priv_arr);
+        vfree(mempool->memblocks_arr);
+        vfree(mempool);
 }
 
 /*
  * __vxge_hw_mempool_grow
  * Will resize mempool up to %num_allocate value.
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_mempool_grow(struct vxge_hw_mempool *mempool, u32 num_allocate,
                        u32 *num_allocated)
 {
@@ -1468,15 +2586,12 @@ __vxge_hw_mempool_grow(struct vxge_hw_mempool *mempool, u32 num_allocate,
                  * allocate new memblock and its private part at once.
                  * This helps to minimize memory usage a lot. */
                 mempool->memblocks_priv_arr[i] =
-                                vmalloc(mempool->items_priv_size * n_items);
+                                vzalloc(mempool->items_priv_size * n_items);
                 if (mempool->memblocks_priv_arr[i] == NULL) {
                         status = VXGE_HW_ERR_OUT_OF_MEMORY;
                         goto exit;
                 }
 
-                memset(mempool->memblocks_priv_arr[i], 0,
-                             mempool->items_priv_size * n_items);
-
                 /* allocate DMA-capable memblock */
                 mempool->memblocks_arr[i] =
                         __vxge_hw_blockpool_malloc(mempool->devh,
@@ -1527,16 +2642,15 @@ exit:
  * with size enough to hold %items_initial number of items. Memory is
  * DMA-able but client must map/unmap before interoperating with the device.
  */
-struct vxge_hw_mempool*
-__vxge_hw_mempool_create(
-        struct __vxge_hw_device *devh,
-        u32 memblock_size,
-        u32 item_size,
-        u32 items_priv_size,
-        u32 items_initial,
-        u32 items_max,
-        struct vxge_hw_mempool_cbs *mp_callback,
-        void *userdata)
+static struct vxge_hw_mempool *
+__vxge_hw_mempool_create(struct __vxge_hw_device *devh,
+                         u32 memblock_size,
+                         u32 item_size,
+                         u32 items_priv_size,
+                         u32 items_initial,
+                         u32 items_max,
+                         struct vxge_hw_mempool_cbs *mp_callback,
+                         void *userdata)
 {
         enum vxge_hw_status status = VXGE_HW_OK;
         u32 memblocks_to_allocate;
@@ -1548,13 +2662,11 @@ __vxge_hw_mempool_create(
                 goto exit;
         }
 
-        mempool = (struct vxge_hw_mempool *)
-                        vmalloc(sizeof(struct vxge_hw_mempool));
+        mempool = vzalloc(sizeof(struct vxge_hw_mempool));
         if (mempool == NULL) {
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 goto exit;
         }
-        memset(mempool, 0, sizeof(struct vxge_hw_mempool));
 
         mempool->devh                   = devh;
         mempool->memblock_size          = memblock_size;
@@ -1574,53 +2686,43 @@ __vxge_hw_mempool_create(
 
         /* allocate array of memblocks */
         mempool->memblocks_arr =
-                (void **) vmalloc(sizeof(void *) * mempool->memblocks_max);
+                vzalloc(sizeof(void *) * mempool->memblocks_max);
         if (mempool->memblocks_arr == NULL) {
                 __vxge_hw_mempool_destroy(mempool);
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 mempool = NULL;
                 goto exit;
         }
-        memset(mempool->memblocks_arr, 0,
-                sizeof(void *) * mempool->memblocks_max);
 
         /* allocate array of private parts of items per memblocks */
         mempool->memblocks_priv_arr =
-                (void **) vmalloc(sizeof(void *) * mempool->memblocks_max);
+                vzalloc(sizeof(void *) * mempool->memblocks_max);
         if (mempool->memblocks_priv_arr == NULL) {
                 __vxge_hw_mempool_destroy(mempool);
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 mempool = NULL;
                 goto exit;
         }
-        memset(mempool->memblocks_priv_arr, 0,
-                    sizeof(void *) * mempool->memblocks_max);
 
         /* allocate array of memblocks DMA objects */
-        mempool->memblocks_dma_arr = (struct vxge_hw_mempool_dma *)
-                vmalloc(sizeof(struct vxge_hw_mempool_dma) *
+        mempool->memblocks_dma_arr =
+                vzalloc(sizeof(struct vxge_hw_mempool_dma) *
                         mempool->memblocks_max);
-
         if (mempool->memblocks_dma_arr == NULL) {
                 __vxge_hw_mempool_destroy(mempool);
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 mempool = NULL;
                 goto exit;
         }
-        memset(mempool->memblocks_dma_arr, 0,
-                        sizeof(struct vxge_hw_mempool_dma) *
-                        mempool->memblocks_max);
 
         /* allocate hash array of items */
-        mempool->items_arr =
-                (void **) vmalloc(sizeof(void *) * mempool->items_max);
+        mempool->items_arr = vzalloc(sizeof(void *) * mempool->items_max);
         if (mempool->items_arr == NULL) {
                 __vxge_hw_mempool_destroy(mempool);
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 mempool = NULL;
                 goto exit;
         }
-        memset(mempool->items_arr, 0, sizeof(void *) * mempool->items_max);
 
         /* calculate initial number of memblocks */
         memblocks_to_allocate = (mempool->items_initial +
@@ -1642,122 +2744,190 @@ exit:
 }
 
 /*
- * vxge_hw_mempool_destroy
+ * __vxge_hw_ring_abort - Returns the RxD
+ * This function terminates the RxDs of ring
  */
-void __vxge_hw_mempool_destroy(struct vxge_hw_mempool *mempool)
+static enum vxge_hw_status __vxge_hw_ring_abort(struct __vxge_hw_ring *ring)
 {
-        u32 i, j;
-        struct __vxge_hw_device *devh = mempool->devh;
-
-        for (i = 0; i < mempool->memblocks_allocated; i++) {
-                struct vxge_hw_mempool_dma *dma_object;
+        void *rxdh;
+        struct __vxge_hw_channel *channel;
 
-                vxge_assert(mempool->memblocks_arr[i]);
-                vxge_assert(mempool->memblocks_dma_arr + i);
+        channel = &ring->channel;
 
-                dma_object = mempool->memblocks_dma_arr + i;
+        for (;;) {
+                vxge_hw_channel_dtr_try_complete(channel, &rxdh);
 
-                for (j = 0; j < mempool->items_per_memblock; j++) {
-                        u32 index = i * mempool->items_per_memblock + j;
+                if (rxdh == NULL)
+                        break;
 
-                        /* to skip last partially filled(if any) memblock */
-                        if (index >= mempool->items_current)
-                                break;
-                }
+                vxge_hw_channel_dtr_complete(channel);
 
-                vfree(mempool->memblocks_priv_arr[i]);
+                if (ring->rxd_term)
+                        ring->rxd_term(rxdh, VXGE_HW_RXD_STATE_POSTED,
+                                channel->userdata);
 
-                __vxge_hw_blockpool_free(devh, mempool->memblocks_arr[i],
-                                mempool->memblock_size, dma_object);
+                vxge_hw_channel_dtr_free(channel, rxdh);
         }
 
-        vfree(mempool->items_arr);
+        return VXGE_HW_OK;
+}
 
-        vfree(mempool->memblocks_dma_arr);
+/*
+ * __vxge_hw_ring_reset - Resets the ring
+ * This function resets the ring during vpath reset operation
+ */
+static enum vxge_hw_status __vxge_hw_ring_reset(struct __vxge_hw_ring *ring)
+{
+        enum vxge_hw_status status = VXGE_HW_OK;
+        struct __vxge_hw_channel *channel;
 
-        vfree(mempool->memblocks_priv_arr);
+        channel = &ring->channel;
 
-        vfree(mempool->memblocks_arr);
+        __vxge_hw_ring_abort(ring);
 
-        vfree(mempool);
+        status = __vxge_hw_channel_reset(channel);
+
+        if (status != VXGE_HW_OK)
+                goto exit;
+
+        if (ring->rxd_init) {
+                status = vxge_hw_ring_replenish(ring);
+                if (status != VXGE_HW_OK)
+                        goto exit;
+        }
+exit:
+        return status;
 }
 
 /*
- * __vxge_hw_device_fifo_config_check - Check fifo configuration.
- * Check the fifo configuration
+ * __vxge_hw_ring_delete - Removes the ring
+ * This function freeup the memory pool and removes the ring
  */
-enum vxge_hw_status
-__vxge_hw_device_fifo_config_check(struct vxge_hw_fifo_config *fifo_config)
+static enum vxge_hw_status
+__vxge_hw_ring_delete(struct __vxge_hw_vpath_handle *vp)
 {
-        if ((fifo_config->fifo_blocks < VXGE_HW_MIN_FIFO_BLOCKS) ||
-             (fifo_config->fifo_blocks > VXGE_HW_MAX_FIFO_BLOCKS))
-                return VXGE_HW_BADCFG_FIFO_BLOCKS;
+        struct __vxge_hw_ring *ring = vp->vpath->ringh;
+
+        __vxge_hw_ring_abort(ring);
+
+        if (ring->mempool)
+                __vxge_hw_mempool_destroy(ring->mempool);
+
+        vp->vpath->ringh = NULL;
+        __vxge_hw_channel_free(&ring->channel);
 
         return VXGE_HW_OK;
 }
 
 /*
- * __vxge_hw_device_vpath_config_check - Check vpath configuration.
- * Check the vpath configuration
+ * __vxge_hw_ring_create - Create a Ring
+ * This function creates Ring and initializes it.
  */
-enum vxge_hw_status
-__vxge_hw_device_vpath_config_check(struct vxge_hw_vp_config *vp_config)
+static enum vxge_hw_status
+__vxge_hw_ring_create(struct __vxge_hw_vpath_handle *vp,
+                      struct vxge_hw_ring_attr *attr)
 {
-        enum vxge_hw_status status;
+        enum vxge_hw_status status = VXGE_HW_OK;
+        struct __vxge_hw_ring *ring;
+        u32 ring_length;
+        struct vxge_hw_ring_config *config;
+        struct __vxge_hw_device *hldev;
+        u32 vp_id;
+        struct vxge_hw_mempool_cbs ring_mp_callback;
 
-        if ((vp_config->min_bandwidth < VXGE_HW_VPATH_BANDWIDTH_MIN) ||
-                (vp_config->min_bandwidth >
-                                        VXGE_HW_VPATH_BANDWIDTH_MAX))
-                return VXGE_HW_BADCFG_VPATH_MIN_BANDWIDTH;
+        if ((vp == NULL) || (attr == NULL)) {
+                status = VXGE_HW_FAIL;
+                goto exit;
+        }
 
-        status = __vxge_hw_device_fifo_config_check(&vp_config->fifo);
-        if (status != VXGE_HW_OK)
-                return status;
+        hldev = vp->vpath->hldev;
+        vp_id = vp->vpath->vp_id;
 
-        if ((vp_config->mtu != VXGE_HW_VPATH_USE_FLASH_DEFAULT_INITIAL_MTU) &&
-                ((vp_config->mtu < VXGE_HW_VPATH_MIN_INITIAL_MTU) ||
-                (vp_config->mtu > VXGE_HW_VPATH_MAX_INITIAL_MTU)))
-                return VXGE_HW_BADCFG_VPATH_MTU;
+        config = &hldev->config.vp_config[vp_id].ring;
 
-        if ((vp_config->rpa_strip_vlan_tag !=
-                VXGE_HW_VPATH_RPA_STRIP_VLAN_TAG_USE_FLASH_DEFAULT) &&
-                (vp_config->rpa_strip_vlan_tag !=
-                VXGE_HW_VPATH_RPA_STRIP_VLAN_TAG_ENABLE) &&
-                (vp_config->rpa_strip_vlan_tag !=
-                VXGE_HW_VPATH_RPA_STRIP_VLAN_TAG_DISABLE))
-                return VXGE_HW_BADCFG_VPATH_RPA_STRIP_VLAN_TAG;
+        ring_length = config->ring_blocks *
+                        vxge_hw_ring_rxds_per_block_get(config->buffer_mode);
 
-        return VXGE_HW_OK;
-}
+        ring = (struct __vxge_hw_ring *)__vxge_hw_channel_allocate(vp,
+                                                VXGE_HW_CHANNEL_TYPE_RING,
+                                                ring_length,
+                                                attr->per_rxd_space,
+                                                attr->userdata);
+        if (ring == NULL) {
+                status = VXGE_HW_ERR_OUT_OF_MEMORY;
+                goto exit;
+        }
 
-/*
- * __vxge_hw_device_config_check - Check device configuration.
- * Check the device configuration
- */
-enum vxge_hw_status
-__vxge_hw_device_config_check(struct vxge_hw_device_config *new_config)
-{
-        u32 i;
-        enum vxge_hw_status status;
+        vp->vpath->ringh = ring;
+        ring->vp_id = vp_id;
+        ring->vp_reg = vp->vpath->vp_reg;
+        ring->common_reg = hldev->common_reg;
+        ring->stats = &vp->vpath->sw_stats->ring_stats;
+        ring->config = config;
+        ring->callback = attr->callback;
+        ring->rxd_init = attr->rxd_init;
+        ring->rxd_term = attr->rxd_term;
+        ring->buffer_mode = config->buffer_mode;
+        ring->tim_rti_cfg1_saved = vp->vpath->tim_rti_cfg1_saved;
+        ring->tim_rti_cfg3_saved = vp->vpath->tim_rti_cfg3_saved;
+        ring->rxds_limit = config->rxds_limit;
 
-        if ((new_config->intr_mode != VXGE_HW_INTR_MODE_IRQLINE) &&
-           (new_config->intr_mode != VXGE_HW_INTR_MODE_MSIX) &&
-           (new_config->intr_mode != VXGE_HW_INTR_MODE_MSIX_ONE_SHOT) &&
-           (new_config->intr_mode != VXGE_HW_INTR_MODE_DEF))
-                return VXGE_HW_BADCFG_INTR_MODE;
+        ring->rxd_size = vxge_hw_ring_rxd_size_get(config->buffer_mode);
+        ring->rxd_priv_size =
+                sizeof(struct __vxge_hw_ring_rxd_priv) + attr->per_rxd_space;
+        ring->per_rxd_space = attr->per_rxd_space;
 
-        if ((new_config->rts_mac_en != VXGE_HW_RTS_MAC_DISABLE) &&
-           (new_config->rts_mac_en != VXGE_HW_RTS_MAC_ENABLE))
-                return VXGE_HW_BADCFG_RTS_MAC_EN;
+        ring->rxd_priv_size =
+                ((ring->rxd_priv_size + VXGE_CACHE_LINE_SIZE - 1) /
+                VXGE_CACHE_LINE_SIZE) * VXGE_CACHE_LINE_SIZE;
 
-        for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
-                status = __vxge_hw_device_vpath_config_check(
-                                &new_config->vp_config[i]);
-                if (status != VXGE_HW_OK)
-                        return status;
+        /* how many RxDs can fit into one block. Depends on configured
+         * buffer_mode. */
+        ring->rxds_per_block =
+                vxge_hw_ring_rxds_per_block_get(config->buffer_mode);
+
+        /* calculate actual RxD block private size */
+        ring->rxdblock_priv_size = ring->rxd_priv_size * ring->rxds_per_block;
+        ring_mp_callback.item_func_alloc = __vxge_hw_ring_mempool_item_alloc;
+        ring->mempool = __vxge_hw_mempool_create(hldev,
+                                VXGE_HW_BLOCK_SIZE,
+                                VXGE_HW_BLOCK_SIZE,
+                                ring->rxdblock_priv_size,
+                                ring->config->ring_blocks,
+                                ring->config->ring_blocks,
+                                &ring_mp_callback,
+                                ring);
+        if (ring->mempool == NULL) {
+                __vxge_hw_ring_delete(vp);
+                return VXGE_HW_ERR_OUT_OF_MEMORY;
         }
 
-        return VXGE_HW_OK;
+        status = __vxge_hw_channel_initialize(&ring->channel);
+        if (status != VXGE_HW_OK) {
+                __vxge_hw_ring_delete(vp);
+                goto exit;
+        }
+
+        /* Note:
+         * Specifying rxd_init callback means two things:
+         * 1) rxds need to be initialized by driver at channel-open time;
+         * 2) rxds need to be posted at channel-open time
+         *    (that's what the initial_replenish() below does)
+         * Currently we don't have a case when the 1) is done without the 2).
+         */
+        if (ring->rxd_init) {
+                status = vxge_hw_ring_replenish(ring);
+                if (status != VXGE_HW_OK) {
+                        __vxge_hw_ring_delete(vp);
+                        goto exit;
+                }
+        }
+
+        /* initial replenish will increment the counter in its post() routine,
+         * we have to reset it */
+        ring->stats->common_stats.usage_cnt = 0;
+exit:
+        return status;
 }
 
 /*
@@ -1779,7 +2949,6 @@ vxge_hw_device_config_default_get(struct vxge_hw_device_config *device_config)
         device_config->rts_mac_en =  VXGE_HW_RTS_MAC_DEFAULT;
 
         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
-
                 device_config->vp_config[i].vp_id = i;
 
                 device_config->vp_config[i].min_bandwidth =
@@ -1919,65 +3088,10 @@ vxge_hw_device_config_default_get(struct vxge_hw_device_config *device_config)
 }
 
 /*
- * _hw_legacy_swapper_set - Set the swapper bits for the legacy secion.
- * Set the swapper bits appropriately for the lagacy section.
- */
-enum vxge_hw_status
-__vxge_hw_legacy_swapper_set(struct vxge_hw_legacy_reg __iomem *legacy_reg)
-{
-        u64 val64;
-        enum vxge_hw_status status = VXGE_HW_OK;
-
-        val64 = readq(&legacy_reg->toc_swapper_fb);
-
-        wmb();
-
-        switch (val64) {
-
-        case VXGE_HW_SWAPPER_INITIAL_VALUE:
-                return status;
-
-        case VXGE_HW_SWAPPER_BYTE_SWAPPED_BIT_FLIPPED:
-                writeq(VXGE_HW_SWAPPER_READ_BYTE_SWAP_ENABLE,
-                        &legacy_reg->pifm_rd_swap_en);
-                writeq(VXGE_HW_SWAPPER_READ_BIT_FLAP_ENABLE,
-                        &legacy_reg->pifm_rd_flip_en);
-                writeq(VXGE_HW_SWAPPER_WRITE_BYTE_SWAP_ENABLE,
-                        &legacy_reg->pifm_wr_swap_en);
-                writeq(VXGE_HW_SWAPPER_WRITE_BIT_FLAP_ENABLE,
-                        &legacy_reg->pifm_wr_flip_en);
-                break;
-
-        case VXGE_HW_SWAPPER_BYTE_SWAPPED:
-                writeq(VXGE_HW_SWAPPER_READ_BYTE_SWAP_ENABLE,
-                        &legacy_reg->pifm_rd_swap_en);
-                writeq(VXGE_HW_SWAPPER_WRITE_BYTE_SWAP_ENABLE,
-                        &legacy_reg->pifm_wr_swap_en);
-                break;
-
-        case VXGE_HW_SWAPPER_BIT_FLIPPED:
-                writeq(VXGE_HW_SWAPPER_READ_BIT_FLAP_ENABLE,
-                        &legacy_reg->pifm_rd_flip_en);
-                writeq(VXGE_HW_SWAPPER_WRITE_BIT_FLAP_ENABLE,
-                        &legacy_reg->pifm_wr_flip_en);
-                break;
-        }
-
-        wmb();
-
-        val64 = readq(&legacy_reg->toc_swapper_fb);
-
-        if (val64 != VXGE_HW_SWAPPER_INITIAL_VALUE)
-                status = VXGE_HW_ERR_SWAPPER_CTRL;
-
-        return status;
-}
-
-/*
  * __vxge_hw_vpath_swapper_set - Set the swapper bits for the vpath.
  * Set the swapper bits appropriately for the vpath.
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_vpath_swapper_set(struct vxge_hw_vpath_reg __iomem *vpath_reg)
 {
 #ifndef __BIG_ENDIAN
@@ -1996,10 +3110,9 @@ __vxge_hw_vpath_swapper_set(struct vxge_hw_vpath_reg __iomem *vpath_reg)
  * __vxge_hw_kdfc_swapper_set - Set the swapper bits for the kdfc.
  * Set the swapper bits appropriately for the vpath.
  */
-enum vxge_hw_status
-__vxge_hw_kdfc_swapper_set(
-        struct vxge_hw_legacy_reg __iomem *legacy_reg,
-        struct vxge_hw_vpath_reg __iomem *vpath_reg)
+static enum vxge_hw_status
+__vxge_hw_kdfc_swapper_set(struct vxge_hw_legacy_reg __iomem *legacy_reg,
+                           struct vxge_hw_vpath_reg __iomem *vpath_reg)
 {
         u64 val64;
 
@@ -2021,28 +3134,6 @@ __vxge_hw_kdfc_swapper_set(
 }
 
 /*
- * vxge_hw_mgmt_device_config - Retrieve device configuration.
- * Get device configuration. Permits to retrieve at run-time configuration
- * values that were used to initialize and configure the device.
- */
-enum vxge_hw_status
-vxge_hw_mgmt_device_config(struct __vxge_hw_device *hldev,
-                           struct vxge_hw_device_config *dev_config, int size)
-{
-
-        if ((hldev == NULL) || (hldev->magic != VXGE_HW_DEVICE_MAGIC))
-                return VXGE_HW_ERR_INVALID_DEVICE;
-
-        if (size != sizeof(struct vxge_hw_device_config))
-                return VXGE_HW_ERR_VERSION_CONFLICT;
-
-        memcpy(dev_config, &hldev->config,
-                sizeof(struct vxge_hw_device_config));
-
-        return VXGE_HW_OK;
-}
-
-/*
  * vxge_hw_mgmt_reg_read - Read Titan register.
  */
 enum vxge_hw_status
@@ -2271,6 +3362,69 @@ exit:
 }
 
 /*
+ * __vxge_hw_fifo_abort - Returns the TxD
+ * This function terminates the TxDs of fifo
+ */
+static enum vxge_hw_status __vxge_hw_fifo_abort(struct __vxge_hw_fifo *fifo)
+{
+        void *txdlh;
+
+        for (;;) {
+                vxge_hw_channel_dtr_try_complete(&fifo->channel, &txdlh);
+
+                if (txdlh == NULL)
+                        break;
+
+                vxge_hw_channel_dtr_complete(&fifo->channel);
+
+                if (fifo->txdl_term) {
+                        fifo->txdl_term(txdlh,
+                        VXGE_HW_TXDL_STATE_POSTED,
+                        fifo->channel.userdata);
+                }
+
+                vxge_hw_channel_dtr_free(&fifo->channel, txdlh);
+        }
+
+        return VXGE_HW_OK;
+}
+
+/*
+ * __vxge_hw_fifo_reset - Resets the fifo
+ * This function resets the fifo during vpath reset operation
+ */
+static enum vxge_hw_status __vxge_hw_fifo_reset(struct __vxge_hw_fifo *fifo)
+{
+        enum vxge_hw_status status = VXGE_HW_OK;
+
+        __vxge_hw_fifo_abort(fifo);
+        status = __vxge_hw_channel_reset(&fifo->channel);
+
+        return status;
+}
+
+/*
+ * __vxge_hw_fifo_delete - Removes the FIFO
+ * This function freeup the memory pool and removes the FIFO
+ */
+static enum vxge_hw_status
+__vxge_hw_fifo_delete(struct __vxge_hw_vpath_handle *vp)
+{
+        struct __vxge_hw_fifo *fifo = vp->vpath->fifoh;
+
+        __vxge_hw_fifo_abort(fifo);
+
+        if (fifo->mempool)
+                __vxge_hw_mempool_destroy(fifo->mempool);
+
+        vp->vpath->fifoh = NULL;
+
+        __vxge_hw_channel_free(&fifo->channel);
+
+        return VXGE_HW_OK;
+}
+
+/*
  * __vxge_hw_fifo_mempool_item_alloc - Allocate List blocks for TxD
  * list callback
  * This function is callback passed to __vxge_hw_mempool_create to create memory
@@ -2316,7 +3470,7 @@ __vxge_hw_fifo_mempool_item_alloc(
  * __vxge_hw_fifo_create - Create a FIFO
  * This function creates FIFO and initializes it.
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_fifo_create(struct __vxge_hw_vpath_handle *vp,
                       struct vxge_hw_fifo_attr *attr)
 {
@@ -2359,6 +3513,8 @@ __vxge_hw_fifo_create(struct __vxge_hw_vpath_handle *vp,
 
         /* apply "interrupts per txdl" attribute */
         fifo->interrupt_type = VXGE_HW_FIFO_TXD_INT_TYPE_UTILZ;
+        fifo->tim_tti_cfg1_saved = vpath->tim_tti_cfg1_saved;
+        fifo->tim_tti_cfg3_saved = vpath->tim_tti_cfg3_saved;
 
         if (fifo->config->intr)
                 fifo->interrupt_type = VXGE_HW_FIFO_TXD_INT_TYPE_PER_LIST;
@@ -2435,73 +3591,11 @@ exit:
 }
 
 /*
- * __vxge_hw_fifo_abort - Returns the TxD
- * This function terminates the TxDs of fifo
- */
-enum vxge_hw_status __vxge_hw_fifo_abort(struct __vxge_hw_fifo *fifo)
-{
-        void *txdlh;
-
-        for (;;) {
-                vxge_hw_channel_dtr_try_complete(&fifo->channel, &txdlh);
-
-                if (txdlh == NULL)
-                        break;
-
-                vxge_hw_channel_dtr_complete(&fifo->channel);
-
-                if (fifo->txdl_term) {
-                        fifo->txdl_term(txdlh,
-                        VXGE_HW_TXDL_STATE_POSTED,
-                        fifo->channel.userdata);
-                }
-
-                vxge_hw_channel_dtr_free(&fifo->channel, txdlh);
-        }
-
-        return VXGE_HW_OK;
-}
-
-/*
- * __vxge_hw_fifo_reset - Resets the fifo
- * This function resets the fifo during vpath reset operation
- */
-enum vxge_hw_status __vxge_hw_fifo_reset(struct __vxge_hw_fifo *fifo)
-{
-        enum vxge_hw_status status = VXGE_HW_OK;
-
-        __vxge_hw_fifo_abort(fifo);
-        status = __vxge_hw_channel_reset(&fifo->channel);
-
-        return status;
-}
-
-/*
- * __vxge_hw_fifo_delete - Removes the FIFO
- * This function freeup the memory pool and removes the FIFO
- */
-enum vxge_hw_status __vxge_hw_fifo_delete(struct __vxge_hw_vpath_handle *vp)
-{
-        struct __vxge_hw_fifo *fifo = vp->vpath->fifoh;
-
-        __vxge_hw_fifo_abort(fifo);
-
-        if (fifo->mempool)
-                __vxge_hw_mempool_destroy(fifo->mempool);
-
-        vp->vpath->fifoh = NULL;
-
-        __vxge_hw_channel_free(&fifo->channel);
-
-        return VXGE_HW_OK;
-}
-
-/*
  * __vxge_hw_vpath_pci_read - Read the content of given address
  *                          in pci config space.
  * Read from the vpath pci config space.
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_vpath_pci_read(struct __vxge_hw_virtualpath *vpath,
                          u32 phy_func_0, u32 offset, u32 *val)
 {
@@ -2538,297 +3632,6 @@ exit:
         return status;
 }
 
-/*
- * __vxge_hw_vpath_func_id_get - Get the function id of the vpath.
- * Returns the function number of the vpath.
- */
-u32
-__vxge_hw_vpath_func_id_get(u32 vp_id,
-        struct vxge_hw_vpmgmt_reg __iomem *vpmgmt_reg)
-{
-        u64 val64;
-
-        val64 = readq(&vpmgmt_reg->vpath_to_func_map_cfg1);
-
-        return
-         (u32)VXGE_HW_VPATH_TO_FUNC_MAP_CFG1_GET_VPATH_TO_FUNC_MAP_CFG1(val64);
-}
-
-/*
- * __vxge_hw_read_rts_ds - Program RTS steering critieria
- */
-static inline void
-__vxge_hw_read_rts_ds(struct vxge_hw_vpath_reg __iomem *vpath_reg,
-                      u64 dta_struct_sel)
-{
-        writeq(0, &vpath_reg->rts_access_steer_ctrl);
-        wmb();
-        writeq(dta_struct_sel, &vpath_reg->rts_access_steer_data0);
-        writeq(0, &vpath_reg->rts_access_steer_data1);
-        wmb();
-}
-
-
-/*
- * __vxge_hw_vpath_card_info_get - Get the serial numbers,
- * part number and product description.
- */
-enum vxge_hw_status
-__vxge_hw_vpath_card_info_get(
-        u32 vp_id,
-        struct vxge_hw_vpath_reg __iomem *vpath_reg,
-        struct vxge_hw_device_hw_info *hw_info)
-{
-        u32 i, j;
-        u64 val64;
-        u64 data1 = 0ULL;
-        u64 data2 = 0ULL;
-        enum vxge_hw_status status = VXGE_HW_OK;
-        u8 *serial_number = hw_info->serial_number;
-        u8 *part_number = hw_info->part_number;
-        u8 *product_desc = hw_info->product_desc;
-
-        __vxge_hw_read_rts_ds(vpath_reg,
-                VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_SERIAL_NUMBER);
-
-        val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_MEMO_ENTRY) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
-
-        status = __vxge_hw_pio_mem_write64(val64,
-                                &vpath_reg->rts_access_steer_ctrl,
-                                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
-                                VXGE_HW_DEF_DEVICE_POLL_MILLIS);
-
-        if (status != VXGE_HW_OK)
-                return status;
-
-        val64 = readq(&vpath_reg->rts_access_steer_ctrl);
-
-        if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
-                data1 = readq(&vpath_reg->rts_access_steer_data0);
-                ((u64 *)serial_number)[0] = be64_to_cpu(data1);
-
-                data2 = readq(&vpath_reg->rts_access_steer_data1);
-                ((u64 *)serial_number)[1] = be64_to_cpu(data2);
-                status = VXGE_HW_OK;
-        } else
-                *serial_number = 0;
-
-        __vxge_hw_read_rts_ds(vpath_reg,
-                        VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PART_NUMBER);
-
-        val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_MEMO_ENTRY) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
-
-        status = __vxge_hw_pio_mem_write64(val64,
-                                &vpath_reg->rts_access_steer_ctrl,
-                                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
-                                VXGE_HW_DEF_DEVICE_POLL_MILLIS);
-
-        if (status != VXGE_HW_OK)
-                return status;
-
-        val64 = readq(&vpath_reg->rts_access_steer_ctrl);
-
-        if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
-
-                data1 = readq(&vpath_reg->rts_access_steer_data0);
-                ((u64 *)part_number)[0] = be64_to_cpu(data1);
-
-                data2 = readq(&vpath_reg->rts_access_steer_data1);
-                ((u64 *)part_number)[1] = be64_to_cpu(data2);
-
-                status = VXGE_HW_OK;
-
-        } else
-                *part_number = 0;
-
-        j = 0;
-
-        for (i = VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_DESC_0;
-             i <= VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_DESC_3; i++) {
-
-                __vxge_hw_read_rts_ds(vpath_reg, i);
-
-                val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_MEMO_ENTRY) |
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
-
-                status = __vxge_hw_pio_mem_write64(val64,
-                                &vpath_reg->rts_access_steer_ctrl,
-                                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
-                                VXGE_HW_DEF_DEVICE_POLL_MILLIS);
-
-                if (status != VXGE_HW_OK)
-                        return status;
-
-                val64 = readq(&vpath_reg->rts_access_steer_ctrl);
-
-                if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
-
-                        data1 = readq(&vpath_reg->rts_access_steer_data0);
-                        ((u64 *)product_desc)[j++] = be64_to_cpu(data1);
-
-                        data2 = readq(&vpath_reg->rts_access_steer_data1);
-                        ((u64 *)product_desc)[j++] = be64_to_cpu(data2);
-
-                        status = VXGE_HW_OK;
-                } else
-                        *product_desc = 0;
-        }
-
-        return status;
-}
-
-/*
- * __vxge_hw_vpath_fw_ver_get - Get the fw version
- * Returns FW Version
- */
-enum vxge_hw_status
-__vxge_hw_vpath_fw_ver_get(
-        u32 vp_id,
-        struct vxge_hw_vpath_reg __iomem *vpath_reg,
-        struct vxge_hw_device_hw_info *hw_info)
-{
-        u64 val64;
-        u64 data1 = 0ULL;
-        u64 data2 = 0ULL;
-        struct vxge_hw_device_version *fw_version = &hw_info->fw_version;
-        struct vxge_hw_device_date *fw_date = &hw_info->fw_date;
-        struct vxge_hw_device_version *flash_version = &hw_info->flash_version;
-        struct vxge_hw_device_date *flash_date = &hw_info->flash_date;
-        enum vxge_hw_status status = VXGE_HW_OK;
-
-        val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_ENTRY) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
-
-        status = __vxge_hw_pio_mem_write64(val64,
-                                &vpath_reg->rts_access_steer_ctrl,
-                                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
-                                VXGE_HW_DEF_DEVICE_POLL_MILLIS);
-
-        if (status != VXGE_HW_OK)
-                goto exit;
-
-        val64 = readq(&vpath_reg->rts_access_steer_ctrl);
-
-        if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
-
-                data1 = readq(&vpath_reg->rts_access_steer_data0);
-                data2 = readq(&vpath_reg->rts_access_steer_data1);
-
-                fw_date->day =
-                        (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_DAY(
-                                                data1);
-                fw_date->month =
-                        (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MONTH(
-                                                data1);
-                fw_date->year =
-                        (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_YEAR(
-                                                data1);
-
-                snprintf(fw_date->date, VXGE_HW_FW_STRLEN, "%2.2d/%2.2d/%4.4d",
-                        fw_date->month, fw_date->day, fw_date->year);
-
-                fw_version->major =
-                    (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MAJOR(data1);
-                fw_version->minor =
-                    (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_MINOR(data1);
-                fw_version->build =
-                    (u32)VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_FW_VER_BUILD(data1);
-
-                snprintf(fw_version->version, VXGE_HW_FW_STRLEN, "%d.%d.%d",
-                    fw_version->major, fw_version->minor, fw_version->build);
-
-                flash_date->day =
-                  (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_DAY(data2);
-                flash_date->month =
-                 (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_MONTH(data2);
-                flash_date->year =
-                 (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_YEAR(data2);
-
-                snprintf(flash_date->date, VXGE_HW_FW_STRLEN,
-                        "%2.2d/%2.2d/%4.4d",
-                        flash_date->month, flash_date->day, flash_date->year);
-
-                flash_version->major =
-                 (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_MAJOR(data2);
-                flash_version->minor =
-                 (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_MINOR(data2);
-                flash_version->build =
-                 (u32)VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_BUILD(data2);
-
-                snprintf(flash_version->version, VXGE_HW_FW_STRLEN, "%d.%d.%d",
-                        flash_version->major, flash_version->minor,
-                        flash_version->build);
-
-                status = VXGE_HW_OK;
-
-        } else
-                status = VXGE_HW_FAIL;
-exit:
-        return status;
-}
-
-/*
- * __vxge_hw_vpath_pci_func_mode_get - Get the pci mode
- * Returns pci function mode
- */
-u64
-__vxge_hw_vpath_pci_func_mode_get(
-        u32  vp_id,
-        struct vxge_hw_vpath_reg __iomem *vpath_reg)
-{
-        u64 val64;
-        u64 data1 = 0ULL;
-        enum vxge_hw_status status = VXGE_HW_OK;
-
-        __vxge_hw_read_rts_ds(vpath_reg,
-                VXGE_HW_RTS_ACCESS_STEER_DATA0_MEMO_ITEM_PCI_MODE);
-
-        val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_MEMO_ENTRY) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
-
-        status = __vxge_hw_pio_mem_write64(val64,
-                                &vpath_reg->rts_access_steer_ctrl,
-                                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
-                                VXGE_HW_DEF_DEVICE_POLL_MILLIS);
-
-        if (status != VXGE_HW_OK)
-                goto exit;
-
-        val64 = readq(&vpath_reg->rts_access_steer_ctrl);
-
-        if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
-                data1 = readq(&vpath_reg->rts_access_steer_data0);
-                status = VXGE_HW_OK;
-        } else {
-                data1 = 0;
-                status = VXGE_HW_FAIL;
-        }
-exit:
-        return data1;
-}
-
 /**
  * vxge_hw_device_flick_link_led - Flick (blink) link LED.
  * @hldev: HW device.
@@ -2837,37 +3640,24 @@ exit:
  * Flicker the link LED.
  */
 enum vxge_hw_status
-vxge_hw_device_flick_link_led(struct __vxge_hw_device *hldev,
-                               u64 on_off)
+vxge_hw_device_flick_link_led(struct __vxge_hw_device *hldev, u64 on_off)
 {
-        u64 val64;
-        enum vxge_hw_status status = VXGE_HW_OK;
-        struct vxge_hw_vpath_reg __iomem *vp_reg;
+        struct __vxge_hw_virtualpath *vpath;
+        u64 data0, data1 = 0, steer_ctrl = 0;
+        enum vxge_hw_status status;
 
         if (hldev == NULL) {
                 status = VXGE_HW_ERR_INVALID_DEVICE;
                 goto exit;
         }
 
-        vp_reg = hldev->vpath_reg[hldev->first_vp_id];
-
-        writeq(0, &vp_reg->rts_access_steer_ctrl);
-        wmb();
-        writeq(on_off, &vp_reg->rts_access_steer_data0);
-        writeq(0, &vp_reg->rts_access_steer_data1);
-        wmb();
+        vpath = &hldev->virtual_paths[hldev->first_vp_id];
 
-        val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_LED_CONTROL) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
-
-        status = __vxge_hw_pio_mem_write64(val64,
-                                &vp_reg->rts_access_steer_ctrl,
-                                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
-                                VXGE_HW_DEF_DEVICE_POLL_MILLIS);
+        data0 = on_off;
+        status = vxge_hw_vpath_fw_api(vpath,
+                        VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_LED_CONTROL,
+                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO,
+                        0, &data0, &data1, &steer_ctrl);
 exit:
         return status;
 }
@@ -2876,63 +3666,38 @@ exit:
  * __vxge_hw_vpath_rts_table_get - Get the entries from RTS access tables
  */
 enum vxge_hw_status
-__vxge_hw_vpath_rts_table_get(
-        struct __vxge_hw_vpath_handle *vp,
-        u32 action, u32 rts_table, u32 offset, u64 *data1, u64 *data2)
+__vxge_hw_vpath_rts_table_get(struct __vxge_hw_vpath_handle *vp,
+                              u32 action, u32 rts_table, u32 offset,
+                              u64 *data0, u64 *data1)
 {
-        u64 val64;
-        struct __vxge_hw_virtualpath *vpath;
-        struct vxge_hw_vpath_reg __iomem *vp_reg;
-
-        enum vxge_hw_status status = VXGE_HW_OK;
+        enum vxge_hw_status status;
+        u64 steer_ctrl = 0;
 
         if (vp == NULL) {
                 status = VXGE_HW_ERR_INVALID_HANDLE;
                 goto exit;
         }
 
-        vpath = vp->vpath;
-        vp_reg = vpath->vp_reg;
-
-        val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(action) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(rts_table) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(offset);
-
         if ((rts_table ==
-                VXGE_HW_RTS_ACS_STEER_CTRL_DATA_STRUCT_SEL_RTH_SOLO_IT) ||
+             VXGE_HW_RTS_ACS_STEER_CTRL_DATA_STRUCT_SEL_RTH_SOLO_IT) ||
             (rts_table ==
-                VXGE_HW_RTS_ACS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT) ||
+             VXGE_HW_RTS_ACS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT) ||
             (rts_table ==
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MASK) ||
+             VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MASK) ||
             (rts_table ==
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_KEY)) {
-                val64 = val64 | VXGE_HW_RTS_ACCESS_STEER_CTRL_TABLE_SEL;
+             VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_KEY)) {
+                steer_ctrl = VXGE_HW_RTS_ACCESS_STEER_CTRL_TABLE_SEL;
         }
 
-        status = __vxge_hw_pio_mem_write64(val64,
-                                &vp_reg->rts_access_steer_ctrl,
-                                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
-                                vpath->hldev->config.device_poll_millis);
-
+        status = vxge_hw_vpath_fw_api(vp->vpath, action, rts_table, offset,
+                                      data0, data1, &steer_ctrl);
         if (status != VXGE_HW_OK)
                 goto exit;
 
-        val64 = readq(&vp_reg->rts_access_steer_ctrl);
-
-        if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
-
-                *data1 = readq(&vp_reg->rts_access_steer_data0);
-
-                if ((rts_table ==
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DA) ||
-                (rts_table ==
-                VXGE_HW_RTS_ACS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT)) {
-                        *data2 = readq(&vp_reg->rts_access_steer_data1);
-                }
-                status = VXGE_HW_OK;
-        } else
-                status = VXGE_HW_FAIL;
+        if ((rts_table != VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DA) &&
+            (rts_table !=
+             VXGE_HW_RTS_ACS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT))
+                *data1 = 0;
 exit:
         return status;
 }
@@ -2941,107 +3706,27 @@ exit:
  * __vxge_hw_vpath_rts_table_set - Set the entries of RTS access tables
  */
 enum vxge_hw_status
-__vxge_hw_vpath_rts_table_set(
-        struct __vxge_hw_vpath_handle *vp, u32 action, u32 rts_table,
-        u32 offset, u64 data1, u64 data2)
+__vxge_hw_vpath_rts_table_set(struct __vxge_hw_vpath_handle *vp, u32 action,
+                              u32 rts_table, u32 offset, u64 steer_data0,
+                              u64 steer_data1)
 {
-        u64 val64;
-        struct __vxge_hw_virtualpath *vpath;
-        enum vxge_hw_status status = VXGE_HW_OK;
-        struct vxge_hw_vpath_reg __iomem *vp_reg;
+        u64 data0, data1 = 0, steer_ctrl = 0;
+        enum vxge_hw_status status;
 
         if (vp == NULL) {
                 status = VXGE_HW_ERR_INVALID_HANDLE;
                 goto exit;
         }
 
-        vpath = vp->vpath;
-        vp_reg = vpath->vp_reg;
-
-        writeq(data1, &vp_reg->rts_access_steer_data0);
-        wmb();
+        data0 = steer_data0;
 
         if ((rts_table == VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DA) ||
             (rts_table ==
-                VXGE_HW_RTS_ACS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT)) {
-                writeq(data2, &vp_reg->rts_access_steer_data1);
-                wmb();
-        }
-
-        val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(action) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(rts_table) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(offset);
-
-        status = __vxge_hw_pio_mem_write64(val64,
-                                &vp_reg->rts_access_steer_ctrl,
-                                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
-                                vpath->hldev->config.device_poll_millis);
-
-        if (status != VXGE_HW_OK)
-                goto exit;
-
-        val64 = readq(&vp_reg->rts_access_steer_ctrl);
+             VXGE_HW_RTS_ACS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT))
+                data1 = steer_data1;
 
-        if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS)
-                status = VXGE_HW_OK;
-        else
-                status = VXGE_HW_FAIL;
-exit:
-        return status;
-}
-
-/*
- * __vxge_hw_vpath_addr_get - Get the hw address entry for this vpath
- *               from MAC address table.
- */
-enum vxge_hw_status
-__vxge_hw_vpath_addr_get(
-        u32 vp_id, struct vxge_hw_vpath_reg __iomem *vpath_reg,
-        u8 (macaddr)[ETH_ALEN], u8 (macaddr_mask)[ETH_ALEN])
-{
-        u32 i;
-        u64 val64;
-        u64 data1 = 0ULL;
-        u64 data2 = 0ULL;
-        enum vxge_hw_status status = VXGE_HW_OK;
-
-        val64 = VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION(
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_LIST_FIRST_ENTRY) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL(
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DA) |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE |
-                VXGE_HW_RTS_ACCESS_STEER_CTRL_OFFSET(0);
-
-        status = __vxge_hw_pio_mem_write64(val64,
-                                &vpath_reg->rts_access_steer_ctrl,
-                                VXGE_HW_RTS_ACCESS_STEER_CTRL_STROBE,
-                                VXGE_HW_DEF_DEVICE_POLL_MILLIS);
-
-        if (status != VXGE_HW_OK)
-                goto exit;
-
-        val64 = readq(&vpath_reg->rts_access_steer_ctrl);
-
-        if (val64 & VXGE_HW_RTS_ACCESS_STEER_CTRL_RMACJ_STATUS) {
-
-                data1 = readq(&vpath_reg->rts_access_steer_data0);
-                data2 = readq(&vpath_reg->rts_access_steer_data1);
-
-                data1 = VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_DA_MAC_ADDR(data1);
-                data2 = VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_DA_MAC_ADDR_MASK(
-                                                        data2);
-
-                for (i = ETH_ALEN; i > 0; i--) {
-                        macaddr[i-1] = (u8)(data1 & 0xFF);
-                        data1 >>= 8;
-
-                        macaddr_mask[i-1] = (u8)(data2 & 0xFF);
-                        data2 >>= 8;
-                }
-                status = VXGE_HW_OK;
-        } else
-                status = VXGE_HW_FAIL;
+        status = vxge_hw_vpath_fw_api(vp->vpath, action, rts_table, offset,
+                                      &data0, &data1, &steer_ctrl);
 exit:
         return status;
 }
@@ -3067,6 +3752,8 @@ enum vxge_hw_status vxge_hw_vpath_rts_rth_set(
                      VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_READ_ENTRY,
                      VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_GEN_CFG,
                         0, &data0, &data1);
+        if (status != VXGE_HW_OK)
+                goto exit;
 
         data0 &= ~(VXGE_HW_RTS_ACCESS_STEER_DATA0_RTH_GEN_BUCKET_SIZE(0xf) |
                         VXGE_HW_RTS_ACCESS_STEER_DATA0_RTH_GEN_ALG_SEL(0x3));
@@ -3347,7 +4034,7 @@ __vxge_hw_vpath_mgmt_read(
  * This routine checks the vpath_rst_in_prog register to see if
  * adapter completed the reset process for the vpath
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_vpath_reset_check(struct __vxge_hw_virtualpath *vpath)
 {
         enum vxge_hw_status status;
@@ -3365,7 +4052,7 @@ __vxge_hw_vpath_reset_check(struct __vxge_hw_virtualpath *vpath)
  * __vxge_hw_vpath_reset
  * This routine resets the vpath on the device
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_vpath_reset(struct __vxge_hw_device *hldev, u32 vp_id)
 {
         u64 val64;
@@ -3383,7 +4070,7 @@ __vxge_hw_vpath_reset(struct __vxge_hw_device *hldev, u32 vp_id)
  * __vxge_hw_vpath_sw_reset
  * This routine resets the vpath structures
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_vpath_sw_reset(struct __vxge_hw_device *hldev, u32 vp_id)
 {
         enum vxge_hw_status status = VXGE_HW_OK;
@@ -3408,7 +4095,7 @@ exit:
  * This routine configures the prc registers of virtual path using the config
  * passed
  */
-void
+static void
 __vxge_hw_vpath_prc_configure(struct __vxge_hw_device *hldev, u32 vp_id)
 {
         u64 val64;
@@ -3480,7 +4167,7 @@ __vxge_hw_vpath_prc_configure(struct __vxge_hw_device *hldev, u32 vp_id)
  * This routine configures the kdfc registers of virtual path using the
  * config passed
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_vpath_kdfc_configure(struct __vxge_hw_device *hldev, u32 vp_id)
 {
         u64 val64;
@@ -3553,7 +4240,7 @@ exit:
  * __vxge_hw_vpath_mac_configure
  * This routine configures the mac of virtual path using the config passed
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_vpath_mac_configure(struct __vxge_hw_device *hldev, u32 vp_id)
 {
         u64 val64;
@@ -3621,7 +4308,7 @@ __vxge_hw_vpath_mac_configure(struct __vxge_hw_device *hldev, u32 vp_id)
  * This routine configures the tim registers of virtual path using the config
  * passed
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_vpath_tim_configure(struct __vxge_hw_device *hldev, u32 vp_id)
 {
         u64 val64;
@@ -3634,10 +4321,10 @@ __vxge_hw_vpath_tim_configure(struct __vxge_hw_device *hldev, u32 vp_id)
         vp_reg = vpath->vp_reg;
         config = vpath->vp_config;
 
-        writeq((u64)0, &vp_reg->tim_dest_addr);
-        writeq((u64)0, &vp_reg->tim_vpath_map);
-        writeq((u64)0, &vp_reg->tim_bitmap);
-        writeq((u64)0, &vp_reg->tim_remap);
+        writeq(0, &vp_reg->tim_dest_addr);
+        writeq(0, &vp_reg->tim_vpath_map);
+        writeq(0, &vp_reg->tim_bitmap);
+        writeq(0, &vp_reg->tim_remap);
 
         if (config->ring.enable == VXGE_HW_RING_ENABLE)
                 writeq(VXGE_HW_TIM_RING_ASSN_INT_NUM(
@@ -3694,6 +4381,8 @@ __vxge_hw_vpath_tim_configure(struct __vxge_hw_device *hldev, u32 vp_id)
                 }
 
                 writeq(val64, &vp_reg->tim_cfg1_int_num[VXGE_HW_VPATH_INTR_TX]);
+                vpath->tim_tti_cfg1_saved = val64;
+
                 val64 = readq(&vp_reg->tim_cfg2_int_num[VXGE_HW_VPATH_INTR_TX]);
 
                 if (config->tti.uec_a != VXGE_HW_USE_FLASH_DEFAULT) {
@@ -3739,8 +4428,7 @@ __vxge_hw_vpath_tim_configure(struct __vxge_hw_device *hldev, u32 vp_id)
 
                 if (config->tti.util_sel != VXGE_HW_USE_FLASH_DEFAULT) {
                         val64 &= ~VXGE_HW_TIM_CFG3_INT_NUM_UTIL_SEL(0x3f);
-                        val64 |= VXGE_HW_TIM_CFG3_INT_NUM_UTIL_SEL(
-                                        config->tti.util_sel);
+                        val64 |= VXGE_HW_TIM_CFG3_INT_NUM_UTIL_SEL(vp_id);
                 }
 
                 if (config->tti.ltimer_val != VXGE_HW_USE_FLASH_DEFAULT) {
@@ -3751,6 +4439,7 @@ __vxge_hw_vpath_tim_configure(struct __vxge_hw_device *hldev, u32 vp_id)
                 }
 
                 writeq(val64, &vp_reg->tim_cfg3_int_num[VXGE_HW_VPATH_INTR_TX]);
+                vpath->tim_tti_cfg3_saved = val64;
         }
 
         if (config->ring.enable == VXGE_HW_RING_ENABLE) {
@@ -3799,6 +4488,8 @@ __vxge_hw_vpath_tim_configure(struct __vxge_hw_device *hldev, u32 vp_id)
                 }
 
                 writeq(val64, &vp_reg->tim_cfg1_int_num[VXGE_HW_VPATH_INTR_RX]);
+                vpath->tim_rti_cfg1_saved = val64;
+
                 val64 = readq(&vp_reg->tim_cfg2_int_num[VXGE_HW_VPATH_INTR_RX]);
 
                 if (config->rti.uec_a != VXGE_HW_USE_FLASH_DEFAULT) {
@@ -3844,8 +4535,7 @@ __vxge_hw_vpath_tim_configure(struct __vxge_hw_device *hldev, u32 vp_id)
 
                 if (config->rti.util_sel != VXGE_HW_USE_FLASH_DEFAULT) {
                         val64 &= ~VXGE_HW_TIM_CFG3_INT_NUM_UTIL_SEL(0x3f);
-                        val64 |= VXGE_HW_TIM_CFG3_INT_NUM_UTIL_SEL(
-                                        config->rti.util_sel);
+                        val64 |= VXGE_HW_TIM_CFG3_INT_NUM_UTIL_SEL(vp_id);
                 }
 
                 if (config->rti.ltimer_val != VXGE_HW_USE_FLASH_DEFAULT) {
@@ -3856,6 +4546,7 @@ __vxge_hw_vpath_tim_configure(struct __vxge_hw_device *hldev, u32 vp_id)
                 }
 
                 writeq(val64, &vp_reg->tim_cfg3_int_num[VXGE_HW_VPATH_INTR_RX]);
+                vpath->tim_rti_cfg3_saved = val64;
         }
 
         val64 = 0;
@@ -3866,38 +4557,20 @@ __vxge_hw_vpath_tim_configure(struct __vxge_hw_device *hldev, u32 vp_id)
         writeq(val64, &vp_reg->tim_cfg2_int_num[VXGE_HW_VPATH_INTR_BMAP]);
         writeq(val64, &vp_reg->tim_cfg3_int_num[VXGE_HW_VPATH_INTR_BMAP]);
 
+        val64 = VXGE_HW_TIM_WRKLD_CLC_WRKLD_EVAL_PRD(150);
+        val64 |= VXGE_HW_TIM_WRKLD_CLC_WRKLD_EVAL_DIV(0);
+        val64 |= VXGE_HW_TIM_WRKLD_CLC_CNT_RX_TX(3);
+        writeq(val64, &vp_reg->tim_wrkld_clc);
+
         return status;
 }
 
-void
-vxge_hw_vpath_tti_ci_set(struct __vxge_hw_device *hldev, u32 vp_id)
-{
-        struct __vxge_hw_virtualpath *vpath;
-        struct vxge_hw_vpath_reg __iomem *vp_reg;
-        struct vxge_hw_vp_config *config;
-        u64 val64;
-
-        vpath = &hldev->virtual_paths[vp_id];
-        vp_reg = vpath->vp_reg;
-        config = vpath->vp_config;
-
-        if (config->fifo.enable == VXGE_HW_FIFO_ENABLE) {
-                val64 = readq(&vp_reg->tim_cfg1_int_num[VXGE_HW_VPATH_INTR_TX]);
-
-                if (config->tti.timer_ci_en != VXGE_HW_TIM_TIMER_CI_ENABLE) {
-                        config->tti.timer_ci_en = VXGE_HW_TIM_TIMER_CI_ENABLE;
-                        val64 |= VXGE_HW_TIM_CFG1_INT_NUM_TIMER_CI;
-                        writeq(val64,
-                        &vp_reg->tim_cfg1_int_num[VXGE_HW_VPATH_INTR_TX]);
-                }
-        }
-}
 /*
  * __vxge_hw_vpath_initialize
  * This routine is the final phase of init which initializes the
  * registers of the vpath using the configuration passed.
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_vpath_initialize(struct __vxge_hw_device *hldev, u32 vp_id)
 {
         u64 val64;
@@ -3915,22 +4588,18 @@ __vxge_hw_vpath_initialize(struct __vxge_hw_device *hldev, u32 vp_id)
         vp_reg = vpath->vp_reg;
 
         status =  __vxge_hw_vpath_swapper_set(vpath->vp_reg);
-
         if (status != VXGE_HW_OK)
                 goto exit;
 
         status =  __vxge_hw_vpath_mac_configure(hldev, vp_id);
-
         if (status != VXGE_HW_OK)
                 goto exit;
 
         status =  __vxge_hw_vpath_kdfc_configure(hldev, vp_id);
-
         if (status != VXGE_HW_OK)
                 goto exit;
 
         status = __vxge_hw_vpath_tim_configure(hldev, vp_id);
-
         if (status != VXGE_HW_OK)
                 goto exit;
 
@@ -3938,7 +4607,6 @@ __vxge_hw_vpath_initialize(struct __vxge_hw_device *hldev, u32 vp_id)
 
         /* Get MRRS value from device control */
         status  = __vxge_hw_vpath_pci_read(vpath, 1, 0x78, &val32);
-
         if (status == VXGE_HW_OK) {
                 val32 = (val32 & VXGE_HW_PCI_EXP_DEVCTL_READRQ) >> 12;
                 val64 &=
@@ -3962,11 +4630,53 @@ exit:
 }
 
 /*
+ * __vxge_hw_vp_terminate - Terminate Virtual Path structure
+ * This routine closes all channels it opened and freeup memory
+ */
+static void __vxge_hw_vp_terminate(struct __vxge_hw_device *hldev, u32 vp_id)
+{
+        struct __vxge_hw_virtualpath *vpath;
+
+        vpath = &hldev->virtual_paths[vp_id];
+
+        if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN)
+                goto exit;
+
+        VXGE_HW_DEVICE_TIM_INT_MASK_RESET(vpath->hldev->tim_int_mask0,
+                vpath->hldev->tim_int_mask1, vpath->vp_id);
+        hldev->stats.hw_dev_info_stats.vpath_info[vpath->vp_id] = NULL;
+
+        /* If the whole struct __vxge_hw_virtualpath is zeroed, nothing will
+         * work after the interface is brought down.
+         */
+        spin_lock(&vpath->lock);
+        vpath->vp_open = VXGE_HW_VP_NOT_OPEN;
+        spin_unlock(&vpath->lock);
+
+        vpath->vpmgmt_reg = NULL;
+        vpath->nofl_db = NULL;
+        vpath->max_mtu = 0;
+        vpath->vsport_number = 0;
+        vpath->max_kdfc_db = 0;
+        vpath->max_nofl_db = 0;
+        vpath->ringh = NULL;
+        vpath->fifoh = NULL;
+        memset(&vpath->vpath_handles, 0, sizeof(struct list_head));
+        vpath->stats_block = 0;
+        vpath->hw_stats = NULL;
+        vpath->hw_stats_sav = NULL;
+        vpath->sw_stats = NULL;
+
+exit:
+        return;
+}
+
+/*
  * __vxge_hw_vp_initialize - Initialize Virtual Path structure
  * This routine is the initial phase of init which resets the vpath and
  * initializes the software support structures.
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 __vxge_hw_vp_initialize(struct __vxge_hw_device *hldev, u32 vp_id,
                         struct vxge_hw_vp_config *config)
 {
@@ -3980,6 +4690,7 @@ __vxge_hw_vp_initialize(struct __vxge_hw_device *hldev, u32 vp_id,
 
         vpath = &hldev->virtual_paths[vp_id];
 
+        spin_lock_init(&vpath->lock);
         vpath->vp_id = vp_id;
         vpath->vp_open = VXGE_HW_VP_OPEN;
         vpath->hldev = hldev;
@@ -3990,14 +4701,12 @@ __vxge_hw_vp_initialize(struct __vxge_hw_device *hldev, u32 vp_id,
         __vxge_hw_vpath_reset(hldev, vp_id);
 
         status = __vxge_hw_vpath_reset_check(vpath);
-
         if (status != VXGE_HW_OK) {
                 memset(vpath, 0, sizeof(struct __vxge_hw_virtualpath));
                 goto exit;
         }
 
         status = __vxge_hw_vpath_mgmt_read(hldev, vpath);
-
         if (status != VXGE_HW_OK) {
                 memset(vpath, 0, sizeof(struct __vxge_hw_virtualpath));
                 goto exit;
@@ -4011,7 +4720,6 @@ __vxge_hw_vp_initialize(struct __vxge_hw_device *hldev, u32 vp_id,
                 hldev->tim_int_mask1, vp_id);
 
         status = __vxge_hw_vpath_initialize(hldev, vp_id);
-
         if (status != VXGE_HW_OK)
                 __vxge_hw_vp_terminate(hldev, vp_id);
 exit:
@@ -4019,29 +4727,6 @@ exit:
 }
 
 /*
- * __vxge_hw_vp_terminate - Terminate Virtual Path structure
- * This routine closes all channels it opened and freeup memory
- */
-void
-__vxge_hw_vp_terminate(struct __vxge_hw_device *hldev, u32 vp_id)
-{
-        struct __vxge_hw_virtualpath *vpath;
-
-        vpath = &hldev->virtual_paths[vp_id];
-
-        if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN)
-                goto exit;
-
-        VXGE_HW_DEVICE_TIM_INT_MASK_RESET(vpath->hldev->tim_int_mask0,
-                vpath->hldev->tim_int_mask1, vpath->vp_id);
-        hldev->stats.hw_dev_info_stats.vpath_info[vpath->vp_id] = NULL;
-
-        memset(vpath, 0, sizeof(struct __vxge_hw_virtualpath));
-exit:
-        return;
-}
-
-/*
  * vxge_hw_vpath_mtu_set - Set MTU.
  * Set new MTU value. Example, to use jumbo frames:
  * vxge_hw_vpath_mtu_set(my_device, 9600);
@@ -4078,6 +4763,64 @@ exit:
 }
 
 /*
+ * vxge_hw_vpath_stats_enable - Enable vpath h/wstatistics.
+ * Enable the DMA vpath statistics. The function is to be called to re-enable
+ * the adapter to update stats into the host memory
+ */
+static enum vxge_hw_status
+vxge_hw_vpath_stats_enable(struct __vxge_hw_vpath_handle *vp)
+{
+        enum vxge_hw_status status = VXGE_HW_OK;
+        struct __vxge_hw_virtualpath *vpath;
+
+        vpath = vp->vpath;
+
+        if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
+                status = VXGE_HW_ERR_VPATH_NOT_OPEN;
+                goto exit;
+        }
+
+        memcpy(vpath->hw_stats_sav, vpath->hw_stats,
+                        sizeof(struct vxge_hw_vpath_stats_hw_info));
+
+        status = __vxge_hw_vpath_stats_get(vpath, vpath->hw_stats);
+exit:
+        return status;
+}
+
+/*
+ * __vxge_hw_blockpool_block_allocate - Allocates a block from block pool
+ * This function allocates a block from block pool or from the system
+ */
+static struct __vxge_hw_blockpool_entry *
+__vxge_hw_blockpool_block_allocate(struct __vxge_hw_device *devh, u32 size)
+{
+        struct __vxge_hw_blockpool_entry *entry = NULL;
+        struct __vxge_hw_blockpool  *blockpool;
+
+        blockpool = &devh->block_pool;
+
+        if (size == blockpool->block_size) {
+
+                if (!list_empty(&blockpool->free_block_list))
+                        entry = (struct __vxge_hw_blockpool_entry *)
+                                list_first_entry(&blockpool->free_block_list,
+                                        struct __vxge_hw_blockpool_entry,
+                                        item);
+
+                if (entry != NULL) {
+                        list_del(&entry->item);
+                        blockpool->pool_size--;
+                }
+        }
+
+        if (entry != NULL)
+                __vxge_hw_blockpool_blocks_add(blockpool);
+
+        return entry;
+}
+
+/*
  * vxge_hw_vpath_open - Open a virtual path on a given adapter
  * This function is used to open access to virtual path of an
  * adapter for offload, GRO operations. This function returns
@@ -4101,19 +4844,15 @@ vxge_hw_vpath_open(struct __vxge_hw_device *hldev,
 
         status = __vxge_hw_vp_initialize(hldev, attr->vp_id,
                         &hldev->config.vp_config[attr->vp_id]);
-
         if (status != VXGE_HW_OK)
                 goto vpath_open_exit1;
 
-        vp = (struct __vxge_hw_vpath_handle *)
-                vmalloc(sizeof(struct __vxge_hw_vpath_handle));
+        vp = vzalloc(sizeof(struct __vxge_hw_vpath_handle));
         if (vp == NULL) {
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 goto vpath_open_exit2;
         }
 
-        memset(vp, 0, sizeof(struct __vxge_hw_vpath_handle));
-
         vp->vpath = vpath;
 
         if (vpath->vp_config->fifo.enable == VXGE_HW_FIFO_ENABLE) {
@@ -4136,7 +4875,6 @@ vxge_hw_vpath_open(struct __vxge_hw_device *hldev,
 
         vpath->stats_block = __vxge_hw_blockpool_block_allocate(hldev,
                                 VXGE_HW_BLOCK_SIZE);
-
         if (vpath->stats_block == NULL) {
                 status = VXGE_HW_ERR_OUT_OF_MEMORY;
                 goto vpath_open_exit8;
@@ -4195,19 +4933,20 @@ vpath_open_exit1:
  * This function is used to close access to virtual path opened
  * earlier.
  */
-void
-vxge_hw_vpath_rx_doorbell_init(struct __vxge_hw_vpath_handle *vp)
+void vxge_hw_vpath_rx_doorbell_init(struct __vxge_hw_vpath_handle *vp)
 {
-        struct __vxge_hw_virtualpath *vpath = NULL;
+        struct __vxge_hw_virtualpath *vpath = vp->vpath;
+        struct __vxge_hw_ring *ring = vpath->ringh;
+        struct vxgedev *vdev = netdev_priv(vpath->hldev->ndev);
         u64 new_count, val64, val164;
-        struct __vxge_hw_ring *ring;
 
-        vpath = vp->vpath;
-        ring = vpath->ringh;
+        if (vdev->titan1) {
+                new_count = readq(&vpath->vp_reg->rxdmem_size);
+                new_count &= 0x1fff;
+        } else
+                new_count = ring->config->ring_blocks * VXGE_HW_BLOCK_SIZE / 8;
 
-        new_count = readq(&vpath->vp_reg->rxdmem_size);
-        new_count &= 0x1fff;
-        val164 = (VXGE_HW_RXDMEM_SIZE_PRC_RXDMEM_SIZE(new_count));
+        val164 = VXGE_HW_RXDMEM_SIZE_PRC_RXDMEM_SIZE(new_count);
 
         writeq(VXGE_HW_PRC_RXD_DOORBELL_NEW_QW_CNT(val164),
                 &vpath->vp_reg->prc_rxd_doorbell);
@@ -4230,6 +4969,29 @@ vxge_hw_vpath_rx_doorbell_init(struct __vxge_hw_vpath_handle *vp)
 }
 
 /*
+ * __vxge_hw_blockpool_block_free - Frees a block from block pool
+ * @devh: Hal device
+ * @entry: Entry of block to be freed
+ *
+ * This function frees a block from block pool
+ */
+static void
+__vxge_hw_blockpool_block_free(struct __vxge_hw_device *devh,
+                               struct __vxge_hw_blockpool_entry *entry)
+{
+        struct __vxge_hw_blockpool  *blockpool;
+
+        blockpool = &devh->block_pool;
+
+        if (entry->length == blockpool->block_size) {
+                list_add(&entry->item, &blockpool->free_block_list);
+                blockpool->pool_size++;
+        }
+
+        __vxge_hw_blockpool_blocks_remove(blockpool);
+}
+
+/*
  * vxge_hw_vpath_close - Close the handle got from previous vpath (vpath) open
  * This function is used to close access to virtual path opened
  * earlier.
@@ -4277,8 +5039,6 @@ enum vxge_hw_status vxge_hw_vpath_close(struct __vxge_hw_vpath_handle *vp)
 
         __vxge_hw_vp_terminate(devh, vp_id);
 
-        vpath->vp_open = VXGE_HW_VP_NOT_OPEN;
-
 vpath_close_exit:
         return status;
 }
@@ -4378,705 +5138,3 @@ vxge_hw_vpath_enable(struct __vxge_hw_vpath_handle *vp)
         __vxge_hw_pio_mem_write32_upper((u32)vxge_bVALn(val64, 0, 32),
                 &hldev->common_reg->cmn_rsthdlr_cfg1);
 }
-
-/*
- * vxge_hw_vpath_stats_enable - Enable vpath h/wstatistics.
- * Enable the DMA vpath statistics. The function is to be called to re-enable
- * the adapter to update stats into the host memory
- */
-enum vxge_hw_status
-vxge_hw_vpath_stats_enable(struct __vxge_hw_vpath_handle *vp)
-{
-        enum vxge_hw_status status = VXGE_HW_OK;
-        struct __vxge_hw_virtualpath *vpath;
-
-        vpath = vp->vpath;
-
-        if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
-                status = VXGE_HW_ERR_VPATH_NOT_OPEN;
-                goto exit;
-        }
-
-        memcpy(vpath->hw_stats_sav, vpath->hw_stats,
-                        sizeof(struct vxge_hw_vpath_stats_hw_info));
-
-        status = __vxge_hw_vpath_stats_get(vpath, vpath->hw_stats);
-exit:
-        return status;
-}
-
-/*
- * __vxge_hw_vpath_stats_access - Get the statistics from the given location
- *                           and offset and perform an operation
- */
-enum vxge_hw_status
-__vxge_hw_vpath_stats_access(struct __vxge_hw_virtualpath *vpath,
-                             u32 operation, u32 offset, u64 *stat)
-{
-        u64 val64;
-        enum vxge_hw_status status = VXGE_HW_OK;
-        struct vxge_hw_vpath_reg __iomem *vp_reg;
-
-        if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
-                status = VXGE_HW_ERR_VPATH_NOT_OPEN;
-                goto vpath_stats_access_exit;
-        }
-
-        vp_reg = vpath->vp_reg;
-
-        val64 =  VXGE_HW_XMAC_STATS_ACCESS_CMD_OP(operation) |
-                 VXGE_HW_XMAC_STATS_ACCESS_CMD_STROBE |
-                 VXGE_HW_XMAC_STATS_ACCESS_CMD_OFFSET_SEL(offset);
-
-        status = __vxge_hw_pio_mem_write64(val64,
-                                &vp_reg->xmac_stats_access_cmd,
-                                VXGE_HW_XMAC_STATS_ACCESS_CMD_STROBE,
-                                vpath->hldev->config.device_poll_millis);
-
-        if ((status == VXGE_HW_OK) && (operation == VXGE_HW_STATS_OP_READ))
-                *stat = readq(&vp_reg->xmac_stats_access_data);
-        else
-                *stat = 0;
-
-vpath_stats_access_exit:
-        return status;
-}
-
-/*
- * __vxge_hw_vpath_xmac_tx_stats_get - Get the TX Statistics of a vpath
- */
-enum vxge_hw_status
-__vxge_hw_vpath_xmac_tx_stats_get(
-        struct __vxge_hw_virtualpath *vpath,
-        struct vxge_hw_xmac_vpath_tx_stats *vpath_tx_stats)
-{
-        u64 *val64;
-        int i;
-        u32 offset = VXGE_HW_STATS_VPATH_TX_OFFSET;
-        enum vxge_hw_status status = VXGE_HW_OK;
-
-        val64 = (u64 *) vpath_tx_stats;
-
-        if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
-                status = VXGE_HW_ERR_VPATH_NOT_OPEN;
-                goto exit;
-        }
-
-        for (i = 0; i < sizeof(struct vxge_hw_xmac_vpath_tx_stats) / 8; i++) {
-                status = __vxge_hw_vpath_stats_access(vpath,
-                                        VXGE_HW_STATS_OP_READ,
-                                        offset, val64);
-                if (status != VXGE_HW_OK)
-                        goto exit;
-                offset++;
-                val64++;
-        }
-exit:
-        return status;
-}
-
-/*
- * __vxge_hw_vpath_xmac_rx_stats_get - Get the RX Statistics of a vpath
- */
-enum vxge_hw_status
-__vxge_hw_vpath_xmac_rx_stats_get(struct __vxge_hw_virtualpath *vpath,
-                        struct vxge_hw_xmac_vpath_rx_stats *vpath_rx_stats)
-{
-        u64 *val64;
-        enum vxge_hw_status status = VXGE_HW_OK;
-        int i;
-        u32 offset = VXGE_HW_STATS_VPATH_RX_OFFSET;
-        val64 = (u64 *) vpath_rx_stats;
-
-        if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
-                status = VXGE_HW_ERR_VPATH_NOT_OPEN;
-                goto exit;
-        }
-        for (i = 0; i < sizeof(struct vxge_hw_xmac_vpath_rx_stats) / 8; i++) {
-                status = __vxge_hw_vpath_stats_access(vpath,
-                                        VXGE_HW_STATS_OP_READ,
-                                        offset >> 3, val64);
-                if (status != VXGE_HW_OK)
-                        goto exit;
-
-                offset += 8;
-                val64++;
-        }
-exit:
-        return status;
-}
-
-/*
- * __vxge_hw_vpath_stats_get - Get the vpath hw statistics.
- */
-enum vxge_hw_status __vxge_hw_vpath_stats_get(
-                        struct __vxge_hw_virtualpath *vpath,
-                        struct vxge_hw_vpath_stats_hw_info *hw_stats)
-{
-        u64 val64;
-        enum vxge_hw_status status = VXGE_HW_OK;
-        struct vxge_hw_vpath_reg __iomem *vp_reg;
-
-        if (vpath->vp_open == VXGE_HW_VP_NOT_OPEN) {
-                status = VXGE_HW_ERR_VPATH_NOT_OPEN;
-                goto exit;
-        }
-        vp_reg = vpath->vp_reg;
-
-        val64 = readq(&vp_reg->vpath_debug_stats0);
-        hw_stats->ini_num_mwr_sent =
-                (u32)VXGE_HW_VPATH_DEBUG_STATS0_GET_INI_NUM_MWR_SENT(val64);
-
-        val64 = readq(&vp_reg->vpath_debug_stats1);
-        hw_stats->ini_num_mrd_sent =
-                (u32)VXGE_HW_VPATH_DEBUG_STATS1_GET_INI_NUM_MRD_SENT(val64);
-
-        val64 = readq(&vp_reg->vpath_debug_stats2);
-        hw_stats->ini_num_cpl_rcvd =
-                (u32)VXGE_HW_VPATH_DEBUG_STATS2_GET_INI_NUM_CPL_RCVD(val64);
-
-        val64 = readq(&vp_reg->vpath_debug_stats3);
-        hw_stats->ini_num_mwr_byte_sent =
-                VXGE_HW_VPATH_DEBUG_STATS3_GET_INI_NUM_MWR_BYTE_SENT(val64);
-
-        val64 = readq(&vp_reg->vpath_debug_stats4);
-        hw_stats->ini_num_cpl_byte_rcvd =
-                VXGE_HW_VPATH_DEBUG_STATS4_GET_INI_NUM_CPL_BYTE_RCVD(val64);
-
-        val64 = readq(&vp_reg->vpath_debug_stats5);
-        hw_stats->wrcrdtarb_xoff =
-                (u32)VXGE_HW_VPATH_DEBUG_STATS5_GET_WRCRDTARB_XOFF(val64);
-
-        val64 = readq(&vp_reg->vpath_debug_stats6);
-        hw_stats->rdcrdtarb_xoff =
-                (u32)VXGE_HW_VPATH_DEBUG_STATS6_GET_RDCRDTARB_XOFF(val64);
-
-        val64 = readq(&vp_reg->vpath_genstats_count01);
-        hw_stats->vpath_genstats_count0 =
-        (u32)VXGE_HW_VPATH_GENSTATS_COUNT01_GET_PPIF_VPATH_GENSTATS_COUNT0(
-                val64);
-
-        val64 = readq(&vp_reg->vpath_genstats_count01);
-        hw_stats->vpath_genstats_count1 =
-        (u32)VXGE_HW_VPATH_GENSTATS_COUNT01_GET_PPIF_VPATH_GENSTATS_COUNT1(
-                val64);
-
-        val64 = readq(&vp_reg->vpath_genstats_count23);
-        hw_stats->vpath_genstats_count2 =
-        (u32)VXGE_HW_VPATH_GENSTATS_COUNT23_GET_PPIF_VPATH_GENSTATS_COUNT2(
-                val64);
-
-        val64 = readq(&vp_reg->vpath_genstats_count01);
-        hw_stats->vpath_genstats_count3 =
-        (u32)VXGE_HW_VPATH_GENSTATS_COUNT23_GET_PPIF_VPATH_GENSTATS_COUNT3(
-                val64);
-
-        val64 = readq(&vp_reg->vpath_genstats_count4);
-        hw_stats->vpath_genstats_count4 =
-        (u32)VXGE_HW_VPATH_GENSTATS_COUNT4_GET_PPIF_VPATH_GENSTATS_COUNT4(
-                val64);
-
-        val64 = readq(&vp_reg->vpath_genstats_count5);
-        hw_stats->vpath_genstats_count5 =
-        (u32)VXGE_HW_VPATH_GENSTATS_COUNT5_GET_PPIF_VPATH_GENSTATS_COUNT5(
-                val64);
-
-        status = __vxge_hw_vpath_xmac_tx_stats_get(vpath, &hw_stats->tx_stats);
-        if (status != VXGE_HW_OK)
-                goto exit;
-
-        status = __vxge_hw_vpath_xmac_rx_stats_get(vpath, &hw_stats->rx_stats);
-        if (status != VXGE_HW_OK)
-                goto exit;
-
-        VXGE_HW_VPATH_STATS_PIO_READ(
-                VXGE_HW_STATS_VPATH_PROG_EVENT_VNUM0_OFFSET);
-
-        hw_stats->prog_event_vnum0 =
-                        (u32)VXGE_HW_STATS_GET_VPATH_PROG_EVENT_VNUM0(val64);
-
-        hw_stats->prog_event_vnum1 =
-                        (u32)VXGE_HW_STATS_GET_VPATH_PROG_EVENT_VNUM1(val64);
-
-        VXGE_HW_VPATH_STATS_PIO_READ(
-                VXGE_HW_STATS_VPATH_PROG_EVENT_VNUM2_OFFSET);
-
-        hw_stats->prog_event_vnum2 =
-                        (u32)VXGE_HW_STATS_GET_VPATH_PROG_EVENT_VNUM2(val64);
-
-        hw_stats->prog_event_vnum3 =
-                        (u32)VXGE_HW_STATS_GET_VPATH_PROG_EVENT_VNUM3(val64);
-
-        val64 = readq(&vp_reg->rx_multi_cast_stats);
-        hw_stats->rx_multi_cast_frame_discard =
-                (u16)VXGE_HW_RX_MULTI_CAST_STATS_GET_FRAME_DISCARD(val64);
-
-        val64 = readq(&vp_reg->rx_frm_transferred);
-        hw_stats->rx_frm_transferred =
-                (u32)VXGE_HW_RX_FRM_TRANSFERRED_GET_RX_FRM_TRANSFERRED(val64);
-
-        val64 = readq(&vp_reg->rxd_returned);
-        hw_stats->rxd_returned =
-                (u16)VXGE_HW_RXD_RETURNED_GET_RXD_RETURNED(val64);
-
-        val64 = readq(&vp_reg->dbg_stats_rx_mpa);
-        hw_stats->rx_mpa_len_fail_frms =
-                (u16)VXGE_HW_DBG_STATS_GET_RX_MPA_LEN_FAIL_FRMS(val64);
-        hw_stats->rx_mpa_mrk_fail_frms =
-                (u16)VXGE_HW_DBG_STATS_GET_RX_MPA_MRK_FAIL_FRMS(val64);
-        hw_stats->rx_mpa_crc_fail_frms =
-                (u16)VXGE_HW_DBG_STATS_GET_RX_MPA_CRC_FAIL_FRMS(val64);
-
-        val64 = readq(&vp_reg->dbg_stats_rx_fau);
-        hw_stats->rx_permitted_frms =
-                (u16)VXGE_HW_DBG_STATS_GET_RX_FAU_RX_PERMITTED_FRMS(val64);
-        hw_stats->rx_vp_reset_discarded_frms =
-        (u16)VXGE_HW_DBG_STATS_GET_RX_FAU_RX_VP_RESET_DISCARDED_FRMS(val64);
-        hw_stats->rx_wol_frms =
-                (u16)VXGE_HW_DBG_STATS_GET_RX_FAU_RX_WOL_FRMS(val64);
-
-        val64 = readq(&vp_reg->tx_vp_reset_discarded_frms);
-        hw_stats->tx_vp_reset_discarded_frms =
-        (u16)VXGE_HW_TX_VP_RESET_DISCARDED_FRMS_GET_TX_VP_RESET_DISCARDED_FRMS(
-                val64);
-exit:
-        return status;
-}
-
-/*
- * __vxge_hw_blockpool_create - Create block pool
- */
-
-enum vxge_hw_status
-__vxge_hw_blockpool_create(struct __vxge_hw_device *hldev,
-                           struct __vxge_hw_blockpool *blockpool,
-                           u32 pool_size,
-                           u32 pool_max)
-{
-        u32 i;
-        struct __vxge_hw_blockpool_entry *entry = NULL;
-        void *memblock;
-        dma_addr_t dma_addr;
-        struct pci_dev *dma_handle;
-        struct pci_dev *acc_handle;
-        enum vxge_hw_status status = VXGE_HW_OK;
-
-        if (blockpool == NULL) {
-                status = VXGE_HW_FAIL;
-                goto blockpool_create_exit;
-        }
-
-        blockpool->hldev = hldev;
-        blockpool->block_size = VXGE_HW_BLOCK_SIZE;
-        blockpool->pool_size = 0;
-        blockpool->pool_max = pool_max;
-        blockpool->req_out = 0;
-
-        INIT_LIST_HEAD(&blockpool->free_block_list);
-        INIT_LIST_HEAD(&blockpool->free_entry_list);
-
-        for (i = 0; i < pool_size + pool_max; i++) {
-                entry = kzalloc(sizeof(struct __vxge_hw_blockpool_entry),
-                                GFP_KERNEL);
-                if (entry == NULL) {
-                        __vxge_hw_blockpool_destroy(blockpool);
-                        status = VXGE_HW_ERR_OUT_OF_MEMORY;
-                        goto blockpool_create_exit;
-                }
-                list_add(&entry->item, &blockpool->free_entry_list);
-        }
-
-        for (i = 0; i < pool_size; i++) {
-
-                memblock = vxge_os_dma_malloc(
-                                hldev->pdev,
-                                VXGE_HW_BLOCK_SIZE,
-                                &dma_handle,
-                                &acc_handle);
-
-                if (memblock == NULL) {
-                        __vxge_hw_blockpool_destroy(blockpool);
-                        status = VXGE_HW_ERR_OUT_OF_MEMORY;
-                        goto blockpool_create_exit;
-                }
-
-                dma_addr = pci_map_single(hldev->pdev, memblock,
-                                VXGE_HW_BLOCK_SIZE, PCI_DMA_BIDIRECTIONAL);
-
-                if (unlikely(pci_dma_mapping_error(hldev->pdev,
-                                dma_addr))) {
-
-                        vxge_os_dma_free(hldev->pdev, memblock, &acc_handle);
-                        __vxge_hw_blockpool_destroy(blockpool);
-                        status = VXGE_HW_ERR_OUT_OF_MEMORY;
-                        goto blockpool_create_exit;
-                }
-
-                if (!list_empty(&blockpool->free_entry_list))
-                        entry = (struct __vxge_hw_blockpool_entry *)
-                                list_first_entry(&blockpool->free_entry_list,
-                                        struct __vxge_hw_blockpool_entry,
-                                        item);
-
-                if (entry == NULL)
-                        entry =
-                            kzalloc(sizeof(struct __vxge_hw_blockpool_entry),
-                                        GFP_KERNEL);
-                if (entry != NULL) {
-                        list_del(&entry->item);
-                        entry->length = VXGE_HW_BLOCK_SIZE;
-                        entry->memblock = memblock;
-                        entry->dma_addr = dma_addr;
-                        entry->acc_handle = acc_handle;
-                        entry->dma_handle = dma_handle;
-                        list_add(&entry->item,
-                                          &blockpool->free_block_list);
-                        blockpool->pool_size++;
-                } else {
-                        __vxge_hw_blockpool_destroy(blockpool);
-                        status = VXGE_HW_ERR_OUT_OF_MEMORY;
-                        goto blockpool_create_exit;
-                }
-        }
-
-blockpool_create_exit:
-        return status;
-}
-
-/*
- * __vxge_hw_blockpool_destroy - Deallocates the block pool
- */
-
-void __vxge_hw_blockpool_destroy(struct __vxge_hw_blockpool *blockpool)
-{
-
-        struct __vxge_hw_device *hldev;
-        struct list_head *p, *n;
-        u16 ret;
-
-        if (blockpool == NULL) {
-                ret = 1;
-                goto exit;
-        }
-
-        hldev = blockpool->hldev;
-
-        list_for_each_safe(p, n, &blockpool->free_block_list) {
-
-                pci_unmap_single(hldev->pdev,
-                        ((struct __vxge_hw_blockpool_entry *)p)->dma_addr,
-                        ((struct __vxge_hw_blockpool_entry *)p)->length,
-                        PCI_DMA_BIDIRECTIONAL);
-
-                vxge_os_dma_free(hldev->pdev,
-                        ((struct __vxge_hw_blockpool_entry *)p)->memblock,
-                        &((struct __vxge_hw_blockpool_entry *) p)->acc_handle);
-
-                list_del(
-                        &((struct __vxge_hw_blockpool_entry *)p)->item);
-                kfree(p);
-                blockpool->pool_size--;
-        }
-
-        list_for_each_safe(p, n, &blockpool->free_entry_list) {
-                list_del(
-                        &((struct __vxge_hw_blockpool_entry *)p)->item);
-                kfree((void *)p);
-        }
-        ret = 0;
-exit:
-        return;
-}
-
-/*
- * __vxge_hw_blockpool_blocks_add - Request additional blocks
- */
-static
-void __vxge_hw_blockpool_blocks_add(struct __vxge_hw_blockpool *blockpool)
-{
-        u32 nreq = 0, i;
-
-        if ((blockpool->pool_size  +  blockpool->req_out) <
-                VXGE_HW_MIN_DMA_BLOCK_POOL_SIZE) {
-                nreq = VXGE_HW_INCR_DMA_BLOCK_POOL_SIZE;
-                blockpool->req_out += nreq;
-        }
-
-        for (i = 0; i < nreq; i++)
-                vxge_os_dma_malloc_async(
-                        ((struct __vxge_hw_device *)blockpool->hldev)->pdev,
-                        blockpool->hldev, VXGE_HW_BLOCK_SIZE);
-}
-
-/*
- * __vxge_hw_blockpool_blocks_remove - Free additional blocks
- */
-static
-void __vxge_hw_blockpool_blocks_remove(struct __vxge_hw_blockpool *blockpool)
-{
-        struct list_head *p, *n;
-
-        list_for_each_safe(p, n, &blockpool->free_block_list) {
-
-                if (blockpool->pool_size < blockpool->pool_max)
-                        break;
-
-                pci_unmap_single(
-                        ((struct __vxge_hw_device *)blockpool->hldev)->pdev,
-                        ((struct __vxge_hw_blockpool_entry *)p)->dma_addr,
-                        ((struct __vxge_hw_blockpool_entry *)p)->length,
-                        PCI_DMA_BIDIRECTIONAL);
-
-                vxge_os_dma_free(
-                        ((struct __vxge_hw_device *)blockpool->hldev)->pdev,
-                        ((struct __vxge_hw_blockpool_entry *)p)->memblock,
-                        &((struct __vxge_hw_blockpool_entry *)p)->acc_handle);
-
-                list_del(&((struct __vxge_hw_blockpool_entry *)p)->item);
-
-                list_add(p, &blockpool->free_entry_list);
-
-                blockpool->pool_size--;
-
-        }
-}
-
-/*
- * vxge_hw_blockpool_block_add - callback for vxge_os_dma_malloc_async
- * Adds a block to block pool
- */
-void vxge_hw_blockpool_block_add(
-                        struct __vxge_hw_device *devh,
-                        void *block_addr,
-                        u32 length,
-                        struct pci_dev *dma_h,
-                        struct pci_dev *acc_handle)
-{
-        struct __vxge_hw_blockpool  *blockpool;
-        struct __vxge_hw_blockpool_entry  *entry = NULL;
-        dma_addr_t dma_addr;
-        enum vxge_hw_status status = VXGE_HW_OK;
-        u32 req_out;
-
-        blockpool = &devh->block_pool;
-
-        if (block_addr == NULL) {
-                blockpool->req_out--;
-                status = VXGE_HW_FAIL;
-                goto exit;
-        }
-
-        dma_addr = pci_map_single(devh->pdev, block_addr, length,
-                                PCI_DMA_BIDIRECTIONAL);
-
-        if (unlikely(pci_dma_mapping_error(devh->pdev, dma_addr))) {
-
-                vxge_os_dma_free(devh->pdev, block_addr, &acc_handle);
-                blockpool->req_out--;
-                status = VXGE_HW_FAIL;
-                goto exit;
-        }
-
-
-        if (!list_empty(&blockpool->free_entry_list))
-                entry = (struct __vxge_hw_blockpool_entry *)
-                        list_first_entry(&blockpool->free_entry_list,
-                                struct __vxge_hw_blockpool_entry,
-                                item);
-
-        if (entry == NULL)
-                entry = (struct __vxge_hw_blockpool_entry *)
-                        vmalloc(sizeof(struct __vxge_hw_blockpool_entry));
-        else
-                list_del(&entry->item);
-
-        if (entry != NULL) {
-                entry->length = length;
-                entry->memblock = block_addr;
-                entry->dma_addr = dma_addr;
-                entry->acc_handle = acc_handle;
-                entry->dma_handle = dma_h;
-                list_add(&entry->item, &blockpool->free_block_list);
-                blockpool->pool_size++;
-                status = VXGE_HW_OK;
-        } else
-                status = VXGE_HW_ERR_OUT_OF_MEMORY;
-
-        blockpool->req_out--;
-
-        req_out = blockpool->req_out;
-exit:
-        return;
-}
-
-/*
- * __vxge_hw_blockpool_malloc - Allocate a memory block from pool
- * Allocates a block of memory of given size, either from block pool
- * or by calling vxge_os_dma_malloc()
- */
-void *
-__vxge_hw_blockpool_malloc(struct __vxge_hw_device *devh, u32 size,
-                                struct vxge_hw_mempool_dma *dma_object)
-{
-        struct __vxge_hw_blockpool_entry *entry = NULL;
-        struct __vxge_hw_blockpool  *blockpool;
-        void *memblock = NULL;
-        enum vxge_hw_status status = VXGE_HW_OK;
-
-        blockpool = &devh->block_pool;
-
-        if (size != blockpool->block_size) {
-
-                memblock = vxge_os_dma_malloc(devh->pdev, size,
-                                                &dma_object->handle,
-                                                &dma_object->acc_handle);
-
-                if (memblock == NULL) {
-                        status = VXGE_HW_ERR_OUT_OF_MEMORY;
-                        goto exit;
-                }
-
-                dma_object->addr = pci_map_single(devh->pdev, memblock, size,
-                                        PCI_DMA_BIDIRECTIONAL);
-
-                if (unlikely(pci_dma_mapping_error(devh->pdev,
-                                dma_object->addr))) {
-                        vxge_os_dma_free(devh->pdev, memblock,
-                                &dma_object->acc_handle);
-                        status = VXGE_HW_ERR_OUT_OF_MEMORY;
-                        goto exit;
-                }
-
-        } else {
-
-                if (!list_empty(&blockpool->free_block_list))
-                        entry = (struct __vxge_hw_blockpool_entry *)
-                                list_first_entry(&blockpool->free_block_list,
-                                        struct __vxge_hw_blockpool_entry,
-                                        item);
-
-                if (entry != NULL) {
-                        list_del(&entry->item);
-                        dma_object->addr = entry->dma_addr;
-                        dma_object->handle = entry->dma_handle;
-                        dma_object->acc_handle = entry->acc_handle;
-                        memblock = entry->memblock;
-
-                        list_add(&entry->item,
-                                &blockpool->free_entry_list);
-                        blockpool->pool_size--;
-                }
-
-                if (memblock != NULL)
-                        __vxge_hw_blockpool_blocks_add(blockpool);
-        }
-exit:
-        return memblock;
-}
-
-/*
- * __vxge_hw_blockpool_free - Frees the memory allcoated with
-                                __vxge_hw_blockpool_malloc
- */
-void
-__vxge_hw_blockpool_free(struct __vxge_hw_device *devh,
-                        void *memblock, u32 size,
-                        struct vxge_hw_mempool_dma *dma_object)
-{
-        struct __vxge_hw_blockpool_entry *entry = NULL;
-        struct __vxge_hw_blockpool  *blockpool;
-        enum vxge_hw_status status = VXGE_HW_OK;
-
-        blockpool = &devh->block_pool;
-
-        if (size != blockpool->block_size) {
-                pci_unmap_single(devh->pdev, dma_object->addr, size,
-                        PCI_DMA_BIDIRECTIONAL);
-                vxge_os_dma_free(devh->pdev, memblock, &dma_object->acc_handle);
-        } else {
-
-                if (!list_empty(&blockpool->free_entry_list))
-                        entry = (struct __vxge_hw_blockpool_entry *)
-                                list_first_entry(&blockpool->free_entry_list,
-                                        struct __vxge_hw_blockpool_entry,
-                                        item);
-
-                if (entry == NULL)
-                        entry = (struct __vxge_hw_blockpool_entry *)
-                                vmalloc(sizeof(
-                                        struct __vxge_hw_blockpool_entry));
-                else
-                        list_del(&entry->item);
-
-                if (entry != NULL) {
-                        entry->length = size;
-                        entry->memblock = memblock;
-                        entry->dma_addr = dma_object->addr;
-                        entry->acc_handle = dma_object->acc_handle;
-                        entry->dma_handle = dma_object->handle;
-                        list_add(&entry->item,
-                                        &blockpool->free_block_list);
-                        blockpool->pool_size++;
-                        status = VXGE_HW_OK;
-                } else
-                        status = VXGE_HW_ERR_OUT_OF_MEMORY;
-
-                if (status == VXGE_HW_OK)
-                        __vxge_hw_blockpool_blocks_remove(blockpool);
-        }
-}
-
-/*
- * __vxge_hw_blockpool_block_allocate - Allocates a block from block pool
- * This function allocates a block from block pool or from the system
- */
-struct __vxge_hw_blockpool_entry *
-__vxge_hw_blockpool_block_allocate(struct __vxge_hw_device *devh, u32 size)
-{
-        struct __vxge_hw_blockpool_entry *entry = NULL;
-        struct __vxge_hw_blockpool  *blockpool;
-
-        blockpool = &devh->block_pool;
-
-        if (size == blockpool->block_size) {
-
-                if (!list_empty(&blockpool->free_block_list))
-                        entry = (struct __vxge_hw_blockpool_entry *)
-                                list_first_entry(&blockpool->free_block_list,
-                                        struct __vxge_hw_blockpool_entry,
-                                        item);
-
-                if (entry != NULL) {
-                        list_del(&entry->item);
-                        blockpool->pool_size--;
-                }
-        }
-
-        if (entry != NULL)
-                __vxge_hw_blockpool_blocks_add(blockpool);
-
-        return entry;
-}
-
-/*
- * __vxge_hw_blockpool_block_free - Frees a block from block pool
- * @devh: Hal device
- * @entry: Entry of block to be freed
- *
- * This function frees a block from block pool
- */
-void
-__vxge_hw_blockpool_block_free(struct __vxge_hw_device *devh,
-                        struct __vxge_hw_blockpool_entry *entry)
-{
-        struct __vxge_hw_blockpool  *blockpool;
-
-        blockpool = &devh->block_pool;
-
-        if (entry->length == blockpool->block_size) {
-                list_add(&entry->item, &blockpool->free_block_list);
-                blockpool->pool_size++;
-        }
-
-        __vxge_hw_blockpool_blocks_remove(blockpool);
-}
diff --git a/drivers/net/vxge/vxge-config.h b/drivers/net/vxge/vxge-config.h
index 1a94343023cb..359b9b9f8041 100644
--- a/drivers/net/vxge/vxge-config.h
+++ b/drivers/net/vxge/vxge-config.h
@@ -20,13 +20,6 @@
 #define VXGE_CACHE_LINE_SIZE 128
 #endif
 
-#define vxge_os_vaprintf(level, mask, fmt, ...) { \
-        char buff[255]; \
-                snprintf(buff, 255, fmt, __VA_ARGS__); \
-                printk(buff); \
-                printk("\n"); \
-}
-
 #ifndef VXGE_ALIGN
 #define VXGE_ALIGN(adrs, size) \
         (((size) - (((u64)adrs) & ((size)-1))) & ((size)-1))
@@ -36,8 +29,16 @@
 #define VXGE_HW_MAX_MTU                         9600
 #define VXGE_HW_DEFAULT_MTU                     1500
 
-#ifdef VXGE_DEBUG_ASSERT
+#define VXGE_HW_MAX_ROM_IMAGES                  8
+
+struct eprom_image {
+        u8 is_valid:1;
+        u8 index;
+        u8 type;
+        u16 version;
+};
 
+#ifdef VXGE_DEBUG_ASSERT
 /**
  * vxge_assert
  * @test: C-condition to check
@@ -48,16 +49,13 @@
  * compilation
  * time.
  */
-#define vxge_assert(test) { \
-        if (!(test)) \
-                vxge_os_bug("bad cond: "#test" at %s:%d\n", \
-                                __FILE__, __LINE__); }
+#define vxge_assert(test) BUG_ON(!(test))
 #else
 #define vxge_assert(test)
 #endif /* end of VXGE_DEBUG_ASSERT */
 
 /**
- * enum enum vxge_debug_level
+ * enum vxge_debug_level
  * @VXGE_NONE: debug disabled
  * @VXGE_ERR: all errors going to be logged out
  * @VXGE_TRACE: all errors plus all kind of verbose tracing print outs
@@ -159,6 +157,47 @@ enum vxge_hw_device_link_state {
 };
 
 /**
+ * enum enum vxge_hw_fw_upgrade_code - FW upgrade return codes.
+ * @VXGE_HW_FW_UPGRADE_OK: All OK send next 16 bytes
+ * @VXGE_HW_FW_UPGRADE_DONE:  upload completed
+ * @VXGE_HW_FW_UPGRADE_ERR:  upload error
+ * @VXGE_FW_UPGRADE_BYTES2SKIP:  skip bytes in the stream
+ *
+ */
+enum vxge_hw_fw_upgrade_code {
+        VXGE_HW_FW_UPGRADE_OK           = 0,
+        VXGE_HW_FW_UPGRADE_DONE         = 1,
+        VXGE_HW_FW_UPGRADE_ERR          = 2,
+        VXGE_FW_UPGRADE_BYTES2SKIP      = 3
+};
+
+/**
+ * enum enum vxge_hw_fw_upgrade_err_code - FW upgrade error codes.
+ * @VXGE_HW_FW_UPGRADE_ERR_CORRUPT_DATA_1: corrupt data
+ * @VXGE_HW_FW_UPGRADE_ERR_BUFFER_OVERFLOW: buffer overflow
+ * @VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_3: invalid .ncf file
+ * @VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_4: invalid .ncf file
+ * @VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_5: invalid .ncf file
+ * @VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_6: invalid .ncf file
+ * @VXGE_HW_FW_UPGRADE_ERR_CORRUPT_DATA_7: corrupt data
+ * @VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_8: invalid .ncf file
+ * @VXGE_HW_FW_UPGRADE_ERR_GENERIC_ERROR_UNKNOWN: generic error unknown type
+ * @VXGE_HW_FW_UPGRADE_ERR_FAILED_TO_FLASH: failed to flash image check failed
+ */
+enum vxge_hw_fw_upgrade_err_code {
+        VXGE_HW_FW_UPGRADE_ERR_CORRUPT_DATA_1           = 1,
+        VXGE_HW_FW_UPGRADE_ERR_BUFFER_OVERFLOW          = 2,
+        VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_3           = 3,
+        VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_4           = 4,
+        VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_5           = 5,
+        VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_6           = 6,
+        VXGE_HW_FW_UPGRADE_ERR_CORRUPT_DATA_7           = 7,
+        VXGE_HW_FW_UPGRADE_ERR_INV_NCF_FILE_8           = 8,
+        VXGE_HW_FW_UPGRADE_ERR_GENERIC_ERROR_UNKNOWN    = 9,
+        VXGE_HW_FW_UPGRADE_ERR_FAILED_TO_FLASH          = 10
+};
+
+/**
  * struct vxge_hw_device_date - Date Format
  * @day: Day
  * @month: Month
@@ -183,11 +222,6 @@ struct vxge_hw_device_version {
         char    version[VXGE_HW_FW_STRLEN];
 };
 
-u64
-__vxge_hw_vpath_pci_func_mode_get(
-        u32 vp_id,
-        struct vxge_hw_vpath_reg __iomem *vpath_reg);
-
 /**
  * struct vxge_hw_fifo_config - Configuration of fifo.
  * @enable: Is this fifo to be commissioned
@@ -280,9 +314,9 @@ struct vxge_hw_ring_config {
 #define VXGE_HW_RING_DEFAULT                                    1
 
         u32                             ring_blocks;
-#define VXGE_HW_MIN_RING_BLOCKS                         1
-#define VXGE_HW_MAX_RING_BLOCKS                         128
-#define VXGE_HW_DEF_RING_BLOCKS                         2
+#define VXGE_HW_MIN_RING_BLOCKS                                 1
+#define VXGE_HW_MAX_RING_BLOCKS                                 128
+#define VXGE_HW_DEF_RING_BLOCKS                                 2
 
         u32                             buffer_mode;
 #define VXGE_HW_RING_RXD_BUFFER_MODE_1                          1
@@ -378,44 +412,48 @@ struct vxge_hw_vp_config {
  * See also: struct vxge_hw_tim_intr_config{}.
  */
 struct vxge_hw_device_config {
-        u32                             dma_blockpool_initial;
-        u32                             dma_blockpool_max;
-#define VXGE_HW_MIN_DMA_BLOCK_POOL_SIZE                 0
-#define VXGE_HW_INITIAL_DMA_BLOCK_POOL_SIZE             0
-#define VXGE_HW_INCR_DMA_BLOCK_POOL_SIZE                4
-#define VXGE_HW_MAX_DMA_BLOCK_POOL_SIZE                 4096
-
-#define        VXGE_HW_MAX_PAYLOAD_SIZE_512             2
-
-        u32                             intr_mode;
-#define VXGE_HW_INTR_MODE_IRQLINE                       0
-#define VXGE_HW_INTR_MODE_MSIX                          1
-#define VXGE_HW_INTR_MODE_MSIX_ONE_SHOT                 2
-
-#define VXGE_HW_INTR_MODE_DEF                           0
-
-        u32                             rth_en;
-#define VXGE_HW_RTH_DISABLE                             0
-#define VXGE_HW_RTH_ENABLE                              1
-#define VXGE_HW_RTH_DEFAULT                             0
-
-        u32                             rth_it_type;
-#define VXGE_HW_RTH_IT_TYPE_SOLO_IT                     0
-#define VXGE_HW_RTH_IT_TYPE_MULTI_IT                    1
-#define VXGE_HW_RTH_IT_TYPE_DEFAULT                     0
-
-        u32                             rts_mac_en;
+        u32                                     device_poll_millis;
+#define VXGE_HW_MIN_DEVICE_POLL_MILLIS          1
+#define VXGE_HW_MAX_DEVICE_POLL_MILLIS          100000
+#define VXGE_HW_DEF_DEVICE_POLL_MILLIS          1000
+
+        u32                                     dma_blockpool_initial;
+        u32                                     dma_blockpool_max;
+#define VXGE_HW_MIN_DMA_BLOCK_POOL_SIZE         0
+#define VXGE_HW_INITIAL_DMA_BLOCK_POOL_SIZE     0
+#define VXGE_HW_INCR_DMA_BLOCK_POOL_SIZE        4
+#define VXGE_HW_MAX_DMA_BLOCK_POOL_SIZE         4096
+
+#define VXGE_HW_MAX_PAYLOAD_SIZE_512            2
+
+        u32                                     intr_mode:2,
+#define VXGE_HW_INTR_MODE_IRQLINE               0
+#define VXGE_HW_INTR_MODE_MSIX                  1
+#define VXGE_HW_INTR_MODE_MSIX_ONE_SHOT         2
+
+#define VXGE_HW_INTR_MODE_DEF                   0
+
+                                                rth_en:1,
+#define VXGE_HW_RTH_DISABLE                     0
+#define VXGE_HW_RTH_ENABLE                      1
+#define VXGE_HW_RTH_DEFAULT                     0
+
+                                                rth_it_type:1,
+#define VXGE_HW_RTH_IT_TYPE_SOLO_IT             0
+#define VXGE_HW_RTH_IT_TYPE_MULTI_IT            1
+#define VXGE_HW_RTH_IT_TYPE_DEFAULT             0
+
+                                                rts_mac_en:1,
 #define VXGE_HW_RTS_MAC_DISABLE                 0
 #define VXGE_HW_RTS_MAC_ENABLE                  1
 #define VXGE_HW_RTS_MAC_DEFAULT                 0
 
-        struct vxge_hw_vp_config        vp_config[VXGE_HW_MAX_VIRTUAL_PATHS];
-
-        u32                             device_poll_millis;
-#define VXGE_HW_MIN_DEVICE_POLL_MILLIS                  1
-#define VXGE_HW_MAX_DEVICE_POLL_MILLIS                  100000
-#define VXGE_HW_DEF_DEVICE_POLL_MILLIS                  1000
+                                                hwts_en:1;
+#define VXGE_HW_HWTS_DISABLE                    0
+#define VXGE_HW_HWTS_ENABLE                     1
+#define VXGE_HW_HWTS_DEFAULT                    1
 
+        struct vxge_hw_vp_config vp_config[VXGE_HW_MAX_VIRTUAL_PATHS];
 };
 
 /**
@@ -470,7 +508,6 @@ struct vxge_hw_device_config {
  * See also: vxge_hw_driver_initialize().
  */
 struct vxge_hw_uld_cbs {
-
         void (*link_up)(struct __vxge_hw_device *devh);
         void (*link_down)(struct __vxge_hw_device *devh);
         void (*crit_err)(struct __vxge_hw_device *devh,
@@ -649,6 +686,10 @@ struct __vxge_hw_virtualpath {
         u32                             vsport_number;
         u32                             max_kdfc_db;
         u32                             max_nofl_db;
+        u64                             tim_tti_cfg1_saved;
+        u64                             tim_tti_cfg3_saved;
+        u64                             tim_rti_cfg1_saved;
+        u64                             tim_rti_cfg3_saved;
 
         struct __vxge_hw_ring *____cacheline_aligned ringh;
         struct __vxge_hw_fifo *____cacheline_aligned fifoh;
@@ -657,6 +698,7 @@ struct __vxge_hw_virtualpath {
         struct vxge_hw_vpath_stats_hw_info      *hw_stats;
         struct vxge_hw_vpath_stats_hw_info      *hw_stats_sav;
         struct vxge_hw_vpath_stats_sw_info      *sw_stats;
+        spinlock_t lock;
 };
 
 /*
@@ -666,7 +708,7 @@ struct __vxge_hw_virtualpath {
  *
  * This structure is used to store the callback information.
  */
-struct __vxge_hw_vpath_handle{
+struct __vxge_hw_vpath_handle {
         struct list_head        item;
         struct __vxge_hw_virtualpath    *vpath;
 };
@@ -679,9 +721,6 @@ struct __vxge_hw_vpath_handle{
 /**
  * struct __vxge_hw_device  - Hal device object
  * @magic: Magic Number
- * @device_id: PCI Device Id of the adapter
- * @major_revision: PCI Device major revision
- * @minor_revision: PCI Device minor revision
  * @bar0: BAR0 virtual address.
  * @pdev: Physical device handle
  * @config: Confguration passed by the LL driver at initialization
@@ -693,9 +732,6 @@ struct __vxge_hw_device {
         u32                             magic;
 #define VXGE_HW_DEVICE_MAGIC            0x12345678
 #define VXGE_HW_DEVICE_DEAD             0xDEADDEAD
-        u16                             device_id;
-        u8                              major_revision;
-        u8                              minor_revision;
         void __iomem                    *bar0;
         struct pci_dev                  *pdev;
         struct net_device               *ndev;
@@ -736,6 +772,7 @@ struct __vxge_hw_device {
         u32                             debug_level;
         u32                             level_err;
         u32                             level_trace;
+        u16 eprom_versions[VXGE_HW_MAX_ROM_IMAGES];
 };
 
 #define VXGE_HW_INFO_LEN        64
@@ -786,8 +823,8 @@ struct vxge_hw_device_hw_info {
         u8              serial_number[VXGE_HW_INFO_LEN];
         u8              part_number[VXGE_HW_INFO_LEN];
         u8              product_desc[VXGE_HW_INFO_LEN];
-        u8 (mac_addrs)[VXGE_HW_MAX_VIRTUAL_PATHS][ETH_ALEN];
-        u8 (mac_addr_masks)[VXGE_HW_MAX_VIRTUAL_PATHS][ETH_ALEN];
+        u8 mac_addrs[VXGE_HW_MAX_VIRTUAL_PATHS][ETH_ALEN];
+        u8 mac_addr_masks[VXGE_HW_MAX_VIRTUAL_PATHS][ETH_ALEN];
 };
 
 /**
@@ -834,20 +871,10 @@ struct vxge_hw_device_attr {
                                 loc, \
                                 offset, \
                                 &val64);                        \
-                                                                \
         if (status != VXGE_HW_OK)                               \
                 return status;                                          \
 }
 
-#define VXGE_HW_VPATH_STATS_PIO_READ(offset) {                          \
-        status = __vxge_hw_vpath_stats_access(vpath, \
-                        VXGE_HW_STATS_OP_READ, \
-                        offset, \
-                        &val64);                                        \
-        if (status != VXGE_HW_OK)                                       \
-                return status;                                          \
-}
-
 /*
  * struct __vxge_hw_ring - Ring channel.
  * @channel: Channel "base" of this ring, the common part of all HW
@@ -902,6 +929,9 @@ struct __vxge_hw_ring {
         u32                                     doorbell_cnt;
         u32                                     total_db_cnt;
         u64                                     rxds_limit;
+        u32                                     rtimer;
+        u64                                     tim_rti_cfg1_saved;
+        u64                                     tim_rti_cfg3_saved;
 
         enum vxge_hw_status (*callback)(
                         struct __vxge_hw_ring *ringh,
@@ -981,6 +1011,9 @@ struct __vxge_hw_fifo {
         u32                                     per_txdl_space;
         u32                                     vp_id;
         u32                                     tx_intr_num;
+        u32                                     rtimer;
+        u64                                     tim_tti_cfg1_saved;
+        u64                                     tim_tti_cfg3_saved;
 
         enum vxge_hw_status (*callback)(
                         struct __vxge_hw_fifo *fifo_handle,
@@ -1119,7 +1152,7 @@ struct __vxge_hw_non_offload_db_wrapper {
  *             lookup to determine the transmit port.
  *             01: Send on physical Port1.
  *             10: Send on physical Port0.
-        *              11: Send on both ports.
+ *             11: Send on both ports.
  *             Bits 18 to 21 - Reserved
  *             Bits 22 to 23 - Gather_Code. This field is set by the host and
  *             is used to describe how individual buffers comprise a frame.
@@ -1418,17 +1451,14 @@ enum vxge_hw_rth_algoritms {
  * See also: vxge_hw_vpath_rts_rth_set(), vxge_hw_vpath_rts_rth_get().
  */
 struct vxge_hw_rth_hash_types {
-        u8 hash_type_tcpipv4_en;
-        u8 hash_type_ipv4_en;
-        u8 hash_type_tcpipv6_en;
-        u8 hash_type_ipv6_en;
-        u8 hash_type_tcpipv6ex_en;
-        u8 hash_type_ipv6ex_en;
+        u8 hash_type_tcpipv4_en:1,
+           hash_type_ipv4_en:1,
+           hash_type_tcpipv6_en:1,
+           hash_type_ipv6_en:1,
+           hash_type_tcpipv6ex_en:1,
+           hash_type_ipv6ex_en:1;
 };
 
-u32
-vxge_hw_device_debug_mask_get(struct __vxge_hw_device *devh);
-
 void vxge_hw_device_debug_set(
         struct __vxge_hw_device *devh,
         enum vxge_debug_level level,
@@ -1440,9 +1470,6 @@ vxge_hw_device_error_level_get(struct __vxge_hw_device *devh);
 u32
 vxge_hw_device_trace_level_get(struct __vxge_hw_device *devh);
 
-u32
-vxge_hw_device_debug_mask_get(struct __vxge_hw_device *devh);
-
 /**
  * vxge_hw_ring_rxd_size_get    - Get the size of ring descriptor.
  * @buf_mode: Buffer mode (1, 3 or 5)
@@ -1817,60 +1844,10 @@ struct vxge_hw_vpath_attr {
         struct vxge_hw_fifo_attr        fifo_attr;
 };
 
-enum vxge_hw_status
-__vxge_hw_blockpool_create(struct __vxge_hw_device *hldev,
-                        struct __vxge_hw_blockpool  *blockpool,
-                        u32 pool_size,
-                        u32 pool_max);
-
-void
-__vxge_hw_blockpool_destroy(struct __vxge_hw_blockpool  *blockpool);
-
-struct __vxge_hw_blockpool_entry *
-__vxge_hw_blockpool_block_allocate(struct __vxge_hw_device *hldev,
-                        u32 size);
-
-void
-__vxge_hw_blockpool_block_free(struct __vxge_hw_device *hldev,
-                        struct __vxge_hw_blockpool_entry *entry);
-
-void *
-__vxge_hw_blockpool_malloc(struct __vxge_hw_device *hldev,
-                        u32 size,
-                        struct vxge_hw_mempool_dma *dma_object);
-
-void
-__vxge_hw_blockpool_free(struct __vxge_hw_device *hldev,
-                        void *memblock,
-                        u32 size,
-                        struct vxge_hw_mempool_dma *dma_object);
-
-enum vxge_hw_status
-__vxge_hw_device_fifo_config_check(struct vxge_hw_fifo_config *fifo_config);
-
-enum vxge_hw_status
-__vxge_hw_device_config_check(struct vxge_hw_device_config *new_config);
-
-enum vxge_hw_status
-vxge_hw_mgmt_device_config(struct __vxge_hw_device *devh,
-                struct vxge_hw_device_config    *dev_config, int size);
-
 enum vxge_hw_status __devinit vxge_hw_device_hw_info_get(
         void __iomem *bar0,
         struct vxge_hw_device_hw_info *hw_info);
 
-enum vxge_hw_status
-__vxge_hw_vpath_fw_ver_get(
-        u32     vp_id,
-        struct vxge_hw_vpath_reg __iomem *vpath_reg,
-        struct vxge_hw_device_hw_info *hw_info);
-
-enum vxge_hw_status
-__vxge_hw_vpath_card_info_get(
-        u32 vp_id,
-        struct vxge_hw_vpath_reg __iomem *vpath_reg,
-        struct vxge_hw_device_hw_info *hw_info);
-
 enum vxge_hw_status __devinit vxge_hw_device_config_default_get(
         struct vxge_hw_device_config *device_config);
 
@@ -1954,29 +1931,6 @@ out:
         return vaddr;
 }
 
-extern void vxge_hw_blockpool_block_add(
-                        struct __vxge_hw_device *devh,
-                        void *block_addr,
-                        u32 length,
-                        struct pci_dev *dma_h,
-                        struct pci_dev *acc_handle);
-
-static inline void vxge_os_dma_malloc_async(struct pci_dev *pdev, void *devh,
-                                        unsigned long size)
-{
-        gfp_t flags;
-        void *vaddr;
-
-        if (in_interrupt())
-                flags = GFP_ATOMIC | GFP_DMA;
-        else
-                flags = GFP_KERNEL | GFP_DMA;
-
-        vaddr = kmalloc((size), flags);
-
-        vxge_hw_blockpool_block_add(devh, vaddr, size, pdev, pdev);
-}
-
 static inline void vxge_os_dma_free(struct pci_dev *pdev, const void *vaddr,
                         struct pci_dev **p_dma_acch)
 {
@@ -2010,40 +1964,6 @@ __vxge_hw_mempool_item_priv(
                             (*memblock_item_idx) * mempool->items_priv_size;
 }
 
-enum vxge_hw_status
-__vxge_hw_mempool_grow(
-        struct vxge_hw_mempool *mempool,
-        u32 num_allocate,
-        u32 *num_allocated);
-
-struct vxge_hw_mempool*
-__vxge_hw_mempool_create(
-        struct __vxge_hw_device *devh,
-        u32 memblock_size,
-        u32 item_size,
-        u32 private_size,
-        u32 items_initial,
-        u32 items_max,
-        struct vxge_hw_mempool_cbs *mp_callback,
-        void *userdata);
-
-struct __vxge_hw_channel*
-__vxge_hw_channel_allocate(struct __vxge_hw_vpath_handle *vph,
-                        enum __vxge_hw_channel_type type, u32 length,
-                        u32 per_dtr_space, void *userdata);
-
-void
-__vxge_hw_channel_free(
-        struct __vxge_hw_channel *channel);
-
-enum vxge_hw_status
-__vxge_hw_channel_initialize(
-        struct __vxge_hw_channel *channel);
-
-enum vxge_hw_status
-__vxge_hw_channel_reset(
-        struct __vxge_hw_channel *channel);
-
 /*
  * __vxge_hw_fifo_txdl_priv - Return the max fragments allocated
  * for the fifo.
@@ -2065,9 +1985,6 @@ enum vxge_hw_status vxge_hw_vpath_open(
         struct vxge_hw_vpath_attr *attr,
         struct __vxge_hw_vpath_handle **vpath_handle);
 
-enum vxge_hw_status
-__vxge_hw_device_vpath_reset_in_prog_check(u64 __iomem *vpath_rst_in_prog);
-
 enum vxge_hw_status vxge_hw_vpath_close(
         struct __vxge_hw_vpath_handle *vpath_handle);
 
@@ -2089,55 +2006,9 @@ enum vxge_hw_status vxge_hw_vpath_mtu_set(
         struct __vxge_hw_vpath_handle *vpath_handle,
         u32 new_mtu);
 
-enum vxge_hw_status vxge_hw_vpath_stats_enable(
-        struct __vxge_hw_vpath_handle *vpath_handle);
-
-enum vxge_hw_status
-__vxge_hw_vpath_stats_access(
-        struct __vxge_hw_virtualpath    *vpath,
-        u32                     operation,
-        u32                     offset,
-        u64                     *stat);
-
-enum vxge_hw_status
-__vxge_hw_vpath_xmac_tx_stats_get(
-        struct __vxge_hw_virtualpath    *vpath,
-        struct vxge_hw_xmac_vpath_tx_stats *vpath_tx_stats);
-
-enum vxge_hw_status
-__vxge_hw_vpath_xmac_rx_stats_get(
-        struct __vxge_hw_virtualpath    *vpath,
-        struct vxge_hw_xmac_vpath_rx_stats *vpath_rx_stats);
-
-enum vxge_hw_status
-__vxge_hw_vpath_stats_get(
-        struct __vxge_hw_virtualpath *vpath,
-        struct vxge_hw_vpath_stats_hw_info *hw_stats);
-
 void
 vxge_hw_vpath_rx_doorbell_init(struct __vxge_hw_vpath_handle *vp);
 
-enum vxge_hw_status
-__vxge_hw_device_vpath_config_check(struct vxge_hw_vp_config *vp_config);
-
-void
-__vxge_hw_device_pci_e_init(struct __vxge_hw_device *hldev);
-
-enum vxge_hw_status
-__vxge_hw_legacy_swapper_set(struct vxge_hw_legacy_reg __iomem *legacy_reg);
-
-enum vxge_hw_status
-__vxge_hw_vpath_swapper_set(struct vxge_hw_vpath_reg __iomem *vpath_reg);
-
-enum vxge_hw_status
-__vxge_hw_kdfc_swapper_set(struct vxge_hw_legacy_reg __iomem *legacy_reg,
-        struct vxge_hw_vpath_reg __iomem *vpath_reg);
-
-enum vxge_hw_status
-__vxge_hw_device_register_poll(
-        void __iomem    *reg,
-        u64 mask, u32 max_millis);
-
 #ifndef readq
 static inline u64 readq(void __iomem *addr)
 {
@@ -2168,64 +2039,14 @@ static inline void __vxge_hw_pio_mem_write32_lower(u32 val, void __iomem *addr)
         writel(val, addr);
 }
 
-static inline enum vxge_hw_status
-__vxge_hw_pio_mem_write64(u64 val64, void __iomem *addr,
-                          u64 mask, u32 max_millis)
-{
-        enum vxge_hw_status status = VXGE_HW_OK;
-
-        __vxge_hw_pio_mem_write32_lower((u32)vxge_bVALn(val64, 32, 32), addr);
-        wmb();
-        __vxge_hw_pio_mem_write32_upper((u32)vxge_bVALn(val64, 0, 32), addr);
-        wmb();
-
-        status = __vxge_hw_device_register_poll(addr, mask, max_millis);
-        return status;
-}
-
-struct vxge_hw_toc_reg __iomem *
-__vxge_hw_device_toc_get(void __iomem *bar0);
-
-enum vxge_hw_status
-__vxge_hw_device_reg_addr_get(struct __vxge_hw_device *hldev);
-
-void
-__vxge_hw_device_id_get(struct __vxge_hw_device *hldev);
-
-void
-__vxge_hw_device_host_info_get(struct __vxge_hw_device *hldev);
-
 enum vxge_hw_status
 vxge_hw_device_flick_link_led(struct __vxge_hw_device *devh, u64 on_off);
 
 enum vxge_hw_status
-__vxge_hw_device_initialize(struct __vxge_hw_device *hldev);
-
-enum vxge_hw_status
-__vxge_hw_vpath_pci_read(
-        struct __vxge_hw_virtualpath    *vpath,
-        u32                     phy_func_0,
-        u32                     offset,
-        u32                     *val);
-
-enum vxge_hw_status
-__vxge_hw_vpath_addr_get(
-        u32 vp_id,
-        struct vxge_hw_vpath_reg __iomem *vpath_reg,
-        u8 (macaddr)[ETH_ALEN],
-        u8 (macaddr_mask)[ETH_ALEN]);
-
-u32
-__vxge_hw_vpath_func_id_get(
-        u32 vp_id, struct vxge_hw_vpmgmt_reg __iomem *vpmgmt_reg);
-
-enum vxge_hw_status
-__vxge_hw_vpath_reset_check(struct __vxge_hw_virtualpath *vpath);
-
-enum vxge_hw_status
 vxge_hw_vpath_strip_fcs_check(struct __vxge_hw_device *hldev, u64 vpath_mask);
+
 /**
- * vxge_debug
+ * vxge_debug_ll
  * @level: level of debug verbosity.
  * @mask: mask for the debug
  * @buf: Circular buffer for tracing
@@ -2237,26 +2058,13 @@ vxge_hw_vpath_strip_fcs_check(struct __vxge_hw_device *hldev, u64 vpath_mask);
  * may be compiled out if DEBUG macro was never defined.
  * See also: enum vxge_debug_level{}.
  */
-
-#define vxge_trace_aux(level, mask, fmt, ...) \
-{\
-                vxge_os_vaprintf(level, mask, fmt, __VA_ARGS__);\
-}
-
-#define vxge_debug(module, level, mask, fmt, ...) { \
-if ((level >= VXGE_TRACE && ((module & VXGE_DEBUG_TRACE_MASK) == module)) || \
-        (level >= VXGE_ERR && ((module & VXGE_DEBUG_ERR_MASK) == module))) {\
-        if ((mask & VXGE_DEBUG_MASK) == mask)\
-                vxge_trace_aux(level, mask, fmt, __VA_ARGS__); \
-} \
-}
-
 #if (VXGE_COMPONENT_LL & VXGE_DEBUG_MODULE_MASK)
-#define vxge_debug_ll(level, mask, fmt, ...) \
-{\
-        vxge_debug(VXGE_COMPONENT_LL, level, mask, fmt, __VA_ARGS__);\
-}
-
+#define vxge_debug_ll(level, mask, fmt, ...) do {                              \
+        if ((level >= VXGE_ERR && VXGE_COMPONENT_LL & VXGE_DEBUG_ERR_MASK) ||  \
+            (level >= VXGE_TRACE && VXGE_COMPONENT_LL & VXGE_DEBUG_TRACE_MASK))\
+                if ((mask & VXGE_DEBUG_MASK) == mask)                          \
+                        printk(fmt "\n", __VA_ARGS__);                         \
+} while (0)
 #else
 #define vxge_debug_ll(level, mask, fmt, ...)
 #endif
@@ -2276,4 +2084,26 @@ enum vxge_hw_status vxge_hw_vpath_rts_rth_set(
 
 enum vxge_hw_status
 __vxge_hw_device_is_privilaged(u32 host_type, u32 func_id);
+
+#define VXGE_HW_MIN_SUCCESSIVE_IDLE_COUNT 5
+#define VXGE_HW_MAX_POLLING_COUNT 100
+
+void
+vxge_hw_device_wait_receive_idle(struct __vxge_hw_device *hldev);
+
+enum vxge_hw_status
+vxge_hw_upgrade_read_version(struct __vxge_hw_device *hldev, u32 *major,
+                             u32 *minor, u32 *build);
+
+enum vxge_hw_status vxge_hw_flash_fw(struct __vxge_hw_device *hldev);
+
+enum vxge_hw_status
+vxge_update_fw_image(struct __vxge_hw_device *hldev, const u8 *filebuf,
+                     int size);
+
+enum vxge_hw_status
+vxge_hw_vpath_eprom_img_ver_get(struct __vxge_hw_device *hldev,
+                                struct eprom_image *eprom_image_data);
+
+int vxge_hw_vpath_wait_receive_idle(struct __vxge_hw_device *hldev, u32 vp_id);
 #endif
diff --git a/drivers/net/vxge/vxge-ethtool.c b/drivers/net/vxge/vxge-ethtool.c
index 05679e306fdd..92dd72d3f9de 100644
--- a/drivers/net/vxge/vxge-ethtool.c
+++ b/drivers/net/vxge/vxge-ethtool.c
@@ -11,7 +11,7 @@
  *                 Virtualized Server Adapter.
  * Copyright(c) 2002-2010 Exar Corp.
  ******************************************************************************/
-#include<linux/ethtool.h>
+#include <linux/ethtool.h>
 #include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/etherdevice.h>
@@ -29,12 +29,12 @@
  * Return value:
  * 0 on success.
  */
-
 static int vxge_ethtool_sset(struct net_device *dev, struct ethtool_cmd *info)
 {
         /* We currently only support 10Gb/FULL */
         if ((info->autoneg == AUTONEG_ENABLE) ||
-            (info->speed != SPEED_10000) || (info->duplex != DUPLEX_FULL))
+            (ethtool_cmd_speed(info) != SPEED_10000) ||
+            (info->duplex != DUPLEX_FULL))
                 return -EINVAL;
 
         return 0;
@@ -59,10 +59,10 @@ static int vxge_ethtool_gset(struct net_device *dev, struct ethtool_cmd *info)
         info->transceiver = XCVR_EXTERNAL;
 
         if (netif_carrier_ok(dev)) {
-                info->speed = SPEED_10000;
+                ethtool_cmd_speed_set(info, SPEED_10000);
                 info->duplex = DUPLEX_FULL;
         } else {
-                info->speed = -1;
+                ethtool_cmd_speed_set(info, -1);
                 info->duplex = -1;
         }
 
@@ -79,10 +79,9 @@ static int vxge_ethtool_gset(struct net_device *dev, struct ethtool_cmd *info)
  * Returns driver specefic information like name, version etc.. to ethtool.
  */
 static void vxge_ethtool_gdrvinfo(struct net_device *dev,
-                        struct ethtool_drvinfo *info)
+                                  struct ethtool_drvinfo *info)
 {
-        struct vxgedev *vdev;
-        vdev = (struct vxgedev *)netdev_priv(dev);
+        struct vxgedev *vdev = netdev_priv(dev);
         strlcpy(info->driver, VXGE_DRIVER_NAME, sizeof(VXGE_DRIVER_NAME));
         strlcpy(info->version, DRV_VERSION, sizeof(DRV_VERSION));
         strlcpy(info->fw_version, vdev->fw_version, VXGE_HW_FW_STRLEN);
@@ -104,15 +103,14 @@ static void vxge_ethtool_gdrvinfo(struct net_device *dev,
  * buffer area.
  */
 static void vxge_ethtool_gregs(struct net_device *dev,
-                        struct ethtool_regs *regs, void *space)
+                               struct ethtool_regs *regs, void *space)
 {
         int index, offset;
         enum vxge_hw_status status;
         u64 reg;
-        u64 *reg_space = (u64 *) space;
-        struct vxgedev *vdev = (struct vxgedev *)netdev_priv(dev);
-        struct __vxge_hw_device  *hldev = (struct __vxge_hw_device *)
-                                        pci_get_drvdata(vdev->pdev);
+        u64 *reg_space = (u64 *)space;
+        struct vxgedev *vdev = netdev_priv(dev);
+        struct __vxge_hw_device *hldev = vdev->devh;
 
         regs->len = sizeof(struct vxge_hw_vpath_reg) * vdev->no_of_vpath;
         regs->version = vdev->pdev->subsystem_device;
@@ -137,23 +135,29 @@ static void vxge_ethtool_gregs(struct net_device *dev,
 /**
  * vxge_ethtool_idnic - To physically identify the nic on the system.
  * @dev : device pointer.
- * @id : pointer to the structure with identification parameters given by
- * ethtool.
+ * @state : requested LED state
  *
  * Used to physically identify the NIC on the system.
- * The Link LED will blink for a time specified by the user.
- * Return value:
  * 0 on success
  */
-static int vxge_ethtool_idnic(struct net_device *dev, u32 data)
+static int vxge_ethtool_idnic(struct net_device *dev,
+                              enum ethtool_phys_id_state state)
 {
-        struct vxgedev *vdev = (struct vxgedev *)netdev_priv(dev);
-        struct __vxge_hw_device  *hldev = (struct __vxge_hw_device  *)
-                        pci_get_drvdata(vdev->pdev);
+        struct vxgedev *vdev = netdev_priv(dev);
+        struct __vxge_hw_device *hldev = vdev->devh;
+
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                vxge_hw_device_flick_link_led(hldev, VXGE_FLICKER_ON);
+                break;
+
+        case ETHTOOL_ID_INACTIVE:
+                vxge_hw_device_flick_link_led(hldev, VXGE_FLICKER_OFF);
+                break;
 
-        vxge_hw_device_flick_link_led(hldev, VXGE_FLICKER_ON);
-        msleep_interruptible(data ? (data * HZ) : VXGE_MAX_FLICKER_TIME);
-        vxge_hw_device_flick_link_led(hldev, VXGE_FLICKER_OFF);
+        default:
+                return -EINVAL;
+        }
 
         return 0;
 }
@@ -168,11 +172,10 @@ static int vxge_ethtool_idnic(struct net_device *dev, u32 data)
  *  void
  */
 static void vxge_ethtool_getpause_data(struct net_device *dev,
-                                        struct ethtool_pauseparam *ep)
+                                       struct ethtool_pauseparam *ep)
 {
-        struct vxgedev *vdev = (struct vxgedev *)netdev_priv(dev);
-        struct __vxge_hw_device  *hldev = (struct __vxge_hw_device  *)
-                        pci_get_drvdata(vdev->pdev);
+        struct vxgedev *vdev = netdev_priv(dev);
+        struct __vxge_hw_device *hldev = vdev->devh;
 
         vxge_hw_device_getpause_data(hldev, 0, &ep->tx_pause, &ep->rx_pause);
 }
@@ -188,11 +191,10 @@ static void vxge_ethtool_getpause_data(struct net_device *dev,
  * int, returns 0 on Success
  */
 static int vxge_ethtool_setpause_data(struct net_device *dev,
-                                        struct ethtool_pauseparam *ep)
+                                      struct ethtool_pauseparam *ep)
 {
-        struct vxgedev *vdev = (struct vxgedev *)netdev_priv(dev);
-        struct __vxge_hw_device  *hldev = (struct __vxge_hw_device  *)
-                        pci_get_drvdata(vdev->pdev);
+        struct vxgedev *vdev = netdev_priv(dev);
+        struct __vxge_hw_device *hldev = vdev->devh;
 
         vxge_hw_device_setpause_data(hldev, 0, ep->tx_pause, ep->rx_pause);
 
@@ -209,9 +211,8 @@ static void vxge_get_ethtool_stats(struct net_device *dev,
         enum vxge_hw_status status;
         enum vxge_hw_status swstatus;
         struct vxge_vpath *vpath = NULL;
-
-        struct vxgedev *vdev = (struct vxgedev *)netdev_priv(dev);
-        struct __vxge_hw_device  *hldev = vdev->devh;
+        struct vxgedev *vdev = netdev_priv(dev);
+        struct __vxge_hw_device *hldev = vdev->devh;
         struct vxge_hw_xmac_stats *xmac_stats;
         struct vxge_hw_device_stats_sw_info *sw_stats;
         struct vxge_hw_device_stats_hw_info *hw_stats;
@@ -574,12 +575,12 @@ static void vxge_get_ethtool_stats(struct net_device *dev,
         kfree(hw_stats);
 }
 
-static void vxge_ethtool_get_strings(struct net_device *dev,
-                              u32 stringset, u8 *data)
+static void vxge_ethtool_get_strings(struct net_device *dev, u32 stringset,
+                                     u8 *data)
 {
         int stat_size = 0;
         int i, j;
-        struct vxgedev *vdev = (struct vxgedev *)netdev_priv(dev);
+        struct vxgedev *vdev = netdev_priv(dev);
         switch (stringset) {
         case ETH_SS_STATS:
                 vxge_add_string("VPATH STATISTICS%s\t\t\t",
@@ -1066,43 +1067,14 @@ static void vxge_ethtool_get_strings(struct net_device *dev,
 
 static int vxge_ethtool_get_regs_len(struct net_device *dev)
 {
-        struct vxgedev *vdev = (struct vxgedev *)netdev_priv(dev);
+        struct vxgedev *vdev = netdev_priv(dev);
 
         return sizeof(struct vxge_hw_vpath_reg) * vdev->no_of_vpath;
 }
 
-static u32 vxge_get_rx_csum(struct net_device *dev)
-{
-        struct vxgedev *vdev = (struct vxgedev *)netdev_priv(dev);
-
-        return vdev->rx_csum;
-}
-
-static int vxge_set_rx_csum(struct net_device *dev, u32 data)
-{
-        struct vxgedev *vdev = (struct vxgedev *)netdev_priv(dev);
-
-        if (data)
-                vdev->rx_csum = 1;
-        else
-                vdev->rx_csum = 0;
-
-        return 0;
-}
-
-static int vxge_ethtool_op_set_tso(struct net_device *dev, u32 data)
-{
-        if (data)
-                dev->features |= (NETIF_F_TSO | NETIF_F_TSO6);
-        else
-                dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
-
-        return 0;
-}
-
 static int vxge_ethtool_get_sset_count(struct net_device *dev, int sset)
 {
-        struct vxgedev *vdev = (struct vxgedev *)netdev_priv(dev);
+        struct vxgedev *vdev = netdev_priv(dev);
 
         switch (sset) {
         case ETH_SS_STATS:
@@ -1119,6 +1091,25 @@ static int vxge_ethtool_get_sset_count(struct net_device *dev, int sset)
         }
 }
 
+static int vxge_fw_flash(struct net_device *dev, struct ethtool_flash *parms)
+{
+        struct vxgedev *vdev = netdev_priv(dev);
+
+        if (vdev->max_vpath_supported != VXGE_HW_MAX_VIRTUAL_PATHS) {
+                printk(KERN_INFO "Single Function Mode is required to flash the"
+                       " firmware\n");
+                return -EINVAL;
+        }
+
+        if (netif_running(dev)) {
+                printk(KERN_INFO "Interface %s must be down to flash the "
+                       "firmware\n", dev->name);
+                return -EBUSY;
+        }
+
+        return vxge_fw_upgrade(vdev, parms->data, 1);
+}
+
 static const struct ethtool_ops vxge_ethtool_ops = {
         .get_settings           = vxge_ethtool_gset,
         .set_settings           = vxge_ethtool_sset,
@@ -1128,21 +1119,14 @@ static const struct ethtool_ops vxge_ethtool_ops = {
         .get_link               = ethtool_op_get_link,
         .get_pauseparam         = vxge_ethtool_getpause_data,
         .set_pauseparam         = vxge_ethtool_setpause_data,
-        .get_rx_csum            = vxge_get_rx_csum,
-        .set_rx_csum            = vxge_set_rx_csum,
-        .get_tx_csum            = ethtool_op_get_tx_csum,
-        .set_tx_csum            = ethtool_op_set_tx_hw_csum,
-        .get_sg                 = ethtool_op_get_sg,
-        .set_sg                 = ethtool_op_set_sg,
-        .get_tso                = ethtool_op_get_tso,
-        .set_tso                = vxge_ethtool_op_set_tso,
         .get_strings            = vxge_ethtool_get_strings,
-        .phys_id                = vxge_ethtool_idnic,
+        .set_phys_id            = vxge_ethtool_idnic,
         .get_sset_count         = vxge_ethtool_get_sset_count,
         .get_ethtool_stats      = vxge_get_ethtool_stats,
+        .flash_device           = vxge_fw_flash,
 };
 
-void initialize_ethtool_ops(struct net_device *ndev)
+void vxge_initialize_ethtool_ops(struct net_device *ndev)
 {
         SET_ETHTOOL_OPS(ndev, &vxge_ethtool_ops);
 }
diff --git a/drivers/net/vxge/vxge-main.c b/drivers/net/vxge/vxge-main.c
index c7c5605b3728..8ab870a2ad02 100644
--- a/drivers/net/vxge/vxge-main.c
+++ b/drivers/net/vxge/vxge-main.c
@@ -50,6 +50,9 @@
 #include <net/ip.h>
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
+#include <linux/firmware.h>
+#include <linux/net_tstamp.h>
+#include <linux/prefetch.h>
 #include "vxge-main.h"
 #include "vxge-reg.h"
 
@@ -138,11 +141,10 @@ static inline void VXGE_COMPLETE_ALL_RX(struct vxgedev *vdev)
  * This function is called during interrupt context to notify link up state
  * change.
  */
-void
-vxge_callback_link_up(struct __vxge_hw_device *hldev)
+static void vxge_callback_link_up(struct __vxge_hw_device *hldev)
 {
         struct net_device *dev = hldev->ndev;
-        struct vxgedev *vdev = (struct vxgedev *)netdev_priv(dev);
+        struct vxgedev *vdev = netdev_priv(dev);
 
         vxge_debug_entryexit(VXGE_TRACE, "%s: %s:%d",
                 vdev->ndev->name, __func__, __LINE__);
@@ -162,11 +164,10 @@ vxge_callback_link_up(struct __vxge_hw_device *hldev)
  * This function is called during interrupt context to notify link down state
  * change.
  */
-void
-vxge_callback_link_down(struct __vxge_hw_device *hldev)
+static void vxge_callback_link_down(struct __vxge_hw_device *hldev)
 {
         struct net_device *dev = hldev->ndev;
-        struct vxgedev *vdev = (struct vxgedev *)netdev_priv(dev);
+        struct vxgedev *vdev = netdev_priv(dev);
 
         vxge_debug_entryexit(VXGE_TRACE,
                 "%s: %s:%d", vdev->ndev->name, __func__, __LINE__);
@@ -185,7 +186,7 @@ vxge_callback_link_down(struct __vxge_hw_device *hldev)
  *
  * Allocate SKB.
  */
-static struct sk_buff*
+static struct sk_buff *
 vxge_rx_alloc(void *dtrh, struct vxge_ring *ring, const int skb_size)
 {
         struct net_device    *dev;
@@ -304,22 +305,14 @@ vxge_rx_complete(struct vxge_ring *ring, struct sk_buff *skb, u16 vlan,
                 "%s: %s:%d  skb protocol = %d",
                 ring->ndev->name, __func__, __LINE__, skb->protocol);
 
-        if (ring->gro_enable) {
-                if (ring->vlgrp && ext_info->vlan &&
-                        (ring->vlan_tag_strip ==
-                                VXGE_HW_VPATH_RPA_STRIP_VLAN_TAG_ENABLE))
-                        vlan_gro_receive(ring->napi_p, ring->vlgrp,
-                                        ext_info->vlan, skb);
-                else
-                        napi_gro_receive(ring->napi_p, skb);
-        } else {
-                if (ring->vlgrp && vlan &&
-                        (ring->vlan_tag_strip ==
-                                VXGE_HW_VPATH_RPA_STRIP_VLAN_TAG_ENABLE))
-                        vlan_hwaccel_receive_skb(skb, ring->vlgrp, vlan);
-                else
-                        netif_receive_skb(skb);
-        }
+        if (ring->vlgrp && ext_info->vlan &&
+                (ring->vlan_tag_strip ==
+                        VXGE_HW_VPATH_RPA_STRIP_VLAN_TAG_ENABLE))
+                vlan_gro_receive(ring->napi_p, ring->vlgrp,
+                                ext_info->vlan, skb);
+        else
+                napi_gro_receive(ring->napi_p, skb);
+
         vxge_debug_entryexit(VXGE_TRACE,
                 "%s: %s:%d Exiting...", ring->ndev->name, __func__, __LINE__);
 }
@@ -354,12 +347,12 @@ static inline void vxge_post(int *dtr_cnt, void **first_dtr,
  * If the interrupt is because of a received frame or if the receive ring
  * contains fresh as yet un-processed frames, this function is called.
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 vxge_rx_1b_compl(struct __vxge_hw_ring *ringh, void *dtr,
                  u8 t_code, void *userdata)
 {
         struct vxge_ring *ring = (struct vxge_ring *)userdata;
-        struct  net_device *dev = ring->ndev;
+        struct net_device *dev = ring->ndev;
         unsigned int dma_sizes;
         void *first_dtr = NULL;
         int dtr_cnt = 0;
@@ -371,9 +364,6 @@ vxge_rx_1b_compl(struct __vxge_hw_ring *ringh, void *dtr,
         struct vxge_hw_ring_rxd_info ext_info;
         vxge_debug_entryexit(VXGE_TRACE, "%s: %s:%d",
                 ring->ndev->name, __func__, __LINE__);
-        ring->pkts_processed = 0;
-
-        vxge_hw_ring_replenish(ringh);
 
         do {
                 prefetch((char *)dtr + L1_CACHE_BYTES);
@@ -403,7 +393,6 @@ vxge_rx_1b_compl(struct __vxge_hw_ring *ringh, void *dtr,
 
                 prefetch((char *)skb + L1_CACHE_BYTES);
                 if (unlikely(t_code)) {
-
                         if (vxge_hw_ring_handle_tcode(ringh, dtr, t_code) !=
                                 VXGE_HW_OK) {
 
@@ -426,9 +415,7 @@ vxge_rx_1b_compl(struct __vxge_hw_ring *ringh, void *dtr,
                 }
 
                 if (pkt_length > VXGE_LL_RX_COPY_THRESHOLD) {
-
                         if (vxge_rx_alloc(dtr, ring, data_size) != NULL) {
-
                                 if (!vxge_rx_map(dtr, ring)) {
                                         skb_put(skb, pkt_length);
 
@@ -496,12 +483,29 @@ vxge_rx_1b_compl(struct __vxge_hw_ring *ringh, void *dtr,
 
                 if ((ext_info.proto & VXGE_HW_FRAME_PROTO_TCP_OR_UDP) &&
                     !(ext_info.proto & VXGE_HW_FRAME_PROTO_IP_FRAG) &&
-                    ring->rx_csum && /* Offload Rx side CSUM */
+                    (dev->features & NETIF_F_RXCSUM) && /* Offload Rx side CSUM */
                     ext_info.l3_cksum == VXGE_HW_L3_CKSUM_OK &&
                     ext_info.l4_cksum == VXGE_HW_L4_CKSUM_OK)
                         skb->ip_summed = CHECKSUM_UNNECESSARY;
                 else
-                        skb->ip_summed = CHECKSUM_NONE;
+                        skb_checksum_none_assert(skb);
+
+
+                if (ring->rx_hwts) {
+                        struct skb_shared_hwtstamps *skb_hwts;
+                        u32 ns = *(u32 *)(skb->head + pkt_length);
+
+                        skb_hwts = skb_hwtstamps(skb);
+                        skb_hwts->hwtstamp = ns_to_ktime(ns);
+                        skb_hwts->syststamp.tv64 = 0;
+                }
+
+                /* rth_hash_type and rth_it_hit are non-zero regardless of
+                 * whether rss is enabled.  Only the rth_value is zero/non-zero
+                 * if rss is disabled/enabled, so key off of that.
+                 */
+                if (ext_info.rth_value)
+                        skb->rxhash = ext_info.rth_value;
 
                 vxge_rx_complete(ring, skb, ext_info.vlan,
                         pkt_length, &ext_info);
@@ -531,7 +535,7 @@ vxge_rx_1b_compl(struct __vxge_hw_ring *ringh, void *dtr,
  * freed and frees all skbs whose data have already DMA'ed into the NICs
  * internal memory.
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 vxge_xmit_compl(struct __vxge_hw_fifo *fifo_hw, void *dtr,
                 enum vxge_hw_fifo_tcode t_code, void *userdata,
                 struct sk_buff ***skb_ptr, int nr_skb, int *more)
@@ -650,6 +654,65 @@ static enum vxge_hw_status vxge_search_mac_addr_in_list(
         return FALSE;
 }
 
+static int vxge_mac_list_add(struct vxge_vpath *vpath, struct macInfo *mac)
+{
+        struct vxge_mac_addrs *new_mac_entry;
+        u8 *mac_address = NULL;
+
+        if (vpath->mac_addr_cnt >= VXGE_MAX_LEARN_MAC_ADDR_CNT)
+                return TRUE;
+
+        new_mac_entry = kzalloc(sizeof(struct vxge_mac_addrs), GFP_ATOMIC);
+        if (!new_mac_entry) {
+                vxge_debug_mem(VXGE_ERR,
+                        "%s: memory allocation failed",
+                        VXGE_DRIVER_NAME);
+                return FALSE;
+        }
+
+        list_add(&new_mac_entry->item, &vpath->mac_addr_list);
+
+        /* Copy the new mac address to the list */
+        mac_address = (u8 *)&new_mac_entry->macaddr;
+        memcpy(mac_address, mac->macaddr, ETH_ALEN);
+
+        new_mac_entry->state = mac->state;
+        vpath->mac_addr_cnt++;
+
+        /* Is this a multicast address */
+        if (0x01 & mac->macaddr[0])
+                vpath->mcast_addr_cnt++;
+
+        return TRUE;
+}
+
+/* Add a mac address to DA table */
+static enum vxge_hw_status
+vxge_add_mac_addr(struct vxgedev *vdev, struct macInfo *mac)
+{
+        enum vxge_hw_status status = VXGE_HW_OK;
+        struct vxge_vpath *vpath;
+        enum vxge_hw_vpath_mac_addr_add_mode duplicate_mode;
+
+        if (0x01 & mac->macaddr[0]) /* multicast address */
+                duplicate_mode = VXGE_HW_VPATH_MAC_ADDR_ADD_DUPLICATE;
+        else
+                duplicate_mode = VXGE_HW_VPATH_MAC_ADDR_REPLACE_DUPLICATE;
+
+        vpath = &vdev->vpaths[mac->vpath_no];
+        status = vxge_hw_vpath_mac_addr_add(vpath->handle, mac->macaddr,
+                                                mac->macmask, duplicate_mode);
+        if (status != VXGE_HW_OK) {
+                vxge_debug_init(VXGE_ERR,
+                        "DA config add entry failed for vpath:%d",
+                        vpath->device_id);
+        } else
+                if (FALSE == vxge_mac_list_add(vpath, mac))
+                        status = -EPERM;
+
+        return status;
+}
+
 static int vxge_learn_mac(struct vxgedev *vdev, u8 *mac_header)
 {
         struct macInfo mac_info;
@@ -660,7 +723,7 @@ static int vxge_learn_mac(struct vxgedev *vdev, u8 *mac_header)
         struct vxge_vpath *vpath = NULL;
         struct __vxge_hw_device *hldev;
 
-        hldev = (struct __vxge_hw_device *) pci_get_drvdata(vdev->pdev);
+        hldev = pci_get_drvdata(vdev->pdev);
 
         mac_address = (u8 *)&mac_addr;
         memcpy(mac_address, mac_header, ETH_ALEN);
@@ -759,7 +822,7 @@ vxge_xmit(struct sk_buff *skb, struct net_device *dev)
                 return NETDEV_TX_OK;
         }
 
-        vdev = (struct vxgedev *)netdev_priv(dev);
+        vdev = netdev_priv(dev);
 
         if (unlikely(!is_vxge_card_up(vdev))) {
                 vxge_debug_tx(VXGE_ERR,
@@ -822,7 +885,7 @@ vxge_xmit(struct sk_buff *skb, struct net_device *dev)
                 dev->name, __func__, __LINE__,
                 fifo_hw, dtr, dtr_priv);
 
-        if (vdev->vlgrp && vlan_tx_tag_present(skb)) {
+        if (vlan_tx_tag_present(skb)) {
                 u16 vlan_tag = vlan_tx_tag_get(skb);
                 vxge_hw_fifo_txdl_vlan_set(dtr, vlan_tag);
         }
@@ -995,6 +1058,50 @@ vxge_tx_term(void *dtrh, enum vxge_hw_txdl_state state, void *userdata)
                 "%s:%d  Exiting...", __func__, __LINE__);
 }
 
+static int vxge_mac_list_del(struct vxge_vpath *vpath, struct macInfo *mac)
+{
+        struct list_head *entry, *next;
+        u64 del_mac = 0;
+        u8 *mac_address = (u8 *) (&del_mac);
+
+        /* Copy the mac address to delete from the list */
+        memcpy(mac_address, mac->macaddr, ETH_ALEN);
+
+        list_for_each_safe(entry, next, &vpath->mac_addr_list) {
+                if (((struct vxge_mac_addrs *)entry)->macaddr == del_mac) {
+                        list_del(entry);
+                        kfree((struct vxge_mac_addrs *)entry);
+                        vpath->mac_addr_cnt--;
+
+                        /* Is this a multicast address */
+                        if (0x01 & mac->macaddr[0])
+                                vpath->mcast_addr_cnt--;
+                        return TRUE;
+                }
+        }
+
+        return FALSE;
+}
+
+/* delete a mac address from DA table */
+static enum vxge_hw_status
+vxge_del_mac_addr(struct vxgedev *vdev, struct macInfo *mac)
+{
+        enum vxge_hw_status status = VXGE_HW_OK;
+        struct vxge_vpath *vpath;
+
+        vpath = &vdev->vpaths[mac->vpath_no];
+        status = vxge_hw_vpath_mac_addr_delete(vpath->handle, mac->macaddr,
+                                                mac->macmask);
+        if (status != VXGE_HW_OK) {
+                vxge_debug_init(VXGE_ERR,
+                        "DA config delete entry failed for vpath:%d",
+                        vpath->device_id);
+        } else
+                vxge_mac_list_del(vpath, mac);
+        return status;
+}
+
 /**
  * vxge_set_multicast
  * @dev: pointer to the device structure
@@ -1024,7 +1131,7 @@ static void vxge_set_multicast(struct net_device *dev)
         vxge_debug_entryexit(VXGE_TRACE,
                 "%s:%d", __func__, __LINE__);
 
-        vdev = (struct vxgedev *)netdev_priv(dev);
+        vdev = netdev_priv(dev);
         hldev = (struct __vxge_hw_device  *)vdev->devh;
 
         if (unlikely(!is_vxge_card_up(vdev)))
@@ -1084,7 +1191,7 @@ static void vxge_set_multicast(struct net_device *dev)
                 /* Delete previous MC's */
                 for (i = 0; i < mcast_cnt; i++) {
                         list_for_each_safe(entry, next, list_head) {
-                                mac_entry = (struct vxge_mac_addrs *) entry;
+                                mac_entry = (struct vxge_mac_addrs *)entry;
                                 /* Copy the mac address to delete */
                                 mac_address = (u8 *)&mac_entry->macaddr;
                                 memcpy(mac_info.macaddr, mac_address, ETH_ALEN);
@@ -1127,7 +1234,7 @@ _set_all_mcast:
                 /* Delete previous MC's */
                 for (i = 0; i < mcast_cnt; i++) {
                         list_for_each_safe(entry, next, list_head) {
-                                mac_entry = (struct vxge_mac_addrs *) entry;
+                                mac_entry = (struct vxge_mac_addrs *)entry;
                                 /* Copy the mac address to delete */
                                 mac_address = (u8 *)&mac_entry->macaddr;
                                 memcpy(mac_info.macaddr, mac_address, ETH_ALEN);
@@ -1174,14 +1281,14 @@ static int vxge_set_mac_addr(struct net_device *dev, void *p)
 {
         struct sockaddr *addr = p;
         struct vxgedev *vdev;
-        struct __vxge_hw_device  *hldev;
+        struct __vxge_hw_device *hldev;
         enum vxge_hw_status status = VXGE_HW_OK;
         struct macInfo mac_info_new, mac_info_old;
         int vpath_idx = 0;
 
         vxge_debug_entryexit(VXGE_TRACE, "%s:%d", __func__, __LINE__);
 
-        vdev = (struct vxgedev *)netdev_priv(dev);
+        vdev = netdev_priv(dev);
         hldev = vdev->devh;
 
         if (!is_valid_ether_addr(addr->sa_data))
@@ -1246,7 +1353,7 @@ static int vxge_set_mac_addr(struct net_device *dev, void *p)
  *
  * Enables the interrupts for the vpath
 */
-void vxge_vpath_intr_enable(struct vxgedev *vdev, int vp_id)
+static void vxge_vpath_intr_enable(struct vxgedev *vdev, int vp_id)
 {
         struct vxge_vpath *vpath = &vdev->vpaths[vp_id];
         int msix_id = 0;
@@ -1279,11 +1386,16 @@ void vxge_vpath_intr_enable(struct vxgedev *vdev, int vp_id)
  *
  * Disables the interrupts for the vpath
 */
-void vxge_vpath_intr_disable(struct vxgedev *vdev, int vp_id)
+static void vxge_vpath_intr_disable(struct vxgedev *vdev, int vp_id)
 {
         struct vxge_vpath *vpath = &vdev->vpaths[vp_id];
+        struct __vxge_hw_device *hldev;
         int msix_id;
 
+        hldev = pci_get_drvdata(vdev->pdev);
+
+        vxge_hw_vpath_wait_receive_idle(hldev, vpath->device_id);
+
         vxge_hw_vpath_intr_disable(vpath->handle);
 
         if (vdev->config.intr_type == INTA)
@@ -1300,6 +1412,95 @@ void vxge_vpath_intr_disable(struct vxgedev *vdev, int vp_id)
         }
 }
 
+/* list all mac addresses from DA table */
+static enum vxge_hw_status
+vxge_search_mac_addr_in_da_table(struct vxge_vpath *vpath, struct macInfo *mac)
+{
+        enum vxge_hw_status status = VXGE_HW_OK;
+        unsigned char macmask[ETH_ALEN];
+        unsigned char macaddr[ETH_ALEN];
+
+        status = vxge_hw_vpath_mac_addr_get(vpath->handle,
+                                macaddr, macmask);
+        if (status != VXGE_HW_OK) {
+                vxge_debug_init(VXGE_ERR,
+                        "DA config list entry failed for vpath:%d",
+                        vpath->device_id);
+                return status;
+        }
+
+        while (memcmp(mac->macaddr, macaddr, ETH_ALEN)) {
+                status = vxge_hw_vpath_mac_addr_get_next(vpath->handle,
+                                macaddr, macmask);
+                if (status != VXGE_HW_OK)
+                        break;
+        }
+
+        return status;
+}
+
+/* Store all mac addresses from the list to the DA table */
+static enum vxge_hw_status vxge_restore_vpath_mac_addr(struct vxge_vpath *vpath)
+{
+        enum vxge_hw_status status = VXGE_HW_OK;
+        struct macInfo mac_info;
+        u8 *mac_address = NULL;
+        struct list_head *entry, *next;
+
+        memset(&mac_info, 0, sizeof(struct macInfo));
+
+        if (vpath->is_open) {
+                list_for_each_safe(entry, next, &vpath->mac_addr_list) {
+                        mac_address =
+                                (u8 *)&
+                                ((struct vxge_mac_addrs *)entry)->macaddr;
+                        memcpy(mac_info.macaddr, mac_address, ETH_ALEN);
+                        ((struct vxge_mac_addrs *)entry)->state =
+                                VXGE_LL_MAC_ADDR_IN_DA_TABLE;
+                        /* does this mac address already exist in da table? */
+                        status = vxge_search_mac_addr_in_da_table(vpath,
+                                &mac_info);
+                        if (status != VXGE_HW_OK) {
+                                /* Add this mac address to the DA table */
+                                status = vxge_hw_vpath_mac_addr_add(
+                                        vpath->handle, mac_info.macaddr,
+                                        mac_info.macmask,
+                                    VXGE_HW_VPATH_MAC_ADDR_ADD_DUPLICATE);
+                                if (status != VXGE_HW_OK) {
+                                        vxge_debug_init(VXGE_ERR,
+                                            "DA add entry failed for vpath:%d",
+                                            vpath->device_id);
+                                        ((struct vxge_mac_addrs *)entry)->state
+                                                = VXGE_LL_MAC_ADDR_IN_LIST;
+                                }
+                        }
+                }
+        }
+
+        return status;
+}
+
+/* Store all vlan ids from the list to the vid table */
+static enum vxge_hw_status
+vxge_restore_vpath_vid_table(struct vxge_vpath *vpath)
+{
+        enum vxge_hw_status status = VXGE_HW_OK;
+        struct vxgedev *vdev = vpath->vdev;
+        u16 vid;
+
+        if (vdev->vlgrp && vpath->is_open) {
+
+                for (vid = 0; vid < VLAN_N_VID; vid++) {
+                        if (!vlan_group_get_device(vdev->vlgrp, vid))
+                                continue;
+                        /* Add these vlan to the vid table */
+                        status = vxge_hw_vpath_vid_add(vpath->handle, vid);
+                }
+        }
+
+        return status;
+}
+
 /*
  * vxge_reset_vpath
  * @vdev: pointer to vdev
@@ -1377,6 +1578,36 @@ static int vxge_reset_vpath(struct vxgedev *vdev, int vp_id)
         return ret;
 }
 
+/* Configure CI */
+static void vxge_config_ci_for_tti_rti(struct vxgedev *vdev)
+{
+        int i = 0;
+
+        /* Enable CI for RTI */
+        if (vdev->config.intr_type == MSI_X) {
+                for (i = 0; i < vdev->no_of_vpath; i++) {
+                        struct __vxge_hw_ring *hw_ring;
+
+                        hw_ring = vdev->vpaths[i].ring.handle;
+                        vxge_hw_vpath_dynamic_rti_ci_set(hw_ring);
+                }
+        }
+
+        /* Enable CI for TTI */
+        for (i = 0; i < vdev->no_of_vpath; i++) {
+                struct __vxge_hw_fifo *hw_fifo = vdev->vpaths[i].fifo.handle;
+                vxge_hw_vpath_tti_ci_set(hw_fifo);
+                /*
+                 * For Inta (with or without napi), Set CI ON for only one
+                 * vpath. (Have only one free running timer).
+                 */
+                if ((vdev->config.intr_type == INTA) && (i == 0))
+                        break;
+        }
+
+        return;
+}
+
 static int do_vxge_reset(struct vxgedev *vdev, int event)
 {
         enum vxge_hw_status status;
@@ -1395,12 +1626,16 @@ static int do_vxge_reset(struct vxgedev *vdev, int event)
         }
 
         if (event == VXGE_LL_FULL_RESET) {
+                netif_carrier_off(vdev->ndev);
+
                 /* wait for all the vpath reset to complete */
                 for (vp_id = 0; vp_id < vdev->no_of_vpath; vp_id++) {
                         while (test_bit(vp_id, &vdev->vp_reset))
                                 msleep(50);
                 }
 
+                netif_carrier_on(vdev->ndev);
+
                 /* if execution mode is set to debug, don't reset the adapter */
                 if (unlikely(vdev->exec_mode)) {
                         vxge_debug_init(VXGE_ERR,
@@ -1413,6 +1648,7 @@ static int do_vxge_reset(struct vxgedev *vdev, int event)
         }
 
         if (event == VXGE_LL_FULL_RESET) {
+                vxge_hw_device_wait_receive_idle(vdev->devh);
                 vxge_hw_device_intr_disable(vdev->devh);
 
                 switch (vdev->cric_err_event) {
@@ -1537,6 +1773,9 @@ static int do_vxge_reset(struct vxgedev *vdev, int event)
                 netif_tx_wake_all_queues(vdev->ndev);
         }
 
+        /* configure CI */
+        vxge_config_ci_for_tti_rti(vdev);
+
 out:
         vxge_debug_entryexit(VXGE_TRACE,
                 "%s:%d  Exiting...", __func__, __LINE__);
@@ -1553,9 +1792,14 @@ out:
  *
  * driver may reset the chip on events of serr, eccerr, etc
  */
-int vxge_reset(struct vxgedev *vdev)
+static void vxge_reset(struct work_struct *work)
 {
-        return do_vxge_reset(vdev, VXGE_LL_FULL_RESET);
+        struct vxgedev *vdev = container_of(work, struct vxgedev, reset_task);
+
+        if (!netif_running(vdev->ndev))
+                return;
+
+        do_vxge_reset(vdev, VXGE_LL_FULL_RESET);
 }
 
 /**
@@ -1572,22 +1816,29 @@ int vxge_reset(struct vxgedev *vdev)
  */
 static int vxge_poll_msix(struct napi_struct *napi, int budget)
 {
-        struct vxge_ring *ring =
-                container_of(napi, struct vxge_ring, napi);
+        struct vxge_ring *ring = container_of(napi, struct vxge_ring, napi);
+        int pkts_processed;
         int budget_org = budget;
-        ring->budget = budget;
 
+        ring->budget = budget;
+        ring->pkts_processed = 0;
         vxge_hw_vpath_poll_rx(ring->handle);
+        pkts_processed = ring->pkts_processed;
 
         if (ring->pkts_processed < budget_org) {
                 napi_complete(napi);
+
                 /* Re enable the Rx interrupts for the vpath */
                 vxge_hw_channel_msix_unmask(
                                 (struct __vxge_hw_channel *)ring->handle,
                                 ring->rx_vector_no);
+                mmiowb();
         }
 
-        return ring->pkts_processed;
+        /* We are copying and returning the local variable, in case if after
+         * clearing the msix interrupt above, if the interrupt fires right
+         * away which can preempt this NAPI thread */
+        return pkts_processed;
 }
 
 static int vxge_poll_inta(struct napi_struct *napi, int budget)
@@ -1598,12 +1849,12 @@ static int vxge_poll_inta(struct napi_struct *napi, int budget)
         int budget_org = budget;
         struct vxge_ring *ring;
 
-        struct __vxge_hw_device  *hldev = (struct __vxge_hw_device *)
-                pci_get_drvdata(vdev->pdev);
+        struct __vxge_hw_device *hldev = pci_get_drvdata(vdev->pdev);
 
         for (i = 0; i < vdev->no_of_vpath; i++) {
                 ring = &vdev->vpaths[i].ring;
                 ring->budget = budget;
+                ring->pkts_processed = 0;
                 vxge_hw_vpath_poll_rx(ring->handle);
                 pkts_processed += ring->pkts_processed;
                 budget -= ring->pkts_processed;
@@ -1635,11 +1886,11 @@ static int vxge_poll_inta(struct napi_struct *napi, int budget)
  */
 static void vxge_netpoll(struct net_device *dev)
 {
-        struct __vxge_hw_device  *hldev;
+        struct __vxge_hw_device *hldev;
         struct vxgedev *vdev;
 
-        vdev = (struct vxgedev *)netdev_priv(dev);
-        hldev = (struct __vxge_hw_device  *)pci_get_drvdata(vdev->pdev);
+        vdev = netdev_priv(dev);
+        hldev = pci_get_drvdata(vdev->pdev);
 
         vxge_debug_entryexit(VXGE_TRACE, "%s:%d", __func__, __LINE__);
 
@@ -1679,15 +1930,6 @@ static enum vxge_hw_status vxge_rth_configure(struct vxgedev *vdev)
                 mtable[index] = index % vdev->no_of_vpath;
         }
 
-        /* Fill RTH hash types */
-        hash_types.hash_type_tcpipv4_en   = vdev->config.rth_hash_type_tcpipv4;
-        hash_types.hash_type_ipv4_en      = vdev->config.rth_hash_type_ipv4;
-        hash_types.hash_type_tcpipv6_en   = vdev->config.rth_hash_type_tcpipv6;
-        hash_types.hash_type_ipv6_en      = vdev->config.rth_hash_type_ipv6;
-        hash_types.hash_type_tcpipv6ex_en =
-                                        vdev->config.rth_hash_type_tcpipv6ex;
-        hash_types.hash_type_ipv6ex_en    = vdev->config.rth_hash_type_ipv6ex;
-
         /* set indirection table, bucket-to-vpath mapping */
         status = vxge_hw_vpath_rts_rth_itable_set(vdev->vp_handles,
                                                 vdev->no_of_vpath,
@@ -1700,19 +1942,27 @@ static enum vxge_hw_status vxge_rth_configure(struct vxgedev *vdev)
                 return status;
         }
 
+        /* Fill RTH hash types */
+        hash_types.hash_type_tcpipv4_en   = vdev->config.rth_hash_type_tcpipv4;
+        hash_types.hash_type_ipv4_en      = vdev->config.rth_hash_type_ipv4;
+        hash_types.hash_type_tcpipv6_en   = vdev->config.rth_hash_type_tcpipv6;
+        hash_types.hash_type_ipv6_en      = vdev->config.rth_hash_type_ipv6;
+        hash_types.hash_type_tcpipv6ex_en =
+                                        vdev->config.rth_hash_type_tcpipv6ex;
+        hash_types.hash_type_ipv6ex_en    = vdev->config.rth_hash_type_ipv6ex;
+
         /*
-        * Because the itable_set() method uses the active_table field
-        * for the target virtual path the RTH config should be updated
-        * for all VPATHs. The h/w only uses the lowest numbered VPATH
-        * when steering frames.
-        */
+         * Because the itable_set() method uses the active_table field
+         * for the target virtual path the RTH config should be updated
+         * for all VPATHs. The h/w only uses the lowest numbered VPATH
+         * when steering frames.
+         */
          for (index = 0; index < vdev->no_of_vpath; index++) {
                 status = vxge_hw_vpath_rts_rth_set(
                                 vdev->vpaths[index].handle,
                                 vdev->config.rth_algorithm,
                                 &hash_types,
                                 vdev->config.rth_bkt_sz);
-
                  if (status != VXGE_HW_OK) {
                         vxge_debug_init(VXGE_ERR,
                                 "RTH configuration failed for vpath:%d",
@@ -1724,197 +1974,6 @@ static enum vxge_hw_status vxge_rth_configure(struct vxgedev *vdev)
         return status;
 }
 
-int vxge_mac_list_add(struct vxge_vpath *vpath, struct macInfo *mac)
-{
-        struct vxge_mac_addrs *new_mac_entry;
-        u8 *mac_address = NULL;
-
-        if (vpath->mac_addr_cnt >= VXGE_MAX_LEARN_MAC_ADDR_CNT)
-                return TRUE;
-
-        new_mac_entry = kzalloc(sizeof(struct vxge_mac_addrs), GFP_ATOMIC);
-        if (!new_mac_entry) {
-                vxge_debug_mem(VXGE_ERR,
-                        "%s: memory allocation failed",
-                        VXGE_DRIVER_NAME);
-                return FALSE;
-        }
-
-        list_add(&new_mac_entry->item, &vpath->mac_addr_list);
-
-        /* Copy the new mac address to the list */
-        mac_address = (u8 *)&new_mac_entry->macaddr;
-        memcpy(mac_address, mac->macaddr, ETH_ALEN);
-
-        new_mac_entry->state = mac->state;
-        vpath->mac_addr_cnt++;
-
-        /* Is this a multicast address */
-        if (0x01 & mac->macaddr[0])
-                vpath->mcast_addr_cnt++;
-
-        return TRUE;
-}
-
-/* Add a mac address to DA table */
-enum vxge_hw_status vxge_add_mac_addr(struct vxgedev *vdev, struct macInfo *mac)
-{
-        enum vxge_hw_status status = VXGE_HW_OK;
-        struct vxge_vpath *vpath;
-        enum vxge_hw_vpath_mac_addr_add_mode duplicate_mode;
-
-        if (0x01 & mac->macaddr[0]) /* multicast address */
-                duplicate_mode = VXGE_HW_VPATH_MAC_ADDR_ADD_DUPLICATE;
-        else
-                duplicate_mode = VXGE_HW_VPATH_MAC_ADDR_REPLACE_DUPLICATE;
-
-        vpath = &vdev->vpaths[mac->vpath_no];
-        status = vxge_hw_vpath_mac_addr_add(vpath->handle, mac->macaddr,
-                                                mac->macmask, duplicate_mode);
-        if (status != VXGE_HW_OK) {
-                vxge_debug_init(VXGE_ERR,
-                        "DA config add entry failed for vpath:%d",
-                        vpath->device_id);
-        } else
-                if (FALSE == vxge_mac_list_add(vpath, mac))
-                        status = -EPERM;
-
-        return status;
-}
-
-int vxge_mac_list_del(struct vxge_vpath *vpath, struct macInfo *mac)
-{
-        struct list_head *entry, *next;
-        u64 del_mac = 0;
-        u8 *mac_address = (u8 *) (&del_mac);
-
-        /* Copy the mac address to delete from the list */
-        memcpy(mac_address, mac->macaddr, ETH_ALEN);
-
-        list_for_each_safe(entry, next, &vpath->mac_addr_list) {
-                if (((struct vxge_mac_addrs *)entry)->macaddr == del_mac) {
-                        list_del(entry);
-                        kfree((struct vxge_mac_addrs *)entry);
-                        vpath->mac_addr_cnt--;
-
-                        /* Is this a multicast address */
-                        if (0x01 & mac->macaddr[0])
-                                vpath->mcast_addr_cnt--;
-                        return TRUE;
-                }
-        }
-
-        return FALSE;
-}
-/* delete a mac address from DA table */
-enum vxge_hw_status vxge_del_mac_addr(struct vxgedev *vdev, struct macInfo *mac)
-{
-        enum vxge_hw_status status = VXGE_HW_OK;
-        struct vxge_vpath *vpath;
-
-        vpath = &vdev->vpaths[mac->vpath_no];
-        status = vxge_hw_vpath_mac_addr_delete(vpath->handle, mac->macaddr,
-                                                mac->macmask);
-        if (status != VXGE_HW_OK) {
-                vxge_debug_init(VXGE_ERR,
-                        "DA config delete entry failed for vpath:%d",
-                        vpath->device_id);
-        } else
-                vxge_mac_list_del(vpath, mac);
-        return status;
-}
-
-/* list all mac addresses from DA table */
-enum vxge_hw_status
-static vxge_search_mac_addr_in_da_table(struct vxge_vpath *vpath,
-                                        struct macInfo *mac)
-{
-        enum vxge_hw_status status = VXGE_HW_OK;
-        unsigned char macmask[ETH_ALEN];
-        unsigned char macaddr[ETH_ALEN];
-
-        status = vxge_hw_vpath_mac_addr_get(vpath->handle,
-                                macaddr, macmask);
-        if (status != VXGE_HW_OK) {
-                vxge_debug_init(VXGE_ERR,
-                        "DA config list entry failed for vpath:%d",
-                        vpath->device_id);
-                return status;
-        }
-
-        while (memcmp(mac->macaddr, macaddr, ETH_ALEN)) {
-
-                status = vxge_hw_vpath_mac_addr_get_next(vpath->handle,
-                                macaddr, macmask);
-                if (status != VXGE_HW_OK)
-                        break;
-        }
-
-        return status;
-}
-
-/* Store all vlan ids from the list to the vid table */
-enum vxge_hw_status vxge_restore_vpath_vid_table(struct vxge_vpath *vpath)
-{
-        enum vxge_hw_status status = VXGE_HW_OK;
-        struct vxgedev *vdev = vpath->vdev;
-        u16 vid;
-
-        if (vdev->vlgrp && vpath->is_open) {
-
-                for (vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) {
-                        if (!vlan_group_get_device(vdev->vlgrp, vid))
-                                continue;
-                        /* Add these vlan to the vid table */
-                        status = vxge_hw_vpath_vid_add(vpath->handle, vid);
-                }
-        }
-
-        return status;
-}
-
-/* Store all mac addresses from the list to the DA table */
-enum vxge_hw_status vxge_restore_vpath_mac_addr(struct vxge_vpath *vpath)
-{
-        enum vxge_hw_status status = VXGE_HW_OK;
-        struct macInfo mac_info;
-        u8 *mac_address = NULL;
-        struct list_head *entry, *next;
-
-        memset(&mac_info, 0, sizeof(struct macInfo));
-
-        if (vpath->is_open) {
-
-                list_for_each_safe(entry, next, &vpath->mac_addr_list) {
-                        mac_address =
-                                (u8 *)&
-                                ((struct vxge_mac_addrs *)entry)->macaddr;
-                        memcpy(mac_info.macaddr, mac_address, ETH_ALEN);
-                        ((struct vxge_mac_addrs *)entry)->state =
-                                VXGE_LL_MAC_ADDR_IN_DA_TABLE;
-                        /* does this mac address already exist in da table? */
-                        status = vxge_search_mac_addr_in_da_table(vpath,
-                                &mac_info);
-                        if (status != VXGE_HW_OK) {
-                                /* Add this mac address to the DA table */
-                                status = vxge_hw_vpath_mac_addr_add(
-                                        vpath->handle, mac_info.macaddr,
-                                        mac_info.macmask,
-                                    VXGE_HW_VPATH_MAC_ADDR_ADD_DUPLICATE);
-                                if (status != VXGE_HW_OK) {
-                                        vxge_debug_init(VXGE_ERR,
-                                            "DA add entry failed for vpath:%d",
-                                            vpath->device_id);
-                                        ((struct vxge_mac_addrs *)entry)->state
-                                                = VXGE_LL_MAC_ADDR_IN_LIST;
-                                }
-                        }
-                }
-        }
-
-        return status;
-}
-
 /* reset vpaths */
 enum vxge_hw_status vxge_reset_all_vpaths(struct vxgedev *vdev)
 {
@@ -1948,7 +2007,7 @@ enum vxge_hw_status vxge_reset_all_vpaths(struct vxgedev *vdev)
 }
 
 /* close vpaths */
-void vxge_close_vpaths(struct vxgedev *vdev, int index)
+static void vxge_close_vpaths(struct vxgedev *vdev, int index)
 {
         struct vxge_vpath *vpath;
         int i;
@@ -1966,7 +2025,7 @@ void vxge_close_vpaths(struct vxgedev *vdev, int index)
 }
 
 /* open vpaths */
-int vxge_open_vpaths(struct vxgedev *vdev)
+static int vxge_open_vpaths(struct vxgedev *vdev)
 {
         struct vxge_hw_vpath_attr attr;
         enum vxge_hw_status status;
@@ -1976,8 +2035,23 @@ int vxge_open_vpaths(struct vxgedev *vdev)
 
         for (i = 0; i < vdev->no_of_vpath; i++) {
                 vpath = &vdev->vpaths[i];
-
                 vxge_assert(vpath->is_configured);
+
+                if (!vdev->titan1) {
+                        struct vxge_hw_vp_config *vcfg;
+                        vcfg = &vdev->devh->config.vp_config[vpath->device_id];
+
+                        vcfg->rti.urange_a = RTI_T1A_RX_URANGE_A;
+                        vcfg->rti.urange_b = RTI_T1A_RX_URANGE_B;
+                        vcfg->rti.urange_c = RTI_T1A_RX_URANGE_C;
+                        vcfg->tti.uec_a = TTI_T1A_TX_UFC_A;
+                        vcfg->tti.uec_b = TTI_T1A_TX_UFC_B;
+                        vcfg->tti.uec_c = TTI_T1A_TX_UFC_C(vdev->mtu);
+                        vcfg->tti.uec_d = TTI_T1A_TX_UFC_D(vdev->mtu);
+                        vcfg->tti.ltimer_val = VXGE_T1A_TTI_LTIMER_VAL;
+                        vcfg->tti.rtimer_val = VXGE_T1A_TTI_RTIMER_VAL;
+                }
+
                 attr.vp_id = vpath->device_id;
                 attr.fifo_attr.callback = vxge_xmit_compl;
                 attr.fifo_attr.txdl_term = vxge_tx_term;
@@ -1992,6 +2066,7 @@ int vxge_open_vpaths(struct vxgedev *vdev)
 
                 vpath->ring.ndev = vdev->ndev;
                 vpath->ring.pdev = vdev->pdev;
+
                 status = vxge_hw_vpath_open(vdev->devh, &attr, &vpath->handle);
                 if (status == VXGE_HW_OK) {
                         vpath->fifo.handle =
@@ -2010,20 +2085,19 @@ int vxge_open_vpaths(struct vxgedev *vdev)
                                         netdev_get_tx_queue(vdev->ndev, 0);
                         vpath->fifo.indicate_max_pkts =
                                 vdev->config.fifo_indicate_max_pkts;
+                        vpath->fifo.tx_vector_no = 0;
                         vpath->ring.rx_vector_no = 0;
-                        vpath->ring.rx_csum = vdev->rx_csum;
+                        vpath->ring.rx_hwts = vdev->rx_hwts;
                         vpath->is_open = 1;
                         vdev->vp_handles[i] = vpath->handle;
-                        vpath->ring.gro_enable = vdev->config.gro_enable;
                         vpath->ring.vlan_tag_strip = vdev->vlan_tag_strip;
                         vdev->stats.vpaths_open++;
                 } else {
                         vdev->stats.vpath_open_fail++;
-                        vxge_debug_init(VXGE_ERR,
-                                "%s: vpath: %d failed to open "
-                                "with status: %d",
-                            vdev->ndev->name, vpath->device_id,
-                                status);
+                        vxge_debug_init(VXGE_ERR, "%s: vpath: %d failed to "
+                                        "open with status: %d",
+                                        vdev->ndev->name, vpath->device_id,
+                                        status);
                         vxge_close_vpaths(vdev, 0);
                         return -EPERM;
                 }
@@ -2031,9 +2105,65 @@ int vxge_open_vpaths(struct vxgedev *vdev)
                 vp_id = vpath->handle->vpath->vp_id;
                 vdev->vpaths_deployed |= vxge_mBIT(vp_id);
         }
+
         return VXGE_HW_OK;
 }
 
+/**
+ *  adaptive_coalesce_tx_interrupts - Changes the interrupt coalescing
+ *  if the interrupts are not within a range
+ *  @fifo: pointer to transmit fifo structure
+ *  Description: The function changes boundary timer and restriction timer
+ *  value depends on the traffic
+ *  Return Value: None
+ */
+static void adaptive_coalesce_tx_interrupts(struct vxge_fifo *fifo)
+{
+        fifo->interrupt_count++;
+        if (jiffies > fifo->jiffies + HZ / 100) {
+                struct __vxge_hw_fifo *hw_fifo = fifo->handle;
+
+                fifo->jiffies = jiffies;
+                if (fifo->interrupt_count > VXGE_T1A_MAX_TX_INTERRUPT_COUNT &&
+                    hw_fifo->rtimer != VXGE_TTI_RTIMER_ADAPT_VAL) {
+                        hw_fifo->rtimer = VXGE_TTI_RTIMER_ADAPT_VAL;
+                        vxge_hw_vpath_dynamic_tti_rtimer_set(hw_fifo);
+                } else if (hw_fifo->rtimer != 0) {
+                        hw_fifo->rtimer = 0;
+                        vxge_hw_vpath_dynamic_tti_rtimer_set(hw_fifo);
+                }
+                fifo->interrupt_count = 0;
+        }
+}
+
+/**
+ *  adaptive_coalesce_rx_interrupts - Changes the interrupt coalescing
+ *  if the interrupts are not within a range
+ *  @ring: pointer to receive ring structure
+ *  Description: The function increases of decreases the packet counts within
+ *  the ranges of traffic utilization, if the interrupts due to this ring are
+ *  not within a fixed range.
+ *  Return Value: Nothing
+ */
+static void adaptive_coalesce_rx_interrupts(struct vxge_ring *ring)
+{
+        ring->interrupt_count++;
+        if (jiffies > ring->jiffies + HZ / 100) {
+                struct __vxge_hw_ring *hw_ring = ring->handle;
+
+                ring->jiffies = jiffies;
+                if (ring->interrupt_count > VXGE_T1A_MAX_INTERRUPT_COUNT &&
+                    hw_ring->rtimer != VXGE_RTI_RTIMER_ADAPT_VAL) {
+                        hw_ring->rtimer = VXGE_RTI_RTIMER_ADAPT_VAL;
+                        vxge_hw_vpath_dynamic_rti_rtimer_set(hw_ring);
+                } else if (hw_ring->rtimer != 0) {
+                        hw_ring->rtimer = 0;
+                        vxge_hw_vpath_dynamic_rti_rtimer_set(hw_ring);
+                }
+                ring->interrupt_count = 0;
+        }
+}
+
 /*
  *  vxge_isr_napi
  *  @irq: the irq of the device.
@@ -2050,21 +2180,20 @@ static irqreturn_t vxge_isr_napi(int irq, void *dev_id)
         struct __vxge_hw_device *hldev;
         u64 reason;
         enum vxge_hw_status status;
-        struct vxgedev *vdev = (struct vxgedev *) dev_id;;
+        struct vxgedev *vdev = (struct vxgedev *)dev_id;
 
         vxge_debug_intr(VXGE_TRACE, "%s:%d", __func__, __LINE__);
 
         dev = vdev->ndev;
-        hldev = (struct __vxge_hw_device *)pci_get_drvdata(vdev->pdev);
+        hldev = pci_get_drvdata(vdev->pdev);
 
         if (pci_channel_offline(vdev->pdev))
                 return IRQ_NONE;
 
         if (unlikely(!is_vxge_card_up(vdev)))
-                return IRQ_NONE;
+                return IRQ_HANDLED;
 
-        status = vxge_hw_device_begin_irq(hldev, vdev->exec_mode,
-                        &reason);
+        status = vxge_hw_device_begin_irq(hldev, vdev->exec_mode, &reason);
         if (status == VXGE_HW_OK) {
                 vxge_hw_device_mask_all(hldev);
 
@@ -2095,24 +2224,39 @@ static irqreturn_t vxge_isr_napi(int irq, void *dev_id)
 
 #ifdef CONFIG_PCI_MSI
 
-static irqreturn_t
-vxge_tx_msix_handle(int irq, void *dev_id)
+static irqreturn_t vxge_tx_msix_handle(int irq, void *dev_id)
 {
         struct vxge_fifo *fifo = (struct vxge_fifo *)dev_id;
 
+        adaptive_coalesce_tx_interrupts(fifo);
+
+        vxge_hw_channel_msix_mask((struct __vxge_hw_channel *)fifo->handle,
+                                  fifo->tx_vector_no);
+
+        vxge_hw_channel_msix_clear((struct __vxge_hw_channel *)fifo->handle,
+                                   fifo->tx_vector_no);
+
         VXGE_COMPLETE_VPATH_TX(fifo);
 
+        vxge_hw_channel_msix_unmask((struct __vxge_hw_channel *)fifo->handle,
+                                    fifo->tx_vector_no);
+
+        mmiowb();
+
         return IRQ_HANDLED;
 }
 
-static irqreturn_t
-vxge_rx_msix_napi_handle(int irq, void *dev_id)
+static irqreturn_t vxge_rx_msix_napi_handle(int irq, void *dev_id)
 {
         struct vxge_ring *ring = (struct vxge_ring *)dev_id;
 
-        /* MSIX_IDX for Rx is 1 */
+        adaptive_coalesce_rx_interrupts(ring);
+
         vxge_hw_channel_msix_mask((struct __vxge_hw_channel *)ring->handle,
-                                        ring->rx_vector_no);
+                                  ring->rx_vector_no);
+
+        vxge_hw_channel_msix_clear((struct __vxge_hw_channel *)ring->handle,
+                                   ring->rx_vector_no);
 
         napi_schedule(&ring->napi);
         return IRQ_HANDLED;
@@ -2129,14 +2273,20 @@ vxge_alarm_msix_handle(int irq, void *dev_id)
                 VXGE_HW_VPATH_MSIX_ACTIVE) + VXGE_ALARM_MSIX_ID;
 
         for (i = 0; i < vdev->no_of_vpath; i++) {
+                /* Reduce the chance of losing alarm interrupts by masking
+                 * the vector. A pending bit will be set if an alarm is
+                 * generated and on unmask the interrupt will be fired.
+                 */
                 vxge_hw_vpath_msix_mask(vdev->vpaths[i].handle, msix_id);
+                vxge_hw_vpath_msix_clear(vdev->vpaths[i].handle, msix_id);
+                mmiowb();
 
                 status = vxge_hw_vpath_alarm_process(vdev->vpaths[i].handle,
                         vdev->exec_mode);
                 if (status == VXGE_HW_OK) {
-
                         vxge_hw_vpath_msix_unmask(vdev->vpaths[i].handle,
-                                        msix_id);
+                                                  msix_id);
+                        mmiowb();
                         continue;
                 }
                 vxge_debug_intr(VXGE_ERR,
@@ -2159,8 +2309,8 @@ start:
         /* Alarm MSIX Vectors count */
         vdev->intr_cnt++;
 
-        vdev->entries = kzalloc(vdev->intr_cnt * sizeof(struct msix_entry),
-                                                GFP_KERNEL);
+        vdev->entries = kcalloc(vdev->intr_cnt, sizeof(struct msix_entry),
+                                GFP_KERNEL);
         if (!vdev->entries) {
                 vxge_debug_init(VXGE_ERR,
                         "%s: memory allocation failed",
@@ -2169,9 +2319,9 @@ start:
                 goto alloc_entries_failed;
         }
 
-        vdev->vxge_entries =
-                kzalloc(vdev->intr_cnt * sizeof(struct vxge_msix_entry),
-                                GFP_KERNEL);
+        vdev->vxge_entries = kcalloc(vdev->intr_cnt,
+                                     sizeof(struct vxge_msix_entry),
+                                     GFP_KERNEL);
         if (!vdev->vxge_entries) {
                 vxge_debug_init(VXGE_ERR, "%s: memory allocation failed",
                         VXGE_DRIVER_NAME);
@@ -2255,6 +2405,9 @@ static int vxge_enable_msix(struct vxgedev *vdev)
                         vpath->ring.rx_vector_no = (vpath->device_id *
                                                 VXGE_HW_VPATH_MSIX_ACTIVE) + 1;
 
+                        vpath->fifo.tx_vector_no = (vpath->device_id *
+                                                VXGE_HW_VPATH_MSIX_ACTIVE);
+
                         vxge_hw_vpath_msix_set(vpath->handle, tim_msix_id,
                                                VXGE_ALARM_MSIX_ID);
                 }
@@ -2289,8 +2442,8 @@ static void vxge_rem_msix_isr(struct vxgedev *vdev)
 
 static void vxge_rem_isr(struct vxgedev *vdev)
 {
-        struct __vxge_hw_device  *hldev;
-        hldev = (struct __vxge_hw_device  *) pci_get_drvdata(vdev->pdev);
+        struct __vxge_hw_device *hldev;
+        hldev = pci_get_drvdata(vdev->pdev);
 
 #ifdef CONFIG_PCI_MSI
         if (vdev->config.intr_type == MSI_X) {
@@ -2430,8 +2583,9 @@ INTA_MODE:
                         "%s:vxge:INTA", vdev->ndev->name);
                 vxge_hw_device_set_intr_type(vdev->devh,
                         VXGE_HW_INTR_MODE_IRQLINE);
-                vxge_hw_vpath_tti_ci_set(vdev->devh,
-                        vdev->vpaths[0].device_id);
+
+                vxge_hw_vpath_tti_ci_set(vdev->vpaths[0].fifo.handle);
+
                 ret = request_irq((int) vdev->pdev->irq,
                         vxge_isr_napi,
                         IRQF_SHARED, vdev->desc[0], vdev);
@@ -2507,6 +2661,40 @@ static void vxge_poll_vp_lockup(unsigned long data)
         mod_timer(&vdev->vp_lockup_timer, jiffies + HZ / 1000);
 }
 
+static u32 vxge_fix_features(struct net_device *dev, u32 features)
+{
+        u32 changed = dev->features ^ features;
+
+        /* Enabling RTH requires some of the logic in vxge_device_register and a
+         * vpath reset.  Due to these restrictions, only allow modification
+         * while the interface is down.
+         */
+        if ((changed & NETIF_F_RXHASH) && netif_running(dev))
+                features ^= NETIF_F_RXHASH;
+
+        return features;
+}
+
+static int vxge_set_features(struct net_device *dev, u32 features)
+{
+        struct vxgedev *vdev = netdev_priv(dev);
+        u32 changed = dev->features ^ features;
+
+        if (!(changed & NETIF_F_RXHASH))
+                return 0;
+
+        /* !netif_running() ensured by vxge_fix_features() */
+
+        vdev->devh->config.rth_en = !!(features & NETIF_F_RXHASH);
+        if (vxge_reset_all_vpaths(vdev) != VXGE_HW_OK) {
+                dev->features = features ^ NETIF_F_RXHASH;
+                vdev->devh->config.rth_en = !!(dev->features & NETIF_F_RXHASH);
+                return -EIO;
+        }
+
+        return 0;
+}
+
 /**
  * vxge_open
  * @dev: pointer to the device structure.
@@ -2517,8 +2705,7 @@ static void vxge_poll_vp_lockup(unsigned long data)
  * Return value: '0' on success and an appropriate (-)ve integer as
  * defined in errno.h file on failure.
  */
-int
-vxge_open(struct net_device *dev)
+static int vxge_open(struct net_device *dev)
 {
         enum vxge_hw_status status;
         struct vxgedev *vdev;
@@ -2527,11 +2714,12 @@ vxge_open(struct net_device *dev)
         int ret = 0;
         int i;
         u64 val64, function_mode;
+
         vxge_debug_entryexit(VXGE_TRACE,
                 "%s: %s:%d", dev->name, __func__, __LINE__);
 
-        vdev = (struct vxgedev *)netdev_priv(dev);
-        hldev = (struct __vxge_hw_device *) pci_get_drvdata(vdev->pdev);
+        vdev = netdev_priv(dev);
+        hldev = pci_get_drvdata(vdev->pdev);
         function_mode = vdev->config.device_hw_info.function_mode;
 
         /* make sure you have link off by default every time Nic is
@@ -2586,6 +2774,8 @@ vxge_open(struct net_device *dev)
                         goto out2;
                 }
         }
+        printk(KERN_INFO "%s: Receive Hashing Offload %s\n", dev->name,
+               hldev->config.rth_en ? "enabled" : "disabled");
 
         for (i = 0; i < vdev->no_of_vpath; i++) {
                 vpath = &vdev->vpaths[i];
@@ -2623,7 +2813,7 @@ vxge_open(struct net_device *dev)
         }
 
         /* Enable vpath to sniff all unicast/multicast traffic that not
-         * addressed to them. We allow promiscous mode for PF only
+         * addressed to them. We allow promiscuous mode for PF only
          */
 
         val64 = 0;
@@ -2671,9 +2861,10 @@ vxge_open(struct net_device *dev)
                 vxge_os_timer(vdev->vp_reset_timer,
                         vxge_poll_vp_reset, vdev, (HZ/2));
 
-        if (vdev->vp_lockup_timer.function == NULL)
-                vxge_os_timer(vdev->vp_lockup_timer,
-                        vxge_poll_vp_lockup, vdev, (HZ/2));
+        /* There is no need to check for RxD leak and RxD lookup on Titan1A */
+        if (vdev->titan1 && vdev->vp_lockup_timer.function == NULL)
+                vxge_os_timer(vdev->vp_lockup_timer, vxge_poll_vp_lockup, vdev,
+                              HZ / 2);
 
         set_bit(__VXGE_STATE_CARD_UP, &vdev->state);
 
@@ -2698,6 +2889,10 @@ vxge_open(struct net_device *dev)
         }
 
         netif_tx_start_all_queues(vdev->ndev);
+
+        /* configure CI */
+        vxge_config_ci_for_tti_rti(vdev);
+
         goto out0;
 
 out2:
@@ -2720,8 +2915,8 @@ out0:
         return ret;
 }
 
-/* Loop throught the mac address list and delete all the entries */
-void vxge_free_mac_add_list(struct vxge_vpath *vpath)
+/* Loop through the mac address list and delete all the entries */
+static void vxge_free_mac_add_list(struct vxge_vpath *vpath)
 {
 
         struct list_head *entry, *next;
@@ -2745,7 +2940,7 @@ static void vxge_napi_del_all(struct vxgedev *vdev)
         }
 }
 
-int do_vxge_close(struct net_device *dev, int do_io)
+static int do_vxge_close(struct net_device *dev, int do_io)
 {
         enum vxge_hw_status status;
         struct vxgedev *vdev;
@@ -2755,8 +2950,8 @@ int do_vxge_close(struct net_device *dev, int do_io)
         vxge_debug_entryexit(VXGE_TRACE, "%s: %s:%d",
                 dev->name, __func__, __LINE__);
 
-        vdev = (struct vxgedev *)netdev_priv(dev);
-        hldev = (struct __vxge_hw_device *) pci_get_drvdata(vdev->pdev);
+        vdev = netdev_priv(dev);
+        hldev = pci_get_drvdata(vdev->pdev);
 
         if (unlikely(!is_vxge_card_up(vdev)))
                 return 0;
@@ -2766,7 +2961,6 @@ int do_vxge_close(struct net_device *dev, int do_io)
         while (test_and_set_bit(__VXGE_STATE_RESET_CARD, &vdev->state))
                 msleep(50);
 
-        clear_bit(__VXGE_STATE_CARD_UP, &vdev->state);
         if (do_io) {
                 /* Put the vpath back in normal mode */
                 vpath_vector = vxge_mBIT(vdev->vpaths[0].device_id);
@@ -2777,7 +2971,6 @@ int do_vxge_close(struct net_device *dev, int do_io)
                                         struct vxge_hw_mrpcim_reg,
                                         rts_mgr_cbasin_cfg),
                                 &val64);
-
                 if (status == VXGE_HW_OK) {
                         val64 &= ~vpath_vector;
                         status = vxge_hw_mgmt_reg_write(vdev->devh,
@@ -2789,7 +2982,7 @@ int do_vxge_close(struct net_device *dev, int do_io)
                                         val64);
                 }
 
-                /* Remove the function 0 from promiscous mode */
+                /* Remove the function 0 from promiscuous mode */
                 vxge_hw_mgmt_reg_write(vdev->devh,
                         vxge_hw_mgmt_reg_type_mrpcim,
                         0,
@@ -2806,10 +2999,17 @@ int do_vxge_close(struct net_device *dev, int do_io)
 
                 smp_wmb();
         }
-        del_timer_sync(&vdev->vp_lockup_timer);
+
+        if (vdev->titan1)
+                del_timer_sync(&vdev->vp_lockup_timer);
 
         del_timer_sync(&vdev->vp_reset_timer);
 
+        if (do_io)
+                vxge_hw_device_wait_receive_idle(hldev);
+
+        clear_bit(__VXGE_STATE_CARD_UP, &vdev->state);
+
         /* Disable napi */
         if (vdev->config.intr_type != MSI_X)
                 napi_disable(&vdev->napi);
@@ -2826,8 +3026,6 @@ int do_vxge_close(struct net_device *dev, int do_io)
         if (do_io)
                 vxge_hw_device_intr_disable(vdev->devh);
 
-        mdelay(1000);
-
         vxge_rem_isr(vdev);
 
         vxge_napi_del_all(vdev);
@@ -2856,8 +3054,7 @@ int do_vxge_close(struct net_device *dev, int do_io)
  * Return value: '0' on success and an appropriate (-)ve integer as
  * defined in errno.h file on failure.
  */
-int
-vxge_close(struct net_device *dev)
+static int vxge_close(struct net_device *dev)
 {
         do_vxge_close(dev, 1);
         return 0;
@@ -2914,34 +3111,24 @@ static int vxge_change_mtu(struct net_device *dev, int new_mtu)
 }
 
 /**
- * vxge_get_stats
+ * vxge_get_stats64
  * @dev: pointer to the device structure
+ * @stats: pointer to struct rtnl_link_stats64
  *
- * Updates the device statistics structure. This function updates the device
- * statistics structure in the net_device structure and returns a pointer
- * to the same.
  */
-static struct net_device_stats *
-vxge_get_stats(struct net_device *dev)
+static struct rtnl_link_stats64 *
+vxge_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *net_stats)
 {
-        struct vxgedev *vdev;
-        struct net_device_stats *net_stats;
+        struct vxgedev *vdev = netdev_priv(dev);
         int k;
 
-        vdev = netdev_priv(dev);
-
-        net_stats = &vdev->stats.net_stats;
-
-        memset(net_stats, 0, sizeof(struct net_device_stats));
-
+        /* net_stats already zeroed by caller */
         for (k = 0; k < vdev->no_of_vpath; k++) {
                 net_stats->rx_packets += vdev->vpaths[k].ring.stats.rx_frms;
                 net_stats->rx_bytes += vdev->vpaths[k].ring.stats.rx_bytes;
                 net_stats->rx_errors += vdev->vpaths[k].ring.stats.rx_errors;
                 net_stats->multicast += vdev->vpaths[k].ring.stats.rx_mcast;
-                net_stats->rx_dropped +=
-                        vdev->vpaths[k].ring.stats.rx_dropped;
-
+                net_stats->rx_dropped += vdev->vpaths[k].ring.stats.rx_dropped;
                 net_stats->tx_packets += vdev->vpaths[k].fifo.stats.tx_frms;
                 net_stats->tx_bytes += vdev->vpaths[k].fifo.stats.tx_bytes;
                 net_stats->tx_errors += vdev->vpaths[k].fifo.stats.tx_errors;
@@ -2950,6 +3137,92 @@ vxge_get_stats(struct net_device *dev)
         return net_stats;
 }
 
+static enum vxge_hw_status vxge_timestamp_config(struct __vxge_hw_device *devh)
+{
+        enum vxge_hw_status status;
+        u64 val64;
+
+        /* Timestamp is passed to the driver via the FCS, therefore we
+         * must disable the FCS stripping by the adapter.  Since this is
+         * required for the driver to load (due to a hardware bug),
+         * there is no need to do anything special here.
+         */
+        val64 = VXGE_HW_XMAC_TIMESTAMP_EN |
+                VXGE_HW_XMAC_TIMESTAMP_USE_LINK_ID(0) |
+                VXGE_HW_XMAC_TIMESTAMP_INTERVAL(0);
+
+        status = vxge_hw_mgmt_reg_write(devh,
+                                        vxge_hw_mgmt_reg_type_mrpcim,
+                                        0,
+                                        offsetof(struct vxge_hw_mrpcim_reg,
+                                                 xmac_timestamp),
+                                        val64);
+        vxge_hw_device_flush_io(devh);
+        devh->config.hwts_en = VXGE_HW_HWTS_ENABLE;
+        return status;
+}
+
+static int vxge_hwtstamp_ioctl(struct vxgedev *vdev, void __user *data)
+{
+        struct hwtstamp_config config;
+        int i;
+
+        if (copy_from_user(&config, data, sizeof(config)))
+                return -EFAULT;
+
+        /* reserved for future extensions */
+        if (config.flags)
+                return -EINVAL;
+
+        /* Transmit HW Timestamp not supported */
+        switch (config.tx_type) {
+        case HWTSTAMP_TX_OFF:
+                break;
+        case HWTSTAMP_TX_ON:
+        default:
+                return -ERANGE;
+        }
+
+        switch (config.rx_filter) {
+        case HWTSTAMP_FILTER_NONE:
+                vdev->rx_hwts = 0;
+                config.rx_filter = HWTSTAMP_FILTER_NONE;
+                break;
+
+        case HWTSTAMP_FILTER_ALL:
+        case HWTSTAMP_FILTER_SOME:
+        case HWTSTAMP_FILTER_PTP_V1_L4_EVENT:
+        case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
+        case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
+        case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
+        case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
+        case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
+        case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
+        case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
+        case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
+        case HWTSTAMP_FILTER_PTP_V2_EVENT:
+        case HWTSTAMP_FILTER_PTP_V2_SYNC:
+        case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
+                if (vdev->devh->config.hwts_en != VXGE_HW_HWTS_ENABLE)
+                        return -EFAULT;
+
+                vdev->rx_hwts = 1;
+                config.rx_filter = HWTSTAMP_FILTER_ALL;
+                break;
+
+        default:
+                 return -ERANGE;
+        }
+
+        for (i = 0; i < vdev->no_of_vpath; i++)
+                vdev->vpaths[i].ring.rx_hwts = vdev->rx_hwts;
+
+        if (copy_to_user(data, &config, sizeof(config)))
+                return -EFAULT;
+
+        return 0;
+}
+
 /**
  * vxge_ioctl
  * @dev: Device pointer.
@@ -2962,7 +3235,20 @@ vxge_get_stats(struct net_device *dev)
  */
 static int vxge_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
-        return -EOPNOTSUPP;
+        struct vxgedev *vdev = netdev_priv(dev);
+        int ret;
+
+        switch (cmd) {
+        case SIOCSHWTSTAMP:
+                ret = vxge_hwtstamp_ioctl(vdev, rq->ifr_data);
+                if (ret)
+                        return ret;
+                break;
+        default:
+                return -EOPNOTSUPP;
+        }
+
+        return 0;
 }
 
 /**
@@ -2973,18 +3259,17 @@ static int vxge_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  * This function is triggered if the Tx Queue is stopped
  * for a pre-defined amount of time when the Interface is still up.
  */
-static void
-vxge_tx_watchdog(struct net_device *dev)
+static void vxge_tx_watchdog(struct net_device *dev)
 {
         struct vxgedev *vdev;
 
         vxge_debug_entryexit(VXGE_TRACE, "%s:%d", __func__, __LINE__);
 
-        vdev = (struct vxgedev *)netdev_priv(dev);
+        vdev = netdev_priv(dev);
 
         vdev->cric_err_event = VXGE_HW_EVENT_RESET_START;
 
-        vxge_reset(vdev);
+        schedule_work(&vdev->reset_task);
         vxge_debug_entryexit(VXGE_TRACE,
                 "%s:%d  Exiting...", __func__, __LINE__);
 }
@@ -3008,7 +3293,7 @@ vxge_vlan_rx_register(struct net_device *dev, struct vlan_group *grp)
 
         vxge_debug_entryexit(VXGE_TRACE, "%s:%d", __func__, __LINE__);
 
-        vdev = (struct vxgedev *)netdev_priv(dev);
+        vdev = netdev_priv(dev);
 
         vpath = &vdev->vpaths[0];
         if ((NULL == grp) && (vpath->is_open)) {
@@ -3057,7 +3342,7 @@ vxge_vlan_rx_add_vid(struct net_device *dev, unsigned short vid)
         struct vxge_vpath *vpath;
         int vp_id;
 
-        vdev = (struct vxgedev *)netdev_priv(dev);
+        vdev = netdev_priv(dev);
 
         /* Add these vlan to the vid table */
         for (vp_id = 0; vp_id < vdev->no_of_vpath; vp_id++) {
@@ -3084,7 +3369,7 @@ vxge_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
 
         vxge_debug_entryexit(VXGE_TRACE, "%s:%d", __func__, __LINE__);
 
-        vdev = (struct vxgedev *)netdev_priv(dev);
+        vdev = netdev_priv(dev);
 
         vlan_group_set_device(vdev->vlgrp, vid, NULL);
 
@@ -3102,29 +3387,28 @@ vxge_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
 static const struct net_device_ops vxge_netdev_ops = {
         .ndo_open               = vxge_open,
         .ndo_stop               = vxge_close,
-        .ndo_get_stats          = vxge_get_stats,
+        .ndo_get_stats64        = vxge_get_stats64,
         .ndo_start_xmit         = vxge_xmit,
         .ndo_validate_addr      = eth_validate_addr,
         .ndo_set_multicast_list = vxge_set_multicast,
-
         .ndo_do_ioctl           = vxge_ioctl,
-
         .ndo_set_mac_address    = vxge_set_mac_addr,
         .ndo_change_mtu         = vxge_change_mtu,
+        .ndo_fix_features       = vxge_fix_features,
+        .ndo_set_features       = vxge_set_features,
         .ndo_vlan_rx_register   = vxge_vlan_rx_register,
         .ndo_vlan_rx_kill_vid   = vxge_vlan_rx_kill_vid,
         .ndo_vlan_rx_add_vid    = vxge_vlan_rx_add_vid,
-
         .ndo_tx_timeout         = vxge_tx_watchdog,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = vxge_netpoll,
 #endif
 };
 
-int __devinit vxge_device_register(struct __vxge_hw_device *hldev,
-                                   struct vxge_config *config,
-                                   int high_dma, int no_of_vpath,
-                                   struct vxgedev **vdev_out)
+static int __devinit vxge_device_register(struct __vxge_hw_device *hldev,
+                                          struct vxge_config *config,
+                                          int high_dma, int no_of_vpath,
+                                          struct vxgedev **vdev_out)
 {
         struct net_device *ndev;
         enum vxge_hw_status status = VXGE_HW_OK;
@@ -3158,12 +3442,21 @@ int __devinit vxge_device_register(struct __vxge_hw_device *hldev,
         vdev->devh = hldev;
         vdev->pdev = hldev->pdev;
         memcpy(&vdev->config, config, sizeof(struct vxge_config));
-        vdev->rx_csum = 1;      /* Enable Rx CSUM by default. */
+        vdev->rx_hwts = 0;
+        vdev->titan1 = (vdev->pdev->revision == VXGE_HW_TITAN1_PCI_REVISION);
 
         SET_NETDEV_DEV(ndev, &vdev->pdev->dev);
 
-        ndev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX |
-                                NETIF_F_HW_VLAN_FILTER;
+        ndev->hw_features = NETIF_F_RXCSUM | NETIF_F_SG |
+                NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM |
+                NETIF_F_TSO | NETIF_F_TSO6 |
+                NETIF_F_HW_VLAN_TX;
+        if (vdev->config.rth_steering != NO_STEERING)
+                ndev->hw_features |= NETIF_F_RXHASH;
+
+        ndev->features |= ndev->hw_features |
+                NETIF_F_HW_VLAN_RX | NETIF_F_HW_VLAN_FILTER;
+
         /*  Driver entry points */
         ndev->irq = vdev->pdev->irq;
         ndev->base_addr = (unsigned long) hldev->bar0;
@@ -3171,8 +3464,9 @@ int __devinit vxge_device_register(struct __vxge_hw_device *hldev,
         ndev->netdev_ops = &vxge_netdev_ops;
 
         ndev->watchdog_timeo = VXGE_LL_WATCH_DOG_TIMEOUT;
+        INIT_WORK(&vdev->reset_task, vxge_reset);
 
-        initialize_ethtool_ops(ndev);
+        vxge_initialize_ethtool_ops(ndev);
 
         /* Allocate memory for vpath */
         vdev->vpaths = kzalloc((sizeof(struct vxge_vpath)) *
@@ -3181,13 +3475,10 @@ int __devinit vxge_device_register(struct __vxge_hw_device *hldev,
                 vxge_debug_init(VXGE_ERR,
                         "%s: vpath memory allocation failed",
                         vdev->ndev->name);
-                ret = -ENODEV;
+                ret = -ENOMEM;
                 goto _out1;
         }
 
-        ndev->features |= NETIF_F_SG;
-
-        ndev->features |= NETIF_F_HW_CSUM;
         vxge_debug_init(vxge_hw_device_trace_level_get(hldev),
                 "%s : checksuming enabled", __func__);
 
@@ -3197,16 +3488,11 @@ int __devinit vxge_device_register(struct __vxge_hw_device *hldev,
                         "%s : using High DMA", __func__);
         }
 
-        ndev->features |= NETIF_F_TSO | NETIF_F_TSO6;
-
-        if (vdev->config.gro_enable)
-                ndev->features |= NETIF_F_GRO;
-
-        if (register_netdev(ndev)) {
+        ret = register_netdev(ndev);
+        if (ret) {
                 vxge_debug_init(vxge_hw_device_trace_level_get(hldev),
                         "%s: %s : device registration failed!",
                         ndev->name, __func__);
-                ret = -ENODEV;
                 goto _out2;
         }
 
@@ -3223,6 +3509,7 @@ int __devinit vxge_device_register(struct __vxge_hw_device *hldev,
                 "%s: Ethernet device registered",
                 ndev->name);
 
+        hldev->ndev = ndev;
         *vdev_out = vdev;
 
         /* Resetting the Device stats */
@@ -3257,36 +3544,34 @@ _out0:
  *
  * This function will unregister and free network device
  */
-void
-vxge_device_unregister(struct __vxge_hw_device *hldev)
+static void vxge_device_unregister(struct __vxge_hw_device *hldev)
 {
         struct vxgedev *vdev;
         struct net_device *dev;
         char buf[IFNAMSIZ];
-#if ((VXGE_DEBUG_INIT & VXGE_DEBUG_MASK) || \
-        (VXGE_DEBUG_ENTRYEXIT & VXGE_DEBUG_MASK))
-        u32 level_trace;
-#endif
 
         dev = hldev->ndev;
         vdev = netdev_priv(dev);
-#if ((VXGE_DEBUG_INIT & VXGE_DEBUG_MASK) || \
-        (VXGE_DEBUG_ENTRYEXIT & VXGE_DEBUG_MASK))
-        level_trace = vdev->level_trace;
-#endif
-        vxge_debug_entryexit(level_trace,
-                "%s: %s:%d", vdev->ndev->name, __func__, __LINE__);
 
-        memcpy(buf, vdev->ndev->name, IFNAMSIZ);
+        vxge_debug_entryexit(vdev->level_trace, "%s: %s:%d", vdev->ndev->name,
+                             __func__, __LINE__);
+
+        strncpy(buf, dev->name, IFNAMSIZ);
+
+        flush_work_sync(&vdev->reset_task);
 
         /* in 2.6 will call stop() if device is up */
         unregister_netdev(dev);
 
-        flush_scheduled_work();
+        kfree(vdev->vpaths);
+
+        /* we are safe to free it now */
+        free_netdev(dev);
 
-        vxge_debug_init(level_trace, "%s: ethernet device unregistered", buf);
-        vxge_debug_entryexit(level_trace,
-                "%s: %s:%d  Exiting...", buf, __func__, __LINE__);
+        vxge_debug_init(vdev->level_trace, "%s: ethernet device unregistered",
+                        buf);
+        vxge_debug_entryexit(vdev->level_trace, "%s: %s:%d  Exiting...", buf,
+                             __func__, __LINE__);
 }
 
 /*
@@ -3300,7 +3585,7 @@ vxge_callback_crit_err(struct __vxge_hw_device *hldev,
                         enum vxge_hw_event type, u64 vp_id)
 {
         struct net_device *dev = hldev->ndev;
-        struct vxgedev *vdev = (struct vxgedev *)netdev_priv(dev);
+        struct vxgedev *vdev = netdev_priv(dev);
         struct vxge_vpath *vpath = NULL;
         int vpath_idx;
 
@@ -3523,9 +3808,9 @@ static int __devinit vxge_config_vpaths(
                 device_config->vp_config[i].tti.timer_ac_en =
                                 VXGE_HW_TIM_TIMER_AC_ENABLE;
 
-                /* For msi-x with napi (each vector
-                has a handler of its own) -
-                Set CI to OFF for all vpaths */
+                /* For msi-x with napi (each vector has a handler of its own) -
+                 * Set CI to OFF for all vpaths
+                 */
                 device_config->vp_config[i].tti.timer_ci_en =
                         VXGE_HW_TIM_TIMER_CI_DISABLE;
 
@@ -3555,10 +3840,13 @@ static int __devinit vxge_config_vpaths(
 
                 device_config->vp_config[i].ring.ring_blocks  =
                                                 VXGE_HW_DEF_RING_BLOCKS;
+
                 device_config->vp_config[i].ring.buffer_mode =
                         VXGE_HW_RING_RXD_BUFFER_MODE_1;
+
                 device_config->vp_config[i].ring.rxds_limit  =
                                 VXGE_HW_DEF_RING_RXDS_LIMIT;
+
                 device_config->vp_config[i].ring.scatter_mode =
                                         VXGE_HW_RING_SCATTER_MODE_A;
 
@@ -3635,9 +3923,10 @@ static void __devinit vxge_device_config_init(
                 break;
 
         case MSI_X:
-                device_config->intr_mode = VXGE_HW_INTR_MODE_MSIX;
+                device_config->intr_mode = VXGE_HW_INTR_MODE_MSIX_ONE_SHOT;
                 break;
         }
+
         /* Timer period between device poll */
         device_config->device_poll_millis = VXGE_TIMER_DELAY;
 
@@ -3649,16 +3938,10 @@ static void __devinit vxge_device_config_init(
 
         vxge_debug_ll_config(VXGE_TRACE, "%s : Device Config Params ",
                         __func__);
-        vxge_debug_ll_config(VXGE_TRACE, "dma_blockpool_initial : %d",
-                        device_config->dma_blockpool_initial);
-        vxge_debug_ll_config(VXGE_TRACE, "dma_blockpool_max : %d",
-                        device_config->dma_blockpool_max);
         vxge_debug_ll_config(VXGE_TRACE, "intr_mode : %d",
                         device_config->intr_mode);
         vxge_debug_ll_config(VXGE_TRACE, "device_poll_millis : %d",
                         device_config->device_poll_millis);
-        vxge_debug_ll_config(VXGE_TRACE, "rts_mac_en : %d",
-                        device_config->rts_mac_en);
         vxge_debug_ll_config(VXGE_TRACE, "rth_en : %d",
                         device_config->rth_en);
         vxge_debug_ll_config(VXGE_TRACE, "rth_it_type : %d",
@@ -3734,22 +4017,10 @@ static void __devinit vxge_print_parm(struct vxgedev *vdev, u64 vpath_mask)
                 vdev->config.tx_steering_type = 0;
         }
 
-        if (vdev->config.gro_enable) {
-                vxge_debug_init(VXGE_ERR,
-                        "%s: Generic receive offload enabled",
-                        vdev->ndev->name);
-        } else
-                vxge_debug_init(VXGE_TRACE,
-                        "%s: Generic receive offload disabled",
-                        vdev->ndev->name);
-
         if (vdev->config.addr_learn_en)
                 vxge_debug_init(VXGE_TRACE,
                         "%s: MAC Address learning enabled", vdev->ndev->name);
 
-        vxge_debug_init(VXGE_TRACE,
-                "%s: Rx doorbell mode enabled", vdev->ndev->name);
-
         for (i = 0; i < VXGE_HW_MAX_VIRTUAL_PATHS; i++) {
                 if (!vxge_bVALn(vpath_mask, i, 1))
                         continue;
@@ -3762,14 +4033,6 @@ static void __devinit vxge_print_parm(struct vxgedev *vdev, u64 vpath_mask)
                         ((struct __vxge_hw_device  *)(vdev->devh))->
                                 config.vp_config[i].rpa_strip_vlan_tag
                         ? "Enabled" : "Disabled");
-                vxge_debug_init(VXGE_TRACE,
-                        "%s: Ring blocks : %d", vdev->ndev->name,
-                        ((struct __vxge_hw_device  *)(vdev->devh))->
-                                config.vp_config[i].ring.ring_blocks);
-                vxge_debug_init(VXGE_TRACE,
-                        "%s: Fifo blocks : %d", vdev->ndev->name,
-                        ((struct __vxge_hw_device  *)(vdev->devh))->
-                                config.vp_config[i].fifo.fifo_blocks);
                 vxge_debug_ll_config(VXGE_TRACE,
                         "%s: Max frags : %d", vdev->ndev->name,
                         ((struct __vxge_hw_device  *)(vdev->devh))->
@@ -3809,8 +4072,7 @@ static int vxge_pm_resume(struct pci_dev *pdev)
 static pci_ers_result_t vxge_io_error_detected(struct pci_dev *pdev,
                                                 pci_channel_state_t state)
 {
-        struct __vxge_hw_device  *hldev =
-                (struct __vxge_hw_device  *) pci_get_drvdata(pdev);
+        struct __vxge_hw_device *hldev = pci_get_drvdata(pdev);
         struct net_device *netdev = hldev->ndev;
 
         netif_device_detach(netdev);
@@ -3839,8 +4101,7 @@ static pci_ers_result_t vxge_io_error_detected(struct pci_dev *pdev,
  */
 static pci_ers_result_t vxge_io_slot_reset(struct pci_dev *pdev)
 {
-        struct __vxge_hw_device  *hldev =
-                (struct __vxge_hw_device  *) pci_get_drvdata(pdev);
+        struct __vxge_hw_device *hldev = pci_get_drvdata(pdev);
         struct net_device *netdev = hldev->ndev;
 
         struct vxgedev *vdev = netdev_priv(netdev);
@@ -3851,7 +4112,7 @@ static pci_ers_result_t vxge_io_slot_reset(struct pci_dev *pdev)
         }
 
         pci_set_master(pdev);
-        vxge_reset(vdev);
+        do_vxge_reset(vdev, VXGE_LL_FULL_RESET);
 
         return PCI_ERS_RESULT_RECOVERED;
 }
@@ -3865,8 +4126,7 @@ static pci_ers_result_t vxge_io_slot_reset(struct pci_dev *pdev)
  */
 static void vxge_io_resume(struct pci_dev *pdev)
 {
-        struct __vxge_hw_device  *hldev =
-                (struct __vxge_hw_device  *) pci_get_drvdata(pdev);
+        struct __vxge_hw_device *hldev = pci_get_drvdata(pdev);
         struct net_device *netdev = hldev->ndev;
 
         if (netif_running(netdev)) {
@@ -3910,6 +4170,157 @@ static inline u32 vxge_get_num_vfs(u64 function_mode)
         return num_functions;
 }
 
+int vxge_fw_upgrade(struct vxgedev *vdev, char *fw_name, int override)
+{
+        struct __vxge_hw_device *hldev = vdev->devh;
+        u32 maj, min, bld, cmaj, cmin, cbld;
+        enum vxge_hw_status status;
+        const struct firmware *fw;
+        int ret;
+
+        ret = request_firmware(&fw, fw_name, &vdev->pdev->dev);
+        if (ret) {
+                vxge_debug_init(VXGE_ERR, "%s: Firmware file '%s' not found",
+                                VXGE_DRIVER_NAME, fw_name);
+                goto out;
+        }
+
+        /* Load the new firmware onto the adapter */
+        status = vxge_update_fw_image(hldev, fw->data, fw->size);
+        if (status != VXGE_HW_OK) {
+                vxge_debug_init(VXGE_ERR,
+                                "%s: FW image download to adapter failed '%s'.",
+                                VXGE_DRIVER_NAME, fw_name);
+                ret = -EIO;
+                goto out;
+        }
+
+        /* Read the version of the new firmware */
+        status = vxge_hw_upgrade_read_version(hldev, &maj, &min, &bld);
+        if (status != VXGE_HW_OK) {
+                vxge_debug_init(VXGE_ERR,
+                                "%s: Upgrade read version failed '%s'.",
+                                VXGE_DRIVER_NAME, fw_name);
+                ret = -EIO;
+                goto out;
+        }
+
+        cmaj = vdev->config.device_hw_info.fw_version.major;
+        cmin = vdev->config.device_hw_info.fw_version.minor;
+        cbld = vdev->config.device_hw_info.fw_version.build;
+        /* It's possible the version in /lib/firmware is not the latest version.
+         * If so, we could get into a loop of trying to upgrade to the latest
+         * and flashing the older version.
+         */
+        if (VXGE_FW_VER(maj, min, bld) == VXGE_FW_VER(cmaj, cmin, cbld) &&
+            !override) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        printk(KERN_NOTICE "Upgrade to firmware version %d.%d.%d commencing\n",
+               maj, min, bld);
+
+        /* Flash the adapter with the new firmware */
+        status = vxge_hw_flash_fw(hldev);
+        if (status != VXGE_HW_OK) {
+                vxge_debug_init(VXGE_ERR, "%s: Upgrade commit failed '%s'.",
+                                VXGE_DRIVER_NAME, fw_name);
+                ret = -EIO;
+                goto out;
+        }
+
+        printk(KERN_NOTICE "Upgrade of firmware successful!  Adapter must be "
+               "hard reset before using, thus requiring a system reboot or a "
+               "hotplug event.\n");
+
+out:
+        release_firmware(fw);
+        return ret;
+}
+
+static int vxge_probe_fw_update(struct vxgedev *vdev)
+{
+        u32 maj, min, bld;
+        int ret, gpxe = 0;
+        char *fw_name;
+
+        maj = vdev->config.device_hw_info.fw_version.major;
+        min = vdev->config.device_hw_info.fw_version.minor;
+        bld = vdev->config.device_hw_info.fw_version.build;
+
+        if (VXGE_FW_VER(maj, min, bld) == VXGE_CERT_FW_VER)
+                return 0;
+
+        /* Ignore the build number when determining if the current firmware is
+         * "too new" to load the driver
+         */
+        if (VXGE_FW_VER(maj, min, 0) > VXGE_CERT_FW_VER) {
+                vxge_debug_init(VXGE_ERR, "%s: Firmware newer than last known "
+                                "version, unable to load driver\n",
+                                VXGE_DRIVER_NAME);
+                return -EINVAL;
+        }
+
+        /* Firmware 1.4.4 and older cannot be upgraded, and is too ancient to
+         * work with this driver.
+         */
+        if (VXGE_FW_VER(maj, min, bld) <= VXGE_FW_DEAD_VER) {
+                vxge_debug_init(VXGE_ERR, "%s: Firmware %d.%d.%d cannot be "
+                                "upgraded\n", VXGE_DRIVER_NAME, maj, min, bld);
+                return -EINVAL;
+        }
+
+        /* If file not specified, determine gPXE or not */
+        if (VXGE_FW_VER(maj, min, bld) >= VXGE_EPROM_FW_VER) {
+                int i;
+                for (i = 0; i < VXGE_HW_MAX_ROM_IMAGES; i++)
+                        if (vdev->devh->eprom_versions[i]) {
+                                gpxe = 1;
+                                break;
+                        }
+        }
+        if (gpxe)
+                fw_name = "vxge/X3fw-pxe.ncf";
+        else
+                fw_name = "vxge/X3fw.ncf";
+
+        ret = vxge_fw_upgrade(vdev, fw_name, 0);
+        /* -EINVAL and -ENOENT are not fatal errors for flashing firmware on
+         * probe, so ignore them
+         */
+        if (ret != -EINVAL && ret != -ENOENT)
+                return -EIO;
+        else
+                ret = 0;
+
+        if (VXGE_FW_VER(VXGE_CERT_FW_VER_MAJOR, VXGE_CERT_FW_VER_MINOR, 0) >
+            VXGE_FW_VER(maj, min, 0)) {
+                vxge_debug_init(VXGE_ERR, "%s: Firmware %d.%d.%d is too old to"
+                                " be used with this driver.\n"
+                                "Please get the latest version from "
+                                "ftp://ftp.s2io.com/pub/X3100-Drivers/FIRMWARE",
+                                VXGE_DRIVER_NAME, maj, min, bld);
+                return -EINVAL;
+        }
+
+        return ret;
+}
+
+static int __devinit is_sriov_initialized(struct pci_dev *pdev)
+{
+        int pos;
+        u16 ctrl;
+
+        pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_SRIOV);
+        if (pos) {
+                pci_read_config_word(pdev, pos + PCI_SRIOV_CTRL, &ctrl);
+                if (ctrl & PCI_SRIOV_CTRL_VFE)
+                        return 1;
+        }
+        return 0;
+}
+
 /**
  * vxge_probe
  * @pdev : structure containing the PCI related information of the device.
@@ -3924,7 +4335,7 @@ static inline u32 vxge_get_num_vfs(u64 function_mode)
 static int __devinit
 vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
 {
-        struct __vxge_hw_device  *hldev;
+        struct __vxge_hw_device *hldev;
         enum vxge_hw_status status;
         int ret;
         int high_dma = 0;
@@ -3947,9 +4358,10 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
         attr.pdev = pdev;
 
         /* In SRIOV-17 mode, functions of the same adapter
-         * can be deployed on different buses */
-        if ((!pdev->is_virtfn) && ((bus != pdev->bus->number) ||
-                (device != PCI_SLOT(pdev->devfn))))
+         * can be deployed on different buses
+         */
+        if (((bus != pdev->bus->number) || (device != PCI_SLOT(pdev->devfn))) &&
+            !pdev->is_virtfn)
                 new_device = 1;
 
         bus = pdev->bus->number;
@@ -3967,6 +4379,7 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
                 driver_config->config_dev_cnt = 0;
                 driver_config->total_dev_cnt = 0;
         }
+
         /* Now making the CPU based no of vpath calculation
          * applicable for individual functions as well.
          */
@@ -3989,11 +4402,11 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
                 goto _exit0;
         }
 
-        ll_config = kzalloc(sizeof(*ll_config), GFP_KERNEL);
+        ll_config = kzalloc(sizeof(struct vxge_config), GFP_KERNEL);
         if (!ll_config) {
                 ret = -ENOMEM;
                 vxge_debug_init(VXGE_ERR,
-                        "ll_config : malloc failed %s %d",
+                        "device_config : malloc failed %s %d",
                         __FILE__, __LINE__);
                 goto _exit0;
         }
@@ -4037,10 +4450,10 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
                 goto _exit1;
         }
 
-        if (pci_request_regions(pdev, VXGE_DRIVER_NAME)) {
+        ret = pci_request_region(pdev, 0, VXGE_DRIVER_NAME);
+        if (ret) {
                 vxge_debug_init(VXGE_ERR,
                         "%s : request regions failed", __func__);
-                ret = -ENODEV;
                 goto _exit1;
         }
 
@@ -4068,16 +4481,6 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
                 goto _exit3;
         }
 
-        if (ll_config->device_hw_info.fw_version.major !=
-                VXGE_DRIVER_FW_VERSION_MAJOR) {
-                vxge_debug_init(VXGE_ERR,
-                        "%s: Incorrect firmware version."
-                        "Please upgrade the firmware to version 1.x.x",
-                        VXGE_DRIVER_NAME);
-                ret = -EINVAL;
-                goto _exit3;
-        }
-
         vpath_mask = ll_config->device_hw_info.vpath_mask;
         if (vpath_mask == 0) {
                 vxge_debug_ll_config(VXGE_TRACE,
@@ -4106,14 +4509,13 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
                 num_vfs = vxge_get_num_vfs(function_mode) - 1;
 
         /* Enable SRIOV mode, if firmware has SRIOV support and if it is a PF */
-        if (is_sriov(function_mode) && (max_config_dev > 1) &&
-                (ll_config->intr_type != INTA) &&
-                (is_privileged == VXGE_HW_OK)) {
-                ret = pci_enable_sriov(pdev, ((max_config_dev - 1) < num_vfs)
-                        ? (max_config_dev - 1) : num_vfs);
+        if (is_sriov(function_mode) && !is_sriov_initialized(pdev) &&
+           (ll_config->intr_type != INTA)) {
+                ret = pci_enable_sriov(pdev, num_vfs);
                 if (ret)
                         vxge_debug_ll_config(VXGE_ERR,
                                 "Failed in enabling SRIOV mode: %d\n", ret);
+                        /* No need to fail out, as an error here is non-fatal */
         }
 
         /*
@@ -4141,46 +4543,93 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
                         goto _exit3;
         }
 
+        if (VXGE_FW_VER(ll_config->device_hw_info.fw_version.major,
+                        ll_config->device_hw_info.fw_version.minor,
+                        ll_config->device_hw_info.fw_version.build) >=
+            VXGE_EPROM_FW_VER) {
+                struct eprom_image img[VXGE_HW_MAX_ROM_IMAGES];
+
+                status = vxge_hw_vpath_eprom_img_ver_get(hldev, img);
+                if (status != VXGE_HW_OK) {
+                        vxge_debug_init(VXGE_ERR, "%s: Reading of EPROM failed",
+                                        VXGE_DRIVER_NAME);
+                        /* This is a non-fatal error, continue */
+                }
+
+                for (i = 0; i < VXGE_HW_MAX_ROM_IMAGES; i++) {
+                        hldev->eprom_versions[i] = img[i].version;
+                        if (!img[i].is_valid)
+                                break;
+                        vxge_debug_init(VXGE_TRACE, "%s: EPROM %d, version "
+                                        "%d.%d.%d.%d", VXGE_DRIVER_NAME, i,
+                                        VXGE_EPROM_IMG_MAJOR(img[i].version),
+                                        VXGE_EPROM_IMG_MINOR(img[i].version),
+                                        VXGE_EPROM_IMG_FIX(img[i].version),
+                                        VXGE_EPROM_IMG_BUILD(img[i].version));
+                }
+        }
+
         /* if FCS stripping is not disabled in MAC fail driver load */
-        if (vxge_hw_vpath_strip_fcs_check(hldev, vpath_mask) != VXGE_HW_OK) {
-                vxge_debug_init(VXGE_ERR,
-                        "%s: FCS stripping is not disabled in MAC"
-                        " failing driver load", VXGE_DRIVER_NAME);
+        status = vxge_hw_vpath_strip_fcs_check(hldev, vpath_mask);
+        if (status != VXGE_HW_OK) {
+                vxge_debug_init(VXGE_ERR, "%s: FCS stripping is enabled in MAC"
+                                " failing driver load", VXGE_DRIVER_NAME);
                 ret = -EINVAL;
                 goto _exit4;
         }
 
+        /* Always enable HWTS.  This will always cause the FCS to be invalid,
+         * due to the fact that HWTS is using the FCS as the location of the
+         * timestamp.  The HW FCS checking will still correctly determine if
+         * there is a valid checksum, and the FCS is being removed by the driver
+         * anyway.  So no fucntionality is being lost.  Since it is always
+         * enabled, we now simply use the ioctl call to set whether or not the
+         * driver should be paying attention to the HWTS.
+         */
+        if (is_privileged == VXGE_HW_OK) {
+                status = vxge_timestamp_config(hldev);
+                if (status != VXGE_HW_OK) {
+                        vxge_debug_init(VXGE_ERR, "%s: HWTS enable failed",
+                                        VXGE_DRIVER_NAME);
+                        ret = -EFAULT;
+                        goto _exit4;
+                }
+        }
+
         vxge_hw_device_debug_set(hldev, VXGE_ERR, VXGE_COMPONENT_LL);
 
         /* set private device info */
         pci_set_drvdata(pdev, hldev);
 
-        ll_config->gro_enable = VXGE_GRO_ALWAYS_AGGREGATE;
         ll_config->fifo_indicate_max_pkts = VXGE_FIFO_INDICATE_MAX_PKTS;
         ll_config->addr_learn_en = addr_learn_en;
         ll_config->rth_algorithm = RTH_ALG_JENKINS;
-        ll_config->rth_hash_type_tcpipv4 = VXGE_HW_RING_HASH_TYPE_TCP_IPV4;
-        ll_config->rth_hash_type_ipv4 = VXGE_HW_RING_HASH_TYPE_NONE;
-        ll_config->rth_hash_type_tcpipv6 = VXGE_HW_RING_HASH_TYPE_NONE;
-        ll_config->rth_hash_type_ipv6 = VXGE_HW_RING_HASH_TYPE_NONE;
-        ll_config->rth_hash_type_tcpipv6ex = VXGE_HW_RING_HASH_TYPE_NONE;
-        ll_config->rth_hash_type_ipv6ex = VXGE_HW_RING_HASH_TYPE_NONE;
+        ll_config->rth_hash_type_tcpipv4 = 1;
+        ll_config->rth_hash_type_ipv4 = 0;
+        ll_config->rth_hash_type_tcpipv6 = 0;
+        ll_config->rth_hash_type_ipv6 = 0;
+        ll_config->rth_hash_type_tcpipv6ex = 0;
+        ll_config->rth_hash_type_ipv6ex = 0;
         ll_config->rth_bkt_sz = RTH_BUCKET_SIZE;
         ll_config->tx_pause_enable = VXGE_PAUSE_CTRL_ENABLE;
         ll_config->rx_pause_enable = VXGE_PAUSE_CTRL_ENABLE;
 
-        if (vxge_device_register(hldev, ll_config, high_dma, no_of_vpath,
-                &vdev)) {
+        ret = vxge_device_register(hldev, ll_config, high_dma, no_of_vpath,
+                                   &vdev);
+        if (ret) {
                 ret = -EINVAL;
                 goto _exit4;
         }
 
+        ret = vxge_probe_fw_update(vdev);
+        if (ret)
+                goto _exit5;
+
         vxge_hw_device_debug_set(hldev, VXGE_TRACE, VXGE_COMPONENT_LL);
         VXGE_COPY_DEBUG_INFO_TO_LL(vdev, vxge_hw_device_error_level_get(hldev),
                 vxge_hw_device_trace_level_get(hldev));
 
         /* set private HW device info */
-        hldev->ndev = vdev->ndev;
         vdev->mtu = VXGE_HW_DEFAULT_MTU;
         vdev->bar0 = attr.bar0;
         vdev->max_vpath_supported = max_vpath_supported;
@@ -4274,15 +4723,13 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
 
         /* Copy the station mac address to the list */
         for (i = 0; i < vdev->no_of_vpath; i++) {
-                entry = (struct vxge_mac_addrs *)
-                                kzalloc(sizeof(struct vxge_mac_addrs),
-                                        GFP_KERNEL);
+                entry = kzalloc(sizeof(struct vxge_mac_addrs), GFP_KERNEL);
                 if (NULL == entry) {
                         vxge_debug_init(VXGE_ERR,
                                 "%s: mac_addr_list : memory allocation failed",
                                 vdev->ndev->name);
                         ret = -EPERM;
-                        goto _exit5;
+                        goto _exit6;
                 }
                 macaddr = (u8 *)&entry->macaddr;
                 memcpy(macaddr, vdev->ndev->dev_addr, ETH_ALEN);
@@ -4322,25 +4769,26 @@ vxge_probe(struct pci_dev *pdev, const struct pci_device_id *pre)
         kfree(ll_config);
         return 0;
 
-_exit5:
+_exit6:
         for (i = 0; i < vdev->no_of_vpath; i++)
                 vxge_free_mac_add_list(&vdev->vpaths[i]);
-
+_exit5:
         vxge_device_unregister(hldev);
 _exit4:
-        pci_disable_sriov(pdev);
+        pci_set_drvdata(pdev, NULL);
         vxge_hw_device_terminate(hldev);
+        pci_disable_sriov(pdev);
 _exit3:
         iounmap(attr.bar0);
 _exit2:
-        pci_release_regions(pdev);
+        pci_release_region(pdev, 0);
 _exit1:
         pci_disable_device(pdev);
 _exit0:
         kfree(ll_config);
         kfree(device_config);
         driver_config->config_dev_cnt--;
-        pci_set_drvdata(pdev, NULL);
+        driver_config->total_dev_cnt--;
         return ret;
 }
 
@@ -4350,61 +4798,39 @@ _exit0:
  * Description: This function is called by the Pci subsystem to release a
  * PCI device and free up all resource held up by the device.
  */
-static void __devexit
-vxge_remove(struct pci_dev *pdev)
+static void __devexit vxge_remove(struct pci_dev *pdev)
 {
-        struct __vxge_hw_device  *hldev;
-        struct vxgedev *vdev = NULL;
-        struct net_device *dev;
-        int i = 0;
-#if ((VXGE_DEBUG_INIT & VXGE_DEBUG_MASK) || \
-        (VXGE_DEBUG_ENTRYEXIT & VXGE_DEBUG_MASK))
-        u32 level_trace;
-#endif
-
-        hldev = (struct __vxge_hw_device  *) pci_get_drvdata(pdev);
+        struct __vxge_hw_device *hldev;
+        struct vxgedev *vdev;
+        int i;
 
+        hldev = pci_get_drvdata(pdev);
         if (hldev == NULL)
                 return;
-        dev = hldev->ndev;
-        vdev = netdev_priv(dev);
 
-#if ((VXGE_DEBUG_INIT & VXGE_DEBUG_MASK) || \
-        (VXGE_DEBUG_ENTRYEXIT & VXGE_DEBUG_MASK))
-        level_trace = vdev->level_trace;
-#endif
-        vxge_debug_entryexit(level_trace,
-                "%s:%d", __func__, __LINE__);
+        vdev = netdev_priv(hldev->ndev);
 
-        vxge_debug_init(level_trace,
-                "%s : removing PCI device...", __func__);
-        vxge_device_unregister(hldev);
+        vxge_debug_entryexit(vdev->level_trace, "%s:%d", __func__, __LINE__);
+        vxge_debug_init(vdev->level_trace, "%s : removing PCI device...",
+                        __func__);
 
-        for (i = 0; i < vdev->no_of_vpath; i++) {
+        for (i = 0; i < vdev->no_of_vpath; i++)
                 vxge_free_mac_add_list(&vdev->vpaths[i]);
-                vdev->vpaths[i].mcast_addr_cnt = 0;
-                vdev->vpaths[i].mac_addr_cnt = 0;
-        }
-
-        kfree(vdev->vpaths);
-
-        iounmap(vdev->bar0);
-
-        pci_disable_sriov(pdev);
-
-        /* we are safe to free it now */
-        free_netdev(dev);
-
-        vxge_debug_init(level_trace,
-                "%s:%d  Device unregistered", __func__, __LINE__);
 
+        vxge_device_unregister(hldev);
+        pci_set_drvdata(pdev, NULL);
+        /* Do not call pci_disable_sriov here, as it will break child devices */
         vxge_hw_device_terminate(hldev);
-
+        iounmap(vdev->bar0);
+        pci_release_region(pdev, 0);
         pci_disable_device(pdev);
-        pci_release_regions(pdev);
-        pci_set_drvdata(pdev, NULL);
-        vxge_debug_entryexit(level_trace,
-                "%s:%d  Exiting...", __func__, __LINE__);
+        driver_config->config_dev_cnt--;
+        driver_config->total_dev_cnt--;
+
+        vxge_debug_init(vdev->level_trace, "%s:%d Device unregistered",
+                        __func__, __LINE__);
+        vxge_debug_entryexit(vdev->level_trace, "%s:%d  Exiting...", __func__,
+                             __LINE__);
 }
 
 static struct pci_error_handlers vxge_err_handler = {
@@ -4440,6 +4866,10 @@ vxge_starter(void)
                 return -ENOMEM;
 
         ret = pci_register_driver(&vxge_driver);
+        if (ret) {
+                kfree(driver_config);
+                goto err;
+        }
 
         if (driver_config->config_dev_cnt &&
            (driver_config->config_dev_cnt != driver_config->total_dev_cnt))
@@ -4447,10 +4877,7 @@ vxge_starter(void)
                         "%s: Configured %d of %d devices",
                         VXGE_DRIVER_NAME, driver_config->config_dev_cnt,
                         driver_config->total_dev_cnt);
-
-        if (ret)
-                kfree(driver_config);
-
+err:
         return ret;
 }
 
diff --git a/drivers/net/vxge/vxge-main.h b/drivers/net/vxge/vxge-main.h
index 2e3b064b8e4b..ed120aba443d 100644
--- a/drivers/net/vxge/vxge-main.h
+++ b/drivers/net/vxge/vxge-main.h
@@ -29,6 +29,9 @@
 
 #define PCI_DEVICE_ID_TITAN_WIN         0x5733
 #define PCI_DEVICE_ID_TITAN_UNI         0x5833
+#define VXGE_HW_TITAN1_PCI_REVISION     1
+#define VXGE_HW_TITAN1A_PCI_REVISION    2
+
 #define VXGE_USE_DEFAULT                0xffffffff
 #define VXGE_HW_VPATH_MSIX_ACTIVE       4
 #define VXGE_ALARM_MSIX_ID              2
@@ -53,12 +56,16 @@
 
 #define VXGE_TTI_BTIMER_VAL 250000
 
-#define VXGE_TTI_LTIMER_VAL 1000
-#define VXGE_TTI_RTIMER_VAL 0
-#define VXGE_RTI_BTIMER_VAL 250
-#define VXGE_RTI_LTIMER_VAL 100
-#define VXGE_RTI_RTIMER_VAL 0
-#define VXGE_FIFO_INDICATE_MAX_PKTS VXGE_DEF_FIFO_LENGTH
+#define VXGE_TTI_LTIMER_VAL     1000
+#define VXGE_T1A_TTI_LTIMER_VAL 80
+#define VXGE_TTI_RTIMER_VAL     0
+#define VXGE_TTI_RTIMER_ADAPT_VAL       10
+#define VXGE_T1A_TTI_RTIMER_VAL 400
+#define VXGE_RTI_BTIMER_VAL     250
+#define VXGE_RTI_LTIMER_VAL     100
+#define VXGE_RTI_RTIMER_VAL     0
+#define VXGE_RTI_RTIMER_ADAPT_VAL       15
+#define VXGE_FIFO_INDICATE_MAX_PKTS     VXGE_DEF_FIFO_LENGTH
 #define VXGE_ISR_POLLING_CNT    8
 #define VXGE_MAX_CONFIG_DEV     0xFF
 #define VXGE_EXEC_MODE_DISABLE  0
@@ -76,14 +83,40 @@
 #define TTI_TX_UFC_B    40
 #define TTI_TX_UFC_C    60
 #define TTI_TX_UFC_D    100
-
-#define RTI_RX_URANGE_A 5
-#define RTI_RX_URANGE_B 15
-#define RTI_RX_URANGE_C 40
-#define RTI_RX_UFC_A    1
-#define RTI_RX_UFC_B    5
-#define RTI_RX_UFC_C    10
-#define RTI_RX_UFC_D    15
+#define TTI_T1A_TX_UFC_A        30
+#define TTI_T1A_TX_UFC_B        80
+/* Slope - (max_mtu - min_mtu)/(max_mtu_ufc - min_mtu_ufc) */
+/* Slope - 93 */
+/* 60 - 9k Mtu, 140 - 1.5k mtu */
+#define TTI_T1A_TX_UFC_C(mtu)   (60 + ((VXGE_HW_MAX_MTU - mtu) / 93))
+
+/* Slope - 37 */
+/* 100 - 9k Mtu, 300 - 1.5k mtu */
+#define TTI_T1A_TX_UFC_D(mtu)   (100 + ((VXGE_HW_MAX_MTU - mtu) / 37))
+
+
+#define RTI_RX_URANGE_A         5
+#define RTI_RX_URANGE_B         15
+#define RTI_RX_URANGE_C         40
+#define RTI_T1A_RX_URANGE_A     1
+#define RTI_T1A_RX_URANGE_B     20
+#define RTI_T1A_RX_URANGE_C     50
+#define RTI_RX_UFC_A            1
+#define RTI_RX_UFC_B            5
+#define RTI_RX_UFC_C            10
+#define RTI_RX_UFC_D            15
+#define RTI_T1A_RX_UFC_B        20
+#define RTI_T1A_RX_UFC_C        50
+#define RTI_T1A_RX_UFC_D        60
+
+/*
+ * The interrupt rate is maintained at 3k per second with the moderation
+ * parameters for most traffic but not all. This is the maximum interrupt
+ * count allowed per function with INTA or per vector in the case of
+ * MSI-X in a 10 millisecond time period. Enabled only for Titan 1A.
+ */
+#define VXGE_T1A_MAX_INTERRUPT_COUNT    100
+#define VXGE_T1A_MAX_TX_INTERRUPT_COUNT 200
 
 /* Milli secs timer period */
 #define VXGE_TIMER_DELAY                10000
@@ -135,9 +168,6 @@ struct vxge_config {
 
 #define NEW_NAPI_WEIGHT 64
         int             napi_weight;
-#define VXGE_GRO_DONOT_AGGREGATE                0
-#define VXGE_GRO_ALWAYS_AGGREGATE               1
-        int             gro_enable;
         int             intr_type;
 #define INTA    0
 #define MSI     1
@@ -145,15 +175,15 @@ struct vxge_config {
 
         int             addr_learn_en;
 
-        int             rth_steering;
-        int             rth_algorithm;
-        int             rth_hash_type_tcpipv4;
-        int             rth_hash_type_ipv4;
-        int             rth_hash_type_tcpipv6;
-        int             rth_hash_type_ipv6;
-        int             rth_hash_type_tcpipv6ex;
-        int             rth_hash_type_ipv6ex;
-        int             rth_bkt_sz;
+        u32             rth_steering:2,
+                        rth_algorithm:2,
+                        rth_hash_type_tcpipv4:1,
+                        rth_hash_type_ipv4:1,
+                        rth_hash_type_tcpipv6:1,
+                        rth_hash_type_ipv6:1,
+                        rth_hash_type_tcpipv6ex:1,
+                        rth_hash_type_ipv6ex:1,
+                        rth_bkt_sz:8;
         int             rth_jhash_golden_ratio;
         int             tx_steering_type;
         int     fifo_indicate_max_pkts;
@@ -172,7 +202,6 @@ struct vxge_msix_entry {
 
 struct vxge_sw_stats {
         /* Network Stats (interface stats) */
-        struct net_device_stats net_stats;
 
         /* Tx */
         u64 tx_frms;
@@ -225,6 +254,11 @@ struct vxge_fifo {
         int tx_steering_type;
         int indicate_max_pkts;
 
+        /* Adaptive interrupt moderation parameters used in T1A */
+        unsigned long interrupt_count;
+        unsigned long jiffies;
+
+        u32 tx_vector_no;
         /* Tx stats */
         struct vxge_fifo_stats stats;
 } ____cacheline_aligned;
@@ -249,12 +283,15 @@ struct vxge_ring {
          */
         int driver_id;
 
-         /* copy of the flag indicating whether rx_csum is to be used */
-        u32 rx_csum;
+        /* Adaptive interrupt moderation parameters used in T1A */
+        unsigned long interrupt_count;
+        unsigned long jiffies;
+
+        /* copy of the flag indicating whether rx_hwts is to be used */
+        u32 rx_hwts:1;
 
         int pkts_processed;
         int budget;
-        int gro_enable;
 
         struct napi_struct napi;
         struct napi_struct *napi_p;
@@ -263,7 +300,7 @@ struct vxge_ring {
 
         int vlan_tag_strip;
         struct vlan_group *vlgrp;
-        int rx_vector_no;
+        u32 rx_vector_no;
         enum vxge_hw_status last_status;
 
         /* Rx stats */
@@ -282,8 +319,8 @@ struct vxge_vpath {
         int is_configured;
         int is_open;
         struct vxgedev *vdev;
-        u8 (macaddr)[ETH_ALEN];
-        u8 (macmask)[ETH_ALEN];
+        u8 macaddr[ETH_ALEN];
+        u8 macmask[ETH_ALEN];
 
 #define VXGE_MAX_LEARN_MAC_ADDR_CNT     2048
         /* mac addresses currently programmed into NIC */
@@ -327,8 +364,9 @@ struct vxgedev {
          */
         u16             all_multi_flg;
 
-         /* A flag indicating whether rx_csum is to be used or not. */
-        u32     rx_csum;
+        /* A flag indicating whether rx_hwts is to be used or not. */
+        u32     rx_hwts:1,
+                titan1:1;
 
         struct vxge_msix_entry *vxge_entries;
         struct msix_entry *entries;
@@ -370,6 +408,7 @@ struct vxgedev {
         u32             level_err;
         u32             level_trace;
         char            fw_version[VXGE_HW_FW_STRLEN];
+        struct work_struct reset_task;
 };
 
 struct vxge_rx_priv {
@@ -388,8 +427,6 @@ struct vxge_tx_priv {
         static int p = val; \
         module_param(p, int, 0)
 
-#define vxge_os_bug(fmt...)             { printk(fmt); BUG(); }
-
 #define vxge_os_timer(timer, handle, arg, exp) do { \
                 init_timer(&timer); \
                 timer.function = handle; \
@@ -397,64 +434,10 @@ struct vxge_tx_priv {
                 mod_timer(&timer, (jiffies + exp)); \
         } while (0);
 
-int __devinit vxge_device_register(struct __vxge_hw_device *devh,
-                                    struct vxge_config *config,
-                                    int high_dma, int no_of_vpath,
-                                    struct vxgedev **vdev);
-
-void vxge_device_unregister(struct __vxge_hw_device *devh);
-
-void vxge_vpath_intr_enable(struct vxgedev *vdev, int vp_id);
-
-void vxge_vpath_intr_disable(struct vxgedev *vdev, int vp_id);
-
-void vxge_callback_link_up(struct __vxge_hw_device *devh);
-
-void vxge_callback_link_down(struct __vxge_hw_device *devh);
-
-enum vxge_hw_status vxge_add_mac_addr(struct vxgedev *vdev,
-        struct macInfo *mac);
-
-int vxge_mac_list_del(struct vxge_vpath *vpath, struct macInfo *mac);
-
-int vxge_reset(struct vxgedev *vdev);
-
-enum vxge_hw_status
-vxge_rx_1b_compl(struct __vxge_hw_ring *ringh, void *dtr,
-        u8 t_code, void *userdata);
-
-enum vxge_hw_status
-vxge_xmit_compl(struct __vxge_hw_fifo *fifo_hw, void *dtr,
-        enum vxge_hw_fifo_tcode t_code, void *userdata,
-        struct sk_buff ***skb_ptr, int nr_skbs, int *more);
-
-int vxge_close(struct net_device *dev);
-
-int vxge_open(struct net_device *dev);
-
-void vxge_close_vpaths(struct vxgedev *vdev, int index);
-
-int vxge_open_vpaths(struct vxgedev *vdev);
-
+void vxge_initialize_ethtool_ops(struct net_device *ndev);
 enum vxge_hw_status vxge_reset_all_vpaths(struct vxgedev *vdev);
+int vxge_fw_upgrade(struct vxgedev *vdev, char *fw_name, int override);
 
-enum vxge_hw_status vxge_add_mac_addr(struct vxgedev *vdev,
-        struct macInfo *mac);
-
-enum vxge_hw_status vxge_del_mac_addr(struct vxgedev *vdev,
-        struct macInfo *mac);
-
-int vxge_mac_list_add(struct vxge_vpath *vpath,
-        struct macInfo *mac);
-
-void vxge_free_mac_add_list(struct vxge_vpath *vpath);
-
-enum vxge_hw_status vxge_restore_vpath_mac_addr(struct vxge_vpath *vpath);
-
-enum vxge_hw_status vxge_restore_vpath_vid_table(struct vxge_vpath *vpath);
-
-int do_vxge_close(struct net_device *dev, int do_io);
-extern void initialize_ethtool_ops(struct net_device *ndev);
 /**
  * #define VXGE_DEBUG_INIT: debug for initialization functions
  * #define VXGE_DEBUG_TX         : debug transmit related functions
diff --git a/drivers/net/vxge/vxge-reg.h b/drivers/net/vxge/vxge-reg.h
index 3dd5c9615ef9..3e658b175947 100644
--- a/drivers/net/vxge/vxge-reg.h
+++ b/drivers/net/vxge/vxge-reg.h
@@ -49,6 +49,33 @@
 #define VXGE_HW_TITAN_VPMGMT_REG_SPACES                 17
 #define VXGE_HW_TITAN_VPATH_REG_SPACES                  17
 
+#define VXGE_HW_FW_API_GET_EPROM_REV                    31
+
+#define VXGE_EPROM_IMG_MAJOR(val)               (u32) vxge_bVALn(val, 48, 4)
+#define VXGE_EPROM_IMG_MINOR(val)               (u32) vxge_bVALn(val, 52, 4)
+#define VXGE_EPROM_IMG_FIX(val)                 (u32) vxge_bVALn(val, 56, 4)
+#define VXGE_EPROM_IMG_BUILD(val)               (u32) vxge_bVALn(val, 60, 4)
+
+#define VXGE_HW_GET_EPROM_IMAGE_INDEX(val)              vxge_bVALn(val, 16, 8)
+#define VXGE_HW_GET_EPROM_IMAGE_VALID(val)              vxge_bVALn(val, 31, 1)
+#define VXGE_HW_GET_EPROM_IMAGE_TYPE(val)               vxge_bVALn(val, 40, 8)
+#define VXGE_HW_GET_EPROM_IMAGE_REV(val)                vxge_bVALn(val, 48, 16)
+#define VXGE_HW_RTS_ACCESS_STEER_ROM_IMAGE_INDEX(val)   vxge_vBIT(val, 16, 8)
+
+#define VXGE_HW_FW_API_GET_FUNC_MODE                    29
+#define VXGE_HW_GET_FUNC_MODE_VAL(val)                  (val & 0xFF)
+
+#define VXGE_HW_FW_UPGRADE_MEMO                         13
+#define VXGE_HW_FW_UPGRADE_ACTION                       16
+#define VXGE_HW_FW_UPGRADE_OFFSET_START                 2
+#define VXGE_HW_FW_UPGRADE_OFFSET_SEND                  3
+#define VXGE_HW_FW_UPGRADE_OFFSET_COMMIT                4
+#define VXGE_HW_FW_UPGRADE_OFFSET_READ                  5
+
+#define VXGE_HW_FW_UPGRADE_BLK_SIZE                     16
+#define VXGE_HW_UPGRADE_GET_RET_ERR_CODE(val)           (val & 0xff)
+#define VXGE_HW_UPGRADE_GET_SEC_ERR_CODE(val)           ((val >> 8) & 0xff)
+
 #define VXGE_HW_ASIC_MODE_RESERVED                              0
 #define VXGE_HW_ASIC_MODE_NO_IOV                                1
 #define VXGE_HW_ASIC_MODE_SR_IOV                                2
@@ -165,13 +192,13 @@
 #define VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_ETYPE             2
 #define VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_PN                3
 #define VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_GEN_CFG       5
-#define VXGE_HW_RTS_ACS_STEER_CTRL_DATA_STRUCT_SEL_RTH_SOLO_IT  6
+#define VXGE_HW_RTS_ACS_STEER_CTRL_DATA_STRUCT_SEL_RTH_SOLO_IT          6
 #define VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_JHASH_CFG     7
 #define VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MASK          8
 #define VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_RTH_KEY           9
 #define VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_QOS               10
 #define VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_DS                11
-#define VXGE_HW_RTS_ACS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT 12
+#define VXGE_HW_RTS_ACS_STEER_CTRL_DATA_STRUCT_SEL_RTH_MULTI_IT         12
 #define VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_FW_MEMO           13
 
 #define VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_DA_MAC_ADDR(bits) \
@@ -437,6 +464,7 @@
 #define VXGE_HW_RTS_ACCESS_STEER_DATA1_GET_FLASH_VER_BUILD(bits) \
                                                         vxge_bVALn(bits, 48, 16)
 #define VXGE_HW_RTS_ACCESS_STEER_DATA1_FLASH_VER_BUILD vxge_vBIT(val, 48, 16)
+#define VXGE_HW_RTS_ACCESS_STEER_CTRL_GET_ACTION(bits) vxge_bVALn(bits, 0, 8)
 
 #define VXGE_HW_SRPCIM_TO_VPATH_ALARM_REG_GET_PPIF_SRPCIM_TO_VPATH_ALARM(bits)\
                                                         vxge_bVALn(bits, 0, 18)
@@ -3998,6 +4026,7 @@ struct vxge_hw_vpath_reg {
 #define VXGE_HW_PRC_CFG6_L4_CPC_TRSFR_CODE_EN   vxge_mBIT(9)
 #define VXGE_HW_PRC_CFG6_RXD_CRXDT(val) vxge_vBIT(val, 23, 9)
 #define VXGE_HW_PRC_CFG6_RXD_SPAT(val) vxge_vBIT(val, 36, 9)
+#define VXGE_HW_PRC_CFG6_GET_RXD_SPAT(val)      vxge_bVALn(val, 36, 9)
 /*0x00a78*/     u64     prc_cfg7;
 #define VXGE_HW_PRC_CFG7_SCATTER_MODE(val) vxge_vBIT(val, 6, 2)
 #define VXGE_HW_PRC_CFG7_SMART_SCAT_EN  vxge_mBIT(11)
diff --git a/drivers/net/vxge/vxge-traffic.c b/drivers/net/vxge/vxge-traffic.c
index cedf08f99cb3..f93517055162 100644
--- a/drivers/net/vxge/vxge-traffic.c
+++ b/drivers/net/vxge/vxge-traffic.c
@@ -12,6 +12,7 @@
  * Copyright(c) 2002-2010 Exar Corp.
  ******************************************************************************/
 #include <linux/etherdevice.h>
+#include <linux/prefetch.h>
 
 #include "vxge-traffic.h"
 #include "vxge-config.h"
@@ -218,6 +219,68 @@ exit:
         return status;
 }
 
+void vxge_hw_vpath_tti_ci_set(struct __vxge_hw_fifo *fifo)
+{
+        struct vxge_hw_vpath_reg __iomem *vp_reg;
+        struct vxge_hw_vp_config *config;
+        u64 val64;
+
+        if (fifo->config->enable != VXGE_HW_FIFO_ENABLE)
+                return;
+
+        vp_reg = fifo->vp_reg;
+        config = container_of(fifo->config, struct vxge_hw_vp_config, fifo);
+
+        if (config->tti.timer_ci_en != VXGE_HW_TIM_TIMER_CI_ENABLE) {
+                config->tti.timer_ci_en = VXGE_HW_TIM_TIMER_CI_ENABLE;
+                val64 = readq(&vp_reg->tim_cfg1_int_num[VXGE_HW_VPATH_INTR_TX]);
+                val64 |= VXGE_HW_TIM_CFG1_INT_NUM_TIMER_CI;
+                fifo->tim_tti_cfg1_saved = val64;
+                writeq(val64, &vp_reg->tim_cfg1_int_num[VXGE_HW_VPATH_INTR_TX]);
+        }
+}
+
+void vxge_hw_vpath_dynamic_rti_ci_set(struct __vxge_hw_ring *ring)
+{
+        u64 val64 = ring->tim_rti_cfg1_saved;
+
+        val64 |= VXGE_HW_TIM_CFG1_INT_NUM_TIMER_CI;
+        ring->tim_rti_cfg1_saved = val64;
+        writeq(val64, &ring->vp_reg->tim_cfg1_int_num[VXGE_HW_VPATH_INTR_RX]);
+}
+
+void vxge_hw_vpath_dynamic_tti_rtimer_set(struct __vxge_hw_fifo *fifo)
+{
+        u64 val64 = fifo->tim_tti_cfg3_saved;
+        u64 timer = (fifo->rtimer * 1000) / 272;
+
+        val64 &= ~VXGE_HW_TIM_CFG3_INT_NUM_RTIMER_VAL(0x3ffffff);
+        if (timer)
+                val64 |= VXGE_HW_TIM_CFG3_INT_NUM_RTIMER_VAL(timer) |
+                        VXGE_HW_TIM_CFG3_INT_NUM_RTIMER_EVENT_SF(5);
+
+        writeq(val64, &fifo->vp_reg->tim_cfg3_int_num[VXGE_HW_VPATH_INTR_TX]);
+        /* tti_cfg3_saved is not updated again because it is
+         * initialized at one place only - init time.
+         */
+}
+
+void vxge_hw_vpath_dynamic_rti_rtimer_set(struct __vxge_hw_ring *ring)
+{
+        u64 val64 = ring->tim_rti_cfg3_saved;
+        u64 timer = (ring->rtimer * 1000) / 272;
+
+        val64 &= ~VXGE_HW_TIM_CFG3_INT_NUM_RTIMER_VAL(0x3ffffff);
+        if (timer)
+                val64 |= VXGE_HW_TIM_CFG3_INT_NUM_RTIMER_VAL(timer) |
+                        VXGE_HW_TIM_CFG3_INT_NUM_RTIMER_EVENT_SF(4);
+
+        writeq(val64, &ring->vp_reg->tim_cfg3_int_num[VXGE_HW_VPATH_INTR_RX]);
+        /* rti_cfg3_saved is not updated again because it is
+         * initialized at one place only - init time.
+         */
+}
+
 /**
  * vxge_hw_channel_msix_mask - Mask MSIX Vector.
  * @channeh: Channel for rx or tx handle
@@ -254,6 +317,23 @@ vxge_hw_channel_msix_unmask(struct __vxge_hw_channel *channel, int msix_id)
 }
 
 /**
+ * vxge_hw_channel_msix_clear - Unmask the MSIX Vector.
+ * @channel: Channel for rx or tx handle
+ * @msix_id:  MSI ID
+ *
+ * The function unmasks the msix interrupt for the given msix_id
+ * if configured in MSIX oneshot mode
+ *
+ * Returns: 0
+ */
+void vxge_hw_channel_msix_clear(struct __vxge_hw_channel *channel, int msix_id)
+{
+        __vxge_hw_pio_mem_write32_upper(
+                (u32) vxge_bVALn(vxge_mBIT(msix_id >> 2), 0, 32),
+                &channel->common_reg->clr_msix_one_shot_vec[msix_id % 4]);
+}
+
+/**
  * vxge_hw_device_set_intr_type - Updates the configuration
  *              with new interrupt type.
  * @hldev: HW device handle.
@@ -412,6 +492,384 @@ void vxge_hw_device_flush_io(struct __vxge_hw_device *hldev)
 }
 
 /**
+ * __vxge_hw_device_handle_error - Handle error
+ * @hldev: HW device
+ * @vp_id: Vpath Id
+ * @type: Error type. Please see enum vxge_hw_event{}
+ *
+ * Handle error.
+ */
+static enum vxge_hw_status
+__vxge_hw_device_handle_error(struct __vxge_hw_device *hldev, u32 vp_id,
+                              enum vxge_hw_event type)
+{
+        switch (type) {
+        case VXGE_HW_EVENT_UNKNOWN:
+                break;
+        case VXGE_HW_EVENT_RESET_START:
+        case VXGE_HW_EVENT_RESET_COMPLETE:
+        case VXGE_HW_EVENT_LINK_DOWN:
+        case VXGE_HW_EVENT_LINK_UP:
+                goto out;
+        case VXGE_HW_EVENT_ALARM_CLEARED:
+                goto out;
+        case VXGE_HW_EVENT_ECCERR:
+        case VXGE_HW_EVENT_MRPCIM_ECCERR:
+                goto out;
+        case VXGE_HW_EVENT_FIFO_ERR:
+        case VXGE_HW_EVENT_VPATH_ERR:
+        case VXGE_HW_EVENT_CRITICAL_ERR:
+        case VXGE_HW_EVENT_SERR:
+                break;
+        case VXGE_HW_EVENT_SRPCIM_SERR:
+        case VXGE_HW_EVENT_MRPCIM_SERR:
+                goto out;
+        case VXGE_HW_EVENT_SLOT_FREEZE:
+                break;
+        default:
+                vxge_assert(0);
+                goto out;
+        }
+
+        /* notify driver */
+        if (hldev->uld_callbacks.crit_err)
+                hldev->uld_callbacks.crit_err(
+                        (struct __vxge_hw_device *)hldev,
+                        type, vp_id);
+out:
+
+        return VXGE_HW_OK;
+}
+
+/*
+ * __vxge_hw_device_handle_link_down_ind
+ * @hldev: HW device handle.
+ *
+ * Link down indication handler. The function is invoked by HW when
+ * Titan indicates that the link is down.
+ */
+static enum vxge_hw_status
+__vxge_hw_device_handle_link_down_ind(struct __vxge_hw_device *hldev)
+{
+        /*
+         * If the previous link state is not down, return.
+         */
+        if (hldev->link_state == VXGE_HW_LINK_DOWN)
+                goto exit;
+
+        hldev->link_state = VXGE_HW_LINK_DOWN;
+
+        /* notify driver */
+        if (hldev->uld_callbacks.link_down)
+                hldev->uld_callbacks.link_down(hldev);
+exit:
+        return VXGE_HW_OK;
+}
+
+/*
+ * __vxge_hw_device_handle_link_up_ind
+ * @hldev: HW device handle.
+ *
+ * Link up indication handler. The function is invoked by HW when
+ * Titan indicates that the link is up for programmable amount of time.
+ */
+static enum vxge_hw_status
+__vxge_hw_device_handle_link_up_ind(struct __vxge_hw_device *hldev)
+{
+        /*
+         * If the previous link state is not down, return.
+         */
+        if (hldev->link_state == VXGE_HW_LINK_UP)
+                goto exit;
+
+        hldev->link_state = VXGE_HW_LINK_UP;
+
+        /* notify driver */
+        if (hldev->uld_callbacks.link_up)
+                hldev->uld_callbacks.link_up(hldev);
+exit:
+        return VXGE_HW_OK;
+}
+
+/*
+ * __vxge_hw_vpath_alarm_process - Process Alarms.
+ * @vpath: Virtual Path.
+ * @skip_alarms: Do not clear the alarms
+ *
+ * Process vpath alarms.
+ *
+ */
+static enum vxge_hw_status
+__vxge_hw_vpath_alarm_process(struct __vxge_hw_virtualpath *vpath,
+                              u32 skip_alarms)
+{
+        u64 val64;
+        u64 alarm_status;
+        u64 pic_status;
+        struct __vxge_hw_device *hldev = NULL;
+        enum vxge_hw_event alarm_event = VXGE_HW_EVENT_UNKNOWN;
+        u64 mask64;
+        struct vxge_hw_vpath_stats_sw_info *sw_stats;
+        struct vxge_hw_vpath_reg __iomem *vp_reg;
+
+        if (vpath == NULL) {
+                alarm_event = VXGE_HW_SET_LEVEL(VXGE_HW_EVENT_UNKNOWN,
+                        alarm_event);
+                goto out2;
+        }
+
+        hldev = vpath->hldev;
+        vp_reg = vpath->vp_reg;
+        alarm_status = readq(&vp_reg->vpath_general_int_status);
+
+        if (alarm_status == VXGE_HW_ALL_FOXES) {
+                alarm_event = VXGE_HW_SET_LEVEL(VXGE_HW_EVENT_SLOT_FREEZE,
+                        alarm_event);
+                goto out;
+        }
+
+        sw_stats = vpath->sw_stats;
+
+        if (alarm_status & ~(
+                VXGE_HW_VPATH_GENERAL_INT_STATUS_PIC_INT |
+                VXGE_HW_VPATH_GENERAL_INT_STATUS_PCI_INT |
+                VXGE_HW_VPATH_GENERAL_INT_STATUS_WRDMA_INT |
+                VXGE_HW_VPATH_GENERAL_INT_STATUS_XMAC_INT)) {
+                sw_stats->error_stats.unknown_alarms++;
+
+                alarm_event = VXGE_HW_SET_LEVEL(VXGE_HW_EVENT_UNKNOWN,
+                        alarm_event);
+                goto out;
+        }
+
+        if (alarm_status & VXGE_HW_VPATH_GENERAL_INT_STATUS_XMAC_INT) {
+
+                val64 = readq(&vp_reg->xgmac_vp_int_status);
+
+                if (val64 &
+                VXGE_HW_XGMAC_VP_INT_STATUS_ASIC_NTWK_VP_ERR_ASIC_NTWK_VP_INT) {
+
+                        val64 = readq(&vp_reg->asic_ntwk_vp_err_reg);
+
+                        if (((val64 &
+                              VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_FLT) &&
+                             (!(val64 &
+                                VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_OK))) ||
+                            ((val64 &
+                             VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_FLT_OCCURR) &&
+                             (!(val64 &
+                                VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_OK_OCCURR)
+                                     ))) {
+                                sw_stats->error_stats.network_sustained_fault++;
+
+                                writeq(
+                                VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_FLT,
+                                        &vp_reg->asic_ntwk_vp_err_mask);
+
+                                __vxge_hw_device_handle_link_down_ind(hldev);
+                                alarm_event = VXGE_HW_SET_LEVEL(
+                                        VXGE_HW_EVENT_LINK_DOWN, alarm_event);
+                        }
+
+                        if (((val64 &
+                              VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_OK) &&
+                             (!(val64 &
+                                VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_FLT))) ||
+                            ((val64 &
+                              VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_OK_OCCURR) &&
+                             (!(val64 &
+                                VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_FLT_OCCURR)
+                                     ))) {
+
+                                sw_stats->error_stats.network_sustained_ok++;
+
+                                writeq(
+                                VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_OK,
+                                        &vp_reg->asic_ntwk_vp_err_mask);
+
+                                __vxge_hw_device_handle_link_up_ind(hldev);
+                                alarm_event = VXGE_HW_SET_LEVEL(
+                                        VXGE_HW_EVENT_LINK_UP, alarm_event);
+                        }
+
+                        writeq(VXGE_HW_INTR_MASK_ALL,
+                                &vp_reg->asic_ntwk_vp_err_reg);
+
+                        alarm_event = VXGE_HW_SET_LEVEL(
+                                VXGE_HW_EVENT_ALARM_CLEARED, alarm_event);
+
+                        if (skip_alarms)
+                                return VXGE_HW_OK;
+                }
+        }
+
+        if (alarm_status & VXGE_HW_VPATH_GENERAL_INT_STATUS_PIC_INT) {
+
+                pic_status = readq(&vp_reg->vpath_ppif_int_status);
+
+                if (pic_status &
+                    VXGE_HW_VPATH_PPIF_INT_STATUS_GENERAL_ERRORS_GENERAL_INT) {
+
+                        val64 = readq(&vp_reg->general_errors_reg);
+                        mask64 = readq(&vp_reg->general_errors_mask);
+
+                        if ((val64 &
+                                VXGE_HW_GENERAL_ERRORS_REG_INI_SERR_DET) &
+                                ~mask64) {
+                                sw_stats->error_stats.ini_serr_det++;
+
+                                alarm_event = VXGE_HW_SET_LEVEL(
+                                        VXGE_HW_EVENT_SERR, alarm_event);
+                        }
+
+                        if ((val64 &
+                            VXGE_HW_GENERAL_ERRORS_REG_DBLGEN_FIFO0_OVRFLOW) &
+                                ~mask64) {
+                                sw_stats->error_stats.dblgen_fifo0_overflow++;
+
+                                alarm_event = VXGE_HW_SET_LEVEL(
+                                        VXGE_HW_EVENT_FIFO_ERR, alarm_event);
+                        }
+
+                        if ((val64 &
+                            VXGE_HW_GENERAL_ERRORS_REG_STATSB_PIF_CHAIN_ERR) &
+                                ~mask64)
+                                sw_stats->error_stats.statsb_pif_chain_error++;
+
+                        if ((val64 &
+                           VXGE_HW_GENERAL_ERRORS_REG_STATSB_DROP_TIMEOUT_REQ) &
+                                ~mask64)
+                                sw_stats->error_stats.statsb_drop_timeout++;
+
+                        if ((val64 &
+                                VXGE_HW_GENERAL_ERRORS_REG_TGT_ILLEGAL_ACCESS) &
+                                ~mask64)
+                                sw_stats->error_stats.target_illegal_access++;
+
+                        if (!skip_alarms) {
+                                writeq(VXGE_HW_INTR_MASK_ALL,
+                                        &vp_reg->general_errors_reg);
+                                alarm_event = VXGE_HW_SET_LEVEL(
+                                        VXGE_HW_EVENT_ALARM_CLEARED,
+                                        alarm_event);
+                        }
+                }
+
+                if (pic_status &
+                    VXGE_HW_VPATH_PPIF_INT_STATUS_KDFCCTL_ERRORS_KDFCCTL_INT) {
+
+                        val64 = readq(&vp_reg->kdfcctl_errors_reg);
+                        mask64 = readq(&vp_reg->kdfcctl_errors_mask);
+
+                        if ((val64 &
+                            VXGE_HW_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_OVRWR) &
+                                ~mask64) {
+                                sw_stats->error_stats.kdfcctl_fifo0_overwrite++;
+
+                                alarm_event = VXGE_HW_SET_LEVEL(
+                                        VXGE_HW_EVENT_FIFO_ERR,
+                                        alarm_event);
+                        }
+
+                        if ((val64 &
+                            VXGE_HW_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_POISON) &
+                                ~mask64) {
+                                sw_stats->error_stats.kdfcctl_fifo0_poison++;
+
+                                alarm_event = VXGE_HW_SET_LEVEL(
+                                        VXGE_HW_EVENT_FIFO_ERR,
+                                        alarm_event);
+                        }
+
+                        if ((val64 &
+                            VXGE_HW_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_DMA_ERR) &
+                                ~mask64) {
+                                sw_stats->error_stats.kdfcctl_fifo0_dma_error++;
+
+                                alarm_event = VXGE_HW_SET_LEVEL(
+                                        VXGE_HW_EVENT_FIFO_ERR,
+                                        alarm_event);
+                        }
+
+                        if (!skip_alarms) {
+                                writeq(VXGE_HW_INTR_MASK_ALL,
+                                        &vp_reg->kdfcctl_errors_reg);
+                                alarm_event = VXGE_HW_SET_LEVEL(
+                                        VXGE_HW_EVENT_ALARM_CLEARED,
+                                        alarm_event);
+                        }
+                }
+
+        }
+
+        if (alarm_status & VXGE_HW_VPATH_GENERAL_INT_STATUS_WRDMA_INT) {
+
+                val64 = readq(&vp_reg->wrdma_alarm_status);
+
+                if (val64 & VXGE_HW_WRDMA_ALARM_STATUS_PRC_ALARM_PRC_INT) {
+
+                        val64 = readq(&vp_reg->prc_alarm_reg);
+                        mask64 = readq(&vp_reg->prc_alarm_mask);
+
+                        if ((val64 & VXGE_HW_PRC_ALARM_REG_PRC_RING_BUMP)&
+                                ~mask64)
+                                sw_stats->error_stats.prc_ring_bumps++;
+
+                        if ((val64 & VXGE_HW_PRC_ALARM_REG_PRC_RXDCM_SC_ERR) &
+                                ~mask64) {
+                                sw_stats->error_stats.prc_rxdcm_sc_err++;
+
+                                alarm_event = VXGE_HW_SET_LEVEL(
+                                        VXGE_HW_EVENT_VPATH_ERR,
+                                        alarm_event);
+                        }
+
+                        if ((val64 & VXGE_HW_PRC_ALARM_REG_PRC_RXDCM_SC_ABORT)
+                                & ~mask64) {
+                                sw_stats->error_stats.prc_rxdcm_sc_abort++;
+
+                                alarm_event = VXGE_HW_SET_LEVEL(
+                                                VXGE_HW_EVENT_VPATH_ERR,
+                                                alarm_event);
+                        }
+
+                        if ((val64 & VXGE_HW_PRC_ALARM_REG_PRC_QUANTA_SIZE_ERR)
+                                 & ~mask64) {
+                                sw_stats->error_stats.prc_quanta_size_err++;
+
+                                alarm_event = VXGE_HW_SET_LEVEL(
+                                        VXGE_HW_EVENT_VPATH_ERR,
+                                        alarm_event);
+                        }
+
+                        if (!skip_alarms) {
+                                writeq(VXGE_HW_INTR_MASK_ALL,
+                                        &vp_reg->prc_alarm_reg);
+                                alarm_event = VXGE_HW_SET_LEVEL(
+                                                VXGE_HW_EVENT_ALARM_CLEARED,
+                                                alarm_event);
+                        }
+                }
+        }
+out:
+        hldev->stats.sw_dev_err_stats.vpath_alarms++;
+out2:
+        if ((alarm_event == VXGE_HW_EVENT_ALARM_CLEARED) ||
+                (alarm_event == VXGE_HW_EVENT_UNKNOWN))
+                return VXGE_HW_OK;
+
+        __vxge_hw_device_handle_error(hldev, vpath->vp_id, alarm_event);
+
+        if (alarm_event == VXGE_HW_EVENT_SERR)
+                return VXGE_HW_ERR_CRITICAL;
+
+        return (alarm_event == VXGE_HW_EVENT_SLOT_FREEZE) ?
+                VXGE_HW_ERR_SLOT_FREEZE :
+                (alarm_event == VXGE_HW_EVENT_FIFO_ERR) ? VXGE_HW_ERR_FIFO :
+                VXGE_HW_ERR_VPATH;
+}
+
+/**
  * vxge_hw_device_begin_irq - Begin IRQ processing.
  * @hldev: HW device handle.
  * @skip_alarms: Do not clear the alarms
@@ -506,108 +964,6 @@ exit:
         return ret;
 }
 
-/*
- * __vxge_hw_device_handle_link_up_ind
- * @hldev: HW device handle.
- *
- * Link up indication handler. The function is invoked by HW when
- * Titan indicates that the link is up for programmable amount of time.
- */
-enum vxge_hw_status
-__vxge_hw_device_handle_link_up_ind(struct __vxge_hw_device *hldev)
-{
-        /*
-         * If the previous link state is not down, return.
-         */
-        if (hldev->link_state == VXGE_HW_LINK_UP)
-                goto exit;
-
-        hldev->link_state = VXGE_HW_LINK_UP;
-
-        /* notify driver */
-        if (hldev->uld_callbacks.link_up)
-                hldev->uld_callbacks.link_up(hldev);
-exit:
-        return VXGE_HW_OK;
-}
-
-/*
- * __vxge_hw_device_handle_link_down_ind
- * @hldev: HW device handle.
- *
- * Link down indication handler. The function is invoked by HW when
- * Titan indicates that the link is down.
- */
-enum vxge_hw_status
-__vxge_hw_device_handle_link_down_ind(struct __vxge_hw_device *hldev)
-{
-        /*
-         * If the previous link state is not down, return.
-         */
-        if (hldev->link_state == VXGE_HW_LINK_DOWN)
-                goto exit;
-
-        hldev->link_state = VXGE_HW_LINK_DOWN;
-
-        /* notify driver */
-        if (hldev->uld_callbacks.link_down)
-                hldev->uld_callbacks.link_down(hldev);
-exit:
-        return VXGE_HW_OK;
-}
-
-/**
- * __vxge_hw_device_handle_error - Handle error
- * @hldev: HW device
- * @vp_id: Vpath Id
- * @type: Error type. Please see enum vxge_hw_event{}
- *
- * Handle error.
- */
-enum vxge_hw_status
-__vxge_hw_device_handle_error(
-                struct __vxge_hw_device *hldev,
-                u32 vp_id,
-                enum vxge_hw_event type)
-{
-        switch (type) {
-        case VXGE_HW_EVENT_UNKNOWN:
-                break;
-        case VXGE_HW_EVENT_RESET_START:
-        case VXGE_HW_EVENT_RESET_COMPLETE:
-        case VXGE_HW_EVENT_LINK_DOWN:
-        case VXGE_HW_EVENT_LINK_UP:
-                goto out;
-        case VXGE_HW_EVENT_ALARM_CLEARED:
-                goto out;
-        case VXGE_HW_EVENT_ECCERR:
-        case VXGE_HW_EVENT_MRPCIM_ECCERR:
-                goto out;
-        case VXGE_HW_EVENT_FIFO_ERR:
-        case VXGE_HW_EVENT_VPATH_ERR:
-        case VXGE_HW_EVENT_CRITICAL_ERR:
-        case VXGE_HW_EVENT_SERR:
-                break;
-        case VXGE_HW_EVENT_SRPCIM_SERR:
-        case VXGE_HW_EVENT_MRPCIM_SERR:
-                goto out;
-        case VXGE_HW_EVENT_SLOT_FREEZE:
-                break;
-        default:
-                vxge_assert(0);
-                goto out;
-        }
-
-        /* notify driver */
-        if (hldev->uld_callbacks.crit_err)
-                hldev->uld_callbacks.crit_err(
-                        (struct __vxge_hw_device *)hldev,
-                        type, vp_id);
-out:
-
-        return VXGE_HW_OK;
-}
-
 /**
  * vxge_hw_device_clear_tx_rx - Acknowledge (that is, clear) the
  * condition that has caused the Tx and RX interrupt.
@@ -646,7 +1002,7 @@ void vxge_hw_device_clear_tx_rx(struct __vxge_hw_device *hldev)
  * it swaps the reserve and free arrays.
  *
  */
-enum vxge_hw_status
+static enum vxge_hw_status
 vxge_hw_channel_dtr_alloc(struct __vxge_hw_channel *channel, void **dtrh)
 {
         void **tmp_arr;
@@ -692,7 +1048,8 @@ _alloc_after_swap:
  * Posts a dtr to work array.
  *
  */
-void vxge_hw_channel_dtr_post(struct __vxge_hw_channel *channel, void *dtrh)
+static void
+vxge_hw_channel_dtr_post(struct __vxge_hw_channel *channel, void *dtrh)
 {
         vxge_assert(channel->work_arr[channel->post_index] == NULL);
 
@@ -755,7 +1112,7 @@ void vxge_hw_channel_dtr_free(struct __vxge_hw_channel *channel, void *dtrh)
  * vxge_hw_channel_dtr_count
  * @channel: Channel handle. Obtained via vxge_hw_channel_open().
  *
- * Retreive number of DTRs available. This function can not be called
+ * Retrieve number of DTRs available. This function can not be called
  * from data path. ring_initial_replenishi() is the only user.
  */
 int vxge_hw_channel_dtr_count(struct __vxge_hw_channel *channel)
@@ -903,10 +1260,6 @@ void vxge_hw_ring_rxd_post(struct __vxge_hw_ring *ring, void *rxdh)
  */
 void vxge_hw_ring_rxd_post_post_wmb(struct __vxge_hw_ring *ring, void *rxdh)
 {
-        struct __vxge_hw_channel *channel;
-
-        channel = &ring->channel;
-
         wmb();
         vxge_hw_ring_rxd_post_post(ring, rxdh);
 }
@@ -967,7 +1320,7 @@ enum vxge_hw_status vxge_hw_ring_rxd_next_completed(
         *t_code = (u8)VXGE_HW_RING_RXD_T_CODE_GET(control_0);
 
         /* check whether it is not the end */
-        if (!own || ((*t_code == VXGE_HW_RING_T_CODE_FRM_DROP) && own)) {
+        if (!own || *t_code == VXGE_HW_RING_T_CODE_FRM_DROP) {
 
                 vxge_assert(((struct vxge_hw_ring_rxd_1 *)rxdp)->host_control !=
                                 0);
@@ -1658,37 +2011,6 @@ exit:
 }
 
 /**
- * vxge_hw_vpath_vid_get_next - Get the next vid entry for this vpath
- *               from vlan id table.
- * @vp: Vpath handle.
- * @vid: Buffer to return vlan id
- *
- * Returns the next vlan id in the list for this vpath.
- * see also: vxge_hw_vpath_vid_get
- *
- */
-enum vxge_hw_status
-vxge_hw_vpath_vid_get_next(struct __vxge_hw_vpath_handle *vp, u64 *vid)
-{
-        u64 data;
-        enum vxge_hw_status status = VXGE_HW_OK;
-
-        if (vp == NULL) {
-                status = VXGE_HW_ERR_INVALID_HANDLE;
-                goto exit;
-        }
-
-        status = __vxge_hw_vpath_rts_table_get(vp,
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_ACTION_LIST_NEXT_ENTRY,
-                        VXGE_HW_RTS_ACCESS_STEER_CTRL_DATA_STRUCT_SEL_VID,
-                        0, vid, &data);
-
-        *vid = VXGE_HW_RTS_ACCESS_STEER_DATA0_GET_VLAN_ID(*vid);
-exit:
-        return status;
-}
-
-/**
  * vxge_hw_vpath_vid_delete - Delete the vlan id entry for this vpath
  *               to vlan id table.
  * @vp: Vpath handle.
@@ -1739,7 +2061,7 @@ enum vxge_hw_status vxge_hw_vpath_promisc_enable(
 
         vpath = vp->vpath;
 
-        /* Enable promiscous mode for function 0 only */
+        /* Enable promiscuous mode for function 0 only */
         if (!(vpath->hldev->access_rights &
                 VXGE_HW_DEVICE_ACCESS_RIGHT_MRPCIM))
                 return VXGE_HW_OK;
@@ -1891,284 +2213,6 @@ exit:
 }
 
 /*
- * __vxge_hw_vpath_alarm_process - Process Alarms.
- * @vpath: Virtual Path.
- * @skip_alarms: Do not clear the alarms
- *
- * Process vpath alarms.
- *
- */
-enum vxge_hw_status __vxge_hw_vpath_alarm_process(
-                        struct __vxge_hw_virtualpath *vpath,
-                        u32 skip_alarms)
-{
-        u64 val64;
-        u64 alarm_status;
-        u64 pic_status;
-        struct __vxge_hw_device *hldev = NULL;
-        enum vxge_hw_event alarm_event = VXGE_HW_EVENT_UNKNOWN;
-        u64 mask64;
-        struct vxge_hw_vpath_stats_sw_info *sw_stats;
-        struct vxge_hw_vpath_reg __iomem *vp_reg;
-
-        if (vpath == NULL) {
-                alarm_event = VXGE_HW_SET_LEVEL(VXGE_HW_EVENT_UNKNOWN,
-                        alarm_event);
-                goto out2;
-        }
-
-        hldev = vpath->hldev;
-        vp_reg = vpath->vp_reg;
-        alarm_status = readq(&vp_reg->vpath_general_int_status);
-
-        if (alarm_status == VXGE_HW_ALL_FOXES) {
-                alarm_event = VXGE_HW_SET_LEVEL(VXGE_HW_EVENT_SLOT_FREEZE,
-                        alarm_event);
-                goto out;
-        }
-
-        sw_stats = vpath->sw_stats;
-
-        if (alarm_status & ~(
-                VXGE_HW_VPATH_GENERAL_INT_STATUS_PIC_INT |
-                VXGE_HW_VPATH_GENERAL_INT_STATUS_PCI_INT |
-                VXGE_HW_VPATH_GENERAL_INT_STATUS_WRDMA_INT |
-                VXGE_HW_VPATH_GENERAL_INT_STATUS_XMAC_INT)) {
-                sw_stats->error_stats.unknown_alarms++;
-
-                alarm_event = VXGE_HW_SET_LEVEL(VXGE_HW_EVENT_UNKNOWN,
-                        alarm_event);
-                goto out;
-        }
-
-        if (alarm_status & VXGE_HW_VPATH_GENERAL_INT_STATUS_XMAC_INT) {
-
-                val64 = readq(&vp_reg->xgmac_vp_int_status);
-
-                if (val64 &
-                VXGE_HW_XGMAC_VP_INT_STATUS_ASIC_NTWK_VP_ERR_ASIC_NTWK_VP_INT) {
-
-                        val64 = readq(&vp_reg->asic_ntwk_vp_err_reg);
-
-                        if (((val64 &
-                              VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_FLT) &&
-                             (!(val64 &
-                                VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_OK))) ||
-                            ((val64 &
-                              VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_FLT_OCCURR) &&
-                             (!(val64 &
-                                VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_OK_OCCURR)
-                                     ))) {
-                                sw_stats->error_stats.network_sustained_fault++;
-
-                                writeq(
-                                VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_FLT,
-                                        &vp_reg->asic_ntwk_vp_err_mask);
-
-                                __vxge_hw_device_handle_link_down_ind(hldev);
-                                alarm_event = VXGE_HW_SET_LEVEL(
-                                        VXGE_HW_EVENT_LINK_DOWN, alarm_event);
-                        }
-
-                        if (((val64 &
-                              VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_OK) &&
-                             (!(val64 &
-                                VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_FLT))) ||
-                            ((val64 &
-                              VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_OK_OCCURR) &&
-                             (!(val64 &
-                                VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_FLT_OCCURR)
-                                     ))) {
-
-                                sw_stats->error_stats.network_sustained_ok++;
-
-                                writeq(
-                                VXGE_HW_ASIC_NW_VP_ERR_REG_XMACJ_STN_OK,
-                                        &vp_reg->asic_ntwk_vp_err_mask);
-
-                                __vxge_hw_device_handle_link_up_ind(hldev);
-                                alarm_event = VXGE_HW_SET_LEVEL(
-                                        VXGE_HW_EVENT_LINK_UP, alarm_event);
-                        }
-
-                        writeq(VXGE_HW_INTR_MASK_ALL,
-                                &vp_reg->asic_ntwk_vp_err_reg);
-
-                        alarm_event = VXGE_HW_SET_LEVEL(
-                                VXGE_HW_EVENT_ALARM_CLEARED, alarm_event);
-
-                        if (skip_alarms)
-                                return VXGE_HW_OK;
-                }
-        }
-
-        if (alarm_status & VXGE_HW_VPATH_GENERAL_INT_STATUS_PIC_INT) {
-
-                pic_status = readq(&vp_reg->vpath_ppif_int_status);
-
-                if (pic_status &
-                    VXGE_HW_VPATH_PPIF_INT_STATUS_GENERAL_ERRORS_GENERAL_INT) {
-
-                        val64 = readq(&vp_reg->general_errors_reg);
-                        mask64 = readq(&vp_reg->general_errors_mask);
-
-                        if ((val64 &
-                                VXGE_HW_GENERAL_ERRORS_REG_INI_SERR_DET) &
-                                ~mask64) {
-                                sw_stats->error_stats.ini_serr_det++;
-
-                                alarm_event = VXGE_HW_SET_LEVEL(
-                                        VXGE_HW_EVENT_SERR, alarm_event);
-                        }
-
-                        if ((val64 &
-                            VXGE_HW_GENERAL_ERRORS_REG_DBLGEN_FIFO0_OVRFLOW) &
-                                ~mask64) {
-                                sw_stats->error_stats.dblgen_fifo0_overflow++;
-
-                                alarm_event = VXGE_HW_SET_LEVEL(
-                                        VXGE_HW_EVENT_FIFO_ERR, alarm_event);
-                        }
-
-                        if ((val64 &
-                            VXGE_HW_GENERAL_ERRORS_REG_STATSB_PIF_CHAIN_ERR) &
-                                ~mask64)
-                                sw_stats->error_stats.statsb_pif_chain_error++;
-
-                        if ((val64 &
-                           VXGE_HW_GENERAL_ERRORS_REG_STATSB_DROP_TIMEOUT_REQ) &
-                                ~mask64)
-                                sw_stats->error_stats.statsb_drop_timeout++;
-
-                        if ((val64 &
-                                VXGE_HW_GENERAL_ERRORS_REG_TGT_ILLEGAL_ACCESS) &
-                                ~mask64)
-                                sw_stats->error_stats.target_illegal_access++;
-
-                        if (!skip_alarms) {
-                                writeq(VXGE_HW_INTR_MASK_ALL,
-                                        &vp_reg->general_errors_reg);
-                                alarm_event = VXGE_HW_SET_LEVEL(
-                                        VXGE_HW_EVENT_ALARM_CLEARED,
-                                        alarm_event);
-                        }
-                }
-
-                if (pic_status &
-                    VXGE_HW_VPATH_PPIF_INT_STATUS_KDFCCTL_ERRORS_KDFCCTL_INT) {
-
-                        val64 = readq(&vp_reg->kdfcctl_errors_reg);
-                        mask64 = readq(&vp_reg->kdfcctl_errors_mask);
-
-                        if ((val64 &
-                            VXGE_HW_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_OVRWR) &
-                                ~mask64) {
-                                sw_stats->error_stats.kdfcctl_fifo0_overwrite++;
-
-                                alarm_event = VXGE_HW_SET_LEVEL(
-                                        VXGE_HW_EVENT_FIFO_ERR,
-                                        alarm_event);
-                        }
-
-                        if ((val64 &
-                            VXGE_HW_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_POISON) &
-                                ~mask64) {
-                                sw_stats->error_stats.kdfcctl_fifo0_poison++;
-
-                                alarm_event = VXGE_HW_SET_LEVEL(
-                                        VXGE_HW_EVENT_FIFO_ERR,
-                                        alarm_event);
-                        }
-
-                        if ((val64 &
-                            VXGE_HW_KDFCCTL_ERRORS_REG_KDFCCTL_FIFO0_DMA_ERR) &
-                                ~mask64) {
-                                sw_stats->error_stats.kdfcctl_fifo0_dma_error++;
-
-                                alarm_event = VXGE_HW_SET_LEVEL(
-                                        VXGE_HW_EVENT_FIFO_ERR,
-                                        alarm_event);
-                        }
-
-                        if (!skip_alarms) {
-                                writeq(VXGE_HW_INTR_MASK_ALL,
-                                        &vp_reg->kdfcctl_errors_reg);
-                                alarm_event = VXGE_HW_SET_LEVEL(
-                                        VXGE_HW_EVENT_ALARM_CLEARED,
-                                        alarm_event);
-                        }
-                }
-
-        }
-
-        if (alarm_status & VXGE_HW_VPATH_GENERAL_INT_STATUS_WRDMA_INT) {
-
-                val64 = readq(&vp_reg->wrdma_alarm_status);
-
-                if (val64 & VXGE_HW_WRDMA_ALARM_STATUS_PRC_ALARM_PRC_INT) {
-
-                        val64 = readq(&vp_reg->prc_alarm_reg);
-                        mask64 = readq(&vp_reg->prc_alarm_mask);
-
-                        if ((val64 & VXGE_HW_PRC_ALARM_REG_PRC_RING_BUMP)&
-                                ~mask64)
-                                sw_stats->error_stats.prc_ring_bumps++;
-
-                        if ((val64 & VXGE_HW_PRC_ALARM_REG_PRC_RXDCM_SC_ERR) &
-                                ~mask64) {
-                                sw_stats->error_stats.prc_rxdcm_sc_err++;
-
-                                alarm_event = VXGE_HW_SET_LEVEL(
-                                        VXGE_HW_EVENT_VPATH_ERR,
-                                        alarm_event);
-                        }
-
-                        if ((val64 & VXGE_HW_PRC_ALARM_REG_PRC_RXDCM_SC_ABORT)
-                                & ~mask64) {
-                                sw_stats->error_stats.prc_rxdcm_sc_abort++;
-
-                                alarm_event = VXGE_HW_SET_LEVEL(
-                                                VXGE_HW_EVENT_VPATH_ERR,
-                                                alarm_event);
-                        }
-
-                        if ((val64 & VXGE_HW_PRC_ALARM_REG_PRC_QUANTA_SIZE_ERR)
-                                 & ~mask64) {
-                                sw_stats->error_stats.prc_quanta_size_err++;
-
-                                alarm_event = VXGE_HW_SET_LEVEL(
-                                        VXGE_HW_EVENT_VPATH_ERR,
-                                        alarm_event);
-                        }
-
-                        if (!skip_alarms) {
-                                writeq(VXGE_HW_INTR_MASK_ALL,
-                                        &vp_reg->prc_alarm_reg);
-                                alarm_event = VXGE_HW_SET_LEVEL(
-                                                VXGE_HW_EVENT_ALARM_CLEARED,
-                                                alarm_event);
-                        }
-                }
-        }
-out:
-        hldev->stats.sw_dev_err_stats.vpath_alarms++;
-out2:
-        if ((alarm_event == VXGE_HW_EVENT_ALARM_CLEARED) ||
-                (alarm_event == VXGE_HW_EVENT_UNKNOWN))
-                return VXGE_HW_OK;
-
-        __vxge_hw_device_handle_error(hldev, vpath->vp_id, alarm_event);
-
-        if (alarm_event == VXGE_HW_EVENT_SERR)
-                return VXGE_HW_ERR_CRITICAL;
-
-        return (alarm_event == VXGE_HW_EVENT_SLOT_FREEZE) ?
-                VXGE_HW_ERR_SLOT_FREEZE :
-                (alarm_event == VXGE_HW_EVENT_FIFO_ERR) ? VXGE_HW_ERR_FIFO :
-                VXGE_HW_ERR_VPATH;
-}
-
-/*
  * vxge_hw_vpath_alarm_process - Process Alarms.
  * @vpath: Virtual Path.
  * @skip_alarms: Do not clear the alarms
@@ -2227,19 +2271,14 @@ vxge_hw_vpath_msix_set(struct __vxge_hw_vpath_handle *vp, int *tim_msix_id,
         if (vpath->hldev->config.intr_mode ==
                                         VXGE_HW_INTR_MODE_MSIX_ONE_SHOT) {
                 __vxge_hw_pio_mem_write32_upper((u32)vxge_bVALn(
+                                VXGE_HW_ONE_SHOT_VECT0_EN_ONE_SHOT_VECT0_EN,
+                                0, 32), &vp_reg->one_shot_vect0_en);
+                __vxge_hw_pio_mem_write32_upper((u32)vxge_bVALn(
                                 VXGE_HW_ONE_SHOT_VECT1_EN_ONE_SHOT_VECT1_EN,
                                 0, 32), &vp_reg->one_shot_vect1_en);
-        }
-
-        if (vpath->hldev->config.intr_mode ==
-                VXGE_HW_INTR_MODE_MSIX_ONE_SHOT) {
                 __vxge_hw_pio_mem_write32_upper((u32)vxge_bVALn(
                                 VXGE_HW_ONE_SHOT_VECT2_EN_ONE_SHOT_VECT2_EN,
                                 0, 32), &vp_reg->one_shot_vect2_en);
-
-                __vxge_hw_pio_mem_write32_upper((u32)vxge_bVALn(
-                                VXGE_HW_ONE_SHOT_VECT3_EN_ONE_SHOT_VECT3_EN,
-                                0, 32), &vp_reg->one_shot_vect3_en);
         }
 }
 
@@ -2276,22 +2315,18 @@ vxge_hw_vpath_msix_mask(struct __vxge_hw_vpath_handle *vp, int msix_id)
  * status.
  * See also:
  */
-void
-vxge_hw_vpath_msix_clear(struct __vxge_hw_vpath_handle *vp, int msix_id)
+void vxge_hw_vpath_msix_clear(struct __vxge_hw_vpath_handle *vp, int msix_id)
 {
         struct __vxge_hw_device *hldev = vp->vpath->hldev;
-        if (hldev->config.intr_mode ==
-                        VXGE_HW_INTR_MODE_MSIX_ONE_SHOT) {
+
+        if ((hldev->config.intr_mode == VXGE_HW_INTR_MODE_MSIX_ONE_SHOT))
                 __vxge_hw_pio_mem_write32_upper(
-                        (u32)vxge_bVALn(vxge_mBIT(msix_id >> 2), 0, 32),
-                                &hldev->common_reg->
-                                        clr_msix_one_shot_vec[msix_id%4]);
-        } else {
+                        (u32) vxge_bVALn(vxge_mBIT((msix_id >> 2)), 0, 32),
+                        &hldev->common_reg->clr_msix_one_shot_vec[msix_id % 4]);
+        else
                 __vxge_hw_pio_mem_write32_upper(
-                        (u32)vxge_bVALn(vxge_mBIT(msix_id >> 2), 0, 32),
-                                &hldev->common_reg->
-                                        clear_msix_mask_vect[msix_id%4]);
-        }
+                        (u32) vxge_bVALn(vxge_mBIT((msix_id >> 2)), 0, 32),
+                        &hldev->common_reg->clear_msix_mask_vect[msix_id % 4]);
 }
 
 /**
@@ -2316,22 +2351,6 @@ vxge_hw_vpath_msix_unmask(struct __vxge_hw_vpath_handle *vp, int msix_id)
 }
 
 /**
- * vxge_hw_vpath_msix_mask_all - Mask all MSIX vectors for the vpath.
- * @vp: Virtual Path handle.
- *
- * The function masks all msix interrupt for the given vpath
- *
- */
-void
-vxge_hw_vpath_msix_mask_all(struct __vxge_hw_vpath_handle *vp)
-{
-
-        __vxge_hw_pio_mem_write32_upper(
-                (u32)vxge_bVALn(vxge_mBIT(vp->vpath->vp_id), 0, 32),
-                &vp->vpath->hldev->common_reg->set_msix_mask_all_vect);
-}
-
-/**
  * vxge_hw_vpath_inta_mask_tx_rx - Mask Tx and Rx interrupts.
  * @vp: Virtual Path handle.
  *
diff --git a/drivers/net/vxge/vxge-traffic.h b/drivers/net/vxge/vxge-traffic.h
index 6fa07d13798e..4a518a3b131c 100644
--- a/drivers/net/vxge/vxge-traffic.h
+++ b/drivers/net/vxge/vxge-traffic.h
@@ -240,7 +240,7 @@ struct vxge_hw_tim_intr_config {
         u32                             btimer_val;
 #define VXGE_HW_MIN_TIM_BTIMER_VAL                              0
 #define VXGE_HW_MAX_TIM_BTIMER_VAL                              67108864
-#define VXGE_HW_USE_FLASH_DEFAULT                               0xffffffff
+#define VXGE_HW_USE_FLASH_DEFAULT                               (~0)
 
         u32                             timer_ac_en;
 #define VXGE_HW_TIM_TIMER_AC_ENABLE                             1
@@ -681,7 +681,7 @@ struct vxge_hw_xmac_aggr_stats {
  * @rx_red_discard: Count of received frames that are discarded because of RED
  *            (Random Early Discard).
  * @rx_xgmii_ctrl_err_cnt: Maintains a count of unexpected or misplaced control
- *            characters occuring between times of normal data transmission
+ *            characters occurring between times of normal data transmission
  *            (i.e. not included in RX_XGMII_DATA_ERR_CNT). This counter is
  *            incremented when either -
  *            1) The Reconciliation Sublayer (RS) is expecting one control
@@ -1695,7 +1695,7 @@ struct vxge_hw_device_stats_sw_err {
  * struct vxge_hw_device_stats - Contains HW per-device statistics,
  * including hw.
  * @devh: HW device handle.
- * @dma_addr: DMA addres of the %hw_info. Given to device to fill-in the stats.
+ * @dma_addr: DMA address of the %hw_info. Given to device to fill-in the stats.
  * @hw_info_dmah: DMA handle used to map hw statistics onto the device memory
  *                space.
  * @hw_info_dma_acch: One more DMA handle used subsequently to free the
@@ -1749,14 +1749,6 @@ vxge_hw_mrpcim_stats_access(
         u64 *stat);
 
 enum vxge_hw_status
-vxge_hw_device_xmac_aggr_stats_get(struct __vxge_hw_device *devh, u32 port,
-                                   struct vxge_hw_xmac_aggr_stats *aggr_stats);
-
-enum vxge_hw_status
-vxge_hw_device_xmac_port_stats_get(struct __vxge_hw_device *devh, u32 port,
-                                   struct vxge_hw_xmac_port_stats *port_stats);
-
-enum vxge_hw_status
 vxge_hw_device_xmac_stats_get(struct __vxge_hw_device *devh,
                               struct vxge_hw_xmac_stats *xmac_stats);
 
@@ -1912,34 +1904,6 @@ enum vxge_hw_ring_tcode {
         VXGE_HW_RING_T_CODE_MULTI_ERR                   = 0xF
 };
 
-/**
- * enum enum vxge_hw_ring_hash_type - RTH hash types
- * @VXGE_HW_RING_HASH_TYPE_NONE: No Hash
- * @VXGE_HW_RING_HASH_TYPE_TCP_IPV4: TCP IPv4
- * @VXGE_HW_RING_HASH_TYPE_UDP_IPV4: UDP IPv4
- * @VXGE_HW_RING_HASH_TYPE_IPV4: IPv4
- * @VXGE_HW_RING_HASH_TYPE_TCP_IPV6: TCP IPv6
- * @VXGE_HW_RING_HASH_TYPE_UDP_IPV6: UDP IPv6
- * @VXGE_HW_RING_HASH_TYPE_IPV6: IPv6
- * @VXGE_HW_RING_HASH_TYPE_TCP_IPV6_EX: TCP IPv6 extension
- * @VXGE_HW_RING_HASH_TYPE_UDP_IPV6_EX: UDP IPv6 extension
- * @VXGE_HW_RING_HASH_TYPE_IPV6_EX: IPv6 extension
- *
- * RTH hash types
- */
-enum vxge_hw_ring_hash_type {
-        VXGE_HW_RING_HASH_TYPE_NONE                     = 0x0,
-        VXGE_HW_RING_HASH_TYPE_TCP_IPV4         = 0x1,
-        VXGE_HW_RING_HASH_TYPE_UDP_IPV4         = 0x2,
-        VXGE_HW_RING_HASH_TYPE_IPV4                     = 0x3,
-        VXGE_HW_RING_HASH_TYPE_TCP_IPV6         = 0x4,
-        VXGE_HW_RING_HASH_TYPE_UDP_IPV6         = 0x5,
-        VXGE_HW_RING_HASH_TYPE_IPV6                     = 0x6,
-        VXGE_HW_RING_HASH_TYPE_TCP_IPV6_EX      = 0x7,
-        VXGE_HW_RING_HASH_TYPE_UDP_IPV6_EX      = 0x8,
-        VXGE_HW_RING_HASH_TYPE_IPV6_EX          = 0x9
-};
-
 enum vxge_hw_status vxge_hw_ring_rxd_reserve(
         struct __vxge_hw_ring *ring_handle,
         void **rxdh);
@@ -2117,49 +2081,6 @@ struct __vxge_hw_ring_rxd_priv {
 #endif
 };
 
-/* ========================= RING PRIVATE API ============================= */
-u64
-__vxge_hw_ring_first_block_address_get(
-        struct __vxge_hw_ring *ringh);
-
-enum vxge_hw_status
-__vxge_hw_ring_create(
-        struct __vxge_hw_vpath_handle *vpath_handle,
-        struct vxge_hw_ring_attr *attr);
-
-enum vxge_hw_status
-__vxge_hw_ring_abort(
-        struct __vxge_hw_ring *ringh);
-
-enum vxge_hw_status
-__vxge_hw_ring_reset(
-        struct __vxge_hw_ring *ringh);
-
-enum vxge_hw_status
-__vxge_hw_ring_delete(
-        struct __vxge_hw_vpath_handle *vpath_handle);
-
-/* ========================= FIFO PRIVATE API ============================= */
-
-struct vxge_hw_fifo_attr;
-
-enum vxge_hw_status
-__vxge_hw_fifo_create(
-        struct __vxge_hw_vpath_handle *vpath_handle,
-        struct vxge_hw_fifo_attr *attr);
-
-enum vxge_hw_status
-__vxge_hw_fifo_abort(
-        struct __vxge_hw_fifo *fifoh);
-
-enum vxge_hw_status
-__vxge_hw_fifo_reset(
-        struct __vxge_hw_fifo *ringh);
-
-enum vxge_hw_status
-__vxge_hw_fifo_delete(
-        struct __vxge_hw_vpath_handle *vpath_handle);
-
 struct vxge_hw_mempool_cbs {
         void (*item_func_alloc)(
                         struct vxge_hw_mempool *mempoolh,
@@ -2169,10 +2090,6 @@ struct vxge_hw_mempool_cbs {
                         u32                     is_last);
 };
 
-void
-__vxge_hw_mempool_destroy(
-        struct vxge_hw_mempool *mempool);
-
 #define VXGE_HW_VIRTUAL_PATH_HANDLE(vpath)                              \
                 ((struct __vxge_hw_vpath_handle *)(vpath)->vpath_handles.next)
 
@@ -2195,61 +2112,10 @@ __vxge_hw_vpath_rts_table_set(
         u64                     data2);
 
 enum vxge_hw_status
-__vxge_hw_vpath_reset(
-        struct __vxge_hw_device *devh,
-        u32                     vp_id);
-
-enum vxge_hw_status
-__vxge_hw_vpath_sw_reset(
-        struct __vxge_hw_device *devh,
-        u32                     vp_id);
-
-enum vxge_hw_status
 __vxge_hw_vpath_enable(
         struct __vxge_hw_device *devh,
         u32                     vp_id);
 
-void
-__vxge_hw_vpath_prc_configure(
-        struct __vxge_hw_device *devh,
-        u32                     vp_id);
-
-enum vxge_hw_status
-__vxge_hw_vpath_kdfc_configure(
-        struct __vxge_hw_device *devh,
-        u32                     vp_id);
-
-enum vxge_hw_status
-__vxge_hw_vpath_mac_configure(
-        struct __vxge_hw_device *devh,
-        u32                     vp_id);
-
-enum vxge_hw_status
-__vxge_hw_vpath_tim_configure(
-        struct __vxge_hw_device *devh,
-        u32                     vp_id);
-
-enum vxge_hw_status
-__vxge_hw_vpath_initialize(
-        struct __vxge_hw_device *devh,
-        u32                     vp_id);
-
-enum vxge_hw_status
-__vxge_hw_vp_initialize(
-        struct __vxge_hw_device *devh,
-        u32                     vp_id,
-        struct vxge_hw_vp_config        *config);
-
-void
-__vxge_hw_vp_terminate(
-        struct __vxge_hw_device *devh,
-        u32                     vp_id);
-
-enum vxge_hw_status
-__vxge_hw_vpath_alarm_process(
-        struct __vxge_hw_virtualpath    *vpath,
-        u32                     skip_alarms);
-
 void vxge_hw_device_intr_enable(
         struct __vxge_hw_device *devh);
 
@@ -2276,6 +2142,10 @@ void vxge_hw_device_clear_tx_rx(
  *  Virtual Paths
  */
 
+void vxge_hw_vpath_dynamic_rti_rtimer_set(struct __vxge_hw_ring *ring);
+
+void vxge_hw_vpath_dynamic_tti_rtimer_set(struct __vxge_hw_fifo *fifo);
+
 u32 vxge_hw_vpath_id(
         struct __vxge_hw_vpath_handle *vpath_handle);
 
@@ -2288,27 +2158,27 @@ enum vxge_hw_vpath_mac_addr_add_mode {
 enum vxge_hw_status
 vxge_hw_vpath_mac_addr_add(
         struct __vxge_hw_vpath_handle *vpath_handle,
-        u8 (macaddr)[ETH_ALEN],
-        u8 (macaddr_mask)[ETH_ALEN],
+        u8 *macaddr,
+        u8 *macaddr_mask,
         enum vxge_hw_vpath_mac_addr_add_mode duplicate_mode);
 
 enum vxge_hw_status
 vxge_hw_vpath_mac_addr_get(
         struct __vxge_hw_vpath_handle *vpath_handle,
-        u8 (macaddr)[ETH_ALEN],
-        u8 (macaddr_mask)[ETH_ALEN]);
+        u8 *macaddr,
+        u8 *macaddr_mask);
 
 enum vxge_hw_status
 vxge_hw_vpath_mac_addr_get_next(
         struct __vxge_hw_vpath_handle *vpath_handle,
-        u8 (macaddr)[ETH_ALEN],
-        u8 (macaddr_mask)[ETH_ALEN]);
+        u8 *macaddr,
+        u8 *macaddr_mask);
 
 enum vxge_hw_status
 vxge_hw_vpath_mac_addr_delete(
         struct __vxge_hw_vpath_handle *vpath_handle,
-        u8 (macaddr)[ETH_ALEN],
-        u8 (macaddr_mask)[ETH_ALEN]);
+        u8 *macaddr,
+        u8 *macaddr_mask);
 
 enum vxge_hw_status
 vxge_hw_vpath_vid_add(
@@ -2321,11 +2191,6 @@ vxge_hw_vpath_vid_get(
         u64                     *vid);
 
 enum vxge_hw_status
-vxge_hw_vpath_vid_get_next(
-        struct __vxge_hw_vpath_handle *vpath_handle,
-        u64                     *vid);
-
-enum vxge_hw_status
 vxge_hw_vpath_vid_delete(
         struct __vxge_hw_vpath_handle *vpath_handle,
         u64                     vid);
@@ -2384,19 +2249,14 @@ void
 vxge_hw_vpath_msix_mask(struct __vxge_hw_vpath_handle *vpath_handle,
                         int msix_id);
 
-void vxge_hw_device_flush_io(struct __vxge_hw_device *devh);
+void vxge_hw_vpath_msix_clear(struct __vxge_hw_vpath_handle *vp, int msix_id);
 
-void
-vxge_hw_vpath_msix_clear(struct __vxge_hw_vpath_handle *vpath_handle,
-                         int msix_id);
+void vxge_hw_device_flush_io(struct __vxge_hw_device *devh);
 
 void
 vxge_hw_vpath_msix_unmask(struct __vxge_hw_vpath_handle *vpath_handle,
                           int msix_id);
 
-void
-vxge_hw_vpath_msix_mask_all(struct __vxge_hw_vpath_handle *vpath_handle);
-
 enum vxge_hw_status vxge_hw_vpath_intr_enable(
                                 struct __vxge_hw_vpath_handle *vpath_handle);
 
@@ -2415,11 +2275,8 @@ vxge_hw_channel_msix_mask(struct __vxge_hw_channel *channelh, int msix_id);
 void
 vxge_hw_channel_msix_unmask(struct __vxge_hw_channel *channelh, int msix_id);
 
-enum vxge_hw_status
-vxge_hw_channel_dtr_alloc(struct __vxge_hw_channel *channel, void **dtrh);
-
 void
-vxge_hw_channel_dtr_post(struct __vxge_hw_channel *channel, void *dtrh);
+vxge_hw_channel_msix_clear(struct __vxge_hw_channel *channelh, int msix_id);
 
 void
 vxge_hw_channel_dtr_try_complete(struct __vxge_hw_channel *channel,
@@ -2433,21 +2290,9 @@ vxge_hw_channel_dtr_free(struct __vxge_hw_channel *channel, void *dtrh);
 
 int
 vxge_hw_channel_dtr_count(struct __vxge_hw_channel *channel);
-void
-vxge_hw_vpath_tti_ci_set(struct __vxge_hw_device *hldev, u32 vp_id);
 
-/* ========================== PRIVATE API ================================= */
+void vxge_hw_vpath_tti_ci_set(struct __vxge_hw_fifo *fifo);
 
-enum vxge_hw_status
-__vxge_hw_device_handle_link_up_ind(struct __vxge_hw_device *hldev);
-
-enum vxge_hw_status
-__vxge_hw_device_handle_link_down_ind(struct __vxge_hw_device *hldev);
-
-enum vxge_hw_status
-__vxge_hw_device_handle_error(
-                struct __vxge_hw_device *hldev,
-                u32 vp_id,
-                enum vxge_hw_event type);
+void vxge_hw_vpath_dynamic_rti_ci_set(struct __vxge_hw_ring *ring);
 
 #endif
diff --git a/drivers/net/vxge/vxge-version.h b/drivers/net/vxge/vxge-version.h
index 53fefe137368..b9efa28bab3e 100644
--- a/drivers/net/vxge/vxge-version.h
+++ b/drivers/net/vxge/vxge-version.h
@@ -15,8 +15,35 @@
 #define VXGE_VERSION_H
 
 #define VXGE_VERSION_MAJOR      "2"
-#define VXGE_VERSION_MINOR      "0"
-#define VXGE_VERSION_FIX        "9"
-#define VXGE_VERSION_BUILD      "20840"
+#define VXGE_VERSION_MINOR      "5"
+#define VXGE_VERSION_FIX        "3"
+#define VXGE_VERSION_BUILD      "22640"
 #define VXGE_VERSION_FOR        "k"
+
+#define VXGE_FW_VER(maj, min, bld) (((maj) << 16) + ((min) << 8) + (bld))
+
+#define VXGE_DEAD_FW_VER_MAJOR  1
+#define VXGE_DEAD_FW_VER_MINOR  4
+#define VXGE_DEAD_FW_VER_BUILD  4
+
+#define VXGE_FW_DEAD_VER VXGE_FW_VER(VXGE_DEAD_FW_VER_MAJOR, \
+                                     VXGE_DEAD_FW_VER_MINOR, \
+                                     VXGE_DEAD_FW_VER_BUILD)
+
+#define VXGE_EPROM_FW_VER_MAJOR 1
+#define VXGE_EPROM_FW_VER_MINOR 6
+#define VXGE_EPROM_FW_VER_BUILD 1
+
+#define VXGE_EPROM_FW_VER VXGE_FW_VER(VXGE_EPROM_FW_VER_MAJOR, \
+                                      VXGE_EPROM_FW_VER_MINOR, \
+                                      VXGE_EPROM_FW_VER_BUILD)
+
+#define VXGE_CERT_FW_VER_MAJOR  1
+#define VXGE_CERT_FW_VER_MINOR  8
+#define VXGE_CERT_FW_VER_BUILD  1
+
+#define VXGE_CERT_FW_VER VXGE_FW_VER(VXGE_CERT_FW_VER_MAJOR, \
+                                     VXGE_CERT_FW_VER_MINOR, \
+                                     VXGE_CERT_FW_VER_BUILD)
+
 #endif