1 /** 2 * Copyright (C) 2005 - 2012 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 int mgmt_get_fw_config(struct be_ctrl_info *ctrl, 282 struct beiscsi_hba *phba) 283 { 284 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); 285 struct be_fw_cfg *req = embedded_payload(wrb); 286 int status = 0; 287 288 spin_lock(&ctrl->mbox_lock); 289 memset(wrb, 0, sizeof(*wrb)); 290 291 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 292 293 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON, 294 OPCODE_COMMON_QUERY_FIRMWARE_CONFIG, sizeof(*req)); 295 status = be_mbox_notify(ctrl); 296 if (!status) { 297 struct be_fw_cfg *pfw_cfg; 298 pfw_cfg = req; 299 phba->fw_config.phys_port = pfw_cfg->phys_port; 300 phba->fw_config.iscsi_icd_start = 301 pfw_cfg->ulp[0].icd_base; 302 phba->fw_config.iscsi_icd_count = 303 pfw_cfg->ulp[0].icd_count; 304 phba->fw_config.iscsi_cid_start = 305 pfw_cfg->ulp[0].sq_base; 306 phba->fw_config.iscsi_cid_count = 307 pfw_cfg->ulp[0].sq_count; 308 if (phba->fw_config.iscsi_cid_count > (BE2_MAX_SESSIONS / 2)) { 309 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, 310 "BG_%d : FW reported MAX CXNS as %d\t" 311 "Max Supported = %d.\n", 312 phba->fw_config.iscsi_cid_count, 313 BE2_MAX_SESSIONS); 314 phba->fw_config.iscsi_cid_count = BE2_MAX_SESSIONS / 2; 315 } 316 } else { 317 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT, 318 "BG_%d : Failed in mgmt_get_fw_config\n"); 319 } 320 321 spin_unlock(&ctrl->mbox_lock); 322 return status; 323 } 324 325 int mgmt_check_supported_fw(struct be_ctrl_info *ctrl, 326 struct beiscsi_hba *phba) 327 { 328 struct be_dma_mem nonemb_cmd; 329 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); 330 struct be_mgmt_controller_attributes *req; 331 struct be_sge *sge = nonembedded_sgl(wrb); 332 int status = 0; 333 334 nonemb_cmd.va = pci_alloc_consistent(ctrl->pdev, 335 sizeof(struct be_mgmt_controller_attributes), 336 &nonemb_cmd.dma); 337 if (nonemb_cmd.va == NULL) { 338 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, 339 "BG_%d : Failed to allocate memory for " 340 "mgmt_check_supported_fw\n"); 341 return -ENOMEM; 342 } 343 nonemb_cmd.size = sizeof(struct be_mgmt_controller_attributes); 344 req = nonemb_cmd.va; 345 memset(req, 0, sizeof(*req)); 346 spin_lock(&ctrl->mbox_lock); 347 memset(wrb, 0, sizeof(*wrb)); 348 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1); 349 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON, 350 OPCODE_COMMON_GET_CNTL_ATTRIBUTES, sizeof(*req)); 351 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd.dma)); 352 sge->pa_lo = cpu_to_le32(nonemb_cmd.dma & 0xFFFFFFFF); 353 sge->len = cpu_to_le32(nonemb_cmd.size); 354 status = be_mbox_notify(ctrl); 355 if (!status) { 356 struct be_mgmt_controller_attributes_resp *resp = nonemb_cmd.va; 357 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, 358 "BG_%d : Firmware Version of CMD : %s\n" 359 "Firmware Version is : %s\n" 360 "Developer Build, not performing version check...\n", 361 resp->params.hba_attribs 362 .flashrom_version_string, 363 resp->params.hba_attribs. 364 firmware_version_string); 365 366 phba->fw_config.iscsi_features = 367 resp->params.hba_attribs.iscsi_features; 368 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT, 369 "BM_%d : phba->fw_config.iscsi_features = %d\n", 370 phba->fw_config.iscsi_features); 371 } else 372 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, 373 "BG_%d : Failed in mgmt_check_supported_fw\n"); 374 spin_unlock(&ctrl->mbox_lock); 375 if (nonemb_cmd.va) 376 pci_free_consistent(ctrl->pdev, nonemb_cmd.size, 377 nonemb_cmd.va, nonemb_cmd.dma); 378 379 return status; 380 } 381 382 unsigned int mgmt_vendor_specific_fw_cmd(struct be_ctrl_info *ctrl, 383 struct beiscsi_hba *phba, 384 struct bsg_job *job, 385 struct be_dma_mem *nonemb_cmd) 386 { 387 struct be_cmd_resp_hdr *resp; 388 struct be_mcc_wrb *wrb = wrb_from_mccq(phba); 389 struct be_sge *mcc_sge = nonembedded_sgl(wrb); 390 unsigned int tag = 0; 391 struct iscsi_bsg_request *bsg_req = job->request; 392 struct be_bsg_vendor_cmd *req = nonemb_cmd->va; 393 unsigned short region, sector_size, sector, offset; 394 395 nonemb_cmd->size = job->request_payload.payload_len; 396 memset(nonemb_cmd->va, 0, nonemb_cmd->size); 397 resp = nonemb_cmd->va; 398 region = bsg_req->rqst_data.h_vendor.vendor_cmd[1]; 399 sector_size = bsg_req->rqst_data.h_vendor.vendor_cmd[2]; 400 sector = bsg_req->rqst_data.h_vendor.vendor_cmd[3]; 401 offset = bsg_req->rqst_data.h_vendor.vendor_cmd[4]; 402 req->region = region; 403 req->sector = sector; 404 req->offset = offset; 405 spin_lock(&ctrl->mbox_lock); 406 memset(wrb, 0, sizeof(*wrb)); 407 408 switch (bsg_req->rqst_data.h_vendor.vendor_cmd[0]) { 409 case BEISCSI_WRITE_FLASH: 410 offset = sector * sector_size + offset; 411 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 412 OPCODE_COMMON_WRITE_FLASH, sizeof(*req)); 413 sg_copy_to_buffer(job->request_payload.sg_list, 414 job->request_payload.sg_cnt, 415 nonemb_cmd->va + offset, job->request_len); 416 break; 417 case BEISCSI_READ_FLASH: 418 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 419 OPCODE_COMMON_READ_FLASH, sizeof(*req)); 420 break; 421 default: 422 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 423 "BG_%d : Unsupported cmd = 0x%x\n\n", 424 bsg_req->rqst_data.h_vendor.vendor_cmd[0]); 425 426 spin_unlock(&ctrl->mbox_lock); 427 return -ENOSYS; 428 } 429 430 tag = alloc_mcc_tag(phba); 431 if (!tag) { 432 spin_unlock(&ctrl->mbox_lock); 433 return tag; 434 } 435 436 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false, 437 job->request_payload.sg_cnt); 438 mcc_sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 439 mcc_sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 440 mcc_sge->len = cpu_to_le32(nonemb_cmd->size); 441 wrb->tag0 |= tag; 442 443 be_mcc_notify(phba); 444 445 spin_unlock(&ctrl->mbox_lock); 446 return tag; 447 } 448 449 int mgmt_epfw_cleanup(struct beiscsi_hba *phba, unsigned short chute) 450 { 451 struct be_ctrl_info *ctrl = &phba->ctrl; 452 struct be_mcc_wrb *wrb = wrb_from_mccq(phba); 453 struct iscsi_cleanup_req *req = embedded_payload(wrb); 454 int status = 0; 455 456 spin_lock(&ctrl->mbox_lock); 457 memset(wrb, 0, sizeof(*wrb)); 458 459 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 460 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 461 OPCODE_COMMON_ISCSI_CLEANUP, sizeof(*req)); 462 463 req->chute = chute; 464 req->hdr_ring_id = cpu_to_le16(HWI_GET_DEF_HDRQ_ID(phba)); 465 req->data_ring_id = cpu_to_le16(HWI_GET_DEF_BUFQ_ID(phba)); 466 467 status = be_mcc_notify_wait(phba); 468 if (status) 469 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT, 470 "BG_%d : mgmt_epfw_cleanup , FAILED\n"); 471 spin_unlock(&ctrl->mbox_lock); 472 return status; 473 } 474 475 unsigned int mgmt_invalidate_icds(struct beiscsi_hba *phba, 476 struct invalidate_command_table *inv_tbl, 477 unsigned int num_invalidate, unsigned int cid, 478 struct be_dma_mem *nonemb_cmd) 479 480 { 481 struct be_ctrl_info *ctrl = &phba->ctrl; 482 struct be_mcc_wrb *wrb; 483 struct be_sge *sge; 484 struct invalidate_commands_params_in *req; 485 unsigned int i, tag = 0; 486 487 spin_lock(&ctrl->mbox_lock); 488 tag = alloc_mcc_tag(phba); 489 if (!tag) { 490 spin_unlock(&ctrl->mbox_lock); 491 return tag; 492 } 493 494 req = nonemb_cmd->va; 495 memset(req, 0, sizeof(*req)); 496 wrb = wrb_from_mccq(phba); 497 sge = nonembedded_sgl(wrb); 498 wrb->tag0 |= tag; 499 500 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1); 501 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 502 OPCODE_COMMON_ISCSI_ERROR_RECOVERY_INVALIDATE_COMMANDS, 503 sizeof(*req)); 504 req->ref_handle = 0; 505 req->cleanup_type = CMD_ISCSI_COMMAND_INVALIDATE; 506 for (i = 0; i < num_invalidate; i++) { 507 req->table[i].icd = inv_tbl->icd; 508 req->table[i].cid = inv_tbl->cid; 509 req->icd_count++; 510 inv_tbl++; 511 } 512 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 513 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 514 sge->len = cpu_to_le32(nonemb_cmd->size); 515 516 be_mcc_notify(phba); 517 spin_unlock(&ctrl->mbox_lock); 518 return tag; 519 } 520 521 unsigned int mgmt_invalidate_connection(struct beiscsi_hba *phba, 522 struct beiscsi_endpoint *beiscsi_ep, 523 unsigned short cid, 524 unsigned short issue_reset, 525 unsigned short savecfg_flag) 526 { 527 struct be_ctrl_info *ctrl = &phba->ctrl; 528 struct be_mcc_wrb *wrb; 529 struct iscsi_invalidate_connection_params_in *req; 530 unsigned int tag = 0; 531 532 spin_lock(&ctrl->mbox_lock); 533 tag = alloc_mcc_tag(phba); 534 if (!tag) { 535 spin_unlock(&ctrl->mbox_lock); 536 return tag; 537 } 538 wrb = wrb_from_mccq(phba); 539 wrb->tag0 |= tag; 540 req = embedded_payload(wrb); 541 542 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 543 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 544 OPCODE_ISCSI_INI_DRIVER_INVALIDATE_CONNECTION, 545 sizeof(*req)); 546 req->session_handle = beiscsi_ep->fw_handle; 547 req->cid = cid; 548 if (issue_reset) 549 req->cleanup_type = CMD_ISCSI_CONNECTION_ISSUE_TCP_RST; 550 else 551 req->cleanup_type = CMD_ISCSI_CONNECTION_INVALIDATE; 552 req->save_cfg = savecfg_flag; 553 be_mcc_notify(phba); 554 spin_unlock(&ctrl->mbox_lock); 555 return tag; 556 } 557 558 unsigned int mgmt_upload_connection(struct beiscsi_hba *phba, 559 unsigned short cid, unsigned int upload_flag) 560 { 561 struct be_ctrl_info *ctrl = &phba->ctrl; 562 struct be_mcc_wrb *wrb; 563 struct tcp_upload_params_in *req; 564 unsigned int tag = 0; 565 566 spin_lock(&ctrl->mbox_lock); 567 tag = alloc_mcc_tag(phba); 568 if (!tag) { 569 spin_unlock(&ctrl->mbox_lock); 570 return tag; 571 } 572 wrb = wrb_from_mccq(phba); 573 req = embedded_payload(wrb); 574 wrb->tag0 |= tag; 575 576 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 577 be_cmd_hdr_prepare(&req->hdr, CMD_COMMON_TCP_UPLOAD, 578 OPCODE_COMMON_TCP_UPLOAD, sizeof(*req)); 579 req->id = (unsigned short)cid; 580 req->upload_type = (unsigned char)upload_flag; 581 be_mcc_notify(phba); 582 spin_unlock(&ctrl->mbox_lock); 583 return tag; 584 } 585 586 int mgmt_open_connection(struct beiscsi_hba *phba, 587 struct sockaddr *dst_addr, 588 struct beiscsi_endpoint *beiscsi_ep, 589 struct be_dma_mem *nonemb_cmd) 590 { 591 struct hwi_controller *phwi_ctrlr; 592 struct hwi_context_memory *phwi_context; 593 struct sockaddr_in *daddr_in = (struct sockaddr_in *)dst_addr; 594 struct sockaddr_in6 *daddr_in6 = (struct sockaddr_in6 *)dst_addr; 595 struct be_ctrl_info *ctrl = &phba->ctrl; 596 struct be_mcc_wrb *wrb; 597 struct tcp_connect_and_offload_in *req; 598 unsigned short def_hdr_id; 599 unsigned short def_data_id; 600 struct phys_addr template_address = { 0, 0 }; 601 struct phys_addr *ptemplate_address; 602 unsigned int tag = 0; 603 unsigned int i; 604 unsigned short cid = beiscsi_ep->ep_cid; 605 struct be_sge *sge; 606 607 phwi_ctrlr = phba->phwi_ctrlr; 608 phwi_context = phwi_ctrlr->phwi_ctxt; 609 def_hdr_id = (unsigned short)HWI_GET_DEF_HDRQ_ID(phba); 610 def_data_id = (unsigned short)HWI_GET_DEF_BUFQ_ID(phba); 611 612 ptemplate_address = &template_address; 613 ISCSI_GET_PDU_TEMPLATE_ADDRESS(phba, ptemplate_address); 614 spin_lock(&ctrl->mbox_lock); 615 tag = alloc_mcc_tag(phba); 616 if (!tag) { 617 spin_unlock(&ctrl->mbox_lock); 618 return tag; 619 } 620 wrb = wrb_from_mccq(phba); 621 memset(wrb, 0, sizeof(*wrb)); 622 sge = nonembedded_sgl(wrb); 623 624 req = nonemb_cmd->va; 625 memset(req, 0, sizeof(*req)); 626 wrb->tag0 |= tag; 627 628 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1); 629 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 630 OPCODE_COMMON_ISCSI_TCP_CONNECT_AND_OFFLOAD, 631 sizeof(*req)); 632 if (dst_addr->sa_family == PF_INET) { 633 __be32 s_addr = daddr_in->sin_addr.s_addr; 634 req->ip_address.ip_type = BE2_IPV4; 635 req->ip_address.addr[0] = s_addr & 0x000000ff; 636 req->ip_address.addr[1] = (s_addr & 0x0000ff00) >> 8; 637 req->ip_address.addr[2] = (s_addr & 0x00ff0000) >> 16; 638 req->ip_address.addr[3] = (s_addr & 0xff000000) >> 24; 639 req->tcp_port = ntohs(daddr_in->sin_port); 640 beiscsi_ep->dst_addr = daddr_in->sin_addr.s_addr; 641 beiscsi_ep->dst_tcpport = ntohs(daddr_in->sin_port); 642 beiscsi_ep->ip_type = BE2_IPV4; 643 } else if (dst_addr->sa_family == PF_INET6) { 644 req->ip_address.ip_type = BE2_IPV6; 645 memcpy(&req->ip_address.addr, 646 &daddr_in6->sin6_addr.in6_u.u6_addr8, 16); 647 req->tcp_port = ntohs(daddr_in6->sin6_port); 648 beiscsi_ep->dst_tcpport = ntohs(daddr_in6->sin6_port); 649 memcpy(&beiscsi_ep->dst6_addr, 650 &daddr_in6->sin6_addr.in6_u.u6_addr8, 16); 651 beiscsi_ep->ip_type = BE2_IPV6; 652 } else{ 653 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG, 654 "BG_%d : unknown addr family %d\n", 655 dst_addr->sa_family); 656 spin_unlock(&ctrl->mbox_lock); 657 free_mcc_tag(&phba->ctrl, tag); 658 return -EINVAL; 659 660 } 661 req->cid = cid; 662 i = phba->nxt_cqid++; 663 if (phba->nxt_cqid == phba->num_cpus) 664 phba->nxt_cqid = 0; 665 req->cq_id = phwi_context->be_cq[i].id; 666 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG, 667 "BG_%d : i=%d cq_id=%d\n", i, req->cq_id); 668 req->defq_id = def_hdr_id; 669 req->hdr_ring_id = def_hdr_id; 670 req->data_ring_id = def_data_id; 671 req->do_offload = 1; 672 req->dataout_template_pa.lo = ptemplate_address->lo; 673 req->dataout_template_pa.hi = ptemplate_address->hi; 674 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 675 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 676 sge->len = cpu_to_le32(nonemb_cmd->size); 677 be_mcc_notify(phba); 678 spin_unlock(&ctrl->mbox_lock); 679 return tag; 680 } 681 682 unsigned int mgmt_get_all_if_id(struct beiscsi_hba *phba) 683 { 684 struct be_ctrl_info *ctrl = &phba->ctrl; 685 struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem); 686 struct be_cmd_get_all_if_id_req *req = embedded_payload(wrb); 687 struct be_cmd_get_all_if_id_req *pbe_allid = req; 688 int status = 0; 689 690 memset(wrb, 0, sizeof(*wrb)); 691 692 spin_lock(&ctrl->mbox_lock); 693 694 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 695 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 696 OPCODE_COMMON_ISCSI_NTWK_GET_ALL_IF_ID, 697 sizeof(*req)); 698 status = be_mbox_notify(ctrl); 699 if (!status) 700 phba->interface_handle = pbe_allid->if_hndl_list[0]; 701 else { 702 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 703 "BG_%d : Failed in mgmt_get_all_if_id\n"); 704 } 705 spin_unlock(&ctrl->mbox_lock); 706 707 return status; 708 } 709 710 /* 711 * mgmt_exec_nonemb_cmd()- Execute Non Embedded MBX Cmd 712 * @phba: Driver priv structure 713 * @nonemb_cmd: Address of the MBX command issued 714 * @resp_buf: Buffer to copy the MBX cmd response 715 * @resp_buf_len: respone lenght to be copied 716 * 717 **/ 718 static int mgmt_exec_nonemb_cmd(struct beiscsi_hba *phba, 719 struct be_dma_mem *nonemb_cmd, void *resp_buf, 720 int resp_buf_len) 721 { 722 struct be_ctrl_info *ctrl = &phba->ctrl; 723 struct be_mcc_wrb *wrb = wrb_from_mccq(phba); 724 struct be_sge *sge; 725 unsigned int tag; 726 int rc = 0; 727 728 spin_lock(&ctrl->mbox_lock); 729 tag = alloc_mcc_tag(phba); 730 if (!tag) { 731 spin_unlock(&ctrl->mbox_lock); 732 rc = -ENOMEM; 733 goto free_cmd; 734 } 735 memset(wrb, 0, sizeof(*wrb)); 736 wrb->tag0 |= tag; 737 sge = nonembedded_sgl(wrb); 738 739 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false, 1); 740 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 741 sge->pa_lo = cpu_to_le32(lower_32_bits(nonemb_cmd->dma)); 742 sge->len = cpu_to_le32(nonemb_cmd->size); 743 744 be_mcc_notify(phba); 745 spin_unlock(&ctrl->mbox_lock); 746 747 rc = beiscsi_mccq_compl(phba, tag, NULL, nonemb_cmd->va); 748 if (rc) { 749 beiscsi_log(phba, KERN_ERR, 750 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX, 751 "BG_%d : mgmt_exec_nonemb_cmd Failed status\n"); 752 753 rc = -EIO; 754 goto free_cmd; 755 } 756 757 if (resp_buf) 758 memcpy(resp_buf, nonemb_cmd->va, resp_buf_len); 759 760 free_cmd: 761 pci_free_consistent(ctrl->pdev, nonemb_cmd->size, 762 nonemb_cmd->va, nonemb_cmd->dma); 763 return rc; 764 } 765 766 static int mgmt_alloc_cmd_data(struct beiscsi_hba *phba, struct be_dma_mem *cmd, 767 int iscsi_cmd, int size) 768 { 769 cmd->va = pci_alloc_consistent(phba->ctrl.pdev, size, &cmd->dma); 770 if (!cmd->va) { 771 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG, 772 "BG_%d : Failed to allocate memory for if info\n"); 773 return -ENOMEM; 774 } 775 memset(cmd->va, 0, size); 776 cmd->size = size; 777 be_cmd_hdr_prepare(cmd->va, CMD_SUBSYSTEM_ISCSI, iscsi_cmd, size); 778 return 0; 779 } 780 781 static int 782 mgmt_static_ip_modify(struct beiscsi_hba *phba, 783 struct be_cmd_get_if_info_resp *if_info, 784 struct iscsi_iface_param_info *ip_param, 785 struct iscsi_iface_param_info *subnet_param, 786 uint32_t ip_action) 787 { 788 struct be_cmd_set_ip_addr_req *req; 789 struct be_dma_mem nonemb_cmd; 790 uint32_t ip_type; 791 int rc; 792 793 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 794 OPCODE_COMMON_ISCSI_NTWK_MODIFY_IP_ADDR, 795 sizeof(*req)); 796 if (rc) 797 return rc; 798 799 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ? 800 BE2_IPV6 : BE2_IPV4 ; 801 802 req = nonemb_cmd.va; 803 req->ip_params.record_entry_count = 1; 804 req->ip_params.ip_record.action = ip_action; 805 req->ip_params.ip_record.interface_hndl = 806 phba->interface_handle; 807 req->ip_params.ip_record.ip_addr.size_of_structure = 808 sizeof(struct be_ip_addr_subnet_format); 809 req->ip_params.ip_record.ip_addr.ip_type = ip_type; 810 811 if (ip_action == IP_ACTION_ADD) { 812 memcpy(req->ip_params.ip_record.ip_addr.addr, ip_param->value, 813 ip_param->len); 814 815 if (subnet_param) 816 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask, 817 subnet_param->value, subnet_param->len); 818 } else { 819 memcpy(req->ip_params.ip_record.ip_addr.addr, 820 if_info->ip_addr.addr, ip_param->len); 821 822 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask, 823 if_info->ip_addr.subnet_mask, ip_param->len); 824 } 825 826 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 827 if (rc < 0) 828 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 829 "BG_%d : Failed to Modify existing IP Address\n"); 830 return rc; 831 } 832 833 static int mgmt_modify_gateway(struct beiscsi_hba *phba, uint8_t *gt_addr, 834 uint32_t gtway_action, uint32_t param_len) 835 { 836 struct be_cmd_set_def_gateway_req *req; 837 struct be_dma_mem nonemb_cmd; 838 int rt_val; 839 840 841 rt_val = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 842 OPCODE_COMMON_ISCSI_NTWK_MODIFY_DEFAULT_GATEWAY, 843 sizeof(*req)); 844 if (rt_val) 845 return rt_val; 846 847 req = nonemb_cmd.va; 848 req->action = gtway_action; 849 req->ip_addr.ip_type = BE2_IPV4; 850 851 memcpy(req->ip_addr.addr, gt_addr, param_len); 852 853 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 854 } 855 856 int mgmt_set_ip(struct beiscsi_hba *phba, 857 struct iscsi_iface_param_info *ip_param, 858 struct iscsi_iface_param_info *subnet_param, 859 uint32_t boot_proto) 860 { 861 struct be_cmd_get_def_gateway_resp gtway_addr_set; 862 struct be_cmd_get_if_info_resp if_info; 863 struct be_cmd_set_dhcp_req *dhcpreq; 864 struct be_cmd_rel_dhcp_req *reldhcp; 865 struct be_dma_mem nonemb_cmd; 866 uint8_t *gtway_addr; 867 uint32_t ip_type; 868 int rc; 869 870 if (mgmt_get_all_if_id(phba)) 871 return -EIO; 872 873 memset(&if_info, 0, sizeof(if_info)); 874 ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ? 875 BE2_IPV6 : BE2_IPV4 ; 876 877 rc = mgmt_get_if_info(phba, ip_type, &if_info); 878 if (rc) 879 return rc; 880 881 if (boot_proto == ISCSI_BOOTPROTO_DHCP) { 882 if (if_info.dhcp_state) { 883 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 884 "BG_%d : DHCP Already Enabled\n"); 885 return 0; 886 } 887 /* The ip_param->len is 1 in DHCP case. Setting 888 proper IP len as this it is used while 889 freeing the Static IP. 890 */ 891 ip_param->len = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ? 892 IP_V6_LEN : IP_V4_LEN; 893 894 } else { 895 if (if_info.dhcp_state) { 896 897 memset(&if_info, 0, sizeof(if_info)); 898 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 899 OPCODE_COMMON_ISCSI_NTWK_REL_STATELESS_IP_ADDR, 900 sizeof(*reldhcp)); 901 902 if (rc) 903 return rc; 904 905 reldhcp = nonemb_cmd.va; 906 reldhcp->interface_hndl = phba->interface_handle; 907 reldhcp->ip_type = ip_type; 908 909 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 910 if (rc < 0) { 911 beiscsi_log(phba, KERN_WARNING, 912 BEISCSI_LOG_CONFIG, 913 "BG_%d : Failed to Delete existing dhcp\n"); 914 return rc; 915 } 916 } 917 } 918 919 /* Delete the Static IP Set */ 920 if (if_info.ip_addr.addr[0]) { 921 rc = mgmt_static_ip_modify(phba, &if_info, ip_param, NULL, 922 IP_ACTION_DEL); 923 if (rc) 924 return rc; 925 } 926 927 /* Delete the Gateway settings if mode change is to DHCP */ 928 if (boot_proto == ISCSI_BOOTPROTO_DHCP) { 929 memset(>way_addr_set, 0, sizeof(gtway_addr_set)); 930 rc = mgmt_get_gateway(phba, BE2_IPV4, >way_addr_set); 931 if (rc) { 932 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 933 "BG_%d : Failed to Get Gateway Addr\n"); 934 return rc; 935 } 936 937 if (gtway_addr_set.ip_addr.addr[0]) { 938 gtway_addr = (uint8_t *)>way_addr_set.ip_addr.addr; 939 rc = mgmt_modify_gateway(phba, gtway_addr, 940 IP_ACTION_DEL, IP_V4_LEN); 941 942 if (rc) { 943 beiscsi_log(phba, KERN_WARNING, 944 BEISCSI_LOG_CONFIG, 945 "BG_%d : Failed to clear Gateway Addr Set\n"); 946 return rc; 947 } 948 } 949 } 950 951 /* Set Adapter to DHCP/Static Mode */ 952 if (boot_proto == ISCSI_BOOTPROTO_DHCP) { 953 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 954 OPCODE_COMMON_ISCSI_NTWK_CONFIG_STATELESS_IP_ADDR, 955 sizeof(*dhcpreq)); 956 if (rc) 957 return rc; 958 959 dhcpreq = nonemb_cmd.va; 960 dhcpreq->flags = BLOCKING; 961 dhcpreq->retry_count = 1; 962 dhcpreq->interface_hndl = phba->interface_handle; 963 dhcpreq->ip_type = BE2_DHCP_V4; 964 965 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 966 } else { 967 return mgmt_static_ip_modify(phba, &if_info, ip_param, 968 subnet_param, IP_ACTION_ADD); 969 } 970 971 return rc; 972 } 973 974 int mgmt_set_gateway(struct beiscsi_hba *phba, 975 struct iscsi_iface_param_info *gateway_param) 976 { 977 struct be_cmd_get_def_gateway_resp gtway_addr_set; 978 uint8_t *gtway_addr; 979 int rt_val; 980 981 memset(>way_addr_set, 0, sizeof(gtway_addr_set)); 982 rt_val = mgmt_get_gateway(phba, BE2_IPV4, >way_addr_set); 983 if (rt_val) { 984 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 985 "BG_%d : Failed to Get Gateway Addr\n"); 986 return rt_val; 987 } 988 989 if (gtway_addr_set.ip_addr.addr[0]) { 990 gtway_addr = (uint8_t *)>way_addr_set.ip_addr.addr; 991 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_DEL, 992 gateway_param->len); 993 if (rt_val) { 994 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 995 "BG_%d : Failed to clear Gateway Addr Set\n"); 996 return rt_val; 997 } 998 } 999 1000 gtway_addr = (uint8_t *)&gateway_param->value; 1001 rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_ADD, 1002 gateway_param->len); 1003 1004 if (rt_val) 1005 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 1006 "BG_%d : Failed to Set Gateway Addr\n"); 1007 1008 return rt_val; 1009 } 1010 1011 int mgmt_get_gateway(struct beiscsi_hba *phba, int ip_type, 1012 struct be_cmd_get_def_gateway_resp *gateway) 1013 { 1014 struct be_cmd_get_def_gateway_req *req; 1015 struct be_dma_mem nonemb_cmd; 1016 int rc; 1017 1018 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1019 OPCODE_COMMON_ISCSI_NTWK_GET_DEFAULT_GATEWAY, 1020 sizeof(*gateway)); 1021 if (rc) 1022 return rc; 1023 1024 req = nonemb_cmd.va; 1025 req->ip_type = ip_type; 1026 1027 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, gateway, 1028 sizeof(*gateway)); 1029 } 1030 1031 int mgmt_get_if_info(struct beiscsi_hba *phba, int ip_type, 1032 struct be_cmd_get_if_info_resp *if_info) 1033 { 1034 struct be_cmd_get_if_info_req *req; 1035 struct be_dma_mem nonemb_cmd; 1036 int rc; 1037 1038 if (mgmt_get_all_if_id(phba)) 1039 return -EIO; 1040 1041 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1042 OPCODE_COMMON_ISCSI_NTWK_GET_IF_INFO, 1043 sizeof(*if_info)); 1044 if (rc) 1045 return rc; 1046 1047 req = nonemb_cmd.va; 1048 req->interface_hndl = phba->interface_handle; 1049 req->ip_type = ip_type; 1050 1051 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, if_info, 1052 sizeof(*if_info)); 1053 } 1054 1055 int mgmt_get_nic_conf(struct beiscsi_hba *phba, 1056 struct be_cmd_get_nic_conf_resp *nic) 1057 { 1058 struct be_dma_mem nonemb_cmd; 1059 int rc; 1060 1061 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 1062 OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG, 1063 sizeof(*nic)); 1064 if (rc) 1065 return rc; 1066 1067 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, nic, sizeof(*nic)); 1068 } 1069 1070 1071 1072 unsigned int be_cmd_get_initname(struct beiscsi_hba *phba) 1073 { 1074 unsigned int tag = 0; 1075 struct be_mcc_wrb *wrb; 1076 struct be_cmd_hba_name *req; 1077 struct be_ctrl_info *ctrl = &phba->ctrl; 1078 1079 spin_lock(&ctrl->mbox_lock); 1080 tag = alloc_mcc_tag(phba); 1081 if (!tag) { 1082 spin_unlock(&ctrl->mbox_lock); 1083 return tag; 1084 } 1085 1086 wrb = wrb_from_mccq(phba); 1087 req = embedded_payload(wrb); 1088 wrb->tag0 |= tag; 1089 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 1090 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 1091 OPCODE_ISCSI_INI_CFG_GET_HBA_NAME, 1092 sizeof(*req)); 1093 1094 be_mcc_notify(phba); 1095 spin_unlock(&ctrl->mbox_lock); 1096 return tag; 1097 } 1098 1099 unsigned int be_cmd_get_port_speed(struct beiscsi_hba *phba) 1100 { 1101 unsigned int tag = 0; 1102 struct be_mcc_wrb *wrb; 1103 struct be_cmd_ntwk_link_status_req *req; 1104 struct be_ctrl_info *ctrl = &phba->ctrl; 1105 1106 spin_lock(&ctrl->mbox_lock); 1107 tag = alloc_mcc_tag(phba); 1108 if (!tag) { 1109 spin_unlock(&ctrl->mbox_lock); 1110 return tag; 1111 } 1112 1113 wrb = wrb_from_mccq(phba); 1114 req = embedded_payload(wrb); 1115 wrb->tag0 |= tag; 1116 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 1117 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON, 1118 OPCODE_COMMON_NTWK_LINK_STATUS_QUERY, 1119 sizeof(*req)); 1120 1121 be_mcc_notify(phba); 1122 spin_unlock(&ctrl->mbox_lock); 1123 return tag; 1124 } 1125 1126 /** 1127 * be_mgmt_get_boot_shandle()- Get the session handle 1128 * @phba: device priv structure instance 1129 * @s_handle: session handle returned for boot session. 1130 * 1131 * Get the boot target session handle. In case of 1132 * crashdump mode driver has to issue and MBX Cmd 1133 * for FW to login to boot target 1134 * 1135 * return 1136 * Success: 0 1137 * Failure: Non-Zero value 1138 * 1139 **/ 1140 int be_mgmt_get_boot_shandle(struct beiscsi_hba *phba, 1141 unsigned int *s_handle) 1142 { 1143 struct be_cmd_get_boot_target_resp *boot_resp; 1144 struct be_mcc_wrb *wrb; 1145 unsigned int tag; 1146 uint8_t boot_retry = 3; 1147 int rc; 1148 1149 do { 1150 /* Get the Boot Target Session Handle and Count*/ 1151 tag = mgmt_get_boot_target(phba); 1152 if (!tag) { 1153 beiscsi_log(phba, KERN_ERR, 1154 BEISCSI_LOG_CONFIG | BEISCSI_LOG_INIT, 1155 "BG_%d : Getting Boot Target Info Failed\n"); 1156 return -EAGAIN; 1157 } 1158 1159 rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL); 1160 if (rc) { 1161 beiscsi_log(phba, KERN_ERR, 1162 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1163 "BG_%d : MBX CMD get_boot_target Failed\n"); 1164 return -EBUSY; 1165 } 1166 1167 boot_resp = embedded_payload(wrb); 1168 1169 /* Check if the there are any Boot targets configured */ 1170 if (!boot_resp->boot_session_count) { 1171 beiscsi_log(phba, KERN_INFO, 1172 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1173 "BG_%d ;No boot targets configured\n"); 1174 return -ENXIO; 1175 } 1176 1177 /* FW returns the session handle of the boot session */ 1178 if (boot_resp->boot_session_handle != INVALID_SESS_HANDLE) { 1179 *s_handle = boot_resp->boot_session_handle; 1180 return 0; 1181 } 1182 1183 /* Issue MBX Cmd to FW to login to the boot target */ 1184 tag = mgmt_reopen_session(phba, BE_REOPEN_BOOT_SESSIONS, 1185 INVALID_SESS_HANDLE); 1186 if (!tag) { 1187 beiscsi_log(phba, KERN_ERR, 1188 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1189 "BG_%d : mgmt_reopen_session Failed\n"); 1190 return -EAGAIN; 1191 } 1192 1193 rc = beiscsi_mccq_compl(phba, tag, NULL, NULL); 1194 if (rc) { 1195 beiscsi_log(phba, KERN_ERR, 1196 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1197 "BG_%d : mgmt_reopen_session Failed"); 1198 return rc; 1199 } 1200 } while (--boot_retry); 1201 1202 /* Couldn't log into the boot target */ 1203 beiscsi_log(phba, KERN_ERR, 1204 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1205 "BG_%d : Login to Boot Target Failed\n"); 1206 return -ENXIO; 1207 } 1208 1209 /** 1210 * mgmt_set_vlan()- Issue and wait for CMD completion 1211 * @phba: device private structure instance 1212 * @vlan_tag: VLAN tag 1213 * 1214 * Issue the MBX Cmd and wait for the completion of the 1215 * command. 1216 * 1217 * returns 1218 * Success: 0 1219 * Failure: Non-Xero Value 1220 **/ 1221 int mgmt_set_vlan(struct beiscsi_hba *phba, 1222 uint16_t vlan_tag) 1223 { 1224 int rc; 1225 unsigned int tag; 1226 struct be_mcc_wrb *wrb = NULL; 1227 1228 tag = be_cmd_set_vlan(phba, vlan_tag); 1229 if (!tag) { 1230 beiscsi_log(phba, KERN_ERR, 1231 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX), 1232 "BG_%d : VLAN Setting Failed\n"); 1233 return -EBUSY; 1234 } 1235 1236 rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL); 1237 if (rc) { 1238 beiscsi_log(phba, KERN_ERR, 1239 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX), 1240 "BS_%d : VLAN MBX Cmd Failed\n"); 1241 return rc; 1242 } 1243 return rc; 1244 } 1245 1246 /** 1247 * beiscsi_drvr_ver_disp()- Display the driver Name and Version 1248 * @dev: ptr to device not used. 1249 * @attr: device attribute, not used. 1250 * @buf: contains formatted text driver name and version 1251 * 1252 * return 1253 * size of the formatted string 1254 **/ 1255 ssize_t 1256 beiscsi_drvr_ver_disp(struct device *dev, struct device_attribute *attr, 1257 char *buf) 1258 { 1259 return snprintf(buf, PAGE_SIZE, BE_NAME "\n"); 1260 } 1261 1262 /** 1263 * beiscsi_adap_family_disp()- Display adapter family. 1264 * @dev: ptr to device to get priv structure 1265 * @attr: device attribute, not used. 1266 * @buf: contains formatted text driver name and version 1267 * 1268 * return 1269 * size of the formatted string 1270 **/ 1271 ssize_t 1272 beiscsi_adap_family_disp(struct device *dev, struct device_attribute *attr, 1273 char *buf) 1274 { 1275 uint16_t dev_id = 0; 1276 struct Scsi_Host *shost = class_to_shost(dev); 1277 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1278 1279 dev_id = phba->pcidev->device; 1280 switch (dev_id) { 1281 case BE_DEVICE_ID1: 1282 case OC_DEVICE_ID1: 1283 case OC_DEVICE_ID2: 1284 return snprintf(buf, PAGE_SIZE, "BE2 Adapter Family\n"); 1285 break; 1286 case BE_DEVICE_ID2: 1287 case OC_DEVICE_ID3: 1288 return snprintf(buf, PAGE_SIZE, "BE3-R Adapter Family\n"); 1289 break; 1290 case OC_SKH_ID1: 1291 return snprintf(buf, PAGE_SIZE, "Skyhawk-R Adapter Family\n"); 1292 break; 1293 default: 1294 return snprintf(buf, PAGE_SIZE, 1295 "Unkown Adapter Family: 0x%x\n", dev_id); 1296 break; 1297 } 1298 } 1299 1300 1301 void beiscsi_offload_cxn_v0(struct beiscsi_offload_params *params, 1302 struct wrb_handle *pwrb_handle, 1303 struct be_mem_descriptor *mem_descr) 1304 { 1305 struct iscsi_wrb *pwrb = pwrb_handle->pwrb; 1306 1307 memset(pwrb, 0, sizeof(*pwrb)); 1308 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1309 max_send_data_segment_length, pwrb, 1310 params->dw[offsetof(struct amap_beiscsi_offload_params, 1311 max_send_data_segment_length) / 32]); 1312 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, type, pwrb, 1313 BE_TGT_CTX_UPDT_CMD); 1314 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1315 first_burst_length, 1316 pwrb, 1317 params->dw[offsetof(struct amap_beiscsi_offload_params, 1318 first_burst_length) / 32]); 1319 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, erl, pwrb, 1320 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1321 erl) / 32] & OFFLD_PARAMS_ERL)); 1322 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, dde, pwrb, 1323 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1324 dde) / 32] & OFFLD_PARAMS_DDE) >> 2); 1325 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, hde, pwrb, 1326 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1327 hde) / 32] & OFFLD_PARAMS_HDE) >> 3); 1328 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ir2t, pwrb, 1329 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1330 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4); 1331 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, imd, pwrb, 1332 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1333 imd) / 32] & OFFLD_PARAMS_IMD) >> 5); 1334 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, stat_sn, 1335 pwrb, 1336 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1337 exp_statsn) / 32] + 1)); 1338 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, wrb_idx, 1339 pwrb, pwrb_handle->wrb_index); 1340 1341 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1342 max_burst_length, pwrb, params->dw[offsetof 1343 (struct amap_beiscsi_offload_params, 1344 max_burst_length) / 32]); 1345 1346 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ptr2nextwrb, 1347 pwrb, pwrb_handle->nxt_wrb_index); 1348 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1349 session_state, pwrb, 0); 1350 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, compltonack, 1351 pwrb, 1); 1352 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, notpredblq, 1353 pwrb, 0); 1354 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, mode, pwrb, 1355 0); 1356 1357 mem_descr += ISCSI_MEM_GLOBAL_HEADER; 1358 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1359 pad_buffer_addr_hi, pwrb, 1360 mem_descr->mem_array[0].bus_address.u.a32.address_hi); 1361 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1362 pad_buffer_addr_lo, pwrb, 1363 mem_descr->mem_array[0].bus_address.u.a32.address_lo); 1364 } 1365 1366 void beiscsi_offload_cxn_v2(struct beiscsi_offload_params *params, 1367 struct wrb_handle *pwrb_handle) 1368 { 1369 struct iscsi_wrb *pwrb = pwrb_handle->pwrb; 1370 1371 memset(pwrb, 0, sizeof(*pwrb)); 1372 1373 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1374 max_burst_length, pwrb, params->dw[offsetof 1375 (struct amap_beiscsi_offload_params, 1376 max_burst_length) / 32]); 1377 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1378 max_burst_length, pwrb, params->dw[offsetof 1379 (struct amap_beiscsi_offload_params, 1380 max_burst_length) / 32]); 1381 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1382 type, pwrb, 1383 BE_TGT_CTX_UPDT_CMD); 1384 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1385 ptr2nextwrb, 1386 pwrb, pwrb_handle->nxt_wrb_index); 1387 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, wrb_idx, 1388 pwrb, pwrb_handle->wrb_index); 1389 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1390 max_send_data_segment_length, pwrb, 1391 params->dw[offsetof(struct amap_beiscsi_offload_params, 1392 max_send_data_segment_length) / 32]); 1393 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1394 first_burst_length, pwrb, 1395 params->dw[offsetof(struct amap_beiscsi_offload_params, 1396 first_burst_length) / 32]); 1397 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1398 max_recv_dataseg_len, pwrb, BEISCSI_MAX_RECV_DATASEG_LEN); 1399 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1400 max_cxns, pwrb, BEISCSI_MAX_CXNS); 1401 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, erl, pwrb, 1402 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1403 erl) / 32] & OFFLD_PARAMS_ERL)); 1404 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, dde, pwrb, 1405 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1406 dde) / 32] & OFFLD_PARAMS_DDE) >> 2); 1407 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, hde, pwrb, 1408 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1409 hde) / 32] & OFFLD_PARAMS_HDE) >> 3); 1410 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1411 ir2t, pwrb, 1412 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1413 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4); 1414 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, imd, pwrb, 1415 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1416 imd) / 32] & OFFLD_PARAMS_IMD) >> 5); 1417 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1418 data_seq_inorder, 1419 pwrb, 1420 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1421 data_seq_inorder) / 32] & 1422 OFFLD_PARAMS_DATA_SEQ_INORDER) >> 6); 1423 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1424 pdu_seq_inorder, 1425 pwrb, 1426 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1427 pdu_seq_inorder) / 32] & 1428 OFFLD_PARAMS_PDU_SEQ_INORDER) >> 7); 1429 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, max_r2t, 1430 pwrb, 1431 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1432 max_r2t) / 32] & 1433 OFFLD_PARAMS_MAX_R2T) >> 8); 1434 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, stat_sn, 1435 pwrb, 1436 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1437 exp_statsn) / 32] + 1)); 1438 } 1439