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