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