1 /** 2 * Copyright (C) 2005 - 2016 Broadcom 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@broadcom.com) 11 * 12 * Contact Information: 13 * linux-drivers@broadcom.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 int beiscsi_modify_eq_delay(struct beiscsi_hba *phba, 28 struct be_set_eqd *set_eqd, 29 int num) 30 { 31 struct be_ctrl_info *ctrl = &phba->ctrl; 32 struct be_mcc_wrb *wrb; 33 struct be_cmd_req_modify_eq_delay *req; 34 unsigned int tag; 35 int i; 36 37 mutex_lock(&ctrl->mbox_lock); 38 wrb = alloc_mcc_wrb(phba, &tag); 39 if (!wrb) { 40 mutex_unlock(&ctrl->mbox_lock); 41 return 0; 42 } 43 44 req = embedded_payload(wrb); 45 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 46 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON, 47 OPCODE_COMMON_MODIFY_EQ_DELAY, sizeof(*req)); 48 49 req->num_eq = cpu_to_le32(num); 50 for (i = 0; i < num; i++) { 51 req->delay[i].eq_id = cpu_to_le32(set_eqd[i].eq_id); 52 req->delay[i].phase = 0; 53 req->delay[i].delay_multiplier = 54 cpu_to_le32(set_eqd[i].delay_multiplier); 55 } 56 57 /* ignore the completion of this mbox command */ 58 set_bit(MCC_TAG_STATE_IGNORE, &ctrl->ptag_state[tag].tag_state); 59 be_mcc_notify(phba, tag); 60 mutex_unlock(&ctrl->mbox_lock); 61 return tag; 62 } 63 64 unsigned int mgmt_vendor_specific_fw_cmd(struct be_ctrl_info *ctrl, 65 struct beiscsi_hba *phba, 66 struct bsg_job *job, 67 struct be_dma_mem *nonemb_cmd) 68 { 69 struct be_cmd_resp_hdr *resp; 70 struct be_mcc_wrb *wrb; 71 struct be_sge *mcc_sge; 72 unsigned int tag = 0; 73 struct iscsi_bsg_request *bsg_req = job->request; 74 struct be_bsg_vendor_cmd *req = nonemb_cmd->va; 75 unsigned short region, sector_size, sector, offset; 76 77 nonemb_cmd->size = job->request_payload.payload_len; 78 memset(nonemb_cmd->va, 0, nonemb_cmd->size); 79 resp = nonemb_cmd->va; 80 region = bsg_req->rqst_data.h_vendor.vendor_cmd[1]; 81 sector_size = bsg_req->rqst_data.h_vendor.vendor_cmd[2]; 82 sector = bsg_req->rqst_data.h_vendor.vendor_cmd[3]; 83 offset = bsg_req->rqst_data.h_vendor.vendor_cmd[4]; 84 req->region = region; 85 req->sector = sector; 86 req->offset = offset; 87 88 if (mutex_lock_interruptible(&ctrl->mbox_lock)) 89 return 0; 90 switch (bsg_req->rqst_data.h_vendor.vendor_cmd[0]) { 91 case BEISCSI_WRITE_FLASH: 92 offset = sector * sector_size + offset; 93 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 94 OPCODE_COMMON_WRITE_FLASH, sizeof(*req)); 95 sg_copy_to_buffer(job->request_payload.sg_list, 96 job->request_payload.sg_cnt, 97 nonemb_cmd->va + offset, job->request_len); 98 break; 99 case BEISCSI_READ_FLASH: 100 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 101 OPCODE_COMMON_READ_FLASH, sizeof(*req)); 102 break; 103 default: 104 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 105 "BG_%d : Unsupported cmd = 0x%x\n\n", 106 bsg_req->rqst_data.h_vendor.vendor_cmd[0]); 107 108 mutex_unlock(&ctrl->mbox_lock); 109 return -EPERM; 110 } 111 112 wrb = alloc_mcc_wrb(phba, &tag); 113 if (!wrb) { 114 mutex_unlock(&ctrl->mbox_lock); 115 return 0; 116 } 117 118 mcc_sge = nonembedded_sgl(wrb); 119 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false, 120 job->request_payload.sg_cnt); 121 mcc_sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 122 mcc_sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 123 mcc_sge->len = cpu_to_le32(nonemb_cmd->size); 124 125 be_mcc_notify(phba, tag); 126 127 mutex_unlock(&ctrl->mbox_lock); 128 return tag; 129 } 130 131 unsigned int mgmt_invalidate_icds(struct beiscsi_hba *phba, 132 struct invalidate_command_table *inv_tbl, 133 unsigned int num_invalidate, unsigned int cid, 134 struct be_dma_mem *nonemb_cmd) 135 136 { 137 struct be_ctrl_info *ctrl = &phba->ctrl; 138 struct be_mcc_wrb *wrb; 139 struct be_sge *sge; 140 struct invalidate_commands_params_in *req; 141 unsigned int i, tag; 142 143 mutex_lock(&ctrl->mbox_lock); 144 wrb = alloc_mcc_wrb(phba, &tag); 145 if (!wrb) { 146 mutex_unlock(&ctrl->mbox_lock); 147 return 0; 148 } 149 150 req = nonemb_cmd->va; 151 memset(req, 0, sizeof(*req)); 152 sge = nonembedded_sgl(wrb); 153 154 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1); 155 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 156 OPCODE_COMMON_ISCSI_ERROR_RECOVERY_INVALIDATE_COMMANDS, 157 sizeof(*req)); 158 req->ref_handle = 0; 159 req->cleanup_type = CMD_ISCSI_COMMAND_INVALIDATE; 160 for (i = 0; i < num_invalidate; i++) { 161 req->table[i].icd = inv_tbl->icd; 162 req->table[i].cid = inv_tbl->cid; 163 req->icd_count++; 164 inv_tbl++; 165 } 166 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 167 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 168 sge->len = cpu_to_le32(nonemb_cmd->size); 169 170 be_mcc_notify(phba, tag); 171 mutex_unlock(&ctrl->mbox_lock); 172 return tag; 173 } 174 175 unsigned int mgmt_invalidate_connection(struct beiscsi_hba *phba, 176 struct beiscsi_endpoint *beiscsi_ep, 177 unsigned short cid, 178 unsigned short issue_reset, 179 unsigned short savecfg_flag) 180 { 181 struct be_ctrl_info *ctrl = &phba->ctrl; 182 struct be_mcc_wrb *wrb; 183 struct iscsi_invalidate_connection_params_in *req; 184 unsigned int tag = 0; 185 186 mutex_lock(&ctrl->mbox_lock); 187 wrb = alloc_mcc_wrb(phba, &tag); 188 if (!wrb) { 189 mutex_unlock(&ctrl->mbox_lock); 190 return 0; 191 } 192 193 req = embedded_payload(wrb); 194 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 195 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 196 OPCODE_ISCSI_INI_DRIVER_INVALIDATE_CONNECTION, 197 sizeof(*req)); 198 req->session_handle = beiscsi_ep->fw_handle; 199 req->cid = cid; 200 if (issue_reset) 201 req->cleanup_type = CMD_ISCSI_CONNECTION_ISSUE_TCP_RST; 202 else 203 req->cleanup_type = CMD_ISCSI_CONNECTION_INVALIDATE; 204 req->save_cfg = savecfg_flag; 205 be_mcc_notify(phba, tag); 206 mutex_unlock(&ctrl->mbox_lock); 207 return tag; 208 } 209 210 unsigned int mgmt_upload_connection(struct beiscsi_hba *phba, 211 unsigned short cid, unsigned int upload_flag) 212 { 213 struct be_ctrl_info *ctrl = &phba->ctrl; 214 struct be_mcc_wrb *wrb; 215 struct tcp_upload_params_in *req; 216 unsigned int tag; 217 218 mutex_lock(&ctrl->mbox_lock); 219 wrb = alloc_mcc_wrb(phba, &tag); 220 if (!wrb) { 221 mutex_unlock(&ctrl->mbox_lock); 222 return 0; 223 } 224 225 req = embedded_payload(wrb); 226 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 227 be_cmd_hdr_prepare(&req->hdr, CMD_COMMON_TCP_UPLOAD, 228 OPCODE_COMMON_TCP_UPLOAD, sizeof(*req)); 229 req->id = (unsigned short)cid; 230 req->upload_type = (unsigned char)upload_flag; 231 be_mcc_notify(phba, tag); 232 mutex_unlock(&ctrl->mbox_lock); 233 return tag; 234 } 235 236 /** 237 * mgmt_open_connection()- Establish a TCP CXN 238 * @dst_addr: Destination Address 239 * @beiscsi_ep: ptr to device endpoint struct 240 * @nonemb_cmd: ptr to memory allocated for command 241 * 242 * return 243 * Success: Tag number of the MBX Command issued 244 * Failure: Error code 245 **/ 246 int mgmt_open_connection(struct beiscsi_hba *phba, 247 struct sockaddr *dst_addr, 248 struct beiscsi_endpoint *beiscsi_ep, 249 struct be_dma_mem *nonemb_cmd) 250 { 251 struct hwi_controller *phwi_ctrlr; 252 struct hwi_context_memory *phwi_context; 253 struct sockaddr_in *daddr_in = (struct sockaddr_in *)dst_addr; 254 struct sockaddr_in6 *daddr_in6 = (struct sockaddr_in6 *)dst_addr; 255 struct be_ctrl_info *ctrl = &phba->ctrl; 256 struct be_mcc_wrb *wrb; 257 struct tcp_connect_and_offload_in_v1 *req; 258 unsigned short def_hdr_id; 259 unsigned short def_data_id; 260 struct phys_addr template_address = { 0, 0 }; 261 struct phys_addr *ptemplate_address; 262 unsigned int tag = 0; 263 unsigned int i, ulp_num; 264 unsigned short cid = beiscsi_ep->ep_cid; 265 struct be_sge *sge; 266 267 if (dst_addr->sa_family != PF_INET && dst_addr->sa_family != PF_INET6) { 268 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG, 269 "BG_%d : unknown addr family %d\n", 270 dst_addr->sa_family); 271 return -EINVAL; 272 } 273 274 phwi_ctrlr = phba->phwi_ctrlr; 275 phwi_context = phwi_ctrlr->phwi_ctxt; 276 277 ulp_num = phwi_ctrlr->wrb_context[BE_GET_CRI_FROM_CID(cid)].ulp_num; 278 279 def_hdr_id = (unsigned short)HWI_GET_DEF_HDRQ_ID(phba, ulp_num); 280 def_data_id = (unsigned short)HWI_GET_DEF_BUFQ_ID(phba, ulp_num); 281 282 ptemplate_address = &template_address; 283 ISCSI_GET_PDU_TEMPLATE_ADDRESS(phba, ptemplate_address); 284 if (mutex_lock_interruptible(&ctrl->mbox_lock)) 285 return 0; 286 wrb = alloc_mcc_wrb(phba, &tag); 287 if (!wrb) { 288 mutex_unlock(&ctrl->mbox_lock); 289 return 0; 290 } 291 292 sge = nonembedded_sgl(wrb); 293 req = nonemb_cmd->va; 294 memset(req, 0, sizeof(*req)); 295 296 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false, 1); 297 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 298 OPCODE_COMMON_ISCSI_TCP_CONNECT_AND_OFFLOAD, 299 nonemb_cmd->size); 300 if (dst_addr->sa_family == PF_INET) { 301 __be32 s_addr = daddr_in->sin_addr.s_addr; 302 req->ip_address.ip_type = BEISCSI_IP_TYPE_V4; 303 req->ip_address.addr[0] = s_addr & 0x000000ff; 304 req->ip_address.addr[1] = (s_addr & 0x0000ff00) >> 8; 305 req->ip_address.addr[2] = (s_addr & 0x00ff0000) >> 16; 306 req->ip_address.addr[3] = (s_addr & 0xff000000) >> 24; 307 req->tcp_port = ntohs(daddr_in->sin_port); 308 beiscsi_ep->dst_addr = daddr_in->sin_addr.s_addr; 309 beiscsi_ep->dst_tcpport = ntohs(daddr_in->sin_port); 310 beiscsi_ep->ip_type = BEISCSI_IP_TYPE_V4; 311 } else { 312 /* else its PF_INET6 family */ 313 req->ip_address.ip_type = BEISCSI_IP_TYPE_V6; 314 memcpy(&req->ip_address.addr, 315 &daddr_in6->sin6_addr.in6_u.u6_addr8, 16); 316 req->tcp_port = ntohs(daddr_in6->sin6_port); 317 beiscsi_ep->dst_tcpport = ntohs(daddr_in6->sin6_port); 318 memcpy(&beiscsi_ep->dst6_addr, 319 &daddr_in6->sin6_addr.in6_u.u6_addr8, 16); 320 beiscsi_ep->ip_type = BEISCSI_IP_TYPE_V6; 321 } 322 req->cid = cid; 323 i = phba->nxt_cqid++; 324 if (phba->nxt_cqid == phba->num_cpus) 325 phba->nxt_cqid = 0; 326 req->cq_id = phwi_context->be_cq[i].id; 327 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG, 328 "BG_%d : i=%d cq_id=%d\n", i, req->cq_id); 329 req->defq_id = def_hdr_id; 330 req->hdr_ring_id = def_hdr_id; 331 req->data_ring_id = def_data_id; 332 req->do_offload = 1; 333 req->dataout_template_pa.lo = ptemplate_address->lo; 334 req->dataout_template_pa.hi = ptemplate_address->hi; 335 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 336 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 337 sge->len = cpu_to_le32(nonemb_cmd->size); 338 339 if (!is_chip_be2_be3r(phba)) { 340 req->hdr.version = MBX_CMD_VER1; 341 req->tcp_window_size = 0x8000; 342 req->tcp_window_scale_count = 2; 343 } 344 345 be_mcc_notify(phba, tag); 346 mutex_unlock(&ctrl->mbox_lock); 347 return tag; 348 } 349 350 /* 351 * mgmt_exec_nonemb_cmd()- Execute Non Embedded MBX Cmd 352 * @phba: Driver priv structure 353 * @nonemb_cmd: Address of the MBX command issued 354 * @resp_buf: Buffer to copy the MBX cmd response 355 * @resp_buf_len: respone lenght to be copied 356 * 357 **/ 358 static int mgmt_exec_nonemb_cmd(struct beiscsi_hba *phba, 359 struct be_dma_mem *nonemb_cmd, void *resp_buf, 360 int resp_buf_len) 361 { 362 struct be_ctrl_info *ctrl = &phba->ctrl; 363 struct be_mcc_wrb *wrb; 364 struct be_sge *sge; 365 unsigned int tag; 366 int rc = 0; 367 368 mutex_lock(&ctrl->mbox_lock); 369 wrb = alloc_mcc_wrb(phba, &tag); 370 if (!wrb) { 371 mutex_unlock(&ctrl->mbox_lock); 372 rc = -ENOMEM; 373 goto free_cmd; 374 } 375 376 sge = nonembedded_sgl(wrb); 377 be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false, 1); 378 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 379 sge->pa_lo = cpu_to_le32(lower_32_bits(nonemb_cmd->dma)); 380 sge->len = cpu_to_le32(nonemb_cmd->size); 381 382 be_mcc_notify(phba, tag); 383 mutex_unlock(&ctrl->mbox_lock); 384 385 rc = beiscsi_mccq_compl_wait(phba, tag, NULL, nonemb_cmd); 386 387 if (resp_buf) 388 memcpy(resp_buf, nonemb_cmd->va, resp_buf_len); 389 390 if (rc) { 391 /* Check if the MBX Cmd needs to be re-issued */ 392 if (rc == -EAGAIN) 393 return rc; 394 395 beiscsi_log(phba, KERN_WARNING, 396 BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX, 397 "BG_%d : mgmt_exec_nonemb_cmd Failed status\n"); 398 399 if (rc != -EBUSY) 400 goto free_cmd; 401 else 402 return rc; 403 } 404 free_cmd: 405 pci_free_consistent(ctrl->pdev, nonemb_cmd->size, 406 nonemb_cmd->va, nonemb_cmd->dma); 407 return rc; 408 } 409 410 static int mgmt_alloc_cmd_data(struct beiscsi_hba *phba, struct be_dma_mem *cmd, 411 int iscsi_cmd, int size) 412 { 413 cmd->va = pci_zalloc_consistent(phba->ctrl.pdev, size, &cmd->dma); 414 if (!cmd->va) { 415 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG, 416 "BG_%d : Failed to allocate memory for if info\n"); 417 return -ENOMEM; 418 } 419 cmd->size = size; 420 be_cmd_hdr_prepare(cmd->va, CMD_SUBSYSTEM_ISCSI, iscsi_cmd, size); 421 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG, 422 "BG_%d : subsystem iSCSI cmd %d size %d\n", 423 iscsi_cmd, size); 424 return 0; 425 } 426 427 unsigned int beiscsi_if_get_handle(struct beiscsi_hba *phba) 428 { 429 struct be_ctrl_info *ctrl = &phba->ctrl; 430 struct be_mcc_wrb *wrb; 431 struct be_cmd_get_all_if_id_req *req; 432 struct be_cmd_get_all_if_id_req *pbe_allid; 433 unsigned int tag; 434 int status = 0; 435 436 if (mutex_lock_interruptible(&ctrl->mbox_lock)) 437 return -EINTR; 438 wrb = alloc_mcc_wrb(phba, &tag); 439 if (!wrb) { 440 mutex_unlock(&ctrl->mbox_lock); 441 return -ENOMEM; 442 } 443 444 req = embedded_payload(wrb); 445 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 446 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI, 447 OPCODE_COMMON_ISCSI_NTWK_GET_ALL_IF_ID, 448 sizeof(*req)); 449 be_mcc_notify(phba, tag); 450 mutex_unlock(&ctrl->mbox_lock); 451 452 status = beiscsi_mccq_compl_wait(phba, tag, &wrb, NULL); 453 if (status) { 454 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 455 "BG_%d : %s failed: %d\n", __func__, status); 456 return -EBUSY; 457 } 458 459 pbe_allid = embedded_payload(wrb); 460 /* we now support only one interface per function */ 461 phba->interface_handle = pbe_allid->if_hndl_list[0]; 462 463 return status; 464 } 465 466 static inline bool beiscsi_if_zero_ip(u8 *ip, u32 ip_type) 467 { 468 u32 len; 469 470 len = (ip_type < BEISCSI_IP_TYPE_V6) ? IP_V4_LEN : IP_V6_LEN; 471 while (len && !ip[len - 1]) 472 len--; 473 return (len == 0); 474 } 475 476 static int beiscsi_if_mod_gw(struct beiscsi_hba *phba, 477 u32 action, u32 ip_type, u8 *gw) 478 { 479 struct be_cmd_set_def_gateway_req *req; 480 struct be_dma_mem nonemb_cmd; 481 int rt_val; 482 483 rt_val = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 484 OPCODE_COMMON_ISCSI_NTWK_MODIFY_DEFAULT_GATEWAY, 485 sizeof(*req)); 486 if (rt_val) 487 return rt_val; 488 489 req = nonemb_cmd.va; 490 req->action = action; 491 req->ip_addr.ip_type = ip_type; 492 memcpy(req->ip_addr.addr, gw, 493 (ip_type < BEISCSI_IP_TYPE_V6) ? IP_V4_LEN : IP_V6_LEN); 494 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 495 } 496 497 int beiscsi_if_set_gw(struct beiscsi_hba *phba, u32 ip_type, u8 *gw) 498 { 499 struct be_cmd_get_def_gateway_resp gw_resp; 500 int rt_val; 501 502 memset(&gw_resp, 0, sizeof(gw_resp)); 503 rt_val = beiscsi_if_get_gw(phba, ip_type, &gw_resp); 504 if (rt_val) { 505 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 506 "BG_%d : Failed to Get Gateway Addr\n"); 507 return rt_val; 508 } 509 510 if (!beiscsi_if_zero_ip(gw_resp.ip_addr.addr, ip_type)) { 511 rt_val = beiscsi_if_mod_gw(phba, IP_ACTION_DEL, ip_type, 512 gw_resp.ip_addr.addr); 513 if (rt_val) { 514 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 515 "BG_%d : Failed to clear Gateway Addr Set\n"); 516 return rt_val; 517 } 518 } 519 520 rt_val = beiscsi_if_mod_gw(phba, IP_ACTION_ADD, ip_type, gw); 521 if (rt_val) 522 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 523 "BG_%d : Failed to Set Gateway Addr\n"); 524 525 return rt_val; 526 } 527 528 int beiscsi_if_get_gw(struct beiscsi_hba *phba, u32 ip_type, 529 struct be_cmd_get_def_gateway_resp *resp) 530 { 531 struct be_cmd_get_def_gateway_req *req; 532 struct be_dma_mem nonemb_cmd; 533 int rc; 534 535 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 536 OPCODE_COMMON_ISCSI_NTWK_GET_DEFAULT_GATEWAY, 537 sizeof(*resp)); 538 if (rc) 539 return rc; 540 541 req = nonemb_cmd.va; 542 req->ip_type = ip_type; 543 544 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, resp, 545 sizeof(*resp)); 546 } 547 548 static int 549 beiscsi_if_clr_ip(struct beiscsi_hba *phba, 550 struct be_cmd_get_if_info_resp *if_info) 551 { 552 struct be_cmd_set_ip_addr_req *req; 553 struct be_dma_mem nonemb_cmd; 554 int rc; 555 556 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 557 OPCODE_COMMON_ISCSI_NTWK_MODIFY_IP_ADDR, 558 sizeof(*req)); 559 if (rc) 560 return rc; 561 562 req = nonemb_cmd.va; 563 req->ip_params.record_entry_count = 1; 564 req->ip_params.ip_record.action = IP_ACTION_DEL; 565 req->ip_params.ip_record.interface_hndl = 566 phba->interface_handle; 567 req->ip_params.ip_record.ip_addr.size_of_structure = 568 sizeof(struct be_ip_addr_subnet_format); 569 req->ip_params.ip_record.ip_addr.ip_type = if_info->ip_addr.ip_type; 570 memcpy(req->ip_params.ip_record.ip_addr.addr, 571 if_info->ip_addr.addr, 572 sizeof(if_info->ip_addr.addr)); 573 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask, 574 if_info->ip_addr.subnet_mask, 575 sizeof(if_info->ip_addr.subnet_mask)); 576 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 577 if (rc < 0 || req->ip_params.ip_record.status) { 578 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG, 579 "BG_%d : failed to clear IP: rc %d status %d\n", 580 rc, req->ip_params.ip_record.status); 581 } 582 return rc; 583 } 584 585 static int 586 beiscsi_if_set_ip(struct beiscsi_hba *phba, u8 *ip, 587 u8 *subnet, u32 ip_type) 588 { 589 struct be_cmd_set_ip_addr_req *req; 590 struct be_dma_mem nonemb_cmd; 591 uint32_t ip_len; 592 int rc; 593 594 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 595 OPCODE_COMMON_ISCSI_NTWK_MODIFY_IP_ADDR, 596 sizeof(*req)); 597 if (rc) 598 return rc; 599 600 req = nonemb_cmd.va; 601 req->ip_params.record_entry_count = 1; 602 req->ip_params.ip_record.action = IP_ACTION_ADD; 603 req->ip_params.ip_record.interface_hndl = 604 phba->interface_handle; 605 req->ip_params.ip_record.ip_addr.size_of_structure = 606 sizeof(struct be_ip_addr_subnet_format); 607 req->ip_params.ip_record.ip_addr.ip_type = ip_type; 608 ip_len = (ip_type < BEISCSI_IP_TYPE_V6) ? IP_V4_LEN : IP_V6_LEN; 609 memcpy(req->ip_params.ip_record.ip_addr.addr, ip, ip_len); 610 if (subnet) 611 memcpy(req->ip_params.ip_record.ip_addr.subnet_mask, 612 subnet, ip_len); 613 614 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 615 /** 616 * In some cases, host needs to look into individual record status 617 * even though FW reported success for that IOCTL. 618 */ 619 if (rc < 0 || req->ip_params.ip_record.status) { 620 __beiscsi_log(phba, KERN_ERR, 621 "BG_%d : failed to set IP: rc %d status %d\n", 622 rc, req->ip_params.ip_record.status); 623 if (req->ip_params.ip_record.status) 624 rc = -EINVAL; 625 } 626 return rc; 627 } 628 629 int beiscsi_if_en_static(struct beiscsi_hba *phba, u32 ip_type, 630 u8 *ip, u8 *subnet) 631 { 632 struct be_cmd_get_if_info_resp *if_info; 633 struct be_cmd_rel_dhcp_req *reldhcp; 634 struct be_dma_mem nonemb_cmd; 635 int rc; 636 637 rc = beiscsi_if_get_info(phba, ip_type, &if_info); 638 if (rc) 639 return rc; 640 641 if (if_info->dhcp_state) { 642 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 643 OPCODE_COMMON_ISCSI_NTWK_REL_STATELESS_IP_ADDR, 644 sizeof(*reldhcp)); 645 if (rc) 646 goto exit; 647 648 reldhcp = nonemb_cmd.va; 649 reldhcp->interface_hndl = phba->interface_handle; 650 reldhcp->ip_type = ip_type; 651 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 652 if (rc < 0) { 653 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 654 "BG_%d : failed to release existing DHCP: %d\n", 655 rc); 656 goto exit; 657 } 658 } 659 660 /* first delete any IP set */ 661 if (!beiscsi_if_zero_ip(if_info->ip_addr.addr, ip_type)) { 662 rc = beiscsi_if_clr_ip(phba, if_info); 663 if (rc) 664 goto exit; 665 } 666 667 /* if ip == NULL then this is called just to release DHCP IP */ 668 if (ip) 669 rc = beiscsi_if_set_ip(phba, ip, subnet, ip_type); 670 exit: 671 kfree(if_info); 672 return rc; 673 } 674 675 int beiscsi_if_en_dhcp(struct beiscsi_hba *phba, u32 ip_type) 676 { 677 struct be_cmd_get_def_gateway_resp gw_resp; 678 struct be_cmd_get_if_info_resp *if_info; 679 struct be_cmd_set_dhcp_req *dhcpreq; 680 struct be_dma_mem nonemb_cmd; 681 u8 *gw; 682 int rc; 683 684 rc = beiscsi_if_get_info(phba, ip_type, &if_info); 685 if (rc) 686 return rc; 687 688 if (if_info->dhcp_state) { 689 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 690 "BG_%d : DHCP Already Enabled\n"); 691 goto exit; 692 } 693 694 /* first delete any IP set */ 695 if (!beiscsi_if_zero_ip(if_info->ip_addr.addr, ip_type)) { 696 rc = beiscsi_if_clr_ip(phba, if_info); 697 if (rc) 698 goto exit; 699 } 700 701 /* delete gateway settings if mode change is to DHCP */ 702 memset(&gw_resp, 0, sizeof(gw_resp)); 703 /* use ip_type provided in if_info */ 704 rc = beiscsi_if_get_gw(phba, if_info->ip_addr.ip_type, &gw_resp); 705 if (rc) { 706 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 707 "BG_%d : Failed to Get Gateway Addr\n"); 708 goto exit; 709 } 710 gw = (u8 *)&gw_resp.ip_addr.addr; 711 if (!beiscsi_if_zero_ip(gw, if_info->ip_addr.ip_type)) { 712 rc = beiscsi_if_mod_gw(phba, IP_ACTION_DEL, 713 if_info->ip_addr.ip_type, gw); 714 if (rc) { 715 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG, 716 "BG_%d : Failed to clear Gateway Addr Set\n"); 717 goto exit; 718 } 719 } 720 721 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 722 OPCODE_COMMON_ISCSI_NTWK_CONFIG_STATELESS_IP_ADDR, 723 sizeof(*dhcpreq)); 724 if (rc) 725 goto exit; 726 727 dhcpreq = nonemb_cmd.va; 728 dhcpreq->flags = 1; /* 1 - blocking; 0 - non-blocking */ 729 dhcpreq->retry_count = 1; 730 dhcpreq->interface_hndl = phba->interface_handle; 731 dhcpreq->ip_type = ip_type; 732 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0); 733 734 exit: 735 kfree(if_info); 736 return rc; 737 } 738 739 /** 740 * beiscsi_if_set_vlan()- Issue and wait for CMD completion 741 * @phba: device private structure instance 742 * @vlan_tag: VLAN tag 743 * 744 * Issue the MBX Cmd and wait for the completion of the 745 * command. 746 * 747 * returns 748 * Success: 0 749 * Failure: Non-Xero Value 750 **/ 751 int beiscsi_if_set_vlan(struct beiscsi_hba *phba, uint16_t vlan_tag) 752 { 753 int rc; 754 unsigned int tag; 755 756 tag = be_cmd_set_vlan(phba, vlan_tag); 757 if (!tag) { 758 beiscsi_log(phba, KERN_ERR, 759 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX), 760 "BG_%d : VLAN Setting Failed\n"); 761 return -EBUSY; 762 } 763 764 rc = beiscsi_mccq_compl_wait(phba, tag, NULL, NULL); 765 if (rc) { 766 beiscsi_log(phba, KERN_ERR, 767 (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX), 768 "BS_%d : VLAN MBX Cmd Failed\n"); 769 return rc; 770 } 771 return rc; 772 } 773 774 775 int beiscsi_if_get_info(struct beiscsi_hba *phba, int ip_type, 776 struct be_cmd_get_if_info_resp **if_info) 777 { 778 struct be_cmd_get_if_info_req *req; 779 struct be_dma_mem nonemb_cmd; 780 uint32_t ioctl_size = sizeof(struct be_cmd_get_if_info_resp); 781 int rc; 782 783 rc = beiscsi_if_get_handle(phba); 784 if (rc) 785 return rc; 786 787 do { 788 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 789 OPCODE_COMMON_ISCSI_NTWK_GET_IF_INFO, 790 ioctl_size); 791 if (rc) 792 return rc; 793 794 req = nonemb_cmd.va; 795 req->interface_hndl = phba->interface_handle; 796 req->ip_type = ip_type; 797 798 /* Allocate memory for if_info */ 799 *if_info = kzalloc(ioctl_size, GFP_KERNEL); 800 if (!*if_info) { 801 beiscsi_log(phba, KERN_ERR, 802 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 803 "BG_%d : Memory Allocation Failure\n"); 804 805 /* Free the DMA memory for the IOCTL issuing */ 806 pci_free_consistent(phba->ctrl.pdev, 807 nonemb_cmd.size, 808 nonemb_cmd.va, 809 nonemb_cmd.dma); 810 return -ENOMEM; 811 } 812 813 rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, *if_info, 814 ioctl_size); 815 816 /* Check if the error is because of Insufficent_Buffer */ 817 if (rc == -EAGAIN) { 818 819 /* Get the new memory size */ 820 ioctl_size = ((struct be_cmd_resp_hdr *) 821 nonemb_cmd.va)->actual_resp_len; 822 ioctl_size += sizeof(struct be_cmd_req_hdr); 823 824 /* Free the previous allocated DMA memory */ 825 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size, 826 nonemb_cmd.va, 827 nonemb_cmd.dma); 828 829 /* Free the virtual memory */ 830 kfree(*if_info); 831 } else 832 break; 833 } while (true); 834 return rc; 835 } 836 837 int mgmt_get_nic_conf(struct beiscsi_hba *phba, 838 struct be_cmd_get_nic_conf_resp *nic) 839 { 840 struct be_dma_mem nonemb_cmd; 841 int rc; 842 843 rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd, 844 OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG, 845 sizeof(*nic)); 846 if (rc) 847 return rc; 848 849 return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, nic, sizeof(*nic)); 850 } 851 852 853 854 unsigned int be_cmd_get_initname(struct beiscsi_hba *phba) 855 { 856 unsigned int tag; 857 struct be_mcc_wrb *wrb; 858 struct be_cmd_hba_name *req; 859 struct be_ctrl_info *ctrl = &phba->ctrl; 860 861 if (mutex_lock_interruptible(&ctrl->mbox_lock)) 862 return 0; 863 wrb = alloc_mcc_wrb(phba, &tag); 864 if (!wrb) { 865 mutex_unlock(&ctrl->mbox_lock); 866 return 0; 867 } 868 869 req = embedded_payload(wrb); 870 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 871 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 872 OPCODE_ISCSI_INI_CFG_GET_HBA_NAME, 873 sizeof(*req)); 874 875 be_mcc_notify(phba, tag); 876 mutex_unlock(&ctrl->mbox_lock); 877 return tag; 878 } 879 880 static void beiscsi_boot_process_compl(struct beiscsi_hba *phba, 881 unsigned int tag) 882 { 883 struct be_cmd_get_boot_target_resp *boot_resp; 884 struct be_cmd_resp_logout_fw_sess *logo_resp; 885 struct be_cmd_get_session_resp *sess_resp; 886 struct be_mcc_wrb *wrb; 887 struct boot_struct *bs; 888 int boot_work, status; 889 890 if (!test_bit(BEISCSI_HBA_BOOT_WORK, &phba->state)) { 891 __beiscsi_log(phba, KERN_ERR, 892 "BG_%d : %s no boot work %lx\n", 893 __func__, phba->state); 894 return; 895 } 896 897 if (phba->boot_struct.tag != tag) { 898 __beiscsi_log(phba, KERN_ERR, 899 "BG_%d : %s tag mismatch %d:%d\n", 900 __func__, tag, phba->boot_struct.tag); 901 return; 902 } 903 bs = &phba->boot_struct; 904 boot_work = 1; 905 status = 0; 906 switch (bs->action) { 907 case BEISCSI_BOOT_REOPEN_SESS: 908 status = __beiscsi_mcc_compl_status(phba, tag, NULL, NULL); 909 if (!status) 910 bs->action = BEISCSI_BOOT_GET_SHANDLE; 911 else 912 bs->retry--; 913 break; 914 case BEISCSI_BOOT_GET_SHANDLE: 915 status = __beiscsi_mcc_compl_status(phba, tag, &wrb, NULL); 916 if (!status) { 917 boot_resp = embedded_payload(wrb); 918 bs->s_handle = boot_resp->boot_session_handle; 919 } 920 if (bs->s_handle == BE_BOOT_INVALID_SHANDLE) { 921 bs->action = BEISCSI_BOOT_REOPEN_SESS; 922 bs->retry--; 923 } else { 924 bs->action = BEISCSI_BOOT_GET_SINFO; 925 } 926 break; 927 case BEISCSI_BOOT_GET_SINFO: 928 status = __beiscsi_mcc_compl_status(phba, tag, NULL, 929 &bs->nonemb_cmd); 930 if (!status) { 931 sess_resp = bs->nonemb_cmd.va; 932 memcpy(&bs->boot_sess, &sess_resp->session_info, 933 sizeof(struct mgmt_session_info)); 934 bs->action = BEISCSI_BOOT_LOGOUT_SESS; 935 } else { 936 __beiscsi_log(phba, KERN_ERR, 937 "BG_%d : get boot session info error : 0x%x\n", 938 status); 939 boot_work = 0; 940 } 941 pci_free_consistent(phba->ctrl.pdev, bs->nonemb_cmd.size, 942 bs->nonemb_cmd.va, bs->nonemb_cmd.dma); 943 bs->nonemb_cmd.va = NULL; 944 break; 945 case BEISCSI_BOOT_LOGOUT_SESS: 946 status = __beiscsi_mcc_compl_status(phba, tag, &wrb, NULL); 947 if (!status) { 948 logo_resp = embedded_payload(wrb); 949 if (logo_resp->session_status != BE_SESS_STATUS_CLOSE) { 950 __beiscsi_log(phba, KERN_ERR, 951 "BG_%d : FW boot session logout error : 0x%x\n", 952 logo_resp->session_status); 953 } 954 } 955 /* continue to create boot_kset even if logout failed? */ 956 bs->action = BEISCSI_BOOT_CREATE_KSET; 957 break; 958 default: 959 break; 960 } 961 962 /* clear the tag so no other completion matches this tag */ 963 bs->tag = 0; 964 if (!bs->retry) { 965 boot_work = 0; 966 __beiscsi_log(phba, KERN_ERR, 967 "BG_%d : failed to setup boot target: status %d action %d\n", 968 status, bs->action); 969 } 970 if (!boot_work) { 971 /* wait for next event to start boot_work */ 972 clear_bit(BEISCSI_HBA_BOOT_WORK, &phba->state); 973 return; 974 } 975 schedule_work(&phba->boot_work); 976 } 977 978 /** 979 * beiscsi_boot_logout_sess()- Logout from boot FW session 980 * @phba: Device priv structure instance 981 * 982 * return 983 * the TAG used for MBOX Command 984 * 985 */ 986 unsigned int beiscsi_boot_logout_sess(struct beiscsi_hba *phba) 987 { 988 struct be_ctrl_info *ctrl = &phba->ctrl; 989 struct be_mcc_wrb *wrb; 990 struct be_cmd_req_logout_fw_sess *req; 991 unsigned int tag; 992 993 mutex_lock(&ctrl->mbox_lock); 994 wrb = alloc_mcc_wrb(phba, &tag); 995 if (!wrb) { 996 mutex_unlock(&ctrl->mbox_lock); 997 return 0; 998 } 999 1000 req = embedded_payload(wrb); 1001 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 1002 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 1003 OPCODE_ISCSI_INI_SESSION_LOGOUT_TARGET, 1004 sizeof(struct be_cmd_req_logout_fw_sess)); 1005 /* Use the session handle copied into boot_sess */ 1006 req->session_handle = phba->boot_struct.boot_sess.session_handle; 1007 1008 phba->boot_struct.tag = tag; 1009 set_bit(MCC_TAG_STATE_ASYNC, &ctrl->ptag_state[tag].tag_state); 1010 ctrl->ptag_state[tag].cbfn = beiscsi_boot_process_compl; 1011 1012 be_mcc_notify(phba, tag); 1013 mutex_unlock(&ctrl->mbox_lock); 1014 1015 return tag; 1016 } 1017 /** 1018 * beiscsi_boot_reopen_sess()- Reopen boot session 1019 * @phba: Device priv structure instance 1020 * 1021 * return 1022 * the TAG used for MBOX Command 1023 * 1024 **/ 1025 unsigned int beiscsi_boot_reopen_sess(struct beiscsi_hba *phba) 1026 { 1027 struct be_ctrl_info *ctrl = &phba->ctrl; 1028 struct be_mcc_wrb *wrb; 1029 struct be_cmd_reopen_session_req *req; 1030 unsigned int tag; 1031 1032 mutex_lock(&ctrl->mbox_lock); 1033 wrb = alloc_mcc_wrb(phba, &tag); 1034 if (!wrb) { 1035 mutex_unlock(&ctrl->mbox_lock); 1036 return 0; 1037 } 1038 1039 req = embedded_payload(wrb); 1040 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 1041 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 1042 OPCODE_ISCSI_INI_DRIVER_REOPEN_ALL_SESSIONS, 1043 sizeof(struct be_cmd_reopen_session_resp)); 1044 req->reopen_type = BE_REOPEN_BOOT_SESSIONS; 1045 req->session_handle = BE_BOOT_INVALID_SHANDLE; 1046 1047 phba->boot_struct.tag = tag; 1048 set_bit(MCC_TAG_STATE_ASYNC, &ctrl->ptag_state[tag].tag_state); 1049 ctrl->ptag_state[tag].cbfn = beiscsi_boot_process_compl; 1050 1051 be_mcc_notify(phba, tag); 1052 mutex_unlock(&ctrl->mbox_lock); 1053 return tag; 1054 } 1055 1056 1057 /** 1058 * beiscsi_boot_get_sinfo()- Get boot session info 1059 * @phba: device priv structure instance 1060 * 1061 * Fetches the boot_struct.s_handle info from FW. 1062 * return 1063 * the TAG used for MBOX Command 1064 * 1065 **/ 1066 unsigned int beiscsi_boot_get_sinfo(struct beiscsi_hba *phba) 1067 { 1068 struct be_ctrl_info *ctrl = &phba->ctrl; 1069 struct be_cmd_get_session_resp *resp; 1070 struct be_cmd_get_session_req *req; 1071 struct be_dma_mem *nonemb_cmd; 1072 struct be_mcc_wrb *wrb; 1073 struct be_sge *sge; 1074 unsigned int tag; 1075 1076 mutex_lock(&ctrl->mbox_lock); 1077 wrb = alloc_mcc_wrb(phba, &tag); 1078 if (!wrb) { 1079 mutex_unlock(&ctrl->mbox_lock); 1080 return 0; 1081 } 1082 1083 nonemb_cmd = &phba->boot_struct.nonemb_cmd; 1084 nonemb_cmd->size = sizeof(*resp); 1085 nonemb_cmd->va = pci_alloc_consistent(phba->ctrl.pdev, 1086 sizeof(nonemb_cmd->size), 1087 &nonemb_cmd->dma); 1088 if (!nonemb_cmd->va) { 1089 mutex_unlock(&ctrl->mbox_lock); 1090 return 0; 1091 } 1092 1093 req = nonemb_cmd->va; 1094 memset(req, 0, sizeof(*req)); 1095 sge = nonembedded_sgl(wrb); 1096 be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1); 1097 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 1098 OPCODE_ISCSI_INI_SESSION_GET_A_SESSION, 1099 sizeof(*resp)); 1100 req->session_handle = phba->boot_struct.s_handle; 1101 sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma)); 1102 sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF); 1103 sge->len = cpu_to_le32(nonemb_cmd->size); 1104 1105 phba->boot_struct.tag = tag; 1106 set_bit(MCC_TAG_STATE_ASYNC, &ctrl->ptag_state[tag].tag_state); 1107 ctrl->ptag_state[tag].cbfn = beiscsi_boot_process_compl; 1108 1109 be_mcc_notify(phba, tag); 1110 mutex_unlock(&ctrl->mbox_lock); 1111 return tag; 1112 } 1113 1114 unsigned int __beiscsi_boot_get_shandle(struct beiscsi_hba *phba, int async) 1115 { 1116 struct be_ctrl_info *ctrl = &phba->ctrl; 1117 struct be_mcc_wrb *wrb; 1118 struct be_cmd_get_boot_target_req *req; 1119 unsigned int tag; 1120 1121 mutex_lock(&ctrl->mbox_lock); 1122 wrb = alloc_mcc_wrb(phba, &tag); 1123 if (!wrb) { 1124 mutex_unlock(&ctrl->mbox_lock); 1125 return 0; 1126 } 1127 1128 req = embedded_payload(wrb); 1129 be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0); 1130 be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI, 1131 OPCODE_ISCSI_INI_BOOT_GET_BOOT_TARGET, 1132 sizeof(struct be_cmd_get_boot_target_resp)); 1133 1134 if (async) { 1135 phba->boot_struct.tag = tag; 1136 set_bit(MCC_TAG_STATE_ASYNC, &ctrl->ptag_state[tag].tag_state); 1137 ctrl->ptag_state[tag].cbfn = beiscsi_boot_process_compl; 1138 } 1139 1140 be_mcc_notify(phba, tag); 1141 mutex_unlock(&ctrl->mbox_lock); 1142 return tag; 1143 } 1144 1145 /** 1146 * beiscsi_boot_get_shandle()- Get boot session handle 1147 * @phba: device priv structure instance 1148 * @s_handle: session handle returned for boot session. 1149 * 1150 * return 1151 * Success: 1 1152 * Failure: negative 1153 * 1154 **/ 1155 int beiscsi_boot_get_shandle(struct beiscsi_hba *phba, unsigned int *s_handle) 1156 { 1157 struct be_cmd_get_boot_target_resp *boot_resp; 1158 struct be_mcc_wrb *wrb; 1159 unsigned int tag; 1160 int rc; 1161 1162 *s_handle = BE_BOOT_INVALID_SHANDLE; 1163 /* get configured boot session count and handle */ 1164 tag = __beiscsi_boot_get_shandle(phba, 0); 1165 if (!tag) { 1166 beiscsi_log(phba, KERN_ERR, 1167 BEISCSI_LOG_CONFIG | BEISCSI_LOG_INIT, 1168 "BG_%d : Getting Boot Target Info Failed\n"); 1169 return -EAGAIN; 1170 } 1171 1172 rc = beiscsi_mccq_compl_wait(phba, tag, &wrb, NULL); 1173 if (rc) { 1174 beiscsi_log(phba, KERN_ERR, 1175 BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG, 1176 "BG_%d : MBX CMD get_boot_target Failed\n"); 1177 return -EBUSY; 1178 } 1179 1180 boot_resp = embedded_payload(wrb); 1181 /* check if there are any boot targets configured */ 1182 if (!boot_resp->boot_session_count) { 1183 __beiscsi_log(phba, KERN_INFO, 1184 "BG_%d : No boot targets configured\n"); 1185 return -ENXIO; 1186 } 1187 1188 /* only if FW has logged in to the boot target, s_handle is valid */ 1189 *s_handle = boot_resp->boot_session_handle; 1190 return 1; 1191 } 1192 1193 /** 1194 * beiscsi_drvr_ver_disp()- Display the driver Name and Version 1195 * @dev: ptr to device not used. 1196 * @attr: device attribute, not used. 1197 * @buf: contains formatted text driver name and version 1198 * 1199 * return 1200 * size of the formatted string 1201 **/ 1202 ssize_t 1203 beiscsi_drvr_ver_disp(struct device *dev, struct device_attribute *attr, 1204 char *buf) 1205 { 1206 return snprintf(buf, PAGE_SIZE, BE_NAME "\n"); 1207 } 1208 1209 /** 1210 * beiscsi_fw_ver_disp()- Display Firmware Version 1211 * @dev: ptr to device not used. 1212 * @attr: device attribute, not used. 1213 * @buf: contains formatted text Firmware version 1214 * 1215 * return 1216 * size of the formatted string 1217 **/ 1218 ssize_t 1219 beiscsi_fw_ver_disp(struct device *dev, struct device_attribute *attr, 1220 char *buf) 1221 { 1222 struct Scsi_Host *shost = class_to_shost(dev); 1223 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1224 1225 return snprintf(buf, PAGE_SIZE, "%s\n", phba->fw_ver_str); 1226 } 1227 1228 /** 1229 * beiscsi_active_session_disp()- Display Sessions Active 1230 * @dev: ptr to device not used. 1231 * @attr: device attribute, not used. 1232 * @buf: contains formatted text Session Count 1233 * 1234 * return 1235 * size of the formatted string 1236 **/ 1237 ssize_t 1238 beiscsi_active_session_disp(struct device *dev, struct device_attribute *attr, 1239 char *buf) 1240 { 1241 struct Scsi_Host *shost = class_to_shost(dev); 1242 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1243 uint16_t avlbl_cids = 0, ulp_num, len = 0, total_cids = 0; 1244 1245 for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) { 1246 if (test_bit(ulp_num, (void *)&phba->fw_config.ulp_supported)) { 1247 avlbl_cids = BEISCSI_ULP_AVLBL_CID(phba, ulp_num); 1248 total_cids = BEISCSI_GET_CID_COUNT(phba, ulp_num); 1249 len += snprintf(buf+len, PAGE_SIZE - len, 1250 "ULP%d : %d\n", ulp_num, 1251 (total_cids - avlbl_cids)); 1252 } else 1253 len += snprintf(buf+len, PAGE_SIZE - len, 1254 "ULP%d : %d\n", ulp_num, 0); 1255 } 1256 1257 return len; 1258 } 1259 1260 /** 1261 * beiscsi_free_session_disp()- Display Avaliable Session 1262 * @dev: ptr to device not used. 1263 * @attr: device attribute, not used. 1264 * @buf: contains formatted text Session Count 1265 * 1266 * return 1267 * size of the formatted string 1268 **/ 1269 ssize_t 1270 beiscsi_free_session_disp(struct device *dev, struct device_attribute *attr, 1271 char *buf) 1272 { 1273 struct Scsi_Host *shost = class_to_shost(dev); 1274 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1275 uint16_t ulp_num, len = 0; 1276 1277 for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) { 1278 if (test_bit(ulp_num, (void *)&phba->fw_config.ulp_supported)) 1279 len += snprintf(buf+len, PAGE_SIZE - len, 1280 "ULP%d : %d\n", ulp_num, 1281 BEISCSI_ULP_AVLBL_CID(phba, ulp_num)); 1282 else 1283 len += snprintf(buf+len, PAGE_SIZE - len, 1284 "ULP%d : %d\n", ulp_num, 0); 1285 } 1286 1287 return len; 1288 } 1289 1290 /** 1291 * beiscsi_adap_family_disp()- Display adapter family. 1292 * @dev: ptr to device to get priv structure 1293 * @attr: device attribute, not used. 1294 * @buf: contains formatted text driver name and version 1295 * 1296 * return 1297 * size of the formatted string 1298 **/ 1299 ssize_t 1300 beiscsi_adap_family_disp(struct device *dev, struct device_attribute *attr, 1301 char *buf) 1302 { 1303 uint16_t dev_id = 0; 1304 struct Scsi_Host *shost = class_to_shost(dev); 1305 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1306 1307 dev_id = phba->pcidev->device; 1308 switch (dev_id) { 1309 case BE_DEVICE_ID1: 1310 case OC_DEVICE_ID1: 1311 case OC_DEVICE_ID2: 1312 return snprintf(buf, PAGE_SIZE, "BE2 Adapter Family\n"); 1313 break; 1314 case BE_DEVICE_ID2: 1315 case OC_DEVICE_ID3: 1316 return snprintf(buf, PAGE_SIZE, "BE3-R Adapter Family\n"); 1317 break; 1318 case OC_SKH_ID1: 1319 return snprintf(buf, PAGE_SIZE, "Skyhawk-R Adapter Family\n"); 1320 break; 1321 default: 1322 return snprintf(buf, PAGE_SIZE, 1323 "Unknown Adapter Family: 0x%x\n", dev_id); 1324 break; 1325 } 1326 } 1327 1328 /** 1329 * beiscsi_phys_port()- Display Physical Port Identifier 1330 * @dev: ptr to device not used. 1331 * @attr: device attribute, not used. 1332 * @buf: contains formatted text port identifier 1333 * 1334 * return 1335 * size of the formatted string 1336 **/ 1337 ssize_t 1338 beiscsi_phys_port_disp(struct device *dev, struct device_attribute *attr, 1339 char *buf) 1340 { 1341 struct Scsi_Host *shost = class_to_shost(dev); 1342 struct beiscsi_hba *phba = iscsi_host_priv(shost); 1343 1344 return snprintf(buf, PAGE_SIZE, "Port Identifier : %d\n", 1345 phba->fw_config.phys_port); 1346 } 1347 1348 void beiscsi_offload_cxn_v0(struct beiscsi_offload_params *params, 1349 struct wrb_handle *pwrb_handle, 1350 struct be_mem_descriptor *mem_descr, 1351 struct hwi_wrb_context *pwrb_context) 1352 { 1353 struct iscsi_wrb *pwrb = pwrb_handle->pwrb; 1354 1355 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1356 max_send_data_segment_length, pwrb, 1357 params->dw[offsetof(struct amap_beiscsi_offload_params, 1358 max_send_data_segment_length) / 32]); 1359 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, type, pwrb, 1360 BE_TGT_CTX_UPDT_CMD); 1361 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1362 first_burst_length, 1363 pwrb, 1364 params->dw[offsetof(struct amap_beiscsi_offload_params, 1365 first_burst_length) / 32]); 1366 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, erl, pwrb, 1367 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1368 erl) / 32] & OFFLD_PARAMS_ERL)); 1369 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, dde, pwrb, 1370 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1371 dde) / 32] & OFFLD_PARAMS_DDE) >> 2); 1372 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, hde, pwrb, 1373 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1374 hde) / 32] & OFFLD_PARAMS_HDE) >> 3); 1375 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ir2t, pwrb, 1376 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1377 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4); 1378 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, imd, pwrb, 1379 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1380 imd) / 32] & OFFLD_PARAMS_IMD) >> 5); 1381 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, stat_sn, 1382 pwrb, 1383 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1384 exp_statsn) / 32] + 1)); 1385 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, wrb_idx, 1386 pwrb, pwrb_handle->wrb_index); 1387 1388 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1389 max_burst_length, pwrb, params->dw[offsetof 1390 (struct amap_beiscsi_offload_params, 1391 max_burst_length) / 32]); 1392 1393 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, ptr2nextwrb, 1394 pwrb, pwrb_handle->wrb_index); 1395 if (pwrb_context->plast_wrb) 1396 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1397 ptr2nextwrb, 1398 pwrb_context->plast_wrb, 1399 pwrb_handle->wrb_index); 1400 pwrb_context->plast_wrb = pwrb; 1401 1402 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1403 session_state, pwrb, 0); 1404 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, compltonack, 1405 pwrb, 1); 1406 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, notpredblq, 1407 pwrb, 0); 1408 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, mode, pwrb, 1409 0); 1410 1411 mem_descr += ISCSI_MEM_GLOBAL_HEADER; 1412 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1413 pad_buffer_addr_hi, pwrb, 1414 mem_descr->mem_array[0].bus_address.u.a32.address_hi); 1415 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb, 1416 pad_buffer_addr_lo, pwrb, 1417 mem_descr->mem_array[0].bus_address.u.a32.address_lo); 1418 } 1419 1420 void beiscsi_offload_cxn_v2(struct beiscsi_offload_params *params, 1421 struct wrb_handle *pwrb_handle, 1422 struct hwi_wrb_context *pwrb_context) 1423 { 1424 struct iscsi_wrb *pwrb = pwrb_handle->pwrb; 1425 1426 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1427 max_burst_length, pwrb, params->dw[offsetof 1428 (struct amap_beiscsi_offload_params, 1429 max_burst_length) / 32]); 1430 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1431 type, pwrb, 1432 BE_TGT_CTX_UPDT_CMD); 1433 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1434 ptr2nextwrb, 1435 pwrb, pwrb_handle->wrb_index); 1436 if (pwrb_context->plast_wrb) 1437 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1438 ptr2nextwrb, 1439 pwrb_context->plast_wrb, 1440 pwrb_handle->wrb_index); 1441 pwrb_context->plast_wrb = pwrb; 1442 1443 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, wrb_idx, 1444 pwrb, pwrb_handle->wrb_index); 1445 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1446 max_send_data_segment_length, pwrb, 1447 params->dw[offsetof(struct amap_beiscsi_offload_params, 1448 max_send_data_segment_length) / 32]); 1449 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1450 first_burst_length, pwrb, 1451 params->dw[offsetof(struct amap_beiscsi_offload_params, 1452 first_burst_length) / 32]); 1453 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1454 max_recv_dataseg_len, pwrb, 1455 params->dw[offsetof(struct amap_beiscsi_offload_params, 1456 max_recv_data_segment_length) / 32]); 1457 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1458 max_cxns, pwrb, BEISCSI_MAX_CXNS); 1459 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, erl, pwrb, 1460 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1461 erl) / 32] & OFFLD_PARAMS_ERL)); 1462 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, dde, pwrb, 1463 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1464 dde) / 32] & OFFLD_PARAMS_DDE) >> 2); 1465 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, hde, pwrb, 1466 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1467 hde) / 32] & OFFLD_PARAMS_HDE) >> 3); 1468 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1469 ir2t, pwrb, 1470 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1471 ir2t) / 32] & OFFLD_PARAMS_IR2T) >> 4); 1472 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, imd, pwrb, 1473 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1474 imd) / 32] & OFFLD_PARAMS_IMD) >> 5); 1475 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1476 data_seq_inorder, 1477 pwrb, 1478 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1479 data_seq_inorder) / 32] & 1480 OFFLD_PARAMS_DATA_SEQ_INORDER) >> 6); 1481 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, 1482 pdu_seq_inorder, 1483 pwrb, 1484 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1485 pdu_seq_inorder) / 32] & 1486 OFFLD_PARAMS_PDU_SEQ_INORDER) >> 7); 1487 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, max_r2t, 1488 pwrb, 1489 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1490 max_r2t) / 32] & 1491 OFFLD_PARAMS_MAX_R2T) >> 8); 1492 AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb_v2, stat_sn, 1493 pwrb, 1494 (params->dw[offsetof(struct amap_beiscsi_offload_params, 1495 exp_statsn) / 32] + 1)); 1496 } 1497