From d28198c4369a6b334df6da78a1edbb0c6be49d82 Mon Sep 17 00:00:00 2001 From: Mike Marciniszyn Date: Wed, 13 Jul 2011 09:19:10 -0700 Subject: [PATCH] --- yaml --- r: 256659 b: refs/heads/master c: 52a09a040dc258ca9eb4fa6530e52ccdbc72e353 h: refs/heads/master i: 256657: c937dca85dd73659bd7bbc759de228488f58b995 256655: e6de306d178b41acf017c1fa60d27b96f02b5e0a v: v3 --- [refs] | 2 +- trunk/MAINTAINERS | 11 +- trunk/drivers/infiniband/hw/mthca/mthca_cmd.c | 276 ++++++++---------- trunk/drivers/infiniband/hw/mthca/mthca_cmd.h | 93 +++--- trunk/drivers/infiniband/hw/mthca/mthca_cq.c | 15 +- trunk/drivers/infiniband/hw/mthca/mthca_eq.c | 43 ++- trunk/drivers/infiniband/hw/mthca/mthca_mad.c | 15 +- .../drivers/infiniband/hw/mthca/mthca_main.c | 175 ++++++++--- trunk/drivers/infiniband/hw/mthca/mthca_mcg.c | 101 +++++-- .../infiniband/hw/mthca/mthca_memfree.c | 43 ++- trunk/drivers/infiniband/hw/mthca/mthca_mr.c | 35 ++- .../infiniband/hw/mthca/mthca_provider.c | 77 ++++- trunk/drivers/infiniband/hw/mthca/mthca_qp.c | 49 +++- .../drivers/infiniband/hw/mthca/mthca_reset.c | 2 +- trunk/drivers/infiniband/hw/mthca/mthca_srq.c | 33 ++- 15 files changed, 622 insertions(+), 348 deletions(-) diff --git a/[refs] b/[refs] index 9c45bd3d96ee..99b5e7d6a4f8 100644 --- a/[refs] +++ b/[refs] @@ -1,2 +1,2 @@ --- -refs/heads/master: 9b89925c0d8f7d1cc203682df4fab847a7b4b7ec +refs/heads/master: 52a09a040dc258ca9eb4fa6530e52ccdbc72e353 diff --git a/trunk/MAINTAINERS b/trunk/MAINTAINERS index 187282da9213..df90fb5c0860 100644 --- a/trunk/MAINTAINERS +++ b/trunk/MAINTAINERS @@ -3425,10 +3425,9 @@ S: Maintained F: drivers/net/ipg.* IPATH DRIVER -M: Ralph Campbell +M: Mike Marciniszyn L: linux-rdma@vger.kernel.org -T: git git://git.qlogic.com/ipath-linux-2.6 -S: Supported +S: Maintained F: drivers/infiniband/hw/ipath/ IPMI SUBSYSTEM @@ -5152,6 +5151,12 @@ M: Robert Jarzmik L: rtc-linux@googlegroups.com S: Maintained +QIB DRIVER +M: Mike Marciniszyn +L: linux-rdma@vger.kernel.org +S: Supported +F: drivers/infiniband/hw/qib/ + QLOGIC QLA1280 SCSI DRIVER M: Michael Reed L: linux-scsi@vger.kernel.org diff --git a/trunk/drivers/infiniband/hw/mthca/mthca_cmd.c b/trunk/drivers/infiniband/hw/mthca/mthca_cmd.c index 3082b3b3d620..7bfa2a164955 100644 --- a/trunk/drivers/infiniband/hw/mthca/mthca_cmd.c +++ b/trunk/drivers/infiniband/hw/mthca/mthca_cmd.c @@ -301,38 +301,6 @@ 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, @@ -340,11 +308,11 @@ static int mthca_cmd_poll(struct mthca_dev *dev, u32 in_modifier, u8 op_modifier, u16 op, - unsigned long timeout) + unsigned long timeout, + u8 *status) { int err = 0; unsigned long end; - u8 status; down(&dev->cmd.poll_sem); @@ -373,12 +341,7 @@ 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; - if (status) { - mthca_dbg(dev, "Command %02x completed with status %02x\n", - op, status); - err = mthca_status_to_errno(status); - } + *status = be32_to_cpu((__force __be32) __raw_readl(dev->hcr + HCR_STATUS_OFFSET)) >> 24; out: up(&dev->cmd.poll_sem); @@ -411,7 +374,8 @@ static int mthca_cmd_wait(struct mthca_dev *dev, u32 in_modifier, u8 op_modifier, u16 op, - unsigned long timeout) + unsigned long timeout, + u8 *status) { int err = 0; struct mthca_cmd_context *context; @@ -443,11 +407,10 @@ static int mthca_cmd_wait(struct mthca_dev *dev, if (err) goto out; - if (context->status) { + *status = context->status; + if (*status) mthca_dbg(dev, "Command %02x completed with status %02x\n", - op, context->status); - err = mthca_status_to_errno(context->status); - } + op, *status); if (out_is_imm) *out_param = context->out_param; @@ -469,16 +432,17 @@ static int mthca_cmd_box(struct mthca_dev *dev, u32 in_modifier, u8 op_modifier, u16 op, - unsigned long timeout) + unsigned long timeout, + u8 *status) { if (dev->cmd.flags & MTHCA_CMD_USE_EVENTS) return mthca_cmd_wait(dev, in_param, &out_param, 0, in_modifier, op_modifier, op, - timeout); + timeout, status); else return mthca_cmd_poll(dev, in_param, &out_param, 0, in_modifier, op_modifier, op, - timeout); + timeout, status); } /* Invoke a command with no output parameter */ @@ -487,10 +451,11 @@ static int mthca_cmd(struct mthca_dev *dev, u32 in_modifier, u8 op_modifier, u16 op, - unsigned long timeout) + unsigned long timeout, + u8 *status) { return mthca_cmd_box(dev, in_param, 0, in_modifier, - op_modifier, op, timeout); + op_modifier, op, timeout, status); } /* @@ -504,16 +469,17 @@ static int mthca_cmd_imm(struct mthca_dev *dev, u32 in_modifier, u8 op_modifier, u16 op, - unsigned long timeout) + unsigned long timeout, + u8 *status) { if (dev->cmd.flags & MTHCA_CMD_USE_EVENTS) return mthca_cmd_wait(dev, in_param, out_param, 1, in_modifier, op_modifier, op, - timeout); + timeout, status); else return mthca_cmd_poll(dev, in_param, out_param, 1, in_modifier, op_modifier, op, - timeout); + timeout, status); } int mthca_cmd_init(struct mthca_dev *dev) @@ -630,14 +596,14 @@ void mthca_free_mailbox(struct mthca_dev *dev, struct mthca_mailbox *mailbox) kfree(mailbox); } -int mthca_SYS_EN(struct mthca_dev *dev) +int mthca_SYS_EN(struct mthca_dev *dev, u8 *status) { u64 out; int ret; - ret = mthca_cmd_imm(dev, 0, &out, 0, 0, CMD_SYS_EN, CMD_TIME_CLASS_D); + ret = mthca_cmd_imm(dev, 0, &out, 0, 0, CMD_SYS_EN, CMD_TIME_CLASS_D, status); - if (ret == -ENOMEM) + if (*status == MTHCA_CMD_STAT_DDR_MEM_ERR) 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, @@ -646,13 +612,13 @@ int mthca_SYS_EN(struct mthca_dev *dev) return ret; } -int mthca_SYS_DIS(struct mthca_dev *dev) +int mthca_SYS_DIS(struct mthca_dev *dev, u8 *status) { - return mthca_cmd(dev, 0, 0, 0, CMD_SYS_DIS, CMD_TIME_CLASS_C); + return mthca_cmd(dev, 0, 0, 0, CMD_SYS_DIS, CMD_TIME_CLASS_C, status); } static int mthca_map_cmd(struct mthca_dev *dev, u16 op, struct mthca_icm *icm, - u64 virt) + u64 virt, u8 *status) { struct mthca_mailbox *mailbox; struct mthca_icm_iter iter; @@ -700,8 +666,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); - if (err) + CMD_TIME_CLASS_B, status); + if (err || *status) goto out; nent = 0; } @@ -710,7 +676,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); + CMD_TIME_CLASS_B, status); switch (op) { case CMD_MAP_FA: @@ -730,19 +696,19 @@ static int mthca_map_cmd(struct mthca_dev *dev, u16 op, struct mthca_icm *icm, return err; } -int mthca_MAP_FA(struct mthca_dev *dev, struct mthca_icm *icm) +int mthca_MAP_FA(struct mthca_dev *dev, struct mthca_icm *icm, u8 *status) { - return mthca_map_cmd(dev, CMD_MAP_FA, icm, -1); + return mthca_map_cmd(dev, CMD_MAP_FA, icm, -1, status); } -int mthca_UNMAP_FA(struct mthca_dev *dev) +int mthca_UNMAP_FA(struct mthca_dev *dev, u8 *status) { - return mthca_cmd(dev, 0, 0, 0, CMD_UNMAP_FA, CMD_TIME_CLASS_B); + return mthca_cmd(dev, 0, 0, 0, CMD_UNMAP_FA, CMD_TIME_CLASS_B, status); } -int mthca_RUN_FW(struct mthca_dev *dev) +int mthca_RUN_FW(struct mthca_dev *dev, u8 *status) { - return mthca_cmd(dev, 0, 0, 0, CMD_RUN_FW, CMD_TIME_CLASS_A); + return mthca_cmd(dev, 0, 0, 0, CMD_RUN_FW, CMD_TIME_CLASS_A, status); } static void mthca_setup_cmd_doorbells(struct mthca_dev *dev, u64 base) @@ -771,7 +737,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) +int mthca_QUERY_FW(struct mthca_dev *dev, u8 *status) { struct mthca_mailbox *mailbox; u32 *outbox; @@ -805,7 +771,7 @@ int mthca_QUERY_FW(struct mthca_dev *dev) outbox = mailbox->buf; err = mthca_cmd_box(dev, 0, mailbox->dma, 0, 0, CMD_QUERY_FW, - CMD_TIME_CLASS_A); + CMD_TIME_CLASS_A, status); if (err) goto out; @@ -877,7 +843,7 @@ int mthca_QUERY_FW(struct mthca_dev *dev) return err; } -int mthca_ENABLE_LAM(struct mthca_dev *dev) +int mthca_ENABLE_LAM(struct mthca_dev *dev, u8 *status) { struct mthca_mailbox *mailbox; u8 info; @@ -898,11 +864,14 @@ int mthca_ENABLE_LAM(struct mthca_dev *dev) outbox = mailbox->buf; err = mthca_cmd_box(dev, 0, mailbox->dma, 0, 0, CMD_ENABLE_LAM, - CMD_TIME_CLASS_C); + CMD_TIME_CLASS_C, status); 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); @@ -927,12 +896,12 @@ int mthca_ENABLE_LAM(struct mthca_dev *dev) return err; } -int mthca_DISABLE_LAM(struct mthca_dev *dev) +int mthca_DISABLE_LAM(struct mthca_dev *dev, u8 *status) { - return mthca_cmd(dev, 0, 0, 0, CMD_SYS_DIS, CMD_TIME_CLASS_C); + return mthca_cmd(dev, 0, 0, 0, CMD_SYS_DIS, CMD_TIME_CLASS_C, status); } -int mthca_QUERY_DDR(struct mthca_dev *dev) +int mthca_QUERY_DDR(struct mthca_dev *dev, u8 *status) { struct mthca_mailbox *mailbox; u8 info; @@ -953,7 +922,7 @@ int mthca_QUERY_DDR(struct mthca_dev *dev) outbox = mailbox->buf; err = mthca_cmd_box(dev, 0, mailbox->dma, 0, 0, CMD_QUERY_DDR, - CMD_TIME_CLASS_A); + CMD_TIME_CLASS_A, status); if (err) goto out; @@ -983,7 +952,7 @@ int mthca_QUERY_DDR(struct mthca_dev *dev) } int mthca_QUERY_DEV_LIM(struct mthca_dev *dev, - struct mthca_dev_lim *dev_lim) + struct mthca_dev_lim *dev_lim, u8 *status) { struct mthca_mailbox *mailbox; u32 *outbox; @@ -1059,7 +1028,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); + CMD_TIME_CLASS_A, status); if (err) goto out; @@ -1263,7 +1232,7 @@ static void get_board_id(void *vsd, char *board_id) } int mthca_QUERY_ADAPTER(struct mthca_dev *dev, - struct mthca_adapter *adapter) + struct mthca_adapter *adapter, u8 *status) { struct mthca_mailbox *mailbox; u32 *outbox; @@ -1282,7 +1251,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); + CMD_TIME_CLASS_A, status); if (err) goto out; @@ -1306,7 +1275,8 @@ int mthca_QUERY_ADAPTER(struct mthca_dev *dev, } int mthca_INIT_HCA(struct mthca_dev *dev, - struct mthca_init_hca_param *param) + struct mthca_init_hca_param *param, + u8 *status) { struct mthca_mailbox *mailbox; __be32 *inbox; @@ -1423,8 +1393,7 @@ 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); + err = mthca_cmd(dev, mailbox->dma, 0, 0, CMD_INIT_HCA, CMD_TIME_CLASS_D, status); mthca_free_mailbox(dev, mailbox); return err; @@ -1432,7 +1401,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) + int port, u8 *status) { struct mthca_mailbox *mailbox; u32 *inbox; @@ -1476,24 +1445,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); + CMD_TIME_CLASS_A, status); mthca_free_mailbox(dev, mailbox); return err; } -int mthca_CLOSE_IB(struct mthca_dev *dev, int port) +int mthca_CLOSE_IB(struct mthca_dev *dev, int port, u8 *status) { - return mthca_cmd(dev, 0, port, 0, CMD_CLOSE_IB, CMD_TIME_CLASS_A); + return mthca_cmd(dev, 0, port, 0, CMD_CLOSE_IB, CMD_TIME_CLASS_A, status); } -int mthca_CLOSE_HCA(struct mthca_dev *dev, int panic) +int mthca_CLOSE_HCA(struct mthca_dev *dev, int panic, u8 *status) { - return mthca_cmd(dev, 0, 0, panic, CMD_CLOSE_HCA, CMD_TIME_CLASS_C); + return mthca_cmd(dev, 0, 0, panic, CMD_CLOSE_HCA, CMD_TIME_CLASS_C, status); } int mthca_SET_IB(struct mthca_dev *dev, struct mthca_set_ib_param *param, - int port) + int port, u8 *status) { struct mthca_mailbox *mailbox; u32 *inbox; @@ -1522,18 +1491,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); + CMD_TIME_CLASS_B, status); mthca_free_mailbox(dev, mailbox); return err; } -int mthca_MAP_ICM(struct mthca_dev *dev, struct mthca_icm *icm, u64 virt) +int mthca_MAP_ICM(struct mthca_dev *dev, struct mthca_icm *icm, u64 virt, u8 *status) { - return mthca_map_cmd(dev, CMD_MAP_ICM, icm, virt); + return mthca_map_cmd(dev, CMD_MAP_ICM, icm, virt, status); } -int mthca_MAP_ICM_page(struct mthca_dev *dev, u64 dma_addr, u64 virt) +int mthca_MAP_ICM_page(struct mthca_dev *dev, u64 dma_addr, u64 virt, u8 *status) { struct mthca_mailbox *mailbox; __be64 *inbox; @@ -1548,7 +1517,7 @@ int mthca_MAP_ICM_page(struct mthca_dev *dev, u64 dma_addr, u64 virt) inbox[1] = cpu_to_be64(dma_addr); err = mthca_cmd(dev, mailbox->dma, 1, 0, CMD_MAP_ICM, - CMD_TIME_CLASS_B); + CMD_TIME_CLASS_B, status); mthca_free_mailbox(dev, mailbox); @@ -1559,31 +1528,31 @@ int mthca_MAP_ICM_page(struct mthca_dev *dev, u64 dma_addr, u64 virt) return err; } -int mthca_UNMAP_ICM(struct mthca_dev *dev, u64 virt, u32 page_count) +int mthca_UNMAP_ICM(struct mthca_dev *dev, u64 virt, u32 page_count, u8 *status) { 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); + return mthca_cmd(dev, virt, page_count, 0, CMD_UNMAP_ICM, CMD_TIME_CLASS_B, status); } -int mthca_MAP_ICM_AUX(struct mthca_dev *dev, struct mthca_icm *icm) +int mthca_MAP_ICM_AUX(struct mthca_dev *dev, struct mthca_icm *icm, u8 *status) { - return mthca_map_cmd(dev, CMD_MAP_ICM_AUX, icm, -1); + return mthca_map_cmd(dev, CMD_MAP_ICM_AUX, icm, -1, status); } -int mthca_UNMAP_ICM_AUX(struct mthca_dev *dev) +int mthca_UNMAP_ICM_AUX(struct mthca_dev *dev, u8 *status) { - return mthca_cmd(dev, 0, 0, 0, CMD_UNMAP_ICM_AUX, CMD_TIME_CLASS_B); + return mthca_cmd(dev, 0, 0, 0, CMD_UNMAP_ICM_AUX, CMD_TIME_CLASS_B, status); } -int mthca_SET_ICM_SIZE(struct mthca_dev *dev, u64 icm_size, u64 *aux_pages) +int mthca_SET_ICM_SIZE(struct mthca_dev *dev, u64 icm_size, u64 *aux_pages, + u8 *status) { - int ret = mthca_cmd_imm(dev, icm_size, aux_pages, 0, - 0, CMD_SET_ICM_SIZE, CMD_TIME_CLASS_A); + int ret = mthca_cmd_imm(dev, icm_size, aux_pages, 0, 0, CMD_SET_ICM_SIZE, + CMD_TIME_CLASS_A, status); - if (ret) + if (ret || status) return ret; /* @@ -1597,73 +1566,74 @@ 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) + int mpt_index, u8 *status) { return mthca_cmd(dev, mailbox->dma, mpt_index, 0, CMD_SW2HW_MPT, - CMD_TIME_CLASS_B); + CMD_TIME_CLASS_B, status); } int mthca_HW2SW_MPT(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int mpt_index) + int mpt_index, u8 *status) { return mthca_cmd_box(dev, 0, mailbox ? mailbox->dma : 0, mpt_index, !mailbox, CMD_HW2SW_MPT, - CMD_TIME_CLASS_B); + CMD_TIME_CLASS_B, status); } int mthca_WRITE_MTT(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int num_mtt) + int num_mtt, u8 *status) { return mthca_cmd(dev, mailbox->dma, num_mtt, 0, CMD_WRITE_MTT, - CMD_TIME_CLASS_B); + CMD_TIME_CLASS_B, status); } -int mthca_SYNC_TPT(struct mthca_dev *dev) +int mthca_SYNC_TPT(struct mthca_dev *dev, u8 *status) { - return mthca_cmd(dev, 0, 0, 0, CMD_SYNC_TPT, CMD_TIME_CLASS_B); + return mthca_cmd(dev, 0, 0, 0, CMD_SYNC_TPT, CMD_TIME_CLASS_B, status); } int mthca_MAP_EQ(struct mthca_dev *dev, u64 event_mask, int unmap, - int eq_num) + int eq_num, u8 *status) { 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); + 0, CMD_MAP_EQ, CMD_TIME_CLASS_B, status); } int mthca_SW2HW_EQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int eq_num) + int eq_num, u8 *status) { return mthca_cmd(dev, mailbox->dma, eq_num, 0, CMD_SW2HW_EQ, - CMD_TIME_CLASS_A); + CMD_TIME_CLASS_A, status); } int mthca_HW2SW_EQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int eq_num) + int eq_num, u8 *status) { return mthca_cmd_box(dev, 0, mailbox->dma, eq_num, 0, CMD_HW2SW_EQ, - CMD_TIME_CLASS_A); + CMD_TIME_CLASS_A, status); } int mthca_SW2HW_CQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int cq_num) + int cq_num, u8 *status) { return mthca_cmd(dev, mailbox->dma, cq_num, 0, CMD_SW2HW_CQ, - CMD_TIME_CLASS_A); + CMD_TIME_CLASS_A, status); } int mthca_HW2SW_CQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int cq_num) + int cq_num, u8 *status) { return mthca_cmd_box(dev, 0, mailbox->dma, cq_num, 0, CMD_HW2SW_CQ, - CMD_TIME_CLASS_A); + CMD_TIME_CLASS_A, status); } -int mthca_RESIZE_CQ(struct mthca_dev *dev, int cq_num, u32 lkey, u8 log_size) +int mthca_RESIZE_CQ(struct mthca_dev *dev, int cq_num, u32 lkey, u8 log_size, + u8 *status) { struct mthca_mailbox *mailbox; __be32 *inbox; @@ -1687,43 +1657,44 @@ 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); + CMD_TIME_CLASS_B, status); mthca_free_mailbox(dev, mailbox); return err; } int mthca_SW2HW_SRQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int srq_num) + int srq_num, u8 *status) { return mthca_cmd(dev, mailbox->dma, srq_num, 0, CMD_SW2HW_SRQ, - CMD_TIME_CLASS_A); + CMD_TIME_CLASS_A, status); } int mthca_HW2SW_SRQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int srq_num) + int srq_num, u8 *status) { return mthca_cmd_box(dev, 0, mailbox->dma, srq_num, 0, CMD_HW2SW_SRQ, - CMD_TIME_CLASS_A); + CMD_TIME_CLASS_A, status); } int mthca_QUERY_SRQ(struct mthca_dev *dev, u32 num, - struct mthca_mailbox *mailbox) + struct mthca_mailbox *mailbox, u8 *status) { return mthca_cmd_box(dev, 0, mailbox->dma, num, 0, - CMD_QUERY_SRQ, CMD_TIME_CLASS_A); + CMD_QUERY_SRQ, CMD_TIME_CLASS_A, status); } -int mthca_ARM_SRQ(struct mthca_dev *dev, int srq_num, int limit) +int mthca_ARM_SRQ(struct mthca_dev *dev, int srq_num, int limit, u8 *status) { return mthca_cmd(dev, limit, srq_num, 0, CMD_ARM_SRQ, - CMD_TIME_CLASS_B); + CMD_TIME_CLASS_B, status); } 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) + struct mthca_mailbox *mailbox, u32 optmask, + u8 *status) { static const u16 op[IB_QPS_ERR + 1][IB_QPS_ERR + 1] = { [IB_QPS_RESET] = { @@ -1784,7 +1755,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); + op[cur][next], CMD_TIME_CLASS_C, status); if (0 && mailbox) { int i; @@ -1818,20 +1789,21 @@ 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); + op_mod, op[cur][next], CMD_TIME_CLASS_C, status); } return err; } int mthca_QUERY_QP(struct mthca_dev *dev, u32 num, int is_ee, - struct mthca_mailbox *mailbox) + struct mthca_mailbox *mailbox, u8 *status) { return mthca_cmd_box(dev, 0, mailbox->dma, (!!is_ee << 24) | num, 0, - CMD_QUERY_QPEE, CMD_TIME_CLASS_A); + CMD_QUERY_QPEE, CMD_TIME_CLASS_A, status); } -int mthca_CONF_SPECIAL_QP(struct mthca_dev *dev, int type, u32 qpn) +int mthca_CONF_SPECIAL_QP(struct mthca_dev *dev, int type, u32 qpn, + u8 *status) { u8 op_mod; @@ -1853,12 +1825,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); + CMD_TIME_CLASS_B, status); } 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) + void *in_mad, void *response_mad, u8 *status) { struct mthca_mailbox *inmailbox, *outmailbox; void *inbox; @@ -1925,9 +1897,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); + CMD_MAD_IFC, CMD_TIME_CLASS_C, status); - if (!err) + if (!err && !*status) memcpy(response_mad, outmailbox->buf, 256); mthca_free_mailbox(dev, inmailbox); @@ -1936,33 +1908,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) + struct mthca_mailbox *mailbox, u8 *status) { return mthca_cmd_box(dev, 0, mailbox->dma, index, 0, - CMD_READ_MGM, CMD_TIME_CLASS_A); + CMD_READ_MGM, CMD_TIME_CLASS_A, status); } int mthca_WRITE_MGM(struct mthca_dev *dev, int index, - struct mthca_mailbox *mailbox) + struct mthca_mailbox *mailbox, u8 *status) { return mthca_cmd(dev, mailbox->dma, index, 0, CMD_WRITE_MGM, - CMD_TIME_CLASS_A); + CMD_TIME_CLASS_A, status); } int mthca_MGID_HASH(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - u16 *hash) + u16 *hash, u8 *status) { u64 imm; int err; err = mthca_cmd_imm(dev, mailbox->dma, &imm, 0, 0, CMD_MGID_HASH, - CMD_TIME_CLASS_A); + CMD_TIME_CLASS_A, status); *hash = imm; return err; } -int mthca_NOP(struct mthca_dev *dev) +int mthca_NOP(struct mthca_dev *dev, u8 *status) { - return mthca_cmd(dev, 0, 0x1f, 0, CMD_NOP, msecs_to_jiffies(100)); + return mthca_cmd(dev, 0, 0x1f, 0, CMD_NOP, msecs_to_jiffies(100), status); } diff --git a/trunk/drivers/infiniband/hw/mthca/mthca_cmd.h b/trunk/drivers/infiniband/hw/mthca/mthca_cmd.h index f952244c54de..6efd3265f248 100644 --- a/trunk/drivers/infiniband/hw/mthca/mthca_cmd.h +++ b/trunk/drivers/infiniband/hw/mthca/mthca_cmd.h @@ -252,74 +252,79 @@ 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); -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_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_QUERY_DEV_LIM(struct mthca_dev *dev, - struct mthca_dev_lim *dev_lim); + struct mthca_dev_lim *dev_lim, u8 *status); int mthca_QUERY_ADAPTER(struct mthca_dev *dev, - struct mthca_adapter *adapter); + struct mthca_adapter *adapter, u8 *status); int mthca_INIT_HCA(struct mthca_dev *dev, - struct mthca_init_hca_param *param); + struct mthca_init_hca_param *param, + u8 *status); int mthca_INIT_IB(struct mthca_dev *dev, struct mthca_init_ib_param *param, - int port); -int mthca_CLOSE_IB(struct mthca_dev *dev, int port); -int mthca_CLOSE_HCA(struct mthca_dev *dev, int panic); + 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 mthca_SET_IB(struct mthca_dev *dev, struct mthca_set_ib_param *param, - 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 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 mthca_SW2HW_MPT(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int mpt_index); + int mpt_index, u8 *status); int mthca_HW2SW_MPT(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int mpt_index); + int mpt_index, u8 *status); int mthca_WRITE_MTT(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int num_mtt); -int mthca_SYNC_TPT(struct mthca_dev *dev); + int num_mtt, u8 *status); +int mthca_SYNC_TPT(struct mthca_dev *dev, u8 *status); int mthca_MAP_EQ(struct mthca_dev *dev, u64 event_mask, int unmap, - int eq_num); + int eq_num, u8 *status); int mthca_SW2HW_EQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int eq_num); + int eq_num, u8 *status); int mthca_HW2SW_EQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int eq_num); + int eq_num, u8 *status); int mthca_SW2HW_CQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int cq_num); + int cq_num, u8 *status); int mthca_HW2SW_CQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int cq_num); -int mthca_RESIZE_CQ(struct mthca_dev *dev, int cq_num, u32 lkey, u8 log_size); + int cq_num, u8 *status); +int mthca_RESIZE_CQ(struct mthca_dev *dev, int cq_num, u32 lkey, u8 log_size, + u8 *status); int mthca_SW2HW_SRQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int srq_num); + int srq_num, u8 *status); int mthca_HW2SW_SRQ(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - int srq_num); + int srq_num, u8 *status); int mthca_QUERY_SRQ(struct mthca_dev *dev, u32 num, - struct mthca_mailbox *mailbox); -int mthca_ARM_SRQ(struct mthca_dev *dev, int srq_num, int limit); + struct mthca_mailbox *mailbox, u8 *status); +int mthca_ARM_SRQ(struct mthca_dev *dev, int srq_num, int limit, u8 *status); 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); + struct mthca_mailbox *mailbox, u32 optmask, + u8 *status); int mthca_QUERY_QP(struct mthca_dev *dev, u32 num, int is_ee, - struct mthca_mailbox *mailbox); -int mthca_CONF_SPECIAL_QP(struct mthca_dev *dev, int type, u32 qpn); + struct mthca_mailbox *mailbox, u8 *status); +int mthca_CONF_SPECIAL_QP(struct mthca_dev *dev, int type, u32 qpn, + u8 *status); 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); + void *in_mad, void *response_mad, u8 *status); int mthca_READ_MGM(struct mthca_dev *dev, int index, - struct mthca_mailbox *mailbox); + struct mthca_mailbox *mailbox, u8 *status); int mthca_WRITE_MGM(struct mthca_dev *dev, int index, - struct mthca_mailbox *mailbox); + struct mthca_mailbox *mailbox, u8 *status); int mthca_MGID_HASH(struct mthca_dev *dev, struct mthca_mailbox *mailbox, - u16 *hash); -int mthca_NOP(struct mthca_dev *dev); + u16 *hash, u8 *status); +int mthca_NOP(struct mthca_dev *dev, u8 *status); #endif /* MTHCA_CMD_H */ diff --git a/trunk/drivers/infiniband/hw/mthca/mthca_cq.c b/trunk/drivers/infiniband/hw/mthca/mthca_cq.c index 53157b86a1ba..18ee3fa4b88c 100644 --- a/trunk/drivers/infiniband/hw/mthca/mthca_cq.c +++ b/trunk/drivers/infiniband/hw/mthca/mthca_cq.c @@ -779,6 +779,7 @@ 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; @@ -846,12 +847,19 @@ 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); + err = mthca_SW2HW_CQ(dev, mailbox, cq->cqn, &status); 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), @@ -907,6 +915,7 @@ 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)) { @@ -914,9 +923,11 @@ void mthca_free_cq(struct mthca_dev *dev, return; } - err = mthca_HW2SW_CQ(dev, mailbox, cq->cqn); + err = mthca_HW2SW_CQ(dev, mailbox, cq->cqn, &status); 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; diff --git a/trunk/drivers/infiniband/hw/mthca/mthca_eq.c b/trunk/drivers/infiniband/hw/mthca/mthca_eq.c index 7c9d35f39d75..76785c653c13 100644 --- a/trunk/drivers/infiniband/hw/mthca/mthca_eq.c +++ b/trunk/drivers/infiniband/hw/mthca/mthca_eq.c @@ -474,6 +474,7 @@ 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)); @@ -542,9 +543,15 @@ 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); + err = mthca_SW2HW_EQ(dev, mailbox, eq->eqn, &status); if (err) { - mthca_warn(dev, "SW2HW_EQ returned %d\n", 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; goto err_out_free_mr; } @@ -590,6 +597,7 @@ 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; @@ -598,9 +606,11 @@ static void mthca_free_eq(struct mthca_dev *dev, if (IS_ERR(mailbox)) return; - err = mthca_HW2SW_EQ(dev, mailbox, eq->eqn); + err = mthca_HW2SW_EQ(dev, mailbox, eq->eqn, &status); if (err) - mthca_warn(dev, "HW2SW_EQ returned %d\n", err); + mthca_warn(dev, "HW2SW_EQ failed (%d)\n", err); + if (status) + mthca_warn(dev, "HW2SW_EQ returned status 0x%02x\n", status); dev->eq_table.arm_mask &= ~eq->eqn_mask; @@ -728,6 +738,7 @@ 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 @@ -746,7 +757,9 @@ 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); + ret = mthca_MAP_ICM_page(dev, dev->eq_table.icm_dma, icm_virt, &status); + if (!ret && status) + ret = -EINVAL; if (ret) { pci_unmap_page(dev->pdev, dev->eq_table.icm_dma, PAGE_SIZE, PCI_DMA_BIDIRECTIONAL); @@ -758,7 +771,9 @@ int mthca_map_eq_icm(struct mthca_dev *dev, u64 icm_virt) void mthca_unmap_eq_icm(struct mthca_dev *dev) { - mthca_UNMAP_ICM(dev, dev->eq_table.icm_virt, 1); + u8 status; + + mthca_UNMAP_ICM(dev, dev->eq_table.icm_virt, 1, &status); pci_unmap_page(dev->pdev, dev->eq_table.icm_dma, PAGE_SIZE, PCI_DMA_BIDIRECTIONAL); __free_page(dev->eq_table.icm_page); @@ -767,6 +782,7 @@ 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; @@ -848,16 +864,22 @@ 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); + 0, dev->eq_table.eq[MTHCA_EQ_ASYNC].eqn, &status); 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); + 0, dev->eq_table.eq[MTHCA_EQ_CMD].eqn, &status); 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)) @@ -887,14 +909,15 @@ int mthca_init_eq_table(struct mthca_dev *dev) 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); + 1, dev->eq_table.eq[MTHCA_EQ_ASYNC].eqn, &status); mthca_MAP_EQ(dev, MTHCA_CMD_EVENT_MASK, - 1, dev->eq_table.eq[MTHCA_EQ_CMD].eqn); + 1, dev->eq_table.eq[MTHCA_EQ_CMD].eqn, &status); for (i = 0; i < MTHCA_NUM_EQ; ++i) mthca_free_eq(dev, &dev->eq_table.eq[i]); diff --git a/trunk/drivers/infiniband/hw/mthca/mthca_mad.c b/trunk/drivers/infiniband/hw/mthca/mthca_mad.c index b6f7f457fc55..03a59534f59e 100644 --- a/trunk/drivers/infiniband/hw/mthca/mthca_mad.c +++ b/trunk/drivers/infiniband/hw/mthca/mthca_mad.c @@ -201,6 +201,7 @@ 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; @@ -251,11 +252,17 @@ 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); - if (err == -EBADMSG) + 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) return IB_MAD_RESULT_SUCCESS; - else if (err) { - mthca_err(to_mdev(ibdev), "MAD_IFC returned %d\n", err); + if (status) { + mthca_err(to_mdev(ibdev), "MAD_IFC returned status %02x\n", + status); return IB_MAD_RESULT_FAILURE; } diff --git a/trunk/drivers/infiniband/hw/mthca/mthca_main.c b/trunk/drivers/infiniband/hw/mthca/mthca_main.c index aa12a533ae9e..f24b79b805f2 100644 --- a/trunk/drivers/infiniband/hw/mthca/mthca_main.c +++ b/trunk/drivers/infiniband/hw/mthca/mthca_main.c @@ -149,7 +149,7 @@ static int mthca_tune_pci(struct mthca_dev *mdev) } else if (!(mdev->mthca_flags & MTHCA_FLAG_PCIE)) mthca_info(mdev, "No PCI-X capability, not setting RBC.\n"); - if (pci_is_pcie(mdev->pdev)) { + if (pci_find_capability(mdev->pdev, PCI_CAP_ID_EXP)) { if (pcie_set_readrq(mdev->pdev, 4096)) { mthca_err(mdev, "Couldn't write PCI Express read request, " "aborting.\n"); @@ -165,14 +165,19 @@ 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); + err = mthca_QUERY_DEV_LIM(mdev, dev_lim, &status); if (err) { - mthca_err(mdev, "QUERY_DEV_LIM command returned %d" - ", aborting.\n", err); + mthca_err(mdev, "QUERY_DEV_LIM command failed, aborting.\n"); 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", @@ -288,32 +293,49 @@ 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); + err = mthca_SYS_EN(mdev, &status); if (err) { - mthca_err(mdev, "SYS_EN command returned %d, aborting.\n", err); + mthca_err(mdev, "SYS_EN command failed, aborting.\n"); return err; } + if (status) { + mthca_err(mdev, "SYS_EN returned status 0x%02x, " + "aborting.\n", status); + return -EINVAL; + } - err = mthca_QUERY_FW(mdev); + err = mthca_QUERY_FW(mdev, &status); if (err) { - mthca_err(mdev, "QUERY_FW command returned %d," - " aborting.\n", 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; goto err_disable; } - err = mthca_QUERY_DDR(mdev); + err = mthca_QUERY_DDR(mdev, &status); if (err) { - mthca_err(mdev, "QUERY_DDR command returned %d, aborting.\n", 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; goto err_disable; } err = mthca_dev_lim(mdev, &dev_lim); if (err) { - mthca_err(mdev, "QUERY_DEV_LIM command returned %d, aborting.\n", err); + mthca_err(mdev, "QUERY_DEV_LIM command failed, aborting.\n"); goto err_disable; } @@ -329,22 +351,29 @@ static int mthca_init_tavor(struct mthca_dev *mdev) goto err_disable; } - err = mthca_INIT_HCA(mdev, &init_hca); + err = mthca_INIT_HCA(mdev, &init_hca, &status); if (err) { - mthca_err(mdev, "INIT_HCA command returned %d, aborting.\n", 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; goto err_disable; } return 0; err_disable: - mthca_SYS_DIS(mdev); + mthca_SYS_DIS(mdev, &status); return err; } static int mthca_load_fw(struct mthca_dev *mdev) { + u8 status; int err; /* FIXME: use HCA-attached memory for FW if present */ @@ -357,21 +386,31 @@ static int mthca_load_fw(struct mthca_dev *mdev) return -ENOMEM; } - err = mthca_MAP_FA(mdev, mdev->fw.arbel.fw_icm); + err = mthca_MAP_FA(mdev, mdev->fw.arbel.fw_icm, &status); if (err) { - mthca_err(mdev, "MAP_FA command returned %d, aborting.\n", 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; goto err_free; } - err = mthca_RUN_FW(mdev); + err = mthca_RUN_FW(mdev, &status); if (err) { - mthca_err(mdev, "RUN_FW command returned %d, aborting.\n", 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; goto err_unmap_fa; } return 0; err_unmap_fa: - mthca_UNMAP_FA(mdev); + mthca_UNMAP_FA(mdev, &status); err_free: mthca_free_icm(mdev, mdev->fw.arbel.fw_icm, 0); @@ -384,13 +423,19 @@ 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); + err = mthca_SET_ICM_SIZE(mdev, icm_size, &aux_pages, &status); if (err) { - mthca_err(mdev, "SET_ICM_SIZE command returned %d, aborting.\n", err); + mthca_err(mdev, "SET_ICM_SIZE command failed, aborting.\n"); 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, @@ -403,9 +448,14 @@ static int mthca_init_icm(struct mthca_dev *mdev, return -ENOMEM; } - err = mthca_MAP_ICM_AUX(mdev, mdev->fw.arbel.aux_icm); + err = mthca_MAP_ICM_AUX(mdev, mdev->fw.arbel.aux_icm, &status); if (err) { - mthca_err(mdev, "MAP_ICM_AUX returned %d, aborting.\n", 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; goto err_free_aux; } @@ -546,7 +596,7 @@ static int mthca_init_icm(struct mthca_dev *mdev, mthca_unmap_eq_icm(mdev); err_unmap_aux: - mthca_UNMAP_ICM_AUX(mdev); + mthca_UNMAP_ICM_AUX(mdev, &status); err_free_aux: mthca_free_icm(mdev, mdev->fw.arbel.aux_icm, 0); @@ -556,6 +606,7 @@ static int mthca_init_icm(struct mthca_dev *mdev, 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) @@ -568,7 +619,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); + mthca_UNMAP_ICM_AUX(mdev, &status); mthca_free_icm(mdev, mdev->fw.arbel.aux_icm, 0); } @@ -578,32 +629,43 @@ 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); + err = mthca_QUERY_FW(mdev, &status); if (err) { - mthca_err(mdev, "QUERY_FW command failed %d, aborting.\n", err); + mthca_err(mdev, "QUERY_FW command failed, aborting.\n"); return err; } + if (status) { + mthca_err(mdev, "QUERY_FW returned status 0x%02x, " + "aborting.\n", status); + return -EINVAL; + } - err = mthca_ENABLE_LAM(mdev); - if (err == -EAGAIN) { + 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) { mthca_dbg(mdev, "No HCA-attached memory (running in MemFree mode)\n"); mdev->mthca_flags |= MTHCA_FLAG_NO_LAM; - } else if (err) { - mthca_err(mdev, "ENABLE_LAM returned %d, aborting.\n", err); - return err; + } else if (status) { + mthca_err(mdev, "ENABLE_LAM returned status 0x%02x, " + "aborting.\n", status); + return -EINVAL; } err = mthca_load_fw(mdev); if (err) { - mthca_err(mdev, "Loading FW returned %d, aborting.\n", err); + mthca_err(mdev, "Failed to start FW, aborting.\n"); goto err_disable; } err = mthca_dev_lim(mdev, &dev_lim); if (err) { - mthca_err(mdev, "QUERY_DEV_LIM returned %d, aborting.\n", err); + mthca_err(mdev, "QUERY_DEV_LIM command failed, aborting.\n"); goto err_stop_fw; } @@ -623,9 +685,15 @@ static int mthca_init_arbel(struct mthca_dev *mdev) if (err) goto err_stop_fw; - err = mthca_INIT_HCA(mdev, &init_hca); + err = mthca_INIT_HCA(mdev, &init_hca, &status); if (err) { - mthca_err(mdev, "INIT_HCA command returned %d, aborting.\n", 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; goto err_free_icm; } @@ -635,34 +703,37 @@ static int mthca_init_arbel(struct mthca_dev *mdev) mthca_free_icms(mdev); err_stop_fw: - mthca_UNMAP_FA(mdev); + mthca_UNMAP_FA(mdev, &status); mthca_free_icm(mdev, mdev->fw.arbel.fw_icm, 0); err_disable: if (!(mdev->mthca_flags & MTHCA_FLAG_NO_LAM)) - mthca_DISABLE_LAM(mdev); + mthca_DISABLE_LAM(mdev, &status); return err; } static void mthca_close_hca(struct mthca_dev *mdev) { - mthca_CLOSE_HCA(mdev, 0); + u8 status; + + mthca_CLOSE_HCA(mdev, 0, &status); if (mthca_is_memfree(mdev)) { mthca_free_icms(mdev); - mthca_UNMAP_FA(mdev); + mthca_UNMAP_FA(mdev, &status); mthca_free_icm(mdev, mdev->fw.arbel.fw_icm, 0); if (!(mdev->mthca_flags & MTHCA_FLAG_NO_LAM)) - mthca_DISABLE_LAM(mdev); + mthca_DISABLE_LAM(mdev, &status); } else - mthca_SYS_DIS(mdev); + mthca_SYS_DIS(mdev, &status); } static int mthca_init_hca(struct mthca_dev *mdev) { + u8 status; int err; struct mthca_adapter adapter; @@ -674,9 +745,15 @@ static int mthca_init_hca(struct mthca_dev *mdev) if (err) return err; - err = mthca_QUERY_ADAPTER(mdev, &adapter); + err = mthca_QUERY_ADAPTER(mdev, &adapter, &status); if (err) { - mthca_err(mdev, "QUERY_ADAPTER command returned %d, aborting.\n", 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; goto err_close; } @@ -695,6 +772,7 @@ static int mthca_init_hca(struct mthca_dev *mdev) static int mthca_setup_hca(struct mthca_dev *dev) { int err; + u8 status; MTHCA_INIT_DOORBELL_LOCK(&dev->doorbell_lock); @@ -755,8 +833,8 @@ static int mthca_setup_hca(struct mthca_dev *dev) goto err_eq_table_free; } - err = mthca_NOP(dev); - if (err) { + err = mthca_NOP(dev, &status); + if (err || status) { if (dev->mthca_flags & MTHCA_FLAG_MSI_X) { mthca_warn(dev, "NOP command failed to generate interrupt " "(IRQ %d).\n", @@ -1088,6 +1166,7 @@ static int __mthca_init_one(struct pci_dev *pdev, int hca_type) static void __mthca_remove_one(struct pci_dev *pdev) { struct mthca_dev *mdev = pci_get_drvdata(pdev); + u8 status; int p; if (mdev) { @@ -1095,7 +1174,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); + mthca_CLOSE_IB(mdev, p, &status); mthca_cleanup_mcg_table(mdev); mthca_cleanup_av_table(mdev); diff --git a/trunk/drivers/infiniband/hw/mthca/mthca_mcg.c b/trunk/drivers/infiniband/hw/mthca/mthca_mcg.c index 6304ae8f4a6c..515790a606e6 100644 --- a/trunk/drivers/infiniband/hw/mthca/mthca_mcg.c +++ b/trunk/drivers/infiniband/hw/mthca/mthca_mcg.c @@ -68,6 +68,7 @@ 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)) @@ -76,9 +77,12 @@ static int find_mgm(struct mthca_dev *dev, memcpy(mgid, gid, 16); - err = mthca_MGID_HASH(dev, mailbox, hash); - if (err) { - mthca_err(dev, "MGID_HASH failed (%d)\n", err); + 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; goto out; } @@ -89,9 +93,12 @@ static int find_mgm(struct mthca_dev *dev, *prev = -1; do { - err = mthca_READ_MGM(dev, *index, mgm_mailbox); - if (err) { - mthca_err(dev, "READ_MGM failed (%d)\n", err); + 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; goto out; } @@ -127,6 +134,7 @@ 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)) @@ -152,9 +160,12 @@ int mthca_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid) goto out; } - err = mthca_READ_MGM(dev, index, mailbox); - if (err) { - mthca_err(dev, "READ_MGM failed (%d)\n", err); + 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; goto out; } memset(mgm, 0, sizeof *mgm); @@ -178,9 +189,11 @@ int mthca_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid) goto out; } - err = mthca_WRITE_MGM(dev, index, mailbox); - if (err) { - mthca_err(dev, "WRITE_MGM failed %d\n", err); + 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; goto out; } @@ -188,17 +201,24 @@ 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); - if (err) { - mthca_err(dev, "READ_MGM failed %d\n", err); + 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; goto out; } mgm->next_gid_index = cpu_to_be32(index << 6); - err = mthca_WRITE_MGM(dev, prev, mailbox); + err = mthca_WRITE_MGM(dev, prev, mailbox, &status); if (err) - mthca_err(dev, "WRITE_MGM returned %d\n", err); + goto out; + if (status) { + mthca_err(dev, "WRITE_MGM returned status %02x\n", status); + err = -EINVAL; + } out: if (err && link && index != -1) { @@ -220,6 +240,7 @@ 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)) @@ -254,9 +275,12 @@ 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); - if (err) { - mthca_err(dev, "WRITE_MGM returned %d\n", err); + 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; goto out; } @@ -268,17 +292,24 @@ 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); - if (err) { - mthca_err(dev, "READ_MGM returned %d\n", err); + mailbox, &status); + if (err) + goto out; + if (status) { + mthca_err(dev, "READ_MGM returned status %02x\n", + status); + err = -EINVAL; goto out; } } else memset(mgm->gid, 0, 16); - err = mthca_WRITE_MGM(dev, index, mailbox); - if (err) { - mthca_err(dev, "WRITE_MGM returned %d\n", err); + 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; goto out; } if (amgm_index_to_free) { @@ -288,17 +319,23 @@ 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); - if (err) { - mthca_err(dev, "READ_MGM returned %d\n", err); + 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; goto out; } mgm->next_gid_index = cpu_to_be32(curr_next_index << 6); - err = mthca_WRITE_MGM(dev, prev, mailbox); - if (err) { - mthca_err(dev, "WRITE_MGM returned %d\n", err); + 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; goto out; } BUG_ON(index < dev->limits.num_mgms); diff --git a/trunk/drivers/infiniband/hw/mthca/mthca_memfree.c b/trunk/drivers/infiniband/hw/mthca/mthca_memfree.c index 7d2e42dd6926..8c2a83732b5d 100644 --- a/trunk/drivers/infiniband/hw/mthca/mthca_memfree.c +++ b/trunk/drivers/infiniband/hw/mthca/mthca_memfree.c @@ -223,6 +223,7 @@ 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); @@ -239,8 +240,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)) { + if (mthca_MAP_ICM(dev, table->icm[i], table->virt + i * MTHCA_TABLE_CHUNK_SIZE, + &status) || status) { mthca_free_icm(dev, table->icm[i], table->coherent); table->icm[i] = NULL; ret = -ENOMEM; @@ -257,6 +258,7 @@ int mthca_table_get(struct mthca_dev *dev, struct mthca_icm_table *table, int ob 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; @@ -267,7 +269,8 @@ 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); + MTHCA_TABLE_CHUNK_SIZE / MTHCA_ICM_PAGE_SIZE, + &status); mthca_free_icm(dev, table->icm[i], table->coherent); table->icm[i] = NULL; } @@ -363,6 +366,7 @@ 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); @@ -392,8 +396,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)) { + if (mthca_MAP_ICM(dev, table->icm[i], virt + i * MTHCA_TABLE_CHUNK_SIZE, + &status) || status) { mthca_free_icm(dev, table->icm[i], table->coherent); table->icm[i] = NULL; goto err; @@ -412,7 +416,8 @@ struct mthca_icm_table *mthca_alloc_icm_table(struct mthca_dev *dev, 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); + MTHCA_TABLE_CHUNK_SIZE / MTHCA_ICM_PAGE_SIZE, + &status); mthca_free_icm(dev, table->icm[i], table->coherent); } @@ -424,12 +429,13 @@ struct mthca_icm_table *mthca_alloc_icm_table(struct mthca_dev *dev, 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); + mthca_UNMAP_ICM(dev, table->virt + i * MTHCA_TABLE_CHUNK_SIZE, + MTHCA_TABLE_CHUNK_SIZE / MTHCA_ICM_PAGE_SIZE, + &status); mthca_free_icm(dev, table->icm[i], table->coherent); } @@ -448,6 +454,7 @@ 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)) @@ -487,7 +494,9 @@ 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)); + mthca_uarc_virt(dev, uar, i), &status); + if (!ret && status) + ret = -EINVAL; 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)); @@ -548,13 +557,14 @@ 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); + mthca_UNMAP_ICM(dev, mthca_uarc_virt(dev, uar, i), 1, &status); pci_unmap_sg(dev->pdev, &db_tab->page[i].mem, 1, PCI_DMA_TODEVICE); put_page(sg_page(&db_tab->page[i].mem)); } @@ -571,6 +581,7 @@ 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); @@ -633,7 +644,9 @@ int mthca_alloc_db(struct mthca_dev *dev, enum mthca_db_type type, 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)); + mthca_uarc_virt(dev, &dev->driver_uar, i), &status); + if (!ret && status) + ret = -EINVAL; if (ret) { dma_free_coherent(&dev->pdev->dev, MTHCA_ICM_PAGE_SIZE, page->db_rec, page->mapping); @@ -665,6 +678,7 @@ 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; @@ -680,7 +694,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); + mthca_UNMAP_ICM(dev, mthca_uarc_virt(dev, &dev->driver_uar, i), 1, &status); dma_free_coherent(&dev->pdev->dev, MTHCA_ICM_PAGE_SIZE, page->db_rec, page->mapping); @@ -731,6 +745,7 @@ 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; @@ -748,7 +763,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); + mthca_UNMAP_ICM(dev, mthca_uarc_virt(dev, &dev->driver_uar, i), 1, &status); dma_free_coherent(&dev->pdev->dev, MTHCA_ICM_PAGE_SIZE, dev->db_tab->page[i].db_rec, diff --git a/trunk/drivers/infiniband/hw/mthca/mthca_mr.c b/trunk/drivers/infiniband/hw/mthca/mthca_mr.c index ab876f928a1b..44045c8846db 100644 --- a/trunk/drivers/infiniband/hw/mthca/mthca_mr.c +++ b/trunk/drivers/infiniband/hw/mthca/mthca_mr.c @@ -257,6 +257,7 @@ 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); @@ -280,11 +281,17 @@ 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); + err = mthca_WRITE_MTT(dev, mailbox, (i + 1) & ~1, &status); 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; @@ -434,6 +441,7 @@ 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); @@ -489,10 +497,16 @@ 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)); + key & (dev->limits.num_mpts - 1), + &status); 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); @@ -553,12 +567,17 @@ 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)); + (dev->limits.num_mpts - 1), + &status); 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); @@ -571,6 +590,7 @@ 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; @@ -652,11 +672,18 @@ int mthca_fmr_alloc(struct mthca_dev *dev, u32 pd, } err = mthca_SW2HW_MPT(dev, mailbox, - key & (dev->limits.num_mpts - 1)); + key & (dev->limits.num_mpts - 1), + &status); 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; diff --git a/trunk/drivers/infiniband/hw/mthca/mthca_provider.c b/trunk/drivers/infiniband/hw/mthca/mthca_provider.c index 365fe0e14192..1e0b4b6074ad 100644 --- a/trunk/drivers/infiniband/hw/mthca/mthca_provider.c +++ b/trunk/drivers/infiniband/hw/mthca/mthca_provider.c @@ -63,6 +63,8 @@ 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) @@ -76,9 +78,14 @@ 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); + 1, NULL, NULL, in_mad, out_mad, + &status); 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)) & @@ -134,6 +141,7 @@ 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); @@ -147,9 +155,14 @@ 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); + port, NULL, NULL, in_mad, out_mad, + &status); 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; @@ -201,6 +214,7 @@ 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; @@ -215,9 +229,14 @@ 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); + err = mthca_SET_IB(to_mdev(ibdev), &set_ib, port, &status); if (err) goto out; + if (status) { + err = -EINVAL; + goto out; + } + out: mutex_unlock(&to_mdev(ibdev)->cap_mask_mutex); return err; @@ -229,6 +248,7 @@ 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); @@ -240,9 +260,14 @@ 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); + port, NULL, NULL, in_mad, out_mad, + &status); if (err) goto out; + if (status) { + err = -EINVAL; + goto out; + } *pkey = be16_to_cpu(((__be16 *) out_mad->data)[index % 32]); @@ -258,6 +283,7 @@ 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); @@ -269,9 +295,14 @@ 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); + port, NULL, NULL, in_mad, out_mad, + &status); if (err) goto out; + if (status) { + err = -EINVAL; + goto out; + } memcpy(gid->raw, out_mad->data + 8, 8); @@ -280,9 +311,14 @@ 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); + port, NULL, NULL, in_mad, out_mad, + &status); if (err) goto out; + if (status) { + err = -EINVAL; + goto out; + } memcpy(gid->raw + 8, out_mad->data + (index % 8) * 8, 8); @@ -764,6 +800,7 @@ 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) @@ -790,7 +827,9 @@ 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)); + ret = mthca_RESIZE_CQ(dev, cq->cqn, lkey, ilog2(entries), &status); + if (status) + ret = -EINVAL; if (ret) { if (cq->resize_buf) { @@ -1122,6 +1161,7 @@ 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) { @@ -1142,8 +1182,12 @@ 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); - return err; + err = mthca_SYNC_TPT(mdev, &status); + if (err) + return err; + if (status) + return -EINVAL; + return 0; } static ssize_t show_rev(struct device *device, struct device_attribute *attr, @@ -1209,6 +1253,7 @@ 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); @@ -1219,18 +1264,28 @@ 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); + 1, NULL, NULL, in_mad, out_mad, + &status); 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); + 1, NULL, NULL, in_mad, out_mad, + &status); 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)); diff --git a/trunk/drivers/infiniband/hw/mthca/mthca_qp.c b/trunk/drivers/infiniband/hw/mthca/mthca_qp.c index 9601049e14d0..a34c9d38e822 100644 --- a/trunk/drivers/infiniband/hw/mthca/mthca_qp.c +++ b/trunk/drivers/infiniband/hw/mthca/mthca_qp.c @@ -308,6 +308,7 @@ 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(¶m, 0, sizeof param); @@ -318,9 +319,11 @@ 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, ¶m, port); + err = mthca_INIT_IB(dev, ¶m, port, &status); 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, @@ -430,6 +433,7 @@ 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); @@ -444,9 +448,12 @@ 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); - if (err) { - mthca_warn(dev, "QUERY_QP failed (%d)\n", err); + 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; goto out_mailbox; } @@ -548,6 +555,7 @@ 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); @@ -773,10 +781,13 @@ 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); - if (err) { - mthca_warn(dev, "modify QP %d->%d returned %d.\n", - cur_state, new_state, err); + 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; goto out_mailbox; } @@ -806,7 +817,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); + mthca_CLOSE_IB(dev, qp->port, &status); } /* @@ -1418,6 +1429,7 @@ 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; @@ -1442,7 +1454,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); + NULL, 0, &status); /* * If this is a userspace QP, the buffers, MR, CQs and so on @@ -2251,6 +2263,7 @@ 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); @@ -2277,10 +2290,15 @@ 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); - if (err) { + dev->qp_table.sqp_start + i * 2, + &status); + if (err) + goto err_out; + if (status) { mthca_warn(dev, "CONF_SPECIAL_QP returned " - "%d, aborting.\n", err); + "status %02x, aborting.\n", + status); + err = -EINVAL; goto err_out; } } @@ -2288,7 +2306,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); + mthca_CONF_SPECIAL_QP(dev, i, 0, &status); mthca_array_cleanup(&dev->qp_table.qp, dev->limits.num_qps); mthca_alloc_cleanup(&dev->qp_table.alloc); @@ -2299,9 +2317,10 @@ 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); + mthca_CONF_SPECIAL_QP(dev, i, 0, &status); mthca_array_cleanup(&dev->qp_table.qp, dev->limits.num_qps); mthca_alloc_cleanup(&dev->qp_table.alloc); diff --git a/trunk/drivers/infiniband/hw/mthca/mthca_reset.c b/trunk/drivers/infiniband/hw/mthca/mthca_reset.c index 4fa3534ec233..2a13a163d337 100644 --- a/trunk/drivers/infiniband/hw/mthca/mthca_reset.c +++ b/trunk/drivers/infiniband/hw/mthca/mthca_reset.c @@ -113,7 +113,7 @@ int mthca_reset(struct mthca_dev *mdev) } hca_pcix_cap = pci_find_capability(mdev->pdev, PCI_CAP_ID_PCIX); - hca_pcie_cap = pci_pcie_cap(mdev->pdev); + hca_pcie_cap = pci_find_capability(mdev->pdev, PCI_CAP_ID_EXP); if (bridge) { bridge_header = kmalloc(256, GFP_KERNEL); diff --git a/trunk/drivers/infiniband/hw/mthca/mthca_srq.c b/trunk/drivers/infiniband/hw/mthca/mthca_srq.c index d22f970480c0..4fabe62aab8a 100644 --- a/trunk/drivers/infiniband/hw/mthca/mthca_srq.c +++ b/trunk/drivers/infiniband/hw/mthca/mthca_srq.c @@ -200,6 +200,7 @@ 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; @@ -265,12 +266,18 @@ 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); + err = mthca_SW2HW_SRQ(dev, mailbox, srq->srqn, &status); 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, @@ -292,9 +299,11 @@ 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); + err = mthca_HW2SW_SRQ(dev, mailbox, srq->srqn, &status); 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) @@ -331,6 +340,7 @@ 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)) { @@ -338,9 +348,11 @@ void mthca_free_srq(struct mthca_dev *dev, struct mthca_srq *srq) return; } - err = mthca_HW2SW_SRQ(dev, mailbox, srq->srqn); + err = mthca_HW2SW_SRQ(dev, mailbox, srq->srqn, &status); 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, @@ -366,7 +378,8 @@ 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 = 0; + int ret; + u8 status; /* We don't support resizing SRQs (yet?) */ if (attr_mask & IB_SRQ_MAX_WR) @@ -378,11 +391,16 @@ 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); + ret = mthca_ARM_SRQ(dev, srq->srqn, attr->srq_limit, &status); mutex_unlock(&srq->mutex); + + if (ret) + return ret; + if (status) + return -EINVAL; } - return ret; + return 0; } int mthca_query_srq(struct ib_srq *ibsrq, struct ib_srq_attr *srq_attr) @@ -392,13 +410,14 @@ 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); + err = mthca_QUERY_SRQ(dev, srq->srqn, mailbox, &status); if (err) goto out;