?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gpio: rcar: Fix runtime PM imbalance on error
[linux/fpc-iii.git] / drivers / net / ethernet / intel / igc / igc_ethtool.c
blobf530fc29b074a189fd3e3cf35173ad593594aed1
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 = sizeof_field(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 = sizeof_field(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 void igc_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
312 {
313 struct igc_adapter *adapter = netdev_priv(netdev);
314
315 wol->wolopts = 0;
316
317 if (!(adapter->flags & IGC_FLAG_WOL_SUPPORTED))
318 return;
319
320 wol->supported = WAKE_UCAST | WAKE_MCAST |
321 WAKE_BCAST | WAKE_MAGIC |
322 WAKE_PHY;
323
324 /* apply any specific unsupported masks here */
325 switch (adapter->hw.device_id) {
326 default:
327 break;
328 }
329
330 if (adapter->wol & IGC_WUFC_EX)
331 wol->wolopts |= WAKE_UCAST;
332 if (adapter->wol & IGC_WUFC_MC)
333 wol->wolopts |= WAKE_MCAST;
334 if (adapter->wol & IGC_WUFC_BC)
335 wol->wolopts |= WAKE_BCAST;
336 if (adapter->wol & IGC_WUFC_MAG)
337 wol->wolopts |= WAKE_MAGIC;
338 if (adapter->wol & IGC_WUFC_LNKC)
339 wol->wolopts |= WAKE_PHY;
340 }
341
342 static int igc_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
343 {
344 struct igc_adapter *adapter = netdev_priv(netdev);
345
346 if (wol->wolopts & (WAKE_ARP | WAKE_MAGICSECURE | WAKE_FILTER))
347 return -EOPNOTSUPP;
348
349 if (!(adapter->flags & IGC_FLAG_WOL_SUPPORTED))
350 return wol->wolopts ? -EOPNOTSUPP : 0;
351
352 /* these settings will always override what we currently have */
353 adapter->wol = 0;
354
355 if (wol->wolopts & WAKE_UCAST)
356 adapter->wol |= IGC_WUFC_EX;
357 if (wol->wolopts & WAKE_MCAST)
358 adapter->wol |= IGC_WUFC_MC;
359 if (wol->wolopts & WAKE_BCAST)
360 adapter->wol |= IGC_WUFC_BC;
361 if (wol->wolopts & WAKE_MAGIC)
362 adapter->wol |= IGC_WUFC_MAG;
363 if (wol->wolopts & WAKE_PHY)
364 adapter->wol |= IGC_WUFC_LNKC;
365 device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);
366
367 return 0;
368 }
369
370 static u32 igc_get_msglevel(struct net_device *netdev)
371 {
372 struct igc_adapter *adapter = netdev_priv(netdev);
373
374 return adapter->msg_enable;
375 }
376
377 static void igc_set_msglevel(struct net_device *netdev, u32 data)
378 {
379 struct igc_adapter *adapter = netdev_priv(netdev);
380
381 adapter->msg_enable = data;
382 }
383
384 static int igc_nway_reset(struct net_device *netdev)
385 {
386 struct igc_adapter *adapter = netdev_priv(netdev);
387
388 if (netif_running(netdev))
389 igc_reinit_locked(adapter);
390 return 0;
391 }
392
393 static u32 igc_get_link(struct net_device *netdev)
394 {
395 struct igc_adapter *adapter = netdev_priv(netdev);
396 struct igc_mac_info *mac = &adapter->hw.mac;
397
398 /* If the link is not reported up to netdev, interrupts are disabled,
399 * and so the physical link state may have changed since we last
400 * looked. Set get_link_status to make sure that the true link
401 * state is interrogated, rather than pulling a cached and possibly
402 * stale link state from the driver.
403 */
404 if (!netif_carrier_ok(netdev))
405 mac->get_link_status = 1;
406
407 return igc_has_link(adapter);
408 }
409
410 static int igc_get_eeprom_len(struct net_device *netdev)
411 {
412 struct igc_adapter *adapter = netdev_priv(netdev);
413
414 return adapter->hw.nvm.word_size * 2;
415 }
416
417 static int igc_get_eeprom(struct net_device *netdev,
418 struct ethtool_eeprom *eeprom, u8 *bytes)
419 {
420 struct igc_adapter *adapter = netdev_priv(netdev);
421 struct igc_hw *hw = &adapter->hw;
422 int first_word, last_word;
423 u16 *eeprom_buff;
424 int ret_val = 0;
425 u16 i;
426
427 if (eeprom->len == 0)
428 return -EINVAL;
429
430 eeprom->magic = hw->vendor_id | (hw->device_id << 16);
431
432 first_word = eeprom->offset >> 1;
433 last_word = (eeprom->offset + eeprom->len - 1) >> 1;
434
435 eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16),
436 GFP_KERNEL);
437 if (!eeprom_buff)
438 return -ENOMEM;
439
440 if (hw->nvm.type == igc_nvm_eeprom_spi) {
441 ret_val = hw->nvm.ops.read(hw, first_word,
442 last_word - first_word + 1,
443 eeprom_buff);
444 } else {
445 for (i = 0; i < last_word - first_word + 1; i++) {
446 ret_val = hw->nvm.ops.read(hw, first_word + i, 1,
447 &eeprom_buff[i]);
448 if (ret_val)
449 break;
450 }
451 }
452
453 /* Device's eeprom is always little-endian, word addressable */
454 for (i = 0; i < last_word - first_word + 1; i++)
455 le16_to_cpus(&eeprom_buff[i]);
456
457 memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1),
458 eeprom->len);
459 kfree(eeprom_buff);
460
461 return ret_val;
462 }
463
464 static int igc_set_eeprom(struct net_device *netdev,
465 struct ethtool_eeprom *eeprom, u8 *bytes)
466 {
467 struct igc_adapter *adapter = netdev_priv(netdev);
468 struct igc_hw *hw = &adapter->hw;
469 int max_len, first_word, last_word, ret_val = 0;
470 u16 *eeprom_buff;
471 void *ptr;
472 u16 i;
473
474 if (eeprom->len == 0)
475 return -EOPNOTSUPP;
476
477 if (hw->mac.type >= igc_i225 &&
478 !igc_get_flash_presence_i225(hw)) {
479 return -EOPNOTSUPP;
480 }
481
482 if (eeprom->magic != (hw->vendor_id | (hw->device_id << 16)))
483 return -EFAULT;
484
485 max_len = hw->nvm.word_size * 2;
486
487 first_word = eeprom->offset >> 1;
488 last_word = (eeprom->offset + eeprom->len - 1) >> 1;
489 eeprom_buff = kmalloc(max_len, GFP_KERNEL);
490 if (!eeprom_buff)
491 return -ENOMEM;
492
493 ptr = (void *)eeprom_buff;
494
495 if (eeprom->offset & 1) {
496 /* need read/modify/write of first changed EEPROM word
497 * only the second byte of the word is being modified
498 */
499 ret_val = hw->nvm.ops.read(hw, first_word, 1,
500 &eeprom_buff[0]);
501 ptr++;
502 }
503 if (((eeprom->offset + eeprom->len) & 1) && ret_val == 0) {
504 /* need read/modify/write of last changed EEPROM word
505 * only the first byte of the word is being modified
506 */
507 ret_val = hw->nvm.ops.read(hw, last_word, 1,
508 &eeprom_buff[last_word - first_word]);
509 }
510
511 /* Device's eeprom is always little-endian, word addressable */
512 for (i = 0; i < last_word - first_word + 1; i++)
513 le16_to_cpus(&eeprom_buff[i]);
514
515 memcpy(ptr, bytes, eeprom->len);
516
517 for (i = 0; i < last_word - first_word + 1; i++)
518 eeprom_buff[i] = cpu_to_le16(eeprom_buff[i]);
519
520 ret_val = hw->nvm.ops.write(hw, first_word,
521 last_word - first_word + 1, eeprom_buff);
522
523 /* Update the checksum if nvm write succeeded */
524 if (ret_val == 0)
525 hw->nvm.ops.update(hw);
526
527 /* check if need: igc_set_fw_version(adapter); */
528 kfree(eeprom_buff);
529 return ret_val;
530 }
531
532 static void igc_get_ringparam(struct net_device *netdev,
533 struct ethtool_ringparam *ring)
534 {
535 struct igc_adapter *adapter = netdev_priv(netdev);
536
537 ring->rx_max_pending = IGC_MAX_RXD;
538 ring->tx_max_pending = IGC_MAX_TXD;
539 ring->rx_pending = adapter->rx_ring_count;
540 ring->tx_pending = adapter->tx_ring_count;
541 }
542
543 static int igc_set_ringparam(struct net_device *netdev,
544 struct ethtool_ringparam *ring)
545 {
546 struct igc_adapter *adapter = netdev_priv(netdev);
547 struct igc_ring *temp_ring;
548 u16 new_rx_count, new_tx_count;
549 int i, err = 0;
550
551 if (ring->rx_mini_pending || ring->rx_jumbo_pending)
552 return -EINVAL;
553
554 new_rx_count = min_t(u32, ring->rx_pending, IGC_MAX_RXD);
555 new_rx_count = max_t(u16, new_rx_count, IGC_MIN_RXD);
556 new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);
557
558 new_tx_count = min_t(u32, ring->tx_pending, IGC_MAX_TXD);
559 new_tx_count = max_t(u16, new_tx_count, IGC_MIN_TXD);
560 new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE);
561
562 if (new_tx_count == adapter->tx_ring_count &&
563 new_rx_count == adapter->rx_ring_count) {
564 /* nothing to do */
565 return 0;
566 }
567
568 while (test_and_set_bit(__IGC_RESETTING, &adapter->state))
569 usleep_range(1000, 2000);
570
571 if (!netif_running(adapter->netdev)) {
572 for (i = 0; i < adapter->num_tx_queues; i++)
573 adapter->tx_ring[i]->count = new_tx_count;
574 for (i = 0; i < adapter->num_rx_queues; i++)
575 adapter->rx_ring[i]->count = new_rx_count;
576 adapter->tx_ring_count = new_tx_count;
577 adapter->rx_ring_count = new_rx_count;
578 goto clear_reset;
579 }
580
581 if (adapter->num_tx_queues > adapter->num_rx_queues)
582 temp_ring = vmalloc(array_size(sizeof(struct igc_ring),
583 adapter->num_tx_queues));
584 else
585 temp_ring = vmalloc(array_size(sizeof(struct igc_ring),
586 adapter->num_rx_queues));
587
588 if (!temp_ring) {
589 err = -ENOMEM;
590 goto clear_reset;
591 }
592
593 igc_down(adapter);
594
595 /* We can't just free everything and then setup again,
596 * because the ISRs in MSI-X mode get passed pointers
597 * to the Tx and Rx ring structs.
598 */
599 if (new_tx_count != adapter->tx_ring_count) {
600 for (i = 0; i < adapter->num_tx_queues; i++) {
601 memcpy(&temp_ring[i], adapter->tx_ring[i],
602 sizeof(struct igc_ring));
603
604 temp_ring[i].count = new_tx_count;
605 err = igc_setup_tx_resources(&temp_ring[i]);
606 if (err) {
607 while (i) {
608 i--;
609 igc_free_tx_resources(&temp_ring[i]);
610 }
611 goto err_setup;
612 }
613 }
614
615 for (i = 0; i < adapter->num_tx_queues; i++) {
616 igc_free_tx_resources(adapter->tx_ring[i]);
617
618 memcpy(adapter->tx_ring[i], &temp_ring[i],
619 sizeof(struct igc_ring));
620 }
621
622 adapter->tx_ring_count = new_tx_count;
623 }
624
625 if (new_rx_count != adapter->rx_ring_count) {
626 for (i = 0; i < adapter->num_rx_queues; i++) {
627 memcpy(&temp_ring[i], adapter->rx_ring[i],
628 sizeof(struct igc_ring));
629
630 temp_ring[i].count = new_rx_count;
631 err = igc_setup_rx_resources(&temp_ring[i]);
632 if (err) {
633 while (i) {
634 i--;
635 igc_free_rx_resources(&temp_ring[i]);
636 }
637 goto err_setup;
638 }
639 }
640
641 for (i = 0; i < adapter->num_rx_queues; i++) {
642 igc_free_rx_resources(adapter->rx_ring[i]);
643
644 memcpy(adapter->rx_ring[i], &temp_ring[i],
645 sizeof(struct igc_ring));
646 }
647
648 adapter->rx_ring_count = new_rx_count;
649 }
650 err_setup:
651 igc_up(adapter);
652 vfree(temp_ring);
653 clear_reset:
654 clear_bit(__IGC_RESETTING, &adapter->state);
655 return err;
656 }
657
658 static void igc_get_pauseparam(struct net_device *netdev,
659 struct ethtool_pauseparam *pause)
660 {
661 struct igc_adapter *adapter = netdev_priv(netdev);
662 struct igc_hw *hw = &adapter->hw;
663
664 pause->autoneg =
665 (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);
666
667 if (hw->fc.current_mode == igc_fc_rx_pause) {
668 pause->rx_pause = 1;
669 } else if (hw->fc.current_mode == igc_fc_tx_pause) {
670 pause->tx_pause = 1;
671 } else if (hw->fc.current_mode == igc_fc_full) {
672 pause->rx_pause = 1;
673 pause->tx_pause = 1;
674 }
675 }
676
677 static int igc_set_pauseparam(struct net_device *netdev,
678 struct ethtool_pauseparam *pause)
679 {
680 struct igc_adapter *adapter = netdev_priv(netdev);
681 struct igc_hw *hw = &adapter->hw;
682 int retval = 0;
683
684 adapter->fc_autoneg = pause->autoneg;
685
686 while (test_and_set_bit(__IGC_RESETTING, &adapter->state))
687 usleep_range(1000, 2000);
688
689 if (adapter->fc_autoneg == AUTONEG_ENABLE) {
690 hw->fc.requested_mode = igc_fc_default;
691 if (netif_running(adapter->netdev)) {
692 igc_down(adapter);
693 igc_up(adapter);
694 } else {
695 igc_reset(adapter);
696 }
697 } else {
698 if (pause->rx_pause && pause->tx_pause)
699 hw->fc.requested_mode = igc_fc_full;
700 else if (pause->rx_pause && !pause->tx_pause)
701 hw->fc.requested_mode = igc_fc_rx_pause;
702 else if (!pause->rx_pause && pause->tx_pause)
703 hw->fc.requested_mode = igc_fc_tx_pause;
704 else if (!pause->rx_pause && !pause->tx_pause)
705 hw->fc.requested_mode = igc_fc_none;
706
707 hw->fc.current_mode = hw->fc.requested_mode;
708
709 retval = ((hw->phy.media_type == igc_media_type_copper) ?
710 igc_force_mac_fc(hw) : igc_setup_link(hw));
711 }
712
713 clear_bit(__IGC_RESETTING, &adapter->state);
714 return retval;
715 }
716
717 static void igc_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
718 {
719 struct igc_adapter *adapter = netdev_priv(netdev);
720 u8 *p = data;
721 int i;
722
723 switch (stringset) {
724 case ETH_SS_TEST:
725 memcpy(data, *igc_gstrings_test,
726 IGC_TEST_LEN * ETH_GSTRING_LEN);
727 break;
728 case ETH_SS_STATS:
729 for (i = 0; i < IGC_GLOBAL_STATS_LEN; i++) {
730 memcpy(p, igc_gstrings_stats[i].stat_string,
731 ETH_GSTRING_LEN);
732 p += ETH_GSTRING_LEN;
733 }
734 for (i = 0; i < IGC_NETDEV_STATS_LEN; i++) {
735 memcpy(p, igc_gstrings_net_stats[i].stat_string,
736 ETH_GSTRING_LEN);
737 p += ETH_GSTRING_LEN;
738 }
739 for (i = 0; i < adapter->num_tx_queues; i++) {
740 sprintf(p, "tx_queue_%u_packets", i);
741 p += ETH_GSTRING_LEN;
742 sprintf(p, "tx_queue_%u_bytes", i);
743 p += ETH_GSTRING_LEN;
744 sprintf(p, "tx_queue_%u_restart", i);
745 p += ETH_GSTRING_LEN;
746 }
747 for (i = 0; i < adapter->num_rx_queues; i++) {
748 sprintf(p, "rx_queue_%u_packets", i);
749 p += ETH_GSTRING_LEN;
750 sprintf(p, "rx_queue_%u_bytes", i);
751 p += ETH_GSTRING_LEN;
752 sprintf(p, "rx_queue_%u_drops", i);
753 p += ETH_GSTRING_LEN;
754 sprintf(p, "rx_queue_%u_csum_err", i);
755 p += ETH_GSTRING_LEN;
756 sprintf(p, "rx_queue_%u_alloc_failed", i);
757 p += ETH_GSTRING_LEN;
758 }
759 /* BUG_ON(p - data != IGC_STATS_LEN * ETH_GSTRING_LEN); */
760 break;
761 case ETH_SS_PRIV_FLAGS:
762 memcpy(data, igc_priv_flags_strings,
763 IGC_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN);
764 break;
765 }
766 }
767
768 static int igc_get_sset_count(struct net_device *netdev, int sset)
769 {
770 switch (sset) {
771 case ETH_SS_STATS:
772 return IGC_STATS_LEN;
773 case ETH_SS_TEST:
774 return IGC_TEST_LEN;
775 case ETH_SS_PRIV_FLAGS:
776 return IGC_PRIV_FLAGS_STR_LEN;
777 default:
778 return -ENOTSUPP;
779 }
780 }
781
782 static void igc_get_ethtool_stats(struct net_device *netdev,
783 struct ethtool_stats *stats, u64 *data)
784 {
785 struct igc_adapter *adapter = netdev_priv(netdev);
786 struct rtnl_link_stats64 *net_stats = &adapter->stats64;
787 unsigned int start;
788 struct igc_ring *ring;
789 int i, j;
790 char *p;
791
792 spin_lock(&adapter->stats64_lock);
793 igc_update_stats(adapter);
794
795 for (i = 0; i < IGC_GLOBAL_STATS_LEN; i++) {
796 p = (char *)adapter + igc_gstrings_stats[i].stat_offset;
797 data[i] = (igc_gstrings_stats[i].sizeof_stat ==
798 sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
799 }
800 for (j = 0; j < IGC_NETDEV_STATS_LEN; j++, i++) {
801 p = (char *)net_stats + igc_gstrings_net_stats[j].stat_offset;
802 data[i] = (igc_gstrings_net_stats[j].sizeof_stat ==
803 sizeof(u64)) ? *(u64 *)p : *(u32 *)p;
804 }
805 for (j = 0; j < adapter->num_tx_queues; j++) {
806 u64 restart2;
807
808 ring = adapter->tx_ring[j];
809 do {
810 start = u64_stats_fetch_begin_irq(&ring->tx_syncp);
811 data[i] = ring->tx_stats.packets;
812 data[i + 1] = ring->tx_stats.bytes;
813 data[i + 2] = ring->tx_stats.restart_queue;
814 } while (u64_stats_fetch_retry_irq(&ring->tx_syncp, start));
815 do {
816 start = u64_stats_fetch_begin_irq(&ring->tx_syncp2);
817 restart2 = ring->tx_stats.restart_queue2;
818 } while (u64_stats_fetch_retry_irq(&ring->tx_syncp2, start));
819 data[i + 2] += restart2;
820
821 i += IGC_TX_QUEUE_STATS_LEN;
822 }
823 for (j = 0; j < adapter->num_rx_queues; j++) {
824 ring = adapter->rx_ring[j];
825 do {
826 start = u64_stats_fetch_begin_irq(&ring->rx_syncp);
827 data[i] = ring->rx_stats.packets;
828 data[i + 1] = ring->rx_stats.bytes;
829 data[i + 2] = ring->rx_stats.drops;
830 data[i + 3] = ring->rx_stats.csum_err;
831 data[i + 4] = ring->rx_stats.alloc_failed;
832 } while (u64_stats_fetch_retry_irq(&ring->rx_syncp, start));
833 i += IGC_RX_QUEUE_STATS_LEN;
834 }
835 spin_unlock(&adapter->stats64_lock);
836 }
837
838 static int igc_get_coalesce(struct net_device *netdev,
839 struct ethtool_coalesce *ec)
840 {
841 struct igc_adapter *adapter = netdev_priv(netdev);
842
843 if (adapter->rx_itr_setting <= 3)
844 ec->rx_coalesce_usecs = adapter->rx_itr_setting;
845 else
846 ec->rx_coalesce_usecs = adapter->rx_itr_setting >> 2;
847
848 if (!(adapter->flags & IGC_FLAG_QUEUE_PAIRS)) {
849 if (adapter->tx_itr_setting <= 3)
850 ec->tx_coalesce_usecs = adapter->tx_itr_setting;
851 else
852 ec->tx_coalesce_usecs = adapter->tx_itr_setting >> 2;
853 }
854
855 return 0;
856 }
857
858 static int igc_set_coalesce(struct net_device *netdev,
859 struct ethtool_coalesce *ec)
860 {
861 struct igc_adapter *adapter = netdev_priv(netdev);
862 int i;
863
864 if (ec->rx_coalesce_usecs > IGC_MAX_ITR_USECS ||
865 (ec->rx_coalesce_usecs > 3 &&
866 ec->rx_coalesce_usecs < IGC_MIN_ITR_USECS) ||
867 ec->rx_coalesce_usecs == 2)
868 return -EINVAL;
869
870 if (ec->tx_coalesce_usecs > IGC_MAX_ITR_USECS ||
871 (ec->tx_coalesce_usecs > 3 &&
872 ec->tx_coalesce_usecs < IGC_MIN_ITR_USECS) ||
873 ec->tx_coalesce_usecs == 2)
874 return -EINVAL;
875
876 if ((adapter->flags & IGC_FLAG_QUEUE_PAIRS) && ec->tx_coalesce_usecs)
877 return -EINVAL;
878
879 /* If ITR is disabled, disable DMAC */
880 if (ec->rx_coalesce_usecs == 0) {
881 if (adapter->flags & IGC_FLAG_DMAC)
882 adapter->flags &= ~IGC_FLAG_DMAC;
883 }
884
885 /* convert to rate of irq's per second */
886 if (ec->rx_coalesce_usecs && ec->rx_coalesce_usecs <= 3)
887 adapter->rx_itr_setting = ec->rx_coalesce_usecs;
888 else
889 adapter->rx_itr_setting = ec->rx_coalesce_usecs << 2;
890
891 /* convert to rate of irq's per second */
892 if (adapter->flags & IGC_FLAG_QUEUE_PAIRS)
893 adapter->tx_itr_setting = adapter->rx_itr_setting;
894 else if (ec->tx_coalesce_usecs && ec->tx_coalesce_usecs <= 3)
895 adapter->tx_itr_setting = ec->tx_coalesce_usecs;
896 else
897 adapter->tx_itr_setting = ec->tx_coalesce_usecs << 2;
898
899 for (i = 0; i < adapter->num_q_vectors; i++) {
900 struct igc_q_vector *q_vector = adapter->q_vector[i];
901
902 q_vector->tx.work_limit = adapter->tx_work_limit;
903 if (q_vector->rx.ring)
904 q_vector->itr_val = adapter->rx_itr_setting;
905 else
906 q_vector->itr_val = adapter->tx_itr_setting;
907 if (q_vector->itr_val && q_vector->itr_val <= 3)
908 q_vector->itr_val = IGC_START_ITR;
909 q_vector->set_itr = 1;
910 }
911
912 return 0;
913 }
914
915 #define ETHER_TYPE_FULL_MASK ((__force __be16)~0)
916 static int igc_get_ethtool_nfc_entry(struct igc_adapter *adapter,
917 struct ethtool_rxnfc *cmd)
918 {
919 struct ethtool_rx_flow_spec *fsp = &cmd->fs;
920 struct igc_nfc_filter *rule = NULL;
921
922 /* report total rule count */
923 cmd->data = IGC_MAX_RXNFC_FILTERS;
924
925 hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) {
926 if (fsp->location <= rule->sw_idx)
927 break;
928 }
929
930 if (!rule || fsp->location != rule->sw_idx)
931 return -EINVAL;
932
933 if (rule->filter.match_flags) {
934 fsp->flow_type = ETHER_FLOW;
935 fsp->ring_cookie = rule->action;
936 if (rule->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) {
937 fsp->h_u.ether_spec.h_proto = rule->filter.etype;
938 fsp->m_u.ether_spec.h_proto = ETHER_TYPE_FULL_MASK;
939 }
940 if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) {
941 fsp->flow_type |= FLOW_EXT;
942 fsp->h_ext.vlan_tci = rule->filter.vlan_tci;
943 fsp->m_ext.vlan_tci = htons(VLAN_PRIO_MASK);
944 }
945 if (rule->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) {
946 ether_addr_copy(fsp->h_u.ether_spec.h_dest,
947 rule->filter.dst_addr);
948 /* As we only support matching by the full
949 * mask, return the mask to userspace
950 */
951 eth_broadcast_addr(fsp->m_u.ether_spec.h_dest);
952 }
953 if (rule->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) {
954 ether_addr_copy(fsp->h_u.ether_spec.h_source,
955 rule->filter.src_addr);
956 /* As we only support matching by the full
957 * mask, return the mask to userspace
958 */
959 eth_broadcast_addr(fsp->m_u.ether_spec.h_source);
960 }
961
962 return 0;
963 }
964 return -EINVAL;
965 }
966
967 static int igc_get_ethtool_nfc_all(struct igc_adapter *adapter,
968 struct ethtool_rxnfc *cmd,
969 u32 *rule_locs)
970 {
971 struct igc_nfc_filter *rule;
972 int cnt = 0;
973
974 /* report total rule count */
975 cmd->data = IGC_MAX_RXNFC_FILTERS;
976
977 hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) {
978 if (cnt == cmd->rule_cnt)
979 return -EMSGSIZE;
980 rule_locs[cnt] = rule->sw_idx;
981 cnt++;
982 }
983
984 cmd->rule_cnt = cnt;
985
986 return 0;
987 }
988
989 static int igc_get_rss_hash_opts(struct igc_adapter *adapter,
990 struct ethtool_rxnfc *cmd)
991 {
992 cmd->data = 0;
993
994 /* Report default options for RSS on igc */
995 switch (cmd->flow_type) {
996 case TCP_V4_FLOW:
997 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
998 /* Fall through */
999 case UDP_V4_FLOW:
1000 if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV4_UDP)
1001 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1002 /* Fall through */
1003 case SCTP_V4_FLOW:
1004 /* Fall through */
1005 case AH_ESP_V4_FLOW:
1006 /* Fall through */
1007 case AH_V4_FLOW:
1008 /* Fall through */
1009 case ESP_V4_FLOW:
1010 /* Fall through */
1011 case IPV4_FLOW:
1012 cmd->data |= RXH_IP_SRC | RXH_IP_DST;
1013 break;
1014 case TCP_V6_FLOW:
1015 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1016 /* Fall through */
1017 case UDP_V6_FLOW:
1018 if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV6_UDP)
1019 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
1020 /* Fall through */
1021 case SCTP_V6_FLOW:
1022 /* Fall through */
1023 case AH_ESP_V6_FLOW:
1024 /* Fall through */
1025 case AH_V6_FLOW:
1026 /* Fall through */
1027 case ESP_V6_FLOW:
1028 /* Fall through */
1029 case IPV6_FLOW:
1030 cmd->data |= RXH_IP_SRC | RXH_IP_DST;
1031 break;
1032 default:
1033 return -EINVAL;
1034 }
1035
1036 return 0;
1037 }
1038
1039 static int igc_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
1040 u32 *rule_locs)
1041 {
1042 struct igc_adapter *adapter = netdev_priv(dev);
1043 int ret = -EOPNOTSUPP;
1044
1045 switch (cmd->cmd) {
1046 case ETHTOOL_GRXRINGS:
1047 cmd->data = adapter->num_rx_queues;
1048 ret = 0;
1049 break;
1050 case ETHTOOL_GRXCLSRLCNT:
1051 cmd->rule_cnt = adapter->nfc_filter_count;
1052 ret = 0;
1053 break;
1054 case ETHTOOL_GRXCLSRULE:
1055 ret = igc_get_ethtool_nfc_entry(adapter, cmd);
1056 break;
1057 case ETHTOOL_GRXCLSRLALL:
1058 ret = igc_get_ethtool_nfc_all(adapter, cmd, rule_locs);
1059 break;
1060 case ETHTOOL_GRXFH:
1061 ret = igc_get_rss_hash_opts(adapter, cmd);
1062 break;
1063 default:
1064 break;
1065 }
1066
1067 return ret;
1068 }
1069
1070 #define UDP_RSS_FLAGS (IGC_FLAG_RSS_FIELD_IPV4_UDP | \
1071 IGC_FLAG_RSS_FIELD_IPV6_UDP)
1072 static int igc_set_rss_hash_opt(struct igc_adapter *adapter,
1073 struct ethtool_rxnfc *nfc)
1074 {
1075 u32 flags = adapter->flags;
1076
1077 /* RSS does not support anything other than hashing
1078 * to queues on src and dst IPs and ports
1079 */
1080 if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST |
1081 RXH_L4_B_0_1 | RXH_L4_B_2_3))
1082 return -EINVAL;
1083
1084 switch (nfc->flow_type) {
1085 case TCP_V4_FLOW:
1086 case TCP_V6_FLOW:
1087 if (!(nfc->data & RXH_IP_SRC) ||
1088 !(nfc->data & RXH_IP_DST) ||
1089 !(nfc->data & RXH_L4_B_0_1) ||
1090 !(nfc->data & RXH_L4_B_2_3))
1091 return -EINVAL;
1092 break;
1093 case UDP_V4_FLOW:
1094 if (!(nfc->data & RXH_IP_SRC) ||
1095 !(nfc->data & RXH_IP_DST))
1096 return -EINVAL;
1097 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1098 case 0:
1099 flags &= ~IGC_FLAG_RSS_FIELD_IPV4_UDP;
1100 break;
1101 case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
1102 flags |= IGC_FLAG_RSS_FIELD_IPV4_UDP;
1103 break;
1104 default:
1105 return -EINVAL;
1106 }
1107 break;
1108 case UDP_V6_FLOW:
1109 if (!(nfc->data & RXH_IP_SRC) ||
1110 !(nfc->data & RXH_IP_DST))
1111 return -EINVAL;
1112 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) {
1113 case 0:
1114 flags &= ~IGC_FLAG_RSS_FIELD_IPV6_UDP;
1115 break;
1116 case (RXH_L4_B_0_1 | RXH_L4_B_2_3):
1117 flags |= IGC_FLAG_RSS_FIELD_IPV6_UDP;
1118 break;
1119 default:
1120 return -EINVAL;
1121 }
1122 break;
1123 case AH_ESP_V4_FLOW:
1124 case AH_V4_FLOW:
1125 case ESP_V4_FLOW:
1126 case SCTP_V4_FLOW:
1127 case AH_ESP_V6_FLOW:
1128 case AH_V6_FLOW:
1129 case ESP_V6_FLOW:
1130 case SCTP_V6_FLOW:
1131 if (!(nfc->data & RXH_IP_SRC) ||
1132 !(nfc->data & RXH_IP_DST) ||
1133 (nfc->data & RXH_L4_B_0_1) ||
1134 (nfc->data & RXH_L4_B_2_3))
1135 return -EINVAL;
1136 break;
1137 default:
1138 return -EINVAL;
1139 }
1140
1141 /* if we changed something we need to update flags */
1142 if (flags != adapter->flags) {
1143 struct igc_hw *hw = &adapter->hw;
1144 u32 mrqc = rd32(IGC_MRQC);
1145
1146 if ((flags & UDP_RSS_FLAGS) &&
1147 !(adapter->flags & UDP_RSS_FLAGS))
1148 dev_err(&adapter->pdev->dev,
1149 "enabling UDP RSS: fragmented packets may arrive out of order to the stack above\n");
1150
1151 adapter->flags = flags;
1152
1153 /* Perform hash on these packet types */
1154 mrqc |= IGC_MRQC_RSS_FIELD_IPV4 |
1155 IGC_MRQC_RSS_FIELD_IPV4_TCP |
1156 IGC_MRQC_RSS_FIELD_IPV6 |
1157 IGC_MRQC_RSS_FIELD_IPV6_TCP;
1158
1159 mrqc &= ~(IGC_MRQC_RSS_FIELD_IPV4_UDP |
1160 IGC_MRQC_RSS_FIELD_IPV6_UDP);
1161
1162 if (flags & IGC_FLAG_RSS_FIELD_IPV4_UDP)
1163 mrqc |= IGC_MRQC_RSS_FIELD_IPV4_UDP;
1164
1165 if (flags & IGC_FLAG_RSS_FIELD_IPV6_UDP)
1166 mrqc |= IGC_MRQC_RSS_FIELD_IPV6_UDP;
1167
1168 wr32(IGC_MRQC, mrqc);
1169 }
1170
1171 return 0;
1172 }
1173
1174 static int igc_rxnfc_write_etype_filter(struct igc_adapter *adapter,
1175 struct igc_nfc_filter *input)
1176 {
1177 struct igc_hw *hw = &adapter->hw;
1178 u8 i;
1179 u32 etqf;
1180 u16 etype;
1181
1182 /* find an empty etype filter register */
1183 for (i = 0; i < MAX_ETYPE_FILTER; ++i) {
1184 if (!adapter->etype_bitmap[i])
1185 break;
1186 }
1187 if (i == MAX_ETYPE_FILTER) {
1188 dev_err(&adapter->pdev->dev, "ethtool -N: etype filters are all used.\n");
1189 return -EINVAL;
1190 }
1191
1192 adapter->etype_bitmap[i] = true;
1193
1194 etqf = rd32(IGC_ETQF(i));
1195 etype = ntohs(input->filter.etype & ETHER_TYPE_FULL_MASK);
1196
1197 etqf |= IGC_ETQF_FILTER_ENABLE;
1198 etqf &= ~IGC_ETQF_ETYPE_MASK;
1199 etqf |= (etype & IGC_ETQF_ETYPE_MASK);
1200
1201 etqf &= ~IGC_ETQF_QUEUE_MASK;
1202 etqf |= ((input->action << IGC_ETQF_QUEUE_SHIFT)
1203 & IGC_ETQF_QUEUE_MASK);
1204 etqf |= IGC_ETQF_QUEUE_ENABLE;
1205
1206 wr32(IGC_ETQF(i), etqf);
1207
1208 input->etype_reg_index = i;
1209
1210 return 0;
1211 }
1212
1213 static int igc_rxnfc_write_vlan_prio_filter(struct igc_adapter *adapter,
1214 struct igc_nfc_filter *input)
1215 {
1216 struct igc_hw *hw = &adapter->hw;
1217 u8 vlan_priority;
1218 u16 queue_index;
1219 u32 vlapqf;
1220
1221 vlapqf = rd32(IGC_VLAPQF);
1222 vlan_priority = (ntohs(input->filter.vlan_tci) & VLAN_PRIO_MASK)
1223 >> VLAN_PRIO_SHIFT;
1224 queue_index = (vlapqf >> (vlan_priority * 4)) & IGC_VLAPQF_QUEUE_MASK;
1225
1226 /* check whether this vlan prio is already set */
1227 if (vlapqf & IGC_VLAPQF_P_VALID(vlan_priority) &&
1228 queue_index != input->action) {
1229 dev_err(&adapter->pdev->dev, "ethtool rxnfc set vlan prio filter failed.\n");
1230 return -EEXIST;
1231 }
1232
1233 vlapqf |= IGC_VLAPQF_P_VALID(vlan_priority);
1234 vlapqf |= IGC_VLAPQF_QUEUE_SEL(vlan_priority, input->action);
1235
1236 wr32(IGC_VLAPQF, vlapqf);
1237
1238 return 0;
1239 }
1240
1241 int igc_add_filter(struct igc_adapter *adapter, struct igc_nfc_filter *input)
1242 {
1243 struct igc_hw *hw = &adapter->hw;
1244 int err = -EINVAL;
1245
1246 if (hw->mac.type == igc_i225 &&
1247 !(input->filter.match_flags & ~IGC_FILTER_FLAG_SRC_MAC_ADDR)) {
1248 dev_err(&adapter->pdev->dev,
1249 "i225 doesn't support flow classification rules specifying only source addresses.\n");
1250 return -EOPNOTSUPP;
1251 }
1252
1253 if (input->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) {
1254 err = igc_rxnfc_write_etype_filter(adapter, input);
1255 if (err)
1256 return err;
1257 }
1258
1259 if (input->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) {
1260 err = igc_add_mac_steering_filter(adapter,
1261 input->filter.dst_addr,
1262 input->action, 0);
1263 err = min_t(int, err, 0);
1264 if (err)
1265 return err;
1266 }
1267
1268 if (input->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) {
1269 err = igc_add_mac_steering_filter(adapter,
1270 input->filter.src_addr,
1271 input->action,
1272 IGC_MAC_STATE_SRC_ADDR);
1273 err = min_t(int, err, 0);
1274 if (err)
1275 return err;
1276 }
1277
1278 if (input->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI)
1279 err = igc_rxnfc_write_vlan_prio_filter(adapter, input);
1280
1281 return err;
1282 }
1283
1284 static void igc_clear_etype_filter_regs(struct igc_adapter *adapter,
1285 u16 reg_index)
1286 {
1287 struct igc_hw *hw = &adapter->hw;
1288 u32 etqf = rd32(IGC_ETQF(reg_index));
1289
1290 etqf &= ~IGC_ETQF_QUEUE_ENABLE;
1291 etqf &= ~IGC_ETQF_QUEUE_MASK;
1292 etqf &= ~IGC_ETQF_FILTER_ENABLE;
1293
1294 wr32(IGC_ETQF(reg_index), etqf);
1295
1296 adapter->etype_bitmap[reg_index] = false;
1297 }
1298
1299 static void igc_clear_vlan_prio_filter(struct igc_adapter *adapter,
1300 u16 vlan_tci)
1301 {
1302 struct igc_hw *hw = &adapter->hw;
1303 u8 vlan_priority;
1304 u32 vlapqf;
1305
1306 vlan_priority = (vlan_tci & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
1307
1308 vlapqf = rd32(IGC_VLAPQF);
1309 vlapqf &= ~IGC_VLAPQF_P_VALID(vlan_priority);
1310 vlapqf &= ~IGC_VLAPQF_QUEUE_SEL(vlan_priority,
1311 IGC_VLAPQF_QUEUE_MASK);
1312
1313 wr32(IGC_VLAPQF, vlapqf);
1314 }
1315
1316 int igc_erase_filter(struct igc_adapter *adapter, struct igc_nfc_filter *input)
1317 {
1318 if (input->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE)
1319 igc_clear_etype_filter_regs(adapter,
1320 input->etype_reg_index);
1321
1322 if (input->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI)
1323 igc_clear_vlan_prio_filter(adapter,
1324 ntohs(input->filter.vlan_tci));
1325
1326 if (input->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR)
1327 igc_del_mac_steering_filter(adapter, input->filter.src_addr,
1328 input->action,
1329 IGC_MAC_STATE_SRC_ADDR);
1330
1331 if (input->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR)
1332 igc_del_mac_steering_filter(adapter, input->filter.dst_addr,
1333 input->action, 0);
1334
1335 return 0;
1336 }
1337
1338 static int igc_update_ethtool_nfc_entry(struct igc_adapter *adapter,
1339 struct igc_nfc_filter *input,
1340 u16 sw_idx)
1341 {
1342 struct igc_nfc_filter *rule, *parent;
1343 int err = -EINVAL;
1344
1345 parent = NULL;
1346 rule = NULL;
1347
1348 hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) {
1349 /* hash found, or no matching entry */
1350 if (rule->sw_idx >= sw_idx)
1351 break;
1352 parent = rule;
1353 }
1354
1355 /* if there is an old rule occupying our place remove it */
1356 if (rule && rule->sw_idx == sw_idx) {
1357 if (!input)
1358 err = igc_erase_filter(adapter, rule);
1359
1360 hlist_del(&rule->nfc_node);
1361 kfree(rule);
1362 adapter->nfc_filter_count--;
1363 }
1364
1365 /* If no input this was a delete, err should be 0 if a rule was
1366 * successfully found and removed from the list else -EINVAL
1367 */
1368 if (!input)
1369 return err;
1370
1371 /* initialize node */
1372 INIT_HLIST_NODE(&input->nfc_node);
1373
1374 /* add filter to the list */
1375 if (parent)
1376 hlist_add_behind(&input->nfc_node, &parent->nfc_node);
1377 else
1378 hlist_add_head(&input->nfc_node, &adapter->nfc_filter_list);
1379
1380 /* update counts */
1381 adapter->nfc_filter_count++;
1382
1383 return 0;
1384 }
1385
1386 static int igc_add_ethtool_nfc_entry(struct igc_adapter *adapter,
1387 struct ethtool_rxnfc *cmd)
1388 {
1389 struct net_device *netdev = adapter->netdev;
1390 struct ethtool_rx_flow_spec *fsp =
1391 (struct ethtool_rx_flow_spec *)&cmd->fs;
1392 struct igc_nfc_filter *input, *rule;
1393 int err = 0;
1394
1395 if (!(netdev->hw_features & NETIF_F_NTUPLE))
1396 return -EOPNOTSUPP;
1397
1398 /* Don't allow programming if the action is a queue greater than
1399 * the number of online Rx queues.
1400 */
1401 if (fsp->ring_cookie == RX_CLS_FLOW_DISC ||
1402 fsp->ring_cookie >= adapter->num_rx_queues) {
1403 dev_err(&adapter->pdev->dev, "ethtool -N: The specified action is invalid\n");
1404 return -EINVAL;
1405 }
1406
1407 /* Don't allow indexes to exist outside of available space */
1408 if (fsp->location >= IGC_MAX_RXNFC_FILTERS) {
1409 dev_err(&adapter->pdev->dev, "Location out of range\n");
1410 return -EINVAL;
1411 }
1412
1413 if ((fsp->flow_type & ~FLOW_EXT) != ETHER_FLOW)
1414 return -EINVAL;
1415
1416 input = kzalloc(sizeof(*input), GFP_KERNEL);
1417 if (!input)
1418 return -ENOMEM;
1419
1420 if (fsp->m_u.ether_spec.h_proto == ETHER_TYPE_FULL_MASK) {
1421 input->filter.etype = fsp->h_u.ether_spec.h_proto;
1422 input->filter.match_flags = IGC_FILTER_FLAG_ETHER_TYPE;
1423 }
1424
1425 /* Only support matching addresses by the full mask */
1426 if (is_broadcast_ether_addr(fsp->m_u.ether_spec.h_source)) {
1427 input->filter.match_flags |= IGC_FILTER_FLAG_SRC_MAC_ADDR;
1428 ether_addr_copy(input->filter.src_addr,
1429 fsp->h_u.ether_spec.h_source);
1430 }
1431
1432 /* Only support matching addresses by the full mask */
1433 if (is_broadcast_ether_addr(fsp->m_u.ether_spec.h_dest)) {
1434 input->filter.match_flags |= IGC_FILTER_FLAG_DST_MAC_ADDR;
1435 ether_addr_copy(input->filter.dst_addr,
1436 fsp->h_u.ether_spec.h_dest);
1437 }
1438
1439 if ((fsp->flow_type & FLOW_EXT) && fsp->m_ext.vlan_tci) {
1440 if (fsp->m_ext.vlan_tci != htons(VLAN_PRIO_MASK)) {
1441 err = -EINVAL;
1442 goto err_out;
1443 }
1444 input->filter.vlan_tci = fsp->h_ext.vlan_tci;
1445 input->filter.match_flags |= IGC_FILTER_FLAG_VLAN_TCI;
1446 }
1447
1448 input->action = fsp->ring_cookie;
1449 input->sw_idx = fsp->location;
1450
1451 spin_lock(&adapter->nfc_lock);
1452
1453 hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) {
1454 if (!memcmp(&input->filter, &rule->filter,
1455 sizeof(input->filter))) {
1456 err = -EEXIST;
1457 dev_err(&adapter->pdev->dev,
1458 "ethtool: this filter is already set\n");
1459 goto err_out_w_lock;
1460 }
1461 }
1462
1463 err = igc_add_filter(adapter, input);
1464 if (err)
1465 goto err_out_w_lock;
1466
1467 igc_update_ethtool_nfc_entry(adapter, input, input->sw_idx);
1468
1469 spin_unlock(&adapter->nfc_lock);
1470 return 0;
1471
1472 err_out_w_lock:
1473 spin_unlock(&adapter->nfc_lock);
1474 err_out:
1475 kfree(input);
1476 return err;
1477 }
1478
1479 static int igc_del_ethtool_nfc_entry(struct igc_adapter *adapter,
1480 struct ethtool_rxnfc *cmd)
1481 {
1482 struct ethtool_rx_flow_spec *fsp =
1483 (struct ethtool_rx_flow_spec *)&cmd->fs;
1484 int err;
1485
1486 spin_lock(&adapter->nfc_lock);
1487 err = igc_update_ethtool_nfc_entry(adapter, NULL, fsp->location);
1488 spin_unlock(&adapter->nfc_lock);
1489
1490 return err;
1491 }
1492
1493 static int igc_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
1494 {
1495 struct igc_adapter *adapter = netdev_priv(dev);
1496 int ret = -EOPNOTSUPP;
1497
1498 switch (cmd->cmd) {
1499 case ETHTOOL_SRXFH:
1500 ret = igc_set_rss_hash_opt(adapter, cmd);
1501 break;
1502 case ETHTOOL_SRXCLSRLINS:
1503 ret = igc_add_ethtool_nfc_entry(adapter, cmd);
1504 break;
1505 case ETHTOOL_SRXCLSRLDEL:
1506 ret = igc_del_ethtool_nfc_entry(adapter, cmd);
1507 default:
1508 break;
1509 }
1510
1511 return ret;
1512 }
1513
1514 void igc_write_rss_indir_tbl(struct igc_adapter *adapter)
1515 {
1516 struct igc_hw *hw = &adapter->hw;
1517 u32 reg = IGC_RETA(0);
1518 u32 shift = 0;
1519 int i = 0;
1520
1521 while (i < IGC_RETA_SIZE) {
1522 u32 val = 0;
1523 int j;
1524
1525 for (j = 3; j >= 0; j--) {
1526 val <<= 8;
1527 val |= adapter->rss_indir_tbl[i + j];
1528 }
1529
1530 wr32(reg, val << shift);
1531 reg += 4;
1532 i += 4;
1533 }
1534 }
1535
1536 static u32 igc_get_rxfh_indir_size(struct net_device *netdev)
1537 {
1538 return IGC_RETA_SIZE;
1539 }
1540
1541 static int igc_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key,
1542 u8 *hfunc)
1543 {
1544 struct igc_adapter *adapter = netdev_priv(netdev);
1545 int i;
1546
1547 if (hfunc)
1548 *hfunc = ETH_RSS_HASH_TOP;
1549 if (!indir)
1550 return 0;
1551 for (i = 0; i < IGC_RETA_SIZE; i++)
1552 indir[i] = adapter->rss_indir_tbl[i];
1553
1554 return 0;
1555 }
1556
1557 static int igc_set_rxfh(struct net_device *netdev, const u32 *indir,
1558 const u8 *key, const u8 hfunc)
1559 {
1560 struct igc_adapter *adapter = netdev_priv(netdev);
1561 u32 num_queues;
1562 int i;
1563
1564 /* We do not allow change in unsupported parameters */
1565 if (key ||
1566 (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP))
1567 return -EOPNOTSUPP;
1568 if (!indir)
1569 return 0;
1570
1571 num_queues = adapter->rss_queues;
1572
1573 /* Verify user input. */
1574 for (i = 0; i < IGC_RETA_SIZE; i++)
1575 if (indir[i] >= num_queues)
1576 return -EINVAL;
1577
1578 for (i = 0; i < IGC_RETA_SIZE; i++)
1579 adapter->rss_indir_tbl[i] = indir[i];
1580
1581 igc_write_rss_indir_tbl(adapter);
1582
1583 return 0;
1584 }
1585
1586 static unsigned int igc_max_channels(struct igc_adapter *adapter)
1587 {
1588 return igc_get_max_rss_queues(adapter);
1589 }
1590
1591 static void igc_get_channels(struct net_device *netdev,
1592 struct ethtool_channels *ch)
1593 {
1594 struct igc_adapter *adapter = netdev_priv(netdev);
1595
1596 /* Report maximum channels */
1597 ch->max_combined = igc_max_channels(adapter);
1598
1599 /* Report info for other vector */
1600 if (adapter->flags & IGC_FLAG_HAS_MSIX) {
1601 ch->max_other = NON_Q_VECTORS;
1602 ch->other_count = NON_Q_VECTORS;
1603 }
1604
1605 ch->combined_count = adapter->rss_queues;
1606 }
1607
1608 static int igc_set_channels(struct net_device *netdev,
1609 struct ethtool_channels *ch)
1610 {
1611 struct igc_adapter *adapter = netdev_priv(netdev);
1612 unsigned int count = ch->combined_count;
1613 unsigned int max_combined = 0;
1614
1615 /* Verify they are not requesting separate vectors */
1616 if (!count || ch->rx_count || ch->tx_count)
1617 return -EINVAL;
1618
1619 /* Verify other_count is valid and has not been changed */
1620 if (ch->other_count != NON_Q_VECTORS)
1621 return -EINVAL;
1622
1623 /* Verify the number of channels doesn't exceed hw limits */
1624 max_combined = igc_max_channels(adapter);
1625 if (count > max_combined)
1626 return -EINVAL;
1627
1628 if (count != adapter->rss_queues) {
1629 adapter->rss_queues = count;
1630 igc_set_flag_queue_pairs(adapter, max_combined);
1631
1632 /* Hardware has to reinitialize queues and interrupts to
1633 * match the new configuration.
1634 */
1635 return igc_reinit_queues(adapter);
1636 }
1637
1638 return 0;
1639 }
1640
1641 static int igc_get_ts_info(struct net_device *dev,
1642 struct ethtool_ts_info *info)
1643 {
1644 struct igc_adapter *adapter = netdev_priv(dev);
1645
1646 if (adapter->ptp_clock)
1647 info->phc_index = ptp_clock_index(adapter->ptp_clock);
1648 else
1649 info->phc_index = -1;
1650
1651 switch (adapter->hw.mac.type) {
1652 case igc_i225:
1653 info->so_timestamping =
1654 SOF_TIMESTAMPING_TX_SOFTWARE |
1655 SOF_TIMESTAMPING_RX_SOFTWARE |
1656 SOF_TIMESTAMPING_SOFTWARE |
1657 SOF_TIMESTAMPING_TX_HARDWARE |
1658 SOF_TIMESTAMPING_RX_HARDWARE |
1659 SOF_TIMESTAMPING_RAW_HARDWARE;
1660
1661 info->tx_types =
1662 BIT(HWTSTAMP_TX_OFF) |
1663 BIT(HWTSTAMP_TX_ON);
1664
1665 info->rx_filters = BIT(HWTSTAMP_FILTER_NONE);
1666 info->rx_filters |= BIT(HWTSTAMP_FILTER_ALL);
1667
1668 return 0;
1669 default:
1670 return -EOPNOTSUPP;
1671 }
1672 }
1673
1674 static u32 igc_get_priv_flags(struct net_device *netdev)
1675 {
1676 struct igc_adapter *adapter = netdev_priv(netdev);
1677 u32 priv_flags = 0;
1678
1679 if (adapter->flags & IGC_FLAG_RX_LEGACY)
1680 priv_flags |= IGC_PRIV_FLAGS_LEGACY_RX;
1681
1682 return priv_flags;
1683 }
1684
1685 static int igc_set_priv_flags(struct net_device *netdev, u32 priv_flags)
1686 {
1687 struct igc_adapter *adapter = netdev_priv(netdev);
1688 unsigned int flags = adapter->flags;
1689
1690 flags &= ~IGC_FLAG_RX_LEGACY;
1691 if (priv_flags & IGC_PRIV_FLAGS_LEGACY_RX)
1692 flags |= IGC_FLAG_RX_LEGACY;
1693
1694 if (flags != adapter->flags) {
1695 adapter->flags = flags;
1696
1697 /* reset interface to repopulate queues */
1698 if (netif_running(netdev))
1699 igc_reinit_locked(adapter);
1700 }
1701
1702 return 0;
1703 }
1704
1705 static int igc_ethtool_begin(struct net_device *netdev)
1706 {
1707 struct igc_adapter *adapter = netdev_priv(netdev);
1708
1709 pm_runtime_get_sync(&adapter->pdev->dev);
1710 return 0;
1711 }
1712
1713 static void igc_ethtool_complete(struct net_device *netdev)
1714 {
1715 struct igc_adapter *adapter = netdev_priv(netdev);
1716
1717 pm_runtime_put(&adapter->pdev->dev);
1718 }
1719
1720 static int igc_get_link_ksettings(struct net_device *netdev,
1721 struct ethtool_link_ksettings *cmd)
1722 {
1723 struct igc_adapter *adapter = netdev_priv(netdev);
1724 struct igc_hw *hw = &adapter->hw;
1725 u32 status;
1726 u32 speed;
1727
1728 ethtool_link_ksettings_zero_link_mode(cmd, supported);
1729 ethtool_link_ksettings_zero_link_mode(cmd, advertising);
1730
1731 /* supported link modes */
1732 ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Half);
1733 ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Full);
1734 ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Half);
1735 ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Full);
1736 ethtool_link_ksettings_add_link_mode(cmd, supported, 1000baseT_Full);
1737 ethtool_link_ksettings_add_link_mode(cmd, supported, 2500baseT_Full);
1738
1739 /* twisted pair */
1740 cmd->base.port = PORT_TP;
1741 cmd->base.phy_address = hw->phy.addr;
1742
1743 /* advertising link modes */
1744 ethtool_link_ksettings_add_link_mode(cmd, advertising, 10baseT_Half);
1745 ethtool_link_ksettings_add_link_mode(cmd, advertising, 10baseT_Full);
1746 ethtool_link_ksettings_add_link_mode(cmd, advertising, 100baseT_Half);
1747 ethtool_link_ksettings_add_link_mode(cmd, advertising, 100baseT_Full);
1748 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1000baseT_Full);
1749 ethtool_link_ksettings_add_link_mode(cmd, advertising, 2500baseT_Full);
1750
1751 /* set autoneg settings */
1752 if (hw->mac.autoneg == 1) {
1753 ethtool_link_ksettings_add_link_mode(cmd, supported, Autoneg);
1754 ethtool_link_ksettings_add_link_mode(cmd, advertising,
1755 Autoneg);
1756 }
1757
1758 switch (hw->fc.requested_mode) {
1759 case igc_fc_full:
1760 ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause);
1761 break;
1762 case igc_fc_rx_pause:
1763 ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause);
1764 ethtool_link_ksettings_add_link_mode(cmd, advertising,
1765 Asym_Pause);
1766 break;
1767 case igc_fc_tx_pause:
1768 ethtool_link_ksettings_add_link_mode(cmd, advertising,
1769 Asym_Pause);
1770 break;
1771 default:
1772 ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause);
1773 ethtool_link_ksettings_add_link_mode(cmd, advertising,
1774 Asym_Pause);
1775 }
1776
1777 status = rd32(IGC_STATUS);
1778
1779 if (status & IGC_STATUS_LU) {
1780 if (status & IGC_STATUS_SPEED_1000) {
1781 /* For I225, STATUS will indicate 1G speed in both
1782 * 1 Gbps and 2.5 Gbps link modes.
1783 * An additional bit is used
1784 * to differentiate between 1 Gbps and 2.5 Gbps.
1785 */
1786 if (hw->mac.type == igc_i225 &&
1787 (status & IGC_STATUS_SPEED_2500)) {
1788 speed = SPEED_2500;
1789 } else {
1790 speed = SPEED_1000;
1791 }
1792 } else if (status & IGC_STATUS_SPEED_100) {
1793 speed = SPEED_100;
1794 } else {
1795 speed = SPEED_10;
1796 }
1797 if ((status & IGC_STATUS_FD) ||
1798 hw->phy.media_type != igc_media_type_copper)
1799 cmd->base.duplex = DUPLEX_FULL;
1800 else
1801 cmd->base.duplex = DUPLEX_HALF;
1802 } else {
1803 speed = SPEED_UNKNOWN;
1804 cmd->base.duplex = DUPLEX_UNKNOWN;
1805 }
1806 cmd->base.speed = speed;
1807 if (hw->mac.autoneg)
1808 cmd->base.autoneg = AUTONEG_ENABLE;
1809 else
1810 cmd->base.autoneg = AUTONEG_DISABLE;
1811
1812 /* MDI-X => 2; MDI =>1; Invalid =>0 */
1813 if (hw->phy.media_type == igc_media_type_copper)
1814 cmd->base.eth_tp_mdix = hw->phy.is_mdix ? ETH_TP_MDI_X :
1815 ETH_TP_MDI;
1816 else
1817 cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;
1818
1819 if (hw->phy.mdix == AUTO_ALL_MODES)
1820 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;
1821 else
1822 cmd->base.eth_tp_mdix_ctrl = hw->phy.mdix;
1823
1824 return 0;
1825 }
1826
1827 static int igc_set_link_ksettings(struct net_device *netdev,
1828 const struct ethtool_link_ksettings *cmd)
1829 {
1830 struct igc_adapter *adapter = netdev_priv(netdev);
1831 struct igc_hw *hw = &adapter->hw;
1832 u32 advertising;
1833
1834 /* When adapter in resetting mode, autoneg/speed/duplex
1835 * cannot be changed
1836 */
1837 if (igc_check_reset_block(hw)) {
1838 dev_err(&adapter->pdev->dev,
1839 "Cannot change link characteristics when reset is active.\n");
1840 return -EINVAL;
1841 }
1842
1843 /* MDI setting is only allowed when autoneg enabled because
1844 * some hardware doesn't allow MDI setting when speed or
1845 * duplex is forced.
1846 */
1847 if (cmd->base.eth_tp_mdix_ctrl) {
1848 if (cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO &&
1849 cmd->base.autoneg != AUTONEG_ENABLE) {
1850 dev_err(&adapter->pdev->dev, "forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");
1851 return -EINVAL;
1852 }
1853 }
1854
1855 while (test_and_set_bit(__IGC_RESETTING, &adapter->state))
1856 usleep_range(1000, 2000);
1857
1858 ethtool_convert_link_mode_to_legacy_u32(&advertising,
1859 cmd->link_modes.advertising);
1860
1861 if (cmd->base.autoneg == AUTONEG_ENABLE) {
1862 hw->mac.autoneg = 1;
1863 hw->phy.autoneg_advertised = advertising;
1864 if (adapter->fc_autoneg)
1865 hw->fc.requested_mode = igc_fc_default;
1866 } else {
1867 /* calling this overrides forced MDI setting */
1868 dev_info(&adapter->pdev->dev,
1869 "Force mode currently not supported\n");
1870 }
1871
1872 /* MDI-X => 2; MDI => 1; Auto => 3 */
1873 if (cmd->base.eth_tp_mdix_ctrl) {
1874 /* fix up the value for auto (3 => 0) as zero is mapped
1875 * internally to auto
1876 */
1877 if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)
1878 hw->phy.mdix = AUTO_ALL_MODES;
1879 else
1880 hw->phy.mdix = cmd->base.eth_tp_mdix_ctrl;
1881 }
1882
1883 /* reset the link */
1884 if (netif_running(adapter->netdev)) {
1885 igc_down(adapter);
1886 igc_up(adapter);
1887 } else {
1888 igc_reset(adapter);
1889 }
1890
1891 clear_bit(__IGC_RESETTING, &adapter->state);
1892
1893 return 0;
1894 }
1895
1896 static const struct ethtool_ops igc_ethtool_ops = {
1897 .supported_coalesce_params = ETHTOOL_COALESCE_USECS,
1898 .get_drvinfo = igc_get_drvinfo,
1899 .get_regs_len = igc_get_regs_len,
1900 .get_regs = igc_get_regs,
1901 .get_wol = igc_get_wol,
1902 .set_wol = igc_set_wol,
1903 .get_msglevel = igc_get_msglevel,
1904 .set_msglevel = igc_set_msglevel,
1905 .nway_reset = igc_nway_reset,
1906 .get_link = igc_get_link,
1907 .get_eeprom_len = igc_get_eeprom_len,
1908 .get_eeprom = igc_get_eeprom,
1909 .set_eeprom = igc_set_eeprom,
1910 .get_ringparam = igc_get_ringparam,
1911 .set_ringparam = igc_set_ringparam,
1912 .get_pauseparam = igc_get_pauseparam,
1913 .set_pauseparam = igc_set_pauseparam,
1914 .get_strings = igc_get_strings,
1915 .get_sset_count = igc_get_sset_count,
1916 .get_ethtool_stats = igc_get_ethtool_stats,
1917 .get_coalesce = igc_get_coalesce,
1918 .set_coalesce = igc_set_coalesce,
1919 .get_rxnfc = igc_get_rxnfc,
1920 .set_rxnfc = igc_set_rxnfc,
1921 .get_rxfh_indir_size = igc_get_rxfh_indir_size,
1922 .get_rxfh = igc_get_rxfh,
1923 .set_rxfh = igc_set_rxfh,
1924 .get_ts_info = igc_get_ts_info,
1925 .get_channels = igc_get_channels,
1926 .set_channels = igc_set_channels,
1927 .get_priv_flags = igc_get_priv_flags,
1928 .set_priv_flags = igc_set_priv_flags,
1929 .begin = igc_ethtool_begin,
1930 .complete = igc_ethtool_complete,
1931 .get_link_ksettings = igc_get_link_ksettings,
1932 .set_link_ksettings = igc_set_link_ksettings,
1933 };
1934
1935 void igc_set_ethtool_ops(struct net_device *netdev)
1936 {
1937 netdev->ethtool_ops = &igc_ethtool_ops;
1938 }
Linux with added FPC-III support