LXR linux/drivers/net/e1000/e1000

   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                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
 537static 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
 563static 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:
 739full_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