usr/src/uts/common/io/bnxe/bnxe_cfg.c

   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.
  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 2014 QLogic Corporation
  24  * The contents of this file are subject to the terms of the
  25  * QLogic End User License (the "License").
  26  * You may not use this file except in compliance with the License.
  27  *
  28  * You can obtain a copy of the License at
  29  * http://www.qlogic.com/Resources/Documents/DriverDownloadHelp/
  30  * QLogic_End_User_Software_License.txt
  31  * See the License for the specific language governing permissions
  32  * and limitations under the License.
  33  */
  34
  35 /*
  36  * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved.
  37  */
  38
  39 #include "bnxe.h"
  40
  41
  42 /* these are the default phy link configs */
  43 BnxeLinkCfg bnxeLinkCfg =
  44 {
  45     B_TRUE,  /* link_autoneg   */
  46     B_TRUE,  /* param_20000fdx */
  47     B_TRUE,  /* param_10000fdx */
  48     B_TRUE,  /* param_2500fdx  */
  49     B_TRUE,  /* param_1000fdx  */
  50     B_FALSE, /* param_100fdx   */
  51     B_FALSE, /* param_100hdx   */
  52     B_FALSE, /* param_10fdx    */
  53     B_FALSE, /* param_10hdx    */
  54     B_TRUE,  /* param_txpause  */
  55     B_TRUE   /* param_rxpause  */
  56 };
  57
  58
  59 static void BnxeCfgGetVal(um_device_t * pUM,
  60                           char *        pName,
  61                           void *        pVal,
  62                           int           defaultVal,
  63                           boolean_t     boolVal)
  64 {
  65     int val;
  66     #define BNXE_CFG_NAME_LEN_MAX 128
  67     char name[BNXE_CFG_NAME_LEN_MAX];
  68
  69     /* first check if the hardcoded default has been overridden */
  70
  71     snprintf(name, BNXE_CFG_NAME_LEN_MAX, "default_%s", pName);
  72
  73     val = ddi_prop_get_int(DDI_DEV_T_ANY,
  74                            pUM->pDev,
  75                            (DDI_PROP_NOTPROM | DDI_PROP_DONTPASS),
  76                            name,
  77                            defaultVal);
  78
  79     /* now check for a config for this specific instance */
  80
  81     snprintf(name, BNXE_CFG_NAME_LEN_MAX, "bnxe%d_%s", pUM->instance, pName);
  82
  83     val = ddi_prop_get_int(DDI_DEV_T_ANY,
  84                            pUM->pDev,
  85                            (DDI_PROP_NOTPROM | DDI_PROP_DONTPASS),
  86                            name,
  87                            val);
  88
  89     if (boolVal)
  90     {
  91         *((boolean_t *)pVal) = (val) ? B_TRUE : B_FALSE;
  92     }
  93     else
  94     {
  95         *((int *)pVal) = val;
  96     }
  97 }
  98
  99
 100 void BnxeCfg_LLDP_DCBX(um_device_t * pUM)
 101 {
 102     lm_device_t * pLM = &pUM->lm_dev;
 103     char name[64];
 104     int i;
 105
 106     /* DCBX defaults configuration: DCBX not supported by default. */
 107     pLM->params.dcbx_port_params.dcbx_enabled = FALSE;
 108
 109     /* DCBX defaults configuration: PFC not supported. */
 110     pLM->params.dcbx_port_params.pfc.enabled = FALSE;
 111
 112     for (i = 0; i < LLFC_DRIVER_TRAFFIC_TYPE_MAX; i++)
 113     {
 114         pLM->params.dcbx_port_params.app.traffic_type_priority[i] =
 115             INVALID_TRAFFIC_TYPE_PRIORITY;
 116     }
 117
 118     pLM->params.dcbx_port_params.pfc.priority_non_pauseable_mask = 0;
 119
 120     memset(&pLM->params.lldp_config_params, 0xFF,
 121            sizeof(pLM->params.lldp_config_params));
 122     memset(&pLM->params.dcbx_config_params, 0xFF,
 123            sizeof(pLM->params.dcbx_config_params));
 124
 125     pLM->params.dcbx_config_params.dcb_enable        = 1;
 126     pLM->params.dcbx_config_params.admin_dcbx_enable = 1;
 127
 128     BnxeCfgGetVal(pUM, "lldp_overwrite_settings",
 129                   &pLM->params.lldp_config_params.overwrite_settings,
 130                   pLM->params.lldp_config_params.overwrite_settings,
 131                   B_FALSE);
 132
 133     BnxeCfgGetVal(pUM, "lldp_msg_tx_hold",
 134                   &pLM->params.lldp_config_params.msg_tx_hold,
 135                   pLM->params.lldp_config_params.msg_tx_hold,
 136                   B_FALSE);
 137
 138     BnxeCfgGetVal(pUM, "lldp_msg_fast_tx",
 139                   &pLM->params.lldp_config_params.msg_fast_tx,
 140                   pLM->params.lldp_config_params.msg_fast_tx,
 141                   B_FALSE);
 142
 143     BnxeCfgGetVal(pUM, "lldp_tx_credit_max",
 144                   &pLM->params.lldp_config_params.tx_credit_max,
 145                   pLM->params.lldp_config_params.tx_credit_max,
 146                   B_FALSE);
 147
 148     BnxeCfgGetVal(pUM, "lldp_msg_tx_interval",
 149                   &pLM->params.lldp_config_params.msg_tx_interval,
 150                   pLM->params.lldp_config_params.msg_tx_interval,
 151                   B_FALSE);
 152
 153     BnxeCfgGetVal(pUM, "lldp_tx_fast",
 154                   &pLM->params.lldp_config_params.tx_fast,
 155                   pLM->params.lldp_config_params.tx_fast,
 156                   B_FALSE);
 157
 158     BnxeCfgGetVal(pUM, "dcbx_dcb_enable",
 159                   &pLM->params.dcbx_config_params.dcb_enable,
 160                   pLM->params.dcbx_config_params.dcb_enable,
 161                   B_FALSE);
 162
 163     BnxeCfgGetVal(pUM, "dcbx_admin_dcbx_enable",
 164                   &pLM->params.dcbx_config_params.admin_dcbx_enable,
 165                   pLM->params.dcbx_config_params.admin_dcbx_enable,
 166                   B_FALSE);
 167
 168     BnxeCfgGetVal(pUM, "dcbx_overwrite_settings",
 169                   &pLM->params.dcbx_config_params.overwrite_settings,
 170                   pLM->params.dcbx_config_params.overwrite_settings,
 171                   B_FALSE);
 172
 173     BnxeCfgGetVal(pUM, "dcbx_admin_dcbx_version",
 174                   &pLM->params.dcbx_config_params.admin_dcbx_version,
 175                   pLM->params.dcbx_config_params.admin_dcbx_version,
 176                   B_FALSE);
 177
 178     BnxeCfgGetVal(pUM, "dcbx_admin_ets_enable",
 179                   &pLM->params.dcbx_config_params.admin_ets_enable,
 180                   pLM->params.dcbx_config_params.admin_ets_enable,
 181                   B_FALSE);
 182
 183     BnxeCfgGetVal(pUM, "dcbx_admin_pfc_enable",
 184                   &pLM->params.dcbx_config_params.admin_pfc_enable,
 185                   pLM->params.dcbx_config_params.admin_pfc_enable,
 186                   B_FALSE);
 187
 188     BnxeCfgGetVal(pUM, "dcbx_admin_tc_supported_tx_enable",
 189                   &pLM->params.dcbx_config_params.admin_tc_supported_tx_enable,
 190                   pLM->params.dcbx_config_params.admin_tc_supported_tx_enable,
 191                   B_FALSE);
 192
 193     BnxeCfgGetVal(pUM, "dcbx_admin_ets_configuration_tx_enable",
 194                   &pLM->params.dcbx_config_params.admin_ets_configuration_tx_enable,
 195                   pLM->params.dcbx_config_params.admin_ets_configuration_tx_enable,
 196                   B_FALSE);
 197
 198     BnxeCfgGetVal(pUM, "dcbx_admin_ets_recommendation_tx_enable",
 199                   &pLM->params.dcbx_config_params.admin_ets_recommendation_tx_enable,
 200                   pLM->params.dcbx_config_params.admin_ets_recommendation_tx_enable,
 201                   B_FALSE);
 202
 203     BnxeCfgGetVal(pUM, "dcbx_admin_pfc_tx_enable",
 204                   &pLM->params.dcbx_config_params.admin_pfc_tx_enable,
 205                   pLM->params.dcbx_config_params.admin_pfc_tx_enable,
 206                   B_FALSE);
 207
 208     BnxeCfgGetVal(pUM, "dcbx_admin_application_priority_tx_enable",
 209                   &pLM->params.dcbx_config_params.admin_application_priority_tx_enable,
 210                   pLM->params.dcbx_config_params.admin_application_priority_tx_enable,
 211                   B_FALSE);
 212
 213     BnxeCfgGetVal(pUM, "dcbx_admin_ets_willing",
 214                   &pLM->params.dcbx_config_params.admin_ets_willing,
 215                   pLM->params.dcbx_config_params.admin_ets_willing,
 216                   B_FALSE);
 217
 218     BnxeCfgGetVal(pUM, "dcbx_admin_pfc_willing",
 219                   &pLM->params.dcbx_config_params.admin_pfc_willing,
 220                   pLM->params.dcbx_config_params.admin_pfc_willing,
 221                   B_FALSE);
 222
 223     BnxeCfgGetVal(pUM, "dcbx_admin_ets_reco_valid",
 224                   &pLM->params.dcbx_config_params.admin_ets_reco_valid,
 225                   pLM->params.dcbx_config_params.admin_ets_reco_valid,
 226                   B_FALSE);
 227
 228     BnxeCfgGetVal(pUM, "dcbx_admin_app_priority_willing",
 229                   &pLM->params.dcbx_config_params.admin_app_priority_willing,
 230                   pLM->params.dcbx_config_params.admin_app_priority_willing,
 231                   B_FALSE);
 232
 233     for (i = 0; i < 8; i++)
 234     {
 235         snprintf(name, sizeof(name), "dcbx_admin_configuration_bw_percentage_%d", i);
 236         BnxeCfgGetVal(pUM, name,
 237                       &pLM->params.dcbx_config_params.admin_configuration_bw_percentage[i],
 238                       pLM->params.dcbx_config_params.admin_configuration_bw_percentage[i],
 239                       B_FALSE);
 240     }
 241
 242     for (i = 0; i < 8; i++)
 243     {
 244         snprintf(name, sizeof(name), "dcbx_admin_configuration_ets_pg_%d", i);
 245         BnxeCfgGetVal(pUM, name,
 246                       &pLM->params.dcbx_config_params.admin_configuration_ets_pg[i],
 247                       pLM->params.dcbx_config_params.admin_configuration_ets_pg[i],
 248                       B_FALSE);
 249     }
 250
 251     for (i = 0; i < 8; i++)
 252     {
 253         snprintf(name, sizeof(name), "dcbx_admin_recommendation_bw_percentage_%d", i);
 254         BnxeCfgGetVal(pUM, name,
 255                       &pLM->params.dcbx_config_params.admin_recommendation_bw_percentage[i],
 256                       pLM->params.dcbx_config_params.admin_recommendation_bw_percentage[i],
 257                       B_FALSE);
 258     }
 259
 260     for (i = 0; i < 8; i++)
 261     {
 262         snprintf(name, sizeof(name), "dcbx_admin_recommendation_ets_pg_%d", i);
 263         BnxeCfgGetVal(pUM, name,
 264                       &pLM->params.dcbx_config_params.admin_recommendation_ets_pg[i],
 265                       pLM->params.dcbx_config_params.admin_recommendation_ets_pg[i],
 266                       B_FALSE);
 267     }
 268
 269     BnxeCfgGetVal(pUM, "dcbx_admin_pfc_bitmap",
 270                   &pLM->params.dcbx_config_params.admin_pfc_bitmap,
 271                   pLM->params.dcbx_config_params.admin_pfc_bitmap,
 272                   B_FALSE);
 273
 274     for (i = 0; i < 4; i++)
 275     {
 276         snprintf(name, sizeof(name), "dcbx_admin_priority_app_table_%d_valid", i);
 277         BnxeCfgGetVal(pUM, name,
 278                       &pLM->params.dcbx_config_params.admin_priority_app_table[i].valid,
 279                       pLM->params.dcbx_config_params.admin_priority_app_table[i].valid,
 280                       B_FALSE);
 281
 282         snprintf(name, sizeof(name), "dcbx_admin_priority_app_table_%d_priority", i);
 283         BnxeCfgGetVal(pUM, name,
 284                       &pLM->params.dcbx_config_params.admin_priority_app_table[i].priority,
 285                       pLM->params.dcbx_config_params.admin_priority_app_table[i].priority,
 286                       B_FALSE);
 287
 288         snprintf(name, sizeof(name), "dcbx_admin_priority_app_table_%d_traffic_type", i);
 289         BnxeCfgGetVal(pUM, name,
 290                       &pLM->params.dcbx_config_params.admin_priority_app_table[i].traffic_type,
 291                       pLM->params.dcbx_config_params.admin_priority_app_table[i].traffic_type,
 292                       B_FALSE);
 293
 294         snprintf(name, sizeof(name), "dcbx_admin_priority_app_table_%d_app_id", i);
 295         BnxeCfgGetVal(pUM, name,
 296                       &pLM->params.dcbx_config_params.admin_priority_app_table[i].app_id,
 297                       pLM->params.dcbx_config_params.admin_priority_app_table[i].app_id,
 298                       B_FALSE);
 299     }
 300
 301     BnxeCfgGetVal(pUM, "dcbx_admin_default_priority",
 302                   &pLM->params.dcbx_config_params.admin_default_priority,
 303                   pLM->params.dcbx_config_params.admin_default_priority,
 304                   B_FALSE);
 305 }
 306
 307
 308 void BnxeCfgInit(um_device_t * pUM)
 309 {
 310     int option, i;
 311
 312     /* set the defaults */
 313     bcopy(&bnxeLinkCfg, &pUM->hwinit.lnkcfg, sizeof(BnxeLinkCfg));
 314
 315     pUM->hwinit.flow_autoneg                  = B_TRUE;
 316     pUM->devParams.checksum                   = USER_OPTION_CKSUM_DEFAULT;
 317     pUM->devParams.enabled_oflds              = LM_OFFLOAD_NONE;
 318     pUM->devParams.mtu[LM_CLI_IDX_NDIS]       = USER_OPTION_MTU_DEFAULT;
 319     pUM->devParams.numRings                   = USER_OPTION_NUM_RINGS_DEFAULT;
 320     pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS] = USER_OPTION_RX_BDS_DEFAULT;
 321     pUM->devParams.numTxDesc[LM_CLI_IDX_NDIS] = USER_OPTION_TX_BDS_DEFAULT;
 322     pUM->devParams.maxRxFree                  = USER_OPTION_RX_MAX_FREE_DEFAULT;
 323     pUM->devParams.maxTxFree                  = USER_OPTION_TX_MAX_FREE_DEFAULT;
 324     pUM->devParams.rxCopyThreshold            = USER_OPTION_RX_DCOPY_THRESH_DEFAULT;
 325     pUM->devParams.txCopyThreshold            = USER_OPTION_TX_DCOPY_THRESH_DEFAULT;
 326     pUM->devParams.intrCoalesce               = B_TRUE;
 327     pUM->devParams.intrRxPerSec               = USER_OPTION_INTR_COALESCE_RX_DEFAULT;
 328     pUM->devParams.intrTxPerSec               = USER_OPTION_INTR_COALESCE_TX_DEFAULT;
 329     pUM->devParams.disableMsix                = B_FALSE;
 330     pUM->devParams.l2_fw_flow_ctrl            = B_FALSE;
 331     pUM->devParams.autogreeenEnable           = B_TRUE;
 332     pUM->devParams.lsoEnable                  = B_TRUE;
 333     pUM->devParams.logEnable                  = B_TRUE;
 334     pUM->devParams.routeTxRingPolicy          = BNXE_ROUTE_RING_TCPUDP;
 335     pUM->devParams.fcoeEnable                 = B_FALSE;
 336     pUM->devParams.linkRemoteFaultDetect      = B_TRUE;
 337
 338     /* set the LLDP/DCBX defaults and get settings from bnxe.conf */
 339     BnxeCfg_LLDP_DCBX(pUM);
 340
 341     /* override the defaults based on what is set in bnxe.conf */
 342
 343     BnxeCfgGetVal(pUM, "adv_autoneg_cap",
 344                   &pUM->hwinit.lnkcfg.link_autoneg,
 345                   pUM->hwinit.lnkcfg.link_autoneg,
 346                   B_TRUE);
 347
 348     BnxeCfgGetVal(pUM, "adv_20000fdx_cap",
 349                   &pUM->hwinit.lnkcfg.param_20000fdx,
 350                   pUM->hwinit.lnkcfg.param_20000fdx,
 351                   B_TRUE);
 352
 353     BnxeCfgGetVal(pUM, "adv_10000fdx_cap",
 354                   &pUM->hwinit.lnkcfg.param_10000fdx,
 355                   pUM->hwinit.lnkcfg.param_10000fdx,
 356                   B_TRUE);
 357
 358     BnxeCfgGetVal(pUM, "adv_2500fdx_cap",
 359                   &pUM->hwinit.lnkcfg.param_2500fdx,
 360                   pUM->hwinit.lnkcfg.param_2500fdx,
 361                   B_TRUE);
 362
 363     BnxeCfgGetVal(pUM, "adv_1000fdx_cap",
 364                   &pUM->hwinit.lnkcfg.param_1000fdx,
 365                   pUM->hwinit.lnkcfg.param_1000fdx,
 366                   B_TRUE);
 367
 368     BnxeCfgGetVal(pUM, "adv_100fdx_cap",
 369                   &pUM->hwinit.lnkcfg.param_100fdx,
 370                   pUM->hwinit.lnkcfg.param_100fdx,
 371                   B_TRUE);
 372
 373     BnxeCfgGetVal(pUM, "adv_100hdx_cap",
 374                   &pUM->hwinit.lnkcfg.param_100hdx,
 375                   pUM->hwinit.lnkcfg.param_100hdx,
 376                   B_TRUE);
 377
 378     BnxeCfgGetVal(pUM, "adv_10fdx_cap",
 379                   &pUM->hwinit.lnkcfg.param_10fdx,
 380                   pUM->hwinit.lnkcfg.param_10fdx,
 381                   B_TRUE);
 382
 383     BnxeCfgGetVal(pUM, "adv_10hdx_cap",
 384                   &pUM->hwinit.lnkcfg.param_10hdx,
 385                   pUM->hwinit.lnkcfg.param_10hdx,
 386                   B_TRUE);
 387
 388     BnxeCfgGetVal(pUM, "txpause_cap",
 389                   &pUM->hwinit.lnkcfg.param_txpause,
 390                   pUM->hwinit.lnkcfg.param_txpause,
 391                   B_TRUE);
 392
 393     BnxeCfgGetVal(pUM, "rxpause_cap",
 394                   &pUM->hwinit.lnkcfg.param_rxpause,
 395                   pUM->hwinit.lnkcfg.param_rxpause,
 396                   B_TRUE);
 397
 398     BnxeCfgGetVal(pUM, "autoneg_flow",
 399                   &pUM->hwinit.flow_autoneg,
 400                   pUM->hwinit.flow_autoneg,
 401                   B_TRUE);
 402
 403     BnxeCfgGetVal(pUM, "checksum",
 404                   &pUM->devParams.checksum,
 405                   pUM->devParams.checksum,
 406                   B_FALSE);
 407     switch (pUM->devParams.checksum)
 408     {
 409     case USER_OPTION_CKSUM_L3:
 410         pUM->devParams.enabled_oflds = (LM_OFFLOAD_TX_IP_CKSUM |
 411                                         LM_OFFLOAD_RX_IP_CKSUM);
 412         break;
 413
 414     case USER_OPTION_CKSUM_L3_L4:
 415         pUM->devParams.enabled_oflds = (LM_OFFLOAD_TX_IP_CKSUM  |
 416                                         LM_OFFLOAD_RX_IP_CKSUM  |
 417                                         LM_OFFLOAD_TX_TCP_CKSUM |
 418                                         LM_OFFLOAD_RX_TCP_CKSUM |
 419                                         LM_OFFLOAD_TX_UDP_CKSUM |
 420                                         LM_OFFLOAD_RX_UDP_CKSUM);
 421         break;
 422
 423     case USER_OPTION_CKSUM_NONE:
 424     default:
 425         pUM->devParams.enabled_oflds = LM_OFFLOAD_NONE;
 426         break;
 427     }
 428
 429     BnxeCfgGetVal(pUM, "mtu",
 430                   &option,
 431                   pUM->devParams.mtu[LM_CLI_IDX_NDIS],
 432                   B_FALSE);
 433     pUM->devParams.mtu[LM_CLI_IDX_NDIS] =
 434         (option < USER_OPTION_MTU_MIN) ?
 435             USER_OPTION_MTU_MIN :
 436             (option > USER_OPTION_MTU_MAX) ?
 437                 USER_OPTION_MTU_MAX :
 438                 option;
 439     pUM->lm_dev.params.mtu[LM_CLI_IDX_NDIS] = pUM->devParams.mtu[LM_CLI_IDX_NDIS];
 440
 441     pUM->devParams.mtu[LM_CLI_IDX_FCOE]     = LM_MTU_FCOE_DEFAULT;
 442     pUM->lm_dev.params.mtu[LM_CLI_IDX_FCOE] = LM_MTU_FCOE_DEFAULT;
 443
 444     pUM->lm_dev.params.mtu_max = (pUM->lm_dev.params.mtu[LM_CLI_IDX_NDIS] >
 445                                   pUM->lm_dev.params.mtu[LM_CLI_IDX_FCOE]) ?
 446                                      pUM->lm_dev.params.mtu[LM_CLI_IDX_NDIS] :
 447                                      pUM->lm_dev.params.mtu[LM_CLI_IDX_FCOE];
 448
 449     BnxeCfgGetVal(pUM, "route_tx_ring_policy",
 450                   &pUM->devParams.routeTxRingPolicy,
 451                   pUM->devParams.routeTxRingPolicy,
 452                   B_FALSE);
 453     if ((pUM->devParams.routeTxRingPolicy != BNXE_ROUTE_RING_NONE) &&
 454         (pUM->devParams.routeTxRingPolicy != BNXE_ROUTE_RING_TCPUDP) &&
 455         (pUM->devParams.routeTxRingPolicy != BNXE_ROUTE_RING_DEST_MAC) &&
 456         (pUM->devParams.routeTxRingPolicy != BNXE_ROUTE_RING_MSG_PRIO))
 457     {
 458         pUM->devParams.routeTxRingPolicy = BNXE_ROUTE_RING_TCPUDP;
 459     }
 460
 461     BnxeCfgGetVal(pUM, "num_rings",
 462                   &option,
 463                   pUM->devParams.numRings,
 464                   B_FALSE);
 465     pUM->devParams.numRings = (option < USER_OPTION_NUM_RINGS_MIN) ?
 466                                   USER_OPTION_NUM_RINGS_MIN :
 467                                   (option > USER_OPTION_NUM_RINGS_MAX) ?
 468                                       USER_OPTION_NUM_RINGS_MAX :
 469                                       option;
 470
 471     /* adjust for function mode defaults */
 472     if (pUM->devParams.numRings == USER_OPTION_NUM_RINGS_DEFAULT)
 473     {
 474         pUM->devParams.numRings = (IS_MULTI_VNIC(&pUM->lm_dev)) ?
 475                                       USER_OPTION_NUM_RINGS_DEFAULT_MF :
 476                                       USER_OPTION_NUM_RINGS_DEFAULT_SF;
 477     }
 478
 479     /* numRings must be a power of two and <= max rss chains allowed */
 480     for (i = 1; pUM->devParams.numRings >> i; i++) { ; }
 481     pUM->devParams.numRings = (1 << (i - 1));
 482     if (pUM->devParams.numRings > LM_MAX_RSS_CHAINS(&pUM->lm_dev))
 483     {
 484         pUM->devParams.numRings = LM_MAX_RSS_CHAINS(&pUM->lm_dev);
 485     }
 486
 487     BnxeCfgGetVal(pUM, "rx_descs",
 488                   &option,
 489                   pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS],
 490                   B_FALSE);
 491     pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS] =
 492         (option < USER_OPTION_BDS_MIN) ?
 493             USER_OPTION_BDS_MIN :
 494             (option > USER_OPTION_BDS_MAX) ?
 495                 USER_OPTION_BDS_MAX :
 496                 option;
 497
 498     BnxeCfgGetVal(pUM, "tx_descs",
 499                   &option,
 500                   pUM->devParams.numTxDesc[LM_CLI_IDX_NDIS],
 501                   B_FALSE);
 502     pUM->devParams.numTxDesc[LM_CLI_IDX_NDIS] =
 503         (option < USER_OPTION_BDS_MIN) ?
 504             USER_OPTION_BDS_MIN :
 505             (option > USER_OPTION_BDS_MAX) ?
 506                 USER_OPTION_BDS_MAX :
 507                 option;
 508
 509     BnxeCfgGetVal(pUM, "rx_free_reclaim",
 510                   &option,
 511                   pUM->devParams.maxRxFree,
 512                   B_FALSE);
 513     pUM->devParams.maxRxFree =
 514         (option < 0) ?
 515             0 :
 516             (option > pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS]) ?
 517                 pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS] :
 518                 option;
 519
 520     BnxeCfgGetVal(pUM, "tx_free_reclaim",
 521                   &option,
 522                   pUM->devParams.maxTxFree,
 523                   B_FALSE);
 524     pUM->devParams.maxTxFree =
 525         (option < 0) ?
 526             0 :
 527             (option > pUM->devParams.numTxDesc[LM_CLI_IDX_NDIS]) ?
 528                 pUM->devParams.numTxDesc[LM_CLI_IDX_NDIS] :
 529                 option;
 530
 531     /* threshold to enable double copy of receive packet */
 532     BnxeCfgGetVal(pUM, "rx_copy_threshold",
 533                   &pUM->devParams.rxCopyThreshold,
 534                   pUM->devParams.rxCopyThreshold,
 535                   B_FALSE);
 536
 537     /* threshold to enable double copy of transmit packet */
 538     BnxeCfgGetVal(pUM, "tx_copy_threshold",
 539                   &pUM->devParams.txCopyThreshold,
 540                   pUM->devParams.txCopyThreshold,
 541                   B_FALSE);
 542
 543     BnxeCfgGetVal(pUM, "interrupt_coalesce",
 544                   &pUM->devParams.intrCoalesce,
 545                   pUM->devParams.intrCoalesce,
 546                   B_TRUE);
 547
 548     BnxeCfgGetVal(pUM, "rx_interrupt_coalesce_usec",
 549                   &option,
 550                   pUM->devParams.intrRxPerSec,
 551                   B_FALSE);
 552     option = (option < USER_OPTION_INTR_COALESCE_MIN) ?
 553                   USER_OPTION_INTR_COALESCE_MIN :
 554                   (option > USER_OPTION_INTR_COALESCE_MAX) ?
 555                       USER_OPTION_INTR_COALESCE_MAX :
 556                       option;
 557     pUM->devParams.intrRxPerSec = (1000000 / option); /* intrs per sec */
 558
 559     BnxeCfgGetVal(pUM, "tx_interrupt_coalesce_usec",
 560                   &option,
 561                   pUM->devParams.intrTxPerSec,
 562                   B_FALSE);
 563     option = (option < USER_OPTION_INTR_COALESCE_MIN) ?
 564                  USER_OPTION_INTR_COALESCE_MIN :
 565                  (option > USER_OPTION_INTR_COALESCE_MAX) ?
 566                      USER_OPTION_INTR_COALESCE_MAX :
 567                      option;
 568     pUM->devParams.intrTxPerSec = (1000000 / option); /* intrs per sec */
 569
 570     BnxeCfgGetVal(pUM, "disable_msix",
 571                   &pUM->devParams.disableMsix,
 572                   pUM->devParams.disableMsix,
 573                   B_TRUE);
 574
 575     BnxeCfgGetVal(pUM, "l2_fw_flow_ctrl",
 576                   &pUM->devParams.l2_fw_flow_ctrl,
 577                   pUM->devParams.l2_fw_flow_ctrl,
 578                   B_TRUE);
 579
 580     BnxeCfgGetVal(pUM, "autogreeen_enable",
 581                   &pUM->devParams.autogreeenEnable,
 582                   pUM->devParams.autogreeenEnable,
 583                   B_TRUE);
 584     pUM->lm_dev.params.autogreeen =
 585         (pUM->devParams.autogreeenEnable) ?
 586             LM_AUTOGREEEN_NVRAM /* maybe enabled or disabled */ :
 587             LM_AUTOGREEEN_DISABLED;
 588
 589     BnxeCfgGetVal(pUM, "lso_enable",
 590                   &pUM->devParams.lsoEnable,
 591                   pUM->devParams.lsoEnable,
 592                   B_TRUE);
 593
 594     /* Only allow LSO if Tx TCP checksum is turned on. */
 595     if (!(pUM->devParams.enabled_oflds & LM_OFFLOAD_TX_TCP_CKSUM))
 596     {
 597         pUM->devParams.lsoEnable = B_FALSE;
 598     }
 599
 600     BnxeCfgGetVal(pUM, "log_enable",
 601                   &pUM->devParams.logEnable,
 602                   pUM->devParams.logEnable,
 603                   B_TRUE);
 604
 605     BnxeCfgGetVal(pUM, "fcoe_enable",
 606                   &pUM->devParams.fcoeEnable,
 607                   pUM->devParams.fcoeEnable,
 608                   B_TRUE);
 609
 610     BnxeCfgGetVal(pUM, "link_remote_fault_detect",
 611                   &pUM->devParams.linkRemoteFaultDetect,
 612                   pUM->devParams.linkRemoteFaultDetect,
 613                   B_TRUE);
 614
 615     if (!pUM->devParams.linkRemoteFaultDetect)
 616     {
 617         SET_FLAGS(pUM->lm_dev.params.link.feature_config_flags,
 618                   ELINK_FEATURE_CONFIG_DISABLE_REMOTE_FAULT_DET);
 619     }
 620
 621     BnxeCfgGetVal(pUM, "debug_level",
 622                   &option,
 623                   pUM->devParams.debug_level,
 624                   B_FALSE);
 625     pUM->devParams.debug_level =
 626         (option < 0) ?
 627             0 :
 628             ((uint32_t)option > (CP_ALL | LV_MASK)) ?
 629                 (CP_ALL | LV_MASK) :
 630                 (uint32_t)option;
 631
 632     /* Adjust the number of rx/tx descriptors if in multi-function mode. */
 633
 634     if (IS_MULTI_VNIC(&pUM->lm_dev))
 635     {
 636         if (!(pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS] /=
 637               USER_OPTION_MF_BDS_DIVISOR))
 638         {
 639             pUM->devParams.numRxDesc[LM_CLI_IDX_NDIS] = USER_OPTION_BDS_MIN;
 640         }
 641
 642         if (!(pUM->devParams.numTxDesc[LM_CLI_IDX_NDIS] /=
 643               USER_OPTION_MF_BDS_DIVISOR))
 644         {
 645             pUM->devParams.numTxDesc[LM_CLI_IDX_NDIS] = USER_OPTION_BDS_MIN;
 646         }
 647     }
 648 }
 649
 650
 651 void BnxeCfgReset(um_device_t * pUM)
 652 {
 653     /* reset the link status */
 654     pUM->props.link_speed   = 0;
 655     pUM->props.link_duplex  = B_FALSE;
 656     pUM->props.link_txpause = B_FALSE;
 657     pUM->props.link_rxpause = B_FALSE;
 658
 659     /* reset the link partner status */
 660     pUM->remote.link_autoneg   = B_FALSE;
 661     pUM->remote.param_20000fdx = B_FALSE;
 662     pUM->remote.param_10000fdx = B_FALSE;
 663     pUM->remote.param_2500fdx  = B_FALSE;
 664     pUM->remote.param_1000fdx  = B_FALSE;
 665     pUM->remote.param_100fdx   = B_FALSE;
 666     pUM->remote.param_100hdx   = B_FALSE;
 667     pUM->remote.param_10fdx    = B_FALSE;
 668     pUM->remote.param_10hdx    = B_FALSE;
 669     pUM->remote.param_txpause  = B_FALSE;
 670     pUM->remote.param_rxpause  = B_FALSE;
 671
 672     /* reset the configuration from the configured hardware default */
 673     bcopy(&pUM->hwinit, &pUM->curcfg, sizeof(BnxePhyCfg));
 674 }
 675