GitHub-Mirror/Star64_linux
2
0
Fork 0
mirror of https://github.com/Fishwaldo/Star64_linux.git synced 2025-06-20 13:41:30 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

be2iscsi: Fix to use atomic bit operations for tag_state

Browse source 
beiscsi_mccq_compl sets MCC_TAG_STATE_TIMEOUT before setting up
tag_mem_state. be_mcc_compl_process_isr checks for MCC_TAG_STATE_TIMEOUT
first then accesses tag_mem_state which might be still getting populated
in the process context.

Fix: Set MCC_TAG_STATE_TIMEOUT after tag_mem_state is populated.
Removed MCC_TAG_STATE_COMPLETED. When posted its in running state and
the running state is cleared in be_mcc_compl_process_isr.  be_mcc_notify
now takes tag argument to set it to running state.  Use bit operations
for tag_state. Use barriers before setting the state.

Signed-off-by: Jitendra Bhivare <jitendra.bhivare@avagotech.com>
Reviewed-by: Hannes Reinicke <hare@suse.de>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
This commit is contained in:
Jitendra Bhivare 2016-01-20 14:10:47 +05:30 • committed by Martin K. Petersen
parent c03a50f709
commit cdde6682ab
4 changed files with 84 additions and 77 deletions
Download patch file Download diff file Expand all files Collapse all files

7
drivers/scsi/be2iscsi/be.h
View file

@ -110,10 +110,9 @@ struct be_mcc_obj {
}; };
struct beiscsi_mcc_tag_state { struct beiscsi_mcc_tag_state {
#define MCC_TAG_STATE_COMPLETED 0x00 unsigned long tag_state;
#define MCC_TAG_STATE_RUNNING 0x01 #define MCC_TAG_STATE_RUNNING 1
#define MCC_TAG_STATE_TIMEOUT 0x02 #define MCC_TAG_STATE_TIMEOUT 2
uint8_t tag_state;
struct be_dma_mem tag_mem_state; struct be_dma_mem tag_mem_state;
}; };

109
drivers/scsi/be2iscsi/be_cmds.c
View file

@ -104,13 +104,16 @@ int be_chk_reset_complete(struct beiscsi_hba *phba)
return 0; return 0;
} }
void be_mcc_notify(struct beiscsi_hba *phba) void be_mcc_notify(struct beiscsi_hba *phba, unsigned int tag)
{ {
struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q; struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
u32 val = 0; u32 val = 0;
set_bit(MCC_TAG_STATE_RUNNING, &phba->ctrl.ptag_state[tag].tag_state);
val |= mccq->id & DB_MCCQ_RING_ID_MASK; val |= mccq->id & DB_MCCQ_RING_ID_MASK;
val |= 1 << DB_MCCQ_NUM_POSTED_SHIFT; val |= 1 << DB_MCCQ_NUM_POSTED_SHIFT;
/* ring doorbell after all of request and state is written */
wmb();
iowrite32(val, phba->db_va + DB_MCCQ_OFFSET); iowrite32(val, phba->db_va + DB_MCCQ_OFFSET);
} }
@ -122,6 +125,7 @@ unsigned int alloc_mcc_tag(struct beiscsi_hba *phba)
tag = phba->ctrl.mcc_tag[phba->ctrl.mcc_alloc_index]; tag = phba->ctrl.mcc_tag[phba->ctrl.mcc_alloc_index];
phba->ctrl.mcc_tag[phba->ctrl.mcc_alloc_index] = 0; phba->ctrl.mcc_tag[phba->ctrl.mcc_alloc_index] = 0;
phba->ctrl.mcc_numtag[tag] = 0; phba->ctrl.mcc_numtag[tag] = 0;
phba->ctrl.ptag_state[tag].tag_state = 0;
} }
if (tag) { if (tag) {
phba->ctrl.mcc_tag_available--; phba->ctrl.mcc_tag_available--;
@ -163,26 +167,25 @@ int beiscsi_mccq_compl(struct beiscsi_hba *phba,
return -EPERM; return -EPERM;
} }
/* Set MBX Tag state to Active */
mutex_lock(&phba->ctrl.mbox_lock);
phba->ctrl.ptag_state[tag].tag_state = MCC_TAG_STATE_RUNNING;
mutex_unlock(&phba->ctrl.mbox_lock);
/* wait for the mccq completion */ /* wait for the mccq completion */
rc = wait_event_interruptible_timeout( rc = wait_event_interruptible_timeout(
phba->ctrl.mcc_wait[tag], phba->ctrl.mcc_wait[tag],
phba->ctrl.mcc_numtag[tag], phba->ctrl.mcc_numtag[tag],
msecs_to_jiffies( msecs_to_jiffies(
BEISCSI_HOST_MBX_TIMEOUT)); BEISCSI_HOST_MBX_TIMEOUT));
/**
* If MBOX cmd timeout expired, tag and resource allocated
* for cmd is not freed until FW returns completion.
*/
if (rc <= 0) { if (rc <= 0) {
struct be_dma_mem *tag_mem; struct be_dma_mem *tag_mem;
/* Set MBX Tag state to timeout */
mutex_lock(&phba->ctrl.mbox_lock);
phba->ctrl.ptag_state[tag].tag_state = MCC_TAG_STATE_TIMEOUT;
mutex_unlock(&phba->ctrl.mbox_lock);
/* Store resource addr to be freed later */ /**
* PCI/DMA memory allocated and posted in non-embedded mode
* will have mbx_cmd_mem != NULL.
* Save virtual and bus addresses for the command so that it
* can be freed later.
**/
tag_mem = &phba->ctrl.ptag_state[tag].tag_mem_state; tag_mem = &phba->ctrl.ptag_state[tag].tag_mem_state;
if (mbx_cmd_mem) { if (mbx_cmd_mem) {
tag_mem->size = mbx_cmd_mem->size; tag_mem->size = mbx_cmd_mem->size;
@ -191,19 +194,19 @@ int beiscsi_mccq_compl(struct beiscsi_hba *phba,
} else } else
tag_mem->size = 0; tag_mem->size = 0;
/* first make tag_mem_state visible to all */
wmb();
set_bit(MCC_TAG_STATE_TIMEOUT,
&phba->ctrl.ptag_state[tag].tag_state);
beiscsi_log(phba, KERN_ERR, beiscsi_log(phba, KERN_ERR,
BEISCSI_LOG_INIT | BEISCSI_LOG_EH | BEISCSI_LOG_INIT | BEISCSI_LOG_EH |
BEISCSI_LOG_CONFIG, BEISCSI_LOG_CONFIG,
"BC_%d : MBX Cmd Completion timed out\n"); "BC_%d : MBX Cmd Completion timed out\n");
return -EBUSY; return -EBUSY;
} else {
rc = 0;
/* Set MBX Tag state to completed */
mutex_lock(&phba->ctrl.mbox_lock);
phba->ctrl.ptag_state[tag].tag_state = MCC_TAG_STATE_COMPLETED;
mutex_unlock(&phba->ctrl.mbox_lock);
} }
rc = 0;
mcc_tag_response = phba->ctrl.mcc_numtag[tag]; mcc_tag_response = phba->ctrl.mcc_numtag[tag];
status = (mcc_tag_response & CQE_STATUS_MASK); status = (mcc_tag_response & CQE_STATUS_MASK);
addl_status = ((mcc_tag_response & CQE_STATUS_ADDL_MASK) >> addl_status = ((mcc_tag_response & CQE_STATUS_ADDL_MASK) >>
@ -231,7 +234,7 @@ int beiscsi_mccq_compl(struct beiscsi_hba *phba,
mbx_hdr->subsystem, mbx_hdr->subsystem,
mbx_hdr->opcode, mbx_hdr->opcode,
status, addl_status); status, addl_status);
rc = -EIO;
if (status == MCC_STATUS_INSUFFICIENT_BUFFER) { if (status == MCC_STATUS_INSUFFICIENT_BUFFER) {
mbx_resp_hdr = (struct be_cmd_resp_hdr *) mbx_hdr; mbx_resp_hdr = (struct be_cmd_resp_hdr *) mbx_hdr;
beiscsi_log(phba, KERN_WARNING, beiscsi_log(phba, KERN_WARNING,
@ -241,17 +244,11 @@ int beiscsi_mccq_compl(struct beiscsi_hba *phba,
"Resp_Len : %d Actual_Resp_Len : %d\n", "Resp_Len : %d Actual_Resp_Len : %d\n",
mbx_resp_hdr->response_length, mbx_resp_hdr->response_length,
mbx_resp_hdr->actual_resp_len); mbx_resp_hdr->actual_resp_len);
rc = -EAGAIN; rc = -EAGAIN;
goto release_mcc_tag;
} }
rc = -EIO;
} }
release_mcc_tag:
/* Release the MCC entry */
free_mcc_tag(&phba->ctrl, tag); free_mcc_tag(&phba->ctrl, tag);
return rc; return rc;
} }
@ -354,9 +351,37 @@ int be_mcc_compl_process_isr(struct be_ctrl_info *ctrl,
{ {
struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev); struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
u16 compl_status, extd_status; u16 compl_status, extd_status;
struct be_dma_mem *tag_mem;
unsigned short tag; unsigned short tag;
be_dws_le_to_cpu(compl, 4); be_dws_le_to_cpu(compl, 4);
tag = (compl->tag0 & 0x000000FF);
if (!test_bit(MCC_TAG_STATE_RUNNING,
&ctrl->ptag_state[tag].tag_state)) {
beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_MBOX |
BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
"BC_%d : MBX cmd completed but not posted\n");
return 0;
}
if (test_bit(MCC_TAG_STATE_TIMEOUT,
&ctrl->ptag_state[tag].tag_state)) {
beiscsi_log(phba, KERN_WARNING,
BEISCSI_LOG_MBOX | BEISCSI_LOG_INIT |
BEISCSI_LOG_CONFIG,
"BC_%d : MBX Completion for timeout Command from FW\n");
/**
* Check for the size before freeing resource.
* Only for non-embedded cmd, PCI resource is allocated.
**/
tag_mem = &ctrl->ptag_state[tag].tag_mem_state;
if (tag_mem->size)
pci_free_consistent(ctrl->pdev, tag_mem->size,
tag_mem->va, tag_mem->dma);
free_mcc_tag(ctrl, tag);
return 0;
}
compl_status = (compl->status >> CQE_STATUS_COMPL_SHIFT) & compl_status = (compl->status >> CQE_STATUS_COMPL_SHIFT) &
CQE_STATUS_COMPL_MASK; CQE_STATUS_COMPL_MASK;
@ -364,40 +389,16 @@ int be_mcc_compl_process_isr(struct be_ctrl_info *ctrl,
* [31] = valid, [30:24] = Rsvd, [23:16] = wrb, [15:8] = extd_status, * [31] = valid, [30:24] = Rsvd, [23:16] = wrb, [15:8] = extd_status,
* [7:0] = compl_status * [7:0] = compl_status
*/ */
tag = (compl->tag0 & 0x000000FF);
extd_status = (compl->status >> CQE_STATUS_EXTD_SHIFT) & extd_status = (compl->status >> CQE_STATUS_EXTD_SHIFT) &
CQE_STATUS_EXTD_MASK; CQE_STATUS_EXTD_MASK;
ctrl->mcc_numtag[tag] = 0x80000000; ctrl->mcc_numtag[tag] = 0x80000000;
ctrl->mcc_numtag[tag] |= (compl->tag0 & 0x00FF0000); ctrl->mcc_numtag[tag] |= (compl->tag0 & 0x00FF0000);
ctrl->mcc_numtag[tag] |= (extd_status & 0x000000FF) << 8; ctrl->mcc_numtag[tag] |= (extd_status & 0x000000FF) << 8;
ctrl->mcc_numtag[tag] |= (compl_status & 0x000000FF); ctrl->mcc_numtag[tag] |= (compl_status & 0x000000FF);
if (ctrl->ptag_state[tag].tag_state == MCC_TAG_STATE_RUNNING) { /* write ordering implied in wake_up_interruptible */
clear_bit(MCC_TAG_STATE_RUNNING, &ctrl->ptag_state[tag].tag_state);
wake_up_interruptible(&ctrl->mcc_wait[tag]); wake_up_interruptible(&ctrl->mcc_wait[tag]);
} else if (ctrl->ptag_state[tag].tag_state == MCC_TAG_STATE_TIMEOUT) {
struct be_dma_mem *tag_mem;
tag_mem = &ctrl->ptag_state[tag].tag_mem_state;
beiscsi_log(phba, KERN_WARNING,
BEISCSI_LOG_MBOX | BEISCSI_LOG_INIT |
BEISCSI_LOG_CONFIG,
"BC_%d : MBX Completion for timeout Command "
"from FW\n");
/* Check if memory needs to be freed */
if (tag_mem->size)
pci_free_consistent(ctrl->pdev, tag_mem->size,
tag_mem->va, tag_mem->dma);
/* Change tag state */
mutex_lock(&phba->ctrl.mbox_lock);
ctrl->ptag_state[tag].tag_state = MCC_TAG_STATE_COMPLETED;
mutex_unlock(&phba->ctrl.mbox_lock);
/* Free MCC Tag */
free_mcc_tag(ctrl, tag);
}
return 0; return 0;
} }
@ -568,9 +569,9 @@ static int be_mcc_wait_compl(struct beiscsi_hba *phba)
* Success: 0 * Success: 0
* Failure: Non-Zero * Failure: Non-Zero
**/ **/
int be_mcc_notify_wait(struct beiscsi_hba *phba) int be_mcc_notify_wait(struct beiscsi_hba *phba, unsigned int tag)
{ {
be_mcc_notify(phba); be_mcc_notify(phba, tag);
return be_mcc_wait_compl(phba); return be_mcc_wait_compl(phba);
} }
@ -1439,7 +1440,7 @@ int be_cmd_set_vlan(struct beiscsi_hba *phba,
req->interface_hndl = phba->interface_handle; req->interface_hndl = phba->interface_handle;
req->vlan_priority = vlan_tag; req->vlan_priority = vlan_tag;
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
return tag; return tag;

4
drivers/scsi/be2iscsi/be_cmds.h
View file

@ -745,8 +745,8 @@ int be_cmd_fw_uninit(struct be_ctrl_info *ctrl);
struct be_mcc_wrb *wrb_from_mbox(struct be_dma_mem *mbox_mem); struct be_mcc_wrb *wrb_from_mbox(struct be_dma_mem *mbox_mem);
struct be_mcc_wrb *wrb_from_mccq(struct beiscsi_hba *phba); struct be_mcc_wrb *wrb_from_mccq(struct beiscsi_hba *phba);
int be_mcc_notify_wait(struct beiscsi_hba *phba); int be_mcc_notify_wait(struct beiscsi_hba *phba, unsigned int tag);
void be_mcc_notify(struct beiscsi_hba *phba); void be_mcc_notify(struct beiscsi_hba *phba, unsigned int tag);
unsigned int alloc_mcc_tag(struct beiscsi_hba *phba); unsigned int alloc_mcc_tag(struct beiscsi_hba *phba);
void beiscsi_async_link_state_process(struct beiscsi_hba *phba, void beiscsi_async_link_state_process(struct beiscsi_hba *phba,
struct be_async_event_link_state *evt); struct be_async_event_link_state *evt);

39
drivers/scsi/be2iscsi/be_mgmt.c
View file

@ -187,7 +187,7 @@ int be_cmd_modify_eq_delay(struct beiscsi_hba *phba,
cpu_to_le32(set_eqd[i].delay_multiplier); cpu_to_le32(set_eqd[i].delay_multiplier);
} }
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
return tag; return tag;
} }
@ -234,7 +234,7 @@ unsigned int mgmt_reopen_session(struct beiscsi_hba *phba,
req->reopen_type = reopen_type; req->reopen_type = reopen_type;
req->session_handle = sess_handle; req->session_handle = sess_handle;
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
return tag; return tag;
} }
@ -265,7 +265,7 @@ unsigned int mgmt_get_boot_target(struct beiscsi_hba *phba)
OPCODE_ISCSI_INI_BOOT_GET_BOOT_TARGET, OPCODE_ISCSI_INI_BOOT_GET_BOOT_TARGET,
sizeof(struct be_cmd_get_boot_target_resp)); sizeof(struct be_cmd_get_boot_target_resp));
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
return tag; return tag;
} }
@ -310,7 +310,7 @@ unsigned int mgmt_get_session_info(struct beiscsi_hba *phba,
sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF);
sge->len = cpu_to_le32(nonemb_cmd->size); sge->len = cpu_to_le32(nonemb_cmd->size);
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
return tag; return tag;
} }
@ -541,7 +541,7 @@ unsigned int mgmt_vendor_specific_fw_cmd(struct be_ctrl_info *ctrl,
mcc_sge->len = cpu_to_le32(nonemb_cmd->size); mcc_sge->len = cpu_to_le32(nonemb_cmd->size);
wrb->tag0 |= tag; wrb->tag0 |= tag;
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
return tag; return tag;
@ -561,19 +561,26 @@ int mgmt_epfw_cleanup(struct beiscsi_hba *phba, unsigned short ulp_num)
struct be_ctrl_info *ctrl = &phba->ctrl; struct be_ctrl_info *ctrl = &phba->ctrl;
struct be_mcc_wrb *wrb = wrb_from_mccq(phba); struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
struct iscsi_cleanup_req *req = embedded_payload(wrb); struct iscsi_cleanup_req *req = embedded_payload(wrb);
int status = 0; unsigned int tag;
int status;
mutex_lock(&ctrl->mbox_lock); mutex_lock(&ctrl->mbox_lock);
tag = alloc_mcc_tag(phba);
if (!tag) {
mutex_unlock(&ctrl->mbox_lock);
return -EBUSY;
}
be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
OPCODE_COMMON_ISCSI_CLEANUP, sizeof(*req)); OPCODE_COMMON_ISCSI_CLEANUP, sizeof(*req));
wrb->tag0 |= tag;
req->chute = (1 << ulp_num); req->chute = (1 << ulp_num);
req->hdr_ring_id = cpu_to_le16(HWI_GET_DEF_HDRQ_ID(phba, ulp_num)); req->hdr_ring_id = cpu_to_le16(HWI_GET_DEF_HDRQ_ID(phba, ulp_num));
req->data_ring_id = cpu_to_le16(HWI_GET_DEF_BUFQ_ID(phba, ulp_num)); req->data_ring_id = cpu_to_le16(HWI_GET_DEF_BUFQ_ID(phba, ulp_num));
status = be_mcc_notify_wait(phba); status = be_mcc_notify_wait(phba, tag);
if (status) if (status)
beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT, beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT,
"BG_%d : mgmt_epfw_cleanup , FAILED\n"); "BG_%d : mgmt_epfw_cleanup , FAILED\n");
@ -622,7 +629,7 @@ unsigned int mgmt_invalidate_icds(struct beiscsi_hba *phba,
sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF);
sge->len = cpu_to_le32(nonemb_cmd->size); sge->len = cpu_to_le32(nonemb_cmd->size);
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
return tag; return tag;
} }
@ -659,7 +666,7 @@ unsigned int mgmt_invalidate_connection(struct beiscsi_hba *phba,
else else
req->cleanup_type = CMD_ISCSI_CONNECTION_INVALIDATE; req->cleanup_type = CMD_ISCSI_CONNECTION_INVALIDATE;
req->save_cfg = savecfg_flag; req->save_cfg = savecfg_flag;
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
return tag; return tag;
} }
@ -687,7 +694,7 @@ unsigned int mgmt_upload_connection(struct beiscsi_hba *phba,
OPCODE_COMMON_TCP_UPLOAD, sizeof(*req)); OPCODE_COMMON_TCP_UPLOAD, sizeof(*req));
req->id = (unsigned short)cid; req->id = (unsigned short)cid;
req->upload_type = (unsigned char)upload_flag; req->upload_type = (unsigned char)upload_flag;
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
return tag; return tag;
} }
@ -803,7 +810,7 @@ int mgmt_open_connection(struct beiscsi_hba *phba,
req->tcp_window_scale_count = 2; req->tcp_window_scale_count = 2;
} }
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
return tag; return tag;
} }
@ -833,7 +840,7 @@ unsigned int mgmt_get_all_if_id(struct beiscsi_hba *phba)
be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
OPCODE_COMMON_ISCSI_NTWK_GET_ALL_IF_ID, OPCODE_COMMON_ISCSI_NTWK_GET_ALL_IF_ID,
sizeof(*req)); sizeof(*req));
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
status = beiscsi_mccq_compl(phba, tag, &wrb, NULL); status = beiscsi_mccq_compl(phba, tag, &wrb, NULL);
@ -884,7 +891,7 @@ static int mgmt_exec_nonemb_cmd(struct beiscsi_hba *phba,
sge->pa_lo = cpu_to_le32(lower_32_bits(nonemb_cmd->dma)); sge->pa_lo = cpu_to_le32(lower_32_bits(nonemb_cmd->dma));
sge->len = cpu_to_le32(nonemb_cmd->size); sge->len = cpu_to_le32(nonemb_cmd->size);
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
rc = beiscsi_mccq_compl(phba, tag, NULL, nonemb_cmd); rc = beiscsi_mccq_compl(phba, tag, NULL, nonemb_cmd);
@ -1281,7 +1288,7 @@ unsigned int be_cmd_get_initname(struct beiscsi_hba *phba)
OPCODE_ISCSI_INI_CFG_GET_HBA_NAME, OPCODE_ISCSI_INI_CFG_GET_HBA_NAME,
sizeof(*req)); sizeof(*req));
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
return tag; return tag;
} }
@ -1309,7 +1316,7 @@ unsigned int be_cmd_get_port_speed(struct beiscsi_hba *phba)
OPCODE_COMMON_NTWK_LINK_STATUS_QUERY, OPCODE_COMMON_NTWK_LINK_STATUS_QUERY,
sizeof(*req)); sizeof(*req));
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
return tag; return tag;
} }
@ -1786,7 +1793,7 @@ int beiscsi_logout_fw_sess(struct beiscsi_hba *phba,
/* Set the session handle */ /* Set the session handle */
req->session_handle = fw_sess_handle; req->session_handle = fw_sess_handle;
be_mcc_notify(phba); be_mcc_notify(phba, tag);
mutex_unlock(&ctrl->mbox_lock); mutex_unlock(&ctrl->mbox_lock);
rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL); rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL);