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 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 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 void e1000_check_options(struct e1000_adapter *adapter) 271 { 272 struct e1000_option opt; 273 int bd = adapter->bd_number; 274 275 if (bd >= E1000_MAX_NIC) { 276 e_dev_warn("Warning: no configuration for board #%i " 277 "using defaults for all values\n", bd); 278 } 279 280 { /* Transmit Descriptor Count */ 281 struct e1000_tx_ring *tx_ring = adapter->tx_ring; 282 int i; 283 e1000_mac_type mac_type = adapter->hw.mac_type; 284 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, 291 .arg = { .r = { 292 .min = E1000_MIN_TXD, 293 .max = mac_type < e1000_82544 ? E1000_MAX_TXD : E1000_MAX_82544_TXD 294 }} 295 }; 296 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); 302 } else { 303 tx_ring->count = opt.def; 304 } 305 for (i = 0; i < adapter->num_tx_queues; i++) 306 tx_ring[i].count = tx_ring->count; 307 } 308 { /* Receive Descriptor Count */ 309 struct e1000_rx_ring *rx_ring = adapter->rx_ring; 310 int i; 311 e1000_mac_type mac_type = adapter->hw.mac_type; 312 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, 319 .arg = { .r = { 320 .min = E1000_MIN_RXD, 321 .max = mac_type < e1000_82544 ? E1000_MAX_RXD : 322 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 */ 493 adapter->itr_setting = adapter->itr & ~3; 494 break; 495 } 496 } else { 497 adapter->itr_setting = opt.def; 498 adapter->itr = 20000; 499 } 500 } 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 507 }; 508 509 if (num_SmartPowerDownEnable > bd) { 510 unsigned int spd = SmartPowerDownEnable[bd]; 511 e1000_validate_option(&spd, &opt, adapter); 512 adapter->smart_power_down = spd; 513 } else { 514 adapter->smart_power_down = opt.def; 515 } 516 } 517 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); 522 break; 523 case e1000_media_type_copper: 524 e1000_check_copper_options(adapter); 525 break; 526 default: 527 BUG(); 528 } 529 } 530 531 /** 532 * e1000_check_fiber_options - Range Checking for Link Options, Fiber Version 533 * @adapter: board private structure 534 * 535 * Handles speed and duplex options on fiber adapters 536 **/ 537 static void 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 static void 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: 738 full_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 755