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