emlxs_dfc.c (4baa2c25) emlxs_dfc.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
28#include <emlxs.h>
29
29#ifdef DFC_SUPPORT
30
31/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
32EMLXS_MSG_DEF(EMLXS_DFC_C);
33
34static int32_t emlxs_dfc_get_rev(emlxs_hba_t *hba, dfc_t *dfc,
35 int32_t mode);
36static int32_t emlxs_dfc_get_hbainfo(emlxs_hba_t *hba, dfc_t *dfc,
37 int32_t mode);
38static int32_t emlxs_dfc_get_hbastats(emlxs_hba_t *hba, dfc_t *dfc,

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

89 int32_t mode);
90static int32_t emlxs_dfc_get_nodeinfo(emlxs_hba_t *hba, dfc_t *dfc,
91 int32_t mode);
92
93#ifdef SFCT_SUPPORT
94static int32_t emlxs_dfc_get_fctstat(emlxs_hba_t *hba, dfc_t *dfc,
95 int32_t mode);
96#endif /* SFCT_SUPPORT */
30/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
31EMLXS_MSG_DEF(EMLXS_DFC_C);
32
33static int32_t emlxs_dfc_get_rev(emlxs_hba_t *hba, dfc_t *dfc,
34 int32_t mode);
35static int32_t emlxs_dfc_get_hbainfo(emlxs_hba_t *hba, dfc_t *dfc,
36 int32_t mode);
37static int32_t emlxs_dfc_get_hbastats(emlxs_hba_t *hba, dfc_t *dfc,

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

88 int32_t mode);
89static int32_t emlxs_dfc_get_nodeinfo(emlxs_hba_t *hba, dfc_t *dfc,
90 int32_t mode);
91
92#ifdef SFCT_SUPPORT
93static int32_t emlxs_dfc_get_fctstat(emlxs_hba_t *hba, dfc_t *dfc,
94 int32_t mode);
95#endif /* SFCT_SUPPORT */
97#ifdef NPIV_SUPPORT
96
98static int32_t emlxs_dfc_create_vport(emlxs_hba_t *hba, dfc_t *dfc,
99 int32_t mode);
100static int32_t emlxs_dfc_destroy_vport(emlxs_hba_t *hba, dfc_t *dfc,
101 int32_t mode);
102static int32_t emlxs_dfc_get_vportinfo(emlxs_hba_t *hba, dfc_t *dfc,
103 int32_t mode);
104static int32_t emlxs_dfc_npiv_resource(emlxs_hba_t *hba, dfc_t *dfc,
105 int32_t mode);
106static int32_t emlxs_dfc_npiv_test(emlxs_hba_t *hba, dfc_t *dfc,
107 int32_t mode);
97static int32_t emlxs_dfc_create_vport(emlxs_hba_t *hba, dfc_t *dfc,
98 int32_t mode);
99static int32_t emlxs_dfc_destroy_vport(emlxs_hba_t *hba, dfc_t *dfc,
100 int32_t mode);
101static int32_t emlxs_dfc_get_vportinfo(emlxs_hba_t *hba, dfc_t *dfc,
102 int32_t mode);
103static int32_t emlxs_dfc_npiv_resource(emlxs_hba_t *hba, dfc_t *dfc,
104 int32_t mode);
105static int32_t emlxs_dfc_npiv_test(emlxs_hba_t *hba, dfc_t *dfc,
106 int32_t mode);
108static emlxs_port_t *emlxs_vport_find_wwpn(emlxs_hba_t *hba, uint8_t *wwpn);
109#endif /* NPIV_SUPPORT */
107static emlxs_port_t *emlxs_vport_find_wwpn(emlxs_hba_t *hba, uint8_t *wwpn);
110
111#ifdef DHCHAP_SUPPORT
112static int32_t emlxs_dfc_init_auth(emlxs_hba_t *hba, dfc_t *dfc,
113 int32_t mode);
114static int32_t emlxs_dfc_get_auth_cfg(emlxs_hba_t *hba, dfc_t *dfc,
115 int32_t mode);
116static int32_t emlxs_dfc_set_auth_cfg(emlxs_hba_t *hba, dfc_t *dfc,
117 int32_t mode);

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

138static int32_t emlxs_dfc_sd_reset_collection(emlxs_hba_t *hba,
139 dfc_t *dfc, int32_t mode);
140static int32_t emlxs_dfc_sd_get_data(emlxs_hba_t *hba, dfc_t *dfc,
141 int32_t mode);
142static int32_t emlxs_dfc_sd_set_event(emlxs_hba_t *hba, dfc_t *dfc,
143 int32_t mode);
144static int32_t emlxs_dfc_sd_get_event(emlxs_hba_t *hba, dfc_t *dfc,
145 int32_t mode);
108
109#ifdef DHCHAP_SUPPORT
110static int32_t emlxs_dfc_init_auth(emlxs_hba_t *hba, dfc_t *dfc,
111 int32_t mode);
112static int32_t emlxs_dfc_get_auth_cfg(emlxs_hba_t *hba, dfc_t *dfc,
113 int32_t mode);
114static int32_t emlxs_dfc_set_auth_cfg(emlxs_hba_t *hba, dfc_t *dfc,
115 int32_t mode);

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

136static int32_t emlxs_dfc_sd_reset_collection(emlxs_hba_t *hba,
137 dfc_t *dfc, int32_t mode);
138static int32_t emlxs_dfc_sd_get_data(emlxs_hba_t *hba, dfc_t *dfc,
139 int32_t mode);
140static int32_t emlxs_dfc_sd_set_event(emlxs_hba_t *hba, dfc_t *dfc,
141 int32_t mode);
142static int32_t emlxs_dfc_sd_get_event(emlxs_hba_t *hba, dfc_t *dfc,
143 int32_t mode);
146#endif
144#endif /* SAN_DIAG_SUPPORT */
147
148static int32_t emlxs_dfc_send_scsi_fcp(emlxs_hba_t *hba, dfc_t *dfc,
149 int32_t mode);
150#ifdef FCIO_SUPPORT
151static int32_t emlxs_fcio_manage(emlxs_hba_t *hba, dfc_t *dfc,
152 int32_t mode);
153#endif /* FCIO_SUPPORT */
154
145
146static int32_t emlxs_dfc_send_scsi_fcp(emlxs_hba_t *hba, dfc_t *dfc,
147 int32_t mode);
148#ifdef FCIO_SUPPORT
149static int32_t emlxs_fcio_manage(emlxs_hba_t *hba, dfc_t *dfc,
150 int32_t mode);
151#endif /* FCIO_SUPPORT */
152
153static int32_t emlxs_dfc_get_persist_linkdown(emlxs_hba_t *hba,
154 dfc_t *dfc, int32_t mode);
155static int32_t emlxs_dfc_set_persist_linkdown(emlxs_hba_t *hba,
156 dfc_t *dfc, int32_t mode);
155
157
158/* SLI-4 ioctls */
159static int32_t emlxs_dfc_get_fcflist(emlxs_hba_t *hba, dfc_t *dfc,
160 int32_t mode);
161static int32_t emlxs_dfc_send_mbox4(emlxs_hba_t *hba, dfc_t *dfc,
162 int32_t mode);
163static int emlxs_dfc_rd_be_fcf(emlxs_hba_t *hba, dfc_t *dfc,
164 int32_t mode);
165static int emlxs_dfc_set_be_dcbx(emlxs_hba_t *hba, dfc_t *dfc,
166 int32_t mode);
167static int emlxs_dfc_get_be_dcbx(emlxs_hba_t *hba, dfc_t *dfc,
168 int32_t mode);
169
170
156uint32_t emlxs_loopback_tmo = 60;
157
158emlxs_table_t emlxs_dfc_table[] = {
159 {EMLXS_GET_HBAINFO, "GET_HBAINFO"},
160 {EMLXS_GET_REV, "GET_REV"},
161 {EMLXS_SET_DIAG, "SET_DIAG"},
162 {EMLXS_SEND_MBOX, "SEND_MBOX"},
163 {EMLXS_READ_PCI, "READ_PCI"},

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

196 {EMLXS_SET_AUTH_CFG, "SET_AUTH_CFG"},
197 {EMLXS_GET_AUTH_PASSWORD, "GET_AUTH_PASSWORD"},
198 {EMLXS_SET_AUTH_PASSWORD, "SET_AUTH_PASSWORD"},
199 {EMLXS_GET_AUTH_STATUS, "GET_AUTH_STATUS"},
200 {EMLXS_GET_AUTH_CFG_TABLE, "GET_AUTH_CFG_TABLE"},
201 {EMLXS_GET_AUTH_KEY_TABLE, "GET_AUTH_KEY_TABLE"},
202 {EMLXS_FCIO_CMD, "FCIO_CMD"},
203 {EMLXS_GET_FCTSTAT, "GET_FCTSTAT"},
171uint32_t emlxs_loopback_tmo = 60;
172
173emlxs_table_t emlxs_dfc_table[] = {
174 {EMLXS_GET_HBAINFO, "GET_HBAINFO"},
175 {EMLXS_GET_REV, "GET_REV"},
176 {EMLXS_SET_DIAG, "SET_DIAG"},
177 {EMLXS_SEND_MBOX, "SEND_MBOX"},
178 {EMLXS_READ_PCI, "READ_PCI"},

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

211 {EMLXS_SET_AUTH_CFG, "SET_AUTH_CFG"},
212 {EMLXS_GET_AUTH_PASSWORD, "GET_AUTH_PASSWORD"},
213 {EMLXS_SET_AUTH_PASSWORD, "SET_AUTH_PASSWORD"},
214 {EMLXS_GET_AUTH_STATUS, "GET_AUTH_STATUS"},
215 {EMLXS_GET_AUTH_CFG_TABLE, "GET_AUTH_CFG_TABLE"},
216 {EMLXS_GET_AUTH_KEY_TABLE, "GET_AUTH_KEY_TABLE"},
217 {EMLXS_FCIO_CMD, "FCIO_CMD"},
218 {EMLXS_GET_FCTSTAT, "GET_FCTSTAT"},
219 {EMLXS_GET_PERSIST_LINKDOWN, "GET_PERSIST_LINKDOWN"},
220 {EMLXS_SET_PERSIST_LINKDOWN, "SET_PERSIST_LINKDOWN"},
221 {EMLXS_GET_FCOE_FCFLIST, "GET_FCOE_FCFLIST"},
222 {EMLXS_SEND_MBOX4, "SEND_MBOX4"},
223 {EMLXS_RD_BE_FCF, "RD_BE_FCF"},
224 {EMLXS_SET_BE_DCBX, "SET_BE_DCBX"},
225 {EMLXS_GET_BE_DCBX, "GET_BE_DCBX"},
204
205}; /* emlxs_dfc_table */
206
207
208emlxs_table_t emlxs_dfc_event_table[] = {
209 {FC_REG_LINK_EVENT, "LINK_EVENT"},
210 {FC_REG_RSCN_EVENT, "RSCN_EVENT"},
211 {FC_REG_CT_EVENT, "CT_EVENT"},
212 {FC_REG_DUMP_EVENT, "DUMP_EVENT"},
213 {FC_REG_TEMP_EVENT, "TEMP_EVENT"},
214 {FC_REG_VPORTRSCN_EVENT, "VPORTRSCN_EVENT"},
215 {FC_REG_FCOE_EVENT, "FCOE_EVENT"},
216
217}; /* emlxs_dfc_event_table */
218
219
220#ifdef SAN_DIAG_SUPPORT
221kmutex_t sd_bucket_mutex;
222sd_bucket_info_t sd_bucket;
226
227}; /* emlxs_dfc_table */
228
229
230emlxs_table_t emlxs_dfc_event_table[] = {
231 {FC_REG_LINK_EVENT, "LINK_EVENT"},
232 {FC_REG_RSCN_EVENT, "RSCN_EVENT"},
233 {FC_REG_CT_EVENT, "CT_EVENT"},
234 {FC_REG_DUMP_EVENT, "DUMP_EVENT"},
235 {FC_REG_TEMP_EVENT, "TEMP_EVENT"},
236 {FC_REG_VPORTRSCN_EVENT, "VPORTRSCN_EVENT"},
237 {FC_REG_FCOE_EVENT, "FCOE_EVENT"},
238
239}; /* emlxs_dfc_event_table */
240
241
242#ifdef SAN_DIAG_SUPPORT
243kmutex_t sd_bucket_mutex;
244sd_bucket_info_t sd_bucket;
223#endif
245#endif /* SAN_DIAG_SUPPORT */
224
225extern char *
226emlxs_dfc_xlate(uint16_t cmd)
227{
228 static char buffer[32];
229 uint32_t i;
230 uint32_t count;
231

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

265
266extern int32_t
267emlxs_dfc_manage(emlxs_hba_t *hba, void *arg, int32_t mode)
268{
269 emlxs_port_t *port = &PPORT;
270 int rval = 0;
271 dfc_t *dfc;
272
246
247extern char *
248emlxs_dfc_xlate(uint16_t cmd)
249{
250 static char buffer[32];
251 uint32_t i;
252 uint32_t count;
253

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

287
288extern int32_t
289emlxs_dfc_manage(emlxs_hba_t *hba, void *arg, int32_t mode)
290{
291 emlxs_port_t *port = &PPORT;
292 int rval = 0;
293 dfc_t *dfc;
294
273 if (!(dfc = (dfc_t *)kmem_zalloc(sizeof (dfc_t), KM_SLEEP))) {
274 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
275 "%s: Unable to allocate dfc buffer.",
276 emlxs_dfc_xlate(dfc->cmd));
295 dfc = (dfc_t *)kmem_zalloc(sizeof (dfc_t), KM_SLEEP);
277
296
278 return (DFC_SYSRES_ERROR);
279 }
280#ifdef _MULTI_DATAMODEL
281 switch (ddi_model_convert_from(mode & FMODELS)) {
282 case DDI_MODEL_ILP32:
283 {
284 dfc32_t dfc32;
285
286 if (ddi_copyin((void *)arg, (void *)&dfc32,
287 sizeof (dfc32_t), mode)) {

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

595 case EMLXS_SEND_SCSI:
596 {
597 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
598 "%s requested.", emlxs_dfc_xlate(dfc->cmd));
599 rval = emlxs_dfc_send_scsi_fcp(hba, dfc, mode);
600 break;
601 }
602
297#ifdef _MULTI_DATAMODEL
298 switch (ddi_model_convert_from(mode & FMODELS)) {
299 case DDI_MODEL_ILP32:
300 {
301 dfc32_t dfc32;
302
303 if (ddi_copyin((void *)arg, (void *)&dfc32,
304 sizeof (dfc32_t), mode)) {

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

612 case EMLXS_SEND_SCSI:
613 {
614 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
615 "%s requested.", emlxs_dfc_xlate(dfc->cmd));
616 rval = emlxs_dfc_send_scsi_fcp(hba, dfc, mode);
617 break;
618 }
619
603#ifdef NPIV_SUPPORT
604 case EMLXS_CREATE_VPORT:
605 {
606
607 rval = emlxs_dfc_create_vport(hba, dfc, mode);
608
609 break;
610 }
611

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

633 }
634
635 case EMLXS_NPIV_TEST:
636 {
637 rval = emlxs_dfc_npiv_test(hba, dfc, mode);
638
639 break;
640 }
620 case EMLXS_CREATE_VPORT:
621 {
622
623 rval = emlxs_dfc_create_vport(hba, dfc, mode);
624
625 break;
626 }
627

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

649 }
650
651 case EMLXS_NPIV_TEST:
652 {
653 rval = emlxs_dfc_npiv_test(hba, dfc, mode);
654
655 break;
656 }
641#endif /* NPIV_SUPPORT */
642
643#ifdef DHCHAP_SUPPORT
644 case EMLXS_INIT_AUTH:
645 {
646 rval = emlxs_dfc_init_auth(hba, dfc, mode);
647
648 break;
649 }

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

734
735 case EMLXS_SD_SET_EVENT:
736 rval = emlxs_dfc_sd_set_event(hba, dfc, mode);
737 break;
738
739 case EMLXS_SD_GET_EVENT:
740 rval = emlxs_dfc_sd_get_event(hba, dfc, mode);
741 break;
657
658#ifdef DHCHAP_SUPPORT
659 case EMLXS_INIT_AUTH:
660 {
661 rval = emlxs_dfc_init_auth(hba, dfc, mode);
662
663 break;
664 }

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

749
750 case EMLXS_SD_SET_EVENT:
751 rval = emlxs_dfc_sd_set_event(hba, dfc, mode);
752 break;
753
754 case EMLXS_SD_GET_EVENT:
755 rval = emlxs_dfc_sd_get_event(hba, dfc, mode);
756 break;
742#endif
757#endif /* SAN_DIAG_SUPPORT */
743
758
759 case EMLXS_GET_PERSIST_LINKDOWN:
760 rval = emlxs_dfc_get_persist_linkdown(hba, dfc, mode);
761 break;
762
763 case EMLXS_SET_PERSIST_LINKDOWN:
764 rval = emlxs_dfc_set_persist_linkdown(hba, dfc, mode);
765 break;
766
767 case EMLXS_GET_FCOE_FCFLIST:
768 rval = emlxs_dfc_get_fcflist(hba, dfc, mode);
769 break;
770
771 case EMLXS_SEND_MBOX4:
772 rval = emlxs_dfc_send_mbox4(hba, dfc, mode);
773 break;
774
775 case EMLXS_RD_BE_FCF:
776 rval = emlxs_dfc_rd_be_fcf(hba, dfc, mode);
777 break;
778
779 case EMLXS_SET_BE_DCBX:
780 rval = emlxs_dfc_set_be_dcbx(hba, dfc, mode);
781 break;
782
783 case EMLXS_GET_BE_DCBX:
784 rval = emlxs_dfc_get_be_dcbx(hba, dfc, mode);
785 break;
786
744 default:
745 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
746 "Unknown command received. (0x%x)", dfc->cmd);
747 rval = DFC_ARG_INVALID;
748
749 } /* switch() */
750
751 kmem_free(dfc, sizeof (dfc_t));

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

781 {FCIO_NS, "NS"},
782 {FCIO_DOWNLOAD_FW, "DOWNLOAD_FW"},
783 {FCIO_GET_HOST_PARAMS, "GET_HOST_PARAMS"},
784 {FCIO_LINK_STATUS, "LINK_STATUS"},
785 {FCIO_DOWNLOAD_FCODE, "DOWNLOAD_FCODE"},
786 {FCIO_GET_NODE_ID, "GET_NODE_ID"},
787 {FCIO_SET_NODE_ID, "SET_NODE_ID"},
788 {FCIO_SEND_NODE_ID, "SEND_NODE_ID"},
787 default:
788 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
789 "Unknown command received. (0x%x)", dfc->cmd);
790 rval = DFC_ARG_INVALID;
791
792 } /* switch() */
793
794 kmem_free(dfc, sizeof (dfc_t));

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

824 {FCIO_NS, "NS"},
825 {FCIO_DOWNLOAD_FW, "DOWNLOAD_FW"},
826 {FCIO_GET_HOST_PARAMS, "GET_HOST_PARAMS"},
827 {FCIO_LINK_STATUS, "LINK_STATUS"},
828 {FCIO_DOWNLOAD_FCODE, "DOWNLOAD_FCODE"},
829 {FCIO_GET_NODE_ID, "GET_NODE_ID"},
830 {FCIO_SET_NODE_ID, "SET_NODE_ID"},
831 {FCIO_SEND_NODE_ID, "SEND_NODE_ID"},
832 /* {FCIO_GET_P2P_INFO, "GET_P2P_INFO"}, */
789 {FCIO_GET_ADAPTER_ATTRIBUTES, "GET_ADAPTER_ATTRIBUTES"},
790 {FCIO_GET_OTHER_ADAPTER_PORTS, "GET_OTHER_ADAPTER_PORTS"},
791 {FCIO_GET_ADAPTER_PORT_ATTRIBUTES, "GET_ADAPTER_PORT_ATTRIBUTES"},
792 {FCIO_GET_DISCOVERED_PORT_ATTRIBUTES, "GET_DISCOVERED_PORT_ATTRIBUTES"},
793 {FCIO_GET_PORT_ATTRIBUTES, "GET_PORT_ATTRIBUTES"},
794 {FCIO_GET_ADAPTER_PORT_STATS, "GET_ADAPTER_PORT_STATS"},
795}; /* emlxs_fcio_table */
796

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

857 fcio->fcio_cmd_flags = dfc->data2;
858 fcio->fcio_xfer = dfc->data3;
859 fcio->fcio_errno = 0; /* dfc->buf4 on return */
860
861 if (dfc->buf1_size && dfc->buf1) {
862 fcio->fcio_ilen = dfc->buf1_size;
863 fcio->fcio_ibuf = kmem_zalloc(dfc->buf1_size, KM_SLEEP);
864
833 {FCIO_GET_ADAPTER_ATTRIBUTES, "GET_ADAPTER_ATTRIBUTES"},
834 {FCIO_GET_OTHER_ADAPTER_PORTS, "GET_OTHER_ADAPTER_PORTS"},
835 {FCIO_GET_ADAPTER_PORT_ATTRIBUTES, "GET_ADAPTER_PORT_ATTRIBUTES"},
836 {FCIO_GET_DISCOVERED_PORT_ATTRIBUTES, "GET_DISCOVERED_PORT_ATTRIBUTES"},
837 {FCIO_GET_PORT_ATTRIBUTES, "GET_PORT_ATTRIBUTES"},
838 {FCIO_GET_ADAPTER_PORT_STATS, "GET_ADAPTER_PORT_STATS"},
839}; /* emlxs_fcio_table */
840

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

901 fcio->fcio_cmd_flags = dfc->data2;
902 fcio->fcio_xfer = dfc->data3;
903 fcio->fcio_errno = 0; /* dfc->buf4 on return */
904
905 if (dfc->buf1_size && dfc->buf1) {
906 fcio->fcio_ilen = dfc->buf1_size;
907 fcio->fcio_ibuf = kmem_zalloc(dfc->buf1_size, KM_SLEEP);
908
865 if (!fcio->fcio_ibuf) {
866 EMLXS_MSGF(EMLXS_CONTEXT,
867 &emlxs_dfc_error_msg,
868 "%s: %s: Unable to allocate ibuf. (size=%d)",
869 emlxs_dfc_xlate(dfc->cmd),
870 emlxs_fcio_xlate(dfc->data1), fcio->fcio_ilen);
871
872 rval = EFAULT;
873 goto done;
874 }
875
876 if (ddi_copyin(dfc->buf1, fcio->fcio_ibuf, fcio->fcio_ilen,
877 mode)) {
878 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
879 "%s: %s: ddi_copyin failed. (size=%d)",
880 emlxs_dfc_xlate(dfc->cmd),
881 emlxs_fcio_xlate(dfc->data1), fcio->fcio_ilen);
882
883 rval = EFAULT;
884 goto done;
885 }
886 }
887
888 if (dfc->buf2_size && dfc->buf2) {
889 fcio->fcio_olen = dfc->buf2_size;
890 fcio->fcio_obuf = kmem_zalloc(dfc->buf2_size, KM_SLEEP);
891
909 if (ddi_copyin(dfc->buf1, fcio->fcio_ibuf, fcio->fcio_ilen,
910 mode)) {
911 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
912 "%s: %s: ddi_copyin failed. (size=%d)",
913 emlxs_dfc_xlate(dfc->cmd),
914 emlxs_fcio_xlate(dfc->data1), fcio->fcio_ilen);
915
916 rval = EFAULT;
917 goto done;
918 }
919 }
920
921 if (dfc->buf2_size && dfc->buf2) {
922 fcio->fcio_olen = dfc->buf2_size;
923 fcio->fcio_obuf = kmem_zalloc(dfc->buf2_size, KM_SLEEP);
924
892 if (!fcio->fcio_obuf) {
893 EMLXS_MSGF(EMLXS_CONTEXT,
894 &emlxs_dfc_error_msg,
895 "%s: %s: Unable to allocate obuf. (size=%d)",
896 emlxs_dfc_xlate(dfc->cmd),
897 emlxs_fcio_xlate(dfc->data1), fcio->fcio_olen);
898
899 rval = EFAULT;
900 goto done;
901 }
902
903 if (ddi_copyin(dfc->buf2, fcio->fcio_obuf, fcio->fcio_olen,
904 mode)) {
905 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
906 "%s: %s: ddi_copyin failed. (size=%d)",
907 emlxs_dfc_xlate(dfc->cmd),
908 emlxs_fcio_xlate(dfc->data1), fcio->fcio_olen);
909
910 rval = EFAULT;
911 goto done;
912 }
913 }
914
915 if (dfc->buf3_size && dfc->buf3) {
916 fcio->fcio_alen = dfc->buf3_size;
917 fcio->fcio_abuf = kmem_zalloc(dfc->buf3_size, KM_SLEEP);
918
925 if (ddi_copyin(dfc->buf2, fcio->fcio_obuf, fcio->fcio_olen,
926 mode)) {
927 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
928 "%s: %s: ddi_copyin failed. (size=%d)",
929 emlxs_dfc_xlate(dfc->cmd),
930 emlxs_fcio_xlate(dfc->data1), fcio->fcio_olen);
931
932 rval = EFAULT;
933 goto done;
934 }
935 }
936
937 if (dfc->buf3_size && dfc->buf3) {
938 fcio->fcio_alen = dfc->buf3_size;
939 fcio->fcio_abuf = kmem_zalloc(dfc->buf3_size, KM_SLEEP);
940
919 if (!fcio->fcio_abuf) {
920 EMLXS_MSGF(EMLXS_CONTEXT,
921 &emlxs_dfc_error_msg,
922 "%s: %s: Unable to allocate abuf. (size=%d)",
923 emlxs_dfc_xlate(dfc->cmd),
924 emlxs_fcio_xlate(dfc->data1), fcio->fcio_alen);
925
926 rval = EFAULT;
927 goto done;
928 }
929
930 if (ddi_copyin(dfc->buf3, fcio->fcio_abuf, fcio->fcio_alen,
931 mode)) {
932 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
933 "%s: %s: ddi_copyin failed. (size=%d)",
934 emlxs_dfc_xlate(dfc->cmd),
935 emlxs_fcio_xlate(dfc->data1), fcio->fcio_alen);
936
937 rval = EFAULT;
938 goto done;
939 }
940 }
941
941 if (ddi_copyin(dfc->buf3, fcio->fcio_abuf, fcio->fcio_alen,
942 mode)) {
943 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
944 "%s: %s: ddi_copyin failed. (size=%d)",
945 emlxs_dfc_xlate(dfc->cmd),
946 emlxs_fcio_xlate(dfc->data1), fcio->fcio_alen);
947
948 rval = EFAULT;
949 goto done;
950 }
951 }
952
942#ifdef _MULTI_DATAMODEL
953#ifdef _MULTI_DATAMODEL
943 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
944 use32 = 1;
945 }
954 if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
955 use32 = 1;
956 }
946#endif /* _MULTI_DATAMODEL */
957#endif /* _MULTI_DATAMODEL */
947
948 /* FCIO command */
949 switch (fcio->fcio_cmd) {
950 case FCIO_DIAG:
951 {
952 fc_fca_pm_t pm;
953
954 bzero((caddr_t)&pm, sizeof (fc_fca_pm_t));

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

968 fcio->fcio_errno = rval;
969
970 if (rval == FC_INVALID_REQUEST) {
971 rval = ENOTTY;
972 } else {
973 rval = EIO;
974 }
975 }
958
959 /* FCIO command */
960 switch (fcio->fcio_cmd) {
961 case FCIO_DIAG:
962 {
963 fc_fca_pm_t pm;
964
965 bzero((caddr_t)&pm, sizeof (fc_fca_pm_t));

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

979 fcio->fcio_errno = rval;
980
981 if (rval == FC_INVALID_REQUEST) {
982 rval = ENOTTY;
983 } else {
984 rval = EIO;
985 }
986 }
987 if (fcio->fcio_olen > pm.pm_stat_len) {
988 fcio->fcio_olen = pm.pm_stat_len;
989 }
976
977 break;
978 }
979
980 case FCIO_GET_HOST_PARAMS:
981 {
990
991 break;
992 }
993
994 case FCIO_GET_HOST_PARAMS:
995 {
982 uint32_t i;
983
984 if (use32) {
985 fc_port_dev32_t *port_dev;
996 if (use32) {
997 fc_port_dev32_t *port_dev;
998 uint32_t i;
986
987 if (fcio->fcio_xfer != FCIO_XFER_READ ||
988 fcio->fcio_olen != sizeof (fc_port_dev32_t)) {
989 rval = EINVAL;
990 break;
991 }
992
993 port_dev = (fc_port_dev32_t *)fcio->fcio_obuf;
994 port_dev->dev_did.port_id = port->did;
995 port_dev->dev_hard_addr.hard_addr =
996 cfg[CFG_ASSIGN_ALPA].current;
997 port_dev->dev_state = port->ulp_statec;
998 bcopy((caddr_t)&port->wwpn,
999 (caddr_t)&port_dev->dev_pwwn, 8);
1000 bcopy((caddr_t)&port->wwnn,
1001 (caddr_t)&port_dev->dev_nwwn, 8);
1002
1003 if (hba->topology == TOPOLOGY_LOOP) {
1004 for (i = 0; i < port->alpa_map[0]; i++) {
999
1000 if (fcio->fcio_xfer != FCIO_XFER_READ ||
1001 fcio->fcio_olen != sizeof (fc_port_dev32_t)) {
1002 rval = EINVAL;
1003 break;
1004 }
1005
1006 port_dev = (fc_port_dev32_t *)fcio->fcio_obuf;
1007 port_dev->dev_did.port_id = port->did;
1008 port_dev->dev_hard_addr.hard_addr =
1009 cfg[CFG_ASSIGN_ALPA].current;
1010 port_dev->dev_state = port->ulp_statec;
1011 bcopy((caddr_t)&port->wwpn,
1012 (caddr_t)&port_dev->dev_pwwn, 8);
1013 bcopy((caddr_t)&port->wwnn,
1014 (caddr_t)&port_dev->dev_nwwn, 8);
1015
1016 if (hba->topology == TOPOLOGY_LOOP) {
1017 for (i = 0; i < port->alpa_map[0]; i++) {
1005 if (port->alpa_map[i + 1] ==
1006 port->did) {
1007 port_dev->
1008 dev_did.priv_lilp_posit =
1009 (uint8_t)(i & 0xff);
1010 break;
1011 }
1018 if (port->alpa_map[i + 1] == port->did) {
1019 port_dev->dev_did.priv_lilp_posit =
1020 (uint8_t)(i & 0xff);
1021 break;
1022 }
1012 }
1013 }
1014
1023 }
1024 }
1025
1015 port_dev->dev_type[0] = SWAP_DATA32(0x00000120);
1016 port_dev->dev_type[1] = SWAP_DATA32(0x00000001);
1026 port_dev->dev_type[0] = LE_SWAP32(0x00000120);
1027 port_dev->dev_type[1] = LE_SWAP32(0x00000001);
1028
1017 } else {
1029 } else {
1030
1018 fc_port_dev_t *port_dev;
1031 fc_port_dev_t *port_dev;
1032 uint32_t i;
1019
1020 if (fcio->fcio_xfer != FCIO_XFER_READ ||
1021 fcio->fcio_olen != sizeof (fc_port_dev_t)) {
1022 rval = EINVAL;
1023 break;
1024 }
1025
1026 port_dev = (fc_port_dev_t *)fcio->fcio_obuf;
1027 port_dev->dev_did.port_id = port->did;
1028 port_dev->dev_hard_addr.hard_addr =
1029 cfg[CFG_ASSIGN_ALPA].current;
1030 port_dev->dev_state = port->ulp_statec;
1031 bcopy((caddr_t)&port->wwpn,
1032 (caddr_t)&port_dev->dev_pwwn, 8);
1033 bcopy((caddr_t)&port->wwnn,
1034 (caddr_t)&port_dev->dev_nwwn, 8);
1035
1036 if (hba->topology == TOPOLOGY_LOOP) {
1037 for (i = 0; i < port->alpa_map[0]; i++) {
1033
1034 if (fcio->fcio_xfer != FCIO_XFER_READ ||
1035 fcio->fcio_olen != sizeof (fc_port_dev_t)) {
1036 rval = EINVAL;
1037 break;
1038 }
1039
1040 port_dev = (fc_port_dev_t *)fcio->fcio_obuf;
1041 port_dev->dev_did.port_id = port->did;
1042 port_dev->dev_hard_addr.hard_addr =
1043 cfg[CFG_ASSIGN_ALPA].current;
1044 port_dev->dev_state = port->ulp_statec;
1045 bcopy((caddr_t)&port->wwpn,
1046 (caddr_t)&port_dev->dev_pwwn, 8);
1047 bcopy((caddr_t)&port->wwnn,
1048 (caddr_t)&port_dev->dev_nwwn, 8);
1049
1050 if (hba->topology == TOPOLOGY_LOOP) {
1051 for (i = 0; i < port->alpa_map[0]; i++) {
1038 if (port->alpa_map[i + 1] ==
1039 port->did) {
1040 port_dev->
1041 dev_did.priv_lilp_posit =
1042 (uint8_t)(i & 0xff);
1043 break;
1044 }
1052 if (port->alpa_map[i + 1] == port->did) {
1053 port_dev->dev_did.priv_lilp_posit =
1054 (uint8_t)(i & 0xff);
1055 break;
1056 }
1045 }
1046 }
1047
1057 }
1058 }
1059
1048 port_dev->dev_type[0] = SWAP_DATA32(0x00000120);
1049 port_dev->dev_type[1] = SWAP_DATA32(0x00000001);
1060 port_dev->dev_type[0] = LE_SWAP32(0x00000120);
1061 port_dev->dev_type[1] = LE_SWAP32(0x00000001);
1050 }
1051
1052 break;
1053 }
1054
1055 case FCIO_RESET_LINK:
1056 {
1057 uint8_t null_wwn[8];

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

1277 vpd->fw_version, vpd->fw_label);
1278 (void) strncpy(hba_attrs->DriverName, DRIVER_NAME,
1279 sizeof (hba_attrs->DriverName));
1280 hba_attrs->VendorSpecificID =
1281 ((hba->model_info.device_id << 16) |
1282 PCI_VENDOR_ID_EMULEX);
1283 hba_attrs->NumberOfPorts = hba->num_of_ports;
1284 }
1062 }
1063
1064 break;
1065 }
1066
1067 case FCIO_RESET_LINK:
1068 {
1069 uint8_t null_wwn[8];

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

1289 vpd->fw_version, vpd->fw_label);
1290 (void) strncpy(hba_attrs->DriverName, DRIVER_NAME,
1291 sizeof (hba_attrs->DriverName));
1292 hba_attrs->VendorSpecificID =
1293 ((hba->model_info.device_id << 16) |
1294 PCI_VENDOR_ID_EMULEX);
1295 hba_attrs->NumberOfPorts = hba->num_of_ports;
1296 }
1285
1286 break;
1287 }
1288
1289 case FCIO_GET_ADAPTER_PORT_ATTRIBUTES:
1290 {
1297 break;
1298 }
1299
1300 case FCIO_GET_ADAPTER_PORT_ATTRIBUTES:
1301 {
1291 uint32_t value1;
1292 uint32_t value2;
1293
1294 if (use32) {
1295 fc_hba_port_attributes32_t *port_attrs;
1302 if (use32) {
1303 fc_hba_port_attributes32_t *port_attrs;
1304 uint32_t value1;
1305 uint32_t value2;
1296
1297 if (fcio->fcio_xfer != FCIO_XFER_READ ||
1298 fcio->fcio_olen <
1299 sizeof (fc_hba_port_attributes32_t)) {
1300 rval = EINVAL;
1301 break;
1302 }
1303
1304 port_attrs =
1305 (fc_hba_port_attributes32_t *)fcio->fcio_obuf;
1306
1306
1307 if (fcio->fcio_xfer != FCIO_XFER_READ ||
1308 fcio->fcio_olen <
1309 sizeof (fc_hba_port_attributes32_t)) {
1310 rval = EINVAL;
1311 break;
1312 }
1313
1314 port_attrs =
1315 (fc_hba_port_attributes32_t *)fcio->fcio_obuf;
1316
1307 port_attrs->version = FC_HBA_PORT_ATTRIBUTES_VERSION;
1317 port_attrs->version = FC_HBA_PORT_ATTRIBUTES_VERSION;
1308 port_attrs->lastChange = 0;
1318 port_attrs->lastChange = 0;
1309 port_attrs->fp_minor = 0;
1319 port_attrs->fp_minor = 0;
1310 bcopy((caddr_t)&port->wwnn,
1311 (caddr_t)&port_attrs->NodeWWN, 8);
1312 bcopy((caddr_t)&port->wwpn,
1313 (caddr_t)&port_attrs->PortWWN, 8);
1314
1315 if (hba->state <= FC_LINK_DOWN) {
1316 /* port_attrs->PortFcId */
1317 /* port_attrs->PortType */

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

1326 if (hba->topology == TOPOLOGY_LOOP) {
1327 port_attrs->PortType =
1328 FC_HBA_PORTTYPE_LPORT;
1329 } else {
1330 port_attrs->PortType =
1331 FC_HBA_PORTTYPE_NPORT;
1332 }
1333
1320 bcopy((caddr_t)&port->wwnn,
1321 (caddr_t)&port_attrs->NodeWWN, 8);
1322 bcopy((caddr_t)&port->wwpn,
1323 (caddr_t)&port_attrs->PortWWN, 8);
1324
1325 if (hba->state <= FC_LINK_DOWN) {
1326 /* port_attrs->PortFcId */
1327 /* port_attrs->PortType */

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

1336 if (hba->topology == TOPOLOGY_LOOP) {
1337 port_attrs->PortType =
1338 FC_HBA_PORTTYPE_LPORT;
1339 } else {
1340 port_attrs->PortType =
1341 FC_HBA_PORTTYPE_NPORT;
1342 }
1343
1334 ndlp = emlxs_node_find_did(port, Fabric_DID);
1344 ndlp = emlxs_node_find_did(port, FABRIC_DID);
1335
1336 if (ndlp) {
1337 bcopy(&ndlp->nlp_portname,
1338 (caddr_t)&port_attrs->FabricName,
1339 sizeof (port_attrs->FabricName));
1340 }
1341
1342 switch (hba->linkspeed) {

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

1366 break;
1367 default:
1368 port_attrs->PortSpeed =
1369 HBA_PORTSPEED_UNKNOWN;
1370 }
1371 }
1372
1373 port_attrs->PortSupportedClassofService =
1345
1346 if (ndlp) {
1347 bcopy(&ndlp->nlp_portname,
1348 (caddr_t)&port_attrs->FabricName,
1349 sizeof (port_attrs->FabricName));
1350 }
1351
1352 switch (hba->linkspeed) {

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

1376 break;
1377 default:
1378 port_attrs->PortSpeed =
1379 HBA_PORTSPEED_UNKNOWN;
1380 }
1381 }
1382
1383 port_attrs->PortSupportedClassofService =
1374 SWAP_DATA32(FC_NS_CLASS3);
1384 LE_SWAP32(FC_NS_CLASS3);
1375 (void) strncpy((caddr_t)port_attrs->PortSymbolicName,
1376 (caddr_t)port->spn,
1377 sizeof (port_attrs->PortSymbolicName));
1378
1379 /* Set the hba speed limit */
1380 if (vpd->link_speed & LMT_10GB_CAPABLE) {
1381 port_attrs->PortSupportedSpeed |=
1382 FC_HBA_PORTSPEED_10GBIT;

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

1409 bcopy((caddr_t)&value1,
1410 (caddr_t)&port_attrs->PortActiveFc4Types[0], 4);
1411 bcopy((caddr_t)&value2,
1412 (caddr_t)&port_attrs->PortActiveFc4Types[4], 4);
1413
1414 port_attrs->PortMaxFrameSize = FF_FRAME_SIZE;
1415 port_attrs->NumberofDiscoveredPorts =
1416 emlxs_nport_count(port);
1385 (void) strncpy((caddr_t)port_attrs->PortSymbolicName,
1386 (caddr_t)port->spn,
1387 sizeof (port_attrs->PortSymbolicName));
1388
1389 /* Set the hba speed limit */
1390 if (vpd->link_speed & LMT_10GB_CAPABLE) {
1391 port_attrs->PortSupportedSpeed |=
1392 FC_HBA_PORTSPEED_10GBIT;

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

1419 bcopy((caddr_t)&value1,
1420 (caddr_t)&port_attrs->PortActiveFc4Types[0], 4);
1421 bcopy((caddr_t)&value2,
1422 (caddr_t)&port_attrs->PortActiveFc4Types[4], 4);
1423
1424 port_attrs->PortMaxFrameSize = FF_FRAME_SIZE;
1425 port_attrs->NumberofDiscoveredPorts =
1426 emlxs_nport_count(port);
1427
1417 } else {
1428 } else {
1429
1418 fc_hba_port_attributes_t *port_attrs;
1430 fc_hba_port_attributes_t *port_attrs;
1431 uint32_t value1;
1432 uint32_t value2;
1419
1420 if (fcio->fcio_xfer != FCIO_XFER_READ ||
1421 fcio->fcio_olen <
1422 sizeof (fc_hba_port_attributes_t)) {
1423 rval = EINVAL;
1424 break;
1425 }
1426
1427 port_attrs =
1428 (fc_hba_port_attributes_t *)fcio->fcio_obuf;
1429
1433
1434 if (fcio->fcio_xfer != FCIO_XFER_READ ||
1435 fcio->fcio_olen <
1436 sizeof (fc_hba_port_attributes_t)) {
1437 rval = EINVAL;
1438 break;
1439 }
1440
1441 port_attrs =
1442 (fc_hba_port_attributes_t *)fcio->fcio_obuf;
1443
1430 port_attrs->version = FC_HBA_PORT_ATTRIBUTES_VERSION;
1444 port_attrs->version = FC_HBA_PORT_ATTRIBUTES_VERSION;
1431 port_attrs->lastChange = 0;
1445 port_attrs->lastChange = 0;
1432 port_attrs->fp_minor = 0;
1446 port_attrs->fp_minor = 0;
1433 bcopy((caddr_t)&port->wwnn,
1434 (caddr_t)&port_attrs->NodeWWN, 8);
1435 bcopy((caddr_t)&port->wwpn,
1436 (caddr_t)&port_attrs->PortWWN, 8);
1437
1438 if (hba->state <= FC_LINK_DOWN) {
1439 /* port_attrs->PortFcId */
1440 /* port_attrs->PortType */

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

1449 if (hba->topology == TOPOLOGY_LOOP) {
1450 port_attrs->PortType =
1451 FC_HBA_PORTTYPE_LPORT;
1452 } else {
1453 port_attrs->PortType =
1454 FC_HBA_PORTTYPE_NPORT;
1455 }
1456
1447 bcopy((caddr_t)&port->wwnn,
1448 (caddr_t)&port_attrs->NodeWWN, 8);
1449 bcopy((caddr_t)&port->wwpn,
1450 (caddr_t)&port_attrs->PortWWN, 8);
1451
1452 if (hba->state <= FC_LINK_DOWN) {
1453 /* port_attrs->PortFcId */
1454 /* port_attrs->PortType */

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

1463 if (hba->topology == TOPOLOGY_LOOP) {
1464 port_attrs->PortType =
1465 FC_HBA_PORTTYPE_LPORT;
1466 } else {
1467 port_attrs->PortType =
1468 FC_HBA_PORTTYPE_NPORT;
1469 }
1470
1457 ndlp = emlxs_node_find_did(port, Fabric_DID);
1471 ndlp = emlxs_node_find_did(port, FABRIC_DID);
1458
1459 if (ndlp) {
1460 bcopy(&ndlp->nlp_portname,
1461 (caddr_t)&port_attrs->FabricName,
1462 sizeof (port_attrs->FabricName));
1463 }
1464
1465 switch (hba->linkspeed) {

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

1489 break;
1490 default:
1491 port_attrs->PortSpeed =
1492 HBA_PORTSPEED_UNKNOWN;
1493 }
1494 }
1495
1496 port_attrs->PortSupportedClassofService =
1472
1473 if (ndlp) {
1474 bcopy(&ndlp->nlp_portname,
1475 (caddr_t)&port_attrs->FabricName,
1476 sizeof (port_attrs->FabricName));
1477 }
1478
1479 switch (hba->linkspeed) {

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

1503 break;
1504 default:
1505 port_attrs->PortSpeed =
1506 HBA_PORTSPEED_UNKNOWN;
1507 }
1508 }
1509
1510 port_attrs->PortSupportedClassofService =
1497 SWAP_DATA32(FC_NS_CLASS3);
1511 LE_SWAP32(FC_NS_CLASS3);
1498 (void) strncpy((caddr_t)port_attrs->PortSymbolicName,
1499 (caddr_t)port->spn,
1500 sizeof (port_attrs->PortSymbolicName));
1501
1502 /* Set the hba speed limit */
1503 if (vpd->link_speed & LMT_10GB_CAPABLE) {
1504 port_attrs->PortSupportedSpeed |=
1505 FC_HBA_PORTSPEED_10GBIT;

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

1589
1590 if (rval != FC_SUCCESS) {
1591 fcio->fcio_errno = rval;
1592 rval = EIO;
1593 }
1594 break;
1595 }
1596
1512 (void) strncpy((caddr_t)port_attrs->PortSymbolicName,
1513 (caddr_t)port->spn,
1514 sizeof (port_attrs->PortSymbolicName));
1515
1516 /* Set the hba speed limit */
1517 if (vpd->link_speed & LMT_10GB_CAPABLE) {
1518 port_attrs->PortSupportedSpeed |=
1519 FC_HBA_PORTSPEED_10GBIT;

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

1603
1604 if (rval != FC_SUCCESS) {
1605 fcio->fcio_errno = rval;
1606 rval = EIO;
1607 }
1608 break;
1609 }
1610
1611
1597 case FCIO_GET_NUM_DEVS:
1598 {
1599 if (fcio->fcio_xfer != FCIO_XFER_READ ||
1600 fcio->fcio_olen < sizeof (uint32_t)) {
1601 rval = EINVAL;
1602 break;
1603 }
1604
1605 *(uint32_t *)fcio->fcio_obuf = emlxs_nport_count(port);
1606
1607 break;
1608 }
1609
1610 case FCIO_GET_DEV_LIST:
1611 {
1612 case FCIO_GET_NUM_DEVS:
1613 {
1614 if (fcio->fcio_xfer != FCIO_XFER_READ ||
1615 fcio->fcio_olen < sizeof (uint32_t)) {
1616 rval = EINVAL;
1617 break;
1618 }
1619
1620 *(uint32_t *)fcio->fcio_obuf = emlxs_nport_count(port);
1621
1622 break;
1623 }
1624
1625 case FCIO_GET_DEV_LIST:
1626 {
1612 uint32_t max_count;
1613 uint32_t i;
1614 uint32_t j;
1615 emlxs_node_t *nlp;
1616 uint32_t nport_count;
1617
1618 if (fcio->fcio_xfer != FCIO_XFER_READ ||
1619 fcio->fcio_alen < sizeof (uint32_t)) {
1620 rval = EINVAL;
1621 break;
1622 }
1623
1624 if (use32) {
1625 fc_port_dev32_t *port_dev;
1627 if (use32) {
1628 fc_port_dev32_t *port_dev;
1629 uint32_t max_count;
1630 uint32_t i;
1631 uint32_t j;
1632 emlxs_node_t *nlp;
1633 uint32_t nport_count;
1626
1634
1635 if (fcio->fcio_xfer != FCIO_XFER_READ ||
1636 fcio->fcio_alen < sizeof (uint32_t)) {
1637 rval = EINVAL;
1638 break;
1639 }
1640
1627 port_dev = (fc_port_dev32_t *)fcio->fcio_obuf;
1628 max_count = fcio->fcio_olen / sizeof (fc_port_dev32_t);
1629
1630 rw_enter(&port->node_rwlock, RW_READER);
1631
1632 nport_count = emlxs_nport_count(port);
1633 *(uint32_t *)fcio->fcio_abuf = nport_count;
1634

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

1646 fcio->fcio_errno = FC_TOOMANY;
1647 rval = EIO;
1648 break;
1649 }
1650
1651 for (i = 0; i < EMLXS_NUM_HASH_QUES; i++) {
1652 nlp = port->node_table[i];
1653 while (nlp != NULL) {
1641 port_dev = (fc_port_dev32_t *)fcio->fcio_obuf;
1642 max_count = fcio->fcio_olen / sizeof (fc_port_dev32_t);
1643
1644 rw_enter(&port->node_rwlock, RW_READER);
1645
1646 nport_count = emlxs_nport_count(port);
1647 *(uint32_t *)fcio->fcio_abuf = nport_count;
1648

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

1660 fcio->fcio_errno = FC_TOOMANY;
1661 rval = EIO;
1662 break;
1663 }
1664
1665 for (i = 0; i < EMLXS_NUM_HASH_QUES; i++) {
1666 nlp = port->node_table[i];
1667 while (nlp != NULL) {
1654 if ((nlp->nlp_DID & 0xFFF000) !=
1655 0xFFF000) {
1656 port_dev->dev_dtype = 0;
1657 port_dev->dev_type[0] =
1658 SWAP_LONG(0x00000100);
1659 port_dev->dev_state =
1660 PORT_DEVICE_LOGGED_IN;
1661 port_dev->dev_did.port_id =
1662 nlp->nlp_DID;
1663 port_dev->
1664 dev_did.priv_lilp_posit = 0;
1665 port_dev->
1666 dev_hard_addr.hard_addr = 0;
1668 if ((nlp->nlp_DID & 0xFFF000) != 0xFFF000) {
1669 port_dev->dev_dtype = 0;
1670 port_dev->dev_type[0] =
1671 BE_SWAP32(0x00000100);
1672 port_dev->dev_state =
1673 PORT_DEVICE_LOGGED_IN;
1674 port_dev->dev_did.port_id =
1675 nlp->nlp_DID;
1676 port_dev->dev_did.priv_lilp_posit = 0;
1677 port_dev->dev_hard_addr.hard_addr = 0;
1667
1678
1668if (hba->topology == TOPOLOGY_LOOP) {
1669 for (j = 1; j < port->alpa_map[0]; j++) {
1670 if (nlp->nlp_DID == port->alpa_map[j]) {
1671 port_dev->dev_did.priv_lilp_posit = j-1;
1672 break;
1679 if (hba->topology == TOPOLOGY_LOOP) {
1680 for (j = 1; j < port->alpa_map[0]; j++) {
1681 if (nlp->nlp_DID == port->alpa_map[j]) {
1682 port_dev->dev_did.priv_lilp_posit = j-1;
1683 break;
1684 }
1673 }
1685 }
1686 port_dev->dev_hard_addr.hard_addr = nlp->nlp_DID;
1674 }
1675
1687 }
1688
1676 port_dev->dev_hard_addr.hard_addr = nlp->nlp_DID;
1677}
1689 bcopy((caddr_t)&nlp->nlp_portname,
1690 (caddr_t)&port_dev->dev_pwwn, 8);
1691 bcopy((caddr_t)&nlp->nlp_nodename,
1692 (caddr_t)&port_dev->dev_nwwn, 8);
1693 port_dev++;
1694 }
1678
1695
1679 bcopy((caddr_t)
1680 &nlp->nlp_portname,
1681 (caddr_t)
1682 &port_dev->dev_pwwn,
1683 8);
1684 bcopy((caddr_t)
1685 &nlp->nlp_nodename,
1686 (caddr_t)
1687 &port_dev->dev_nwwn,
1688 8);
1689 port_dev++;
1690 }
1691
1692 nlp = (NODELIST *) nlp->nlp_list_next;
1696 nlp = (NODELIST *) nlp->nlp_list_next;
1693 }
1694 }
1695 rw_exit(&port->node_rwlock);
1697 }
1698 }
1699 rw_exit(&port->node_rwlock);
1700
1696 } else {
1701 } else {
1702
1697 fc_port_dev_t *port_dev;
1703 fc_port_dev_t *port_dev;
1704 uint32_t max_count;
1705 uint32_t i;
1706 uint32_t j;
1707 emlxs_node_t *nlp;
1708 uint32_t nport_count;
1698
1709
1710 if (fcio->fcio_xfer != FCIO_XFER_READ ||
1711 fcio->fcio_alen < sizeof (uint32_t)) {
1712 rval = EINVAL;
1713 break;
1714 }
1715
1699 port_dev = (fc_port_dev_t *)fcio->fcio_obuf;
1700 max_count = fcio->fcio_olen / sizeof (fc_port_dev_t);
1701
1702 rw_enter(&port->node_rwlock, RW_READER);
1703
1704 nport_count = emlxs_nport_count(port);
1705 *(uint32_t *)fcio->fcio_abuf = nport_count;
1706

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

1718 fcio->fcio_errno = FC_TOOMANY;
1719 rval = EIO;
1720 break;
1721 }
1722
1723 for (i = 0; i < EMLXS_NUM_HASH_QUES; i++) {
1724 nlp = port->node_table[i];
1725 while (nlp != NULL) {
1716 port_dev = (fc_port_dev_t *)fcio->fcio_obuf;
1717 max_count = fcio->fcio_olen / sizeof (fc_port_dev_t);
1718
1719 rw_enter(&port->node_rwlock, RW_READER);
1720
1721 nport_count = emlxs_nport_count(port);
1722 *(uint32_t *)fcio->fcio_abuf = nport_count;
1723

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

1735 fcio->fcio_errno = FC_TOOMANY;
1736 rval = EIO;
1737 break;
1738 }
1739
1740 for (i = 0; i < EMLXS_NUM_HASH_QUES; i++) {
1741 nlp = port->node_table[i];
1742 while (nlp != NULL) {
1726 if ((nlp->nlp_DID & 0xFFF000) !=
1727 0xFFF000) {
1728 port_dev->dev_dtype = 0;
1729 port_dev->dev_type[0] =
1730 SWAP_LONG(0x00000100);
1731 port_dev->dev_state =
1732 PORT_DEVICE_LOGGED_IN;
1733 port_dev->dev_did.port_id =
1734 nlp->nlp_DID;
1735 port_dev->
1736 dev_did.priv_lilp_posit = 0;
1737 port_dev->
1738 dev_hard_addr.hard_addr = 0;
1743 if ((nlp->nlp_DID & 0xFFF000) != 0xFFF000) {
1744 port_dev->dev_dtype = 0;
1745 port_dev->dev_type[0] =
1746 BE_SWAP32(0x00000100);
1747 port_dev->dev_state =
1748 PORT_DEVICE_LOGGED_IN;
1749 port_dev->dev_did.port_id =
1750 nlp->nlp_DID;
1751 port_dev->dev_did.priv_lilp_posit = 0;
1752 port_dev->dev_hard_addr.hard_addr = 0;
1739
1753
1740if (hba->topology == TOPOLOGY_LOOP) {
1741 for (j = 1; j < port->alpa_map[0]; j++) {
1742 if (nlp->nlp_DID == port->alpa_map[j]) {
1743 port_dev->dev_did.priv_lilp_posit = j-1;
1744 break;
1754 if (hba->topology == TOPOLOGY_LOOP) {
1755 for (j = 1; j < port->alpa_map[0]; j++) {
1756 if (nlp->nlp_DID == port->alpa_map[j]) {
1757 port_dev->dev_did.priv_lilp_posit = j-1;
1758 break;
1759 }
1745 }
1760 }
1761 port_dev->dev_hard_addr.hard_addr = nlp->nlp_DID;
1746 }
1747
1762 }
1763
1748port_dev->dev_hard_addr.hard_addr = nlp->nlp_DID;
1749}
1764 bcopy((caddr_t)&nlp->nlp_portname,
1765 (caddr_t)&port_dev->dev_pwwn, 8);
1766 bcopy((caddr_t)&nlp->nlp_nodename,
1767 (caddr_t)&port_dev->dev_nwwn, 8);
1768 port_dev++;
1769 }
1750
1770
1751 bcopy((caddr_t)
1752 &nlp->nlp_portname,
1753 (caddr_t)
1754 &port_dev->dev_pwwn,
1755 8);
1756 bcopy((caddr_t)
1757 &nlp->nlp_nodename,
1758 (caddr_t)&
1759 port_dev->dev_nwwn,
1760 8);
1761 port_dev++;
1762 }
1763
1764 nlp = (NODELIST *) nlp->nlp_list_next;
1771 nlp = (NODELIST *) nlp->nlp_list_next;
1765 }
1766 }
1767 rw_exit(&port->node_rwlock);
1768 }
1769
1770 break;
1771 }
1772

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

1846 break;
1847 }
1848
1849 tp = (uint32_t *)fcio->fcio_obuf;
1850
1851 if (hba->state <= FC_LINK_DOWN) {
1852 *tp = FC_TOP_UNKNOWN;
1853 } else {
1772 }
1773 }
1774 rw_exit(&port->node_rwlock);
1775 }
1776
1777 break;
1778 }
1779

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

1853 break;
1854 }
1855
1856 tp = (uint32_t *)fcio->fcio_obuf;
1857
1858 if (hba->state <= FC_LINK_DOWN) {
1859 *tp = FC_TOP_UNKNOWN;
1860 } else {
1854 ndlp = emlxs_node_find_did(port, Fabric_DID);
1861 ndlp = emlxs_node_find_did(port, FABRIC_DID);
1855
1856 if (hba->topology == TOPOLOGY_LOOP) {
1857 if (ndlp) {
1858 *tp = FC_TOP_PUBLIC_LOOP;
1859 } else {
1860 *tp = FC_TOP_PRIVATE_LOOP;
1861 }
1862 } else {

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

1922 fcio->fcio_ilen != sizeof (uint32_t)) {
1923 rval = EINVAL;
1924 break;
1925 }
1926
1927 index = *(uint32_t *)fcio->fcio_ibuf;
1928 path = (char *)fcio->fcio_obuf;
1929
1862
1863 if (hba->topology == TOPOLOGY_LOOP) {
1864 if (ndlp) {
1865 *tp = FC_TOP_PUBLIC_LOOP;
1866 } else {
1867 *tp = FC_TOP_PRIVATE_LOOP;
1868 }
1869 } else {

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

1929 fcio->fcio_ilen != sizeof (uint32_t)) {
1930 rval = EINVAL;
1931 break;
1932 }
1933
1934 index = *(uint32_t *)fcio->fcio_ibuf;
1935 path = (char *)fcio->fcio_obuf;
1936
1930 if (index > hba->vpi_max - 1) {
1937 if (index > hba->vpi_max) {
1931 fcio->fcio_errno = FC_BADPORT;
1932 rval = EFAULT;
1933 break;
1934 }
1935
1936 (void) ddi_pathname(hba->dip, path);
1937
1938 break;

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

2002 bcopy((caddr_t)&ndlp->nlp_portname,
2003 (caddr_t)&port_attrs->PortWWN, 8);
2004
2005 port_attrs->PortSpeed = HBA_PORTSPEED_UNKNOWN;
2006 port_attrs->PortType = FC_HBA_PORTTYPE_UNKNOWN;
2007 port_attrs->PortState = FC_HBA_PORTSTATE_OFFLINE;
2008
2009 if (hba->state > FC_LINK_UP) {
1938 fcio->fcio_errno = FC_BADPORT;
1939 rval = EFAULT;
1940 break;
1941 }
1942
1943 (void) ddi_pathname(hba->dip, path);
1944
1945 break;

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

2009 bcopy((caddr_t)&ndlp->nlp_portname,
2010 (caddr_t)&port_attrs->PortWWN, 8);
2011
2012 port_attrs->PortSpeed = HBA_PORTSPEED_UNKNOWN;
2013 port_attrs->PortType = FC_HBA_PORTTYPE_UNKNOWN;
2014 port_attrs->PortState = FC_HBA_PORTSTATE_OFFLINE;
2015
2016 if (hba->state > FC_LINK_UP) {
2010 ndlp2 = emlxs_node_find_did(port, Fabric_DID);
2017 ndlp2 = emlxs_node_find_did(port, FABRIC_DID);
2011
2012 port_attrs->PortFcId = ndlp->nlp_DID;
2013 port_attrs->PortState = FC_HBA_PORTSTATE_ONLINE;
2014
2015 /* no switch */
2016 if (!ndlp2) {
2017 if (hba->topology == TOPOLOGY_LOOP) {
2018 port_attrs->PortType =

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

2085 HBA_PORTSPEED_10GBIT;
2086 break;
2087 }
2088 }
2089 }
2090 }
2091
2092 port_attrs->PortSupportedClassofService =
2018
2019 port_attrs->PortFcId = ndlp->nlp_DID;
2020 port_attrs->PortState = FC_HBA_PORTSTATE_ONLINE;
2021
2022 /* no switch */
2023 if (!ndlp2) {
2024 if (hba->topology == TOPOLOGY_LOOP) {
2025 port_attrs->PortType =

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

2092 HBA_PORTSPEED_10GBIT;
2093 break;
2094 }
2095 }
2096 }
2097 }
2098
2099 port_attrs->PortSupportedClassofService =
2093 SWAP_DATA32(FC_NS_CLASS3);
2100 LE_SWAP32(FC_NS_CLASS3);
2094 /* port_attrs->PortSymbolicName */
2095 /* port_attrs->PortSupportedSpeed */
2096 /* port_attrs->PortSupportedFc4Types */
2097 /* port_attrs->PortActiveFc4Types */
2098 /* port_attrs->PortMaxFrameSize */
2099 /* port_attrs->NumberofDiscoveredPorts */
2100
2101 break;

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

2311
2312 return (rval);
2313
2314} /* emlxs_fcio_manage() */
2315
2316#endif /* FCIO_SUPPORT */
2317
2318
2101 /* port_attrs->PortSymbolicName */
2102 /* port_attrs->PortSupportedSpeed */
2103 /* port_attrs->PortSupportedFc4Types */
2104 /* port_attrs->PortActiveFc4Types */
2105 /* port_attrs->PortMaxFrameSize */
2106 /* port_attrs->NumberofDiscoveredPorts */
2107
2108 break;

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

2318
2319 return (rval);
2320
2321} /* emlxs_fcio_manage() */
2322
2323#endif /* FCIO_SUPPORT */
2324
2325
2319
2320#ifdef NPIV_SUPPORT
2321
2322static int32_t
2323emlxs_dfc_create_vport(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
2324{
2325 emlxs_port_t *port = &PPORT;
2326 emlxs_config_t *cfg = &CFG;
2327 emlxs_port_t *vport;
2326static int32_t
2327emlxs_dfc_create_vport(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
2328{
2329 emlxs_port_t *port = &PPORT;
2330 emlxs_config_t *cfg = &CFG;
2331 emlxs_port_t *vport;
2332 emlxs_port_t *tport;
2328 dfc_vportinfo_t dfc_vport;
2329 uint32_t vpi;
2330 uint32_t options;
2331 char name[256];
2332 uint8_t wwn[8];
2333
2334 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg, "%s requested.",
2335 emlxs_dfc_xlate(dfc->cmd));

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

2434 if (!(bcmp(wwn, dfc_vport.wwpn, 8))) {
2435 /* Generate new WWPN */
2436 bcopy((caddr_t)&hba->wwpn, (caddr_t)dfc_vport.wwpn, 8);
2437 dfc_vport.wwpn[0] = 0x20;
2438 dfc_vport.wwpn[1] = vpi;
2439 } else { /* use one provided */
2440
2441 /* Make sure WWPN is unique */
2333 dfc_vportinfo_t dfc_vport;
2334 uint32_t vpi;
2335 uint32_t options;
2336 char name[256];
2337 uint8_t wwn[8];
2338
2339 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg, "%s requested.",
2340 emlxs_dfc_xlate(dfc->cmd));

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

2439 if (!(bcmp(wwn, dfc_vport.wwpn, 8))) {
2440 /* Generate new WWPN */
2441 bcopy((caddr_t)&hba->wwpn, (caddr_t)dfc_vport.wwpn, 8);
2442 dfc_vport.wwpn[0] = 0x20;
2443 dfc_vport.wwpn[1] = vpi;
2444 } else { /* use one provided */
2445
2446 /* Make sure WWPN is unique */
2442 if (emlxs_vport_find_wwpn(hba, dfc_vport.wwpn)) {
2443 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
2444 "%s: WWPN already exists. vpi=%d",
2445 emlxs_dfc_xlate(dfc->cmd), vpi);
2446
2447 return (DFC_ARG_INVALID);
2447 if (tport = emlxs_vport_find_wwpn(hba, dfc_vport.wwpn)) {
2448 if ((tport->flag & EMLXS_PORT_CONFIG) &&
2449 (tport->flag & EMLXS_PORT_BOUND)) {
2450 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
2451 "%s: WWPN already exists. vpi=%d",
2452 emlxs_dfc_xlate(dfc->cmd), vpi);
2453 return (DFC_ARG_INVALID);
2454 }
2448 }
2449 }
2450
2451 /* Establish a WWNN */
2452 bzero(wwn, 8);
2453 if (!(bcmp(wwn, dfc_vport.wwnn, 8))) {
2454 /* Generate new WWNN */
2455 bcopy((caddr_t)&hba->wwnn, (caddr_t)dfc_vport.wwnn, 8);

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

2601 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
2602 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
2603 pkt->pkt_comp = NULL;
2604
2605 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
2606 pkt->pkt_timeout = 60;
2607
2608 /* Build the fc header */
2455 }
2456 }
2457
2458 /* Establish a WWNN */
2459 bzero(wwn, 8);
2460 if (!(bcmp(wwn, dfc_vport.wwnn, 8))) {
2461 /* Generate new WWNN */
2462 bcopy((caddr_t)&hba->wwnn, (caddr_t)dfc_vport.wwnn, 8);

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

2608 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
2609 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
2610 pkt->pkt_comp = NULL;
2611
2612 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
2613 pkt->pkt_timeout = 60;
2614
2615 /* Build the fc header */
2609 pkt->pkt_cmd_fhdr.d_id = SWAP_DATA24_LO(Fabric_DID);
2616 pkt->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(FABRIC_DID);
2610 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_ELS_REQ;
2617 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_ELS_REQ;
2611 pkt->pkt_cmd_fhdr.s_id = SWAP_DATA24_LO(vport->did);
2618 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(vport->did);
2612 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
2613 pkt->pkt_cmd_fhdr.f_ctl =
2614 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
2615 pkt->pkt_cmd_fhdr.seq_id = 0;
2616 pkt->pkt_cmd_fhdr.df_ctl = 0;
2617 pkt->pkt_cmd_fhdr.seq_cnt = 0;
2618 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
2619 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;
2620 pkt->pkt_cmd_fhdr.ro = 0;
2621
2622 /* Build the command */
2623 els = (ELS_PKT *) pkt->pkt_cmd;
2624 els->elsCode = 0x05; /* LOGO */
2619 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
2620 pkt->pkt_cmd_fhdr.f_ctl =
2621 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
2622 pkt->pkt_cmd_fhdr.seq_id = 0;
2623 pkt->pkt_cmd_fhdr.df_ctl = 0;
2624 pkt->pkt_cmd_fhdr.seq_cnt = 0;
2625 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
2626 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;
2627 pkt->pkt_cmd_fhdr.ro = 0;
2628
2629 /* Build the command */
2630 els = (ELS_PKT *) pkt->pkt_cmd;
2631 els->elsCode = 0x05; /* LOGO */
2625 els->un.logo.un.nPortId32 = SWAP_DATA32(vport->did);
2632 els->un.logo.un.nPortId32 = LE_SWAP32(vport->did);
2626 bcopy(&vport->wwpn, &els->un.logo.portName, 8);
2627
2628 /*
2629 * Just send LOGO. Don't worry about result.
2630 * This is just a courtesy anyway.
2631 */
2632 (void) emlxs_pkt_send(pkt, 1);
2633

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

2808 if (dfc->buf1_size < sizeof (dfc_vport_resource_t)) {
2809 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
2810 "%s: Buffer1 too small. (size=%d)",
2811 emlxs_dfc_xlate(dfc->cmd), dfc->buf1_size);
2812
2813 return (DFC_ARG_TOOSMALL);
2814 }
2815
2633 bcopy(&vport->wwpn, &els->un.logo.portName, 8);
2634
2635 /*
2636 * Just send LOGO. Don't worry about result.
2637 * This is just a courtesy anyway.
2638 */
2639 (void) emlxs_pkt_send(pkt, 1);
2640

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

2815 if (dfc->buf1_size < sizeof (dfc_vport_resource_t)) {
2816 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
2817 "%s: Buffer1 too small. (size=%d)",
2818 emlxs_dfc_xlate(dfc->cmd), dfc->buf1_size);
2819
2820 return (DFC_ARG_TOOSMALL);
2821 }
2822
2816 if ((mbq =
2817 (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP)) == 0) {
2818 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
2819 "%s: Unable to allocate mailbox buffer.",
2820 emlxs_dfc_xlate(dfc->cmd));
2823 bzero(&vres, sizeof (dfc_vport_resource_t));
2821
2824
2822 return (DFC_SYSRES_ERROR);
2825 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
2826 int i;
2827 int total_rpi;
2828 emlxs_port_t *vport;
2829
2830 total_rpi = 0;
2831 for (i = 0; i < hba->sli.sli4.VPICount; i++) {
2832 vport = &VPORT(i);
2833 total_rpi += vport->outstandingRPIs;
2834 }
2835
2836 vres.vpi_max = hba->sli.sli4.VPICount - 1;
2837 vres.vpi_inuse = (port->VFIp == NULL) ? 0 :
2838 port->VFIp->outstandingVPIs - 1;
2839 vres.rpi_max = hba->sli.sli4.RPICount;
2840 vres.rpi_inuse = total_rpi;
2841
2842 if (ddi_copyout((void *)&vres, (void *)dfc->buf1,
2843 sizeof (dfc_vport_resource_t), mode) != 0) {
2844 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
2845 "%s: ddi_copyout failed.",
2846 emlxs_dfc_xlate(dfc->cmd));
2847
2848 rval = DFC_COPYOUT_ERROR;
2849 }
2850 return (rval);
2823 }
2824
2851 }
2852
2853 mbq =
2854 (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP);
2855
2825 mb = (MAILBOX *) mbq;
2826
2856 mb = (MAILBOX *) mbq;
2857
2827 emlxs_mb_read_config(hba, mb);
2858 emlxs_mb_read_config(hba, mbq);
2828
2859
2829 rval = emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0);
2860 rval = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
2830
2831 if (rval == MBX_TIMEOUT) {
2832 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
2833 "%s: Mailbox timed out. cmd=%x",
2834 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
2835
2836 rval = DFC_TIMEOUT;
2837 goto done;
2838 }
2839
2840 if (rval) {
2841 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
2842 "%s: %s failed. status=%x", emlxs_dfc_xlate(dfc->cmd),
2843 emlxs_mb_cmd_xlate(mb->mbxCommand), rval);
2844
2845 rval = DFC_IO_ERROR;
2846 goto done;
2847 }
2848
2861
2862 if (rval == MBX_TIMEOUT) {
2863 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
2864 "%s: Mailbox timed out. cmd=%x",
2865 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
2866
2867 rval = DFC_TIMEOUT;
2868 goto done;
2869 }
2870
2871 if (rval) {
2872 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
2873 "%s: %s failed. status=%x", emlxs_dfc_xlate(dfc->cmd),
2874 emlxs_mb_cmd_xlate(mb->mbxCommand), rval);
2875
2876 rval = DFC_IO_ERROR;
2877 goto done;
2878 }
2879
2849 bzero(&vres, sizeof (dfc_vport_resource_t));
2850 vres.vpi_max = mb->un.varRdConfig.max_vpi;
2851 vres.vpi_inuse =
2852 (mb->un.varRdConfig.max_vpi <=
2853 mb->un.varRdConfig.avail_vpi) ? 0 : mb->un.varRdConfig.max_vpi -
2854 mb->un.varRdConfig.avail_vpi;
2855
2856 vres.rpi_max = mb->un.varRdConfig.max_rpi;
2857 vres.rpi_inuse =

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

2915 checklist |= CL_NPIV_PARM_ENABLE;
2916 }
2917
2918 if (hba->sli_mode >= 3) {
2919 checklist |= CL_SLI3_ENABLE;
2920 }
2921
2922
2880 vres.vpi_max = mb->un.varRdConfig.max_vpi;
2881 vres.vpi_inuse =
2882 (mb->un.varRdConfig.max_vpi <=
2883 mb->un.varRdConfig.avail_vpi) ? 0 : mb->un.varRdConfig.max_vpi -
2884 mb->un.varRdConfig.avail_vpi;
2885
2886 vres.rpi_max = mb->un.varRdConfig.max_rpi;
2887 vres.rpi_inuse =

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

2945 checklist |= CL_NPIV_PARM_ENABLE;
2946 }
2947
2948 if (hba->sli_mode >= 3) {
2949 checklist |= CL_SLI3_ENABLE;
2950 }
2951
2952
2923 if (vpd->feaLevelHigh >= 0x09) {
2953 if ((vpd->feaLevelHigh >= 0x09) || (hba->sli_mode >= 4)) {
2924 checklist |= CL_HBA_SUPPORT_NPIV;
2925 }
2926
2927
2928 if (hba->num_of_ports <= hba->vpi_max) {
2929 checklist |= CL_HBA_HAS_RESOURCES;
2930 }
2931

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

2981 sizeof (uint32_t) + sizeof (SERV_PARM), sizeof (FCP_RSP),
2982 0, KM_NOSLEEP))) {
2983 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
2984 "Unable to allocate packet.");
2985 goto done;
2986 }
2987
2988 /* Build (FDISC) the fc header */
2954 checklist |= CL_HBA_SUPPORT_NPIV;
2955 }
2956
2957
2958 if (hba->num_of_ports <= hba->vpi_max) {
2959 checklist |= CL_HBA_HAS_RESOURCES;
2960 }
2961

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

3011 sizeof (uint32_t) + sizeof (SERV_PARM), sizeof (FCP_RSP),
3012 0, KM_NOSLEEP))) {
3013 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
3014 "Unable to allocate packet.");
3015 goto done;
3016 }
3017
3018 /* Build (FDISC) the fc header */
2989 pkt->pkt_cmd_fhdr.d_id = SWAP_DATA24_LO(Fabric_DID);
3019 pkt->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(FABRIC_DID);
2990 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_EXTENDED_SVC | R_CTL_UNSOL_CONTROL;
2991 pkt->pkt_cmd_fhdr.s_id = 0;
2992 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
2993 pkt->pkt_cmd_fhdr.f_ctl = F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE;
2994 pkt->pkt_cmd_fhdr.seq_id = 0;
2995 pkt->pkt_cmd_fhdr.df_ctl = 0;
2996 pkt->pkt_cmd_fhdr.seq_cnt = 0;
2997 pkt->pkt_cmd_fhdr.ox_id = 0xffff;

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

3077 pkt1->pkt_tran_flags &= ~FC_TRAN_INTR;
3078 pkt1->pkt_tran_flags |= FC_TRAN_NO_INTR;
3079 pkt1->pkt_comp = NULL;
3080
3081 pkt1->pkt_tran_type = FC_PKT_EXCHANGE;
3082 pkt1->pkt_timeout = 60;
3083
3084 /* Build (LOGO) the fc header */
3020 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_EXTENDED_SVC | R_CTL_UNSOL_CONTROL;
3021 pkt->pkt_cmd_fhdr.s_id = 0;
3022 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
3023 pkt->pkt_cmd_fhdr.f_ctl = F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE;
3024 pkt->pkt_cmd_fhdr.seq_id = 0;
3025 pkt->pkt_cmd_fhdr.df_ctl = 0;
3026 pkt->pkt_cmd_fhdr.seq_cnt = 0;
3027 pkt->pkt_cmd_fhdr.ox_id = 0xffff;

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

3107 pkt1->pkt_tran_flags &= ~FC_TRAN_INTR;
3108 pkt1->pkt_tran_flags |= FC_TRAN_NO_INTR;
3109 pkt1->pkt_comp = NULL;
3110
3111 pkt1->pkt_tran_type = FC_PKT_EXCHANGE;
3112 pkt1->pkt_timeout = 60;
3113
3114 /* Build (LOGO) the fc header */
3085 pkt1->pkt_cmd_fhdr.d_id = SWAP_DATA24_LO(Fabric_DID);
3115 pkt1->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(FABRIC_DID);
3086 pkt1->pkt_cmd_fhdr.r_ctl = R_CTL_ELS_REQ;
3087 pkt1->pkt_cmd_fhdr.s_id =
3116 pkt1->pkt_cmd_fhdr.r_ctl = R_CTL_ELS_REQ;
3117 pkt1->pkt_cmd_fhdr.s_id =
3088 SWAP_DATA24_LO(pkt->pkt_resp_fhdr.d_id);
3118 LE_SWAP24_LO(pkt->pkt_resp_fhdr.d_id);
3089 pkt1->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
3090 pkt1->pkt_cmd_fhdr.f_ctl =
3091 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
3092 pkt1->pkt_cmd_fhdr.seq_id = 0;
3093 pkt1->pkt_cmd_fhdr.df_ctl = 0;
3094 pkt1->pkt_cmd_fhdr.seq_cnt = 0;
3095 pkt1->pkt_cmd_fhdr.ox_id = 0xFFFF;
3096 pkt1->pkt_cmd_fhdr.rx_id = 0xFFFF;
3097 pkt1->pkt_cmd_fhdr.ro = 0;
3098
3099 /* Build the command (LOGO) */
3100 els = (ELS_PKT *) pkt1->pkt_cmd;
3101 els->elsCode = 0x05; /* LOGO */
3102 els->un.logo.un.nPortId32 =
3119 pkt1->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
3120 pkt1->pkt_cmd_fhdr.f_ctl =
3121 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
3122 pkt1->pkt_cmd_fhdr.seq_id = 0;
3123 pkt1->pkt_cmd_fhdr.df_ctl = 0;
3124 pkt1->pkt_cmd_fhdr.seq_cnt = 0;
3125 pkt1->pkt_cmd_fhdr.ox_id = 0xFFFF;
3126 pkt1->pkt_cmd_fhdr.rx_id = 0xFFFF;
3127 pkt1->pkt_cmd_fhdr.ro = 0;
3128
3129 /* Build the command (LOGO) */
3130 els = (ELS_PKT *) pkt1->pkt_cmd;
3131 els->elsCode = 0x05; /* LOGO */
3132 els->un.logo.un.nPortId32 =
3103 SWAP_DATA32(pkt->pkt_resp_fhdr.d_id);
3133 LE_SWAP32(pkt->pkt_resp_fhdr.d_id);
3104 bcopy((caddr_t)&hba->wwpn, (caddr_t)wwn, 8);
3105 wwn[0] = 0x20;
3106 wwn[1] = hba->vpi_max;
3107 bcopy(wwn, &els->un.logo.portName, 8);
3108
3109 if (emlxs_pkt_send(pkt1, 1) != FC_SUCCESS) {
3110 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
3111 "%s: Unable to send packet.",

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

3137 checklist |= CL_FABRIC_HAS_RESOURCES;
3138 }
3139 }
3140
3141 /*
3142 * Free up default RPIs and VPI
3143 */
3144free_resc:
3134 bcopy((caddr_t)&hba->wwpn, (caddr_t)wwn, 8);
3135 wwn[0] = 0x20;
3136 wwn[1] = hba->vpi_max;
3137 bcopy(wwn, &els->un.logo.portName, 8);
3138
3139 if (emlxs_pkt_send(pkt1, 1) != FC_SUCCESS) {
3140 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
3141 "%s: Unable to send packet.",

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

3167 checklist |= CL_FABRIC_HAS_RESOURCES;
3168 }
3169 }
3170
3171 /*
3172 * Free up default RPIs and VPI
3173 */
3174free_resc:
3145 (void) emlxs_mb_unreg_rpi(vport, 0xffff, 0, 0, 0);
3175 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
3176 (void) emlxs_sli4_unreg_all_rpi_by_port(vport);
3177 } else {
3178 (void) emlxs_mb_unreg_rpi(vport, 0xffff, 0, 0, 0);
3179 }
3146 (void) emlxs_mb_unreg_vpi(vport);
3147
3148done:
3149 if (ddi_copyout((void *)&checklist, (void *)dfc->buf1,
3150 sizeof (uint32_t), mode) != 0) {
3151 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
3152 "%s: ddi_copyout failed.", emlxs_dfc_xlate(dfc->cmd));
3153 rval = DFC_COPYOUT_ERROR;

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

3162 /* Free the pkt */
3163 emlxs_pkt_free(pkt1);
3164 }
3165
3166 return (rval);
3167
3168} /* emlxs_dfc_npiv_test() */
3169
3180 (void) emlxs_mb_unreg_vpi(vport);
3181
3182done:
3183 if (ddi_copyout((void *)&checklist, (void *)dfc->buf1,
3184 sizeof (uint32_t), mode) != 0) {
3185 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
3186 "%s: ddi_copyout failed.", emlxs_dfc_xlate(dfc->cmd));
3187 rval = DFC_COPYOUT_ERROR;

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

3196 /* Free the pkt */
3197 emlxs_pkt_free(pkt1);
3198 }
3199
3200 return (rval);
3201
3202} /* emlxs_dfc_npiv_test() */
3203
3170#endif /* NPIV_SUPPORT */
3171
3204
3172
3173
3174static int32_t
3175emlxs_dfc_get_rev(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
3176{
3177 emlxs_port_t *port = &PPORT;
3178 uint32_t rev;
3179
3180 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg, "%s requested.",
3181 emlxs_dfc_xlate(dfc->cmd));

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

3307 sizeof (hbainfo.sli4_name));
3308
3309 hbainfo.sli_mode = hba->sli_mode;
3310 hbainfo.vpi_max = hba->vpi_max;
3311 hbainfo.vpi_high = hba->vpi_high;
3312 hbainfo.flags = 0;
3313
3314 /* Set support flags */
3205static int32_t
3206emlxs_dfc_get_rev(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
3207{
3208 emlxs_port_t *port = &PPORT;
3209 uint32_t rev;
3210
3211 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg, "%s requested.",
3212 emlxs_dfc_xlate(dfc->cmd));

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

3338 sizeof (hbainfo.sli4_name));
3339
3340 hbainfo.sli_mode = hba->sli_mode;
3341 hbainfo.vpi_max = hba->vpi_max;
3342 hbainfo.vpi_high = hba->vpi_high;
3343 hbainfo.flags = 0;
3344
3345 /* Set support flags */
3315 hbainfo.flags = HBA_FLAG_DYN_WWN;
3316
3317#ifdef NPIV_SUPPORT
3346 hbainfo.flags = HBA_FLAG_DYN_WWN;
3318 hbainfo.flags |= HBA_FLAG_NPIV;
3347 hbainfo.flags |= HBA_FLAG_NPIV;
3319#endif /* NPIV_SUPPORT */
3320
3321#ifdef DHCHAP_SUPPORT
3322 hbainfo.flags |= HBA_FLAG_DHCHAP;
3323
3324 if (cfg[CFG_AUTH_E2E].current) {
3325 hbainfo.flags |= HBA_FLAG_E2E_AUTH;
3326 }
3327#endif /* DHCHAP_SUPPORT */
3328
3348
3349#ifdef DHCHAP_SUPPORT
3350 hbainfo.flags |= HBA_FLAG_DHCHAP;
3351
3352 if (cfg[CFG_AUTH_E2E].current) {
3353 hbainfo.flags |= HBA_FLAG_E2E_AUTH;
3354 }
3355#endif /* DHCHAP_SUPPORT */
3356
3357#ifdef SAN_DIAG_SUPPORT
3358 hbainfo.flags |= HBA_FLAG_SAN_DIAG;
3359#endif /* SAN_DIAG_SUPPORT */
3360
3329#ifdef SFCT_SUPPORT
3330 hbainfo.flags |= HBA_FLAG_TARGET_MODE;
3331 if (hba->tgt_mode) {
3332 hbainfo.flags |= HBA_FLAG_TARGET_MODE_ENA;
3333 }
3334#endif /* SFCT_SUPPORT */
3335
3361#ifdef SFCT_SUPPORT
3362 hbainfo.flags |= HBA_FLAG_TARGET_MODE;
3363 if (hba->tgt_mode) {
3364 hbainfo.flags |= HBA_FLAG_TARGET_MODE_ENA;
3365 }
3366#endif /* SFCT_SUPPORT */
3367
3368 hbainfo.flags |= HBA_FLAG_FCOE;
3369
3370 if (! (hba->model_info.flags & EMLXS_FCOE_SUPPORTED)) {
3371 hbainfo.flags |= HBA_FLAG_PERSISTLINK;
3372 }
3373
3336 (void) strncpy(hbainfo.fcode_version, vpd->fcode_version,
3337 sizeof (hbainfo.fcode_version));
3338 (void) strncpy(hbainfo.boot_version, vpd->boot_version,
3339 sizeof (hbainfo.boot_version));
3340 (void) strncpy(hbainfo.fw_version, vpd->fw_version,
3341 sizeof (hbainfo.fw_version));
3342 (void) strncpy(hbainfo.drv_label, emlxs_label,
3343 sizeof (hbainfo.drv_label));

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

3365
3366#ifdef MENLO_SUPPORT
3367 if (hba->flag & FC_MENLO_MODE) {
3368 hbainfo.topology = LNK_MENLO_MAINTENANCE;
3369 } else
3370#endif /* MENLO_SUPPORT */
3371
3372 if (hba->state >= FC_LINK_UP) {
3374 (void) strncpy(hbainfo.fcode_version, vpd->fcode_version,
3375 sizeof (hbainfo.fcode_version));
3376 (void) strncpy(hbainfo.boot_version, vpd->boot_version,
3377 sizeof (hbainfo.boot_version));
3378 (void) strncpy(hbainfo.fw_version, vpd->fw_version,
3379 sizeof (hbainfo.fw_version));
3380 (void) strncpy(hbainfo.drv_label, emlxs_label,
3381 sizeof (hbainfo.drv_label));

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

3403
3404#ifdef MENLO_SUPPORT
3405 if (hba->flag & FC_MENLO_MODE) {
3406 hbainfo.topology = LNK_MENLO_MAINTENANCE;
3407 } else
3408#endif /* MENLO_SUPPORT */
3409
3410 if (hba->state >= FC_LINK_UP) {
3373 ndlp = emlxs_node_find_did(port, Fabric_DID);
3411 ndlp = emlxs_node_find_did(port, FABRIC_DID);
3374
3375 if (hba->topology == TOPOLOGY_LOOP) {
3376 if (ndlp) {
3377 hbainfo.port_type = HBA_PORTTYPE_NLPORT;
3378 hbainfo.topology = LNK_PUBLIC_LOOP;
3379 } else {
3380 hbainfo.port_type = HBA_PORTTYPE_LPORT;
3381 hbainfo.topology = LNK_LOOP;

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

3412 } else {
3413 hbainfo.port_speed = HBA_PORTSPEED_1GBIT;
3414 }
3415
3416 hbainfo.node_count = port->node_count;
3417 }
3418
3419 hbainfo.hard_alpa = cfg[CFG_ASSIGN_ALPA].current;
3412
3413 if (hba->topology == TOPOLOGY_LOOP) {
3414 if (ndlp) {
3415 hbainfo.port_type = HBA_PORTTYPE_NLPORT;
3416 hbainfo.topology = LNK_PUBLIC_LOOP;
3417 } else {
3418 hbainfo.port_type = HBA_PORTTYPE_LPORT;
3419 hbainfo.topology = LNK_LOOP;

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

3450 } else {
3451 hbainfo.port_speed = HBA_PORTSPEED_1GBIT;
3452 }
3453
3454 hbainfo.node_count = port->node_count;
3455 }
3456
3457 hbainfo.hard_alpa = cfg[CFG_ASSIGN_ALPA].current;
3420 hbainfo.supported_cos = SWAP_DATA32((FC_NS_CLASS3 | FC_NS_CLASS2));
3458 hbainfo.supported_cos = LE_SWAP32((FC_NS_CLASS3 | FC_NS_CLASS2));
3421
3459
3422 hbainfo.supported_types[0] = SWAP_DATA32(0x00000120);
3423 hbainfo.supported_types[1] = SWAP_DATA32(0x00000001);
3460 hbainfo.supported_types[0] = LE_SWAP32(0x00000120);
3461 hbainfo.supported_types[1] = LE_SWAP32(0x00000001);
3424
3462
3425 hbainfo.active_types[0] = SWAP_DATA32(0x00000120);
3426 hbainfo.active_types[1] = SWAP_DATA32(0x00000001);
3463 hbainfo.active_types[0] = LE_SWAP32(0x00000120);
3464 hbainfo.active_types[1] = LE_SWAP32(0x00000001);
3427
3428 if (!cfg[CFG_NETWORK_ON].current) {
3465
3466 if (!cfg[CFG_NETWORK_ON].current) {
3429 hbainfo.active_types[0] &= ~(SWAP_DATA32(0x00000020));
3467 hbainfo.active_types[0] &= ~(LE_SWAP32(0x00000020));
3430 }
3431
3432 if (vpd->link_speed & LMT_10GB_CAPABLE) {
3433 hbainfo.supported_speeds |= FC_HBA_PORTSPEED_10GBIT;
3434 }
3435 if (vpd->link_speed & LMT_8GB_CAPABLE) {
3436 hbainfo.supported_speeds |= FC_HBA_PORTSPEED_8GBIT;
3437 }

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

3473
3474 if (hba->state == FC_ERROR) {
3475 hbainfo.port_state = HBA_PORTSTATE_ERROR;
3476 } else {
3477 hbainfo.port_state = HBA_PORTSTATE_OFFLINE;
3478 }
3479 }
3480
3468 }
3469
3470 if (vpd->link_speed & LMT_10GB_CAPABLE) {
3471 hbainfo.supported_speeds |= FC_HBA_PORTSPEED_10GBIT;
3472 }
3473 if (vpd->link_speed & LMT_8GB_CAPABLE) {
3474 hbainfo.supported_speeds |= FC_HBA_PORTSPEED_8GBIT;
3475 }

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

3511
3512 if (hba->state == FC_ERROR) {
3513 hbainfo.port_state = HBA_PORTSTATE_ERROR;
3514 } else {
3515 hbainfo.port_state = HBA_PORTSTATE_OFFLINE;
3516 }
3517 }
3518
3519 hbainfo.pci_function_number = hba->pci_function_number;
3520 hbainfo.pci_device_number = hba->pci_device_number;
3521 hbainfo.pci_bus_number = hba->pci_bus_number;
3522
3481 if (ddi_copyout((void *)&hbainfo, (void *)dfc->buf1,
3482 sizeof (dfc_hbainfo_t), mode) != 0) {
3483 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
3484 "%s: ddi_copyout failed.", emlxs_dfc_xlate(dfc->cmd));
3485
3486 return (DFC_COPYOUT_ERROR);
3487 }
3488

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

3524 if (dfc->buf1_size < sizeof (dfc_hbastats_t)) {
3525 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
3526 "%s: Buffer1 too small. (size=%d)",
3527 emlxs_dfc_xlate(dfc->cmd), dfc->buf1_size);
3528
3529 return (DFC_ARG_TOOSMALL);
3530 }
3531
3523 if (ddi_copyout((void *)&hbainfo, (void *)dfc->buf1,
3524 sizeof (dfc_hbainfo_t), mode) != 0) {
3525 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
3526 "%s: ddi_copyout failed.", emlxs_dfc_xlate(dfc->cmd));
3527
3528 return (DFC_COPYOUT_ERROR);
3529 }
3530

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

3566 if (dfc->buf1_size < sizeof (dfc_hbastats_t)) {
3567 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
3568 "%s: Buffer1 too small. (size=%d)",
3569 emlxs_dfc_xlate(dfc->cmd), dfc->buf1_size);
3570
3571 return (DFC_ARG_TOOSMALL);
3572 }
3573
3532 if ((mbq =
3533 (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP)) == 0) {
3534 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
3535 "%s: Unable to allocate mailbox buffer.",
3536 emlxs_dfc_xlate(dfc->cmd));
3574 mbq =
3575 (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP);
3537
3576
3538 return (DFC_SYSRES_ERROR);
3539 }
3540
3541 mb = (MAILBOX *)mbq;
3542
3577 mb = (MAILBOX *)mbq;
3578
3543 emlxs_mb_read_status(hba, mb);
3579 emlxs_mb_read_status(hba, mbq);
3544
3580
3545 rval = emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0);
3581 rval = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
3546
3547 if (rval == MBX_TIMEOUT) {
3548 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
3549 "%s: Mailbox timed out. cmd=%x",
3550 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
3551
3552 rval = DFC_TIMEOUT;
3553 goto done;

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

3570 stats.rx_kbyte_cnt = mb->un.varRdStatus.rcvByteCnt;
3571 stats.tx_seq_cnt = mb->un.varRdStatus.xmitSeqCnt;
3572 stats.rx_seq_cnt = mb->un.varRdStatus.rcvSeqCnt;
3573 stats.orig_exch_cnt = mb->un.varRdStatus.totalOrigExchanges;
3574 stats.resp_exch_cnt = mb->un.varRdStatus.totalRespExchanges;
3575 stats.pbsy_cnt = mb->un.varRdStatus.rcvPbsyCnt;
3576 stats.fbsy_cnt = mb->un.varRdStatus.rcvFbsyCnt;
3577
3582
3583 if (rval == MBX_TIMEOUT) {
3584 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
3585 "%s: Mailbox timed out. cmd=%x",
3586 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
3587
3588 rval = DFC_TIMEOUT;
3589 goto done;

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

3606 stats.rx_kbyte_cnt = mb->un.varRdStatus.rcvByteCnt;
3607 stats.tx_seq_cnt = mb->un.varRdStatus.xmitSeqCnt;
3608 stats.rx_seq_cnt = mb->un.varRdStatus.rcvSeqCnt;
3609 stats.orig_exch_cnt = mb->un.varRdStatus.totalOrigExchanges;
3610 stats.resp_exch_cnt = mb->un.varRdStatus.totalRespExchanges;
3611 stats.pbsy_cnt = mb->un.varRdStatus.rcvPbsyCnt;
3612 stats.fbsy_cnt = mb->un.varRdStatus.rcvFbsyCnt;
3613
3578 emlxs_mb_read_lnk_stat(hba, mb);
3614 emlxs_mb_read_lnk_stat(hba, mbq);
3579
3615
3580 rval = emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0);
3616 rval = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
3581
3582 if (rval == MBX_TIMEOUT) {
3583 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
3584 "%s: Mailbox timed out. cmd=%x",
3585 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
3586
3587 rval = DFC_TIMEOUT;
3588 goto done;

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

3861 /* Killed + Restart state */
3862 case DDI_OFFDI:
3863 if (hba->flag & FC_ONLINE_MODE) {
3864 mutex_exit(&EMLXS_PORT_LOCK);
3865
3866 (void) emlxs_offline(hba);
3867
3868 /* Reset with restart */
3617
3618 if (rval == MBX_TIMEOUT) {
3619 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
3620 "%s: Mailbox timed out. cmd=%x",
3621 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
3622
3623 rval = DFC_TIMEOUT;
3624 goto done;

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

3897 /* Killed + Restart state */
3898 case DDI_OFFDI:
3899 if (hba->flag & FC_ONLINE_MODE) {
3900 mutex_exit(&EMLXS_PORT_LOCK);
3901
3902 (void) emlxs_offline(hba);
3903
3904 /* Reset with restart */
3869 emlxs_sli_hba_reset(hba, 1, 1);
3905 EMLXS_SLI_HBA_RESET(hba, 1, 1, 0);
3870
3871 mutex_enter(&EMLXS_PORT_LOCK);
3872 } else if (hba->state < FC_INIT_START) {
3873 mutex_exit(&EMLXS_PORT_LOCK);
3874
3875 /* Reset with restart */
3906
3907 mutex_enter(&EMLXS_PORT_LOCK);
3908 } else if (hba->state < FC_INIT_START) {
3909 mutex_exit(&EMLXS_PORT_LOCK);
3910
3911 /* Reset with restart */
3876 emlxs_sli_hba_reset(hba, 1, 1);
3912 EMLXS_SLI_HBA_RESET(hba, 1, 1, 0);
3877
3878 mutex_enter(&EMLXS_PORT_LOCK);
3879 }
3880
3881 break;
3882
3883 /* Killed + Reset state */
3884 case DDI_WARMDI:
3885 if (hba->flag & FC_ONLINE_MODE) {
3886 mutex_exit(&EMLXS_PORT_LOCK);
3887
3888 (void) emlxs_offline(hba);
3889
3890 /* Reset with no restart */
3913
3914 mutex_enter(&EMLXS_PORT_LOCK);
3915 }
3916
3917 break;
3918
3919 /* Killed + Reset state */
3920 case DDI_WARMDI:
3921 if (hba->flag & FC_ONLINE_MODE) {
3922 mutex_exit(&EMLXS_PORT_LOCK);
3923
3924 (void) emlxs_offline(hba);
3925
3926 /* Reset with no restart */
3891 emlxs_sli_hba_reset(hba, 0, 0);
3927 EMLXS_SLI_HBA_RESET(hba, 0, 0, 0);
3892
3893 mutex_enter(&EMLXS_PORT_LOCK);
3894 } else if (hba->state != FC_WARM_START) {
3895 mutex_exit(&EMLXS_PORT_LOCK);
3896
3897 /* Reset with no restart */
3928
3929 mutex_enter(&EMLXS_PORT_LOCK);
3930 } else if (hba->state != FC_WARM_START) {
3931 mutex_exit(&EMLXS_PORT_LOCK);
3932
3933 /* Reset with no restart */
3898 emlxs_sli_hba_reset(hba, 0, 0);
3934 EMLXS_SLI_HBA_RESET(hba, 0, 0, 0);
3899
3900 mutex_enter(&EMLXS_PORT_LOCK);
3901 }
3902
3903 break;
3904
3905 /* Killed */
3906 case DDI_DIAGDI:
3907 if (hba->flag & FC_ONLINE_MODE) {
3908 mutex_exit(&EMLXS_PORT_LOCK);
3909
3910 (void) emlxs_offline(hba);
3911
3912 mutex_enter(&EMLXS_PORT_LOCK);
3913 } else if (hba->state != FC_KILLED) {
3914 mutex_exit(&EMLXS_PORT_LOCK);
3915
3935
3936 mutex_enter(&EMLXS_PORT_LOCK);
3937 }
3938
3939 break;
3940
3941 /* Killed */
3942 case DDI_DIAGDI:
3943 if (hba->flag & FC_ONLINE_MODE) {
3944 mutex_exit(&EMLXS_PORT_LOCK);
3945
3946 (void) emlxs_offline(hba);
3947
3948 mutex_enter(&EMLXS_PORT_LOCK);
3949 } else if (hba->state != FC_KILLED) {
3950 mutex_exit(&EMLXS_PORT_LOCK);
3951
3916 emlxs_sli_offline(hba);
3952 EMLXS_SLI_HBA_KILL(hba);
3917
3918 mutex_enter(&EMLXS_PORT_LOCK);
3919 }
3920
3921 break;
3922
3923 default:
3924 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,

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

4063 emlxs_dfc_xlate(dfc->cmd), dfc->buf3_size);
4064
4065 return (DFC_ARG_TOOBIG);
4066 }
4067
4068 extsize =
4069 (dfc->buf3_size >
4070 dfc->buf4_size) ? dfc->buf3_size : dfc->buf4_size;
3953
3954 mutex_enter(&EMLXS_PORT_LOCK);
3955 }
3956
3957 break;
3958
3959 default:
3960 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,

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

4099 emlxs_dfc_xlate(dfc->cmd), dfc->buf3_size);
4100
4101 return (DFC_ARG_TOOBIG);
4102 }
4103
4104 extsize =
4105 (dfc->buf3_size >
4106 dfc->buf4_size) ? dfc->buf3_size : dfc->buf4_size;
4071 if ((extbuf =
4072 (uint8_t *)kmem_zalloc(extsize, KM_SLEEP)) == 0) {
4073 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4074 "%s: Unable to allocate mailbox extension buffer.",
4075 emlxs_dfc_xlate(dfc->cmd));
4107 extbuf =
4108 (uint8_t *)kmem_zalloc(extsize, KM_SLEEP);
4076
4109
4077 return (DFC_SYSRES_ERROR);
4078 }
4079
4080 if (dfc->buf3_size) {
4081 if (ddi_copyin((void *)dfc->buf3, (void *)extbuf,
4082 dfc->buf3_size, mode) != 0) {
4083 EMLXS_MSGF(EMLXS_CONTEXT,
4084 &emlxs_dfc_error_msg,
4085 "%s: ddi_copyin mbox extension data "
4086 "failed.", emlxs_dfc_xlate(dfc->cmd));
4087
4088 rval = DFC_COPYIN_ERROR;
4089 goto done;
4090 }
4091 }
4092 }
4093#endif /* MBOX_EXT_SUPPORT */
4094
4110 if (dfc->buf3_size) {
4111 if (ddi_copyin((void *)dfc->buf3, (void *)extbuf,
4112 dfc->buf3_size, mode) != 0) {
4113 EMLXS_MSGF(EMLXS_CONTEXT,
4114 &emlxs_dfc_error_msg,
4115 "%s: ddi_copyin mbox extension data "
4116 "failed.", emlxs_dfc_xlate(dfc->cmd));
4117
4118 rval = DFC_COPYIN_ERROR;
4119 goto done;
4120 }
4121 }
4122 }
4123#endif /* MBOX_EXT_SUPPORT */
4124
4095 if ((mbq =
4096 (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP)) == 0) {
4097 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4098 "%s: Unable to allocate mailbox buffer.",
4099 emlxs_dfc_xlate(dfc->cmd));
4125 mbq =
4126 (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP);
4100
4127
4101 rval = DFC_SYSRES_ERROR;
4102 goto done;
4103 }
4104
4105 mb = (MAILBOX *) mbq;
4106
4107 bzero((void *) mb, MAILBOX_CMD_BSIZE);
4108
4109 if (ddi_copyin((void *)dfc->buf1, (void *)mb, dfc->buf1_size,
4110 mode) != 0) {
4111 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4112 "%s: ddi_copyin failed.", emlxs_dfc_xlate(dfc->cmd));

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

4198 }
4199
4200 if (did == 0xffffffff) {
4201 emlxs_node_destroy_all(port);
4202 break;
4203 }
4204
4205 /* Check for base node */
4128 mb = (MAILBOX *) mbq;
4129
4130 bzero((void *) mb, MAILBOX_CMD_BSIZE);
4131
4132 if (ddi_copyin((void *)dfc->buf1, (void *)mb, dfc->buf1_size,
4133 mode) != 0) {
4134 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4135 "%s: ddi_copyin failed.", emlxs_dfc_xlate(dfc->cmd));

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

4221 }
4222
4223 if (did == 0xffffffff) {
4224 emlxs_node_destroy_all(port);
4225 break;
4226 }
4227
4228 /* Check for base node */
4206 if (did == Bcast_DID) {
4229 if (did == BCAST_DID) {
4207 /* just flush base node */
4208 (void) emlxs_tx_node_flush(port, &port->node_base,
4209 0, 0, 0);
4210 (void) emlxs_chipq_node_flush(port, 0, &port->node_base,
4211 0);
4212
4213 /* Return now */
4214 rval = 0;

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

4241 }
4242
4243 /* Send it */
4244 break;
4245
4246 /* Online / Offline - with DMA */
4247 case MBX_READ_EVENT_LOG: /* 0x38 */
4248 lptr =
4230 /* just flush base node */
4231 (void) emlxs_tx_node_flush(port, &port->node_base,
4232 0, 0, 0);
4233 (void) emlxs_chipq_node_flush(port, 0, &port->node_base,
4234 0);
4235
4236 /* Return now */
4237 rval = 0;

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

4264 }
4265
4266 /* Send it */
4267 break;
4268
4269 /* Online / Offline - with DMA */
4270 case MBX_READ_EVENT_LOG: /* 0x38 */
4271 lptr =
4249 (uintptr_t)getPaddr(mb->un.varRdEvtLog.un.sp64.addrHigh,
4272 (uintptr_t)PADDR(mb->un.varRdEvtLog.un.sp64.addrHigh,
4250 mb->un.varRdEvtLog.un.sp64.addrLow);
4251 size = (int)mb->un.varRdEvtLog.un.sp64.tus.f.bdeSize;
4252
4253 if (!lptr || !size || (size > MEM_BUF_SIZE)) {
4254 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4255 "%s: Invalid BDE. cmd=%x",
4256 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4257
4258 rval = DFC_ARG_INVALID;
4259 goto done;
4260 }
4261
4262 /* Allocate receive buffer */
4273 mb->un.varRdEvtLog.un.sp64.addrLow);
4274 size = (int)mb->un.varRdEvtLog.un.sp64.tus.f.bdeSize;
4275
4276 if (!lptr || !size || (size > MEM_BUF_SIZE)) {
4277 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4278 "%s: Invalid BDE. cmd=%x",
4279 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4280
4281 rval = DFC_ARG_INVALID;
4282 goto done;
4283 }
4284
4285 /* Allocate receive buffer */
4263 if ((rx_mp = (MATCHMAP *)emlxs_mem_buf_alloc(hba)) == 0) {
4286 if ((rx_mp = emlxs_mem_buf_alloc(hba, MEM_BUF_SIZE)) == 0) {
4264 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4265 "%s: Unable to allocate receive buffer. cmd=%x",
4266 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4267
4268 rval = DFC_DRVRES_ERROR;
4269 goto done;
4270 }
4271
4287 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4288 "%s: Unable to allocate receive buffer. cmd=%x",
4289 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4290
4291 rval = DFC_DRVRES_ERROR;
4292 goto done;
4293 }
4294
4272 mb->un.varRdEvtLog.un.sp64.addrHigh = putPaddrHigh(rx_mp->phys);
4273 mb->un.varRdEvtLog.un.sp64.addrLow = putPaddrLow(rx_mp->phys);
4295 mb->un.varRdEvtLog.un.sp64.addrHigh = PADDR_HI(rx_mp->phys);
4296 mb->un.varRdEvtLog.un.sp64.addrLow = PADDR_LO(rx_mp->phys);
4274 mb->un.varRdEvtLog.un.sp64.tus.f.bdeFlags = 0;
4275
4276 break;
4277
4278 case MBX_READ_SPARM: /* 0x0D */
4279 case MBX_READ_SPARM64: /* 0x8D */
4280 lptr =
4297 mb->un.varRdEvtLog.un.sp64.tus.f.bdeFlags = 0;
4298
4299 break;
4300
4301 case MBX_READ_SPARM: /* 0x0D */
4302 case MBX_READ_SPARM64: /* 0x8D */
4303 lptr =
4281 (uintptr_t)getPaddr(mb->un.varRdSparm.un.sp64.addrHigh,
4304 (uintptr_t)PADDR(mb->un.varRdSparm.un.sp64.addrHigh,
4282 mb->un.varRdSparm.un.sp64.addrLow);
4283 size = (int)mb->un.varRdSparm.un.sp64.tus.f.bdeSize;
4284
4285 if (!lptr || !size || (size > MEM_BUF_SIZE)) {
4286 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4287 "%s: Invalid BDE. cmd=%x",
4288 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4289
4290 rval = DFC_ARG_INVALID;
4291 goto done;
4292 }
4293
4294 /* Allocate receive buffer */
4305 mb->un.varRdSparm.un.sp64.addrLow);
4306 size = (int)mb->un.varRdSparm.un.sp64.tus.f.bdeSize;
4307
4308 if (!lptr || !size || (size > MEM_BUF_SIZE)) {
4309 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4310 "%s: Invalid BDE. cmd=%x",
4311 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4312
4313 rval = DFC_ARG_INVALID;
4314 goto done;
4315 }
4316
4317 /* Allocate receive buffer */
4295 if ((rx_mp = (MATCHMAP *)emlxs_mem_buf_alloc(hba)) == 0) {
4318 if ((rx_mp = emlxs_mem_buf_alloc(hba, MEM_BUF_SIZE)) == 0) {
4296 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4297 "%s: Unable to allocate receive buffer. cmd=%x",
4298 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4299
4300 rval = DFC_DRVRES_ERROR;
4301 goto done;
4302 }
4303
4319 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4320 "%s: Unable to allocate receive buffer. cmd=%x",
4321 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4322
4323 rval = DFC_DRVRES_ERROR;
4324 goto done;
4325 }
4326
4304 mb->un.varRdSparm.un.sp64.addrHigh = putPaddrHigh(rx_mp->phys);
4305 mb->un.varRdSparm.un.sp64.addrLow = putPaddrLow(rx_mp->phys);
4327 mb->un.varRdSparm.un.sp64.addrHigh = PADDR_HI(rx_mp->phys);
4328 mb->un.varRdSparm.un.sp64.addrLow = PADDR_LO(rx_mp->phys);
4306 mb->un.varRdSparm.un.sp64.tus.f.bdeFlags = 0;
4307
4308 break;
4309
4310 case MBX_READ_RPI: /* 0x0F */
4311 case MBX_READ_RPI64: /* 0x8F */
4312 lptr =
4329 mb->un.varRdSparm.un.sp64.tus.f.bdeFlags = 0;
4330
4331 break;
4332
4333 case MBX_READ_RPI: /* 0x0F */
4334 case MBX_READ_RPI64: /* 0x8F */
4335 lptr =
4313 (uintptr_t)getPaddr(mb->un.varRdRPI.un.sp64.addrHigh,
4336 (uintptr_t)PADDR(mb->un.varRdRPI.un.sp64.addrHigh,
4314 mb->un.varRdRPI.un.sp64.addrLow);
4315 size = (int)mb->un.varRdRPI.un.sp64.tus.f.bdeSize;
4316
4317 if (!lptr || !size || (size > MEM_BUF_SIZE)) {
4318 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4319 "%s: Invalid BDE. cmd=%x",
4320 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4321
4322 rval = DFC_ARG_INVALID;
4323 goto done;
4324 }
4325
4326 /* Allocate receive buffer */
4337 mb->un.varRdRPI.un.sp64.addrLow);
4338 size = (int)mb->un.varRdRPI.un.sp64.tus.f.bdeSize;
4339
4340 if (!lptr || !size || (size > MEM_BUF_SIZE)) {
4341 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4342 "%s: Invalid BDE. cmd=%x",
4343 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4344
4345 rval = DFC_ARG_INVALID;
4346 goto done;
4347 }
4348
4349 /* Allocate receive buffer */
4327 if ((rx_mp = (MATCHMAP *)emlxs_mem_buf_alloc(hba)) == 0) {
4350 if ((rx_mp = emlxs_mem_buf_alloc(hba, MEM_BUF_SIZE)) == 0) {
4328 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4329 "%s: Unable to allocate receive buffer. cmd=%x",
4330 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4331
4332 rval = DFC_DRVRES_ERROR;
4333 goto done;
4334 }
4335
4351 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4352 "%s: Unable to allocate receive buffer. cmd=%x",
4353 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4354
4355 rval = DFC_DRVRES_ERROR;
4356 goto done;
4357 }
4358
4336 mb->un.varRdRPI.un.sp64.addrHigh = putPaddrHigh(rx_mp->phys);
4337 mb->un.varRdRPI.un.sp64.addrLow = putPaddrLow(rx_mp->phys);
4359 mb->un.varRdRPI.un.sp64.addrHigh = PADDR_HI(rx_mp->phys);
4360 mb->un.varRdRPI.un.sp64.addrLow = PADDR_LO(rx_mp->phys);
4338 mb->un.varRdRPI.un.sp64.tus.f.bdeFlags = 0;
4339
4340 break;
4341
4342 case MBX_RUN_BIU_DIAG: /* 0x04 */
4343 case MBX_RUN_BIU_DIAG64: /* 0x84 */
4344 lptr =
4361 mb->un.varRdRPI.un.sp64.tus.f.bdeFlags = 0;
4362
4363 break;
4364
4365 case MBX_RUN_BIU_DIAG: /* 0x04 */
4366 case MBX_RUN_BIU_DIAG64: /* 0x84 */
4367 lptr =
4345 (uintptr_t)getPaddr(mb->un.varBIUdiag.un.s2.xmit_bde64.
4368 (uintptr_t)PADDR(mb->un.varBIUdiag.un.s2.xmit_bde64.
4346 addrHigh, mb->un.varBIUdiag.un.s2.xmit_bde64.addrLow);
4347 size = (int)mb->un.varBIUdiag.un.s2.xmit_bde64.tus.f.bdeSize;
4348
4349 if (!lptr || !size || (size > MEM_BUF_SIZE)) {
4350 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4351 "%s: Invalid xmit BDE. cmd=%x",
4352 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4353
4354 rval = DFC_ARG_INVALID;
4355 goto done;
4356 }
4357
4358 /* Allocate xmit buffer */
4369 addrHigh, mb->un.varBIUdiag.un.s2.xmit_bde64.addrLow);
4370 size = (int)mb->un.varBIUdiag.un.s2.xmit_bde64.tus.f.bdeSize;
4371
4372 if (!lptr || !size || (size > MEM_BUF_SIZE)) {
4373 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4374 "%s: Invalid xmit BDE. cmd=%x",
4375 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4376
4377 rval = DFC_ARG_INVALID;
4378 goto done;
4379 }
4380
4381 /* Allocate xmit buffer */
4359 if ((tx_mp = (MATCHMAP *)emlxs_mem_buf_alloc(hba)) == 0) {
4382 if ((tx_mp = emlxs_mem_buf_alloc(hba, MEM_BUF_SIZE)) == 0) {
4360 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4361 "%s: Unable to allocate xmit buffer. cmd=%x",
4362 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4363
4364 rval = DFC_DRVRES_ERROR;
4365 goto done;
4366 }
4367
4368 /* Initialize the xmit buffer */
4369 if (ddi_copyin((void *)lptr, (void *)tx_mp->virt, size,
4370 mode) != 0) {
4371 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4372 "%s: ddi_copyin failed. cmd=%x",
4373 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4374
4375 rval = DFC_COPYIN_ERROR;
4376 goto done;
4377 }
4383 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4384 "%s: Unable to allocate xmit buffer. cmd=%x",
4385 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4386
4387 rval = DFC_DRVRES_ERROR;
4388 goto done;
4389 }
4390
4391 /* Initialize the xmit buffer */
4392 if (ddi_copyin((void *)lptr, (void *)tx_mp->virt, size,
4393 mode) != 0) {
4394 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4395 "%s: ddi_copyin failed. cmd=%x",
4396 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4397
4398 rval = DFC_COPYIN_ERROR;
4399 goto done;
4400 }
4378 emlxs_mpdata_sync(tx_mp->dma_handle, 0, size,
4401 EMLXS_MPDATA_SYNC(tx_mp->dma_handle, 0, size,
4379 DDI_DMA_SYNC_FORDEV);
4380
4381 mb->un.varBIUdiag.un.s2.xmit_bde64.addrHigh =
4402 DDI_DMA_SYNC_FORDEV);
4403
4404 mb->un.varBIUdiag.un.s2.xmit_bde64.addrHigh =
4382 putPaddrHigh(tx_mp->phys);
4405 PADDR_HI(tx_mp->phys);
4383 mb->un.varBIUdiag.un.s2.xmit_bde64.addrLow =
4406 mb->un.varBIUdiag.un.s2.xmit_bde64.addrLow =
4384 putPaddrLow(tx_mp->phys);
4407 PADDR_LO(tx_mp->phys);
4385 mb->un.varBIUdiag.un.s2.xmit_bde64.tus.f.bdeFlags = 0;
4386
4387 /* Initialize the receive buffer */
4388 lptr =
4408 mb->un.varBIUdiag.un.s2.xmit_bde64.tus.f.bdeFlags = 0;
4409
4410 /* Initialize the receive buffer */
4411 lptr =
4389 (uintptr_t)getPaddr(mb->un.varBIUdiag.un.s2.rcv_bde64.
4412 (uintptr_t)PADDR(mb->un.varBIUdiag.un.s2.rcv_bde64.
4390 addrHigh, mb->un.varBIUdiag.un.s2.rcv_bde64.addrLow);
4391 size = (int)mb->un.varBIUdiag.un.s2.rcv_bde64.tus.f.bdeSize;
4392
4393 if (!lptr || !size || (size > MEM_BUF_SIZE)) {
4394 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4395 "%s: Invalid rcv BDE. cmd=%x",
4396 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4397
4398 rval = DFC_ARG_INVALID;
4399 goto done;
4400 }
4401
4402 /* Allocate receive buffer */
4413 addrHigh, mb->un.varBIUdiag.un.s2.rcv_bde64.addrLow);
4414 size = (int)mb->un.varBIUdiag.un.s2.rcv_bde64.tus.f.bdeSize;
4415
4416 if (!lptr || !size || (size > MEM_BUF_SIZE)) {
4417 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4418 "%s: Invalid rcv BDE. cmd=%x",
4419 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4420
4421 rval = DFC_ARG_INVALID;
4422 goto done;
4423 }
4424
4425 /* Allocate receive buffer */
4403 if ((rx_mp = (MATCHMAP *)emlxs_mem_buf_alloc(hba)) == 0) {
4426 if ((rx_mp = emlxs_mem_buf_alloc(hba, MEM_BUF_SIZE)) == 0) {
4404 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4405 "%s: Unable to allocate receive buffer. cmd=%x",
4406 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4407
4408 rval = DFC_DRVRES_ERROR;
4409 goto done;
4410 }
4411
4412 mb->un.varBIUdiag.un.s2.rcv_bde64.addrHigh =
4427 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4428 "%s: Unable to allocate receive buffer. cmd=%x",
4429 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4430
4431 rval = DFC_DRVRES_ERROR;
4432 goto done;
4433 }
4434
4435 mb->un.varBIUdiag.un.s2.rcv_bde64.addrHigh =
4413 putPaddrHigh(rx_mp->phys);
4436 PADDR_HI(rx_mp->phys);
4414 mb->un.varBIUdiag.un.s2.rcv_bde64.addrLow =
4437 mb->un.varBIUdiag.un.s2.rcv_bde64.addrLow =
4415 putPaddrLow(rx_mp->phys);
4438 PADDR_LO(rx_mp->phys);
4416 mb->un.varBIUdiag.un.s2.rcv_bde64.tus.f.bdeFlags = 0;
4417
4418 break;
4419
4420 case MBX_REG_LOGIN: /* 0x13 */
4421 case MBX_REG_LOGIN64: /* 0x93 */
4422
4423 did = mb->un.varRegLogin.did;

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

4438 "%s: Too many nodes. cmd=%x",
4439 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4440
4441 rval = DFC_HBARES_ERROR;
4442 goto done;
4443 }
4444
4445 lptr =
4439 mb->un.varBIUdiag.un.s2.rcv_bde64.tus.f.bdeFlags = 0;
4440
4441 break;
4442
4443 case MBX_REG_LOGIN: /* 0x13 */
4444 case MBX_REG_LOGIN64: /* 0x93 */
4445
4446 did = mb->un.varRegLogin.did;

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

4461 "%s: Too many nodes. cmd=%x",
4462 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4463
4464 rval = DFC_HBARES_ERROR;
4465 goto done;
4466 }
4467
4468 lptr =
4446 (uintptr_t)getPaddr(mb->un.varRegLogin.un.sp64.addrHigh,
4469 (uintptr_t)PADDR(mb->un.varRegLogin.un.sp64.addrHigh,
4447 mb->un.varRegLogin.un.sp64.addrLow);
4448 size = (int)mb->un.varRegLogin.un.sp64.tus.f.bdeSize;
4449
4450 if (!lptr || (size > MEM_BUF_SIZE)) {
4451 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4452 "%s: Invalid BDE. cmd=%x",
4453 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4454
4455 rval = DFC_ARG_INVALID;
4456 goto done;
4457 }
4458
4459 /* Allocate xmit buffer */
4470 mb->un.varRegLogin.un.sp64.addrLow);
4471 size = (int)mb->un.varRegLogin.un.sp64.tus.f.bdeSize;
4472
4473 if (!lptr || (size > MEM_BUF_SIZE)) {
4474 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4475 "%s: Invalid BDE. cmd=%x",
4476 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4477
4478 rval = DFC_ARG_INVALID;
4479 goto done;
4480 }
4481
4482 /* Allocate xmit buffer */
4460 if ((tx_mp = (MATCHMAP *)emlxs_mem_buf_alloc(hba)) == 0) {
4483 if ((tx_mp = emlxs_mem_buf_alloc(hba, MEM_BUF_SIZE)) == 0) {
4461 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4462 "%s: Unable to allocate xmit buffer. cmd=%x",
4463 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4464
4465 rval = DFC_DRVRES_ERROR;
4466 goto done;
4467 }
4468
4469 /* Initialize the xmit buffer */
4470 if (ddi_copyin((void *)lptr, (void *)tx_mp->virt, size,
4471 mode) != 0) {
4472 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4473 "%s: Unable to allocate xmit buffer. cmd=%x",
4474 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4475
4476 rval = DFC_COPYIN_ERROR;
4477 goto done;
4478 }
4484 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4485 "%s: Unable to allocate xmit buffer. cmd=%x",
4486 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4487
4488 rval = DFC_DRVRES_ERROR;
4489 goto done;
4490 }
4491
4492 /* Initialize the xmit buffer */
4493 if (ddi_copyin((void *)lptr, (void *)tx_mp->virt, size,
4494 mode) != 0) {
4495 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4496 "%s: Unable to allocate xmit buffer. cmd=%x",
4497 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4498
4499 rval = DFC_COPYIN_ERROR;
4500 goto done;
4501 }
4479 emlxs_mpdata_sync(tx_mp->dma_handle, 0, size,
4502 EMLXS_MPDATA_SYNC(tx_mp->dma_handle, 0, size,
4480 DDI_DMA_SYNC_FORDEV);
4481
4503 DDI_DMA_SYNC_FORDEV);
4504
4482 mb->un.varRegLogin.un.sp64.addrHigh = putPaddrHigh(tx_mp->phys);
4483 mb->un.varRegLogin.un.sp64.addrLow = putPaddrLow(tx_mp->phys);
4505 mb->un.varRegLogin.un.sp64.addrHigh = PADDR_HI(tx_mp->phys);
4506 mb->un.varRegLogin.un.sp64.addrLow = PADDR_LO(tx_mp->phys);
4484 mb->un.varRegLogin.un.sp64.tus.f.bdeFlags = 0;
4485
4486 break;
4487
4488 case MBX_READ_LA: /* 0x15 */
4489 case MBX_READ_LA64: /* 0x95 */
4490 lptr =
4507 mb->un.varRegLogin.un.sp64.tus.f.bdeFlags = 0;
4508
4509 break;
4510
4511 case MBX_READ_LA: /* 0x15 */
4512 case MBX_READ_LA64: /* 0x95 */
4513 lptr =
4491 (uintptr_t)getPaddr(mb->un.varReadLA.un.lilpBde64.
4514 (uintptr_t)PADDR(mb->un.varReadLA.un.lilpBde64.
4492 addrHigh, mb->un.varReadLA.un.lilpBde64.addrLow);
4493 size = (int)mb->un.varReadLA.un.lilpBde64.tus.f.bdeSize;
4494
4495 if (!lptr || !size || (size > MEM_BUF_SIZE)) {
4496 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4497 "%s: Invalid BDE. cmd=%x",
4498 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4499
4500 rval = DFC_ARG_INVALID;
4501 goto done;
4502 }
4503
4504 /* Allocate receive buffer */
4515 addrHigh, mb->un.varReadLA.un.lilpBde64.addrLow);
4516 size = (int)mb->un.varReadLA.un.lilpBde64.tus.f.bdeSize;
4517
4518 if (!lptr || !size || (size > MEM_BUF_SIZE)) {
4519 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4520 "%s: Invalid BDE. cmd=%x",
4521 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4522
4523 rval = DFC_ARG_INVALID;
4524 goto done;
4525 }
4526
4527 /* Allocate receive buffer */
4505 if ((rx_mp = (MATCHMAP *)emlxs_mem_buf_alloc(hba)) == 0) {
4528 if ((rx_mp = emlxs_mem_buf_alloc(hba, MEM_BUF_SIZE)) == 0) {
4506 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4507 "%s: Unable to allocate receive buffer. cmd=%x",
4508 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4509
4510 rval = DFC_DRVRES_ERROR;
4511 goto done;
4512 }
4513
4514 mb->un.varReadLA.un.lilpBde64.addrHigh =
4529 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4530 "%s: Unable to allocate receive buffer. cmd=%x",
4531 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4532
4533 rval = DFC_DRVRES_ERROR;
4534 goto done;
4535 }
4536
4537 mb->un.varReadLA.un.lilpBde64.addrHigh =
4515 putPaddrHigh(rx_mp->phys);
4538 PADDR_HI(rx_mp->phys);
4516 mb->un.varReadLA.un.lilpBde64.addrLow =
4539 mb->un.varReadLA.un.lilpBde64.addrLow =
4517 putPaddrLow(rx_mp->phys);
4540 PADDR_LO(rx_mp->phys);
4518 mb->un.varReadLA.un.lilpBde64.tus.f.bdeFlags = 0;
4519
4520 break;
4521
4522
4523 /* Do not allow these commands */
4524 case MBX_CONFIG_PORT: /* 0x88 */
4525 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,

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

4557#endif /* MBOX_EXT_SUPPORT */
4558
4559 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
4560 "%s: %s sent. (%x %x %x %x)", emlxs_dfc_xlate(dfc->cmd),
4561 emlxs_mb_cmd_xlate(mb->mbxCommand), mb->un.varWords[0],
4562 mb->un.varWords[1], mb->un.varWords[2], mb->un.varWords[3]);
4563
4564 /* issue the mbox cmd to the sli */
4541 mb->un.varReadLA.un.lilpBde64.tus.f.bdeFlags = 0;
4542
4543 break;
4544
4545
4546 /* Do not allow these commands */
4547 case MBX_CONFIG_PORT: /* 0x88 */
4548 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,

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

4580#endif /* MBOX_EXT_SUPPORT */
4581
4582 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
4583 "%s: %s sent. (%x %x %x %x)", emlxs_dfc_xlate(dfc->cmd),
4584 emlxs_mb_cmd_xlate(mb->mbxCommand), mb->un.varWords[0],
4585 mb->un.varWords[1], mb->un.varWords[2], mb->un.varWords[3]);
4586
4587 /* issue the mbox cmd to the sli */
4565 mbxstatus = emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0);
4588 mbxstatus = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
4566
4567 if (mbxstatus) {
4568 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4569 "%s: %s failed. mbxstatus=0x%x",
4570 emlxs_dfc_xlate(dfc->cmd),
4571 emlxs_mb_cmd_xlate(mb->mbxCommand), mbxstatus);
4572
4573 }

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

4578 "%s: ddi_copyout failed. cmd=%x",
4579 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4580
4581 rval = DFC_COPYOUT_ERROR;
4582 goto done;
4583 }
4584
4585 if (rx_mp) {
4589
4590 if (mbxstatus) {
4591 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4592 "%s: %s failed. mbxstatus=0x%x",
4593 emlxs_dfc_xlate(dfc->cmd),
4594 emlxs_mb_cmd_xlate(mb->mbxCommand), mbxstatus);
4595
4596 }

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

4601 "%s: ddi_copyout failed. cmd=%x",
4602 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4603
4604 rval = DFC_COPYOUT_ERROR;
4605 goto done;
4606 }
4607
4608 if (rx_mp) {
4586 emlxs_mpdata_sync(rx_mp->dma_handle, 0, size,
4609 EMLXS_MPDATA_SYNC(rx_mp->dma_handle, 0, size,
4587 DDI_DMA_SYNC_FORKERNEL);
4588
4589 if (ddi_copyout((void *)rx_mp->virt, (void *)lptr, size,
4590 mode) != 0) {
4591 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4592 "%s: ddi_copyout failed for receive buffer. cmd=%x",
4593 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4594

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

4622
4623 /* Free allocated mbox memory */
4624 if (mbq) {
4625 kmem_free(mbq, sizeof (MAILBOXQ));
4626 }
4627
4628 /* Free allocated mbuf memory */
4629 if (rx_mp) {
4610 DDI_DMA_SYNC_FORKERNEL);
4611
4612 if (ddi_copyout((void *)rx_mp->virt, (void *)lptr, size,
4613 mode) != 0) {
4614 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4615 "%s: ddi_copyout failed for receive buffer. cmd=%x",
4616 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
4617

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

4645
4646 /* Free allocated mbox memory */
4647 if (mbq) {
4648 kmem_free(mbq, sizeof (MAILBOXQ));
4649 }
4650
4651 /* Free allocated mbuf memory */
4652 if (rx_mp) {
4630 (void) emlxs_mem_buf_free(hba, (uint8_t *)rx_mp);
4653 (void) emlxs_mem_buf_free(hba, rx_mp);
4631 }
4632
4633 if (tx_mp) {
4654 }
4655
4656 if (tx_mp) {
4634 (void) emlxs_mem_buf_free(hba, (uint8_t *)tx_mp);
4657 (void) emlxs_mem_buf_free(hba, tx_mp);
4635 }
4636
4637 return (rval);
4638
4639} /* emlxs_dfc_send_mbox() */
4640
4641
4642static int32_t

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

4724 return (DFC_SYSRES_ERROR);
4725 }
4726
4727 bptr = buffer;
4728 for (i = offset; i < (offset + cnt); i += 4) {
4729 value =
4730 ddi_get32(hba->pci_acc_handle,
4731 (uint32_t *)(hba->pci_addr + i));
4658 }
4659
4660 return (rval);
4661
4662} /* emlxs_dfc_send_mbox() */
4663
4664
4665static int32_t

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

4747 return (DFC_SYSRES_ERROR);
4748 }
4749
4750 bptr = buffer;
4751 for (i = offset; i < (offset + cnt); i += 4) {
4752 value =
4753 ddi_get32(hba->pci_acc_handle,
4754 (uint32_t *)(hba->pci_addr + i));
4732 *bptr++ = PCIMEM_LONG(value);
4755 *bptr++ = BE_SWAP32(value);
4733 }
4734
4756 }
4757
4735
4736 if (ddi_copyout((void *)buffer, (void *)dfc->buf1, outsz, mode) != 0) {
4737 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4738 "%s: ddi_copyout failed.", emlxs_dfc_xlate(dfc->cmd));
4739
4740 kmem_free(buffer, size);
4741 return (DFC_COPYOUT_ERROR);
4742 }
4743

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

4831 "%s: ddi_copyin failed.", emlxs_dfc_xlate(dfc->cmd));
4832
4833 return (DFC_COPYIN_ERROR);
4834 }
4835
4836 bptr = (uint32_t *)buffer;
4837 for (i = offset; i < (offset + cnt); i += 4) {
4838 value = *bptr++;
4758 if (ddi_copyout((void *)buffer, (void *)dfc->buf1, outsz, mode) != 0) {
4759 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
4760 "%s: ddi_copyout failed.", emlxs_dfc_xlate(dfc->cmd));
4761
4762 kmem_free(buffer, size);
4763 return (DFC_COPYOUT_ERROR);
4764 }
4765

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

4853 "%s: ddi_copyin failed.", emlxs_dfc_xlate(dfc->cmd));
4854
4855 return (DFC_COPYIN_ERROR);
4856 }
4857
4858 bptr = (uint32_t *)buffer;
4859 for (i = offset; i < (offset + cnt); i += 4) {
4860 value = *bptr++;
4839 value = PCIMEM_LONG(value);
4861 value = BE_SWAP32(value);
4840
4841 word0 = value & 0xFFFF;
4842 word1 = value >> 16;
4843
4844 /*
4845 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_debug_msg,
4846 * "%s: Writing. offset=%x cnt=%d value=%08x %04x %04x",
4847 * emlxs_dfc_xlate(dfc->cmd), i, value, word0, word1);

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

4916 cfgparam[i].a_low = cfg[i].low;
4917 cfgparam[i].a_hi = cfg[i].hi;
4918 cfgparam[i].a_default = cfg[i].def;
4919 cfgparam[i].a_current = cfg[i].current;
4920
4921 if (!(cfg[i].flags & PARM_HIDDEN)) {
4922 cfgparam[i].a_flag |= CFG_EXPORT;
4923 }
4862
4863 word0 = value & 0xFFFF;
4864 word1 = value >> 16;
4865
4866 /*
4867 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_debug_msg,
4868 * "%s: Writing. offset=%x cnt=%d value=%08x %04x %04x",
4869 * emlxs_dfc_xlate(dfc->cmd), i, value, word0, word1);

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

4938 cfgparam[i].a_low = cfg[i].low;
4939 cfgparam[i].a_hi = cfg[i].hi;
4940 cfgparam[i].a_default = cfg[i].def;
4941 cfgparam[i].a_current = cfg[i].current;
4942
4943 if (!(cfg[i].flags & PARM_HIDDEN)) {
4944 cfgparam[i].a_flag |= CFG_EXPORT;
4945 }
4946 cfgparam[i].a_flag |= CFG_COMMON;
4924
4947
4948 /* Adjust a_flag based on the hba model */
4949 switch (i) {
4950 case CFG_NETWORK_ON:
4951 case CFG_TOPOLOGY:
4952 case CFG_LINK_SPEED:
4953 case CFG_CR_DELAY:
4954 case CFG_CR_COUNT:
4955#ifdef SFCT_SUPPORT
4956 case CFG_TARGET_MODE:
4957#endif /* SFCT_SUPPORT */
4958 if (!(hba->model_info.flags & EMLXS_FCOE_SUPPORTED)) {
4959 cfgparam[i].a_flag |= CFG_APPLICABLE;
4960 }
4961 break;
4962
4963 case CFG_NUM_WQ:
4964 if (hba->model_info.flags & EMLXS_FCOE_SUPPORTED) {
4965 cfgparam[i].a_flag |= CFG_APPLICABLE;
4966 }
4967 break;
4968
4969 case CFG_PERSIST_LINKDOWN:
4970 cfgparam[i].a_flag &= ~CFG_EXPORT;
4971 break;
4972
4973 default:
4974 cfgparam[i].a_flag |= CFG_APPLICABLE;
4975 break;
4976 }
4977
4925 if ((cfg[i].flags & PARM_DYNAMIC)) {
4926 if ((cfg[i].flags & PARM_DYNAMIC_RESET) ==
4927 PARM_DYNAMIC_RESET) {
4928 cfgparam[i].a_changestate = CFG_RESTART;
4929 } else if ((cfg[i].flags & PARM_DYNAMIC_LINK) ==
4930 PARM_DYNAMIC_LINK) {
4931 cfgparam[i].a_changestate = CFG_LINKRESET;
4932 } else {

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

5138 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
5139 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
5140 pkt->pkt_comp = NULL;
5141
5142 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
5143 pkt->pkt_timeout = (timeout) ? timeout : 30;
5144
5145 /* Build the fc header */
4978 if ((cfg[i].flags & PARM_DYNAMIC)) {
4979 if ((cfg[i].flags & PARM_DYNAMIC_RESET) ==
4980 PARM_DYNAMIC_RESET) {
4981 cfgparam[i].a_changestate = CFG_RESTART;
4982 } else if ((cfg[i].flags & PARM_DYNAMIC_LINK) ==
4983 PARM_DYNAMIC_LINK) {
4984 cfgparam[i].a_changestate = CFG_LINKRESET;
4985 } else {

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

5191 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
5192 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
5193 pkt->pkt_comp = NULL;
5194
5195 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
5196 pkt->pkt_timeout = (timeout) ? timeout : 30;
5197
5198 /* Build the fc header */
5146 pkt->pkt_cmd_fhdr.d_id = SWAP_DATA24_LO(did);
5199 pkt->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(did);
5147 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_UNSOL_CONTROL;
5200 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_UNSOL_CONTROL;
5148 pkt->pkt_cmd_fhdr.s_id = SWAP_DATA24_LO(port->did);
5201 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(port->did);
5149 pkt->pkt_cmd_fhdr.type = FC_TYPE_FC_SERVICES;
5150 pkt->pkt_cmd_fhdr.f_ctl =
5151 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
5152 pkt->pkt_cmd_fhdr.seq_id = 0;
5153 pkt->pkt_cmd_fhdr.df_ctl = 0;
5154 pkt->pkt_cmd_fhdr.seq_cnt = 0;
5155 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
5156 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;

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

5263 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
5264 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
5265 pkt->pkt_comp = NULL;
5266
5267 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
5268 pkt->pkt_timeout = (timeout) ? timeout : 30;
5269
5270 /* Build the fc header */
5202 pkt->pkt_cmd_fhdr.type = FC_TYPE_FC_SERVICES;
5203 pkt->pkt_cmd_fhdr.f_ctl =
5204 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
5205 pkt->pkt_cmd_fhdr.seq_id = 0;
5206 pkt->pkt_cmd_fhdr.df_ctl = 0;
5207 pkt->pkt_cmd_fhdr.seq_cnt = 0;
5208 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
5209 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;

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

5316 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
5317 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
5318 pkt->pkt_comp = NULL;
5319
5320 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
5321 pkt->pkt_timeout = (timeout) ? timeout : 30;
5322
5323 /* Build the fc header */
5271 pkt->pkt_cmd_fhdr.d_id = SWAP_DATA24_LO(0);
5324 pkt->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(0);
5272 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_SOLICITED_CONTROL;
5325 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_SOLICITED_CONTROL;
5273 pkt->pkt_cmd_fhdr.s_id = SWAP_DATA24_LO(port->did);
5326 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(port->did);
5274 pkt->pkt_cmd_fhdr.type = FC_TYPE_FC_SERVICES;
5275 pkt->pkt_cmd_fhdr.f_ctl =
5276 F_CTL_LAST_SEQ | F_CTL_END_SEQ | F_CTL_XCHG_CONTEXT;
5277 pkt->pkt_cmd_fhdr.seq_id = 0;
5278 pkt->pkt_cmd_fhdr.df_ctl = 0;
5279 pkt->pkt_cmd_fhdr.seq_cnt = 0;
5280 pkt->pkt_cmd_fhdr.ox_id = 0xffff;
5281 pkt->pkt_cmd_fhdr.rx_id = rx_id;

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

5382 emlxs_dfc_xlate(dfc->cmd), dfc->buf3_size,
5383 sizeof (uint32_t));
5384
5385 rval = DFC_ARG_TOOSMALL;
5386 goto done;
5387 }
5388
5389 cmd_size = dfc->buf1_size;
5327 pkt->pkt_cmd_fhdr.type = FC_TYPE_FC_SERVICES;
5328 pkt->pkt_cmd_fhdr.f_ctl =
5329 F_CTL_LAST_SEQ | F_CTL_END_SEQ | F_CTL_XCHG_CONTEXT;
5330 pkt->pkt_cmd_fhdr.seq_id = 0;
5331 pkt->pkt_cmd_fhdr.df_ctl = 0;
5332 pkt->pkt_cmd_fhdr.seq_cnt = 0;
5333 pkt->pkt_cmd_fhdr.ox_id = 0xffff;
5334 pkt->pkt_cmd_fhdr.rx_id = rx_id;

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

5435 emlxs_dfc_xlate(dfc->cmd), dfc->buf3_size,
5436 sizeof (uint32_t));
5437
5438 rval = DFC_ARG_TOOSMALL;
5439 goto done;
5440 }
5441
5442 cmd_size = dfc->buf1_size;
5390 if ((cmd_buf = (uint8_t *)kmem_zalloc(cmd_size,
5391 KM_SLEEP)) == 0) {
5392 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
5393 "%s: Unable to allocate command buffer.",
5394 emlxs_dfc_xlate(dfc->cmd));
5443 cmd_buf = (uint8_t *)kmem_zalloc(cmd_size,
5444 KM_SLEEP);
5395
5445
5396 rval = DFC_SYSRES_ERROR;
5397 goto done;
5398 }
5399
5400 rsp_size = dfc->buf2_size;
5446 rsp_size = dfc->buf2_size;
5401 if ((rsp_buf = (uint8_t *)kmem_zalloc(rsp_size,
5402 KM_SLEEP)) == 0) {
5403 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
5404 "%s: Unable to allocate response buffer.",
5405 emlxs_dfc_xlate(dfc->cmd));
5447 rsp_buf = (uint8_t *)kmem_zalloc(rsp_size,
5448 KM_SLEEP);
5406
5449
5407 rval = DFC_SYSRES_ERROR;
5408 goto done;
5409 }
5410
5411 /* Read the command buffer */
5412 if (ddi_copyin((void *)dfc->buf1, (void *)cmd_buf,
5413 cmd_size, mode) != 0) {
5414 EMLXS_MSGF(EMLXS_CONTEXT,
5415 &emlxs_dfc_error_msg,
5416 "%s: Unable to read command buffer.",
5417 emlxs_dfc_xlate(dfc->cmd));
5418

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

5480 clock_t timeout;
5481 MAILBOXQ *mbq = NULL;
5482 MAILBOX *mb;
5483 uint32_t addr;
5484 uint32_t value;
5485 uint32_t mbxstatus;
5486
5487 cmd_code = *(uint32_t *)cmd_buf;
5450 /* Read the command buffer */
5451 if (ddi_copyin((void *)dfc->buf1, (void *)cmd_buf,
5452 cmd_size, mode) != 0) {
5453 EMLXS_MSGF(EMLXS_CONTEXT,
5454 &emlxs_dfc_error_msg,
5455 "%s: Unable to read command buffer.",
5456 emlxs_dfc_xlate(dfc->cmd));
5457

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

5519 clock_t timeout;
5520 MAILBOXQ *mbq = NULL;
5521 MAILBOX *mb;
5522 uint32_t addr;
5523 uint32_t value;
5524 uint32_t mbxstatus;
5525
5526 cmd_code = *(uint32_t *)cmd_buf;
5488 cmd_code = SWAP_LONG(cmd_code);
5527 cmd_code = BE_SWAP32(cmd_code);
5489
5490 /* Look for Zephyr specific commands */
5491 if (cmd_code & 0x80000000) {
5492 bzero((uint8_t *)&reset_cmd, sizeof (menlo_reset_cmd_t));
5493 bzero((uint8_t *)&set_cmd, sizeof (menlo_set_cmd_t));
5494 bzero((uint8_t *)&rsp_code, sizeof (uint32_t));
5495
5496 /* Validate response buffer */

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

5591 default:
5592 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
5593 "emlxs_send_menlo_cmd: "
5594 "Invalid command. cmd=%x", cmd_code);
5595 rval = DFC_ARG_INVALID;
5596 goto done;
5597 }
5598
5528
5529 /* Look for Zephyr specific commands */
5530 if (cmd_code & 0x80000000) {
5531 bzero((uint8_t *)&reset_cmd, sizeof (menlo_reset_cmd_t));
5532 bzero((uint8_t *)&set_cmd, sizeof (menlo_set_cmd_t));
5533 bzero((uint8_t *)&rsp_code, sizeof (uint32_t));
5534
5535 /* Validate response buffer */

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

5630 default:
5631 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
5632 "emlxs_send_menlo_cmd: "
5633 "Invalid command. cmd=%x", cmd_code);
5634 rval = DFC_ARG_INVALID;
5635 goto done;
5636 }
5637
5599 if ((mbq = (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ),
5600 KM_SLEEP)) == 0) {
5601 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
5602 "emlxs_send_menlo_cmd: "
5603 "Unable to allocate mailbox buffer.");
5638 mbq = (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ),
5639 KM_SLEEP);
5604
5640
5605 rval = DFC_SYSRES_ERROR;
5606 goto done;
5607 }
5608
5609 mb = (MAILBOX *) mbq;
5610
5611 /* Create the set_variable mailbox request */
5641 mb = (MAILBOX *) mbq;
5642
5643 /* Create the set_variable mailbox request */
5612 emlxs_mb_set_var(hba, mb, addr, value);
5644 emlxs_mb_set_var(hba, mbq, addr, value);
5613
5614 mbq->flag |= MBQ_PASSTHRU;
5615
5616 /* issue the mbox cmd to the sli */
5645
5646 mbq->flag |= MBQ_PASSTHRU;
5647
5648 /* issue the mbox cmd to the sli */
5617 mbxstatus = emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0);
5649 mbxstatus = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
5618
5619 if (mbxstatus) {
5620 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
5621 "emlxs_send_menlo_cmd: %s failed. mbxstatus=0x%x",
5622 emlxs_mb_cmd_xlate(mb->mbxCommand), mbxstatus);
5623
5624 if (mbxstatus == MBX_TIMEOUT) {
5625 rval = DFC_TIMEOUT;

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

5701 /* Make this a polled IO */
5702 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
5703 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
5704 pkt->pkt_comp = NULL;
5705 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
5706 pkt->pkt_timeout = 30;
5707
5708 /* Build the fc header */
5650
5651 if (mbxstatus) {
5652 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
5653 "emlxs_send_menlo_cmd: %s failed. mbxstatus=0x%x",
5654 emlxs_mb_cmd_xlate(mb->mbxCommand), mbxstatus);
5655
5656 if (mbxstatus == MBX_TIMEOUT) {
5657 rval = DFC_TIMEOUT;

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

5733 /* Make this a polled IO */
5734 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
5735 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
5736 pkt->pkt_comp = NULL;
5737 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
5738 pkt->pkt_timeout = 30;
5739
5740 /* Build the fc header */
5709 pkt->pkt_cmd_fhdr.d_id = SWAP_DATA24_LO(EMLXS_MENLO_DID);
5741 pkt->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(EMLXS_MENLO_DID);
5710 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_COMMAND;
5742 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_COMMAND;
5711 pkt->pkt_cmd_fhdr.s_id = SWAP_DATA24_LO(port->did);
5743 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(port->did);
5712 pkt->pkt_cmd_fhdr.type = EMLXS_MENLO_TYPE;
5713 pkt->pkt_cmd_fhdr.f_ctl =
5714 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
5715 pkt->pkt_cmd_fhdr.seq_id = 0;
5716 pkt->pkt_cmd_fhdr.df_ctl = 0;
5717 pkt->pkt_cmd_fhdr.seq_cnt = 0;
5718 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
5719 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;

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

5756 }
5757
5758 if (cmd_code == MENLO_CMD_FW_DOWNLOAD) {
5759 uint32_t *rsp;
5760
5761 /* Check response code */
5762 rsp = (uint32_t *)pkt->pkt_resp;
5763 rsp_code = *rsp;
5744 pkt->pkt_cmd_fhdr.type = EMLXS_MENLO_TYPE;
5745 pkt->pkt_cmd_fhdr.f_ctl =
5746 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
5747 pkt->pkt_cmd_fhdr.seq_id = 0;
5748 pkt->pkt_cmd_fhdr.df_ctl = 0;
5749 pkt->pkt_cmd_fhdr.seq_cnt = 0;
5750 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
5751 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;

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

5788 }
5789
5790 if (cmd_code == MENLO_CMD_FW_DOWNLOAD) {
5791 uint32_t *rsp;
5792
5793 /* Check response code */
5794 rsp = (uint32_t *)pkt->pkt_resp;
5795 rsp_code = *rsp;
5764 rsp_code = SWAP_LONG(rsp_code);
5796 rsp_code = BE_SWAP32(rsp_code);
5765
5766 if (rsp_code == MENLO_RSP_SUCCESS) {
5767 /* Now transmit the data phase */
5768
5769 /* Save last rx_id */
5770 uint32_t rx_id = pkt->pkt_cmd_fhdr.rx_id;
5771
5772 /* Free old pkt */

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

5789 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
5790 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
5791 pkt->pkt_comp = NULL;
5792 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
5793 pkt->pkt_timeout = 30;
5794
5795 /* Build the fc header */
5796 pkt->pkt_cmd_fhdr.d_id =
5797
5798 if (rsp_code == MENLO_RSP_SUCCESS) {
5799 /* Now transmit the data phase */
5800
5801 /* Save last rx_id */
5802 uint32_t rx_id = pkt->pkt_cmd_fhdr.rx_id;
5803
5804 /* Free old pkt */

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

5821 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
5822 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
5823 pkt->pkt_comp = NULL;
5824 pkt->pkt_tran_type = FC_PKT_OUTBOUND;
5825 pkt->pkt_timeout = 30;
5826
5827 /* Build the fc header */
5828 pkt->pkt_cmd_fhdr.d_id =
5797 SWAP_DATA24_LO(EMLXS_MENLO_DID);
5829 LE_SWAP24_LO(EMLXS_MENLO_DID);
5798 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_COMMAND;
5799 pkt->pkt_cmd_fhdr.s_id =
5830 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_COMMAND;
5831 pkt->pkt_cmd_fhdr.s_id =
5800 SWAP_DATA24_LO(port->did);
5832 LE_SWAP24_LO(port->did);
5801 pkt->pkt_cmd_fhdr.type = EMLXS_MENLO_TYPE;
5802 pkt->pkt_cmd_fhdr.f_ctl =
5803 F_CTL_FIRST_SEQ | F_CTL_END_SEQ |
5804 F_CTL_SEQ_INITIATIVE;
5805 pkt->pkt_cmd_fhdr.seq_id = 0;
5806 pkt->pkt_cmd_fhdr.df_ctl = 0;
5807 pkt->pkt_cmd_fhdr.seq_cnt = 0;
5808 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;

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

5897 /* Make this a polled IO */
5898 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
5899 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
5900 pkt->pkt_comp = NULL;
5901 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
5902 pkt->pkt_timeout = 30;
5903
5904 /* Build the fc header */
5833 pkt->pkt_cmd_fhdr.type = EMLXS_MENLO_TYPE;
5834 pkt->pkt_cmd_fhdr.f_ctl =
5835 F_CTL_FIRST_SEQ | F_CTL_END_SEQ |
5836 F_CTL_SEQ_INITIATIVE;
5837 pkt->pkt_cmd_fhdr.seq_id = 0;
5838 pkt->pkt_cmd_fhdr.df_ctl = 0;
5839 pkt->pkt_cmd_fhdr.seq_cnt = 0;
5840 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;

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

5929 /* Make this a polled IO */
5930 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
5931 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
5932 pkt->pkt_comp = NULL;
5933 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
5934 pkt->pkt_timeout = 30;
5935
5936 /* Build the fc header */
5905 pkt->pkt_cmd_fhdr.d_id = SWAP_DATA24_LO(EMLXS_MENLO_DID);
5937 pkt->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(EMLXS_MENLO_DID);
5906 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_COMMAND;
5938 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_COMMAND;
5907 pkt->pkt_cmd_fhdr.s_id = SWAP_DATA24_LO(port->did);
5939 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(port->did);
5908 pkt->pkt_cmd_fhdr.type = EMLXS_MENLO_TYPE;
5909 pkt->pkt_cmd_fhdr.f_ctl =
5910 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
5911 pkt->pkt_cmd_fhdr.seq_id = 0;
5912 pkt->pkt_cmd_fhdr.df_ctl = 0;
5913 pkt->pkt_cmd_fhdr.seq_cnt = 0;
5914 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
5915 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;
5916 pkt->pkt_cmd_fhdr.ro = 0;
5917
5918 cmd = (menlo_get_cmd_t *)pkt->pkt_cmd;
5919 cmd->code = MENLO_CMD_GET_INIT;
5920 cmd->context = 0;
5921 cmd->length = sizeof (menlo_init_rsp_t);
5922
5923 /* Little Endian Swap */
5940 pkt->pkt_cmd_fhdr.type = EMLXS_MENLO_TYPE;
5941 pkt->pkt_cmd_fhdr.f_ctl =
5942 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
5943 pkt->pkt_cmd_fhdr.seq_id = 0;
5944 pkt->pkt_cmd_fhdr.df_ctl = 0;
5945 pkt->pkt_cmd_fhdr.seq_cnt = 0;
5946 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
5947 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;
5948 pkt->pkt_cmd_fhdr.ro = 0;
5949
5950 cmd = (menlo_get_cmd_t *)pkt->pkt_cmd;
5951 cmd->code = MENLO_CMD_GET_INIT;
5952 cmd->context = 0;
5953 cmd->length = sizeof (menlo_init_rsp_t);
5954
5955 /* Little Endian Swap */
5924 cmd->code = SWAP_LONG(cmd->code);
5925 cmd->length = SWAP_LONG(cmd->length);
5956 cmd->code = BE_SWAP32(cmd->code);
5957 cmd->length = BE_SWAP32(cmd->length);
5926
5927 if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
5928 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
5929 "FCoE attention: Unable to send packet.");
5930
5931 goto done;
5932 }
5933
5934 if (pkt->pkt_state != FC_PKT_SUCCESS) {
5935 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
5936 "FCoE attention: Pkt Transport error. state=%x",
5937 pkt->pkt_state);
5938
5939 goto done;
5940 }
5941
5942 /* Check response code */
5943 rsp = (menlo_init_rsp_t *)pkt->pkt_resp;
5958
5959 if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
5960 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
5961 "FCoE attention: Unable to send packet.");
5962
5963 goto done;
5964 }
5965
5966 if (pkt->pkt_state != FC_PKT_SUCCESS) {
5967 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
5968 "FCoE attention: Pkt Transport error. state=%x",
5969 pkt->pkt_state);
5970
5971 goto done;
5972 }
5973
5974 /* Check response code */
5975 rsp = (menlo_init_rsp_t *)pkt->pkt_resp;
5944 rsp->code = SWAP_LONG(rsp->code);
5976 rsp->code = BE_SWAP32(rsp->code);
5945
5946 if (rsp->code != MENLO_RSP_SUCCESS) {
5947 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
5948 "FCoE attention: FCOE Response error =%x", rsp->code);
5949
5950 goto done;
5951 }
5952
5953 /* Little Endian Swap */
5977
5978 if (rsp->code != MENLO_RSP_SUCCESS) {
5979 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
5980 "FCoE attention: FCOE Response error =%x", rsp->code);
5981
5982 goto done;
5983 }
5984
5985 /* Little Endian Swap */
5954 rsp->bb_credit = SWAP_LONG(rsp->bb_credit);
5955 rsp->frame_size = SWAP_LONG(rsp->frame_size);
5956 rsp->fw_version = SWAP_LONG(rsp->fw_version);
5957 rsp->reset_status = SWAP_LONG(rsp->reset_status);
5958 rsp->maint_status = SWAP_LONG(rsp->maint_status);
5959 rsp->fw_type = SWAP_LONG(rsp->fw_type);
5960 rsp->fru_data_valid = SWAP_LONG(rsp->fru_data_valid);
5986 rsp->bb_credit = BE_SWAP32(rsp->bb_credit);
5987 rsp->frame_size = BE_SWAP32(rsp->frame_size);
5988 rsp->fw_version = BE_SWAP32(rsp->fw_version);
5989 rsp->reset_status = BE_SWAP32(rsp->reset_status);
5990 rsp->maint_status = BE_SWAP32(rsp->maint_status);
5991 rsp->fw_type = BE_SWAP32(rsp->fw_type);
5992 rsp->fru_data_valid = BE_SWAP32(rsp->fru_data_valid);
5961
5962 /* Log the event */
5963 emlxs_log_fcoe_event(port, rsp);
5964
5965 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
5966 "MENLO_INIT: bb_credit = 0x%x", rsp->bb_credit);
5967 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
5968 "MENLO_INIT: frame_size = 0x%x", rsp->frame_size);

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

6096 offset++;
6097 bptr++;
6098 }
6099
6100 kmem_free(buffer, cnt);
6101
6102#ifdef FMA_SUPPORT
6103 /* Access handle validation */
5993
5994 /* Log the event */
5995 emlxs_log_fcoe_event(port, rsp);
5996
5997 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
5998 "MENLO_INIT: bb_credit = 0x%x", rsp->bb_credit);
5999 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
6000 "MENLO_INIT: frame_size = 0x%x", rsp->frame_size);

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

6128 offset++;
6129 bptr++;
6130 }
6131
6132 kmem_free(buffer, cnt);
6133
6134#ifdef FMA_SUPPORT
6135 /* Access handle validation */
6104 if (emlxs_fm_check_acc_handle(hba, hba->sbus_flash_acc_handle)
6136 if (emlxs_fm_check_acc_handle(hba, hba->sli.sli3.sbus_flash_acc_handle)
6105 != DDI_FM_OK) {
6106 EMLXS_MSGF(EMLXS_CONTEXT,
6107 &emlxs_invalid_access_handle_msg, NULL);
6108 return (DFC_DRV_ERROR);
6109 }
6110#endif /* FMA_SUPPORT */
6111
6112 return (0);

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

6191 kmem_free(buffer, outsz);
6192 return (DFC_COPYOUT_ERROR);
6193 }
6194
6195 kmem_free(buffer, outsz);
6196
6197#ifdef FMA_SUPPORT
6198 /* Access handle validation */
6137 != DDI_FM_OK) {
6138 EMLXS_MSGF(EMLXS_CONTEXT,
6139 &emlxs_invalid_access_handle_msg, NULL);
6140 return (DFC_DRV_ERROR);
6141 }
6142#endif /* FMA_SUPPORT */
6143
6144 return (0);

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

6223 kmem_free(buffer, outsz);
6224 return (DFC_COPYOUT_ERROR);
6225 }
6226
6227 kmem_free(buffer, outsz);
6228
6229#ifdef FMA_SUPPORT
6230 /* Access handle validation */
6199 if (emlxs_fm_check_acc_handle(hba, hba->sbus_flash_acc_handle)
6231 if (emlxs_fm_check_acc_handle(hba, hba->sli.sli3.sbus_flash_acc_handle)
6200 != DDI_FM_OK) {
6201 EMLXS_MSGF(EMLXS_CONTEXT,
6202 &emlxs_invalid_access_handle_msg, NULL);
6203 return (DFC_DRV_ERROR);
6204 }
6205#endif /* FMA_SUPPORT */
6206
6207 return (0);

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

6331 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
6332 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
6333 pkt->pkt_comp = NULL;
6334
6335 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
6336 pkt->pkt_timeout = (timeout) ? timeout : 30;
6337
6338 /* Build the fc header */
6232 != DDI_FM_OK) {
6233 EMLXS_MSGF(EMLXS_CONTEXT,
6234 &emlxs_invalid_access_handle_msg, NULL);
6235 return (DFC_DRV_ERROR);
6236 }
6237#endif /* FMA_SUPPORT */
6238
6239 return (0);

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

6363 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
6364 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
6365 pkt->pkt_comp = NULL;
6366
6367 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
6368 pkt->pkt_timeout = (timeout) ? timeout : 30;
6369
6370 /* Build the fc header */
6339 pkt->pkt_cmd_fhdr.d_id = SWAP_DATA24_LO(did);
6371 pkt->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(did);
6340 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_ELS_REQ;
6372 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_ELS_REQ;
6341 pkt->pkt_cmd_fhdr.s_id = SWAP_DATA24_LO(port->did);
6373 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(port->did);
6342 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
6343 pkt->pkt_cmd_fhdr.f_ctl =
6344 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
6345 pkt->pkt_cmd_fhdr.seq_id = 0;
6346 pkt->pkt_cmd_fhdr.df_ctl = 0;
6347 pkt->pkt_cmd_fhdr.seq_cnt = 0;
6348 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
6349 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;

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

6433 }
6434
6435 bzero(&ioinfo, sizeof (dfc_ioinfo_t));
6436
6437 ioinfo.a_mboxCmd = HBASTATS.MboxIssued;
6438 ioinfo.a_mboxCmpl = HBASTATS.MboxCompleted;
6439 ioinfo.a_mboxErr = HBASTATS.MboxError;
6440
6374 pkt->pkt_cmd_fhdr.type = FC_TYPE_EXTENDED_LS;
6375 pkt->pkt_cmd_fhdr.f_ctl =
6376 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
6377 pkt->pkt_cmd_fhdr.seq_id = 0;
6378 pkt->pkt_cmd_fhdr.df_ctl = 0;
6379 pkt->pkt_cmd_fhdr.seq_cnt = 0;
6380 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
6381 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;

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

6465 }
6466
6467 bzero(&ioinfo, sizeof (dfc_ioinfo_t));
6468
6469 ioinfo.a_mboxCmd = HBASTATS.MboxIssued;
6470 ioinfo.a_mboxCmpl = HBASTATS.MboxCompleted;
6471 ioinfo.a_mboxErr = HBASTATS.MboxError;
6472
6441 for (i = 0; i < MAX_RINGS; i++) {
6473 for (i = 0; i < hba->chan_count; i++) {
6442 ioinfo.a_iocbCmd += HBASTATS.IocbIssued[i];
6443 ioinfo.a_iocbRsp += HBASTATS.IocbReceived[i];
6444 }
6445
6446 ioinfo.a_adapterIntr = HBASTATS.IntrEvent[0] + HBASTATS.IntrEvent[1] +
6447 HBASTATS.IntrEvent[2] + HBASTATS.IntrEvent[3] +
6448 HBASTATS.IntrEvent[4] + HBASTATS.IntrEvent[5] +
6449 HBASTATS.IntrEvent[6] + HBASTATS.IntrEvent[7];

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

6521 }
6522#ifdef MENLO_SUPPORT
6523 else if (hba->flag & FC_MENLO_MODE) {
6524 linkinfo.a_linkState = LNK_DOWN;
6525 linkinfo.a_topology = LNK_MENLO_MAINTENANCE;
6526
6527 }
6528#endif /* MENLO_SUPPORT */
6474 ioinfo.a_iocbCmd += HBASTATS.IocbIssued[i];
6475 ioinfo.a_iocbRsp += HBASTATS.IocbReceived[i];
6476 }
6477
6478 ioinfo.a_adapterIntr = HBASTATS.IntrEvent[0] + HBASTATS.IntrEvent[1] +
6479 HBASTATS.IntrEvent[2] + HBASTATS.IntrEvent[3] +
6480 HBASTATS.IntrEvent[4] + HBASTATS.IntrEvent[5] +
6481 HBASTATS.IntrEvent[6] + HBASTATS.IntrEvent[7];

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

6553 }
6554#ifdef MENLO_SUPPORT
6555 else if (hba->flag & FC_MENLO_MODE) {
6556 linkinfo.a_linkState = LNK_DOWN;
6557 linkinfo.a_topology = LNK_MENLO_MAINTENANCE;
6558
6559 }
6560#endif /* MENLO_SUPPORT */
6529 else if (hba->state < FC_READY) {
6561 else if (hba->state == FC_LINK_DOWN_PERSIST) {
6562 linkinfo.a_linkState = LNK_DOWN_PERSIST;
6563 } else if (hba->state < FC_READY) {
6530 linkinfo.a_linkState = LNK_DISCOVERY;
6531 } else {
6532 linkinfo.a_linkState = LNK_READY;
6533 }
6534
6535 if (linkinfo.a_linkState != LNK_DOWN) {
6536 if (hba->topology == TOPOLOGY_LOOP) {
6537 if (hba->flag & FC_FABRIC_ATTACHED) {

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

6543 linkinfo.a_alpa = port->did & 0xff;
6544 linkinfo.a_alpaCnt = port->alpa_map[0];
6545
6546 if (linkinfo.a_alpaCnt > 127) {
6547 linkinfo.a_alpaCnt = 127;
6548 }
6549
6550 bcopy((void *)&port->alpa_map[0], linkinfo.a_alpaMap,
6564 linkinfo.a_linkState = LNK_DISCOVERY;
6565 } else {
6566 linkinfo.a_linkState = LNK_READY;
6567 }
6568
6569 if (linkinfo.a_linkState != LNK_DOWN) {
6570 if (hba->topology == TOPOLOGY_LOOP) {
6571 if (hba->flag & FC_FABRIC_ATTACHED) {

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

6577 linkinfo.a_alpa = port->did & 0xff;
6578 linkinfo.a_alpaCnt = port->alpa_map[0];
6579
6580 if (linkinfo.a_alpaCnt > 127) {
6581 linkinfo.a_alpaCnt = 127;
6582 }
6583
6584 bcopy((void *)&port->alpa_map[0], linkinfo.a_alpaMap,
6551 linkinfo.a_alpaCnt + 1);
6585 linkinfo.a_alpaCnt+1);
6552 } else {
6553 if (hba->flag & FC_FABRIC_ATTACHED) {
6554 linkinfo.a_topology = LNK_FABRIC;
6555 } else {
6556 linkinfo.a_topology = LNK_PT2PT;
6557 }
6558 }
6559 }

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

6856 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
6857 "%s: Unable to allocate buffer.",
6858 emlxs_dfc_xlate(dfc->cmd));
6859
6860 return (DFC_SYSRES_ERROR);
6861 }
6862
6863 if (hba->flag & FC_SLIM2_MODE) {
6586 } else {
6587 if (hba->flag & FC_FABRIC_ATTACHED) {
6588 linkinfo.a_topology = LNK_FABRIC;
6589 } else {
6590 linkinfo.a_topology = LNK_PT2PT;
6591 }
6592 }
6593 }

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

6890 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
6891 "%s: Unable to allocate buffer.",
6892 emlxs_dfc_xlate(dfc->cmd));
6893
6894 return (DFC_SYSRES_ERROR);
6895 }
6896
6897 if (hba->flag & FC_SLIM2_MODE) {
6864 slim = (uint8_t *)hba->slim2.virt + offset;
6865 emlxs_pcimem_bcopy((uint32_t *)slim, (uint32_t *)buffer,
6866 size);
6898 slim = (uint8_t *)hba->sli.sli3.slim2.virt + offset;
6899 BE_SWAP32_BCOPY((uint8_t *)slim, (uint8_t *)buffer, size);
6867 } else {
6900 } else {
6868 slim = (uint8_t *)hba->slim_addr + offset;
6901 slim = (uint8_t *)hba->sli.sli3.slim_addr + offset;
6869 READ_SLIM_COPY(hba, (uint32_t *)buffer, (uint32_t *)slim,
6870 (size / 4));
6871 }
6872
6873 if (ddi_copyout((void *)buffer, (void *)dfc->buf1, size, mode) != 0) {
6874 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
6875 "%s: ddi_copyout failed.", emlxs_dfc_xlate(dfc->cmd));
6876
6877 kmem_free(buffer, size);
6878 return (DFC_COPYOUT_ERROR);
6879 }
6880
6881 kmem_free(buffer, size);
6882
6883#ifdef FMA_SUPPORT
6902 READ_SLIM_COPY(hba, (uint32_t *)buffer, (uint32_t *)slim,
6903 (size / 4));
6904 }
6905
6906 if (ddi_copyout((void *)buffer, (void *)dfc->buf1, size, mode) != 0) {
6907 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
6908 "%s: ddi_copyout failed.", emlxs_dfc_xlate(dfc->cmd));
6909
6910 kmem_free(buffer, size);
6911 return (DFC_COPYOUT_ERROR);
6912 }
6913
6914 kmem_free(buffer, size);
6915
6916#ifdef FMA_SUPPORT
6884 if (!(hba->flag & FC_SLIM2_MODE)) {
6885 /* Access handle validation */
6886 if (emlxs_fm_check_acc_handle(hba, hba->slim_acc_handle)
6887 != DDI_FM_OK) {
6888 EMLXS_MSGF(EMLXS_CONTEXT,
6889 &emlxs_invalid_access_handle_msg, NULL);
6890 return (DFC_DRV_ERROR);
6891 }
6917 /* Access handle validation */
6918 if (emlxs_fm_check_acc_handle(hba, hba->sli.sli3.slim_acc_handle)
6919 != DDI_FM_OK) {
6920 EMLXS_MSGF(EMLXS_CONTEXT,
6921 &emlxs_invalid_access_handle_msg, NULL);
6922 return (DFC_DRV_ERROR);
6892 }
6893#endif /* FMA_SUPPORT */
6894
6895 return (0);
6896
6897} /* emlxs_dfc_read_mem() */
6898
6899

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

6967 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
6968 "%s: ddi_copyin failed.", emlxs_dfc_xlate(dfc->cmd));
6969
6970 kmem_free(buffer, size);
6971 return (DFC_COPYIN_ERROR);
6972 }
6973
6974 if (hba->flag & FC_SLIM2_MODE) {
6923 }
6924#endif /* FMA_SUPPORT */
6925
6926 return (0);
6927
6928} /* emlxs_dfc_read_mem() */
6929
6930

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

6998 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
6999 "%s: ddi_copyin failed.", emlxs_dfc_xlate(dfc->cmd));
7000
7001 kmem_free(buffer, size);
7002 return (DFC_COPYIN_ERROR);
7003 }
7004
7005 if (hba->flag & FC_SLIM2_MODE) {
6975 slim = (uint8_t *)hba->slim2.virt + offset;
6976 emlxs_pcimem_bcopy((uint32_t *)buffer, (uint32_t *)slim,
6977 size);
7006 slim = (uint8_t *)hba->sli.sli3.slim2.virt + offset;
7007 BE_SWAP32_BCOPY((uint8_t *)buffer, (uint8_t *)slim, size);
6978 } else {
7008 } else {
6979 slim = (uint8_t *)hba->slim_addr + offset;
7009 slim = (uint8_t *)hba->sli.sli3.slim_addr + offset;
6980 WRITE_SLIM_COPY(hba, (uint32_t *)buffer, (uint32_t *)slim,
6981 (size / 4));
6982 }
6983
6984 kmem_free(buffer, size);
6985
6986#ifdef FMA_SUPPORT
7010 WRITE_SLIM_COPY(hba, (uint32_t *)buffer, (uint32_t *)slim,
7011 (size / 4));
7012 }
7013
7014 kmem_free(buffer, size);
7015
7016#ifdef FMA_SUPPORT
6987 if (!(hba->flag & FC_SLIM2_MODE)) {
6988 /* Access handle validation */
6989 if (emlxs_fm_check_acc_handle(hba, hba->slim_acc_handle)
6990 != DDI_FM_OK) {
6991 EMLXS_MSGF(EMLXS_CONTEXT,
6992 &emlxs_invalid_access_handle_msg, NULL);
6993 return (DFC_DRV_ERROR);
6994 }
7017 /* Access handle validation */
7018 if (emlxs_fm_check_acc_handle(hba, hba->sli.sli3.slim_acc_handle)
7019 != DDI_FM_OK) {
7020 EMLXS_MSGF(EMLXS_CONTEXT,
7021 &emlxs_invalid_access_handle_msg, NULL);
7022 return (DFC_DRV_ERROR);
6995 }
6996#endif /* FMA_SUPPORT */
6997
6998 return (0);
6999
7000} /* emlxs_dfc_write_mem() */
7001
7002
7003/* ARGSUSED */
7004static int32_t
7005emlxs_dfc_write_ctlreg(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
7006{
7007 emlxs_port_t *port = &PPORT;
7008 uint32_t offset;
7009 uint32_t value;
7010
7011 offset = dfc->data1;
7012 value = dfc->data2;
7013
7023 }
7024#endif /* FMA_SUPPORT */
7025
7026 return (0);
7027
7028} /* emlxs_dfc_write_mem() */
7029
7030
7031/* ARGSUSED */
7032static int32_t
7033emlxs_dfc_write_ctlreg(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
7034{
7035 emlxs_port_t *port = &PPORT;
7036 uint32_t offset;
7037 uint32_t value;
7038
7039 offset = dfc->data1;
7040 value = dfc->data2;
7041
7042 if (hba->model_info.flags & EMLXS_FCOE_SUPPORTED) {
7043 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7044 "%s: FCoE not supported.", emlxs_dfc_xlate(dfc->cmd));
7045
7046 return (DFC_FCOE_NOTSUPPORTED);
7047 }
7048
7014 if (!(hba->flag & FC_OFFLINE_MODE)) {
7015 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7016 "%s: Adapter not offline.", emlxs_dfc_xlate(dfc->cmd));
7017
7018 return (DFC_ONLINE_ERROR);
7019 }
7020
7021 if (offset % 4) {

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

7029 if (offset > 255) {
7030 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7031 "%s: Offset too large. (offset=%d)",
7032 emlxs_dfc_xlate(dfc->cmd), offset);
7033
7034 return (DFC_ARG_TOOBIG);
7035 }
7036
7049 if (!(hba->flag & FC_OFFLINE_MODE)) {
7050 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7051 "%s: Adapter not offline.", emlxs_dfc_xlate(dfc->cmd));
7052
7053 return (DFC_ONLINE_ERROR);
7054 }
7055
7056 if (offset % 4) {

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

7064 if (offset > 255) {
7065 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7066 "%s: Offset too large. (offset=%d)",
7067 emlxs_dfc_xlate(dfc->cmd), offset);
7068
7069 return (DFC_ARG_TOOBIG);
7070 }
7071
7037 WRITE_CSR_REG(hba, (hba->csr_addr + offset), value);
7072 WRITE_CSR_REG(hba, (hba->sli.sli3.csr_addr + offset), value);
7038
7039#ifdef FMA_SUPPORT
7040 /* Access handle validation */
7073
7074#ifdef FMA_SUPPORT
7075 /* Access handle validation */
7041 if (emlxs_fm_check_acc_handle(hba, hba->csr_acc_handle)
7076 if (emlxs_fm_check_acc_handle(hba, hba->sli.sli3.csr_acc_handle)
7042 != DDI_FM_OK) {
7043 EMLXS_MSGF(EMLXS_CONTEXT,
7044 &emlxs_invalid_access_handle_msg, NULL);
7045 return (DFC_DRV_ERROR);
7046 }
7047#endif /* FMA_SUPPORT */
7048
7049 return (0);

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

7055emlxs_dfc_read_ctlreg(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
7056{
7057 emlxs_port_t *port = &PPORT;
7058 uint32_t offset;
7059 uint32_t value;
7060
7061 offset = dfc->data1;
7062
7077 != DDI_FM_OK) {
7078 EMLXS_MSGF(EMLXS_CONTEXT,
7079 &emlxs_invalid_access_handle_msg, NULL);
7080 return (DFC_DRV_ERROR);
7081 }
7082#endif /* FMA_SUPPORT */
7083
7084 return (0);

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

7090emlxs_dfc_read_ctlreg(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
7091{
7092 emlxs_port_t *port = &PPORT;
7093 uint32_t offset;
7094 uint32_t value;
7095
7096 offset = dfc->data1;
7097
7098 if (hba->model_info.flags & EMLXS_FCOE_SUPPORTED) {
7099 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7100 "%s: FCoE not supported.", emlxs_dfc_xlate(dfc->cmd));
7101
7102 return (DFC_FCOE_NOTSUPPORTED);
7103 }
7104
7063 if (offset % 4) {
7064 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7065 "%s: Offset misaligned. (offset=%d)",
7066 emlxs_dfc_xlate(dfc->cmd), offset);
7067
7068 return (DFC_ARG_MISALIGNED);
7069 }
7070

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

7086 if (dfc->buf1_size < sizeof (uint32_t)) {
7087 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7088 "%s: Buffer1 too small. (size=%d)",
7089 emlxs_dfc_xlate(dfc->cmd), dfc->buf1_size);
7090
7091 return (DFC_ARG_TOOSMALL);
7092 }
7093
7105 if (offset % 4) {
7106 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7107 "%s: Offset misaligned. (offset=%d)",
7108 emlxs_dfc_xlate(dfc->cmd), offset);
7109
7110 return (DFC_ARG_MISALIGNED);
7111 }
7112

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

7128 if (dfc->buf1_size < sizeof (uint32_t)) {
7129 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7130 "%s: Buffer1 too small. (size=%d)",
7131 emlxs_dfc_xlate(dfc->cmd), dfc->buf1_size);
7132
7133 return (DFC_ARG_TOOSMALL);
7134 }
7135
7094 value = READ_CSR_REG(hba, (hba->csr_addr + offset));
7136 value = READ_CSR_REG(hba, (hba->sli.sli3.csr_addr + offset));
7095
7096 if (ddi_copyout((void *)&value, (void *)dfc->buf1, sizeof (uint32_t),
7097 mode) != 0) {
7098 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7099 "%s: ddi_copyout failed.", emlxs_dfc_xlate(dfc->cmd));
7100
7101 return (DFC_COPYOUT_ERROR);
7102 }
7103
7104#ifdef FMA_SUPPORT
7105 /* Access handle validation */
7137
7138 if (ddi_copyout((void *)&value, (void *)dfc->buf1, sizeof (uint32_t),
7139 mode) != 0) {
7140 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7141 "%s: ddi_copyout failed.", emlxs_dfc_xlate(dfc->cmd));
7142
7143 return (DFC_COPYOUT_ERROR);
7144 }
7145
7146#ifdef FMA_SUPPORT
7147 /* Access handle validation */
7106 if (emlxs_fm_check_acc_handle(hba, hba->csr_acc_handle)
7148 if (emlxs_fm_check_acc_handle(hba, hba->sli.sli3.csr_acc_handle)
7107 != DDI_FM_OK) {
7108 EMLXS_MSGF(EMLXS_CONTEXT,
7109 &emlxs_invalid_access_handle_msg, NULL);
7110 return (DFC_DRV_ERROR);
7111 }
7112#endif /* FMA_SUPPORT */
7113
7114 return (0);

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

7220 }
7221
7222 /*
7223 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_debug_msg,
7224 * "%s: %s. Enabled. pid=%d id=%d", emlxs_dfc_xlate(dfc->cmd),
7225 * emlxs_dfc_event_xlate(event), pid, dfc_event->last_id);
7226 */
7227
7149 != DDI_FM_OK) {
7150 EMLXS_MSGF(EMLXS_CONTEXT,
7151 &emlxs_invalid_access_handle_msg, NULL);
7152 return (DFC_DRV_ERROR);
7153 }
7154#endif /* FMA_SUPPORT */
7155
7156 return (0);

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

7262 }
7263
7264 /*
7265 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_debug_msg,
7266 * "%s: %s. Enabled. pid=%d id=%d", emlxs_dfc_xlate(dfc->cmd),
7267 * emlxs_dfc_event_xlate(event), pid, dfc_event->last_id);
7268 */
7269
7228 hba->log_events |= event;
7270 hba->event_mask |= event;
7271
7229 } else { /* Disable */
7230
7231 /* Find the event entry */
7232 dfc_event = NULL;
7233 for (i = 0; i < MAX_DFC_EVENTS; i++) {
7234 dfc_event = &hba->dfc_event[i];
7235
7236 if (dfc_event->pid == pid &&

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

7259 if (dfc_event->event == event) {
7260 count++;
7261 }
7262 }
7263
7264 /* If no more pids need this event, */
7265 /* then disable logging for this event */
7266 if (count == 0) {
7272 } else { /* Disable */
7273
7274 /* Find the event entry */
7275 dfc_event = NULL;
7276 for (i = 0; i < MAX_DFC_EVENTS; i++) {
7277 dfc_event = &hba->dfc_event[i];
7278
7279 if (dfc_event->pid == pid &&

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

7302 if (dfc_event->event == event) {
7303 count++;
7304 }
7305 }
7306
7307 /* If no more pids need this event, */
7308 /* then disable logging for this event */
7309 if (count == 0) {
7267 hba->log_events &= ~event;
7310 hba->event_mask &= ~event;
7268 }
7269 }
7270
7271 return (0);
7272
7273} /* emlxs_dfc_set_event() */
7274
7275

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

7329
7330 return (DFC_ARG_TOOSMALL);
7331 }
7332
7333 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg, "%s called. max=%d",
7334 emlxs_dfc_xlate(dfc->cmd), event_count);
7335
7336 size = (event_count * sizeof (HBA_EVENTINFO));
7311 }
7312 }
7313
7314 return (0);
7315
7316} /* emlxs_dfc_set_event() */
7317
7318

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

7372
7373 return (DFC_ARG_TOOSMALL);
7374 }
7375
7376 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg, "%s called. max=%d",
7377 emlxs_dfc_xlate(dfc->cmd), event_count);
7378
7379 size = (event_count * sizeof (HBA_EVENTINFO));
7337 if (!(event_buffer = (HBA_EVENTINFO *)kmem_zalloc(size, KM_SLEEP))) {
7338 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7339 "%s: Unable to allocate buffer. size=%d",
7340 emlxs_dfc_xlate(dfc->cmd), size);
7380 event_buffer = (HBA_EVENTINFO *)kmem_zalloc(size, KM_SLEEP);
7341
7381
7342 return (DFC_SYSRES_ERROR);
7343 }
7344
7345 if (emlxs_get_dfc_eventinfo(port, event_buffer, &event_count,
7346 &missed) != 0) {
7347 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7348 "%s: emlxs_get_dfc_eventinfo failed.",
7349 emlxs_dfc_xlate(dfc->cmd));
7350
7351 rval = DFC_DRV_ERROR;
7352 goto done;

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

7449 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7450 "%s: %s. Event not registered. pid=%d",
7451 emlxs_dfc_xlate(dfc->cmd), emlxs_dfc_event_xlate(event),
7452 pid);
7453
7454 return (DFC_ARG_INVALID);
7455 }
7456
7382 if (emlxs_get_dfc_eventinfo(port, event_buffer, &event_count,
7383 &missed) != 0) {
7384 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7385 "%s: emlxs_get_dfc_eventinfo failed.",
7386 emlxs_dfc_xlate(dfc->cmd));
7387
7388 rval = DFC_DRV_ERROR;
7389 goto done;

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

7486 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7487 "%s: %s. Event not registered. pid=%d",
7488 emlxs_dfc_xlate(dfc->cmd), emlxs_dfc_event_xlate(event),
7489 pid);
7490
7491 return (DFC_ARG_INVALID);
7492 }
7493
7457 if (!(hba->log_events & dfc_event->event)) {
7494 if (!(hba->event_mask & dfc_event->event)) {
7458 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7459 "%s: %s. Event not registered. pid=%d",
7460 emlxs_dfc_xlate(dfc->cmd), emlxs_dfc_event_xlate(event),
7461 pid);
7462
7463 return (DFC_ARG_INVALID);
7464 }
7465

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

7526 if (!buffer || !(*psize)) {
7527 size_only = 1;
7528 size = 0xffffffff;
7529 } else {
7530 size_only = 0;
7531 size = *psize;
7532 }
7533
7495 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7496 "%s: %s. Event not registered. pid=%d",
7497 emlxs_dfc_xlate(dfc->cmd), emlxs_dfc_event_xlate(event),
7498 pid);
7499
7500 return (DFC_ARG_INVALID);
7501 }
7502

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

7563 if (!buffer || !(*psize)) {
7564 size_only = 1;
7565 size = 0xffffffff;
7566 } else {
7567 size_only = 0;
7568 size = *psize;
7569 }
7570
7571 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
7572 if (region != 7) {
7573 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7574 "emlxs_get_dump_region: Invalid sli4 region. "
7575 "(id=%d)", region);
7576
7577 rval = DFC_ARG_INVALID;
7578 goto done;
7579 }
7580 }
7581
7534 switch (region) {
7535 case 0: /* SLI Registers */
7536
7537 if (size < (4 * sizeof (uint32_t))) {
7538 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7539 "emlxs_get_dump_region: Buffer too small. "
7540 "(SLI Registers: size=%d)", size);
7541
7542 rval = DFC_ARG_TOOSMALL;
7543 goto done;
7544 }
7545
7546 size = (4 * sizeof (uint32_t));
7547
7548 if (size_only) {
7549 break;
7550 }
7551
7552 wptr = (uint32_t *)buffer;
7582 switch (region) {
7583 case 0: /* SLI Registers */
7584
7585 if (size < (4 * sizeof (uint32_t))) {
7586 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7587 "emlxs_get_dump_region: Buffer too small. "
7588 "(SLI Registers: size=%d)", size);
7589
7590 rval = DFC_ARG_TOOSMALL;
7591 goto done;
7592 }
7593
7594 size = (4 * sizeof (uint32_t));
7595
7596 if (size_only) {
7597 break;
7598 }
7599
7600 wptr = (uint32_t *)buffer;
7553 wptr[0] = READ_CSR_REG(hba, FC_HA_REG(hba, hba->csr_addr));
7554 wptr[1] = READ_CSR_REG(hba, FC_CA_REG(hba, hba->csr_addr));
7555 wptr[2] = READ_CSR_REG(hba, FC_HS_REG(hba, hba->csr_addr));
7556 wptr[3] = READ_CSR_REG(hba, FC_HC_REG(hba, hba->csr_addr));
7601 wptr[0] = READ_CSR_REG(hba, FC_HA_REG(hba));
7602 wptr[1] = READ_CSR_REG(hba, FC_CA_REG(hba));
7603 wptr[2] = READ_CSR_REG(hba, FC_HS_REG(hba));
7604 wptr[3] = READ_CSR_REG(hba, FC_HC_REG(hba));
7557
7558#ifdef FMA_SUPPORT
7559 /* Access handle validation */
7605
7606#ifdef FMA_SUPPORT
7607 /* Access handle validation */
7560 if (emlxs_fm_check_acc_handle(hba, hba->csr_acc_handle)
7608 if (emlxs_fm_check_acc_handle(hba, hba->sli.sli3.csr_acc_handle)
7561 != DDI_FM_OK) {
7562 EMLXS_MSGF(EMLXS_CONTEXT,
7563 &emlxs_invalid_access_handle_msg, NULL);
7564 rval = DFC_DRV_ERROR;
7565 }
7566#endif /* FMA_SUPPORT */
7567
7568 break;

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

7575 size = MIN(4096, size);
7576 }
7577
7578 if (size_only) {
7579 break;
7580 }
7581
7582 if (hba->flag & FC_SLIM2_MODE) {
7609 != DDI_FM_OK) {
7610 EMLXS_MSGF(EMLXS_CONTEXT,
7611 &emlxs_invalid_access_handle_msg, NULL);
7612 rval = DFC_DRV_ERROR;
7613 }
7614#endif /* FMA_SUPPORT */
7615
7616 break;

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

7623 size = MIN(4096, size);
7624 }
7625
7626 if (size_only) {
7627 break;
7628 }
7629
7630 if (hba->flag & FC_SLIM2_MODE) {
7583 memptr = (uint8_t *)hba->slim2.virt;
7584 emlxs_pcimem_bcopy((uint32_t *)memptr,
7585 (uint32_t *)buffer, size);
7631 memptr = (uint8_t *)hba->sli.sli3.slim2.virt;
7632 BE_SWAP32_BCOPY((uint8_t *)memptr, (uint8_t *)buffer,
7633 size);
7586 } else {
7634 } else {
7587 memptr = (uint8_t *)hba->slim_addr;
7635 memptr = (uint8_t *)hba->sli.sli3.slim_addr;
7588 READ_SLIM_COPY(hba, (uint32_t *)buffer,
7589 (uint32_t *)memptr, (size / 4));
7590#ifdef FMA_SUPPORT
7591 /* Access handle validation */
7636 READ_SLIM_COPY(hba, (uint32_t *)buffer,
7637 (uint32_t *)memptr, (size / 4));
7638#ifdef FMA_SUPPORT
7639 /* Access handle validation */
7592 if (emlxs_fm_check_acc_handle(hba, hba->slim_acc_handle)
7593 != DDI_FM_OK) {
7640 if (emlxs_fm_check_acc_handle(hba,
7641 hba->sli.sli3.slim_acc_handle) != DDI_FM_OK) {
7594 EMLXS_MSGF(EMLXS_CONTEXT,
7595 &emlxs_invalid_access_handle_msg, NULL);
7596 rval = DFC_DRV_ERROR;
7597 }
7598#endif /* FMA_SUPPORT */
7599 }
7600
7601 break;

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

7612 }
7613
7614 size = sizeof (PCB);
7615
7616 if (size_only) {
7617 break;
7618 }
7619
7642 EMLXS_MSGF(EMLXS_CONTEXT,
7643 &emlxs_invalid_access_handle_msg, NULL);
7644 rval = DFC_DRV_ERROR;
7645 }
7646#endif /* FMA_SUPPORT */
7647 }
7648
7649 break;

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

7660 }
7661
7662 size = sizeof (PCB);
7663
7664 if (size_only) {
7665 break;
7666 }
7667
7620 memptr = (uint8_t *)&(((SLIM2 *)hba->slim2.virt)->pcb);
7621 emlxs_pcimem_bcopy((uint32_t *)memptr, (uint32_t *)buffer,
7622 size);
7623
7668 memptr = (uint8_t *)&(((SLIM2 *)hba->sli.sli3.slim2.virt)->pcb);
7669 BE_SWAP32_BCOPY((uint8_t *)memptr, (uint8_t *)buffer, size);
7624 break;
7625
7626 case 3: /* MailBox */
7627
7628 if (size < MAILBOX_CMD_BSIZE) {
7629 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7630 "emlxs_get_dump_region: Buffer too small. "
7631 "(Mailbox: size=%d)", size);

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

7636
7637 size = MAILBOX_CMD_BSIZE;
7638
7639 if (size_only) {
7640 break;
7641 }
7642
7643 if (hba->flag & FC_SLIM2_MODE) {
7670 break;
7671
7672 case 3: /* MailBox */
7673
7674 if (size < MAILBOX_CMD_BSIZE) {
7675 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7676 "emlxs_get_dump_region: Buffer too small. "
7677 "(Mailbox: size=%d)", size);

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

7682
7683 size = MAILBOX_CMD_BSIZE;
7684
7685 if (size_only) {
7686 break;
7687 }
7688
7689 if (hba->flag & FC_SLIM2_MODE) {
7644 memptr = (uint8_t *)hba->slim2.virt;
7645 emlxs_pcimem_bcopy((uint32_t *)memptr,
7646 (uint32_t *)buffer, size);
7690 memptr = (uint8_t *)hba->sli.sli3.slim2.virt;
7691 BE_SWAP32_BCOPY((uint8_t *)memptr, (uint8_t *)buffer,
7692 size);
7647 } else {
7693 } else {
7648 memptr = (uint8_t *)hba->slim_addr;
7694 memptr = (uint8_t *)hba->sli.sli3.slim_addr;
7649 READ_SLIM_COPY(hba, (uint32_t *)buffer,
7650 (uint32_t *)memptr, (size / 4));
7651#ifdef FMA_SUPPORT
7652 /* Access handle validation */
7695 READ_SLIM_COPY(hba, (uint32_t *)buffer,
7696 (uint32_t *)memptr, (size / 4));
7697#ifdef FMA_SUPPORT
7698 /* Access handle validation */
7653 if (emlxs_fm_check_acc_handle(hba, hba->slim_acc_handle)
7654 != DDI_FM_OK) {
7699 if (emlxs_fm_check_acc_handle(hba,
7700 hba->sli.sli3.slim_acc_handle) != DDI_FM_OK) {
7655 EMLXS_MSGF(EMLXS_CONTEXT,
7656 &emlxs_invalid_access_handle_msg, NULL);
7657 rval = DFC_DRV_ERROR;
7658 }
7659#endif /* FMA_SUPPORT */
7660 }
7661
7662 break;

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

7674
7675 size = MAX_RINGS * sizeof (HGP);
7676
7677 if (size_only) {
7678 break;
7679 }
7680
7681 {
7701 EMLXS_MSGF(EMLXS_CONTEXT,
7702 &emlxs_invalid_access_handle_msg, NULL);
7703 rval = DFC_DRV_ERROR;
7704 }
7705#endif /* FMA_SUPPORT */
7706 }
7707
7708 break;

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

7720
7721 size = MAX_RINGS * sizeof (HGP);
7722
7723 if (size_only) {
7724 break;
7725 }
7726
7727 {
7682 memptr =
7683 (uint8_t *)hba->slim_addr + hba->hgp_ring_offset;
7728 memptr = (uint8_t *)hba->sli.sli3.slim_addr +
7729 hba->sli.sli3.hgp_ring_offset;
7730
7684 READ_SLIM_COPY(hba, (uint32_t *)buffer,
7685 (uint32_t *)memptr, (size / 4));
7686#ifdef FMA_SUPPORT
7687 /* Access handle validation */
7731 READ_SLIM_COPY(hba, (uint32_t *)buffer,
7732 (uint32_t *)memptr, (size / 4));
7733#ifdef FMA_SUPPORT
7734 /* Access handle validation */
7688 if (emlxs_fm_check_acc_handle(hba, hba->slim_acc_handle)
7689 != DDI_FM_OK) {
7735 if (emlxs_fm_check_acc_handle(hba,
7736 hba->sli.sli3.slim_acc_handle) != DDI_FM_OK) {
7690 EMLXS_MSGF(EMLXS_CONTEXT,
7691 &emlxs_invalid_access_handle_msg, NULL);
7692 rval = DFC_DRV_ERROR;
7693 }
7694#endif /* FMA_SUPPORT */
7695 }
7696
7697 break;

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

7708 }
7709
7710 size = MAX_RINGS * sizeof (PGP);
7711
7712 if (size_only) {
7713 break;
7714 }
7715
7737 EMLXS_MSGF(EMLXS_CONTEXT,
7738 &emlxs_invalid_access_handle_msg, NULL);
7739 rval = DFC_DRV_ERROR;
7740 }
7741#endif /* FMA_SUPPORT */
7742 }
7743
7744 break;

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

7755 }
7756
7757 size = MAX_RINGS * sizeof (PGP);
7758
7759 if (size_only) {
7760 break;
7761 }
7762
7716 memptr =
7717 (uint8_t *)((SLIM2 *)hba->slim2.virt)->mbx.us.s2.port;
7718 emlxs_pcimem_bcopy((uint32_t *)memptr, (uint32_t *)buffer,
7719 size);
7720
7763 memptr = (uint8_t *)
7764 ((SLIM2 *)hba->sli.sli3.slim2.virt)->mbx.us.s2.port;
7765 BE_SWAP32_BCOPY((uint8_t *)memptr, (uint8_t *)buffer, size);
7721 break;
7722
7723 case 6: /* Command/Response Ring */
7724
7725 if (size < SLI_IOCB_MAX_SIZE) {
7726 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7727 "emlxs_get_dump_region: Buffer too small. "
7728 "(Rings: size=%d)", size);
7729
7730 rval = DFC_ARG_TOOSMALL;
7731 goto done;
7732 }
7733
7734 size = SLI_IOCB_MAX_SIZE;
7735
7736 if (size_only) {
7737 break;
7738 }
7739
7766 break;
7767
7768 case 6: /* Command/Response Ring */
7769
7770 if (size < SLI_IOCB_MAX_SIZE) {
7771 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7772 "emlxs_get_dump_region: Buffer too small. "
7773 "(Rings: size=%d)", size);
7774
7775 rval = DFC_ARG_TOOSMALL;
7776 goto done;
7777 }
7778
7779 size = SLI_IOCB_MAX_SIZE;
7780
7781 if (size_only) {
7782 break;
7783 }
7784
7740 memptr = (uint8_t *)((SLIM2 *)hba->slim2.virt)->IOCBs;
7741 emlxs_pcimem_bcopy((uint32_t *)memptr, (uint32_t *)buffer,
7742 size);
7743
7785 memptr = (uint8_t *)((SLIM2 *)hba->sli.sli3.slim2.virt)->IOCBs;
7786 BE_SWAP32_BCOPY((uint8_t *)memptr, (uint8_t *)buffer, size);
7744 break;
7745
7746 case 7: /* All driver specific structures */
7747
7748 if (size < sizeof (emlxs_hba_t)) {
7749 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7750 "emlxs_get_dump_region: Buffer too small. "
7751 "(Driver: size=%d)", size);

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

7827 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7828 "%s: Buffer1 too small. (size: %d < %d)",
7829 emlxs_dfc_xlate(dfc->cmd), dfc->buf1_size, size);
7830
7831 rval = DFC_ARG_TOOSMALL;
7832 goto done;
7833 }
7834
7787 break;
7788
7789 case 7: /* All driver specific structures */
7790
7791 if (size < sizeof (emlxs_hba_t)) {
7792 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7793 "emlxs_get_dump_region: Buffer too small. "
7794 "(Driver: size=%d)", size);

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

7870 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7871 "%s: Buffer1 too small. (size: %d < %d)",
7872 emlxs_dfc_xlate(dfc->cmd), dfc->buf1_size, size);
7873
7874 rval = DFC_ARG_TOOSMALL;
7875 goto done;
7876 }
7877
7835 if (!(buffer = (uint8_t *)kmem_zalloc(size, KM_SLEEP))) {
7836 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7837 "%s: Unable to allocate buffer. size=%d",
7838 emlxs_dfc_xlate(dfc->cmd), size);
7878 buffer = (uint8_t *)kmem_zalloc(size, KM_SLEEP);
7839
7879
7840 rval = DFC_SYSRES_ERROR;
7841 goto done;
7842 }
7843
7844 /* Get the region data */
7845 rval = emlxs_get_dump_region(hba, dfc->data1, buffer, &size);
7846
7847 if (rval != 0) {
7848 goto done;
7849 }
7850
7851 /* Return the region data */

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

7904 MAILBOX *mb = NULL;
7905 fc_packet_t *pkt = NULL;
7906 uint32_t mbxstatus;
7907 uint32_t i;
7908 uint32_t offset;
7909 uint32_t rval = 0;
7910 menlo_cmd_t *cmd;
7911
7880 /* Get the region data */
7881 rval = emlxs_get_dump_region(hba, dfc->data1, buffer, &size);
7882
7883 if (rval != 0) {
7884 goto done;
7885 }
7886
7887 /* Return the region data */

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

7940 MAILBOX *mb = NULL;
7941 fc_packet_t *pkt = NULL;
7942 uint32_t mbxstatus;
7943 uint32_t i;
7944 uint32_t offset;
7945 uint32_t rval = 0;
7946 menlo_cmd_t *cmd;
7947
7912 if ((mbq = (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ),
7913 KM_SLEEP)) == 0) {
7914 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7915 "%s: Unable to allocate mailbox buffer.",
7916 emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE));
7948 mbq = (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ),
7949 KM_SLEEP);
7917
7950
7918 rval = DFC_SYSRES_ERROR;
7919 goto done;
7920 }
7921
7922 mb = (MAILBOX *)mbq;
7923
7924 /* SET MENLO maint mode */
7925 /* Create the set_variable mailbox request */
7951 mb = (MAILBOX *)mbq;
7952
7953 /* SET MENLO maint mode */
7954 /* Create the set_variable mailbox request */
7926 emlxs_mb_set_var(hba, mb, 0x103107, 1);
7955 emlxs_mb_set_var(hba, mbq, 0x103107, 1);
7927
7928 mbq->flag |= MBQ_PASSTHRU;
7929
7930 /* issue the mbox cmd to the sli */
7956
7957 mbq->flag |= MBQ_PASSTHRU;
7958
7959 /* issue the mbox cmd to the sli */
7931 mbxstatus = emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0);
7960 mbxstatus = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
7932
7933 if (mbxstatus) {
7934 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7935 "%s: %s failed. mbxstatus=0x%x",
7936 emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE),
7937 emlxs_mb_cmd_xlate(mb->mbxCommand), mbxstatus);
7938
7939 rval = DFC_IO_ERROR;

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

7983 /* Make this a polled IO */
7984 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
7985 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
7986 pkt->pkt_comp = NULL;
7987 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
7988 pkt->pkt_timeout = 30;
7989
7990 /* Build the fc header */
7961
7962 if (mbxstatus) {
7963 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
7964 "%s: %s failed. mbxstatus=0x%x",
7965 emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE),
7966 emlxs_mb_cmd_xlate(mb->mbxCommand), mbxstatus);
7967
7968 rval = DFC_IO_ERROR;

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

8012 /* Make this a polled IO */
8013 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
8014 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
8015 pkt->pkt_comp = NULL;
8016 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
8017 pkt->pkt_timeout = 30;
8018
8019 /* Build the fc header */
7991 pkt->pkt_cmd_fhdr.d_id = SWAP_DATA24_LO(EMLXS_MENLO_DID);
8020 pkt->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(EMLXS_MENLO_DID);
7992 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_COMMAND;
8021 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_COMMAND;
7993 pkt->pkt_cmd_fhdr.s_id = SWAP_DATA24_LO(port->did);
8022 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(port->did);
7994 pkt->pkt_cmd_fhdr.type = EMLXS_MENLO_TYPE;
7995 pkt->pkt_cmd_fhdr.f_ctl =
7996 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
7997 pkt->pkt_cmd_fhdr.seq_id = 0;
7998 pkt->pkt_cmd_fhdr.df_ctl = 0;
7999 pkt->pkt_cmd_fhdr.seq_cnt = 0;
8000 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
8001 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;
8002 pkt->pkt_cmd_fhdr.ro = 0;
8003
8004 cmd = (menlo_cmd_t *)pkt->pkt_cmd;
8023 pkt->pkt_cmd_fhdr.type = EMLXS_MENLO_TYPE;
8024 pkt->pkt_cmd_fhdr.f_ctl =
8025 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
8026 pkt->pkt_cmd_fhdr.seq_id = 0;
8027 pkt->pkt_cmd_fhdr.df_ctl = 0;
8028 pkt->pkt_cmd_fhdr.seq_cnt = 0;
8029 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
8030 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;
8031 pkt->pkt_cmd_fhdr.ro = 0;
8032
8033 cmd = (menlo_cmd_t *)pkt->pkt_cmd;
8005 cmd->code = SWAP_LONG(MENLO_CMD_LOOPBACK);
8006 cmd->lb.context = SWAP_LONG(offset);
8007 cmd->lb.type = SWAP_LONG(MENLO_LOOPBACK_ENABLE);
8034 cmd->code = BE_SWAP32(MENLO_CMD_LOOPBACK);
8035 cmd->lb.context = BE_SWAP32(offset);
8036 cmd->lb.type = BE_SWAP32(MENLO_LOOPBACK_ENABLE);
8008
8009 if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
8010 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8011 "%s: Unable to send packet.",
8012 emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE));
8013
8014 rval = DFC_IO_ERROR;
8015 goto done;

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

8038 rval = DFC_IO_ERROR;
8039 }
8040 goto done;
8041 }
8042
8043
8044 /* CLEAR MENLO maint mode */
8045 /* Create the set_variable mailbox request */
8037
8038 if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
8039 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8040 "%s: Unable to send packet.",
8041 emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE));
8042
8043 rval = DFC_IO_ERROR;
8044 goto done;

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

8067 rval = DFC_IO_ERROR;
8068 }
8069 goto done;
8070 }
8071
8072
8073 /* CLEAR MENLO maint mode */
8074 /* Create the set_variable mailbox request */
8046 emlxs_mb_set_var(hba, mb, 0x103107, 0);
8075 emlxs_mb_set_var(hba, mbq, 0x103107, 0);
8047
8048 mbq->flag |= MBQ_PASSTHRU;
8049
8050 /* issue the mbox cmd to the sli */
8076
8077 mbq->flag |= MBQ_PASSTHRU;
8078
8079 /* issue the mbox cmd to the sli */
8051 mbxstatus = emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0);
8080 mbxstatus = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
8052
8053 if (mbxstatus) {
8054 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8055 "%s: %s failed. mbxstatus=0x%x",
8056 emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE),
8057 emlxs_mb_cmd_xlate(mb->mbxCommand), mbxstatus);
8058
8059 rval = DFC_IO_ERROR;

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

8112 /* Make this a polled IO */
8113 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
8114 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
8115 pkt->pkt_comp = NULL;
8116 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
8117 pkt->pkt_timeout = 30;
8118
8119 /* Build the fc header */
8081
8082 if (mbxstatus) {
8083 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8084 "%s: %s failed. mbxstatus=0x%x",
8085 emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE),
8086 emlxs_mb_cmd_xlate(mb->mbxCommand), mbxstatus);
8087
8088 rval = DFC_IO_ERROR;

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

8141 /* Make this a polled IO */
8142 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
8143 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
8144 pkt->pkt_comp = NULL;
8145 pkt->pkt_tran_type = FC_PKT_EXCHANGE;
8146 pkt->pkt_timeout = 30;
8147
8148 /* Build the fc header */
8120 pkt->pkt_cmd_fhdr.d_id = SWAP_DATA24_LO(EMLXS_MENLO_DID);
8149 pkt->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(EMLXS_MENLO_DID);
8121 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_COMMAND;
8150 pkt->pkt_cmd_fhdr.r_ctl = R_CTL_COMMAND;
8122 pkt->pkt_cmd_fhdr.s_id = SWAP_DATA24_LO(port->did);
8151 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(port->did);
8123 pkt->pkt_cmd_fhdr.type = EMLXS_MENLO_TYPE;
8124 pkt->pkt_cmd_fhdr.f_ctl =
8125 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
8126 pkt->pkt_cmd_fhdr.seq_id = 0;
8127 pkt->pkt_cmd_fhdr.df_ctl = 0;
8128 pkt->pkt_cmd_fhdr.seq_cnt = 0;
8129 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
8130 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;
8131 pkt->pkt_cmd_fhdr.ro = 0;
8132
8133 cmd = (menlo_cmd_t *)pkt->pkt_cmd;
8152 pkt->pkt_cmd_fhdr.type = EMLXS_MENLO_TYPE;
8153 pkt->pkt_cmd_fhdr.f_ctl =
8154 F_CTL_FIRST_SEQ | F_CTL_END_SEQ | F_CTL_SEQ_INITIATIVE;
8155 pkt->pkt_cmd_fhdr.seq_id = 0;
8156 pkt->pkt_cmd_fhdr.df_ctl = 0;
8157 pkt->pkt_cmd_fhdr.seq_cnt = 0;
8158 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
8159 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;
8160 pkt->pkt_cmd_fhdr.ro = 0;
8161
8162 cmd = (menlo_cmd_t *)pkt->pkt_cmd;
8134 cmd->code = SWAP_LONG(MENLO_CMD_FTE_INSERT);
8135 cmd->fte_insert.fcid = SWAP_LONG(0);
8163 cmd->code = BE_SWAP32(MENLO_CMD_FTE_INSERT);
8164 cmd->fte_insert.fcid = BE_SWAP32(0);
8136 bcopy((caddr_t)&port->wwpn, (caddr_t)cmd->fte_insert.wwpn, 8);
8137
8138 if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
8139 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8140 "%s: Unable to send packet.",
8141 emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE));
8142
8143 rval = DFC_IO_ERROR;

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

8181emlxs_dfc_reset_menlo(emlxs_hba_t *hba)
8182{
8183 emlxs_port_t *port = &PPORT;
8184 MAILBOXQ *mbq = NULL;
8185 MAILBOX *mb = NULL;
8186 uint32_t mbxstatus;
8187 uint32_t rval = 0;
8188
8165 bcopy((caddr_t)&port->wwpn, (caddr_t)cmd->fte_insert.wwpn, 8);
8166
8167 if (emlxs_pkt_send(pkt, 1) != FC_SUCCESS) {
8168 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8169 "%s: Unable to send packet.",
8170 emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE));
8171
8172 rval = DFC_IO_ERROR;

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

8210emlxs_dfc_reset_menlo(emlxs_hba_t *hba)
8211{
8212 emlxs_port_t *port = &PPORT;
8213 MAILBOXQ *mbq = NULL;
8214 MAILBOX *mb = NULL;
8215 uint32_t mbxstatus;
8216 uint32_t rval = 0;
8217
8189 if ((mbq = (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ),
8190 KM_SLEEP)) == 0) {
8191 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8192 "%s: Unable to allocate mailbox buffer.",
8193 emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE));
8218 mbq = (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ),
8219 KM_SLEEP);
8194
8220
8195 rval = DFC_SYSRES_ERROR;
8196 goto done;
8197 }
8198
8199 mb = (MAILBOX *)mbq;
8200
8201 /* RESET MENLO */
8202 /* Create the set_variable mailbox request */
8221 mb = (MAILBOX *)mbq;
8222
8223 /* RESET MENLO */
8224 /* Create the set_variable mailbox request */
8203 emlxs_mb_set_var(hba, mb, 0x103007, 0);
8225 emlxs_mb_set_var(hba, mbq, 0x103007, 0);
8204
8205 mbq->flag |= MBQ_PASSTHRU;
8206
8207 /* issue the mbox cmd to the sli */
8226
8227 mbq->flag |= MBQ_PASSTHRU;
8228
8229 /* issue the mbox cmd to the sli */
8208 mbxstatus = emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0);
8230 mbxstatus = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
8209
8210 if (mbxstatus) {
8211 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8212 "%s: %s failed. mbxstatus=0x%x",
8213 emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE),
8214 emlxs_mb_cmd_xlate(mb->mbxCommand), mbxstatus);
8215
8216 rval = DFC_IO_ERROR;

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

8239 uint32_t rval = DFC_SUCCESS;
8240 uint32_t i;
8241 uint32_t timeout;
8242 uint32_t topology;
8243 uint32_t speed;
8244 uint32_t new_mode;
8245 NODELIST *ndlp;
8246
8231
8232 if (mbxstatus) {
8233 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8234 "%s: %s failed. mbxstatus=0x%x",
8235 emlxs_dfc_xlate(EMLXS_LOOPBACK_MODE),
8236 emlxs_mb_cmd_xlate(mb->mbxCommand), mbxstatus);
8237
8238 rval = DFC_IO_ERROR;

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

8261 uint32_t rval = DFC_SUCCESS;
8262 uint32_t i;
8263 uint32_t timeout;
8264 uint32_t topology;
8265 uint32_t speed;
8266 uint32_t new_mode;
8267 NODELIST *ndlp;
8268
8269 if (hba->model_info.flags & EMLXS_FCOE_SUPPORTED) {
8270 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8271 "%s: FCoE not supported.", emlxs_dfc_xlate(dfc->cmd));
8272
8273 return (DFC_FCOE_NOTSUPPORTED);
8274 }
8275
8247 /* Reinitialize the link */
8248 switch (dfc->flag) {
8249 case 0: /* Disable */
8250
8251 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_debug_msg,
8252 "%s: Disabling Loopback.", emlxs_dfc_xlate(dfc->cmd));
8253
8254 if (!(hba->flag & FC_LOOPBACK_MODE)) {

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

8324 if (new_mode == FC_ILB_MODE) {
8325 rval = emlxs_dfc_set_menlo_loopback(hba);
8326 if (rval)
8327 goto done;
8328 }
8329 }
8330#endif /* MENLO_SUPPORT */
8331
8276 /* Reinitialize the link */
8277 switch (dfc->flag) {
8278 case 0: /* Disable */
8279
8280 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_debug_msg,
8281 "%s: Disabling Loopback.", emlxs_dfc_xlate(dfc->cmd));
8282
8283 if (!(hba->flag & FC_LOOPBACK_MODE)) {

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

8353 if (new_mode == FC_ILB_MODE) {
8354 rval = emlxs_dfc_set_menlo_loopback(hba);
8355 if (rval)
8356 goto done;
8357 }
8358 }
8359#endif /* MENLO_SUPPORT */
8360
8332 if ((mbq = (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ),
8333 KM_SLEEP)) == 0) {
8334 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8335 "%s: Unable to allocate mailbox buffer.",
8336 emlxs_dfc_xlate(dfc->cmd));
8361 mbq = (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ),
8362 KM_SLEEP);
8337
8363
8338 rval = DFC_SYSRES_ERROR;
8339 goto done;
8340 }
8341
8342 mb = (MAILBOX *) mbq;
8343
8344 /* Take the link down */
8364 mb = (MAILBOX *) mbq;
8365
8366 /* Take the link down */
8345 emlxs_mb_down_link(hba, mb);
8367 emlxs_mb_down_link(hba, mbq);
8346
8368
8347 rval = emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0);
8369 rval = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
8348
8349 if (rval == MBX_TIMEOUT) {
8350 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8351 "%s: Mailbox timed out. cmd=%x",
8352 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
8353
8354 rval = DFC_TIMEOUT;
8355 goto done;

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

8360 "%s: %s failed. status=%x", emlxs_dfc_xlate(dfc->cmd),
8361 emlxs_mb_cmd_xlate(mb->mbxCommand), rval);
8362
8363 rval = DFC_IO_ERROR;
8364 goto done;
8365 }
8366
8367 /* Reinitialize the link */
8370
8371 if (rval == MBX_TIMEOUT) {
8372 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8373 "%s: Mailbox timed out. cmd=%x",
8374 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
8375
8376 rval = DFC_TIMEOUT;
8377 goto done;

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

8382 "%s: %s failed. status=%x", emlxs_dfc_xlate(dfc->cmd),
8383 emlxs_mb_cmd_xlate(mb->mbxCommand), rval);
8384
8385 rval = DFC_IO_ERROR;
8386 goto done;
8387 }
8388
8389 /* Reinitialize the link */
8368 emlxs_mb_init_link(hba, mb, topology, speed);
8390 emlxs_mb_init_link(hba, mbq, topology, speed);
8369
8370 /* Set the loopback mode and timer */
8371 mutex_enter(&EMLXS_PORT_LOCK);
8372 hba->flag |= new_mode;
8373 hba->loopback_tics = hba->timer_tics + emlxs_loopback_tmo;
8374 mutex_exit(&EMLXS_PORT_LOCK);
8375
8391
8392 /* Set the loopback mode and timer */
8393 mutex_enter(&EMLXS_PORT_LOCK);
8394 hba->flag |= new_mode;
8395 hba->loopback_tics = hba->timer_tics + emlxs_loopback_tmo;
8396 mutex_exit(&EMLXS_PORT_LOCK);
8397
8376 rval = emlxs_sli_issue_mbox_cmd(hba, mb, MBX_WAIT, 0);
8398 rval = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
8377
8378 if (rval == MBX_TIMEOUT) {
8379 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8380 "%s: Mailbox timed out. cmd=%x",
8381 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
8382
8383 rval = DFC_TIMEOUT;
8384 goto done;

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

8460
8461 rval = emlxs_dfc_set_menlo_fte(hba);
8462 if (rval)
8463 goto done;
8464 }
8465#endif /* MENLO_SUPPORT */
8466
8467 /* Create host XRI */
8399
8400 if (rval == MBX_TIMEOUT) {
8401 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8402 "%s: Mailbox timed out. cmd=%x",
8403 emlxs_dfc_xlate(dfc->cmd), mb->mbxCommand);
8404
8405 rval = DFC_TIMEOUT;
8406 goto done;

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

8482
8483 rval = emlxs_dfc_set_menlo_fte(hba);
8484 if (rval)
8485 goto done;
8486 }
8487#endif /* MENLO_SUPPORT */
8488
8489 /* Create host XRI */
8468 (void) emlxs_create_xri(port, &hba->ring[FC_CT_RING], ndlp);
8490 (void) emlxs_create_xri(port, &hba->chan[hba->channel_ct], ndlp);
8469
8470 i = 0;
8471 do {
8472 if (i++ > 300) {
8473 break;
8474 }
8475
8476 delay(drv_usectohz(100000));

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

8504
8505 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_debug_msg,
8506 "%s: Menlo reset: rval:x%x",
8507 emlxs_dfc_xlate(dfc->cmd), rval);
8508 }
8509#endif /* MENLO_SUPPORT */
8510
8511 /* Reset link whether we are bound to ULP or not */
8491
8492 i = 0;
8493 do {
8494 if (i++ > 300) {
8495 break;
8496 }
8497
8498 delay(drv_usectohz(100000));

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

8526
8527 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_debug_msg,
8528 "%s: Menlo reset: rval:x%x",
8529 emlxs_dfc_xlate(dfc->cmd), rval);
8530 }
8531#endif /* MENLO_SUPPORT */
8532
8533 /* Reset link whether we are bound to ULP or not */
8512 (void) emlxs_reset_link(hba, 1);
8534 (void) emlxs_reset_link(hba, 1, 1);
8513 }
8514
8515 return (rval);
8516} /* emlxs_dfc_loopback_mode() */
8517
8518
8519static int32_t
8520emlxs_dfc_loopback_test(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
8521{
8522 emlxs_port_t *port = &PPORT;
8523 uint32_t rval = 0;
8524 NODELIST *ndlp;
8525 clock_t timeout;
8526 fc_packet_t *pkt = NULL;
8527 SLI_CT_REQUEST *CtCmd;
8528 uint16_t CtRsp;
8529
8535 }
8536
8537 return (rval);
8538} /* emlxs_dfc_loopback_mode() */
8539
8540
8541static int32_t
8542emlxs_dfc_loopback_test(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
8543{
8544 emlxs_port_t *port = &PPORT;
8545 uint32_t rval = 0;
8546 NODELIST *ndlp;
8547 clock_t timeout;
8548 fc_packet_t *pkt = NULL;
8549 SLI_CT_REQUEST *CtCmd;
8550 uint16_t CtRsp;
8551
8552 if (hba->model_info.flags & EMLXS_FCOE_SUPPORTED) {
8553 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8554 "%s: FCoE not supported.", emlxs_dfc_xlate(dfc->cmd));
8555
8556 return (DFC_FCOE_NOTSUPPORTED);
8557 }
8558
8530 mutex_enter(&EMLXS_PORT_LOCK);
8531 if (!(hba->flag & FC_LOOPBACK_MODE)) {
8532 mutex_exit(&EMLXS_PORT_LOCK);
8533
8534 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8535 "%s: Adapter not in loopback mode.",
8536 emlxs_dfc_xlate(dfc->cmd));
8537

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

8596 if (!ndlp->nlp_Xri) {
8597 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8598 "%s: Host XRI not found.", emlxs_dfc_xlate(dfc->cmd));
8599
8600 rval = DFC_DRV_ERROR;
8601 goto done;
8602 }
8603
8559 mutex_enter(&EMLXS_PORT_LOCK);
8560 if (!(hba->flag & FC_LOOPBACK_MODE)) {
8561 mutex_exit(&EMLXS_PORT_LOCK);
8562
8563 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8564 "%s: Adapter not in loopback mode.",
8565 emlxs_dfc_xlate(dfc->cmd));
8566

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

8625 if (!ndlp->nlp_Xri) {
8626 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8627 "%s: Host XRI not found.", emlxs_dfc_xlate(dfc->cmd));
8628
8629 rval = DFC_DRV_ERROR;
8630 goto done;
8631 }
8632
8604 if (!(pkt = emlxs_pkt_alloc(port, dfc->buf1_size + 16,
8605 dfc->buf2_size + 16, 0, KM_SLEEP))) {
8633 pkt = emlxs_pkt_alloc(port, dfc->buf1_size + 16,
8634 dfc->buf2_size + 16, 0, KM_SLEEP);
8635
8636 if (pkt == NULL) {
8606 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8607 "%s: Unable to allocate pkt.", emlxs_dfc_xlate(dfc->cmd));
8637 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8638 "%s: Unable to allocate pkt.", emlxs_dfc_xlate(dfc->cmd));
8608
8609 rval = DFC_SYSRES_ERROR;
8610 goto done;
8611 }
8612
8613 CtCmd = (SLI_CT_REQUEST*)pkt->pkt_cmd;
8614 CtRsp = SLI_CT_LOOPBACK;
8639 rval = DFC_SYSRES_ERROR;
8640 goto done;
8641 }
8642
8643 CtCmd = (SLI_CT_REQUEST*)pkt->pkt_cmd;
8644 CtRsp = SLI_CT_LOOPBACK;
8615 CtCmd->CommandResponse.bits.CmdRsp = SWAP_DATA16(CtRsp);
8645 CtCmd->CommandResponse.bits.CmdRsp = LE_SWAP16(CtRsp);
8616
8617 if (ddi_copyin((void *)dfc->buf1, (void *)&CtCmd->un.data,
8618 dfc->buf1_size, mode) != 0) {
8619 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8620 "%s: ddi_copyin failed.", emlxs_dfc_xlate(dfc->cmd));
8621
8622 rval = DFC_COPYIN_ERROR;
8623 goto done;

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

8736 }
8737
8738 return (rval);
8739
8740} /* emlxs_dfc_loopback_test() */
8741
8742
8743extern int32_t
8646
8647 if (ddi_copyin((void *)dfc->buf1, (void *)&CtCmd->un.data,
8648 dfc->buf1_size, mode) != 0) {
8649 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8650 "%s: ddi_copyin failed.", emlxs_dfc_xlate(dfc->cmd));
8651
8652 rval = DFC_COPYIN_ERROR;
8653 goto done;

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

8766 }
8767
8768 return (rval);
8769
8770} /* emlxs_dfc_loopback_test() */
8771
8772
8773extern int32_t
8744emlxs_dfc_handle_event(emlxs_hba_t *hba, RING *rp, IOCBQ *iocbq)
8774emlxs_dfc_handle_event(emlxs_hba_t *hba, CHANNEL *cp, IOCBQ *iocbq)
8745{
8746 emlxs_port_t *port = &PPORT;
8747 IOCB *cmd;
8748 emlxs_buf_t *sbp;
8749
8750 cmd = &iocbq->iocb;
8751
8752 HBASTATS.CtEvent++;
8753
8754 sbp = (emlxs_buf_t *)iocbq->sbp;
8755
8756 if (!sbp) {
8757 HBASTATS.CtStray++;
8758
8759 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8760 "Stray interrupt. cmd=0x%x iotag=0x%x status=0x%x "
8775{
8776 emlxs_port_t *port = &PPORT;
8777 IOCB *cmd;
8778 emlxs_buf_t *sbp;
8779
8780 cmd = &iocbq->iocb;
8781
8782 HBASTATS.CtEvent++;
8783
8784 sbp = (emlxs_buf_t *)iocbq->sbp;
8785
8786 if (!sbp) {
8787 HBASTATS.CtStray++;
8788
8789 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8790 "Stray interrupt. cmd=0x%x iotag=0x%x status=0x%x "
8761 "perr=0x%x", (uint32_t)cmd->ulpCommand,
8762 (uint32_t)cmd->ulpIoTag, cmd->ulpStatus,
8791 "perr=0x%x", (uint32_t)cmd->ULPCOMMAND,
8792 (uint32_t)cmd->ULPIOTAG, cmd->ULPSTATUS,
8763 cmd->un.ulpWord[4]);
8764
8765 return (DFC_ARG_INVALID);
8766 }
8767
8793 cmd->un.ulpWord[4]);
8794
8795 return (DFC_ARG_INVALID);
8796 }
8797
8768 if (rp->ringno != FC_CT_RING) {
8798 if (cp->channelno != hba->channel_ct) {
8769 HBASTATS.CtStray++;
8770
8771 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8799 HBASTATS.CtStray++;
8800
8801 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8772 "CT Event: Invalid ring: ring=%d iocbq=%p", rp->ringno,
8802 "CT Event: Invalid IO Channel:%d iocbq=%p", cp->channelno,
8773 iocbq);
8774
8775 return (DFC_ARG_INVALID);
8776 }
8777
8803 iocbq);
8804
8805 return (DFC_ARG_INVALID);
8806 }
8807
8778 switch (cmd->ulpCommand) {
8808 switch (cmd->ULPCOMMAND) {
8779 case CMD_XMIT_SEQUENCE_CR:
8780 case CMD_XMIT_SEQUENCE64_CR:
8781 case CMD_XMIT_SEQUENCE_CX:
8782 case CMD_XMIT_SEQUENCE64_CX:
8783
8784 HBASTATS.CtCmdCompleted++;
8785
8809 case CMD_XMIT_SEQUENCE_CR:
8810 case CMD_XMIT_SEQUENCE64_CR:
8811 case CMD_XMIT_SEQUENCE_CX:
8812 case CMD_XMIT_SEQUENCE64_CX:
8813
8814 HBASTATS.CtCmdCompleted++;
8815
8786 if (cmd->ulpStatus == 0) {
8816 if (cmd->ULPSTATUS == 0) {
8787 HBASTATS.CtCmdGood++;
8788
8789 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
8790 "XMIT_SEQUENCE comp: status=0x%x",
8817 HBASTATS.CtCmdGood++;
8818
8819 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
8820 "XMIT_SEQUENCE comp: status=0x%x",
8791 cmd->ulpStatus);
8821 cmd->ULPSTATUS);
8792 } else {
8793 HBASTATS.CtCmdError++;
8794
8795 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8796 "XMIT_SEQUENCE comp: status=0x%x [%08x,%08x]",
8822 } else {
8823 HBASTATS.CtCmdError++;
8824
8825 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8826 "XMIT_SEQUENCE comp: status=0x%x [%08x,%08x]",
8797 cmd->ulpStatus, cmd->un.ulpWord[4],
8827 cmd->ULPSTATUS, cmd->un.ulpWord[4],
8798 cmd->un.ulpWord[5]);
8799 }
8800
8828 cmd->un.ulpWord[5]);
8829 }
8830
8801 emlxs_pkt_complete(sbp, cmd->ulpStatus,
8831 emlxs_pkt_complete(sbp, cmd->ULPSTATUS,
8802 cmd->un.grsp.perr.statLocalError, 1);
8803
8804 break;
8805
8806 default:
8807
8808 HBASTATS.CtStray++;
8809
8810 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8832 cmd->un.grsp.perr.statLocalError, 1);
8833
8834 break;
8835
8836 default:
8837
8838 HBASTATS.CtStray++;
8839
8840 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
8811 "Invalid iocb: cmd=0x%x", cmd->ulpCommand);
8841 "Invalid iocb: cmd=0x%x", cmd->ULPCOMMAND);
8812
8842
8813 emlxs_pkt_complete(sbp, cmd->ulpStatus,
8843 emlxs_pkt_complete(sbp, cmd->ULPSTATUS,
8814 cmd->un.grsp.perr.statLocalError, 1);
8815
8816 break;
8817
8844 cmd->un.grsp.perr.statLocalError, 1);
8845
8846 break;
8847
8818 } /* switch(cmd->ulpCommand) */
8848 } /* switch(cmd->ULPCOMMAND) */
8819
8820 return (0);
8821
8822} /* emlxs_dfc_handle_event() */
8823
8824
8825/* ARGSUSED */
8826extern int
8849
8850 return (0);
8851
8852} /* emlxs_dfc_handle_event() */
8853
8854
8855/* ARGSUSED */
8856extern int
8827emlxs_dfc_handle_unsol_req(emlxs_port_t *port, RING *rp, IOCBQ *iocbq,
8857emlxs_dfc_handle_unsol_req(emlxs_port_t *port, CHANNEL *cp, IOCBQ *iocbq,
8828 MATCHMAP *mp, uint32_t size)
8829{
8830 emlxs_hba_t *hba = HBA;
8831 IOCB *iocb;
8832 uint8_t *bp;
8833 fc_packet_t *pkt;
8834
8835 iocb = &iocbq->iocb;
8836 bp = (uint8_t *)mp->virt;
8837
8838 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
8839 "CT Receive: cmd=%x status=0x%x ",
8858 MATCHMAP *mp, uint32_t size)
8859{
8860 emlxs_hba_t *hba = HBA;
8861 IOCB *iocb;
8862 uint8_t *bp;
8863 fc_packet_t *pkt;
8864
8865 iocb = &iocbq->iocb;
8866 bp = (uint8_t *)mp->virt;
8867
8868 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
8869 "CT Receive: cmd=%x status=0x%x ",
8840 iocb->ulpCommand, iocb->ulpStatus);
8870 iocb->ULPCOMMAND, iocb->ULPSTATUS);
8841
8842 /*
8843 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_debug_msg,
8844 * "CT Receive: payload=%p size=%d [%02x,%02x, %02x, %02x]", bp,
8845 * size, bp[0], bp[1], bp[2],bp[3]);
8846 */
8847
8848 /* Return payload */

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

9282 &emlxs_dfc_error_msg, "%s: Buffer1 too small. (%d < %d)",
9283 emlxs_dfc_xlate(dfc->cmd), count, hba->auth_cfg_count);
9284
9285 mutex_exit(&hba->auth_lock);
9286 return (DFC_ARG_TOOSMALL);
9287 }
9288
9289 size = hba->auth_cfg_count * sizeof (dfc_fcsp_config_t);
8871
8872 /*
8873 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_debug_msg,
8874 * "CT Receive: payload=%p size=%d [%02x,%02x, %02x, %02x]", bp,
8875 * size, bp[0], bp[1], bp[2],bp[3]);
8876 */
8877
8878 /* Return payload */

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

9312 &emlxs_dfc_error_msg, "%s: Buffer1 too small. (%d < %d)",
9313 emlxs_dfc_xlate(dfc->cmd), count, hba->auth_cfg_count);
9314
9315 mutex_exit(&hba->auth_lock);
9316 return (DFC_ARG_TOOSMALL);
9317 }
9318
9319 size = hba->auth_cfg_count * sizeof (dfc_fcsp_config_t);
9290 if (!(fcsp_cfg = (dfc_fcsp_config_t *)kmem_zalloc(size, KM_SLEEP))) {
9291 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
9292 "%s: Unable to allocate table buffer.",
9293 emlxs_dfc_xlate(dfc->cmd));
9294
9320
9295 mutex_exit(&hba->auth_lock);
9296 return (DFC_SYSRES_ERROR);
9297 }
9321 mutex_exit(&hba->auth_lock);
9298
9322
9323 fcsp_cfg = (dfc_fcsp_config_t *)kmem_zalloc(size, KM_SLEEP);
9324
9325 mutex_enter(&hba->auth_lock);
9326
9299 if ((rval = emlxs_dhc_get_auth_cfg_table(hba, fcsp_cfg)) != 0) {
9300 mutex_exit(&hba->auth_lock);
9301 kmem_free(fcsp_cfg, size);
9302 return (rval);
9303 }
9304
9305 mutex_exit(&hba->auth_lock);
9306

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

9375 &emlxs_dfc_error_msg, "%s: Buffer1 too small. (%d < %d)",
9376 emlxs_dfc_xlate(dfc->cmd), count, hba->auth_key_count);
9377
9378 mutex_exit(&hba->auth_lock);
9379 return (DFC_ARG_TOOSMALL);
9380 }
9381
9382 size = hba->auth_key_count * sizeof (dfc_auth_password_t);
9327 if ((rval = emlxs_dhc_get_auth_cfg_table(hba, fcsp_cfg)) != 0) {
9328 mutex_exit(&hba->auth_lock);
9329 kmem_free(fcsp_cfg, size);
9330 return (rval);
9331 }
9332
9333 mutex_exit(&hba->auth_lock);
9334

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

9403 &emlxs_dfc_error_msg, "%s: Buffer1 too small. (%d < %d)",
9404 emlxs_dfc_xlate(dfc->cmd), count, hba->auth_key_count);
9405
9406 mutex_exit(&hba->auth_lock);
9407 return (DFC_ARG_TOOSMALL);
9408 }
9409
9410 size = hba->auth_key_count * sizeof (dfc_auth_password_t);
9383 if (!(auth_pwd = (dfc_auth_password_t *)kmem_zalloc(size, KM_SLEEP))) {
9384 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
9385 "%s: Unable to allocate table buffer.",
9386 emlxs_dfc_xlate(dfc->cmd));
9387
9411
9388 mutex_exit(&hba->auth_lock);
9389 return (DFC_SYSRES_ERROR);
9390 }
9412 mutex_exit(&hba->auth_lock);
9391
9413
9414 auth_pwd = (dfc_auth_password_t *)kmem_zalloc(size, KM_SLEEP);
9415
9416 mutex_enter(&hba->auth_lock);
9417
9392 if ((rval = emlxs_dhc_get_auth_key_table(hba, auth_pwd)) != 0) {
9393 mutex_exit(&hba->auth_lock);
9394 kmem_free(auth_pwd, size);
9395 return (rval);
9396 }
9397
9398 mutex_exit(&hba->auth_lock);
9399

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

9824 dfc_event->mode = 0;
9825
9826 (void) emlxs_get_sd_event(vport, dfc_event, 0);
9827
9828 if (dfc->buf1)
9829 (void) ddi_copyout((void *) &dfc_event->last_id,
9830 dfc->buf1, sizeof (uint32_t), mode);
9831
9418 if ((rval = emlxs_dhc_get_auth_key_table(hba, auth_pwd)) != 0) {
9419 mutex_exit(&hba->auth_lock);
9420 kmem_free(auth_pwd, size);
9421 return (rval);
9422 }
9423
9424 mutex_exit(&hba->auth_lock);
9425

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

9850 dfc_event->mode = 0;
9851
9852 (void) emlxs_get_sd_event(vport, dfc_event, 0);
9853
9854 if (dfc->buf1)
9855 (void) ddi_copyout((void *) &dfc_event->last_id,
9856 dfc->buf1, sizeof (uint32_t), mode);
9857
9832 vport->sd_reg_events |= event;
9858 vport->sd_event_mask |= event;
9833 } else { /* Disable */
9834 /* find event entry */
9835 for (i = 0; i < MAX_DFC_EVENTS; i++) {
9836 dfc_event = &vport->sd_events[i];
9837
9838 if (dfc_event->pid == pid && dfc_event->event == event)
9839 break;
9840 }

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

9857 count++;
9858 }
9859
9860 /*
9861 * If no more pids need this event,
9862 * then disable logging for this event
9863 */
9864 if (count == 0)
9859 } else { /* Disable */
9860 /* find event entry */
9861 for (i = 0; i < MAX_DFC_EVENTS; i++) {
9862 dfc_event = &vport->sd_events[i];
9863
9864 if (dfc_event->pid == pid && dfc_event->event == event)
9865 break;
9866 }

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

9883 count++;
9884 }
9885
9886 /*
9887 * If no more pids need this event,
9888 * then disable logging for this event
9889 */
9890 if (count == 0)
9865 vport->sd_reg_events &= ~event;
9891 vport->sd_event_mask &= ~event;
9866 }
9867
9868set_sd_event_exit:
9869 return (rval);
9870} /* emlxs_dfc_sd_set_event */
9871
9872
9873static int32_t

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

9902 break;
9903 }
9904
9905 if (i == MAX_DFC_EVENTS) {
9906 rval = DFC_SD_ERROR_GENERIC;
9907 goto get_sd_event_exit;
9908 }
9909
9892 }
9893
9894set_sd_event_exit:
9895 return (rval);
9896} /* emlxs_dfc_sd_set_event */
9897
9898
9899static int32_t

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

9928 break;
9929 }
9930
9931 if (i == MAX_DFC_EVENTS) {
9932 rval = DFC_SD_ERROR_GENERIC;
9933 goto get_sd_event_exit;
9934 }
9935
9910 if (!(vport->sd_reg_events & dfc_event->event)) {
9936 if (!(vport->sd_event_mask & dfc_event->event)) {
9911 rval = DFC_SD_ERROR_GENERIC;
9912 goto get_sd_event_exit;
9913 }
9914
9915 /* Initialize event buffer pointers */
9916 dfc_event->dataout = dfc->buf1;
9917 dfc_event->size = dfc->buf1_size;
9918 dfc_event->last_id = dfc->data3;

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

9995 if (ddi_copyin((void *) dfc->buf1, (void *) &cmdinfo,
9996 sizeof (dfc_send_scsi_fcp_cmd_info_t), mode) != 0) {
9997 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
9998 "%s: ddi_copyin failed.", emlxs_dfc_xlate(dfc->cmd));
9999
10000 rval = DFC_COPYIN_ERROR;
10001 goto done;
10002 }
9937 rval = DFC_SD_ERROR_GENERIC;
9938 goto get_sd_event_exit;
9939 }
9940
9941 /* Initialize event buffer pointers */
9942 dfc_event->dataout = dfc->buf1;
9943 dfc_event->size = dfc->buf1_size;
9944 dfc_event->last_id = dfc->data3;

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

10021 if (ddi_copyin((void *) dfc->buf1, (void *) &cmdinfo,
10022 sizeof (dfc_send_scsi_fcp_cmd_info_t), mode) != 0) {
10023 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10024 "%s: ddi_copyin failed.", emlxs_dfc_xlate(dfc->cmd));
10025
10026 rval = DFC_COPYIN_ERROR;
10027 goto done;
10028 }
10003#ifdef NPIV_SUPPORT
10029
10004 if (cmdinfo.ver == DFC_SEND_SCSI_FCP_V2) {
10005 port =
10006 emlxs_vport_find_wwpn(hba, (uint8_t *)&cmdinfo.src_wwn);
10007 if (port == NULL) {
10008 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10009 "%s: WWPN does not exists. %s",
10010 emlxs_dfc_xlate(dfc->cmd), emlxs_wwn_xlate(buffer,
10011 (uint8_t *)&cmdinfo.src_wwn));
10012
10013 rval = DFC_ARG_INVALID;
10014 goto done;
10015 }
10016 }
10030 if (cmdinfo.ver == DFC_SEND_SCSI_FCP_V2) {
10031 port =
10032 emlxs_vport_find_wwpn(hba, (uint8_t *)&cmdinfo.src_wwn);
10033 if (port == NULL) {
10034 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10035 "%s: WWPN does not exists. %s",
10036 emlxs_dfc_xlate(dfc->cmd), emlxs_wwn_xlate(buffer,
10037 (uint8_t *)&cmdinfo.src_wwn));
10038
10039 rval = DFC_ARG_INVALID;
10040 goto done;
10041 }
10042 }
10017#endif /* NPIV_SUPPORT */
10018
10019 if ((ndlp = emlxs_node_find_wwpn(port,
10020 (uint8_t *)&cmdinfo.dst_wwn)) == NULL) {
10021 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10022 "%s: WWPN does not exists. %s", emlxs_dfc_xlate(dfc->cmd),
10023 emlxs_wwn_xlate(buffer, (uint8_t *)&cmdinfo.dst_wwn));
10024
10025 rval = DFC_ARG_INVALID;

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

10047 }
10048
10049 /* Make this a polled IO */
10050 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
10051 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
10052 pkt->pkt_comp = NULL;
10053
10054 /* Build the fc header */
10043
10044 if ((ndlp = emlxs_node_find_wwpn(port,
10045 (uint8_t *)&cmdinfo.dst_wwn)) == NULL) {
10046 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10047 "%s: WWPN does not exists. %s", emlxs_dfc_xlate(dfc->cmd),
10048 emlxs_wwn_xlate(buffer, (uint8_t *)&cmdinfo.dst_wwn));
10049
10050 rval = DFC_ARG_INVALID;

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

10072 }
10073
10074 /* Make this a polled IO */
10075 pkt->pkt_tran_flags &= ~FC_TRAN_INTR;
10076 pkt->pkt_tran_flags |= FC_TRAN_NO_INTR;
10077 pkt->pkt_comp = NULL;
10078
10079 /* Build the fc header */
10055 pkt->pkt_cmd_fhdr.d_id = SWAP_DATA24_LO(ndlp->nlp_DID);
10080 pkt->pkt_cmd_fhdr.d_id = LE_SWAP24_LO(ndlp->nlp_DID);
10056 pkt->pkt_cmd_fhdr.r_ctl = FC_FCP_CMND;
10081 pkt->pkt_cmd_fhdr.r_ctl = FC_FCP_CMND;
10057 pkt->pkt_cmd_fhdr.s_id = SWAP_DATA24_LO(port->did);
10082 pkt->pkt_cmd_fhdr.s_id = LE_SWAP24_LO(port->did);
10058 pkt->pkt_cmd_fhdr.type = FC_FCP_DATA;
10059 pkt->pkt_cmd_fhdr.seq_id = 0;
10060 pkt->pkt_cmd_fhdr.df_ctl = 0;
10061 pkt->pkt_cmd_fhdr.seq_cnt = 0;
10062 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
10063 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;
10064 pkt->pkt_cmd_fhdr.ro = 0;
10065

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

10108 SCSI_RSP_CNT(cmdinfo) = dfc->buf3_size;
10109
10110 fcp_rsp = (FCP_RSP *) pkt->pkt_resp;
10111 /*
10112 * This is sense count for flag = 0.
10113 * It is fcp response size for flag = 1.
10114 */
10115 if (dfc->flag) {
10083 pkt->pkt_cmd_fhdr.type = FC_FCP_DATA;
10084 pkt->pkt_cmd_fhdr.seq_id = 0;
10085 pkt->pkt_cmd_fhdr.df_ctl = 0;
10086 pkt->pkt_cmd_fhdr.seq_cnt = 0;
10087 pkt->pkt_cmd_fhdr.ox_id = 0xFFFF;
10088 pkt->pkt_cmd_fhdr.rx_id = 0xFFFF;
10089 pkt->pkt_cmd_fhdr.ro = 0;
10090

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

10133 SCSI_RSP_CNT(cmdinfo) = dfc->buf3_size;
10134
10135 fcp_rsp = (FCP_RSP *) pkt->pkt_resp;
10136 /*
10137 * This is sense count for flag = 0.
10138 * It is fcp response size for flag = 1.
10139 */
10140 if (dfc->flag) {
10116 SCSI_SNS_CNT(cmdinfo) = 24 + SWAP_DATA32(fcp_rsp->rspSnsLen) +
10117 SWAP_DATA32(fcp_rsp->rspRspLen);
10141 SCSI_SNS_CNT(cmdinfo) = 24 + LE_SWAP32(fcp_rsp->rspSnsLen) +
10142 LE_SWAP32(fcp_rsp->rspRspLen);
10118 ptr = (void *)fcp_rsp;
10119 } else {
10143 ptr = (void *)fcp_rsp;
10144 } else {
10120 SCSI_SNS_CNT(cmdinfo) = SWAP_DATA32(fcp_rsp->rspSnsLen);
10145 SCSI_SNS_CNT(cmdinfo) = LE_SWAP32(fcp_rsp->rspSnsLen);
10121 ptr = (void *)&fcp_rsp->rspSnsInfo[0];
10122 }
10123
10124 if (ddi_copyout((void *) &cmdinfo, (void *) dfc->buf1,
10125 sizeof (dfc_send_scsi_fcp_cmd_info_t), mode) != 0) {
10126 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10127 "%s: rsp_buf ddi_copyout failed.",
10128 emlxs_dfc_xlate(dfc->cmd));

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

10162 if (pkt) {
10163 emlxs_pkt_free(pkt);
10164 }
10165
10166 return (rval);
10167
10168} /* emlxs_dfc_send_scsi_fcp() */
10169
10146 ptr = (void *)&fcp_rsp->rspSnsInfo[0];
10147 }
10148
10149 if (ddi_copyout((void *) &cmdinfo, (void *) dfc->buf1,
10150 sizeof (dfc_send_scsi_fcp_cmd_info_t), mode) != 0) {
10151 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10152 "%s: rsp_buf ddi_copyout failed.",
10153 emlxs_dfc_xlate(dfc->cmd));

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

10187 if (pkt) {
10188 emlxs_pkt_free(pkt);
10189 }
10190
10191 return (rval);
10192
10193} /* emlxs_dfc_send_scsi_fcp() */
10194
10170#endif /* DFC_SUPPORT */
10195
10196static int32_t
10197emlxs_dfc_get_persist_linkdown(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
10198{
10199 emlxs_port_t *port = &PPORT;
10200 emlxs_config_t *cfg = &CFG;
10201 uint16_t linkdown = 0;
10202 uint32_t rval = 0;
10203
10204 if (hba->model_info.flags & EMLXS_FCOE_SUPPORTED) {
10205 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10206 "%s: FCoE not supported.", emlxs_dfc_xlate(dfc->cmd));
10207
10208 return (DFC_FCOE_NOTSUPPORTED);
10209 }
10210
10211 if (!dfc->buf1 || !dfc->buf1_size) {
10212 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10213 "%s: Null buffer1 found.", emlxs_dfc_xlate(dfc->cmd));
10214
10215 return (DFC_ARG_NULL);
10216 }
10217
10218 linkdown = (uint16_t)cfg[CFG_PERSIST_LINKDOWN].current;
10219 if (ddi_copyout((void *)&linkdown, dfc->buf1, dfc->buf1_size,
10220 mode) != 0) {
10221 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10222 "%s: ddi_copyout failed.", emlxs_dfc_xlate(dfc->cmd));
10223
10224 return (DFC_COPYOUT_ERROR);
10225 }
10226
10227 return (rval);
10228
10229} /* emlxs_dfc_get_persist_linkdown() */
10230
10231
10232/*ARGSUSED*/
10233static int32_t
10234emlxs_dfc_set_persist_linkdown(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
10235{
10236 emlxs_port_t *port = &PPORT;
10237 emlxs_config_t *cfg = &CFG;
10238 uint32_t rval = 0;
10239
10240 if (hba->model_info.flags & EMLXS_FCOE_SUPPORTED) {
10241 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10242 "%s: FCoE not supported.", emlxs_dfc_xlate(dfc->cmd));
10243
10244 return (DFC_FCOE_NOTSUPPORTED);
10245 }
10246
10247 if (dfc->data1) {
10248 cfg[CFG_PERSIST_LINKDOWN].current = 1;
10249 } else {
10250 cfg[CFG_PERSIST_LINKDOWN].current = 0;
10251 }
10252
10253 return (rval);
10254
10255} /* emlxs_dfc_set_persist_linkdown() */
10256
10257
10258static int32_t
10259emlxs_dfc_get_fcflist(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
10260{
10261 emlxs_port_t *port = &PPORT;
10262 DFC_FCoEFCFInfo_t *fcflistentry;
10263 DFC_FCoEFCFList_t *fcflist;
10264 FCFIobj_t *fp;
10265 uint32_t size;
10266 uint32_t i;
10267 uint32_t count = 0;
10268 uint32_t rval = 0;
10269
10270 if (!dfc->buf1 || !dfc->buf1_size) {
10271 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10272 "%s: Null buffer1 found.", emlxs_dfc_xlate(dfc->cmd));
10273
10274 return (DFC_ARG_NULL);
10275 }
10276
10277 if (dfc->buf1_size < sizeof (DFC_FCoEFCFList_t)) {
10278 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10279 "%s: Buffer1 too small. (size=%d)",
10280 emlxs_dfc_xlate(dfc->cmd), dfc->buf1_size);
10281
10282 return (DFC_ARG_TOOSMALL);
10283 }
10284
10285 if (! (hba->model_info.flags & EMLXS_FCOE_SUPPORTED)) {
10286 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10287 "%s: FCoE not supported.", emlxs_dfc_xlate(dfc->cmd));
10288
10289 return (DFC_FCOE_NOTSUPPORTED);
10290 }
10291
10292 size = sizeof (DFC_FCoEFCFList_t) +
10293 hba->sli.sli4.FCFICount * sizeof (DFC_FCoEFCFInfo_t);
10294 fcflist = (DFC_FCoEFCFList_t *)kmem_zalloc(size, KM_SLEEP);
10295
10296 if (ddi_copyin(dfc->buf1, (void *)fcflist,
10297 sizeof (DFC_FCoEFCFList_t), mode) != 0) {
10298 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10299 "%s: ddi_copyin failed.", emlxs_dfc_xlate(dfc->cmd));
10300
10301 rval = DFC_COPYIN_ERROR;
10302 goto done;
10303 }
10304
10305 fcflistentry = fcflist->entries;
10306 mutex_enter(&hba->sli.sli4.id_lock);
10307 fp = hba->sli.sli4.FCFIp;
10308 for (i = 0; i < hba->sli.sli4.FCFICount; i ++) {
10309 if ((fp->state == RESOURCE_ALLOCATED) &&
10310 (fp->fcf_rec.fcf_valid)) {
10311 fcflistentry->Priority = fp->fcf_rec.fip_priority;
10312 if (fp->fcf_rec.fcf_available)
10313 fcflistentry->State = FCF_AVAILABLE_STATE;
10314 fcflistentry->LKA_Period = fp->fcf_rec.fka_adv_period;
10315
10316 bcopy((void *)fp->fcf_rec.vlan_bitmap,
10317 (void *)fcflistentry->VLanBitMap, 512);
10318 bcopy((void *)fp->fcf_rec.fc_map,
10319 (void *)fcflistentry->FC_Map, 3);
10320 bcopy((void *)fp->fcf_rec.fabric_name_identifier,
10321 (void *)fcflistentry->FabricName, 8);
10322 bcopy((void *)fp->fcf_rec.switch_name_identifier,
10323 (void *)fcflistentry->SwitchName, 8);
10324 bcopy((void *)&fp->fcf_rec.fcf_mac_address_hi,
10325 (void *)fcflistentry->Mac, 6);
10326
10327 count ++;
10328 fcflistentry ++;
10329 }
10330 fp ++;
10331 }
10332 mutex_exit(&hba->sli.sli4.id_lock);
10333
10334 if (count > fcflist->numberOfEntries)
10335 rval = DFC_ARG_TOOSMALL;
10336
10337 i = sizeof (DFC_FCoEFCFList_t) +
10338 (fcflist->numberOfEntries - 1) * sizeof (DFC_FCoEFCFInfo_t);
10339 fcflist->numberOfEntries = count;
10340
10341 if (ddi_copyout((void *) fcflist, dfc->buf1,
10342 i, mode) != 0) {
10343 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10344 "%s: ddi_copyout failed.", emlxs_dfc_xlate(dfc->cmd));
10345
10346 rval = DFC_COPYOUT_ERROR;
10347 goto done;
10348 }
10349
10350done:
10351 kmem_free(fcflist, size);
10352 return (rval);
10353
10354} /* emlxs_dfc_get_fcflist() */
10355
10356
10357static int32_t
10358emlxs_dfc_send_mbox4(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
10359{
10360 emlxs_port_t *port = &PPORT;
10361 MAILBOX4 *mb4 = NULL;
10362 MAILBOXQ *mbq = NULL;
10363 MBUF_INFO bufinfo;
10364 uint32_t offset;
10365 int32_t mbxstatus = 0;
10366 uint32_t rval = 0;
10367
10368 if (!dfc->buf1 || !dfc->buf1_size) {
10369 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10370 "%s: Null buffer1 found.", emlxs_dfc_xlate(dfc->cmd));
10371
10372 return (DFC_ARG_NULL);
10373 }
10374
10375 if (!dfc->buf2 || !dfc->buf2_size) {
10376 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10377 "%s: Null buffer2 found.", emlxs_dfc_xlate(dfc->cmd));
10378
10379 return (DFC_ARG_NULL);
10380 }
10381
10382 if ((dfc->buf1_size != sizeof (MAILBOX4)) &&
10383 (dfc->buf2_size != sizeof (MAILBOX4))) {
10384 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10385 "%s: Invalid buffer size. (size=%d)",
10386 emlxs_dfc_xlate(dfc->cmd), dfc->buf1_size);
10387
10388 return (DFC_ARG_INVALID);
10389 }
10390
10391 if (dfc->buf3_size && !dfc->buf3) {
10392 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10393 "%s: NULL buffer3 found.",
10394 emlxs_dfc_xlate(dfc->cmd));
10395
10396 return (DFC_ARG_INVALID);
10397 }
10398
10399 if (! (hba->model_info.flags & EMLXS_FCOE_SUPPORTED)) {
10400 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10401 "%s: FCoE not supported.", emlxs_dfc_xlate(dfc->cmd));
10402
10403 return (DFC_FCOE_NOTSUPPORTED);
10404 }
10405
10406 bzero(&bufinfo, sizeof (MBUF_INFO));
10407 if (dfc->buf3_size) {
10408 bufinfo.size = dfc->buf3_size;
10409 bufinfo.flags = FC_MBUF_DMA | FC_MBUF_SNGLSG | FC_MBUF_DMA32;
10410 bufinfo.align = ddi_ptob(hba->dip, 1L);
10411 (void) emlxs_mem_alloc(hba, &bufinfo);
10412
10413 if (bufinfo.virt == NULL) {
10414 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10415 "%s: Unable to allocate buffer.",
10416 emlxs_dfc_xlate(dfc->cmd));
10417
10418 rval = DFC_SYSRES_ERROR;
10419 goto done;
10420 }
10421
10422 if (ddi_copyin((void *)dfc->buf3, (void *)bufinfo.virt,
10423 dfc->buf3_size, mode) != 0) {
10424 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10425 "%s: ddi_copyin failed", emlxs_dfc_xlate(dfc->cmd));
10426
10427 rval = DFC_COPYIN_ERROR;
10428 goto done;
10429 }
10430 }
10431
10432 mbq =
10433 (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP);
10434
10435 mb4 = (MAILBOX4 *) mbq;
10436
10437 bzero((void *)mb4, sizeof (MAILBOX4));
10438
10439 if (ddi_copyin((void *)dfc->buf1, (void *)mb4, dfc->buf1_size,
10440 mode) != 0) {
10441 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10442 "%s: ddi_copyin failed.", emlxs_dfc_xlate(dfc->cmd));
10443
10444 rval = DFC_COPYIN_ERROR;
10445 goto done;
10446 }
10447
10448 if (dfc->buf3_size) {
10449 offset = dfc->data3;
10450 mb4->un.varWords[offset-1] = PADDR_LO(bufinfo.phys);
10451 mb4->un.varWords[offset] = PADDR_HI(bufinfo.phys);
10452 }
10453
10454 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
10455 "%s: %s sent. (%x %x %x %x)", emlxs_dfc_xlate(dfc->cmd),
10456 emlxs_mb_cmd_xlate(mb4->mbxCommand), mb4->un.varWords[0],
10457 mb4->un.varWords[1], mb4->un.varWords[2], mb4->un.varWords[3]);
10458
10459 /* issue the mbox cmd to the sli */
10460 mbxstatus = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
10461
10462 if (mbxstatus) {
10463 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10464 "%s: %s failed. mbxstatus=0x%x",
10465 emlxs_dfc_xlate(dfc->cmd),
10466 emlxs_mb_cmd_xlate(mb4->mbxCommand), mbxstatus);
10467 }
10468
10469 if (ddi_copyout((void *)mb4, (void *)dfc->buf2, dfc->buf2_size,
10470 mode) != 0) {
10471 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10472 "%s: ddi_copyout failed. cmd=%x",
10473 emlxs_dfc_xlate(dfc->cmd), mb4->mbxCommand);
10474
10475 rval = DFC_COPYOUT_ERROR;
10476 goto done;
10477 }
10478
10479 if (dfc->buf3_size) {
10480 if (ddi_copyout((void *)bufinfo.virt, (void *)dfc->buf3,
10481 dfc->buf3_size, mode) != 0) {
10482 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10483 "%s: ddi_copyout failed. cmd=%x",
10484 emlxs_dfc_xlate(dfc->cmd), mb4->mbxCommand);
10485
10486 rval = DFC_COPYIN_ERROR;
10487 goto done;
10488 }
10489 }
10490done:
10491 /* Free allocated memory */
10492 if (bufinfo.virt) {
10493 emlxs_mem_free(hba, &bufinfo);
10494 }
10495
10496 if (mbq) {
10497 kmem_free(mbq, sizeof (MAILBOXQ));
10498 }
10499
10500 return (rval);
10501} /* emlxs_dfc_send_mbox4() */
10502
10503
10504static int
10505emlxs_dfc_rd_be_fcf(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
10506{
10507 emlxs_port_t *port = &PPORT;
10508 MATCHMAP *mp;
10509 MAILBOX4 *mb = NULL;
10510 MAILBOXQ *mbq = NULL;
10511 IOCTL_FCOE_READ_FCF_TABLE *fcf;
10512 mbox_req_hdr_t *hdr_req;
10513 FCF_RECORD_t *fcfrec;
10514 int32_t rc = 0;
10515 uint32_t rval = 0;
10516 uint16_t index;
10517
10518 if (!dfc->buf1 || !dfc->buf1_size) {
10519 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10520 "%s: Null buffer1 found.", emlxs_dfc_xlate(dfc->cmd));
10521
10522 return (DFC_ARG_NULL);
10523 }
10524
10525 mbq =
10526 (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP);
10527
10528 index = dfc->data1;
10529 mb = (MAILBOX4 *)mbq;
10530
10531 bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE);
10532
10533 if ((mp = (MATCHMAP *)emlxs_mem_get(hba, MEM_BUF, 1)) == 0) {
10534 rval = DFC_SYSRES_ERROR;
10535 goto done;
10536 }
10537 /*
10538 * Save address for completion
10539 * Signifies a non-embedded command
10540 */
10541 mb->un.varSLIConfig.be.embedded = 0;
10542 mbq->nonembed = (uint8_t *)mp;
10543 mbq->mbox_cmpl = NULL;
10544
10545 mb->mbxCommand = MBX_SLI_CONFIG;
10546 mb->mbxOwner = OWN_HOST;
10547
10548 hdr_req = (mbox_req_hdr_t *)mp->virt;
10549 hdr_req->subsystem = IOCTL_SUBSYSTEM_FCOE;
10550 hdr_req->opcode = FCOE_OPCODE_READ_FCF_TABLE;
10551 hdr_req->timeout = 0;
10552 hdr_req->req_length = sizeof (IOCTL_FCOE_READ_FCF_TABLE);
10553 fcf = (IOCTL_FCOE_READ_FCF_TABLE *)(hdr_req + 1);
10554 fcf->params.request.fcf_index = index;
10555
10556 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
10557 if (rc == MBX_SUCCESS) {
10558 fcfrec = &fcf->params.response.fcf_entry[0];
10559 if (ddi_copyout((void *)fcfrec, (void *)dfc->buf1,
10560 dfc->buf1_size, mode) != 0) {
10561 rval = DFC_COPYOUT_ERROR;
10562 }
10563 if (ddi_copyout(
10564 (void *)&fcf->params.response.next_valid_fcf_index,
10565 (void *)dfc->buf2, dfc->buf2_size, mode) != 0) {
10566 rval = DFC_COPYOUT_ERROR;
10567 }
10568 } else {
10569 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10570 "%s: %s failed. mbxstatus=0x%x", emlxs_dfc_xlate(dfc->cmd),
10571 emlxs_mb_cmd_xlate(mb->mbxCommand), rc);
10572 rval = DFC_COPYOUT_ERROR;
10573 }
10574done:
10575 if (mp)
10576 (void) emlxs_mem_put(hba, MEM_BUF, (uint8_t *)mp);
10577 if (mbq)
10578 kmem_free(mbq, sizeof (MAILBOXQ));
10579
10580 return (rval);
10581}
10582
10583
10584/*ARGSUSED*/
10585static int
10586emlxs_dfc_set_be_dcbx(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
10587{
10588 emlxs_port_t *port = &PPORT;
10589 MAILBOXQ *mbq = NULL;
10590 MAILBOX4 *mb;
10591 IOCTL_COMMON_QUERY_FIRMWARE_CONFIG *fw_config;
10592 IOCTL_DCBX_SET_DCBX_MODE *dcbx_mode;
10593 uint32_t port_num;
10594 uint32_t rval = 0;
10595
10596 mbq =
10597 (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP);
10598
10599 mb = (MAILBOX4 *)mbq;
10600
10601 /*
10602 * Signifies an embedded command
10603 */
10604 mb->un.varSLIConfig.be.embedded = 1;
10605 mbq->mbox_cmpl = NULL;
10606
10607 mb->mbxCommand = MBX_SLI_CONFIG;
10608 mb->mbxOwner = OWN_HOST;
10609 mb->un.varSLIConfig.be.payload_length = IOCTL_HEADER_SZ;
10610 mb->un.varSLIConfig.be.un_hdr.hdr_req.subsystem =
10611 IOCTL_SUBSYSTEM_COMMON;
10612 mb->un.varSLIConfig.be.un_hdr.hdr_req.opcode =
10613 COMMON_OPCODE_QUERY_FIRMWARE_CONFIG;
10614 mb->un.varSLIConfig.be.un_hdr.hdr_req.timeout = 0;
10615 mb->un.varSLIConfig.be.un_hdr.hdr_req.req_length =
10616 sizeof (IOCTL_COMMON_QUERY_FIRMWARE_CONFIG);
10617
10618 rval = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
10619 if (rval != MBX_SUCCESS) {
10620 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10621 "%s: %s failed. mbxstatus=0x%x", emlxs_dfc_xlate(dfc->cmd),
10622 emlxs_mb_cmd_xlate(mb->mbxCommand), rval);
10623
10624 rval = DFC_DRV_ERROR;
10625 goto done;
10626 }
10627
10628 fw_config =
10629 (IOCTL_COMMON_QUERY_FIRMWARE_CONFIG *)&mb->un.varSLIConfig.payload;
10630 port_num = fw_config->params.response.PhysicalPort;
10631
10632 bzero((void *)mb, sizeof (MAILBOX4));
10633 mb->un.varSLIConfig.be.embedded = 1;
10634 mbq->mbox_cmpl = NULL;
10635
10636 mb->mbxCommand = MBX_SLI_CONFIG;
10637 mb->mbxOwner = OWN_HOST;
10638 mb->un.varSLIConfig.be.payload_length = IOCTL_HEADER_SZ;
10639 mb->un.varSLIConfig.be.un_hdr.hdr_req.subsystem =
10640 IOCTL_SUBSYSTEM_DCBX;
10641 mb->un.varSLIConfig.be.un_hdr.hdr_req.opcode =
10642 DCBX_OPCODE_SET_DCBX_MODE;
10643 mb->un.varSLIConfig.be.un_hdr.hdr_req.timeout = 0;
10644 mb->un.varSLIConfig.be.un_hdr.hdr_req.req_length =
10645 sizeof (IOCTL_DCBX_SET_DCBX_MODE);
10646 dcbx_mode = (IOCTL_DCBX_SET_DCBX_MODE *)&mb->un.varSLIConfig.payload;
10647 dcbx_mode->params.request.port_num = port_num;
10648 dcbx_mode->params.request.dcbx_mode = dfc->data1;
10649
10650 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
10651 "%s requested on port %d.", emlxs_dfc_xlate(dfc->cmd), port_num);
10652 rval = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
10653 if (rval != MBX_SUCCESS) {
10654 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10655 "%s: %s failed. mbxstatus=0x%x", emlxs_dfc_xlate(dfc->cmd),
10656 emlxs_mb_cmd_xlate(mb->mbxCommand), rval);
10657
10658 rval = DFC_DRV_ERROR;
10659 }
10660
10661done:
10662 if (mbq)
10663 kmem_free(mbq, sizeof (MAILBOXQ));
10664
10665 return (rval);
10666}
10667
10668
10669static int
10670emlxs_dfc_get_be_dcbx(emlxs_hba_t *hba, dfc_t *dfc, int32_t mode)
10671{
10672 emlxs_port_t *port = &PPORT;
10673 MAILBOXQ *mbq = NULL;
10674 MAILBOX4 *mb;
10675 IOCTL_COMMON_QUERY_FIRMWARE_CONFIG *fw_config;
10676 IOCTL_DCBX_GET_DCBX_MODE *dcbx_mode;
10677 uint32_t port_num;
10678 uint32_t rval = 0;
10679
10680 mbq =
10681 (MAILBOXQ *)kmem_zalloc(sizeof (MAILBOXQ), KM_SLEEP);
10682
10683 mb = (MAILBOX4 *)mbq;
10684
10685 /*
10686 * Signifies an embedded command
10687 */
10688 mb->un.varSLIConfig.be.embedded = 1;
10689 mbq->mbox_cmpl = NULL;
10690
10691 mb->mbxCommand = MBX_SLI_CONFIG;
10692 mb->mbxOwner = OWN_HOST;
10693 mb->un.varSLIConfig.be.payload_length = IOCTL_HEADER_SZ;
10694 mb->un.varSLIConfig.be.un_hdr.hdr_req.subsystem =
10695 IOCTL_SUBSYSTEM_COMMON;
10696 mb->un.varSLIConfig.be.un_hdr.hdr_req.opcode =
10697 COMMON_OPCODE_QUERY_FIRMWARE_CONFIG;
10698 mb->un.varSLIConfig.be.un_hdr.hdr_req.timeout = 0;
10699 mb->un.varSLIConfig.be.un_hdr.hdr_req.req_length =
10700 sizeof (IOCTL_COMMON_QUERY_FIRMWARE_CONFIG);
10701
10702 rval = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
10703 if (rval != MBX_SUCCESS) {
10704 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10705 "%s: %s failed. mbxstatus=0x%x", emlxs_dfc_xlate(dfc->cmd),
10706 emlxs_mb_cmd_xlate(mb->mbxCommand), rval);
10707
10708 rval = DFC_DRV_ERROR;
10709 goto done;
10710 }
10711
10712 fw_config =
10713 (IOCTL_COMMON_QUERY_FIRMWARE_CONFIG *)&mb->un.varSLIConfig.payload;
10714 port_num = fw_config->params.response.PhysicalPort;
10715
10716 bzero((void *)mb, sizeof (MAILBOX4));
10717 mb->un.varSLIConfig.be.embedded = 1;
10718 mbq->mbox_cmpl = NULL;
10719
10720 mb->mbxCommand = MBX_SLI_CONFIG;
10721 mb->mbxOwner = OWN_HOST;
10722 mb->un.varSLIConfig.be.payload_length = IOCTL_HEADER_SZ;
10723 mb->un.varSLIConfig.be.un_hdr.hdr_req.subsystem =
10724 IOCTL_SUBSYSTEM_DCBX;
10725 mb->un.varSLIConfig.be.un_hdr.hdr_req.opcode =
10726 DCBX_OPCODE_GET_DCBX_MODE;
10727 mb->un.varSLIConfig.be.un_hdr.hdr_req.timeout = 0;
10728 mb->un.varSLIConfig.be.un_hdr.hdr_req.req_length =
10729 sizeof (IOCTL_DCBX_SET_DCBX_MODE);
10730 dcbx_mode = (IOCTL_DCBX_GET_DCBX_MODE *)&mb->un.varSLIConfig.payload;
10731 dcbx_mode->params.request.port_num = port_num;
10732
10733 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_detail_msg,
10734 "%s requested on port %d.", emlxs_dfc_xlate(dfc->cmd), port_num);
10735 rval = EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0);
10736 if (rval != MBX_SUCCESS) {
10737 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_dfc_error_msg,
10738 "%s: %s failed. mbxstatus=0x%x", emlxs_dfc_xlate(dfc->cmd),
10739 emlxs_mb_cmd_xlate(mb->mbxCommand), rval);
10740
10741 rval = DFC_DRV_ERROR;
10742 goto done;
10743 }
10744
10745 if (ddi_copyout((void *)&dcbx_mode->params.response.dcbx_mode,
10746 (void *)dfc->buf1, dfc->buf1_size, mode) != 0) {
10747 rval = DFC_COPYOUT_ERROR;
10748 }
10749
10750done:
10751 if (mbq)
10752 kmem_free(mbq, sizeof (MAILBOXQ));
10753
10754 return (rval);
10755}