drivers/scsi/be2iscsi/be_mgmt.c

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