drivers/scsi/qla2xxx/qla_gs.c

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