Jeff Kirsher | ae06c70 | 2018-03-22 10:08:48 -0700 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Jeff Kirsher | 51dce24 | 2018-04-26 08:08:09 -0700 | [diff] [blame] | 2 | /* Copyright(c) 1999 - 2006 Intel Corporation. */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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) \ |
Bill Pemberton | 9f9a12f | 2012-12-03 09:24:25 -0500 | [diff] [blame] | 23 | static int X[E1000_MAX_NIC+1] = E1000_PARAM_INIT; \ |
Stephen Hemminger | abec42a | 2007-10-29 10:46:19 -0700 | [diff] [blame] | 24 | static unsigned int num_##X; \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 83 | E1000_PARAM(AutoNeg, "Advertised auto-negotiation setting"); |
Auke Kok | 04fedbf | 2006-11-01 08:48:07 -0800 | [diff] [blame] | 84 | #define AUTONEG_ADV_DEFAULT 0x2F |
| 85 | #define AUTONEG_ADV_MASK 0x2F |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 97 | E1000_PARAM(FlowControl, "Flow Control setting"); |
Auke Kok | 04fedbf | 2006-11-01 08:48:07 -0800 | [diff] [blame] | 98 | #define FLOW_CONTROL_DEFAULT FLOW_CONTROL_FULL |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | E1000_PARAM(XsumRX, "Disable or enable Receive Checksum offload"); |
| 110 | |
| 111 | /* Transmit Interrupt Delay in units of 1.024 microseconds |
Auke Kok | 04fedbf | 2006-11-01 08:48:07 -0800 | [diff] [blame] | 112 | * Tx interrupt delay needs to typically be set to something non zero |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | * |
| 114 | * Valid Range: 0-65535 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | E1000_PARAM(TxIntDelay, "Transmit Interrupt Delay"); |
Jesse Brandeburg | 835bb12 | 2006-11-01 08:48:13 -0800 | [diff] [blame] | 117 | #define DEFAULT_TIDV 8 |
Auke Kok | 04fedbf | 2006-11-01 08:48:07 -0800 | [diff] [blame] | 118 | #define MAX_TXDELAY 0xFFFF |
| 119 | #define MIN_TXDELAY 0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | |
| 121 | /* Transmit Absolute Interrupt Delay in units of 1.024 microseconds |
| 122 | * |
| 123 | * Valid Range: 0-65535 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | E1000_PARAM(TxAbsIntDelay, "Transmit Absolute Interrupt Delay"); |
Jesse Brandeburg | 835bb12 | 2006-11-01 08:48:13 -0800 | [diff] [blame] | 126 | #define DEFAULT_TADV 32 |
Auke Kok | 04fedbf | 2006-11-01 08:48:07 -0800 | [diff] [blame] | 127 | #define MAX_TXABSDELAY 0xFFFF |
| 128 | #define MIN_TXABSDELAY 0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 129 | |
| 130 | /* Receive Interrupt Delay in units of 1.024 microseconds |
Auke Kok | 04fedbf | 2006-11-01 08:48:07 -0800 | [diff] [blame] | 131 | * hardware will likely hang if you set this to anything but zero. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 132 | * |
| 133 | * Valid Range: 0-65535 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 135 | E1000_PARAM(RxIntDelay, "Receive Interrupt Delay"); |
Auke Kok | 04fedbf | 2006-11-01 08:48:07 -0800 | [diff] [blame] | 136 | #define DEFAULT_RDTR 0 |
| 137 | #define MAX_RXDELAY 0xFFFF |
| 138 | #define MIN_RXDELAY 0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 139 | |
| 140 | /* Receive Absolute Interrupt Delay in units of 1.024 microseconds |
| 141 | * |
| 142 | * Valid Range: 0-65535 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 143 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | E1000_PARAM(RxAbsIntDelay, "Receive Absolute Interrupt Delay"); |
Jesse Brandeburg | 835bb12 | 2006-11-01 08:48:13 -0800 | [diff] [blame] | 145 | #define DEFAULT_RADV 8 |
Auke Kok | 04fedbf | 2006-11-01 08:48:07 -0800 | [diff] [blame] | 146 | #define MAX_RXABSDELAY 0xFFFF |
| 147 | #define MIN_RXABSDELAY 0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | |
| 149 | /* Interrupt Throttle Rate (interrupts/sec) |
| 150 | * |
Jesse Brandeburg | 835bb12 | 2006-11-01 08:48:13 -0800 | [diff] [blame] | 151 | * Valid Range: 100-100000 (0=off, 1=dynamic, 3=dynamic conservative) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 152 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | E1000_PARAM(InterruptThrottleRate, "Interrupt Throttling Rate"); |
Jesse Brandeburg | 835bb12 | 2006-11-01 08:48:13 -0800 | [diff] [blame] | 154 | #define DEFAULT_ITR 3 |
Auke Kok | 04fedbf | 2006-11-01 08:48:07 -0800 | [diff] [blame] | 155 | #define MAX_ITR 100000 |
| 156 | #define MIN_ITR 100 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | |
Auke Kok | 9a53a20 | 2006-06-27 09:06:45 -0700 | [diff] [blame] | 158 | /* Enable Smart Power Down of the PHY |
| 159 | * |
| 160 | * Valid Range: 0, 1 |
| 161 | * |
| 162 | * Default Value: 0 (disabled) |
| 163 | */ |
Auke Kok | 9a53a20 | 2006-06-27 09:06:45 -0700 | [diff] [blame] | 164 | E1000_PARAM(SmartPowerDownEnable, "Enable PHY smart power down"); |
| 165 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | struct e1000_option { |
| 167 | enum { enable_option, range_option, list_option } type; |
Stephen Hemminger | abec42a | 2007-10-29 10:46:19 -0700 | [diff] [blame] | 168 | const char *name; |
| 169 | const char *err; |
| 170 | int def; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | union { |
| 172 | struct { /* range_option info */ |
| 173 | int min; |
| 174 | int max; |
| 175 | } r; |
| 176 | struct { /* list_option info */ |
| 177 | int nr; |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 178 | const struct e1000_opt_list { int i; char *str; } *p; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | } l; |
| 180 | } arg; |
| 181 | }; |
| 182 | |
Bill Pemberton | 9f9a12f | 2012-12-03 09:24:25 -0500 | [diff] [blame] | 183 | static int e1000_validate_option(unsigned int *value, |
Greg Kroah-Hartman | 1dd06ae | 2012-12-06 14:30:56 +0000 | [diff] [blame] | 184 | const struct e1000_option *opt, |
| 185 | struct e1000_adapter *adapter) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | { |
Jesse Brandeburg | 96838a4 | 2006-01-18 13:01:39 -0800 | [diff] [blame] | 187 | if (*value == OPTION_UNSET) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 188 | *value = opt->def; |
| 189 | return 0; |
| 190 | } |
| 191 | |
| 192 | switch (opt->type) { |
| 193 | case enable_option: |
| 194 | switch (*value) { |
| 195 | case OPTION_ENABLED: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 196 | e_dev_info("%s Enabled\n", opt->name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | return 0; |
| 198 | case OPTION_DISABLED: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 199 | e_dev_info("%s Disabled\n", opt->name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | return 0; |
| 201 | } |
| 202 | break; |
| 203 | case range_option: |
Jesse Brandeburg | 96838a4 | 2006-01-18 13:01:39 -0800 | [diff] [blame] | 204 | if (*value >= opt->arg.r.min && *value <= opt->arg.r.max) { |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 205 | e_dev_info("%s set to %i\n", opt->name, *value); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | return 0; |
| 207 | } |
| 208 | break; |
| 209 | case list_option: { |
| 210 | int i; |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 211 | const struct e1000_opt_list *ent; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | |
Jesse Brandeburg | 96838a4 | 2006-01-18 13:01:39 -0800 | [diff] [blame] | 213 | for (i = 0; i < opt->arg.l.nr; i++) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 214 | ent = &opt->arg.l.p[i]; |
Jesse Brandeburg | 96838a4 | 2006-01-18 13:01:39 -0800 | [diff] [blame] | 215 | if (*value == ent->i) { |
| 216 | if (ent->str[0] != '\0') |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 217 | e_dev_info("%s\n", ent->str); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 218 | return 0; |
| 219 | } |
| 220 | } |
| 221 | } |
| 222 | break; |
| 223 | default: |
| 224 | BUG(); |
| 225 | } |
| 226 | |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 227 | e_dev_info("Invalid %s value specified (%i) %s\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | **/ |
Bill Pemberton | 9f9a12f | 2012-12-03 09:24:25 -0500 | [diff] [blame] | 245 | void e1000_check_options(struct e1000_adapter *adapter) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 246 | { |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 247 | struct e1000_option opt; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 248 | int bd = adapter->bd_number; |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 249 | |
Jesse Brandeburg | 96838a4 | 2006-01-18 13:01:39 -0800 | [diff] [blame] | 250 | if (bd >= E1000_MAX_NIC) { |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 251 | e_dev_warn("Warning: no configuration for board #%i " |
| 252 | "using defaults for all values\n", bd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 253 | } |
| 254 | |
| 255 | { /* Transmit Descriptor Count */ |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 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) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 261 | .type = range_option, |
| 262 | .name = "Transmit Descriptors", |
| 263 | .err = "using default of " |
| 264 | __MODULE_STRING(E1000_DEFAULT_TXD), |
| 265 | .def = E1000_DEFAULT_TXD, |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 266 | .arg = { .r = { |
| 267 | .min = E1000_MIN_TXD, |
| 268 | .max = mac_type < e1000_82544 ? E1000_MAX_TXD : E1000_MAX_82544_TXD |
| 269 | }} |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 270 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 272 | if (num_TxDescriptors > bd) { |
| 273 | tx_ring->count = TxDescriptors[bd]; |
| 274 | e1000_validate_option(&tx_ring->count, &opt, adapter); |
Milind Arun Choudhary | 9099cfb | 2007-04-27 13:55:29 -0700 | [diff] [blame] | 275 | tx_ring->count = ALIGN(tx_ring->count, |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 276 | REQ_TX_DESCRIPTOR_MULTIPLE); |
| 277 | } else { |
| 278 | tx_ring->count = opt.def; |
| 279 | } |
Jeff Kirsher | f56799e | 2006-01-12 16:50:39 -0800 | [diff] [blame] | 280 | for (i = 0; i < adapter->num_tx_queues; i++) |
Mallikarjuna R Chilakala | 581d708 | 2005-10-04 07:01:55 -0400 | [diff] [blame] | 281 | tx_ring[i].count = tx_ring->count; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 282 | } |
| 283 | { /* Receive Descriptor Count */ |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 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) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 289 | .type = range_option, |
| 290 | .name = "Receive Descriptors", |
| 291 | .err = "using default of " |
| 292 | __MODULE_STRING(E1000_DEFAULT_RXD), |
| 293 | .def = E1000_DEFAULT_RXD, |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 294 | .arg = { .r = { |
| 295 | .min = E1000_MIN_RXD, |
Jeff Kirsher | 6cfbd97 | 2013-02-09 12:49:21 +0000 | [diff] [blame] | 296 | .max = mac_type < e1000_82544 ? E1000_MAX_RXD : |
| 297 | E1000_MAX_82544_RXD |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 298 | }} |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 299 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 300 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 301 | if (num_RxDescriptors > bd) { |
| 302 | rx_ring->count = RxDescriptors[bd]; |
| 303 | e1000_validate_option(&rx_ring->count, &opt, adapter); |
Milind Arun Choudhary | 9099cfb | 2007-04-27 13:55:29 -0700 | [diff] [blame] | 304 | rx_ring->count = ALIGN(rx_ring->count, |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 305 | REQ_RX_DESCRIPTOR_MULTIPLE); |
| 306 | } else { |
| 307 | rx_ring->count = opt.def; |
| 308 | } |
Jeff Kirsher | f56799e | 2006-01-12 16:50:39 -0800 | [diff] [blame] | 309 | for (i = 0; i < adapter->num_rx_queues; i++) |
Mallikarjuna R Chilakala | 581d708 | 2005-10-04 07:01:55 -0400 | [diff] [blame] | 310 | rx_ring[i].count = rx_ring->count; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 311 | } |
| 312 | { /* Checksum Offload Enable/Disable */ |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 313 | opt = (struct e1000_option) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 314 | .type = enable_option, |
| 315 | .name = "Checksum Offload", |
| 316 | .err = "defaulting to Enabled", |
| 317 | .def = OPTION_ENABLED |
| 318 | }; |
| 319 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 320 | if (num_XsumRX > bd) { |
Stephen Hemminger | abec42a | 2007-10-29 10:46:19 -0700 | [diff] [blame] | 321 | unsigned int rx_csum = XsumRX[bd]; |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 322 | e1000_validate_option(&rx_csum, &opt, adapter); |
| 323 | adapter->rx_csum = rx_csum; |
| 324 | } else { |
| 325 | adapter->rx_csum = opt.def; |
| 326 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 327 | } |
| 328 | { /* Flow Control */ |
| 329 | |
Jeff Kirsher | 6674450 | 2010-12-01 19:59:50 +0000 | [diff] [blame] | 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 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 337 | |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 338 | opt = (struct e1000_option) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 339 | .type = list_option, |
| 340 | .name = "Flow Control", |
| 341 | .err = "reading default settings from EEPROM", |
Jeff Kirsher | 11241b1 | 2006-09-27 12:53:28 -0700 | [diff] [blame] | 342 | .def = E1000_FC_DEFAULT, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 343 | .arg = { .l = { .nr = ARRAY_SIZE(fc_list), |
| 344 | .p = fc_list }} |
| 345 | }; |
| 346 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 347 | if (num_FlowControl > bd) { |
Stephen Hemminger | abec42a | 2007-10-29 10:46:19 -0700 | [diff] [blame] | 348 | unsigned int fc = FlowControl[bd]; |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 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 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 354 | } |
| 355 | { /* Transmit Interrupt Delay */ |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 356 | opt = (struct e1000_option) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 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 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 372 | } |
| 373 | { /* Transmit Absolute Interrupt Delay */ |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 374 | opt = (struct e1000_option) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 383 | if (num_TxAbsIntDelay > bd) { |
| 384 | adapter->tx_abs_int_delay = TxAbsIntDelay[bd]; |
| 385 | e1000_validate_option(&adapter->tx_abs_int_delay, &opt, |
Jeff Kirsher | 6cfbd97 | 2013-02-09 12:49:21 +0000 | [diff] [blame] | 386 | adapter); |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 387 | } else { |
| 388 | adapter->tx_abs_int_delay = opt.def; |
| 389 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 390 | } |
| 391 | { /* Receive Interrupt Delay */ |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 392 | opt = (struct e1000_option) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 401 | if (num_RxIntDelay > bd) { |
| 402 | adapter->rx_int_delay = RxIntDelay[bd]; |
| 403 | e1000_validate_option(&adapter->rx_int_delay, &opt, |
Jeff Kirsher | 6cfbd97 | 2013-02-09 12:49:21 +0000 | [diff] [blame] | 404 | adapter); |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 405 | } else { |
| 406 | adapter->rx_int_delay = opt.def; |
| 407 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 408 | } |
| 409 | { /* Receive Absolute Interrupt Delay */ |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 410 | opt = (struct e1000_option) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 419 | if (num_RxAbsIntDelay > bd) { |
| 420 | adapter->rx_abs_int_delay = RxAbsIntDelay[bd]; |
| 421 | e1000_validate_option(&adapter->rx_abs_int_delay, &opt, |
Jeff Kirsher | 6cfbd97 | 2013-02-09 12:49:21 +0000 | [diff] [blame] | 422 | adapter); |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 423 | } else { |
| 424 | adapter->rx_abs_int_delay = opt.def; |
| 425 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 426 | } |
| 427 | { /* Interrupt Throttling Rate */ |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 428 | opt = (struct e1000_option) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 437 | if (num_InterruptThrottleRate > bd) { |
| 438 | adapter->itr = InterruptThrottleRate[bd]; |
| 439 | switch (adapter->itr) { |
| 440 | case 0: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 441 | e_dev_info("%s turned off\n", opt.name); |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 442 | break; |
| 443 | case 1: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 444 | e_dev_info("%s set to dynamic mode\n", |
| 445 | opt.name); |
Jesse Brandeburg | 835bb12 | 2006-11-01 08:48:13 -0800 | [diff] [blame] | 446 | adapter->itr_setting = adapter->itr; |
| 447 | adapter->itr = 20000; |
| 448 | break; |
| 449 | case 3: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 450 | e_dev_info("%s set to dynamic conservative " |
| 451 | "mode\n", opt.name); |
Jesse Brandeburg | 835bb12 | 2006-11-01 08:48:13 -0800 | [diff] [blame] | 452 | adapter->itr_setting = adapter->itr; |
| 453 | adapter->itr = 20000; |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 454 | break; |
Jesse Brandeburg | eab2abf | 2010-05-04 22:26:03 +0000 | [diff] [blame] | 455 | case 4: |
| 456 | e_dev_info("%s set to simplified " |
Jeff Kirsher | 6cfbd97 | 2013-02-09 12:49:21 +0000 | [diff] [blame] | 457 | "(2000-8000) ints mode\n", opt.name); |
Jesse Brandeburg | eab2abf | 2010-05-04 22:26:03 +0000 | [diff] [blame] | 458 | adapter->itr_setting = adapter->itr; |
| 459 | break; |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 460 | default: |
| 461 | e1000_validate_option(&adapter->itr, &opt, |
Jeff Kirsher | 6cfbd97 | 2013-02-09 12:49:21 +0000 | [diff] [blame] | 462 | adapter); |
Jesse Brandeburg | eab2abf | 2010-05-04 22:26:03 +0000 | [diff] [blame] | 463 | /* save the setting, because the dynamic bits |
| 464 | * change itr. |
| 465 | * clear the lower two bits because they are |
Jeff Kirsher | 6cfbd97 | 2013-02-09 12:49:21 +0000 | [diff] [blame] | 466 | * used as control |
| 467 | */ |
Jesse Brandeburg | 7d16e65 | 2006-12-15 10:29:31 +0100 | [diff] [blame] | 468 | adapter->itr_setting = adapter->itr & ~3; |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 469 | break; |
| 470 | } |
| 471 | } else { |
Jesse Brandeburg | 835bb12 | 2006-11-01 08:48:13 -0800 | [diff] [blame] | 472 | adapter->itr_setting = opt.def; |
| 473 | adapter->itr = 20000; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 474 | } |
| 475 | } |
Auke Kok | 9a53a20 | 2006-06-27 09:06:45 -0700 | [diff] [blame] | 476 | { /* Smart Power Down */ |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 477 | opt = (struct e1000_option) { |
Auke Kok | 9a53a20 | 2006-06-27 09:06:45 -0700 | [diff] [blame] | 478 | .type = enable_option, |
| 479 | .name = "PHY Smart Power Down", |
| 480 | .err = "defaulting to Disabled", |
| 481 | .def = OPTION_DISABLED |
| 482 | }; |
| 483 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 484 | if (num_SmartPowerDownEnable > bd) { |
Stephen Hemminger | abec42a | 2007-10-29 10:46:19 -0700 | [diff] [blame] | 485 | unsigned int spd = SmartPowerDownEnable[bd]; |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 486 | e1000_validate_option(&spd, &opt, adapter); |
| 487 | adapter->smart_power_down = spd; |
| 488 | } else { |
| 489 | adapter->smart_power_down = opt.def; |
| 490 | } |
Auke Kok | 9a53a20 | 2006-06-27 09:06:45 -0700 | [diff] [blame] | 491 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 492 | |
Jesse Brandeburg | 96838a4 | 2006-01-18 13:01:39 -0800 | [diff] [blame] | 493 | switch (adapter->hw.media_type) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | **/ |
Bill Pemberton | 9f9a12f | 2012-12-03 09:24:25 -0500 | [diff] [blame] | 512 | static void e1000_check_fiber_options(struct e1000_adapter *adapter) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 513 | { |
| 514 | int bd = adapter->bd_number; |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 515 | if (num_Speed > bd) { |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 516 | e_dev_info("Speed not valid for fiber adapters, parameter " |
| 517 | "ignored\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 518 | } |
| 519 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 520 | if (num_Duplex > bd) { |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 521 | e_dev_info("Duplex not valid for fiber adapters, parameter " |
| 522 | "ignored\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 523 | } |
| 524 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 525 | if ((num_AutoNeg > bd) && (AutoNeg[bd] != 0x20)) { |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 526 | e_dev_info("AutoNeg other than 1000/Full is not valid for fiber" |
| 527 | "adapters, parameter ignored\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | **/ |
Bill Pemberton | 9f9a12f | 2012-12-03 09:24:25 -0500 | [diff] [blame] | 537 | static void e1000_check_copper_options(struct e1000_adapter *adapter) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 538 | { |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 539 | struct e1000_option opt; |
Stephen Hemminger | abec42a | 2007-10-29 10:46:19 -0700 | [diff] [blame] | 540 | unsigned int speed, dplx, an; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 541 | int bd = adapter->bd_number; |
| 542 | |
| 543 | { /* Speed */ |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 544 | static const struct e1000_opt_list speed_list[] = { |
| 545 | { 0, "" }, |
| 546 | { SPEED_10, "" }, |
| 547 | { SPEED_100, "" }, |
| 548 | { SPEED_1000, "" }}; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 549 | |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 550 | opt = (struct e1000_option) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 559 | if (num_Speed > bd) { |
| 560 | speed = Speed[bd]; |
| 561 | e1000_validate_option(&speed, &opt, adapter); |
| 562 | } else { |
| 563 | speed = opt.def; |
| 564 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 565 | } |
| 566 | { /* Duplex */ |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 567 | static const struct e1000_opt_list dplx_list[] = { |
| 568 | { 0, "" }, |
| 569 | { HALF_DUPLEX, "" }, |
| 570 | { FULL_DUPLEX, "" }}; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 571 | |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 572 | opt = (struct e1000_option) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 581 | if (num_Duplex > bd) { |
| 582 | dplx = Duplex[bd]; |
| 583 | e1000_validate_option(&dplx, &opt, adapter); |
| 584 | } else { |
| 585 | dplx = opt.def; |
| 586 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 587 | } |
| 588 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 589 | if ((num_AutoNeg > bd) && (speed != 0 || dplx != 0)) { |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 590 | e_dev_info("AutoNeg specified along with Speed or Duplex, " |
| 591 | "parameter ignored\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 592 | adapter->hw.autoneg_advertised = AUTONEG_ADV_DEFAULT; |
| 593 | } else { /* Autoneg */ |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 594 | static const struct e1000_opt_list an_list[] = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 16ecf85 | 2008-08-27 01:14:46 -0700 | [diff] [blame] | 628 | opt = (struct e1000_option) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 637 | if (num_AutoNeg > bd) { |
| 638 | an = AutoNeg[bd]; |
| 639 | e1000_validate_option(&an, &opt, adapter); |
| 640 | } else { |
| 641 | an = opt.def; |
| 642 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 643 | adapter->hw.autoneg_advertised = an; |
| 644 | } |
| 645 | |
| 646 | switch (speed + dplx) { |
| 647 | case 0: |
| 648 | adapter->hw.autoneg = adapter->fc_autoneg = 1; |
Auke Kok | 1db2740 | 2006-08-28 14:56:32 -0700 | [diff] [blame] | 649 | if ((num_Speed > bd) && (speed != 0 || dplx != 0)) |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 650 | e_dev_info("Speed and duplex autonegotiation " |
| 651 | "enabled\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 652 | break; |
| 653 | case HALF_DUPLEX: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 654 | e_dev_info("Half Duplex specified without Speed\n"); |
| 655 | e_dev_info("Using Autonegotiation at Half Duplex only\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 656 | adapter->hw.autoneg = adapter->fc_autoneg = 1; |
| 657 | adapter->hw.autoneg_advertised = ADVERTISE_10_HALF | |
Jeff Kirsher | 6cfbd97 | 2013-02-09 12:49:21 +0000 | [diff] [blame] | 658 | ADVERTISE_100_HALF; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 659 | break; |
| 660 | case FULL_DUPLEX: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 661 | e_dev_info("Full Duplex specified without Speed\n"); |
| 662 | e_dev_info("Using Autonegotiation at Full Duplex only\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 663 | adapter->hw.autoneg = adapter->fc_autoneg = 1; |
| 664 | adapter->hw.autoneg_advertised = ADVERTISE_10_FULL | |
Jeff Kirsher | 6cfbd97 | 2013-02-09 12:49:21 +0000 | [diff] [blame] | 665 | ADVERTISE_100_FULL | |
| 666 | ADVERTISE_1000_FULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 667 | break; |
| 668 | case SPEED_10: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 669 | e_dev_info("10 Mbps Speed specified without Duplex\n"); |
| 670 | e_dev_info("Using Autonegotiation at 10 Mbps only\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 671 | adapter->hw.autoneg = adapter->fc_autoneg = 1; |
| 672 | adapter->hw.autoneg_advertised = ADVERTISE_10_HALF | |
Jeff Kirsher | 6cfbd97 | 2013-02-09 12:49:21 +0000 | [diff] [blame] | 673 | ADVERTISE_10_FULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 674 | break; |
| 675 | case SPEED_10 + HALF_DUPLEX: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 676 | e_dev_info("Forcing to 10 Mbps Half Duplex\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 682 | e_dev_info("Forcing to 10 Mbps Full Duplex\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 688 | e_dev_info("100 Mbps Speed specified without Duplex\n"); |
| 689 | e_dev_info("Using Autonegotiation at 100 Mbps only\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 690 | adapter->hw.autoneg = adapter->fc_autoneg = 1; |
| 691 | adapter->hw.autoneg_advertised = ADVERTISE_100_HALF | |
Jeff Kirsher | 6cfbd97 | 2013-02-09 12:49:21 +0000 | [diff] [blame] | 692 | ADVERTISE_100_FULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 693 | break; |
| 694 | case SPEED_100 + HALF_DUPLEX: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 695 | e_dev_info("Forcing to 100 Mbps Half Duplex\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 701 | e_dev_info("Forcing to 100 Mbps Full Duplex\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 707 | e_dev_info("1000 Mbps Speed specified without Duplex\n"); |
Jesse Brandeburg | 9990fa3 | 2007-01-18 09:25:15 -0800 | [diff] [blame] | 708 | goto full_duplex_only; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 709 | case SPEED_1000 + HALF_DUPLEX: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 710 | e_dev_info("Half Duplex is not supported at 1000 Mbps\n"); |
Jeff Kirsher | 5463fce6 | 2020-06-03 20:07:26 -0700 | [diff] [blame] | 711 | fallthrough; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 712 | case SPEED_1000 + FULL_DUPLEX: |
Jesse Brandeburg | 9990fa3 | 2007-01-18 09:25:15 -0800 | [diff] [blame] | 713 | full_duplex_only: |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 714 | e_dev_info("Using Autonegotiation at 1000 Mbps Full Duplex " |
| 715 | "only\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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) { |
Emil Tantilov | 675ad47 | 2010-04-27 14:02:58 +0000 | [diff] [blame] | 725 | e_dev_info("Speed, AutoNeg and MDI-X specs are incompatible. " |
| 726 | "Setting MDI-X to a compatible value.\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 727 | } |
| 728 | } |
| 729 | |