[PATCH 0/2] RDMA/core: add support for iWarp multicast acceleration over IB_QPT_RAW_ETY QP type

[PATCH 0/2] RDMA/core: add support for iWarp multicast acceleration over IB_QPT_RAW_ETY QP type

[Mirek Walukiewicz]

This patch series implements iWarp multicast acceleration over raw eth QP type.

In ibv_attach_mcast and ibv_detach_mcast, new case is added for RDMA_TRANSPORT_IWARP to allow multicast 
on IB_QPT_RAW_ETY QP type. This change is for iWarp only and does not affect IB.

Changes to nes demenstrate how IB_QPT_RAW_ETY QP is used to accelerate multicast traffic.

Miroslaw Walukiewicz
 
--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH 1/2] RDMA/core: add support for iWarp multicast acceleration over IB_QPT_RAW_ETY QP type

[miroslaw.walukiewicz-ral2JQCrhuEAvxtiuMwx3w]

The patch enables usage of attach_mcast()/detach_mcast driver
specific verbs for iWARP devices.

IB path is unchanged.
iWARP path adds checking for raw ethernet QP type

Signed-off-by: Mirek Walukiewicz <miroslaw.walukiewicz-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org>



---

 drivers/infiniband/core/verbs.c |   24 ++++++++++++++++++++----
 1 files changed, 20 insertions(+), 4 deletions(-)


diff --git a/drivers/infiniband/core/verbs.c b/drivers/infiniband/core/verbs.c
index a7da9be..b5023f2 100644
--- a/drivers/infiniband/core/verbs.c
+++ b/drivers/infiniband/core/verbs.c
@@ -887,9 +887,17 @@ int ib_attach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid)
 {
 	if (!qp->device->attach_mcast)
 		return -ENOSYS;
-	if (gid->raw[0] != 0xff || qp->qp_type != IB_QPT_UD)
-		return -EINVAL;
 
+	switch (qp->device->node_type) {
+	case RDMA_TRANSPORT_IB:
+		if (gid->raw[0] != 0xff || qp->qp_type != IB_QPT_UD)
+			return -EINVAL;
+		break;
+	case RDMA_TRANSPORT_IWARP:
+		if (qp->qp_type != IB_QPT_RAW_ETY)
+			return -EINVAL;
+		break;
+	}
 	return qp->device->attach_mcast(qp, gid, lid);
 }
 EXPORT_SYMBOL(ib_attach_mcast);
@@ -898,9 +906,17 @@ int ib_detach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid)
 {
 	if (!qp->device->detach_mcast)
 		return -ENOSYS;
-	if (gid->raw[0] != 0xff || qp->qp_type != IB_QPT_UD)
-		return -EINVAL;
 
+	switch (qp->device->node_type) {
+	case RDMA_TRANSPORT_IB:
+		if (gid->raw[0] != 0xff || qp->qp_type != IB_QPT_UD)
+			return -EINVAL;
+		break;
+	case RDMA_TRANSPORT_IWARP:
+		if (qp->qp_type != IB_QPT_RAW_ETY)
+			return -EINVAL;
+		break;
+	}
 	return qp->device->detach_mcast(qp, gid, lid);
 }
 EXPORT_SYMBOL(ib_detach_mcast);


--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH 1/2] RDMA/core: add support for iWarp multicast acceleration over IB_QPT_RAW_ETY QP type

[Steve Wise]

Hey Roland,

Do you have thoughts on this change?  It is useful along with the 
IBV_QPT_RAW_ETY type added to libibverbs for cxgb devices too.

Steve.

miroslaw.walukiewicz-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org wrote:
> The patch enables usage of attach_mcast()/detach_mcast driver
> specific verbs for iWARP devices.
>
> IB path is unchanged.
> iWARP path adds checking for raw ethernet QP type
>
> Signed-off-by: Mirek Walukiewicz <miroslaw.walukiewicz-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org>
>
>
>
> ---
>
>  drivers/infiniband/core/verbs.c |   24 ++++++++++++++++++++----
>  1 files changed, 20 insertions(+), 4 deletions(-)
>
>
> diff --git a/drivers/infiniband/core/verbs.c b/drivers/infiniband/core/verbs.c
> index a7da9be..b5023f2 100644
> --- a/drivers/infiniband/core/verbs.c
> +++ b/drivers/infiniband/core/verbs.c
> @@ -887,9 +887,17 @@ int ib_attach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid)
>  {
>  	if (!qp->device->attach_mcast)
>  		return -ENOSYS;
> -	if (gid->raw[0] != 0xff || qp->qp_type != IB_QPT_UD)
> -		return -EINVAL;
>  
> +	switch (qp->device->node_type) {
> +	case RDMA_TRANSPORT_IB:
> +		if (gid->raw[0] != 0xff || qp->qp_type != IB_QPT_UD)
> +			return -EINVAL;
> +		break;
> +	case RDMA_TRANSPORT_IWARP:
> +		if (qp->qp_type != IB_QPT_RAW_ETY)
> +			return -EINVAL;
> +		break;
> +	}
>  	return qp->device->attach_mcast(qp, gid, lid);
>  }
>  EXPORT_SYMBOL(ib_attach_mcast);
> @@ -898,9 +906,17 @@ int ib_detach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid)
>  {
>  	if (!qp->device->detach_mcast)
>  		return -ENOSYS;
> -	if (gid->raw[0] != 0xff || qp->qp_type != IB_QPT_UD)
> -		return -EINVAL;
>  
> +	switch (qp->device->node_type) {
> +	case RDMA_TRANSPORT_IB:
> +		if (gid->raw[0] != 0xff || qp->qp_type != IB_QPT_UD)
> +			return -EINVAL;
> +		break;
> +	case RDMA_TRANSPORT_IWARP:
> +		if (qp->qp_type != IB_QPT_RAW_ETY)
> +			return -EINVAL;
> +		break;
> +	}
>  	return qp->device->detach_mcast(qp, gid, lid);
>  }
>  EXPORT_SYMBOL(ib_detach_mcast);
>
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
> the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>   

--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH 2/2] RDMA/nes: add support of iWARP multicast acceleration over IB_QPT_RAW_ETY QP type

[miroslaw.walukiewicz-ral2JQCrhuEAvxtiuMwx3w]

This patch implements iWarp multicast acceleration (IMA)
over IB_QPT_RAW_ETY QP type in nes driver.

Application creates a raw eth QP (IBV_QPT_RAW_ETH in user-space) and
manages the multicast via ibv_attach_mcast and ibv_detach_mcast calls.

Calling ibv_attach_mcast/ibv_datach_mcast has an effect of
enabling/disabling L2 MAC address filters in HW.

Signed-off-by: Mirek Walukiewicz <miroslaw.walukiewicz-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org>



---

 drivers/infiniband/hw/nes/Makefile    |    2 
 drivers/infiniband/hw/nes/nes.c       |    4 
 drivers/infiniband/hw/nes/nes.h       |    2 
 drivers/infiniband/hw/nes/nes_nic.c   |   11 
 drivers/infiniband/hw/nes/nes_ud.c    | 2070 +++++++++++++++++++++++++++++++++
 drivers/infiniband/hw/nes/nes_ud.h    |   86 +
 drivers/infiniband/hw/nes/nes_verbs.c |  221 +++-
 drivers/infiniband/hw/nes/nes_verbs.h |    7 
 8 files changed, 2388 insertions(+), 15 deletions(-)
 create mode 100644 drivers/infiniband/hw/nes/nes_ud.c
 create mode 100644 drivers/infiniband/hw/nes/nes_ud.h


diff --git a/drivers/infiniband/hw/nes/Makefile b/drivers/infiniband/hw/nes/Makefile
index 3514851..850df8e 100644
--- a/drivers/infiniband/hw/nes/Makefile
+++ b/drivers/infiniband/hw/nes/Makefile
@@ -1,3 +1,3 @@
 obj-$(CONFIG_INFINIBAND_NES) += iw_nes.o
 
-iw_nes-objs := nes.o nes_hw.o nes_nic.o nes_utils.o nes_verbs.o nes_cm.o
+iw_nes-objs := nes.o nes_hw.o nes_nic.o nes_utils.o nes_verbs.o nes_cm.o nes_ud.o
diff --git a/drivers/infiniband/hw/nes/nes.c b/drivers/infiniband/hw/nes/nes.c
index de7b9d7..e430804 100644
--- a/drivers/infiniband/hw/nes/nes.c
+++ b/drivers/infiniband/hw/nes/nes.c
@@ -60,6 +60,8 @@
 #include <linux/route.h>
 #include <net/ip_fib.h>
 
+#include "nes_ud.h"
+
 MODULE_AUTHOR("NetEffect");
 MODULE_DESCRIPTION("NetEffect RNIC Low-level iWARP Driver");
 MODULE_LICENSE("Dual BSD/GPL");
@@ -1205,6 +1207,7 @@ static int __init nes_init_module(void)
 		if (retval1 < 0)
 			printk(KERN_ERR PFX "Unable to create NetEffect sys files.\n");
 	}
+	nes_ud_init();
 	return retval;
 }
 
@@ -1214,6 +1217,7 @@ static int __init nes_init_module(void)
  */
 static void __exit nes_exit_module(void)
 {
+	nes_ud_exit();
 	nes_cm_stop();
 	nes_remove_driver_sysfs(&nes_pci_driver);
 
diff --git a/drivers/infiniband/hw/nes/nes.h b/drivers/infiniband/hw/nes/nes.h
index cc78fee..faf420f 100644
--- a/drivers/infiniband/hw/nes/nes.h
+++ b/drivers/infiniband/hw/nes/nes.h
@@ -102,6 +102,7 @@
 #define NES_DRV_OPT_NO_INLINE_DATA       0x00000080
 #define NES_DRV_OPT_DISABLE_INT_MOD      0x00000100
 #define NES_DRV_OPT_DISABLE_VIRT_WQ      0x00000200
+#define NES_DRV_OPT_MCAST_LOGPORT_MAP    0x00000800
 
 #define NES_AEQ_EVENT_TIMEOUT         2500
 #define NES_DISCONNECT_EVENT_TIMEOUT  2000
@@ -128,6 +129,7 @@
 #define NES_DBG_IW_RX       0x00020000
 #define NES_DBG_IW_TX       0x00040000
 #define NES_DBG_SHUTDOWN    0x00080000
+#define NES_DBG_UD          0x00100000
 #define NES_DBG_RSVD1       0x10000000
 #define NES_DBG_RSVD2       0x20000000
 #define NES_DBG_RSVD3       0x40000000
diff --git a/drivers/infiniband/hw/nes/nes_nic.c b/drivers/infiniband/hw/nes/nes_nic.c
index b7c813f..c7bbb83 100644
--- a/drivers/infiniband/hw/nes/nes_nic.c
+++ b/drivers/infiniband/hw/nes/nes_nic.c
@@ -897,7 +897,7 @@ static void nes_netdev_set_multicast_list(struct net_device *netdev)
 			((mc_nic_index = nesvnic->mcrq_mcast_filter(nesvnic,
 					get_addr(addrs, i++))) == 0));
 			if (mc_nic_index < 0)
-				mc_nic_index = nesvnic->nic_index;
+				mc_nic_index = (1 << nesvnic->nic_index);
 			while (nesadapter->pft_mcast_map[mc_index] < 16 &&
 				nesadapter->pft_mcast_map[mc_index] !=
 					nesvnic->nic_index &&
@@ -930,7 +930,7 @@ static void nes_netdev_set_multicast_list(struct net_device *netdev)
 				nes_write_indexed(nesdev,
 						perfect_filter_register_address+4+(mc_index * 8),
 						(u32)macaddr_high | NES_MAC_ADDR_VALID |
-						((((u32)(1<<mc_nic_index)) << 16)));
+					((((u32)(mc_nic_index)) << 16)));
 				nesadapter->pft_mcast_map[mc_index] =
 							nesvnic->nic_index;
 			} else {
@@ -1676,8 +1676,11 @@ struct net_device *nes_netdev_init(struct nes_device *nesdev,
 			(nesvnic->nesdev->nesadapter->port_count == 1 &&
 			nesvnic->nesdev->nesadapter->adapter_fcn_count == 2)) {
 				nesvnic->qp_nic_index[0] = nesvnic->nic_index;
-				nesvnic->qp_nic_index[1] = nesvnic->nic_index
-									+ 2;
+
+			if (nes_drv_opt & NES_DRV_OPT_MCAST_LOGPORT_MAP)
+				nesvnic->qp_nic_index[1] = 0xf;
+			else
+				nesvnic->qp_nic_index[1] = nesvnic->nic_index+2;
 				nesvnic->qp_nic_index[2] = 0xf;
 				nesvnic->qp_nic_index[3] = 0xf;
 		} else {
diff --git a/drivers/infiniband/hw/nes/nes_ud.c b/drivers/infiniband/hw/nes/nes_ud.c
new file mode 100644
index 0000000..f004855
--- /dev/null
+++ b/drivers/infiniband/hw/nes/nes_ud.c
@@ -0,0 +1,2070 @@
+/*
+ * Copyright (c) 2008 - 2010 Intel Corporation.  All rights reserved.
+ * Copyright (c) 2006 - 2008 Neteffect, All rights reserved.
+ * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - 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.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <linux/version.h>
+#include <linux/completion.h>
+#include <linux/mutex.h>
+#include <linux/poll.h>
+#include <linux/idr.h>
+#include <linux/in.h>
+#include <linux/in6.h>
+#include <linux/device.h>
+#include <linux/netdevice.h>
+#include <linux/list.h>
+#include <linux/miscdevice.h>
+#include <linux/device.h>
+
+#include <rdma/ib_umem.h>
+#include <rdma/ib_user_verbs.h>
+
+#include "nes.h"
+#include "nes_ud.h"
+
+#define NES_UD_BASE_XMIT_NIC_QPID  28
+#define NES_UD_BASE_RECV_NIC_IDX   12
+#define NES_UD_BASE_XMIT_NIC_IDX   8
+#define NES_UD_MAX_NIC_CNT 8
+#define NES_UD_CLEANUP_TIMEOUT (HZ)
+#define NES_UD_MCAST_TBL_SZ 128
+#define NES_UD_SINGLE_HDR_SZ 64
+#define NES_UD_CQE_NUM NES_NIC_WQ_SIZE
+#define NES_UD_SKSQ_WAIT_TIMEOUT	100000
+#define NES_UD_MAX_REG_CNT 128
+
+#define NES_UD_MAX_ADAPTERS 4 /* number of supported interfaces for  RAW ETH */
+
+#define NES_UD_MAX_REG_HASH_CNT 256 /* last byte of the STAG is hash key */
+
+/*
+ * the same multicast could be allocated up to 2 owners so there could be
+ *  two differentmcast entries allocated for the same mcas address
+ */
+struct nes_ud_file;
+struct nes_ud_mcast {
+	u8 addr[3];
+	u8 in_use;
+	struct nes_ud_file *owner;
+	u8 nic_mask;
+};
+
+struct nes_ud_mem_region {
+	struct list_head list;
+	dma_addr_t *addrs;
+	u64 va;
+	u64 length;
+	u32 pg_cnt;
+	u32 in_use;
+	u32 stag; /* stag related this structure */
+};
+
+struct nic_queue_info {
+	u32 qpn;
+	u32 nic_index;
+	u32 logical_port;
+	enum nes_ud_dev_priority prio;
+	enum nes_ud_queue_type queue_type;
+	struct nes_ud_file *file;
+	struct nes_ud_file file_body;
+};
+
+struct nes_ud_resources {
+	int num_logport_confed;
+	int num_allocated_nics;
+	u8 logport_2_map;
+	u8 logport_3_map;
+	u32 original_6000;
+	u32 original_60b8;
+	struct nic_queue_info nics[NES_UD_MAX_NIC_CNT];
+	struct mutex          mutex;
+	struct nes_ud_mcast mcast[NES_UD_MCAST_TBL_SZ];
+	u32 adapter_no;  /* the allocated adapter no */
+
+	/* the unique ID of the NE020 adapter */
+	/*- it is allocated once per HW */
+	struct nes_adapter *pAdap;
+};
+
+/* memory hash list entry */
+struct nes_ud_hash_mem {
+    struct list_head   list;
+    int                read_stats;
+};
+
+
+
+struct nes_ud_mem {
+	/* hash list of registered STAGs */
+	struct nes_ud_hash_mem mrs[NES_UD_MAX_REG_HASH_CNT];
+	struct mutex          mutex;
+};
+
+/* the QP in format x.y.z where x is adapter no, */
+/* y is ud file idx in adapter, z is a qp no */
+static struct nes_ud_mem ud_mem;
+
+struct nes_ud_send_wr {
+    u32               wr_cnt;
+    u32               qpn;
+    u32               flags;
+    u32               resv[1];
+    struct ib_sge     sg_list[64];
+};
+
+struct nes_ud_recv_wr {
+    u32               wr_cnt;
+    u32               qpn;
+    u32	              resv[2];
+    struct ib_sge     sg_list[64];
+};
+
+static struct nes_ud_resources nes_ud_rsc[NES_UD_MAX_ADAPTERS];
+static struct workqueue_struct *nes_ud_workqueue;
+
+/*
+ * locate_ud_adapter
+ *
+ * the function locates the UD adapter
+*  on base of the adapter unique ID (structure nes_adapter)
+ */
+static inline
+struct nes_ud_resources *locate_ud_adapter(struct nes_adapter *pAdapt)
+{
+	int i;
+	struct nes_ud_resources *pRsc;
+
+	for (i = 0; i < NES_UD_MAX_ADAPTERS; i++) {
+		pRsc = &nes_ud_rsc[i];
+
+		if (pRsc->pAdap == pAdapt)
+			return pRsc;
+
+	}
+	return NULL;
+}
+
+/*
+ * allocate_ud_adapter()
+ *
+ * function allocates a new adapter
+ */
+static inline
+struct nes_ud_resources *allocate_ud_adapter(struct nes_adapter *pAdapt)
+{
+    int i;
+    struct nes_ud_resources *pRsc;
+
+    for (i = 0; i < NES_UD_MAX_ADAPTERS; i++) {
+	pRsc = &nes_ud_rsc[i];
+	if (pRsc->pAdap == NULL) {
+		pRsc->pAdap = pAdapt;
+		nes_debug(NES_DBG_UD, "new UD Adapter allocated %d"
+		" for adapter %p no =%d\n", i, pAdapt, pRsc->adapter_no);
+		return pRsc;
+		}
+	}
+	nes_debug(NES_DBG_UD, "Unable to allocate adapter\n");
+	return NULL;
+}
+
+static inline
+struct nes_ud_file *allocate_nic_queue(struct nes_vnic *nesvnic,
+					enum nes_ud_queue_type queue_type)
+{
+    struct nes_ud_file *file = NULL;
+	int i = 0;
+	u8 select_log_port = 0xf;
+	struct nes_device *nesdev = nesvnic->nesdev;
+	int log_port_2_alloced = 0;
+	int log_port_3_alloced = 0;
+	int ret = 0;
+	struct nes_ud_resources *pRsc;
+
+	/* the first thing that must be done is determine the adapter */
+	/* number max the adapter could have up to 2 interfaces */
+	if (nesvnic->nic_index != 0 && nesvnic->nic_index != 1) {
+		nes_debug(NES_DBG_UD, "nic queue allocation failed"
+		" nesvnic->nic_index = %d\n", nesvnic->nic_index);
+		return NULL;
+	}
+
+	/* locate device on base of nesvnic */
+	/* - when it is an unknown card a new one is allocated */
+	pRsc = locate_ud_adapter(nesdev->nesadapter);
+	if (pRsc == NULL)
+		return NULL;
+
+	for (i = 0; i < NES_UD_MAX_NIC_CNT; i++) {
+		if (pRsc->nics[i].file->active == 0)
+			continue;
+		if (pRsc->nics[i].logical_port == 2 &&
+		    queue_type == pRsc->nics[i].queue_type)
+				log_port_2_alloced++;
+		if (pRsc->nics[i].logical_port == 3 &&
+		    queue_type == pRsc->nics[i].queue_type)
+				log_port_3_alloced++;
+	}
+
+	/* check dual/single card */
+	if (pRsc->logport_2_map != pRsc->logport_3_map) {
+		/* a dual port card */
+		/* allocation is NIC2, NIC2, NIC3, NIC3 */
+		/*- no RX packat replication supported */
+		if (log_port_2_alloced < 2 &&
+		    pRsc->logport_2_map == nesvnic->nic_index)
+				select_log_port = 2;
+		else if (log_port_3_alloced < 2 &&
+			 pRsc->logport_3_map == nesvnic->nic_index)
+				select_log_port = 3;
+	} else {
+		/* single port card */
+		/* change allocation scheme to NIC2,NIC3,NIC2,NIC3 */
+		switch (log_port_2_alloced + log_port_3_alloced) {
+		case 0: /* no QPs allocated - use NIC2 */
+			if (pRsc->logport_2_map == nesvnic->nic_index)
+				select_log_port = 2;
+
+			break;
+		case 1: /* NIC2 or NIC3 allocated */
+			if (log_port_2_alloced > 0) {
+				/* if NIC2 allocated use NIC3 */
+				if (pRsc->logport_3_map == nesvnic->nic_index)
+					select_log_port = 3;
+
+			} else {
+				/* when NIC3 allocated use NIC2 */
+				if (pRsc->logport_2_map == nesvnic->nic_index)
+					select_log_port = 2;
+
+			}
+			break;
+
+		case 2:
+		/* NIC2 and NIC3 allocated or both ports on NIC3 - use NIC2 */
+			if ((log_port_2_alloced == 1) ||
+			    (log_port_3_alloced == 2)) {
+				if (pRsc->logport_2_map == nesvnic->nic_index)
+					select_log_port = 2;
+
+			} else {
+				/* both ports allocated on NIC2 - use NIC3 */
+				if (pRsc->logport_3_map == nesvnic->nic_index)
+					select_log_port = 3;
+
+			}
+				break;
+		case 3:
+			/* when both NIC2 allocated use NIC3 */
+			if (log_port_2_alloced == 2) {
+				if (pRsc->logport_3_map == nesvnic->nic_index)
+					select_log_port = 3;
+
+			} else {
+				/* when both NIC3 alloced use NIC2 */
+				if (pRsc->logport_2_map == nesvnic->nic_index)
+					select_log_port = 2;
+			}
+			break;
+
+		default:
+			break;
+		}
+	}
+	if (select_log_port == 0xf) {
+		ret = -1;
+		nes_debug(NES_DBG_UD, "%s(%d) logport allocation failed "
+		"log_port_2_alloced=%d log_port_3_alloced=%d\n",
+			__func__, __LINE__, log_port_2_alloced,
+			log_port_3_alloced);
+		goto out;
+	}
+
+	nes_debug(NES_DBG_UD, "%s(%d) log_port_2_alloced=%d "
+		"log_port_3_alloced=%d select_log_port=%d\n",
+		__func__, __LINE__, log_port_2_alloced,
+		log_port_3_alloced, select_log_port);
+
+	for (i = 0; i < NES_UD_MAX_NIC_CNT; i++) {
+		if (pRsc->nics[i].file->active == 1)
+			continue;
+		if (pRsc->nics[i].logical_port == select_log_port &&
+		    queue_type == pRsc->nics[i].queue_type) {
+
+			/* file is preallocated during initialization */
+			file = pRsc->nics[i].file;
+			memset(file, 0, sizeof(*file));
+
+			file->nesvnic = nesvnic;
+			file->queue_type = queue_type;
+
+			file->prio = pRsc->nics[i].prio;
+			file->qpn = pRsc->nics[i].qpn;
+			file->nes_ud_nic_index = pRsc->nics[i].nic_index;
+			file->rsc_idx = i;
+			file->adapter_no = pRsc->adapter_no;
+			goto out;
+		}
+	}
+
+out:
+	return file;
+}
+
+static inline int  del_rsc_list(struct nes_ud_file *file)
+{
+	int logport_2_cnt = 0;
+	int logport_3_cnt = 0;
+	struct nes_device *nesdev = file->nesvnic->nesdev;
+	int i = 0;
+	struct nes_ud_resources *pRsc;
+
+	if (file == NULL) {
+		nes_debug(NES_DBG_UD, "%s(%d) file is NULL\n",
+			__func__, __LINE__);
+		return -EFAULT;
+	}
+	if (file->nesvnic == NULL) {
+		nes_debug(NES_DBG_UD, "%s(%d) file->nesvnic is NULL\n",
+			__func__, __LINE__);
+		return -EFAULT;
+	}
+	if (nesdev == NULL) {
+		nes_debug(NES_DBG_UD, "%s(%d) nesdev is NULL\n",
+			__func__, __LINE__);
+		return -EFAULT;
+	}
+
+	/* locate device on base of nesvnic */
+	/*- when it is an unknown card a new one is allocated */
+	pRsc = locate_ud_adapter(nesdev->nesadapter);
+	if (pRsc == NULL) {
+		nes_debug(NES_DBG_UD, "%s(%d) cannot locate an allocated "
+			"adapter  is NULL\n", __func__, __LINE__);
+		return -EFAULT;
+	}
+	if (--pRsc->num_allocated_nics == 0) {
+		nes_write_indexed(nesdev, 0x60b8, pRsc->original_60b8);
+		nes_write_indexed(nesdev, 0x6000, pRsc->original_6000);
+		pRsc->num_logport_confed = 0;
+	}
+	BUG_ON(pRsc->num_allocated_nics < 0);
+	BUG_ON(file->rsc_idx >= NES_UD_MAX_NIC_CNT);
+
+	for (i = 0; i < NES_UD_MAX_NIC_CNT; i++) {
+		if (pRsc->nics[i].file->active &&
+		    pRsc->nics[i].logical_port == 2)
+			logport_2_cnt++;
+		if (pRsc->nics[i].file->active &&
+		    pRsc->nics[i].logical_port == 3)
+			logport_3_cnt++;
+	}
+
+	if (pRsc->num_logport_confed != 0x3 && logport_2_cnt == 0)
+		pRsc->logport_2_map = 0xf;
+
+	if (pRsc->num_logport_confed != 0x3 && logport_3_cnt == 0)
+		pRsc->logport_3_map = 0xf;
+	return 0;
+}
+
+/*
+* the QPN contains now the number of the RAW ETH
+* adapter and QPN number on the adapter
+* the adapter number is located in the highier
+* 8 bits so QPN is stored as [adapter:qpn]
+*/
+static inline
+struct nes_ud_file *get_file_by_qpn(struct nes_ud_resources *pRsc, int qpn)
+{
+	int i = 0;
+
+	for (i = 0; i < NES_UD_MAX_NIC_CNT; i++) {
+		if (pRsc->nics[i].file->active &&
+		    pRsc->nics[i].qpn == (qpn & 0xff))
+			return pRsc->nics[i].file;
+
+	}
+	return NULL;
+}
+
+/* function counts all ETH RAW entities that have  */
+/* a specific type and relation to specific vnic */
+static inline
+int count_files_by_nic(struct nes_vnic *nesvnic,
+			enum nes_ud_queue_type queue_type)
+{
+	int count = 0;
+	int i = 0;
+	struct nes_ud_resources *pRsc;
+
+	pRsc = locate_ud_adapter(nesvnic->nesdev->nesadapter);
+	if (pRsc == NULL)
+		return 0;
+
+	for (i = 0; i < NES_UD_MAX_NIC_CNT; i++) {
+		if (pRsc->nics[i].file->active &&
+		    pRsc->nics[i].file->nesvnic == nesvnic &&
+		    pRsc->nics[i].queue_type == queue_type)
+				count++;
+	}
+	return count;
+}
+
+/* function counts all RAW ETH  entities the have a specific type */
+static inline
+int count_files(struct nes_vnic *nesvnic, enum nes_ud_queue_type queue_type)
+{
+	int count = 0;
+	int i = 0;
+	struct nes_ud_resources *pRsc;
+
+	pRsc = locate_ud_adapter(nesvnic->nesdev->nesadapter);
+	if (pRsc == NULL)
+		return 0;
+
+	for (i = 0; i < NES_UD_MAX_NIC_CNT; i++) {
+		if (pRsc->nics[i].file->active &&
+		    pRsc->nics[i].queue_type == queue_type)
+			count++;
+	}
+	return count;
+}
+
+/*
+ * the function locates the entry allocated by IGMP and modifies the
+ * PFT entry with the list of the NICs allowed to receive that multicast
+ * the NIC0/NIC1 are removed due to performance issue so tcpdum
+ * like tools cannot receive the accelerated multicasts
+ */
+static void mcast_fix_filter_table_single(struct nes_ud_file *file, u8 *addr)
+{
+  struct nes_device *nesdev = file->nesvnic->nesdev;
+  int i = 0;
+  u32 macaddr_low;
+  u32 orig_low;
+  u32 macaddr_high;
+  u32 prev_high;
+
+  for (i = 0; i < 48; i++) {
+	macaddr_low = nes_read_indexed(nesdev,
+					NES_IDX_PERFECT_FILTER_LOW + i*8);
+	orig_low = macaddr_low;
+	macaddr_high = nes_read_indexed(nesdev,
+					NES_IDX_PERFECT_FILTER_LOW + 4 + i*8);
+	if (!(macaddr_high & NES_MAC_ADDR_VALID))
+		continue;
+	if ((macaddr_high & 0xffff) != 0x0100)
+		continue;
+	if ((macaddr_low & 0xff) != addr[2])
+		continue;
+	macaddr_low >>= 8;
+	if ((macaddr_low & 0xff) != addr[1])
+		continue;
+	macaddr_low >>= 8;
+	if ((macaddr_low & 0xff) != addr[0])
+		continue;
+	macaddr_low >>= 8;
+	if ((macaddr_low & 0xff) != 0x5e)
+		continue;
+	/* hit - that means Linux or other UD set this bit earlier  */
+	prev_high = macaddr_high;
+	nes_write_indexed(nesdev, NES_IDX_PERFECT_FILTER_LOW + 4 + i*8, 0);
+	macaddr_high = (macaddr_high & 0xfffcffff) |
+					((1<<file->nes_ud_nic_index) << 16);
+
+	nes_debug(NES_DBG_UD, "%s(%d) found addr to fix, "
+		 "i=%d, macaddr_high=0x%x  macaddr_low=0x%x "
+		 "nic_idx=%d prev_high=0x%x\n",
+		 __func__, __LINE__, i, macaddr_high, orig_low,
+		file->nes_ud_nic_index, prev_high);
+	nes_write_indexed(nesdev,
+			NES_IDX_PERFECT_FILTER_LOW + 4 + i*8, macaddr_high);
+	break;
+  }
+}
+
+/* this function is implemented that way because the Linux multicast API
+   use the multicast list approach. When a new multicast address is added
+   all PFT table is reinitialized by linux and all entries must be fixed
+   by this procedure
+*/
+static void mcast_fix_filter_table(struct nes_ud_file *file)
+{
+	int i;
+	struct nes_ud_resources *pRsc;
+
+	pRsc = locate_ud_adapter(file->nesvnic->nesdev->nesadapter);
+	if (pRsc == NULL)
+		return;
+
+	for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++) {
+		if (pRsc->mcast[i].in_use != 0)
+			mcast_fix_filter_table_single(pRsc->mcast[i].owner,
+							pRsc->mcast[i].addr);
+	}
+}
+
+/* function invalidates the PFT entry */
+static void remove_mcast_from_pft(struct nes_ud_file *file, u8 *addr)
+{
+  struct nes_device *nesdev = file->nesvnic->nesdev;
+  int i = 0;
+   u32 macaddr_low;
+  u32 orig_low;
+  u32 macaddr_high;
+  u32 prev_high;
+
+  for (i = 0; i < 48; i++) {
+	macaddr_low = nes_read_indexed(nesdev,
+					NES_IDX_PERFECT_FILTER_LOW + i*8);
+	orig_low = macaddr_low;
+	macaddr_high = nes_read_indexed(nesdev,
+					NES_IDX_PERFECT_FILTER_LOW + 4 + i*8);
+	if (!(macaddr_high & NES_MAC_ADDR_VALID))
+		continue;
+
+	if ((macaddr_high & 0xffff) != 0x0100)
+		continue;
+	if ((macaddr_low & 0xff) != addr[2])
+		continue;
+	macaddr_low >>= 8;
+	if ((macaddr_low & 0xff) != addr[1])
+		continue;
+	macaddr_low >>= 8;
+	if ((macaddr_low & 0xff) != addr[0])
+		continue;
+	macaddr_low >>= 8;
+	if ((macaddr_low & 0xff) != 0x5e)
+		continue;
+	/* hit - that means Linux or other UD set this bit earlier */
+	/* so remove the NIC from MAC address reception */
+	prev_high = macaddr_high;
+	macaddr_high = (macaddr_high & 0xfffcffff) &
+					~((1<<file->nes_ud_nic_index) << 16);
+	nes_debug(NES_DBG_UD, "%s(%d) found addr to mcast remove,"
+		"i=%d, macaddr_high=0x%x  macaddr_low=0x%x "
+		"nic_idx=%d prev_high=0x%x\n", __func__, __LINE__, i,
+		macaddr_high, orig_low, file->nes_ud_nic_index, prev_high);
+	nes_write_indexed(nesdev, NES_IDX_PERFECT_FILTER_LOW + 4 + i*8,
+							macaddr_high);
+	break;
+	}
+
+}
+
+/*
+* the function returns a mask of the NICs
+* assotiated with given multicast address
+*/
+static int nes_ud_mcast_filter(struct nes_vnic *nesvnic, __u8 *dmi_addr)
+{
+	int i = 0;
+	int ret = 0;
+	int mask = 0;
+	struct nes_ud_resources *pRsc;
+
+	pRsc = locate_ud_adapter(nesvnic->nesdev->nesadapter);
+	if (pRsc == NULL)
+		return 0;
+
+	for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++) {
+		if (pRsc->mcast[i].in_use &&
+		    pRsc->mcast[i].addr[0] == dmi_addr[3] &&
+		    pRsc->mcast[i].addr[1] == dmi_addr[4] &&
+		    pRsc->mcast[i].addr[2] == dmi_addr[5]) {
+			mask = (pRsc->mcast[i].owner->mcast_mode ==
+				NES_UD_MCAST_PFT_MODE) ?
+				pRsc->mcast[i].owner->nes_ud_nic_index : 0;
+
+			ret = ret | (1 << mask);
+			nes_debug(NES_DBG_UD, "mcast filter, "
+				"fpr=%02X%02X%02X ret=%d\n",
+				dmi_addr[3], dmi_addr[4], dmi_addr[5], ret);
+		}
+	}
+	if (ret == 0)
+		return -1;
+	else
+		return ret;
+
+}
+
+static __u32 mqueue_key[4] = { 0x0, 0x80, 0x0, 0x0 };
+
+static inline __u8 nes_ud_calculate_hash(__u8 dest_addr_lsb)
+{
+  __u8 in[8];
+  __u32 key_arr[4];
+  int i;
+  __u32 result = 0;
+  int j, k;
+  __u8 shift_in, next_shift_in;
+
+  in[0] = 0;
+  in[1] = 0;
+  in[2] = 0;
+  in[3] = 0;
+
+  in[4] = 0;
+
+  in[5] = 0;
+  in[6] = 0;
+  in[7] = dest_addr_lsb;
+
+
+
+	for (i = 0; i < 4; i++)
+		key_arr[3-i] = mqueue_key[i];
+
+
+
+	for (i = 0; i < 8; i++) {
+		for (j = 7; j >= 0; j--) {
+			if (in[i] & (1 << j))
+				result = result ^ key_arr[0];
+
+			shift_in = 0;
+			for (k = 3; k >= 0; k--) {
+				next_shift_in = key_arr[k] >> 31;
+				key_arr[k] = (key_arr[k] << 1) + shift_in;
+				shift_in = next_shift_in;
+			}
+		}
+	}
+	return result & 0x7f;
+}
+
+static inline void nes_ud_enable_mqueue(struct nes_ud_file *file)
+{
+	struct nes_device *nesdev = file->nesvnic->nesdev;
+	int mqueue_config0;
+	int mqueue_config2;
+	int instance = file->nes_ud_nic_index & 0x1;
+
+	mqueue_config0 = nes_read_indexed(nesdev, 0x6400);
+	mqueue_config0 |= (4 | (instance & 0x3)) << (file->nes_ud_nic_index*3);
+	nes_write_indexed(nesdev, 0x6400, mqueue_config0);
+	mqueue_config0 = nes_read_indexed(nesdev, 0x6400);
+
+	mqueue_config2 = nes_read_indexed(nesdev, 0x6408);
+	mqueue_config2 |= (2 << (instance*2)) | (6 << (instance*3+8));
+	nes_write_indexed(nesdev, 0x6408, mqueue_config2);
+	mqueue_config2 = nes_read_indexed(nesdev, 0x6408);
+
+	nes_write_indexed(nesdev, 0x64a0+instance*0x100, mqueue_key[0]);
+	nes_write_indexed(nesdev, 0x64a4+instance*0x100, mqueue_key[1]);
+	nes_write_indexed(nesdev, 0x64a8+instance*0x100, mqueue_key[2]);
+	nes_write_indexed(nesdev, 0x64ac+instance*0x100, mqueue_key[3]);
+
+	nes_debug(NES_DBG_UD, "mq_config0=0x%x mq_config2=0x%x nic_idx= %d\n",
+		  mqueue_config0, mqueue_config2, file->nes_ud_nic_index);
+
+}
+
+
+
+static inline
+void nes_ud_redirect_from_mqueue(struct nes_ud_file *file, int num_queues)
+{
+	struct nes_device *nesdev = file->nesvnic->nesdev;
+	int instance = file->nes_ud_nic_index & 0x1;
+	unsigned addr = 0x6420+instance*0x100;
+	unsigned value;
+	int i;
+
+	value  = (file->prio == NES_UD_DEV_PRIO_LOW || num_queues == 1) ?
+							0x0 : 0x11111111;
+	for (i = 0; i < 16; i++)
+		nes_write_indexed(nesdev, addr+i*4, value);
+}
+
+
+static int nes_ud_create_nic(struct nes_ud_file *file)
+{
+	struct nes_vnic *nesvnic = file->nesvnic;
+	struct nes_device *nesdev = nesvnic->nesdev;
+	struct nes_hw_nic_qp_context *nic_context;
+	struct nes_hw_cqp_wqe *cqp_wqe;
+	struct nes_cqp_request *cqp_request;
+	unsigned long flags;
+	void *vmem;
+	dma_addr_t pmem;
+	u64 u64temp;
+	int ret = 0;
+
+	BUG_ON(file->nic_vbase != NULL);
+
+	file->nic_mem_size = 256 +
+			(NES_NIC_WQ_SIZE * sizeof(struct nes_hw_nic_sq_wqe)) +
+			sizeof(struct nes_hw_nic_qp_context);
+
+	file->nic_vbase = pci_alloc_consistent(nesdev->pcidev,
+						file->nic_mem_size,
+						&file->nic_pbase);
+	if (!file->nic_vbase) {
+		nes_debug(NES_DBG_UD, "Unable to allocate memory for NIC host "
+			"descriptor rings\n");
+		return -ENOMEM;
+	}
+
+	memset(file->nic_vbase, 0, file->nic_mem_size);
+
+	vmem = (void *)(((unsigned long long)file->nic_vbase + (256 - 1)) &
+			~(unsigned long long)(256 - 1));
+	pmem = (dma_addr_t)(((unsigned long long)file->nic_pbase + (256 - 1)) &
+			~(unsigned long long)(256 - 1));
+
+	file->wq_vbase = vmem;
+	file->wq_pbase = pmem;
+	file->head = 0;
+	file->tail = 0;
+
+	vmem += (NES_NIC_WQ_SIZE * sizeof(struct nes_hw_nic_sq_wqe));
+	pmem += (NES_NIC_WQ_SIZE * sizeof(struct nes_hw_nic_sq_wqe));
+
+	cqp_request = nesvnic->get_cqp_request(nesdev);
+	if (cqp_request == NULL) {
+		nes_debug(NES_DBG_QP, "Failed to get a cqp_request.\n");
+		goto fail_cqp_req_alloc;
+	}
+	cqp_request->waiting = 1;
+	cqp_wqe = &cqp_request->cqp_wqe;
+
+	cqp_wqe->wqe_words[NES_CQP_WQE_OPCODE_IDX] =
+			cpu_to_le32(NES_CQP_CREATE_QP | NES_CQP_QP_TYPE_NIC);
+	cqp_wqe->wqe_words[NES_CQP_WQE_ID_IDX] = cpu_to_le32(file->qpn);
+	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_CTX_LOW_IDX] =
+			cpu_to_le32((u32)((u64)(&nesdev->cqp)));
+	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_CTX_HIGH_IDX] =
+			cpu_to_le32((u32)(((u64)(&nesdev->cqp))>>32));
+	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_SCRATCH_LOW_IDX] = 0;
+	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_SCRATCH_HIGH_IDX] = 0;
+
+
+	nic_context = vmem;
+
+	nic_context->context_words[NES_NIC_CTX_MISC_IDX] =
+			cpu_to_le32((u32)NES_NIC_CTX_SIZE |
+			((u32)PCI_FUNC(nesdev->pcidev->devfn) << 12) |
+			(1 << 18));
+
+	nic_context->context_words[NES_NIC_CTX_SQ_LOW_IDX] = 0;
+	nic_context->context_words[NES_NIC_CTX_SQ_HIGH_IDX] = 0;
+	nic_context->context_words[NES_NIC_CTX_RQ_LOW_IDX] = 0;
+	nic_context->context_words[NES_NIC_CTX_RQ_HIGH_IDX] = 0;
+
+	u64temp = (u64)file->wq_pbase;
+	if (file->queue_type == NES_UD_SEND_QUEUE) {
+		nic_context->context_words[NES_NIC_CTX_SQ_LOW_IDX] =
+						cpu_to_le32((u32)u64temp);
+		nic_context->context_words[NES_NIC_CTX_SQ_HIGH_IDX] =
+					cpu_to_le32((u32)(u64temp >> 32));
+	} else {
+		nic_context->context_words[NES_NIC_CTX_RQ_LOW_IDX] =
+						cpu_to_le32((u32)u64temp);
+		nic_context->context_words[NES_NIC_CTX_RQ_HIGH_IDX] =
+					cpu_to_le32((u32)(u64temp >> 32));
+	}
+
+	u64temp = (u64)pmem;
+
+	cqp_wqe->wqe_words[NES_CQP_QP_WQE_CONTEXT_LOW_IDX] =
+						cpu_to_le32((u32)u64temp);
+	cqp_wqe->wqe_words[NES_CQP_QP_WQE_CONTEXT_HIGH_IDX] =
+					cpu_to_le32((u32)(u64temp >> 32));
+
+	atomic_set(&cqp_request->refcount, 2);
+	nesvnic->post_cqp_request(nesdev, cqp_request);
+
+	/* Wait for CQP */
+	ret = wait_event_timeout(cqp_request->waitq,
+				(cqp_request->request_done != 0),
+				NES_EVENT_TIMEOUT);
+	if (!ret)
+		nes_debug(NES_DBG_UD, "NES_UD NIC QP%u "
+			"create timeout expired\n", file->qpn);
+
+
+	if (atomic_dec_and_test(&cqp_request->refcount)) {
+		if (cqp_request->dynamic) {
+			kfree(cqp_request);
+		} else {
+			spin_lock_irqsave(&nesdev->cqp.lock, flags);
+			list_add_tail(&cqp_request->list,
+						&nesdev->cqp_avail_reqs);
+			spin_unlock_irqrestore(&nesdev->cqp.lock, flags);
+		}
+	}
+	nes_debug(NES_DBG_UD, "Created NIC, qpn=%d, SQ/RQ pa=0x%p va=%p "
+		"virt_to_phys=%p\n", file->qpn,
+		(void *)file->wq_pbase, (void *)file->nic_vbase,
+		(void *)virt_to_phys(file->nic_vbase));
+	return ret;
+
+ fail_cqp_req_alloc:
+	pci_free_consistent(nesdev->pcidev, file->nic_mem_size, file->nic_vbase,
+			file->nic_pbase);
+	file->nic_vbase = NULL;
+	return -EFAULT;
+}
+
+
+static void nes_ud_destroy_nic(struct nes_ud_file *file)
+{
+	struct nes_vnic *nesvnic = file->nesvnic;
+	struct nes_device *nesdev = nesvnic->nesdev;
+	struct nes_hw_cqp_wqe *cqp_wqe;
+	struct nes_cqp_request *cqp_request;
+	unsigned long flags;
+	int ret = 0;
+
+	cqp_request = nesvnic->get_cqp_request(nesdev);
+	if (cqp_request == NULL) {
+		nes_debug(NES_DBG_QP, "Failed to get a cqp_request.\n");
+		return;
+	}
+	cqp_request->waiting = 1;
+	cqp_wqe = &cqp_request->cqp_wqe;
+
+	cqp_wqe->wqe_words[NES_CQP_WQE_OPCODE_IDX] =
+			cpu_to_le32(NES_CQP_DESTROY_QP | NES_CQP_QP_TYPE_NIC);
+	cqp_wqe->wqe_words[NES_CQP_WQE_ID_IDX] = cpu_to_le32(file->qpn);
+	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_CTX_LOW_IDX] =
+			cpu_to_le32((u32)((u64)(&nesdev->cqp)));
+	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_CTX_HIGH_IDX] =
+			cpu_to_le32((u32)(((u64)(&nesdev->cqp)) >> 32));
+	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_SCRATCH_LOW_IDX] = 0;
+	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_SCRATCH_HIGH_IDX] = 0;
+
+	atomic_set(&cqp_request->refcount, 2);
+	nesvnic->post_cqp_request(nesdev, cqp_request);
+
+	/* Wait for CQP */
+	ret = wait_event_timeout(cqp_request->waitq,
+			(cqp_request->request_done != 0),
+			NES_EVENT_TIMEOUT);
+	if (!ret)
+		nes_debug(NES_DBG_UD, "NES_UD NIC QP%u "
+			"destroy timeout expired\n", file->qpn);
+
+	if (atomic_dec_and_test(&cqp_request->refcount)) {
+		if (cqp_request->dynamic) {
+			kfree(cqp_request);
+		} else {
+			spin_lock_irqsave(&nesdev->cqp.lock, flags);
+			list_add_tail(&cqp_request->list,
+					&nesdev->cqp_avail_reqs);
+			spin_unlock_irqrestore(&nesdev->cqp.lock, flags);
+		}
+	}
+
+	pci_free_consistent(nesdev->pcidev, file->nic_mem_size, file->nic_vbase,
+			file->nic_pbase);
+	file->nic_vbase = NULL;
+	file->qp_ptr = NULL;
+
+	return;
+}
+
+static void nes_ud_free_resources(struct nes_ud_file *file)
+{
+	struct nes_device *nesdev = file->nesvnic->nesdev;
+	int nic_active = 0;
+	int mcast_all = 0;
+	int mcast_en = 0;
+	int wqm_config0 = 0;
+	wait_queue_head_t     waitq;
+	int num_queues  = 0;
+	nes_debug(NES_DBG_UD, " %s(%d) NAME=%s nes_ud_qpid=%d\n",
+		__func__, __LINE__, file->ifrn_name, file->qpn);
+
+	if (!file->nesvnic || !file->active)
+		return;
+
+	if (file->queue_type == NES_UD_SEND_QUEUE) {
+		nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
+		nic_active &= ~(1 << file->nes_ud_nic_index);
+		nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
+		nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
+	} else {
+		num_queues = count_files_by_nic(file->nesvnic,
+						file->queue_type);
+
+	if (num_queues == 1) {
+
+		nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
+		nic_active &= ~(1 << file->nes_ud_nic_index);
+		nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
+		nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
+
+		mcast_all = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
+		mcast_all &= ~(1 << file->nes_ud_nic_index);
+		nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, mcast_all);
+		mcast_all = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
+
+		mcast_en = nes_read_indexed(nesdev,
+						NES_IDX_NIC_MULTICAST_ENABLE);
+		mcast_en &= ~(1 << file->nes_ud_nic_index);
+		nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE,
+								mcast_en);
+		mcast_en = nes_read_indexed(nesdev,
+						NES_IDX_NIC_MULTICAST_ENABLE);
+
+		nes_debug(NES_DBG_UD, "nic_active=0x%x, mcast_en=0x%x, "
+			"mcast_all=0x%x nic_index=%d num_queues=%d\n",
+			nic_active, mcast_en, mcast_all,
+			file->nes_ud_nic_index, num_queues);
+	  }
+
+	 nes_ud_redirect_from_mqueue(file, num_queues);
+	 num_queues = count_files(file->nesvnic, file->queue_type);
+	if (num_queues == 1) {
+		nes_debug(NES_DBG_UD, "Last receive queue, "
+			"restoring MPP debug register\n");
+		nes_write_indexed(nesdev, 0xA00, 0x200);
+		nes_write_indexed(nesdev, 0xA40, 0x200);
+	  }
+	}
+
+
+
+	nes_ud_destroy_nic(file);
+
+	if (file->queue_type == NES_UD_RECV_QUEUE) {
+		wqm_config0 = nes_read_indexed(nesdev, 0x5000);
+		wqm_config0 &= ~0x8000;
+		nes_write_indexed(nesdev, 0x5000, wqm_config0);
+
+		init_waitqueue_head(&waitq);
+
+		wait_event_timeout(waitq, 0, NES_UD_CLEANUP_TIMEOUT);
+
+		nes_debug(NES_DBG_UD, "%s(%d) enabling stall_no_wqes\n",
+			__func__, __LINE__);
+		wqm_config0 = nes_read_indexed(nesdev, 0x5000);
+		wqm_config0 |= 0x8000;
+		nes_write_indexed(nesdev, 0x5000, wqm_config0);
+	}
+
+	dev_put(file->nesvnic->netdev);
+
+	file->active = 0;
+
+	nes_debug(NES_DBG_UD, "%s(%d) done\n", __func__, __LINE__);
+}
+
+
+static int nes_ud_init_channel(struct nes_ud_file *file)
+{
+	struct nes_device *nesdev = NULL;
+	int ret = 0;
+	int nic_active = 0;
+	int mcast_all = 0;
+	int mcast_en = 0;
+	int link_ag = 0;
+	int mpp4_dbg = 0;
+
+	nesdev = file->nesvnic->nesdev;
+
+	ret = nes_ud_create_nic(file);
+	if (ret != 0)
+		return ret;
+
+	if (file->queue_type == NES_UD_RECV_QUEUE) {
+
+		file->nesvnic->mcrq_mcast_filter = nes_ud_mcast_filter;
+
+		mcast_en = nes_read_indexed(nesdev,
+					NES_IDX_NIC_MULTICAST_ENABLE);
+		mcast_en |= 1 << file->nes_ud_nic_index;
+		nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE,
+								mcast_en);
+		mcast_en = nes_read_indexed(nesdev,
+					NES_IDX_NIC_MULTICAST_ENABLE);
+
+		/* the only case when we use PFT is for single port
+		two functions, which probably would be the
+		most common usage model :), but anyway */
+	if (file->mcast_mode == NES_UD_MCAST_ALL_MODE) {
+		mcast_all = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
+		mcast_all |= 1 << file->nes_ud_nic_index;
+		nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, mcast_all);
+		mcast_all = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
+	}
+	if (nesdev->nesadapter->port_count <= 2) {
+		link_ag = 0x00;
+		nes_write_indexed(nesdev, 0x6038, link_ag);
+		link_ag = nes_read_indexed(nesdev, 0x6038);
+	}
+	if (nesdev->nesadapter->netdev_count <= 2)
+		nes_ud_enable_mqueue(file);
+
+	nes_write_indexed(nesdev, 0xA00, 0x245);
+	nes_write_indexed(nesdev, 0xA40, 0x245);
+
+	}
+	/* NES_UD_SEND_QUEUE */
+	else {
+		mpp4_dbg = nes_read_indexed(nesdev, 0xb00);
+		mpp4_dbg |= 1 << 12;
+		nes_write_indexed(nesdev, 0xb00, mpp4_dbg);
+		mpp4_dbg = nes_read_indexed(nesdev, 0xb00);
+	}
+
+	nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
+	nic_active |= 1 << file->nes_ud_nic_index;
+	nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
+	nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
+
+	nes_debug(NES_DBG_UD, "nic_active=0x%x, mcast_en=0x%x, "
+		"mcast_all=0x%x nic_index=%d link_ag=0x%x mpp4_dbg=0x%x\n",
+		nic_active, mcast_en, mcast_all, file->nes_ud_nic_index,
+		link_ag, mpp4_dbg);
+
+	return ret;
+}
+
+static struct nes_ud_file *nes_ud_get_nxt_channel(struct nes_vnic *nesvnic,
+					enum nes_ud_queue_type queue_type)
+{
+	struct nes_ud_file *file = NULL;
+	struct net_device *netdev = NULL;
+	struct nes_device *nesdev = NULL;
+	struct nes_ud_resources *pRsc;
+
+	netdev = nesvnic->netdev;
+	nesdev = nesvnic->nesdev;
+
+	pRsc = locate_ud_adapter(nesdev->nesadapter);
+	if (pRsc == NULL) {
+		pRsc = allocate_ud_adapter(nesdev->nesadapter);
+		if (pRsc == NULL)
+			return NULL;
+
+	}
+	if (pRsc->num_logport_confed == 0) {
+		pRsc->original_60b8 = nes_read_indexed(nesdev, 0x60b8);
+		pRsc->original_6000 = nes_read_indexed(nesdev, 0x6000);
+		/* everything goes to port 0x0 */
+		if ((nesvnic->nesdev->nesadapter->port_count == 1) ||
+		    (nes_drv_opt & NES_DRV_OPT_MCAST_LOGPORT_MAP)) {
+			/* single port card or dual port using single if */
+			pRsc->num_logport_confed = 0x3;
+			pRsc->logport_2_map = 0x0;
+			pRsc->logport_3_map = 0x0;
+			nes_write_indexed(nesdev, 0x60b8, 0x3);
+			nes_write_indexed(nesdev, 0x6000, 0x0);
+		} else {
+			pRsc->num_logport_confed = 0x3;
+			pRsc->logport_2_map = 0x0;
+			pRsc->logport_3_map = 0x1;
+		}
+		nes_debug(NES_DBG_UD, "%s(%d) num_logport_confed=%d "
+			"original_6000=%d logport_3_map = %d nes_drv_opt=%x\n",
+			__func__, __LINE__, pRsc->num_logport_confed,
+			pRsc->original_6000, pRsc->logport_3_map, nes_drv_opt);
+	}
+
+	nes_debug(NES_DBG_UD, "%s(%d) logport_2_map=%d logport_3_map=%d\n",
+		 __func__, __LINE__, pRsc->logport_2_map, pRsc->logport_3_map);
+
+	file = allocate_nic_queue(nesvnic, queue_type);
+	if (file == NULL) {
+		nes_debug(NES_DBG_UD, "%s(%d) failed to allocate NIC\n",
+			__func__, __LINE__);
+		return NULL;
+	}
+
+	file->active = 1;
+	memcpy(file->ifrn_name, netdev->name, IFNAMSIZ);
+
+	/* for now use pft always */
+	file->mcast_mode = NES_UD_MCAST_PFT_MODE;
+
+	nes_debug(NES_DBG_UD, " %s(%d) NAME=%s qpn=%d nes_ud_nic_index=%d "
+		"nes_ud_nic.qp_id=%d mcast_mode=%d port_count=%d "
+		"netdev_count=%d\n", __func__, __LINE__, file->ifrn_name,
+		 file->qpn, file->nes_ud_nic_index, file->nesvnic->mcrq_qp_id,
+		 file->mcast_mode, nesdev->nesadapter->port_count,
+		nesdev->nesadapter->netdev_count);
+
+	file->mss = netdev->mtu-28;
+	pRsc->num_allocated_nics++;
+	BUG_ON(pRsc->num_allocated_nics > 8);
+
+	return file;
+
+}
+
+static struct nes_ud_mem_region *nes_ud_allocate_mr(u32 npages)
+{
+	struct nes_ud_mem_region *mr = NULL;
+
+	mr = vmalloc(sizeof(*mr));
+	if (mr == NULL)
+		return NULL;
+
+
+	mr->addrs = vmalloc(npages * sizeof(dma_addr_t));
+	if (!mr->addrs) {
+		nes_debug(NES_DBG_UD, "%s(%d) Cannot allocate mr struct "
+		"for %d pages\n", __func__, __LINE__, npages);
+		vfree(mr);
+		return NULL;
+	}
+	mr->pg_cnt = npages;
+	mr->in_use = 1;
+
+	INIT_LIST_HEAD(&mr->list);
+
+	return mr;
+}
+
+static void nes_ud_free_mr(struct nes_ud_mem_region *mr)
+{
+	if (mr->addrs != NULL)
+		vfree(mr->addrs);
+
+	vfree(mr);
+}
+
+/* nes_ud_get_hash_entry()
+ *
+ * function returns a key for hash table
+ */
+static inline
+int nes_ud_get_hash_entry(u32 stag)
+{
+	return stag & 0xff;
+}
+
+
+/* nes_ud_lookup_mr()
+ *
+ * function returns a pointer to mr realized by specific STAG
+ */
+static inline
+struct nes_ud_mem_region *nes_ud_lookup_mr(u32 stag)
+{
+	int key;
+	struct nes_ud_mem_region *mr;
+
+	key = nes_ud_get_hash_entry(stag);
+
+	list_for_each_entry(mr, &ud_mem.mrs[key].list, list) {
+		ud_mem.mrs[key].read_stats++;
+		if (mr->stag == stag)
+			return mr;
+
+	}
+	return NULL;
+}
+
+/* nes_ud_add_mr_hash()
+ *
+ * the function inserts the mr entry into the hash list
+ * the stag is a key
+ */
+static inline
+int nes_ud_add_mr_hash(struct nes_ud_mem_region *mr)
+{
+	int key;
+
+	/* first check if the stag is unique */
+	if (nes_ud_lookup_mr(mr->stag) != NULL) {
+		nes_debug(NES_DBG_UD, "%s(%d) double STAG error stag=%x\n",
+			__func__, __LINE__, mr->stag);
+		return -1;
+	}
+	key = nes_ud_get_hash_entry(mr->stag);
+
+	/* structure is global so mutexes are necessary */
+	mutex_lock(&ud_mem.mutex);
+
+	/* add mr to the list at start  */
+	list_add(&mr->list, &ud_mem.mrs[key].list);
+
+	mutex_unlock(&ud_mem.mutex);
+
+	return 0;
+
+}
+
+/* nes_ud_del_mr()
+ *
+ * the function removes the entry from the hash list
+ * the stag is the key
+ */
+static inline
+void nes_ud_del_mr(struct nes_ud_mem_region *mr)
+{
+	/* structure is global so mutexes are necessary */
+	mutex_lock(&ud_mem.mutex);
+
+	list_del(&mr->list);
+
+	/* init entry */
+	INIT_LIST_HEAD(&mr->list);
+
+	mutex_unlock(&ud_mem.mutex);
+}
+
+/* nes_ud_cleanup_mr()
+ *
+ * function deletes and and frees all hash entries
+ */
+static inline
+void nes_ud_cleanup_mr(void)
+{
+	struct nes_ud_mem_region *mr;
+	struct nes_ud_mem_region *next;
+	int i;
+
+	/* structure is global so mutexes are necessary */
+	mutex_lock(&ud_mem.mutex);
+
+	for (i = 0; i < NES_UD_MAX_REG_HASH_CNT; i++) {
+		if (list_empty(&ud_mem.mrs[i].list))
+			continue;
+
+		list_for_each_entry_safe(mr, next, &ud_mem.mrs[i].list, list) {
+			nes_debug(NES_DBG_UD, "%s(%d) non free stag=%x\n",
+				__func__, __LINE__, mr->stag);
+			list_del_init(&mr->list);
+
+			nes_ud_free_mr(mr);
+		}
+	}
+
+	mutex_unlock(&ud_mem.mutex);
+}
+
+u32 nes_ud_reg_mr(struct ib_umem *region, u64 length, u64 virt, u32 stag)
+{
+	unsigned long npages =
+		PAGE_ALIGN(region->length + region->offset) >> PAGE_SHIFT;
+	struct nes_ud_mem_region *mr = nes_ud_allocate_mr(npages);
+	struct ib_umem_chunk *chunk;
+	dma_addr_t page;
+	u32 chunk_pages = 0;
+	int nmap_index;
+	int i = 0;
+	int mr_id = 0;
+	nes_debug(NES_DBG_UD, "%s(%d) mr=%p length=%d virt=%p\n",
+		__func__, __LINE__, mr, (int)length, (void *)virt);
+	if (!mr)
+		return 0;
+
+
+	mr->stag = stag;
+
+	mr->va = virt;
+	mr->length = length;
+	list_for_each_entry(chunk, &region->chunk_list, list) {
+	for (nmap_index = 0; nmap_index < chunk->nmap; ++nmap_index) {
+		page = sg_dma_address(&chunk->page_list[nmap_index]);
+		chunk_pages = sg_dma_len(&chunk->page_list[nmap_index]) >> 12;
+		if (page & ~PAGE_MASK)
+			goto reg_user_mr_err;
+		if (!chunk_pages)
+			goto reg_user_mr_err;
+
+		for (i = 0; i < chunk_pages; i++) {
+			mr->addrs[mr_id] = page;
+			page += PAGE_SIZE;
+			if (++mr_id > npages)
+				goto reg_user_mr_err;
+			}
+		}
+	}
+	nes_debug(NES_DBG_UD, "%s(%d) stag=0x%x mr_id=%d npages=%d\n",
+		__func__, __LINE__, stag, mr_id, (int)npages);
+	nes_ud_add_mr_hash(mr);
+	return stag;
+
+reg_user_mr_err:
+	if (mr)
+		nes_ud_free_mr(mr);
+
+	return 0;
+}
+
+
+int nes_ud_dereg_mr(u32 stag)
+{
+	struct nes_ud_mem_region *mr = NULL;
+
+	nes_debug(NES_DBG_UD, "%s(%d) stag=0x%x\n", __func__, __LINE__, stag);
+
+	mr = nes_ud_lookup_mr(stag);
+	if (mr != NULL) {
+		nes_ud_del_mr(mr);
+		nes_ud_free_mr(mr);
+	} else {
+		nes_debug(NES_DBG_UD, "%s(%d) unknown stag=0x%x\n",
+		__func__, __LINE__, stag);
+	}
+
+	nes_debug(NES_DBG_UD, "%s(%d) done\n", __func__, __LINE__);
+	return 0;
+}
+
+
+int nes_ud_unsubscribe_mcast(struct nes_ud_file *file, union ib_gid *gid)
+{
+	int ret = 0;
+	int i;
+	struct nes_ud_resources *pRsc;
+
+	if (file->queue_type == NES_UD_SEND_QUEUE)
+		return -EFAULT;
+
+	pRsc = locate_ud_adapter(file->nesvnic->nesdev->nesadapter);
+	if (pRsc == NULL)
+		return -EFAULT;
+
+	for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++) {
+		if (pRsc->mcast[i].in_use &&
+			pRsc->mcast[i].owner == file &&
+			pRsc->mcast[i].addr[0] == gid->raw[13] &&
+			pRsc->mcast[i].addr[1] == gid->raw[14] &&
+			pRsc->mcast[i].addr[2] == gid->raw[15]) {
+				pRsc->mcast[i].in_use = 0;
+				goto out;
+		}
+	}
+
+	ret = -EFAULT;
+out:
+	nes_debug(NES_DBG_UD, "%s(%d) %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X \
+		ret=%d mcast=%d\n", __func__, __LINE__, gid->raw[10],
+		gid->raw[11], gid->raw[12], gid->raw[13], gid->raw[14],
+		gid->raw[15], ret , i);
+	return ret;
+
+}
+
+/* function returns a number of allocated multicast entries in given adapter */
+static int get_mcast_number_alloced(struct nes_ud_resources *pRsc)
+{
+	int i;
+	int no = 0;
+
+	for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++) {
+		if (pRsc->mcast[i].in_use != 0)
+			no++;
+
+	}
+	return no;
+}
+
+/* function subscribe a multicast group in the system - PFT modification */
+int nes_ud_subscribe_mcast(struct nes_ud_file *file, union ib_gid *gid)
+{
+	struct nes_device *nesdev = file->nesvnic->nesdev;
+	int ret = 0;
+	int i;
+	__u8 hash_idx = 0;
+	__u8 instance = file->nes_ud_nic_index & 0x1;
+	unsigned addr = 0;
+	unsigned mqueue_ind_tbl;
+	struct nes_ud_resources *pRsc;
+
+	struct net_device *netdev = file->nesvnic->netdev;
+	struct dev_mc_list *mc_list;
+	int	multicast_address_exist = 0;
+
+
+	if (file->queue_type == NES_UD_SEND_QUEUE)
+		return -EFAULT;
+
+	pRsc = locate_ud_adapter(nesdev->nesadapter);
+	if (pRsc == NULL)
+		return -EFAULT;
+
+	for (mc_list = netdev->mc_list;
+		mc_list != NULL;
+		mc_list = mc_list->next) {
+		if (mc_list != NULL) {
+			if ((mc_list->dmi_addr[3] == gid->raw[13]) &&
+			    (mc_list->dmi_addr[4] == gid->raw[14]) &&
+			    (mc_list->dmi_addr[5] == gid->raw[15]) &&
+			    (mc_list->dmi_addr[0] == 0x01) &&
+			    (mc_list->dmi_addr[1] == 0) &&
+			    (mc_list->dmi_addr[2] == 0x5e)) {
+				multicast_address_exist = 1;
+				break;
+			}
+		} else {
+			break;
+		}
+	}
+
+	if (multicast_address_exist == 0) {
+		nes_debug(NES_DBG_UD, "WARNING: multicast address not exist "
+			"on multicast list\n");
+		return -EFAULT;
+	}
+
+	/* first check that we have not subecribed to this mcast address, yet */
+	for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++) {
+		if ((pRsc->mcast[i].in_use > 0) &&
+		    (pRsc->mcast[i].addr[0] == gid->raw[13]) &&
+		    (pRsc->mcast[i].addr[1] == gid->raw[14]) &&
+		    (pRsc->mcast[i].addr[2] == gid->raw[15])) {
+			if (pRsc->mcast[i].owner == file) {
+				nes_debug(NES_DBG_UD, "WARNING - subscribing  "
+				"mcast to the same nes_ud more than once\n");
+				break;
+			} else {
+		/* receiving the same multicast on different NICs is allowed:
+			1. when two different NICS are used
+			2.  exactly one QP exists on this adapter
+			3. The existing QP was allocated as first
+				or the second in the system
+		  */
+			if (pRsc->mcast[i].owner->nes_ud_nic_index !=
+						file->nes_ud_nic_index) {
+				if (get_mcast_number_alloced(pRsc) == 1) {
+					if ((i == 0) || (i == 1)) {
+						/* add the mask of other nics
+						that subscribe this address  */
+						break;
+					}
+				}
+			}
+			nes_debug(NES_DBG_UD, "ERROR - subscribing same mcast "
+				"to the diff nes_ud's and NIC  owner_idx = %d "
+				"file_idx = %d\n",
+				pRsc->mcast[i].owner->nes_ud_nic_index,
+				file->nes_ud_nic_index);
+			ret = -EFAULT;
+		    }
+		    goto out;
+		}
+	}
+
+	for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++) {
+		if (!pRsc->mcast[i].in_use) {
+			pRsc->mcast[i].addr[0] = gid->raw[13];
+			pRsc->mcast[i].addr[1] = gid->raw[14];
+			pRsc->mcast[i].addr[2] = gid->raw[15];
+			pRsc->mcast[i].owner = file;
+			pRsc->mcast[i].in_use = 1;
+
+			hash_idx =
+				nes_ud_calculate_hash(pRsc->mcast[i].addr[2]);
+
+			addr = 0x6420 + ((hash_idx >> 3) << 2) + instance*0x100;
+			mqueue_ind_tbl = nes_read_indexed(nesdev, addr);
+			if (file->prio == NES_UD_DEV_PRIO_HIGH)
+				mqueue_ind_tbl &= ~(1 << ((hash_idx & 0x7)*4));
+			else
+				mqueue_ind_tbl |= 1 << ((hash_idx & 0x7)*4);
+
+			nes_write_indexed(nesdev, addr, mqueue_ind_tbl);
+			mqueue_ind_tbl = nes_read_indexed(nesdev, addr);
+
+			nes_debug(NES_DBG_UD, "%s(%d) addr=0x%x "
+				 "mqueue_ind_tbl=0x%x hash=0x%x, mac=0x%x\n",
+				__func__, __LINE__, addr, mqueue_ind_tbl,
+				hash_idx, pRsc->mcast[i].addr[2]);
+			/* take care of the case when linux join_mcast
+			is called before mcast_attach in that case our pft
+			will already be programmed with that mcast address,
+			just with wrong NIC we need just to find an address,
+			and fix the NIC additionally the mask with other NICs
+			that subscribed the address are added*/
+
+			mcast_fix_filter_table(file);
+			goto out;
+		}
+	}
+	ret = -EFAULT;
+
+out:
+
+	nes_debug(NES_DBG_UD, "%s(%d) %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X \
+		ret=%d\n", __func__, __LINE__, gid->raw[10], gid->raw[11],
+		gid->raw[12], gid->raw[13], gid->raw[14], gid->raw[15], ret);
+
+	return ret;
+}
+
+
+static inline
+int nes_ud_post_recv(struct nes_ud_file *file,
+			u32 adap_no,
+			struct nes_ud_recv_wr *nes_ud_wr)
+{
+	struct nes_hw_nic_rq_wqe *nic_rqe;
+	struct nes_hw_nic_rq_wqe *rq_vbase =
+				(struct nes_hw_nic_rq_wqe *)file->wq_vbase;
+	struct nes_device *nesdev = file->nesvnic->nesdev;
+	u16 *wqe_fragment_length = NULL;
+	u32 mr_offset;
+	u32 page_offset;
+	u32 page_id;
+	struct nes_ud_mem_region *mr = NULL;
+	int remaining_length = 0;
+	int wqe_fragment_index = 0;
+	int err = 0;
+	int i = 0;
+	struct nes_ud_resources *pRsc;
+
+	/* check if qp is activated */
+	if (file->active == 0)
+		return -EFAULT;
+
+	pRsc = &nes_ud_rsc[adap_no];
+
+	/* let's assume for now that max sge count is 1 */
+	for (i = 0; i < nes_ud_wr->wr_cnt; i++) {
+		nic_rqe = &rq_vbase[file->head];
+
+		mr = nes_ud_lookup_mr(nes_ud_wr->sg_list[i].lkey);
+		if (mr == NULL)
+			return -EFAULT;
+
+
+		if (mr->va > nes_ud_wr->sg_list[i].addr ||
+		    (nes_ud_wr->sg_list[i].addr + nes_ud_wr->sg_list[i].length >
+							mr->va + mr->length)) {
+			err = -EFAULT;
+			goto out;
+		}
+
+		mr_offset = nes_ud_wr->sg_list[i].addr - mr->va;
+		page_offset = nes_ud_wr->sg_list[i].addr & ~PAGE_MASK;
+		page_id = ((mr->va & ~PAGE_MASK) + mr_offset) >> PAGE_SHIFT;
+
+		wqe_fragment_length =
+		(u16 *)&nic_rqe->wqe_words[NES_NIC_RQ_WQE_LENGTH_1_0_IDX];
+
+		remaining_length = nes_ud_wr->sg_list[i].length;
+		wqe_fragment_index = 0;
+
+		while (remaining_length > 0) {
+			if (wqe_fragment_index >= 4) {
+				err = -EFAULT;
+				goto out;
+			}
+
+			set_wqe_64bit_value(nic_rqe->wqe_words,
+			NES_NIC_RQ_WQE_FRAG0_LOW_IDX + 2*wqe_fragment_index,
+				  mr->addrs[page_id]+page_offset);
+
+		      wqe_fragment_length[wqe_fragment_index] =
+				cpu_to_le16(PAGE_SIZE - page_offset);
+
+		      remaining_length -= PAGE_SIZE - page_offset;
+		      page_offset = 0;
+		      page_id++;
+		      wqe_fragment_index++;
+		}
+
+		nes_write32(nesdev->regs+NES_WQE_ALLOC, (1 << 24) |  file->qpn);
+
+		file->head = (file->head+1) & ~NES_NIC_WQ_SIZE;
+	}
+out:
+	return err;
+}
+
+static inline
+int nes_ud_post_send(struct nes_ud_file *file,
+			u32 adap_no,
+			struct nes_ud_send_wr *nes_ud_wr)
+{
+	struct nes_hw_nic_sq_wqe *nic_sqe;
+	struct nes_hw_nic_sq_wqe *sq_vbase =
+			(struct nes_hw_nic_sq_wqe *)file->wq_vbase;
+	struct nes_device *nesdev = file->nesvnic->nesdev;
+	u16 *wqe_fragment_length = NULL;
+	u32 mr_offset;
+	u32 page_offset;
+	u32 page_id;
+	struct nes_ud_mem_region *mr = NULL;
+	int remaining_length = 0;
+	int wqe_fragment_index = 0;
+	int err = 0;
+	int misc_flags = NES_NIC_SQ_WQE_COMPLETION;
+	int i = 0;
+	struct nes_ud_resources *pRsc;
+
+	/* check if qp is activated */
+	if (file->active == 0)
+		return -EFAULT;
+
+	pRsc = &nes_ud_rsc[adap_no];
+
+	/* check if is not set checksum */
+	if (!(nes_ud_wr->flags & IB_SEND_IP_CSUM))
+		misc_flags |= NES_NIC_SQ_WQE_DISABLE_CHKSUM;
+
+	/* let's assume for now that max sge count is 1 */
+	for (i = 0; i < nes_ud_wr->wr_cnt; i++) {
+		nic_sqe = &sq_vbase[file->head];
+
+		mr = nes_ud_lookup_mr(nes_ud_wr->sg_list[i].lkey);
+		if (mr == NULL)
+			return -EFAULT;
+
+
+		if ((mr->va > nes_ud_wr->sg_list[i].addr) ||
+		     (nes_ud_wr->sg_list[i].addr+nes_ud_wr->sg_list[i].length >
+							mr->va + mr->length)) {
+
+			err = -EFAULT;
+			goto out;
+		}
+
+		mr_offset = nes_ud_wr->sg_list[i].addr - mr->va;
+		page_offset = nes_ud_wr->sg_list[i].addr & ~PAGE_MASK;
+		page_id = ((mr->va & ~PAGE_MASK) + mr_offset) >> PAGE_SHIFT;
+
+		wqe_fragment_length =
+		(u16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
+
+		wqe_fragment_length++; /* skip vlan tag */
+		remaining_length = nes_ud_wr->sg_list[i].length;
+		wqe_fragment_index = 0;
+
+		while (remaining_length > 0) {
+			if (wqe_fragment_index >= 4) {
+				err = -EFAULT;
+				goto out;
+			}
+			set_wqe_64bit_value(nic_sqe->wqe_words,
+				NES_NIC_SQ_WQE_FRAG0_LOW_IDX +
+						2*wqe_fragment_index,
+				mr->addrs[page_id]+page_offset);
+		      wqe_fragment_length[wqe_fragment_index] =
+				cpu_to_le16(PAGE_SIZE - page_offset);
+		      remaining_length -= PAGE_SIZE - page_offset;
+		      page_offset = 0;
+		      page_id++;
+		      wqe_fragment_index++;
+		}
+		nic_sqe->wqe_words[NES_IWARP_SQ_WQE_TOTAL_PAYLOAD_IDX] =
+				cpu_to_le32(nes_ud_wr->sg_list[i].length);
+		nic_sqe->wqe_words[NES_NIC_SQ_WQE_MISC_IDX] =
+						cpu_to_le32(misc_flags);
+
+		nes_write32(nesdev->regs+NES_WQE_ALLOC,
+					(1 << 24) | (1 << 23) | file->qpn);
+
+		file->head = (file->head+1) & ~NES_NIC_WQ_SIZE;
+	}
+out:
+	return err;
+}
+
+
+
+static void nes_ud_mcast_cleanup_work(struct nes_ud_file *file)
+{
+	int i = 0;
+	int num_queues = count_files_by_nic(file->nesvnic, file->queue_type);
+	struct nes_ud_resources *pRsc;
+
+	pRsc = locate_ud_adapter(file->nesvnic->nesdev->nesadapter);
+	if (pRsc == NULL)
+		return;
+
+
+	nes_debug(NES_DBG_UD, "%s(%d) file->rsc_idx=%d\n",
+			__func__, __LINE__, file->rsc_idx);
+
+	mutex_lock(&pRsc->mutex);
+	for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++) {
+		if (pRsc->mcast[i].owner == file) {
+			nes_debug(NES_DBG_UD, "%s(%d) mcast cleared idx=%d "
+				"%2.2X:%2.2X:%2.2X\n", __func__, __LINE__,
+				i, pRsc->mcast[i].addr[0],
+				pRsc->mcast[i].addr[1],
+				pRsc->mcast[i].addr[2]);
+
+			pRsc->mcast[i].in_use = 0;
+			remove_mcast_from_pft(file, pRsc->mcast[i].addr);
+		}
+	}
+
+	if (del_rsc_list(file) == 0) {
+		if (num_queues == 1)
+			file->nesvnic->mcrq_mcast_filter = NULL;
+
+	}
+	mutex_unlock(&pRsc->mutex);
+}
+
+struct nes_ud_file *nes_ud_create_wq(struct nes_vnic *nesvnic, int isrecv)
+{
+	struct nes_ud_file *file;
+	int ret = 0;
+	file = nes_ud_get_nxt_channel(nesvnic, (isrecv) ?
+				NES_UD_RECV_QUEUE : NES_UD_SEND_QUEUE);
+	if (!file)
+		return NULL;
+
+
+	ret =  nes_ud_init_channel(file);
+	if (ret != 0) {
+		del_rsc_list(file);
+		return NULL;
+	}
+
+	dev_hold(file->nesvnic->netdev);
+
+	nes_debug(NES_DBG_UD, "%s(%d) file=%p\n", __func__, __LINE__, file);
+	return file;
+}
+
+
+
+int nes_ud_destroy_wq(struct nes_ud_file *file)
+{
+	struct nes_ud_resources *pRsc;
+	int count = 0;
+	int i;
+	pRsc = locate_ud_adapter(file->nesvnic->nesdev->nesadapter);
+	if (pRsc == NULL)
+		return -EFAULT;
+
+	if (file->active) {
+		nes_ud_mcast_cleanup_work(file);
+		nes_ud_free_resources(file);
+	}
+
+	/* check if the the adapter has any queues */
+	for (i = 0; i < NES_UD_MAX_NIC_CNT; i++) {
+		if (pRsc->nics[i].file->active != 0)
+			count++;
+
+	}
+	if (count == 0) {
+		nes_debug(NES_DBG_UD, "%s(%d) adapter %d "
+				"is ready to next use\n",
+				__func__, __LINE__, pRsc->adapter_no);
+		pRsc->pAdap = NULL;
+	}
+	nes_debug(NES_DBG_UD, "%s(%d) done\n", __func__, __LINE__);
+	return 0;
+}
+
+
+struct nes_ud_sksq_file {
+	unsigned long shared_page;
+	struct nes_ud_file *nes_ud_send_file;
+	struct nes_ud_file *nes_ud_recv_file;
+};
+
+static ssize_t nes_ud_sksq_write(struct file *filp, const char __user *buf,
+		size_t len, loff_t *pos)
+{
+	struct nes_ud_sksq_file *file = filp->private_data;
+	struct nes_ud_send_wr *nes_ud_wr =
+			(struct nes_ud_send_wr *)file->shared_page;
+	u32 adap_no;
+	u32 nic_no;
+
+	nic_no = ((nes_ud_wr->qpn >> 16) & 0x0f00) >> 8;
+	adap_no = ((nes_ud_wr->qpn >> 16) & 0xf000) >> 12;
+	if (unlikely(!file->nes_ud_send_file)) {
+		struct nes_ud_file *nes_ud_file = NULL;
+
+	nes_ud_file = nes_ud_rsc[adap_no].nics[nic_no].file;
+	/* the nic must be active and previously activated */
+	if ((nes_ud_file->active == 0) ||
+		(nes_ud_file->qpn != ((nes_ud_wr->qpn >> 16) & 0xff)))
+			return -EAGAIN;
+
+		file->nes_ud_send_file = nes_ud_file;
+		nes_debug(NES_DBG_UD, "send shared page addr = %p "
+				"adap_no = %d nic_no=%d qpn=%x\n",
+				nes_ud_wr, adap_no, nic_no, nes_ud_wr->qpn);
+  }
+  return nes_ud_post_send(file->nes_ud_send_file, adap_no, nes_ud_wr);
+
+}
+
+static ssize_t nes_ud_sksq_read(struct file *filp, char __user *buf,
+		size_t len, loff_t *pos)
+{
+	struct nes_ud_sksq_file *file = filp->private_data;
+	struct nes_ud_recv_wr *nes_ud_recv_wr;
+	u32 adap_no;
+	u32 nic_no;
+
+	nes_ud_recv_wr = (struct nes_ud_recv_wr *)(file->shared_page+2048);
+	adap_no = (nes_ud_recv_wr->qpn & 0xf000) >> 12;
+	nic_no = (nes_ud_recv_wr->qpn & 0x0f00) >> 8;
+
+	if (unlikely(!file->nes_ud_recv_file)) {
+		struct nes_ud_file *nes_ud_file = NULL;
+
+		nes_ud_file = nes_ud_rsc[adap_no].nics[nic_no].file;
+		/* the nic must be active and previously activated */
+		if ((nes_ud_file->active == 0) ||
+			(nes_ud_file->qpn != (nes_ud_recv_wr->qpn & 0xff)))
+				return -EAGAIN;
+
+		file->nes_ud_recv_file  = nes_ud_file;
+		nes_debug(NES_DBG_UD, "recv shared page addr = %p "
+				"adap_no = %d nic_no=%d qpn=%x\n",
+			nes_ud_recv_wr, adap_no, nic_no, nes_ud_recv_wr->qpn);
+	}
+	return nes_ud_post_recv(file->nes_ud_recv_file,
+				adap_no, nes_ud_recv_wr);
+}
+
+static int nes_ud_sksq_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+	struct nes_ud_sksq_file *file = filp->private_data;
+
+	nes_debug(NES_DBG_UD, "shared mem pgprot_val(prot)=0x%x pa=%p\n",
+			(unsigned int)pgprot_val(vma->vm_page_prot),
+			(void *)virt_to_phys((void *)file->shared_page));
+	if (remap_pfn_range(vma, vma->vm_start,
+			virt_to_phys((void *)file->shared_page) >> PAGE_SHIFT,
+			 PAGE_SIZE, vma->vm_page_prot)) {
+		printk(KERN_ERR "remap_pfn_range failed.\n");
+		return -EAGAIN;
+	}
+	return 0;
+}
+
+
+static int nes_ud_sksq_open(struct inode *inode, struct file *filp)
+{
+	struct nes_ud_sksq_file *file;
+
+	file = kmalloc(sizeof *file, GFP_KERNEL);
+	if (!file)
+		return -ENOMEM;
+
+	memset(file, 0, sizeof *file);
+	nes_debug(NES_DBG_UD, "%s(%d) file=%p\n",
+			__func__, __LINE__, file);
+
+	filp->private_data = file;
+	file->nes_ud_send_file = NULL;
+	file->nes_ud_recv_file = NULL;
+
+	file->shared_page = __get_free_page(GFP_USER);
+	return 0;
+}
+
+static int nes_ud_sksq_close(struct inode *inode, struct file *filp)
+{
+
+	struct nes_ud_sksq_file *file = filp->private_data;
+
+	if (file->shared_page) {
+		free_page(file->shared_page);
+		file->shared_page = 0;
+	}
+	kfree(file);
+	return 0;
+}
+
+static const struct file_operations nes_ud_sksq_fops = {
+	.owner = THIS_MODULE,
+	.open = nes_ud_sksq_open,
+	.release = nes_ud_sksq_close,
+	.write = nes_ud_sksq_write,
+	.read = nes_ud_sksq_read,
+	.mmap = nes_ud_sksq_mmap,
+};
+
+
+static struct miscdevice nes_ud_sksq_misc = {
+	.minor = MISC_DYNAMIC_MINOR,
+	.name = "nes_ud_sksq",
+	.fops = &nes_ud_sksq_fops,
+};
+
+/*
+ * function replaces the CQ pointer in QP stored in the file
+ * the QP must have a valid CQ pointers assotiated with it
+ */
+int nes_ud_cq_replace(struct nes_vnic *nesvnic, struct nes_cq *cq)
+{
+	u32 cq_num;
+	struct nes_ud_file *file;
+	struct nes_ud_resources *pRsc;
+
+	BUG_ON(!cq);
+
+	pRsc = locate_ud_adapter(nesvnic->nesdev->nesadapter);
+	if (pRsc == NULL)
+		return -EFAULT;
+
+
+	/* now create a QP number on base cq and adapter no */
+	cq_num = cq->hw_cq.cq_number;
+
+	nes_debug(NES_DBG_UD, "%s(%d) cq_number=%d\n",
+			__func__, __LINE__, cq_num);
+
+	/* the QP number should have the same number like CQ number */
+	file = get_file_by_qpn(pRsc, cq_num);
+	if (!file) {
+		nes_debug(NES_DBG_UD, "%s(%d) file not found\n",
+				__func__, __LINE__);
+		return -EFAULT;
+	}
+	if (file->qp_ptr) {
+		if (file->queue_type == NES_UD_RECV_QUEUE) {
+			nes_debug(NES_DBG_UD, "%s(%d) RECV file found "
+			"old=%p new=%p\n", __func__, __LINE__,
+			file->qp_ptr->ibqp.recv_cq, cq);
+			file->qp_ptr->ibqp.recv_cq = &cq->ibcq;
+		}
+		if (file->queue_type == NES_UD_SEND_QUEUE) {
+			nes_debug(NES_DBG_UD, "%s(%d) SEND file found "
+			"old=%p new=%p\n", __func__, __LINE__,
+			file->qp_ptr->ibqp.send_cq, cq);
+
+			file->qp_ptr->ibqp.send_cq = &cq->ibcq;
+		}
+	}
+	return 0;
+}
+int nes_ud_init(void)
+{
+	int i = 0;
+	int adap_no;
+	struct nes_ud_resources *pRsc;
+
+	nes_debug(NES_DBG_UD, "%s(%d)\n", __func__, __LINE__);
+
+	/* the memory registration is global for all NICS */
+	memset(&ud_mem, 0, sizeof(ud_mem));
+
+	/* init hash list of memory entries */
+	for (i = 0; i < NES_UD_MAX_REG_HASH_CNT; i++) {
+		INIT_LIST_HEAD(&ud_mem.mrs[i].list);
+		ud_mem.mrs[i].read_stats = 0;
+	}
+	mutex_init(&ud_mem.mutex);
+
+	/*allocate resources fro each adapter */
+	for (adap_no = 0; adap_no < NES_UD_MAX_ADAPTERS; adap_no++) {
+		pRsc = &nes_ud_rsc[adap_no];
+
+		memset(pRsc, 0, sizeof(*pRsc));
+
+		mutex_init(&pRsc->mutex);
+
+		pRsc->adapter_no = adap_no;
+		pRsc->pAdap = NULL;
+
+		pRsc->num_logport_confed = 0;
+		pRsc->num_allocated_nics = 0;
+		pRsc->logport_2_map = 0xf;
+		pRsc->logport_3_map = 0xf;
+		for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++)
+			pRsc->mcast[i].in_use = 0;
+
+		pRsc->nics[0].qpn = 20;
+		pRsc->nics[0].nic_index = 2;
+		pRsc->nics[0].logical_port = 2;
+		pRsc->nics[0].prio = NES_UD_DEV_PRIO_HIGH;
+		pRsc->nics[0].queue_type = NES_UD_RECV_QUEUE;
+		pRsc->nics[0].file = &pRsc->nics[0].file_body;
+
+		pRsc->nics[1].qpn = 22;
+		pRsc->nics[1].nic_index = 3;
+		pRsc->nics[1].logical_port = 3;
+		pRsc->nics[1].prio = NES_UD_DEV_PRIO_HIGH;
+		pRsc->nics[1].queue_type = NES_UD_RECV_QUEUE;
+		pRsc->nics[1].file = &pRsc->nics[1].file_body;
+
+		pRsc->nics[2].qpn = 21;
+		pRsc->nics[2].nic_index = 2;
+		pRsc->nics[2].logical_port = 2;
+		pRsc->nics[2].prio = NES_UD_DEV_PRIO_LOW;
+		pRsc->nics[2].queue_type = NES_UD_RECV_QUEUE;
+		pRsc->nics[2].file = &pRsc->nics[2].file_body;
+
+		pRsc->nics[3].qpn = 23;
+		pRsc->nics[3].nic_index = 3;
+		pRsc->nics[3].logical_port = 3;
+		pRsc->nics[3].prio = NES_UD_DEV_PRIO_LOW;
+		pRsc->nics[3].queue_type = NES_UD_RECV_QUEUE;
+		pRsc->nics[3].file = &pRsc->nics[3].file_body;
+
+		pRsc->nics[4].qpn = 26;
+		pRsc->nics[4].nic_index = 6;
+		pRsc->nics[4].logical_port = 2;
+		pRsc->nics[4].prio = NES_UD_DEV_PRIO_HIGH;
+		pRsc->nics[4].queue_type = NES_UD_SEND_QUEUE;
+		pRsc->nics[4].file = &pRsc->nics[4].file_body;
+
+		pRsc->nics[5].qpn = 27;
+		pRsc->nics[5].nic_index = 7;
+		pRsc->nics[5].logical_port = 3;
+		pRsc->nics[5].prio = NES_UD_DEV_PRIO_HIGH;
+		pRsc->nics[5].queue_type = NES_UD_SEND_QUEUE;
+		pRsc->nics[5].file = &pRsc->nics[5].file_body;
+
+		pRsc->nics[6].qpn = 30;
+		pRsc->nics[6].nic_index = 10;
+		pRsc->nics[6].logical_port = 2;
+		pRsc->nics[6].prio = NES_UD_DEV_PRIO_LOW;
+		pRsc->nics[6].queue_type = NES_UD_SEND_QUEUE;
+		pRsc->nics[6].file = &pRsc->nics[6].file_body;
+
+		pRsc->nics[7].qpn = 31;
+		pRsc->nics[7].nic_index = 11;
+		pRsc->nics[7].logical_port = 3;
+		pRsc->nics[7].prio = NES_UD_DEV_PRIO_LOW;
+		pRsc->nics[7].queue_type = NES_UD_SEND_QUEUE;
+		pRsc->nics[7].file = &pRsc->nics[7].file_body;
+
+	}
+	nes_ud_workqueue = create_singlethread_workqueue("nes_ud");
+
+	return misc_register(&nes_ud_sksq_misc);
+}
+
+
+int nes_ud_exit(void)
+{
+	/* clean memory hash list */
+	nes_ud_cleanup_mr();
+	misc_deregister(&nes_ud_sksq_misc);
+	return 0;
+}
+
diff --git a/drivers/infiniband/hw/nes/nes_ud.h b/drivers/infiniband/hw/nes/nes_ud.h
new file mode 100644
index 0000000..5a03b33
--- /dev/null
+++ b/drivers/infiniband/hw/nes/nes_ud.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2008 - 2010 Intel Corporation.  All rights reserved.
+ * Copyright (c) 2006 - 2008 Neteffect, All rights reserved.
+ * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - 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.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef __NES_UD_H
+#define __NES_UD_H
+
+enum nes_ud_dev_priority {
+	NES_UD_DEV_PRIO_HIGH,
+	NES_UD_DEV_PRIO_LOW,
+};
+
+enum nes_ud_queue_type {
+  NES_UD_RECV_QUEUE,
+  NES_UD_SEND_QUEUE,
+};
+
+enum nes_ud_mcast_mode {
+  NES_UD_MCAST_ALL_MODE,
+  NES_UD_MCAST_PFT_MODE,
+};
+
+
+struct nes_ud_file {
+	struct nes_vnic *nesvnic;
+	u8 active;
+	char ifrn_name[IFNAMSIZ];
+	int nes_ud_nic_index;
+	int qpn;
+	enum nes_ud_dev_priority prio;
+	enum nes_ud_mcast_mode mcast_mode;
+	enum nes_ud_queue_type queue_type;
+	void      *nic_vbase;
+	dma_addr_t nic_pbase;
+	int        nic_mem_size;
+	void      *wq_vbase;
+	dma_addr_t wq_pbase;
+	int mss;
+	struct delayed_work mcast_cleanup_work;
+	int head;
+	int tail;
+	u32 rsc_idx;
+	struct nes_qp *qp_ptr; /* it is association used for CQ replacement */
+	u32 adapter_no;    /* assotiation to allocated adapter */
+};
+
+int nes_ud_init(void);
+int nes_ud_exit(void);
+struct nes_ud_file *nes_ud_create_wq(struct nes_vnic *nesvnic, int isrecv);
+int nes_ud_destroy_wq(struct nes_ud_file *file);
+u32 nes_ud_reg_mr(struct ib_umem *region, u64 length, u64 virt, u32 stag);
+int nes_ud_dereg_mr(u32 stag);
+int nes_ud_subscribe_mcast(struct nes_ud_file *file, union ib_gid *gid);
+int nes_ud_unsubscribe_mcast(struct nes_ud_file *file, union ib_gid *gid);
+int nes_ud_cq_replace(struct nes_vnic *nesvnic, struct nes_cq *cq);
+
+#endif
diff --git a/drivers/infiniband/hw/nes/nes_verbs.c b/drivers/infiniband/hw/nes/nes_verbs.c
index e54f312..ff39235 100644
--- a/drivers/infiniband/hw/nes/nes_verbs.c
+++ b/drivers/infiniband/hw/nes/nes_verbs.c
@@ -46,6 +46,8 @@
 
 #include <rdma/ib_umem.h>
 
+#include "nes_ud.h"
+
 atomic_t mod_qp_timouts;
 atomic_t qps_created;
 atomic_t sw_qps_destroyed;
@@ -1139,7 +1141,6 @@ static struct ib_qp *nes_create_qp(struct ib_pd *ibpd,
 	if (init_attr->create_flags)
 		return ERR_PTR(-EINVAL);
 
-	atomic_inc(&qps_created);
 	switch (init_attr->qp_type) {
 		case IB_QPT_RC:
 			if (nes_drv_opt & NES_DRV_OPT_NO_INLINE_DATA) {
@@ -1405,10 +1406,122 @@ static struct ib_qp *nes_create_qp(struct ib_pd *ibpd,
 					nesqp->hwqp.qp_id, nesqp, (u32)sizeof(*nesqp));
 			spin_lock_init(&nesqp->lock);
 			nes_add_ref(&nesqp->ibqp);
+			/* moved here to be sure that QP is really created */
+			/*(now it counted a number of QP creation trials */
+			atomic_inc(&qps_created);
 			break;
-		default:
-			nes_debug(NES_DBG_QP, "Invalid QP type: %d\n", init_attr->qp_type);
-			return ERR_PTR(-EINVAL);
+
+	case IB_QPT_RAW_ETY:
+	if (!ibpd->uobject)
+		return ERR_PTR(-EINVAL);
+
+	/* we are about to destroy those cqs w/o destroying qp
+	 now free memory for nespbl that is not used
+	 first map nespbl with the qp created */
+	if (ibpd->uobject->context) {
+		nes_ucontext = to_nesucontext(ibpd->uobject->context);
+		if (udata) {
+			if (ib_copy_from_udata(&req,
+				udata,
+				sizeof(struct nes_create_qp_req))) {
+				return ERR_PTR(-EFAULT);
+			}
+			if (req.user_wqe_buffers) {
+				err = 1;
+				list_for_each_entry(nespbl,
+				&nes_ucontext->qp_reg_mem_list,
+				list) {
+					if (nespbl->user_base ==
+						req.user_wqe_buffers) {
+						list_del(&nespbl->list);
+						err = 0;
+						/* done with memory allocated
+						during nes_reg_user_mr() */
+						pci_free_consistent(
+							nesdev->pcidev,
+							nespbl->pbl_size,
+							nespbl->pbl_vbase,
+							nespbl->pbl_pbase);
+						kfree(nespbl);
+						break;
+					}
+				}
+			}
+		}
+	}
+	/* Need 512 (actually now 1024) byte alignment on this structure */
+	mem = kzalloc(sizeof(*nesqp)+NES_SW_CONTEXT_ALIGN-1, GFP_KERNEL);
+	if (!mem) {
+		nes_debug(NES_DBG_UD, "Unable to allocate QP\n");
+		return ERR_PTR(-ENOMEM);
+	}
+	u64nesqp = (unsigned long)mem;
+	u64nesqp += ((u64)NES_SW_CONTEXT_ALIGN) - 1;
+	u64temp = ((u64)NES_SW_CONTEXT_ALIGN) - 1;
+	u64nesqp &= ~u64temp;
+	nesqp = (struct nes_qp *)(unsigned long)u64nesqp;
+	nesqp->allocated_buffer = mem;
+
+	nesqp->rx_ud_wq = nes_ud_create_wq(nesvnic, 1);
+	nesqp->tx_ud_wq = nes_ud_create_wq(nesvnic, 0);
+	if ((!nesqp->rx_ud_wq) || (!nesqp->tx_ud_wq)) {
+		kfree(nesqp->allocated_buffer);
+		return ERR_PTR(-EFAULT);
+	}
+
+	/* create association between qp and tx/rx files
+	 it is used when CQ is replaced from user space */
+	nesqp->rx_ud_wq->qp_ptr = nesqp;
+	nesqp->tx_ud_wq->qp_ptr = nesqp;
+
+	sq_size = init_attr->cap.max_send_wr;
+	rq_size = init_attr->cap.max_recv_wr;
+	nes_debug(NES_DBG_UD, "%s(%d) sq_size=%d rq_size=%d\n",
+				__func__,
+				__LINE__, sq_size, rq_size);
+	uresp.actual_sq_size = sq_size;
+	uresp.actual_rq_size = rq_size;
+
+	/* Init qp size due to ibv_query_qp requirements */
+	nesqp->hwqp.sq_size = sq_size;
+	nesqp->hwqp.rq_size = rq_size;
+
+	/* enhance the response qp number with adapter number and QP number
+	on this adapter
+	 user space will use this identifier when packets will be posted */
+	uresp.qp_id = nesqp->rx_ud_wq->qpn |
+			(nesqp->rx_ud_wq->adapter_no << 12) |
+			(nesqp->rx_ud_wq->rsc_idx << 8);
+	uresp.qp_id = uresp.qp_id |
+			((nesqp->tx_ud_wq->qpn |
+			(nesqp->tx_ud_wq->adapter_no << 12) |
+			(nesqp->tx_ud_wq->rsc_idx << 8)) << 16);
+
+	nesqp->hwqp.qp_id = uresp.qp_id;
+	nesqp->ibqp.qp_num = uresp.qp_id;
+
+	nes_debug(NES_DBG_UD, "%s(%d) qpid=0x%x\n",
+			__func__, __LINE__, uresp.qp_id);
+	if (ib_copy_to_udata(udata, &uresp, sizeof uresp)) {
+		kfree(nesqp->allocated_buffer);
+		return ERR_PTR(-EFAULT);
+	}
+	/* the usecount is decreased because without it
+	the cq re-creation in user-spce will fail */
+	atomic_dec(&init_attr->send_cq->usecnt);
+	atomic_dec(&init_attr->recv_cq->usecnt);
+	nes_add_ref(&nesqp->ibqp);
+	spin_lock_init(&nesqp->lock);
+
+	/* moved here to be sure that QP is really created
+	(now it counted a number of QP creation trials */
+	atomic_inc(&qps_created);
+	return &nesqp->ibqp;
+
+	default:
+		nes_debug(NES_DBG_QP, "Invalid QP type: %d\n",
+					init_attr->qp_type);
+		return ERR_PTR(-EINVAL);
 	}
 
 	nesqp->sig_all = (init_attr->sq_sig_type == IB_SIGNAL_ALL_WR);
@@ -1462,6 +1575,8 @@ static void nes_clean_cq(struct nes_qp *nesqp, struct nes_cq *nescq)
 static int nes_destroy_qp(struct ib_qp *ibqp)
 {
 	struct nes_qp *nesqp = to_nesqp(ibqp);
+	struct nes_cq *scq;
+	struct nes_cq *rcq;
 	struct nes_ucontext *nes_ucontext;
 	struct ib_qp_attr attr;
 	struct iw_cm_id *cm_id;
@@ -1471,6 +1586,39 @@ static int nes_destroy_qp(struct ib_qp *ibqp)
 	atomic_inc(&sw_qps_destroyed);
 	nesqp->destroyed = 1;
 
+	if (nesqp->ibqp.qp_type == IB_QPT_RAW_ETY) {
+		/* check the QP refernece count */
+		if (atomic_read(&nesqp->refcount) == 0)
+			BUG();
+		if (atomic_dec_and_test(&nesqp->refcount)) {
+			/* destroy send and rcv  QPs */
+			if (nesqp->rx_ud_wq)
+				nes_ud_destroy_wq(nesqp->rx_ud_wq);
+			nesqp->rx_ud_wq = 0;
+
+			if (nesqp->tx_ud_wq)
+				nes_ud_destroy_wq(nesqp->tx_ud_wq);
+			nesqp->tx_ud_wq = 0;
+			atomic_inc(&qps_destroyed);
+
+			/* to prevent the destroy of cq before QP
+			destroy the usecount is used */
+			if (ibqp->send_cq) {
+				scq = to_nescq(ibqp->send_cq);
+				atomic_inc(&ibqp->send_cq->usecnt);
+				atomic_dec(&scq->usecnt);
+			}
+			if (ibqp->recv_cq) {
+				rcq = to_nescq(ibqp->recv_cq);
+				atomic_inc(&ibqp->recv_cq->usecnt);
+				atomic_dec(&rcq->usecnt);
+			}
+			/* free memory for the qp */
+			kfree(nesqp->allocated_buffer);
+		}
+		return 0;
+	}
+
 	/* Blow away the connection if it exists. */
 	if (nesqp->ibqp_state >= IB_QPS_INIT && nesqp->ibqp_state <= IB_QPS_RTS) {
 		/* if (nesqp->ibqp_state == IB_QPS_RTS) { */
@@ -1567,9 +1715,18 @@ static struct ib_cq *nes_create_cq(struct ib_device *ibdev, int entries,
 		return ERR_PTR(-ENOMEM);
 	}
 
+	/* to make sure that RAW ETH cq will be not destoyed
+	without qp destroy the internal usecount is used
+	 the ibcq usecount cannot be used because the  RAW ETH makes
+	recreation of the CQs after QP creation
+	 when this situation occured (mcrqf != 0) the usecount is increase
+	 the ibcq usecount is cleared after successfull CQ creation */
+	atomic_set(&nescq->usecnt, 0);
+
 	nescq->hw_cq.cq_size = max(entries + 1, 5);
 	nescq->hw_cq.cq_number = cq_num;
 	nescq->ibcq.cqe = nescq->hw_cq.cq_size - 1;
+	nescq->mcrqf = 0;
 
 
 	if (context) {
@@ -1586,8 +1743,23 @@ static struct ib_cq *nes_create_cq(struct ib_device *ibdev, int entries,
 				nescq->hw_cq.cq_number = nesvnic->nic.qp_id + 28 + 2 * ((nes_ucontext->mcrqf & 0xf) - 1);
 			else if (nes_ucontext->mcrqf & 0x40000000)
 				nescq->hw_cq.cq_number = nes_ucontext->mcrqf & 0xffff;
+			else if (nes_ucontext->mcrqf & 0x20000000) {
+				/* the cq number is coded
+						adapter:4/nic:4/cq_num:8 */
+				nescq->hw_cq.cq_number =
+						nes_ucontext->mcrqf & 0x00ff;
+
+				/* to prevent the cq destroy before qp destroy
+				the internal usecount is increased
+				in this place it is the  RAW ETH specific CQ
+				(after re-creation)
+				only  RAW ETH type QP destroy can decrease
+				this usecounter */
+				atomic_inc(&nescq->usecnt);
+			}
 			else
 				nescq->hw_cq.cq_number = nesvnic->mcrq_qp_id + nes_ucontext->mcrqf-1;
+
 			nescq->mcrqf = nes_ucontext->mcrqf;
 			nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
 		}
@@ -1776,6 +1948,10 @@ static struct ib_cq *nes_create_cq(struct ib_device *ibdev, int entries,
 			kfree(nescq);
 			return ERR_PTR(-EFAULT);
 		}
+		if (nes_ucontext->mcrqf & 0x20000000) {
+			/* change the cq address only for  RAW in QP pointer */
+			nes_ud_cq_replace(nesvnic, nescq);
+		}
 	}
 
 	return &nescq->ibcq;
@@ -1805,6 +1981,11 @@ static int nes_destroy_cq(struct ib_cq *ib_cq)
 	nesdev = nesvnic->nesdev;
 	nesadapter = nesdev->nesadapter;
 
+	if (atomic_read(&nescq->usecnt) != 0) {
+		nes_debug(NES_DBG_CQ, "CQ is in use now. %d\n",
+				(int) atomic_read(&nescq->usecnt));
+		return -EBUSY;
+	}
 	nes_debug(NES_DBG_CQ, "Destroy CQ%u\n", nescq->hw_cq.cq_number);
 
 	/* Send DestroyCQ request to CQP */
@@ -2540,6 +2721,13 @@ static struct ib_mr *nes_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
 				nesmr->ibmr.lkey = stag;
 				nesmr->mode = IWNES_MEMREG_TYPE_MEM;
 				ibmr = &nesmr->ibmr;
+				/* register memory parallelly for RAW ETH */
+				if (nes_ud_reg_mr(region, length,
+						virt, stag) == 0) {
+					ib_umem_release(region);
+					kfree(nesmr);
+					ibmr = ERR_PTR(-ENOMEM);
+				}
 			} else {
 				ib_umem_release(region);
 				kfree(nesmr);
@@ -2733,6 +2921,9 @@ static int nes_dereg_mr(struct ib_mr *ib_mr)
 	}
 	nes_free_resource(nesadapter, nesadapter->allocated_mrs,
 			(ib_mr->rkey & 0x0fffff00) >> 8);
+	ret = nes_ud_dereg_mr(ib_mr->rkey);
+	if (ret != 0)
+		return ret;
 
 	kfree(nesmr);
 
@@ -2939,6 +3130,9 @@ int nes_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
 			nesqp->hwqp.qp_id, attr->qp_state, nesqp->ibqp_state,
 			nesqp->iwarp_state, atomic_read(&nesqp->refcount));
 
+	if (ibqp->qp_type == IB_QPT_RAW_ETY)
+		return 0;
+
 	spin_lock_irqsave(&nesqp->lock, qplockflags);
 
 	nes_debug(NES_DBG_MOD_QP, "QP%u: hw_iwarp_state=0x%X, hw_tcp_state=0x%X,"
@@ -3208,8 +3402,10 @@ int nes_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
  */
 static int nes_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 {
-	nes_debug(NES_DBG_INIT, "\n");
-	return -ENOSYS;
+	int ret =  -ENOSYS;
+	struct nes_qp *nesqp = to_nesqp(ibqp);
+	ret =  nes_ud_subscribe_mcast(nesqp->rx_ud_wq, gid);
+	return ret;
 }
 
 
@@ -3218,8 +3414,10 @@ static int nes_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
  */
 static int nes_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 {
-	nes_debug(NES_DBG_INIT, "\n");
-	return -ENOSYS;
+	int ret =  -ENOSYS;
+	struct nes_qp *nesqp = to_nesqp(ibqp);
+	ret =  nes_ud_unsubscribe_mcast(nesqp->rx_ud_wq, gid);
+	return ret;
 }
 
 
@@ -3846,6 +4044,7 @@ struct nes_ib_device *nes_init_ofa_device(struct net_device *netdev)
 		return NULL;
 	}
 	strlcpy(nesibdev->ibdev.name, "nes%d", IB_DEVICE_NAME_MAX);
+	strcpy(nesibdev->ibdev.name, netdev->name);
 	nesibdev->ibdev.owner = THIS_MODULE;
 
 	nesibdev->ibdev.node_type = RDMA_NODE_RNIC;
@@ -3868,6 +4067,9 @@ struct nes_ib_device *nes_init_ofa_device(struct net_device *netdev)
 			(1ull << IB_USER_VERBS_CMD_REQ_NOTIFY_CQ) |
 			(1ull << IB_USER_VERBS_CMD_CREATE_QP) |
 			(1ull << IB_USER_VERBS_CMD_MODIFY_QP) |
+			(1ull << IB_USER_VERBS_CMD_QUERY_QP) |
+			(1ull << IB_USER_VERBS_CMD_ATTACH_MCAST) |
+			(1ull << IB_USER_VERBS_CMD_DETACH_MCAST) |
 			(1ull << IB_USER_VERBS_CMD_POLL_CQ) |
 			(1ull << IB_USER_VERBS_CMD_DESTROY_QP) |
 			(1ull << IB_USER_VERBS_CMD_ALLOC_MW) |
@@ -3911,8 +4113,9 @@ struct nes_ib_device *nes_init_ofa_device(struct net_device *netdev)
 	nesibdev->ibdev.alloc_fast_reg_page_list = nes_alloc_fast_reg_page_list;
 	nesibdev->ibdev.free_fast_reg_page_list = nes_free_fast_reg_page_list;
 
-	nesibdev->ibdev.attach_mcast = nes_multicast_attach;
 	nesibdev->ibdev.detach_mcast = nes_multicast_detach;
+	nesibdev->ibdev.attach_mcast = nes_multicast_attach;
+
 	nesibdev->ibdev.process_mad = nes_process_mad;
 
 	nesibdev->ibdev.req_notify_cq = nes_req_notify_cq;
diff --git a/drivers/infiniband/hw/nes/nes_verbs.h b/drivers/infiniband/hw/nes/nes_verbs.h
index 2df9993..cbb6585 100644
--- a/drivers/infiniband/hw/nes/nes_verbs.h
+++ b/drivers/infiniband/hw/nes/nes_verbs.h
@@ -79,6 +79,7 @@ struct nes_mr {
 	u16               pbls_used;
 	u8                mode;
 	u8                pbl_4k;
+	u32               mcrqf;
 };
 
 struct nes_hw_pb {
@@ -116,7 +117,8 @@ struct nes_cq {
 	spinlock_t       lock;
 	u8               virtual_cq;
 	u8               pad[3];
-	u32		 mcrqf;
+	atomic_t         usecnt;
+	u32              mcrqf;
 };
 
 struct nes_wq {
@@ -130,6 +132,7 @@ struct disconn_work {
 
 struct iw_cm_id;
 struct ietf_mpa_frame;
+struct nes_ud_file;
 
 struct nes_qp {
 	struct ib_qp          ibqp;
@@ -176,5 +179,7 @@ struct nes_qp {
 	u8                    hw_tcp_state;
 	u8                    term_flags;
 	u8                    sq_kmapped;
+	struct nes_ud_file    *rx_ud_wq;
+	struct nes_ud_file    *tx_ud_wq;
 };
 #endif			/* NES_VERBS_H */


--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH 2/2] RDMA/nes: add support of iWARP multicast acceleration over IB_QPT_RAW_ETY QP type

[Steve Wise]

Hey Mirek,

It looks like this patch adds a new file interface for a UD service.  
Why didn't you extend the existing UD interface as needed? 

What IO is supported with these changes?  IMA via the raw QP, but what 
ud_post_send() and friends used for?


Steve.



miroslaw.walukiewicz-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org wrote:
> This patch implements iWarp multicast acceleration (IMA)
> over IB_QPT_RAW_ETY QP type in nes driver.
>
> Application creates a raw eth QP (IBV_QPT_RAW_ETH in user-space) and
> manages the multicast via ibv_attach_mcast and ibv_detach_mcast calls.
>
> Calling ibv_attach_mcast/ibv_datach_mcast has an effect of
> enabling/disabling L2 MAC address filters in HW.
>
> Signed-off-by: Mirek Walukiewicz <miroslaw.walukiewicz-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org>
>
>
>
> ---
>
>  drivers/infiniband/hw/nes/Makefile    |    2 
>  drivers/infiniband/hw/nes/nes.c       |    4 
>  drivers/infiniband/hw/nes/nes.h       |    2 
>  drivers/infiniband/hw/nes/nes_nic.c   |   11 
>  drivers/infiniband/hw/nes/nes_ud.c    | 2070 +++++++++++++++++++++++++++++++++
>  drivers/infiniband/hw/nes/nes_ud.h    |   86 +
>  drivers/infiniband/hw/nes/nes_verbs.c |  221 +++-
>  drivers/infiniband/hw/nes/nes_verbs.h |    7 
>  8 files changed, 2388 insertions(+), 15 deletions(-)
>  create mode 100644 drivers/infiniband/hw/nes/nes_ud.c
>  create mode 100644 drivers/infiniband/hw/nes/nes_ud.h
>
>
> diff --git a/drivers/infiniband/hw/nes/Makefile b/drivers/infiniband/hw/nes/Makefile
> index 3514851..850df8e 100644
> --- a/drivers/infiniband/hw/nes/Makefile
> +++ b/drivers/infiniband/hw/nes/Makefile
> @@ -1,3 +1,3 @@
>  obj-$(CONFIG_INFINIBAND_NES) += iw_nes.o
>  
> -iw_nes-objs := nes.o nes_hw.o nes_nic.o nes_utils.o nes_verbs.o nes_cm.o
> +iw_nes-objs := nes.o nes_hw.o nes_nic.o nes_utils.o nes_verbs.o nes_cm.o nes_ud.o
> diff --git a/drivers/infiniband/hw/nes/nes.c b/drivers/infiniband/hw/nes/nes.c
> index de7b9d7..e430804 100644
> --- a/drivers/infiniband/hw/nes/nes.c
> +++ b/drivers/infiniband/hw/nes/nes.c
> @@ -60,6 +60,8 @@
>  #include <linux/route.h>
>  #include <net/ip_fib.h>
>  
> +#include "nes_ud.h"
> +
>  MODULE_AUTHOR("NetEffect");
>  MODULE_DESCRIPTION("NetEffect RNIC Low-level iWARP Driver");
>  MODULE_LICENSE("Dual BSD/GPL");
> @@ -1205,6 +1207,7 @@ static int __init nes_init_module(void)
>  		if (retval1 < 0)
>  			printk(KERN_ERR PFX "Unable to create NetEffect sys files.\n");
>  	}
> +	nes_ud_init();
>  	return retval;
>  }
>  
> @@ -1214,6 +1217,7 @@ static int __init nes_init_module(void)
>   */
>  static void __exit nes_exit_module(void)
>  {
> +	nes_ud_exit();
>  	nes_cm_stop();
>  	nes_remove_driver_sysfs(&nes_pci_driver);
>  
> diff --git a/drivers/infiniband/hw/nes/nes.h b/drivers/infiniband/hw/nes/nes.h
> index cc78fee..faf420f 100644
> --- a/drivers/infiniband/hw/nes/nes.h
> +++ b/drivers/infiniband/hw/nes/nes.h
> @@ -102,6 +102,7 @@
>  #define NES_DRV_OPT_NO_INLINE_DATA       0x00000080
>  #define NES_DRV_OPT_DISABLE_INT_MOD      0x00000100
>  #define NES_DRV_OPT_DISABLE_VIRT_WQ      0x00000200
> +#define NES_DRV_OPT_MCAST_LOGPORT_MAP    0x00000800
>  
>  #define NES_AEQ_EVENT_TIMEOUT         2500
>  #define NES_DISCONNECT_EVENT_TIMEOUT  2000
> @@ -128,6 +129,7 @@
>  #define NES_DBG_IW_RX       0x00020000
>  #define NES_DBG_IW_TX       0x00040000
>  #define NES_DBG_SHUTDOWN    0x00080000
> +#define NES_DBG_UD          0x00100000
>  #define NES_DBG_RSVD1       0x10000000
>  #define NES_DBG_RSVD2       0x20000000
>  #define NES_DBG_RSVD3       0x40000000
> diff --git a/drivers/infiniband/hw/nes/nes_nic.c b/drivers/infiniband/hw/nes/nes_nic.c
> index b7c813f..c7bbb83 100644
> --- a/drivers/infiniband/hw/nes/nes_nic.c
> +++ b/drivers/infiniband/hw/nes/nes_nic.c
> @@ -897,7 +897,7 @@ static void nes_netdev_set_multicast_list(struct net_device *netdev)
>  			((mc_nic_index = nesvnic->mcrq_mcast_filter(nesvnic,
>  					get_addr(addrs, i++))) == 0));
>  			if (mc_nic_index < 0)
> -				mc_nic_index = nesvnic->nic_index;
> +				mc_nic_index = (1 << nesvnic->nic_index);
>  			while (nesadapter->pft_mcast_map[mc_index] < 16 &&
>  				nesadapter->pft_mcast_map[mc_index] !=
>  					nesvnic->nic_index &&
> @@ -930,7 +930,7 @@ static void nes_netdev_set_multicast_list(struct net_device *netdev)
>  				nes_write_indexed(nesdev,
>  						perfect_filter_register_address+4+(mc_index * 8),
>  						(u32)macaddr_high | NES_MAC_ADDR_VALID |
> -						((((u32)(1<<mc_nic_index)) << 16)));
> +					((((u32)(mc_nic_index)) << 16)));
>  				nesadapter->pft_mcast_map[mc_index] =
>  							nesvnic->nic_index;
>  			} else {
> @@ -1676,8 +1676,11 @@ struct net_device *nes_netdev_init(struct nes_device *nesdev,
>  			(nesvnic->nesdev->nesadapter->port_count == 1 &&
>  			nesvnic->nesdev->nesadapter->adapter_fcn_count == 2)) {
>  				nesvnic->qp_nic_index[0] = nesvnic->nic_index;
> -				nesvnic->qp_nic_index[1] = nesvnic->nic_index
> -									+ 2;
> +
> +			if (nes_drv_opt & NES_DRV_OPT_MCAST_LOGPORT_MAP)
> +				nesvnic->qp_nic_index[1] = 0xf;
> +			else
> +				nesvnic->qp_nic_index[1] = nesvnic->nic_index+2;
>  				nesvnic->qp_nic_index[2] = 0xf;
>  				nesvnic->qp_nic_index[3] = 0xf;
>  		} else {
> diff --git a/drivers/infiniband/hw/nes/nes_ud.c b/drivers/infiniband/hw/nes/nes_ud.c
> new file mode 100644
> index 0000000..f004855
> --- /dev/null
> +++ b/drivers/infiniband/hw/nes/nes_ud.c
> @@ -0,0 +1,2070 @@
> +/*
> + * Copyright (c) 2008 - 2010 Intel Corporation.  All rights reserved.
> + * Copyright (c) 2006 - 2008 Neteffect, All rights reserved.
> + * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
> + *
> + * This software is available to you under a choice of one of two
> + * licenses.  You may choose to be licensed under the terms of the GNU
> + * General Public License (GPL) Version 2, available from the file
> + * COPYING in the main directory of this source tree, or the
> + * OpenIB.org BSD license below:
> + *
> + *     Redistribution and use in source and binary forms, with or
> + *     without modification, are permitted provided that the following
> + *     conditions are met:
> + *
> + *      - Redistributions of source code must retain the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer.
> + *
> + *      - 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.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
> + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
> + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
> + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
> + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
> + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
> + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
> + * SOFTWARE.
> + */
> +
> +#include <linux/version.h>
> +#include <linux/completion.h>
> +#include <linux/mutex.h>
> +#include <linux/poll.h>
> +#include <linux/idr.h>
> +#include <linux/in.h>
> +#include <linux/in6.h>
> +#include <linux/device.h>
> +#include <linux/netdevice.h>
> +#include <linux/list.h>
> +#include <linux/miscdevice.h>
> +#include <linux/device.h>
> +
> +#include <rdma/ib_umem.h>
> +#include <rdma/ib_user_verbs.h>
> +
> +#include "nes.h"
> +#include "nes_ud.h"
> +
> +#define NES_UD_BASE_XMIT_NIC_QPID  28
> +#define NES_UD_BASE_RECV_NIC_IDX   12
> +#define NES_UD_BASE_XMIT_NIC_IDX   8
> +#define NES_UD_MAX_NIC_CNT 8
> +#define NES_UD_CLEANUP_TIMEOUT (HZ)
> +#define NES_UD_MCAST_TBL_SZ 128
> +#define NES_UD_SINGLE_HDR_SZ 64
> +#define NES_UD_CQE_NUM NES_NIC_WQ_SIZE
> +#define NES_UD_SKSQ_WAIT_TIMEOUT	100000
> +#define NES_UD_MAX_REG_CNT 128
> +
> +#define NES_UD_MAX_ADAPTERS 4 /* number of supported interfaces for  RAW ETH */
> +
> +#define NES_UD_MAX_REG_HASH_CNT 256 /* last byte of the STAG is hash key */
> +
> +/*
> + * the same multicast could be allocated up to 2 owners so there could be
> + *  two differentmcast entries allocated for the same mcas address
> + */
> +struct nes_ud_file;
> +struct nes_ud_mcast {
> +	u8 addr[3];
> +	u8 in_use;
> +	struct nes_ud_file *owner;
> +	u8 nic_mask;
> +};
> +
> +struct nes_ud_mem_region {
> +	struct list_head list;
> +	dma_addr_t *addrs;
> +	u64 va;
> +	u64 length;
> +	u32 pg_cnt;
> +	u32 in_use;
> +	u32 stag; /* stag related this structure */
> +};
> +
> +struct nic_queue_info {
> +	u32 qpn;
> +	u32 nic_index;
> +	u32 logical_port;
> +	enum nes_ud_dev_priority prio;
> +	enum nes_ud_queue_type queue_type;
> +	struct nes_ud_file *file;
> +	struct nes_ud_file file_body;
> +};
> +
> +struct nes_ud_resources {
> +	int num_logport_confed;
> +	int num_allocated_nics;
> +	u8 logport_2_map;
> +	u8 logport_3_map;
> +	u32 original_6000;
> +	u32 original_60b8;
> +	struct nic_queue_info nics[NES_UD_MAX_NIC_CNT];
> +	struct mutex          mutex;
> +	struct nes_ud_mcast mcast[NES_UD_MCAST_TBL_SZ];
> +	u32 adapter_no;  /* the allocated adapter no */
> +
> +	/* the unique ID of the NE020 adapter */
> +	/*- it is allocated once per HW */
> +	struct nes_adapter *pAdap;
> +};
> +
> +/* memory hash list entry */
> +struct nes_ud_hash_mem {
> +    struct list_head   list;
> +    int                read_stats;
> +};
> +
> +
> +
> +struct nes_ud_mem {
> +	/* hash list of registered STAGs */
> +	struct nes_ud_hash_mem mrs[NES_UD_MAX_REG_HASH_CNT];
> +	struct mutex          mutex;
> +};
> +
> +/* the QP in format x.y.z where x is adapter no, */
> +/* y is ud file idx in adapter, z is a qp no */
> +static struct nes_ud_mem ud_mem;
> +
> +struct nes_ud_send_wr {
> +    u32               wr_cnt;
> +    u32               qpn;
> +    u32               flags;
> +    u32               resv[1];
> +    struct ib_sge     sg_list[64];
> +};
> +
> +struct nes_ud_recv_wr {
> +    u32               wr_cnt;
> +    u32               qpn;
> +    u32	              resv[2];
> +    struct ib_sge     sg_list[64];
> +};
> +
> +static struct nes_ud_resources nes_ud_rsc[NES_UD_MAX_ADAPTERS];
> +static struct workqueue_struct *nes_ud_workqueue;
> +
> +/*
> + * locate_ud_adapter
> + *
> + * the function locates the UD adapter
> +*  on base of the adapter unique ID (structure nes_adapter)
> + */
> +static inline
> +struct nes_ud_resources *locate_ud_adapter(struct nes_adapter *pAdapt)
> +{
> +	int i;
> +	struct nes_ud_resources *pRsc;
> +
> +	for (i = 0; i < NES_UD_MAX_ADAPTERS; i++) {
> +		pRsc = &nes_ud_rsc[i];
> +
> +		if (pRsc->pAdap == pAdapt)
> +			return pRsc;
> +
> +	}
> +	return NULL;
> +}
> +
> +/*
> + * allocate_ud_adapter()
> + *
> + * function allocates a new adapter
> + */
> +static inline
> +struct nes_ud_resources *allocate_ud_adapter(struct nes_adapter *pAdapt)
> +{
> +    int i;
> +    struct nes_ud_resources *pRsc;
> +
> +    for (i = 0; i < NES_UD_MAX_ADAPTERS; i++) {
> +	pRsc = &nes_ud_rsc[i];
> +	if (pRsc->pAdap == NULL) {
> +		pRsc->pAdap = pAdapt;
> +		nes_debug(NES_DBG_UD, "new UD Adapter allocated %d"
> +		" for adapter %p no =%d\n", i, pAdapt, pRsc->adapter_no);
> +		return pRsc;
> +		}
> +	}
> +	nes_debug(NES_DBG_UD, "Unable to allocate adapter\n");
> +	return NULL;
> +}
> +
> +static inline
> +struct nes_ud_file *allocate_nic_queue(struct nes_vnic *nesvnic,
> +					enum nes_ud_queue_type queue_type)
> +{
> +    struct nes_ud_file *file = NULL;
> +	int i = 0;
> +	u8 select_log_port = 0xf;
> +	struct nes_device *nesdev = nesvnic->nesdev;
> +	int log_port_2_alloced = 0;
> +	int log_port_3_alloced = 0;
> +	int ret = 0;
> +	struct nes_ud_resources *pRsc;
> +
> +	/* the first thing that must be done is determine the adapter */
> +	/* number max the adapter could have up to 2 interfaces */
> +	if (nesvnic->nic_index != 0 && nesvnic->nic_index != 1) {
> +		nes_debug(NES_DBG_UD, "nic queue allocation failed"
> +		" nesvnic->nic_index = %d\n", nesvnic->nic_index);
> +		return NULL;
> +	}
> +
> +	/* locate device on base of nesvnic */
> +	/* - when it is an unknown card a new one is allocated */
> +	pRsc = locate_ud_adapter(nesdev->nesadapter);
> +	if (pRsc == NULL)
> +		return NULL;
> +
> +	for (i = 0; i < NES_UD_MAX_NIC_CNT; i++) {
> +		if (pRsc->nics[i].file->active == 0)
> +			continue;
> +		if (pRsc->nics[i].logical_port == 2 &&
> +		    queue_type == pRsc->nics[i].queue_type)
> +				log_port_2_alloced++;
> +		if (pRsc->nics[i].logical_port == 3 &&
> +		    queue_type == pRsc->nics[i].queue_type)
> +				log_port_3_alloced++;
> +	}
> +
> +	/* check dual/single card */
> +	if (pRsc->logport_2_map != pRsc->logport_3_map) {
> +		/* a dual port card */
> +		/* allocation is NIC2, NIC2, NIC3, NIC3 */
> +		/*- no RX packat replication supported */
> +		if (log_port_2_alloced < 2 &&
> +		    pRsc->logport_2_map == nesvnic->nic_index)
> +				select_log_port = 2;
> +		else if (log_port_3_alloced < 2 &&
> +			 pRsc->logport_3_map == nesvnic->nic_index)
> +				select_log_port = 3;
> +	} else {
> +		/* single port card */
> +		/* change allocation scheme to NIC2,NIC3,NIC2,NIC3 */
> +		switch (log_port_2_alloced + log_port_3_alloced) {
> +		case 0: /* no QPs allocated - use NIC2 */
> +			if (pRsc->logport_2_map == nesvnic->nic_index)
> +				select_log_port = 2;
> +
> +			break;
> +		case 1: /* NIC2 or NIC3 allocated */
> +			if (log_port_2_alloced > 0) {
> +				/* if NIC2 allocated use NIC3 */
> +				if (pRsc->logport_3_map == nesvnic->nic_index)
> +					select_log_port = 3;
> +
> +			} else {
> +				/* when NIC3 allocated use NIC2 */
> +				if (pRsc->logport_2_map == nesvnic->nic_index)
> +					select_log_port = 2;
> +
> +			}
> +			break;
> +
> +		case 2:
> +		/* NIC2 and NIC3 allocated or both ports on NIC3 - use NIC2 */
> +			if ((log_port_2_alloced == 1) ||
> +			    (log_port_3_alloced == 2)) {
> +				if (pRsc->logport_2_map == nesvnic->nic_index)
> +					select_log_port = 2;
> +
> +			} else {
> +				/* both ports allocated on NIC2 - use NIC3 */
> +				if (pRsc->logport_3_map == nesvnic->nic_index)
> +					select_log_port = 3;
> +
> +			}
> +				break;
> +		case 3:
> +			/* when both NIC2 allocated use NIC3 */
> +			if (log_port_2_alloced == 2) {
> +				if (pRsc->logport_3_map == nesvnic->nic_index)
> +					select_log_port = 3;
> +
> +			} else {
> +				/* when both NIC3 alloced use NIC2 */
> +				if (pRsc->logport_2_map == nesvnic->nic_index)
> +					select_log_port = 2;
> +			}
> +			break;
> +
> +		default:
> +			break;
> +		}
> +	}
> +	if (select_log_port == 0xf) {
> +		ret = -1;
> +		nes_debug(NES_DBG_UD, "%s(%d) logport allocation failed "
> +		"log_port_2_alloced=%d log_port_3_alloced=%d\n",
> +			__func__, __LINE__, log_port_2_alloced,
> +			log_port_3_alloced);
> +		goto out;
> +	}
> +
> +	nes_debug(NES_DBG_UD, "%s(%d) log_port_2_alloced=%d "
> +		"log_port_3_alloced=%d select_log_port=%d\n",
> +		__func__, __LINE__, log_port_2_alloced,
> +		log_port_3_alloced, select_log_port);
> +
> +	for (i = 0; i < NES_UD_MAX_NIC_CNT; i++) {
> +		if (pRsc->nics[i].file->active == 1)
> +			continue;
> +		if (pRsc->nics[i].logical_port == select_log_port &&
> +		    queue_type == pRsc->nics[i].queue_type) {
> +
> +			/* file is preallocated during initialization */
> +			file = pRsc->nics[i].file;
> +			memset(file, 0, sizeof(*file));
> +
> +			file->nesvnic = nesvnic;
> +			file->queue_type = queue_type;
> +
> +			file->prio = pRsc->nics[i].prio;
> +			file->qpn = pRsc->nics[i].qpn;
> +			file->nes_ud_nic_index = pRsc->nics[i].nic_index;
> +			file->rsc_idx = i;
> +			file->adapter_no = pRsc->adapter_no;
> +			goto out;
> +		}
> +	}
> +
> +out:
> +	return file;
> +}
> +
> +static inline int  del_rsc_list(struct nes_ud_file *file)
> +{
> +	int logport_2_cnt = 0;
> +	int logport_3_cnt = 0;
> +	struct nes_device *nesdev = file->nesvnic->nesdev;
> +	int i = 0;
> +	struct nes_ud_resources *pRsc;
> +
> +	if (file == NULL) {
> +		nes_debug(NES_DBG_UD, "%s(%d) file is NULL\n",
> +			__func__, __LINE__);
> +		return -EFAULT;
> +	}
> +	if (file->nesvnic == NULL) {
> +		nes_debug(NES_DBG_UD, "%s(%d) file->nesvnic is NULL\n",
> +			__func__, __LINE__);
> +		return -EFAULT;
> +	}
> +	if (nesdev == NULL) {
> +		nes_debug(NES_DBG_UD, "%s(%d) nesdev is NULL\n",
> +			__func__, __LINE__);
> +		return -EFAULT;
> +	}
> +
> +	/* locate device on base of nesvnic */
> +	/*- when it is an unknown card a new one is allocated */
> +	pRsc = locate_ud_adapter(nesdev->nesadapter);
> +	if (pRsc == NULL) {
> +		nes_debug(NES_DBG_UD, "%s(%d) cannot locate an allocated "
> +			"adapter  is NULL\n", __func__, __LINE__);
> +		return -EFAULT;
> +	}
> +	if (--pRsc->num_allocated_nics == 0) {
> +		nes_write_indexed(nesdev, 0x60b8, pRsc->original_60b8);
> +		nes_write_indexed(nesdev, 0x6000, pRsc->original_6000);
> +		pRsc->num_logport_confed = 0;
> +	}
> +	BUG_ON(pRsc->num_allocated_nics < 0);
> +	BUG_ON(file->rsc_idx >= NES_UD_MAX_NIC_CNT);
> +
> +	for (i = 0; i < NES_UD_MAX_NIC_CNT; i++) {
> +		if (pRsc->nics[i].file->active &&
> +		    pRsc->nics[i].logical_port == 2)
> +			logport_2_cnt++;
> +		if (pRsc->nics[i].file->active &&
> +		    pRsc->nics[i].logical_port == 3)
> +			logport_3_cnt++;
> +	}
> +
> +	if (pRsc->num_logport_confed != 0x3 && logport_2_cnt == 0)
> +		pRsc->logport_2_map = 0xf;
> +
> +	if (pRsc->num_logport_confed != 0x3 && logport_3_cnt == 0)
> +		pRsc->logport_3_map = 0xf;
> +	return 0;
> +}
> +
> +/*
> +* the QPN contains now the number of the RAW ETH
> +* adapter and QPN number on the adapter
> +* the adapter number is located in the highier
> +* 8 bits so QPN is stored as [adapter:qpn]
> +*/
> +static inline
> +struct nes_ud_file *get_file_by_qpn(struct nes_ud_resources *pRsc, int qpn)
> +{
> +	int i = 0;
> +
> +	for (i = 0; i < NES_UD_MAX_NIC_CNT; i++) {
> +		if (pRsc->nics[i].file->active &&
> +		    pRsc->nics[i].qpn == (qpn & 0xff))
> +			return pRsc->nics[i].file;
> +
> +	}
> +	return NULL;
> +}
> +
> +/* function counts all ETH RAW entities that have  */
> +/* a specific type and relation to specific vnic */
> +static inline
> +int count_files_by_nic(struct nes_vnic *nesvnic,
> +			enum nes_ud_queue_type queue_type)
> +{
> +	int count = 0;
> +	int i = 0;
> +	struct nes_ud_resources *pRsc;
> +
> +	pRsc = locate_ud_adapter(nesvnic->nesdev->nesadapter);
> +	if (pRsc == NULL)
> +		return 0;
> +
> +	for (i = 0; i < NES_UD_MAX_NIC_CNT; i++) {
> +		if (pRsc->nics[i].file->active &&
> +		    pRsc->nics[i].file->nesvnic == nesvnic &&
> +		    pRsc->nics[i].queue_type == queue_type)
> +				count++;
> +	}
> +	return count;
> +}
> +
> +/* function counts all RAW ETH  entities the have a specific type */
> +static inline
> +int count_files(struct nes_vnic *nesvnic, enum nes_ud_queue_type queue_type)
> +{
> +	int count = 0;
> +	int i = 0;
> +	struct nes_ud_resources *pRsc;
> +
> +	pRsc = locate_ud_adapter(nesvnic->nesdev->nesadapter);
> +	if (pRsc == NULL)
> +		return 0;
> +
> +	for (i = 0; i < NES_UD_MAX_NIC_CNT; i++) {
> +		if (pRsc->nics[i].file->active &&
> +		    pRsc->nics[i].queue_type == queue_type)
> +			count++;
> +	}
> +	return count;
> +}
> +
> +/*
> + * the function locates the entry allocated by IGMP and modifies the
> + * PFT entry with the list of the NICs allowed to receive that multicast
> + * the NIC0/NIC1 are removed due to performance issue so tcpdum
> + * like tools cannot receive the accelerated multicasts
> + */
> +static void mcast_fix_filter_table_single(struct nes_ud_file *file, u8 *addr)
> +{
> +  struct nes_device *nesdev = file->nesvnic->nesdev;
> +  int i = 0;
> +  u32 macaddr_low;
> +  u32 orig_low;
> +  u32 macaddr_high;
> +  u32 prev_high;
> +
> +  for (i = 0; i < 48; i++) {
> +	macaddr_low = nes_read_indexed(nesdev,
> +					NES_IDX_PERFECT_FILTER_LOW + i*8);
> +	orig_low = macaddr_low;
> +	macaddr_high = nes_read_indexed(nesdev,
> +					NES_IDX_PERFECT_FILTER_LOW + 4 + i*8);
> +	if (!(macaddr_high & NES_MAC_ADDR_VALID))
> +		continue;
> +	if ((macaddr_high & 0xffff) != 0x0100)
> +		continue;
> +	if ((macaddr_low & 0xff) != addr[2])
> +		continue;
> +	macaddr_low >>= 8;
> +	if ((macaddr_low & 0xff) != addr[1])
> +		continue;
> +	macaddr_low >>= 8;
> +	if ((macaddr_low & 0xff) != addr[0])
> +		continue;
> +	macaddr_low >>= 8;
> +	if ((macaddr_low & 0xff) != 0x5e)
> +		continue;
> +	/* hit - that means Linux or other UD set this bit earlier  */
> +	prev_high = macaddr_high;
> +	nes_write_indexed(nesdev, NES_IDX_PERFECT_FILTER_LOW + 4 + i*8, 0);
> +	macaddr_high = (macaddr_high & 0xfffcffff) |
> +					((1<<file->nes_ud_nic_index) << 16);
> +
> +	nes_debug(NES_DBG_UD, "%s(%d) found addr to fix, "
> +		 "i=%d, macaddr_high=0x%x  macaddr_low=0x%x "
> +		 "nic_idx=%d prev_high=0x%x\n",
> +		 __func__, __LINE__, i, macaddr_high, orig_low,
> +		file->nes_ud_nic_index, prev_high);
> +	nes_write_indexed(nesdev,
> +			NES_IDX_PERFECT_FILTER_LOW + 4 + i*8, macaddr_high);
> +	break;
> +  }
> +}
> +
> +/* this function is implemented that way because the Linux multicast API
> +   use the multicast list approach. When a new multicast address is added
> +   all PFT table is reinitialized by linux and all entries must be fixed
> +   by this procedure
> +*/
> +static void mcast_fix_filter_table(struct nes_ud_file *file)
> +{
> +	int i;
> +	struct nes_ud_resources *pRsc;
> +
> +	pRsc = locate_ud_adapter(file->nesvnic->nesdev->nesadapter);
> +	if (pRsc == NULL)
> +		return;
> +
> +	for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++) {
> +		if (pRsc->mcast[i].in_use != 0)
> +			mcast_fix_filter_table_single(pRsc->mcast[i].owner,
> +							pRsc->mcast[i].addr);
> +	}
> +}
> +
> +/* function invalidates the PFT entry */
> +static void remove_mcast_from_pft(struct nes_ud_file *file, u8 *addr)
> +{
> +  struct nes_device *nesdev = file->nesvnic->nesdev;
> +  int i = 0;
> +   u32 macaddr_low;
> +  u32 orig_low;
> +  u32 macaddr_high;
> +  u32 prev_high;
> +
> +  for (i = 0; i < 48; i++) {
> +	macaddr_low = nes_read_indexed(nesdev,
> +					NES_IDX_PERFECT_FILTER_LOW + i*8);
> +	orig_low = macaddr_low;
> +	macaddr_high = nes_read_indexed(nesdev,
> +					NES_IDX_PERFECT_FILTER_LOW + 4 + i*8);
> +	if (!(macaddr_high & NES_MAC_ADDR_VALID))
> +		continue;
> +
> +	if ((macaddr_high & 0xffff) != 0x0100)
> +		continue;
> +	if ((macaddr_low & 0xff) != addr[2])
> +		continue;
> +	macaddr_low >>= 8;
> +	if ((macaddr_low & 0xff) != addr[1])
> +		continue;
> +	macaddr_low >>= 8;
> +	if ((macaddr_low & 0xff) != addr[0])
> +		continue;
> +	macaddr_low >>= 8;
> +	if ((macaddr_low & 0xff) != 0x5e)
> +		continue;
> +	/* hit - that means Linux or other UD set this bit earlier */
> +	/* so remove the NIC from MAC address reception */
> +	prev_high = macaddr_high;
> +	macaddr_high = (macaddr_high & 0xfffcffff) &
> +					~((1<<file->nes_ud_nic_index) << 16);
> +	nes_debug(NES_DBG_UD, "%s(%d) found addr to mcast remove,"
> +		"i=%d, macaddr_high=0x%x  macaddr_low=0x%x "
> +		"nic_idx=%d prev_high=0x%x\n", __func__, __LINE__, i,
> +		macaddr_high, orig_low, file->nes_ud_nic_index, prev_high);
> +	nes_write_indexed(nesdev, NES_IDX_PERFECT_FILTER_LOW + 4 + i*8,
> +							macaddr_high);
> +	break;
> +	}
> +
> +}
> +
> +/*
> +* the function returns a mask of the NICs
> +* assotiated with given multicast address
> +*/
> +static int nes_ud_mcast_filter(struct nes_vnic *nesvnic, __u8 *dmi_addr)
> +{
> +	int i = 0;
> +	int ret = 0;
> +	int mask = 0;
> +	struct nes_ud_resources *pRsc;
> +
> +	pRsc = locate_ud_adapter(nesvnic->nesdev->nesadapter);
> +	if (pRsc == NULL)
> +		return 0;
> +
> +	for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++) {
> +		if (pRsc->mcast[i].in_use &&
> +		    pRsc->mcast[i].addr[0] == dmi_addr[3] &&
> +		    pRsc->mcast[i].addr[1] == dmi_addr[4] &&
> +		    pRsc->mcast[i].addr[2] == dmi_addr[5]) {
> +			mask = (pRsc->mcast[i].owner->mcast_mode ==
> +				NES_UD_MCAST_PFT_MODE) ?
> +				pRsc->mcast[i].owner->nes_ud_nic_index : 0;
> +
> +			ret = ret | (1 << mask);
> +			nes_debug(NES_DBG_UD, "mcast filter, "
> +				"fpr=%02X%02X%02X ret=%d\n",
> +				dmi_addr[3], dmi_addr[4], dmi_addr[5], ret);
> +		}
> +	}
> +	if (ret == 0)
> +		return -1;
> +	else
> +		return ret;
> +
> +}
> +
> +static __u32 mqueue_key[4] = { 0x0, 0x80, 0x0, 0x0 };
> +
> +static inline __u8 nes_ud_calculate_hash(__u8 dest_addr_lsb)
> +{
> +  __u8 in[8];
> +  __u32 key_arr[4];
> +  int i;
> +  __u32 result = 0;
> +  int j, k;
> +  __u8 shift_in, next_shift_in;
> +
> +  in[0] = 0;
> +  in[1] = 0;
> +  in[2] = 0;
> +  in[3] = 0;
> +
> +  in[4] = 0;
> +
> +  in[5] = 0;
> +  in[6] = 0;
> +  in[7] = dest_addr_lsb;
> +
> +
> +
> +	for (i = 0; i < 4; i++)
> +		key_arr[3-i] = mqueue_key[i];
> +
> +
> +
> +	for (i = 0; i < 8; i++) {
> +		for (j = 7; j >= 0; j--) {
> +			if (in[i] & (1 << j))
> +				result = result ^ key_arr[0];
> +
> +			shift_in = 0;
> +			for (k = 3; k >= 0; k--) {
> +				next_shift_in = key_arr[k] >> 31;
> +				key_arr[k] = (key_arr[k] << 1) + shift_in;
> +				shift_in = next_shift_in;
> +			}
> +		}
> +	}
> +	return result & 0x7f;
> +}
> +
> +static inline void nes_ud_enable_mqueue(struct nes_ud_file *file)
> +{
> +	struct nes_device *nesdev = file->nesvnic->nesdev;
> +	int mqueue_config0;
> +	int mqueue_config2;
> +	int instance = file->nes_ud_nic_index & 0x1;
> +
> +	mqueue_config0 = nes_read_indexed(nesdev, 0x6400);
> +	mqueue_config0 |= (4 | (instance & 0x3)) << (file->nes_ud_nic_index*3);
> +	nes_write_indexed(nesdev, 0x6400, mqueue_config0);
> +	mqueue_config0 = nes_read_indexed(nesdev, 0x6400);
> +
> +	mqueue_config2 = nes_read_indexed(nesdev, 0x6408);
> +	mqueue_config2 |= (2 << (instance*2)) | (6 << (instance*3+8));
> +	nes_write_indexed(nesdev, 0x6408, mqueue_config2);
> +	mqueue_config2 = nes_read_indexed(nesdev, 0x6408);
> +
> +	nes_write_indexed(nesdev, 0x64a0+instance*0x100, mqueue_key[0]);
> +	nes_write_indexed(nesdev, 0x64a4+instance*0x100, mqueue_key[1]);
> +	nes_write_indexed(nesdev, 0x64a8+instance*0x100, mqueue_key[2]);
> +	nes_write_indexed(nesdev, 0x64ac+instance*0x100, mqueue_key[3]);
> +
> +	nes_debug(NES_DBG_UD, "mq_config0=0x%x mq_config2=0x%x nic_idx= %d\n",
> +		  mqueue_config0, mqueue_config2, file->nes_ud_nic_index);
> +
> +}
> +
> +
> +
> +static inline
> +void nes_ud_redirect_from_mqueue(struct nes_ud_file *file, int num_queues)
> +{
> +	struct nes_device *nesdev = file->nesvnic->nesdev;
> +	int instance = file->nes_ud_nic_index & 0x1;
> +	unsigned addr = 0x6420+instance*0x100;
> +	unsigned value;
> +	int i;
> +
> +	value  = (file->prio == NES_UD_DEV_PRIO_LOW || num_queues == 1) ?
> +							0x0 : 0x11111111;
> +	for (i = 0; i < 16; i++)
> +		nes_write_indexed(nesdev, addr+i*4, value);
> +}
> +
> +
> +static int nes_ud_create_nic(struct nes_ud_file *file)
> +{
> +	struct nes_vnic *nesvnic = file->nesvnic;
> +	struct nes_device *nesdev = nesvnic->nesdev;
> +	struct nes_hw_nic_qp_context *nic_context;
> +	struct nes_hw_cqp_wqe *cqp_wqe;
> +	struct nes_cqp_request *cqp_request;
> +	unsigned long flags;
> +	void *vmem;
> +	dma_addr_t pmem;
> +	u64 u64temp;
> +	int ret = 0;
> +
> +	BUG_ON(file->nic_vbase != NULL);
> +
> +	file->nic_mem_size = 256 +
> +			(NES_NIC_WQ_SIZE * sizeof(struct nes_hw_nic_sq_wqe)) +
> +			sizeof(struct nes_hw_nic_qp_context);
> +
> +	file->nic_vbase = pci_alloc_consistent(nesdev->pcidev,
> +						file->nic_mem_size,
> +						&file->nic_pbase);
> +	if (!file->nic_vbase) {
> +		nes_debug(NES_DBG_UD, "Unable to allocate memory for NIC host "
> +			"descriptor rings\n");
> +		return -ENOMEM;
> +	}
> +
> +	memset(file->nic_vbase, 0, file->nic_mem_size);
> +
> +	vmem = (void *)(((unsigned long long)file->nic_vbase + (256 - 1)) &
> +			~(unsigned long long)(256 - 1));
> +	pmem = (dma_addr_t)(((unsigned long long)file->nic_pbase + (256 - 1)) &
> +			~(unsigned long long)(256 - 1));
> +
> +	file->wq_vbase = vmem;
> +	file->wq_pbase = pmem;
> +	file->head = 0;
> +	file->tail = 0;
> +
> +	vmem += (NES_NIC_WQ_SIZE * sizeof(struct nes_hw_nic_sq_wqe));
> +	pmem += (NES_NIC_WQ_SIZE * sizeof(struct nes_hw_nic_sq_wqe));
> +
> +	cqp_request = nesvnic->get_cqp_request(nesdev);
> +	if (cqp_request == NULL) {
> +		nes_debug(NES_DBG_QP, "Failed to get a cqp_request.\n");
> +		goto fail_cqp_req_alloc;
> +	}
> +	cqp_request->waiting = 1;
> +	cqp_wqe = &cqp_request->cqp_wqe;
> +
> +	cqp_wqe->wqe_words[NES_CQP_WQE_OPCODE_IDX] =
> +			cpu_to_le32(NES_CQP_CREATE_QP | NES_CQP_QP_TYPE_NIC);
> +	cqp_wqe->wqe_words[NES_CQP_WQE_ID_IDX] = cpu_to_le32(file->qpn);
> +	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_CTX_LOW_IDX] =
> +			cpu_to_le32((u32)((u64)(&nesdev->cqp)));
> +	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_CTX_HIGH_IDX] =
> +			cpu_to_le32((u32)(((u64)(&nesdev->cqp))>>32));
> +	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_SCRATCH_LOW_IDX] = 0;
> +	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_SCRATCH_HIGH_IDX] = 0;
> +
> +
> +	nic_context = vmem;
> +
> +	nic_context->context_words[NES_NIC_CTX_MISC_IDX] =
> +			cpu_to_le32((u32)NES_NIC_CTX_SIZE |
> +			((u32)PCI_FUNC(nesdev->pcidev->devfn) << 12) |
> +			(1 << 18));
> +
> +	nic_context->context_words[NES_NIC_CTX_SQ_LOW_IDX] = 0;
> +	nic_context->context_words[NES_NIC_CTX_SQ_HIGH_IDX] = 0;
> +	nic_context->context_words[NES_NIC_CTX_RQ_LOW_IDX] = 0;
> +	nic_context->context_words[NES_NIC_CTX_RQ_HIGH_IDX] = 0;
> +
> +	u64temp = (u64)file->wq_pbase;
> +	if (file->queue_type == NES_UD_SEND_QUEUE) {
> +		nic_context->context_words[NES_NIC_CTX_SQ_LOW_IDX] =
> +						cpu_to_le32((u32)u64temp);
> +		nic_context->context_words[NES_NIC_CTX_SQ_HIGH_IDX] =
> +					cpu_to_le32((u32)(u64temp >> 32));
> +	} else {
> +		nic_context->context_words[NES_NIC_CTX_RQ_LOW_IDX] =
> +						cpu_to_le32((u32)u64temp);
> +		nic_context->context_words[NES_NIC_CTX_RQ_HIGH_IDX] =
> +					cpu_to_le32((u32)(u64temp >> 32));
> +	}
> +
> +	u64temp = (u64)pmem;
> +
> +	cqp_wqe->wqe_words[NES_CQP_QP_WQE_CONTEXT_LOW_IDX] =
> +						cpu_to_le32((u32)u64temp);
> +	cqp_wqe->wqe_words[NES_CQP_QP_WQE_CONTEXT_HIGH_IDX] =
> +					cpu_to_le32((u32)(u64temp >> 32));
> +
> +	atomic_set(&cqp_request->refcount, 2);
> +	nesvnic->post_cqp_request(nesdev, cqp_request);
> +
> +	/* Wait for CQP */
> +	ret = wait_event_timeout(cqp_request->waitq,
> +				(cqp_request->request_done != 0),
> +				NES_EVENT_TIMEOUT);
> +	if (!ret)
> +		nes_debug(NES_DBG_UD, "NES_UD NIC QP%u "
> +			"create timeout expired\n", file->qpn);
> +
> +
> +	if (atomic_dec_and_test(&cqp_request->refcount)) {
> +		if (cqp_request->dynamic) {
> +			kfree(cqp_request);
> +		} else {
> +			spin_lock_irqsave(&nesdev->cqp.lock, flags);
> +			list_add_tail(&cqp_request->list,
> +						&nesdev->cqp_avail_reqs);
> +			spin_unlock_irqrestore(&nesdev->cqp.lock, flags);
> +		}
> +	}
> +	nes_debug(NES_DBG_UD, "Created NIC, qpn=%d, SQ/RQ pa=0x%p va=%p "
> +		"virt_to_phys=%p\n", file->qpn,
> +		(void *)file->wq_pbase, (void *)file->nic_vbase,
> +		(void *)virt_to_phys(file->nic_vbase));
> +	return ret;
> +
> + fail_cqp_req_alloc:
> +	pci_free_consistent(nesdev->pcidev, file->nic_mem_size, file->nic_vbase,
> +			file->nic_pbase);
> +	file->nic_vbase = NULL;
> +	return -EFAULT;
> +}
> +
> +
> +static void nes_ud_destroy_nic(struct nes_ud_file *file)
> +{
> +	struct nes_vnic *nesvnic = file->nesvnic;
> +	struct nes_device *nesdev = nesvnic->nesdev;
> +	struct nes_hw_cqp_wqe *cqp_wqe;
> +	struct nes_cqp_request *cqp_request;
> +	unsigned long flags;
> +	int ret = 0;
> +
> +	cqp_request = nesvnic->get_cqp_request(nesdev);
> +	if (cqp_request == NULL) {
> +		nes_debug(NES_DBG_QP, "Failed to get a cqp_request.\n");
> +		return;
> +	}
> +	cqp_request->waiting = 1;
> +	cqp_wqe = &cqp_request->cqp_wqe;
> +
> +	cqp_wqe->wqe_words[NES_CQP_WQE_OPCODE_IDX] =
> +			cpu_to_le32(NES_CQP_DESTROY_QP | NES_CQP_QP_TYPE_NIC);
> +	cqp_wqe->wqe_words[NES_CQP_WQE_ID_IDX] = cpu_to_le32(file->qpn);
> +	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_CTX_LOW_IDX] =
> +			cpu_to_le32((u32)((u64)(&nesdev->cqp)));
> +	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_CTX_HIGH_IDX] =
> +			cpu_to_le32((u32)(((u64)(&nesdev->cqp)) >> 32));
> +	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_SCRATCH_LOW_IDX] = 0;
> +	cqp_wqe->wqe_words[NES_CQP_WQE_COMP_SCRATCH_HIGH_IDX] = 0;
> +
> +	atomic_set(&cqp_request->refcount, 2);
> +	nesvnic->post_cqp_request(nesdev, cqp_request);
> +
> +	/* Wait for CQP */
> +	ret = wait_event_timeout(cqp_request->waitq,
> +			(cqp_request->request_done != 0),
> +			NES_EVENT_TIMEOUT);
> +	if (!ret)
> +		nes_debug(NES_DBG_UD, "NES_UD NIC QP%u "
> +			"destroy timeout expired\n", file->qpn);
> +
> +	if (atomic_dec_and_test(&cqp_request->refcount)) {
> +		if (cqp_request->dynamic) {
> +			kfree(cqp_request);
> +		} else {
> +			spin_lock_irqsave(&nesdev->cqp.lock, flags);
> +			list_add_tail(&cqp_request->list,
> +					&nesdev->cqp_avail_reqs);
> +			spin_unlock_irqrestore(&nesdev->cqp.lock, flags);
> +		}
> +	}
> +
> +	pci_free_consistent(nesdev->pcidev, file->nic_mem_size, file->nic_vbase,
> +			file->nic_pbase);
> +	file->nic_vbase = NULL;
> +	file->qp_ptr = NULL;
> +
> +	return;
> +}
> +
> +static void nes_ud_free_resources(struct nes_ud_file *file)
> +{
> +	struct nes_device *nesdev = file->nesvnic->nesdev;
> +	int nic_active = 0;
> +	int mcast_all = 0;
> +	int mcast_en = 0;
> +	int wqm_config0 = 0;
> +	wait_queue_head_t     waitq;
> +	int num_queues  = 0;
> +	nes_debug(NES_DBG_UD, " %s(%d) NAME=%s nes_ud_qpid=%d\n",
> +		__func__, __LINE__, file->ifrn_name, file->qpn);
> +
> +	if (!file->nesvnic || !file->active)
> +		return;
> +
> +	if (file->queue_type == NES_UD_SEND_QUEUE) {
> +		nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
> +		nic_active &= ~(1 << file->nes_ud_nic_index);
> +		nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
> +		nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
> +	} else {
> +		num_queues = count_files_by_nic(file->nesvnic,
> +						file->queue_type);
> +
> +	if (num_queues == 1) {
> +
> +		nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
> +		nic_active &= ~(1 << file->nes_ud_nic_index);
> +		nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
> +		nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
> +
> +		mcast_all = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
> +		mcast_all &= ~(1 << file->nes_ud_nic_index);
> +		nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, mcast_all);
> +		mcast_all = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
> +
> +		mcast_en = nes_read_indexed(nesdev,
> +						NES_IDX_NIC_MULTICAST_ENABLE);
> +		mcast_en &= ~(1 << file->nes_ud_nic_index);
> +		nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE,
> +								mcast_en);
> +		mcast_en = nes_read_indexed(nesdev,
> +						NES_IDX_NIC_MULTICAST_ENABLE);
> +
> +		nes_debug(NES_DBG_UD, "nic_active=0x%x, mcast_en=0x%x, "
> +			"mcast_all=0x%x nic_index=%d num_queues=%d\n",
> +			nic_active, mcast_en, mcast_all,
> +			file->nes_ud_nic_index, num_queues);
> +	  }
> +
> +	 nes_ud_redirect_from_mqueue(file, num_queues);
> +	 num_queues = count_files(file->nesvnic, file->queue_type);
> +	if (num_queues == 1) {
> +		nes_debug(NES_DBG_UD, "Last receive queue, "
> +			"restoring MPP debug register\n");
> +		nes_write_indexed(nesdev, 0xA00, 0x200);
> +		nes_write_indexed(nesdev, 0xA40, 0x200);
> +	  }
> +	}
> +
> +
> +
> +	nes_ud_destroy_nic(file);
> +
> +	if (file->queue_type == NES_UD_RECV_QUEUE) {
> +		wqm_config0 = nes_read_indexed(nesdev, 0x5000);
> +		wqm_config0 &= ~0x8000;
> +		nes_write_indexed(nesdev, 0x5000, wqm_config0);
> +
> +		init_waitqueue_head(&waitq);
> +
> +		wait_event_timeout(waitq, 0, NES_UD_CLEANUP_TIMEOUT);
> +
> +		nes_debug(NES_DBG_UD, "%s(%d) enabling stall_no_wqes\n",
> +			__func__, __LINE__);
> +		wqm_config0 = nes_read_indexed(nesdev, 0x5000);
> +		wqm_config0 |= 0x8000;
> +		nes_write_indexed(nesdev, 0x5000, wqm_config0);
> +	}
> +
> +	dev_put(file->nesvnic->netdev);
> +
> +	file->active = 0;
> +
> +	nes_debug(NES_DBG_UD, "%s(%d) done\n", __func__, __LINE__);
> +}
> +
> +
> +static int nes_ud_init_channel(struct nes_ud_file *file)
> +{
> +	struct nes_device *nesdev = NULL;
> +	int ret = 0;
> +	int nic_active = 0;
> +	int mcast_all = 0;
> +	int mcast_en = 0;
> +	int link_ag = 0;
> +	int mpp4_dbg = 0;
> +
> +	nesdev = file->nesvnic->nesdev;
> +
> +	ret = nes_ud_create_nic(file);
> +	if (ret != 0)
> +		return ret;
> +
> +	if (file->queue_type == NES_UD_RECV_QUEUE) {
> +
> +		file->nesvnic->mcrq_mcast_filter = nes_ud_mcast_filter;
> +
> +		mcast_en = nes_read_indexed(nesdev,
> +					NES_IDX_NIC_MULTICAST_ENABLE);
> +		mcast_en |= 1 << file->nes_ud_nic_index;
> +		nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE,
> +								mcast_en);
> +		mcast_en = nes_read_indexed(nesdev,
> +					NES_IDX_NIC_MULTICAST_ENABLE);
> +
> +		/* the only case when we use PFT is for single port
> +		two functions, which probably would be the
> +		most common usage model :), but anyway */
> +	if (file->mcast_mode == NES_UD_MCAST_ALL_MODE) {
> +		mcast_all = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
> +		mcast_all |= 1 << file->nes_ud_nic_index;
> +		nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, mcast_all);
> +		mcast_all = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
> +	}
> +	if (nesdev->nesadapter->port_count <= 2) {
> +		link_ag = 0x00;
> +		nes_write_indexed(nesdev, 0x6038, link_ag);
> +		link_ag = nes_read_indexed(nesdev, 0x6038);
> +	}
> +	if (nesdev->nesadapter->netdev_count <= 2)
> +		nes_ud_enable_mqueue(file);
> +
> +	nes_write_indexed(nesdev, 0xA00, 0x245);
> +	nes_write_indexed(nesdev, 0xA40, 0x245);
> +
> +	}
> +	/* NES_UD_SEND_QUEUE */
> +	else {
> +		mpp4_dbg = nes_read_indexed(nesdev, 0xb00);
> +		mpp4_dbg |= 1 << 12;
> +		nes_write_indexed(nesdev, 0xb00, mpp4_dbg);
> +		mpp4_dbg = nes_read_indexed(nesdev, 0xb00);
> +	}
> +
> +	nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
> +	nic_active |= 1 << file->nes_ud_nic_index;
> +	nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
> +	nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
> +
> +	nes_debug(NES_DBG_UD, "nic_active=0x%x, mcast_en=0x%x, "
> +		"mcast_all=0x%x nic_index=%d link_ag=0x%x mpp4_dbg=0x%x\n",
> +		nic_active, mcast_en, mcast_all, file->nes_ud_nic_index,
> +		link_ag, mpp4_dbg);
> +
> +	return ret;
> +}
> +
> +static struct nes_ud_file *nes_ud_get_nxt_channel(struct nes_vnic *nesvnic,
> +					enum nes_ud_queue_type queue_type)
> +{
> +	struct nes_ud_file *file = NULL;
> +	struct net_device *netdev = NULL;
> +	struct nes_device *nesdev = NULL;
> +	struct nes_ud_resources *pRsc;
> +
> +	netdev = nesvnic->netdev;
> +	nesdev = nesvnic->nesdev;
> +
> +	pRsc = locate_ud_adapter(nesdev->nesadapter);
> +	if (pRsc == NULL) {
> +		pRsc = allocate_ud_adapter(nesdev->nesadapter);
> +		if (pRsc == NULL)
> +			return NULL;
> +
> +	}
> +	if (pRsc->num_logport_confed == 0) {
> +		pRsc->original_60b8 = nes_read_indexed(nesdev, 0x60b8);
> +		pRsc->original_6000 = nes_read_indexed(nesdev, 0x6000);
> +		/* everything goes to port 0x0 */
> +		if ((nesvnic->nesdev->nesadapter->port_count == 1) ||
> +		    (nes_drv_opt & NES_DRV_OPT_MCAST_LOGPORT_MAP)) {
> +			/* single port card or dual port using single if */
> +			pRsc->num_logport_confed = 0x3;
> +			pRsc->logport_2_map = 0x0;
> +			pRsc->logport_3_map = 0x0;
> +			nes_write_indexed(nesdev, 0x60b8, 0x3);
> +			nes_write_indexed(nesdev, 0x6000, 0x0);
> +		} else {
> +			pRsc->num_logport_confed = 0x3;
> +			pRsc->logport_2_map = 0x0;
> +			pRsc->logport_3_map = 0x1;
> +		}
> +		nes_debug(NES_DBG_UD, "%s(%d) num_logport_confed=%d "
> +			"original_6000=%d logport_3_map = %d nes_drv_opt=%x\n",
> +			__func__, __LINE__, pRsc->num_logport_confed,
> +			pRsc->original_6000, pRsc->logport_3_map, nes_drv_opt);
> +	}
> +
> +	nes_debug(NES_DBG_UD, "%s(%d) logport_2_map=%d logport_3_map=%d\n",
> +		 __func__, __LINE__, pRsc->logport_2_map, pRsc->logport_3_map);
> +
> +	file = allocate_nic_queue(nesvnic, queue_type);
> +	if (file == NULL) {
> +		nes_debug(NES_DBG_UD, "%s(%d) failed to allocate NIC\n",
> +			__func__, __LINE__);
> +		return NULL;
> +	}
> +
> +	file->active = 1;
> +	memcpy(file->ifrn_name, netdev->name, IFNAMSIZ);
> +
> +	/* for now use pft always */
> +	file->mcast_mode = NES_UD_MCAST_PFT_MODE;
> +
> +	nes_debug(NES_DBG_UD, " %s(%d) NAME=%s qpn=%d nes_ud_nic_index=%d "
> +		"nes_ud_nic.qp_id=%d mcast_mode=%d port_count=%d "
> +		"netdev_count=%d\n", __func__, __LINE__, file->ifrn_name,
> +		 file->qpn, file->nes_ud_nic_index, file->nesvnic->mcrq_qp_id,
> +		 file->mcast_mode, nesdev->nesadapter->port_count,
> +		nesdev->nesadapter->netdev_count);
> +
> +	file->mss = netdev->mtu-28;
> +	pRsc->num_allocated_nics++;
> +	BUG_ON(pRsc->num_allocated_nics > 8);
> +
> +	return file;
> +
> +}
> +
> +static struct nes_ud_mem_region *nes_ud_allocate_mr(u32 npages)
> +{
> +	struct nes_ud_mem_region *mr = NULL;
> +
> +	mr = vmalloc(sizeof(*mr));
> +	if (mr == NULL)
> +		return NULL;
> +
> +
> +	mr->addrs = vmalloc(npages * sizeof(dma_addr_t));
> +	if (!mr->addrs) {
> +		nes_debug(NES_DBG_UD, "%s(%d) Cannot allocate mr struct "
> +		"for %d pages\n", __func__, __LINE__, npages);
> +		vfree(mr);
> +		return NULL;
> +	}
> +	mr->pg_cnt = npages;
> +	mr->in_use = 1;
> +
> +	INIT_LIST_HEAD(&mr->list);
> +
> +	return mr;
> +}
> +
> +static void nes_ud_free_mr(struct nes_ud_mem_region *mr)
> +{
> +	if (mr->addrs != NULL)
> +		vfree(mr->addrs);
> +
> +	vfree(mr);
> +}
> +
> +/* nes_ud_get_hash_entry()
> + *
> + * function returns a key for hash table
> + */
> +static inline
> +int nes_ud_get_hash_entry(u32 stag)
> +{
> +	return stag & 0xff;
> +}
> +
> +
> +/* nes_ud_lookup_mr()
> + *
> + * function returns a pointer to mr realized by specific STAG
> + */
> +static inline
> +struct nes_ud_mem_region *nes_ud_lookup_mr(u32 stag)
> +{
> +	int key;
> +	struct nes_ud_mem_region *mr;
> +
> +	key = nes_ud_get_hash_entry(stag);
> +
> +	list_for_each_entry(mr, &ud_mem.mrs[key].list, list) {
> +		ud_mem.mrs[key].read_stats++;
> +		if (mr->stag == stag)
> +			return mr;
> +
> +	}
> +	return NULL;
> +}
> +
> +/* nes_ud_add_mr_hash()
> + *
> + * the function inserts the mr entry into the hash list
> + * the stag is a key
> + */
> +static inline
> +int nes_ud_add_mr_hash(struct nes_ud_mem_region *mr)
> +{
> +	int key;
> +
> +	/* first check if the stag is unique */
> +	if (nes_ud_lookup_mr(mr->stag) != NULL) {
> +		nes_debug(NES_DBG_UD, "%s(%d) double STAG error stag=%x\n",
> +			__func__, __LINE__, mr->stag);
> +		return -1;
> +	}
> +	key = nes_ud_get_hash_entry(mr->stag);
> +
> +	/* structure is global so mutexes are necessary */
> +	mutex_lock(&ud_mem.mutex);
> +
> +	/* add mr to the list at start  */
> +	list_add(&mr->list, &ud_mem.mrs[key].list);
> +
> +	mutex_unlock(&ud_mem.mutex);
> +
> +	return 0;
> +
> +}
> +
> +/* nes_ud_del_mr()
> + *
> + * the function removes the entry from the hash list
> + * the stag is the key
> + */
> +static inline
> +void nes_ud_del_mr(struct nes_ud_mem_region *mr)
> +{
> +	/* structure is global so mutexes are necessary */
> +	mutex_lock(&ud_mem.mutex);
> +
> +	list_del(&mr->list);
> +
> +	/* init entry */
> +	INIT_LIST_HEAD(&mr->list);
> +
> +	mutex_unlock(&ud_mem.mutex);
> +}
> +
> +/* nes_ud_cleanup_mr()
> + *
> + * function deletes and and frees all hash entries
> + */
> +static inline
> +void nes_ud_cleanup_mr(void)
> +{
> +	struct nes_ud_mem_region *mr;
> +	struct nes_ud_mem_region *next;
> +	int i;
> +
> +	/* structure is global so mutexes are necessary */
> +	mutex_lock(&ud_mem.mutex);
> +
> +	for (i = 0; i < NES_UD_MAX_REG_HASH_CNT; i++) {
> +		if (list_empty(&ud_mem.mrs[i].list))
> +			continue;
> +
> +		list_for_each_entry_safe(mr, next, &ud_mem.mrs[i].list, list) {
> +			nes_debug(NES_DBG_UD, "%s(%d) non free stag=%x\n",
> +				__func__, __LINE__, mr->stag);
> +			list_del_init(&mr->list);
> +
> +			nes_ud_free_mr(mr);
> +		}
> +	}
> +
> +	mutex_unlock(&ud_mem.mutex);
> +}
> +
> +u32 nes_ud_reg_mr(struct ib_umem *region, u64 length, u64 virt, u32 stag)
> +{
> +	unsigned long npages =
> +		PAGE_ALIGN(region->length + region->offset) >> PAGE_SHIFT;
> +	struct nes_ud_mem_region *mr = nes_ud_allocate_mr(npages);
> +	struct ib_umem_chunk *chunk;
> +	dma_addr_t page;
> +	u32 chunk_pages = 0;
> +	int nmap_index;
> +	int i = 0;
> +	int mr_id = 0;
> +	nes_debug(NES_DBG_UD, "%s(%d) mr=%p length=%d virt=%p\n",
> +		__func__, __LINE__, mr, (int)length, (void *)virt);
> +	if (!mr)
> +		return 0;
> +
> +
> +	mr->stag = stag;
> +
> +	mr->va = virt;
> +	mr->length = length;
> +	list_for_each_entry(chunk, &region->chunk_list, list) {
> +	for (nmap_index = 0; nmap_index < chunk->nmap; ++nmap_index) {
> +		page = sg_dma_address(&chunk->page_list[nmap_index]);
> +		chunk_pages = sg_dma_len(&chunk->page_list[nmap_index]) >> 12;
> +		if (page & ~PAGE_MASK)
> +			goto reg_user_mr_err;
> +		if (!chunk_pages)
> +			goto reg_user_mr_err;
> +
> +		for (i = 0; i < chunk_pages; i++) {
> +			mr->addrs[mr_id] = page;
> +			page += PAGE_SIZE;
> +			if (++mr_id > npages)
> +				goto reg_user_mr_err;
> +			}
> +		}
> +	}
> +	nes_debug(NES_DBG_UD, "%s(%d) stag=0x%x mr_id=%d npages=%d\n",
> +		__func__, __LINE__, stag, mr_id, (int)npages);
> +	nes_ud_add_mr_hash(mr);
> +	return stag;
> +
> +reg_user_mr_err:
> +	if (mr)
> +		nes_ud_free_mr(mr);
> +
> +	return 0;
> +}
> +
> +
> +int nes_ud_dereg_mr(u32 stag)
> +{
> +	struct nes_ud_mem_region *mr = NULL;
> +
> +	nes_debug(NES_DBG_UD, "%s(%d) stag=0x%x\n", __func__, __LINE__, stag);
> +
> +	mr = nes_ud_lookup_mr(stag);
> +	if (mr != NULL) {
> +		nes_ud_del_mr(mr);
> +		nes_ud_free_mr(mr);
> +	} else {
> +		nes_debug(NES_DBG_UD, "%s(%d) unknown stag=0x%x\n",
> +		__func__, __LINE__, stag);
> +	}
> +
> +	nes_debug(NES_DBG_UD, "%s(%d) done\n", __func__, __LINE__);
> +	return 0;
> +}
> +
> +
> +int nes_ud_unsubscribe_mcast(struct nes_ud_file *file, union ib_gid *gid)
> +{
> +	int ret = 0;
> +	int i;
> +	struct nes_ud_resources *pRsc;
> +
> +	if (file->queue_type == NES_UD_SEND_QUEUE)
> +		return -EFAULT;
> +
> +	pRsc = locate_ud_adapter(file->nesvnic->nesdev->nesadapter);
> +	if (pRsc == NULL)
> +		return -EFAULT;
> +
> +	for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++) {
> +		if (pRsc->mcast[i].in_use &&
> +			pRsc->mcast[i].owner == file &&
> +			pRsc->mcast[i].addr[0] == gid->raw[13] &&
> +			pRsc->mcast[i].addr[1] == gid->raw[14] &&
> +			pRsc->mcast[i].addr[2] == gid->raw[15]) {
> +				pRsc->mcast[i].in_use = 0;
> +				goto out;
> +		}
> +	}
> +
> +	ret = -EFAULT;
> +out:
> +	nes_debug(NES_DBG_UD, "%s(%d) %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X \
> +		ret=%d mcast=%d\n", __func__, __LINE__, gid->raw[10],
> +		gid->raw[11], gid->raw[12], gid->raw[13], gid->raw[14],
> +		gid->raw[15], ret , i);
> +	return ret;
> +
> +}
> +
> +/* function returns a number of allocated multicast entries in given adapter */
> +static int get_mcast_number_alloced(struct nes_ud_resources *pRsc)
> +{
> +	int i;
> +	int no = 0;
> +
> +	for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++) {
> +		if (pRsc->mcast[i].in_use != 0)
> +			no++;
> +
> +	}
> +	return no;
> +}
> +
> +/* function subscribe a multicast group in the system - PFT modification */
> +int nes_ud_subscribe_mcast(struct nes_ud_file *file, union ib_gid *gid)
> +{
> +	struct nes_device *nesdev = file->nesvnic->nesdev;
> +	int ret = 0;
> +	int i;
> +	__u8 hash_idx = 0;
> +	__u8 instance = file->nes_ud_nic_index & 0x1;
> +	unsigned addr = 0;
> +	unsigned mqueue_ind_tbl;
> +	struct nes_ud_resources *pRsc;
> +
> +	struct net_device *netdev = file->nesvnic->netdev;
> +	struct dev_mc_list *mc_list;
> +	int	multicast_address_exist = 0;
> +
> +
> +	if (file->queue_type == NES_UD_SEND_QUEUE)
> +		return -EFAULT;
> +
> +	pRsc = locate_ud_adapter(nesdev->nesadapter);
> +	if (pRsc == NULL)
> +		return -EFAULT;
> +
> +	for (mc_list = netdev->mc_list;
> +		mc_list != NULL;
> +		mc_list = mc_list->next) {
> +		if (mc_list != NULL) {
> +			if ((mc_list->dmi_addr[3] == gid->raw[13]) &&
> +			    (mc_list->dmi_addr[4] == gid->raw[14]) &&
> +			    (mc_list->dmi_addr[5] == gid->raw[15]) &&
> +			    (mc_list->dmi_addr[0] == 0x01) &&
> +			    (mc_list->dmi_addr[1] == 0) &&
> +			    (mc_list->dmi_addr[2] == 0x5e)) {
> +				multicast_address_exist = 1;
> +				break;
> +			}
> +		} else {
> +			break;
> +		}
> +	}
> +
> +	if (multicast_address_exist == 0) {
> +		nes_debug(NES_DBG_UD, "WARNING: multicast address not exist "
> +			"on multicast list\n");
> +		return -EFAULT;
> +	}
> +
> +	/* first check that we have not subecribed to this mcast address, yet */
> +	for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++) {
> +		if ((pRsc->mcast[i].in_use > 0) &&
> +		    (pRsc->mcast[i].addr[0] == gid->raw[13]) &&
> +		    (pRsc->mcast[i].addr[1] == gid->raw[14]) &&
> +		    (pRsc->mcast[i].addr[2] == gid->raw[15])) {
> +			if (pRsc->mcast[i].owner == file) {
> +				nes_debug(NES_DBG_UD, "WARNING - subscribing  "
> +				"mcast to the same nes_ud more than once\n");
> +				break;
> +			} else {
> +		/* receiving the same multicast on different NICs is allowed:
> +			1. when two different NICS are used
> +			2.  exactly one QP exists on this adapter
> +			3. The existing QP was allocated as first
> +				or the second in the system
> +		  */
> +			if (pRsc->mcast[i].owner->nes_ud_nic_index !=
> +						file->nes_ud_nic_index) {
> +				if (get_mcast_number_alloced(pRsc) == 1) {
> +					if ((i == 0) || (i == 1)) {
> +						/* add the mask of other nics
> +						that subscribe this address  */
> +						break;
> +					}
> +				}
> +			}
> +			nes_debug(NES_DBG_UD, "ERROR - subscribing same mcast "
> +				"to the diff nes_ud's and NIC  owner_idx = %d "
> +				"file_idx = %d\n",
> +				pRsc->mcast[i].owner->nes_ud_nic_index,
> +				file->nes_ud_nic_index);
> +			ret = -EFAULT;
> +		    }
> +		    goto out;
> +		}
> +	}
> +
> +	for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++) {
> +		if (!pRsc->mcast[i].in_use) {
> +			pRsc->mcast[i].addr[0] = gid->raw[13];
> +			pRsc->mcast[i].addr[1] = gid->raw[14];
> +			pRsc->mcast[i].addr[2] = gid->raw[15];
> +			pRsc->mcast[i].owner = file;
> +			pRsc->mcast[i].in_use = 1;
> +
> +			hash_idx =
> +				nes_ud_calculate_hash(pRsc->mcast[i].addr[2]);
> +
> +			addr = 0x6420 + ((hash_idx >> 3) << 2) + instance*0x100;
> +			mqueue_ind_tbl = nes_read_indexed(nesdev, addr);
> +			if (file->prio == NES_UD_DEV_PRIO_HIGH)
> +				mqueue_ind_tbl &= ~(1 << ((hash_idx & 0x7)*4));
> +			else
> +				mqueue_ind_tbl |= 1 << ((hash_idx & 0x7)*4);
> +
> +			nes_write_indexed(nesdev, addr, mqueue_ind_tbl);
> +			mqueue_ind_tbl = nes_read_indexed(nesdev, addr);
> +
> +			nes_debug(NES_DBG_UD, "%s(%d) addr=0x%x "
> +				 "mqueue_ind_tbl=0x%x hash=0x%x, mac=0x%x\n",
> +				__func__, __LINE__, addr, mqueue_ind_tbl,
> +				hash_idx, pRsc->mcast[i].addr[2]);
> +			/* take care of the case when linux join_mcast
> +			is called before mcast_attach in that case our pft
> +			will already be programmed with that mcast address,
> +			just with wrong NIC we need just to find an address,
> +			and fix the NIC additionally the mask with other NICs
> +			that subscribed the address are added*/
> +
> +			mcast_fix_filter_table(file);
> +			goto out;
> +		}
> +	}
> +	ret = -EFAULT;
> +
> +out:
> +
> +	nes_debug(NES_DBG_UD, "%s(%d) %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X \
> +		ret=%d\n", __func__, __LINE__, gid->raw[10], gid->raw[11],
> +		gid->raw[12], gid->raw[13], gid->raw[14], gid->raw[15], ret);
> +
> +	return ret;
> +}
> +
> +
> +static inline
> +int nes_ud_post_recv(struct nes_ud_file *file,
> +			u32 adap_no,
> +			struct nes_ud_recv_wr *nes_ud_wr)
> +{
> +	struct nes_hw_nic_rq_wqe *nic_rqe;
> +	struct nes_hw_nic_rq_wqe *rq_vbase =
> +				(struct nes_hw_nic_rq_wqe *)file->wq_vbase;
> +	struct nes_device *nesdev = file->nesvnic->nesdev;
> +	u16 *wqe_fragment_length = NULL;
> +	u32 mr_offset;
> +	u32 page_offset;
> +	u32 page_id;
> +	struct nes_ud_mem_region *mr = NULL;
> +	int remaining_length = 0;
> +	int wqe_fragment_index = 0;
> +	int err = 0;
> +	int i = 0;
> +	struct nes_ud_resources *pRsc;
> +
> +	/* check if qp is activated */
> +	if (file->active == 0)
> +		return -EFAULT;
> +
> +	pRsc = &nes_ud_rsc[adap_no];
> +
> +	/* let's assume for now that max sge count is 1 */
> +	for (i = 0; i < nes_ud_wr->wr_cnt; i++) {
> +		nic_rqe = &rq_vbase[file->head];
> +
> +		mr = nes_ud_lookup_mr(nes_ud_wr->sg_list[i].lkey);
> +		if (mr == NULL)
> +			return -EFAULT;
> +
> +
> +		if (mr->va > nes_ud_wr->sg_list[i].addr ||
> +		    (nes_ud_wr->sg_list[i].addr + nes_ud_wr->sg_list[i].length >
> +							mr->va + mr->length)) {
> +			err = -EFAULT;
> +			goto out;
> +		}
> +
> +		mr_offset = nes_ud_wr->sg_list[i].addr - mr->va;
> +		page_offset = nes_ud_wr->sg_list[i].addr & ~PAGE_MASK;
> +		page_id = ((mr->va & ~PAGE_MASK) + mr_offset) >> PAGE_SHIFT;
> +
> +		wqe_fragment_length =
> +		(u16 *)&nic_rqe->wqe_words[NES_NIC_RQ_WQE_LENGTH_1_0_IDX];
> +
> +		remaining_length = nes_ud_wr->sg_list[i].length;
> +		wqe_fragment_index = 0;
> +
> +		while (remaining_length > 0) {
> +			if (wqe_fragment_index >= 4) {
> +				err = -EFAULT;
> +				goto out;
> +			}
> +
> +			set_wqe_64bit_value(nic_rqe->wqe_words,
> +			NES_NIC_RQ_WQE_FRAG0_LOW_IDX + 2*wqe_fragment_index,
> +				  mr->addrs[page_id]+page_offset);
> +
> +		      wqe_fragment_length[wqe_fragment_index] =
> +				cpu_to_le16(PAGE_SIZE - page_offset);
> +
> +		      remaining_length -= PAGE_SIZE - page_offset;
> +		      page_offset = 0;
> +		      page_id++;
> +		      wqe_fragment_index++;
> +		}
> +
> +		nes_write32(nesdev->regs+NES_WQE_ALLOC, (1 << 24) |  file->qpn);
> +
> +		file->head = (file->head+1) & ~NES_NIC_WQ_SIZE;
> +	}
> +out:
> +	return err;
> +}
> +
> +static inline
> +int nes_ud_post_send(struct nes_ud_file *file,
> +			u32 adap_no,
> +			struct nes_ud_send_wr *nes_ud_wr)
> +{
> +	struct nes_hw_nic_sq_wqe *nic_sqe;
> +	struct nes_hw_nic_sq_wqe *sq_vbase =
> +			(struct nes_hw_nic_sq_wqe *)file->wq_vbase;
> +	struct nes_device *nesdev = file->nesvnic->nesdev;
> +	u16 *wqe_fragment_length = NULL;
> +	u32 mr_offset;
> +	u32 page_offset;
> +	u32 page_id;
> +	struct nes_ud_mem_region *mr = NULL;
> +	int remaining_length = 0;
> +	int wqe_fragment_index = 0;
> +	int err = 0;
> +	int misc_flags = NES_NIC_SQ_WQE_COMPLETION;
> +	int i = 0;
> +	struct nes_ud_resources *pRsc;
> +
> +	/* check if qp is activated */
> +	if (file->active == 0)
> +		return -EFAULT;
> +
> +	pRsc = &nes_ud_rsc[adap_no];
> +
> +	/* check if is not set checksum */
> +	if (!(nes_ud_wr->flags & IB_SEND_IP_CSUM))
> +		misc_flags |= NES_NIC_SQ_WQE_DISABLE_CHKSUM;
> +
> +	/* let's assume for now that max sge count is 1 */
> +	for (i = 0; i < nes_ud_wr->wr_cnt; i++) {
> +		nic_sqe = &sq_vbase[file->head];
> +
> +		mr = nes_ud_lookup_mr(nes_ud_wr->sg_list[i].lkey);
> +		if (mr == NULL)
> +			return -EFAULT;
> +
> +
> +		if ((mr->va > nes_ud_wr->sg_list[i].addr) ||
> +		     (nes_ud_wr->sg_list[i].addr+nes_ud_wr->sg_list[i].length >
> +							mr->va + mr->length)) {
> +
> +			err = -EFAULT;
> +			goto out;
> +		}
> +
> +		mr_offset = nes_ud_wr->sg_list[i].addr - mr->va;
> +		page_offset = nes_ud_wr->sg_list[i].addr & ~PAGE_MASK;
> +		page_id = ((mr->va & ~PAGE_MASK) + mr_offset) >> PAGE_SHIFT;
> +
> +		wqe_fragment_length =
> +		(u16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
> +
> +		wqe_fragment_length++; /* skip vlan tag */
> +		remaining_length = nes_ud_wr->sg_list[i].length;
> +		wqe_fragment_index = 0;
> +
> +		while (remaining_length > 0) {
> +			if (wqe_fragment_index >= 4) {
> +				err = -EFAULT;
> +				goto out;
> +			}
> +			set_wqe_64bit_value(nic_sqe->wqe_words,
> +				NES_NIC_SQ_WQE_FRAG0_LOW_IDX +
> +						2*wqe_fragment_index,
> +				mr->addrs[page_id]+page_offset);
> +		      wqe_fragment_length[wqe_fragment_index] =
> +				cpu_to_le16(PAGE_SIZE - page_offset);
> +		      remaining_length -= PAGE_SIZE - page_offset;
> +		      page_offset = 0;
> +		      page_id++;
> +		      wqe_fragment_index++;
> +		}
> +		nic_sqe->wqe_words[NES_IWARP_SQ_WQE_TOTAL_PAYLOAD_IDX] =
> +				cpu_to_le32(nes_ud_wr->sg_list[i].length);
> +		nic_sqe->wqe_words[NES_NIC_SQ_WQE_MISC_IDX] =
> +						cpu_to_le32(misc_flags);
> +
> +		nes_write32(nesdev->regs+NES_WQE_ALLOC,
> +					(1 << 24) | (1 << 23) | file->qpn);
> +
> +		file->head = (file->head+1) & ~NES_NIC_WQ_SIZE;
> +	}
> +out:
> +	return err;
> +}
> +
> +
> +
> +static void nes_ud_mcast_cleanup_work(struct nes_ud_file *file)
> +{
> +	int i = 0;
> +	int num_queues = count_files_by_nic(file->nesvnic, file->queue_type);
> +	struct nes_ud_resources *pRsc;
> +
> +	pRsc = locate_ud_adapter(file->nesvnic->nesdev->nesadapter);
> +	if (pRsc == NULL)
> +		return;
> +
> +
> +	nes_debug(NES_DBG_UD, "%s(%d) file->rsc_idx=%d\n",
> +			__func__, __LINE__, file->rsc_idx);
> +
> +	mutex_lock(&pRsc->mutex);
> +	for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++) {
> +		if (pRsc->mcast[i].owner == file) {
> +			nes_debug(NES_DBG_UD, "%s(%d) mcast cleared idx=%d "
> +				"%2.2X:%2.2X:%2.2X\n", __func__, __LINE__,
> +				i, pRsc->mcast[i].addr[0],
> +				pRsc->mcast[i].addr[1],
> +				pRsc->mcast[i].addr[2]);
> +
> +			pRsc->mcast[i].in_use = 0;
> +			remove_mcast_from_pft(file, pRsc->mcast[i].addr);
> +		}
> +	}
> +
> +	if (del_rsc_list(file) == 0) {
> +		if (num_queues == 1)
> +			file->nesvnic->mcrq_mcast_filter = NULL;
> +
> +	}
> +	mutex_unlock(&pRsc->mutex);
> +}
> +
> +struct nes_ud_file *nes_ud_create_wq(struct nes_vnic *nesvnic, int isrecv)
> +{
> +	struct nes_ud_file *file;
> +	int ret = 0;
> +	file = nes_ud_get_nxt_channel(nesvnic, (isrecv) ?
> +				NES_UD_RECV_QUEUE : NES_UD_SEND_QUEUE);
> +	if (!file)
> +		return NULL;
> +
> +
> +	ret =  nes_ud_init_channel(file);
> +	if (ret != 0) {
> +		del_rsc_list(file);
> +		return NULL;
> +	}
> +
> +	dev_hold(file->nesvnic->netdev);
> +
> +	nes_debug(NES_DBG_UD, "%s(%d) file=%p\n", __func__, __LINE__, file);
> +	return file;
> +}
> +
> +
> +
> +int nes_ud_destroy_wq(struct nes_ud_file *file)
> +{
> +	struct nes_ud_resources *pRsc;
> +	int count = 0;
> +	int i;
> +	pRsc = locate_ud_adapter(file->nesvnic->nesdev->nesadapter);
> +	if (pRsc == NULL)
> +		return -EFAULT;
> +
> +	if (file->active) {
> +		nes_ud_mcast_cleanup_work(file);
> +		nes_ud_free_resources(file);
> +	}
> +
> +	/* check if the the adapter has any queues */
> +	for (i = 0; i < NES_UD_MAX_NIC_CNT; i++) {
> +		if (pRsc->nics[i].file->active != 0)
> +			count++;
> +
> +	}
> +	if (count == 0) {
> +		nes_debug(NES_DBG_UD, "%s(%d) adapter %d "
> +				"is ready to next use\n",
> +				__func__, __LINE__, pRsc->adapter_no);
> +		pRsc->pAdap = NULL;
> +	}
> +	nes_debug(NES_DBG_UD, "%s(%d) done\n", __func__, __LINE__);
> +	return 0;
> +}
> +
> +
> +struct nes_ud_sksq_file {
> +	unsigned long shared_page;
> +	struct nes_ud_file *nes_ud_send_file;
> +	struct nes_ud_file *nes_ud_recv_file;
> +};
> +
> +static ssize_t nes_ud_sksq_write(struct file *filp, const char __user *buf,
> +		size_t len, loff_t *pos)
> +{
> +	struct nes_ud_sksq_file *file = filp->private_data;
> +	struct nes_ud_send_wr *nes_ud_wr =
> +			(struct nes_ud_send_wr *)file->shared_page;
> +	u32 adap_no;
> +	u32 nic_no;
> +
> +	nic_no = ((nes_ud_wr->qpn >> 16) & 0x0f00) >> 8;
> +	adap_no = ((nes_ud_wr->qpn >> 16) & 0xf000) >> 12;
> +	if (unlikely(!file->nes_ud_send_file)) {
> +		struct nes_ud_file *nes_ud_file = NULL;
> +
> +	nes_ud_file = nes_ud_rsc[adap_no].nics[nic_no].file;
> +	/* the nic must be active and previously activated */
> +	if ((nes_ud_file->active == 0) ||
> +		(nes_ud_file->qpn != ((nes_ud_wr->qpn >> 16) & 0xff)))
> +			return -EAGAIN;
> +
> +		file->nes_ud_send_file = nes_ud_file;
> +		nes_debug(NES_DBG_UD, "send shared page addr = %p "
> +				"adap_no = %d nic_no=%d qpn=%x\n",
> +				nes_ud_wr, adap_no, nic_no, nes_ud_wr->qpn);
> +  }
> +  return nes_ud_post_send(file->nes_ud_send_file, adap_no, nes_ud_wr);
> +
> +}
> +
> +static ssize_t nes_ud_sksq_read(struct file *filp, char __user *buf,
> +		size_t len, loff_t *pos)
> +{
> +	struct nes_ud_sksq_file *file = filp->private_data;
> +	struct nes_ud_recv_wr *nes_ud_recv_wr;
> +	u32 adap_no;
> +	u32 nic_no;
> +
> +	nes_ud_recv_wr = (struct nes_ud_recv_wr *)(file->shared_page+2048);
> +	adap_no = (nes_ud_recv_wr->qpn & 0xf000) >> 12;
> +	nic_no = (nes_ud_recv_wr->qpn & 0x0f00) >> 8;
> +
> +	if (unlikely(!file->nes_ud_recv_file)) {
> +		struct nes_ud_file *nes_ud_file = NULL;
> +
> +		nes_ud_file = nes_ud_rsc[adap_no].nics[nic_no].file;
> +		/* the nic must be active and previously activated */
> +		if ((nes_ud_file->active == 0) ||
> +			(nes_ud_file->qpn != (nes_ud_recv_wr->qpn & 0xff)))
> +				return -EAGAIN;
> +
> +		file->nes_ud_recv_file  = nes_ud_file;
> +		nes_debug(NES_DBG_UD, "recv shared page addr = %p "
> +				"adap_no = %d nic_no=%d qpn=%x\n",
> +			nes_ud_recv_wr, adap_no, nic_no, nes_ud_recv_wr->qpn);
> +	}
> +	return nes_ud_post_recv(file->nes_ud_recv_file,
> +				adap_no, nes_ud_recv_wr);
> +}
> +
> +static int nes_ud_sksq_mmap(struct file *filp, struct vm_area_struct *vma)
> +{
> +	struct nes_ud_sksq_file *file = filp->private_data;
> +
> +	nes_debug(NES_DBG_UD, "shared mem pgprot_val(prot)=0x%x pa=%p\n",
> +			(unsigned int)pgprot_val(vma->vm_page_prot),
> +			(void *)virt_to_phys((void *)file->shared_page));
> +	if (remap_pfn_range(vma, vma->vm_start,
> +			virt_to_phys((void *)file->shared_page) >> PAGE_SHIFT,
> +			 PAGE_SIZE, vma->vm_page_prot)) {
> +		printk(KERN_ERR "remap_pfn_range failed.\n");
> +		return -EAGAIN;
> +	}
> +	return 0;
> +}
> +
> +
> +static int nes_ud_sksq_open(struct inode *inode, struct file *filp)
> +{
> +	struct nes_ud_sksq_file *file;
> +
> +	file = kmalloc(sizeof *file, GFP_KERNEL);
> +	if (!file)
> +		return -ENOMEM;
> +
> +	memset(file, 0, sizeof *file);
> +	nes_debug(NES_DBG_UD, "%s(%d) file=%p\n",
> +			__func__, __LINE__, file);
> +
> +	filp->private_data = file;
> +	file->nes_ud_send_file = NULL;
> +	file->nes_ud_recv_file = NULL;
> +
> +	file->shared_page = __get_free_page(GFP_USER);
> +	return 0;
> +}
> +
> +static int nes_ud_sksq_close(struct inode *inode, struct file *filp)
> +{
> +
> +	struct nes_ud_sksq_file *file = filp->private_data;
> +
> +	if (file->shared_page) {
> +		free_page(file->shared_page);
> +		file->shared_page = 0;
> +	}
> +	kfree(file);
> +	return 0;
> +}
> +
> +static const struct file_operations nes_ud_sksq_fops = {
> +	.owner = THIS_MODULE,
> +	.open = nes_ud_sksq_open,
> +	.release = nes_ud_sksq_close,
> +	.write = nes_ud_sksq_write,
> +	.read = nes_ud_sksq_read,
> +	.mmap = nes_ud_sksq_mmap,
> +};
> +
> +
> +static struct miscdevice nes_ud_sksq_misc = {
> +	.minor = MISC_DYNAMIC_MINOR,
> +	.name = "nes_ud_sksq",
> +	.fops = &nes_ud_sksq_fops,
> +};
> +
> +/*
> + * function replaces the CQ pointer in QP stored in the file
> + * the QP must have a valid CQ pointers assotiated with it
> + */
> +int nes_ud_cq_replace(struct nes_vnic *nesvnic, struct nes_cq *cq)
> +{
> +	u32 cq_num;
> +	struct nes_ud_file *file;
> +	struct nes_ud_resources *pRsc;
> +
> +	BUG_ON(!cq);
> +
> +	pRsc = locate_ud_adapter(nesvnic->nesdev->nesadapter);
> +	if (pRsc == NULL)
> +		return -EFAULT;
> +
> +
> +	/* now create a QP number on base cq and adapter no */
> +	cq_num = cq->hw_cq.cq_number;
> +
> +	nes_debug(NES_DBG_UD, "%s(%d) cq_number=%d\n",
> +			__func__, __LINE__, cq_num);
> +
> +	/* the QP number should have the same number like CQ number */
> +	file = get_file_by_qpn(pRsc, cq_num);
> +	if (!file) {
> +		nes_debug(NES_DBG_UD, "%s(%d) file not found\n",
> +				__func__, __LINE__);
> +		return -EFAULT;
> +	}
> +	if (file->qp_ptr) {
> +		if (file->queue_type == NES_UD_RECV_QUEUE) {
> +			nes_debug(NES_DBG_UD, "%s(%d) RECV file found "
> +			"old=%p new=%p\n", __func__, __LINE__,
> +			file->qp_ptr->ibqp.recv_cq, cq);
> +			file->qp_ptr->ibqp.recv_cq = &cq->ibcq;
> +		}
> +		if (file->queue_type == NES_UD_SEND_QUEUE) {
> +			nes_debug(NES_DBG_UD, "%s(%d) SEND file found "
> +			"old=%p new=%p\n", __func__, __LINE__,
> +			file->qp_ptr->ibqp.send_cq, cq);
> +
> +			file->qp_ptr->ibqp.send_cq = &cq->ibcq;
> +		}
> +	}
> +	return 0;
> +}
> +int nes_ud_init(void)
> +{
> +	int i = 0;
> +	int adap_no;
> +	struct nes_ud_resources *pRsc;
> +
> +	nes_debug(NES_DBG_UD, "%s(%d)\n", __func__, __LINE__);
> +
> +	/* the memory registration is global for all NICS */
> +	memset(&ud_mem, 0, sizeof(ud_mem));
> +
> +	/* init hash list of memory entries */
> +	for (i = 0; i < NES_UD_MAX_REG_HASH_CNT; i++) {
> +		INIT_LIST_HEAD(&ud_mem.mrs[i].list);
> +		ud_mem.mrs[i].read_stats = 0;
> +	}
> +	mutex_init(&ud_mem.mutex);
> +
> +	/*allocate resources fro each adapter */
> +	for (adap_no = 0; adap_no < NES_UD_MAX_ADAPTERS; adap_no++) {
> +		pRsc = &nes_ud_rsc[adap_no];
> +
> +		memset(pRsc, 0, sizeof(*pRsc));
> +
> +		mutex_init(&pRsc->mutex);
> +
> +		pRsc->adapter_no = adap_no;
> +		pRsc->pAdap = NULL;
> +
> +		pRsc->num_logport_confed = 0;
> +		pRsc->num_allocated_nics = 0;
> +		pRsc->logport_2_map = 0xf;
> +		pRsc->logport_3_map = 0xf;
> +		for (i = 0; i < NES_UD_MCAST_TBL_SZ; i++)
> +			pRsc->mcast[i].in_use = 0;
> +
> +		pRsc->nics[0].qpn = 20;
> +		pRsc->nics[0].nic_index = 2;
> +		pRsc->nics[0].logical_port = 2;
> +		pRsc->nics[0].prio = NES_UD_DEV_PRIO_HIGH;
> +		pRsc->nics[0].queue_type = NES_UD_RECV_QUEUE;
> +		pRsc->nics[0].file = &pRsc->nics[0].file_body;
> +
> +		pRsc->nics[1].qpn = 22;
> +		pRsc->nics[1].nic_index = 3;
> +		pRsc->nics[1].logical_port = 3;
> +		pRsc->nics[1].prio = NES_UD_DEV_PRIO_HIGH;
> +		pRsc->nics[1].queue_type = NES_UD_RECV_QUEUE;
> +		pRsc->nics[1].file = &pRsc->nics[1].file_body;
> +
> +		pRsc->nics[2].qpn = 21;
> +		pRsc->nics[2].nic_index = 2;
> +		pRsc->nics[2].logical_port = 2;
> +		pRsc->nics[2].prio = NES_UD_DEV_PRIO_LOW;
> +		pRsc->nics[2].queue_type = NES_UD_RECV_QUEUE;
> +		pRsc->nics[2].file = &pRsc->nics[2].file_body;
> +
> +		pRsc->nics[3].qpn = 23;
> +		pRsc->nics[3].nic_index = 3;
> +		pRsc->nics[3].logical_port = 3;
> +		pRsc->nics[3].prio = NES_UD_DEV_PRIO_LOW;
> +		pRsc->nics[3].queue_type = NES_UD_RECV_QUEUE;
> +		pRsc->nics[3].file = &pRsc->nics[3].file_body;
> +
> +		pRsc->nics[4].qpn = 26;
> +		pRsc->nics[4].nic_index = 6;
> +		pRsc->nics[4].logical_port = 2;
> +		pRsc->nics[4].prio = NES_UD_DEV_PRIO_HIGH;
> +		pRsc->nics[4].queue_type = NES_UD_SEND_QUEUE;
> +		pRsc->nics[4].file = &pRsc->nics[4].file_body;
> +
> +		pRsc->nics[5].qpn = 27;
> +		pRsc->nics[5].nic_index = 7;
> +		pRsc->nics[5].logical_port = 3;
> +		pRsc->nics[5].prio = NES_UD_DEV_PRIO_HIGH;
> +		pRsc->nics[5].queue_type = NES_UD_SEND_QUEUE;
> +		pRsc->nics[5].file = &pRsc->nics[5].file_body;
> +
> +		pRsc->nics[6].qpn = 30;
> +		pRsc->nics[6].nic_index = 10;
> +		pRsc->nics[6].logical_port = 2;
> +		pRsc->nics[6].prio = NES_UD_DEV_PRIO_LOW;
> +		pRsc->nics[6].queue_type = NES_UD_SEND_QUEUE;
> +		pRsc->nics[6].file = &pRsc->nics[6].file_body;
> +
> +		pRsc->nics[7].qpn = 31;
> +		pRsc->nics[7].nic_index = 11;
> +		pRsc->nics[7].logical_port = 3;
> +		pRsc->nics[7].prio = NES_UD_DEV_PRIO_LOW;
> +		pRsc->nics[7].queue_type = NES_UD_SEND_QUEUE;
> +		pRsc->nics[7].file = &pRsc->nics[7].file_body;
> +
> +	}
> +	nes_ud_workqueue = create_singlethread_workqueue("nes_ud");
> +
> +	return misc_register(&nes_ud_sksq_misc);
> +}
> +
> +
> +int nes_ud_exit(void)
> +{
> +	/* clean memory hash list */
> +	nes_ud_cleanup_mr();
> +	misc_deregister(&nes_ud_sksq_misc);
> +	return 0;
> +}
> +
> diff --git a/drivers/infiniband/hw/nes/nes_ud.h b/drivers/infiniband/hw/nes/nes_ud.h
> new file mode 100644
> index 0000000..5a03b33
> --- /dev/null
> +++ b/drivers/infiniband/hw/nes/nes_ud.h
> @@ -0,0 +1,86 @@
> +/*
> + * Copyright (c) 2008 - 2010 Intel Corporation.  All rights reserved.
> + * Copyright (c) 2006 - 2008 Neteffect, All rights reserved.
> + * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
> + *
> + * This software is available to you under a choice of one of two
> + * licenses.  You may choose to be licensed under the terms of the GNU
> + * General Public License (GPL) Version 2, available from the file
> + * COPYING in the main directory of this source tree, or the
> + * OpenIB.org BSD license below:
> + *
> + *     Redistribution and use in source and binary forms, with or
> + *     without modification, are permitted provided that the following
> + *     conditions are met:
> + *
> + *      - Redistributions of source code must retain the above
> + *        copyright notice, this list of conditions and the following
> + *        disclaimer.
> + *
> + *      - 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.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
> + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
> + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
> + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
> + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
> + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
> + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
> + * SOFTWARE.
> + */
> +#ifndef __NES_UD_H
> +#define __NES_UD_H
> +
> +enum nes_ud_dev_priority {
> +	NES_UD_DEV_PRIO_HIGH,
> +	NES_UD_DEV_PRIO_LOW,
> +};
> +
> +enum nes_ud_queue_type {
> +  NES_UD_RECV_QUEUE,
> +  NES_UD_SEND_QUEUE,
> +};
> +
> +enum nes_ud_mcast_mode {
> +  NES_UD_MCAST_ALL_MODE,
> +  NES_UD_MCAST_PFT_MODE,
> +};
> +
> +
> +struct nes_ud_file {
> +	struct nes_vnic *nesvnic;
> +	u8 active;
> +	char ifrn_name[IFNAMSIZ];
> +	int nes_ud_nic_index;
> +	int qpn;
> +	enum nes_ud_dev_priority prio;
> +	enum nes_ud_mcast_mode mcast_mode;
> +	enum nes_ud_queue_type queue_type;
> +	void      *nic_vbase;
> +	dma_addr_t nic_pbase;
> +	int        nic_mem_size;
> +	void      *wq_vbase;
> +	dma_addr_t wq_pbase;
> +	int mss;
> +	struct delayed_work mcast_cleanup_work;
> +	int head;
> +	int tail;
> +	u32 rsc_idx;
> +	struct nes_qp *qp_ptr; /* it is association used for CQ replacement */
> +	u32 adapter_no;    /* assotiation to allocated adapter */
> +};
> +
> +int nes_ud_init(void);
> +int nes_ud_exit(void);
> +struct nes_ud_file *nes_ud_create_wq(struct nes_vnic *nesvnic, int isrecv);
> +int nes_ud_destroy_wq(struct nes_ud_file *file);
> +u32 nes_ud_reg_mr(struct ib_umem *region, u64 length, u64 virt, u32 stag);
> +int nes_ud_dereg_mr(u32 stag);
> +int nes_ud_subscribe_mcast(struct nes_ud_file *file, union ib_gid *gid);
> +int nes_ud_unsubscribe_mcast(struct nes_ud_file *file, union ib_gid *gid);
> +int nes_ud_cq_replace(struct nes_vnic *nesvnic, struct nes_cq *cq);
> +
> +#endif
> diff --git a/drivers/infiniband/hw/nes/nes_verbs.c b/drivers/infiniband/hw/nes/nes_verbs.c
> index e54f312..ff39235 100644
> --- a/drivers/infiniband/hw/nes/nes_verbs.c
> +++ b/drivers/infiniband/hw/nes/nes_verbs.c
> @@ -46,6 +46,8 @@
>  
>  #include <rdma/ib_umem.h>
>  
> +#include "nes_ud.h"
> +
>  atomic_t mod_qp_timouts;
>  atomic_t qps_created;
>  atomic_t sw_qps_destroyed;
> @@ -1139,7 +1141,6 @@ static struct ib_qp *nes_create_qp(struct ib_pd *ibpd,
>  	if (init_attr->create_flags)
>  		return ERR_PTR(-EINVAL);
>  
> -	atomic_inc(&qps_created);
>  	switch (init_attr->qp_type) {
>  		case IB_QPT_RC:
>  			if (nes_drv_opt & NES_DRV_OPT_NO_INLINE_DATA) {
> @@ -1405,10 +1406,122 @@ static struct ib_qp *nes_create_qp(struct ib_pd *ibpd,
>  					nesqp->hwqp.qp_id, nesqp, (u32)sizeof(*nesqp));
>  			spin_lock_init(&nesqp->lock);
>  			nes_add_ref(&nesqp->ibqp);
> +			/* moved here to be sure that QP is really created */
> +			/*(now it counted a number of QP creation trials */
> +			atomic_inc(&qps_created);
>  			break;
> -		default:
> -			nes_debug(NES_DBG_QP, "Invalid QP type: %d\n", init_attr->qp_type);
> -			return ERR_PTR(-EINVAL);
> +
> +	case IB_QPT_RAW_ETY:
> +	if (!ibpd->uobject)
> +		return ERR_PTR(-EINVAL);
> +
> +	/* we are about to destroy those cqs w/o destroying qp
> +	 now free memory for nespbl that is not used
> +	 first map nespbl with the qp created */
> +	if (ibpd->uobject->context) {
> +		nes_ucontext = to_nesucontext(ibpd->uobject->context);
> +		if (udata) {
> +			if (ib_copy_from_udata(&req,
> +				udata,
> +				sizeof(struct nes_create_qp_req))) {
> +				return ERR_PTR(-EFAULT);
> +			}
> +			if (req.user_wqe_buffers) {
> +				err = 1;
> +				list_for_each_entry(nespbl,
> +				&nes_ucontext->qp_reg_mem_list,
> +				list) {
> +					if (nespbl->user_base ==
> +						req.user_wqe_buffers) {
> +						list_del(&nespbl->list);
> +						err = 0;
> +						/* done with memory allocated
> +						during nes_reg_user_mr() */
> +						pci_free_consistent(
> +							nesdev->pcidev,
> +							nespbl->pbl_size,
> +							nespbl->pbl_vbase,
> +							nespbl->pbl_pbase);
> +						kfree(nespbl);
> +						break;
> +					}
> +				}
> +			}
> +		}
> +	}
> +	/* Need 512 (actually now 1024) byte alignment on this structure */
> +	mem = kzalloc(sizeof(*nesqp)+NES_SW_CONTEXT_ALIGN-1, GFP_KERNEL);
> +	if (!mem) {
> +		nes_debug(NES_DBG_UD, "Unable to allocate QP\n");
> +		return ERR_PTR(-ENOMEM);
> +	}
> +	u64nesqp = (unsigned long)mem;
> +	u64nesqp += ((u64)NES_SW_CONTEXT_ALIGN) - 1;
> +	u64temp = ((u64)NES_SW_CONTEXT_ALIGN) - 1;
> +	u64nesqp &= ~u64temp;
> +	nesqp = (struct nes_qp *)(unsigned long)u64nesqp;
> +	nesqp->allocated_buffer = mem;
> +
> +	nesqp->rx_ud_wq = nes_ud_create_wq(nesvnic, 1);
> +	nesqp->tx_ud_wq = nes_ud_create_wq(nesvnic, 0);
> +	if ((!nesqp->rx_ud_wq) || (!nesqp->tx_ud_wq)) {
> +		kfree(nesqp->allocated_buffer);
> +		return ERR_PTR(-EFAULT);
> +	}
> +
> +	/* create association between qp and tx/rx files
> +	 it is used when CQ is replaced from user space */
> +	nesqp->rx_ud_wq->qp_ptr = nesqp;
> +	nesqp->tx_ud_wq->qp_ptr = nesqp;
> +
> +	sq_size = init_attr->cap.max_send_wr;
> +	rq_size = init_attr->cap.max_recv_wr;
> +	nes_debug(NES_DBG_UD, "%s(%d) sq_size=%d rq_size=%d\n",
> +				__func__,
> +				__LINE__, sq_size, rq_size);
> +	uresp.actual_sq_size = sq_size;
> +	uresp.actual_rq_size = rq_size;
> +
> +	/* Init qp size due to ibv_query_qp requirements */
> +	nesqp->hwqp.sq_size = sq_size;
> +	nesqp->hwqp.rq_size = rq_size;
> +
> +	/* enhance the response qp number with adapter number and QP number
> +	on this adapter
> +	 user space will use this identifier when packets will be posted */
> +	uresp.qp_id = nesqp->rx_ud_wq->qpn |
> +			(nesqp->rx_ud_wq->adapter_no << 12) |
> +			(nesqp->rx_ud_wq->rsc_idx << 8);
> +	uresp.qp_id = uresp.qp_id |
> +			((nesqp->tx_ud_wq->qpn |
> +			(nesqp->tx_ud_wq->adapter_no << 12) |
> +			(nesqp->tx_ud_wq->rsc_idx << 8)) << 16);
> +
> +	nesqp->hwqp.qp_id = uresp.qp_id;
> +	nesqp->ibqp.qp_num = uresp.qp_id;
> +
> +	nes_debug(NES_DBG_UD, "%s(%d) qpid=0x%x\n",
> +			__func__, __LINE__, uresp.qp_id);
> +	if (ib_copy_to_udata(udata, &uresp, sizeof uresp)) {
> +		kfree(nesqp->allocated_buffer);
> +		return ERR_PTR(-EFAULT);
> +	}
> +	/* the usecount is decreased because without it
> +	the cq re-creation in user-spce will fail */
> +	atomic_dec(&init_attr->send_cq->usecnt);
> +	atomic_dec(&init_attr->recv_cq->usecnt);
> +	nes_add_ref(&nesqp->ibqp);
> +	spin_lock_init(&nesqp->lock);
> +
> +	/* moved here to be sure that QP is really created
> +	(now it counted a number of QP creation trials */
> +	atomic_inc(&qps_created);
> +	return &nesqp->ibqp;
> +
> +	default:
> +		nes_debug(NES_DBG_QP, "Invalid QP type: %d\n",
> +					init_attr->qp_type);
> +		return ERR_PTR(-EINVAL);
>  	}
>  
>  	nesqp->sig_all = (init_attr->sq_sig_type == IB_SIGNAL_ALL_WR);
> @@ -1462,6 +1575,8 @@ static void nes_clean_cq(struct nes_qp *nesqp, struct nes_cq *nescq)
>  static int nes_destroy_qp(struct ib_qp *ibqp)
>  {
>  	struct nes_qp *nesqp = to_nesqp(ibqp);
> +	struct nes_cq *scq;
> +	struct nes_cq *rcq;
>  	struct nes_ucontext *nes_ucontext;
>  	struct ib_qp_attr attr;
>  	struct iw_cm_id *cm_id;
> @@ -1471,6 +1586,39 @@ static int nes_destroy_qp(struct ib_qp *ibqp)
>  	atomic_inc(&sw_qps_destroyed);
>  	nesqp->destroyed = 1;
>  
> +	if (nesqp->ibqp.qp_type == IB_QPT_RAW_ETY) {
> +		/* check the QP refernece count */
> +		if (atomic_read(&nesqp->refcount) == 0)
> +			BUG();
> +		if (atomic_dec_and_test(&nesqp->refcount)) {
> +			/* destroy send and rcv  QPs */
> +			if (nesqp->rx_ud_wq)
> +				nes_ud_destroy_wq(nesqp->rx_ud_wq);
> +			nesqp->rx_ud_wq = 0;
> +
> +			if (nesqp->tx_ud_wq)
> +				nes_ud_destroy_wq(nesqp->tx_ud_wq);
> +			nesqp->tx_ud_wq = 0;
> +			atomic_inc(&qps_destroyed);
> +
> +			/* to prevent the destroy of cq before QP
> +			destroy the usecount is used */
> +			if (ibqp->send_cq) {
> +				scq = to_nescq(ibqp->send_cq);
> +				atomic_inc(&ibqp->send_cq->usecnt);
> +				atomic_dec(&scq->usecnt);
> +			}
> +			if (ibqp->recv_cq) {
> +				rcq = to_nescq(ibqp->recv_cq);
> +				atomic_inc(&ibqp->recv_cq->usecnt);
> +				atomic_dec(&rcq->usecnt);
> +			}
> +			/* free memory for the qp */
> +			kfree(nesqp->allocated_buffer);
> +		}
> +		return 0;
> +	}
> +
>  	/* Blow away the connection if it exists. */
>  	if (nesqp->ibqp_state >= IB_QPS_INIT && nesqp->ibqp_state <= IB_QPS_RTS) {
>  		/* if (nesqp->ibqp_state == IB_QPS_RTS) { */
> @@ -1567,9 +1715,18 @@ static struct ib_cq *nes_create_cq(struct ib_device *ibdev, int entries,
>  		return ERR_PTR(-ENOMEM);
>  	}
>  
> +	/* to make sure that RAW ETH cq will be not destoyed
> +	without qp destroy the internal usecount is used
> +	 the ibcq usecount cannot be used because the  RAW ETH makes
> +	recreation of the CQs after QP creation
> +	 when this situation occured (mcrqf != 0) the usecount is increase
> +	 the ibcq usecount is cleared after successfull CQ creation */
> +	atomic_set(&nescq->usecnt, 0);
> +
>  	nescq->hw_cq.cq_size = max(entries + 1, 5);
>  	nescq->hw_cq.cq_number = cq_num;
>  	nescq->ibcq.cqe = nescq->hw_cq.cq_size - 1;
> +	nescq->mcrqf = 0;
>  
>  
>  	if (context) {
> @@ -1586,8 +1743,23 @@ static struct ib_cq *nes_create_cq(struct ib_device *ibdev, int entries,
>  				nescq->hw_cq.cq_number = nesvnic->nic.qp_id + 28 + 2 * ((nes_ucontext->mcrqf & 0xf) - 1);
>  			else if (nes_ucontext->mcrqf & 0x40000000)
>  				nescq->hw_cq.cq_number = nes_ucontext->mcrqf & 0xffff;
> +			else if (nes_ucontext->mcrqf & 0x20000000) {
> +				/* the cq number is coded
> +						adapter:4/nic:4/cq_num:8 */
> +				nescq->hw_cq.cq_number =
> +						nes_ucontext->mcrqf & 0x00ff;
> +
> +				/* to prevent the cq destroy before qp destroy
> +				the internal usecount is increased
> +				in this place it is the  RAW ETH specific CQ
> +				(after re-creation)
> +				only  RAW ETH type QP destroy can decrease
> +				this usecounter */
> +				atomic_inc(&nescq->usecnt);
> +			}
>  			else
>  				nescq->hw_cq.cq_number = nesvnic->mcrq_qp_id + nes_ucontext->mcrqf-1;
> +
>  			nescq->mcrqf = nes_ucontext->mcrqf;
>  			nes_free_resource(nesadapter, nesadapter->allocated_cqs, cq_num);
>  		}
> @@ -1776,6 +1948,10 @@ static struct ib_cq *nes_create_cq(struct ib_device *ibdev, int entries,
>  			kfree(nescq);
>  			return ERR_PTR(-EFAULT);
>  		}
> +		if (nes_ucontext->mcrqf & 0x20000000) {
> +			/* change the cq address only for  RAW in QP pointer */
> +			nes_ud_cq_replace(nesvnic, nescq);
> +		}
>  	}
>  
>  	return &nescq->ibcq;
> @@ -1805,6 +1981,11 @@ static int nes_destroy_cq(struct ib_cq *ib_cq)
>  	nesdev = nesvnic->nesdev;
>  	nesadapter = nesdev->nesadapter;
>  
> +	if (atomic_read(&nescq->usecnt) != 0) {
> +		nes_debug(NES_DBG_CQ, "CQ is in use now. %d\n",
> +				(int) atomic_read(&nescq->usecnt));
> +		return -EBUSY;
> +	}
>  	nes_debug(NES_DBG_CQ, "Destroy CQ%u\n", nescq->hw_cq.cq_number);
>  
>  	/* Send DestroyCQ request to CQP */
> @@ -2540,6 +2721,13 @@ static struct ib_mr *nes_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
>  				nesmr->ibmr.lkey = stag;
>  				nesmr->mode = IWNES_MEMREG_TYPE_MEM;
>  				ibmr = &nesmr->ibmr;
> +				/* register memory parallelly for RAW ETH */
> +				if (nes_ud_reg_mr(region, length,
> +						virt, stag) == 0) {
> +					ib_umem_release(region);
> +					kfree(nesmr);
> +					ibmr = ERR_PTR(-ENOMEM);
> +				}
>  			} else {
>  				ib_umem_release(region);
>  				kfree(nesmr);
> @@ -2733,6 +2921,9 @@ static int nes_dereg_mr(struct ib_mr *ib_mr)
>  	}
>  	nes_free_resource(nesadapter, nesadapter->allocated_mrs,
>  			(ib_mr->rkey & 0x0fffff00) >> 8);
> +	ret = nes_ud_dereg_mr(ib_mr->rkey);
> +	if (ret != 0)
> +		return ret;
>  
>  	kfree(nesmr);
>  
> @@ -2939,6 +3130,9 @@ int nes_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
>  			nesqp->hwqp.qp_id, attr->qp_state, nesqp->ibqp_state,
>  			nesqp->iwarp_state, atomic_read(&nesqp->refcount));
>  
> +	if (ibqp->qp_type == IB_QPT_RAW_ETY)
> +		return 0;
> +
>  	spin_lock_irqsave(&nesqp->lock, qplockflags);
>  
>  	nes_debug(NES_DBG_MOD_QP, "QP%u: hw_iwarp_state=0x%X, hw_tcp_state=0x%X,"
> @@ -3208,8 +3402,10 @@ int nes_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
>   */
>  static int nes_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
>  {
> -	nes_debug(NES_DBG_INIT, "\n");
> -	return -ENOSYS;
> +	int ret =  -ENOSYS;
> +	struct nes_qp *nesqp = to_nesqp(ibqp);
> +	ret =  nes_ud_subscribe_mcast(nesqp->rx_ud_wq, gid);
> +	return ret;
>  }
>  
>  
> @@ -3218,8 +3414,10 @@ static int nes_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
>   */
>  static int nes_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
>  {
> -	nes_debug(NES_DBG_INIT, "\n");
> -	return -ENOSYS;
> +	int ret =  -ENOSYS;
> +	struct nes_qp *nesqp = to_nesqp(ibqp);
> +	ret =  nes_ud_unsubscribe_mcast(nesqp->rx_ud_wq, gid);
> +	return ret;
>  }
>  
>  
> @@ -3846,6 +4044,7 @@ struct nes_ib_device *nes_init_ofa_device(struct net_device *netdev)
>  		return NULL;
>  	}
>  	strlcpy(nesibdev->ibdev.name, "nes%d", IB_DEVICE_NAME_MAX);
> +	strcpy(nesibdev->ibdev.name, netdev->name);
>  	nesibdev->ibdev.owner = THIS_MODULE;
>  
>  	nesibdev->ibdev.node_type = RDMA_NODE_RNIC;
> @@ -3868,6 +4067,9 @@ struct nes_ib_device *nes_init_ofa_device(struct net_device *netdev)
>  			(1ull << IB_USER_VERBS_CMD_REQ_NOTIFY_CQ) |
>  			(1ull << IB_USER_VERBS_CMD_CREATE_QP) |
>  			(1ull << IB_USER_VERBS_CMD_MODIFY_QP) |
> +			(1ull << IB_USER_VERBS_CMD_QUERY_QP) |
> +			(1ull << IB_USER_VERBS_CMD_ATTACH_MCAST) |
> +			(1ull << IB_USER_VERBS_CMD_DETACH_MCAST) |
>  			(1ull << IB_USER_VERBS_CMD_POLL_CQ) |
>  			(1ull << IB_USER_VERBS_CMD_DESTROY_QP) |
>  			(1ull << IB_USER_VERBS_CMD_ALLOC_MW) |
> @@ -3911,8 +4113,9 @@ struct nes_ib_device *nes_init_ofa_device(struct net_device *netdev)
>  	nesibdev->ibdev.alloc_fast_reg_page_list = nes_alloc_fast_reg_page_list;
>  	nesibdev->ibdev.free_fast_reg_page_list = nes_free_fast_reg_page_list;
>  
> -	nesibdev->ibdev.attach_mcast = nes_multicast_attach;
>  	nesibdev->ibdev.detach_mcast = nes_multicast_detach;
> +	nesibdev->ibdev.attach_mcast = nes_multicast_attach;
> +
>  	nesibdev->ibdev.process_mad = nes_process_mad;
>  
>  	nesibdev->ibdev.req_notify_cq = nes_req_notify_cq;
> diff --git a/drivers/infiniband/hw/nes/nes_verbs.h b/drivers/infiniband/hw/nes/nes_verbs.h
> index 2df9993..cbb6585 100644
> --- a/drivers/infiniband/hw/nes/nes_verbs.h
> +++ b/drivers/infiniband/hw/nes/nes_verbs.h
> @@ -79,6 +79,7 @@ struct nes_mr {
>  	u16               pbls_used;
>  	u8                mode;
>  	u8                pbl_4k;
> +	u32               mcrqf;
>  };
>  
>  struct nes_hw_pb {
> @@ -116,7 +117,8 @@ struct nes_cq {
>  	spinlock_t       lock;
>  	u8               virtual_cq;
>  	u8               pad[3];
> -	u32		 mcrqf;
> +	atomic_t         usecnt;
> +	u32              mcrqf;
>  };
>  
>  struct nes_wq {
> @@ -130,6 +132,7 @@ struct disconn_work {
>  
>  struct iw_cm_id;
>  struct ietf_mpa_frame;
> +struct nes_ud_file;
>  
>  struct nes_qp {
>  	struct ib_qp          ibqp;
> @@ -176,5 +179,7 @@ struct nes_qp {
>  	u8                    hw_tcp_state;
>  	u8                    term_flags;
>  	u8                    sq_kmapped;
> +	struct nes_ud_file    *rx_ud_wq;
> +	struct nes_ud_file    *tx_ud_wq;
>  };
>  #endif			/* NES_VERBS_H */
>
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
> the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>   

--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

RE: [PATCH 2/2] RDMA/nes: add support of iWARP multicast acceleration over IB_QPT_RAW_ETY QP type

[Walukiewicz, Miroslaw]

Hello Steve,

Our Hw QP is not a UD type QP but L2 raw QP. In verbs API there is assumtion that user provides a data payload only for TX and similarly receives a payload only. The protocol headers (in case of UD - MAC/IP/UDP) are attached by HW. 

Our QP implementation in HW  does not provide such possibity of attaching headers by HW for UD traffic so for multicast acceleration we choose L2 raw path. It provides some overhead for user application but it is still zero copy apprach.

I thought about using a simulation of UD path using L2 raw QP to get the same result like for true UD QP (user handles a payload only). Such approach costs additional copy of payload in SW due to putting headers first and next payload to single tx buffer. Similar situation is for rx. It is a need for copy payload to posted buffers or provide data with some offset. 

ud_post_send and friends implements the transmit path for IMA. Our RAW ETH QP needs access to physical addresses from user space. Due to security reasons we should make a virtual-to-physical address translation in kernel. 

Unfortunately an OFED path for ibv_post_send diving to kernel is quite slow due to some number of dynamic memory allocations in the path. We choose to create own private post_send channel to increase tx bandwidth using ud_post_send and friends. 

Regards,

Mirek

-----Original Message-----
From: Steve Wise [mailto:swise-7bPotxP6k4+P2YhJcF5u+vpXobYPEAuW@public.gmane.org] 
Sent: Tuesday, May 04, 2010 7:19 PM
To: Walukiewicz, Miroslaw
Cc: rdreier-FYB4Gu1CFyUAvxtiuMwx3w@public.gmane.org; linux-rdma-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
Subject: Re: [PATCH 2/2] RDMA/nes: add support of iWARP multicast acceleration over IB_QPT_RAW_ETY QP type

Hey Mirek,

It looks like this patch adds a new file interface for a UD service.  
Why didn't you extend the existing UD interface as needed? 

What IO is supported with these changes?  IMA via the raw QP, but what 
ud_post_send() and friends used for?


Steve.



miroslaw.walukiewicz-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org wrote:
> This patch implements iWarp multicast acceleration (IMA)
> over IB_QPT_RAW_ETY QP type in nes driver.
>
> Application creates a raw eth QP (IBV_QPT_RAW_ETH in user-space) and
> manages the multicast via ibv_attach_mcast and ibv_detach_mcast calls.
>
> Calling ibv_attach_mcast/ibv_datach_mcast has an effect of
> enabling/disabling L2 MAC address filters in HW.
>
> Signed-off-by: Mirek Walukiewicz <miroslaw.walukiewicz-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org>
>
>
>
--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH 2/2] RDMA/nes: add support of iWARP multicast acceleration over IB_QPT_RAW_ETY QP type

[Steve Wise]

Walukiewicz, Miroslaw wrote:
> Hello Steve,
>
> Our Hw QP is not a UD type QP but L2 raw QP. In verbs API there is assumtion that user provides a data payload only for TX and similarly receives a payload only. The protocol headers (in case of UD - MAC/IP/UDP) are attached by HW. 
>
> Our QP implementation in HW  does not provide such possibity of attaching headers by HW for UD traffic so for multicast acceleration we choose L2 raw path. It provides some overhead for user application but it is still zero copy apprach.
>
> I thought about using a simulation of UD path using L2 raw QP to get the same result like for true UD QP (user handles a payload only). Such approach costs additional copy of payload in SW due to putting headers first and next payload to single tx buffer. Similar situation is for rx. It is a need for copy payload to posted buffers or provide data with some offset. 
>
> ud_post_send and friends implements the transmit path for IMA. Our RAW ETH QP needs access to physical addresses from user space. Due to security reasons we should make a virtual-to-physical address translation in kernel. 
>
>   

But why couldn't you just use the normal memory registration paths?  IE 
the user mode app does ibv_reg_mr() and then uses lkey/addr/len in SGEs 
in the ibv_post_send() which could do kernel bypass.

> Unfortunately an OFED path for ibv_post_send diving to kernel is quite slow due to some number of dynamic memory allocations in the path. We choose to create own private post_send channel to increase tx bandwidth using ud_post_send and friends.

Seems like maybe you could fix the non-bypass post_send/recv paths 
instead of implementing an entirely new user<->kernel interface...

Steve.


>  
>
> Regards,
>
> Mirek
>
> -----Original Message-----
> From: Steve Wise [mailto:swise-7bPotxP6k4+P2YhJcF5u+vpXobYPEAuW@public.gmane.org] 
> Sent: Tuesday, May 04, 2010 7:19 PM
> To: Walukiewicz, Miroslaw
> Cc: rdreier-FYB4Gu1CFyUAvxtiuMwx3w@public.gmane.org; linux-rdma-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
> Subject: Re: [PATCH 2/2] RDMA/nes: add support of iWARP multicast acceleration over IB_QPT_RAW_ETY QP type
>
> Hey Mirek,
>
> It looks like this patch adds a new file interface for a UD service.  
> Why didn't you extend the existing UD interface as needed? 
>
> What IO is supported with these changes?  IMA via the raw QP, but what 
> ud_post_send() and friends used for?
>
>
> Steve.
>
>
>
> miroslaw.walukiewicz-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org wrote:
>   
>> This patch implements iWarp multicast acceleration (IMA)
>> over IB_QPT_RAW_ETY QP type in nes driver.
>>
>> Application creates a raw eth QP (IBV_QPT_RAW_ETH in user-space) and
>> manages the multicast via ibv_attach_mcast and ibv_detach_mcast calls.
>>
>> Calling ibv_attach_mcast/ibv_datach_mcast has an effect of
>> enabling/disabling L2 MAC address filters in HW.
>>
>> Signed-off-by: Mirek Walukiewicz <miroslaw.walukiewicz-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org>
>>
>>
>>
>>     

--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

RE: [PATCH 2/2] RDMA/nes: add support of iWARP multicast acceleration over IB_QPT_RAW_ETY QP type

[Walukiewicz, Miroslaw]

Steve, 

> ud_post_send and friends implements the transmit path for IMA. Our RAW ETH QP needs access to physical addresses from user space. Due to security reasons we should make a virtual-to-physical address translation in kernel. 
>
>   
Steve Wise wrote:
But why couldn't you just use the normal memory registration paths?  IE 
the user mode app does ibv_reg_mr() and then uses lkey/addr/len in SGEs 
in the ibv_post_send() which could do kernel bypass.

I see here some misunderstanding. Let me explain better how our tramsmit path works. 

In our implementation we use normal memory registration path using ibv_reg_mr and we use ibv_post_send() with lkey/vaddr/len.

The implementation of ibv_post_send (nes_post_send in libnes) for RAW QP passes lkey/virtual_addr/len information to kernel using shared page to our device driver (ud_post_send). There is no data copy here and the driver is used only for fast synchronization.

Because our RAW ETH QP must use physical addresses only,  ud_post_send() in kernel makes a virtual to physical memory translation and accesses the QP HW for packet transmission. Previously a packet buffer memory was registered and pinned by ibv_reg_mr to provide necessary information for making such translation.

Steve Wise wrote:
Seems like maybe you could fix the non-bypass post_send/recv paths 
instead of implementing an entirely new user<->kernel interface...

The non-bypass post_send/recv channel (using /dev/infiniband/rdma_cm) is shared with all other user-kernel  communication and it is quite complex. It is a perfect path for QP/CQ/PD/mem management but for me it is too complex for traffic acceleration. 

The user<->kernel  path  through additional driver, shared page for lkey/vaddr/len passing and SW memory translation in kernel is much more effective. 

Maybe it is a good idea to make that API more official after some kind of standarization. Our tests proved that it works. We achieved twice better performance and latency. That way could open the way for adding some non-RDMA devices to devices supported OFED API. 

Regards,

Mirek


-----Original Message-----
From: Steve Wise [mailto:swise-7bPotxP6k4+P2YhJcF5u+vpXobYPEAuW@public.gmane.org] 
Sent: Tuesday, May 04, 2010 8:15 PM
To: Walukiewicz, Miroslaw
Cc: rdreier-FYB4Gu1CFyUAvxtiuMwx3w@public.gmane.org; linux-rdma-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
Subject: Re: [PATCH 2/2] RDMA/nes: add support of iWARP multicast acceleration over IB_QPT_RAW_ETY QP type

Walukiewicz, Miroslaw wrote:
> Hello Steve,
>
> Our Hw QP is not a UD type QP but L2 raw QP. In verbs API there is assumtion that user provides a data payload only for TX and similarly receives a payload only. The protocol headers (in case of UD - MAC/IP/UDP) are attached by HW. 
>
> Our QP implementation in HW  does not provide such possibity of attaching headers by HW for UD traffic so for multicast acceleration we choose L2 raw path. It provides some overhead for user application but it is still zero copy apprach.
>
> I thought about using a simulation of UD path using L2 raw QP to get the same result like for true UD QP (user handles a payload only). Such approach costs additional copy of payload in SW due to putting headers first and next payload to single tx buffer. Similar situation is for rx. It is a need for copy payload to posted buffers or provide data with some offset. 
>
> ud_post_send and friends implements the transmit path for IMA. Our RAW ETH QP needs access to physical addresses from user space. Due to security reasons we should make a virtual-to-physical address translation in kernel. 
>
>   

But why couldn't you just use the normal memory registration paths?  IE 
the user mode app does ibv_reg_mr() and then uses lkey/addr/len in SGEs 
in the ibv_post_send() which could do kernel bypass.

> Unfortunately an OFED path for ibv_post_send diving to kernel is quite slow due to some number of dynamic memory allocations in the path. We choose to create own private post_send channel to increase tx bandwidth using ud_post_send and friends.

Seems like maybe you could fix the non-bypass post_send/recv paths 
instead of implementing an entirely new user<->kernel interface...

Steve.


>  
>
> Regards,
>
> Mirek
>
> -----Original Message-----
> From: Steve Wise [mailto:swise-7bPotxP6k4+P2YhJcF5u+vpXobYPEAuW@public.gmane.org] 
> Sent: Tuesday, May 04, 2010 7:19 PM
> To: Walukiewicz, Miroslaw
> Cc: rdreier-FYB4Gu1CFyUAvxtiuMwx3w@public.gmane.org; linux-rdma-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
> Subject: Re: [PATCH 2/2] RDMA/nes: add support of iWARP multicast acceleration over IB_QPT_RAW_ETY QP type
>
> Hey Mirek,
>
> It looks like this patch adds a new file interface for a UD service.  
> Why didn't you extend the existing UD interface as needed? 
>
> What IO is supported with these changes?  IMA via the raw QP, but what 
> ud_post_send() and friends used for?
>
>
> Steve.
>
>
>
> miroslaw.walukiewicz-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org wrote:
>   
>> This patch implements iWarp multicast acceleration (IMA)
>> over IB_QPT_RAW_ETY QP type in nes driver.
>>
>> Application creates a raw eth QP (IBV_QPT_RAW_ETH in user-space) and
>> manages the multicast via ibv_attach_mcast and ibv_detach_mcast calls.
>>
>> Calling ibv_attach_mcast/ibv_datach_mcast has an effect of
>> enabling/disabling L2 MAC address filters in HW.
>>
>> Signed-off-by: Mirek Walukiewicz <miroslaw.walukiewicz-ral2JQCrhuEAvxtiuMwx3w@public.gmane.org>
>>
>>
>>
>>     

--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH 2/2] RDMA/nes: add support of iWARP multicast acceleration over IB_QPT_RAW_ETY QP type

[Steve Wise]

> I see here some misunderstanding. Let me explain better how our tramsmit path works. 
>
> In our implementation we use normal memory registration path using ibv_reg_mr and we use ibv_post_send() with lkey/vaddr/len.
>
> The implementation of ibv_post_send (nes_post_send in libnes) for RAW QP passes lkey/virtual_addr/len information to kernel using shared page to our device driver (ud_post_send). There is no data copy here and the driver is used only for fast synchronization.
>
> Because our RAW ETH QP must use physical addresses only,  ud_post_send() in kernel makes a virtual to physical memory translation and accesses the QP HW for packet transmission. Previously a packet buffer memory was registered and pinned by ibv_reg_mr to provide necessary information for making such translation.
>
>   

I see.  Thanks!


> The non-bypass post_send/recv channel (using /dev/infiniband/rdma_cm) is shared with all other user-kernel  communication and it is quite complex. It is a perfect path for QP/CQ/PD/mem management but for me it is too complex for traffic acceleration. 
>
> The user<->kernel  path  through additional driver, shared page for lkey/vaddr/len passing and SW memory translation in kernel is much more effective. 
>
> Maybe it is a good idea to make that API more official after some kind of standarization. Our tests proved that it works. We achieved twice better performance and latency. That way could open the way for adding some non-RDMA devices to devices supported OFED API. 
>
>   

Sounds good.

Do you have specific perf numbers to share?  Is this all just optimizing 
mcast packets? 

Also:

Does this raw qp service share the mac address with the ports being used 
by the host stack?  Or does each raw qp get its own mac address?

Do you all have a user mode UDP/IP running on this raw qp?  If so, does 
it use its own IP address separate from the host stack or does it share 
the host's IP address.


Thanks,

Steve.




--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

RE: [PATCH 2/2] RDMA/nes: add support of iWARP multicast acceleration over IB_QPT_RAW_ETY QP type

[Walukiewicz, Miroslaw]

Steve Wise wrote:
Is this all just optimizing mcast packets?

The RAW ETH QP API could be used to accelerate sending and receiving any L2 packets. It depends on application and HW setup. We use it for accelerating a multicast traffic.

Steve Wise wrote:
Does this raw qp service share the mac address with the ports being used 
by the host stack?  Or does each raw qp get its own mac address?

We use a MAC address of the port as a source MAC. The destination MAC is derived from multicast group. In theory,  it is possible using other MAC for unicast traffic acceleration, but it is much more complex due to making correct ARP responses and HW possibility to push unicast packets to correct QPs. 

Steve Wise wrote:
Do you all have a user mode UDP/IP running on this raw qp? 

Yes, we use modified mckey for most tests. 

Steve Wise wrote:
If so, does it use its own IP address separate from the host stack or does it share the host's IP address.

Our test application shares an IP address of host interface as a source IP address. 

Regards,

Mirek
 

-----Original Message-----
From: linux-rdma-owner-u79uwXL29TY76Z2rM5mHXA@public.gmane.org [mailto:linux-rdma-owner-u79uwXL29TY76Z2rM5mHXA@public.gmane.org] On Behalf Of Steve Wise
Sent: Wednesday, May 05, 2010 4:56 PM
To: Walukiewicz, Miroslaw
Cc: rdreier-FYB4Gu1CFyUAvxtiuMwx3w@public.gmane.org; linux-rdma-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
Subject: Re: [PATCH 2/2] RDMA/nes: add support of iWARP multicast acceleration over IB_QPT_RAW_ETY QP type


> I see here some misunderstanding. Let me explain better how our tramsmit path works. 
>
> In our implementation we use normal memory registration path using ibv_reg_mr and we use ibv_post_send() with lkey/vaddr/len.
>
> The implementation of ibv_post_send (nes_post_send in libnes) for RAW QP passes lkey/virtual_addr/len information to kernel using shared page to our device driver (ud_post_send). There is no data copy here and the driver is used only for fast synchronization.
>
> Because our RAW ETH QP must use physical addresses only,  ud_post_send() in kernel makes a virtual to physical memory translation and accesses the QP HW for packet transmission. Previously a packet buffer memory was registered and pinned by ibv_reg_mr to provide necessary information for making such translation.
>
>   

I see.  Thanks!


> The non-bypass post_send/recv channel (using /dev/infiniband/rdma_cm) is shared with all other user-kernel  communication and it is quite complex. It is a perfect path for QP/CQ/PD/mem management but for me it is too complex for traffic acceleration. 
>
> The user<->kernel  path  through additional driver, shared page for lkey/vaddr/len passing and SW memory translation in kernel is much more effective. 
>
> Maybe it is a good idea to make that API more official after some kind of standarization. Our tests proved that it works. We achieved twice better performance and latency. That way could open the way for adding some non-RDMA devices to devices supported OFED API. 
>
>   

Sounds good.

Do you have specific perf numbers to share?  Is this all just optimizing 
mcast packets? 

Also:

Does this raw qp service share the mac address with the ports being used 
by the host stack?  Or does each raw qp get its own mac address?

Do you all have a user mode UDP/IP running on this raw qp?  If so, does 
it use its own IP address separate from the host stack or does it share 
the host's IP address.


Thanks,

Steve.




--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH 0/2] RDMA/core: add support for iWarp multicast acceleration over IB_QPT_RAW_ETY QP type

[Steve Wise]

BTW: I agree with the core changes proposed in this series as well as 
the patch adding the RAW_ETY QP type for user mode.

Steve.



Mirek Walukiewicz wrote:
> This patch series implements iWarp multicast acceleration over raw eth QP type.
>
> In ibv_attach_mcast and ibv_detach_mcast, new case is added for RDMA_TRANSPORT_IWARP to allow multicast 
> on IB_QPT_RAW_ETY QP type. This change is for iWarp only and does not affect IB.
>
> Changes to nes demenstrate how IB_QPT_RAW_ETY QP is used to accelerate multicast traffic.
>
> Miroslaw Walukiewicz
>  
> --
> To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
> the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
>   

--
To unsubscribe from this list: send the line "unsubscribe linux-rdma" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html