1 /*******************************************************************************
3 Intel PRO/1000 Linux driver
4 Copyright(c) 1999 - 2006 Intel Corporation.
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.
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
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.
19 The full GNU General Public License is included in this distribution in
20 the file called "COPYING".
25 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *******************************************************************************/
31 /* This is the only thing that needs to be changed to adjust the
32 * maximum number of ports that the driver can manage.
35 #define E1000_MAX_NIC 32
37 #define OPTION_UNSET -1
38 #define OPTION_DISABLED 0
39 #define OPTION_ENABLED 1
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).
46 #define E1000_PARAM_INIT { [0 ... E1000_MAX_NIC] = OPTION_UNSET }
47 #define E1000_PARAM(X, desc) \
48 static int 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);
53 /* Transmit Descriptor Count
55 * Valid Range: 80-256 for 82542 and 82543 gigabit ethernet controllers
56 * Valid Range: 80-4096 for 82544 and newer
60 E1000_PARAM(TxDescriptors, "Number of transmit descriptors");
62 /* Receive Descriptor Count
64 * Valid Range: 80-256 for 82542 and 82543 gigabit ethernet controllers
65 * Valid Range: 80-4096 for 82544 and newer
69 E1000_PARAM(RxDescriptors, "Number of receive descriptors");
71 /* User Specified Speed Override
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
81 E1000_PARAM(Speed, "Speed setting");
83 /* User Specified Duplex Override
86 * - 0 - auto-negotiate for duplex
87 * - 1 - only link at half duplex
88 * - 2 - only link at full duplex
92 E1000_PARAM(Duplex, "Duplex setting");
94 /* Auto-negotiation Advertisement Override
96 * Valid Range: 0x01-0x0F, 0x20-0x2F (copper); 0x20 (fiber)
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
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
106 * Default Value: 0x2F (copper); 0x20 (fiber)
108 E1000_PARAM(AutoNeg, "Advertised auto-negotiation setting");
109 #define AUTONEG_ADV_DEFAULT 0x2F
110 #define AUTONEG_ADV_MASK 0x2F
112 /* User Specified Flow Control Override
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
120 * Default Value: Read flow control settings from the EEPROM
122 E1000_PARAM(FlowControl, "Flow Control setting");
123 #define FLOW_CONTROL_DEFAULT FLOW_CONTROL_FULL
125 /* XsumRX - Receive Checksum Offload Enable/Disable
128 * - 0 - disables all checksum offload
129 * - 1 - enables receive IP/TCP/UDP checksum offload
130 * on 82543 and newer -based NICs
134 E1000_PARAM(XsumRX, "Disable or enable Receive Checksum offload");
136 /* Transmit Interrupt Delay in units of 1.024 microseconds
137 * Tx interrupt delay needs to typically be set to something non zero
139 * Valid Range: 0-65535
141 E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay");
142 #define DEFAULT_TIDV 8
143 #define MAX_TXDELAY 0xFFFF
144 #define MIN_TXDELAY 0
146 /* Transmit Absolute Interrupt Delay in units of 1.024 microseconds
148 * Valid Range: 0-65535
150 E1000_PARAM(TxAbsIntDelay, "Transmit Absolute Interrupt Delay");
151 #define DEFAULT_TADV 32
152 #define MAX_TXABSDELAY 0xFFFF
153 #define MIN_TXABSDELAY 0
155 /* Receive Interrupt Delay in units of 1.024 microseconds
156 * hardware will likely hang if you set this to anything but zero.
158 * Valid Range: 0-65535
160 E1000_PARAM(RxIntDelay, "Receive Interrupt Delay");
161 #define DEFAULT_RDTR 0
162 #define MAX_RXDELAY 0xFFFF
163 #define MIN_RXDELAY 0
165 /* Receive Absolute Interrupt Delay in units of 1.024 microseconds
167 * Valid Range: 0-65535
169 E1000_PARAM(RxAbsIntDelay, "Receive Absolute Interrupt Delay");
170 #define DEFAULT_RADV 8
171 #define MAX_RXABSDELAY 0xFFFF
172 #define MIN_RXABSDELAY 0
174 /* Interrupt Throttle Rate (interrupts/sec)
176 * Valid Range: 100-100000 (0=off, 1=dynamic, 3=dynamic conservative)
178 E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate");
179 #define DEFAULT_ITR 3
180 #define MAX_ITR 100000
183 /* Enable Smart Power Down of the PHY
187 * Default Value: 0 (disabled)
189 E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down");
191 struct e1000_option {
192 enum { enable_option, range_option, list_option } type;
197 struct { /* range_option info */
201 struct { /* list_option info */
203 const struct e1000_opt_list { int i; char *str; } *p;
208 static int e1000_validate_option(unsigned int *value,
209 const struct e1000_option *opt,
210 struct e1000_adapter *adapter)
212 if (*value == OPTION_UNSET) {
221 e_dev_info("%s Enabled\n", opt->name);
223 case OPTION_DISABLED:
224 e_dev_info("%s Disabled\n", opt->name);
229 if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) {
230 e_dev_info("%s set to %i\n", opt->name, *value);
236 const struct e1000_opt_list *ent;
238 for (i = 0; i < opt->arg.l.nr; i++) {
239 ent = &opt->arg.l.p[i];
240 if (*value == ent->i) {
241 if (ent->str[0] != '\0')
242 e_dev_info("%s\n", ent->str);
252 e_dev_info("Invalid %s value specified (%i) %s\n",
253 opt->name, *value, opt->err);
258 static void e1000_check_fiber_options(struct e1000_adapter *adapter);
259 static void e1000_check_copper_options(struct e1000_adapter *adapter);
262 * e1000_check_options - Range Checking for Command Line Parameters
263 * @adapter: board private structure
265 * This routine checks all command line parameters for valid user
266 * input. If an invalid value is given, or if no user specified
267 * value exists, a default value is used. The final value is stored
268 * in a variable in the adapter structure.
270 void e1000_check_options(struct e1000_adapter *adapter)
272 struct e1000_option opt;
273 int bd = adapter->bd_number;
275 if (bd >= E1000_MAX_NIC) {
276 e_dev_warn("Warning: no configuration for board #%i "
277 "using defaults for all values\n", bd);
280 { /* Transmit Descriptor Count */
281 struct e1000_tx_ring *tx_ring = adapter->tx_ring;
283 e1000_mac_type mac_type = adapter->hw.mac_type;
285 opt = (struct e1000_option) {
286 .type = range_option,
287 .name = "Transmit Descriptors",
288 .err = "using default of "
289 __MODULE_STRING(E1000_DEFAULT_TXD),
290 .def = E1000_DEFAULT_TXD,
292 .min = E1000_MIN_TXD,
293 .max = mac_type < e1000_82544 ? E1000_MAX_TXD : E1000_MAX_82544_TXD
297 if (num_TxDescriptors > bd) {
298 tx_ring->count = TxDescriptors[bd];
299 e1000_validate_option(&tx_ring->count, &opt, adapter);
300 tx_ring->count = ALIGN(tx_ring->count,
301 REQ_TX_DESCRIPTOR_MULTIPLE);
303 tx_ring->count = opt.def;
305 for (i = 0; i < adapter->num_tx_queues; i++)
306 tx_ring[i].count = tx_ring->count;
308 { /* Receive Descriptor Count */
309 struct e1000_rx_ring *rx_ring = adapter->rx_ring;
311 e1000_mac_type mac_type = adapter->hw.mac_type;
313 opt = (struct e1000_option) {
314 .type = range_option,
315 .name = "Receive Descriptors",
316 .err = "using default of "
317 __MODULE_STRING(E1000_DEFAULT_RXD),
318 .def = E1000_DEFAULT_RXD,
320 .min = E1000_MIN_RXD,
321 .max = mac_type < e1000_82544 ? E1000_MAX_RXD :
326 if (num_RxDescriptors > bd) {
327 rx_ring->count = RxDescriptors[bd];
328 e1000_validate_option(&rx_ring->count, &opt, adapter);
329 rx_ring->count = ALIGN(rx_ring->count,
330 REQ_RX_DESCRIPTOR_MULTIPLE);
332 rx_ring->count = opt.def;
334 for (i = 0; i < adapter->num_rx_queues; i++)
335 rx_ring[i].count = rx_ring->count;
337 { /* Checksum Offload Enable/Disable */
338 opt = (struct e1000_option) {
339 .type = enable_option,
340 .name = "Checksum Offload",
341 .err = "defaulting to Enabled",
342 .def = OPTION_ENABLED
345 if (num_XsumRX > bd) {
346 unsigned int rx_csum = XsumRX[bd];
347 e1000_validate_option(&rx_csum, &opt, adapter);
348 adapter->rx_csum = rx_csum;
350 adapter->rx_csum = opt.def;
355 static const struct e1000_opt_list fc_list[] = {
356 { E1000_FC_NONE, "Flow Control Disabled" },
357 { E1000_FC_RX_PAUSE, "Flow Control Receive Only" },
358 { E1000_FC_TX_PAUSE, "Flow Control Transmit Only" },
359 { E1000_FC_FULL, "Flow Control Enabled" },
360 { E1000_FC_DEFAULT, "Flow Control Hardware Default" }
363 opt = (struct e1000_option) {
365 .name = "Flow Control",
366 .err = "reading default settings from EEPROM",
367 .def = E1000_FC_DEFAULT,
368 .arg = { .l = { .nr = ARRAY_SIZE(fc_list),
372 if (num_FlowControl > bd) {
373 unsigned int fc = FlowControl[bd];
374 e1000_validate_option(&fc, &opt, adapter);
375 adapter->hw.fc = adapter->hw.original_fc = fc;
377 adapter->hw.fc = adapter->hw.original_fc = opt.def;
380 { /* Transmit Interrupt Delay */
381 opt = (struct e1000_option) {
382 .type = range_option,
383 .name = "Transmit Interrupt Delay",
384 .err = "using default of " __MODULE_STRING(DEFAULT_TIDV),
386 .arg = { .r = { .min = MIN_TXDELAY,
387 .max = MAX_TXDELAY }}
390 if (num_TxIntDelay > bd) {
391 adapter->tx_int_delay = TxIntDelay[bd];
392 e1000_validate_option(&adapter->tx_int_delay, &opt,
395 adapter->tx_int_delay = opt.def;
398 { /* Transmit Absolute Interrupt Delay */
399 opt = (struct e1000_option) {
400 .type = range_option,
401 .name = "Transmit Absolute Interrupt Delay",
402 .err = "using default of " __MODULE_STRING(DEFAULT_TADV),
404 .arg = { .r = { .min = MIN_TXABSDELAY,
405 .max = MAX_TXABSDELAY }}
408 if (num_TxAbsIntDelay > bd) {
409 adapter->tx_abs_int_delay = TxAbsIntDelay[bd];
410 e1000_validate_option(&adapter->tx_abs_int_delay, &opt,
413 adapter->tx_abs_int_delay = opt.def;
416 { /* Receive Interrupt Delay */
417 opt = (struct e1000_option) {
418 .type = range_option,
419 .name = "Receive Interrupt Delay",
420 .err = "using default of " __MODULE_STRING(DEFAULT_RDTR),
422 .arg = { .r = { .min = MIN_RXDELAY,
423 .max = MAX_RXDELAY }}
426 if (num_RxIntDelay > bd) {
427 adapter->rx_int_delay = RxIntDelay[bd];
428 e1000_validate_option(&adapter->rx_int_delay, &opt,
431 adapter->rx_int_delay = opt.def;
434 { /* Receive Absolute Interrupt Delay */
435 opt = (struct e1000_option) {
436 .type = range_option,
437 .name = "Receive Absolute Interrupt Delay",
438 .err = "using default of " __MODULE_STRING(DEFAULT_RADV),
440 .arg = { .r = { .min = MIN_RXABSDELAY,
441 .max = MAX_RXABSDELAY }}
444 if (num_RxAbsIntDelay > bd) {
445 adapter->rx_abs_int_delay = RxAbsIntDelay[bd];
446 e1000_validate_option(&adapter->rx_abs_int_delay, &opt,
449 adapter->rx_abs_int_delay = opt.def;
452 { /* Interrupt Throttling Rate */
453 opt = (struct e1000_option) {
454 .type = range_option,
455 .name = "Interrupt Throttling Rate (ints/sec)",
456 .err = "using default of " __MODULE_STRING(DEFAULT_ITR),
458 .arg = { .r = { .min = MIN_ITR,
462 if (num_InterruptThrottleRate > bd) {
463 adapter->itr = InterruptThrottleRate[bd];
464 switch (adapter->itr) {
466 e_dev_info("%s turned off\n", opt.name);
469 e_dev_info("%s set to dynamic mode\n",
471 adapter->itr_setting = adapter->itr;
472 adapter->itr = 20000;
475 e_dev_info("%s set to dynamic conservative "
477 adapter->itr_setting = adapter->itr;
478 adapter->itr = 20000;
481 e_dev_info("%s set to simplified "
482 "(2000-8000) ints mode\n", opt.name);
483 adapter->itr_setting = adapter->itr;
486 e1000_validate_option(&adapter->itr, &opt,
488 /* save the setting, because the dynamic bits
490 * clear the lower two bits because they are
493 adapter->itr_setting = adapter->itr & ~3;
497 adapter->itr_setting = opt.def;
498 adapter->itr = 20000;
501 { /* Smart Power Down */
502 opt = (struct e1000_option) {
503 .type = enable_option,
504 .name = "PHY Smart Power Down",
505 .err = "defaulting to Disabled",
506 .def = OPTION_DISABLED
509 if (num_SmartPowerDownEnable > bd) {
510 unsigned int spd = SmartPowerDownEnable[bd];
511 e1000_validate_option(&spd, &opt, adapter);
512 adapter->smart_power_down = spd;
514 adapter->smart_power_down = opt.def;
518 switch (adapter->hw.media_type) {
519 case e1000_media_type_fiber:
520 case e1000_media_type_internal_serdes:
521 e1000_check_fiber_options(adapter);
523 case e1000_media_type_copper:
524 e1000_check_copper_options(adapter);
532 * e1000_check_fiber_options - Range Checking for Link Options, Fiber Version
533 * @adapter: board private structure
535 * Handles speed and duplex options on fiber adapters
537 static void e1000_check_fiber_options(struct e1000_adapter *adapter)
539 int bd = adapter->bd_number;
540 if (num_Speed > bd) {
541 e_dev_info("Speed not valid for fiber adapters, parameter "
545 if (num_Duplex > bd) {
546 e_dev_info("Duplex not valid for fiber adapters, parameter "
550 if ((num_AutoNeg > bd) && (AutoNeg[bd] != 0x20)) {
551 e_dev_info("AutoNeg other than 1000/Full is not valid for fiber"
552 "adapters, parameter ignored\n");
557 * e1000_check_copper_options - Range Checking for Link Options, Copper Version
558 * @adapter: board private structure
560 * Handles speed and duplex options on copper adapters
562 static void e1000_check_copper_options(struct e1000_adapter *adapter)
564 struct e1000_option opt;
565 unsigned int speed, dplx, an;
566 int bd = adapter->bd_number;
569 static const struct e1000_opt_list speed_list[] = {
575 opt = (struct e1000_option) {
578 .err = "parameter ignored",
580 .arg = { .l = { .nr = ARRAY_SIZE(speed_list),
584 if (num_Speed > bd) {
586 e1000_validate_option(&speed, &opt, adapter);
592 static const struct e1000_opt_list dplx_list[] = {
595 { FULL_DUPLEX, "" }};
597 opt = (struct e1000_option) {
600 .err = "parameter ignored",
602 .arg = { .l = { .nr = ARRAY_SIZE(dplx_list),
606 if (num_Duplex > bd) {
608 e1000_validate_option(&dplx, &opt, adapter);
614 if ((num_AutoNeg > bd) && (speed != 0 || dplx != 0)) {
615 e_dev_info("AutoNeg specified along with Speed or Duplex, "
616 "parameter ignored\n");
617 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
618 } else { /* Autoneg */
619 static const struct e1000_opt_list an_list[] =
620 #define AA "AutoNeg advertising "
621 {{ 0x01, AA "10/HD" },
622 { 0x02, AA "10/FD" },
623 { 0x03, AA "10/FD, 10/HD" },
624 { 0x04, AA "100/HD" },
625 { 0x05, AA "100/HD, 10/HD" },
626 { 0x06, AA "100/HD, 10/FD" },
627 { 0x07, AA "100/HD, 10/FD, 10/HD" },
628 { 0x08, AA "100/FD" },
629 { 0x09, AA "100/FD, 10/HD" },
630 { 0x0a, AA "100/FD, 10/FD" },
631 { 0x0b, AA "100/FD, 10/FD, 10/HD" },
632 { 0x0c, AA "100/FD, 100/HD" },
633 { 0x0d, AA "100/FD, 100/HD, 10/HD" },
634 { 0x0e, AA "100/FD, 100/HD, 10/FD" },
635 { 0x0f, AA "100/FD, 100/HD, 10/FD, 10/HD" },
636 { 0x20, AA "1000/FD" },
637 { 0x21, AA "1000/FD, 10/HD" },
638 { 0x22, AA "1000/FD, 10/FD" },
639 { 0x23, AA "1000/FD, 10/FD, 10/HD" },
640 { 0x24, AA "1000/FD, 100/HD" },
641 { 0x25, AA "1000/FD, 100/HD, 10/HD" },
642 { 0x26, AA "1000/FD, 100/HD, 10/FD" },
643 { 0x27, AA "1000/FD, 100/HD, 10/FD, 10/HD" },
644 { 0x28, AA "1000/FD, 100/FD" },
645 { 0x29, AA "1000/FD, 100/FD, 10/HD" },
646 { 0x2a, AA "1000/FD, 100/FD, 10/FD" },
647 { 0x2b, AA "1000/FD, 100/FD, 10/FD, 10/HD" },
648 { 0x2c, AA "1000/FD, 100/FD, 100/HD" },
649 { 0x2d, AA "1000/FD, 100/FD, 100/HD, 10/HD" },
650 { 0x2e, AA "1000/FD, 100/FD, 100/HD, 10/FD" },
651 { 0x2f, AA "1000/FD, 100/FD, 100/HD, 10/FD, 10/HD" }};
653 opt = (struct e1000_option) {
656 .err = "parameter ignored",
657 .def = AUTONEG_ADV_DEFAULT,
658 .arg = { .l = { .nr = ARRAY_SIZE(an_list),
662 if (num_AutoNeg > bd) {
664 e1000_validate_option(&an, &opt, adapter);
668 adapter->hw.autoneg_advertised = an;
671 switch (speed + dplx) {
673 adapter->hw.autoneg = adapter->fc_autoneg = 1;
674 if ((num_Speed > bd) && (speed != 0 || dplx != 0))
675 e_dev_info("Speed and duplex autonegotiation "
679 e_dev_info("Half Duplex specified without Speed\n");
680 e_dev_info("Using Autonegotiation at Half Duplex only\n");
681 adapter->hw.autoneg = adapter->fc_autoneg = 1;
682 adapter->hw.autoneg_advertised = ADVERTISE_10_HALF |
686 e_dev_info("Full Duplex specified without Speed\n");
687 e_dev_info("Using Autonegotiation at Full Duplex only\n");
688 adapter->hw.autoneg = adapter->fc_autoneg = 1;
689 adapter->hw.autoneg_advertised = ADVERTISE_10_FULL |
694 e_dev_info("10 Mbps Speed specified without Duplex\n");
695 e_dev_info("Using Autonegotiation at 10 Mbps only\n");
696 adapter->hw.autoneg = adapter->fc_autoneg = 1;
697 adapter->hw.autoneg_advertised = ADVERTISE_10_HALF |
700 case SPEED_10 + HALF_DUPLEX:
701 e_dev_info("Forcing to 10 Mbps Half Duplex\n");
702 adapter->hw.autoneg = adapter->fc_autoneg = 0;
703 adapter->hw.forced_speed_duplex = e1000_10_half;
704 adapter->hw.autoneg_advertised = 0;
706 case SPEED_10 + FULL_DUPLEX:
707 e_dev_info("Forcing to 10 Mbps Full Duplex\n");
708 adapter->hw.autoneg = adapter->fc_autoneg = 0;
709 adapter->hw.forced_speed_duplex = e1000_10_full;
710 adapter->hw.autoneg_advertised = 0;
713 e_dev_info("100 Mbps Speed specified without Duplex\n");
714 e_dev_info("Using Autonegotiation at 100 Mbps only\n");
715 adapter->hw.autoneg = adapter->fc_autoneg = 1;
716 adapter->hw.autoneg_advertised = ADVERTISE_100_HALF |
719 case SPEED_100 + HALF_DUPLEX:
720 e_dev_info("Forcing to 100 Mbps Half Duplex\n");
721 adapter->hw.autoneg = adapter->fc_autoneg = 0;
722 adapter->hw.forced_speed_duplex = e1000_100_half;
723 adapter->hw.autoneg_advertised = 0;
725 case SPEED_100 + FULL_DUPLEX:
726 e_dev_info("Forcing to 100 Mbps Full Duplex\n");
727 adapter->hw.autoneg = adapter->fc_autoneg = 0;
728 adapter->hw.forced_speed_duplex = e1000_100_full;
729 adapter->hw.autoneg_advertised = 0;
732 e_dev_info("1000 Mbps Speed specified without Duplex\n");
733 goto full_duplex_only;
734 case SPEED_1000 + HALF_DUPLEX:
735 e_dev_info("Half Duplex is not supported at 1000 Mbps\n");
737 case SPEED_1000 + FULL_DUPLEX:
739 e_dev_info("Using Autonegotiation at 1000 Mbps Full Duplex "
741 adapter->hw.autoneg = adapter->fc_autoneg = 1;
742 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
748 /* Speed, AutoNeg and MDI/MDI-X must all play nice */
749 if (e1000_validate_mdi_setting(&(adapter->hw)) < 0) {
750 e_dev_info("Speed, AutoNeg and MDI-X specs are incompatible. "
751 "Setting MDI-X to a compatible value.\n");