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); 832 833 if (resp_buf) 834 memcpy(resp_buf, nonemb_cmd->va, resp_buf_len); 835 836 if (rc) { 837 /* Check if the MBX Cmd needs to be re-issued */ 838 if (rc == -EAGAIN) 839 return rc; 840 841 beiscsi_log(phba, KERN_WARNING, 842 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX, 843 "BG_%d : mgmt_exec_nonemb_cmd Failed status\n"); 844 845 if (rc != -EBUSY) 846 goto free_cmd; 847 else 848 return rc; 849 } 850 free_cmd: 851 pci_free_consistent(ctrl->pdev, nonemb_cmd->size, 852 nonemb_cmd->va, nonemb_cmd->dma); 853 return rc; 854 } 855 856 static int mgmt_alloc_cmd_data(struct beiscsi_hba *phba, struct be_dma_mem *cmd, 857 int iscsi_cmd, int size) 858 { 859 cmd->va = pci_alloc_consistent(phba->ctrl.pdev, size, &cmd->dma); 860 if (!cmd->va) { 861 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG, 862 "BG_%d : Failed to allocate memory for if info\n"); 863 return -ENOMEM; 864 } 865 memset(cmd->va, 0, size); 866 cmd->size = size; 867 be_cmd_hdr_prepare(cmd->va, CMD_SUBSYSTEM_ISCSI, iscsi_cmd, size); 868 return 0; 869 } 870 871 static int 872 mgmt_static_ip_modify(struct beiscsi_hba *phba, 873 struct be_cmd_get_if_info_resp *if_info, 874 struct iscsi_iface_param_info *ip_param, 875 struct iscsi_iface_param_info *subnet_param, 876 uint32_t ip_action) 877 { 878 struct be_cmd_set_ip_addr_req *req; 879 struct be_dma_mem nonemb_cmd; 880 uint32_t ip_type; 881 int rc; 882 883 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 884 OPCODE_COMMON_ISCSI_NTWK_MODIFY_IP_ADDR, 885 sizeof(*req)); 886 if (rc) 887 return rc; 888 889 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ? 890 BE2_IPV6 : BE2_IPV4 ; 891 892 req = nonemb_cmd.va; 893 req->ip_params.record_entry_count = 1; 894 req->ip_params.ip_record.action = ip_action; 895 req->ip_params.ip_record.interface_hndl = 896 phba->interface_handle; 897 req->ip_params.ip_record.ip_addr.size_of_structure = 898 sizeof(struct be_ip_addr_subnet_format); 899 req->ip_params.ip_record.ip_addr.ip_type = ip_type; 900 901 if (ip_action == IP_ACTION_ADD) { 902 memcpy(req->ip_params.ip_record.ip_addr.addr, ip_param->value, 903 ip_param->len); 904 905 if (subnet_param) 906 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask, 907 subnet_param->value, subnet_param->len); 908 } else { 909 memcpy(req->ip_params.ip_record.ip_addr.addr, 910 if_info->ip_addr.addr, ip_param->len); 911 912 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask, 913 if_info->ip_addr.subnet_mask, ip_param->len); 914 } 915 916 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 917 if (rc < 0) 918 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 919 "BG_%d : Failed to Modify existing IP Address\n"); 920 return rc; 921 } 922 923 static int mgmt_modify_gateway(struct beiscsi_hba *phba, uint8_t *gt_addr, 924 uint32_t gtway_action, uint32_t param_len) 925 { 926 struct be_cmd_set_def_gateway_req *req; 927 struct be_dma_mem nonemb_cmd; 928 int rt_val; 929 930 931 rt_val = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 932 OPCODE_COMMON_ISCSI_NTWK_MODIFY_DEFAULT_GATEWAY, 933 sizeof(*req)); 934 if (rt_val) 935 return rt_val; 936 937 req = nonemb_cmd.va; 938 req->action = gtway_action; 939 req->ip_addr.ip_type = BE2_IPV4; 940 941 memcpy(req->ip_addr.addr, gt_addr, param_len); 942 943 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 944 } 945 946 int mgmt_set_ip(struct beiscsi_hba *phba, 947 struct iscsi_iface_param_info *ip_param, 948 struct iscsi_iface_param_info *subnet_param, 949 uint32_t boot_proto) 950 { 951 struct be_cmd_get_def_gateway_resp gtway_addr_set; 952 struct be_cmd_get_if_info_resp *if_info; 953 struct be_cmd_set_dhcp_req *dhcpreq; 954 struct be_cmd_rel_dhcp_req *reldhcp; 955 struct be_dma_mem nonemb_cmd; 956 uint8_t *gtway_addr; 957 uint32_t ip_type; 958 int rc; 959 960 if (mgmt_get_all_if_id(phba)) 961 return -EIO; 962 963 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ? 964 BE2_IPV6 : BE2_IPV4 ; 965 966 rc = mgmt_get_if_info(phba, ip_type, &if_info); 967 if (rc) { 968 kfree(if_info); 969 return rc; 970 } 971 972 if (boot_proto == ISCSI_BOOTPROTO_DHCP) { 973 if (if_info->dhcp_state) { 974 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 975 "BG_%d : DHCP Already Enabled\n"); 976 return 0; 977 } 978 /* The ip_param->len is 1 in DHCP case. Setting 979 proper IP len as this it is used while 980 freeing the Static IP. 981 */ 982 ip_param->len = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ? 983 IP_V6_LEN : IP_V4_LEN; 984 985 } else { 986 if (if_info->dhcp_state) { 987 988 memset(if_info, 0, sizeof(*if_info)); 989 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 990 OPCODE_COMMON_ISCSI_NTWK_REL_STATELESS_IP_ADDR, 991 sizeof(*reldhcp)); 992 993 if (rc) 994 return rc; 995 996 reldhcp = nonemb_cmd.va; 997 reldhcp->interface_hndl = phba->interface_handle; 998 reldhcp->ip_type = ip_type; 999 1000 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 1001 if (rc < 0) { 1002 beiscsi_log(phba, KERN_WARNING, 1003 BEISCSI_LOG_CONFIG, 1004 "BG_%d : Failed to Delete existing dhcp\n"); 1005 return rc; 1006 } 1007 } 1008 } 1009 1010 /* Delete the Static IP Set */ 1011 if (if_info->ip_addr.addr[0]) { 1012 rc = mgmt_static_ip_modify(phba, if_info, ip_param, NULL, 1013 IP_ACTION_DEL); 1014 if (rc) 1015 return rc; 1016 } 1017 1018 /* Delete the Gateway settings if mode change is to DHCP */ 1019 if (boot_proto == ISCSI_BOOTPROTO_DHCP) { 1020 memset(>way_addr_set, 0, sizeof(gtway_addr_set)); 1021 rc = mgmt_get_gateway(phba, BE2_IPV4, >way_addr_set); 1022 if (rc) { 1023 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1024 "BG_%d : Failed to Get Gateway Addr\n"); 1025 return rc; 1026 } 1027 1028 if (gtway_addr_set.ip_addr.addr[0]) { 1029 gtway_addr = (uint8_t *)>way_addr_set.ip_addr.addr; 1030 rc = mgmt_modify_gateway(phba, gtway_addr, 1031 IP_ACTION_DEL, IP_V4_LEN); 1032 1033 if (rc) { 1034 beiscsi_log(phba, KERN_WARNING, 1035 BEISCSI_LOG_CONFIG, 1036 "BG_%d : Failed to clear Gateway Addr Set\n"); 1037 return rc; 1038 } 1039 } 1040 } 1041 1042 /* Set Adapter to DHCP/Static Mode */ 1043 if (boot_proto == ISCSI_BOOTPROTO_DHCP) { 1044 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1045 OPCODE_COMMON_ISCSI_NTWK_CONFIG_STATELESS_IP_ADDR, 1046 sizeof(*dhcpreq)); 1047 if (rc) 1048 return rc; 1049 1050 dhcpreq = nonemb_cmd.va; 1051 dhcpreq->flags = BLOCKING; 1052 dhcpreq->retry_count = 1; 1053 dhcpreq->interface_hndl = phba->interface_handle; 1054 dhcpreq->ip_type = BE2_DHCP_V4; 1055 1056 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 1057 } else { 1058 return mgmt_static_ip_modify(phba, if_info, ip_param, 1059 subnet_param, IP_ACTION_ADD); 1060 } 1061 1062 return rc; 1063 } 1064 1065 int mgmt_set_gateway(struct beiscsi_hba *phba, 1066 struct iscsi_iface_param_info *gateway_param) 1067 { 1068 struct be_cmd_get_def_gateway_resp gtway_addr_set; 1069 uint8_t *gtway_addr; 1070 int rt_val; 1071 1072 memset(>way_addr_set, 0, sizeof(gtway_addr_set)); 1073 rt_val = mgmt_get_gateway(phba, BE2_IPV4, >way_addr_set); 1074 if (rt_val) { 1075 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1076 "BG_%d : Failed to Get Gateway Addr\n"); 1077 return rt_val; 1078 } 1079 1080 if (gtway_addr_set.ip_addr.addr[0]) { 1081 gtway_addr = (uint8_t *)>way_addr_set.ip_addr.addr; 1082 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_DEL, 1083 gateway_param->len); 1084 if (rt_val) { 1085 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1086 "BG_%d : Failed to clear Gateway Addr Set\n"); 1087 return rt_val; 1088 } 1089 } 1090 1091 gtway_addr = (uint8_t *)&gateway_param->value; 1092 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_ADD, 1093 gateway_param->len); 1094 1095 if (rt_val) 1096 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1097 "BG_%d : Failed to Set Gateway Addr\n"); 1098 1099 return rt_val; 1100 } 1101 1102 int mgmt_get_gateway(struct beiscsi_hba *phba, int ip_type, 1103 struct be_cmd_get_def_gateway_resp *gateway) 1104 { 1105 struct be_cmd_get_def_gateway_req *req; 1106 struct be_dma_mem nonemb_cmd; 1107 int rc; 1108 1109 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1110 OPCODE_COMMON_ISCSI_NTWK_GET_DEFAULT_GATEWAY, 1111 sizeof(*gateway)); 1112 if (rc) 1113 return rc; 1114 1115 req = nonemb_cmd.va; 1116 req->ip_type = ip_type; 1117 1118 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, gateway, 1119 sizeof(*gateway)); 1120 } 1121 1122 int mgmt_get_if_info(struct beiscsi_hba *phba, int ip_type, 1123 struct be_cmd_get_if_info_resp **if_info) 1124 { 1125 struct be_cmd_get_if_info_req *req; 1126 struct be_dma_mem nonemb_cmd; 1127 uint32_t ioctl_size = sizeof(struct be_cmd_get_if_info_resp); 1128 int rc; 1129 1130 if (mgmt_get_all_if_id(phba)) 1131 return -EIO; 1132 1133 do { 1134 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1135 OPCODE_COMMON_ISCSI_NTWK_GET_IF_INFO, 1136 ioctl_size); 1137 if (rc) 1138 return rc; 1139 1140 req = nonemb_cmd.va; 1141 req->interface_hndl = phba->interface_handle; 1142 req->ip_type = ip_type; 1143 1144 /* Allocate memory for if_info */ 1145 *if_info = kzalloc(ioctl_size, GFP_KERNEL); 1146 if (!*if_info) { 1147 beiscsi_log(phba, KERN_ERR, 1148 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1149 "BG_%d : Memory Allocation Failure\n"); 1150 1151 /* Free the DMA memory for the IOCTL issuing */ 1152 pci_free_consistent(phba->ctrl.pdev, 1153 nonemb_cmd.size, 1154 nonemb_cmd.va, 1155 nonemb_cmd.dma); 1156 return -ENOMEM; 1157 } 1158 1159 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, *if_info, 1160 ioctl_size); 1161 1162 /* Check if the error is because of Insufficent_Buffer */ 1163 if (rc == -EAGAIN) { 1164 1165 /* Get the new memory size */ 1166 ioctl_size = ((struct be_cmd_resp_hdr *) 1167 nonemb_cmd.va)->actual_resp_len; 1168 ioctl_size += sizeof(struct be_cmd_req_hdr); 1169 1170 /* Free the previous allocated DMA memory */ 1171 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size, 1172 nonemb_cmd.va, 1173 nonemb_cmd.dma); 1174 1175 /* Free the virtual memory */ 1176 kfree(*if_info); 1177 } else 1178 break; 1179 } while (true); 1180 return rc; 1181 } 1182 1183 int mgmt_get_nic_conf(struct beiscsi_hba *phba, 1184 struct be_cmd_get_nic_conf_resp *nic) 1185 { 1186 struct be_dma_mem nonemb_cmd; 1187 int rc; 1188 1189 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1190 OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG, 1191 sizeof(*nic)); 1192 if (rc) 1193 return rc; 1194 1195 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, nic, sizeof(*nic)); 1196 } 1197 1198 1199 1200 unsigned int be_cmd_get_initname(struct beiscsi_hba *phba) 1201 { 1202 unsigned int tag = 0; 1203 struct be_mcc_wrb *wrb; 1204 struct be_cmd_hba_name *req; 1205 struct be_ctrl_info *ctrl = &phba->ctrl; 1206 1207 spin_lock(&ctrl->mbox_lock); 1208 tag = alloc_mcc_tag(phba); 1209 if (!tag) { 1210 spin_unlock(&ctrl->mbox_lock); 1211 return tag; 1212 } 1213 1214 wrb = wrb_from_mccq(phba); 1215 req = embedded_payload(wrb); 1216 wrb->tag0 |= tag; 1217 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 1218 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 1219 OPCODE_ISCSI_INI_CFG_GET_HBA_NAME, 1220 sizeof(*req)); 1221 1222 be_mcc_notify(phba); 1223 spin_unlock(&ctrl->mbox_lock); 1224 return tag; 1225 } 1226 1227 unsigned int be_cmd_get_port_speed(struct beiscsi_hba *phba) 1228 { 1229 unsigned int tag = 0; 1230 struct be_mcc_wrb *wrb; 1231 struct be_cmd_ntwk_link_status_req *req; 1232 struct be_ctrl_info *ctrl = &phba->ctrl; 1233 1234 spin_lock(&ctrl->mbox_lock); 1235 tag = alloc_mcc_tag(phba); 1236 if (!tag) { 1237 spin_unlock(&ctrl->mbox_lock); 1238 return tag; 1239 } 1240 1241 wrb = wrb_from_mccq(phba); 1242 req = embedded_payload(wrb); 1243 wrb->tag0 |= tag; 1244 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 1245 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON, 1246 OPCODE_COMMON_NTWK_LINK_STATUS_QUERY, 1247 sizeof(*req)); 1248 1249 be_mcc_notify(phba); 1250 spin_unlock(&ctrl->mbox_lock); 1251 return tag; 1252 } 1253 1254 /** 1255 * be_mgmt_get_boot_shandle()- Get the session handle 1256 * @phba: device priv structure instance 1257 * @s_handle: session handle returned for boot session. 1258 * 1259 * Get the boot target session handle. In case of 1260 * crashdump mode driver has to issue and MBX Cmd 1261 * for FW to login to boot target 1262 * 1263 * return 1264 * Success: 0 1265 * Failure: Non-Zero value 1266 * 1267 **/ 1268 int be_mgmt_get_boot_shandle(struct beiscsi_hba *phba, 1269 unsigned int *s_handle) 1270 { 1271 struct be_cmd_get_boot_target_resp *boot_resp; 1272 struct be_mcc_wrb *wrb; 1273 unsigned int tag; 1274 uint8_t boot_retry = 3; 1275 int rc; 1276 1277 do { 1278 /* Get the Boot Target Session Handle and Count*/ 1279 tag = mgmt_get_boot_target(phba); 1280 if (!tag) { 1281 beiscsi_log(phba, KERN_ERR, 1282 BEISCSI_LOG_CONFIG | BEISCSI_LOG_INIT, 1283 "BG_%d : Getting Boot Target Info Failed\n"); 1284 return -EAGAIN; 1285 } 1286 1287 rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL); 1288 if (rc) { 1289 beiscsi_log(phba, KERN_ERR, 1290 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1291 "BG_%d : MBX CMD get_boot_target Failed\n"); 1292 return -EBUSY; 1293 } 1294 1295 boot_resp = embedded_payload(wrb); 1296 1297 /* Check if the there are any Boot targets configured */ 1298 if (!boot_resp->boot_session_count) { 1299 beiscsi_log(phba, KERN_INFO, 1300 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1301 "BG_%d ;No boot targets configured\n"); 1302 return -ENXIO; 1303 } 1304 1305 /* FW returns the session handle of the boot session */ 1306 if (boot_resp->boot_session_handle != INVALID_SESS_HANDLE) { 1307 *s_handle = boot_resp->boot_session_handle; 1308 return 0; 1309 } 1310 1311 /* Issue MBX Cmd to FW to login to the boot target */ 1312 tag = mgmt_reopen_session(phba, BE_REOPEN_BOOT_SESSIONS, 1313 INVALID_SESS_HANDLE); 1314 if (!tag) { 1315 beiscsi_log(phba, KERN_ERR, 1316 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1317 "BG_%d : mgmt_reopen_session Failed\n"); 1318 return -EAGAIN; 1319 } 1320 1321 rc = beiscsi_mccq_compl(phba, tag, NULL, NULL); 1322 if (rc) { 1323 beiscsi_log(phba, KERN_ERR, 1324 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1325 "BG_%d : mgmt_reopen_session Failed"); 1326 return rc; 1327 } 1328 } while (--boot_retry); 1329 1330 /* Couldn't log into the boot target */ 1331 beiscsi_log(phba, KERN_ERR, 1332 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1333 "BG_%d : Login to Boot Target Failed\n"); 1334 return -ENXIO; 1335 } 1336 1337 /** 1338 * mgmt_set_vlan()- Issue and wait for CMD completion 1339 * @phba: device private structure instance 1340 * @vlan_tag: VLAN tag 1341 * 1342 * Issue the MBX Cmd and wait for the completion of the 1343 * command. 1344 * 1345 * returns 1346 * Success: 0 1347 * Failure: Non-Xero Value 1348 **/ 1349 int mgmt_set_vlan(struct beiscsi_hba *phba, 1350 uint16_t vlan_tag) 1351 { 1352 int rc; 1353 unsigned int tag; 1354 1355 tag = be_cmd_set_vlan(phba, vlan_tag); 1356 if (!tag) { 1357 beiscsi_log(phba, KERN_ERR, 1358 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX), 1359 "BG_%d : VLAN Setting Failed\n"); 1360 return -EBUSY; 1361 } 1362 1363 rc = beiscsi_mccq_compl(phba, tag, NULL, NULL); 1364 if (rc) { 1365 beiscsi_log(phba, KERN_ERR, 1366 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX), 1367 "BS_%d : VLAN MBX Cmd Failed\n"); 1368 return rc; 1369 } 1370 return rc; 1371 } 1372 1373 /** 1374 * beiscsi_drvr_ver_disp()- Display the driver Name and Version 1375 * @dev: ptr to device not used. 1376 * @attr: device attribute, not used. 1377 * @buf: contains formatted text driver name and version 1378 * 1379 * return 1380 * size of the formatted string 1381 **/ 1382 ssize_t 1383 beiscsi_drvr_ver_disp(struct device *dev, struct device_attribute *attr, 1384 char *buf) 1385 { 1386 return snprintf(buf, PAGE_SIZE, BE_NAME "\n"); 1387 } 1388 1389 /** 1390 * beiscsi_fw_ver_disp()- Display Firmware Version 1391 * @dev: ptr to device not used. 1392 * @attr: device attribute, not used. 1393 * @buf: contains formatted text Firmware version 1394 * 1395 * return 1396 * size of the formatted string 1397 **/ 1398 ssize_t 1399 beiscsi_fw_ver_disp(struct device *dev, struct device_attribute *attr, 1400 char *buf) 1401 { 1402 struct Scsi_Host *shost = class_to_shost(dev); 1403 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1404 1405 return snprintf(buf, PAGE_SIZE, "%s\n", phba->fw_ver_str); 1406 } 1407 1408 /** 1409 * beiscsi_active_session_disp()- Display Sessions Active 1410 * @dev: ptr to device not used. 1411 * @attr: device attribute, not used. 1412 * @buf: contains formatted text Session Count 1413 * 1414 * return 1415 * size of the formatted string 1416 **/ 1417 ssize_t 1418 beiscsi_active_session_disp(struct device *dev, struct device_attribute *attr, 1419 char *buf) 1420 { 1421 struct Scsi_Host *shost = class_to_shost(dev); 1422 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1423 uint16_t avlbl_cids = 0, ulp_num, len = 0, total_cids = 0; 1424 1425 for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) { 1426 if (test_bit(ulp_num, (void *)&phba->fw_config.ulp_supported)) { 1427 avlbl_cids = BEISCSI_ULP_AVLBL_CID(phba, ulp_num); 1428 total_cids = BEISCSI_GET_CID_COUNT(phba, ulp_num); 1429 len += snprintf(buf+len, PAGE_SIZE - len, 1430 "ULP%d : %d\n", ulp_num, 1431 (total_cids - avlbl_cids)); 1432 } else 1433 len += snprintf(buf+len, PAGE_SIZE - len, 1434 "ULP%d : %d\n", ulp_num, 0); 1435 } 1436 1437 return len; 1438 } 1439 1440 /** 1441 * beiscsi_free_session_disp()- Display Avaliable Session 1442 * @dev: ptr to device not used. 1443 * @attr: device attribute, not used. 1444 * @buf: contains formatted text Session Count 1445 * 1446 * return 1447 * size of the formatted string 1448 **/ 1449 ssize_t 1450 beiscsi_free_session_disp(struct device *dev, struct device_attribute *attr, 1451 char *buf) 1452 { 1453 struct Scsi_Host *shost = class_to_shost(dev); 1454 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1455 uint16_t ulp_num, len = 0; 1456 1457 for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) { 1458 if (test_bit(ulp_num, (void *)&phba->fw_config.ulp_supported)) 1459 len += snprintf(buf+len, PAGE_SIZE - len, 1460 "ULP%d : %d\n", ulp_num, 1461 BEISCSI_ULP_AVLBL_CID(phba, ulp_num)); 1462 else 1463 len += snprintf(buf+len, PAGE_SIZE - len, 1464 "ULP%d : %d\n", ulp_num, 0); 1465 } 1466 1467 return len; 1468 } 1469 1470 /** 1471 * beiscsi_adap_family_disp()- Display adapter family. 1472 * @dev: ptr to device to get priv structure 1473 * @attr: device attribute, not used. 1474 * @buf: contains formatted text driver name and version 1475 * 1476 * return 1477 * size of the formatted string 1478 **/ 1479 ssize_t 1480 beiscsi_adap_family_disp(struct device *dev, struct device_attribute *attr, 1481 char *buf) 1482 { 1483 uint16_t dev_id = 0; 1484 struct Scsi_Host *shost = class_to_shost(dev); 1485 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1486 1487 dev_id = phba->pcidev->device; 1488 switch (dev_id) { 1489 case BE_DEVICE_ID1: 1490 case OC_DEVICE_ID1: 1491 case OC_DEVICE_ID2: 1492 return snprintf(buf, PAGE_SIZE, "BE2 Adapter Family\n"); 1493 break; 1494 case BE_DEVICE_ID2: 1495 case OC_DEVICE_ID3: 1496 return snprintf(buf, PAGE_SIZE, "BE3-R Adapter Family\n"); 1497 break; 1498 case OC_SKH_ID1: 1499 return snprintf(buf, PAGE_SIZE, "Skyhawk-R Adapter Family\n"); 1500 break; 1501 default: 1502 return snprintf(buf, PAGE_SIZE, 1503 "Unknown Adapter Family: 0x%x\n", dev_id); 1504 break; 1505 } 1506 } 1507 1508 /** 1509 * beiscsi_phys_port()- Display Physical Port Identifier 1510 * @dev: ptr to device not used. 1511 * @attr: device attribute, not used. 1512 * @buf: contains formatted text port identifier 1513 * 1514 * return 1515 * size of the formatted string 1516 **/ 1517 ssize_t 1518 beiscsi_phys_port_disp(struct device *dev, struct device_attribute *attr, 1519 char *buf) 1520 { 1521 struct Scsi_Host *shost = class_to_shost(dev); 1522 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1523 1524 return snprintf(buf, PAGE_SIZE, "Port Identifier : %d\n", 1525 phba->fw_config.phys_port); 1526 } 1527 1528 void beiscsi_offload_cxn_v0(struct beiscsi_offload_params *params, 1529 struct wrb_handle *pwrb_handle, 1530 struct be_mem_descriptor *mem_descr) 1531 { 1532 struct iscsi_wrb *pwrb = pwrb_handle->pwrb; 1533 1534 memset(pwrb, 0, sizeof(*pwrb)); 1535 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1536 max_send_data_segment_length, pwrb, 1537 params->dw[offsetof(struct amap_beiscsi_offload_params, 1538 max_send_data_segment_length) / 32]); 1539 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, type, pwrb, 1540 BE_TGT_CTX_UPDT_CMD); 1541 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1542 first_burst_length, 1543 pwrb, 1544 params->dw[offsetof(struct amap_beiscsi_offload_params, 1545 first_burst_length) / 32]); 1546 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, erl, pwrb, 1547 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1548 erl) / 32] & OFFLD_PARAMS_ERL)); 1549 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, dde, pwrb, 1550 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1551 dde) / 32] & OFFLD_PARAMS_DDE) >> 2); 1552 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, hde, pwrb, 1553 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1554 hde) / 32] & OFFLD_PARAMS_HDE) >> 3); 1555 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ir2t, pwrb, 1556 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1557 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4); 1558 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, imd, pwrb, 1559 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1560 imd) / 32] & OFFLD_PARAMS_IMD) >> 5); 1561 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, stat_sn, 1562 pwrb, 1563 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1564 exp_statsn) / 32] + 1)); 1565 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, wrb_idx, 1566 pwrb, pwrb_handle->wrb_index); 1567 1568 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1569 max_burst_length, pwrb, params->dw[offsetof 1570 (struct amap_beiscsi_offload_params, 1571 max_burst_length) / 32]); 1572 1573 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ptr2nextwrb, 1574 pwrb, pwrb_handle->nxt_wrb_index); 1575 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1576 session_state, pwrb, 0); 1577 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, compltonack, 1578 pwrb, 1); 1579 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, notpredblq, 1580 pwrb, 0); 1581 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, mode, pwrb, 1582 0); 1583 1584 mem_descr += ISCSI_MEM_GLOBAL_HEADER; 1585 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1586 pad_buffer_addr_hi, pwrb, 1587 mem_descr->mem_array[0].bus_address.u.a32.address_hi); 1588 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1589 pad_buffer_addr_lo, pwrb, 1590 mem_descr->mem_array[0].bus_address.u.a32.address_lo); 1591 } 1592 1593 void beiscsi_offload_cxn_v2(struct beiscsi_offload_params *params, 1594 struct wrb_handle *pwrb_handle) 1595 { 1596 struct iscsi_wrb *pwrb = pwrb_handle->pwrb; 1597 1598 memset(pwrb, 0, sizeof(*pwrb)); 1599 1600 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1601 max_burst_length, pwrb, params->dw[offsetof 1602 (struct amap_beiscsi_offload_params, 1603 max_burst_length) / 32]); 1604 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1605 type, pwrb, 1606 BE_TGT_CTX_UPDT_CMD); 1607 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1608 ptr2nextwrb, 1609 pwrb, pwrb_handle->nxt_wrb_index); 1610 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, wrb_idx, 1611 pwrb, pwrb_handle->wrb_index); 1612 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1613 max_send_data_segment_length, pwrb, 1614 params->dw[offsetof(struct amap_beiscsi_offload_params, 1615 max_send_data_segment_length) / 32]); 1616 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1617 first_burst_length, pwrb, 1618 params->dw[offsetof(struct amap_beiscsi_offload_params, 1619 first_burst_length) / 32]); 1620 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1621 max_recv_dataseg_len, pwrb, 1622 params->dw[offsetof(struct amap_beiscsi_offload_params, 1623 max_recv_data_segment_length) / 32]); 1624 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1625 max_cxns, pwrb, BEISCSI_MAX_CXNS); 1626 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, erl, pwrb, 1627 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1628 erl) / 32] & OFFLD_PARAMS_ERL)); 1629 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, dde, pwrb, 1630 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1631 dde) / 32] & OFFLD_PARAMS_DDE) >> 2); 1632 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, hde, pwrb, 1633 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1634 hde) / 32] & OFFLD_PARAMS_HDE) >> 3); 1635 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1636 ir2t, pwrb, 1637 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1638 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4); 1639 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, imd, pwrb, 1640 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1641 imd) / 32] & OFFLD_PARAMS_IMD) >> 5); 1642 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1643 data_seq_inorder, 1644 pwrb, 1645 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1646 data_seq_inorder) / 32] & 1647 OFFLD_PARAMS_DATA_SEQ_INORDER) >> 6); 1648 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1649 pdu_seq_inorder, 1650 pwrb, 1651 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1652 pdu_seq_inorder) / 32] & 1653 OFFLD_PARAMS_PDU_SEQ_INORDER) >> 7); 1654 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, max_r2t, 1655 pwrb, 1656 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1657 max_r2t) / 32] & 1658 OFFLD_PARAMS_MAX_R2T) >> 8); 1659 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, stat_sn, 1660 pwrb, 1661 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1662 exp_statsn) / 32] + 1)); 1663 } 1664