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 */ 60E1000_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 */ 69E1000_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 */ 81E1000_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 */ 92E1000_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 */ 108E1000_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 */ 122E1000_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 */ 134E1000_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 */ 141E1000_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 */ 150E1000_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 */ 160E1000_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 */ 169E1000_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 */ 178E1000_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 */ 189E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down"); 190 191struct 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 208static 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 258static void e1000_check_fiber_options(struct e1000_adapter *adapter); 259static 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 271void __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 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 opt = (struct e1000_option) { 363 .type = list_option, 364 .name = "Flow Control", 365 .err = "reading default settings from EEPROM", 366 .def = E1000_FC_DEFAULT, 367 .arg = { .l = { .nr = ARRAY_SIZE(fc_list), 368 .p = fc_list }} 369 }; 370 371 if (num_FlowControl > bd) { 372 unsigned int fc = FlowControl[bd]; 373 e1000_validate_option(&fc, &opt, adapter); 374 adapter->hw.fc = adapter->hw.original_fc = fc; 375 } else { 376 adapter->hw.fc = adapter->hw.original_fc = opt.def; 377 } 378 } 379 { /* Transmit Interrupt Delay */ 380 opt = (struct e1000_option) { 381 .type = range_option, 382 .name = "Transmit Interrupt Delay", 383 .err = "using default of " __MODULE_STRING(DEFAULT_TIDV), 384 .def = DEFAULT_TIDV, 385 .arg = { .r = { .min = MIN_TXDELAY, 386 .max = MAX_TXDELAY }} 387 }; 388 389 if (num_TxIntDelay > bd) { 390 adapter->tx_int_delay = TxIntDelay[bd]; 391 e1000_validate_option(&adapter->tx_int_delay, &opt, 392 adapter); 393 } else { 394 adapter->tx_int_delay = opt.def; 395 } 396 } 397 { /* Transmit Absolute Interrupt Delay */ 398 opt = (struct e1000_option) { 399 .type = range_option, 400 .name = "Transmit Absolute Interrupt Delay", 401 .err = "using default of " __MODULE_STRING(DEFAULT_TADV), 402 .def = DEFAULT_TADV, 403 .arg = { .r = { .min = MIN_TXABSDELAY, 404 .max = MAX_TXABSDELAY }} 405 }; 406 407 if (num_TxAbsIntDelay > bd) { 408 adapter->tx_abs_int_delay = TxAbsIntDelay[bd]; 409 e1000_validate_option(&adapter->tx_abs_int_delay, &opt, 410 adapter); 411 } else { 412 adapter->tx_abs_int_delay = opt.def; 413 } 414 } 415 { /* Receive Interrupt Delay */ 416 opt = (struct e1000_option) { 417 .type = range_option, 418 .name = "Receive Interrupt Delay", 419 .err = "using default of " __MODULE_STRING(DEFAULT_RDTR), 420 .def = DEFAULT_RDTR, 421 .arg = { .r = { .min = MIN_RXDELAY, 422 .max = MAX_RXDELAY }} 423 }; 424 425 if (num_RxIntDelay > bd) { 426 adapter->rx_int_delay = RxIntDelay[bd]; 427 e1000_validate_option(&adapter->rx_int_delay, &opt, 428 adapter); 429 } else { 430 adapter->rx_int_delay = opt.def; 431 } 432 } 433 { /* Receive Absolute Interrupt Delay */ 434 opt = (struct e1000_option) { 435 .type = range_option, 436 .name = "Receive Absolute Interrupt Delay", 437 .err = "using default of " __MODULE_STRING(DEFAULT_RADV), 438 .def = DEFAULT_RADV, 439 .arg = { .r = { .min = MIN_RXABSDELAY, 440 .max = MAX_RXABSDELAY }} 441 }; 442 443 if (num_RxAbsIntDelay > bd) { 444 adapter->rx_abs_int_delay = RxAbsIntDelay[bd]; 445 e1000_validate_option(&adapter->rx_abs_int_delay, &opt, 446 adapter); 447 } else { 448 adapter->rx_abs_int_delay = opt.def; 449 } 450 } 451 { /* Interrupt Throttling Rate */ 452 opt = (struct e1000_option) { 453 .type = range_option, 454 .name = "Interrupt Throttling Rate (ints/sec)", 455 .err = "using default of " __MODULE_STRING(DEFAULT_ITR), 456 .def = DEFAULT_ITR, 457 .arg = { .r = { .min = MIN_ITR, 458 .max = MAX_ITR }} 459 }; 460 461 if (num_InterruptThrottleRate > bd) { 462 adapter->itr = InterruptThrottleRate[bd]; 463 switch (adapter->itr) { 464 case 0: 465 e_dev_info("%s turned off\n", opt.name); 466 break; 467 case 1: 468 e_dev_info("%s set to dynamic mode\n", 469 opt.name); 470 adapter->itr_setting = adapter->itr; 471 adapter->itr = 20000; 472 break; 473 case 3: 474 e_dev_info("%s set to dynamic conservative " 475 "mode\n", opt.name); 476 adapter->itr_setting = adapter->itr; 477 adapter->itr = 20000; 478 break; 479 case 4: 480 e_dev_info("%s set to simplified " 481 "(2000-8000) ints mode\n", opt.name); 482 adapter->itr_setting = adapter->itr; 483 break; 484 default: 485 e1000_validate_option(&adapter->itr, &opt, 486 adapter); 487 /* save the setting, because the dynamic bits 488 * change itr. 489 * clear the lower two bits because they are 490 * used as control */ 491 adapter->itr_setting = adapter->itr & ~3; 492 break; 493 } 494 } else { 495 adapter->itr_setting = opt.def; 496 adapter->itr = 20000; 497 } 498 } 499 { /* Smart Power Down */ 500 opt = (struct e1000_option) { 501 .type = enable_option, 502 .name = "PHY Smart Power Down", 503 .err = "defaulting to Disabled", 504 .def = OPTION_DISABLED 505 }; 506 507 if (num_SmartPowerDownEnable > bd) { 508 unsigned int spd = SmartPowerDownEnable[bd]; 509 e1000_validate_option(&spd, &opt, adapter); 510 adapter->smart_power_down = spd; 511 } else { 512 adapter->smart_power_down = opt.def; 513 } 514 } 515 516 switch (adapter->hw.media_type) { 517 case e1000_media_type_fiber: 518 case e1000_media_type_internal_serdes: 519 e1000_check_fiber_options(adapter); 520 break; 521 case e1000_media_type_copper: 522 e1000_check_copper_options(adapter); 523 break; 524 default: 525 BUG(); 526 } 527} 528 529/** 530 * e1000_check_fiber_options - Range Checking for Link Options, Fiber Version 531 * @adapter: board private structure 532 * 533 * Handles speed and duplex options on fiber adapters 534 **/ 535 536static void __devinit e1000_check_fiber_options(struct e1000_adapter *adapter) 537{ 538 int bd = adapter->bd_number; 539 if (num_Speed > bd) { 540 e_dev_info("Speed not valid for fiber adapters, parameter " 541 "ignored\n"); 542 } 543 544 if (num_Duplex > bd) { 545 e_dev_info("Duplex not valid for fiber adapters, parameter " 546 "ignored\n"); 547 } 548 549 if ((num_AutoNeg > bd) && (AutoNeg[bd] != 0x20)) { 550 e_dev_info("AutoNeg other than 1000/Full is not valid for fiber" 551 "adapters, parameter ignored\n"); 552 } 553} 554 555/** 556 * e1000_check_copper_options - Range Checking for Link Options, Copper Version 557 * @adapter: board private structure 558 * 559 * Handles speed and duplex options on copper adapters 560 **/ 561 562static void __devinit e1000_check_copper_options(struct e1000_adapter *adapter) 563{ 564 struct e1000_option opt; 565 unsigned int speed, dplx, an; 566 int bd = adapter->bd_number; 567 568 { /* Speed */ 569 static const struct e1000_opt_list speed_list[] = { 570 { 0, "" }, 571 { SPEED_10, "" }, 572 { SPEED_100, "" }, 573 { SPEED_1000, "" }}; 574 575 opt = (struct e1000_option) { 576 .type = list_option, 577 .name = "Speed", 578 .err = "parameter ignored", 579 .def = 0, 580 .arg = { .l = { .nr = ARRAY_SIZE(speed_list), 581 .p = speed_list }} 582 }; 583 584 if (num_Speed > bd) { 585 speed = Speed[bd]; 586 e1000_validate_option(&speed, &opt, adapter); 587 } else { 588 speed = opt.def; 589 } 590 } 591 { /* Duplex */ 592 static const struct e1000_opt_list dplx_list[] = { 593 { 0, "" }, 594 { HALF_DUPLEX, "" }, 595 { FULL_DUPLEX, "" }}; 596 597 opt = (struct e1000_option) { 598 .type = list_option, 599 .name = "Duplex", 600 .err = "parameter ignored", 601 .def = 0, 602 .arg = { .l = { .nr = ARRAY_SIZE(dplx_list), 603 .p = dplx_list }} 604 }; 605 606 if (num_Duplex > bd) { 607 dplx = Duplex[bd]; 608 e1000_validate_option(&dplx, &opt, adapter); 609 } else { 610 dplx = opt.def; 611 } 612 } 613 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" }}; 652 653 opt = (struct e1000_option) { 654 .type = list_option, 655 .name = "AutoNeg", 656 .err = "parameter ignored", 657 .def = AUTONEG_ADV_DEFAULT, 658 .arg = { .l = { .nr = ARRAY_SIZE(an_list), 659 .p = an_list }} 660 }; 661 662 if (num_AutoNeg > bd) { 663 an = AutoNeg[bd]; 664 e1000_validate_option(&an, &opt, adapter); 665 } else { 666 an = opt.def; 667 } 668 adapter->hw.autoneg_advertised = an; 669 } 670 671 switch (speed + dplx) { 672 case 0: 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 " 676 "enabled\n"); 677 break; 678 case HALF_DUPLEX: 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 | 683 ADVERTISE_100_HALF; 684 break; 685 case FULL_DUPLEX: 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 | 690 ADVERTISE_100_FULL | 691 ADVERTISE_1000_FULL; 692 break; 693 case SPEED_10: 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 | 698 ADVERTISE_10_FULL; 699 break; 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; 705 break; 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; 711 break; 712 case SPEED_100: 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 | 717 ADVERTISE_100_FULL; 718 break; 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; 724 break; 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; 730 break; 731 case SPEED_1000: 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"); 736 /* fall through */ 737 case SPEED_1000 + FULL_DUPLEX: 738full_duplex_only: 739 e_dev_info("Using Autonegotiation at 1000 Mbps Full Duplex " 740 "only\n"); 741 adapter->hw.autoneg = adapter->fc_autoneg = 1; 742 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL; 743 break; 744 default: 745 BUG(); 746 } 747 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"); 752 } 753} 754