1 // SPDX-License-Identifier: GPL-2.0 2 /******************************************************************************* 3 4 Intel PRO/1000 Linux driver 5 Copyright(c) 1999 - 2006 Intel Corporation. 6 7 This program is free software; you can redistribute it and/or modify it 8 under the terms and conditions of the GNU General Public License, 9 version 2, as published by the Free Software Foundation. 10 11 This program is distributed in the hope it will be useful, but WITHOUT 12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 14 more details. 15 16 You should have received a copy of the GNU General Public License along with 17 this program; if not, write to the Free Software Foundation, Inc., 18 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 19 20 The full GNU General Public License is included in this distribution in 21 the file called "COPYING". 22 23 Contact Information: 24 Linux NICS <linux.nics@intel.com> 25 e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> 26 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 27 28 *******************************************************************************/ 29 30 #include "e1000.h" 31 32 /* This is the only thing that needs to be changed to adjust the 33 * maximum number of ports that the driver can manage. 34 */ 35 36 #define E1000_MAX_NIC 32 37 38 #define OPTION_UNSET -1 39 #define OPTION_DISABLED 0 40 #define OPTION_ENABLED 1 41 42 /* All parameters are treated the same, as an integer array of values. 43 * This macro just reduces the need to repeat the same declaration code 44 * over and over (plus this helps to avoid typo bugs). 45 */ 46 47 #define E1000_PARAM_INIT { [0 ... E1000_MAX_NIC] = OPTION_UNSET } 48 #define E1000_PARAM(X, desc) \ 49 static int X[E1000_MAX_NIC+1] = E1000_PARAM_INIT; \ 50 static unsigned int num_##X; \ 51 module_param_array_named(X, X, int, &num_##X, 0); \ 52 MODULE_PARM_DESC(X, desc); 53 54 /* Transmit Descriptor Count 55 * 56 * Valid Range: 80-256 for 82542 and 82543 gigabit ethernet controllers 57 * Valid Range: 80-4096 for 82544 and newer 58 * 59 * Default Value: 256 60 */ 61 E1000_PARAM(TxDescriptors, "Number of transmit descriptors"); 62 63 /* Receive Descriptor Count 64 * 65 * Valid Range: 80-256 for 82542 and 82543 gigabit ethernet controllers 66 * Valid Range: 80-4096 for 82544 and newer 67 * 68 * Default Value: 256 69 */ 70 E1000_PARAM(RxDescriptors, "Number of receive descriptors"); 71 72 /* User Specified Speed Override 73 * 74 * Valid Range: 0, 10, 100, 1000 75 * - 0 - auto-negotiate at all supported speeds 76 * - 10 - only link at 10 Mbps 77 * - 100 - only link at 100 Mbps 78 * - 1000 - only link at 1000 Mbps 79 * 80 * Default Value: 0 81 */ 82 E1000_PARAM(Speed, "Speed setting"); 83 84 /* User Specified Duplex Override 85 * 86 * Valid Range: 0-2 87 * - 0 - auto-negotiate for duplex 88 * - 1 - only link at half duplex 89 * - 2 - only link at full duplex 90 * 91 * Default Value: 0 92 */ 93 E1000_PARAM(Duplex, "Duplex setting"); 94 95 /* Auto-negotiation Advertisement Override 96 * 97 * Valid Range: 0x01-0x0F, 0x20-0x2F (copper); 0x20 (fiber) 98 * 99 * The AutoNeg value is a bit mask describing which speed and duplex 100 * combinations should be advertised during auto-negotiation. 101 * The supported speed and duplex modes are listed below 102 * 103 * Bit 7 6 5 4 3 2 1 0 104 * Speed (Mbps) N/A N/A 1000 N/A 100 100 10 10 105 * Duplex Full Full Half Full Half 106 * 107 * Default Value: 0x2F (copper); 0x20 (fiber) 108 */ 109 E1000_PARAM(AutoNeg, "Advertised auto-negotiation setting"); 110 #define AUTONEG_ADV_DEFAULT 0x2F 111 #define AUTONEG_ADV_MASK 0x2F 112 113 /* User Specified Flow Control Override 114 * 115 * Valid Range: 0-3 116 * - 0 - No Flow Control 117 * - 1 - Rx only, respond to PAUSE frames but do not generate them 118 * - 2 - Tx only, generate PAUSE frames but ignore them on receive 119 * - 3 - Full Flow Control Support 120 * 121 * Default Value: Read flow control settings from the EEPROM 122 */ 123 E1000_PARAM(FlowControl, "Flow Control setting"); 124 #define FLOW_CONTROL_DEFAULT FLOW_CONTROL_FULL 125 126 /* XsumRX - Receive Checksum Offload Enable/Disable 127 * 128 * Valid Range: 0, 1 129 * - 0 - disables all checksum offload 130 * - 1 - enables receive IP/TCP/UDP checksum offload 131 * on 82543 and newer -based NICs 132 * 133 * Default Value: 1 134 */ 135 E1000_PARAM(XsumRX, "Disable or enable Receive Checksum offload"); 136 137 /* Transmit Interrupt Delay in units of 1.024 microseconds 138 * Tx interrupt delay needs to typically be set to something non zero 139 * 140 * Valid Range: 0-65535 141 */ 142 E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay"); 143 #define DEFAULT_TIDV 8 144 #define MAX_TXDELAY 0xFFFF 145 #define MIN_TXDELAY 0 146 147 /* Transmit Absolute Interrupt Delay in units of 1.024 microseconds 148 * 149 * Valid Range: 0-65535 150 */ 151 E1000_PARAM(TxAbsIntDelay, "Transmit Absolute Interrupt Delay"); 152 #define DEFAULT_TADV 32 153 #define MAX_TXABSDELAY 0xFFFF 154 #define MIN_TXABSDELAY 0 155 156 /* Receive Interrupt Delay in units of 1.024 microseconds 157 * hardware will likely hang if you set this to anything but zero. 158 * 159 * Valid Range: 0-65535 160 */ 161 E1000_PARAM(RxIntDelay, "Receive Interrupt Delay"); 162 #define DEFAULT_RDTR 0 163 #define MAX_RXDELAY 0xFFFF 164 #define MIN_RXDELAY 0 165 166 /* Receive Absolute Interrupt Delay in units of 1.024 microseconds 167 * 168 * Valid Range: 0-65535 169 */ 170 E1000_PARAM(RxAbsIntDelay, "Receive Absolute Interrupt Delay"); 171 #define DEFAULT_RADV 8 172 #define MAX_RXABSDELAY 0xFFFF 173 #define MIN_RXABSDELAY 0 174 175 /* Interrupt Throttle Rate (interrupts/sec) 176 * 177 * Valid Range: 100-100000 (0=off, 1=dynamic, 3=dynamic conservative) 178 */ 179 E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate"); 180 #define DEFAULT_ITR 3 181 #define MAX_ITR 100000 182 #define MIN_ITR 100 183 184 /* Enable Smart Power Down of the PHY 185 * 186 * Valid Range: 0, 1 187 * 188 * Default Value: 0 (disabled) 189 */ 190 E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down"); 191 192 struct e1000_option { 193 enum { enable_option, range_option, list_option } type; 194 const char *name; 195 const char *err; 196 int def; 197 union { 198 struct { /* range_option info */ 199 int min; 200 int max; 201 } r; 202 struct { /* list_option info */ 203 int nr; 204 const struct e1000_opt_list { int i; char *str; } *p; 205 } l; 206 } arg; 207 }; 208 209 static int e1000_validate_option(unsigned int *value, 210 const struct e1000_option *opt, 211 struct e1000_adapter *adapter) 212 { 213 if (*value == OPTION_UNSET) { 214 *value = opt->def; 215 return 0; 216 } 217 218 switch (opt->type) { 219 case enable_option: 220 switch (*value) { 221 case OPTION_ENABLED: 222 e_dev_info("%s Enabled\n", opt->name); 223 return 0; 224 case OPTION_DISABLED: 225 e_dev_info("%s Disabled\n", opt->name); 226 return 0; 227 } 228 break; 229 case range_option: 230 if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) { 231 e_dev_info("%s set to %i\n", opt->name, *value); 232 return 0; 233 } 234 break; 235 case list_option: { 236 int i; 237 const struct e1000_opt_list *ent; 238 239 for (i = 0; i < opt->arg.l.nr; i++) { 240 ent = &opt->arg.l.p[i]; 241 if (*value == ent->i) { 242 if (ent->str[0] != '\0') 243 e_dev_info("%s\n", ent->str); 244 return 0; 245 } 246 } 247 } 248 break; 249 default: 250 BUG(); 251 } 252 253 e_dev_info("Invalid %s value specified (%i) %s\n", 254 opt->name, *value, opt->err); 255 *value = opt->def; 256 return -1; 257 } 258 259 static void e1000_check_fiber_options(struct e1000_adapter *adapter); 260 static void e1000_check_copper_options(struct e1000_adapter *adapter); 261 262 /** 263 * e1000_check_options - Range Checking for Command Line Parameters 264 * @adapter: board private structure 265 * 266 * This routine checks all command line parameters for valid user 267 * input. If an invalid value is given, or if no user specified 268 * value exists, a default value is used. The final value is stored 269 * in a variable in the adapter structure. 270 **/ 271 void 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 : 323 E1000_MAX_82544_RXD 324 }} 325 }; 326 327 if (num_RxDescriptors > bd) { 328 rx_ring->count = RxDescriptors[bd]; 329 e1000_validate_option(&rx_ring->count, &opt, adapter); 330 rx_ring->count = ALIGN(rx_ring->count, 331 REQ_RX_DESCRIPTOR_MULTIPLE); 332 } else { 333 rx_ring->count = opt.def; 334 } 335 for (i = 0; i < adapter->num_rx_queues; i++) 336 rx_ring[i].count = rx_ring->count; 337 } 338 { /* Checksum Offload Enable/Disable */ 339 opt = (struct e1000_option) { 340 .type = enable_option, 341 .name = "Checksum Offload", 342 .err = "defaulting to Enabled", 343 .def = OPTION_ENABLED 344 }; 345 346 if (num_XsumRX > bd) { 347 unsigned int rx_csum = XsumRX[bd]; 348 e1000_validate_option(&rx_csum, &opt, adapter); 349 adapter->rx_csum = rx_csum; 350 } else { 351 adapter->rx_csum = opt.def; 352 } 353 } 354 { /* Flow Control */ 355 356 static const struct e1000_opt_list fc_list[] = { 357 { E1000_FC_NONE, "Flow Control Disabled" }, 358 { E1000_FC_RX_PAUSE, "Flow Control Receive Only" }, 359 { E1000_FC_TX_PAUSE, "Flow Control Transmit Only" }, 360 { E1000_FC_FULL, "Flow Control Enabled" }, 361 { E1000_FC_DEFAULT, "Flow Control Hardware Default" } 362 }; 363 364 opt = (struct e1000_option) { 365 .type = list_option, 366 .name = "Flow Control", 367 .err = "reading default settings from EEPROM", 368 .def = E1000_FC_DEFAULT, 369 .arg = { .l = { .nr = ARRAY_SIZE(fc_list), 370 .p = fc_list }} 371 }; 372 373 if (num_FlowControl > bd) { 374 unsigned int fc = FlowControl[bd]; 375 e1000_validate_option(&fc, &opt, adapter); 376 adapter->hw.fc = adapter->hw.original_fc = fc; 377 } else { 378 adapter->hw.fc = adapter->hw.original_fc = opt.def; 379 } 380 } 381 { /* Transmit Interrupt Delay */ 382 opt = (struct e1000_option) { 383 .type = range_option, 384 .name = "Transmit Interrupt Delay", 385 .err = "using default of " __MODULE_STRING(DEFAULT_TIDV), 386 .def = DEFAULT_TIDV, 387 .arg = { .r = { .min = MIN_TXDELAY, 388 .max = MAX_TXDELAY }} 389 }; 390 391 if (num_TxIntDelay > bd) { 392 adapter->tx_int_delay = TxIntDelay[bd]; 393 e1000_validate_option(&adapter->tx_int_delay, &opt, 394 adapter); 395 } else { 396 adapter->tx_int_delay = opt.def; 397 } 398 } 399 { /* Transmit Absolute Interrupt Delay */ 400 opt = (struct e1000_option) { 401 .type = range_option, 402 .name = "Transmit Absolute Interrupt Delay", 403 .err = "using default of " __MODULE_STRING(DEFAULT_TADV), 404 .def = DEFAULT_TADV, 405 .arg = { .r = { .min = MIN_TXABSDELAY, 406 .max = MAX_TXABSDELAY }} 407 }; 408 409 if (num_TxAbsIntDelay > bd) { 410 adapter->tx_abs_int_delay = TxAbsIntDelay[bd]; 411 e1000_validate_option(&adapter->tx_abs_int_delay, &opt, 412 adapter); 413 } else { 414 adapter->tx_abs_int_delay = opt.def; 415 } 416 } 417 { /* Receive Interrupt Delay */ 418 opt = (struct e1000_option) { 419 .type = range_option, 420 .name = "Receive Interrupt Delay", 421 .err = "using default of " __MODULE_STRING(DEFAULT_RDTR), 422 .def = DEFAULT_RDTR, 423 .arg = { .r = { .min = MIN_RXDELAY, 424 .max = MAX_RXDELAY }} 425 }; 426 427 if (num_RxIntDelay > bd) { 428 adapter->rx_int_delay = RxIntDelay[bd]; 429 e1000_validate_option(&adapter->rx_int_delay, &opt, 430 adapter); 431 } else { 432 adapter->rx_int_delay = opt.def; 433 } 434 } 435 { /* Receive Absolute Interrupt Delay */ 436 opt = (struct e1000_option) { 437 .type = range_option, 438 .name = "Receive Absolute Interrupt Delay", 439 .err = "using default of " __MODULE_STRING(DEFAULT_RADV), 440 .def = DEFAULT_RADV, 441 .arg = { .r = { .min = MIN_RXABSDELAY, 442 .max = MAX_RXABSDELAY }} 443 }; 444 445 if (num_RxAbsIntDelay > bd) { 446 adapter->rx_abs_int_delay = RxAbsIntDelay[bd]; 447 e1000_validate_option(&adapter->rx_abs_int_delay, &opt, 448 adapter); 449 } else { 450 adapter->rx_abs_int_delay = opt.def; 451 } 452 } 453 { /* Interrupt Throttling Rate */ 454 opt = (struct e1000_option) { 455 .type = range_option, 456 .name = "Interrupt Throttling Rate (ints/sec)", 457 .err = "using default of " __MODULE_STRING(DEFAULT_ITR), 458 .def = DEFAULT_ITR, 459 .arg = { .r = { .min = MIN_ITR, 460 .max = MAX_ITR }} 461 }; 462 463 if (num_InterruptThrottleRate > bd) { 464 adapter->itr = InterruptThrottleRate[bd]; 465 switch (adapter->itr) { 466 case 0: 467 e_dev_info("%s turned off\n", opt.name); 468 break; 469 case 1: 470 e_dev_info("%s set to dynamic mode\n", 471 opt.name); 472 adapter->itr_setting = adapter->itr; 473 adapter->itr = 20000; 474 break; 475 case 3: 476 e_dev_info("%s set to dynamic conservative " 477 "mode\n", opt.name); 478 adapter->itr_setting = adapter->itr; 479 adapter->itr = 20000; 480 break; 481 case 4: 482 e_dev_info("%s set to simplified " 483 "(2000-8000) ints mode\n", opt.name); 484 adapter->itr_setting = adapter->itr; 485 break; 486 default: 487 e1000_validate_option(&adapter->itr, &opt, 488 adapter); 489 /* save the setting, because the dynamic bits 490 * change itr. 491 * clear the lower two bits because they are 492 * used as control 493 */ 494 adapter->itr_setting = adapter->itr & ~3; 495 break; 496 } 497 } else { 498 adapter->itr_setting = opt.def; 499 adapter->itr = 20000; 500 } 501 } 502 { /* Smart Power Down */ 503 opt = (struct e1000_option) { 504 .type = enable_option, 505 .name = "PHY Smart Power Down", 506 .err = "defaulting to Disabled", 507 .def = OPTION_DISABLED 508 }; 509 510 if (num_SmartPowerDownEnable > bd) { 511 unsigned int spd = SmartPowerDownEnable[bd]; 512 e1000_validate_option(&spd, &opt, adapter); 513 adapter->smart_power_down = spd; 514 } else { 515 adapter->smart_power_down = opt.def; 516 } 517 } 518 519 switch (adapter->hw.media_type) { 520 case e1000_media_type_fiber: 521 case e1000_media_type_internal_serdes: 522 e1000_check_fiber_options(adapter); 523 break; 524 case e1000_media_type_copper: 525 e1000_check_copper_options(adapter); 526 break; 527 default: 528 BUG(); 529 } 530 } 531 532 /** 533 * e1000_check_fiber_options - Range Checking for Link Options, Fiber Version 534 * @adapter: board private structure 535 * 536 * Handles speed and duplex options on fiber adapters 537 **/ 538 static void e1000_check_fiber_options(struct e1000_adapter *adapter) 539 { 540 int bd = adapter->bd_number; 541 if (num_Speed > bd) { 542 e_dev_info("Speed not valid for fiber adapters, parameter " 543 "ignored\n"); 544 } 545 546 if (num_Duplex > bd) { 547 e_dev_info("Duplex not valid for fiber adapters, parameter " 548 "ignored\n"); 549 } 550 551 if ((num_AutoNeg > bd) && (AutoNeg[bd] != 0x20)) { 552 e_dev_info("AutoNeg other than 1000/Full is not valid for fiber" 553 "adapters, parameter ignored\n"); 554 } 555 } 556 557 /** 558 * e1000_check_copper_options - Range Checking for Link Options, Copper Version 559 * @adapter: board private structure 560 * 561 * Handles speed and duplex options on copper adapters 562 **/ 563 static void 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