projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] e1000: Added functions declarations
[linux-block.git] / drivers / net / e1000 / e1000_param.c
CommitLineData
1da177e4
LT		 1/*******************************************************************************
2
3
2648345f 4 Copyright(c) 1999 - 2005 Intel Corporation. All rights reserved.
1da177e4
LT		 5
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 2 of the License, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 more details.
15
16 You should have received a copy of the GNU General Public License along with
17 this program; if not, write to the Free Software Foundation, Inc., 59
18 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
20 The full GNU General Public License is included in this distribution in the
21 file called LICENSE.
22
23 Contact Information:
24 Linux NICS <linux.nics@intel.com>
25 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
26
27*******************************************************************************/
28
29#include "e1000.h"
30
31/* This is the only thing that needs to be changed to adjust the
32 * maximum number of ports that the driver can manage.
33 */
34
35#define E1000_MAX_NIC 32
36
37#define OPTION_UNSET -1
38#define OPTION_DISABLED 0
39#define OPTION_ENABLED 1
40
41/* All parameters are treated the same, as an integer array of values.
42 * This macro just reduces the need to repeat the same declaration code
43 * over and over (plus this helps to avoid typo bugs).
44 */
45
46#define E1000_PARAM_INIT { [0 ... E1000_MAX_NIC] = OPTION_UNSET }
47#define E1000_PARAM(X, desc) \
48 static int __devinitdata X[E1000_MAX_NIC+1] = E1000_PARAM_INIT; \
49 static int num_##X = 0; \
50 module_param_array_named(X, X, int, &num_##X, 0); \
51 MODULE_PARM_DESC(X, desc);
52
53/* Transmit Descriptor Count
54 *
55 * Valid Range: 80-256 for 82542 and 82543 gigabit ethernet controllers
56 * Valid Range: 80-4096 for 82544 and newer
57 *
58 * Default Value: 256
59 */
60
61E1000_PARAM(TxDescriptors, "Number of transmit descriptors");
62
63/* Receive Descriptor Count
64 *
65 * Valid Range: 80-256 for 82542 and 82543 gigabit ethernet controllers
66 * Valid Range: 80-4096 for 82544 and newer
67 *
68 * Default Value: 256
69 */
70
71E1000_PARAM(RxDescriptors, "Number of receive descriptors");
72
73/* User Specified Speed Override
74 *
75 * Valid Range: 0, 10, 100, 1000
76 * - 0 - auto-negotiate at all supported speeds
77 * - 10 - only link at 10 Mbps
78 * - 100 - only link at 100 Mbps
79 * - 1000 - only link at 1000 Mbps
80 *
81 * Default Value: 0
82 */
83
84E1000_PARAM(Speed, "Speed setting");
85
86/* User Specified Duplex Override
87 *
88 * Valid Range: 0-2
89 * - 0 - auto-negotiate for duplex
90 * - 1 - only link at half duplex
91 * - 2 - only link at full duplex
92 *
93 * Default Value: 0
94 */
95
96E1000_PARAM(Duplex, "Duplex setting");
97
98/* Auto-negotiation Advertisement Override
99 *
100 * Valid Range: 0x01-0x0F, 0x20-0x2F (copper); 0x20 (fiber)
101 *
102 * The AutoNeg value is a bit mask describing which speed and duplex
103 * combinations should be advertised during auto-negotiation.
104 * The supported speed and duplex modes are listed below
105 *
106 * Bit 7 6 5 4 3 2 1 0
107 * Speed (Mbps) N/A N/A 1000 N/A 100 100 10 10
108 * Duplex Full Full Half Full Half
109 *
110 * Default Value: 0x2F (copper); 0x20 (fiber)
111 */
112
113E1000_PARAM(AutoNeg, "Advertised auto-negotiation setting");
114
115/* User Specified Flow Control Override
116 *
117 * Valid Range: 0-3
118 * - 0 - No Flow Control
119 * - 1 - Rx only, respond to PAUSE frames but do not generate them
120 * - 2 - Tx only, generate PAUSE frames but ignore them on receive
121 * - 3 - Full Flow Control Support
122 *
123 * Default Value: Read flow control settings from the EEPROM
124 */
125
126E1000_PARAM(FlowControl, "Flow Control setting");
127
128/* XsumRX - Receive Checksum Offload Enable/Disable
129 *
130 * Valid Range: 0, 1
131 * - 0 - disables all checksum offload
132 * - 1 - enables receive IP/TCP/UDP checksum offload
133 * on 82543 and newer -based NICs
134 *
135 * Default Value: 1
136 */
137
138E1000_PARAM(XsumRX, "Disable or enable Receive Checksum offload");
139
140/* Transmit Interrupt Delay in units of 1.024 microseconds
141 *
142 * Valid Range: 0-65535
143 *
144 * Default Value: 64
145 */
146
147E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");
148
149/* Transmit Absolute Interrupt Delay in units of 1.024 microseconds
150 *
151 * Valid Range: 0-65535
152 *
153 * Default Value: 0
154 */
155
156E1000_PARAM(TxAbsIntDelay, "Transmit Absolute Interrupt Delay");
157
158/* Receive Interrupt Delay in units of 1.024 microseconds
159 *
160 * Valid Range: 0-65535
161 *
162 * Default Value: 0
163 */
164
165E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");
166
167/* Receive Absolute Interrupt Delay in units of 1.024 microseconds
168 *
169 * Valid Range: 0-65535
170 *
171 * Default Value: 128
172 */
173
174E1000_PARAM(RxAbsIntDelay, "Receive Absolute Interrupt Delay");
175
176/* Interrupt Throttle Rate (interrupts/sec)
177 *
178 * Valid Range: 100-100000 (0=off, 1=dynamic)
179 *
38bd3b26 180 * Default Value: 8000
1da177e4
LT		 181 */
182
183E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");
184
185#define AUTONEG_ADV_DEFAULT 0x2F
186#define AUTONEG_ADV_MASK 0x2F
187#define FLOW_CONTROL_DEFAULT FLOW_CONTROL_FULL
188
189#define DEFAULT_RDTR 0
190#define MAX_RXDELAY 0xFFFF
191#define MIN_RXDELAY 0
192
193#define DEFAULT_RADV 128
194#define MAX_RXABSDELAY 0xFFFF
195#define MIN_RXABSDELAY 0
196
197#define DEFAULT_TIDV 64
198#define MAX_TXDELAY 0xFFFF
199#define MIN_TXDELAY 0
200
201#define DEFAULT_TADV 64
202#define MAX_TXABSDELAY 0xFFFF
203#define MIN_TXABSDELAY 0
204
205#define DEFAULT_ITR 8000
206#define MAX_ITR 100000
207#define MIN_ITR 100
208
209struct e1000_option {
210 enum { enable_option, range_option, list_option } type;
211 char *name;
212 char *err;
213 int def;
214 union {
215 struct { /* range_option info */
216 int min;
217 int max;
218 } r;
219 struct { /* list_option info */
220 int nr;
221 struct e1000_opt_list { int i; char *str; } *p;
222 } l;
223 } arg;
224};
225
226static int __devinit
227e1000_validate_option(int *value, struct e1000_option *opt,
228 struct e1000_adapter *adapter)
229{
230 if(*value == OPTION_UNSET) {
231 *value = opt->def;
232 return 0;
233 }
234
235 switch (opt->type) {
236 case enable_option:
237 switch (*value) {
238 case OPTION_ENABLED:
239 DPRINTK(PROBE, INFO, "%s Enabled\n", opt->name);
240 return 0;
241 case OPTION_DISABLED:
242 DPRINTK(PROBE, INFO, "%s Disabled\n", opt->name);
243 return 0;
244 }
245 break;
246 case range_option:
247 if(*value >= opt->arg.r.min && *value <= opt->arg.r.max) {
248 DPRINTK(PROBE, INFO,
249 "%s set to %i\n", opt->name, *value);
250 return 0;
251 }
252 break;
253 case list_option: {
254 int i;
255 struct e1000_opt_list *ent;
256
257 for(i = 0; i < opt->arg.l.nr; i++) {
258 ent = &opt->arg.l.p[i];
259 if(*value == ent->i) {
260 if(ent->str[0] != '\0')
261 DPRINTK(PROBE, INFO, "%s\n", ent->str);
262 return 0;
263 }
264 }
265 }
266 break;
267 default:
268 BUG();
269 }
270
271 DPRINTK(PROBE, INFO, "Invalid %s specified (%i) %s\n",
272 opt->name, *value, opt->err);
273 *value = opt->def;
274 return -1;
275}
276
277static void e1000_check_fiber_options(struct e1000_adapter *adapter);
278static void e1000_check_copper_options(struct e1000_adapter *adapter);
279
280/**
281 * e1000_check_options - Range Checking for Command Line Parameters
282 * @adapter: board private structure
283 *
284 * This routine checks all command line parameters for valid user
285 * input. If an invalid value is given, or if no user specified
286 * value exists, a default value is used. The final value is stored
287 * in a variable in the adapter structure.
288 **/
289
290void __devinit
291e1000_check_options(struct e1000_adapter *adapter)
292{
293 int bd = adapter->bd_number;
294 if(bd >= E1000_MAX_NIC) {
295 DPRINTK(PROBE, NOTICE,
296 "Warning: no configuration for board #%i\n", bd);
297 DPRINTK(PROBE, NOTICE, "Using defaults for all values\n");
298 }
299
300 { /* Transmit Descriptor Count */
301 struct e1000_option opt = {
302 .type = range_option,
303 .name = "Transmit Descriptors",
304 .err = "using default of "
305 __MODULE_STRING(E1000_DEFAULT_TXD),
306 .def = E1000_DEFAULT_TXD,
307 .arg = { .r = { .min = E1000_MIN_TXD }}
308 };
581d708e
MC		 309 struct e1000_tx_ring *tx_ring = adapter->tx_ring;
310 int i;
1da177e4
LT		 311 e1000_mac_type mac_type = adapter->hw.mac_type;
312 opt.arg.r.max = mac_type < e1000_82544 ?
313 E1000_MAX_TXD : E1000_MAX_82544_TXD;
314
315 if (num_TxDescriptors > bd) {
316 tx_ring->count = TxDescriptors[bd];
317 e1000_validate_option(&tx_ring->count, &opt, adapter);
318 E1000_ROUNDUP(tx_ring->count,
319 REQ_TX_DESCRIPTOR_MULTIPLE);
320 } else {
321 tx_ring->count = opt.def;
322 }
f56799ea 323 for (i = 0; i < adapter->num_tx_queues; i++)
581d708e 324 tx_ring[i].count = tx_ring->count;
1da177e4
LT		 325 }
326 { /* Receive Descriptor Count */
327 struct e1000_option opt = {
328 .type = range_option,
329 .name = "Receive Descriptors",
330 .err = "using default of "
331 __MODULE_STRING(E1000_DEFAULT_RXD),
332 .def = E1000_DEFAULT_RXD,
333 .arg = { .r = { .min = E1000_MIN_RXD }}
334 };
581d708e
MC		 335 struct e1000_rx_ring *rx_ring = adapter->rx_ring;
336 int i;
1da177e4
LT		 337 e1000_mac_type mac_type = adapter->hw.mac_type;
338 opt.arg.r.max = mac_type < e1000_82544 ? E1000_MAX_RXD :
339 E1000_MAX_82544_RXD;
340
341 if (num_RxDescriptors > bd) {
342 rx_ring->count = RxDescriptors[bd];
343 e1000_validate_option(&rx_ring->count, &opt, adapter);
344 E1000_ROUNDUP(rx_ring->count,
345 REQ_RX_DESCRIPTOR_MULTIPLE);
346 } else {
347 rx_ring->count = opt.def;
348 }
f56799ea 349 for (i = 0; i < adapter->num_rx_queues; i++)
581d708e 350 rx_ring[i].count = rx_ring->count;
1da177e4
LT		 351 }
352 { /* Checksum Offload Enable/Disable */
353 struct e1000_option opt = {
354 .type = enable_option,
355 .name = "Checksum Offload",
356 .err = "defaulting to Enabled",
357 .def = OPTION_ENABLED
358 };
359
360 if (num_XsumRX > bd) {
361 int rx_csum = XsumRX[bd];
362 e1000_validate_option(&rx_csum, &opt, adapter);
363 adapter->rx_csum = rx_csum;
364 } else {
365 adapter->rx_csum = opt.def;
366 }
367 }
368 { /* Flow Control */
369
370 struct e1000_opt_list fc_list[] =
371 {{ e1000_fc_none, "Flow Control Disabled" },
372 { e1000_fc_rx_pause,"Flow Control Receive Only" },
373 { e1000_fc_tx_pause,"Flow Control Transmit Only" },
374 { e1000_fc_full, "Flow Control Enabled" },
375 { e1000_fc_default, "Flow Control Hardware Default" }};
376
377 struct e1000_option opt = {
378 .type = list_option,
379 .name = "Flow Control",
380 .err = "reading default settings from EEPROM",
381 .def = e1000_fc_default,
382 .arg = { .l = { .nr = ARRAY_SIZE(fc_list),
383 .p = fc_list }}
384 };
385
386 if (num_FlowControl > bd) {
387 int fc = FlowControl[bd];
388 e1000_validate_option(&fc, &opt, adapter);
389 adapter->hw.fc = adapter->hw.original_fc = fc;
390 } else {
f11b7f85 391 adapter->hw.fc = adapter->hw.original_fc = opt.def;
1da177e4
LT		 392 }
393 }
394 { /* Transmit Interrupt Delay */
395 struct e1000_option opt = {
396 .type = range_option,
397 .name = "Transmit Interrupt Delay",
398 .err = "using default of " __MODULE_STRING(DEFAULT_TIDV),
399 .def = DEFAULT_TIDV,
400 .arg = { .r = { .min = MIN_TXDELAY,
401 .max = MAX_TXDELAY }}
402 };
403
404 if (num_TxIntDelay > bd) {
405 adapter->tx_int_delay = TxIntDelay[bd];
406 e1000_validate_option(&adapter->tx_int_delay, &opt,
407 adapter);
408 } else {
409 adapter->tx_int_delay = opt.def;
410 }
411 }
412 { /* Transmit Absolute Interrupt Delay */
413 struct e1000_option opt = {
414 .type = range_option,
415 .name = "Transmit Absolute Interrupt Delay",
416 .err = "using default of " __MODULE_STRING(DEFAULT_TADV),
417 .def = DEFAULT_TADV,
418 .arg = { .r = { .min = MIN_TXABSDELAY,
419 .max = MAX_TXABSDELAY }}
420 };
421
422 if (num_TxAbsIntDelay > bd) {
423 adapter->tx_abs_int_delay = TxAbsIntDelay[bd];
424 e1000_validate_option(&adapter->tx_abs_int_delay, &opt,
425 adapter);
426 } else {
427 adapter->tx_abs_int_delay = opt.def;
428 }
429 }
430 { /* Receive Interrupt Delay */
431 struct e1000_option opt = {
432 .type = range_option,
433 .name = "Receive Interrupt Delay",
434 .err = "using default of " __MODULE_STRING(DEFAULT_RDTR),
435 .def = DEFAULT_RDTR,
436 .arg = { .r = { .min = MIN_RXDELAY,
437 .max = MAX_RXDELAY }}
438 };
439
440 if (num_RxIntDelay > bd) {
441 adapter->rx_int_delay = RxIntDelay[bd];
442 e1000_validate_option(&adapter->rx_int_delay, &opt,
443 adapter);
444 } else {
445 adapter->rx_int_delay = opt.def;
446 }
447 }
448 { /* Receive Absolute Interrupt Delay */
449 struct e1000_option opt = {
450 .type = range_option,
451 .name = "Receive Absolute Interrupt Delay",
452 .err = "using default of " __MODULE_STRING(DEFAULT_RADV),
453 .def = DEFAULT_RADV,
454 .arg = { .r = { .min = MIN_RXABSDELAY,
455 .max = MAX_RXABSDELAY }}
456 };
457
458 if (num_RxAbsIntDelay > bd) {
459 adapter->rx_abs_int_delay = RxAbsIntDelay[bd];
460 e1000_validate_option(&adapter->rx_abs_int_delay, &opt,
461 adapter);
462 } else {
463 adapter->rx_abs_int_delay = opt.def;
464 }
465 }
466 { /* Interrupt Throttling Rate */
467 struct e1000_option opt = {
468 .type = range_option,
469 .name = "Interrupt Throttling Rate (ints/sec)",
470 .err = "using default of " __MODULE_STRING(DEFAULT_ITR),
471 .def = DEFAULT_ITR,
472 .arg = { .r = { .min = MIN_ITR,
473 .max = MAX_ITR }}
474 };
475
476 if (num_InterruptThrottleRate > bd) {
477 adapter->itr = InterruptThrottleRate[bd];
478 switch(adapter->itr) {
479 case 0:
480 DPRINTK(PROBE, INFO, "%s turned off\n",
481 opt.name);
482 break;
483 case 1:
484 DPRINTK(PROBE, INFO, "%s set to dynamic mode\n",
485 opt.name);
486 break;
1da177e4
LT		 487 default:
488 e1000_validate_option(&adapter->itr, &opt,
489 adapter);
490 break;
491 }
492 } else {
493 adapter->itr = opt.def;
494 }
495 }
496
497 switch(adapter->hw.media_type) {
498 case e1000_media_type_fiber:
499 case e1000_media_type_internal_serdes:
500 e1000_check_fiber_options(adapter);
501 break;
502 case e1000_media_type_copper:
503 e1000_check_copper_options(adapter);
504 break;
505 default:
506 BUG();
507 }
508}
509
510/**
511 * e1000_check_fiber_options - Range Checking for Link Options, Fiber Version
512 * @adapter: board private structure
513 *
514 * Handles speed and duplex options on fiber adapters
515 **/
516
517static void __devinit
518e1000_check_fiber_options(struct e1000_adapter *adapter)
519{
520 int bd = adapter->bd_number;
521 if(num_Speed > bd) {
522 DPRINTK(PROBE, INFO, "Speed not valid for fiber adapters, "
523 "parameter ignored\n");
524 }
525
526 if(num_Duplex > bd) {
527 DPRINTK(PROBE, INFO, "Duplex not valid for fiber adapters, "
528 "parameter ignored\n");
529 }
530
531 if((num_AutoNeg > bd) && (AutoNeg[bd] != 0x20)) {
532 DPRINTK(PROBE, INFO, "AutoNeg other than 1000/Full is "
533 "not valid for fiber adapters, "
534 "parameter ignored\n");
535 }
536}
537
538/**
539 * e1000_check_copper_options - Range Checking for Link Options, Copper Version
540 * @adapter: board private structure
541 *
542 * Handles speed and duplex options on copper adapters
543 **/
544
545static void __devinit
546e1000_check_copper_options(struct e1000_adapter *adapter)
547{
32a4ec97 548 int speed, dplx, an;
1da177e4
LT		 549 int bd = adapter->bd_number;
550
551 { /* Speed */
552 struct e1000_opt_list speed_list[] = {{ 0, "" },
553 { SPEED_10, "" },
554 { SPEED_100, "" },
555 { SPEED_1000, "" }};
556
557 struct e1000_option opt = {
558 .type = list_option,
559 .name = "Speed",
560 .err = "parameter ignored",
561 .def = 0,
562 .arg = { .l = { .nr = ARRAY_SIZE(speed_list),
563 .p = speed_list }}
564 };
565
566 if (num_Speed > bd) {
567 speed = Speed[bd];
568 e1000_validate_option(&speed, &opt, adapter);
569 } else {
570 speed = opt.def;
571 }
572 }
573 { /* Duplex */
574 struct e1000_opt_list dplx_list[] = {{ 0, "" },
575 { HALF_DUPLEX, "" },
576 { FULL_DUPLEX, "" }};
577
578 struct e1000_option opt = {
579 .type = list_option,
580 .name = "Duplex",
581 .err = "parameter ignored",
582 .def = 0,
583 .arg = { .l = { .nr = ARRAY_SIZE(dplx_list),
584 .p = dplx_list }}
585 };
586
57128197
JK		 587 if (e1000_check_phy_reset_block(&adapter->hw)) {
588 DPRINTK(PROBE, INFO,
589 "Link active due to SoL/IDER Session. "
590 "Speed/Duplex/AutoNeg parameter ignored.\n");
591 return;
592 }
1da177e4
LT		 593 if (num_Duplex > bd) {
594 dplx = Duplex[bd];
595 e1000_validate_option(&dplx, &opt, adapter);
596 } else {
597 dplx = opt.def;
598 }
599 }
600
601 if((num_AutoNeg > bd) && (speed != 0 || dplx != 0)) {
602 DPRINTK(PROBE, INFO,
603 "AutoNeg specified along with Speed or Duplex, "
604 "parameter ignored\n");
605 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
606 } else { /* Autoneg */
607 struct e1000_opt_list an_list[] =
608 #define AA "AutoNeg advertising "
609 {{ 0x01, AA "10/HD" },
610 { 0x02, AA "10/FD" },
611 { 0x03, AA "10/FD, 10/HD" },
612 { 0x04, AA "100/HD" },
613 { 0x05, AA "100/HD, 10/HD" },
614 { 0x06, AA "100/HD, 10/FD" },
615 { 0x07, AA "100/HD, 10/FD, 10/HD" },
616 { 0x08, AA "100/FD" },
617 { 0x09, AA "100/FD, 10/HD" },
618 { 0x0a, AA "100/FD, 10/FD" },
619 { 0x0b, AA "100/FD, 10/FD, 10/HD" },
620 { 0x0c, AA "100/FD, 100/HD" },
621 { 0x0d, AA "100/FD, 100/HD, 10/HD" },
622 { 0x0e, AA "100/FD, 100/HD, 10/FD" },
623 { 0x0f, AA "100/FD, 100/HD, 10/FD, 10/HD" },
624 { 0x20, AA "1000/FD" },
625 { 0x21, AA "1000/FD, 10/HD" },
626 { 0x22, AA "1000/FD, 10/FD" },
627 { 0x23, AA "1000/FD, 10/FD, 10/HD" },
628 { 0x24, AA "1000/FD, 100/HD" },
629 { 0x25, AA "1000/FD, 100/HD, 10/HD" },
630 { 0x26, AA "1000/FD, 100/HD, 10/FD" },
631 { 0x27, AA "1000/FD, 100/HD, 10/FD, 10/HD" },
632 { 0x28, AA "1000/FD, 100/FD" },
633 { 0x29, AA "1000/FD, 100/FD, 10/HD" },
634 { 0x2a, AA "1000/FD, 100/FD, 10/FD" },
635 { 0x2b, AA "1000/FD, 100/FD, 10/FD, 10/HD" },
636 { 0x2c, AA "1000/FD, 100/FD, 100/HD" },
637 { 0x2d, AA "1000/FD, 100/FD, 100/HD, 10/HD" },
638 { 0x2e, AA "1000/FD, 100/FD, 100/HD, 10/FD" },
639 { 0x2f, AA "1000/FD, 100/FD, 100/HD, 10/FD, 10/HD" }};
640
641 struct e1000_option opt = {
642 .type = list_option,
643 .name = "AutoNeg",
644 .err = "parameter ignored",
645 .def = AUTONEG_ADV_DEFAULT,
646 .arg = { .l = { .nr = ARRAY_SIZE(an_list),
647 .p = an_list }}
648 };
649
32a4ec97
KK		 650 if (num_AutoNeg > bd) {
651 an = AutoNeg[bd];
652 e1000_validate_option(&an, &opt, adapter);
653 } else {
654 an = opt.def;
655 }
1da177e4
LT		 656 adapter->hw.autoneg_advertised = an;
657 }
658
659 switch (speed + dplx) {
660 case 0:
661 adapter->hw.autoneg = adapter->fc_autoneg = 1;
662 if((num_Speed > bd) && (speed != 0 || dplx != 0))
663 DPRINTK(PROBE, INFO,
664 "Speed and duplex autonegotiation enabled\n");
665 break;
666 case HALF_DUPLEX:
667 DPRINTK(PROBE, INFO, "Half Duplex specified without Speed\n");
668 DPRINTK(PROBE, INFO, "Using Autonegotiation at "
669 "Half Duplex only\n");
670 adapter->hw.autoneg = adapter->fc_autoneg = 1;
671 adapter->hw.autoneg_advertised = ADVERTISE_10_HALF |
672 ADVERTISE_100_HALF;
673 break;
674 case FULL_DUPLEX:
675 DPRINTK(PROBE, INFO, "Full Duplex specified without Speed\n");
676 DPRINTK(PROBE, INFO, "Using Autonegotiation at "
677 "Full Duplex only\n");
678 adapter->hw.autoneg = adapter->fc_autoneg = 1;
679 adapter->hw.autoneg_advertised = ADVERTISE_10_FULL |
680 ADVERTISE_100_FULL |
681 ADVERTISE_1000_FULL;
682 break;
683 case SPEED_10:
684 DPRINTK(PROBE, INFO, "10 Mbps Speed specified "
685 "without Duplex\n");
686 DPRINTK(PROBE, INFO, "Using Autonegotiation at 10 Mbps only\n");
687 adapter->hw.autoneg = adapter->fc_autoneg = 1;
688 adapter->hw.autoneg_advertised = ADVERTISE_10_HALF |
689 ADVERTISE_10_FULL;
690 break;
691 case SPEED_10 + HALF_DUPLEX:
692 DPRINTK(PROBE, INFO, "Forcing to 10 Mbps Half Duplex\n");
693 adapter->hw.autoneg = adapter->fc_autoneg = 0;
694 adapter->hw.forced_speed_duplex = e1000_10_half;
695 adapter->hw.autoneg_advertised = 0;
696 break;
697 case SPEED_10 + FULL_DUPLEX:
698 DPRINTK(PROBE, INFO, "Forcing to 10 Mbps Full Duplex\n");
699 adapter->hw.autoneg = adapter->fc_autoneg = 0;
700 adapter->hw.forced_speed_duplex = e1000_10_full;
701 adapter->hw.autoneg_advertised = 0;
702 break;
703 case SPEED_100:
704 DPRINTK(PROBE, INFO, "100 Mbps Speed specified "
705 "without Duplex\n");
706 DPRINTK(PROBE, INFO, "Using Autonegotiation at "
707 "100 Mbps only\n");
708 adapter->hw.autoneg = adapter->fc_autoneg = 1;
709 adapter->hw.autoneg_advertised = ADVERTISE_100_HALF |
710 ADVERTISE_100_FULL;
711 break;
712 case SPEED_100 + HALF_DUPLEX:
713 DPRINTK(PROBE, INFO, "Forcing to 100 Mbps Half Duplex\n");
714 adapter->hw.autoneg = adapter->fc_autoneg = 0;
715 adapter->hw.forced_speed_duplex = e1000_100_half;
716 adapter->hw.autoneg_advertised = 0;
717 break;
718 case SPEED_100 + FULL_DUPLEX:
719 DPRINTK(PROBE, INFO, "Forcing to 100 Mbps Full Duplex\n");
720 adapter->hw.autoneg = adapter->fc_autoneg = 0;
721 adapter->hw.forced_speed_duplex = e1000_100_full;
722 adapter->hw.autoneg_advertised = 0;
723 break;
724 case SPEED_1000:
725 DPRINTK(PROBE, INFO, "1000 Mbps Speed specified without "
726 "Duplex\n");
727 DPRINTK(PROBE, INFO,
728 "Using Autonegotiation at 1000 Mbps "
729 "Full Duplex only\n");
730 adapter->hw.autoneg = adapter->fc_autoneg = 1;
731 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
732 break;
733 case SPEED_1000 + HALF_DUPLEX:
734 DPRINTK(PROBE, INFO,
735 "Half Duplex is not supported at 1000 Mbps\n");
736 DPRINTK(PROBE, INFO,
737 "Using Autonegotiation at 1000 Mbps "
738 "Full Duplex only\n");
739 adapter->hw.autoneg = adapter->fc_autoneg = 1;
740 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
741 break;
742 case SPEED_1000 + FULL_DUPLEX:
743 DPRINTK(PROBE, INFO,
744 "Using Autonegotiation at 1000 Mbps Full Duplex only\n");
745 adapter->hw.autoneg = adapter->fc_autoneg = 1;
746 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
747 break;
748 default:
749 BUG();
750 }
751
752 /* Speed, AutoNeg and MDI/MDI-X must all play nice */
753 if (e1000_validate_mdi_setting(&(adapter->hw)) < 0) {
754 DPRINTK(PROBE, INFO,
755 "Speed, AutoNeg and MDI-X specifications are "
756 "incompatible. Setting MDI-X to a compatible value.\n");
757 }
758}
759
Linux 6.x block layer and io_uring tree(s)