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