1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 1999 - 2006 Intel Corporation. */ 3 4 #include "e1000.h" 5 6 /* This is the only thing that needs to be changed to adjust the 7 * maximum number of ports that the driver can manage. 8 */ 9 10 #define E1000_MAX_NIC 32 11 12 #define OPTION_UNSET -1 13 #define OPTION_DISABLED 0 14 #define OPTION_ENABLED 1 15 16 /* All parameters are treated the same, as an integer array of values. 17 * This macro just reduces the need to repeat the same declaration code 18 * over and over (plus this helps to avoid typo bugs). 19 */ 20 21 #define E1000_PARAM_INIT { [0 ... E1000_MAX_NIC] = OPTION_UNSET } 22 #define E1000_PARAM(X, desc) \ 23 static int X[E1000_MAX_NIC+1] = E1000_PARAM_INIT; \ 24 static unsigned int num_##X; \ 25 module_param_array_named(X, X, int, &num_##X, 0); \ 26 MODULE_PARM_DESC(X, desc); 27 28 /* Transmit Descriptor Count 29 * 30 * Valid Range: 80-256 for 82542 and 82543 gigabit ethernet controllers 31 * Valid Range: 80-4096 for 82544 and newer 32 * 33 * Default Value: 256 34 */ 35 E1000_PARAM(TxDescriptors, "Number of transmit descriptors"); 36 37 /* Receive Descriptor Count 38 * 39 * Valid Range: 80-256 for 82542 and 82543 gigabit ethernet controllers 40 * Valid Range: 80-4096 for 82544 and newer 41 * 42 * Default Value: 256 43 */ 44 E1000_PARAM(RxDescriptors, "Number of receive descriptors"); 45 46 /* User Specified Speed Override 47 * 48 * Valid Range: 0, 10, 100, 1000 49 * - 0 - auto-negotiate at all supported speeds 50 * - 10 - only link at 10 Mbps 51 * - 100 - only link at 100 Mbps 52 * - 1000 - only link at 1000 Mbps 53 * 54 * Default Value: 0 55 */ 56 E1000_PARAM(Speed, "Speed setting"); 57 58 /* User Specified Duplex Override 59 * 60 * Valid Range: 0-2 61 * - 0 - auto-negotiate for duplex 62 * - 1 - only link at half duplex 63 * - 2 - only link at full duplex 64 * 65 * Default Value: 0 66 */ 67 E1000_PARAM(Duplex, "Duplex setting"); 68 69 /* Auto-negotiation Advertisement Override 70 * 71 * Valid Range: 0x01-0x0F, 0x20-0x2F (copper); 0x20 (fiber) 72 * 73 * The AutoNeg value is a bit mask describing which speed and duplex 74 * combinations should be advertised during auto-negotiation. 75 * The supported speed and duplex modes are listed below 76 * 77 * Bit 7 6 5 4 3 2 1 0 78 * Speed (Mbps) N/A N/A 1000 N/A 100 100 10 10 79 * Duplex Full Full Half Full Half 80 * 81 * Default Value: 0x2F (copper); 0x20 (fiber) 82 */ 83 E1000_PARAM(AutoNeg, "Advertised auto-negotiation setting"); 84 #define AUTONEG_ADV_DEFAULT 0x2F 85 #define AUTONEG_ADV_MASK 0x2F 86 87 /* User Specified Flow Control Override 88 * 89 * Valid Range: 0-3 90 * - 0 - No Flow Control 91 * - 1 - Rx only, respond to PAUSE frames but do not generate them 92 * - 2 - Tx only, generate PAUSE frames but ignore them on receive 93 * - 3 - Full Flow Control Support 94 * 95 * Default Value: Read flow control settings from the EEPROM 96 */ 97 E1000_PARAM(FlowControl, "Flow Control setting"); 98 #define FLOW_CONTROL_DEFAULT FLOW_CONTROL_FULL 99 100 /* XsumRX - Receive Checksum Offload Enable/Disable 101 * 102 * Valid Range: 0, 1 103 * - 0 - disables all checksum offload 104 * - 1 - enables receive IP/TCP/UDP checksum offload 105 * on 82543 and newer -based NICs 106 * 107 * Default Value: 1 108 */ 109 E1000_PARAM(XsumRX, "Disable or enable Receive Checksum offload"); 110 111 /* Transmit Interrupt Delay in units of 1.024 microseconds 112 * Tx interrupt delay needs to typically be set to something non zero 113 * 114 * Valid Range: 0-65535 115 */ 116 E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay"); 117 #define DEFAULT_TIDV 8 118 #define MAX_TXDELAY 0xFFFF 119 #define MIN_TXDELAY 0 120 121 /* Transmit Absolute Interrupt Delay in units of 1.024 microseconds 122 * 123 * Valid Range: 0-65535 124 */ 125 E1000_PARAM(TxAbsIntDelay, "Transmit Absolute Interrupt Delay"); 126 #define DEFAULT_TADV 32 127 #define MAX_TXABSDELAY 0xFFFF 128 #define MIN_TXABSDELAY 0 129 130 /* Receive Interrupt Delay in units of 1.024 microseconds 131 * hardware will likely hang if you set this to anything but zero. 132 * 133 * Valid Range: 0-65535 134 */ 135 E1000_PARAM(RxIntDelay, "Receive Interrupt Delay"); 136 #define DEFAULT_RDTR 0 137 #define MAX_RXDELAY 0xFFFF 138 #define MIN_RXDELAY 0 139 140 /* Receive Absolute Interrupt Delay in units of 1.024 microseconds 141 * 142 * Valid Range: 0-65535 143 */ 144 E1000_PARAM(RxAbsIntDelay, "Receive Absolute Interrupt Delay"); 145 #define DEFAULT_RADV 8 146 #define MAX_RXABSDELAY 0xFFFF 147 #define MIN_RXABSDELAY 0 148 149 /* Interrupt Throttle Rate (interrupts/sec) 150 * 151 * Valid Range: 100-100000 (0=off, 1=dynamic, 3=dynamic conservative) 152 */ 153 E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate"); 154 #define DEFAULT_ITR 3 155 #define MAX_ITR 100000 156 #define MIN_ITR 100 157 158 /* Enable Smart Power Down of the PHY 159 * 160 * Valid Range: 0, 1 161 * 162 * Default Value: 0 (disabled) 163 */ 164 E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down"); 165 166 struct e1000_option { 167 enum { enable_option, range_option, list_option } type; 168 const char *name; 169 const char *err; 170 int def; 171 union { 172 struct { /* range_option info */ 173 int min; 174 int max; 175 } r; 176 struct { /* list_option info */ 177 int nr; 178 const struct e1000_opt_list { int i; char *str; } *p; 179 } l; 180 } arg; 181 }; 182 183 static int e1000_validate_option(unsigned int *value, 184 const struct e1000_option *opt, 185 struct e1000_adapter *adapter) 186 { 187 if (*value == OPTION_UNSET) { 188 *value = opt->def; 189 return 0; 190 } 191 192 switch (opt->type) { 193 case enable_option: 194 switch (*value) { 195 case OPTION_ENABLED: 196 e_dev_info("%s Enabled\n", opt->name); 197 return 0; 198 case OPTION_DISABLED: 199 e_dev_info("%s Disabled\n", opt->name); 200 return 0; 201 } 202 break; 203 case range_option: 204 if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) { 205 e_dev_info("%s set to %i\n", opt->name, *value); 206 return 0; 207 } 208 break; 209 case list_option: { 210 int i; 211 const struct e1000_opt_list *ent; 212 213 for (i = 0; i < opt->arg.l.nr; i++) { 214 ent = &opt->arg.l.p[i]; 215 if (*value == ent->i) { 216 if (ent->str[0] != '\0') 217 e_dev_info("%s\n", ent->str); 218 return 0; 219 } 220 } 221 } 222 break; 223 default: 224 BUG(); 225 } 226 227 e_dev_info("Invalid %s value specified (%i) %s\n", 228 opt->name, *value, opt->err); 229 *value = opt->def; 230 return -1; 231 } 232 233 static void e1000_check_fiber_options(struct e1000_adapter *adapter); 234 static void e1000_check_copper_options(struct e1000_adapter *adapter); 235 236 /** 237 * e1000_check_options - Range Checking for Command Line Parameters 238 * @adapter: board private structure 239 * 240 * This routine checks all command line parameters for valid user 241 * input. If an invalid value is given, or if no user specified 242 * value exists, a default value is used. The final value is stored 243 * in a variable in the adapter structure. 244 **/ 245 void e1000_check_options(struct e1000_adapter *adapter) 246 { 247 struct e1000_option opt; 248 int bd = adapter->bd_number; 249 250 if (bd >= E1000_MAX_NIC) { 251 e_dev_warn("Warning: no configuration for board #%i " 252 "using defaults for all values\n", bd); 253 } 254 255 { /* Transmit Descriptor Count */ 256 struct e1000_tx_ring *tx_ring = adapter->tx_ring; 257 int i; 258 e1000_mac_type mac_type = adapter->hw.mac_type; 259 260 opt = (struct e1000_option) { 261 .type = range_option, 262 .name = "Transmit Descriptors", 263 .err = "using default of " 264 __MODULE_STRING(E1000_DEFAULT_TXD), 265 .def = E1000_DEFAULT_TXD, 266 .arg = { .r = { 267 .min = E1000_MIN_TXD, 268 .max = mac_type < e1000_82544 ? E1000_MAX_TXD : E1000_MAX_82544_TXD 269 }} 270 }; 271 272 if (num_TxDescriptors > bd) { 273 tx_ring->count = TxDescriptors[bd]; 274 e1000_validate_option(&tx_ring->count, &opt, adapter); 275 tx_ring->count = ALIGN(tx_ring->count, 276 REQ_TX_DESCRIPTOR_MULTIPLE); 277 } else { 278 tx_ring->count = opt.def; 279 } 280 for (i = 0; i < adapter->num_tx_queues; i++) 281 tx_ring[i].count = tx_ring->count; 282 } 283 { /* Receive Descriptor Count */ 284 struct e1000_rx_ring *rx_ring = adapter->rx_ring; 285 int i; 286 e1000_mac_type mac_type = adapter->hw.mac_type; 287 288 opt = (struct e1000_option) { 289 .type = range_option, 290 .name = "Receive Descriptors", 291 .err = "using default of " 292 __MODULE_STRING(E1000_DEFAULT_RXD), 293 .def = E1000_DEFAULT_RXD, 294 .arg = { .r = { 295 .min = E1000_MIN_RXD, 296 .max = mac_type < e1000_82544 ? E1000_MAX_RXD : 297 E1000_MAX_82544_RXD 298 }} 299 }; 300 301 if (num_RxDescriptors > bd) { 302 rx_ring->count = RxDescriptors[bd]; 303 e1000_validate_option(&rx_ring->count, &opt, adapter); 304 rx_ring->count = ALIGN(rx_ring->count, 305 REQ_RX_DESCRIPTOR_MULTIPLE); 306 } else { 307 rx_ring->count = opt.def; 308 } 309 for (i = 0; i < adapter->num_rx_queues; i++) 310 rx_ring[i].count = rx_ring->count; 311 } 312 { /* Checksum Offload Enable/Disable */ 313 opt = (struct e1000_option) { 314 .type = enable_option, 315 .name = "Checksum Offload", 316 .err = "defaulting to Enabled", 317 .def = OPTION_ENABLED 318 }; 319 320 if (num_XsumRX > bd) { 321 unsigned int rx_csum = XsumRX[bd]; 322 e1000_validate_option(&rx_csum, &opt, adapter); 323 adapter->rx_csum = rx_csum; 324 } else { 325 adapter->rx_csum = opt.def; 326 } 327 } 328 { /* Flow Control */ 329 330 static const struct e1000_opt_list fc_list[] = { 331 { E1000_FC_NONE, "Flow Control Disabled" }, 332 { E1000_FC_RX_PAUSE, "Flow Control Receive Only" }, 333 { E1000_FC_TX_PAUSE, "Flow Control Transmit Only" }, 334 { E1000_FC_FULL, "Flow Control Enabled" }, 335 { E1000_FC_DEFAULT, "Flow Control Hardware Default" } 336 }; 337 338 opt = (struct e1000_option) { 339 .type = list_option, 340 .name = "Flow Control", 341 .err = "reading default settings from EEPROM", 342 .def = E1000_FC_DEFAULT, 343 .arg = { .l = { .nr = ARRAY_SIZE(fc_list), 344 .p = fc_list }} 345 }; 346 347 if (num_FlowControl > bd) { 348 unsigned int fc = FlowControl[bd]; 349 e1000_validate_option(&fc, &opt, adapter); 350 adapter->hw.fc = adapter->hw.original_fc = fc; 351 } else { 352 adapter->hw.fc = adapter->hw.original_fc = opt.def; 353 } 354 } 355 { /* Transmit Interrupt Delay */ 356 opt = (struct e1000_option) { 357 .type = range_option, 358 .name = "Transmit Interrupt Delay", 359 .err = "using default of " __MODULE_STRING(DEFAULT_TIDV), 360 .def = DEFAULT_TIDV, 361 .arg = { .r = { .min = MIN_TXDELAY, 362 .max = MAX_TXDELAY }} 363 }; 364 365 if (num_TxIntDelay > bd) { 366 adapter->tx_int_delay = TxIntDelay[bd]; 367 e1000_validate_option(&adapter->tx_int_delay, &opt, 368 adapter); 369 } else { 370 adapter->tx_int_delay = opt.def; 371 } 372 } 373 { /* Transmit Absolute Interrupt Delay */ 374 opt = (struct e1000_option) { 375 .type = range_option, 376 .name = "Transmit Absolute Interrupt Delay", 377 .err = "using default of " __MODULE_STRING(DEFAULT_TADV), 378 .def = DEFAULT_TADV, 379 .arg = { .r = { .min = MIN_TXABSDELAY, 380 .max = MAX_TXABSDELAY }} 381 }; 382 383 if (num_TxAbsIntDelay > bd) { 384 adapter->tx_abs_int_delay = TxAbsIntDelay[bd]; 385 e1000_validate_option(&adapter->tx_abs_int_delay, &opt, 386 adapter); 387 } else { 388 adapter->tx_abs_int_delay = opt.def; 389 } 390 } 391 { /* Receive Interrupt Delay */ 392 opt = (struct e1000_option) { 393 .type = range_option, 394 .name = "Receive Interrupt Delay", 395 .err = "using default of " __MODULE_STRING(DEFAULT_RDTR), 396 .def = DEFAULT_RDTR, 397 .arg = { .r = { .min = MIN_RXDELAY, 398 .max = MAX_RXDELAY }} 399 }; 400 401 if (num_RxIntDelay > bd) { 402 adapter->rx_int_delay = RxIntDelay[bd]; 403 e1000_validate_option(&adapter->rx_int_delay, &opt, 404 adapter); 405 } else { 406 adapter->rx_int_delay = opt.def; 407 } 408 } 409 { /* Receive Absolute Interrupt Delay */ 410 opt = (struct e1000_option) { 411 .type = range_option, 412 .name = "Receive Absolute Interrupt Delay", 413 .err = "using default of " __MODULE_STRING(DEFAULT_RADV), 414 .def = DEFAULT_RADV, 415 .arg = { .r = { .min = MIN_RXABSDELAY, 416 .max = MAX_RXABSDELAY }} 417 }; 418 419 if (num_RxAbsIntDelay > bd) { 420 adapter->rx_abs_int_delay = RxAbsIntDelay[bd]; 421 e1000_validate_option(&adapter->rx_abs_int_delay, &opt, 422 adapter); 423 } else { 424 adapter->rx_abs_int_delay = opt.def; 425 } 426 } 427 { /* Interrupt Throttling Rate */ 428 opt = (struct e1000_option) { 429 .type = range_option, 430 .name = "Interrupt Throttling Rate (ints/sec)", 431 .err = "using default of " __MODULE_STRING(DEFAULT_ITR), 432 .def = DEFAULT_ITR, 433 .arg = { .r = { .min = MIN_ITR, 434 .max = MAX_ITR }} 435 }; 436 437 if (num_InterruptThrottleRate > bd) { 438 adapter->itr = InterruptThrottleRate[bd]; 439 switch (adapter->itr) { 440 case 0: 441 e_dev_info("%s turned off\n", opt.name); 442 break; 443 case 1: 444 e_dev_info("%s set to dynamic mode\n", 445 opt.name); 446 adapter->itr_setting = adapter->itr; 447 adapter->itr = 20000; 448 break; 449 case 3: 450 e_dev_info("%s set to dynamic conservative " 451 "mode\n", opt.name); 452 adapter->itr_setting = adapter->itr; 453 adapter->itr = 20000; 454 break; 455 case 4: 456 e_dev_info("%s set to simplified " 457 "(2000-8000) ints mode\n", opt.name); 458 adapter->itr_setting = adapter->itr; 459 break; 460 default: 461 e1000_validate_option(&adapter->itr, &opt, 462 adapter); 463 /* save the setting, because the dynamic bits 464 * change itr. 465 * clear the lower two bits because they are 466 * used as control 467 */ 468 adapter->itr_setting = adapter->itr & ~3; 469 break; 470 } 471 } else { 472 adapter->itr_setting = opt.def; 473 adapter->itr = 20000; 474 } 475 } 476 { /* Smart Power Down */ 477 opt = (struct e1000_option) { 478 .type = enable_option, 479 .name = "PHY Smart Power Down", 480 .err = "defaulting to Disabled", 481 .def = OPTION_DISABLED 482 }; 483 484 if (num_SmartPowerDownEnable > bd) { 485 unsigned int spd = SmartPowerDownEnable[bd]; 486 e1000_validate_option(&spd, &opt, adapter); 487 adapter->smart_power_down = spd; 488 } else { 489 adapter->smart_power_down = opt.def; 490 } 491 } 492 493 switch (adapter->hw.media_type) { 494 case e1000_media_type_fiber: 495 case e1000_media_type_internal_serdes: 496 e1000_check_fiber_options(adapter); 497 break; 498 case e1000_media_type_copper: 499 e1000_check_copper_options(adapter); 500 break; 501 default: 502 BUG(); 503 } 504 } 505 506 /** 507 * e1000_check_fiber_options - Range Checking for Link Options, Fiber Version 508 * @adapter: board private structure 509 * 510 * Handles speed and duplex options on fiber adapters 511 **/ 512 static void e1000_check_fiber_options(struct e1000_adapter *adapter) 513 { 514 int bd = adapter->bd_number; 515 if (num_Speed > bd) { 516 e_dev_info("Speed not valid for fiber adapters, parameter " 517 "ignored\n"); 518 } 519 520 if (num_Duplex > bd) { 521 e_dev_info("Duplex not valid for fiber adapters, parameter " 522 "ignored\n"); 523 } 524 525 if ((num_AutoNeg > bd) && (AutoNeg[bd] != 0x20)) { 526 e_dev_info("AutoNeg other than 1000/Full is not valid for fiber" 527 "adapters, parameter ignored\n"); 528 } 529 } 530 531 /** 532 * e1000_check_copper_options - Range Checking for Link Options, Copper Version 533 * @adapter: board private structure 534 * 535 * Handles speed and duplex options on copper adapters 536 **/ 537 static void e1000_check_copper_options(struct e1000_adapter *adapter) 538 { 539 struct e1000_option opt; 540 unsigned int speed, dplx, an; 541 int bd = adapter->bd_number; 542 543 { /* Speed */ 544 static const struct e1000_opt_list speed_list[] = { 545 { 0, "" }, 546 { SPEED_10, "" }, 547 { SPEED_100, "" }, 548 { SPEED_1000, "" }}; 549 550 opt = (struct e1000_option) { 551 .type = list_option, 552 .name = "Speed", 553 .err = "parameter ignored", 554 .def = 0, 555 .arg = { .l = { .nr = ARRAY_SIZE(speed_list), 556 .p = speed_list }} 557 }; 558 559 if (num_Speed > bd) { 560 speed = Speed[bd]; 561 e1000_validate_option(&speed, &opt, adapter); 562 } else { 563 speed = opt.def; 564 } 565 } 566 { /* Duplex */ 567 static const struct e1000_opt_list dplx_list[] = { 568 { 0, "" }, 569 { HALF_DUPLEX, "" }, 570 { FULL_DUPLEX, "" }}; 571 572 opt = (struct e1000_option) { 573 .type = list_option, 574 .name = "Duplex", 575 .err = "parameter ignored", 576 .def = 0, 577 .arg = { .l = { .nr = ARRAY_SIZE(dplx_list), 578 .p = dplx_list }} 579 }; 580 581 if (num_Duplex > bd) { 582 dplx = Duplex[bd]; 583 e1000_validate_option(&dplx, &opt, adapter); 584 } else { 585 dplx = opt.def; 586 } 587 } 588 589 if ((num_AutoNeg > bd) && (speed != 0 || dplx != 0)) { 590 e_dev_info("AutoNeg specified along with Speed or Duplex, " 591 "parameter ignored\n"); 592 adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; 593 } else { /* Autoneg */ 594 static const struct e1000_opt_list an_list[] = 595 #define AA "AutoNeg advertising " 596 {{ 0x01, AA "10/HD" }, 597 { 0x02, AA "10/FD" }, 598 { 0x03, AA "10/FD, 10/HD" }, 599 { 0x04, AA "100/HD" }, 600 { 0x05, AA "100/HD, 10/HD" }, 601 { 0x06, AA "100/HD, 10/FD" }, 602 { 0x07, AA "100/HD, 10/FD, 10/HD" }, 603 { 0x08, AA "100/FD" }, 604 { 0x09, AA "100/FD, 10/HD" }, 605 { 0x0a, AA "100/FD, 10/FD" }, 606 { 0x0b, AA "100/FD, 10/FD, 10/HD" }, 607 { 0x0c, AA "100/FD, 100/HD" }, 608 { 0x0d, AA "100/FD, 100/HD, 10/HD" }, 609 { 0x0e, AA "100/FD, 100/HD, 10/FD" }, 610 { 0x0f, AA "100/FD, 100/HD, 10/FD, 10/HD" }, 611 { 0x20, AA "1000/FD" }, 612 { 0x21, AA "1000/FD, 10/HD" }, 613 { 0x22, AA "1000/FD, 10/FD" }, 614 { 0x23, AA "1000/FD, 10/FD, 10/HD" }, 615 { 0x24, AA "1000/FD, 100/HD" }, 616 { 0x25, AA "1000/FD, 100/HD, 10/HD" }, 617 { 0x26, AA "1000/FD, 100/HD, 10/FD" }, 618 { 0x27, AA "1000/FD, 100/HD, 10/FD, 10/HD" }, 619 { 0x28, AA "1000/FD, 100/FD" }, 620 { 0x29, AA "1000/FD, 100/FD, 10/HD" }, 621 { 0x2a, AA "1000/FD, 100/FD, 10/FD" }, 622 { 0x2b, AA "1000/FD, 100/FD, 10/FD, 10/HD" }, 623 { 0x2c, AA "1000/FD, 100/FD, 100/HD" }, 624 { 0x2d, AA "1000/FD, 100/FD, 100/HD, 10/HD" }, 625 { 0x2e, AA "1000/FD, 100/FD, 100/HD, 10/FD" }, 626 { 0x2f, AA "1000/FD, 100/FD, 100/HD, 10/FD, 10/HD" }}; 627 628 opt = (struct e1000_option) { 629 .type = list_option, 630 .name = "AutoNeg", 631 .err = "parameter ignored", 632 .def = AUTONEG_ADV_DEFAULT, 633 .arg = { .l = { .nr = ARRAY_SIZE(an_list), 634 .p = an_list }} 635 }; 636 637 if (num_AutoNeg > bd) { 638 an = AutoNeg[bd]; 639 e1000_validate_option(&an, &opt, adapter); 640 } else { 641 an = opt.def; 642 } 643 adapter->hw.autoneg_advertised = an; 644 } 645 646 switch (speed + dplx) { 647 case 0: 648 adapter->hw.autoneg = adapter->fc_autoneg = 1; 649 if ((num_Speed > bd) && (speed != 0 || dplx != 0)) 650 e_dev_info("Speed and duplex autonegotiation " 651 "enabled\n"); 652 break; 653 case HALF_DUPLEX: 654 e_dev_info("Half Duplex specified without Speed\n"); 655 e_dev_info("Using Autonegotiation at Half Duplex only\n"); 656 adapter->hw.autoneg = adapter->fc_autoneg = 1; 657 adapter->hw.autoneg_advertised = ADVERTISE_10_HALF | 658 ADVERTISE_100_HALF; 659 break; 660 case FULL_DUPLEX: 661 e_dev_info("Full Duplex specified without Speed\n"); 662 e_dev_info("Using Autonegotiation at Full Duplex only\n"); 663 adapter->hw.autoneg = adapter->fc_autoneg = 1; 664 adapter->hw.autoneg_advertised = ADVERTISE_10_FULL | 665 ADVERTISE_100_FULL | 666 ADVERTISE_1000_FULL; 667 break; 668 case SPEED_10: 669 e_dev_info("10 Mbps Speed specified without Duplex\n"); 670 e_dev_info("Using Autonegotiation at 10 Mbps only\n"); 671 adapter->hw.autoneg = adapter->fc_autoneg = 1; 672 adapter->hw.autoneg_advertised = ADVERTISE_10_HALF | 673 ADVERTISE_10_FULL; 674 break; 675 case SPEED_10 + HALF_DUPLEX: 676 e_dev_info("Forcing to 10 Mbps Half Duplex\n"); 677 adapter->hw.autoneg = adapter->fc_autoneg = 0; 678 adapter->hw.forced_speed_duplex = e1000_10_half; 679 adapter->hw.autoneg_advertised = 0; 680 break; 681 case SPEED_10 + FULL_DUPLEX: 682 e_dev_info("Forcing to 10 Mbps Full Duplex\n"); 683 adapter->hw.autoneg = adapter->fc_autoneg = 0; 684 adapter->hw.forced_speed_duplex = e1000_10_full; 685 adapter->hw.autoneg_advertised = 0; 686 break; 687 case SPEED_100: 688 e_dev_info("100 Mbps Speed specified without Duplex\n"); 689 e_dev_info("Using Autonegotiation at 100 Mbps only\n"); 690 adapter->hw.autoneg = adapter->fc_autoneg = 1; 691 adapter->hw.autoneg_advertised = ADVERTISE_100_HALF | 692 ADVERTISE_100_FULL; 693 break; 694 case SPEED_100 + HALF_DUPLEX: 695 e_dev_info("Forcing to 100 Mbps Half Duplex\n"); 696 adapter->hw.autoneg = adapter->fc_autoneg = 0; 697 adapter->hw.forced_speed_duplex = e1000_100_half; 698 adapter->hw.autoneg_advertised = 0; 699 break; 700 case SPEED_100 + FULL_DUPLEX: 701 e_dev_info("Forcing to 100 Mbps Full Duplex\n"); 702 adapter->hw.autoneg = adapter->fc_autoneg = 0; 703 adapter->hw.forced_speed_duplex = e1000_100_full; 704 adapter->hw.autoneg_advertised = 0; 705 break; 706 case SPEED_1000: 707 e_dev_info("1000 Mbps Speed specified without Duplex\n"); 708 goto full_duplex_only; 709 case SPEED_1000 + HALF_DUPLEX: 710 e_dev_info("Half Duplex is not supported at 1000 Mbps\n"); 711 /* fall through */ 712 case SPEED_1000 + FULL_DUPLEX: 713 full_duplex_only: 714 e_dev_info("Using Autonegotiation at 1000 Mbps Full Duplex " 715 "only\n"); 716 adapter->hw.autoneg = adapter->fc_autoneg = 1; 717 adapter->hw.autoneg_advertised = ADVERTISE_1000_FULL; 718 break; 719 default: 720 BUG(); 721 } 722 723 /* Speed, AutoNeg and MDI/MDI-X must all play nice */ 724 if (e1000_validate_mdi_setting(&(adapter->hw)) < 0) { 725 e_dev_info("Speed, AutoNeg and MDI-X specs are incompatible. " 726 "Setting MDI-X to a compatible value.\n"); 727 } 728 } 729 730