emlxs_els.c (e51761e0) emlxs_els.c (82527734)
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

--- 7 unchanged lines hidden (view full) ---

16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright 2009 Emulex. All rights reserved.
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

--- 7 unchanged lines hidden (view full) ---

16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright 2009 Emulex. All rights reserved.
24 * Use is subject to License terms.
24 * Use is subject to license terms.
25 */
26
25 */
26
27
27#include <emlxs.h>
28
29/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
30EMLXS_MSG_DEF(EMLXS_ELS_C);
31
32static void emlxs_handle_sol_flogi(emlxs_port_t *port, emlxs_buf_t *sbp);
33static void emlxs_handle_sol_fdisk(emlxs_port_t *port, emlxs_buf_t *sbp);
34static void emlxs_handle_sol_plogi(emlxs_port_t *port, emlxs_buf_t *sbp);
35static void emlxs_handle_sol_adisc(emlxs_port_t *port, emlxs_buf_t *sbp);
36static void emlxs_handle_sol_logo(emlxs_port_t *port, emlxs_buf_t *sbp);
37static void emlxs_handle_sol_prli(emlxs_port_t *port, emlxs_buf_t *sbp);
38
28#include <emlxs.h>
29
30/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
31EMLXS_MSG_DEF(EMLXS_ELS_C);
32
33static void emlxs_handle_sol_flogi(emlxs_port_t *port, emlxs_buf_t *sbp);
34static void emlxs_handle_sol_fdisk(emlxs_port_t *port, emlxs_buf_t *sbp);
35static void emlxs_handle_sol_plogi(emlxs_port_t *port, emlxs_buf_t *sbp);
36static void emlxs_handle_sol_adisc(emlxs_port_t *port, emlxs_buf_t *sbp);
37static void emlxs_handle_sol_logo(emlxs_port_t *port, emlxs_buf_t *sbp);
38static void emlxs_handle_sol_prli(emlxs_port_t *port, emlxs_buf_t *sbp);
39
39static void emlxs_handle_unsol_rscn(emlxs_port_t *port, RING *rp,
40static void emlxs_handle_unsol_rscn(emlxs_port_t *port, CHANNEL *cp,
40 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
41 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
41static void emlxs_handle_unsol_flogi(emlxs_port_t *port, RING *rp,
42static void emlxs_handle_unsol_flogi(emlxs_port_t *port, CHANNEL *cp,
42 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
43 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
43static void emlxs_handle_unsol_plogi(emlxs_port_t *port, RING *rp,
44static void emlxs_handle_unsol_plogi(emlxs_port_t *port, CHANNEL *cp,
44 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
45 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
45static void emlxs_handle_unsol_logo(emlxs_port_t *port, RING *rp,
46static void emlxs_handle_unsol_logo(emlxs_port_t *port, CHANNEL *cp,
46 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
47 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
47static void emlxs_handle_unsol_adisc(emlxs_port_t *port, RING *rp,
48static void emlxs_handle_unsol_adisc(emlxs_port_t *port, CHANNEL *cp,
48 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
49 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
49static void emlxs_handle_unsol_prli(emlxs_port_t *port, RING *rp,
50static void emlxs_handle_unsol_prli(emlxs_port_t *port, CHANNEL *cp,
50 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
51 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
51static void emlxs_handle_unsol_prlo(emlxs_port_t *port, RING *rp,
52static void emlxs_handle_unsol_prlo(emlxs_port_t *port, CHANNEL *cp,
52 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
53 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
53static void emlxs_handle_unsol_auth(emlxs_port_t *port, RING *rp,
54static void emlxs_handle_unsol_auth(emlxs_port_t *port, CHANNEL *cp,
54 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
55 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
55static void emlxs_handle_unsol_gen_cmd(emlxs_port_t *port, RING *rp,
56static void emlxs_handle_unsol_gen_cmd(emlxs_port_t *port, CHANNEL *cp,
56 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
57static void emlxs_handle_acc(emlxs_port_t *port, emlxs_buf_t *sbp,
58 IOCBQ *iocbq, uint32_t flag);
59static void emlxs_handle_reject(emlxs_port_t *port, emlxs_buf_t *sbp,
60 IOCBQ *iocbq, uint32_t flag);
61static void emlxs_send_rsnn(emlxs_port_t *port);
62
63

--- 4 unchanged lines hidden (view full) ---

68
69/*
70 * emlxs_els_handle_event
71 *
72 * Description: Process an ELS Response Ring cmpl
73 *
74 */
75extern int
57 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
58static void emlxs_handle_acc(emlxs_port_t *port, emlxs_buf_t *sbp,
59 IOCBQ *iocbq, uint32_t flag);
60static void emlxs_handle_reject(emlxs_port_t *port, emlxs_buf_t *sbp,
61 IOCBQ *iocbq, uint32_t flag);
62static void emlxs_send_rsnn(emlxs_port_t *port);
63
64

--- 4 unchanged lines hidden (view full) ---

69
70/*
71 * emlxs_els_handle_event
72 *
73 * Description: Process an ELS Response Ring cmpl
74 *
75 */
76extern int
76emlxs_els_handle_event(emlxs_hba_t *hba, RING *rp, IOCBQ *iocbq)
77emlxs_els_handle_event(emlxs_hba_t *hba, CHANNEL *cp, IOCBQ *iocbq)
77{
78 emlxs_port_t *port = &PPORT;
79 IOCB *iocb;
80 emlxs_buf_t *sbp;
81 fc_packet_t *pkt;
82 uint32_t *lp0;
83 uint32_t command;
84 NODELIST *ndlp;

--- 9 unchanged lines hidden (view full) ---

94 if (!sbp) {
95 /*
96 * completion with missing xmit command
97 */
98 HBASTATS.ElsStray++;
99
100 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_els_completion_msg,
101 "iocbq=%p cmd=0x%x iotag=0x%x status=0x%x perr=0x%x",
78{
79 emlxs_port_t *port = &PPORT;
80 IOCB *iocb;
81 emlxs_buf_t *sbp;
82 fc_packet_t *pkt;
83 uint32_t *lp0;
84 uint32_t command;
85 NODELIST *ndlp;

--- 9 unchanged lines hidden (view full) ---

95 if (!sbp) {
96 /*
97 * completion with missing xmit command
98 */
99 HBASTATS.ElsStray++;
100
101 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_els_completion_msg,
102 "iocbq=%p cmd=0x%x iotag=0x%x status=0x%x perr=0x%x",
102 iocbq, (uint32_t)iocb->ulpCommand,
103 (uint32_t)iocb->ulpIoTag, iocb->ulpStatus,
103 iocbq, (uint32_t)iocb->ULPCOMMAND,
104 (uint32_t)iocb->ULPIOTAG, iocb->ULPSTATUS,
104 iocb->un.ulpWord[4]);
105
106 return (1);
107 }
108
105 iocb->un.ulpWord[4]);
106
107 return (1);
108 }
109
109 if (rp->ringno != FC_ELS_RING) {
110 if (cp->channelno != hba->channel_els) {
110 HBASTATS.ElsStray++;
111
112 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_els_completion_msg,
111 HBASTATS.ElsStray++;
112
113 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_els_completion_msg,
113 "Not ELS ring: ring=%d iocbq=%p cmd=0x%x iotag=0x%x "
114 "status=0x%x perr=0x%x", rp->ringno, iocbq,
115 (uint32_t)iocb->ulpCommand, (uint32_t)iocb->ulpIoTag,
116 iocb->ulpStatus, iocb->un.ulpWord[4]);
114 "Not ELS channel: channel=%d iocbq=%p cmd=0x%x iotag=0x%x "
115 "status=0x%x perr=0x%x", cp->channelno, iocbq,
116 (uint32_t)iocb->ULPCOMMAND, (uint32_t)iocb->ULPIOTAG,
117 iocb->ULPSTATUS, iocb->un.ulpWord[4]);
117
118 return (1);
119 }
120
121 port = sbp->iocbq.port;
122 pkt = PRIV2PKT(sbp);
123 lp0 = (uint32_t *)pkt->pkt_cmd;
124 command = *lp0 & ELS_CMD_MASK;
118
119 return (1);
120 }
121
122 port = sbp->iocbq.port;
123 pkt = PRIV2PKT(sbp);
124 lp0 = (uint32_t *)pkt->pkt_cmd;
125 command = *lp0 & ELS_CMD_MASK;
125 did = SWAP_DATA24_LO(pkt->pkt_cmd_fhdr.d_id);
126 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
126
127 /* Check if a response buffer was provided */
128 if (pkt->pkt_rsplen) {
127
128 /* Check if a response buffer was provided */
129 if (pkt->pkt_rsplen) {
129 emlxs_mpdata_sync(pkt->pkt_resp_dma, 0, pkt->pkt_rsplen,
130 EMLXS_MPDATA_SYNC(pkt->pkt_resp_dma, 0, pkt->pkt_rsplen,
130 DDI_DMA_SYNC_FORKERNEL);
131 }
132
131 DDI_DMA_SYNC_FORKERNEL);
132 }
133
133 switch (iocb->ulpCommand) {
134 switch (iocb->ULPCOMMAND) {
134 /*
135 * ELS Reply completion
136 */
137 case CMD_XMIT_ELS_RSP_CX:
138 case CMD_XMIT_ELS_RSP64_CX:
139
140 HBASTATS.ElsRspCompleted++;
141

--- 21 unchanged lines hidden (view full) ---

163
164 pkt->pkt_resp_resid =
165 pkt->pkt_rsplen - iocb->un.elsreq64.bdl.bdeSize;
166 pkt->pkt_data_resid = pkt->pkt_datalen;
167
168 pkt->pkt_resp_fhdr.d_id = pkt->pkt_cmd_fhdr.s_id;
169 pkt->pkt_resp_fhdr.s_id = pkt->pkt_cmd_fhdr.d_id;
170
135 /*
136 * ELS Reply completion
137 */
138 case CMD_XMIT_ELS_RSP_CX:
139 case CMD_XMIT_ELS_RSP64_CX:
140
141 HBASTATS.ElsRspCompleted++;
142

--- 21 unchanged lines hidden (view full) ---

164
165 pkt->pkt_resp_resid =
166 pkt->pkt_rsplen - iocb->un.elsreq64.bdl.bdeSize;
167 pkt->pkt_data_resid = pkt->pkt_datalen;
168
169 pkt->pkt_resp_fhdr.d_id = pkt->pkt_cmd_fhdr.s_id;
170 pkt->pkt_resp_fhdr.s_id = pkt->pkt_cmd_fhdr.d_id;
171
171 if ((iocb->ulpStatus == 0) && (els->elsCode == 0x02)) {
172 if ((iocb->ULPSTATUS == 0) && (els->elsCode == 0x02)) {
172 HBASTATS.ElsCmdGood++;
173
174 if (!(sbp->pkt_flags & PACKET_ALLOCATED)) {
175 /*
176 * ULP patch - ULP expects
177 * resp_resid = 0 on success
178 */
179 pkt->pkt_resp_resid = 0;

--- 39 unchanged lines hidden (view full) ---

219
220 break;
221 }
222
223 } else {
224 HBASTATS.ElsCmdError++;
225
226 /* Look for LS_REJECT */
173 HBASTATS.ElsCmdGood++;
174
175 if (!(sbp->pkt_flags & PACKET_ALLOCATED)) {
176 /*
177 * ULP patch - ULP expects
178 * resp_resid = 0 on success
179 */
180 pkt->pkt_resp_resid = 0;

--- 39 unchanged lines hidden (view full) ---

220
221 break;
222 }
223
224 } else {
225 HBASTATS.ElsCmdError++;
226
227 /* Look for LS_REJECT */
227 if (iocb->ulpStatus == IOSTAT_LS_RJT) {
228 if (iocb->ULPSTATUS == IOSTAT_LS_RJT) {
228 pkt->pkt_state = FC_PKT_LS_RJT;
229 pkt->pkt_action = FC_ACTION_RETRYABLE;
230 pkt->pkt_reason = iocb->un.grsp.perr.statRsn;
231 pkt->pkt_expln = iocb->un.grsp.perr.statBaExp;
232 sbp->pkt_flags |= PACKET_STATE_VALID;
233
234#ifdef SAN_DIAG_SUPPORT
235 ndlp = emlxs_node_find_did(port, did);

--- 5 unchanged lines hidden (view full) ---

241 }
242#endif
243
244 EMLXS_MSGF(EMLXS_CONTEXT,
245 &emlxs_els_completion_msg,
246 "%s Rejected: did=%x rsn=%x exp=%x",
247 emlxs_elscmd_xlate(command), did,
248 pkt->pkt_reason, pkt->pkt_expln);
229 pkt->pkt_state = FC_PKT_LS_RJT;
230 pkt->pkt_action = FC_ACTION_RETRYABLE;
231 pkt->pkt_reason = iocb->un.grsp.perr.statRsn;
232 pkt->pkt_expln = iocb->un.grsp.perr.statBaExp;
233 sbp->pkt_flags |= PACKET_STATE_VALID;
234
235#ifdef SAN_DIAG_SUPPORT
236 ndlp = emlxs_node_find_did(port, did);

--- 5 unchanged lines hidden (view full) ---

242 }
243#endif
244
245 EMLXS_MSGF(EMLXS_CONTEXT,
246 &emlxs_els_completion_msg,
247 "%s Rejected: did=%x rsn=%x exp=%x",
248 emlxs_elscmd_xlate(command), did,
249 pkt->pkt_reason, pkt->pkt_expln);
249 } else if (iocb->ulpStatus == IOSTAT_LOCAL_REJECT) {
250 } else if (iocb->ULPSTATUS == IOSTAT_LOCAL_REJECT) {
250 EMLXS_MSGF(EMLXS_CONTEXT,
251 &emlxs_bad_els_completion_msg,
252 "%s: did=%x Local Reject. %s",
253 emlxs_elscmd_xlate(command), did,
254 emlxs_error_xlate(iocb->un.grsp.perr.
255 statLocalError));
256 } else {
257 EMLXS_MSGF(EMLXS_CONTEXT,
258 &emlxs_bad_els_completion_msg,
259 "%s: did=%x %s (%02x%02x%02x%02x)",
260 emlxs_elscmd_xlate(command), did,
251 EMLXS_MSGF(EMLXS_CONTEXT,
252 &emlxs_bad_els_completion_msg,
253 "%s: did=%x Local Reject. %s",
254 emlxs_elscmd_xlate(command), did,
255 emlxs_error_xlate(iocb->un.grsp.perr.
256 statLocalError));
257 } else {
258 EMLXS_MSGF(EMLXS_CONTEXT,
259 &emlxs_bad_els_completion_msg,
260 "%s: did=%x %s (%02x%02x%02x%02x)",
261 emlxs_elscmd_xlate(command), did,
261 emlxs_state_xlate(iocb->ulpStatus),
262 emlxs_state_xlate(iocb->ULPSTATUS),
262 iocb->un.grsp.perr.statAction,
263 iocb->un.grsp.perr.statRsn,
264 iocb->un.grsp.perr.statBaExp,
265 iocb->un.grsp.perr.statLocalError);
266 }
267
268 switch (command) {
269 case ELS_CMD_PLOGI: /* NPort login failed */
270 ndlp = emlxs_node_find_did(port, did);
271
272 if (ndlp && ndlp->nlp_active) {
273 /* Open the node again */
274 emlxs_node_open(port, ndlp,
263 iocb->un.grsp.perr.statAction,
264 iocb->un.grsp.perr.statRsn,
265 iocb->un.grsp.perr.statBaExp,
266 iocb->un.grsp.perr.statLocalError);
267 }
268
269 switch (command) {
270 case ELS_CMD_PLOGI: /* NPort login failed */
271 ndlp = emlxs_node_find_did(port, did);
272
273 if (ndlp && ndlp->nlp_active) {
274 /* Open the node again */
275 emlxs_node_open(port, ndlp,
275 FC_FCP_RING);
276 hba->channel_fcp);
276 emlxs_node_open(port, ndlp,
277 emlxs_node_open(port, ndlp,
277 FC_IP_RING);
278 hba->channel_ip);
278#ifdef DHCHAP_SUPPORT
279 if (pkt->pkt_state == FC_PKT_LS_RJT) {
280 emlxs_dhc_state(port, ndlp,
281 NODE_STATE_NOCHANGE,
282 pkt->pkt_reason,
283 pkt->pkt_expln);
284 }
285#endif /* DHCHAP_SUPPORT */
286 }
287
288 break;
289
290
291 case ELS_CMD_PRLI: /* Process Log In failed */
292 ndlp = emlxs_node_find_did(port, did);
293
294 if (ndlp && ndlp->nlp_active) {
295 /* Open the node again */
296 emlxs_node_open(port, ndlp,
279#ifdef DHCHAP_SUPPORT
280 if (pkt->pkt_state == FC_PKT_LS_RJT) {
281 emlxs_dhc_state(port, ndlp,
282 NODE_STATE_NOCHANGE,
283 pkt->pkt_reason,
284 pkt->pkt_expln);
285 }
286#endif /* DHCHAP_SUPPORT */
287 }
288
289 break;
290
291
292 case ELS_CMD_PRLI: /* Process Log In failed */
293 ndlp = emlxs_node_find_did(port, did);
294
295 if (ndlp && ndlp->nlp_active) {
296 /* Open the node again */
297 emlxs_node_open(port, ndlp,
297 FC_FCP_RING);
298 hba->channel_fcp);
298 }
299
300 break;
301
302 case ELS_CMD_FDISC: /* Fabric login */
303 case ELS_CMD_FLOGI: /* Fabric login */
304 if (pkt->pkt_state == FC_PKT_LS_RJT) {
305 /* This will cause ULP to retry */

--- 13 unchanged lines hidden (view full) ---

319 }
320
321 break;
322
323 default:
324 break;
325 }
326
299 }
300
301 break;
302
303 case ELS_CMD_FDISC: /* Fabric login */
304 case ELS_CMD_FLOGI: /* Fabric login */
305 if (pkt->pkt_state == FC_PKT_LS_RJT) {
306 /* This will cause ULP to retry */

--- 13 unchanged lines hidden (view full) ---

320 }
321
322 break;
323
324 default:
325 break;
326 }
327
327 emlxs_pkt_complete(sbp, iocb->ulpStatus,
328 emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
328 iocb->un.grsp.perr.statLocalError, 1);
329
330 }
331
332
333 break;
334
335 default:
336
337 HBASTATS.ElsStray++;
338
339 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_invalid_els_msg,
329 iocb->un.grsp.perr.statLocalError, 1);
330
331 }
332
333
334 break;
335
336 default:
337
338 HBASTATS.ElsStray++;
339
340 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_invalid_els_msg,
340 "Invalid iocb: cmd=0x%x", iocb->ulpCommand);
341 "Invalid iocb: cmd=0x%x", iocb->ULPCOMMAND);
341
342
342 emlxs_pkt_complete(sbp, iocb->ulpStatus,
343 emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
343 iocb->un.grsp.perr.statLocalError, 1);
344
345 break;
344 iocb->un.grsp.perr.statLocalError, 1);
345
346 break;
346 } /* switch(iocb->ulpCommand) */
347 } /* switch(iocb->ULPCOMMAND) */
347
348 return (0);
349
348
349 return (0);
350
350} /* emlxs_els_handle_event() */
351} /* emlxs_els_handle_event() */
351
352
353extern int
352
353
354extern int
354emlxs_els_handle_unsol_req(emlxs_port_t *port, RING *rp, IOCBQ *iocbq,
355emlxs_els_handle_unsol_req(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
355 MATCHMAP *mp, uint32_t size)
356{
357 emlxs_hba_t *hba = HBA;
358 uint32_t cmd_code;
359
360 HBASTATS.ElsCmdReceived++;
361
362 cmd_code = *((uint32_t *)mp->virt) & ELS_CMD_MASK;
363
356 MATCHMAP *mp, uint32_t size)
357{
358 emlxs_hba_t *hba = HBA;
359 uint32_t cmd_code;
360
361 HBASTATS.ElsCmdReceived++;
362
363 cmd_code = *((uint32_t *)mp->virt) & ELS_CMD_MASK;
364
365 if (!(port->flag & EMLXS_PORT_BOUND)) {
366 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_invalid_els_msg,
367 "ELS rcvd (0x%x): sid=%x Port not bound: Rejecting.",
368 cmd_code, iocbq->iocb.un.elsreq.remoteID);
369
370 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
371 ELS_CMD_RSCN, LSRJT_LOGICAL_BSY, LSEXP_OUT_OF_RESOURCE);
372
373 return (0);
374 }
375
364 switch (cmd_code) {
365 case ELS_CMD_RSCN:
366 HBASTATS.ElsRscnReceived++;
376 switch (cmd_code) {
377 case ELS_CMD_RSCN:
378 HBASTATS.ElsRscnReceived++;
367 emlxs_handle_unsol_rscn(port, rp, iocbq, mp, size);
379 emlxs_handle_unsol_rscn(port, cp, iocbq, mp, size);
368 break;
369
370 case ELS_CMD_FLOGI:
371 HBASTATS.ElsFlogiReceived++;
380 break;
381
382 case ELS_CMD_FLOGI:
383 HBASTATS.ElsFlogiReceived++;
372 emlxs_handle_unsol_flogi(port, rp, iocbq, mp, size);
384 emlxs_handle_unsol_flogi(port, cp, iocbq, mp, size);
373 break;
374
375 case ELS_CMD_PLOGI:
376 HBASTATS.ElsPlogiReceived++;
385 break;
386
387 case ELS_CMD_PLOGI:
388 HBASTATS.ElsPlogiReceived++;
377 emlxs_handle_unsol_plogi(port, rp, iocbq, mp, size);
389 emlxs_handle_unsol_plogi(port, cp, iocbq, mp, size);
378 break;
379
380 case ELS_CMD_PRLI:
381 HBASTATS.ElsPrliReceived++;
390 break;
391
392 case ELS_CMD_PRLI:
393 HBASTATS.ElsPrliReceived++;
382 emlxs_handle_unsol_prli(port, rp, iocbq, mp, size);
394 emlxs_handle_unsol_prli(port, cp, iocbq, mp, size);
383 break;
384
385 case ELS_CMD_PRLO:
386 HBASTATS.ElsPrloReceived++;
395 break;
396
397 case ELS_CMD_PRLO:
398 HBASTATS.ElsPrloReceived++;
387 emlxs_handle_unsol_prlo(port, rp, iocbq, mp, size);
399 emlxs_handle_unsol_prlo(port, cp, iocbq, mp, size);
388 break;
389
390 case ELS_CMD_LOGO:
391 HBASTATS.ElsLogoReceived++;
400 break;
401
402 case ELS_CMD_LOGO:
403 HBASTATS.ElsLogoReceived++;
392 emlxs_handle_unsol_logo(port, rp, iocbq, mp, size);
404 emlxs_handle_unsol_logo(port, cp, iocbq, mp, size);
393 break;
394
395 case ELS_CMD_ADISC:
396 HBASTATS.ElsAdiscReceived++;
405 break;
406
407 case ELS_CMD_ADISC:
408 HBASTATS.ElsAdiscReceived++;
397 emlxs_handle_unsol_adisc(port, rp, iocbq, mp, size);
409 emlxs_handle_unsol_adisc(port, cp, iocbq, mp, size);
398 break;
399
400 case ELS_CMD_AUTH:
401 HBASTATS.ElsAuthReceived++;
410 break;
411
412 case ELS_CMD_AUTH:
413 HBASTATS.ElsAuthReceived++;
402 emlxs_handle_unsol_auth(port, rp, iocbq, mp, size);
414 emlxs_handle_unsol_auth(port, cp, iocbq, mp, size);
403 break;
404
405 default:
406 HBASTATS.ElsGenReceived++;
415 break;
416
417 default:
418 HBASTATS.ElsGenReceived++;
407 emlxs_handle_unsol_gen_cmd(port, rp, iocbq, mp, size);
419 emlxs_handle_unsol_gen_cmd(port, cp, iocbq, mp, size);
408 break;
409 }
410
411 return (0);
412
420 break;
421 }
422
423 return (0);
424
413} /* emlxs_els_handle_unsol_req() */
425} /* emlxs_els_handle_unsol_req() */
414
415
416static void
417emlxs_handle_sol_flogi(emlxs_port_t *port, emlxs_buf_t *sbp)
418{
419 emlxs_hba_t *hba = HBA;
420 emlxs_config_t *cfg = &CFG;
421 emlxs_port_t *vport;
422 SERV_PARM *sp;
423 fc_packet_t *pkt;
424 MAILBOXQ *mbox;
425 uint32_t did;
426 IOCBQ *iocbq;
427 IOCB *iocb;
428 char buffer[64];
429 uint32_t i;
426
427
428static void
429emlxs_handle_sol_flogi(emlxs_port_t *port, emlxs_buf_t *sbp)
430{
431 emlxs_hba_t *hba = HBA;
432 emlxs_config_t *cfg = &CFG;
433 emlxs_port_t *vport;
434 SERV_PARM *sp;
435 fc_packet_t *pkt;
436 MAILBOXQ *mbox;
437 uint32_t did;
438 IOCBQ *iocbq;
439 IOCB *iocb;
440 char buffer[64];
441 uint32_t i;
442 int rc;
430
431 pkt = PRIV2PKT(sbp);
432 sp = (SERV_PARM *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
443
444 pkt = PRIV2PKT(sbp);
445 sp = (SERV_PARM *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
433 did = SWAP_DATA24_LO(pkt->pkt_cmd_fhdr.d_id);
446 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
434 iocbq = &sbp->iocbq;
435 iocb = &iocbq->iocb;
436
437 if (sp->cmn.fPort) {
438 mutex_enter(&EMLXS_PORT_LOCK);
439
440 hba->flag |= FC_FABRIC_ATTACHED;
441 hba->flag &= ~FC_PT_TO_PT;
442
443 /* Save our new port ID */
444 port->did = iocb->un.elsreq.myID;
447 iocbq = &sbp->iocbq;
448 iocb = &iocbq->iocb;
449
450 if (sp->cmn.fPort) {
451 mutex_enter(&EMLXS_PORT_LOCK);
452
453 hba->flag |= FC_FABRIC_ATTACHED;
454 hba->flag &= ~FC_PT_TO_PT;
455
456 /* Save our new port ID */
457 port->did = iocb->un.elsreq.myID;
445 pkt->pkt_resp_fhdr.s_id = SWAP_DATA24_LO(Fabric_DID);
446 pkt->pkt_resp_fhdr.d_id = SWAP_DATA24_LO(port->did);
458 pkt->pkt_resp_fhdr.s_id = LE_SWAP24_LO(FABRIC_DID);
459 pkt->pkt_resp_fhdr.d_id = LE_SWAP24_LO(port->did);
447
448 /* Save E_D_TOV ticks in nanoseconds */
449 if (sp->cmn.edtovResolution) {
450 hba->fc_edtov =
460
461 /* Save E_D_TOV ticks in nanoseconds */
462 if (sp->cmn.edtovResolution) {
463 hba->fc_edtov =
451 (SWAP_DATA32(sp->cmn.e_d_tov) + 999999) / 1000000;
464 (LE_SWAP32(sp->cmn.e_d_tov) + 999999) / 1000000;
452 } else {
465 } else {
453 hba->fc_edtov = SWAP_DATA32(sp->cmn.e_d_tov);
466 hba->fc_edtov = LE_SWAP32(sp->cmn.e_d_tov);
454 }
455
456 /* Save R_A_TOV ticks */
457 hba->fc_ratov =
467 }
468
469 /* Save R_A_TOV ticks */
470 hba->fc_ratov =
458 (SWAP_DATA32(sp->cmn.w2.r_a_tov) + 999) / 1000;
471 (LE_SWAP32(sp->cmn.w2.r_a_tov) + 999) / 1000;
459
460 if (hba->topology != TOPOLOGY_LOOP) {
461 /*
462 * If we are a N-port connected to a Fabric,
463 * fixup sparam's so logins to devices on remote
464 * loops work.
465 */
466 hba->sparam.cmn.altBbCredit = 1;

--- 4 unchanged lines hidden (view full) ---

471
472 if (!(vport->flag & EMLXS_PORT_BOUND)) {
473 continue;
474 }
475
476 vport->sparam.cmn.altBbCredit = 1;
477 }
478 }
472
473 if (hba->topology != TOPOLOGY_LOOP) {
474 /*
475 * If we are a N-port connected to a Fabric,
476 * fixup sparam's so logins to devices on remote
477 * loops work.
478 */
479 hba->sparam.cmn.altBbCredit = 1;

--- 4 unchanged lines hidden (view full) ---

484
485 if (!(vport->flag & EMLXS_PORT_BOUND)) {
486 continue;
487 }
488
489 vport->sparam.cmn.altBbCredit = 1;
490 }
491 }
479#ifdef NPIV_SUPPORT
492
480 if (sp->cmn.rspMultipleNPort) {
481 hba->flag |= FC_NPIV_SUPPORTED;
482
483 if (cfg[CFG_NPIV_DELAY].current) {
484 /*
485 * PATCH: for NPIV support on
486 * Brocade switch firmware 5.10b
487 */

--- 10 unchanged lines hidden (view full) ---

498
499 if (!(hba->flag & FC_NPIV_ENABLED)) {
500 (void) strcpy(buffer, "npiv:Disabled ");
501 } else if (hba->flag & FC_NPIV_SUPPORTED) {
502 (void) strcpy(buffer, "npiv:Supported ");
503 } else {
504 (void) strcpy(buffer, "npiv:Unsupported ");
505 }
493 if (sp->cmn.rspMultipleNPort) {
494 hba->flag |= FC_NPIV_SUPPORTED;
495
496 if (cfg[CFG_NPIV_DELAY].current) {
497 /*
498 * PATCH: for NPIV support on
499 * Brocade switch firmware 5.10b
500 */

--- 10 unchanged lines hidden (view full) ---

511
512 if (!(hba->flag & FC_NPIV_ENABLED)) {
513 (void) strcpy(buffer, "npiv:Disabled ");
514 } else if (hba->flag & FC_NPIV_SUPPORTED) {
515 (void) strcpy(buffer, "npiv:Supported ");
516 } else {
517 (void) strcpy(buffer, "npiv:Unsupported ");
518 }
506#else
507 buffer[0] = 0;
508#endif /* NPIV_SUPPORT */
509
519
510 /* Save the fabric service parameters */
511 bcopy((void *)sp, (void *)&port->fabric_sparam,
512 sizeof (SERV_PARM));
513
514#ifdef DHCHAP_SUPPORT
515 if (!sp->cmn.fcsp_support) {
516 (void) strcat(buffer, "fcsp:Unsupported");
517 } else if (cfg[CFG_AUTH_ENABLE].current &&
518 (port->vpi == 0 || cfg[CFG_AUTH_NPIV].current)) {
519 (void) strcat(buffer, "fcsp:Supported");
520 } else {
521 (void) strcat(buffer, "fcsp:Disabled");
522 }
523#endif /* DHCHAP_SUPPORT */
524
525 mutex_exit(&EMLXS_PORT_LOCK);
526
527 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
528 "FLOGI: did=%x sid=%x %s", did, port->did, buffer);
529
530 /* Update our service parms */
520#ifdef DHCHAP_SUPPORT
521 if (!sp->cmn.fcsp_support) {
522 (void) strcat(buffer, "fcsp:Unsupported");
523 } else if (cfg[CFG_AUTH_ENABLE].current &&
524 (port->vpi == 0 || cfg[CFG_AUTH_NPIV].current)) {
525 (void) strcat(buffer, "fcsp:Supported");
526 } else {
527 (void) strcat(buffer, "fcsp:Disabled");
528 }
529#endif /* DHCHAP_SUPPORT */
530
531 mutex_exit(&EMLXS_PORT_LOCK);
532
533 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
534 "FLOGI: did=%x sid=%x %s", did, port->did, buffer);
535
536 /* Update our service parms */
531 if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba,
532 MEM_MBOX | MEM_PRI))) {
533 emlxs_mb_config_link(hba, (MAILBOX *)mbox);
537 if (!(mbox = (MAILBOXQ *)emlxs_mem_get(hba,
538 MEM_MBOX, 1))) {
539 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
540 IOERR_NO_RESOURCES, 1);
541 return;
534
542
535 if (emlxs_sli_issue_mbox_cmd(hba, (MAILBOX *)mbox,
536 MBX_NOWAIT, 0) != MBX_BUSY) {
543 }
544
545 /* For SLI4 we replace CONFIG_LINK and REG_LOGIN of */
546 /* Fabric with a REG_VFI mailbox command. */
547 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
548 emlxs_port_t *vpip = sbp->port;
549 VFIobj_t *vfip;
550 FCFIobj_t *fcfp;
551 uint32_t regvfi;
552
553 vfip = vpip->VFIp;
554 fcfp = vfip->FCFIp;
555 regvfi = vfip->state & RESOURCE_VFI_REG;
556
557 /* Save the FCF service parameters */
558 bcopy((void *)sp, (void *)&fcfp->fcf_sparam,
559 sizeof (SERV_PARM));
560
561 if (emlxs_mb_check_sparm(hba, sp)) {
562 EMLXS_MSGF(EMLXS_CONTEXT,
563 &emlxs_node_create_failed_msg,
564 "Invalid Fabric parameters. did=%06x",
565 port->did);
537 (void) emlxs_mem_put(hba, MEM_MBOX,
538 (uint8_t *)mbox);
566 (void) emlxs_mem_put(hba, MEM_MBOX,
567 (uint8_t *)mbox);
568 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
569 IOERR_NO_RESOURCES, 1);
570 return;
539 }
540
571 }
572
573 if (!regvfi) {
574 if (emlxs_mb_reg_vfi(hba, mbox, vfip, vpip) ==
575 0) {
576 EMLXS_MSGF(EMLXS_CONTEXT,
577 &emlxs_sli_detail_msg,
578 "Cannot REG_VFI for FCF: sid=%x",
579 port->did);
580
581 (void) emlxs_mem_put(hba, MEM_MBOX,
582 (uint8_t *)mbox);
583 emlxs_pkt_complete(sbp,
584 IOSTAT_LOCAL_REJECT,
585 IOERR_NO_RESOURCES, 1);
586 return;
587 }
588 mbox->sbp = (uint8_t *)sbp;
589
590 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox,
591 MBX_NOWAIT, 0);
592 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
593 EMLXS_MSGF(EMLXS_CONTEXT,
594 &emlxs_sli_detail_msg,
595 "Cannot REG_VFI for FCF: sid=%x",
596 port->did);
597
598 (void) emlxs_mem_put(hba, MEM_MBOX,
599 (uint8_t *)mbox);
600 emlxs_pkt_complete(sbp,
601 IOSTAT_LOCAL_REJECT,
602 IOERR_NO_RESOURCES, 1);
603 return;
604 }
605 /* Preset the state for the REG_VFI cmpl */
606 emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);
607
608 /* Deferred completion of this pkt until */
609 /* REG_VFI is complete */
610 return;
611 }
612 /* VFI is already Registered */
613
614 (void) emlxs_mem_put(hba, MEM_MBOX, (uint8_t *)mbox);
615 emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);
616
617 EMLXS_STATE_CHANGE_LOCKED(hba, FC_READY);
618 if (regvfi) {
619 /*
620 * If NPIV Fabric support has just been
621 * established on the physical port, then
622 * notify the vports of the link up.
623 */
624 if ((hba->flag & FC_NPIV_ENABLED) &&
625 (hba->flag & FC_NPIV_SUPPORTED)) {
626 /* Skip the physical port */
627 for (i = 1; i < MAX_VPORTS; i++) {
628 vport = &VPORT(i);
629
630 if (!(vport->flag &
631 EMLXS_PORT_BOUND) ||
632 !(vport->flag &
633 EMLXS_PORT_ENABLE)) {
634 continue;
635 }
636
637 emlxs_port_online(vport);
638 }
639 }
640 }
641 return;
541 }
542
642 }
643
644 /* Save the fabric service parameters */
645 bcopy((void *)sp, (void *)&port->fabric_sparam,
646 sizeof (SERV_PARM));
647
648 emlxs_mb_config_link(hba, mbox);
649
650 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_NOWAIT, 0);
651 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
652 (void) emlxs_mem_put(hba, MEM_MBOX, (uint8_t *)mbox);
653 }
654
543 /* Preset the state for the reg_did */
544 emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);
545
655 /* Preset the state for the reg_did */
656 emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);
657
546 if (emlxs_mb_reg_did(port, Fabric_DID, &port->fabric_sparam,
658 if (emlxs_mb_reg_did(port, FABRIC_DID, &port->fabric_sparam,
547 sbp, NULL, NULL) == 0) {
548 /* Deferred completion of this pkt until */
549 /* login is complete */
550 return;
551 }
552
553 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
554 IOERR_NO_RESOURCES, 1);
555
556 } else { /* No switch */
557
558 mutex_enter(&EMLXS_PORT_LOCK);
559
560 hba->flag &= ~FC_FABRIC_ATTACHED;
561 hba->flag |= FC_PT_TO_PT;
562
563 /* Save E_D_TOV ticks in nanoseconds */
564 if (sp->cmn.edtovResolution) {
565 hba->fc_edtov =
659 sbp, NULL, NULL) == 0) {
660 /* Deferred completion of this pkt until */
661 /* login is complete */
662 return;
663 }
664
665 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
666 IOERR_NO_RESOURCES, 1);
667
668 } else { /* No switch */
669
670 mutex_enter(&EMLXS_PORT_LOCK);
671
672 hba->flag &= ~FC_FABRIC_ATTACHED;
673 hba->flag |= FC_PT_TO_PT;
674
675 /* Save E_D_TOV ticks in nanoseconds */
676 if (sp->cmn.edtovResolution) {
677 hba->fc_edtov =
566 (SWAP_DATA32(sp->cmn.e_d_tov) + 999999) / 1000000;
678 (LE_SWAP32(sp->cmn.e_d_tov) + 999999) / 1000000;
567 } else {
679 } else {
568 hba->fc_edtov = SWAP_DATA32(sp->cmn.e_d_tov);
680 hba->fc_edtov = LE_SWAP32(sp->cmn.e_d_tov);
569 }
570
571 /* Save R_A_TOV ticks */
572 hba->fc_ratov =
681 }
682
683 /* Save R_A_TOV ticks */
684 hba->fc_ratov =
573 (SWAP_DATA32(sp->cmn.w2.r_a_tov) + 999) / 1000;
685 (LE_SWAP32(sp->cmn.w2.r_a_tov) + 999) / 1000;
574
686
575#ifdef NPIV_SUPPORT
576 hba->flag &= ~FC_NPIV_SUPPORTED;
577 (void) strcpy(buffer, "npiv:Disabled. P2P");
687 hba->flag &= ~FC_NPIV_SUPPORTED;
688 (void) strcpy(buffer, "npiv:Disabled. P2P");
578#else
579 (void) strcpy(buffer, "P2P");
580#endif /* NPIV_SUPPORT */
581
689
690 port->rdid = did;
691
582 /* Clear the fabric service parameters */
583 bzero((void *)&port->fabric_sparam, sizeof (SERV_PARM));
584
585 mutex_exit(&EMLXS_PORT_LOCK);
586
587 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
588 "FLOGI: did=%x sid=%x %s", did, port->did, buffer);
589
590 emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);
591 }
592
593 return;
594
692 /* Clear the fabric service parameters */
693 bzero((void *)&port->fabric_sparam, sizeof (SERV_PARM));
694
695 mutex_exit(&EMLXS_PORT_LOCK);
696
697 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
698 "FLOGI: did=%x sid=%x %s", did, port->did, buffer);
699
700 emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);
701 }
702
703 return;
704
595} /* emlxs_handle_sol_flogi() */
705} /* emlxs_handle_sol_flogi() */
596
597
598static void
599emlxs_handle_sol_fdisk(emlxs_port_t *port, emlxs_buf_t *sbp)
600{
601 emlxs_hba_t *hba = HBA;
602 emlxs_config_t *cfg = &CFG;
603 SERV_PARM *sp;
604 fc_packet_t *pkt;
605 MAILBOXQ *mbox;
606 uint32_t did;
607 IOCBQ *iocbq;
608 IOCB *iocb;
609 char buffer[64];
706
707
708static void
709emlxs_handle_sol_fdisk(emlxs_port_t *port, emlxs_buf_t *sbp)
710{
711 emlxs_hba_t *hba = HBA;
712 emlxs_config_t *cfg = &CFG;
713 SERV_PARM *sp;
714 fc_packet_t *pkt;
715 MAILBOXQ *mbox;
716 uint32_t did;
717 IOCBQ *iocbq;
718 IOCB *iocb;
719 char buffer[64];
720 int rc;
610
611 pkt = PRIV2PKT(sbp);
612 sp = (SERV_PARM *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
721
722 pkt = PRIV2PKT(sbp);
723 sp = (SERV_PARM *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
613 did = SWAP_DATA24_LO(pkt->pkt_cmd_fhdr.d_id);
724 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
614 iocbq = &sbp->iocbq;
615 iocb = &iocbq->iocb;
616
617 mutex_enter(&EMLXS_PORT_LOCK);
618
619 /* Save our new port ID */
620 port->did = iocb->un.elsreq.myID;
725 iocbq = &sbp->iocbq;
726 iocb = &iocbq->iocb;
727
728 mutex_enter(&EMLXS_PORT_LOCK);
729
730 /* Save our new port ID */
731 port->did = iocb->un.elsreq.myID;
621 pkt->pkt_resp_fhdr.d_id = SWAP_DATA24_LO(port->did);
732 pkt->pkt_resp_fhdr.d_id = LE_SWAP24_LO(port->did);
622
623 /* Save the fabric service parameters */
624 bcopy((void *)sp, (void *)&port->fabric_sparam, sizeof (SERV_PARM));
625
626 mutex_exit(&EMLXS_PORT_LOCK);
627
628 buffer[0] = 0;
629

--- 5 unchanged lines hidden (view full) ---

635 } else {
636 (void) strcat(buffer, "fcsp:Disabled");
637 }
638#endif /* DHCHAP_SUPPORT */
639
640 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
641 "FDISK: did=%x sid=%x %s", did, port->did, buffer);
642
733
734 /* Save the fabric service parameters */
735 bcopy((void *)sp, (void *)&port->fabric_sparam, sizeof (SERV_PARM));
736
737 mutex_exit(&EMLXS_PORT_LOCK);
738
739 buffer[0] = 0;
740

--- 5 unchanged lines hidden (view full) ---

746 } else {
747 (void) strcat(buffer, "fcsp:Disabled");
748 }
749#endif /* DHCHAP_SUPPORT */
750
751 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
752 "FDISK: did=%x sid=%x %s", did, port->did, buffer);
753
754 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
755 emlxs_port_t *pport = &PPORT;
756
757 port->VFIp = pport->VFIp;
758
759 if (emlxs_mb_check_sparm(hba, sp)) {
760 EMLXS_MSGF(EMLXS_CONTEXT,
761 &emlxs_node_create_failed_msg,
762 "Invalid Fabric parameters. did=%06x",
763 port->did);
764 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
765 IOERR_NO_RESOURCES, 1);
766 return;
767 }
768
769 /* Preset the state for the REG_VFI cmpl */
770 emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);
771
772 if (port->flag & EMLXS_PORT_REG_VPI_CMPL) {
773 emlxs_pkt_complete(sbp, -1, 0, 1);
774 } else {
775 /* Deferred completion of this pkt until */
776 /* REG_VPI is complete */
777 (void) emlxs_mb_reg_vpi(port, sbp);
778 }
779
780 return;
781 }
782
643 /* Update our service parms */
783 /* Update our service parms */
644 if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba, MEM_MBOX | MEM_PRI))) {
645 emlxs_mb_config_link(hba, (MAILBOX *)mbox);
784 if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba, MEM_MBOX, 1))) {
785 emlxs_mb_config_link(hba, mbox);
646
786
647 if (emlxs_sli_issue_mbox_cmd(hba, (MAILBOX *)mbox, MBX_NOWAIT,
648 0) != MBX_BUSY) {
787 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox,
788 MBX_NOWAIT, 0);
789 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
649 (void) emlxs_mem_put(hba, MEM_MBOX, (uint8_t *)mbox);
650 }
790 (void) emlxs_mem_put(hba, MEM_MBOX, (uint8_t *)mbox);
791 }
651
652 }
653
654 /* Preset the state for the reg_did */
655 emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);
656
792 }
793
794 /* Preset the state for the reg_did */
795 emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);
796
657 if (emlxs_mb_reg_did(port, Fabric_DID, &port->fabric_sparam, sbp,
797 if (emlxs_mb_reg_did(port, FABRIC_DID, &port->fabric_sparam, sbp,
658 NULL, NULL) == 0) {
659 /*
660 * Deferred completion of this pkt until login is complete
661 */
662
663 return;
664 }
665
666 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT, IOERR_NO_RESOURCES, 1);
667
668 return;
669
798 NULL, NULL) == 0) {
799 /*
800 * Deferred completion of this pkt until login is complete
801 */
802
803 return;
804 }
805
806 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT, IOERR_NO_RESOURCES, 1);
807
808 return;
809
670} /* emlxs_handle_sol_fdisk() */
810} /* emlxs_handle_sol_fdisk() */
671
672
673static void
674emlxs_handle_sol_plogi(emlxs_port_t *port, emlxs_buf_t *sbp)
675{
676 emlxs_hba_t *hba = HBA;
677 emlxs_config_t *cfg = &CFG;
678 SERV_PARM *sp;
679 fc_packet_t *pkt;
680 uint32_t did;
681 uint32_t sid;
682 NODELIST *ndlp;
683 char buffer[64];
684
685 pkt = PRIV2PKT(sbp);
686 sp = (SERV_PARM *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
811
812
813static void
814emlxs_handle_sol_plogi(emlxs_port_t *port, emlxs_buf_t *sbp)
815{
816 emlxs_hba_t *hba = HBA;
817 emlxs_config_t *cfg = &CFG;
818 SERV_PARM *sp;
819 fc_packet_t *pkt;
820 uint32_t did;
821 uint32_t sid;
822 NODELIST *ndlp;
823 char buffer[64];
824
825 pkt = PRIV2PKT(sbp);
826 sp = (SERV_PARM *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
687 did = SWAP_DATA24_LO(pkt->pkt_cmd_fhdr.d_id);
688 sid = SWAP_DATA24_LO(pkt->pkt_cmd_fhdr.s_id);
827 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
828 sid = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.s_id);
689
690 buffer[0] = 0;
691
692#ifdef DHCHAP_SUPPORT
693 if (!sp->cmn.fcsp_support) {
694 (void) strcat(buffer, "fcsp:Unsupported");
695 } else if (cfg[CFG_AUTH_ENABLE].current && cfg[CFG_AUTH_E2E].current &&
696 (port->vpi == 0 || cfg[CFG_AUTH_NPIV].current)) {

--- 18 unchanged lines hidden (view full) ---

715 */
716 return;
717 }
718
719 ndlp = emlxs_node_find_did(port, did);
720
721 if (ndlp && ndlp->nlp_active) {
722 /* Open the node again */
829
830 buffer[0] = 0;
831
832#ifdef DHCHAP_SUPPORT
833 if (!sp->cmn.fcsp_support) {
834 (void) strcat(buffer, "fcsp:Unsupported");
835 } else if (cfg[CFG_AUTH_ENABLE].current && cfg[CFG_AUTH_E2E].current &&
836 (port->vpi == 0 || cfg[CFG_AUTH_NPIV].current)) {

--- 18 unchanged lines hidden (view full) ---

855 */
856 return;
857 }
858
859 ndlp = emlxs_node_find_did(port, did);
860
861 if (ndlp && ndlp->nlp_active) {
862 /* Open the node again */
723 emlxs_node_open(port, ndlp, FC_FCP_RING);
724 emlxs_node_open(port, ndlp, FC_IP_RING);
863 emlxs_node_open(port, ndlp, hba->channel_fcp);
864 emlxs_node_open(port, ndlp, hba->channel_ip);
725 }
726
727 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT, IOERR_NO_RESOURCES, 1);
728
729 return;
730
865 }
866
867 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT, IOERR_NO_RESOURCES, 1);
868
869 return;
870
731} /* emlxs_handle_sol_plogi() */
871} /* emlxs_handle_sol_plogi() */
732
733
734static void
735emlxs_handle_sol_adisc(emlxs_port_t *port, emlxs_buf_t *sbp)
736{
872
873
874static void
875emlxs_handle_sol_adisc(emlxs_port_t *port, emlxs_buf_t *sbp)
876{
877 emlxs_hba_t *hba = HBA;
737 fc_packet_t *pkt;
738 uint32_t did;
739 NODELIST *ndlp;
878 fc_packet_t *pkt;
879 uint32_t did;
880 NODELIST *ndlp;
881 RPIobj_t *rp;
740
741 pkt = PRIV2PKT(sbp);
882
883 pkt = PRIV2PKT(sbp);
742 did = SWAP_DATA24_LO(pkt->pkt_cmd_fhdr.d_id);
884 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
743
744 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg, "ADISC: did=%x",
745 did);
746
747 ndlp = emlxs_node_find_did(port, did);
748
749 if (ndlp && ndlp->nlp_active) {
750 /* Open the node again */
885
886 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg, "ADISC: did=%x",
887 did);
888
889 ndlp = emlxs_node_find_did(port, did);
890
891 if (ndlp && ndlp->nlp_active) {
892 /* Open the node again */
751 emlxs_node_open(port, ndlp, FC_FCP_RING);
752 emlxs_node_open(port, ndlp, FC_IP_RING);
893 emlxs_node_open(port, ndlp, hba->channel_fcp);
894 emlxs_node_open(port, ndlp, hba->channel_ip);
895
896 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
897 rp = emlxs_sli4_find_rpi(hba, ndlp->nlp_Rpi);
898 if (rp && (rp->state & RESOURCE_RPI_PAUSED)) {
899 (void) emlxs_mb_resume_rpi(hba, sbp,
900 ndlp->nlp_Rpi);
901 rp->state &= ~RESOURCE_RPI_PAUSED;
902 /*
903 * Delay ADISC cmpl to ULP till
904 * after RESUME_RPI
905 */
906 return;
907 }
908 }
753 }
754
755 emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);
756
757 return;
758
909 }
910
911 emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);
912
913 return;
914
759} /* emlxs_handle_sol_adisc() */
915} /* emlxs_handle_sol_adisc() */
760
761
762static void
763emlxs_handle_sol_prli(emlxs_port_t *port, emlxs_buf_t *sbp)
764{
765 emlxs_hba_t *hba = HBA;
766 emlxs_config_t *cfg = &CFG;
767 fc_packet_t *pkt;
768 NODELIST *ndlp;
769 uint32_t did;
770 PRLI *npr;
771 uint32_t task_retry_id;
772
773 pkt = PRIV2PKT(sbp);
774 npr = (PRLI *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
916
917
918static void
919emlxs_handle_sol_prli(emlxs_port_t *port, emlxs_buf_t *sbp)
920{
921 emlxs_hba_t *hba = HBA;
922 emlxs_config_t *cfg = &CFG;
923 fc_packet_t *pkt;
924 NODELIST *ndlp;
925 uint32_t did;
926 PRLI *npr;
927 uint32_t task_retry_id;
928
929 pkt = PRIV2PKT(sbp);
930 npr = (PRLI *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
775 did = SWAP_DATA24_LO(pkt->pkt_cmd_fhdr.d_id);
931 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
776
777 ndlp = emlxs_node_find_did(port, did);
778
779 if (ndlp && ndlp->nlp_active) {
780 /* Check for FCP support */
781 if ((npr->acceptRspCode == PRLI_REQ_EXECUTED) &&
782 (npr->prliType == PRLI_FCP_TYPE)) {
783 /* Check for target */

--- 23 unchanged lines hidden (view full) ---

807 if (npr->targetFunc && npr->Retry && task_retry_id) {
808 ndlp->nlp_fcp_info |= NLP_FCP_2_DEVICE;
809 } else {
810 ndlp->nlp_fcp_info &= ~NLP_FCP_2_DEVICE;
811 }
812 }
813
814 /* Open the node again */
932
933 ndlp = emlxs_node_find_did(port, did);
934
935 if (ndlp && ndlp->nlp_active) {
936 /* Check for FCP support */
937 if ((npr->acceptRspCode == PRLI_REQ_EXECUTED) &&
938 (npr->prliType == PRLI_FCP_TYPE)) {
939 /* Check for target */

--- 23 unchanged lines hidden (view full) ---

963 if (npr->targetFunc && npr->Retry && task_retry_id) {
964 ndlp->nlp_fcp_info |= NLP_FCP_2_DEVICE;
965 } else {
966 ndlp->nlp_fcp_info &= ~NLP_FCP_2_DEVICE;
967 }
968 }
969
970 /* Open the node again */
815 emlxs_node_open(port, ndlp, FC_FCP_RING);
971 emlxs_node_open(port, ndlp, hba->channel_fcp);
816
817 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
818 "PRLI: did=%x info=%02x", did, ndlp->nlp_fcp_info);
819
820 /*
821 * Report PRLI completion
822 */
823 emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);
824
825 } else {
826 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
827 "PRLI: did=%x: Node not found. Failing.", did);
828
829 /*
830 * Report PRLI failed
831 */
832 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
833 IOERR_INVALID_RPI, 1);
834 }
972
973 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
974 "PRLI: did=%x info=%02x", did, ndlp->nlp_fcp_info);
975
976 /*
977 * Report PRLI completion
978 */
979 emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);
980
981 } else {
982 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
983 "PRLI: did=%x: Node not found. Failing.", did);
984
985 /*
986 * Report PRLI failed
987 */
988 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
989 IOERR_INVALID_RPI, 1);
990 }
835
836 return;
837
991 return;
992
838} /* emlxs_handle_sol_prli() */
993} /* emlxs_handle_sol_prli() */
839
840
841static void
842emlxs_handle_sol_logo(emlxs_port_t *port, emlxs_buf_t *sbp)
843{
994
995
996static void
997emlxs_handle_sol_logo(emlxs_port_t *port, emlxs_buf_t *sbp)
998{
999 emlxs_hba_t *hba = HBA;
844 fc_packet_t *pkt;
845 uint32_t did;
846 NODELIST *ndlp;
847
848 pkt = PRIV2PKT(sbp);
1000 fc_packet_t *pkt;
1001 uint32_t did;
1002 NODELIST *ndlp;
1003
1004 pkt = PRIV2PKT(sbp);
849 did = SWAP_DATA24_LO(pkt->pkt_cmd_fhdr.d_id);
1005 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
850
851 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg, "LOGO: did=%x",
852 did);
853
854 ndlp = emlxs_node_find_did(port, did);
855
856 if (ndlp && ndlp->nlp_active) {
857 /* Close the node for any further normal IO */
1006
1007 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg, "LOGO: did=%x",
1008 did);
1009
1010 ndlp = emlxs_node_find_did(port, did);
1011
1012 if (ndlp && ndlp->nlp_active) {
1013 /* Close the node for any further normal IO */
858 emlxs_node_close(port, ndlp, FC_FCP_RING, 60);
859 emlxs_node_close(port, ndlp, FC_IP_RING, 60);
1014 emlxs_node_close(port, ndlp, hba->channel_fcp, 60);
1015 emlxs_node_close(port, ndlp, hba->channel_ip, 60);
860
861 /* Flush tx queues */
862 (void) emlxs_tx_node_flush(port, ndlp, 0, 0, 0);
863
864 /* Flush chip queues */
865 (void) emlxs_chipq_node_flush(port, 0, ndlp, 0);
866 }
867
868 emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);
869
870 return;
871
1016
1017 /* Flush tx queues */
1018 (void) emlxs_tx_node_flush(port, ndlp, 0, 0, 0);
1019
1020 /* Flush chip queues */
1021 (void) emlxs_chipq_node_flush(port, 0, ndlp, 0);
1022 }
1023
1024 emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);
1025
1026 return;
1027
872} /* emlxs_handle_sol_logo() */
1028} /* emlxs_handle_sol_logo() */
873
874
875/* ARGSUSED */
876static void
1029
1030
1031/* ARGSUSED */
1032static void
877emlxs_handle_unsol_rscn(emlxs_port_t *port, RING *rp, IOCBQ *iocbq,
1033emlxs_handle_unsol_rscn(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
878 MATCHMAP *mp, uint32_t size)
879{
880 uint32_t *lp;
881 fc_unsol_buf_t *ubp;
882 uint8_t *bp;
883 IOCB *iocb;
884 uint32_t count;
885 uint32_t sid;

--- 14 unchanged lines hidden (view full) ---

900
901 count = ((size - 4) / 4);
902
903 ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size, FC_ELS_DATA, 1);
904
905 if (ubp == NULL) {
906 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
907 "RSCN rcvd: sid=%x %d page(s): %08X, %08X. Rejecting.",
1034 MATCHMAP *mp, uint32_t size)
1035{
1036 uint32_t *lp;
1037 fc_unsol_buf_t *ubp;
1038 uint8_t *bp;
1039 IOCB *iocb;
1040 uint32_t count;
1041 uint32_t sid;

--- 14 unchanged lines hidden (view full) ---

1056
1057 count = ((size - 4) / 4);
1058
1059 ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size, FC_ELS_DATA, 1);
1060
1061 if (ubp == NULL) {
1062 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
1063 "RSCN rcvd: sid=%x %d page(s): %08X, %08X. Rejecting.",
908 sid, count, SWAP_DATA32(*lp),
909 ((count > 1) ? SWAP_DATA32(*(lp + 1)) : 0));
1064 sid, count, LE_SWAP32(*lp),
1065 ((count > 1) ? LE_SWAP32(*(lp + 1)) : 0));
910
911 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
912 ELS_CMD_RSCN, LSRJT_LOGICAL_BSY, LSEXP_OUT_OF_RESOURCE);
913
914 goto drop_it;
915 }
916
917 bcopy(bp, ubp->ub_buffer, size);
918 ub_priv = ubp->ub_fca_private;
919 ub_priv->cmd = ELS_CMD_RSCN;
920
921 /*
922 * Setup frame header
923 */
924 ubp->ub_frame.r_ctl = FC_ELS_REQ;
925 ubp->ub_frame.type = FC_ELS_DATA;
1066
1067 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
1068 ELS_CMD_RSCN, LSRJT_LOGICAL_BSY, LSEXP_OUT_OF_RESOURCE);
1069
1070 goto drop_it;
1071 }
1072
1073 bcopy(bp, ubp->ub_buffer, size);
1074 ub_priv = ubp->ub_fca_private;
1075 ub_priv->cmd = ELS_CMD_RSCN;
1076
1077 /*
1078 * Setup frame header
1079 */
1080 ubp->ub_frame.r_ctl = FC_ELS_REQ;
1081 ubp->ub_frame.type = FC_ELS_DATA;
926 ubp->ub_frame.s_id = SWAP_DATA24_LO(iocb->un.elsreq.remoteID);
927 ubp->ub_frame.d_id = SWAP_DATA24_LO(iocb->un.elsreq.myID);
1082 ubp->ub_frame.s_id = LE_SWAP24_LO(iocb->un.elsreq.remoteID);
1083 ubp->ub_frame.d_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
928 ubp->ub_frame.ox_id = ub_priv->token;
1084 ubp->ub_frame.ox_id = ub_priv->token;
929 ubp->ub_frame.rx_id = iocb->ulpContext;
1085 ubp->ub_frame.rx_id = iocb->ULPCONTEXT;
930 ubp->ub_class = FC_TRAN_CLASS3;
931
932 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
933 "RSCN: sid=%x %d page(s): %08X, %08X buffer=%p token=%x.", sid,
1086 ubp->ub_class = FC_TRAN_CLASS3;
1087
1088 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1089 "RSCN: sid=%x %d page(s): %08X, %08X buffer=%p token=%x.", sid,
934 count, SWAP_DATA32(*lp),
935 ((count > 1) ? SWAP_DATA32(*(lp + 1)) : 0), ubp, ub_priv->token);
1090 count, LE_SWAP32(*lp),
1091 ((count > 1) ? LE_SWAP32(*(lp + 1)) : 0), ubp, ub_priv->token);
936
937#if (EMLXS_MODREVX == EMLXS_MODREV2X)
938 emlxs_swap_els_ub(ubp);
939#endif /* EMLXS_MODREV2X */
940
941 emlxs_ub_callback(port, ubp);
942
943drop_it:
944
945 return;
946
1092
1093#if (EMLXS_MODREVX == EMLXS_MODREV2X)
1094 emlxs_swap_els_ub(ubp);
1095#endif /* EMLXS_MODREV2X */
1096
1097 emlxs_ub_callback(port, ubp);
1098
1099drop_it:
1100
1101 return;
1102
947} /* emlxs_handle_unsol_rscn() */
1103} /* emlxs_handle_unsol_rscn() */
948
949
950/* This is shared by FCT driver */
951extern uint32_t
952emlxs_process_unsol_flogi(emlxs_port_t *port, IOCBQ *iocbq, MATCHMAP *mp,
953 uint32_t size, char *buffer)
954{
955 emlxs_hba_t *hba = HBA;

--- 24 unchanged lines hidden (view full) ---

980 mutex_enter(&EMLXS_PORT_LOCK);
981
982 hba->flag &= ~FC_FABRIC_ATTACHED;
983 hba->flag |= FC_PT_TO_PT;
984
985 /* Save E_D_TOV ticks in nanoseconds */
986 if (sp->cmn.edtovResolution) {
987 hba->fc_edtov =
1104
1105
1106/* This is shared by FCT driver */
1107extern uint32_t
1108emlxs_process_unsol_flogi(emlxs_port_t *port, IOCBQ *iocbq, MATCHMAP *mp,
1109 uint32_t size, char *buffer)
1110{
1111 emlxs_hba_t *hba = HBA;

--- 24 unchanged lines hidden (view full) ---

1136 mutex_enter(&EMLXS_PORT_LOCK);
1137
1138 hba->flag &= ~FC_FABRIC_ATTACHED;
1139 hba->flag |= FC_PT_TO_PT;
1140
1141 /* Save E_D_TOV ticks in nanoseconds */
1142 if (sp->cmn.edtovResolution) {
1143 hba->fc_edtov =
988 (SWAP_DATA32(sp->cmn.e_d_tov) + 999999) / 1000000;
1144 (LE_SWAP32(sp->cmn.e_d_tov) + 999999) / 1000000;
989 } else {
1145 } else {
990 hba->fc_edtov = SWAP_DATA32(sp->cmn.e_d_tov);
1146 hba->fc_edtov = LE_SWAP32(sp->cmn.e_d_tov);
991 }
992
993 /* Save R_A_TOV ticks */
1147 }
1148
1149 /* Save R_A_TOV ticks */
994 hba->fc_ratov = (SWAP_DATA32(sp->cmn.w2.r_a_tov) + 999) / 1000;
1150 hba->fc_ratov = (LE_SWAP32(sp->cmn.w2.r_a_tov) + 999) / 1000;
995
996 buffer[0] = 0;
997
1151
1152 buffer[0] = 0;
1153
998#ifdef NPIV_SUPPORT
999 hba->flag &= ~FC_NPIV_SUPPORTED;
1000 (void) strcpy(buffer, "npiv:Disabled. P2P ");
1154 hba->flag &= ~FC_NPIV_SUPPORTED;
1155 (void) strcpy(buffer, "npiv:Disabled. P2P ");
1001#else
1002 (void) strcpy(buffer, "P2P ");
1003#endif /* NPIV_SUPPORT */
1004
1156
1157 port->rdid = sid;
1158
1005#ifdef DHCHAP_SUPPORT
1006 if (!sp->cmn.fcsp_support) {
1007 (void) strcat(buffer, "fcsp:Unsupported");
1008 } else if (cfg[CFG_AUTH_ENABLE].current &&
1009 (port->vpi == 0 || cfg[CFG_AUTH_NPIV].current)) {
1010 (void) strcat(buffer, "fcsp:Supported");
1011 } else {
1012 (void) strcat(buffer, "fcsp:Disabled");
1013 }
1014#endif /* DHCHAP_SUPPORT */
1015
1016 /* Clear the fabric service parameters */
1017 bzero((void *)&port->fabric_sparam, sizeof (SERV_PARM));
1018
1019 mutex_exit(&EMLXS_PORT_LOCK);
1020
1021 return (0);
1022
1159#ifdef DHCHAP_SUPPORT
1160 if (!sp->cmn.fcsp_support) {
1161 (void) strcat(buffer, "fcsp:Unsupported");
1162 } else if (cfg[CFG_AUTH_ENABLE].current &&
1163 (port->vpi == 0 || cfg[CFG_AUTH_NPIV].current)) {
1164 (void) strcat(buffer, "fcsp:Supported");
1165 } else {
1166 (void) strcat(buffer, "fcsp:Disabled");
1167 }
1168#endif /* DHCHAP_SUPPORT */
1169
1170 /* Clear the fabric service parameters */
1171 bzero((void *)&port->fabric_sparam, sizeof (SERV_PARM));
1172
1173 mutex_exit(&EMLXS_PORT_LOCK);
1174
1175 return (0);
1176
1023} /* emlxs_process_unsol_flogi() */
1177} /* emlxs_process_unsol_flogi() */
1024
1025
1026/* ARGSUSED */
1027static void
1178
1179
1180/* ARGSUSED */
1181static void
1028emlxs_handle_unsol_flogi(emlxs_port_t *port, RING *rp, IOCBQ *iocbq,
1182emlxs_handle_unsol_flogi(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
1029 MATCHMAP *mp, uint32_t size)
1030{
1031 uint8_t *bp;
1032 fc_unsol_buf_t *ubp;
1033 IOCB *iocb;
1034 uint32_t sid;
1035 emlxs_ub_priv_t *ub_priv;
1036 char buffer[64];

--- 29 unchanged lines hidden (view full) ---

1066 ub_priv = ubp->ub_fca_private;
1067 ub_priv->cmd = ELS_CMD_FLOGI;
1068
1069 /*
1070 * Setup frame header
1071 */
1072 ubp->ub_frame.r_ctl = FC_ELS_REQ;
1073 ubp->ub_frame.type = FC_ELS_DATA;
1183 MATCHMAP *mp, uint32_t size)
1184{
1185 uint8_t *bp;
1186 fc_unsol_buf_t *ubp;
1187 IOCB *iocb;
1188 uint32_t sid;
1189 emlxs_ub_priv_t *ub_priv;
1190 char buffer[64];

--- 29 unchanged lines hidden (view full) ---

1220 ub_priv = ubp->ub_fca_private;
1221 ub_priv->cmd = ELS_CMD_FLOGI;
1222
1223 /*
1224 * Setup frame header
1225 */
1226 ubp->ub_frame.r_ctl = FC_ELS_REQ;
1227 ubp->ub_frame.type = FC_ELS_DATA;
1074 ubp->ub_frame.s_id = SWAP_DATA24_LO(iocb->un.elsreq.remoteID);
1075 ubp->ub_frame.d_id = SWAP_DATA24_LO(iocb->un.elsreq.myID);
1228 ubp->ub_frame.s_id = LE_SWAP24_LO(iocb->un.elsreq.remoteID);
1229 ubp->ub_frame.d_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
1076 ubp->ub_frame.ox_id = ub_priv->token;
1230 ubp->ub_frame.ox_id = ub_priv->token;
1077 ubp->ub_frame.rx_id = iocb->ulpContext;
1231 ubp->ub_frame.rx_id = iocb->ULPCONTEXT;
1078 ubp->ub_class = FC_TRAN_CLASS3;
1079
1080 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1081 "FLOGI: sid=%x buffer=%p token=%x %s", sid, ubp, ub_priv->token,
1082 buffer);
1083
1084#if (EMLXS_MODREVX == EMLXS_MODREV2X)
1085 emlxs_swap_els_ub(ubp);
1086#endif /* EMLXS_MODREV2X */
1087
1088 emlxs_ub_callback(port, ubp);
1089
1090drop_it:
1091
1092 return;
1093
1232 ubp->ub_class = FC_TRAN_CLASS3;
1233
1234 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1235 "FLOGI: sid=%x buffer=%p token=%x %s", sid, ubp, ub_priv->token,
1236 buffer);
1237
1238#if (EMLXS_MODREVX == EMLXS_MODREV2X)
1239 emlxs_swap_els_ub(ubp);
1240#endif /* EMLXS_MODREV2X */
1241
1242 emlxs_ub_callback(port, ubp);
1243
1244drop_it:
1245
1246 return;
1247
1094} /* emlxs_handle_unsol_flogi() */
1248} /* emlxs_handle_unsol_flogi() */
1095
1096
1097
1098/* This is shared by FCT driver */
1099extern uint32_t
1100emlxs_process_unsol_plogi(emlxs_port_t *port, IOCBQ *iocbq, MATCHMAP *mp,
1101 uint32_t size, char *buffer)
1102{
1103 emlxs_hba_t *hba = HBA;
1104 emlxs_config_t *cfg = &CFG;
1105 uint8_t *bp;
1106 IOCB *iocb;
1107 uint32_t sid;
1108 SERV_PARM *sp;
1109 MAILBOXQ *mbox;
1110 emlxs_vvl_fmt_t vvl;
1249
1250
1251
1252/* This is shared by FCT driver */
1253extern uint32_t
1254emlxs_process_unsol_plogi(emlxs_port_t *port, IOCBQ *iocbq, MATCHMAP *mp,
1255 uint32_t size, char *buffer)
1256{
1257 emlxs_hba_t *hba = HBA;
1258 emlxs_config_t *cfg = &CFG;
1259 uint8_t *bp;
1260 IOCB *iocb;
1261 uint32_t sid;
1262 SERV_PARM *sp;
1263 MAILBOXQ *mbox;
1264 emlxs_vvl_fmt_t vvl;
1265 int rc;
1111
1112 iocb = &iocbq->iocb;
1113 sid = iocb->un.elsreq.remoteID;
1114
1115 if (size < (sizeof (SERV_PARM) + 4)) {
1116 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1117 "PLOGI: sid=%x. Payload too small. %d<%d Rejecting.", sid,
1118 size, (sizeof (SERV_PARM) + 4));
1119
1120 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
1121 ELS_CMD_PLOGI, LSRJT_PROTOCOL_ERR, LSEXP_NOTHING_MORE);
1122
1123 return (1);
1124 }
1125
1126 bp = mp->virt;
1127 sp = (SERV_PARM *)(bp + sizeof (uint32_t));
1128
1266
1267 iocb = &iocbq->iocb;
1268 sid = iocb->un.elsreq.remoteID;
1269
1270 if (size < (sizeof (SERV_PARM) + 4)) {
1271 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1272 "PLOGI: sid=%x. Payload too small. %d<%d Rejecting.", sid,
1273 size, (sizeof (SERV_PARM) + 4));
1274
1275 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
1276 ELS_CMD_PLOGI, LSRJT_PROTOCOL_ERR, LSEXP_NOTHING_MORE);
1277
1278 return (1);
1279 }
1280
1281 bp = mp->virt;
1282 sp = (SERV_PARM *)(bp + sizeof (uint32_t));
1283
1129#ifdef NPIV_SUPPORT
1130
1131 bzero((char *)&vvl, sizeof (emlxs_vvl_fmt_t));
1132
1284 bzero((char *)&vvl, sizeof (emlxs_vvl_fmt_t));
1285
1133 if (sp->valid_vendor_version) {
1286 if (sp->VALID_VENDOR_VERSION) {
1134
1135 bcopy((caddr_t *)&sp->vendorVersion[0],
1136 (caddr_t *)&vvl, sizeof (emlxs_vvl_fmt_t));
1287
1288 bcopy((caddr_t *)&sp->vendorVersion[0],
1289 (caddr_t *)&vvl, sizeof (emlxs_vvl_fmt_t));
1137 vvl.un0.word0 = SWAP_DATA32(vvl.un0.word0);
1138 vvl.un1.word1 = SWAP_DATA32(vvl.un1.word1);
1290 vvl.un0.word0 = LE_SWAP32(vvl.un0.word0);
1291 vvl.un1.word1 = LE_SWAP32(vvl.un1.word1);
1139 }
1140
1141 if (port->flag & EMLXS_PORT_RESTRICTED) {
1142 uint32_t reject_it = 0;
1143
1144 /* If remote port is the virtual port, then reject it */
1145 if ((vvl.un0.w0.oui == 0x0000C9) && (vvl.un1.w1.vport)) {
1146 reject_it = 1;
1147 }
1148
1149 /* If we are a virtual port and the remote device */
1150 /* is not a switch, then reject it */
1292 }
1293
1294 if (port->flag & EMLXS_PORT_RESTRICTED) {
1295 uint32_t reject_it = 0;
1296
1297 /* If remote port is the virtual port, then reject it */
1298 if ((vvl.un0.w0.oui == 0x0000C9) && (vvl.un1.w1.vport)) {
1299 reject_it = 1;
1300 }
1301
1302 /* If we are a virtual port and the remote device */
1303 /* is not a switch, then reject it */
1151 else if (port->vpi && ((sid & Fabric_DID_MASK) !=
1152 Fabric_DID_MASK)) {
1304 else if (port->vpi && ((sid & FABRIC_DID_MASK) !=
1305 FABRIC_DID_MASK)) {
1153 reject_it = 1;
1154 }
1155
1156 if (reject_it) {
1157 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1158 "PLOGI rcvd: sid=%x. Restricted. Rejecting.",
1159 sid);
1160

--- 6 unchanged lines hidden (view full) ---

1167 * to free up rpi
1168 */
1169 (void) emlxs_mb_reg_did(port, sid, sp, NULL, NULL,
1170 (IOCBQ *)1);
1171
1172 return (1);
1173 }
1174 }
1306 reject_it = 1;
1307 }
1308
1309 if (reject_it) {
1310 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1311 "PLOGI rcvd: sid=%x. Restricted. Rejecting.",
1312 sid);
1313

--- 6 unchanged lines hidden (view full) ---

1320 * to free up rpi
1321 */
1322 (void) emlxs_mb_reg_did(port, sid, sp, NULL, NULL,
1323 (IOCBQ *)1);
1324
1325 return (1);
1326 }
1327 }
1175#endif /* NPIV_SUPPORT */
1176
1177#ifdef DHCHAP_SUPPORT
1178 if (emlxs_dhc_verify_login(port, sid, sp)) {
1179 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1180 "PLOGI: sid=%x. FCSP disabled. Rejecting.", sid);
1181
1182 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
1183 ELS_CMD_PLOGI, LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);

--- 16 unchanged lines hidden (view full) ---

1200 mutex_enter(&EMLXS_PORT_LOCK);
1201
1202 /* Save our new port ID */
1203 port->did = iocb->un.elsreq.myID;
1204
1205 /* Save E_D_TOV ticks in nanoseconds */
1206 if (sp->cmn.edtovResolution) {
1207 hba->fc_edtov =
1328
1329#ifdef DHCHAP_SUPPORT
1330 if (emlxs_dhc_verify_login(port, sid, sp)) {
1331 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1332 "PLOGI: sid=%x. FCSP disabled. Rejecting.", sid);
1333
1334 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
1335 ELS_CMD_PLOGI, LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);

--- 16 unchanged lines hidden (view full) ---

1352 mutex_enter(&EMLXS_PORT_LOCK);
1353
1354 /* Save our new port ID */
1355 port->did = iocb->un.elsreq.myID;
1356
1357 /* Save E_D_TOV ticks in nanoseconds */
1358 if (sp->cmn.edtovResolution) {
1359 hba->fc_edtov =
1208 (SWAP_DATA32(sp->cmn.e_d_tov) + 999999) / 1000000;
1360 (LE_SWAP32(sp->cmn.e_d_tov) + 999999) / 1000000;
1209 } else {
1361 } else {
1210 hba->fc_edtov = SWAP_DATA32(sp->cmn.e_d_tov);
1362 hba->fc_edtov = LE_SWAP32(sp->cmn.e_d_tov);
1211 }
1212
1213 /* Save R_A_TOV ticks */
1214 hba->fc_ratov =
1363 }
1364
1365 /* Save R_A_TOV ticks */
1366 hba->fc_ratov =
1215 (SWAP_DATA32(sp->cmn.w2.r_a_tov) + 999) / 1000;
1367 (LE_SWAP32(sp->cmn.w2.r_a_tov) + 999) / 1000;
1216
1217 mutex_exit(&EMLXS_PORT_LOCK);
1218
1219 /* Update our service parms */
1220 if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba,
1368
1369 mutex_exit(&EMLXS_PORT_LOCK);
1370
1371 /* Update our service parms */
1372 if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba,
1221 MEM_MBOX | MEM_PRI))) {
1222 emlxs_mb_config_link(hba, (MAILBOX *)mbox);
1373 MEM_MBOX, 1))) {
1374 emlxs_mb_config_link(hba, mbox);
1223
1375
1224 if (emlxs_sli_issue_mbox_cmd(hba, (MAILBOX *)mbox,
1225 MBX_NOWAIT, 0) != MBX_BUSY) {
1376 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox,
1377 MBX_NOWAIT, 0);
1378 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
1226 (void) emlxs_mem_put(hba, MEM_MBOX,
1227 (uint8_t *)mbox);
1228 }
1229
1230 }
1231 }
1232
1233 return (0);
1234
1379 (void) emlxs_mem_put(hba, MEM_MBOX,
1380 (uint8_t *)mbox);
1381 }
1382
1383 }
1384 }
1385
1386 return (0);
1387
1235} /* emlxs_process_unsol_plogi() */
1388} /* emlxs_process_unsol_plogi() */
1236
1237
1238/* ARGSUSED */
1239static void
1389
1390
1391/* ARGSUSED */
1392static void
1240emlxs_handle_unsol_plogi(emlxs_port_t *port, RING *rp, IOCBQ *iocbq,
1393emlxs_handle_unsol_plogi(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
1241 MATCHMAP *mp, uint32_t size)
1242{
1243 fc_unsol_buf_t *ubp;
1244 uint8_t *bp;
1245 IOCB *iocb;
1246 uint32_t sid;
1247 uint32_t did;
1248 emlxs_ub_priv_t *ub_priv;

--- 38 unchanged lines hidden (view full) ---

1287 ub_priv = ubp->ub_fca_private;
1288 ub_priv->cmd = ELS_CMD_PLOGI;
1289
1290 /*
1291 * Setup frame header
1292 */
1293 ubp->ub_frame.r_ctl = FC_ELS_REQ;
1294 ubp->ub_frame.type = FC_ELS_DATA;
1394 MATCHMAP *mp, uint32_t size)
1395{
1396 fc_unsol_buf_t *ubp;
1397 uint8_t *bp;
1398 IOCB *iocb;
1399 uint32_t sid;
1400 uint32_t did;
1401 emlxs_ub_priv_t *ub_priv;

--- 38 unchanged lines hidden (view full) ---

1440 ub_priv = ubp->ub_fca_private;
1441 ub_priv->cmd = ELS_CMD_PLOGI;
1442
1443 /*
1444 * Setup frame header
1445 */
1446 ubp->ub_frame.r_ctl = FC_ELS_REQ;
1447 ubp->ub_frame.type = FC_ELS_DATA;
1295 ubp->ub_frame.s_id = SWAP_DATA24_LO(iocb->un.elsreq.remoteID);
1296 ubp->ub_frame.d_id = SWAP_DATA24_LO(iocb->un.elsreq.myID);
1448 ubp->ub_frame.s_id = LE_SWAP24_LO(iocb->un.elsreq.remoteID);
1449 ubp->ub_frame.d_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
1297 ubp->ub_frame.ox_id = ub_priv->token;
1450 ubp->ub_frame.ox_id = ub_priv->token;
1298 ubp->ub_frame.rx_id = iocb->ulpContext;
1451 ubp->ub_frame.rx_id = iocb->ULPCONTEXT;
1299 ubp->ub_class = FC_TRAN_CLASS3;
1300
1301 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1302 "PLOGI: sid=%x did=%x buffer=%p token=%x %s", sid, did, ubp,
1303 ub_priv->token, buffer);
1304
1305#if (EMLXS_MODREVX == EMLXS_MODREV2X)
1306 emlxs_swap_els_ub(ubp);

--- 8 unchanged lines hidden (view full) ---

1315 }
1316
1317 emlxs_ub_callback(port, ubp);
1318
1319drop_it:
1320
1321 return;
1322
1452 ubp->ub_class = FC_TRAN_CLASS3;
1453
1454 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1455 "PLOGI: sid=%x did=%x buffer=%p token=%x %s", sid, did, ubp,
1456 ub_priv->token, buffer);
1457
1458#if (EMLXS_MODREVX == EMLXS_MODREV2X)
1459 emlxs_swap_els_ub(ubp);

--- 8 unchanged lines hidden (view full) ---

1468 }
1469
1470 emlxs_ub_callback(port, ubp);
1471
1472drop_it:
1473
1474 return;
1475
1323} /* emlxs_handle_unsol_plogi() */
1476} /* emlxs_handle_unsol_plogi() */
1324
1325
1326/* ARGSUSED */
1327static void
1477
1478
1479/* ARGSUSED */
1480static void
1328emlxs_handle_unsol_prli(emlxs_port_t *port, RING *rp, IOCBQ *iocbq,
1481emlxs_handle_unsol_prli(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
1329 MATCHMAP *mp, uint32_t size)
1330{
1482 MATCHMAP *mp, uint32_t size)
1483{
1484 emlxs_hba_t *hba = HBA;
1485 emlxs_config_t *cfg = &CFG;
1331 IOCB *iocb;
1332 uint32_t sid;
1333 NODELIST *ndlp;
1334 PRLI *npr;
1486 IOCB *iocb;
1487 uint32_t sid;
1488 NODELIST *ndlp;
1489 PRLI *npr;
1335
1336#ifndef ULP_PATCH3
1337 fc_unsol_buf_t *ubp;
1338 emlxs_ub_priv_t *ub_priv;
1490 fc_unsol_buf_t *ubp;
1491 emlxs_ub_priv_t *ub_priv;
1339#endif
1340
1341 iocb = &iocbq->iocb;
1342 sid = iocb->un.elsreq.remoteID;
1343 ndlp = emlxs_node_find_did(port, sid);
1344
1345 if (!ndlp || !ndlp->nlp_active) {
1346 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1347 "PRLI: sid=%x: Node not found. Rejecting.", sid);

--- 26 unchanged lines hidden (view full) ---

1374
1375 /* Check for FCP2 target support */
1376 if (npr->targetFunc && npr->Retry) {
1377 ndlp->nlp_fcp_info |= NLP_FCP_2_DEVICE;
1378 } else {
1379 ndlp->nlp_fcp_info &= ~NLP_FCP_2_DEVICE;
1380 }
1381 }
1492
1493 iocb = &iocbq->iocb;
1494 sid = iocb->un.elsreq.remoteID;
1495 ndlp = emlxs_node_find_did(port, sid);
1496
1497 if (!ndlp || !ndlp->nlp_active) {
1498 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1499 "PRLI: sid=%x: Node not found. Rejecting.", sid);

--- 26 unchanged lines hidden (view full) ---

1526
1527 /* Check for FCP2 target support */
1528 if (npr->targetFunc && npr->Retry) {
1529 ndlp->nlp_fcp_info |= NLP_FCP_2_DEVICE;
1530 } else {
1531 ndlp->nlp_fcp_info &= ~NLP_FCP_2_DEVICE;
1532 }
1533 }
1534
1382#ifdef ULP_PATCH3
1535#ifdef ULP_PATCH3
1536 if (cfg[CFG_ENABLE_PATCH].current & ULP_PATCH3) {
1537 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1538 "PRLI: sid=%x. Accepting.", sid);
1383
1539
1384 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1385 "PRLI: sid=%x. Accepting.", sid);
1540 /* Auto reply to PRLI's */
1541 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC,
1542 ELS_CMD_PRLI, 0, 0);
1543 goto drop_it;
1544 }
1545#endif /* ULP_PATCH3 */
1386
1546
1387 /* Auto reply to PRLI's */
1388 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_PRLI, 0, 0);
1389
1390#else
1391
1392 /* Tell ULP about it */
1393 ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size, FC_ELS_DATA, 0);
1394
1395 if (ubp == NULL) {
1396 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
1397 "PRLI rcvd: sid=%x. Rejecting.", sid);
1398
1399 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,

--- 9 unchanged lines hidden (view full) ---

1409 ub_priv = ubp->ub_fca_private;
1410 ub_priv->cmd = ELS_CMD_PRLI;
1411
1412 /*
1413 * Setup frame header
1414 */
1415 ubp->ub_frame.r_ctl = FC_ELS_REQ;
1416 ubp->ub_frame.type = FC_ELS_DATA;
1547 /* Tell ULP about it */
1548 ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size, FC_ELS_DATA, 0);
1549
1550 if (ubp == NULL) {
1551 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
1552 "PRLI rcvd: sid=%x. Rejecting.", sid);
1553
1554 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,

--- 9 unchanged lines hidden (view full) ---

1564 ub_priv = ubp->ub_fca_private;
1565 ub_priv->cmd = ELS_CMD_PRLI;
1566
1567 /*
1568 * Setup frame header
1569 */
1570 ubp->ub_frame.r_ctl = FC_ELS_REQ;
1571 ubp->ub_frame.type = FC_ELS_DATA;
1417 ubp->ub_frame.s_id = SWAP_DATA24_LO(iocb->un.elsreq.remoteID);
1418 ubp->ub_frame.d_id = SWAP_DATA24_LO(iocb->un.elsreq.myID);
1572 ubp->ub_frame.s_id = LE_SWAP24_LO(iocb->un.elsreq.remoteID);
1573 ubp->ub_frame.d_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
1419 ubp->ub_frame.ox_id = ub_priv->token;
1574 ubp->ub_frame.ox_id = ub_priv->token;
1420 ubp->ub_frame.rx_id = iocb->ulpContext;
1575 ubp->ub_frame.rx_id = iocb->ULPCONTEXT;
1421 ubp->ub_class = FC_TRAN_CLASS3;
1422
1423 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1424 "PRLI: sid=%x buffer=%p token=%x info=%02x", sid, ubp,
1425 ub_priv->token, ndlp->nlp_fcp_info);
1426
1427#if (EMLXS_MODREVX == EMLXS_MODREV2X)
1428 emlxs_swap_els_ub(ubp);
1429#endif /* EMLXS_MODREV2X */
1430
1431 emlxs_ub_callback(port, ubp);
1432
1576 ubp->ub_class = FC_TRAN_CLASS3;
1577
1578 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1579 "PRLI: sid=%x buffer=%p token=%x info=%02x", sid, ubp,
1580 ub_priv->token, ndlp->nlp_fcp_info);
1581
1582#if (EMLXS_MODREVX == EMLXS_MODREV2X)
1583 emlxs_swap_els_ub(ubp);
1584#endif /* EMLXS_MODREV2X */
1585
1586 emlxs_ub_callback(port, ubp);
1587
1433#endif /* ULP_PATCH3 */
1434
1435drop_it:
1436
1437 return;
1438
1588drop_it:
1589
1590 return;
1591
1439} /* emlxs_handle_unsol_prli() */
1592} /* emlxs_handle_unsol_prli() */
1440
1441
1442/* ARGSUSED */
1443static void
1593
1594
1595/* ARGSUSED */
1596static void
1444emlxs_handle_unsol_auth(emlxs_port_t *port, RING *rp, IOCBQ *iocbq,
1597emlxs_handle_unsol_auth(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
1445 MATCHMAP *mp, uint32_t size)
1446{
1447 IOCB *iocb;
1448 uint32_t sid;
1449 NODELIST *ndlp;
1450
1451 iocb = &iocbq->iocb;
1452 sid = iocb->un.elsreq.remoteID;

--- 9 unchanged lines hidden (view full) ---

1462 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
1463 ELS_CMD_AUTH, LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);
1464
1465 goto drop_it;
1466 }
1467
1468 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg, "AUTH: sid=%x", sid);
1469
1598 MATCHMAP *mp, uint32_t size)
1599{
1600 IOCB *iocb;
1601 uint32_t sid;
1602 NODELIST *ndlp;
1603
1604 iocb = &iocbq->iocb;
1605 sid = iocb->un.elsreq.remoteID;

--- 9 unchanged lines hidden (view full) ---

1615 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
1616 ELS_CMD_AUTH, LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);
1617
1618 goto drop_it;
1619 }
1620
1621 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg, "AUTH: sid=%x", sid);
1622
1470 (void) emlxs_dhchap_state_machine(port, rp, iocbq, mp, ndlp,
1623 (void) emlxs_dhchap_state_machine(port, cp, iocbq, mp, ndlp,
1471 NODE_EVENT_RCV_AUTH_MSG);
1472#else
1473
1474 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1475 "AUTH: sid=%x: Rejecting.", sid);
1476 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT, ELS_CMD_AUTH,
1477 LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);
1478
1479#endif /* DHCAHP_SUPPORT */
1480
1481drop_it:
1482
1483 return;
1484
1624 NODE_EVENT_RCV_AUTH_MSG);
1625#else
1626
1627 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1628 "AUTH: sid=%x: Rejecting.", sid);
1629 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT, ELS_CMD_AUTH,
1630 LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);
1631
1632#endif /* DHCAHP_SUPPORT */
1633
1634drop_it:
1635
1636 return;
1637
1485} /* emlxs_handle_unsol_auth() */
1638} /* emlxs_handle_unsol_auth() */
1486
1487
1488/* ARGSUSED */
1489static void
1639
1640
1641/* ARGSUSED */
1642static void
1490emlxs_handle_unsol_adisc(emlxs_port_t *port, RING *rp, IOCBQ *iocbq,
1643emlxs_handle_unsol_adisc(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
1491 MATCHMAP *mp, uint32_t size)
1492{
1493 IOCB *iocb;
1494#ifdef SAN_DIAG_SUPPORT
1495 NODELIST *ndlp;
1496#endif
1497 uint32_t sid;
1498

--- 11 unchanged lines hidden (view full) ---

1510#endif
1511
1512 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1513 "ADISC: sid=%x: Accepting.", sid);
1514 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_ADISC, 0, 0);
1515
1516 return;
1517
1644 MATCHMAP *mp, uint32_t size)
1645{
1646 IOCB *iocb;
1647#ifdef SAN_DIAG_SUPPORT
1648 NODELIST *ndlp;
1649#endif
1650 uint32_t sid;
1651

--- 11 unchanged lines hidden (view full) ---

1663#endif
1664
1665 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1666 "ADISC: sid=%x: Accepting.", sid);
1667 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_ADISC, 0, 0);
1668
1669 return;
1670
1518} /* emlxs_handle_unsol_adisc() */
1671} /* emlxs_handle_unsol_adisc() */
1519
1520
1521/* ARGSUSED */
1522static void
1672
1673
1674/* ARGSUSED */
1675static void
1523emlxs_handle_unsol_prlo(emlxs_port_t *port, RING *rp, IOCBQ *iocbq,
1676emlxs_handle_unsol_prlo(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
1524 MATCHMAP *mp, uint32_t size)
1525{
1677 MATCHMAP *mp, uint32_t size)
1678{
1526#ifdef ULP_PATCH4
1527#ifdef ULP_PATCH6
1528 emlxs_hba_t *hba = HBA;
1529#endif /* ULP_PATCH6 */
1530#endif /* ULP_PATCH4 */
1679 emlxs_hba_t *hba = HBA;
1680 emlxs_config_t *cfg = &CFG;
1531 IOCB *iocb;
1532 uint32_t sid;
1681 IOCB *iocb;
1682 uint32_t sid;
1533#ifndef ULP_PATCH4
1534 fc_unsol_buf_t *ubp;
1535 emlxs_ub_priv_t *ub_priv;
1683 fc_unsol_buf_t *ubp;
1684 emlxs_ub_priv_t *ub_priv;
1536#endif
1537
1538 NODELIST *ndlp;
1539
1540 iocb = &iocbq->iocb;
1541 sid = iocb->un.elsreq.remoteID;
1542
1543 /* Get the node */
1544 ndlp = emlxs_node_find_did(port, sid);
1545
1546#ifdef SAN_DIAG_SUPPORT
1547 if (ndlp) {
1548 emlxs_log_sd_prlo_event(port, (HBA_WWN *)&ndlp->nlp_portname);
1549 }
1550#endif
1551
1552#ifdef ULP_PATCH4
1685 NODELIST *ndlp;
1686
1687 iocb = &iocbq->iocb;
1688 sid = iocb->un.elsreq.remoteID;
1689
1690 /* Get the node */
1691 ndlp = emlxs_node_find_did(port, sid);
1692
1693#ifdef SAN_DIAG_SUPPORT
1694 if (ndlp) {
1695 emlxs_log_sd_prlo_event(port, (HBA_WWN *)&ndlp->nlp_portname);
1696 }
1697#endif
1698
1699#ifdef ULP_PATCH4
1700 if (cfg[CFG_ENABLE_PATCH].current & ULP_PATCH4) {
1553#ifdef ULP_PATCH6
1701#ifdef ULP_PATCH6
1702 if (cfg[CFG_ENABLE_PATCH].current & ULP_PATCH6) {
1703 /* Check if this is a SCSI target */
1704 if (ndlp && (ndlp->nlp_fcp_info & NLP_FCP_TGT_DEVICE)) {
1705 /* This is a SCSI target */
1554
1706
1555 /* Check if this is a SCSI target */
1556 if (ndlp && (ndlp->nlp_fcp_info & NLP_FCP_TGT_DEVICE)) {
1557 /* This is a SCSI target */
1707 /* If only one node is present, then we can */
1708 /* conclude that we are direct attached */
1709 /* to a target */
1710 if (port->node_count == 1) {
1711 EMLXS_MSGF(EMLXS_CONTEXT,
1712 &emlxs_unsol_els_msg,
1713 "PRLO: sid=%x. Accepting and " \
1714 "reseting link.",
1715 sid);
1558
1716
1559 /* If only one node is present, then we can */
1560 /* conclude that we are direct attached to a target */
1561 if (port->node_count == 1) {
1562 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1563 "PRLO: sid=%x. Accepting and reseting link.",
1564 sid);
1717 /* Send Acc */
1718 (void) emlxs_els_reply(port, iocbq,
1719 ELS_CMD_ACC, ELS_CMD_PRLO, 0, 0);
1565
1720
1566 /* Send Acc */
1567 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC,
1568 ELS_CMD_PRLO, 0, 0);
1721 /* Spawn a thread to reset the link */
1722 emlxs_thread_spawn(hba,
1723 emlxs_reset_link_thread,
1724 NULL, NULL);
1569
1725
1570 /* Spawn a thread to reset the link */
1571 emlxs_thread_spawn(hba, emlxs_reset_link_thread,
1572 NULL, NULL);
1726 goto drop_it;
1573
1727
1574 goto drop_it;
1728 }
1729 /* Check if fabric is present */
1730 else if (hba->flag & FC_FABRIC_ATTACHED) {
1731 /* Auto reply to PRLO */
1732 EMLXS_MSGF(EMLXS_CONTEXT,
1733 &emlxs_unsol_els_msg,
1734 "PRLO: sid=%x. Accepting and " \
1735 "generating RSCN.",
1736 sid);
1575
1737
1576 }
1577 /* Check if fabric is present */
1578 else if (hba->flag & FC_FABRIC_ATTACHED) {
1579 /* Auto reply to PRLO */
1580 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1581 "PRLO: sid=%x. Accepting and generating RSCN.",
1582 sid);
1738 /* Send Acc */
1739 (void) emlxs_els_reply(port, iocbq,
1740 ELS_CMD_ACC, ELS_CMD_PRLO, 0, 0);
1583
1741
1584 /* Send Acc */
1585 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC,
1586 ELS_CMD_PRLO, 0, 0);
1742 /* Generate an RSCN to wakeup ULP */
1743 (void) emlxs_generate_rscn(port, sid);
1587
1744
1588 /* Generate an RSCN to wakeup ULP */
1589 (void) emlxs_generate_rscn(port, sid);
1590
1591 goto drop_it;
1745 goto drop_it;
1746 }
1747 }
1592 }
1748 }
1593
1594 }
1595 /* SCSI target */
1596#endif /* ULP_PATCH6 */
1597
1749#endif /* ULP_PATCH6 */
1750
1598 /* Auto reply to PRLO */
1599 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1600 "PRLO: sid=%x. Accepting.", sid);
1751 /* Auto reply to PRLO */
1752 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1753 "PRLO: sid=%x. Accepting.", sid);
1601
1754
1602 /* Send Acc */
1603 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC, ELS_CMD_PRLO, 0, 0);
1755 /* Send Acc */
1756 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC,
1757 ELS_CMD_PRLO, 0, 0);
1604
1758
1605 goto drop_it;
1759 goto drop_it;
1760 }
1761#endif /* ULP_PATCH4 */
1606
1762
1607#else /* !ULP_PATCH4 */
1608
1609 /* Tell ULP about it */
1610
1611 ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size, FC_ELS_DATA, 0);
1612
1613 if (ubp == NULL) {
1614 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
1615 "PRLO recvd: sid=%x. Rejecting.", sid);
1616

--- 10 unchanged lines hidden (view full) ---

1627 ub_priv = ubp->ub_fca_private;
1628 ub_priv->cmd = ELS_CMD_PRLO;
1629
1630 /*
1631 * Setup frame header
1632 */
1633 ubp->ub_frame.r_ctl = FC_ELS_REQ;
1634 ubp->ub_frame.type = FC_ELS_DATA;
1763 /* Tell ULP about it */
1764
1765 ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size, FC_ELS_DATA, 0);
1766
1767 if (ubp == NULL) {
1768 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
1769 "PRLO recvd: sid=%x. Rejecting.", sid);
1770

--- 10 unchanged lines hidden (view full) ---

1781 ub_priv = ubp->ub_fca_private;
1782 ub_priv->cmd = ELS_CMD_PRLO;
1783
1784 /*
1785 * Setup frame header
1786 */
1787 ubp->ub_frame.r_ctl = FC_ELS_REQ;
1788 ubp->ub_frame.type = FC_ELS_DATA;
1635 ubp->ub_frame.s_id = SWAP_DATA24_LO(iocb->un.elsreq.remoteID);
1636 ubp->ub_frame.d_id = SWAP_DATA24_LO(iocb->un.elsreq.myID);
1789 ubp->ub_frame.s_id = LE_SWAP24_LO(iocb->un.elsreq.remoteID);
1790 ubp->ub_frame.d_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
1637 ubp->ub_frame.ox_id = ub_priv->token;
1791 ubp->ub_frame.ox_id = ub_priv->token;
1638 ubp->ub_frame.rx_id = iocb->ulpContext;
1792 ubp->ub_frame.rx_id = iocb->ULPCONTEXT;
1639 ubp->ub_class = FC_TRAN_CLASS3;
1640
1641 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1642 "PRLO: sid=%x buffeiocbr=%p token=%x.", sid, ubp, ub_priv->token);
1643
1644#if (EMLXS_MODREVX == EMLXS_MODREV2X)
1645 emlxs_swap_els_ub(ubp);
1646#endif /* EMLXS_MODREV2X */
1647
1648 emlxs_ub_callback(port, ubp);
1649
1793 ubp->ub_class = FC_TRAN_CLASS3;
1794
1795 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1796 "PRLO: sid=%x buffeiocbr=%p token=%x.", sid, ubp, ub_priv->token);
1797
1798#if (EMLXS_MODREVX == EMLXS_MODREV2X)
1799 emlxs_swap_els_ub(ubp);
1800#endif /* EMLXS_MODREV2X */
1801
1802 emlxs_ub_callback(port, ubp);
1803
1650#endif /* ULP_PATCH4 */
1651
1652drop_it:
1653
1654 return;
1655
1804drop_it:
1805
1806 return;
1807
1656} /* emlxs_handle_unsol_prlo() */
1808} /* emlxs_handle_unsol_prlo() */
1657
1658
1659/* ARGSUSED */
1660static void
1809
1810
1811/* ARGSUSED */
1812static void
1661emlxs_handle_unsol_logo(emlxs_port_t *port, RING *rp, IOCBQ *iocbq,
1813emlxs_handle_unsol_logo(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
1662 MATCHMAP *mp, uint32_t size)
1663{
1664 emlxs_hba_t *hba = HBA;
1814 MATCHMAP *mp, uint32_t size)
1815{
1816 emlxs_hba_t *hba = HBA;
1817 emlxs_config_t *cfg = &CFG;
1665 fc_unsol_buf_t *ubp;
1666 IOCB *iocb;
1667 uint32_t sid;
1668 emlxs_ub_priv_t *ub_priv;
1669 uint32_t reply_sent = 0;
1670 NODELIST *ndlp;
1671
1672 iocb = &iocbq->iocb;

--- 5 unchanged lines hidden (view full) ---

1678 if (ndlp) {
1679 emlxs_log_sd_basic_els_event(port, SD_ELS_SUBCATEGORY_LOGO_RCV,
1680 (HBA_WWN *)&ndlp->nlp_portname,
1681 (HBA_WWN *)((uint32_t *)mp->virt + 2));
1682 }
1683#endif
1684
1685#ifdef ULP_PATCH6
1818 fc_unsol_buf_t *ubp;
1819 IOCB *iocb;
1820 uint32_t sid;
1821 emlxs_ub_priv_t *ub_priv;
1822 uint32_t reply_sent = 0;
1823 NODELIST *ndlp;
1824
1825 iocb = &iocbq->iocb;

--- 5 unchanged lines hidden (view full) ---

1831 if (ndlp) {
1832 emlxs_log_sd_basic_els_event(port, SD_ELS_SUBCATEGORY_LOGO_RCV,
1833 (HBA_WWN *)&ndlp->nlp_portname,
1834 (HBA_WWN *)((uint32_t *)mp->virt + 2));
1835 }
1836#endif
1837
1838#ifdef ULP_PATCH6
1839 if (cfg[CFG_ENABLE_PATCH].current & ULP_PATCH6) {
1840 /* Check if this is a SCSI target */
1841 if (ndlp && (ndlp->nlp_fcp_info & NLP_FCP_TGT_DEVICE)) {
1842 /* This is a SCSI target */
1686
1843
1687 /* Check if this is a SCSI target */
1688 if (ndlp && (ndlp->nlp_fcp_info & NLP_FCP_TGT_DEVICE)) {
1689 /* This is a SCSI target */
1844 /* If only one node is present, then we can */
1845 /* conclude that we are direct attached to a target */
1846 if (port->node_count == 1) {
1847 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1848 "LOGO: sid=%x. Accepting and "\
1849 "reseting link.", sid);
1690
1850
1691 /* If only one node is present, then we can */
1692 /* conclude that we are direct attached to a target */
1693 if (port->node_count == 1) {
1694 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1695 "LOGO: sid=%x. Accepting and reseting link.",
1696 sid);
1851 (void) emlxs_els_reply(port, iocbq,
1852 ELS_CMD_ACC, ELS_CMD_LOGO, 0, 0);
1697
1853
1698 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC,
1699 ELS_CMD_LOGO, 0, 0);
1854 /* Spawn a thread to reset the link */
1855 emlxs_thread_spawn(hba, emlxs_reset_link_thread,
1856 NULL, NULL);
1700
1857
1701 /* Spawn a thread to reset the link */
1702 emlxs_thread_spawn(hba, emlxs_reset_link_thread,
1703 NULL, NULL);
1858 goto drop_it;
1859 }
1860 /* Check if fabric node is present */
1861 else if (hba->flag & FC_FABRIC_ATTACHED) {
1862 /* Send reply ourselves */
1863 /* We will block all attempts */
1864 /* for ULP to reply to a LOGO */
1865 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1866 "LOGO: sid=%x. Accepting and " \
1867 "generating RSCN.", sid);
1704
1868
1705 goto drop_it;
1706 }
1707 /* Check if fabric node is present */
1708 else if (hba->flag & FC_FABRIC_ATTACHED) {
1709 /* Send reply ourselves */
1710 /* We will block all attempts */
1711 /* for ULP to reply to a LOGO */
1712 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1713 "LOGO: sid=%x. Accepting and generating RSCN.",
1714 sid);
1869 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC,
1870 ELS_CMD_LOGO, 0, 0);
1715
1871
1716 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC,
1717 ELS_CMD_LOGO, 0, 0);
1872 /* Generate an RSCN to wakeup ULP */
1873 if (emlxs_generate_rscn(port, sid)
1874 == FC_SUCCESS) {
1875 goto drop_it;
1876 }
1718
1877
1719 /* Generate an RSCN to wakeup ULP */
1720 if (emlxs_generate_rscn(port, sid) == FC_SUCCESS) {
1721 goto drop_it;
1878 reply_sent = 1;
1722 }
1879 }
1723
1724 reply_sent = 1;
1725 }
1880 }
1726
1727 }
1881 }
1728 /* SCSI target */
1729#endif /* ULP_PATCH6 */
1730
1731 ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size, FC_ELS_DATA, 1);
1732
1733 if (ubp == NULL) {
1734 if (!reply_sent) {
1735 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
1736 "LOGO rcvd: sid=%x. Rejecting.", sid);

--- 10 unchanged lines hidden (view full) ---

1747 /* Setup unsolicited buffer and pass it up */
1748 bcopy(mp->virt, ubp->ub_buffer, size);
1749 ub_priv = ubp->ub_fca_private;
1750 ub_priv->cmd = ELS_CMD_LOGO;
1751
1752 /* Setup frame header */
1753 ubp->ub_frame.r_ctl = FC_ELS_REQ;
1754 ubp->ub_frame.type = FC_ELS_DATA;
1882#endif /* ULP_PATCH6 */
1883
1884 ubp = (fc_unsol_buf_t *)emlxs_ub_get(port, size, FC_ELS_DATA, 1);
1885
1886 if (ubp == NULL) {
1887 if (!reply_sent) {
1888 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_no_unsol_buf_msg,
1889 "LOGO rcvd: sid=%x. Rejecting.", sid);

--- 10 unchanged lines hidden (view full) ---

1900 /* Setup unsolicited buffer and pass it up */
1901 bcopy(mp->virt, ubp->ub_buffer, size);
1902 ub_priv = ubp->ub_fca_private;
1903 ub_priv->cmd = ELS_CMD_LOGO;
1904
1905 /* Setup frame header */
1906 ubp->ub_frame.r_ctl = FC_ELS_REQ;
1907 ubp->ub_frame.type = FC_ELS_DATA;
1755 ubp->ub_frame.s_id = SWAP_DATA24_LO(iocb->un.elsreq.remoteID);
1756 ubp->ub_frame.d_id = SWAP_DATA24_LO(iocb->un.elsreq.myID);
1908 ubp->ub_frame.s_id = LE_SWAP24_LO(iocb->un.elsreq.remoteID);
1909 ubp->ub_frame.d_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
1757 ubp->ub_frame.ox_id = ub_priv->token;
1910 ubp->ub_frame.ox_id = ub_priv->token;
1758 ubp->ub_frame.rx_id = iocb->ulpContext;
1911 ubp->ub_frame.rx_id = iocb->ULPCONTEXT;
1759 ubp->ub_class = FC_TRAN_CLASS3;
1760
1761#ifdef ULP_PATCH2
1912 ubp->ub_class = FC_TRAN_CLASS3;
1913
1914#ifdef ULP_PATCH2
1915 if (cfg[CFG_ENABLE_PATCH].current & ULP_PATCH2) {
1916 if (!reply_sent) {
1917 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1918 "LOGO: sid=%x buffer=%p token=%x. Accepting.",
1919 sid, ubp, ub_priv->token);
1762
1920
1763 if (!reply_sent) {
1764 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1765 "LOGO: sid=%x buffer=%p token=%x. Accepting.", sid, ubp,
1766 ub_priv->token);
1921 ub_priv->flags |= EMLXS_UB_REPLY;
1767
1922
1768 ub_priv->flags |= EMLXS_UB_REPLY;
1769
1770 /* Send Acc */
1771 /* Send reply ourselves because ULP */
1772 /* doesn't always reply to these */
1773 /* We will block all attempts for ULP to reply to a LOGO */
1774 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC,
1775 ELS_CMD_LOGO, 0, 0);
1776 reply_sent = 1;
1923 /* Send Acc */
1924 /* Send reply ourselves because ULP */
1925 /* doesn't always reply to these */
1926 /* We ll block attempts for ULP to reply to a LOGO */
1927 (void) emlxs_els_reply(port, iocbq, ELS_CMD_ACC,
1928 ELS_CMD_LOGO, 0, 0);
1929 reply_sent = 1;
1930 }
1777 }
1931 }
1778#else /* !ULP_PATCH2 */
1932#endif /* ULP_PATCH2 */
1779
1780 if (!reply_sent) {
1781 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1782 "LOGO: sid=%x buffer=%p token=%x.", sid, ubp,
1783 ub_priv->token);
1784 }
1933
1934 if (!reply_sent) {
1935 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1936 "LOGO: sid=%x buffer=%p token=%x.", sid, ubp,
1937 ub_priv->token);
1938 }
1785#endif /* ULP_PATCH2 */
1786
1787#if (EMLXS_MODREVX == EMLXS_MODREV2X)
1788 emlxs_swap_els_ub(ubp);
1789#endif /* EMLXS_MODREV2X */
1790
1791 /* Clear the RPI */
1939
1940#if (EMLXS_MODREVX == EMLXS_MODREV2X)
1941 emlxs_swap_els_ub(ubp);
1942#endif /* EMLXS_MODREV2X */
1943
1944 /* Clear the RPI */
1792 if ((sid & Fabric_DID_MASK) == Fabric_DID_MASK) {
1945 if ((sid & FABRIC_DID_MASK) == FABRIC_DID_MASK) {
1793 if (emlxs_mb_unreg_did(port, sid, NULL, ubp, NULL) == 0) {
1794 /*
1795 * Deferred completion of this ubp
1796 * until unreg login is complete
1797 */
1798
1799 return;
1800 }
1801 }
1802
1803 emlxs_ub_callback(port, ubp);
1804
1805drop_it:
1806
1807 return;
1808
1946 if (emlxs_mb_unreg_did(port, sid, NULL, ubp, NULL) == 0) {
1947 /*
1948 * Deferred completion of this ubp
1949 * until unreg login is complete
1950 */
1951
1952 return;
1953 }
1954 }
1955
1956 emlxs_ub_callback(port, ubp);
1957
1958drop_it:
1959
1960 return;
1961
1809} /* emlxs_handle_unsol_logo() */
1962} /* emlxs_handle_unsol_logo() */
1810
1811
1812
1813/* ARGSUSED */
1814static void
1963
1964
1965
1966/* ARGSUSED */
1967static void
1815emlxs_handle_unsol_gen_cmd(emlxs_port_t *port, RING *rp, IOCBQ *iocbq,
1968emlxs_handle_unsol_gen_cmd(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
1816 MATCHMAP *mp, uint32_t size)
1817{
1818 uint8_t *bp;
1819 fc_unsol_buf_t *ubp;
1820 IOCB *iocb;
1821 uint32_t *lp;
1822 uint32_t cmd;
1823 uint32_t sid;

--- 21 unchanged lines hidden (view full) ---

1845
1846 bcopy(bp, ubp->ub_buffer, size);
1847 ub_priv = ubp->ub_fca_private;
1848 ub_priv->cmd = cmd;
1849
1850 /* Setup frame header */
1851 ubp->ub_frame.r_ctl = FC_ELS_REQ;
1852 ubp->ub_frame.type = FC_ELS_DATA;
1969 MATCHMAP *mp, uint32_t size)
1970{
1971 uint8_t *bp;
1972 fc_unsol_buf_t *ubp;
1973 IOCB *iocb;
1974 uint32_t *lp;
1975 uint32_t cmd;
1976 uint32_t sid;

--- 21 unchanged lines hidden (view full) ---

1998
1999 bcopy(bp, ubp->ub_buffer, size);
2000 ub_priv = ubp->ub_fca_private;
2001 ub_priv->cmd = cmd;
2002
2003 /* Setup frame header */
2004 ubp->ub_frame.r_ctl = FC_ELS_REQ;
2005 ubp->ub_frame.type = FC_ELS_DATA;
1853 ubp->ub_frame.s_id = SWAP_DATA24_LO(iocb->un.elsreq.remoteID);
1854 ubp->ub_frame.d_id = SWAP_DATA24_LO(iocb->un.elsreq.myID);
2006 ubp->ub_frame.s_id = LE_SWAP24_LO(iocb->un.elsreq.remoteID);
2007 ubp->ub_frame.d_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
1855 ubp->ub_frame.ox_id = ub_priv->token;
2008 ubp->ub_frame.ox_id = ub_priv->token;
1856 ubp->ub_frame.rx_id = iocb->ulpContext;
2009 ubp->ub_frame.rx_id = iocb->ULPCONTEXT;
1857 ubp->ub_class = FC_TRAN_CLASS3;
1858
1859 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1860 "%s: sid=%x buffer=%p token=%x.", emlxs_elscmd_xlate(cmd), sid,
1861 ubp, ub_priv->token);
1862
1863#if (EMLXS_MODREVX == EMLXS_MODREV2X)
1864 emlxs_swap_els_ub(ubp);
1865#endif /* EMLXS_MODREV2X */
1866
1867 emlxs_ub_callback(port, ubp);
1868
1869drop_it:
1870
1871 return;
1872
2010 ubp->ub_class = FC_TRAN_CLASS3;
2011
2012 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
2013 "%s: sid=%x buffer=%p token=%x.", emlxs_elscmd_xlate(cmd), sid,
2014 ubp, ub_priv->token);
2015
2016#if (EMLXS_MODREVX == EMLXS_MODREV2X)
2017 emlxs_swap_els_ub(ubp);
2018#endif /* EMLXS_MODREV2X */
2019
2020 emlxs_ub_callback(port, ubp);
2021
2022drop_it:
2023
2024 return;
2025
1873} /* emlxs_handle_unsol_gen_cmd() */
2026} /* emlxs_handle_unsol_gen_cmd() */
1874
1875
1876/* This handles the reply completions to unsolicited cmds */
1877/* ARGSUSED */
1878static void
1879emlxs_handle_acc(emlxs_port_t *port, emlxs_buf_t *sbp, IOCBQ *iocbq,
1880 uint32_t flag)
1881{
2027
2028
2029/* This handles the reply completions to unsolicited cmds */
2030/* ARGSUSED */
2031static void
2032emlxs_handle_acc(emlxs_port_t *port, emlxs_buf_t *sbp, IOCBQ *iocbq,
2033 uint32_t flag)
2034{
2035 emlxs_hba_t *hba = HBA;
1882 fc_packet_t *pkt;
1883 IOCB *iocb;
1884 uint32_t did;
1885 NODELIST *ndlp;
1886 uint32_t ucmd;
1887 uint32_t cmd;
1888 uint32_t *lp;
1889
1890 iocb = &iocbq->iocb;
1891 pkt = PRIV2PKT(sbp);
2036 fc_packet_t *pkt;
2037 IOCB *iocb;
2038 uint32_t did;
2039 NODELIST *ndlp;
2040 uint32_t ucmd;
2041 uint32_t cmd;
2042 uint32_t *lp;
2043
2044 iocb = &iocbq->iocb;
2045 pkt = PRIV2PKT(sbp);
1892 did = SWAP_DATA24_LO(pkt->pkt_cmd_fhdr.d_id);
2046 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
1893 ucmd = pkt->pkt_cmd_fhdr.ox_id << ELS_CMD_SHIFT;
1894 lp = (uint32_t *)pkt->pkt_cmd;
1895 cmd = *lp & ELS_CMD_MASK;
1896
1897 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
1898 "%s %s: did=%x %s %s", emlxs_elscmd_xlate(ucmd),
2047 ucmd = pkt->pkt_cmd_fhdr.ox_id << ELS_CMD_SHIFT;
2048 lp = (uint32_t *)pkt->pkt_cmd;
2049 cmd = *lp & ELS_CMD_MASK;
2050
2051 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
2052 "%s %s: did=%x %s %s", emlxs_elscmd_xlate(ucmd),
1899 emlxs_elscmd_xlate(cmd), did, emlxs_state_xlate(iocb->ulpStatus),
2053 emlxs_elscmd_xlate(cmd), did, emlxs_state_xlate(iocb->ULPSTATUS),
1900 emlxs_error_xlate(iocb->un.grsp.perr.statLocalError));
1901
1902 switch (ucmd) {
1903 case ELS_CMD_PLOGI:
1904 case ELS_CMD_ADISC:
1905
1906 ndlp = emlxs_node_find_did(port, did);
1907
1908 if (ndlp && ndlp->nlp_active) {
1909 /* Open the node again */
2054 emlxs_error_xlate(iocb->un.grsp.perr.statLocalError));
2055
2056 switch (ucmd) {
2057 case ELS_CMD_PLOGI:
2058 case ELS_CMD_ADISC:
2059
2060 ndlp = emlxs_node_find_did(port, did);
2061
2062 if (ndlp && ndlp->nlp_active) {
2063 /* Open the node again */
1910 emlxs_node_open(port, ndlp, FC_FCP_RING);
1911 emlxs_node_open(port, ndlp, FC_IP_RING);
2064 emlxs_node_open(port, ndlp, hba->channel_fcp);
2065 emlxs_node_open(port, ndlp, hba->channel_ip);
1912 }
1913
1914 break;
1915
1916 case ELS_CMD_PRLI:
1917
1918 ndlp = emlxs_node_find_did(port, did);
1919
1920 if (ndlp && ndlp->nlp_active) {
1921 /* Open the node again */
2066 }
2067
2068 break;
2069
2070 case ELS_CMD_PRLI:
2071
2072 ndlp = emlxs_node_find_did(port, did);
2073
2074 if (ndlp && ndlp->nlp_active) {
2075 /* Open the node again */
1922 emlxs_node_open(port, ndlp, FC_FCP_RING);
2076 emlxs_node_open(port, ndlp, hba->channel_fcp);
1923 }
1924
1925 break;
1926 }
1927
2077 }
2078
2079 break;
2080 }
2081
1928 emlxs_pkt_complete(sbp, iocb->ulpStatus,
2082 emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
1929 iocb->un.grsp.perr.statLocalError, 1);
1930
1931 return;
1932
2083 iocb->un.grsp.perr.statLocalError, 1);
2084
2085 return;
2086
1933} /* emlxs_handle_acc() */
2087} /* emlxs_handle_acc() */
1934
1935
1936/* This handles the reply completions to unsolicited cmds */
1937/* ARGSUSED */
1938static void
1939emlxs_handle_reject(emlxs_port_t *port, emlxs_buf_t *sbp, IOCBQ *iocbq,
1940 uint32_t flag)
1941{
2088
2089
2090/* This handles the reply completions to unsolicited cmds */
2091/* ARGSUSED */
2092static void
2093emlxs_handle_reject(emlxs_port_t *port, emlxs_buf_t *sbp, IOCBQ *iocbq,
2094 uint32_t flag)
2095{
2096 emlxs_hba_t *hba = HBA;
1942 fc_packet_t *pkt;
1943 NODELIST *ndlp;
1944 IOCB *iocb;
1945 uint32_t did;
1946 uint32_t ucmd;
1947 uint32_t cmd;
1948 uint32_t *lp;
1949
1950 iocb = &iocbq->iocb;
1951 pkt = PRIV2PKT(sbp);
2097 fc_packet_t *pkt;
2098 NODELIST *ndlp;
2099 IOCB *iocb;
2100 uint32_t did;
2101 uint32_t ucmd;
2102 uint32_t cmd;
2103 uint32_t *lp;
2104
2105 iocb = &iocbq->iocb;
2106 pkt = PRIV2PKT(sbp);
1952 did = SWAP_DATA24_LO(pkt->pkt_cmd_fhdr.d_id);
2107 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
1953 ucmd = pkt->pkt_cmd_fhdr.ox_id << ELS_CMD_SHIFT;
1954 lp = (uint32_t *)pkt->pkt_cmd;
1955 cmd = *lp & ELS_CMD_MASK;
1956
1957 ndlp = emlxs_node_find_did(port, did);
1958
1959 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
1960 "%s %s: did=%x %s %s", emlxs_elscmd_xlate(ucmd),
2108 ucmd = pkt->pkt_cmd_fhdr.ox_id << ELS_CMD_SHIFT;
2109 lp = (uint32_t *)pkt->pkt_cmd;
2110 cmd = *lp & ELS_CMD_MASK;
2111
2112 ndlp = emlxs_node_find_did(port, did);
2113
2114 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
2115 "%s %s: did=%x %s %s", emlxs_elscmd_xlate(ucmd),
1961 emlxs_elscmd_xlate(cmd), did, emlxs_state_xlate(iocb->ulpStatus),
2116 emlxs_elscmd_xlate(cmd), did, emlxs_state_xlate(iocb->ULPSTATUS),
1962 emlxs_error_xlate(iocb->un.grsp.perr.statLocalError));
1963
1964 switch (ucmd) {
1965 case ELS_CMD_PLOGI:
1966
1967 if (ndlp && ndlp->nlp_active) {
1968 /* Open the node again */
2117 emlxs_error_xlate(iocb->un.grsp.perr.statLocalError));
2118
2119 switch (ucmd) {
2120 case ELS_CMD_PLOGI:
2121
2122 if (ndlp && ndlp->nlp_active) {
2123 /* Open the node again */
1969 emlxs_node_open(port, ndlp, FC_FCP_RING);
1970 emlxs_node_open(port, ndlp, FC_IP_RING);
2124 emlxs_node_open(port, ndlp, hba->channel_fcp);
2125 emlxs_node_open(port, ndlp, hba->channel_ip);
1971 }
1972
1973 break;
1974
1975 case ELS_CMD_PRLI:
1976
1977 if (ndlp && ndlp->nlp_active) {
1978 /* Open the node again */
2126 }
2127
2128 break;
2129
2130 case ELS_CMD_PRLI:
2131
2132 if (ndlp && ndlp->nlp_active) {
2133 /* Open the node again */
1979 emlxs_node_open(port, ndlp, FC_FCP_RING);
2134 emlxs_node_open(port, ndlp, hba->channel_fcp);
1980 }
1981
1982 break;
1983 }
1984
2135 }
2136
2137 break;
2138 }
2139
1985 emlxs_pkt_complete(sbp, iocb->ulpStatus,
2140 emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
1986 iocb->un.grsp.perr.statLocalError, 1);
1987
1988 return;
1989
2141 iocb->un.grsp.perr.statLocalError, 1);
2142
2143 return;
2144
1990} /* emlxs_handle_reject() */
2145} /* emlxs_handle_reject() */
1991
1992
1993/* ARGSUSED */
1994extern int32_t
1995emlxs_els_reply(emlxs_port_t *port, IOCBQ *iocbq, uint32_t type,
1996 uint32_t type2, uint32_t reason, uint32_t explain)
1997{
1998 emlxs_hba_t *hba = HBA;

--- 50 unchanged lines hidden (view full) ---

2049 return (1);
2050 }
2051 }
2052
2053 /* Common initialization */
2054 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
2055 pkt->pkt_timeout = (2 * hba->fc_ratov);
2056
2146
2147
2148/* ARGSUSED */
2149extern int32_t
2150emlxs_els_reply(emlxs_port_t *port, IOCBQ *iocbq, uint32_t type,
2151 uint32_t type2, uint32_t reason, uint32_t explain)
2152{
2153 emlxs_hba_t *hba = HBA;

--- 50 unchanged lines hidden (view full) ---

2204 return (1);
2205 }
2206 }
2207
2208 /* Common initialization */
2209 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
2210 pkt->pkt_timeout = (2 * hba->fc_ratov);
2211
2057 if ((uint32_t)iocb->ulpClass == CLASS2) {
2212 if ((uint32_t)iocb->ULPCLASS == CLASS2) {
2058 pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
2059 pkt->pkt_tran_flags |= FC_TRAN_CLASS2;
2060 }
2061
2062 /* Build the fc header */
2063 pkt->pkt_cmd_fhdr.d_id =
2213 pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
2214 pkt->pkt_tran_flags |= FC_TRAN_CLASS2;
2215 }
2216
2217 /* Build the fc header */
2218 pkt->pkt_cmd_fhdr.d_id =
2064 SWAP_DATA24_LO(iocb->un.elsreq.remoteID);
2219 LE_SWAP24_LO(iocb->un.elsreq.remoteID);
2065 pkt->pkt_cmd_fhdr.r_ctl =
2066 R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
2220 pkt->pkt_cmd_fhdr.r_ctl =
2221 R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
2067 pkt->pkt_cmd_fhdr.s_id = SWAP_DATA24_LO(iocb->un.elsreq.myID);
2222 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
2068 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
2069 pkt->pkt_cmd_fhdr.f_ctl =
2070 F_CTL_XCHG_CONTEXT | F_CTL_LAST_SEQ | F_CTL_END_SEQ;
2071 pkt->pkt_cmd_fhdr.seq_id = 0;
2072 pkt->pkt_cmd_fhdr.df_ctl = 0;
2073 pkt->pkt_cmd_fhdr.seq_cnt = 0;
2074 pkt->pkt_cmd_fhdr.ox_id = (type2 >> ELS_CMD_SHIFT) & 0xff;
2223 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
2224 pkt->pkt_cmd_fhdr.f_ctl =
2225 F_CTL_XCHG_CONTEXT | F_CTL_LAST_SEQ | F_CTL_END_SEQ;
2226 pkt->pkt_cmd_fhdr.seq_id = 0;
2227 pkt->pkt_cmd_fhdr.df_ctl = 0;
2228 pkt->pkt_cmd_fhdr.seq_cnt = 0;
2229 pkt->pkt_cmd_fhdr.ox_id = (type2 >> ELS_CMD_SHIFT) & 0xff;
2075 pkt->pkt_cmd_fhdr.rx_id = iocb->ulpContext;
2230 pkt->pkt_cmd_fhdr.rx_id = iocb->ULPCONTEXT;
2076 pkt->pkt_cmd_fhdr.ro = 0;
2077
2078 /*
2079 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
2080 * "%s ACC send. oxid=%x", emlxs_elscmd_xlate(type2),
2081 * pkt->pkt_cmd_fhdr.ox_id);
2082 */
2083

--- 6 unchanged lines hidden (view full) ---

2090 case ELS_CMD_ADISC:
2091
2092 els->un.adisc.hardAL_PA =
2093 (uint8_t)cfg[CFG_ASSIGN_ALPA].current;
2094 bcopy(&port->wwnn, &els->un.adisc.nodeName,
2095 sizeof (NAME_TYPE));
2096 bcopy(&port->wwpn, &els->un.adisc.portName,
2097 sizeof (NAME_TYPE));
2231 pkt->pkt_cmd_fhdr.ro = 0;
2232
2233 /*
2234 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
2235 * "%s ACC send. oxid=%x", emlxs_elscmd_xlate(type2),
2236 * pkt->pkt_cmd_fhdr.ox_id);
2237 */
2238

--- 6 unchanged lines hidden (view full) ---

2245 case ELS_CMD_ADISC:
2246
2247 els->un.adisc.hardAL_PA =
2248 (uint8_t)cfg[CFG_ASSIGN_ALPA].current;
2249 bcopy(&port->wwnn, &els->un.adisc.nodeName,
2250 sizeof (NAME_TYPE));
2251 bcopy(&port->wwpn, &els->un.adisc.portName,
2252 sizeof (NAME_TYPE));
2098 els->un.adisc.DID = SWAP_DATA24_LO(port->did);
2253 els->un.adisc.DID = LE_SWAP24_LO(port->did);
2099
2100 break;
2101
2102 case ELS_CMD_PRLI:
2103
2104 els->elsByte1 = 0x10;
2105 els->elsByte2 = 0;
2106 els->elsByte3 = 0x14;

--- 44 unchanged lines hidden (view full) ---

2151 if (!(pkt = emlxs_pkt_alloc(port,
2152 sizeof (uint32_t) + sizeof (LS_RJT), 0, 0, KM_NOSLEEP))) {
2153 return (1);
2154 }
2155
2156 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
2157 pkt->pkt_timeout = (2 * hba->fc_ratov);
2158
2254
2255 break;
2256
2257 case ELS_CMD_PRLI:
2258
2259 els->elsByte1 = 0x10;
2260 els->elsByte2 = 0;
2261 els->elsByte3 = 0x14;

--- 44 unchanged lines hidden (view full) ---

2306 if (!(pkt = emlxs_pkt_alloc(port,
2307 sizeof (uint32_t) + sizeof (LS_RJT), 0, 0, KM_NOSLEEP))) {
2308 return (1);
2309 }
2310
2311 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
2312 pkt->pkt_timeout = (2 * hba->fc_ratov);
2313
2159 if ((uint32_t)iocb->ulpClass == CLASS2) {
2314 if ((uint32_t)iocb->ULPCLASS == CLASS2) {
2160 pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
2161 pkt->pkt_tran_flags |= FC_TRAN_CLASS2;
2162 }
2163
2164 /* Build the fc header */
2165 pkt->pkt_cmd_fhdr.d_id =
2315 pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
2316 pkt->pkt_tran_flags |= FC_TRAN_CLASS2;
2317 }
2318
2319 /* Build the fc header */
2320 pkt->pkt_cmd_fhdr.d_id =
2166 SWAP_DATA24_LO(iocb->un.elsreq.remoteID);
2321 LE_SWAP24_LO(iocb->un.elsreq.remoteID);
2167 pkt->pkt_cmd_fhdr.r_ctl =
2168 R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
2322 pkt->pkt_cmd_fhdr.r_ctl =
2323 R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
2169 pkt->pkt_cmd_fhdr.s_id = SWAP_DATA24_LO(iocb->un.elsreq.myID);
2324 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
2170 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
2171 pkt->pkt_cmd_fhdr.f_ctl =
2172 F_CTL_XCHG_CONTEXT | F_CTL_LAST_SEQ | F_CTL_END_SEQ;
2173 pkt->pkt_cmd_fhdr.seq_id = 0;
2174 pkt->pkt_cmd_fhdr.df_ctl = 0;
2175 pkt->pkt_cmd_fhdr.seq_cnt = 0;
2176 pkt->pkt_cmd_fhdr.ox_id = (type2 >> ELS_CMD_SHIFT) & 0xff;
2325 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
2326 pkt->pkt_cmd_fhdr.f_ctl =
2327 F_CTL_XCHG_CONTEXT | F_CTL_LAST_SEQ | F_CTL_END_SEQ;
2328 pkt->pkt_cmd_fhdr.seq_id = 0;
2329 pkt->pkt_cmd_fhdr.df_ctl = 0;
2330 pkt->pkt_cmd_fhdr.seq_cnt = 0;
2331 pkt->pkt_cmd_fhdr.ox_id = (type2 >> ELS_CMD_SHIFT) & 0xff;
2177 pkt->pkt_cmd_fhdr.rx_id = iocb->ulpContext;
2332 pkt->pkt_cmd_fhdr.rx_id = iocb->ULPCONTEXT;
2178 pkt->pkt_cmd_fhdr.ro = 0;
2179
2180 /*
2181 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
2182 * "%s LS_RJT send. oxid=%x", emlxs_elscmd_xlate(type2),
2183 * pkt->pkt_cmd_fhdr.ox_id);
2184 */
2185

--- 10 unchanged lines hidden (view full) ---

2196
2197 if ((rval = emlxs_pkt_send(pkt, 1)) != FC_SUCCESS) {
2198 /* Free the pkt */
2199 emlxs_pkt_free(pkt);
2200 }
2201
2202 return (rval);
2203
2333 pkt->pkt_cmd_fhdr.ro = 0;
2334
2335 /*
2336 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
2337 * "%s LS_RJT send. oxid=%x", emlxs_elscmd_xlate(type2),
2338 * pkt->pkt_cmd_fhdr.ox_id);
2339 */
2340

--- 10 unchanged lines hidden (view full) ---

2351
2352 if ((rval = emlxs_pkt_send(pkt, 1)) != FC_SUCCESS) {
2353 /* Free the pkt */
2354 emlxs_pkt_free(pkt);
2355 }
2356
2357 return (rval);
2358
2204} /* emlxs_els_reply() */
2359} /* emlxs_els_reply() */
2205
2206
2207#ifdef ULP_PATCH6
2208
2209extern uint32_t
2210emlxs_generate_rscn(emlxs_port_t *port, uint32_t d_id)
2211{
2212 fc_unsol_buf_t *ubp;

--- 17 unchanged lines hidden (view full) ---

2230 rscn->rscn_len = 0x04;
2231 rscn->rscn_payload_len = 0x0008;
2232 page = ((uint32_t *)rscn);
2233 page++;
2234 *page = d_id;
2235
2236#ifdef EMLXS_I386
2237 /* Put payload in BE format */
2360
2361
2362#ifdef ULP_PATCH6
2363
2364extern uint32_t
2365emlxs_generate_rscn(emlxs_port_t *port, uint32_t d_id)
2366{
2367 fc_unsol_buf_t *ubp;

--- 17 unchanged lines hidden (view full) ---

2385 rscn->rscn_len = 0x04;
2386 rscn->rscn_payload_len = 0x0008;
2387 page = ((uint32_t *)rscn);
2388 page++;
2389 *page = d_id;
2390
2391#ifdef EMLXS_I386
2392 /* Put payload in BE format */
2238 rscn->rscn_payload_len = SWAP_DATA16(rscn->rscn_payload_len);
2239 *page = SWAP_DATA32(d_id);
2393 rscn->rscn_payload_len = LE_SWAP16(rscn->rscn_payload_len);
2394 *page = LE_SWAP32(d_id);
2240#endif /* EMLXS_I386 */
2241
2242 ub_priv = ubp->ub_fca_private;
2243 ub_priv->cmd = ELS_CMD_RSCN;
2244 ub_priv->flags |= EMLXS_UB_INTERCEPT;
2245
2246 ubp->ub_frame.r_ctl = FC_ELS_REQ;
2247 ubp->ub_frame.type = FC_ELS_DATA;
2248 ubp->ub_frame.s_id = 0xfffffd;
2395#endif /* EMLXS_I386 */
2396
2397 ub_priv = ubp->ub_fca_private;
2398 ub_priv->cmd = ELS_CMD_RSCN;
2399 ub_priv->flags |= EMLXS_UB_INTERCEPT;
2400
2401 ubp->ub_frame.r_ctl = FC_ELS_REQ;
2402 ubp->ub_frame.type = FC_ELS_DATA;
2403 ubp->ub_frame.s_id = 0xfffffd;
2249 ubp->ub_frame.d_id = SWAP_DATA24_LO(port->did);
2404 ubp->ub_frame.d_id = LE_SWAP24_LO(port->did);
2250 ubp->ub_frame.ox_id = ub_priv->token;
2251 ubp->ub_frame.rx_id = 0xffff;
2252 ubp->ub_class = FC_TRAN_CLASS3;
2253
2254 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
2255 "RSCN: sid=fffffd 1 page(s): %08X, 00000000 buffer=%p "
2256 "token=%x. Created.", d_id, ubp, ub_priv->token);
2257
2258#if (EMLXS_MODREVX == EMLXS_MODREV2X)
2259 emlxs_swap_els_ub(ubp);
2260#endif /* EMLXS_MODREV2X */
2261
2262 emlxs_ub_callback(port, ubp);
2263
2264 return (FC_SUCCESS);
2265
2405 ubp->ub_frame.ox_id = ub_priv->token;
2406 ubp->ub_frame.rx_id = 0xffff;
2407 ubp->ub_class = FC_TRAN_CLASS3;
2408
2409 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
2410 "RSCN: sid=fffffd 1 page(s): %08X, 00000000 buffer=%p "
2411 "token=%x. Created.", d_id, ubp, ub_priv->token);
2412
2413#if (EMLXS_MODREVX == EMLXS_MODREV2X)
2414 emlxs_swap_els_ub(ubp);
2415#endif /* EMLXS_MODREV2X */
2416
2417 emlxs_ub_callback(port, ubp);
2418
2419 return (FC_SUCCESS);
2420
2266} /* emlxs_generate_rscn() */
2421} /* emlxs_generate_rscn() */
2267
2268#endif /* ULP_PATCH6 */
2269
2270
2271#ifdef MENLO_SUPPORT
2272extern int
2422
2423#endif /* ULP_PATCH6 */
2424
2425
2426#ifdef MENLO_SUPPORT
2427extern int
2273emlxs_menlo_handle_event(emlxs_hba_t *hba, RING *rp, IOCBQ *iocbq)
2428emlxs_menlo_handle_event(emlxs_hba_t *hba, CHANNEL *cp, IOCBQ *iocbq)
2274{
2275 emlxs_port_t *port = &PPORT;
2276 IOCB *iocb;
2277 emlxs_buf_t *sbp;
2278 fc_packet_t *pkt;
2279 uint32_t cmd_code = 0;
2280 uint32_t rsp_code = 0;
2281 menlo_cmd_t *cmd;

--- 8 unchanged lines hidden (view full) ---

2290 if (!sbp) {
2291 /*
2292 * completion with missing xmit command
2293 */
2294 HBASTATS.CtStray++;
2295
2296 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_ct_completion_msg,
2297 "iocbq=%p cmd=0x%x iotag=0x%x status=0x%x perr=0x%x",
2429{
2430 emlxs_port_t *port = &PPORT;
2431 IOCB *iocb;
2432 emlxs_buf_t *sbp;
2433 fc_packet_t *pkt;
2434 uint32_t cmd_code = 0;
2435 uint32_t rsp_code = 0;
2436 menlo_cmd_t *cmd;

--- 8 unchanged lines hidden (view full) ---

2445 if (!sbp) {
2446 /*
2447 * completion with missing xmit command
2448 */
2449 HBASTATS.CtStray++;
2450
2451 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_ct_completion_msg,
2452 "iocbq=%p cmd=0x%x iotag=0x%x status=0x%x perr=0x%x",
2298 iocbq, (uint32_t)iocb->ulpCommand,
2299 (uint32_t)iocb->ulpIoTag, iocb->ulpStatus,
2453 iocbq, (uint32_t)iocb->ULPCOMMAND,
2454 (uint32_t)iocb->ULPIOTAG, iocb->ULPSTATUS,
2300 iocb->un.ulpWord[4]);
2301
2302 return (1);
2303 }
2304
2455 iocb->un.ulpWord[4]);
2456
2457 return (1);
2458 }
2459
2305 if (rp->ringno != FC_CT_RING) {
2460 if (cp->channelno != hba->channel_ct) {
2306 HBASTATS.CtStray++;
2307
2308 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_ct_completion_msg,
2461 HBASTATS.CtStray++;
2462
2463 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_ct_completion_msg,
2309 "Invalid ring: ring=%d iocbq=%p", rp->ringno, iocbq);
2464 "Invalid IO channel:%d iocbq=%p", cp->channelno, iocbq);
2310
2311 return (1);
2312 }
2313
2314 port = sbp->iocbq.port;
2315 pkt = PRIV2PKT(sbp);
2316
2317 cmd = (menlo_cmd_t *)pkt->pkt_cmd;
2465
2466 return (1);
2467 }
2468
2469 port = sbp->iocbq.port;
2470 pkt = PRIV2PKT(sbp);
2471
2472 cmd = (menlo_cmd_t *)pkt->pkt_cmd;
2318 cmd_code = SWAP_LONG(cmd->code);
2473 cmd_code = BE_SWAP32(cmd->code);
2319
2320 /* Check if a response buffer was provided */
2321 if (pkt->pkt_rsplen) {
2474
2475 /* Check if a response buffer was provided */
2476 if (pkt->pkt_rsplen) {
2322 emlxs_mpdata_sync(pkt->pkt_resp_dma, 0, pkt->pkt_rsplen,
2477 EMLXS_MPDATA_SYNC(pkt->pkt_resp_dma, 0, pkt->pkt_rsplen,
2323 DDI_DMA_SYNC_FORKERNEL);
2324 }
2325
2478 DDI_DMA_SYNC_FORKERNEL);
2479 }
2480
2326 switch (iocb->ulpCommand) {
2481 switch (iocb->ULPCOMMAND) {
2327 /*
2328 * MENLO Command completion
2329 */
2330 case CMD_GEN_REQUEST64_CR:
2331 case CMD_GEN_REQUEST64_CX:
2332
2333 HBASTATS.CtCmdCompleted++;
2334
2335 sbp->pkt_flags |= PACKET_CT_RSP_VALID;
2336
2337 rsp = (uint32_t *)pkt->pkt_resp;
2338 rsp_code = *rsp;
2482 /*
2483 * MENLO Command completion
2484 */
2485 case CMD_GEN_REQUEST64_CR:
2486 case CMD_GEN_REQUEST64_CX:
2487
2488 HBASTATS.CtCmdCompleted++;
2489
2490 sbp->pkt_flags |= PACKET_CT_RSP_VALID;
2491
2492 rsp = (uint32_t *)pkt->pkt_resp;
2493 rsp_code = *rsp;
2339 rsp_code = SWAP_LONG(rsp_code);
2494 rsp_code = BE_SWAP32(rsp_code);
2340
2495
2341#ifdef SLI3_SUPPORT
2342 if (hba->sli_mode >= 3) {
2496 if (hba->sli_mode == EMLXS_HBA_SLI3_MODE) {
2343 pkt->pkt_resp_resid =
2344 pkt->pkt_rsplen - iocb->unsli3.ext_iocb.rsplen;
2345 } else
2497 pkt->pkt_resp_resid =
2498 pkt->pkt_rsplen - iocb->unsli3.ext_iocb.rsplen;
2499 } else
2346#endif /* SLI3_SUPPORT */
2347 {
2348 pkt->pkt_resp_resid =
2349 pkt->pkt_rsplen - iocb->un.genreq64.bdl.bdeSize;
2350 }
2351
2352 pkt->pkt_data_resid = pkt->pkt_datalen;
2500 {
2501 pkt->pkt_resp_resid =
2502 pkt->pkt_rsplen - iocb->un.genreq64.bdl.bdeSize;
2503 }
2504
2505 pkt->pkt_data_resid = pkt->pkt_datalen;
2353 pkt->pkt_cmd_fhdr.rx_id = iocb->ulpContext;
2506 pkt->pkt_cmd_fhdr.rx_id = iocb->ULPCONTEXT;
2354
2507
2355 if ((iocb->ulpStatus == 0) && (rsp_code == MENLO_RSP_SUCCESS)) {
2508 if ((iocb->ULPSTATUS == 0) && (rsp_code == MENLO_RSP_SUCCESS)) {
2356 HBASTATS.CtCmdGood++;
2357
2358 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
2359 "%s: %s rxid=0x%x",
2360 emlxs_menlo_cmd_xlate(cmd_code),
2361 emlxs_menlo_rsp_xlate(rsp_code),
2509 HBASTATS.CtCmdGood++;
2510
2511 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
2512 "%s: %s rxid=0x%x",
2513 emlxs_menlo_cmd_xlate(cmd_code),
2514 emlxs_menlo_rsp_xlate(rsp_code),
2362 iocb->ulpContext);
2515 iocb->ULPCONTEXT);
2363
2364 } else {
2365 HBASTATS.CtCmdError++;
2366
2367 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
2368 "%s: %s %s %s rxid=0x%x",
2369 emlxs_menlo_cmd_xlate(cmd_code),
2370 emlxs_menlo_rsp_xlate(rsp_code),
2516
2517 } else {
2518 HBASTATS.CtCmdError++;
2519
2520 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
2521 "%s: %s %s %s rxid=0x%x",
2522 emlxs_menlo_cmd_xlate(cmd_code),
2523 emlxs_menlo_rsp_xlate(rsp_code),
2371 emlxs_state_xlate(iocb->ulpStatus),
2524 emlxs_state_xlate(iocb->ULPSTATUS),
2372 emlxs_error_xlate(iocb->un.grsp.perr.
2525 emlxs_error_xlate(iocb->un.grsp.perr.
2373 statLocalError), iocb->ulpContext);
2526 statLocalError), iocb->ULPCONTEXT);
2374 }
2375
2527 }
2528
2376 emlxs_pkt_complete(sbp, iocb->ulpStatus,
2529 emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
2377 iocb->un.grsp.perr.statLocalError, 1);
2378
2379 break;
2380
2381 default:
2382
2383 HBASTATS.CtStray++;
2384
2385 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_invalid_ct_msg,
2530 iocb->un.grsp.perr.statLocalError, 1);
2531
2532 break;
2533
2534 default:
2535
2536 HBASTATS.CtStray++;
2537
2538 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_invalid_ct_msg,
2386 "Invalid iocb: cmd=0x%x", iocb->ulpCommand);
2539 "Invalid iocb: cmd=0x%x", iocb->ULPCOMMAND);
2387
2540
2388 emlxs_pkt_complete(sbp, iocb->ulpStatus,
2541 emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
2389 iocb->un.grsp.perr.statLocalError, 1);
2390
2391 break;
2392
2542 iocb->un.grsp.perr.statLocalError, 1);
2543
2544 break;
2545
2393 } /* switch(iocb->ulpCommand) */
2546 } /* switch(iocb->ULPCOMMAND) */
2394
2395 return (0);
2396
2547
2548 return (0);
2549
2397} /* emlxs_menlo_handle_event() */
2550} /* emlxs_menlo_handle_event() */
2398
2399#endif /* MENLO_SUPPORT */
2400
2401
2402extern int
2551
2552#endif /* MENLO_SUPPORT */
2553
2554
2555extern int
2403emlxs_ct_handle_event(emlxs_hba_t *hba, RING *rp, IOCBQ *iocbq)
2556emlxs_ct_handle_event(emlxs_hba_t *hba, CHANNEL *cp, IOCBQ *iocbq)
2404{
2405 emlxs_port_t *port = &PPORT;
2406 IOCB *iocb;
2407 emlxs_buf_t *sbp;
2408 fc_packet_t *pkt;
2409 uint32_t *rsp;
2410 SLI_CT_REQUEST *CtRsp;
2411 SLI_CT_REQUEST *CtCmd;

--- 9 unchanged lines hidden (view full) ---

2421 if (!sbp) {
2422 /*
2423 * completion with missing xmit command
2424 */
2425 HBASTATS.CtStray++;
2426
2427 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_ct_completion_msg,
2428 "iocbq=%p cmd=0x%x iotag=0x%x status=0x%x perr=0x%x",
2557{
2558 emlxs_port_t *port = &PPORT;
2559 IOCB *iocb;
2560 emlxs_buf_t *sbp;
2561 fc_packet_t *pkt;
2562 uint32_t *rsp;
2563 SLI_CT_REQUEST *CtRsp;
2564 SLI_CT_REQUEST *CtCmd;

--- 9 unchanged lines hidden (view full) ---

2574 if (!sbp) {
2575 /*
2576 * completion with missing xmit command
2577 */
2578 HBASTATS.CtStray++;
2579
2580 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_ct_completion_msg,
2581 "iocbq=%p cmd=0x%x iotag=0x%x status=0x%x perr=0x%x",
2429 iocbq, (uint32_t)iocb->ulpCommand,
2430 (uint32_t)iocb->ulpIoTag, iocb->ulpStatus,
2582 iocbq, (uint32_t)iocb->ULPCOMMAND,
2583 (uint32_t)iocb->ULPIOTAG, iocb->ULPSTATUS,
2431 iocb->un.ulpWord[4]);
2432
2433 return (1);
2434 }
2435
2584 iocb->un.ulpWord[4]);
2585
2586 return (1);
2587 }
2588
2436 if (rp->ringno != FC_CT_RING) {
2589 if (cp->channelno != hba->channel_ct) {
2437 HBASTATS.CtStray++;
2438
2439 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_ct_completion_msg,
2590 HBASTATS.CtStray++;
2591
2592 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_stray_ct_completion_msg,
2440 "Invalid ring: ring=%d iocbq=%p", rp->ringno, iocbq);
2593 "Invalid channel: channel=%d iocbq=%p", cp->channelno,
2594 iocbq);
2441
2442 return (1);
2443 }
2444
2445 pkt = PRIV2PKT(sbp);
2446 port = sbp->iocbq.port;
2447 CtCmd = (SLI_CT_REQUEST *)pkt->pkt_cmd;
2595
2596 return (1);
2597 }
2598
2599 pkt = PRIV2PKT(sbp);
2600 port = sbp->iocbq.port;
2601 CtCmd = (SLI_CT_REQUEST *)pkt->pkt_cmd;
2448 cmd_code = SWAP_DATA16(CtCmd->CommandResponse.bits.CmdRsp);
2602 cmd_code = LE_SWAP16(CtCmd->CommandResponse.bits.CmdRsp);
2449
2603
2450#ifdef DFC_SUPPORT
2451 if (cmd_code == SLI_CT_LOOPBACK) {
2452 HBASTATS.CtEvent--;
2604 if (cmd_code == SLI_CT_LOOPBACK) {
2605 HBASTATS.CtEvent--;
2453 return (emlxs_dfc_handle_event(hba, rp, iocbq));
2606 return (emlxs_dfc_handle_event(hba, cp, iocbq));
2454 }
2607 }
2455#endif /* DFC_SUPPORT */
2456
2457 /* Check if a response buffer was provided */
2458 if (pkt->pkt_rsplen) {
2608
2609 /* Check if a response buffer was provided */
2610 if (pkt->pkt_rsplen) {
2459 emlxs_mpdata_sync(pkt->pkt_resp_dma, 0, pkt->pkt_rsplen,
2611 EMLXS_MPDATA_SYNC(pkt->pkt_resp_dma, 0, pkt->pkt_rsplen,
2460 DDI_DMA_SYNC_FORKERNEL);
2461 }
2462
2612 DDI_DMA_SYNC_FORKERNEL);
2613 }
2614
2463 switch (iocb->ulpCommand) {
2615 switch (iocb->ULPCOMMAND) {
2464 /*
2465 * CT Reply completion
2466 */
2467 case CMD_XMIT_SEQUENCE_CX:
2468 case CMD_XMIT_SEQUENCE64_CX:
2469
2470 HBASTATS.CtRspCompleted++;
2471
2472 switch (CtCmd->FsType) {
2473 case 0xFC: /* Name server */
2474 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
2475 "%s: %s %s", emlxs_ctcmd_xlate(cmd_code),
2616 /*
2617 * CT Reply completion
2618 */
2619 case CMD_XMIT_SEQUENCE_CX:
2620 case CMD_XMIT_SEQUENCE64_CX:
2621
2622 HBASTATS.CtRspCompleted++;
2623
2624 switch (CtCmd->FsType) {
2625 case 0xFC: /* Name server */
2626 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
2627 "%s: %s %s", emlxs_ctcmd_xlate(cmd_code),
2476 emlxs_state_xlate(iocb->ulpStatus),
2628 emlxs_state_xlate(iocb->ULPSTATUS),
2477 emlxs_error_xlate(iocb->un.grsp.perr.
2478 statLocalError));
2479 break;
2480
2481 case 0xFA: /* Managment server */
2482 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
2483 "%s: %s %s", emlxs_mscmd_xlate(cmd_code),
2629 emlxs_error_xlate(iocb->un.grsp.perr.
2630 statLocalError));
2631 break;
2632
2633 case 0xFA: /* Managment server */
2634 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
2635 "%s: %s %s", emlxs_mscmd_xlate(cmd_code),
2484 emlxs_state_xlate(iocb->ulpStatus),
2636 emlxs_state_xlate(iocb->ULPSTATUS),
2485 emlxs_error_xlate(iocb->un.grsp.perr.
2486 statLocalError));
2487 break;
2488
2489 case 0x0A: /* Emulex Remote server */
2490 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
2491 "%s: %s %s", emlxs_rmcmd_xlate(cmd_code),
2637 emlxs_error_xlate(iocb->un.grsp.perr.
2638 statLocalError));
2639 break;
2640
2641 case 0x0A: /* Emulex Remote server */
2642 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
2643 "%s: %s %s", emlxs_rmcmd_xlate(cmd_code),
2492 emlxs_state_xlate(iocb->ulpStatus),
2644 emlxs_state_xlate(iocb->ULPSTATUS),
2493 emlxs_error_xlate(iocb->un.grsp.perr.
2494 statLocalError));
2495 break;
2496
2497 default:
2498 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
2499 "%s: %s %s", emlxs_ctcmd_xlate(cmd_code),
2645 emlxs_error_xlate(iocb->un.grsp.perr.
2646 statLocalError));
2647 break;
2648
2649 default:
2650 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
2651 "%s: %s %s", emlxs_ctcmd_xlate(cmd_code),
2500 emlxs_state_xlate(iocb->ulpStatus),
2652 emlxs_state_xlate(iocb->ULPSTATUS),
2501 emlxs_error_xlate(iocb->un.grsp.perr.
2502 statLocalError));
2503 }
2504
2653 emlxs_error_xlate(iocb->un.grsp.perr.
2654 statLocalError));
2655 }
2656
2505 emlxs_pkt_complete(sbp, iocb->ulpStatus,
2657 emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
2506 iocb->un.grsp.perr.statLocalError, 1);
2507
2508 break;
2509
2510 /*
2511 * CT Command completion
2512 */
2513 case CMD_GEN_REQUEST64_CR:
2514 case CMD_GEN_REQUEST64_CX:
2515
2516 HBASTATS.CtCmdCompleted++;
2517
2518 sbp->pkt_flags |= PACKET_CT_RSP_VALID;
2519
2520 rsp = (uint32_t *)pkt->pkt_resp;
2521 CtRsp = (SLI_CT_REQUEST *)pkt->pkt_resp;
2658 iocb->un.grsp.perr.statLocalError, 1);
2659
2660 break;
2661
2662 /*
2663 * CT Command completion
2664 */
2665 case CMD_GEN_REQUEST64_CR:
2666 case CMD_GEN_REQUEST64_CX:
2667
2668 HBASTATS.CtCmdCompleted++;
2669
2670 sbp->pkt_flags |= PACKET_CT_RSP_VALID;
2671
2672 rsp = (uint32_t *)pkt->pkt_resp;
2673 CtRsp = (SLI_CT_REQUEST *)pkt->pkt_resp;
2522 rsp_code = SWAP_DATA16(CtRsp->CommandResponse.bits.CmdRsp);
2674 rsp_code = LE_SWAP16(CtRsp->CommandResponse.bits.CmdRsp);
2523
2675
2524#ifdef SLI3_SUPPORT
2525 if (hba->sli_mode >= 3) {
2676 if (hba->sli_mode >= EMLXS_HBA_SLI3_MODE) {
2526 pkt->pkt_resp_resid =
2527 pkt->pkt_rsplen - iocb->unsli3.ext_iocb.rsplen;
2528 } else
2677 pkt->pkt_resp_resid =
2678 pkt->pkt_rsplen - iocb->unsli3.ext_iocb.rsplen;
2679 } else
2529#endif /* SLI3_SUPPORT */
2530 {
2531 pkt->pkt_resp_resid =
2532 pkt->pkt_rsplen - iocb->un.genreq64.bdl.bdeSize;
2533 }
2534
2535 pkt->pkt_data_resid = pkt->pkt_datalen;
2536
2537 /*
2538 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
2539 * "INFO: pkt_resid=%d %d %d %x", pkt->pkt_resp_resid,
2540 * pkt->pkt_rsplen, iocb->un.genreq64.bdl.bdeSize,
2541 * iocb->un.genreq64.bdl.bdeFlags);
2542 */
2543
2680 {
2681 pkt->pkt_resp_resid =
2682 pkt->pkt_rsplen - iocb->un.genreq64.bdl.bdeSize;
2683 }
2684
2685 pkt->pkt_data_resid = pkt->pkt_datalen;
2686
2687 /*
2688 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_completion_msg,
2689 * "INFO: pkt_resid=%d %d %d %x", pkt->pkt_resp_resid,
2690 * pkt->pkt_rsplen, iocb->un.genreq64.bdl.bdeSize,
2691 * iocb->un.genreq64.bdl.bdeFlags);
2692 */
2693
2544 if ((iocb->ulpStatus == 0) &&
2694 if ((iocb->ULPSTATUS == 0) &&
2545 (rsp_code == SLI_CT_RESPONSE_FS_ACC)) {
2546 HBASTATS.CtCmdGood++;
2547
2548 if (!(sbp->pkt_flags & PACKET_ALLOCATED)) {
2549 /* ULP patch - ULP expects */
2550 /* resp_resid = 0 on success */
2551 pkt->pkt_resp_resid = 0;
2552 }
2553
2554 switch (CtCmd->FsType) {
2555 case 0xFC: /* Name server */
2556 EMLXS_MSGF(EMLXS_CONTEXT,
2557 &emlxs_ct_completion_msg,
2558 "%s: %s: Rsn=%x Exp=%x [%08x,%08x]",
2559 emlxs_ctcmd_xlate(cmd_code),
2560 emlxs_ctcmd_xlate(rsp_code),
2561 CtRsp->ReasonCode, CtRsp->Explanation,
2695 (rsp_code == SLI_CT_RESPONSE_FS_ACC)) {
2696 HBASTATS.CtCmdGood++;
2697
2698 if (!(sbp->pkt_flags & PACKET_ALLOCATED)) {
2699 /* ULP patch - ULP expects */
2700 /* resp_resid = 0 on success */
2701 pkt->pkt_resp_resid = 0;
2702 }
2703
2704 switch (CtCmd->FsType) {
2705 case 0xFC: /* Name server */
2706 EMLXS_MSGF(EMLXS_CONTEXT,
2707 &emlxs_ct_completion_msg,
2708 "%s: %s: Rsn=%x Exp=%x [%08x,%08x]",
2709 emlxs_ctcmd_xlate(cmd_code),
2710 emlxs_ctcmd_xlate(rsp_code),
2711 CtRsp->ReasonCode, CtRsp->Explanation,
2562 SWAP_DATA32(rsp[4]), SWAP_DATA32(rsp[5]));
2712 LE_SWAP32(rsp[4]), LE_SWAP32(rsp[5]));
2563
2564#if (EMLXS_MODREV < EMLXS_MODREV4)
2565 if (cmd_code == SLI_CTNS_RNN_ID) {
2566 emlxs_send_rsnn(port);
2567 }
2568#endif /* < EMLXS_MODREV4 */
2569
2570 break;
2571
2572 case 0xFA: /* Managment server */
2573 EMLXS_MSGF(EMLXS_CONTEXT,
2574 &emlxs_ct_completion_msg,
2575 "%s: %s: Rsn=%x Exp=%x [%08x,%08x]",
2576 emlxs_mscmd_xlate(cmd_code),
2577 emlxs_mscmd_xlate(rsp_code),
2578 CtRsp->ReasonCode, CtRsp->Explanation,
2713
2714#if (EMLXS_MODREV < EMLXS_MODREV4)
2715 if (cmd_code == SLI_CTNS_RNN_ID) {
2716 emlxs_send_rsnn(port);
2717 }
2718#endif /* < EMLXS_MODREV4 */
2719
2720 break;
2721
2722 case 0xFA: /* Managment server */
2723 EMLXS_MSGF(EMLXS_CONTEXT,
2724 &emlxs_ct_completion_msg,
2725 "%s: %s: Rsn=%x Exp=%x [%08x,%08x]",
2726 emlxs_mscmd_xlate(cmd_code),
2727 emlxs_mscmd_xlate(rsp_code),
2728 CtRsp->ReasonCode, CtRsp->Explanation,
2579 SWAP_DATA32(rsp[4]), SWAP_DATA32(rsp[5]));
2729 LE_SWAP32(rsp[4]), LE_SWAP32(rsp[5]));
2580 break;
2581
2582 case 0x0A: /* Emulex Remote server */
2583 EMLXS_MSGF(EMLXS_CONTEXT,
2584 &emlxs_ct_completion_msg,
2585 "%s: %s: Rsn=%x Exp=%x [%08x,%08x]",
2586 emlxs_rmcmd_xlate(cmd_code),
2587 emlxs_rmcmd_xlate(rsp_code),
2588 CtRsp->ReasonCode, CtRsp->Explanation,
2730 break;
2731
2732 case 0x0A: /* Emulex Remote server */
2733 EMLXS_MSGF(EMLXS_CONTEXT,
2734 &emlxs_ct_completion_msg,
2735 "%s: %s: Rsn=%x Exp=%x [%08x,%08x]",
2736 emlxs_rmcmd_xlate(cmd_code),
2737 emlxs_rmcmd_xlate(rsp_code),
2738 CtRsp->ReasonCode, CtRsp->Explanation,
2589 SWAP_DATA32(rsp[4]), SWAP_DATA32(rsp[5]));
2739 LE_SWAP32(rsp[4]), LE_SWAP32(rsp[5]));
2590 break;
2591
2592 default:
2593 EMLXS_MSGF(EMLXS_CONTEXT,
2594 &emlxs_ct_completion_msg,
2595 "%s: %s: Rsn=%x Exp=%x [%08x,%08x]",
2596 emlxs_ctcmd_xlate(cmd_code),
2597 emlxs_ctcmd_xlate(rsp_code),
2598 CtRsp->ReasonCode, CtRsp->Explanation,
2740 break;
2741
2742 default:
2743 EMLXS_MSGF(EMLXS_CONTEXT,
2744 &emlxs_ct_completion_msg,
2745 "%s: %s: Rsn=%x Exp=%x [%08x,%08x]",
2746 emlxs_ctcmd_xlate(cmd_code),
2747 emlxs_ctcmd_xlate(rsp_code),
2748 CtRsp->ReasonCode, CtRsp->Explanation,
2599 SWAP_DATA32(rsp[4]), SWAP_DATA32(rsp[5]));
2749 LE_SWAP32(rsp[4]), LE_SWAP32(rsp[5]));
2600 }
2601 } else {
2602 HBASTATS.CtCmdError++;
2603
2604 if (rsp_code == SLI_CT_RESPONSE_FS_RJT) {
2605 pkt->pkt_state = FC_PKT_FS_RJT;
2606 pkt->pkt_action = FC_ACTION_RETRYABLE;
2607 pkt->pkt_reason = CtRsp->ReasonCode;
2608 pkt->pkt_expln = CtRsp->Explanation;
2609 sbp->pkt_flags |= PACKET_STATE_VALID;
2610
2611 EMLXS_MSGF(EMLXS_CONTEXT,
2612 &emlxs_ct_completion_msg,
2613 "%s: Rejected. rsn=%x exp=%x",
2614 emlxs_ctcmd_xlate(cmd_code),
2615 pkt->pkt_reason, pkt->pkt_expln);
2750 }
2751 } else {
2752 HBASTATS.CtCmdError++;
2753
2754 if (rsp_code == SLI_CT_RESPONSE_FS_RJT) {
2755 pkt->pkt_state = FC_PKT_FS_RJT;
2756 pkt->pkt_action = FC_ACTION_RETRYABLE;
2757 pkt->pkt_reason = CtRsp->ReasonCode;
2758 pkt->pkt_expln = CtRsp->Explanation;
2759 sbp->pkt_flags |= PACKET_STATE_VALID;
2760
2761 EMLXS_MSGF(EMLXS_CONTEXT,
2762 &emlxs_ct_completion_msg,
2763 "%s: Rejected. rsn=%x exp=%x",
2764 emlxs_ctcmd_xlate(cmd_code),
2765 pkt->pkt_reason, pkt->pkt_expln);
2616 } else if (iocb->ulpStatus == IOSTAT_LOCAL_REJECT) {
2766 } else if (iocb->ULPSTATUS == IOSTAT_LOCAL_REJECT) {
2617 switch (CtCmd->FsType) {
2618 case 0xFC: /* Name server */
2619 EMLXS_MSGF(EMLXS_CONTEXT,
2620 &emlxs_ct_completion_msg,
2621 "%s: %s %s",
2622 emlxs_ctcmd_xlate(cmd_code),
2623 emlxs_state_xlate(iocb->
2767 switch (CtCmd->FsType) {
2768 case 0xFC: /* Name server */
2769 EMLXS_MSGF(EMLXS_CONTEXT,
2770 &emlxs_ct_completion_msg,
2771 "%s: %s %s",
2772 emlxs_ctcmd_xlate(cmd_code),
2773 emlxs_state_xlate(iocb->
2624 ulpStatus),
2774 ULPSTATUS),
2625 emlxs_error_xlate(iocb->un.grsp.
2626 perr.statLocalError));
2627 break;
2628
2629 case 0xFA: /* Managment server */
2630 EMLXS_MSGF(EMLXS_CONTEXT,
2631 &emlxs_ct_completion_msg,
2632 "%s: %s %s",
2633 emlxs_mscmd_xlate(cmd_code),
2634 emlxs_state_xlate(iocb->
2775 emlxs_error_xlate(iocb->un.grsp.
2776 perr.statLocalError));
2777 break;
2778
2779 case 0xFA: /* Managment server */
2780 EMLXS_MSGF(EMLXS_CONTEXT,
2781 &emlxs_ct_completion_msg,
2782 "%s: %s %s",
2783 emlxs_mscmd_xlate(cmd_code),
2784 emlxs_state_xlate(iocb->
2635 ulpStatus),
2785 ULPSTATUS),
2636 emlxs_error_xlate(iocb->un.grsp.
2637 perr.statLocalError));
2638 break;
2639
2640 case 0x0A: /* Emulex Remote server */
2641 EMLXS_MSGF(EMLXS_CONTEXT,
2642 &emlxs_ct_completion_msg,
2643 "%s: %s %s",
2644 emlxs_rmcmd_xlate(cmd_code),
2645 emlxs_state_xlate(iocb->
2786 emlxs_error_xlate(iocb->un.grsp.
2787 perr.statLocalError));
2788 break;
2789
2790 case 0x0A: /* Emulex Remote server */
2791 EMLXS_MSGF(EMLXS_CONTEXT,
2792 &emlxs_ct_completion_msg,
2793 "%s: %s %s",
2794 emlxs_rmcmd_xlate(cmd_code),
2795 emlxs_state_xlate(iocb->
2646 ulpStatus),
2796 ULPSTATUS),
2647 emlxs_error_xlate(iocb->un.grsp.
2648 perr.statLocalError));
2649 break;
2650
2651 default:
2652 EMLXS_MSGF(EMLXS_CONTEXT,
2653 &emlxs_ct_completion_msg,
2654 "%s: %s %s",
2655 emlxs_ctcmd_xlate(cmd_code),
2656 emlxs_state_xlate(iocb->
2797 emlxs_error_xlate(iocb->un.grsp.
2798 perr.statLocalError));
2799 break;
2800
2801 default:
2802 EMLXS_MSGF(EMLXS_CONTEXT,
2803 &emlxs_ct_completion_msg,
2804 "%s: %s %s",
2805 emlxs_ctcmd_xlate(cmd_code),
2806 emlxs_state_xlate(iocb->
2657 ulpStatus),
2807 ULPSTATUS),
2658 emlxs_error_xlate(iocb->un.grsp.
2659 perr.statLocalError));
2660 }
2661 } else {
2662 switch (CtCmd->FsType) {
2663 case 0xFC: /* Name server */
2664 EMLXS_MSGF(EMLXS_CONTEXT,
2665 &emlxs_ct_completion_msg,
2666 "%s: %s (%02x%02x%02x%02x)",
2667 emlxs_ctcmd_xlate(cmd_code),
2668 emlxs_state_xlate(iocb->
2808 emlxs_error_xlate(iocb->un.grsp.
2809 perr.statLocalError));
2810 }
2811 } else {
2812 switch (CtCmd->FsType) {
2813 case 0xFC: /* Name server */
2814 EMLXS_MSGF(EMLXS_CONTEXT,
2815 &emlxs_ct_completion_msg,
2816 "%s: %s (%02x%02x%02x%02x)",
2817 emlxs_ctcmd_xlate(cmd_code),
2818 emlxs_state_xlate(iocb->
2669 ulpStatus),
2819 ULPSTATUS),
2670 iocb->un.grsp.perr.statAction,
2671 iocb->un.grsp.perr.statRsn,
2672 iocb->un.grsp.perr.statBaExp,
2673 iocb->un.grsp.perr.
2674 statLocalError);
2675 break;
2676
2677 case 0xFA: /* Managment server */
2678 EMLXS_MSGF(EMLXS_CONTEXT,
2679 &emlxs_ct_completion_msg,
2680 "%s: %s (%02x%02x%02x%02x)",
2681 emlxs_mscmd_xlate(cmd_code),
2682 emlxs_state_xlate(iocb->
2820 iocb->un.grsp.perr.statAction,
2821 iocb->un.grsp.perr.statRsn,
2822 iocb->un.grsp.perr.statBaExp,
2823 iocb->un.grsp.perr.
2824 statLocalError);
2825 break;
2826
2827 case 0xFA: /* Managment server */
2828 EMLXS_MSGF(EMLXS_CONTEXT,
2829 &emlxs_ct_completion_msg,
2830 "%s: %s (%02x%02x%02x%02x)",
2831 emlxs_mscmd_xlate(cmd_code),
2832 emlxs_state_xlate(iocb->
2683 ulpStatus),
2833 ULPSTATUS),
2684 iocb->un.grsp.perr.statAction,
2685 iocb->un.grsp.perr.statRsn,
2686 iocb->un.grsp.perr.statBaExp,
2687 iocb->un.grsp.perr.
2688 statLocalError);
2689 break;
2690
2691 case 0x0A: /* Emulex Remote server */
2692 EMLXS_MSGF(EMLXS_CONTEXT,
2693 &emlxs_ct_completion_msg,
2694 "%s: %s (%02x%02x%02x%02x)",
2695 emlxs_rmcmd_xlate(cmd_code),
2696 emlxs_state_xlate(iocb->
2834 iocb->un.grsp.perr.statAction,
2835 iocb->un.grsp.perr.statRsn,
2836 iocb->un.grsp.perr.statBaExp,
2837 iocb->un.grsp.perr.
2838 statLocalError);
2839 break;
2840
2841 case 0x0A: /* Emulex Remote server */
2842 EMLXS_MSGF(EMLXS_CONTEXT,
2843 &emlxs_ct_completion_msg,
2844 "%s: %s (%02x%02x%02x%02x)",
2845 emlxs_rmcmd_xlate(cmd_code),
2846 emlxs_state_xlate(iocb->
2697 ulpStatus),
2847 ULPSTATUS),
2698 iocb->un.grsp.perr.statAction,
2699 iocb->un.grsp.perr.statRsn,
2700 iocb->un.grsp.perr.statBaExp,
2701 iocb->un.grsp.perr.
2702 statLocalError);
2703 break;
2704
2705 default:
2706 EMLXS_MSGF(EMLXS_CONTEXT,
2707 &emlxs_ct_completion_msg,
2708 "%s: %s (%02x%02x%02x%02x)",
2709 emlxs_ctcmd_xlate(cmd_code),
2710 emlxs_state_xlate(iocb->
2848 iocb->un.grsp.perr.statAction,
2849 iocb->un.grsp.perr.statRsn,
2850 iocb->un.grsp.perr.statBaExp,
2851 iocb->un.grsp.perr.
2852 statLocalError);
2853 break;
2854
2855 default:
2856 EMLXS_MSGF(EMLXS_CONTEXT,
2857 &emlxs_ct_completion_msg,
2858 "%s: %s (%02x%02x%02x%02x)",
2859 emlxs_ctcmd_xlate(cmd_code),
2860 emlxs_state_xlate(iocb->
2711 ulpStatus),
2861 ULPSTATUS),
2712 iocb->un.grsp.perr.statAction,
2713 iocb->un.grsp.perr.statRsn,
2714 iocb->un.grsp.perr.statBaExp,
2715 iocb->un.grsp.perr.
2716 statLocalError);
2717 }
2718 }
2719 }
2720
2862 iocb->un.grsp.perr.statAction,
2863 iocb->un.grsp.perr.statRsn,
2864 iocb->un.grsp.perr.statBaExp,
2865 iocb->un.grsp.perr.
2866 statLocalError);
2867 }
2868 }
2869 }
2870
2721 emlxs_pkt_complete(sbp, iocb->ulpStatus,
2871 emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
2722 iocb->un.grsp.perr.statLocalError, 1);
2723
2724 break;
2725
2726 default:
2727
2728 HBASTATS.CtStray++;
2729
2730 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_invalid_ct_msg,
2872 iocb->un.grsp.perr.statLocalError, 1);
2873
2874 break;
2875
2876 default:
2877
2878 HBASTATS.CtStray++;
2879
2880 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_invalid_ct_msg,
2731 "Invalid iocb: cmd=0x%x", iocb->ulpCommand);
2881 "Invalid iocb: cmd=0x%x", iocb->ULPCOMMAND);
2732
2882
2733 emlxs_pkt_complete(sbp, iocb->ulpStatus,
2883 emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
2734 iocb->un.grsp.perr.statLocalError, 1);
2735
2736 break;
2884 iocb->un.grsp.perr.statLocalError, 1);
2885
2886 break;
2737 } /* switch(iocb->ulpCommand) */
2887 } /* switch(iocb->ULPCOMMAND) */
2738
2739 return (0);
2740
2888
2889 return (0);
2890
2741} /* emlxs_ct_handle_event() */
2891} /* emlxs_ct_handle_event() */
2742
2743
2744extern int
2892
2893
2894extern int
2745emlxs_ct_handle_unsol_req(emlxs_port_t *port, RING *rp, IOCBQ *iocbq,
2895emlxs_ct_handle_unsol_req(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
2746 MATCHMAP *mp, uint32_t size)
2747{
2748 emlxs_hba_t *hba = HBA;
2749 IOCB *iocb;
2750 SLI_CT_REQUEST *CtCmd;
2751 uint32_t cmd_code;
2752
2753 iocb = &iocbq->iocb;
2754
2755 CtCmd = (SLI_CT_REQUEST *)mp->virt;
2896 MATCHMAP *mp, uint32_t size)
2897{
2898 emlxs_hba_t *hba = HBA;
2899 IOCB *iocb;
2900 SLI_CT_REQUEST *CtCmd;
2901 uint32_t cmd_code;
2902
2903 iocb = &iocbq->iocb;
2904
2905 CtCmd = (SLI_CT_REQUEST *)mp->virt;
2756 cmd_code = SWAP_DATA16(CtCmd->CommandResponse.bits.CmdRsp);
2906 cmd_code = LE_SWAP16(CtCmd->CommandResponse.bits.CmdRsp);
2757
2907
2758#ifdef DFC_SUPPORT
2759 if (cmd_code == SLI_CT_LOOPBACK) {
2760 int rval;
2761
2908 if (cmd_code == SLI_CT_LOOPBACK) {
2909 int rval;
2910
2762 rval = emlxs_dfc_handle_unsol_req(port, rp, iocbq, mp, size);
2911 rval = emlxs_dfc_handle_unsol_req(port, cp, iocbq, mp, size);
2763
2764 return (rval);
2765 }
2912
2913 return (rval);
2914 }
2766#endif /* DFC_SUPPORT */
2767
2768 HBASTATS.CtCmdReceived++;
2769
2770 switch (CtCmd->FsType) {
2771 case 0xFC: /* Name server */
2772 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_ct_msg,
2773 "%s: pl=%p size=%d rxid=%x", emlxs_ctcmd_xlate(cmd_code),
2915
2916 HBASTATS.CtCmdReceived++;
2917
2918 switch (CtCmd->FsType) {
2919 case 0xFC: /* Name server */
2920 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_ct_msg,
2921 "%s: pl=%p size=%d rxid=%x", emlxs_ctcmd_xlate(cmd_code),
2774 CtCmd, size, iocb->ulpContext);
2922 CtCmd, size, iocb->ULPCONTEXT);
2775 break;
2776
2777 case 0xFA: /* Managment server */
2778 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_ct_msg,
2779 "%s: pl=%p size=%d rxid=%x", emlxs_mscmd_xlate(cmd_code),
2923 break;
2924
2925 case 0xFA: /* Managment server */
2926 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_ct_msg,
2927 "%s: pl=%p size=%d rxid=%x", emlxs_mscmd_xlate(cmd_code),
2780 CtCmd, size, iocb->ulpContext);
2928 CtCmd, size, iocb->ULPCONTEXT);
2781 break;
2782
2783 case 0x0A: /* Emulex Remote server */
2784 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_ct_msg,
2785 "%s: pl=%p size=%d rxid=%x", emlxs_rmcmd_xlate(cmd_code),
2929 break;
2930
2931 case 0x0A: /* Emulex Remote server */
2932 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_ct_msg,
2933 "%s: pl=%p size=%d rxid=%x", emlxs_rmcmd_xlate(cmd_code),
2786 CtCmd, size, iocb->ulpContext);
2934 CtCmd, size, iocb->ULPCONTEXT);
2787 break;
2788
2789 default:
2790 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_ct_msg,
2791 "%s: pl=%p size=%d rxid=%x", emlxs_ctcmd_xlate(cmd_code),
2935 break;
2936
2937 default:
2938 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_ct_msg,
2939 "%s: pl=%p size=%d rxid=%x", emlxs_ctcmd_xlate(cmd_code),
2792 CtCmd, size, iocb->ulpContext);
2940 CtCmd, size, iocb->ULPCONTEXT);
2793 }
2794
2795 if (emlxs_log_ct_event(port, (uint8_t *)mp->virt, size,
2941 }
2942
2943 if (emlxs_log_ct_event(port, (uint8_t *)mp->virt, size,
2796 iocb->ulpContext)) {
2944 iocb->ULPCONTEXT)) {
2797 /* Abort the exchange */
2945 /* Abort the exchange */
2798 emlxs_abort_ct_exchange(hba, port, iocb->ulpContext);
2946 emlxs_abort_ct_exchange(hba, port, iocb->ULPCONTEXT);
2799 }
2800
2801 return (0);
2802
2947 }
2948
2949 return (0);
2950
2803} /* emlxs_ct_handle_unsol_req() */
2951} /* emlxs_ct_handle_unsol_req() */
2804
2805
2806static void
2807emlxs_send_rsnn(emlxs_port_t *port)
2808{
2809 emlxs_hba_t *hba = HBA;
2810 fc_packet_t *pkt;
2811 SLI_CT_REQUEST *ct;
2812
2813 if (!(pkt = emlxs_pkt_alloc(port, sizeof (SLI_CT_REQUEST),
2814 sizeof (SLI_CT_REQUEST), 0, KM_NOSLEEP))) {
2815 return;
2816 }
2817
2818 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
2819 pkt->pkt_timeout = (2 * hba->fc_ratov);
2820
2821 /* Build the fc header */
2952
2953
2954static void
2955emlxs_send_rsnn(emlxs_port_t *port)
2956{
2957 emlxs_hba_t *hba = HBA;
2958 fc_packet_t *pkt;
2959 SLI_CT_REQUEST *ct;
2960
2961 if (!(pkt = emlxs_pkt_alloc(port, sizeof (SLI_CT_REQUEST),
2962 sizeof (SLI_CT_REQUEST), 0, KM_NOSLEEP))) {
2963 return;
2964 }
2965
2966 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
2967 pkt->pkt_timeout = (2 * hba->fc_ratov);
2968
2969 /* Build the fc header */
2822 pkt->pkt_cmd_fhdr.d_id = SWAP_DATA24_LO(NameServer_DID);
2970 pkt->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(NAMESERVER_DID);
2823 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_UNSOL_CONTROL;
2971 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_UNSOL_CONTROL;
2824 pkt->pkt_cmd_fhdr.s_id = SWAP_DATA24_LO(port->did);
2972 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(port->did);
2825 pkt->pkt_cmd_fhdr.type = FC_TYPE_FC_SERVICES;
2826 pkt->pkt_cmd_fhdr.f_ctl =
2827 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
2828 pkt->pkt_cmd_fhdr.seq_id = 0;
2829 pkt->pkt_cmd_fhdr.df_ctl = 0;
2830 pkt->pkt_cmd_fhdr.seq_cnt = 0;
2831 pkt->pkt_cmd_fhdr.ox_id = 0xffff;
2832 pkt->pkt_cmd_fhdr.rx_id = 0xffff;

--- 4 unchanged lines hidden (view full) ---

2837
2838 ct->RevisionId.bits.Revision = SLI_CT_REVISION;
2839 ct->RevisionId.bits.InId = 0;
2840
2841 ct->FsType = SLI_CT_DIRECTORY_SERVICE;
2842 ct->FsSubType = SLI_CT_DIRECTORY_NAME_SERVER;
2843
2844 ct->CommandResponse.bits.Size = 0;
2973 pkt->pkt_cmd_fhdr.type = FC_TYPE_FC_SERVICES;
2974 pkt->pkt_cmd_fhdr.f_ctl =
2975 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
2976 pkt->pkt_cmd_fhdr.seq_id = 0;
2977 pkt->pkt_cmd_fhdr.df_ctl = 0;
2978 pkt->pkt_cmd_fhdr.seq_cnt = 0;
2979 pkt->pkt_cmd_fhdr.ox_id = 0xffff;
2980 pkt->pkt_cmd_fhdr.rx_id = 0xffff;

--- 4 unchanged lines hidden (view full) ---

2985
2986 ct->RevisionId.bits.Revision = SLI_CT_REVISION;
2987 ct->RevisionId.bits.InId = 0;
2988
2989 ct->FsType = SLI_CT_DIRECTORY_SERVICE;
2990 ct->FsSubType = SLI_CT_DIRECTORY_NAME_SERVER;
2991
2992 ct->CommandResponse.bits.Size = 0;
2845 ct->CommandResponse.bits.CmdRsp = SWAP_DATA16(SLI_CTNS_RSNN_NN);
2993 ct->CommandResponse.bits.CmdRsp = LE_SWAP16(SLI_CTNS_RSNN_NN);
2846
2847 bcopy((uint8_t *)&hba->wwnn, (char *)ct->un.rsnn.wwnn, 8);
2848
2849 ct->un.rsnn.snn_len = strlen(port->snn);
2850 bcopy(port->snn, (char *)ct->un.rsnn.snn, ct->un.rsnn.snn_len);
2851
2852 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_send_msg, "Sending RSNN_NN. [%s]",
2853 port->snn);
2854
2855 /* Send the pkt later in another thread */
2856 if (emlxs_pkt_send(pkt, 0) != FC_SUCCESS) {
2857 /* Free the pkt */
2858 emlxs_pkt_free(pkt);
2859 }
2860
2861 return;
2862
2994
2995 bcopy((uint8_t *)&hba->wwnn, (char *)ct->un.rsnn.wwnn, 8);
2996
2997 ct->un.rsnn.snn_len = strlen(port->snn);
2998 bcopy(port->snn, (char *)ct->un.rsnn.snn, ct->un.rsnn.snn_len);
2999
3000 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_ct_send_msg, "Sending RSNN_NN. [%s]",
3001 port->snn);
3002
3003 /* Send the pkt later in another thread */
3004 if (emlxs_pkt_send(pkt, 0) != FC_SUCCESS) {
3005 /* Free the pkt */
3006 emlxs_pkt_free(pkt);
3007 }
3008
3009 return;
3010
2863} /* emlxs_send_rsnn() */
3011} /* emlxs_send_rsnn() */
2864
2865
2866extern uint32_t
2867emlxs_ub_send_login_acc(emlxs_port_t *port, fc_unsol_buf_t *ubp)
2868{
2869 emlxs_hba_t *hba = HBA;
2870 fc_packet_t *pkt;
2871 ELS_PKT *els;

--- 41 unchanged lines hidden (view full) ---

2913 /* Free the pkt */
2914 emlxs_pkt_free(pkt);
2915 } else {
2916 ub_priv->flags |= EMLXS_UB_INTERCEPT;
2917 }
2918
2919 return (rval);
2920
3012
3013
3014extern uint32_t
3015emlxs_ub_send_login_acc(emlxs_port_t *port, fc_unsol_buf_t *ubp)
3016{
3017 emlxs_hba_t *hba = HBA;
3018 fc_packet_t *pkt;
3019 ELS_PKT *els;

--- 41 unchanged lines hidden (view full) ---

3061 /* Free the pkt */
3062 emlxs_pkt_free(pkt);
3063 } else {
3064 ub_priv->flags |= EMLXS_UB_INTERCEPT;
3065 }
3066
3067 return (rval);
3068
2921} /* emlxs_ub_send_login_acc */
3069} /* emlxs_ub_send_login_acc */
2922
2923
2924extern void
2925emlxs_send_logo(emlxs_port_t *port, uint32_t d_id)
2926{
2927 emlxs_hba_t *hba = HBA;
2928 fc_packet_t *pkt;
2929 ELS_PKT *els;

--- 7 unchanged lines hidden (view full) ---

2937 sizeof (uint32_t) + sizeof (LOGO), 0, KM_NOSLEEP))) {
2938 return;
2939 }
2940
2941 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
2942 pkt->pkt_timeout = (2 * hba->fc_ratov);
2943
2944 /* Build the fc header */
3070
3071
3072extern void
3073emlxs_send_logo(emlxs_port_t *port, uint32_t d_id)
3074{
3075 emlxs_hba_t *hba = HBA;
3076 fc_packet_t *pkt;
3077 ELS_PKT *els;

--- 7 unchanged lines hidden (view full) ---

3085 sizeof (uint32_t) + sizeof (LOGO), 0, KM_NOSLEEP))) {
3086 return;
3087 }
3088
3089 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
3090 pkt->pkt_timeout = (2 * hba->fc_ratov);
3091
3092 /* Build the fc header */
2945 pkt->pkt_cmd_fhdr.d_id = SWAP_DATA24_LO(d_id);
3093 pkt->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(d_id);
2946 pkt->pkt_cmd_fhdr.r_ctl =
2947 R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
3094 pkt->pkt_cmd_fhdr.r_ctl =
3095 R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
2948 pkt->pkt_cmd_fhdr.s_id = SWAP_DATA24_LO(port->did);
3096 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(port->did);
2949 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
2950 pkt->pkt_cmd_fhdr.f_ctl =
2951 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
2952 pkt->pkt_cmd_fhdr.seq_id = 0;
2953 pkt->pkt_cmd_fhdr.df_ctl = 0;
2954 pkt->pkt_cmd_fhdr.seq_cnt = 0;
2955 pkt->pkt_cmd_fhdr.ox_id = 0xffff;
2956 pkt->pkt_cmd_fhdr.rx_id = 0xffff;

--- 18 unchanged lines hidden ---
3097 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
3098 pkt->pkt_cmd_fhdr.f_ctl =
3099 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
3100 pkt->pkt_cmd_fhdr.seq_id = 0;
3101 pkt->pkt_cmd_fhdr.df_ctl = 0;
3102 pkt->pkt_cmd_fhdr.seq_cnt = 0;
3103 pkt->pkt_cmd_fhdr.ox_id = 0xffff;
3104 pkt->pkt_cmd_fhdr.rx_id = 0xffff;

--- 18 unchanged lines hidden ---