1 /** 2 * Copyright (C) 2005 - 2015 Emulex 3 * All rights reserved. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License version 2 7 * as published by the Free Software Foundation. The full GNU General 8 * Public License is included in this distribution in the file called COPYING. 9 * 10 * Written by: Jayamohan Kallickal (jayamohan.kallickal@avagotech.com) 11 * 12 * Contact Information: 13 * linux-drivers@avagotech.com 14 * 15 * Emulex 16 * 3333 Susan Street 17 * Costa Mesa, CA 92626 18 */ 19 20 #include <linux/bsg-lib.h> 21 #include <scsi/scsi_transport_iscsi.h> 22 #include <scsi/scsi_bsg_iscsi.h> 23 #include "be_mgmt.h" 24 #include "be_iscsi.h" 25 #include "be_main.h" 26 27 /* UE Status Low CSR */ 28 static const char * const desc_ue_status_low[] = { 29 "CEV", 30 "CTX", 31 "DBUF", 32 "ERX", 33 "Host", 34 "MPU", 35 "NDMA", 36 "PTC ", 37 "RDMA ", 38 "RXF ", 39 "RXIPS ", 40 "RXULP0 ", 41 "RXULP1 ", 42 "RXULP2 ", 43 "TIM ", 44 "TPOST ", 45 "TPRE ", 46 "TXIPS ", 47 "TXULP0 ", 48 "TXULP1 ", 49 "UC ", 50 "WDMA ", 51 "TXULP2 ", 52 "HOST1 ", 53 "P0_OB_LINK ", 54 "P1_OB_LINK ", 55 "HOST_GPIO ", 56 "MBOX ", 57 "AXGMAC0", 58 "AXGMAC1", 59 "JTAG", 60 "MPU_INTPEND" 61 }; 62 63 /* UE Status High CSR */ 64 static const char * const desc_ue_status_hi[] = { 65 "LPCMEMHOST", 66 "MGMT_MAC", 67 "PCS0ONLINE", 68 "MPU_IRAM", 69 "PCS1ONLINE", 70 "PCTL0", 71 "PCTL1", 72 "PMEM", 73 "RR", 74 "TXPB", 75 "RXPP", 76 "XAUI", 77 "TXP", 78 "ARM", 79 "IPC", 80 "HOST2", 81 "HOST3", 82 "HOST4", 83 "HOST5", 84 "HOST6", 85 "HOST7", 86 "HOST8", 87 "HOST9", 88 "NETC", 89 "Unknown", 90 "Unknown", 91 "Unknown", 92 "Unknown", 93 "Unknown", 94 "Unknown", 95 "Unknown", 96 "Unknown" 97 }; 98 99 /* 100 * beiscsi_ue_detec()- Detect Unrecoverable Error on adapter 101 * @phba: Driver priv structure 102 * 103 * Read registers linked to UE and check for the UE status 104 **/ 105 void beiscsi_ue_detect(struct beiscsi_hba *phba) 106 { 107 uint32_t ue_hi = 0, ue_lo = 0; 108 uint32_t ue_mask_hi = 0, ue_mask_lo = 0; 109 uint8_t i = 0; 110 111 if (phba->ue_detected) 112 return; 113 114 pci_read_config_dword(phba->pcidev, 115 PCICFG_UE_STATUS_LOW, &ue_lo); 116 pci_read_config_dword(phba->pcidev, 117 PCICFG_UE_STATUS_MASK_LOW, 118 &ue_mask_lo); 119 pci_read_config_dword(phba->pcidev, 120 PCICFG_UE_STATUS_HIGH, 121 &ue_hi); 122 pci_read_config_dword(phba->pcidev, 123 PCICFG_UE_STATUS_MASK_HI, 124 &ue_mask_hi); 125 126 ue_lo = (ue_lo & ~ue_mask_lo); 127 ue_hi = (ue_hi & ~ue_mask_hi); 128 129 130 if (ue_lo || ue_hi) { 131 phba->ue_detected = true; 132 beiscsi_log(phba, KERN_ERR, 133 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX, 134 "BG_%d : Error detected on the adapter\n"); 135 } 136 137 if (ue_lo) { 138 for (i = 0; ue_lo; ue_lo >>= 1, i++) { 139 if (ue_lo & 1) 140 beiscsi_log(phba, KERN_ERR, 141 BEISCSI_LOG_CONFIG, 142 "BG_%d : UE_LOW %s bit set\n", 143 desc_ue_status_low[i]); 144 } 145 } 146 147 if (ue_hi) { 148 for (i = 0; ue_hi; ue_hi >>= 1, i++) { 149 if (ue_hi & 1) 150 beiscsi_log(phba, KERN_ERR, 151 BEISCSI_LOG_CONFIG, 152 "BG_%d : UE_HIGH %s bit set\n", 153 desc_ue_status_hi[i]); 154 } 155 } 156 } 157 158 int be_cmd_modify_eq_delay(struct beiscsi_hba *phba, 159 struct be_set_eqd *set_eqd, int num) 160 { 161 struct be_ctrl_info *ctrl = &phba->ctrl; 162 struct be_mcc_wrb *wrb; 163 struct be_cmd_req_modify_eq_delay *req; 164 unsigned int tag; 165 int i; 166 167 mutex_lock(&ctrl->mbox_lock); 168 wrb = alloc_mcc_wrb(phba, &tag); 169 if (!wrb) { 170 mutex_unlock(&ctrl->mbox_lock); 171 return 0; 172 } 173 174 req = embedded_payload(wrb); 175 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 176 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON, 177 OPCODE_COMMON_MODIFY_EQ_DELAY, sizeof(*req)); 178 179 req->num_eq = cpu_to_le32(num); 180 for (i = 0; i < num; i++) { 181 req->delay[i].eq_id = cpu_to_le32(set_eqd[i].eq_id); 182 req->delay[i].phase = 0; 183 req->delay[i].delay_multiplier = 184 cpu_to_le32(set_eqd[i].delay_multiplier); 185 } 186 187 be_mcc_notify(phba, tag); 188 mutex_unlock(&ctrl->mbox_lock); 189 return tag; 190 } 191 192 /** 193 * mgmt_reopen_session()- Reopen a session based on reopen_type 194 * @phba: Device priv structure instance 195 * @reopen_type: Type of reopen_session FW should do. 196 * @sess_handle: Session Handle of the session to be re-opened 197 * 198 * return 199 * the TAG used for MBOX Command 200 * 201 **/ 202 unsigned int mgmt_reopen_session(struct beiscsi_hba *phba, 203 unsigned int reopen_type, 204 unsigned int sess_handle) 205 { 206 struct be_ctrl_info *ctrl = &phba->ctrl; 207 struct be_mcc_wrb *wrb; 208 struct be_cmd_reopen_session_req *req; 209 unsigned int tag; 210 211 beiscsi_log(phba, KERN_INFO, 212 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX, 213 "BG_%d : In bescsi_get_boot_target\n"); 214 215 mutex_lock(&ctrl->mbox_lock); 216 wrb = alloc_mcc_wrb(phba, &tag); 217 if (!wrb) { 218 mutex_unlock(&ctrl->mbox_lock); 219 return 0; 220 } 221 222 req = embedded_payload(wrb); 223 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 224 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 225 OPCODE_ISCSI_INI_DRIVER_REOPEN_ALL_SESSIONS, 226 sizeof(struct be_cmd_reopen_session_resp)); 227 228 /* set the reopen_type,sess_handle */ 229 req->reopen_type = reopen_type; 230 req->session_handle = sess_handle; 231 232 be_mcc_notify(phba, tag); 233 mutex_unlock(&ctrl->mbox_lock); 234 return tag; 235 } 236 237 unsigned int mgmt_get_boot_target(struct beiscsi_hba *phba) 238 { 239 struct be_ctrl_info *ctrl = &phba->ctrl; 240 struct be_mcc_wrb *wrb; 241 struct be_cmd_get_boot_target_req *req; 242 unsigned int tag; 243 244 beiscsi_log(phba, KERN_INFO, 245 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX, 246 "BG_%d : In bescsi_get_boot_target\n"); 247 248 mutex_lock(&ctrl->mbox_lock); 249 wrb = alloc_mcc_wrb(phba, &tag); 250 if (!wrb) { 251 mutex_unlock(&ctrl->mbox_lock); 252 return 0; 253 } 254 255 req = embedded_payload(wrb); 256 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 257 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 258 OPCODE_ISCSI_INI_BOOT_GET_BOOT_TARGET, 259 sizeof(struct be_cmd_get_boot_target_resp)); 260 261 be_mcc_notify(phba, tag); 262 mutex_unlock(&ctrl->mbox_lock); 263 return tag; 264 } 265 266 unsigned int mgmt_get_session_info(struct beiscsi_hba *phba, 267 u32 boot_session_handle, 268 struct be_dma_mem *nonemb_cmd) 269 { 270 struct be_ctrl_info *ctrl = &phba->ctrl; 271 struct be_mcc_wrb *wrb; 272 unsigned int tag; 273 struct be_cmd_get_session_req *req; 274 struct be_cmd_get_session_resp *resp; 275 struct be_sge *sge; 276 277 beiscsi_log(phba, KERN_INFO, 278 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX, 279 "BG_%d : In beiscsi_get_session_info\n"); 280 281 mutex_lock(&ctrl->mbox_lock); 282 wrb = alloc_mcc_wrb(phba, &tag); 283 if (!wrb) { 284 mutex_unlock(&ctrl->mbox_lock); 285 return 0; 286 } 287 288 nonemb_cmd->size = sizeof(*resp); 289 req = nonemb_cmd->va; 290 memset(req, 0, sizeof(*req)); 291 sge = nonembedded_sgl(wrb); 292 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1); 293 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 294 OPCODE_ISCSI_INI_SESSION_GET_A_SESSION, 295 sizeof(*resp)); 296 req->session_handle = boot_session_handle; 297 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 298 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 299 sge->len = cpu_to_le32(nonemb_cmd->size); 300 301 be_mcc_notify(phba, tag); 302 mutex_unlock(&ctrl->mbox_lock); 303 return tag; 304 } 305 306 /** 307 * mgmt_get_port_name()- Get port name for the function 308 * @ctrl: ptr to Ctrl Info 309 * @phba: ptr to the dev priv structure 310 * 311 * Get the alphanumeric character for port 312 * 313 **/ 314 int mgmt_get_port_name(struct be_ctrl_info *ctrl, 315 struct beiscsi_hba *phba) 316 { 317 int ret = 0; 318 struct be_mcc_wrb *wrb; 319 struct be_cmd_get_port_name *ioctl; 320 321 mutex_lock(&ctrl->mbox_lock); 322 wrb = wrb_from_mbox(&ctrl->mbox_mem); 323 memset(wrb, 0, sizeof(*wrb)); 324 ioctl = embedded_payload(wrb); 325 326 be_wrb_hdr_prepare(wrb, sizeof(*ioctl), true, 0); 327 be_cmd_hdr_prepare(&ioctl->h.req_hdr, CMD_SUBSYSTEM_COMMON, 328 OPCODE_COMMON_GET_PORT_NAME, 329 EMBED_MBX_MAX_PAYLOAD_SIZE); 330 ret = be_mbox_notify(ctrl); 331 phba->port_name = 0; 332 if (!ret) { 333 phba->port_name = ioctl->p.resp.port_names >> 334 (phba->fw_config.phys_port * 8) & 0xff; 335 } else { 336 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, 337 "BG_%d : GET_PORT_NAME ret 0x%x status 0x%x\n", 338 ret, ioctl->h.resp_hdr.status); 339 } 340 341 if (phba->port_name == 0) 342 phba->port_name = '?'; 343 344 mutex_unlock(&ctrl->mbox_lock); 345 return ret; 346 } 347 348 /** 349 * mgmt_get_fw_config()- Get the FW config for the function 350 * @ctrl: ptr to Ctrl Info 351 * @phba: ptr to the dev priv structure 352 * 353 * Get the FW config and resources available for the function. 354 * The resources are created based on the count received here. 355 * 356 * return 357 * Success: 0 358 * Failure: Non-Zero Value 359 **/ 360 int mgmt_get_fw_config(struct be_ctrl_info *ctrl, 361 struct beiscsi_hba *phba) 362 { 363 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); 364 struct be_fw_cfg *pfw_cfg = embedded_payload(wrb); 365 uint32_t cid_count, icd_count; 366 int status = -EINVAL; 367 uint8_t ulp_num = 0; 368 369 mutex_lock(&ctrl->mbox_lock); 370 memset(wrb, 0, sizeof(*wrb)); 371 be_wrb_hdr_prepare(wrb, sizeof(*pfw_cfg), true, 0); 372 373 be_cmd_hdr_prepare(&pfw_cfg->hdr, CMD_SUBSYSTEM_COMMON, 374 OPCODE_COMMON_QUERY_FIRMWARE_CONFIG, 375 EMBED_MBX_MAX_PAYLOAD_SIZE); 376 377 if (be_mbox_notify(ctrl)) { 378 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, 379 "BG_%d : Failed in mgmt_get_fw_config\n"); 380 goto fail_init; 381 } 382 383 /* FW response formats depend on port id */ 384 phba->fw_config.phys_port = pfw_cfg->phys_port; 385 if (phba->fw_config.phys_port >= BEISCSI_PHYS_PORT_MAX) { 386 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, 387 "BG_%d : invalid physical port id %d\n", 388 phba->fw_config.phys_port); 389 goto fail_init; 390 } 391 392 /* populate and check FW config against min and max values */ 393 if (!is_chip_be2_be3r(phba)) { 394 phba->fw_config.eqid_count = pfw_cfg->eqid_count; 395 phba->fw_config.cqid_count = pfw_cfg->cqid_count; 396 if (phba->fw_config.eqid_count == 0 || 397 phba->fw_config.eqid_count > 2048) { 398 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, 399 "BG_%d : invalid EQ count %d\n", 400 phba->fw_config.eqid_count); 401 goto fail_init; 402 } 403 if (phba->fw_config.cqid_count == 0 || 404 phba->fw_config.cqid_count > 4096) { 405 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, 406 "BG_%d : invalid CQ count %d\n", 407 phba->fw_config.cqid_count); 408 goto fail_init; 409 } 410 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, 411 "BG_%d : EQ_Count : %d CQ_Count : %d\n", 412 phba->fw_config.eqid_count, 413 phba->fw_config.cqid_count); 414 } 415 416 /** 417 * Check on which all ULP iSCSI Protocol is loaded. 418 * Set the Bit for those ULP. This set flag is used 419 * at all places in the code to check on which ULP 420 * iSCSi Protocol is loaded 421 **/ 422 for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) { 423 if (pfw_cfg->ulp[ulp_num].ulp_mode & 424 BEISCSI_ULP_ISCSI_INI_MODE) { 425 set_bit(ulp_num, &phba->fw_config.ulp_supported); 426 427 /* Get the CID, ICD and Chain count for each ULP */ 428 phba->fw_config.iscsi_cid_start[ulp_num] = 429 pfw_cfg->ulp[ulp_num].sq_base; 430 phba->fw_config.iscsi_cid_count[ulp_num] = 431 pfw_cfg->ulp[ulp_num].sq_count; 432 433 phba->fw_config.iscsi_icd_start[ulp_num] = 434 pfw_cfg->ulp[ulp_num].icd_base; 435 phba->fw_config.iscsi_icd_count[ulp_num] = 436 pfw_cfg->ulp[ulp_num].icd_count; 437 438 phba->fw_config.iscsi_chain_start[ulp_num] = 439 pfw_cfg->chain_icd[ulp_num].chain_base; 440 phba->fw_config.iscsi_chain_count[ulp_num] = 441 pfw_cfg->chain_icd[ulp_num].chain_count; 442 443 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, 444 "BG_%d : Function loaded on ULP : %d\n" 445 "\tiscsi_cid_count : %d\n" 446 "\tiscsi_cid_start : %d\n" 447 "\t iscsi_icd_count : %d\n" 448 "\t iscsi_icd_start : %d\n", 449 ulp_num, 450 phba->fw_config. 451 iscsi_cid_count[ulp_num], 452 phba->fw_config. 453 iscsi_cid_start[ulp_num], 454 phba->fw_config. 455 iscsi_icd_count[ulp_num], 456 phba->fw_config. 457 iscsi_icd_start[ulp_num]); 458 } 459 } 460 461 if (phba->fw_config.ulp_supported == 0) { 462 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, 463 "BG_%d : iSCSI initiator mode not set: ULP0 %x ULP1 %x\n", 464 pfw_cfg->ulp[BEISCSI_ULP0].ulp_mode, 465 pfw_cfg->ulp[BEISCSI_ULP1].ulp_mode); 466 goto fail_init; 467 } 468 469 /** 470 * ICD is shared among ULPs. Use icd_count of any one loaded ULP 471 **/ 472 for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) 473 if (test_bit(ulp_num, &phba->fw_config.ulp_supported)) 474 break; 475 icd_count = phba->fw_config.iscsi_icd_count[ulp_num]; 476 if (icd_count == 0 || icd_count > 65536) { 477 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, 478 "BG_%d: invalid ICD count %d\n", icd_count); 479 goto fail_init; 480 } 481 482 cid_count = BEISCSI_GET_CID_COUNT(phba, BEISCSI_ULP0) + 483 BEISCSI_GET_CID_COUNT(phba, BEISCSI_ULP1); 484 if (cid_count == 0 || cid_count > 4096) { 485 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, 486 "BG_%d: invalid CID count %d\n", cid_count); 487 goto fail_init; 488 } 489 490 /** 491 * Check FW is dual ULP aware i.e. can handle either 492 * of the protocols. 493 */ 494 phba->fw_config.dual_ulp_aware = (pfw_cfg->function_mode & 495 BEISCSI_FUNC_DUA_MODE); 496 497 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, 498 "BG_%d : DUA Mode : 0x%x\n", 499 phba->fw_config.dual_ulp_aware); 500 501 /* all set, continue using this FW config */ 502 status = 0; 503 fail_init: 504 mutex_unlock(&ctrl->mbox_lock); 505 return status; 506 } 507 508 int mgmt_check_supported_fw(struct be_ctrl_info *ctrl, 509 struct beiscsi_hba *phba) 510 { 511 struct be_dma_mem nonemb_cmd; 512 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); 513 struct be_mgmt_controller_attributes *req; 514 struct be_sge *sge = nonembedded_sgl(wrb); 515 int status = 0; 516 517 nonemb_cmd.va = pci_alloc_consistent(ctrl->pdev, 518 sizeof(struct be_mgmt_controller_attributes), 519 &nonemb_cmd.dma); 520 if (nonemb_cmd.va == NULL) { 521 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, 522 "BG_%d : Failed to allocate memory for " 523 "mgmt_check_supported_fw\n"); 524 return -ENOMEM; 525 } 526 nonemb_cmd.size = sizeof(struct be_mgmt_controller_attributes); 527 req = nonemb_cmd.va; 528 memset(req, 0, sizeof(*req)); 529 mutex_lock(&ctrl->mbox_lock); 530 memset(wrb, 0, sizeof(*wrb)); 531 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1); 532 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON, 533 OPCODE_COMMON_GET_CNTL_ATTRIBUTES, sizeof(*req)); 534 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd.dma)); 535 sge->pa_lo = cpu_to_le32(nonemb_cmd.dma & 0xFFFFFFFF); 536 sge->len = cpu_to_le32(nonemb_cmd.size); 537 status = be_mbox_notify(ctrl); 538 if (!status) { 539 struct be_mgmt_controller_attributes_resp *resp = nonemb_cmd.va; 540 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, 541 "BG_%d : Firmware Version of CMD : %s\n" 542 "Firmware Version is : %s\n" 543 "Developer Build, not performing version check...\n", 544 resp->params.hba_attribs 545 .flashrom_version_string, 546 resp->params.hba_attribs. 547 firmware_version_string); 548 549 phba->fw_config.iscsi_features = 550 resp->params.hba_attribs.iscsi_features; 551 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, 552 "BM_%d : phba->fw_config.iscsi_features = %d\n", 553 phba->fw_config.iscsi_features); 554 memcpy(phba->fw_ver_str, resp->params.hba_attribs. 555 firmware_version_string, BEISCSI_VER_STRLEN); 556 } else 557 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, 558 "BG_%d : Failed in mgmt_check_supported_fw\n"); 559 mutex_unlock(&ctrl->mbox_lock); 560 if (nonemb_cmd.va) 561 pci_free_consistent(ctrl->pdev, nonemb_cmd.size, 562 nonemb_cmd.va, nonemb_cmd.dma); 563 564 return status; 565 } 566 567 unsigned int mgmt_vendor_specific_fw_cmd(struct be_ctrl_info *ctrl, 568 struct beiscsi_hba *phba, 569 struct bsg_job *job, 570 struct be_dma_mem *nonemb_cmd) 571 { 572 struct be_cmd_resp_hdr *resp; 573 struct be_mcc_wrb *wrb; 574 struct be_sge *mcc_sge; 575 unsigned int tag = 0; 576 struct iscsi_bsg_request *bsg_req = job->request; 577 struct be_bsg_vendor_cmd *req = nonemb_cmd->va; 578 unsigned short region, sector_size, sector, offset; 579 580 nonemb_cmd->size = job->request_payload.payload_len; 581 memset(nonemb_cmd->va, 0, nonemb_cmd->size); 582 resp = nonemb_cmd->va; 583 region = bsg_req->rqst_data.h_vendor.vendor_cmd[1]; 584 sector_size = bsg_req->rqst_data.h_vendor.vendor_cmd[2]; 585 sector = bsg_req->rqst_data.h_vendor.vendor_cmd[3]; 586 offset = bsg_req->rqst_data.h_vendor.vendor_cmd[4]; 587 req->region = region; 588 req->sector = sector; 589 req->offset = offset; 590 591 if (mutex_lock_interruptible(&ctrl->mbox_lock)) 592 return 0; 593 switch (bsg_req->rqst_data.h_vendor.vendor_cmd[0]) { 594 case BEISCSI_WRITE_FLASH: 595 offset = sector * sector_size + offset; 596 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 597 OPCODE_COMMON_WRITE_FLASH, sizeof(*req)); 598 sg_copy_to_buffer(job->request_payload.sg_list, 599 job->request_payload.sg_cnt, 600 nonemb_cmd->va + offset, job->request_len); 601 break; 602 case BEISCSI_READ_FLASH: 603 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 604 OPCODE_COMMON_READ_FLASH, sizeof(*req)); 605 break; 606 default: 607 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 608 "BG_%d : Unsupported cmd = 0x%x\n\n", 609 bsg_req->rqst_data.h_vendor.vendor_cmd[0]); 610 611 mutex_unlock(&ctrl->mbox_lock); 612 return -ENOSYS; 613 } 614 615 wrb = alloc_mcc_wrb(phba, &tag); 616 if (!wrb) { 617 mutex_unlock(&ctrl->mbox_lock); 618 return 0; 619 } 620 621 mcc_sge = nonembedded_sgl(wrb); 622 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false, 623 job->request_payload.sg_cnt); 624 mcc_sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 625 mcc_sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 626 mcc_sge->len = cpu_to_le32(nonemb_cmd->size); 627 628 be_mcc_notify(phba, tag); 629 630 mutex_unlock(&ctrl->mbox_lock); 631 return tag; 632 } 633 634 /** 635 * mgmt_epfw_cleanup()- Inform FW to cleanup data structures. 636 * @phba: pointer to dev priv structure 637 * @ulp_num: ULP number. 638 * 639 * return 640 * Success: 0 641 * Failure: Non-Zero Value 642 **/ 643 int mgmt_epfw_cleanup(struct beiscsi_hba *phba, unsigned short ulp_num) 644 { 645 struct be_ctrl_info *ctrl = &phba->ctrl; 646 struct be_mcc_wrb *wrb; 647 struct iscsi_cleanup_req *req; 648 unsigned int tag; 649 int status; 650 651 mutex_lock(&ctrl->mbox_lock); 652 wrb = alloc_mcc_wrb(phba, &tag); 653 if (!wrb) { 654 mutex_unlock(&ctrl->mbox_lock); 655 return -EBUSY; 656 } 657 658 req = embedded_payload(wrb); 659 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 660 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 661 OPCODE_COMMON_ISCSI_CLEANUP, sizeof(*req)); 662 663 req->chute = (1 << ulp_num); 664 req->hdr_ring_id = cpu_to_le16(HWI_GET_DEF_HDRQ_ID(phba, ulp_num)); 665 req->data_ring_id = cpu_to_le16(HWI_GET_DEF_BUFQ_ID(phba, ulp_num)); 666 667 be_mcc_notify(phba, tag); 668 status = be_mcc_compl_poll(phba, tag); 669 if (status) 670 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT, 671 "BG_%d : mgmt_epfw_cleanup , FAILED\n"); 672 mutex_unlock(&ctrl->mbox_lock); 673 return status; 674 } 675 676 unsigned int mgmt_invalidate_icds(struct beiscsi_hba *phba, 677 struct invalidate_command_table *inv_tbl, 678 unsigned int num_invalidate, unsigned int cid, 679 struct be_dma_mem *nonemb_cmd) 680 681 { 682 struct be_ctrl_info *ctrl = &phba->ctrl; 683 struct be_mcc_wrb *wrb; 684 struct be_sge *sge; 685 struct invalidate_commands_params_in *req; 686 unsigned int i, tag; 687 688 mutex_lock(&ctrl->mbox_lock); 689 wrb = alloc_mcc_wrb(phba, &tag); 690 if (!wrb) { 691 mutex_unlock(&ctrl->mbox_lock); 692 return 0; 693 } 694 695 req = nonemb_cmd->va; 696 memset(req, 0, sizeof(*req)); 697 sge = nonembedded_sgl(wrb); 698 699 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1); 700 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 701 OPCODE_COMMON_ISCSI_ERROR_RECOVERY_INVALIDATE_COMMANDS, 702 sizeof(*req)); 703 req->ref_handle = 0; 704 req->cleanup_type = CMD_ISCSI_COMMAND_INVALIDATE; 705 for (i = 0; i < num_invalidate; i++) { 706 req->table[i].icd = inv_tbl->icd; 707 req->table[i].cid = inv_tbl->cid; 708 req->icd_count++; 709 inv_tbl++; 710 } 711 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 712 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 713 sge->len = cpu_to_le32(nonemb_cmd->size); 714 715 be_mcc_notify(phba, tag); 716 mutex_unlock(&ctrl->mbox_lock); 717 return tag; 718 } 719 720 unsigned int mgmt_invalidate_connection(struct beiscsi_hba *phba, 721 struct beiscsi_endpoint *beiscsi_ep, 722 unsigned short cid, 723 unsigned short issue_reset, 724 unsigned short savecfg_flag) 725 { 726 struct be_ctrl_info *ctrl = &phba->ctrl; 727 struct be_mcc_wrb *wrb; 728 struct iscsi_invalidate_connection_params_in *req; 729 unsigned int tag = 0; 730 731 mutex_lock(&ctrl->mbox_lock); 732 wrb = alloc_mcc_wrb(phba, &tag); 733 if (!wrb) { 734 mutex_unlock(&ctrl->mbox_lock); 735 return 0; 736 } 737 738 req = embedded_payload(wrb); 739 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 740 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 741 OPCODE_ISCSI_INI_DRIVER_INVALIDATE_CONNECTION, 742 sizeof(*req)); 743 req->session_handle = beiscsi_ep->fw_handle; 744 req->cid = cid; 745 if (issue_reset) 746 req->cleanup_type = CMD_ISCSI_CONNECTION_ISSUE_TCP_RST; 747 else 748 req->cleanup_type = CMD_ISCSI_CONNECTION_INVALIDATE; 749 req->save_cfg = savecfg_flag; 750 be_mcc_notify(phba, tag); 751 mutex_unlock(&ctrl->mbox_lock); 752 return tag; 753 } 754 755 unsigned int mgmt_upload_connection(struct beiscsi_hba *phba, 756 unsigned short cid, unsigned int upload_flag) 757 { 758 struct be_ctrl_info *ctrl = &phba->ctrl; 759 struct be_mcc_wrb *wrb; 760 struct tcp_upload_params_in *req; 761 unsigned int tag; 762 763 mutex_lock(&ctrl->mbox_lock); 764 wrb = alloc_mcc_wrb(phba, &tag); 765 if (!wrb) { 766 mutex_unlock(&ctrl->mbox_lock); 767 return 0; 768 } 769 770 req = embedded_payload(wrb); 771 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 772 be_cmd_hdr_prepare(&req->hdr, CMD_COMMON_TCP_UPLOAD, 773 OPCODE_COMMON_TCP_UPLOAD, sizeof(*req)); 774 req->id = (unsigned short)cid; 775 req->upload_type = (unsigned char)upload_flag; 776 be_mcc_notify(phba, tag); 777 mutex_unlock(&ctrl->mbox_lock); 778 return tag; 779 } 780 781 /** 782 * mgmt_open_connection()- Establish a TCP CXN 783 * @dst_addr: Destination Address 784 * @beiscsi_ep: ptr to device endpoint struct 785 * @nonemb_cmd: ptr to memory allocated for command 786 * 787 * return 788 * Success: Tag number of the MBX Command issued 789 * Failure: Error code 790 **/ 791 int mgmt_open_connection(struct beiscsi_hba *phba, 792 struct sockaddr *dst_addr, 793 struct beiscsi_endpoint *beiscsi_ep, 794 struct be_dma_mem *nonemb_cmd) 795 { 796 struct hwi_controller *phwi_ctrlr; 797 struct hwi_context_memory *phwi_context; 798 struct sockaddr_in *daddr_in = (struct sockaddr_in *)dst_addr; 799 struct sockaddr_in6 *daddr_in6 = (struct sockaddr_in6 *)dst_addr; 800 struct be_ctrl_info *ctrl = &phba->ctrl; 801 struct be_mcc_wrb *wrb; 802 struct tcp_connect_and_offload_in_v1 *req; 803 unsigned short def_hdr_id; 804 unsigned short def_data_id; 805 struct phys_addr template_address = { 0, 0 }; 806 struct phys_addr *ptemplate_address; 807 unsigned int tag = 0; 808 unsigned int i, ulp_num; 809 unsigned short cid = beiscsi_ep->ep_cid; 810 struct be_sge *sge; 811 812 if (dst_addr->sa_family != PF_INET && dst_addr->sa_family != PF_INET6) { 813 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG, 814 "BG_%d : unknown addr family %d\n", 815 dst_addr->sa_family); 816 return -EINVAL; 817 } 818 819 phwi_ctrlr = phba->phwi_ctrlr; 820 phwi_context = phwi_ctrlr->phwi_ctxt; 821 822 ulp_num = phwi_ctrlr->wrb_context[BE_GET_CRI_FROM_CID(cid)].ulp_num; 823 824 def_hdr_id = (unsigned short)HWI_GET_DEF_HDRQ_ID(phba, ulp_num); 825 def_data_id = (unsigned short)HWI_GET_DEF_BUFQ_ID(phba, ulp_num); 826 827 ptemplate_address = &template_address; 828 ISCSI_GET_PDU_TEMPLATE_ADDRESS(phba, ptemplate_address); 829 if (mutex_lock_interruptible(&ctrl->mbox_lock)) 830 return 0; 831 wrb = alloc_mcc_wrb(phba, &tag); 832 if (!wrb) { 833 mutex_unlock(&ctrl->mbox_lock); 834 return 0; 835 } 836 837 sge = nonembedded_sgl(wrb); 838 req = nonemb_cmd->va; 839 memset(req, 0, sizeof(*req)); 840 841 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false, 1); 842 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 843 OPCODE_COMMON_ISCSI_TCP_CONNECT_AND_OFFLOAD, 844 nonemb_cmd->size); 845 if (dst_addr->sa_family == PF_INET) { 846 __be32 s_addr = daddr_in->sin_addr.s_addr; 847 req->ip_address.ip_type = BE2_IPV4; 848 req->ip_address.addr[0] = s_addr & 0x000000ff; 849 req->ip_address.addr[1] = (s_addr & 0x0000ff00) >> 8; 850 req->ip_address.addr[2] = (s_addr & 0x00ff0000) >> 16; 851 req->ip_address.addr[3] = (s_addr & 0xff000000) >> 24; 852 req->tcp_port = ntohs(daddr_in->sin_port); 853 beiscsi_ep->dst_addr = daddr_in->sin_addr.s_addr; 854 beiscsi_ep->dst_tcpport = ntohs(daddr_in->sin_port); 855 beiscsi_ep->ip_type = BE2_IPV4; 856 } else { 857 /* else its PF_INET6 family */ 858 req->ip_address.ip_type = BE2_IPV6; 859 memcpy(&req->ip_address.addr, 860 &daddr_in6->sin6_addr.in6_u.u6_addr8, 16); 861 req->tcp_port = ntohs(daddr_in6->sin6_port); 862 beiscsi_ep->dst_tcpport = ntohs(daddr_in6->sin6_port); 863 memcpy(&beiscsi_ep->dst6_addr, 864 &daddr_in6->sin6_addr.in6_u.u6_addr8, 16); 865 beiscsi_ep->ip_type = BE2_IPV6; 866 } 867 req->cid = cid; 868 i = phba->nxt_cqid++; 869 if (phba->nxt_cqid == phba->num_cpus) 870 phba->nxt_cqid = 0; 871 req->cq_id = phwi_context->be_cq[i].id; 872 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG, 873 "BG_%d : i=%d cq_id=%d\n", i, req->cq_id); 874 req->defq_id = def_hdr_id; 875 req->hdr_ring_id = def_hdr_id; 876 req->data_ring_id = def_data_id; 877 req->do_offload = 1; 878 req->dataout_template_pa.lo = ptemplate_address->lo; 879 req->dataout_template_pa.hi = ptemplate_address->hi; 880 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 881 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 882 sge->len = cpu_to_le32(nonemb_cmd->size); 883 884 if (!is_chip_be2_be3r(phba)) { 885 req->hdr.version = MBX_CMD_VER1; 886 req->tcp_window_size = 0; 887 req->tcp_window_scale_count = 2; 888 } 889 890 be_mcc_notify(phba, tag); 891 mutex_unlock(&ctrl->mbox_lock); 892 return tag; 893 } 894 895 unsigned int mgmt_get_all_if_id(struct beiscsi_hba *phba) 896 { 897 struct be_ctrl_info *ctrl = &phba->ctrl; 898 struct be_mcc_wrb *wrb; 899 struct be_cmd_get_all_if_id_req *req; 900 struct be_cmd_get_all_if_id_req *pbe_allid; 901 unsigned int tag; 902 int status = 0; 903 904 if (mutex_lock_interruptible(&ctrl->mbox_lock)) 905 return -EINTR; 906 wrb = alloc_mcc_wrb(phba, &tag); 907 if (!wrb) { 908 mutex_unlock(&ctrl->mbox_lock); 909 return -ENOMEM; 910 } 911 912 req = embedded_payload(wrb); 913 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 914 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 915 OPCODE_COMMON_ISCSI_NTWK_GET_ALL_IF_ID, 916 sizeof(*req)); 917 be_mcc_notify(phba, tag); 918 mutex_unlock(&ctrl->mbox_lock); 919 920 status = beiscsi_mccq_compl_wait(phba, tag, &wrb, NULL); 921 if (status) { 922 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 923 "BG_%d : Failed in mgmt_get_all_if_id\n"); 924 return -EBUSY; 925 } 926 927 pbe_allid = embedded_payload(wrb); 928 phba->interface_handle = pbe_allid->if_hndl_list[0]; 929 930 return status; 931 } 932 933 /* 934 * mgmt_exec_nonemb_cmd()- Execute Non Embedded MBX Cmd 935 * @phba: Driver priv structure 936 * @nonemb_cmd: Address of the MBX command issued 937 * @resp_buf: Buffer to copy the MBX cmd response 938 * @resp_buf_len: respone lenght to be copied 939 * 940 **/ 941 static int mgmt_exec_nonemb_cmd(struct beiscsi_hba *phba, 942 struct be_dma_mem *nonemb_cmd, void *resp_buf, 943 int resp_buf_len) 944 { 945 struct be_ctrl_info *ctrl = &phba->ctrl; 946 struct be_mcc_wrb *wrb; 947 struct be_sge *sge; 948 unsigned int tag; 949 int rc = 0; 950 951 mutex_lock(&ctrl->mbox_lock); 952 wrb = alloc_mcc_wrb(phba, &tag); 953 if (!wrb) { 954 mutex_unlock(&ctrl->mbox_lock); 955 rc = -ENOMEM; 956 goto free_cmd; 957 } 958 959 sge = nonembedded_sgl(wrb); 960 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false, 1); 961 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 962 sge->pa_lo = cpu_to_le32(lower_32_bits(nonemb_cmd->dma)); 963 sge->len = cpu_to_le32(nonemb_cmd->size); 964 965 be_mcc_notify(phba, tag); 966 mutex_unlock(&ctrl->mbox_lock); 967 968 rc = beiscsi_mccq_compl_wait(phba, tag, NULL, nonemb_cmd); 969 970 if (resp_buf) 971 memcpy(resp_buf, nonemb_cmd->va, resp_buf_len); 972 973 if (rc) { 974 /* Check if the MBX Cmd needs to be re-issued */ 975 if (rc == -EAGAIN) 976 return rc; 977 978 beiscsi_log(phba, KERN_WARNING, 979 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX, 980 "BG_%d : mgmt_exec_nonemb_cmd Failed status\n"); 981 982 if (rc != -EBUSY) 983 goto free_cmd; 984 else 985 return rc; 986 } 987 free_cmd: 988 pci_free_consistent(ctrl->pdev, nonemb_cmd->size, 989 nonemb_cmd->va, nonemb_cmd->dma); 990 return rc; 991 } 992 993 static int mgmt_alloc_cmd_data(struct beiscsi_hba *phba, struct be_dma_mem *cmd, 994 int iscsi_cmd, int size) 995 { 996 cmd->va = pci_zalloc_consistent(phba->ctrl.pdev, size, &cmd->dma); 997 if (!cmd->va) { 998 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG, 999 "BG_%d : Failed to allocate memory for if info\n"); 1000 return -ENOMEM; 1001 } 1002 cmd->size = size; 1003 be_cmd_hdr_prepare(cmd->va, CMD_SUBSYSTEM_ISCSI, iscsi_cmd, size); 1004 return 0; 1005 } 1006 1007 static int 1008 mgmt_static_ip_modify(struct beiscsi_hba *phba, 1009 struct be_cmd_get_if_info_resp *if_info, 1010 struct iscsi_iface_param_info *ip_param, 1011 struct iscsi_iface_param_info *subnet_param, 1012 uint32_t ip_action) 1013 { 1014 struct be_cmd_set_ip_addr_req *req; 1015 struct be_dma_mem nonemb_cmd; 1016 uint32_t ip_type; 1017 int rc; 1018 1019 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1020 OPCODE_COMMON_ISCSI_NTWK_MODIFY_IP_ADDR, 1021 sizeof(*req)); 1022 if (rc) 1023 return rc; 1024 1025 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ? 1026 BE2_IPV6 : BE2_IPV4 ; 1027 1028 req = nonemb_cmd.va; 1029 req->ip_params.record_entry_count = 1; 1030 req->ip_params.ip_record.action = ip_action; 1031 req->ip_params.ip_record.interface_hndl = 1032 phba->interface_handle; 1033 req->ip_params.ip_record.ip_addr.size_of_structure = 1034 sizeof(struct be_ip_addr_subnet_format); 1035 req->ip_params.ip_record.ip_addr.ip_type = ip_type; 1036 1037 if (ip_action == IP_ACTION_ADD) { 1038 memcpy(req->ip_params.ip_record.ip_addr.addr, ip_param->value, 1039 sizeof(req->ip_params.ip_record.ip_addr.addr)); 1040 1041 if (subnet_param) 1042 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask, 1043 subnet_param->value, 1044 sizeof(req->ip_params.ip_record.ip_addr.subnet_mask)); 1045 } else { 1046 memcpy(req->ip_params.ip_record.ip_addr.addr, 1047 if_info->ip_addr.addr, 1048 sizeof(req->ip_params.ip_record.ip_addr.addr)); 1049 1050 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask, 1051 if_info->ip_addr.subnet_mask, 1052 sizeof(req->ip_params.ip_record.ip_addr.subnet_mask)); 1053 } 1054 1055 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 1056 if (rc < 0) 1057 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1058 "BG_%d : Failed to Modify existing IP Address\n"); 1059 return rc; 1060 } 1061 1062 static int mgmt_modify_gateway(struct beiscsi_hba *phba, uint8_t *gt_addr, 1063 uint32_t gtway_action, uint32_t param_len) 1064 { 1065 struct be_cmd_set_def_gateway_req *req; 1066 struct be_dma_mem nonemb_cmd; 1067 int rt_val; 1068 1069 1070 rt_val = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1071 OPCODE_COMMON_ISCSI_NTWK_MODIFY_DEFAULT_GATEWAY, 1072 sizeof(*req)); 1073 if (rt_val) 1074 return rt_val; 1075 1076 req = nonemb_cmd.va; 1077 req->action = gtway_action; 1078 req->ip_addr.ip_type = BE2_IPV4; 1079 1080 memcpy(req->ip_addr.addr, gt_addr, sizeof(req->ip_addr.addr)); 1081 1082 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 1083 } 1084 1085 int mgmt_set_ip(struct beiscsi_hba *phba, 1086 struct iscsi_iface_param_info *ip_param, 1087 struct iscsi_iface_param_info *subnet_param, 1088 uint32_t boot_proto) 1089 { 1090 struct be_cmd_get_def_gateway_resp gtway_addr_set; 1091 struct be_cmd_get_if_info_resp *if_info; 1092 struct be_cmd_set_dhcp_req *dhcpreq; 1093 struct be_cmd_rel_dhcp_req *reldhcp; 1094 struct be_dma_mem nonemb_cmd; 1095 uint8_t *gtway_addr; 1096 uint32_t ip_type; 1097 int rc; 1098 1099 rc = mgmt_get_all_if_id(phba); 1100 if (rc) 1101 return rc; 1102 1103 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ? 1104 BE2_IPV6 : BE2_IPV4 ; 1105 1106 rc = mgmt_get_if_info(phba, ip_type, &if_info); 1107 if (rc) 1108 return rc; 1109 1110 if (boot_proto == ISCSI_BOOTPROTO_DHCP) { 1111 if (if_info->dhcp_state) { 1112 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1113 "BG_%d : DHCP Already Enabled\n"); 1114 goto exit; 1115 } 1116 /* The ip_param->len is 1 in DHCP case. Setting 1117 proper IP len as this it is used while 1118 freeing the Static IP. 1119 */ 1120 ip_param->len = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ? 1121 IP_V6_LEN : IP_V4_LEN; 1122 1123 } else { 1124 if (if_info->dhcp_state) { 1125 1126 memset(if_info, 0, sizeof(*if_info)); 1127 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1128 OPCODE_COMMON_ISCSI_NTWK_REL_STATELESS_IP_ADDR, 1129 sizeof(*reldhcp)); 1130 1131 if (rc) 1132 goto exit; 1133 1134 reldhcp = nonemb_cmd.va; 1135 reldhcp->interface_hndl = phba->interface_handle; 1136 reldhcp->ip_type = ip_type; 1137 1138 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 1139 if (rc < 0) { 1140 beiscsi_log(phba, KERN_WARNING, 1141 BEISCSI_LOG_CONFIG, 1142 "BG_%d : Failed to Delete existing dhcp\n"); 1143 goto exit; 1144 } 1145 } 1146 } 1147 1148 /* Delete the Static IP Set */ 1149 if (if_info->ip_addr.addr[0]) { 1150 rc = mgmt_static_ip_modify(phba, if_info, ip_param, NULL, 1151 IP_ACTION_DEL); 1152 if (rc) 1153 goto exit; 1154 } 1155 1156 /* Delete the Gateway settings if mode change is to DHCP */ 1157 if (boot_proto == ISCSI_BOOTPROTO_DHCP) { 1158 memset(>way_addr_set, 0, sizeof(gtway_addr_set)); 1159 rc = mgmt_get_gateway(phba, BE2_IPV4, >way_addr_set); 1160 if (rc) { 1161 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1162 "BG_%d : Failed to Get Gateway Addr\n"); 1163 goto exit; 1164 } 1165 1166 if (gtway_addr_set.ip_addr.addr[0]) { 1167 gtway_addr = (uint8_t *)>way_addr_set.ip_addr.addr; 1168 rc = mgmt_modify_gateway(phba, gtway_addr, 1169 IP_ACTION_DEL, IP_V4_LEN); 1170 1171 if (rc) { 1172 beiscsi_log(phba, KERN_WARNING, 1173 BEISCSI_LOG_CONFIG, 1174 "BG_%d : Failed to clear Gateway Addr Set\n"); 1175 goto exit; 1176 } 1177 } 1178 } 1179 1180 /* Set Adapter to DHCP/Static Mode */ 1181 if (boot_proto == ISCSI_BOOTPROTO_DHCP) { 1182 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1183 OPCODE_COMMON_ISCSI_NTWK_CONFIG_STATELESS_IP_ADDR, 1184 sizeof(*dhcpreq)); 1185 if (rc) 1186 goto exit; 1187 1188 dhcpreq = nonemb_cmd.va; 1189 dhcpreq->flags = BLOCKING; 1190 dhcpreq->retry_count = 1; 1191 dhcpreq->interface_hndl = phba->interface_handle; 1192 dhcpreq->ip_type = BE2_DHCP_V4; 1193 1194 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 1195 } else { 1196 rc = mgmt_static_ip_modify(phba, if_info, ip_param, 1197 subnet_param, IP_ACTION_ADD); 1198 } 1199 1200 exit: 1201 kfree(if_info); 1202 return rc; 1203 } 1204 1205 int mgmt_set_gateway(struct beiscsi_hba *phba, 1206 struct iscsi_iface_param_info *gateway_param) 1207 { 1208 struct be_cmd_get_def_gateway_resp gtway_addr_set; 1209 uint8_t *gtway_addr; 1210 int rt_val; 1211 1212 memset(>way_addr_set, 0, sizeof(gtway_addr_set)); 1213 rt_val = mgmt_get_gateway(phba, BE2_IPV4, >way_addr_set); 1214 if (rt_val) { 1215 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1216 "BG_%d : Failed to Get Gateway Addr\n"); 1217 return rt_val; 1218 } 1219 1220 if (gtway_addr_set.ip_addr.addr[0]) { 1221 gtway_addr = (uint8_t *)>way_addr_set.ip_addr.addr; 1222 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_DEL, 1223 gateway_param->len); 1224 if (rt_val) { 1225 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1226 "BG_%d : Failed to clear Gateway Addr Set\n"); 1227 return rt_val; 1228 } 1229 } 1230 1231 gtway_addr = (uint8_t *)&gateway_param->value; 1232 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_ADD, 1233 gateway_param->len); 1234 1235 if (rt_val) 1236 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1237 "BG_%d : Failed to Set Gateway Addr\n"); 1238 1239 return rt_val; 1240 } 1241 1242 int mgmt_get_gateway(struct beiscsi_hba *phba, int ip_type, 1243 struct be_cmd_get_def_gateway_resp *gateway) 1244 { 1245 struct be_cmd_get_def_gateway_req *req; 1246 struct be_dma_mem nonemb_cmd; 1247 int rc; 1248 1249 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1250 OPCODE_COMMON_ISCSI_NTWK_GET_DEFAULT_GATEWAY, 1251 sizeof(*gateway)); 1252 if (rc) 1253 return rc; 1254 1255 req = nonemb_cmd.va; 1256 req->ip_type = ip_type; 1257 1258 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, gateway, 1259 sizeof(*gateway)); 1260 } 1261 1262 int mgmt_get_if_info(struct beiscsi_hba *phba, int ip_type, 1263 struct be_cmd_get_if_info_resp **if_info) 1264 { 1265 struct be_cmd_get_if_info_req *req; 1266 struct be_dma_mem nonemb_cmd; 1267 uint32_t ioctl_size = sizeof(struct be_cmd_get_if_info_resp); 1268 int rc; 1269 1270 rc = mgmt_get_all_if_id(phba); 1271 if (rc) 1272 return rc; 1273 1274 do { 1275 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1276 OPCODE_COMMON_ISCSI_NTWK_GET_IF_INFO, 1277 ioctl_size); 1278 if (rc) 1279 return rc; 1280 1281 req = nonemb_cmd.va; 1282 req->interface_hndl = phba->interface_handle; 1283 req->ip_type = ip_type; 1284 1285 /* Allocate memory for if_info */ 1286 *if_info = kzalloc(ioctl_size, GFP_KERNEL); 1287 if (!*if_info) { 1288 beiscsi_log(phba, KERN_ERR, 1289 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1290 "BG_%d : Memory Allocation Failure\n"); 1291 1292 /* Free the DMA memory for the IOCTL issuing */ 1293 pci_free_consistent(phba->ctrl.pdev, 1294 nonemb_cmd.size, 1295 nonemb_cmd.va, 1296 nonemb_cmd.dma); 1297 return -ENOMEM; 1298 } 1299 1300 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, *if_info, 1301 ioctl_size); 1302 1303 /* Check if the error is because of Insufficent_Buffer */ 1304 if (rc == -EAGAIN) { 1305 1306 /* Get the new memory size */ 1307 ioctl_size = ((struct be_cmd_resp_hdr *) 1308 nonemb_cmd.va)->actual_resp_len; 1309 ioctl_size += sizeof(struct be_cmd_req_hdr); 1310 1311 /* Free the previous allocated DMA memory */ 1312 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size, 1313 nonemb_cmd.va, 1314 nonemb_cmd.dma); 1315 1316 /* Free the virtual memory */ 1317 kfree(*if_info); 1318 } else 1319 break; 1320 } while (true); 1321 return rc; 1322 } 1323 1324 int mgmt_get_nic_conf(struct beiscsi_hba *phba, 1325 struct be_cmd_get_nic_conf_resp *nic) 1326 { 1327 struct be_dma_mem nonemb_cmd; 1328 int rc; 1329 1330 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1331 OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG, 1332 sizeof(*nic)); 1333 if (rc) 1334 return rc; 1335 1336 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, nic, sizeof(*nic)); 1337 } 1338 1339 1340 1341 unsigned int be_cmd_get_initname(struct beiscsi_hba *phba) 1342 { 1343 unsigned int tag; 1344 struct be_mcc_wrb *wrb; 1345 struct be_cmd_hba_name *req; 1346 struct be_ctrl_info *ctrl = &phba->ctrl; 1347 1348 if (mutex_lock_interruptible(&ctrl->mbox_lock)) 1349 return 0; 1350 wrb = alloc_mcc_wrb(phba, &tag); 1351 if (!wrb) { 1352 mutex_unlock(&ctrl->mbox_lock); 1353 return 0; 1354 } 1355 1356 req = embedded_payload(wrb); 1357 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 1358 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 1359 OPCODE_ISCSI_INI_CFG_GET_HBA_NAME, 1360 sizeof(*req)); 1361 1362 be_mcc_notify(phba, tag); 1363 mutex_unlock(&ctrl->mbox_lock); 1364 return tag; 1365 } 1366 1367 /** 1368 * be_mgmt_get_boot_shandle()- Get the session handle 1369 * @phba: device priv structure instance 1370 * @s_handle: session handle returned for boot session. 1371 * 1372 * Get the boot target session handle. In case of 1373 * crashdump mode driver has to issue and MBX Cmd 1374 * for FW to login to boot target 1375 * 1376 * return 1377 * Success: 0 1378 * Failure: Non-Zero value 1379 * 1380 **/ 1381 int be_mgmt_get_boot_shandle(struct beiscsi_hba *phba, 1382 unsigned int *s_handle) 1383 { 1384 struct be_cmd_get_boot_target_resp *boot_resp; 1385 struct be_mcc_wrb *wrb; 1386 unsigned int tag; 1387 uint8_t boot_retry = 3; 1388 int rc; 1389 1390 do { 1391 /* Get the Boot Target Session Handle and Count*/ 1392 tag = mgmt_get_boot_target(phba); 1393 if (!tag) { 1394 beiscsi_log(phba, KERN_ERR, 1395 BEISCSI_LOG_CONFIG | BEISCSI_LOG_INIT, 1396 "BG_%d : Getting Boot Target Info Failed\n"); 1397 return -EAGAIN; 1398 } 1399 1400 rc = beiscsi_mccq_compl_wait(phba, tag, &wrb, NULL); 1401 if (rc) { 1402 beiscsi_log(phba, KERN_ERR, 1403 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1404 "BG_%d : MBX CMD get_boot_target Failed\n"); 1405 return -EBUSY; 1406 } 1407 1408 boot_resp = embedded_payload(wrb); 1409 1410 /* Check if the there are any Boot targets configured */ 1411 if (!boot_resp->boot_session_count) { 1412 beiscsi_log(phba, KERN_INFO, 1413 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1414 "BG_%d ;No boot targets configured\n"); 1415 return -ENXIO; 1416 } 1417 1418 /* FW returns the session handle of the boot session */ 1419 if (boot_resp->boot_session_handle != INVALID_SESS_HANDLE) { 1420 *s_handle = boot_resp->boot_session_handle; 1421 return 0; 1422 } 1423 1424 /* Issue MBX Cmd to FW to login to the boot target */ 1425 tag = mgmt_reopen_session(phba, BE_REOPEN_BOOT_SESSIONS, 1426 INVALID_SESS_HANDLE); 1427 if (!tag) { 1428 beiscsi_log(phba, KERN_ERR, 1429 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1430 "BG_%d : mgmt_reopen_session Failed\n"); 1431 return -EAGAIN; 1432 } 1433 1434 rc = beiscsi_mccq_compl_wait(phba, tag, NULL, NULL); 1435 if (rc) { 1436 beiscsi_log(phba, KERN_ERR, 1437 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1438 "BG_%d : mgmt_reopen_session Failed"); 1439 return rc; 1440 } 1441 } while (--boot_retry); 1442 1443 /* Couldn't log into the boot target */ 1444 beiscsi_log(phba, KERN_ERR, 1445 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1446 "BG_%d : Login to Boot Target Failed\n"); 1447 return -ENXIO; 1448 } 1449 1450 /** 1451 * mgmt_set_vlan()- Issue and wait for CMD completion 1452 * @phba: device private structure instance 1453 * @vlan_tag: VLAN tag 1454 * 1455 * Issue the MBX Cmd and wait for the completion of the 1456 * command. 1457 * 1458 * returns 1459 * Success: 0 1460 * Failure: Non-Xero Value 1461 **/ 1462 int mgmt_set_vlan(struct beiscsi_hba *phba, 1463 uint16_t vlan_tag) 1464 { 1465 int rc; 1466 unsigned int tag; 1467 1468 tag = be_cmd_set_vlan(phba, vlan_tag); 1469 if (!tag) { 1470 beiscsi_log(phba, KERN_ERR, 1471 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX), 1472 "BG_%d : VLAN Setting Failed\n"); 1473 return -EBUSY; 1474 } 1475 1476 rc = beiscsi_mccq_compl_wait(phba, tag, NULL, NULL); 1477 if (rc) { 1478 beiscsi_log(phba, KERN_ERR, 1479 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX), 1480 "BS_%d : VLAN MBX Cmd Failed\n"); 1481 return rc; 1482 } 1483 return rc; 1484 } 1485 1486 /** 1487 * beiscsi_drvr_ver_disp()- Display the driver Name and Version 1488 * @dev: ptr to device not used. 1489 * @attr: device attribute, not used. 1490 * @buf: contains formatted text driver name and version 1491 * 1492 * return 1493 * size of the formatted string 1494 **/ 1495 ssize_t 1496 beiscsi_drvr_ver_disp(struct device *dev, struct device_attribute *attr, 1497 char *buf) 1498 { 1499 return snprintf(buf, PAGE_SIZE, BE_NAME "\n"); 1500 } 1501 1502 /** 1503 * beiscsi_fw_ver_disp()- Display Firmware Version 1504 * @dev: ptr to device not used. 1505 * @attr: device attribute, not used. 1506 * @buf: contains formatted text Firmware version 1507 * 1508 * return 1509 * size of the formatted string 1510 **/ 1511 ssize_t 1512 beiscsi_fw_ver_disp(struct device *dev, struct device_attribute *attr, 1513 char *buf) 1514 { 1515 struct Scsi_Host *shost = class_to_shost(dev); 1516 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1517 1518 return snprintf(buf, PAGE_SIZE, "%s\n", phba->fw_ver_str); 1519 } 1520 1521 /** 1522 * beiscsi_active_session_disp()- Display Sessions Active 1523 * @dev: ptr to device not used. 1524 * @attr: device attribute, not used. 1525 * @buf: contains formatted text Session Count 1526 * 1527 * return 1528 * size of the formatted string 1529 **/ 1530 ssize_t 1531 beiscsi_active_session_disp(struct device *dev, struct device_attribute *attr, 1532 char *buf) 1533 { 1534 struct Scsi_Host *shost = class_to_shost(dev); 1535 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1536 uint16_t avlbl_cids = 0, ulp_num, len = 0, total_cids = 0; 1537 1538 for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) { 1539 if (test_bit(ulp_num, (void *)&phba->fw_config.ulp_supported)) { 1540 avlbl_cids = BEISCSI_ULP_AVLBL_CID(phba, ulp_num); 1541 total_cids = BEISCSI_GET_CID_COUNT(phba, ulp_num); 1542 len += snprintf(buf+len, PAGE_SIZE - len, 1543 "ULP%d : %d\n", ulp_num, 1544 (total_cids - avlbl_cids)); 1545 } else 1546 len += snprintf(buf+len, PAGE_SIZE - len, 1547 "ULP%d : %d\n", ulp_num, 0); 1548 } 1549 1550 return len; 1551 } 1552 1553 /** 1554 * beiscsi_free_session_disp()- Display Avaliable Session 1555 * @dev: ptr to device not used. 1556 * @attr: device attribute, not used. 1557 * @buf: contains formatted text Session Count 1558 * 1559 * return 1560 * size of the formatted string 1561 **/ 1562 ssize_t 1563 beiscsi_free_session_disp(struct device *dev, struct device_attribute *attr, 1564 char *buf) 1565 { 1566 struct Scsi_Host *shost = class_to_shost(dev); 1567 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1568 uint16_t ulp_num, len = 0; 1569 1570 for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) { 1571 if (test_bit(ulp_num, (void *)&phba->fw_config.ulp_supported)) 1572 len += snprintf(buf+len, PAGE_SIZE - len, 1573 "ULP%d : %d\n", ulp_num, 1574 BEISCSI_ULP_AVLBL_CID(phba, ulp_num)); 1575 else 1576 len += snprintf(buf+len, PAGE_SIZE - len, 1577 "ULP%d : %d\n", ulp_num, 0); 1578 } 1579 1580 return len; 1581 } 1582 1583 /** 1584 * beiscsi_adap_family_disp()- Display adapter family. 1585 * @dev: ptr to device to get priv structure 1586 * @attr: device attribute, not used. 1587 * @buf: contains formatted text driver name and version 1588 * 1589 * return 1590 * size of the formatted string 1591 **/ 1592 ssize_t 1593 beiscsi_adap_family_disp(struct device *dev, struct device_attribute *attr, 1594 char *buf) 1595 { 1596 uint16_t dev_id = 0; 1597 struct Scsi_Host *shost = class_to_shost(dev); 1598 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1599 1600 dev_id = phba->pcidev->device; 1601 switch (dev_id) { 1602 case BE_DEVICE_ID1: 1603 case OC_DEVICE_ID1: 1604 case OC_DEVICE_ID2: 1605 return snprintf(buf, PAGE_SIZE, "BE2 Adapter Family\n"); 1606 break; 1607 case BE_DEVICE_ID2: 1608 case OC_DEVICE_ID3: 1609 return snprintf(buf, PAGE_SIZE, "BE3-R Adapter Family\n"); 1610 break; 1611 case OC_SKH_ID1: 1612 return snprintf(buf, PAGE_SIZE, "Skyhawk-R Adapter Family\n"); 1613 break; 1614 default: 1615 return snprintf(buf, PAGE_SIZE, 1616 "Unknown Adapter Family: 0x%x\n", dev_id); 1617 break; 1618 } 1619 } 1620 1621 /** 1622 * beiscsi_phys_port()- Display Physical Port Identifier 1623 * @dev: ptr to device not used. 1624 * @attr: device attribute, not used. 1625 * @buf: contains formatted text port identifier 1626 * 1627 * return 1628 * size of the formatted string 1629 **/ 1630 ssize_t 1631 beiscsi_phys_port_disp(struct device *dev, struct device_attribute *attr, 1632 char *buf) 1633 { 1634 struct Scsi_Host *shost = class_to_shost(dev); 1635 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1636 1637 return snprintf(buf, PAGE_SIZE, "Port Identifier : %d\n", 1638 phba->fw_config.phys_port); 1639 } 1640 1641 void beiscsi_offload_cxn_v0(struct beiscsi_offload_params *params, 1642 struct wrb_handle *pwrb_handle, 1643 struct be_mem_descriptor *mem_descr, 1644 struct hwi_wrb_context *pwrb_context) 1645 { 1646 struct iscsi_wrb *pwrb = pwrb_handle->pwrb; 1647 1648 memset(pwrb, 0, sizeof(*pwrb)); 1649 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1650 max_send_data_segment_length, pwrb, 1651 params->dw[offsetof(struct amap_beiscsi_offload_params, 1652 max_send_data_segment_length) / 32]); 1653 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, type, pwrb, 1654 BE_TGT_CTX_UPDT_CMD); 1655 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1656 first_burst_length, 1657 pwrb, 1658 params->dw[offsetof(struct amap_beiscsi_offload_params, 1659 first_burst_length) / 32]); 1660 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, erl, pwrb, 1661 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1662 erl) / 32] & OFFLD_PARAMS_ERL)); 1663 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, dde, pwrb, 1664 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1665 dde) / 32] & OFFLD_PARAMS_DDE) >> 2); 1666 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, hde, pwrb, 1667 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1668 hde) / 32] & OFFLD_PARAMS_HDE) >> 3); 1669 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ir2t, pwrb, 1670 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1671 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4); 1672 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, imd, pwrb, 1673 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1674 imd) / 32] & OFFLD_PARAMS_IMD) >> 5); 1675 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, stat_sn, 1676 pwrb, 1677 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1678 exp_statsn) / 32] + 1)); 1679 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, wrb_idx, 1680 pwrb, pwrb_handle->wrb_index); 1681 1682 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1683 max_burst_length, pwrb, params->dw[offsetof 1684 (struct amap_beiscsi_offload_params, 1685 max_burst_length) / 32]); 1686 1687 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ptr2nextwrb, 1688 pwrb, pwrb_handle->wrb_index); 1689 if (pwrb_context->plast_wrb) 1690 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1691 ptr2nextwrb, 1692 pwrb_context->plast_wrb, 1693 pwrb_handle->wrb_index); 1694 pwrb_context->plast_wrb = pwrb; 1695 1696 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1697 session_state, pwrb, 0); 1698 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, compltonack, 1699 pwrb, 1); 1700 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, notpredblq, 1701 pwrb, 0); 1702 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, mode, pwrb, 1703 0); 1704 1705 mem_descr += ISCSI_MEM_GLOBAL_HEADER; 1706 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1707 pad_buffer_addr_hi, pwrb, 1708 mem_descr->mem_array[0].bus_address.u.a32.address_hi); 1709 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1710 pad_buffer_addr_lo, pwrb, 1711 mem_descr->mem_array[0].bus_address.u.a32.address_lo); 1712 } 1713 1714 void beiscsi_offload_cxn_v2(struct beiscsi_offload_params *params, 1715 struct wrb_handle *pwrb_handle, 1716 struct hwi_wrb_context *pwrb_context) 1717 { 1718 struct iscsi_wrb *pwrb = pwrb_handle->pwrb; 1719 1720 memset(pwrb, 0, sizeof(*pwrb)); 1721 1722 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1723 max_burst_length, pwrb, params->dw[offsetof 1724 (struct amap_beiscsi_offload_params, 1725 max_burst_length) / 32]); 1726 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1727 type, pwrb, 1728 BE_TGT_CTX_UPDT_CMD); 1729 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1730 ptr2nextwrb, 1731 pwrb, pwrb_handle->wrb_index); 1732 if (pwrb_context->plast_wrb) 1733 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1734 ptr2nextwrb, 1735 pwrb_context->plast_wrb, 1736 pwrb_handle->wrb_index); 1737 pwrb_context->plast_wrb = pwrb; 1738 1739 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, wrb_idx, 1740 pwrb, pwrb_handle->wrb_index); 1741 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1742 max_send_data_segment_length, pwrb, 1743 params->dw[offsetof(struct amap_beiscsi_offload_params, 1744 max_send_data_segment_length) / 32]); 1745 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1746 first_burst_length, pwrb, 1747 params->dw[offsetof(struct amap_beiscsi_offload_params, 1748 first_burst_length) / 32]); 1749 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1750 max_recv_dataseg_len, pwrb, 1751 params->dw[offsetof(struct amap_beiscsi_offload_params, 1752 max_recv_data_segment_length) / 32]); 1753 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1754 max_cxns, pwrb, BEISCSI_MAX_CXNS); 1755 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, erl, pwrb, 1756 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1757 erl) / 32] & OFFLD_PARAMS_ERL)); 1758 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, dde, pwrb, 1759 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1760 dde) / 32] & OFFLD_PARAMS_DDE) >> 2); 1761 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, hde, pwrb, 1762 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1763 hde) / 32] & OFFLD_PARAMS_HDE) >> 3); 1764 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1765 ir2t, pwrb, 1766 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1767 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4); 1768 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, imd, pwrb, 1769 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1770 imd) / 32] & OFFLD_PARAMS_IMD) >> 5); 1771 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1772 data_seq_inorder, 1773 pwrb, 1774 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1775 data_seq_inorder) / 32] & 1776 OFFLD_PARAMS_DATA_SEQ_INORDER) >> 6); 1777 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1778 pdu_seq_inorder, 1779 pwrb, 1780 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1781 pdu_seq_inorder) / 32] & 1782 OFFLD_PARAMS_PDU_SEQ_INORDER) >> 7); 1783 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, max_r2t, 1784 pwrb, 1785 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1786 max_r2t) / 32] & 1787 OFFLD_PARAMS_MAX_R2T) >> 8); 1788 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, stat_sn, 1789 pwrb, 1790 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1791 exp_statsn) / 32] + 1)); 1792 } 1793 1794 /** 1795 * beiscsi_logout_fw_sess()- Firmware Session Logout 1796 * @phba: Device priv structure instance 1797 * @fw_sess_handle: FW session handle 1798 * 1799 * Logout from the FW established sessions. 1800 * returns 1801 * Success: 0 1802 * Failure: Non-Zero Value 1803 * 1804 */ 1805 int beiscsi_logout_fw_sess(struct beiscsi_hba *phba, 1806 uint32_t fw_sess_handle) 1807 { 1808 struct be_ctrl_info *ctrl = &phba->ctrl; 1809 struct be_mcc_wrb *wrb; 1810 struct be_cmd_req_logout_fw_sess *req; 1811 struct be_cmd_resp_logout_fw_sess *resp; 1812 unsigned int tag; 1813 int rc; 1814 1815 beiscsi_log(phba, KERN_INFO, 1816 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX, 1817 "BG_%d : In bescsi_logout_fwboot_sess\n"); 1818 1819 mutex_lock(&ctrl->mbox_lock); 1820 wrb = alloc_mcc_wrb(phba, &tag); 1821 if (!wrb) { 1822 mutex_unlock(&ctrl->mbox_lock); 1823 beiscsi_log(phba, KERN_INFO, 1824 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX, 1825 "BG_%d : MBX Tag Failure\n"); 1826 return -EINVAL; 1827 } 1828 1829 req = embedded_payload(wrb); 1830 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 1831 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 1832 OPCODE_ISCSI_INI_SESSION_LOGOUT_TARGET, 1833 sizeof(struct be_cmd_req_logout_fw_sess)); 1834 1835 /* Set the session handle */ 1836 req->session_handle = fw_sess_handle; 1837 be_mcc_notify(phba, tag); 1838 mutex_unlock(&ctrl->mbox_lock); 1839 1840 rc = beiscsi_mccq_compl_wait(phba, tag, &wrb, NULL); 1841 if (rc) { 1842 beiscsi_log(phba, KERN_ERR, 1843 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1844 "BG_%d : MBX CMD FW_SESSION_LOGOUT_TARGET Failed\n"); 1845 return -EBUSY; 1846 } 1847 1848 resp = embedded_payload(wrb); 1849 if (resp->session_status != 1850 BEISCSI_MGMT_SESSION_CLOSE) { 1851 beiscsi_log(phba, KERN_ERR, 1852 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1853 "BG_%d : FW_SESSION_LOGOUT_TARGET resp : 0x%x\n", 1854 resp->session_status); 1855 rc = -EINVAL; 1856 } 1857 1858 return rc; 1859 } 1860