emlxs_solaris.c (a9800beb) | emlxs_solaris.c (8f23e9fa) |
---|---|
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 * | 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 9 * or http://www.opensolaris.org/os/licensing. | 8 * You can obtain a copy of the license at 9 * http://www.opensource.org/licenses/cddl1.txt. |
10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22/* | 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22/* |
23 * Copyright 2010 Emulex. All rights reserved. | 23 * Copyright (c) 2004-2012 Emulex. All rights reserved. |
24 * Use is subject to license terms. | 24 * Use is subject to license terms. |
25 * Copyright (c) 2011 Bayard G. Bell. All rights reserved. | |
26 */ 27 | 25 */ 26 |
28 | |
29#define DEF_ICFG 1 30 31#include <emlxs.h> 32#include <emlxs_version.h> 33 34 | 27#define DEF_ICFG 1 28 29#include <emlxs.h> 30#include <emlxs_version.h> 31 32 |
33static char emlxs_copyright[] = EMLXS_COPYRIGHT; |
|
35char emlxs_revision[] = EMLXS_REVISION; 36char emlxs_version[] = EMLXS_VERSION; 37char emlxs_name[] = EMLXS_NAME; 38char emlxs_label[] = EMLXS_LABEL; 39 40/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */ 41EMLXS_MSG_DEF(EMLXS_SOLARIS_C); 42 --- 23 unchanged lines hidden (view full) --- 66 uint32_t failed); 67static void emlxs_iodone_server(void *arg1, void *arg2, void *arg3); 68static uint32_t emlxs_integrity_check(emlxs_hba_t *hba); 69static uint32_t emlxs_test(emlxs_hba_t *hba, uint32_t test_code, 70 uint32_t args, uint32_t *arg); 71 72#if (EMLXS_MODREV >= EMLXS_MODREV3) && (EMLXS_MODREV <= EMLXS_MODREV4) 73static void emlxs_read_vport_prop(emlxs_hba_t *hba); | 34char emlxs_revision[] = EMLXS_REVISION; 35char emlxs_version[] = EMLXS_VERSION; 36char emlxs_name[] = EMLXS_NAME; 37char emlxs_label[] = EMLXS_LABEL; 38 39/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */ 40EMLXS_MSG_DEF(EMLXS_SOLARIS_C); 41 --- 23 unchanged lines hidden (view full) --- 65 uint32_t failed); 66static void emlxs_iodone_server(void *arg1, void *arg2, void *arg3); 67static uint32_t emlxs_integrity_check(emlxs_hba_t *hba); 68static uint32_t emlxs_test(emlxs_hba_t *hba, uint32_t test_code, 69 uint32_t args, uint32_t *arg); 70 71#if (EMLXS_MODREV >= EMLXS_MODREV3) && (EMLXS_MODREV <= EMLXS_MODREV4) 72static void emlxs_read_vport_prop(emlxs_hba_t *hba); |
74#endif /* EMLXS_MODREV3 || EMLXS_MODREV4 */ | 73#endif /* EMLXS_MODREV3 && EMLXS_MODREV4 */ |
75 | 74 |
75static void emlxs_mode_init_masks(emlxs_hba_t *hba); |
|
76 77 78extern int 79emlxs_msiid_to_chan(emlxs_hba_t *hba, int msi_id); 80extern int 81emlxs_select_msiid(emlxs_hba_t *hba); | 76 77 78extern int 79emlxs_msiid_to_chan(emlxs_hba_t *hba, int msi_id); 80extern int 81emlxs_select_msiid(emlxs_hba_t *hba); |
82extern void 83emlxs_sli4_zero_queue_stat(emlxs_hba_t *hba); |
|
82 83/* 84 * Driver Entry Routines. 85 */ 86static int32_t emlxs_detach(dev_info_t *, ddi_detach_cmd_t); 87static int32_t emlxs_attach(dev_info_t *, ddi_attach_cmd_t); 88static int32_t emlxs_open(dev_t *, int32_t, int32_t, cred_t *); 89static int32_t emlxs_close(dev_t, int32_t, int32_t, cred_t *); --- 24 unchanged lines hidden (view full) --- 114 * Driver Internal Functions. 115 */ 116 117static void emlxs_poll(emlxs_port_t *, emlxs_buf_t *); 118static int32_t emlxs_power(dev_info_t *, int32_t, int32_t); 119#ifdef EMLXS_I386 120#ifdef S11 121static int32_t emlxs_quiesce(dev_info_t *); | 84 85/* 86 * Driver Entry Routines. 87 */ 88static int32_t emlxs_detach(dev_info_t *, ddi_detach_cmd_t); 89static int32_t emlxs_attach(dev_info_t *, ddi_attach_cmd_t); 90static int32_t emlxs_open(dev_t *, int32_t, int32_t, cred_t *); 91static int32_t emlxs_close(dev_t, int32_t, int32_t, cred_t *); --- 24 unchanged lines hidden (view full) --- 116 * Driver Internal Functions. 117 */ 118 119static void emlxs_poll(emlxs_port_t *, emlxs_buf_t *); 120static int32_t emlxs_power(dev_info_t *, int32_t, int32_t); 121#ifdef EMLXS_I386 122#ifdef S11 123static int32_t emlxs_quiesce(dev_info_t *); |
122#endif 123#endif | 124#endif /* S11 */ 125#endif /* EMLXS_I386 */ |
124static int32_t emlxs_hba_resume(dev_info_t *); 125static int32_t emlxs_hba_suspend(dev_info_t *); 126static int32_t emlxs_hba_detach(dev_info_t *); 127static int32_t emlxs_hba_attach(dev_info_t *); 128static void emlxs_lock_destroy(emlxs_hba_t *); 129static void emlxs_lock_init(emlxs_hba_t *); 130 131char *emlxs_pm_components[] = { | 126static int32_t emlxs_hba_resume(dev_info_t *); 127static int32_t emlxs_hba_suspend(dev_info_t *); 128static int32_t emlxs_hba_detach(dev_info_t *); 129static int32_t emlxs_hba_attach(dev_info_t *); 130static void emlxs_lock_destroy(emlxs_hba_t *); 131static void emlxs_lock_init(emlxs_hba_t *); 132 133char *emlxs_pm_components[] = { |
132 "NAME=emlxx000", | 134 "NAME=" DRIVER_NAME "000", |
133 "0=Device D3 State", 134 "1=Device D0 State" 135}; 136 137 138/* 139 * Default emlx dma limits 140 */ --- 21 unchanged lines hidden (view full) --- 162 (uint64_t)0, /* dma_attr_addr_lo */ 163 (uint64_t)0xffffffffffffffff, /* dma_attr_addr_hi */ 164 (uint64_t)0x00ffffff, /* dma_attr_count_max */ 165 1, /* dma_attr_align */ 166 DEFAULT_BURSTSIZE | BURST32 | BURST64, /* dma_attr_burstsizes */ 167 1, /* dma_attr_minxfer */ 168 (uint64_t)0x00ffffff, /* dma_attr_maxxfer */ 169 (uint64_t)0xffffffff, /* dma_attr_seg */ | 135 "0=Device D3 State", 136 "1=Device D0 State" 137}; 138 139 140/* 141 * Default emlx dma limits 142 */ --- 21 unchanged lines hidden (view full) --- 164 (uint64_t)0, /* dma_attr_addr_lo */ 165 (uint64_t)0xffffffffffffffff, /* dma_attr_addr_hi */ 166 (uint64_t)0x00ffffff, /* dma_attr_count_max */ 167 1, /* dma_attr_align */ 168 DEFAULT_BURSTSIZE | BURST32 | BURST64, /* dma_attr_burstsizes */ 169 1, /* dma_attr_minxfer */ 170 (uint64_t)0x00ffffff, /* dma_attr_maxxfer */ 171 (uint64_t)0xffffffff, /* dma_attr_seg */ |
170 EMLXS_SGLLEN, /* dma_attr_sgllen */ | 172 1, /* dma_attr_sgllen */ |
171 1, /* dma_attr_granular */ 172 0 /* dma_attr_flags */ 173}; 174 175ddi_dma_attr_t emlxs_dma_attr_ro = { 176 DMA_ATTR_V0, /* dma_attr_version */ 177 (uint64_t)0, /* dma_attr_addr_lo */ 178 (uint64_t)0xffffffffffffffff, /* dma_attr_addr_hi */ 179 (uint64_t)0x00ffffff, /* dma_attr_count_max */ 180 1, /* dma_attr_align */ 181 DEFAULT_BURSTSIZE | BURST32 | BURST64, /* dma_attr_burstsizes */ 182 1, /* dma_attr_minxfer */ 183 (uint64_t)0x00ffffff, /* dma_attr_maxxfer */ 184 (uint64_t)0xffffffff, /* dma_attr_seg */ | 173 1, /* dma_attr_granular */ 174 0 /* dma_attr_flags */ 175}; 176 177ddi_dma_attr_t emlxs_dma_attr_ro = { 178 DMA_ATTR_V0, /* dma_attr_version */ 179 (uint64_t)0, /* dma_attr_addr_lo */ 180 (uint64_t)0xffffffffffffffff, /* dma_attr_addr_hi */ 181 (uint64_t)0x00ffffff, /* dma_attr_count_max */ 182 1, /* dma_attr_align */ 183 DEFAULT_BURSTSIZE | BURST32 | BURST64, /* dma_attr_burstsizes */ 184 1, /* dma_attr_minxfer */ 185 (uint64_t)0x00ffffff, /* dma_attr_maxxfer */ 186 (uint64_t)0xffffffff, /* dma_attr_seg */ |
185 EMLXS_SGLLEN, /* dma_attr_sgllen */ | 187 1, /* dma_attr_sgllen */ |
186 1, /* dma_attr_granular */ 187 DDI_DMA_RELAXED_ORDERING /* dma_attr_flags */ 188}; 189 190ddi_dma_attr_t emlxs_dma_attr_1sg = { 191 DMA_ATTR_V0, /* dma_attr_version */ 192 (uint64_t)0, /* dma_attr_addr_lo */ 193 (uint64_t)0xffffffffffffffff, /* dma_attr_addr_hi */ --- 14 unchanged lines hidden (view full) --- 208 (uint64_t)0, /* dma_attr_addr_lo */ 209 (uint64_t)0xffffffffffffffff, /* dma_attr_addr_hi */ 210 (uint64_t)0x00ffffff, /* dma_attr_count_max */ 211 1, /* dma_attr_align */ 212 DEFAULT_BURSTSIZE | BURST32 | BURST64, /* dma_attr_burstsizes */ 213 1, /* dma_attr_minxfer */ 214 (uint64_t)0x00ffffff, /* dma_attr_maxxfer */ 215 (uint64_t)0xffffffff, /* dma_attr_seg */ | 188 1, /* dma_attr_granular */ 189 DDI_DMA_RELAXED_ORDERING /* dma_attr_flags */ 190}; 191 192ddi_dma_attr_t emlxs_dma_attr_1sg = { 193 DMA_ATTR_V0, /* dma_attr_version */ 194 (uint64_t)0, /* dma_attr_addr_lo */ 195 (uint64_t)0xffffffffffffffff, /* dma_attr_addr_hi */ --- 14 unchanged lines hidden (view full) --- 210 (uint64_t)0, /* dma_attr_addr_lo */ 211 (uint64_t)0xffffffffffffffff, /* dma_attr_addr_hi */ 212 (uint64_t)0x00ffffff, /* dma_attr_count_max */ 213 1, /* dma_attr_align */ 214 DEFAULT_BURSTSIZE | BURST32 | BURST64, /* dma_attr_burstsizes */ 215 1, /* dma_attr_minxfer */ 216 (uint64_t)0x00ffffff, /* dma_attr_maxxfer */ 217 (uint64_t)0xffffffff, /* dma_attr_seg */ |
216 EMLXS_SGLLEN, /* dma_attr_sgllen */ | 218 1, /* dma_attr_sgllen */ |
217 1, /* dma_attr_granular */ 218 0 /* dma_attr_flags */ 219}; 220#endif /* >= EMLXS_MODREV3 */ 221 222/* 223 * DDI access attributes for device 224 */ --- 159 unchanged lines hidden (view full) --- 384 emlxs_fca_pkt_abort, 385 emlxs_fca_reset, 386 emlxs_fca_port_manage, 387 emlxs_fca_get_device, 388 emlxs_fca_notify 389}; 390#endif /* EMLXS_MODREV2 */ 391 | 219 1, /* dma_attr_granular */ 220 0 /* dma_attr_flags */ 221}; 222#endif /* >= EMLXS_MODREV3 */ 223 224/* 225 * DDI access attributes for device 226 */ --- 159 unchanged lines hidden (view full) --- 386 emlxs_fca_pkt_abort, 387 emlxs_fca_reset, 388 emlxs_fca_port_manage, 389 emlxs_fca_get_device, 390 emlxs_fca_notify 391}; 392#endif /* EMLXS_MODREV2 */ 393 |
394 |
|
392/* 393 * state pointer which the implementation uses as a place to 394 * hang a set of per-driver structures; 395 * 396 */ 397void *emlxs_soft_state = NULL; 398 399/* --- 5 unchanged lines hidden (view full) --- 405 406uint32_t emlxs_instance[MAX_FC_BRDS]; /* uses emlxs_device.lock */ 407uint32_t emlxs_instance_count = 0; /* uses emlxs_device.lock */ 408uint32_t emlxs_instance_flag = 0; /* uses emlxs_device.lock */ 409#define EMLXS_FW_SHOW 0x00000001 410 411 412/* | 395/* 396 * state pointer which the implementation uses as a place to 397 * hang a set of per-driver structures; 398 * 399 */ 400void *emlxs_soft_state = NULL; 401 402/* --- 5 unchanged lines hidden (view full) --- 408 409uint32_t emlxs_instance[MAX_FC_BRDS]; /* uses emlxs_device.lock */ 410uint32_t emlxs_instance_count = 0; /* uses emlxs_device.lock */ 411uint32_t emlxs_instance_flag = 0; /* uses emlxs_device.lock */ 412#define EMLXS_FW_SHOW 0x00000001 413 414 415/* |
413 * Single private "global" lock used to gain access to 414 * the hba_list and/or any other case where we want need to be 415 * single-threaded. 416 */ 417uint32_t emlxs_diag_state; 418 419/* | |
420 * CB ops vector. Used for administration only. 421 */ 422static struct cb_ops emlxs_cb_ops = { 423 emlxs_open, /* cb_open */ 424 emlxs_close, /* cb_close */ 425 nodev, /* cb_strategy */ 426 nodev, /* cb_print */ 427 nodev, /* cb_dump */ --- 26 unchanged lines hidden (view full) --- 454 emlxs_detach, /* detach */ 455 nodev, /* reset */ 456 &emlxs_cb_ops, /* devo_cb_ops */ 457 NULL, /* devo_bus_ops */ 458 emlxs_power, /* power ops */ 459#ifdef EMLXS_I386 460#ifdef S11 461 emlxs_quiesce, /* quiesce */ | 416 * CB ops vector. Used for administration only. 417 */ 418static struct cb_ops emlxs_cb_ops = { 419 emlxs_open, /* cb_open */ 420 emlxs_close, /* cb_close */ 421 nodev, /* cb_strategy */ 422 nodev, /* cb_print */ 423 nodev, /* cb_dump */ --- 26 unchanged lines hidden (view full) --- 450 emlxs_detach, /* detach */ 451 nodev, /* reset */ 452 &emlxs_cb_ops, /* devo_cb_ops */ 453 NULL, /* devo_bus_ops */ 454 emlxs_power, /* power ops */ 455#ifdef EMLXS_I386 456#ifdef S11 457 emlxs_quiesce, /* quiesce */ |
462#endif 463#endif | 458#endif /* S11 */ 459#endif /* EMLXS_I386 */ |
464}; 465 466#include <sys/modctl.h> 467extern struct mod_ops mod_driverops; 468 469#ifdef SAN_DIAG_SUPPORT | 460}; 461 462#include <sys/modctl.h> 463extern struct mod_ops mod_driverops; 464 465#ifdef SAN_DIAG_SUPPORT |
470extern kmutex_t sd_bucket_mutex; 471extern sd_bucket_info_t sd_bucket; | 466extern kmutex_t emlxs_sd_bucket_mutex; 467extern sd_bucket_info_t emlxs_sd_bucket; |
472#endif /* SAN_DIAG_SUPPORT */ 473 474/* 475 * Module linkage information for the kernel. 476 */ 477static struct modldrv emlxs_modldrv = { 478 &mod_driverops, /* module type - driver */ 479 emlxs_name, /* module name */ --- 45 unchanged lines hidden (view full) --- 525 {IOSTAT_DATA_OVERRUN, FC_PKT_TRAN_ERROR, FC_REASON_OVERRUN, 526 FC_EXPLN_NONE, FC_ACTION_RETRYABLE}, 527 528 /* Special error code */ 529 /* 0x11 */ 530 {IOSTAT_DATA_UNDERRUN, FC_PKT_TRAN_ERROR, FC_REASON_ABORTED, 531 FC_EXPLN_NONE, FC_ACTION_RETRYABLE}, 532 | 468#endif /* SAN_DIAG_SUPPORT */ 469 470/* 471 * Module linkage information for the kernel. 472 */ 473static struct modldrv emlxs_modldrv = { 474 &mod_driverops, /* module type - driver */ 475 emlxs_name, /* module name */ --- 45 unchanged lines hidden (view full) --- 521 {IOSTAT_DATA_OVERRUN, FC_PKT_TRAN_ERROR, FC_REASON_OVERRUN, 522 FC_EXPLN_NONE, FC_ACTION_RETRYABLE}, 523 524 /* Special error code */ 525 /* 0x11 */ 526 {IOSTAT_DATA_UNDERRUN, FC_PKT_TRAN_ERROR, FC_REASON_ABORTED, 527 FC_EXPLN_NONE, FC_ACTION_RETRYABLE}, 528 |
529 /* Special error code */ 530 /* 0x12 */ 531 {IOSTAT_RSP_INVALID, FC_PKT_TRAN_ERROR, FC_REASON_ABORTED, 532 FC_EXPLN_NONE, FC_ACTION_RETRYABLE}, 533 |
|
533 /* CLASS 2 only */ 534 /* 0x04 */ 535 {IOSTAT_NPORT_RJT, FC_PKT_NPORT_RJT, FC_REASON_PROTOCOL_ERROR, 536 FC_EXPLN_NONE, FC_ACTION_RETRYABLE}, 537 538 /* CLASS 2 only */ 539 /* 0x05 */ 540 {IOSTAT_FABRIC_RJT, FC_PKT_FABRIC_RJT, FC_REASON_PROTOCOL_ERROR, --- 175 unchanged lines hidden (view full) --- 716 {IOSTAT_FABRIC_BSY, "Fabric busy."}, 717 {IOSTAT_INTERMED_RSP, "Intermediate response."}, 718 {IOSTAT_LS_RJT, "LS reject."}, 719 {IOSTAT_CMD_REJECT, "Cmd reject."}, 720 {IOSTAT_FCP_TGT_LENCHK, "TGT length check."}, 721 {IOSTAT_NEED_BUFF_ENTRY, "Need buffer entry."}, 722 {IOSTAT_DATA_UNDERRUN, "Data underrun."}, 723 {IOSTAT_DATA_OVERRUN, "Data overrun."}, | 534 /* CLASS 2 only */ 535 /* 0x04 */ 536 {IOSTAT_NPORT_RJT, FC_PKT_NPORT_RJT, FC_REASON_PROTOCOL_ERROR, 537 FC_EXPLN_NONE, FC_ACTION_RETRYABLE}, 538 539 /* CLASS 2 only */ 540 /* 0x05 */ 541 {IOSTAT_FABRIC_RJT, FC_PKT_FABRIC_RJT, FC_REASON_PROTOCOL_ERROR, --- 175 unchanged lines hidden (view full) --- 717 {IOSTAT_FABRIC_BSY, "Fabric busy."}, 718 {IOSTAT_INTERMED_RSP, "Intermediate response."}, 719 {IOSTAT_LS_RJT, "LS reject."}, 720 {IOSTAT_CMD_REJECT, "Cmd reject."}, 721 {IOSTAT_FCP_TGT_LENCHK, "TGT length check."}, 722 {IOSTAT_NEED_BUFF_ENTRY, "Need buffer entry."}, 723 {IOSTAT_DATA_UNDERRUN, "Data underrun."}, 724 {IOSTAT_DATA_OVERRUN, "Data overrun."}, |
725 {IOSTAT_RSP_INVALID, "Response Invalid."}, |
|
724 725}; /* emlxs_state_table */ 726 727 728#ifdef MENLO_SUPPORT 729emlxs_table_t emlxs_menlo_cmd_table[] = { 730 {MENLO_CMD_INITIALIZE, "MENLO_INIT"}, 731 {MENLO_CMD_FW_DOWNLOAD, "MENLO_FW_DOWNLOAD"}, --- 241 unchanged lines hidden (view full) --- 973 {ELS_CMD_SCR, "SCR"}, 974 {ELS_CMD_LINIT, "LINIT"}, 975 {ELS_CMD_RNID, "RNID"}, 976 {ELS_CMD_AUTH, "AUTH"} 977 978}; /* emlxs_elscmd_table */ 979 980 | 726 727}; /* emlxs_state_table */ 728 729 730#ifdef MENLO_SUPPORT 731emlxs_table_t emlxs_menlo_cmd_table[] = { 732 {MENLO_CMD_INITIALIZE, "MENLO_INIT"}, 733 {MENLO_CMD_FW_DOWNLOAD, "MENLO_FW_DOWNLOAD"}, --- 241 unchanged lines hidden (view full) --- 975 {ELS_CMD_SCR, "SCR"}, 976 {ELS_CMD_LINIT, "LINIT"}, 977 {ELS_CMD_RNID, "RNID"}, 978 {ELS_CMD_AUTH, "AUTH"} 979 980}; /* emlxs_elscmd_table */ 981 982 |
983emlxs_table_t emlxs_mode_table[] = { 984 {MODE_NONE, "NONE"}, 985 {MODE_INITIATOR, "INITIATOR"}, 986 {MODE_TARGET, "TARGET"}, 987 {MODE_ALL, "INITIATOR | TARGET"} 988}; /* emlxs_mode_table */ 989 |
|
981/* 982 * 983 * Device Driver Entry Routines 984 * 985 */ 986 987#ifdef MODSYM_SUPPORT 988static void emlxs_fca_modclose(); --- 87 unchanged lines hidden (view full) --- 1076 1077/* 1078 * Global driver initialization, called once when driver is loaded 1079 */ 1080int 1081_init(void) 1082{ 1083 int ret; | 990/* 991 * 992 * Device Driver Entry Routines 993 * 994 */ 995 996#ifdef MODSYM_SUPPORT 997static void emlxs_fca_modclose(); --- 87 unchanged lines hidden (view full) --- 1085 1086/* 1087 * Global driver initialization, called once when driver is loaded 1088 */ 1089int 1090_init(void) 1091{ 1092 int ret; |
1084 char buf[64]; | |
1085 1086 /* 1087 * First init call for this driver, 1088 * so initialize the emlxs_dev_ctl structure. 1089 */ 1090 bzero(&emlxs_device, sizeof (emlxs_device)); 1091 1092#ifdef MODSYM_SUPPORT 1093 bzero(&emlxs_modsym, sizeof (emlxs_modsym_t)); 1094#endif /* MODSYM_SUPPORT */ 1095 | 1093 1094 /* 1095 * First init call for this driver, 1096 * so initialize the emlxs_dev_ctl structure. 1097 */ 1098 bzero(&emlxs_device, sizeof (emlxs_device)); 1099 1100#ifdef MODSYM_SUPPORT 1101 bzero(&emlxs_modsym, sizeof (emlxs_modsym_t)); 1102#endif /* MODSYM_SUPPORT */ 1103 |
1096 (void) sprintf(buf, "%s_device mutex", DRIVER_NAME); 1097 mutex_init(&emlxs_device.lock, buf, MUTEX_DRIVER, NULL); | 1104 mutex_init(&emlxs_device.lock, NULL, MUTEX_DRIVER, NULL); |
1098 1099 (void) drv_getparm(LBOLT, &emlxs_device.log_timestamp); 1100 emlxs_device.drv_timestamp = ddi_get_time(); 1101 1102 for (ret = 0; ret < MAX_FC_BRDS; ret++) { 1103 emlxs_instance[ret] = (uint32_t)-1; 1104 } 1105 --- 24 unchanged lines hidden (view full) --- 1130 /* Close SFS */ 1131 emlxs_fca_modclose(); 1132#endif /* MODSYM_SUPPORT */ 1133 1134 return (ret); 1135 } 1136 1137#ifdef SAN_DIAG_SUPPORT | 1105 1106 (void) drv_getparm(LBOLT, &emlxs_device.log_timestamp); 1107 emlxs_device.drv_timestamp = ddi_get_time(); 1108 1109 for (ret = 0; ret < MAX_FC_BRDS; ret++) { 1110 emlxs_instance[ret] = (uint32_t)-1; 1111 } 1112 --- 24 unchanged lines hidden (view full) --- 1137 /* Close SFS */ 1138 emlxs_fca_modclose(); 1139#endif /* MODSYM_SUPPORT */ 1140 1141 return (ret); 1142 } 1143 1144#ifdef SAN_DIAG_SUPPORT |
1138 (void) sprintf(buf, "%s_sd_bucket mutex", DRIVER_NAME); 1139 mutex_init(&sd_bucket_mutex, buf, MUTEX_DRIVER, NULL); | 1145 mutex_init(&emlxs_sd_bucket_mutex, NULL, MUTEX_DRIVER, NULL); |
1140#endif /* SAN_DIAG_SUPPORT */ 1141 1142 return (ret); 1143 1144} /* _init() */ 1145 1146 1147/* --- 16 unchanged lines hidden (view full) --- 1164 * Destroy the soft state structure 1165 */ 1166 (void) ddi_soft_state_fini(&emlxs_soft_state); 1167 1168 /* Destroy the global device lock */ 1169 mutex_destroy(&emlxs_device.lock); 1170 1171#ifdef SAN_DIAG_SUPPORT | 1146#endif /* SAN_DIAG_SUPPORT */ 1147 1148 return (ret); 1149 1150} /* _init() */ 1151 1152 1153/* --- 16 unchanged lines hidden (view full) --- 1170 * Destroy the soft state structure 1171 */ 1172 (void) ddi_soft_state_fini(&emlxs_soft_state); 1173 1174 /* Destroy the global device lock */ 1175 mutex_destroy(&emlxs_device.lock); 1176 1177#ifdef SAN_DIAG_SUPPORT |
1172 mutex_destroy(&sd_bucket_mutex); | 1178 mutex_destroy(&emlxs_sd_bucket_mutex); |
1173#endif /* SAN_DIAG_SUPPORT */ 1174 1175 return (ret); 1176 1177} /* _fini() */ 1178 1179 1180 --- 19 unchanged lines hidden (view full) --- 1200 int rval; 1201 1202 switch (cmd) { 1203 case DDI_ATTACH: 1204 /* If successful this will set EMLXS_PM_IN_ATTACH */ 1205 rval = emlxs_hba_attach(dip); 1206 break; 1207 | 1179#endif /* SAN_DIAG_SUPPORT */ 1180 1181 return (ret); 1182 1183} /* _fini() */ 1184 1185 1186 --- 19 unchanged lines hidden (view full) --- 1206 int rval; 1207 1208 switch (cmd) { 1209 case DDI_ATTACH: 1210 /* If successful this will set EMLXS_PM_IN_ATTACH */ 1211 rval = emlxs_hba_attach(dip); 1212 break; 1213 |
1208 case DDI_PM_RESUME: 1209 /* This will resume the driver */ 1210 rval = emlxs_pm_raise_power(dip); 1211 break; 1212 | |
1213 case DDI_RESUME: 1214 /* This will resume the driver */ 1215 rval = emlxs_hba_resume(dip); 1216 break; 1217 1218 default: 1219 rval = DDI_FAILURE; 1220 } --- 51 unchanged lines hidden (view full) --- 1272 1273 /* Check driver dump */ 1274 mutex_enter(&EMLXS_PORT_LOCK); 1275 1276 if (hba->flag & FC_DUMP_ACTIVE) { 1277 mutex_exit(&EMLXS_PORT_LOCK); 1278 1279 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_failed_msg, | 1214 case DDI_RESUME: 1215 /* This will resume the driver */ 1216 rval = emlxs_hba_resume(dip); 1217 break; 1218 1219 default: 1220 rval = DDI_FAILURE; 1221 } --- 51 unchanged lines hidden (view full) --- 1273 1274 /* Check driver dump */ 1275 mutex_enter(&EMLXS_PORT_LOCK); 1276 1277 if (hba->flag & FC_DUMP_ACTIVE) { 1278 mutex_exit(&EMLXS_PORT_LOCK); 1279 1280 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_failed_msg, |
1280 "emlxs_detach: Driver busy. Driver dump active."); | 1281 "detach: Driver busy. Driver dump active."); |
1281 1282 return (DDI_FAILURE); 1283 } 1284 1285#ifdef SFCT_SUPPORT | 1282 1283 return (DDI_FAILURE); 1284 } 1285 1286#ifdef SFCT_SUPPORT |
1286 if (port->tgt_mode && ((port->fct_flags & FCT_STATE_PORT_ONLINE) || | 1287 if ((port->flag & EMLXS_TGT_BOUND) && 1288 ((port->fct_flags & FCT_STATE_PORT_ONLINE) || |
1287 (port->fct_flags & FCT_STATE_NOT_ACKED))) { 1288 mutex_exit(&EMLXS_PORT_LOCK); 1289 1290 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_failed_msg, | 1289 (port->fct_flags & FCT_STATE_NOT_ACKED))) { 1290 mutex_exit(&EMLXS_PORT_LOCK); 1291 1292 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_failed_msg, |
1291 "emlxs_detach: Driver busy. Target mode active."); | 1293 "detach: Driver busy. Target mode active."); |
1292 1293 return (DDI_FAILURE); 1294 } 1295#endif /* SFCT_SUPPORT */ 1296 | 1294 1295 return (DDI_FAILURE); 1296 } 1297#endif /* SFCT_SUPPORT */ 1298 |
1297 if (port->ini_mode && (port->flag & EMLXS_PORT_BOUND)) { | 1299 if (port->flag & EMLXS_INI_BOUND) { |
1298 mutex_exit(&EMLXS_PORT_LOCK); 1299 1300 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_failed_msg, | 1300 mutex_exit(&EMLXS_PORT_LOCK); 1301 1302 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_failed_msg, |
1301 "emlxs_detach: Driver busy. Initiator mode active."); | 1303 "detach: Driver busy. Initiator mode active."); |
1302 1303 return (DDI_FAILURE); 1304 } 1305 1306 hba->flag &= ~FC_DUMP_SAFE; 1307 1308 mutex_exit(&EMLXS_PORT_LOCK); 1309 --- 6 unchanged lines hidden (view full) --- 1316 rval = emlxs_hba_detach(dip); 1317 1318 if (rval != DDI_SUCCESS) { 1319 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_failed_msg, 1320 "Unable to detach."); 1321 } 1322 break; 1323 | 1304 1305 return (DDI_FAILURE); 1306 } 1307 1308 hba->flag &= ~FC_DUMP_SAFE; 1309 1310 mutex_exit(&EMLXS_PORT_LOCK); 1311 --- 6 unchanged lines hidden (view full) --- 1318 rval = emlxs_hba_detach(dip); 1319 1320 if (rval != DDI_SUCCESS) { 1321 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_failed_msg, 1322 "Unable to detach."); 1323 } 1324 break; 1325 |
1324 1325 case DDI_PM_SUSPEND: 1326 1327 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_debug_msg, 1328 "DDI_PM_SUSPEND"); 1329 1330 /* This will suspend the driver */ 1331 rval = emlxs_pm_lower_power(dip); 1332 1333 if (rval != DDI_SUCCESS) { 1334 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_failed_msg, 1335 "Unable to lower power."); 1336 } 1337 1338 break; 1339 1340 | |
1341 case DDI_SUSPEND: 1342 1343 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_debug_msg, 1344 "DDI_SUSPEND"); 1345 1346 /* Suspend the driver */ 1347 rval = emlxs_hba_suspend(dip); 1348 1349 if (rval != DDI_SUCCESS) { 1350 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_failed_msg, 1351 "Unable to suspend driver."); 1352 } 1353 break; 1354 | 1326 case DDI_SUSPEND: 1327 1328 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_debug_msg, 1329 "DDI_SUSPEND"); 1330 1331 /* Suspend the driver */ 1332 rval = emlxs_hba_suspend(dip); 1333 1334 if (rval != DDI_SUCCESS) { 1335 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_failed_msg, 1336 "Unable to suspend driver."); 1337 } 1338 break; 1339 |
1355 | |
1356 default: 1357 cmn_err(CE_WARN, "?%s: Detach: Unknown cmd received. cmd=%x", 1358 DRIVER_NAME, cmd); 1359 rval = DDI_FAILURE; 1360 } 1361 1362 if (rval == DDI_FAILURE) { 1363 /* Re-Enable driver dump feature */ --- 18 unchanged lines hidden (view full) --- 1382 port->node_base.nlp_Rpi = 0; 1383 port->node_base.nlp_DID = 0xffffff; 1384 port->node_base.nlp_list_next = NULL; 1385 port->node_base.nlp_list_prev = NULL; 1386 port->node_base.nlp_active = 1; 1387 port->node_base.nlp_base = 1; 1388 port->node_count = 0; 1389 | 1340 default: 1341 cmn_err(CE_WARN, "?%s: Detach: Unknown cmd received. cmd=%x", 1342 DRIVER_NAME, cmd); 1343 rval = DDI_FAILURE; 1344 } 1345 1346 if (rval == DDI_FAILURE) { 1347 /* Re-Enable driver dump feature */ --- 18 unchanged lines hidden (view full) --- 1366 port->node_base.nlp_Rpi = 0; 1367 port->node_base.nlp_DID = 0xffffff; 1368 port->node_base.nlp_list_next = NULL; 1369 port->node_base.nlp_list_prev = NULL; 1370 port->node_base.nlp_active = 1; 1371 port->node_base.nlp_base = 1; 1372 port->node_count = 0; 1373 |
1390 if (!(port->flag & EMLXS_PORT_ENABLE)) { | 1374 if (!(port->flag & EMLXS_PORT_ENABLED)) { |
1391 uint8_t dummy_wwn[8] = 1392 { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; 1393 1394 bcopy((caddr_t)dummy_wwn, (caddr_t)&port->wwnn, 1395 sizeof (NAME_TYPE)); 1396 bcopy((caddr_t)dummy_wwn, (caddr_t)&port->wwpn, 1397 sizeof (NAME_TYPE)); 1398 } 1399 1400 if (!(port->flag & EMLXS_PORT_CONFIG)) { | 1375 uint8_t dummy_wwn[8] = 1376 { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; 1377 1378 bcopy((caddr_t)dummy_wwn, (caddr_t)&port->wwnn, 1379 sizeof (NAME_TYPE)); 1380 bcopy((caddr_t)dummy_wwn, (caddr_t)&port->wwpn, 1381 sizeof (NAME_TYPE)); 1382 } 1383 1384 if (!(port->flag & EMLXS_PORT_CONFIG)) { |
1401 (void) strncpy((caddr_t)port->snn, (caddr_t)hba->snn, 256); 1402 (void) strncpy((caddr_t)port->spn, (caddr_t)hba->spn, 256); | 1385 (void) strncpy((caddr_t)port->snn, (caddr_t)hba->snn, 1386 (sizeof (port->snn)-1)); 1387 (void) strncpy((caddr_t)port->spn, (caddr_t)hba->spn, 1388 (sizeof (port->spn)-1)); |
1403 } 1404 1405 bcopy((caddr_t)&hba->sparam, (caddr_t)&port->sparam, 1406 sizeof (SERV_PARM)); 1407 bcopy((caddr_t)&port->wwnn, (caddr_t)&port->sparam.nodeName, 1408 sizeof (NAME_TYPE)); 1409 bcopy((caddr_t)&port->wwpn, (caddr_t)&port->sparam.portName, 1410 sizeof (NAME_TYPE)); --- 12 unchanged lines hidden (view full) --- 1423 return; 1424 } 1425 1426 /* Turn off the Correctable Error Reporting */ 1427 /* (the Device Control Register, bit 0). */ 1428 reg = ddi_get16(hba->pci_acc_handle, 1429 (uint16_t *)(hba->pci_addr + 1430 hba->pci_cap_offset[PCI_CAP_ID_PCI_E] + | 1389 } 1390 1391 bcopy((caddr_t)&hba->sparam, (caddr_t)&port->sparam, 1392 sizeof (SERV_PARM)); 1393 bcopy((caddr_t)&port->wwnn, (caddr_t)&port->sparam.nodeName, 1394 sizeof (NAME_TYPE)); 1395 bcopy((caddr_t)&port->wwpn, (caddr_t)&port->sparam.portName, 1396 sizeof (NAME_TYPE)); --- 12 unchanged lines hidden (view full) --- 1409 return; 1410 } 1411 1412 /* Turn off the Correctable Error Reporting */ 1413 /* (the Device Control Register, bit 0). */ 1414 reg = ddi_get16(hba->pci_acc_handle, 1415 (uint16_t *)(hba->pci_addr + 1416 hba->pci_cap_offset[PCI_CAP_ID_PCI_E] + |
1431 PCIE_DEVCTL_OFFSET)); | 1417 PCIE_DEVCTL)); |
1432 1433 reg &= ~1; 1434 1435 (void) ddi_put16(hba->pci_acc_handle, 1436 (uint16_t *)(hba->pci_addr + 1437 hba->pci_cap_offset[PCI_CAP_ID_PCI_E] + | 1418 1419 reg &= ~1; 1420 1421 (void) ddi_put16(hba->pci_acc_handle, 1422 (uint16_t *)(hba->pci_addr + 1423 hba->pci_cap_offset[PCI_CAP_ID_PCI_E] + |
1438 PCIE_DEVCTL_OFFSET), | 1424 PCIE_DEVCTL), |
1439 reg); 1440 1441 return; 1442 1443} /* emlxs_disable_pcie_ce_err() */ 1444 1445 1446/* --- 9 unchanged lines hidden (view full) --- 1456 * 1457 */ 1458static opaque_t 1459emlxs_fca_bind_port(dev_info_t *dip, fc_fca_port_info_t *port_info, 1460 fc_fca_bind_info_t *bind_info) 1461{ 1462 emlxs_hba_t *hba; 1463 emlxs_port_t *port; | 1425 reg); 1426 1427 return; 1428 1429} /* emlxs_disable_pcie_ce_err() */ 1430 1431 1432/* --- 9 unchanged lines hidden (view full) --- 1442 * 1443 */ 1444static opaque_t 1445emlxs_fca_bind_port(dev_info_t *dip, fc_fca_port_info_t *port_info, 1446 fc_fca_bind_info_t *bind_info) 1447{ 1448 emlxs_hba_t *hba; 1449 emlxs_port_t *port; |
1450 emlxs_port_t *pport; |
|
1464 emlxs_port_t *vport; 1465 int ddiinst; 1466 emlxs_vpd_t *vpd; 1467 emlxs_config_t *cfg; 1468 char *dptr; 1469 char buffer[16]; 1470 uint32_t length; 1471 uint32_t len; 1472 char topology[32]; 1473 char linkspeed[32]; | 1451 emlxs_port_t *vport; 1452 int ddiinst; 1453 emlxs_vpd_t *vpd; 1454 emlxs_config_t *cfg; 1455 char *dptr; 1456 char buffer[16]; 1457 uint32_t length; 1458 uint32_t len; 1459 char topology[32]; 1460 char linkspeed[32]; |
1461 uint32_t linkstate; |
|
1474 1475 ddiinst = ddi_get_instance(dip); 1476 hba = ddi_get_soft_state(emlxs_soft_state, ddiinst); 1477 port = &PPORT; | 1462 1463 ddiinst = ddi_get_instance(dip); 1464 hba = ddi_get_soft_state(emlxs_soft_state, ddiinst); 1465 port = &PPORT; |
1466 pport = &PPORT; |
|
1478 1479 ddiinst = hba->ddiinst; 1480 vpd = &VPD; 1481 cfg = &CFG; 1482 1483 mutex_enter(&EMLXS_PORT_LOCK); 1484 1485 if (bind_info->port_num > 0) { --- 15 unchanged lines hidden (view full) --- 1501 port_info->pi_error = FC_OUTOFBOUNDS; 1502 return (NULL); 1503 } 1504 } 1505 1506 /* Get true port pointer */ 1507 port = &VPORT(bind_info->port_num); 1508 | 1467 1468 ddiinst = hba->ddiinst; 1469 vpd = &VPD; 1470 cfg = &CFG; 1471 1472 mutex_enter(&EMLXS_PORT_LOCK); 1473 1474 if (bind_info->port_num > 0) { --- 15 unchanged lines hidden (view full) --- 1490 port_info->pi_error = FC_OUTOFBOUNDS; 1491 return (NULL); 1492 } 1493 } 1494 1495 /* Get true port pointer */ 1496 port = &VPORT(bind_info->port_num); 1497 |
1509 if (port->tgt_mode) { | 1498 /* Make sure the port is not already bound to the transport */ 1499 if (port->flag & EMLXS_INI_BOUND) { 1500 |
1510 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 1501 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
1511 "fca_bind_port: Port %d is in target mode.", 1512 bind_info->port_num); | 1502 "fca_bind_port: Port %d already bound. flag=%x", 1503 bind_info->port_num, port->flag); |
1513 1514 mutex_exit(&EMLXS_PORT_LOCK); 1515 | 1504 1505 mutex_exit(&EMLXS_PORT_LOCK); 1506 |
1516 port_info->pi_error = FC_OUTOFBOUNDS; | 1507 port_info->pi_error = FC_ALREADY; |
1517 return (NULL); 1518 } 1519 | 1508 return (NULL); 1509 } 1510 |
1520 if (!port->ini_mode) { | 1511 if (!(pport->flag & EMLXS_INI_ENABLED)) { |
1521 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 1512 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
1522 "fca_bind_port: Port %d is not in initiator mode.", 1523 bind_info->port_num); | 1513 "fca_bind_port: Physical port does not support " 1514 "initiator mode."); |
1524 1525 mutex_exit(&EMLXS_PORT_LOCK); 1526 1527 port_info->pi_error = FC_OUTOFBOUNDS; 1528 return (NULL); 1529 } 1530 | 1515 1516 mutex_exit(&EMLXS_PORT_LOCK); 1517 1518 port_info->pi_error = FC_OUTOFBOUNDS; 1519 return (NULL); 1520 } 1521 |
1531 /* Make sure the port is not already bound to the transport */ 1532 if (port->flag & EMLXS_PORT_BOUND) { | 1522 /* Make sure port enable flag is set */ 1523 /* Just in case fca_port_unbind is called just prior to fca_port_bind */ 1524 /* without a driver attach or resume operation */ 1525 port->flag |= EMLXS_PORT_ENABLED; |
1533 | 1526 |
1534 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 1535 "fca_bind_port: Port %d already bound. flag=%x", 1536 bind_info->port_num, port->flag); 1537 1538 mutex_exit(&EMLXS_PORT_LOCK); 1539 1540 port_info->pi_error = FC_ALREADY; 1541 return (NULL); 1542 } 1543 | |
1544 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 1545 "fca_bind_port: Port %d: port_info=%p bind_info=%p", 1546 bind_info->port_num, port_info, bind_info); 1547 1548#if (EMLXS_MODREV >= EMLXS_MODREV5) 1549 if (bind_info->port_npiv) { | 1527 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 1528 "fca_bind_port: Port %d: port_info=%p bind_info=%p", 1529 bind_info->port_num, port_info, bind_info); 1530 1531#if (EMLXS_MODREV >= EMLXS_MODREV5) 1532 if (bind_info->port_npiv) { |
1533 /* Leadville is telling us about a new virtual port */ |
|
1550 bcopy((caddr_t)&bind_info->port_nwwn, (caddr_t)&port->wwnn, 1551 sizeof (NAME_TYPE)); 1552 bcopy((caddr_t)&bind_info->port_pwwn, (caddr_t)&port->wwpn, 1553 sizeof (NAME_TYPE)); 1554 if (port->snn[0] == 0) { 1555 (void) strncpy((caddr_t)port->snn, (caddr_t)hba->snn, | 1534 bcopy((caddr_t)&bind_info->port_nwwn, (caddr_t)&port->wwnn, 1535 sizeof (NAME_TYPE)); 1536 bcopy((caddr_t)&bind_info->port_pwwn, (caddr_t)&port->wwpn, 1537 sizeof (NAME_TYPE)); 1538 if (port->snn[0] == 0) { 1539 (void) strncpy((caddr_t)port->snn, (caddr_t)hba->snn, |
1556 256); | 1540 (sizeof (port->snn)-1)); 1541 |
1557 } 1558 1559 if (port->spn[0] == 0) { | 1542 } 1543 1544 if (port->spn[0] == 0) { |
1560 (void) sprintf((caddr_t)port->spn, "%s VPort-%d", | 1545 (void) snprintf((caddr_t)port->spn, 1546 (sizeof (port->spn)-1), "%s VPort-%d", |
1561 (caddr_t)hba->spn, port->vpi); 1562 } | 1547 (caddr_t)hba->spn, port->vpi); 1548 } |
1563 port->flag |= (EMLXS_PORT_CONFIG | EMLXS_PORT_ENABLE); | 1549 port->flag |= EMLXS_PORT_CONFIG; |
1564 } 1565#endif /* >= EMLXS_MODREV5 */ 1566 1567 /* 1568 * Restricted login should apply both physical and 1569 * virtual ports. 1570 */ 1571 if (cfg[CFG_VPORT_RESTRICTED].current) { 1572 port->flag |= EMLXS_PORT_RESTRICTED; 1573 } 1574 1575 /* Perform generic port initialization */ 1576 emlxs_port_init(port); 1577 1578 /* Perform SFS specific initialization */ 1579 port->ulp_handle = bind_info->port_handle; 1580 port->ulp_statec_cb = bind_info->port_statec_cb; 1581 port->ulp_unsol_cb = bind_info->port_unsol_cb; | 1550 } 1551#endif /* >= EMLXS_MODREV5 */ 1552 1553 /* 1554 * Restricted login should apply both physical and 1555 * virtual ports. 1556 */ 1557 if (cfg[CFG_VPORT_RESTRICTED].current) { 1558 port->flag |= EMLXS_PORT_RESTRICTED; 1559 } 1560 1561 /* Perform generic port initialization */ 1562 emlxs_port_init(port); 1563 1564 /* Perform SFS specific initialization */ 1565 port->ulp_handle = bind_info->port_handle; 1566 port->ulp_statec_cb = bind_info->port_statec_cb; 1567 port->ulp_unsol_cb = bind_info->port_unsol_cb; |
1582 port->ub_count = EMLXS_UB_TOKEN_OFFSET; 1583 port->ub_pool = NULL; | |
1584 | 1568 |
1569 /* Set the bound flag */ 1570 port->flag |= EMLXS_INI_BOUND; 1571 hba->num_of_ports++; 1572 1573 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) { 1574 mutex_exit(&EMLXS_PORT_LOCK); 1575 (void) emlxs_vpi_port_bind_notify(port); 1576 mutex_enter(&EMLXS_PORT_LOCK); 1577 1578 linkstate = (port->vpip->state == VPI_STATE_PORT_ONLINE)? 1579 FC_LINK_UP:FC_LINK_DOWN; 1580 } else { 1581 linkstate = hba->state; 1582 } 1583 |
|
1585 /* Update the port info structure */ 1586 1587 /* Set the topology and state */ | 1584 /* Update the port info structure */ 1585 1586 /* Set the topology and state */ |
1588 if ((hba->state < FC_LINK_UP) || 1589 ((port->vpi > 0) && (!(port->flag & EMLXS_PORT_ENABLE) || 1590 !(hba->flag & FC_NPIV_SUPPORTED)))) { | 1587 if (port->mode == MODE_TARGET) { |
1591 port_info->pi_port_state = FC_STATE_OFFLINE; 1592 port_info->pi_topology = FC_TOP_UNKNOWN; | 1588 port_info->pi_port_state = FC_STATE_OFFLINE; 1589 port_info->pi_topology = FC_TOP_UNKNOWN; |
1593 } else if ((hba->sli_mode == EMLXS_HBA_SLI4_MODE) && 1594 (port->VPIobj.state == VPI_STATE_OFFLINE)) { | 1590 } else if ((linkstate < FC_LINK_UP) || 1591 ((port->vpi > 0) && (!(port->flag & EMLXS_PORT_ENABLED) || 1592 !(hba->flag & FC_NPIV_SUPPORTED)))) { |
1595 port_info->pi_port_state = FC_STATE_OFFLINE; 1596 port_info->pi_topology = FC_TOP_UNKNOWN; 1597 } 1598#ifdef MENLO_SUPPORT 1599 else if (hba->flag & FC_MENLO_MODE) { 1600 port_info->pi_port_state = FC_STATE_OFFLINE; 1601 port_info->pi_topology = FC_TOP_UNKNOWN; 1602 } 1603#endif /* MENLO_SUPPORT */ 1604 else { 1605 /* Check for loop topology */ 1606 if (hba->topology == TOPOLOGY_LOOP) { 1607 port_info->pi_port_state = FC_STATE_LOOP; | 1593 port_info->pi_port_state = FC_STATE_OFFLINE; 1594 port_info->pi_topology = FC_TOP_UNKNOWN; 1595 } 1596#ifdef MENLO_SUPPORT 1597 else if (hba->flag & FC_MENLO_MODE) { 1598 port_info->pi_port_state = FC_STATE_OFFLINE; 1599 port_info->pi_topology = FC_TOP_UNKNOWN; 1600 } 1601#endif /* MENLO_SUPPORT */ 1602 else { 1603 /* Check for loop topology */ 1604 if (hba->topology == TOPOLOGY_LOOP) { 1605 port_info->pi_port_state = FC_STATE_LOOP; |
1608 (void) strcpy(topology, ", loop"); | 1606 (void) strlcpy(topology, ", loop", sizeof (topology)); |
1609 1610 if (hba->flag & FC_FABRIC_ATTACHED) { 1611 port_info->pi_topology = FC_TOP_PUBLIC_LOOP; 1612 } else { 1613 port_info->pi_topology = FC_TOP_PRIVATE_LOOP; 1614 } 1615 } else { 1616 port_info->pi_topology = FC_TOP_FABRIC; 1617 port_info->pi_port_state = FC_STATE_ONLINE; | 1607 1608 if (hba->flag & FC_FABRIC_ATTACHED) { 1609 port_info->pi_topology = FC_TOP_PUBLIC_LOOP; 1610 } else { 1611 port_info->pi_topology = FC_TOP_PRIVATE_LOOP; 1612 } 1613 } else { 1614 port_info->pi_topology = FC_TOP_FABRIC; 1615 port_info->pi_port_state = FC_STATE_ONLINE; |
1618 (void) strcpy(topology, ", fabric"); | 1616 (void) strlcpy(topology, ", fabric", sizeof (topology)); |
1619 } 1620 1621 /* Set the link speed */ 1622 switch (hba->linkspeed) { 1623 case 0: | 1617 } 1618 1619 /* Set the link speed */ 1620 switch (hba->linkspeed) { 1621 case 0: |
1624 (void) strcpy(linkspeed, "Gb"); | 1622 (void) strlcpy(linkspeed, "Gb", sizeof (linkspeed)); |
1625 port_info->pi_port_state |= FC_STATE_1GBIT_SPEED; 1626 break; 1627 1628 case LA_1GHZ_LINK: | 1623 port_info->pi_port_state |= FC_STATE_1GBIT_SPEED; 1624 break; 1625 1626 case LA_1GHZ_LINK: |
1629 (void) strcpy(linkspeed, "1Gb"); | 1627 (void) strlcpy(linkspeed, "1Gb", sizeof (linkspeed)); |
1630 port_info->pi_port_state |= FC_STATE_1GBIT_SPEED; 1631 break; 1632 case LA_2GHZ_LINK: | 1628 port_info->pi_port_state |= FC_STATE_1GBIT_SPEED; 1629 break; 1630 case LA_2GHZ_LINK: |
1633 (void) strcpy(linkspeed, "2Gb"); | 1631 (void) strlcpy(linkspeed, "2Gb", sizeof (linkspeed)); |
1634 port_info->pi_port_state |= FC_STATE_2GBIT_SPEED; 1635 break; 1636 case LA_4GHZ_LINK: | 1632 port_info->pi_port_state |= FC_STATE_2GBIT_SPEED; 1633 break; 1634 case LA_4GHZ_LINK: |
1637 (void) strcpy(linkspeed, "4Gb"); | 1635 (void) strlcpy(linkspeed, "4Gb", sizeof (linkspeed)); |
1638 port_info->pi_port_state |= FC_STATE_4GBIT_SPEED; 1639 break; 1640 case LA_8GHZ_LINK: | 1636 port_info->pi_port_state |= FC_STATE_4GBIT_SPEED; 1637 break; 1638 case LA_8GHZ_LINK: |
1641 (void) strcpy(linkspeed, "8Gb"); | 1639 (void) strlcpy(linkspeed, "8Gb", sizeof (linkspeed)); |
1642 port_info->pi_port_state |= FC_STATE_8GBIT_SPEED; 1643 break; 1644 case LA_10GHZ_LINK: | 1640 port_info->pi_port_state |= FC_STATE_8GBIT_SPEED; 1641 break; 1642 case LA_10GHZ_LINK: |
1645 (void) strcpy(linkspeed, "10Gb"); | 1643 (void) strlcpy(linkspeed, "10Gb", sizeof (linkspeed)); |
1646 port_info->pi_port_state |= FC_STATE_10GBIT_SPEED; 1647 break; | 1644 port_info->pi_port_state |= FC_STATE_10GBIT_SPEED; 1645 break; |
1646 case LA_16GHZ_LINK: 1647 (void) strlcpy(linkspeed, "16Gb", sizeof (linkspeed)); 1648 port_info->pi_port_state |= FC_STATE_16GBIT_SPEED; 1649 break; |
|
1648 default: | 1650 default: |
1649 (void) sprintf(linkspeed, "unknown(0x%x)", 1650 hba->linkspeed); | 1651 (void) snprintf(linkspeed, sizeof (linkspeed), 1652 "unknown(0x%x)", hba->linkspeed); |
1651 break; 1652 } 1653 | 1653 break; 1654 } 1655 |
1654 /* Adjusting port context for link up messages */ 1655 vport = port; 1656 port = &PPORT; 1657 if (vport->vpi == 0) { 1658 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_link_up_msg, "%s%s", 1659 linkspeed, topology); 1660 } else if (!(hba->flag & FC_NPIV_LINKUP)) { 1661 hba->flag |= FC_NPIV_LINKUP; 1662 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_npiv_link_up_msg, 1663 "%s%s", linkspeed, topology); | 1656 if (hba->sli_mode <= EMLXS_HBA_SLI3_MODE) { 1657 /* Adjusting port context for link up messages */ 1658 vport = port; 1659 port = &PPORT; 1660 if (vport->vpi == 0) { 1661 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_link_up_msg, 1662 "%s%s, initiator", 1663 linkspeed, topology); 1664 } else if (!(hba->flag & FC_NPIV_LINKUP)) { 1665 hba->flag |= FC_NPIV_LINKUP; 1666 EMLXS_MSGF(EMLXS_CONTEXT, 1667 &emlxs_npiv_link_up_msg, 1668 "%s%s, initiator", linkspeed, topology); 1669 } 1670 port = vport; |
1664 } | 1671 } |
1665 port = vport; 1666 | |
1667 } 1668 1669 /* PCIE Correctable Error Reporting workaround */ 1670 if (((hba->model_info.chip == EMLXS_BE2_CHIP) || 1671 (hba->model_info.chip == EMLXS_BE3_CHIP)) && 1672 (bind_info->port_num == 0)) { 1673 emlxs_disable_pcie_ce_err(hba); 1674 } --- 65 unchanged lines hidden (view full) --- 1740 /* Additional parameters */ 1741 port_info->pi_s_id.port_id = port->did; 1742 port_info->pi_s_id.priv_lilp_posit = 0; 1743 port_info->pi_hard_addr.hard_addr = cfg[CFG_ASSIGN_ALPA].current; 1744 1745 /* Initialize the RNID parameters */ 1746 bzero(&port_info->pi_rnid_params, sizeof (port_info->pi_rnid_params)); 1747 | 1672 } 1673 1674 /* PCIE Correctable Error Reporting workaround */ 1675 if (((hba->model_info.chip == EMLXS_BE2_CHIP) || 1676 (hba->model_info.chip == EMLXS_BE3_CHIP)) && 1677 (bind_info->port_num == 0)) { 1678 emlxs_disable_pcie_ce_err(hba); 1679 } --- 65 unchanged lines hidden (view full) --- 1745 /* Additional parameters */ 1746 port_info->pi_s_id.port_id = port->did; 1747 port_info->pi_s_id.priv_lilp_posit = 0; 1748 port_info->pi_hard_addr.hard_addr = cfg[CFG_ASSIGN_ALPA].current; 1749 1750 /* Initialize the RNID parameters */ 1751 bzero(&port_info->pi_rnid_params, sizeof (port_info->pi_rnid_params)); 1752 |
1748 (void) sprintf((char *)port_info->pi_rnid_params.params.global_id, | 1753 (void) snprintf((char *)port_info->pi_rnid_params.params.global_id, 1754 (sizeof (port_info->pi_rnid_params.params.global_id)-1), |
1749 "%01x%01x%02x%02x%02x%02x%02x%02x%02x", hba->wwpn.nameType, 1750 hba->wwpn.IEEEextMsn, hba->wwpn.IEEEextLsb, hba->wwpn.IEEE[0], 1751 hba->wwpn.IEEE[1], hba->wwpn.IEEE[2], hba->wwpn.IEEE[3], 1752 hba->wwpn.IEEE[4], hba->wwpn.IEEE[5]); 1753 1754 port_info->pi_rnid_params.params.unit_type = RNID_HBA; 1755 port_info->pi_rnid_params.params.port_id = port->did; 1756 port_info->pi_rnid_params.params.ip_version = RNID_IPV4; 1757 1758 /* Initialize the port attributes */ 1759 bzero(&port_info->pi_attrs, sizeof (port_info->pi_attrs)); 1760 | 1755 "%01x%01x%02x%02x%02x%02x%02x%02x%02x", hba->wwpn.nameType, 1756 hba->wwpn.IEEEextMsn, hba->wwpn.IEEEextLsb, hba->wwpn.IEEE[0], 1757 hba->wwpn.IEEE[1], hba->wwpn.IEEE[2], hba->wwpn.IEEE[3], 1758 hba->wwpn.IEEE[4], hba->wwpn.IEEE[5]); 1759 1760 port_info->pi_rnid_params.params.unit_type = RNID_HBA; 1761 port_info->pi_rnid_params.params.port_id = port->did; 1762 port_info->pi_rnid_params.params.ip_version = RNID_IPV4; 1763 1764 /* Initialize the port attributes */ 1765 bzero(&port_info->pi_attrs, sizeof (port_info->pi_attrs)); 1766 |
1761 (void) strcpy(port_info->pi_attrs.manufacturer, "Emulex"); | 1767 (void) strncpy(port_info->pi_attrs.manufacturer, "Emulex", 1768 (sizeof (port_info->pi_attrs.manufacturer)-1)); |
1762 1763 port_info->pi_rnid_params.status = FC_SUCCESS; 1764 | 1769 1770 port_info->pi_rnid_params.status = FC_SUCCESS; 1771 |
1765 (void) strcpy(port_info->pi_attrs.serial_number, vpd->serial_num); | 1772 (void) strncpy(port_info->pi_attrs.serial_number, vpd->serial_num, 1773 (sizeof (port_info->pi_attrs.serial_number)-1)); |
1766 | 1774 |
1767 (void) sprintf(port_info->pi_attrs.firmware_version, "%s (%s)", | 1775 (void) snprintf(port_info->pi_attrs.firmware_version, 1776 (sizeof (port_info->pi_attrs.firmware_version)-1), "%s (%s)", |
1768 vpd->fw_version, vpd->fw_label); 1769 1770#ifdef EMLXS_I386 | 1777 vpd->fw_version, vpd->fw_label); 1778 1779#ifdef EMLXS_I386 |
1771 (void) sprintf(port_info->pi_attrs.option_rom_version, | 1780 (void) snprintf(port_info->pi_attrs.option_rom_version, 1781 (sizeof (port_info->pi_attrs.option_rom_version)-1), |
1772 "Boot:%s", vpd->boot_version); 1773#else /* EMLXS_SPARC */ | 1782 "Boot:%s", vpd->boot_version); 1783#else /* EMLXS_SPARC */ |
1774 (void) sprintf(port_info->pi_attrs.option_rom_version, | 1784 (void) snprintf(port_info->pi_attrs.option_rom_version, 1785 (sizeof (port_info->pi_attrs.option_rom_version)-1), |
1775 "Boot:%s Fcode:%s", vpd->boot_version, vpd->fcode_version); 1776#endif /* EMLXS_I386 */ 1777 | 1786 "Boot:%s Fcode:%s", vpd->boot_version, vpd->fcode_version); 1787#endif /* EMLXS_I386 */ 1788 |
1778 1779 (void) sprintf(port_info->pi_attrs.driver_version, "%s (%s)", | 1789 (void) snprintf(port_info->pi_attrs.driver_version, 1790 (sizeof (port_info->pi_attrs.driver_version)-1), "%s (%s)", |
1780 emlxs_version, emlxs_revision); 1781 | 1791 emlxs_version, emlxs_revision); 1792 |
1782 (void) strcpy(port_info->pi_attrs.driver_name, DRIVER_NAME); | 1793 (void) strncpy(port_info->pi_attrs.driver_name, DRIVER_NAME, 1794 (sizeof (port_info->pi_attrs.driver_name)-1)); |
1783 1784 port_info->pi_attrs.vendor_specific_id = 1785 ((hba->model_info.device_id << 16) | PCI_VENDOR_ID_EMULEX); 1786 1787 port_info->pi_attrs.supported_cos = LE_SWAP32(FC_NS_CLASS3); 1788 1789 port_info->pi_attrs.max_frame_size = FF_FRAME_SIZE; 1790 | 1795 1796 port_info->pi_attrs.vendor_specific_id = 1797 ((hba->model_info.device_id << 16) | PCI_VENDOR_ID_EMULEX); 1798 1799 port_info->pi_attrs.supported_cos = LE_SWAP32(FC_NS_CLASS3); 1800 1801 port_info->pi_attrs.max_frame_size = FF_FRAME_SIZE; 1802 |
1791#if (EMLXS_MODREV >= EMLXS_MODREV5) 1792 | 1803#if (EMLXS_MODREV >= EMLXS_MODREV3) |
1793 port_info->pi_rnid_params.params.num_attached = 0; 1794 | 1804 port_info->pi_rnid_params.params.num_attached = 0; 1805 |
1795 /* 1796 * Copy the serial number string (right most 16 chars) into the right 1797 * justified local buffer 1798 */ 1799 bzero(buffer, sizeof (buffer)); 1800 length = strlen(vpd->serial_num); 1801 len = (length > 16) ? 16 : length; 1802 bcopy(&vpd->serial_num[(length - len)], 1803 &buffer[(sizeof (buffer) - len)], len); | 1806 if (hba->model_info.chip == EMLXS_LANCER_CHIP) { 1807 uint8_t byte; 1808 uint8_t *wwpn; 1809 uint32_t i; 1810 uint32_t j; |
1804 | 1811 |
1805 port_info->pi_attrs.hba_fru_details.port_index = vpd->port_index; | 1812 /* Copy the WWPN as a string into the local buffer */ 1813 wwpn = (uint8_t *)&hba->wwpn; 1814 for (i = 0; i < 16; i++) { 1815 byte = *wwpn++; 1816 j = ((byte & 0xf0) >> 4); 1817 if (j <= 9) { 1818 buffer[i] = 1819 (char)((uint8_t)'0' + (uint8_t)j); 1820 } else { 1821 buffer[i] = 1822 (char)((uint8_t)'A' + (uint8_t)(j - 1823 10)); 1824 } |
1806 | 1825 |
1807#endif /* >= EMLXS_MODREV5 */ | 1826 i++; 1827 j = (byte & 0xf); 1828 if (j <= 9) { 1829 buffer[i] = 1830 (char)((uint8_t)'0' + (uint8_t)j); 1831 } else { 1832 buffer[i] = 1833 (char)((uint8_t)'A' + (uint8_t)(j - 1834 10)); 1835 } 1836 } |
1808 | 1837 |
1838 port_info->pi_attrs.hba_fru_details.port_index = 0; |
|
1809#if ((EMLXS_MODREV == EMLXS_MODREV3) || (EMLXS_MODREV == EMLXS_MODREV4)) 1810 | 1839#if ((EMLXS_MODREV == EMLXS_MODREV3) || (EMLXS_MODREV == EMLXS_MODREV4)) 1840 |
1811 port_info->pi_rnid_params.params.num_attached = 0; 1812 1813 if (hba->flag & FC_NPIV_ENABLED) { | 1841 } else if (hba->flag & FC_NPIV_ENABLED) { |
1814 uint8_t byte; 1815 uint8_t *wwpn; 1816 uint32_t i; 1817 uint32_t j; 1818 1819 /* Copy the WWPN as a string into the local buffer */ 1820 wwpn = (uint8_t *)&hba->wwpn; 1821 for (i = 0; i < 16; i++) { --- 13 unchanged lines hidden (view full) --- 1835 if (j <= 9) { 1836 buffer[i] = 1837 (char)((uint8_t)'0' + (uint8_t)j); 1838 } else { 1839 buffer[i] = 1840 (char)((uint8_t)'A' + (uint8_t)(j - 1841 10)); 1842 } | 1842 uint8_t byte; 1843 uint8_t *wwpn; 1844 uint32_t i; 1845 uint32_t j; 1846 1847 /* Copy the WWPN as a string into the local buffer */ 1848 wwpn = (uint8_t *)&hba->wwpn; 1849 for (i = 0; i < 16; i++) { --- 13 unchanged lines hidden (view full) --- 1863 if (j <= 9) { 1864 buffer[i] = 1865 (char)((uint8_t)'0' + (uint8_t)j); 1866 } else { 1867 buffer[i] = 1868 (char)((uint8_t)'A' + (uint8_t)(j - 1869 10)); 1870 } |
1843 } | 1871 } |
1844 1845 port_info->pi_attrs.hba_fru_details.port_index = port->vpi; | 1872 1873 port_info->pi_attrs.hba_fru_details.port_index = port->vpi; |
1874#endif /* == EMLXS_MODREV3 || EMLXS_MODREV4 */ 1875 |
|
1846 } else { 1847 /* Copy the serial number string (right most 16 chars) */ 1848 /* into the right justified local buffer */ 1849 bzero(buffer, sizeof (buffer)); 1850 length = strlen(vpd->serial_num); 1851 len = (length > 16) ? 16 : length; 1852 bcopy(&vpd->serial_num[(length - len)], 1853 &buffer[(sizeof (buffer) - len)], len); 1854 1855 port_info->pi_attrs.hba_fru_details.port_index = 1856 vpd->port_index; 1857 } 1858 | 1876 } else { 1877 /* Copy the serial number string (right most 16 chars) */ 1878 /* into the right justified local buffer */ 1879 bzero(buffer, sizeof (buffer)); 1880 length = strlen(vpd->serial_num); 1881 len = (length > 16) ? 16 : length; 1882 bcopy(&vpd->serial_num[(length - len)], 1883 &buffer[(sizeof (buffer) - len)], len); 1884 1885 port_info->pi_attrs.hba_fru_details.port_index = 1886 vpd->port_index; 1887 } 1888 |
1859#endif /* == EMLXS_MODREV3 || EMLXS_MODREV4 */ 1860 1861#if (EMLXS_MODREV >= EMLXS_MODREV3) 1862 | |
1863 dptr = (char *)&port_info->pi_attrs.hba_fru_details.high; 1864 dptr[0] = buffer[0]; 1865 dptr[1] = buffer[1]; 1866 dptr[2] = buffer[2]; 1867 dptr[3] = buffer[3]; 1868 dptr[4] = buffer[4]; 1869 dptr[5] = buffer[5]; 1870 dptr[6] = buffer[6]; --- 17 unchanged lines hidden (view full) --- 1888 1889#if (EMLXS_MODREV >= EMLXS_MODREV4) 1890 (void) strncpy((caddr_t)port_info->pi_attrs.sym_node_name, 1891 (caddr_t)port->snn, FCHBA_SYMB_NAME_LEN); 1892 (void) strncpy((caddr_t)port_info->pi_attrs.sym_port_name, 1893 (caddr_t)port->spn, FCHBA_SYMB_NAME_LEN); 1894#endif /* >= EMLXS_MODREV4 */ 1895 | 1889 dptr = (char *)&port_info->pi_attrs.hba_fru_details.high; 1890 dptr[0] = buffer[0]; 1891 dptr[1] = buffer[1]; 1892 dptr[2] = buffer[2]; 1893 dptr[3] = buffer[3]; 1894 dptr[4] = buffer[4]; 1895 dptr[5] = buffer[5]; 1896 dptr[6] = buffer[6]; --- 17 unchanged lines hidden (view full) --- 1914 1915#if (EMLXS_MODREV >= EMLXS_MODREV4) 1916 (void) strncpy((caddr_t)port_info->pi_attrs.sym_node_name, 1917 (caddr_t)port->snn, FCHBA_SYMB_NAME_LEN); 1918 (void) strncpy((caddr_t)port_info->pi_attrs.sym_port_name, 1919 (caddr_t)port->spn, FCHBA_SYMB_NAME_LEN); 1920#endif /* >= EMLXS_MODREV4 */ 1921 |
1896 (void) sprintf(port_info->pi_attrs.hardware_version, "%x", vpd->biuRev); | 1922 (void) snprintf(port_info->pi_attrs.hardware_version, 1923 (sizeof (port_info->pi_attrs.hardware_version)-1), 1924 "%x", vpd->biuRev); |
1897 1898 /* Set the hba speed limit */ | 1925 1926 /* Set the hba speed limit */ |
1927 if (vpd->link_speed & LMT_16GB_CAPABLE) { 1928 port_info->pi_attrs.supported_speed |= 1929 FC_HBA_PORTSPEED_16GBIT; 1930 } |
|
1899 if (vpd->link_speed & LMT_10GB_CAPABLE) { 1900 port_info->pi_attrs.supported_speed |= 1901 FC_HBA_PORTSPEED_10GBIT; 1902 } 1903 if (vpd->link_speed & LMT_8GB_CAPABLE) { 1904 port_info->pi_attrs.supported_speed |= FC_HBA_PORTSPEED_8GBIT; 1905 } 1906 if (vpd->link_speed & LMT_4GB_CAPABLE) { 1907 port_info->pi_attrs.supported_speed |= FC_HBA_PORTSPEED_4GBIT; 1908 } 1909 if (vpd->link_speed & LMT_2GB_CAPABLE) { 1910 port_info->pi_attrs.supported_speed |= FC_HBA_PORTSPEED_2GBIT; 1911 } 1912 if (vpd->link_speed & LMT_1GB_CAPABLE) { 1913 port_info->pi_attrs.supported_speed |= FC_HBA_PORTSPEED_1GBIT; 1914 } 1915 1916 /* Set the hba model info */ | 1931 if (vpd->link_speed & LMT_10GB_CAPABLE) { 1932 port_info->pi_attrs.supported_speed |= 1933 FC_HBA_PORTSPEED_10GBIT; 1934 } 1935 if (vpd->link_speed & LMT_8GB_CAPABLE) { 1936 port_info->pi_attrs.supported_speed |= FC_HBA_PORTSPEED_8GBIT; 1937 } 1938 if (vpd->link_speed & LMT_4GB_CAPABLE) { 1939 port_info->pi_attrs.supported_speed |= FC_HBA_PORTSPEED_4GBIT; 1940 } 1941 if (vpd->link_speed & LMT_2GB_CAPABLE) { 1942 port_info->pi_attrs.supported_speed |= FC_HBA_PORTSPEED_2GBIT; 1943 } 1944 if (vpd->link_speed & LMT_1GB_CAPABLE) { 1945 port_info->pi_attrs.supported_speed |= FC_HBA_PORTSPEED_1GBIT; 1946 } 1947 1948 /* Set the hba model info */ |
1917 (void) strcpy(port_info->pi_attrs.model, hba->model_info.model); 1918 (void) strcpy(port_info->pi_attrs.model_description, 1919 hba->model_info.model_desc); | 1949 (void) strncpy(port_info->pi_attrs.model, hba->model_info.model, 1950 (sizeof (port_info->pi_attrs.model)-1)); 1951 (void) strncpy(port_info->pi_attrs.model_description, 1952 hba->model_info.model_desc, 1953 (sizeof (port_info->pi_attrs.model_description)-1)); |
1920 1921 1922 /* Log information */ 1923 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 1924 "Bind info: port_num = %d", bind_info->port_num); 1925 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 1926 "Bind info: port_handle = %p", bind_info->port_handle); 1927 --- 105 unchanged lines hidden (view full) --- 2033 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 2034 "Port info: sym_node_name = %s", 2035 port_info->pi_attrs.sym_node_name); 2036 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 2037 "Port info: sym_port_name = %s", 2038 port_info->pi_attrs.sym_port_name); 2039#endif /* >= EMLXS_MODREV4 */ 2040 | 1954 1955 1956 /* Log information */ 1957 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 1958 "Bind info: port_num = %d", bind_info->port_num); 1959 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 1960 "Bind info: port_handle = %p", bind_info->port_handle); 1961 --- 105 unchanged lines hidden (view full) --- 2067 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 2068 "Port info: sym_node_name = %s", 2069 port_info->pi_attrs.sym_node_name); 2070 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 2071 "Port info: sym_port_name = %s", 2072 port_info->pi_attrs.sym_port_name); 2073#endif /* >= EMLXS_MODREV4 */ 2074 |
2041 /* Set the bound flag */ 2042 port->flag |= EMLXS_PORT_BOUND; 2043 hba->num_of_ports++; 2044 | |
2045 mutex_exit(&EMLXS_PORT_LOCK); 2046 | 2075 mutex_exit(&EMLXS_PORT_LOCK); 2076 |
2047 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) { 2048 (void) emlxs_vpi_port_bind_notify(port); | 2077#ifdef SFCT_SUPPORT 2078 if (port->flag & EMLXS_TGT_ENABLED) { 2079 emlxs_fct_bind_port(port); |
2049 } | 2080 } |
2081#endif /* SFCT_SUPPORT */ |
|
2050 2051 return ((opaque_t)port); 2052 2053} /* emlxs_fca_bind_port() */ 2054 2055 2056static void 2057emlxs_fca_unbind_port(opaque_t fca_port_handle) 2058{ 2059 emlxs_port_t *port = (emlxs_port_t *)fca_port_handle; 2060 emlxs_hba_t *hba = HBA; 2061 2062 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 2063 "fca_unbind_port: port=%p", port); 2064 | 2082 2083 return ((opaque_t)port); 2084 2085} /* emlxs_fca_bind_port() */ 2086 2087 2088static void 2089emlxs_fca_unbind_port(opaque_t fca_port_handle) 2090{ 2091 emlxs_port_t *port = (emlxs_port_t *)fca_port_handle; 2092 emlxs_hba_t *hba = HBA; 2093 2094 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 2095 "fca_unbind_port: port=%p", port); 2096 |
2097 if (!(port->flag & EMLXS_PORT_BOUND)) { 2098 return; 2099 } 2100 |
|
2065 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) { 2066 (void) emlxs_vpi_port_unbind_notify(port, 1); 2067 } 2068 2069 /* Destroy & flush all port nodes, if they exist */ 2070 if (port->node_count) { | 2101 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) { 2102 (void) emlxs_vpi_port_unbind_notify(port, 1); 2103 } 2104 2105 /* Destroy & flush all port nodes, if they exist */ 2106 if (port->node_count) { |
2071 (void) emlxs_mb_unreg_node(port, 0, 0, 0, 0); | 2107 (void) EMLXS_SLI_UNREG_NODE(port, 0, 0, 0, 0); |
2072 } 2073 2074#if (EMLXS_MODREV >= EMLXS_MODREV5) 2075 if ((hba->sli_mode <= EMLXS_HBA_SLI3_MODE) && 2076 (hba->flag & FC_NPIV_ENABLED) && | 2108 } 2109 2110#if (EMLXS_MODREV >= EMLXS_MODREV5) 2111 if ((hba->sli_mode <= EMLXS_HBA_SLI3_MODE) && 2112 (hba->flag & FC_NPIV_ENABLED) && |
2077 (port->flag & (EMLXS_PORT_CONFIG | EMLXS_PORT_ENABLE))) { | 2113 (port->flag & (EMLXS_PORT_CONFIG | EMLXS_PORT_ENABLED))) { |
2078 (void) emlxs_mb_unreg_vpi(port); 2079 } 2080#endif 2081 2082 mutex_enter(&EMLXS_PORT_LOCK); | 2114 (void) emlxs_mb_unreg_vpi(port); 2115 } 2116#endif 2117 2118 mutex_enter(&EMLXS_PORT_LOCK); |
2119 if (port->flag & EMLXS_INI_BOUND) { 2120#if (EMLXS_MODREV >= EMLXS_MODREV5) 2121 port->flag &= ~(EMLXS_PORT_CONFIG | EMLXS_PORT_ENABLED); 2122#endif 2123 port->flag &= ~EMLXS_INI_BOUND; 2124 hba->num_of_ports--; |
|
2083 | 2125 |
2084 if (!(port->flag & EMLXS_PORT_BOUND)) { 2085 mutex_exit(&EMLXS_PORT_LOCK); 2086 return; 2087 } | 2126 /* Wait until ulp callback interface is idle */ 2127 while (port->ulp_busy) { 2128 mutex_exit(&EMLXS_PORT_LOCK); 2129 delay(drv_usectohz(500000)); 2130 mutex_enter(&EMLXS_PORT_LOCK); 2131 } |
2088 | 2132 |
2089 port->flag &= ~EMLXS_PORT_BOUND; 2090 hba->num_of_ports--; 2091 2092 port->ulp_handle = 0; 2093 port->ulp_statec = FC_STATE_OFFLINE; 2094 port->ulp_statec_cb = NULL; 2095 port->ulp_unsol_cb = NULL; 2096 | 2133 port->ulp_handle = 0; 2134 port->ulp_statec = FC_STATE_OFFLINE; 2135 port->ulp_statec_cb = NULL; 2136 port->ulp_unsol_cb = NULL; 2137 } |
2097 mutex_exit(&EMLXS_PORT_LOCK); 2098 | 2138 mutex_exit(&EMLXS_PORT_LOCK); 2139 |
2140#ifdef SFCT_SUPPORT 2141 /* Check if port was target bound */ 2142 if (port->flag & EMLXS_TGT_BOUND) { 2143 emlxs_fct_unbind_port(port); 2144 } 2145#endif /* SFCT_SUPPORT */ 2146 |
|
2099 return; 2100 2101} /* emlxs_fca_unbind_port() */ 2102 2103 2104/*ARGSUSED*/ 2105extern int 2106emlxs_fca_pkt_init(opaque_t fca_port_handle, fc_packet_t *pkt, int32_t sleep) --- 21 unchanged lines hidden (view full) --- 2128 2129 2130static void 2131emlxs_initialize_pkt(emlxs_port_t *port, emlxs_buf_t *sbp) 2132{ 2133 emlxs_hba_t *hba = HBA; 2134 emlxs_config_t *cfg = &CFG; 2135 fc_packet_t *pkt = PRIV2PKT(sbp); | 2147 return; 2148 2149} /* emlxs_fca_unbind_port() */ 2150 2151 2152/*ARGSUSED*/ 2153extern int 2154emlxs_fca_pkt_init(opaque_t fca_port_handle, fc_packet_t *pkt, int32_t sleep) --- 21 unchanged lines hidden (view full) --- 2176 2177 2178static void 2179emlxs_initialize_pkt(emlxs_port_t *port, emlxs_buf_t *sbp) 2180{ 2181 emlxs_hba_t *hba = HBA; 2182 emlxs_config_t *cfg = &CFG; 2183 fc_packet_t *pkt = PRIV2PKT(sbp); |
2136 uint32_t *iptr; | |
2137 2138 mutex_enter(&sbp->mtx); 2139 2140 /* Reinitialize */ 2141 sbp->pkt = pkt; 2142 sbp->port = port; 2143 sbp->bmp = NULL; 2144 sbp->pkt_flags &= (PACKET_VALID | PACKET_ALLOCATED); 2145 sbp->iotag = 0; 2146 sbp->ticks = 0; 2147 sbp->abort_attempts = 0; 2148 sbp->fpkt = NULL; 2149 sbp->flush_count = 0; 2150 sbp->next = NULL; 2151 | 2184 2185 mutex_enter(&sbp->mtx); 2186 2187 /* Reinitialize */ 2188 sbp->pkt = pkt; 2189 sbp->port = port; 2190 sbp->bmp = NULL; 2191 sbp->pkt_flags &= (PACKET_VALID | PACKET_ALLOCATED); 2192 sbp->iotag = 0; 2193 sbp->ticks = 0; 2194 sbp->abort_attempts = 0; 2195 sbp->fpkt = NULL; 2196 sbp->flush_count = 0; 2197 sbp->next = NULL; 2198 |
2152 if (!port->tgt_mode) { | 2199 if (port->mode == MODE_INITIATOR) { |
2153 sbp->node = NULL; 2154 sbp->did = 0; 2155 sbp->lun = EMLXS_LUN_NONE; 2156 sbp->class = 0; | 2200 sbp->node = NULL; 2201 sbp->did = 0; 2202 sbp->lun = EMLXS_LUN_NONE; 2203 sbp->class = 0; |
2157 sbp->class = 0; | |
2158 sbp->channel = NULL; 2159 } 2160 2161 bzero((void *)&sbp->iocbq, sizeof (IOCBQ)); 2162 sbp->iocbq.sbp = sbp; 2163 2164 if ((pkt->pkt_tran_flags & FC_TRAN_NO_INTR) || !pkt->pkt_comp || 2165 ddi_in_panic()) { --- 13 unchanged lines hidden (view full) --- 2179 /* This disables all IOCB on chip timeouts */ 2180 pkt->pkt_timeout = 0x80000000; 2181 } else if (pkt->pkt_timeout == 0 || pkt->pkt_timeout == 0xffffffff) { 2182 pkt->pkt_timeout = 60; 2183 } 2184 2185 /* Clear the response buffer */ 2186 if (pkt->pkt_rsplen) { | 2204 sbp->channel = NULL; 2205 } 2206 2207 bzero((void *)&sbp->iocbq, sizeof (IOCBQ)); 2208 sbp->iocbq.sbp = sbp; 2209 2210 if ((pkt->pkt_tran_flags & FC_TRAN_NO_INTR) || !pkt->pkt_comp || 2211 ddi_in_panic()) { --- 13 unchanged lines hidden (view full) --- 2225 /* This disables all IOCB on chip timeouts */ 2226 pkt->pkt_timeout = 0x80000000; 2227 } else if (pkt->pkt_timeout == 0 || pkt->pkt_timeout == 0xffffffff) { 2228 pkt->pkt_timeout = 60; 2229 } 2230 2231 /* Clear the response buffer */ 2232 if (pkt->pkt_rsplen) { |
2187 /* Check for FCP commands */ 2188 if ((pkt->pkt_tran_type == FC_PKT_FCP_READ) || 2189 (pkt->pkt_tran_type == FC_PKT_FCP_WRITE)) { 2190 iptr = (uint32_t *)pkt->pkt_resp; 2191 iptr[2] = 0; 2192 iptr[3] = 0; 2193 } else { | |
2194 bzero(pkt->pkt_resp, pkt->pkt_rsplen); 2195 } | 2233 bzero(pkt->pkt_resp, pkt->pkt_rsplen); 2234 } |
2196 } | |
2197 2198 mutex_exit(&sbp->mtx); 2199 2200 return; 2201 2202} /* emlxs_initialize_pkt() */ 2203 2204 --- 23 unchanged lines hidden (view full) --- 2228 2229 2230static int 2231emlxs_fca_get_cap(opaque_t fca_port_handle, char *cap, void *ptr) 2232{ 2233 emlxs_port_t *port = (emlxs_port_t *)fca_port_handle; 2234 emlxs_hba_t *hba = HBA; 2235 int32_t rval; | 2235 2236 mutex_exit(&sbp->mtx); 2237 2238 return; 2239 2240} /* emlxs_initialize_pkt() */ 2241 2242 --- 23 unchanged lines hidden (view full) --- 2266 2267 2268static int 2269emlxs_fca_get_cap(opaque_t fca_port_handle, char *cap, void *ptr) 2270{ 2271 emlxs_port_t *port = (emlxs_port_t *)fca_port_handle; 2272 emlxs_hba_t *hba = HBA; 2273 int32_t rval; |
2274 emlxs_config_t *cfg = &CFG; |
|
2236 | 2275 |
2237 if (!(port->flag & EMLXS_PORT_BOUND)) { | 2276 if (!(port->flag & EMLXS_INI_BOUND)) { |
2238 return (FC_CAP_ERROR); 2239 } 2240 2241 if (strcmp(cap, FC_NODE_WWN) == 0) { 2242 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 2243 "fca_get_cap: FC_NODE_WWN"); 2244 2245 bcopy((void *)&hba->wwnn, (void *)ptr, sizeof (NAME_TYPE)); --- 11 unchanged lines hidden (view full) --- 2257 hba->sparam.cls2.classValid = 0; 2258 2259 bcopy((void *)&hba->sparam, (void *)ptr, sizeof (SERV_PARM)); 2260 2261 rval = FC_CAP_FOUND; 2262 2263 } else if (strcmp(cap, FC_CAP_UNSOL_BUF) == 0) { 2264 int32_t *num_bufs; | 2277 return (FC_CAP_ERROR); 2278 } 2279 2280 if (strcmp(cap, FC_NODE_WWN) == 0) { 2281 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 2282 "fca_get_cap: FC_NODE_WWN"); 2283 2284 bcopy((void *)&hba->wwnn, (void *)ptr, sizeof (NAME_TYPE)); --- 11 unchanged lines hidden (view full) --- 2296 hba->sparam.cls2.classValid = 0; 2297 2298 bcopy((void *)&hba->sparam, (void *)ptr, sizeof (SERV_PARM)); 2299 2300 rval = FC_CAP_FOUND; 2301 2302 } else if (strcmp(cap, FC_CAP_UNSOL_BUF) == 0) { 2303 int32_t *num_bufs; |
2265 emlxs_config_t *cfg = &CFG; | |
2266 2267 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 2268 "fca_get_cap: FC_CAP_UNSOL_BUF (%d)", 2269 cfg[CFG_UB_BUFS].current); 2270 2271 num_bufs = (int32_t *)ptr; 2272 2273 /* We multiply by MAX_VPORTS because ULP uses a */ --- 103 unchanged lines hidden (view full) --- 2377 emlxs_hba_t *hba = HBA; 2378 uint32_t lilp_length; 2379 2380 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 2381 "fca_get_map: mapbuf=%p length=%d (%X,%X,%X,%X)", mapbuf, 2382 port->alpa_map[0], port->alpa_map[1], port->alpa_map[2], 2383 port->alpa_map[3], port->alpa_map[4]); 2384 | 2304 2305 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 2306 "fca_get_cap: FC_CAP_UNSOL_BUF (%d)", 2307 cfg[CFG_UB_BUFS].current); 2308 2309 num_bufs = (int32_t *)ptr; 2310 2311 /* We multiply by MAX_VPORTS because ULP uses a */ --- 103 unchanged lines hidden (view full) --- 2415 emlxs_hba_t *hba = HBA; 2416 uint32_t lilp_length; 2417 2418 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 2419 "fca_get_map: mapbuf=%p length=%d (%X,%X,%X,%X)", mapbuf, 2420 port->alpa_map[0], port->alpa_map[1], port->alpa_map[2], 2421 port->alpa_map[3], port->alpa_map[4]); 2422 |
2385 if (!(port->flag & EMLXS_PORT_BOUND)) { | 2423 if (!(port->flag & EMLXS_INI_BOUND)) { |
2386 return (FC_NOMAP); 2387 } 2388 2389 if (hba->topology != TOPOLOGY_LOOP) { 2390 return (FC_NOMAP); 2391 } 2392 2393 /* Check if alpa map is available */ --- 32 unchanged lines hidden (view full) --- 2426emlxs_fca_transport(opaque_t fca_port_handle, fc_packet_t *pkt) 2427{ 2428 emlxs_port_t *port = (emlxs_port_t *)fca_port_handle; 2429 emlxs_hba_t *hba = HBA; 2430 emlxs_buf_t *sbp; 2431 uint32_t rval; 2432 uint32_t pkt_flags; 2433 | 2424 return (FC_NOMAP); 2425 } 2426 2427 if (hba->topology != TOPOLOGY_LOOP) { 2428 return (FC_NOMAP); 2429 } 2430 2431 /* Check if alpa map is available */ --- 32 unchanged lines hidden (view full) --- 2464emlxs_fca_transport(opaque_t fca_port_handle, fc_packet_t *pkt) 2465{ 2466 emlxs_port_t *port = (emlxs_port_t *)fca_port_handle; 2467 emlxs_hba_t *hba = HBA; 2468 emlxs_buf_t *sbp; 2469 uint32_t rval; 2470 uint32_t pkt_flags; 2471 |
2472 /* Validate packet */ 2473 sbp = PKT2PRIV(pkt); 2474 |
|
2434 /* Make sure adapter is online */ | 2475 /* Make sure adapter is online */ |
2435 if (!(hba->flag & FC_ONLINE_MODE)) { | 2476 if (!(hba->flag & FC_ONLINE_MODE) && 2477 !(sbp->pkt_flags & PACKET_ALLOCATED)) { |
2436 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg, 2437 "Adapter offline."); 2438 | 2478 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg, 2479 "Adapter offline."); 2480 |
2439 return (FC_OFFLINE); | 2481 rval = (hba->flag & FC_ONLINING_MODE) ? 2482 FC_TRAN_BUSY : FC_OFFLINE; 2483 return (rval); |
2440 } 2441 | 2484 } 2485 |
2442 /* Validate packet */ 2443 sbp = PKT2PRIV(pkt); 2444 | |
2445 /* Make sure ULP was told that the port was online */ 2446 if ((port->ulp_statec == FC_STATE_OFFLINE) && 2447 !(sbp->pkt_flags & PACKET_ALLOCATED)) { 2448 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg, 2449 "Port offline."); 2450 2451 return (FC_OFFLINE); 2452 } --- 6 unchanged lines hidden (view full) --- 2459 } 2460 2461 if (!(sbp->pkt_flags & (PACKET_VALID | PACKET_ULP_OWNED))) { 2462 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_error_msg, 2463 "Invalid packet flags. sbp=%p port=%p flags=%x", sbp, 2464 sbp->port, sbp->pkt_flags); 2465 return (FC_BADPACKET); 2466 } | 2486 /* Make sure ULP was told that the port was online */ 2487 if ((port->ulp_statec == FC_STATE_OFFLINE) && 2488 !(sbp->pkt_flags & PACKET_ALLOCATED)) { 2489 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg, 2490 "Port offline."); 2491 2492 return (FC_OFFLINE); 2493 } --- 6 unchanged lines hidden (view full) --- 2500 } 2501 2502 if (!(sbp->pkt_flags & (PACKET_VALID | PACKET_ULP_OWNED))) { 2503 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_error_msg, 2504 "Invalid packet flags. sbp=%p port=%p flags=%x", sbp, 2505 sbp->port, sbp->pkt_flags); 2506 return (FC_BADPACKET); 2507 } |
2508 |
|
2467#ifdef SFCT_SUPPORT | 2509#ifdef SFCT_SUPPORT |
2468 if (port->tgt_mode && !sbp->fct_cmd && | 2510 if ((port->mode == MODE_TARGET) && !sbp->fct_cmd && |
2469 !(sbp->pkt_flags & PACKET_ALLOCATED)) { 2470 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_error_msg, 2471 "Packet blocked. Target mode."); 2472 return (FC_TRANSPORT_ERROR); 2473 } 2474#endif /* SFCT_SUPPORT */ 2475 2476#ifdef IDLE_TIMER --- 99 unchanged lines hidden (view full) --- 2576 2577static void 2578emlxs_poll(emlxs_port_t *port, emlxs_buf_t *sbp) 2579{ 2580 emlxs_hba_t *hba = HBA; 2581 fc_packet_t *pkt = PRIV2PKT(sbp); 2582 clock_t timeout; 2583 clock_t time; | 2511 !(sbp->pkt_flags & PACKET_ALLOCATED)) { 2512 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_error_msg, 2513 "Packet blocked. Target mode."); 2514 return (FC_TRANSPORT_ERROR); 2515 } 2516#endif /* SFCT_SUPPORT */ 2517 2518#ifdef IDLE_TIMER --- 99 unchanged lines hidden (view full) --- 2618 2619static void 2620emlxs_poll(emlxs_port_t *port, emlxs_buf_t *sbp) 2621{ 2622 emlxs_hba_t *hba = HBA; 2623 fc_packet_t *pkt = PRIV2PKT(sbp); 2624 clock_t timeout; 2625 clock_t time; |
2584 uint32_t att_bit; | |
2585 CHANNEL *cp; 2586 int in_panic = 0; 2587 2588 mutex_enter(&EMLXS_PORT_LOCK); 2589 hba->io_poll_count++; 2590 mutex_exit(&EMLXS_PORT_LOCK); 2591 2592 /* Check for panic situation */ --- 5 unchanged lines hidden (view full) --- 2598 * In panic situations there will be one thread with 2599 * no interrrupts (hard or soft) and no timers 2600 */ 2601 2602 /* 2603 * We must manually poll everything in this thread 2604 * to keep the driver going. 2605 */ | 2626 CHANNEL *cp; 2627 int in_panic = 0; 2628 2629 mutex_enter(&EMLXS_PORT_LOCK); 2630 hba->io_poll_count++; 2631 mutex_exit(&EMLXS_PORT_LOCK); 2632 2633 /* Check for panic situation */ --- 5 unchanged lines hidden (view full) --- 2639 * In panic situations there will be one thread with 2640 * no interrrupts (hard or soft) and no timers 2641 */ 2642 2643 /* 2644 * We must manually poll everything in this thread 2645 * to keep the driver going. 2646 */ |
2606 if (hba->sli_mode == EMLXS_HBA_SLI3_MODE) { 2607 switch (cp->channelno) { 2608 case FC_FCP_RING: 2609 att_bit = HA_R0ATT; 2610 break; | |
2611 | 2647 |
2612 case FC_IP_RING: 2613 att_bit = HA_R1ATT; 2614 break; 2615 2616 case FC_ELS_RING: 2617 att_bit = HA_R2ATT; 2618 break; 2619 2620 case FC_CT_RING: 2621 att_bit = HA_R3ATT; 2622 break; 2623 } 2624 } 2625 | |
2626 /* Keep polling the chip until our IO is completed */ 2627 /* Driver's timer will not function during panics. */ 2628 /* Therefore, timer checks must be performed manually. */ 2629 (void) drv_getparm(LBOLT, &time); 2630 timeout = time + drv_usectohz(1000000); 2631 while (!(sbp->pkt_flags & PACKET_COMPLETED)) { | 2648 /* Keep polling the chip until our IO is completed */ 2649 /* Driver's timer will not function during panics. */ 2650 /* Therefore, timer checks must be performed manually. */ 2651 (void) drv_getparm(LBOLT, &time); 2652 timeout = time + drv_usectohz(1000000); 2653 while (!(sbp->pkt_flags & PACKET_COMPLETED)) { |
2632 if (hba->sli_mode == EMLXS_HBA_SLI3_MODE) { 2633 EMLXS_SLI_POLL_INTR(hba, att_bit); 2634 } else { 2635 EMLXS_SLI_POLL_INTR(hba, 0); 2636 } | 2654 EMLXS_SLI_POLL_INTR(hba); |
2637 (void) drv_getparm(LBOLT, &time); 2638 2639 /* Trigger timer checks periodically */ 2640 if (time >= timeout) { 2641 emlxs_timer_checks(hba); 2642 timeout = time + drv_usectohz(1000000); 2643 } 2644 } --- 136 unchanged lines hidden (view full) --- 2781 2782 2783static int 2784emlxs_fca_ub_alloc(opaque_t fca_port_handle, uint64_t tokens[], uint32_t size, 2785 uint32_t *count, uint32_t type) 2786{ 2787 emlxs_port_t *port = (emlxs_port_t *)fca_port_handle; 2788 emlxs_hba_t *hba = HBA; | 2655 (void) drv_getparm(LBOLT, &time); 2656 2657 /* Trigger timer checks periodically */ 2658 if (time >= timeout) { 2659 emlxs_timer_checks(hba); 2660 timeout = time + drv_usectohz(1000000); 2661 } 2662 } --- 136 unchanged lines hidden (view full) --- 2799 2800 2801static int 2802emlxs_fca_ub_alloc(opaque_t fca_port_handle, uint64_t tokens[], uint32_t size, 2803 uint32_t *count, uint32_t type) 2804{ 2805 emlxs_port_t *port = (emlxs_port_t *)fca_port_handle; 2806 emlxs_hba_t *hba = HBA; |
2789 | |
2790 char *err = NULL; | 2807 char *err = NULL; |
2791 emlxs_unsol_buf_t *pool; 2792 emlxs_unsol_buf_t *new_pool; | 2808 emlxs_unsol_buf_t *pool = NULL; 2809 emlxs_unsol_buf_t *new_pool = NULL; 2810 emlxs_config_t *cfg = &CFG; |
2793 int32_t i; 2794 int result; 2795 uint32_t free_resv; 2796 uint32_t free; | 2811 int32_t i; 2812 int result; 2813 uint32_t free_resv; 2814 uint32_t free; |
2797 emlxs_config_t *cfg = &CFG; | |
2798 fc_unsol_buf_t *ubp; 2799 emlxs_ub_priv_t *ub_priv; 2800 int rc; 2801 | 2815 fc_unsol_buf_t *ubp; 2816 emlxs_ub_priv_t *ub_priv; 2817 int rc; 2818 |
2802 if (port->tgt_mode) { | 2819 if (!(port->flag & EMLXS_INI_ENABLED)) { |
2803 if (tokens && count) { 2804 bzero(tokens, (sizeof (uint64_t) * (*count))); 2805 } 2806 return (FC_SUCCESS); 2807 } 2808 | 2820 if (tokens && count) { 2821 bzero(tokens, (sizeof (uint64_t) * (*count))); 2822 } 2823 return (FC_SUCCESS); 2824 } 2825 |
2809 if (!(port->flag & EMLXS_PORT_BOUND)) { | 2826 if (!(port->flag & EMLXS_INI_BOUND)) { |
2810 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 2811 "fca_ub_alloc failed: Port not bound! size=%x count=%d " 2812 "type=%x", size, *count, type); 2813 2814 return (FC_FAILURE); 2815 } 2816 2817 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, --- 158 unchanged lines hidden (view full) --- 2976 2977 /* Set the post counts */ 2978 if (type == FC_TYPE_IS8802_SNAP) { 2979 MAILBOXQ *mbox; 2980 2981 port->ub_post[hba->channel_ip] += new_pool->pool_nentries; 2982 2983 if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba, | 2827 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 2828 "fca_ub_alloc failed: Port not bound! size=%x count=%d " 2829 "type=%x", size, *count, type); 2830 2831 return (FC_FAILURE); 2832 } 2833 2834 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, --- 158 unchanged lines hidden (view full) --- 2993 2994 /* Set the post counts */ 2995 if (type == FC_TYPE_IS8802_SNAP) { 2996 MAILBOXQ *mbox; 2997 2998 port->ub_post[hba->channel_ip] += new_pool->pool_nentries; 2999 3000 if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba, |
2984 MEM_MBOX, 1))) { | 3001 MEM_MBOX))) { |
2985 emlxs_mb_config_farp(hba, mbox); 2986 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, 2987 mbox, MBX_NOWAIT, 0); 2988 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) { 2989 emlxs_mem_put(hba, MEM_MBOX, (void *)mbox); 2990 } 2991 } 2992 port->flag |= EMLXS_PORT_IP_UP; --- 28 unchanged lines hidden (view full) --- 3021 3022 /* Free the private area of the buffer object */ 3023 kmem_free(ubp->ub_fca_private, sizeof (emlxs_ub_priv_t)); 3024 3025 tokens[i] = 0; 3026 port->ub_count--; 3027 } 3028 | 3002 emlxs_mb_config_farp(hba, mbox); 3003 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, 3004 mbox, MBX_NOWAIT, 0); 3005 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) { 3006 emlxs_mem_put(hba, MEM_MBOX, (void *)mbox); 3007 } 3008 } 3009 port->flag |= EMLXS_PORT_IP_UP; --- 28 unchanged lines hidden (view full) --- 3038 3039 /* Free the private area of the buffer object */ 3040 kmem_free(ubp->ub_fca_private, sizeof (emlxs_ub_priv_t)); 3041 3042 tokens[i] = 0; 3043 port->ub_count--; 3044 } 3045 |
3029 /* Free the array of buffer objects in the pool */ 3030 kmem_free((caddr_t)new_pool->fc_ubufs, 3031 (sizeof (fc_unsol_buf_t) * new_pool->pool_nentries)); | 3046 if (new_pool) { 3047 /* Free the array of buffer objects in the pool */ 3048 kmem_free((caddr_t)new_pool->fc_ubufs, 3049 (sizeof (fc_unsol_buf_t) * new_pool->pool_nentries)); |
3032 | 3050 |
3033 /* Free the pool object */ 3034 kmem_free((caddr_t)new_pool, sizeof (emlxs_unsol_buf_t)); | 3051 /* Free the pool object */ 3052 kmem_free((caddr_t)new_pool, sizeof (emlxs_unsol_buf_t)); 3053 } |
3035 3036 mutex_exit(&EMLXS_UB_LOCK); 3037 3038 return (result); 3039 3040} /* emlxs_fca_ub_alloc() */ 3041 3042 --- 77 unchanged lines hidden (view full) --- 3120 3121 if (count == 0) { 3122 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 3123 "fca_ub_release: Nothing to do. count=%d", count); 3124 3125 return (FC_SUCCESS); 3126 } 3127 | 3054 3055 mutex_exit(&EMLXS_UB_LOCK); 3056 3057 return (result); 3058 3059} /* emlxs_fca_ub_alloc() */ 3060 3061 --- 77 unchanged lines hidden (view full) --- 3139 3140 if (count == 0) { 3141 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 3142 "fca_ub_release: Nothing to do. count=%d", count); 3143 3144 return (FC_SUCCESS); 3145 } 3146 |
3128 if (!(port->flag & EMLXS_PORT_BOUND)) { | 3147 if (!(port->flag & EMLXS_INI_BOUND)) { |
3129 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 3130 "fca_ub_release failed: Port not bound. count=%d " 3131 "token[0]=%p", 3132 count, tokens[0]); 3133 3134 return (FC_UNBOUND); 3135 } 3136 --- 89 unchanged lines hidden (view full) --- 3226emlxs_fca_ub_free(opaque_t fca_port_handle, uint32_t count, uint64_t tokens[]) 3227{ 3228 emlxs_port_t *port = (emlxs_port_t *)fca_port_handle; 3229 emlxs_unsol_buf_t *pool; 3230 fc_unsol_buf_t *ubp; 3231 emlxs_ub_priv_t *ub_priv; 3232 uint32_t i; 3233 | 3148 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 3149 "fca_ub_release failed: Port not bound. count=%d " 3150 "token[0]=%p", 3151 count, tokens[0]); 3152 3153 return (FC_UNBOUND); 3154 } 3155 --- 89 unchanged lines hidden (view full) --- 3245emlxs_fca_ub_free(opaque_t fca_port_handle, uint32_t count, uint64_t tokens[]) 3246{ 3247 emlxs_port_t *port = (emlxs_port_t *)fca_port_handle; 3248 emlxs_unsol_buf_t *pool; 3249 fc_unsol_buf_t *ubp; 3250 emlxs_ub_priv_t *ub_priv; 3251 uint32_t i; 3252 |
3234 if (port->tgt_mode) { | 3253 if (!(port->flag & EMLXS_INI_ENABLED)) { |
3235 return (FC_SUCCESS); 3236 } 3237 3238 if (count == 0) { 3239 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 3240 "fca_ub_free: Nothing to do. count=%d token[0]=%p", count, 3241 tokens[0]); 3242 3243 return (FC_SUCCESS); 3244 } 3245 | 3254 return (FC_SUCCESS); 3255 } 3256 3257 if (count == 0) { 3258 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 3259 "fca_ub_free: Nothing to do. count=%d token[0]=%p", count, 3260 tokens[0]); 3261 3262 return (FC_SUCCESS); 3263 } 3264 |
3246 if (!(port->flag & EMLXS_PORT_BOUND)) { | 3265 if (!(port->flag & EMLXS_INI_BOUND)) { |
3247 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 3248 "fca_ub_free: Port not bound. count=%d token[0]=%p", count, 3249 tokens[0]); 3250 3251 return (FC_SUCCESS); 3252 } 3253 3254 mutex_enter(&EMLXS_UB_LOCK); --- 143 unchanged lines hidden (view full) --- 3398 emlxs_hba_t *hba = HBA; 3399 emlxs_config_t *cfg = &CFG; 3400 3401 emlxs_buf_t *sbp; 3402 NODELIST *nlp; 3403 NODELIST *prev_nlp; 3404 uint8_t channelno; 3405 CHANNEL *cp; | 3266 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 3267 "fca_ub_free: Port not bound. count=%d token[0]=%p", count, 3268 tokens[0]); 3269 3270 return (FC_SUCCESS); 3271 } 3272 3273 mutex_enter(&EMLXS_UB_LOCK); --- 143 unchanged lines hidden (view full) --- 3417 emlxs_hba_t *hba = HBA; 3418 emlxs_config_t *cfg = &CFG; 3419 3420 emlxs_buf_t *sbp; 3421 NODELIST *nlp; 3422 NODELIST *prev_nlp; 3423 uint8_t channelno; 3424 CHANNEL *cp; |
3406 clock_t timeout; | 3425 clock_t pkt_timeout; 3426 clock_t timer; |
3407 clock_t time; 3408 int32_t pkt_ret; 3409 IOCBQ *iocbq; 3410 IOCBQ *next; 3411 IOCBQ *prev; 3412 uint32_t found; | 3427 clock_t time; 3428 int32_t pkt_ret; 3429 IOCBQ *iocbq; 3430 IOCBQ *next; 3431 IOCBQ *prev; 3432 uint32_t found; |
3413 uint32_t att_bit; | |
3414 uint32_t pass = 0; 3415 3416 sbp = (emlxs_buf_t *)pkt->pkt_fca_private; 3417 iocbq = &sbp->iocbq; 3418 nlp = (NODELIST *)sbp->node; 3419 cp = (CHANNEL *)sbp->channel; 3420 channelno = (cp) ? cp->channelno : 0; 3421 | 3433 uint32_t pass = 0; 3434 3435 sbp = (emlxs_buf_t *)pkt->pkt_fca_private; 3436 iocbq = &sbp->iocbq; 3437 nlp = (NODELIST *)sbp->node; 3438 cp = (CHANNEL *)sbp->channel; 3439 channelno = (cp) ? cp->channelno : 0; 3440 |
3422 if (!(port->flag & EMLXS_PORT_BOUND)) { | 3441 if (!(port->flag & EMLXS_INI_BOUND)) { |
3423 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_abort_failed_msg, 3424 "Port not bound."); 3425 return (FC_UNBOUND); 3426 } 3427 3428 if (!(hba->flag & FC_ONLINE_MODE)) { 3429 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_abort_failed_msg, 3430 "Adapter offline."); --- 187 unchanged lines hidden (view full) --- 3618 } 3619 3620 /* Clear node */ 3621 nlp->nlp_next[channelno] = NULL; 3622 } 3623 3624 /* Free the ULPIOTAG and the bmp */ 3625 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) { | 3442 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_abort_failed_msg, 3443 "Port not bound."); 3444 return (FC_UNBOUND); 3445 } 3446 3447 if (!(hba->flag & FC_ONLINE_MODE)) { 3448 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_abort_failed_msg, 3449 "Adapter offline."); --- 187 unchanged lines hidden (view full) --- 3637 } 3638 3639 /* Clear node */ 3640 nlp->nlp_next[channelno] = NULL; 3641 } 3642 3643 /* Free the ULPIOTAG and the bmp */ 3644 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) { |
3626 emlxs_sli4_free_xri(hba, sbp, sbp->xrip, 1); | 3645 emlxs_sli4_free_xri(port, sbp, sbp->xrip, 1); |
3627 } else { 3628 (void) emlxs_unregister_pkt(cp, sbp->iotag, 1); 3629 } 3630 3631 3632 mutex_exit(&EMLXS_TX_CHANNEL_LOCK); 3633 3634 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT, --- 88 unchanged lines hidden (view full) --- 3723 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT, IOERR_ABORT_REQUESTED, 3724 1); 3725 3726done: 3727 3728 /* Now wait for the pkt to complete */ 3729 if (!(sbp->pkt_flags & PACKET_COMPLETED)) { 3730 /* Set thread timeout */ | 3646 } else { 3647 (void) emlxs_unregister_pkt(cp, sbp->iotag, 1); 3648 } 3649 3650 3651 mutex_exit(&EMLXS_TX_CHANNEL_LOCK); 3652 3653 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT, --- 88 unchanged lines hidden (view full) --- 3742 emlxs_pkt_complete(sbp, IOSTAT_LOCAL_REJECT, IOERR_ABORT_REQUESTED, 3743 1); 3744 3745done: 3746 3747 /* Now wait for the pkt to complete */ 3748 if (!(sbp->pkt_flags & PACKET_COMPLETED)) { 3749 /* Set thread timeout */ |
3731 timeout = emlxs_timeout(hba, 30); | 3750 pkt_timeout = emlxs_timeout(hba, 30); |
3732 3733 /* Check for panic situation */ 3734 if (ddi_in_panic()) { 3735 3736 /* 3737 * In panic situations there will be one thread with no 3738 * interrrupts (hard or soft) and no timers 3739 */ 3740 3741 /* 3742 * We must manually poll everything in this thread 3743 * to keep the driver going. 3744 */ 3745 | 3751 3752 /* Check for panic situation */ 3753 if (ddi_in_panic()) { 3754 3755 /* 3756 * In panic situations there will be one thread with no 3757 * interrrupts (hard or soft) and no timers 3758 */ 3759 3760 /* 3761 * We must manually poll everything in this thread 3762 * to keep the driver going. 3763 */ 3764 |
3746 cp = (CHANNEL *)sbp->channel; 3747 switch (cp->channelno) { 3748 case FC_FCP_RING: 3749 att_bit = HA_R0ATT; 3750 break; 3751 3752 case FC_IP_RING: 3753 att_bit = HA_R1ATT; 3754 break; 3755 3756 case FC_ELS_RING: 3757 att_bit = HA_R2ATT; 3758 break; 3759 3760 case FC_CT_RING: 3761 att_bit = HA_R3ATT; 3762 break; 3763 } 3764 | |
3765 /* Keep polling the chip until our IO is completed */ 3766 (void) drv_getparm(LBOLT, &time); | 3765 /* Keep polling the chip until our IO is completed */ 3766 (void) drv_getparm(LBOLT, &time); |
3767 while ((time < timeout) && | 3767 timer = time + drv_usectohz(1000000); 3768 while ((time < pkt_timeout) && |
3768 !(sbp->pkt_flags & PACKET_COMPLETED)) { | 3769 !(sbp->pkt_flags & PACKET_COMPLETED)) { |
3769 EMLXS_SLI_POLL_INTR(hba, att_bit); | 3770 EMLXS_SLI_POLL_INTR(hba); |
3770 (void) drv_getparm(LBOLT, &time); | 3771 (void) drv_getparm(LBOLT, &time); |
3772 3773 /* Trigger timer checks periodically */ 3774 if (time >= timer) { 3775 emlxs_timer_checks(hba); 3776 timer = time + drv_usectohz(1000000); 3777 } |
|
3771 } 3772 } else { | 3778 } 3779 } else { |
3773 /* Wait for IO completion or timeout */ | 3780 /* Wait for IO completion or pkt_timeout */ |
3774 mutex_enter(&EMLXS_PKT_LOCK); 3775 pkt_ret = 0; 3776 while ((pkt_ret != -1) && 3777 !(sbp->pkt_flags & PACKET_COMPLETED)) { 3778 pkt_ret = 3779 cv_timedwait(&EMLXS_PKT_CV, | 3781 mutex_enter(&EMLXS_PKT_LOCK); 3782 pkt_ret = 0; 3783 while ((pkt_ret != -1) && 3784 !(sbp->pkt_flags & PACKET_COMPLETED)) { 3785 pkt_ret = 3786 cv_timedwait(&EMLXS_PKT_CV, |
3780 &EMLXS_PKT_LOCK, timeout); | 3787 &EMLXS_PKT_LOCK, pkt_timeout); |
3781 } 3782 mutex_exit(&EMLXS_PKT_LOCK); 3783 } 3784 | 3788 } 3789 mutex_exit(&EMLXS_PKT_LOCK); 3790 } 3791 |
3785 /* Check if timeout occured. This is not good. */ | 3792 /* Check if pkt_timeout occured. This is not good. */ |
3786 /* Something happened to our IO. */ 3787 if (!(sbp->pkt_flags & PACKET_COMPLETED)) { 3788 /* Force the completion now */ 3789 goto force_it; 3790 } 3791 } 3792#if (EMLXS_MODREVX == EMLXS_MODREV2X) 3793 emlxs_unswap_pkt(sbp); --- 61 unchanged lines hidden (view full) --- 3855} /* emlxs_abort_all() */ 3856 3857 3858extern int32_t 3859emlxs_reset(emlxs_port_t *port, uint32_t cmd) 3860{ 3861 emlxs_hba_t *hba = HBA; 3862 int rval; | 3793 /* Something happened to our IO. */ 3794 if (!(sbp->pkt_flags & PACKET_COMPLETED)) { 3795 /* Force the completion now */ 3796 goto force_it; 3797 } 3798 } 3799#if (EMLXS_MODREVX == EMLXS_MODREV2X) 3800 emlxs_unswap_pkt(sbp); --- 61 unchanged lines hidden (view full) --- 3862} /* emlxs_abort_all() */ 3863 3864 3865extern int32_t 3866emlxs_reset(emlxs_port_t *port, uint32_t cmd) 3867{ 3868 emlxs_hba_t *hba = HBA; 3869 int rval; |
3870 int i = 0; |
|
3863 int ret; 3864 clock_t timeout; 3865 3866 switch (cmd) { 3867 case FC_FCA_LINK_RESET: 3868 | 3871 int ret; 3872 clock_t timeout; 3873 3874 switch (cmd) { 3875 case FC_FCA_LINK_RESET: 3876 |
3877 mutex_enter(&EMLXS_PORT_LOCK); |
|
3869 if (!(hba->flag & FC_ONLINE_MODE) || 3870 (hba->state <= FC_LINK_DOWN)) { | 3878 if (!(hba->flag & FC_ONLINE_MODE) || 3879 (hba->state <= FC_LINK_DOWN)) { |
3880 mutex_exit(&EMLXS_PORT_LOCK); |
|
3871 return (FC_SUCCESS); 3872 } 3873 | 3881 return (FC_SUCCESS); 3882 } 3883 |
3884 if (hba->reset_state & 3885 (FC_LINK_RESET_INP | FC_PORT_RESET_INP)) { 3886 mutex_exit(&EMLXS_PORT_LOCK); 3887 return (FC_FAILURE); 3888 } 3889 3890 hba->reset_state |= FC_LINK_RESET_INP; 3891 hba->reset_request |= FC_LINK_RESET; 3892 mutex_exit(&EMLXS_PORT_LOCK); 3893 |
|
3874 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 3875 "Resetting Link."); 3876 3877 mutex_enter(&EMLXS_LINKUP_LOCK); 3878 hba->linkup_wait_flag = TRUE; 3879 mutex_exit(&EMLXS_LINKUP_LOCK); 3880 3881 if (emlxs_reset_link(hba, 1, 1)) { 3882 mutex_enter(&EMLXS_LINKUP_LOCK); 3883 hba->linkup_wait_flag = FALSE; 3884 mutex_exit(&EMLXS_LINKUP_LOCK); 3885 | 3894 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 3895 "Resetting Link."); 3896 3897 mutex_enter(&EMLXS_LINKUP_LOCK); 3898 hba->linkup_wait_flag = TRUE; 3899 mutex_exit(&EMLXS_LINKUP_LOCK); 3900 3901 if (emlxs_reset_link(hba, 1, 1)) { 3902 mutex_enter(&EMLXS_LINKUP_LOCK); 3903 hba->linkup_wait_flag = FALSE; 3904 mutex_exit(&EMLXS_LINKUP_LOCK); 3905 |
3906 mutex_enter(&EMLXS_PORT_LOCK); 3907 hba->reset_state &= ~FC_LINK_RESET_INP; 3908 hba->reset_request &= ~FC_LINK_RESET; 3909 mutex_exit(&EMLXS_PORT_LOCK); 3910 |
|
3886 return (FC_FAILURE); 3887 } 3888 3889 mutex_enter(&EMLXS_LINKUP_LOCK); 3890 timeout = emlxs_timeout(hba, 60); 3891 ret = 0; 3892 while ((ret != -1) && (hba->linkup_wait_flag == TRUE)) { 3893 ret = 3894 cv_timedwait(&EMLXS_LINKUP_CV, &EMLXS_LINKUP_LOCK, 3895 timeout); 3896 } 3897 3898 hba->linkup_wait_flag = FALSE; 3899 mutex_exit(&EMLXS_LINKUP_LOCK); 3900 | 3911 return (FC_FAILURE); 3912 } 3913 3914 mutex_enter(&EMLXS_LINKUP_LOCK); 3915 timeout = emlxs_timeout(hba, 60); 3916 ret = 0; 3917 while ((ret != -1) && (hba->linkup_wait_flag == TRUE)) { 3918 ret = 3919 cv_timedwait(&EMLXS_LINKUP_CV, &EMLXS_LINKUP_LOCK, 3920 timeout); 3921 } 3922 3923 hba->linkup_wait_flag = FALSE; 3924 mutex_exit(&EMLXS_LINKUP_LOCK); 3925 |
3926 mutex_enter(&EMLXS_PORT_LOCK); 3927 hba->reset_state &= ~FC_LINK_RESET_INP; 3928 hba->reset_request &= ~FC_LINK_RESET; 3929 mutex_exit(&EMLXS_PORT_LOCK); 3930 |
|
3901 if (ret == -1) { 3902 return (FC_FAILURE); 3903 } 3904 3905 return (FC_SUCCESS); 3906 3907 case FC_FCA_CORE: 3908#ifdef DUMP_SUPPORT --- 7 unchanged lines hidden (view full) --- 3916 emlxs_dump_wait(hba); 3917 3918 return (FC_SUCCESS); 3919#endif /* DUMP_SUPPORT */ 3920 3921 case FC_FCA_RESET: 3922 case FC_FCA_RESET_CORE: 3923 | 3931 if (ret == -1) { 3932 return (FC_FAILURE); 3933 } 3934 3935 return (FC_SUCCESS); 3936 3937 case FC_FCA_CORE: 3938#ifdef DUMP_SUPPORT --- 7 unchanged lines hidden (view full) --- 3946 emlxs_dump_wait(hba); 3947 3948 return (FC_SUCCESS); 3949#endif /* DUMP_SUPPORT */ 3950 3951 case FC_FCA_RESET: 3952 case FC_FCA_RESET_CORE: 3953 |
3954 mutex_enter(&EMLXS_PORT_LOCK); 3955 if (hba->reset_state & FC_PORT_RESET_INP) { 3956 mutex_exit(&EMLXS_PORT_LOCK); 3957 return (FC_FAILURE); 3958 } 3959 3960 hba->reset_state |= FC_PORT_RESET_INP; 3961 hba->reset_request |= (FC_PORT_RESET | FC_LINK_RESET); 3962 3963 /* wait for any pending link resets to complete */ 3964 while ((hba->reset_state & FC_LINK_RESET_INP) && 3965 (i++ < 1000)) { 3966 mutex_exit(&EMLXS_PORT_LOCK); 3967 delay(drv_usectohz(1000)); 3968 mutex_enter(&EMLXS_PORT_LOCK); 3969 } 3970 3971 if (hba->reset_state & FC_LINK_RESET_INP) { 3972 hba->reset_state &= ~FC_PORT_RESET_INP; 3973 hba->reset_request &= ~(FC_PORT_RESET | FC_LINK_RESET); 3974 mutex_exit(&EMLXS_PORT_LOCK); 3975 return (FC_FAILURE); 3976 } 3977 mutex_exit(&EMLXS_PORT_LOCK); 3978 |
|
3924 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 3925 "Resetting Adapter."); 3926 3927 rval = FC_SUCCESS; 3928 | 3979 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 3980 "Resetting Adapter."); 3981 3982 rval = FC_SUCCESS; 3983 |
3929 if (emlxs_offline(hba) == 0) { | 3984 if (emlxs_offline(hba, 0) == 0) { |
3930 (void) emlxs_online(hba); 3931 } else { 3932 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 3933 "Adapter reset failed. Device busy."); 3934 3935 rval = FC_DEVICE_BUSY; 3936 } 3937 | 3985 (void) emlxs_online(hba); 3986 } else { 3987 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 3988 "Adapter reset failed. Device busy."); 3989 3990 rval = FC_DEVICE_BUSY; 3991 } 3992 |
3993 mutex_enter(&EMLXS_PORT_LOCK); 3994 hba->reset_state &= ~FC_PORT_RESET_INP; 3995 hba->reset_request &= ~(FC_PORT_RESET | FC_LINK_RESET); 3996 mutex_exit(&EMLXS_PORT_LOCK); 3997 |
|
3938 return (rval); 3939 | 3998 return (rval); 3999 |
4000 case EMLXS_DFC_RESET_ALL: 4001 case EMLXS_DFC_RESET_ALL_FORCE_DUMP: 4002 4003 mutex_enter(&EMLXS_PORT_LOCK); 4004 if (hba->reset_state & FC_PORT_RESET_INP) { 4005 mutex_exit(&EMLXS_PORT_LOCK); 4006 return (FC_FAILURE); 4007 } 4008 4009 hba->reset_state |= FC_PORT_RESET_INP; 4010 hba->reset_request |= (FC_PORT_RESET | FC_LINK_RESET); 4011 4012 /* wait for any pending link resets to complete */ 4013 while ((hba->reset_state & FC_LINK_RESET_INP) && 4014 (i++ < 1000)) { 4015 mutex_exit(&EMLXS_PORT_LOCK); 4016 delay(drv_usectohz(1000)); 4017 mutex_enter(&EMLXS_PORT_LOCK); 4018 } 4019 4020 if (hba->reset_state & FC_LINK_RESET_INP) { 4021 hba->reset_state &= ~FC_PORT_RESET_INP; 4022 hba->reset_request &= ~(FC_PORT_RESET | FC_LINK_RESET); 4023 mutex_exit(&EMLXS_PORT_LOCK); 4024 return (FC_FAILURE); 4025 } 4026 mutex_exit(&EMLXS_PORT_LOCK); 4027 4028 rval = FC_SUCCESS; 4029 4030 if (cmd == EMLXS_DFC_RESET_ALL) { 4031 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 4032 "Resetting Adapter (All Firmware Reset)."); 4033 4034 emlxs_sli4_hba_reset_all(hba, 0); 4035 } else { 4036 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 4037 "Resetting Adapter " 4038 "(All Firmware Reset, Force Dump)."); 4039 4040 emlxs_sli4_hba_reset_all(hba, 1); 4041 } 4042 4043 mutex_enter(&EMLXS_PORT_LOCK); 4044 hba->reset_state &= ~FC_PORT_RESET_INP; 4045 hba->reset_request &= ~(FC_PORT_RESET | FC_LINK_RESET); 4046 mutex_exit(&EMLXS_PORT_LOCK); 4047 4048 /* Wait for the timer thread to detect the error condition */ 4049 delay(drv_usectohz(1000000)); 4050 4051 /* Wait for the HBA to re-initialize */ 4052 i = 0; 4053 mutex_enter(&EMLXS_PORT_LOCK); 4054 while (!(hba->flag & FC_ONLINE_MODE) && (i++ < 30)) { 4055 mutex_exit(&EMLXS_PORT_LOCK); 4056 delay(drv_usectohz(1000000)); 4057 mutex_enter(&EMLXS_PORT_LOCK); 4058 } 4059 4060 if (!(hba->flag & FC_ONLINE_MODE)) { 4061 rval = FC_FAILURE; 4062 } 4063 4064 mutex_exit(&EMLXS_PORT_LOCK); 4065 4066 return (rval); 4067 |
|
3940 default: 3941 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 4068 default: 4069 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
3942 "emlxs_reset: Unknown command. cmd=%x", cmd); | 4070 "reset: Unknown command. cmd=%x", cmd); |
3943 3944 break; 3945 } 3946 3947 return (FC_FAILURE); 3948 3949} /* emlxs_reset() */ 3950 3951 3952extern int32_t 3953emlxs_fca_reset(opaque_t fca_port_handle, uint32_t cmd) 3954{ 3955 emlxs_port_t *port = (emlxs_port_t *)fca_port_handle; 3956 emlxs_hba_t *hba = HBA; 3957 int32_t rval; 3958 | 4071 4072 break; 4073 } 4074 4075 return (FC_FAILURE); 4076 4077} /* emlxs_reset() */ 4078 4079 4080extern int32_t 4081emlxs_fca_reset(opaque_t fca_port_handle, uint32_t cmd) 4082{ 4083 emlxs_port_t *port = (emlxs_port_t *)fca_port_handle; 4084 emlxs_hba_t *hba = HBA; 4085 int32_t rval; 4086 |
3959 if (!(port->flag & EMLXS_PORT_BOUND)) { | 4087 if (port->mode != MODE_INITIATOR) { |
3960 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 4088 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4089 "fca_reset failed. Port is not in initiator mode."); 4090 4091 return (FC_FAILURE); 4092 } 4093 4094 if (!(port->flag & EMLXS_INI_BOUND)) { 4095 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
|
3961 "fca_reset: Port not bound."); 3962 3963 return (FC_UNBOUND); 3964 } 3965 3966 switch (cmd) { 3967 case FC_FCA_LINK_RESET: 3968 if (hba->fw_flag & FW_UPDATE_NEEDED) { --- 41 unchanged lines hidden (view full) --- 4010extern int 4011emlxs_fca_port_manage(opaque_t fca_port_handle, fc_fca_pm_t *pm) 4012{ 4013 emlxs_port_t *port = (emlxs_port_t *)fca_port_handle; 4014 emlxs_hba_t *hba = HBA; 4015 int32_t ret; 4016 emlxs_vpd_t *vpd = &VPD; 4017 | 4096 "fca_reset: Port not bound."); 4097 4098 return (FC_UNBOUND); 4099 } 4100 4101 switch (cmd) { 4102 case FC_FCA_LINK_RESET: 4103 if (hba->fw_flag & FW_UPDATE_NEEDED) { --- 41 unchanged lines hidden (view full) --- 4145extern int 4146emlxs_fca_port_manage(opaque_t fca_port_handle, fc_fca_pm_t *pm) 4147{ 4148 emlxs_port_t *port = (emlxs_port_t *)fca_port_handle; 4149 emlxs_hba_t *hba = HBA; 4150 int32_t ret; 4151 emlxs_vpd_t *vpd = &VPD; 4152 |
4018 | |
4019 ret = FC_SUCCESS; 4020 | 4153 ret = FC_SUCCESS; 4154 |
4021 if (!(port->flag & EMLXS_PORT_BOUND)) { 4022 return (FC_UNBOUND); 4023 } 4024 4025 | |
4026#ifdef IDLE_TIMER 4027 emlxs_pm_busy_component(hba); 4028#endif /* IDLE_TIMER */ 4029 4030 switch (pm->pm_cmd_code) { 4031 4032 case FC_PORT_GET_FW_REV: 4033 { 4034 char buffer[128]; 4035 4036 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 4037 "fca_port_manage: FC_PORT_GET_FW_REV"); 4038 | 4155#ifdef IDLE_TIMER 4156 emlxs_pm_busy_component(hba); 4157#endif /* IDLE_TIMER */ 4158 4159 switch (pm->pm_cmd_code) { 4160 4161 case FC_PORT_GET_FW_REV: 4162 { 4163 char buffer[128]; 4164 4165 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 4166 "fca_port_manage: FC_PORT_GET_FW_REV"); 4167 |
4039 (void) sprintf(buffer, "%s %s", hba->model_info.model, | 4168 (void) snprintf(buffer, (sizeof (buffer)-1), 4169 "%s %s", hba->model_info.model, |
4040 vpd->fw_version); 4041 bzero(pm->pm_data_buf, pm->pm_data_len); 4042 4043 if (pm->pm_data_len < strlen(buffer) + 1) { 4044 ret = FC_NOMEM; 4045 4046 break; 4047 } 4048 | 4170 vpd->fw_version); 4171 bzero(pm->pm_data_buf, pm->pm_data_len); 4172 4173 if (pm->pm_data_len < strlen(buffer) + 1) { 4174 ret = FC_NOMEM; 4175 4176 break; 4177 } 4178 |
4049 (void) strcpy(pm->pm_data_buf, buffer); | 4179 (void) strncpy(pm->pm_data_buf, buffer, 4180 (pm->pm_data_len-1)); |
4050 break; 4051 } 4052 4053 case FC_PORT_GET_FCODE_REV: 4054 { 4055 char buffer[128]; 4056 4057 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 4058 "fca_port_manage: FC_PORT_GET_FCODE_REV"); 4059 4060 /* Force update here just to be sure */ 4061 emlxs_get_fcode_version(hba); 4062 | 4181 break; 4182 } 4183 4184 case FC_PORT_GET_FCODE_REV: 4185 { 4186 char buffer[128]; 4187 4188 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 4189 "fca_port_manage: FC_PORT_GET_FCODE_REV"); 4190 4191 /* Force update here just to be sure */ 4192 emlxs_get_fcode_version(hba); 4193 |
4063 (void) sprintf(buffer, "%s %s", hba->model_info.model, | 4194 (void) snprintf(buffer, (sizeof (buffer)-1), 4195 "%s %s", hba->model_info.model, |
4064 vpd->fcode_version); 4065 bzero(pm->pm_data_buf, pm->pm_data_len); 4066 4067 if (pm->pm_data_len < strlen(buffer) + 1) { 4068 ret = FC_NOMEM; 4069 break; 4070 } 4071 | 4196 vpd->fcode_version); 4197 bzero(pm->pm_data_buf, pm->pm_data_len); 4198 4199 if (pm->pm_data_len < strlen(buffer) + 1) { 4200 ret = FC_NOMEM; 4201 break; 4202 } 4203 |
4072 (void) strcpy(pm->pm_data_buf, buffer); | 4204 (void) strncpy(pm->pm_data_buf, buffer, 4205 (pm->pm_data_len-1)); |
4073 break; 4074 } 4075 4076 case FC_PORT_GET_DUMP_SIZE: 4077 { 4078#ifdef DUMP_SUPPORT 4079 uint32_t dump_size = 0; 4080 --- 103 unchanged lines hidden (view full) --- 4184 *link_state |= FC_STATE_4GBIT_SPEED; 4185 break; 4186 case LA_8GHZ_LINK: 4187 *link_state |= FC_STATE_8GBIT_SPEED; 4188 break; 4189 case LA_10GHZ_LINK: 4190 *link_state |= FC_STATE_10GBIT_SPEED; 4191 break; | 4206 break; 4207 } 4208 4209 case FC_PORT_GET_DUMP_SIZE: 4210 { 4211#ifdef DUMP_SUPPORT 4212 uint32_t dump_size = 0; 4213 --- 103 unchanged lines hidden (view full) --- 4317 *link_state |= FC_STATE_4GBIT_SPEED; 4318 break; 4319 case LA_8GHZ_LINK: 4320 *link_state |= FC_STATE_8GBIT_SPEED; 4321 break; 4322 case LA_10GHZ_LINK: 4323 *link_state |= FC_STATE_10GBIT_SPEED; 4324 break; |
4325 case LA_16GHZ_LINK: 4326 *link_state |= FC_STATE_16GBIT_SPEED; 4327 break; |
|
4192 case LA_1GHZ_LINK: 4193 default: 4194 *link_state |= FC_STATE_1GBIT_SPEED; 4195 break; 4196 } 4197 } else { 4198 *link_state = FC_STATE_OFFLINE; 4199 } --- 16 unchanged lines hidden (view full) --- 4216 "fca_port_manage: FC_PORT_RLS / FC_PORT_ERR_STATS"); 4217 4218 if (pm->pm_data_len < sizeof (fc_rls_acc_t)) { 4219 ret = FC_NOMEM; 4220 break; 4221 } 4222 4223 if ((mbq = (MAILBOXQ *)emlxs_mem_get(hba, | 4328 case LA_1GHZ_LINK: 4329 default: 4330 *link_state |= FC_STATE_1GBIT_SPEED; 4331 break; 4332 } 4333 } else { 4334 *link_state = FC_STATE_OFFLINE; 4335 } --- 16 unchanged lines hidden (view full) --- 4352 "fca_port_manage: FC_PORT_RLS / FC_PORT_ERR_STATS"); 4353 4354 if (pm->pm_data_len < sizeof (fc_rls_acc_t)) { 4355 ret = FC_NOMEM; 4356 break; 4357 } 4358 4359 if ((mbq = (MAILBOXQ *)emlxs_mem_get(hba, |
4224 MEM_MBOX, 1)) == 0) { | 4360 MEM_MBOX)) == 0) { |
4225 ret = FC_NOMEM; 4226 break; 4227 } 4228 mb = (MAILBOX *)mbq; 4229 4230 emlxs_mb_read_lnk_stat(hba, mbq); 4231 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) 4232 != MBX_SUCCESS) { --- 42 unchanged lines hidden (view full) --- 4275 4276 switch (pm->pm_cmd_flags) { 4277 case EMLXS_DIAG_BIU: 4278 4279 if (!(hba->flag & FC_ONLINE_MODE)) { 4280 return (FC_OFFLINE); 4281 } 4282 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 4361 ret = FC_NOMEM; 4362 break; 4363 } 4364 mb = (MAILBOX *)mbq; 4365 4366 emlxs_mb_read_lnk_stat(hba, mbq); 4367 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) 4368 != MBX_SUCCESS) { --- 42 unchanged lines hidden (view full) --- 4411 4412 switch (pm->pm_cmd_flags) { 4413 case EMLXS_DIAG_BIU: 4414 4415 if (!(hba->flag & FC_ONLINE_MODE)) { 4416 return (FC_OFFLINE); 4417 } 4418 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4283 "fca_port_manage: EMLXS_DIAG_BIU"); | 4419 "fca_port_manage: DIAG_BIU"); |
4284 4285 if (pm->pm_data_len) { 4286 pattern = *((uint32_t *)pm->pm_data_buf); 4287 } 4288 4289 errno = emlxs_diag_biu_run(hba, pattern); 4290 4291 if (pm->pm_stat_len == sizeof (errno)) { --- 4 unchanged lines hidden (view full) --- 4296 4297 4298 case EMLXS_DIAG_POST: 4299 4300 if (!(hba->flag & FC_ONLINE_MODE)) { 4301 return (FC_OFFLINE); 4302 } 4303 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 4420 4421 if (pm->pm_data_len) { 4422 pattern = *((uint32_t *)pm->pm_data_buf); 4423 } 4424 4425 errno = emlxs_diag_biu_run(hba, pattern); 4426 4427 if (pm->pm_stat_len == sizeof (errno)) { --- 4 unchanged lines hidden (view full) --- 4432 4433 4434 case EMLXS_DIAG_POST: 4435 4436 if (!(hba->flag & FC_ONLINE_MODE)) { 4437 return (FC_OFFLINE); 4438 } 4439 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4304 "fca_port_manage: EMLXS_DIAG_POST"); | 4440 "fca_port_manage: DIAG_POST"); |
4305 4306 errno = emlxs_diag_post_run(hba); 4307 4308 if (pm->pm_stat_len == sizeof (errno)) { 4309 *(int *)pm->pm_stat_buf = errno; 4310 } 4311 4312 break; 4313 4314 4315 case EMLXS_DIAG_ECHO: 4316 4317 if (!(hba->flag & FC_ONLINE_MODE)) { 4318 return (FC_OFFLINE); 4319 } 4320 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 4441 4442 errno = emlxs_diag_post_run(hba); 4443 4444 if (pm->pm_stat_len == sizeof (errno)) { 4445 *(int *)pm->pm_stat_buf = errno; 4446 } 4447 4448 break; 4449 4450 4451 case EMLXS_DIAG_ECHO: 4452 4453 if (!(hba->flag & FC_ONLINE_MODE)) { 4454 return (FC_OFFLINE); 4455 } 4456 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4321 "fca_port_manage: EMLXS_DIAG_ECHO"); | 4457 "fca_port_manage: DIAG_ECHO"); |
4322 4323 if (pm->pm_cmd_len != sizeof (uint32_t)) { 4324 ret = FC_INVALID_REQUEST; 4325 break; 4326 } 4327 4328 did = *((uint32_t *)pm->pm_cmd_buf); 4329 --- 12 unchanged lines hidden (view full) --- 4342 4343 case EMLXS_PARM_GET_NUM: 4344 { 4345 uint32_t *num; 4346 emlxs_config_t *cfg; 4347 uint32_t i; 4348 uint32_t count; 4349 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 4458 4459 if (pm->pm_cmd_len != sizeof (uint32_t)) { 4460 ret = FC_INVALID_REQUEST; 4461 break; 4462 } 4463 4464 did = *((uint32_t *)pm->pm_cmd_buf); 4465 --- 12 unchanged lines hidden (view full) --- 4478 4479 case EMLXS_PARM_GET_NUM: 4480 { 4481 uint32_t *num; 4482 emlxs_config_t *cfg; 4483 uint32_t i; 4484 uint32_t count; 4485 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4350 "fca_port_manage: EMLXS_PARM_GET_NUM"); | 4486 "fca_port_manage: PARM_GET_NUM"); |
4351 4352 if (pm->pm_stat_len < sizeof (uint32_t)) { 4353 ret = FC_NOMEM; 4354 break; 4355 } 4356 4357 num = (uint32_t *)pm->pm_stat_buf; 4358 count = 0; --- 13 unchanged lines hidden (view full) --- 4372 case EMLXS_PARM_GET_LIST: 4373 { 4374 emlxs_parm_t *parm; 4375 emlxs_config_t *cfg; 4376 uint32_t i; 4377 uint32_t max_count; 4378 4379 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 4487 4488 if (pm->pm_stat_len < sizeof (uint32_t)) { 4489 ret = FC_NOMEM; 4490 break; 4491 } 4492 4493 num = (uint32_t *)pm->pm_stat_buf; 4494 count = 0; --- 13 unchanged lines hidden (view full) --- 4508 case EMLXS_PARM_GET_LIST: 4509 { 4510 emlxs_parm_t *parm; 4511 emlxs_config_t *cfg; 4512 uint32_t i; 4513 uint32_t max_count; 4514 4515 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4380 "fca_port_manage: EMLXS_PARM_GET_LIST"); | 4516 "fca_port_manage: PARM_GET_LIST"); |
4381 4382 if (pm->pm_stat_len < sizeof (emlxs_parm_t)) { 4383 ret = FC_NOMEM; 4384 break; 4385 } 4386 4387 max_count = pm->pm_stat_len / sizeof (emlxs_parm_t); 4388 4389 parm = (emlxs_parm_t *)pm->pm_stat_buf; 4390 cfg = &CFG; 4391 for (i = 0; i < NUM_CFG_PARAM && max_count; i++, 4392 cfg++) { 4393 if (!(cfg->flags & PARM_HIDDEN)) { | 4517 4518 if (pm->pm_stat_len < sizeof (emlxs_parm_t)) { 4519 ret = FC_NOMEM; 4520 break; 4521 } 4522 4523 max_count = pm->pm_stat_len / sizeof (emlxs_parm_t); 4524 4525 parm = (emlxs_parm_t *)pm->pm_stat_buf; 4526 cfg = &CFG; 4527 for (i = 0; i < NUM_CFG_PARAM && max_count; i++, 4528 cfg++) { 4529 if (!(cfg->flags & PARM_HIDDEN)) { |
4394 (void) strcpy(parm->label, cfg->string); | 4530 (void) strncpy(parm->label, cfg->string, 4531 (sizeof (parm->label)-1)); |
4395 parm->min = cfg->low; 4396 parm->max = cfg->hi; 4397 parm->def = cfg->def; 4398 parm->current = cfg->current; 4399 parm->flags = cfg->flags; | 4532 parm->min = cfg->low; 4533 parm->max = cfg->hi; 4534 parm->def = cfg->def; 4535 parm->current = cfg->current; 4536 parm->flags = cfg->flags; |
4400 (void) strcpy(parm->help, cfg->help); | 4537 (void) strncpy(parm->help, cfg->help, 4538 (sizeof (parm->help)-1)); |
4401 parm++; 4402 max_count--; 4403 } 4404 } 4405 4406 break; 4407 } 4408 4409 case EMLXS_PARM_GET: 4410 { 4411 emlxs_parm_t *parm_in; 4412 emlxs_parm_t *parm_out; 4413 emlxs_config_t *cfg; 4414 uint32_t i; 4415 uint32_t len; 4416 4417 if (pm->pm_cmd_len < sizeof (emlxs_parm_t)) { 4418 EMLXS_MSGF(EMLXS_CONTEXT, 4419 &emlxs_sfs_debug_msg, | 4539 parm++; 4540 max_count--; 4541 } 4542 } 4543 4544 break; 4545 } 4546 4547 case EMLXS_PARM_GET: 4548 { 4549 emlxs_parm_t *parm_in; 4550 emlxs_parm_t *parm_out; 4551 emlxs_config_t *cfg; 4552 uint32_t i; 4553 uint32_t len; 4554 4555 if (pm->pm_cmd_len < sizeof (emlxs_parm_t)) { 4556 EMLXS_MSGF(EMLXS_CONTEXT, 4557 &emlxs_sfs_debug_msg, |
4420 "fca_port_manage: EMLXS_PARM_GET. " | 4558 "fca_port_manage: PARM_GET. " |
4421 "inbuf too small."); 4422 4423 ret = FC_BADCMD; 4424 break; 4425 } 4426 4427 if (pm->pm_stat_len < sizeof (emlxs_parm_t)) { 4428 EMLXS_MSGF(EMLXS_CONTEXT, 4429 &emlxs_sfs_debug_msg, | 4559 "inbuf too small."); 4560 4561 ret = FC_BADCMD; 4562 break; 4563 } 4564 4565 if (pm->pm_stat_len < sizeof (emlxs_parm_t)) { 4566 EMLXS_MSGF(EMLXS_CONTEXT, 4567 &emlxs_sfs_debug_msg, |
4430 "fca_port_manage: EMLXS_PARM_GET. " | 4568 "fca_port_manage: PARM_GET. " |
4431 "outbuf too small"); 4432 4433 ret = FC_BADCMD; 4434 break; 4435 } 4436 4437 parm_in = (emlxs_parm_t *)pm->pm_cmd_buf; 4438 parm_out = (emlxs_parm_t *)pm->pm_stat_buf; 4439 len = strlen(parm_in->label); 4440 cfg = &CFG; 4441 ret = FC_BADOBJECT; 4442 4443 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 4569 "outbuf too small"); 4570 4571 ret = FC_BADCMD; 4572 break; 4573 } 4574 4575 parm_in = (emlxs_parm_t *)pm->pm_cmd_buf; 4576 parm_out = (emlxs_parm_t *)pm->pm_stat_buf; 4577 len = strlen(parm_in->label); 4578 cfg = &CFG; 4579 ret = FC_BADOBJECT; 4580 4581 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4444 "fca_port_manage: EMLXS_PARM_GET: %s", 4445 parm_in->label); | 4582 "fca_port_manage: PARM_GET: %s=0x%x,%d", 4583 parm_in->label, parm_in->current, 4584 parm_in->current); |
4446 4447 for (i = 0; i < NUM_CFG_PARAM; i++, cfg++) { 4448 if (len == strlen(cfg->string) && 4449 (strcmp(parm_in->label, 4450 cfg->string) == 0)) { | 4585 4586 for (i = 0; i < NUM_CFG_PARAM; i++, cfg++) { 4587 if (len == strlen(cfg->string) && 4588 (strcmp(parm_in->label, 4589 cfg->string) == 0)) { |
4451 (void) strcpy(parm_out->label, 4452 cfg->string); | 4590 (void) strncpy(parm_out->label, 4591 cfg->string, 4592 (sizeof (parm_out->label)-1)); |
4453 parm_out->min = cfg->low; 4454 parm_out->max = cfg->hi; 4455 parm_out->def = cfg->def; 4456 parm_out->current = cfg->current; 4457 parm_out->flags = cfg->flags; | 4593 parm_out->min = cfg->low; 4594 parm_out->max = cfg->hi; 4595 parm_out->def = cfg->def; 4596 parm_out->current = cfg->current; 4597 parm_out->flags = cfg->flags; |
4458 (void) strcpy(parm_out->help, 4459 cfg->help); | 4598 (void) strncpy(parm_out->help, 4599 cfg->help, 4600 (sizeof (parm_out->help)-1)); |
4460 4461 ret = FC_SUCCESS; 4462 break; 4463 } 4464 } 4465 4466 break; 4467 } --- 4 unchanged lines hidden (view full) --- 4472 emlxs_parm_t *parm_out; 4473 emlxs_config_t *cfg; 4474 uint32_t i; 4475 uint32_t len; 4476 4477 if (pm->pm_cmd_len < sizeof (emlxs_parm_t)) { 4478 EMLXS_MSGF(EMLXS_CONTEXT, 4479 &emlxs_sfs_debug_msg, | 4601 4602 ret = FC_SUCCESS; 4603 break; 4604 } 4605 } 4606 4607 break; 4608 } --- 4 unchanged lines hidden (view full) --- 4613 emlxs_parm_t *parm_out; 4614 emlxs_config_t *cfg; 4615 uint32_t i; 4616 uint32_t len; 4617 4618 if (pm->pm_cmd_len < sizeof (emlxs_parm_t)) { 4619 EMLXS_MSGF(EMLXS_CONTEXT, 4620 &emlxs_sfs_debug_msg, |
4480 "fca_port_manage: EMLXS_PARM_GET. " | 4621 "fca_port_manage: PARM_GET. " |
4481 "inbuf too small."); 4482 4483 ret = FC_BADCMD; 4484 break; 4485 } 4486 4487 if (pm->pm_stat_len < sizeof (emlxs_parm_t)) { 4488 EMLXS_MSGF(EMLXS_CONTEXT, 4489 &emlxs_sfs_debug_msg, | 4622 "inbuf too small."); 4623 4624 ret = FC_BADCMD; 4625 break; 4626 } 4627 4628 if (pm->pm_stat_len < sizeof (emlxs_parm_t)) { 4629 EMLXS_MSGF(EMLXS_CONTEXT, 4630 &emlxs_sfs_debug_msg, |
4490 "fca_port_manage: EMLXS_PARM_GET. " | 4631 "fca_port_manage: PARM_GET. " |
4491 "outbuf too small"); 4492 ret = FC_BADCMD; 4493 break; 4494 } 4495 4496 parm_in = (emlxs_parm_t *)pm->pm_cmd_buf; 4497 parm_out = (emlxs_parm_t *)pm->pm_stat_buf; 4498 len = strlen(parm_in->label); 4499 cfg = &CFG; 4500 ret = FC_BADOBJECT; 4501 4502 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 4632 "outbuf too small"); 4633 ret = FC_BADCMD; 4634 break; 4635 } 4636 4637 parm_in = (emlxs_parm_t *)pm->pm_cmd_buf; 4638 parm_out = (emlxs_parm_t *)pm->pm_stat_buf; 4639 len = strlen(parm_in->label); 4640 cfg = &CFG; 4641 ret = FC_BADOBJECT; 4642 4643 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4503 "fca_port_manage: EMLXS_PARM_SET: %s=0x%x,%d", | 4644 "fca_port_manage: PARM_SET: %s=0x%x,%d", |
4504 parm_in->label, parm_in->current, 4505 parm_in->current); 4506 4507 for (i = 0; i < NUM_CFG_PARAM; i++, cfg++) { 4508 /* Find matching parameter string */ 4509 if (len == strlen(cfg->string) && 4510 (strcmp(parm_in->label, 4511 cfg->string) == 0)) { 4512 /* Attempt to update parameter */ 4513 if (emlxs_set_parm(hba, i, 4514 parm_in->current) == FC_SUCCESS) { | 4645 parm_in->label, parm_in->current, 4646 parm_in->current); 4647 4648 for (i = 0; i < NUM_CFG_PARAM; i++, cfg++) { 4649 /* Find matching parameter string */ 4650 if (len == strlen(cfg->string) && 4651 (strcmp(parm_in->label, 4652 cfg->string) == 0)) { 4653 /* Attempt to update parameter */ 4654 if (emlxs_set_parm(hba, i, 4655 parm_in->current) == FC_SUCCESS) { |
4515 (void) strcpy(parm_out->label, 4516 cfg->string); | 4656 (void) strncpy(parm_out->label, 4657 cfg->string, 4658 (sizeof (parm_out->label)- 4659 1)); |
4517 parm_out->min = cfg->low; 4518 parm_out->max = cfg->hi; 4519 parm_out->def = cfg->def; 4520 parm_out->current = 4521 cfg->current; 4522 parm_out->flags = cfg->flags; | 4660 parm_out->min = cfg->low; 4661 parm_out->max = cfg->hi; 4662 parm_out->def = cfg->def; 4663 parm_out->current = 4664 cfg->current; 4665 parm_out->flags = cfg->flags; |
4523 (void) strcpy(parm_out->help, 4524 cfg->help); | 4666 (void) strncpy(parm_out->help, 4667 cfg->help, 4668 (sizeof (parm_out->help)- 4669 1)); |
4525 4526 ret = FC_SUCCESS; 4527 } 4528 4529 break; 4530 } 4531 } 4532 --- 33 unchanged lines hidden (view full) --- 4566 4567 ret = FC_SUCCESS; 4568 break; 4569 } 4570 4571 case EMLXS_GET_BOOT_REV: 4572 { 4573 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 4670 4671 ret = FC_SUCCESS; 4672 } 4673 4674 break; 4675 } 4676 } 4677 --- 33 unchanged lines hidden (view full) --- 4711 4712 ret = FC_SUCCESS; 4713 break; 4714 } 4715 4716 case EMLXS_GET_BOOT_REV: 4717 { 4718 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4574 "fca_port_manage: EMLXS_GET_BOOT_REV"); | 4719 "fca_port_manage: GET_BOOT_REV"); |
4575 4576 if (pm->pm_stat_len < strlen(vpd->boot_version)) { 4577 ret = FC_NOMEM; 4578 break; 4579 } 4580 4581 bzero(pm->pm_stat_buf, pm->pm_stat_len); | 4720 4721 if (pm->pm_stat_len < strlen(vpd->boot_version)) { 4722 ret = FC_NOMEM; 4723 break; 4724 } 4725 4726 bzero(pm->pm_stat_buf, pm->pm_stat_len); |
4582 (void) sprintf(pm->pm_stat_buf, "%s %s", 4583 hba->model_info.model, vpd->boot_version); | 4727 (void) snprintf(pm->pm_stat_buf, pm->pm_stat_len, 4728 "%s %s", hba->model_info.model, vpd->boot_version); |
4584 4585 break; 4586 } 4587 4588 case EMLXS_DOWNLOAD_BOOT: 4589 if (!(hba->flag & FC_ONLINE_MODE)) { 4590 return (FC_OFFLINE); 4591 } 4592 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 4729 4730 break; 4731 } 4732 4733 case EMLXS_DOWNLOAD_BOOT: 4734 if (!(hba->flag & FC_ONLINE_MODE)) { 4735 return (FC_OFFLINE); 4736 } 4737 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4593 "fca_port_manage: EMLXS_DOWNLOAD_BOOT"); | 4738 "fca_port_manage: DOWNLOAD_BOOT"); |
4594 4595 ret = emlxs_fw_download(hba, pm->pm_data_buf, 4596 pm->pm_data_len, 1); 4597 break; 4598 4599 case EMLXS_DOWNLOAD_CFL: 4600 { 4601 uint32_t *buffer; 4602 uint32_t region; 4603 uint32_t length; 4604 4605 if (!(hba->flag & FC_ONLINE_MODE)) { 4606 return (FC_OFFLINE); 4607 } 4608 4609 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 4739 4740 ret = emlxs_fw_download(hba, pm->pm_data_buf, 4741 pm->pm_data_len, 1); 4742 break; 4743 4744 case EMLXS_DOWNLOAD_CFL: 4745 { 4746 uint32_t *buffer; 4747 uint32_t region; 4748 uint32_t length; 4749 4750 if (!(hba->flag & FC_ONLINE_MODE)) { 4751 return (FC_OFFLINE); 4752 } 4753 4754 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4610 "fca_port_manage: EMLXS_DOWNLOAD_CFL"); | 4755 "fca_port_manage: DOWNLOAD_CFL"); |
4611 4612 /* Extract the region number from the first word. */ 4613 buffer = (uint32_t *)pm->pm_data_buf; 4614 region = *buffer++; 4615 4616 /* Adjust the image length for the header word */ 4617 length = pm->pm_data_len - 4; 4618 4619 ret = 4620 emlxs_cfl_download(hba, region, (caddr_t)buffer, 4621 length); 4622 break; 4623 } 4624 4625 case EMLXS_VPD_GET: 4626 { 4627 emlxs_vpd_desc_t *vpd_out; 4628 4629 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 4756 4757 /* Extract the region number from the first word. */ 4758 buffer = (uint32_t *)pm->pm_data_buf; 4759 region = *buffer++; 4760 4761 /* Adjust the image length for the header word */ 4762 length = pm->pm_data_len - 4; 4763 4764 ret = 4765 emlxs_cfl_download(hba, region, (caddr_t)buffer, 4766 length); 4767 break; 4768 } 4769 4770 case EMLXS_VPD_GET: 4771 { 4772 emlxs_vpd_desc_t *vpd_out; 4773 4774 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4630 "fca_port_manage: EMLXS_VPD_GET"); | 4775 "fca_port_manage: VPD_GET"); |
4631 4632 if (pm->pm_stat_len < sizeof (emlxs_vpd_desc_t)) { 4633 ret = FC_BADCMD; 4634 break; 4635 } 4636 4637 vpd_out = (emlxs_vpd_desc_t *)pm->pm_stat_buf; | 4776 4777 if (pm->pm_stat_len < sizeof (emlxs_vpd_desc_t)) { 4778 ret = FC_BADCMD; 4779 break; 4780 } 4781 4782 vpd_out = (emlxs_vpd_desc_t *)pm->pm_stat_buf; |
4638 bzero(vpd_out, sizeof (emlxs_vpd_desc_t)); | 4783 bzero(vpd_out, pm->pm_stat_len); |
4639 4640 (void) strncpy(vpd_out->id, vpd->id, | 4784 4785 (void) strncpy(vpd_out->id, vpd->id, |
4641 sizeof (vpd_out->id)); | 4786 (sizeof (vpd_out->id)-1)); |
4642 (void) strncpy(vpd_out->part_num, vpd->part_num, | 4787 (void) strncpy(vpd_out->part_num, vpd->part_num, |
4643 sizeof (vpd_out->part_num)); | 4788 (sizeof (vpd_out->part_num)-1)); |
4644 (void) strncpy(vpd_out->eng_change, vpd->eng_change, | 4789 (void) strncpy(vpd_out->eng_change, vpd->eng_change, |
4645 sizeof (vpd_out->eng_change)); | 4790 (sizeof (vpd_out->eng_change)-1)); |
4646 (void) strncpy(vpd_out->manufacturer, vpd->manufacturer, | 4791 (void) strncpy(vpd_out->manufacturer, vpd->manufacturer, |
4647 sizeof (vpd_out->manufacturer)); | 4792 (sizeof (vpd_out->manufacturer)-1)); |
4648 (void) strncpy(vpd_out->serial_num, vpd->serial_num, | 4793 (void) strncpy(vpd_out->serial_num, vpd->serial_num, |
4649 sizeof (vpd_out->serial_num)); | 4794 (sizeof (vpd_out->serial_num)-1)); |
4650 (void) strncpy(vpd_out->model, vpd->model, | 4795 (void) strncpy(vpd_out->model, vpd->model, |
4651 sizeof (vpd_out->model)); | 4796 (sizeof (vpd_out->model)-1)); |
4652 (void) strncpy(vpd_out->model_desc, vpd->model_desc, | 4797 (void) strncpy(vpd_out->model_desc, vpd->model_desc, |
4653 sizeof (vpd_out->model_desc)); | 4798 (sizeof (vpd_out->model_desc)-1)); |
4654 (void) strncpy(vpd_out->port_num, vpd->port_num, | 4799 (void) strncpy(vpd_out->port_num, vpd->port_num, |
4655 sizeof (vpd_out->port_num)); | 4800 (sizeof (vpd_out->port_num)-1)); |
4656 (void) strncpy(vpd_out->prog_types, vpd->prog_types, | 4801 (void) strncpy(vpd_out->prog_types, vpd->prog_types, |
4657 sizeof (vpd_out->prog_types)); | 4802 (sizeof (vpd_out->prog_types)-1)); |
4658 4659 ret = FC_SUCCESS; 4660 4661 break; 4662 } 4663 | 4803 4804 ret = FC_SUCCESS; 4805 4806 break; 4807 } 4808 |
4809 case EMLXS_VPD_GET_V2: 4810 { 4811 emlxs_vpd_desc_v2_t *vpd_out; 4812 4813 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 4814 "fca_port_manage: VPD_GET_V2"); 4815 4816 if (pm->pm_stat_len < sizeof (emlxs_vpd_desc_v2_t)) { 4817 ret = FC_BADCMD; 4818 break; 4819 } 4820 4821 vpd_out = (emlxs_vpd_desc_v2_t *)pm->pm_stat_buf; 4822 bzero(vpd_out, pm->pm_stat_len); 4823 4824 (void) strncpy(vpd_out->id, vpd->id, 4825 (sizeof (vpd_out->id)-1)); 4826 (void) strncpy(vpd_out->part_num, vpd->part_num, 4827 (sizeof (vpd_out->part_num)-1)); 4828 (void) strncpy(vpd_out->eng_change, vpd->eng_change, 4829 (sizeof (vpd_out->eng_change)-1)); 4830 (void) strncpy(vpd_out->manufacturer, vpd->manufacturer, 4831 (sizeof (vpd_out->manufacturer)-1)); 4832 (void) strncpy(vpd_out->serial_num, vpd->serial_num, 4833 (sizeof (vpd_out->serial_num)-1)); 4834 (void) strncpy(vpd_out->model, vpd->model, 4835 (sizeof (vpd_out->model)-1)); 4836 (void) strncpy(vpd_out->model_desc, vpd->model_desc, 4837 (sizeof (vpd_out->model_desc)-1)); 4838 (void) strncpy(vpd_out->port_num, vpd->port_num, 4839 (sizeof (vpd_out->port_num)-1)); 4840 (void) strncpy(vpd_out->prog_types, vpd->prog_types, 4841 (sizeof (vpd_out->prog_types)-1)); 4842 4843 ret = FC_SUCCESS; 4844 4845 break; 4846 } 4847 4848 case EMLXS_PHY_GET: 4849 { 4850 emlxs_phy_desc_t *phy_out; 4851 MAILBOXQ *mbq; 4852 MAILBOX4 *mb; 4853 IOCTL_COMMON_GET_PHY_DETAILS *phy; 4854 mbox_req_hdr_t *hdr_req; 4855 4856 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 4857 "fca_port_manage: EMLXS_PHY_GET"); 4858 4859 if (pm->pm_stat_len < sizeof (emlxs_phy_desc_t)) { 4860 ret = FC_BADCMD; 4861 break; 4862 } 4863 4864 if (hba->sli_mode != EMLXS_HBA_SLI4_MODE) { 4865 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 4866 "Invalid sli_mode. mode=%d", hba->sli_mode); 4867 ret = FC_BADCMD; 4868 break; 4869 } 4870 4871 phy_out = (emlxs_phy_desc_t *)pm->pm_stat_buf; 4872 bzero(phy_out, sizeof (emlxs_phy_desc_t)); 4873 4874 if ((mbq = (MAILBOXQ *)emlxs_mem_get(hba, 4875 MEM_MBOX)) == 0) { 4876 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 4877 "Unable to allocate mailbox buffer."); 4878 ret = FC_NOMEM; 4879 break; 4880 } 4881 4882 mb = (MAILBOX4*)mbq; 4883 4884 bzero((void *) mb, MAILBOX_CMD_SLI4_BSIZE); 4885 4886 mb->un.varSLIConfig.be.embedded = 1; 4887 mbq->mbox_cmpl = NULL; 4888 4889 mb->mbxCommand = MBX_SLI_CONFIG; 4890 mb->mbxOwner = OWN_HOST; 4891 4892 hdr_req = (mbox_req_hdr_t *) 4893 &mb->un.varSLIConfig.be.un_hdr.hdr_req; 4894 hdr_req->subsystem = IOCTL_SUBSYSTEM_COMMON; 4895 hdr_req->opcode = COMMON_OPCODE_GET_PHY_DETAILS; 4896 hdr_req->timeout = 0; 4897 hdr_req->req_length = 4898 sizeof (IOCTL_COMMON_GET_PHY_DETAILS); 4899 4900 phy = (IOCTL_COMMON_GET_PHY_DETAILS *)(hdr_req + 1); 4901 4902 /* Send read request */ 4903 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) != 4904 MBX_SUCCESS) { 4905 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 4906 "Unable to get PHY details. status=%x", 4907 mb->mbxStatus); 4908 4909 emlxs_mem_put(hba, MEM_MBOX, (void *)mbq); 4910 4911 ret = FC_FAILURE; 4912 break; 4913 } 4914 4915 phy_out->phy_type = phy->params.response.phy_type; 4916 phy_out->interface_type = 4917 phy->params.response.interface_type; 4918 phy_out->misc_params = phy->params.response.misc_params; 4919 phy_out->rsvd[0] = phy->params.response.rsvd[0]; 4920 phy_out->rsvd[1] = phy->params.response.rsvd[1]; 4921 phy_out->rsvd[2] = phy->params.response.rsvd[2]; 4922 phy_out->rsvd[3] = phy->params.response.rsvd[3]; 4923 4924 emlxs_mem_put(hba, MEM_MBOX, (void *)mbq); 4925 4926 ret = FC_SUCCESS; 4927 break; 4928 } 4929 4930#ifdef NODE_THROTTLE_SUPPORT 4931 case EMLXS_SET_THROTTLE: 4932 { 4933 emlxs_node_t *node; 4934 uint32_t scope = 0; 4935 uint32_t i; 4936 char buf1[32]; 4937 emlxs_throttle_desc_t *desc; 4938 4939 if ((pm->pm_data_buf == NULL) || 4940 (pm->pm_data_len != 4941 sizeof (emlxs_throttle_desc_t))) { 4942 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 4943 "fca_port_manage: EMLXS_SET_THROTTLE: " 4944 "Descriptor buffer not valid. %d", 4945 pm->pm_data_len); 4946 ret = FC_BADCMD; 4947 break; 4948 } 4949 4950 if ((pm->pm_cmd_buf != NULL) && 4951 (pm->pm_cmd_len == sizeof (uint32_t))) { 4952 scope = *(uint32_t *)pm->pm_cmd_buf; 4953 } 4954 4955 desc = (emlxs_throttle_desc_t *)pm->pm_data_buf; 4956 desc->throttle = MIN(desc->throttle, MAX_NODE_THROTTLE); 4957 4958 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 4959 "fca_port_manage: EMLXS_SET_THROTTLE: scope=%d " 4960 "depth=%d", 4961 scope, desc->throttle); 4962 4963 rw_enter(&port->node_rwlock, RW_WRITER); 4964 switch (scope) { 4965 case 1: /* all */ 4966 for (i = 0; i < EMLXS_NUM_HASH_QUES; i++) { 4967 node = port->node_table[i]; 4968 while (node != NULL) { 4969 node->io_throttle = desc->throttle; 4970 4971 EMLXS_MSGF(EMLXS_CONTEXT, 4972 &emlxs_sfs_debug_msg, 4973 "EMLXS_SET_THROTTLE: wwpn=%s " 4974 "depth=%d", 4975 emlxs_wwn_xlate(buf1, sizeof (buf1), 4976 (uint8_t *)&node->nlp_portname), 4977 node->io_throttle); 4978 4979 node = (NODELIST *)node->nlp_list_next; 4980 } 4981 } 4982 break; 4983 4984 case 2: /* FCP */ 4985 for (i = 0; i < EMLXS_NUM_HASH_QUES; i++) { 4986 node = port->node_table[i]; 4987 while (node != NULL) { 4988 if (!(node->nlp_fcp_info & 4989 NLP_FCP_TGT_DEVICE)) { 4990 node = (NODELIST *) 4991 node->nlp_list_next; 4992 continue; 4993 } 4994 4995 node->io_throttle = desc->throttle; 4996 4997 EMLXS_MSGF(EMLXS_CONTEXT, 4998 &emlxs_sfs_debug_msg, 4999 "EMLXS_SET_THROTTLE: wwpn=%s " 5000 "depth=%d", 5001 emlxs_wwn_xlate(buf1, sizeof (buf1), 5002 (uint8_t *)&node->nlp_portname), 5003 node->io_throttle); 5004 5005 node = (NODELIST *)node->nlp_list_next; 5006 } 5007 } 5008 break; 5009 5010 case 0: /* WWPN */ 5011 default: 5012 for (i = 0; i < EMLXS_NUM_HASH_QUES; i++) { 5013 node = port->node_table[i]; 5014 while (node != NULL) { 5015 if (bcmp((caddr_t)&node->nlp_portname, 5016 desc->wwpn, 8)) { 5017 node = (NODELIST *) 5018 node->nlp_list_next; 5019 continue; 5020 } 5021 5022 node->io_throttle = desc->throttle; 5023 5024 EMLXS_MSGF(EMLXS_CONTEXT, 5025 &emlxs_sfs_debug_msg, 5026 "EMLXS_SET_THROTTLE: wwpn=%s " 5027 "depth=%d", 5028 emlxs_wwn_xlate(buf1, sizeof (buf1), 5029 (uint8_t *)&node->nlp_portname), 5030 node->io_throttle); 5031 5032 goto set_throttle_done; 5033 } 5034 } 5035set_throttle_done: 5036 break; 5037 } 5038 5039 rw_exit(&port->node_rwlock); 5040 ret = FC_SUCCESS; 5041 5042 break; 5043 } 5044 5045 case EMLXS_GET_THROTTLE: 5046 { 5047 emlxs_node_t *node; 5048 uint32_t i; 5049 uint32_t j; 5050 char buf1[32]; 5051 uint32_t count; 5052 emlxs_throttle_desc_t *desc; 5053 5054 if (pm->pm_stat_len == sizeof (uint32_t)) { 5055 count = emlxs_nport_count(port); 5056 *(uint32_t *)pm->pm_stat_buf = count; 5057 5058 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 5059 "fca_port_manage: EMLXS_GET_THROTTLE: " 5060 "count=%d", 5061 count); 5062 5063 ret = FC_SUCCESS; 5064 break; 5065 } 5066 5067 if ((pm->pm_stat_buf == NULL) || 5068 (pm->pm_stat_len < 5069 sizeof (emlxs_throttle_desc_t))) { 5070 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 5071 "fca_port_manage: EMLXS_GET_THROTTLE: " 5072 "Descriptor buffer too small. %d", 5073 pm->pm_data_len); 5074 ret = FC_BADCMD; 5075 break; 5076 } 5077 5078 count = pm->pm_stat_len / 5079 sizeof (emlxs_throttle_desc_t); 5080 desc = (emlxs_throttle_desc_t *)pm->pm_stat_buf; 5081 5082 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 5083 "fca_port_manage: EMLXS_GET_THROTTLE: max=%d", 5084 count); 5085 5086 rw_enter(&port->node_rwlock, RW_READER); 5087 j = 0; 5088 for (i = 0; i < EMLXS_NUM_HASH_QUES; i++) { 5089 node = port->node_table[i]; 5090 while (node != NULL) { 5091 if ((node->nlp_DID & 0xFFF000) == 5092 0xFFF000) { 5093 node = (NODELIST *) 5094 node->nlp_list_next; 5095 continue; 5096 } 5097 5098 bcopy((uint8_t *)&node->nlp_portname, 5099 desc[j].wwpn, 8); 5100 desc[j].throttle = node->io_throttle; 5101 5102 EMLXS_MSGF(EMLXS_CONTEXT, 5103 &emlxs_sfs_debug_msg, 5104 "EMLXS_GET_THROTTLE: wwpn=%s " 5105 "depth=%d", 5106 emlxs_wwn_xlate(buf1, sizeof (buf1), 5107 desc[j].wwpn), 5108 desc[j].throttle); 5109 5110 j++; 5111 if (j >= count) { 5112 goto get_throttle_done; 5113 } 5114 5115 node = (NODELIST *)node->nlp_list_next; 5116 } 5117 } 5118get_throttle_done: 5119 rw_exit(&port->node_rwlock); 5120 ret = FC_SUCCESS; 5121 5122 break; 5123 } 5124#endif /* NODE_THROTTLE_SUPPORT */ 5125 |
|
4664 case EMLXS_GET_FCIO_REV: 4665 { 4666 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 5126 case EMLXS_GET_FCIO_REV: 5127 { 5128 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4667 "fca_port_manage: EMLXS_GET_FCIO_REV"); | 5129 "fca_port_manage: GET_FCIO_REV"); |
4668 4669 if (pm->pm_stat_len < sizeof (uint32_t)) { 4670 ret = FC_NOMEM; 4671 break; 4672 } 4673 4674 bzero(pm->pm_stat_buf, pm->pm_stat_len); 4675 *(uint32_t *)pm->pm_stat_buf = FCIO_REV; 4676 4677 break; 4678 } 4679 4680 case EMLXS_GET_DFC_REV: 4681 { 4682 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 5130 5131 if (pm->pm_stat_len < sizeof (uint32_t)) { 5132 ret = FC_NOMEM; 5133 break; 5134 } 5135 5136 bzero(pm->pm_stat_buf, pm->pm_stat_len); 5137 *(uint32_t *)pm->pm_stat_buf = FCIO_REV; 5138 5139 break; 5140 } 5141 5142 case EMLXS_GET_DFC_REV: 5143 { 5144 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4683 "fca_port_manage: EMLXS_GET_DFC_REV"); | 5145 "fca_port_manage: GET_DFC_REV"); |
4684 4685 if (pm->pm_stat_len < sizeof (uint32_t)) { 4686 ret = FC_NOMEM; 4687 break; 4688 } 4689 4690 bzero(pm->pm_stat_buf, pm->pm_stat_len); 4691 *(uint32_t *)pm->pm_stat_buf = DFC_REV; --- 7 unchanged lines hidden (view full) --- 4699 uint32_t state; 4700 4701 if (!(hba->flag & FC_ONLINE_MODE)) { 4702 return (FC_OFFLINE); 4703 } 4704 if (pm->pm_cmd_len < sizeof (uint32_t)) { 4705 EMLXS_MSGF(EMLXS_CONTEXT, 4706 &emlxs_sfs_debug_msg, | 5146 5147 if (pm->pm_stat_len < sizeof (uint32_t)) { 5148 ret = FC_NOMEM; 5149 break; 5150 } 5151 5152 bzero(pm->pm_stat_buf, pm->pm_stat_len); 5153 *(uint32_t *)pm->pm_stat_buf = DFC_REV; --- 7 unchanged lines hidden (view full) --- 5161 uint32_t state; 5162 5163 if (!(hba->flag & FC_ONLINE_MODE)) { 5164 return (FC_OFFLINE); 5165 } 5166 if (pm->pm_cmd_len < sizeof (uint32_t)) { 5167 EMLXS_MSGF(EMLXS_CONTEXT, 5168 &emlxs_sfs_debug_msg, |
4707 "fca_port_manage: EMLXS_SET_BOOT_STATE"); | 5169 "fca_port_manage: SET_BOOT_STATE"); |
4708 ret = FC_BADCMD; 4709 break; 4710 } 4711 4712 state = *(uint32_t *)pm->pm_cmd_buf; 4713 4714 if (state == 0) { 4715 EMLXS_MSGF(EMLXS_CONTEXT, 4716 &emlxs_sfs_debug_msg, | 5170 ret = FC_BADCMD; 5171 break; 5172 } 5173 5174 state = *(uint32_t *)pm->pm_cmd_buf; 5175 5176 if (state == 0) { 5177 EMLXS_MSGF(EMLXS_CONTEXT, 5178 &emlxs_sfs_debug_msg, |
4717 "fca_port_manage: EMLXS_SET_BOOT_STATE: " | 5179 "fca_port_manage: SET_BOOT_STATE: " |
4718 "Disable"); 4719 ret = emlxs_boot_code_disable(hba); 4720 } else { 4721 EMLXS_MSGF(EMLXS_CONTEXT, 4722 &emlxs_sfs_debug_msg, | 5180 "Disable"); 5181 ret = emlxs_boot_code_disable(hba); 5182 } else { 5183 EMLXS_MSGF(EMLXS_CONTEXT, 5184 &emlxs_sfs_debug_msg, |
4723 "fca_port_manage: EMLXS_SET_BOOT_STATE: " | 5185 "fca_port_manage: SET_BOOT_STATE: " |
4724 "Enable"); 4725 ret = emlxs_boot_code_enable(hba); 4726 } 4727 4728 break; 4729 } 4730 4731 case EMLXS_GET_BOOT_STATE: 4732 case EMLXS_GET_BOOT_STATE_old: 4733 { 4734 if (!(hba->flag & FC_ONLINE_MODE)) { 4735 return (FC_OFFLINE); 4736 } 4737 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 5186 "Enable"); 5187 ret = emlxs_boot_code_enable(hba); 5188 } 5189 5190 break; 5191 } 5192 5193 case EMLXS_GET_BOOT_STATE: 5194 case EMLXS_GET_BOOT_STATE_old: 5195 { 5196 if (!(hba->flag & FC_ONLINE_MODE)) { 5197 return (FC_OFFLINE); 5198 } 5199 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4738 "fca_port_manage: EMLXS_GET_BOOT_STATE"); | 5200 "fca_port_manage: GET_BOOT_STATE"); |
4739 4740 if (pm->pm_stat_len < sizeof (uint32_t)) { 4741 ret = FC_NOMEM; 4742 break; 4743 } 4744 bzero(pm->pm_stat_buf, pm->pm_stat_len); 4745 4746 ret = emlxs_boot_code_state(hba); --- 24 unchanged lines hidden (view full) --- 4771 4772 case EMLXS_MB_TIMEOUT_TEST: 4773 { 4774 if (!(hba->flag & FC_ONLINE_MODE)) { 4775 return (FC_OFFLINE); 4776 } 4777 4778 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 5201 5202 if (pm->pm_stat_len < sizeof (uint32_t)) { 5203 ret = FC_NOMEM; 5204 break; 5205 } 5206 bzero(pm->pm_stat_buf, pm->pm_stat_len); 5207 5208 ret = emlxs_boot_code_state(hba); --- 24 unchanged lines hidden (view full) --- 5233 5234 case EMLXS_MB_TIMEOUT_TEST: 5235 { 5236 if (!(hba->flag & FC_ONLINE_MODE)) { 5237 return (FC_OFFLINE); 5238 } 5239 5240 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4779 "fca_port_manage: EMLXS_HW_ERROR_TEST"); | 5241 "fca_port_manage: HW_ERROR_TEST"); |
4780 4781 /* Trigger a mailbox timeout */ 4782 hba->mbox_timer = hba->timer_tics; 4783 4784 break; 4785 } 4786 4787 case EMLXS_TEST_CODE: 4788 { 4789 uint32_t *cmd; 4790 4791 if (!(hba->flag & FC_ONLINE_MODE)) { 4792 return (FC_OFFLINE); 4793 } 4794 4795 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 5242 5243 /* Trigger a mailbox timeout */ 5244 hba->mbox_timer = hba->timer_tics; 5245 5246 break; 5247 } 5248 5249 case EMLXS_TEST_CODE: 5250 { 5251 uint32_t *cmd; 5252 5253 if (!(hba->flag & FC_ONLINE_MODE)) { 5254 return (FC_OFFLINE); 5255 } 5256 5257 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4796 "fca_port_manage: EMLXS_TEST_CODE"); | 5258 "fca_port_manage: TEST_CODE"); |
4797 4798 if (pm->pm_cmd_len < sizeof (uint32_t)) { 4799 EMLXS_MSGF(EMLXS_CONTEXT, 4800 &emlxs_sfs_debug_msg, | 5259 5260 if (pm->pm_cmd_len < sizeof (uint32_t)) { 5261 EMLXS_MSGF(EMLXS_CONTEXT, 5262 &emlxs_sfs_debug_msg, |
4801 "fca_port_manage: EMLXS_TEST_CODE. " | 5263 "fca_port_manage: TEST_CODE. " |
4802 "inbuf to small."); 4803 4804 ret = FC_BADCMD; 4805 break; 4806 } 4807 4808 cmd = (uint32_t *)pm->pm_cmd_buf; 4809 4810 ret = emlxs_test(hba, cmd[0], 4811 (pm->pm_cmd_len/sizeof (uint32_t)) - 1, &cmd[1]); 4812 4813 break; 4814 } 4815 4816 case EMLXS_BAR_IO: 4817 { 4818 uint32_t *cmd; 4819 uint32_t *datap; | 5264 "inbuf to small."); 5265 5266 ret = FC_BADCMD; 5267 break; 5268 } 5269 5270 cmd = (uint32_t *)pm->pm_cmd_buf; 5271 5272 ret = emlxs_test(hba, cmd[0], 5273 (pm->pm_cmd_len/sizeof (uint32_t)) - 1, &cmd[1]); 5274 5275 break; 5276 } 5277 5278 case EMLXS_BAR_IO: 5279 { 5280 uint32_t *cmd; 5281 uint32_t *datap; |
5282 FCIO_Q_STAT_t *qp; 5283 clock_t time; |
|
4820 uint32_t offset; 4821 caddr_t addr; 4822 uint32_t i; 4823 uint32_t tx_cnt; 4824 uint32_t chip_cnt; 4825 4826 cmd = (uint32_t *)pm->pm_cmd_buf; 4827 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 5284 uint32_t offset; 5285 caddr_t addr; 5286 uint32_t i; 5287 uint32_t tx_cnt; 5288 uint32_t chip_cnt; 5289 5290 cmd = (uint32_t *)pm->pm_cmd_buf; 5291 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
4828 "fca_port_manage: EMLXS_BAR_IO %x %x %x", | 5292 "fca_port_manage: BAR_IO %x %x %x", |
4829 cmd[0], cmd[1], cmd[2]); 4830 4831 offset = cmd[1]; 4832 4833 ret = FC_SUCCESS; 4834 4835 switch (cmd[0]) { 4836 case 2: /* bar1read */ --- 111 unchanged lines hidden (view full) --- 4948 if (hba->sli_mode != EMLXS_HBA_SLI4_MODE) { 4949 return (FC_BADCMD); 4950 } 4951 emlxs_abort_all(hba, &tx_cnt, &chip_cnt); 4952 datap = (uint32_t *)pm->pm_stat_buf; 4953 *datap++ = tx_cnt; 4954 *datap = chip_cnt; 4955 break; | 5293 cmd[0], cmd[1], cmd[2]); 5294 5295 offset = cmd[1]; 5296 5297 ret = FC_SUCCESS; 5298 5299 switch (cmd[0]) { 5300 case 2: /* bar1read */ --- 111 unchanged lines hidden (view full) --- 5412 if (hba->sli_mode != EMLXS_HBA_SLI4_MODE) { 5413 return (FC_BADCMD); 5414 } 5415 emlxs_abort_all(hba, &tx_cnt, &chip_cnt); 5416 datap = (uint32_t *)pm->pm_stat_buf; 5417 *datap++ = tx_cnt; 5418 *datap = chip_cnt; 5419 break; |
5420 case 9: /* get_q_info */ 5421 if (hba->sli_mode != EMLXS_HBA_SLI4_MODE) { 5422 return (FC_BADCMD); 5423 } 5424 qp = (FCIO_Q_STAT_t *)pm->pm_stat_buf; 5425 for (i = 0; i < FCIO_MAX_EQS; i++) { 5426 addr = hba->sli.sli4.eq[i].addr.virt; 5427 qp->eq[i].host_index = 5428 hba->sli.sli4.eq[i].host_index; 5429 qp->eq[i].max_index = 5430 hba->sli.sli4.eq[i].max_index; 5431 qp->eq[i].qid = 5432 hba->sli.sli4.eq[i].qid; 5433 qp->eq[i].msix_vector = 5434 hba->sli.sli4.eq[i].msix_vector; 5435 qp->eq[i].phys = 5436 hba->sli.sli4.eq[i].addr.phys; 5437 qp->eq[i].virt = PADDR_LO( 5438 (uintptr_t)addr); 5439 qp->eq[i].virt_hi = PADDR_HI( 5440 (uintptr_t)addr); 5441 qp->eq[i].max_proc = 5442 hba->sli.sli4.eq[i].max_proc; 5443 qp->eq[i].isr_count = 5444 hba->sli.sli4.eq[i].isr_count; 5445 qp->eq[i].num_proc = 5446 hba->sli.sli4.eq[i].num_proc; 5447 } 5448 for (i = 0; i < FCIO_MAX_CQS; i++) { 5449 addr = hba->sli.sli4.cq[i].addr.virt; 5450 qp->cq[i].host_index = 5451 hba->sli.sli4.cq[i].host_index; 5452 qp->cq[i].max_index = 5453 hba->sli.sli4.cq[i].max_index; 5454 qp->cq[i].qid = 5455 hba->sli.sli4.cq[i].qid; 5456 qp->cq[i].eqid = 5457 hba->sli.sli4.cq[i].eqid; 5458 qp->cq[i].type = 5459 hba->sli.sli4.cq[i].type; 5460 qp->cq[i].phys = 5461 hba->sli.sli4.cq[i].addr.phys; 5462 qp->cq[i].virt = PADDR_LO( 5463 (uintptr_t)addr); 5464 qp->cq[i].virt_hi = PADDR_HI( 5465 (uintptr_t)addr); 5466 qp->cq[i].max_proc = 5467 hba->sli.sli4.cq[i].max_proc; 5468 qp->cq[i].isr_count = 5469 hba->sli.sli4.cq[i].isr_count; 5470 qp->cq[i].num_proc = 5471 hba->sli.sli4.cq[i].num_proc; 5472 } 5473 for (i = 0; i < FCIO_MAX_WQS; i++) { 5474 addr = hba->sli.sli4.wq[i].addr.virt; 5475 qp->wq[i].host_index = 5476 hba->sli.sli4.wq[i].host_index; 5477 qp->wq[i].max_index = 5478 hba->sli.sli4.wq[i].max_index; 5479 qp->wq[i].port_index = 5480 hba->sli.sli4.wq[i].port_index; 5481 qp->wq[i].release_depth = 5482 hba->sli.sli4.wq[i].release_depth; 5483 qp->wq[i].qid = 5484 hba->sli.sli4.wq[i].qid; 5485 qp->wq[i].cqid = 5486 hba->sli.sli4.wq[i].cqid; 5487 qp->wq[i].phys = 5488 hba->sli.sli4.wq[i].addr.phys; 5489 qp->wq[i].virt = PADDR_LO( 5490 (uintptr_t)addr); 5491 qp->wq[i].virt_hi = PADDR_HI( 5492 (uintptr_t)addr); 5493 qp->wq[i].num_proc = 5494 hba->sli.sli4.wq[i].num_proc; 5495 qp->wq[i].num_busy = 5496 hba->sli.sli4.wq[i].num_busy; 5497 } 5498 for (i = 0; i < FCIO_MAX_RQS; i++) { 5499 addr = hba->sli.sli4.rq[i].addr.virt; 5500 qp->rq[i].qid = 5501 hba->sli.sli4.rq[i].qid; 5502 qp->rq[i].cqid = 5503 hba->sli.sli4.rq[i].cqid; 5504 qp->rq[i].host_index = 5505 hba->sli.sli4.rq[i].host_index; 5506 qp->rq[i].max_index = 5507 hba->sli.sli4.rq[i].max_index; 5508 qp->rq[i].phys = 5509 hba->sli.sli4.rq[i].addr.phys; 5510 qp->rq[i].virt = PADDR_LO( 5511 (uintptr_t)addr); 5512 qp->rq[i].virt_hi = PADDR_HI( 5513 (uintptr_t)addr); 5514 qp->rq[i].num_proc = 5515 hba->sli.sli4.rq[i].num_proc; 5516 } 5517 qp->que_start_timer = 5518 hba->sli.sli4.que_stat_timer; 5519 (void) drv_getparm(LBOLT, &time); 5520 qp->que_current_timer = (uint32_t)time; 5521 qp->intr_count = hba->intr_count; 5522 break; 5523 case 10: /* zero_q_stat */ 5524 if (hba->sli_mode != EMLXS_HBA_SLI4_MODE) { 5525 return (FC_BADCMD); 5526 } 5527 emlxs_sli4_zero_queue_stat(hba); 5528 break; |
|
4956 default: 4957 ret = FC_BADCMD; 4958 break; 4959 } 4960 break; 4961 } 4962 4963 default: --- 51 unchanged lines hidden (view full) --- 5015 5016 if (pm->pm_data_len < sizeof (fc_rnid_t)) { 5017 ret = FC_NOMEM; 5018 break; 5019 } 5020 5021 rnid = (fc_rnid_t *)pm->pm_data_buf; 5022 | 5529 default: 5530 ret = FC_BADCMD; 5531 break; 5532 } 5533 break; 5534 } 5535 5536 default: --- 51 unchanged lines hidden (view full) --- 5588 5589 if (pm->pm_data_len < sizeof (fc_rnid_t)) { 5590 ret = FC_NOMEM; 5591 break; 5592 } 5593 5594 rnid = (fc_rnid_t *)pm->pm_data_buf; 5595 |
5023 (void) sprintf((char *)rnid->global_id, | 5596 (void) snprintf((char *)rnid->global_id, 5597 (sizeof (rnid->global_id)-1), |
5024 "%01x%01x%02x%02x%02x%02x%02x%02x%02x", 5025 hba->wwpn.nameType, hba->wwpn.IEEEextMsn, 5026 hba->wwpn.IEEEextLsb, hba->wwpn.IEEE[0], 5027 hba->wwpn.IEEE[1], hba->wwpn.IEEE[2], hba->wwpn.IEEE[3], 5028 hba->wwpn.IEEE[4], hba->wwpn.IEEE[5]); 5029 5030 rnid->unit_type = RNID_HBA; 5031 rnid->port_id = port->did; --- 79 unchanged lines hidden (view full) --- 5111 5112 if (hba->state >= FC_LINK_UP) { 5113 if ((hba->topology == TOPOLOGY_PT_PT) && 5114 (hba->flag & FC_PT_TO_PT)) { 5115 p2p_info->fca_d_id = port->did; 5116 p2p_info->d_id = port->rdid; 5117 5118 ndlp = emlxs_node_find_did(port, | 5598 "%01x%01x%02x%02x%02x%02x%02x%02x%02x", 5599 hba->wwpn.nameType, hba->wwpn.IEEEextMsn, 5600 hba->wwpn.IEEEextLsb, hba->wwpn.IEEE[0], 5601 hba->wwpn.IEEE[1], hba->wwpn.IEEE[2], hba->wwpn.IEEE[3], 5602 hba->wwpn.IEEE[4], hba->wwpn.IEEE[5]); 5603 5604 rnid->unit_type = RNID_HBA; 5605 rnid->port_id = port->did; --- 79 unchanged lines hidden (view full) --- 5685 5686 if (hba->state >= FC_LINK_UP) { 5687 if ((hba->topology == TOPOLOGY_PT_PT) && 5688 (hba->flag & FC_PT_TO_PT)) { 5689 p2p_info->fca_d_id = port->did; 5690 p2p_info->d_id = port->rdid; 5691 5692 ndlp = emlxs_node_find_did(port, |
5119 port->rdid); | 5693 port->rdid, 1); |
5120 5121 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 5122 "FC_PORT_GET_P2P_INFO: fca_d_id: 0x%x, " 5123 "d_id: 0x%x, ndlp: 0x%p", port->did, 5124 port->rdid, ndlp); 5125 if (ndlp) { 5126 bcopy(&ndlp->nlp_portname, 5127 (caddr_t)&p2p_info->pwwn, --- 41 unchanged lines hidden (view full) --- 5169 { 5170 hba->underrun_counter = (args)? arg[0]:1; 5171 break; 5172 } 5173#endif /* TEST_SUPPORT */ 5174 5175 default: 5176 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 5694 5695 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, 5696 "FC_PORT_GET_P2P_INFO: fca_d_id: 0x%x, " 5697 "d_id: 0x%x, ndlp: 0x%p", port->did, 5698 port->rdid, ndlp); 5699 if (ndlp) { 5700 bcopy(&ndlp->nlp_portname, 5701 (caddr_t)&p2p_info->pwwn, --- 41 unchanged lines hidden (view full) --- 5743 { 5744 hba->underrun_counter = (args)? arg[0]:1; 5745 break; 5746 } 5747#endif /* TEST_SUPPORT */ 5748 5749 default: 5750 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
5177 "emlxs_test: Unsupported test code. (0x%x)", test_code); | 5751 "test: Unsupported test code. (0x%x)", test_code); |
5178 rval = FC_INVALID_REQUEST; 5179 } 5180 5181 return (rval); 5182 5183} /* emlxs_test() */ 5184 5185 --- 164 unchanged lines hidden (view full) --- 5350 /* The fourth arg 1 indicates the call is from quiesce */ 5351 if (EMLXS_SLI_HBA_RESET(hba, 1, 1, 1) == 0) { 5352 return (rval); 5353 } else { 5354 return (DDI_FAILURE); 5355 } 5356 5357} /* emlxs_quiesce */ | 5752 rval = FC_INVALID_REQUEST; 5753 } 5754 5755 return (rval); 5756 5757} /* emlxs_test() */ 5758 5759 --- 164 unchanged lines hidden (view full) --- 5924 /* The fourth arg 1 indicates the call is from quiesce */ 5925 if (EMLXS_SLI_HBA_RESET(hba, 1, 1, 1) == 0) { 5926 return (rval); 5927 } else { 5928 return (DDI_FAILURE); 5929 } 5930 5931} /* emlxs_quiesce */ |
5358#endif | 5932#endif /* S11 */ |
5359#endif /* EMLXS_I386 */ 5360 5361 5362static int 5363emlxs_open(dev_t *dev_p, int32_t flag, int32_t otype, cred_t *cred_p) 5364{ 5365 emlxs_hba_t *hba; 5366 emlxs_port_t *port; --- 158 unchanged lines hidden (view full) --- 5525 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_resume_msg, NULL); 5526 5527 if (!(hba->pm_state & EMLXS_PM_SUSPENDED)) { 5528 return (DDI_SUCCESS); 5529 } 5530 5531 hba->pm_state &= ~EMLXS_PM_SUSPENDED; 5532 | 5933#endif /* EMLXS_I386 */ 5934 5935 5936static int 5937emlxs_open(dev_t *dev_p, int32_t flag, int32_t otype, cred_t *cred_p) 5938{ 5939 emlxs_hba_t *hba; 5940 emlxs_port_t *port; --- 158 unchanged lines hidden (view full) --- 6099 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_resume_msg, NULL); 6100 6101 if (!(hba->pm_state & EMLXS_PM_SUSPENDED)) { 6102 return (DDI_SUCCESS); 6103 } 6104 6105 hba->pm_state &= ~EMLXS_PM_SUSPENDED; 6106 |
6107 /* Re-enable the physical port on this HBA */ 6108 port->flag |= EMLXS_PORT_ENABLED; 6109 |
|
5533 /* Take the adapter online */ 5534 if (emlxs_power_up(hba)) { 5535 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_resume_failed_msg, 5536 "Unable to take adapter online."); 5537 5538 hba->pm_state |= EMLXS_PM_SUSPENDED; 5539 5540 return (DDI_FAILURE); --- 39 unchanged lines hidden (view full) --- 5580} /* emlxs_hba_suspend() */ 5581 5582 5583 5584static void 5585emlxs_lock_init(emlxs_hba_t *hba) 5586{ 5587 emlxs_port_t *port = &PPORT; | 6110 /* Take the adapter online */ 6111 if (emlxs_power_up(hba)) { 6112 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_resume_failed_msg, 6113 "Unable to take adapter online."); 6114 6115 hba->pm_state |= EMLXS_PM_SUSPENDED; 6116 6117 return (DDI_FAILURE); --- 39 unchanged lines hidden (view full) --- 6157} /* emlxs_hba_suspend() */ 6158 6159 6160 6161static void 6162emlxs_lock_init(emlxs_hba_t *hba) 6163{ 6164 emlxs_port_t *port = &PPORT; |
5588 int32_t ddiinst; 5589 char buf[64]; | |
5590 uint32_t i; 5591 | 6165 uint32_t i; 6166 |
5592 ddiinst = hba->ddiinst; 5593 | |
5594 /* Initialize the power management */ | 6167 /* Initialize the power management */ |
5595 (void) sprintf(buf, "%s%d_pm_lock mutex", DRIVER_NAME, ddiinst); 5596 mutex_init(&EMLXS_PM_LOCK, buf, MUTEX_DRIVER, | 6168 mutex_init(&EMLXS_PM_LOCK, NULL, MUTEX_DRIVER, |
5597 DDI_INTR_PRI(hba->intr_arg)); 5598 | 6169 DDI_INTR_PRI(hba->intr_arg)); 6170 |
5599 (void) sprintf(buf, "%s%d_adap_lock mutex", DRIVER_NAME, ddiinst); 5600 mutex_init(&EMLXS_TIMER_LOCK, buf, MUTEX_DRIVER, | 6171 mutex_init(&EMLXS_TIMER_LOCK, NULL, MUTEX_DRIVER, |
5601 DDI_INTR_PRI(hba->intr_arg)); 5602 | 6172 DDI_INTR_PRI(hba->intr_arg)); 6173 |
5603 (void) sprintf(buf, "%s%d_adap_lock cv", DRIVER_NAME, ddiinst); 5604 cv_init(&hba->timer_lock_cv, buf, CV_DRIVER, NULL); | 6174 cv_init(&hba->timer_lock_cv, NULL, CV_DRIVER, NULL); |
5605 | 6175 |
5606 (void) sprintf(buf, "%s%d_port_lock mutex", DRIVER_NAME, ddiinst); 5607 mutex_init(&EMLXS_PORT_LOCK, buf, MUTEX_DRIVER, | 6176 mutex_init(&EMLXS_PORT_LOCK, NULL, MUTEX_DRIVER, |
5608 DDI_INTR_PRI(hba->intr_arg)); 5609 | 6177 DDI_INTR_PRI(hba->intr_arg)); 6178 |
5610 (void) sprintf(buf, "%s%d_mbox_lock mutex", DRIVER_NAME, ddiinst); 5611 mutex_init(&EMLXS_MBOX_LOCK, buf, MUTEX_DRIVER, | 6179 mutex_init(&EMLXS_MBOX_LOCK, NULL, MUTEX_DRIVER, |
5612 DDI_INTR_PRI(hba->intr_arg)); 5613 | 6180 DDI_INTR_PRI(hba->intr_arg)); 6181 |
5614 (void) sprintf(buf, "%s%d_mbox_lock cv", DRIVER_NAME, ddiinst); 5615 cv_init(&EMLXS_MBOX_CV, buf, CV_DRIVER, NULL); | 6182 cv_init(&EMLXS_MBOX_CV, NULL, CV_DRIVER, NULL); |
5616 | 6183 |
5617 (void) sprintf(buf, "%s%d_linkup_lock mutex", DRIVER_NAME, ddiinst); 5618 mutex_init(&EMLXS_LINKUP_LOCK, buf, MUTEX_DRIVER, | 6184 mutex_init(&EMLXS_LINKUP_LOCK, NULL, MUTEX_DRIVER, |
5619 DDI_INTR_PRI(hba->intr_arg)); 5620 | 6185 DDI_INTR_PRI(hba->intr_arg)); 6186 |
5621 (void) sprintf(buf, "%s%d_linkup_lock cv", DRIVER_NAME, ddiinst); 5622 cv_init(&EMLXS_LINKUP_CV, buf, CV_DRIVER, NULL); | 6187 cv_init(&EMLXS_LINKUP_CV, NULL, CV_DRIVER, NULL); |
5623 | 6188 |
5624 (void) sprintf(buf, "%s%d_tx channel_lock mutex", DRIVER_NAME, ddiinst); 5625 mutex_init(&EMLXS_TX_CHANNEL_LOCK, buf, MUTEX_DRIVER, | 6189 mutex_init(&EMLXS_TX_CHANNEL_LOCK, NULL, MUTEX_DRIVER, |
5626 DDI_INTR_PRI(hba->intr_arg)); 5627 5628 for (i = 0; i < MAX_RINGS; i++) { | 6190 DDI_INTR_PRI(hba->intr_arg)); 6191 6192 for (i = 0; i < MAX_RINGS; i++) { |
5629 (void) sprintf(buf, "%s%d_cmd_ring%d_lock mutex", DRIVER_NAME, 5630 ddiinst, i); 5631 mutex_init(&EMLXS_CMD_RING_LOCK(i), buf, MUTEX_DRIVER, | 6193 mutex_init(&EMLXS_CMD_RING_LOCK(i), NULL, MUTEX_DRIVER, |
5632 DDI_INTR_PRI(hba->intr_arg)); 5633 } 5634 5635 5636 for (i = 0; i < EMLXS_MAX_WQS; i++) { | 6194 DDI_INTR_PRI(hba->intr_arg)); 6195 } 6196 6197 6198 for (i = 0; i < EMLXS_MAX_WQS; i++) { |
5637 (void) sprintf(buf, "%s%d wq_cq_eq%d lock mutex", DRIVER_NAME, 5638 ddiinst, i); 5639 mutex_init(&EMLXS_QUE_LOCK(i), buf, MUTEX_DRIVER, | 6199 mutex_init(&EMLXS_QUE_LOCK(i), NULL, MUTEX_DRIVER, |
5640 DDI_INTR_PRI(hba->intr_arg)); 5641 } 5642 | 6200 DDI_INTR_PRI(hba->intr_arg)); 6201 } 6202 |
5643 (void) sprintf(buf, "%s%d_msiid lock mutex", DRIVER_NAME, ddiinst); 5644 mutex_init(&EMLXS_MSIID_LOCK, buf, MUTEX_DRIVER, | 6203 mutex_init(&EMLXS_MSIID_LOCK, NULL, MUTEX_DRIVER, |
5645 DDI_INTR_PRI(hba->intr_arg)); 5646 | 6204 DDI_INTR_PRI(hba->intr_arg)); 6205 |
5647 (void) sprintf(buf, "%s%d_fctab_lock mutex", DRIVER_NAME, ddiinst); 5648 mutex_init(&EMLXS_FCTAB_LOCK, buf, MUTEX_DRIVER, | 6206 mutex_init(&EMLXS_FCTAB_LOCK, NULL, MUTEX_DRIVER, |
5649 DDI_INTR_PRI(hba->intr_arg)); 5650 | 6207 DDI_INTR_PRI(hba->intr_arg)); 6208 |
5651 (void) sprintf(buf, "%s%d_memget_lock mutex", DRIVER_NAME, ddiinst); 5652 mutex_init(&EMLXS_MEMGET_LOCK, buf, MUTEX_DRIVER, | 6209 mutex_init(&EMLXS_MEMGET_LOCK, NULL, MUTEX_DRIVER, |
5653 DDI_INTR_PRI(hba->intr_arg)); 5654 | 6210 DDI_INTR_PRI(hba->intr_arg)); 6211 |
5655 (void) sprintf(buf, "%s%d_memput_lock mutex", DRIVER_NAME, ddiinst); 5656 mutex_init(&EMLXS_MEMPUT_LOCK, buf, MUTEX_DRIVER, | 6212 mutex_init(&EMLXS_MEMPUT_LOCK, NULL, MUTEX_DRIVER, |
5657 DDI_INTR_PRI(hba->intr_arg)); 5658 | 6213 DDI_INTR_PRI(hba->intr_arg)); 6214 |
5659 (void) sprintf(buf, "%s%d_ioctl_lock mutex", DRIVER_NAME, ddiinst); 5660 mutex_init(&EMLXS_IOCTL_LOCK, buf, MUTEX_DRIVER, | 6215 mutex_init(&EMLXS_IOCTL_LOCK, NULL, MUTEX_DRIVER, |
5661 DDI_INTR_PRI(hba->intr_arg)); 5662 5663#ifdef DUMP_SUPPORT | 6216 DDI_INTR_PRI(hba->intr_arg)); 6217 6218#ifdef DUMP_SUPPORT |
5664 (void) sprintf(buf, "%s%d_dump mutex", DRIVER_NAME, ddiinst); 5665 mutex_init(&EMLXS_DUMP_LOCK, buf, MUTEX_DRIVER, | 6219 mutex_init(&EMLXS_DUMP_LOCK, NULL, MUTEX_DRIVER, |
5666 DDI_INTR_PRI(hba->intr_arg)); 5667#endif /* DUMP_SUPPORT */ 5668 | 6220 DDI_INTR_PRI(hba->intr_arg)); 6221#endif /* DUMP_SUPPORT */ 6222 |
5669 (void) sprintf(buf, "%s%d_thread_lock mutex", DRIVER_NAME, ddiinst); 5670 mutex_init(&EMLXS_SPAWN_LOCK, buf, MUTEX_DRIVER, | 6223 mutex_init(&EMLXS_SPAWN_LOCK, NULL, MUTEX_DRIVER, |
5671 DDI_INTR_PRI(hba->intr_arg)); 5672 5673 /* Create per port locks */ 5674 for (i = 0; i < MAX_VPORTS; i++) { 5675 port = &VPORT(i); 5676 5677 rw_init(&port->node_rwlock, NULL, RW_DRIVER, NULL); 5678 5679 if (i == 0) { | 6224 DDI_INTR_PRI(hba->intr_arg)); 6225 6226 /* Create per port locks */ 6227 for (i = 0; i < MAX_VPORTS; i++) { 6228 port = &VPORT(i); 6229 6230 rw_init(&port->node_rwlock, NULL, RW_DRIVER, NULL); 6231 6232 if (i == 0) { |
5680 (void) sprintf(buf, "%s%d_pkt_lock mutex", DRIVER_NAME, 5681 ddiinst); 5682 mutex_init(&EMLXS_PKT_LOCK, buf, MUTEX_DRIVER, | 6233 mutex_init(&EMLXS_PKT_LOCK, NULL, MUTEX_DRIVER, |
5683 DDI_INTR_PRI(hba->intr_arg)); 5684 | 6234 DDI_INTR_PRI(hba->intr_arg)); 6235 |
5685 (void) sprintf(buf, "%s%d_pkt_lock cv", DRIVER_NAME, 5686 ddiinst); 5687 cv_init(&EMLXS_PKT_CV, buf, CV_DRIVER, NULL); | 6236 cv_init(&EMLXS_PKT_CV, NULL, CV_DRIVER, NULL); |
5688 | 6237 |
5689 (void) sprintf(buf, "%s%d_ub_lock mutex", DRIVER_NAME, 5690 ddiinst); 5691 mutex_init(&EMLXS_UB_LOCK, buf, MUTEX_DRIVER, | 6238 mutex_init(&EMLXS_UB_LOCK, NULL, MUTEX_DRIVER, |
5692 DDI_INTR_PRI(hba->intr_arg)); 5693 } else { | 6239 DDI_INTR_PRI(hba->intr_arg)); 6240 } else { |
5694 (void) sprintf(buf, "%s%d.%d_pkt_lock mutex", 5695 DRIVER_NAME, ddiinst, port->vpi); 5696 mutex_init(&EMLXS_PKT_LOCK, buf, MUTEX_DRIVER, | 6241 mutex_init(&EMLXS_PKT_LOCK, NULL, MUTEX_DRIVER, |
5697 DDI_INTR_PRI(hba->intr_arg)); 5698 | 6242 DDI_INTR_PRI(hba->intr_arg)); 6243 |
5699 (void) sprintf(buf, "%s%d.%d_pkt_lock cv", DRIVER_NAME, 5700 ddiinst, port->vpi); 5701 cv_init(&EMLXS_PKT_CV, buf, CV_DRIVER, NULL); | 6244 cv_init(&EMLXS_PKT_CV, NULL, CV_DRIVER, NULL); |
5702 | 6245 |
5703 (void) sprintf(buf, "%s%d.%d_ub_lock mutex", 5704 DRIVER_NAME, ddiinst, port->vpi); 5705 mutex_init(&EMLXS_UB_LOCK, buf, MUTEX_DRIVER, | 6246 mutex_init(&EMLXS_UB_LOCK, NULL, MUTEX_DRIVER, |
5706 DDI_INTR_PRI(hba->intr_arg)); 5707 } 5708 } 5709 5710 return; 5711 5712} /* emlxs_lock_init() */ 5713 --- 90 unchanged lines hidden (view full) --- 5804 emlxs_thread_spawn_destroy(hba); 5805 } 5806 5807 if (init_flag & ATTACH_EVENTS) { 5808 (void) emlxs_event_queue_destroy(hba); 5809 } 5810 5811 if (init_flag & ATTACH_ONLINE) { | 6247 DDI_INTR_PRI(hba->intr_arg)); 6248 } 6249 } 6250 6251 return; 6252 6253} /* emlxs_lock_init() */ 6254 --- 90 unchanged lines hidden (view full) --- 6345 emlxs_thread_spawn_destroy(hba); 6346 } 6347 6348 if (init_flag & ATTACH_EVENTS) { 6349 (void) emlxs_event_queue_destroy(hba); 6350 } 6351 6352 if (init_flag & ATTACH_ONLINE) { |
5812 (void) emlxs_offline(hba); | 6353 (void) emlxs_offline(hba, 1); |
5813 } 5814 5815 if (init_flag & ATTACH_INTR_ADD) { 5816 (void) EMLXS_INTR_REMOVE(hba); 5817 } 5818#ifdef SFCT_SUPPORT 5819 if (init_flag & ATTACH_FCT) { 5820 emlxs_fct_detach(hba); | 6354 } 6355 6356 if (init_flag & ATTACH_INTR_ADD) { 6357 (void) EMLXS_INTR_REMOVE(hba); 6358 } 6359#ifdef SFCT_SUPPORT 6360 if (init_flag & ATTACH_FCT) { 6361 emlxs_fct_detach(hba); |
5821 if (hba->tgt_mode) { 5822 emlxs_fct_modclose(); 5823 } | 6362 emlxs_fct_modclose(); |
5824 } 5825#endif /* SFCT_SUPPORT */ 5826 5827#ifdef DHCHAP_SUPPORT 5828 if (init_flag & ATTACH_DHCHAP) { 5829 emlxs_dhc_detach(hba); 5830 } 5831#endif /* DHCHAP_SUPPORT */ --- 67 unchanged lines hidden (view full) --- 5899 (void) ddi_soft_state_free(emlxs_soft_state, ddiinst); 5900 } 5901 5902 return; 5903 5904} /* emlxs_driver_remove() */ 5905 5906 | 6363 } 6364#endif /* SFCT_SUPPORT */ 6365 6366#ifdef DHCHAP_SUPPORT 6367 if (init_flag & ATTACH_DHCHAP) { 6368 emlxs_dhc_detach(hba); 6369 } 6370#endif /* DHCHAP_SUPPORT */ --- 67 unchanged lines hidden (view full) --- 6438 (void) ddi_soft_state_free(emlxs_soft_state, ddiinst); 6439 } 6440 6441 return; 6442 6443} /* emlxs_driver_remove() */ 6444 6445 |
5907 | |
5908/* This determines which ports will be initiator mode */ | 6446/* This determines which ports will be initiator mode */ |
5909static void | 6447static uint32_t |
5910emlxs_fca_init(emlxs_hba_t *hba) 5911{ 5912 emlxs_port_t *port = &PPORT; | 6448emlxs_fca_init(emlxs_hba_t *hba) 6449{ 6450 emlxs_port_t *port = &PPORT; |
5913 emlxs_port_t *vport; 5914 uint32_t i; | |
5915 | 6451 |
5916 if (!hba->ini_mode) { 5917 return; 5918 } | |
5919 /* Check if SFS present */ 5920 if (((void *)MODSYM(fc_fca_init) == NULL) || 5921 ((void *)MODSYM(fc_fca_attach) == NULL)) { 5922 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, | 6452 /* Check if SFS present */ 6453 if (((void *)MODSYM(fc_fca_init) == NULL) || 6454 ((void *)MODSYM(fc_fca_attach) == NULL)) { 6455 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, |
5923 "SFS not present. Initiator mode disabled."); 5924 goto failed; | 6456 "SFS not present."); 6457 return (1); |
5925 } 5926 5927 /* Check if our SFS driver interface matches the current SFS stack */ 5928 if (MODSYM(fc_fca_attach) (hba->dip, hba->fca_tran) != DDI_SUCCESS) { 5929 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 5930 "SFS/FCA version mismatch. FCA=0x%x", 5931 hba->fca_tran->fca_version); | 6458 } 6459 6460 /* Check if our SFS driver interface matches the current SFS stack */ 6461 if (MODSYM(fc_fca_attach) (hba->dip, hba->fca_tran) != DDI_SUCCESS) { 6462 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 6463 "SFS/FCA version mismatch. FCA=0x%x", 6464 hba->fca_tran->fca_version); |
6465 return (1); 6466 } 6467 6468 return (0); 6469 6470} /* emlxs_fca_init() */ 6471 6472 6473/* This determines which ports will be initiator or target mode */ 6474static void 6475emlxs_mode_init(emlxs_hba_t *hba) 6476{ 6477 emlxs_port_t *port = &PPORT; 6478 emlxs_config_t *cfg = &CFG; 6479 emlxs_port_t *vport; 6480 uint32_t i; 6481 uint32_t mode_mask; 6482 6483 /* Initialize mode masks */ 6484 (void) emlxs_mode_init_masks(hba); 6485 6486 if (!(port->mode_mask & MODE_INITIATOR)) { |
|
5932 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, | 6487 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, |
5933 "SFS present. Initiator mode disabled."); | 6488 "Initiator mode not enabled."); |
5934 | 6489 |
5935 goto failed; | 6490#ifdef SFCT_SUPPORT 6491 /* Disable dynamic target mode */ 6492 cfg[CFG_DTM_ENABLE].current = 0; 6493#endif /* SFCT_SUPPORT */ 6494 6495 goto done1; |
5936 } 5937 | 6496 } 6497 |
6498 /* Try to initialize fca interface */ 6499 if (emlxs_fca_init(hba) != 0) { 6500 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 6501 "Initiator mode disabled."); 6502 6503 /* Disable initiator mode */ 6504 port->mode_mask &= ~MODE_INITIATOR; 6505 6506#ifdef SFCT_SUPPORT 6507 /* Disable dynamic target mode */ 6508 cfg[CFG_DTM_ENABLE].current = 0; 6509#endif /* SFCT_SUPPORT */ 6510 6511 goto done1; 6512 } 6513 |
|
5938 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, | 6514 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, |
5939 "SFS present. Initiator mode enabled."); | 6515 "Initiator mode enabled."); |
5940 | 6516 |
5941 return; | 6517done1: |
5942 | 6518 |
5943failed: | 6519#ifdef SFCT_SUPPORT 6520 if (!(port->mode_mask & MODE_TARGET)) { 6521 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 6522 "Target mode not enabled."); |
5944 | 6523 |
5945 hba->ini_mode = 0; 5946 for (i = 0; i < MAX_VPORTS; i++) { | 6524 /* Disable target modes */ 6525 cfg[CFG_DTM_ENABLE].current = 0; 6526 cfg[CFG_TARGET_MODE].current = 0; 6527 6528 goto done2; 6529 } 6530 6531 /* Try to open the COMSTAR module */ 6532 if (emlxs_fct_modopen() != 0) { 6533 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 6534 "Target mode disabled."); 6535 6536 /* Disable target modes */ 6537 port->mode_mask &= ~MODE_TARGET; 6538 cfg[CFG_DTM_ENABLE].current = 0; 6539 cfg[CFG_TARGET_MODE].current = 0; 6540 6541 goto done2; 6542 } 6543 6544 /* Try to initialize fct interface */ 6545 if (emlxs_fct_init(hba) != 0) { 6546 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 6547 "Target mode disabled."); 6548 6549 /* Disable target modes */ 6550 port->mode_mask &= ~MODE_TARGET; 6551 cfg[CFG_DTM_ENABLE].current = 0; 6552 cfg[CFG_TARGET_MODE].current = 0; 6553 6554 goto done2; 6555 } 6556 6557 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 6558 "Target mode enabled."); 6559 6560done2: 6561 /* Adjust target mode parameter flags */ 6562 if (cfg[CFG_DTM_ENABLE].current) { 6563 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 6564 "Dynamic target mode enabled."); 6565 6566 cfg[CFG_TARGET_MODE].flags |= PARM_DYNAMIC; 6567 } else { 6568 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 6569 "Dynamic target mode disabled."); 6570 6571 cfg[CFG_TARGET_MODE].flags &= ~PARM_DYNAMIC; 6572 } 6573#endif /* SFCT_SUPPORT */ 6574 6575 /* Now set port flags */ 6576 mutex_enter(&EMLXS_PORT_LOCK); 6577 6578 /* Set flags for physical port */ 6579 if (port->mode_mask & MODE_INITIATOR) { 6580 port->flag |= EMLXS_INI_ENABLED; 6581 } else { 6582 port->flag &= ~EMLXS_INI_ENABLED; 6583 } 6584 6585 if (port->mode_mask & MODE_TARGET) { 6586 port->flag |= EMLXS_TGT_ENABLED; 6587 } else { 6588 port->flag &= ~EMLXS_TGT_ENABLED; 6589 } 6590 6591 for (i = 1; i < MAX_VPORTS; i++) { |
5947 vport = &VPORT(i); | 6592 vport = &VPORT(i); |
5948 vport->ini_mode = 0; | 6593 6594 /* Physical port mask has only allowable bits */ 6595 mode_mask = vport->mode_mask & port->mode_mask; 6596 6597 /* Set flags for physical port */ 6598 if (mode_mask & MODE_INITIATOR) { 6599 vport->flag |= EMLXS_INI_ENABLED; 6600 } else { 6601 vport->flag &= ~EMLXS_INI_ENABLED; 6602 } 6603 6604 if (mode_mask & MODE_TARGET) { 6605 vport->flag |= EMLXS_TGT_ENABLED; 6606 } else { 6607 vport->flag &= ~EMLXS_TGT_ENABLED; 6608 } |
5949 } 5950 | 6609 } 6610 |
6611 /* Set initial driver mode */ 6612 emlxs_mode_set(hba); 6613 6614 mutex_exit(&EMLXS_PORT_LOCK); 6615 6616 /* Recheck possible mode dependent parameters */ 6617 /* in case conditions have changed. */ 6618 if (port->mode != MODE_NONE) { 6619 for (i = 0; i < NUM_CFG_PARAM; i++) { 6620 cfg = &hba->config[i]; 6621 cfg->current = emlxs_check_parm(hba, i, cfg->current); 6622 } 6623 } 6624 |
|
5951 return; 5952 | 6625 return; 6626 |
5953} /* emlxs_fca_init() */ | 6627} /* emlxs_mode_init() */ |
5954 5955 | 6628 6629 |
5956/* This determines which ports will be initiator or target mode */ 5957static void 5958emlxs_set_mode(emlxs_hba_t *hba) | 6630/* This must be called while holding the EMLXS_PORT_LOCK */ 6631extern void 6632emlxs_mode_set(emlxs_hba_t *hba) |
5959{ 5960 emlxs_port_t *port = &PPORT; | 6633{ 6634 emlxs_port_t *port = &PPORT; |
6635#ifdef SFCT_SUPPORT 6636 emlxs_config_t *cfg = &CFG; 6637#endif /* SFCT_SUPPORT */ |
|
5961 emlxs_port_t *vport; 5962 uint32_t i; | 6638 emlxs_port_t *vport; 6639 uint32_t i; |
5963 uint32_t tgt_mode = 0; | 6640 uint32_t cfg_tgt_mode = 0; |
5964 | 6641 |
6642 /* mutex_enter(&EMLXS_PORT_LOCK); */ 6643 |
|
5965#ifdef SFCT_SUPPORT | 6644#ifdef SFCT_SUPPORT |
5966 emlxs_config_t *cfg; | 6645 cfg_tgt_mode = cfg[CFG_TARGET_MODE].current; 6646#endif /* SFCT_SUPPORT */ |
5967 | 6647 |
5968 cfg = &hba->config[CFG_TARGET_MODE]; 5969 tgt_mode = cfg->current; 5970 5971 if (tgt_mode) { 5972 if (emlxs_fct_modopen() != 0) { 5973 tgt_mode = 0; | 6648 /* Initiator mode requested */ 6649 if (!cfg_tgt_mode) { 6650 for (i = 0; i < MAX_VPORTS; i++) { 6651 vport = &VPORT(i); 6652 vport->mode = (vport->flag & EMLXS_INI_ENABLED)? 6653 MODE_INITIATOR:MODE_NONE; |
5974 } | 6654 } |
6655#ifdef SFCT_SUPPORT 6656 /* Target mode requested */ 6657 } else { 6658 for (i = 0; i < MAX_VPORTS; i++) { 6659 vport = &VPORT(i); 6660 vport->mode = (vport->flag & EMLXS_TGT_ENABLED)? 6661 MODE_TARGET:MODE_NONE; 6662 } 6663#endif /* SFCT_SUPPORT */ |
|
5975 } 5976 | 6664 } 6665 |
5977 port->fct_flags = 0; 5978#endif /* SFCT_SUPPORT */ | 6666 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg, 6667 "MODE: %s", emlxs_mode_xlate(port->mode)); |
5979 | 6668 |
5980 /* Initialize physical port */ 5981 if (tgt_mode) { 5982 hba->tgt_mode = 1; 5983 hba->ini_mode = 0; | 6669 /* mutex_exit(&EMLXS_PORT_LOCK); */ |
5984 | 6670 |
5985 port->tgt_mode = 1; 5986 port->ini_mode = 0; 5987 } else { 5988 hba->tgt_mode = 0; 5989 hba->ini_mode = 1; | 6671 return; |
5990 | 6672 |
5991 port->tgt_mode = 0; 5992 port->ini_mode = 1; 5993 } | 6673} /* emlxs_mode_set() */ |
5994 | 6674 |
5995 /* Initialize virtual ports */ 5996 /* Virtual ports take on the mode of the parent physical port */ 5997 for (i = 1; i < MAX_VPORTS; i++) { 5998 vport = &VPORT(i); | |
5999 | 6675 |
6676static void 6677emlxs_mode_init_masks(emlxs_hba_t *hba) 6678{ 6679 emlxs_port_t *port = &PPORT; 6680 emlxs_port_t *vport; 6681 uint32_t i; 6682 |
|
6000#ifdef SFCT_SUPPORT | 6683#ifdef SFCT_SUPPORT |
6001 vport->fct_flags = 0; 6002#endif /* SFCT_SUPPORT */ | 6684 emlxs_config_t *cfg = &CFG; 6685 uint32_t vport_mode_mask; 6686 uint32_t cfg_vport_mode_mask; 6687 uint32_t mode_mask; 6688 char string[256]; |
6003 | 6689 |
6004 vport->ini_mode = port->ini_mode; 6005 vport->tgt_mode = port->tgt_mode; | 6690 port->mode_mask = 0; 6691 6692 if (!cfg[CFG_TARGET_MODE].current || 6693 cfg[CFG_DTM_ENABLE].current) { 6694 port->mode_mask |= MODE_INITIATOR; |
6006 } 6007 | 6695 } 6696 |
6008 /* Check if initiator mode is requested */ 6009 if (hba->ini_mode) { 6010 emlxs_fca_init(hba); 6011 } else { | 6697 if (cfg[CFG_TARGET_MODE].current || 6698 cfg[CFG_DTM_ENABLE].current) { 6699 port->mode_mask |= MODE_TARGET; 6700 } 6701 6702 /* Physical port mask has only allowable bits */ 6703 vport_mode_mask = port->mode_mask; 6704 cfg_vport_mode_mask = cfg[CFG_VPORT_MODE_MASK].current; 6705 6706 /* Check dynamic target mode value for virtual ports */ 6707 if (cfg[CFG_DTM_ENABLE].current == 0) { |
6012 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, | 6708 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, |
6013 "Initiator mode not enabled."); | 6709 "%s = 0: Virtual target ports are not supported.", 6710 cfg[CFG_DTM_ENABLE].string); 6711 6712 vport_mode_mask &= ~MODE_TARGET; |
6014 } 6015 | 6713 } 6714 |
6016#ifdef SFCT_SUPPORT 6017 /* Check if target mode is requested */ 6018 if (hba->tgt_mode) { 6019 emlxs_fct_init(hba); 6020 } else { | 6715 cfg_vport_mode_mask &= vport_mode_mask; 6716 6717 if (cfg[CFG_VPORT_MODE_MASK].current != cfg_vport_mode_mask) { |
6021 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, | 6718 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, |
6022 "Target mode not enabled."); | 6719 "%s: Changing 0x%x --> 0x%x", 6720 cfg[CFG_VPORT_MODE_MASK].string, 6721 cfg[CFG_VPORT_MODE_MASK].current, 6722 cfg_vport_mode_mask); 6723 6724 cfg[CFG_VPORT_MODE_MASK].current = cfg_vport_mode_mask; |
6023 } | 6725 } |
6726 6727 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 6728 "pport-mode-mask: %s", emlxs_mode_xlate(port->mode_mask)); 6729 6730 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 6731 "vport-mode-mask: %s", emlxs_mode_xlate(cfg_vport_mode_mask)); 6732 6733 for (i = 1; i < MAX_VPORTS; i++) { 6734 vport = &VPORT(i); 6735 6736 (void) snprintf(string, sizeof (string), 6737 "%s%d-vport%d-mode-mask", DRIVER_NAME, hba->ddiinst, i); 6738 6739 mode_mask = (uint32_t)ddi_prop_get_int(DDI_DEV_T_ANY, 6740 (void *)hba->dip, DDI_PROP_DONTPASS, string, 6741 cfg_vport_mode_mask); 6742 6743 vport->mode_mask = mode_mask & vport_mode_mask; 6744 6745 if (vport->mode_mask != cfg_vport_mode_mask) { 6746 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_debug_msg, 6747 "vport%d-mode-mask: %s", 6748 i, emlxs_mode_xlate(vport->mode_mask)); 6749 } 6750 } 6751#else 6752 port->mode_mask = MODE_INITIATOR; 6753 for (i = 1; i < MAX_VPORTS; i++) { 6754 vport = &VPORT(i); 6755 vport->mode_mask = MODE_INITIATOR; 6756 } |
|
6024#endif /* SFCT_SUPPORT */ 6025 6026 return; 6027 | 6757#endif /* SFCT_SUPPORT */ 6758 6759 return; 6760 |
6028} /* emlxs_set_mode() */ | 6761} /* emlxs_mode_init_masks() */ |
6029 6030 | 6762 6763 |
6031 | |
6032static void 6033emlxs_fca_attach(emlxs_hba_t *hba) 6034{ | 6764static void 6765emlxs_fca_attach(emlxs_hba_t *hba) 6766{ |
6767 emlxs_port_t *port; 6768 uint32_t i; 6769 |
|
6035 /* Update our transport structure */ 6036 hba->fca_tran->fca_iblock = (ddi_iblock_cookie_t *)&hba->intr_arg; 6037 hba->fca_tran->fca_cmd_max = hba->io_throttle; 6038 | 6770 /* Update our transport structure */ 6771 hba->fca_tran->fca_iblock = (ddi_iblock_cookie_t *)&hba->intr_arg; 6772 hba->fca_tran->fca_cmd_max = hba->io_throttle; 6773 |
6774 for (i = 0; i < MAX_VPORTS; i++) { 6775 port = &VPORT(i); 6776 port->ub_count = EMLXS_UB_TOKEN_OFFSET; 6777 port->ub_pool = NULL; 6778 } 6779 |
|
6039#if (EMLXS_MODREV >= EMLXS_MODREV5) 6040 bcopy((caddr_t)&hba->wwpn, (caddr_t)&hba->fca_tran->fca_perm_pwwn, 6041 sizeof (NAME_TYPE)); 6042#endif /* >= EMLXS_MODREV5 */ 6043 6044 return; 6045 6046} /* emlxs_fca_attach() */ 6047 6048 6049static void 6050emlxs_fca_detach(emlxs_hba_t *hba) 6051{ | 6780#if (EMLXS_MODREV >= EMLXS_MODREV5) 6781 bcopy((caddr_t)&hba->wwpn, (caddr_t)&hba->fca_tran->fca_perm_pwwn, 6782 sizeof (NAME_TYPE)); 6783#endif /* >= EMLXS_MODREV5 */ 6784 6785 return; 6786 6787} /* emlxs_fca_attach() */ 6788 6789 6790static void 6791emlxs_fca_detach(emlxs_hba_t *hba) 6792{ |
6793 emlxs_port_t *port = &PPORT; |
|
6052 uint32_t i; 6053 emlxs_port_t *vport; 6054 | 6794 uint32_t i; 6795 emlxs_port_t *vport; 6796 |
6055 if (hba->ini_mode) { 6056 if ((void *)MODSYM(fc_fca_detach) != NULL) { 6057 MODSYM(fc_fca_detach)(hba->dip); 6058 } | 6797 if (!(port->flag & EMLXS_INI_ENABLED)) { 6798 return; 6799 } |
6059 | 6800 |
6060 hba->ini_mode = 0; | 6801 if ((void *)MODSYM(fc_fca_detach) != NULL) { 6802 MODSYM(fc_fca_detach)(hba->dip); 6803 } |
6061 | 6804 |
6062 for (i = 0; i < MAX_VPORTS; i++) { 6063 vport = &VPORT(i); 6064 vport->ini_mode = 0; 6065 } | 6805 /* Disable INI mode for all ports */ 6806 for (i = 0; i < MAX_VPORTS; i++) { 6807 vport = &VPORT(i); 6808 vport->flag &= ~EMLXS_INI_ENABLED; |
6066 } 6067 6068 return; 6069 6070} /* emlxs_fca_detach() */ 6071 6072 | 6809 } 6810 6811 return; 6812 6813} /* emlxs_fca_detach() */ 6814 6815 |
6073 | |
6074static void 6075emlxs_drv_banner(emlxs_hba_t *hba) 6076{ 6077 emlxs_port_t *port = &PPORT; 6078 uint32_t i; 6079 char sli_mode[16]; 6080 char msi_mode[16]; 6081 char npiv_mode[16]; 6082 emlxs_vpd_t *vpd = &VPD; | 6816static void 6817emlxs_drv_banner(emlxs_hba_t *hba) 6818{ 6819 emlxs_port_t *port = &PPORT; 6820 uint32_t i; 6821 char sli_mode[16]; 6822 char msi_mode[16]; 6823 char npiv_mode[16]; 6824 emlxs_vpd_t *vpd = &VPD; |
6083 emlxs_config_t *cfg = &CFG; | |
6084 uint8_t *wwpn; 6085 uint8_t *wwnn; 6086 uint32_t fw_show = 0; 6087 6088 /* Display firmware library one time for all driver instances */ 6089 mutex_enter(&emlxs_device.lock); | 6825 uint8_t *wwpn; 6826 uint8_t *wwnn; 6827 uint32_t fw_show = 0; 6828 6829 /* Display firmware library one time for all driver instances */ 6830 mutex_enter(&emlxs_device.lock); |
6090 if (! (emlxs_instance_flag & EMLXS_FW_SHOW)) { | 6831 if (!(emlxs_instance_flag & EMLXS_FW_SHOW)) { |
6091 emlxs_instance_flag |= EMLXS_FW_SHOW; 6092 fw_show = 1; 6093 } 6094 mutex_exit(&emlxs_device.lock); 6095 6096 if (fw_show) { | 6832 emlxs_instance_flag |= EMLXS_FW_SHOW; 6833 fw_show = 1; 6834 } 6835 mutex_exit(&emlxs_device.lock); 6836 6837 if (fw_show) { |
6838 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_msg, "%s", 6839 emlxs_copyright); |
|
6097 emlxs_fw_show(hba); 6098 } 6099 6100 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_msg, "%s (%s)", emlxs_label, 6101 emlxs_revision); 6102 6103 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_msg, 6104 "%s Dev_id:%x Sub_id:%x Id:%d", hba->model_info.model, --- 10 unchanged lines hidden (view full) --- 6115 6116 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_msg, 6117 "Firmware:%s (%s) Boot:%s Fcode:%s", vpd->fw_version, 6118 vpd->fw_label, vpd->boot_version, vpd->fcode_version); 6119 6120#endif /* EMLXS_I386 */ 6121 6122 if (hba->sli_mode > 3) { | 6840 emlxs_fw_show(hba); 6841 } 6842 6843 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_msg, "%s (%s)", emlxs_label, 6844 emlxs_revision); 6845 6846 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_msg, 6847 "%s Dev_id:%x Sub_id:%x Id:%d", hba->model_info.model, --- 10 unchanged lines hidden (view full) --- 6858 6859 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_msg, 6860 "Firmware:%s (%s) Boot:%s Fcode:%s", vpd->fw_version, 6861 vpd->fw_label, vpd->boot_version, vpd->fcode_version); 6862 6863#endif /* EMLXS_I386 */ 6864 6865 if (hba->sli_mode > 3) { |
6123 (void) sprintf(sli_mode, "SLI:%d(%s)", hba->sli_mode, | 6866 (void) snprintf(sli_mode, sizeof (sli_mode), "SLI:%d(%s)", 6867 hba->sli_mode, |
6124 ((hba->flag & FC_FIP_SUPPORTED) ? "FIP" : "nonFIP")); 6125 } else { | 6868 ((hba->flag & FC_FIP_SUPPORTED) ? "FIP" : "nonFIP")); 6869 } else { |
6126 (void) sprintf(sli_mode, "SLI:%d", hba->sli_mode); | 6870 (void) snprintf(sli_mode, sizeof (sli_mode), "SLI:%d", 6871 hba->sli_mode); |
6127 } 6128 | 6872 } 6873 |
6129 (void) strcpy(msi_mode, " INTX:1"); | 6874 (void) strlcpy(msi_mode, " INTX:1", sizeof (msi_mode)); |
6130 6131#ifdef MSI_SUPPORT 6132 if (hba->intr_flags & EMLXS_MSI_ENABLED) { 6133 switch (hba->intr_type) { 6134 case DDI_INTR_TYPE_FIXED: | 6875 6876#ifdef MSI_SUPPORT 6877 if (hba->intr_flags & EMLXS_MSI_ENABLED) { 6878 switch (hba->intr_type) { 6879 case DDI_INTR_TYPE_FIXED: |
6135 (void) strcpy(msi_mode, " MSI:0"); | 6880 (void) strlcpy(msi_mode, " MSI:0", sizeof (msi_mode)); |
6136 break; 6137 6138 case DDI_INTR_TYPE_MSI: | 6881 break; 6882 6883 case DDI_INTR_TYPE_MSI: |
6139 (void) sprintf(msi_mode, " MSI:%d", hba->intr_count); | 6884 (void) snprintf(msi_mode, sizeof (msi_mode), " MSI:%d", 6885 hba->intr_count); |
6140 break; 6141 6142 case DDI_INTR_TYPE_MSIX: | 6886 break; 6887 6888 case DDI_INTR_TYPE_MSIX: |
6143 (void) sprintf(msi_mode, " MSIX:%d", hba->intr_count); | 6889 (void) snprintf(msi_mode, sizeof (msi_mode), " MSIX:%d", 6890 hba->intr_count); |
6144 break; 6145 } 6146 } | 6891 break; 6892 } 6893 } |
6147#endif | 6894#endif /* MSI_SUPPORT */ |
6148 | 6895 |
6149 (void) strcpy(npiv_mode, ""); | 6896 (void) strlcpy(npiv_mode, "", sizeof (npiv_mode)); |
6150 6151 if (hba->flag & FC_NPIV_ENABLED) { | 6897 6898 if (hba->flag & FC_NPIV_ENABLED) { |
6152 (void) sprintf(npiv_mode, " NPIV:%d", hba->vpi_max+1); | 6899 (void) snprintf(npiv_mode, sizeof (npiv_mode), " NPIV:%d", 6900 hba->vpi_max+1); |
6153 } else { | 6901 } else { |
6154 (void) strcpy(npiv_mode, " NPIV:0"); | 6902 (void) strlcpy(npiv_mode, " NPIV:0", sizeof (npiv_mode)); |
6155 } 6156 | 6903 } 6904 |
6157 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_msg, "%s%s%s%s%s", 6158 sli_mode, msi_mode, npiv_mode, 6159 ((hba->ini_mode)? " FCA":""), ((hba->tgt_mode)? " FCT":"")); | 6905 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) { 6906 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_msg, "%s%s%s%s%s%s", 6907 sli_mode, msi_mode, npiv_mode, 6908 ((port->flag & EMLXS_INI_ENABLED)? " FCA":""), 6909 ((port->flag & EMLXS_TGT_ENABLED)? " FCT":""), 6910 ((SLI4_FCOE_MODE)? " FCoE":" FC")); 6911 } else { 6912 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_msg, "%s%s%s%s%s", 6913 sli_mode, msi_mode, npiv_mode, 6914 ((port->flag & EMLXS_INI_ENABLED)? " FCA":""), 6915 ((port->flag & EMLXS_TGT_ENABLED)? " FCT":"")); 6916 } |
6160 6161 wwpn = (uint8_t *)&hba->wwpn; 6162 wwnn = (uint8_t *)&hba->wwnn; 6163 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_msg, 6164 "WWPN:%02X%02X%02X%02X%02X%02X%02X%02X " 6165 "WWNN:%02X%02X%02X%02X%02X%02X%02X%02X", 6166 wwpn[0], wwpn[1], wwpn[2], wwpn[3], wwpn[4], wwpn[5], wwpn[6], 6167 wwpn[7], wwnn[0], wwnn[1], wwnn[2], wwnn[3], wwnn[4], wwnn[5], --- 11 unchanged lines hidden (view full) --- 6179 6180 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_msg, 6181 "WWPN:%02X%02X%02X%02X%02X%02X%02X%02X " 6182 "WWNN:%02X%02X%02X%02X%02X%02X%02X%02X", 6183 wwpn[0], wwpn[1], wwpn[2], wwpn[3], wwpn[4], wwpn[5], 6184 wwpn[6], wwpn[7], wwnn[0], wwnn[1], wwnn[2], wwnn[3], 6185 wwnn[4], wwnn[5], wwnn[6], wwnn[7]); 6186 } | 6917 6918 wwpn = (uint8_t *)&hba->wwpn; 6919 wwnn = (uint8_t *)&hba->wwnn; 6920 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_msg, 6921 "WWPN:%02X%02X%02X%02X%02X%02X%02X%02X " 6922 "WWNN:%02X%02X%02X%02X%02X%02X%02X%02X", 6923 wwpn[0], wwpn[1], wwpn[2], wwpn[3], wwpn[4], wwpn[5], wwpn[6], 6924 wwpn[7], wwnn[0], wwnn[1], wwnn[2], wwnn[3], wwnn[4], wwnn[5], --- 11 unchanged lines hidden (view full) --- 6936 6937 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_msg, 6938 "WWPN:%02X%02X%02X%02X%02X%02X%02X%02X " 6939 "WWNN:%02X%02X%02X%02X%02X%02X%02X%02X", 6940 wwpn[0], wwpn[1], wwpn[2], wwpn[3], wwpn[4], wwpn[5], 6941 wwpn[6], wwpn[7], wwnn[0], wwnn[1], wwnn[2], wwnn[3], 6942 wwnn[4], wwnn[5], wwnn[6], wwnn[7]); 6943 } |
6187 port = &PPORT; | |
6188 6189 /* | 6944 6945 /* |
6190 * No dependency for Restricted login parameter. 6191 */ 6192 if ((cfg[CFG_VPORT_RESTRICTED].current) && (port->ini_mode)) { 6193 port->flag |= EMLXS_PORT_RESTRICTED; 6194 } else { 6195 port->flag &= ~EMLXS_PORT_RESTRICTED; 6196 } 6197 6198 /* | |
6199 * Announce the device: ddi_report_dev() prints a banner at boot time, 6200 * announcing the device pointed to by dip. 6201 */ 6202 (void) ddi_report_dev(hba->dip); 6203 6204 return; 6205 6206} /* emlxs_drv_banner() */ --- 11 unchanged lines hidden (view full) --- 6218 status = 6219 ddi_prop_lookup_string(DDI_DEV_T_ANY, (dev_info_t *)hba->dip, 0, 6220 "fcode-version", (char **)&prop_str); 6221 6222 if (status == DDI_PROP_SUCCESS) { 6223 bcopy(prop_str, vpd->fcode_version, strlen(prop_str)); 6224 (void) ddi_prop_free((void *)prop_str); 6225 } else { | 6946 * Announce the device: ddi_report_dev() prints a banner at boot time, 6947 * announcing the device pointed to by dip. 6948 */ 6949 (void) ddi_report_dev(hba->dip); 6950 6951 return; 6952 6953} /* emlxs_drv_banner() */ --- 11 unchanged lines hidden (view full) --- 6965 status = 6966 ddi_prop_lookup_string(DDI_DEV_T_ANY, (dev_info_t *)hba->dip, 0, 6967 "fcode-version", (char **)&prop_str); 6968 6969 if (status == DDI_PROP_SUCCESS) { 6970 bcopy(prop_str, vpd->fcode_version, strlen(prop_str)); 6971 (void) ddi_prop_free((void *)prop_str); 6972 } else { |
6226 (void) strcpy(vpd->fcode_version, "none"); | 6973 (void) strncpy(vpd->fcode_version, "none", 6974 (sizeof (vpd->fcode_version)-1)); |
6227 } 6228 6229 return; 6230 6231} /* emlxs_get_fcode_version() */ 6232 6233 6234static int --- 4 unchanged lines hidden (view full) --- 6239 emlxs_config_t *cfg; 6240 char *prop_str; 6241 int ddiinst; 6242 int32_t emlxinst; 6243 int status; 6244 uint32_t rval; 6245 uint32_t init_flag = 0; 6246 char local_pm_components[32]; | 6975 } 6976 6977 return; 6978 6979} /* emlxs_get_fcode_version() */ 6980 6981 6982static int --- 4 unchanged lines hidden (view full) --- 6987 emlxs_config_t *cfg; 6988 char *prop_str; 6989 int ddiinst; 6990 int32_t emlxinst; 6991 int status; 6992 uint32_t rval; 6993 uint32_t init_flag = 0; 6994 char local_pm_components[32]; |
6247#ifdef EMLXS_I386 | |
6248 uint32_t i; | 6995 uint32_t i; |
6249#endif /* EMLXS_I386 */ | |
6250 6251 ddiinst = ddi_get_instance(dip); 6252 emlxinst = emlxs_add_instance(ddiinst); 6253 6254 if (emlxinst >= MAX_FC_BRDS) { 6255 cmn_err(CE_WARN, 6256 "?%s: fca_hba_attach failed. Too many driver ddiinsts. " 6257 "inst=%x", DRIVER_NAME, ddiinst); --- 41 unchanged lines hidden (view full) --- 6299 emlxs_device.dump_txtfile[emlxinst] = &hba->dump_txtfile; 6300 emlxs_device.dump_dmpfile[emlxinst] = &hba->dump_dmpfile; 6301 emlxs_device.dump_ceefile[emlxinst] = &hba->dump_ceefile; 6302#endif /* DUMP_SUPPORT */ 6303 6304 hba->dip = dip; 6305 hba->emlxinst = emlxinst; 6306 hba->ddiinst = ddiinst; | 6996 6997 ddiinst = ddi_get_instance(dip); 6998 emlxinst = emlxs_add_instance(ddiinst); 6999 7000 if (emlxinst >= MAX_FC_BRDS) { 7001 cmn_err(CE_WARN, 7002 "?%s: fca_hba_attach failed. Too many driver ddiinsts. " 7003 "inst=%x", DRIVER_NAME, ddiinst); --- 41 unchanged lines hidden (view full) --- 7045 emlxs_device.dump_txtfile[emlxinst] = &hba->dump_txtfile; 7046 emlxs_device.dump_dmpfile[emlxinst] = &hba->dump_dmpfile; 7047 emlxs_device.dump_ceefile[emlxinst] = &hba->dump_ceefile; 7048#endif /* DUMP_SUPPORT */ 7049 7050 hba->dip = dip; 7051 hba->emlxinst = emlxinst; 7052 hba->ddiinst = ddiinst; |
6307 hba->ini_mode = 0; 6308 hba->tgt_mode = 0; | |
6309 6310 init_flag |= ATTACH_HBA; 6311 6312 /* Enable the physical port on this HBA */ 6313 port = &PPORT; 6314 port->hba = hba; 6315 port->vpi = 0; | 7053 7054 init_flag |= ATTACH_HBA; 7055 7056 /* Enable the physical port on this HBA */ 7057 port = &PPORT; 7058 port->hba = hba; 7059 port->vpi = 0; |
6316 port->flag |= EMLXS_PORT_ENABLE; | 7060 port->flag |= EMLXS_PORT_ENABLED; |
6317 6318 /* Allocate a transport structure */ 6319 hba->fca_tran = 6320 (fc_fca_tran_t *)kmem_zalloc(sizeof (fc_fca_tran_t), KM_NOSLEEP); 6321 if (hba->fca_tran == NULL) { 6322 cmn_err(CE_WARN, 6323 "?%s%d: fca_hba_attach failed. Unable to allocate fca_tran " 6324 "memory.", DRIVER_NAME, ddiinst); --- 106 unchanged lines hidden (view full) --- 6431 "Unable to get adapter info. Id:%d Device id:0x%x " 6432 "Model:%s", hba->model_info.id, 6433 hba->model_info.device_id, hba->model_info.model); 6434 goto failed; 6435 } 6436#define FILTER_ORACLE_BRANDED 6437#ifdef FILTER_ORACLE_BRANDED 6438 | 7061 7062 /* Allocate a transport structure */ 7063 hba->fca_tran = 7064 (fc_fca_tran_t *)kmem_zalloc(sizeof (fc_fca_tran_t), KM_NOSLEEP); 7065 if (hba->fca_tran == NULL) { 7066 cmn_err(CE_WARN, 7067 "?%s%d: fca_hba_attach failed. Unable to allocate fca_tran " 7068 "memory.", DRIVER_NAME, ddiinst); --- 106 unchanged lines hidden (view full) --- 7175 "Unable to get adapter info. Id:%d Device id:0x%x " 7176 "Model:%s", hba->model_info.id, 7177 hba->model_info.device_id, hba->model_info.model); 7178 goto failed; 7179 } 7180#define FILTER_ORACLE_BRANDED 7181#ifdef FILTER_ORACLE_BRANDED 7182 |
6439 /* Sun-branded adapters are not supported */ 6440 if (hba->model_info.flags & EMLXS_SUN_BRANDED) { | 7183 /* Oracle branded adapters are not supported in this driver */ 7184 if (hba->model_info.flags & EMLXS_ORACLE_BRANDED) { |
6441 hba->model_info.flags |= EMLXS_NOT_SUPPORTED; 6442 } 6443#endif /* FILTER_ORACLE_BRANDED */ 6444 6445 /* Check if adapter is not supported */ 6446 if (hba->model_info.flags & EMLXS_NOT_SUPPORTED) { 6447 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_failed_msg, 6448 "Unsupported adapter found. Id:%d Device id:0x%x " 6449 "SSDID:0x%x Model:%s", hba->model_info.id, 6450 hba->model_info.device_id, 6451 hba->model_info.ssdid, hba->model_info.model); 6452 goto failed; 6453 } | 7185 hba->model_info.flags |= EMLXS_NOT_SUPPORTED; 7186 } 7187#endif /* FILTER_ORACLE_BRANDED */ 7188 7189 /* Check if adapter is not supported */ 7190 if (hba->model_info.flags & EMLXS_NOT_SUPPORTED) { 7191 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_failed_msg, 7192 "Unsupported adapter found. Id:%d Device id:0x%x " 7193 "SSDID:0x%x Model:%s", hba->model_info.id, 7194 hba->model_info.device_id, 7195 hba->model_info.ssdid, hba->model_info.model); 7196 goto failed; 7197 } |
7198 |
|
6454 if (hba->model_info.sli_mask & EMLXS_SLI4_MASK) { 6455 hba->sli.sli4.mem_sgl_size = MEM_SGL_SIZE; | 7199 if (hba->model_info.sli_mask & EMLXS_SLI4_MASK) { 7200 hba->sli.sli4.mem_sgl_size = MEM_SGL_SIZE; |
7201 |
|
6456#ifdef EMLXS_I386 6457 /* 6458 * TigerShark has 64K limit for SG element size 6459 * Do this for x86 alone. For SPARC, the driver 6460 * breaks up the single SGE later on. 6461 */ 6462 hba->dma_attr_ro.dma_attr_count_max = 0xffff; 6463 6464 i = cfg[CFG_MAX_XFER_SIZE].current; 6465 /* Update SGL size based on max_xfer_size */ | 7202#ifdef EMLXS_I386 7203 /* 7204 * TigerShark has 64K limit for SG element size 7205 * Do this for x86 alone. For SPARC, the driver 7206 * breaks up the single SGE later on. 7207 */ 7208 hba->dma_attr_ro.dma_attr_count_max = 0xffff; 7209 7210 i = cfg[CFG_MAX_XFER_SIZE].current; 7211 /* Update SGL size based on max_xfer_size */ |
6466 if (i > 688128) { 6467 /* 688128 = (((2048 / 12) - 2) * 4096) */ | 7212 if (i > 516096) { 7213 /* 516096 = (((2048 / 16) - 2) * 4096) */ |
6468 hba->sli.sli4.mem_sgl_size = 4096; | 7214 hba->sli.sli4.mem_sgl_size = 4096; |
6469 } else if (i > 339968) { 6470 /* 339968 = (((1024 / 12) - 2) * 4096) */ | 7215 } else if (i > 253952) { 7216 /* 253952 = (((1024 / 16) - 2) * 4096) */ |
6471 hba->sli.sli4.mem_sgl_size = 2048; 6472 } else { 6473 hba->sli.sli4.mem_sgl_size = 1024; 6474 } | 7217 hba->sli.sli4.mem_sgl_size = 2048; 7218 } else { 7219 hba->sli.sli4.mem_sgl_size = 1024; 7220 } |
6475 i = SGL_TO_SGLLEN(hba->sli.sli4.mem_sgl_size); | |
6476#endif /* EMLXS_I386 */ | 7221#endif /* EMLXS_I386 */ |
7222 7223 i = SGL_TO_SGLLEN(hba->sli.sli4.mem_sgl_size); |
|
6477 } else { 6478 hba->sli.sli3.mem_bpl_size = MEM_BPL_SIZE; | 7224 } else { 7225 hba->sli.sli3.mem_bpl_size = MEM_BPL_SIZE; |
7226 |
|
6479#ifdef EMLXS_I386 6480 i = cfg[CFG_MAX_XFER_SIZE].current; 6481 /* Update BPL size based on max_xfer_size */ 6482 if (i > 688128) { 6483 /* 688128 = (((2048 / 12) - 2) * 4096) */ 6484 hba->sli.sli3.mem_bpl_size = 4096; 6485 } else if (i > 339968) { 6486 /* 339968 = (((1024 / 12) - 2) * 4096) */ 6487 hba->sli.sli3.mem_bpl_size = 2048; 6488 } else { 6489 hba->sli.sli3.mem_bpl_size = 1024; 6490 } | 7227#ifdef EMLXS_I386 7228 i = cfg[CFG_MAX_XFER_SIZE].current; 7229 /* Update BPL size based on max_xfer_size */ 7230 if (i > 688128) { 7231 /* 688128 = (((2048 / 12) - 2) * 4096) */ 7232 hba->sli.sli3.mem_bpl_size = 4096; 7233 } else if (i > 339968) { 7234 /* 339968 = (((1024 / 12) - 2) * 4096) */ 7235 hba->sli.sli3.mem_bpl_size = 2048; 7236 } else { 7237 hba->sli.sli3.mem_bpl_size = 1024; 7238 } |
6491 i = BPL_TO_SGLLEN(hba->sli.sli3.mem_bpl_size); | |
6492#endif /* EMLXS_I386 */ | 7239#endif /* EMLXS_I386 */ |
7240 7241 i = BPL_TO_SGLLEN(hba->sli.sli3.mem_bpl_size); |
|
6493 } 6494 | 7242 } 7243 |
6495#ifdef EMLXS_I386 6496 /* Update dma_attr_sgllen based on BPL size */ | 7244 /* Update dma_attr_sgllen based on true SGL length */ |
6497 hba->dma_attr.dma_attr_sgllen = i; 6498 hba->dma_attr_ro.dma_attr_sgllen = i; 6499 hba->dma_attr_fcip_rsp.dma_attr_sgllen = i; | 7245 hba->dma_attr.dma_attr_sgllen = i; 7246 hba->dma_attr_ro.dma_attr_sgllen = i; 7247 hba->dma_attr_fcip_rsp.dma_attr_sgllen = i; |
6500#endif /* EMLXS_I386 */ | |
6501 6502 if (EMLXS_SLI_MAP_HDW(hba)) { 6503 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_failed_msg, 6504 "Unable to map memory"); 6505 goto failed; 6506 6507 } 6508 init_flag |= ATTACH_MAP_SLI; --- 30 unchanged lines hidden (view full) --- 6539 hba->pm_busy = 0; 6540#ifdef IDLE_TIMER 6541 hba->pm_active = 1; 6542 hba->pm_idle_timer = 0; 6543#endif /* IDLE_TIMER */ 6544 mutex_exit(&EMLXS_PM_LOCK); 6545 6546 /* Set the pm component name */ | 7248 7249 if (EMLXS_SLI_MAP_HDW(hba)) { 7250 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_failed_msg, 7251 "Unable to map memory"); 7252 goto failed; 7253 7254 } 7255 init_flag |= ATTACH_MAP_SLI; --- 30 unchanged lines hidden (view full) --- 7286 hba->pm_busy = 0; 7287#ifdef IDLE_TIMER 7288 hba->pm_active = 1; 7289 hba->pm_idle_timer = 0; 7290#endif /* IDLE_TIMER */ 7291 mutex_exit(&EMLXS_PM_LOCK); 7292 7293 /* Set the pm component name */ |
6547 (void) sprintf(local_pm_components, "NAME=%s%d", DRIVER_NAME, 6548 ddiinst); | 7294 (void) snprintf(local_pm_components, sizeof (local_pm_components), 7295 "NAME=%s%d", DRIVER_NAME, ddiinst); |
6549 emlxs_pm_components[0] = local_pm_components; 6550 6551 /* Check if power management support is enabled */ 6552 if (cfg[CFG_PM_SUPPORT].current) { 6553 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, dip, 6554 "pm-components", emlxs_pm_components, 6555 sizeof (emlxs_pm_components) / 6556 sizeof (emlxs_pm_components[0])) != --- 11 unchanged lines hidden (view full) --- 6568 6569 emlxs_thread_spawn_create(hba); 6570 init_flag |= ATTACH_SPAWN; 6571 6572 emlxs_thread_create(hba, &hba->iodone_thread); 6573 6574 init_flag |= ATTACH_THREAD; 6575 | 7296 emlxs_pm_components[0] = local_pm_components; 7297 7298 /* Check if power management support is enabled */ 7299 if (cfg[CFG_PM_SUPPORT].current) { 7300 if (ddi_prop_update_string_array(DDI_DEV_T_NONE, dip, 7301 "pm-components", emlxs_pm_components, 7302 sizeof (emlxs_pm_components) / 7303 sizeof (emlxs_pm_components[0])) != --- 11 unchanged lines hidden (view full) --- 7315 7316 emlxs_thread_spawn_create(hba); 7317 init_flag |= ATTACH_SPAWN; 7318 7319 emlxs_thread_create(hba, &hba->iodone_thread); 7320 7321 init_flag |= ATTACH_THREAD; 7322 |
7323retry: |
|
6576 /* Setup initiator / target ports */ | 7324 /* Setup initiator / target ports */ |
6577 emlxs_set_mode(hba); | 7325 emlxs_mode_init(hba); |
6578 6579 /* If driver did not attach to either stack, */ | 7326 7327 /* If driver did not attach to either stack, */ |
6580 /* then driver attach failed */ 6581 if (!hba->tgt_mode && !hba->ini_mode) { | 7328 /* then driver attach fails */ 7329 if (port->mode == MODE_NONE) { |
6582 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_failed_msg, 6583 "Driver interfaces not enabled."); 6584 goto failed; 6585 } 6586 6587 /* 6588 * Initialize HBA 6589 */ 6590 6591 /* Set initial state */ 6592 mutex_enter(&EMLXS_PORT_LOCK); | 7330 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_failed_msg, 7331 "Driver interfaces not enabled."); 7332 goto failed; 7333 } 7334 7335 /* 7336 * Initialize HBA 7337 */ 7338 7339 /* Set initial state */ 7340 mutex_enter(&EMLXS_PORT_LOCK); |
6593 emlxs_diag_state = DDI_OFFDI; | |
6594 hba->flag |= FC_OFFLINE_MODE; 6595 hba->flag &= ~(FC_ONLINE_MODE | FC_ONLINING_MODE | FC_OFFLINING_MODE); 6596 mutex_exit(&EMLXS_PORT_LOCK); 6597 6598 if (status = emlxs_online(hba)) { 6599 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_failed_msg, 6600 "Unable to initialize adapter."); | 7341 hba->flag |= FC_OFFLINE_MODE; 7342 hba->flag &= ~(FC_ONLINE_MODE | FC_ONLINING_MODE | FC_OFFLINING_MODE); 7343 mutex_exit(&EMLXS_PORT_LOCK); 7344 7345 if (status = emlxs_online(hba)) { 7346 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_failed_msg, 7347 "Unable to initialize adapter."); |
7348 7349 if (status == EAGAIN) { 7350 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_attach_failed_msg, 7351 "Retrying adapter initialization ..."); 7352 goto retry; 7353 } |
|
6601 goto failed; 6602 } 6603 init_flag |= ATTACH_ONLINE; 6604 6605 /* This is to ensure that the model property is properly set */ 6606 (void) ddi_prop_update_string(DDI_DEV_T_NONE, dip, "model", 6607 hba->model_info.model); 6608 --- 54 unchanged lines hidden (view full) --- 6663 mutex_exit(&EMLXS_PM_LOCK); 6664 } else { 6665 mutex_enter(&EMLXS_PM_LOCK); 6666 hba->pm_state &= ~EMLXS_PM_IN_ATTACH; 6667 mutex_exit(&EMLXS_PM_LOCK); 6668 } 6669 6670#ifdef SFCT_SUPPORT | 7354 goto failed; 7355 } 7356 init_flag |= ATTACH_ONLINE; 7357 7358 /* This is to ensure that the model property is properly set */ 7359 (void) ddi_prop_update_string(DDI_DEV_T_NONE, dip, "model", 7360 hba->model_info.model); 7361 --- 54 unchanged lines hidden (view full) --- 7416 mutex_exit(&EMLXS_PM_LOCK); 7417 } else { 7418 mutex_enter(&EMLXS_PM_LOCK); 7419 hba->pm_state &= ~EMLXS_PM_IN_ATTACH; 7420 mutex_exit(&EMLXS_PM_LOCK); 7421 } 7422 7423#ifdef SFCT_SUPPORT |
6671 /* Do this last */ 6672 emlxs_fct_attach(hba); 6673 init_flag |= ATTACH_FCT; | 7424 if (port->flag & EMLXS_TGT_ENABLED) { 7425 /* Do this last */ 7426 emlxs_fct_attach(hba); 7427 init_flag |= ATTACH_FCT; 7428 } |
6674#endif /* SFCT_SUPPORT */ 6675 6676 return (DDI_SUCCESS); 6677 6678failed: 6679 6680 emlxs_driver_remove(dip, init_flag, 1); 6681 --- 33 unchanged lines hidden (view full) --- 6715 mutex_enter(&EMLXS_PM_LOCK); 6716 hba->pm_state &= ~EMLXS_PM_IN_DETACH; 6717 mutex_exit(&EMLXS_PM_LOCK); 6718 6719 return (DDI_FAILURE); 6720 } 6721 6722 /* Take the adapter offline first, if not already */ | 7429#endif /* SFCT_SUPPORT */ 7430 7431 return (DDI_SUCCESS); 7432 7433failed: 7434 7435 emlxs_driver_remove(dip, init_flag, 1); 7436 --- 33 unchanged lines hidden (view full) --- 7470 mutex_enter(&EMLXS_PM_LOCK); 7471 hba->pm_state &= ~EMLXS_PM_IN_DETACH; 7472 mutex_exit(&EMLXS_PM_LOCK); 7473 7474 return (DDI_FAILURE); 7475 } 7476 7477 /* Take the adapter offline first, if not already */ |
6723 if (emlxs_offline(hba) != 0) { | 7478 if (emlxs_offline(hba, 1) != 0) { |
6724 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_failed_msg, 6725 "Unable to take adapter offline."); 6726 6727 mutex_enter(&EMLXS_PM_LOCK); 6728 hba->pm_state &= ~EMLXS_PM_IN_DETACH; 6729 mutex_exit(&EMLXS_PM_LOCK); 6730 6731 (void) emlxs_pm_raise_power(dip); --- 157 unchanged lines hidden (view full) --- 6889 new_value = cfg->def; 6890 6891 /* First check for the global setting */ 6892 new_value = (uint32_t)ddi_prop_get_int(DDI_DEV_T_ANY, 6893 (void *)hba->dip, DDI_PROP_DONTPASS, 6894 cfg->string, new_value); 6895 6896 /* Now check for the per adapter ddiinst setting */ | 7479 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_detach_failed_msg, 7480 "Unable to take adapter offline."); 7481 7482 mutex_enter(&EMLXS_PM_LOCK); 7483 hba->pm_state &= ~EMLXS_PM_IN_DETACH; 7484 mutex_exit(&EMLXS_PM_LOCK); 7485 7486 (void) emlxs_pm_raise_power(dip); --- 157 unchanged lines hidden (view full) --- 7644 new_value = cfg->def; 7645 7646 /* First check for the global setting */ 7647 new_value = (uint32_t)ddi_prop_get_int(DDI_DEV_T_ANY, 7648 (void *)hba->dip, DDI_PROP_DONTPASS, 7649 cfg->string, new_value); 7650 7651 /* Now check for the per adapter ddiinst setting */ |
6897 (void) sprintf(string, "%s%d-%s", DRIVER_NAME, hba->ddiinst, 6898 cfg->string); | 7652 (void) snprintf(string, sizeof (string), "%s%d-%s", DRIVER_NAME, 7653 hba->ddiinst, cfg->string); |
6899 6900 new_value = (uint32_t)ddi_prop_get_int(DDI_DEV_T_ANY, 6901 (void *)hba->dip, DDI_PROP_DONTPASS, string, new_value); 6902 6903 /* Now check the parameter */ 6904 cfg->current = emlxs_check_parm(hba, i, new_value); 6905 } 6906 --- 5 unchanged lines hidden (view full) --- 6912extern uint32_t 6913emlxs_check_parm(emlxs_hba_t *hba, uint32_t index, uint32_t new_value) 6914{ 6915 emlxs_port_t *port = &PPORT; 6916 uint32_t i; 6917 emlxs_config_t *cfg; 6918 emlxs_vpd_t *vpd = &VPD; 6919 | 7654 7655 new_value = (uint32_t)ddi_prop_get_int(DDI_DEV_T_ANY, 7656 (void *)hba->dip, DDI_PROP_DONTPASS, string, new_value); 7657 7658 /* Now check the parameter */ 7659 cfg->current = emlxs_check_parm(hba, i, new_value); 7660 } 7661 --- 5 unchanged lines hidden (view full) --- 7667extern uint32_t 7668emlxs_check_parm(emlxs_hba_t *hba, uint32_t index, uint32_t new_value) 7669{ 7670 emlxs_port_t *port = &PPORT; 7671 uint32_t i; 7672 emlxs_config_t *cfg; 7673 emlxs_vpd_t *vpd = &VPD; 7674 |
6920 if (index > NUM_CFG_PARAM) { | 7675 if (index >= NUM_CFG_PARAM) { |
6921 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 7676 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
6922 "emlxs_check_parm failed. Invalid index = %d", index); | 7677 "check_parm failed. Invalid index = %d", index); |
6923 6924 return (new_value); 6925 } 6926 6927 cfg = &hba->config[index]; 6928 6929 if (new_value > cfg->hi) { 6930 new_value = cfg->def; 6931 } else if (new_value < cfg->low) { 6932 new_value = cfg->def; 6933 } 6934 6935 /* Perform additional checks */ 6936 switch (index) { | 7678 7679 return (new_value); 7680 } 7681 7682 cfg = &hba->config[index]; 7683 7684 if (new_value > cfg->hi) { 7685 new_value = cfg->def; 7686 } else if (new_value < cfg->low) { 7687 new_value = cfg->def; 7688 } 7689 7690 /* Perform additional checks */ 7691 switch (index) { |
7692#ifdef SFCT_SUPPORT |
|
6937 case CFG_NPIV_ENABLE: | 7693 case CFG_NPIV_ENABLE: |
6938 if (hba->tgt_mode) { | 7694 if (hba->config[CFG_TARGET_MODE].current && 7695 hba->config[CFG_DTM_ENABLE].current == 0) { |
6939 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg, | 7696 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg, |
6940 "enable-npiv: Not supported in target mode. " | 7697 "enable-npiv: Not supported in pure target mode. " |
6941 "Disabling."); 6942 6943 new_value = 0; 6944 } 6945 break; | 7698 "Disabling."); 7699 7700 new_value = 0; 7701 } 7702 break; |
7703#endif /* SFCT_SUPPORT */ |
|
6946 | 7704 |
6947#ifdef DHCHAP_SUPPORT 6948 case CFG_AUTH_ENABLE: 6949 if (hba->tgt_mode) { 6950 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg, 6951 "enable-auth: Not supported in target mode. " 6952 "Disabling."); | |
6953 | 7705 |
6954 new_value = 0; 6955 } 6956 break; 6957#endif /* DHCHAP_SUPPORT */ 6958 | |
6959 case CFG_NUM_NODES: 6960 switch (new_value) { 6961 case 1: 6962 case 2: 6963 /* Must have at least 3 if not 0 */ 6964 return (3); 6965 6966 default: --- 9 unchanged lines hidden (view full) --- 6976 6977 /* The 0x4 bit should not be set if 0x1 or 0x2 is not set */ 6978 if (!(new_value & 0x3) && (new_value & 0x4)) { 6979 new_value &= ~0x4; 6980 } 6981 break; 6982 6983 case CFG_LINK_SPEED: | 7706 case CFG_NUM_NODES: 7707 switch (new_value) { 7708 case 1: 7709 case 2: 7710 /* Must have at least 3 if not 0 */ 7711 return (3); 7712 7713 default: --- 9 unchanged lines hidden (view full) --- 7723 7724 /* The 0x4 bit should not be set if 0x1 or 0x2 is not set */ 7725 if (!(new_value & 0x3) && (new_value & 0x4)) { 7726 new_value &= ~0x4; 7727 } 7728 break; 7729 7730 case CFG_LINK_SPEED: |
7731 if ((new_value > 8) && 7732 (hba->config[CFG_TOPOLOGY].current == 4)) { 7733 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg, 7734 "link-speed: %dGb not supported in loop topology. " 7735 "Switching to auto detect.", 7736 new_value); 7737 7738 new_value = 0; 7739 break; 7740 } 7741 |
|
6984 if (vpd->link_speed) { 6985 switch (new_value) { 6986 case 0: 6987 break; 6988 6989 case 1: 6990 if (!(vpd->link_speed & LMT_1GB_CAPABLE)) { 6991 new_value = 0; --- 12 unchanged lines hidden (view full) --- 7004 7005 EMLXS_MSGF(EMLXS_CONTEXT, 7006 &emlxs_init_msg, 7007 "link-speed: 2Gb not supported " 7008 "by adapter. Switching to auto " 7009 "detect."); 7010 } 7011 break; | 7742 if (vpd->link_speed) { 7743 switch (new_value) { 7744 case 0: 7745 break; 7746 7747 case 1: 7748 if (!(vpd->link_speed & LMT_1GB_CAPABLE)) { 7749 new_value = 0; --- 12 unchanged lines hidden (view full) --- 7762 7763 EMLXS_MSGF(EMLXS_CONTEXT, 7764 &emlxs_init_msg, 7765 "link-speed: 2Gb not supported " 7766 "by adapter. Switching to auto " 7767 "detect."); 7768 } 7769 break; |
7770 |
|
7012 case 4: 7013 if (!(vpd->link_speed & LMT_4GB_CAPABLE)) { 7014 new_value = 0; 7015 7016 EMLXS_MSGF(EMLXS_CONTEXT, 7017 &emlxs_init_msg, 7018 "link-speed: 4Gb not supported " 7019 "by adapter. Switching to auto " --- 8 unchanged lines hidden (view full) --- 7028 EMLXS_MSGF(EMLXS_CONTEXT, 7029 &emlxs_init_msg, 7030 "link-speed: 8Gb not supported " 7031 "by adapter. Switching to auto " 7032 "detect."); 7033 } 7034 break; 7035 | 7771 case 4: 7772 if (!(vpd->link_speed & LMT_4GB_CAPABLE)) { 7773 new_value = 0; 7774 7775 EMLXS_MSGF(EMLXS_CONTEXT, 7776 &emlxs_init_msg, 7777 "link-speed: 4Gb not supported " 7778 "by adapter. Switching to auto " --- 8 unchanged lines hidden (view full) --- 7787 EMLXS_MSGF(EMLXS_CONTEXT, 7788 &emlxs_init_msg, 7789 "link-speed: 8Gb not supported " 7790 "by adapter. Switching to auto " 7791 "detect."); 7792 } 7793 break; 7794 |
7036 case 10: 7037 if (!(vpd->link_speed & LMT_10GB_CAPABLE)) { | 7795 case 16: 7796 if (!(vpd->link_speed & LMT_16GB_CAPABLE)) { |
7038 new_value = 0; 7039 7040 EMLXS_MSGF(EMLXS_CONTEXT, 7041 &emlxs_init_msg, | 7797 new_value = 0; 7798 7799 EMLXS_MSGF(EMLXS_CONTEXT, 7800 &emlxs_init_msg, |
7042 "link-speed: 10Gb not supported " | 7801 "link-speed: 16Gb not supported " |
7043 "by adapter. Switching to auto " 7044 "detect."); 7045 } 7046 break; 7047 7048 default: 7049 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg, 7050 "link-speed: Invalid value=%d provided. " --- 6 unchanged lines hidden (view full) --- 7057 7058 /* Perform additional check on link speed */ 7059 switch (new_value) { 7060 case 0: 7061 case 1: 7062 case 2: 7063 case 4: 7064 case 8: | 7802 "by adapter. Switching to auto " 7803 "detect."); 7804 } 7805 break; 7806 7807 default: 7808 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg, 7809 "link-speed: Invalid value=%d provided. " --- 6 unchanged lines hidden (view full) --- 7816 7817 /* Perform additional check on link speed */ 7818 switch (new_value) { 7819 case 0: 7820 case 1: 7821 case 2: 7822 case 4: 7823 case 8: |
7065 case 10: | 7824 case 16: |
7066 /* link-speed is a valid choice */ 7067 break; 7068 7069 default: | 7825 /* link-speed is a valid choice */ 7826 break; 7827 7828 default: |
7070 new_value = cfg->def; | 7829 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg, 7830 "link-speed: Invalid value=%d provided. " 7831 "Switching to auto detect.", 7832 new_value); 7833 7834 new_value = 0; |
7071 } 7072 } 7073 break; 7074 7075 case CFG_TOPOLOGY: | 7835 } 7836 } 7837 break; 7838 7839 case CFG_TOPOLOGY: |
7840 if ((new_value == 4) && 7841 (hba->config[CFG_LINK_SPEED].current > 8)) { 7842 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg, 7843 "topology: Loop topology not supported " 7844 "with link speeds greater than 8Gb. " 7845 "Switching to auto detect."); 7846 7847 new_value = 0; 7848 break; 7849 } 7850 |
|
7076 /* Perform additional check on topology */ 7077 switch (new_value) { 7078 case 0: 7079 case 2: 7080 case 4: 7081 case 6: 7082 /* topology is a valid choice */ 7083 break; 7084 7085 default: | 7851 /* Perform additional check on topology */ 7852 switch (new_value) { 7853 case 0: 7854 case 2: 7855 case 4: 7856 case 6: 7857 /* topology is a valid choice */ 7858 break; 7859 7860 default: |
7086 return (cfg->def); | 7861 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg, 7862 "topology: Invalid value=%d provided. " 7863 "Switching to auto detect.", 7864 new_value); 7865 7866 new_value = 0; 7867 break; |
7087 } 7088 break; 7089 7090#ifdef DHCHAP_SUPPORT 7091 case CFG_AUTH_TYPE: 7092 { 7093 uint32_t shift; 7094 uint32_t mask; --- 71 unchanged lines hidden (view full) --- 7166emlxs_set_parm(emlxs_hba_t *hba, uint32_t index, uint32_t new_value) 7167{ 7168 emlxs_port_t *port = &PPORT; 7169 emlxs_port_t *vport; 7170 uint32_t vpi; 7171 emlxs_config_t *cfg; 7172 uint32_t old_value; 7173 | 7868 } 7869 break; 7870 7871#ifdef DHCHAP_SUPPORT 7872 case CFG_AUTH_TYPE: 7873 { 7874 uint32_t shift; 7875 uint32_t mask; --- 71 unchanged lines hidden (view full) --- 7947emlxs_set_parm(emlxs_hba_t *hba, uint32_t index, uint32_t new_value) 7948{ 7949 emlxs_port_t *port = &PPORT; 7950 emlxs_port_t *vport; 7951 uint32_t vpi; 7952 emlxs_config_t *cfg; 7953 uint32_t old_value; 7954 |
7174 if (index > NUM_CFG_PARAM) { | 7955 if (index >= NUM_CFG_PARAM) { |
7175 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 7956 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
7176 "emlxs_set_parm failed. Invalid index = %d", index); | 7957 "set_parm failed. Invalid index = %d", index); |
7177 7178 return ((uint32_t)FC_FAILURE); 7179 } 7180 7181 cfg = &hba->config[index]; 7182 7183 if (!(cfg->flags & PARM_DYNAMIC)) { 7184 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 7958 7959 return ((uint32_t)FC_FAILURE); 7960 } 7961 7962 cfg = &hba->config[index]; 7963 7964 if (!(cfg->flags & PARM_DYNAMIC)) { 7965 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
7185 "emlxs_set_parm failed. %s is not dynamic.", cfg->string); | 7966 "set_parm failed. %s is not dynamic.", cfg->string); |
7186 7187 return ((uint32_t)FC_FAILURE); 7188 } 7189 7190 /* Check new value */ 7191 old_value = new_value; 7192 new_value = emlxs_check_parm(hba, index, new_value); 7193 7194 if (old_value != new_value) { 7195 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 7967 7968 return ((uint32_t)FC_FAILURE); 7969 } 7970 7971 /* Check new value */ 7972 old_value = new_value; 7973 new_value = emlxs_check_parm(hba, index, new_value); 7974 7975 if (old_value != new_value) { 7976 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
7196 "emlxs_set_parm: %s invalid. 0x%x --> 0x%x", | 7977 "set_parm: %s invalid. 0x%x --> 0x%x", |
7197 cfg->string, old_value, new_value); 7198 } 7199 7200 /* Return now if no actual change */ 7201 if (new_value == cfg->current) { 7202 return (FC_SUCCESS); 7203 } 7204 7205 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, | 7978 cfg->string, old_value, new_value); 7979 } 7980 7981 /* Return now if no actual change */ 7982 if (new_value == cfg->current) { 7983 return (FC_SUCCESS); 7984 } 7985 7986 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sfs_debug_msg, |
7206 "emlxs_set_parm: %s changing. 0x%x --> 0x%x", | 7987 "set_parm: %s changing. 0x%x --> 0x%x", |
7207 cfg->string, cfg->current, new_value); 7208 7209 old_value = cfg->current; 7210 cfg->current = new_value; 7211 7212 /* React to change if needed */ 7213 switch (index) { 7214 7215 case CFG_PCI_MAX_READ: 7216 /* Update MXR */ 7217 emlxs_pcix_mxr_update(hba, 1); 7218 break; 7219 | 7988 cfg->string, cfg->current, new_value); 7989 7990 old_value = cfg->current; 7991 cfg->current = new_value; 7992 7993 /* React to change if needed */ 7994 switch (index) { 7995 7996 case CFG_PCI_MAX_READ: 7997 /* Update MXR */ 7998 emlxs_pcix_mxr_update(hba, 1); 7999 break; 8000 |
8001#ifdef SFCT_SUPPORT 8002 case CFG_TARGET_MODE: 8003 (void) emlxs_reset(port, FC_FCA_LINK_RESET); 8004 break; 8005#endif /* SFCT_SUPPORT */ 8006 |
|
7220 case CFG_SLI_MODE: 7221 /* Check SLI mode */ 7222 if ((hba->sli_mode == 3) && (new_value == 2)) { 7223 /* All vports must be disabled first */ 7224 for (vpi = 1; vpi < MAX_VPORTS; vpi++) { 7225 vport = &VPORT(vpi); 7226 | 8007 case CFG_SLI_MODE: 8008 /* Check SLI mode */ 8009 if ((hba->sli_mode == 3) && (new_value == 2)) { 8010 /* All vports must be disabled first */ 8011 for (vpi = 1; vpi < MAX_VPORTS; vpi++) { 8012 vport = &VPORT(vpi); 8013 |
7227 if (vport->flag & EMLXS_PORT_ENABLE) { | 8014 if (vport->flag & EMLXS_PORT_ENABLED) { |
7228 /* Reset current value */ 7229 cfg->current = old_value; 7230 7231 EMLXS_MSGF(EMLXS_CONTEXT, 7232 &emlxs_sfs_debug_msg, | 8015 /* Reset current value */ 8016 cfg->current = old_value; 8017 8018 EMLXS_MSGF(EMLXS_CONTEXT, 8019 &emlxs_sfs_debug_msg, |
7233 "emlxs_set_parm failed. %s: vpi=%d " | 8020 "set_parm failed. %s: vpi=%d " |
7234 "still enabled. Value restored to " 7235 "0x%x.", cfg->string, vpi, 7236 old_value); 7237 7238 return (2); 7239 } 7240 } 7241 } | 8021 "still enabled. Value restored to " 8022 "0x%x.", cfg->string, vpi, 8023 old_value); 8024 8025 return (2); 8026 } 8027 } 8028 } |
8029 8030 if ((hba->sli_mode >= 4) && (new_value < 4)) { 8031 /* 8032 * Not allow to set to SLI 2 or 3 if HBA supports SLI4 8033 */ 8034 cfg->current = old_value; 8035 return ((uint32_t)FC_FAILURE); 8036 } 8037 |
|
7242 break; 7243 7244 case CFG_NPIV_ENABLE: 7245 /* Check if NPIV is being disabled */ 7246 if ((old_value == 1) && (new_value == 0)) { 7247 /* All vports must be disabled first */ 7248 for (vpi = 1; vpi < MAX_VPORTS; vpi++) { 7249 vport = &VPORT(vpi); 7250 | 8038 break; 8039 8040 case CFG_NPIV_ENABLE: 8041 /* Check if NPIV is being disabled */ 8042 if ((old_value == 1) && (new_value == 0)) { 8043 /* All vports must be disabled first */ 8044 for (vpi = 1; vpi < MAX_VPORTS; vpi++) { 8045 vport = &VPORT(vpi); 8046 |
7251 if (vport->flag & EMLXS_PORT_ENABLE) { | 8047 if (vport->flag & EMLXS_PORT_ENABLED) { |
7252 /* Reset current value */ 7253 cfg->current = old_value; 7254 7255 EMLXS_MSGF(EMLXS_CONTEXT, 7256 &emlxs_sfs_debug_msg, | 8048 /* Reset current value */ 8049 cfg->current = old_value; 8050 8051 EMLXS_MSGF(EMLXS_CONTEXT, 8052 &emlxs_sfs_debug_msg, |
7257 "emlxs_set_parm failed. %s: vpi=%d " | 8053 "set_parm failed. %s: vpi=%d " |
7258 "still enabled. Value restored to " 7259 "0x%x.", cfg->string, vpi, 7260 old_value); 7261 7262 return (2); 7263 } 7264 } 7265 } --- 161 unchanged lines hidden (view full) --- 7427 dma_flag = (DDI_DMA_RDWR | DDI_DMA_CONSISTENT); 7428 break; 7429 case DMA_READ_ONLY: 7430 dma_flag = (DDI_DMA_READ | DDI_DMA_CONSISTENT); 7431 break; 7432 case DMA_WRITE_ONLY: 7433 dma_flag = (DDI_DMA_WRITE | DDI_DMA_CONSISTENT); 7434 break; | 8054 "still enabled. Value restored to " 8055 "0x%x.", cfg->string, vpi, 8056 old_value); 8057 8058 return (2); 8059 } 8060 } 8061 } --- 161 unchanged lines hidden (view full) --- 8223 dma_flag = (DDI_DMA_RDWR | DDI_DMA_CONSISTENT); 8224 break; 8225 case DMA_READ_ONLY: 8226 dma_flag = (DDI_DMA_READ | DDI_DMA_CONSISTENT); 8227 break; 8228 case DMA_WRITE_ONLY: 8229 dma_flag = (DDI_DMA_WRITE | DDI_DMA_CONSISTENT); 8230 break; |
8231 default: 8232 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_mem_alloc_failed_msg, 8233 "Invalid DMA flag"); 8234 (void) ddi_dma_free_handle( 8235 (ddi_dma_handle_t *)&buf_info->dma_handle); 8236 buf_info->phys = 0; 8237 buf_info->dma_handle = 0; 8238 return ((uint8_t *)buf_info->virt); |
|
7435 } 7436 7437 /* Map this page of memory */ 7438 status = ddi_dma_addr_bind_handle( 7439 (ddi_dma_handle_t)buf_info->dma_handle, NULL, 7440 (caddr_t)buf_info->virt, (size_t)buf_info->size, 7441 dma_flag, DDI_DMA_DONTWAIT, NULL, &dma_cookie, 7442 &cookie_count); --- 222 unchanged lines hidden (view full) --- 7665 7666 7667 /* If channel is closed, then try fcp channel */ 7668 if (ndlp->nlp_flag[channel] & NLP_CLOSED) { 7669 channel = hba->channel_fcp; 7670 } 7671 return (channel); 7672 | 8239 } 8240 8241 /* Map this page of memory */ 8242 status = ddi_dma_addr_bind_handle( 8243 (ddi_dma_handle_t)buf_info->dma_handle, NULL, 8244 (caddr_t)buf_info->virt, (size_t)buf_info->size, 8245 dma_flag, DDI_DMA_DONTWAIT, NULL, &dma_cookie, 8246 &cookie_count); --- 222 unchanged lines hidden (view full) --- 8469 8470 8471 /* If channel is closed, then try fcp channel */ 8472 if (ndlp->nlp_flag[channel] & NLP_CLOSED) { 8473 channel = hba->channel_fcp; 8474 } 8475 return (channel); 8476 |
7673} | 8477} /* emlxs_select_fcp_channel() */ |
7674 | 8478 |
8479 |
|
7675static int32_t 7676emlxs_fast_target_reset(emlxs_port_t *port, emlxs_buf_t *sbp, NODELIST *ndlp) 7677{ 7678 emlxs_hba_t *hba = HBA; 7679 fc_packet_t *pkt; 7680 emlxs_config_t *cfg; 7681 MAILBOXQ *mbq; 7682 MAILBOX *mb; --- 12 unchanged lines hidden (view full) --- 7695 * compatable. Things like reservations will not be broken. 7696 * By default this option is DISABLED, and its only enabled thru 7697 * a hidden configuration parameter (fast-tgt-reset). 7698 */ 7699 rc = FC_TRAN_BUSY; 7700 pkt = PRIV2PKT(sbp); 7701 cfg = &CFG; 7702 | 8480static int32_t 8481emlxs_fast_target_reset(emlxs_port_t *port, emlxs_buf_t *sbp, NODELIST *ndlp) 8482{ 8483 emlxs_hba_t *hba = HBA; 8484 fc_packet_t *pkt; 8485 emlxs_config_t *cfg; 8486 MAILBOXQ *mbq; 8487 MAILBOX *mb; --- 12 unchanged lines hidden (view full) --- 8500 * compatable. Things like reservations will not be broken. 8501 * By default this option is DISABLED, and its only enabled thru 8502 * a hidden configuration parameter (fast-tgt-reset). 8503 */ 8504 rc = FC_TRAN_BUSY; 8505 pkt = PRIV2PKT(sbp); 8506 cfg = &CFG; 8507 |
7703 if ((mbq = (MAILBOXQ *)emlxs_mem_get(hba, MEM_MBOX, 1))) { | 8508 if ((mbq = (MAILBOXQ *)emlxs_mem_get(hba, MEM_MBOX))) { |
7704 /* issue the mbox cmd to the sli */ 7705 mb = (MAILBOX *) mbq->mbox; 7706 bzero((void *) mb, MAILBOX_CMD_BSIZE); 7707 mb->un.varUnregLogin.rpi = (uint16_t)ndlp->nlp_Rpi; 7708#ifdef SLI3_SUPPORT 7709 mb->un.varUnregLogin.vpi = port->vpi; 7710#endif /* SLI3_SUPPORT */ 7711 mb->mbxCommand = MBX_UNREG_LOGIN; 7712 mb->mbxOwner = OWN_HOST; 7713 7714 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg, | 8509 /* issue the mbox cmd to the sli */ 8510 mb = (MAILBOX *) mbq->mbox; 8511 bzero((void *) mb, MAILBOX_CMD_BSIZE); 8512 mb->un.varUnregLogin.rpi = (uint16_t)ndlp->nlp_Rpi; 8513#ifdef SLI3_SUPPORT 8514 mb->un.varUnregLogin.vpi = port->vpi; 8515#endif /* SLI3_SUPPORT */ 8516 mb->mbxCommand = MBX_UNREG_LOGIN; 8517 mb->mbxOwner = OWN_HOST; 8518 8519 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg, |
7715 "Fast Target Reset: unreg rpi=x%x tmr %d", ndlp->nlp_Rpi, | 8520 "Fast Target Reset: unreg rpi=%d tmr=%d", ndlp->nlp_Rpi, |
7716 cfg[CFG_FAST_TGT_RESET_TMR].current); 7717 7718 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) 7719 == MBX_SUCCESS) { 7720 7721 ndlp->nlp_Rpi = 0; 7722 7723 mutex_enter(&sbp->mtx); --- 12 unchanged lines hidden (view full) --- 7736 7737 emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 0); 7738 } 7739 7740 emlxs_mem_put(hba, MEM_MBOX, (void *)mbq); 7741 rc = FC_SUCCESS; 7742 } 7743 return (rc); | 8521 cfg[CFG_FAST_TGT_RESET_TMR].current); 8522 8523 if (EMLXS_SLI_ISSUE_MBOX_CMD(hba, mbq, MBX_WAIT, 0) 8524 == MBX_SUCCESS) { 8525 8526 ndlp->nlp_Rpi = 0; 8527 8528 mutex_enter(&sbp->mtx); --- 12 unchanged lines hidden (view full) --- 8541 8542 emlxs_pkt_complete(sbp, IOSTAT_SUCCESS, 0, 0); 8543 } 8544 8545 emlxs_mem_put(hba, MEM_MBOX, (void *)mbq); 8546 rc = FC_SUCCESS; 8547 } 8548 return (rc); |
7744} | 8549} /* emlxs_fast_target_reset() */ |
7745 7746static int32_t 7747emlxs_send_fcp_cmd(emlxs_port_t *port, emlxs_buf_t *sbp, uint32_t *pkt_flags) 7748{ 7749 emlxs_hba_t *hba = HBA; 7750 fc_packet_t *pkt; 7751 emlxs_config_t *cfg; 7752 IOCBQ *iocbq; --- 7 unchanged lines hidden (view full) --- 7760 uint32_t reset = 0; 7761 int channel; 7762 int32_t rval; 7763 7764 pkt = PRIV2PKT(sbp); 7765 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id); 7766 7767 /* Find target node object */ | 8550 8551static int32_t 8552emlxs_send_fcp_cmd(emlxs_port_t *port, emlxs_buf_t *sbp, uint32_t *pkt_flags) 8553{ 8554 emlxs_hba_t *hba = HBA; 8555 fc_packet_t *pkt; 8556 emlxs_config_t *cfg; 8557 IOCBQ *iocbq; --- 7 unchanged lines hidden (view full) --- 8565 uint32_t reset = 0; 8566 int channel; 8567 int32_t rval; 8568 8569 pkt = PRIV2PKT(sbp); 8570 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id); 8571 8572 /* Find target node object */ |
7768 ndlp = emlxs_node_find_did(port, did); | 8573 ndlp = emlxs_node_find_did(port, did, 1); |
7769 7770 if (!ndlp || !ndlp->nlp_active) { 7771 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg, 7772 "Node not found. did=%x", did); 7773 7774 return (FC_BADPACKET); 7775 } 7776 --- 246 unchanged lines hidden (view full) --- 8023} /* emlxs_msiid_to_chan */ 8024 8025 8026#ifdef SFCT_SUPPORT 8027static int32_t 8028emlxs_send_fct_status(emlxs_port_t *port, emlxs_buf_t *sbp) 8029{ 8030 emlxs_hba_t *hba = HBA; | 8574 8575 if (!ndlp || !ndlp->nlp_active) { 8576 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg, 8577 "Node not found. did=%x", did); 8578 8579 return (FC_BADPACKET); 8580 } 8581 --- 246 unchanged lines hidden (view full) --- 8828} /* emlxs_msiid_to_chan */ 8829 8830 8831#ifdef SFCT_SUPPORT 8832static int32_t 8833emlxs_send_fct_status(emlxs_port_t *port, emlxs_buf_t *sbp) 8834{ 8835 emlxs_hba_t *hba = HBA; |
8031 fc_packet_t *pkt; | |
8032 IOCBQ *iocbq; 8033 IOCB *iocb; 8034 NODELIST *ndlp; 8035 CHANNEL *cp; | 8836 IOCBQ *iocbq; 8837 IOCB *iocb; 8838 NODELIST *ndlp; 8839 CHANNEL *cp; |
8036 uint16_t iotag; | |
8037 uint32_t did; | 8840 uint32_t did; |
8038 ddi_dma_cookie_t *cp_cmd; | |
8039 | 8841 |
8040 pkt = PRIV2PKT(sbp); 8041 | |
8042 did = sbp->did; 8043 ndlp = sbp->node; | 8842 did = sbp->did; 8843 ndlp = sbp->node; |
8844 cp = (CHANNEL *)sbp->channel; |
|
8044 8045 iocbq = &sbp->iocbq; 8046 iocb = &iocbq->iocb; 8047 8048 /* Make sure node is still active */ 8049 if (!ndlp->nlp_active) { 8050 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg, 8051 "*Node not found. did=%x", did); 8052 8053 return (FC_BADPACKET); 8054 } 8055 8056 /* If gate is closed */ 8057 if (ndlp->nlp_flag[hba->channel_fcp] & NLP_CLOSED) { 8058 return (FC_TRAN_BUSY); 8059 } 8060 | 8845 8846 iocbq = &sbp->iocbq; 8847 iocb = &iocbq->iocb; 8848 8849 /* Make sure node is still active */ 8850 if (!ndlp->nlp_active) { 8851 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg, 8852 "*Node not found. did=%x", did); 8853 8854 return (FC_BADPACKET); 8855 } 8856 8857 /* If gate is closed */ 8858 if (ndlp->nlp_flag[hba->channel_fcp] & NLP_CLOSED) { 8859 return (FC_TRAN_BUSY); 8860 } 8861 |
8061 /* Get the iotag by registering the packet */ 8062 iotag = emlxs_register_pkt(sbp->channel, sbp); 8063 8064 if (!iotag) { 8065 /* No more command slots available, retry later */ 8066 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg, 8067 "*Adapter Busy. Unable to allocate iotag: did=0x%x", did); 8068 | 8862 iocb->ULPCOMMAND = CMD_FCP_TRSP64_CX; 8863 if (EMLXS_SLI_PREP_FCT_IOCB(port, sbp, cp->channelno) != 8864 IOERR_SUCCESS) { |
8069 return (FC_TRAN_BUSY); 8070 } 8071 | 8865 return (FC_TRAN_BUSY); 8866 } 8867 |
8072 /* Point of no return */ 8073 8074 cp = sbp->channel; 8075 cp->ulpSendCmd++; 8076 8077#if (EMLXS_MODREV >= EMLXS_MODREV3) 8078 cp_cmd = pkt->pkt_cmd_cookie; 8079#else 8080 cp_cmd = &pkt->pkt_cmd_cookie; 8081#endif /* >= EMLXS_MODREV3 */ 8082 8083 iocb->un.fcpt64.bdl.addrHigh = PADDR_HI(cp_cmd->dmac_laddress); 8084 iocb->un.fcpt64.bdl.addrLow = PADDR_LO(cp_cmd->dmac_laddress); 8085 iocb->un.fcpt64.bdl.bdeSize = pkt->pkt_cmdlen; 8086 iocb->un.fcpt64.bdl.bdeFlags = 0; 8087 8088 if (hba->sli_mode < 3) { 8089 iocb->ULPBDECOUNT = 1; 8090 iocb->ULPLE = 1; 8091 } else { /* SLI3 */ 8092 8093 iocb->ULPBDECOUNT = 0; 8094 iocb->ULPLE = 0; 8095 iocb->unsli3.ext_iocb.ebde_count = 0; 8096 } 8097 8098 /* Initalize iocbq */ 8099 iocbq->port = (void *)port; 8100 iocbq->node = (void *)ndlp; 8101 iocbq->channel = (void *)cp; 8102 8103 /* Initalize iocb */ 8104 iocb->ULPCONTEXT = (uint16_t)pkt->pkt_cmd_fhdr.rx_id; 8105 iocb->ULPIOTAG = iotag; 8106 iocb->ULPRSVDBYTE = 8107 ((pkt->pkt_timeout > 0xff) ? 0 : pkt->pkt_timeout); 8108 iocb->ULPOWNER = OWN_CHIP; 8109 iocb->ULPCLASS = sbp->class; 8110 iocb->ULPCOMMAND = CMD_FCP_TRSP64_CX; 8111 8112 /* Set the pkt timer */ 8113 sbp->ticks = hba->timer_tics + pkt->pkt_timeout + 8114 ((pkt->pkt_timeout > 0xff) ? 0 : 10); 8115 8116 if (pkt->pkt_cmdlen) { 8117 EMLXS_MPDATA_SYNC(pkt->pkt_cmd_dma, 0, pkt->pkt_cmdlen, 8118 DDI_DMA_SYNC_FORDEV); 8119 } 8120 | |
8121 HBASTATS.FcpIssued++; 8122 8123 EMLXS_SLI_ISSUE_IOCB_CMD(hba, cp, iocbq); 8124 8125 return (FC_SUCCESS); 8126 8127} /* emlxs_send_fct_status() */ 8128 8129 8130static int32_t 8131emlxs_send_fct_abort(emlxs_port_t *port, emlxs_buf_t *sbp) 8132{ 8133 emlxs_hba_t *hba = HBA; | 8868 HBASTATS.FcpIssued++; 8869 8870 EMLXS_SLI_ISSUE_IOCB_CMD(hba, cp, iocbq); 8871 8872 return (FC_SUCCESS); 8873 8874} /* emlxs_send_fct_status() */ 8875 8876 8877static int32_t 8878emlxs_send_fct_abort(emlxs_port_t *port, emlxs_buf_t *sbp) 8879{ 8880 emlxs_hba_t *hba = HBA; |
8134 fc_packet_t *pkt; | |
8135 IOCBQ *iocbq; 8136 IOCB *iocb; 8137 NODELIST *ndlp; | 8881 IOCBQ *iocbq; 8882 IOCB *iocb; 8883 NODELIST *ndlp; |
8138 uint16_t iotag; | 8884 CHANNEL *cp; |
8139 uint32_t did; 8140 | 8885 uint32_t did; 8886 |
8141 pkt = PRIV2PKT(sbp); 8142 | |
8143 did = sbp->did; 8144 ndlp = sbp->node; | 8887 did = sbp->did; 8888 ndlp = sbp->node; |
8889 cp = (CHANNEL *)sbp->channel; |
|
8145 | 8890 |
8146 | |
8147 iocbq = &sbp->iocbq; 8148 iocb = &iocbq->iocb; 8149 8150 /* Make sure node is still active */ 8151 if ((ndlp == NULL) || (!ndlp->nlp_active)) { 8152 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg, 8153 "*Node not found. did=%x", did); 8154 8155 return (FC_BADPACKET); 8156 } 8157 8158 /* If gate is closed */ 8159 if (ndlp->nlp_flag[hba->channel_fcp] & NLP_CLOSED) { 8160 return (FC_TRAN_BUSY); 8161 } 8162 | 8891 iocbq = &sbp->iocbq; 8892 iocb = &iocbq->iocb; 8893 8894 /* Make sure node is still active */ 8895 if ((ndlp == NULL) || (!ndlp->nlp_active)) { 8896 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg, 8897 "*Node not found. did=%x", did); 8898 8899 return (FC_BADPACKET); 8900 } 8901 8902 /* If gate is closed */ 8903 if (ndlp->nlp_flag[hba->channel_fcp] & NLP_CLOSED) { 8904 return (FC_TRAN_BUSY); 8905 } 8906 |
8163 /* Get the iotag by registering the packet */ 8164 iotag = emlxs_register_pkt(sbp->channel, sbp); 8165 8166 if (!iotag) { 8167 /* No more command slots available, retry later */ 8168 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_msg, 8169 "*Adapter Busy. Unable to allocate iotag: did=0x%x", did); 8170 | 8907 iocb->ULPCOMMAND = CMD_ABORT_XRI_CX; 8908 if (EMLXS_SLI_PREP_FCT_IOCB(port, sbp, cp->channelno) != 8909 IOERR_SUCCESS) { |
8171 return (FC_TRAN_BUSY); 8172 } 8173 | 8910 return (FC_TRAN_BUSY); 8911 } 8912 |
8174 /* Point of no return */ 8175 iocbq->port = (void *)port; 8176 iocbq->node = (void *)ndlp; 8177 iocbq->channel = (void *)sbp->channel; 8178 ((CHANNEL *)sbp->channel)->ulpSendCmd++; 8179 8180 /* 8181 * Don't give the abort priority, we want the IOCB 8182 * we are aborting to be processed first. 8183 */ 8184 iocbq->flag |= IOCB_SPECIAL; 8185 8186 iocb->ULPCONTEXT = pkt->pkt_cmd_fhdr.rx_id; 8187 iocb->ULPIOTAG = iotag; 8188 iocb->ULPLE = 1; 8189 iocb->ULPCLASS = sbp->class; 8190 iocb->ULPOWNER = OWN_CHIP; 8191 8192 if (hba->state >= FC_LINK_UP) { 8193 /* Create the abort IOCB */ 8194 iocb->un.acxri.abortType = ABORT_TYPE_ABTS; 8195 iocb->ULPCOMMAND = CMD_ABORT_XRI_CX; 8196 8197 } else { 8198 /* Create the close IOCB */ 8199 iocb->ULPCOMMAND = CMD_CLOSE_XRI_CX; 8200 8201 } 8202 8203 iocb->ULPRSVDBYTE = 8204 ((pkt->pkt_timeout > 0xff) ? 0 : pkt->pkt_timeout); 8205 /* Set the pkt timer */ 8206 sbp->ticks = hba->timer_tics + pkt->pkt_timeout + 8207 ((pkt->pkt_timeout > 0xff) ? 0 : 10); 8208 | |
8209 EMLXS_SLI_ISSUE_IOCB_CMD(hba, sbp->channel, iocbq); 8210 8211 return (FC_SUCCESS); 8212 8213} /* emlxs_send_fct_abort() */ 8214 8215#endif /* SFCT_SUPPORT */ 8216 --- 12 unchanged lines hidden (view full) --- 8229 int32_t rval; 8230 8231 pkt = PRIV2PKT(sbp); 8232 cp = &hba->chan[hba->channel_ip]; 8233 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id); 8234 8235 /* Check if node exists */ 8236 /* Broadcast did is always a success */ | 8913 EMLXS_SLI_ISSUE_IOCB_CMD(hba, sbp->channel, iocbq); 8914 8915 return (FC_SUCCESS); 8916 8917} /* emlxs_send_fct_abort() */ 8918 8919#endif /* SFCT_SUPPORT */ 8920 --- 12 unchanged lines hidden (view full) --- 8933 int32_t rval; 8934 8935 pkt = PRIV2PKT(sbp); 8936 cp = &hba->chan[hba->channel_ip]; 8937 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id); 8938 8939 /* Check if node exists */ 8940 /* Broadcast did is always a success */ |
8237 ndlp = emlxs_node_find_did(port, did); | 8941 ndlp = emlxs_node_find_did(port, did, 1); |
8238 8239 if (!ndlp || !ndlp->nlp_active) { 8240 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg, 8241 "Node not found. did=0x%x", did); 8242 8243 return (FC_BADPACKET); 8244 } 8245 --- 68 unchanged lines hidden (view full) --- 8314static int32_t 8315emlxs_send_els(emlxs_port_t *port, emlxs_buf_t *sbp) 8316{ 8317 emlxs_hba_t *hba = HBA; 8318 emlxs_port_t *vport; 8319 fc_packet_t *pkt; 8320 IOCBQ *iocbq; 8321 CHANNEL *cp; | 8942 8943 if (!ndlp || !ndlp->nlp_active) { 8944 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg, 8945 "Node not found. did=0x%x", did); 8946 8947 return (FC_BADPACKET); 8948 } 8949 --- 68 unchanged lines hidden (view full) --- 9018static int32_t 9019emlxs_send_els(emlxs_port_t *port, emlxs_buf_t *sbp) 9020{ 9021 emlxs_hba_t *hba = HBA; 9022 emlxs_port_t *vport; 9023 fc_packet_t *pkt; 9024 IOCBQ *iocbq; 9025 CHANNEL *cp; |
9026 SERV_PARM *sp; |
|
8322 uint32_t cmd; 8323 int i; 8324 ELS_PKT *els_pkt; 8325 NODELIST *ndlp; 8326 uint32_t did; 8327 char fcsp_msg[32]; 8328 int rc; 8329 int32_t rval; --- 62 unchanged lines hidden (view full) --- 8392 /* We will process these cmds at the bottom of this routine */ 8393 break; 8394 8395 case ELS_CMD_PLOGI: 8396 /* Make sure we don't log into ourself */ 8397 for (i = 0; i < MAX_VPORTS; i++) { 8398 vport = &VPORT(i); 8399 | 9027 uint32_t cmd; 9028 int i; 9029 ELS_PKT *els_pkt; 9030 NODELIST *ndlp; 9031 uint32_t did; 9032 char fcsp_msg[32]; 9033 int rc; 9034 int32_t rval; --- 62 unchanged lines hidden (view full) --- 9097 /* We will process these cmds at the bottom of this routine */ 9098 break; 9099 9100 case ELS_CMD_PLOGI: 9101 /* Make sure we don't log into ourself */ 9102 for (i = 0; i < MAX_VPORTS; i++) { 9103 vport = &VPORT(i); 9104 |
8400 if (!(vport->flag & EMLXS_PORT_BOUND)) { | 9105 if (!(vport->flag & EMLXS_INI_BOUND)) { |
8401 continue; 8402 } 8403 8404 if (did == vport->did) { 8405 pkt->pkt_state = FC_PKT_NPORT_RJT; 8406 8407#if (EMLXS_MODREVX == EMLXS_MODREV2X) 8408 emlxs_unswap_pkt(sbp); 8409#endif /* EMLXS_MODREV2X */ 8410 8411 return (FC_FAILURE); 8412 } 8413 } 8414 8415 ndlp = NULL; 8416 | 9106 continue; 9107 } 9108 9109 if (did == vport->did) { 9110 pkt->pkt_state = FC_PKT_NPORT_RJT; 9111 9112#if (EMLXS_MODREVX == EMLXS_MODREV2X) 9113 emlxs_unswap_pkt(sbp); 9114#endif /* EMLXS_MODREV2X */ 9115 9116 return (FC_FAILURE); 9117 } 9118 } 9119 9120 ndlp = NULL; 9121 |
8417 /* Check if this is the first PLOGI */ 8418 /* after a PT_TO_PT connection */ 8419 if ((hba->flag & FC_PT_TO_PT) && (port->did == 0)) { | 9122 if (hba->flag & FC_PT_TO_PT) { |
8420 MAILBOXQ *mbox; 8421 8422 /* ULP bug fix */ 8423 if (pkt->pkt_cmd_fhdr.s_id == 0) { | 9123 MAILBOXQ *mbox; 9124 9125 /* ULP bug fix */ 9126 if (pkt->pkt_cmd_fhdr.s_id == 0) { |
8424 pkt->pkt_cmd_fhdr.s_id = 8425 pkt->pkt_cmd_fhdr.d_id - FP_DEFAULT_DID + 8426 FP_DEFAULT_SID; | 9127 pkt->pkt_cmd_fhdr.s_id = FP_DEFAULT_SID; |
8427 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_send_msg, 8428 "PLOGI: P2P Fix. sid=0-->%x did=%x", 8429 pkt->pkt_cmd_fhdr.s_id, 8430 pkt->pkt_cmd_fhdr.d_id); 8431 } 8432 8433 mutex_enter(&EMLXS_PORT_LOCK); 8434 port->did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.s_id); | 9128 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_send_msg, 9129 "PLOGI: P2P Fix. sid=0-->%x did=%x", 9130 pkt->pkt_cmd_fhdr.s_id, 9131 pkt->pkt_cmd_fhdr.d_id); 9132 } 9133 9134 mutex_enter(&EMLXS_PORT_LOCK); 9135 port->did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.s_id); |
9136 port->rdid = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id); |
|
8435 mutex_exit(&EMLXS_PORT_LOCK); 8436 | 9137 mutex_exit(&EMLXS_PORT_LOCK); 9138 |
8437 /* Update our service parms */ 8438 if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba, 8439 MEM_MBOX, 1))) { 8440 emlxs_mb_config_link(hba, mbox); | 9139 if (hba->sli_mode <= EMLXS_HBA_SLI3_MODE) { 9140 /* Update our service parms */ 9141 if ((mbox = (MAILBOXQ *)emlxs_mem_get(hba, 9142 MEM_MBOX))) { 9143 emlxs_mb_config_link(hba, mbox); |
8441 | 9144 |
8442 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, 8443 mbox, MBX_NOWAIT, 0); 8444 if ((rc != MBX_BUSY) && (rc != MBX_SUCCESS)) { 8445 emlxs_mem_put(hba, MEM_MBOX, 8446 (void *)mbox); | 9145 rc = EMLXS_SLI_ISSUE_MBOX_CMD(hba, 9146 mbox, MBX_NOWAIT, 0); 9147 if ((rc != MBX_BUSY) && 9148 (rc != MBX_SUCCESS)) { 9149 emlxs_mem_put(hba, MEM_MBOX, 9150 (void *)mbox); 9151 } |
8447 } | 9152 } |
8448 | |
8449 } 8450 } 8451 8452 /* We will process these cmds at the bottom of this routine */ 8453 break; 8454 8455 default: | 9153 } 9154 } 9155 9156 /* We will process these cmds at the bottom of this routine */ 9157 break; 9158 9159 default: |
8456 ndlp = emlxs_node_find_did(port, did); | 9160 ndlp = emlxs_node_find_did(port, did, 1); |
8457 8458 /* If an ADISC is being sent and we have no node, */ 8459 /* then we must fail the ADISC now */ | 9161 9162 /* If an ADISC is being sent and we have no node, */ 9163 /* then we must fail the ADISC now */ |
8460 if (!ndlp && (cmd == ELS_CMD_ADISC) && !port->tgt_mode) { | 9164 if (!ndlp && (cmd == ELS_CMD_ADISC) && 9165 (port->mode == MODE_INITIATOR)) { |
8461 8462 /* Build the LS_RJT response */ 8463 els_pkt = (ELS_PKT *)pkt->pkt_resp; 8464 els_pkt->elsCode = 0x01; 8465 els_pkt->un.lsRjt.un.b.lsRjtRsvd0 = 0; 8466 els_pkt->un.lsRjt.un.b.lsRjtRsnCode = 8467 LSRJT_LOGICAL_ERR; 8468 els_pkt->un.lsRjt.un.b.lsRjtRsnCodeExp = --- 33 unchanged lines hidden (view full) --- 8502 rval = FC_SUCCESS; 8503 } 8504 8505 return (rval); 8506 } 8507 8508 cp = &hba->chan[hba->channel_els]; 8509 cp->ulpSendCmd++; | 9166 9167 /* Build the LS_RJT response */ 9168 els_pkt = (ELS_PKT *)pkt->pkt_resp; 9169 els_pkt->elsCode = 0x01; 9170 els_pkt->un.lsRjt.un.b.lsRjtRsvd0 = 0; 9171 els_pkt->un.lsRjt.un.b.lsRjtRsnCode = 9172 LSRJT_LOGICAL_ERR; 9173 els_pkt->un.lsRjt.un.b.lsRjtRsnCodeExp = --- 33 unchanged lines hidden (view full) --- 9207 rval = FC_SUCCESS; 9208 } 9209 9210 return (rval); 9211 } 9212 9213 cp = &hba->chan[hba->channel_els]; 9214 cp->ulpSendCmd++; |
9215 sp = (SERV_PARM *)&els_pkt->un.logi; |
|
8510 8511 /* Check cmd */ 8512 switch (cmd) { 8513 case ELS_CMD_PRLI: 8514 /* 8515 * if our firmware version is 3.20 or later, 8516 * set the following bits for FC-TAPE support. 8517 */ | 9216 9217 /* Check cmd */ 9218 switch (cmd) { 9219 case ELS_CMD_PRLI: 9220 /* 9221 * if our firmware version is 3.20 or later, 9222 * set the following bits for FC-TAPE support. 9223 */ |
8518 if (port->ini_mode && | 9224 if ((port->mode == MODE_INITIATOR) && |
8519 (hba->vpd.feaLevelHigh >= 0x02) && 8520 (cfg[CFG_ADISC_SUPPORT].current != 0)) { 8521 els_pkt->un.prli.ConfmComplAllowed = 1; 8522 els_pkt->un.prli.Retry = 1; 8523 els_pkt->un.prli.TaskRetryIdReq = 1; 8524 } else { 8525 els_pkt->un.prli.ConfmComplAllowed = 0; 8526 els_pkt->un.prli.Retry = 0; --- 8 unchanged lines hidden (view full) --- 8535 * ULP only reads our service parameters once during bind_port, 8536 * but the service parameters change due to topology. 8537 */ 8538 case ELS_CMD_FLOGI: 8539 case ELS_CMD_FDISC: 8540 case ELS_CMD_PLOGI: 8541 case ELS_CMD_PDISC: 8542 /* Copy latest service parameters to payload */ | 9225 (hba->vpd.feaLevelHigh >= 0x02) && 9226 (cfg[CFG_ADISC_SUPPORT].current != 0)) { 9227 els_pkt->un.prli.ConfmComplAllowed = 1; 9228 els_pkt->un.prli.Retry = 1; 9229 els_pkt->un.prli.TaskRetryIdReq = 1; 9230 } else { 9231 els_pkt->un.prli.ConfmComplAllowed = 0; 9232 els_pkt->un.prli.Retry = 0; --- 8 unchanged lines hidden (view full) --- 9241 * ULP only reads our service parameters once during bind_port, 9242 * but the service parameters change due to topology. 9243 */ 9244 case ELS_CMD_FLOGI: 9245 case ELS_CMD_FDISC: 9246 case ELS_CMD_PLOGI: 9247 case ELS_CMD_PDISC: 9248 /* Copy latest service parameters to payload */ |
8543 bcopy((void *) &port->sparam, 8544 (void *)&els_pkt->un.logi, sizeof (SERV_PARM)); | 9249 bcopy((void *) &port->sparam, (void *)sp, sizeof (SERV_PARM)); |
8545 | 9250 |
9251 if ((cmd == ELS_CMD_FLOGI) || (cmd == ELS_CMD_FDISC)) { 9252 9253 /* Clear support for virtual fabrics */ 9254 /* randomOffset bit controls this for FLOGI */ 9255 sp->cmn.randomOffset = 0; 9256 9257 /* Set R_A_TOV to current value */ 9258 sp->cmn.w2.r_a_tov = 9259 LE_SWAP32((hba->fc_ratov * 1000)); 9260 } 9261 |
|
8546 if ((hba->flag & FC_NPIV_ENABLED) && 8547 (hba->flag & FC_NPIV_SUPPORTED) && 8548 (cmd == ELS_CMD_PLOGI)) { | 9262 if ((hba->flag & FC_NPIV_ENABLED) && 9263 (hba->flag & FC_NPIV_SUPPORTED) && 9264 (cmd == ELS_CMD_PLOGI)) { |
8549 SERV_PARM *sp; 8550 emlxs_vvl_fmt_t *vvl; | 9265 emlxs_vvl_fmt_t *vvl; |
8551 | 9266 |
8552 sp = (SERV_PARM *)&els_pkt->un.logi; 8553 sp->VALID_VENDOR_VERSION = 1; 8554 vvl = (emlxs_vvl_fmt_t *)&sp->vendorVersion[0]; 8555 vvl->un0.w0.oui = 0x0000C9; 8556 vvl->un0.word0 = LE_SWAP32(vvl->un0.word0); 8557 vvl->un1.w1.vport = (port->vpi > 0) ? 1 : 0; 8558 vvl->un1.word1 = LE_SWAP32(vvl->un1.word1); 8559 } | 9267 sp->VALID_VENDOR_VERSION = 1; 9268 vvl = (emlxs_vvl_fmt_t *)&sp->vendorVersion[0]; 9269 vvl->un0.w0.oui = 0x0000C9; 9270 vvl->un0.word0 = LE_SWAP32(vvl->un0.word0); 9271 vvl->un1.w1.vport = (port->vpi > 0) ? 1 : 0; 9272 vvl->un1.word1 = LE_SWAP32(vvl->un1.word1); 9273 } |
8560 8561#ifdef DHCHAP_SUPPORT | 9274 9275#ifdef DHCHAP_SUPPORT |
8562 emlxs_dhc_init_sp(port, did, 8563 (SERV_PARM *)&els_pkt->un.logi, (char **)&fcsp_msg); | 9276 emlxs_dhc_init_sp(port, did, sp, (char **)&fcsp_msg); |
8564#endif /* DHCHAP_SUPPORT */ 8565 | 9277#endif /* DHCHAP_SUPPORT */ 9278 |
8566 break; | 9279 break; |
8567 } 8568 8569 /* Initialize the sbp */ 8570 mutex_enter(&sbp->mtx); 8571 sbp->ticks = hba->timer_tics + pkt->pkt_timeout + 8572 ((pkt->pkt_timeout > 0xff) ? 0 : 10); 8573 sbp->node = (void *)ndlp; 8574 sbp->lun = EMLXS_LUN_NONE; --- 7 unchanged lines hidden (view full) --- 8582 EMLXS_MPDATA_SYNC(pkt->pkt_cmd_dma, 0, pkt->pkt_cmdlen, 8583 DDI_DMA_SYNC_FORDEV); 8584 } 8585 8586 /* Check node */ 8587 switch (cmd) { 8588 case ELS_CMD_FLOGI: 8589 case ELS_CMD_FDISC: | 9280 } 9281 9282 /* Initialize the sbp */ 9283 mutex_enter(&sbp->mtx); 9284 sbp->ticks = hba->timer_tics + pkt->pkt_timeout + 9285 ((pkt->pkt_timeout > 0xff) ? 0 : 10); 9286 sbp->node = (void *)ndlp; 9287 sbp->lun = EMLXS_LUN_NONE; --- 7 unchanged lines hidden (view full) --- 9295 EMLXS_MPDATA_SYNC(pkt->pkt_cmd_dma, 0, pkt->pkt_cmdlen, 9296 DDI_DMA_SYNC_FORDEV); 9297 } 9298 9299 /* Check node */ 9300 switch (cmd) { 9301 case ELS_CMD_FLOGI: 9302 case ELS_CMD_FDISC: |
8590 if (port->ini_mode) { | 9303 if (port->mode == MODE_INITIATOR) { |
8591 /* Make sure fabric node is destroyed */ 8592 /* It should already have been destroyed at link down */ 8593 if (hba->sli_mode != EMLXS_HBA_SLI4_MODE) { | 9304 /* Make sure fabric node is destroyed */ 9305 /* It should already have been destroyed at link down */ 9306 if (hba->sli_mode != EMLXS_HBA_SLI4_MODE) { |
8594 ndlp = emlxs_node_find_did(port, FABRIC_DID); | 9307 ndlp = emlxs_node_find_did(port, FABRIC_DID, 1); |
8595 if (ndlp) { | 9308 if (ndlp) { |
8596 if (emlxs_mb_unreg_node(port, ndlp, | 9309 if (EMLXS_SLI_UNREG_NODE(port, ndlp, |
8597 NULL, NULL, iocbq) == 0) { 8598 /* Deferring iocb tx until */ 8599 /* completion of unreg */ 8600 return (FC_SUCCESS); 8601 } 8602 } 8603 } 8604 } 8605 break; 8606 8607 case ELS_CMD_PLOGI: 8608 | 9310 NULL, NULL, iocbq) == 0) { 9311 /* Deferring iocb tx until */ 9312 /* completion of unreg */ 9313 return (FC_SUCCESS); 9314 } 9315 } 9316 } 9317 } 9318 break; 9319 9320 case ELS_CMD_PLOGI: 9321 |
8609 ndlp = emlxs_node_find_did(port, did); | 9322 ndlp = emlxs_node_find_did(port, did, 1); |
8610 8611 if (ndlp && ndlp->nlp_active) { 8612 /* Close the node for any further normal IO */ 8613 emlxs_node_close(port, ndlp, hba->channel_fcp, 8614 pkt->pkt_timeout + 10); 8615 emlxs_node_close(port, ndlp, hba->channel_ip, 8616 pkt->pkt_timeout + 10); 8617 8618 /* Flush tx queues */ 8619 (void) emlxs_tx_node_flush(port, ndlp, 0, 0, 0); 8620 8621 /* Flush chip queues */ 8622 (void) emlxs_chipq_node_flush(port, 0, ndlp, 0); 8623 } 8624 8625 break; 8626 8627 case ELS_CMD_PRLI: 8628 | 9323 9324 if (ndlp && ndlp->nlp_active) { 9325 /* Close the node for any further normal IO */ 9326 emlxs_node_close(port, ndlp, hba->channel_fcp, 9327 pkt->pkt_timeout + 10); 9328 emlxs_node_close(port, ndlp, hba->channel_ip, 9329 pkt->pkt_timeout + 10); 9330 9331 /* Flush tx queues */ 9332 (void) emlxs_tx_node_flush(port, ndlp, 0, 0, 0); 9333 9334 /* Flush chip queues */ 9335 (void) emlxs_chipq_node_flush(port, 0, ndlp, 0); 9336 } 9337 9338 break; 9339 9340 case ELS_CMD_PRLI: 9341 |
8629 ndlp = emlxs_node_find_did(port, did); | 9342 ndlp = emlxs_node_find_did(port, did, 1); |
8630 8631 if (ndlp && ndlp->nlp_active) { 8632 /* 8633 * Close the node for any further FCP IO; 8634 * Flush all outstanding I/O only if 8635 * "Establish Image Pair" bit is set. 8636 */ 8637 emlxs_node_close(port, ndlp, hba->channel_fcp, --- 179 unchanged lines hidden (view full) --- 8817 cmd = *((uint32_t *)pkt->pkt_cmd); 8818 cmd = LE_SWAP32(cmd); 8819 cmd &= ELS_CMD_MASK; 8820 8821 /* 8822 * If ULP is accepting this, 8823 * then close affected node 8824 */ | 9343 9344 if (ndlp && ndlp->nlp_active) { 9345 /* 9346 * Close the node for any further FCP IO; 9347 * Flush all outstanding I/O only if 9348 * "Establish Image Pair" bit is set. 9349 */ 9350 emlxs_node_close(port, ndlp, hba->channel_fcp, --- 179 unchanged lines hidden (view full) --- 9530 cmd = *((uint32_t *)pkt->pkt_cmd); 9531 cmd = LE_SWAP32(cmd); 9532 cmd &= ELS_CMD_MASK; 9533 9534 /* 9535 * If ULP is accepting this, 9536 * then close affected node 9537 */ |
8825 if (port->ini_mode && ub_buffer && cmd 8826 == ELS_CMD_ACC) { | 9538 if ((port->mode == MODE_INITIATOR) && ub_buffer && 9539 cmd == ELS_CMD_ACC) { |
8827 fc_rscn_t *rscn; 8828 uint32_t count; 8829 uint32_t *lp; 8830 8831 /* 8832 * Only the Leadville code path will 8833 * come thru here. The RSCN data is NOT 8834 * swapped properly for the Comstar code --- 64 unchanged lines hidden (view full) --- 8899 8900 /* Check if modifications are needed */ 8901 switch (ucmd) { 8902 case (ELS_CMD_PRLI): 8903 8904 if (cmd == ELS_CMD_ACC) { 8905 /* This is a patch for the ULP stack. */ 8906 /* ULP does not keep track of FCP2 support */ | 9540 fc_rscn_t *rscn; 9541 uint32_t count; 9542 uint32_t *lp; 9543 9544 /* 9545 * Only the Leadville code path will 9546 * come thru here. The RSCN data is NOT 9547 * swapped properly for the Comstar code --- 64 unchanged lines hidden (view full) --- 9612 9613 /* Check if modifications are needed */ 9614 switch (ucmd) { 9615 case (ELS_CMD_PRLI): 9616 9617 if (cmd == ELS_CMD_ACC) { 9618 /* This is a patch for the ULP stack. */ 9619 /* ULP does not keep track of FCP2 support */ |
8907 if (port->ini_mode && | 9620 if ((port->mode == MODE_INITIATOR) && |
8908 (hba->vpd.feaLevelHigh >= 0x02) && 8909 (cfg[CFG_ADISC_SUPPORT].current != 0)) { 8910 els_pkt->un.prli.ConfmComplAllowed = 1; 8911 els_pkt->un.prli.Retry = 1; 8912 els_pkt->un.prli.TaskRetryIdReq = 1; 8913 } else { 8914 els_pkt->un.prli.ConfmComplAllowed = 0; 8915 els_pkt->un.prli.Retry = 0; 8916 els_pkt->un.prli.TaskRetryIdReq = 0; 8917 } 8918 } 8919 8920 break; 8921 8922 case ELS_CMD_FLOGI: | 9621 (hba->vpd.feaLevelHigh >= 0x02) && 9622 (cfg[CFG_ADISC_SUPPORT].current != 0)) { 9623 els_pkt->un.prli.ConfmComplAllowed = 1; 9624 els_pkt->un.prli.Retry = 1; 9625 els_pkt->un.prli.TaskRetryIdReq = 1; 9626 } else { 9627 els_pkt->un.prli.ConfmComplAllowed = 0; 9628 els_pkt->un.prli.Retry = 0; 9629 els_pkt->un.prli.TaskRetryIdReq = 0; 9630 } 9631 } 9632 9633 break; 9634 9635 case ELS_CMD_FLOGI: |
8923 case ELS_CMD_PLOGI: | |
8924 case ELS_CMD_FDISC: | 9636 case ELS_CMD_FDISC: |
8925 case ELS_CMD_PDISC: 8926 | |
8927 if (cmd == ELS_CMD_ACC) { | 9637 if (cmd == ELS_CMD_ACC) { |
9638 SERV_PARM *sp = (SERV_PARM *)&els_pkt->un.logi; 9639 |
|
8928 /* This is a patch for the ULP stack. */ 8929 8930 /* 8931 * ULP only reads our service parameters 8932 * once during bind_port, but the service 8933 * parameters change due to topology. 8934 */ 8935 8936 /* Copy latest service parameters to payload */ 8937 bcopy((void *)&port->sparam, | 9640 /* This is a patch for the ULP stack. */ 9641 9642 /* 9643 * ULP only reads our service parameters 9644 * once during bind_port, but the service 9645 * parameters change due to topology. 9646 */ 9647 9648 /* Copy latest service parameters to payload */ 9649 bcopy((void *)&port->sparam, |
8938 (void *)&els_pkt->un.logi, sizeof (SERV_PARM)); | 9650 (void *)sp, sizeof (SERV_PARM)); |
8939 | 9651 |
9652 /* We are in pt-to-pt mode. Set R_A_TOV to default */ 9653 sp->cmn.w2.r_a_tov = 9654 LE_SWAP32((FF_DEF_RATOV * 1000)); 9655 9656 /* Clear support for virtual fabrics */ 9657 /* randomOffset bit controls this for FLOGI */ 9658 sp->cmn.randomOffset = 0; |
|
8940#ifdef DHCHAP_SUPPORT | 9659#ifdef DHCHAP_SUPPORT |
8941 emlxs_dhc_init_sp(port, did, 8942 (SERV_PARM *)&els_pkt->un.logi, (char **)&fcsp_msg); | 9660 emlxs_dhc_init_sp(port, did, sp, (char **)&fcsp_msg); |
8943#endif /* DHCHAP_SUPPORT */ | 9661#endif /* DHCHAP_SUPPORT */ |
8944 | |
8945 } | 9662 } |
9663 break; |
|
8946 | 9664 |
9665 case ELS_CMD_PLOGI: 9666 case ELS_CMD_PDISC: 9667 if (cmd == ELS_CMD_ACC) { 9668 SERV_PARM *sp = (SERV_PARM *)&els_pkt->un.logi; 9669 9670 /* This is a patch for the ULP stack. */ 9671 9672 /* 9673 * ULP only reads our service parameters 9674 * once during bind_port, but the service 9675 * parameters change due to topology. 9676 */ 9677 9678 /* Copy latest service parameters to payload */ 9679 bcopy((void *)&port->sparam, 9680 (void *)sp, sizeof (SERV_PARM)); 9681 9682#ifdef DHCHAP_SUPPORT 9683 emlxs_dhc_init_sp(port, did, sp, (char **)&fcsp_msg); 9684#endif /* DHCHAP_SUPPORT */ 9685 } |
|
8947 break; 8948 8949 } 8950 8951 /* Initalize iocbq */ 8952 iocbq->node = (void *)NULL; 8953 if ((rval = EMLXS_SLI_PREP_ELS_IOCB(port, sbp)) != FC_SUCCESS) { 8954 --- 21 unchanged lines hidden (view full) --- 8976 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_reply_msg, 8977 "%s %s: did=%x oxid=%x rxid=%x %s", emlxs_elscmd_xlate(ucmd), 8978 emlxs_elscmd_xlate(cmd), did, pkt->pkt_cmd_fhdr.ox_id, 8979 pkt->pkt_cmd_fhdr.rx_id, fcsp_msg); 8980 8981 /* Process nodes */ 8982 switch (ucmd) { 8983 case ELS_CMD_RSCN: | 9686 break; 9687 9688 } 9689 9690 /* Initalize iocbq */ 9691 iocbq->node = (void *)NULL; 9692 if ((rval = EMLXS_SLI_PREP_ELS_IOCB(port, sbp)) != FC_SUCCESS) { 9693 --- 21 unchanged lines hidden (view full) --- 9715 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_els_reply_msg, 9716 "%s %s: did=%x oxid=%x rxid=%x %s", emlxs_elscmd_xlate(ucmd), 9717 emlxs_elscmd_xlate(cmd), did, pkt->pkt_cmd_fhdr.ox_id, 9718 pkt->pkt_cmd_fhdr.rx_id, fcsp_msg); 9719 9720 /* Process nodes */ 9721 switch (ucmd) { 9722 case ELS_CMD_RSCN: |
8984 { 8985 if (port->ini_mode && ub_buffer && cmd == ELS_CMD_ACC) { | 9723 if ((port->mode == MODE_INITIATOR) && ub_buffer && 9724 cmd == ELS_CMD_ACC) { |
8986 fc_rscn_t *rscn; 8987 uint32_t count; 8988 uint32_t *lp = NULL; 8989 8990 /* 8991 * Only the Leadville code path will come thru 8992 * here. The RSCN data is NOT swapped properly 8993 * for the Comstar code path. 8994 */ 8995 lp = (uint32_t *)ub_buffer; 8996 rscn = (fc_rscn_t *)lp++; 8997 count = ((rscn->rscn_payload_len - 4) / 4); 8998 8999 /* Close affected ports */ 9000 for (i = 0; i < count; i++, lp++) { 9001 (void) emlxs_port_offline(port, *lp); 9002 } 9003 } | 9725 fc_rscn_t *rscn; 9726 uint32_t count; 9727 uint32_t *lp = NULL; 9728 9729 /* 9730 * Only the Leadville code path will come thru 9731 * here. The RSCN data is NOT swapped properly 9732 * for the Comstar code path. 9733 */ 9734 lp = (uint32_t *)ub_buffer; 9735 rscn = (fc_rscn_t *)lp++; 9736 count = ((rscn->rscn_payload_len - 4) / 4); 9737 9738 /* Close affected ports */ 9739 for (i = 0; i < count; i++, lp++) { 9740 (void) emlxs_port_offline(port, *lp); 9741 } 9742 } |
9004 break; 9005 } 9006 case ELS_CMD_PLOGI: | 9743 break; |
9007 | 9744 |
9745 case ELS_CMD_PLOGI: |
|
9008 if (cmd == ELS_CMD_ACC) { | 9746 if (cmd == ELS_CMD_ACC) { |
9009 ndlp = emlxs_node_find_did(port, did); | 9747 ndlp = emlxs_node_find_did(port, did, 1); |
9010 9011 if (ndlp && ndlp->nlp_active) { 9012 /* Close the node for any further normal IO */ 9013 emlxs_node_close(port, ndlp, hba->channel_fcp, 9014 pkt->pkt_timeout + 10); 9015 emlxs_node_close(port, ndlp, hba->channel_ip, 9016 pkt->pkt_timeout + 10); 9017 9018 /* Flush tx queue */ 9019 (void) emlxs_tx_node_flush(port, ndlp, 0, 0, 0); 9020 9021 /* Flush chip queue */ 9022 (void) emlxs_chipq_node_flush(port, 0, ndlp, 0); 9023 } 9024 } | 9748 9749 if (ndlp && ndlp->nlp_active) { 9750 /* Close the node for any further normal IO */ 9751 emlxs_node_close(port, ndlp, hba->channel_fcp, 9752 pkt->pkt_timeout + 10); 9753 emlxs_node_close(port, ndlp, hba->channel_ip, 9754 pkt->pkt_timeout + 10); 9755 9756 /* Flush tx queue */ 9757 (void) emlxs_tx_node_flush(port, ndlp, 0, 0, 0); 9758 9759 /* Flush chip queue */ 9760 (void) emlxs_chipq_node_flush(port, 0, ndlp, 0); 9761 } 9762 } |
9025 | |
9026 break; 9027 9028 case ELS_CMD_PRLI: | 9763 break; 9764 9765 case ELS_CMD_PRLI: |
9029 | |
9030 if (cmd == ELS_CMD_ACC) { | 9766 if (cmd == ELS_CMD_ACC) { |
9031 ndlp = emlxs_node_find_did(port, did); | 9767 ndlp = emlxs_node_find_did(port, did, 1); |
9032 9033 if (ndlp && ndlp->nlp_active) { 9034 /* Close the node for any further normal IO */ 9035 emlxs_node_close(port, ndlp, hba->channel_fcp, 9036 pkt->pkt_timeout + 10); 9037 9038 /* Flush tx queues */ 9039 (void) emlxs_tx_node_flush(port, ndlp, 9040 &hba->chan[hba->channel_fcp], 0, 0); 9041 9042 /* Flush chip queues */ 9043 (void) emlxs_chipq_node_flush(port, 9044 &hba->chan[hba->channel_fcp], ndlp, 0); 9045 } 9046 } | 9768 9769 if (ndlp && ndlp->nlp_active) { 9770 /* Close the node for any further normal IO */ 9771 emlxs_node_close(port, ndlp, hba->channel_fcp, 9772 pkt->pkt_timeout + 10); 9773 9774 /* Flush tx queues */ 9775 (void) emlxs_tx_node_flush(port, ndlp, 9776 &hba->chan[hba->channel_fcp], 0, 0); 9777 9778 /* Flush chip queues */ 9779 (void) emlxs_chipq_node_flush(port, 9780 &hba->chan[hba->channel_fcp], ndlp, 0); 9781 } 9782 } |
9047 | |
9048 break; 9049 9050 case ELS_CMD_PRLO: | 9783 break; 9784 9785 case ELS_CMD_PRLO: |
9051 | |
9052 if (cmd == ELS_CMD_ACC) { | 9786 if (cmd == ELS_CMD_ACC) { |
9053 ndlp = emlxs_node_find_did(port, did); | 9787 ndlp = emlxs_node_find_did(port, did, 1); |
9054 9055 if (ndlp && ndlp->nlp_active) { 9056 /* Close the node for any further normal IO */ 9057 emlxs_node_close(port, ndlp, 9058 hba->channel_fcp, 60); 9059 9060 /* Flush tx queues */ 9061 (void) emlxs_tx_node_flush(port, ndlp, 9062 &hba->chan[hba->channel_fcp], 0, 0); 9063 9064 /* Flush chip queues */ 9065 (void) emlxs_chipq_node_flush(port, 9066 &hba->chan[hba->channel_fcp], ndlp, 0); 9067 } 9068 } 9069 9070 break; 9071 9072 case ELS_CMD_LOGO: | 9788 9789 if (ndlp && ndlp->nlp_active) { 9790 /* Close the node for any further normal IO */ 9791 emlxs_node_close(port, ndlp, 9792 hba->channel_fcp, 60); 9793 9794 /* Flush tx queues */ 9795 (void) emlxs_tx_node_flush(port, ndlp, 9796 &hba->chan[hba->channel_fcp], 0, 0); 9797 9798 /* Flush chip queues */ 9799 (void) emlxs_chipq_node_flush(port, 9800 &hba->chan[hba->channel_fcp], ndlp, 0); 9801 } 9802 } 9803 9804 break; 9805 9806 case ELS_CMD_LOGO: |
9073 | |
9074 if (cmd == ELS_CMD_ACC) { | 9807 if (cmd == ELS_CMD_ACC) { |
9075 ndlp = emlxs_node_find_did(port, did); | 9808 ndlp = emlxs_node_find_did(port, did, 1); |
9076 9077 if (ndlp && ndlp->nlp_active) { 9078 /* Close the node for any further normal IO */ 9079 emlxs_node_close(port, ndlp, 9080 hba->channel_fcp, 60); 9081 emlxs_node_close(port, ndlp, 9082 hba->channel_ip, 60); 9083 --- 38 unchanged lines hidden (view full) --- 9122 9123 pkt = PRIV2PKT(sbp); 9124 did = EMLXS_MENLO_DID; 9125 lp = (uint32_t *)pkt->pkt_cmd; 9126 9127 iocbq = &sbp->iocbq; 9128 iocb = &iocbq->iocb; 9129 | 9809 9810 if (ndlp && ndlp->nlp_active) { 9811 /* Close the node for any further normal IO */ 9812 emlxs_node_close(port, ndlp, 9813 hba->channel_fcp, 60); 9814 emlxs_node_close(port, ndlp, 9815 hba->channel_ip, 60); 9816 --- 38 unchanged lines hidden (view full) --- 9855 9856 pkt = PRIV2PKT(sbp); 9857 did = EMLXS_MENLO_DID; 9858 lp = (uint32_t *)pkt->pkt_cmd; 9859 9860 iocbq = &sbp->iocbq; 9861 iocb = &iocbq->iocb; 9862 |
9130 ndlp = emlxs_node_find_did(port, did); | 9863 ndlp = emlxs_node_find_did(port, did, 1); |
9131 9132 if (!ndlp || !ndlp->nlp_active) { 9133 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg, 9134 "Node not found. did=0x%x", did); 9135 9136 return (FC_BADPACKET); 9137 } 9138 --- 76 unchanged lines hidden (view full) --- 9215 int32_t rval; 9216 9217 pkt = PRIV2PKT(sbp); 9218 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id); 9219 9220 iocbq = &sbp->iocbq; 9221 iocb = &iocbq->iocb; 9222 | 9864 9865 if (!ndlp || !ndlp->nlp_active) { 9866 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg, 9867 "Node not found. did=0x%x", did); 9868 9869 return (FC_BADPACKET); 9870 } 9871 --- 76 unchanged lines hidden (view full) --- 9948 int32_t rval; 9949 9950 pkt = PRIV2PKT(sbp); 9951 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id); 9952 9953 iocbq = &sbp->iocbq; 9954 iocb = &iocbq->iocb; 9955 |
9223 ndlp = emlxs_node_find_did(port, did); | 9956 ndlp = emlxs_node_find_did(port, did, 1); |
9224 9225 if (!ndlp || !ndlp->nlp_active) { 9226 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg, 9227 "Node not found. did=0x%x", did); 9228 9229 return (FC_BADPACKET); 9230 } 9231 --- 229 unchanged lines hidden (view full) --- 9461 return; 9462 } 9463 9464 hba = HBA; 9465 9466 if ((hba->sli_mode == EMLXS_HBA_SLI4_MODE) && 9467 (sbp->iotag)) { 9468 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_debug_msg, | 9957 9958 if (!ndlp || !ndlp->nlp_active) { 9959 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_trans_failed_msg, 9960 "Node not found. did=0x%x", did); 9961 9962 return (FC_BADPACKET); 9963 } 9964 --- 229 unchanged lines hidden (view full) --- 10194 return; 10195 } 10196 10197 hba = HBA; 10198 10199 if ((hba->sli_mode == EMLXS_HBA_SLI4_MODE) && 10200 (sbp->iotag)) { 10201 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_debug_msg, |
9469 "WARNING: Completing IO with iotag. sbp=%p iotag=%x " | 10202 "WARNING: Completing IO with iotag. sbp=%p iotag=%d " |
9470 "xri_flags=%x", 9471 sbp, sbp->iotag, ((sbp->xrip)? sbp->xrip->flag:0)); 9472 | 10203 "xri_flags=%x", 10204 sbp, sbp->iotag, ((sbp->xrip)? sbp->xrip->flag:0)); 10205 |
9473 emlxs_sli4_free_xri(hba, sbp, sbp->xrip, 1); | 10206 emlxs_sli4_free_xri(port, sbp, sbp->xrip, 1); |
9474 } 9475 9476 mutex_enter(&sbp->mtx); 9477 9478 /* Check for error conditions */ 9479 if (sbp->pkt_flags & (PACKET_ULP_OWNED | PACKET_COMPLETED | 9480 PACKET_IN_DONEQ | PACKET_IN_COMPLETION | 9481 PACKET_IN_TXQ | PACKET_IN_CHIPQ)) { --- 136 unchanged lines hidden (view full) --- 9618 uint32_t did; 9619 hrtime_t t; 9620 hrtime_t delta_time; 9621 int i; 9622 NODELIST *ndlp; 9623 9624 vport = sbp->port; 9625 | 10207 } 10208 10209 mutex_enter(&sbp->mtx); 10210 10211 /* Check for error conditions */ 10212 if (sbp->pkt_flags & (PACKET_ULP_OWNED | PACKET_COMPLETED | 10213 PACKET_IN_DONEQ | PACKET_IN_COMPLETION | 10214 PACKET_IN_TXQ | PACKET_IN_CHIPQ)) { --- 136 unchanged lines hidden (view full) --- 10351 uint32_t did; 10352 hrtime_t t; 10353 hrtime_t delta_time; 10354 int i; 10355 NODELIST *ndlp; 10356 10357 vport = sbp->port; 10358 |
9626 if ((sd_bucket.search_type == 0) || 9627 (vport->sd_io_latency_state != SD_COLLECTING)) | 10359 if ((emlxs_sd_bucket.search_type == 0) || 10360 (vport->sd_io_latency_state != SD_COLLECTING)) { |
9628 return; | 10361 return; |
10362 } |
|
9629 9630 /* Compute the iolatency time in microseconds */ 9631 t = gethrtime(); 9632 delta_time = t - sbp->sd_start_time; 9633 pkt = PRIV2PKT(sbp); 9634 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id); | 10363 10364 /* Compute the iolatency time in microseconds */ 10365 t = gethrtime(); 10366 delta_time = t - sbp->sd_start_time; 10367 pkt = PRIV2PKT(sbp); 10368 did = LE_SWAP24_LO(pkt->pkt_cmd_fhdr.d_id); |
9635 ndlp = emlxs_node_find_did(vport, did); | 10369 ndlp = emlxs_node_find_did(vport, did, 1); |
9636 | 10370 |
9637 if (ndlp) { 9638 if (delta_time >= 9639 sd_bucket.values[SD_IO_LATENCY_MAX_BUCKETS - 1]) 9640 ndlp->sd_dev_bucket[SD_IO_LATENCY_MAX_BUCKETS - 1]. 9641 count++; 9642 else if (delta_time <= sd_bucket.values[0]) 9643 ndlp->sd_dev_bucket[0].count++; 9644 else { 9645 for (i = 1; i < SD_IO_LATENCY_MAX_BUCKETS; i++) { 9646 if ((delta_time > sd_bucket.values[i-1]) && 9647 (delta_time <= sd_bucket.values[i])) { 9648 ndlp->sd_dev_bucket[i].count++; 9649 break; 9650 } | 10371 if (!ndlp) { 10372 return; 10373 } 10374 10375 if (delta_time >= 10376 emlxs_sd_bucket.values[SD_IO_LATENCY_MAX_BUCKETS - 1]) { 10377 ndlp->sd_dev_bucket[SD_IO_LATENCY_MAX_BUCKETS - 1]. 10378 count++; 10379 } else if (delta_time <= emlxs_sd_bucket.values[0]) { 10380 ndlp->sd_dev_bucket[0].count++; 10381 } else { 10382 for (i = 1; i < SD_IO_LATENCY_MAX_BUCKETS; i++) { 10383 if ((delta_time > emlxs_sd_bucket.values[i-1]) && 10384 (delta_time <= emlxs_sd_bucket.values[i])) { 10385 ndlp->sd_dev_bucket[i].count++; 10386 break; |
9651 } 9652 } 9653 } | 10387 } 10388 } 10389 } |
9654} | 10390 10391 return; 10392 10393} /* emlxs_update_sd_bucket() */ |
9655#endif /* SAN_DIAG_SUPPORT */ 9656 9657/*ARGSUSED*/ 9658static void 9659emlxs_iodone_server(void *arg1, void *arg2, void *arg3) 9660{ 9661 emlxs_hba_t *hba = (emlxs_hba_t *)arg1; 9662 emlxs_buf_t *sbp; --- 243 unchanged lines hidden (view full) --- 9906 fcp_rsp_t *fcp_rsp; 9907 uint32_t i; 9908 emlxs_xlat_err_t *tptr; 9909 emlxs_xlat_err_t *entry; 9910 9911 9912 pkt = PRIV2PKT(sbp); 9913 | 10394#endif /* SAN_DIAG_SUPPORT */ 10395 10396/*ARGSUSED*/ 10397static void 10398emlxs_iodone_server(void *arg1, void *arg2, void *arg3) 10399{ 10400 emlxs_hba_t *hba = (emlxs_hba_t *)arg1; 10401 emlxs_buf_t *sbp; --- 243 unchanged lines hidden (view full) --- 10645 fcp_rsp_t *fcp_rsp; 10646 uint32_t i; 10647 emlxs_xlat_err_t *tptr; 10648 emlxs_xlat_err_t *entry; 10649 10650 10651 pkt = PRIV2PKT(sbp); 10652 |
10653 /* Warning: Some FCT sbp's don't have */ 10654 /* fc_packet objects, so just return */ 10655 if (!pkt) { 10656 return; 10657 } 10658 |
|
9914 if (lock) { 9915 mutex_enter(&sbp->mtx); 9916 } 9917 9918 if (!(sbp->pkt_flags & PACKET_STATE_VALID)) { 9919 sbp->pkt_flags |= PACKET_STATE_VALID; 9920 9921 /* Perform table lookup */ --- 459 unchanged lines hidden (view full) --- 10381 10382} /* emlxs_swap_els_ub() */ 10383 10384 10385#endif /* EMLXS_MODREV2X */ 10386 10387 10388extern char * | 10659 if (lock) { 10660 mutex_enter(&sbp->mtx); 10661 } 10662 10663 if (!(sbp->pkt_flags & PACKET_STATE_VALID)) { 10664 sbp->pkt_flags |= PACKET_STATE_VALID; 10665 10666 /* Perform table lookup */ --- 459 unchanged lines hidden (view full) --- 11126 11127} /* emlxs_swap_els_ub() */ 11128 11129 11130#endif /* EMLXS_MODREV2X */ 11131 11132 11133extern char * |
11134emlxs_mode_xlate(uint32_t mode) 11135{ 11136 static char buffer[32]; 11137 uint32_t i; 11138 uint32_t count; 11139 11140 count = sizeof (emlxs_mode_table) / sizeof (emlxs_table_t); 11141 for (i = 0; i < count; i++) { 11142 if (mode == emlxs_mode_table[i].code) { 11143 return (emlxs_mode_table[i].string); 11144 } 11145 } 11146 11147 (void) snprintf(buffer, sizeof (buffer), "Unknown (%x)", mode); 11148 return (buffer); 11149 11150} /* emlxs_mode_xlate() */ 11151 11152 11153extern char * |
|
10389emlxs_elscmd_xlate(uint32_t elscmd) 10390{ 10391 static char buffer[32]; 10392 uint32_t i; 10393 uint32_t count; 10394 10395 count = sizeof (emlxs_elscmd_table) / sizeof (emlxs_table_t); 10396 for (i = 0; i < count; i++) { 10397 if (elscmd == emlxs_elscmd_table[i].code) { 10398 return (emlxs_elscmd_table[i].string); 10399 } 10400 } 10401 | 11154emlxs_elscmd_xlate(uint32_t elscmd) 11155{ 11156 static char buffer[32]; 11157 uint32_t i; 11158 uint32_t count; 11159 11160 count = sizeof (emlxs_elscmd_table) / sizeof (emlxs_table_t); 11161 for (i = 0; i < count; i++) { 11162 if (elscmd == emlxs_elscmd_table[i].code) { 11163 return (emlxs_elscmd_table[i].string); 11164 } 11165 } 11166 |
10402 (void) sprintf(buffer, "ELS=0x%x", elscmd); | 11167 (void) snprintf(buffer, sizeof (buffer), "ELS=0x%x", elscmd); |
10403 return (buffer); 10404 10405} /* emlxs_elscmd_xlate() */ 10406 10407 10408extern char * 10409emlxs_ctcmd_xlate(uint32_t ctcmd) 10410{ 10411 static char buffer[32]; 10412 uint32_t i; 10413 uint32_t count; 10414 10415 count = sizeof (emlxs_ctcmd_table) / sizeof (emlxs_table_t); 10416 for (i = 0; i < count; i++) { 10417 if (ctcmd == emlxs_ctcmd_table[i].code) { 10418 return (emlxs_ctcmd_table[i].string); 10419 } 10420 } 10421 | 11168 return (buffer); 11169 11170} /* emlxs_elscmd_xlate() */ 11171 11172 11173extern char * 11174emlxs_ctcmd_xlate(uint32_t ctcmd) 11175{ 11176 static char buffer[32]; 11177 uint32_t i; 11178 uint32_t count; 11179 11180 count = sizeof (emlxs_ctcmd_table) / sizeof (emlxs_table_t); 11181 for (i = 0; i < count; i++) { 11182 if (ctcmd == emlxs_ctcmd_table[i].code) { 11183 return (emlxs_ctcmd_table[i].string); 11184 } 11185 } 11186 |
10422 (void) sprintf(buffer, "cmd=0x%x", ctcmd); | 11187 (void) snprintf(buffer, sizeof (buffer), "cmd=0x%x", ctcmd); |
10423 return (buffer); 10424 10425} /* emlxs_ctcmd_xlate() */ 10426 10427 10428#ifdef MENLO_SUPPORT 10429extern char * 10430emlxs_menlo_cmd_xlate(uint32_t cmd) --- 4 unchanged lines hidden (view full) --- 10435 10436 count = sizeof (emlxs_menlo_cmd_table) / sizeof (emlxs_table_t); 10437 for (i = 0; i < count; i++) { 10438 if (cmd == emlxs_menlo_cmd_table[i].code) { 10439 return (emlxs_menlo_cmd_table[i].string); 10440 } 10441 } 10442 | 11188 return (buffer); 11189 11190} /* emlxs_ctcmd_xlate() */ 11191 11192 11193#ifdef MENLO_SUPPORT 11194extern char * 11195emlxs_menlo_cmd_xlate(uint32_t cmd) --- 4 unchanged lines hidden (view full) --- 11200 11201 count = sizeof (emlxs_menlo_cmd_table) / sizeof (emlxs_table_t); 11202 for (i = 0; i < count; i++) { 11203 if (cmd == emlxs_menlo_cmd_table[i].code) { 11204 return (emlxs_menlo_cmd_table[i].string); 11205 } 11206 } 11207 |
10443 (void) sprintf(buffer, "Cmd=0x%x", cmd); | 11208 (void) snprintf(buffer, sizeof (buffer), "Cmd=0x%x", cmd); |
10444 return (buffer); 10445 10446} /* emlxs_menlo_cmd_xlate() */ 10447 10448extern char * 10449emlxs_menlo_rsp_xlate(uint32_t rsp) 10450{ 10451 static char buffer[32]; 10452 uint32_t i; 10453 uint32_t count; 10454 10455 count = sizeof (emlxs_menlo_rsp_table) / sizeof (emlxs_table_t); 10456 for (i = 0; i < count; i++) { 10457 if (rsp == emlxs_menlo_rsp_table[i].code) { 10458 return (emlxs_menlo_rsp_table[i].string); 10459 } 10460 } 10461 | 11209 return (buffer); 11210 11211} /* emlxs_menlo_cmd_xlate() */ 11212 11213extern char * 11214emlxs_menlo_rsp_xlate(uint32_t rsp) 11215{ 11216 static char buffer[32]; 11217 uint32_t i; 11218 uint32_t count; 11219 11220 count = sizeof (emlxs_menlo_rsp_table) / sizeof (emlxs_table_t); 11221 for (i = 0; i < count; i++) { 11222 if (rsp == emlxs_menlo_rsp_table[i].code) { 11223 return (emlxs_menlo_rsp_table[i].string); 11224 } 11225 } 11226 |
10462 (void) sprintf(buffer, "Rsp=0x%x", rsp); | 11227 (void) snprintf(buffer, sizeof (buffer), "Rsp=0x%x", rsp); |
10463 return (buffer); 10464 10465} /* emlxs_menlo_rsp_xlate() */ 10466 10467#endif /* MENLO_SUPPORT */ 10468 10469 10470extern char * --- 5 unchanged lines hidden (view full) --- 10476 10477 count = sizeof (emlxs_rmcmd_table) / sizeof (emlxs_table_t); 10478 for (i = 0; i < count; i++) { 10479 if (rmcmd == emlxs_rmcmd_table[i].code) { 10480 return (emlxs_rmcmd_table[i].string); 10481 } 10482 } 10483 | 11228 return (buffer); 11229 11230} /* emlxs_menlo_rsp_xlate() */ 11231 11232#endif /* MENLO_SUPPORT */ 11233 11234 11235extern char * --- 5 unchanged lines hidden (view full) --- 11241 11242 count = sizeof (emlxs_rmcmd_table) / sizeof (emlxs_table_t); 11243 for (i = 0; i < count; i++) { 11244 if (rmcmd == emlxs_rmcmd_table[i].code) { 11245 return (emlxs_rmcmd_table[i].string); 11246 } 11247 } 11248 |
10484 (void) sprintf(buffer, "RM=0x%x", rmcmd); | 11249 (void) snprintf(buffer, sizeof (buffer), "RM=0x%x", rmcmd); |
10485 return (buffer); 10486 10487} /* emlxs_rmcmd_xlate() */ 10488 10489 10490 10491extern char * 10492emlxs_mscmd_xlate(uint16_t mscmd) --- 4 unchanged lines hidden (view full) --- 10497 10498 count = sizeof (emlxs_mscmd_table) / sizeof (emlxs_table_t); 10499 for (i = 0; i < count; i++) { 10500 if (mscmd == emlxs_mscmd_table[i].code) { 10501 return (emlxs_mscmd_table[i].string); 10502 } 10503 } 10504 | 11250 return (buffer); 11251 11252} /* emlxs_rmcmd_xlate() */ 11253 11254 11255 11256extern char * 11257emlxs_mscmd_xlate(uint16_t mscmd) --- 4 unchanged lines hidden (view full) --- 11262 11263 count = sizeof (emlxs_mscmd_table) / sizeof (emlxs_table_t); 11264 for (i = 0; i < count; i++) { 11265 if (mscmd == emlxs_mscmd_table[i].code) { 11266 return (emlxs_mscmd_table[i].string); 11267 } 11268 } 11269 |
10505 (void) sprintf(buffer, "Cmd=0x%x", mscmd); | 11270 (void) snprintf(buffer, sizeof (buffer), "Cmd=0x%x", mscmd); |
10506 return (buffer); 10507 10508} /* emlxs_mscmd_xlate() */ 10509 10510 10511extern char * 10512emlxs_state_xlate(uint8_t state) 10513{ 10514 static char buffer[32]; 10515 uint32_t i; 10516 uint32_t count; 10517 10518 count = sizeof (emlxs_state_table) / sizeof (emlxs_table_t); 10519 for (i = 0; i < count; i++) { 10520 if (state == emlxs_state_table[i].code) { 10521 return (emlxs_state_table[i].string); 10522 } 10523 } 10524 | 11271 return (buffer); 11272 11273} /* emlxs_mscmd_xlate() */ 11274 11275 11276extern char * 11277emlxs_state_xlate(uint8_t state) 11278{ 11279 static char buffer[32]; 11280 uint32_t i; 11281 uint32_t count; 11282 11283 count = sizeof (emlxs_state_table) / sizeof (emlxs_table_t); 11284 for (i = 0; i < count; i++) { 11285 if (state == emlxs_state_table[i].code) { 11286 return (emlxs_state_table[i].string); 11287 } 11288 } 11289 |
10525 (void) sprintf(buffer, "State=0x%x", state); | 11290 (void) snprintf(buffer, sizeof (buffer), "State=0x%x", state); |
10526 return (buffer); 10527 10528} /* emlxs_state_xlate() */ 10529 10530 10531extern char * 10532emlxs_error_xlate(uint8_t errno) 10533{ 10534 static char buffer[32]; 10535 uint32_t i; 10536 uint32_t count; 10537 10538 count = sizeof (emlxs_error_table) / sizeof (emlxs_table_t); 10539 for (i = 0; i < count; i++) { 10540 if (errno == emlxs_error_table[i].code) { 10541 return (emlxs_error_table[i].string); 10542 } 10543 } 10544 | 11291 return (buffer); 11292 11293} /* emlxs_state_xlate() */ 11294 11295 11296extern char * 11297emlxs_error_xlate(uint8_t errno) 11298{ 11299 static char buffer[32]; 11300 uint32_t i; 11301 uint32_t count; 11302 11303 count = sizeof (emlxs_error_table) / sizeof (emlxs_table_t); 11304 for (i = 0; i < count; i++) { 11305 if (errno == emlxs_error_table[i].code) { 11306 return (emlxs_error_table[i].string); 11307 } 11308 } 11309 |
10545 (void) sprintf(buffer, "Errno=0x%x", errno); | 11310 (void) snprintf(buffer, sizeof (buffer), "Errno=0x%x", errno); |
10546 return (buffer); 10547 10548} /* emlxs_error_xlate() */ 10549 10550 10551static int 10552emlxs_pm_lower_power(dev_info_t *dip) 10553{ --- 201 unchanged lines hidden (view full) --- 10755 uint32_t i; 10756 uint32_t j; 10757 uint32_t c1; 10758 uint32_t sum; 10759 uint32_t errors; 10760 char buffer[64]; 10761 10762 /* Check for the per adapter vport setting */ | 11311 return (buffer); 11312 11313} /* emlxs_error_xlate() */ 11314 11315 11316static int 11317emlxs_pm_lower_power(dev_info_t *dip) 11318{ --- 201 unchanged lines hidden (view full) --- 11520 uint32_t i; 11521 uint32_t j; 11522 uint32_t c1; 11523 uint32_t sum; 11524 uint32_t errors; 11525 char buffer[64]; 11526 11527 /* Check for the per adapter vport setting */ |
10763 (void) sprintf(buffer, "%s%d-vport", DRIVER_NAME, hba->ddiinst); | 11528 (void) snprintf(buffer, sizeof (buffer), "%s%d-vport", DRIVER_NAME, 11529 hba->ddiinst); |
10764 cnt = 0; 10765 arrayp = NULL; 10766 rval = 10767 ddi_prop_lookup_string_array(DDI_DEV_T_ANY, hba->dip, 10768 (DDI_PROP_DONTPASS), buffer, &arrayp, &cnt); 10769 10770 if ((rval != DDI_PROP_SUCCESS) || !cnt || !arrayp) { 10771 /* Check for the global vport setting */ --- 198 unchanged lines hidden (view full) --- 10970 10971 bcopy((caddr_t)&wwnn, (caddr_t)&hba->port[vpi].wwnn, 10972 sizeof (NAME_TYPE)); 10973 bcopy((caddr_t)&wwpn, (caddr_t)&hba->port[vpi].wwpn, 10974 sizeof (NAME_TYPE)); 10975 10976 if (hba->port[vpi].snn[0] == 0) { 10977 (void) strncpy((caddr_t)hba->port[vpi].snn, | 11530 cnt = 0; 11531 arrayp = NULL; 11532 rval = 11533 ddi_prop_lookup_string_array(DDI_DEV_T_ANY, hba->dip, 11534 (DDI_PROP_DONTPASS), buffer, &arrayp, &cnt); 11535 11536 if ((rval != DDI_PROP_SUCCESS) || !cnt || !arrayp) { 11537 /* Check for the global vport setting */ --- 198 unchanged lines hidden (view full) --- 11736 11737 bcopy((caddr_t)&wwnn, (caddr_t)&hba->port[vpi].wwnn, 11738 sizeof (NAME_TYPE)); 11739 bcopy((caddr_t)&wwpn, (caddr_t)&hba->port[vpi].wwpn, 11740 sizeof (NAME_TYPE)); 11741 11742 if (hba->port[vpi].snn[0] == 0) { 11743 (void) strncpy((caddr_t)hba->port[vpi].snn, |
10978 (caddr_t)hba->snn, 256); | 11744 (caddr_t)hba->snn, 11745 (sizeof (hba->port[vpi].snn)-1)); |
10979 } 10980 10981 if (hba->port[vpi].spn[0] == 0) { | 11746 } 11747 11748 if (hba->port[vpi].spn[0] == 0) { |
10982 (void) sprintf((caddr_t)hba->port[vpi].spn, | 11749 (void) snprintf((caddr_t)hba->port[vpi].spn, 11750 sizeof (hba->port[vpi].spn), |
10983 "%s VPort-%d", 10984 (caddr_t)hba->spn, vpi); 10985 } 10986 10987 hba->port[vpi].flag |= | 11751 "%s VPort-%d", 11752 (caddr_t)hba->spn, vpi); 11753 } 11754 11755 hba->port[vpi].flag |= |
10988 (EMLXS_PORT_CONFIG | EMLXS_PORT_ENABLE); | 11756 (EMLXS_PORT_CONFIG | EMLXS_PORT_ENABLED); |
10989 10990 if (cfg[CFG_VPORT_RESTRICTED].current) { 10991 hba->port[vpi].flag |= EMLXS_PORT_RESTRICTED; 10992 } 10993 } 10994 10995out: 10996 10997 (void) ddi_prop_free((void *) arrayp); 10998 return; 10999 11000} /* emlxs_read_vport_prop() */ 11001#endif /* EMLXS_MODREV3 || EMLXS_MODREV4 */ 11002 11003 11004extern char * | 11757 11758 if (cfg[CFG_VPORT_RESTRICTED].current) { 11759 hba->port[vpi].flag |= EMLXS_PORT_RESTRICTED; 11760 } 11761 } 11762 11763out: 11764 11765 (void) ddi_prop_free((void *) arrayp); 11766 return; 11767 11768} /* emlxs_read_vport_prop() */ 11769#endif /* EMLXS_MODREV3 || EMLXS_MODREV4 */ 11770 11771 11772extern char * |
11005emlxs_wwn_xlate(char *buffer, uint8_t *wwn) | 11773emlxs_wwn_xlate(char *buffer, size_t len, uint8_t *wwn) |
11006{ | 11774{ |
11007 (void) sprintf(buffer, "%02x%02x%02x%02x%02x%02x%02x%02x", | 11775 (void) snprintf(buffer, len, "%02x%02x%02x%02x%02x%02x%02x%02x", |
11008 wwn[0] & 0xff, wwn[1] & 0xff, wwn[2] & 0xff, wwn[3] & 0xff, 11009 wwn[4] & 0xff, wwn[5] & 0xff, wwn[6] & 0xff, wwn[7] & 0xff); 11010 11011 return (buffer); 11012 11013} /* emlxs_wwn_xlate() */ 11014 11015 | 11776 wwn[0] & 0xff, wwn[1] & 0xff, wwn[2] & 0xff, wwn[3] & 0xff, 11777 wwn[4] & 0xff, wwn[5] & 0xff, wwn[6] & 0xff, wwn[7] & 0xff); 11778 11779 return (buffer); 11780 11781} /* emlxs_wwn_xlate() */ 11782 11783 |
11784extern int32_t 11785emlxs_wwn_cmp(uint8_t *wwn1, uint8_t *wwn2) 11786{ 11787 uint32_t i; 11788 11789 for (i = 0; i < 8; i ++, wwn1 ++, wwn2 ++) { 11790 if (*wwn1 > *wwn2) { 11791 return (1); 11792 } 11793 if (*wwn1 < *wwn2) { 11794 return (-1); 11795 } 11796 } 11797 11798 return (0); 11799 11800} /* emlxs_wwn_cmp() */ 11801 11802 |
|
11016/* This is called at port online and offline */ 11017extern void 11018emlxs_ub_flush(emlxs_port_t *port) 11019{ 11020 emlxs_hba_t *hba = HBA; 11021 fc_unsol_buf_t *ubp; 11022 emlxs_ub_priv_t *ub_priv; 11023 emlxs_ub_priv_t *next; --- 9 unchanged lines hidden (view full) --- 11033 port->ub_wait_tail = NULL; 11034 mutex_exit(&EMLXS_PORT_LOCK); 11035 11036 while (ub_priv) { 11037 next = ub_priv->next; 11038 ubp = ub_priv->ubp; 11039 11040 /* Check if ULP is online and we have a callback function */ | 11803/* This is called at port online and offline */ 11804extern void 11805emlxs_ub_flush(emlxs_port_t *port) 11806{ 11807 emlxs_hba_t *hba = HBA; 11808 fc_unsol_buf_t *ubp; 11809 emlxs_ub_priv_t *ub_priv; 11810 emlxs_ub_priv_t *next; --- 9 unchanged lines hidden (view full) --- 11820 port->ub_wait_tail = NULL; 11821 mutex_exit(&EMLXS_PORT_LOCK); 11822 11823 while (ub_priv) { 11824 next = ub_priv->next; 11825 ubp = ub_priv->ubp; 11826 11827 /* Check if ULP is online and we have a callback function */ |
11041 if ((port->ulp_statec != FC_STATE_OFFLINE) && 11042 port->ulp_unsol_cb) { | 11828 if (port->ulp_statec != FC_STATE_OFFLINE) { |
11043 /* Send ULP the ub buffer */ | 11829 /* Send ULP the ub buffer */ |
11044 port->ulp_unsol_cb(port->ulp_handle, ubp, 11045 ubp->ub_frame.type); | 11830 emlxs_ulp_unsol_cb(port, ubp); |
11046 } else { /* Drop the buffer */ | 11831 } else { /* Drop the buffer */ |
11047 | |
11048 (void) emlxs_fca_ub_release(port, 1, &ubp->ub_token); 11049 } 11050 11051 ub_priv = next; 11052 11053 } /* while () */ 11054 11055 return; --- 6 unchanged lines hidden (view full) --- 11062{ 11063 emlxs_hba_t *hba = HBA; 11064 emlxs_ub_priv_t *ub_priv; 11065 11066 ub_priv = ubp->ub_fca_private; 11067 11068 /* Check if ULP is online */ 11069 if (port->ulp_statec != FC_STATE_OFFLINE) { | 11832 (void) emlxs_fca_ub_release(port, 1, &ubp->ub_token); 11833 } 11834 11835 ub_priv = next; 11836 11837 } /* while () */ 11838 11839 return; --- 6 unchanged lines hidden (view full) --- 11846{ 11847 emlxs_hba_t *hba = HBA; 11848 emlxs_ub_priv_t *ub_priv; 11849 11850 ub_priv = ubp->ub_fca_private; 11851 11852 /* Check if ULP is online */ 11853 if (port->ulp_statec != FC_STATE_OFFLINE) { |
11070 if (port->ulp_unsol_cb) { 11071 port->ulp_unsol_cb(port->ulp_handle, ubp, 11072 ubp->ub_frame.type); 11073 } else { 11074 (void) emlxs_fca_ub_release(port, 1, &ubp->ub_token); 11075 } | 11854 emlxs_ulp_unsol_cb(port, ubp); |
11076 | 11855 |
11077 return; | |
11078 } else { /* ULP offline */ 11079 11080 if (hba->state >= FC_LINK_UP) { 11081 /* Add buffer to queue tail */ 11082 mutex_enter(&EMLXS_PORT_LOCK); 11083 11084 if (port->ub_wait_tail) { 11085 port->ub_wait_tail->next = ub_priv; --- 10 unchanged lines hidden (view full) --- 11096 } 11097 } 11098 11099 return; 11100 11101} /* emlxs_ub_callback() */ 11102 11103 | 11856 } else { /* ULP offline */ 11857 11858 if (hba->state >= FC_LINK_UP) { 11859 /* Add buffer to queue tail */ 11860 mutex_enter(&EMLXS_PORT_LOCK); 11861 11862 if (port->ub_wait_tail) { 11863 port->ub_wait_tail->next = ub_priv; --- 10 unchanged lines hidden (view full) --- 11874 } 11875 } 11876 11877 return; 11878 11879} /* emlxs_ub_callback() */ 11880 11881 |
11882extern void 11883emlxs_fca_link_up(emlxs_port_t *port) 11884{ 11885 emlxs_ulp_statec_cb(port, port->ulp_statec); 11886 return; 11887 11888} /* emlxs_fca_link_up() */ 11889 11890 11891extern void 11892emlxs_fca_link_down(emlxs_port_t *port) 11893{ 11894 emlxs_ulp_statec_cb(port, FC_STATE_OFFLINE); 11895 return; 11896 11897} /* emlxs_fca_link_down() */ 11898 11899 |
|
11104static uint32_t 11105emlxs_integrity_check(emlxs_hba_t *hba) 11106{ 11107 uint32_t size; 11108 uint32_t errors = 0; 11109 int ddiinst = hba->ddiinst; 11110 11111 size = 16; --- 392 unchanged lines hidden (view full) --- 11504 11505extern void 11506emlxs_swap32_buffer(uint8_t *buffer, uint32_t size) 11507{ 11508 uint32_t word; 11509 uint32_t *wptr; 11510 uint32_t i; 11511 | 11900static uint32_t 11901emlxs_integrity_check(emlxs_hba_t *hba) 11902{ 11903 uint32_t size; 11904 uint32_t errors = 0; 11905 int ddiinst = hba->ddiinst; 11906 11907 size = 16; --- 392 unchanged lines hidden (view full) --- 12300 12301extern void 12302emlxs_swap32_buffer(uint8_t *buffer, uint32_t size) 12303{ 12304 uint32_t word; 12305 uint32_t *wptr; 12306 uint32_t i; 12307 |
12308 VERIFY((size % 4) == 0); 12309 |
|
11512 wptr = (uint32_t *)buffer; 11513 | 12310 wptr = (uint32_t *)buffer; 12311 |
11514 size += (size%4)? (4-(size%4)):0; | |
11515 for (i = 0; i < size / 4; i++) { 11516 word = *wptr; 11517 *wptr++ = SWAP32(word); 11518 } 11519 11520 return; 11521 11522} /* emlxs_swap32_buffer() */ 11523 11524 11525extern void 11526emlxs_swap32_bcopy(uint8_t *src, uint8_t *dst, uint32_t size) 11527{ 11528 uint32_t word; 11529 uint32_t *sptr; 11530 uint32_t *dptr; 11531 uint32_t i; 11532 | 12312 for (i = 0; i < size / 4; i++) { 12313 word = *wptr; 12314 *wptr++ = SWAP32(word); 12315 } 12316 12317 return; 12318 12319} /* emlxs_swap32_buffer() */ 12320 12321 12322extern void 12323emlxs_swap32_bcopy(uint8_t *src, uint8_t *dst, uint32_t size) 12324{ 12325 uint32_t word; 12326 uint32_t *sptr; 12327 uint32_t *dptr; 12328 uint32_t i; 12329 |
12330 VERIFY((size % 4) == 0); 12331 |
|
11533 sptr = (uint32_t *)src; 11534 dptr = (uint32_t *)dst; 11535 | 12332 sptr = (uint32_t *)src; 12333 dptr = (uint32_t *)dst; 12334 |
11536 size += (size%4)? (4-(size%4)):0; | |
11537 for (i = 0; i < size / 4; i++) { 11538 word = *sptr++; 11539 *dptr++ = SWAP32(word); 11540 } 11541 11542 return; 11543 11544} /* emlxs_swap32_buffer() */ | 12335 for (i = 0; i < size / 4; i++) { 12336 word = *sptr++; 12337 *dptr++ = SWAP32(word); 12338 } 12339 12340 return; 12341 12342} /* emlxs_swap32_buffer() */ |
12343 12344 12345extern char * 12346emlxs_strtoupper(char *str) 12347{ 12348 char *cptr = str; 12349 12350 while (*cptr) { 12351 if ((*cptr >= 'a') && (*cptr <= 'z')) { 12352 *cptr -= ('a' - 'A'); 12353 } 12354 cptr++; 12355 } 12356 12357 return (str); 12358 12359} /* emlxs_strtoupper() */ 12360 12361 12362extern void 12363emlxs_ulp_statec_cb(emlxs_port_t *port, uint32_t statec) 12364{ 12365 emlxs_hba_t *hba = HBA; 12366 12367 /* This routine coordinates protection with emlxs_fca_unbind_port() */ 12368 12369 mutex_enter(&EMLXS_PORT_LOCK); 12370 if (!(port->flag & EMLXS_INI_BOUND)) { 12371 mutex_exit(&EMLXS_PORT_LOCK); 12372 return; 12373 } 12374 port->ulp_busy++; 12375 mutex_exit(&EMLXS_PORT_LOCK); 12376 12377 port->ulp_statec_cb(port->ulp_handle, statec); 12378 12379 mutex_enter(&EMLXS_PORT_LOCK); 12380 port->ulp_busy--; 12381 mutex_exit(&EMLXS_PORT_LOCK); 12382 12383 return; 12384 12385} /* emlxs_ulp_statec_cb() */ 12386 12387 12388extern void 12389emlxs_ulp_unsol_cb(emlxs_port_t *port, fc_unsol_buf_t *ubp) 12390{ 12391 emlxs_hba_t *hba = HBA; 12392 12393 /* This routine coordinates protection with emlxs_fca_unbind_port() */ 12394 12395 mutex_enter(&EMLXS_PORT_LOCK); 12396 if (!(port->flag & EMLXS_INI_BOUND)) { 12397 mutex_exit(&EMLXS_PORT_LOCK); 12398 return; 12399 } 12400 port->ulp_busy++; 12401 mutex_exit(&EMLXS_PORT_LOCK); 12402 12403 port->ulp_unsol_cb(port->ulp_handle, ubp, ubp->ub_frame.type); 12404 12405 mutex_enter(&EMLXS_PORT_LOCK); 12406 port->ulp_busy--; 12407 mutex_exit(&EMLXS_PORT_LOCK); 12408 12409 return; 12410 12411} /* emlxs_ulp_unsol_cb() */ |
|