int mgmt_check_supported_fw(struct be_ctrl_info *ctrl, struct beiscsi_hba *phba) { struct be_dma_mem nonemb_cmd; struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); struct be_mgmt_controller_attributes *req; struct be_sge *sge = nonembedded_sgl(wrb); int status = 0; nonemb_cmd.va = pci_alloc_consistent(ctrl->pdev, sizeof(struct be_mgmt_controller_attributes), &nonemb_cmd.dma); if (nonemb_cmd.va == NULL) { SE_DEBUG(DBG_LVL_1, "Failed to allocate memory for mgmt_check_supported_fw" "\n"); return -ENOMEM; } nonemb_cmd.size = sizeof(struct be_mgmt_controller_attributes); req = nonemb_cmd.va; memset(req, 0, sizeof(*req)); spin_lock(&ctrl->mbox_lock); memset(wrb, 0, sizeof(*wrb)); be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1); be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON, OPCODE_COMMON_GET_CNTL_ATTRIBUTES, sizeof(*req)); sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd.dma)); sge->pa_lo = cpu_to_le32(nonemb_cmd.dma & 0xFFFFFFFF); sge->len = cpu_to_le32(nonemb_cmd.size); status = be_mbox_notify(ctrl); if (!status) { struct be_mgmt_controller_attributes_resp *resp = nonemb_cmd.va; SE_DEBUG(DBG_LVL_8, "Firmware version of CMD: %s\n", resp->params.hba_attribs.flashrom_version_string); SE_DEBUG(DBG_LVL_8, "Firmware version is : %s\n", resp->params.hba_attribs.firmware_version_string); SE_DEBUG(DBG_LVL_8, "Developer Build, not performing version check...\n"); phba->fw_config.iscsi_features = resp->params.hba_attribs.iscsi_features; SE_DEBUG(DBG_LVL_8, " phba->fw_config.iscsi_features = %d\n", phba->fw_config.iscsi_features); } else SE_DEBUG(DBG_LVL_1, " Failed in mgmt_check_supported_fw\n"); spin_unlock(&ctrl->mbox_lock); if (nonemb_cmd.va) pci_free_consistent(ctrl->pdev, nonemb_cmd.size, nonemb_cmd.va, nonemb_cmd.dma); return status; }
unsigned char mgmt_invalidate_icds(struct beiscsi_hba *phba, unsigned int icd, unsigned int cid) { struct be_dma_mem nonemb_cmd; struct be_ctrl_info *ctrl = &phba->ctrl; struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); struct be_sge *sge = nonembedded_sgl(wrb); struct invalidate_commands_params_in *req; int status = 0; nonemb_cmd.va = pci_alloc_consistent(ctrl->pdev, sizeof(struct invalidate_commands_params_in), &nonemb_cmd.dma); if (nonemb_cmd.va == NULL) { SE_DEBUG(DBG_LVL_1, "Failed to allocate memory for" "mgmt_invalidate_icds \n"); return -1; } nonemb_cmd.size = sizeof(struct invalidate_commands_params_in); req = nonemb_cmd.va; spin_lock(&ctrl->mbox_lock); memset(wrb, 0, sizeof(*wrb)); be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1); be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, OPCODE_COMMON_ISCSI_ERROR_RECOVERY_INVALIDATE_COMMANDS, sizeof(*req)); req->ref_handle = 0; req->cleanup_type = CMD_ISCSI_COMMAND_INVALIDATE; req->icd_count = 0; req->table[req->icd_count].icd = icd; req->table[req->icd_count].cid = cid; sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd.dma)); sge->pa_lo = cpu_to_le32(nonemb_cmd.dma & 0xFFFFFFFF); sge->len = cpu_to_le32(nonemb_cmd.size); status = be_mbox_notify(ctrl); if (status) SE_DEBUG(DBG_LVL_1, "ICDS Invalidation Failed\n"); spin_unlock(&ctrl->mbox_lock); if (nonemb_cmd.va) pci_free_consistent(ctrl->pdev, nonemb_cmd.size, nonemb_cmd.va, nonemb_cmd.dma); return status; }
int mgmt_open_connection(struct beiscsi_hba *phba, struct sockaddr *dst_addr, struct beiscsi_endpoint *beiscsi_ep) { struct hwi_controller *phwi_ctrlr; struct hwi_context_memory *phwi_context; struct sockaddr_in *daddr_in = (struct sockaddr_in *)dst_addr; struct sockaddr_in6 *daddr_in6 = (struct sockaddr_in6 *)dst_addr; struct be_ctrl_info *ctrl = &phba->ctrl; struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); struct tcp_connect_and_offload_in *req = embedded_payload(wrb); unsigned short def_hdr_id; unsigned short def_data_id; struct phys_addr template_address = { 0, 0 }; struct phys_addr *ptemplate_address; int status = 0; unsigned short cid = beiscsi_ep->ep_cid; phwi_ctrlr = phba->phwi_ctrlr; phwi_context = phwi_ctrlr->phwi_ctxt; def_hdr_id = (unsigned short)HWI_GET_DEF_HDRQ_ID(phba); def_data_id = (unsigned short)HWI_GET_DEF_BUFQ_ID(phba); ptemplate_address = &template_address; ISCSI_GET_PDU_TEMPLATE_ADDRESS(phba, ptemplate_address); spin_lock(&ctrl->mbox_lock); memset(wrb, 0, sizeof(*wrb)); be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, OPCODE_COMMON_ISCSI_TCP_CONNECT_AND_OFFLOAD, sizeof(*req)); if (dst_addr->sa_family == PF_INET) { __be32 s_addr = daddr_in->sin_addr.s_addr; req->ip_address.ip_type = BE2_IPV4; req->ip_address.ip_address[0] = s_addr & 0x000000ff; req->ip_address.ip_address[1] = (s_addr & 0x0000ff00) >> 8; req->ip_address.ip_address[2] = (s_addr & 0x00ff0000) >> 16; req->ip_address.ip_address[3] = (s_addr & 0xff000000) >> 24; req->tcp_port = ntohs(daddr_in->sin_port); beiscsi_ep->dst_addr = daddr_in->sin_addr.s_addr; beiscsi_ep->dst_tcpport = ntohs(daddr_in->sin_port); beiscsi_ep->ip_type = BE2_IPV4; } else if (dst_addr->sa_family == PF_INET6) {
int mgmt_get_fw_config(struct be_ctrl_info *ctrl, struct beiscsi_hba *phba) { struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); struct be_fw_cfg *req = embedded_payload(wrb); int status = 0; spin_lock(&ctrl->mbox_lock); memset(wrb, 0, sizeof(*wrb)); be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON, OPCODE_COMMON_QUERY_FIRMWARE_CONFIG, sizeof(*req)); status = be_mbox_notify(ctrl); if (!status) { struct be_fw_cfg *pfw_cfg; pfw_cfg = req; phba->fw_config.phys_port = pfw_cfg->phys_port; phba->fw_config.iscsi_icd_start = pfw_cfg->ulp[0].icd_base; phba->fw_config.iscsi_icd_count = pfw_cfg->ulp[0].icd_count; phba->fw_config.iscsi_cid_start = pfw_cfg->ulp[0].sq_base; phba->fw_config.iscsi_cid_count = pfw_cfg->ulp[0].sq_count; if (phba->fw_config.iscsi_cid_count > (BE2_MAX_SESSIONS / 2)) { SE_DEBUG(DBG_LVL_8, "FW reported MAX CXNS as %d\t" "Max Supported = %d.\n", phba->fw_config.iscsi_cid_count, BE2_MAX_SESSIONS); phba->fw_config.iscsi_cid_count = BE2_MAX_SESSIONS / 2; } } else { shost_printk(KERN_WARNING, phba->shost, "Failed in mgmt_get_fw_config\n"); } spin_unlock(&ctrl->mbox_lock); return status; }
unsigned char mgmt_upload_connection(struct beiscsi_hba *phba, unsigned short cid, unsigned int upload_flag) { struct be_ctrl_info *ctrl = &phba->ctrl; struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); struct tcp_upload_params_in *req = embedded_payload(wrb); int status = 0; spin_lock(&ctrl->mbox_lock); memset(wrb, 0, sizeof(*wrb)); be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); be_cmd_hdr_prepare(&req->hdr, CMD_COMMON_TCP_UPLOAD, OPCODE_COMMON_TCP_UPLOAD, sizeof(*req)); req->id = (unsigned short)cid; req->upload_type = (unsigned char)upload_flag; status = be_mbox_notify(ctrl); if (status) SE_DEBUG(DBG_LVL_1, "mgmt_upload_connection Failed\n"); spin_unlock(&ctrl->mbox_lock); return status; }
unsigned char mgmt_get_fw_config(struct be_ctrl_info *ctrl, struct beiscsi_hba *phba) { struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); struct be_fw_cfg *req = embedded_payload(wrb); int status = 0; spin_lock(&ctrl->mbox_lock); memset(wrb, 0, sizeof(*wrb)); be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON, OPCODE_COMMON_QUERY_FIRMWARE_CONFIG, sizeof(*req)); status = be_mbox_notify(ctrl); if (!status) { struct be_fw_cfg *pfw_cfg; pfw_cfg = req; phba->fw_config.phys_port = pfw_cfg->phys_port; phba->fw_config.iscsi_icd_start = pfw_cfg->ulp[0].icd_base; phba->fw_config.iscsi_icd_count = pfw_cfg->ulp[0].icd_count; phba->fw_config.iscsi_cid_start = pfw_cfg->ulp[0].sq_base; phba->fw_config.iscsi_cid_count = pfw_cfg->ulp[0].sq_count; } else { shost_printk(KERN_WARNING, phba->shost, "Failed in mgmt_get_fw_config \n"); } spin_unlock(&ctrl->mbox_lock); return status; }
/** * mgmt_get_fw_config()- Get the FW config for the function * @ctrl: ptr to Ctrl Info * @phba: ptr to the dev priv structure * * Get the FW config and resources available for the function. * The resources are created based on the count received here. * * return * Success: 0 * Failure: Non-Zero Value **/ int mgmt_get_fw_config(struct be_ctrl_info *ctrl, struct beiscsi_hba *phba) { struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); struct be_fw_cfg *req = embedded_payload(wrb); int status = 0; spin_lock(&ctrl->mbox_lock); memset(wrb, 0, sizeof(*wrb)); be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON, OPCODE_COMMON_QUERY_FIRMWARE_CONFIG, EMBED_MBX_MAX_PAYLOAD_SIZE); status = be_mbox_notify(ctrl); if (!status) { uint8_t ulp_num = 0; struct be_fw_cfg *pfw_cfg; pfw_cfg = req; if (!is_chip_be2_be3r(phba)) { phba->fw_config.eqid_count = pfw_cfg->eqid_count; phba->fw_config.cqid_count = pfw_cfg->cqid_count; beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, "BG_%d : EQ_Count : %d CQ_Count : %d\n", phba->fw_config.eqid_count, phba->fw_config.cqid_count); } for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) if (pfw_cfg->ulp[ulp_num].ulp_mode & BEISCSI_ULP_ISCSI_INI_MODE) set_bit(ulp_num, &phba->fw_config.ulp_supported); phba->fw_config.phys_port = pfw_cfg->phys_port; for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) { if (test_bit(ulp_num, &phba->fw_config.ulp_supported)) { phba->fw_config.iscsi_cid_start[ulp_num] = pfw_cfg->ulp[ulp_num].sq_base; phba->fw_config.iscsi_cid_count[ulp_num] = pfw_cfg->ulp[ulp_num].sq_count; phba->fw_config.iscsi_icd_start[ulp_num] = pfw_cfg->ulp[ulp_num].icd_base; phba->fw_config.iscsi_icd_count[ulp_num] = pfw_cfg->ulp[ulp_num].icd_count; phba->fw_config.iscsi_chain_start[ulp_num] = pfw_cfg->chain_icd[ulp_num].chain_base; phba->fw_config.iscsi_chain_count[ulp_num] = pfw_cfg->chain_icd[ulp_num].chain_count; beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, "BG_%d : Function loaded on ULP : %d\n" "\tiscsi_cid_count : %d\n" "\tiscsi_cid_start : %d\n" "\t iscsi_icd_count : %d\n" "\t iscsi_icd_start : %d\n", ulp_num, phba->fw_config. iscsi_cid_count[ulp_num], phba->fw_config. iscsi_cid_start[ulp_num], phba->fw_config. iscsi_icd_count[ulp_num], phba->fw_config. iscsi_icd_start[ulp_num]); } } phba->fw_config.dual_ulp_aware = (pfw_cfg->function_mode & BEISCSI_FUNC_DUA_MODE); beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, "BG_%d : DUA Mode : 0x%x\n", phba->fw_config.dual_ulp_aware); } else { beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, "BG_%d : Failed in mgmt_get_fw_config\n"); status = -EINVAL; } spin_unlock(&ctrl->mbox_lock); return status; }