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