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