1 /** 2 * Copyright (C) 2005 - 2013 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@emulex.com) 11 * 12 * Contact Information: 13 * linux-drivers@emulex.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 /** 159 * mgmt_reopen_session()- Reopen a session based on reopen_type 160 * @phba: Device priv structure instance 161 * @reopen_type: Type of reopen_session FW should do. 162 * @sess_handle: Session Handle of the session to be re-opened 163 * 164 * return 165 * the TAG used for MBOX Command 166 * 167 **/ 168 unsigned int mgmt_reopen_session(struct beiscsi_hba *phba, 169 unsigned int reopen_type, 170 unsigned int sess_handle) 171 { 172 struct be_ctrl_info *ctrl = &phba->ctrl; 173 struct be_mcc_wrb *wrb; 174 struct be_cmd_reopen_session_req *req; 175 unsigned int tag = 0; 176 177 beiscsi_log(phba, KERN_INFO, 178 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX, 179 "BG_%d : In bescsi_get_boot_target\n"); 180 181 spin_lock(&ctrl->mbox_lock); 182 tag = alloc_mcc_tag(phba); 183 if (!tag) { 184 spin_unlock(&ctrl->mbox_lock); 185 return tag; 186 } 187 188 wrb = wrb_from_mccq(phba); 189 req = embedded_payload(wrb); 190 wrb->tag0 |= tag; 191 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 192 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 193 OPCODE_ISCSI_INI_DRIVER_REOPEN_ALL_SESSIONS, 194 sizeof(struct be_cmd_reopen_session_resp)); 195 196 /* set the reopen_type,sess_handle */ 197 req->reopen_type = reopen_type; 198 req->session_handle = sess_handle; 199 200 be_mcc_notify(phba); 201 spin_unlock(&ctrl->mbox_lock); 202 return tag; 203 } 204 205 unsigned int mgmt_get_boot_target(struct beiscsi_hba *phba) 206 { 207 struct be_ctrl_info *ctrl = &phba->ctrl; 208 struct be_mcc_wrb *wrb; 209 struct be_cmd_get_boot_target_req *req; 210 unsigned int tag = 0; 211 212 beiscsi_log(phba, KERN_INFO, 213 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX, 214 "BG_%d : In bescsi_get_boot_target\n"); 215 216 spin_lock(&ctrl->mbox_lock); 217 tag = alloc_mcc_tag(phba); 218 if (!tag) { 219 spin_unlock(&ctrl->mbox_lock); 220 return tag; 221 } 222 223 wrb = wrb_from_mccq(phba); 224 req = embedded_payload(wrb); 225 wrb->tag0 |= tag; 226 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 227 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 228 OPCODE_ISCSI_INI_BOOT_GET_BOOT_TARGET, 229 sizeof(struct be_cmd_get_boot_target_resp)); 230 231 be_mcc_notify(phba); 232 spin_unlock(&ctrl->mbox_lock); 233 return tag; 234 } 235 236 unsigned int mgmt_get_session_info(struct beiscsi_hba *phba, 237 u32 boot_session_handle, 238 struct be_dma_mem *nonemb_cmd) 239 { 240 struct be_ctrl_info *ctrl = &phba->ctrl; 241 struct be_mcc_wrb *wrb; 242 unsigned int tag = 0; 243 struct be_cmd_get_session_req *req; 244 struct be_cmd_get_session_resp *resp; 245 struct be_sge *sge; 246 247 beiscsi_log(phba, KERN_INFO, 248 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX, 249 "BG_%d : In beiscsi_get_session_info\n"); 250 251 spin_lock(&ctrl->mbox_lock); 252 tag = alloc_mcc_tag(phba); 253 if (!tag) { 254 spin_unlock(&ctrl->mbox_lock); 255 return tag; 256 } 257 258 nonemb_cmd->size = sizeof(*resp); 259 req = nonemb_cmd->va; 260 memset(req, 0, sizeof(*req)); 261 wrb = wrb_from_mccq(phba); 262 sge = nonembedded_sgl(wrb); 263 wrb->tag0 |= tag; 264 265 266 wrb->tag0 |= tag; 267 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1); 268 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 269 OPCODE_ISCSI_INI_SESSION_GET_A_SESSION, 270 sizeof(*resp)); 271 req->session_handle = boot_session_handle; 272 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 273 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 274 sge->len = cpu_to_le32(nonemb_cmd->size); 275 276 be_mcc_notify(phba); 277 spin_unlock(&ctrl->mbox_lock); 278 return tag; 279 } 280 281 /** 282 * mgmt_get_fw_config()- Get the FW config for the function 283 * @ctrl: ptr to Ctrl Info 284 * @phba: ptr to the dev priv structure 285 * 286 * Get the FW config and resources available for the function. 287 * The resources are created based on the count received here. 288 * 289 * return 290 * Success: 0 291 * Failure: Non-Zero Value 292 **/ 293 int mgmt_get_fw_config(struct be_ctrl_info *ctrl, 294 struct beiscsi_hba *phba) 295 { 296 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); 297 struct be_fw_cfg *req = embedded_payload(wrb); 298 int status = 0; 299 300 spin_lock(&ctrl->mbox_lock); 301 memset(wrb, 0, sizeof(*wrb)); 302 303 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 304 305 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON, 306 OPCODE_COMMON_QUERY_FIRMWARE_CONFIG, 307 EMBED_MBX_MAX_PAYLOAD_SIZE); 308 status = be_mbox_notify(ctrl); 309 if (!status) { 310 uint8_t ulp_num = 0; 311 struct be_fw_cfg *pfw_cfg; 312 pfw_cfg = req; 313 314 if (!is_chip_be2_be3r(phba)) { 315 phba->fw_config.eqid_count = pfw_cfg->eqid_count; 316 phba->fw_config.cqid_count = pfw_cfg->cqid_count; 317 318 beiscsi_log(phba, KERN_INFO, 319 BEISCSI_LOG_INIT, 320 "BG_%d : EQ_Count : %d CQ_Count : %d\n", 321 phba->fw_config.eqid_count, 322 phba->fw_config.cqid_count); 323 } 324 325 for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) 326 if (pfw_cfg->ulp[ulp_num].ulp_mode & 327 BEISCSI_ULP_ISCSI_INI_MODE) 328 set_bit(ulp_num, 329 &phba->fw_config.ulp_supported); 330 331 phba->fw_config.phys_port = pfw_cfg->phys_port; 332 for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) { 333 if (test_bit(ulp_num, &phba->fw_config.ulp_supported)) { 334 335 phba->fw_config.iscsi_cid_start[ulp_num] = 336 pfw_cfg->ulp[ulp_num].sq_base; 337 phba->fw_config.iscsi_cid_count[ulp_num] = 338 pfw_cfg->ulp[ulp_num].sq_count; 339 340 phba->fw_config.iscsi_icd_start[ulp_num] = 341 pfw_cfg->ulp[ulp_num].icd_base; 342 phba->fw_config.iscsi_icd_count[ulp_num] = 343 pfw_cfg->ulp[ulp_num].icd_count; 344 345 phba->fw_config.iscsi_chain_start[ulp_num] = 346 pfw_cfg->chain_icd[ulp_num].chain_base; 347 phba->fw_config.iscsi_chain_count[ulp_num] = 348 pfw_cfg->chain_icd[ulp_num].chain_count; 349 350 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, 351 "BG_%d : Function loaded on ULP : %d\n" 352 "\tiscsi_cid_count : %d\n" 353 "\tiscsi_cid_start : %d\n" 354 "\t iscsi_icd_count : %d\n" 355 "\t iscsi_icd_start : %d\n", 356 ulp_num, 357 phba->fw_config. 358 iscsi_cid_count[ulp_num], 359 phba->fw_config. 360 iscsi_cid_start[ulp_num], 361 phba->fw_config. 362 iscsi_icd_count[ulp_num], 363 phba->fw_config. 364 iscsi_icd_start[ulp_num]); 365 } 366 } 367 368 phba->fw_config.dual_ulp_aware = (pfw_cfg->function_mode & 369 BEISCSI_FUNC_DUA_MODE); 370 371 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, 372 "BG_%d : DUA Mode : 0x%x\n", 373 phba->fw_config.dual_ulp_aware); 374 375 } else { 376 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, 377 "BG_%d : Failed in mgmt_get_fw_config\n"); 378 status = -EINVAL; 379 } 380 381 spin_unlock(&ctrl->mbox_lock); 382 return status; 383 } 384 385 int mgmt_check_supported_fw(struct be_ctrl_info *ctrl, 386 struct beiscsi_hba *phba) 387 { 388 struct be_dma_mem nonemb_cmd; 389 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); 390 struct be_mgmt_controller_attributes *req; 391 struct be_sge *sge = nonembedded_sgl(wrb); 392 int status = 0; 393 394 nonemb_cmd.va = pci_alloc_consistent(ctrl->pdev, 395 sizeof(struct be_mgmt_controller_attributes), 396 &nonemb_cmd.dma); 397 if (nonemb_cmd.va == NULL) { 398 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, 399 "BG_%d : Failed to allocate memory for " 400 "mgmt_check_supported_fw\n"); 401 return -ENOMEM; 402 } 403 nonemb_cmd.size = sizeof(struct be_mgmt_controller_attributes); 404 req = nonemb_cmd.va; 405 memset(req, 0, sizeof(*req)); 406 spin_lock(&ctrl->mbox_lock); 407 memset(wrb, 0, sizeof(*wrb)); 408 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1); 409 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON, 410 OPCODE_COMMON_GET_CNTL_ATTRIBUTES, sizeof(*req)); 411 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd.dma)); 412 sge->pa_lo = cpu_to_le32(nonemb_cmd.dma & 0xFFFFFFFF); 413 sge->len = cpu_to_le32(nonemb_cmd.size); 414 status = be_mbox_notify(ctrl); 415 if (!status) { 416 struct be_mgmt_controller_attributes_resp *resp = nonemb_cmd.va; 417 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, 418 "BG_%d : Firmware Version of CMD : %s\n" 419 "Firmware Version is : %s\n" 420 "Developer Build, not performing version check...\n", 421 resp->params.hba_attribs 422 .flashrom_version_string, 423 resp->params.hba_attribs. 424 firmware_version_string); 425 426 phba->fw_config.iscsi_features = 427 resp->params.hba_attribs.iscsi_features; 428 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, 429 "BM_%d : phba->fw_config.iscsi_features = %d\n", 430 phba->fw_config.iscsi_features); 431 memcpy(phba->fw_ver_str, resp->params.hba_attribs. 432 firmware_version_string, BEISCSI_VER_STRLEN); 433 } else 434 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, 435 "BG_%d : Failed in mgmt_check_supported_fw\n"); 436 spin_unlock(&ctrl->mbox_lock); 437 if (nonemb_cmd.va) 438 pci_free_consistent(ctrl->pdev, nonemb_cmd.size, 439 nonemb_cmd.va, nonemb_cmd.dma); 440 441 return status; 442 } 443 444 unsigned int mgmt_vendor_specific_fw_cmd(struct be_ctrl_info *ctrl, 445 struct beiscsi_hba *phba, 446 struct bsg_job *job, 447 struct be_dma_mem *nonemb_cmd) 448 { 449 struct be_cmd_resp_hdr *resp; 450 struct be_mcc_wrb *wrb = wrb_from_mccq(phba); 451 struct be_sge *mcc_sge = nonembedded_sgl(wrb); 452 unsigned int tag = 0; 453 struct iscsi_bsg_request *bsg_req = job->request; 454 struct be_bsg_vendor_cmd *req = nonemb_cmd->va; 455 unsigned short region, sector_size, sector, offset; 456 457 nonemb_cmd->size = job->request_payload.payload_len; 458 memset(nonemb_cmd->va, 0, nonemb_cmd->size); 459 resp = nonemb_cmd->va; 460 region = bsg_req->rqst_data.h_vendor.vendor_cmd[1]; 461 sector_size = bsg_req->rqst_data.h_vendor.vendor_cmd[2]; 462 sector = bsg_req->rqst_data.h_vendor.vendor_cmd[3]; 463 offset = bsg_req->rqst_data.h_vendor.vendor_cmd[4]; 464 req->region = region; 465 req->sector = sector; 466 req->offset = offset; 467 spin_lock(&ctrl->mbox_lock); 468 memset(wrb, 0, sizeof(*wrb)); 469 470 switch (bsg_req->rqst_data.h_vendor.vendor_cmd[0]) { 471 case BEISCSI_WRITE_FLASH: 472 offset = sector * sector_size + offset; 473 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 474 OPCODE_COMMON_WRITE_FLASH, sizeof(*req)); 475 sg_copy_to_buffer(job->request_payload.sg_list, 476 job->request_payload.sg_cnt, 477 nonemb_cmd->va + offset, job->request_len); 478 break; 479 case BEISCSI_READ_FLASH: 480 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 481 OPCODE_COMMON_READ_FLASH, sizeof(*req)); 482 break; 483 default: 484 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 485 "BG_%d : Unsupported cmd = 0x%x\n\n", 486 bsg_req->rqst_data.h_vendor.vendor_cmd[0]); 487 488 spin_unlock(&ctrl->mbox_lock); 489 return -ENOSYS; 490 } 491 492 tag = alloc_mcc_tag(phba); 493 if (!tag) { 494 spin_unlock(&ctrl->mbox_lock); 495 return tag; 496 } 497 498 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false, 499 job->request_payload.sg_cnt); 500 mcc_sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 501 mcc_sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 502 mcc_sge->len = cpu_to_le32(nonemb_cmd->size); 503 wrb->tag0 |= tag; 504 505 be_mcc_notify(phba); 506 507 spin_unlock(&ctrl->mbox_lock); 508 return tag; 509 } 510 511 /** 512 * mgmt_epfw_cleanup()- Inform FW to cleanup data structures. 513 * @phba: pointer to dev priv structure 514 * @ulp_num: ULP number. 515 * 516 * return 517 * Success: 0 518 * Failure: Non-Zero Value 519 **/ 520 int mgmt_epfw_cleanup(struct beiscsi_hba *phba, unsigned short ulp_num) 521 { 522 struct be_ctrl_info *ctrl = &phba->ctrl; 523 struct be_mcc_wrb *wrb = wrb_from_mccq(phba); 524 struct iscsi_cleanup_req *req = embedded_payload(wrb); 525 int status = 0; 526 527 spin_lock(&ctrl->mbox_lock); 528 memset(wrb, 0, sizeof(*wrb)); 529 530 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 531 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 532 OPCODE_COMMON_ISCSI_CLEANUP, sizeof(*req)); 533 534 req->chute = (1 << ulp_num); 535 req->hdr_ring_id = cpu_to_le16(HWI_GET_DEF_HDRQ_ID(phba, ulp_num)); 536 req->data_ring_id = cpu_to_le16(HWI_GET_DEF_BUFQ_ID(phba, ulp_num)); 537 538 status = be_mcc_notify_wait(phba); 539 if (status) 540 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT, 541 "BG_%d : mgmt_epfw_cleanup , FAILED\n"); 542 spin_unlock(&ctrl->mbox_lock); 543 return status; 544 } 545 546 unsigned int mgmt_invalidate_icds(struct beiscsi_hba *phba, 547 struct invalidate_command_table *inv_tbl, 548 unsigned int num_invalidate, unsigned int cid, 549 struct be_dma_mem *nonemb_cmd) 550 551 { 552 struct be_ctrl_info *ctrl = &phba->ctrl; 553 struct be_mcc_wrb *wrb; 554 struct be_sge *sge; 555 struct invalidate_commands_params_in *req; 556 unsigned int i, tag = 0; 557 558 spin_lock(&ctrl->mbox_lock); 559 tag = alloc_mcc_tag(phba); 560 if (!tag) { 561 spin_unlock(&ctrl->mbox_lock); 562 return tag; 563 } 564 565 req = nonemb_cmd->va; 566 memset(req, 0, sizeof(*req)); 567 wrb = wrb_from_mccq(phba); 568 sge = nonembedded_sgl(wrb); 569 wrb->tag0 |= tag; 570 571 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1); 572 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 573 OPCODE_COMMON_ISCSI_ERROR_RECOVERY_INVALIDATE_COMMANDS, 574 sizeof(*req)); 575 req->ref_handle = 0; 576 req->cleanup_type = CMD_ISCSI_COMMAND_INVALIDATE; 577 for (i = 0; i < num_invalidate; i++) { 578 req->table[i].icd = inv_tbl->icd; 579 req->table[i].cid = inv_tbl->cid; 580 req->icd_count++; 581 inv_tbl++; 582 } 583 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 584 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 585 sge->len = cpu_to_le32(nonemb_cmd->size); 586 587 be_mcc_notify(phba); 588 spin_unlock(&ctrl->mbox_lock); 589 return tag; 590 } 591 592 unsigned int mgmt_invalidate_connection(struct beiscsi_hba *phba, 593 struct beiscsi_endpoint *beiscsi_ep, 594 unsigned short cid, 595 unsigned short issue_reset, 596 unsigned short savecfg_flag) 597 { 598 struct be_ctrl_info *ctrl = &phba->ctrl; 599 struct be_mcc_wrb *wrb; 600 struct iscsi_invalidate_connection_params_in *req; 601 unsigned int tag = 0; 602 603 spin_lock(&ctrl->mbox_lock); 604 tag = alloc_mcc_tag(phba); 605 if (!tag) { 606 spin_unlock(&ctrl->mbox_lock); 607 return tag; 608 } 609 wrb = wrb_from_mccq(phba); 610 wrb->tag0 |= tag; 611 req = embedded_payload(wrb); 612 613 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 614 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 615 OPCODE_ISCSI_INI_DRIVER_INVALIDATE_CONNECTION, 616 sizeof(*req)); 617 req->session_handle = beiscsi_ep->fw_handle; 618 req->cid = cid; 619 if (issue_reset) 620 req->cleanup_type = CMD_ISCSI_CONNECTION_ISSUE_TCP_RST; 621 else 622 req->cleanup_type = CMD_ISCSI_CONNECTION_INVALIDATE; 623 req->save_cfg = savecfg_flag; 624 be_mcc_notify(phba); 625 spin_unlock(&ctrl->mbox_lock); 626 return tag; 627 } 628 629 unsigned int mgmt_upload_connection(struct beiscsi_hba *phba, 630 unsigned short cid, unsigned int upload_flag) 631 { 632 struct be_ctrl_info *ctrl = &phba->ctrl; 633 struct be_mcc_wrb *wrb; 634 struct tcp_upload_params_in *req; 635 unsigned int tag = 0; 636 637 spin_lock(&ctrl->mbox_lock); 638 tag = alloc_mcc_tag(phba); 639 if (!tag) { 640 spin_unlock(&ctrl->mbox_lock); 641 return tag; 642 } 643 wrb = wrb_from_mccq(phba); 644 req = embedded_payload(wrb); 645 wrb->tag0 |= tag; 646 647 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 648 be_cmd_hdr_prepare(&req->hdr, CMD_COMMON_TCP_UPLOAD, 649 OPCODE_COMMON_TCP_UPLOAD, sizeof(*req)); 650 req->id = (unsigned short)cid; 651 req->upload_type = (unsigned char)upload_flag; 652 be_mcc_notify(phba); 653 spin_unlock(&ctrl->mbox_lock); 654 return tag; 655 } 656 657 /** 658 * mgmt_open_connection()- Establish a TCP CXN 659 * @dst_addr: Destination Address 660 * @beiscsi_ep: ptr to device endpoint struct 661 * @nonemb_cmd: ptr to memory allocated for command 662 * 663 * return 664 * Success: Tag number of the MBX Command issued 665 * Failure: Error code 666 **/ 667 int mgmt_open_connection(struct beiscsi_hba *phba, 668 struct sockaddr *dst_addr, 669 struct beiscsi_endpoint *beiscsi_ep, 670 struct be_dma_mem *nonemb_cmd) 671 { 672 struct hwi_controller *phwi_ctrlr; 673 struct hwi_context_memory *phwi_context; 674 struct sockaddr_in *daddr_in = (struct sockaddr_in *)dst_addr; 675 struct sockaddr_in6 *daddr_in6 = (struct sockaddr_in6 *)dst_addr; 676 struct be_ctrl_info *ctrl = &phba->ctrl; 677 struct be_mcc_wrb *wrb; 678 struct tcp_connect_and_offload_in *req; 679 unsigned short def_hdr_id; 680 unsigned short def_data_id; 681 struct phys_addr template_address = { 0, 0 }; 682 struct phys_addr *ptemplate_address; 683 unsigned int tag = 0; 684 unsigned int i, ulp_num; 685 unsigned short cid = beiscsi_ep->ep_cid; 686 struct be_sge *sge; 687 688 phwi_ctrlr = phba->phwi_ctrlr; 689 phwi_context = phwi_ctrlr->phwi_ctxt; 690 691 ulp_num = phwi_ctrlr->wrb_context[BE_GET_CRI_FROM_CID(cid)].ulp_num; 692 693 def_hdr_id = (unsigned short)HWI_GET_DEF_HDRQ_ID(phba, ulp_num); 694 def_data_id = (unsigned short)HWI_GET_DEF_BUFQ_ID(phba, ulp_num); 695 696 ptemplate_address = &template_address; 697 ISCSI_GET_PDU_TEMPLATE_ADDRESS(phba, ptemplate_address); 698 spin_lock(&ctrl->mbox_lock); 699 tag = alloc_mcc_tag(phba); 700 if (!tag) { 701 spin_unlock(&ctrl->mbox_lock); 702 return tag; 703 } 704 wrb = wrb_from_mccq(phba); 705 memset(wrb, 0, sizeof(*wrb)); 706 sge = nonembedded_sgl(wrb); 707 708 req = nonemb_cmd->va; 709 memset(req, 0, sizeof(*req)); 710 wrb->tag0 |= tag; 711 712 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1); 713 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 714 OPCODE_COMMON_ISCSI_TCP_CONNECT_AND_OFFLOAD, 715 sizeof(*req)); 716 if (dst_addr->sa_family == PF_INET) { 717 __be32 s_addr = daddr_in->sin_addr.s_addr; 718 req->ip_address.ip_type = BE2_IPV4; 719 req->ip_address.addr[0] = s_addr & 0x000000ff; 720 req->ip_address.addr[1] = (s_addr & 0x0000ff00) >> 8; 721 req->ip_address.addr[2] = (s_addr & 0x00ff0000) >> 16; 722 req->ip_address.addr[3] = (s_addr & 0xff000000) >> 24; 723 req->tcp_port = ntohs(daddr_in->sin_port); 724 beiscsi_ep->dst_addr = daddr_in->sin_addr.s_addr; 725 beiscsi_ep->dst_tcpport = ntohs(daddr_in->sin_port); 726 beiscsi_ep->ip_type = BE2_IPV4; 727 } else if (dst_addr->sa_family == PF_INET6) { 728 req->ip_address.ip_type = BE2_IPV6; 729 memcpy(&req->ip_address.addr, 730 &daddr_in6->sin6_addr.in6_u.u6_addr8, 16); 731 req->tcp_port = ntohs(daddr_in6->sin6_port); 732 beiscsi_ep->dst_tcpport = ntohs(daddr_in6->sin6_port); 733 memcpy(&beiscsi_ep->dst6_addr, 734 &daddr_in6->sin6_addr.in6_u.u6_addr8, 16); 735 beiscsi_ep->ip_type = BE2_IPV6; 736 } else{ 737 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG, 738 "BG_%d : unknown addr family %d\n", 739 dst_addr->sa_family); 740 spin_unlock(&ctrl->mbox_lock); 741 free_mcc_tag(&phba->ctrl, tag); 742 return -EINVAL; 743 744 } 745 req->cid = cid; 746 i = phba->nxt_cqid++; 747 if (phba->nxt_cqid == phba->num_cpus) 748 phba->nxt_cqid = 0; 749 req->cq_id = phwi_context->be_cq[i].id; 750 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG, 751 "BG_%d : i=%d cq_id=%d\n", i, req->cq_id); 752 req->defq_id = def_hdr_id; 753 req->hdr_ring_id = def_hdr_id; 754 req->data_ring_id = def_data_id; 755 req->do_offload = 1; 756 req->dataout_template_pa.lo = ptemplate_address->lo; 757 req->dataout_template_pa.hi = ptemplate_address->hi; 758 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 759 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 760 sge->len = cpu_to_le32(nonemb_cmd->size); 761 be_mcc_notify(phba); 762 spin_unlock(&ctrl->mbox_lock); 763 return tag; 764 } 765 766 unsigned int mgmt_get_all_if_id(struct beiscsi_hba *phba) 767 { 768 struct be_ctrl_info *ctrl = &phba->ctrl; 769 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); 770 struct be_cmd_get_all_if_id_req *req = embedded_payload(wrb); 771 struct be_cmd_get_all_if_id_req *pbe_allid = req; 772 int status = 0; 773 774 memset(wrb, 0, sizeof(*wrb)); 775 776 spin_lock(&ctrl->mbox_lock); 777 778 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 779 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 780 OPCODE_COMMON_ISCSI_NTWK_GET_ALL_IF_ID, 781 sizeof(*req)); 782 status = be_mbox_notify(ctrl); 783 if (!status) 784 phba->interface_handle = pbe_allid->if_hndl_list[0]; 785 else { 786 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 787 "BG_%d : Failed in mgmt_get_all_if_id\n"); 788 } 789 spin_unlock(&ctrl->mbox_lock); 790 791 return status; 792 } 793 794 /* 795 * mgmt_exec_nonemb_cmd()- Execute Non Embedded MBX Cmd 796 * @phba: Driver priv structure 797 * @nonemb_cmd: Address of the MBX command issued 798 * @resp_buf: Buffer to copy the MBX cmd response 799 * @resp_buf_len: respone lenght to be copied 800 * 801 **/ 802 static int mgmt_exec_nonemb_cmd(struct beiscsi_hba *phba, 803 struct be_dma_mem *nonemb_cmd, void *resp_buf, 804 int resp_buf_len) 805 { 806 struct be_ctrl_info *ctrl = &phba->ctrl; 807 struct be_mcc_wrb *wrb = wrb_from_mccq(phba); 808 struct be_sge *sge; 809 unsigned int tag; 810 int rc = 0; 811 812 spin_lock(&ctrl->mbox_lock); 813 tag = alloc_mcc_tag(phba); 814 if (!tag) { 815 spin_unlock(&ctrl->mbox_lock); 816 rc = -ENOMEM; 817 goto free_cmd; 818 } 819 memset(wrb, 0, sizeof(*wrb)); 820 wrb->tag0 |= tag; 821 sge = nonembedded_sgl(wrb); 822 823 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false, 1); 824 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 825 sge->pa_lo = cpu_to_le32(lower_32_bits(nonemb_cmd->dma)); 826 sge->len = cpu_to_le32(nonemb_cmd->size); 827 828 be_mcc_notify(phba); 829 spin_unlock(&ctrl->mbox_lock); 830 831 rc = beiscsi_mccq_compl(phba, tag, NULL, nonemb_cmd->va); 832 if (rc) { 833 /* Check if the IOCTL needs to be re-issued */ 834 if (rc == -EAGAIN) 835 return rc; 836 837 beiscsi_log(phba, KERN_ERR, 838 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX, 839 "BG_%d : mgmt_exec_nonemb_cmd Failed status\n"); 840 841 goto free_cmd; 842 } 843 844 if (resp_buf) 845 memcpy(resp_buf, nonemb_cmd->va, resp_buf_len); 846 847 free_cmd: 848 pci_free_consistent(ctrl->pdev, nonemb_cmd->size, 849 nonemb_cmd->va, nonemb_cmd->dma); 850 return rc; 851 } 852 853 static int mgmt_alloc_cmd_data(struct beiscsi_hba *phba, struct be_dma_mem *cmd, 854 int iscsi_cmd, int size) 855 { 856 cmd->va = pci_alloc_consistent(phba->ctrl.pdev, size, &cmd->dma); 857 if (!cmd->va) { 858 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG, 859 "BG_%d : Failed to allocate memory for if info\n"); 860 return -ENOMEM; 861 } 862 memset(cmd->va, 0, size); 863 cmd->size = size; 864 be_cmd_hdr_prepare(cmd->va, CMD_SUBSYSTEM_ISCSI, iscsi_cmd, size); 865 return 0; 866 } 867 868 static int 869 mgmt_static_ip_modify(struct beiscsi_hba *phba, 870 struct be_cmd_get_if_info_resp *if_info, 871 struct iscsi_iface_param_info *ip_param, 872 struct iscsi_iface_param_info *subnet_param, 873 uint32_t ip_action) 874 { 875 struct be_cmd_set_ip_addr_req *req; 876 struct be_dma_mem nonemb_cmd; 877 uint32_t ip_type; 878 int rc; 879 880 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 881 OPCODE_COMMON_ISCSI_NTWK_MODIFY_IP_ADDR, 882 sizeof(*req)); 883 if (rc) 884 return rc; 885 886 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ? 887 BE2_IPV6 : BE2_IPV4 ; 888 889 req = nonemb_cmd.va; 890 req->ip_params.record_entry_count = 1; 891 req->ip_params.ip_record.action = ip_action; 892 req->ip_params.ip_record.interface_hndl = 893 phba->interface_handle; 894 req->ip_params.ip_record.ip_addr.size_of_structure = 895 sizeof(struct be_ip_addr_subnet_format); 896 req->ip_params.ip_record.ip_addr.ip_type = ip_type; 897 898 if (ip_action == IP_ACTION_ADD) { 899 memcpy(req->ip_params.ip_record.ip_addr.addr, ip_param->value, 900 ip_param->len); 901 902 if (subnet_param) 903 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask, 904 subnet_param->value, subnet_param->len); 905 } else { 906 memcpy(req->ip_params.ip_record.ip_addr.addr, 907 if_info->ip_addr.addr, ip_param->len); 908 909 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask, 910 if_info->ip_addr.subnet_mask, ip_param->len); 911 } 912 913 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 914 if (rc < 0) 915 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 916 "BG_%d : Failed to Modify existing IP Address\n"); 917 return rc; 918 } 919 920 static int mgmt_modify_gateway(struct beiscsi_hba *phba, uint8_t *gt_addr, 921 uint32_t gtway_action, uint32_t param_len) 922 { 923 struct be_cmd_set_def_gateway_req *req; 924 struct be_dma_mem nonemb_cmd; 925 int rt_val; 926 927 928 rt_val = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 929 OPCODE_COMMON_ISCSI_NTWK_MODIFY_DEFAULT_GATEWAY, 930 sizeof(*req)); 931 if (rt_val) 932 return rt_val; 933 934 req = nonemb_cmd.va; 935 req->action = gtway_action; 936 req->ip_addr.ip_type = BE2_IPV4; 937 938 memcpy(req->ip_addr.addr, gt_addr, param_len); 939 940 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 941 } 942 943 int mgmt_set_ip(struct beiscsi_hba *phba, 944 struct iscsi_iface_param_info *ip_param, 945 struct iscsi_iface_param_info *subnet_param, 946 uint32_t boot_proto) 947 { 948 struct be_cmd_get_def_gateway_resp gtway_addr_set; 949 struct be_cmd_get_if_info_resp *if_info; 950 struct be_cmd_set_dhcp_req *dhcpreq; 951 struct be_cmd_rel_dhcp_req *reldhcp; 952 struct be_dma_mem nonemb_cmd; 953 uint8_t *gtway_addr; 954 uint32_t ip_type; 955 int rc; 956 957 if (mgmt_get_all_if_id(phba)) 958 return -EIO; 959 960 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ? 961 BE2_IPV6 : BE2_IPV4 ; 962 963 rc = mgmt_get_if_info(phba, ip_type, &if_info); 964 if (rc) { 965 kfree(if_info); 966 return rc; 967 } 968 969 if (boot_proto == ISCSI_BOOTPROTO_DHCP) { 970 if (if_info->dhcp_state) { 971 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 972 "BG_%d : DHCP Already Enabled\n"); 973 return 0; 974 } 975 /* The ip_param->len is 1 in DHCP case. Setting 976 proper IP len as this it is used while 977 freeing the Static IP. 978 */ 979 ip_param->len = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ? 980 IP_V6_LEN : IP_V4_LEN; 981 982 } else { 983 if (if_info->dhcp_state) { 984 985 memset(if_info, 0, sizeof(*if_info)); 986 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 987 OPCODE_COMMON_ISCSI_NTWK_REL_STATELESS_IP_ADDR, 988 sizeof(*reldhcp)); 989 990 if (rc) 991 return rc; 992 993 reldhcp = nonemb_cmd.va; 994 reldhcp->interface_hndl = phba->interface_handle; 995 reldhcp->ip_type = ip_type; 996 997 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 998 if (rc < 0) { 999 beiscsi_log(phba, KERN_WARNING, 1000 BEISCSI_LOG_CONFIG, 1001 "BG_%d : Failed to Delete existing dhcp\n"); 1002 return rc; 1003 } 1004 } 1005 } 1006 1007 /* Delete the Static IP Set */ 1008 if (if_info->ip_addr.addr[0]) { 1009 rc = mgmt_static_ip_modify(phba, if_info, ip_param, NULL, 1010 IP_ACTION_DEL); 1011 if (rc) 1012 return rc; 1013 } 1014 1015 /* Delete the Gateway settings if mode change is to DHCP */ 1016 if (boot_proto == ISCSI_BOOTPROTO_DHCP) { 1017 memset(>way_addr_set, 0, sizeof(gtway_addr_set)); 1018 rc = mgmt_get_gateway(phba, BE2_IPV4, >way_addr_set); 1019 if (rc) { 1020 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1021 "BG_%d : Failed to Get Gateway Addr\n"); 1022 return rc; 1023 } 1024 1025 if (gtway_addr_set.ip_addr.addr[0]) { 1026 gtway_addr = (uint8_t *)>way_addr_set.ip_addr.addr; 1027 rc = mgmt_modify_gateway(phba, gtway_addr, 1028 IP_ACTION_DEL, IP_V4_LEN); 1029 1030 if (rc) { 1031 beiscsi_log(phba, KERN_WARNING, 1032 BEISCSI_LOG_CONFIG, 1033 "BG_%d : Failed to clear Gateway Addr Set\n"); 1034 return rc; 1035 } 1036 } 1037 } 1038 1039 /* Set Adapter to DHCP/Static Mode */ 1040 if (boot_proto == ISCSI_BOOTPROTO_DHCP) { 1041 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1042 OPCODE_COMMON_ISCSI_NTWK_CONFIG_STATELESS_IP_ADDR, 1043 sizeof(*dhcpreq)); 1044 if (rc) 1045 return rc; 1046 1047 dhcpreq = nonemb_cmd.va; 1048 dhcpreq->flags = BLOCKING; 1049 dhcpreq->retry_count = 1; 1050 dhcpreq->interface_hndl = phba->interface_handle; 1051 dhcpreq->ip_type = BE2_DHCP_V4; 1052 1053 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 1054 } else { 1055 return mgmt_static_ip_modify(phba, if_info, ip_param, 1056 subnet_param, IP_ACTION_ADD); 1057 } 1058 1059 return rc; 1060 } 1061 1062 int mgmt_set_gateway(struct beiscsi_hba *phba, 1063 struct iscsi_iface_param_info *gateway_param) 1064 { 1065 struct be_cmd_get_def_gateway_resp gtway_addr_set; 1066 uint8_t *gtway_addr; 1067 int rt_val; 1068 1069 memset(>way_addr_set, 0, sizeof(gtway_addr_set)); 1070 rt_val = mgmt_get_gateway(phba, BE2_IPV4, >way_addr_set); 1071 if (rt_val) { 1072 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1073 "BG_%d : Failed to Get Gateway Addr\n"); 1074 return rt_val; 1075 } 1076 1077 if (gtway_addr_set.ip_addr.addr[0]) { 1078 gtway_addr = (uint8_t *)>way_addr_set.ip_addr.addr; 1079 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_DEL, 1080 gateway_param->len); 1081 if (rt_val) { 1082 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1083 "BG_%d : Failed to clear Gateway Addr Set\n"); 1084 return rt_val; 1085 } 1086 } 1087 1088 gtway_addr = (uint8_t *)&gateway_param->value; 1089 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_ADD, 1090 gateway_param->len); 1091 1092 if (rt_val) 1093 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1094 "BG_%d : Failed to Set Gateway Addr\n"); 1095 1096 return rt_val; 1097 } 1098 1099 int mgmt_get_gateway(struct beiscsi_hba *phba, int ip_type, 1100 struct be_cmd_get_def_gateway_resp *gateway) 1101 { 1102 struct be_cmd_get_def_gateway_req *req; 1103 struct be_dma_mem nonemb_cmd; 1104 int rc; 1105 1106 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1107 OPCODE_COMMON_ISCSI_NTWK_GET_DEFAULT_GATEWAY, 1108 sizeof(*gateway)); 1109 if (rc) 1110 return rc; 1111 1112 req = nonemb_cmd.va; 1113 req->ip_type = ip_type; 1114 1115 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, gateway, 1116 sizeof(*gateway)); 1117 } 1118 1119 int mgmt_get_if_info(struct beiscsi_hba *phba, int ip_type, 1120 struct be_cmd_get_if_info_resp **if_info) 1121 { 1122 struct be_cmd_get_if_info_req *req; 1123 struct be_dma_mem nonemb_cmd; 1124 uint32_t ioctl_size = sizeof(struct be_cmd_get_if_info_resp); 1125 int rc; 1126 1127 if (mgmt_get_all_if_id(phba)) 1128 return -EIO; 1129 1130 do { 1131 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1132 OPCODE_COMMON_ISCSI_NTWK_GET_IF_INFO, 1133 ioctl_size); 1134 if (rc) 1135 return rc; 1136 1137 req = nonemb_cmd.va; 1138 req->interface_hndl = phba->interface_handle; 1139 req->ip_type = ip_type; 1140 1141 /* Allocate memory for if_info */ 1142 *if_info = kzalloc(ioctl_size, GFP_KERNEL); 1143 if (!*if_info) { 1144 beiscsi_log(phba, KERN_ERR, 1145 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1146 "BG_%d : Memory Allocation Failure\n"); 1147 1148 /* Free the DMA memory for the IOCTL issuing */ 1149 pci_free_consistent(phba->ctrl.pdev, 1150 nonemb_cmd.size, 1151 nonemb_cmd.va, 1152 nonemb_cmd.dma); 1153 return -ENOMEM; 1154 } 1155 1156 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, *if_info, 1157 ioctl_size); 1158 1159 /* Check if the error is because of Insufficent_Buffer */ 1160 if (rc == -EAGAIN) { 1161 1162 /* Get the new memory size */ 1163 ioctl_size = ((struct be_cmd_resp_hdr *) 1164 nonemb_cmd.va)->actual_resp_len; 1165 ioctl_size += sizeof(struct be_cmd_req_hdr); 1166 1167 /* Free the previous allocated DMA memory */ 1168 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size, 1169 nonemb_cmd.va, 1170 nonemb_cmd.dma); 1171 1172 /* Free the virtual memory */ 1173 kfree(*if_info); 1174 } else 1175 break; 1176 } while (true); 1177 return rc; 1178 } 1179 1180 int mgmt_get_nic_conf(struct beiscsi_hba *phba, 1181 struct be_cmd_get_nic_conf_resp *nic) 1182 { 1183 struct be_dma_mem nonemb_cmd; 1184 int rc; 1185 1186 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1187 OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG, 1188 sizeof(*nic)); 1189 if (rc) 1190 return rc; 1191 1192 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, nic, sizeof(*nic)); 1193 } 1194 1195 1196 1197 unsigned int be_cmd_get_initname(struct beiscsi_hba *phba) 1198 { 1199 unsigned int tag = 0; 1200 struct be_mcc_wrb *wrb; 1201 struct be_cmd_hba_name *req; 1202 struct be_ctrl_info *ctrl = &phba->ctrl; 1203 1204 spin_lock(&ctrl->mbox_lock); 1205 tag = alloc_mcc_tag(phba); 1206 if (!tag) { 1207 spin_unlock(&ctrl->mbox_lock); 1208 return tag; 1209 } 1210 1211 wrb = wrb_from_mccq(phba); 1212 req = embedded_payload(wrb); 1213 wrb->tag0 |= tag; 1214 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 1215 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 1216 OPCODE_ISCSI_INI_CFG_GET_HBA_NAME, 1217 sizeof(*req)); 1218 1219 be_mcc_notify(phba); 1220 spin_unlock(&ctrl->mbox_lock); 1221 return tag; 1222 } 1223 1224 unsigned int be_cmd_get_port_speed(struct beiscsi_hba *phba) 1225 { 1226 unsigned int tag = 0; 1227 struct be_mcc_wrb *wrb; 1228 struct be_cmd_ntwk_link_status_req *req; 1229 struct be_ctrl_info *ctrl = &phba->ctrl; 1230 1231 spin_lock(&ctrl->mbox_lock); 1232 tag = alloc_mcc_tag(phba); 1233 if (!tag) { 1234 spin_unlock(&ctrl->mbox_lock); 1235 return tag; 1236 } 1237 1238 wrb = wrb_from_mccq(phba); 1239 req = embedded_payload(wrb); 1240 wrb->tag0 |= tag; 1241 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 1242 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON, 1243 OPCODE_COMMON_NTWK_LINK_STATUS_QUERY, 1244 sizeof(*req)); 1245 1246 be_mcc_notify(phba); 1247 spin_unlock(&ctrl->mbox_lock); 1248 return tag; 1249 } 1250 1251 /** 1252 * be_mgmt_get_boot_shandle()- Get the session handle 1253 * @phba: device priv structure instance 1254 * @s_handle: session handle returned for boot session. 1255 * 1256 * Get the boot target session handle. In case of 1257 * crashdump mode driver has to issue and MBX Cmd 1258 * for FW to login to boot target 1259 * 1260 * return 1261 * Success: 0 1262 * Failure: Non-Zero value 1263 * 1264 **/ 1265 int be_mgmt_get_boot_shandle(struct beiscsi_hba *phba, 1266 unsigned int *s_handle) 1267 { 1268 struct be_cmd_get_boot_target_resp *boot_resp; 1269 struct be_mcc_wrb *wrb; 1270 unsigned int tag; 1271 uint8_t boot_retry = 3; 1272 int rc; 1273 1274 do { 1275 /* Get the Boot Target Session Handle and Count*/ 1276 tag = mgmt_get_boot_target(phba); 1277 if (!tag) { 1278 beiscsi_log(phba, KERN_ERR, 1279 BEISCSI_LOG_CONFIG | BEISCSI_LOG_INIT, 1280 "BG_%d : Getting Boot Target Info Failed\n"); 1281 return -EAGAIN; 1282 } 1283 1284 rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL); 1285 if (rc) { 1286 beiscsi_log(phba, KERN_ERR, 1287 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1288 "BG_%d : MBX CMD get_boot_target Failed\n"); 1289 return -EBUSY; 1290 } 1291 1292 boot_resp = embedded_payload(wrb); 1293 1294 /* Check if the there are any Boot targets configured */ 1295 if (!boot_resp->boot_session_count) { 1296 beiscsi_log(phba, KERN_INFO, 1297 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1298 "BG_%d ;No boot targets configured\n"); 1299 return -ENXIO; 1300 } 1301 1302 /* FW returns the session handle of the boot session */ 1303 if (boot_resp->boot_session_handle != INVALID_SESS_HANDLE) { 1304 *s_handle = boot_resp->boot_session_handle; 1305 return 0; 1306 } 1307 1308 /* Issue MBX Cmd to FW to login to the boot target */ 1309 tag = mgmt_reopen_session(phba, BE_REOPEN_BOOT_SESSIONS, 1310 INVALID_SESS_HANDLE); 1311 if (!tag) { 1312 beiscsi_log(phba, KERN_ERR, 1313 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1314 "BG_%d : mgmt_reopen_session Failed\n"); 1315 return -EAGAIN; 1316 } 1317 1318 rc = beiscsi_mccq_compl(phba, tag, NULL, NULL); 1319 if (rc) { 1320 beiscsi_log(phba, KERN_ERR, 1321 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1322 "BG_%d : mgmt_reopen_session Failed"); 1323 return rc; 1324 } 1325 } while (--boot_retry); 1326 1327 /* Couldn't log into the boot target */ 1328 beiscsi_log(phba, KERN_ERR, 1329 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1330 "BG_%d : Login to Boot Target Failed\n"); 1331 return -ENXIO; 1332 } 1333 1334 /** 1335 * mgmt_set_vlan()- Issue and wait for CMD completion 1336 * @phba: device private structure instance 1337 * @vlan_tag: VLAN tag 1338 * 1339 * Issue the MBX Cmd and wait for the completion of the 1340 * command. 1341 * 1342 * returns 1343 * Success: 0 1344 * Failure: Non-Xero Value 1345 **/ 1346 int mgmt_set_vlan(struct beiscsi_hba *phba, 1347 uint16_t vlan_tag) 1348 { 1349 int rc; 1350 unsigned int tag; 1351 struct be_mcc_wrb *wrb = NULL; 1352 1353 tag = be_cmd_set_vlan(phba, vlan_tag); 1354 if (!tag) { 1355 beiscsi_log(phba, KERN_ERR, 1356 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX), 1357 "BG_%d : VLAN Setting Failed\n"); 1358 return -EBUSY; 1359 } 1360 1361 rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL); 1362 if (rc) { 1363 beiscsi_log(phba, KERN_ERR, 1364 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX), 1365 "BS_%d : VLAN MBX Cmd Failed\n"); 1366 return rc; 1367 } 1368 return rc; 1369 } 1370 1371 /** 1372 * beiscsi_drvr_ver_disp()- Display the driver Name and Version 1373 * @dev: ptr to device not used. 1374 * @attr: device attribute, not used. 1375 * @buf: contains formatted text driver name and version 1376 * 1377 * return 1378 * size of the formatted string 1379 **/ 1380 ssize_t 1381 beiscsi_drvr_ver_disp(struct device *dev, struct device_attribute *attr, 1382 char *buf) 1383 { 1384 return snprintf(buf, PAGE_SIZE, BE_NAME "\n"); 1385 } 1386 1387 /** 1388 * beiscsi_fw_ver_disp()- Display Firmware Version 1389 * @dev: ptr to device not used. 1390 * @attr: device attribute, not used. 1391 * @buf: contains formatted text Firmware version 1392 * 1393 * return 1394 * size of the formatted string 1395 **/ 1396 ssize_t 1397 beiscsi_fw_ver_disp(struct device *dev, struct device_attribute *attr, 1398 char *buf) 1399 { 1400 struct Scsi_Host *shost = class_to_shost(dev); 1401 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1402 1403 return snprintf(buf, PAGE_SIZE, "%s\n", phba->fw_ver_str); 1404 } 1405 1406 /** 1407 * beiscsi_active_session_disp()- Display Sessions Active 1408 * @dev: ptr to device not used. 1409 * @attr: device attribute, not used. 1410 * @buf: contains formatted text Session Count 1411 * 1412 * return 1413 * size of the formatted string 1414 **/ 1415 ssize_t 1416 beiscsi_active_session_disp(struct device *dev, struct device_attribute *attr, 1417 char *buf) 1418 { 1419 struct Scsi_Host *shost = class_to_shost(dev); 1420 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1421 uint16_t avlbl_cids = 0, ulp_num, len = 0, total_cids = 0; 1422 1423 for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) { 1424 if (test_bit(ulp_num, (void *)&phba->fw_config.ulp_supported)) { 1425 avlbl_cids = BEISCSI_ULP_AVLBL_CID(phba, ulp_num); 1426 total_cids = BEISCSI_GET_CID_COUNT(phba, ulp_num); 1427 len += snprintf(buf+len, PAGE_SIZE - len, 1428 "ULP%d : %d\n", ulp_num, 1429 (total_cids - avlbl_cids)); 1430 } else 1431 len += snprintf(buf+len, PAGE_SIZE - len, 1432 "ULP%d : %d\n", ulp_num, 0); 1433 } 1434 1435 return len; 1436 } 1437 1438 /** 1439 * beiscsi_free_session_disp()- Display Avaliable Session 1440 * @dev: ptr to device not used. 1441 * @attr: device attribute, not used. 1442 * @buf: contains formatted text Session Count 1443 * 1444 * return 1445 * size of the formatted string 1446 **/ 1447 ssize_t 1448 beiscsi_free_session_disp(struct device *dev, struct device_attribute *attr, 1449 char *buf) 1450 { 1451 struct Scsi_Host *shost = class_to_shost(dev); 1452 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1453 uint16_t ulp_num, len = 0; 1454 1455 for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) { 1456 if (test_bit(ulp_num, (void *)&phba->fw_config.ulp_supported)) 1457 len += snprintf(buf+len, PAGE_SIZE - len, 1458 "ULP%d : %d\n", ulp_num, 1459 BEISCSI_ULP_AVLBL_CID(phba, ulp_num)); 1460 else 1461 len += snprintf(buf+len, PAGE_SIZE - len, 1462 "ULP%d : %d\n", ulp_num, 0); 1463 } 1464 1465 return len; 1466 } 1467 1468 /** 1469 * beiscsi_adap_family_disp()- Display adapter family. 1470 * @dev: ptr to device to get priv structure 1471 * @attr: device attribute, not used. 1472 * @buf: contains formatted text driver name and version 1473 * 1474 * return 1475 * size of the formatted string 1476 **/ 1477 ssize_t 1478 beiscsi_adap_family_disp(struct device *dev, struct device_attribute *attr, 1479 char *buf) 1480 { 1481 uint16_t dev_id = 0; 1482 struct Scsi_Host *shost = class_to_shost(dev); 1483 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1484 1485 dev_id = phba->pcidev->device; 1486 switch (dev_id) { 1487 case BE_DEVICE_ID1: 1488 case OC_DEVICE_ID1: 1489 case OC_DEVICE_ID2: 1490 return snprintf(buf, PAGE_SIZE, "BE2 Adapter Family\n"); 1491 break; 1492 case BE_DEVICE_ID2: 1493 case OC_DEVICE_ID3: 1494 return snprintf(buf, PAGE_SIZE, "BE3-R Adapter Family\n"); 1495 break; 1496 case OC_SKH_ID1: 1497 return snprintf(buf, PAGE_SIZE, "Skyhawk-R Adapter Family\n"); 1498 break; 1499 default: 1500 return snprintf(buf, PAGE_SIZE, 1501 "Unknown Adapter Family: 0x%x\n", dev_id); 1502 break; 1503 } 1504 } 1505 1506 /** 1507 * beiscsi_phys_port()- Display Physical Port Identifier 1508 * @dev: ptr to device not used. 1509 * @attr: device attribute, not used. 1510 * @buf: contains formatted text port identifier 1511 * 1512 * return 1513 * size of the formatted string 1514 **/ 1515 ssize_t 1516 beiscsi_phys_port_disp(struct device *dev, struct device_attribute *attr, 1517 char *buf) 1518 { 1519 struct Scsi_Host *shost = class_to_shost(dev); 1520 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1521 1522 return snprintf(buf, PAGE_SIZE, "Port Identifier : %d\n", 1523 phba->fw_config.phys_port); 1524 } 1525 1526 void beiscsi_offload_cxn_v0(struct beiscsi_offload_params *params, 1527 struct wrb_handle *pwrb_handle, 1528 struct be_mem_descriptor *mem_descr) 1529 { 1530 struct iscsi_wrb *pwrb = pwrb_handle->pwrb; 1531 1532 memset(pwrb, 0, sizeof(*pwrb)); 1533 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1534 max_send_data_segment_length, pwrb, 1535 params->dw[offsetof(struct amap_beiscsi_offload_params, 1536 max_send_data_segment_length) / 32]); 1537 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, type, pwrb, 1538 BE_TGT_CTX_UPDT_CMD); 1539 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1540 first_burst_length, 1541 pwrb, 1542 params->dw[offsetof(struct amap_beiscsi_offload_params, 1543 first_burst_length) / 32]); 1544 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, erl, pwrb, 1545 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1546 erl) / 32] & OFFLD_PARAMS_ERL)); 1547 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, dde, pwrb, 1548 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1549 dde) / 32] & OFFLD_PARAMS_DDE) >> 2); 1550 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, hde, pwrb, 1551 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1552 hde) / 32] & OFFLD_PARAMS_HDE) >> 3); 1553 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ir2t, pwrb, 1554 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1555 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4); 1556 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, imd, pwrb, 1557 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1558 imd) / 32] & OFFLD_PARAMS_IMD) >> 5); 1559 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, stat_sn, 1560 pwrb, 1561 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1562 exp_statsn) / 32] + 1)); 1563 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, wrb_idx, 1564 pwrb, pwrb_handle->wrb_index); 1565 1566 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1567 max_burst_length, pwrb, params->dw[offsetof 1568 (struct amap_beiscsi_offload_params, 1569 max_burst_length) / 32]); 1570 1571 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ptr2nextwrb, 1572 pwrb, pwrb_handle->nxt_wrb_index); 1573 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1574 session_state, pwrb, 0); 1575 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, compltonack, 1576 pwrb, 1); 1577 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, notpredblq, 1578 pwrb, 0); 1579 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, mode, pwrb, 1580 0); 1581 1582 mem_descr += ISCSI_MEM_GLOBAL_HEADER; 1583 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1584 pad_buffer_addr_hi, pwrb, 1585 mem_descr->mem_array[0].bus_address.u.a32.address_hi); 1586 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1587 pad_buffer_addr_lo, pwrb, 1588 mem_descr->mem_array[0].bus_address.u.a32.address_lo); 1589 } 1590 1591 void beiscsi_offload_cxn_v2(struct beiscsi_offload_params *params, 1592 struct wrb_handle *pwrb_handle) 1593 { 1594 struct iscsi_wrb *pwrb = pwrb_handle->pwrb; 1595 1596 memset(pwrb, 0, sizeof(*pwrb)); 1597 1598 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1599 max_burst_length, pwrb, params->dw[offsetof 1600 (struct amap_beiscsi_offload_params, 1601 max_burst_length) / 32]); 1602 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1603 type, pwrb, 1604 BE_TGT_CTX_UPDT_CMD); 1605 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1606 ptr2nextwrb, 1607 pwrb, pwrb_handle->nxt_wrb_index); 1608 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, wrb_idx, 1609 pwrb, pwrb_handle->wrb_index); 1610 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1611 max_send_data_segment_length, pwrb, 1612 params->dw[offsetof(struct amap_beiscsi_offload_params, 1613 max_send_data_segment_length) / 32]); 1614 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1615 first_burst_length, pwrb, 1616 params->dw[offsetof(struct amap_beiscsi_offload_params, 1617 first_burst_length) / 32]); 1618 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1619 max_recv_dataseg_len, pwrb, 1620 params->dw[offsetof(struct amap_beiscsi_offload_params, 1621 max_recv_data_segment_length) / 32]); 1622 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1623 max_cxns, pwrb, BEISCSI_MAX_CXNS); 1624 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, erl, pwrb, 1625 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1626 erl) / 32] & OFFLD_PARAMS_ERL)); 1627 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, dde, pwrb, 1628 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1629 dde) / 32] & OFFLD_PARAMS_DDE) >> 2); 1630 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, hde, pwrb, 1631 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1632 hde) / 32] & OFFLD_PARAMS_HDE) >> 3); 1633 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1634 ir2t, pwrb, 1635 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1636 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4); 1637 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, imd, pwrb, 1638 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1639 imd) / 32] & OFFLD_PARAMS_IMD) >> 5); 1640 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1641 data_seq_inorder, 1642 pwrb, 1643 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1644 data_seq_inorder) / 32] & 1645 OFFLD_PARAMS_DATA_SEQ_INORDER) >> 6); 1646 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1647 pdu_seq_inorder, 1648 pwrb, 1649 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1650 pdu_seq_inorder) / 32] & 1651 OFFLD_PARAMS_PDU_SEQ_INORDER) >> 7); 1652 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, max_r2t, 1653 pwrb, 1654 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1655 max_r2t) / 32] & 1656 OFFLD_PARAMS_MAX_R2T) >> 8); 1657 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, stat_sn, 1658 pwrb, 1659 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1660 exp_statsn) / 32] + 1)); 1661 } 1662