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