emlxs_els.c (e2ca2865) emlxs_els.c (a9800beb)
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

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

15 * If applicable, add the following below this CDDL HEADER, with the
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/*
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

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

15 * If applicable, add the following below this CDDL HEADER, with the
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.
23 * Copyright 2011 Emulex. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27
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);
24 * Use is subject to license terms.
25 */
26
27
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);
34static void emlxs_handle_sol_fdisc(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
40static void emlxs_handle_unsol_rscn(emlxs_port_t *port, CHANNEL *cp,
41 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
42static void emlxs_handle_unsol_flogi(emlxs_port_t *port, CHANNEL *cp,

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

50static void emlxs_handle_unsol_prli(emlxs_port_t *port, CHANNEL *cp,
51 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
52static void emlxs_handle_unsol_prlo(emlxs_port_t *port, CHANNEL *cp,
53 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
54static void emlxs_handle_unsol_auth(emlxs_port_t *port, CHANNEL *cp,
55 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
56static void emlxs_handle_unsol_gen_cmd(emlxs_port_t *port, CHANNEL *cp,
57 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
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
40static void emlxs_handle_unsol_rscn(emlxs_port_t *port, CHANNEL *cp,
41 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
42static void emlxs_handle_unsol_flogi(emlxs_port_t *port, CHANNEL *cp,

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

50static void emlxs_handle_unsol_prli(emlxs_port_t *port, CHANNEL *cp,
51 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
52static void emlxs_handle_unsol_prlo(emlxs_port_t *port, CHANNEL *cp,
53 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
54static void emlxs_handle_unsol_auth(emlxs_port_t *port, CHANNEL *cp,
55 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
56static void emlxs_handle_unsol_gen_cmd(emlxs_port_t *port, CHANNEL *cp,
57 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
58static void emlxs_handle_unsol_echo_cmd(emlxs_port_t *port, CHANNEL *cp,
59 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
60static void emlxs_handle_unsol_rtv_cmd(emlxs_port_t *port, CHANNEL *cp,
61 IOCBQ *iocbq, MATCHMAP *mp, uint32_t size);
62static void emlxs_handle_unsol_rls_cmd(emlxs_port_t *port, CHANNEL *cp,
63 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);
64static void emlxs_handle_acc(emlxs_port_t *port, emlxs_buf_t *sbp,
65 IOCBQ *iocbq, uint32_t flag);
66static void emlxs_handle_reject(emlxs_port_t *port, emlxs_buf_t *sbp,
67 IOCBQ *iocbq, uint32_t flag);
68
69#if (EMLXS_MODREV < EMLXS_MODREV4)
62static void emlxs_send_rsnn(emlxs_port_t *port);
63
70static void emlxs_send_rsnn(emlxs_port_t *port);
71
72#endif /* < EMLXS_MODREV4 */
64
65
66
67/* Routine Declaration - Local */
68/* End Routine Declaration - Local */
69
70/*
71 * emlxs_els_handle_event

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

177 * ULP patch - ULP expects
178 * resp_resid = 0 on success
179 */
180 pkt->pkt_resp_resid = 0;
181 }
182
183 switch (command) {
184 case ELS_CMD_FDISC: /* Fabric login */
73
74
75
76/* Routine Declaration - Local */
77/* End Routine Declaration - Local */
78
79/*
80 * emlxs_els_handle_event

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

186 * ULP patch - ULP expects
187 * resp_resid = 0 on success
188 */
189 pkt->pkt_resp_resid = 0;
190 }
191
192 switch (command) {
193 case ELS_CMD_FDISC: /* Fabric login */
185 emlxs_handle_sol_fdisk(port, sbp);
194 emlxs_handle_sol_fdisc(port, sbp);
186
187 break;
188
189 case ELS_CMD_FLOGI: /* Fabric login */
190 emlxs_handle_sol_flogi(port, sbp);
191
192 break;
193

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

314 emlxs_dhc_state(port, ndlp,
315 NODE_STATE_NOCHANGE,
316 pkt->pkt_reason,
317 pkt->pkt_expln);
318 }
319#endif /* DHCHAP_SUPPORT */
320 }
321
195
196 break;
197
198 case ELS_CMD_FLOGI: /* Fabric login */
199 emlxs_handle_sol_flogi(port, sbp);
200
201 break;
202

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

323 emlxs_dhc_state(port, ndlp,
324 NODE_STATE_NOCHANGE,
325 pkt->pkt_reason,
326 pkt->pkt_expln);
327 }
328#endif /* DHCHAP_SUPPORT */
329 }
330
331 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
332 (void) emlxs_vpi_logi_failed_notify(
333 sbp->port);
334 }
335
322 break;
323
324 default:
325 break;
326 }
327
328 emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
329 iocb->un.grsp.perr.statLocalError, 1);
336 break;
337
338 default:
339 break;
340 }
341
342 emlxs_pkt_complete(sbp, iocb->ULPSTATUS,
343 iocb->un.grsp.perr.statLocalError, 1);
330
331 }
332
344 }
345
333
334 break;
335
336 default:
337
338 HBASTATS.ElsStray++;
339
340 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_invalid_els_msg,
341 "Invalid iocb: cmd=0x%x", iocb->ULPCOMMAND);

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

352
353
354extern int
355emlxs_els_handle_unsol_req(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
356 MATCHMAP *mp, uint32_t size)
357{
358 emlxs_hba_t *hba = HBA;
359 uint32_t cmd_code;
346 break;
347
348 default:
349
350 HBASTATS.ElsStray++;
351
352 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_invalid_els_msg,
353 "Invalid iocb: cmd=0x%x", iocb->ULPCOMMAND);

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

364
365
366extern int
367emlxs_els_handle_unsol_req(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
368 MATCHMAP *mp, uint32_t size)
369{
370 emlxs_hba_t *hba = HBA;
371 uint32_t cmd_code;
372 IOCB *iocb;
360
361 HBASTATS.ElsCmdReceived++;
362
373
374 HBASTATS.ElsCmdReceived++;
375
376 iocb = &iocbq->iocb;
363 cmd_code = *((uint32_t *)mp->virt) & ELS_CMD_MASK;
364
365 if (!(port->flag & EMLXS_PORT_BOUND)) {
366 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
367 "%s: sid=%x. Port not bound: Rejecting.",
368 emlxs_elscmd_xlate(cmd_code),
369 iocbq->iocb.un.elsreq.remoteID);
370

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

410 emlxs_handle_unsol_adisc(port, cp, iocbq, mp, size);
411 break;
412
413 case ELS_CMD_AUTH:
414 HBASTATS.ElsAuthReceived++;
415 emlxs_handle_unsol_auth(port, cp, iocbq, mp, size);
416 break;
417
377 cmd_code = *((uint32_t *)mp->virt) & ELS_CMD_MASK;
378
379 if (!(port->flag & EMLXS_PORT_BOUND)) {
380 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
381 "%s: sid=%x. Port not bound: Rejecting.",
382 emlxs_elscmd_xlate(cmd_code),
383 iocbq->iocb.un.elsreq.remoteID);
384

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

424 emlxs_handle_unsol_adisc(port, cp, iocbq, mp, size);
425 break;
426
427 case ELS_CMD_AUTH:
428 HBASTATS.ElsAuthReceived++;
429 emlxs_handle_unsol_auth(port, cp, iocbq, mp, size);
430 break;
431
432 case ELS_CMD_TEST:
433 HBASTATS.ElsTestReceived++;
434 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
435 "%s: sid=%x. Dropping.",
436 emlxs_elscmd_xlate(cmd_code),
437 iocbq->iocb.un.elsreq.remoteID);
438
439 /* drop it */
440 emlxs_close_els_exchange(hba, port, iocb->ULPCONTEXT);
441 break;
442
443 case ELS_CMD_ESTC:
444 HBASTATS.ElsEstcReceived++;
445 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
446 "%s: sid=%x. Dropping.",
447 emlxs_elscmd_xlate(cmd_code),
448 iocbq->iocb.un.elsreq.remoteID);
449
450 /* drop it */
451 emlxs_close_els_exchange(hba, port, iocb->ULPCONTEXT);
452 break;
453
454 case ELS_CMD_FARPR:
455 HBASTATS.ElsFarprReceived++;
456
457 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
458 "%s: sid=%x. Dropping.",
459 emlxs_elscmd_xlate(cmd_code),
460 iocbq->iocb.un.elsreq.remoteID);
461
462 /* drop it */
463 emlxs_close_els_exchange(hba, port, iocb->ULPCONTEXT);
464 break;
465
466 case ELS_CMD_ECHO:
467 HBASTATS.ElsEchoReceived++;
468 emlxs_handle_unsol_echo_cmd(port, cp, iocbq, mp, size);
469 break;
470
471 case ELS_CMD_RLS:
472 HBASTATS.ElsRlsReceived++;
473 emlxs_handle_unsol_rls_cmd(port, cp, iocbq, mp, size);
474 break;
475
476 case ELS_CMD_RTV:
477 HBASTATS.ElsRtvReceived++;
478 emlxs_handle_unsol_rtv_cmd(port, cp, iocbq, mp, size);
479 break;
480
481 case ELS_CMD_ABTX:
482 case ELS_CMD_RCS:
483 case ELS_CMD_RES:
484 case ELS_CMD_RSS:
485 case ELS_CMD_RSI:
486 case ELS_CMD_ESTS:
487 case ELS_CMD_RRQ:
488 case ELS_CMD_REC:
489 HBASTATS.ElsGenReceived++;
490
491 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
492 "%s: sid=%x. Rejecting.",
493 emlxs_elscmd_xlate(cmd_code),
494 iocbq->iocb.un.elsreq.remoteID);
495
496 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT, cmd_code,
497 LSRJT_CMD_UNSUPPORTED, LSEXP_NOTHING_MORE);
498 break;
499
418 default:
419 HBASTATS.ElsGenReceived++;
420 emlxs_handle_unsol_gen_cmd(port, cp, iocbq, mp, size);
421 break;
422 }
423
424 return (0);
425

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

436 fc_packet_t *pkt;
437 MAILBOXQ *mbox;
438 uint32_t did;
439 IOCBQ *iocbq;
440 IOCB *iocb;
441 char buffer[64];
442 uint32_t i;
443 int rc;
500 default:
501 HBASTATS.ElsGenReceived++;
502 emlxs_handle_unsol_gen_cmd(port, cp, iocbq, mp, size);
503 break;
504 }
505
506 return (0);
507

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

518 fc_packet_t *pkt;
519 MAILBOXQ *mbox;
520 uint32_t did;
521 IOCBQ *iocbq;
522 IOCB *iocb;
523 char buffer[64];
524 uint32_t i;
525 int rc;
526 uint16_t altBbCredit;
444
445 pkt = PRIV2PKT(sbp);
446 sp = (SERV_PARM *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
447 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
448 iocbq = &sbp->iocbq;
449 iocb = &iocbq->iocb;
450
527
528 pkt = PRIV2PKT(sbp);
529 sp = (SERV_PARM *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
530 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
531 iocbq = &sbp->iocbq;
532 iocb = &iocbq->iocb;
533
451 if (sp->cmn.fPort) {
452 mutex_enter(&EMLXS_PORT_LOCK);
534 mutex_enter(&EMLXS_PORT_LOCK);
453
535
536 /* Save the fabric service parameters and did */
537 port->did = iocb->un.elsreq.myID;
538 bcopy((void *)sp, (void *)&port->fabric_sparam, sizeof (SERV_PARM));
539
540 if (sp->cmn.fPort) {
454 hba->flag |= FC_FABRIC_ATTACHED;
455 hba->flag &= ~FC_PT_TO_PT;
456
541 hba->flag |= FC_FABRIC_ATTACHED;
542 hba->flag &= ~FC_PT_TO_PT;
543
457 /* Save our new port ID */
458 port->did = iocb->un.elsreq.myID;
459 pkt->pkt_resp_fhdr.s_id = LE_SWAP24_LO(FABRIC_DID);
460 pkt->pkt_resp_fhdr.d_id = LE_SWAP24_LO(port->did);
461
462 /* Save E_D_TOV ticks in nanoseconds */
463 if (sp->cmn.edtovResolution) {
464 hba->fc_edtov =
465 (LE_SWAP32(sp->cmn.e_d_tov) + 999999) / 1000000;
466 } else {
467 hba->fc_edtov = LE_SWAP32(sp->cmn.e_d_tov);
468 }
469
470 /* Save R_A_TOV ticks */
471 hba->fc_ratov =
472 (LE_SWAP32(sp->cmn.w2.r_a_tov) + 999) / 1000;
473
544 pkt->pkt_resp_fhdr.s_id = LE_SWAP24_LO(FABRIC_DID);
545 pkt->pkt_resp_fhdr.d_id = LE_SWAP24_LO(port->did);
546
547 /* Save E_D_TOV ticks in nanoseconds */
548 if (sp->cmn.edtovResolution) {
549 hba->fc_edtov =
550 (LE_SWAP32(sp->cmn.e_d_tov) + 999999) / 1000000;
551 } else {
552 hba->fc_edtov = LE_SWAP32(sp->cmn.e_d_tov);
553 }
554
555 /* Save R_A_TOV ticks */
556 hba->fc_ratov =
557 (LE_SWAP32(sp->cmn.w2.r_a_tov) + 999) / 1000;
558
474 if (hba->topology != TOPOLOGY_LOOP) {
475 /*
476 * If we are a N-port connected to a Fabric,
477 * fixup sparam's so logins to devices on remote
478 * loops work.
479 */
480 hba->sparam.cmn.altBbCredit = 1;
559 /*
560 * If we are a N-port connected to a Fabric,
561 * fixup sparam's so logins to devices on remote
562 * loops work.
563 */
564 altBbCredit = (hba->topology != TOPOLOGY_LOOP)? 1:0;
565 hba->sparam.cmn.altBbCredit = altBbCredit;
481
566
482 /* Set this bit in all the port sparam copies */
483 for (i = 0; i < MAX_VPORTS; i++) {
484 vport = &VPORT(i);
567 /* Set this bit in all the port sparam copies */
568 for (i = 0; i < MAX_VPORTS; i++) {
569 vport = &VPORT(i);
485
570
486 if (!(vport->flag & EMLXS_PORT_BOUND)) {
487 continue;
488 }
489
490 vport->sparam.cmn.altBbCredit = 1;
571 if (!(vport->flag & EMLXS_PORT_BOUND)) {
572 continue;
491 }
573 }
574
575 vport->sparam.cmn.altBbCredit = altBbCredit;
492 }
493
494 if (sp->cmn.rspMultipleNPort) {
495 hba->flag |= FC_NPIV_SUPPORTED;
496
497 if (cfg[CFG_NPIV_DELAY].current) {
498 /*
499 * PATCH: for NPIV support on

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

529 }
530#endif /* DHCHAP_SUPPORT */
531
532 mutex_exit(&EMLXS_PORT_LOCK);
533
534 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
535 "FLOGI: did=%x sid=%x %s", did, port->did, buffer);
536
576 }
577
578 if (sp->cmn.rspMultipleNPort) {
579 hba->flag |= FC_NPIV_SUPPORTED;
580
581 if (cfg[CFG_NPIV_DELAY].current) {
582 /*
583 * PATCH: for NPIV support on

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

613 }
614#endif /* DHCHAP_SUPPORT */
615
616 mutex_exit(&EMLXS_PORT_LOCK);
617
618 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
619 "FLOGI: did=%x sid=%x %s", did, port->did, buffer);
620
537 /* Update our service parms */
621 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
622 /* Deferred completion */
623 (void) emlxs_vpi_logi_cmpl_notify(sbp->port, sbp);
624 return;
625 }
626
538 if (!(mbox = (MAILBOXQ *)emlxs_mem_get(hba,
539 MEM_MBOX, 1))) {
540 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
541 IOERR_NO_RESOURCES, 1);
542 return;
627 if (!(mbox = (MAILBOXQ *)emlxs_mem_get(hba,
628 MEM_MBOX, 1))) {
629 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
630 IOERR_NO_RESOURCES, 1);
631 return;
543
544 }
545
632 }
633
546 /* For SLI4 we replace CONFIG_LINK and REG_LOGIN of */
547 /* Fabric with a REG_VFI mailbox command. */
548 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
549 emlxs_port_t *vpip = sbp->port;
550 VFIobj_t *vfip;
551 FCFIobj_t *fcfp;
552 uint32_t regvfi;
553
554 vfip = vpip->VFIp;
555 fcfp = vfip->FCFIp;
556 regvfi = vfip->state & RESOURCE_VFI_REG;
557
558 /* Save the FCF service parameters */
559 bcopy((void *)sp, (void *)&fcfp->fcf_sparam,
560 sizeof (SERV_PARM));
561
562 if (emlxs_mb_check_sparm(hba, sp)) {
563 EMLXS_MSGF(EMLXS_CONTEXT,
564 &emlxs_node_create_failed_msg,
565 "Invalid Fabric parameters. did=%06x",
566 port->did);
567 (void) emlxs_mem_put(hba, MEM_MBOX,
568 (uint8_t *)mbox);
569 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
570 IOERR_NO_RESOURCES, 1);
571 return;
572 }
573
574 if (!regvfi) {
575 if (emlxs_mb_reg_vfi(hba, mbox, vfip, vpip) ==
576 0) {
577 EMLXS_MSGF(EMLXS_CONTEXT,
578 &emlxs_sli_detail_msg,
579 "Cannot REG_VFI for FCF: sid=%x",
580 port->did);
581
582 (void) emlxs_mem_put(hba, MEM_MBOX,
583 (uint8_t *)mbox);
584 emlxs_pkt_complete(sbp,
585 IOSTAT_LOCAL_REJECT,
586 IOERR_NO_RESOURCES, 1);
587 return;
588 }
589 mbox->sbp = (uint8_t *)sbp;
590
591 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox,
592 MBX_NOWAIT, 0);
593 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
594 EMLXS_MSGF(EMLXS_CONTEXT,
595 &emlxs_sli_detail_msg,
596 "Cannot REG_VFI for FCF: sid=%x",
597 port->did);
598
599 (void) emlxs_mem_put(hba, MEM_MBOX,
600 (uint8_t *)mbox);
601 emlxs_pkt_complete(sbp,
602 IOSTAT_LOCAL_REJECT,
603 IOERR_NO_RESOURCES, 1);
604 return;
605 }
606 /* Preset the state for the REG_VFI cmpl */
607 emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);
608
609 /* Deferred completion of this pkt until */
610 /* REG_VFI is complete */
611 return;
612 }
613 /* VFI is already Registered */
614
615 (void) emlxs_mem_put(hba, MEM_MBOX, (uint8_t *)mbox);
616 emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 1);
617
618 EMLXS_STATE_CHANGE_LOCKED(hba, FC_READY);
619 if (regvfi) {
620 /*
621 * If NPIV Fabric support has just been
622 * established on the physical port, then
623 * notify the vports of the link up.
624 */
625 if ((hba->flag & FC_NPIV_ENABLED) &&
626 (hba->flag & FC_NPIV_SUPPORTED)) {
627 /* Skip the physical port */
628 for (i = 1; i < MAX_VPORTS; i++) {
629 vport = &VPORT(i);
630
631 if (!(vport->flag &
632 EMLXS_PORT_BOUND) ||
633 !(vport->flag &
634 EMLXS_PORT_ENABLE)) {
635 continue;
636 }
637
638 emlxs_port_online(vport);
639 }
640 }
641 }
642 return;
643 }
644
645 /* Save the fabric service parameters */
646 bcopy((void *)sp, (void *)&port->fabric_sparam,
647 sizeof (SERV_PARM));
648
634 /* Update our service parms */
649 emlxs_mb_config_link(hba, mbox);
650
651 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_NOWAIT, 0);
652 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
635 emlxs_mb_config_link(hba, mbox);
636
637 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox, MBX_NOWAIT, 0);
638 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
653 (void) emlxs_mem_put(hba, MEM_MBOX, (uint8_t *)mbox);
639 emlxs_mem_put(hba, MEM_MBOX, (void *)mbox);
654 }
655
656 /* Preset the state for the reg_did */
657 emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);
658
659 if (emlxs_mb_reg_did(port, FABRIC_DID, &port->fabric_sparam,
660 sbp, NULL, NULL) == 0) {
661 /* Deferred completion of this pkt until */
662 /* login is complete */
663 return;
664 }
665
666 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
667 IOERR_NO_RESOURCES, 1);
668
669 } else { /* No switch */
670
640 }
641
642 /* Preset the state for the reg_did */
643 emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);
644
645 if (emlxs_mb_reg_did(port, FABRIC_DID, &port->fabric_sparam,
646 sbp, NULL, NULL) == 0) {
647 /* Deferred completion of this pkt until */
648 /* login is complete */
649 return;
650 }
651
652 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
653 IOERR_NO_RESOURCES, 1);
654
655 } else { /* No switch */
656
671 mutex_enter(&EMLXS_PORT_LOCK);
672
673 hba->flag &= ~FC_FABRIC_ATTACHED;
674 hba->flag |= FC_PT_TO_PT;
675
676 /* Save E_D_TOV ticks in nanoseconds */
677 if (sp->cmn.edtovResolution) {
678 hba->fc_edtov =
679 (LE_SWAP32(sp->cmn.e_d_tov) + 999999) / 1000000;
680 } else {

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

702 }
703
704 return;
705
706} /* emlxs_handle_sol_flogi() */
707
708
709static void
657 hba->flag &= ~FC_FABRIC_ATTACHED;
658 hba->flag |= FC_PT_TO_PT;
659
660 /* Save E_D_TOV ticks in nanoseconds */
661 if (sp->cmn.edtovResolution) {
662 hba->fc_edtov =
663 (LE_SWAP32(sp->cmn.e_d_tov) + 999999) / 1000000;
664 } else {

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

686 }
687
688 return;
689
690} /* emlxs_handle_sol_flogi() */
691
692
693static void
710emlxs_handle_sol_fdisk(emlxs_port_t *port, emlxs_buf_t *sbp)
694emlxs_handle_sol_fdisc(emlxs_port_t *port, emlxs_buf_t *sbp)
711{
712 emlxs_hba_t *hba = HBA;
713 emlxs_config_t *cfg = &CFG;
714 SERV_PARM *sp;
715 fc_packet_t *pkt;
716 MAILBOXQ *mbox;
717 uint32_t did;
718 IOCBQ *iocbq;

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

723 pkt = PRIV2PKT(sbp);
724 sp = (SERV_PARM *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
725 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
726 iocbq = &sbp->iocbq;
727 iocb = &iocbq->iocb;
728
729 mutex_enter(&EMLXS_PORT_LOCK);
730
695{
696 emlxs_hba_t *hba = HBA;
697 emlxs_config_t *cfg = &CFG;
698 SERV_PARM *sp;
699 fc_packet_t *pkt;
700 MAILBOXQ *mbox;
701 uint32_t did;
702 IOCBQ *iocbq;

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

707 pkt = PRIV2PKT(sbp);
708 sp = (SERV_PARM *)((caddr_t)pkt->pkt_resp + sizeof (uint32_t));
709 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
710 iocbq = &sbp->iocbq;
711 iocb = &iocbq->iocb;
712
713 mutex_enter(&EMLXS_PORT_LOCK);
714
731 /* Save our new port ID */
715 /* Save the fabric service parameters and did */
732 port->did = iocb->un.elsreq.myID;
716 port->did = iocb->un.elsreq.myID;
733 pkt->pkt_resp_fhdr.d_id = LE_SWAP24_LO(port->did);
734
735 /* Save the fabric service parameters */
736 bcopy((void *)sp, (void *)&port->fabric_sparam, sizeof (SERV_PARM));
737
717 bcopy((void *)sp, (void *)&port->fabric_sparam, sizeof (SERV_PARM));
718
719 pkt->pkt_resp_fhdr.d_id = LE_SWAP24_LO(port->did);
720
738 mutex_exit(&EMLXS_PORT_LOCK);
739
740 buffer[0] = 0;
741
742#ifdef DHCHAP_SUPPORT
743 if (!sp->cmn.fcsp_support) {
744 (void) strcat(buffer, "fcsp:Unsupported");
745 } else if (cfg[CFG_AUTH_ENABLE].current && cfg[CFG_AUTH_NPIV].current) {
746 (void) strcat(buffer, "fcsp:Supported");
747 } else {
748 (void) strcat(buffer, "fcsp:Disabled");
749 }
750#endif /* DHCHAP_SUPPORT */
751
752 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
721 mutex_exit(&EMLXS_PORT_LOCK);
722
723 buffer[0] = 0;
724
725#ifdef DHCHAP_SUPPORT
726 if (!sp->cmn.fcsp_support) {
727 (void) strcat(buffer, "fcsp:Unsupported");
728 } else if (cfg[CFG_AUTH_ENABLE].current && cfg[CFG_AUTH_NPIV].current) {
729 (void) strcat(buffer, "fcsp:Supported");
730 } else {
731 (void) strcat(buffer, "fcsp:Disabled");
732 }
733#endif /* DHCHAP_SUPPORT */
734
735 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg,
753 "FDISK: did=%x sid=%x %s", did, port->did, buffer);
736 "FDISC: did=%x sid=%x %s", did, port->did, buffer);
754
755 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
737
738 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
756 emlxs_port_t *pport = &PPORT;
757
758 port->VFIp = pport->VFIp;
759
760 if (emlxs_mb_check_sparm(hba, sp)) {
761 EMLXS_MSGF(EMLXS_CONTEXT,
762 &emlxs_node_create_failed_msg,
763 "Invalid Fabric parameters. did=%06x",
764 port->did);
765 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT,
766 IOERR_NO_RESOURCES, 1);
767 return;
768 }
769
770 /* Preset the state for the REG_VFI cmpl */
771 emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);
772
773 if (port->flag & EMLXS_PORT_REG_VPI_CMPL) {
774 emlxs_pkt_complete(sbp, -1, 0, 1);
775 } else {
776 /* Deferred completion of this pkt until */
777 /* REG_VPI is complete */
778 (void) emlxs_mb_reg_vpi(port, sbp);
779 }
780
739 (void) emlxs_vpi_logi_cmpl_notify(sbp->port, sbp);
781 return;
782 }
783
784 /* Update our service parms */
785 if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba, MEM_MBOX, 1))) {
786 emlxs_mb_config_link(hba, mbox);
787
788 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox,
789 MBX_NOWAIT, 0);
790 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
740 return;
741 }
742
743 /* Update our service parms */
744 if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba, MEM_MBOX, 1))) {
745 emlxs_mb_config_link(hba, mbox);
746
747 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox,
748 MBX_NOWAIT, 0);
749 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
791 (void) emlxs_mem_put(hba, MEM_MBOX, (uint8_t *)mbox);
750 emlxs_mem_put(hba, MEM_MBOX, (void *)mbox);
792 }
793 }
794
795 /* Preset the state for the reg_did */
796 emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);
797
798 if (emlxs_mb_reg_did(port, FABRIC_DID, &port->fabric_sparam, sbp,
799 NULL, NULL) == 0) {
800 /*
801 * Deferred completion of this pkt until login is complete
802 */
803
804 return;
805 }
806
807 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT, IOERR_NO_RESOURCES, 1);
808
809 return;
810
751 }
752 }
753
754 /* Preset the state for the reg_did */
755 emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);
756
757 if (emlxs_mb_reg_did(port, FABRIC_DID, &port->fabric_sparam, sbp,
758 NULL, NULL) == 0) {
759 /*
760 * Deferred completion of this pkt until login is complete
761 */
762
763 return;
764 }
765
766 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT, IOERR_NO_RESOURCES, 1);
767
768 return;
769
811} /* emlxs_handle_sol_fdisk() */
770} /* emlxs_handle_sol_fdisc() */
812
813
814static void
815emlxs_handle_sol_plogi(emlxs_port_t *port, emlxs_buf_t *sbp)
816{
817 emlxs_hba_t *hba = HBA;
818 emlxs_config_t *cfg = &CFG;
819 SERV_PARM *sp;

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

874
875static void
876emlxs_handle_sol_adisc(emlxs_port_t *port, emlxs_buf_t *sbp)
877{
878 emlxs_hba_t *hba = HBA;
879 fc_packet_t *pkt;
880 uint32_t did;
881 NODELIST *ndlp;
771
772
773static void
774emlxs_handle_sol_plogi(emlxs_port_t *port, emlxs_buf_t *sbp)
775{
776 emlxs_hba_t *hba = HBA;
777 emlxs_config_t *cfg = &CFG;
778 SERV_PARM *sp;

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

833
834static void
835emlxs_handle_sol_adisc(emlxs_port_t *port, emlxs_buf_t *sbp)
836{
837 emlxs_hba_t *hba = HBA;
838 fc_packet_t *pkt;
839 uint32_t did;
840 NODELIST *ndlp;
882 RPIobj_t *rp;
883
884 pkt = PRIV2PKT(sbp);
885 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
886
887 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg, "ADISC: did=%x",
888 did);
889
890 ndlp = emlxs_node_find_did(port, did);
891
892 if (ndlp && ndlp->nlp_active) {
893 /* Open the node again */
894 emlxs_node_open(port, ndlp, hba->channel_fcp);
895 emlxs_node_open(port, ndlp, hba->channel_ip);
896
897 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
841
842 pkt = PRIV2PKT(sbp);
843 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
844
845 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_completion_msg, "ADISC: did=%x",
846 did);
847
848 ndlp = emlxs_node_find_did(port, did);
849
850 if (ndlp && ndlp->nlp_active) {
851 /* Open the node again */
852 emlxs_node_open(port, ndlp, hba->channel_fcp);
853 emlxs_node_open(port, ndlp, hba->channel_ip);
854
855 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
898 rp = emlxs_sli4_find_rpi(hba, ndlp->nlp_Rpi);
899 if (rp && (rp->state & RESOURCE_RPI_PAUSED)) {
900 (void) emlxs_mb_resume_rpi(hba, sbp,
901 ndlp->nlp_Rpi);
902 rp->state &= ~RESOURCE_RPI_PAUSED;
856
857 emlxs_set_pkt_state(sbp, IOSTAT_SUCCESS, 0, 1);
858
859 if (emlxs_rpi_resume_notify(port,
860 ndlp->rpip, sbp) == 0) {
903 /*
904 * Delay ADISC cmpl to ULP till
905 * after RESUME_RPI
906 */
907 return;
908 }
909 }
910 }

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

932 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
933
934 ndlp = emlxs_node_find_did(port, did);
935
936 if (ndlp && ndlp->nlp_active) {
937 /* Check for FCP support */
938 if ((npr->acceptRspCode == PRLI_REQ_EXECUTED) &&
939 (npr->prliType == PRLI_FCP_TYPE)) {
861 /*
862 * Delay ADISC cmpl to ULP till
863 * after RESUME_RPI
864 */
865 return;
866 }
867 }
868 }

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

890 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id);
891
892 ndlp = emlxs_node_find_did(port, did);
893
894 if (ndlp && ndlp->nlp_active) {
895 /* Check for FCP support */
896 if ((npr->acceptRspCode == PRLI_REQ_EXECUTED) &&
897 (npr->prliType == PRLI_FCP_TYPE)) {
898 /* Clear FCP2 support if no ADISC support requested */
899 if (cfg[CFG_ADISC_SUPPORT].current == 0) {
900 npr->ConfmComplAllowed = 0;
901 npr->TaskRetryIdReq = 0;
902 npr->Retry = 0;
903 }
904
940 /* Check for target */
941 if (npr->targetFunc) {
942 ndlp->nlp_fcp_info |= NLP_FCP_TGT_DEVICE;
943 } else {
944 ndlp->nlp_fcp_info &= ~NLP_FCP_TGT_DEVICE;
945 }
946
947 /* Check for initiator */

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

1311 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1312 "PLOGI rcvd: sid=%x. Restricted. Rejecting.",
1313 sid);
1314
1315 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
1316 ELS_CMD_PLOGI, LSRJT_UNABLE_TPC,
1317 LSEXP_NOTHING_MORE);
1318
905 /* Check for target */
906 if (npr->targetFunc) {
907 ndlp->nlp_fcp_info |= NLP_FCP_TGT_DEVICE;
908 } else {
909 ndlp->nlp_fcp_info &= ~NLP_FCP_TGT_DEVICE;
910 }
911
912 /* Check for initiator */

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

1276 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1277 "PLOGI rcvd: sid=%x. Restricted. Rejecting.",
1278 sid);
1279
1280 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
1281 ELS_CMD_PLOGI, LSRJT_UNABLE_TPC,
1282 LSEXP_NOTHING_MORE);
1283
1319 /*
1320 * We still need to do reg_did and unreg_did
1321 * to free up rpi
1322 */
1323 (void) emlxs_mb_reg_did(port, sid, sp, NULL, NULL,
1324 (IOCBQ *)1);
1284 /* Clear temporary RPI in firmware */
1285 if (hba->sli_mode == EMLXS_HBA_SLI3_MODE) {
1286 (void) emlxs_mb_reg_did(port, sid, sp,
1287 NULL, NULL, (IOCBQ *)1);
1288 }
1325
1326 return (1);
1327 }
1328 }
1329
1330#ifdef DHCHAP_SUPPORT
1331 if (emlxs_dhc_verify_login(port, sid, sp)) {
1332 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,

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

1372 /* Update our service parms */
1373 if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba,
1374 MEM_MBOX, 1))) {
1375 emlxs_mb_config_link(hba, mbox);
1376
1377 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox,
1378 MBX_NOWAIT, 0);
1379 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
1289
1290 return (1);
1291 }
1292 }
1293
1294#ifdef DHCHAP_SUPPORT
1295 if (emlxs_dhc_verify_login(port, sid, sp)) {
1296 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,

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

1336 /* Update our service parms */
1337 if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba,
1338 MEM_MBOX, 1))) {
1339 emlxs_mb_config_link(hba, mbox);
1340
1341 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbox,
1342 MBX_NOWAIT, 0);
1343 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) {
1380 (void) emlxs_mem_put(hba, MEM_MBOX,
1381 (uint8_t *)mbox);
1344 emlxs_mem_put(hba, MEM_MBOX, (void *)mbox);
1382 }
1383
1384 }
1385 }
1386
1387 return (0);
1388
1389} /* emlxs_process_unsol_plogi() */

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

1485 emlxs_hba_t *hba = HBA;
1486 emlxs_config_t *cfg = &CFG;
1487 IOCB *iocb;
1488 uint32_t sid;
1489 NODELIST *ndlp;
1490 PRLI *npr;
1491 fc_unsol_buf_t *ubp;
1492 emlxs_ub_priv_t *ub_priv;
1345 }
1346
1347 }
1348 }
1349
1350 return (0);
1351
1352} /* emlxs_process_unsol_plogi() */

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

1448 emlxs_hba_t *hba = HBA;
1449 emlxs_config_t *cfg = &CFG;
1450 IOCB *iocb;
1451 uint32_t sid;
1452 NODELIST *ndlp;
1453 PRLI *npr;
1454 fc_unsol_buf_t *ubp;
1455 emlxs_ub_priv_t *ub_priv;
1456 uint32_t task_retry_id;
1493
1494 iocb = &iocbq->iocb;
1495 sid = iocb->un.elsreq.remoteID;
1496 ndlp = emlxs_node_find_did(port, sid);
1497
1498 if (!ndlp || !ndlp->nlp_active) {
1499 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1500 "PRLI: sid=%x: Node not found. Rejecting.", sid);

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

1506 goto drop_it;
1507 }
1508
1509 /* If node exists then save FCP2 support */
1510 npr = (PRLI *)((caddr_t)mp->virt + sizeof (uint32_t));
1511
1512 /* Check for FCP2 support */
1513 if ((npr->prliType == PRLI_FCP_TYPE) && npr->targetFunc) {
1457
1458 iocb = &iocbq->iocb;
1459 sid = iocb->un.elsreq.remoteID;
1460 ndlp = emlxs_node_find_did(port, sid);
1461
1462 if (!ndlp || !ndlp->nlp_active) {
1463 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
1464 "PRLI: sid=%x: Node not found. Rejecting.", sid);

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

1470 goto drop_it;
1471 }
1472
1473 /* If node exists then save FCP2 support */
1474 npr = (PRLI *)((caddr_t)mp->virt + sizeof (uint32_t));
1475
1476 /* Check for FCP2 support */
1477 if ((npr->prliType == PRLI_FCP_TYPE) && npr->targetFunc) {
1478 /* Clear FCP2 support if no ADISC support is requested */
1479 if (cfg[CFG_ADISC_SUPPORT].current == 0) {
1480 npr->ConfmComplAllowed = 0;
1481 npr->TaskRetryIdReq = 0;
1482 npr->Retry = 0;
1483 }
1484
1514 /* Check for target */
1515 if (npr->targetFunc) {
1516 ndlp->nlp_fcp_info |= NLP_FCP_TGT_DEVICE;
1517 } else {
1518 ndlp->nlp_fcp_info &= ~NLP_FCP_TGT_DEVICE;
1519 }
1520
1521 /* Check for initiator */
1522 if (npr->initiatorFunc) {
1523 ndlp->nlp_fcp_info |= NLP_FCP_INI_DEVICE;
1524 } else {
1525 ndlp->nlp_fcp_info &= ~NLP_FCP_INI_DEVICE;
1526 }
1527
1485 /* Check for target */
1486 if (npr->targetFunc) {
1487 ndlp->nlp_fcp_info |= NLP_FCP_TGT_DEVICE;
1488 } else {
1489 ndlp->nlp_fcp_info &= ~NLP_FCP_TGT_DEVICE;
1490 }
1491
1492 /* Check for initiator */
1493 if (npr->initiatorFunc) {
1494 ndlp->nlp_fcp_info |= NLP_FCP_INI_DEVICE;
1495 } else {
1496 ndlp->nlp_fcp_info &= ~NLP_FCP_INI_DEVICE;
1497 }
1498
1499 /* If TRI support is not required then force */
1500 /* the task_retry_id value to one */
1501 if (cfg[CFG_TRI_REQUIRED].current == 0) {
1502 task_retry_id = 1;
1503 } else {
1504 task_retry_id = npr->TaskRetryIdReq;
1505 }
1506
1528 /* Check for FCP2 target support */
1507 /* Check for FCP2 target support */
1529 if (npr->targetFunc && npr->Retry) {
1508 /* Retry and TaskRetryId bits are both required here */
1509 if (npr->targetFunc && npr->Retry && task_retry_id) {
1530 ndlp->nlp_fcp_info |= NLP_FCP_2_DEVICE;
1531 } else {
1532 ndlp->nlp_fcp_info &= ~NLP_FCP_2_DEVICE;
1533 }
1534 }
1535
1536#ifdef ULP_PATCH3
1537 if (cfg[CFG_ENABLE_PATCH].current & ULP_PATCH3) {

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

1937 "LOGO: sid=%x buffer=%p token=%x.", sid, ubp,
1938 ub_priv->token);
1939 }
1940
1941#if (EMLXS_MODREVX == EMLXS_MODREV2X)
1942 emlxs_swap_els_ub(ubp);
1943#endif /* EMLXS_MODREV2X */
1944
1510 ndlp->nlp_fcp_info |= NLP_FCP_2_DEVICE;
1511 } else {
1512 ndlp->nlp_fcp_info &= ~NLP_FCP_2_DEVICE;
1513 }
1514 }
1515
1516#ifdef ULP_PATCH3
1517 if (cfg[CFG_ENABLE_PATCH].current & ULP_PATCH3) {

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

1917 "LOGO: sid=%x buffer=%p token=%x.", sid, ubp,
1918 ub_priv->token);
1919 }
1920
1921#if (EMLXS_MODREVX == EMLXS_MODREV2X)
1922 emlxs_swap_els_ub(ubp);
1923#endif /* EMLXS_MODREV2X */
1924
1945 /* Clear the RPI */
1925 /* Unregister the node */
1946 if ((sid & FABRIC_DID_MASK) == FABRIC_DID_MASK) {
1926 if ((sid & FABRIC_DID_MASK) == FABRIC_DID_MASK) {
1947 if (emlxs_mb_unreg_did(port, sid, NULL, ubp, NULL) == 0) {
1948 /*
1949 * Deferred completion of this ubp
1950 * until unreg login is complete
1951 */
1952
1953 return;
1927 if (ndlp) {
1928 if (emlxs_mb_unreg_node(port, ndlp, NULL,
1929 ubp, NULL) == 0) {
1930 /*
1931 * Deferred completion of this ubp
1932 * until unreg login is complete
1933 */
1934 return;
1935 }
1954 }
1955 }
1956
1957 emlxs_ub_callback(port, ubp);
1958
1959drop_it:
1960
1961 return;

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

2022
2023drop_it:
2024
2025 return;
2026
2027} /* emlxs_handle_unsol_gen_cmd() */
2028
2029
1936 }
1937 }
1938
1939 emlxs_ub_callback(port, ubp);
1940
1941drop_it:
1942
1943 return;

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

2004
2005drop_it:
2006
2007 return;
2008
2009} /* emlxs_handle_unsol_gen_cmd() */
2010
2011
2012/* ARGSUSED */
2013static void
2014emlxs_handle_unsol_echo_cmd(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
2015 MATCHMAP *mp, uint32_t size)
2016{
2017 emlxs_hba_t *hba = HBA;
2018 uint8_t *bp;
2019 IOCB *iocb;
2020 uint32_t *lp;
2021 uint32_t sid;
2022 fc_packet_t *pkt;
2023 uint32_t cmd;
2024
2025 iocb = &iocbq->iocb;
2026 sid = iocb->un.elsreq.remoteID;
2027
2028 bp = mp->virt;
2029 lp = (uint32_t *)bp;
2030 cmd = *lp & ELS_CMD_MASK;
2031
2032 if (!(pkt = emlxs_pkt_alloc(port,
2033 size, 0, 0, KM_NOSLEEP))) {
2034 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
2035 "ECHO: sid=%x. Unable to allocate pkt. Rejecting.",
2036 sid);
2037
2038 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
2039 ELS_CMD_ECHO, LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);
2040 return;
2041 }
2042
2043 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
2044 "ECHO: sid=%x. Accepting.",
2045 sid);
2046
2047 /* Common initialization */
2048 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
2049 pkt->pkt_timeout = (2 * hba->fc_ratov);
2050
2051 if ((uint32_t)iocb->ULPCLASS == CLASS2) {
2052 pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
2053 pkt->pkt_tran_flags |= FC_TRAN_CLASS2;
2054 }
2055
2056 /* Build the fc header */
2057 pkt->pkt_cmd_fhdr.d_id =
2058 LE_SWAP24_LO(iocb->un.elsreq.remoteID);
2059 pkt->pkt_cmd_fhdr.r_ctl =
2060 R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
2061 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
2062 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
2063 pkt->pkt_cmd_fhdr.f_ctl =
2064 F_CTL_XCHG_CONTEXT | F_CTL_LAST_SEQ | F_CTL_END_SEQ;
2065 pkt->pkt_cmd_fhdr.seq_id = 0;
2066 pkt->pkt_cmd_fhdr.df_ctl = 0;
2067 pkt->pkt_cmd_fhdr.seq_cnt = 0;
2068 pkt->pkt_cmd_fhdr.ox_id = (cmd >> ELS_CMD_SHIFT) & 0xff;
2069 pkt->pkt_cmd_fhdr.rx_id = iocb->ULPCONTEXT;
2070 pkt->pkt_cmd_fhdr.ro = 0;
2071
2072 /* Build the response */
2073 *lp = ELS_CMD_ACC;
2074 bcopy(lp, pkt->pkt_cmd, size);
2075
2076 if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
2077 /* Free the pkt */
2078 emlxs_pkt_free(pkt);
2079 emlxs_abort_els_exchange(hba, port, iocb->ULPCONTEXT);
2080 }
2081
2082 return;
2083
2084} /* emlxs_handle_unsol_echo_cmd() */
2085
2086
2087/* ARGSUSED */
2088static void
2089emlxs_handle_unsol_rtv_cmd(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
2090 MATCHMAP *mp, uint32_t size)
2091{
2092 emlxs_hba_t *hba = HBA;
2093 uint8_t *bp;
2094 IOCB *iocb;
2095 uint32_t *lp;
2096 uint32_t sid;
2097 fc_packet_t *pkt;
2098 uint32_t cmd;
2099 SERV_PARM *sp;
2100
2101 iocb = &iocbq->iocb;
2102 sid = iocb->un.elsreq.remoteID;
2103
2104 bp = mp->virt;
2105 lp = (uint32_t *)bp;
2106 cmd = *lp & ELS_CMD_MASK;
2107
2108 if (!(pkt = emlxs_pkt_alloc(port,
2109 (4 * sizeof (uint32_t)), 0, 0, KM_NOSLEEP))) {
2110 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
2111 "RTV: sid=%x. Unable to allocate pkt. Rejecting.",
2112 sid);
2113
2114 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
2115 ELS_CMD_RTV, LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);
2116 return;
2117 }
2118
2119 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
2120 "RTV: sid=%x. Accepting.",
2121 emlxs_elscmd_xlate(cmd),
2122 sid);
2123
2124 /* Common initialization */
2125 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
2126 pkt->pkt_timeout = (2 * hba->fc_ratov);
2127
2128 if ((uint32_t)iocb->ULPCLASS == CLASS2) {
2129 pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
2130 pkt->pkt_tran_flags |= FC_TRAN_CLASS2;
2131 }
2132
2133 /* Build the fc header */
2134 pkt->pkt_cmd_fhdr.d_id =
2135 LE_SWAP24_LO(iocb->un.elsreq.remoteID);
2136 pkt->pkt_cmd_fhdr.r_ctl =
2137 R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
2138 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
2139 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
2140 pkt->pkt_cmd_fhdr.f_ctl =
2141 F_CTL_XCHG_CONTEXT | F_CTL_LAST_SEQ | F_CTL_END_SEQ;
2142 pkt->pkt_cmd_fhdr.seq_id = 0;
2143 pkt->pkt_cmd_fhdr.df_ctl = 0;
2144 pkt->pkt_cmd_fhdr.seq_cnt = 0;
2145 pkt->pkt_cmd_fhdr.ox_id = (cmd >> ELS_CMD_SHIFT) & 0xff;
2146 pkt->pkt_cmd_fhdr.rx_id = iocb->ULPCONTEXT;
2147 pkt->pkt_cmd_fhdr.ro = 0;
2148
2149 /* Build the response */
2150 sp = (SERV_PARM *)&port->sparam;
2151 lp = (uint32_t *)pkt->pkt_cmd;
2152 lp[0] = ELS_CMD_ACC;
2153 lp[1] = LE_SWAP32(sp->cmn.w2.r_a_tov);
2154 lp[2] = LE_SWAP32(sp->cmn.e_d_tov);
2155 lp[3] = LE_SWAP32(sp->cmn.edtovResolution << 26);
2156
2157 if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
2158 /* Free the pkt */
2159 emlxs_pkt_free(pkt);
2160 emlxs_abort_els_exchange(hba, port, iocb->ULPCONTEXT);
2161 }
2162
2163 return;
2164
2165} /* emlxs_handle_unsol_rtv_cmd() */
2166
2167
2168/* ARGSUSED */
2169static void
2170emlxs_rls_rsp_thread(emlxs_hba_t *hba, void *arg1, void *arg2)
2171{
2172 emlxs_port_t *port = (emlxs_port_t *)arg1;
2173 fc_packet_t *pkt = (fc_packet_t *)arg2;
2174 MAILBOXQ *mbq = NULL;
2175 MAILBOX *mb;
2176 la_els_rls_acc_t *rls;
2177 uint32_t rval;
2178
2179 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
2180 "RLS: sid=%x. Accepting.",
2181 LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id));
2182
2183 if (!(mbq = (MAILBOXQ *)emlxs_mem_get(hba, MEM_MBOX, 1))) {
2184 goto dropit;
2185 }
2186 mb = (MAILBOX *)mbq;
2187
2188 /* Read current link status */
2189 emlxs_mb_read_lnk_stat(hba, mbq);
2190 rval = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
2191
2192 if (rval != MBX_SUCCESS) {
2193 goto dropit;
2194 }
2195
2196 /* Build the response */
2197 rls = (la_els_rls_acc_t *)pkt->pkt_cmd;
2198 rls->ls_code.ls_code = 0x02;
2199 rls->rls_link_params.rls_link_fail =
2200 mb->un.varRdLnk.linkFailureCnt;
2201 rls->rls_link_params.rls_sync_loss =
2202 mb->un.varRdLnk.lossSyncCnt;
2203 rls->rls_link_params.rls_sig_loss =
2204 mb->un.varRdLnk.lossSignalCnt;
2205 rls->rls_link_params.rls_prim_seq_err =
2206 mb->un.varRdLnk.primSeqErrCnt;
2207 rls->rls_link_params.rls_invalid_word =
2208 mb->un.varRdLnk.invalidXmitWord;
2209 rls->rls_link_params.rls_invalid_crc =
2210 mb->un.varRdLnk.crcCnt;
2211
2212 LE_SWAP32_BUFFER((uint8_t *)rls, sizeof (la_els_rls_acc_t));
2213
2214 emlxs_mem_put(hba, MEM_MBOX, (void *)mbq);
2215 mbq = NULL;
2216
2217 if ((rval = emlxs_pkt_send(pkt, 1)) != FC_SUCCESS) {
2218 goto dropit;
2219 }
2220
2221 return;
2222
2223dropit:
2224
2225 emlxs_abort_els_exchange(hba, port, pkt->pkt_cmd_fhdr.rx_id);
2226
2227 emlxs_pkt_free(pkt);
2228
2229 if (mbq) {
2230 emlxs_mem_put(hba, MEM_MBOX, (void *)mbq);
2231 }
2232
2233 return;
2234
2235} /* emlxs_rls_rsp_thread() */
2236
2237
2238/* ARGSUSED */
2239static void
2240emlxs_handle_unsol_rls_cmd(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
2241 MATCHMAP *mp, uint32_t size)
2242{
2243 emlxs_hba_t *hba = HBA;
2244 uint8_t *bp;
2245 IOCB *iocb;
2246 uint32_t *lp;
2247 uint32_t sid;
2248 fc_packet_t *pkt;
2249 uint32_t cmd;
2250
2251 iocb = &iocbq->iocb;
2252 sid = iocb->un.elsreq.remoteID;
2253
2254 bp = mp->virt;
2255 lp = (uint32_t *)bp;
2256 cmd = *lp++ & ELS_CMD_MASK;
2257
2258 if (!(pkt = emlxs_pkt_alloc(port,
2259 sizeof (la_els_rls_acc_t), 0, 0, KM_NOSLEEP))) {
2260 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
2261 "RLS: sid=%x. Unable to allocate pkt. Rejecting.",
2262 sid);
2263
2264 (void) emlxs_els_reply(port, iocbq, ELS_CMD_LS_RJT,
2265 ELS_CMD_RLS, LSRJT_UNABLE_TPC, LSEXP_NOTHING_MORE);
2266 return;
2267 }
2268
2269 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_unsol_els_msg,
2270 "RLS: sid=%x. Scheduling response.",
2271 sid);
2272
2273 /* Common initialization */
2274 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
2275 pkt->pkt_timeout = (2 * hba->fc_ratov);
2276
2277 if ((uint32_t)iocb->ULPCLASS == CLASS2) {
2278 pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
2279 pkt->pkt_tran_flags |= FC_TRAN_CLASS2;
2280 }
2281
2282 /* Build the fc header */
2283 pkt->pkt_cmd_fhdr.d_id =
2284 LE_SWAP24_LO(iocb->un.elsreq.remoteID);
2285 pkt->pkt_cmd_fhdr.r_ctl =
2286 R_CTL_EXTENDED_SVC | R_CTL_SOLICITED_CONTROL;
2287 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(iocb->un.elsreq.myID);
2288 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
2289 pkt->pkt_cmd_fhdr.f_ctl =
2290 F_CTL_XCHG_CONTEXT | F_CTL_LAST_SEQ | F_CTL_END_SEQ;
2291 pkt->pkt_cmd_fhdr.seq_id = 0;
2292 pkt->pkt_cmd_fhdr.df_ctl = 0;
2293 pkt->pkt_cmd_fhdr.seq_cnt = 0;
2294 pkt->pkt_cmd_fhdr.ox_id = (cmd >> ELS_CMD_SHIFT) & 0xff;
2295 pkt->pkt_cmd_fhdr.rx_id = iocb->ULPCONTEXT;
2296 pkt->pkt_cmd_fhdr.ro = 0;
2297
2298 /* We must spawn a separate thread to send the */
2299 /* read link status mailbox command becasue we are */
2300 /* normally in a hardware interrupt context here. */
2301 emlxs_thread_spawn(hba, emlxs_rls_rsp_thread,
2302 (void *)port, (void *)pkt);
2303
2304 return;
2305
2306} /* emlxs_handle_unsol_rls_cmd() */
2307
2308
2030/* This handles the reply completions to unsolicited cmds */
2031/* ARGSUSED */
2032static void
2033emlxs_handle_acc(emlxs_port_t *port, emlxs_buf_t *sbp, IOCBQ *iocbq,
2034 uint32_t flag)
2035{
2036 emlxs_hba_t *hba = HBA;
2037 fc_packet_t *pkt;

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

2150extern int32_t
2151emlxs_els_reply(emlxs_port_t *port, IOCBQ *iocbq, uint32_t type,
2152 uint32_t type2, uint32_t reason, uint32_t explain)
2153{
2154 emlxs_hba_t *hba = HBA;
2155 emlxs_config_t *cfg = &CFG;
2156 fc_packet_t *pkt;
2157 ELS_PKT *els;
2309/* This handles the reply completions to unsolicited cmds */
2310/* ARGSUSED */
2311static void
2312emlxs_handle_acc(emlxs_port_t *port, emlxs_buf_t *sbp, IOCBQ *iocbq,
2313 uint32_t flag)
2314{
2315 emlxs_hba_t *hba = HBA;
2316 fc_packet_t *pkt;

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

2429extern int32_t
2430emlxs_els_reply(emlxs_port_t *port, IOCBQ *iocbq, uint32_t type,
2431 uint32_t type2, uint32_t reason, uint32_t explain)
2432{
2433 emlxs_hba_t *hba = HBA;
2434 emlxs_config_t *cfg = &CFG;
2435 fc_packet_t *pkt;
2436 ELS_PKT *els;
2158 uint32_t rval;
2159 IOCB *iocb;
2160
2161 iocb = &iocbq->iocb;
2162
2163 switch (type) {
2164 case ELS_CMD_ACC: /* Accept Response */
2165
2166 /* Allocate the pkt */
2167 switch (type2) {
2168 case ELS_CMD_FLOGI:
2437 IOCB *iocb;
2438
2439 iocb = &iocbq->iocb;
2440
2441 switch (type) {
2442 case ELS_CMD_ACC: /* Accept Response */
2443
2444 /* Allocate the pkt */
2445 switch (type2) {
2446 case ELS_CMD_FLOGI:
2169 if (!(pkt = emlxs_pkt_alloc(port,
2447 pkt = emlxs_pkt_alloc(port,
2170 sizeof (uint32_t) + sizeof (SERV_PARM), 0,
2448 sizeof (uint32_t) + sizeof (SERV_PARM), 0,
2171 0, KM_NOSLEEP))) {
2172 return (1);
2173 }
2449 0, KM_NOSLEEP);
2174 break;
2175
2176 case ELS_CMD_ADISC:
2450 break;
2451
2452 case ELS_CMD_ADISC:
2177 if (!(pkt = emlxs_pkt_alloc(port,
2453 pkt = emlxs_pkt_alloc(port,
2178 sizeof (uint32_t) + sizeof (ADISC), 0, 0,
2454 sizeof (uint32_t) + sizeof (ADISC), 0, 0,
2179 KM_NOSLEEP))) {
2180 return (1);
2181 }
2455 KM_NOSLEEP);
2182 break;
2183
2184 case ELS_CMD_PRLI:
2456 break;
2457
2458 case ELS_CMD_PRLI:
2185 if (!(pkt = emlxs_pkt_alloc(port,
2459 pkt = emlxs_pkt_alloc(port,
2186 sizeof (uint32_t) + sizeof (PRLI), 0, 0,
2460 sizeof (uint32_t) + sizeof (PRLI), 0, 0,
2187 KM_NOSLEEP))) {
2188 return (1);
2189 }
2461 KM_NOSLEEP);
2190 break;
2191
2192 case ELS_CMD_PRLO:
2462 break;
2463
2464 case ELS_CMD_PRLO:
2193 if (!(pkt = emlxs_pkt_alloc(port,
2465 pkt = emlxs_pkt_alloc(port,
2194 sizeof (uint32_t) + sizeof (PRLO), 0, 0,
2466 sizeof (uint32_t) + sizeof (PRLO), 0, 0,
2195 KM_NOSLEEP))) {
2196 return (1);
2197 }
2467 KM_NOSLEEP);
2198 break;
2199
2200 case ELS_CMD_AUTH:
2201 default:
2468 break;
2469
2470 case ELS_CMD_AUTH:
2471 default:
2472 pkt = emlxs_pkt_alloc(port, sizeof (uint32_t),
2473 0, 0, KM_NOSLEEP);
2474 }
2202
2475
2203 if (!(pkt = emlxs_pkt_alloc(port, sizeof (uint32_t),
2204 0, 0, KM_NOSLEEP))) {
2205 return (1);
2206 }
2476 if (!pkt) {
2477 goto dropit;
2207 }
2208
2209 /* Common initialization */
2210 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
2211 pkt->pkt_timeout = (2 * hba->fc_ratov);
2212
2213 if ((uint32_t)iocb->ULPCLASS == CLASS2) {
2214 pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;

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

2270 }
2271
2272 if (port->tgt_mode) {
2273 els->un.prli.targetFunc = 1;
2274 }
2275
2276 els->un.prli.readXferRdyDis = 1;
2277
2478 }
2479
2480 /* Common initialization */
2481 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
2482 pkt->pkt_timeout = (2 * hba->fc_ratov);
2483
2484 if ((uint32_t)iocb->ULPCLASS == CLASS2) {
2485 pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;

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

2541 }
2542
2543 if (port->tgt_mode) {
2544 els->un.prli.targetFunc = 1;
2545 }
2546
2547 els->un.prli.readXferRdyDis = 1;
2548
2278 if (hba->vpd.feaLevelHigh >= 0x02) {
2549 if ((hba->vpd.feaLevelHigh >= 0x02) &&
2550 (cfg[CFG_ADISC_SUPPORT].current != 0)) {
2279 els->un.prli.ConfmComplAllowed = 1;
2280 els->un.prli.Retry = 1;
2281 els->un.prli.TaskRetryIdReq = 1;
2282 } else {
2283 els->un.prli.ConfmComplAllowed = 0;
2284 els->un.prli.Retry = 0;
2285 els->un.prli.TaskRetryIdReq = 0;
2286 }

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

2301
2302 } /* switch(type2) */
2303 break;
2304
2305 case ELS_CMD_LS_RJT: /* reject response */
2306
2307 if (!(pkt = emlxs_pkt_alloc(port,
2308 sizeof (uint32_t) + sizeof (LS_RJT), 0, 0, KM_NOSLEEP))) {
2551 els->un.prli.ConfmComplAllowed = 1;
2552 els->un.prli.Retry = 1;
2553 els->un.prli.TaskRetryIdReq = 1;
2554 } else {
2555 els->un.prli.ConfmComplAllowed = 0;
2556 els->un.prli.Retry = 0;
2557 els->un.prli.TaskRetryIdReq = 0;
2558 }

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

2573
2574 } /* switch(type2) */
2575 break;
2576
2577 case ELS_CMD_LS_RJT: /* reject response */
2578
2579 if (!(pkt = emlxs_pkt_alloc(port,
2580 sizeof (uint32_t) + sizeof (LS_RJT), 0, 0, KM_NOSLEEP))) {
2309 return (1);
2581 goto dropit;
2310 }
2311
2312 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
2313 pkt->pkt_timeout = (2 * hba->fc_ratov);
2314
2315 if ((uint32_t)iocb->ULPCLASS == CLASS2) {
2316 pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
2317 pkt->pkt_tran_flags |= FC_TRAN_CLASS2;

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

2345 els->un.lsRjt.un.b.lsRjtRsvd0 = 0;
2346 els->un.lsRjt.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2347 els->un.lsRjt.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
2348 els->un.lsRjt.un.b.vendorUnique = 0x01;
2349
2350 break;
2351 }
2352
2582 }
2583
2584 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
2585 pkt->pkt_timeout = (2 * hba->fc_ratov);
2586
2587 if ((uint32_t)iocb->ULPCLASS == CLASS2) {
2588 pkt->pkt_tran_flags &= ~FC_TRAN_CLASS3;
2589 pkt->pkt_tran_flags |= FC_TRAN_CLASS2;

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

2617 els->un.lsRjt.un.b.lsRjtRsvd0 = 0;
2618 els->un.lsRjt.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
2619 els->un.lsRjt.un.b.lsRjtRsnCodeExp = LSEXP_NOTHING_MORE;
2620 els->un.lsRjt.un.b.vendorUnique = 0x01;
2621
2622 break;
2623 }
2624
2353 if ((rval = emlxs_pkt_send(pkt, 1)) != FC_SUCCESS) {
2625 if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
2354 /* Free the pkt */
2355 emlxs_pkt_free(pkt);
2626 /* Free the pkt */
2627 emlxs_pkt_free(pkt);
2628 goto dropit;
2356 }
2357
2629 }
2630
2358 return (rval);
2631 return (0);
2359
2632
2633dropit:
2634
2635 emlxs_abort_els_exchange(hba, port, iocb->ULPCONTEXT);
2636 return (1);
2637
2360} /* emlxs_els_reply() */
2361
2362
2363#ifdef ULP_PATCH6
2364
2365extern uint32_t
2366emlxs_generate_rscn(emlxs_port_t *port, uint32_t d_id)
2367{

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

2947 emlxs_abort_ct_exchange(hba, port, iocb->ULPCONTEXT);
2948 }
2949
2950 return (0);
2951
2952} /* emlxs_ct_handle_unsol_req() */
2953
2954
2638} /* emlxs_els_reply() */
2639
2640
2641#ifdef ULP_PATCH6
2642
2643extern uint32_t
2644emlxs_generate_rscn(emlxs_port_t *port, uint32_t d_id)
2645{

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

3225 emlxs_abort_ct_exchange(hba, port, iocb->ULPCONTEXT);
3226 }
3227
3228 return (0);
3229
3230} /* emlxs_ct_handle_unsol_req() */
3231
3232
3233#if (EMLXS_MODREV < EMLXS_MODREV4)
2955static void
2956emlxs_send_rsnn(emlxs_port_t *port)
2957{
2958 emlxs_hba_t *hba = HBA;
2959 fc_packet_t *pkt;
2960 SLI_CT_REQUEST *ct;
2961
2962 if (!(pkt = emlxs_pkt_alloc(port, sizeof (SLI_CT_REQUEST),

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

3005 if (emlxs_pkt_send(pkt, 0) != FC_SUCCESS) {
3006 /* Free the pkt */
3007 emlxs_pkt_free(pkt);
3008 }
3009
3010 return;
3011
3012} /* emlxs_send_rsnn() */
3234static void
3235emlxs_send_rsnn(emlxs_port_t *port)
3236{
3237 emlxs_hba_t *hba = HBA;
3238 fc_packet_t *pkt;
3239 SLI_CT_REQUEST *ct;
3240
3241 if (!(pkt = emlxs_pkt_alloc(port, sizeof (SLI_CT_REQUEST),

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

3284 if (emlxs_pkt_send(pkt, 0) != FC_SUCCESS) {
3285 /* Free the pkt */
3286 emlxs_pkt_free(pkt);
3287 }
3288
3289 return;
3290
3291} /* emlxs_send_rsnn() */
3292#endif /* < EMLXS_MODREV4 */
3013
3014
3293
3294
3295
3015extern uint32_t
3016emlxs_ub_send_login_acc(emlxs_port_t *port, fc_unsol_buf_t *ubp)
3017{
3018 emlxs_hba_t *hba = HBA;
3019 fc_packet_t *pkt;
3020 ELS_PKT *els;
3021 uint32_t rval;
3022 emlxs_ub_priv_t *ub_priv;

--- 101 unchanged lines hidden --- 		3296extern uint32_t
3297emlxs_ub_send_login_acc(emlxs_port_t *port, fc_unsol_buf_t *ubp)
3298{
3299 emlxs_hba_t *hba = HBA;
3300 fc_packet_t *pkt;
3301 ELS_PKT *els;
3302 uint32_t rval;
3303 emlxs_ub_priv_t *ub_priv;

--- 101 unchanged lines hidden ---