base/SOURCES/open-iscsi-2.0.874-8-iscsiuio-Add-support-for-the-new-qedi-transport.patch

From 264e48a0bda2d6cd5d0607acd2669894ee95b3b5 Mon Sep 17 00:00:00 2001
From: Nilesh Javali <nilesh.javali@cavium.com>
Date: Fri, 11 Nov 2016 08:17:51 +0200
Subject: iscsiuio: Add support for the new qedi transport

Signed-off-by: Manish Rangankar <manish.rangankar@cavium.com>
Signed-off-by: Adheer Chandravanshi <adheer.chandravanshi@qlogic.com>
Signed-off-by: Nilesh Javali <nilesh.javali@cavium.com>
---
 iscsiuio/src/unix/libs/Makefile.am |    3 +-
 iscsiuio/src/unix/libs/cnic.c      |    9 +
 iscsiuio/src/unix/libs/cnic.h      |    2 +
 iscsiuio/src/unix/libs/qedi.c      | 1151 ++++++++++++++++++++++++++++++++++++
 iscsiuio/src/unix/libs/qedi.h      |  159 +++++
 iscsiuio/src/unix/nic.c            |    6 +-
 iscsiuio/src/unix/nic.h            |    1 +
 iscsiuio/src/unix/nic_utils.c      |  147 ++++-
 iscsiuio/src/unix/nic_utils.h      |    2 +
 iscsiuio/src/unix/options.h        |    1 +
 10 files changed, 1475 insertions(+), 6 deletions(-)
 create mode 100644 iscsiuio/src/unix/libs/qedi.c
 create mode 100644 iscsiuio/src/unix/libs/qedi.h

diff --git a/iscsiuio/src/unix/libs/Makefile.am b/iscsiuio/src/unix/libs/Makefile.am
index 890415f5a79a..737546b04917 100644
--- a/iscsiuio/src/unix/libs/Makefile.am
+++ b/iscsiuio/src/unix/libs/Makefile.am
@@ -10,4 +10,5 @@ noinst_LIBRARIES = lib_iscsiuio_hw_cnic.a
 lib_iscsiuio_hw_cnic_a_SOURCES =	../build_date.c \
 					cnic.c 		\
 					bnx2.c		\
-					bnx2x.c
+					bnx2x.c		\
+					qedi.c
diff --git a/iscsiuio/src/unix/libs/cnic.c b/iscsiuio/src/unix/libs/cnic.c
index 228c4b9e25b1..5d60f898ad57 100644
--- a/iscsiuio/src/unix/libs/cnic.c
+++ b/iscsiuio/src/unix/libs/cnic.c
@@ -55,6 +55,7 @@
 #include <sys/types.h>
 #include <sys/user.h>
 #include <sys/socket.h>
+#include <sys/mman.h>
 
 #include "uip_arp.h"
 #include "nic.h"
@@ -65,6 +66,7 @@
 #include "cnic.h"
 #include "iscsi_if.h"
 #include "ipv6_ndpc.h"
+#include "qedi.h"
 
 /*******************************************************************************
  * Constants
@@ -81,6 +83,13 @@ const char bnx2i_library_transport_name[] = "bnx2i";
 const size_t bnx2i_library_transport_name_size =
 			sizeof(bnx2i_library_transport_name);
 
+/*******************************************************************************
+ * Constants for qedi module
+ ******************************************************************************/
+const char qedi_library_transport_name[] = "qedi";
+const size_t qedi_library_transport_name_size =
+			sizeof(qedi_library_transport_name);
+
 /******************************************************************************
  * Netlink Functions
  ******************************************************************************/
diff --git a/iscsiuio/src/unix/libs/cnic.h b/iscsiuio/src/unix/libs/cnic.h
index 6244a94012c1..c86595c512b0 100644
--- a/iscsiuio/src/unix/libs/cnic.h
+++ b/iscsiuio/src/unix/libs/cnic.h
@@ -44,6 +44,8 @@
  ******************************************************************************/
 extern const char bnx2i_library_transport_name[];
 extern const size_t bnx2i_library_transport_name_size;
+extern const char qedi_library_transport_name[];
+extern const size_t qedi_library_transport_name_size;
 
 int cnic_nl_open();
 void cnic_nl_close();
diff --git a/iscsiuio/src/unix/libs/qedi.c b/iscsiuio/src/unix/libs/qedi.c
new file mode 100644
index 000000000000..c2096e59dad1
--- /dev/null
+++ b/iscsiuio/src/unix/libs/qedi.c
@@ -0,0 +1,1151 @@
+/*
+ * Copyright (c) 2016, Cavium Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Adam Dunkels.
+ * 4. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * qedi.c - qedi user space driver
+ * This file handles different qedi NIC operations,
+ * qedi_open - initializes all hardware resources under NIC device
+ * qedi_close - closes the NIC device
+ * qedi_read - reads data to the hardware
+ * qedi_write - writes data to the hardware
+ * qedi_start_xmit - sends a pkt of data on NIC device
+ * qedi_get_tx_pkt - gets a Tx pkt from NIC
+ * qedi_clear_tx_intr - clears the Tx interrupt
+ * NOTE: nic_t is used as NIC device,
+ * 	 qedi is not attached to netdev hence it is not mandatory
+ * 	 for netdev to be upd
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <arpa/inet.h>
+#include <linux/types.h>
+#include <linux/sockios.h>
+#include <linux/ethtool.h>
+#include <linux/netlink.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/user.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "config.h"
+
+#include "build_date.h"
+#include "bnx2x.h"
+#include "qedi.h"
+#include "cnic.h"
+#include "logger.h"
+#include "nic.h"
+#include "nic_id.h"
+#include "nic_utils.h"
+#include "options.h"
+
+#define PFX	"qedi "
+
+extern int nl_sock;
+
+/*  Foward struct declarations */
+struct nic_ops qedi_op;
+
+/*******************************************************************************
+ * NIC Library Strings
+ ******************************************************************************/
+static const char library_name[] = "qedi";
+static const char library_version[] = PACKAGE_VERSION;
+static const char library_uio_name[] = "qedi_uio";
+
+/*  The name that should be returned from /sys/class/uio/uio0/name */
+static const char cnic_uio_sysfs_name_tempate[] = "/sys/class/uio/uio%i/name";
+static const char qedi_uio_sysfs_name[] = "qedi_uio";
+static const char qedi_host_mac_template[] =
+	"/sys/class/iscsi_host/host%i/hwaddress";
+
+struct qedi_driver_version qedi_version = {
+	QEDI_UNKNOWN_MAJOR_VERSION,
+	QEDI_UNKNOWN_MINOR_VERSION,
+	QEDI_UNKNOWN_SUB_MINOR_VERSION,
+};
+
+static int qedi_clear_tx_intr(nic_t *nic);
+
+/*******************************************************************************
+ * QEDI Library Functions
+ ******************************************************************************/
+/**
+ *  qedi_get_library_name() - Used to get the name of this NIC library
+ *  @param name - This function will return the pointer to this NIC
+ *                library name
+ *  @param name_size
+ */
+static void qedi_get_library_name(char **name, size_t *name_size)
+{
+	*name = (char *)library_name;
+	*name_size = sizeof(library_name);
+}
+
+/**
+ *  qedi_get_library_version() - Used to get the version string of this
+ *                                NIC library
+ *  @param version - This function will return the pointer to this NIC
+ *                   library version string
+ *  @param version_size - This will be set with the version size
+ */
+static void qedi_get_library_version(char **version, size_t *version_size)
+{
+	*version = (char *)library_version;
+	*version_size = sizeof(library_version);
+}
+
+/**
+ *  qedi_get_build_date() - Used to get the build date string of this library
+ *  @param version - This function will return the pointer to this NIC
+ *                   library build date string
+ *  @param version_size - This will be set with the build date string size
+ */
+static void qedi_get_build_date(char **build, size_t *build_size)
+{
+	*build = (char *)build_date;
+	*build_size = sizeof(build_date);
+}
+
+/**
+ *  qedi_get_transport_name() - Used to get the transport name associated
+ *                              with this this NIC library
+ *  @param transport_name - This function will return the pointer to this NIC
+ *                          library's associated transport string
+ *  @param transport_name_size - This will be set with the transport name size
+ */
+static void qedi_get_transport_name(char **transport_name,
+				    size_t *transport_name_size)
+{
+	*transport_name = (char *)qedi_library_transport_name;
+	*transport_name_size = qedi_library_transport_name_size;
+}
+
+/**
+ *  qedi_get_uio_name() - Used to get the uio name associated with this this
+ *                        NIC library
+ *  @param uio_name - This function will return the pointer to this NIC
+ *                    library's associated uio string
+ *  @param transport_name_size - This will be set with the uio name size
+ */
+static void qedi_get_uio_name(char **uio_name, size_t *uio_name_size)
+{
+	*uio_name = (char *)library_uio_name;
+	*uio_name_size = sizeof(library_uio_name);
+}
+
+/**
+ *  qedi_get_ops() - Used to get the NIC library op table
+ *  @param op - The op table of this NIC library
+ */
+struct nic_ops *qedi_get_ops()
+{
+	return &qedi_op;
+}
+
+/*******************************************************************************
+ * qedi Utility Functions
+ ******************************************************************************/
+/*******************************************************************************
+ * Utility Functions Used to read register from the qedi device
+ ******************************************************************************/
+static void qedi_set_drv_version_unknown(qedi_t *bp)
+{
+	bp->version.major = QEDI_UNKNOWN_MAJOR_VERSION;
+	bp->version.minor = QEDI_UNKNOWN_MINOR_VERSION;
+	bp->version.sub_minor = QEDI_UNKNOWN_SUB_MINOR_VERSION;
+}
+
+/* Return: 1 = Unknown, 0 = Known */
+static int qedi_is_drv_version_unknown(struct qedi_driver_version *version)
+{
+	if ((version->major == (uint16_t)QEDI_UNKNOWN_MAJOR_VERSION) &&
+	    (version->minor == (uint16_t)QEDI_UNKNOWN_MINOR_VERSION) &&
+	    (version->sub_minor == (uint16_t)QEDI_UNKNOWN_SUB_MINOR_VERSION)) {
+		return 1;
+	}
+
+	return 0;
+}
+
+/**
+ * qedi_get_drv_version() - Used to determine the driver version
+ * @param bp - Device used to determine qedi driver version
+ */
+static int qedi_get_drv_version(qedi_t *bp)
+{
+	nic_t *nic = bp->parent;
+
+	/*
+	 * CAPABILITIES: Get the iscsi driver version from qedi
+	 * This may be obtained from sysfs
+	 */
+	LOG_INFO(PFX "%s: qedi driver using version %d.%d.%d",
+		 nic->log_name,
+		 bp->version.major, bp->version.minor, bp->version.sub_minor);
+
+	return 0;
+}
+
+/******************************************************************************/
+
+/**
+ * qedi_get_chip_id() - Used to retrieve the chip ID from the nic
+ * @param dev - Device used to determin NIC type
+ * @return Chip ID read from the MISC ID register
+ */
+static int qedi_get_chip_id(qedi_t *bp)
+{
+	/* int val, id; */
+
+	/* Get the chip revision id and number. */
+	/* chip num:16-31, rev:12-15, metal:4-11, bond_id:0-3 */
+	/*
+	 * CAPABILITIES: Get the CHIP info from qedi through sysfs or uio struct.
+	 */
+	return 0;
+}
+
+/**
+ *  qedi_uio_verify()
+ *
+ */
+static int qedi_uio_verify(nic_t *nic)
+{
+	char *raw = NULL, *raw_tmp;
+	uint32_t raw_size = 0;
+	char temp_path[sizeof(cnic_uio_sysfs_name_tempate) + 8];
+	int rc = 0;
+
+	/*  Build the path to determine uio name */
+	snprintf(temp_path, sizeof(temp_path),
+		 cnic_uio_sysfs_name_tempate, nic->uio_minor);
+
+	rc = capture_file(&raw, &raw_size, temp_path);
+	if (rc != 0)
+		goto error;
+
+	/* sanitize name string by replacing newline with null termination */
+	raw_tmp = raw;
+	while (*raw_tmp != '\n')
+		raw_tmp++;
+	*raw_tmp = '\0';
+
+	if (strncmp(raw, qedi_uio_sysfs_name,
+		    sizeof(qedi_uio_sysfs_name)) != 0) {
+		LOG_ERR(PFX "%s: uio names not equal: expecting %s got %s from %s",
+			nic->log_name, qedi_uio_sysfs_name, raw, temp_path);
+		rc = -EIO;
+	}
+
+	free(raw);
+
+	LOG_INFO(PFX "%s: Verified is a qedi_uio device", nic->log_name);
+
+error:
+	return rc;
+}
+
+static int qedi_get_mac_addr(qedi_t *bp)
+{
+	nic_t *nic = bp->parent;
+	char *raw = NULL, *raw_tmp;
+	uint32_t raw_size = 0;
+	char temp_path[sizeof(qedi_host_mac_template) + 8];
+	int rc = 0;
+
+	/*  Build the path to determine mac address */
+	snprintf(temp_path, sizeof(temp_path),
+		 qedi_host_mac_template, nic->host_no);
+
+	rc = capture_file(&raw, &raw_size, temp_path);
+	if (rc != 0)
+		goto error;
+
+	/* sanitize name string by replacing newline with null termination */
+	raw_tmp = raw;
+	while (*raw_tmp != '\n')
+		raw_tmp++;
+	*raw_tmp = '\0';
+
+	rc = sscanf(raw, "%02x:%02x:%02x:%02x:%02x:%02x",
+	       (uint32_t *)&nic->mac_addr[0], (uint32_t *)&nic->mac_addr[1],
+	       (uint32_t *)&nic->mac_addr[2], (uint32_t *)&nic->mac_addr[3],
+	       (uint32_t *)&nic->mac_addr[4], (uint32_t *)&nic->mac_addr[5]);
+	if (rc != 1) {
+		LOG_WARN(PFX "%s: Could not parse mac_addr",
+			nic->log_name);
+		rc = -ENODEV;
+		goto error;
+	}
+
+error:
+	if (raw)
+		free(raw);
+	return rc;
+}
+
+/*******************************************************************************
+ * qedi Utility Functions to get to the hardware consumer indexes
+ ******************************************************************************/
+
+static __u32 qedi_get_rx(qedi_t *bp)
+{
+	return ((struct qedi_uio_ctrl *)bp->uctrl_map)->host_rx_cons;
+}
+
+static __u32 qedi_get_tx(qedi_t *bp)
+{
+	return ((struct qedi_uio_ctrl *)bp->uctrl_map)->hw_tx_cons;
+}
+
+/**
+ *  qedi_free() - Used to free a qedi structure
+ */
+static void qedi_free(nic_t *nic)
+{
+	if (nic->priv)
+		free(nic->priv);
+	nic->priv = NULL;
+}
+
+/**
+ *  qedi_alloc() - Used to allocate a qedi structure
+ */
+static qedi_t *qedi_alloc(nic_t *nic)
+{
+	qedi_t *bp = malloc(sizeof(*bp));
+
+	if (!bp) {
+		LOG_ERR(PFX "%s: Could not allocate QEDI space",
+			nic->log_name);
+		return NULL;
+	}
+
+	/*  Clear out the CNIC contents */
+	memset(bp, 0, sizeof(*bp));
+
+	bp->parent = nic;
+	nic->priv = (void *)bp;
+	get_iscsi_transport_handle(nic, &nic->transport_handle);
+	qedi_set_drv_version_unknown(bp);
+
+	return bp;
+}
+
+int uio_get_map_offset(nic_t *nic, uint8_t map, uint32_t *offset)
+{
+	char *raw = NULL;
+	uint32_t raw_size = 0;
+	ssize_t elements_read;
+	char temp_path[sizeof(UIO_OFFSET_TMPL) + 8];
+	int rc = 0;
+
+	/*  Capture RX buffer size */
+	snprintf(temp_path, sizeof(temp_path),
+		 UIO_OFFSET_TMPL, nic->uio_minor, map);
+
+	rc = capture_file(&raw, &raw_size, temp_path);
+	if (rc != 0)
+		goto error;
+
+	elements_read = sscanf(raw, "0x%x", offset);
+	if (elements_read != 1) {
+		LOG_ERR(PFX "%s: Couldn't get the offset from %s",
+			nic->log_name, temp_path);
+		rc = -EIO;
+		goto error;
+	}
+
+	rc = 0;
+error:
+	if (raw)
+		free(raw);
+
+	return rc;
+}
+
+int uio_get_map_info(nic_t *nic, uint8_t map, char *attr, uint32_t *val)
+{
+	char *raw = NULL;
+	uint32_t raw_size = 0;
+	ssize_t elements_read;
+	char temp_path[sizeof(UIO_ATTR_TMPL) + 8];
+	int rc = 0;
+
+	/*  Capture RX buffer size */
+	snprintf(temp_path, sizeof(temp_path),
+		 UIO_ATTR_TMPL, nic->uio_minor, map, attr);
+
+	rc = capture_file(&raw, &raw_size, temp_path);
+	if (rc != 0)
+		goto error;
+
+	elements_read = sscanf(raw, "0x%x", val);
+	if (elements_read != 1) {
+		LOG_ERR(PFX "%s: Couldn't get the offset from %s",
+			nic->log_name, temp_path);
+		rc = -EIO;
+		goto error;
+	}
+
+	rc = 0;
+error:
+	if (raw)
+		free(raw);
+
+	return rc;
+}
+
+/**
+ * qedi_open() - This will initialize all the hardware resources underneath
+ *               a struct cnic_uio device
+ * @param dev - The struct cnic_uio device to attach the hardware with
+ * @return 0 on success, on failure a errno will be returned
+ */
+static int qedi_open(nic_t *nic)
+{
+	qedi_t *bp = NULL;
+	struct stat uio_stat;
+	int i, rc;
+	int count;
+	uint32_t bus;
+	uint32_t slot;
+	uint32_t func;
+	uint32_t offset;
+
+	/*  Sanity Check: validate the parameters */
+	if (!nic) {
+		LOG_ERR(PFX "nic == NULL");
+		return -EINVAL;
+	}
+
+	if ((nic->priv) != NULL &&
+	    (((qedi_t *)(nic->priv))->flags & QEDI_OPENED)) {
+		return 0;
+	}
+
+	if (nic->host_no == INVALID_HOST_NO) {
+		rc = sscanf(nic->config_device_name, "host%d", &nic->host_no);
+		if (rc != 1) {
+			LOG_WARN(PFX "%s: Could not parse for host number",
+				 nic->config_device_name);
+			rc = -ENODEV;
+			goto open_error;
+		}
+	}
+
+	bp = qedi_alloc(nic);
+	if (!bp)
+		return -ENOMEM;
+
+	if (qedi_is_drv_version_unknown(&qedi_version)) {
+		/* If version is unknown, go read from ethtool */
+		rc = qedi_get_drv_version(bp);
+		if (rc)
+			goto open_error;
+	} else {
+		/* Version is not unknown, just use it */
+		qedi_version.major = bp->version.major;
+		qedi_version.minor = bp->version.minor;
+		qedi_version.sub_minor = bp->version.sub_minor;
+	}
+
+	count = 0;
+	while ((nic->fd < 0) && count < 15) {
+		/*  udev might not have created the file yet */
+		pthread_mutex_unlock(&nic->nic_mutex);
+		sleep(1);
+		pthread_mutex_lock(&nic->nic_mutex);
+
+		nic->fd = open(nic->uio_device_name, O_RDWR | O_NONBLOCK);
+		if (nic->fd != INVALID_FD) {
+			LOG_ERR(PFX "%s: uio device has been brought up via pid: %d on fd: %d",
+				nic->uio_device_name, getpid(), nic->fd);
+
+			rc = qedi_uio_verify(nic);
+			if (rc != 0)
+				continue;
+
+			break;
+		} else {
+			LOG_WARN(PFX "%s: Could not open device: %s, [%s]",
+				 nic->log_name, nic->uio_device_name,
+				 strerror(errno));
+
+			manually_trigger_uio_event(nic, nic->uio_minor);
+
+			/*  udev might not have created the file yet */
+			pthread_mutex_unlock(&nic->nic_mutex);
+			sleep(1);
+			pthread_mutex_lock(&nic->nic_mutex);
+
+			count++;
+		}
+	}
+	if (fstat(nic->fd, &uio_stat) < 0) {
+		LOG_ERR(PFX "%s: Could not fstat device", nic->log_name);
+		rc = -ENODEV;
+		goto open_error;
+	}
+	nic->uio_minor = minor(uio_stat.st_rdev);
+
+	/*
+	 * CAPABILITIES: acquire the rx buffer size and rx ring size from qedi
+	 */
+
+	bp->rx_ring_size = RX_RING_SIZE;
+	bp->rx_buffer_size = PKT_BUF_SIZE;
+
+	LOG_DEBUG(PFX "%s: using rx ring size: %d, rx buffer size: %d",
+		  nic->log_name, bp->rx_ring_size, bp->rx_buffer_size);
+
+	/* Determine the number of UIO events that have already occurred */
+	rc = detemine_initial_uio_events(nic, &nic->intr_count);
+	if (rc != 0) {
+		LOG_ERR(PFX "Could not get the no. of initial UIO events");
+		nic->intr_count = 0;
+	}
+
+	/* Allocate space for rx pkt ring */
+	bp->rx_pkt_ring = malloc(sizeof(void *) * bp->rx_ring_size);
+	if (!bp->rx_pkt_ring) {
+		LOG_ERR(PFX "%s: Could not allocate space for rx_pkt_ring",
+			nic->log_name);
+		rc = errno;
+		goto open_error;
+	}
+
+	/*
+	 * Map the uio struct and packet buffer
+	 */
+	offset = 0;
+	rc = uio_get_map_info(nic, QEDI_UCTRL_MAP_REG, "size", &offset);
+	if (rc) {
+		LOG_INFO(PFX "Failed to get the map size rc=%d", rc);
+		goto open_error;
+	}
+	LOG_INFO(PFX "uctrl map size=%u", offset);
+
+	offset = 0;
+	rc = uio_get_map_info(nic, QEDI_RING_MAP_REG, "size", &offset);
+	if (rc) {
+		LOG_INFO(PFX "Failed to get the map size rc=%d", rc);
+		goto open_error;
+	}
+	LOG_INFO(PFX "ring map size=%u", offset);
+
+	offset = 0;
+	rc = uio_get_map_info(nic, QEDI_BUF_MAP_REG, "size", &offset);
+	if (rc) {
+		LOG_INFO(PFX "Failed to get the map size rc=%d", rc);
+		goto open_error;
+	}
+	LOG_INFO(PFX "buf map size=%u", offset);
+
+	offset = 0;
+	rc = uio_get_map_offset(nic, QEDI_UCTRL_MAP_REG, &offset);
+	if (rc) {
+		LOG_INFO(PFX "Failed to get the map offset rc=%d", rc);
+		goto open_error;
+	}
+
+	bp->uctrl_map = mmap(NULL, sizeof(struct qedi_uio_ctrl),
+			    PROT_READ | PROT_WRITE,
+			    MAP_SHARED | MAP_LOCKED,
+			    nic->fd, (off_t)0);
+	if (bp->uctrl_map == MAP_FAILED) {
+		LOG_INFO(PFX "%s: Could not mmap uio ctrl struct: %s",
+			 nic->log_name, strerror(errno));
+		bp->uctrl_map = NULL;
+		rc = errno;
+		goto open_error;
+	}
+
+	bp->uctrl_map_offset = offset;
+	bp->uctrl_map += offset;
+
+	bp->rx_comp_ring = mmap(NULL, nic->page_size,
+			   PROT_READ | PROT_WRITE, MAP_SHARED | MAP_LOCKED,
+			   nic->fd, (off_t)nic->page_size);
+	if (bp->rx_comp_ring == MAP_FAILED) {
+		LOG_INFO(PFX "%s: Could not mmap rx_comp_ring: %s",
+			 nic->log_name, strerror(errno));
+		bp->rx_comp_ring = NULL;
+		rc = errno;
+		goto open_error;
+	}
+
+	bp->bufs = mmap(NULL, (bp->rx_ring_size + 1) * bp->rx_buffer_size,
+			PROT_READ | PROT_WRITE, MAP_SHARED | MAP_LOCKED,
+			nic->fd, (off_t)2 * nic->page_size);
+	if (bp->bufs == MAP_FAILED) {
+		LOG_INFO(PFX "%s: Could not mmap pkt buffers: %s",
+			 nic->log_name, strerror(errno));
+		bp->bufs = NULL;
+		rc = errno;
+		goto open_error;
+	}
+
+	/*
+	 * Get all CHIP related info from qedi
+	 */
+	bp->chip_id = qedi_get_chip_id(bp);
+	LOG_DEBUG(PFX "Chip ID: %x", bp->chip_id);
+
+	rc = get_bus_slot_func_num(nic, &bus, &slot, &func);
+	if (rc != 0) {
+		LOG_INFO(PFX "%s: Couldn't determine bus:slot.func",
+			 nic->log_name);
+		goto open_error;
+	}
+
+	/*
+	 * Get all function, pfid, client_id and cid info from qedi
+	 */
+	LOG_INFO(PFX "%s: func 0x%x, pfid 0x%x, client_id 0x%x, cid 0x%x",
+		 nic->log_name, bp->func, bp->pfid, bp->client_id, bp->cid);
+
+	bp->get_rx_cons = qedi_get_rx;
+	bp->get_tx_cons = qedi_get_tx;
+	bp->tx_cons = 0;
+	bp->tx_prod = 0;
+	bp->tx_bd_prod = 0;
+	bp->tx_pkt = bp->bufs;
+	bp->rx_pkts = bp->bufs + bp->rx_buffer_size;
+
+	bp->rx_index = 0;
+	bp->rx_cons = 0;
+	bp->rx_bd_cons = 0;
+	bp->rx_prod = 127;
+	bp->rx_bd_prod = bp->rx_ring_size;
+
+	for (i = 0; i < bp->rx_ring_size; i++) {
+		void *ptr = bp->bufs + (bp->rx_buffer_size * (i + 1));
+
+		bp->rx_pkt_ring[i] = ptr;
+	}
+
+	qedi_get_mac_addr(bp);
+	LOG_INFO(PFX "%s:  Using mac address: %02x:%02x:%02x:%02x:%02x:%02x",
+		 nic->log_name,
+		 nic->mac_addr[0], nic->mac_addr[1], nic->mac_addr[2],
+		 nic->mac_addr[3], nic->mac_addr[4], nic->mac_addr[5]);
+
+	qedi_get_library_name(&nic->library_name, (size_t *)&count);
+	LOG_INFO("%s: qedi initialized", nic->log_name);
+
+	bp->flags |= QEDI_OPENED;
+
+	return 0;
+
+open_error:
+
+	if (bp->bufs) {
+		munmap(bp->bufs, (bp->rx_ring_size + 1) * bp->rx_buffer_size);
+		bp->bufs = NULL;
+	}
+
+	if (bp->rx_comp_ring) {
+		munmap(bp->rx_comp_ring, nic->page_size);
+		bp->rx_comp_ring = NULL;
+	}
+
+	if (bp->uctrl_map) {
+		bp->uctrl_map -= bp->uctrl_map_offset;
+		munmap(bp->uctrl_map, sizeof(struct qedi_uio_ctrl));
+		bp->uctrl_map = NULL;
+	}
+
+	if (bp->rx_pkt_ring) {
+		free(bp->rx_pkt_ring);
+		bp->rx_pkt_ring = NULL;
+	}
+
+	if (nic->fd != INVALID_FD) {
+		close(nic->fd);
+		nic->fd = INVALID_FD;
+	}
+
+	qedi_free(nic);
+
+	return rc;
+}
+
+/**
+ *  qedi_uio_close_resources() - Used to free resource for the NIC/CNIC
+ *  @param nic - NIC device to free resource
+ *  @param graceful - whether to wait to close gracefully
+ *  @return 0 on success, <0 on failure
+ */
+static int qedi_uio_close_resources(nic_t *nic, NIC_SHUTDOWN_T graceful)
+{
+	qedi_t *bp = (qedi_t *)nic->priv;
+	int rc = 0;
+
+	/*  Check if there is an assoicated qedi device */
+	if (!bp) {
+		LOG_WARN(PFX "%s: when closing resources there is no assoicated qedi",
+			 nic->log_name);
+		return -EIO;
+	}
+
+	/*  Clean up allocated memory */
+
+	if (bp->rx_pkt_ring) {
+		free(bp->rx_pkt_ring);
+		bp->rx_pkt_ring = NULL;
+	}
+
+	/*  Clean up mapped registers */
+	if (bp->bufs) {
+		rc = munmap(bp->bufs,
+			    (bp->rx_ring_size + 1) * bp->rx_buffer_size);
+		if (rc != 0)
+			LOG_ERR(PFX "%s: Couldn't unmap bufs", nic->log_name);
+		bp->bufs = NULL;
+	}
+
+	if (bp->rx_comp_ring) {
+		rc = munmap(bp->rx_comp_ring, nic->page_size);
+		if (rc != 0)
+			LOG_ERR(PFX "%s: Couldn't unmap ring", nic->log_name);
+		bp->rx_comp_ring = NULL;
+	}
+
+	if (bp->uctrl_map) {
+		bp->uctrl_map -= bp->uctrl_map_offset;
+		rc = munmap(bp->uctrl_map, sizeof(struct qedi_uio_ctrl));
+		if (rc != 0) {
+			LOG_ERR(PFX "%s: Couldn't unmap uio ctrl",
+				nic->log_name);
+		}
+		bp->uctrl_map = NULL;
+	}
+
+	if (nic->fd != INVALID_FD) {
+		rc = close(nic->fd);
+		if (rc != 0) {
+			LOG_ERR(PFX
+				 "%s: Couldn't close uio file descriptor: %d",
+				 nic->log_name, nic->fd);
+		} else {
+			LOG_DEBUG(PFX "%s: Closed uio file descriptor: %d",
+				  nic->log_name, nic->fd);
+		}
+
+		nic->fd = INVALID_FD;
+	} else {
+		LOG_ERR(PFX "%s: Invalid uio file descriptor: %d",
+			nic->log_name, nic->fd);
+	}
+
+	qedi_set_drv_version_unknown(bp);
+
+	LOG_INFO(PFX "%s: Closed all resources", nic->log_name);
+
+	return 0;
+}
+
+/**
+ *  qedi_close() - Used to close the NIC device
+ *  @param nic - NIC device to close
+ *  @param graceful - whether to wait to close gracefully
+ *  @return 0 if successful, <0 if there is an error
+ */
+static int qedi_close(nic_t *nic, NIC_SHUTDOWN_T graceful)
+{
+	/*  Sanity Check: validate the parameters */
+	if (!nic) {
+		LOG_ERR(PFX "%s: nic == NULL", __func__);
+		return -EINVAL;
+	}
+	if (!nic->priv) {
+		LOG_ERR(PFX "%s: nic->priv == NULL", __func__);
+		return -EINVAL;
+	}
+
+	LOG_INFO(PFX "Closing NIC device: %s", nic->log_name);
+
+	qedi_uio_close_resources(nic, graceful);
+	qedi_free(nic);
+
+	return 0;
+}
+
+static void qedi_prepare_xmit_packet(nic_t *nic,
+				     nic_interface_t *nic_iface,
+				     struct packet *pkt)
+{
+	qedi_t *bp = (qedi_t *)nic->priv;
+	struct uip_vlan_eth_hdr *eth_vlan = (struct uip_vlan_eth_hdr *)pkt->buf;
+	struct uip_eth_hdr *eth = (struct uip_eth_hdr *)bp->tx_pkt;
+
+	if (eth_vlan->tpid == htons(UIP_ETHTYPE_8021Q)) {
+		memcpy(bp->tx_pkt, pkt->buf, sizeof(struct uip_eth_hdr));
+		eth->type = eth_vlan->type;
+		pkt->buf_size -= (sizeof(struct uip_vlan_eth_hdr) -
+				  sizeof(struct uip_eth_hdr));
+		memcpy(bp->tx_pkt + sizeof(struct uip_eth_hdr),
+		       pkt->buf + sizeof(struct uip_vlan_eth_hdr),
+		       pkt->buf_size - sizeof(struct uip_eth_hdr));
+	} else {
+		memcpy(bp->tx_pkt, pkt->buf, pkt->buf_size);
+	}
+
+	msync(bp->tx_pkt, pkt->buf_size, MS_SYNC);
+}
+
+/**
+ *  qedi_get_tx_pkt() - This function is used to a TX packet from the NIC
+ *  @param nic - The NIC device to send the packet
+ */
+void *qedi_get_tx_pkt(nic_t *nic)
+{
+	qedi_t *bp = (qedi_t *)nic->priv;
+
+	return bp->tx_pkt;
+}
+
+/**
+ *  qedi_start_xmit() - This function is used to send a packet of data
+ *  @param nic - The NIC device to send the packet
+ *  @param len - the length of the TX packet
+ *
+ */
+void qedi_start_xmit(nic_t *nic, size_t len, u16_t vlan_id)
+{
+	qedi_t *bp = (qedi_t *)nic->priv;
+	uint8_t *ubuf;
+	struct iscsi_uevent *ev;
+	struct iscsi_path *path_data;
+	struct qedi_uio_ctrl *uctrl;
+	int rc = 0;
+	uint16_t buflen;
+
+	uctrl = (struct qedi_uio_ctrl *)bp->uctrl_map;
+
+	buflen = sizeof(struct iscsi_uevent) + sizeof(struct iscsi_path);
+	ubuf = calloc(1, NLMSG_SPACE(buflen));
+	if (!ubuf) {
+		LOG_ERR(PFX "%s: alloc failed for uevent buf", __func__);
+		return;
+	}
+
+	memset(ubuf, 0, NLMSG_SPACE(buflen));
+
+	/*  prepare the iscsi_uevent buffer */
+	ev = (struct iscsi_uevent *)ubuf;
+	ev->type = ISCSI_UEVENT_PATH_UPDATE;
+	ev->transport_handle = nic->transport_handle;
+	ev->u.set_path.host_no = nic->host_no;
+
+	/*  Prepare the iscsi_path buffer */
+	path_data = (struct iscsi_path *)(ubuf + sizeof(struct iscsi_uevent));
+	path_data->handle = QEDI_PATH_HANDLE;
+	path_data->vlan_id = vlan_id;
+	uctrl->host_tx_pkt_len = len;
+
+	rc = __kipc_call(nl_sock, ev, buflen);
+	if (rc > 0) {
+		bp->tx_prod++;
+		uctrl->host_tx_prod++;
+		msync(uctrl, sizeof(struct qedi_uio_ctrl), MS_SYNC);
+		LOG_PACKET(PFX "%s: sent %d bytes using bp->tx_prod: %d",
+			   nic->log_name, len, bp->tx_prod);
+	} else {
+		LOG_ERR(PFX "Pkt transmission failed: %d", rc);
+		pthread_mutex_unlock(&nic->xmit_mutex);
+	}
+
+	free(ubuf);
+}
+
+/**
+ *  qedi_write() - Used to write the data to the hardware
+ *  @param nic - NIC hardware to read from
+ *  @param pkt - The packet which will hold the data to be sent on the wire
+ *  @return 0 if successful, <0 if failed
+ */
+int qedi_write(nic_t *nic, nic_interface_t *nic_iface, packet_t *pkt)
+{
+	qedi_t *bp;
+	struct uip_stack *uip;
+	int i = 0;
+
+	/* Sanity Check: validate the parameters */
+	if (!nic || !nic_iface || !pkt) {
+		LOG_ERR(PFX "%s: qedi_write() nic == 0x%p || nic_iface == 0x%p || pkt == 0x%x",
+			nic, nic_iface, pkt);
+		return -EINVAL;
+	}
+	bp = (qedi_t *)nic->priv;
+	uip = &nic_iface->ustack;
+
+	if (pkt->buf_size == 0) {
+		LOG_ERR(PFX "%s: Trying to transmitted 0 sized packet",
+			nic->log_name);
+		return -EINVAL;
+	}
+
+	/*  Try to wait for a TX completion */
+	for (i = 0; i < 15; i++) {
+		struct timespec sleep_req = {.tv_sec = 0, .tv_nsec = 5000000 },
+		    sleep_rem;
+
+		if (qedi_clear_tx_intr(nic) == 0)
+			break;
+
+		nanosleep(&sleep_req, &sleep_rem);
+	}
+
+	if (pthread_mutex_trylock(&nic->xmit_mutex) != 0) {
+		LOG_PACKET(PFX "%s: Dropped previous transmitted packet",
+			   nic->log_name);
+		return -EINVAL;
+	}
+
+	qedi_prepare_xmit_packet(nic, nic_iface, pkt);
+	qedi_start_xmit(nic, pkt->buf_size,
+			(nic_iface->vlan_priority << 12) |
+			nic_iface->vlan_id);
+
+	/* bump up the tx stats */
+	nic->stats.tx.packets++;
+	nic->stats.tx.bytes += uip->uip_len;
+
+	LOG_PACKET(PFX "%s: transmitted %d bytes dev->tx_cons: %d, dev->tx_prod: %d, dev->tx_bd_prod:%d",
+		   nic->log_name, pkt->buf_size,
+		   bp->tx_cons, bp->tx_prod, bp->tx_bd_prod);
+
+	return 0;
+}
+
+/**
+ *  qedi_read() - Used to read the data from the hardware
+ *  @param nic - NIC hardware to read from
+ *  @param pkt - The packet which will hold the data
+ *  @return 0 if successful, < 0 if failed
+ */
+static int qedi_read(nic_t *nic, packet_t *pkt)
+{
+	qedi_t *bp;
+	void *rx_pkt;
+	int rc = 0;
+	uint32_t sw_cons, bd_cons;
+	uint32_t hw_prod;
+	uint32_t rx_pkt_idx;
+	int len;
+	struct qedi_rx_bd *rx_bd;
+	struct qedi_uio_ctrl *uctrl;
+	uint16_t vlan_id;
+
+	/* Sanity Check: validate the parameters */
+	if (!nic || !pkt) {
+		LOG_ERR(PFX "%s: qedi_read() nic == 0x%p || pkt == 0x%x",
+			nic, pkt);
+		return -EINVAL;
+	}
+
+	bp = (qedi_t *)nic->priv;
+	msync(bp->uctrl_map, sizeof(struct qedi_uio_ctrl), MS_SYNC);
+	msync(bp->rx_comp_ring, nic->page_size, MS_SYNC);
+	uctrl = (struct qedi_uio_ctrl *)bp->uctrl_map;
+	hw_prod = uctrl->hw_rx_prod;
+	sw_cons = uctrl->host_rx_cons;
+	bd_cons = uctrl->host_rx_bd_cons;
+	rx_bd = bp->rx_comp_ring + (bd_cons * sizeof(*rx_bd));
+	len = rx_bd->rx_pkt_len;
+	rx_pkt_idx = rx_bd->rx_pkt_index;
+	vlan_id = rx_bd->vlan_id;
+
+	if (sw_cons != hw_prod) {
+		LOG_DEBUG(PFX "%s: clearing rx interrupt: %d %d",
+			  nic->log_name, sw_cons, hw_prod);
+		rc = 1;
+		rx_pkt = bp->rx_pkts + (bp->rx_buffer_size * rx_pkt_idx);
+
+		if (len > 0) {
+			msync(rx_pkt, len, MS_SYNC);
+			/*  Copy the data */
+			memcpy(pkt->buf, rx_pkt, len);
+			pkt->buf_size = len;
+			if (vlan_id) {
+				pkt->vlan_tag = vlan_id;
+				pkt->flags |= VLAN_TAGGED;
+			} else {
+				pkt->vlan_tag = 0;
+			}
+
+			LOG_DEBUG(PFX "%s: processing packet length: %d",
+				  nic->log_name, len);
+
+			/* bump up the recv stats */
+			nic->stats.rx.packets++;
+			nic->stats.rx.bytes += pkt->buf_size;
+		} else {
+			rc = 0;
+		}
+
+		sw_cons = (sw_cons + 1) % RX_RING_SIZE;
+		bd_cons = (bd_cons + 1) % QEDI_NUM_RX_BD;
+		uctrl->host_rx_cons_cnt++;
+	}
+
+	uctrl->host_rx_bd_cons = bd_cons;
+	uctrl->host_rx_cons = sw_cons;
+
+	msync(uctrl, sizeof(struct qedi_uio_ctrl), MS_SYNC);
+	msync(bp->rx_comp_ring, nic->page_size, MS_SYNC);
+	return rc;
+}
+
+/*******************************************************************************
+ * Clearing TX interrupts
+ ******************************************************************************/
+/**
+ *  qedi_clear_tx_intr() - This routine is called when a TX interrupt occurs
+ *  @param nic - the nic the interrupt occurred on
+ *  @return  0 on success
+ */
+
+static int qedi_clear_tx_intr(nic_t *nic)
+{
+	qedi_t *bp;
+	uint32_t hw_cons;
+	struct qedi_uio_ctrl *uctrl;
+
+	/* Sanity check: ensure the parameters passed in are valid */
+	if (unlikely(!nic)) {
+		LOG_ERR(PFX "%s: nic == NULL", __func__);
+		return -EINVAL;
+	}
+
+	bp = (qedi_t *)nic->priv;
+	uctrl = (struct qedi_uio_ctrl *)bp->uctrl_map;
+	msync(bp->uctrl_map, sizeof(struct qedi_uio_ctrl), MS_SYNC);
+	hw_cons = uctrl->hw_tx_cons;
+
+	if (bp->tx_cons == hw_cons) {
+		if (bp->tx_cons == bp->tx_prod) {
+			/* Make sure the xmit_mutex lock is unlock */
+			if (pthread_mutex_trylock(&nic->xmit_mutex))
+				LOG_ERR(PFX "qedi tx lock with prod == cons");
+
+			pthread_mutex_unlock(&nic->xmit_mutex);
+			return 0;
+		}
+		return -EAGAIN;
+	}
+
+	LOG_PACKET(PFX "%s: clearing tx interrupt [%d %d]",
+		   nic->log_name, bp->tx_cons, hw_cons);
+	bp->tx_cons = hw_cons;
+
+	/* There is a queued TX packet that needs to be sent out.  The usual
+	 * case is when stack will send an ARP packet out before sending the
+	 * intended packet
+	 */
+	if (nic->tx_packet_queue) {
+		packet_t *pkt;
+		int i;
+
+		LOG_PACKET(PFX "%s: sending queued tx packet", nic->log_name);
+		pkt = nic_dequeue_tx_packet(nic);
+
+		/* Got a TX packet buffer of the TX queue and put it onto
+		 * the hardware
+		 */
+		if (pkt) {
+			qedi_prepare_xmit_packet(nic, pkt->nic_iface, pkt);
+
+			qedi_start_xmit(nic, pkt->buf_size,
+					(pkt->nic_iface->vlan_priority << 12) |
+					pkt->nic_iface->vlan_id);
+
+			LOG_PACKET(PFX "%s: transmitted queued packet %d bytes, dev->tx_cons: %d, dev->tx_prod: %d, dev->tx_bd_prod:%d",
+				   nic->log_name, pkt->buf_size,
+				   bp->tx_cons, bp->tx_prod, bp->tx_bd_prod);
+
+			return 0;
+		}
+
+		/* Try to wait for a TX completion */
+		for (i = 0; i < 15; i++) {
+			struct timespec sleep_req = {.tv_sec = 0,
+				.tv_nsec = 5000000
+			}, sleep_rem;
+
+			hw_cons = uctrl->hw_tx_cons;
+			if (bp->tx_cons != hw_cons) {
+				LOG_PACKET(PFX
+					   "%s: clearing tx interrupt [%d %d]",
+					   nic->log_name, bp->tx_cons, hw_cons);
+				bp->tx_cons = hw_cons;
+
+				break;
+			}
+
+			nanosleep(&sleep_req, &sleep_rem);
+		}
+	}
+
+	pthread_mutex_unlock(&nic->xmit_mutex);
+
+	return 0;
+}
+
+/*******************************************************************************
+ * qedi NIC op's table
+ ******************************************************************************/
+struct nic_ops qedi_op = {
+	.description = "qedi",
+	.open = qedi_open,
+	.close = qedi_close,
+	.write = qedi_write,
+	.get_tx_pkt = qedi_get_tx_pkt,
+	.start_xmit = qedi_start_xmit,
+	.read = qedi_read,
+	.clear_tx_intr = qedi_clear_tx_intr,
+	.handle_iscsi_path_req = cnic_handle_iscsi_path_req,
+
+	.lib_ops = {
+		    .get_library_name = qedi_get_library_name,
+		    .get_library_version = qedi_get_library_version,
+		    .get_build_date = qedi_get_build_date,
+		    .get_transport_name = qedi_get_transport_name,
+		    .get_uio_name = qedi_get_uio_name,
+		    },
+};
diff --git a/iscsiuio/src/unix/libs/qedi.h b/iscsiuio/src/unix/libs/qedi.h
new file mode 100644
index 000000000000..7e0140adb2ba
--- /dev/null
+++ b/iscsiuio/src/unix/libs/qedi.h
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2016, Cavium Inc.
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *      This product includes software developed by Adam Dunkels.
+ * 4. The name of the author may not be used to endorse or promote
+ *    products derived from this software without specific prior
+ *    written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+ * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * qedi.h - qedi user space driver
+ *
+ */
+#ifndef __QEDI_H__
+#define __QEDI_H__
+
+#include "nic.h"
+
+#define RX_RING_SIZE	15
+#define PKT_BUF_SIZE 0X400
+#define QEDI_PAGE_SIZE 4096
+
+#define QEDI_UNKNOWN_MAJOR_VERSION	-1
+#define QEDI_UNKNOWN_MINOR_VERSION	-1
+#define QEDI_UNKNOWN_SUB_MINOR_VERSION	-1
+struct qedi_driver_version {
+	uint16_t major;
+	uint16_t minor;
+	uint16_t sub_minor;
+};
+
+#define QEDI_UCTRL_MAP_REG	0
+#define QEDI_RING_MAP_REG	1
+#define QEDI_BUF_MAP_REG	2
+#define UIO_ATTR_TMPL	"/sys/class/uio/uio%u/maps/map%u/%s"
+#define UIO_ADDR_TMPL	"/sys/class/uio/uio%u/maps/map%u/addr"
+#define UIO_OFFSET_TMPL	"/sys/class/uio/uio%u/maps/map%u/offset"
+#define UIO_SIZE_TMPL	"/sys/class/uio/uio%u/maps/map%u/size"
+
+struct qedi_uio_ctrl {
+	/* meta data */
+	__u32 uio_hsi_version;
+
+	/* user writes */
+	__u32 host_tx_prod;
+	__u32 host_rx_cons;
+	__u32 host_rx_bd_cons;
+	__u32 host_tx_pkt_len;
+	__u32 host_rx_cons_cnt;
+
+	/* driver writes */
+	__u32 hw_tx_cons;
+	__u32 hw_rx_prod;
+	__u32 hw_rx_bd_prod;
+	__u32 hw_rx_prod_cnt;
+
+	/* other */
+	__u8 mac_addr[6];
+	__u8 reserve[2];
+};
+
+struct qedi_rx_bd {
+	__u32 rx_pkt_index;
+	__u32 rx_pkt_len;
+	__u16 vlan_id;
+};
+
+#define QEDI_RX_DESC_CNT	(QEDI_PAGE_SIZE / sizeof(struct qedi_rx_bd))
+#define QEDI_MAX_RX_DESC_CNT	(QEDI_RX_DESC_CNT - 1)
+#define QEDI_NUM_RX_BD		(QEDI_RX_DESC_CNT * 1)
+#define QEDI_MAX_RX_BD		(QEDI_NUM_RX_BD - 1)
+
+#define QEDI_NEXT_RX_IDX(x)	((((x) & (QEDI_MAX_RX_DESC_CNT)) ==     \
+				  (QEDI_MAX_RX_DESC_CNT - 1)) ?         \
+				 (x) + 2 : (x) + 1)
+
+#define QEDI_PATH_HANDLE	0xFE0000000
+
+typedef struct qedi {
+	nic_t *parent;
+
+	struct qedi_driver_version version;
+
+	uint16_t flags;
+#define CNIC_UIO_UNITIALIZED		0x0001
+#define CNIC_UIO_INITIALIZED		0x0002
+#define CNIC_UIO_ENABLED		0x0004
+#define CNIC_UIO_DISABLED		0x0008
+#define CNIC_UIO_IPv6_ENABLED		0x0010
+#define CNIC_UIO_ADDED_MULICAST		0x0020
+#define CNIC_UIO_MSIX_ENABLED		0x0200
+#define CNIC_UIO_TX_HAS_SENT		0x0400
+#define QEDI_OPENED			0x0800
+
+	__u32 chip_id;
+	int func;
+	int port;
+	int pfid;
+	__u32 cid;
+	__u32 client_id;
+
+	__u32 tx_prod;
+	__u32 tx_bd_prod;
+	__u32 tx_cons;
+	__u8 tx_vlan_tag_bit;
+
+	__u32 rx_prod;
+	__u32 rx_bd_prod;
+	__u32 rx_cons;
+	__u32 rx_bd_cons;
+	__u32 rx_hw_prod;
+
+	 __u32 (*get_rx_cons)(struct qedi *);
+	 __u32 (*get_tx_cons)(struct qedi *);
+
+	/* RX ring parameters */
+	uint32_t rx_ring_size;
+	uint32_t rx_buffer_size;
+
+	void *bufs; /* Pointer to the mapped buffer space */
+	void *uctrl_map; /* UIO control structure */
+	uint32_t uctrl_map_offset; /* UIO control structure mmap offset */
+
+	uint32_t rx_index;
+	void *rx_comp_ring;
+	void **rx_pkt_ring;
+	void *tx_pkt;
+	void *rx_pkts;
+} qedi_t;
+
+/******************************************************************************
+ *  qedi Function Declarations
+ ******************************************************************************/
+void qedi_start_xmit(nic_t *nic, size_t len, u16_t vlan_id);
+struct nic_ops *qedi_get_ops();
+
+#endif /* __QEDI_H__ */
diff --git a/iscsiuio/src/unix/nic.c b/iscsiuio/src/unix/nic.c
index 8825f00b7216..a5f714a91923 100644
--- a/iscsiuio/src/unix/nic.c
+++ b/iscsiuio/src/unix/nic.c
@@ -65,6 +65,7 @@
 
 #include "bnx2.h"
 #include "bnx2x.h"
+#include "qedi.h"
 #include "ipv6.h"
 
 /******************************************************************************
@@ -180,7 +181,7 @@ error:
 }
 
 static struct nic_ops *(*nic_get_ops[]) () = {
-bnx2_get_ops, bnx2x_get_ops,};
+bnx2_get_ops, bnx2x_get_ops, qedi_get_ops};
 
 int load_all_nic_libraries()
 {
@@ -404,6 +405,7 @@ nic_t *nic_init()
 	memset(nic, 0, sizeof(*nic));
 	nic->uio_minor = -1;
 	nic->fd = INVALID_FD;
+	nic->host_no = INVALID_HOST_NO;
 	nic->next = NULL;
 	nic->thread = INVALID_THREAD;
 	nic->enable_thread = INVALID_THREAD;
@@ -1070,6 +1072,8 @@ int process_packets(nic_t *nic,
 		}
 nic_iface_present:
 		pkt->nic_iface = nic_iface;
+		LOG_DEBUG(PFX "%s: found nic iface, type=0x%x, bufsize=%d",
+			  nic->log_name, type, pkt->buf_size);
 
 		ustack = &nic_iface->ustack;
 
diff --git a/iscsiuio/src/unix/nic.h b/iscsiuio/src/unix/nic.h
index ec157815a375..2c41e6e3c25a 100644
--- a/iscsiuio/src/unix/nic.h
+++ b/iscsiuio/src/unix/nic.h
@@ -334,6 +334,7 @@ typedef struct nic {
 
 	/* The thread used to perform ping */
 	pthread_t ping_thread;
+	uint64_t transport_handle;
 } nic_t;
 
 /******************************************************************************
diff --git a/iscsiuio/src/unix/nic_utils.c b/iscsiuio/src/unix/nic_utils.c
index 0daffd2fcb6d..6e580f862eea 100644
--- a/iscsiuio/src/unix/nic_utils.c
+++ b/iscsiuio/src/unix/nic_utils.c
@@ -81,6 +81,10 @@ static const char iscsi_host_path_netdev_template[] =
 	"/sys/class/iscsi_host/host%d/netdev";
 static const char cnic_uio_sysfs_resc_template[] =
 	"/sys/class/uio/uio%i/device/resource%i";
+static const char iscsi_transport_handle_template[] =
+	"/sys/class/iscsi_transport/%s/handle";
+static const char eth_pfx[] = "eth";
+static const char host_pfx[] = "host";
 
 /**
  *  manually_trigger_uio_event() - If the uio file node doesn't exist then
@@ -250,6 +254,7 @@ int nic_discover_iscsi_hosts()
 				strncpy(nic->eth_device_name, raw, raw_size);
 				nic->config_device_name = nic->eth_device_name;
 				nic->log_name = nic->eth_device_name;
+				nic->host_no = host_no;
 
 				if (nic_fill_name(nic) != 0) {
 					free(nic);
@@ -557,6 +562,102 @@ error:
 }
 
 /**
+ *  from_uio_find_associated_host() - Given the uio minor number
+ *      this function will try to find the assoicated iscsi host
+ *  @param uio_minor - minor number of the UIO device
+ *  @param name - char buffer which will be filled if successful
+ *  @param name_size - size of the name buffer
+ *  @return >0 minor number <0 an error
+ */
+static int from_uio_find_associated_host(nic_t *nic, int uio_minor,
+					 char *name, size_t name_size)
+{
+	char *path;
+	int rc;
+	int count;
+	struct dirent **files;
+	char *parsed_name;
+	int i;
+	int path_iterator;
+	char *search_paths[] = { "/sys/class/uio/uio%i/device/" };
+	int path_to[] = { 5, 1 };
+	int (*search_filters[]) (const struct dirent *) = { filter_host_name, };
+	char *(*extract_name[]) (struct dirent **files) = {  extract_none, };
+	int extract_name_offset[] = { 0 };
+
+	path = malloc(PATH_MAX);
+	if (!path) {
+		LOG_ERR(PFX "Could not allocate memory for path");
+		rc = -ENOMEM;
+		goto error;
+	}
+
+	for (path_iterator = 0;
+	     path_iterator < sizeof(search_paths) / sizeof(search_paths[0]);
+	     path_iterator++) {
+		/*  Build the path to determine uio name */
+		rc = sprintf(path, search_paths[path_iterator], uio_minor);
+
+		wait_for_file_node_timed(nic, path, path_to[path_iterator]);
+
+		count = scandir(path, &files,
+				search_filters[path_iterator], alphasort);
+
+		switch (count) {
+		case 1:
+			parsed_name = (*extract_name[path_iterator]) (files);
+			if (!parsed_name) {
+				LOG_WARN(PFX "Couldn't find delimiter in: %s",
+					 files[0]->d_name);
+
+				break;
+			}
+
+			strncpy(name,
+				parsed_name +
+				extract_name_offset[path_iterator], name_size);
+
+			free(files[0]);
+			free(files);
+
+			rc = 0;
+			break;
+
+		case 0:
+			rc = -EINVAL;
+			break;
+
+		case -1:
+			LOG_WARN(PFX "Error when scanning path: %s[%s]",
+				 path, strerror(errno));
+			rc = -EINVAL;
+			break;
+
+		default:
+			LOG_WARN(PFX
+				 "Too many entries when looking for device: %s",
+				 path);
+
+			/*  Cleanup the scandir() call */
+			for (i = 0; i < count; i++)
+				free(files[i]);
+			free(files);
+
+			rc = -EINVAL;
+			break;
+		}
+
+		if (rc == 0)
+			break;
+	}
+
+error:
+	free(path);
+
+	return rc;
+}
+
+/**
  *  filter_uio_name() - This is the callback used by scandir when looking for
  *                      the number of uio entries
  */
@@ -652,10 +753,16 @@ int from_phys_name_find_assoicated_uio_device(nic_t *nic)
 			continue;
 		}
 
-		rc = from_uio_find_associated_eth_device(nic,
-							 uio_minor,
-							 eth_name,
-							 sizeof(eth_name));
+		if (!memcmp(host_pfx, nic->config_device_name,
+			    strlen(host_pfx))) {
+			rc = from_uio_find_associated_host(nic, uio_minor,
+							   eth_name,
+							   sizeof(eth_name));
+		} else {
+			rc = from_uio_find_associated_eth_device(nic, uio_minor,
+								 eth_name,
+								 sizeof(eth_name));
+		}
 		if (rc != 0) {
 			LOG_WARN("uio minor: %d not valid [%D]", uio_minor, rc);
 			continue;
@@ -1124,6 +1231,38 @@ int detemine_initial_uio_events(nic_t *nic, uint32_t *num_of_events)
 
 	rc = 0;
 error:
+	if (raw)
+		free(raw);
+
+	return rc;
+}
+
+int get_iscsi_transport_handle(nic_t *nic, uint64_t *handle)
+{
+	char *raw = NULL;
+	uint32_t raw_size = 0;
+	ssize_t elements_read;
+	char temp_path[sizeof(iscsi_transport_handle_template) + 8];
+	int rc;
+
+	/*  Capture RX buffer size */
+	snprintf(temp_path, sizeof(temp_path),
+		 iscsi_transport_handle_template, nic->library_name);
+
+	rc = capture_file(&raw, &raw_size, temp_path);
+	if (rc != 0)
+		goto error;
+
+	elements_read = sscanf(raw, "%lu", handle);
+	if (elements_read != 1) {
+		LOG_ERR(PFX "%s: Couldn't parse transport handle from %s",
+			nic->log_name, temp_path);
+		rc = -EIO;
+		goto error;
+	}
+
+	rc = 0;
+error:
 	if (raw != NULL)
 		free(raw);
 
diff --git a/iscsiuio/src/unix/nic_utils.h b/iscsiuio/src/unix/nic_utils.h
index d5c1b580f340..e4cf5c13177e 100644
--- a/iscsiuio/src/unix/nic_utils.h
+++ b/iscsiuio/src/unix/nic_utils.h
@@ -99,4 +99,6 @@ void dump_packet_to_log(struct nic_interface *iface,
 int determine_file_size_read(const char *filepath);
 int capture_file(char **raw, uint32_t *raw_size, const char *path);
 
+int get_iscsi_transport_handle(nic_t *nic, uint64_t *handle);
+
 #endif /* __NIC_UTILS_H__ */
diff --git a/iscsiuio/src/unix/options.h b/iscsiuio/src/unix/options.h
index df03255f7a87..63b86357aafa 100644
--- a/iscsiuio/src/unix/options.h
+++ b/iscsiuio/src/unix/options.h
@@ -87,6 +87,7 @@
 
 #define INVALID_FD	-1
 #define INVALID_THREAD	-1
+#define INVALID_HOST_NO	-1
 
 struct options {
 	char debug;
-- 
2.9.3