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
BnxeCfgGetVal(um_device_t * pUM,char * pName,void * pVal,int defaultVal,boolean_t boolVal)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
BnxeCfg_LLDP_DCBX(um_device_t * pUM)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
BnxeCfgInit(um_device_t * pUM)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
BnxeCfgReset(um_device_t * pUM)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
676