1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c)  2018 Intel Corporation */
3 
4 /* ethtool support for igc */
5 #include <linux/if_vlan.h>
6 #include <linux/pm_runtime.h>
7 
8 #include "igc.h"
9 
10 /* forward declaration */
11 struct igc_stats {
12 	char stat_string[ETH_GSTRING_LEN];
13 	int sizeof_stat;
14 	int stat_offset;
15 };
16 
17 #define IGC_STAT(_name, _stat) { \
18 	.stat_string = _name, \
19 	.sizeof_stat = FIELD_SIZEOF(struct igc_adapter, _stat), \
20 	.stat_offset = offsetof(struct igc_adapter, _stat) \
21 }
22 
23 static const struct igc_stats igc_gstrings_stats[] = {
24 	IGC_STAT("rx_packets", stats.gprc),
25 	IGC_STAT("tx_packets", stats.gptc),
26 	IGC_STAT("rx_bytes", stats.gorc),
27 	IGC_STAT("tx_bytes", stats.gotc),
28 	IGC_STAT("rx_broadcast", stats.bprc),
29 	IGC_STAT("tx_broadcast", stats.bptc),
30 	IGC_STAT("rx_multicast", stats.mprc),
31 	IGC_STAT("tx_multicast", stats.mptc),
32 	IGC_STAT("multicast", stats.mprc),
33 	IGC_STAT("collisions", stats.colc),
34 	IGC_STAT("rx_crc_errors", stats.crcerrs),
35 	IGC_STAT("rx_no_buffer_count", stats.rnbc),
36 	IGC_STAT("rx_missed_errors", stats.mpc),
37 	IGC_STAT("tx_aborted_errors", stats.ecol),
38 	IGC_STAT("tx_carrier_errors", stats.tncrs),
39 	IGC_STAT("tx_window_errors", stats.latecol),
40 	IGC_STAT("tx_abort_late_coll", stats.latecol),
41 	IGC_STAT("tx_deferred_ok", stats.dc),
42 	IGC_STAT("tx_single_coll_ok", stats.scc),
43 	IGC_STAT("tx_multi_coll_ok", stats.mcc),
44 	IGC_STAT("tx_timeout_count", tx_timeout_count),
45 	IGC_STAT("rx_long_length_errors", stats.roc),
46 	IGC_STAT("rx_short_length_errors", stats.ruc),
47 	IGC_STAT("rx_align_errors", stats.algnerrc),
48 	IGC_STAT("tx_tcp_seg_good", stats.tsctc),
49 	IGC_STAT("tx_tcp_seg_failed", stats.tsctfc),
50 	IGC_STAT("rx_flow_control_xon", stats.xonrxc),
51 	IGC_STAT("rx_flow_control_xoff", stats.xoffrxc),
52 	IGC_STAT("tx_flow_control_xon", stats.xontxc),
53 	IGC_STAT("tx_flow_control_xoff", stats.xofftxc),
54 	IGC_STAT("rx_long_byte_count", stats.gorc),
55 	IGC_STAT("tx_dma_out_of_sync", stats.doosync),
56 	IGC_STAT("tx_smbus", stats.mgptc),
57 	IGC_STAT("rx_smbus", stats.mgprc),
58 	IGC_STAT("dropped_smbus", stats.mgpdc),
59 	IGC_STAT("os2bmc_rx_by_bmc", stats.o2bgptc),
60 	IGC_STAT("os2bmc_tx_by_bmc", stats.b2ospc),
61 	IGC_STAT("os2bmc_tx_by_host", stats.o2bspc),
62 	IGC_STAT("os2bmc_rx_by_host", stats.b2ogprc),
63 	IGC_STAT("tx_hwtstamp_timeouts", tx_hwtstamp_timeouts),
64 	IGC_STAT("tx_hwtstamp_skipped", tx_hwtstamp_skipped),
65 	IGC_STAT("rx_hwtstamp_cleared", rx_hwtstamp_cleared),
66 };
67 
68 #define IGC_NETDEV_STAT(_net_stat) { \
69 	.stat_string = __stringify(_net_stat), \
70 	.sizeof_stat = FIELD_SIZEOF(struct rtnl_link_stats64, _net_stat), \
71 	.stat_offset = offsetof(struct rtnl_link_stats64, _net_stat) \
72 }
73 
74 static const struct igc_stats igc_gstrings_net_stats[] = {
75 	IGC_NETDEV_STAT(rx_errors),
76 	IGC_NETDEV_STAT(tx_errors),
77 	IGC_NETDEV_STAT(tx_dropped),
78 	IGC_NETDEV_STAT(rx_length_errors),
79 	IGC_NETDEV_STAT(rx_over_errors),
80 	IGC_NETDEV_STAT(rx_frame_errors),
81 	IGC_NETDEV_STAT(rx_fifo_errors),
82 	IGC_NETDEV_STAT(tx_fifo_errors),
83 	IGC_NETDEV_STAT(tx_heartbeat_errors)
84 };
85 
86 enum igc_diagnostics_results {
87 	TEST_REG = 0,
88 	TEST_EEP,
89 	TEST_IRQ,
90 	TEST_LOOP,
91 	TEST_LINK
92 };
93 
94 static const char igc_gstrings_test[][ETH_GSTRING_LEN] = {
95 	[TEST_REG]  = "Register test  (offline)",
96 	[TEST_EEP]  = "Eeprom test    (offline)",
97 	[TEST_IRQ]  = "Interrupt test (offline)",
98 	[TEST_LOOP] = "Loopback test  (offline)",
99 	[TEST_LINK] = "Link test   (on/offline)"
100 };
101 
102 #define IGC_TEST_LEN (sizeof(igc_gstrings_test) / ETH_GSTRING_LEN)
103 
104 #define IGC_GLOBAL_STATS_LEN	\
105 	(sizeof(igc_gstrings_stats) / sizeof(struct igc_stats))
106 #define IGC_NETDEV_STATS_LEN	\
107 	(sizeof(igc_gstrings_net_stats) / sizeof(struct igc_stats))
108 #define IGC_RX_QUEUE_STATS_LEN \
109 	(sizeof(struct igc_rx_queue_stats) / sizeof(u64))
110 #define IGC_TX_QUEUE_STATS_LEN 3 /* packets, bytes, restart_queue */
111 #define IGC_QUEUE_STATS_LEN \
112 	((((struct igc_adapter *)netdev_priv(netdev))->num_rx_queues * \
113 	  IGC_RX_QUEUE_STATS_LEN) + \
114 	 (((struct igc_adapter *)netdev_priv(netdev))->num_tx_queues * \
115 	  IGC_TX_QUEUE_STATS_LEN))
116 #define IGC_STATS_LEN \
117 	(IGC_GLOBAL_STATS_LEN + IGC_NETDEV_STATS_LEN + IGC_QUEUE_STATS_LEN)
118 
119 static const char igc_priv_flags_strings[][ETH_GSTRING_LEN] = {
120 #define IGC_PRIV_FLAGS_LEGACY_RX	BIT(0)
121 	"legacy-rx",
122 };
123 
124 #define IGC_PRIV_FLAGS_STR_LEN ARRAY_SIZE(igc_priv_flags_strings)
125 
126 static void igc_get_drvinfo(struct net_device *netdev,
127 			    struct ethtool_drvinfo *drvinfo)
128 {
129 	struct igc_adapter *adapter = netdev_priv(netdev);
130 
131 	strlcpy(drvinfo->driver,  igc_driver_name, sizeof(drvinfo->driver));
132 	strlcpy(drvinfo->version, igc_driver_version, sizeof(drvinfo->version));
133 
134 	/* add fw_version here */
135 	strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
136 		sizeof(drvinfo->bus_info));
137 
138 	drvinfo->n_priv_flags = IGC_PRIV_FLAGS_STR_LEN;
139 }
140 
141 static int igc_get_regs_len(struct net_device *netdev)
142 {
143 	return IGC_REGS_LEN * sizeof(u32);
144 }
145 
146 static void igc_get_regs(struct net_device *netdev,
147 			 struct ethtool_regs *regs, void *p)
148 {
149 	struct igc_adapter *adapter = netdev_priv(netdev);
150 	struct igc_hw *hw = &adapter->hw;
151 	u32 *regs_buff = p;
152 	u8 i;
153 
154 	memset(p, 0, IGC_REGS_LEN * sizeof(u32));
155 
156 	regs->version = (1u << 24) | (hw->revision_id << 16) | hw->device_id;
157 
158 	/* General Registers */
159 	regs_buff[0] = rd32(IGC_CTRL);
160 	regs_buff[1] = rd32(IGC_STATUS);
161 	regs_buff[2] = rd32(IGC_CTRL_EXT);
162 	regs_buff[3] = rd32(IGC_MDIC);
163 	regs_buff[4] = rd32(IGC_CONNSW);
164 
165 	/* NVM Register */
166 	regs_buff[5] = rd32(IGC_EECD);
167 
168 	/* Interrupt */
169 	/* Reading EICS for EICR because they read the
170 	 * same but EICS does not clear on read
171 	 */
172 	regs_buff[6] = rd32(IGC_EICS);
173 	regs_buff[7] = rd32(IGC_EICS);
174 	regs_buff[8] = rd32(IGC_EIMS);
175 	regs_buff[9] = rd32(IGC_EIMC);
176 	regs_buff[10] = rd32(IGC_EIAC);
177 	regs_buff[11] = rd32(IGC_EIAM);
178 	/* Reading ICS for ICR because they read the
179 	 * same but ICS does not clear on read
180 	 */
181 	regs_buff[12] = rd32(IGC_ICS);
182 	regs_buff[13] = rd32(IGC_ICS);
183 	regs_buff[14] = rd32(IGC_IMS);
184 	regs_buff[15] = rd32(IGC_IMC);
185 	regs_buff[16] = rd32(IGC_IAC);
186 	regs_buff[17] = rd32(IGC_IAM);
187 
188 	/* Flow Control */
189 	regs_buff[18] = rd32(IGC_FCAL);
190 	regs_buff[19] = rd32(IGC_FCAH);
191 	regs_buff[20] = rd32(IGC_FCTTV);
192 	regs_buff[21] = rd32(IGC_FCRTL);
193 	regs_buff[22] = rd32(IGC_FCRTH);
194 	regs_buff[23] = rd32(IGC_FCRTV);
195 
196 	/* Receive */
197 	regs_buff[24] = rd32(IGC_RCTL);
198 	regs_buff[25] = rd32(IGC_RXCSUM);
199 	regs_buff[26] = rd32(IGC_RLPML);
200 	regs_buff[27] = rd32(IGC_RFCTL);
201 
202 	/* Transmit */
203 	regs_buff[28] = rd32(IGC_TCTL);
204 	regs_buff[29] = rd32(IGC_TIPG);
205 
206 	/* Wake Up */
207 
208 	/* MAC */
209 
210 	/* Statistics */
211 	regs_buff[30] = adapter->stats.crcerrs;
212 	regs_buff[31] = adapter->stats.algnerrc;
213 	regs_buff[32] = adapter->stats.symerrs;
214 	regs_buff[33] = adapter->stats.rxerrc;
215 	regs_buff[34] = adapter->stats.mpc;
216 	regs_buff[35] = adapter->stats.scc;
217 	regs_buff[36] = adapter->stats.ecol;
218 	regs_buff[37] = adapter->stats.mcc;
219 	regs_buff[38] = adapter->stats.latecol;
220 	regs_buff[39] = adapter->stats.colc;
221 	regs_buff[40] = adapter->stats.dc;
222 	regs_buff[41] = adapter->stats.tncrs;
223 	regs_buff[42] = adapter->stats.sec;
224 	regs_buff[43] = adapter->stats.htdpmc;
225 	regs_buff[44] = adapter->stats.rlec;
226 	regs_buff[45] = adapter->stats.xonrxc;
227 	regs_buff[46] = adapter->stats.xontxc;
228 	regs_buff[47] = adapter->stats.xoffrxc;
229 	regs_buff[48] = adapter->stats.xofftxc;
230 	regs_buff[49] = adapter->stats.fcruc;
231 	regs_buff[50] = adapter->stats.prc64;
232 	regs_buff[51] = adapter->stats.prc127;
233 	regs_buff[52] = adapter->stats.prc255;
234 	regs_buff[53] = adapter->stats.prc511;
235 	regs_buff[54] = adapter->stats.prc1023;
236 	regs_buff[55] = adapter->stats.prc1522;
237 	regs_buff[56] = adapter->stats.gprc;
238 	regs_buff[57] = adapter->stats.bprc;
239 	regs_buff[58] = adapter->stats.mprc;
240 	regs_buff[59] = adapter->stats.gptc;
241 	regs_buff[60] = adapter->stats.gorc;
242 	regs_buff[61] = adapter->stats.gotc;
243 	regs_buff[62] = adapter->stats.rnbc;
244 	regs_buff[63] = adapter->stats.ruc;
245 	regs_buff[64] = adapter->stats.rfc;
246 	regs_buff[65] = adapter->stats.roc;
247 	regs_buff[66] = adapter->stats.rjc;
248 	regs_buff[67] = adapter->stats.mgprc;
249 	regs_buff[68] = adapter->stats.mgpdc;
250 	regs_buff[69] = adapter->stats.mgptc;
251 	regs_buff[70] = adapter->stats.tor;
252 	regs_buff[71] = adapter->stats.tot;
253 	regs_buff[72] = adapter->stats.tpr;
254 	regs_buff[73] = adapter->stats.tpt;
255 	regs_buff[74] = adapter->stats.ptc64;
256 	regs_buff[75] = adapter->stats.ptc127;
257 	regs_buff[76] = adapter->stats.ptc255;
258 	regs_buff[77] = adapter->stats.ptc511;
259 	regs_buff[78] = adapter->stats.ptc1023;
260 	regs_buff[79] = adapter->stats.ptc1522;
261 	regs_buff[80] = adapter->stats.mptc;
262 	regs_buff[81] = adapter->stats.bptc;
263 	regs_buff[82] = adapter->stats.tsctc;
264 	regs_buff[83] = adapter->stats.iac;
265 	regs_buff[84] = adapter->stats.rpthc;
266 	regs_buff[85] = adapter->stats.hgptc;
267 	regs_buff[86] = adapter->stats.hgorc;
268 	regs_buff[87] = adapter->stats.hgotc;
269 	regs_buff[88] = adapter->stats.lenerrs;
270 	regs_buff[89] = adapter->stats.scvpc;
271 	regs_buff[90] = adapter->stats.hrmpc;
272 
273 	for (i = 0; i < 4; i++)
274 		regs_buff[91 + i] = rd32(IGC_SRRCTL(i));
275 	for (i = 0; i < 4; i++)
276 		regs_buff[95 + i] = rd32(IGC_PSRTYPE(i));
277 	for (i = 0; i < 4; i++)
278 		regs_buff[99 + i] = rd32(IGC_RDBAL(i));
279 	for (i = 0; i < 4; i++)
280 		regs_buff[103 + i] = rd32(IGC_RDBAH(i));
281 	for (i = 0; i < 4; i++)
282 		regs_buff[107 + i] = rd32(IGC_RDLEN(i));
283 	for (i = 0; i < 4; i++)
284 		regs_buff[111 + i] = rd32(IGC_RDH(i));
285 	for (i = 0; i < 4; i++)
286 		regs_buff[115 + i] = rd32(IGC_RDT(i));
287 	for (i = 0; i < 4; i++)
288 		regs_buff[119 + i] = rd32(IGC_RXDCTL(i));
289 
290 	for (i = 0; i < 10; i++)
291 		regs_buff[123 + i] = rd32(IGC_EITR(i));
292 	for (i = 0; i < 16; i++)
293 		regs_buff[139 + i] = rd32(IGC_RAL(i));
294 	for (i = 0; i < 16; i++)
295 		regs_buff[145 + i] = rd32(IGC_RAH(i));
296 
297 	for (i = 0; i < 4; i++)
298 		regs_buff[149 + i] = rd32(IGC_TDBAL(i));
299 	for (i = 0; i < 4; i++)
300 		regs_buff[152 + i] = rd32(IGC_TDBAH(i));
301 	for (i = 0; i < 4; i++)
302 		regs_buff[156 + i] = rd32(IGC_TDLEN(i));
303 	for (i = 0; i < 4; i++)
304 		regs_buff[160 + i] = rd32(IGC_TDH(i));
305 	for (i = 0; i < 4; i++)
306 		regs_buff[164 + i] = rd32(IGC_TDT(i));
307 	for (i = 0; i < 4; i++)
308 		regs_buff[168 + i] = rd32(IGC_TXDCTL(i));
309 }
310 
311 static u32 igc_get_msglevel(struct net_device *netdev)
312 {
313 	struct igc_adapter *adapter = netdev_priv(netdev);
314 
315 	return adapter->msg_enable;
316 }
317 
318 static void igc_set_msglevel(struct net_device *netdev, u32 data)
319 {
320 	struct igc_adapter *adapter = netdev_priv(netdev);
321 
322 	adapter->msg_enable = data;
323 }
324 
325 static int igc_nway_reset(struct net_device *netdev)
326 {
327 	struct igc_adapter *adapter = netdev_priv(netdev);
328 
329 	if (netif_running(netdev))
330 		igc_reinit_locked(adapter);
331 	return 0;
332 }
333 
334 static u32 igc_get_link(struct net_device *netdev)
335 {
336 	struct igc_adapter *adapter = netdev_priv(netdev);
337 	struct igc_mac_info *mac = &adapter->hw.mac;
338 
339 	/* If the link is not reported up to netdev, interrupts are disabled,
340 	 * and so the physical link state may have changed since we last
341 	 * looked. Set get_link_status to make sure that the true link
342 	 * state is interrogated, rather than pulling a cached and possibly
343 	 * stale link state from the driver.
344 	 */
345 	if (!netif_carrier_ok(netdev))
346 		mac->get_link_status = 1;
347 
348 	return igc_has_link(adapter);
349 }
350 
351 static int igc_get_eeprom_len(struct net_device *netdev)
352 {
353 	struct igc_adapter *adapter = netdev_priv(netdev);
354 
355 	return adapter->hw.nvm.word_size * 2;
356 }
357 
358 static int igc_get_eeprom(struct net_device *netdev,
359 			  struct ethtool_eeprom *eeprom, u8 *bytes)
360 {
361 	struct igc_adapter *adapter = netdev_priv(netdev);
362 	struct igc_hw *hw = &adapter->hw;
363 	int first_word, last_word;
364 	u16 *eeprom_buff;
365 	int ret_val = 0;
366 	u16 i;
367 
368 	if (eeprom->len == 0)
369 		return -EINVAL;
370 
371 	eeprom->magic = hw->vendor_id | (hw->device_id << 16);
372 
373 	first_word = eeprom->offset >> 1;
374 	last_word = (eeprom->offset + eeprom->len - 1) >> 1;
375 
376 	eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16),
377 				    GFP_KERNEL);
378 	if (!eeprom_buff)
379 		return -ENOMEM;
380 
381 	if (hw->nvm.type == igc_nvm_eeprom_spi) {
382 		ret_val = hw->nvm.ops.read(hw, first_word,
383 					   last_word - first_word + 1,
384 					   eeprom_buff);
385 	} else {
386 		for (i = 0; i < last_word - first_word + 1; i++) {
387 			ret_val = hw->nvm.ops.read(hw, first_word + i, 1,
388 						   &eeprom_buff[i]);
389 			if (ret_val)
390 				break;
391 		}
392 	}
393 
394 	/* Device's eeprom is always little-endian, word addressable */
395 	for (i = 0; i < last_word - first_word + 1; i++)
396 		le16_to_cpus(&eeprom_buff[i]);
397 
398 	memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1),
399 	       eeprom->len);
400 	kfree(eeprom_buff);
401 
402 	return ret_val;
403 }
404 
405 static int igc_set_eeprom(struct net_device *netdev,
406 			  struct ethtool_eeprom *eeprom, u8 *bytes)
407 {
408 	struct igc_adapter *adapter = netdev_priv(netdev);
409 	struct igc_hw *hw = &adapter->hw;
410 	int max_len, first_word, last_word, ret_val = 0;
411 	u16 *eeprom_buff;
412 	void *ptr;
413 	u16 i;
414 
415 	if (eeprom->len == 0)
416 		return -EOPNOTSUPP;
417 
418 	if (hw->mac.type >= igc_i225 &&
419 	    !igc_get_flash_presence_i225(hw)) {
420 		return -EOPNOTSUPP;
421 	}
422 
423 	if (eeprom->magic != (hw->vendor_id | (hw->device_id << 16)))
424 		return -EFAULT;
425 
426 	max_len = hw->nvm.word_size * 2;
427 
428 	first_word = eeprom->offset >> 1;
429 	last_word = (eeprom->offset + eeprom->len - 1) >> 1;
430 	eeprom_buff = kmalloc(max_len, GFP_KERNEL);
431 	if (!eeprom_buff)
432 		return -ENOMEM;
433 
434 	ptr = (void *)eeprom_buff;
435 
436 	if (eeprom->offset & 1) {
437 		/* need read/modify/write of first changed EEPROM word
438 		 * only the second byte of the word is being modified
439 		 */
440 		ret_val = hw->nvm.ops.read(hw, first_word, 1,
441 					    &eeprom_buff[0]);
442 		ptr++;
443 	}
444 	if (((eeprom->offset + eeprom->len) & 1) && ret_val == 0) {
445 		/* need read/modify/write of last changed EEPROM word
446 		 * only the first byte of the word is being modified
447 		 */
448 		ret_val = hw->nvm.ops.read(hw, last_word, 1,
449 				   &eeprom_buff[last_word - first_word]);
450 	}
451 
452 	/* Device's eeprom is always little-endian, word addressable */
453 	for (i = 0; i < last_word - first_word + 1; i++)
454 		le16_to_cpus(&eeprom_buff[i]);
455 
456 	memcpy(ptr, bytes, eeprom->len);
457 
458 	for (i = 0; i < last_word - first_word + 1; i++)
459 		eeprom_buff[i] = cpu_to_le16(eeprom_buff[i]);
460 
461 	ret_val = hw->nvm.ops.write(hw, first_word,
462 				    last_word - first_word + 1, eeprom_buff);
463 
464 	/* Update the checksum if nvm write succeeded */
465 	if (ret_val == 0)
466 		hw->nvm.ops.update(hw);
467 
468 	/* check if need: igc_set_fw_version(adapter); */
469 	kfree(eeprom_buff);
470 	return ret_val;
471 }
472 
473 static void igc_get_ringparam(struct net_device *netdev,
474 			      struct ethtool_ringparam *ring)
475 {
476 	struct igc_adapter *adapter = netdev_priv(netdev);
477 
478 	ring->rx_max_pending = IGC_MAX_RXD;
479 	ring->tx_max_pending = IGC_MAX_TXD;
480 	ring->rx_pending = adapter->rx_ring_count;
481 	ring->tx_pending = adapter->tx_ring_count;
482 }
483 
484 static int igc_set_ringparam(struct net_device *netdev,
485 			     struct ethtool_ringparam *ring)
486 {
487 	struct igc_adapter *adapter = netdev_priv(netdev);
488 	struct igc_ring *temp_ring;
489 	u16 new_rx_count, new_tx_count;
490 	int i, err = 0;
491 
492 	if (ring->rx_mini_pending || ring->rx_jumbo_pending)
493 		return -EINVAL;
494 
495 	new_rx_count = min_t(u32, ring->rx_pending, IGC_MAX_RXD);
496 	new_rx_count = max_t(u16, new_rx_count, IGC_MIN_RXD);
497 	new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);
498 
499 	new_tx_count = min_t(u32, ring->tx_pending, IGC_MAX_TXD);
500 	new_tx_count = max_t(u16, new_tx_count, IGC_MIN_TXD);
501 	new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE);
502 
503 	if (new_tx_count == adapter->tx_ring_count &&
504 	    new_rx_count == adapter->rx_ring_count) {
505 		/* nothing to do */
506 		return 0;
507 	}
508 
509 	while (test_and_set_bit(__IGC_RESETTING, &adapter->state))
510 		usleep_range(1000, 2000);
511 
512 	if (!netif_running(adapter->netdev)) {
513 		for (i = 0; i < adapter->num_tx_queues; i++)
514 			adapter->tx_ring[i]->count = new_tx_count;
515 		for (i = 0; i < adapter->num_rx_queues; i++)
516 			adapter->rx_ring[i]->count = new_rx_count;
517 		adapter->tx_ring_count = new_tx_count;
518 		adapter->rx_ring_count = new_rx_count;
519 		goto clear_reset;
520 	}
521 
522 	if (adapter->num_tx_queues > adapter->num_rx_queues)
523 		temp_ring = vmalloc(array_size(sizeof(struct igc_ring),
524 					       adapter->num_tx_queues));
525 	else
526 		temp_ring = vmalloc(array_size(sizeof(struct igc_ring),
527 					       adapter->num_rx_queues));
528 
529 	if (!temp_ring) {
530 		err = -ENOMEM;
531 		goto clear_reset;
532 	}
533 
534 	igc_down(adapter);
535 
536 	/* We can't just free everything and then setup again,
537 	 * because the ISRs in MSI-X mode get passed pointers
538 	 * to the Tx and Rx ring structs.
539 	 */
540 	if (new_tx_count != adapter->tx_ring_count) {
541 		for (i = 0; i < adapter->num_tx_queues; i++) {
542 			memcpy(&temp_ring[i], adapter->tx_ring[i],
543 			       sizeof(struct igc_ring));
544 
545 			temp_ring[i].count = new_tx_count;
546 			err = igc_setup_tx_resources(&temp_ring[i]);
547 			if (err) {
548 				while (i) {
549 					i--;
550 					igc_free_tx_resources(&temp_ring[i]);
551 				}
552 				goto err_setup;
553 			}
554 		}
555 
556 		for (i = 0; i < adapter->num_tx_queues; i++) {
557 			igc_free_tx_resources(adapter->tx_ring[i]);
558 
559 			memcpy(adapter->tx_ring[i], &temp_ring[i],
560 			       sizeof(struct igc_ring));
561 		}
562 
563 		adapter->tx_ring_count = new_tx_count;
564 	}
565 
566 	if (new_rx_count != adapter->rx_ring_count) {
567 		for (i = 0; i < adapter->num_rx_queues; i++) {
568 			memcpy(&temp_ring[i], adapter->rx_ring[i],
569 			       sizeof(struct igc_ring));
570 
571 			temp_ring[i].count = new_rx_count;
572 			err = igc_setup_rx_resources(&temp_ring[i]);
573 			if (err) {
574 				while (i) {
575 					i--;
576 					igc_free_rx_resources(&temp_ring[i]);
577 				}
578 				goto err_setup;
579 			}
580 		}
581 
582 		for (i = 0; i < adapter->num_rx_queues; i++) {
583 			igc_free_rx_resources(adapter->rx_ring[i]);
584 
585 			memcpy(adapter->rx_ring[i], &temp_ring[i],
586 			       sizeof(struct igc_ring));
587 		}
588 
589 		adapter->rx_ring_count = new_rx_count;
590 	}
591 err_setup:
592 	igc_up(adapter);
593 	vfree(temp_ring);
594 clear_reset:
595 	clear_bit(__IGC_RESETTING, &adapter->state);
596 	return err;
597 }
598 
599 static void igc_get_pauseparam(struct net_device *netdev,
600 			       struct ethtool_pauseparam *pause)
601 {
602 	struct igc_adapter *adapter = netdev_priv(netdev);
603 	struct igc_hw *hw = &adapter->hw;
604 
605 	pause->autoneg =
606 		(adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);
607 
608 	if (hw->fc.current_mode == igc_fc_rx_pause) {
609 		pause->rx_pause = 1;
610 	} else if (hw->fc.current_mode == igc_fc_tx_pause) {
611 		pause->tx_pause = 1;
612 	} else if (hw->fc.current_mode == igc_fc_full) {
613 		pause->rx_pause = 1;
614 		pause->tx_pause = 1;
615 	}
616 }
617 
618 static int igc_set_pauseparam(struct net_device *netdev,
619 			      struct ethtool_pauseparam *pause)
620 {
621 	struct igc_adapter *adapter = netdev_priv(netdev);
622 	struct igc_hw *hw = &adapter->hw;
623 	int retval = 0;
624 
625 	adapter->fc_autoneg = pause->autoneg;
626 
627 	while (test_and_set_bit(__IGC_RESETTING, &adapter->state))
628 		usleep_range(1000, 2000);
629 
630 	if (adapter->fc_autoneg == AUTONEG_ENABLE) {
631 		hw->fc.requested_mode = igc_fc_default;
632 		if (netif_running(adapter->netdev)) {
633 			igc_down(adapter);
634 			igc_up(adapter);
635 		} else {
636 			igc_reset(adapter);
637 		}
638 	} else {
639 		if (pause->rx_pause && pause->tx_pause)
640 			hw->fc.requested_mode = igc_fc_full;
641 		else if (pause->rx_pause && !pause->tx_pause)
642 			hw->fc.requested_mode = igc_fc_rx_pause;
643 		else if (!pause->rx_pause && pause->tx_pause)
644 			hw->fc.requested_mode = igc_fc_tx_pause;
645 		else if (!pause->rx_pause && !pause->tx_pause)
646 			hw->fc.requested_mode = igc_fc_none;
647 
648 		hw->fc.current_mode = hw->fc.requested_mode;
649 
650 		retval = ((hw->phy.media_type == igc_media_type_copper) ?
651 			  igc_force_mac_fc(hw) : igc_setup_link(hw));
652 	}
653 
654 	clear_bit(__IGC_RESETTING, &adapter->state);
655 	return retval;
656 }
657 
658 static void igc_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
659 {
660 	struct igc_adapter *adapter = netdev_priv(netdev);
661 	u8 *p = data;
662 	int i;
663 
664 	switch (stringset) {
665 	case ETH_SS_TEST:
666 		memcpy(data, *igc_gstrings_test,
667 		       IGC_TEST_LEN * ETH_GSTRING_LEN);
668 		break;
669 	case ETH_SS_STATS:
670 		for (i = 0; i < IGC_GLOBAL_STATS_LEN; i++) {
671 			memcpy(p, igc_gstrings_stats[i].stat_string,
672 			       ETH_GSTRING_LEN);
673 			p += ETH_GSTRING_LEN;
674 		}
675 		for (i = 0; i < IGC_NETDEV_STATS_LEN; i++) {
676 			memcpy(p, igc_gstrings_net_stats[i].stat_string,
677 			       ETH_GSTRING_LEN);
678 			p += ETH_GSTRING_LEN;
679 		}
680 		for (i = 0; i < adapter->num_tx_queues; i++) {
681 			sprintf(p, "tx_queue_%u_packets", i);
682 			p += ETH_GSTRING_LEN;
683 			sprintf(p, "tx_queue_%u_bytes", i);
684 			p += ETH_GSTRING_LEN;
685 			sprintf(p, "tx_queue_%u_restart", i);
686 			p += ETH_GSTRING_LEN;
687 		}
688 		for (i = 0; i < adapter->num_rx_queues; i++) {
689 			sprintf(p, "rx_queue_%u_packets", i);
690 			p += ETH_GSTRING_LEN;
691 			sprintf(p, "rx_queue_%u_bytes", i);
692 			p += ETH_GSTRING_LEN;
693 			sprintf(p, "rx_queue_%u_drops", i);
694 			p += ETH_GSTRING_LEN;
695 			sprintf(p, "rx_queue_%u_csum_err", i);
696 			p += ETH_GSTRING_LEN;
697 			sprintf(p, "rx_queue_%u_alloc_failed", i);
698 			p += ETH_GSTRING_LEN;
699 		}
700 		/* BUG_ON(p - data != IGC_STATS_LEN * ETH_GSTRING_LEN); */
701 		break;
702 	case ETH_SS_PRIV_FLAGS:
703 		memcpy(data, igc_priv_flags_strings,
704 		       IGC_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN);
705 		break;
706 	}
707 }
708 
709 static int igc_get_sset_count(struct net_device *netdev, int sset)
710 {
711 	switch (sset) {
712 	case ETH_SS_STATS:
713 		return IGC_STATS_LEN;
714 	case ETH_SS_TEST:
715 		return IGC_TEST_LEN;
716 	case ETH_SS_PRIV_FLAGS:
717 		return IGC_PRIV_FLAGS_STR_LEN;
718 	default:
719 		return -ENOTSUPP;
720 	}
721 }
722 
723 static void igc_get_ethtool_stats(struct net_device *netdev,
724 				  struct ethtool_stats *stats, u64 *data)
725 {
726 	struct igc_adapter *adapter = netdev_priv(netdev);
727 	struct rtnl_link_stats64 *net_stats = &adapter->stats64;
728 	unsigned int start;
729 	struct igc_ring *ring;
730 	int i, j;
731 	char *p;
732 
733 	spin_lock(&adapter->stats64_lock);
734 	igc_update_stats(adapter);
735 
736 	for (i = 0; i < IGC_GLOBAL_STATS_LEN; i++) {
737 		p = (char *)adapter + igc_gstrings_stats[i].stat_offset;
738 		data[i] = (igc_gstrings_stats[i].sizeof_stat ==
739 			sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
740 	}
741 	for (j = 0; j < IGC_NETDEV_STATS_LEN; j++, i++) {
742 		p = (char *)net_stats + igc_gstrings_net_stats[j].stat_offset;
743 		data[i] = (igc_gstrings_net_stats[j].sizeof_stat ==
744 			sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
745 	}
746 	for (j = 0; j < adapter->num_tx_queues; j++) {
747 		u64	restart2;
748 
749 		ring = adapter->tx_ring[j];
750 		do {
751 			start = u64_stats_fetch_begin_irq(&ring->tx_syncp);
752 			data[i]   = ring->tx_stats.packets;
753 			data[i + 1] = ring->tx_stats.bytes;
754 			data[i + 2] = ring->tx_stats.restart_queue;
755 		} while (u64_stats_fetch_retry_irq(&ring->tx_syncp, start));
756 		do {
757 			start = u64_stats_fetch_begin_irq(&ring->tx_syncp2);
758 			restart2  = ring->tx_stats.restart_queue2;
759 		} while (u64_stats_fetch_retry_irq(&ring->tx_syncp2, start));
760 		data[i + 2] += restart2;
761 
762 		i += IGC_TX_QUEUE_STATS_LEN;
763 	}
764 	for (j = 0; j < adapter->num_rx_queues; j++) {
765 		ring = adapter->rx_ring[j];
766 		do {
767 			start = u64_stats_fetch_begin_irq(&ring->rx_syncp);
768 			data[i]   = ring->rx_stats.packets;
769 			data[i + 1] = ring->rx_stats.bytes;
770 			data[i + 2] = ring->rx_stats.drops;
771 			data[i + 3] = ring->rx_stats.csum_err;
772 			data[i + 4] = ring->rx_stats.alloc_failed;
773 		} while (u64_stats_fetch_retry_irq(&ring->rx_syncp, start));
774 		i += IGC_RX_QUEUE_STATS_LEN;
775 	}
776 	spin_unlock(&adapter->stats64_lock);
777 }
778 
779 static int igc_get_coalesce(struct net_device *netdev,
780 			    struct ethtool_coalesce *ec)
781 {
782 	struct igc_adapter *adapter = netdev_priv(netdev);
783 
784 	if (adapter->rx_itr_setting <= 3)
785 		ec->rx_coalesce_usecs = adapter->rx_itr_setting;
786 	else
787 		ec->rx_coalesce_usecs = adapter->rx_itr_setting >> 2;
788 
789 	if (!(adapter->flags & IGC_FLAG_QUEUE_PAIRS)) {
790 		if (adapter->tx_itr_setting <= 3)
791 			ec->tx_coalesce_usecs = adapter->tx_itr_setting;
792 		else
793 			ec->tx_coalesce_usecs = adapter->tx_itr_setting >> 2;
794 	}
795 
796 	return 0;
797 }
798 
799 static int igc_set_coalesce(struct net_device *netdev,
800 			    struct ethtool_coalesce *ec)
801 {
802 	struct igc_adapter *adapter = netdev_priv(netdev);
803 	int i;
804 
805 	if (ec->rx_max_coalesced_frames ||
806 	    ec->rx_coalesce_usecs_irq ||
807 	    ec->rx_max_coalesced_frames_irq ||
808 	    ec->tx_max_coalesced_frames ||
809 	    ec->tx_coalesce_usecs_irq ||
810 	    ec->stats_block_coalesce_usecs ||
811 	    ec->use_adaptive_rx_coalesce ||
812 	    ec->use_adaptive_tx_coalesce ||
813 	    ec->pkt_rate_low ||
814 	    ec->rx_coalesce_usecs_low ||
815 	    ec->rx_max_coalesced_frames_low ||
816 	    ec->tx_coalesce_usecs_low ||
817 	    ec->tx_max_coalesced_frames_low ||
818 	    ec->pkt_rate_high ||
819 	    ec->rx_coalesce_usecs_high ||
820 	    ec->rx_max_coalesced_frames_high ||
821 	    ec->tx_coalesce_usecs_high ||
822 	    ec->tx_max_coalesced_frames_high ||
823 	    ec->rate_sample_interval)
824 		return -ENOTSUPP;
825 
826 	if (ec->rx_coalesce_usecs > IGC_MAX_ITR_USECS ||
827 	    (ec->rx_coalesce_usecs > 3 &&
828 	     ec->rx_coalesce_usecs < IGC_MIN_ITR_USECS) ||
829 	    ec->rx_coalesce_usecs == 2)
830 		return -EINVAL;
831 
832 	if (ec->tx_coalesce_usecs > IGC_MAX_ITR_USECS ||
833 	    (ec->tx_coalesce_usecs > 3 &&
834 	     ec->tx_coalesce_usecs < IGC_MIN_ITR_USECS) ||
835 	    ec->tx_coalesce_usecs == 2)
836 		return -EINVAL;
837 
838 	if ((adapter->flags & IGC_FLAG_QUEUE_PAIRS) && ec->tx_coalesce_usecs)
839 		return -EINVAL;
840 
841 	/* If ITR is disabled, disable DMAC */
842 	if (ec->rx_coalesce_usecs == 0) {
843 		if (adapter->flags & IGC_FLAG_DMAC)
844 			adapter->flags &= ~IGC_FLAG_DMAC;
845 	}
846 
847 	/* convert to rate of irq's per second */
848 	if (ec->rx_coalesce_usecs && ec->rx_coalesce_usecs <= 3)
849 		adapter->rx_itr_setting = ec->rx_coalesce_usecs;
850 	else
851 		adapter->rx_itr_setting = ec->rx_coalesce_usecs << 2;
852 
853 	/* convert to rate of irq's per second */
854 	if (adapter->flags & IGC_FLAG_QUEUE_PAIRS)
855 		adapter->tx_itr_setting = adapter->rx_itr_setting;
856 	else if (ec->tx_coalesce_usecs && ec->tx_coalesce_usecs <= 3)
857 		adapter->tx_itr_setting = ec->tx_coalesce_usecs;
858 	else
859 		adapter->tx_itr_setting = ec->tx_coalesce_usecs << 2;
860 
861 	for (i = 0; i < adapter->num_q_vectors; i++) {
862 		struct igc_q_vector *q_vector = adapter->q_vector[i];
863 
864 		q_vector->tx.work_limit = adapter->tx_work_limit;
865 		if (q_vector->rx.ring)
866 			q_vector->itr_val = adapter->rx_itr_setting;
867 		else
868 			q_vector->itr_val = adapter->tx_itr_setting;
869 		if (q_vector->itr_val && q_vector->itr_val <= 3)
870 			q_vector->itr_val = IGC_START_ITR;
871 		q_vector->set_itr = 1;
872 	}
873 
874 	return 0;
875 }
876 
877 #define ETHER_TYPE_FULL_MASK ((__force __be16)~0)
878 static int igc_get_ethtool_nfc_entry(struct igc_adapter *adapter,
879 				     struct ethtool_rxnfc *cmd)
880 {
881 	struct ethtool_rx_flow_spec *fsp = &cmd->fs;
882 	struct igc_nfc_filter *rule = NULL;
883 
884 	/* report total rule count */
885 	cmd->data = IGC_MAX_RXNFC_FILTERS;
886 
887 	hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) {
888 		if (fsp->location <= rule->sw_idx)
889 			break;
890 	}
891 
892 	if (!rule || fsp->location != rule->sw_idx)
893 		return -EINVAL;
894 
895 	if (rule->filter.match_flags) {
896 		fsp->flow_type = ETHER_FLOW;
897 		fsp->ring_cookie = rule->action;
898 		if (rule->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) {
899 			fsp->h_u.ether_spec.h_proto = rule->filter.etype;
900 			fsp->m_u.ether_spec.h_proto = ETHER_TYPE_FULL_MASK;
901 		}
902 		if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) {
903 			fsp->flow_type |= FLOW_EXT;
904 			fsp->h_ext.vlan_tci = rule->filter.vlan_tci;
905 			fsp->m_ext.vlan_tci = htons(VLAN_PRIO_MASK);
906 		}
907 		if (rule->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) {
908 			ether_addr_copy(fsp->h_u.ether_spec.h_dest,
909 					rule->filter.dst_addr);
910 			/* As we only support matching by the full
911 			 * mask, return the mask to userspace
912 			 */
913 			eth_broadcast_addr(fsp->m_u.ether_spec.h_dest);
914 		}
915 		if (rule->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) {
916 			ether_addr_copy(fsp->h_u.ether_spec.h_source,
917 					rule->filter.src_addr);
918 			/* As we only support matching by the full
919 			 * mask, return the mask to userspace
920 			 */
921 			eth_broadcast_addr(fsp->m_u.ether_spec.h_source);
922 		}
923 
924 		return 0;
925 	}
926 	return -EINVAL;
927 }
928 
929 static int igc_get_ethtool_nfc_all(struct igc_adapter *adapter,
930 				   struct ethtool_rxnfc *cmd,
931 				   u32 *rule_locs)
932 {
933 	struct igc_nfc_filter *rule;
934 	int cnt = 0;
935 
936 	/* report total rule count */
937 	cmd->data = IGC_MAX_RXNFC_FILTERS;
938 
939 	hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) {
940 		if (cnt == cmd->rule_cnt)
941 			return -EMSGSIZE;
942 		rule_locs[cnt] = rule->sw_idx;
943 		cnt++;
944 	}
945 
946 	cmd->rule_cnt = cnt;
947 
948 	return 0;
949 }
950 
951 static int igc_get_rss_hash_opts(struct igc_adapter *adapter,
952 				 struct ethtool_rxnfc *cmd)
953 {
954 	cmd->data = 0;
955 
956 	/* Report default options for RSS on igc */
957 	switch (cmd->flow_type) {
958 	case TCP_V4_FLOW:
959 		cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
960 		/* Fall through */
961 	case UDP_V4_FLOW:
962 		if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV4_UDP)
963 			cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
964 		/* Fall through */
965 	case SCTP_V4_FLOW:
966 		/* Fall through */
967 	case AH_ESP_V4_FLOW:
968 		/* Fall through */
969 	case AH_V4_FLOW:
970 		/* Fall through */
971 	case ESP_V4_FLOW:
972 		/* Fall through */
973 	case IPV4_FLOW:
974 		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
975 		break;
976 	case TCP_V6_FLOW:
977 		cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
978 		/* Fall through */
979 	case UDP_V6_FLOW:
980 		if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV6_UDP)
981 			cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
982 		/* Fall through */
983 	case SCTP_V6_FLOW:
984 		/* Fall through */
985 	case AH_ESP_V6_FLOW:
986 		/* Fall through */
987 	case AH_V6_FLOW:
988 		/* Fall through */
989 	case ESP_V6_FLOW:
990 		/* Fall through */
991 	case IPV6_FLOW:
992 		cmd->data |= RXH_IP_SRC | RXH_IP_DST;
993 		break;
994 	default:
995 		return -EINVAL;
996 	}
997 
998 	return 0;
999 }
1000 
1001 static int igc_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
1002 			 u32 *rule_locs)
1003 {
1004 	struct igc_adapter *adapter = netdev_priv(dev);
1005 	int ret = -EOPNOTSUPP;
1006 
1007 	switch (cmd->cmd) {
1008 	case ETHTOOL_GRXRINGS:
1009 		cmd->data = adapter->num_rx_queues;
1010 		ret = 0;
1011 		break;
1012 	case ETHTOOL_GRXCLSRLCNT:
1013 		cmd->rule_cnt = adapter->nfc_filter_count;
1014 		ret = 0;
1015 		break;
1016 	case ETHTOOL_GRXCLSRULE:
1017 		ret = igc_get_ethtool_nfc_entry(adapter, cmd);
1018 		break;
1019 	case ETHTOOL_GRXCLSRLALL:
1020 		ret = igc_get_ethtool_nfc_all(adapter, cmd, rule_locs);
1021 		break;
1022 	case ETHTOOL_GRXFH:
1023 		ret = igc_get_rss_hash_opts(adapter, cmd);
1024 		break;
1025 	default:
1026 		break;
1027 	}
1028 
1029 	return ret;
1030 }
1031 
1032 #define UDP_RSS_FLAGS (IGC_FLAG_RSS_FIELD_IPV4_UDP | \
1033 		       IGC_FLAG_RSS_FIELD_IPV6_UDP)
1034 static int igc_set_rss_hash_opt(struct igc_adapter *adapter,
1035 				struct ethtool_rxnfc *nfc)
1036 {
1037 	u32 flags = adapter->flags;
1038 
1039 	/* RSS does not support anything other than hashing
1040 	 * to queues on src and dst IPs and ports
1041 	 */
1042 	if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |
1043 			  RXH_L4_B_0_1 | RXH_L4_B_2_3))
1044 		return -EINVAL;
1045 
1046 	switch (nfc->flow_type) {
1047 	case TCP_V4_FLOW:
1048 	case TCP_V6_FLOW:
1049 		if (!(nfc->data & RXH_IP_SRC) ||
1050 		    !(nfc->data & RXH_IP_DST) ||
1051 		    !(nfc->data & RXH_L4_B_0_1) ||
1052 		    !(nfc->data & RXH_L4_B_2_3))
1053 			return -EINVAL;
1054 		break;
1055 	case UDP_V4_FLOW:
1056 		if (!(nfc->data & RXH_IP_SRC) ||
1057 		    !(nfc->data & RXH_IP_DST))
1058 			return -EINVAL;
1059 		switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1060 		case 0:
1061 			flags &= ~IGC_FLAG_RSS_FIELD_IPV4_UDP;
1062 			break;
1063 		case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
1064 			flags |= IGC_FLAG_RSS_FIELD_IPV4_UDP;
1065 			break;
1066 		default:
1067 			return -EINVAL;
1068 		}
1069 		break;
1070 	case UDP_V6_FLOW:
1071 		if (!(nfc->data & RXH_IP_SRC) ||
1072 		    !(nfc->data & RXH_IP_DST))
1073 			return -EINVAL;
1074 		switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1075 		case 0:
1076 			flags &= ~IGC_FLAG_RSS_FIELD_IPV6_UDP;
1077 			break;
1078 		case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
1079 			flags |= IGC_FLAG_RSS_FIELD_IPV6_UDP;
1080 			break;
1081 		default:
1082 			return -EINVAL;
1083 		}
1084 		break;
1085 	case AH_ESP_V4_FLOW:
1086 	case AH_V4_FLOW:
1087 	case ESP_V4_FLOW:
1088 	case SCTP_V4_FLOW:
1089 	case AH_ESP_V6_FLOW:
1090 	case AH_V6_FLOW:
1091 	case ESP_V6_FLOW:
1092 	case SCTP_V6_FLOW:
1093 		if (!(nfc->data & RXH_IP_SRC) ||
1094 		    !(nfc->data & RXH_IP_DST) ||
1095 		    (nfc->data & RXH_L4_B_0_1) ||
1096 		    (nfc->data & RXH_L4_B_2_3))
1097 			return -EINVAL;
1098 		break;
1099 	default:
1100 		return -EINVAL;
1101 	}
1102 
1103 	/* if we changed something we need to update flags */
1104 	if (flags != adapter->flags) {
1105 		struct igc_hw *hw = &adapter->hw;
1106 		u32 mrqc = rd32(IGC_MRQC);
1107 
1108 		if ((flags & UDP_RSS_FLAGS) &&
1109 		    !(adapter->flags & UDP_RSS_FLAGS))
1110 			dev_err(&adapter->pdev->dev,
1111 				"enabling UDP RSS: fragmented packets may arrive out of order to the stack above\n");
1112 
1113 		adapter->flags = flags;
1114 
1115 		/* Perform hash on these packet types */
1116 		mrqc |= IGC_MRQC_RSS_FIELD_IPV4 |
1117 			IGC_MRQC_RSS_FIELD_IPV4_TCP |
1118 			IGC_MRQC_RSS_FIELD_IPV6 |
1119 			IGC_MRQC_RSS_FIELD_IPV6_TCP;
1120 
1121 		mrqc &= ~(IGC_MRQC_RSS_FIELD_IPV4_UDP |
1122 			  IGC_MRQC_RSS_FIELD_IPV6_UDP);
1123 
1124 		if (flags & IGC_FLAG_RSS_FIELD_IPV4_UDP)
1125 			mrqc |= IGC_MRQC_RSS_FIELD_IPV4_UDP;
1126 
1127 		if (flags & IGC_FLAG_RSS_FIELD_IPV6_UDP)
1128 			mrqc |= IGC_MRQC_RSS_FIELD_IPV6_UDP;
1129 
1130 		wr32(IGC_MRQC, mrqc);
1131 	}
1132 
1133 	return 0;
1134 }
1135 
1136 static int igc_rxnfc_write_etype_filter(struct igc_adapter *adapter,
1137 					struct igc_nfc_filter *input)
1138 {
1139 	struct igc_hw *hw = &adapter->hw;
1140 	u8 i;
1141 	u32 etqf;
1142 	u16 etype;
1143 
1144 	/* find an empty etype filter register */
1145 	for (i = 0; i < MAX_ETYPE_FILTER; ++i) {
1146 		if (!adapter->etype_bitmap[i])
1147 			break;
1148 	}
1149 	if (i == MAX_ETYPE_FILTER) {
1150 		dev_err(&adapter->pdev->dev, "ethtool -N: etype filters are all used.\n");
1151 		return -EINVAL;
1152 	}
1153 
1154 	adapter->etype_bitmap[i] = true;
1155 
1156 	etqf = rd32(IGC_ETQF(i));
1157 	etype = ntohs(input->filter.etype & ETHER_TYPE_FULL_MASK);
1158 
1159 	etqf |= IGC_ETQF_FILTER_ENABLE;
1160 	etqf &= ~IGC_ETQF_ETYPE_MASK;
1161 	etqf |= (etype & IGC_ETQF_ETYPE_MASK);
1162 
1163 	etqf &= ~IGC_ETQF_QUEUE_MASK;
1164 	etqf |= ((input->action << IGC_ETQF_QUEUE_SHIFT)
1165 		& IGC_ETQF_QUEUE_MASK);
1166 	etqf |= IGC_ETQF_QUEUE_ENABLE;
1167 
1168 	wr32(IGC_ETQF(i), etqf);
1169 
1170 	input->etype_reg_index = i;
1171 
1172 	return 0;
1173 }
1174 
1175 static int igc_rxnfc_write_vlan_prio_filter(struct igc_adapter *adapter,
1176 					    struct igc_nfc_filter *input)
1177 {
1178 	struct igc_hw *hw = &adapter->hw;
1179 	u8 vlan_priority;
1180 	u16 queue_index;
1181 	u32 vlapqf;
1182 
1183 	vlapqf = rd32(IGC_VLAPQF);
1184 	vlan_priority = (ntohs(input->filter.vlan_tci) & VLAN_PRIO_MASK)
1185 				>> VLAN_PRIO_SHIFT;
1186 	queue_index = (vlapqf >> (vlan_priority * 4)) & IGC_VLAPQF_QUEUE_MASK;
1187 
1188 	/* check whether this vlan prio is already set */
1189 	if (vlapqf & IGC_VLAPQF_P_VALID(vlan_priority) &&
1190 	    queue_index != input->action) {
1191 		dev_err(&adapter->pdev->dev, "ethtool rxnfc set vlan prio filter failed.\n");
1192 		return -EEXIST;
1193 	}
1194 
1195 	vlapqf |= IGC_VLAPQF_P_VALID(vlan_priority);
1196 	vlapqf |= IGC_VLAPQF_QUEUE_SEL(vlan_priority, input->action);
1197 
1198 	wr32(IGC_VLAPQF, vlapqf);
1199 
1200 	return 0;
1201 }
1202 
1203 int igc_add_filter(struct igc_adapter *adapter, struct igc_nfc_filter *input)
1204 {
1205 	struct igc_hw *hw = &adapter->hw;
1206 	int err = -EINVAL;
1207 
1208 	if (hw->mac.type == igc_i225 &&
1209 	    !(input->filter.match_flags & ~IGC_FILTER_FLAG_SRC_MAC_ADDR)) {
1210 		dev_err(&adapter->pdev->dev,
1211 			"i225 doesn't support flow classification rules specifying only source addresses.\n");
1212 		return -EOPNOTSUPP;
1213 	}
1214 
1215 	if (input->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) {
1216 		err = igc_rxnfc_write_etype_filter(adapter, input);
1217 		if (err)
1218 			return err;
1219 	}
1220 
1221 	if (input->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) {
1222 		err = igc_add_mac_steering_filter(adapter,
1223 						  input->filter.dst_addr,
1224 						  input->action, 0);
1225 		err = min_t(int, err, 0);
1226 		if (err)
1227 			return err;
1228 	}
1229 
1230 	if (input->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) {
1231 		err = igc_add_mac_steering_filter(adapter,
1232 						  input->filter.src_addr,
1233 						  input->action,
1234 						  IGC_MAC_STATE_SRC_ADDR);
1235 		err = min_t(int, err, 0);
1236 		if (err)
1237 			return err;
1238 	}
1239 
1240 	if (input->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI)
1241 		err = igc_rxnfc_write_vlan_prio_filter(adapter, input);
1242 
1243 	return err;
1244 }
1245 
1246 static void igc_clear_etype_filter_regs(struct igc_adapter *adapter,
1247 					u16 reg_index)
1248 {
1249 	struct igc_hw *hw = &adapter->hw;
1250 	u32 etqf = rd32(IGC_ETQF(reg_index));
1251 
1252 	etqf &= ~IGC_ETQF_QUEUE_ENABLE;
1253 	etqf &= ~IGC_ETQF_QUEUE_MASK;
1254 	etqf &= ~IGC_ETQF_FILTER_ENABLE;
1255 
1256 	wr32(IGC_ETQF(reg_index), etqf);
1257 
1258 	adapter->etype_bitmap[reg_index] = false;
1259 }
1260 
1261 static void igc_clear_vlan_prio_filter(struct igc_adapter *adapter,
1262 				       u16 vlan_tci)
1263 {
1264 	struct igc_hw *hw = &adapter->hw;
1265 	u8 vlan_priority;
1266 	u32 vlapqf;
1267 
1268 	vlan_priority = (vlan_tci & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
1269 
1270 	vlapqf = rd32(IGC_VLAPQF);
1271 	vlapqf &= ~IGC_VLAPQF_P_VALID(vlan_priority);
1272 	vlapqf &= ~IGC_VLAPQF_QUEUE_SEL(vlan_priority,
1273 						IGC_VLAPQF_QUEUE_MASK);
1274 
1275 	wr32(IGC_VLAPQF, vlapqf);
1276 }
1277 
1278 int igc_erase_filter(struct igc_adapter *adapter, struct igc_nfc_filter *input)
1279 {
1280 	if (input->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE)
1281 		igc_clear_etype_filter_regs(adapter,
1282 					    input->etype_reg_index);
1283 
1284 	if (input->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI)
1285 		igc_clear_vlan_prio_filter(adapter,
1286 					   ntohs(input->filter.vlan_tci));
1287 
1288 	if (input->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR)
1289 		igc_del_mac_steering_filter(adapter, input->filter.src_addr,
1290 					    input->action,
1291 					    IGC_MAC_STATE_SRC_ADDR);
1292 
1293 	if (input->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR)
1294 		igc_del_mac_steering_filter(adapter, input->filter.dst_addr,
1295 					    input->action, 0);
1296 
1297 	return 0;
1298 }
1299 
1300 static int igc_update_ethtool_nfc_entry(struct igc_adapter *adapter,
1301 					struct igc_nfc_filter *input,
1302 					u16 sw_idx)
1303 {
1304 	struct igc_nfc_filter *rule, *parent;
1305 	int err = -EINVAL;
1306 
1307 	parent = NULL;
1308 	rule = NULL;
1309 
1310 	hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) {
1311 		/* hash found, or no matching entry */
1312 		if (rule->sw_idx >= sw_idx)
1313 			break;
1314 		parent = rule;
1315 	}
1316 
1317 	/* if there is an old rule occupying our place remove it */
1318 	if (rule && rule->sw_idx == sw_idx) {
1319 		if (!input)
1320 			err = igc_erase_filter(adapter, rule);
1321 
1322 		hlist_del(&rule->nfc_node);
1323 		kfree(rule);
1324 		adapter->nfc_filter_count--;
1325 	}
1326 
1327 	/* If no input this was a delete, err should be 0 if a rule was
1328 	 * successfully found and removed from the list else -EINVAL
1329 	 */
1330 	if (!input)
1331 		return err;
1332 
1333 	/* initialize node */
1334 	INIT_HLIST_NODE(&input->nfc_node);
1335 
1336 	/* add filter to the list */
1337 	if (parent)
1338 		hlist_add_behind(&input->nfc_node, &parent->nfc_node);
1339 	else
1340 		hlist_add_head(&input->nfc_node, &adapter->nfc_filter_list);
1341 
1342 	/* update counts */
1343 	adapter->nfc_filter_count++;
1344 
1345 	return 0;
1346 }
1347 
1348 static int igc_add_ethtool_nfc_entry(struct igc_adapter *adapter,
1349 				     struct ethtool_rxnfc *cmd)
1350 {
1351 	struct net_device *netdev = adapter->netdev;
1352 	struct ethtool_rx_flow_spec *fsp =
1353 		(struct ethtool_rx_flow_spec *)&cmd->fs;
1354 	struct igc_nfc_filter *input, *rule;
1355 	int err = 0;
1356 
1357 	if (!(netdev->hw_features & NETIF_F_NTUPLE))
1358 		return -EOPNOTSUPP;
1359 
1360 	/* Don't allow programming if the action is a queue greater than
1361 	 * the number of online Rx queues.
1362 	 */
1363 	if (fsp->ring_cookie == RX_CLS_FLOW_DISC ||
1364 	    fsp->ring_cookie >= adapter->num_rx_queues) {
1365 		dev_err(&adapter->pdev->dev, "ethtool -N: The specified action is invalid\n");
1366 		return -EINVAL;
1367 	}
1368 
1369 	/* Don't allow indexes to exist outside of available space */
1370 	if (fsp->location >= IGC_MAX_RXNFC_FILTERS) {
1371 		dev_err(&adapter->pdev->dev, "Location out of range\n");
1372 		return -EINVAL;
1373 	}
1374 
1375 	if ((fsp->flow_type & ~FLOW_EXT) != ETHER_FLOW)
1376 		return -EINVAL;
1377 
1378 	input = kzalloc(sizeof(*input), GFP_KERNEL);
1379 	if (!input)
1380 		return -ENOMEM;
1381 
1382 	if (fsp->m_u.ether_spec.h_proto == ETHER_TYPE_FULL_MASK) {
1383 		input->filter.etype = fsp->h_u.ether_spec.h_proto;
1384 		input->filter.match_flags = IGC_FILTER_FLAG_ETHER_TYPE;
1385 	}
1386 
1387 	/* Only support matching addresses by the full mask */
1388 	if (is_broadcast_ether_addr(fsp->m_u.ether_spec.h_source)) {
1389 		input->filter.match_flags |= IGC_FILTER_FLAG_SRC_MAC_ADDR;
1390 		ether_addr_copy(input->filter.src_addr,
1391 				fsp->h_u.ether_spec.h_source);
1392 	}
1393 
1394 	/* Only support matching addresses by the full mask */
1395 	if (is_broadcast_ether_addr(fsp->m_u.ether_spec.h_dest)) {
1396 		input->filter.match_flags |= IGC_FILTER_FLAG_DST_MAC_ADDR;
1397 		ether_addr_copy(input->filter.dst_addr,
1398 				fsp->h_u.ether_spec.h_dest);
1399 	}
1400 
1401 	if ((fsp->flow_type & FLOW_EXT) && fsp->m_ext.vlan_tci) {
1402 		if (fsp->m_ext.vlan_tci != htons(VLAN_PRIO_MASK)) {
1403 			err = -EINVAL;
1404 			goto err_out;
1405 		}
1406 		input->filter.vlan_tci = fsp->h_ext.vlan_tci;
1407 		input->filter.match_flags |= IGC_FILTER_FLAG_VLAN_TCI;
1408 	}
1409 
1410 	input->action = fsp->ring_cookie;
1411 	input->sw_idx = fsp->location;
1412 
1413 	spin_lock(&adapter->nfc_lock);
1414 
1415 	hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) {
1416 		if (!memcmp(&input->filter, &rule->filter,
1417 			    sizeof(input->filter))) {
1418 			err = -EEXIST;
1419 			dev_err(&adapter->pdev->dev,
1420 				"ethtool: this filter is already set\n");
1421 			goto err_out_w_lock;
1422 		}
1423 	}
1424 
1425 	err = igc_add_filter(adapter, input);
1426 	if (err)
1427 		goto err_out_w_lock;
1428 
1429 	igc_update_ethtool_nfc_entry(adapter, input, input->sw_idx);
1430 
1431 	spin_unlock(&adapter->nfc_lock);
1432 	return 0;
1433 
1434 err_out_w_lock:
1435 	spin_unlock(&adapter->nfc_lock);
1436 err_out:
1437 	kfree(input);
1438 	return err;
1439 }
1440 
1441 static int igc_del_ethtool_nfc_entry(struct igc_adapter *adapter,
1442 				     struct ethtool_rxnfc *cmd)
1443 {
1444 	struct ethtool_rx_flow_spec *fsp =
1445 		(struct ethtool_rx_flow_spec *)&cmd->fs;
1446 	int err;
1447 
1448 	spin_lock(&adapter->nfc_lock);
1449 	err = igc_update_ethtool_nfc_entry(adapter, NULL, fsp->location);
1450 	spin_unlock(&adapter->nfc_lock);
1451 
1452 	return err;
1453 }
1454 
1455 static int igc_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
1456 {
1457 	struct igc_adapter *adapter = netdev_priv(dev);
1458 	int ret = -EOPNOTSUPP;
1459 
1460 	switch (cmd->cmd) {
1461 	case ETHTOOL_SRXFH:
1462 		ret = igc_set_rss_hash_opt(adapter, cmd);
1463 		break;
1464 	case ETHTOOL_SRXCLSRLINS:
1465 		ret = igc_add_ethtool_nfc_entry(adapter, cmd);
1466 		break;
1467 	case ETHTOOL_SRXCLSRLDEL:
1468 		ret = igc_del_ethtool_nfc_entry(adapter, cmd);
1469 	default:
1470 		break;
1471 	}
1472 
1473 	return ret;
1474 }
1475 
1476 void igc_write_rss_indir_tbl(struct igc_adapter *adapter)
1477 {
1478 	struct igc_hw *hw = &adapter->hw;
1479 	u32 reg = IGC_RETA(0);
1480 	u32 shift = 0;
1481 	int i = 0;
1482 
1483 	while (i < IGC_RETA_SIZE) {
1484 		u32 val = 0;
1485 		int j;
1486 
1487 		for (j = 3; j >= 0; j--) {
1488 			val <<= 8;
1489 			val |= adapter->rss_indir_tbl[i + j];
1490 		}
1491 
1492 		wr32(reg, val << shift);
1493 		reg += 4;
1494 		i += 4;
1495 	}
1496 }
1497 
1498 static u32 igc_get_rxfh_indir_size(struct net_device *netdev)
1499 {
1500 	return IGC_RETA_SIZE;
1501 }
1502 
1503 static int igc_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key,
1504 			u8 *hfunc)
1505 {
1506 	struct igc_adapter *adapter = netdev_priv(netdev);
1507 	int i;
1508 
1509 	if (hfunc)
1510 		*hfunc = ETH_RSS_HASH_TOP;
1511 	if (!indir)
1512 		return 0;
1513 	for (i = 0; i < IGC_RETA_SIZE; i++)
1514 		indir[i] = adapter->rss_indir_tbl[i];
1515 
1516 	return 0;
1517 }
1518 
1519 static int igc_set_rxfh(struct net_device *netdev, const u32 *indir,
1520 			const u8 *key, const u8 hfunc)
1521 {
1522 	struct igc_adapter *adapter = netdev_priv(netdev);
1523 	u32 num_queues;
1524 	int i;
1525 
1526 	/* We do not allow change in unsupported parameters */
1527 	if (key ||
1528 	    (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP))
1529 		return -EOPNOTSUPP;
1530 	if (!indir)
1531 		return 0;
1532 
1533 	num_queues = adapter->rss_queues;
1534 
1535 	/* Verify user input. */
1536 	for (i = 0; i < IGC_RETA_SIZE; i++)
1537 		if (indir[i] >= num_queues)
1538 			return -EINVAL;
1539 
1540 	for (i = 0; i < IGC_RETA_SIZE; i++)
1541 		adapter->rss_indir_tbl[i] = indir[i];
1542 
1543 	igc_write_rss_indir_tbl(adapter);
1544 
1545 	return 0;
1546 }
1547 
1548 static unsigned int igc_max_channels(struct igc_adapter *adapter)
1549 {
1550 	return igc_get_max_rss_queues(adapter);
1551 }
1552 
1553 static void igc_get_channels(struct net_device *netdev,
1554 			     struct ethtool_channels *ch)
1555 {
1556 	struct igc_adapter *adapter = netdev_priv(netdev);
1557 
1558 	/* Report maximum channels */
1559 	ch->max_combined = igc_max_channels(adapter);
1560 
1561 	/* Report info for other vector */
1562 	if (adapter->flags & IGC_FLAG_HAS_MSIX) {
1563 		ch->max_other = NON_Q_VECTORS;
1564 		ch->other_count = NON_Q_VECTORS;
1565 	}
1566 
1567 	ch->combined_count = adapter->rss_queues;
1568 }
1569 
1570 static int igc_set_channels(struct net_device *netdev,
1571 			    struct ethtool_channels *ch)
1572 {
1573 	struct igc_adapter *adapter = netdev_priv(netdev);
1574 	unsigned int count = ch->combined_count;
1575 	unsigned int max_combined = 0;
1576 
1577 	/* Verify they are not requesting separate vectors */
1578 	if (!count || ch->rx_count || ch->tx_count)
1579 		return -EINVAL;
1580 
1581 	/* Verify other_count is valid and has not been changed */
1582 	if (ch->other_count != NON_Q_VECTORS)
1583 		return -EINVAL;
1584 
1585 	/* Verify the number of channels doesn't exceed hw limits */
1586 	max_combined = igc_max_channels(adapter);
1587 	if (count > max_combined)
1588 		return -EINVAL;
1589 
1590 	if (count != adapter->rss_queues) {
1591 		adapter->rss_queues = count;
1592 		igc_set_flag_queue_pairs(adapter, max_combined);
1593 
1594 		/* Hardware has to reinitialize queues and interrupts to
1595 		 * match the new configuration.
1596 		 */
1597 		return igc_reinit_queues(adapter);
1598 	}
1599 
1600 	return 0;
1601 }
1602 
1603 static u32 igc_get_priv_flags(struct net_device *netdev)
1604 {
1605 	struct igc_adapter *adapter = netdev_priv(netdev);
1606 	u32 priv_flags = 0;
1607 
1608 	if (adapter->flags & IGC_FLAG_RX_LEGACY)
1609 		priv_flags |= IGC_PRIV_FLAGS_LEGACY_RX;
1610 
1611 	return priv_flags;
1612 }
1613 
1614 static int igc_set_priv_flags(struct net_device *netdev, u32 priv_flags)
1615 {
1616 	struct igc_adapter *adapter = netdev_priv(netdev);
1617 	unsigned int flags = adapter->flags;
1618 
1619 	flags &= ~IGC_FLAG_RX_LEGACY;
1620 	if (priv_flags & IGC_PRIV_FLAGS_LEGACY_RX)
1621 		flags |= IGC_FLAG_RX_LEGACY;
1622 
1623 	if (flags != adapter->flags) {
1624 		adapter->flags = flags;
1625 
1626 		/* reset interface to repopulate queues */
1627 		if (netif_running(netdev))
1628 			igc_reinit_locked(adapter);
1629 	}
1630 
1631 	return 0;
1632 }
1633 
1634 static int igc_ethtool_begin(struct net_device *netdev)
1635 {
1636 	struct igc_adapter *adapter = netdev_priv(netdev);
1637 
1638 	pm_runtime_get_sync(&adapter->pdev->dev);
1639 	return 0;
1640 }
1641 
1642 static void igc_ethtool_complete(struct net_device *netdev)
1643 {
1644 	struct igc_adapter *adapter = netdev_priv(netdev);
1645 
1646 	pm_runtime_put(&adapter->pdev->dev);
1647 }
1648 
1649 static int igc_get_link_ksettings(struct net_device *netdev,
1650 				  struct ethtool_link_ksettings *cmd)
1651 {
1652 	struct igc_adapter *adapter = netdev_priv(netdev);
1653 	struct igc_hw *hw = &adapter->hw;
1654 	u32 status;
1655 	u32 speed;
1656 
1657 	ethtool_link_ksettings_zero_link_mode(cmd, supported);
1658 	ethtool_link_ksettings_zero_link_mode(cmd, advertising);
1659 
1660 	/* supported link modes */
1661 	ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Half);
1662 	ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Full);
1663 	ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Half);
1664 	ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Full);
1665 	ethtool_link_ksettings_add_link_mode(cmd, supported, 1000baseT_Full);
1666 	ethtool_link_ksettings_add_link_mode(cmd, supported, 2500baseT_Full);
1667 
1668 	/* twisted pair */
1669 	cmd->base.port = PORT_TP;
1670 	cmd->base.phy_address = hw->phy.addr;
1671 
1672 	/* advertising link modes */
1673 	ethtool_link_ksettings_add_link_mode(cmd, advertising, 10baseT_Half);
1674 	ethtool_link_ksettings_add_link_mode(cmd, advertising, 10baseT_Full);
1675 	ethtool_link_ksettings_add_link_mode(cmd, advertising, 100baseT_Half);
1676 	ethtool_link_ksettings_add_link_mode(cmd, advertising, 100baseT_Full);
1677 	ethtool_link_ksettings_add_link_mode(cmd, advertising, 1000baseT_Full);
1678 	ethtool_link_ksettings_add_link_mode(cmd, advertising, 2500baseT_Full);
1679 
1680 	/* set autoneg settings */
1681 	if (hw->mac.autoneg == 1) {
1682 		ethtool_link_ksettings_add_link_mode(cmd, supported, Autoneg);
1683 		ethtool_link_ksettings_add_link_mode(cmd, advertising,
1684 						     Autoneg);
1685 	}
1686 
1687 	switch (hw->fc.requested_mode) {
1688 	case igc_fc_full:
1689 		ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause);
1690 		break;
1691 	case igc_fc_rx_pause:
1692 		ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause);
1693 		ethtool_link_ksettings_add_link_mode(cmd, advertising,
1694 						     Asym_Pause);
1695 		break;
1696 	case igc_fc_tx_pause:
1697 		ethtool_link_ksettings_add_link_mode(cmd, advertising,
1698 						     Asym_Pause);
1699 		break;
1700 	default:
1701 		ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause);
1702 		ethtool_link_ksettings_add_link_mode(cmd, advertising,
1703 						     Asym_Pause);
1704 	}
1705 
1706 	status = rd32(IGC_STATUS);
1707 
1708 	if (status & IGC_STATUS_LU) {
1709 		if (status & IGC_STATUS_SPEED_1000) {
1710 			/* For I225, STATUS will indicate 1G speed in both
1711 			 * 1 Gbps and 2.5 Gbps link modes.
1712 			 * An additional bit is used
1713 			 * to differentiate between 1 Gbps and 2.5 Gbps.
1714 			 */
1715 			if (hw->mac.type == igc_i225 &&
1716 			    (status & IGC_STATUS_SPEED_2500)) {
1717 				speed = SPEED_2500;
1718 			} else {
1719 				speed = SPEED_1000;
1720 			}
1721 		} else if (status & IGC_STATUS_SPEED_100) {
1722 			speed = SPEED_100;
1723 		} else {
1724 			speed = SPEED_10;
1725 		}
1726 		if ((status & IGC_STATUS_FD) ||
1727 		    hw->phy.media_type != igc_media_type_copper)
1728 			cmd->base.duplex = DUPLEX_FULL;
1729 		else
1730 			cmd->base.duplex = DUPLEX_HALF;
1731 	} else {
1732 		speed = SPEED_UNKNOWN;
1733 		cmd->base.duplex = DUPLEX_UNKNOWN;
1734 	}
1735 	cmd->base.speed = speed;
1736 	if (hw->mac.autoneg)
1737 		cmd->base.autoneg = AUTONEG_ENABLE;
1738 	else
1739 		cmd->base.autoneg = AUTONEG_DISABLE;
1740 
1741 	/* MDI-X => 2; MDI =>1; Invalid =>0 */
1742 	if (hw->phy.media_type == igc_media_type_copper)
1743 		cmd->base.eth_tp_mdix = hw->phy.is_mdix ? ETH_TP_MDI_X :
1744 						      ETH_TP_MDI;
1745 	else
1746 		cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;
1747 
1748 	if (hw->phy.mdix == AUTO_ALL_MODES)
1749 		cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
1750 	else
1751 		cmd->base.eth_tp_mdix_ctrl = hw->phy.mdix;
1752 
1753 	return 0;
1754 }
1755 
1756 static int igc_set_link_ksettings(struct net_device *netdev,
1757 				  const struct ethtool_link_ksettings *cmd)
1758 {
1759 	struct igc_adapter *adapter = netdev_priv(netdev);
1760 	struct igc_hw *hw = &adapter->hw;
1761 	u32 advertising;
1762 
1763 	/* When adapter in resetting mode, autoneg/speed/duplex
1764 	 * cannot be changed
1765 	 */
1766 	if (igc_check_reset_block(hw)) {
1767 		dev_err(&adapter->pdev->dev,
1768 			"Cannot change link characteristics when reset is active.\n");
1769 		return -EINVAL;
1770 	}
1771 
1772 	/* MDI setting is only allowed when autoneg enabled because
1773 	 * some hardware doesn't allow MDI setting when speed or
1774 	 * duplex is forced.
1775 	 */
1776 	if (cmd->base.eth_tp_mdix_ctrl) {
1777 		if (cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO &&
1778 		    cmd->base.autoneg != AUTONEG_ENABLE) {
1779 			dev_err(&adapter->pdev->dev, "forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");
1780 			return -EINVAL;
1781 		}
1782 	}
1783 
1784 	while (test_and_set_bit(__IGC_RESETTING, &adapter->state))
1785 		usleep_range(1000, 2000);
1786 
1787 	ethtool_convert_link_mode_to_legacy_u32(&advertising,
1788 						cmd->link_modes.advertising);
1789 
1790 	if (cmd->base.autoneg == AUTONEG_ENABLE) {
1791 		hw->mac.autoneg = 1;
1792 		hw->phy.autoneg_advertised = advertising;
1793 		if (adapter->fc_autoneg)
1794 			hw->fc.requested_mode = igc_fc_default;
1795 	} else {
1796 		/* calling this overrides forced MDI setting */
1797 		dev_info(&adapter->pdev->dev,
1798 			 "Force mode currently not supported\n");
1799 	}
1800 
1801 	/* MDI-X => 2; MDI => 1; Auto => 3 */
1802 	if (cmd->base.eth_tp_mdix_ctrl) {
1803 		/* fix up the value for auto (3 => 0) as zero is mapped
1804 		 * internally to auto
1805 		 */
1806 		if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)
1807 			hw->phy.mdix = AUTO_ALL_MODES;
1808 		else
1809 			hw->phy.mdix = cmd->base.eth_tp_mdix_ctrl;
1810 	}
1811 
1812 	/* reset the link */
1813 	if (netif_running(adapter->netdev)) {
1814 		igc_down(adapter);
1815 		igc_up(adapter);
1816 	} else {
1817 		igc_reset(adapter);
1818 	}
1819 
1820 	clear_bit(__IGC_RESETTING, &adapter->state);
1821 
1822 	return 0;
1823 }
1824 
1825 static const struct ethtool_ops igc_ethtool_ops = {
1826 	.get_drvinfo		= igc_get_drvinfo,
1827 	.get_regs_len		= igc_get_regs_len,
1828 	.get_regs		= igc_get_regs,
1829 	.get_msglevel		= igc_get_msglevel,
1830 	.set_msglevel		= igc_set_msglevel,
1831 	.nway_reset		= igc_nway_reset,
1832 	.get_link		= igc_get_link,
1833 	.get_eeprom_len		= igc_get_eeprom_len,
1834 	.get_eeprom		= igc_get_eeprom,
1835 	.set_eeprom		= igc_set_eeprom,
1836 	.get_ringparam		= igc_get_ringparam,
1837 	.set_ringparam		= igc_set_ringparam,
1838 	.get_pauseparam		= igc_get_pauseparam,
1839 	.set_pauseparam		= igc_set_pauseparam,
1840 	.get_strings		= igc_get_strings,
1841 	.get_sset_count		= igc_get_sset_count,
1842 	.get_ethtool_stats	= igc_get_ethtool_stats,
1843 	.get_coalesce		= igc_get_coalesce,
1844 	.set_coalesce		= igc_set_coalesce,
1845 	.get_rxnfc		= igc_get_rxnfc,
1846 	.set_rxnfc		= igc_set_rxnfc,
1847 	.get_rxfh_indir_size	= igc_get_rxfh_indir_size,
1848 	.get_rxfh		= igc_get_rxfh,
1849 	.set_rxfh		= igc_set_rxfh,
1850 	.get_channels		= igc_get_channels,
1851 	.set_channels		= igc_set_channels,
1852 	.get_priv_flags		= igc_get_priv_flags,
1853 	.set_priv_flags		= igc_set_priv_flags,
1854 	.begin			= igc_ethtool_begin,
1855 	.complete		= igc_ethtool_complete,
1856 	.get_link_ksettings	= igc_get_link_ksettings,
1857 	.set_link_ksettings	= igc_set_link_ksettings,
1858 };
1859 
1860 void igc_set_ethtool_ops(struct net_device *netdev)
1861 {
1862 	netdev->ethtool_ops = &igc_ethtool_ops;
1863 }
1864