drivers/scsi/qla2xxx/qla_gs.c

   1 /*
   2  *                  QLOGIC LINUX SOFTWARE
   3  *
   4  * QLogic ISP2x00 device driver for Linux 2.6.x
   5  * Copyright (C) 2003-2004 QLogic Corporation
   6  * (www.qlogic.com)
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; either version 2, or (at your option) any
  11  * later version.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  */
  19 #include "qla_def.h"
  20
  21 static inline ms_iocb_entry_t *
  22 qla2x00_prep_ms_iocb(scsi_qla_host_t *, uint32_t, uint32_t);
  23
  24 static inline struct ct_sns_req *
  25 qla2x00_prep_ct_req(struct ct_sns_req *, uint16_t, uint16_t);
  26
  27 static inline struct sns_cmd_pkt *
  28 qla2x00_prep_sns_cmd(scsi_qla_host_t *, uint16_t, uint16_t, uint16_t);
  29
  30 static int qla2x00_sns_ga_nxt(scsi_qla_host_t *, fc_port_t *);
  31 static int qla2x00_sns_gid_pt(scsi_qla_host_t *, sw_info_t *);
  32 static int qla2x00_sns_gpn_id(scsi_qla_host_t *, sw_info_t *);
  33 static int qla2x00_sns_gnn_id(scsi_qla_host_t *, sw_info_t *);
  34 static int qla2x00_sns_rft_id(scsi_qla_host_t *);
  35 static int qla2x00_sns_rnn_id(scsi_qla_host_t *);
  36
  37 /**
  38  * qla2x00_prep_ms_iocb() - Prepare common MS IOCB fields for SNS CT query.
  39  * @ha: HA context
  40  * @req_size: request size in bytes
  41  * @rsp_size: response size in bytes
  42  *
  43  * Returns a pointer to the @ha's ms_iocb.
  44  */
  45 static inline ms_iocb_entry_t *
  46 qla2x00_prep_ms_iocb(scsi_qla_host_t *ha, uint32_t req_size, uint32_t rsp_size)
  47 {
  48         ms_iocb_entry_t *ms_pkt;
  49
  50         ms_pkt = ha->ms_iocb;
  51         memset(ms_pkt, 0, sizeof(ms_iocb_entry_t));
  52
  53         ms_pkt->entry_type = MS_IOCB_TYPE;
  54         ms_pkt->entry_count = 1;
  55         SET_TARGET_ID(ha, ms_pkt->loop_id, SIMPLE_NAME_SERVER);
  56         ms_pkt->control_flags = __constant_cpu_to_le16(CF_READ | CF_HEAD_TAG);
  57         ms_pkt->timeout = __constant_cpu_to_le16(25);
  58         ms_pkt->cmd_dsd_count = __constant_cpu_to_le16(1);
  59         ms_pkt->total_dsd_count = __constant_cpu_to_le16(2);
  60         ms_pkt->rsp_bytecount = cpu_to_le32(rsp_size);
  61         ms_pkt->req_bytecount = cpu_to_le32(req_size);
  62
  63         ms_pkt->dseg_req_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma));
  64         ms_pkt->dseg_req_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma));
  65         ms_pkt->dseg_req_length = ms_pkt->req_bytecount;
  66
  67         ms_pkt->dseg_rsp_address[0] = cpu_to_le32(LSD(ha->ct_sns_dma));
  68         ms_pkt->dseg_rsp_address[1] = cpu_to_le32(MSD(ha->ct_sns_dma));
  69         ms_pkt->dseg_rsp_length = ms_pkt->rsp_bytecount;
  70
  71         return (ms_pkt);
  72 }
  73
  74 /**
  75  * qla2x00_prep_ct_req() - Prepare common CT request fields for SNS query.
  76  * @ct_req: CT request buffer
  77  * @cmd: GS command
  78  * @rsp_size: response size in bytes
  79  *
  80  * Returns a pointer to the intitialized @ct_req.
  81  */
  82 static inline struct ct_sns_req *
  83 qla2x00_prep_ct_req(struct ct_sns_req *ct_req, uint16_t cmd, uint16_t rsp_size)
  84 {
  85         memset(ct_req, 0, sizeof(struct ct_sns_pkt));
  86
  87         ct_req->header.revision = 0x01;
  88         ct_req->header.gs_type = 0xFC;
  89         ct_req->header.gs_subtype = 0x02;
  90         ct_req->command = cpu_to_be16(cmd);
  91         ct_req->max_rsp_size = cpu_to_be16((rsp_size - 16) / 4);
  92
  93         return (ct_req);
  94 }
  95
  96
  97 /**
  98  * qla2x00_ga_nxt() - SNS scan for fabric devices via GA_NXT command.
  99  * @ha: HA context
 100  * @fcport: fcport entry to updated
 101  *
 102  * Returns 0 on success.
 103  */
 104 int
 105 qla2x00_ga_nxt(scsi_qla_host_t *ha, fc_port_t *fcport)
 106 {
 107         int             rval;
 108
 109         ms_iocb_entry_t *ms_pkt;
 110         struct ct_sns_req       *ct_req;
 111         struct ct_sns_rsp       *ct_rsp;
 112
 113         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
 114                 return (qla2x00_sns_ga_nxt(ha, fcport));
 115         }
 116
 117         /* Issue GA_NXT */
 118         /* Prepare common MS IOCB */
 119         ms_pkt = qla2x00_prep_ms_iocb(ha, GA_NXT_REQ_SIZE, GA_NXT_RSP_SIZE);
 120
 121         /* Prepare CT request */
 122         ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, GA_NXT_CMD,
 123             GA_NXT_RSP_SIZE);
 124         ct_rsp = &ha->ct_sns->p.rsp;
 125
 126         /* Prepare CT arguments -- port_id */
 127         ct_req->req.port_id.port_id[0] = fcport->d_id.b.domain;
 128         ct_req->req.port_id.port_id[1] = fcport->d_id.b.area;
 129         ct_req->req.port_id.port_id[2] = fcport->d_id.b.al_pa;
 130
 131         /* Execute MS IOCB */
 132         rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
 133             sizeof(ms_iocb_entry_t));
 134         if (rval != QLA_SUCCESS) {
 135                 /*EMPTY*/
 136                 DEBUG2_3(printk("scsi(%ld): GA_NXT issue IOCB failed (%d).\n",
 137                     ha->host_no, rval));
 138         } else if (ct_rsp->header.response !=
 139             __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) {
 140                 DEBUG2_3(printk("scsi(%ld): GA_NXT failed, rejected request, "
 141                     "ga_nxt_rsp:\n", ha->host_no));
 142                 DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header,
 143                     sizeof(struct ct_rsp_hdr)));
 144                 rval = QLA_FUNCTION_FAILED;
 145         } else {
 146                 /* Populate fc_port_t entry. */
 147                 fcport->d_id.b.domain = ct_rsp->rsp.ga_nxt.port_id[0];
 148                 fcport->d_id.b.area = ct_rsp->rsp.ga_nxt.port_id[1];
 149                 fcport->d_id.b.al_pa = ct_rsp->rsp.ga_nxt.port_id[2];
 150
 151                 memcpy(fcport->node_name, ct_rsp->rsp.ga_nxt.node_name,
 152                     WWN_SIZE);
 153                 memcpy(fcport->port_name, ct_rsp->rsp.ga_nxt.port_name,
 154                     WWN_SIZE);
 155
 156                 if (ct_rsp->rsp.ga_nxt.port_type != NS_N_PORT_TYPE &&
 157                     ct_rsp->rsp.ga_nxt.port_type != NS_NL_PORT_TYPE)
 158                         fcport->d_id.b.domain = 0xf0;
 159
 160                 DEBUG2_3(printk("scsi(%ld): GA_NXT entry - "
 161                     "nn %02x%02x%02x%02x%02x%02x%02x%02x "
 162                     "pn %02x%02x%02x%02x%02x%02x%02x%02x "
 163                     "portid=%02x%02x%02x.\n",
 164                     ha->host_no,
 165                     fcport->node_name[0], fcport->node_name[1],
 166                     fcport->node_name[2], fcport->node_name[3],
 167                     fcport->node_name[4], fcport->node_name[5],
 168                     fcport->node_name[6], fcport->node_name[7],
 169                     fcport->port_name[0], fcport->port_name[1],
 170                     fcport->port_name[2], fcport->port_name[3],
 171                     fcport->port_name[4], fcport->port_name[5],
 172                     fcport->port_name[6], fcport->port_name[7],
 173                     fcport->d_id.b.domain, fcport->d_id.b.area,
 174                     fcport->d_id.b.al_pa));
 175         }
 176
 177         return (rval);
 178 }
 179
 180 /**
 181  * qla2x00_gid_pt() - SNS scan for fabric devices via GID_PT command.
 182  * @ha: HA context
 183  * @list: switch info entries to populate
 184  *
 185  * NOTE: Non-Nx_Ports are not requested.
 186  *
 187  * Returns 0 on success.
 188  */
 189 int
 190 qla2x00_gid_pt(scsi_qla_host_t *ha, sw_info_t *list)
 191 {
 192         int             rval;
 193         uint16_t        i;
 194
 195         ms_iocb_entry_t *ms_pkt;
 196         struct ct_sns_req       *ct_req;
 197         struct ct_sns_rsp       *ct_rsp;
 198
 199         struct ct_sns_gid_pt_data *gid_data;
 200
 201         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
 202                 return (qla2x00_sns_gid_pt(ha, list));
 203         }
 204
 205         gid_data = NULL;
 206
 207         /* Issue GID_PT */
 208         /* Prepare common MS IOCB */
 209         ms_pkt = qla2x00_prep_ms_iocb(ha, GID_PT_REQ_SIZE, GID_PT_RSP_SIZE);
 210
 211         /* Prepare CT request */
 212         ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, GID_PT_CMD,
 213             GID_PT_RSP_SIZE);
 214         ct_rsp = &ha->ct_sns->p.rsp;
 215
 216         /* Prepare CT arguments -- port_type */
 217         ct_req->req.gid_pt.port_type = NS_NX_PORT_TYPE;
 218
 219         /* Execute MS IOCB */
 220         rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
 221             sizeof(ms_iocb_entry_t));
 222         if (rval != QLA_SUCCESS) {
 223                 /*EMPTY*/
 224                 DEBUG2_3(printk("scsi(%ld): GID_PT issue IOCB failed (%d).\n",
 225                     ha->host_no, rval));
 226         } else if (ct_rsp->header.response !=
 227             __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) {
 228                 DEBUG2_3(printk("scsi(%ld): GID_PT failed, rejected request, "
 229                     "gid_pt_rsp:\n", ha->host_no));
 230                 DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header,
 231                     sizeof(struct ct_rsp_hdr)));
 232                 rval = QLA_FUNCTION_FAILED;
 233         } else {
 234                 /* Set port IDs in switch info list. */
 235                 for (i = 0; i < MAX_FIBRE_DEVICES; i++) {
 236                         gid_data = &ct_rsp->rsp.gid_pt.entries[i];
 237                         list[i].d_id.b.domain = gid_data->port_id[0];
 238                         list[i].d_id.b.area = gid_data->port_id[1];
 239                         list[i].d_id.b.al_pa = gid_data->port_id[2];
 240
 241                         /* Last one exit. */
 242                         if (gid_data->control_byte & BIT_7) {
 243                                 list[i].d_id.b.rsvd_1 = gid_data->control_byte;
 244                                 break;
 245                         }
 246                 }
 247
 248                 /*
 249                  * If we've used all available slots, then the switch is
 250                  * reporting back more devices than we can handle with this
 251                  * single call.  Return a failed status, and let GA_NXT handle
 252                  * the overload.
 253                  */
 254                 if (i == MAX_FIBRE_DEVICES)
 255                         rval = QLA_FUNCTION_FAILED;
 256         }
 257
 258         return (rval);
 259 }
 260
 261 /**
 262  * qla2x00_gpn_id() - SNS Get Port Name (GPN_ID) query.
 263  * @ha: HA context
 264  * @list: switch info entries to populate
 265  *
 266  * Returns 0 on success.
 267  */
 268 int
 269 qla2x00_gpn_id(scsi_qla_host_t *ha, sw_info_t *list)
 270 {
 271         int             rval;
 272         uint16_t        i;
 273
 274         ms_iocb_entry_t *ms_pkt;
 275         struct ct_sns_req       *ct_req;
 276         struct ct_sns_rsp       *ct_rsp;
 277
 278         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
 279                 return (qla2x00_sns_gpn_id(ha, list));
 280         }
 281
 282         for (i = 0; i < MAX_FIBRE_DEVICES; i++) {
 283                 /* Issue GPN_ID */
 284                 /* Prepare common MS IOCB */
 285                 ms_pkt = qla2x00_prep_ms_iocb(ha, GPN_ID_REQ_SIZE,
 286                     GPN_ID_RSP_SIZE);
 287
 288                 /* Prepare CT request */
 289                 ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, GPN_ID_CMD,
 290                     GPN_ID_RSP_SIZE);
 291                 ct_rsp = &ha->ct_sns->p.rsp;
 292
 293                 /* Prepare CT arguments -- port_id */
 294                 ct_req->req.port_id.port_id[0] = list[i].d_id.b.domain;
 295                 ct_req->req.port_id.port_id[1] = list[i].d_id.b.area;
 296                 ct_req->req.port_id.port_id[2] = list[i].d_id.b.al_pa;
 297
 298                 /* Execute MS IOCB */
 299                 rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
 300                     sizeof(ms_iocb_entry_t));
 301                 if (rval != QLA_SUCCESS) {
 302                         /*EMPTY*/
 303                         DEBUG2_3(printk("scsi(%ld): GPN_ID issue IOCB failed "
 304                             "(%d).\n", ha->host_no, rval));
 305                 } else if (ct_rsp->header.response !=
 306                     __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) {
 307                         DEBUG2_3(printk("scsi(%ld): GPN_ID failed, rejected "
 308                             "request, gpn_id_rsp:\n", ha->host_no));
 309                         DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header,
 310                             sizeof(struct ct_rsp_hdr)));
 311                         rval = QLA_FUNCTION_FAILED;
 312                 } else {
 313                         /* Save portname */
 314                         memcpy(list[i].port_name,
 315                             ct_rsp->rsp.gpn_id.port_name, WWN_SIZE);
 316                 }
 317
 318                 /* Last device exit. */
 319                 if (list[i].d_id.b.rsvd_1 != 0)
 320                         break;
 321         }
 322
 323         return (rval);
 324 }
 325
 326 /**
 327  * qla2x00_gnn_id() - SNS Get Node Name (GNN_ID) query.
 328  * @ha: HA context
 329  * @list: switch info entries to populate
 330  *
 331  * Returns 0 on success.
 332  */
 333 int
 334 qla2x00_gnn_id(scsi_qla_host_t *ha, sw_info_t *list)
 335 {
 336         int             rval;
 337         uint16_t        i;
 338
 339         ms_iocb_entry_t *ms_pkt;
 340         struct ct_sns_req       *ct_req;
 341         struct ct_sns_rsp       *ct_rsp;
 342
 343         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
 344                 return (qla2x00_sns_gnn_id(ha, list));
 345         }
 346
 347         for (i = 0; i < MAX_FIBRE_DEVICES; i++) {
 348                 /* Issue GNN_ID */
 349                 /* Prepare common MS IOCB */
 350                 ms_pkt = qla2x00_prep_ms_iocb(ha, GNN_ID_REQ_SIZE,
 351                     GNN_ID_RSP_SIZE);
 352
 353                 /* Prepare CT request */
 354                 ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, GNN_ID_CMD,
 355                     GNN_ID_RSP_SIZE);
 356                 ct_rsp = &ha->ct_sns->p.rsp;
 357
 358                 /* Prepare CT arguments -- port_id */
 359                 ct_req->req.port_id.port_id[0] = list[i].d_id.b.domain;
 360                 ct_req->req.port_id.port_id[1] = list[i].d_id.b.area;
 361                 ct_req->req.port_id.port_id[2] = list[i].d_id.b.al_pa;
 362
 363                 /* Execute MS IOCB */
 364                 rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
 365                     sizeof(ms_iocb_entry_t));
 366                 if (rval != QLA_SUCCESS) {
 367                         /*EMPTY*/
 368                         DEBUG2_3(printk("scsi(%ld): GNN_ID issue IOCB failed "
 369                             "(%d).\n", ha->host_no, rval));
 370                 } else if (ct_rsp->header.response !=
 371                     __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) {
 372                         DEBUG2_3(printk("scsi(%ld): GNN_ID failed, rejected "
 373                             "request, gnn_id_rsp:\n", ha->host_no));
 374                         DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header,
 375                             sizeof(struct ct_rsp_hdr)));
 376                         rval = QLA_FUNCTION_FAILED;
 377                 } else {
 378                         /* Save nodename */
 379                         memcpy(list[i].node_name,
 380                             ct_rsp->rsp.gnn_id.node_name, WWN_SIZE);
 381
 382                         DEBUG2_3(printk("scsi(%ld): GID_PT entry - "
 383                             "nn %02x%02x%02x%02x%02x%02x%02x%02x "
 384                             "pn %02x%02x%02x%02x%02x%02x%02x%02x "
 385                             "portid=%02x%02x%02x.\n",
 386                             ha->host_no,
 387                             list[i].node_name[0], list[i].node_name[1],
 388                             list[i].node_name[2], list[i].node_name[3],
 389                             list[i].node_name[4], list[i].node_name[5],
 390                             list[i].node_name[6], list[i].node_name[7],
 391                             list[i].port_name[0], list[i].port_name[1],
 392                             list[i].port_name[2], list[i].port_name[3],
 393                             list[i].port_name[4], list[i].port_name[5],
 394                             list[i].port_name[6], list[i].port_name[7],
 395                             list[i].d_id.b.domain, list[i].d_id.b.area,
 396                             list[i].d_id.b.al_pa));
 397                 }
 398
 399                 /* Last device exit. */
 400                 if (list[i].d_id.b.rsvd_1 != 0)
 401                         break;
 402         }
 403
 404         return (rval);
 405 }
 406
 407 /**
 408  * qla2x00_rft_id() - SNS Register FC-4 TYPEs (RFT_ID) supported by the HBA.
 409  * @ha: HA context
 410  *
 411  * Returns 0 on success.
 412  */
 413 int
 414 qla2x00_rft_id(scsi_qla_host_t *ha)
 415 {
 416         int             rval;
 417
 418         ms_iocb_entry_t *ms_pkt;
 419         struct ct_sns_req       *ct_req;
 420         struct ct_sns_rsp       *ct_rsp;
 421
 422         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
 423                 return (qla2x00_sns_rft_id(ha));
 424         }
 425
 426         /* Issue RFT_ID */
 427         /* Prepare common MS IOCB */
 428         ms_pkt = qla2x00_prep_ms_iocb(ha, RFT_ID_REQ_SIZE, RFT_ID_RSP_SIZE);
 429
 430         /* Prepare CT request */
 431         ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, RFT_ID_CMD,
 432             RFT_ID_RSP_SIZE);
 433         ct_rsp = &ha->ct_sns->p.rsp;
 434
 435         /* Prepare CT arguments -- port_id, FC-4 types */
 436         ct_req->req.rft_id.port_id[0] = ha->d_id.b.domain;
 437         ct_req->req.rft_id.port_id[1] = ha->d_id.b.area;
 438         ct_req->req.rft_id.port_id[2] = ha->d_id.b.al_pa;
 439
 440         ct_req->req.rft_id.fc4_types[2] = 0x01;         /* FCP-3 */
 441
 442         /* Execute MS IOCB */
 443         rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
 444             sizeof(ms_iocb_entry_t));
 445         if (rval != QLA_SUCCESS) {
 446                 /*EMPTY*/
 447                 DEBUG2_3(printk("scsi(%ld): RFT_ID issue IOCB failed (%d).\n",
 448                     ha->host_no, rval));
 449         } else if (ct_rsp->header.response !=
 450             __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) {
 451                 DEBUG2_3(printk("scsi(%ld): RFT_ID failed, rejected "
 452                     "request, rft_id_rsp:\n", ha->host_no));
 453                 DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header,
 454                     sizeof(struct ct_rsp_hdr)));
 455                 rval = QLA_FUNCTION_FAILED;
 456         } else {
 457                 DEBUG2(printk("scsi(%ld): RFT_ID exiting normally.\n",
 458                     ha->host_no));
 459         }
 460
 461         return (rval);
 462 }
 463
 464 /**
 465  * qla2x00_rff_id() - SNS Register FC-4 Features (RFF_ID) supported by the HBA.
 466  * @ha: HA context
 467  *
 468  * Returns 0 on success.
 469  */
 470 int
 471 qla2x00_rff_id(scsi_qla_host_t *ha)
 472 {
 473         int             rval;
 474
 475         ms_iocb_entry_t *ms_pkt;
 476         struct ct_sns_req       *ct_req;
 477         struct ct_sns_rsp       *ct_rsp;
 478
 479         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
 480                 DEBUG2(printk("scsi(%ld): RFF_ID call unsupported on "
 481                     "ISP2100/ISP2200.\n", ha->host_no));
 482                 return (QLA_SUCCESS);
 483         }
 484
 485         /* Issue RFF_ID */
 486         /* Prepare common MS IOCB */
 487         ms_pkt = qla2x00_prep_ms_iocb(ha, RFF_ID_REQ_SIZE, RFF_ID_RSP_SIZE);
 488
 489         /* Prepare CT request */
 490         ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, RFF_ID_CMD,
 491             RFF_ID_RSP_SIZE);
 492         ct_rsp = &ha->ct_sns->p.rsp;
 493
 494         /* Prepare CT arguments -- port_id, FC-4 feature, FC-4 type */
 495         ct_req->req.rff_id.port_id[0] = ha->d_id.b.domain;
 496         ct_req->req.rff_id.port_id[1] = ha->d_id.b.area;
 497         ct_req->req.rff_id.port_id[2] = ha->d_id.b.al_pa;
 498
 499         ct_req->req.rff_id.fc4_type = 0x08;             /* SCSI - FCP */
 500
 501         /* Execute MS IOCB */
 502         rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
 503             sizeof(ms_iocb_entry_t));
 504         if (rval != QLA_SUCCESS) {
 505                 /*EMPTY*/
 506                 DEBUG2_3(printk("scsi(%ld): RFF_ID issue IOCB failed (%d).\n",
 507                     ha->host_no, rval));
 508         } else if (ct_rsp->header.response !=
 509             __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) {
 510                 DEBUG2_3(printk("scsi(%ld): RFF_ID failed, rejected "
 511                     "request, rff_id_rsp:\n", ha->host_no));
 512                 DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header,
 513                     sizeof(struct ct_rsp_hdr)));
 514                 rval = QLA_FUNCTION_FAILED;
 515         } else {
 516                 DEBUG2(printk("scsi(%ld): RFF_ID exiting normally.\n",
 517                     ha->host_no));
 518         }
 519
 520         return (rval);
 521 }
 522
 523 /**
 524  * qla2x00_rnn_id() - SNS Register Node Name (RNN_ID) of the HBA.
 525  * @ha: HA context
 526  *
 527  * Returns 0 on success.
 528  */
 529 int
 530 qla2x00_rnn_id(scsi_qla_host_t *ha)
 531 {
 532         int             rval;
 533
 534         ms_iocb_entry_t *ms_pkt;
 535         struct ct_sns_req       *ct_req;
 536         struct ct_sns_rsp       *ct_rsp;
 537
 538         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
 539                 return (qla2x00_sns_rnn_id(ha));
 540         }
 541
 542         /* Issue RNN_ID */
 543         /* Prepare common MS IOCB */
 544         ms_pkt = qla2x00_prep_ms_iocb(ha, RNN_ID_REQ_SIZE, RNN_ID_RSP_SIZE);
 545
 546         /* Prepare CT request */
 547         ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, RNN_ID_CMD,
 548             RNN_ID_RSP_SIZE);
 549         ct_rsp = &ha->ct_sns->p.rsp;
 550
 551         /* Prepare CT arguments -- port_id, node_name */
 552         ct_req->req.rnn_id.port_id[0] = ha->d_id.b.domain;
 553         ct_req->req.rnn_id.port_id[1] = ha->d_id.b.area;
 554         ct_req->req.rnn_id.port_id[2] = ha->d_id.b.al_pa;
 555
 556         memcpy(ct_req->req.rnn_id.node_name, ha->init_cb->node_name, WWN_SIZE);
 557
 558         /* Execute MS IOCB */
 559         rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
 560             sizeof(ms_iocb_entry_t));
 561         if (rval != QLA_SUCCESS) {
 562                 /*EMPTY*/
 563                 DEBUG2_3(printk("scsi(%ld): RNN_ID issue IOCB failed (%d).\n",
 564                     ha->host_no, rval));
 565         } else if (ct_rsp->header.response !=
 566             __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) {
 567                 DEBUG2_3(printk("scsi(%ld): RNN_ID failed, rejected "
 568                     "request, rnn_id_rsp:\n", ha->host_no));
 569                 DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header,
 570                     sizeof(struct ct_rsp_hdr)));
 571                 rval = QLA_FUNCTION_FAILED;
 572         } else {
 573                 DEBUG2(printk("scsi(%ld): RNN_ID exiting normally.\n",
 574                     ha->host_no));
 575         }
 576
 577         return (rval);
 578 }
 579
 580 /**
 581  * qla2x00_rsnn_nn() - SNS Register Symbolic Node Name (RSNN_NN) of the HBA.
 582  * @ha: HA context
 583  *
 584  * Returns 0 on success.
 585  */
 586 int
 587 qla2x00_rsnn_nn(scsi_qla_host_t *ha)
 588 {
 589         int             rval;
 590         uint8_t         *snn;
 591         uint8_t         version[20];
 592
 593         ms_iocb_entry_t *ms_pkt;
 594         struct ct_sns_req       *ct_req;
 595         struct ct_sns_rsp       *ct_rsp;
 596
 597         if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
 598                 DEBUG2(printk("scsi(%ld): RSNN_ID call unsupported on "
 599                     "ISP2100/ISP2200.\n", ha->host_no));
 600                 return (QLA_SUCCESS);
 601         }
 602
 603         /* Issue RSNN_NN */
 604         /* Prepare common MS IOCB */
 605         /*   Request size adjusted after CT preparation */
 606         ms_pkt = qla2x00_prep_ms_iocb(ha, 0, RSNN_NN_RSP_SIZE);
 607
 608         /* Prepare CT request */
 609         ct_req = qla2x00_prep_ct_req(&ha->ct_sns->p.req, RSNN_NN_CMD,
 610             RSNN_NN_RSP_SIZE);
 611         ct_rsp = &ha->ct_sns->p.rsp;
 612
 613         /* Prepare CT arguments -- node_name, symbolic node_name, size */
 614         memcpy(ct_req->req.rsnn_nn.node_name, ha->init_cb->node_name, WWN_SIZE);
 615
 616         /* Prepare the Symbolic Node Name */
 617         /* Board type */
 618         snn = ct_req->req.rsnn_nn.sym_node_name;
 619         strcpy(snn, ha->model_number);
 620         /* Firmware version */
 621         strcat(snn, " FW:v");
 622         sprintf(version, "%d.%02d.%02d", ha->fw_major_version,
 623             ha->fw_minor_version, ha->fw_subminor_version);
 624         strcat(snn, version);
 625         /* Driver version */
 626         strcat(snn, " DVR:v");
 627         strcat(snn, qla2x00_version_str);
 628
 629         /* Calculate SNN length */
 630         ct_req->req.rsnn_nn.name_len = (uint8_t)strlen(snn);
 631
 632         /* Update MS IOCB request */
 633         ms_pkt->req_bytecount =
 634             cpu_to_le32(24 + 1 + ct_req->req.rsnn_nn.name_len);
 635         ms_pkt->dseg_req_length = ms_pkt->req_bytecount;
 636
 637         /* Execute MS IOCB */
 638         rval = qla2x00_issue_iocb(ha, ha->ms_iocb, ha->ms_iocb_dma,
 639             sizeof(ms_iocb_entry_t));
 640         if (rval != QLA_SUCCESS) {
 641                 /*EMPTY*/
 642                 DEBUG2_3(printk("scsi(%ld): RSNN_NN issue IOCB failed (%d).\n",
 643                     ha->host_no, rval));
 644         } else if (ct_rsp->header.response !=
 645             __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) {
 646                 DEBUG2_3(printk("scsi(%ld): RSNN_NN failed, rejected "
 647                     "request, rsnn_id_rsp:\n", ha->host_no));
 648                 DEBUG2_3(qla2x00_dump_buffer((uint8_t *)&ct_rsp->header,
 649                     sizeof(struct ct_rsp_hdr)));
 650                 rval = QLA_FUNCTION_FAILED;
 651         } else {
 652                 DEBUG2(printk("scsi(%ld): RSNN_NN exiting normally.\n",
 653                     ha->host_no));
 654         }
 655
 656         return (rval);
 657 }
 658
 659
 660 /**
 661  * qla2x00_prep_sns_cmd() - Prepare common SNS command request fields for query.
 662  * @ha: HA context
 663  * @cmd: GS command
 664  * @scmd_len: Subcommand length
 665  * @data_size: response size in bytes
 666  *
 667  * Returns a pointer to the @ha's sns_cmd.
 668  */
 669 static inline struct sns_cmd_pkt *
 670 qla2x00_prep_sns_cmd(scsi_qla_host_t *ha, uint16_t cmd, uint16_t scmd_len,
 671     uint16_t data_size)
 672 {
 673         uint16_t                wc;
 674         struct sns_cmd_pkt      *sns_cmd;
 675
 676         sns_cmd = ha->sns_cmd;
 677         memset(sns_cmd, 0, sizeof(struct sns_cmd_pkt));
 678         wc = data_size / 2;                     /* Size in 16bit words. */
 679         sns_cmd->p.cmd.buffer_length = cpu_to_le16(wc);
 680         sns_cmd->p.cmd.buffer_address[0] = cpu_to_le32(LSD(ha->sns_cmd_dma));
 681         sns_cmd->p.cmd.buffer_address[1] = cpu_to_le32(MSD(ha->sns_cmd_dma));
 682         sns_cmd->p.cmd.subcommand_length = cpu_to_le16(scmd_len);
 683         sns_cmd->p.cmd.subcommand = cpu_to_le16(cmd);
 684         wc = (data_size - 16) / 4;              /* Size in 32bit words. */
 685         sns_cmd->p.cmd.size = cpu_to_le16(wc);
 686
 687         return (sns_cmd);
 688 }
 689
 690 /**
 691  * qla2x00_sns_ga_nxt() - SNS scan for fabric devices via GA_NXT command.
 692  * @ha: HA context
 693  * @fcport: fcport entry to updated
 694  *
 695  * This command uses the old Exectute SNS Command mailbox routine.
 696  *
 697  * Returns 0 on success.
 698  */
 699 static int
 700 qla2x00_sns_ga_nxt(scsi_qla_host_t *ha, fc_port_t *fcport)
 701 {
 702         int             rval;
 703
 704         struct sns_cmd_pkt      *sns_cmd;
 705
 706         /* Issue GA_NXT. */
 707         /* Prepare SNS command request. */
 708         sns_cmd = qla2x00_prep_sns_cmd(ha, GA_NXT_CMD, GA_NXT_SNS_SCMD_LEN,
 709             GA_NXT_SNS_DATA_SIZE);
 710
 711         /* Prepare SNS command arguments -- port_id. */
 712         sns_cmd->p.cmd.param[0] = fcport->d_id.b.al_pa;
 713         sns_cmd->p.cmd.param[1] = fcport->d_id.b.area;
 714         sns_cmd->p.cmd.param[2] = fcport->d_id.b.domain;
 715
 716         /* Execute SNS command. */
 717         rval = qla2x00_send_sns(ha, ha->sns_cmd_dma, GA_NXT_SNS_CMD_SIZE / 2,
 718             sizeof(struct sns_cmd_pkt));
 719         if (rval != QLA_SUCCESS) {
 720                 /*EMPTY*/
 721                 DEBUG2_3(printk("scsi(%ld): GA_NXT Send SNS failed (%d).\n",
 722                     ha->host_no, rval));
 723         } else if (sns_cmd->p.gan_data[8] != 0x80 ||
 724             sns_cmd->p.gan_data[9] != 0x02) {
 725                 DEBUG2_3(printk("scsi(%ld): GA_NXT failed, rejected request, "
 726                     "ga_nxt_rsp:\n", ha->host_no));
 727                 DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gan_data, 16));
 728                 rval = QLA_FUNCTION_FAILED;
 729         } else {
 730                 /* Populate fc_port_t entry. */
 731                 fcport->d_id.b.domain = sns_cmd->p.gan_data[17];
 732                 fcport->d_id.b.area = sns_cmd->p.gan_data[18];
 733                 fcport->d_id.b.al_pa = sns_cmd->p.gan_data[19];
 734
 735                 memcpy(fcport->node_name, &sns_cmd->p.gan_data[284], WWN_SIZE);
 736                 memcpy(fcport->port_name, &sns_cmd->p.gan_data[20], WWN_SIZE);
 737
 738                 if (sns_cmd->p.gan_data[16] != NS_N_PORT_TYPE &&
 739                     sns_cmd->p.gan_data[16] != NS_NL_PORT_TYPE)
 740                         fcport->d_id.b.domain = 0xf0;
 741
 742                 DEBUG2_3(printk("scsi(%ld): GA_NXT entry - "
 743                     "nn %02x%02x%02x%02x%02x%02x%02x%02x "
 744                     "pn %02x%02x%02x%02x%02x%02x%02x%02x "
 745                     "portid=%02x%02x%02x.\n",
 746                     ha->host_no,
 747                     fcport->node_name[0], fcport->node_name[1],
 748                     fcport->node_name[2], fcport->node_name[3],
 749                     fcport->node_name[4], fcport->node_name[5],
 750                     fcport->node_name[6], fcport->node_name[7],
 751                     fcport->port_name[0], fcport->port_name[1],
 752                     fcport->port_name[2], fcport->port_name[3],
 753                     fcport->port_name[4], fcport->port_name[5],
 754                     fcport->port_name[6], fcport->port_name[7],
 755                     fcport->d_id.b.domain, fcport->d_id.b.area,
 756                     fcport->d_id.b.al_pa));
 757         }
 758
 759         return (rval);
 760 }
 761
 762 /**
 763  * qla2x00_sns_gid_pt() - SNS scan for fabric devices via GID_PT command.
 764  * @ha: HA context
 765  * @list: switch info entries to populate
 766  *
 767  * This command uses the old Exectute SNS Command mailbox routine.
 768  *
 769  * NOTE: Non-Nx_Ports are not requested.
 770  *
 771  * Returns 0 on success.
 772  */
 773 static int
 774 qla2x00_sns_gid_pt(scsi_qla_host_t *ha, sw_info_t *list)
 775 {
 776         int             rval;
 777
 778         uint16_t        i;
 779         uint8_t         *entry;
 780         struct sns_cmd_pkt      *sns_cmd;
 781
 782         /* Issue GID_PT. */
 783         /* Prepare SNS command request. */
 784         sns_cmd = qla2x00_prep_sns_cmd(ha, GID_PT_CMD, GID_PT_SNS_SCMD_LEN,
 785             GID_PT_SNS_DATA_SIZE);
 786
 787         /* Prepare SNS command arguments -- port_type. */
 788         sns_cmd->p.cmd.param[0] = NS_NX_PORT_TYPE;
 789
 790         /* Execute SNS command. */
 791         rval = qla2x00_send_sns(ha, ha->sns_cmd_dma, GID_PT_SNS_CMD_SIZE / 2,
 792             sizeof(struct sns_cmd_pkt));
 793         if (rval != QLA_SUCCESS) {
 794                 /*EMPTY*/
 795                 DEBUG2_3(printk("scsi(%ld): GID_PT Send SNS failed (%d).\n",
 796                     ha->host_no, rval));
 797         } else if (sns_cmd->p.gid_data[8] != 0x80 ||
 798             sns_cmd->p.gid_data[9] != 0x02) {
 799                 DEBUG2_3(printk("scsi(%ld): GID_PT failed, rejected request, "
 800                     "gid_rsp:\n", ha->host_no));
 801                 DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gid_data, 16));
 802                 rval = QLA_FUNCTION_FAILED;
 803         } else {
 804                 /* Set port IDs in switch info list. */
 805                 for (i = 0; i < MAX_FIBRE_DEVICES; i++) {
 806                         entry = &sns_cmd->p.gid_data[(i * 4) + 16];
 807                         list[i].d_id.b.domain = entry[1];
 808                         list[i].d_id.b.area = entry[2];
 809                         list[i].d_id.b.al_pa = entry[3];
 810
 811                         /* Last one exit. */
 812                         if (entry[0] & BIT_7) {
 813                                 list[i].d_id.b.rsvd_1 = entry[0];
 814                                 break;
 815                         }
 816                 }
 817
 818                 /*
 819                  * If we've used all available slots, then the switch is
 820                  * reporting back more devices that we can handle with this
 821                  * single call.  Return a failed status, and let GA_NXT handle
 822                  * the overload.
 823                  */
 824                 if (i == MAX_FIBRE_DEVICES)
 825                         rval = QLA_FUNCTION_FAILED;
 826         }
 827
 828         return (rval);
 829 }
 830
 831 /**
 832  * qla2x00_sns_gpn_id() - SNS Get Port Name (GPN_ID) query.
 833  * @ha: HA context
 834  * @list: switch info entries to populate
 835  *
 836  * This command uses the old Exectute SNS Command mailbox routine.
 837  *
 838  * Returns 0 on success.
 839  */
 840 static int
 841 qla2x00_sns_gpn_id(scsi_qla_host_t *ha, sw_info_t *list)
 842 {
 843         int             rval;
 844
 845         uint16_t        i;
 846         struct sns_cmd_pkt      *sns_cmd;
 847
 848         for (i = 0; i < MAX_FIBRE_DEVICES; i++) {
 849                 /* Issue GPN_ID */
 850                 /* Prepare SNS command request. */
 851                 sns_cmd = qla2x00_prep_sns_cmd(ha, GPN_ID_CMD,
 852                     GPN_ID_SNS_SCMD_LEN, GPN_ID_SNS_DATA_SIZE);
 853
 854                 /* Prepare SNS command arguments -- port_id. */
 855                 sns_cmd->p.cmd.param[0] = list[i].d_id.b.al_pa;
 856                 sns_cmd->p.cmd.param[1] = list[i].d_id.b.area;
 857                 sns_cmd->p.cmd.param[2] = list[i].d_id.b.domain;
 858
 859                 /* Execute SNS command. */
 860                 rval = qla2x00_send_sns(ha, ha->sns_cmd_dma,
 861                     GPN_ID_SNS_CMD_SIZE / 2, sizeof(struct sns_cmd_pkt));
 862                 if (rval != QLA_SUCCESS) {
 863                         /*EMPTY*/
 864                         DEBUG2_3(printk("scsi(%ld): GPN_ID Send SNS failed "
 865                             "(%d).\n", ha->host_no, rval));
 866                 } else if (sns_cmd->p.gpn_data[8] != 0x80 ||
 867                     sns_cmd->p.gpn_data[9] != 0x02) {
 868                         DEBUG2_3(printk("scsi(%ld): GPN_ID failed, rejected "
 869                             "request, gpn_rsp:\n", ha->host_no));
 870                         DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gpn_data, 16));
 871                         rval = QLA_FUNCTION_FAILED;
 872                 } else {
 873                         /* Save portname */
 874                         memcpy(list[i].port_name, &sns_cmd->p.gpn_data[16],
 875                             WWN_SIZE);
 876                 }
 877
 878                 /* Last device exit. */
 879                 if (list[i].d_id.b.rsvd_1 != 0)
 880                         break;
 881         }
 882
 883         return (rval);
 884 }
 885
 886 /**
 887  * qla2x00_sns_gnn_id() - SNS Get Node Name (GNN_ID) query.
 888  * @ha: HA context
 889  * @list: switch info entries to populate
 890  *
 891  * This command uses the old Exectute SNS Command mailbox routine.
 892  *
 893  * Returns 0 on success.
 894  */
 895 static int
 896 qla2x00_sns_gnn_id(scsi_qla_host_t *ha, sw_info_t *list)
 897 {
 898         int             rval;
 899
 900         uint16_t        i;
 901         struct sns_cmd_pkt      *sns_cmd;
 902
 903         for (i = 0; i < MAX_FIBRE_DEVICES; i++) {
 904                 /* Issue GNN_ID */
 905                 /* Prepare SNS command request. */
 906                 sns_cmd = qla2x00_prep_sns_cmd(ha, GNN_ID_CMD,
 907                     GNN_ID_SNS_SCMD_LEN, GNN_ID_SNS_DATA_SIZE);
 908
 909                 /* Prepare SNS command arguments -- port_id. */
 910                 sns_cmd->p.cmd.param[0] = list[i].d_id.b.al_pa;
 911                 sns_cmd->p.cmd.param[1] = list[i].d_id.b.area;
 912                 sns_cmd->p.cmd.param[2] = list[i].d_id.b.domain;
 913
 914                 /* Execute SNS command. */
 915                 rval = qla2x00_send_sns(ha, ha->sns_cmd_dma,
 916                     GNN_ID_SNS_CMD_SIZE / 2, sizeof(struct sns_cmd_pkt));
 917                 if (rval != QLA_SUCCESS) {
 918                         /*EMPTY*/
 919                         DEBUG2_3(printk("scsi(%ld): GNN_ID Send SNS failed "
 920                             "(%d).\n", ha->host_no, rval));
 921                 } else if (sns_cmd->p.gnn_data[8] != 0x80 ||
 922                     sns_cmd->p.gnn_data[9] != 0x02) {
 923                         DEBUG2_3(printk("scsi(%ld): GNN_ID failed, rejected "
 924                             "request, gnn_rsp:\n", ha->host_no));
 925                         DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.gnn_data, 16));
 926                         rval = QLA_FUNCTION_FAILED;
 927                 } else {
 928                         /* Save nodename */
 929                         memcpy(list[i].node_name, &sns_cmd->p.gnn_data[16],
 930                             WWN_SIZE);
 931
 932                         DEBUG2_3(printk("scsi(%ld): GID_PT entry - "
 933                             "nn %02x%02x%02x%02x%02x%02x%02x%02x "
 934                             "pn %02x%02x%02x%02x%02x%02x%02x%02x "
 935                             "portid=%02x%02x%02x.\n",
 936                             ha->host_no,
 937                             list[i].node_name[0], list[i].node_name[1],
 938                             list[i].node_name[2], list[i].node_name[3],
 939                             list[i].node_name[4], list[i].node_name[5],
 940                             list[i].node_name[6], list[i].node_name[7],
 941                             list[i].port_name[0], list[i].port_name[1],
 942                             list[i].port_name[2], list[i].port_name[3],
 943                             list[i].port_name[4], list[i].port_name[5],
 944                             list[i].port_name[6], list[i].port_name[7],
 945                             list[i].d_id.b.domain, list[i].d_id.b.area,
 946                             list[i].d_id.b.al_pa));
 947                 }
 948
 949                 /* Last device exit. */
 950                 if (list[i].d_id.b.rsvd_1 != 0)
 951                         break;
 952         }
 953
 954         return (rval);
 955 }
 956
 957 /**
 958  * qla2x00_snd_rft_id() - SNS Register FC-4 TYPEs (RFT_ID) supported by the HBA.
 959  * @ha: HA context
 960  *
 961  * This command uses the old Exectute SNS Command mailbox routine.
 962  *
 963  * Returns 0 on success.
 964  */
 965 static int
 966 qla2x00_sns_rft_id(scsi_qla_host_t *ha)
 967 {
 968         int             rval;
 969
 970         struct sns_cmd_pkt      *sns_cmd;
 971
 972         /* Issue RFT_ID. */
 973         /* Prepare SNS command request. */
 974         sns_cmd = qla2x00_prep_sns_cmd(ha, RFT_ID_CMD, RFT_ID_SNS_SCMD_LEN,
 975             RFT_ID_SNS_DATA_SIZE);
 976
 977         /* Prepare SNS command arguments -- port_id, FC-4 types */
 978         sns_cmd->p.cmd.param[0] = ha->d_id.b.al_pa;
 979         sns_cmd->p.cmd.param[1] = ha->d_id.b.area;
 980         sns_cmd->p.cmd.param[2] = ha->d_id.b.domain;
 981
 982         sns_cmd->p.cmd.param[5] = 0x01;                 /* FCP-3 */
 983
 984         /* Execute SNS command. */
 985         rval = qla2x00_send_sns(ha, ha->sns_cmd_dma, RFT_ID_SNS_CMD_SIZE / 2,
 986             sizeof(struct sns_cmd_pkt));
 987         if (rval != QLA_SUCCESS) {
 988                 /*EMPTY*/
 989                 DEBUG2_3(printk("scsi(%ld): RFT_ID Send SNS failed (%d).\n",
 990                     ha->host_no, rval));
 991         } else if (sns_cmd->p.rft_data[8] != 0x80 ||
 992             sns_cmd->p.rft_data[9] != 0x02) {
 993                 DEBUG2_3(printk("scsi(%ld): RFT_ID failed, rejected request, "
 994                     "rft_rsp:\n", ha->host_no));
 995                 DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.rft_data, 16));
 996                 rval = QLA_FUNCTION_FAILED;
 997         } else {
 998                 DEBUG2(printk("scsi(%ld): RFT_ID exiting normally.\n",
 999                     ha->host_no));
1000         }
1001
1002         return (rval);
1003 }
1004
1005 /**
1006  * qla2x00_sns_rnn_id() - SNS Register Node Name (RNN_ID) of the HBA.
1007  * HBA.
1008  * @ha: HA context
1009  *
1010  * This command uses the old Exectute SNS Command mailbox routine.
1011  *
1012  * Returns 0 on success.
1013  */
1014 static int
1015 qla2x00_sns_rnn_id(scsi_qla_host_t *ha)
1016 {
1017         int             rval;
1018
1019         struct sns_cmd_pkt      *sns_cmd;
1020
1021         /* Issue RNN_ID. */
1022         /* Prepare SNS command request. */
1023         sns_cmd = qla2x00_prep_sns_cmd(ha, RNN_ID_CMD, RNN_ID_SNS_SCMD_LEN,
1024             RNN_ID_SNS_DATA_SIZE);
1025
1026         /* Prepare SNS command arguments -- port_id, nodename. */
1027         sns_cmd->p.cmd.param[0] = ha->d_id.b.al_pa;
1028         sns_cmd->p.cmd.param[1] = ha->d_id.b.area;
1029         sns_cmd->p.cmd.param[2] = ha->d_id.b.domain;
1030
1031         sns_cmd->p.cmd.param[4] = ha->init_cb->node_name[7];
1032         sns_cmd->p.cmd.param[5] = ha->init_cb->node_name[6];
1033         sns_cmd->p.cmd.param[6] = ha->init_cb->node_name[5];
1034         sns_cmd->p.cmd.param[7] = ha->init_cb->node_name[4];
1035         sns_cmd->p.cmd.param[8] = ha->init_cb->node_name[3];
1036         sns_cmd->p.cmd.param[9] = ha->init_cb->node_name[2];
1037         sns_cmd->p.cmd.param[10] = ha->init_cb->node_name[1];
1038         sns_cmd->p.cmd.param[11] = ha->init_cb->node_name[0];
1039
1040         /* Execute SNS command. */
1041         rval = qla2x00_send_sns(ha, ha->sns_cmd_dma, RNN_ID_SNS_CMD_SIZE / 2,
1042             sizeof(struct sns_cmd_pkt));
1043         if (rval != QLA_SUCCESS) {
1044                 /*EMPTY*/
1045                 DEBUG2_3(printk("scsi(%ld): RNN_ID Send SNS failed (%d).\n",
1046                     ha->host_no, rval));
1047         } else if (sns_cmd->p.rnn_data[8] != 0x80 ||
1048             sns_cmd->p.rnn_data[9] != 0x02) {
1049                 DEBUG2_3(printk("scsi(%ld): RNN_ID failed, rejected request, "
1050                     "rnn_rsp:\n", ha->host_no));
1051                 DEBUG2_3(qla2x00_dump_buffer(sns_cmd->p.rnn_data, 16));
1052                 rval = QLA_FUNCTION_FAILED;
1053         } else {
1054                 DEBUG2(printk("scsi(%ld): RNN_ID exiting normally.\n",
1055                     ha->host_no));
1056         }
1057
1058         return (rval);
1059 }