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