11 files changed, 191 insertions, 112 deletions

diff --git a/drivers/infiniband/core/mad.c b/drivers/infiniband/core/mad.c
index 6dc7b77d5d29..ef1304f151dc 100644
--- a/drivers/infiniband/core/mad.c
+++ b/drivers/infiniband/core/mad.c
@@ -47,8 +47,8 @@ MODULE_DESCRIPTION("kernel IB MAD API");
 MODULE_AUTHOR("Hal Rosenstock");
 MODULE_AUTHOR("Sean Hefty");
 
-int mad_sendq_size = IB_MAD_QP_SEND_SIZE;
-int mad_recvq_size = IB_MAD_QP_RECV_SIZE;
+static int mad_sendq_size = IB_MAD_QP_SEND_SIZE;
+static int mad_recvq_size = IB_MAD_QP_RECV_SIZE;
 
 module_param_named(send_queue_size, mad_sendq_size, int, 0444);
 MODULE_PARM_DESC(send_queue_size, "Size of send queue in number of work requests");
diff --git a/drivers/infiniband/hw/cxgb4/cq.c b/drivers/infiniband/hw/cxgb4/cq.c
index fb1aafcc294f..2447f5295482 100644
--- a/drivers/infiniband/hw/cxgb4/cq.c
+++ b/drivers/infiniband/hw/cxgb4/cq.c
@@ -373,6 +373,7 @@ static void create_read_req_cqe(struct t4_wq *wq, struct t4_cqe *hw_cqe,
                                  V_CQE_SWCQE(SW_CQE(hw_cqe)) |
                                  V_CQE_OPCODE(FW_RI_READ_REQ) |
                                  V_CQE_TYPE(1));
+        read_cqe->bits_type_ts = hw_cqe->bits_type_ts;
 }
 
 /*
@@ -780,6 +781,9 @@ struct ib_cq *c4iw_create_cq(struct ib_device *ibdev, int entries,
         /* account for the status page. */
         entries++;
 
+        /* IQ needs one extra entry to differentiate full vs empty. */
+        entries++;
+
         /*
          * entries must be multiple of 16 for HW.
          */
@@ -801,7 +805,7 @@ struct ib_cq *c4iw_create_cq(struct ib_device *ibdev, int entries,
 
         chp->rhp = rhp;
         chp->cq.size--;                         /* status page */
-        chp->ibcq.cqe = chp->cq.size;
+        chp->ibcq.cqe = chp->cq.size - 1;
         spin_lock_init(&chp->lock);
         atomic_set(&chp->refcnt, 1);
         init_waitqueue_head(&chp->wait);
diff --git a/drivers/infiniband/hw/cxgb4/device.c b/drivers/infiniband/hw/cxgb4/device.c
index be23b5eab13b..d870f9c17c1e 100644
--- a/drivers/infiniband/hw/cxgb4/device.c
+++ b/drivers/infiniband/hw/cxgb4/device.c
@@ -306,7 +306,8 @@ static void c4iw_remove(struct c4iw_dev *dev)
         PDBG("%s c4iw_dev %p\n", __func__,  dev);
         cancel_delayed_work_sync(&dev->db_drop_task);
         list_del(&dev->entry);
-        c4iw_unregister_device(dev);
+        if (dev->registered)
+                c4iw_unregister_device(dev);
         c4iw_rdev_close(&dev->rdev);
         idr_destroy(&dev->cqidr);
         idr_destroy(&dev->qpidr);
@@ -343,12 +344,6 @@ static struct c4iw_dev *c4iw_alloc(const struct cxgb4_lld_info *infop)
         list_add_tail(&devp->entry, &dev_list);
         mutex_unlock(&dev_mutex);
 
-        if (c4iw_register_device(devp)) {
-                printk(KERN_ERR MOD "Unable to register device\n");
-                mutex_lock(&dev_mutex);
-                c4iw_remove(devp);
-                mutex_unlock(&dev_mutex);
-        }
         if (c4iw_debugfs_root) {
                 devp->debugfs_root = debugfs_create_dir(
                                         pci_name(devp->rdev.lldi.pdev),
@@ -379,9 +374,6 @@ static void *c4iw_uld_add(const struct cxgb4_lld_info *infop)
 
         for (i = 0; i < dev->rdev.lldi.nrxq; i++)
                 PDBG("rxqid[%u] %u\n", i, dev->rdev.lldi.rxq_ids[i]);
-
-        printk(KERN_INFO MOD "Initialized device %s\n",
-               pci_name(dev->rdev.lldi.pdev));
 out:
         return dev;
 }
@@ -471,7 +463,41 @@ nomem:
 
 static int c4iw_uld_state_change(void *handle, enum cxgb4_state new_state)
 {
+        struct c4iw_dev *dev = handle;
+
         PDBG("%s new_state %u\n", __func__, new_state);
+        switch (new_state) {
+        case CXGB4_STATE_UP:
+                printk(KERN_INFO MOD "%s: Up\n", pci_name(dev->rdev.lldi.pdev));
+                if (!dev->registered) {
+                        int ret;
+                        ret = c4iw_register_device(dev);
+                        if (ret)
+                                printk(KERN_ERR MOD
+                                       "%s: RDMA registration failed: %d\n",
+                                       pci_name(dev->rdev.lldi.pdev), ret);
+                }
+                break;
+        case CXGB4_STATE_DOWN:
+                printk(KERN_INFO MOD "%s: Down\n",
+                       pci_name(dev->rdev.lldi.pdev));
+                if (dev->registered)
+                        c4iw_unregister_device(dev);
+                break;
+        case CXGB4_STATE_START_RECOVERY:
+                printk(KERN_INFO MOD "%s: Fatal Error\n",
+                       pci_name(dev->rdev.lldi.pdev));
+                if (dev->registered)
+                        c4iw_unregister_device(dev);
+                break;
+        case CXGB4_STATE_DETACH:
+                printk(KERN_INFO MOD "%s: Detach\n",
+                       pci_name(dev->rdev.lldi.pdev));
+                mutex_lock(&dev_mutex);
+                c4iw_remove(dev);
+                mutex_unlock(&dev_mutex);
+                break;
+        }
         return 0;
 }
 
@@ -504,14 +530,12 @@ static void __exit c4iw_exit_module(void)
 {
         struct c4iw_dev *dev, *tmp;
 
-        cxgb4_unregister_uld(CXGB4_ULD_RDMA);
-
         mutex_lock(&dev_mutex);
         list_for_each_entry_safe(dev, tmp, &dev_list, entry) {
                 c4iw_remove(dev);
         }
         mutex_unlock(&dev_mutex);
-
+        cxgb4_unregister_uld(CXGB4_ULD_RDMA);
         c4iw_cm_term();
         debugfs_remove_recursive(c4iw_debugfs_root);
 }
diff --git a/drivers/infiniband/hw/cxgb4/iw_cxgb4.h b/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
index a6269981e815..277ab589b44d 100644
--- a/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
+++ b/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
@@ -152,6 +152,7 @@ struct c4iw_dev {
         struct list_head entry;
         struct delayed_work db_drop_task;
         struct dentry *debugfs_root;
+        u8 registered;
 };
 
 static inline struct c4iw_dev *to_c4iw_dev(struct ib_device *ibdev)
diff --git a/drivers/infiniband/hw/cxgb4/mem.c b/drivers/infiniband/hw/cxgb4/mem.c
index e54ff6d25691..7f94da1a2437 100644
--- a/drivers/infiniband/hw/cxgb4/mem.c
+++ b/drivers/infiniband/hw/cxgb4/mem.c
@@ -712,8 +712,10 @@ struct ib_mr *c4iw_alloc_fast_reg_mr(struct ib_pd *pd, int pbl_depth)
         php = to_c4iw_pd(pd);
         rhp = php->rhp;
         mhp = kzalloc(sizeof(*mhp), GFP_KERNEL);
-        if (!mhp)
+        if (!mhp) {
+                ret = -ENOMEM;
                 goto err;
+        }
 
         mhp->rhp = rhp;
         ret = alloc_pbl(mhp, pbl_depth);
@@ -730,8 +732,10 @@ struct ib_mr *c4iw_alloc_fast_reg_mr(struct ib_pd *pd, int pbl_depth)
         mhp->attr.state = 1;
         mmid = (stag) >> 8;
         mhp->ibmr.rkey = mhp->ibmr.lkey = stag;
-        if (insert_handle(rhp, &rhp->mmidr, mhp, mmid))
+        if (insert_handle(rhp, &rhp->mmidr, mhp, mmid)) {
+                ret = -ENOMEM;
                 goto err3;
+        }
 
         PDBG("%s mmid 0x%x mhp %p stag 0x%x\n", __func__, mmid, mhp, stag);
         return &(mhp->ibmr);
@@ -755,9 +759,6 @@ struct ib_fast_reg_page_list *c4iw_alloc_fastreg_pbl(struct ib_device *device,
         dma_addr_t dma_addr;
         int size = sizeof *c4pl + page_list_len * sizeof(u64);
 
-        if (page_list_len > T4_MAX_FR_DEPTH)
-                return ERR_PTR(-EINVAL);
-
         c4pl = dma_alloc_coherent(&dev->rdev.lldi.pdev->dev, size,
                                   &dma_addr, GFP_KERNEL);
         if (!c4pl)
diff --git a/drivers/infiniband/hw/cxgb4/provider.c b/drivers/infiniband/hw/cxgb4/provider.c
index cd3d6e2c7edf..8f645c83a125 100644
--- a/drivers/infiniband/hw/cxgb4/provider.c
+++ b/drivers/infiniband/hw/cxgb4/provider.c
@@ -496,6 +496,7 @@ int c4iw_register_device(struct c4iw_dev *dev)
                 if (ret)
                         goto bail2;
         }
+        dev->registered = 1;
         return 0;
 bail2:
         ib_unregister_device(&dev->ibdev);
@@ -514,5 +515,6 @@ void c4iw_unregister_device(struct c4iw_dev *dev)
                                    c4iw_class_attributes[i]);
         ib_unregister_device(&dev->ibdev);
         kfree(dev->ibdev.iwcm);
+        dev->registered = 0;
         return;
 }
diff --git a/drivers/infiniband/hw/cxgb4/qp.c b/drivers/infiniband/hw/cxgb4/qp.c
index 83a01dc0c4c1..0c28ed1eafa6 100644
--- a/drivers/infiniband/hw/cxgb4/qp.c
+++ b/drivers/infiniband/hw/cxgb4/qp.c
@@ -572,9 +572,13 @@ int c4iw_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                         err = build_rdma_write(wqe, wr, &len16);
                         break;
                 case IB_WR_RDMA_READ:
+                case IB_WR_RDMA_READ_WITH_INV:
                         fw_opcode = FW_RI_RDMA_READ_WR;
                         swsqe->opcode = FW_RI_READ_REQ;
-                        fw_flags = 0;
+                        if (wr->opcode == IB_WR_RDMA_READ_WITH_INV)
+                                fw_flags |= FW_RI_RDMA_READ_INVALIDATE;
+                        else
+                                fw_flags = 0;
                         err = build_rdma_read(wqe, wr, &len16);
                         if (err)
                                 break;
@@ -588,6 +592,8 @@ int c4iw_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                         err = build_fastreg(wqe, wr, &len16);
                         break;
                 case IB_WR_LOCAL_INV:
+                        if (wr->send_flags & IB_SEND_FENCE)
+                                fw_flags |= FW_RI_LOCAL_FENCE_FLAG;
                         fw_opcode = FW_RI_INV_LSTAG_WR;
                         swsqe->opcode = FW_RI_LOCAL_INV;
                         err = build_inv_stag(wqe, wr, &len16);
@@ -1339,7 +1345,6 @@ int c4iw_destroy_qp(struct ib_qp *ib_qp)
         wait_event(qhp->wait, !qhp->ep);
 
         remove_handle(rhp, &rhp->qpidr, qhp->wq.sq.qid);
-        remove_handle(rhp, &rhp->qpidr, qhp->wq.rq.qid);
         atomic_dec(&qhp->refcnt);
         wait_event(qhp->wait, !atomic_read(&qhp->refcnt));
 
@@ -1442,30 +1447,26 @@ struct ib_qp *c4iw_create_qp(struct ib_pd *pd, struct ib_qp_init_attr *attrs,
         if (ret)
                 goto err2;
 
-        ret = insert_handle(rhp, &rhp->qpidr, qhp, qhp->wq.rq.qid);
-        if (ret)
-                goto err3;
-
         if (udata) {
                 mm1 = kmalloc(sizeof *mm1, GFP_KERNEL);
                 if (!mm1) {
                         ret = -ENOMEM;
-                        goto err4;
+                        goto err3;
                 }
                 mm2 = kmalloc(sizeof *mm2, GFP_KERNEL);
                 if (!mm2) {
                         ret = -ENOMEM;
-                        goto err5;
+                        goto err4;
                 }
                 mm3 = kmalloc(sizeof *mm3, GFP_KERNEL);
                 if (!mm3) {
                         ret = -ENOMEM;
-                        goto err6;
+                        goto err5;
                 }
                 mm4 = kmalloc(sizeof *mm4, GFP_KERNEL);
                 if (!mm4) {
                         ret = -ENOMEM;
-                        goto err7;
+                        goto err6;
                 }
 
                 uresp.qid_mask = rhp->rdev.qpmask;
@@ -1487,7 +1488,7 @@ struct ib_qp *c4iw_create_qp(struct ib_pd *pd, struct ib_qp_init_attr *attrs,
                 spin_unlock(&ucontext->mmap_lock);
                 ret = ib_copy_to_udata(udata, &uresp, sizeof uresp);
                 if (ret)
-                        goto err8;
+                        goto err7;
                 mm1->key = uresp.sq_key;
                 mm1->addr = virt_to_phys(qhp->wq.sq.queue);
                 mm1->len = PAGE_ALIGN(qhp->wq.sq.memsize);
@@ -1511,16 +1512,14 @@ struct ib_qp *c4iw_create_qp(struct ib_pd *pd, struct ib_qp_init_attr *attrs,
              __func__, qhp, qhp->attr.sq_num_entries, qhp->attr.rq_num_entries,
              qhp->wq.sq.qid);
         return &qhp->ibqp;
-err8:
-        kfree(mm4);
 err7:
-        kfree(mm3);
+        kfree(mm4);
 err6:
-        kfree(mm2);
+        kfree(mm3);
 err5:
-        kfree(mm1);
+        kfree(mm2);
 err4:
-        remove_handle(rhp, &rhp->qpidr, qhp->wq.rq.qid);
+        kfree(mm1);
 err3:
         remove_handle(rhp, &rhp->qpidr, qhp->wq.sq.qid);
 err2:
diff --git a/drivers/infiniband/hw/cxgb4/t4.h b/drivers/infiniband/hw/cxgb4/t4.h
index d0e8af352408..1057cb96302e 100644
--- a/drivers/infiniband/hw/cxgb4/t4.h
+++ b/drivers/infiniband/hw/cxgb4/t4.h
@@ -41,11 +41,13 @@
 #define T4_MAX_NUM_QP (1<<16)
 #define T4_MAX_NUM_CQ (1<<15)
 #define T4_MAX_NUM_PD (1<<15)
-#define T4_MAX_PBL_SIZE 256
-#define T4_MAX_RQ_SIZE 1024
-#define T4_MAX_SQ_SIZE 1024
-#define T4_MAX_QP_DEPTH (T4_MAX_RQ_SIZE-1)
-#define T4_MAX_CQ_DEPTH 8192
+#define T4_EQ_STATUS_ENTRIES (L1_CACHE_BYTES > 64 ? 2 : 1)
+#define T4_MAX_EQ_SIZE (65520 - T4_EQ_STATUS_ENTRIES)
+#define T4_MAX_IQ_SIZE (65520 - 1)
+#define T4_MAX_RQ_SIZE (8192 - T4_EQ_STATUS_ENTRIES)
+#define T4_MAX_SQ_SIZE (T4_MAX_EQ_SIZE - 1)
+#define T4_MAX_QP_DEPTH (T4_MAX_RQ_SIZE - 1)
+#define T4_MAX_CQ_DEPTH (T4_MAX_IQ_SIZE - 1)
 #define T4_MAX_NUM_STAG (1<<15)
 #define T4_MAX_MR_SIZE (~0ULL - 1)
 #define T4_PAGESIZE_MASK 0xffff000  /* 4KB-128MB */
@@ -79,12 +81,11 @@ struct t4_status_page {
                         sizeof(struct fw_ri_isgl)) / sizeof(struct fw_ri_sge))
 #define T4_MAX_FR_IMMD ((T4_SQ_NUM_BYTES - sizeof(struct fw_ri_fr_nsmr_wr) - \
                         sizeof(struct fw_ri_immd)))
-#define T4_MAX_FR_DEPTH 255
+#define T4_MAX_FR_DEPTH (T4_MAX_FR_IMMD / sizeof(u64))
 
 #define T4_RQ_NUM_SLOTS 2
 #define T4_RQ_NUM_BYTES (T4_EQ_SIZE * T4_RQ_NUM_SLOTS)
-#define T4_MAX_RECV_SGE ((T4_RQ_NUM_BYTES - sizeof(struct fw_ri_recv_wr) - \
-                        sizeof(struct fw_ri_isgl)) / sizeof(struct fw_ri_sge))
+#define T4_MAX_RECV_SGE 4
 
 union t4_wr {
         struct fw_ri_res_wr res;
@@ -434,7 +435,7 @@ struct t4_cq {
         struct c4iw_rdev *rdev;
         u64 ugts;
         size_t memsize;
-        u64 timestamp;
+        __be64 bits_type_ts;
         u32 cqid;
         u16 size; /* including status page */
         u16 cidx;
@@ -449,25 +450,17 @@ struct t4_cq {
 static inline int t4_arm_cq(struct t4_cq *cq, int se)
 {
         u32 val;
-        u16 inc;
-
-        do {
-                /*
-                 * inc must be less the both the max update value -and-
-                 * the size of the CQ.
-                 */
-                inc = cq->cidx_inc <= CIDXINC_MASK ? cq->cidx_inc :
-                                                     CIDXINC_MASK;
-                inc = inc <= (cq->size - 1) ? inc : (cq->size - 1);
-                if (inc == cq->cidx_inc)
-                        val = SEINTARM(se) | CIDXINC(inc) | TIMERREG(6) |
-                              INGRESSQID(cq->cqid);
-                else
-                        val = SEINTARM(0) | CIDXINC(inc) | TIMERREG(7) |
-                              INGRESSQID(cq->cqid);
-                cq->cidx_inc -= inc;
+
+        while (cq->cidx_inc > CIDXINC_MASK) {
+                val = SEINTARM(0) | CIDXINC(CIDXINC_MASK) | TIMERREG(7) |
+                      INGRESSQID(cq->cqid);
                 writel(val, cq->gts);
-        } while (cq->cidx_inc);
+                cq->cidx_inc -= CIDXINC_MASK;
+        }
+        val = SEINTARM(se) | CIDXINC(cq->cidx_inc) | TIMERREG(6) |
+              INGRESSQID(cq->cqid);
+        writel(val, cq->gts);
+        cq->cidx_inc = 0;
         return 0;
 }
 
@@ -487,7 +480,9 @@ static inline void t4_swcq_consume(struct t4_cq *cq)
 
 static inline void t4_hwcq_consume(struct t4_cq *cq)
 {
-        cq->cidx_inc++;
+        cq->bits_type_ts = cq->queue[cq->cidx].bits_type_ts;
+        if (++cq->cidx_inc == cq->size)
+                cq->cidx_inc = 0;
         if (++cq->cidx == cq->size) {
                 cq->cidx = 0;
                 cq->gen ^= 1;
@@ -501,20 +496,23 @@ static inline int t4_valid_cqe(struct t4_cq *cq, struct t4_cqe *cqe)
 
 static inline int t4_next_hw_cqe(struct t4_cq *cq, struct t4_cqe **cqe)
 {
-        int ret = 0;
-        u64 bits_type_ts = be64_to_cpu(cq->queue[cq->cidx].bits_type_ts);
+        int ret;
+        u16 prev_cidx;
 
-        if (G_CQE_GENBIT(bits_type_ts) == cq->gen) {
-                *cqe = &cq->queue[cq->cidx];
-                cq->timestamp = G_CQE_TS(bits_type_ts);
-        } else if (G_CQE_TS(bits_type_ts) > cq->timestamp)
-                ret = -EOVERFLOW;
+        if (cq->cidx == 0)
+                prev_cidx = cq->size - 1;
         else
-                ret = -ENODATA;
-        if (ret == -EOVERFLOW) {
-                printk(KERN_ERR MOD "cq overflow cqid %u\n", cq->cqid);
+                prev_cidx = cq->cidx - 1;
+
+        if (cq->queue[prev_cidx].bits_type_ts != cq->bits_type_ts) {
+                ret = -EOVERFLOW;
                 cq->error = 1;
-        }
+                printk(KERN_ERR MOD "cq overflow cqid %u\n", cq->cqid);
+        } else if (t4_valid_cqe(cq, &cq->queue[cq->cidx])) {
+                *cqe = &cq->queue[cq->cidx];
+                ret = 0;
+        } else
+                ret = -ENODATA;
         return ret;
 }
 
diff --git a/drivers/infiniband/hw/nes/nes_hw.c b/drivers/infiniband/hw/nes/nes_hw.c
index 86acb7d57064..57874a165083 100644
--- a/drivers/infiniband/hw/nes/nes_hw.c
+++ b/drivers/infiniband/hw/nes/nes_hw.c
@@ -2584,7 +2584,6 @@ static void nes_process_mac_intr(struct nes_device *nesdev, u32 mac_number)
                                 break;
                         }
                 }
-                spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
 
                 if (phy_data & 0x0004) {
                         if (wide_ppm_offset &&
@@ -2639,6 +2638,8 @@ static void nes_process_mac_intr(struct nes_device *nesdev, u32 mac_number)
                 }
         }
 
+        spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
+
         nesadapter->mac_sw_state[mac_number] = NES_MAC_SW_IDLE;
 }
 
@@ -3422,6 +3423,7 @@ static void nes_process_iwarp_aeqe(struct nes_device *nesdev,
         struct nes_adapter *nesadapter = nesdev->nesadapter;
         u32 aeq_info;
         u32 next_iwarp_state = 0;
+        u32 aeqe_cq_id;
         u16 async_event_id;
         u8 tcp_state;
         u8 iwarp_state;
@@ -3449,6 +3451,14 @@ static void nes_process_iwarp_aeqe(struct nes_device *nesdev,
                         le32_to_cpu(aeqe->aeqe_words[NES_AEQE_COMP_QP_CQ_ID_IDX]), aeqe,
                         nes_tcp_state_str[tcp_state], nes_iwarp_state_str[iwarp_state]);
 
+        aeqe_cq_id = le32_to_cpu(aeqe->aeqe_words[NES_AEQE_COMP_QP_CQ_ID_IDX]);
+        if (aeq_info & NES_AEQE_QP) {
+                if ((!nes_is_resource_allocated(nesadapter, nesadapter->allocated_qps,
+                                aeqe_cq_id)) ||
+                                (atomic_read(&nesqp->close_timer_started)))
+                        return;
+        }
+
         switch (async_event_id) {
                 case NES_AEQE_AEID_LLP_FIN_RECEIVED:
                         if (nesqp->term_flags)
diff --git a/drivers/infiniband/hw/nes/nes_nic.c b/drivers/infiniband/hw/nes/nes_nic.c
index 9f4cadf9f851..242f42d8c1c6 100644
--- a/drivers/infiniband/hw/nes/nes_nic.c
+++ b/drivers/infiniband/hw/nes/nes_nic.c
@@ -1002,6 +1002,7 @@ static int nes_netdev_change_mtu(struct net_device *netdev, int new_mtu)
         return ret;
 }
 
+
 static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
         "Link Change Interrupts",
         "Linearized SKBs",
@@ -1016,11 +1017,15 @@ static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
         "Rx Jabber Errors",
         "Rx Oversized Frames",
         "Rx Short Frames",
+        "Rx Length Errors",
+        "Rx CRC Errors",
+        "Rx Port Discard",
         "Endnode Rx Discards",
         "Endnode Rx Octets",
         "Endnode Rx Frames",
         "Endnode Tx Octets",
         "Endnode Tx Frames",
+        "Tx Errors",
         "mh detected",
         "mh pauses",
         "Retransmission Count",
@@ -1049,19 +1054,13 @@ static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
         "CM Nodes Destroyed",
         "CM Accel Drops",
         "CM Resets Received",
+        "Free 4Kpbls",
+        "Free 256pbls",
         "Timer Inits",
-        "CQ Depth 1",
-        "CQ Depth 4",
-        "CQ Depth 16",
-        "CQ Depth 24",
-        "CQ Depth 32",
-        "CQ Depth 128",
-        "CQ Depth 256",
         "LRO aggregated",
         "LRO flushed",
         "LRO no_desc",
 };
-
 #define NES_ETHTOOL_STAT_COUNT  ARRAY_SIZE(nes_ethtool_stringset)
 
 /**
@@ -1121,12 +1120,14 @@ static void nes_netdev_get_strings(struct net_device *netdev, u32 stringset,
 /**
  * nes_netdev_get_ethtool_stats
  */
+
 static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
                 struct ethtool_stats *target_ethtool_stats, u64 *target_stat_values)
 {
         u64 u64temp;
         struct nes_vnic *nesvnic = netdev_priv(netdev);
         struct nes_device *nesdev = nesvnic->nesdev;
+        struct nes_adapter *nesadapter = nesdev->nesadapter;
         u32 nic_count;
         u32 u32temp;
         u32 index = 0;
@@ -1155,6 +1156,46 @@ static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
         nesvnic->nesdev->port_tx_discards += u32temp;
         nesvnic->netstats.tx_dropped += u32temp;
 
+        u32temp = nes_read_indexed(nesdev,
+                        NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
+        nesvnic->netstats.rx_dropped += u32temp;
+        nesvnic->nesdev->mac_rx_errors += u32temp;
+        nesvnic->nesdev->mac_rx_short_frames += u32temp;
+
+        u32temp = nes_read_indexed(nesdev,
+                        NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
+        nesvnic->netstats.rx_dropped += u32temp;
+        nesvnic->nesdev->mac_rx_errors += u32temp;
+        nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
+
+        u32temp = nes_read_indexed(nesdev,
+                        NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
+        nesvnic->netstats.rx_dropped += u32temp;
+        nesvnic->nesdev->mac_rx_errors += u32temp;
+        nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
+
+        u32temp = nes_read_indexed(nesdev,
+                        NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
+        nesvnic->netstats.rx_dropped += u32temp;
+        nesvnic->nesdev->mac_rx_errors += u32temp;
+        nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
+
+        u32temp = nes_read_indexed(nesdev,
+                        NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
+        nesvnic->netstats.rx_length_errors += u32temp;
+        nesvnic->nesdev->mac_rx_errors += u32temp;
+
+        u32temp = nes_read_indexed(nesdev,
+                        NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
+        nesvnic->nesdev->mac_rx_errors += u32temp;
+        nesvnic->nesdev->mac_rx_crc_errors += u32temp;
+        nesvnic->netstats.rx_crc_errors += u32temp;
+
+        u32temp = nes_read_indexed(nesdev,
+                        NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
+        nesvnic->nesdev->mac_tx_errors += u32temp;
+        nesvnic->netstats.tx_errors += u32temp;
+
         for (nic_count = 0; nic_count < NES_MAX_PORT_COUNT; nic_count++) {
                 if (nesvnic->qp_nic_index[nic_count] == 0xf)
                         break;
@@ -1219,11 +1260,15 @@ static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
         target_stat_values[++index] = nesvnic->nesdev->mac_rx_jabber_frames;
         target_stat_values[++index] = nesvnic->nesdev->mac_rx_oversized_frames;
         target_stat_values[++index] = nesvnic->nesdev->mac_rx_short_frames;
+        target_stat_values[++index] = nesvnic->netstats.rx_length_errors;
+        target_stat_values[++index] = nesvnic->nesdev->mac_rx_crc_errors;
+        target_stat_values[++index] = nesvnic->nesdev->port_rx_discards;
         target_stat_values[++index] = nesvnic->endnode_nstat_rx_discard;
         target_stat_values[++index] = nesvnic->endnode_nstat_rx_octets;
         target_stat_values[++index] = nesvnic->endnode_nstat_rx_frames;
         target_stat_values[++index] = nesvnic->endnode_nstat_tx_octets;
         target_stat_values[++index] = nesvnic->endnode_nstat_tx_frames;
+        target_stat_values[++index] = nesvnic->nesdev->mac_tx_errors;
         target_stat_values[++index] = mh_detected;
         target_stat_values[++index] = mh_pauses_sent;
         target_stat_values[++index] = nesvnic->endnode_ipv4_tcp_retransmits;
@@ -1252,21 +1297,14 @@ static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
         target_stat_values[++index] = atomic_read(&cm_nodes_destroyed);
         target_stat_values[++index] = atomic_read(&cm_accel_dropped_pkts);
         target_stat_values[++index] = atomic_read(&cm_resets_recvd);
+        target_stat_values[++index] = nesadapter->free_4kpbl;
+        target_stat_values[++index] = nesadapter->free_256pbl;
         target_stat_values[++index] = int_mod_timer_init;
-        target_stat_values[++index] = int_mod_cq_depth_1;
-        target_stat_values[++index] = int_mod_cq_depth_4;
-        target_stat_values[++index] = int_mod_cq_depth_16;
-        target_stat_values[++index] = int_mod_cq_depth_24;
-        target_stat_values[++index] = int_mod_cq_depth_32;
-        target_stat_values[++index] = int_mod_cq_depth_128;
-        target_stat_values[++index] = int_mod_cq_depth_256;
         target_stat_values[++index] = nesvnic->lro_mgr.stats.aggregated;
         target_stat_values[++index] = nesvnic->lro_mgr.stats.flushed;
         target_stat_values[++index] = nesvnic->lro_mgr.stats.no_desc;
-
 }
 
-
 /**
  * nes_netdev_get_drvinfo
  */
diff --git a/drivers/net/mlx4/icm.c b/drivers/net/mlx4/icm.c
index 57288ca1395f..b07e4dee80aa 100644
--- a/drivers/net/mlx4/icm.c
+++ b/drivers/net/mlx4/icm.c
@@ -163,28 +163,30 @@ struct mlx4_icm *mlx4_alloc_icm(struct mlx4_dev *dev, int npages,
                         ret = mlx4_alloc_icm_pages(&chunk->mem[chunk->npages],
                                                    cur_order, gfp_mask);
 
-                if (!ret) {
-                        ++chunk->npages;
-
-                        if (coherent)
-                                ++chunk->nsg;
-                        else if (chunk->npages == MLX4_ICM_CHUNK_LEN) {
-                                chunk->nsg = pci_map_sg(dev->pdev, chunk->mem,
-                                                        chunk->npages,
-                                                        PCI_DMA_BIDIRECTIONAL);
+                if (ret) {
+                        if (--cur_order < 0)
+                                goto fail;
+                        else
+                                continue;
+                }
 
-                                if (chunk->nsg <= 0)
-                                        goto fail;
+                ++chunk->npages;
 
-                                chunk = NULL;
-                        }
+                if (coherent)
+                        ++chunk->nsg;
+                else if (chunk->npages == MLX4_ICM_CHUNK_LEN) {
+                        chunk->nsg = pci_map_sg(dev->pdev, chunk->mem,
+                                                chunk->npages,
+                                                PCI_DMA_BIDIRECTIONAL);
 
-                        npages -= 1 << cur_order;
-                } else {
-                        --cur_order;
-                        if (cur_order < 0)
+                        if (chunk->nsg <= 0)
                                 goto fail;
                 }
+
+                if (chunk->npages == MLX4_ICM_CHUNK_LEN)
+                        chunk = NULL;
+
+                npages -= 1 << cur_order;
         }
 
         if (!coherent && chunk) {