drivers/scsi/qla2xxx/qla_bsg.c

   1 /*
   2  * QLogic Fibre Channel HBA Driver
   3  * Copyright (c)  2003-2012 QLogic Corporation
   4  *
   5  * See LICENSE.qla2xxx for copyright and licensing details.
   6  */
   7 #include "qla_def.h"
   8
   9 #include <linux/kthread.h>
  10 #include <linux/vmalloc.h>
  11 #include <linux/delay.h>
  12
  13 /* BSG support for ELS/CT pass through */
  14 void
  15 qla2x00_bsg_job_done(void *data, void *ptr, int res)
  16 {
  17         srb_t *sp = (srb_t *)ptr;
  18         struct scsi_qla_host *vha = (scsi_qla_host_t *)data;
  19         struct fc_bsg_job *bsg_job = sp->u.bsg_job;
  20
  21         bsg_job->reply->result = res;
  22         bsg_job->job_done(bsg_job);
  23         sp->free(vha, sp);
  24 }
  25
  26 void
  27 qla2x00_bsg_sp_free(void *data, void *ptr)
  28 {
  29         srb_t *sp = (srb_t *)ptr;
  30         struct scsi_qla_host *vha = (scsi_qla_host_t *)data;
  31         struct fc_bsg_job *bsg_job = sp->u.bsg_job;
  32         struct qla_hw_data *ha = vha->hw;
  33
  34         dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
  35             bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
  36
  37         dma_unmap_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
  38             bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
  39
  40         if (sp->type == SRB_CT_CMD ||
  41             sp->type == SRB_ELS_CMD_HST)
  42                 kfree(sp->fcport);
  43         mempool_free(sp, vha->hw->srb_mempool);
  44 }
  45
  46 int
  47 qla24xx_fcp_prio_cfg_valid(scsi_qla_host_t *vha,
  48         struct qla_fcp_prio_cfg *pri_cfg, uint8_t flag)
  49 {
  50         int i, ret, num_valid;
  51         uint8_t *bcode;
  52         struct qla_fcp_prio_entry *pri_entry;
  53         uint32_t *bcode_val_ptr, bcode_val;
  54
  55         ret = 1;
  56         num_valid = 0;
  57         bcode = (uint8_t *)pri_cfg;
  58         bcode_val_ptr = (uint32_t *)pri_cfg;
  59         bcode_val = (uint32_t)(*bcode_val_ptr);
  60
  61         if (bcode_val == 0xFFFFFFFF) {
  62                 /* No FCP Priority config data in flash */
  63                 ql_dbg(ql_dbg_user, vha, 0x7051,
  64                     "No FCP Priority config data.\n");
  65                 return 0;
  66         }
  67
  68         if (bcode[0] != 'H' || bcode[1] != 'Q' || bcode[2] != 'O' ||
  69                         bcode[3] != 'S') {
  70                 /* Invalid FCP priority data header*/
  71                 ql_dbg(ql_dbg_user, vha, 0x7052,
  72                     "Invalid FCP Priority data header. bcode=0x%x.\n",
  73                     bcode_val);
  74                 return 0;
  75         }
  76         if (flag != 1)
  77                 return ret;
  78
  79         pri_entry = &pri_cfg->entry[0];
  80         for (i = 0; i < pri_cfg->num_entries; i++) {
  81                 if (pri_entry->flags & FCP_PRIO_ENTRY_TAG_VALID)
  82                         num_valid++;
  83                 pri_entry++;
  84         }
  85
  86         if (num_valid == 0) {
  87                 /* No valid FCP priority data entries */
  88                 ql_dbg(ql_dbg_user, vha, 0x7053,
  89                     "No valid FCP Priority data entries.\n");
  90                 ret = 0;
  91         } else {
  92                 /* FCP priority data is valid */
  93                 ql_dbg(ql_dbg_user, vha, 0x7054,
  94                     "Valid FCP priority data. num entries = %d.\n",
  95                     num_valid);
  96         }
  97
  98         return ret;
  99 }
 100
 101 static int
 102 qla24xx_proc_fcp_prio_cfg_cmd(struct fc_bsg_job *bsg_job)
 103 {
 104         struct Scsi_Host *host = bsg_job->shost;
 105         scsi_qla_host_t *vha = shost_priv(host);
 106         struct qla_hw_data *ha = vha->hw;
 107         int ret = 0;
 108         uint32_t len;
 109         uint32_t oper;
 110
 111         if (!(IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha) || IS_QLA82XX(ha))) {
 112                 ret = -EINVAL;
 113                 goto exit_fcp_prio_cfg;
 114         }
 115
 116         /* Get the sub command */
 117         oper = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
 118
 119         /* Only set config is allowed if config memory is not allocated */
 120         if (!ha->fcp_prio_cfg && (oper != QLFC_FCP_PRIO_SET_CONFIG)) {
 121                 ret = -EINVAL;
 122                 goto exit_fcp_prio_cfg;
 123         }
 124         switch (oper) {
 125         case QLFC_FCP_PRIO_DISABLE:
 126                 if (ha->flags.fcp_prio_enabled) {
 127                         ha->flags.fcp_prio_enabled = 0;
 128                         ha->fcp_prio_cfg->attributes &=
 129                                 ~FCP_PRIO_ATTR_ENABLE;
 130                         qla24xx_update_all_fcp_prio(vha);
 131                         bsg_job->reply->result = DID_OK;
 132                 } else {
 133                         ret = -EINVAL;
 134                         bsg_job->reply->result = (DID_ERROR << 16);
 135                         goto exit_fcp_prio_cfg;
 136                 }
 137                 break;
 138
 139         case QLFC_FCP_PRIO_ENABLE:
 140                 if (!ha->flags.fcp_prio_enabled) {
 141                         if (ha->fcp_prio_cfg) {
 142                                 ha->flags.fcp_prio_enabled = 1;
 143                                 ha->fcp_prio_cfg->attributes |=
 144                                     FCP_PRIO_ATTR_ENABLE;
 145                                 qla24xx_update_all_fcp_prio(vha);
 146                                 bsg_job->reply->result = DID_OK;
 147                         } else {
 148                                 ret = -EINVAL;
 149                                 bsg_job->reply->result = (DID_ERROR << 16);
 150                                 goto exit_fcp_prio_cfg;
 151                         }
 152                 }
 153                 break;
 154
 155         case QLFC_FCP_PRIO_GET_CONFIG:
 156                 len = bsg_job->reply_payload.payload_len;
 157                 if (!len || len > FCP_PRIO_CFG_SIZE) {
 158                         ret = -EINVAL;
 159                         bsg_job->reply->result = (DID_ERROR << 16);
 160                         goto exit_fcp_prio_cfg;
 161                 }
 162
 163                 bsg_job->reply->result = DID_OK;
 164                 bsg_job->reply->reply_payload_rcv_len =
 165                         sg_copy_from_buffer(
 166                         bsg_job->reply_payload.sg_list,
 167                         bsg_job->reply_payload.sg_cnt, ha->fcp_prio_cfg,
 168                         len);
 169
 170                 break;
 171
 172         case QLFC_FCP_PRIO_SET_CONFIG:
 173                 len = bsg_job->request_payload.payload_len;
 174                 if (!len || len > FCP_PRIO_CFG_SIZE) {
 175                         bsg_job->reply->result = (DID_ERROR << 16);
 176                         ret = -EINVAL;
 177                         goto exit_fcp_prio_cfg;
 178                 }
 179
 180                 if (!ha->fcp_prio_cfg) {
 181                         ha->fcp_prio_cfg = vmalloc(FCP_PRIO_CFG_SIZE);
 182                         if (!ha->fcp_prio_cfg) {
 183                                 ql_log(ql_log_warn, vha, 0x7050,
 184                                     "Unable to allocate memory for fcp prio "
 185                                     "config data (%x).\n", FCP_PRIO_CFG_SIZE);
 186                                 bsg_job->reply->result = (DID_ERROR << 16);
 187                                 ret = -ENOMEM;
 188                                 goto exit_fcp_prio_cfg;
 189                         }
 190                 }
 191
 192                 memset(ha->fcp_prio_cfg, 0, FCP_PRIO_CFG_SIZE);
 193                 sg_copy_to_buffer(bsg_job->request_payload.sg_list,
 194                 bsg_job->request_payload.sg_cnt, ha->fcp_prio_cfg,
 195                         FCP_PRIO_CFG_SIZE);
 196
 197                 /* validate fcp priority data */
 198
 199                 if (!qla24xx_fcp_prio_cfg_valid(vha,
 200                     (struct qla_fcp_prio_cfg *) ha->fcp_prio_cfg, 1)) {
 201                         bsg_job->reply->result = (DID_ERROR << 16);
 202                         ret = -EINVAL;
 203                         /* If buffer was invalidatic int
 204                          * fcp_prio_cfg is of no use
 205                          */
 206                         vfree(ha->fcp_prio_cfg);
 207                         ha->fcp_prio_cfg = NULL;
 208                         goto exit_fcp_prio_cfg;
 209                 }
 210
 211                 ha->flags.fcp_prio_enabled = 0;
 212                 if (ha->fcp_prio_cfg->attributes & FCP_PRIO_ATTR_ENABLE)
 213                         ha->flags.fcp_prio_enabled = 1;
 214                 qla24xx_update_all_fcp_prio(vha);
 215                 bsg_job->reply->result = DID_OK;
 216                 break;
 217         default:
 218                 ret = -EINVAL;
 219                 break;
 220         }
 221 exit_fcp_prio_cfg:
 222         bsg_job->job_done(bsg_job);
 223         return ret;
 224 }
 225
 226 static int
 227 qla2x00_process_els(struct fc_bsg_job *bsg_job)
 228 {
 229         struct fc_rport *rport;
 230         fc_port_t *fcport = NULL;
 231         struct Scsi_Host *host;
 232         scsi_qla_host_t *vha;
 233         struct qla_hw_data *ha;
 234         srb_t *sp;
 235         const char *type;
 236         int req_sg_cnt, rsp_sg_cnt;
 237         int rval =  (DRIVER_ERROR << 16);
 238         uint16_t nextlid = 0;
 239
 240         if (bsg_job->request->msgcode == FC_BSG_RPT_ELS) {
 241                 rport = bsg_job->rport;
 242                 fcport = *(fc_port_t **) rport->dd_data;
 243                 host = rport_to_shost(rport);
 244                 vha = shost_priv(host);
 245                 ha = vha->hw;
 246                 type = "FC_BSG_RPT_ELS";
 247         } else {
 248                 host = bsg_job->shost;
 249                 vha = shost_priv(host);
 250                 ha = vha->hw;
 251                 type = "FC_BSG_HST_ELS_NOLOGIN";
 252         }
 253
 254         /* pass through is supported only for ISP 4Gb or higher */
 255         if (!IS_FWI2_CAPABLE(ha)) {
 256                 ql_dbg(ql_dbg_user, vha, 0x7001,
 257                     "ELS passthru not supported for ISP23xx based adapters.\n");
 258                 rval = -EPERM;
 259                 goto done;
 260         }
 261
 262         /*  Multiple SG's are not supported for ELS requests */
 263         if (bsg_job->request_payload.sg_cnt > 1 ||
 264                 bsg_job->reply_payload.sg_cnt > 1) {
 265                 ql_dbg(ql_dbg_user, vha, 0x7002,
 266                     "Multiple SG's are not suppored for ELS requests, "
 267                     "request_sg_cnt=%x reply_sg_cnt=%x.\n",
 268                     bsg_job->request_payload.sg_cnt,
 269                     bsg_job->reply_payload.sg_cnt);
 270                 rval = -EPERM;
 271                 goto done;
 272         }
 273
 274         /* ELS request for rport */
 275         if (bsg_job->request->msgcode == FC_BSG_RPT_ELS) {
 276                 /* make sure the rport is logged in,
 277                  * if not perform fabric login
 278                  */
 279                 if (qla2x00_fabric_login(vha, fcport, &nextlid)) {
 280                         ql_dbg(ql_dbg_user, vha, 0x7003,
 281                             "Failed to login port %06X for ELS passthru.\n",
 282                             fcport->d_id.b24);
 283                         rval = -EIO;
 284                         goto done;
 285                 }
 286         } else {
 287                 /* Allocate a dummy fcport structure, since functions
 288                  * preparing the IOCB and mailbox command retrieves port
 289                  * specific information from fcport structure. For Host based
 290                  * ELS commands there will be no fcport structure allocated
 291                  */
 292                 fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
 293                 if (!fcport) {
 294                         rval = -ENOMEM;
 295                         goto done;
 296                 }
 297
 298                 /* Initialize all required  fields of fcport */
 299                 fcport->vha = vha;
 300                 fcport->d_id.b.al_pa =
 301                         bsg_job->request->rqst_data.h_els.port_id[0];
 302                 fcport->d_id.b.area =
 303                         bsg_job->request->rqst_data.h_els.port_id[1];
 304                 fcport->d_id.b.domain =
 305                         bsg_job->request->rqst_data.h_els.port_id[2];
 306                 fcport->loop_id =
 307                         (fcport->d_id.b.al_pa == 0xFD) ?
 308                         NPH_FABRIC_CONTROLLER : NPH_F_PORT;
 309         }
 310
 311         if (!vha->flags.online) {
 312                 ql_log(ql_log_warn, vha, 0x7005, "Host not online.\n");
 313                 rval = -EIO;
 314                 goto done;
 315         }
 316
 317         req_sg_cnt =
 318                 dma_map_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
 319                 bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
 320         if (!req_sg_cnt) {
 321                 rval = -ENOMEM;
 322                 goto done_free_fcport;
 323         }
 324
 325         rsp_sg_cnt = dma_map_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
 326                 bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
 327         if (!rsp_sg_cnt) {
 328                 rval = -ENOMEM;
 329                 goto done_free_fcport;
 330         }
 331
 332         if ((req_sg_cnt !=  bsg_job->request_payload.sg_cnt) ||
 333                 (rsp_sg_cnt != bsg_job->reply_payload.sg_cnt)) {
 334                 ql_log(ql_log_warn, vha, 0x7008,
 335                     "dma mapping resulted in different sg counts, "
 336                     "request_sg_cnt: %x dma_request_sg_cnt:%x reply_sg_cnt:%x "
 337                     "dma_reply_sg_cnt:%x.\n", bsg_job->request_payload.sg_cnt,
 338                     req_sg_cnt, bsg_job->reply_payload.sg_cnt, rsp_sg_cnt);
 339                 rval = -EAGAIN;
 340                 goto done_unmap_sg;
 341         }
 342
 343         /* Alloc SRB structure */
 344         sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
 345         if (!sp) {
 346                 rval = -ENOMEM;
 347                 goto done_unmap_sg;
 348         }
 349
 350         sp->type =
 351                 (bsg_job->request->msgcode == FC_BSG_RPT_ELS ?
 352                 SRB_ELS_CMD_RPT : SRB_ELS_CMD_HST);
 353         sp->name =
 354                 (bsg_job->request->msgcode == FC_BSG_RPT_ELS ?
 355                 "bsg_els_rpt" : "bsg_els_hst");
 356         sp->u.bsg_job = bsg_job;
 357         sp->free = qla2x00_bsg_sp_free;
 358         sp->done = qla2x00_bsg_job_done;
 359
 360         ql_dbg(ql_dbg_user, vha, 0x700a,
 361             "bsg rqst type: %s els type: %x - loop-id=%x "
 362             "portid=%-2x%02x%02x.\n", type,
 363             bsg_job->request->rqst_data.h_els.command_code, fcport->loop_id,
 364             fcport->d_id.b.domain, fcport->d_id.b.area, fcport->d_id.b.al_pa);
 365
 366         rval = qla2x00_start_sp(sp);
 367         if (rval != QLA_SUCCESS) {
 368                 ql_log(ql_log_warn, vha, 0x700e,
 369                     "qla2x00_start_sp failed = %d\n", rval);
 370                 mempool_free(sp, ha->srb_mempool);
 371                 rval = -EIO;
 372                 goto done_unmap_sg;
 373         }
 374         return rval;
 375
 376 done_unmap_sg:
 377         dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
 378                 bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
 379         dma_unmap_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
 380                 bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
 381         goto done_free_fcport;
 382
 383 done_free_fcport:
 384         if (bsg_job->request->msgcode == FC_BSG_HST_ELS_NOLOGIN)
 385                 kfree(fcport);
 386 done:
 387         return rval;
 388 }
 389
 390 inline uint16_t
 391 qla24xx_calc_ct_iocbs(uint16_t dsds)
 392 {
 393         uint16_t iocbs;
 394
 395         iocbs = 1;
 396         if (dsds > 2) {
 397                 iocbs += (dsds - 2) / 5;
 398                 if ((dsds - 2) % 5)
 399                         iocbs++;
 400         }
 401         return iocbs;
 402 }
 403
 404 static int
 405 qla2x00_process_ct(struct fc_bsg_job *bsg_job)
 406 {
 407         srb_t *sp;
 408         struct Scsi_Host *host = bsg_job->shost;
 409         scsi_qla_host_t *vha = shost_priv(host);
 410         struct qla_hw_data *ha = vha->hw;
 411         int rval = (DRIVER_ERROR << 16);
 412         int req_sg_cnt, rsp_sg_cnt;
 413         uint16_t loop_id;
 414         struct fc_port *fcport;
 415         char  *type = "FC_BSG_HST_CT";
 416
 417         req_sg_cnt =
 418                 dma_map_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
 419                         bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
 420         if (!req_sg_cnt) {
 421                 ql_log(ql_log_warn, vha, 0x700f,
 422                     "dma_map_sg return %d for request\n", req_sg_cnt);
 423                 rval = -ENOMEM;
 424                 goto done;
 425         }
 426
 427         rsp_sg_cnt = dma_map_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
 428                 bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
 429         if (!rsp_sg_cnt) {
 430                 ql_log(ql_log_warn, vha, 0x7010,
 431                     "dma_map_sg return %d for reply\n", rsp_sg_cnt);
 432                 rval = -ENOMEM;
 433                 goto done;
 434         }
 435
 436         if ((req_sg_cnt !=  bsg_job->request_payload.sg_cnt) ||
 437             (rsp_sg_cnt != bsg_job->reply_payload.sg_cnt)) {
 438                 ql_log(ql_log_warn, vha, 0x7011,
 439                     "request_sg_cnt: %x dma_request_sg_cnt: %x reply_sg_cnt:%x "
 440                     "dma_reply_sg_cnt: %x\n", bsg_job->request_payload.sg_cnt,
 441                     req_sg_cnt, bsg_job->reply_payload.sg_cnt, rsp_sg_cnt);
 442                 rval = -EAGAIN;
 443                 goto done_unmap_sg;
 444         }
 445
 446         if (!vha->flags.online) {
 447                 ql_log(ql_log_warn, vha, 0x7012,
 448                     "Host is not online.\n");
 449                 rval = -EIO;
 450                 goto done_unmap_sg;
 451         }
 452
 453         loop_id =
 454                 (bsg_job->request->rqst_data.h_ct.preamble_word1 & 0xFF000000)
 455                         >> 24;
 456         switch (loop_id) {
 457         case 0xFC:
 458                 loop_id = cpu_to_le16(NPH_SNS);
 459                 break;
 460         case 0xFA:
 461                 loop_id = vha->mgmt_svr_loop_id;
 462                 break;
 463         default:
 464                 ql_dbg(ql_dbg_user, vha, 0x7013,
 465                     "Unknown loop id: %x.\n", loop_id);
 466                 rval = -EINVAL;
 467                 goto done_unmap_sg;
 468         }
 469
 470         /* Allocate a dummy fcport structure, since functions preparing the
 471          * IOCB and mailbox command retrieves port specific information
 472          * from fcport structure. For Host based ELS commands there will be
 473          * no fcport structure allocated
 474          */
 475         fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
 476         if (!fcport) {
 477                 ql_log(ql_log_warn, vha, 0x7014,
 478                     "Failed to allocate fcport.\n");
 479                 rval = -ENOMEM;
 480                 goto done_unmap_sg;
 481         }
 482
 483         /* Initialize all required  fields of fcport */
 484         fcport->vha = vha;
 485         fcport->d_id.b.al_pa = bsg_job->request->rqst_data.h_ct.port_id[0];
 486         fcport->d_id.b.area = bsg_job->request->rqst_data.h_ct.port_id[1];
 487         fcport->d_id.b.domain = bsg_job->request->rqst_data.h_ct.port_id[2];
 488         fcport->loop_id = loop_id;
 489
 490         /* Alloc SRB structure */
 491         sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
 492         if (!sp) {
 493                 ql_log(ql_log_warn, vha, 0x7015,
 494                     "qla2x00_get_sp failed.\n");
 495                 rval = -ENOMEM;
 496                 goto done_free_fcport;
 497         }
 498
 499         sp->type = SRB_CT_CMD;
 500         sp->name = "bsg_ct";
 501         sp->iocbs = qla24xx_calc_ct_iocbs(req_sg_cnt + rsp_sg_cnt);
 502         sp->u.bsg_job = bsg_job;
 503         sp->free = qla2x00_bsg_sp_free;
 504         sp->done = qla2x00_bsg_job_done;
 505
 506         ql_dbg(ql_dbg_user, vha, 0x7016,
 507             "bsg rqst type: %s else type: %x - "
 508             "loop-id=%x portid=%02x%02x%02x.\n", type,
 509             (bsg_job->request->rqst_data.h_ct.preamble_word2 >> 16),
 510             fcport->loop_id, fcport->d_id.b.domain, fcport->d_id.b.area,
 511             fcport->d_id.b.al_pa);
 512
 513         rval = qla2x00_start_sp(sp);
 514         if (rval != QLA_SUCCESS) {
 515                 ql_log(ql_log_warn, vha, 0x7017,
 516                     "qla2x00_start_sp failed=%d.\n", rval);
 517                 mempool_free(sp, ha->srb_mempool);
 518                 rval = -EIO;
 519                 goto done_free_fcport;
 520         }
 521         return rval;
 522
 523 done_free_fcport:
 524         kfree(fcport);
 525 done_unmap_sg:
 526         dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
 527                 bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
 528         dma_unmap_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
 529                 bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
 530 done:
 531         return rval;
 532 }
 533 /*
 534  * Set the port configuration to enable the internal or external loopback
 535  * depending on the loopback mode.
 536  */
 537 static inline int
 538 qla81xx_set_loopback_mode(scsi_qla_host_t *vha, uint16_t *config,
 539         uint16_t *new_config, uint16_t mode)
 540 {
 541         int ret = 0;
 542         int rval = 0;
 543         struct qla_hw_data *ha = vha->hw;
 544
 545         if (!IS_QLA81XX(ha) && !IS_QLA8031(ha))
 546                 goto done_set_internal;
 547
 548         if (mode == INTERNAL_LOOPBACK)
 549                 new_config[0] = config[0] | (ENABLE_INTERNAL_LOOPBACK << 1);
 550         else if (mode == EXTERNAL_LOOPBACK)
 551                 new_config[0] = config[0] | (ENABLE_EXTERNAL_LOOPBACK << 1);
 552         ql_dbg(ql_dbg_user, vha, 0x70be,
 553              "new_config[0]=%02x\n", (new_config[0] & INTERNAL_LOOPBACK_MASK));
 554
 555         memcpy(&new_config[1], &config[1], sizeof(uint16_t) * 3);
 556
 557         ha->notify_dcbx_comp = 1;
 558         ret = qla81xx_set_port_config(vha, new_config);
 559         if (ret != QLA_SUCCESS) {
 560                 ql_log(ql_log_warn, vha, 0x7021,
 561                     "set port config failed.\n");
 562                 ha->notify_dcbx_comp = 0;
 563                 rval = -EINVAL;
 564                 goto done_set_internal;
 565         }
 566
 567         /* Wait for DCBX complete event */
 568         if (!wait_for_completion_timeout(&ha->dcbx_comp, (20 * HZ))) {
 569                 ql_dbg(ql_dbg_user, vha, 0x7022,
 570                     "State change notification not received.\n");
 571                 rval = -EINVAL;
 572         } else {
 573                 if (ha->flags.idc_compl_status) {
 574                         ql_dbg(ql_dbg_user, vha, 0x70c3,
 575                             "Bad status in IDC Completion AEN\n");
 576                         rval = -EINVAL;
 577                         ha->flags.idc_compl_status = 0;
 578                 } else
 579                         ql_dbg(ql_dbg_user, vha, 0x7023,
 580                             "State change received.\n");
 581         }
 582
 583         ha->notify_dcbx_comp = 0;
 584
 585 done_set_internal:
 586         return rval;
 587 }
 588
 589 /* Disable loopback mode */
 590 static inline int
 591 qla81xx_reset_loopback_mode(scsi_qla_host_t *vha, uint16_t *config,
 592     int wait)
 593 {
 594         int ret = 0;
 595         int rval = 0;
 596         uint16_t new_config[4];
 597         struct qla_hw_data *ha = vha->hw;
 598
 599         if (!IS_QLA81XX(ha) && !IS_QLA8031(ha))
 600                 goto done_reset_internal;
 601
 602         memset(new_config, 0 , sizeof(new_config));
 603         if ((config[0] & INTERNAL_LOOPBACK_MASK) >> 1 ==
 604             ENABLE_INTERNAL_LOOPBACK ||
 605             (config[0] & INTERNAL_LOOPBACK_MASK) >> 1 ==
 606             ENABLE_EXTERNAL_LOOPBACK) {
 607                 new_config[0] = config[0] & ~INTERNAL_LOOPBACK_MASK;
 608                 ql_dbg(ql_dbg_user, vha, 0x70bf, "new_config[0]=%02x\n",
 609                     (new_config[0] & INTERNAL_LOOPBACK_MASK));
 610                 memcpy(&new_config[1], &config[1], sizeof(uint16_t) * 3) ;
 611
 612                 ha->notify_dcbx_comp = wait;
 613                 ret = qla81xx_set_port_config(vha, new_config);
 614                 if (ret != QLA_SUCCESS) {
 615                         ql_log(ql_log_warn, vha, 0x7025,
 616                             "Set port config failed.\n");
 617                         ha->notify_dcbx_comp = 0;
 618                         rval = -EINVAL;
 619                         goto done_reset_internal;
 620                 }
 621
 622                 /* Wait for DCBX complete event */
 623                 if (wait && !wait_for_completion_timeout(&ha->dcbx_comp,
 624                         (20 * HZ))) {
 625                         ql_dbg(ql_dbg_user, vha, 0x7026,
 626                             "State change notification not received.\n");
 627                         ha->notify_dcbx_comp = 0;
 628                         rval = -EINVAL;
 629                         goto done_reset_internal;
 630                 } else
 631                         ql_dbg(ql_dbg_user, vha, 0x7027,
 632                             "State change received.\n");
 633
 634                 ha->notify_dcbx_comp = 0;
 635         }
 636 done_reset_internal:
 637         return rval;
 638 }
 639
 640 static int
 641 qla2x00_process_loopback(struct fc_bsg_job *bsg_job)
 642 {
 643         struct Scsi_Host *host = bsg_job->shost;
 644         scsi_qla_host_t *vha = shost_priv(host);
 645         struct qla_hw_data *ha = vha->hw;
 646         int rval;
 647         uint8_t command_sent;
 648         char *type;
 649         struct msg_echo_lb elreq;
 650         uint16_t response[MAILBOX_REGISTER_COUNT];
 651         uint16_t config[4], new_config[4];
 652         uint8_t *fw_sts_ptr;
 653         uint8_t *req_data = NULL;
 654         dma_addr_t req_data_dma;
 655         uint32_t req_data_len;
 656         uint8_t *rsp_data = NULL;
 657         dma_addr_t rsp_data_dma;
 658         uint32_t rsp_data_len;
 659
 660         if (!vha->flags.online) {
 661                 ql_log(ql_log_warn, vha, 0x7019, "Host is not online.\n");
 662                 return -EIO;
 663         }
 664
 665         elreq.req_sg_cnt = dma_map_sg(&ha->pdev->dev,
 666                 bsg_job->request_payload.sg_list, bsg_job->request_payload.sg_cnt,
 667                 DMA_TO_DEVICE);
 668
 669         if (!elreq.req_sg_cnt) {
 670                 ql_log(ql_log_warn, vha, 0x701a,
 671                     "dma_map_sg returned %d for request.\n", elreq.req_sg_cnt);
 672                 return -ENOMEM;
 673         }
 674
 675         elreq.rsp_sg_cnt = dma_map_sg(&ha->pdev->dev,
 676                 bsg_job->reply_payload.sg_list, bsg_job->reply_payload.sg_cnt,
 677                 DMA_FROM_DEVICE);
 678
 679         if (!elreq.rsp_sg_cnt) {
 680                 ql_log(ql_log_warn, vha, 0x701b,
 681                     "dma_map_sg returned %d for reply.\n", elreq.rsp_sg_cnt);
 682                 rval = -ENOMEM;
 683                 goto done_unmap_req_sg;
 684         }
 685
 686         if ((elreq.req_sg_cnt !=  bsg_job->request_payload.sg_cnt) ||
 687                 (elreq.rsp_sg_cnt != bsg_job->reply_payload.sg_cnt)) {
 688                 ql_log(ql_log_warn, vha, 0x701c,
 689                     "dma mapping resulted in different sg counts, "
 690                     "request_sg_cnt: %x dma_request_sg_cnt: %x "
 691                     "reply_sg_cnt: %x dma_reply_sg_cnt: %x.\n",
 692                     bsg_job->request_payload.sg_cnt, elreq.req_sg_cnt,
 693                     bsg_job->reply_payload.sg_cnt, elreq.rsp_sg_cnt);
 694                 rval = -EAGAIN;
 695                 goto done_unmap_sg;
 696         }
 697         req_data_len = rsp_data_len = bsg_job->request_payload.payload_len;
 698         req_data = dma_alloc_coherent(&ha->pdev->dev, req_data_len,
 699                 &req_data_dma, GFP_KERNEL);
 700         if (!req_data) {
 701                 ql_log(ql_log_warn, vha, 0x701d,
 702                     "dma alloc failed for req_data.\n");
 703                 rval = -ENOMEM;
 704                 goto done_unmap_sg;
 705         }
 706
 707         rsp_data = dma_alloc_coherent(&ha->pdev->dev, rsp_data_len,
 708                 &rsp_data_dma, GFP_KERNEL);
 709         if (!rsp_data) {
 710                 ql_log(ql_log_warn, vha, 0x7004,
 711                     "dma alloc failed for rsp_data.\n");
 712                 rval = -ENOMEM;
 713                 goto done_free_dma_req;
 714         }
 715
 716         /* Copy the request buffer in req_data now */
 717         sg_copy_to_buffer(bsg_job->request_payload.sg_list,
 718                 bsg_job->request_payload.sg_cnt, req_data, req_data_len);
 719
 720         elreq.send_dma = req_data_dma;
 721         elreq.rcv_dma = rsp_data_dma;
 722         elreq.transfer_size = req_data_len;
 723
 724         elreq.options = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
 725
 726         if (atomic_read(&vha->loop_state) == LOOP_READY &&
 727             (ha->current_topology == ISP_CFG_F ||
 728             ((IS_QLA81XX(ha) || IS_QLA8031(ha)) &&
 729             le32_to_cpu(*(uint32_t *)req_data) == ELS_OPCODE_BYTE
 730             && req_data_len == MAX_ELS_FRAME_PAYLOAD)) &&
 731                 elreq.options == EXTERNAL_LOOPBACK) {
 732                 type = "FC_BSG_HST_VENDOR_ECHO_DIAG";
 733                 ql_dbg(ql_dbg_user, vha, 0x701e,
 734                     "BSG request type: %s.\n", type);
 735                 command_sent = INT_DEF_LB_ECHO_CMD;
 736                 rval = qla2x00_echo_test(vha, &elreq, response);
 737         } else {
 738                 if (IS_QLA81XX(ha) || IS_QLA8031(ha)) {
 739                         memset(config, 0, sizeof(config));
 740                         memset(new_config, 0, sizeof(new_config));
 741                         if (qla81xx_get_port_config(vha, config)) {
 742                                 ql_log(ql_log_warn, vha, 0x701f,
 743                                     "Get port config failed.\n");
 744                                 bsg_job->reply->result = (DID_ERROR << 16);
 745                                 rval = -EPERM;
 746                                 goto done_free_dma_req;
 747                         }
 748
 749                         ql_dbg(ql_dbg_user, vha, 0x70c0,
 750                             "elreq.options=%04x\n", elreq.options);
 751
 752                         if (elreq.options == EXTERNAL_LOOPBACK)
 753                                 if (IS_QLA8031(ha))
 754                                         rval = qla81xx_set_loopback_mode(vha,
 755                                             config, new_config, elreq.options);
 756                                 else
 757                                         rval = qla81xx_reset_loopback_mode(vha,
 758                                             config, 1);
 759                         else
 760                                 rval = qla81xx_set_loopback_mode(vha, config,
 761                                     new_config, elreq.options);
 762
 763                         if (rval) {
 764                                 bsg_job->reply->result = (DID_ERROR << 16);
 765                                 rval = -EPERM;
 766                                 goto done_free_dma_req;
 767                         }
 768
 769                         type = "FC_BSG_HST_VENDOR_LOOPBACK";
 770                         ql_dbg(ql_dbg_user, vha, 0x7028,
 771                             "BSG request type: %s.\n", type);
 772
 773                         command_sent = INT_DEF_LB_LOOPBACK_CMD;
 774                         rval = qla2x00_loopback_test(vha, &elreq, response);
 775
 776                         if (new_config[0]) {
 777                                 /* Revert back to original port config
 778                                  * Also clear internal loopback
 779                                  */
 780                                 qla81xx_reset_loopback_mode(vha,
 781                                     new_config, 0);
 782                         }
 783
 784                         if (response[0] == MBS_COMMAND_ERROR &&
 785                                         response[1] == MBS_LB_RESET) {
 786                                 ql_log(ql_log_warn, vha, 0x7029,
 787                                     "MBX command error, Aborting ISP.\n");
 788                                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
 789                                 qla2xxx_wake_dpc(vha);
 790                                 qla2x00_wait_for_chip_reset(vha);
 791                                 /* Also reset the MPI */
 792                                 if (qla81xx_restart_mpi_firmware(vha) !=
 793                                     QLA_SUCCESS) {
 794                                         ql_log(ql_log_warn, vha, 0x702a,
 795                                             "MPI reset failed.\n");
 796                                 }
 797
 798                                 bsg_job->reply->result = (DID_ERROR << 16);
 799                                 rval = -EIO;
 800                                 goto done_free_dma_req;
 801                         }
 802                 } else {
 803                         type = "FC_BSG_HST_VENDOR_LOOPBACK";
 804                         ql_dbg(ql_dbg_user, vha, 0x702b,
 805                             "BSG request type: %s.\n", type);
 806                         command_sent = INT_DEF_LB_LOOPBACK_CMD;
 807                         rval = qla2x00_loopback_test(vha, &elreq, response);
 808                 }
 809         }
 810
 811         if (rval) {
 812                 ql_log(ql_log_warn, vha, 0x702c,
 813                     "Vendor request %s failed.\n", type);
 814
 815                 fw_sts_ptr = ((uint8_t *)bsg_job->req->sense) +
 816                     sizeof(struct fc_bsg_reply);
 817
 818                 memcpy(fw_sts_ptr, response, sizeof(response));
 819                 fw_sts_ptr += sizeof(response);
 820                 *fw_sts_ptr = command_sent;
 821                 rval = 0;
 822                 bsg_job->reply->result = (DID_ERROR << 16);
 823         } else {
 824                 ql_dbg(ql_dbg_user, vha, 0x702d,
 825                     "Vendor request %s completed.\n", type);
 826
 827                 bsg_job->reply_len = sizeof(struct fc_bsg_reply) +
 828                         sizeof(response) + sizeof(uint8_t);
 829                 bsg_job->reply->reply_payload_rcv_len =
 830                         bsg_job->reply_payload.payload_len;
 831                 fw_sts_ptr = ((uint8_t *)bsg_job->req->sense) +
 832                         sizeof(struct fc_bsg_reply);
 833                 memcpy(fw_sts_ptr, response, sizeof(response));
 834                 fw_sts_ptr += sizeof(response);
 835                 *fw_sts_ptr = command_sent;
 836                 bsg_job->reply->result = DID_OK;
 837                 sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
 838                         bsg_job->reply_payload.sg_cnt, rsp_data,
 839                         rsp_data_len);
 840         }
 841         bsg_job->job_done(bsg_job);
 842
 843         dma_free_coherent(&ha->pdev->dev, rsp_data_len,
 844                 rsp_data, rsp_data_dma);
 845 done_free_dma_req:
 846         dma_free_coherent(&ha->pdev->dev, req_data_len,
 847                 req_data, req_data_dma);
 848 done_unmap_sg:
 849         dma_unmap_sg(&ha->pdev->dev,
 850             bsg_job->reply_payload.sg_list,
 851             bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
 852 done_unmap_req_sg:
 853         dma_unmap_sg(&ha->pdev->dev,
 854             bsg_job->request_payload.sg_list,
 855             bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
 856         return rval;
 857 }
 858
 859 static int
 860 qla84xx_reset(struct fc_bsg_job *bsg_job)
 861 {
 862         struct Scsi_Host *host = bsg_job->shost;
 863         scsi_qla_host_t *vha = shost_priv(host);
 864         struct qla_hw_data *ha = vha->hw;
 865         int rval = 0;
 866         uint32_t flag;
 867
 868         if (!IS_QLA84XX(ha)) {
 869                 ql_dbg(ql_dbg_user, vha, 0x702f, "Not 84xx, exiting.\n");
 870                 return -EINVAL;
 871         }
 872
 873         flag = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
 874
 875         rval = qla84xx_reset_chip(vha, flag == A84_ISSUE_RESET_DIAG_FW);
 876
 877         if (rval) {
 878                 ql_log(ql_log_warn, vha, 0x7030,
 879                     "Vendor request 84xx reset failed.\n");
 880                 rval = 0;
 881                 bsg_job->reply->result = (DID_ERROR << 16);
 882
 883         } else {
 884                 ql_dbg(ql_dbg_user, vha, 0x7031,
 885                     "Vendor request 84xx reset completed.\n");
 886                 bsg_job->reply->result = DID_OK;
 887         }
 888
 889         bsg_job->job_done(bsg_job);
 890         return rval;
 891 }
 892
 893 static int
 894 qla84xx_updatefw(struct fc_bsg_job *bsg_job)
 895 {
 896         struct Scsi_Host *host = bsg_job->shost;
 897         scsi_qla_host_t *vha = shost_priv(host);
 898         struct qla_hw_data *ha = vha->hw;
 899         struct verify_chip_entry_84xx *mn = NULL;
 900         dma_addr_t mn_dma, fw_dma;
 901         void *fw_buf = NULL;
 902         int rval = 0;
 903         uint32_t sg_cnt;
 904         uint32_t data_len;
 905         uint16_t options;
 906         uint32_t flag;
 907         uint32_t fw_ver;
 908
 909         if (!IS_QLA84XX(ha)) {
 910                 ql_dbg(ql_dbg_user, vha, 0x7032,
 911                     "Not 84xx, exiting.\n");
 912                 return -EINVAL;
 913         }
 914
 915         sg_cnt = dma_map_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
 916                 bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
 917         if (!sg_cnt) {
 918                 ql_log(ql_log_warn, vha, 0x7033,
 919                     "dma_map_sg returned %d for request.\n", sg_cnt);
 920                 return -ENOMEM;
 921         }
 922
 923         if (sg_cnt != bsg_job->request_payload.sg_cnt) {
 924                 ql_log(ql_log_warn, vha, 0x7034,
 925                     "DMA mapping resulted in different sg counts, "
 926                     "request_sg_cnt: %x dma_request_sg_cnt: %x.\n",
 927                     bsg_job->request_payload.sg_cnt, sg_cnt);
 928                 rval = -EAGAIN;
 929                 goto done_unmap_sg;
 930         }
 931
 932         data_len = bsg_job->request_payload.payload_len;
 933         fw_buf = dma_alloc_coherent(&ha->pdev->dev, data_len,
 934                 &fw_dma, GFP_KERNEL);
 935         if (!fw_buf) {
 936                 ql_log(ql_log_warn, vha, 0x7035,
 937                     "DMA alloc failed for fw_buf.\n");
 938                 rval = -ENOMEM;
 939                 goto done_unmap_sg;
 940         }
 941
 942         sg_copy_to_buffer(bsg_job->request_payload.sg_list,
 943                 bsg_job->request_payload.sg_cnt, fw_buf, data_len);
 944
 945         mn = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &mn_dma);
 946         if (!mn) {
 947                 ql_log(ql_log_warn, vha, 0x7036,
 948                     "DMA alloc failed for fw buffer.\n");
 949                 rval = -ENOMEM;
 950                 goto done_free_fw_buf;
 951         }
 952
 953         flag = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
 954         fw_ver = le32_to_cpu(*((uint32_t *)((uint32_t *)fw_buf + 2)));
 955
 956         memset(mn, 0, sizeof(struct access_chip_84xx));
 957         mn->entry_type = VERIFY_CHIP_IOCB_TYPE;
 958         mn->entry_count = 1;
 959
 960         options = VCO_FORCE_UPDATE | VCO_END_OF_DATA;
 961         if (flag == A84_ISSUE_UPDATE_DIAGFW_CMD)
 962                 options |= VCO_DIAG_FW;
 963
 964         mn->options = cpu_to_le16(options);
 965         mn->fw_ver =  cpu_to_le32(fw_ver);
 966         mn->fw_size =  cpu_to_le32(data_len);
 967         mn->fw_seq_size =  cpu_to_le32(data_len);
 968         mn->dseg_address[0] = cpu_to_le32(LSD(fw_dma));
 969         mn->dseg_address[1] = cpu_to_le32(MSD(fw_dma));
 970         mn->dseg_length = cpu_to_le32(data_len);
 971         mn->data_seg_cnt = cpu_to_le16(1);
 972
 973         rval = qla2x00_issue_iocb_timeout(vha, mn, mn_dma, 0, 120);
 974
 975         if (rval) {
 976                 ql_log(ql_log_warn, vha, 0x7037,
 977                     "Vendor request 84xx updatefw failed.\n");
 978
 979                 rval = 0;
 980                 bsg_job->reply->result = (DID_ERROR << 16);
 981         } else {
 982                 ql_dbg(ql_dbg_user, vha, 0x7038,
 983                     "Vendor request 84xx updatefw completed.\n");
 984
 985                 bsg_job->reply_len = sizeof(struct fc_bsg_reply);
 986                 bsg_job->reply->result = DID_OK;
 987         }
 988
 989         bsg_job->job_done(bsg_job);
 990         dma_pool_free(ha->s_dma_pool, mn, mn_dma);
 991
 992 done_free_fw_buf:
 993         dma_free_coherent(&ha->pdev->dev, data_len, fw_buf, fw_dma);
 994
 995 done_unmap_sg:
 996         dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
 997                 bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
 998
 999         return rval;
1000 }
1001
1002 static int
1003 qla84xx_mgmt_cmd(struct fc_bsg_job *bsg_job)
1004 {
1005         struct Scsi_Host *host = bsg_job->shost;
1006         scsi_qla_host_t *vha = shost_priv(host);
1007         struct qla_hw_data *ha = vha->hw;
1008         struct access_chip_84xx *mn = NULL;
1009         dma_addr_t mn_dma, mgmt_dma;
1010         void *mgmt_b = NULL;
1011         int rval = 0;
1012         struct qla_bsg_a84_mgmt *ql84_mgmt;
1013         uint32_t sg_cnt;
1014         uint32_t data_len = 0;
1015         uint32_t dma_direction = DMA_NONE;
1016
1017         if (!IS_QLA84XX(ha)) {
1018                 ql_log(ql_log_warn, vha, 0x703a,
1019                     "Not 84xx, exiting.\n");
1020                 return -EINVAL;
1021         }
1022
1023         ql84_mgmt = (struct qla_bsg_a84_mgmt *)((char *)bsg_job->request +
1024                 sizeof(struct fc_bsg_request));
1025         if (!ql84_mgmt) {
1026                 ql_log(ql_log_warn, vha, 0x703b,
1027                     "MGMT header not provided, exiting.\n");
1028                 return -EINVAL;
1029         }
1030
1031         mn = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &mn_dma);
1032         if (!mn) {
1033                 ql_log(ql_log_warn, vha, 0x703c,
1034                     "DMA alloc failed for fw buffer.\n");
1035                 return -ENOMEM;
1036         }
1037
1038         memset(mn, 0, sizeof(struct access_chip_84xx));
1039         mn->entry_type = ACCESS_CHIP_IOCB_TYPE;
1040         mn->entry_count = 1;
1041
1042         switch (ql84_mgmt->mgmt.cmd) {
1043         case QLA84_MGMT_READ_MEM:
1044         case QLA84_MGMT_GET_INFO:
1045                 sg_cnt = dma_map_sg(&ha->pdev->dev,
1046                         bsg_job->reply_payload.sg_list,
1047                         bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
1048                 if (!sg_cnt) {
1049                         ql_log(ql_log_warn, vha, 0x703d,
1050                             "dma_map_sg returned %d for reply.\n", sg_cnt);
1051                         rval = -ENOMEM;
1052                         goto exit_mgmt;
1053                 }
1054
1055                 dma_direction = DMA_FROM_DEVICE;
1056
1057                 if (sg_cnt != bsg_job->reply_payload.sg_cnt) {
1058                         ql_log(ql_log_warn, vha, 0x703e,
1059                             "DMA mapping resulted in different sg counts, "
1060                             "reply_sg_cnt: %x dma_reply_sg_cnt: %x.\n",
1061                             bsg_job->reply_payload.sg_cnt, sg_cnt);
1062                         rval = -EAGAIN;
1063                         goto done_unmap_sg;
1064                 }
1065
1066                 data_len = bsg_job->reply_payload.payload_len;
1067
1068                 mgmt_b = dma_alloc_coherent(&ha->pdev->dev, data_len,
1069                     &mgmt_dma, GFP_KERNEL);
1070                 if (!mgmt_b) {
1071                         ql_log(ql_log_warn, vha, 0x703f,
1072                             "DMA alloc failed for mgmt_b.\n");
1073                         rval = -ENOMEM;
1074                         goto done_unmap_sg;
1075                 }
1076
1077                 if (ql84_mgmt->mgmt.cmd == QLA84_MGMT_READ_MEM) {
1078                         mn->options = cpu_to_le16(ACO_DUMP_MEMORY);
1079                         mn->parameter1 =
1080                                 cpu_to_le32(
1081                                 ql84_mgmt->mgmt.mgmtp.u.mem.start_addr);
1082
1083                 } else if (ql84_mgmt->mgmt.cmd == QLA84_MGMT_GET_INFO) {
1084                         mn->options = cpu_to_le16(ACO_REQUEST_INFO);
1085                         mn->parameter1 =
1086                                 cpu_to_le32(ql84_mgmt->mgmt.mgmtp.u.info.type);
1087
1088                         mn->parameter2 =
1089                                 cpu_to_le32(
1090                                 ql84_mgmt->mgmt.mgmtp.u.info.context);
1091                 }
1092                 break;
1093
1094         case QLA84_MGMT_WRITE_MEM:
1095                 sg_cnt = dma_map_sg(&ha->pdev->dev,
1096                         bsg_job->request_payload.sg_list,
1097                         bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
1098
1099                 if (!sg_cnt) {
1100                         ql_log(ql_log_warn, vha, 0x7040,
1101                             "dma_map_sg returned %d.\n", sg_cnt);
1102                         rval = -ENOMEM;
1103                         goto exit_mgmt;
1104                 }
1105
1106                 dma_direction = DMA_TO_DEVICE;
1107
1108                 if (sg_cnt != bsg_job->request_payload.sg_cnt) {
1109                         ql_log(ql_log_warn, vha, 0x7041,
1110                             "DMA mapping resulted in different sg counts, "
1111                             "request_sg_cnt: %x dma_request_sg_cnt: %x.\n",
1112                             bsg_job->request_payload.sg_cnt, sg_cnt);
1113                         rval = -EAGAIN;
1114                         goto done_unmap_sg;
1115                 }
1116
1117                 data_len = bsg_job->request_payload.payload_len;
1118                 mgmt_b = dma_alloc_coherent(&ha->pdev->dev, data_len,
1119                         &mgmt_dma, GFP_KERNEL);
1120                 if (!mgmt_b) {
1121                         ql_log(ql_log_warn, vha, 0x7042,
1122                             "DMA alloc failed for mgmt_b.\n");
1123                         rval = -ENOMEM;
1124                         goto done_unmap_sg;
1125                 }
1126
1127                 sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1128                         bsg_job->request_payload.sg_cnt, mgmt_b, data_len);
1129
1130                 mn->options = cpu_to_le16(ACO_LOAD_MEMORY);
1131                 mn->parameter1 =
1132                         cpu_to_le32(ql84_mgmt->mgmt.mgmtp.u.mem.start_addr);
1133                 break;
1134
1135         case QLA84_MGMT_CHNG_CONFIG:
1136                 mn->options = cpu_to_le16(ACO_CHANGE_CONFIG_PARAM);
1137                 mn->parameter1 =
1138                         cpu_to_le32(ql84_mgmt->mgmt.mgmtp.u.config.id);
1139
1140                 mn->parameter2 =
1141                         cpu_to_le32(ql84_mgmt->mgmt.mgmtp.u.config.param0);
1142
1143                 mn->parameter3 =
1144                         cpu_to_le32(ql84_mgmt->mgmt.mgmtp.u.config.param1);
1145                 break;
1146
1147         default:
1148                 rval = -EIO;
1149                 goto exit_mgmt;
1150         }
1151
1152         if (ql84_mgmt->mgmt.cmd != QLA84_MGMT_CHNG_CONFIG) {
1153                 mn->total_byte_cnt = cpu_to_le32(ql84_mgmt->mgmt.len);
1154                 mn->dseg_count = cpu_to_le16(1);
1155                 mn->dseg_address[0] = cpu_to_le32(LSD(mgmt_dma));
1156                 mn->dseg_address[1] = cpu_to_le32(MSD(mgmt_dma));
1157                 mn->dseg_length = cpu_to_le32(ql84_mgmt->mgmt.len);
1158         }
1159
1160         rval = qla2x00_issue_iocb(vha, mn, mn_dma, 0);
1161
1162         if (rval) {
1163                 ql_log(ql_log_warn, vha, 0x7043,
1164                     "Vendor request 84xx mgmt failed.\n");
1165
1166                 rval = 0;
1167                 bsg_job->reply->result = (DID_ERROR << 16);
1168
1169         } else {
1170                 ql_dbg(ql_dbg_user, vha, 0x7044,
1171                     "Vendor request 84xx mgmt completed.\n");
1172
1173                 bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1174                 bsg_job->reply->result = DID_OK;
1175
1176                 if ((ql84_mgmt->mgmt.cmd == QLA84_MGMT_READ_MEM) ||
1177                         (ql84_mgmt->mgmt.cmd == QLA84_MGMT_GET_INFO)) {
1178                         bsg_job->reply->reply_payload_rcv_len =
1179                                 bsg_job->reply_payload.payload_len;
1180
1181                         sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
1182                                 bsg_job->reply_payload.sg_cnt, mgmt_b,
1183                                 data_len);
1184                 }
1185         }
1186
1187         bsg_job->job_done(bsg_job);
1188
1189 done_unmap_sg:
1190         if (mgmt_b)
1191                 dma_free_coherent(&ha->pdev->dev, data_len, mgmt_b, mgmt_dma);
1192
1193         if (dma_direction == DMA_TO_DEVICE)
1194                 dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
1195                         bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
1196         else if (dma_direction == DMA_FROM_DEVICE)
1197                 dma_unmap_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
1198                         bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
1199
1200 exit_mgmt:
1201         dma_pool_free(ha->s_dma_pool, mn, mn_dma);
1202
1203         return rval;
1204 }
1205
1206 static int
1207 qla24xx_iidma(struct fc_bsg_job *bsg_job)
1208 {
1209         struct Scsi_Host *host = bsg_job->shost;
1210         scsi_qla_host_t *vha = shost_priv(host);
1211         int rval = 0;
1212         struct qla_port_param *port_param = NULL;
1213         fc_port_t *fcport = NULL;
1214         uint16_t mb[MAILBOX_REGISTER_COUNT];
1215         uint8_t *rsp_ptr = NULL;
1216
1217         if (!IS_IIDMA_CAPABLE(vha->hw)) {
1218                 ql_log(ql_log_info, vha, 0x7046, "iiDMA not supported.\n");
1219                 return -EINVAL;
1220         }
1221
1222         port_param = (struct qla_port_param *)((char *)bsg_job->request +
1223                 sizeof(struct fc_bsg_request));
1224         if (!port_param) {
1225                 ql_log(ql_log_warn, vha, 0x7047,
1226                     "port_param header not provided.\n");
1227                 return -EINVAL;
1228         }
1229
1230         if (port_param->fc_scsi_addr.dest_type != EXT_DEF_TYPE_WWPN) {
1231                 ql_log(ql_log_warn, vha, 0x7048,
1232                     "Invalid destination type.\n");
1233                 return -EINVAL;
1234         }
1235
1236         list_for_each_entry(fcport, &vha->vp_fcports, list) {
1237                 if (fcport->port_type != FCT_TARGET)
1238                         continue;
1239
1240                 if (memcmp(port_param->fc_scsi_addr.dest_addr.wwpn,
1241                         fcport->port_name, sizeof(fcport->port_name)))
1242                         continue;
1243                 break;
1244         }
1245
1246         if (!fcport) {
1247                 ql_log(ql_log_warn, vha, 0x7049,
1248                     "Failed to find port.\n");
1249                 return -EINVAL;
1250         }
1251
1252         if (atomic_read(&fcport->state) != FCS_ONLINE) {
1253                 ql_log(ql_log_warn, vha, 0x704a,
1254                     "Port is not online.\n");
1255                 return -EINVAL;
1256         }
1257
1258         if (fcport->flags & FCF_LOGIN_NEEDED) {
1259                 ql_log(ql_log_warn, vha, 0x704b,
1260                     "Remote port not logged in flags = 0x%x.\n", fcport->flags);
1261                 return -EINVAL;
1262         }
1263
1264         if (port_param->mode)
1265                 rval = qla2x00_set_idma_speed(vha, fcport->loop_id,
1266                         port_param->speed, mb);
1267         else
1268                 rval = qla2x00_get_idma_speed(vha, fcport->loop_id,
1269                         &port_param->speed, mb);
1270
1271         if (rval) {
1272                 ql_log(ql_log_warn, vha, 0x704c,
1273                     "iIDMA cmd failed for %02x%02x%02x%02x%02x%02x%02x%02x -- "
1274                     "%04x %x %04x %04x.\n", fcport->port_name[0],
1275                     fcport->port_name[1], fcport->port_name[2],
1276                     fcport->port_name[3], fcport->port_name[4],
1277                     fcport->port_name[5], fcport->port_name[6],
1278                     fcport->port_name[7], rval, fcport->fp_speed, mb[0], mb[1]);
1279                 rval = 0;
1280                 bsg_job->reply->result = (DID_ERROR << 16);
1281
1282         } else {
1283                 if (!port_param->mode) {
1284                         bsg_job->reply_len = sizeof(struct fc_bsg_reply) +
1285                                 sizeof(struct qla_port_param);
1286
1287                         rsp_ptr = ((uint8_t *)bsg_job->reply) +
1288                                 sizeof(struct fc_bsg_reply);
1289
1290                         memcpy(rsp_ptr, port_param,
1291                                 sizeof(struct qla_port_param));
1292                 }
1293
1294                 bsg_job->reply->result = DID_OK;
1295         }
1296
1297         bsg_job->job_done(bsg_job);
1298         return rval;
1299 }
1300
1301 static int
1302 qla2x00_optrom_setup(struct fc_bsg_job *bsg_job, scsi_qla_host_t *vha,
1303         uint8_t is_update)
1304 {
1305         uint32_t start = 0;
1306         int valid = 0;
1307         struct qla_hw_data *ha = vha->hw;
1308
1309         if (unlikely(pci_channel_offline(ha->pdev)))
1310                 return -EINVAL;
1311
1312         start = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
1313         if (start > ha->optrom_size) {
1314                 ql_log(ql_log_warn, vha, 0x7055,
1315                     "start %d > optrom_size %d.\n", start, ha->optrom_size);
1316                 return -EINVAL;
1317         }
1318
1319         if (ha->optrom_state != QLA_SWAITING) {
1320                 ql_log(ql_log_info, vha, 0x7056,
1321                     "optrom_state %d.\n", ha->optrom_state);
1322                 return -EBUSY;
1323         }
1324
1325         ha->optrom_region_start = start;
1326         ql_dbg(ql_dbg_user, vha, 0x7057, "is_update=%d.\n", is_update);
1327         if (is_update) {
1328                 if (ha->optrom_size == OPTROM_SIZE_2300 && start == 0)
1329                         valid = 1;
1330                 else if (start == (ha->flt_region_boot * 4) ||
1331                     start == (ha->flt_region_fw * 4))
1332                         valid = 1;
1333                 else if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha) ||
1334                     IS_CNA_CAPABLE(ha) || IS_QLA2031(ha))
1335                         valid = 1;
1336                 if (!valid) {
1337                         ql_log(ql_log_warn, vha, 0x7058,
1338                             "Invalid start region 0x%x/0x%x.\n", start,
1339                             bsg_job->request_payload.payload_len);
1340                         return -EINVAL;
1341                 }
1342
1343                 ha->optrom_region_size = start +
1344                     bsg_job->request_payload.payload_len > ha->optrom_size ?
1345                     ha->optrom_size - start :
1346                     bsg_job->request_payload.payload_len;
1347                 ha->optrom_state = QLA_SWRITING;
1348         } else {
1349                 ha->optrom_region_size = start +
1350                     bsg_job->reply_payload.payload_len > ha->optrom_size ?
1351                     ha->optrom_size - start :
1352                     bsg_job->reply_payload.payload_len;
1353                 ha->optrom_state = QLA_SREADING;
1354         }
1355
1356         ha->optrom_buffer = vmalloc(ha->optrom_region_size);
1357         if (!ha->optrom_buffer) {
1358                 ql_log(ql_log_warn, vha, 0x7059,
1359                     "Read: Unable to allocate memory for optrom retrieval "
1360                     "(%x)\n", ha->optrom_region_size);
1361
1362                 ha->optrom_state = QLA_SWAITING;
1363                 return -ENOMEM;
1364         }
1365
1366         memset(ha->optrom_buffer, 0, ha->optrom_region_size);
1367         return 0;
1368 }
1369
1370 static int
1371 qla2x00_read_optrom(struct fc_bsg_job *bsg_job)
1372 {
1373         struct Scsi_Host *host = bsg_job->shost;
1374         scsi_qla_host_t *vha = shost_priv(host);
1375         struct qla_hw_data *ha = vha->hw;
1376         int rval = 0;
1377
1378         if (ha->flags.nic_core_reset_hdlr_active)
1379                 return -EBUSY;
1380
1381         rval = qla2x00_optrom_setup(bsg_job, vha, 0);
1382         if (rval)
1383                 return rval;
1384
1385         ha->isp_ops->read_optrom(vha, ha->optrom_buffer,
1386             ha->optrom_region_start, ha->optrom_region_size);
1387
1388         sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
1389             bsg_job->reply_payload.sg_cnt, ha->optrom_buffer,
1390             ha->optrom_region_size);
1391
1392         bsg_job->reply->reply_payload_rcv_len = ha->optrom_region_size;
1393         bsg_job->reply->result = DID_OK;
1394         vfree(ha->optrom_buffer);
1395         ha->optrom_buffer = NULL;
1396         ha->optrom_state = QLA_SWAITING;
1397         bsg_job->job_done(bsg_job);
1398         return rval;
1399 }
1400
1401 static int
1402 qla2x00_update_optrom(struct fc_bsg_job *bsg_job)
1403 {
1404         struct Scsi_Host *host = bsg_job->shost;
1405         scsi_qla_host_t *vha = shost_priv(host);
1406         struct qla_hw_data *ha = vha->hw;
1407         int rval = 0;
1408
1409         rval = qla2x00_optrom_setup(bsg_job, vha, 1);
1410         if (rval)
1411                 return rval;
1412
1413         /* Set the isp82xx_no_md_cap not to capture minidump */
1414         ha->flags.isp82xx_no_md_cap = 1;
1415
1416         sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1417             bsg_job->request_payload.sg_cnt, ha->optrom_buffer,
1418             ha->optrom_region_size);
1419
1420         ha->isp_ops->write_optrom(vha, ha->optrom_buffer,
1421             ha->optrom_region_start, ha->optrom_region_size);
1422
1423         bsg_job->reply->result = DID_OK;
1424         vfree(ha->optrom_buffer);
1425         ha->optrom_buffer = NULL;
1426         ha->optrom_state = QLA_SWAITING;
1427         bsg_job->job_done(bsg_job);
1428         return rval;
1429 }
1430
1431 static int
1432 qla2x00_update_fru_versions(struct fc_bsg_job *bsg_job)
1433 {
1434         struct Scsi_Host *host = bsg_job->shost;
1435         scsi_qla_host_t *vha = shost_priv(host);
1436         struct qla_hw_data *ha = vha->hw;
1437         int rval = 0;
1438         uint8_t bsg[DMA_POOL_SIZE];
1439         struct qla_image_version_list *list = (void *)bsg;
1440         struct qla_image_version *image;
1441         uint32_t count;
1442         dma_addr_t sfp_dma;
1443         void *sfp = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &sfp_dma);
1444         if (!sfp) {
1445                 bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1446                     EXT_STATUS_NO_MEMORY;
1447                 goto done;
1448         }
1449
1450         sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1451             bsg_job->request_payload.sg_cnt, list, sizeof(bsg));
1452
1453         image = list->version;
1454         count = list->count;
1455         while (count--) {
1456                 memcpy(sfp, &image->field_info, sizeof(image->field_info));
1457                 rval = qla2x00_write_sfp(vha, sfp_dma, sfp,
1458                     image->field_address.device, image->field_address.offset,
1459                     sizeof(image->field_info), image->field_address.option);
1460                 if (rval) {
1461                         bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1462                             EXT_STATUS_MAILBOX;
1463                         goto dealloc;
1464                 }
1465                 image++;
1466         }
1467
1468         bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] = 0;
1469
1470 dealloc:
1471         dma_pool_free(ha->s_dma_pool, sfp, sfp_dma);
1472
1473 done:
1474         bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1475         bsg_job->reply->result = DID_OK << 16;
1476         bsg_job->job_done(bsg_job);
1477
1478         return 0;
1479 }
1480
1481 static int
1482 qla2x00_read_fru_status(struct fc_bsg_job *bsg_job)
1483 {
1484         struct Scsi_Host *host = bsg_job->shost;
1485         scsi_qla_host_t *vha = shost_priv(host);
1486         struct qla_hw_data *ha = vha->hw;
1487         int rval = 0;
1488         uint8_t bsg[DMA_POOL_SIZE];
1489         struct qla_status_reg *sr = (void *)bsg;
1490         dma_addr_t sfp_dma;
1491         uint8_t *sfp = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &sfp_dma);
1492         if (!sfp) {
1493                 bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1494                     EXT_STATUS_NO_MEMORY;
1495                 goto done;
1496         }
1497
1498         sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1499             bsg_job->request_payload.sg_cnt, sr, sizeof(*sr));
1500
1501         rval = qla2x00_read_sfp(vha, sfp_dma, sfp,
1502             sr->field_address.device, sr->field_address.offset,
1503             sizeof(sr->status_reg), sr->field_address.option);
1504         sr->status_reg = *sfp;
1505
1506         if (rval) {
1507                 bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1508                     EXT_STATUS_MAILBOX;
1509                 goto dealloc;
1510         }
1511
1512         sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
1513             bsg_job->reply_payload.sg_cnt, sr, sizeof(*sr));
1514
1515         bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] = 0;
1516
1517 dealloc:
1518         dma_pool_free(ha->s_dma_pool, sfp, sfp_dma);
1519
1520 done:
1521         bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1522         bsg_job->reply->reply_payload_rcv_len = sizeof(*sr);
1523         bsg_job->reply->result = DID_OK << 16;
1524         bsg_job->job_done(bsg_job);
1525
1526         return 0;
1527 }
1528
1529 static int
1530 qla2x00_write_fru_status(struct fc_bsg_job *bsg_job)
1531 {
1532         struct Scsi_Host *host = bsg_job->shost;
1533         scsi_qla_host_t *vha = shost_priv(host);
1534         struct qla_hw_data *ha = vha->hw;
1535         int rval = 0;
1536         uint8_t bsg[DMA_POOL_SIZE];
1537         struct qla_status_reg *sr = (void *)bsg;
1538         dma_addr_t sfp_dma;
1539         uint8_t *sfp = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &sfp_dma);
1540         if (!sfp) {
1541                 bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1542                     EXT_STATUS_NO_MEMORY;
1543                 goto done;
1544         }
1545
1546         sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1547             bsg_job->request_payload.sg_cnt, sr, sizeof(*sr));
1548
1549         *sfp = sr->status_reg;
1550         rval = qla2x00_write_sfp(vha, sfp_dma, sfp,
1551             sr->field_address.device, sr->field_address.offset,
1552             sizeof(sr->status_reg), sr->field_address.option);
1553
1554         if (rval) {
1555                 bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1556                     EXT_STATUS_MAILBOX;
1557                 goto dealloc;
1558         }
1559
1560         bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] = 0;
1561
1562 dealloc:
1563         dma_pool_free(ha->s_dma_pool, sfp, sfp_dma);
1564
1565 done:
1566         bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1567         bsg_job->reply->result = DID_OK << 16;
1568         bsg_job->job_done(bsg_job);
1569
1570         return 0;
1571 }
1572
1573 static int
1574 qla2x00_write_i2c(struct fc_bsg_job *bsg_job)
1575 {
1576         struct Scsi_Host *host = bsg_job->shost;
1577         scsi_qla_host_t *vha = shost_priv(host);
1578         struct qla_hw_data *ha = vha->hw;
1579         int rval = 0;
1580         uint8_t bsg[DMA_POOL_SIZE];
1581         struct qla_i2c_access *i2c = (void *)bsg;
1582         dma_addr_t sfp_dma;
1583         uint8_t *sfp = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &sfp_dma);
1584         if (!sfp) {
1585                 bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1586                     EXT_STATUS_NO_MEMORY;
1587                 goto done;
1588         }
1589
1590         sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1591             bsg_job->request_payload.sg_cnt, i2c, sizeof(*i2c));
1592
1593         memcpy(sfp, i2c->buffer, i2c->length);
1594         rval = qla2x00_write_sfp(vha, sfp_dma, sfp,
1595             i2c->device, i2c->offset, i2c->length, i2c->option);
1596
1597         if (rval) {
1598                 bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1599                     EXT_STATUS_MAILBOX;
1600                 goto dealloc;
1601         }
1602
1603         bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] = 0;
1604
1605 dealloc:
1606         dma_pool_free(ha->s_dma_pool, sfp, sfp_dma);
1607
1608 done:
1609         bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1610         bsg_job->reply->result = DID_OK << 16;
1611         bsg_job->job_done(bsg_job);
1612
1613         return 0;
1614 }
1615
1616 static int
1617 qla2x00_read_i2c(struct fc_bsg_job *bsg_job)
1618 {
1619         struct Scsi_Host *host = bsg_job->shost;
1620         scsi_qla_host_t *vha = shost_priv(host);
1621         struct qla_hw_data *ha = vha->hw;
1622         int rval = 0;
1623         uint8_t bsg[DMA_POOL_SIZE];
1624         struct qla_i2c_access *i2c = (void *)bsg;
1625         dma_addr_t sfp_dma;
1626         uint8_t *sfp = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &sfp_dma);
1627         if (!sfp) {
1628                 bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1629                     EXT_STATUS_NO_MEMORY;
1630                 goto done;
1631         }
1632
1633         sg_copy_to_buffer(bsg_job->request_payload.sg_list,
1634             bsg_job->request_payload.sg_cnt, i2c, sizeof(*i2c));
1635
1636         rval = qla2x00_read_sfp(vha, sfp_dma, sfp,
1637                 i2c->device, i2c->offset, i2c->length, i2c->option);
1638
1639         if (rval) {
1640                 bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] =
1641                     EXT_STATUS_MAILBOX;
1642                 goto dealloc;
1643         }
1644
1645         memcpy(i2c->buffer, sfp, i2c->length);
1646         sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
1647             bsg_job->reply_payload.sg_cnt, i2c, sizeof(*i2c));
1648
1649         bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] = 0;
1650
1651 dealloc:
1652         dma_pool_free(ha->s_dma_pool, sfp, sfp_dma);
1653
1654 done:
1655         bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1656         bsg_job->reply->reply_payload_rcv_len = sizeof(*i2c);
1657         bsg_job->reply->result = DID_OK << 16;
1658         bsg_job->job_done(bsg_job);
1659
1660         return 0;
1661 }
1662
1663 static int
1664 qla24xx_process_bidir_cmd(struct fc_bsg_job *bsg_job)
1665 {
1666         struct Scsi_Host *host = bsg_job->shost;
1667         scsi_qla_host_t *vha = shost_priv(host);
1668         struct qla_hw_data *ha = vha->hw;
1669         uint16_t thread_id;
1670         uint32_t rval = EXT_STATUS_OK;
1671         uint16_t req_sg_cnt = 0;
1672         uint16_t rsp_sg_cnt = 0;
1673         uint16_t nextlid = 0;
1674         uint32_t tot_dsds;
1675         srb_t *sp = NULL;
1676         uint32_t req_data_len = 0;
1677         uint32_t rsp_data_len = 0;
1678
1679         /* Check the type of the adapter */
1680         if (!IS_BIDI_CAPABLE(ha)) {
1681                 ql_log(ql_log_warn, vha, 0x70a0,
1682                         "This adapter is not supported\n");
1683                 rval = EXT_STATUS_NOT_SUPPORTED;
1684                 goto done;
1685         }
1686
1687         if (test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) ||
1688                 test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) ||
1689                 test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
1690                 rval =  EXT_STATUS_BUSY;
1691                 goto done;
1692         }
1693
1694         /* Check if host is online */
1695         if (!vha->flags.online) {
1696                 ql_log(ql_log_warn, vha, 0x70a1,
1697                         "Host is not online\n");
1698                 rval = EXT_STATUS_DEVICE_OFFLINE;
1699                 goto done;
1700         }
1701
1702         /* Check if cable is plugged in or not */
1703         if (vha->device_flags & DFLG_NO_CABLE) {
1704                 ql_log(ql_log_warn, vha, 0x70a2,
1705                         "Cable is unplugged...\n");
1706                 rval = EXT_STATUS_INVALID_CFG;
1707                 goto done;
1708         }
1709
1710         /* Check if the switch is connected or not */
1711         if (ha->current_topology != ISP_CFG_F) {
1712                 ql_log(ql_log_warn, vha, 0x70a3,
1713                         "Host is not connected to the switch\n");
1714                 rval = EXT_STATUS_INVALID_CFG;
1715                 goto done;
1716         }
1717
1718         /* Check if operating mode is P2P */
1719         if (ha->operating_mode != P2P) {
1720                 ql_log(ql_log_warn, vha, 0x70a4,
1721                     "Host is operating mode is not P2p\n");
1722                 rval = EXT_STATUS_INVALID_CFG;
1723                 goto done;
1724         }
1725
1726         thread_id = bsg_job->request->rqst_data.h_vendor.vendor_cmd[1];
1727
1728         mutex_lock(&ha->selflogin_lock);
1729         if (vha->self_login_loop_id == 0) {
1730                 /* Initialize all required  fields of fcport */
1731                 vha->bidir_fcport.vha = vha;
1732                 vha->bidir_fcport.d_id.b.al_pa = vha->d_id.b.al_pa;
1733                 vha->bidir_fcport.d_id.b.area = vha->d_id.b.area;
1734                 vha->bidir_fcport.d_id.b.domain = vha->d_id.b.domain;
1735                 vha->bidir_fcport.loop_id = vha->loop_id;
1736
1737                 if (qla2x00_fabric_login(vha, &(vha->bidir_fcport), &nextlid)) {
1738                         ql_log(ql_log_warn, vha, 0x70a7,
1739                             "Failed to login port %06X for bidirectional IOCB\n",
1740                             vha->bidir_fcport.d_id.b24);
1741                         mutex_unlock(&ha->selflogin_lock);
1742                         rval = EXT_STATUS_MAILBOX;
1743                         goto done;
1744                 }
1745                 vha->self_login_loop_id = nextlid - 1;
1746
1747         }
1748         /* Assign the self login loop id to fcport */
1749         mutex_unlock(&ha->selflogin_lock);
1750
1751         vha->bidir_fcport.loop_id = vha->self_login_loop_id;
1752
1753         req_sg_cnt = dma_map_sg(&ha->pdev->dev,
1754                 bsg_job->request_payload.sg_list,
1755                 bsg_job->request_payload.sg_cnt,
1756                 DMA_TO_DEVICE);
1757
1758         if (!req_sg_cnt) {
1759                 rval = EXT_STATUS_NO_MEMORY;
1760                 goto done;
1761         }
1762
1763         rsp_sg_cnt = dma_map_sg(&ha->pdev->dev,
1764                 bsg_job->reply_payload.sg_list, bsg_job->reply_payload.sg_cnt,
1765                 DMA_FROM_DEVICE);
1766
1767         if (!rsp_sg_cnt) {
1768                 rval = EXT_STATUS_NO_MEMORY;
1769                 goto done_unmap_req_sg;
1770         }
1771
1772         if ((req_sg_cnt !=  bsg_job->request_payload.sg_cnt) ||
1773                 (rsp_sg_cnt != bsg_job->reply_payload.sg_cnt)) {
1774                 ql_dbg(ql_dbg_user, vha, 0x70a9,
1775                     "Dma mapping resulted in different sg counts "
1776                     "[request_sg_cnt: %x dma_request_sg_cnt: %x reply_sg_cnt: "
1777                     "%x dma_reply_sg_cnt: %x]\n",
1778                     bsg_job->request_payload.sg_cnt, req_sg_cnt,
1779                     bsg_job->reply_payload.sg_cnt, rsp_sg_cnt);
1780                 rval = EXT_STATUS_NO_MEMORY;
1781                 goto done_unmap_sg;
1782         }
1783
1784         if (req_data_len != rsp_data_len) {
1785                 rval = EXT_STATUS_BUSY;
1786                 ql_log(ql_log_warn, vha, 0x70aa,
1787                     "req_data_len != rsp_data_len\n");
1788                 goto done_unmap_sg;
1789         }
1790
1791         req_data_len = bsg_job->request_payload.payload_len;
1792         rsp_data_len = bsg_job->reply_payload.payload_len;
1793
1794
1795         /* Alloc SRB structure */
1796         sp = qla2x00_get_sp(vha, &(vha->bidir_fcport), GFP_KERNEL);
1797         if (!sp) {
1798                 ql_dbg(ql_dbg_user, vha, 0x70ac,
1799                     "Alloc SRB structure failed\n");
1800                 rval = EXT_STATUS_NO_MEMORY;
1801                 goto done_unmap_sg;
1802         }
1803
1804         /*Populate srb->ctx with bidir ctx*/
1805         sp->u.bsg_job = bsg_job;
1806         sp->free = qla2x00_bsg_sp_free;
1807         sp->type = SRB_BIDI_CMD;
1808         sp->done = qla2x00_bsg_job_done;
1809
1810         /* Add the read and write sg count */
1811         tot_dsds = rsp_sg_cnt + req_sg_cnt;
1812
1813         rval = qla2x00_start_bidir(sp, vha, tot_dsds);
1814         if (rval != EXT_STATUS_OK)
1815                 goto done_free_srb;
1816         /* the bsg request  will be completed in the interrupt handler */
1817         return rval;
1818
1819 done_free_srb:
1820         mempool_free(sp, ha->srb_mempool);
1821 done_unmap_sg:
1822         dma_unmap_sg(&ha->pdev->dev,
1823             bsg_job->reply_payload.sg_list,
1824             bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
1825 done_unmap_req_sg:
1826         dma_unmap_sg(&ha->pdev->dev,
1827             bsg_job->request_payload.sg_list,
1828             bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
1829 done:
1830
1831         /* Return an error vendor specific response
1832          * and complete the bsg request
1833          */
1834         bsg_job->reply->reply_data.vendor_reply.vendor_rsp[0] = rval;
1835         bsg_job->reply_len = sizeof(struct fc_bsg_reply);
1836         bsg_job->reply->reply_payload_rcv_len = 0;
1837         bsg_job->reply->result = (DID_OK) << 16;
1838         bsg_job->job_done(bsg_job);
1839         /* Always retrun success, vendor rsp carries correct status */
1840         return 0;
1841 }
1842
1843 static int
1844 qla2x00_process_vendor_specific(struct fc_bsg_job *bsg_job)
1845 {
1846         switch (bsg_job->request->rqst_data.h_vendor.vendor_cmd[0]) {
1847         case QL_VND_LOOPBACK:
1848                 return qla2x00_process_loopback(bsg_job);
1849
1850         case QL_VND_A84_RESET:
1851                 return qla84xx_reset(bsg_job);
1852
1853         case QL_VND_A84_UPDATE_FW:
1854                 return qla84xx_updatefw(bsg_job);
1855
1856         case QL_VND_A84_MGMT_CMD:
1857                 return qla84xx_mgmt_cmd(bsg_job);
1858
1859         case QL_VND_IIDMA:
1860                 return qla24xx_iidma(bsg_job);
1861
1862         case QL_VND_FCP_PRIO_CFG_CMD:
1863                 return qla24xx_proc_fcp_prio_cfg_cmd(bsg_job);
1864
1865         case QL_VND_READ_FLASH:
1866                 return qla2x00_read_optrom(bsg_job);
1867
1868         case QL_VND_UPDATE_FLASH:
1869                 return qla2x00_update_optrom(bsg_job);
1870
1871         case QL_VND_SET_FRU_VERSION:
1872                 return qla2x00_update_fru_versions(bsg_job);
1873
1874         case QL_VND_READ_FRU_STATUS:
1875                 return qla2x00_read_fru_status(bsg_job);
1876
1877         case QL_VND_WRITE_FRU_STATUS:
1878                 return qla2x00_write_fru_status(bsg_job);
1879
1880         case QL_VND_WRITE_I2C:
1881                 return qla2x00_write_i2c(bsg_job);
1882
1883         case QL_VND_READ_I2C:
1884                 return qla2x00_read_i2c(bsg_job);
1885
1886         case QL_VND_DIAG_IO_CMD:
1887                 return qla24xx_process_bidir_cmd(bsg_job);
1888
1889         default:
1890                 bsg_job->reply->result = (DID_ERROR << 16);
1891                 bsg_job->job_done(bsg_job);
1892                 return -ENOSYS;
1893         }
1894 }
1895
1896 int
1897 qla24xx_bsg_request(struct fc_bsg_job *bsg_job)
1898 {
1899         int ret = -EINVAL;
1900         struct fc_rport *rport;
1901         fc_port_t *fcport = NULL;
1902         struct Scsi_Host *host;
1903         scsi_qla_host_t *vha;
1904
1905         /* In case no data transferred. */
1906         bsg_job->reply->reply_payload_rcv_len = 0;
1907
1908         if (bsg_job->request->msgcode == FC_BSG_RPT_ELS) {
1909                 rport = bsg_job->rport;
1910                 fcport = *(fc_port_t **) rport->dd_data;
1911                 host = rport_to_shost(rport);
1912                 vha = shost_priv(host);
1913         } else {
1914                 host = bsg_job->shost;
1915                 vha = shost_priv(host);
1916         }
1917
1918         if (qla2x00_reset_active(vha)) {
1919                 ql_dbg(ql_dbg_user, vha, 0x709f,
1920                     "BSG: ISP abort active/needed -- cmd=%d.\n",
1921                     bsg_job->request->msgcode);
1922                 bsg_job->reply->result = (DID_ERROR << 16);
1923                 bsg_job->job_done(bsg_job);
1924                 return -EBUSY;
1925         }
1926
1927         ql_dbg(ql_dbg_user, vha, 0x7000,
1928             "Entered %s msgcode=0x%x.\n", __func__, bsg_job->request->msgcode);
1929
1930         switch (bsg_job->request->msgcode) {
1931         case FC_BSG_RPT_ELS:
1932         case FC_BSG_HST_ELS_NOLOGIN:
1933                 ret = qla2x00_process_els(bsg_job);
1934                 break;
1935         case FC_BSG_HST_CT:
1936                 ret = qla2x00_process_ct(bsg_job);
1937                 break;
1938         case FC_BSG_HST_VENDOR:
1939                 ret = qla2x00_process_vendor_specific(bsg_job);
1940                 break;
1941         case FC_BSG_HST_ADD_RPORT:
1942         case FC_BSG_HST_DEL_RPORT:
1943         case FC_BSG_RPT_CT:
1944         default:
1945                 ql_log(ql_log_warn, vha, 0x705a, "Unsupported BSG request.\n");
1946                 bsg_job->reply->result = ret;
1947                 break;
1948         }
1949         return ret;
1950 }
1951
1952 int
1953 qla24xx_bsg_timeout(struct fc_bsg_job *bsg_job)
1954 {
1955         scsi_qla_host_t *vha = shost_priv(bsg_job->shost);
1956         struct qla_hw_data *ha = vha->hw;
1957         srb_t *sp;
1958         int cnt, que;
1959         unsigned long flags;
1960         struct req_que *req;
1961
1962         /* find the bsg job from the active list of commands */
1963         spin_lock_irqsave(&ha->hardware_lock, flags);
1964         for (que = 0; que < ha->max_req_queues; que++) {
1965                 req = ha->req_q_map[que];
1966                 if (!req)
1967                         continue;
1968
1969                 for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
1970                         sp = req->outstanding_cmds[cnt];
1971                         if (sp) {
1972                                 if (((sp->type == SRB_CT_CMD) ||
1973                                         (sp->type == SRB_ELS_CMD_HST))
1974                                         && (sp->u.bsg_job == bsg_job)) {
1975                                         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1976                                         if (ha->isp_ops->abort_command(sp)) {
1977                                                 ql_log(ql_log_warn, vha, 0x7089,
1978                                                     "mbx abort_command "
1979                                                     "failed.\n");
1980                                                 bsg_job->req->errors =
1981                                                 bsg_job->reply->result = -EIO;
1982                                         } else {
1983                                                 ql_dbg(ql_dbg_user, vha, 0x708a,
1984                                                     "mbx abort_command "
1985                                                     "success.\n");
1986                                                 bsg_job->req->errors =
1987                                                 bsg_job->reply->result = 0;
1988                                         }
1989                                         spin_lock_irqsave(&ha->hardware_lock, flags);
1990                                         goto done;
1991                                 }
1992                         }
1993                 }
1994         }
1995         spin_unlock_irqrestore(&ha->hardware_lock, flags);
1996         ql_log(ql_log_info, vha, 0x708b, "SRB not found to abort.\n");
1997         bsg_job->req->errors = bsg_job->reply->result = -ENXIO;
1998         return 0;
1999
2000 done:
2001         spin_unlock_irqrestore(&ha->hardware_lock, flags);
2002         if (bsg_job->request->msgcode == FC_BSG_HST_CT)
2003                 kfree(sp->fcport);
2004         mempool_free(sp, ha->srb_mempool);
2005         return 0;
2006 }