| /* |
| * 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)); |
| } |
| |