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 --- |