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