Patched in Tegra support.

5 files changed, 128 insertions, 252 deletions

diff --git a/drivers/infiniband/ulp/iser/iscsi_iser.c b/drivers/infiniband/ulp/iser/iscsi_iser.c
index 0ab8c9cc3a7..9c61b9c2c59 100644
--- a/drivers/infiniband/ulp/iser/iscsi_iser.c
+++ b/drivers/infiniband/ulp/iser/iscsi_iser.c
@@ -57,7 +57,6 @@
 #include <linux/scatterlist.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 
 #include <net/sock.h>
 
@@ -152,6 +151,7 @@ int iser_initialize_task_headers(struct iscsi_task *task,
         tx_desc->tx_sg[0].length = ISER_HEADERS_LEN;
         tx_desc->tx_sg[0].lkey   = device->mr->lkey;
 
+        iser_task->headers_initialized  = 1;
         iser_task->iser_conn            = iser_conn;
         return 0;
 }
@@ -166,7 +166,8 @@ iscsi_iser_task_init(struct iscsi_task *task)
 {
         struct iscsi_iser_task *iser_task = task->dd_data;
 
-        if (iser_initialize_task_headers(task, &iser_task->desc))
+        if (!iser_task->headers_initialized)
+                if (iser_initialize_task_headers(task, &iser_task->desc))
                         return -ENOMEM;
 
         /* mgmt task */
@@ -277,13 +278,6 @@ iscsi_iser_task_xmit(struct iscsi_task *task)
 static void iscsi_iser_cleanup_task(struct iscsi_task *task)
 {
         struct iscsi_iser_task *iser_task = task->dd_data;
-        struct iser_tx_desc     *tx_desc = &iser_task->desc;
-
-        struct iscsi_iser_conn *iser_conn = task->conn->dd_data;
-        struct iser_device     *device    = iser_conn->ib_conn->device;
-
-        ib_dma_unmap_single(device->ib_device,
-                tx_desc->dma_addr, ISER_HEADERS_LEN, DMA_TO_DEVICE);
 
         /* mgmt tasks do not need special cleanup */
         if (!task->sc)
@@ -364,9 +358,6 @@ iscsi_iser_conn_bind(struct iscsi_cls_session *cls_session,
         }
         ib_conn = ep->dd_data;
 
-        if (iser_alloc_rx_descriptors(ib_conn))
-                return -ENOMEM;
-
         /* binds the iSER connection retrieved from the previously
          * connected ep_handle to the iSCSI layer connection. exchanges
          * connection pointers */
@@ -401,6 +392,19 @@ iscsi_iser_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
         iser_conn->ib_conn = NULL;
 }
 
+static int
+iscsi_iser_conn_start(struct iscsi_cls_conn *cls_conn)
+{
+        struct iscsi_conn *conn = cls_conn->dd_data;
+        int err;
+
+        err = iser_conn_set_full_featured_mode(conn);
+        if (err)
+                return err;
+
+        return iscsi_conn_start(cls_conn);
+}
+
 static void iscsi_iser_session_destroy(struct iscsi_cls_session *cls_session)
 {
         struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
@@ -573,9 +577,10 @@ iscsi_iser_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
 
         err = iser_connect(ib_conn, NULL, (struct sockaddr_in *)dst_addr,
                            non_blocking);
-        if (err)
+        if (err) {
+                iscsi_destroy_endpoint(ep);
                 return ERR_PTR(err);
-
+        }
         return ep;
 }
 
@@ -627,59 +632,6 @@ iscsi_iser_ep_disconnect(struct iscsi_endpoint *ep)
         iser_conn_terminate(ib_conn);
 }
 
-static umode_t iser_attr_is_visible(int param_type, int param)
-{
-        switch (param_type) {
-        case ISCSI_HOST_PARAM:
-                switch (param) {
-                case ISCSI_HOST_PARAM_NETDEV_NAME:
-                case ISCSI_HOST_PARAM_HWADDRESS:
-                case ISCSI_HOST_PARAM_INITIATOR_NAME:
-                        return S_IRUGO;
-                default:
-                        return 0;
-                }
-        case ISCSI_PARAM:
-                switch (param) {
-                case ISCSI_PARAM_MAX_RECV_DLENGTH:
-                case ISCSI_PARAM_MAX_XMIT_DLENGTH:
-                case ISCSI_PARAM_HDRDGST_EN:
-                case ISCSI_PARAM_DATADGST_EN:
-                case ISCSI_PARAM_CONN_ADDRESS:
-                case ISCSI_PARAM_CONN_PORT:
-                case ISCSI_PARAM_EXP_STATSN:
-                case ISCSI_PARAM_PERSISTENT_ADDRESS:
-                case ISCSI_PARAM_PERSISTENT_PORT:
-                case ISCSI_PARAM_PING_TMO:
-                case ISCSI_PARAM_RECV_TMO:
-                case ISCSI_PARAM_INITIAL_R2T_EN:
-                case ISCSI_PARAM_MAX_R2T:
-                case ISCSI_PARAM_IMM_DATA_EN:
-                case ISCSI_PARAM_FIRST_BURST:
-                case ISCSI_PARAM_MAX_BURST:
-                case ISCSI_PARAM_PDU_INORDER_EN:
-                case ISCSI_PARAM_DATASEQ_INORDER_EN:
-                case ISCSI_PARAM_TARGET_NAME:
-                case ISCSI_PARAM_TPGT:
-                case ISCSI_PARAM_USERNAME:
-                case ISCSI_PARAM_PASSWORD:
-                case ISCSI_PARAM_USERNAME_IN:
-                case ISCSI_PARAM_PASSWORD_IN:
-                case ISCSI_PARAM_FAST_ABORT:
-                case ISCSI_PARAM_ABORT_TMO:
-                case ISCSI_PARAM_LU_RESET_TMO:
-                case ISCSI_PARAM_TGT_RESET_TMO:
-                case ISCSI_PARAM_IFACE_NAME:
-                case ISCSI_PARAM_INITIATOR_NAME:
-                        return S_IRUGO;
-                default:
-                        return 0;
-                }
-        }
-
-        return 0;
-}
-
 static struct scsi_host_template iscsi_iser_sht = {
         .module                 = THIS_MODULE,
         .name                   = "iSCSI Initiator over iSER, v." DRV_VER,
@@ -701,6 +653,32 @@ static struct iscsi_transport iscsi_iser_transport = {
         .owner                  = THIS_MODULE,
         .name                   = "iser",
         .caps                   = CAP_RECOVERY_L0 | CAP_MULTI_R2T,
+        .param_mask             = ISCSI_MAX_RECV_DLENGTH |
+                                  ISCSI_MAX_XMIT_DLENGTH |
+                                  ISCSI_HDRDGST_EN |
+                                  ISCSI_DATADGST_EN |
+                                  ISCSI_INITIAL_R2T_EN |
+                                  ISCSI_MAX_R2T |
+                                  ISCSI_IMM_DATA_EN |
+                                  ISCSI_FIRST_BURST |
+                                  ISCSI_MAX_BURST |
+                                  ISCSI_PDU_INORDER_EN |
+                                  ISCSI_DATASEQ_INORDER_EN |
+                                  ISCSI_CONN_PORT |
+                                  ISCSI_CONN_ADDRESS |
+                                  ISCSI_EXP_STATSN |
+                                  ISCSI_PERSISTENT_PORT |
+                                  ISCSI_PERSISTENT_ADDRESS |
+                                  ISCSI_TARGET_NAME | ISCSI_TPGT |
+                                  ISCSI_USERNAME | ISCSI_PASSWORD |
+                                  ISCSI_USERNAME_IN | ISCSI_PASSWORD_IN |
+                                  ISCSI_FAST_ABORT | ISCSI_ABORT_TMO |
+                                  ISCSI_LU_RESET_TMO | ISCSI_TGT_RESET_TMO |
+                                  ISCSI_PING_TMO | ISCSI_RECV_TMO |
+                                  ISCSI_IFACE_NAME | ISCSI_INITIATOR_NAME,
+        .host_param_mask        = ISCSI_HOST_HWADDRESS |
+                                  ISCSI_HOST_NETDEV_NAME |
+                                  ISCSI_HOST_INITIATOR_NAME,
         /* session management */
         .create_session         = iscsi_iser_session_create,
         .destroy_session        = iscsi_iser_session_destroy,
@@ -708,12 +686,11 @@ static struct iscsi_transport iscsi_iser_transport = {
         .create_conn            = iscsi_iser_conn_create,
         .bind_conn              = iscsi_iser_conn_bind,
         .destroy_conn           = iscsi_iser_conn_destroy,
-        .attr_is_visible        = iser_attr_is_visible,
         .set_param              = iscsi_iser_set_param,
         .get_conn_param         = iscsi_conn_get_param,
         .get_ep_param           = iscsi_iser_get_ep_param,
         .get_session_param      = iscsi_session_get_param,
-        .start_conn             = iscsi_conn_start,
+        .start_conn             = iscsi_iser_conn_start,
         .stop_conn              = iscsi_iser_conn_stop,
         /* iscsi host params */
         .get_host_param         = iscsi_host_get_param,
diff --git a/drivers/infiniband/ulp/iser/iscsi_iser.h b/drivers/infiniband/ulp/iser/iscsi_iser.h
index ef7d3be46c3..db6f3ce9f3b 100644
--- a/drivers/infiniband/ulp/iser/iscsi_iser.h
+++ b/drivers/infiniband/ulp/iser/iscsi_iser.h
@@ -177,7 +177,6 @@ struct iser_data_buf {
 
 /* fwd declarations */
 struct iser_device;
-struct iser_cq_desc;
 struct iscsi_iser_conn;
 struct iscsi_iser_task;
 struct iscsi_endpoint;
@@ -227,21 +226,16 @@ struct iser_rx_desc {
         char                         pad[ISER_RX_PAD_SIZE];
 } __attribute__((packed));
 
-#define ISER_MAX_CQ 4
-
 struct iser_device {
         struct ib_device             *ib_device;
         struct ib_pd                 *pd;
-        struct ib_cq                 *rx_cq[ISER_MAX_CQ];
-        struct ib_cq                 *tx_cq[ISER_MAX_CQ];
+        struct ib_cq                 *rx_cq;
+        struct ib_cq                 *tx_cq;
         struct ib_mr                 *mr;
-        struct tasklet_struct        cq_tasklet[ISER_MAX_CQ];
+        struct tasklet_struct        cq_tasklet;
         struct ib_event_handler      event_handler;
         struct list_head             ig_list; /* entry in ig devices list */
         int                          refcount;
-        int                          cq_active_qps[ISER_MAX_CQ];
-        int                          cqs_used;
-        struct iser_cq_desc          *cq_desc;
 };
 
 struct iser_conn {
@@ -263,8 +257,7 @@ struct iser_conn {
         struct list_head             conn_list;       /* entry in ig conn list */
 
         char                         *login_buf;
-        char                         *login_req_buf, *login_resp_buf;
-        u64                          login_req_dma, login_resp_dma;
+        u64                          login_dma;
         unsigned int                 rx_desc_head;
         struct iser_rx_desc          *rx_descs;
         struct ib_recv_wr            rx_wr[ISER_MIN_POSTED_RX];
@@ -284,6 +277,7 @@ struct iscsi_iser_task {
         struct iser_regd_buf         rdma_regd[ISER_DIRS_NUM];/* regd rdma buf */
         struct iser_data_buf         data[ISER_DIRS_NUM];     /* orig. data des*/
         struct iser_data_buf         data_copy[ISER_DIRS_NUM];/* contig. copy  */
+        int                          headers_initialized;
 };
 
 struct iser_page_vec {
@@ -293,11 +287,6 @@ struct iser_page_vec {
         int data_size;
 };
 
-struct iser_cq_desc {
-        struct iser_device           *device;
-        int                          cq_index;
-};
-
 struct iser_global {
         struct mutex      device_list_mutex;/*                   */
         struct list_head  device_list;       /* all iSER devices */
@@ -377,5 +366,4 @@ int iser_dma_map_task_data(struct iscsi_iser_task *iser_task,
 void iser_dma_unmap_task_data(struct iscsi_iser_task *iser_task);
 int  iser_initialize_task_headers(struct iscsi_task *task,
                         struct iser_tx_desc *tx_desc);
-int iser_alloc_rx_descriptors(struct iser_conn *ib_conn);
 #endif
diff --git a/drivers/infiniband/ulp/iser/iser_initiator.c b/drivers/infiniband/ulp/iser/iser_initiator.c
index a00ccd1ca33..f299de6b419 100644
--- a/drivers/infiniband/ulp/iser/iser_initiator.c
+++ b/drivers/infiniband/ulp/iser/iser_initiator.c
@@ -170,7 +170,7 @@ static void iser_create_send_desc(struct iser_conn	*ib_conn,
 }
 
 
-int iser_alloc_rx_descriptors(struct iser_conn *ib_conn)
+static int iser_alloc_rx_descriptors(struct iser_conn *ib_conn)
 {
         int i, j;
         u64 dma_addr;
@@ -220,6 +220,12 @@ void iser_free_rx_descriptors(struct iser_conn *ib_conn)
         struct iser_rx_desc *rx_desc;
         struct iser_device *device = ib_conn->device;
 
+        if (ib_conn->login_buf) {
+                ib_dma_unmap_single(device->ib_device, ib_conn->login_dma,
+                        ISER_RX_LOGIN_SIZE, DMA_FROM_DEVICE);
+                kfree(ib_conn->login_buf);
+        }
+
         if (!ib_conn->rx_descs)
                 return;
 
@@ -230,24 +236,23 @@ void iser_free_rx_descriptors(struct iser_conn *ib_conn)
         kfree(ib_conn->rx_descs);
 }
 
-static int iser_post_rx_bufs(struct iscsi_conn *conn, struct iscsi_hdr *req)
+/**
+ *  iser_conn_set_full_featured_mode - (iSER API)
+ */
+int iser_conn_set_full_featured_mode(struct iscsi_conn *conn)
 {
         struct iscsi_iser_conn *iser_conn = conn->dd_data;
 
-        iser_dbg("req op %x flags %x\n", req->opcode, req->flags);
-        /* check if this is the last login - going to full feature phase */
-        if ((req->flags & ISCSI_FULL_FEATURE_PHASE) != ISCSI_FULL_FEATURE_PHASE)
-                return 0;
+        iser_dbg("Initially post: %d\n", ISER_MIN_POSTED_RX);
 
-        /*
-         * Check that there is one posted recv buffer (for the last login
-         * response) and no posted send buffers left - they must have been
-         * consumed during previous login phases.
-         */
-        WARN_ON(iser_conn->ib_conn->post_recv_buf_count != 1);
-        WARN_ON(atomic_read(&iser_conn->ib_conn->post_send_buf_count) != 0);
+        /* Check that there is no posted recv or send buffers left - */
+        /* they must be consumed during the login phase */
+        BUG_ON(iser_conn->ib_conn->post_recv_buf_count != 0);
+        BUG_ON(atomic_read(&iser_conn->ib_conn->post_send_buf_count) != 0);
+
+        if (iser_alloc_rx_descriptors(iser_conn->ib_conn))
+                return -ENOMEM;
 
-        iser_dbg("Initially post: %d\n", ISER_MIN_POSTED_RX);
         /* Initial post receive buffers */
         if (iser_post_recvm(iser_conn->ib_conn, ISER_MIN_POSTED_RX))
                 return -ENOMEM;
@@ -389,7 +394,6 @@ int iser_send_control(struct iscsi_conn *conn,
         unsigned long data_seg_len;
         int err = 0;
         struct iser_device *device;
-        struct iser_conn *ib_conn = iser_conn->ib_conn;
 
         /* build the tx desc regd header and add it to the tx desc dto */
         mdesc->type = ISCSI_TX_CONTROL;
@@ -405,19 +409,9 @@ int iser_send_control(struct iscsi_conn *conn,
                         iser_err("data present on non login task!!!\n");
                         goto send_control_error;
                 }
-
-                ib_dma_sync_single_for_cpu(device->ib_device,
-                        ib_conn->login_req_dma, task->data_count,
-                        DMA_TO_DEVICE);
-
-                memcpy(iser_conn->ib_conn->login_req_buf, task->data,
+                memcpy(iser_conn->ib_conn->login_buf, task->data,
                                                         task->data_count);
-
-                ib_dma_sync_single_for_device(device->ib_device,
-                        ib_conn->login_req_dma, task->data_count,
-                        DMA_TO_DEVICE);
-
-                tx_dsg->addr    = iser_conn->ib_conn->login_req_dma;
+                tx_dsg->addr    = iser_conn->ib_conn->login_dma;
                 tx_dsg->length  = task->data_count;
                 tx_dsg->lkey    = device->mr->lkey;
                 mdesc->num_sge = 2;
@@ -427,9 +421,6 @@ int iser_send_control(struct iscsi_conn *conn,
                 err = iser_post_recvl(iser_conn->ib_conn);
                 if (err)
                         goto send_control_error;
-                err = iser_post_rx_bufs(conn, task->hdr);
-                if (err)
-                        goto send_control_error;
         }
 
         err = iser_post_send(iser_conn->ib_conn, mdesc);
@@ -454,8 +445,8 @@ void iser_rcv_completion(struct iser_rx_desc *rx_desc,
         int rx_buflen, outstanding, count, err;
 
         /* differentiate between login to all other PDUs */
-        if ((char *)rx_desc == ib_conn->login_resp_buf) {
-                rx_dma = ib_conn->login_resp_dma;
+        if ((char *)rx_desc == ib_conn->login_buf) {
+                rx_dma = ib_conn->login_dma;
                 rx_buflen = ISER_RX_LOGIN_SIZE;
         } else {
                 rx_dma = rx_desc->dma_addr;
@@ -482,7 +473,7 @@ void iser_rcv_completion(struct iser_rx_desc *rx_desc,
          * for the posted rx bufs refcount to become zero handles everything   */
         conn->ib_conn->post_recv_buf_count--;
 
-        if (rx_dma == ib_conn->login_resp_dma)
+        if (rx_dma == ib_conn->login_dma)
                 return;
 
         outstanding = ib_conn->post_recv_buf_count;
diff --git a/drivers/infiniband/ulp/iser/iser_memory.c b/drivers/infiniband/ulp/iser/iser_memory.c
index 2033a928d34..fb88d6896b6 100644
--- a/drivers/infiniband/ulp/iser/iser_memory.c
+++ b/drivers/infiniband/ulp/iser/iser_memory.c
@@ -73,11 +73,11 @@ static int iser_start_rdma_unaligned_sg(struct iscsi_iser_task *iser_task,
 
                 p = mem;
                 for_each_sg(sgl, sg, data->size, i) {
-                        from = kmap_atomic(sg_page(sg));
+                        from = kmap_atomic(sg_page(sg), KM_USER0);
                         memcpy(p,
                                from + sg->offset,
                                sg->length);
-                        kunmap_atomic(from);
+                        kunmap_atomic(from, KM_USER0);
                         p += sg->length;
                 }
         }
@@ -133,11 +133,11 @@ void iser_finalize_rdma_unaligned_sg(struct iscsi_iser_task *iser_task,
 
                 p = mem;
                 for_each_sg(sgl, sg, sg_size, i) {
-                        to = kmap_atomic(sg_page(sg));
+                        to = kmap_atomic(sg_page(sg), KM_SOFTIRQ0);
                         memcpy(to + sg->offset,
                                p,
                                sg->length);
-                        kunmap_atomic(to);
+                        kunmap_atomic(to, KM_SOFTIRQ0);
                         p += sg->length;
                 }
         }
diff --git a/drivers/infiniband/ulp/iser/iser_verbs.c b/drivers/infiniband/ulp/iser/iser_verbs.c
index 95a49affee4..ede1475bee0 100644
--- a/drivers/infiniband/ulp/iser/iser_verbs.c
+++ b/drivers/infiniband/ulp/iser/iser_verbs.c
@@ -70,50 +70,32 @@ static void iser_event_handler(struct ib_event_handler *handler,
  */
 static int iser_create_device_ib_res(struct iser_device *device)
 {
-        int i, j;
-        struct iser_cq_desc *cq_desc;
-
-        device->cqs_used = min(ISER_MAX_CQ, device->ib_device->num_comp_vectors);
-        iser_err("using %d CQs, device %s supports %d vectors\n", device->cqs_used,
-                 device->ib_device->name, device->ib_device->num_comp_vectors);
-
-        device->cq_desc = kmalloc(sizeof(struct iser_cq_desc) * device->cqs_used,
-                                  GFP_KERNEL);
-        if (device->cq_desc == NULL)
-                goto cq_desc_err;
-        cq_desc = device->cq_desc;
-
         device->pd = ib_alloc_pd(device->ib_device);
         if (IS_ERR(device->pd))
                 goto pd_err;
 
-        for (i = 0; i < device->cqs_used; i++) {
-                cq_desc[i].device   = device;
-                cq_desc[i].cq_index = i;
+        device->rx_cq = ib_create_cq(device->ib_device,
+                                  iser_cq_callback,
+                                  iser_cq_event_callback,
+                                  (void *)device,
+                                  ISER_MAX_RX_CQ_LEN, 0);
+        if (IS_ERR(device->rx_cq))
+                goto rx_cq_err;
 
-                device->rx_cq[i] = ib_create_cq(device->ib_device,
-                                          iser_cq_callback,
-                                          iser_cq_event_callback,
-                                          (void *)&cq_desc[i],
-                                          ISER_MAX_RX_CQ_LEN, i);
-                if (IS_ERR(device->rx_cq[i]))
-                        goto cq_err;
+        device->tx_cq = ib_create_cq(device->ib_device,
+                                  NULL, iser_cq_event_callback,
+                                  (void *)device,
+                                  ISER_MAX_TX_CQ_LEN, 0);
 
-                device->tx_cq[i] = ib_create_cq(device->ib_device,
-                                          NULL, iser_cq_event_callback,
-                                          (void *)&cq_desc[i],
-                                          ISER_MAX_TX_CQ_LEN, i);
+        if (IS_ERR(device->tx_cq))
+                goto tx_cq_err;
 
-                if (IS_ERR(device->tx_cq[i]))
-                        goto cq_err;
+        if (ib_req_notify_cq(device->rx_cq, IB_CQ_NEXT_COMP))
+                goto cq_arm_err;
 
-                if (ib_req_notify_cq(device->rx_cq[i], IB_CQ_NEXT_COMP))
-                        goto cq_err;
-
-                tasklet_init(&device->cq_tasklet[i],
-                             iser_cq_tasklet_fn,
-                        (unsigned long)&cq_desc[i]);
-        }
+        tasklet_init(&device->cq_tasklet,
+                     iser_cq_tasklet_fn,
+                     (unsigned long)device);
 
         device->mr = ib_get_dma_mr(device->pd, IB_ACCESS_LOCAL_WRITE |
                                    IB_ACCESS_REMOTE_WRITE |
@@ -131,19 +113,14 @@ static int iser_create_device_ib_res(struct iser_device *device)
 handler_err:
         ib_dereg_mr(device->mr);
 dma_mr_err:
-        for (j = 0; j < device->cqs_used; j++)
-                tasklet_kill(&device->cq_tasklet[j]);
-cq_err:
-        for (j = 0; j < i; j++) {
-                if (device->tx_cq[j])
-                        ib_destroy_cq(device->tx_cq[j]);
-                if (device->rx_cq[j])
-                        ib_destroy_cq(device->rx_cq[j]);
-        }
+        tasklet_kill(&device->cq_tasklet);
+cq_arm_err:
+        ib_destroy_cq(device->tx_cq);
+tx_cq_err:
+        ib_destroy_cq(device->rx_cq);
+rx_cq_err:
         ib_dealloc_pd(device->pd);
 pd_err:
-        kfree(device->cq_desc);
-cq_desc_err:
         iser_err("failed to allocate an IB resource\n");
         return -1;
 }
@@ -154,24 +131,18 @@ cq_desc_err:
  */
 static void iser_free_device_ib_res(struct iser_device *device)
 {
-        int i;
         BUG_ON(device->mr == NULL);
 
-        for (i = 0; i < device->cqs_used; i++) {
-                tasklet_kill(&device->cq_tasklet[i]);
-                (void)ib_destroy_cq(device->tx_cq[i]);
-                (void)ib_destroy_cq(device->rx_cq[i]);
-                device->tx_cq[i] = NULL;
-                device->rx_cq[i] = NULL;
-        }
-
+        tasklet_kill(&device->cq_tasklet);
         (void)ib_unregister_event_handler(&device->event_handler);
         (void)ib_dereg_mr(device->mr);
+        (void)ib_destroy_cq(device->tx_cq);
+        (void)ib_destroy_cq(device->rx_cq);
         (void)ib_dealloc_pd(device->pd);
 
-        kfree(device->cq_desc);
-
         device->mr = NULL;
+        device->tx_cq = NULL;
+        device->rx_cq = NULL;
         device->pd = NULL;
 }
 
@@ -184,40 +155,20 @@ static int iser_create_ib_conn_res(struct iser_conn *ib_conn)
 {
         struct iser_device      *device;
         struct ib_qp_init_attr  init_attr;
-        int                     req_err, resp_err, ret = -ENOMEM;
+        int                     ret = -ENOMEM;
         struct ib_fmr_pool_param params;
-        int index, min_index = 0;
 
         BUG_ON(ib_conn->device == NULL);
 
         device = ib_conn->device;
 
-        ib_conn->login_buf = kmalloc(ISCSI_DEF_MAX_RECV_SEG_LEN +
-                                        ISER_RX_LOGIN_SIZE, GFP_KERNEL);
+        ib_conn->login_buf = kmalloc(ISER_RX_LOGIN_SIZE, GFP_KERNEL);
         if (!ib_conn->login_buf)
                 goto out_err;
 
-        ib_conn->login_req_buf  = ib_conn->login_buf;
-        ib_conn->login_resp_buf = ib_conn->login_buf + ISCSI_DEF_MAX_RECV_SEG_LEN;
-
-        ib_conn->login_req_dma = ib_dma_map_single(ib_conn->device->ib_device,
-                                (void *)ib_conn->login_req_buf,
-                                ISCSI_DEF_MAX_RECV_SEG_LEN, DMA_TO_DEVICE);
-
-        ib_conn->login_resp_dma = ib_dma_map_single(ib_conn->device->ib_device,
-                                (void *)ib_conn->login_resp_buf,
-                                ISER_RX_LOGIN_SIZE, DMA_FROM_DEVICE);
-
-        req_err  = ib_dma_mapping_error(device->ib_device, ib_conn->login_req_dma);
-        resp_err = ib_dma_mapping_error(device->ib_device, ib_conn->login_resp_dma);
-
-        if (req_err || resp_err) {
-                if (req_err)
-                        ib_conn->login_req_dma = 0;
-                if (resp_err)
-                        ib_conn->login_resp_dma = 0;
-                goto out_err;
-        }
+        ib_conn->login_dma = ib_dma_map_single(ib_conn->device->ib_device,
+                                (void *)ib_conn->login_buf, ISER_RX_LOGIN_SIZE,
+                                DMA_FROM_DEVICE);
 
         ib_conn->page_vec = kmalloc(sizeof(struct iser_page_vec) +
                                     (sizeof(u64) * (ISCSI_ISER_SG_TABLESIZE +1)),
@@ -250,20 +201,10 @@ static int iser_create_ib_conn_res(struct iser_conn *ib_conn)
 
         memset(&init_attr, 0, sizeof init_attr);
 
-        mutex_lock(&ig.connlist_mutex);
-        /* select the CQ with the minimal number of usages */
-        for (index = 0; index < device->cqs_used; index++)
-                if (device->cq_active_qps[index] <
-                    device->cq_active_qps[min_index])
-                        min_index = index;
-        device->cq_active_qps[min_index]++;
-        mutex_unlock(&ig.connlist_mutex);
-        iser_err("cq index %d used for ib_conn %p\n", min_index, ib_conn);
-
         init_attr.event_handler = iser_qp_event_callback;
         init_attr.qp_context    = (void *)ib_conn;
-        init_attr.send_cq       = device->tx_cq[min_index];
-        init_attr.recv_cq       = device->rx_cq[min_index];
+        init_attr.send_cq       = device->tx_cq;
+        init_attr.recv_cq       = device->rx_cq;
         init_attr.cap.max_send_wr  = ISER_QP_MAX_REQ_DTOS;
         init_attr.cap.max_recv_wr  = ISER_QP_MAX_RECV_DTOS;
         init_attr.cap.max_send_sge = 2;
@@ -292,7 +233,6 @@ out_err:
  */
 static int iser_free_ib_conn_res(struct iser_conn *ib_conn, int can_destroy_id)
 {
-        int cq_index;
         BUG_ON(ib_conn == NULL);
 
         iser_err("freeing conn %p cma_id %p fmr pool %p qp %p\n",
@@ -303,12 +243,9 @@ static int iser_free_ib_conn_res(struct iser_conn *ib_conn, int can_destroy_id)
         if (ib_conn->fmr_pool != NULL)
                 ib_destroy_fmr_pool(ib_conn->fmr_pool);
 
-        if (ib_conn->qp != NULL) {
-                cq_index = ((struct iser_cq_desc *)ib_conn->qp->recv_cq->cq_context)->cq_index;
-                ib_conn->device->cq_active_qps[cq_index]--;
-
+        if (ib_conn->qp != NULL)
                 rdma_destroy_qp(ib_conn->cma_id);
-        }
+
         /* if cma handler context, the caller acts s.t the cma destroy the id */
         if (ib_conn->cma_id != NULL && can_destroy_id)
                 rdma_destroy_id(ib_conn->cma_id);
@@ -318,18 +255,6 @@ static int iser_free_ib_conn_res(struct iser_conn *ib_conn, int can_destroy_id)
         ib_conn->cma_id   = NULL;
         kfree(ib_conn->page_vec);
 
-        if (ib_conn->login_buf) {
-                if (ib_conn->login_req_dma)
-                        ib_dma_unmap_single(ib_conn->device->ib_device,
-                                ib_conn->login_req_dma,
-                                ISCSI_DEF_MAX_RECV_SEG_LEN, DMA_TO_DEVICE);
-                if (ib_conn->login_resp_dma)
-                        ib_dma_unmap_single(ib_conn->device->ib_device,
-                                ib_conn->login_resp_dma,
-                                ISER_RX_LOGIN_SIZE, DMA_FROM_DEVICE);
-                kfree(ib_conn->login_buf);
-        }
-
         return 0;
 }
 
@@ -657,9 +582,8 @@ id_failure:
         ib_conn->cma_id = NULL;
 addr_failure:
         ib_conn->state = ISER_CONN_DOWN;
-        iser_conn_put(ib_conn, 1); /* deref ib conn's cma id */
 connect_failure:
-        iser_conn_put(ib_conn, 1); /* deref ib conn deallocate */
+        iser_conn_release(ib_conn, 1);
         return err;
 }
 
@@ -734,11 +658,11 @@ int iser_post_recvl(struct iser_conn *ib_conn)
         struct ib_sge     sge;
         int ib_ret;
 
-        sge.addr   = ib_conn->login_resp_dma;
+        sge.addr   = ib_conn->login_dma;
         sge.length = ISER_RX_LOGIN_SIZE;
         sge.lkey   = ib_conn->device->mr->lkey;
 
-        rx_wr.wr_id   = (unsigned long)ib_conn->login_resp_buf;
+        rx_wr.wr_id   = (unsigned long)ib_conn->login_buf;
         rx_wr.sg_list = &sge;
         rx_wr.num_sge = 1;
         rx_wr.next    = NULL;
@@ -835,9 +759,9 @@ static void iser_handle_comp_error(struct iser_tx_desc *desc,
         }
 }
 
-static int iser_drain_tx_cq(struct iser_device  *device, int cq_index)
+static int iser_drain_tx_cq(struct iser_device  *device)
 {
-        struct ib_cq  *cq = device->tx_cq[cq_index];
+        struct ib_cq  *cq = device->tx_cq;
         struct ib_wc  wc;
         struct iser_tx_desc *tx_desc;
         struct iser_conn *ib_conn;
@@ -866,10 +790,8 @@ static int iser_drain_tx_cq(struct iser_device  *device, int cq_index)
 
 static void iser_cq_tasklet_fn(unsigned long data)
 {
-        struct iser_cq_desc *cq_desc = (struct iser_cq_desc *)data;
-        struct iser_device  *device = cq_desc->device;
-        int cq_index = cq_desc->cq_index;
-        struct ib_cq         *cq = device->rx_cq[cq_index];
+         struct iser_device  *device = (struct iser_device *)data;
+         struct ib_cq        *cq = device->rx_cq;
          struct ib_wc        wc;
          struct iser_rx_desc *desc;
          unsigned long       xfer_len;
@@ -897,21 +819,19 @@ static void iser_cq_tasklet_fn(unsigned long data)
                 }
                 completed_rx++;
                 if (!(completed_rx & 63))
-                        completed_tx += iser_drain_tx_cq(device, cq_index);
+                        completed_tx += iser_drain_tx_cq(device);
         }
         /* #warning "it is assumed here that arming CQ only once its empty" *
          * " would not cause interrupts to be missed"                       */
         ib_req_notify_cq(cq, IB_CQ_NEXT_COMP);
 
-        completed_tx += iser_drain_tx_cq(device, cq_index);
+        completed_tx += iser_drain_tx_cq(device);
         iser_dbg("got %d rx %d tx completions\n", completed_rx, completed_tx);
 }
 
 static void iser_cq_callback(struct ib_cq *cq, void *cq_context)
 {
-        struct iser_cq_desc *cq_desc = (struct iser_cq_desc *)cq_context;
-        struct iser_device  *device = cq_desc->device;
-        int cq_index = cq_desc->cq_index;
+        struct iser_device  *device = (struct iser_device *)cq_context;
 
-        tasklet_schedule(&device->cq_tasklet[cq_index]);
+        tasklet_schedule(&device->cq_tasklet);
 }