emlxs_hba.c (a9800beb) emlxs_hba.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.
25 */
26
24 * Use is subject to license terms.
25 */
26
27
28#define EMLXS_FW_TABLE_DEF
29#define EMLXS_MODEL_DEF
30
31#include <emlxs.h>
32
33/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
34EMLXS_MSG_DEF(EMLXS_HBA_C);
35

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

68 {PCI_CAP_ID_SECURE_DEV, "PCI_CAP_ID_SECURE_DEV"},
69 {PCI_CAP_ID_PCI_E, "PCI_CAP_ID_PCI_E"},
70 {PCI_CAP_ID_MSI_X, "PCI_CAP_ID_MSI_X"},
71 {PCI_CAP_ID_SATA, "PCI_CAP_ID_SATA"},
72 {PCI_CAP_ID_FLR, "PCI_CAP_ID_FLR"}
73
74}; /* emlxs_pci_cap */
75
27#define EMLXS_FW_TABLE_DEF
28#define EMLXS_MODEL_DEF
29
30#include <emlxs.h>
31
32/* Required for EMLXS_CONTEXT in EMLXS_MSGF calls */
33EMLXS_MSG_DEF(EMLXS_HBA_C);
34

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

67 {PCI_CAP_ID_SECURE_DEV, "PCI_CAP_ID_SECURE_DEV"},
68 {PCI_CAP_ID_PCI_E, "PCI_CAP_ID_PCI_E"},
69 {PCI_CAP_ID_MSI_X, "PCI_CAP_ID_MSI_X"},
70 {PCI_CAP_ID_SATA, "PCI_CAP_ID_SATA"},
71 {PCI_CAP_ID_FLR, "PCI_CAP_ID_FLR"}
72
73}; /* emlxs_pci_cap */
74
75emlxs_table_t emlxs_pci_ecap[] = {
76 {PCIE_EXT_CAP_ID_AER, "PCIE_EXT_CAP_ID_AER"},
77 {PCIE_EXT_CAP_ID_VC, "PCIE_EXT_CAP_ID_VC"},
78 {PCIE_EXT_CAP_ID_SER, "PCIE_EXT_CAP_ID_SER"},
79 {PCIE_EXT_CAP_ID_PWR_BUDGET, "PCIE_EXT_CAP_ID_PWR_BUDGET"},
80 {PCIE_EXT_CAP_ID_RC_LINK_DECL, "PCIE_EXT_CAP_ID_RC_LINK_DECL"},
81 {PCIE_EXT_CAP_ID_RC_INT_LINKCTRL, "PCIE_EXT_CAP_ID_RC_INT_LINKCTRL"},
82 {PCIE_EXT_CAP_ID_RC_EVNT_CEA, "PCIE_EXT_CAP_ID_RC_EVNT_CEA"},
83 {PCIE_EXT_CAP_ID_MFVC, "PCIE_EXT_CAP_ID_MFVC"},
84 {PCIE_EXT_CAP_ID_VC_WITH_MFVC, "PCIE_EXT_CAP_ID_VC_WITH_MFVC"},
85 {PCIE_EXT_CAP_ID_RCRB, "PCIE_EXT_CAP_ID_RCRB"},
86 {PCIE_EXT_CAP_ID_VS, "PCIE_EXT_CAP_ID_VS"},
87 {PCIE_EXT_CAP_ID_CAC, "PCIE_EXT_CAP_ID_CAC"},
88 {PCIE_EXT_CAP_ID_ACS, "PCIE_EXT_CAP_ID_ACS"},
89 {PCIE_EXT_CAP_ID_ARI, "PCIE_EXT_CAP_ID_ARI"},
90 {PCIE_EXT_CAP_ID_ATS, "PCIE_EXT_CAP_ID_ATS"},
91 {PCI_EXT_CAP_ID_SRIOV, "PCI_EXT_CAP_ID_SRIOV"},
92 {PCI_EXT_CAP_ID_TPH, "PCI_EXT_CAP_ID_TPH"},
93 {PCI_EXT_CAP_ID_SEC_PCI, "PCI_EXT_CAP_ID_SEC_PCI"}
94
95}; /* emlxs_pci_ecap */
96
97
76emlxs_table_t emlxs_ring_table[] = {
77 {FC_FCP_RING, "FCP Ring"},
78 {FC_IP_RING, "IP Ring"},
79 {FC_ELS_RING, "ELS Ring"},
80 {FC_CT_RING, "CT Ring"}
81
82}; /* emlxs_ring_table */
83

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

118 int32_t i;
119 int32_t ret;
120 ddi_intr_handle_t *htable = NULL;
121 ddi_intr_handle_t *new_htable = NULL;
122 uint32_t *intr_pri = NULL;
123 int32_t *intr_cap = NULL;
124 int32_t hilevel_pri;
125 emlxs_config_t *cfg = &CFG;
98emlxs_table_t emlxs_ring_table[] = {
99 {FC_FCP_RING, "FCP Ring"},
100 {FC_IP_RING, "IP Ring"},
101 {FC_ELS_RING, "ELS Ring"},
102 {FC_CT_RING, "CT Ring"}
103
104}; /* emlxs_ring_table */
105

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

140 int32_t i;
141 int32_t ret;
142 ddi_intr_handle_t *htable = NULL;
143 ddi_intr_handle_t *new_htable = NULL;
144 uint32_t *intr_pri = NULL;
145 int32_t *intr_cap = NULL;
146 int32_t hilevel_pri;
147 emlxs_config_t *cfg = &CFG;
126 char buf[64];
127
128 if (!(hba->intr_flags & EMLXS_MSI_ENABLED)) {
129 return (emlxs_intx_init(hba, max));
130 }
131
132 if (hba->intr_flags & EMLXS_MSI_INITED) {
133 return (DDI_SUCCESS);
134 }

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

182 /* Get the max interrupt count from the adapter */
183 nintrs = 0;
184 ret =
185 ddi_intr_get_nintrs(hba->dip, DDI_INTR_TYPE_MSIX,
186 &nintrs);
187
188 if (ret == DDI_SUCCESS && nintrs) {
189 type = DDI_INTR_TYPE_MSIX;
148
149 if (!(hba->intr_flags & EMLXS_MSI_ENABLED)) {
150 return (emlxs_intx_init(hba, max));
151 }
152
153 if (hba->intr_flags & EMLXS_MSI_INITED) {
154 return (DDI_SUCCESS);
155 }

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

203 /* Get the max interrupt count from the adapter */
204 nintrs = 0;
205 ret =
206 ddi_intr_get_nintrs(hba->dip, DDI_INTR_TYPE_MSIX,
207 &nintrs);
208
209 if (ret == DDI_SUCCESS && nintrs) {
210 type = DDI_INTR_TYPE_MSIX;
190 (void) strcpy(s_type, "TYPE_MSIX");
211 (void) strlcpy(s_type, "TYPE_MSIX", sizeof (s_type));
191 goto initialize;
192 }
193 }
194
195 /* Check if MSI is fully supported */
196 if ((types & DDI_INTR_TYPE_MSI) &&
197 (hba->model_info.flags & EMLXS_MSI_SUPPORTED)) {
198 /* Get the max interrupt count from the adapter */
199 nintrs = 0;
200 ret =
201 ddi_intr_get_nintrs(hba->dip, DDI_INTR_TYPE_MSI, &nintrs);
202
203 if (ret == DDI_SUCCESS && nintrs) {
204 type = DDI_INTR_TYPE_MSI;
212 goto initialize;
213 }
214 }
215
216 /* Check if MSI is fully supported */
217 if ((types & DDI_INTR_TYPE_MSI) &&
218 (hba->model_info.flags & EMLXS_MSI_SUPPORTED)) {
219 /* Get the max interrupt count from the adapter */
220 nintrs = 0;
221 ret =
222 ddi_intr_get_nintrs(hba->dip, DDI_INTR_TYPE_MSI, &nintrs);
223
224 if (ret == DDI_SUCCESS && nintrs) {
225 type = DDI_INTR_TYPE_MSI;
205 (void) strcpy(s_type, "TYPE_MSI");
226 (void) strlcpy(s_type, "TYPE_MSI", sizeof (s_type));
206 goto initialize;
207 }
208 }
209
210 /* Check if fixed interrupts are fully supported */
211 if ((types & DDI_INTR_TYPE_FIXED) &&
212 (hba->model_info.flags & EMLXS_INTX_SUPPORTED)) {
213 /* Get the max interrupt count from the adapter */
214 nintrs = 0;
215 ret =
216 ddi_intr_get_nintrs(hba->dip, DDI_INTR_TYPE_FIXED,
217 &nintrs);
218
219 if (ret == DDI_SUCCESS) {
220 type = DDI_INTR_TYPE_FIXED;
227 goto initialize;
228 }
229 }
230
231 /* Check if fixed interrupts are fully supported */
232 if ((types & DDI_INTR_TYPE_FIXED) &&
233 (hba->model_info.flags & EMLXS_INTX_SUPPORTED)) {
234 /* Get the max interrupt count from the adapter */
235 nintrs = 0;
236 ret =
237 ddi_intr_get_nintrs(hba->dip, DDI_INTR_TYPE_FIXED,
238 &nintrs);
239
240 if (ret == DDI_SUCCESS) {
241 type = DDI_INTR_TYPE_FIXED;
221 (void) strcpy(s_type, "TYPE_FIXED");
242 (void) strlcpy(s_type, "TYPE_FIXED", sizeof (s_type));
222 goto initialize;
223 }
224 }
225
226 goto init_failed;
227
228
229initialize:

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

399 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
400 hba->chan_count = hba->intr_count * cfg[CFG_NUM_WQ].current;
401 }
402
403 for (i = 0; i < EMLXS_MSI_MAX_INTRS; i++) {
404 hba->intr_map[i] = emlxs_msi_map[mode][i];
405 hba->intr_cond |= emlxs_msi_map[mode][i];
406
243 goto initialize;
244 }
245 }
246
247 goto init_failed;
248
249
250initialize:

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

420 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
421 hba->chan_count = hba->intr_count * cfg[CFG_NUM_WQ].current;
422 }
423
424 for (i = 0; i < EMLXS_MSI_MAX_INTRS; i++) {
425 hba->intr_map[i] = emlxs_msi_map[mode][i];
426 hba->intr_cond |= emlxs_msi_map[mode][i];
427
407 (void) sprintf(buf, "%s%d_msi%d mutex", DRIVER_NAME,
408 hba->ddiinst, i);
409 mutex_init(&hba->intr_lock[i], buf, MUTEX_DRIVER,
428 mutex_init(&hba->intr_lock[i], NULL, MUTEX_DRIVER,
410 DDI_INTR_PRI(hba->intr_arg));
411 }
412
413 /* Set flag to indicate support */
414 hba->intr_flags |= EMLXS_MSI_INITED;
415
416 /* Create the interrupt threads */
417 for (i = 0; i < hba->chan_count; i++) {
429 DDI_INTR_PRI(hba->intr_arg));
430 }
431
432 /* Set flag to indicate support */
433 hba->intr_flags |= EMLXS_MSI_INITED;
434
435 /* Create the interrupt threads */
436 for (i = 0; i < hba->chan_count; i++) {
418 (void) sprintf(buf, "%s%d_channel%d mutex", DRIVER_NAME,
419 hba->ddiinst, i);
420 mutex_init(&hba->chan[i].rsp_lock, buf, MUTEX_DRIVER,
437 mutex_init(&hba->chan[i].rsp_lock, NULL, MUTEX_DRIVER,
421 DDI_INTR_PRI(hba->intr_arg));
422
423 emlxs_thread_create(hba, &hba->chan[i].intr_thread);
424 }
425
426 return (DDI_SUCCESS);
427
428init_failed:

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

485 int32_t ret;
486
487 if (!(hba->intr_flags & EMLXS_MSI_ENABLED)) {
488 return (emlxs_intx_uninit(hba));
489 }
490
491 /*
492 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
438 DDI_INTR_PRI(hba->intr_arg));
439
440 emlxs_thread_create(hba, &hba->chan[i].intr_thread);
441 }
442
443 return (DDI_SUCCESS);
444
445init_failed:

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

502 int32_t ret;
503
504 if (!(hba->intr_flags & EMLXS_MSI_ENABLED)) {
505 return (emlxs_intx_uninit(hba));
506 }
507
508 /*
509 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
493 * "MSI: emlxs_msi_uninit called. flags=%x",
510 * "MSI: msi_uninit called. flags=%x",
494 * hba->intr_flags);
495 */
496
497 /* Make sure interrupts have been removed first */
498 if ((hba->intr_flags & EMLXS_MSI_ADDED)) {
499 ret = emlxs_msi_remove(hba);
500
501 if (ret != DDI_SUCCESS) {

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

551 /* Destroy the interrupt threads */
552 for (i = 0; i < hba->chan_count; i++) {
553 emlxs_thread_destroy(&hba->chan[i].intr_thread);
554 mutex_destroy(&hba->chan[i].rsp_lock);
555 }
556
557 /*
558 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
511 * hba->intr_flags);
512 */
513
514 /* Make sure interrupts have been removed first */
515 if ((hba->intr_flags & EMLXS_MSI_ADDED)) {
516 ret = emlxs_msi_remove(hba);
517
518 if (ret != DDI_SUCCESS) {

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

568 /* Destroy the interrupt threads */
569 for (i = 0; i < hba->chan_count; i++) {
570 emlxs_thread_destroy(&hba->chan[i].intr_thread);
571 mutex_destroy(&hba->chan[i].rsp_lock);
572 }
573
574 /*
575 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
559 * "MSI: emlxs_msi_uninit done. flags=%x",
576 * "MSI: msi_uninit done. flags=%x",
560 * hba->intr_flags);
561 */
562
563 return (DDI_SUCCESS);
564
565} /* emlxs_msi_uninit() */
566
567

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

682 int32_t ret;
683
684 if (!(hba->intr_flags & EMLXS_MSI_ENABLED)) {
685 return (emlxs_intx_remove(hba));
686 }
687
688 /*
689 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
577 * hba->intr_flags);
578 */
579
580 return (DDI_SUCCESS);
581
582} /* emlxs_msi_uninit() */
583
584

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

699 int32_t ret;
700
701 if (!(hba->intr_flags & EMLXS_MSI_ENABLED)) {
702 return (emlxs_intx_remove(hba));
703 }
704
705 /*
706 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
690 * "MSI: emlxs_msi_remove called. flags=%x",
707 * "MSI: msi_remove called. flags=%x",
691 * hba->intr_flags);
692 */
693
694 /* Check if interrupts have already been removed */
695 if (!(hba->intr_flags & EMLXS_MSI_ADDED)) {
696 return (DDI_SUCCESS);
697 }
698 hba->intr_flags &= ~EMLXS_MSI_ADDED;

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

758/* ARGSUSED */
759int32_t
760emlxs_intx_init(emlxs_hba_t *hba, uint32_t max)
761{
762 emlxs_port_t *port = &PPORT;
763 emlxs_config_t *cfg = &CFG;
764 int32_t ret;
765 uint32_t i;
708 * hba->intr_flags);
709 */
710
711 /* Check if interrupts have already been removed */
712 if (!(hba->intr_flags & EMLXS_MSI_ADDED)) {
713 return (DDI_SUCCESS);
714 }
715 hba->intr_flags &= ~EMLXS_MSI_ADDED;

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

775/* ARGSUSED */
776int32_t
777emlxs_intx_init(emlxs_hba_t *hba, uint32_t max)
778{
779 emlxs_port_t *port = &PPORT;
780 emlxs_config_t *cfg = &CFG;
781 int32_t ret;
782 uint32_t i;
766 char buf[64];
767
768 /* Check if interrupts have already been initialized */
769 if (hba->intr_flags & EMLXS_INTX_INITED) {
770 return (DDI_SUCCESS);
771 }
772
773 /* Check if adapter is flagged for INTX support */
774 if (!(hba->model_info.flags & EMLXS_INTX_SUPPORTED)) {

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

808 hba->intr_count = 1;
809 /* Adjust number of channels based on intr_count */
810 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
811 hba->chan_count = cfg[CFG_NUM_WQ].current;
812 }
813
814 /* Create the interrupt threads */
815 for (i = 0; i < hba->chan_count; i++) {
783
784 /* Check if interrupts have already been initialized */
785 if (hba->intr_flags & EMLXS_INTX_INITED) {
786 return (DDI_SUCCESS);
787 }
788
789 /* Check if adapter is flagged for INTX support */
790 if (!(hba->model_info.flags & EMLXS_INTX_SUPPORTED)) {

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

824 hba->intr_count = 1;
825 /* Adjust number of channels based on intr_count */
826 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
827 hba->chan_count = cfg[CFG_NUM_WQ].current;
828 }
829
830 /* Create the interrupt threads */
831 for (i = 0; i < hba->chan_count; i++) {
816 (void) sprintf(buf, "%s%d_channel%d mutex", DRIVER_NAME,
817 hba->ddiinst, i);
818 mutex_init(&hba->chan[i].rsp_lock, buf, MUTEX_DRIVER,
832 mutex_init(&hba->chan[i].rsp_lock, NULL, MUTEX_DRIVER,
819 DDI_INTR_PRI(hba->intr_arg));
820
821 emlxs_thread_create(hba, &hba->chan[i].intr_thread);
822 }
823
824 return (DDI_SUCCESS);
825
826} /* emlxs_intx_init() */

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

928} /* emlxs_intx_remove() */
929
930
931extern void
932emlxs_process_link_speed(emlxs_hba_t *hba)
933{
934 emlxs_vpd_t *vpd;
935 emlxs_config_t *cfg;
833 DDI_INTR_PRI(hba->intr_arg));
834
835 emlxs_thread_create(hba, &hba->chan[i].intr_thread);
836 }
837
838 return (DDI_SUCCESS);
839
840} /* emlxs_intx_init() */

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

942} /* emlxs_intx_remove() */
943
944
945extern void
946emlxs_process_link_speed(emlxs_hba_t *hba)
947{
948 emlxs_vpd_t *vpd;
949 emlxs_config_t *cfg;
936 char *cptr;
937 uint32_t hi;
938
939 /*
940 * This routine modifies the link-speed config parameter entry
941 * based on adapter capabilities
942 */
943 vpd = &VPD;
944 cfg = &hba->config[CFG_LINK_SPEED];
945
950 uint32_t hi;
951
952 /*
953 * This routine modifies the link-speed config parameter entry
954 * based on adapter capabilities
955 */
956 vpd = &VPD;
957 cfg = &hba->config[CFG_LINK_SPEED];
958
946 cptr = cfg->help;
947 (void) strcpy(cptr, "Select link speed. [0=Auto");
948 cptr += 26;
959 (void) strlcpy(cfg->help, "Select link speed. [0=Auto",
960 EMLXS_CFG_HELP_SIZE);
949 hi = 0;
950
951 if (vpd->link_speed & LMT_1GB_CAPABLE) {
961 hi = 0;
962
963 if (vpd->link_speed & LMT_1GB_CAPABLE) {
952 (void) strcpy(cptr, ", 1=1Gb");
953 cptr += 7;
964 (void) strlcat(cfg->help, ", 1=1Gb", EMLXS_CFG_HELP_SIZE);
954 hi = 1;
955 }
956
957 if (vpd->link_speed & LMT_2GB_CAPABLE) {
965 hi = 1;
966 }
967
968 if (vpd->link_speed & LMT_2GB_CAPABLE) {
958 (void) strcpy(cptr, ", 2=2Gb");
959 cptr += 7;
969 (void) strlcat(cfg->help, ", 2=2Gb", EMLXS_CFG_HELP_SIZE);
960 hi = 2;
961 }
962
963 if (vpd->link_speed & LMT_4GB_CAPABLE) {
970 hi = 2;
971 }
972
973 if (vpd->link_speed & LMT_4GB_CAPABLE) {
964 (void) strcpy(cptr, ", 4=4Gb");
965 cptr += 7;
974 (void) strlcat(cfg->help, ", 4=4Gb", EMLXS_CFG_HELP_SIZE);
966 hi = 4;
967 }
968
969 if (vpd->link_speed & LMT_8GB_CAPABLE) {
975 hi = 4;
976 }
977
978 if (vpd->link_speed & LMT_8GB_CAPABLE) {
970 (void) strcpy(cptr, ", 8=8Gb");
971 cptr += 7;
979 (void) strlcat(cfg->help, ", 8=8Gb", EMLXS_CFG_HELP_SIZE);
972 hi = 8;
973 }
974
975 if (vpd->link_speed & LMT_10GB_CAPABLE) {
980 hi = 8;
981 }
982
983 if (vpd->link_speed & LMT_10GB_CAPABLE) {
976 (void) strcpy(cptr, ", 10=10Gb");
977 cptr += 9;
984 (void) strlcat(cfg->help, ", 10=10Gb", EMLXS_CFG_HELP_SIZE);
978 hi = 10;
979 }
980
985 hi = 10;
986 }
987
981 (void) strcpy(cptr, "]");
988 if (vpd->link_speed & LMT_16GB_CAPABLE) {
989 (void) strlcat(cfg->help, ", 16=16Gb", EMLXS_CFG_HELP_SIZE);
990 hi = 16;
991 }
992
993 (void) strlcat(cfg->help, "]", EMLXS_CFG_HELP_SIZE);
982 cfg->hi = hi;
983
984 /* Now revalidate the current parameter setting */
985 cfg->current = emlxs_check_parm(hba, CFG_LINK_SPEED, cfg->current);
986
987 return;
988
989} /* emlxs_process_link_speed() */

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

1037 * "block_size = %x", block_size);
1038 */
1039
1040 n = sizeof (buffer);
1041 bzero(buffer, n);
1042 bcopy(&vpd_buf[index], buffer,
1043 (block_size < (n - 1)) ? block_size : (n - 1));
1044
994 cfg->hi = hi;
995
996 /* Now revalidate the current parameter setting */
997 cfg->current = emlxs_check_parm(hba, CFG_LINK_SPEED, cfg->current);
998
999 return;
1000
1001} /* emlxs_process_link_speed() */

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

1049 * "block_size = %x", block_size);
1050 */
1051
1052 n = sizeof (buffer);
1053 bzero(buffer, n);
1054 bcopy(&vpd_buf[index], buffer,
1055 (block_size < (n - 1)) ? block_size : (n - 1));
1056
1045 (void) strcpy(vpd->id, buffer);
1057 (void) strncpy(vpd->id, buffer, (sizeof (vpd->id)-1));
1046 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_vpd_msg, "ID: %s",
1047 vpd->id);
1048
1049 break;
1050
1051 case 0x90:
1052 index = block_index;
1053 index += 1;

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

1091 bzero(buffer, n);
1092 bcopy(&vpd_buf[index], buffer,
1093 (sub_size < (n - 1)) ? sub_size : (n - 1));
1094
1095 /*
1096 * Look for Engineering Change (EC)
1097 */
1098 if (strcmp(tag, "EC") == 0) {
1058 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_vpd_msg, "ID: %s",
1059 vpd->id);
1060
1061 break;
1062
1063 case 0x90:
1064 index = block_index;
1065 index += 1;

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

1103 bzero(buffer, n);
1104 bcopy(&vpd_buf[index], buffer,
1105 (sub_size < (n - 1)) ? sub_size : (n - 1));
1106
1107 /*
1108 * Look for Engineering Change (EC)
1109 */
1110 if (strcmp(tag, "EC") == 0) {
1099 (void) strcpy(vpd->eng_change, buffer);
1111 (void) strncpy(vpd->eng_change, buffer,
1112 (sizeof (vpd->eng_change)-1));
1100 EMLXS_MSGF(EMLXS_CONTEXT,
1101 &emlxs_vpd_msg, "EC: %s",
1102 vpd->eng_change);
1103 }
1104 /*
1105 * Look for Manufacturer (MN)
1106 */
1107 else if (strcmp(tag, "MN") == 0) {
1113 EMLXS_MSGF(EMLXS_CONTEXT,
1114 &emlxs_vpd_msg, "EC: %s",
1115 vpd->eng_change);
1116 }
1117 /*
1118 * Look for Manufacturer (MN)
1119 */
1120 else if (strcmp(tag, "MN") == 0) {
1108 (void) strcpy(vpd->manufacturer,
1109 buffer);
1121 (void) strncpy(vpd->manufacturer,
1122 buffer,
1123 (sizeof (vpd->manufacturer)-1));
1110 EMLXS_MSGF(EMLXS_CONTEXT,
1111 &emlxs_vpd_msg, "MN: %s",
1112 vpd->manufacturer);
1113 }
1114 /*
1115 * Look for Serial Number (SN)
1116 */
1117 else if (strcmp(tag, "SN") == 0) {
1124 EMLXS_MSGF(EMLXS_CONTEXT,
1125 &emlxs_vpd_msg, "MN: %s",
1126 vpd->manufacturer);
1127 }
1128 /*
1129 * Look for Serial Number (SN)
1130 */
1131 else if (strcmp(tag, "SN") == 0) {
1118 (void) strcpy(vpd->serial_num, buffer);
1132 (void) strncpy(vpd->serial_num, buffer,
1133 (sizeof (vpd->serial_num)-1));
1119 EMLXS_MSGF(EMLXS_CONTEXT,
1120 &emlxs_vpd_msg, "SN: %s",
1121 vpd->serial_num);
1122
1123 /* Validate the serial number */
1124 if (strncmp(buffer, "FFFFFFFFFF", 10) ==
1125 0 ||
1126 strncmp(buffer, "0000000000", 10) ==
1127 0) {
1128 vpd->serial_num[0] = 0;
1129 }
1130 }
1131 /*
1132 * Look for Part Number (PN)
1133 */
1134 else if (strcmp(tag, "PN") == 0) {
1134 EMLXS_MSGF(EMLXS_CONTEXT,
1135 &emlxs_vpd_msg, "SN: %s",
1136 vpd->serial_num);
1137
1138 /* Validate the serial number */
1139 if (strncmp(buffer, "FFFFFFFFFF", 10) ==
1140 0 ||
1141 strncmp(buffer, "0000000000", 10) ==
1142 0) {
1143 vpd->serial_num[0] = 0;
1144 }
1145 }
1146 /*
1147 * Look for Part Number (PN)
1148 */
1149 else if (strcmp(tag, "PN") == 0) {
1135 (void) strcpy(vpd->part_num, buffer);
1150 (void) strncpy(vpd->part_num, buffer,
1151 (sizeof (vpd->part_num)-1));
1136 EMLXS_MSGF(EMLXS_CONTEXT,
1137 &emlxs_vpd_msg, "PN: %s",
1138 vpd->part_num);
1139 }
1140 /*
1141 * Look for (V0)
1142 */
1143 else if (strcmp(tag, "V0") == 0) {
1144 /* Not used */
1145 EMLXS_MSGF(EMLXS_CONTEXT,
1146 &emlxs_vpd_msg, "V0: %s", buffer);
1147 }
1148 /*
1149 * Look for model description (V1)
1150 */
1151 else if (strcmp(tag, "V1") == 0) {
1152 EMLXS_MSGF(EMLXS_CONTEXT,
1153 &emlxs_vpd_msg, "PN: %s",
1154 vpd->part_num);
1155 }
1156 /*
1157 * Look for (V0)
1158 */
1159 else if (strcmp(tag, "V0") == 0) {
1160 /* Not used */
1161 EMLXS_MSGF(EMLXS_CONTEXT,
1162 &emlxs_vpd_msg, "V0: %s", buffer);
1163 }
1164 /*
1165 * Look for model description (V1)
1166 */
1167 else if (strcmp(tag, "V1") == 0) {
1152 (void) strcpy(vpd->model_desc, buffer);
1168 (void) strncpy(vpd->model_desc, buffer,
1169 (sizeof (vpd->model_desc)-1));
1153 EMLXS_MSGF(EMLXS_CONTEXT,
1154 &emlxs_vpd_msg, "Desc: %s",
1155 vpd->model_desc);
1156 }
1157 /*
1158 * Look for model (V2)
1159 */
1160 else if (strcmp(tag, "V2") == 0) {
1170 EMLXS_MSGF(EMLXS_CONTEXT,
1171 &emlxs_vpd_msg, "Desc: %s",
1172 vpd->model_desc);
1173 }
1174 /*
1175 * Look for model (V2)
1176 */
1177 else if (strcmp(tag, "V2") == 0) {
1161 (void) strcpy(vpd->model, buffer);
1178 (void) strncpy(vpd->model, buffer,
1179 (sizeof (vpd->model)-1));
1162 EMLXS_MSGF(EMLXS_CONTEXT,
1163 &emlxs_vpd_msg, "Model: %s",
1164 vpd->model);
1165 }
1166 /*
1167 * Look for program type (V3)
1168 */
1169
1170 else if (strcmp(tag, "V3") == 0) {
1180 EMLXS_MSGF(EMLXS_CONTEXT,
1181 &emlxs_vpd_msg, "Model: %s",
1182 vpd->model);
1183 }
1184 /*
1185 * Look for program type (V3)
1186 */
1187
1188 else if (strcmp(tag, "V3") == 0) {
1171 (void) strcpy(vpd->prog_types, buffer);
1189 (void) strncpy(vpd->prog_types,
1190 buffer,
1191 (sizeof (vpd->prog_types)-1));
1172 EMLXS_MSGF(EMLXS_CONTEXT,
1173 &emlxs_vpd_msg, "Prog Types: %s",
1174 vpd->prog_types);
1175 }
1176 /*
1177 * Look for port number (V4)
1178 */
1179 else if (strcmp(tag, "V4") == 0) {
1192 EMLXS_MSGF(EMLXS_CONTEXT,
1193 &emlxs_vpd_msg, "Prog Types: %s",
1194 vpd->prog_types);
1195 }
1196 /*
1197 * Look for port number (V4)
1198 */
1199 else if (strcmp(tag, "V4") == 0) {
1180 (void) strcpy(vpd->port_num, buffer);
1200 (void) strncpy(vpd->port_num, buffer,
1201 (sizeof (vpd->port_num)-1));
1181 vpd->port_index =
1182 emlxs_strtol(vpd->port_num, 10);
1183
1184 EMLXS_MSGF(EMLXS_CONTEXT,
1185 &emlxs_vpd_msg, "Port: %s",
1186 (vpd->port_num[0]) ? vpd->
1187 port_num : "not applicable");
1188 }

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

1234 */
1235extern int
1236emlxs_parse_fcoe(emlxs_hba_t *hba, uint8_t *fcoep, uint32_t size)
1237{
1238 emlxs_port_t *port = &PPORT;
1239 tlv_fcoe_t *fcoelist;
1240 tlv_fcfconnectlist_t *fcflist;
1241 int i;
1202 vpd->port_index =
1203 emlxs_strtol(vpd->port_num, 10);
1204
1205 EMLXS_MSGF(EMLXS_CONTEXT,
1206 &emlxs_vpd_msg, "Port: %s",
1207 (vpd->port_num[0]) ? vpd->
1208 port_num : "not applicable");
1209 }

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

1255 */
1256extern int
1257emlxs_parse_fcoe(emlxs_hba_t *hba, uint8_t *fcoep, uint32_t size)
1258{
1259 emlxs_port_t *port = &PPORT;
1260 tlv_fcoe_t *fcoelist;
1261 tlv_fcfconnectlist_t *fcflist;
1262 int i;
1263 uint32_t flags;
1264 uint32_t entry_count;
1265 char FabricName[32];
1266 char SwitchName[32];
1242
1243 /* Validate the config region 23 signature */
1244 if ((*fcoep != 'R') || (*(fcoep+1) != 'G') ||
1245 (*(fcoep+2) != '2') || (*(fcoep+3) != '3')) {
1246 return (0);
1247 }
1248
1249 /* Search the config region 23, for FCOE Parameters record */

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

1267 while ((i < size) && (*(fcoep+i) != 0xA1) && (*(fcoep+i) != 0xff)) {
1268 i += fcoep[i+1] * sizeof (uint32_t) + 2;
1269 }
1270
1271 if (*(fcoep+i) == 0xA1) {
1272 fcflist = (tlv_fcfconnectlist_t *)(fcoep+i);
1273 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_vpd_msg,
1274 "Found FCF ConnectList (A1):%d", fcflist->length);
1267
1268 /* Validate the config region 23 signature */
1269 if ((*fcoep != 'R') || (*(fcoep+1) != 'G') ||
1270 (*(fcoep+2) != '2') || (*(fcoep+3) != '3')) {
1271 return (0);
1272 }
1273
1274 /* Search the config region 23, for FCOE Parameters record */

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

1292 while ((i < size) && (*(fcoep+i) != 0xA1) && (*(fcoep+i) != 0xff)) {
1293 i += fcoep[i+1] * sizeof (uint32_t) + 2;
1294 }
1295
1296 if (*(fcoep+i) == 0xA1) {
1297 fcflist = (tlv_fcfconnectlist_t *)(fcoep+i);
1298 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_vpd_msg,
1299 "Found FCF ConnectList (A1):%d", fcflist->length);
1300
1275 bcopy((uint8_t *)fcflist, (uint8_t *)&hba->sli.sli4.cfgFCF,
1276 sizeof (tlv_fcfconnectlist_t));
1301 bcopy((uint8_t *)fcflist, (uint8_t *)&hba->sli.sli4.cfgFCF,
1302 sizeof (tlv_fcfconnectlist_t));
1303
1304 /* Display the list */
1305 entry_count = (hba->sli.sli4.cfgFCF.length *
1306 sizeof (uint32_t)) / sizeof (tlv_fcfconnectentry_t);
1307
1308 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_vpd_msg,
1309 "FCF List: %d entries", entry_count);
1310
1311 for (i = 0; i < entry_count; i++) {
1312 flags = *(uint32_t *)&hba->sli.sli4.cfgFCF.entry[i];
1313 (void) emlxs_wwn_xlate(FabricName, sizeof (FabricName),
1314 hba->sli.sli4.cfgFCF.entry[i].FabricName);
1315 (void) emlxs_wwn_xlate(SwitchName, sizeof (SwitchName),
1316 hba->sli.sli4.cfgFCF.entry[i].SwitchName);
1317
1318 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_vpd_msg,
1319 "FCF List:%02d %08x %s %s",
1320 i, flags, FabricName, SwitchName);
1321 }
1277 }
1278
1279 return (1);
1280
1281} /* emlxs_parse_fcoe */
1282
1283
1284extern void
1285emlxs_decode_firmware_rev(emlxs_hba_t *hba, emlxs_vpd_t *vpd)
1286{
1287 if (vpd->rBit) {
1288 switch (hba->sli_mode) {
1289 case EMLXS_HBA_SLI4_MODE:
1322 }
1323
1324 return (1);
1325
1326} /* emlxs_parse_fcoe */
1327
1328
1329extern void
1330emlxs_decode_firmware_rev(emlxs_hba_t *hba, emlxs_vpd_t *vpd)
1331{
1332 if (vpd->rBit) {
1333 switch (hba->sli_mode) {
1334 case EMLXS_HBA_SLI4_MODE:
1290 (void) strcpy(vpd->fw_version, vpd->sli4FwName);
1291 (void) strcpy(vpd->fw_label, vpd->sli4FwLabel);
1335 (void) strncpy(vpd->fw_version, vpd->sli4FwName,
1336 (sizeof (vpd->fw_version)-1));
1337 (void) strncpy(vpd->fw_label, vpd->sli4FwLabel,
1338 (sizeof (vpd->fw_label)-1));
1292 break;
1293 case EMLXS_HBA_SLI3_MODE:
1339 break;
1340 case EMLXS_HBA_SLI3_MODE:
1294 (void) strcpy(vpd->fw_version, vpd->sli3FwName);
1295 (void) strcpy(vpd->fw_label, vpd->sli3FwLabel);
1341 (void) strncpy(vpd->fw_version, vpd->sli3FwName,
1342 (sizeof (vpd->fw_version)-1));
1343 (void) strncpy(vpd->fw_label, vpd->sli3FwLabel,
1344 (sizeof (vpd->fw_label)-1));
1296 break;
1297 case EMLXS_HBA_SLI2_MODE:
1345 break;
1346 case EMLXS_HBA_SLI2_MODE:
1298 (void) strcpy(vpd->fw_version, vpd->sli2FwName);
1299 (void) strcpy(vpd->fw_label, vpd->sli2FwLabel);
1347 (void) strncpy(vpd->fw_version, vpd->sli2FwName,
1348 (sizeof (vpd->fw_version)-1));
1349 (void) strncpy(vpd->fw_label, vpd->sli2FwLabel,
1350 (sizeof (vpd->fw_label)-1));
1300 break;
1301 case EMLXS_HBA_SLI1_MODE:
1351 break;
1352 case EMLXS_HBA_SLI1_MODE:
1302 (void) strcpy(vpd->fw_version, vpd->sli1FwName);
1303 (void) strcpy(vpd->fw_label, vpd->sli1FwLabel);
1353 (void) strncpy(vpd->fw_version, vpd->sli1FwName,
1354 (sizeof (vpd->fw_version)-1));
1355 (void) strncpy(vpd->fw_label, vpd->sli1FwLabel,
1356 (sizeof (vpd->fw_label)-1));
1304 break;
1305 default:
1357 break;
1358 default:
1306 (void) strcpy(vpd->fw_version, "unknown");
1307 (void) strcpy(vpd->fw_label, vpd->fw_version);
1359 (void) strncpy(vpd->fw_version, "unknown",
1360 (sizeof (vpd->fw_version)-1));
1361 (void) strncpy(vpd->fw_label, vpd->fw_version,
1362 (sizeof (vpd->fw_label)-1));
1308 }
1309 } else {
1363 }
1364 } else {
1310 emlxs_decode_version(vpd->smFwRev, vpd->fw_version);
1311 (void) strcpy(vpd->fw_label, vpd->fw_version);
1365 emlxs_decode_version(vpd->smFwRev, vpd->fw_version,
1366 sizeof (vpd->fw_version));
1367 (void) strncpy(vpd->fw_label, vpd->fw_version,
1368 (sizeof (vpd->fw_label)-1));
1312 }
1313
1314 return;
1315
1316} /* emlxs_decode_firmware_rev() */
1317
1318
1319
1320extern void
1369 }
1370
1371 return;
1372
1373} /* emlxs_decode_firmware_rev() */
1374
1375
1376
1377extern void
1321emlxs_decode_version(uint32_t version, char *buffer)
1378emlxs_decode_version(uint32_t version, char *buffer, size_t len)
1322{
1323 uint32_t b1, b2, b3, b4;
1324 char c;
1325
1326 b1 = (version & 0x0000f000) >> 12;
1327 b2 = (version & 0x00000f00) >> 8;
1328 b3 = (version & 0x000000c0) >> 6;
1329 b4 = (version & 0x00000030) >> 4;
1330
1331 if (b1 == 0 && b2 == 0) {
1379{
1380 uint32_t b1, b2, b3, b4;
1381 char c;
1382
1383 b1 = (version & 0x0000f000) >> 12;
1384 b2 = (version & 0x00000f00) >> 8;
1385 b3 = (version & 0x000000c0) >> 6;
1386 b4 = (version & 0x00000030) >> 4;
1387
1388 if (b1 == 0 && b2 == 0) {
1332 (void) sprintf(buffer, "none");
1389 (void) snprintf(buffer, len, "none");
1333 return;
1334 }
1335
1336 c = 0;
1337 switch (b4) {
1338 case 0:
1339 c = 'n';
1340 break;

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

1349 c = 'x';
1350 }
1351 break;
1352
1353 }
1354 b4 = (version & 0x0000000f);
1355
1356 if (c == 0) {
1390 return;
1391 }
1392
1393 c = 0;
1394 switch (b4) {
1395 case 0:
1396 c = 'n';
1397 break;

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

1406 c = 'x';
1407 }
1408 break;
1409
1410 }
1411 b4 = (version & 0x0000000f);
1412
1413 if (c == 0) {
1357 (void) sprintf(buffer, "%d.%d%d", b1, b2, b3);
1414 (void) snprintf(buffer, len, "%d.%d%d", b1, b2, b3);
1358 } else {
1415 } else {
1359 (void) sprintf(buffer, "%d.%d%d%c%d", b1, b2, b3, c, b4);
1416 (void) snprintf(buffer, len, "%d.%d%d%c%d", b1, b2, b3, c, b4);
1360 }
1361
1362 return;
1363
1364} /* emlxs_decode_version() */
1365
1366
1367extern void
1417 }
1418
1419 return;
1420
1421} /* emlxs_decode_version() */
1422
1423
1424extern void
1368emlxs_decode_label(char *label, char *buffer, int bige)
1425emlxs_decode_label(char *label, char *buffer, int bige, size_t len)
1369{
1370 uint32_t i;
1371 char name[16];
1372
1426{
1427 uint32_t i;
1428 char name[16];
1429
1373 bcopy(label, name, sizeof (name));
1430 bzero(name, sizeof (name));
1431 bcopy(label, name, MIN(sizeof (name), len));
1374 /* bige is TRUE if the data format is big endian */
1375
1376 if (bige) {
1377 /* Data format big Endian */
1378 LE_SWAP32_BUFFER((uint8_t *)name, sizeof (name));
1379
1380 for (i = 0; i < sizeof (name); i++) {
1381 if (name[i] == 0x20) {

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

1388
1389 for (i = 0; i < sizeof (name); i++) {
1390 if (name[i] == 0x20) {
1391 name[i] = 0;
1392 }
1393 }
1394 }
1395
1432 /* bige is TRUE if the data format is big endian */
1433
1434 if (bige) {
1435 /* Data format big Endian */
1436 LE_SWAP32_BUFFER((uint8_t *)name, sizeof (name));
1437
1438 for (i = 0; i < sizeof (name); i++) {
1439 if (name[i] == 0x20) {

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

1446
1447 for (i = 0; i < sizeof (name); i++) {
1448 if (name[i] == 0x20) {
1449 name[i] = 0;
1450 }
1451 }
1452 }
1453
1396 (void) strcpy(buffer, name);
1454 (void) strlcpy(buffer, name, len);
1397
1398 return;
1399
1400} /* emlxs_decode_label() */
1401
1402
1403extern uint32_t
1404emlxs_strtol(char *str, uint32_t base)

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

1727 }
1728
1729 return;
1730
1731} /* emlxs_parse_prog_types() */
1732
1733
1734extern void
1455
1456 return;
1457
1458} /* emlxs_decode_label() */
1459
1460
1461extern uint32_t
1462emlxs_strtol(char *str, uint32_t base)

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

1785 }
1786
1787 return;
1788
1789} /* emlxs_parse_prog_types() */
1790
1791
1792extern void
1735emlxs_build_prog_types(emlxs_hba_t *hba, char *prog_types)
1793emlxs_build_prog_types(emlxs_hba_t *hba, emlxs_vpd_t *vpd)
1736{
1737 uint32_t i;
1738 uint32_t found = 0;
1739 char buffer[256];
1740
1794{
1795 uint32_t i;
1796 uint32_t found = 0;
1797 char buffer[256];
1798
1741 bzero(prog_types, 256);
1799 bzero(vpd->prog_types, sizeof (vpd->prog_types));
1742
1743 /* Rebuild the prog type string */
1744 if (hba->model_info.pt_2[0]) {
1800
1801 /* Rebuild the prog type string */
1802 if (hba->model_info.pt_2[0]) {
1745 (void) strcat(prog_types, "T2:");
1803 (void) strlcat(vpd->prog_types, "T2:",
1804 sizeof (vpd->prog_types));
1746 found = 1;
1747
1748 i = 0;
1805 found = 1;
1806
1807 i = 0;
1749 while (hba->model_info.pt_2[i] && i < 8) {
1750 (void) sprintf(buffer, "%X,", hba->model_info.pt_2[i]);
1751 (void) strcat(prog_types, buffer);
1808 while ((i < 8) && (hba->model_info.pt_2[i])) {
1809 (void) snprintf(buffer, sizeof (buffer), "%X,",
1810 hba->model_info.pt_2[i]);
1811 (void) strlcat(vpd->prog_types, buffer,
1812 sizeof (vpd->prog_types));
1752 i++;
1753 }
1754 }
1755
1756 if (hba->model_info.pt_3[0]) {
1813 i++;
1814 }
1815 }
1816
1817 if (hba->model_info.pt_3[0]) {
1757 (void) strcat(prog_types, "T3:");
1818 (void) strlcat(vpd->prog_types, "T3:",
1819 sizeof (vpd->prog_types));
1758 found = 1;
1759
1760 i = 0;
1820 found = 1;
1821
1822 i = 0;
1761 while (hba->model_info.pt_3[i] && i < 8) {
1762 (void) sprintf(buffer, "%X,", hba->model_info.pt_3[i]);
1763 (void) strcat(prog_types, buffer);
1823 while ((i < 8) && (hba->model_info.pt_3[i])) {
1824 (void) snprintf(buffer, sizeof (buffer), "%X,",
1825 hba->model_info.pt_3[i]);
1826 (void) strlcat(vpd->prog_types, buffer,
1827 sizeof (vpd->prog_types));
1764 i++;
1765
1766 }
1767 }
1768
1769 if (hba->model_info.pt_6[0]) {
1828 i++;
1829
1830 }
1831 }
1832
1833 if (hba->model_info.pt_6[0]) {
1770 (void) strcat(prog_types, "T6:");
1834 (void) strlcat(vpd->prog_types, "T6:",
1835 sizeof (vpd->prog_types));
1771 found = 1;
1772
1773 i = 0;
1836 found = 1;
1837
1838 i = 0;
1774 while (hba->model_info.pt_6[i] && i < 8) {
1775 (void) sprintf(buffer, "%X,", hba->model_info.pt_6[i]);
1776 (void) strcat(prog_types, buffer);
1839 while ((i < 8) && (hba->model_info.pt_6[i])) {
1840 (void) snprintf(buffer, sizeof (buffer), "%X,",
1841 hba->model_info.pt_6[i]);
1842 (void) strlcat(vpd->prog_types, buffer,
1843 sizeof (vpd->prog_types));
1777 i++;
1778 }
1779 }
1780
1781 if (hba->model_info.pt_7[0]) {
1844 i++;
1845 }
1846 }
1847
1848 if (hba->model_info.pt_7[0]) {
1782 (void) strcat(prog_types, "T7:");
1849 (void) strlcat(vpd->prog_types, "T7:",
1850 sizeof (vpd->prog_types));
1783 found = 1;
1784
1785 i = 0;
1851 found = 1;
1852
1853 i = 0;
1786 while (hba->model_info.pt_7[i] && i < 8) {
1787 (void) sprintf(buffer, "%X,", hba->model_info.pt_7[i]);
1788 (void) strcat(prog_types, buffer);
1854 while ((i < 8) && (hba->model_info.pt_7[i])) {
1855 (void) snprintf(buffer, sizeof (buffer), "%X,",
1856 hba->model_info.pt_7[i]);
1857 (void) strlcat(vpd->prog_types, buffer,
1858 sizeof (vpd->prog_types));
1789 i++;
1790 }
1791 }
1792
1793 if (hba->model_info.pt_A[0]) {
1859 i++;
1860 }
1861 }
1862
1863 if (hba->model_info.pt_A[0]) {
1794 (void) strcat(prog_types, "TA:");
1864 (void) strlcat(vpd->prog_types, "TA:",
1865 sizeof (vpd->prog_types));
1795 found = 1;
1796
1797 i = 0;
1866 found = 1;
1867
1868 i = 0;
1798 while (hba->model_info.pt_A[i] && i < 8) {
1799 (void) sprintf(buffer, "%X,", hba->model_info.pt_A[i]);
1800 (void) strcat(prog_types, buffer);
1869 while ((i < 8) && (hba->model_info.pt_A[i])) {
1870 (void) snprintf(buffer, sizeof (buffer), "%X,",
1871 hba->model_info.pt_A[i]);
1872 (void) strlcat(vpd->prog_types, buffer,
1873 sizeof (vpd->prog_types));
1801 i++;
1802 }
1803 }
1804
1805
1806 if (hba->model_info.pt_B[0]) {
1874 i++;
1875 }
1876 }
1877
1878
1879 if (hba->model_info.pt_B[0]) {
1807 (void) strcat(prog_types, "TB:");
1880 (void) strlcat(vpd->prog_types, "TB:",
1881 sizeof (vpd->prog_types));
1808 found = 1;
1809
1810 i = 0;
1882 found = 1;
1883
1884 i = 0;
1811 while (hba->model_info.pt_B[i] && i < 8) {
1812 (void) sprintf(buffer, "%X,", hba->model_info.pt_B[i]);
1813 (void) strcat(prog_types, buffer);
1885 while ((i < 8) && (hba->model_info.pt_B[i])) {
1886 (void) snprintf(buffer, sizeof (buffer), "%X,",
1887 hba->model_info.pt_B[i]);
1888 (void) strlcat(vpd->prog_types, buffer,
1889 sizeof (vpd->prog_types));
1814 i++;
1815 }
1816 }
1817
1818 if (hba->model_info.pt_20[0]) {
1890 i++;
1891 }
1892 }
1893
1894 if (hba->model_info.pt_20[0]) {
1819 (void) strcat(prog_types, "T20:");
1895 (void) strlcat(vpd->prog_types, "T20:",
1896 sizeof (vpd->prog_types));
1820 found = 1;
1821
1822 i = 0;
1897 found = 1;
1898
1899 i = 0;
1823 while (hba->model_info.pt_20[i] && i < 8) {
1824 (void) sprintf(buffer, "%X,", hba->model_info.pt_20[i]);
1825 (void) strcat(prog_types, buffer);
1900 while ((i < 8) && (hba->model_info.pt_20[i])) {
1901 (void) snprintf(buffer, sizeof (buffer), "%X,",
1902 hba->model_info.pt_20[i]);
1903 (void) strlcat(vpd->prog_types, buffer,
1904 sizeof (vpd->prog_types));
1826 i++;
1827 }
1828 }
1829
1830 if (hba->model_info.pt_FF[0]) {
1905 i++;
1906 }
1907 }
1908
1909 if (hba->model_info.pt_FF[0]) {
1831 (void) strcat(prog_types, "TFF:");
1910 (void) strlcat(vpd->prog_types, "TFF:",
1911 sizeof (vpd->prog_types));
1832 found = 1;
1833
1834 i = 0;
1912 found = 1;
1913
1914 i = 0;
1835 while (hba->model_info.pt_FF[i] && i < 8) {
1836 (void) sprintf(buffer, "%X,", hba->model_info.pt_FF[i]);
1837 (void) strcat(prog_types, buffer);
1915 while ((i < 8) && (hba->model_info.pt_FF[i])) {
1916 (void) snprintf(buffer, sizeof (buffer), "%X,",
1917 hba->model_info.pt_FF[i]);
1918 (void) strlcat(vpd->prog_types, buffer,
1919 sizeof (vpd->prog_types));
1838 i++;
1839 }
1840 }
1841
1842 if (found) {
1843 /* Terminate at the last comma in string */
1920 i++;
1921 }
1922 }
1923
1924 if (found) {
1925 /* Terminate at the last comma in string */
1844 prog_types[(strlen(prog_types) - 1)] = 0;
1926 vpd->prog_types[(strlen(vpd->prog_types) - 1)] = 0;
1845 }
1846
1847 return;
1848
1849} /* emlxs_build_prog_types() */
1850
1851
1927 }
1928
1929 return;
1930
1931} /* emlxs_build_prog_types() */
1932
1933
1852
1853
1854extern uint32_t
1855emlxs_init_adapter_info(emlxs_hba_t *hba)
1856{
1857 emlxs_port_t *port = &PPORT;
1858 uint32_t pci_id;
1859 uint32_t cache_line;
1860 uint32_t channels;
1861 uint16_t device_id;

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

1927
1928 /* Read the Cache Line reg */
1929 cache_line =
1930 ddi_get32(hba->pci_acc_handle,
1931 (uint32_t *)(hba->pci_addr + PCI_CACHE_LINE_REGISTER));
1932
1933 /* Check for the multifunction bit being set */
1934 if ((cache_line & 0x00ff0000) == 0x00800000) {
1934extern uint32_t
1935emlxs_init_adapter_info(emlxs_hba_t *hba)
1936{
1937 emlxs_port_t *port = &PPORT;
1938 uint32_t pci_id;
1939 uint32_t cache_line;
1940 uint32_t channels;
1941 uint16_t device_id;

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

2007
2008 /* Read the Cache Line reg */
2009 cache_line =
2010 ddi_get32(hba->pci_acc_handle,
2011 (uint32_t *)(hba->pci_addr + PCI_CACHE_LINE_REGISTER));
2012
2013 /* Check for the multifunction bit being set */
2014 if ((cache_line & 0x00ff0000) == 0x00800000) {
1935 channels = 2;
2015 channels = EMLXS_MULTI_CHANNEL;
1936 } else {
2016 } else {
1937 channels = 1;
2017 channels = EMLXS_SINGLE_CHANNEL;
1938 }
1939
1940 /* If device ids are unique, then use them for search */
1941 if (device_id != ssdid) {
2018 }
2019
2020 /* If device ids are unique, then use them for search */
2021 if (device_id != ssdid) {
1942 if (channels > 1) {
1943 /*
1944 * Find matching adapter model using
1945 * device_id, ssdid and channels
1946 */
1947 for (i = 1; i < emlxs_pci_model_count; i++) {
1948 if (emlxs_pci_model[i].device_id ==
1949 device_id &&
1950 emlxs_pci_model[i].ssdid == ssdid &&
1951 emlxs_pci_model[i].channels ==
1952 channels) {
1953 bcopy(&emlxs_pci_model[i],
1954 &hba->model_info,
1955 sizeof (emlxs_model_t));
1956 found = 1;
1957 break;
1958 }
2022 /*
2023 * Find matching adapter model using
2024 * device_id, ssdid, and channels
2025 */
2026 for (i = 1; i < emlxs_pci_model_count; i++) {
2027 if (emlxs_pci_model[i].device_id ==
2028 device_id &&
2029 emlxs_pci_model[i].ssdid == ssdid &&
2030 emlxs_pci_model[i].channels ==
2031 channels) {
2032 bcopy(&emlxs_pci_model[i],
2033 &hba->model_info,
2034 sizeof (emlxs_model_t));
2035 found = 1;
2036 break;
1959 }
2037 }
1960 } else {
1961 /*
1962 * Find matching adapter model using
1963 * device_id and ssdid
1964 */
1965 for (i = 1; i < emlxs_pci_model_count; i++) {
1966 if (emlxs_pci_model[i].device_id ==
1967 device_id &&
1968 emlxs_pci_model[i].ssdid == ssdid) {
1969 bcopy(&emlxs_pci_model[i],
1970 &hba->model_info,
1971 sizeof (emlxs_model_t));
1972 found = 1;
1973 break;
1974 }
1975 }
1976 }
1977 }
1978
1979 /* If adapter not found, try again */
1980 if (!found) {
2038 }
2039 }
2040
2041 /* If adapter not found, try again */
2042 if (!found) {
1981 /* Find matching adapter model */
2043 /*
2044 * Find matching adapter model using
2045 * device_id and channels
2046 */
1982 for (i = 1; i < emlxs_pci_model_count; i++) {
1983 if (emlxs_pci_model[i].device_id == device_id &&
1984 emlxs_pci_model[i].channels == channels) {
1985 bcopy(&emlxs_pci_model[i],
1986 &hba->model_info,
1987 sizeof (emlxs_model_t));
1988 found = 1;
1989 break;
1990 }
1991 }
1992 }
1993
1994 /* If adapter not found, try one last time */
1995 if (!found) {
2047 for (i = 1; i < emlxs_pci_model_count; i++) {
2048 if (emlxs_pci_model[i].device_id == device_id &&
2049 emlxs_pci_model[i].channels == channels) {
2050 bcopy(&emlxs_pci_model[i],
2051 &hba->model_info,
2052 sizeof (emlxs_model_t));
2053 found = 1;
2054 break;
2055 }
2056 }
2057 }
2058
2059 /* If adapter not found, try one last time */
2060 if (!found) {
1996 /* Find matching adapter model */
2061 /*
2062 * Find matching adapter model using
2063 * device_id only
2064 */
1997 for (i = 1; i < emlxs_pci_model_count; i++) {
1998 if (emlxs_pci_model[i].device_id == device_id) {
1999 bcopy(&emlxs_pci_model[i],
2000 &hba->model_info,
2001 sizeof (emlxs_model_t));
2002 found = 1;
2003 break;
2004 }

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

2038 }
2039
2040 /* Verify MSI-X support */
2041 if ((hba->model_info.flags & EMLXS_MSIX_SUPPORTED) &&
2042 !hba->pci_cap_offset[PCI_CAP_ID_MSI_X]) {
2043 hba->model_info.flags &= ~EMLXS_MSIX_SUPPORTED;
2044 }
2045#endif /* MSI_SUPPORT */
2065 for (i = 1; i < emlxs_pci_model_count; i++) {
2066 if (emlxs_pci_model[i].device_id == device_id) {
2067 bcopy(&emlxs_pci_model[i],
2068 &hba->model_info,
2069 sizeof (emlxs_model_t));
2070 found = 1;
2071 break;
2072 }

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

2106 }
2107
2108 /* Verify MSI-X support */
2109 if ((hba->model_info.flags & EMLXS_MSIX_SUPPORTED) &&
2110 !hba->pci_cap_offset[PCI_CAP_ID_MSI_X]) {
2111 hba->model_info.flags &= ~EMLXS_MSIX_SUPPORTED;
2112 }
2113#endif /* MSI_SUPPORT */
2114
2115 /* Set the sli_intf value */
2116 if (hba->pci_cap_offset[PCI_CAP_ID_VS]) {
2117 /* Save the SLI_INTF register, this contains */
2118 /* information about the BAR register layout */
2119 /* and other HBA information. */
2120 hba->sli_intf =
2121 ddi_get32(hba->pci_acc_handle,
2122 (uint32_t *)(hba->pci_addr +
2123 hba->pci_cap_offset[PCI_CAP_ID_VS] +
2124 PCI_VS_SLI_INTF_OFFSET));
2125
2126 EMLXS_MSGF(EMLXS_CONTEXT,
2127 &emlxs_init_debug_msg, "PCI_CAP_ID_VS: "
2128 "SLI_INTF:%08x",
2129 hba->sli_intf);
2130
2131 /* Check validity */
2132 if ((hba->sli_intf & SLI_INTF_VALID_MASK) !=
2133 SLI_INTF_VALID) {
2134 hba->sli_intf = 0;
2135 }
2136 }
2046 }
2047
2048 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, hba->dip, 0,
2049 "reg", &prop, &num_prop) == DDI_PROP_SUCCESS) {
2050 /* Parse the property for PCI function, device and bus no. */
2051 hba->pci_function_number =
2052 (uint8_t)((prop[0] & 0x00000700) >> 8);
2137 }
2138
2139 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, hba->dip, 0,
2140 "reg", &prop, &num_prop) == DDI_PROP_SUCCESS) {
2141 /* Parse the property for PCI function, device and bus no. */
2142 hba->pci_function_number =
2143 (uint8_t)((prop[0] & 0x00000700) >> 8);
2053 hba->pci_device_number = (uint8_t)((prop[0] & 0x00008100) >> 8);
2144 hba->pci_device_number =
2145 (uint8_t)((prop[0] & 0x0000f800) >> 11);
2054 hba->pci_bus_number = (uint8_t)((prop[0] & 0x00ff0000) >> 16);
2055 ddi_prop_free((void *)prop);
2056 }
2057
2146 hba->pci_bus_number = (uint8_t)((prop[0] & 0x00ff0000) >> 16);
2147 ddi_prop_free((void *)prop);
2148 }
2149
2058 if (hba->model_info.sli_mask & EMLXS_SLI4_MASK) {
2059 hba->sli_api = emlxs_sli4_api;
2060 } else {
2150 switch (hba->sli_intf & SLI_INTF_SLI_REV_MASK) {
2151 case SLI_INTF_SLI_REV_NONE: /* Legacy support */
2152 if (hba->model_info.sli_mask & EMLXS_SLI4_MASK) {
2153 hba->sli_api = emlxs_sli4_api;
2154 } else {
2155 hba->sli_api = emlxs_sli3_api;
2156 }
2157 break;
2158
2159 case SLI_INTF_SLI_REV_3:
2160 if (!(hba->model_info.sli_mask & EMLXS_SLI3_MASK)) {
2161 EMLXS_MSGF(EMLXS_CONTEXT,
2162 &emlxs_init_failed_msg,
2163 "Adapter does not support SLI3 interface. "
2164 "sli_intf=%08x sli_mask=%08x",
2165 hba->sli_intf, hba->model_info.sli_mask);
2166 return (0);
2167 }
2061 hba->sli_api = emlxs_sli3_api;
2168 hba->sli_api = emlxs_sli3_api;
2169 break;
2170
2171 case SLI_INTF_SLI_REV_4:
2172 if (!(hba->model_info.sli_mask & EMLXS_SLI4_MASK)) {
2173 EMLXS_MSGF(EMLXS_CONTEXT,
2174 &emlxs_init_failed_msg,
2175 "Adapter does not support SLI4 interface. "
2176 "sli_intf=%08x sli_mask=%08x",
2177 hba->sli_intf, hba->model_info.sli_mask);
2178 return (0);
2179 }
2180 hba->sli_api = emlxs_sli4_api;
2181 break;
2182
2183 default:
2184 EMLXS_MSGF(EMLXS_CONTEXT,
2185 &emlxs_init_failed_msg,
2186 "Invalid SLI interface specified. "
2187 "sli_intf=%08x sli_mask=%08x",
2188 hba->sli_intf, hba->model_info.sli_mask);
2189 return (0);
2062 }
2063
2064#ifdef FMA_SUPPORT
2065 if (emlxs_fm_check_acc_handle(hba, hba->pci_acc_handle)
2066 != DDI_FM_OK) {
2067 EMLXS_MSGF(EMLXS_CONTEXT,
2068 &emlxs_invalid_access_handle_msg, NULL);
2069 return (0);

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

2179 }
2180 hba->flag |= FC_SHUTDOWN;
2181 mutex_exit(&EMLXS_PORT_LOCK);
2182
2183 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_adapter_trans_msg,
2184 "Shutting down...");
2185
2186 /* Take adapter offline and leave it there */
2190 }
2191
2192#ifdef FMA_SUPPORT
2193 if (emlxs_fm_check_acc_handle(hba, hba->pci_acc_handle)
2194 != DDI_FM_OK) {
2195 EMLXS_MSGF(EMLXS_CONTEXT,
2196 &emlxs_invalid_access_handle_msg, NULL);
2197 return (0);

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

2307 }
2308 hba->flag |= FC_SHUTDOWN;
2309 mutex_exit(&EMLXS_PORT_LOCK);
2310
2311 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_adapter_trans_msg,
2312 "Shutting down...");
2313
2314 /* Take adapter offline and leave it there */
2187 (void) emlxs_offline(hba);
2315 (void) emlxs_offline(hba, 0);
2188
2189 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
2190 /*
2191 * Dump is not defined for SLI4, so just
2192 * reset the HBA for now.
2193 */
2194 EMLXS_SLI_HBA_RESET(hba, 1, 1, 0);
2195

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

2213extern void
2214emlxs_proc_channel(emlxs_hba_t *hba, CHANNEL *cp, void *arg2)
2215{
2216 IOCBQ *iocbq;
2217 IOCBQ *rsp_head;
2218
2219 /*
2220 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
2316
2317 if (hba->sli_mode == EMLXS_HBA_SLI4_MODE) {
2318 /*
2319 * Dump is not defined for SLI4, so just
2320 * reset the HBA for now.
2321 */
2322 EMLXS_SLI_HBA_RESET(hba, 1, 1, 0);
2323

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

2341extern void
2342emlxs_proc_channel(emlxs_hba_t *hba, CHANNEL *cp, void *arg2)
2343{
2344 IOCBQ *iocbq;
2345 IOCBQ *rsp_head;
2346
2347 /*
2348 * EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_sli_detail_msg,
2221 * "emlxs_proc_channel: channel=%d", cp->channelno);
2349 * "proc_channel: channel=%d", cp->channelno);
2222 */
2223
2224 mutex_enter(&cp->rsp_lock);
2225
2226 while ((rsp_head = cp->rsp_head) != NULL) {
2227 cp->rsp_head = NULL;
2228 cp->rsp_tail = NULL;
2229

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

2252 */
2253void
2254emlxs_proc_channel_event(emlxs_hba_t *hba, CHANNEL *cp, IOCBQ *iocbq)
2255{
2256 emlxs_port_t *port = &PPORT;
2257 char buffer[MAX_MSG_DATA + 1];
2258 IOCB *iocb;
2259 emlxs_buf_t *sbp;
2350 */
2351
2352 mutex_enter(&cp->rsp_lock);
2353
2354 while ((rsp_head = cp->rsp_head) != NULL) {
2355 cp->rsp_head = NULL;
2356 cp->rsp_tail = NULL;
2357

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

2380 */
2381void
2382emlxs_proc_channel_event(emlxs_hba_t *hba, CHANNEL *cp, IOCBQ *iocbq)
2383{
2384 emlxs_port_t *port = &PPORT;
2385 char buffer[MAX_MSG_DATA + 1];
2386 IOCB *iocb;
2387 emlxs_buf_t *sbp;
2388 fc_packet_t *pkt;
2260
2261 iocb = &iocbq->iocb;
2262
2263#ifdef DEBUG_CMPL_IOCB
2264 emlxs_data_dump(port, "CMPL_IOCB", (uint32_t *)iocb, 8, 0);
2265#endif
2266
2267 sbp = (emlxs_buf_t *)iocbq->sbp;
2268 if (sbp) {
2269 if (!(sbp->pkt_flags & PACKET_VALID) ||
2270 (sbp->pkt_flags & (PACKET_ULP_OWNED |
2271 PACKET_IN_COMPLETION))) {
2272 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_iocb_stale_msg,
2273 "Duplicate: iocb=%p cmd=%x status=%x "
2389
2390 iocb = &iocbq->iocb;
2391
2392#ifdef DEBUG_CMPL_IOCB
2393 emlxs_data_dump(port, "CMPL_IOCB", (uint32_t *)iocb, 8, 0);
2394#endif
2395
2396 sbp = (emlxs_buf_t *)iocbq->sbp;
2397 if (sbp) {
2398 if (!(sbp->pkt_flags & PACKET_VALID) ||
2399 (sbp->pkt_flags & (PACKET_ULP_OWNED |
2400 PACKET_IN_COMPLETION))) {
2401 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_iocb_stale_msg,
2402 "Duplicate: iocb=%p cmd=%x status=%x "
2274 "error=%x iotag=%x context=%x info=%x",
2403 "error=%x iotag=%d context=%x info=%x",
2275 iocbq, (uint8_t)iocbq->iocb.ULPCOMMAND,
2276 iocbq->iocb.ULPSTATUS,
2277 (uint8_t)iocbq->iocb.un.grsp.perr.statLocalError,
2278 (uint16_t)iocbq->iocb.ULPIOTAG,
2279 (uint16_t)iocbq->iocb.ULPCONTEXT,
2280 (uint8_t)iocbq->iocb.ULPRSVDBYTE);
2281
2282 /* Drop this IO immediately */

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

2301 IOERR_ABORT_REQUESTED;
2302 }
2303 }
2304
2305 /* Check for IOCB local error */
2306 if (iocb->ULPSTATUS == IOSTAT_LOCAL_REJECT) {
2307 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_iocb_event_msg,
2308 "Local reject. ringno=%d iocb=%p cmd=%x "
2404 iocbq, (uint8_t)iocbq->iocb.ULPCOMMAND,
2405 iocbq->iocb.ULPSTATUS,
2406 (uint8_t)iocbq->iocb.un.grsp.perr.statLocalError,
2407 (uint16_t)iocbq->iocb.ULPIOTAG,
2408 (uint16_t)iocbq->iocb.ULPCONTEXT,
2409 (uint8_t)iocbq->iocb.ULPRSVDBYTE);
2410
2411 /* Drop this IO immediately */

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

2430 IOERR_ABORT_REQUESTED;
2431 }
2432 }
2433
2434 /* Check for IOCB local error */
2435 if (iocb->ULPSTATUS == IOSTAT_LOCAL_REJECT) {
2436 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_iocb_event_msg,
2437 "Local reject. ringno=%d iocb=%p cmd=%x "
2309 "iotag=%x context=%x info=%x error=%x",
2438 "iotag=%d context=%x info=%x error=%x",
2310 cp->channelno, iocb, (uint8_t)iocb->ULPCOMMAND,
2311 (uint16_t)iocb->ULPIOTAG, (uint16_t)iocb->ULPCONTEXT,
2312 (uint8_t)iocb->ULPRSVDBYTE,
2313 (uint8_t)iocb->un.grsp.perr.statLocalError);
2314 }
2315
2316 switch (iocb->ULPCOMMAND) {
2317 /* RING 0 FCP commands */

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

2332
2333#ifdef SFCT_SUPPORT
2334 case CMD_FCP_TSEND_CX: /* FCP_TARGET IOCB command */
2335 case CMD_FCP_TSEND64_CX: /* FCP_TARGET IOCB command */
2336 case CMD_FCP_TRECEIVE_CX: /* FCP_TARGET IOCB command */
2337 case CMD_FCP_TRECEIVE64_CX: /* FCP_TARGET IOCB command */
2338 case CMD_FCP_TRSP_CX: /* FCP_TARGET IOCB command */
2339 case CMD_FCP_TRSP64_CX: /* FCP_TARGET IOCB command */
2439 cp->channelno, iocb, (uint8_t)iocb->ULPCOMMAND,
2440 (uint16_t)iocb->ULPIOTAG, (uint16_t)iocb->ULPCONTEXT,
2441 (uint8_t)iocb->ULPRSVDBYTE,
2442 (uint8_t)iocb->un.grsp.perr.statLocalError);
2443 }
2444
2445 switch (iocb->ULPCOMMAND) {
2446 /* RING 0 FCP commands */

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

2461
2462#ifdef SFCT_SUPPORT
2463 case CMD_FCP_TSEND_CX: /* FCP_TARGET IOCB command */
2464 case CMD_FCP_TSEND64_CX: /* FCP_TARGET IOCB command */
2465 case CMD_FCP_TRECEIVE_CX: /* FCP_TARGET IOCB command */
2466 case CMD_FCP_TRECEIVE64_CX: /* FCP_TARGET IOCB command */
2467 case CMD_FCP_TRSP_CX: /* FCP_TARGET IOCB command */
2468 case CMD_FCP_TRSP64_CX: /* FCP_TARGET IOCB command */
2340 (void) emlxs_fct_handle_fcp_event(hba, cp, iocbq);
2469 if (port->mode == MODE_TARGET) {
2470 (void) emlxs_fct_handle_fcp_event(hba, cp, iocbq);
2471 }
2341 break;
2342#endif /* SFCT_SUPPORT */
2343
2344 /* RING 1 IP commands */
2345 case CMD_XMIT_BCAST_CN:
2346 case CMD_XMIT_BCAST_CX:
2347 case CMD_XMIT_BCAST64_CN:
2348 case CMD_XMIT_BCAST64_CX:

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

2359 break;
2360
2361 case FC_TYPE_FC_SERVICES:
2362 (void) emlxs_ct_handle_event(hba, cp, iocbq);
2363 break;
2364
2365 default:
2366 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_iocb_invalid_msg,
2472 break;
2473#endif /* SFCT_SUPPORT */
2474
2475 /* RING 1 IP commands */
2476 case CMD_XMIT_BCAST_CN:
2477 case CMD_XMIT_BCAST_CX:
2478 case CMD_XMIT_BCAST64_CN:
2479 case CMD_XMIT_BCAST64_CX:

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

2490 break;
2491
2492 case FC_TYPE_FC_SERVICES:
2493 (void) emlxs_ct_handle_event(hba, cp, iocbq);
2494 break;
2495
2496 default:
2497 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_iocb_invalid_msg,
2367 "cmd=%x type=%x status=%x iotag=%x context=%x ",
2498 "cmd=%x type=%x status=%x iotag=%d context=%x ",
2368 iocb->ULPCOMMAND, iocb->un.rcvseq64.w5.hcsw.Type,
2369 iocb->ULPSTATUS, iocb->ULPIOTAG,
2370 iocb->ULPCONTEXT);
2371 }
2372 break;
2373
2374 case CMD_RCV_SEQUENCE_CX:
2375 case CMD_RCV_SEQUENCE64_CX:

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

2412#endif /* MENLO_SUPPORT */
2413
2414 case FC_TYPE_FC_SERVICES:
2415 (void) emlxs_ct_handle_event(hba, cp, iocbq);
2416 break;
2417
2418 default:
2419 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_iocb_invalid_msg,
2499 iocb->ULPCOMMAND, iocb->un.rcvseq64.w5.hcsw.Type,
2500 iocb->ULPSTATUS, iocb->ULPIOTAG,
2501 iocb->ULPCONTEXT);
2502 }
2503 break;
2504
2505 case CMD_RCV_SEQUENCE_CX:
2506 case CMD_RCV_SEQUENCE64_CX:

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

2543#endif /* MENLO_SUPPORT */
2544
2545 case FC_TYPE_FC_SERVICES:
2546 (void) emlxs_ct_handle_event(hba, cp, iocbq);
2547 break;
2548
2549 default:
2550 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_iocb_invalid_msg,
2420 "cmd=%x type=%x status=%x iotag=%x context=%x ",
2551 "cmd=%x type=%x status=%x iotag=%d context=%x ",
2421 iocb->ULPCOMMAND, iocb->un.rcvseq64.w5.hcsw.Type,
2422 iocb->ULPSTATUS, iocb->ULPIOTAG,
2423 iocb->ULPCONTEXT);
2424 }
2425 break;
2426
2427 case CMD_ABORT_XRI_CN: /* Abort fcp command */
2428
2429 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_flushed_msg,
2552 iocb->ULPCOMMAND, iocb->un.rcvseq64.w5.hcsw.Type,
2553 iocb->ULPSTATUS, iocb->ULPIOTAG,
2554 iocb->ULPCONTEXT);
2555 }
2556 break;
2557
2558 case CMD_ABORT_XRI_CN: /* Abort fcp command */
2559
2560 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_flushed_msg,
2430 "ABORT_XRI_CN: rpi=%d iotag=%x status=%x parm=%x",
2561 "ABORT_XRI_CN: rpi=%d iotag=%d status=%x parm=%x",
2431 (uint32_t)iocb->un.acxri.abortContextTag,
2432 (uint32_t)iocb->un.acxri.abortIoTag, iocb->ULPSTATUS,
2433 iocb->un.acxri.parm);
2434
2435#ifdef SFCT_SUPPORT
2562 (uint32_t)iocb->un.acxri.abortContextTag,
2563 (uint32_t)iocb->un.acxri.abortIoTag, iocb->ULPSTATUS,
2564 iocb->un.acxri.parm);
2565
2566#ifdef SFCT_SUPPORT
2436 if (port->tgt_mode) {
2567 if (port->mode == MODE_TARGET) {
2437 (void) emlxs_fct_handle_abort(hba, cp, iocbq);
2438 }
2439#endif /* SFCT_SUPPORT */
2440 break;
2441
2442 case CMD_ABORT_XRI_CX: /* Abort command */
2443
2444 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_flushed_msg,
2568 (void) emlxs_fct_handle_abort(hba, cp, iocbq);
2569 }
2570#endif /* SFCT_SUPPORT */
2571 break;
2572
2573 case CMD_ABORT_XRI_CX: /* Abort command */
2574
2575 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_flushed_msg,
2445 "ABORT_XRI_CX: rpi=%d iotag=%x status=%x parm=%x sbp=%p",
2576 "ABORT_XRI_CX: rpi=%d iotag=%d status=%x parm=%x sbp=%p",
2446 (uint32_t)iocb->un.acxri.abortContextTag,
2447 (uint32_t)iocb->un.acxri.abortIoTag, iocb->ULPSTATUS,
2448 iocb->un.acxri.parm, iocbq->sbp);
2449
2450#ifdef SFCT_SUPPORT
2577 (uint32_t)iocb->un.acxri.abortContextTag,
2578 (uint32_t)iocb->un.acxri.abortIoTag, iocb->ULPSTATUS,
2579 iocb->un.acxri.parm, iocbq->sbp);
2580
2581#ifdef SFCT_SUPPORT
2451 if (port->tgt_mode) {
2582 if (port->mode == MODE_TARGET) {
2452 (void) emlxs_fct_handle_abort(hba, cp, iocbq);
2453 }
2454#endif /* SFCT_SUPPORT */
2455 break;
2456
2457 case CMD_XRI_ABORTED_CX: /* Handle ABORT condition */
2458
2459 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_flushed_msg,
2583 (void) emlxs_fct_handle_abort(hba, cp, iocbq);
2584 }
2585#endif /* SFCT_SUPPORT */
2586 break;
2587
2588 case CMD_XRI_ABORTED_CX: /* Handle ABORT condition */
2589
2590 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_flushed_msg,
2460 "XRI_ABORTED_CX: rpi=%d iotag=%x status=%x parm=%x",
2591 "XRI_ABORTED_CX: rpi=%d iotag=%d status=%x parm=%x",
2461 (uint32_t)iocb->un.acxri.abortContextTag,
2462 (uint32_t)iocb->un.acxri.abortIoTag, iocb->ULPSTATUS,
2463 iocb->un.acxri.parm);
2464
2465#ifdef SFCT_SUPPORT
2592 (uint32_t)iocb->un.acxri.abortContextTag,
2593 (uint32_t)iocb->un.acxri.abortIoTag, iocb->ULPSTATUS,
2594 iocb->un.acxri.parm);
2595
2596#ifdef SFCT_SUPPORT
2466 if (port->tgt_mode) {
2597 if (port->mode == MODE_TARGET) {
2467 (void) emlxs_fct_handle_abort(hba, cp, iocbq);
2468 }
2469#endif /* SFCT_SUPPORT */
2470 break;
2471
2472 case CMD_CLOSE_XRI_CN: /* Handle CLOSE condition */
2473
2474 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_flushed_msg,
2598 (void) emlxs_fct_handle_abort(hba, cp, iocbq);
2599 }
2600#endif /* SFCT_SUPPORT */
2601 break;
2602
2603 case CMD_CLOSE_XRI_CN: /* Handle CLOSE condition */
2604
2605 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_flushed_msg,
2475 "CLOSE_XRI_CN: rpi=%d iotag=%x status=%x parm=%x",
2606 "CLOSE_XRI_CN: rpi=%d iotag=%d status=%x parm=%x",
2476 (uint32_t)iocb->un.acxri.abortContextTag,
2477 (uint32_t)iocb->un.acxri.abortIoTag, iocb->ULPSTATUS,
2478 iocb->un.acxri.parm);
2479
2480#ifdef SFCT_SUPPORT
2607 (uint32_t)iocb->un.acxri.abortContextTag,
2608 (uint32_t)iocb->un.acxri.abortIoTag, iocb->ULPSTATUS,
2609 iocb->un.acxri.parm);
2610
2611#ifdef SFCT_SUPPORT
2481 if (port->tgt_mode) {
2612 if (port->mode == MODE_TARGET) {
2482 (void) emlxs_fct_handle_abort(hba, cp, iocbq);
2483 }
2484#endif /* SFCT_SUPPORT */
2485 break;
2486
2487 case CMD_CLOSE_XRI_CX: /* Handle CLOSE condition */
2488
2489 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_flushed_msg,
2613 (void) emlxs_fct_handle_abort(hba, cp, iocbq);
2614 }
2615#endif /* SFCT_SUPPORT */
2616 break;
2617
2618 case CMD_CLOSE_XRI_CX: /* Handle CLOSE condition */
2619
2620 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_flushed_msg,
2490 "CLOSE_XRI_CX: rpi=%d iotag=%x status=%x parm=%x sbp=%p",
2621 "CLOSE_XRI_CX: rpi=%d iotag=%d status=%x parm=%x sbp=%p",
2491 (uint32_t)iocb->un.acxri.abortContextTag,
2492 (uint32_t)iocb->un.acxri.abortIoTag, iocb->ULPSTATUS,
2493 iocb->un.acxri.parm, iocbq->sbp);
2494
2495#ifdef SFCT_SUPPORT
2622 (uint32_t)iocb->un.acxri.abortContextTag,
2623 (uint32_t)iocb->un.acxri.abortIoTag, iocb->ULPSTATUS,
2624 iocb->un.acxri.parm, iocbq->sbp);
2625
2626#ifdef SFCT_SUPPORT
2496 if (port->tgt_mode) {
2627 if (port->mode == MODE_TARGET) {
2497 (void) emlxs_fct_handle_abort(hba, cp, iocbq);
2498 }
2499#endif /* SFCT_SUPPORT */
2500 break;
2501
2502 case CMD_ADAPTER_MSG:
2503 /* Allows debug adapter firmware messages to print on host */
2504 bzero(buffer, sizeof (buffer));

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

2511 case CMD_QUE_RING_LIST64_CN:
2512 case CMD_QUE_RING_BUF64_CN:
2513 break;
2514
2515 case CMD_ASYNC_STATUS:
2516 emlxs_handle_async_event(hba, cp, iocbq);
2517 break;
2518
2628 (void) emlxs_fct_handle_abort(hba, cp, iocbq);
2629 }
2630#endif /* SFCT_SUPPORT */
2631 break;
2632
2633 case CMD_ADAPTER_MSG:
2634 /* Allows debug adapter firmware messages to print on host */
2635 bzero(buffer, sizeof (buffer));

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

2642 case CMD_QUE_RING_LIST64_CN:
2643 case CMD_QUE_RING_BUF64_CN:
2644 break;
2645
2646 case CMD_ASYNC_STATUS:
2647 emlxs_handle_async_event(hba, cp, iocbq);
2648 break;
2649
2650 case CMD_XMIT_BLS_RSP64_CX:
2651 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_pkt_flushed_msg,
2652 "CMD_XMIT_BLS_RSP64_CX: sbp = %p", sbp);
2653
2654 /*
2655 * The exchange should have been already freed in the wqe_cmpl
2656 * so just free up the pkt here.
2657 */
2658 pkt = PRIV2PKT(sbp);
2659 emlxs_pkt_free(pkt);
2660 break;
2661
2519 default:
2662 default:
2663 if (iocb->ULPCOMMAND == 0) {
2664 break;
2665 }
2666
2520 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_iocb_invalid_msg,
2667 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_iocb_invalid_msg,
2521 "cmd=%x status=%x iotag=%x context=%x", iocb->ULPCOMMAND,
2668 "cmd=%x status=%x iotag=%d context=%x", iocb->ULPCOMMAND,
2522 iocb->ULPSTATUS, iocb->ULPIOTAG, iocb->ULPCONTEXT);
2523
2524 break;
2525 } /* switch(entry->ULPCOMMAND) */
2526
2527 return;
2528
2529} /* emlxs_proc_channel_event() */

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

2538
2539 count = sizeof (emlxs_ffstate_table) / sizeof (emlxs_table_t);
2540 for (i = 0; i < count; i++) {
2541 if (state == emlxs_ffstate_table[i].code) {
2542 return (emlxs_ffstate_table[i].string);
2543 }
2544 }
2545
2669 iocb->ULPSTATUS, iocb->ULPIOTAG, iocb->ULPCONTEXT);
2670
2671 break;
2672 } /* switch(entry->ULPCOMMAND) */
2673
2674 return;
2675
2676} /* emlxs_proc_channel_event() */

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

2685
2686 count = sizeof (emlxs_ffstate_table) / sizeof (emlxs_table_t);
2687 for (i = 0; i < count; i++) {
2688 if (state == emlxs_ffstate_table[i].code) {
2689 return (emlxs_ffstate_table[i].string);
2690 }
2691 }
2692
2546 (void) sprintf(buffer, "state=0x%x", state);
2693 (void) snprintf(buffer, sizeof (buffer), "state=0x%x", state);
2547 return (buffer);
2548
2549} /* emlxs_ffstate_xlate() */
2550
2551
2552extern char *
2553emlxs_ring_xlate(uint32_t ringno)
2554{
2555 static char buffer[32];
2556 uint32_t i;
2557 uint32_t count;
2558
2559 count = sizeof (emlxs_ring_table) / sizeof (emlxs_table_t);
2560 for (i = 0; i < count; i++) {
2561 if (ringno == emlxs_ring_table[i].code) {
2562 return (emlxs_ring_table[i].string);
2563 }
2564 }
2565
2694 return (buffer);
2695
2696} /* emlxs_ffstate_xlate() */
2697
2698
2699extern char *
2700emlxs_ring_xlate(uint32_t ringno)
2701{
2702 static char buffer[32];
2703 uint32_t i;
2704 uint32_t count;
2705
2706 count = sizeof (emlxs_ring_table) / sizeof (emlxs_table_t);
2707 for (i = 0; i < count; i++) {
2708 if (ringno == emlxs_ring_table[i].code) {
2709 return (emlxs_ring_table[i].string);
2710 }
2711 }
2712
2566 (void) sprintf(buffer, "ring=0x%x", ringno);
2713 (void) snprintf(buffer, sizeof (buffer), "ring=0x%x", ringno);
2567 return (buffer);
2568
2569} /* emlxs_ring_xlate() */
2570
2571
2572extern char *
2573emlxs_pci_cap_xlate(uint32_t id)
2574{
2575 static char buffer[32];
2576 uint32_t i;
2577 uint32_t count;
2578
2579 count = sizeof (emlxs_pci_cap) / sizeof (emlxs_table_t);
2580 for (i = 0; i < count; i++) {
2581 if (id == emlxs_pci_cap[i].code) {
2582 return (emlxs_pci_cap[i].string);
2583 }
2584 }
2585
2714 return (buffer);
2715
2716} /* emlxs_ring_xlate() */
2717
2718
2719extern char *
2720emlxs_pci_cap_xlate(uint32_t id)
2721{
2722 static char buffer[32];
2723 uint32_t i;
2724 uint32_t count;
2725
2726 count = sizeof (emlxs_pci_cap) / sizeof (emlxs_table_t);
2727 for (i = 0; i < count; i++) {
2728 if (id == emlxs_pci_cap[i].code) {
2729 return (emlxs_pci_cap[i].string);
2730 }
2731 }
2732
2586 (void) sprintf(buffer, "PCI_CAP_ID_%02X", id);
2733 (void) snprintf(buffer, sizeof (buffer), "PCI_CAP_ID_%02X", id);
2587 return (buffer);
2588
2589} /* emlxs_pci_cap_xlate() */
2590
2591
2734 return (buffer);
2735
2736} /* emlxs_pci_cap_xlate() */
2737
2738
2739extern char *
2740emlxs_pci_ecap_xlate(uint32_t id)
2741{
2742 static char buffer[32];
2743 uint32_t i;
2744 uint32_t count;
2745
2746 count = sizeof (emlxs_pci_ecap) / sizeof (emlxs_table_t);
2747 for (i = 0; i < count; i++) {
2748 if (id == emlxs_pci_ecap[i].code) {
2749 return (emlxs_pci_ecap[i].string);
2750 }
2751 }
2752
2753 (void) snprintf(buffer, sizeof (buffer), "PCI_EXT_CAP_ID_%02X", id);
2754 return (buffer);
2755
2756} /* emlxs_pci_ecap_xlate() */
2757
2758
2592extern void
2593emlxs_pcix_mxr_update(emlxs_hba_t *hba, uint32_t verbose)
2594{
2595 emlxs_port_t *port = &PPORT;
2596 MAILBOXQ *mbq;
2597 MAILBOX *mb;
2598 emlxs_config_t *cfg;
2599 uint32_t value;

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

2623 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
2624 "PCI_MAX_READ: Invalid parameter value. old=%d new=%d",
2625 cfg[CFG_PCI_MAX_READ].current, cfg[CFG_PCI_MAX_READ].def);
2626
2627 cfg[CFG_PCI_MAX_READ].current = cfg[CFG_PCI_MAX_READ].def;
2628 goto xlate;
2629 }
2630
2759extern void
2760emlxs_pcix_mxr_update(emlxs_hba_t *hba, uint32_t verbose)
2761{
2762 emlxs_port_t *port = &PPORT;
2763 MAILBOXQ *mbq;
2764 MAILBOX *mb;
2765 emlxs_config_t *cfg;
2766 uint32_t value;

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

2790 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
2791 "PCI_MAX_READ: Invalid parameter value. old=%d new=%d",
2792 cfg[CFG_PCI_MAX_READ].current, cfg[CFG_PCI_MAX_READ].def);
2793
2794 cfg[CFG_PCI_MAX_READ].current = cfg[CFG_PCI_MAX_READ].def;
2795 goto xlate;
2796 }
2797
2631 if ((mbq = (MAILBOXQ *)emlxs_mem_get(hba, MEM_MBOX, 1)) == 0) {
2798 if ((mbq = (MAILBOXQ *) kmem_zalloc((sizeof (MAILBOXQ)),
2799 KM_SLEEP)) == 0) {
2632 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
2633 "PCI_MAX_READ: Unable to allocate mailbox buffer.");
2634 return;
2635 }
2636 mb = (MAILBOX *)mbq;
2637
2638 emlxs_mb_set_var(hba, mbq, 0x00100506, value);
2639

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

2650 (cfg[CFG_PCI_MAX_READ].current !=
2651 cfg[CFG_PCI_MAX_READ].def)) {
2652 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
2653 "PCI_MAX_READ: Updated. %d bytes",
2654 cfg[CFG_PCI_MAX_READ].current);
2655 }
2656 }
2657
2800 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
2801 "PCI_MAX_READ: Unable to allocate mailbox buffer.");
2802 return;
2803 }
2804 mb = (MAILBOX *)mbq;
2805
2806 emlxs_mb_set_var(hba, mbq, 0x00100506, value);
2807

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

2818 (cfg[CFG_PCI_MAX_READ].current !=
2819 cfg[CFG_PCI_MAX_READ].def)) {
2820 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
2821 "PCI_MAX_READ: Updated. %d bytes",
2822 cfg[CFG_PCI_MAX_READ].current);
2823 }
2824 }
2825
2658 emlxs_mem_put(hba, MEM_MBOX, (void *)mbq);
2826 (void) kmem_free((uint8_t *)mbq, sizeof (MAILBOXQ));
2659
2660 return;
2661
2662} /* emlxs_pcix_mxr_update */
2663
2664
2665
2666extern uint32_t

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

2730
2731#ifdef MODFW_SUPPORT
2732extern void
2733emlxs_fw_load(emlxs_hba_t *hba, emlxs_firmware_t *fw)
2734{
2735 emlxs_port_t *port = &PPORT;
2736 int (*emlxs_fw_get)(emlxs_firmware_t *);
2737 int err;
2827
2828 return;
2829
2830} /* emlxs_pcix_mxr_update */
2831
2832
2833
2834extern uint32_t

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

2898
2899#ifdef MODFW_SUPPORT
2900extern void
2901emlxs_fw_load(emlxs_hba_t *hba, emlxs_firmware_t *fw)
2902{
2903 emlxs_port_t *port = &PPORT;
2904 int (*emlxs_fw_get)(emlxs_firmware_t *);
2905 int err;
2906 char name[64];
2738
2739 /* Make sure image is unloaded and image buffer pointer is clear */
2740 emlxs_fw_unload(hba, fw);
2741
2742 err = 0;
2743 hba->fw_modhandle =
2744 ddi_modopen(EMLXS_FW_MODULE, KRTLD_MODE_FIRST, &err);
2745 if (!hba->fw_modhandle) {
2746 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
2747 "Unable to load firmware module. error=%d", err);
2748
2749 return;
2750 } else {
2751 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg,
2752 "Firmware module loaded.");
2753 }
2754
2907
2908 /* Make sure image is unloaded and image buffer pointer is clear */
2909 emlxs_fw_unload(hba, fw);
2910
2911 err = 0;
2912 hba->fw_modhandle =
2913 ddi_modopen(EMLXS_FW_MODULE, KRTLD_MODE_FIRST, &err);
2914 if (!hba->fw_modhandle) {
2915 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
2916 "Unable to load firmware module. error=%d", err);
2917
2918 return;
2919 } else {
2920 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_msg,
2921 "Firmware module loaded.");
2922 }
2923
2924 (void) snprintf(name, sizeof (name), "%s_fw_get", DRIVER_NAME);
2755 err = 0;
2756 emlxs_fw_get =
2925 err = 0;
2926 emlxs_fw_get =
2757 (int (*)())ddi_modsym(hba->fw_modhandle, "emlxs_fw_get", &err);
2927 (int (*)())ddi_modsym(hba->fw_modhandle, name, &err);
2758 if ((void *)emlxs_fw_get == NULL) {
2759 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
2928 if ((void *)emlxs_fw_get == NULL) {
2929 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
2760 "emlxs_fw_get not present. error=%d", err);
2930 "%s not present. error=%d", name, err);
2761
2762 emlxs_fw_unload(hba, fw);
2763 return;
2764 }
2765
2766 if (emlxs_fw_get(fw)) {
2767 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
2768 "Invalid firmware image module found. %s", fw->label);

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

2799} /* emlxs_fw_unload() */
2800#endif /* MODFW_SUPPORT */
2801
2802
2803static void
2804emlxs_pci_cap_offsets(emlxs_hba_t *hba)
2805{
2806 emlxs_port_t *port = &PPORT;
2931
2932 emlxs_fw_unload(hba, fw);
2933 return;
2934 }
2935
2936 if (emlxs_fw_get(fw)) {
2937 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_failed_msg,
2938 "Invalid firmware image module found. %s", fw->label);

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

2969} /* emlxs_fw_unload() */
2970#endif /* MODFW_SUPPORT */
2971
2972
2973static void
2974emlxs_pci_cap_offsets(emlxs_hba_t *hba)
2975{
2976 emlxs_port_t *port = &PPORT;
2977 uint32_t reg;
2807 uint8_t offset;
2978 uint8_t offset;
2979 uint8_t next;
2808 uint8_t id;
2980 uint8_t id;
2981 uint16_t eoffset;
2982 uint16_t enext;
2983 uint8_t eversion;
2984 uint16_t eid;
2809
2985
2986 /* Read PCI capbabilities */
2987
2810 bzero(hba->pci_cap_offset, sizeof (hba->pci_cap_offset));
2811
2812 /* Read first offset */
2988 bzero(hba->pci_cap_offset, sizeof (hba->pci_cap_offset));
2989
2990 /* Read first offset */
2991 offset = PCI_CAP_POINTER;
2813 offset = ddi_get8(hba->pci_acc_handle,
2992 offset = ddi_get8(hba->pci_acc_handle,
2814 (uint8_t *)(hba->pci_addr + PCI_CAP_POINTER));
2815 offset &= PCI_CAP_PTR_MASK;
2993 (uint8_t *)(hba->pci_addr + offset));
2816
2817 while (offset >= PCI_CAP_PTR_OFF) {
2994
2995 while (offset >= PCI_CAP_PTR_OFF) {
2818 /* Read the next cap id */
2819 id = ddi_get8(hba->pci_acc_handle,
2820 (uint8_t *)(hba->pci_addr + offset));
2996 /* Read the cap */
2997 reg = ddi_get32(hba->pci_acc_handle,
2998 (uint32_t *)(hba->pci_addr + offset));
2821
2999
2822 if (id < PCI_CAP_MAX_PTR) {
3000 id = ((reg >> PCI_CAP_ID_SHIFT) & PCI_CAP_ID_MASK);
3001 next = ((reg >> PCI_CAP_NEXT_PTR_SHIFT) &
3002 PCI_CAP_NEXT_PTR_MASK);
3003
3004 if ((id < PCI_CAP_MAX_PTR) &&
3005 (hba->pci_cap_offset[id] == 0)) {
2823 hba->pci_cap_offset[id] = offset;
2824 }
2825
2826 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
3006 hba->pci_cap_offset[id] = offset;
3007 }
3008
3009 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
2827 "%s: offset=0x%x",
2828 emlxs_pci_cap_xlate(id), offset);
3010 "%s: offset=0x%x next=0x%x",
3011 emlxs_pci_cap_xlate(id), offset, next);
2829
3012
2830 /* Read next offset */
2831 offset = ddi_get8(hba->pci_acc_handle,
2832 (uint8_t *)(hba->pci_addr + offset + PCI_CAP_NEXT_PTR));
2833 offset &= PCI_CAP_PTR_MASK;
3013 offset = next;
2834 }
2835
3014 }
3015
3016 /* Workaround for BE adapters */
3017 if ((hba->pci_cap_offset[PCI_CAP_ID_VS] == 0) &&
3018 (hba->model_info.chip & EMLXS_BE_CHIPS)) {
3019 hba->pci_cap_offset[PCI_CAP_ID_VS] = 0x54;
3020
3021 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
3022 "%s: offset=0x%x Added.",
3023 emlxs_pci_cap_xlate(PCI_CAP_ID_VS),
3024 hba->pci_cap_offset[PCI_CAP_ID_VS]);
3025 }
3026
3027 if (! hba->pci_cap_offset[PCI_CAP_ID_PCI_E]) {
3028 /* It's not a PCIE adapter. */
3029 return;
3030 }
3031
3032 /* Read PCI Extended capbabilities */
3033
3034 bzero(hba->pci_ecap_offset, sizeof (hba->pci_ecap_offset));
3035
3036 /* Set first offset */
3037 eoffset = PCIE_EXT_CAP;
3038
3039 while (eoffset >= PCIE_EXT_CAP) {
3040 /* Read the cap */
3041 reg = ddi_get32(hba->pci_acc_handle,
3042 (uint32_t *)(hba->pci_addr + eoffset));
3043
3044 eid = ((reg >> PCIE_EXT_CAP_ID_SHIFT) & PCIE_EXT_CAP_ID_MASK);
3045 eversion = ((reg >> PCIE_EXT_CAP_VER_SHIFT) &
3046 PCIE_EXT_CAP_VER_MASK);
3047 enext = ((reg >> PCIE_EXT_CAP_NEXT_PTR_SHIFT) &
3048 PCIE_EXT_CAP_NEXT_PTR_MASK);
3049
3050 if ((eid < PCI_EXT_CAP_MAX_PTR) &&
3051 (hba->pci_ecap_offset[eid] == 0)) {
3052 hba->pci_ecap_offset[eid] = eoffset;
3053 }
3054
3055 EMLXS_MSGF(EMLXS_CONTEXT, &emlxs_init_debug_msg,
3056 "%s: offset=0x%x version=0x%x next=0x%x",
3057 emlxs_pci_ecap_xlate(eid),
3058 eoffset, eversion, enext);
3059
3060 eoffset = enext;
3061 }
3062
2836 return;
2837
2838} /* emlxs_pci_cap_offsets() */
3063 return;
3064
3065} /* emlxs_pci_cap_offsets() */