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 init_cb_24xx *icb24 = (struct init_cb_24xx *)ha->init_cb;
1958         struct new_utsname *p_sysid = NULL;
1959
1960         /* Issue RHBA */
1961         /* Prepare common MS IOCB */
1962         /*   Request size adjusted after CT preparation */
1963         ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, RHBA_RSP_SIZE);
1964
1965         /* Prepare CT request */
1966         ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RHBA_CMD,
1967             RHBA_RSP_SIZE);
1968         ct_rsp = &ha->ct_sns->p.rsp;
1969
1970         /* Prepare FDMI command arguments -- attribute block, attributes. */
1971         memcpy(ct_req->req.rhba2.hba_identifier, vha->port_name, WWN_SIZE);
1972         ct_req->req.rhba2.entry_count = cpu_to_be32(1);
1973         memcpy(ct_req->req.rhba2.port_name, vha->port_name, WWN_SIZE);
1974         size = 2 * WWN_SIZE + 4 + 4;
1975
1976         /* Attributes */
1977         ct_req->req.rhba2.attrs.count = cpu_to_be32(FDMIV2_HBA_ATTR_COUNT);
1978         entries = ct_req->req.rhba2.hba_identifier;
1979
1980         /* Nodename. */
1981         eiter = entries + size;
1982         eiter->type = cpu_to_be16(FDMI_HBA_NODE_NAME);
1983         eiter->len = cpu_to_be16(4 + WWN_SIZE);
1984         memcpy(eiter->a.node_name, vha->node_name, WWN_SIZE);
1985         size += 4 + WWN_SIZE;
1986
1987         ql_dbg(ql_dbg_disc, vha, 0x207d,
1988             "NodeName = %016llx.\n", wwn_to_u64(eiter->a.node_name));
1989
1990         /* Manufacturer. */
1991         eiter = entries + size;
1992         eiter->type = cpu_to_be16(FDMI_HBA_MANUFACTURER);
1993         snprintf(eiter->a.manufacturer, sizeof(eiter->a.manufacturer),
1994             "%s", "QLogic Corporation");
1995         eiter->a.manufacturer[strlen("QLogic Corporation")] = '\0';
1996         alen = strlen(eiter->a.manufacturer);
1997         alen += 4 - (alen & 3);
1998         eiter->len = cpu_to_be16(4 + alen);
1999         size += 4 + alen;
2000
2001         ql_dbg(ql_dbg_disc, vha, 0x20a5,
2002             "Manufacturer = %s.\n", eiter->a.manufacturer);
2003
2004         /* Serial number. */
2005         eiter = entries + size;
2006         eiter->type = cpu_to_be16(FDMI_HBA_SERIAL_NUMBER);
2007         if (IS_FWI2_CAPABLE(ha))
2008                 qla2xxx_get_vpd_field(vha, "SN", eiter->a.serial_num,
2009                     sizeof(eiter->a.serial_num));
2010         else {
2011                 sn = ((ha->serial0 & 0x1f) << 16) |
2012                         (ha->serial2 << 8) | ha->serial1;
2013                 snprintf(eiter->a.serial_num, sizeof(eiter->a.serial_num),
2014                     "%c%05d", 'A' + sn / 100000, sn % 100000);
2015         }
2016         alen = strlen(eiter->a.serial_num);
2017         alen += 4 - (alen & 3);
2018         eiter->len = cpu_to_be16(4 + alen);
2019         size += 4 + alen;
2020
2021         ql_dbg(ql_dbg_disc, vha, 0x20a6,
2022             "Serial no. = %s.\n", eiter->a.serial_num);
2023
2024         /* Model name. */
2025         eiter = entries + size;
2026         eiter->type = cpu_to_be16(FDMI_HBA_MODEL);
2027         snprintf(eiter->a.model, sizeof(eiter->a.model),
2028             "%s", ha->model_number);
2029         alen = strlen(eiter->a.model);
2030         alen += 4 - (alen & 3);
2031         eiter->len = cpu_to_be16(4 + alen);
2032         size += 4 + alen;
2033
2034         ql_dbg(ql_dbg_disc, vha, 0x20a7,
2035             "Model Name = %s.\n", eiter->a.model);
2036
2037         /* Model description. */
2038         eiter = entries + size;
2039         eiter->type = cpu_to_be16(FDMI_HBA_MODEL_DESCRIPTION);
2040         snprintf(eiter->a.model_desc, sizeof(eiter->a.model_desc),
2041             "%s", ha->model_desc);
2042         alen = strlen(eiter->a.model_desc);
2043         alen += 4 - (alen & 3);
2044         eiter->len = cpu_to_be16(4 + alen);
2045         size += 4 + alen;
2046
2047         ql_dbg(ql_dbg_disc, vha, 0x20a8,
2048             "Model Desc = %s.\n", eiter->a.model_desc);
2049
2050         /* Hardware version. */
2051         eiter = entries + size;
2052         eiter->type = cpu_to_be16(FDMI_HBA_HARDWARE_VERSION);
2053         if (!IS_FWI2_CAPABLE(ha)) {
2054                 snprintf(eiter->a.hw_version, sizeof(eiter->a.hw_version),
2055                     "HW:%s", ha->adapter_id);
2056         } else if (qla2xxx_get_vpd_field(vha, "MN", eiter->a.hw_version,
2057                     sizeof(eiter->a.hw_version))) {
2058                 ;
2059         } else if (qla2xxx_get_vpd_field(vha, "EC", eiter->a.hw_version,
2060                     sizeof(eiter->a.hw_version))) {
2061                 ;
2062         } else {
2063                 snprintf(eiter->a.hw_version, sizeof(eiter->a.hw_version),
2064                     "HW:%s", ha->adapter_id);
2065         }
2066         alen = strlen(eiter->a.hw_version);
2067         alen += 4 - (alen & 3);
2068         eiter->len = cpu_to_be16(4 + alen);
2069         size += 4 + alen;
2070
2071         ql_dbg(ql_dbg_disc, vha, 0x20a9,
2072             "Hardware ver = %s.\n", eiter->a.hw_version);
2073
2074         /* Driver version. */
2075         eiter = entries + size;
2076         eiter->type = cpu_to_be16(FDMI_HBA_DRIVER_VERSION);
2077         snprintf(eiter->a.driver_version, sizeof(eiter->a.driver_version),
2078             "%s", qla2x00_version_str);
2079         alen = strlen(eiter->a.driver_version);
2080         alen += 4 - (alen & 3);
2081         eiter->len = cpu_to_be16(4 + alen);
2082         size += 4 + alen;
2083
2084         ql_dbg(ql_dbg_disc, vha, 0x20aa,
2085             "Driver ver = %s.\n", eiter->a.driver_version);
2086
2087         /* Option ROM version. */
2088         eiter = entries + size;
2089         eiter->type = cpu_to_be16(FDMI_HBA_OPTION_ROM_VERSION);
2090         snprintf(eiter->a.orom_version, sizeof(eiter->a.orom_version),
2091             "%d.%02d", ha->bios_revision[1], ha->bios_revision[0]);
2092         alen = strlen(eiter->a.orom_version);
2093         alen += 4 - (alen & 3);
2094         eiter->len = cpu_to_be16(4 + alen);
2095         size += 4 + alen;
2096
2097         ql_dbg(ql_dbg_disc, vha , 0x20ab,
2098             "Optrom version = %d.%02d.\n", eiter->a.orom_version[1],
2099             eiter->a.orom_version[0]);
2100
2101         /* Firmware version */
2102         eiter = entries + size;
2103         eiter->type = cpu_to_be16(FDMI_HBA_FIRMWARE_VERSION);
2104         ha->isp_ops->fw_version_str(vha, eiter->a.fw_version,
2105             sizeof(eiter->a.fw_version));
2106         alen = strlen(eiter->a.fw_version);
2107         alen += 4 - (alen & 3);
2108         eiter->len = cpu_to_be16(4 + alen);
2109         size += 4 + alen;
2110
2111         ql_dbg(ql_dbg_disc, vha, 0x20ac,
2112             "Firmware vers = %s.\n", eiter->a.fw_version);
2113
2114         /* OS Name and Version */
2115         eiter = entries + size;
2116         eiter->type = cpu_to_be16(FDMI_HBA_OS_NAME_AND_VERSION);
2117         p_sysid = utsname();
2118         if (p_sysid) {
2119                 snprintf(eiter->a.os_version, sizeof(eiter->a.os_version),
2120                     "%s %s %s",
2121                     p_sysid->sysname, p_sysid->release, p_sysid->version);
2122         } else {
2123                 snprintf(eiter->a.os_version, sizeof(eiter->a.os_version),
2124                     "%s %s", "Linux", fc_host_system_hostname(vha->host));
2125         }
2126         alen = strlen(eiter->a.os_version);
2127         alen += 4 - (alen & 3);
2128         eiter->len = cpu_to_be16(4 + alen);
2129         size += 4 + alen;
2130
2131         ql_dbg(ql_dbg_disc, vha, 0x20ae,
2132             "OS Name and Version = %s.\n", eiter->a.os_version);
2133
2134         /* MAX CT Payload Length */
2135         eiter = entries + size;
2136         eiter->type = cpu_to_be16(FDMI_HBA_MAXIMUM_CT_PAYLOAD_LENGTH);
2137         eiter->a.max_ct_len = IS_FWI2_CAPABLE(ha) ?
2138             le16_to_cpu(icb24->frame_payload_size) :
2139             le16_to_cpu(ha->init_cb->frame_payload_size);
2140         eiter->a.max_ct_len = cpu_to_be32(eiter->a.max_ct_len);
2141         eiter->len = cpu_to_be16(4 + 4);
2142         size += 4 + 4;
2143
2144         ql_dbg(ql_dbg_disc, vha, 0x20af,
2145             "CT Payload Length = 0x%x.\n", eiter->a.max_ct_len);
2146
2147         /* Node Sybolic Name */
2148         eiter = entries + size;
2149         eiter->type = cpu_to_be16(FDMI_HBA_NODE_SYMBOLIC_NAME);
2150         qla2x00_get_sym_node_name(vha, eiter->a.sym_name,
2151             sizeof(eiter->a.sym_name));
2152         alen = strlen(eiter->a.sym_name);
2153         alen += 4 - (alen & 3);
2154         eiter->len = cpu_to_be16(4 + alen);
2155         size += 4 + alen;
2156
2157         ql_dbg(ql_dbg_disc, vha, 0x20b0,
2158             "Symbolic Name = %s.\n", eiter->a.sym_name);
2159
2160         /* Vendor Id */
2161         eiter = entries + size;
2162         eiter->type = cpu_to_be16(FDMI_HBA_VENDOR_ID);
2163         eiter->a.vendor_id = cpu_to_be32(0x1077);
2164         eiter->len = cpu_to_be16(4 + 4);
2165         size += 4 + 4;
2166
2167         ql_dbg(ql_dbg_disc, vha, 0x20b1,
2168             "Vendor Id = %x.\n", eiter->a.vendor_id);
2169
2170         /* Num Ports */
2171         eiter = entries + size;
2172         eiter->type = cpu_to_be16(FDMI_HBA_NUM_PORTS);
2173         eiter->a.num_ports = cpu_to_be32(1);
2174         eiter->len = cpu_to_be16(4 + 4);
2175         size += 4 + 4;
2176
2177         ql_dbg(ql_dbg_disc, vha, 0x20b2,
2178             "Port Num = %x.\n", eiter->a.num_ports);
2179
2180         /* Fabric Name */
2181         eiter = entries + size;
2182         eiter->type = cpu_to_be16(FDMI_HBA_FABRIC_NAME);
2183         memcpy(eiter->a.fabric_name, vha->fabric_node_name, WWN_SIZE);
2184         eiter->len = cpu_to_be16(4 + WWN_SIZE);
2185         size += 4 + WWN_SIZE;
2186
2187         ql_dbg(ql_dbg_disc, vha, 0x20b3,
2188             "Fabric Name = %016llx.\n", wwn_to_u64(eiter->a.fabric_name));
2189
2190         /* BIOS Version */
2191         eiter = entries + size;
2192         eiter->type = cpu_to_be16(FDMI_HBA_BOOT_BIOS_NAME);
2193         snprintf(eiter->a.bios_name, sizeof(eiter->a.bios_name),
2194             "BIOS %d.%02d", ha->bios_revision[1], ha->bios_revision[0]);
2195         alen = strlen(eiter->a.bios_name);
2196         alen += 4 - (alen & 3);
2197         eiter->len = cpu_to_be16(4 + alen);
2198         size += 4 + alen;
2199
2200         ql_dbg(ql_dbg_disc, vha, 0x20b4,
2201             "BIOS Name = %s\n", eiter->a.bios_name);
2202
2203         /* Vendor Identifier */
2204         eiter = entries + size;
2205         eiter->type = cpu_to_be16(FDMI_HBA_TYPE_VENDOR_IDENTIFIER);
2206         snprintf(eiter->a.vendor_identifier, sizeof(eiter->a.vendor_identifier),
2207             "%s", "QLGC");
2208         alen = strlen(eiter->a.vendor_identifier);
2209         alen += 4 - (alen & 3);
2210         eiter->len = cpu_to_be16(4 + alen);
2211         size += 4 + alen;
2212
2213         ql_dbg(ql_dbg_disc, vha, 0x201b,
2214             "Vendor Identifier = %s.\n", eiter->a.vendor_identifier);
2215
2216         /* Update MS request size. */
2217         qla2x00_update_ms_fdmi_iocb(vha, size + 16);
2218
2219         ql_dbg(ql_dbg_disc, vha, 0x20b5,
2220             "RHBA identifier = %016llx.\n",
2221             wwn_to_u64(ct_req->req.rhba2.hba_identifier));
2222         ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x20b6,
2223             entries, size);
2224
2225         /* Execute MS IOCB */
2226         rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2227             sizeof(ms_iocb_entry_t));
2228         if (rval != QLA_SUCCESS) {
2229                 /*EMPTY*/
2230                 ql_dbg(ql_dbg_disc, vha, 0x20b7,
2231                     "RHBA issue IOCB failed (%d).\n", rval);
2232         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RHBA") !=
2233             QLA_SUCCESS) {
2234                 rval = QLA_FUNCTION_FAILED;
2235
2236                 if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
2237                     ct_rsp->header.explanation_code ==
2238                     CT_EXPL_ALREADY_REGISTERED) {
2239                         ql_dbg(ql_dbg_disc, vha, 0x20b8,
2240                             "HBA already registered.\n");
2241                         rval = QLA_ALREADY_REGISTERED;
2242                 } else {
2243                         ql_dbg(ql_dbg_disc, vha, 0x2016,
2244                             "RHBA FDMI v2 failed, CT Reason code: 0x%x, CT Explanation 0x%x\n",
2245                             ct_rsp->header.reason_code,
2246                             ct_rsp->header.explanation_code);
2247                 }
2248         } else {
2249                 ql_dbg(ql_dbg_disc, vha, 0x20b9,
2250                     "RHBA FDMI V2 exiting normally.\n");
2251         }
2252
2253         return rval;
2254 }
2255
2256 /**
2257  * qla2x00_fdmi_dhba() -
2258  * @vha: HA context
2259  *
2260  * Returns 0 on success.
2261  */
2262 static int
2263 qla2x00_fdmi_dhba(scsi_qla_host_t *vha)
2264 {
2265         int rval;
2266         struct qla_hw_data *ha = vha->hw;
2267         ms_iocb_entry_t *ms_pkt;
2268         struct ct_sns_req *ct_req;
2269         struct ct_sns_rsp *ct_rsp;
2270
2271         /* Issue RPA */
2272         /* Prepare common MS IOCB */
2273         ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, DHBA_REQ_SIZE,
2274             DHBA_RSP_SIZE);
2275
2276         /* Prepare CT request */
2277         ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, DHBA_CMD, DHBA_RSP_SIZE);
2278         ct_rsp = &ha->ct_sns->p.rsp;
2279
2280         /* Prepare FDMI command arguments -- portname. */
2281         memcpy(ct_req->req.dhba.port_name, vha->port_name, WWN_SIZE);
2282
2283         ql_dbg(ql_dbg_disc, vha, 0x2036,
2284             "DHBA portname = %8phN.\n", ct_req->req.dhba.port_name);
2285
2286         /* Execute MS IOCB */
2287         rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2288             sizeof(ms_iocb_entry_t));
2289         if (rval != QLA_SUCCESS) {
2290                 /*EMPTY*/
2291                 ql_dbg(ql_dbg_disc, vha, 0x2037,
2292                     "DHBA issue IOCB failed (%d).\n", rval);
2293         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "DHBA") !=
2294             QLA_SUCCESS) {
2295                 rval = QLA_FUNCTION_FAILED;
2296         } else {
2297                 ql_dbg(ql_dbg_disc, vha, 0x2038,
2298                     "DHBA exiting normally.\n");
2299         }
2300
2301         return rval;
2302 }
2303
2304 /**
2305  * qla2x00_fdmiv2_rpa() -
2306  * @vha: HA context
2307  *
2308  * Returns 0 on success.
2309  */
2310 static int
2311 qla2x00_fdmiv2_rpa(scsi_qla_host_t *vha)
2312 {
2313         int rval, alen;
2314         uint32_t size;
2315         struct qla_hw_data *ha = vha->hw;
2316         ms_iocb_entry_t *ms_pkt;
2317         struct ct_sns_req *ct_req;
2318         struct ct_sns_rsp *ct_rsp;
2319         void *entries;
2320         struct ct_fdmiv2_port_attr *eiter;
2321         struct init_cb_24xx *icb24 = (struct init_cb_24xx *)ha->init_cb;
2322         struct new_utsname *p_sysid = NULL;
2323
2324         /* Issue RPA */
2325         /* Prepare common MS IOCB */
2326         /*   Request size adjusted after CT preparation */
2327         ms_pkt = ha->isp_ops->prep_ms_fdmi_iocb(vha, 0, RPA_RSP_SIZE);
2328
2329         /* Prepare CT request */
2330         ct_req = qla2x00_prep_ct_fdmi_req(ha->ct_sns, RPA_CMD, RPA_RSP_SIZE);
2331         ct_rsp = &ha->ct_sns->p.rsp;
2332
2333         /* Prepare FDMI command arguments -- attribute block, attributes. */
2334         memcpy(ct_req->req.rpa2.port_name, vha->port_name, WWN_SIZE);
2335         size = WWN_SIZE + 4;
2336
2337         /* Attributes */
2338         ct_req->req.rpa2.attrs.count = cpu_to_be32(FDMIV2_PORT_ATTR_COUNT);
2339         entries = ct_req->req.rpa2.port_name;
2340
2341         /* FC4 types. */
2342         eiter = entries + size;
2343         eiter->type = cpu_to_be16(FDMI_PORT_FC4_TYPES);
2344         eiter->len = cpu_to_be16(4 + 32);
2345         eiter->a.fc4_types[2] = 0x01;
2346         size += 4 + 32;
2347
2348         ql_dbg(ql_dbg_disc, vha, 0x20ba,
2349             "FC4_TYPES=%02x %02x.\n",
2350             eiter->a.fc4_types[2],
2351             eiter->a.fc4_types[1]);
2352
2353         if (vha->flags.nvme_enabled) {
2354                 eiter->a.fc4_types[6] = 1;      /* NVMe type 28h */
2355                 ql_dbg(ql_dbg_disc, vha, 0x211f,
2356                     "NVME FC4 Type = %02x 0x0 0x0 0x0 0x0 0x0.\n",
2357                     eiter->a.fc4_types[6]);
2358         }
2359
2360         /* Supported speed. */
2361         eiter = entries + size;
2362         eiter->type = cpu_to_be16(FDMI_PORT_SUPPORT_SPEED);
2363         eiter->len = cpu_to_be16(4 + 4);
2364         if (IS_CNA_CAPABLE(ha))
2365                 eiter->a.sup_speed = cpu_to_be32(
2366                     FDMI_PORT_SPEED_10GB);
2367         else if (IS_QLA27XX(ha))
2368                 eiter->a.sup_speed = cpu_to_be32(
2369                     FDMI_PORT_SPEED_32GB|
2370                     FDMI_PORT_SPEED_16GB|
2371                     FDMI_PORT_SPEED_8GB);
2372         else if (IS_QLA2031(ha))
2373                 eiter->a.sup_speed = cpu_to_be32(
2374                     FDMI_PORT_SPEED_16GB|
2375                     FDMI_PORT_SPEED_8GB|
2376                     FDMI_PORT_SPEED_4GB);
2377         else if (IS_QLA25XX(ha))
2378                 eiter->a.sup_speed = cpu_to_be32(
2379                     FDMI_PORT_SPEED_8GB|
2380                     FDMI_PORT_SPEED_4GB|
2381                     FDMI_PORT_SPEED_2GB|
2382                     FDMI_PORT_SPEED_1GB);
2383         else if (IS_QLA24XX_TYPE(ha))
2384                 eiter->a.sup_speed = cpu_to_be32(
2385                     FDMI_PORT_SPEED_4GB|
2386                     FDMI_PORT_SPEED_2GB|
2387                     FDMI_PORT_SPEED_1GB);
2388         else if (IS_QLA23XX(ha))
2389                 eiter->a.sup_speed = cpu_to_be32(
2390                     FDMI_PORT_SPEED_2GB|
2391                     FDMI_PORT_SPEED_1GB);
2392         else
2393                 eiter->a.sup_speed = cpu_to_be32(
2394                     FDMI_PORT_SPEED_1GB);
2395         size += 4 + 4;
2396
2397         ql_dbg(ql_dbg_disc, vha, 0x20bb,
2398             "Supported Port Speed = %x.\n", eiter->a.sup_speed);
2399
2400         /* Current speed. */
2401         eiter = entries + size;
2402         eiter->type = cpu_to_be16(FDMI_PORT_CURRENT_SPEED);
2403         eiter->len = cpu_to_be16(4 + 4);
2404         switch (ha->link_data_rate) {
2405         case PORT_SPEED_1GB:
2406                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_1GB);
2407                 break;
2408         case PORT_SPEED_2GB:
2409                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_2GB);
2410                 break;
2411         case PORT_SPEED_4GB:
2412                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_4GB);
2413                 break;
2414         case PORT_SPEED_8GB:
2415                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_8GB);
2416                 break;
2417         case PORT_SPEED_10GB:
2418                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_10GB);
2419                 break;
2420         case PORT_SPEED_16GB:
2421                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_16GB);
2422                 break;
2423         case PORT_SPEED_32GB:
2424                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_32GB);
2425                 break;
2426         default:
2427                 eiter->a.cur_speed = cpu_to_be32(FDMI_PORT_SPEED_UNKNOWN);
2428                 break;
2429         }
2430         size += 4 + 4;
2431
2432         ql_dbg(ql_dbg_disc, vha, 0x2017,
2433             "Current_Speed = %x.\n", eiter->a.cur_speed);
2434
2435         /* Max frame size. */
2436         eiter = entries + size;
2437         eiter->type = cpu_to_be16(FDMI_PORT_MAX_FRAME_SIZE);
2438         eiter->len = cpu_to_be16(4 + 4);
2439         eiter->a.max_frame_size = IS_FWI2_CAPABLE(ha) ?
2440             le16_to_cpu(icb24->frame_payload_size):
2441             le16_to_cpu(ha->init_cb->frame_payload_size);
2442         eiter->a.max_frame_size = cpu_to_be32(eiter->a.max_frame_size);
2443         size += 4 + 4;
2444
2445         ql_dbg(ql_dbg_disc, vha, 0x20bc,
2446             "Max_Frame_Size = %x.\n", eiter->a.max_frame_size);
2447
2448         /* OS device name. */
2449         eiter = entries + size;
2450         eiter->type = cpu_to_be16(FDMI_PORT_OS_DEVICE_NAME);
2451         alen = strlen(QLA2XXX_DRIVER_NAME);
2452         snprintf(eiter->a.os_dev_name, sizeof(eiter->a.os_dev_name),
2453             "%s:host%lu", QLA2XXX_DRIVER_NAME, vha->host_no);
2454         alen += 4 - (alen & 3);
2455         eiter->len = cpu_to_be16(4 + alen);
2456         size += 4 + alen;
2457
2458         ql_dbg(ql_dbg_disc, vha, 0x20be,
2459             "OS_Device_Name = %s.\n", eiter->a.os_dev_name);
2460
2461         /* Hostname. */
2462         eiter = entries + size;
2463         eiter->type = cpu_to_be16(FDMI_PORT_HOST_NAME);
2464         p_sysid = utsname();
2465         if (p_sysid) {
2466                 snprintf(eiter->a.host_name, sizeof(eiter->a.host_name),
2467                     "%s", p_sysid->nodename);
2468         } else {
2469                 snprintf(eiter->a.host_name, sizeof(eiter->a.host_name),
2470                     "%s", fc_host_system_hostname(vha->host));
2471         }
2472         alen = strlen(eiter->a.host_name);
2473         alen += 4 - (alen & 3);
2474         eiter->len = cpu_to_be16(4 + alen);
2475         size += 4 + alen;
2476
2477         ql_dbg(ql_dbg_disc, vha, 0x201a,
2478             "HostName=%s.\n", eiter->a.host_name);
2479
2480         /* Node Name */
2481         eiter = entries + size;
2482         eiter->type = cpu_to_be16(FDMI_PORT_NODE_NAME);
2483         memcpy(eiter->a.node_name, vha->node_name, WWN_SIZE);
2484         eiter->len = cpu_to_be16(4 + WWN_SIZE);
2485         size += 4 + WWN_SIZE;
2486
2487         ql_dbg(ql_dbg_disc, vha, 0x20c0,
2488             "Node Name = %016llx.\n", wwn_to_u64(eiter->a.node_name));
2489
2490         /* Port Name */
2491         eiter = entries + size;
2492         eiter->type = cpu_to_be16(FDMI_PORT_NAME);
2493         memcpy(eiter->a.port_name, vha->port_name, WWN_SIZE);
2494         eiter->len = cpu_to_be16(4 + WWN_SIZE);
2495         size += 4 + WWN_SIZE;
2496
2497         ql_dbg(ql_dbg_disc, vha, 0x20c1,
2498             "Port Name = %016llx.\n", wwn_to_u64(eiter->a.port_name));
2499
2500         /* Port Symbolic Name */
2501         eiter = entries + size;
2502         eiter->type = cpu_to_be16(FDMI_PORT_SYM_NAME);
2503         qla2x00_get_sym_node_name(vha, eiter->a.port_sym_name,
2504             sizeof(eiter->a.port_sym_name));
2505         alen = strlen(eiter->a.port_sym_name);
2506         alen += 4 - (alen & 3);
2507         eiter->len = cpu_to_be16(4 + alen);
2508         size += 4 + alen;
2509
2510         ql_dbg(ql_dbg_disc, vha, 0x20c2,
2511             "port symbolic name = %s\n", eiter->a.port_sym_name);
2512
2513         /* Port Type */
2514         eiter = entries + size;
2515         eiter->type = cpu_to_be16(FDMI_PORT_TYPE);
2516         eiter->a.port_type = cpu_to_be32(NS_NX_PORT_TYPE);
2517         eiter->len = cpu_to_be16(4 + 4);
2518         size += 4 + 4;
2519
2520         ql_dbg(ql_dbg_disc, vha, 0x20c3,
2521             "Port Type = %x.\n", eiter->a.port_type);
2522
2523         /* Class of Service  */
2524         eiter = entries + size;
2525         eiter->type = cpu_to_be16(FDMI_PORT_SUPP_COS);
2526         eiter->a.port_supported_cos = cpu_to_be32(FC_CLASS_3);
2527         eiter->len = cpu_to_be16(4 + 4);
2528         size += 4 + 4;
2529
2530         ql_dbg(ql_dbg_disc, vha, 0x20c4,
2531             "Supported COS = %08x\n", eiter->a.port_supported_cos);
2532
2533         /* Port Fabric Name */
2534         eiter = entries + size;
2535         eiter->type = cpu_to_be16(FDMI_PORT_FABRIC_NAME);
2536         memcpy(eiter->a.fabric_name, vha->fabric_node_name, WWN_SIZE);
2537         eiter->len = cpu_to_be16(4 + WWN_SIZE);
2538         size += 4 + WWN_SIZE;
2539
2540         ql_dbg(ql_dbg_disc, vha, 0x20c5,
2541             "Fabric Name = %016llx.\n", wwn_to_u64(eiter->a.fabric_name));
2542
2543         /* FC4_type */
2544         eiter = entries + size;
2545         eiter->type = cpu_to_be16(FDMI_PORT_FC4_TYPE);
2546         eiter->a.port_fc4_type[0] = 0;
2547         eiter->a.port_fc4_type[1] = 0;
2548         eiter->a.port_fc4_type[2] = 1;
2549         eiter->a.port_fc4_type[3] = 0;
2550         eiter->len = cpu_to_be16(4 + 32);
2551         size += 4 + 32;
2552
2553         ql_dbg(ql_dbg_disc, vha, 0x20c6,
2554             "Port Active FC4 Type = %02x %02x.\n",
2555             eiter->a.port_fc4_type[2], eiter->a.port_fc4_type[1]);
2556
2557         if (vha->flags.nvme_enabled) {
2558                 eiter->a.port_fc4_type[4] = 0;
2559                 eiter->a.port_fc4_type[5] = 0;
2560                 eiter->a.port_fc4_type[6] = 1;  /* NVMe type 28h */
2561                 ql_dbg(ql_dbg_disc, vha, 0x2120,
2562                     "NVME Port Active FC4 Type = %02x 0x0 0x0 0x0 0x0 0x0.\n",
2563                     eiter->a.port_fc4_type[6]);
2564         }
2565
2566         /* Port State */
2567         eiter = entries + size;
2568         eiter->type = cpu_to_be16(FDMI_PORT_STATE);
2569         eiter->a.port_state = cpu_to_be32(1);
2570         eiter->len = cpu_to_be16(4 + 4);
2571         size += 4 + 4;
2572
2573         ql_dbg(ql_dbg_disc, vha, 0x20c7,
2574             "Port State = %x.\n", eiter->a.port_state);
2575
2576         /* Number of Ports */
2577         eiter = entries + size;
2578         eiter->type = cpu_to_be16(FDMI_PORT_COUNT);
2579         eiter->a.num_ports = cpu_to_be32(1);
2580         eiter->len = cpu_to_be16(4 + 4);
2581         size += 4 + 4;
2582
2583         ql_dbg(ql_dbg_disc, vha, 0x20c8,
2584             "Number of ports = %x.\n", eiter->a.num_ports);
2585
2586         /* Port Id */
2587         eiter = entries + size;
2588         eiter->type = cpu_to_be16(FDMI_PORT_ID);
2589         eiter->a.port_id = cpu_to_be32(vha->d_id.b24);
2590         eiter->len = cpu_to_be16(4 + 4);
2591         size += 4 + 4;
2592
2593         ql_dbg(ql_dbg_disc, vha, 0x201c,
2594             "Port Id = %x.\n", eiter->a.port_id);
2595
2596         /* Update MS request size. */
2597         qla2x00_update_ms_fdmi_iocb(vha, size + 16);
2598
2599         ql_dbg(ql_dbg_disc, vha, 0x2018,
2600             "RPA portname= %8phN size=%d.\n", ct_req->req.rpa.port_name, size);
2601         ql_dump_buffer(ql_dbg_disc + ql_dbg_buffer, vha, 0x20ca,
2602             entries, size);
2603
2604         /* Execute MS IOCB */
2605         rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2606             sizeof(ms_iocb_entry_t));
2607         if (rval != QLA_SUCCESS) {
2608                 /*EMPTY*/
2609                 ql_dbg(ql_dbg_disc, vha, 0x20cb,
2610                     "RPA FDMI v2 issue IOCB failed (%d).\n", rval);
2611         } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp, "RPA") !=
2612             QLA_SUCCESS) {
2613                 rval = QLA_FUNCTION_FAILED;
2614                 if (ct_rsp->header.reason_code == CT_REASON_CANNOT_PERFORM &&
2615                     ct_rsp->header.explanation_code ==
2616                     CT_EXPL_ALREADY_REGISTERED) {
2617                         ql_dbg(ql_dbg_disc, vha, 0x20ce,
2618                             "RPA FDMI v2 already registered\n");
2619                         rval = QLA_ALREADY_REGISTERED;
2620                 } else {
2621                         ql_dbg(ql_dbg_disc, vha, 0x2020,
2622                             "RPA FDMI v2 failed, CT Reason code: 0x%x, CT Explanation 0x%x\n",
2623                             ct_rsp->header.reason_code,
2624                             ct_rsp->header.explanation_code);
2625                 }
2626         } else {
2627                 ql_dbg(ql_dbg_disc, vha, 0x20cc,
2628                     "RPA FDMI V2 exiting normally.\n");
2629         }
2630
2631         return rval;
2632 }
2633
2634 /**
2635  * qla2x00_fdmi_register() -
2636  * @vha: HA context
2637  *
2638  * Returns 0 on success.
2639  */
2640 int
2641 qla2x00_fdmi_register(scsi_qla_host_t *vha)
2642 {
2643         int rval = QLA_FUNCTION_FAILED;
2644         struct qla_hw_data *ha = vha->hw;
2645
2646         if (IS_QLA2100(ha) || IS_QLA2200(ha) ||
2647             IS_QLAFX00(ha))
2648                 return QLA_FUNCTION_FAILED;
2649
2650         rval = qla2x00_mgmt_svr_login(vha);
2651         if (rval)
2652                 return rval;
2653
2654         rval = qla2x00_fdmiv2_rhba(vha);
2655         if (rval) {
2656                 if (rval != QLA_ALREADY_REGISTERED)
2657                         goto try_fdmi;
2658
2659                 rval = qla2x00_fdmi_dhba(vha);
2660                 if (rval)
2661                         goto try_fdmi;
2662
2663                 rval = qla2x00_fdmiv2_rhba(vha);
2664                 if (rval)
2665                         goto try_fdmi;
2666         }
2667         rval = qla2x00_fdmiv2_rpa(vha);
2668         if (rval)
2669                 goto try_fdmi;
2670
2671         goto out;
2672
2673 try_fdmi:
2674         rval = qla2x00_fdmi_rhba(vha);
2675         if (rval) {
2676                 if (rval != QLA_ALREADY_REGISTERED)
2677                         return rval;
2678
2679                 rval = qla2x00_fdmi_dhba(vha);
2680                 if (rval)
2681                         return rval;
2682
2683                 rval = qla2x00_fdmi_rhba(vha);
2684                 if (rval)
2685                         return rval;
2686         }
2687         rval = qla2x00_fdmi_rpa(vha);
2688 out:
2689         return rval;
2690 }
2691
2692 /**
2693  * qla2x00_gfpn_id() - SNS Get Fabric Port Name (GFPN_ID) query.
2694  * @vha: HA context
2695  * @list: switch info entries to populate
2696  *
2697  * Returns 0 on success.
2698  */
2699 int
2700 qla2x00_gfpn_id(scsi_qla_host_t *vha, sw_info_t *list)
2701 {
2702         int             rval = QLA_SUCCESS;
2703         uint16_t        i;
2704         struct qla_hw_data *ha = vha->hw;
2705         ms_iocb_entry_t *ms_pkt;
2706         struct ct_sns_req       *ct_req;
2707         struct ct_sns_rsp       *ct_rsp;
2708         struct ct_arg arg;
2709
2710         if (!IS_IIDMA_CAPABLE(ha))
2711                 return QLA_FUNCTION_FAILED;
2712
2713         arg.iocb = ha->ms_iocb;
2714         arg.req_dma = ha->ct_sns_dma;
2715         arg.rsp_dma = ha->ct_sns_dma;
2716         arg.req_size = GFPN_ID_REQ_SIZE;
2717         arg.rsp_size = GFPN_ID_RSP_SIZE;
2718         arg.nport_handle = NPH_SNS;
2719
2720         for (i = 0; i < ha->max_fibre_devices; i++) {
2721                 /* Issue GFPN_ID */
2722                 /* Prepare common MS IOCB */
2723                 ms_pkt = ha->isp_ops->prep_ms_iocb(vha, &arg);
2724
2725                 /* Prepare CT request */
2726                 ct_req = qla2x00_prep_ct_req(ha->ct_sns, GFPN_ID_CMD,
2727                     GFPN_ID_RSP_SIZE);
2728                 ct_rsp = &ha->ct_sns->p.rsp;
2729
2730                 /* Prepare CT arguments -- port_id */
2731                 ct_req->req.port_id.port_id[0] = list[i].d_id.b.domain;
2732                 ct_req->req.port_id.port_id[1] = list[i].d_id.b.area;
2733                 ct_req->req.port_id.port_id[2] = list[i].d_id.b.al_pa;
2734
2735                 /* Execute MS IOCB */
2736                 rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2737                     sizeof(ms_iocb_entry_t));
2738                 if (rval != QLA_SUCCESS) {
2739                         /*EMPTY*/
2740                         ql_dbg(ql_dbg_disc, vha, 0x2023,
2741                             "GFPN_ID issue IOCB failed (%d).\n", rval);
2742                         break;
2743                 } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
2744                     "GFPN_ID") != QLA_SUCCESS) {
2745                         rval = QLA_FUNCTION_FAILED;
2746                         break;
2747                 } else {
2748                         /* Save fabric portname */
2749                         memcpy(list[i].fabric_port_name,
2750                             ct_rsp->rsp.gfpn_id.port_name, WWN_SIZE);
2751                 }
2752
2753                 /* Last device exit. */
2754                 if (list[i].d_id.b.rsvd_1 != 0)
2755                         break;
2756         }
2757
2758         return (rval);
2759 }
2760
2761
2762 static inline struct ct_sns_req *
2763 qla24xx_prep_ct_fm_req(struct ct_sns_pkt *p, uint16_t cmd,
2764     uint16_t rsp_size)
2765 {
2766         memset(p, 0, sizeof(struct ct_sns_pkt));
2767
2768         p->p.req.header.revision = 0x01;
2769         p->p.req.header.gs_type = 0xFA;
2770         p->p.req.header.gs_subtype = 0x01;
2771         p->p.req.command = cpu_to_be16(cmd);
2772         p->p.req.max_rsp_size = cpu_to_be16((rsp_size - 16) / 4);
2773
2774         return &p->p.req;
2775 }
2776
2777 /**
2778  * qla2x00_gpsc() - FCS Get Port Speed Capabilities (GPSC) query.
2779  * @vha: HA context
2780  * @list: switch info entries to populate
2781  *
2782  * Returns 0 on success.
2783  */
2784 int
2785 qla2x00_gpsc(scsi_qla_host_t *vha, sw_info_t *list)
2786 {
2787         int             rval;
2788         uint16_t        i;
2789         struct qla_hw_data *ha = vha->hw;
2790         ms_iocb_entry_t *ms_pkt;
2791         struct ct_sns_req       *ct_req;
2792         struct ct_sns_rsp       *ct_rsp;
2793         struct ct_arg arg;
2794
2795         if (!IS_IIDMA_CAPABLE(ha))
2796                 return QLA_FUNCTION_FAILED;
2797         if (!ha->flags.gpsc_supported)
2798                 return QLA_FUNCTION_FAILED;
2799
2800         rval = qla2x00_mgmt_svr_login(vha);
2801         if (rval)
2802                 return rval;
2803
2804         arg.iocb = ha->ms_iocb;
2805         arg.req_dma = ha->ct_sns_dma;
2806         arg.rsp_dma = ha->ct_sns_dma;
2807         arg.req_size = GPSC_REQ_SIZE;
2808         arg.rsp_size = GPSC_RSP_SIZE;
2809         arg.nport_handle = vha->mgmt_svr_loop_id;
2810
2811         for (i = 0; i < ha->max_fibre_devices; i++) {
2812                 /* Issue GFPN_ID */
2813                 /* Prepare common MS IOCB */
2814                 ms_pkt = qla24xx_prep_ms_iocb(vha, &arg);
2815
2816                 /* Prepare CT request */
2817                 ct_req = qla24xx_prep_ct_fm_req(ha->ct_sns, GPSC_CMD,
2818                     GPSC_RSP_SIZE);
2819                 ct_rsp = &ha->ct_sns->p.rsp;
2820
2821                 /* Prepare CT arguments -- port_name */
2822                 memcpy(ct_req->req.gpsc.port_name, list[i].fabric_port_name,
2823                     WWN_SIZE);
2824
2825                 /* Execute MS IOCB */
2826                 rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2827                     sizeof(ms_iocb_entry_t));
2828                 if (rval != QLA_SUCCESS) {
2829                         /*EMPTY*/
2830                         ql_dbg(ql_dbg_disc, vha, 0x2059,
2831                             "GPSC issue IOCB failed (%d).\n", rval);
2832                 } else if ((rval = qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
2833                     "GPSC")) != QLA_SUCCESS) {
2834                         /* FM command unsupported? */
2835                         if (rval == QLA_INVALID_COMMAND &&
2836                             (ct_rsp->header.reason_code ==
2837                                 CT_REASON_INVALID_COMMAND_CODE ||
2838                              ct_rsp->header.reason_code ==
2839                                 CT_REASON_COMMAND_UNSUPPORTED)) {
2840                                 ql_dbg(ql_dbg_disc, vha, 0x205a,
2841                                     "GPSC command unsupported, disabling "
2842                                     "query.\n");
2843                                 ha->flags.gpsc_supported = 0;
2844                                 rval = QLA_FUNCTION_FAILED;
2845                                 break;
2846                         }
2847                         rval = QLA_FUNCTION_FAILED;
2848                 } else {
2849                         /* Save port-speed */
2850                         switch (be16_to_cpu(ct_rsp->rsp.gpsc.speed)) {
2851                         case BIT_15:
2852                                 list[i].fp_speed = PORT_SPEED_1GB;
2853                                 break;
2854                         case BIT_14:
2855                                 list[i].fp_speed = PORT_SPEED_2GB;
2856                                 break;
2857                         case BIT_13:
2858                                 list[i].fp_speed = PORT_SPEED_4GB;
2859                                 break;
2860                         case BIT_12:
2861                                 list[i].fp_speed = PORT_SPEED_10GB;
2862                                 break;
2863                         case BIT_11:
2864                                 list[i].fp_speed = PORT_SPEED_8GB;
2865                                 break;
2866                         case BIT_10:
2867                                 list[i].fp_speed = PORT_SPEED_16GB;
2868                                 break;
2869                         case BIT_8:
2870                                 list[i].fp_speed = PORT_SPEED_32GB;
2871                                 break;
2872                         }
2873
2874                         ql_dbg(ql_dbg_disc, vha, 0x205b,
2875                             "GPSC ext entry - fpn "
2876                             "%8phN speeds=%04x speed=%04x.\n",
2877                             list[i].fabric_port_name,
2878                             be16_to_cpu(ct_rsp->rsp.gpsc.speeds),
2879                             be16_to_cpu(ct_rsp->rsp.gpsc.speed));
2880                 }
2881
2882                 /* Last device exit. */
2883                 if (list[i].d_id.b.rsvd_1 != 0)
2884                         break;
2885         }
2886
2887         return (rval);
2888 }
2889
2890 /**
2891  * qla2x00_gff_id() - SNS Get FC-4 Features (GFF_ID) query.
2892  *
2893  * @vha: HA context
2894  * @list: switch info entries to populate
2895  *
2896  */
2897 void
2898 qla2x00_gff_id(scsi_qla_host_t *vha, sw_info_t *list)
2899 {
2900         int             rval;
2901         uint16_t        i;
2902
2903         ms_iocb_entry_t *ms_pkt;
2904         struct ct_sns_req       *ct_req;
2905         struct ct_sns_rsp       *ct_rsp;
2906         struct qla_hw_data *ha = vha->hw;
2907         uint8_t fcp_scsi_features = 0;
2908         struct ct_arg arg;
2909
2910         for (i = 0; i < ha->max_fibre_devices; i++) {
2911                 /* Set default FC4 Type as UNKNOWN so the default is to
2912                  * Process this port */
2913                 list[i].fc4_type = FC4_TYPE_UNKNOWN;
2914
2915                 /* Do not attempt GFF_ID if we are not FWI_2 capable */
2916                 if (!IS_FWI2_CAPABLE(ha))
2917                         continue;
2918
2919                 arg.iocb = ha->ms_iocb;
2920                 arg.req_dma = ha->ct_sns_dma;
2921                 arg.rsp_dma = ha->ct_sns_dma;
2922                 arg.req_size = GFF_ID_REQ_SIZE;
2923                 arg.rsp_size = GFF_ID_RSP_SIZE;
2924                 arg.nport_handle = NPH_SNS;
2925
2926                 /* Prepare common MS IOCB */
2927                 ms_pkt = ha->isp_ops->prep_ms_iocb(vha, &arg);
2928
2929                 /* Prepare CT request */
2930                 ct_req = qla2x00_prep_ct_req(ha->ct_sns, GFF_ID_CMD,
2931                     GFF_ID_RSP_SIZE);
2932                 ct_rsp = &ha->ct_sns->p.rsp;
2933
2934                 /* Prepare CT arguments -- port_id */
2935                 ct_req->req.port_id.port_id[0] = list[i].d_id.b.domain;
2936                 ct_req->req.port_id.port_id[1] = list[i].d_id.b.area;
2937                 ct_req->req.port_id.port_id[2] = list[i].d_id.b.al_pa;
2938
2939                 /* Execute MS IOCB */
2940                 rval = qla2x00_issue_iocb(vha, ha->ms_iocb, ha->ms_iocb_dma,
2941                    sizeof(ms_iocb_entry_t));
2942
2943                 if (rval != QLA_SUCCESS) {
2944                         ql_dbg(ql_dbg_disc, vha, 0x205c,
2945                             "GFF_ID issue IOCB failed (%d).\n", rval);
2946                 } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
2947                                "GFF_ID") != QLA_SUCCESS) {
2948                         ql_dbg(ql_dbg_disc, vha, 0x205d,
2949                             "GFF_ID IOCB status had a failure status code.\n");
2950                 } else {
2951                         fcp_scsi_features =
2952                            ct_rsp->rsp.gff_id.fc4_features[GFF_FCP_SCSI_OFFSET];
2953                         fcp_scsi_features &= 0x0f;
2954
2955                         if (fcp_scsi_features)
2956                                 list[i].fc4_type = FC4_TYPE_FCP_SCSI;
2957                         else
2958                                 list[i].fc4_type = FC4_TYPE_OTHER;
2959
2960                         list[i].fc4f_nvme =
2961                             ct_rsp->rsp.gff_id.fc4_features[GFF_NVME_OFFSET];
2962                         list[i].fc4f_nvme &= 0xf;
2963                 }
2964
2965                 /* Last device exit. */
2966                 if (list[i].d_id.b.rsvd_1 != 0)
2967                         break;
2968         }
2969 }
2970
2971 /* GID_PN completion processing. */
2972 void qla24xx_handle_gidpn_event(scsi_qla_host_t *vha, struct event_arg *ea)
2973 {
2974         fc_port_t *fcport = ea->fcport;
2975
2976         ql_dbg(ql_dbg_disc, vha, 0x201d,
2977             "%s %8phC DS %d LS %d rc %d login %d|%d rscn %d|%d lid %d\n",
2978             __func__, fcport->port_name, fcport->disc_state,
2979             fcport->fw_login_state, ea->rc, fcport->login_gen, ea->sp->gen2,
2980             fcport->rscn_gen, ea->sp->gen1, fcport->loop_id);
2981
2982         if (fcport->disc_state == DSC_DELETE_PEND)
2983                 return;
2984
2985         if (ea->sp->gen2 != fcport->login_gen) {
2986                 /* PLOGI/PRLI/LOGO came in while cmd was out.*/
2987                 ql_dbg(ql_dbg_disc, vha, 0x201e,
2988                     "%s %8phC generation changed rscn %d|%d n",
2989                     __func__, fcport->port_name, fcport->last_rscn_gen,
2990                     fcport->rscn_gen);
2991                 return;
2992         }
2993
2994         if (!ea->rc) {
2995                 if (ea->sp->gen1 == fcport->rscn_gen) {
2996                         fcport->scan_state = QLA_FCPORT_FOUND;
2997                         fcport->flags |= FCF_FABRIC_DEVICE;
2998
2999                         if (fcport->d_id.b24 == ea->id.b24) {
3000                                 /* cable plugged into the same place */
3001                                 switch (vha->host->active_mode) {
3002                                 case MODE_TARGET:
3003                                         if (fcport->fw_login_state ==
3004                                             DSC_LS_PRLI_COMP) {
3005                                                 u16 data[2];
3006                                                 /*
3007                                                  * Late RSCN was delivered.
3008                                                  * Remote port already login'ed.
3009                                                  */
3010                                                 ql_dbg(ql_dbg_disc, vha, 0x201f,
3011                                                     "%s %d %8phC post adisc\n",
3012                                                     __func__, __LINE__,
3013                                                     fcport->port_name);
3014                                                 data[0] = data[1] = 0;
3015                                                 qla2x00_post_async_adisc_work(
3016                                                     vha, fcport, data);
3017                                         }
3018                                         break;
3019                                 case MODE_INITIATOR:
3020                                 case MODE_DUAL:
3021                                 default:
3022                                         ql_dbg(ql_dbg_disc, vha, 0x201f,
3023                                             "%s %d %8phC post %s\n", __func__,
3024                                             __LINE__, fcport->port_name,
3025                                             (atomic_read(&fcport->state) ==
3026                                             FCS_ONLINE) ? "adisc" : "gnl");
3027
3028                                         if (atomic_read(&fcport->state) ==
3029                                             FCS_ONLINE) {
3030                                                 u16 data[2];
3031
3032                                                 data[0] = data[1] = 0;
3033                                                 qla2x00_post_async_adisc_work(
3034                                                     vha, fcport, data);
3035                                         } else {
3036                                                 qla24xx_post_gnl_work(vha,
3037                                                     fcport);
3038                                         }
3039                                         break;
3040                                 }
3041                         } else { /* fcport->d_id.b24 != ea->id.b24 */
3042                                 fcport->d_id.b24 = ea->id.b24;
3043                                 fcport->id_changed = 1;
3044                                 if (fcport->deleted != QLA_SESS_DELETED) {
3045                                         ql_dbg(ql_dbg_disc, vha, 0x2021,
3046                                             "%s %d %8phC post del sess\n",
3047                                             __func__, __LINE__, fcport->port_name);
3048                                         qlt_schedule_sess_for_deletion(fcport);
3049                                 }
3050                         }
3051                 } else { /* ea->sp->gen1 != fcport->rscn_gen */
3052                         ql_dbg(ql_dbg_disc, vha, 0x2022,
3053                             "%s %d %8phC post gidpn\n",
3054                             __func__, __LINE__, fcport->port_name);
3055                         /* rscn came in while cmd was out */
3056                         qla24xx_post_gidpn_work(vha, fcport);
3057                 }
3058         } else { /* ea->rc */
3059                 /* cable pulled */
3060                 if (ea->sp->gen1 == fcport->rscn_gen) {
3061                         if (ea->sp->gen2 == fcport->login_gen) {
3062                                 ql_dbg(ql_dbg_disc, vha, 0x2042,
3063                                     "%s %d %8phC post del sess\n", __func__,
3064                                     __LINE__, fcport->port_name);
3065                                 qlt_schedule_sess_for_deletion(fcport);
3066                         } else {
3067                                 ql_dbg(ql_dbg_disc, vha, 0x2045,
3068                                     "%s %d %8phC login\n", __func__, __LINE__,
3069                                     fcport->port_name);
3070                                 qla24xx_fcport_handle_login(vha, fcport);
3071                         }
3072                 } else {
3073                         ql_dbg(ql_dbg_disc, vha, 0x2049,
3074                             "%s %d %8phC post gidpn\n", __func__, __LINE__,
3075                             fcport->port_name);
3076                         qla24xx_post_gidpn_work(vha, fcport);
3077                 }
3078         }
3079 } /* gidpn_event */
3080
3081 static void qla2x00_async_gidpn_sp_done(void *s, int res)
3082 {
3083         struct srb *sp = s;
3084         struct scsi_qla_host *vha = sp->vha;
3085         fc_port_t *fcport = sp->fcport;
3086         u8 *id = fcport->ct_desc.ct_sns->p.rsp.rsp.gid_pn.port_id;
3087         struct event_arg ea;
3088
3089         fcport->flags &= ~(FCF_ASYNC_SENT | FCF_ASYNC_ACTIVE);
3090
3091         memset(&ea, 0, sizeof(ea));
3092         ea.fcport = fcport;
3093         ea.id.b.domain = id[0];
3094         ea.id.b.area = id[1];
3095         ea.id.b.al_pa = id[2];
3096         ea.sp = sp;
3097         ea.rc = res;
3098         ea.event = FCME_GIDPN_DONE;
3099
3100         if (res == QLA_FUNCTION_TIMEOUT) {
3101                 ql_dbg(ql_dbg_disc, sp->vha, 0xffff,
3102                     "Async done-%s WWPN %8phC timed out.\n",
3103                     sp->name, fcport->port_name);
3104                 qla24xx_post_gidpn_work(sp->vha, fcport);
3105                 sp->free(sp);
3106                 return;
3107         } else if (res) {
3108                 ql_dbg(ql_dbg_disc, sp->vha, 0xffff,
3109                     "Async done-%s fail res %x, WWPN %8phC\n",
3110                     sp->name, res, fcport->port_name);
3111         } else {
3112                 ql_dbg(ql_dbg_disc, vha, 0x204f,
3113                     "Async done-%s good WWPN %8phC ID %3phC\n",
3114                     sp->name, fcport->port_name, id);
3115         }
3116
3117         qla2x00_fcport_event_handler(vha, &ea);
3118
3119         sp->free(sp);
3120 }
3121
3122 int qla24xx_async_gidpn(scsi_qla_host_t *vha, fc_port_t *fcport)
3123 {
3124         int rval = QLA_FUNCTION_FAILED;
3125         struct ct_sns_req       *ct_req;
3126         srb_t *sp;
3127
3128         if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT))
3129                 return rval;
3130
3131         fcport->disc_state = DSC_GID_PN;
3132         fcport->scan_state = QLA_FCPORT_SCAN;
3133         sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
3134         if (!sp)
3135                 goto done;
3136
3137         fcport->flags |= FCF_ASYNC_SENT;
3138         sp->type = SRB_CT_PTHRU_CMD;
3139         sp->name = "gidpn";
3140         sp->gen1 = fcport->rscn_gen;
3141         sp->gen2 = fcport->login_gen;
3142
3143         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
3144
3145         /* CT_IU preamble  */
3146         ct_req = qla2x00_prep_ct_req(fcport->ct_desc.ct_sns, GID_PN_CMD,
3147                 GID_PN_RSP_SIZE);
3148
3149         /* GIDPN req */
3150         memcpy(ct_req->req.gid_pn.port_name, fcport->port_name,
3151                 WWN_SIZE);
3152
3153         /* req & rsp use the same buffer */
3154         sp->u.iocb_cmd.u.ctarg.req = fcport->ct_desc.ct_sns;
3155         sp->u.iocb_cmd.u.ctarg.req_dma = fcport->ct_desc.ct_sns_dma;
3156         sp->u.iocb_cmd.u.ctarg.rsp = fcport->ct_desc.ct_sns;
3157         sp->u.iocb_cmd.u.ctarg.rsp_dma = fcport->ct_desc.ct_sns_dma;
3158         sp->u.iocb_cmd.u.ctarg.req_size = GID_PN_REQ_SIZE;
3159         sp->u.iocb_cmd.u.ctarg.rsp_size = GID_PN_RSP_SIZE;
3160         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
3161
3162         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
3163         sp->done = qla2x00_async_gidpn_sp_done;
3164
3165         rval = qla2x00_start_sp(sp);
3166         if (rval != QLA_SUCCESS)
3167                 goto done_free_sp;
3168
3169         ql_dbg(ql_dbg_disc, vha, 0x20a4,
3170             "Async-%s - %8phC hdl=%x loopid=%x portid %02x%02x%02x.\n",
3171             sp->name, fcport->port_name,
3172             sp->handle, fcport->loop_id, fcport->d_id.b.domain,
3173             fcport->d_id.b.area, fcport->d_id.b.al_pa);
3174         return rval;
3175
3176 done_free_sp:
3177         sp->free(sp);
3178 done:
3179         fcport->flags &= ~FCF_ASYNC_ACTIVE;
3180         return rval;
3181 }
3182
3183 int qla24xx_post_gidpn_work(struct scsi_qla_host *vha, fc_port_t *fcport)
3184 {
3185         struct qla_work_evt *e;
3186         int ls;
3187
3188         ls = atomic_read(&vha->loop_state);
3189         if (((ls != LOOP_READY) && (ls != LOOP_UP)) ||
3190                 test_bit(UNLOADING, &vha->dpc_flags))
3191                 return 0;
3192
3193         e = qla2x00_alloc_work(vha, QLA_EVT_GIDPN);
3194         if (!e)
3195                 return QLA_FUNCTION_FAILED;
3196
3197         e->u.fcport.fcport = fcport;
3198         fcport->flags |= FCF_ASYNC_ACTIVE;
3199         return qla2x00_post_work(vha, e);
3200 }
3201
3202 int qla24xx_post_gpsc_work(struct scsi_qla_host *vha, fc_port_t *fcport)
3203 {
3204         struct qla_work_evt *e;
3205
3206         e = qla2x00_alloc_work(vha, QLA_EVT_GPSC);
3207         if (!e)
3208                 return QLA_FUNCTION_FAILED;
3209
3210         e->u.fcport.fcport = fcport;
3211         fcport->flags |= FCF_ASYNC_ACTIVE;
3212         return qla2x00_post_work(vha, e);
3213 }
3214
3215 void qla24xx_handle_gpsc_event(scsi_qla_host_t *vha, struct event_arg *ea)
3216 {
3217         struct fc_port *fcport = ea->fcport;
3218
3219         ql_dbg(ql_dbg_disc, vha, 0x20d8,
3220             "%s %8phC DS %d LS %d rc %d login %d|%d rscn %d|%d lid %d\n",
3221             __func__, fcport->port_name, fcport->disc_state,
3222             fcport->fw_login_state, ea->rc, ea->sp->gen2, fcport->login_gen,
3223             ea->sp->gen2, fcport->rscn_gen|ea->sp->gen1, fcport->loop_id);
3224
3225         if (fcport->disc_state == DSC_DELETE_PEND)
3226                 return;
3227
3228         if (ea->sp->gen2 != fcport->login_gen) {
3229                 /* target side must have changed it. */
3230                 ql_dbg(ql_dbg_disc, vha, 0x20d3,
3231                     "%s %8phC generation changed\n",
3232                     __func__, fcport->port_name);
3233                 return;
3234         } else if (ea->sp->gen1 != fcport->rscn_gen) {
3235                 ql_dbg(ql_dbg_disc, vha, 0x20d4, "%s %d %8phC post gidpn\n",
3236                     __func__, __LINE__, fcport->port_name);
3237                 qla24xx_post_gidpn_work(vha, fcport);
3238                 return;
3239         }
3240
3241         qla_post_iidma_work(vha, fcport);
3242 }
3243
3244 static void qla24xx_async_gpsc_sp_done(void *s, int res)
3245 {
3246         struct srb *sp = s;
3247         struct scsi_qla_host *vha = sp->vha;
3248         struct qla_hw_data *ha = vha->hw;
3249         fc_port_t *fcport = sp->fcport;
3250         struct ct_sns_rsp       *ct_rsp;
3251         struct event_arg ea;
3252
3253         ct_rsp = &fcport->ct_desc.ct_sns->p.rsp;
3254
3255         ql_dbg(ql_dbg_disc, vha, 0x2053,
3256             "Async done-%s res %x, WWPN %8phC \n",
3257             sp->name, res, fcport->port_name);
3258
3259         if (res == (DID_ERROR << 16)) {
3260                 /* entry status error */
3261                 goto done;
3262         } else if (res) {
3263                 if ((ct_rsp->header.reason_code ==
3264                          CT_REASON_INVALID_COMMAND_CODE) ||
3265                         (ct_rsp->header.reason_code ==
3266                         CT_REASON_COMMAND_UNSUPPORTED)) {
3267                         ql_dbg(ql_dbg_disc, vha, 0x2019,
3268                             "GPSC command unsupported, disabling query.\n");
3269                         ha->flags.gpsc_supported = 0;
3270                         res = QLA_SUCCESS;
3271                 }
3272         } else {
3273                 switch (be16_to_cpu(ct_rsp->rsp.gpsc.speed)) {
3274                 case BIT_15:
3275                         fcport->fp_speed = PORT_SPEED_1GB;
3276                         break;
3277                 case BIT_14:
3278                         fcport->fp_speed = PORT_SPEED_2GB;
3279                         break;
3280                 case BIT_13:
3281                         fcport->fp_speed = PORT_SPEED_4GB;
3282                         break;
3283                 case BIT_12:
3284                         fcport->fp_speed = PORT_SPEED_10GB;
3285                         break;
3286                 case BIT_11:
3287                         fcport->fp_speed = PORT_SPEED_8GB;
3288                         break;
3289                 case BIT_10:
3290                         fcport->fp_speed = PORT_SPEED_16GB;
3291                         break;
3292                 case BIT_8:
3293                         fcport->fp_speed = PORT_SPEED_32GB;
3294                         break;
3295                 }
3296
3297                 ql_dbg(ql_dbg_disc, vha, 0x2054,
3298                     "Async-%s OUT WWPN %8phC speeds=%04x speed=%04x.\n",
3299                     sp->name, fcport->fabric_port_name,
3300                     be16_to_cpu(ct_rsp->rsp.gpsc.speeds),
3301                     be16_to_cpu(ct_rsp->rsp.gpsc.speed));
3302         }
3303 done:
3304         memset(&ea, 0, sizeof(ea));
3305         ea.event = FCME_GPSC_DONE;
3306         ea.rc = res;
3307         ea.fcport = fcport;
3308         ea.sp = sp;
3309         qla2x00_fcport_event_handler(vha, &ea);
3310
3311         sp->free(sp);
3312 }
3313
3314 int qla24xx_async_gpsc(scsi_qla_host_t *vha, fc_port_t *fcport)
3315 {
3316         int rval = QLA_FUNCTION_FAILED;
3317         struct ct_sns_req       *ct_req;
3318         srb_t *sp;
3319
3320         if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT))
3321                 return rval;
3322
3323         sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
3324         if (!sp)
3325                 goto done;
3326
3327         sp->type = SRB_CT_PTHRU_CMD;
3328         sp->name = "gpsc";
3329         sp->gen1 = fcport->rscn_gen;
3330         sp->gen2 = fcport->login_gen;
3331
3332         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
3333
3334         /* CT_IU preamble  */
3335         ct_req = qla24xx_prep_ct_fm_req(fcport->ct_desc.ct_sns, GPSC_CMD,
3336                 GPSC_RSP_SIZE);
3337
3338         /* GPSC req */
3339         memcpy(ct_req->req.gpsc.port_name, fcport->fabric_port_name,
3340                 WWN_SIZE);
3341
3342         sp->u.iocb_cmd.u.ctarg.req = fcport->ct_desc.ct_sns;
3343         sp->u.iocb_cmd.u.ctarg.req_dma = fcport->ct_desc.ct_sns_dma;
3344         sp->u.iocb_cmd.u.ctarg.rsp = fcport->ct_desc.ct_sns;
3345         sp->u.iocb_cmd.u.ctarg.rsp_dma = fcport->ct_desc.ct_sns_dma;
3346         sp->u.iocb_cmd.u.ctarg.req_size = GPSC_REQ_SIZE;
3347         sp->u.iocb_cmd.u.ctarg.rsp_size = GPSC_RSP_SIZE;
3348         sp->u.iocb_cmd.u.ctarg.nport_handle = vha->mgmt_svr_loop_id;
3349
3350         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
3351         sp->done = qla24xx_async_gpsc_sp_done;
3352
3353         rval = qla2x00_start_sp(sp);
3354         if (rval != QLA_SUCCESS)
3355                 goto done_free_sp;
3356
3357         ql_dbg(ql_dbg_disc, vha, 0x205e,
3358             "Async-%s %8phC hdl=%x loopid=%x portid=%02x%02x%02x.\n",
3359             sp->name, fcport->port_name, sp->handle,
3360             fcport->loop_id, fcport->d_id.b.domain,
3361             fcport->d_id.b.area, fcport->d_id.b.al_pa);
3362         return rval;
3363
3364 done_free_sp:
3365         sp->free(sp);
3366         fcport->flags &= ~FCF_ASYNC_SENT;
3367 done:
3368         fcport->flags &= ~FCF_ASYNC_ACTIVE;
3369         return rval;
3370 }
3371
3372 int qla24xx_post_gpnid_work(struct scsi_qla_host *vha, port_id_t *id)
3373 {
3374         struct qla_work_evt *e;
3375
3376         if (test_bit(UNLOADING, &vha->dpc_flags))
3377                 return 0;
3378
3379         e = qla2x00_alloc_work(vha, QLA_EVT_GPNID);
3380         if (!e)
3381                 return QLA_FUNCTION_FAILED;
3382
3383         e->u.gpnid.id = *id;
3384         return qla2x00_post_work(vha, e);
3385 }
3386
3387 void qla24xx_sp_unmap(scsi_qla_host_t *vha, srb_t *sp)
3388 {
3389         if (sp->u.iocb_cmd.u.ctarg.req) {
3390                 dma_free_coherent(&vha->hw->pdev->dev,
3391                         sizeof(struct ct_sns_pkt),
3392                         sp->u.iocb_cmd.u.ctarg.req,
3393                         sp->u.iocb_cmd.u.ctarg.req_dma);
3394                 sp->u.iocb_cmd.u.ctarg.req = NULL;
3395         }
3396         if (sp->u.iocb_cmd.u.ctarg.rsp) {
3397                 dma_free_coherent(&vha->hw->pdev->dev,
3398                         sizeof(struct ct_sns_pkt),
3399                         sp->u.iocb_cmd.u.ctarg.rsp,
3400                         sp->u.iocb_cmd.u.ctarg.rsp_dma);
3401                 sp->u.iocb_cmd.u.ctarg.rsp = NULL;
3402         }
3403
3404         sp->free(sp);
3405 }
3406
3407 void qla24xx_handle_gpnid_event(scsi_qla_host_t *vha, struct event_arg *ea)
3408 {
3409         fc_port_t *fcport, *conflict, *t;
3410         u16 data[2];
3411
3412         ql_dbg(ql_dbg_disc, vha, 0xffff,
3413             "%s %d port_id: %06x\n",
3414             __func__, __LINE__, ea->id.b24);
3415
3416         if (ea->rc) {
3417                 /* cable is disconnected */
3418                 list_for_each_entry_safe(fcport, t, &vha->vp_fcports, list) {
3419                         if (fcport->d_id.b24 == ea->id.b24) {
3420                                 ql_dbg(ql_dbg_disc, vha, 0xffff,
3421                                     "%s %d %8phC DS %d\n",
3422                                     __func__, __LINE__,
3423                                     fcport->port_name,
3424                                     fcport->disc_state);
3425                                 fcport->scan_state = QLA_FCPORT_SCAN;
3426                                 switch (fcport->disc_state) {
3427                                 case DSC_DELETED:
3428                                 case DSC_DELETE_PEND:
3429                                         break;
3430                                 default:
3431                                         ql_dbg(ql_dbg_disc, vha, 0xffff,
3432                                             "%s %d %8phC post del sess\n",
3433                                             __func__, __LINE__,
3434                                             fcport->port_name);
3435                                         qlt_schedule_sess_for_deletion(fcport);
3436                                         break;
3437                                 }
3438                         }
3439                 }
3440         } else {
3441                 /* cable is connected */
3442                 fcport = qla2x00_find_fcport_by_wwpn(vha, ea->port_name, 1);
3443                 if (fcport) {
3444                         list_for_each_entry_safe(conflict, t, &vha->vp_fcports,
3445                             list) {
3446                                 if ((conflict->d_id.b24 == ea->id.b24) &&
3447                                     (fcport != conflict)) {
3448                                         /* 2 fcports with conflict Nport ID or
3449                                          * an existing fcport is having nport ID
3450                                          * conflict with new fcport.
3451                                          */
3452
3453                                         ql_dbg(ql_dbg_disc, vha, 0xffff,
3454                                             "%s %d %8phC DS %d\n",
3455                                             __func__, __LINE__,
3456                                             conflict->port_name,
3457                                             conflict->disc_state);
3458                                         conflict->scan_state = QLA_FCPORT_SCAN;
3459                                         switch (conflict->disc_state) {
3460                                         case DSC_DELETED:
3461                                         case DSC_DELETE_PEND:
3462                                                 break;
3463                                         default:
3464                                                 ql_dbg(ql_dbg_disc, vha, 0xffff,
3465                                                     "%s %d %8phC post del sess\n",
3466                                                     __func__, __LINE__,
3467                                                     conflict->port_name);
3468                                                 qlt_schedule_sess_for_deletion
3469                                                         (conflict);
3470                                                 break;
3471                                         }
3472                                 }
3473                         }
3474
3475                         fcport->rscn_gen++;
3476                         fcport->scan_state = QLA_FCPORT_FOUND;
3477                         fcport->flags |= FCF_FABRIC_DEVICE;
3478                         switch (fcport->disc_state) {
3479                         case DSC_LOGIN_COMPLETE:
3480                                 /* recheck session is still intact. */
3481                                 ql_dbg(ql_dbg_disc, vha, 0x210d,
3482                                     "%s %d %8phC revalidate session with ADISC\n",
3483                                     __func__, __LINE__, fcport->port_name);
3484                                 data[0] = data[1] = 0;
3485                                 qla2x00_post_async_adisc_work(vha, fcport,
3486                                     data);
3487                                 break;
3488                         case DSC_DELETED:
3489                                 ql_dbg(ql_dbg_disc, vha, 0x210d,
3490                                     "%s %d %8phC login\n", __func__, __LINE__,
3491                                     fcport->port_name);
3492                                 fcport->d_id = ea->id;
3493                                 qla24xx_fcport_handle_login(vha, fcport);
3494                                 break;
3495                         case DSC_DELETE_PEND:
3496                                 fcport->d_id = ea->id;
3497                                 break;
3498                         default:
3499                                 fcport->d_id = ea->id;
3500                                 break;
3501                         }
3502                 } else {
3503                         list_for_each_entry_safe(conflict, t, &vha->vp_fcports,
3504                             list) {
3505                                 if (conflict->d_id.b24 == ea->id.b24) {
3506                                         /* 2 fcports with conflict Nport ID or
3507                                          * an existing fcport is having nport ID
3508                                          * conflict with new fcport.
3509                                          */
3510                                         ql_dbg(ql_dbg_disc, vha, 0xffff,
3511                                             "%s %d %8phC DS %d\n",
3512                                             __func__, __LINE__,
3513                                             conflict->port_name,
3514                                             conflict->disc_state);
3515
3516                                         conflict->scan_state = QLA_FCPORT_SCAN;
3517                                         switch (conflict->disc_state) {
3518                                         case DSC_DELETED:
3519                                         case DSC_DELETE_PEND:
3520                                                 break;
3521                                         default:
3522                                                 ql_dbg(ql_dbg_disc, vha, 0xffff,
3523                                                     "%s %d %8phC post del sess\n",
3524                                                     __func__, __LINE__,
3525                                                     conflict->port_name);
3526                                                 qlt_schedule_sess_for_deletion
3527                                                         (conflict);
3528                                                 break;
3529                                         }
3530                                 }
3531                         }
3532
3533                         /* create new fcport */
3534                         ql_dbg(ql_dbg_disc, vha, 0x2065,
3535                             "%s %d %8phC post new sess\n",
3536                             __func__, __LINE__, ea->port_name);
3537                         qla24xx_post_newsess_work(vha, &ea->id,
3538                             ea->port_name, NULL, NULL, FC4_TYPE_UNKNOWN);
3539                 }
3540         }
3541 }
3542
3543 static void qla2x00_async_gpnid_sp_done(void *s, int res)
3544 {
3545         struct srb *sp = s;
3546         struct scsi_qla_host *vha = sp->vha;
3547         struct ct_sns_req *ct_req =
3548             (struct ct_sns_req *)sp->u.iocb_cmd.u.ctarg.req;
3549         struct ct_sns_rsp *ct_rsp =
3550             (struct ct_sns_rsp *)sp->u.iocb_cmd.u.ctarg.rsp;
3551         struct event_arg ea;
3552         struct qla_work_evt *e;
3553         unsigned long flags;
3554
3555         if (res)
3556                 ql_dbg(ql_dbg_disc, vha, 0x2066,
3557                     "Async done-%s fail res %x rscn gen %d ID %3phC. %8phC\n",
3558                     sp->name, res, sp->gen1, ct_req->req.port_id.port_id,
3559                     ct_rsp->rsp.gpn_id.port_name);
3560         else
3561                 ql_dbg(ql_dbg_disc, vha, 0x2066,
3562                     "Async done-%s good rscn gen %d ID %3phC. %8phC\n",
3563                     sp->name, sp->gen1, ct_req->req.port_id.port_id,
3564                     ct_rsp->rsp.gpn_id.port_name);
3565
3566         memset(&ea, 0, sizeof(ea));
3567         memcpy(ea.port_name, ct_rsp->rsp.gpn_id.port_name, WWN_SIZE);
3568         ea.sp = sp;
3569         ea.id.b.domain = ct_req->req.port_id.port_id[0];
3570         ea.id.b.area = ct_req->req.port_id.port_id[1];
3571         ea.id.b.al_pa = ct_req->req.port_id.port_id[2];
3572         ea.rc = res;
3573         ea.event = FCME_GPNID_DONE;
3574
3575         spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
3576         list_del(&sp->elem);
3577         spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
3578
3579         if (res) {
3580                 if (res == QLA_FUNCTION_TIMEOUT) {
3581                         qla24xx_post_gpnid_work(sp->vha, &ea.id);
3582                         sp->free(sp);
3583                         return;
3584                 }
3585         } else if (sp->gen1) {
3586                 /* There was another RSCN for this Nport ID */
3587                 qla24xx_post_gpnid_work(sp->vha, &ea.id);
3588                 sp->free(sp);
3589                 return;
3590         }
3591
3592         qla2x00_fcport_event_handler(vha, &ea);
3593
3594         e = qla2x00_alloc_work(vha, QLA_EVT_UNMAP);
3595         if (!e) {
3596                 /* please ignore kernel warning. otherwise, we have mem leak. */
3597                 if (sp->u.iocb_cmd.u.ctarg.req) {
3598                         dma_free_coherent(&vha->hw->pdev->dev,
3599                                 sizeof(struct ct_sns_pkt),
3600                                 sp->u.iocb_cmd.u.ctarg.req,
3601                                 sp->u.iocb_cmd.u.ctarg.req_dma);
3602                         sp->u.iocb_cmd.u.ctarg.req = NULL;
3603                 }
3604                 if (sp->u.iocb_cmd.u.ctarg.rsp) {
3605                         dma_free_coherent(&vha->hw->pdev->dev,
3606                                 sizeof(struct ct_sns_pkt),
3607                                 sp->u.iocb_cmd.u.ctarg.rsp,
3608                                 sp->u.iocb_cmd.u.ctarg.rsp_dma);
3609                         sp->u.iocb_cmd.u.ctarg.rsp = NULL;
3610                 }
3611
3612                 sp->free(sp);
3613                 return;
3614         }
3615
3616         e->u.iosb.sp = sp;
3617         qla2x00_post_work(vha, e);
3618 }
3619
3620 /* Get WWPN with Nport ID. */
3621 int qla24xx_async_gpnid(scsi_qla_host_t *vha, port_id_t *id)
3622 {
3623         int rval = QLA_FUNCTION_FAILED;
3624         struct ct_sns_req       *ct_req;
3625         srb_t *sp, *tsp;
3626         struct ct_sns_pkt *ct_sns;
3627         unsigned long flags;
3628
3629         if (!vha->flags.online)
3630                 goto done;
3631
3632         sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
3633         if (!sp)
3634                 goto done;
3635
3636         sp->type = SRB_CT_PTHRU_CMD;
3637         sp->name = "gpnid";
3638         sp->u.iocb_cmd.u.ctarg.id = *id;
3639         sp->gen1 = 0;
3640         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
3641
3642         spin_lock_irqsave(&vha->hw->tgt.sess_lock, flags);
3643         list_for_each_entry(tsp, &vha->gpnid_list, elem) {
3644                 if (tsp->u.iocb_cmd.u.ctarg.id.b24 == id->b24) {
3645                         tsp->gen1++;
3646                         spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
3647                         sp->free(sp);
3648                         goto done;
3649                 }
3650         }
3651         list_add_tail(&sp->elem, &vha->gpnid_list);
3652         spin_unlock_irqrestore(&vha->hw->tgt.sess_lock, flags);
3653
3654         sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
3655                 sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.req_dma,
3656                 GFP_KERNEL);
3657         if (!sp->u.iocb_cmd.u.ctarg.req) {
3658                 ql_log(ql_log_warn, vha, 0xd041,
3659                     "Failed to allocate ct_sns request.\n");
3660                 goto done_free_sp;
3661         }
3662
3663         sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
3664                 sizeof(struct ct_sns_pkt), &sp->u.iocb_cmd.u.ctarg.rsp_dma,
3665                 GFP_KERNEL);
3666         if (!sp->u.iocb_cmd.u.ctarg.rsp) {
3667                 ql_log(ql_log_warn, vha, 0xd042,
3668                     "Failed to allocate ct_sns request.\n");
3669                 goto done_free_sp;
3670         }
3671
3672         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.rsp;
3673         memset(ct_sns, 0, sizeof(*ct_sns));
3674
3675         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
3676         /* CT_IU preamble  */
3677         ct_req = qla2x00_prep_ct_req(ct_sns, GPN_ID_CMD, GPN_ID_RSP_SIZE);
3678
3679         /* GPN_ID req */
3680         ct_req->req.port_id.port_id[0] = id->b.domain;
3681         ct_req->req.port_id.port_id[1] = id->b.area;
3682         ct_req->req.port_id.port_id[2] = id->b.al_pa;
3683
3684         sp->u.iocb_cmd.u.ctarg.req_size = GPN_ID_REQ_SIZE;
3685         sp->u.iocb_cmd.u.ctarg.rsp_size = GPN_ID_RSP_SIZE;
3686         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
3687
3688         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
3689         sp->done = qla2x00_async_gpnid_sp_done;
3690
3691         rval = qla2x00_start_sp(sp);
3692         if (rval != QLA_SUCCESS)
3693                 goto done_free_sp;
3694
3695         ql_dbg(ql_dbg_disc, vha, 0x2067,
3696             "Async-%s hdl=%x ID %3phC.\n", sp->name,
3697             sp->handle, ct_req->req.port_id.port_id);
3698         return rval;
3699
3700 done_free_sp:
3701         if (sp->u.iocb_cmd.u.ctarg.req) {
3702                 dma_free_coherent(&vha->hw->pdev->dev,
3703                         sizeof(struct ct_sns_pkt),
3704                         sp->u.iocb_cmd.u.ctarg.req,
3705                         sp->u.iocb_cmd.u.ctarg.req_dma);
3706                 sp->u.iocb_cmd.u.ctarg.req = NULL;
3707         }
3708         if (sp->u.iocb_cmd.u.ctarg.rsp) {
3709                 dma_free_coherent(&vha->hw->pdev->dev,
3710                         sizeof(struct ct_sns_pkt),
3711                         sp->u.iocb_cmd.u.ctarg.rsp,
3712                         sp->u.iocb_cmd.u.ctarg.rsp_dma);
3713                 sp->u.iocb_cmd.u.ctarg.rsp = NULL;
3714         }
3715
3716         sp->free(sp);
3717 done:
3718         return rval;
3719 }
3720
3721 void qla24xx_handle_gffid_event(scsi_qla_host_t *vha, struct event_arg *ea)
3722 {
3723        fc_port_t *fcport = ea->fcport;
3724
3725        qla24xx_post_gnl_work(vha, fcport);
3726 }
3727
3728 void qla24xx_async_gffid_sp_done(void *s, int res)
3729 {
3730        struct srb *sp = s;
3731        struct scsi_qla_host *vha = sp->vha;
3732        fc_port_t *fcport = sp->fcport;
3733        struct ct_sns_rsp *ct_rsp;
3734        struct event_arg ea;
3735
3736        ql_dbg(ql_dbg_disc, vha, 0x2133,
3737            "Async done-%s res %x ID %x. %8phC\n",
3738            sp->name, res, fcport->d_id.b24, fcport->port_name);
3739
3740        fcport->flags &= ~FCF_ASYNC_SENT;
3741        ct_rsp = &fcport->ct_desc.ct_sns->p.rsp;
3742        /*
3743         * FC-GS-7, 5.2.3.12 FC-4 Features - format
3744         * The format of the FC-4 Features object, as defined by the FC-4,
3745         * Shall be an array of 4-bit values, one for each type code value
3746         */
3747        if (!res) {
3748                if (ct_rsp->rsp.gff_id.fc4_features[GFF_FCP_SCSI_OFFSET] & 0xf) {
3749                        /* w1 b00:03 */
3750                        fcport->fc4_type =
3751                            ct_rsp->rsp.gff_id.fc4_features[GFF_FCP_SCSI_OFFSET];
3752                        fcport->fc4_type &= 0xf;
3753                }
3754
3755                if (ct_rsp->rsp.gff_id.fc4_features[GFF_NVME_OFFSET] & 0xf) {
3756                        /* w5 [00:03]/28h */
3757                        fcport->fc4f_nvme =
3758                            ct_rsp->rsp.gff_id.fc4_features[GFF_NVME_OFFSET];
3759                        fcport->fc4f_nvme &= 0xf;
3760                }
3761        }
3762
3763        memset(&ea, 0, sizeof(ea));
3764        ea.sp = sp;
3765        ea.fcport = sp->fcport;
3766        ea.rc = res;
3767        ea.event = FCME_GFFID_DONE;
3768
3769        qla2x00_fcport_event_handler(vha, &ea);
3770        sp->free(sp);
3771 }
3772
3773 /* Get FC4 Feature with Nport ID. */
3774 int qla24xx_async_gffid(scsi_qla_host_t *vha, fc_port_t *fcport)
3775 {
3776         int rval = QLA_FUNCTION_FAILED;
3777         struct ct_sns_req       *ct_req;
3778         srb_t *sp;
3779
3780         if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT))
3781                 return rval;
3782
3783         sp = qla2x00_get_sp(vha, fcport, GFP_KERNEL);
3784         if (!sp)
3785                 return rval;
3786
3787         fcport->flags |= FCF_ASYNC_SENT;
3788         sp->type = SRB_CT_PTHRU_CMD;
3789         sp->name = "gffid";
3790         sp->gen1 = fcport->rscn_gen;
3791         sp->gen2 = fcport->login_gen;
3792
3793         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
3794         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
3795
3796         /* CT_IU preamble  */
3797         ct_req = qla2x00_prep_ct_req(fcport->ct_desc.ct_sns, GFF_ID_CMD,
3798             GFF_ID_RSP_SIZE);
3799
3800         ct_req->req.gff_id.port_id[0] = fcport->d_id.b.domain;
3801         ct_req->req.gff_id.port_id[1] = fcport->d_id.b.area;
3802         ct_req->req.gff_id.port_id[2] = fcport->d_id.b.al_pa;
3803
3804         sp->u.iocb_cmd.u.ctarg.req = fcport->ct_desc.ct_sns;
3805         sp->u.iocb_cmd.u.ctarg.req_dma = fcport->ct_desc.ct_sns_dma;
3806         sp->u.iocb_cmd.u.ctarg.rsp = fcport->ct_desc.ct_sns;
3807         sp->u.iocb_cmd.u.ctarg.rsp_dma = fcport->ct_desc.ct_sns_dma;
3808         sp->u.iocb_cmd.u.ctarg.req_size = GFF_ID_REQ_SIZE;
3809         sp->u.iocb_cmd.u.ctarg.rsp_size = GFF_ID_RSP_SIZE;
3810         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
3811
3812         sp->done = qla24xx_async_gffid_sp_done;
3813
3814         rval = qla2x00_start_sp(sp);
3815         if (rval != QLA_SUCCESS)
3816                 goto done_free_sp;
3817
3818         ql_dbg(ql_dbg_disc, vha, 0x2132,
3819             "Async-%s hdl=%x  %8phC.\n", sp->name,
3820             sp->handle, fcport->port_name);
3821
3822         return rval;
3823 done_free_sp:
3824         sp->free(sp);
3825         fcport->flags &= ~FCF_ASYNC_SENT;
3826         return rval;
3827 }
3828
3829 /* GPN_FT + GNN_FT*/
3830 static int qla2x00_is_a_vp(scsi_qla_host_t *vha, u64 wwn)
3831 {
3832         struct qla_hw_data *ha = vha->hw;
3833         scsi_qla_host_t *vp;
3834         unsigned long flags;
3835         u64 twwn;
3836         int rc = 0;
3837
3838         if (!ha->num_vhosts)
3839                 return 0;
3840
3841         spin_lock_irqsave(&ha->vport_slock, flags);
3842         list_for_each_entry(vp, &ha->vp_list, list) {
3843                 twwn = wwn_to_u64(vp->port_name);
3844                 if (wwn == twwn) {
3845                         rc = 1;
3846                         break;
3847                 }
3848         }
3849         spin_unlock_irqrestore(&ha->vport_slock, flags);
3850
3851         return rc;
3852 }
3853
3854 void qla24xx_async_gnnft_done(scsi_qla_host_t *vha, srb_t *sp)
3855 {
3856         fc_port_t *fcport;
3857         u32 i, rc;
3858         bool found;
3859         struct fab_scan_rp *rp;
3860         unsigned long flags;
3861         u8 recheck = 0;
3862
3863         ql_dbg(ql_dbg_disc, vha, 0xffff,
3864             "%s enter\n", __func__);
3865
3866         if (sp->gen1 != vha->hw->base_qpair->chip_reset) {
3867                 ql_dbg(ql_dbg_disc, vha, 0xffff,
3868                     "%s scan stop due to chip reset %x/%x\n",
3869                     sp->name, sp->gen1, vha->hw->base_qpair->chip_reset);
3870                 goto out;
3871         }
3872
3873         rc = sp->rc;
3874         if (rc) {
3875                 vha->scan.scan_retry++;
3876                 if (vha->scan.scan_retry < MAX_SCAN_RETRIES) {
3877                         set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3878                         set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3879                 } else {
3880                         ql_dbg(ql_dbg_disc, vha, 0xffff,
3881                             "Fabric scan failed on all retries.\n");
3882                 }
3883                 goto out;
3884         }
3885         vha->scan.scan_retry = 0;
3886
3887         list_for_each_entry(fcport, &vha->vp_fcports, list)
3888                 fcport->scan_state = QLA_FCPORT_SCAN;
3889
3890         for (i = 0; i < vha->hw->max_fibre_devices; i++) {
3891                 u64 wwn;
3892
3893                 rp = &vha->scan.l[i];
3894                 found = false;
3895
3896                 wwn = wwn_to_u64(rp->port_name);
3897                 if (wwn == 0)
3898                         continue;
3899
3900                 if (!memcmp(rp->port_name, vha->port_name, WWN_SIZE))
3901                         continue;
3902
3903                 /* Bypass reserved domain fields. */
3904                 if ((rp->id.b.domain & 0xf0) == 0xf0)
3905                         continue;
3906
3907                 /* Bypass virtual ports of the same host. */
3908                 if (qla2x00_is_a_vp(vha, wwn))
3909                         continue;
3910
3911                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
3912                         if (memcmp(rp->port_name, fcport->port_name, WWN_SIZE))
3913                                 continue;
3914                         fcport->rscn_rcvd = 0;
3915                         fcport->scan_state = QLA_FCPORT_FOUND;
3916                         found = true;
3917                         /*
3918                          * If device was not a fabric device before.
3919                          */
3920                         if ((fcport->flags & FCF_FABRIC_DEVICE) == 0) {
3921                                 qla2x00_clear_loop_id(fcport);
3922                                 fcport->flags |= FCF_FABRIC_DEVICE;
3923                         } else if (fcport->d_id.b24 != rp->id.b24) {
3924                                 qlt_schedule_sess_for_deletion(fcport);
3925                         }
3926                         fcport->d_id.b24 = rp->id.b24;
3927                         break;
3928                 }
3929
3930                 if (!found) {
3931                         ql_dbg(ql_dbg_disc, vha, 0xffff,
3932                             "%s %d %8phC post new sess\n",
3933                             __func__, __LINE__, rp->port_name);
3934                         qla24xx_post_newsess_work(vha, &rp->id, rp->port_name,
3935                             rp->node_name, NULL, rp->fc4type);
3936                 }
3937         }
3938
3939         /*
3940          * Logout all previous fabric dev marked lost, except FCP2 devices.
3941          */
3942         list_for_each_entry(fcport, &vha->vp_fcports, list) {
3943                 if ((fcport->flags & FCF_FABRIC_DEVICE) == 0) {
3944                         fcport->rscn_rcvd = 0;
3945                         continue;
3946                 }
3947
3948                 if (fcport->scan_state != QLA_FCPORT_FOUND) {
3949                         fcport->rscn_rcvd = 0;
3950                         if ((qla_dual_mode_enabled(vha) ||
3951                                 qla_ini_mode_enabled(vha)) &&
3952                             atomic_read(&fcport->state) == FCS_ONLINE) {
3953                                 qla2x00_mark_device_lost(vha, fcport,
3954                                     ql2xplogiabsentdevice, 0);
3955
3956                                 if (fcport->loop_id != FC_NO_LOOP_ID &&
3957                                     (fcport->flags & FCF_FCP2_DEVICE) == 0) {
3958                                         ql_dbg(ql_dbg_disc, vha, 0x20f0,
3959                                             "%s %d %8phC post del sess\n",
3960                                             __func__, __LINE__,
3961                                             fcport->port_name);
3962
3963                                         qlt_schedule_sess_for_deletion(fcport);
3964                                         continue;
3965                                 }
3966                         }
3967                 } else {
3968                         if (fcport->rscn_rcvd ||
3969                             fcport->disc_state != DSC_LOGIN_COMPLETE) {
3970                                 fcport->rscn_rcvd = 0;
3971                                 qla24xx_fcport_handle_login(vha, fcport);
3972                         }
3973                 }
3974         }
3975
3976         recheck = 1;
3977 out:
3978         qla24xx_sp_unmap(vha, sp);
3979         spin_lock_irqsave(&vha->work_lock, flags);
3980         vha->scan.scan_flags &= ~SF_SCANNING;
3981         spin_unlock_irqrestore(&vha->work_lock, flags);
3982
3983         if (recheck) {
3984                 list_for_each_entry(fcport, &vha->vp_fcports, list) {
3985                         if (fcport->rscn_rcvd) {
3986                                 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
3987                                 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
3988                                 break;
3989                         }
3990                 }
3991         }
3992 }
3993
3994 static void qla2x00_find_free_fcp_nvme_slot(struct scsi_qla_host *vha,
3995         struct srb *sp)
3996 {
3997         struct qla_hw_data *ha = vha->hw;
3998         int num_fibre_dev = ha->max_fibre_devices;
3999         struct ct_sns_req *ct_req =
4000                 (struct ct_sns_req *)sp->u.iocb_cmd.u.ctarg.req;
4001         struct ct_sns_gpnft_rsp *ct_rsp =
4002                 (struct ct_sns_gpnft_rsp *)sp->u.iocb_cmd.u.ctarg.rsp;
4003         struct ct_sns_gpn_ft_data *d;
4004         struct fab_scan_rp *rp;
4005         u16 cmd = be16_to_cpu(ct_req->command);
4006         u8 fc4_type = sp->gen2;
4007         int i, j, k;
4008         port_id_t id;
4009         u8 found;
4010         u64 wwn;
4011
4012         j = 0;
4013         for (i = 0; i < num_fibre_dev; i++) {
4014                 d  = &ct_rsp->entries[i];
4015
4016                 id.b.rsvd_1 = 0;
4017                 id.b.domain = d->port_id[0];
4018                 id.b.area   = d->port_id[1];
4019                 id.b.al_pa  = d->port_id[2];
4020                 wwn = wwn_to_u64(d->port_name);
4021
4022                 if (id.b24 == 0 || wwn == 0)
4023                         continue;
4024
4025                 if (fc4_type == FC4_TYPE_FCP_SCSI) {
4026                         if (cmd == GPN_FT_CMD) {
4027                                 rp = &vha->scan.l[j];
4028                                 rp->id = id;
4029                                 memcpy(rp->port_name, d->port_name, 8);
4030                                 j++;
4031                                 rp->fc4type = FS_FC4TYPE_FCP;
4032                         } else {
4033                                 for (k = 0; k < num_fibre_dev; k++) {
4034                                         rp = &vha->scan.l[k];
4035                                         if (id.b24 == rp->id.b24) {
4036                                                 memcpy(rp->node_name,
4037                                                     d->port_name, 8);
4038                                                 break;
4039                                         }
4040                                 }
4041                         }
4042                 } else {
4043                         /* Search if the fibre device supports FC4_TYPE_NVME */
4044                         if (cmd == GPN_FT_CMD) {
4045                                 found = 0;
4046
4047                                 for (k = 0; k < num_fibre_dev; k++) {
4048                                         rp = &vha->scan.l[k];
4049                                         if (!memcmp(rp->port_name,
4050                                             d->port_name, 8)) {
4051                                                 /*
4052                                                  * Supports FC-NVMe & FCP
4053                                                  */
4054                                                 rp->fc4type |= FS_FC4TYPE_NVME;
4055                                                 found = 1;
4056                                                 break;
4057                                         }
4058                                 }
4059
4060                                 /* We found new FC-NVMe only port */
4061                                 if (!found) {
4062                                         for (k = 0; k < num_fibre_dev; k++) {
4063                                                 rp = &vha->scan.l[k];
4064                                                 if (wwn_to_u64(rp->port_name)) {
4065                                                         continue;
4066                                                 } else {
4067                                                         rp->id = id;
4068                                                         memcpy(rp->port_name,
4069                                                             d->port_name, 8);
4070                                                         rp->fc4type =
4071                                                             FS_FC4TYPE_NVME;
4072                                                         break;
4073                                                 }
4074                                         }
4075                                 }
4076                         } else {
4077                                 for (k = 0; k < num_fibre_dev; k++) {
4078                                         rp = &vha->scan.l[k];
4079                                         if (id.b24 == rp->id.b24) {
4080                                                 memcpy(rp->node_name,
4081                                                     d->port_name, 8);
4082                                                 break;
4083                                         }
4084                                 }
4085                         }
4086                 }
4087         }
4088 }
4089
4090 static void qla2x00_async_gpnft_gnnft_sp_done(void *s, int res)
4091 {
4092         struct srb *sp = s;
4093         struct scsi_qla_host *vha = sp->vha;
4094         struct qla_work_evt *e;
4095         struct ct_sns_req *ct_req =
4096                 (struct ct_sns_req *)sp->u.iocb_cmd.u.ctarg.req;
4097         u16 cmd = be16_to_cpu(ct_req->command);
4098         u8 fc4_type = sp->gen2;
4099         unsigned long flags;
4100
4101         /* gen2 field is holding the fc4type */
4102         ql_dbg(ql_dbg_disc, vha, 0xffff,
4103             "Async done-%s res %x FC4Type %x\n",
4104             sp->name, res, sp->gen2);
4105
4106         if (res) {
4107                 unsigned long flags;
4108
4109                 sp->free(sp);
4110                 spin_lock_irqsave(&vha->work_lock, flags);
4111                 vha->scan.scan_flags &= ~SF_SCANNING;
4112                 vha->scan.scan_retry++;
4113                 spin_unlock_irqrestore(&vha->work_lock, flags);
4114
4115                 if (vha->scan.scan_retry < MAX_SCAN_RETRIES) {
4116                         set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
4117                         set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
4118                         qla2xxx_wake_dpc(vha);
4119                 } else {
4120                         ql_dbg(ql_dbg_disc, sp->vha, 0xffff,
4121                             "Async done-%s rescan failed on all retries\n",
4122                             sp->name);
4123                 }
4124                 return;
4125         }
4126
4127         if (!res)
4128                 qla2x00_find_free_fcp_nvme_slot(vha, sp);
4129
4130         if ((fc4_type == FC4_TYPE_FCP_SCSI) && vha->flags.nvme_enabled &&
4131             cmd == GNN_FT_CMD) {
4132                 del_timer(&sp->u.iocb_cmd.timer);
4133                 spin_lock_irqsave(&vha->work_lock, flags);
4134                 vha->scan.scan_flags &= ~SF_SCANNING;
4135                 spin_unlock_irqrestore(&vha->work_lock, flags);
4136
4137                 e = qla2x00_alloc_work(vha, QLA_EVT_GPNFT);
4138                 if (!e) {
4139                         /*
4140                          * please ignore kernel warning. Otherwise,
4141                          * we have mem leak.
4142                          */
4143                         if (sp->u.iocb_cmd.u.ctarg.req) {
4144                                 dma_free_coherent(&vha->hw->pdev->dev,
4145                                     sizeof(struct ct_sns_pkt),
4146                                     sp->u.iocb_cmd.u.ctarg.req,
4147                                     sp->u.iocb_cmd.u.ctarg.req_dma);
4148                                 sp->u.iocb_cmd.u.ctarg.req = NULL;
4149                         }
4150                         if (sp->u.iocb_cmd.u.ctarg.rsp) {
4151                                 dma_free_coherent(&vha->hw->pdev->dev,
4152                                     sizeof(struct ct_sns_pkt),
4153                                     sp->u.iocb_cmd.u.ctarg.rsp,
4154                                     sp->u.iocb_cmd.u.ctarg.rsp_dma);
4155                                 sp->u.iocb_cmd.u.ctarg.rsp = NULL;
4156                         }
4157
4158                         ql_dbg(ql_dbg_disc, vha, 0xffff,
4159                             "Async done-%s unable to alloc work element\n",
4160                             sp->name);
4161                         sp->free(sp);
4162                         set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
4163                         set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
4164                         return;
4165                 }
4166                 e->u.gpnft.fc4_type = FC4_TYPE_NVME;
4167                 sp->rc = res;
4168                 e->u.gpnft.sp = sp;
4169
4170                 qla2x00_post_work(vha, e);
4171                 return;
4172         }
4173
4174         if (cmd == GPN_FT_CMD)
4175                 e = qla2x00_alloc_work(vha, QLA_EVT_GPNFT_DONE);
4176         else
4177                 e = qla2x00_alloc_work(vha, QLA_EVT_GNNFT_DONE);
4178         if (!e) {
4179                 /* please ignore kernel warning. Otherwise, we have mem leak. */
4180                 if (sp->u.iocb_cmd.u.ctarg.req) {
4181                         dma_free_coherent(&vha->hw->pdev->dev,
4182                             sizeof(struct ct_sns_pkt),
4183                             sp->u.iocb_cmd.u.ctarg.req,
4184                             sp->u.iocb_cmd.u.ctarg.req_dma);
4185                         sp->u.iocb_cmd.u.ctarg.req = NULL;
4186                 }
4187                 if (sp->u.iocb_cmd.u.ctarg.rsp) {
4188                         dma_free_coherent(&vha->hw->pdev->dev,
4189                             sizeof(struct ct_sns_pkt),
4190                             sp->u.iocb_cmd.u.ctarg.rsp,
4191                             sp->u.iocb_cmd.u.ctarg.rsp_dma);
4192                         sp->u.iocb_cmd.u.ctarg.rsp = NULL;
4193                 }
4194
4195                 ql_dbg(ql_dbg_disc, vha, 0xffff,
4196                     "Async done-%s unable to alloc work element\n",
4197                     sp->name);
4198                 sp->free(sp);
4199                 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
4200                 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
4201                 return;
4202         }
4203
4204         sp->rc = res;
4205         e->u.iosb.sp = sp;
4206
4207         qla2x00_post_work(vha, e);
4208 }
4209
4210 /*
4211  * Get WWNN list for fc4_type
4212  *
4213  * It is assumed the same SRB is re-used from GPNFT to avoid
4214  * mem free & re-alloc
4215  */
4216 static int qla24xx_async_gnnft(scsi_qla_host_t *vha, struct srb *sp,
4217     u8 fc4_type)
4218 {
4219         int rval = QLA_FUNCTION_FAILED;
4220         struct ct_sns_req *ct_req;
4221         struct ct_sns_pkt *ct_sns;
4222         unsigned long flags;
4223
4224         if (!vha->flags.online) {
4225                 spin_lock_irqsave(&vha->work_lock, flags);
4226                 vha->scan.scan_flags &= ~SF_SCANNING;
4227                 spin_unlock_irqrestore(&vha->work_lock, flags);
4228                 goto done_free_sp;
4229         }
4230
4231         if (!sp->u.iocb_cmd.u.ctarg.req || !sp->u.iocb_cmd.u.ctarg.rsp) {
4232                 ql_log(ql_log_warn, vha, 0xffff,
4233                     "%s: req %p rsp %p are not setup\n",
4234                     __func__, sp->u.iocb_cmd.u.ctarg.req,
4235                     sp->u.iocb_cmd.u.ctarg.rsp);
4236                 spin_lock_irqsave(&vha->work_lock, flags);
4237                 vha->scan.scan_flags &= ~SF_SCANNING;
4238                 spin_unlock_irqrestore(&vha->work_lock, flags);
4239                 WARN_ON(1);
4240                 goto done_free_sp;
4241         }
4242
4243         ql_dbg(ql_dbg_disc, vha, 0xfffff,
4244             "%s: FC4Type %x, CT-PASSTRHU %s command ctarg rsp size %d, ctarg req size %d\n",
4245             __func__, fc4_type, sp->name, sp->u.iocb_cmd.u.ctarg.rsp_size,
4246              sp->u.iocb_cmd.u.ctarg.req_size);
4247
4248         sp->type = SRB_CT_PTHRU_CMD;
4249         sp->name = "gnnft";
4250         sp->gen1 = vha->hw->base_qpair->chip_reset;
4251         sp->gen2 = fc4_type;
4252
4253         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
4254         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
4255
4256         memset(sp->u.iocb_cmd.u.ctarg.rsp, 0, sp->u.iocb_cmd.u.ctarg.rsp_size);
4257         memset(sp->u.iocb_cmd.u.ctarg.req, 0, sp->u.iocb_cmd.u.ctarg.req_size);
4258
4259         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
4260         /* CT_IU preamble  */
4261         ct_req = qla2x00_prep_ct_req(ct_sns, GNN_FT_CMD,
4262             sp->u.iocb_cmd.u.ctarg.rsp_size);
4263
4264         /* GPN_FT req */
4265         ct_req->req.gpn_ft.port_type = fc4_type;
4266
4267         sp->u.iocb_cmd.u.ctarg.req_size = GNN_FT_REQ_SIZE;
4268         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
4269
4270         sp->done = qla2x00_async_gpnft_gnnft_sp_done;
4271
4272         rval = qla2x00_start_sp(sp);
4273         if (rval != QLA_SUCCESS)
4274                 goto done_free_sp;
4275
4276         ql_dbg(ql_dbg_disc, vha, 0xffff,
4277             "Async-%s hdl=%x FC4Type %x.\n", sp->name,
4278             sp->handle, ct_req->req.gpn_ft.port_type);
4279         return rval;
4280
4281 done_free_sp:
4282         if (sp->u.iocb_cmd.u.ctarg.req) {
4283                 dma_free_coherent(&vha->hw->pdev->dev,
4284                     sizeof(struct ct_sns_pkt),
4285                     sp->u.iocb_cmd.u.ctarg.req,
4286                     sp->u.iocb_cmd.u.ctarg.req_dma);
4287                 sp->u.iocb_cmd.u.ctarg.req = NULL;
4288         }
4289         if (sp->u.iocb_cmd.u.ctarg.rsp) {
4290                 dma_free_coherent(&vha->hw->pdev->dev,
4291                     sizeof(struct ct_sns_pkt),
4292                     sp->u.iocb_cmd.u.ctarg.rsp,
4293                     sp->u.iocb_cmd.u.ctarg.rsp_dma);
4294                 sp->u.iocb_cmd.u.ctarg.rsp = NULL;
4295         }
4296
4297         sp->free(sp);
4298
4299         return rval;
4300 } /* GNNFT */
4301
4302 void qla24xx_async_gpnft_done(scsi_qla_host_t *vha, srb_t *sp)
4303 {
4304         ql_dbg(ql_dbg_disc, vha, 0xffff,
4305             "%s enter\n", __func__);
4306         del_timer(&sp->u.iocb_cmd.timer);
4307         qla24xx_async_gnnft(vha, sp, sp->gen2);
4308 }
4309
4310 /* Get WWPN list for certain fc4_type */
4311 int qla24xx_async_gpnft(scsi_qla_host_t *vha, u8 fc4_type, srb_t *sp)
4312 {
4313         int rval = QLA_FUNCTION_FAILED;
4314         struct ct_sns_req       *ct_req;
4315         struct ct_sns_pkt *ct_sns;
4316         u32 rspsz;
4317         unsigned long flags;
4318
4319         ql_dbg(ql_dbg_disc, vha, 0xffff,
4320             "%s enter\n", __func__);
4321
4322         if (!vha->flags.online)
4323                 return rval;
4324
4325         spin_lock_irqsave(&vha->work_lock, flags);
4326         if (vha->scan.scan_flags & SF_SCANNING) {
4327                 spin_unlock_irqrestore(&vha->work_lock, flags);
4328                 ql_dbg(ql_dbg_disc, vha, 0xffff, "scan active\n");
4329                 return rval;
4330         }
4331         vha->scan.scan_flags |= SF_SCANNING;
4332         spin_unlock_irqrestore(&vha->work_lock, flags);
4333
4334         if (fc4_type == FC4_TYPE_FCP_SCSI) {
4335                 ql_dbg(ql_dbg_disc, vha, 0xffff,
4336                     "%s: Performing FCP Scan\n", __func__);
4337
4338                 if (sp)
4339                         sp->free(sp); /* should not happen */
4340
4341                 sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
4342                 if (!sp) {
4343                         spin_lock_irqsave(&vha->work_lock, flags);
4344                         vha->scan.scan_flags &= ~SF_SCANNING;
4345                         spin_unlock_irqrestore(&vha->work_lock, flags);
4346                         return rval;
4347                 }
4348
4349                 sp->u.iocb_cmd.u.ctarg.req = dma_zalloc_coherent(
4350                         &vha->hw->pdev->dev, sizeof(struct ct_sns_pkt),
4351                         &sp->u.iocb_cmd.u.ctarg.req_dma, GFP_KERNEL);
4352                 if (!sp->u.iocb_cmd.u.ctarg.req) {
4353                         ql_log(ql_log_warn, vha, 0xffff,
4354                             "Failed to allocate ct_sns request.\n");
4355                         spin_lock_irqsave(&vha->work_lock, flags);
4356                         vha->scan.scan_flags &= ~SF_SCANNING;
4357                         spin_unlock_irqrestore(&vha->work_lock, flags);
4358                         goto done_free_sp;
4359                 }
4360                 sp->u.iocb_cmd.u.ctarg.req_size = GPN_FT_REQ_SIZE;
4361
4362                 rspsz = sizeof(struct ct_sns_gpnft_rsp) +
4363                         ((vha->hw->max_fibre_devices - 1) *
4364                             sizeof(struct ct_sns_gpn_ft_data));
4365
4366                 sp->u.iocb_cmd.u.ctarg.rsp = dma_zalloc_coherent(
4367                         &vha->hw->pdev->dev, rspsz,
4368                         &sp->u.iocb_cmd.u.ctarg.rsp_dma, GFP_KERNEL);
4369                 if (!sp->u.iocb_cmd.u.ctarg.rsp) {
4370                         ql_log(ql_log_warn, vha, 0xffff,
4371                             "Failed to allocate ct_sns request.\n");
4372                         spin_lock_irqsave(&vha->work_lock, flags);
4373                         vha->scan.scan_flags &= ~SF_SCANNING;
4374                         spin_unlock_irqrestore(&vha->work_lock, flags);
4375                         goto done_free_sp;
4376                 }
4377                 sp->u.iocb_cmd.u.ctarg.rsp_size = rspsz;
4378
4379                 ql_dbg(ql_dbg_disc, vha, 0xffff,
4380                     "%s scan list size %d\n", __func__, vha->scan.size);
4381
4382                 memset(vha->scan.l, 0, vha->scan.size);
4383         } else if (!sp) {
4384                 ql_dbg(ql_dbg_disc, vha, 0xffff,
4385                     "NVME scan did not provide SP\n");
4386                 return rval;
4387         }
4388
4389         sp->type = SRB_CT_PTHRU_CMD;
4390         sp->name = "gpnft";
4391         sp->gen1 = vha->hw->base_qpair->chip_reset;
4392         sp->gen2 = fc4_type;
4393
4394         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
4395         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
4396
4397         rspsz = sizeof(struct ct_sns_gpnft_rsp) +
4398                 ((vha->hw->max_fibre_devices - 1) *
4399                     sizeof(struct ct_sns_gpn_ft_data));
4400
4401         ct_sns = (struct ct_sns_pkt *)sp->u.iocb_cmd.u.ctarg.req;
4402         /* CT_IU preamble  */
4403         ct_req = qla2x00_prep_ct_req(ct_sns, GPN_FT_CMD, rspsz);
4404
4405         /* GPN_FT req */
4406         ct_req->req.gpn_ft.port_type = fc4_type;
4407
4408         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
4409
4410         sp->done = qla2x00_async_gpnft_gnnft_sp_done;
4411
4412         rval = qla2x00_start_sp(sp);
4413         if (rval != QLA_SUCCESS) {
4414                 spin_lock_irqsave(&vha->work_lock, flags);
4415                 vha->scan.scan_flags &= ~SF_SCANNING;
4416                 spin_unlock_irqrestore(&vha->work_lock, flags);
4417                 goto done_free_sp;
4418         }
4419
4420         ql_dbg(ql_dbg_disc, vha, 0xffff,
4421             "Async-%s hdl=%x FC4Type %x.\n", sp->name,
4422             sp->handle, ct_req->req.gpn_ft.port_type);
4423         return rval;
4424
4425 done_free_sp:
4426         if (sp->u.iocb_cmd.u.ctarg.req) {
4427                 dma_free_coherent(&vha->hw->pdev->dev,
4428                     sizeof(struct ct_sns_pkt),
4429                     sp->u.iocb_cmd.u.ctarg.req,
4430                     sp->u.iocb_cmd.u.ctarg.req_dma);
4431                 sp->u.iocb_cmd.u.ctarg.req = NULL;
4432         }
4433         if (sp->u.iocb_cmd.u.ctarg.rsp) {
4434                 dma_free_coherent(&vha->hw->pdev->dev,
4435                     sizeof(struct ct_sns_pkt),
4436                     sp->u.iocb_cmd.u.ctarg.rsp,
4437                     sp->u.iocb_cmd.u.ctarg.rsp_dma);
4438                 sp->u.iocb_cmd.u.ctarg.rsp = NULL;
4439         }
4440
4441         sp->free(sp);
4442
4443         return rval;
4444 }
4445
4446 void qla_scan_work_fn(struct work_struct *work)
4447 {
4448         struct fab_scan *s = container_of(to_delayed_work(work),
4449             struct fab_scan, scan_work);
4450         struct scsi_qla_host *vha = container_of(s, struct scsi_qla_host,
4451             scan);
4452         unsigned long flags;
4453
4454         ql_dbg(ql_dbg_disc, vha, 0xffff,
4455             "%s: schedule loop resync\n", __func__);
4456         set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
4457         set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
4458         qla2xxx_wake_dpc(vha);
4459         spin_lock_irqsave(&vha->work_lock, flags);
4460         vha->scan.scan_flags &= ~SF_QUEUED;
4461         spin_unlock_irqrestore(&vha->work_lock, flags);
4462 }
4463
4464 /* GNN_ID */
4465 void qla24xx_handle_gnnid_event(scsi_qla_host_t *vha, struct event_arg *ea)
4466 {
4467         qla24xx_post_gnl_work(vha, ea->fcport);
4468 }
4469
4470 static void qla2x00_async_gnnid_sp_done(void *s, int res)
4471 {
4472         struct srb *sp = s;
4473         struct scsi_qla_host *vha = sp->vha;
4474         fc_port_t *fcport = sp->fcport;
4475         u8 *node_name = fcport->ct_desc.ct_sns->p.rsp.rsp.gnn_id.node_name;
4476         struct event_arg ea;
4477         u64 wwnn;
4478
4479         fcport->flags &= ~FCF_ASYNC_SENT;
4480         wwnn = wwn_to_u64(node_name);
4481         if (wwnn)
4482                 memcpy(fcport->node_name, node_name, WWN_SIZE);
4483
4484         memset(&ea, 0, sizeof(ea));
4485         ea.fcport = fcport;
4486         ea.sp = sp;
4487         ea.rc = res;
4488         ea.event = FCME_GNNID_DONE;
4489
4490         ql_dbg(ql_dbg_disc, vha, 0x204f,
4491             "Async done-%s res %x, WWPN %8phC %8phC\n",
4492             sp->name, res, fcport->port_name, fcport->node_name);
4493
4494         qla2x00_fcport_event_handler(vha, &ea);
4495
4496         sp->free(sp);
4497 }
4498
4499 int qla24xx_async_gnnid(scsi_qla_host_t *vha, fc_port_t *fcport)
4500 {
4501         int rval = QLA_FUNCTION_FAILED;
4502         struct ct_sns_req       *ct_req;
4503         srb_t *sp;
4504
4505         if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT))
4506                 return rval;
4507
4508         fcport->disc_state = DSC_GNN_ID;
4509         sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
4510         if (!sp)
4511                 goto done;
4512
4513         fcport->flags |= FCF_ASYNC_SENT;
4514         sp->type = SRB_CT_PTHRU_CMD;
4515         sp->name = "gnnid";
4516         sp->gen1 = fcport->rscn_gen;
4517         sp->gen2 = fcport->login_gen;
4518
4519         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
4520         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
4521
4522         /* CT_IU preamble  */
4523         ct_req = qla2x00_prep_ct_req(fcport->ct_desc.ct_sns, GNN_ID_CMD,
4524             GNN_ID_RSP_SIZE);
4525
4526         /* GNN_ID req */
4527         ct_req->req.port_id.port_id[0] = fcport->d_id.b.domain;
4528         ct_req->req.port_id.port_id[1] = fcport->d_id.b.area;
4529         ct_req->req.port_id.port_id[2] = fcport->d_id.b.al_pa;
4530
4531
4532         /* req & rsp use the same buffer */
4533         sp->u.iocb_cmd.u.ctarg.req = fcport->ct_desc.ct_sns;
4534         sp->u.iocb_cmd.u.ctarg.req_dma = fcport->ct_desc.ct_sns_dma;
4535         sp->u.iocb_cmd.u.ctarg.rsp = fcport->ct_desc.ct_sns;
4536         sp->u.iocb_cmd.u.ctarg.rsp_dma = fcport->ct_desc.ct_sns_dma;
4537         sp->u.iocb_cmd.u.ctarg.req_size = GNN_ID_REQ_SIZE;
4538         sp->u.iocb_cmd.u.ctarg.rsp_size = GNN_ID_RSP_SIZE;
4539         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
4540
4541         sp->done = qla2x00_async_gnnid_sp_done;
4542
4543         rval = qla2x00_start_sp(sp);
4544         if (rval != QLA_SUCCESS)
4545                 goto done_free_sp;
4546         ql_dbg(ql_dbg_disc, vha, 0xffff,
4547             "Async-%s - %8phC hdl=%x loopid=%x portid %06x.\n",
4548             sp->name, fcport->port_name,
4549             sp->handle, fcport->loop_id, fcport->d_id.b24);
4550         return rval;
4551
4552 done_free_sp:
4553         sp->free(sp);
4554 done:
4555         return rval;
4556 }
4557
4558 int qla24xx_post_gnnid_work(struct scsi_qla_host *vha, fc_port_t *fcport)
4559 {
4560         struct qla_work_evt *e;
4561         int ls;
4562
4563         ls = atomic_read(&vha->loop_state);
4564         if (((ls != LOOP_READY) && (ls != LOOP_UP)) ||
4565                 test_bit(UNLOADING, &vha->dpc_flags))
4566                 return 0;
4567
4568         e = qla2x00_alloc_work(vha, QLA_EVT_GNNID);
4569         if (!e)
4570                 return QLA_FUNCTION_FAILED;
4571
4572         e->u.fcport.fcport = fcport;
4573         return qla2x00_post_work(vha, e);
4574 }
4575
4576 /* GPFN_ID */
4577 void qla24xx_handle_gfpnid_event(scsi_qla_host_t *vha, struct event_arg *ea)
4578 {
4579         fc_port_t *fcport = ea->fcport;
4580
4581         ql_dbg(ql_dbg_disc, vha, 0xffff,
4582             "%s %8phC DS %d LS %d rc %d login %d|%d rscn %d|%d fcpcnt %d\n",
4583             __func__, fcport->port_name, fcport->disc_state,
4584             fcport->fw_login_state, ea->rc, fcport->login_gen, ea->sp->gen2,
4585             fcport->rscn_gen, ea->sp->gen1, vha->fcport_count);
4586
4587         if (fcport->disc_state == DSC_DELETE_PEND)
4588                 return;
4589
4590         if (ea->sp->gen2 != fcport->login_gen) {
4591                 /* target side must have changed it. */
4592                 ql_dbg(ql_dbg_disc, vha, 0x20d3,
4593                     "%s %8phC generation changed\n",
4594                     __func__, fcport->port_name);
4595                 return;
4596         } else if (ea->sp->gen1 != fcport->rscn_gen) {
4597                 ql_dbg(ql_dbg_disc, vha, 0x20d4, "%s %d %8phC post gidpn\n",
4598                     __func__, __LINE__, fcport->port_name);
4599                 qla24xx_post_gidpn_work(vha, fcport);
4600                 return;
4601         }
4602
4603         qla24xx_post_gpsc_work(vha, fcport);
4604 }
4605
4606 static void qla2x00_async_gfpnid_sp_done(void *s, int res)
4607 {
4608         struct srb *sp = s;
4609         struct scsi_qla_host *vha = sp->vha;
4610         fc_port_t *fcport = sp->fcport;
4611         u8 *fpn = fcport->ct_desc.ct_sns->p.rsp.rsp.gfpn_id.port_name;
4612         struct event_arg ea;
4613         u64 wwn;
4614
4615         wwn = wwn_to_u64(fpn);
4616         if (wwn)
4617                 memcpy(fcport->fabric_port_name, fpn, WWN_SIZE);
4618
4619         memset(&ea, 0, sizeof(ea));
4620         ea.fcport = fcport;
4621         ea.sp = sp;
4622         ea.rc = res;
4623         ea.event = FCME_GFPNID_DONE;
4624
4625         ql_dbg(ql_dbg_disc, vha, 0x204f,
4626             "Async done-%s res %x, WWPN %8phC %8phC\n",
4627             sp->name, res, fcport->port_name, fcport->fabric_port_name);
4628
4629         qla2x00_fcport_event_handler(vha, &ea);
4630
4631         sp->free(sp);
4632 }
4633
4634 int qla24xx_async_gfpnid(scsi_qla_host_t *vha, fc_port_t *fcport)
4635 {
4636         int rval = QLA_FUNCTION_FAILED;
4637         struct ct_sns_req       *ct_req;
4638         srb_t *sp;
4639
4640         if (!vha->flags.online || (fcport->flags & FCF_ASYNC_SENT))
4641                 return rval;
4642
4643         sp = qla2x00_get_sp(vha, fcport, GFP_ATOMIC);
4644         if (!sp)
4645                 goto done;
4646
4647         sp->type = SRB_CT_PTHRU_CMD;
4648         sp->name = "gfpnid";
4649         sp->gen1 = fcport->rscn_gen;
4650         sp->gen2 = fcport->login_gen;
4651
4652         sp->u.iocb_cmd.timeout = qla2x00_async_iocb_timeout;
4653         qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
4654
4655         /* CT_IU preamble  */
4656         ct_req = qla2x00_prep_ct_req(fcport->ct_desc.ct_sns, GFPN_ID_CMD,
4657             GFPN_ID_RSP_SIZE);
4658
4659         /* GFPN_ID req */
4660         ct_req->req.port_id.port_id[0] = fcport->d_id.b.domain;
4661         ct_req->req.port_id.port_id[1] = fcport->d_id.b.area;
4662         ct_req->req.port_id.port_id[2] = fcport->d_id.b.al_pa;
4663
4664
4665         /* req & rsp use the same buffer */
4666         sp->u.iocb_cmd.u.ctarg.req = fcport->ct_desc.ct_sns;
4667         sp->u.iocb_cmd.u.ctarg.req_dma = fcport->ct_desc.ct_sns_dma;
4668         sp->u.iocb_cmd.u.ctarg.rsp = fcport->ct_desc.ct_sns;
4669         sp->u.iocb_cmd.u.ctarg.rsp_dma = fcport->ct_desc.ct_sns_dma;
4670         sp->u.iocb_cmd.u.ctarg.req_size = GFPN_ID_REQ_SIZE;
4671         sp->u.iocb_cmd.u.ctarg.rsp_size = GFPN_ID_RSP_SIZE;
4672         sp->u.iocb_cmd.u.ctarg.nport_handle = NPH_SNS;
4673
4674         sp->done = qla2x00_async_gfpnid_sp_done;
4675
4676         rval = qla2x00_start_sp(sp);
4677         if (rval != QLA_SUCCESS)
4678                 goto done_free_sp;
4679
4680         ql_dbg(ql_dbg_disc, vha, 0xffff,
4681             "Async-%s - %8phC hdl=%x loopid=%x portid %06x.\n",
4682             sp->name, fcport->port_name,
4683             sp->handle, fcport->loop_id, fcport->d_id.b24);
4684         return rval;
4685
4686 done_free_sp:
4687         sp->free(sp);
4688         fcport->flags &= ~FCF_ASYNC_SENT;
4689 done:
4690         return rval;
4691 }
4692
4693 int qla24xx_post_gfpnid_work(struct scsi_qla_host *vha, fc_port_t *fcport)
4694 {
4695         struct qla_work_evt *e;
4696         int ls;
4697
4698         ls = atomic_read(&vha->loop_state);
4699         if (((ls != LOOP_READY) && (ls != LOOP_UP)) ||
4700                 test_bit(UNLOADING, &vha->dpc_flags))
4701                 return 0;
4702
4703         e = qla2x00_alloc_work(vha, QLA_EVT_GFPNID);
4704         if (!e)
4705                 return QLA_FUNCTION_FAILED;
4706
4707         e->u.fcport.fcport = fcport;
4708         return qla2x00_post_work(vha, e);
4709 }