/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2014 QLogic Corporation * The contents of this file are subject to the terms of the * QLogic End User License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the License at * http://www.qlogic.com/Resources/Documents/DriverDownloadHelp/ * QLogic_End_User_Software_License.txt * See the License for the specific language governing permissions * and limitations under the License. */ /* * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved. */ #include "bnxe.h" /* these are the default phy link configs */ BnxeLinkCfg bnxeLinkCfg = { B_TRUE, /* link_autoneg */ B_TRUE, /* param_20000fdx */ B_TRUE, /* param_10000fdx */ B_TRUE, /* param_2500fdx */ B_TRUE, /* param_1000fdx */ B_FALSE, /* param_100fdx */ B_FALSE, /* param_100hdx */ B_FALSE, /* param_10fdx */ B_FALSE, /* param_10hdx */ B_TRUE, /* param_txpause */ B_TRUE /* param_rxpause */ }; static void BnxeCfgGetVal(um_device_t * pUM, char * pName, void * pVal, int defaultVal, boolean_t boolVal) { int val; #define BNXE_CFG_NAME_LEN_MAX 128 char name[BNXE_CFG_NAME_LEN_MAX]; /* first check if the hardcoded default has been overridden */ snprintf(name, BNXE_CFG_NAME_LEN_MAX, "default_%s", pName); val = ddi_prop_get_int(DDI_DEV_T_ANY, pUM->pDev, (DDI_PROP_NOTPROM | DDI_PROP_DONTPASS), name, defaultVal); /* now check for a config for this specific instance */ snprintf(name, BNXE_CFG_NAME_LEN_MAX, "bnxe%d_%s", pUM->instance, pName); val = ddi_prop_get_int(DDI_DEV_T_ANY, pUM->pDev, (DDI_PROP_NOTPROM | DDI_PROP_DONTPASS), name, val); if (boolVal) { *((boolean_t *)pVal) = (val) ? B_TRUE : B_FALSE; } else { *((int *)pVal) = val; } } void BnxeCfg_LLDP_DCBX(um_device_t * pUM) { lm_device_t * pLM = &pUM->lm_dev; char name[64]; int i; /* DCBX defaults configuration: DCBX not supported by default. */ pLM->params.dcbx_port_params.dcbx_enabled = FALSE; /* DCBX defaults configuration: PFC not supported. */ pLM->params.dcbx_port_params.pfc.enabled = FALSE; for (i = 0; i < LLFC_DRIVER_TRAFFIC_TYPE_MAX; i++) { pLM->params.dcbx_port_params.app.traffic_type_priority[i] = INVALID_TRAFFIC_TYPE_PRIORITY; } pLM->params.dcbx_port_params.pfc.priority_non_pauseable_mask = 0; memset(&pLM->params.lldp_config_params, 0xFF, sizeof(pLM->params.lldp_config_params)); memset(&pLM->params.dcbx_config_params, 0xFF, sizeof(pLM->params.dcbx_config_params)); pLM->params.dcbx_config_params.dcb_enable = 1; pLM->params.dcbx_config_params.admin_dcbx_enable = 1; BnxeCfgGetVal(pUM, "lldp_overwrite_settings", &pLM->params.lldp_config_params.overwrite_settings, pLM->params.lldp_config_params.overwrite_settings, B_FALSE); BnxeCfgGetVal(pUM, "lldp_msg_tx_hold", &pLM->params.lldp_config_params.msg_tx_hold, pLM->params.lldp_config_params.msg_tx_hold, B_FALSE); BnxeCfgGetVal(pUM, "lldp_msg_fast_tx", &pLM->params.lldp_config_params.msg_fast_tx, pLM->params.lldp_config_params.msg_fast_tx, B_FALSE); BnxeCfgGetVal(pUM, "lldp_tx_credit_max", &pLM->params.lldp_config_params.tx_credit_max, pLM->params.lldp_config_params.tx_credit_max, B_FALSE); BnxeCfgGetVal(pUM, "lldp_msg_tx_interval", &pLM->params.lldp_config_params.msg_tx_interval, pLM->params.lldp_config_params.msg_tx_interval, B_FALSE); BnxeCfgGetVal(pUM, "lldp_tx_fast", &pLM->params.lldp_config_params.tx_fast, pLM->params.lldp_config_params.tx_fast, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_dcb_enable", &pLM->params.dcbx_config_params.dcb_enable, pLM->params.dcbx_config_params.dcb_enable, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_admin_dcbx_enable", &pLM->params.dcbx_config_params.admin_dcbx_enable, pLM->params.dcbx_config_params.admin_dcbx_enable, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_overwrite_settings", &pLM->params.dcbx_config_params.overwrite_settings, pLM->params.dcbx_config_params.overwrite_settings, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_admin_dcbx_version", &pLM->params.dcbx_config_params.admin_dcbx_version, pLM->params.dcbx_config_params.admin_dcbx_version, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_admin_ets_enable", &pLM->params.dcbx_config_params.admin_ets_enable, pLM->params.dcbx_config_params.admin_ets_enable, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_admin_pfc_enable", &pLM->params.dcbx_config_params.admin_pfc_enable, pLM->params.dcbx_config_params.admin_pfc_enable, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_admin_tc_supported_tx_enable", &pLM->params.dcbx_config_params.admin_tc_supported_tx_enable, pLM->params.dcbx_config_params.admin_tc_supported_tx_enable, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_admin_ets_configuration_tx_enable", &pLM->params.dcbx_config_params.admin_ets_configuration_tx_enable, pLM->params.dcbx_config_params.admin_ets_configuration_tx_enable, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_admin_ets_recommendation_tx_enable", &pLM->params.dcbx_config_params.admin_ets_recommendation_tx_enable, pLM->params.dcbx_config_params.admin_ets_recommendation_tx_enable, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_admin_pfc_tx_enable", &pLM->params.dcbx_config_params.admin_pfc_tx_enable, pLM->params.dcbx_config_params.admin_pfc_tx_enable, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_admin_application_priority_tx_enable", &pLM->params.dcbx_config_params.admin_application_priority_tx_enable, pLM->params.dcbx_config_params.admin_application_priority_tx_enable, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_admin_ets_willing", &pLM->params.dcbx_config_params.admin_ets_willing, pLM->params.dcbx_config_params.admin_ets_willing, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_admin_pfc_willing", &pLM->params.dcbx_config_params.admin_pfc_willing, pLM->params.dcbx_config_params.admin_pfc_willing, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_admin_ets_reco_valid", &pLM->params.dcbx_config_params.admin_ets_reco_valid, pLM->params.dcbx_config_params.admin_ets_reco_valid, B_FALSE); BnxeCfgGetVal(pUM, "dcbx_admin_app_priority_willing", &pLM->params.dcbx_config_params.admin_app_priority_willing, pLM->params.dcbx_config_params.admin_app_priority_willing, B_FALSE); for (i = 0; i < 8; i++) { snprintf(name, sizeof(name), "dcbx_admin_configuration_bw_percentage_%d", i); BnxeCfgGetVal(pUM, name, &pLM->params.dcbx_config_params.admin_configuration_bw_percentage[i], pLM->params.dcbx_config_params.admin_configuration_bw_percentage[i], B_FALSE); } for (i = 0; i < 8; i++) { snprintf(name, sizeof(name), "dcbx_admin_configuration_ets_pg_%d", i); BnxeCfgGetVal(pUM, name, &pLM->params.dcbx_config_params.admin_configuration_ets_pg[i], pLM->params.dcbx_config_params.admin_configuration_ets_pg[i], B_FALSE); } for (i = 0; i < 8; i++) { snprintf(name, sizeof(name), "dcbx_admin_recommendation_bw_percentage_%d", i); BnxeCfgGetVal(pUM, name, &pLM->params.dcbx_config_params.admin_recommendation_bw_percentage[i], pLM->params.dcbx_config_params.admin_recommendation_bw_percentage[i], B_FALSE); } for (i = 0; i < 8; i++) { snprintf(name, sizeof(name), "dcbx_admin_recommendation_ets_pg_%d", i); BnxeCfgGetVal(pUM, name, &pLM->params.dcbx_config_params.admin_recommendation_ets_pg[i], pLM->params.dcbx_config_params.admin_recommendation_ets_pg[i], B_FALSE); } BnxeCfgGetVal(pUM, "dcbx_admin_pfc_bitmap", &pLM->params.dcbx_config_params.admin_pfc_bitmap, pLM->params.dcbx_config_params.admin_pfc_bitmap, B_FALSE); for (i = 0; i < 4; i++) { snprintf(name, sizeof(name), "dcbx_admin_priority_app_table_%d_valid", i); BnxeCfgGetVal(pUM, name, &pLM->params.dcbx_config_params.admin_priority_app_table[i].valid, pLM->params.dcbx_config_params.admin_priority_app_table[i].valid, B_FALSE); snprintf(name, sizeof(name), "dcbx_admin_priority_app_table_%d_priority", i); BnxeCfgGetVal(pUM, name, &pLM->params.dcbx_config_params.admin_priority_app_table[i].priority, pLM->params.dcbx_config_params.admin_priority_app_table[i].priority, B_FALSE); snprintf(name, sizeof(name), "dcbx_admin_priority_app_table_%d_traffic_type", i); BnxeCfgGetVal(pUM, name, &pLM->params.dcbx_config_params.admin_priority_app_table[i].traffic_type, pLM->params.dcbx_config_params.admin_priority_app_table[i].traffic_type, B_FALSE); snprintf(name, sizeof(name), "dcbx_admin_priority_app_table_%d_app_id", i); BnxeCfgGetVal(pUM, name, &pLM->params.dcbx_config_params.admin_priority_app_table[i].app_id, pLM->params.dcbx_config_params.admin_priority_app_table[i].app_id, B_FALSE); } BnxeCfgGetVal(pUM, "dcbx_admin_default_priority", &pLM->params.dcbx_config_params.admin_default_priority, pLM->params.dcbx_config_params.admin_default_priority, B_FALSE); } void BnxeCfgInit(um_device_t * pUM) { int option, i; /* set the defaults */ bcopy(&bnxeLinkCfg, &pUM->hwinit.lnkcfg, sizeof(BnxeLinkCfg)); pUM->hwinit.flow_autoneg = B_TRUE; pUM->devParams.checksum = USER_OPTION_CKSUM_DEFAULT; pUM->devParams.enabled_oflds = LM_OFFLOAD_NONE; pUM->devParams.mtu[LM_CLI_IDX_NDIS] = USER_OPTION_MTU_DEFAULT; pUM->devParams.numRings = USER_OPTION_NUM_RINGS_DEFAULT; pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS] = USER_OPTION_RX_BDS_DEFAULT; pUM->devParams.numTxDesc[LM_CLI_IDX_NDIS] = USER_OPTION_TX_BDS_DEFAULT; pUM->devParams.maxRxFree = USER_OPTION_RX_MAX_FREE_DEFAULT; pUM->devParams.maxTxFree = USER_OPTION_TX_MAX_FREE_DEFAULT; pUM->devParams.rxCopyThreshold = USER_OPTION_RX_DCOPY_THRESH_DEFAULT; pUM->devParams.txCopyThreshold = USER_OPTION_TX_DCOPY_THRESH_DEFAULT; pUM->devParams.intrCoalesce = B_TRUE; pUM->devParams.intrRxPerSec = USER_OPTION_INTR_COALESCE_RX_DEFAULT; pUM->devParams.intrTxPerSec = USER_OPTION_INTR_COALESCE_TX_DEFAULT; pUM->devParams.disableMsix = B_FALSE; pUM->devParams.l2_fw_flow_ctrl = B_FALSE; pUM->devParams.autogreeenEnable = B_TRUE; pUM->devParams.lsoEnable = B_TRUE; pUM->devParams.logEnable = B_TRUE; pUM->devParams.routeTxRingPolicy = BNXE_ROUTE_RING_TCPUDP; pUM->devParams.fcoeEnable = B_FALSE; pUM->devParams.linkRemoteFaultDetect = B_TRUE; /* set the LLDP/DCBX defaults and get settings from bnxe.conf */ BnxeCfg_LLDP_DCBX(pUM); /* override the defaults based on what is set in bnxe.conf */ BnxeCfgGetVal(pUM, "adv_autoneg_cap", &pUM->hwinit.lnkcfg.link_autoneg, pUM->hwinit.lnkcfg.link_autoneg, B_TRUE); BnxeCfgGetVal(pUM, "adv_20000fdx_cap", &pUM->hwinit.lnkcfg.param_20000fdx, pUM->hwinit.lnkcfg.param_20000fdx, B_TRUE); BnxeCfgGetVal(pUM, "adv_10000fdx_cap", &pUM->hwinit.lnkcfg.param_10000fdx, pUM->hwinit.lnkcfg.param_10000fdx, B_TRUE); BnxeCfgGetVal(pUM, "adv_2500fdx_cap", &pUM->hwinit.lnkcfg.param_2500fdx, pUM->hwinit.lnkcfg.param_2500fdx, B_TRUE); BnxeCfgGetVal(pUM, "adv_1000fdx_cap", &pUM->hwinit.lnkcfg.param_1000fdx, pUM->hwinit.lnkcfg.param_1000fdx, B_TRUE); BnxeCfgGetVal(pUM, "adv_100fdx_cap", &pUM->hwinit.lnkcfg.param_100fdx, pUM->hwinit.lnkcfg.param_100fdx, B_TRUE); BnxeCfgGetVal(pUM, "adv_100hdx_cap", &pUM->hwinit.lnkcfg.param_100hdx, pUM->hwinit.lnkcfg.param_100hdx, B_TRUE); BnxeCfgGetVal(pUM, "adv_10fdx_cap", &pUM->hwinit.lnkcfg.param_10fdx, pUM->hwinit.lnkcfg.param_10fdx, B_TRUE); BnxeCfgGetVal(pUM, "adv_10hdx_cap", &pUM->hwinit.lnkcfg.param_10hdx, pUM->hwinit.lnkcfg.param_10hdx, B_TRUE); BnxeCfgGetVal(pUM, "txpause_cap", &pUM->hwinit.lnkcfg.param_txpause, pUM->hwinit.lnkcfg.param_txpause, B_TRUE); BnxeCfgGetVal(pUM, "rxpause_cap", &pUM->hwinit.lnkcfg.param_rxpause, pUM->hwinit.lnkcfg.param_rxpause, B_TRUE); BnxeCfgGetVal(pUM, "autoneg_flow", &pUM->hwinit.flow_autoneg, pUM->hwinit.flow_autoneg, B_TRUE); BnxeCfgGetVal(pUM, "checksum", &pUM->devParams.checksum, pUM->devParams.checksum, B_FALSE); switch (pUM->devParams.checksum) { case USER_OPTION_CKSUM_L3: pUM->devParams.enabled_oflds = (LM_OFFLOAD_TX_IP_CKSUM | LM_OFFLOAD_RX_IP_CKSUM); break; case USER_OPTION_CKSUM_L3_L4: pUM->devParams.enabled_oflds = (LM_OFFLOAD_TX_IP_CKSUM | LM_OFFLOAD_RX_IP_CKSUM | LM_OFFLOAD_TX_TCP_CKSUM | LM_OFFLOAD_RX_TCP_CKSUM | LM_OFFLOAD_TX_UDP_CKSUM | LM_OFFLOAD_RX_UDP_CKSUM); break; case USER_OPTION_CKSUM_NONE: default: pUM->devParams.enabled_oflds = LM_OFFLOAD_NONE; break; } BnxeCfgGetVal(pUM, "mtu", &option, pUM->devParams.mtu[LM_CLI_IDX_NDIS], B_FALSE); pUM->devParams.mtu[LM_CLI_IDX_NDIS] = (option < USER_OPTION_MTU_MIN) ? USER_OPTION_MTU_MIN : (option > USER_OPTION_MTU_MAX) ? USER_OPTION_MTU_MAX : option; pUM->lm_dev.params.mtu[LM_CLI_IDX_NDIS] = pUM->devParams.mtu[LM_CLI_IDX_NDIS]; pUM->devParams.mtu[LM_CLI_IDX_FCOE] = LM_MTU_FCOE_DEFAULT; pUM->lm_dev.params.mtu[LM_CLI_IDX_FCOE] = LM_MTU_FCOE_DEFAULT; pUM->lm_dev.params.mtu_max = (pUM->lm_dev.params.mtu[LM_CLI_IDX_NDIS] > pUM->lm_dev.params.mtu[LM_CLI_IDX_FCOE]) ? pUM->lm_dev.params.mtu[LM_CLI_IDX_NDIS] : pUM->lm_dev.params.mtu[LM_CLI_IDX_FCOE]; BnxeCfgGetVal(pUM, "route_tx_ring_policy", &pUM->devParams.routeTxRingPolicy, pUM->devParams.routeTxRingPolicy, B_FALSE); if ((pUM->devParams.routeTxRingPolicy != BNXE_ROUTE_RING_NONE) && (pUM->devParams.routeTxRingPolicy != BNXE_ROUTE_RING_TCPUDP) && (pUM->devParams.routeTxRingPolicy != BNXE_ROUTE_RING_DEST_MAC) && (pUM->devParams.routeTxRingPolicy != BNXE_ROUTE_RING_MSG_PRIO)) { pUM->devParams.routeTxRingPolicy = BNXE_ROUTE_RING_TCPUDP; } BnxeCfgGetVal(pUM, "num_rings", &option, pUM->devParams.numRings, B_FALSE); pUM->devParams.numRings = (option < USER_OPTION_NUM_RINGS_MIN) ? USER_OPTION_NUM_RINGS_MIN : (option > USER_OPTION_NUM_RINGS_MAX) ? USER_OPTION_NUM_RINGS_MAX : option; /* adjust for function mode defaults */ if (pUM->devParams.numRings == USER_OPTION_NUM_RINGS_DEFAULT) { pUM->devParams.numRings = (IS_MULTI_VNIC(&pUM->lm_dev)) ? USER_OPTION_NUM_RINGS_DEFAULT_MF : USER_OPTION_NUM_RINGS_DEFAULT_SF; } /* numRings must be a power of two and <= max rss chains allowed */ for (i = 1; pUM->devParams.numRings >> i; i++) { ; } pUM->devParams.numRings = (1 << (i - 1)); if (pUM->devParams.numRings > LM_MAX_RSS_CHAINS(&pUM->lm_dev)) { pUM->devParams.numRings = LM_MAX_RSS_CHAINS(&pUM->lm_dev); } BnxeCfgGetVal(pUM, "rx_descs", &option, pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS], B_FALSE); pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS] = (option < USER_OPTION_BDS_MIN) ? USER_OPTION_BDS_MIN : (option > USER_OPTION_BDS_MAX) ? USER_OPTION_BDS_MAX : option; BnxeCfgGetVal(pUM, "tx_descs", &option, pUM->devParams.numTxDesc[LM_CLI_IDX_NDIS], B_FALSE); pUM->devParams.numTxDesc[LM_CLI_IDX_NDIS] = (option < USER_OPTION_BDS_MIN) ? USER_OPTION_BDS_MIN : (option > USER_OPTION_BDS_MAX) ? USER_OPTION_BDS_MAX : option; BnxeCfgGetVal(pUM, "rx_free_reclaim", &option, pUM->devParams.maxRxFree, B_FALSE); pUM->devParams.maxRxFree = (option < 0) ? 0 : (option > pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS]) ? pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS] : option; BnxeCfgGetVal(pUM, "tx_free_reclaim", &option, pUM->devParams.maxTxFree, B_FALSE); pUM->devParams.maxTxFree = (option < 0) ? 0 : (option > pUM->devParams.numTxDesc[LM_CLI_IDX_NDIS]) ? pUM->devParams.numTxDesc[LM_CLI_IDX_NDIS] : option; /* threshold to enable double copy of receive packet */ BnxeCfgGetVal(pUM, "rx_copy_threshold", &pUM->devParams.rxCopyThreshold, pUM->devParams.rxCopyThreshold, B_FALSE); /* threshold to enable double copy of transmit packet */ BnxeCfgGetVal(pUM, "tx_copy_threshold", &pUM->devParams.txCopyThreshold, pUM->devParams.txCopyThreshold, B_FALSE); BnxeCfgGetVal(pUM, "interrupt_coalesce", &pUM->devParams.intrCoalesce, pUM->devParams.intrCoalesce, B_TRUE); BnxeCfgGetVal(pUM, "rx_interrupt_coalesce_usec", &option, pUM->devParams.intrRxPerSec, B_FALSE); option = (option < USER_OPTION_INTR_COALESCE_MIN) ? USER_OPTION_INTR_COALESCE_MIN : (option > USER_OPTION_INTR_COALESCE_MAX) ? USER_OPTION_INTR_COALESCE_MAX : option; pUM->devParams.intrRxPerSec = (1000000 / option); /* intrs per sec */ BnxeCfgGetVal(pUM, "tx_interrupt_coalesce_usec", &option, pUM->devParams.intrTxPerSec, B_FALSE); option = (option < USER_OPTION_INTR_COALESCE_MIN) ? USER_OPTION_INTR_COALESCE_MIN : (option > USER_OPTION_INTR_COALESCE_MAX) ? USER_OPTION_INTR_COALESCE_MAX : option; pUM->devParams.intrTxPerSec = (1000000 / option); /* intrs per sec */ BnxeCfgGetVal(pUM, "disable_msix", &pUM->devParams.disableMsix, pUM->devParams.disableMsix, B_TRUE); BnxeCfgGetVal(pUM, "l2_fw_flow_ctrl", &pUM->devParams.l2_fw_flow_ctrl, pUM->devParams.l2_fw_flow_ctrl, B_TRUE); BnxeCfgGetVal(pUM, "autogreeen_enable", &pUM->devParams.autogreeenEnable, pUM->devParams.autogreeenEnable, B_TRUE); pUM->lm_dev.params.autogreeen = (pUM->devParams.autogreeenEnable) ? LM_AUTOGREEEN_NVRAM /* maybe enabled or disabled */ : LM_AUTOGREEEN_DISABLED; BnxeCfgGetVal(pUM, "lso_enable", &pUM->devParams.lsoEnable, pUM->devParams.lsoEnable, B_TRUE); /* Only allow LSO if Tx TCP checksum is turned on. */ if (!(pUM->devParams.enabled_oflds & LM_OFFLOAD_TX_TCP_CKSUM)) { pUM->devParams.lsoEnable = B_FALSE; } BnxeCfgGetVal(pUM, "log_enable", &pUM->devParams.logEnable, pUM->devParams.logEnable, B_TRUE); BnxeCfgGetVal(pUM, "fcoe_enable", &pUM->devParams.fcoeEnable, pUM->devParams.fcoeEnable, B_TRUE); BnxeCfgGetVal(pUM, "link_remote_fault_detect", &pUM->devParams.linkRemoteFaultDetect, pUM->devParams.linkRemoteFaultDetect, B_TRUE); if (!pUM->devParams.linkRemoteFaultDetect) { SET_FLAGS(pUM->lm_dev.params.link.feature_config_flags, ELINK_FEATURE_CONFIG_DISABLE_REMOTE_FAULT_DET); } BnxeCfgGetVal(pUM, "debug_level", &option, pUM->devParams.debug_level, B_FALSE); pUM->devParams.debug_level = (option < 0) ? 0 : ((uint32_t)option > (CP_ALL | LV_MASK)) ? (CP_ALL | LV_MASK) : (uint32_t)option; /* Adjust the number of rx/tx descriptors if in multi-function mode. */ if (IS_MULTI_VNIC(&pUM->lm_dev)) { if (!(pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS] /= USER_OPTION_MF_BDS_DIVISOR)) { pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS] = USER_OPTION_BDS_MIN; } if (!(pUM->devParams.numTxDesc[LM_CLI_IDX_NDIS] /= USER_OPTION_MF_BDS_DIVISOR)) { pUM->devParams.numTxDesc[LM_CLI_IDX_NDIS] = USER_OPTION_BDS_MIN; } } } void BnxeCfgReset(um_device_t * pUM) { /* reset the link status */ pUM->props.link_speed = 0; pUM->props.link_duplex = B_FALSE; pUM->props.link_txpause = B_FALSE; pUM->props.link_rxpause = B_FALSE; /* reset the link partner status */ pUM->remote.link_autoneg = B_FALSE; pUM->remote.param_20000fdx = B_FALSE; pUM->remote.param_10000fdx = B_FALSE; pUM->remote.param_2500fdx = B_FALSE; pUM->remote.param_1000fdx = B_FALSE; pUM->remote.param_100fdx = B_FALSE; pUM->remote.param_100hdx = B_FALSE; pUM->remote.param_10fdx = B_FALSE; pUM->remote.param_10hdx = B_FALSE; pUM->remote.param_txpause = B_FALSE; pUM->remote.param_rxpause = B_FALSE; /* reset the configuration from the configured hardware default */ bcopy(&pUM->hwinit, &pUM->curcfg, sizeof(BnxePhyCfg)); }