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() */