drivers/scsi/qla2xxx/qla_gs.c

   1 /*
   2  * QLogic Fibre Channel HBA Driver
   3  * Copyright (c)  2003-2014 QLogic Corporation
   4  *
   5  * See LICENSE.qla2xxx for copyright and licensing details.
   6  */
   7 #include "qla_def.h"
   8 #include "qla_target.h"
   9 #include <linux/utsname.h>
  10
  11 static int qla2x00_sns_ga_nxt(scsi_qla_host_t *, fc_port_t *);
  12 static int qla2x00_sns_gid_pt(scsi_qla_host_t *, sw_info_t *);
  13 static int qla2x00_sns_gpn_id(scsi_qla_host_t *, sw_info_t *);
  14 static int qla2x00_sns_gnn_id(scsi_qla_host_t *, sw_info_t *);
  15 static int qla2x00_sns_rft_id(scsi_qla_host_t *);
  16 static int qla2x00_sns_rnn_id(scsi_qla_host_t *);
  17 static int qla_async_rftid(scsi_qla_host_t *, port_id_t *);
  18 static int qla_async_rffid(scsi_qla_host_t *, port_id_t *, u8, u8);
  19 static int qla_async_rnnid(scsi_qla_host_t *, port_id_t *, u8*);
  20 static int qla_async_rsnn_nn(scsi_qla_host_t *);
  21
  22 /**
  23  * qla2x00_prep_ms_iocb() - Prepare common MS/CT IOCB fields for SNS CT query.
  24  * @vha: HA context
  25  * @arg: CT arguments
  26  *
  27  * Returns a pointer to the @vha's ms_iocb.
  28  */
  29 void *
  30 qla2x00_prep_ms_iocb(scsi_qla_host_t *vha, struct ct_arg *arg)
  31 {
  32         struct qla_hw_data *ha = vha->hw;
  33         ms_iocb_entry_t *ms_pkt;
  34
  35         ms_pkt = (ms_iocb_entry_t *)arg->iocb;
  36         memset(ms_pkt, 0, sizeof(ms_iocb_entry_t));
  37
  38         ms_pkt->entry_type = MS_IOCB_TYPE;
  39         ms_pkt->entry_count = 1;
  40         SET_TARGET_ID(ha, ms_pkt->loop_id, SIMPLE_NAME_SERVER);
  41         ms_pkt->control_flags = cpu_to_le16(CF_READ | CF_HEAD_TAG);
  42         ms_pkt->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
  43         ms_pkt->cmd_dsd_count = cpu_to_le16(1);
  44         ms_pkt->total_dsd_count = cpu_to_le16(2);
  45         ms_pkt->rsp_bytecount = cpu_to_le32(arg->rsp_size);
  46         ms_pkt->req_bytecount = cpu_to_le32(arg->req_size);
  47
  48         put_unaligned_le64(arg->req_dma, &ms_pkt->req_dsd.address);
  49         ms_pkt->req_dsd.length = ms_pkt->req_bytecount;
  50
  51         put_unaligned_le64(arg->rsp_dma, &ms_pkt->rsp_dsd.address);
  52         ms_pkt->rsp_dsd.length = ms_pkt->rsp_bytecount;
  53
  54         vha->qla_stats.control_requests++;
  55
  56         return (ms_pkt);
  57 }
  58
  59 /**
  60  * qla24xx_prep_ms_iocb() - Prepare common CT IOCB fields for SNS CT query.
  61  * @vha: HA context
  62  * @arg: CT arguments
  63  *
  64  * Returns a pointer to the @ha's ms_iocb.
  65  */
  66 void *
  67 qla24xx_prep_ms_iocb(scsi_qla_host_t *vha, struct ct_arg *arg)
  68 {
  69         struct qla_hw_data *ha = vha->hw;
  70         struct ct_entry_24xx *ct_pkt;
  71
  72         ct_pkt = (struct ct_entry_24xx *)arg->iocb;
  73         memset(ct_pkt, 0, sizeof(struct ct_entry_24xx));
  74
  75         ct_pkt->entry_type = CT_IOCB_TYPE;
  76         ct_pkt->entry_count = 1;
  77         ct_pkt->nport_handle = cpu_to_le16(arg->nport_handle);
  78         ct_pkt->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
  79         ct_pkt->cmd_dsd_count = cpu_to_le16(1);
  80         ct_pkt->rsp_dsd_count = cpu_to_le16(1);
  81         ct_pkt->rsp_byte_count = cpu_to_le32(arg->rsp_size);
  82         ct_pkt->cmd_byte_count = cpu_to_le32(arg->req_size);
  83
  84         put_unaligned_le64(arg->req_dma, &ct_pkt->dsd[0].address);
  85         ct_pkt->dsd[0].length = ct_pkt->cmd_byte_count;
  86
  87         put_unaligned_le64(arg->rsp_dma, &ct_pkt->dsd[1].address);
  88         ct_pkt->dsd[1].length = ct_pkt->rsp_byte_count;
  89         ct_pkt->vp_index = vha->vp_idx;
  90
  91         vha->qla_stats.control_requests++;
  92
  93         return (ct_pkt);
  94 }
  95
  96 /**
  97  * qla2x00_prep_ct_req() - Prepare common CT request fields for SNS query.
  98  * @p: CT request buffer
  99  * @cmd: GS command
 100  * @rsp_size: response size in bytes
 101  *
 102  * Returns a pointer to the intitialized @ct_req.
 103  */
 104 static inline struct ct_sns_req *
 105 qla2x00_prep_ct_req(struct ct_sns_pkt *p, uint16_t cmd, uint16_t rsp_size)
 106 {
 107         memset(p, 0, sizeof(struct ct_sns_pkt));
 108
 109         p->p.req.header.revision = 0x01;
 110         p->p.req.header.gs_type = 0xFC;
 111         p->p.req.header.gs_subtype = 0x02;
 112         p->p.req.command = cpu_to_be16(cmd);
 113         p->p.req.max_rsp_size = cpu_to_be16((rsp_size - 16) / 4);
 114
 115         return &p->p.req;
 116 }
 117
 118 int
 119 qla2x00_chk_ms_status(scsi_qla_host_t *vha, ms_iocb_entry_t *ms_pkt,
 120     struct ct_sns_rsp *ct_rsp, const char *routine)
 121 {
 122         int rval;
 123         uint16_t comp_status;
 124         struct qla_hw_data *ha = vha->hw;
 125         bool lid_is_sns = false;
 126
 127         rval = QLA_FUNCTION_FAILED;
 128         if (ms_pkt->entry_status != 0) {
 129                 ql_dbg(ql_dbg_disc, vha, 0x2031,
 130                     "%s failed, error status (%x) on port_id: %02x%02x%02x.\n",
 131                     routine, ms_pkt->entry_status, vha->d_id.b.domain,
 132                     vha->d_id.b.area, vha->d_id.b.al_pa);
 133         } else {
 134                 if (IS_FWI2_CAPABLE(ha))
 135                         comp_status = le16_to_cpu(
 136                             ((struct ct_entry_24xx *)ms_pkt)->comp_status);
 137                 else
 138                         comp_status = le16_to_cpu(ms_pkt->status);
 139                 switch (comp_status) {
 140                 case CS_COMPLETE:
 141                 case CS_DATA_UNDERRUN:
 142                 case CS_DATA_OVERRUN:           /* Overrun? */
 143                         if (ct_rsp->header.response !=
 144                             cpu_to_be16(CT_ACCEPT_RESPONSE)) {
 145                                 ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x2077,
 146                                     "%s failed rejected request on port_id: %02x%02x%02x Completion status 0x%x, response 0x%x\n",
 147                                     routine, vha->d_id.b.domain,
 148                                     vha->d_id.b.area, vha->d_id.b.al_pa,
 149                                     comp_status, ct_rsp->header.response);
 150                                 ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha,
 151                                     0x2078, ct_rsp,
 152                                     offsetof(typeof(*ct_rsp), rsp));
 153                                 rval = QLA_INVALID_COMMAND;
 154                         } else
 155                                 rval = QLA_SUCCESS;
 156                         break;
 157                 case CS_PORT_LOGGED_OUT:
 158                         if (IS_FWI2_CAPABLE(ha)) {
 159                                 if (le16_to_cpu(ms_pkt->loop_id.extended) ==
 160                                     NPH_SNS)
 161                                         lid_is_sns = true;
 162                         } else {
 163                                 if (le16_to_cpu(ms_pkt->loop_id.extended) ==
 164                                     SIMPLE_NAME_SERVER)
 165                                         lid_is_sns = true;
 166                         }
 167                         if (lid_is_sns) {
 168                                 ql_dbg(ql_dbg_async, vha, 0x502b,
 169                                         "%s failed, Name server has logged out",
 170                                         routine);
 171                                 rval = QLA_NOT_LOGGED_IN;
 172                                 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
 173                                 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
 174                         }
 175                         break;
 176                 case CS_TIMEOUT:
 177                         rval = QLA_FUNCTION_TIMEOUT;
 178                         /* fall through */
 179                 default:
 180                         ql_dbg(ql_dbg_disc, vha, 0x2033,
 181                             "%s failed, completion status (%x) on port_id: "
 182                             "%02x%02x%02x.\n", routine, comp_status,
 183                             vha->d_id.b.domain, vha->d_id.b.area,
 184                             vha->d_id.b.al_pa);
 185                         break;
 186                 }
 187         }
 188         return rval;
 189 }
 190
 191 /**
 192  * qla2x00_ga_nxt() - SNS scan for fabric devices via GA_NXT command.
 193  * @vha: HA context
 194  * @fcport: fcport entry to updated
 195  *
 196  * Returns 0 on success.
 197  */
 198 int
 199 qla2x00_ga_nxt(scsi_qla_host_t *vha, fc_port_t *fcport)
 200 {
 201         int             rval;
 202
 203         ms_iocb_entry_t *ms_pkt;
 204         struct ct_sns_req       *ct_req;
 205         struct ct_sns_rsp       *ct_rsp;
 206         struct qla_hw_data *ha = vha->hw;
 207         struct ct_arg arg;
 208
 209         if (IS_QLA2100(ha) || IS_QLA2200(ha))
 210                 return qla2x00_sns_ga_nxt(vha, fcport);
 211
 212         arg.iocb = ha->ms_iocb;
 213         arg.req_dma = ha->ct_sns_dma;
 214         arg.rsp_dma = ha->ct_sns_dma;
 215         arg.req_size = GA_NXT_REQ_SIZE;
 216         arg.rsp_size = GA_NXT_RSP_SIZE;
 217         arg.nport_handle = NPH_SNS;
 218
 219         /* Issue GA_NXT */
 220         /* Prepare common MS IOCB */
 221         ms_pkt = ha->isp_ops->prep_ms_iocb(vha, &arg);
 222
 223         /* Prepare CT request */
 224         ct_req = qla2x00_prep_ct_req(ha->ct_sns, GA_NXT_CMD,
 225             GA_NXT_RSP_SIZE);
 226         ct_rsp = &ha->ct_sns->p.rsp;
 227
 228         /* Prepare CT arguments -- port_id */
 229         ct_req->req.port_id.port_id = port_id_to_be_id(fcport->d_id);
 230
 231         /* Execute MS IOCB */
 232         rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
 233             sizeof(ms_iocb_entry_t));
 234         if (rval != QLA_SUCCESS) {
 235                 /*EMPTY*/
 236                 ql_dbg(ql_dbg_disc, vha, 0x2062,
 237                     "GA_NXT issue IOCB failed (%d).\n", rval);
 238         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "GA_NXT") !=
 239             QLA_SUCCESS) {
 240                 rval = QLA_FUNCTION_FAILED;
 241         } else {
 242                 /* Populate fc_port_t entry. */
 243                 fcport->d_id = be_to_port_id(ct_rsp->rsp.ga_nxt.port_id);
 244
 245                 memcpy(fcport->node_name, ct_rsp->rsp.ga_nxt.node_name,
 246                     WWN_SIZE);
 247                 memcpy(fcport->port_name, ct_rsp->rsp.ga_nxt.port_name,
 248                     WWN_SIZE);
 249
 250                 fcport->fc4_type = (ct_rsp->rsp.ga_nxt.fc4_types[2] & BIT_0) ?
 251                     FS_FC4TYPE_FCP : FC4_TYPE_OTHER;
 252
 253                 if (ct_rsp->rsp.ga_nxt.port_type != NS_N_PORT_TYPE &&
 254                     ct_rsp->rsp.ga_nxt.port_type != NS_NL_PORT_TYPE)
 255                         fcport->d_id.b.domain = 0xf0;
 256
 257                 ql_dbg(ql_dbg_disc, vha, 0x2063,
 258                     "GA_NXT entry - nn %8phN pn %8phN "
 259                     "port_id=%02x%02x%02x.\n",
 260                     fcport->node_name, fcport->port_name,
 261                     fcport->d_id.b.domain, fcport->d_id.b.area,
 262                     fcport->d_id.b.al_pa);
 263         }
 264
 265         return (rval);
 266 }
 267
 268 static inline int
 269 qla2x00_gid_pt_rsp_size(scsi_qla_host_t *vha)
 270 {
 271         return vha->hw->max_fibre_devices * 4 + 16;
 272 }
 273
 274 /**
 275  * qla2x00_gid_pt() - SNS scan for fabric devices via GID_PT command.
 276  * @vha: HA context
 277  * @list: switch info entries to populate
 278  *
 279  * NOTE: Non-Nx_Ports are not requested.
 280  *
 281  * Returns 0 on success.
 282  */
 283 int
 284 qla2x00_gid_pt(scsi_qla_host_t *vha, sw_info_t *list)
 285 {
 286         int             rval;
 287         uint16_t        i;
 288
 289         ms_iocb_entry_t *ms_pkt;
 290         struct ct_sns_req       *ct_req;
 291         struct ct_sns_rsp       *ct_rsp;
 292
 293         struct ct_sns_gid_pt_data *gid_data;
 294         struct qla_hw_data *ha = vha->hw;
 295         uint16_t gid_pt_rsp_size;
 296         struct ct_arg arg;
 297
 298         if (IS_QLA2100(ha) || IS_QLA2200(ha))
 299                 return qla2x00_sns_gid_pt(vha, list);
 300
 301         gid_data = NULL;
 302         gid_pt_rsp_size = qla2x00_gid_pt_rsp_size(vha);
 303
 304         arg.iocb = ha->ms_iocb;
 305         arg.req_dma = ha->ct_sns_dma;
 306         arg.rsp_dma = ha->ct_sns_dma;
 307         arg.req_size = GID_PT_REQ_SIZE;
 308         arg.rsp_size = gid_pt_rsp_size;
 309         arg.nport_handle = NPH_SNS;
 310
 311         /* Issue GID_PT */
 312         /* Prepare common MS IOCB */
 313         ms_pkt = ha->isp_ops->prep_ms_iocb(vha, &arg);
 314
 315         /* Prepare CT request */
 316         ct_req = qla2x00_prep_ct_req(ha->ct_sns, GID_PT_CMD, gid_pt_rsp_size);
 317         ct_rsp = &ha->ct_sns->p.rsp;
 318
 319         /* Prepare CT arguments -- port_type */
 320         ct_req->req.gid_pt.port_type = NS_NX_PORT_TYPE;
 321
 322         /* Execute MS IOCB */
 323         rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
 324             sizeof(ms_iocb_entry_t));
 325         if (rval != QLA_SUCCESS) {
 326                 /*EMPTY*/
 327                 ql_dbg(ql_dbg_disc, vha, 0x2055,
 328                     "GID_PT issue IOCB failed (%d).\n", rval);
 329         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "GID_PT") !=
 330             QLA_SUCCESS) {
 331                 rval = QLA_FUNCTION_FAILED;
 332         } else {
 333                 /* Set port IDs in switch info list. */
 334                 for (i = 0; i < ha->max_fibre_devices; i++) {
 335                         gid_data = &ct_rsp->rsp.gid_pt.entries[i];
 336                         list[i].d_id = be_to_port_id(gid_data->port_id);
 337                         memset(list[i].fabric_port_name, 0, WWN_SIZE);
 338                         list[i].fp_speed = PORT_SPEED_UNKNOWN;
 339
 340                         /* Last one exit. */
 341                         if (gid_data->control_byte & BIT_7) {
 342                                 list[i].d_id.b.rsvd_1 = gid_data->control_byte;
 343                                 break;
 344                         }
 345                 }
 346
 347                 /*
 348                  * If we've used all available slots, then the switch is
 349                  * reporting back more devices than we can handle with this
 350                  * single call.  Return a failed status, and let GA_NXT handle
 351                  * the overload.
 352                  */
 353                 if (i == ha->max_fibre_devices)
 354                         rval = QLA_FUNCTION_FAILED;
 355         }
 356
 357         return (rval);
 358 }
 359
 360 /**
 361  * qla2x00_gpn_id() - SNS Get Port Name (GPN_ID) query.
 362  * @vha: HA context
 363  * @list: switch info entries to populate
 364  *
 365  * Returns 0 on success.
 366  */
 367 int
 368 qla2x00_gpn_id(scsi_qla_host_t *vha, sw_info_t *list)
 369 {
 370         int             rval = QLA_SUCCESS;
 371         uint16_t        i;
 372
 373         ms_iocb_entry_t *ms_pkt;
 374         struct ct_sns_req       *ct_req;
 375         struct ct_sns_rsp       *ct_rsp;
 376         struct qla_hw_data *ha = vha->hw;
 377         struct ct_arg arg;
 378
 379         if (IS_QLA2100(ha) || IS_QLA2200(ha))
 380                 return qla2x00_sns_gpn_id(vha, list);
 381
 382         arg.iocb = ha->ms_iocb;
 383         arg.req_dma = ha->ct_sns_dma;
 384         arg.rsp_dma = ha->ct_sns_dma;
 385         arg.req_size = GPN_ID_REQ_SIZE;
 386         arg.rsp_size = GPN_ID_RSP_SIZE;
 387         arg.nport_handle = NPH_SNS;
 388
 389         for (i = 0; i < ha->max_fibre_devices; i++) {
 390                 /* Issue GPN_ID */
 391                 /* Prepare common MS IOCB */
 392                 ms_pkt = ha->isp_ops->prep_ms_iocb(vha, &arg);
 393
 394                 /* Prepare CT request */
 395                 ct_req = qla2x00_prep_ct_req(ha->ct_sns, GPN_ID_CMD,
 396                     GPN_ID_RSP_SIZE);
 397                 ct_rsp = &ha->ct_sns->p.rsp;
 398
 399                 /* Prepare CT arguments -- port_id */
 400                 ct_req->req.port_id.port_id = port_id_to_be_id(list[i].d_id);
 401
 402                 /* Execute MS IOCB */
 403                 rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
 404                     sizeof(ms_iocb_entry_t));
 405                 if (rval != QLA_SUCCESS) {
 406                         /*EMPTY*/
 407                         ql_dbg(ql_dbg_disc, vha, 0x2056,
 408                             "GPN_ID issue IOCB failed (%d).\n", rval);
 409                         break;
 410                 } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
 411                     "GPN_ID") != QLA_SUCCESS) {
 412                         rval = QLA_FUNCTION_FAILED;
 413                         break;
 414                 } else {
 415                         /* Save portname */
 416                         memcpy(list[i].port_name,
 417                             ct_rsp->rsp.gpn_id.port_name, WWN_SIZE);
 418                 }
 419
 420                 /* Last device exit. */
 421                 if (list[i].d_id.b.rsvd_1 != 0)
 422                         break;
 423         }
 424
 425         return (rval);
 426 }
 427
 428 /**
 429  * qla2x00_gnn_id() - SNS Get Node Name (GNN_ID) query.
 430  * @vha: HA context
 431  * @list: switch info entries to populate
 432  *
 433  * Returns 0 on success.
 434  */
 435 int
 436 qla2x00_gnn_id(scsi_qla_host_t *vha, sw_info_t *list)
 437 {
 438         int             rval = QLA_SUCCESS;
 439         uint16_t        i;
 440         struct qla_hw_data *ha = vha->hw;
 441         ms_iocb_entry_t *ms_pkt;
 442         struct ct_sns_req       *ct_req;
 443         struct ct_sns_rsp       *ct_rsp;
 444         struct ct_arg arg;
 445
 446         if (IS_QLA2100(ha) || IS_QLA2200(ha))
 447                 return qla2x00_sns_gnn_id(vha, list);
 448
 449         arg.iocb = ha->ms_iocb;
 450         arg.req_dma = ha->ct_sns_dma;
 451         arg.rsp_dma = ha->ct_sns_dma;
 452         arg.req_size = GNN_ID_REQ_SIZE;
 453         arg.rsp_size = GNN_ID_RSP_SIZE;
 454         arg.nport_handle = NPH_SNS;
 455
 456         for (i = 0; i < ha->max_fibre_devices; i++) {
 457                 /* Issue GNN_ID */
 458                 /* Prepare common MS IOCB */
 459                 ms_pkt = ha->isp_ops->prep_ms_iocb(vha, &arg);
 460
 461                 /* Prepare CT request */
 462                 ct_req = qla2x00_prep_ct_req(ha->ct_sns, GNN_ID_CMD,
 463                     GNN_ID_RSP_SIZE);
 464                 ct_rsp = &ha->ct_sns->p.rsp;
 465
 466                 /* Prepare CT arguments -- port_id */
 467                 ct_req->req.port_id.port_id = port_id_to_be_id(list[i].d_id);
 468
 469                 /* Execute MS IOCB */
 470                 rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
 471                     sizeof(ms_iocb_entry_t));
 472                 if (rval != QLA_SUCCESS) {
 473                         /*EMPTY*/
 474                         ql_dbg(ql_dbg_disc, vha, 0x2057,
 475                             "GNN_ID issue IOCB failed (%d).\n", rval);
 476                         break;
 477                 } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
 478                     "GNN_ID") != QLA_SUCCESS) {
 479                         rval = QLA_FUNCTION_FAILED;
 480                         break;
 481                 } else {
 482                         /* Save nodename */
 483                         memcpy(list[i].node_name,
 484                             ct_rsp->rsp.gnn_id.node_name, WWN_SIZE);
 485
 486                         ql_dbg(ql_dbg_disc, vha, 0x2058,
 487                             "GID_PT entry - nn %8phN pn %8phN "
 488                             "portid=%02x%02x%02x.\n",
 489                             list[i].node_name, list[i].port_name,
 490                             list[i].d_id.b.domain, list[i].d_id.b.area,
 491                             list[i].d_id.b.al_pa);
 492                 }
 493
 494                 /* Last device exit. */
 495                 if (list[i].d_id.b.rsvd_1 != 0)
 496                         break;
 497         }
 498
 499         return (rval);
 500 }
 501
 502 static void qla2x00_async_sns_sp_done(srb_t *sp, int rc)
 503 {
 504         struct scsi_qla_host *vha = sp->vha;
 505         struct ct_sns_pkt *ct_sns;
 506         struct qla_work_evt *e;
 507
 508         sp->rc = rc;
 509         if (rc == QLA_SUCCESS) {
 510                 ql_dbg(ql_dbg_disc, vha, 0x204f,
 511                     "Async done-%s exiting normally.\n",
 512                     sp->name);
 513         } else if (rc == QLA_FUNCTION_TIMEOUT) {
 514                 ql_dbg(ql_dbg_disc, vha, 0x204f,
 515                     "Async done-%s timeout\n", sp->name);
 516         } else {
 517                 ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.rsp;
 518                 memset(ct_sns, 0, sizeof(*ct_sns));
 519                 sp->retry_count++;
 520                 if (sp->retry_count > 3)
 521                         goto err;
 522
 523                 ql_dbg(ql_dbg_disc, vha, 0x204f,
 524                     "Async done-%s fail rc %x.  Retry count %d\n",
 525                     sp->name, rc, sp->retry_count);
 526
 527                 e = qla2x00_alloc_work(vha, QLA_EVT_SP_RETRY);
 528                 if (!e)
 529                         goto err2;
 530
 531                 del_timer(&sp->u.iocb_cmd.timer);
 532                 e->u.iosb.sp = sp;
 533                 qla2x00_post_work(vha, e);
 534                 return;
 535         }
 536
 537 err:
 538         e = qla2x00_alloc_work(vha, QLA_EVT_UNMAP);
 539 err2:
 540         if (!e) {
 541                 /* please ignore kernel warning. otherwise, we have mem leak. */
 542                 if (sp->u.iocb_cmd.u.ctarg.req) {
 543                         dma_free_coherent(&vha->hw->pdev->dev,
 544                             sp->u.iocb_cmd.u.ctarg.req_allocated_size,
 545                             sp->u.iocb_cmd.u.ctarg.req,
 546                             sp->u.iocb_cmd.u.ctarg.req_dma);
 547                         sp->u.iocb_cmd.u.ctarg.req = NULL;
 548                 }
 549
 550                 if (sp->u.iocb_cmd.u.ctarg.rsp) {
 551                         dma_free_coherent(&vha->hw->pdev->dev,
 552                             sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
 553                             sp->u.iocb_cmd.u.ctarg.rsp,
 554                             sp->u.iocb_cmd.u.ctarg.rsp_dma);
 555                         sp->u.iocb_cmd.u.ctarg.rsp = NULL;
 556                 }
 557
 558                 sp->free(sp);
 559
 560                 return;
 561         }
 562
 563         e->u.iosb.sp = sp;
 564         qla2x00_post_work(vha, e);
 565 }
 566
 567 /**
 568  * qla2x00_rft_id() - SNS Register FC-4 TYPEs (RFT_ID) supported by the HBA.
 569  * @vha: HA context
 570  *
 571  * Returns 0 on success.
 572  */
 573 int
 574 qla2x00_rft_id(scsi_qla_host_t *vha)
 575 {
 576         struct qla_hw_data *ha = vha->hw;
 577
 578         if (IS_QLA2100(ha) || IS_QLA2200(ha))
 579                 return qla2x00_sns_rft_id(vha);
 580
 581         return qla_async_rftid(vha, &vha->d_id);
 582 }
 583
 584 static int qla_async_rftid(scsi_qla_host_t *vha, port_id_t *d_id)
 585 {
 586         int rval = QLA_MEMORY_ALLOC_FAILED;
 587         struct ct_sns_req *ct_req;
 588         srb_t *sp;
 589         struct ct_sns_pkt *ct_sns;
 590
 591         if (!vha->flags.online)
 592                 goto done;
 593
 594         sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
 595         if (!sp)
 596                 goto done;
 597
 598         sp->type = SRB_CT_PTHRU_CMD;
 599         sp->name = "rft_id";
 600         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
 601
 602         sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
 603             sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.req_dma,
 604             GFP_KERNEL);
 605         sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
 606         if (!sp->u.iocb_cmd.u.ctarg.req) {
 607                 ql_log(ql_log_warn, vha, 0xd041,
 608                     "%s: Failed to allocate ct_sns request.\n",
 609                     __func__);
 610                 goto done_free_sp;
 611         }
 612
 613         sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
 614             sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.rsp_dma,
 615             GFP_KERNEL);
 616         sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = sizeof(struct ct_sns_pkt);
 617         if (!sp->u.iocb_cmd.u.ctarg.rsp) {
 618                 ql_log(ql_log_warn, vha, 0xd042,
 619                     "%s: Failed to allocate ct_sns request.\n",
 620                     __func__);
 621                 goto done_free_sp;
 622         }
 623         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.rsp;
 624         memset(ct_sns, 0, sizeof(*ct_sns));
 625         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
 626
 627         /* Prepare CT request */
 628         ct_req = qla2x00_prep_ct_req(ct_sns, RFT_ID_CMD, RFT_ID_RSP_SIZE);
 629
 630         /* Prepare CT arguments -- port_id, FC-4 types */
 631         ct_req->req.rft_id.port_id = port_id_to_be_id(vha->d_id);
 632         ct_req->req.rft_id.fc4_types[2] = 0x01;         /* FCP-3 */
 633
 634         if (vha->flags.nvme_enabled)
 635                 ct_req->req.rft_id.fc4_types[6] = 1;    /* NVMe type 28h */
 636
 637         sp->u.iocb_cmd.u.ctarg.req_size = RFT_ID_REQ_SIZE;
 638         sp->u.iocb_cmd.u.ctarg.rsp_size = RFT_ID_RSP_SIZE;
 639         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
 640         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
 641         sp->done = qla2x00_async_sns_sp_done;
 642
 643         ql_dbg(ql_dbg_disc, vha, 0xffff,
 644             "Async-%s - hdl=%x portid %06x.\n",
 645             sp->name, sp->handle, d_id->b24);
 646
 647         rval = qla2x00_start_sp(sp);
 648         if (rval != QLA_SUCCESS) {
 649                 ql_dbg(ql_dbg_disc, vha, 0x2043,
 650                     "RFT_ID issue IOCB failed (%d).\n", rval);
 651                 goto done_free_sp;
 652         }
 653         return rval;
 654 done_free_sp:
 655         sp->free(sp);
 656 done:
 657         return rval;
 658 }
 659
 660 /**
 661  * qla2x00_rff_id() - SNS Register FC-4 Features (RFF_ID) supported by the HBA.
 662  * @vha: HA context
 663  * @type: not used
 664  *
 665  * Returns 0 on success.
 666  */
 667 int
 668 qla2x00_rff_id(scsi_qla_host_t *vha, u8 type)
 669 {
 670         struct qla_hw_data *ha = vha->hw;
 671
 672         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
 673                 ql_dbg(ql_dbg_disc, vha, 0x2046,
 674                     "RFF_ID call not supported on ISP2100/ISP2200.\n");
 675                 return (QLA_SUCCESS);
 676         }
 677
 678         return qla_async_rffid(vha, &vha->d_id, qlt_rff_id(vha), type);
 679 }
 680
 681 static int qla_async_rffid(scsi_qla_host_t *vha, port_id_t *d_id,
 682     u8 fc4feature, u8 fc4type)
 683 {
 684         int rval = QLA_MEMORY_ALLOC_FAILED;
 685         struct ct_sns_req *ct_req;
 686         srb_t *sp;
 687         struct ct_sns_pkt *ct_sns;
 688
 689         sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
 690         if (!sp)
 691                 goto done;
 692
 693         sp->type = SRB_CT_PTHRU_CMD;
 694         sp->name = "rff_id";
 695         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
 696
 697         sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
 698             sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.req_dma,
 699             GFP_KERNEL);
 700         sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
 701         if (!sp->u.iocb_cmd.u.ctarg.req) {
 702                 ql_log(ql_log_warn, vha, 0xd041,
 703                     "%s: Failed to allocate ct_sns request.\n",
 704                     __func__);
 705                 goto done_free_sp;
 706         }
 707
 708         sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
 709             sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.rsp_dma,
 710             GFP_KERNEL);
 711         sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = sizeof(struct ct_sns_pkt);
 712         if (!sp->u.iocb_cmd.u.ctarg.rsp) {
 713                 ql_log(ql_log_warn, vha, 0xd042,
 714                     "%s: Failed to allocate ct_sns request.\n",
 715                     __func__);
 716                 goto done_free_sp;
 717         }
 718         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.rsp;
 719         memset(ct_sns, 0, sizeof(*ct_sns));
 720         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
 721
 722         /* Prepare CT request */
 723         ct_req = qla2x00_prep_ct_req(ct_sns, RFF_ID_CMD, RFF_ID_RSP_SIZE);
 724
 725         /* Prepare CT arguments -- port_id, FC-4 feature, FC-4 type */
 726         ct_req->req.rff_id.port_id = port_id_to_be_id(*d_id);
 727         ct_req->req.rff_id.fc4_feature = fc4feature;
 728         ct_req->req.rff_id.fc4_type = fc4type;          /* SCSI-FCP or FC-NVMe */
 729
 730         sp->u.iocb_cmd.u.ctarg.req_size = RFF_ID_REQ_SIZE;
 731         sp->u.iocb_cmd.u.ctarg.rsp_size = RFF_ID_RSP_SIZE;
 732         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
 733         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
 734         sp->done = qla2x00_async_sns_sp_done;
 735
 736         ql_dbg(ql_dbg_disc, vha, 0xffff,
 737             "Async-%s - hdl=%x portid %06x feature %x type %x.\n",
 738             sp->name, sp->handle, d_id->b24, fc4feature, fc4type);
 739
 740         rval = qla2x00_start_sp(sp);
 741         if (rval != QLA_SUCCESS) {
 742                 ql_dbg(ql_dbg_disc, vha, 0x2047,
 743                     "RFF_ID issue IOCB failed (%d).\n", rval);
 744                 goto done_free_sp;
 745         }
 746
 747         return rval;
 748
 749 done_free_sp:
 750         sp->free(sp);
 751 done:
 752         return rval;
 753 }
 754
 755 /**
 756  * qla2x00_rnn_id() - SNS Register Node Name (RNN_ID) of the HBA.
 757  * @vha: HA context
 758  *
 759  * Returns 0 on success.
 760  */
 761 int
 762 qla2x00_rnn_id(scsi_qla_host_t *vha)
 763 {
 764         struct qla_hw_data *ha = vha->hw;
 765
 766         if (IS_QLA2100(ha) || IS_QLA2200(ha))
 767                 return qla2x00_sns_rnn_id(vha);
 768
 769         return  qla_async_rnnid(vha, &vha->d_id, vha->node_name);
 770 }
 771
 772 static int qla_async_rnnid(scsi_qla_host_t *vha, port_id_t *d_id,
 773         u8 *node_name)
 774 {
 775         int rval = QLA_MEMORY_ALLOC_FAILED;
 776         struct ct_sns_req *ct_req;
 777         srb_t *sp;
 778         struct ct_sns_pkt *ct_sns;
 779
 780         sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
 781         if (!sp)
 782                 goto done;
 783
 784         sp->type = SRB_CT_PTHRU_CMD;
 785         sp->name = "rnid";
 786         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
 787
 788         sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
 789             sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.req_dma,
 790             GFP_KERNEL);
 791         sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
 792         if (!sp->u.iocb_cmd.u.ctarg.req) {
 793                 ql_log(ql_log_warn, vha, 0xd041,
 794                     "%s: Failed to allocate ct_sns request.\n",
 795                     __func__);
 796                 goto done_free_sp;
 797         }
 798
 799         sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
 800             sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.rsp_dma,
 801             GFP_KERNEL);
 802         sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = sizeof(struct ct_sns_pkt);
 803         if (!sp->u.iocb_cmd.u.ctarg.rsp) {
 804                 ql_log(ql_log_warn, vha, 0xd042,
 805                     "%s: Failed to allocate ct_sns request.\n",
 806                     __func__);
 807                 goto done_free_sp;
 808         }
 809         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.rsp;
 810         memset(ct_sns, 0, sizeof(*ct_sns));
 811         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
 812
 813         /* Prepare CT request */
 814         ct_req = qla2x00_prep_ct_req(ct_sns, RNN_ID_CMD, RNN_ID_RSP_SIZE);
 815
 816         /* Prepare CT arguments -- port_id, node_name */
 817         ct_req->req.rnn_id.port_id = port_id_to_be_id(vha->d_id);
 818         memcpy(ct_req->req.rnn_id.node_name, vha->node_name, WWN_SIZE);
 819
 820         sp->u.iocb_cmd.u.ctarg.req_size = RNN_ID_REQ_SIZE;
 821         sp->u.iocb_cmd.u.ctarg.rsp_size = RNN_ID_RSP_SIZE;
 822         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
 823
 824         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
 825         sp->done = qla2x00_async_sns_sp_done;
 826
 827         ql_dbg(ql_dbg_disc, vha, 0xffff,
 828             "Async-%s - hdl=%x portid %06x\n",
 829             sp->name, sp->handle, d_id->b24);
 830
 831         rval = qla2x00_start_sp(sp);
 832         if (rval != QLA_SUCCESS) {
 833                 ql_dbg(ql_dbg_disc, vha, 0x204d,
 834                     "RNN_ID issue IOCB failed (%d).\n", rval);
 835                 goto done_free_sp;
 836         }
 837
 838         return rval;
 839
 840 done_free_sp:
 841         sp->free(sp);
 842 done:
 843         return rval;
 844 }
 845
 846 void
 847 qla2x00_get_sym_node_name(scsi_qla_host_t *vha, uint8_t *snn, size_t size)
 848 {
 849         struct qla_hw_data *ha = vha->hw;
 850
 851         if (IS_QLAFX00(ha))
 852                 snprintf(snn, size, "%s FW:v%s DVR:v%s", ha->model_number,
 853                     ha->mr.fw_version, qla2x00_version_str);
 854         else
 855                 snprintf(snn, size,
 856                     "%s FW:v%d.%02d.%02d DVR:v%s", ha->model_number,
 857                     ha->fw_major_version, ha->fw_minor_version,
 858                     ha->fw_subminor_version, qla2x00_version_str);
 859 }
 860
 861 /**
 862  * qla2x00_rsnn_nn() - SNS Register Symbolic Node Name (RSNN_NN) of the HBA.
 863  * @vha: HA context
 864  *
 865  * Returns 0 on success.
 866  */
 867 int
 868 qla2x00_rsnn_nn(scsi_qla_host_t *vha)
 869 {
 870         struct qla_hw_data *ha = vha->hw;
 871
 872         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
 873                 ql_dbg(ql_dbg_disc, vha, 0x2050,
 874                     "RSNN_ID call unsupported on ISP2100/ISP2200.\n");
 875                 return (QLA_SUCCESS);
 876         }
 877
 878         return qla_async_rsnn_nn(vha);
 879 }
 880
 881 static int qla_async_rsnn_nn(scsi_qla_host_t *vha)
 882 {
 883         int rval = QLA_MEMORY_ALLOC_FAILED;
 884         struct ct_sns_req *ct_req;
 885         srb_t *sp;
 886         struct ct_sns_pkt *ct_sns;
 887
 888         sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
 889         if (!sp)
 890                 goto done;
 891
 892         sp->type = SRB_CT_PTHRU_CMD;
 893         sp->name = "rsnn_nn";
 894         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
 895
 896         sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
 897             sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.req_dma,
 898             GFP_KERNEL);
 899         sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
 900         if (!sp->u.iocb_cmd.u.ctarg.req) {
 901                 ql_log(ql_log_warn, vha, 0xd041,
 902                     "%s: Failed to allocate ct_sns request.\n",
 903                     __func__);
 904                 goto done_free_sp;
 905         }
 906
 907         sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
 908             sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.rsp_dma,
 909             GFP_KERNEL);
 910         sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = sizeof(struct ct_sns_pkt);
 911         if (!sp->u.iocb_cmd.u.ctarg.rsp) {
 912                 ql_log(ql_log_warn, vha, 0xd042,
 913                     "%s: Failed to allocate ct_sns request.\n",
 914                     __func__);
 915                 goto done_free_sp;
 916         }
 917         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.rsp;
 918         memset(ct_sns, 0, sizeof(*ct_sns));
 919         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
 920
 921         /* Prepare CT request */
 922         ct_req = qla2x00_prep_ct_req(ct_sns, RSNN_NN_CMD, RSNN_NN_RSP_SIZE);
 923
 924         /* Prepare CT arguments -- node_name, symbolic node_name, size */
 925         memcpy(ct_req->req.rsnn_nn.node_name, vha->node_name, WWN_SIZE);
 926
 927         /* Prepare the Symbolic Node Name */
 928         qla2x00_get_sym_node_name(vha, ct_req->req.rsnn_nn.sym_node_name,
 929             sizeof(ct_req->req.rsnn_nn.sym_node_name));
 930         ct_req->req.rsnn_nn.name_len =
 931             (uint8_t)strlen(ct_req->req.rsnn_nn.sym_node_name);
 932
 933
 934         sp->u.iocb_cmd.u.ctarg.req_size = 24 + 1 + ct_req->req.rsnn_nn.name_len;
 935         sp->u.iocb_cmd.u.ctarg.rsp_size = RSNN_NN_RSP_SIZE;
 936         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
 937
 938         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
 939         sp->done = qla2x00_async_sns_sp_done;
 940
 941         ql_dbg(ql_dbg_disc, vha, 0xffff,
 942             "Async-%s - hdl=%x.\n",
 943             sp->name, sp->handle);
 944
 945         rval = qla2x00_start_sp(sp);
 946         if (rval != QLA_SUCCESS) {
 947                 ql_dbg(ql_dbg_disc, vha, 0x2043,
 948                     "RFT_ID issue IOCB failed (%d).\n", rval);
 949                 goto done_free_sp;
 950         }
 951
 952         return rval;
 953
 954 done_free_sp:
 955         sp->free(sp);
 956 done:
 957         return rval;
 958 }
 959
 960 /**
 961  * qla2x00_prep_sns_cmd() - Prepare common SNS command request fields for query.
 962  * @vha: HA context
 963  * @cmd: GS command
 964  * @scmd_len: Subcommand length
 965  * @data_size: response size in bytes
 966  *
 967  * Returns a pointer to the @ha's sns_cmd.
 968  */
 969 static inline struct sns_cmd_pkt *
 970 qla2x00_prep_sns_cmd(scsi_qla_host_t *vha, uint16_t cmd, uint16_t scmd_len,
 971     uint16_t data_size)
 972 {
 973         uint16_t                wc;
 974         struct sns_cmd_pkt      *sns_cmd;
 975         struct qla_hw_data *ha = vha->hw;
 976
 977         sns_cmd = ha->sns_cmd;
 978         memset(sns_cmd, 0, sizeof(struct sns_cmd_pkt));
 979         wc = data_size / 2;                     /* Size in 16bit words. */
 980         sns_cmd->p.cmd.buffer_length = cpu_to_le16(wc);
 981         put_unaligned_le64(ha->sns_cmd_dma, &sns_cmd->p.cmd.buffer_address);
 982         sns_cmd->p.cmd.subcommand_length = cpu_to_le16(scmd_len);
 983         sns_cmd->p.cmd.subcommand = cpu_to_le16(cmd);
 984         wc = (data_size - 16) / 4;              /* Size in 32bit words. */
 985         sns_cmd->p.cmd.size = cpu_to_le16(wc);
 986
 987         vha->qla_stats.control_requests++;
 988
 989         return (sns_cmd);
 990 }
 991
 992 /**
 993  * qla2x00_sns_ga_nxt() - SNS scan for fabric devices via GA_NXT command.
 994  * @vha: HA context
 995  * @fcport: fcport entry to updated
 996  *
 997  * This command uses the old Exectute SNS Command mailbox routine.
 998  *
 999  * Returns 0 on success.
1000  */
1001 static int
1002 qla2x00_sns_ga_nxt(scsi_qla_host_t *vha, fc_port_t *fcport)
1003 {
1004         int             rval = QLA_SUCCESS;
1005         struct qla_hw_data *ha = vha->hw;
1006         struct sns_cmd_pkt      *sns_cmd;
1007
1008         /* Issue GA_NXT. */
1009         /* Prepare SNS command request. */
1010         sns_cmd = qla2x00_prep_sns_cmd(vha, GA_NXT_CMD, GA_NXT_SNS_SCMD_LEN,
1011             GA_NXT_SNS_DATA_SIZE);
1012
1013         /* Prepare SNS command arguments -- port_id. */
1014         sns_cmd->p.cmd.param[0] = fcport->d_id.b.al_pa;
1015         sns_cmd->p.cmd.param[1] = fcport->d_id.b.area;
1016         sns_cmd->p.cmd.param[2] = fcport->d_id.b.domain;
1017
1018         /* Execute SNS command. */
1019         rval = qla2x00_send_sns(vha, ha->sns_cmd_dma, GA_NXT_SNS_CMD_SIZE / 2,
1020             sizeof(struct sns_cmd_pkt));
1021         if (rval != QLA_SUCCESS) {
1022                 /*EMPTY*/
1023                 ql_dbg(ql_dbg_disc, vha, 0x205f,
1024                     "GA_NXT Send SNS failed (%d).\n", rval);
1025         } else if (sns_cmd->p.gan_data[8] != 0x80 ||
1026             sns_cmd->p.gan_data[9] != 0x02) {
1027                 ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x2084,
1028                     "GA_NXT failed, rejected request ga_nxt_rsp:\n");
1029                 ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2074,
1030                     sns_cmd->p.gan_data, 16);
1031                 rval = QLA_FUNCTION_FAILED;
1032         } else {
1033                 /* Populate fc_port_t entry. */
1034                 fcport->d_id.b.domain = sns_cmd->p.gan_data[17];
1035                 fcport->d_id.b.area = sns_cmd->p.gan_data[18];
1036                 fcport->d_id.b.al_pa = sns_cmd->p.gan_data[19];
1037
1038                 memcpy(fcport->node_name, &sns_cmd->p.gan_data[284], WWN_SIZE);
1039                 memcpy(fcport->port_name, &sns_cmd->p.gan_data[20], WWN_SIZE);
1040
1041                 if (sns_cmd->p.gan_data[16] != NS_N_PORT_TYPE &&
1042                     sns_cmd->p.gan_data[16] != NS_NL_PORT_TYPE)
1043                         fcport->d_id.b.domain = 0xf0;
1044
1045                 ql_dbg(ql_dbg_disc, vha, 0x2061,
1046                     "GA_NXT entry - nn %8phN pn %8phN "
1047                     "port_id=%02x%02x%02x.\n",
1048                     fcport->node_name, fcport->port_name,
1049                     fcport->d_id.b.domain, fcport->d_id.b.area,
1050                     fcport->d_id.b.al_pa);
1051         }
1052
1053         return (rval);
1054 }
1055
1056 /**
1057  * qla2x00_sns_gid_pt() - SNS scan for fabric devices via GID_PT command.
1058  * @vha: HA context
1059  * @list: switch info entries to populate
1060  *
1061  * This command uses the old Exectute SNS Command mailbox routine.
1062  *
1063  * NOTE: Non-Nx_Ports are not requested.
1064  *
1065  * Returns 0 on success.
1066  */
1067 static int
1068 qla2x00_sns_gid_pt(scsi_qla_host_t *vha, sw_info_t *list)
1069 {
1070         int             rval;
1071         struct qla_hw_data *ha = vha->hw;
1072         uint16_t        i;
1073         uint8_t         *entry;
1074         struct sns_cmd_pkt      *sns_cmd;
1075         uint16_t gid_pt_sns_data_size;
1076
1077         gid_pt_sns_data_size = qla2x00_gid_pt_rsp_size(vha);
1078
1079         /* Issue GID_PT. */
1080         /* Prepare SNS command request. */
1081         sns_cmd = qla2x00_prep_sns_cmd(vha, GID_PT_CMD, GID_PT_SNS_SCMD_LEN,
1082             gid_pt_sns_data_size);
1083
1084         /* Prepare SNS command arguments -- port_type. */
1085         sns_cmd->p.cmd.param[0] = NS_NX_PORT_TYPE;
1086
1087         /* Execute SNS command. */
1088         rval = qla2x00_send_sns(vha, ha->sns_cmd_dma, GID_PT_SNS_CMD_SIZE / 2,
1089             sizeof(struct sns_cmd_pkt));
1090         if (rval != QLA_SUCCESS) {
1091                 /*EMPTY*/
1092                 ql_dbg(ql_dbg_disc, vha, 0x206d,
1093                     "GID_PT Send SNS failed (%d).\n", rval);
1094         } else if (sns_cmd->p.gid_data[8] != 0x80 ||
1095             sns_cmd->p.gid_data[9] != 0x02) {
1096                 ql_dbg(ql_dbg_disc, vha, 0x202f,
1097                     "GID_PT failed, rejected request, gid_rsp:\n");
1098                 ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2081,
1099                     sns_cmd->p.gid_data, 16);
1100                 rval = QLA_FUNCTION_FAILED;
1101         } else {
1102                 /* Set port IDs in switch info list. */
1103                 for (i = 0; i < ha->max_fibre_devices; i++) {
1104                         entry = &sns_cmd->p.gid_data[(i * 4) + 16];
1105                         list[i].d_id.b.domain = entry[1];
1106                         list[i].d_id.b.area = entry[2];
1107                         list[i].d_id.b.al_pa = entry[3];
1108
1109                         /* Last one exit. */
1110                         if (entry[0] & BIT_7) {
1111                                 list[i].d_id.b.rsvd_1 = entry[0];
1112                                 break;
1113                         }
1114                 }
1115
1116                 /*
1117                  * If we've used all available slots, then the switch is
1118                  * reporting back more devices that we can handle with this
1119                  * single call.  Return a failed status, and let GA_NXT handle
1120                  * the overload.
1121                  */
1122                 if (i == ha->max_fibre_devices)
1123                         rval = QLA_FUNCTION_FAILED;
1124         }
1125
1126         return (rval);
1127 }
1128
1129 /**
1130  * qla2x00_sns_gpn_id() - SNS Get Port Name (GPN_ID) query.
1131  * @vha: HA context
1132  * @list: switch info entries to populate
1133  *
1134  * This command uses the old Exectute SNS Command mailbox routine.
1135  *
1136  * Returns 0 on success.
1137  */
1138 static int
1139 qla2x00_sns_gpn_id(scsi_qla_host_t *vha, sw_info_t *list)
1140 {
1141         int             rval = QLA_SUCCESS;
1142         struct qla_hw_data *ha = vha->hw;
1143         uint16_t        i;
1144         struct sns_cmd_pkt      *sns_cmd;
1145
1146         for (i = 0; i < ha->max_fibre_devices; i++) {
1147                 /* Issue GPN_ID */
1148                 /* Prepare SNS command request. */
1149                 sns_cmd = qla2x00_prep_sns_cmd(vha, GPN_ID_CMD,
1150                     GPN_ID_SNS_SCMD_LEN, GPN_ID_SNS_DATA_SIZE);
1151
1152                 /* Prepare SNS command arguments -- port_id. */
1153                 sns_cmd->p.cmd.param[0] = list[i].d_id.b.al_pa;
1154                 sns_cmd->p.cmd.param[1] = list[i].d_id.b.area;
1155                 sns_cmd->p.cmd.param[2] = list[i].d_id.b.domain;
1156
1157                 /* Execute SNS command. */
1158                 rval = qla2x00_send_sns(vha, ha->sns_cmd_dma,
1159                     GPN_ID_SNS_CMD_SIZE / 2, sizeof(struct sns_cmd_pkt));
1160                 if (rval != QLA_SUCCESS) {
1161                         /*EMPTY*/
1162                         ql_dbg(ql_dbg_disc, vha, 0x2032,
1163                             "GPN_ID Send SNS failed (%d).\n", rval);
1164                 } else if (sns_cmd->p.gpn_data[8] != 0x80 ||
1165                     sns_cmd->p.gpn_data[9] != 0x02) {
1166                         ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x207e,
1167                             "GPN_ID failed, rejected request, gpn_rsp:\n");
1168                         ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x207f,
1169                             sns_cmd->p.gpn_data, 16);
1170                         rval = QLA_FUNCTION_FAILED;
1171                 } else {
1172                         /* Save portname */
1173                         memcpy(list[i].port_name, &sns_cmd->p.gpn_data[16],
1174                             WWN_SIZE);
1175                 }
1176
1177                 /* Last device exit. */
1178                 if (list[i].d_id.b.rsvd_1 != 0)
1179                         break;
1180         }
1181
1182         return (rval);
1183 }
1184
1185 /**
1186  * qla2x00_sns_gnn_id() - SNS Get Node Name (GNN_ID) query.
1187  * @vha: HA context
1188  * @list: switch info entries to populate
1189  *
1190  * This command uses the old Exectute SNS Command mailbox routine.
1191  *
1192  * Returns 0 on success.
1193  */
1194 static int
1195 qla2x00_sns_gnn_id(scsi_qla_host_t *vha, sw_info_t *list)
1196 {
1197         int             rval = QLA_SUCCESS;
1198         struct qla_hw_data *ha = vha->hw;
1199         uint16_t        i;
1200         struct sns_cmd_pkt      *sns_cmd;
1201
1202         for (i = 0; i < ha->max_fibre_devices; i++) {
1203                 /* Issue GNN_ID */
1204                 /* Prepare SNS command request. */
1205                 sns_cmd = qla2x00_prep_sns_cmd(vha, GNN_ID_CMD,
1206                     GNN_ID_SNS_SCMD_LEN, GNN_ID_SNS_DATA_SIZE);
1207
1208                 /* Prepare SNS command arguments -- port_id. */
1209                 sns_cmd->p.cmd.param[0] = list[i].d_id.b.al_pa;
1210                 sns_cmd->p.cmd.param[1] = list[i].d_id.b.area;
1211                 sns_cmd->p.cmd.param[2] = list[i].d_id.b.domain;
1212
1213                 /* Execute SNS command. */
1214                 rval = qla2x00_send_sns(vha, ha->sns_cmd_dma,
1215                     GNN_ID_SNS_CMD_SIZE / 2, sizeof(struct sns_cmd_pkt));
1216                 if (rval != QLA_SUCCESS) {
1217                         /*EMPTY*/
1218                         ql_dbg(ql_dbg_disc, vha, 0x203f,
1219                             "GNN_ID Send SNS failed (%d).\n", rval);
1220                 } else if (sns_cmd->p.gnn_data[8] != 0x80 ||
1221                     sns_cmd->p.gnn_data[9] != 0x02) {
1222                         ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x2082,
1223                             "GNN_ID failed, rejected request, gnn_rsp:\n");
1224                         ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x207a,
1225                             sns_cmd->p.gnn_data, 16);
1226                         rval = QLA_FUNCTION_FAILED;
1227                 } else {
1228                         /* Save nodename */
1229                         memcpy(list[i].node_name, &sns_cmd->p.gnn_data[16],
1230                             WWN_SIZE);
1231
1232                         ql_dbg(ql_dbg_disc, vha, 0x206e,
1233                             "GID_PT entry - nn %8phN pn %8phN "
1234                             "port_id=%02x%02x%02x.\n",
1235                             list[i].node_name, list[i].port_name,
1236                             list[i].d_id.b.domain, list[i].d_id.b.area,
1237                             list[i].d_id.b.al_pa);
1238                 }
1239
1240                 /* Last device exit. */
1241                 if (list[i].d_id.b.rsvd_1 != 0)
1242                         break;
1243         }
1244
1245         return (rval);
1246 }
1247
1248 /**
1249  * qla2x00_snd_rft_id() - SNS Register FC-4 TYPEs (RFT_ID) supported by the HBA.
1250  * @vha: HA context
1251  *
1252  * This command uses the old Exectute SNS Command mailbox routine.
1253  *
1254  * Returns 0 on success.
1255  */
1256 static int
1257 qla2x00_sns_rft_id(scsi_qla_host_t *vha)
1258 {
1259         int             rval;
1260         struct qla_hw_data *ha = vha->hw;
1261         struct sns_cmd_pkt      *sns_cmd;
1262
1263         /* Issue RFT_ID. */
1264         /* Prepare SNS command request. */
1265         sns_cmd = qla2x00_prep_sns_cmd(vha, RFT_ID_CMD, RFT_ID_SNS_SCMD_LEN,
1266             RFT_ID_SNS_DATA_SIZE);
1267
1268         /* Prepare SNS command arguments -- port_id, FC-4 types */
1269         sns_cmd->p.cmd.param[0] = vha->d_id.b.al_pa;
1270         sns_cmd->p.cmd.param[1] = vha->d_id.b.area;
1271         sns_cmd->p.cmd.param[2] = vha->d_id.b.domain;
1272
1273         sns_cmd->p.cmd.param[5] = 0x01;                 /* FCP-3 */
1274
1275         /* Execute SNS command. */
1276         rval = qla2x00_send_sns(vha, ha->sns_cmd_dma, RFT_ID_SNS_CMD_SIZE / 2,
1277             sizeof(struct sns_cmd_pkt));
1278         if (rval != QLA_SUCCESS) {
1279                 /*EMPTY*/
1280                 ql_dbg(ql_dbg_disc, vha, 0x2060,
1281                     "RFT_ID Send SNS failed (%d).\n", rval);
1282         } else if (sns_cmd->p.rft_data[8] != 0x80 ||
1283             sns_cmd->p.rft_data[9] != 0x02) {
1284                 ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x2083,
1285                     "RFT_ID failed, rejected request rft_rsp:\n");
1286                 ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2080,
1287                     sns_cmd->p.rft_data, 16);
1288                 rval = QLA_FUNCTION_FAILED;
1289         } else {
1290                 ql_dbg(ql_dbg_disc, vha, 0x2073,
1291                     "RFT_ID exiting normally.\n");
1292         }
1293
1294         return (rval);
1295 }
1296
1297 /**
1298  * qla2x00_sns_rnn_id() - SNS Register Node Name (RNN_ID) of the HBA.
1299  * @vha: HA context
1300  *
1301  * This command uses the old Exectute SNS Command mailbox routine.
1302  *
1303  * Returns 0 on success.
1304  */
1305 static int
1306 qla2x00_sns_rnn_id(scsi_qla_host_t *vha)
1307 {
1308         int             rval;
1309         struct qla_hw_data *ha = vha->hw;
1310         struct sns_cmd_pkt      *sns_cmd;
1311
1312         /* Issue RNN_ID. */
1313         /* Prepare SNS command request. */
1314         sns_cmd = qla2x00_prep_sns_cmd(vha, RNN_ID_CMD, RNN_ID_SNS_SCMD_LEN,
1315             RNN_ID_SNS_DATA_SIZE);
1316
1317         /* Prepare SNS command arguments -- port_id, nodename. */
1318         sns_cmd->p.cmd.param[0] = vha->d_id.b.al_pa;
1319         sns_cmd->p.cmd.param[1] = vha->d_id.b.area;
1320         sns_cmd->p.cmd.param[2] = vha->d_id.b.domain;
1321
1322         sns_cmd->p.cmd.param[4] = vha->node_name[7];
1323         sns_cmd->p.cmd.param[5] = vha->node_name[6];
1324         sns_cmd->p.cmd.param[6] = vha->node_name[5];
1325         sns_cmd->p.cmd.param[7] = vha->node_name[4];
1326         sns_cmd->p.cmd.param[8] = vha->node_name[3];
1327         sns_cmd->p.cmd.param[9] = vha->node_name[2];
1328         sns_cmd->p.cmd.param[10] = vha->node_name[1];
1329         sns_cmd->p.cmd.param[11] = vha->node_name[0];
1330
1331         /* Execute SNS command. */
1332         rval = qla2x00_send_sns(vha, ha->sns_cmd_dma, RNN_ID_SNS_CMD_SIZE / 2,
1333             sizeof(struct sns_cmd_pkt));
1334         if (rval != QLA_SUCCESS) {
1335                 /*EMPTY*/
1336                 ql_dbg(ql_dbg_disc, vha, 0x204a,
1337                     "RNN_ID Send SNS failed (%d).\n", rval);
1338         } else if (sns_cmd->p.rnn_data[8] != 0x80 ||
1339             sns_cmd->p.rnn_data[9] != 0x02) {
1340                 ql_dbg(ql_dbg_disc + ql_dbg_buffer, vha, 0x207b,
1341                     "RNN_ID failed, rejected request, rnn_rsp:\n");
1342                 ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x207c,
1343                     sns_cmd->p.rnn_data, 16);
1344                 rval = QLA_FUNCTION_FAILED;
1345         } else {
1346                 ql_dbg(ql_dbg_disc, vha, 0x204c,
1347                     "RNN_ID exiting normally.\n");
1348         }
1349
1350         return (rval);
1351 }
1352
1353 /**
1354  * qla2x00_mgmt_svr_login() - Login to fabric Management Service.
1355  * @vha: HA context
1356  *
1357  * Returns 0 on success.
1358  */
1359 int
1360 qla2x00_mgmt_svr_login(scsi_qla_host_t *vha)
1361 {
1362         int ret, rval;
1363         uint16_t mb[MAILBOX_REGISTER_COUNT];
1364         struct qla_hw_data *ha = vha->hw;
1365
1366         ret = QLA_SUCCESS;
1367         if (vha->flags.management_server_logged_in)
1368                 return ret;
1369
1370         rval = ha->isp_ops->fabric_login(vha, vha->mgmt_svr_loop_id, 0xff, 0xff,
1371             0xfa, mb, BIT_1);
1372         if (rval != QLA_SUCCESS || mb[0] != MBS_COMMAND_COMPLETE) {
1373                 if (rval == QLA_MEMORY_ALLOC_FAILED)
1374                         ql_dbg(ql_dbg_disc, vha, 0x2085,
1375                             "Failed management_server login: loopid=%x "
1376                             "rval=%d\n", vha->mgmt_svr_loop_id, rval);
1377                 else
1378                         ql_dbg(ql_dbg_disc, vha, 0x2024,
1379                             "Failed management_server login: loopid=%x "
1380                             "mb[0]=%x mb[1]=%x mb[2]=%x mb[6]=%x mb[7]=%x.\n",
1381                             vha->mgmt_svr_loop_id, mb[0], mb[1], mb[2], mb[6],
1382                             mb[7]);
1383                 ret = QLA_FUNCTION_FAILED;
1384         } else
1385                 vha->flags.management_server_logged_in = 1;
1386
1387         return ret;
1388 }
1389
1390 /**
1391  * qla2x00_prep_ms_fdmi_iocb() - Prepare common MS IOCB fields for FDMI query.
1392  * @vha: HA context
1393  * @req_size: request size in bytes
1394  * @rsp_size: response size in bytes
1395  *
1396  * Returns a pointer to the @ha's ms_iocb.
1397  */
1398 void *
1399 qla2x00_prep_ms_fdmi_iocb(scsi_qla_host_t *vha, uint32_t req_size,
1400     uint32_t rsp_size)
1401 {
1402         ms_iocb_entry_t *ms_pkt;
1403         struct qla_hw_data *ha = vha->hw;
1404
1405         ms_pkt = ha->ms_iocb;
1406         memset(ms_pkt, 0, sizeof(ms_iocb_entry_t));
1407
1408         ms_pkt->entry_type = MS_IOCB_TYPE;
1409         ms_pkt->entry_count = 1;
1410         SET_TARGET_ID(ha, ms_pkt->loop_id, vha->mgmt_svr_loop_id);
1411         ms_pkt->control_flags = cpu_to_le16(CF_READ | CF_HEAD_TAG);
1412         ms_pkt->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
1413         ms_pkt->cmd_dsd_count = cpu_to_le16(1);
1414         ms_pkt->total_dsd_count = cpu_to_le16(2);
1415         ms_pkt->rsp_bytecount = cpu_to_le32(rsp_size);
1416         ms_pkt->req_bytecount = cpu_to_le32(req_size);
1417
1418         put_unaligned_le64(ha->ct_sns_dma, &ms_pkt->req_dsd.address);
1419         ms_pkt->req_dsd.length = ms_pkt->req_bytecount;
1420
1421         put_unaligned_le64(ha->ct_sns_dma, &ms_pkt->rsp_dsd.address);
1422         ms_pkt->rsp_dsd.length = ms_pkt->rsp_bytecount;
1423
1424         return ms_pkt;
1425 }
1426
1427 /**
1428  * qla24xx_prep_ms_fdmi_iocb() - Prepare common MS IOCB fields for FDMI query.
1429  * @vha: HA context
1430  * @req_size: request size in bytes
1431  * @rsp_size: response size in bytes
1432  *
1433  * Returns a pointer to the @ha's ms_iocb.
1434  */
1435 void *
1436 qla24xx_prep_ms_fdmi_iocb(scsi_qla_host_t *vha, uint32_t req_size,
1437     uint32_t rsp_size)
1438 {
1439         struct ct_entry_24xx *ct_pkt;
1440         struct qla_hw_data *ha = vha->hw;
1441
1442         ct_pkt = (struct ct_entry_24xx *)ha->ms_iocb;
1443         memset(ct_pkt, 0, sizeof(struct ct_entry_24xx));
1444
1445         ct_pkt->entry_type = CT_IOCB_TYPE;
1446         ct_pkt->entry_count = 1;
1447         ct_pkt->nport_handle = cpu_to_le16(vha->mgmt_svr_loop_id);
1448         ct_pkt->timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
1449         ct_pkt->cmd_dsd_count = cpu_to_le16(1);
1450         ct_pkt->rsp_dsd_count = cpu_to_le16(1);
1451         ct_pkt->rsp_byte_count = cpu_to_le32(rsp_size);
1452         ct_pkt->cmd_byte_count = cpu_to_le32(req_size);
1453
1454         put_unaligned_le64(ha->ct_sns_dma, &ct_pkt->dsd[0].address);
1455         ct_pkt->dsd[0].length = ct_pkt->cmd_byte_count;
1456
1457         put_unaligned_le64(ha->ct_sns_dma, &ct_pkt->dsd[1].address);
1458         ct_pkt->dsd[1].length = ct_pkt->rsp_byte_count;
1459         ct_pkt->vp_index = vha->vp_idx;
1460
1461         return ct_pkt;
1462 }
1463
1464 static void
1465 qla2x00_update_ms_fdmi_iocb(scsi_qla_host_t *vha, uint32_t req_size)
1466 {
1467         struct qla_hw_data *ha = vha->hw;
1468         ms_iocb_entry_t *ms_pkt = ha->ms_iocb;
1469         struct ct_entry_24xx *ct_pkt = (struct ct_entry_24xx *)ha->ms_iocb;
1470
1471         if (IS_FWI2_CAPABLE(ha)) {
1472                 ct_pkt->cmd_byte_count = cpu_to_le32(req_size);
1473                 ct_pkt->dsd[0].length = ct_pkt->cmd_byte_count;
1474         } else {
1475                 ms_pkt->req_bytecount = cpu_to_le32(req_size);
1476                 ms_pkt->req_dsd.length = ms_pkt->req_bytecount;
1477         }
1478 }
1479
1480 /**
1481  * qla2x00_prep_ct_req() - Prepare common CT request fields for SNS query.
1482  * @p: CT request buffer
1483  * @cmd: GS command
1484  * @rsp_size: response size in bytes
1485  *
1486  * Returns a pointer to the intitialized @ct_req.
1487  */
1488 static inline struct ct_sns_req *
1489 qla2x00_prep_ct_fdmi_req(struct ct_sns_pkt *p, uint16_t cmd,
1490     uint16_t rsp_size)
1491 {
1492         memset(p, 0, sizeof(struct ct_sns_pkt));
1493
1494         p->p.req.header.revision = 0x01;
1495         p->p.req.header.gs_type = 0xFA;
1496         p->p.req.header.gs_subtype = 0x10;
1497         p->p.req.command = cpu_to_be16(cmd);
1498         p->p.req.max_rsp_size = cpu_to_be16((rsp_size - 16) / 4);
1499
1500         return &p->p.req;
1501 }
1502
1503 /**
1504  * qla2x00_fdmi_rhba() - perform RHBA FDMI registration
1505  * @vha: HA context
1506  *
1507  * Returns 0 on success.
1508  */
1509 static int
1510 qla2x00_fdmi_rhba(scsi_qla_host_t *vha)
1511 {
1512         int rval, alen;
1513         uint32_t size, sn;
1514
1515         ms_iocb_entry_t *ms_pkt;
1516         struct ct_sns_req *ct_req;
1517         struct ct_sns_rsp *ct_rsp;
1518         void *entries;
1519         struct ct_fdmi_hba_attr *eiter;
1520         struct qla_hw_data *ha = vha->hw;
1521
1522         /* Issue RHBA */
1523         /* Prepare common MS IOCB */
1524         /*   Request size adjusted after CT preparation */
1525         ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, RHBA_RSP_SIZE);
1526
1527         /* Prepare CT request */
1528         ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RHBA_CMD, RHBA_RSP_SIZE);
1529         ct_rsp = &ha->ct_sns->p.rsp;
1530
1531         /* Prepare FDMI command arguments -- attribute block, attributes. */
1532         memcpy(ct_req->req.rhba.hba_identifier, vha->port_name, WWN_SIZE);
1533         ct_req->req.rhba.entry_count = cpu_to_be32(1);
1534         memcpy(ct_req->req.rhba.port_name, vha->port_name, WWN_SIZE);
1535         size = 2 * WWN_SIZE + 4 + 4;
1536
1537         /* Attributes */
1538         ct_req->req.rhba.attrs.count =
1539             cpu_to_be32(FDMI_HBA_ATTR_COUNT);
1540         entries = &ct_req->req;
1541
1542         /* Nodename. */
1543         eiter = entries + size;
1544         eiter->type = cpu_to_be16(FDMI_HBA_NODE_NAME);
1545         eiter->len = cpu_to_be16(4 + WWN_SIZE);
1546         memcpy(eiter->a.node_name, vha->node_name, WWN_SIZE);
1547         size += 4 + WWN_SIZE;
1548
1549         ql_dbg(ql_dbg_disc, vha, 0x2025,
1550             "NodeName = %8phN.\n", eiter->a.node_name);
1551
1552         /* Manufacturer. */
1553         eiter = entries + size;
1554         eiter->type = cpu_to_be16(FDMI_HBA_MANUFACTURER);
1555         alen = strlen(QLA2XXX_MANUFACTURER);
1556         snprintf(eiter->a.manufacturer, sizeof(eiter->a.manufacturer),
1557             "%s", "QLogic Corporation");
1558         alen += 4 - (alen & 3);
1559         eiter->len = cpu_to_be16(4 + alen);
1560         size += 4 + alen;
1561
1562         ql_dbg(ql_dbg_disc, vha, 0x2026,
1563             "Manufacturer = %s.\n", eiter->a.manufacturer);
1564
1565         /* Serial number. */
1566         eiter = entries + size;
1567         eiter->type = cpu_to_be16(FDMI_HBA_SERIAL_NUMBER);
1568         if (IS_FWI2_CAPABLE(ha))
1569                 qla2xxx_get_vpd_field(vha, "SN", eiter->a.serial_num,
1570                     sizeof(eiter->a.serial_num));
1571         else {
1572                 sn = ((ha->serial0 & 0x1f) << 16) |
1573                         (ha->serial2 << 8) | ha->serial1;
1574                 snprintf(eiter->a.serial_num, sizeof(eiter->a.serial_num),
1575                     "%c%05d", 'A' + sn / 100000, sn % 100000);
1576         }
1577         alen = strlen(eiter->a.serial_num);
1578         alen += 4 - (alen & 3);
1579         eiter->len = cpu_to_be16(4 + alen);
1580         size += 4 + alen;
1581
1582         ql_dbg(ql_dbg_disc, vha, 0x2027,
1583             "Serial no. = %s.\n", eiter->a.serial_num);
1584
1585         /* Model name. */
1586         eiter = entries + size;
1587         eiter->type = cpu_to_be16(FDMI_HBA_MODEL);
1588         snprintf(eiter->a.model, sizeof(eiter->a.model),
1589             "%s", ha->model_number);
1590         alen = strlen(eiter->a.model);
1591         alen += 4 - (alen & 3);
1592         eiter->len = cpu_to_be16(4 + alen);
1593         size += 4 + alen;
1594
1595         ql_dbg(ql_dbg_disc, vha, 0x2028,
1596             "Model Name = %s.\n", eiter->a.model);
1597
1598         /* Model description. */
1599         eiter = entries + size;
1600         eiter->type = cpu_to_be16(FDMI_HBA_MODEL_DESCRIPTION);
1601         snprintf(eiter->a.model_desc, sizeof(eiter->a.model_desc),
1602             "%s", ha->model_desc);
1603         alen = strlen(eiter->a.model_desc);
1604         alen += 4 - (alen & 3);
1605         eiter->len = cpu_to_be16(4 + alen);
1606         size += 4 + alen;
1607
1608         ql_dbg(ql_dbg_disc, vha, 0x2029,
1609             "Model Desc = %s.\n", eiter->a.model_desc);
1610
1611         /* Hardware version. */
1612         eiter = entries + size;
1613         eiter->type = cpu_to_be16(FDMI_HBA_HARDWARE_VERSION);
1614         if (!IS_FWI2_CAPABLE(ha)) {
1615                 snprintf(eiter->a.hw_version, sizeof(eiter->a.hw_version),
1616                     "HW:%s", ha->adapter_id);
1617         } else if (qla2xxx_get_vpd_field(vha, "MN", eiter->a.hw_version,
1618                     sizeof(eiter->a.hw_version))) {
1619                 ;
1620         } else if (qla2xxx_get_vpd_field(vha, "EC", eiter->a.hw_version,
1621                     sizeof(eiter->a.hw_version))) {
1622                 ;
1623         } else {
1624                 snprintf(eiter->a.hw_version, sizeof(eiter->a.hw_version),
1625                     "HW:%s", ha->adapter_id);
1626         }
1627         alen = strlen(eiter->a.hw_version);
1628         alen += 4 - (alen & 3);
1629         eiter->len = cpu_to_be16(4 + alen);
1630         size += 4 + alen;
1631
1632         ql_dbg(ql_dbg_disc, vha, 0x202a,
1633             "Hardware ver = %s.\n", eiter->a.hw_version);
1634
1635         /* Driver version. */
1636         eiter = entries + size;
1637         eiter->type = cpu_to_be16(FDMI_HBA_DRIVER_VERSION);
1638         snprintf(eiter->a.driver_version, sizeof(eiter->a.driver_version),
1639             "%s", qla2x00_version_str);
1640         alen = strlen(eiter->a.driver_version);
1641         alen += 4 - (alen & 3);
1642         eiter->len = cpu_to_be16(4 + alen);
1643         size += 4 + alen;
1644
1645         ql_dbg(ql_dbg_disc, vha, 0x202b,
1646             "Driver ver = %s.\n", eiter->a.driver_version);
1647
1648         /* Option ROM version. */
1649         eiter = entries + size;
1650         eiter->type = cpu_to_be16(FDMI_HBA_OPTION_ROM_VERSION);
1651         snprintf(eiter->a.orom_version, sizeof(eiter->a.orom_version),
1652             "%d.%02d", ha->bios_revision[1], ha->bios_revision[0]);
1653         alen = strlen(eiter->a.orom_version);
1654         alen += 4 - (alen & 3);
1655         eiter->len = cpu_to_be16(4 + alen);
1656         size += 4 + alen;
1657
1658         ql_dbg(ql_dbg_disc, vha , 0x202c,
1659             "Optrom vers = %s.\n", eiter->a.orom_version);
1660
1661         /* Firmware version */
1662         eiter = entries + size;
1663         eiter->type = cpu_to_be16(FDMI_HBA_FIRMWARE_VERSION);
1664         ha->isp_ops->fw_version_str(vha, eiter->a.fw_version,
1665             sizeof(eiter->a.fw_version));
1666         alen = strlen(eiter->a.fw_version);
1667         alen += 4 - (alen & 3);
1668         eiter->len = cpu_to_be16(4 + alen);
1669         size += 4 + alen;
1670
1671         ql_dbg(ql_dbg_disc, vha, 0x202d,
1672             "Firmware vers = %s.\n", eiter->a.fw_version);
1673
1674         /* Update MS request size. */
1675         qla2x00_update_ms_fdmi_iocb(vha, size + 16);
1676
1677         ql_dbg(ql_dbg_disc, vha, 0x202e,
1678             "RHBA identifier = %8phN size=%d.\n",
1679             ct_req->req.rhba.hba_identifier, size);
1680         ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2076,
1681             entries, size);
1682
1683         /* Execute MS IOCB */
1684         rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
1685             sizeof(ms_iocb_entry_t));
1686         if (rval != QLA_SUCCESS) {
1687                 /*EMPTY*/
1688                 ql_dbg(ql_dbg_disc, vha, 0x2030,
1689                     "RHBA issue IOCB failed (%d).\n", rval);
1690         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RHBA") !=
1691             QLA_SUCCESS) {
1692                 rval = QLA_FUNCTION_FAILED;
1693                 if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
1694                     ct_rsp->header.explanation_code ==
1695                     CT_EXPL_ALREADY_REGISTERED) {
1696                         ql_dbg(ql_dbg_disc, vha, 0x2034,
1697                             "HBA already registered.\n");
1698                         rval = QLA_ALREADY_REGISTERED;
1699                 } else {
1700                         ql_dbg(ql_dbg_disc, vha, 0x20ad,
1701                             "RHBA FDMI registration failed, CT Reason code: 0x%x, CT Explanation 0x%x\n",
1702                             ct_rsp->header.reason_code,
1703                             ct_rsp->header.explanation_code);
1704                 }
1705         } else {
1706                 ql_dbg(ql_dbg_disc, vha, 0x2035,
1707                     "RHBA exiting normally.\n");
1708         }
1709
1710         return rval;
1711 }
1712
1713 /**
1714  * qla2x00_fdmi_rpa() - perform RPA registration
1715  * @vha: HA context
1716  *
1717  * Returns 0 on success.
1718  */
1719 static int
1720 qla2x00_fdmi_rpa(scsi_qla_host_t *vha)
1721 {
1722         int rval, alen;
1723         uint32_t size;
1724         struct qla_hw_data *ha = vha->hw;
1725         ms_iocb_entry_t *ms_pkt;
1726         struct ct_sns_req *ct_req;
1727         struct ct_sns_rsp *ct_rsp;
1728         void *entries;
1729         struct ct_fdmi_port_attr *eiter;
1730         struct init_cb_24xx *icb24 = (struct init_cb_24xx *)ha->init_cb;
1731         struct new_utsname *p_sysid = NULL;
1732
1733         /* Issue RPA */
1734         /* Prepare common MS IOCB */
1735         /*   Request size adjusted after CT preparation */
1736         ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, RPA_RSP_SIZE);
1737
1738         /* Prepare CT request */
1739         ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RPA_CMD,
1740             RPA_RSP_SIZE);
1741         ct_rsp = &ha->ct_sns->p.rsp;
1742
1743         /* Prepare FDMI command arguments -- attribute block, attributes. */
1744         memcpy(ct_req->req.rpa.port_name, vha->port_name, WWN_SIZE);
1745         size = WWN_SIZE + 4;
1746
1747         /* Attributes */
1748         ct_req->req.rpa.attrs.count = cpu_to_be32(FDMI_PORT_ATTR_COUNT);
1749         entries = &ct_req->req;
1750
1751         /* FC4 types. */
1752         eiter = entries + size;
1753         eiter->type = cpu_to_be16(FDMI_PORT_FC4_TYPES);
1754         eiter->len = cpu_to_be16(4 + 32);
1755         eiter->a.fc4_types[2] = 0x01;
1756         size += 4 + 32;
1757
1758         ql_dbg(ql_dbg_disc, vha, 0x2039,
1759             "FC4_TYPES=%02x %02x.\n",
1760             eiter->a.fc4_types[2],
1761             eiter->a.fc4_types[1]);
1762
1763         /* Supported speed. */
1764         eiter = entries + size;
1765         eiter->type = cpu_to_be16(FDMI_PORT_SUPPORT_SPEED);
1766         eiter->len = cpu_to_be16(4 + 4);
1767         if (IS_CNA_CAPABLE(ha))
1768                 eiter->a.sup_speed = cpu_to_be32(
1769                     FDMI_PORT_SPEED_10GB);
1770         else if (IS_QLA27XX(ha) || IS_QLA28XX(ha))
1771                 eiter->a.sup_speed = cpu_to_be32(
1772                     FDMI_PORT_SPEED_32GB|
1773                     FDMI_PORT_SPEED_16GB|
1774                     FDMI_PORT_SPEED_8GB);
1775         else if (IS_QLA2031(ha))
1776                 eiter->a.sup_speed = cpu_to_be32(
1777                     FDMI_PORT_SPEED_16GB|
1778                     FDMI_PORT_SPEED_8GB|
1779                     FDMI_PORT_SPEED_4GB);
1780         else if (IS_QLA25XX(ha))
1781                 eiter->a.sup_speed = cpu_to_be32(
1782                     FDMI_PORT_SPEED_8GB|
1783                     FDMI_PORT_SPEED_4GB|
1784                     FDMI_PORT_SPEED_2GB|
1785                     FDMI_PORT_SPEED_1GB);
1786         else if (IS_QLA24XX_TYPE(ha))
1787                 eiter->a.sup_speed = cpu_to_be32(
1788                     FDMI_PORT_SPEED_4GB|
1789                     FDMI_PORT_SPEED_2GB|
1790                     FDMI_PORT_SPEED_1GB);
1791         else if (IS_QLA23XX(ha))
1792                 eiter->a.sup_speed = cpu_to_be32(
1793                     FDMI_PORT_SPEED_2GB|
1794                     FDMI_PORT_SPEED_1GB);
1795         else
1796                 eiter->a.sup_speed = cpu_to_be32(
1797                     FDMI_PORT_SPEED_1GB);
1798         size += 4 + 4;
1799
1800         ql_dbg(ql_dbg_disc, vha, 0x203a,
1801             "Supported_Speed=%x.\n", eiter->a.sup_speed);
1802
1803         /* Current speed. */
1804         eiter = entries + size;
1805         eiter->type = cpu_to_be16(FDMI_PORT_CURRENT_SPEED);
1806         eiter->len = cpu_to_be16(4 + 4);
1807         switch (ha->link_data_rate) {
1808         case PORT_SPEED_1GB:
1809                 eiter->a.cur_speed =
1810                     cpu_to_be32(FDMI_PORT_SPEED_1GB);
1811                 break;
1812         case PORT_SPEED_2GB:
1813                 eiter->a.cur_speed =
1814                     cpu_to_be32(FDMI_PORT_SPEED_2GB);
1815                 break;
1816         case PORT_SPEED_4GB:
1817                 eiter->a.cur_speed =
1818                     cpu_to_be32(FDMI_PORT_SPEED_4GB);
1819                 break;
1820         case PORT_SPEED_8GB:
1821                 eiter->a.cur_speed =
1822                     cpu_to_be32(FDMI_PORT_SPEED_8GB);
1823                 break;
1824         case PORT_SPEED_10GB:
1825                 eiter->a.cur_speed =
1826                     cpu_to_be32(FDMI_PORT_SPEED_10GB);
1827                 break;
1828         case PORT_SPEED_16GB:
1829                 eiter->a.cur_speed =
1830                     cpu_to_be32(FDMI_PORT_SPEED_16GB);
1831                 break;
1832         case PORT_SPEED_32GB:
1833                 eiter->a.cur_speed =
1834                     cpu_to_be32(FDMI_PORT_SPEED_32GB);
1835                 break;
1836         default:
1837                 eiter->a.cur_speed =
1838                     cpu_to_be32(FDMI_PORT_SPEED_UNKNOWN);
1839                 break;
1840         }
1841         size += 4 + 4;
1842
1843         ql_dbg(ql_dbg_disc, vha, 0x203b,
1844             "Current_Speed=%x.\n", eiter->a.cur_speed);
1845
1846         /* Max frame size. */
1847         eiter = entries + size;
1848         eiter->type = cpu_to_be16(FDMI_PORT_MAX_FRAME_SIZE);
1849         eiter->len = cpu_to_be16(4 + 4);
1850         eiter->a.max_frame_size = IS_FWI2_CAPABLE(ha) ?
1851             le16_to_cpu(icb24->frame_payload_size) :
1852             le16_to_cpu(ha->init_cb->frame_payload_size);
1853         eiter->a.max_frame_size = cpu_to_be32(eiter->a.max_frame_size);
1854         size += 4 + 4;
1855
1856         ql_dbg(ql_dbg_disc, vha, 0x203c,
1857             "Max_Frame_Size=%x.\n", eiter->a.max_frame_size);
1858
1859         /* OS device name. */
1860         eiter = entries + size;
1861         eiter->type = cpu_to_be16(FDMI_PORT_OS_DEVICE_NAME);
1862         snprintf(eiter->a.os_dev_name, sizeof(eiter->a.os_dev_name),
1863             "%s:host%lu", QLA2XXX_DRIVER_NAME, vha->host_no);
1864         alen = strlen(eiter->a.os_dev_name);
1865         alen += 4 - (alen & 3);
1866         eiter->len = cpu_to_be16(4 + alen);
1867         size += 4 + alen;
1868
1869         ql_dbg(ql_dbg_disc, vha, 0x204b,
1870             "OS_Device_Name=%s.\n", eiter->a.os_dev_name);
1871
1872         /* Hostname. */
1873         eiter = entries + size;
1874         eiter->type = cpu_to_be16(FDMI_PORT_HOST_NAME);
1875         p_sysid = utsname();
1876         if (p_sysid) {
1877                 snprintf(eiter->a.host_name, sizeof(eiter->a.host_name),
1878                     "%s", p_sysid->nodename);
1879         } else {
1880                 snprintf(eiter->a.host_name, sizeof(eiter->a.host_name),
1881                     "%s", fc_host_system_hostname(vha->host));
1882         }
1883         alen = strlen(eiter->a.host_name);
1884         alen += 4 - (alen & 3);
1885         eiter->len = cpu_to_be16(4 + alen);
1886         size += 4 + alen;
1887
1888         ql_dbg(ql_dbg_disc, vha, 0x203d, "HostName=%s.\n", eiter->a.host_name);
1889
1890         /* Update MS request size. */
1891         qla2x00_update_ms_fdmi_iocb(vha, size + 16);
1892
1893         ql_dbg(ql_dbg_disc, vha, 0x203e,
1894             "RPA portname  %016llx, size = %d.\n",
1895             wwn_to_u64(ct_req->req.rpa.port_name), size);
1896         ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x2079,
1897             entries, size);
1898
1899         /* Execute MS IOCB */
1900         rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
1901             sizeof(ms_iocb_entry_t));
1902         if (rval != QLA_SUCCESS) {
1903                 /*EMPTY*/
1904                 ql_dbg(ql_dbg_disc, vha, 0x2040,
1905                     "RPA issue IOCB failed (%d).\n", rval);
1906         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RPA") !=
1907             QLA_SUCCESS) {
1908                 rval = QLA_FUNCTION_FAILED;
1909                 if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
1910                     ct_rsp->header.explanation_code ==
1911                     CT_EXPL_ALREADY_REGISTERED) {
1912                         ql_dbg(ql_dbg_disc, vha, 0x20cd,
1913                             "RPA already registered.\n");
1914                         rval = QLA_ALREADY_REGISTERED;
1915                 }
1916
1917         } else {
1918                 ql_dbg(ql_dbg_disc, vha, 0x2041,
1919                     "RPA exiting normally.\n");
1920         }
1921
1922         return rval;
1923 }
1924
1925 /**
1926  * qla2x00_fdmiv2_rhba() - perform RHBA FDMI v2 registration
1927  * @vha: HA context
1928  *
1929  * Returns 0 on success.
1930  */
1931 static int
1932 qla2x00_fdmiv2_rhba(scsi_qla_host_t *vha)
1933 {
1934         int rval, alen;
1935         uint32_t size, sn;
1936         ms_iocb_entry_t *ms_pkt;
1937         struct ct_sns_req *ct_req;
1938         struct ct_sns_rsp *ct_rsp;
1939         void *entries;
1940         struct ct_fdmiv2_hba_attr *eiter;
1941         struct qla_hw_data *ha = vha->hw;
1942         struct new_utsname *p_sysid = NULL;
1943
1944         /* Issue RHBA */
1945         /* Prepare common MS IOCB */
1946         /*   Request size adjusted after CT preparation */
1947         ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, RHBA_RSP_SIZE);
1948
1949         /* Prepare CT request */
1950         ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RHBA_CMD,
1951             RHBA_RSP_SIZE);
1952         ct_rsp = &ha->ct_sns->p.rsp;
1953
1954         /* Prepare FDMI command arguments -- attribute block, attributes. */
1955         memcpy(ct_req->req.rhba2.hba_identifier, vha->port_name, WWN_SIZE);
1956         ct_req->req.rhba2.entry_count = cpu_to_be32(1);
1957         memcpy(ct_req->req.rhba2.port_name, vha->port_name, WWN_SIZE);
1958         size = 2 * WWN_SIZE + 4 + 4;
1959
1960         /* Attributes */
1961         ct_req->req.rhba2.attrs.count = cpu_to_be32(FDMIV2_HBA_ATTR_COUNT);
1962         entries = &ct_req->req;
1963
1964         /* Nodename. */
1965         eiter = entries + size;
1966         eiter->type = cpu_to_be16(FDMI_HBA_NODE_NAME);
1967         eiter->len = cpu_to_be16(4 + WWN_SIZE);
1968         memcpy(eiter->a.node_name, vha->node_name, WWN_SIZE);
1969         size += 4 + WWN_SIZE;
1970
1971         ql_dbg(ql_dbg_disc, vha, 0x207d,
1972             "NodeName = %016llx.\n", wwn_to_u64(eiter->a.node_name));
1973
1974         /* Manufacturer. */
1975         eiter = entries + size;
1976         eiter->type = cpu_to_be16(FDMI_HBA_MANUFACTURER);
1977         snprintf(eiter->a.manufacturer, sizeof(eiter->a.manufacturer),
1978             "%s", "QLogic Corporation");
1979         eiter->a.manufacturer[strlen("QLogic Corporation")] = '\0';
1980         alen = strlen(eiter->a.manufacturer);
1981         alen += 4 - (alen & 3);
1982         eiter->len = cpu_to_be16(4 + alen);
1983         size += 4 + alen;
1984
1985         ql_dbg(ql_dbg_disc, vha, 0x20a5,
1986             "Manufacturer = %s.\n", eiter->a.manufacturer);
1987
1988         /* Serial number. */
1989         eiter = entries + size;
1990         eiter->type = cpu_to_be16(FDMI_HBA_SERIAL_NUMBER);
1991         if (IS_FWI2_CAPABLE(ha))
1992                 qla2xxx_get_vpd_field(vha, "SN", eiter->a.serial_num,
1993                     sizeof(eiter->a.serial_num));
1994         else {
1995                 sn = ((ha->serial0 & 0x1f) << 16) |
1996                         (ha->serial2 << 8) | ha->serial1;
1997                 snprintf(eiter->a.serial_num, sizeof(eiter->a.serial_num),
1998                     "%c%05d", 'A' + sn / 100000, sn % 100000);
1999         }
2000         alen = strlen(eiter->a.serial_num);
2001         alen += 4 - (alen & 3);
2002         eiter->len = cpu_to_be16(4 + alen);
2003         size += 4 + alen;
2004
2005         ql_dbg(ql_dbg_disc, vha, 0x20a6,
2006             "Serial no. = %s.\n", eiter->a.serial_num);
2007
2008         /* Model name. */
2009         eiter = entries + size;
2010         eiter->type = cpu_to_be16(FDMI_HBA_MODEL);
2011         snprintf(eiter->a.model, sizeof(eiter->a.model),
2012             "%s", ha->model_number);
2013         alen = strlen(eiter->a.model);
2014         alen += 4 - (alen & 3);
2015         eiter->len = cpu_to_be16(4 + alen);
2016         size += 4 + alen;
2017
2018         ql_dbg(ql_dbg_disc, vha, 0x20a7,
2019             "Model Name = %s.\n", eiter->a.model);
2020
2021         /* Model description. */
2022         eiter = entries + size;
2023         eiter->type = cpu_to_be16(FDMI_HBA_MODEL_DESCRIPTION);
2024         snprintf(eiter->a.model_desc, sizeof(eiter->a.model_desc),
2025             "%s", ha->model_desc);
2026         alen = strlen(eiter->a.model_desc);
2027         alen += 4 - (alen & 3);
2028         eiter->len = cpu_to_be16(4 + alen);
2029         size += 4 + alen;
2030
2031         ql_dbg(ql_dbg_disc, vha, 0x20a8,
2032             "Model Desc = %s.\n", eiter->a.model_desc);
2033
2034         /* Hardware version. */
2035         eiter = entries + size;
2036         eiter->type = cpu_to_be16(FDMI_HBA_HARDWARE_VERSION);
2037         if (!IS_FWI2_CAPABLE(ha)) {
2038                 snprintf(eiter->a.hw_version, sizeof(eiter->a.hw_version),
2039                     "HW:%s", ha->adapter_id);
2040         } else if (qla2xxx_get_vpd_field(vha, "MN", eiter->a.hw_version,
2041                     sizeof(eiter->a.hw_version))) {
2042                 ;
2043         } else if (qla2xxx_get_vpd_field(vha, "EC", eiter->a.hw_version,
2044                     sizeof(eiter->a.hw_version))) {
2045                 ;
2046         } else {
2047                 snprintf(eiter->a.hw_version, sizeof(eiter->a.hw_version),
2048                     "HW:%s", ha->adapter_id);
2049         }
2050         alen = strlen(eiter->a.hw_version);
2051         alen += 4 - (alen & 3);
2052         eiter->len = cpu_to_be16(4 + alen);
2053         size += 4 + alen;
2054
2055         ql_dbg(ql_dbg_disc, vha, 0x20a9,
2056             "Hardware ver = %s.\n", eiter->a.hw_version);
2057
2058         /* Driver version. */
2059         eiter = entries + size;
2060         eiter->type = cpu_to_be16(FDMI_HBA_DRIVER_VERSION);
2061         snprintf(eiter->a.driver_version, sizeof(eiter->a.driver_version),
2062             "%s", qla2x00_version_str);
2063         alen = strlen(eiter->a.driver_version);
2064         alen += 4 - (alen & 3);
2065         eiter->len = cpu_to_be16(4 + alen);
2066         size += 4 + alen;
2067
2068         ql_dbg(ql_dbg_disc, vha, 0x20aa,
2069             "Driver ver = %s.\n", eiter->a.driver_version);
2070
2071         /* Option ROM version. */
2072         eiter = entries + size;
2073         eiter->type = cpu_to_be16(FDMI_HBA_OPTION_ROM_VERSION);
2074         snprintf(eiter->a.orom_version, sizeof(eiter->a.orom_version),
2075             "%d.%02d", ha->bios_revision[1], ha->bios_revision[0]);
2076         alen = strlen(eiter->a.orom_version);
2077         alen += 4 - (alen & 3);
2078         eiter->len = cpu_to_be16(4 + alen);
2079         size += 4 + alen;
2080
2081         ql_dbg(ql_dbg_disc, vha , 0x20ab,
2082             "Optrom version = %d.%02d.\n", eiter->a.orom_version[1],
2083             eiter->a.orom_version[0]);
2084
2085         /* Firmware version */
2086         eiter = entries + size;
2087         eiter->type = cpu_to_be16(FDMI_HBA_FIRMWARE_VERSION);
2088         ha->isp_ops->fw_version_str(vha, eiter->a.fw_version,
2089             sizeof(eiter->a.fw_version));
2090         alen = strlen(eiter->a.fw_version);
2091         alen += 4 - (alen & 3);
2092         eiter->len = cpu_to_be16(4 + alen);
2093         size += 4 + alen;
2094
2095         ql_dbg(ql_dbg_disc, vha, 0x20ac,
2096             "Firmware vers = %s.\n", eiter->a.fw_version);
2097
2098         /* OS Name and Version */
2099         eiter = entries + size;
2100         eiter->type = cpu_to_be16(FDMI_HBA_OS_NAME_AND_VERSION);
2101         p_sysid = utsname();
2102         if (p_sysid) {
2103                 snprintf(eiter->a.os_version, sizeof(eiter->a.os_version),
2104                     "%s %s %s",
2105                     p_sysid->sysname, p_sysid->release, p_sysid->version);
2106         } else {
2107                 snprintf(eiter->a.os_version, sizeof(eiter->a.os_version),
2108                     "%s %s", "Linux", fc_host_system_hostname(vha->host));
2109         }
2110         alen = strlen(eiter->a.os_version);
2111         alen += 4 - (alen & 3);
2112         eiter->len = cpu_to_be16(4 + alen);
2113         size += 4 + alen;
2114
2115         ql_dbg(ql_dbg_disc, vha, 0x20ae,
2116             "OS Name and Version = %s.\n", eiter->a.os_version);
2117
2118         /* MAX CT Payload Length */
2119         eiter = entries + size;
2120         eiter->type = cpu_to_be16(FDMI_HBA_MAXIMUM_CT_PAYLOAD_LENGTH);
2121         eiter->a.max_ct_len = cpu_to_be32(ha->frame_payload_size);
2122         eiter->a.max_ct_len = cpu_to_be32(eiter->a.max_ct_len);
2123         eiter->len = cpu_to_be16(4 + 4);
2124         size += 4 + 4;
2125
2126         ql_dbg(ql_dbg_disc, vha, 0x20af,
2127             "CT Payload Length = 0x%x.\n", eiter->a.max_ct_len);
2128
2129         /* Node Sybolic Name */
2130         eiter = entries + size;
2131         eiter->type = cpu_to_be16(FDMI_HBA_NODE_SYMBOLIC_NAME);
2132         qla2x00_get_sym_node_name(vha, eiter->a.sym_name,
2133             sizeof(eiter->a.sym_name));
2134         alen = strlen(eiter->a.sym_name);
2135         alen += 4 - (alen & 3);
2136         eiter->len = cpu_to_be16(4 + alen);
2137         size += 4 + alen;
2138
2139         ql_dbg(ql_dbg_disc, vha, 0x20b0,
2140             "Symbolic Name = %s.\n", eiter->a.sym_name);
2141
2142         /* Vendor Id */
2143         eiter = entries + size;
2144         eiter->type = cpu_to_be16(FDMI_HBA_VENDOR_ID);
2145         eiter->a.vendor_id = cpu_to_be32(0x1077);
2146         eiter->len = cpu_to_be16(4 + 4);
2147         size += 4 + 4;
2148
2149         ql_dbg(ql_dbg_disc, vha, 0x20b1,
2150             "Vendor Id = %x.\n", eiter->a.vendor_id);
2151
2152         /* Num Ports */
2153         eiter = entries + size;
2154         eiter->type = cpu_to_be16(FDMI_HBA_NUM_PORTS);
2155         eiter->a.num_ports = cpu_to_be32(1);
2156         eiter->len = cpu_to_be16(4 + 4);
2157         size += 4 + 4;
2158
2159         ql_dbg(ql_dbg_disc, vha, 0x20b2,
2160             "Port Num = %x.\n", eiter->a.num_ports);
2161
2162         /* Fabric Name */
2163         eiter = entries + size;
2164         eiter->type = cpu_to_be16(FDMI_HBA_FABRIC_NAME);
2165         memcpy(eiter->a.fabric_name, vha->fabric_node_name, WWN_SIZE);
2166         eiter->len = cpu_to_be16(4 + WWN_SIZE);
2167         size += 4 + WWN_SIZE;
2168
2169         ql_dbg(ql_dbg_disc, vha, 0x20b3,
2170             "Fabric Name = %016llx.\n", wwn_to_u64(eiter->a.fabric_name));
2171
2172         /* BIOS Version */
2173         eiter = entries + size;
2174         eiter->type = cpu_to_be16(FDMI_HBA_BOOT_BIOS_NAME);
2175         snprintf(eiter->a.bios_name, sizeof(eiter->a.bios_name),
2176             "BIOS %d.%02d", ha->bios_revision[1], ha->bios_revision[0]);
2177         alen = strlen(eiter->a.bios_name);
2178         alen += 4 - (alen & 3);
2179         eiter->len = cpu_to_be16(4 + alen);
2180         size += 4 + alen;
2181
2182         ql_dbg(ql_dbg_disc, vha, 0x20b4,
2183             "BIOS Name = %s\n", eiter->a.bios_name);
2184
2185         /* Vendor Identifier */
2186         eiter = entries + size;
2187         eiter->type = cpu_to_be16(FDMI_HBA_TYPE_VENDOR_IDENTIFIER);
2188         snprintf(eiter->a.vendor_identifier, sizeof(eiter->a.vendor_identifier),
2189             "%s", "QLGC");
2190         alen = strlen(eiter->a.vendor_identifier);
2191         alen += 4 - (alen & 3);
2192         eiter->len = cpu_to_be16(4 + alen);
2193         size += 4 + alen;
2194
2195         ql_dbg(ql_dbg_disc, vha, 0x201b,
2196             "Vendor Identifier = %s.\n", eiter->a.vendor_identifier);
2197
2198         /* Update MS request size. */
2199         qla2x00_update_ms_fdmi_iocb(vha, size + 16);
2200
2201         ql_dbg(ql_dbg_disc, vha, 0x20b5,
2202             "RHBA identifier = %016llx.\n",
2203             wwn_to_u64(ct_req->req.rhba2.hba_identifier));
2204         ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x20b6,
2205             entries, size);
2206
2207         /* Execute MS IOCB */
2208         rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2209             sizeof(ms_iocb_entry_t));
2210         if (rval != QLA_SUCCESS) {
2211                 /*EMPTY*/
2212                 ql_dbg(ql_dbg_disc, vha, 0x20b7,
2213                     "RHBA issue IOCB failed (%d).\n", rval);
2214         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RHBA") !=
2215             QLA_SUCCESS) {
2216                 rval = QLA_FUNCTION_FAILED;
2217
2218                 if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
2219                     ct_rsp->header.explanation_code ==
2220                     CT_EXPL_ALREADY_REGISTERED) {
2221                         ql_dbg(ql_dbg_disc, vha, 0x20b8,
2222                             "HBA already registered.\n");
2223                         rval = QLA_ALREADY_REGISTERED;
2224                 } else {
2225                         ql_dbg(ql_dbg_disc, vha, 0x2016,
2226                             "RHBA FDMI v2 failed, CT Reason code: 0x%x, CT Explanation 0x%x\n",
2227                             ct_rsp->header.reason_code,
2228                             ct_rsp->header.explanation_code);
2229                 }
2230         } else {
2231                 ql_dbg(ql_dbg_disc, vha, 0x20b9,
2232                     "RHBA FDMI V2 exiting normally.\n");
2233         }
2234
2235         return rval;
2236 }
2237
2238 /**
2239  * qla2x00_fdmi_dhba() -
2240  * @vha: HA context
2241  *
2242  * Returns 0 on success.
2243  */
2244 static int
2245 qla2x00_fdmi_dhba(scsi_qla_host_t *vha)
2246 {
2247         int rval;
2248         struct qla_hw_data *ha = vha->hw;
2249         ms_iocb_entry_t *ms_pkt;
2250         struct ct_sns_req *ct_req;
2251         struct ct_sns_rsp *ct_rsp;
2252
2253         /* Issue RPA */
2254         /* Prepare common MS IOCB */
2255         ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, DHBA_REQ_SIZE,
2256             DHBA_RSP_SIZE);
2257
2258         /* Prepare CT request */
2259         ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, DHBA_CMD, DHBA_RSP_SIZE);
2260         ct_rsp = &ha->ct_sns->p.rsp;
2261
2262         /* Prepare FDMI command arguments -- portname. */
2263         memcpy(ct_req->req.dhba.port_name, vha->port_name, WWN_SIZE);
2264
2265         ql_dbg(ql_dbg_disc, vha, 0x2036,
2266             "DHBA portname = %8phN.\n", ct_req->req.dhba.port_name);
2267
2268         /* Execute MS IOCB */
2269         rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2270             sizeof(ms_iocb_entry_t));
2271         if (rval != QLA_SUCCESS) {
2272                 /*EMPTY*/
2273                 ql_dbg(ql_dbg_disc, vha, 0x2037,
2274                     "DHBA issue IOCB failed (%d).\n", rval);
2275         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "DHBA") !=
2276             QLA_SUCCESS) {
2277                 rval = QLA_FUNCTION_FAILED;
2278         } else {
2279                 ql_dbg(ql_dbg_disc, vha, 0x2038,
2280                     "DHBA exiting normally.\n");
2281         }
2282
2283         return rval;
2284 }
2285
2286 /**
2287  * qla2x00_fdmiv2_rpa() -
2288  * @vha: HA context
2289  *
2290  * Returns 0 on success.
2291  */
2292 static int
2293 qla2x00_fdmiv2_rpa(scsi_qla_host_t *vha)
2294 {
2295         int rval, alen;
2296         uint32_t size;
2297         struct qla_hw_data *ha = vha->hw;
2298         ms_iocb_entry_t *ms_pkt;
2299         struct ct_sns_req *ct_req;
2300         struct ct_sns_rsp *ct_rsp;
2301         void *entries;
2302         struct ct_fdmiv2_port_attr *eiter;
2303         struct init_cb_24xx *icb24 = (struct init_cb_24xx *)ha->init_cb;
2304         struct new_utsname *p_sysid = NULL;
2305
2306         /* Issue RPA */
2307         /* Prepare common MS IOCB */
2308         /*   Request size adjusted after CT preparation */
2309         ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, RPA_RSP_SIZE);
2310
2311         /* Prepare CT request */
2312         ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RPA_CMD, RPA_RSP_SIZE);
2313         ct_rsp = &ha->ct_sns->p.rsp;
2314
2315         /* Prepare FDMI command arguments -- attribute block, attributes. */
2316         memcpy(ct_req->req.rpa2.port_name, vha->port_name, WWN_SIZE);
2317         size = WWN_SIZE + 4;
2318
2319         /* Attributes */
2320         ct_req->req.rpa2.attrs.count = cpu_to_be32(FDMIV2_PORT_ATTR_COUNT);
2321         entries = &ct_req->req;
2322
2323         /* FC4 types. */
2324         eiter = entries + size;
2325         eiter->type = cpu_to_be16(FDMI_PORT_FC4_TYPES);
2326         eiter->len = cpu_to_be16(4 + 32);
2327         eiter->a.fc4_types[2] = 0x01;
2328         size += 4 + 32;
2329
2330         ql_dbg(ql_dbg_disc, vha, 0x20ba,
2331             "FC4_TYPES=%02x %02x.\n",
2332             eiter->a.fc4_types[2],
2333             eiter->a.fc4_types[1]);
2334
2335         if (vha->flags.nvme_enabled) {
2336                 eiter->a.fc4_types[6] = 1;      /* NVMe type 28h */
2337                 ql_dbg(ql_dbg_disc, vha, 0x211f,
2338                     "NVME FC4 Type = %02x 0x0 0x0 0x0 0x0 0x0.\n",
2339                     eiter->a.fc4_types[6]);
2340         }
2341
2342         /* Supported speed. */
2343         eiter = entries + size;
2344         eiter->type = cpu_to_be16(FDMI_PORT_SUPPORT_SPEED);
2345         eiter->len = cpu_to_be16(4 + 4);
2346         if (IS_CNA_CAPABLE(ha))
2347                 eiter->a.sup_speed = cpu_to_be32(
2348                     FDMI_PORT_SPEED_10GB);
2349         else if (IS_QLA27XX(ha) || IS_QLA28XX(ha))
2350                 eiter->a.sup_speed = cpu_to_be32(
2351                     FDMI_PORT_SPEED_32GB|
2352                     FDMI_PORT_SPEED_16GB|
2353                     FDMI_PORT_SPEED_8GB);
2354         else if (IS_QLA2031(ha))
2355                 eiter->a.sup_speed = cpu_to_be32(
2356                     FDMI_PORT_SPEED_16GB|
2357                     FDMI_PORT_SPEED_8GB|
2358                     FDMI_PORT_SPEED_4GB);
2359         else if (IS_QLA25XX(ha))
2360                 eiter->a.sup_speed = cpu_to_be32(
2361                     FDMI_PORT_SPEED_8GB|
2362                     FDMI_PORT_SPEED_4GB|
2363                     FDMI_PORT_SPEED_2GB|
2364                     FDMI_PORT_SPEED_1GB);
2365         else if (IS_QLA24XX_TYPE(ha))
2366                 eiter->a.sup_speed = cpu_to_be32(
2367                     FDMI_PORT_SPEED_4GB|
2368                     FDMI_PORT_SPEED_2GB|
2369                     FDMI_PORT_SPEED_1GB);
2370         else if (IS_QLA23XX(ha))
2371                 eiter->a.sup_speed = cpu_to_be32(
2372                     FDMI_PORT_SPEED_2GB|
2373                     FDMI_PORT_SPEED_1GB);
2374         else
2375                 eiter->a.sup_speed = cpu_to_be32(
2376                     FDMI_PORT_SPEED_1GB);
2377         size += 4 + 4;
2378
2379         ql_dbg(ql_dbg_disc, vha, 0x20bb,
2380             "Supported Port Speed = %x.\n", eiter->a.sup_speed);
2381
2382         /* Current speed. */
2383         eiter = entries + size;
2384         eiter->type = cpu_to_be16(FDMI_PORT_CURRENT_SPEED);
2385         eiter->len = cpu_to_be16(4 + 4);
2386         switch (ha->link_data_rate) {
2387         case PORT_SPEED_1GB:
2388                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_1GB);
2389                 break;
2390         case PORT_SPEED_2GB:
2391                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_2GB);
2392                 break;
2393         case PORT_SPEED_4GB:
2394                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_4GB);
2395                 break;
2396         case PORT_SPEED_8GB:
2397                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_8GB);
2398                 break;
2399         case PORT_SPEED_10GB:
2400                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_10GB);
2401                 break;
2402         case PORT_SPEED_16GB:
2403                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_16GB);
2404                 break;
2405         case PORT_SPEED_32GB:
2406                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_32GB);
2407                 break;
2408         default:
2409                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_UNKNOWN);
2410                 break;
2411         }
2412         size += 4 + 4;
2413
2414         ql_dbg(ql_dbg_disc, vha, 0x2017,
2415             "Current_Speed = %x.\n", eiter->a.cur_speed);
2416
2417         /* Max frame size. */
2418         eiter = entries + size;
2419         eiter->type = cpu_to_be16(FDMI_PORT_MAX_FRAME_SIZE);
2420         eiter->len = cpu_to_be16(4 + 4);
2421         eiter->a.max_frame_size = IS_FWI2_CAPABLE(ha) ?
2422             le16_to_cpu(icb24->frame_payload_size) :
2423             le16_to_cpu(ha->init_cb->frame_payload_size);
2424         eiter->a.max_frame_size = cpu_to_be32(eiter->a.max_frame_size);
2425         size += 4 + 4;
2426
2427         ql_dbg(ql_dbg_disc, vha, 0x20bc,
2428             "Max_Frame_Size = %x.\n", eiter->a.max_frame_size);
2429
2430         /* OS device name. */
2431         eiter = entries + size;
2432         eiter->type = cpu_to_be16(FDMI_PORT_OS_DEVICE_NAME);
2433         alen = strlen(QLA2XXX_DRIVER_NAME);
2434         snprintf(eiter->a.os_dev_name, sizeof(eiter->a.os_dev_name),
2435             "%s:host%lu", QLA2XXX_DRIVER_NAME, vha->host_no);
2436         alen += 4 - (alen & 3);
2437         eiter->len = cpu_to_be16(4 + alen);
2438         size += 4 + alen;
2439
2440         ql_dbg(ql_dbg_disc, vha, 0x20be,
2441             "OS_Device_Name = %s.\n", eiter->a.os_dev_name);
2442
2443         /* Hostname. */
2444         eiter = entries + size;
2445         eiter->type = cpu_to_be16(FDMI_PORT_HOST_NAME);
2446         p_sysid = utsname();
2447         if (p_sysid) {
2448                 snprintf(eiter->a.host_name, sizeof(eiter->a.host_name),
2449                     "%s", p_sysid->nodename);
2450         } else {
2451                 snprintf(eiter->a.host_name, sizeof(eiter->a.host_name),
2452                     "%s", fc_host_system_hostname(vha->host));
2453         }
2454         alen = strlen(eiter->a.host_name);
2455         alen += 4 - (alen & 3);
2456         eiter->len = cpu_to_be16(4 + alen);
2457         size += 4 + alen;
2458
2459         ql_dbg(ql_dbg_disc, vha, 0x201a,
2460             "HostName=%s.\n", eiter->a.host_name);
2461
2462         /* Node Name */
2463         eiter = entries + size;
2464         eiter->type = cpu_to_be16(FDMI_PORT_NODE_NAME);
2465         memcpy(eiter->a.node_name, vha->node_name, WWN_SIZE);
2466         eiter->len = cpu_to_be16(4 + WWN_SIZE);
2467         size += 4 + WWN_SIZE;
2468
2469         ql_dbg(ql_dbg_disc, vha, 0x20c0,
2470             "Node Name = %016llx.\n", wwn_to_u64(eiter->a.node_name));
2471
2472         /* Port Name */
2473         eiter = entries + size;
2474         eiter->type = cpu_to_be16(FDMI_PORT_NAME);
2475         memcpy(eiter->a.port_name, vha->port_name, WWN_SIZE);
2476         eiter->len = cpu_to_be16(4 + WWN_SIZE);
2477         size += 4 + WWN_SIZE;
2478
2479         ql_dbg(ql_dbg_disc, vha, 0x20c1,
2480             "Port Name = %016llx.\n", wwn_to_u64(eiter->a.port_name));
2481
2482         /* Port Symbolic Name */
2483         eiter = entries + size;
2484         eiter->type = cpu_to_be16(FDMI_PORT_SYM_NAME);
2485         qla2x00_get_sym_node_name(vha, eiter->a.port_sym_name,
2486             sizeof(eiter->a.port_sym_name));
2487         alen = strlen(eiter->a.port_sym_name);
2488         alen += 4 - (alen & 3);
2489         eiter->len = cpu_to_be16(4 + alen);
2490         size += 4 + alen;
2491
2492         ql_dbg(ql_dbg_disc, vha, 0x20c2,
2493             "port symbolic name = %s\n", eiter->a.port_sym_name);
2494
2495         /* Port Type */
2496         eiter = entries + size;
2497         eiter->type = cpu_to_be16(FDMI_PORT_TYPE);
2498         eiter->a.port_type = cpu_to_be32(NS_NX_PORT_TYPE);
2499         eiter->len = cpu_to_be16(4 + 4);
2500         size += 4 + 4;
2501
2502         ql_dbg(ql_dbg_disc, vha, 0x20c3,
2503             "Port Type = %x.\n", eiter->a.port_type);
2504
2505         /* Class of Service  */
2506         eiter = entries + size;
2507         eiter->type = cpu_to_be16(FDMI_PORT_SUPP_COS);
2508         eiter->a.port_supported_cos = cpu_to_be32(FC_CLASS_3);
2509         eiter->len = cpu_to_be16(4 + 4);
2510         size += 4 + 4;
2511
2512         ql_dbg(ql_dbg_disc, vha, 0x20c4,
2513             "Supported COS = %08x\n", eiter->a.port_supported_cos);
2514
2515         /* Port Fabric Name */
2516         eiter = entries + size;
2517         eiter->type = cpu_to_be16(FDMI_PORT_FABRIC_NAME);
2518         memcpy(eiter->a.fabric_name, vha->fabric_node_name, WWN_SIZE);
2519         eiter->len = cpu_to_be16(4 + WWN_SIZE);
2520         size += 4 + WWN_SIZE;
2521
2522         ql_dbg(ql_dbg_disc, vha, 0x20c5,
2523             "Fabric Name = %016llx.\n", wwn_to_u64(eiter->a.fabric_name));
2524
2525         /* FC4_type */
2526         eiter = entries + size;
2527         eiter->type = cpu_to_be16(FDMI_PORT_FC4_TYPE);
2528         eiter->a.port_fc4_type[0] = 0;
2529         eiter->a.port_fc4_type[1] = 0;
2530         eiter->a.port_fc4_type[2] = 1;
2531         eiter->a.port_fc4_type[3] = 0;
2532         eiter->len = cpu_to_be16(4 + 32);
2533         size += 4 + 32;
2534
2535         ql_dbg(ql_dbg_disc, vha, 0x20c6,
2536             "Port Active FC4 Type = %02x %02x.\n",
2537             eiter->a.port_fc4_type[2], eiter->a.port_fc4_type[1]);
2538
2539         if (vha->flags.nvme_enabled) {
2540                 eiter->a.port_fc4_type[4] = 0;
2541                 eiter->a.port_fc4_type[5] = 0;
2542                 eiter->a.port_fc4_type[6] = 1;  /* NVMe type 28h */
2543                 ql_dbg(ql_dbg_disc, vha, 0x2120,
2544                     "NVME Port Active FC4 Type = %02x 0x0 0x0 0x0 0x0 0x0.\n",
2545                     eiter->a.port_fc4_type[6]);
2546         }
2547
2548         /* Port State */
2549         eiter = entries + size;
2550         eiter->type = cpu_to_be16(FDMI_PORT_STATE);
2551         eiter->a.port_state = cpu_to_be32(1);
2552         eiter->len = cpu_to_be16(4 + 4);
2553         size += 4 + 4;
2554
2555         ql_dbg(ql_dbg_disc, vha, 0x20c7,
2556             "Port State = %x.\n", eiter->a.port_state);
2557
2558         /* Number of Ports */
2559         eiter = entries + size;
2560         eiter->type = cpu_to_be16(FDMI_PORT_COUNT);
2561         eiter->a.num_ports = cpu_to_be32(1);
2562         eiter->len = cpu_to_be16(4 + 4);
2563         size += 4 + 4;
2564
2565         ql_dbg(ql_dbg_disc, vha, 0x20c8,
2566             "Number of ports = %x.\n", eiter->a.num_ports);
2567
2568         /* Port Id */
2569         eiter = entries + size;
2570         eiter->type = cpu_to_be16(FDMI_PORT_ID);
2571         eiter->a.port_id = cpu_to_be32(vha->d_id.b24);
2572         eiter->len = cpu_to_be16(4 + 4);
2573         size += 4 + 4;
2574
2575         ql_dbg(ql_dbg_disc, vha, 0x201c,
2576             "Port Id = %x.\n", eiter->a.port_id);
2577
2578         /* Update MS request size. */
2579         qla2x00_update_ms_fdmi_iocb(vha, size + 16);
2580
2581         ql_dbg(ql_dbg_disc, vha, 0x2018,
2582             "RPA portname= %8phN size=%d.\n", ct_req->req.rpa.port_name, size);
2583         ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x20ca,
2584             entries, size);
2585
2586         /* Execute MS IOCB */
2587         rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2588             sizeof(ms_iocb_entry_t));
2589         if (rval != QLA_SUCCESS) {
2590                 /*EMPTY*/
2591                 ql_dbg(ql_dbg_disc, vha, 0x20cb,
2592                     "RPA FDMI v2 issue IOCB failed (%d).\n", rval);
2593         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RPA") !=
2594             QLA_SUCCESS) {
2595                 rval = QLA_FUNCTION_FAILED;
2596                 if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
2597                     ct_rsp->header.explanation_code ==
2598                     CT_EXPL_ALREADY_REGISTERED) {
2599                         ql_dbg(ql_dbg_disc, vha, 0x20ce,
2600                             "RPA FDMI v2 already registered\n");
2601                         rval = QLA_ALREADY_REGISTERED;
2602                 } else {
2603                         ql_dbg(ql_dbg_disc, vha, 0x2020,
2604                             "RPA FDMI v2 failed, CT Reason code: 0x%x, CT Explanation 0x%x\n",
2605                             ct_rsp->header.reason_code,
2606                             ct_rsp->header.explanation_code);
2607                 }
2608         } else {
2609                 ql_dbg(ql_dbg_disc, vha, 0x20cc,
2610                     "RPA FDMI V2 exiting normally.\n");
2611         }
2612
2613         return rval;
2614 }
2615
2616 /**
2617  * qla2x00_fdmi_register() -
2618  * @vha: HA context
2619  *
2620  * Returns 0 on success.
2621  */
2622 int
2623 qla2x00_fdmi_register(scsi_qla_host_t *vha)
2624 {
2625         int rval = QLA_FUNCTION_FAILED;
2626         struct qla_hw_data *ha = vha->hw;
2627
2628         if (IS_QLA2100(ha) || IS_QLA2200(ha) ||
2629             IS_QLAFX00(ha))
2630                 return QLA_FUNCTION_FAILED;
2631
2632         rval = qla2x00_mgmt_svr_login(vha);
2633         if (rval)
2634                 return rval;
2635
2636         rval = qla2x00_fdmiv2_rhba(vha);
2637         if (rval) {
2638                 if (rval != QLA_ALREADY_REGISTERED)
2639                         goto try_fdmi;
2640
2641                 rval = qla2x00_fdmi_dhba(vha);
2642                 if (rval)
2643                         goto try_fdmi;
2644
2645                 rval = qla2x00_fdmiv2_rhba(vha);
2646                 if (rval)
2647                         goto try_fdmi;
2648         }
2649         rval = qla2x00_fdmiv2_rpa(vha);
2650         if (rval)
2651                 goto try_fdmi;
2652
2653         goto out;
2654
2655 try_fdmi:
2656         rval = qla2x00_fdmi_rhba(vha);
2657         if (rval) {
2658                 if (rval != QLA_ALREADY_REGISTERED)
2659                         return rval;
2660
2661                 rval = qla2x00_fdmi_dhba(vha);
2662                 if (rval)
2663                         return rval;
2664
2665                 rval = qla2x00_fdmi_rhba(vha);
2666                 if (rval)
2667                         return rval;
2668         }
2669         rval = qla2x00_fdmi_rpa(vha);
2670 out:
2671         return rval;
2672 }
2673
2674 /**
2675  * qla2x00_gfpn_id() - SNS Get Fabric Port Name (GFPN_ID) query.
2676  * @vha: HA context
2677  * @list: switch info entries to populate
2678  *
2679  * Returns 0 on success.
2680  */
2681 int
2682 qla2x00_gfpn_id(scsi_qla_host_t *vha, sw_info_t *list)
2683 {
2684         int             rval = QLA_SUCCESS;
2685         uint16_t        i;
2686         struct qla_hw_data *ha = vha->hw;
2687         ms_iocb_entry_t *ms_pkt;
2688         struct ct_sns_req       *ct_req;
2689         struct ct_sns_rsp       *ct_rsp;
2690         struct ct_arg arg;
2691
2692         if (!IS_IIDMA_CAPABLE(ha))
2693                 return QLA_FUNCTION_FAILED;
2694
2695         arg.iocb = ha->ms_iocb;
2696         arg.req_dma = ha->ct_sns_dma;
2697         arg.rsp_dma = ha->ct_sns_dma;
2698         arg.req_size = GFPN_ID_REQ_SIZE;
2699         arg.rsp_size = GFPN_ID_RSP_SIZE;
2700         arg.nport_handle = NPH_SNS;
2701
2702         for (i = 0; i < ha->max_fibre_devices; i++) {
2703                 /* Issue GFPN_ID */
2704                 /* Prepare common MS IOCB */
2705                 ms_pkt = ha->isp_ops->prep_ms_iocb(vha, &arg);
2706
2707                 /* Prepare CT request */
2708                 ct_req = qla2x00_prep_ct_req(ha->ct_sns, GFPN_ID_CMD,
2709                     GFPN_ID_RSP_SIZE);
2710                 ct_rsp = &ha->ct_sns->p.rsp;
2711
2712                 /* Prepare CT arguments -- port_id */
2713                 ct_req->req.port_id.port_id = port_id_to_be_id(list[i].d_id);
2714
2715                 /* Execute MS IOCB */
2716                 rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2717                     sizeof(ms_iocb_entry_t));
2718                 if (rval != QLA_SUCCESS) {
2719                         /*EMPTY*/
2720                         ql_dbg(ql_dbg_disc, vha, 0x2023,
2721                             "GFPN_ID issue IOCB failed (%d).\n", rval);
2722                         break;
2723                 } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
2724                     "GFPN_ID") != QLA_SUCCESS) {
2725                         rval = QLA_FUNCTION_FAILED;
2726                         break;
2727                 } else {
2728                         /* Save fabric portname */
2729                         memcpy(list[i].fabric_port_name,
2730                             ct_rsp->rsp.gfpn_id.port_name, WWN_SIZE);
2731                 }
2732
2733                 /* Last device exit. */
2734                 if (list[i].d_id.b.rsvd_1 != 0)
2735                         break;
2736         }
2737
2738         return (rval);
2739 }
2740
2741
2742 static inline struct ct_sns_req *
2743 qla24xx_prep_ct_fm_req(struct ct_sns_pkt *p, uint16_t cmd,
2744     uint16_t rsp_size)
2745 {
2746         memset(p, 0, sizeof(struct ct_sns_pkt));
2747
2748         p->p.req.header.revision = 0x01;
2749         p->p.req.header.gs_type = 0xFA;
2750         p->p.req.header.gs_subtype = 0x01;
2751         p->p.req.command = cpu_to_be16(cmd);
2752         p->p.req.max_rsp_size = cpu_to_be16((rsp_size - 16) / 4);
2753
2754         return &p->p.req;
2755 }
2756
2757 static uint16_t
2758 qla2x00_port_speed_capability(uint16_t speed)
2759 {
2760         switch (speed) {
2761         case BIT_15:
2762                 return PORT_SPEED_1GB;
2763         case BIT_14:
2764                 return PORT_SPEED_2GB;
2765         case BIT_13:
2766                 return PORT_SPEED_4GB;
2767         case BIT_12:
2768                 return PORT_SPEED_10GB;
2769         case BIT_11:
2770                 return PORT_SPEED_8GB;
2771         case BIT_10:
2772                 return PORT_SPEED_16GB;
2773         case BIT_8:
2774                 return PORT_SPEED_32GB;
2775         case BIT_7:
2776                 return PORT_SPEED_64GB;
2777         default:
2778                 return PORT_SPEED_UNKNOWN;
2779         }
2780 }
2781
2782 /**
2783  * qla2x00_gpsc() - FCS Get Port Speed Capabilities (GPSC) query.
2784  * @vha: HA context
2785  * @list: switch info entries to populate
2786  *
2787  * Returns 0 on success.
2788  */
2789 int
2790 qla2x00_gpsc(scsi_qla_host_t *vha, sw_info_t *list)
2791 {
2792         int             rval;
2793         uint16_t        i;
2794         struct qla_hw_data *ha = vha->hw;
2795         ms_iocb_entry_t *ms_pkt;
2796         struct ct_sns_req       *ct_req;
2797         struct ct_sns_rsp       *ct_rsp;
2798         struct ct_arg arg;
2799
2800         if (!IS_IIDMA_CAPABLE(ha))
2801                 return QLA_FUNCTION_FAILED;
2802         if (!ha->flags.gpsc_supported)
2803                 return QLA_FUNCTION_FAILED;
2804
2805         rval = qla2x00_mgmt_svr_login(vha);
2806         if (rval)
2807                 return rval;
2808
2809         arg.iocb = ha->ms_iocb;
2810         arg.req_dma = ha->ct_sns_dma;
2811         arg.rsp_dma = ha->ct_sns_dma;
2812         arg.req_size = GPSC_REQ_SIZE;
2813         arg.rsp_size = GPSC_RSP_SIZE;
2814         arg.nport_handle = vha->mgmt_svr_loop_id;
2815
2816         for (i = 0; i < ha->max_fibre_devices; i++) {
2817                 /* Issue GFPN_ID */
2818                 /* Prepare common MS IOCB */
2819                 ms_pkt = qla24xx_prep_ms_iocb(vha, &arg);
2820
2821                 /* Prepare CT request */
2822                 ct_req = qla24xx_prep_ct_fm_req(ha->ct_sns, GPSC_CMD,
2823                     GPSC_RSP_SIZE);
2824                 ct_rsp = &ha->ct_sns->p.rsp;
2825
2826                 /* Prepare CT arguments -- port_name */
2827                 memcpy(ct_req->req.gpsc.port_name, list[i].fabric_port_name,
2828                     WWN_SIZE);
2829
2830                 /* Execute MS IOCB */
2831                 rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2832                     sizeof(ms_iocb_entry_t));
2833                 if (rval != QLA_SUCCESS) {
2834                         /*EMPTY*/
2835                         ql_dbg(ql_dbg_disc, vha, 0x2059,
2836                             "GPSC issue IOCB failed (%d).\n", rval);
2837                 } else if ((rval = qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
2838                     "GPSC")) != QLA_SUCCESS) {
2839                         /* FM command unsupported? */
2840                         if (rval == QLA_INVALID_COMMAND &&
2841                             (ct_rsp->header.reason_code ==
2842                                 CT_REASON_INVALID_COMMAND_CODE ||
2843                              ct_rsp->header.reason_code ==
2844                                 CT_REASON_COMMAND_UNSUPPORTED)) {
2845                                 ql_dbg(ql_dbg_disc, vha, 0x205a,
2846                                     "GPSC command unsupported, disabling "
2847                                     "query.\n");
2848                                 ha->flags.gpsc_supported = 0;
2849                                 rval = QLA_FUNCTION_FAILED;
2850                                 break;
2851                         }
2852                         rval = QLA_FUNCTION_FAILED;
2853                 } else {
2854                         list->fp_speed = qla2x00_port_speed_capability(
2855                             be16_to_cpu(ct_rsp->rsp.gpsc.speed));
2856                         ql_dbg(ql_dbg_disc, vha, 0x205b,
2857                             "GPSC ext entry - fpn "
2858                             "%8phN speeds=%04x speed=%04x.\n",
2859                             list[i].fabric_port_name,
2860                             be16_to_cpu(ct_rsp->rsp.gpsc.speeds),
2861                             be16_to_cpu(ct_rsp->rsp.gpsc.speed));
2862                 }
2863
2864                 /* Last device exit. */
2865                 if (list[i].d_id.b.rsvd_1 != 0)
2866                         break;
2867         }
2868
2869         return (rval);
2870 }
2871
2872 /**
2873  * qla2x00_gff_id() - SNS Get FC-4 Features (GFF_ID) query.
2874  *
2875  * @vha: HA context
2876  * @list: switch info entries to populate
2877  *
2878  */
2879 void
2880 qla2x00_gff_id(scsi_qla_host_t *vha, sw_info_t *list)
2881 {
2882         int             rval;
2883         uint16_t        i;
2884
2885         ms_iocb_entry_t *ms_pkt;
2886         struct ct_sns_req       *ct_req;
2887         struct ct_sns_rsp       *ct_rsp;
2888         struct qla_hw_data *ha = vha->hw;
2889         uint8_t fcp_scsi_features = 0, nvme_features = 0;
2890         struct ct_arg arg;
2891
2892         for (i = 0; i < ha->max_fibre_devices; i++) {
2893                 /* Set default FC4 Type as UNKNOWN so the default is to
2894                  * Process this port */
2895                 list[i].fc4_type = FC4_TYPE_UNKNOWN;
2896
2897                 /* Do not attempt GFF_ID if we are not FWI_2 capable */
2898                 if (!IS_FWI2_CAPABLE(ha))
2899                         continue;
2900
2901                 arg.iocb = ha->ms_iocb;
2902                 arg.req_dma = ha->ct_sns_dma;
2903                 arg.rsp_dma = ha->ct_sns_dma;
2904                 arg.req_size = GFF_ID_REQ_SIZE;
2905                 arg.rsp_size = GFF_ID_RSP_SIZE;
2906                 arg.nport_handle = NPH_SNS;
2907
2908                 /* Prepare common MS IOCB */
2909                 ms_pkt = ha->isp_ops->prep_ms_iocb(vha, &arg);
2910
2911                 /* Prepare CT request */
2912                 ct_req = qla2x00_prep_ct_req(ha->ct_sns, GFF_ID_CMD,
2913                     GFF_ID_RSP_SIZE);
2914                 ct_rsp = &ha->ct_sns->p.rsp;
2915
2916                 /* Prepare CT arguments -- port_id */
2917                 ct_req->req.port_id.port_id = port_id_to_be_id(list[i].d_id);
2918
2919                 /* Execute MS IOCB */
2920                 rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2921                    sizeof(ms_iocb_entry_t));
2922
2923                 if (rval != QLA_SUCCESS) {
2924                         ql_dbg(ql_dbg_disc, vha, 0x205c,
2925                             "GFF_ID issue IOCB failed (%d).\n", rval);
2926                 } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
2927                                "GFF_ID") != QLA_SUCCESS) {
2928                         ql_dbg(ql_dbg_disc, vha, 0x205d,
2929                             "GFF_ID IOCB status had a failure status code.\n");
2930                 } else {
2931                         fcp_scsi_features =
2932                            ct_rsp->rsp.gff_id.fc4_features[GFF_FCP_SCSI_OFFSET];
2933                         fcp_scsi_features &= 0x0f;
2934
2935                         if (fcp_scsi_features) {
2936                                 list[i].fc4_type = FS_FC4TYPE_FCP;
2937                                 list[i].fc4_features = fcp_scsi_features;
2938                         }
2939
2940                         nvme_features =
2941                             ct_rsp->rsp.gff_id.fc4_features[GFF_NVME_OFFSET];
2942                         nvme_features &= 0xf;
2943
2944                         if (nvme_features) {
2945                                 list[i].fc4_type |= FS_FC4TYPE_NVME;
2946                                 list[i].fc4_features = nvme_features;
2947                         }
2948                 }
2949
2950                 /* Last device exit. */
2951                 if (list[i].d_id.b.rsvd_1 != 0)
2952                         break;
2953         }
2954 }
2955
2956 int qla24xx_post_gpsc_work(struct scsi_qla_host *vha, fc_port_t *fcport)
2957 {
2958         struct qla_work_evt *e;
2959
2960         e = qla2x00_alloc_work(vha, QLA_EVT_GPSC);
2961         if (!e)
2962                 return QLA_FUNCTION_FAILED;
2963
2964         e->u.fcport.fcport = fcport;
2965         fcport->flags |= FCF_ASYNC_ACTIVE;
2966         return qla2x00_post_work(vha, e);
2967 }
2968
2969 void qla24xx_handle_gpsc_event(scsi_qla_host_t *vha, struct event_arg *ea)
2970 {
2971         struct fc_port *fcport = ea->fcport;
2972
2973         ql_dbg(ql_dbg_disc, vha, 0x20d8,
2974             "%s %8phC DS %d LS %d rc %d login %d|%d rscn %d|%d lid %d\n",
2975             __func__, fcport->port_name, fcport->disc_state,
2976             fcport->fw_login_state, ea->rc, ea->sp->gen2, fcport->login_gen,
2977             ea->sp->gen2, fcport->rscn_gen|ea->sp->gen1, fcport->loop_id);
2978
2979         if (fcport->disc_state == DSC_DELETE_PEND)
2980                 return;
2981
2982         if (ea->sp->gen2 != fcport->login_gen) {
2983                 /* target side must have changed it. */
2984                 ql_dbg(ql_dbg_disc, vha, 0x20d3,
2985                     "%s %8phC generation changed\n",
2986                     __func__, fcport->port_name);
2987                 return;
2988         } else if (ea->sp->gen1 != fcport->rscn_gen) {
2989                 return;
2990         }
2991
2992         qla_post_iidma_work(vha, fcport);
2993 }
2994
2995 static void qla24xx_async_gpsc_sp_done(srb_t *sp, int res)
2996 {
2997         struct scsi_qla_host *vha = sp->vha;
2998         struct qla_hw_data *ha = vha->hw;
2999         fc_port_t *fcport = sp->fcport;
3000         struct ct_sns_rsp       *ct_rsp;
3001         struct event_arg ea;
3002
3003         ct_rsp = &fcport->ct_desc.ct_sns->p.rsp;
3004
3005         ql_dbg(ql_dbg_disc, vha, 0x2053,
3006             "Async done-%s res %x, WWPN %8phC \n",
3007             sp->name, res, fcport->port_name);
3008
3009         fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
3010
3011         if (res == QLA_FUNCTION_TIMEOUT)
3012                 goto done;
3013
3014         if (res == (DID_ERROR << 16)) {
3015                 /* entry status error */
3016                 goto done;
3017         } else if (res) {
3018                 if ((ct_rsp->header.reason_code ==
3019                          CT_REASON_INVALID_COMMAND_CODE) ||
3020                         (ct_rsp->header.reason_code ==
3021                         CT_REASON_COMMAND_UNSUPPORTED)) {
3022                         ql_dbg(ql_dbg_disc, vha, 0x2019,
3023                             "GPSC command unsupported, disabling query.\n");
3024                         ha->flags.gpsc_supported = 0;
3025                         goto done;
3026                 }
3027         } else {
3028                 fcport->fp_speed = qla2x00_port_speed_capability(
3029                     be16_to_cpu(ct_rsp->rsp.gpsc.speed));
3030
3031                 ql_dbg(ql_dbg_disc, vha, 0x2054,
3032                     "Async-%s OUT WWPN %8phC speeds=%04x speed=%04x.\n",
3033                     sp->name, fcport->fabric_port_name,
3034                     be16_to_cpu(ct_rsp->rsp.gpsc.speeds),
3035                     be16_to_cpu(ct_rsp->rsp.gpsc.speed));
3036         }
3037         memset(&ea, 0, sizeof(ea));
3038         ea.rc = res;
3039         ea.fcport = fcport;
3040         ea.sp = sp;
3041         qla24xx_handle_gpsc_event(vha, &ea);
3042
3043 done:
3044         sp->free(sp);
3045 }
3046
3047 int qla24xx_async_gpsc(scsi_qla_host_t *vha, fc_port_t *fcport)
3048 {
3049         int rval = QLA_FUNCTION_FAILED;
3050         struct ct_sns_req       *ct_req;
3051         srb_t *sp;
3052
3053         if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT))
3054                 return rval;
3055
3056         sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
3057         if (!sp)
3058                 goto done;
3059
3060         sp->type = SRB_CT_PTHRU_CMD;
3061         sp->name = "gpsc";
3062         sp->gen1 = fcport->rscn_gen;
3063         sp->gen2 = fcport->login_gen;
3064
3065         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
3066
3067         /* CT_IU preamble  */
3068         ct_req = qla24xx_prep_ct_fm_req(fcport->ct_desc.ct_sns, GPSC_CMD,
3069                 GPSC_RSP_SIZE);
3070
3071         /* GPSC req */
3072         memcpy(ct_req->req.gpsc.port_name, fcport->fabric_port_name,
3073                 WWN_SIZE);
3074
3075         sp->u.iocb_cmd.u.ctarg.req = fcport->ct_desc.ct_sns;
3076         sp->u.iocb_cmd.u.ctarg.req_dma = fcport->ct_desc.ct_sns_dma;
3077         sp->u.iocb_cmd.u.ctarg.rsp = fcport->ct_desc.ct_sns;
3078         sp->u.iocb_cmd.u.ctarg.rsp_dma = fcport->ct_desc.ct_sns_dma;
3079         sp->u.iocb_cmd.u.ctarg.req_size = GPSC_REQ_SIZE;
3080         sp->u.iocb_cmd.u.ctarg.rsp_size = GPSC_RSP_SIZE;
3081         sp->u.iocb_cmd.u.ctarg.nport_handle = vha->mgmt_svr_loop_id;
3082
3083         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
3084         sp->done = qla24xx_async_gpsc_sp_done;
3085
3086         ql_dbg(ql_dbg_disc, vha, 0x205e,
3087             "Async-%s %8phC hdl=%x loopid=%x portid=%02x%02x%02x.\n",
3088             sp->name, fcport->port_name, sp->handle,
3089             fcport->loop_id, fcport->d_id.b.domain,
3090             fcport->d_id.b.area, fcport->d_id.b.al_pa);
3091
3092         rval = qla2x00_start_sp(sp);
3093         if (rval != QLA_SUCCESS)
3094                 goto done_free_sp;
3095         return rval;
3096
3097 done_free_sp:
3098         sp->free(sp);
3099         fcport->flags &= ~FCF_ASYNC_SENT;
3100 done:
3101         fcport->flags &= ~FCF_ASYNC_ACTIVE;
3102         return rval;
3103 }
3104
3105 int qla24xx_post_gpnid_work(struct scsi_qla_host *vha, port_id_t *id)
3106 {
3107         struct qla_work_evt *e;
3108
3109         if (test_bit(UNLOADING, &vha->dpc_flags) ||
3110             (vha->vp_idx && test_bit(VPORT_DELETE, &vha->dpc_flags)))
3111                 return 0;
3112
3113         e = qla2x00_alloc_work(vha, QLA_EVT_GPNID);
3114         if (!e)
3115                 return QLA_FUNCTION_FAILED;
3116
3117         e->u.gpnid.id = *id;
3118         return qla2x00_post_work(vha, e);
3119 }
3120
3121 void qla24xx_sp_unmap(scsi_qla_host_t *vha, srb_t *sp)
3122 {
3123         struct srb_iocb *c = &sp->u.iocb_cmd;
3124
3125         switch (sp->type) {
3126         case SRB_ELS_DCMD:
3127                 qla2x00_els_dcmd2_free(vha, &c->u.els_plogi);
3128                 break;
3129         case SRB_CT_PTHRU_CMD:
3130         default:
3131                 if (sp->u.iocb_cmd.u.ctarg.req) {
3132                         dma_free_coherent(&vha->hw->pdev->dev,
3133                             sp->u.iocb_cmd.u.ctarg.req_allocated_size,
3134                             sp->u.iocb_cmd.u.ctarg.req,
3135                             sp->u.iocb_cmd.u.ctarg.req_dma);
3136                         sp->u.iocb_cmd.u.ctarg.req = NULL;
3137                 }
3138
3139                 if (sp->u.iocb_cmd.u.ctarg.rsp) {
3140                         dma_free_coherent(&vha->hw->pdev->dev,
3141                             sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
3142                             sp->u.iocb_cmd.u.ctarg.rsp,
3143                             sp->u.iocb_cmd.u.ctarg.rsp_dma);
3144                         sp->u.iocb_cmd.u.ctarg.rsp = NULL;
3145                 }
3146                 break;
3147         }
3148
3149         sp->free(sp);
3150 }
3151
3152 void qla24xx_handle_gpnid_event(scsi_qla_host_t *vha, struct event_arg *ea)
3153 {
3154         fc_port_t *fcport, *conflict, *t;
3155         u16 data[2];
3156
3157         ql_dbg(ql_dbg_disc, vha, 0xffff,
3158             "%s %d port_id: %06x\n",
3159             __func__, __LINE__, ea->id.b24);
3160
3161         if (ea->rc) {
3162                 /* cable is disconnected */
3163                 list_for_each_entry_safe(fcport, t, &vha->vp_fcports, list) {
3164                         if (fcport->d_id.b24 == ea->id.b24)
3165                                 fcport->scan_state = QLA_FCPORT_SCAN;
3166
3167                         qlt_schedule_sess_for_deletion(fcport);
3168                 }
3169         } else {
3170                 /* cable is connected */
3171                 fcport = qla2x00_find_fcport_by_wwpn(vha, ea->port_name, 1);
3172                 if (fcport) {
3173                         list_for_each_entry_safe(conflict, t, &vha->vp_fcports,
3174                             list) {
3175                                 if ((conflict->d_id.b24 == ea->id.b24) &&
3176                                     (fcport != conflict))
3177                                         /*
3178                                          * 2 fcports with conflict Nport ID or
3179                                          * an existing fcport is having nport ID
3180                                          * conflict with new fcport.
3181                                          */
3182
3183                                         conflict->scan_state = QLA_FCPORT_SCAN;
3184
3185                                 qlt_schedule_sess_for_deletion(conflict);
3186                         }
3187
3188                         fcport->scan_needed = 0;
3189                         fcport->rscn_gen++;
3190                         fcport->scan_state = QLA_FCPORT_FOUND;
3191                         fcport->flags |= FCF_FABRIC_DEVICE;
3192                         if (fcport->login_retry == 0) {
3193                                 fcport->login_retry =
3194                                         vha->hw->login_retry_count;
3195                                 ql_dbg(ql_dbg_disc, vha, 0xffff,
3196                                     "Port login retry %8phN, lid 0x%04x cnt=%d.\n",
3197                                     fcport->port_name, fcport->loop_id,
3198                                     fcport->login_retry);
3199                         }
3200                         switch (fcport->disc_state) {
3201                         case DSC_LOGIN_COMPLETE:
3202                                 /* recheck session is still intact. */
3203                                 ql_dbg(ql_dbg_disc, vha, 0x210d,
3204                                     "%s %d %8phC revalidate session with ADISC\n",
3205                                     __func__, __LINE__, fcport->port_name);
3206                                 data[0] = data[1] = 0;
3207                                 qla2x00_post_async_adisc_work(vha, fcport,
3208                                     data);
3209                                 break;
3210                         case DSC_DELETED:
3211                                 ql_dbg(ql_dbg_disc, vha, 0x210d,
3212                                     "%s %d %8phC login\n", __func__, __LINE__,
3213                                     fcport->port_name);
3214                                 fcport->d_id = ea->id;
3215                                 qla24xx_fcport_handle_login(vha, fcport);
3216                                 break;
3217                         case DSC_DELETE_PEND:
3218                                 fcport->d_id = ea->id;
3219                                 break;
3220                         default:
3221                                 fcport->d_id = ea->id;
3222                                 break;
3223                         }
3224                 } else {
3225                         list_for_each_entry_safe(conflict, t, &vha->vp_fcports,
3226                             list) {
3227                                 if (conflict->d_id.b24 == ea->id.b24) {
3228                                         /* 2 fcports with conflict Nport ID or
3229                                          * an existing fcport is having nport ID
3230                                          * conflict with new fcport.
3231                                          */
3232                                         ql_dbg(ql_dbg_disc, vha, 0xffff,
3233                                             "%s %d %8phC DS %d\n",
3234                                             __func__, __LINE__,
3235                                             conflict->port_name,
3236                                             conflict->disc_state);
3237
3238                                         conflict->scan_state = QLA_FCPORT_SCAN;
3239                                         qlt_schedule_sess_for_deletion(conflict);
3240                                 }
3241                         }
3242
3243                         /* create new fcport */
3244                         ql_dbg(ql_dbg_disc, vha, 0x2065,
3245                             "%s %d %8phC post new sess\n",
3246                             __func__, __LINE__, ea->port_name);
3247                         qla24xx_post_newsess_work(vha, &ea->id,
3248                             ea->port_name, NULL, NULL, FC4_TYPE_UNKNOWN);
3249                 }
3250         }
3251 }
3252
3253 static void qla2x00_async_gpnid_sp_done(srb_t *sp, int res)
3254 {
3255         struct scsi_qla_host *vha = sp->vha;
3256         struct ct_sns_req *ct_req =
3257             (struct ct_sns_req *)sp->u.iocb_cmd.u.ctarg.req;
3258         struct ct_sns_rsp *ct_rsp =
3259             (struct ct_sns_rsp *)sp->u.iocb_cmd.u.ctarg.rsp;
3260         struct event_arg ea;
3261         struct qla_work_evt *e;
3262         unsigned long flags;
3263
3264         if (res)
3265                 ql_dbg(ql_dbg_disc, vha, 0x2066,
3266                     "Async done-%s fail res %x rscn gen %d ID %3phC. %8phC\n",
3267                     sp->name, res, sp->gen1, &ct_req->req.port_id.port_id,
3268                     ct_rsp->rsp.gpn_id.port_name);
3269         else
3270                 ql_dbg(ql_dbg_disc, vha, 0x2066,
3271                     "Async done-%s good rscn gen %d ID %3phC. %8phC\n",
3272                     sp->name, sp->gen1, &ct_req->req.port_id.port_id,
3273                     ct_rsp->rsp.gpn_id.port_name);
3274
3275         memset(&ea, 0, sizeof(ea));
3276         memcpy(ea.port_name, ct_rsp->rsp.gpn_id.port_name, WWN_SIZE);
3277         ea.sp = sp;
3278         ea.id = be_to_port_id(ct_req->req.port_id.port_id);
3279         ea.rc = res;
3280
3281         spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
3282         list_del(&sp->elem);
3283         spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
3284
3285         if (res) {
3286                 if (res == QLA_FUNCTION_TIMEOUT) {
3287                         qla24xx_post_gpnid_work(sp->vha, &ea.id);
3288                         sp->free(sp);
3289                         return;
3290                 }
3291         } else if (sp->gen1) {
3292                 /* There was another RSCN for this Nport ID */
3293                 qla24xx_post_gpnid_work(sp->vha, &ea.id);
3294                 sp->free(sp);
3295                 return;
3296         }
3297
3298         qla24xx_handle_gpnid_event(vha, &ea);
3299
3300         e = qla2x00_alloc_work(vha, QLA_EVT_UNMAP);
3301         if (!e) {
3302                 /* please ignore kernel warning. otherwise, we have mem leak. */
3303                 dma_free_coherent(&vha->hw->pdev->dev,
3304                                   sp->u.iocb_cmd.u.ctarg.req_allocated_size,
3305                                   sp->u.iocb_cmd.u.ctarg.req,
3306                                   sp->u.iocb_cmd.u.ctarg.req_dma);
3307                 sp->u.iocb_cmd.u.ctarg.req = NULL;
3308
3309                 dma_free_coherent(&vha->hw->pdev->dev,
3310                                   sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
3311                                   sp->u.iocb_cmd.u.ctarg.rsp,
3312                                   sp->u.iocb_cmd.u.ctarg.rsp_dma);
3313                 sp->u.iocb_cmd.u.ctarg.rsp = NULL;
3314
3315                 sp->free(sp);
3316                 return;
3317         }
3318
3319         e->u.iosb.sp = sp;
3320         qla2x00_post_work(vha, e);
3321 }
3322
3323 /* Get WWPN with Nport ID. */
3324 int qla24xx_async_gpnid(scsi_qla_host_t *vha, port_id_t *id)
3325 {
3326         int rval = QLA_FUNCTION_FAILED;
3327         struct ct_sns_req       *ct_req;
3328         srb_t *sp, *tsp;
3329         struct ct_sns_pkt *ct_sns;
3330         unsigned long flags;
3331
3332         if (!vha->flags.online)
3333                 goto done;
3334
3335         sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
3336         if (!sp)
3337                 goto done;
3338
3339         sp->type = SRB_CT_PTHRU_CMD;
3340         sp->name = "gpnid";
3341         sp->u.iocb_cmd.u.ctarg.id = *id;
3342         sp->gen1 = 0;
3343         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
3344
3345         spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
3346         list_for_each_entry(tsp, &vha->gpnid_list, elem) {
3347                 if (tsp->u.iocb_cmd.u.ctarg.id.b24 == id->b24) {
3348                         tsp->gen1++;
3349                         spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
3350                         sp->free(sp);
3351                         goto done;
3352                 }
3353         }
3354         list_add_tail(&sp->elem, &vha->gpnid_list);
3355         spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
3356
3357         sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
3358                 sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.req_dma,
3359                 GFP_KERNEL);
3360         sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
3361         if (!sp->u.iocb_cmd.u.ctarg.req) {
3362                 ql_log(ql_log_warn, vha, 0xd041,
3363                     "Failed to allocate ct_sns request.\n");
3364                 goto done_free_sp;
3365         }
3366
3367         sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
3368                 sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.rsp_dma,
3369                 GFP_KERNEL);
3370         sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = sizeof(struct ct_sns_pkt);
3371         if (!sp->u.iocb_cmd.u.ctarg.rsp) {
3372                 ql_log(ql_log_warn, vha, 0xd042,
3373                     "Failed to allocate ct_sns request.\n");
3374                 goto done_free_sp;
3375         }
3376
3377         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.rsp;
3378         memset(ct_sns, 0, sizeof(*ct_sns));
3379
3380         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
3381         /* CT_IU preamble  */
3382         ct_req = qla2x00_prep_ct_req(ct_sns, GPN_ID_CMD, GPN_ID_RSP_SIZE);
3383
3384         /* GPN_ID req */
3385         ct_req->req.port_id.port_id = port_id_to_be_id(*id);
3386
3387         sp->u.iocb_cmd.u.ctarg.req_size = GPN_ID_REQ_SIZE;
3388         sp->u.iocb_cmd.u.ctarg.rsp_size = GPN_ID_RSP_SIZE;
3389         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
3390
3391         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
3392         sp->done = qla2x00_async_gpnid_sp_done;
3393
3394         ql_dbg(ql_dbg_disc, vha, 0x2067,
3395             "Async-%s hdl=%x ID %3phC.\n", sp->name,
3396             sp->handle, &ct_req->req.port_id.port_id);
3397
3398         rval = qla2x00_start_sp(sp);
3399         if (rval != QLA_SUCCESS)
3400                 goto done_free_sp;
3401
3402         return rval;
3403
3404 done_free_sp:
3405         spin_lock_irqsave(&vha->hw->vport_slock, flags);
3406         list_del(&sp->elem);
3407         spin_unlock_irqrestore(&vha->hw->vport_slock, flags);
3408
3409         if (sp->u.iocb_cmd.u.ctarg.req) {
3410                 dma_free_coherent(&vha->hw->pdev->dev,
3411                         sizeof(struct ct_sns_pkt),
3412                         sp->u.iocb_cmd.u.ctarg.req,
3413                         sp->u.iocb_cmd.u.ctarg.req_dma);
3414                 sp->u.iocb_cmd.u.ctarg.req = NULL;
3415         }
3416         if (sp->u.iocb_cmd.u.ctarg.rsp) {
3417                 dma_free_coherent(&vha->hw->pdev->dev,
3418                         sizeof(struct ct_sns_pkt),
3419                         sp->u.iocb_cmd.u.ctarg.rsp,
3420                         sp->u.iocb_cmd.u.ctarg.rsp_dma);
3421                 sp->u.iocb_cmd.u.ctarg.rsp = NULL;
3422         }
3423
3424         sp->free(sp);
3425 done:
3426         return rval;
3427 }
3428
3429 void qla24xx_handle_gffid_event(scsi_qla_host_t *vha, struct event_arg *ea)
3430 {
3431         fc_port_t *fcport = ea->fcport;
3432
3433         qla24xx_post_gnl_work(vha, fcport);
3434 }
3435
3436 void qla24xx_async_gffid_sp_done(srb_t *sp, int res)
3437 {
3438         struct scsi_qla_host *vha = sp->vha;
3439         fc_port_t *fcport = sp->fcport;
3440         struct ct_sns_rsp *ct_rsp;
3441         struct event_arg ea;
3442         uint8_t fc4_scsi_feat;
3443         uint8_t fc4_nvme_feat;
3444
3445         ql_dbg(ql_dbg_disc, vha, 0x2133,
3446                "Async done-%s res %x ID %x. %8phC\n",
3447                sp->name, res, fcport->d_id.b24, fcport->port_name);
3448
3449         fcport->flags &= ~FCF_ASYNC_SENT;
3450         ct_rsp = &fcport->ct_desc.ct_sns->p.rsp;
3451         fc4_scsi_feat = ct_rsp->rsp.gff_id.fc4_features[GFF_FCP_SCSI_OFFSET];
3452         fc4_nvme_feat = ct_rsp->rsp.gff_id.fc4_features[GFF_NVME_OFFSET];
3453
3454         /*
3455          * FC-GS-7, 5.2.3.12 FC-4 Features - format
3456          * The format of the FC-4 Features object, as defined by the FC-4,
3457          * Shall be an array of 4-bit values, one for each type code value
3458          */
3459         if (!res) {
3460                 if (fc4_scsi_feat & 0xf) {
3461                         /* w1 b00:03 */
3462                         fcport->fc4_type = FS_FC4TYPE_FCP;
3463                         fcport->fc4_features = fc4_scsi_feat & 0xf;
3464                 }
3465
3466                 if (fc4_nvme_feat & 0xf) {
3467                         /* w5 [00:03]/28h */
3468                         fcport->fc4_type |= FS_FC4TYPE_NVME;
3469                         fcport->fc4_features = fc4_nvme_feat & 0xf;
3470                 }
3471         }
3472
3473         memset(&ea, 0, sizeof(ea));
3474         ea.sp = sp;
3475         ea.fcport = sp->fcport;
3476         ea.rc = res;
3477
3478         qla24xx_handle_gffid_event(vha, &ea);
3479         sp->free(sp);
3480 }
3481
3482 /* Get FC4 Feature with Nport ID. */
3483 int qla24xx_async_gffid(scsi_qla_host_t *vha, fc_port_t *fcport)
3484 {
3485         int rval = QLA_FUNCTION_FAILED;
3486         struct ct_sns_req       *ct_req;
3487         srb_t *sp;
3488
3489         if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT))
3490                 return rval;
3491
3492         sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
3493         if (!sp)
3494                 return rval;
3495
3496         fcport->flags |= FCF_ASYNC_SENT;
3497         sp->type = SRB_CT_PTHRU_CMD;
3498         sp->name = "gffid";
3499         sp->gen1 = fcport->rscn_gen;
3500         sp->gen2 = fcport->login_gen;
3501
3502         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
3503         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
3504
3505         /* CT_IU preamble  */
3506         ct_req = qla2x00_prep_ct_req(fcport->ct_desc.ct_sns, GFF_ID_CMD,
3507             GFF_ID_RSP_SIZE);
3508
3509         ct_req->req.gff_id.port_id[0] = fcport->d_id.b.domain;
3510         ct_req->req.gff_id.port_id[1] = fcport->d_id.b.area;
3511         ct_req->req.gff_id.port_id[2] = fcport->d_id.b.al_pa;
3512
3513         sp->u.iocb_cmd.u.ctarg.req = fcport->ct_desc.ct_sns;
3514         sp->u.iocb_cmd.u.ctarg.req_dma = fcport->ct_desc.ct_sns_dma;
3515         sp->u.iocb_cmd.u.ctarg.rsp = fcport->ct_desc.ct_sns;
3516         sp->u.iocb_cmd.u.ctarg.rsp_dma = fcport->ct_desc.ct_sns_dma;
3517         sp->u.iocb_cmd.u.ctarg.req_size = GFF_ID_REQ_SIZE;
3518         sp->u.iocb_cmd.u.ctarg.rsp_size = GFF_ID_RSP_SIZE;
3519         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
3520
3521         sp->done = qla24xx_async_gffid_sp_done;
3522
3523         ql_dbg(ql_dbg_disc, vha, 0x2132,
3524             "Async-%s hdl=%x  %8phC.\n", sp->name,
3525             sp->handle, fcport->port_name);
3526
3527         rval = qla2x00_start_sp(sp);
3528         if (rval != QLA_SUCCESS)
3529                 goto done_free_sp;
3530
3531         return rval;
3532 done_free_sp:
3533         sp->free(sp);
3534         fcport->flags &= ~FCF_ASYNC_SENT;
3535         return rval;
3536 }
3537
3538 /* GPN_FT + GNN_FT*/
3539 static int qla2x00_is_a_vp(scsi_qla_host_t *vha, u64 wwn)
3540 {
3541         struct qla_hw_data *ha = vha->hw;
3542         scsi_qla_host_t *vp;
3543         unsigned long flags;
3544         u64 twwn;
3545         int rc = 0;
3546
3547         if (!ha->num_vhosts)
3548                 return 0;
3549
3550         spin_lock_irqsave(&ha->vport_slock, flags);
3551         list_for_each_entry(vp, &ha->vp_list, list) {
3552                 twwn = wwn_to_u64(vp->port_name);
3553                 if (wwn == twwn) {
3554                         rc = 1;
3555                         break;
3556                 }
3557         }
3558         spin_unlock_irqrestore(&ha->vport_slock, flags);
3559
3560         return rc;
3561 }
3562
3563 void qla24xx_async_gnnft_done(scsi_qla_host_t *vha, srb_t *sp)
3564 {
3565         fc_port_t *fcport;
3566         u32 i, rc;
3567         bool found;
3568         struct fab_scan_rp *rp, *trp;
3569         unsigned long flags;
3570         u8 recheck = 0;
3571         u16 dup = 0, dup_cnt = 0;
3572
3573         ql_dbg(ql_dbg_disc, vha, 0xffff,
3574             "%s enter\n", __func__);
3575
3576         if (sp->gen1 != vha->hw->base_qpair->chip_reset) {
3577                 ql_dbg(ql_dbg_disc, vha, 0xffff,
3578                     "%s scan stop due to chip reset %x/%x\n",
3579                     sp->name, sp->gen1, vha->hw->base_qpair->chip_reset);
3580                 goto out;
3581         }
3582
3583         rc = sp->rc;
3584         if (rc) {
3585                 vha->scan.scan_retry++;
3586                 if (vha->scan.scan_retry < MAX_SCAN_RETRIES) {
3587                         set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3588                         set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3589                 } else {
3590                         ql_dbg(ql_dbg_disc, vha, 0xffff,
3591                             "Fabric scan failed on all retries.\n");
3592                 }
3593                 goto out;
3594         }
3595         vha->scan.scan_retry = 0;
3596
3597         list_for_each_entry(fcport, &vha->vp_fcports, list)
3598                 fcport->scan_state = QLA_FCPORT_SCAN;
3599
3600         for (i = 0; i < vha->hw->max_fibre_devices; i++) {
3601                 u64 wwn;
3602                 int k;
3603
3604                 rp = &vha->scan.l[i];
3605                 found = false;
3606
3607                 wwn = wwn_to_u64(rp->port_name);
3608                 if (wwn == 0)
3609                         continue;
3610
3611                 /* Remove duplicate NPORT ID entries from switch data base */
3612                 for (k = i + 1; k < vha->hw->max_fibre_devices; k++) {
3613                         trp = &vha->scan.l[k];
3614                         if (rp->id.b24 == trp->id.b24) {
3615                                 dup = 1;
3616                                 dup_cnt++;
3617                                 ql_dbg(ql_dbg_disc + ql_dbg_verbose,
3618                                     vha, 0xffff,
3619                                     "Detected duplicate NPORT ID from switch data base: ID %06x WWN %8phN WWN %8phN\n",
3620                                     rp->id.b24, rp->port_name, trp->port_name);
3621                                 memset(trp, 0, sizeof(*trp));
3622                         }
3623                 }
3624
3625                 if (!memcmp(rp->port_name, vha->port_name, WWN_SIZE))
3626                         continue;
3627
3628                 /* Bypass reserved domain fields. */
3629                 if ((rp->id.b.domain & 0xf0) == 0xf0)
3630                         continue;
3631
3632                 /* Bypass virtual ports of the same host. */
3633                 if (qla2x00_is_a_vp(vha, wwn))
3634                         continue;
3635
3636                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
3637                         if (memcmp(rp->port_name, fcport->port_name, WWN_SIZE))
3638                                 continue;
3639                         fcport->scan_state = QLA_FCPORT_FOUND;
3640                         found = true;
3641                         /*
3642                          * If device was not a fabric device before.
3643                          */
3644                         if ((fcport->flags & FCF_FABRIC_DEVICE) == 0) {
3645                                 qla2x00_clear_loop_id(fcport);
3646                                 fcport->flags |= FCF_FABRIC_DEVICE;
3647                         } else if (fcport->d_id.b24 != rp->id.b24 ||
3648                                    (fcport->scan_needed &&
3649                                     fcport->port_type != FCT_INITIATOR &&
3650                                     fcport->port_type != FCT_NVME_INITIATOR)) {
3651                                 qlt_schedule_sess_for_deletion(fcport);
3652                         }
3653                         fcport->d_id.b24 = rp->id.b24;
3654                         fcport->scan_needed = 0;
3655                         break;
3656                 }
3657
3658                 if (!found) {
3659                         ql_dbg(ql_dbg_disc, vha, 0xffff,
3660                             "%s %d %8phC post new sess\n",
3661                             __func__, __LINE__, rp->port_name);
3662                         qla24xx_post_newsess_work(vha, &rp->id, rp->port_name,
3663                             rp->node_name, NULL, rp->fc4type);
3664                 }
3665         }
3666
3667         if (dup) {
3668                 ql_log(ql_log_warn, vha, 0xffff,
3669                     "Detected %d duplicate NPORT ID(s) from switch data base\n",
3670                     dup_cnt);
3671         }
3672
3673         /*
3674          * Logout all previous fabric dev marked lost, except FCP2 devices.
3675          */
3676         list_for_each_entry(fcport, &vha->vp_fcports, list) {
3677                 if ((fcport->flags & FCF_FABRIC_DEVICE) == 0) {
3678                         fcport->scan_needed = 0;
3679                         continue;
3680                 }
3681
3682                 if (fcport->scan_state != QLA_FCPORT_FOUND) {
3683                         bool do_delete = false;
3684
3685                         if (fcport->scan_needed &&
3686                             fcport->disc_state == DSC_LOGIN_PEND) {
3687                                 /* Cable got disconnected after we sent
3688                                  * a login. Do delete to prevent timeout.
3689                                  */
3690                                 fcport->logout_on_delete = 1;
3691                                 do_delete = true;
3692                         }
3693
3694                         fcport->scan_needed = 0;
3695                         if (((qla_dual_mode_enabled(vha) ||
3696                               qla_ini_mode_enabled(vha)) &&
3697                             atomic_read(&fcport->state) == FCS_ONLINE) ||
3698                                 do_delete) {
3699                                 if (fcport->loop_id != FC_NO_LOOP_ID) {
3700                                         if (fcport->flags & FCF_FCP2_DEVICE)
3701                                                 fcport->logout_on_delete = 0;
3702
3703                                         ql_dbg(ql_dbg_disc, vha, 0x20f0,
3704                                             "%s %d %8phC post del sess\n",
3705                                             __func__, __LINE__,
3706                                             fcport->port_name);
3707
3708                                         qlt_schedule_sess_for_deletion(fcport);
3709                                         continue;
3710                                 }
3711                         }
3712                 } else {
3713                         if (fcport->scan_needed ||
3714                             fcport->disc_state != DSC_LOGIN_COMPLETE) {
3715                                 if (fcport->login_retry == 0) {
3716                                         fcport->login_retry =
3717                                                 vha->hw->login_retry_count;
3718                                         ql_dbg(ql_dbg_disc, vha, 0x20a3,
3719                                             "Port login retry %8phN, lid 0x%04x retry cnt=%d.\n",
3720                                             fcport->port_name, fcport->loop_id,
3721                                             fcport->login_retry);
3722                                 }
3723                                 fcport->scan_needed = 0;
3724                                 qla24xx_fcport_handle_login(vha, fcport);
3725                         }
3726                 }
3727         }
3728
3729         recheck = 1;
3730 out:
3731         qla24xx_sp_unmap(vha, sp);
3732         spin_lock_irqsave(&vha->work_lock, flags);
3733         vha->scan.scan_flags &= ~SF_SCANNING;
3734         spin_unlock_irqrestore(&vha->work_lock, flags);
3735
3736         if (recheck) {
3737                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
3738                         if (fcport->scan_needed) {
3739                                 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3740                                 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3741                                 break;
3742                         }
3743                 }
3744         }
3745 }
3746
3747 static int qla2x00_post_gnnft_gpnft_done_work(struct scsi_qla_host *vha,
3748     srb_t *sp, int cmd)
3749 {
3750         struct qla_work_evt *e;
3751
3752         if (cmd != QLA_EVT_GPNFT_DONE && cmd != QLA_EVT_GNNFT_DONE)
3753                 return QLA_PARAMETER_ERROR;
3754
3755         e = qla2x00_alloc_work(vha, cmd);
3756         if (!e)
3757                 return QLA_FUNCTION_FAILED;
3758
3759         e->u.iosb.sp = sp;
3760
3761         return qla2x00_post_work(vha, e);
3762 }
3763
3764 static int qla2x00_post_nvme_gpnft_work(struct scsi_qla_host *vha,
3765     srb_t *sp, int cmd)
3766 {
3767         struct qla_work_evt *e;
3768
3769         if (cmd != QLA_EVT_GPNFT)
3770                 return QLA_PARAMETER_ERROR;
3771
3772         e = qla2x00_alloc_work(vha, cmd);
3773         if (!e)
3774                 return QLA_FUNCTION_FAILED;
3775
3776         e->u.gpnft.fc4_type = FC4_TYPE_NVME;
3777         e->u.gpnft.sp = sp;
3778
3779         return qla2x00_post_work(vha, e);
3780 }
3781
3782 static void qla2x00_find_free_fcp_nvme_slot(struct scsi_qla_host *vha,
3783         struct srb *sp)
3784 {
3785         struct qla_hw_data *ha = vha->hw;
3786         int num_fibre_dev = ha->max_fibre_devices;
3787         struct ct_sns_req *ct_req =
3788                 (struct ct_sns_req *)sp->u.iocb_cmd.u.ctarg.req;
3789         struct ct_sns_gpnft_rsp *ct_rsp =
3790                 (struct ct_sns_gpnft_rsp *)sp->u.iocb_cmd.u.ctarg.rsp;
3791         struct ct_sns_gpn_ft_data *d;
3792         struct fab_scan_rp *rp;
3793         u16 cmd = be16_to_cpu(ct_req->command);
3794         u8 fc4_type = sp->gen2;
3795         int i, j, k;
3796         port_id_t id;
3797         u8 found;
3798         u64 wwn;
3799
3800         j = 0;
3801         for (i = 0; i < num_fibre_dev; i++) {
3802                 d  = &ct_rsp->entries[i];
3803
3804                 id.b.rsvd_1 = 0;
3805                 id.b.domain = d->port_id[0];
3806                 id.b.area   = d->port_id[1];
3807                 id.b.al_pa  = d->port_id[2];
3808                 wwn = wwn_to_u64(d->port_name);
3809
3810                 if (id.b24 == 0 || wwn == 0)
3811                         continue;
3812
3813                 if (fc4_type == FC4_TYPE_FCP_SCSI) {
3814                         if (cmd == GPN_FT_CMD) {
3815                                 rp = &vha->scan.l[j];
3816                                 rp->id = id;
3817                                 memcpy(rp->port_name, d->port_name, 8);
3818                                 j++;
3819                                 rp->fc4type = FS_FC4TYPE_FCP;
3820                         } else {
3821                                 for (k = 0; k < num_fibre_dev; k++) {
3822                                         rp = &vha->scan.l[k];
3823                                         if (id.b24 == rp->id.b24) {
3824                                                 memcpy(rp->node_name,
3825                                                     d->port_name, 8);
3826                                                 break;
3827                                         }
3828                                 }
3829                         }
3830                 } else {
3831                         /* Search if the fibre device supports FC4_TYPE_NVME */
3832                         if (cmd == GPN_FT_CMD) {
3833                                 found = 0;
3834
3835                                 for (k = 0; k < num_fibre_dev; k++) {
3836                                         rp = &vha->scan.l[k];
3837                                         if (!memcmp(rp->port_name,
3838                                             d->port_name, 8)) {
3839                                                 /*
3840                                                  * Supports FC-NVMe & FCP
3841                                                  */
3842                                                 rp->fc4type |= FS_FC4TYPE_NVME;
3843                                                 found = 1;
3844                                                 break;
3845                                         }
3846                                 }
3847
3848                                 /* We found new FC-NVMe only port */
3849                                 if (!found) {
3850                                         for (k = 0; k < num_fibre_dev; k++) {
3851                                                 rp = &vha->scan.l[k];
3852                                                 if (wwn_to_u64(rp->port_name)) {
3853                                                         continue;
3854                                                 } else {
3855                                                         rp->id = id;
3856                                                         memcpy(rp->port_name,
3857                                                             d->port_name, 8);
3858                                                         rp->fc4type =
3859                                                             FS_FC4TYPE_NVME;
3860                                                         break;
3861                                                 }
3862                                         }
3863                                 }
3864                         } else {
3865                                 for (k = 0; k < num_fibre_dev; k++) {
3866                                         rp = &vha->scan.l[k];
3867                                         if (id.b24 == rp->id.b24) {
3868                                                 memcpy(rp->node_name,
3869                                                     d->port_name, 8);
3870                                                 break;
3871                                         }
3872                                 }
3873                         }
3874                 }
3875         }
3876 }
3877
3878 static void qla2x00_async_gpnft_gnnft_sp_done(srb_t *sp, int res)
3879 {
3880         struct scsi_qla_host *vha = sp->vha;
3881         struct ct_sns_req *ct_req =
3882                 (struct ct_sns_req *)sp->u.iocb_cmd.u.ctarg.req;
3883         u16 cmd = be16_to_cpu(ct_req->command);
3884         u8 fc4_type = sp->gen2;
3885         unsigned long flags;
3886         int rc;
3887
3888         /* gen2 field is holding the fc4type */
3889         ql_dbg(ql_dbg_disc, vha, 0xffff,
3890             "Async done-%s res %x FC4Type %x\n",
3891             sp->name, res, sp->gen2);
3892
3893         del_timer(&sp->u.iocb_cmd.timer);
3894         sp->rc = res;
3895         if (res) {
3896                 unsigned long flags;
3897                 const char *name = sp->name;
3898
3899                 /*
3900                  * We are in an Interrupt context, queue up this
3901                  * sp for GNNFT_DONE work. This will allow all
3902                  * the resource to get freed up.
3903                  */
3904                 rc = qla2x00_post_gnnft_gpnft_done_work(vha, sp,
3905                     QLA_EVT_GNNFT_DONE);
3906                 if (rc) {
3907                         /* Cleanup here to prevent memory leak */
3908                         qla24xx_sp_unmap(vha, sp);
3909
3910                         spin_lock_irqsave(&vha->work_lock, flags);
3911                         vha->scan.scan_flags &= ~SF_SCANNING;
3912                         vha->scan.scan_retry++;
3913                         spin_unlock_irqrestore(&vha->work_lock, flags);
3914
3915                         if (vha->scan.scan_retry < MAX_SCAN_RETRIES) {
3916                                 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3917                                 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3918                                 qla2xxx_wake_dpc(vha);
3919                         } else {
3920                                 ql_dbg(ql_dbg_disc, vha, 0xffff,
3921                                     "Async done-%s rescan failed on all retries.\n",
3922                                     name);
3923                         }
3924                 }
3925                 return;
3926         }
3927
3928         qla2x00_find_free_fcp_nvme_slot(vha, sp);
3929
3930         if ((fc4_type == FC4_TYPE_FCP_SCSI) && vha->flags.nvme_enabled &&
3931             cmd == GNN_FT_CMD) {
3932                 spin_lock_irqsave(&vha->work_lock, flags);
3933                 vha->scan.scan_flags &= ~SF_SCANNING;
3934                 spin_unlock_irqrestore(&vha->work_lock, flags);
3935
3936                 sp->rc = res;
3937                 rc = qla2x00_post_nvme_gpnft_work(vha, sp, QLA_EVT_GPNFT);
3938                 if (rc) {
3939                         qla24xx_sp_unmap(vha, sp);
3940                         set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3941                         set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3942                 }
3943                 return;
3944         }
3945
3946         if (cmd == GPN_FT_CMD) {
3947                 rc = qla2x00_post_gnnft_gpnft_done_work(vha, sp,
3948                     QLA_EVT_GPNFT_DONE);
3949         } else {
3950                 rc = qla2x00_post_gnnft_gpnft_done_work(vha, sp,
3951                     QLA_EVT_GNNFT_DONE);
3952         }
3953
3954         if (rc) {
3955                 qla24xx_sp_unmap(vha, sp);
3956                 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3957                 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3958                 return;
3959         }
3960 }
3961
3962 /*
3963  * Get WWNN list for fc4_type
3964  *
3965  * It is assumed the same SRB is re-used from GPNFT to avoid
3966  * mem free & re-alloc
3967  */
3968 static int qla24xx_async_gnnft(scsi_qla_host_t *vha, struct srb *sp,
3969     u8 fc4_type)
3970 {
3971         int rval = QLA_FUNCTION_FAILED;
3972         struct ct_sns_req *ct_req;
3973         struct ct_sns_pkt *ct_sns;
3974         unsigned long flags;
3975
3976         if (!vha->flags.online) {
3977                 spin_lock_irqsave(&vha->work_lock, flags);
3978                 vha->scan.scan_flags &= ~SF_SCANNING;
3979                 spin_unlock_irqrestore(&vha->work_lock, flags);
3980                 goto done_free_sp;
3981         }
3982
3983         if (!sp->u.iocb_cmd.u.ctarg.req || !sp->u.iocb_cmd.u.ctarg.rsp) {
3984                 ql_log(ql_log_warn, vha, 0xffff,
3985                     "%s: req %p rsp %p are not setup\n",
3986                     __func__, sp->u.iocb_cmd.u.ctarg.req,
3987                     sp->u.iocb_cmd.u.ctarg.rsp);
3988                 spin_lock_irqsave(&vha->work_lock, flags);
3989                 vha->scan.scan_flags &= ~SF_SCANNING;
3990                 spin_unlock_irqrestore(&vha->work_lock, flags);
3991                 WARN_ON(1);
3992                 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3993                 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3994                 goto done_free_sp;
3995         }
3996
3997         ql_dbg(ql_dbg_disc, vha, 0xfffff,
3998             "%s: FC4Type %x, CT-PASSTHRU %s command ctarg rsp size %d, ctarg req size %d\n",
3999             __func__, fc4_type, sp->name, sp->u.iocb_cmd.u.ctarg.rsp_size,
4000              sp->u.iocb_cmd.u.ctarg.req_size);
4001
4002         sp->type = SRB_CT_PTHRU_CMD;
4003         sp->name = "gnnft";
4004         sp->gen1 = vha->hw->base_qpair->chip_reset;
4005         sp->gen2 = fc4_type;
4006
4007         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
4008         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
4009
4010         memset(sp->u.iocb_cmd.u.ctarg.rsp, 0, sp->u.iocb_cmd.u.ctarg.rsp_size);
4011         memset(sp->u.iocb_cmd.u.ctarg.req, 0, sp->u.iocb_cmd.u.ctarg.req_size);
4012
4013         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
4014         /* CT_IU preamble  */
4015         ct_req = qla2x00_prep_ct_req(ct_sns, GNN_FT_CMD,
4016             sp->u.iocb_cmd.u.ctarg.rsp_size);
4017
4018         /* GPN_FT req */
4019         ct_req->req.gpn_ft.port_type = fc4_type;
4020
4021         sp->u.iocb_cmd.u.ctarg.req_size = GNN_FT_REQ_SIZE;
4022         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
4023
4024         sp->done = qla2x00_async_gpnft_gnnft_sp_done;
4025
4026         ql_dbg(ql_dbg_disc, vha, 0xffff,
4027             "Async-%s hdl=%x FC4Type %x.\n", sp->name,
4028             sp->handle, ct_req->req.gpn_ft.port_type);
4029
4030         rval = qla2x00_start_sp(sp);
4031         if (rval != QLA_SUCCESS) {
4032                 goto done_free_sp;
4033         }
4034
4035         return rval;
4036
4037 done_free_sp:
4038         if (sp->u.iocb_cmd.u.ctarg.req) {
4039                 dma_free_coherent(&vha->hw->pdev->dev,
4040                     sp->u.iocb_cmd.u.ctarg.req_allocated_size,
4041                     sp->u.iocb_cmd.u.ctarg.req,
4042                     sp->u.iocb_cmd.u.ctarg.req_dma);
4043                 sp->u.iocb_cmd.u.ctarg.req = NULL;
4044         }
4045         if (sp->u.iocb_cmd.u.ctarg.rsp) {
4046                 dma_free_coherent(&vha->hw->pdev->dev,
4047                     sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
4048                     sp->u.iocb_cmd.u.ctarg.rsp,
4049                     sp->u.iocb_cmd.u.ctarg.rsp_dma);
4050                 sp->u.iocb_cmd.u.ctarg.rsp = NULL;
4051         }
4052
4053         sp->free(sp);
4054
4055         spin_lock_irqsave(&vha->work_lock, flags);
4056         vha->scan.scan_flags &= ~SF_SCANNING;
4057         if (vha->scan.scan_flags == 0) {
4058                 ql_dbg(ql_dbg_disc, vha, 0xffff,
4059                     "%s: schedule\n", __func__);
4060                 vha->scan.scan_flags |= SF_QUEUED;
4061                 schedule_delayed_work(&vha->scan.scan_work, 5);
4062         }
4063         spin_unlock_irqrestore(&vha->work_lock, flags);
4064
4065
4066         return rval;
4067 } /* GNNFT */
4068
4069 void qla24xx_async_gpnft_done(scsi_qla_host_t *vha, srb_t *sp)
4070 {
4071         ql_dbg(ql_dbg_disc, vha, 0xffff,
4072             "%s enter\n", __func__);
4073         qla24xx_async_gnnft(vha, sp, sp->gen2);
4074 }
4075
4076 /* Get WWPN list for certain fc4_type */
4077 int qla24xx_async_gpnft(scsi_qla_host_t *vha, u8 fc4_type, srb_t *sp)
4078 {
4079         int rval = QLA_FUNCTION_FAILED;
4080         struct ct_sns_req       *ct_req;
4081         struct ct_sns_pkt *ct_sns;
4082         u32 rspsz;
4083         unsigned long flags;
4084
4085         ql_dbg(ql_dbg_disc, vha, 0xffff,
4086             "%s enter\n", __func__);
4087
4088         if (!vha->flags.online)
4089                 return rval;
4090
4091         spin_lock_irqsave(&vha->work_lock, flags);
4092         if (vha->scan.scan_flags & SF_SCANNING) {
4093                 spin_unlock_irqrestore(&vha->work_lock, flags);
4094                 ql_dbg(ql_dbg_disc, vha, 0xffff, "scan active\n");
4095                 return rval;
4096         }
4097         vha->scan.scan_flags |= SF_SCANNING;
4098         spin_unlock_irqrestore(&vha->work_lock, flags);
4099
4100         if (fc4_type == FC4_TYPE_FCP_SCSI) {
4101                 ql_dbg(ql_dbg_disc, vha, 0xffff,
4102                     "%s: Performing FCP Scan\n", __func__);
4103
4104                 if (sp)
4105                         sp->free(sp); /* should not happen */
4106
4107                 sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
4108                 if (!sp) {
4109                         spin_lock_irqsave(&vha->work_lock, flags);
4110                         vha->scan.scan_flags &= ~SF_SCANNING;
4111                         spin_unlock_irqrestore(&vha->work_lock, flags);
4112                         return rval;
4113                 }
4114
4115                 sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
4116                                                                 sizeof(struct ct_sns_pkt),
4117                                                                 &sp->u.iocb_cmd.u.ctarg.req_dma,
4118                                                                 GFP_KERNEL);
4119                 sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
4120                 if (!sp->u.iocb_cmd.u.ctarg.req) {
4121                         ql_log(ql_log_warn, vha, 0xffff,
4122                             "Failed to allocate ct_sns request.\n");
4123                         spin_lock_irqsave(&vha->work_lock, flags);
4124                         vha->scan.scan_flags &= ~SF_SCANNING;
4125                         spin_unlock_irqrestore(&vha->work_lock, flags);
4126                         qla2x00_rel_sp(sp);
4127                         return rval;
4128                 }
4129                 sp->u.iocb_cmd.u.ctarg.req_size = GPN_FT_REQ_SIZE;
4130
4131                 rspsz = sizeof(struct ct_sns_gpnft_rsp) +
4132                         ((vha->hw->max_fibre_devices - 1) *
4133                             sizeof(struct ct_sns_gpn_ft_data));
4134
4135                 sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
4136                                                                 rspsz,
4137                                                                 &sp->u.iocb_cmd.u.ctarg.rsp_dma,
4138                                                                 GFP_KERNEL);
4139                 sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = rspsz;
4140                 if (!sp->u.iocb_cmd.u.ctarg.rsp) {
4141                         ql_log(ql_log_warn, vha, 0xffff,
4142                             "Failed to allocate ct_sns request.\n");
4143                         spin_lock_irqsave(&vha->work_lock, flags);
4144                         vha->scan.scan_flags &= ~SF_SCANNING;
4145                         spin_unlock_irqrestore(&vha->work_lock, flags);
4146                         dma_free_coherent(&vha->hw->pdev->dev,
4147                             sp->u.iocb_cmd.u.ctarg.req_allocated_size,
4148                             sp->u.iocb_cmd.u.ctarg.req,
4149                             sp->u.iocb_cmd.u.ctarg.req_dma);
4150                         sp->u.iocb_cmd.u.ctarg.req = NULL;
4151                         qla2x00_rel_sp(sp);
4152                         return rval;
4153                 }
4154                 sp->u.iocb_cmd.u.ctarg.rsp_size = rspsz;
4155
4156                 ql_dbg(ql_dbg_disc, vha, 0xffff,
4157                     "%s scan list size %d\n", __func__, vha->scan.size);
4158
4159                 memset(vha->scan.l, 0, vha->scan.size);
4160         } else if (!sp) {
4161                 ql_dbg(ql_dbg_disc, vha, 0xffff,
4162                     "NVME scan did not provide SP\n");
4163                 return rval;
4164         }
4165
4166         sp->type = SRB_CT_PTHRU_CMD;
4167         sp->name = "gpnft";
4168         sp->gen1 = vha->hw->base_qpair->chip_reset;
4169         sp->gen2 = fc4_type;
4170
4171         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
4172         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
4173
4174         rspsz = sp->u.iocb_cmd.u.ctarg.rsp_size;
4175         memset(sp->u.iocb_cmd.u.ctarg.rsp, 0, sp->u.iocb_cmd.u.ctarg.rsp_size);
4176         memset(sp->u.iocb_cmd.u.ctarg.req, 0, sp->u.iocb_cmd.u.ctarg.req_size);
4177
4178         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
4179         /* CT_IU preamble  */
4180         ct_req = qla2x00_prep_ct_req(ct_sns, GPN_FT_CMD, rspsz);
4181
4182         /* GPN_FT req */
4183         ct_req->req.gpn_ft.port_type = fc4_type;
4184
4185         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
4186
4187         sp->done = qla2x00_async_gpnft_gnnft_sp_done;
4188
4189         ql_dbg(ql_dbg_disc, vha, 0xffff,
4190             "Async-%s hdl=%x FC4Type %x.\n", sp->name,
4191             sp->handle, ct_req->req.gpn_ft.port_type);
4192
4193         rval = qla2x00_start_sp(sp);
4194         if (rval != QLA_SUCCESS) {
4195                 goto done_free_sp;
4196         }
4197
4198         return rval;
4199
4200 done_free_sp:
4201         if (sp->u.iocb_cmd.u.ctarg.req) {
4202                 dma_free_coherent(&vha->hw->pdev->dev,
4203                     sp->u.iocb_cmd.u.ctarg.req_allocated_size,
4204                     sp->u.iocb_cmd.u.ctarg.req,
4205                     sp->u.iocb_cmd.u.ctarg.req_dma);
4206                 sp->u.iocb_cmd.u.ctarg.req = NULL;
4207         }
4208         if (sp->u.iocb_cmd.u.ctarg.rsp) {
4209                 dma_free_coherent(&vha->hw->pdev->dev,
4210                     sp->u.iocb_cmd.u.ctarg.rsp_allocated_size,
4211                     sp->u.iocb_cmd.u.ctarg.rsp,
4212                     sp->u.iocb_cmd.u.ctarg.rsp_dma);
4213                 sp->u.iocb_cmd.u.ctarg.rsp = NULL;
4214         }
4215
4216         sp->free(sp);
4217
4218         spin_lock_irqsave(&vha->work_lock, flags);
4219         vha->scan.scan_flags &= ~SF_SCANNING;
4220         if (vha->scan.scan_flags == 0) {
4221                 ql_dbg(ql_dbg_disc, vha, 0xffff,
4222                     "%s: schedule\n", __func__);
4223                 vha->scan.scan_flags |= SF_QUEUED;
4224                 schedule_delayed_work(&vha->scan.scan_work, 5);
4225         }
4226         spin_unlock_irqrestore(&vha->work_lock, flags);
4227
4228
4229         return rval;
4230 }
4231
4232 void qla_scan_work_fn(struct work_struct *work)
4233 {
4234         struct fab_scan *s = container_of(to_delayed_work(work),
4235             struct fab_scan, scan_work);
4236         struct scsi_qla_host *vha = container_of(s, struct scsi_qla_host,
4237             scan);
4238         unsigned long flags;
4239
4240         ql_dbg(ql_dbg_disc, vha, 0xffff,
4241             "%s: schedule loop resync\n", __func__);
4242         set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
4243         set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
4244         qla2xxx_wake_dpc(vha);
4245         spin_lock_irqsave(&vha->work_lock, flags);
4246         vha->scan.scan_flags &= ~SF_QUEUED;
4247         spin_unlock_irqrestore(&vha->work_lock, flags);
4248 }
4249
4250 /* GNN_ID */
4251 void qla24xx_handle_gnnid_event(scsi_qla_host_t *vha, struct event_arg *ea)
4252 {
4253         qla24xx_post_gnl_work(vha, ea->fcport);
4254 }
4255
4256 static void qla2x00_async_gnnid_sp_done(srb_t *sp, int res)
4257 {
4258         struct scsi_qla_host *vha = sp->vha;
4259         fc_port_t *fcport = sp->fcport;
4260         u8 *node_name = fcport->ct_desc.ct_sns->p.rsp.rsp.gnn_id.node_name;
4261         struct event_arg ea;
4262         u64 wwnn;
4263
4264         fcport->flags &= ~FCF_ASYNC_SENT;
4265         wwnn = wwn_to_u64(node_name);
4266         if (wwnn)
4267                 memcpy(fcport->node_name, node_name, WWN_SIZE);
4268
4269         memset(&ea, 0, sizeof(ea));
4270         ea.fcport = fcport;
4271         ea.sp = sp;
4272         ea.rc = res;
4273
4274         ql_dbg(ql_dbg_disc, vha, 0x204f,
4275             "Async done-%s res %x, WWPN %8phC %8phC\n",
4276             sp->name, res, fcport->port_name, fcport->node_name);
4277
4278         qla24xx_handle_gnnid_event(vha, &ea);
4279
4280         sp->free(sp);
4281 }
4282
4283 int qla24xx_async_gnnid(scsi_qla_host_t *vha, fc_port_t *fcport)
4284 {
4285         int rval = QLA_FUNCTION_FAILED;
4286         struct ct_sns_req       *ct_req;
4287         srb_t *sp;
4288
4289         if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT))
4290                 return rval;
4291
4292         qla2x00_set_fcport_disc_state(fcport, DSC_GNN_ID);
4293         sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
4294         if (!sp)
4295                 goto done;
4296
4297         fcport->flags |= FCF_ASYNC_SENT;
4298         sp->type = SRB_CT_PTHRU_CMD;
4299         sp->name = "gnnid";
4300         sp->gen1 = fcport->rscn_gen;
4301         sp->gen2 = fcport->login_gen;
4302
4303         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
4304         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
4305
4306         /* CT_IU preamble  */
4307         ct_req = qla2x00_prep_ct_req(fcport->ct_desc.ct_sns, GNN_ID_CMD,
4308             GNN_ID_RSP_SIZE);
4309
4310         /* GNN_ID req */
4311         ct_req->req.port_id.port_id = port_id_to_be_id(fcport->d_id);
4312
4313
4314         /* req & rsp use the same buffer */
4315         sp->u.iocb_cmd.u.ctarg.req = fcport->ct_desc.ct_sns;
4316         sp->u.iocb_cmd.u.ctarg.req_dma = fcport->ct_desc.ct_sns_dma;
4317         sp->u.iocb_cmd.u.ctarg.rsp = fcport->ct_desc.ct_sns;
4318         sp->u.iocb_cmd.u.ctarg.rsp_dma = fcport->ct_desc.ct_sns_dma;
4319         sp->u.iocb_cmd.u.ctarg.req_size = GNN_ID_REQ_SIZE;
4320         sp->u.iocb_cmd.u.ctarg.rsp_size = GNN_ID_RSP_SIZE;
4321         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
4322
4323         sp->done = qla2x00_async_gnnid_sp_done;
4324
4325         ql_dbg(ql_dbg_disc, vha, 0xffff,
4326             "Async-%s - %8phC hdl=%x loopid=%x portid %06x.\n",
4327             sp->name, fcport->port_name,
4328             sp->handle, fcport->loop_id, fcport->d_id.b24);
4329
4330         rval = qla2x00_start_sp(sp);
4331         if (rval != QLA_SUCCESS)
4332                 goto done_free_sp;
4333         return rval;
4334
4335 done_free_sp:
4336         sp->free(sp);
4337         fcport->flags &= ~FCF_ASYNC_SENT;
4338 done:
4339         return rval;
4340 }
4341
4342 int qla24xx_post_gnnid_work(struct scsi_qla_host *vha, fc_port_t *fcport)
4343 {
4344         struct qla_work_evt *e;
4345         int ls;
4346
4347         ls = atomic_read(&vha->loop_state);
4348         if (((ls != LOOP_READY) && (ls != LOOP_UP)) ||
4349                 test_bit(UNLOADING, &vha->dpc_flags))
4350                 return 0;
4351
4352         e = qla2x00_alloc_work(vha, QLA_EVT_GNNID);
4353         if (!e)
4354                 return QLA_FUNCTION_FAILED;
4355
4356         e->u.fcport.fcport = fcport;
4357         return qla2x00_post_work(vha, e);
4358 }
4359
4360 /* GPFN_ID */
4361 void qla24xx_handle_gfpnid_event(scsi_qla_host_t *vha, struct event_arg *ea)
4362 {
4363         fc_port_t *fcport = ea->fcport;
4364
4365         ql_dbg(ql_dbg_disc, vha, 0xffff,
4366             "%s %8phC DS %d LS %d rc %d login %d|%d rscn %d|%d fcpcnt %d\n",
4367             __func__, fcport->port_name, fcport->disc_state,
4368             fcport->fw_login_state, ea->rc, fcport->login_gen, ea->sp->gen2,
4369             fcport->rscn_gen, ea->sp->gen1, vha->fcport_count);
4370
4371         if (fcport->disc_state == DSC_DELETE_PEND)
4372                 return;
4373
4374         if (ea->sp->gen2 != fcport->login_gen) {
4375                 /* target side must have changed it. */
4376                 ql_dbg(ql_dbg_disc, vha, 0x20d3,
4377                     "%s %8phC generation changed\n",
4378                     __func__, fcport->port_name);
4379                 return;
4380         } else if (ea->sp->gen1 != fcport->rscn_gen) {
4381                 return;
4382         }
4383
4384         qla24xx_post_gpsc_work(vha, fcport);
4385 }
4386
4387 static void qla2x00_async_gfpnid_sp_done(srb_t *sp, int res)
4388 {
4389         struct scsi_qla_host *vha = sp->vha;
4390         fc_port_t *fcport = sp->fcport;
4391         u8 *fpn = fcport->ct_desc.ct_sns->p.rsp.rsp.gfpn_id.port_name;
4392         struct event_arg ea;
4393         u64 wwn;
4394
4395         wwn = wwn_to_u64(fpn);
4396         if (wwn)
4397                 memcpy(fcport->fabric_port_name, fpn, WWN_SIZE);
4398
4399         memset(&ea, 0, sizeof(ea));
4400         ea.fcport = fcport;
4401         ea.sp = sp;
4402         ea.rc = res;
4403
4404         ql_dbg(ql_dbg_disc, vha, 0x204f,
4405             "Async done-%s res %x, WWPN %8phC %8phC\n",
4406             sp->name, res, fcport->port_name, fcport->fabric_port_name);
4407
4408         qla24xx_handle_gfpnid_event(vha, &ea);
4409
4410         sp->free(sp);
4411 }
4412
4413 int qla24xx_async_gfpnid(scsi_qla_host_t *vha, fc_port_t *fcport)
4414 {
4415         int rval = QLA_FUNCTION_FAILED;
4416         struct ct_sns_req       *ct_req;
4417         srb_t *sp;
4418
4419         if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT))
4420                 return rval;
4421
4422         sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
4423         if (!sp)
4424                 goto done;
4425
4426         sp->type = SRB_CT_PTHRU_CMD;
4427         sp->name = "gfpnid";
4428         sp->gen1 = fcport->rscn_gen;
4429         sp->gen2 = fcport->login_gen;
4430
4431         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
4432         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
4433
4434         /* CT_IU preamble  */
4435         ct_req = qla2x00_prep_ct_req(fcport->ct_desc.ct_sns, GFPN_ID_CMD,
4436             GFPN_ID_RSP_SIZE);
4437
4438         /* GFPN_ID req */
4439         ct_req->req.port_id.port_id = port_id_to_be_id(fcport->d_id);
4440
4441
4442         /* req & rsp use the same buffer */
4443         sp->u.iocb_cmd.u.ctarg.req = fcport->ct_desc.ct_sns;
4444         sp->u.iocb_cmd.u.ctarg.req_dma = fcport->ct_desc.ct_sns_dma;
4445         sp->u.iocb_cmd.u.ctarg.rsp = fcport->ct_desc.ct_sns;
4446         sp->u.iocb_cmd.u.ctarg.rsp_dma = fcport->ct_desc.ct_sns_dma;
4447         sp->u.iocb_cmd.u.ctarg.req_size = GFPN_ID_REQ_SIZE;
4448         sp->u.iocb_cmd.u.ctarg.rsp_size = GFPN_ID_RSP_SIZE;
4449         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
4450
4451         sp->done = qla2x00_async_gfpnid_sp_done;
4452
4453         ql_dbg(ql_dbg_disc, vha, 0xffff,
4454             "Async-%s - %8phC hdl=%x loopid=%x portid %06x.\n",
4455             sp->name, fcport->port_name,
4456             sp->handle, fcport->loop_id, fcport->d_id.b24);
4457
4458         rval = qla2x00_start_sp(sp);
4459         if (rval != QLA_SUCCESS)
4460                 goto done_free_sp;
4461
4462         return rval;
4463
4464 done_free_sp:
4465         sp->free(sp);
4466         fcport->flags &= ~FCF_ASYNC_SENT;
4467 done:
4468         return rval;
4469 }
4470
4471 int qla24xx_post_gfpnid_work(struct scsi_qla_host *vha, fc_port_t *fcport)
4472 {
4473         struct qla_work_evt *e;
4474         int ls;
4475
4476         ls = atomic_read(&vha->loop_state);
4477         if (((ls != LOOP_READY) && (ls != LOOP_UP)) ||
4478                 test_bit(UNLOADING, &vha->dpc_flags))
4479                 return 0;
4480
4481         e = qla2x00_alloc_work(vha, QLA_EVT_GFPNID);
4482         if (!e)
4483                 return QLA_FUNCTION_FAILED;
4484
4485         e->u.fcport.fcport = fcport;
4486         return qla2x00_post_work(vha, e);
4487 }