xref: /illumos-gate/usr/src/uts/common/io/bnxe/bnxe_cfg.c (revision d14abf15)

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