IB/mthca: Stop returning separate error and status from FW commands
Goldwyn Rodrigues [Thu, 7 Jul 2011 17:20:40 +0000 (17:20 +0000)]
Instead of having firmware command functions return an error and also
a status, leading to code like:

err = mthca_FW_COMMAND(..., &status);
if (err)
goto out;
        if (status) {
err = -E...;
goto out;
}

all over the place, just handle the FW status inside the FW command
handling code (the way mlx4 does it), so we can simply write:

err = mthca_FW_COMMAND(...);
if (err)
goto out;

In addition to simplifying the source code, this also saves a healthy
chunk of text:

    add/remove: 0/0 grow/shrink: 10/88 up/down: 510/-3357 (-2847)
    function                                     old     new   delta
    static.trans_table                           324     584    +260
    mthca_cmd_poll                               352     477    +125
    mthca_cmd_wait                               511     567     +56
    mthca_table_put                              213     240     +27
    mthca_cleanup_db_tab                         372     387     +15
    __mthca_remove_one                           314     323      +9
    mthca_cleanup_user_db_tab                    275     283      +8
    __mthca_init_one                            1738    1746      +8
    mthca_cleanup                                 20      21      +1
    mthca_MAD_IFC                               1081    1082      +1
    mthca_MGID_HASH                               43      40      -3
    mthca_MAP_ICM_AUX                             23      20      -3
    mthca_MAP_ICM                                 19      16      -3
    mthca_MAP_FA                                  23      20      -3
    mthca_READ_MGM                                43      38      -5
    mthca_QUERY_SRQ                               43      38      -5
    mthca_QUERY_QP                                59      54      -5
    mthca_HW2SW_SRQ                               43      38      -5
    mthca_HW2SW_MPT                               60      55      -5
    mthca_HW2SW_EQ                                43      38      -5
    mthca_HW2SW_CQ                                43      38      -5
    mthca_free_icm_table                         120     114      -6
    mthca_query_srq                              214     206      -8
    mthca_free_qp                                662     654      -8
    mthca_cmd                                     38      28     -10
    mthca_alloc_db                              1321    1311     -10
    mthca_setup_hca                             1067    1055     -12
    mthca_WRITE_MTT                               35      22     -13
    mthca_WRITE_MGM                               40      27     -13
    mthca_UNMAP_ICM_AUX                           36      23     -13
    mthca_UNMAP_FA                                36      23     -13
    mthca_SYS_DIS                                 36      23     -13
    mthca_SYNC_TPT                                36      23     -13
    mthca_SW2HW_SRQ                               35      22     -13
    mthca_SW2HW_MPT                               35      22     -13
    mthca_SW2HW_EQ                                35      22     -13
    mthca_SW2HW_CQ                                35      22     -13
    mthca_RUN_FW                                  36      23     -13
    mthca_DISABLE_LAM                             36      23     -13
    mthca_CLOSE_IB                                36      23     -13
    mthca_CLOSE_HCA                               38      25     -13
    mthca_ARM_SRQ                                 39      26     -13
    mthca_free_icms                              178     164     -14
    mthca_QUERY_DDR                              389     375     -14
    mthca_resize_cq                             1063    1048     -15
    mthca_unmap_eq_icm                           123     107     -16
    mthca_map_eq_icm                             396     380     -16
    mthca_cmd_box                                 90      74     -16
    mthca_SET_IB                                 433     417     -16
    mthca_RESIZE_CQ                              369     353     -16
    mthca_MAP_ICM_page                           240     224     -16
    mthca_MAP_EQ                                 183     167     -16
    mthca_INIT_IB                                473     457     -16
    mthca_INIT_HCA                               745     729     -16
    mthca_map_user_db                            816     798     -18
    mthca_SYS_EN                                 157     139     -18
    mthca_cleanup_qp_table                        78      59     -19
    mthca_cleanup_eq_table                       168     149     -19
    mthca_UNMAP_ICM                              143     121     -22
    mthca_modify_srq                             172     149     -23
    mthca_unmap_fmr                              198     174     -24
    mthca_query_qp                               814     790     -24
    mthca_query_pkey                             343     319     -24
    mthca_SET_ICM_SIZE                            34      10     -24
    mthca_QUERY_DEV_LIM                         1870    1846     -24
    mthca_map_cmd                               1130    1105     -25
    mthca_ENABLE_LAM                             401     375     -26
    mthca_modify_port                            247     220     -27
    mthca_query_device                           884     850     -34
    mthca_NOP                                     75      41     -34
    mthca_table_get                              287     249     -38
    mthca_init_qp_table                          333     293     -40
    mthca_MODIFY_QP                              348     308     -40
    mthca_close_hca                              131      89     -42
    mthca_free_eq                                435     390     -45
    mthca_query_port                             755     705     -50
    mthca_free_cq                                581     528     -53
    mthca_alloc_icm_table                        578     524     -54
    mthca_multicast_attach                      1041     986     -55
    mthca_init_hca                               326     271     -55
    mthca_query_gid                              487     431     -56
    mthca_free_srq                               524     468     -56
    mthca_free_mr                                168     111     -57
    mthca_create_eq                             1560    1501     -59
    mthca_multicast_detach                       790     728     -62
    mthca_write_mtt                              918     854     -64
    mthca_register_device                       1406    1342     -64
    mthca_fmr_alloc                              947     883     -64
    mthca_mr_alloc                               652     582     -70
    mthca_process_mad                           1242    1164     -78
    mthca_dev_lim                                910     830     -80
    find_mgm                                     482     400     -82
    mthca_modify_qp                             3852    3753     -99
    mthca_init_cq                               1281    1181    -100
    mthca_alloc_srq                             1719    1610    -109
    mthca_init_eq_table                         1807    1679    -128
    mthca_init_tavor                             761     491    -270
    mthca_init_arbel                            2617    2098    -519

Signed-off-by: Goldwyn Rodrigues <rgoldwyn@suse.de>

12 files changed:
drivers/infiniband/hw/mthca/mthca_cmd.c
drivers/infiniband/hw/mthca/mthca_cmd.h
drivers/infiniband/hw/mthca/mthca_cq.c
drivers/infiniband/hw/mthca/mthca_eq.c
drivers/infiniband/hw/mthca/mthca_mad.c
drivers/infiniband/hw/mthca/mthca_main.c
drivers/infiniband/hw/mthca/mthca_mcg.c
drivers/infiniband/hw/mthca/mthca_memfree.c
drivers/infiniband/hw/mthca/mthca_mr.c
drivers/infiniband/hw/mthca/mthca_provider.c
drivers/infiniband/hw/mthca/mthca_qp.c
drivers/infiniband/hw/mthca/mthca_srq.c

index 7bfa2a1..3082b3b 100644 (file)
@@ -301,6 +301,38 @@ static int mthca_cmd_post(struct mthca_dev *dev,
        return err;
 }
 
+
+static int mthca_status_to_errno(u8 status)
+{
+       static const int trans_table[] = {
+               [MTHCA_CMD_STAT_INTERNAL_ERR]   = -EIO,
+               [MTHCA_CMD_STAT_BAD_OP]         = -EPERM,
+               [MTHCA_CMD_STAT_BAD_PARAM]      = -EINVAL,
+               [MTHCA_CMD_STAT_BAD_SYS_STATE]  = -ENXIO,
+               [MTHCA_CMD_STAT_BAD_RESOURCE]   = -EBADF,
+               [MTHCA_CMD_STAT_RESOURCE_BUSY]  = -EBUSY,
+               [MTHCA_CMD_STAT_DDR_MEM_ERR]    = -ENOMEM,
+               [MTHCA_CMD_STAT_EXCEED_LIM]     = -ENOMEM,
+               [MTHCA_CMD_STAT_BAD_RES_STATE]  = -EBADF,
+               [MTHCA_CMD_STAT_BAD_INDEX]      = -EBADF,
+               [MTHCA_CMD_STAT_BAD_NVMEM]      = -EFAULT,
+               [MTHCA_CMD_STAT_BAD_QPEE_STATE] = -EINVAL,
+               [MTHCA_CMD_STAT_BAD_SEG_PARAM]  = -EFAULT,
+               [MTHCA_CMD_STAT_REG_BOUND]      = -EBUSY,
+               [MTHCA_CMD_STAT_LAM_NOT_PRE]    = -EAGAIN,
+               [MTHCA_CMD_STAT_BAD_PKT]        = -EBADMSG,
+               [MTHCA_CMD_STAT_BAD_SIZE]       = -ENOMEM,
+       };
+
+       if (status >= ARRAY_SIZE(trans_table) ||
+                       (status != MTHCA_CMD_STAT_OK
+                        && trans_table[status] == 0))
+               return -EINVAL;
+
+       return trans_table[status];
+}
+
+
 static int mthca_cmd_poll(struct mthca_dev *dev,
                          u64 in_param,
                          u64 *out_param,
@@ -308,11 +340,11 @@ static int mthca_cmd_poll(struct mthca_dev *dev,
                          u32 in_modifier,
                          u8 op_modifier,
                          u16 op,
-                         unsigned long timeout,
-                         u8 *status)
+                         unsigned long timeout)
 {
        int err = 0;
        unsigned long end;
+       u8 status;
 
        down(&dev->cmd.poll_sem);
 
@@ -341,7 +373,12 @@ static int mthca_cmd_poll(struct mthca_dev *dev,
                        (u64) be32_to_cpu((__force __be32)
                                          __raw_readl(dev->hcr + HCR_OUT_PARAM_OFFSET + 4));
 
-       *status = be32_to_cpu((__force __be32) __raw_readl(dev->hcr + HCR_STATUS_OFFSET)) >> 24;
+       status = be32_to_cpu((__force __be32) __raw_readl(dev->hcr + HCR_STATUS_OFFSET)) >> 24;
+       if (status) {
+               mthca_dbg(dev, "Command %02x completed with status %02x\n",
+                         op, status);
+               err = mthca_status_to_errno(status);
+       }
 
 out:
        up(&dev->cmd.poll_sem);
@@ -374,8 +411,7 @@ static int mthca_cmd_wait(struct mthca_dev *dev,
                          u32 in_modifier,
                          u8 op_modifier,
                          u16 op,
-                         unsigned long timeout,
-                         u8 *status)
+                         unsigned long timeout)
 {
        int err = 0;
        struct mthca_cmd_context *context;
@@ -407,10 +443,11 @@ static int mthca_cmd_wait(struct mthca_dev *dev,
        if (err)
                goto out;
 
-       *status = context->status;
-       if (*status)
+       if (context->status) {
                mthca_dbg(dev, "Command %02x completed with status %02x\n",
-                         op, *status);
+                         op, context->status);
+               err = mthca_status_to_errno(context->status);
+       }
 
        if (out_is_imm)
                *out_param = context->out_param;
@@ -432,17 +469,16 @@ static int mthca_cmd_box(struct mthca_dev *dev,
                         u32 in_modifier,
                         u8 op_modifier,
                         u16 op,
-                        unsigned long timeout,
-                        u8 *status)
+                        unsigned long timeout)
 {
        if (dev->cmd.flags & MTHCA_CMD_USE_EVENTS)
                return mthca_cmd_wait(dev, in_param, &out_param, 0,
                                      in_modifier, op_modifier, op,
-                                     timeout, status);
+                                     timeout);
        else
                return mthca_cmd_poll(dev, in_param, &out_param, 0,
                                      in_modifier, op_modifier, op,
-                                     timeout, status);
+                                     timeout);
 }
 
 /* Invoke a command with no output parameter */
@@ -451,11 +487,10 @@ static int mthca_cmd(struct mthca_dev *dev,
                     u32 in_modifier,
                     u8 op_modifier,
                     u16 op,
-                    unsigned long timeout,
-                    u8 *status)
+                    unsigned long timeout)
 {
        return mthca_cmd_box(dev, in_param, 0, in_modifier,
-                            op_modifier, op, timeout, status);
+                            op_modifier, op, timeout);
 }
 
 /*
@@ -469,17 +504,16 @@ static int mthca_cmd_imm(struct mthca_dev *dev,
                         u32 in_modifier,
                         u8 op_modifier,
                         u16 op,
-                        unsigned long timeout,
-                        u8 *status)
+                        unsigned long timeout)
 {
        if (dev->cmd.flags & MTHCA_CMD_USE_EVENTS)
                return mthca_cmd_wait(dev, in_param, out_param, 1,
                                      in_modifier, op_modifier, op,
-                                     timeout, status);
+                                     timeout);
        else
                return mthca_cmd_poll(dev, in_param, out_param, 1,
                                      in_modifier, op_modifier, op,
-                                     timeout, status);
+                                     timeout);
 }
 
 int mthca_cmd_init(struct mthca_dev *dev)
@@ -596,14 +630,14 @@ void mthca_free_mailbox(struct mthca_dev *dev, struct mthca_mailbox *mailbox)
        kfree(mailbox);
 }
 
-int mthca_SYS_EN(struct mthca_dev *dev, u8 *status)
+int mthca_SYS_EN(struct mthca_dev *dev)
 {
        u64 out;
        int ret;
 
-       ret = mthca_cmd_imm(dev, 0, &out, 0, 0, CMD_SYS_EN, CMD_TIME_CLASS_D, status);
+       ret = mthca_cmd_imm(dev, 0, &out, 0, 0, CMD_SYS_EN, CMD_TIME_CLASS_D);
 
-       if (*status == MTHCA_CMD_STAT_DDR_MEM_ERR)
+       if (ret == -ENOMEM)
                mthca_warn(dev, "SYS_EN DDR error: syn=%x, sock=%d, "
                           "sladdr=%d, SPD source=%s\n",
                           (int) (out >> 6) & 0xf, (int) (out >> 4) & 3,
@@ -612,13 +646,13 @@ int mthca_SYS_EN(struct mthca_dev *dev, u8 *status)
        return ret;
 }
 
-int mthca_SYS_DIS(struct mthca_dev *dev, u8 *status)
+int mthca_SYS_DIS(struct mthca_dev *dev)
 {
-       return mthca_cmd(dev, 0, 0, 0, CMD_SYS_DIS, CMD_TIME_CLASS_C, status);
+       return mthca_cmd(dev, 0, 0, 0, CMD_SYS_DIS, CMD_TIME_CLASS_C);
 }
 
 static int mthca_map_cmd(struct mthca_dev *dev, u16 op, struct mthca_icm *icm,
-                        u64 virt, u8 *status)
+                        u64 virt)
 {
        struct mthca_mailbox *mailbox;
        struct mthca_icm_iter iter;
@@ -666,8 +700,8 @@ static int mthca_map_cmd(struct mthca_dev *dev, u16 op, struct mthca_icm *icm,
 
                        if (++nent == MTHCA_MAILBOX_SIZE / 16) {
                                err = mthca_cmd(dev, mailbox->dma, nent, 0, op,
-                                               CMD_TIME_CLASS_B, status);
-                               if (err || *status)
+                                               CMD_TIME_CLASS_B);
+                               if (err)
                                        goto out;
                                nent = 0;
                        }
@@ -676,7 +710,7 @@ static int mthca_map_cmd(struct mthca_dev *dev, u16 op, struct mthca_icm *icm,
 
        if (nent)
                err = mthca_cmd(dev, mailbox->dma, nent, 0, op,
-                               CMD_TIME_CLASS_B, status);
+                               CMD_TIME_CLASS_B);
 
        switch (op) {
        case CMD_MAP_FA:
@@ -696,19 +730,19 @@ out:
        return err;
 }
 
-int mthca_MAP_FA(struct mthca_dev *dev, struct mthca_icm *icm, u8 *status)
+int mthca_MAP_FA(struct mthca_dev *dev, struct mthca_icm *icm)
 {
-       return mthca_map_cmd(dev, CMD_MAP_FA, icm, -1, status);
+       return mthca_map_cmd(dev, CMD_MAP_FA, icm, -1);
 }
 
-int mthca_UNMAP_FA(struct mthca_dev *dev, u8 *status)
+int mthca_UNMAP_FA(struct mthca_dev *dev)
 {
-       return mthca_cmd(dev, 0, 0, 0, CMD_UNMAP_FA, CMD_TIME_CLASS_B, status);
+       return mthca_cmd(dev, 0, 0, 0, CMD_UNMAP_FA, CMD_TIME_CLASS_B);
 }
 
-int mthca_RUN_FW(struct mthca_dev *dev, u8 *status)
+int mthca_RUN_FW(struct mthca_dev *dev)
 {
-       return mthca_cmd(dev, 0, 0, 0, CMD_RUN_FW, CMD_TIME_CLASS_A, status);
+       return mthca_cmd(dev, 0, 0, 0, CMD_RUN_FW, CMD_TIME_CLASS_A);
 }
 
 static void mthca_setup_cmd_doorbells(struct mthca_dev *dev, u64 base)
@@ -737,7 +771,7 @@ static void mthca_setup_cmd_doorbells(struct mthca_dev *dev, u64 base)
        mthca_dbg(dev, "Mapped doorbell page for posting FW commands\n");
 }
 
-int mthca_QUERY_FW(struct mthca_dev *dev, u8 *status)
+int mthca_QUERY_FW(struct mthca_dev *dev)
 {
        struct mthca_mailbox *mailbox;
        u32 *outbox;
@@ -771,7 +805,7 @@ int mthca_QUERY_FW(struct mthca_dev *dev, u8 *status)
        outbox = mailbox->buf;
 
        err = mthca_cmd_box(dev, 0, mailbox->dma, 0, 0, CMD_QUERY_FW,
-                           CMD_TIME_CLASS_A, status);
+                           CMD_TIME_CLASS_A);
 
        if (err)
                goto out;
@@ -843,7 +877,7 @@ out:
        return err;
 }
 
-int mthca_ENABLE_LAM(struct mthca_dev *dev, u8 *status)
+int mthca_ENABLE_LAM(struct mthca_dev *dev)
 {
        struct mthca_mailbox *mailbox;
        u8 info;
@@ -864,14 +898,11 @@ int mthca_ENABLE_LAM(struct mthca_dev *dev, u8 *status)
        outbox = mailbox->buf;
 
        err = mthca_cmd_box(dev, 0, mailbox->dma, 0, 0, CMD_ENABLE_LAM,
-                           CMD_TIME_CLASS_C, status);
+                           CMD_TIME_CLASS_C);
 
        if (err)
                goto out;
 
-       if (*status == MTHCA_CMD_STAT_LAM_NOT_PRE)
-               goto out;
-
        MTHCA_GET(dev->ddr_start, outbox, ENABLE_LAM_START_OFFSET);
        MTHCA_GET(dev->ddr_end,   outbox, ENABLE_LAM_END_OFFSET);
        MTHCA_GET(info,           outbox, ENABLE_LAM_INFO_OFFSET);
@@ -896,12 +927,12 @@ out:
        return err;
 }
 
-int mthca_DISABLE_LAM(struct mthca_dev *dev, u8 *status)
+int mthca_DISABLE_LAM(struct mthca_dev *dev)
 {
-       return mthca_cmd(dev, 0, 0, 0, CMD_SYS_DIS, CMD_TIME_CLASS_C, status);
+       return mthca_cmd(dev, 0, 0, 0, CMD_SYS_DIS, CMD_TIME_CLASS_C);
 }
 
-int mthca_QUERY_DDR(struct mthca_dev *dev, u8 *status)
+int mthca_QUERY_DDR(struct mthca_dev *dev)
 {
        struct mthca_mailbox *mailbox;
        u8 info;
@@ -922,7 +953,7 @@ int mthca_QUERY_DDR(struct mthca_dev *dev, u8 *status)
        outbox = mailbox->buf;
 
        err = mthca_cmd_box(dev, 0, mailbox->dma, 0, 0, CMD_QUERY_DDR,
-                           CMD_TIME_CLASS_A, status);
+                           CMD_TIME_CLASS_A);
 
        if (err)
                goto out;
@@ -952,7 +983,7 @@ out:
 }
 
 int mthca_QUERY_DEV_LIM(struct mthca_dev *dev,
-                       struct mthca_dev_lim *dev_lim, u8 *status)
+                       struct mthca_dev_lim *dev_lim)
 {
        struct mthca_mailbox *mailbox;
        u32 *outbox;
@@ -1028,7 +1059,7 @@ int mthca_QUERY_DEV_LIM(struct mthca_dev *dev,
        outbox = mailbox->buf;
 
        err = mthca_cmd_box(dev, 0, mailbox->dma, 0, 0, CMD_QUERY_DEV_LIM,
-                           CMD_TIME_CLASS_A, status);
+                           CMD_TIME_CLASS_A);
 
        if (err)
                goto out;
@@ -1232,7 +1263,7 @@ static void get_board_id(void *vsd, char *board_id)
 }
 
 int mthca_QUERY_ADAPTER(struct mthca_dev *dev,
-                       struct mthca_adapter *adapter, u8 *status)
+                       struct mthca_adapter *adapter)
 {
        struct mthca_mailbox *mailbox;
        u32 *outbox;
@@ -1251,7 +1282,7 @@ int mthca_QUERY_ADAPTER(struct mthca_dev *dev,
        outbox = mailbox->buf;
 
        err = mthca_cmd_box(dev, 0, mailbox->dma, 0, 0, CMD_QUERY_ADAPTER,
-                           CMD_TIME_CLASS_A, status);
+                           CMD_TIME_CLASS_A);
 
        if (err)
                goto out;
@@ -1275,8 +1306,7 @@ out:
 }
 
 int mthca_INIT_HCA(struct mthca_dev *dev,
-                  struct mthca_init_hca_param *param,
-                  u8 *status)
+                  struct mthca_init_hca_param *param)
 {
        struct mthca_mailbox *mailbox;
        __be32 *inbox;
@@ -1393,7 +1423,8 @@ int mthca_INIT_HCA(struct mthca_dev *dev,
                MTHCA_PUT(inbox, param->uarc_base,   INIT_HCA_UAR_CTX_BASE_OFFSET);
        }
 
-       err = mthca_cmd(dev, mailbox->dma, 0, 0, CMD_INIT_HCA, CMD_TIME_CLASS_D, status);
+       err = mthca_cmd(dev, mailbox->dma, 0, 0,
+                       CMD_INIT_HCA, CMD_TIME_CLASS_D);
 
        mthca_free_mailbox(dev, mailbox);
        return err;
@@ -1401,7 +1432,7 @@ int mthca_INIT_HCA(struct mthca_dev *dev,
 
 int mthca_INIT_IB(struct mthca_dev *dev,
                  struct mthca_init_ib_param *param,
-                 int port, u8 *status)
+                 int port)
 {
        struct mthca_mailbox *mailbox;
        u32 *inbox;
@@ -1445,24 +1476,24 @@ int mthca_INIT_IB(struct mthca_dev *dev,
        MTHCA_PUT(inbox, param->si_guid,   INIT_IB_SI_GUID_OFFSET);
 
        err = mthca_cmd(dev, mailbox->dma, port, 0, CMD_INIT_IB,
-                       CMD_TIME_CLASS_A, status);
+                       CMD_TIME_CLASS_A);
 
        mthca_free_mailbox(dev, mailbox);
        return err;
 }
 
-int mthca_CLOSE_IB(struct mthca_dev *dev, int port, u8 *status)
+int mthca_CLOSE_IB(struct mthca_dev *dev, int port)
 {
-       return mthca_cmd(dev, 0, port, 0, CMD_CLOSE_IB, CMD_TIME_CLASS_A, status);
+       return mthca_cmd(dev, 0, port, 0, CMD_CLOSE_IB, CMD_TIME_CLASS_A);
 }
 
-int mthca_CLOSE_HCA(struct mthca_dev *dev, int panic, u8 *status)
+int mthca_CLOSE_HCA(struct mthca_dev *dev, int panic)
 {
-       return mthca_cmd(dev, 0, 0, panic, CMD_CLOSE_HCA, CMD_TIME_CLASS_C, status);
+       return mthca_cmd(dev, 0, 0, panic, CMD_CLOSE_HCA, CMD_TIME_CLASS_C);
 }
 
 int mthca_SET_IB(struct mthca_dev *dev, struct mthca_set_ib_param *param,
-                int port, u8 *status)
+                int port)
 {
        struct mthca_mailbox *mailbox;
        u32 *inbox;
@@ -1491,18 +1522,18 @@ int mthca_SET_IB(struct mthca_dev *dev, struct mthca_set_ib_param *param,
        MTHCA_PUT(inbox, param->si_guid,  SET_IB_SI_GUID_OFFSET);
 
        err = mthca_cmd(dev, mailbox->dma, port, 0, CMD_SET_IB,
-                       CMD_TIME_CLASS_B, status);
+                       CMD_TIME_CLASS_B);
 
        mthca_free_mailbox(dev, mailbox);
        return err;
 }
 
-int mthca_MAP_ICM(struct mthca_dev *dev, struct mthca_icm *icm, u64 virt, u8 *status)
+int mthca_MAP_ICM(struct mthca_dev *dev, struct mthca_icm *icm, u64 virt)
 {
-       return mthca_map_cmd(dev, CMD_MAP_ICM, icm, virt, status);
+       return mthca_map_cmd(dev, CMD_MAP_ICM, icm, virt);
 }
 
-int mthca_MAP_ICM_page(struct mthca_dev *dev, u64 dma_addr, u64 virt, u8 *status)
+int mthca_MAP_ICM_page(struct mthca_dev *dev, u64 dma_addr, u64 virt)
 {
        struct mthca_mailbox *mailbox;
        __be64 *inbox;
@@ -1517,7 +1548,7 @@ int mthca_MAP_ICM_page(struct mthca_dev *dev, u64 dma_addr, u64 virt, u8 *status
        inbox[1] = cpu_to_be64(dma_addr);
 
        err = mthca_cmd(dev, mailbox->dma, 1, 0, CMD_MAP_ICM,
-                       CMD_TIME_CLASS_B, status);
+                       CMD_TIME_CLASS_B);
 
        mthca_free_mailbox(dev, mailbox);
 
@@ -1528,31 +1559,31 @@ int mthca_MAP_ICM_page(struct mthca_dev *dev, u64 dma_addr, u64 virt, u8 *status
        return err;
 }
 
-int mthca_UNMAP_ICM(struct mthca_dev *dev, u64 virt, u32 page_count, u8 *status)
+int mthca_UNMAP_ICM(struct mthca_dev *dev, u64 virt, u32 page_count)
 {
        mthca_dbg(dev, "Unmapping %d pages at %llx from ICM.\n",
                  page_count, (unsigned long long) virt);
 
-       return mthca_cmd(dev, virt, page_count, 0, CMD_UNMAP_ICM, CMD_TIME_CLASS_B, status);
+       return mthca_cmd(dev, virt, page_count, 0,
+                       CMD_UNMAP_ICM, CMD_TIME_CLASS_B);
 }
 
-int mthca_MAP_ICM_AUX(struct mthca_dev *dev, struct mthca_icm *icm, u8 *status)
+int mthca_MAP_ICM_AUX(struct mthca_dev *dev, struct mthca_icm *icm)
 {
-       return mthca_map_cmd(dev, CMD_MAP_ICM_AUX, icm, -1, status);
+       return mthca_map_cmd(dev, CMD_MAP_ICM_AUX, icm, -1);
 }
 
-int mthca_UNMAP_ICM_AUX(struct mthca_dev *dev, u8 *status)
+int mthca_UNMAP_ICM_AUX(struct mthca_dev *dev)
 {
-       return mthca_cmd(dev, 0, 0, 0, CMD_UNMAP_ICM_AUX, CMD_TIME_CLASS_B, status);
+       return mthca_cmd(dev, 0, 0, 0, CMD_UNMAP_ICM_AUX, CMD_TIME_CLASS_B);
 }
 
-int mthca_SET_ICM_SIZE(struct mthca_dev *dev, u64 icm_size, u64 *aux_pages,
-                      u8 *status)
+int mthca_SET_ICM_SIZE(struct mthca_dev *dev, u64 icm_size, u64 *aux_pages)
 {
-       int ret = mthca_cmd_imm(dev, icm_size, aux_pages, 0, 0, CMD_SET_ICM_SIZE,
-                               CMD_TIME_CLASS_A, status);
+       int ret = mthca_cmd_imm(dev, icm_size, aux_pages, 0,
+                       0, CMD_SET_ICM_SIZE, CMD_TIME_CLASS_A);
 
-       if (ret || status)
+       if (ret)
                return ret;
 
        /*
@@ -1566,74 +1597,73 @@ int mthca_SET_ICM_SIZE(struct mthca_dev *dev, u64 icm_size, u64 *aux_pages,
 }
 
 int mthca_SW2HW_MPT(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                   int mpt_index, u8 *status)
+                   int mpt_index)
 {
        return mthca_cmd(dev, mailbox->dma, mpt_index, 0, CMD_SW2HW_MPT,
-                        CMD_TIME_CLASS_B, status);
+                        CMD_TIME_CLASS_B);
 }
 
 int mthca_HW2SW_MPT(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                   int mpt_index, u8 *status)
+                   int mpt_index)
 {
        return mthca_cmd_box(dev, 0, mailbox ? mailbox->dma : 0, mpt_index,
                             !mailbox, CMD_HW2SW_MPT,
-                            CMD_TIME_CLASS_B, status);
+                            CMD_TIME_CLASS_B);
 }
 
 int mthca_WRITE_MTT(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                   int num_mtt, u8 *status)
+                   int num_mtt)
 {
        return mthca_cmd(dev, mailbox->dma, num_mtt, 0, CMD_WRITE_MTT,
-                        CMD_TIME_CLASS_B, status);
+                        CMD_TIME_CLASS_B);
 }
 
-int mthca_SYNC_TPT(struct mthca_dev *dev, u8 *status)
+int mthca_SYNC_TPT(struct mthca_dev *dev)
 {
-       return mthca_cmd(dev, 0, 0, 0, CMD_SYNC_TPT, CMD_TIME_CLASS_B, status);
+       return mthca_cmd(dev, 0, 0, 0, CMD_SYNC_TPT, CMD_TIME_CLASS_B);
 }
 
 int mthca_MAP_EQ(struct mthca_dev *dev, u64 event_mask, int unmap,
-                int eq_num, u8 *status)
+                int eq_num)
 {
        mthca_dbg(dev, "%s mask %016llx for eqn %d\n",
                  unmap ? "Clearing" : "Setting",
                  (unsigned long long) event_mask, eq_num);
        return mthca_cmd(dev, event_mask, (unmap << 31) | eq_num,
-                        0, CMD_MAP_EQ, CMD_TIME_CLASS_B, status);
+                        0, CMD_MAP_EQ, CMD_TIME_CLASS_B);
 }
 
 int mthca_SW2HW_EQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                  int eq_num, u8 *status)
+                  int eq_num)
 {
        return mthca_cmd(dev, mailbox->dma, eq_num, 0, CMD_SW2HW_EQ,
-                        CMD_TIME_CLASS_A, status);
+                        CMD_TIME_CLASS_A);
 }
 
 int mthca_HW2SW_EQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                  int eq_num, u8 *status)
+                  int eq_num)
 {
        return mthca_cmd_box(dev, 0, mailbox->dma, eq_num, 0,
                             CMD_HW2SW_EQ,
-                            CMD_TIME_CLASS_A, status);
+                            CMD_TIME_CLASS_A);
 }
 
 int mthca_SW2HW_CQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                  int cq_num, u8 *status)
+                  int cq_num)
 {
        return mthca_cmd(dev, mailbox->dma, cq_num, 0, CMD_SW2HW_CQ,
-                       CMD_TIME_CLASS_A, status);
+                       CMD_TIME_CLASS_A);
 }
 
 int mthca_HW2SW_CQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                  int cq_num, u8 *status)
+                  int cq_num)
 {
        return mthca_cmd_box(dev, 0, mailbox->dma, cq_num, 0,
                             CMD_HW2SW_CQ,
-                            CMD_TIME_CLASS_A, status);
+                            CMD_TIME_CLASS_A);
 }
 
-int mthca_RESIZE_CQ(struct mthca_dev *dev, int cq_num, u32 lkey, u8 log_size,
-                   u8 *status)
+int mthca_RESIZE_CQ(struct mthca_dev *dev, int cq_num, u32 lkey, u8 log_size)
 {
        struct mthca_mailbox *mailbox;
        __be32 *inbox;
@@ -1657,44 +1687,43 @@ int mthca_RESIZE_CQ(struct mthca_dev *dev, int cq_num, u32 lkey, u8 log_size,
        MTHCA_PUT(inbox, lkey,     RESIZE_CQ_LKEY_OFFSET);
 
        err = mthca_cmd(dev, mailbox->dma, cq_num, 1, CMD_RESIZE_CQ,
-                       CMD_TIME_CLASS_B, status);
+                       CMD_TIME_CLASS_B);
 
        mthca_free_mailbox(dev, mailbox);
        return err;
 }
 
 int mthca_SW2HW_SRQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                   int srq_num, u8 *status)
+                   int srq_num)
 {
        return mthca_cmd(dev, mailbox->dma, srq_num, 0, CMD_SW2HW_SRQ,
-                       CMD_TIME_CLASS_A, status);
+                       CMD_TIME_CLASS_A);
 }
 
 int mthca_HW2SW_SRQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                   int srq_num, u8 *status)
+                   int srq_num)
 {
        return mthca_cmd_box(dev, 0, mailbox->dma, srq_num, 0,
                             CMD_HW2SW_SRQ,
-                            CMD_TIME_CLASS_A, status);
+                            CMD_TIME_CLASS_A);
 }
 
 int mthca_QUERY_SRQ(struct mthca_dev *dev, u32 num,
-                   struct mthca_mailbox *mailbox, u8 *status)
+                   struct mthca_mailbox *mailbox)
 {
        return mthca_cmd_box(dev, 0, mailbox->dma, num, 0,
-                            CMD_QUERY_SRQ, CMD_TIME_CLASS_A, status);
+                            CMD_QUERY_SRQ, CMD_TIME_CLASS_A);
 }
 
-int mthca_ARM_SRQ(struct mthca_dev *dev, int srq_num, int limit, u8 *status)
+int mthca_ARM_SRQ(struct mthca_dev *dev, int srq_num, int limit)
 {
        return mthca_cmd(dev, limit, srq_num, 0, CMD_ARM_SRQ,
-                        CMD_TIME_CLASS_B, status);
+                        CMD_TIME_CLASS_B);
 }
 
 int mthca_MODIFY_QP(struct mthca_dev *dev, enum ib_qp_state cur,
                    enum ib_qp_state next, u32 num, int is_ee,
-                   struct mthca_mailbox *mailbox, u32 optmask,
-                   u8 *status)
+                   struct mthca_mailbox *mailbox, u32 optmask)
 {
        static const u16 op[IB_QPS_ERR + 1][IB_QPS_ERR + 1] = {
                [IB_QPS_RESET] = {
@@ -1755,7 +1784,7 @@ int mthca_MODIFY_QP(struct mthca_dev *dev, enum ib_qp_state cur,
 
                err = mthca_cmd_box(dev, 0, mailbox ? mailbox->dma : 0,
                                    (!!is_ee << 24) | num, op_mod,
-                                   op[cur][next], CMD_TIME_CLASS_C, status);
+                                   op[cur][next], CMD_TIME_CLASS_C);
 
                if (0 && mailbox) {
                        int i;
@@ -1789,21 +1818,20 @@ int mthca_MODIFY_QP(struct mthca_dev *dev, enum ib_qp_state cur,
                }
 
                err = mthca_cmd(dev, mailbox->dma, optmask | (!!is_ee << 24) | num,
-                               op_mod, op[cur][next], CMD_TIME_CLASS_C, status);
+                               op_mod, op[cur][next], CMD_TIME_CLASS_C);
        }
 
        return err;
 }
 
 int mthca_QUERY_QP(struct mthca_dev *dev, u32 num, int is_ee,
-                  struct mthca_mailbox *mailbox, u8 *status)
+                  struct mthca_mailbox *mailbox)
 {
        return mthca_cmd_box(dev, 0, mailbox->dma, (!!is_ee << 24) | num, 0,
-                            CMD_QUERY_QPEE, CMD_TIME_CLASS_A, status);
+                            CMD_QUERY_QPEE, CMD_TIME_CLASS_A);
 }
 
-int mthca_CONF_SPECIAL_QP(struct mthca_dev *dev, int type, u32 qpn,
-                         u8 *status)
+int mthca_CONF_SPECIAL_QP(struct mthca_dev *dev, int type, u32 qpn)
 {
        u8 op_mod;
 
@@ -1825,12 +1853,12 @@ int mthca_CONF_SPECIAL_QP(struct mthca_dev *dev, int type, u32 qpn,
        }
 
        return mthca_cmd(dev, 0, qpn, op_mod, CMD_CONF_SPECIAL_QP,
-                        CMD_TIME_CLASS_B, status);
+                        CMD_TIME_CLASS_B);
 }
 
 int mthca_MAD_IFC(struct mthca_dev *dev, int ignore_mkey, int ignore_bkey,
                  int port, struct ib_wc *in_wc, struct ib_grh *in_grh,
-                 void *in_mad, void *response_mad, u8 *status)
+                 void *in_mad, void *response_mad)
 {
        struct mthca_mailbox *inmailbox, *outmailbox;
        void *inbox;
@@ -1897,9 +1925,9 @@ int mthca_MAD_IFC(struct mthca_dev *dev, int ignore_mkey, int ignore_bkey,
 
        err = mthca_cmd_box(dev, inmailbox->dma, outmailbox->dma,
                            in_modifier, op_modifier,
-                           CMD_MAD_IFC, CMD_TIME_CLASS_C, status);
+                           CMD_MAD_IFC, CMD_TIME_CLASS_C);
 
-       if (!err && !*status)
+       if (!err)
                memcpy(response_mad, outmailbox->buf, 256);
 
        mthca_free_mailbox(dev, inmailbox);
@@ -1908,33 +1936,33 @@ int mthca_MAD_IFC(struct mthca_dev *dev, int ignore_mkey, int ignore_bkey,
 }
 
 int mthca_READ_MGM(struct mthca_dev *dev, int index,
-                  struct mthca_mailbox *mailbox, u8 *status)
+                  struct mthca_mailbox *mailbox)
 {
        return mthca_cmd_box(dev, 0, mailbox->dma, index, 0,
-                            CMD_READ_MGM, CMD_TIME_CLASS_A, status);
+                            CMD_READ_MGM, CMD_TIME_CLASS_A);
 }
 
 int mthca_WRITE_MGM(struct mthca_dev *dev, int index,
-                   struct mthca_mailbox *mailbox, u8 *status)
+                   struct mthca_mailbox *mailbox)
 {
        return mthca_cmd(dev, mailbox->dma, index, 0, CMD_WRITE_MGM,
-                        CMD_TIME_CLASS_A, status);
+                        CMD_TIME_CLASS_A);
 }
 
 int mthca_MGID_HASH(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                   u16 *hash, u8 *status)
+                   u16 *hash)
 {
        u64 imm;
        int err;
 
        err = mthca_cmd_imm(dev, mailbox->dma, &imm, 0, 0, CMD_MGID_HASH,
-                           CMD_TIME_CLASS_A, status);
+                           CMD_TIME_CLASS_A);
 
        *hash = imm;
        return err;
 }
 
-int mthca_NOP(struct mthca_dev *dev, u8 *status)
+int mthca_NOP(struct mthca_dev *dev)
 {
-       return mthca_cmd(dev, 0, 0x1f, 0, CMD_NOP, msecs_to_jiffies(100), status);
+       return mthca_cmd(dev, 0, 0x1f, 0, CMD_NOP, msecs_to_jiffies(100));
 }
index 6efd326..f952244 100644 (file)
@@ -252,79 +252,74 @@ struct mthca_mailbox *mthca_alloc_mailbox(struct mthca_dev *dev,
                                          gfp_t gfp_mask);
 void mthca_free_mailbox(struct mthca_dev *dev, struct mthca_mailbox *mailbox);
 
-int mthca_SYS_EN(struct mthca_dev *dev, u8 *status);
-int mthca_SYS_DIS(struct mthca_dev *dev, u8 *status);
-int mthca_MAP_FA(struct mthca_dev *dev, struct mthca_icm *icm, u8 *status);
-int mthca_UNMAP_FA(struct mthca_dev *dev, u8 *status);
-int mthca_RUN_FW(struct mthca_dev *dev, u8 *status);
-int mthca_QUERY_FW(struct mthca_dev *dev, u8 *status);
-int mthca_ENABLE_LAM(struct mthca_dev *dev, u8 *status);
-int mthca_DISABLE_LAM(struct mthca_dev *dev, u8 *status);
-int mthca_QUERY_DDR(struct mthca_dev *dev, u8 *status);
+int mthca_SYS_EN(struct mthca_dev *dev);
+int mthca_SYS_DIS(struct mthca_dev *dev);
+int mthca_MAP_FA(struct mthca_dev *dev, struct mthca_icm *icm);
+int mthca_UNMAP_FA(struct mthca_dev *dev);
+int mthca_RUN_FW(struct mthca_dev *dev);
+int mthca_QUERY_FW(struct mthca_dev *dev);
+int mthca_ENABLE_LAM(struct mthca_dev *dev);
+int mthca_DISABLE_LAM(struct mthca_dev *dev);
+int mthca_QUERY_DDR(struct mthca_dev *dev);
 int mthca_QUERY_DEV_LIM(struct mthca_dev *dev,
-                       struct mthca_dev_lim *dev_lim, u8 *status);
+                       struct mthca_dev_lim *dev_lim);
 int mthca_QUERY_ADAPTER(struct mthca_dev *dev,
-                       struct mthca_adapter *adapter, u8 *status);
+                       struct mthca_adapter *adapter);
 int mthca_INIT_HCA(struct mthca_dev *dev,
-                  struct mthca_init_hca_param *param,
-                  u8 *status);
+                  struct mthca_init_hca_param *param);
 int mthca_INIT_IB(struct mthca_dev *dev,
                  struct mthca_init_ib_param *param,
-                 int port, u8 *status);
-int mthca_CLOSE_IB(struct mthca_dev *dev, int port, u8 *status);
-int mthca_CLOSE_HCA(struct mthca_dev *dev, int panic, u8 *status);
+                 int port);
+int mthca_CLOSE_IB(struct mthca_dev *dev, int port);
+int mthca_CLOSE_HCA(struct mthca_dev *dev, int panic);
 int mthca_SET_IB(struct mthca_dev *dev, struct mthca_set_ib_param *param,
-                int port, u8 *status);
-int mthca_MAP_ICM(struct mthca_dev *dev, struct mthca_icm *icm, u64 virt, u8 *status);
-int mthca_MAP_ICM_page(struct mthca_dev *dev, u64 dma_addr, u64 virt, u8 *status);
-int mthca_UNMAP_ICM(struct mthca_dev *dev, u64 virt, u32 page_count, u8 *status);
-int mthca_MAP_ICM_AUX(struct mthca_dev *dev, struct mthca_icm *icm, u8 *status);
-int mthca_UNMAP_ICM_AUX(struct mthca_dev *dev, u8 *status);
-int mthca_SET_ICM_SIZE(struct mthca_dev *dev, u64 icm_size, u64 *aux_pages,
-                      u8 *status);
+                int port);
+int mthca_MAP_ICM(struct mthca_dev *dev, struct mthca_icm *icm, u64 virt);
+int mthca_MAP_ICM_page(struct mthca_dev *dev, u64 dma_addr, u64 virt);
+int mthca_UNMAP_ICM(struct mthca_dev *dev, u64 virt, u32 page_count);
+int mthca_MAP_ICM_AUX(struct mthca_dev *dev, struct mthca_icm *icm);
+int mthca_UNMAP_ICM_AUX(struct mthca_dev *dev);
+int mthca_SET_ICM_SIZE(struct mthca_dev *dev, u64 icm_size, u64 *aux_pages);
 int mthca_SW2HW_MPT(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                   int mpt_index, u8 *status);
+                   int mpt_index);
 int mthca_HW2SW_MPT(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                   int mpt_index, u8 *status);
+                   int mpt_index);
 int mthca_WRITE_MTT(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                   int num_mtt, u8 *status);
-int mthca_SYNC_TPT(struct mthca_dev *dev, u8 *status);
+                   int num_mtt);
+int mthca_SYNC_TPT(struct mthca_dev *dev);
 int mthca_MAP_EQ(struct mthca_dev *dev, u64 event_mask, int unmap,
-                int eq_num, u8 *status);
+                int eq_num);
 int mthca_SW2HW_EQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                  int eq_num, u8 *status);
+                  int eq_num);
 int mthca_HW2SW_EQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                  int eq_num, u8 *status);
+                  int eq_num);
 int mthca_SW2HW_CQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                  int cq_num, u8 *status);
+                  int cq_num);
 int mthca_HW2SW_CQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                  int cq_num, u8 *status);
-int mthca_RESIZE_CQ(struct mthca_dev *dev, int cq_num, u32 lkey, u8 log_size,
-                   u8 *status);
+                  int cq_num);
+int mthca_RESIZE_CQ(struct mthca_dev *dev, int cq_num, u32 lkey, u8 log_size);
 int mthca_SW2HW_SRQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                   int srq_num, u8 *status);
+                   int srq_num);
 int mthca_HW2SW_SRQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                   int srq_num, u8 *status);
+                   int srq_num);
 int mthca_QUERY_SRQ(struct mthca_dev *dev, u32 num,
-                   struct mthca_mailbox *mailbox, u8 *status);
-int mthca_ARM_SRQ(struct mthca_dev *dev, int srq_num, int limit, u8 *status);
+                   struct mthca_mailbox *mailbox);
+int mthca_ARM_SRQ(struct mthca_dev *dev, int srq_num, int limit);
 int mthca_MODIFY_QP(struct mthca_dev *dev, enum ib_qp_state cur,
                    enum ib_qp_state next, u32 num, int is_ee,
-                   struct mthca_mailbox *mailbox, u32 optmask,
-                   u8 *status);
+                   struct mthca_mailbox *mailbox, u32 optmask);
 int mthca_QUERY_QP(struct mthca_dev *dev, u32 num, int is_ee,
-                  struct mthca_mailbox *mailbox, u8 *status);
-int mthca_CONF_SPECIAL_QP(struct mthca_dev *dev, int type, u32 qpn,
-                         u8 *status);
+                  struct mthca_mailbox *mailbox);
+int mthca_CONF_SPECIAL_QP(struct mthca_dev *dev, int type, u32 qpn);
 int mthca_MAD_IFC(struct mthca_dev *dev, int ignore_mkey, int ignore_bkey,
                  int port, struct ib_wc *in_wc, struct ib_grh *in_grh,
-                 void *in_mad, void *response_mad, u8 *status);
+                 void *in_mad, void *response_mad);
 int mthca_READ_MGM(struct mthca_dev *dev, int index,
-                  struct mthca_mailbox *mailbox, u8 *status);
+                  struct mthca_mailbox *mailbox);
 int mthca_WRITE_MGM(struct mthca_dev *dev, int index,
-                   struct mthca_mailbox *mailbox, u8 *status);
+                   struct mthca_mailbox *mailbox);
 int mthca_MGID_HASH(struct mthca_dev *dev, struct mthca_mailbox *mailbox,
-                   u16 *hash, u8 *status);
-int mthca_NOP(struct mthca_dev *dev, u8 *status);
+                   u16 *hash);
+int mthca_NOP(struct mthca_dev *dev);
 
 #endif /* MTHCA_CMD_H */
index 18ee3fa..53157b8 100644 (file)
@@ -779,7 +779,6 @@ int mthca_init_cq(struct mthca_dev *dev, int nent,
        struct mthca_mailbox *mailbox;
        struct mthca_cq_context *cq_context;
        int err = -ENOMEM;
-       u8 status;
 
        cq->ibcq.cqe  = nent - 1;
        cq->is_kernel = !ctx;
@@ -847,19 +846,12 @@ int mthca_init_cq(struct mthca_dev *dev, int nent,
                cq_context->state_db = cpu_to_be32(cq->arm_db_index);
        }
 
-       err = mthca_SW2HW_CQ(dev, mailbox, cq->cqn, &status);
+       err = mthca_SW2HW_CQ(dev, mailbox, cq->cqn);
        if (err) {
                mthca_warn(dev, "SW2HW_CQ failed (%d)\n", err);
                goto err_out_free_mr;
        }
 
-       if (status) {
-               mthca_warn(dev, "SW2HW_CQ returned status 0x%02x\n",
-                          status);
-               err = -EINVAL;
-               goto err_out_free_mr;
-       }
-
        spin_lock_irq(&dev->cq_table.lock);
        if (mthca_array_set(&dev->cq_table.cq,
                            cq->cqn & (dev->limits.num_cqs - 1),
@@ -915,7 +907,6 @@ void mthca_free_cq(struct mthca_dev *dev,
 {
        struct mthca_mailbox *mailbox;
        int err;
-       u8 status;
 
        mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
        if (IS_ERR(mailbox)) {
@@ -923,11 +914,9 @@ void mthca_free_cq(struct mthca_dev *dev,
                return;
        }
 
-       err = mthca_HW2SW_CQ(dev, mailbox, cq->cqn, &status);
+       err = mthca_HW2SW_CQ(dev, mailbox, cq->cqn);
        if (err)
                mthca_warn(dev, "HW2SW_CQ failed (%d)\n", err);
-       else if (status)
-               mthca_warn(dev, "HW2SW_CQ returned status 0x%02x\n", status);
 
        if (0) {
                __be32 *ctx = mailbox->buf;
index 76785c6..7c9d35f 100644 (file)
@@ -474,7 +474,6 @@ static int mthca_create_eq(struct mthca_dev *dev,
        struct mthca_eq_context *eq_context;
        int err = -ENOMEM;
        int i;
-       u8 status;
 
        eq->dev  = dev;
        eq->nent = roundup_pow_of_two(max(nent, 2));
@@ -543,15 +542,9 @@ static int mthca_create_eq(struct mthca_dev *dev,
        eq_context->intr            = intr;
        eq_context->lkey            = cpu_to_be32(eq->mr.ibmr.lkey);
 
-       err = mthca_SW2HW_EQ(dev, mailbox, eq->eqn, &status);
+       err = mthca_SW2HW_EQ(dev, mailbox, eq->eqn);
        if (err) {
-               mthca_warn(dev, "SW2HW_EQ failed (%d)\n", err);
-               goto err_out_free_mr;
-       }
-       if (status) {
-               mthca_warn(dev, "SW2HW_EQ returned status 0x%02x\n",
-                          status);
-               err = -EINVAL;
+               mthca_warn(dev, "SW2HW_EQ returned %d\n", err);
                goto err_out_free_mr;
        }
 
@@ -597,7 +590,6 @@ static void mthca_free_eq(struct mthca_dev *dev,
 {
        struct mthca_mailbox *mailbox;
        int err;
-       u8 status;
        int npages = (eq->nent * MTHCA_EQ_ENTRY_SIZE + PAGE_SIZE - 1) /
                PAGE_SIZE;
        int i;
@@ -606,11 +598,9 @@ static void mthca_free_eq(struct mthca_dev *dev,
        if (IS_ERR(mailbox))
                return;
 
-       err = mthca_HW2SW_EQ(dev, mailbox, eq->eqn, &status);
+       err = mthca_HW2SW_EQ(dev, mailbox, eq->eqn);
        if (err)
-               mthca_warn(dev, "HW2SW_EQ failed (%d)\n", err);
-       if (status)
-               mthca_warn(dev, "HW2SW_EQ returned status 0x%02x\n", status);
+               mthca_warn(dev, "HW2SW_EQ returned %d\n", err);
 
        dev->eq_table.arm_mask &= ~eq->eqn_mask;
 
@@ -738,7 +728,6 @@ static void mthca_unmap_eq_regs(struct mthca_dev *dev)
 int mthca_map_eq_icm(struct mthca_dev *dev, u64 icm_virt)
 {
        int ret;
-       u8 status;
 
        /*
         * We assume that mapping one page is enough for the whole EQ
@@ -757,9 +746,7 @@ int mthca_map_eq_icm(struct mthca_dev *dev, u64 icm_virt)
                return -ENOMEM;
        }
 
-       ret = mthca_MAP_ICM_page(dev, dev->eq_table.icm_dma, icm_virt, &status);
-       if (!ret && status)
-               ret = -EINVAL;
+       ret = mthca_MAP_ICM_page(dev, dev->eq_table.icm_dma, icm_virt);
        if (ret) {
                pci_unmap_page(dev->pdev, dev->eq_table.icm_dma, PAGE_SIZE,
                               PCI_DMA_BIDIRECTIONAL);
@@ -771,9 +758,7 @@ int mthca_map_eq_icm(struct mthca_dev *dev, u64 icm_virt)
 
 void mthca_unmap_eq_icm(struct mthca_dev *dev)
 {
-       u8 status;
-
-       mthca_UNMAP_ICM(dev, dev->eq_table.icm_virt, 1, &status);
+       mthca_UNMAP_ICM(dev, dev->eq_table.icm_virt, 1);
        pci_unmap_page(dev->pdev, dev->eq_table.icm_dma, PAGE_SIZE,
                       PCI_DMA_BIDIRECTIONAL);
        __free_page(dev->eq_table.icm_page);
@@ -782,7 +767,6 @@ void mthca_unmap_eq_icm(struct mthca_dev *dev)
 int mthca_init_eq_table(struct mthca_dev *dev)
 {
        int err;
-       u8 status;
        u8 intr;
        int i;
 
@@ -864,22 +848,16 @@ int mthca_init_eq_table(struct mthca_dev *dev)
        }
 
        err = mthca_MAP_EQ(dev, async_mask(dev),
-                          0, dev->eq_table.eq[MTHCA_EQ_ASYNC].eqn, &status);
+                          0, dev->eq_table.eq[MTHCA_EQ_ASYNC].eqn);
        if (err)
                mthca_warn(dev, "MAP_EQ for async EQ %d failed (%d)\n",
                           dev->eq_table.eq[MTHCA_EQ_ASYNC].eqn, err);
-       if (status)
-               mthca_warn(dev, "MAP_EQ for async EQ %d returned status 0x%02x\n",
-                          dev->eq_table.eq[MTHCA_EQ_ASYNC].eqn, status);
 
        err = mthca_MAP_EQ(dev, MTHCA_CMD_EVENT_MASK,
-                          0, dev->eq_table.eq[MTHCA_EQ_CMD].eqn, &status);
+                          0, dev->eq_table.eq[MTHCA_EQ_CMD].eqn);
        if (err)
                mthca_warn(dev, "MAP_EQ for cmd EQ %d failed (%d)\n",
                           dev->eq_table.eq[MTHCA_EQ_CMD].eqn, err);
-       if (status)
-               mthca_warn(dev, "MAP_EQ for cmd EQ %d returned status 0x%02x\n",
-                          dev->eq_table.eq[MTHCA_EQ_CMD].eqn, status);
 
        for (i = 0; i < MTHCA_NUM_EQ; ++i)
                if (mthca_is_memfree(dev))
@@ -909,15 +887,14 @@ err_out_free:
 
 void mthca_cleanup_eq_table(struct mthca_dev *dev)
 {
-       u8 status;
        int i;
 
        mthca_free_irqs(dev);
 
        mthca_MAP_EQ(dev, async_mask(dev),
-                    1, dev->eq_table.eq[MTHCA_EQ_ASYNC].eqn, &status);
+                    1, dev->eq_table.eq[MTHCA_EQ_ASYNC].eqn);
        mthca_MAP_EQ(dev, MTHCA_CMD_EVENT_MASK,
-                    1, dev->eq_table.eq[MTHCA_EQ_CMD].eqn, &status);
+                    1, dev->eq_table.eq[MTHCA_EQ_CMD].eqn);
 
        for (i = 0; i < MTHCA_NUM_EQ; ++i)
                mthca_free_eq(dev, &dev->eq_table.eq[i]);
index 03a5953..b6f7f45 100644 (file)
@@ -201,7 +201,6 @@ int mthca_process_mad(struct ib_device *ibdev,
                      struct ib_mad *out_mad)
 {
        int err;
-       u8 status;
        u16 slid = in_wc ? in_wc->slid : be16_to_cpu(IB_LID_PERMISSIVE);
        u16 prev_lid = 0;
        struct ib_port_attr pattr;
@@ -252,17 +251,11 @@ int mthca_process_mad(struct ib_device *ibdev,
        err = mthca_MAD_IFC(to_mdev(ibdev),
                            mad_flags & IB_MAD_IGNORE_MKEY,
                            mad_flags & IB_MAD_IGNORE_BKEY,
-                           port_num, in_wc, in_grh, in_mad, out_mad,
-                           &status);
-       if (err) {
-               mthca_err(to_mdev(ibdev), "MAD_IFC failed\n");
-               return IB_MAD_RESULT_FAILURE;
-       }
-       if (status == MTHCA_CMD_STAT_BAD_PKT)
+                           port_num, in_wc, in_grh, in_mad, out_mad);
+       if (err == -EBADMSG)
                return IB_MAD_RESULT_SUCCESS;
-       if (status) {
-               mthca_err(to_mdev(ibdev), "MAD_IFC returned status %02x\n",
-                         status);
+       else if (err) {
+               mthca_err(to_mdev(ibdev), "MAD_IFC returned %d\n", err);
                return IB_MAD_RESULT_FAILURE;
        }
 
index f24b79b..f983476 100644 (file)
@@ -165,19 +165,14 @@ static int mthca_tune_pci(struct mthca_dev *mdev)
 static int mthca_dev_lim(struct mthca_dev *mdev, struct mthca_dev_lim *dev_lim)
 {
        int err;
-       u8 status;
 
        mdev->limits.mtt_seg_size = (1 << log_mtts_per_seg) * 8;
-       err = mthca_QUERY_DEV_LIM(mdev, dev_lim, &status);
+       err = mthca_QUERY_DEV_LIM(mdev, dev_lim);
        if (err) {
-               mthca_err(mdev, "QUERY_DEV_LIM command failed, aborting.\n");
+               mthca_err(mdev, "QUERY_DEV_LIM command returned %d"
+                               ", aborting.\n", err);
                return err;
        }
-       if (status) {
-               mthca_err(mdev, "QUERY_DEV_LIM returned status 0x%02x, "
-                         "aborting.\n", status);
-               return -EINVAL;
-       }
        if (dev_lim->min_page_sz > PAGE_SIZE) {
                mthca_err(mdev, "HCA minimum page size of %d bigger than "
                          "kernel PAGE_SIZE of %ld, aborting.\n",
@@ -293,49 +288,32 @@ static int mthca_dev_lim(struct mthca_dev *mdev, struct mthca_dev_lim *dev_lim)
 static int mthca_init_tavor(struct mthca_dev *mdev)
 {
        s64 size;
-       u8 status;
        int err;
        struct mthca_dev_lim        dev_lim;
        struct mthca_profile        profile;
        struct mthca_init_hca_param init_hca;
 
-       err = mthca_SYS_EN(mdev, &status);
+       err = mthca_SYS_EN(mdev);
        if (err) {
-               mthca_err(mdev, "SYS_EN command failed, aborting.\n");
+               mthca_err(mdev, "SYS_EN command returned %d, aborting.\n", err);
                return err;
        }
-       if (status) {
-               mthca_err(mdev, "SYS_EN returned status 0x%02x, "
-                         "aborting.\n", status);
-               return -EINVAL;
-       }
 
-       err = mthca_QUERY_FW(mdev, &status);
+       err = mthca_QUERY_FW(mdev);
        if (err) {
-               mthca_err(mdev, "QUERY_FW command failed, aborting.\n");
-               goto err_disable;
-       }
-       if (status) {
-               mthca_err(mdev, "QUERY_FW returned status 0x%02x, "
-                         "aborting.\n", status);
-               err = -EINVAL;
+               mthca_err(mdev, "QUERY_FW command returned %d,"
+                               " aborting.\n", err);
                goto err_disable;
        }
-       err = mthca_QUERY_DDR(mdev, &status);
+       err = mthca_QUERY_DDR(mdev);
        if (err) {
-               mthca_err(mdev, "QUERY_DDR command failed, aborting.\n");
-               goto err_disable;
-       }
-       if (status) {
-               mthca_err(mdev, "QUERY_DDR returned status 0x%02x, "
-                         "aborting.\n", status);
-               err = -EINVAL;
+               mthca_err(mdev, "QUERY_DDR command returned %d, aborting.\n", err);
                goto err_disable;
        }
 
        err = mthca_dev_lim(mdev, &dev_lim);
        if (err) {
-               mthca_err(mdev, "QUERY_DEV_LIM command failed, aborting.\n");
+               mthca_err(mdev, "QUERY_DEV_LIM command returned %d, aborting.\n", err);
                goto err_disable;
        }
 
@@ -351,29 +329,22 @@ static int mthca_init_tavor(struct mthca_dev *mdev)
                goto err_disable;
        }
 
-       err = mthca_INIT_HCA(mdev, &init_hca, &status);
+       err = mthca_INIT_HCA(mdev, &init_hca);
        if (err) {
-               mthca_err(mdev, "INIT_HCA command failed, aborting.\n");
-               goto err_disable;
-       }
-       if (status) {
-               mthca_err(mdev, "INIT_HCA returned status 0x%02x, "
-                         "aborting.\n", status);
-               err = -EINVAL;
+               mthca_err(mdev, "INIT_HCA command returned %d, aborting.\n", err);
                goto err_disable;
        }
 
        return 0;
 
 err_disable:
-       mthca_SYS_DIS(mdev, &status);
+       mthca_SYS_DIS(mdev);
 
        return err;
 }
 
 static int mthca_load_fw(struct mthca_dev *mdev)
 {
-       u8 status;
        int err;
 
        /* FIXME: use HCA-attached memory for FW if present */
@@ -386,31 +357,21 @@ static int mthca_load_fw(struct mthca_dev *mdev)
                return -ENOMEM;
        }
 
-       err = mthca_MAP_FA(mdev, mdev->fw.arbel.fw_icm, &status);
+       err = mthca_MAP_FA(mdev, mdev->fw.arbel.fw_icm);
        if (err) {
-               mthca_err(mdev, "MAP_FA command failed, aborting.\n");
-               goto err_free;
-       }
-       if (status) {
-               mthca_err(mdev, "MAP_FA returned status 0x%02x, aborting.\n", status);
-               err = -EINVAL;
+               mthca_err(mdev, "MAP_FA command returned %d, aborting.\n", err);
                goto err_free;
        }
-       err = mthca_RUN_FW(mdev, &status);
+       err = mthca_RUN_FW(mdev);
        if (err) {
-               mthca_err(mdev, "RUN_FW command failed, aborting.\n");
-               goto err_unmap_fa;
-       }
-       if (status) {
-               mthca_err(mdev, "RUN_FW returned status 0x%02x, aborting.\n", status);
-               err = -EINVAL;
+               mthca_err(mdev, "RUN_FW command returned %d, aborting.\n", err);
                goto err_unmap_fa;
        }
 
        return 0;
 
 err_unmap_fa:
-       mthca_UNMAP_FA(mdev, &status);
+       mthca_UNMAP_FA(mdev);
 
 err_free:
        mthca_free_icm(mdev, mdev->fw.arbel.fw_icm, 0);
@@ -423,19 +384,13 @@ static int mthca_init_icm(struct mthca_dev *mdev,
                          u64 icm_size)
 {
        u64 aux_pages;
-       u8 status;
        int err;
 
-       err = mthca_SET_ICM_SIZE(mdev, icm_size, &aux_pages, &status);
+       err = mthca_SET_ICM_SIZE(mdev, icm_size, &aux_pages);
        if (err) {
-               mthca_err(mdev, "SET_ICM_SIZE command failed, aborting.\n");
+               mthca_err(mdev, "SET_ICM_SIZE command returned %d, aborting.\n", err);
                return err;
        }
-       if (status) {
-               mthca_err(mdev, "SET_ICM_SIZE returned status 0x%02x, "
-                         "aborting.\n", status);
-               return -EINVAL;
-       }
 
        mthca_dbg(mdev, "%lld KB of HCA context requires %lld KB aux memory.\n",
                  (unsigned long long) icm_size >> 10,
@@ -448,14 +403,9 @@ static int mthca_init_icm(struct mthca_dev *mdev,
                return -ENOMEM;
        }
 
-       err = mthca_MAP_ICM_AUX(mdev, mdev->fw.arbel.aux_icm, &status);
+       err = mthca_MAP_ICM_AUX(mdev, mdev->fw.arbel.aux_icm);
        if (err) {
-               mthca_err(mdev, "MAP_ICM_AUX command failed, aborting.\n");
-               goto err_free_aux;
-       }
-       if (status) {
-               mthca_err(mdev, "MAP_ICM_AUX returned status 0x%02x, aborting.\n", status);
-               err = -EINVAL;
+               mthca_err(mdev, "MAP_ICM_AUX returned %d, aborting.\n", err);
                goto err_free_aux;
        }
 
@@ -596,7 +546,7 @@ err_unmap_eq:
        mthca_unmap_eq_icm(mdev);
 
 err_unmap_aux:
-       mthca_UNMAP_ICM_AUX(mdev, &status);
+       mthca_UNMAP_ICM_AUX(mdev);
 
 err_free_aux:
        mthca_free_icm(mdev, mdev->fw.arbel.aux_icm, 0);
@@ -606,7 +556,6 @@ err_free_aux:
 
 static void mthca_free_icms(struct mthca_dev *mdev)
 {
-       u8 status;
 
        mthca_free_icm_table(mdev, mdev->mcg_table.table);
        if (mdev->mthca_flags & MTHCA_FLAG_SRQ)
@@ -619,7 +568,7 @@ static void mthca_free_icms(struct mthca_dev *mdev)
        mthca_free_icm_table(mdev, mdev->mr_table.mtt_table);
        mthca_unmap_eq_icm(mdev);
 
-       mthca_UNMAP_ICM_AUX(mdev, &status);
+       mthca_UNMAP_ICM_AUX(mdev);
        mthca_free_icm(mdev, mdev->fw.arbel.aux_icm, 0);
 }
 
@@ -629,43 +578,32 @@ static int mthca_init_arbel(struct mthca_dev *mdev)
        struct mthca_profile        profile;
        struct mthca_init_hca_param init_hca;
        s64 icm_size;
-       u8 status;
        int err;
 
-       err = mthca_QUERY_FW(mdev, &status);
+       err = mthca_QUERY_FW(mdev);
        if (err) {
-               mthca_err(mdev, "QUERY_FW command failed, aborting.\n");
+               mthca_err(mdev, "QUERY_FW command failed %d, aborting.\n", err);
                return err;
        }
-       if (status) {
-               mthca_err(mdev, "QUERY_FW returned status 0x%02x, "
-                         "aborting.\n", status);
-               return -EINVAL;
-       }
 
-       err = mthca_ENABLE_LAM(mdev, &status);
-       if (err) {
-               mthca_err(mdev, "ENABLE_LAM command failed, aborting.\n");
-               return err;
-       }
-       if (status == MTHCA_CMD_STAT_LAM_NOT_PRE) {
+       err = mthca_ENABLE_LAM(mdev);
+       if (err == -EAGAIN) {
                mthca_dbg(mdev, "No HCA-attached memory (running in MemFree mode)\n");
                mdev->mthca_flags |= MTHCA_FLAG_NO_LAM;
-       } else if (status) {
-               mthca_err(mdev, "ENABLE_LAM returned status 0x%02x, "
-                         "aborting.\n", status);
-               return -EINVAL;
+       } else if (err) {
+               mthca_err(mdev, "ENABLE_LAM returned %d, aborting.\n", err);
+               return err;
        }
 
        err = mthca_load_fw(mdev);
        if (err) {
-               mthca_err(mdev, "Failed to start FW, aborting.\n");
+               mthca_err(mdev, "Loading FW returned %d, aborting.\n", err);
                goto err_disable;
        }
 
        err = mthca_dev_lim(mdev, &dev_lim);
        if (err) {
-               mthca_err(mdev, "QUERY_DEV_LIM command failed, aborting.\n");
+               mthca_err(mdev, "QUERY_DEV_LIM returned %d, aborting.\n", err);
                goto err_stop_fw;
        }
 
@@ -685,15 +623,9 @@ static int mthca_init_arbel(struct mthca_dev *mdev)
        if (err)
                goto err_stop_fw;
 
-       err = mthca_INIT_HCA(mdev, &init_hca, &status);
+       err = mthca_INIT_HCA(mdev, &init_hca);
        if (err) {
-               mthca_err(mdev, "INIT_HCA command failed, aborting.\n");
-               goto err_free_icm;
-       }
-       if (status) {
-               mthca_err(mdev, "INIT_HCA returned status 0x%02x, "
-                         "aborting.\n", status);
-               err = -EINVAL;
+               mthca_err(mdev, "INIT_HCA command returned %d, aborting.\n", err);
                goto err_free_icm;
        }
 
@@ -703,37 +635,34 @@ err_free_icm:
        mthca_free_icms(mdev);
 
 err_stop_fw:
-       mthca_UNMAP_FA(mdev, &status);
+       mthca_UNMAP_FA(mdev);
        mthca_free_icm(mdev, mdev->fw.arbel.fw_icm, 0);
 
 err_disable:
        if (!(mdev->mthca_flags & MTHCA_FLAG_NO_LAM))
-               mthca_DISABLE_LAM(mdev, &status);
+               mthca_DISABLE_LAM(mdev);
 
        return err;
 }
 
 static void mthca_close_hca(struct mthca_dev *mdev)
 {
-       u8 status;
-
-       mthca_CLOSE_HCA(mdev, 0, &status);
+       mthca_CLOSE_HCA(mdev, 0);
 
        if (mthca_is_memfree(mdev)) {
                mthca_free_icms(mdev);
 
-               mthca_UNMAP_FA(mdev, &status);
+               mthca_UNMAP_FA(mdev);
                mthca_free_icm(mdev, mdev->fw.arbel.fw_icm, 0);
 
                if (!(mdev->mthca_flags & MTHCA_FLAG_NO_LAM))
-                       mthca_DISABLE_LAM(mdev, &status);
+                       mthca_DISABLE_LAM(mdev);
        } else
-               mthca_SYS_DIS(mdev, &status);
+               mthca_SYS_DIS(mdev);
 }
 
 static int mthca_init_hca(struct mthca_dev *mdev)
 {
-       u8 status;
        int err;
        struct mthca_adapter adapter;
 
@@ -745,15 +674,9 @@ static int mthca_init_hca(struct mthca_dev *mdev)
        if (err)
                return err;
 
-       err = mthca_QUERY_ADAPTER(mdev, &adapter, &status);
+       err = mthca_QUERY_ADAPTER(mdev, &adapter);
        if (err) {
-               mthca_err(mdev, "QUERY_ADAPTER command failed, aborting.\n");
-               goto err_close;
-       }
-       if (status) {
-               mthca_err(mdev, "QUERY_ADAPTER returned status 0x%02x, "
-                         "aborting.\n", status);
-               err = -EINVAL;
+               mthca_err(mdev, "QUERY_ADAPTER command returned %d, aborting.\n", err);
                goto err_close;
        }
 
@@ -772,7 +695,6 @@ err_close:
 static int mthca_setup_hca(struct mthca_dev *dev)
 {
        int err;
-       u8 status;
 
        MTHCA_INIT_DOORBELL_LOCK(&dev->doorbell_lock);
 
@@ -833,8 +755,8 @@ static int mthca_setup_hca(struct mthca_dev *dev)
                goto err_eq_table_free;
        }
 
-       err = mthca_NOP(dev, &status);
-       if (err || status) {
+       err = mthca_NOP(dev);
+       if (err) {
                if (dev->mthca_flags & MTHCA_FLAG_MSI_X) {
                        mthca_warn(dev, "NOP command failed to generate interrupt "
                                   "(IRQ %d).\n",
@@ -1166,7 +1088,6 @@ err_disable_pdev:
 static void __mthca_remove_one(struct pci_dev *pdev)
 {
        struct mthca_dev *mdev = pci_get_drvdata(pdev);
-       u8 status;
        int p;
 
        if (mdev) {
@@ -1174,7 +1095,7 @@ static void __mthca_remove_one(struct pci_dev *pdev)
                mthca_unregister_device(mdev);
 
                for (p = 1; p <= mdev->limits.num_ports; ++p)
-                       mthca_CLOSE_IB(mdev, p, &status);
+                       mthca_CLOSE_IB(mdev, p);
 
                mthca_cleanup_mcg_table(mdev);
                mthca_cleanup_av_table(mdev);
index 515790a..6304ae8 100644 (file)
@@ -68,7 +68,6 @@ static int find_mgm(struct mthca_dev *dev,
        struct mthca_mgm *mgm = mgm_mailbox->buf;
        u8 *mgid;
        int err;
-       u8 status;
 
        mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
        if (IS_ERR(mailbox))
@@ -77,12 +76,9 @@ static int find_mgm(struct mthca_dev *dev,
 
        memcpy(mgid, gid, 16);
 
-       err = mthca_MGID_HASH(dev, mailbox, hash, &status);
-       if (err)
-               goto out;
-       if (status) {
-               mthca_err(dev, "MGID_HASH returned status %02x\n", status);
-               err = -EINVAL;
+       err = mthca_MGID_HASH(dev, mailbox, hash);
+       if (err) {
+               mthca_err(dev, "MGID_HASH failed (%d)\n", err);
                goto out;
        }
 
@@ -93,12 +89,9 @@ static int find_mgm(struct mthca_dev *dev,
        *prev  = -1;
 
        do {
-               err = mthca_READ_MGM(dev, *index, mgm_mailbox, &status);
-               if (err)
-                       goto out;
-               if (status) {
-                       mthca_err(dev, "READ_MGM returned status %02x\n", status);
-                       err = -EINVAL;
+               err = mthca_READ_MGM(dev, *index, mgm_mailbox);
+               if (err) {
+                       mthca_err(dev, "READ_MGM failed (%d)\n", err);
                        goto out;
                }
 
@@ -134,7 +127,6 @@ int mthca_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
        int link = 0;
        int i;
        int err;
-       u8 status;
 
        mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
        if (IS_ERR(mailbox))
@@ -160,12 +152,9 @@ int mthca_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
                        goto out;
                }
 
-               err = mthca_READ_MGM(dev, index, mailbox, &status);
-               if (err)
-                       goto out;
-               if (status) {
-                       mthca_err(dev, "READ_MGM returned status %02x\n", status);
-                       err = -EINVAL;
+               err = mthca_READ_MGM(dev, index, mailbox);
+               if (err) {
+                       mthca_err(dev, "READ_MGM failed (%d)\n", err);
                        goto out;
                }
                memset(mgm, 0, sizeof *mgm);
@@ -189,11 +178,9 @@ int mthca_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
                goto out;
        }
 
-       err = mthca_WRITE_MGM(dev, index, mailbox, &status);
-       if (err)
-               goto out;
-       if (status) {
-               mthca_err(dev, "WRITE_MGM returned status %02x\n", status);
+       err = mthca_WRITE_MGM(dev, index, mailbox);
+       if (err) {
+               mthca_err(dev, "WRITE_MGM failed %d\n", err);
                err = -EINVAL;
                goto out;
        }
@@ -201,24 +188,17 @@ int mthca_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
        if (!link)
                goto out;
 
-       err = mthca_READ_MGM(dev, prev, mailbox, &status);
-       if (err)
-               goto out;
-       if (status) {
-               mthca_err(dev, "READ_MGM returned status %02x\n", status);
-               err = -EINVAL;
+       err = mthca_READ_MGM(dev, prev, mailbox);
+       if (err) {
+               mthca_err(dev, "READ_MGM failed %d\n", err);
                goto out;
        }
 
        mgm->next_gid_index = cpu_to_be32(index << 6);
 
-       err = mthca_WRITE_MGM(dev, prev, mailbox, &status);
+       err = mthca_WRITE_MGM(dev, prev, mailbox);
        if (err)
-               goto out;
-       if (status) {
-               mthca_err(dev, "WRITE_MGM returned status %02x\n", status);
-               err = -EINVAL;
-       }
+               mthca_err(dev, "WRITE_MGM returned %d\n", err);
 
  out:
        if (err && link && index != -1) {
@@ -240,7 +220,6 @@ int mthca_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
        int prev, index;
        int i, loc;
        int err;
-       u8 status;
 
        mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
        if (IS_ERR(mailbox))
@@ -275,12 +254,9 @@ int mthca_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
        mgm->qp[loc]   = mgm->qp[i - 1];
        mgm->qp[i - 1] = 0;
 
-       err = mthca_WRITE_MGM(dev, index, mailbox, &status);
-       if (err)
-               goto out;
-       if (status) {
-               mthca_err(dev, "WRITE_MGM returned status %02x\n", status);
-               err = -EINVAL;
+       err = mthca_WRITE_MGM(dev, index, mailbox);
+       if (err) {
+               mthca_err(dev, "WRITE_MGM returned %d\n", err);
                goto out;
        }
 
@@ -292,24 +268,17 @@ int mthca_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
                int amgm_index_to_free = be32_to_cpu(mgm->next_gid_index) >> 6;
                if (amgm_index_to_free) {
                        err = mthca_READ_MGM(dev, amgm_index_to_free,
-                                            mailbox, &status);
-                       if (err)
-                               goto out;
-                       if (status) {
-                               mthca_err(dev, "READ_MGM returned status %02x\n",
-                                         status);
-                               err = -EINVAL;
+                                            mailbox);
+                       if (err) {
+                               mthca_err(dev, "READ_MGM returned %d\n", err);
                                goto out;
                        }
                } else
                        memset(mgm->gid, 0, 16);
 
-               err = mthca_WRITE_MGM(dev, index, mailbox, &status);
-               if (err)
-                       goto out;
-               if (status) {
-                       mthca_err(dev, "WRITE_MGM returned status %02x\n", status);
-                       err = -EINVAL;
+               err = mthca_WRITE_MGM(dev, index, mailbox);
+               if (err) {
+                       mthca_err(dev, "WRITE_MGM returned %d\n", err);
                        goto out;
                }
                if (amgm_index_to_free) {
@@ -319,23 +288,17 @@ int mthca_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
        } else {
                /* Remove entry from AMGM */
                int curr_next_index = be32_to_cpu(mgm->next_gid_index) >> 6;
-               err = mthca_READ_MGM(dev, prev, mailbox, &status);
-               if (err)
-                       goto out;
-               if (status) {
-                       mthca_err(dev, "READ_MGM returned status %02x\n", status);
-                       err = -EINVAL;
+               err = mthca_READ_MGM(dev, prev, mailbox);
+               if (err) {
+                       mthca_err(dev, "READ_MGM returned %d\n", err);
                        goto out;
                }
 
                mgm->next_gid_index = cpu_to_be32(curr_next_index << 6);
 
-               err = mthca_WRITE_MGM(dev, prev, mailbox, &status);
-               if (err)
-                       goto out;
-               if (status) {
-                       mthca_err(dev, "WRITE_MGM returned status %02x\n", status);
-                       err = -EINVAL;
+               err = mthca_WRITE_MGM(dev, prev, mailbox);
+               if (err) {
+                       mthca_err(dev, "WRITE_MGM returned %d\n", err);
                        goto out;
                }
                BUG_ON(index < dev->limits.num_mgms);
index 8c2a837..7d2e42d 100644 (file)
@@ -223,7 +223,6 @@ int mthca_table_get(struct mthca_dev *dev, struct mthca_icm_table *table, int ob
 {
        int i = (obj & (table->num_obj - 1)) * table->obj_size / MTHCA_TABLE_CHUNK_SIZE;
        int ret = 0;
-       u8 status;
 
        mutex_lock(&table->mutex);
 
@@ -240,8 +239,8 @@ int mthca_table_get(struct mthca_dev *dev, struct mthca_icm_table *table, int ob
                goto out;
        }
 
-       if (mthca_MAP_ICM(dev, table->icm[i], table->virt + i * MTHCA_TABLE_CHUNK_SIZE,
-                         &status) || status) {
+       if (mthca_MAP_ICM(dev, table->icm[i],
+                         table->virt + i * MTHCA_TABLE_CHUNK_SIZE)) {
                mthca_free_icm(dev, table->icm[i], table->coherent);
                table->icm[i] = NULL;
                ret = -ENOMEM;
@@ -258,7 +257,6 @@ out:
 void mthca_table_put(struct mthca_dev *dev, struct mthca_icm_table *table, int obj)
 {
        int i;
-       u8 status;
 
        if (!mthca_is_memfree(dev))
                return;
@@ -269,8 +267,7 @@ void mthca_table_put(struct mthca_dev *dev, struct mthca_icm_table *table, int o
 
        if (--table->icm[i]->refcount == 0) {
                mthca_UNMAP_ICM(dev, table->virt + i * MTHCA_TABLE_CHUNK_SIZE,
-                               MTHCA_TABLE_CHUNK_SIZE / MTHCA_ICM_PAGE_SIZE,
-                               &status);
+                               MTHCA_TABLE_CHUNK_SIZE / MTHCA_ICM_PAGE_SIZE);
                mthca_free_icm(dev, table->icm[i], table->coherent);
                table->icm[i] = NULL;
        }
@@ -366,7 +363,6 @@ struct mthca_icm_table *mthca_alloc_icm_table(struct mthca_dev *dev,
        int num_icm;
        unsigned chunk_size;
        int i;
-       u8 status;
 
        obj_per_chunk = MTHCA_TABLE_CHUNK_SIZE / obj_size;
        num_icm = DIV_ROUND_UP(nobj, obj_per_chunk);
@@ -396,8 +392,8 @@ struct mthca_icm_table *mthca_alloc_icm_table(struct mthca_dev *dev,
                                                __GFP_NOWARN, use_coherent);
                if (!table->icm[i])
                        goto err;
-               if (mthca_MAP_ICM(dev, table->icm[i], virt + i * MTHCA_TABLE_CHUNK_SIZE,
-                                 &status) || status) {
+               if (mthca_MAP_ICM(dev, table->icm[i],
+                                 virt + i * MTHCA_TABLE_CHUNK_SIZE)) {
                        mthca_free_icm(dev, table->icm[i], table->coherent);
                        table->icm[i] = NULL;
                        goto err;
@@ -416,8 +412,7 @@ err:
        for (i = 0; i < num_icm; ++i)
                if (table->icm[i]) {
                        mthca_UNMAP_ICM(dev, virt + i * MTHCA_TABLE_CHUNK_SIZE,
-                                       MTHCA_TABLE_CHUNK_SIZE / MTHCA_ICM_PAGE_SIZE,
-                                       &status);
+                                       MTHCA_TABLE_CHUNK_SIZE / MTHCA_ICM_PAGE_SIZE);
                        mthca_free_icm(dev, table->icm[i], table->coherent);
                }
 
@@ -429,13 +424,12 @@ err:
 void mthca_free_icm_table(struct mthca_dev *dev, struct mthca_icm_table *table)
 {
        int i;
-       u8 status;
 
        for (i = 0; i < table->num_icm; ++i)
                if (table->icm[i]) {
-                       mthca_UNMAP_ICM(dev, table->virt + i * MTHCA_TABLE_CHUNK_SIZE,
-                                       MTHCA_TABLE_CHUNK_SIZE / MTHCA_ICM_PAGE_SIZE,
-                                       &status);
+                       mthca_UNMAP_ICM(dev,
+                                       table->virt + i * MTHCA_TABLE_CHUNK_SIZE,
+                                       MTHCA_TABLE_CHUNK_SIZE / MTHCA_ICM_PAGE_SIZE);
                        mthca_free_icm(dev, table->icm[i], table->coherent);
                }
 
@@ -454,7 +448,6 @@ int mthca_map_user_db(struct mthca_dev *dev, struct mthca_uar *uar,
 {
        struct page *pages[1];
        int ret = 0;
-       u8 status;
        int i;
 
        if (!mthca_is_memfree(dev))
@@ -494,9 +487,7 @@ int mthca_map_user_db(struct mthca_dev *dev, struct mthca_uar *uar,
        }
 
        ret = mthca_MAP_ICM_page(dev, sg_dma_address(&db_tab->page[i].mem),
-                                mthca_uarc_virt(dev, uar, i), &status);
-       if (!ret && status)
-               ret = -EINVAL;
+                                mthca_uarc_virt(dev, uar, i));
        if (ret) {
                pci_unmap_sg(dev->pdev, &db_tab->page[i].mem, 1, PCI_DMA_TODEVICE);
                put_page(sg_page(&db_tab->page[i].mem));
@@ -557,14 +548,13 @@ void mthca_cleanup_user_db_tab(struct mthca_dev *dev, struct mthca_uar *uar,
                               struct mthca_user_db_table *db_tab)
 {
        int i;
-       u8 status;
 
        if (!mthca_is_memfree(dev))
                return;
 
        for (i = 0; i < dev->uar_table.uarc_size / MTHCA_ICM_PAGE_SIZE; ++i) {
                if (db_tab->page[i].uvirt) {
-                       mthca_UNMAP_ICM(dev, mthca_uarc_virt(dev, uar, i), 1, &status);
+                       mthca_UNMAP_ICM(dev, mthca_uarc_virt(dev, uar, i), 1);
                        pci_unmap_sg(dev->pdev, &db_tab->page[i].mem, 1, PCI_DMA_TODEVICE);
                        put_page(sg_page(&db_tab->page[i].mem));
                }
@@ -581,7 +571,6 @@ int mthca_alloc_db(struct mthca_dev *dev, enum mthca_db_type type,
        int i, j;
        struct mthca_db_page *page;
        int ret = 0;
-       u8 status;
 
        mutex_lock(&dev->db_tab->mutex);
 
@@ -644,9 +633,7 @@ alloc:
        memset(page->db_rec, 0, MTHCA_ICM_PAGE_SIZE);
 
        ret = mthca_MAP_ICM_page(dev, page->mapping,
-                                mthca_uarc_virt(dev, &dev->driver_uar, i), &status);
-       if (!ret && status)
-               ret = -EINVAL;
+                                mthca_uarc_virt(dev, &dev->driver_uar, i));
        if (ret) {
                dma_free_coherent(&dev->pdev->dev, MTHCA_ICM_PAGE_SIZE,
                                  page->db_rec, page->mapping);
@@ -678,7 +665,6 @@ void mthca_free_db(struct mthca_dev *dev, int type, int db_index)
 {
        int i, j;
        struct mthca_db_page *page;
-       u8 status;
 
        i = db_index / MTHCA_DB_REC_PER_PAGE;
        j = db_index % MTHCA_DB_REC_PER_PAGE;
@@ -694,7 +680,7 @@ void mthca_free_db(struct mthca_dev *dev, int type, int db_index)
 
        if (bitmap_empty(page->used, MTHCA_DB_REC_PER_PAGE) &&
            i >= dev->db_tab->max_group1 - 1) {
-               mthca_UNMAP_ICM(dev, mthca_uarc_virt(dev, &dev->driver_uar, i), 1, &status);
+               mthca_UNMAP_ICM(dev, mthca_uarc_virt(dev, &dev->driver_uar, i), 1);
 
                dma_free_coherent(&dev->pdev->dev, MTHCA_ICM_PAGE_SIZE,
                                  page->db_rec, page->mapping);
@@ -745,7 +731,6 @@ int mthca_init_db_tab(struct mthca_dev *dev)
 void mthca_cleanup_db_tab(struct mthca_dev *dev)
 {
        int i;
-       u8 status;
 
        if (!mthca_is_memfree(dev))
                return;
@@ -763,7 +748,7 @@ void mthca_cleanup_db_tab(struct mthca_dev *dev)
                if (!bitmap_empty(dev->db_tab->page[i].used, MTHCA_DB_REC_PER_PAGE))
                        mthca_warn(dev, "Kernel UARC page %d not empty\n", i);
 
-               mthca_UNMAP_ICM(dev, mthca_uarc_virt(dev, &dev->driver_uar, i), 1, &status);
+               mthca_UNMAP_ICM(dev, mthca_uarc_virt(dev, &dev->driver_uar, i), 1);
 
                dma_free_coherent(&dev->pdev->dev, MTHCA_ICM_PAGE_SIZE,
                                  dev->db_tab->page[i].db_rec,
index 44045c8..ab876f9 100644 (file)
@@ -257,7 +257,6 @@ static int __mthca_write_mtt(struct mthca_dev *dev, struct mthca_mtt *mtt,
        struct mthca_mailbox *mailbox;
        __be64 *mtt_entry;
        int err = 0;
-       u8 status;
        int i;
 
        mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
@@ -281,17 +280,11 @@ static int __mthca_write_mtt(struct mthca_dev *dev, struct mthca_mtt *mtt,
                if (i & 1)
                        mtt_entry[i + 2] = 0;
 
-               err = mthca_WRITE_MTT(dev, mailbox, (i + 1) & ~1, &status);
+               err = mthca_WRITE_MTT(dev, mailbox, (i + 1) & ~1);
                if (err) {
                        mthca_warn(dev, "WRITE_MTT failed (%d)\n", err);
                        goto out;
                }
-               if (status) {
-                       mthca_warn(dev, "WRITE_MTT returned status 0x%02x\n",
-                                  status);
-                       err = -EINVAL;
-                       goto out;
-               }
 
                list_len    -= i;
                start_index += i;
@@ -441,7 +434,6 @@ int mthca_mr_alloc(struct mthca_dev *dev, u32 pd, int buffer_size_shift,
        u32 key;
        int i;
        int err;
-       u8 status;
 
        WARN_ON(buffer_size_shift >= 32);
 
@@ -497,16 +489,10 @@ int mthca_mr_alloc(struct mthca_dev *dev, u32 pd, int buffer_size_shift,
        }
 
        err = mthca_SW2HW_MPT(dev, mailbox,
-                             key & (dev->limits.num_mpts - 1),
-                             &status);
+                             key & (dev->limits.num_mpts - 1));
        if (err) {
                mthca_warn(dev, "SW2HW_MPT failed (%d)\n", err);
                goto err_out_mailbox;
-       } else if (status) {
-               mthca_warn(dev, "SW2HW_MPT returned status 0x%02x\n",
-                          status);
-               err = -EINVAL;
-               goto err_out_mailbox;
        }
 
        mthca_free_mailbox(dev, mailbox);
@@ -567,17 +553,12 @@ static void mthca_free_region(struct mthca_dev *dev, u32 lkey)
 void mthca_free_mr(struct mthca_dev *dev, struct mthca_mr *mr)
 {
        int err;
-       u8 status;
 
        err = mthca_HW2SW_MPT(dev, NULL,
                              key_to_hw_index(dev, mr->ibmr.lkey) &
-                             (dev->limits.num_mpts - 1),
-                             &status);
+                             (dev->limits.num_mpts - 1));
        if (err)
                mthca_warn(dev, "HW2SW_MPT failed (%d)\n", err);
-       else if (status)
-               mthca_warn(dev, "HW2SW_MPT returned status 0x%02x\n",
-                          status);
 
        mthca_free_region(dev, mr->ibmr.lkey);
        mthca_free_mtt(dev, mr->mtt);
@@ -590,7 +571,6 @@ int mthca_fmr_alloc(struct mthca_dev *dev, u32 pd,
        struct mthca_mailbox *mailbox;
        u64 mtt_seg;
        u32 key, idx;
-       u8 status;
        int list_len = mr->attr.max_pages;
        int err = -ENOMEM;
        int i;
@@ -672,18 +652,11 @@ int mthca_fmr_alloc(struct mthca_dev *dev, u32 pd,
        }
 
        err = mthca_SW2HW_MPT(dev, mailbox,
-                             key & (dev->limits.num_mpts - 1),
-                             &status);
+                             key & (dev->limits.num_mpts - 1));
        if (err) {
                mthca_warn(dev, "SW2HW_MPT failed (%d)\n", err);
                goto err_out_mailbox_free;
        }
-       if (status) {
-               mthca_warn(dev, "SW2HW_MPT returned status 0x%02x\n",
-                          status);
-               err = -EINVAL;
-               goto err_out_mailbox_free;
-       }
 
        mthca_free_mailbox(dev, mailbox);
        return 0;
index 1e0b4b6..365fe0e 100644 (file)
@@ -63,8 +63,6 @@ static int mthca_query_device(struct ib_device *ibdev,
        int err = -ENOMEM;
        struct mthca_dev *mdev = to_mdev(ibdev);
 
-       u8 status;
-
        in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
        out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
        if (!in_mad || !out_mad)
@@ -78,14 +76,9 @@ static int mthca_query_device(struct ib_device *ibdev,
        in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
 
        err = mthca_MAD_IFC(mdev, 1, 1,
-                           1, NULL, NULL, in_mad, out_mad,
-                           &status);
+                           1, NULL, NULL, in_mad, out_mad);
        if (err)
                goto out;
-       if (status) {
-               err = -EINVAL;
-               goto out;
-       }
 
        props->device_cap_flags    = mdev->device_cap_flags;
        props->vendor_id           = be32_to_cpup((__be32 *) (out_mad->data + 36)) &
@@ -141,7 +134,6 @@ static int mthca_query_port(struct ib_device *ibdev,
        struct ib_smp *in_mad  = NULL;
        struct ib_smp *out_mad = NULL;
        int err = -ENOMEM;
-       u8 status;
 
        in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
        out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
@@ -155,14 +147,9 @@ static int mthca_query_port(struct ib_device *ibdev,
        in_mad->attr_mod = cpu_to_be32(port);
 
        err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
-                           port, NULL, NULL, in_mad, out_mad,
-                           &status);
+                           port, NULL, NULL, in_mad, out_mad);
        if (err)
                goto out;
-       if (status) {
-               err = -EINVAL;
-               goto out;
-       }
 
        props->lid               = be16_to_cpup((__be16 *) (out_mad->data + 16));
        props->lmc               = out_mad->data[34] & 0x7;
@@ -214,7 +201,6 @@ static int mthca_modify_port(struct ib_device *ibdev,
        struct mthca_set_ib_param set_ib;
        struct ib_port_attr attr;
        int err;
-       u8 status;
 
        if (mutex_lock_interruptible(&to_mdev(ibdev)->cap_mask_mutex))
                return -ERESTARTSYS;
@@ -229,14 +215,9 @@ static int mthca_modify_port(struct ib_device *ibdev,
        set_ib.cap_mask = (attr.port_cap_flags | props->set_port_cap_mask) &
                ~props->clr_port_cap_mask;
 
-       err = mthca_SET_IB(to_mdev(ibdev), &set_ib, port, &status);
+       err = mthca_SET_IB(to_mdev(ibdev), &set_ib, port);
        if (err)
                goto out;
-       if (status) {
-               err = -EINVAL;
-               goto out;
-       }
-
 out:
        mutex_unlock(&to_mdev(ibdev)->cap_mask_mutex);
        return err;
@@ -248,7 +229,6 @@ static int mthca_query_pkey(struct ib_device *ibdev,
        struct ib_smp *in_mad  = NULL;
        struct ib_smp *out_mad = NULL;
        int err = -ENOMEM;
-       u8 status;
 
        in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
        out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
@@ -260,14 +240,9 @@ static int mthca_query_pkey(struct ib_device *ibdev,
        in_mad->attr_mod = cpu_to_be32(index / 32);
 
        err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
-                           port, NULL, NULL, in_mad, out_mad,
-                           &status);
+                           port, NULL, NULL, in_mad, out_mad);
        if (err)
                goto out;
-       if (status) {
-               err = -EINVAL;
-               goto out;
-       }
 
        *pkey = be16_to_cpu(((__be16 *) out_mad->data)[index % 32]);
 
@@ -283,7 +258,6 @@ static int mthca_query_gid(struct ib_device *ibdev, u8 port,
        struct ib_smp *in_mad  = NULL;
        struct ib_smp *out_mad = NULL;
        int err = -ENOMEM;
-       u8 status;
 
        in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
        out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
@@ -295,14 +269,9 @@ static int mthca_query_gid(struct ib_device *ibdev, u8 port,
        in_mad->attr_mod = cpu_to_be32(port);
 
        err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
-                           port, NULL, NULL, in_mad, out_mad,
-                           &status);
+                           port, NULL, NULL, in_mad, out_mad);
        if (err)
                goto out;
-       if (status) {
-               err = -EINVAL;
-               goto out;
-       }
 
        memcpy(gid->raw, out_mad->data + 8, 8);
 
@@ -311,14 +280,9 @@ static int mthca_query_gid(struct ib_device *ibdev, u8 port,
        in_mad->attr_mod = cpu_to_be32(index / 8);
 
        err = mthca_MAD_IFC(to_mdev(ibdev), 1, 1,
-                           port, NULL, NULL, in_mad, out_mad,
-                           &status);
+                           port, NULL, NULL, in_mad, out_mad);
        if (err)
                goto out;
-       if (status) {
-               err = -EINVAL;
-               goto out;
-       }
 
        memcpy(gid->raw + 8, out_mad->data + (index % 8) * 8, 8);
 
@@ -800,7 +764,6 @@ static int mthca_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *uda
        struct mthca_cq *cq = to_mcq(ibcq);
        struct mthca_resize_cq ucmd;
        u32 lkey;
-       u8 status;
        int ret;
 
        if (entries < 1 || entries > dev->limits.max_cqes)
@@ -827,9 +790,7 @@ static int mthca_resize_cq(struct ib_cq *ibcq, int entries, struct ib_udata *uda
                lkey = ucmd.lkey;
        }
 
-       ret = mthca_RESIZE_CQ(dev, cq->cqn, lkey, ilog2(entries), &status);
-       if (status)
-               ret = -EINVAL;
+       ret = mthca_RESIZE_CQ(dev, cq->cqn, lkey, ilog2(entries));
 
        if (ret) {
                if (cq->resize_buf) {
@@ -1161,7 +1122,6 @@ static int mthca_unmap_fmr(struct list_head *fmr_list)
 {
        struct ib_fmr *fmr;
        int err;
-       u8 status;
        struct mthca_dev *mdev = NULL;
 
        list_for_each_entry(fmr, fmr_list, list) {
@@ -1182,12 +1142,8 @@ static int mthca_unmap_fmr(struct list_head *fmr_list)
                list_for_each_entry(fmr, fmr_list, list)
                        mthca_tavor_fmr_unmap(mdev, to_mfmr(fmr));
 
-       err = mthca_SYNC_TPT(mdev, &status);
-       if (err)
-               return err;
-       if (status)
-               return -EINVAL;
-       return 0;
+       err = mthca_SYNC_TPT(mdev);
+       return err;
 }
 
 static ssize_t show_rev(struct device *device, struct device_attribute *attr,
@@ -1253,7 +1209,6 @@ static int mthca_init_node_data(struct mthca_dev *dev)
        struct ib_smp *in_mad  = NULL;
        struct ib_smp *out_mad = NULL;
        int err = -ENOMEM;
-       u8 status;
 
        in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
        out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
@@ -1264,28 +1219,18 @@ static int mthca_init_node_data(struct mthca_dev *dev)
        in_mad->attr_id = IB_SMP_ATTR_NODE_DESC;
 
        err = mthca_MAD_IFC(dev, 1, 1,
-                           1, NULL, NULL, in_mad, out_mad,
-                           &status);
+                           1, NULL, NULL, in_mad, out_mad);
        if (err)
                goto out;
-       if (status) {
-               err = -EINVAL;
-               goto out;
-       }
 
        memcpy(dev->ib_dev.node_desc, out_mad->data, 64);
 
        in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
 
        err = mthca_MAD_IFC(dev, 1, 1,
-                           1, NULL, NULL, in_mad, out_mad,
-                           &status);
+                           1, NULL, NULL, in_mad, out_mad);
        if (err)
                goto out;
-       if (status) {
-               err = -EINVAL;
-               goto out;
-       }
 
        if (mthca_is_memfree(dev))
                dev->rev_id = be32_to_cpup((__be32 *) (out_mad->data + 32));
index a34c9d3..9601049 100644 (file)
@@ -308,7 +308,6 @@ static void store_attrs(struct mthca_sqp *sqp, const struct ib_qp_attr *attr,
 static void init_port(struct mthca_dev *dev, int port)
 {
        int err;
-       u8 status;
        struct mthca_init_ib_param param;
 
        memset(&param, 0, sizeof param);
@@ -319,11 +318,9 @@ static void init_port(struct mthca_dev *dev, int port)
        param.gid_cap    = dev->limits.gid_table_len;
        param.pkey_cap   = dev->limits.pkey_table_len;
 
-       err = mthca_INIT_IB(dev, &param, port, &status);
+       err = mthca_INIT_IB(dev, &param, port);
        if (err)
                mthca_warn(dev, "INIT_IB failed, return code %d.\n", err);
-       if (status)
-               mthca_warn(dev, "INIT_IB returned status %02x.\n", status);
 }
 
 static __be32 get_hw_access_flags(struct mthca_qp *qp, const struct ib_qp_attr *attr,
@@ -433,7 +430,6 @@ int mthca_query_qp(struct ib_qp *ibqp, struct ib_qp_attr *qp_attr, int qp_attr_m
        struct mthca_qp_param *qp_param;
        struct mthca_qp_context *context;
        int mthca_state;
-       u8 status;
 
        mutex_lock(&qp->mutex);
 
@@ -448,12 +444,9 @@ int mthca_query_qp(struct ib_qp *ibqp, struct ib_qp_attr *qp_attr, int qp_attr_m
                goto out;
        }
 
-       err = mthca_QUERY_QP(dev, qp->qpn, 0, mailbox, &status);
-       if (err)
-               goto out_mailbox;
-       if (status) {
-               mthca_warn(dev, "QUERY_QP returned status %02x\n", status);
-               err = -EINVAL;
+       err = mthca_QUERY_QP(dev, qp->qpn, 0, mailbox);
+       if (err) {
+               mthca_warn(dev, "QUERY_QP failed (%d)\n", err);
                goto out_mailbox;
        }
 
@@ -555,7 +548,6 @@ static int __mthca_modify_qp(struct ib_qp *ibqp,
        struct mthca_qp_param *qp_param;
        struct mthca_qp_context *qp_context;
        u32 sqd_event = 0;
-       u8 status;
        int err = -EINVAL;
 
        mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
@@ -781,13 +773,10 @@ static int __mthca_modify_qp(struct ib_qp *ibqp,
                sqd_event = 1 << 31;
 
        err = mthca_MODIFY_QP(dev, cur_state, new_state, qp->qpn, 0,
-                             mailbox, sqd_event, &status);
-       if (err)
-               goto out_mailbox;
-       if (status) {
-               mthca_warn(dev, "modify QP %d->%d returned status %02x.\n",
-                          cur_state, new_state, status);
-               err = -EINVAL;
+                             mailbox, sqd_event);
+       if (err) {
+               mthca_warn(dev, "modify QP %d->%d returned %d.\n",
+                          cur_state, new_state, err);
                goto out_mailbox;
        }
 
@@ -817,7 +806,7 @@ static int __mthca_modify_qp(struct ib_qp *ibqp,
                    cur_state != IB_QPS_ERR &&
                    (new_state == IB_QPS_RESET ||
                     new_state == IB_QPS_ERR))
-                       mthca_CLOSE_IB(dev, qp->port, &status);
+                       mthca_CLOSE_IB(dev, qp->port);
        }
 
        /*
@@ -1429,7 +1418,6 @@ static inline int get_qp_refcount(struct mthca_dev *dev, struct mthca_qp *qp)
 void mthca_free_qp(struct mthca_dev *dev,
                   struct mthca_qp *qp)
 {
-       u8 status;
        struct mthca_cq *send_cq;
        struct mthca_cq *recv_cq;
 
@@ -1454,7 +1442,7 @@ void mthca_free_qp(struct mthca_dev *dev,
 
        if (qp->state != IB_QPS_RESET)
                mthca_MODIFY_QP(dev, qp->state, IB_QPS_RESET, qp->qpn, 0,
-                               NULL, 0, &status);
+                               NULL, 0);
 
        /*
         * If this is a userspace QP, the buffers, MR, CQs and so on
@@ -2263,7 +2251,6 @@ void mthca_free_err_wqe(struct mthca_dev *dev, struct mthca_qp *qp, int is_send,
 int mthca_init_qp_table(struct mthca_dev *dev)
 {
        int err;
-       u8 status;
        int i;
 
        spin_lock_init(&dev->qp_table.lock);
@@ -2290,15 +2277,10 @@ int mthca_init_qp_table(struct mthca_dev *dev)
 
        for (i = 0; i < 2; ++i) {
                err = mthca_CONF_SPECIAL_QP(dev, i ? IB_QPT_GSI : IB_QPT_SMI,
-                                           dev->qp_table.sqp_start + i * 2,
-                                           &status);
-               if (err)
-                       goto err_out;
-               if (status) {
+                                   dev->qp_table.sqp_start + i * 2);
+               if (err) {
                        mthca_warn(dev, "CONF_SPECIAL_QP returned "
-                                  "status %02x, aborting.\n",
-                                  status);
-                       err = -EINVAL;
+                                  "%d, aborting.\n", err);
                        goto err_out;
                }
        }
@@ -2306,7 +2288,7 @@ int mthca_init_qp_table(struct mthca_dev *dev)
 
  err_out:
        for (i = 0; i < 2; ++i)
-               mthca_CONF_SPECIAL_QP(dev, i, 0, &status);
+               mthca_CONF_SPECIAL_QP(dev, i, 0);
 
        mthca_array_cleanup(&dev->qp_table.qp, dev->limits.num_qps);
        mthca_alloc_cleanup(&dev->qp_table.alloc);
@@ -2317,10 +2299,9 @@ int mthca_init_qp_table(struct mthca_dev *dev)
 void mthca_cleanup_qp_table(struct mthca_dev *dev)
 {
        int i;
-       u8 status;
 
        for (i = 0; i < 2; ++i)
-               mthca_CONF_SPECIAL_QP(dev, i, 0, &status);
+               mthca_CONF_SPECIAL_QP(dev, i, 0);
 
        mthca_array_cleanup(&dev->qp_table.qp, dev->limits.num_qps);
        mthca_alloc_cleanup(&dev->qp_table.alloc);
index 4fabe62..d22f970 100644 (file)
@@ -200,7 +200,6 @@ int mthca_alloc_srq(struct mthca_dev *dev, struct mthca_pd *pd,
                    struct ib_srq_attr *attr, struct mthca_srq *srq)
 {
        struct mthca_mailbox *mailbox;
-       u8 status;
        int ds;
        int err;
 
@@ -266,18 +265,12 @@ int mthca_alloc_srq(struct mthca_dev *dev, struct mthca_pd *pd,
        else
                mthca_tavor_init_srq_context(dev, pd, srq, mailbox->buf);
 
-       err = mthca_SW2HW_SRQ(dev, mailbox, srq->srqn, &status);
+       err = mthca_SW2HW_SRQ(dev, mailbox, srq->srqn);
 
        if (err) {
                mthca_warn(dev, "SW2HW_SRQ failed (%d)\n", err);
                goto err_out_free_buf;
        }
-       if (status) {
-               mthca_warn(dev, "SW2HW_SRQ returned status 0x%02x\n",
-                          status);
-               err = -EINVAL;
-               goto err_out_free_buf;
-       }
 
        spin_lock_irq(&dev->srq_table.lock);
        if (mthca_array_set(&dev->srq_table.srq,
@@ -299,11 +292,9 @@ int mthca_alloc_srq(struct mthca_dev *dev, struct mthca_pd *pd,
        return 0;
 
 err_out_free_srq:
-       err = mthca_HW2SW_SRQ(dev, mailbox, srq->srqn, &status);
+       err = mthca_HW2SW_SRQ(dev, mailbox, srq->srqn);
        if (err)
                mthca_warn(dev, "HW2SW_SRQ failed (%d)\n", err);
-       else if (status)
-               mthca_warn(dev, "HW2SW_SRQ returned status 0x%02x\n", status);
 
 err_out_free_buf:
        if (!pd->ibpd.uobject)
@@ -340,7 +331,6 @@ void mthca_free_srq(struct mthca_dev *dev, struct mthca_srq *srq)
 {
        struct mthca_mailbox *mailbox;
        int err;
-       u8 status;
 
        mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
        if (IS_ERR(mailbox)) {
@@ -348,11 +338,9 @@ void mthca_free_srq(struct mthca_dev *dev, struct mthca_srq *srq)
                return;
        }
 
-       err = mthca_HW2SW_SRQ(dev, mailbox, srq->srqn, &status);
+       err = mthca_HW2SW_SRQ(dev, mailbox, srq->srqn);
        if (err)
                mthca_warn(dev, "HW2SW_SRQ failed (%d)\n", err);
-       else if (status)
-               mthca_warn(dev, "HW2SW_SRQ returned status 0x%02x\n", status);
 
        spin_lock_irq(&dev->srq_table.lock);
        mthca_array_clear(&dev->srq_table.srq,
@@ -378,8 +366,7 @@ int mthca_modify_srq(struct ib_srq *ibsrq, struct ib_srq_attr *attr,
 {
        struct mthca_dev *dev = to_mdev(ibsrq->device);
        struct mthca_srq *srq = to_msrq(ibsrq);
-       int ret;
-       u8 status;
+       int ret = 0;
 
        /* We don't support resizing SRQs (yet?) */
        if (attr_mask & IB_SRQ_MAX_WR)
@@ -391,16 +378,11 @@ int mthca_modify_srq(struct ib_srq *ibsrq, struct ib_srq_attr *attr,
                        return -EINVAL;
 
                mutex_lock(&srq->mutex);
-               ret = mthca_ARM_SRQ(dev, srq->srqn, attr->srq_limit, &status);
+               ret = mthca_ARM_SRQ(dev, srq->srqn, attr->srq_limit);
                mutex_unlock(&srq->mutex);
-
-               if (ret)
-                       return ret;
-               if (status)
-                       return -EINVAL;
        }
 
-       return 0;
+       return ret;
 }
 
 int mthca_query_srq(struct ib_srq *ibsrq, struct ib_srq_attr *srq_attr)
@@ -410,14 +392,13 @@ int mthca_query_srq(struct ib_srq *ibsrq, struct ib_srq_attr *srq_attr)
        struct mthca_mailbox *mailbox;
        struct mthca_arbel_srq_context *arbel_ctx;
        struct mthca_tavor_srq_context *tavor_ctx;
-       u8 status;
        int err;
 
        mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
        if (IS_ERR(mailbox))
                return PTR_ERR(mailbox);
 
-       err = mthca_QUERY_SRQ(dev, srq->srqn, mailbox, &status);
+       err = mthca_QUERY_SRQ(dev, srq->srqn, mailbox);
        if (err)
                goto out;