Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
e1000_param.c
Go to the documentation of this file.
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 <[email protected]>
24  e1000-devel Mailing List <[email protected]>
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 struct e1000_option {
192  enum { enable_option, range_option, list_option } type;
193  const char *name;
194  const char *err;
195  int def;
196  union {
197  struct { /* range_option info */
198  int min;
199  int max;
200  } r;
201  struct { /* list_option info */
202  int nr;
203  const struct e1000_opt_list { int i; char *str; } *p;
204  } l;
205  } arg;
206 };
207 
208 static int __devinit e1000_validate_option(unsigned int *value,
209  const struct e1000_option *opt,
210  struct e1000_adapter *adapter)
211 {
212  if (*value == OPTION_UNSET) {
213  *value = opt->def;
214  return 0;
215  }
216 
217  switch (opt->type) {
218  case enable_option:
219  switch (*value) {
220  case OPTION_ENABLED:
221  e_dev_info("%s Enabled\n", opt->name);
222  return 0;
223  case OPTION_DISABLED:
224  e_dev_info("%s Disabled\n", opt->name);
225  return 0;
226  }
227  break;
228  case range_option:
229  if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) {
230  e_dev_info("%s set to %i\n", opt->name, *value);
231  return 0;
232  }
233  break;
234  case list_option: {
235  int i;
236  const struct e1000_opt_list *ent;
237 
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);
243  return 0;
244  }
245  }
246  }
247  break;
248  default:
249  BUG();
250  }
251 
252  e_dev_info("Invalid %s value specified (%i) %s\n",
253  opt->name, *value, opt->err);
254  *value = opt->def;
255  return -1;
256 }
257 
258 static void e1000_check_fiber_options(struct e1000_adapter *adapter);
259 static void e1000_check_copper_options(struct e1000_adapter *adapter);
260 
271 void __devinit e1000_check_options(struct e1000_adapter *adapter)
272 {
273  struct e1000_option opt;
274  int bd = adapter->bd_number;
275 
276  if (bd >= E1000_MAX_NIC) {
277  e_dev_warn("Warning: no configuration for board #%i "
278  "using defaults for all values\n", bd);
279  }
280 
281  { /* Transmit Descriptor Count */
282  struct e1000_tx_ring *tx_ring = adapter->tx_ring;
283  int i;
284  e1000_mac_type mac_type = adapter->hw.mac_type;
285 
286  opt = (struct e1000_option) {
287  .type = range_option,
288  .name = "Transmit Descriptors",
289  .err = "using default of "
290  __MODULE_STRING(E1000_DEFAULT_TXD),
291  .def = E1000_DEFAULT_TXD,
292  .arg = { .r = {
293  .min = E1000_MIN_TXD,
294  .max = mac_type < e1000_82544 ? E1000_MAX_TXD : E1000_MAX_82544_TXD
295  }}
296  };
297 
298  if (num_TxDescriptors > bd) {
299  tx_ring->count = TxDescriptors[bd];
300  e1000_validate_option(&tx_ring->count, &opt, adapter);
301  tx_ring->count = ALIGN(tx_ring->count,
302  REQ_TX_DESCRIPTOR_MULTIPLE);
303  } else {
304  tx_ring->count = opt.def;
305  }
306  for (i = 0; i < adapter->num_tx_queues; i++)
307  tx_ring[i].count = tx_ring->count;
308  }
309  { /* Receive Descriptor Count */
310  struct e1000_rx_ring *rx_ring = adapter->rx_ring;
311  int i;
312  e1000_mac_type mac_type = adapter->hw.mac_type;
313 
314  opt = (struct e1000_option) {
315  .type = range_option,
316  .name = "Receive Descriptors",
317  .err = "using default of "
318  __MODULE_STRING(E1000_DEFAULT_RXD),
319  .def = E1000_DEFAULT_RXD,
320  .arg = { .r = {
321  .min = E1000_MIN_RXD,
322  .max = mac_type < e1000_82544 ? E1000_MAX_RXD : E1000_MAX_82544_RXD
323  }}
324  };
325 
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);
331  } else {
332  rx_ring->count = opt.def;
333  }
334  for (i = 0; i < adapter->num_rx_queues; i++)
335  rx_ring[i].count = rx_ring->count;
336  }
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
343  };
344 
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;
349  } else {
350  adapter->rx_csum = opt.def;
351  }
352  }
353  { /* Flow Control */
354 
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" }
361  };
362 
363  opt = (struct e1000_option) {
364  .type = list_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),
369  .p = fc_list }}
370  };
371 
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;
376  } else {
377  adapter->hw.fc = adapter->hw.original_fc = opt.def;
378  }
379  }
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),
385  .def = DEFAULT_TIDV,
386  .arg = { .r = { .min = MIN_TXDELAY,
387  .max = MAX_TXDELAY }}
388  };
389 
390  if (num_TxIntDelay > bd) {
391  adapter->tx_int_delay = TxIntDelay[bd];
392  e1000_validate_option(&adapter->tx_int_delay, &opt,
393  adapter);
394  } else {
395  adapter->tx_int_delay = opt.def;
396  }
397  }
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),
403  .def = DEFAULT_TADV,
404  .arg = { .r = { .min = MIN_TXABSDELAY,
405  .max = MAX_TXABSDELAY }}
406  };
407 
408  if (num_TxAbsIntDelay > bd) {
409  adapter->tx_abs_int_delay = TxAbsIntDelay[bd];
410  e1000_validate_option(&adapter->tx_abs_int_delay, &opt,
411  adapter);
412  } else {
413  adapter->tx_abs_int_delay = opt.def;
414  }
415  }
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),
421  .def = DEFAULT_RDTR,
422  .arg = { .r = { .min = MIN_RXDELAY,
423  .max = MAX_RXDELAY }}
424  };
425 
426  if (num_RxIntDelay > bd) {
427  adapter->rx_int_delay = RxIntDelay[bd];
428  e1000_validate_option(&adapter->rx_int_delay, &opt,
429  adapter);
430  } else {
431  adapter->rx_int_delay = opt.def;
432  }
433  }
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),
439  .def = DEFAULT_RADV,
440  .arg = { .r = { .min = MIN_RXABSDELAY,
441  .max = MAX_RXABSDELAY }}
442  };
443 
444  if (num_RxAbsIntDelay > bd) {
445  adapter->rx_abs_int_delay = RxAbsIntDelay[bd];
446  e1000_validate_option(&adapter->rx_abs_int_delay, &opt,
447  adapter);
448  } else {
449  adapter->rx_abs_int_delay = opt.def;
450  }
451  }
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),
457  .def = DEFAULT_ITR,
458  .arg = { .r = { .min = MIN_ITR,
459  .max = MAX_ITR }}
460  };
461 
462  if (num_InterruptThrottleRate > bd) {
463  adapter->itr = InterruptThrottleRate[bd];
464  switch (adapter->itr) {
465  case 0:
466  e_dev_info("%s turned off\n", opt.name);
467  break;
468  case 1:
469  e_dev_info("%s set to dynamic mode\n",
470  opt.name);
471  adapter->itr_setting = adapter->itr;
472  adapter->itr = 20000;
473  break;
474  case 3:
475  e_dev_info("%s set to dynamic conservative "
476  "mode\n", opt.name);
477  adapter->itr_setting = adapter->itr;
478  adapter->itr = 20000;
479  break;
480  case 4:
481  e_dev_info("%s set to simplified "
482  "(2000-8000) ints mode\n", opt.name);
483  adapter->itr_setting = adapter->itr;
484  break;
485  default:
486  e1000_validate_option(&adapter->itr, &opt,
487  adapter);
488  /* save the setting, because the dynamic bits
489  * change itr.
490  * clear the lower two bits because they are
491  * used as control */
492  adapter->itr_setting = adapter->itr & ~3;
493  break;
494  }
495  } else {
496  adapter->itr_setting = opt.def;
497  adapter->itr = 20000;
498  }
499  }
500  { /* Smart Power Down */
501  opt = (struct e1000_option) {
502  .type = enable_option,
503  .name = "PHY Smart Power Down",
504  .err = "defaulting to Disabled",
505  .def = OPTION_DISABLED
506  };
507 
508  if (num_SmartPowerDownEnable > bd) {
509  unsigned int spd = SmartPowerDownEnable[bd];
510  e1000_validate_option(&spd, &opt, adapter);
511  adapter->smart_power_down = spd;
512  } else {
513  adapter->smart_power_down = opt.def;
514  }
515  }
516 
517  switch (adapter->hw.media_type) {
518  case e1000_media_type_fiber:
519  case e1000_media_type_internal_serdes:
520  e1000_check_fiber_options(adapter);
521  break;
522  case e1000_media_type_copper:
523  e1000_check_copper_options(adapter);
524  break;
525  default:
526  BUG();
527  }
528 }
529 
537 static void __devinit e1000_check_fiber_options(struct e1000_adapter *adapter)
538 {
539  int bd = adapter->bd_number;
540  if (num_Speed > bd) {
541  e_dev_info("Speed not valid for fiber adapters, parameter "
542  "ignored\n");
543  }
544 
545  if (num_Duplex > bd) {
546  e_dev_info("Duplex not valid for fiber adapters, parameter "
547  "ignored\n");
548  }
549 
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");
553  }
554 }
555 
563 static void __devinit e1000_check_copper_options(struct e1000_adapter *adapter)
564 {
565  struct e1000_option opt;
566  unsigned int speed, dplx, an;
567  int bd = adapter->bd_number;
568 
569  { /* Speed */
570  static const struct e1000_opt_list speed_list[] = {
571  { 0, "" },
572  { SPEED_10, "" },
573  { SPEED_100, "" },
574  { SPEED_1000, "" }};
575 
576  opt = (struct e1000_option) {
577  .type = list_option,
578  .name = "Speed",
579  .err = "parameter ignored",
580  .def = 0,
581  .arg = { .l = { .nr = ARRAY_SIZE(speed_list),
582  .p = speed_list }}
583  };
584 
585  if (num_Speed > bd) {
586  speed = Speed[bd];
587  e1000_validate_option(&speed, &opt, adapter);
588  } else {
589  speed = opt.def;
590  }
591  }
592  { /* Duplex */
593  static const struct e1000_opt_list dplx_list[] = {
594  { 0, "" },
595  { HALF_DUPLEX, "" },
596  { FULL_DUPLEX, "" }};
597 
598  opt = (struct e1000_option) {
599  .type = list_option,
600  .name = "Duplex",
601  .err = "parameter ignored",
602  .def = 0,
603  .arg = { .l = { .nr = ARRAY_SIZE(dplx_list),
604  .p = dplx_list }}
605  };
606 
607  if (num_Duplex > bd) {
608  dplx = Duplex[bd];
609  e1000_validate_option(&dplx, &opt, adapter);
610  } else {
611  dplx = opt.def;
612  }
613  }
614 
615  if ((num_AutoNeg > bd) && (speed != 0 || dplx != 0)) {
616  e_dev_info("AutoNeg specified along with Speed or Duplex, "
617  "parameter ignored\n");
618  adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT;
619  } else { /* Autoneg */
620  static const struct e1000_opt_list an_list[] =
621  #define AA "AutoNeg advertising "
622  {{ 0x01, AA "10/HD" },
623  { 0x02, AA "10/FD" },
624  { 0x03, AA "10/FD, 10/HD" },
625  { 0x04, AA "100/HD" },
626  { 0x05, AA "100/HD, 10/HD" },
627  { 0x06, AA "100/HD, 10/FD" },
628  { 0x07, AA "100/HD, 10/FD, 10/HD" },
629  { 0x08, AA "100/FD" },
630  { 0x09, AA "100/FD, 10/HD" },
631  { 0x0a, AA "100/FD, 10/FD" },
632  { 0x0b, AA "100/FD, 10/FD, 10/HD" },
633  { 0x0c, AA "100/FD, 100/HD" },
634  { 0x0d, AA "100/FD, 100/HD, 10/HD" },
635  { 0x0e, AA "100/FD, 100/HD, 10/FD" },
636  { 0x0f, AA "100/FD, 100/HD, 10/FD, 10/HD" },
637  { 0x20, AA "1000/FD" },
638  { 0x21, AA "1000/FD, 10/HD" },
639  { 0x22, AA "1000/FD, 10/FD" },
640  { 0x23, AA "1000/FD, 10/FD, 10/HD" },
641  { 0x24, AA "1000/FD, 100/HD" },
642  { 0x25, AA "1000/FD, 100/HD, 10/HD" },
643  { 0x26, AA "1000/FD, 100/HD, 10/FD" },
644  { 0x27, AA "1000/FD, 100/HD, 10/FD, 10/HD" },
645  { 0x28, AA "1000/FD, 100/FD" },
646  { 0x29, AA "1000/FD, 100/FD, 10/HD" },
647  { 0x2a, AA "1000/FD, 100/FD, 10/FD" },
648  { 0x2b, AA "1000/FD, 100/FD, 10/FD, 10/HD" },
649  { 0x2c, AA "1000/FD, 100/FD, 100/HD" },
650  { 0x2d, AA "1000/FD, 100/FD, 100/HD, 10/HD" },
651  { 0x2e, AA "1000/FD, 100/FD, 100/HD, 10/FD" },
652  { 0x2f, AA "1000/FD, 100/FD, 100/HD, 10/FD, 10/HD" }};
653 
654  opt = (struct e1000_option) {
655  .type = list_option,
656  .name = "AutoNeg",
657  .err = "parameter ignored",
658  .def = AUTONEG_ADV_DEFAULT,
659  .arg = { .l = { .nr = ARRAY_SIZE(an_list),
660  .p = an_list }}
661  };
662 
663  if (num_AutoNeg > bd) {
664  an = AutoNeg[bd];
665  e1000_validate_option(&an, &opt, adapter);
666  } else {
667  an = opt.def;
668  }
669  adapter->hw.autoneg_advertised = an;
670  }
671 
672  switch (speed + dplx) {
673  case 0:
674  adapter->hw.autoneg = adapter->fc_autoneg = 1;
675  if ((num_Speed > bd) && (speed != 0 || dplx != 0))
676  e_dev_info("Speed and duplex autonegotiation "
677  "enabled\n");
678  break;
679  case HALF_DUPLEX:
680  e_dev_info("Half Duplex specified without Speed\n");
681  e_dev_info("Using Autonegotiation at Half Duplex only\n");
682  adapter->hw.autoneg = adapter->fc_autoneg = 1;
683  adapter->hw.autoneg_advertised = ADVERTISE_10_HALF |
684  ADVERTISE_100_HALF;
685  break;
686  case FULL_DUPLEX:
687  e_dev_info("Full Duplex specified without Speed\n");
688  e_dev_info("Using Autonegotiation at Full Duplex only\n");
689  adapter->hw.autoneg = adapter->fc_autoneg = 1;
690  adapter->hw.autoneg_advertised = ADVERTISE_10_FULL |
691  ADVERTISE_100_FULL |
692  ADVERTISE_1000_FULL;
693  break;
694  case SPEED_10:
695  e_dev_info("10 Mbps Speed specified without Duplex\n");
696  e_dev_info("Using Autonegotiation at 10 Mbps only\n");
697  adapter->hw.autoneg = adapter->fc_autoneg = 1;
698  adapter->hw.autoneg_advertised = ADVERTISE_10_HALF |
699  ADVERTISE_10_FULL;
700  break;
701  case SPEED_10 + HALF_DUPLEX:
702  e_dev_info("Forcing to 10 Mbps Half Duplex\n");
703  adapter->hw.autoneg = adapter->fc_autoneg = 0;
704  adapter->hw.forced_speed_duplex = e1000_10_half;
705  adapter->hw.autoneg_advertised = 0;
706  break;
707  case SPEED_10 + FULL_DUPLEX:
708  e_dev_info("Forcing to 10 Mbps Full Duplex\n");
709  adapter->hw.autoneg = adapter->fc_autoneg = 0;
710  adapter->hw.forced_speed_duplex = e1000_10_full;
711  adapter->hw.autoneg_advertised = 0;
712  break;
713  case SPEED_100:
714  e_dev_info("100 Mbps Speed specified without Duplex\n");
715  e_dev_info("Using Autonegotiation at 100 Mbps only\n");
716  adapter->hw.autoneg = adapter->fc_autoneg = 1;
717  adapter->hw.autoneg_advertised = ADVERTISE_100_HALF |
718  ADVERTISE_100_FULL;
719  break;
720  case SPEED_100 + HALF_DUPLEX:
721  e_dev_info("Forcing to 100 Mbps Half Duplex\n");
722  adapter->hw.autoneg = adapter->fc_autoneg = 0;
723  adapter->hw.forced_speed_duplex = e1000_100_half;
724  adapter->hw.autoneg_advertised = 0;
725  break;
726  case SPEED_100 + FULL_DUPLEX:
727  e_dev_info("Forcing to 100 Mbps Full Duplex\n");
728  adapter->hw.autoneg = adapter->fc_autoneg = 0;
729  adapter->hw.forced_speed_duplex = e1000_100_full;
730  adapter->hw.autoneg_advertised = 0;
731  break;
732  case SPEED_1000:
733  e_dev_info("1000 Mbps Speed specified without Duplex\n");
734  goto full_duplex_only;
735  case SPEED_1000 + HALF_DUPLEX:
736  e_dev_info("Half Duplex is not supported at 1000 Mbps\n");
737  /* fall through */
738  case SPEED_1000 + FULL_DUPLEX:
739 full_duplex_only:
740  e_dev_info("Using Autonegotiation at 1000 Mbps Full Duplex "
741  "only\n");
742  adapter->hw.autoneg = adapter->fc_autoneg = 1;
743  adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL;
744  break;
745  default:
746  BUG();
747  }
748 
749  /* Speed, AutoNeg and MDI/MDI-X must all play nice */
750  if (e1000_validate_mdi_setting(&(adapter->hw)) < 0) {
751  e_dev_info("Speed, AutoNeg and MDI-X specs are incompatible. "
752  "Setting MDI-X to a compatible value.\n");
753  }
754 }
755 
Generated on Thu Jan 10 2013 14:02:10 for Linux Kernel by   doxygen 1.8.2