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 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 261 /** 262 * e1000_check_options - Range Checking for Command Line Parameters 263 * @adapter: board private structure 264 * 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. 269 **/ 270 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 530 /** 531 * e1000_check_fiber_options - Range Checking for Link Options, Fiber Version 532 * @adapter: board private structure 533 * 534 * Handles speed and duplex options on fiber adapters 535 **/ 536 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 556 /** 557 * e1000_check_copper_options - Range Checking for Link Options, Copper Version 558 * @adapter: board private structure 559 * 560 * Handles speed and duplex options on copper adapters 561 **/ 562 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 756