18c5ad0daSSasha Neftin // SPDX-License-Identifier: GPL-2.0 28c5ad0daSSasha Neftin /* Copyright (c) 2018 Intel Corporation */ 38c5ad0daSSasha Neftin 48c5ad0daSSasha Neftin /* ethtool support for igc */ 56245c848SSasha Neftin #include <linux/if_vlan.h> 68c5ad0daSSasha Neftin #include <linux/pm_runtime.h> 78c5ad0daSSasha Neftin 88c5ad0daSSasha Neftin #include "igc.h" 9f026d8caSVitaly Lifshits #include "igc_diag.h" 108c5ad0daSSasha Neftin 1136b9fea6SSasha Neftin /* forward declaration */ 1236b9fea6SSasha Neftin struct igc_stats { 1336b9fea6SSasha Neftin char stat_string[ETH_GSTRING_LEN]; 1436b9fea6SSasha Neftin int sizeof_stat; 1536b9fea6SSasha Neftin int stat_offset; 1636b9fea6SSasha Neftin }; 1736b9fea6SSasha Neftin 1836b9fea6SSasha Neftin #define IGC_STAT(_name, _stat) { \ 1936b9fea6SSasha Neftin .stat_string = _name, \ 20c593642cSPankaj Bharadiya .sizeof_stat = sizeof_field(struct igc_adapter, _stat), \ 2136b9fea6SSasha Neftin .stat_offset = offsetof(struct igc_adapter, _stat) \ 2236b9fea6SSasha Neftin } 2336b9fea6SSasha Neftin 2436b9fea6SSasha Neftin static const struct igc_stats igc_gstrings_stats[] = { 2536b9fea6SSasha Neftin IGC_STAT("rx_packets", stats.gprc), 2636b9fea6SSasha Neftin IGC_STAT("tx_packets", stats.gptc), 2736b9fea6SSasha Neftin IGC_STAT("rx_bytes", stats.gorc), 2836b9fea6SSasha Neftin IGC_STAT("tx_bytes", stats.gotc), 2936b9fea6SSasha Neftin IGC_STAT("rx_broadcast", stats.bprc), 3036b9fea6SSasha Neftin IGC_STAT("tx_broadcast", stats.bptc), 3136b9fea6SSasha Neftin IGC_STAT("rx_multicast", stats.mprc), 3236b9fea6SSasha Neftin IGC_STAT("tx_multicast", stats.mptc), 3336b9fea6SSasha Neftin IGC_STAT("multicast", stats.mprc), 3436b9fea6SSasha Neftin IGC_STAT("collisions", stats.colc), 3536b9fea6SSasha Neftin IGC_STAT("rx_crc_errors", stats.crcerrs), 3636b9fea6SSasha Neftin IGC_STAT("rx_no_buffer_count", stats.rnbc), 3736b9fea6SSasha Neftin IGC_STAT("rx_missed_errors", stats.mpc), 3836b9fea6SSasha Neftin IGC_STAT("tx_aborted_errors", stats.ecol), 3936b9fea6SSasha Neftin IGC_STAT("tx_carrier_errors", stats.tncrs), 4036b9fea6SSasha Neftin IGC_STAT("tx_window_errors", stats.latecol), 4136b9fea6SSasha Neftin IGC_STAT("tx_abort_late_coll", stats.latecol), 4236b9fea6SSasha Neftin IGC_STAT("tx_deferred_ok", stats.dc), 4336b9fea6SSasha Neftin IGC_STAT("tx_single_coll_ok", stats.scc), 4436b9fea6SSasha Neftin IGC_STAT("tx_multi_coll_ok", stats.mcc), 4536b9fea6SSasha Neftin IGC_STAT("tx_timeout_count", tx_timeout_count), 4636b9fea6SSasha Neftin IGC_STAT("rx_long_length_errors", stats.roc), 4736b9fea6SSasha Neftin IGC_STAT("rx_short_length_errors", stats.ruc), 4836b9fea6SSasha Neftin IGC_STAT("rx_align_errors", stats.algnerrc), 4936b9fea6SSasha Neftin IGC_STAT("tx_tcp_seg_good", stats.tsctc), 5036b9fea6SSasha Neftin IGC_STAT("tx_tcp_seg_failed", stats.tsctfc), 5136b9fea6SSasha Neftin IGC_STAT("rx_flow_control_xon", stats.xonrxc), 5236b9fea6SSasha Neftin IGC_STAT("rx_flow_control_xoff", stats.xoffrxc), 5336b9fea6SSasha Neftin IGC_STAT("tx_flow_control_xon", stats.xontxc), 5436b9fea6SSasha Neftin IGC_STAT("tx_flow_control_xoff", stats.xofftxc), 5536b9fea6SSasha Neftin IGC_STAT("rx_long_byte_count", stats.gorc), 5636b9fea6SSasha Neftin IGC_STAT("tx_dma_out_of_sync", stats.doosync), 5736b9fea6SSasha Neftin IGC_STAT("tx_smbus", stats.mgptc), 5836b9fea6SSasha Neftin IGC_STAT("rx_smbus", stats.mgprc), 5936b9fea6SSasha Neftin IGC_STAT("dropped_smbus", stats.mgpdc), 6036b9fea6SSasha Neftin IGC_STAT("os2bmc_rx_by_bmc", stats.o2bgptc), 6136b9fea6SSasha Neftin IGC_STAT("os2bmc_tx_by_bmc", stats.b2ospc), 6236b9fea6SSasha Neftin IGC_STAT("os2bmc_tx_by_host", stats.o2bspc), 6336b9fea6SSasha Neftin IGC_STAT("os2bmc_rx_by_host", stats.b2ogprc), 6436b9fea6SSasha Neftin IGC_STAT("tx_hwtstamp_timeouts", tx_hwtstamp_timeouts), 6536b9fea6SSasha Neftin IGC_STAT("tx_hwtstamp_skipped", tx_hwtstamp_skipped), 6636b9fea6SSasha Neftin IGC_STAT("rx_hwtstamp_cleared", rx_hwtstamp_cleared), 6736b9fea6SSasha Neftin }; 6836b9fea6SSasha Neftin 6936b9fea6SSasha Neftin #define IGC_NETDEV_STAT(_net_stat) { \ 7036b9fea6SSasha Neftin .stat_string = __stringify(_net_stat), \ 71c593642cSPankaj Bharadiya .sizeof_stat = sizeof_field(struct rtnl_link_stats64, _net_stat), \ 7236b9fea6SSasha Neftin .stat_offset = offsetof(struct rtnl_link_stats64, _net_stat) \ 7336b9fea6SSasha Neftin } 7436b9fea6SSasha Neftin 7536b9fea6SSasha Neftin static const struct igc_stats igc_gstrings_net_stats[] = { 7636b9fea6SSasha Neftin IGC_NETDEV_STAT(rx_errors), 7736b9fea6SSasha Neftin IGC_NETDEV_STAT(tx_errors), 7836b9fea6SSasha Neftin IGC_NETDEV_STAT(tx_dropped), 7936b9fea6SSasha Neftin IGC_NETDEV_STAT(rx_length_errors), 8036b9fea6SSasha Neftin IGC_NETDEV_STAT(rx_over_errors), 8136b9fea6SSasha Neftin IGC_NETDEV_STAT(rx_frame_errors), 8236b9fea6SSasha Neftin IGC_NETDEV_STAT(rx_fifo_errors), 8336b9fea6SSasha Neftin IGC_NETDEV_STAT(tx_fifo_errors), 8436b9fea6SSasha Neftin IGC_NETDEV_STAT(tx_heartbeat_errors) 8536b9fea6SSasha Neftin }; 8636b9fea6SSasha Neftin 8736b9fea6SSasha Neftin enum igc_diagnostics_results { 8836b9fea6SSasha Neftin TEST_REG = 0, 8936b9fea6SSasha Neftin TEST_EEP, 9036b9fea6SSasha Neftin TEST_IRQ, 9136b9fea6SSasha Neftin TEST_LOOP, 9236b9fea6SSasha Neftin TEST_LINK 9336b9fea6SSasha Neftin }; 9436b9fea6SSasha Neftin 9536b9fea6SSasha Neftin static const char igc_gstrings_test[][ETH_GSTRING_LEN] = { 9636b9fea6SSasha Neftin [TEST_REG] = "Register test (offline)", 9736b9fea6SSasha Neftin [TEST_EEP] = "Eeprom test (offline)", 9836b9fea6SSasha Neftin [TEST_IRQ] = "Interrupt test (offline)", 9936b9fea6SSasha Neftin [TEST_LOOP] = "Loopback test (offline)", 10036b9fea6SSasha Neftin [TEST_LINK] = "Link test (on/offline)" 10136b9fea6SSasha Neftin }; 10236b9fea6SSasha Neftin 10336b9fea6SSasha Neftin #define IGC_TEST_LEN (sizeof(igc_gstrings_test) / ETH_GSTRING_LEN) 10436b9fea6SSasha Neftin 10536b9fea6SSasha Neftin #define IGC_GLOBAL_STATS_LEN \ 10636b9fea6SSasha Neftin (sizeof(igc_gstrings_stats) / sizeof(struct igc_stats)) 10736b9fea6SSasha Neftin #define IGC_NETDEV_STATS_LEN \ 10836b9fea6SSasha Neftin (sizeof(igc_gstrings_net_stats) / sizeof(struct igc_stats)) 10936b9fea6SSasha Neftin #define IGC_RX_QUEUE_STATS_LEN \ 11036b9fea6SSasha Neftin (sizeof(struct igc_rx_queue_stats) / sizeof(u64)) 11136b9fea6SSasha Neftin #define IGC_TX_QUEUE_STATS_LEN 3 /* packets, bytes, restart_queue */ 11236b9fea6SSasha Neftin #define IGC_QUEUE_STATS_LEN \ 11336b9fea6SSasha Neftin ((((struct igc_adapter *)netdev_priv(netdev))->num_rx_queues * \ 11436b9fea6SSasha Neftin IGC_RX_QUEUE_STATS_LEN) + \ 11536b9fea6SSasha Neftin (((struct igc_adapter *)netdev_priv(netdev))->num_tx_queues * \ 11636b9fea6SSasha Neftin IGC_TX_QUEUE_STATS_LEN)) 11736b9fea6SSasha Neftin #define IGC_STATS_LEN \ 11836b9fea6SSasha Neftin (IGC_GLOBAL_STATS_LEN + IGC_NETDEV_STATS_LEN + IGC_QUEUE_STATS_LEN) 11936b9fea6SSasha Neftin 1208c5ad0daSSasha Neftin static const char igc_priv_flags_strings[][ETH_GSTRING_LEN] = { 1218c5ad0daSSasha Neftin #define IGC_PRIV_FLAGS_LEGACY_RX BIT(0) 1228c5ad0daSSasha Neftin "legacy-rx", 1238c5ad0daSSasha Neftin }; 1248c5ad0daSSasha Neftin 1258c5ad0daSSasha Neftin #define IGC_PRIV_FLAGS_STR_LEN ARRAY_SIZE(igc_priv_flags_strings) 1268c5ad0daSSasha Neftin 1278c5ad0daSSasha Neftin static void igc_get_drvinfo(struct net_device *netdev, 1288c5ad0daSSasha Neftin struct ethtool_drvinfo *drvinfo) 1298c5ad0daSSasha Neftin { 1308c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 1318c5ad0daSSasha Neftin 1328c5ad0daSSasha Neftin strlcpy(drvinfo->driver, igc_driver_name, sizeof(drvinfo->driver)); 1338c5ad0daSSasha Neftin strlcpy(drvinfo->version, igc_driver_version, sizeof(drvinfo->version)); 1348c5ad0daSSasha Neftin 1358c5ad0daSSasha Neftin /* add fw_version here */ 1368c5ad0daSSasha Neftin strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 1378c5ad0daSSasha Neftin sizeof(drvinfo->bus_info)); 1388c5ad0daSSasha Neftin 1398c5ad0daSSasha Neftin drvinfo->n_priv_flags = IGC_PRIV_FLAGS_STR_LEN; 1408c5ad0daSSasha Neftin } 1418c5ad0daSSasha Neftin 1428c5ad0daSSasha Neftin static int igc_get_regs_len(struct net_device *netdev) 1438c5ad0daSSasha Neftin { 1448c5ad0daSSasha Neftin return IGC_REGS_LEN * sizeof(u32); 1458c5ad0daSSasha Neftin } 1468c5ad0daSSasha Neftin 1478c5ad0daSSasha Neftin static void igc_get_regs(struct net_device *netdev, 1488c5ad0daSSasha Neftin struct ethtool_regs *regs, void *p) 1498c5ad0daSSasha Neftin { 1508c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 1518c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 1528c5ad0daSSasha Neftin u32 *regs_buff = p; 1538c5ad0daSSasha Neftin u8 i; 1548c5ad0daSSasha Neftin 1558c5ad0daSSasha Neftin memset(p, 0, IGC_REGS_LEN * sizeof(u32)); 1568c5ad0daSSasha Neftin 157b8a61ea1SAndre Guedes regs->version = (2u << 24) | (hw->revision_id << 16) | hw->device_id; 1588c5ad0daSSasha Neftin 1598c5ad0daSSasha Neftin /* General Registers */ 1608c5ad0daSSasha Neftin regs_buff[0] = rd32(IGC_CTRL); 1618c5ad0daSSasha Neftin regs_buff[1] = rd32(IGC_STATUS); 1628c5ad0daSSasha Neftin regs_buff[2] = rd32(IGC_CTRL_EXT); 1638c5ad0daSSasha Neftin regs_buff[3] = rd32(IGC_MDIC); 1648c5ad0daSSasha Neftin regs_buff[4] = rd32(IGC_CONNSW); 1658c5ad0daSSasha Neftin 1668c5ad0daSSasha Neftin /* NVM Register */ 1678c5ad0daSSasha Neftin regs_buff[5] = rd32(IGC_EECD); 1688c5ad0daSSasha Neftin 1698c5ad0daSSasha Neftin /* Interrupt */ 1708c5ad0daSSasha Neftin /* Reading EICS for EICR because they read the 1718c5ad0daSSasha Neftin * same but EICS does not clear on read 1728c5ad0daSSasha Neftin */ 1738c5ad0daSSasha Neftin regs_buff[6] = rd32(IGC_EICS); 1748c5ad0daSSasha Neftin regs_buff[7] = rd32(IGC_EICS); 1758c5ad0daSSasha Neftin regs_buff[8] = rd32(IGC_EIMS); 1768c5ad0daSSasha Neftin regs_buff[9] = rd32(IGC_EIMC); 1778c5ad0daSSasha Neftin regs_buff[10] = rd32(IGC_EIAC); 1788c5ad0daSSasha Neftin regs_buff[11] = rd32(IGC_EIAM); 1798c5ad0daSSasha Neftin /* Reading ICS for ICR because they read the 1808c5ad0daSSasha Neftin * same but ICS does not clear on read 1818c5ad0daSSasha Neftin */ 1828c5ad0daSSasha Neftin regs_buff[12] = rd32(IGC_ICS); 1838c5ad0daSSasha Neftin regs_buff[13] = rd32(IGC_ICS); 1848c5ad0daSSasha Neftin regs_buff[14] = rd32(IGC_IMS); 1858c5ad0daSSasha Neftin regs_buff[15] = rd32(IGC_IMC); 1868c5ad0daSSasha Neftin regs_buff[16] = rd32(IGC_IAC); 1878c5ad0daSSasha Neftin regs_buff[17] = rd32(IGC_IAM); 1888c5ad0daSSasha Neftin 1898c5ad0daSSasha Neftin /* Flow Control */ 1908c5ad0daSSasha Neftin regs_buff[18] = rd32(IGC_FCAL); 1918c5ad0daSSasha Neftin regs_buff[19] = rd32(IGC_FCAH); 1928c5ad0daSSasha Neftin regs_buff[20] = rd32(IGC_FCTTV); 1938c5ad0daSSasha Neftin regs_buff[21] = rd32(IGC_FCRTL); 1948c5ad0daSSasha Neftin regs_buff[22] = rd32(IGC_FCRTH); 1958c5ad0daSSasha Neftin regs_buff[23] = rd32(IGC_FCRTV); 1968c5ad0daSSasha Neftin 1978c5ad0daSSasha Neftin /* Receive */ 1988c5ad0daSSasha Neftin regs_buff[24] = rd32(IGC_RCTL); 1998c5ad0daSSasha Neftin regs_buff[25] = rd32(IGC_RXCSUM); 2008c5ad0daSSasha Neftin regs_buff[26] = rd32(IGC_RLPML); 2018c5ad0daSSasha Neftin regs_buff[27] = rd32(IGC_RFCTL); 2028c5ad0daSSasha Neftin 2038c5ad0daSSasha Neftin /* Transmit */ 2048c5ad0daSSasha Neftin regs_buff[28] = rd32(IGC_TCTL); 2058c5ad0daSSasha Neftin regs_buff[29] = rd32(IGC_TIPG); 2068c5ad0daSSasha Neftin 2078c5ad0daSSasha Neftin /* Wake Up */ 2088c5ad0daSSasha Neftin 2098c5ad0daSSasha Neftin /* MAC */ 2108c5ad0daSSasha Neftin 2118c5ad0daSSasha Neftin /* Statistics */ 2128c5ad0daSSasha Neftin regs_buff[30] = adapter->stats.crcerrs; 2138c5ad0daSSasha Neftin regs_buff[31] = adapter->stats.algnerrc; 2148c5ad0daSSasha Neftin regs_buff[32] = adapter->stats.symerrs; 2158c5ad0daSSasha Neftin regs_buff[33] = adapter->stats.rxerrc; 2168c5ad0daSSasha Neftin regs_buff[34] = adapter->stats.mpc; 2178c5ad0daSSasha Neftin regs_buff[35] = adapter->stats.scc; 2188c5ad0daSSasha Neftin regs_buff[36] = adapter->stats.ecol; 2198c5ad0daSSasha Neftin regs_buff[37] = adapter->stats.mcc; 2208c5ad0daSSasha Neftin regs_buff[38] = adapter->stats.latecol; 2218c5ad0daSSasha Neftin regs_buff[39] = adapter->stats.colc; 2228c5ad0daSSasha Neftin regs_buff[40] = adapter->stats.dc; 2238c5ad0daSSasha Neftin regs_buff[41] = adapter->stats.tncrs; 2248c5ad0daSSasha Neftin regs_buff[42] = adapter->stats.sec; 2258c5ad0daSSasha Neftin regs_buff[43] = adapter->stats.htdpmc; 2268c5ad0daSSasha Neftin regs_buff[44] = adapter->stats.rlec; 2278c5ad0daSSasha Neftin regs_buff[45] = adapter->stats.xonrxc; 2288c5ad0daSSasha Neftin regs_buff[46] = adapter->stats.xontxc; 2298c5ad0daSSasha Neftin regs_buff[47] = adapter->stats.xoffrxc; 2308c5ad0daSSasha Neftin regs_buff[48] = adapter->stats.xofftxc; 2318c5ad0daSSasha Neftin regs_buff[49] = adapter->stats.fcruc; 2328c5ad0daSSasha Neftin regs_buff[50] = adapter->stats.prc64; 2338c5ad0daSSasha Neftin regs_buff[51] = adapter->stats.prc127; 2348c5ad0daSSasha Neftin regs_buff[52] = adapter->stats.prc255; 2358c5ad0daSSasha Neftin regs_buff[53] = adapter->stats.prc511; 2368c5ad0daSSasha Neftin regs_buff[54] = adapter->stats.prc1023; 2378c5ad0daSSasha Neftin regs_buff[55] = adapter->stats.prc1522; 2388c5ad0daSSasha Neftin regs_buff[56] = adapter->stats.gprc; 2398c5ad0daSSasha Neftin regs_buff[57] = adapter->stats.bprc; 2408c5ad0daSSasha Neftin regs_buff[58] = adapter->stats.mprc; 2418c5ad0daSSasha Neftin regs_buff[59] = adapter->stats.gptc; 2428c5ad0daSSasha Neftin regs_buff[60] = adapter->stats.gorc; 2438c5ad0daSSasha Neftin regs_buff[61] = adapter->stats.gotc; 2448c5ad0daSSasha Neftin regs_buff[62] = adapter->stats.rnbc; 2458c5ad0daSSasha Neftin regs_buff[63] = adapter->stats.ruc; 2468c5ad0daSSasha Neftin regs_buff[64] = adapter->stats.rfc; 2478c5ad0daSSasha Neftin regs_buff[65] = adapter->stats.roc; 2488c5ad0daSSasha Neftin regs_buff[66] = adapter->stats.rjc; 2498c5ad0daSSasha Neftin regs_buff[67] = adapter->stats.mgprc; 2508c5ad0daSSasha Neftin regs_buff[68] = adapter->stats.mgpdc; 2518c5ad0daSSasha Neftin regs_buff[69] = adapter->stats.mgptc; 2528c5ad0daSSasha Neftin regs_buff[70] = adapter->stats.tor; 2538c5ad0daSSasha Neftin regs_buff[71] = adapter->stats.tot; 2548c5ad0daSSasha Neftin regs_buff[72] = adapter->stats.tpr; 2558c5ad0daSSasha Neftin regs_buff[73] = adapter->stats.tpt; 2568c5ad0daSSasha Neftin regs_buff[74] = adapter->stats.ptc64; 2578c5ad0daSSasha Neftin regs_buff[75] = adapter->stats.ptc127; 2588c5ad0daSSasha Neftin regs_buff[76] = adapter->stats.ptc255; 2598c5ad0daSSasha Neftin regs_buff[77] = adapter->stats.ptc511; 2608c5ad0daSSasha Neftin regs_buff[78] = adapter->stats.ptc1023; 2618c5ad0daSSasha Neftin regs_buff[79] = adapter->stats.ptc1522; 2628c5ad0daSSasha Neftin regs_buff[80] = adapter->stats.mptc; 2638c5ad0daSSasha Neftin regs_buff[81] = adapter->stats.bptc; 2648c5ad0daSSasha Neftin regs_buff[82] = adapter->stats.tsctc; 2658c5ad0daSSasha Neftin regs_buff[83] = adapter->stats.iac; 2668c5ad0daSSasha Neftin regs_buff[84] = adapter->stats.rpthc; 2678c5ad0daSSasha Neftin regs_buff[85] = adapter->stats.hgptc; 2688c5ad0daSSasha Neftin regs_buff[86] = adapter->stats.hgorc; 2698c5ad0daSSasha Neftin regs_buff[87] = adapter->stats.hgotc; 2708c5ad0daSSasha Neftin regs_buff[88] = adapter->stats.lenerrs; 2718c5ad0daSSasha Neftin regs_buff[89] = adapter->stats.scvpc; 2728c5ad0daSSasha Neftin regs_buff[90] = adapter->stats.hrmpc; 2738c5ad0daSSasha Neftin 2748c5ad0daSSasha Neftin for (i = 0; i < 4; i++) 2758c5ad0daSSasha Neftin regs_buff[91 + i] = rd32(IGC_SRRCTL(i)); 2768c5ad0daSSasha Neftin for (i = 0; i < 4; i++) 2778c5ad0daSSasha Neftin regs_buff[95 + i] = rd32(IGC_PSRTYPE(i)); 2788c5ad0daSSasha Neftin for (i = 0; i < 4; i++) 2798c5ad0daSSasha Neftin regs_buff[99 + i] = rd32(IGC_RDBAL(i)); 2808c5ad0daSSasha Neftin for (i = 0; i < 4; i++) 2818c5ad0daSSasha Neftin regs_buff[103 + i] = rd32(IGC_RDBAH(i)); 2828c5ad0daSSasha Neftin for (i = 0; i < 4; i++) 2838c5ad0daSSasha Neftin regs_buff[107 + i] = rd32(IGC_RDLEN(i)); 2848c5ad0daSSasha Neftin for (i = 0; i < 4; i++) 2858c5ad0daSSasha Neftin regs_buff[111 + i] = rd32(IGC_RDH(i)); 2868c5ad0daSSasha Neftin for (i = 0; i < 4; i++) 2878c5ad0daSSasha Neftin regs_buff[115 + i] = rd32(IGC_RDT(i)); 2888c5ad0daSSasha Neftin for (i = 0; i < 4; i++) 2898c5ad0daSSasha Neftin regs_buff[119 + i] = rd32(IGC_RXDCTL(i)); 2908c5ad0daSSasha Neftin 2918c5ad0daSSasha Neftin for (i = 0; i < 10; i++) 2928c5ad0daSSasha Neftin regs_buff[123 + i] = rd32(IGC_EITR(i)); 2938c5ad0daSSasha Neftin for (i = 0; i < 16; i++) 2948c5ad0daSSasha Neftin regs_buff[139 + i] = rd32(IGC_RAL(i)); 2958c5ad0daSSasha Neftin for (i = 0; i < 16; i++) 2968c5ad0daSSasha Neftin regs_buff[145 + i] = rd32(IGC_RAH(i)); 2978c5ad0daSSasha Neftin 2988c5ad0daSSasha Neftin for (i = 0; i < 4; i++) 2998c5ad0daSSasha Neftin regs_buff[149 + i] = rd32(IGC_TDBAL(i)); 3008c5ad0daSSasha Neftin for (i = 0; i < 4; i++) 3018c5ad0daSSasha Neftin regs_buff[152 + i] = rd32(IGC_TDBAH(i)); 3028c5ad0daSSasha Neftin for (i = 0; i < 4; i++) 3038c5ad0daSSasha Neftin regs_buff[156 + i] = rd32(IGC_TDLEN(i)); 3048c5ad0daSSasha Neftin for (i = 0; i < 4; i++) 3058c5ad0daSSasha Neftin regs_buff[160 + i] = rd32(IGC_TDH(i)); 3068c5ad0daSSasha Neftin for (i = 0; i < 4; i++) 3078c5ad0daSSasha Neftin regs_buff[164 + i] = rd32(IGC_TDT(i)); 3088c5ad0daSSasha Neftin for (i = 0; i < 4; i++) 3098c5ad0daSSasha Neftin regs_buff[168 + i] = rd32(IGC_TXDCTL(i)); 310b8a61ea1SAndre Guedes 311b8a61ea1SAndre Guedes /* XXX: Due to a bug few lines above, RAL and RAH registers are 312b8a61ea1SAndre Guedes * overwritten. To preserve the ABI, we write these registers again in 313b8a61ea1SAndre Guedes * regs_buff. 314b8a61ea1SAndre Guedes */ 315b8a61ea1SAndre Guedes for (i = 0; i < 16; i++) 316b8a61ea1SAndre Guedes regs_buff[172 + i] = rd32(IGC_RAL(i)); 317b8a61ea1SAndre Guedes for (i = 0; i < 16; i++) 318b8a61ea1SAndre Guedes regs_buff[188 + i] = rd32(IGC_RAH(i)); 319fbee4760SAndre Guedes 320fbee4760SAndre Guedes regs_buff[204] = rd32(IGC_VLANPQF); 32181e33061SAndre Guedes 32281e33061SAndre Guedes for (i = 0; i < 8; i++) 32381e33061SAndre Guedes regs_buff[205 + i] = rd32(IGC_ETQF(i)); 3248c5ad0daSSasha Neftin } 3258c5ad0daSSasha Neftin 326e055600dSSasha Neftin static void igc_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol) 327e055600dSSasha Neftin { 328e055600dSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 329e055600dSSasha Neftin 330e055600dSSasha Neftin wol->wolopts = 0; 331e055600dSSasha Neftin 332e055600dSSasha Neftin if (!(adapter->flags & IGC_FLAG_WOL_SUPPORTED)) 333e055600dSSasha Neftin return; 334e055600dSSasha Neftin 335e055600dSSasha Neftin wol->supported = WAKE_UCAST | WAKE_MCAST | 336e055600dSSasha Neftin WAKE_BCAST | WAKE_MAGIC | 337e055600dSSasha Neftin WAKE_PHY; 338e055600dSSasha Neftin 339e055600dSSasha Neftin /* apply any specific unsupported masks here */ 340e055600dSSasha Neftin switch (adapter->hw.device_id) { 341e055600dSSasha Neftin default: 342e055600dSSasha Neftin break; 343e055600dSSasha Neftin } 344e055600dSSasha Neftin 345e055600dSSasha Neftin if (adapter->wol & IGC_WUFC_EX) 346e055600dSSasha Neftin wol->wolopts |= WAKE_UCAST; 347e055600dSSasha Neftin if (adapter->wol & IGC_WUFC_MC) 348e055600dSSasha Neftin wol->wolopts |= WAKE_MCAST; 349e055600dSSasha Neftin if (adapter->wol & IGC_WUFC_BC) 350e055600dSSasha Neftin wol->wolopts |= WAKE_BCAST; 351e055600dSSasha Neftin if (adapter->wol & IGC_WUFC_MAG) 352e055600dSSasha Neftin wol->wolopts |= WAKE_MAGIC; 353e055600dSSasha Neftin if (adapter->wol & IGC_WUFC_LNKC) 354e055600dSSasha Neftin wol->wolopts |= WAKE_PHY; 355e055600dSSasha Neftin } 356e055600dSSasha Neftin 357e055600dSSasha Neftin static int igc_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol) 358e055600dSSasha Neftin { 359e055600dSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 360e055600dSSasha Neftin 361e055600dSSasha Neftin if (wol->wolopts & (WAKE_ARP | WAKE_MAGICSECURE | WAKE_FILTER)) 362e055600dSSasha Neftin return -EOPNOTSUPP; 363e055600dSSasha Neftin 364e055600dSSasha Neftin if (!(adapter->flags & IGC_FLAG_WOL_SUPPORTED)) 365e055600dSSasha Neftin return wol->wolopts ? -EOPNOTSUPP : 0; 366e055600dSSasha Neftin 367e055600dSSasha Neftin /* these settings will always override what we currently have */ 368e055600dSSasha Neftin adapter->wol = 0; 369e055600dSSasha Neftin 370e055600dSSasha Neftin if (wol->wolopts & WAKE_UCAST) 371e055600dSSasha Neftin adapter->wol |= IGC_WUFC_EX; 372e055600dSSasha Neftin if (wol->wolopts & WAKE_MCAST) 373e055600dSSasha Neftin adapter->wol |= IGC_WUFC_MC; 374e055600dSSasha Neftin if (wol->wolopts & WAKE_BCAST) 375e055600dSSasha Neftin adapter->wol |= IGC_WUFC_BC; 376e055600dSSasha Neftin if (wol->wolopts & WAKE_MAGIC) 377e055600dSSasha Neftin adapter->wol |= IGC_WUFC_MAG; 378e055600dSSasha Neftin if (wol->wolopts & WAKE_PHY) 379e055600dSSasha Neftin adapter->wol |= IGC_WUFC_LNKC; 380e055600dSSasha Neftin device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol); 381e055600dSSasha Neftin 382e055600dSSasha Neftin return 0; 383e055600dSSasha Neftin } 384e055600dSSasha Neftin 3858c5ad0daSSasha Neftin static u32 igc_get_msglevel(struct net_device *netdev) 3868c5ad0daSSasha Neftin { 3878c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 3888c5ad0daSSasha Neftin 3898c5ad0daSSasha Neftin return adapter->msg_enable; 3908c5ad0daSSasha Neftin } 3918c5ad0daSSasha Neftin 3928c5ad0daSSasha Neftin static void igc_set_msglevel(struct net_device *netdev, u32 data) 3938c5ad0daSSasha Neftin { 3948c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 3958c5ad0daSSasha Neftin 3968c5ad0daSSasha Neftin adapter->msg_enable = data; 3978c5ad0daSSasha Neftin } 3988c5ad0daSSasha Neftin 3998c5ad0daSSasha Neftin static int igc_nway_reset(struct net_device *netdev) 4008c5ad0daSSasha Neftin { 4018c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 4028c5ad0daSSasha Neftin 4038c5ad0daSSasha Neftin if (netif_running(netdev)) 4048c5ad0daSSasha Neftin igc_reinit_locked(adapter); 4058c5ad0daSSasha Neftin return 0; 4068c5ad0daSSasha Neftin } 4078c5ad0daSSasha Neftin 4088c5ad0daSSasha Neftin static u32 igc_get_link(struct net_device *netdev) 4098c5ad0daSSasha Neftin { 4108c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 4118c5ad0daSSasha Neftin struct igc_mac_info *mac = &adapter->hw.mac; 4128c5ad0daSSasha Neftin 4138c5ad0daSSasha Neftin /* If the link is not reported up to netdev, interrupts are disabled, 4148c5ad0daSSasha Neftin * and so the physical link state may have changed since we last 4158c5ad0daSSasha Neftin * looked. Set get_link_status to make sure that the true link 4168c5ad0daSSasha Neftin * state is interrogated, rather than pulling a cached and possibly 4178c5ad0daSSasha Neftin * stale link state from the driver. 4188c5ad0daSSasha Neftin */ 4198c5ad0daSSasha Neftin if (!netif_carrier_ok(netdev)) 4208c5ad0daSSasha Neftin mac->get_link_status = 1; 4218c5ad0daSSasha Neftin 4228c5ad0daSSasha Neftin return igc_has_link(adapter); 4238c5ad0daSSasha Neftin } 4248c5ad0daSSasha Neftin 4258c5ad0daSSasha Neftin static int igc_get_eeprom_len(struct net_device *netdev) 4268c5ad0daSSasha Neftin { 4278c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 4288c5ad0daSSasha Neftin 4298c5ad0daSSasha Neftin return adapter->hw.nvm.word_size * 2; 4308c5ad0daSSasha Neftin } 4318c5ad0daSSasha Neftin 4328c5ad0daSSasha Neftin static int igc_get_eeprom(struct net_device *netdev, 4338c5ad0daSSasha Neftin struct ethtool_eeprom *eeprom, u8 *bytes) 4348c5ad0daSSasha Neftin { 4358c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 4368c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 4378c5ad0daSSasha Neftin int first_word, last_word; 4388c5ad0daSSasha Neftin u16 *eeprom_buff; 4398c5ad0daSSasha Neftin int ret_val = 0; 4408c5ad0daSSasha Neftin u16 i; 4418c5ad0daSSasha Neftin 4428c5ad0daSSasha Neftin if (eeprom->len == 0) 4438c5ad0daSSasha Neftin return -EINVAL; 4448c5ad0daSSasha Neftin 4458c5ad0daSSasha Neftin eeprom->magic = hw->vendor_id | (hw->device_id << 16); 4468c5ad0daSSasha Neftin 4478c5ad0daSSasha Neftin first_word = eeprom->offset >> 1; 4488c5ad0daSSasha Neftin last_word = (eeprom->offset + eeprom->len - 1) >> 1; 4498c5ad0daSSasha Neftin 4508c5ad0daSSasha Neftin eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16), 4518c5ad0daSSasha Neftin GFP_KERNEL); 4528c5ad0daSSasha Neftin if (!eeprom_buff) 4538c5ad0daSSasha Neftin return -ENOMEM; 4548c5ad0daSSasha Neftin 4558c5ad0daSSasha Neftin if (hw->nvm.type == igc_nvm_eeprom_spi) { 4568c5ad0daSSasha Neftin ret_val = hw->nvm.ops.read(hw, first_word, 4578c5ad0daSSasha Neftin last_word - first_word + 1, 4588c5ad0daSSasha Neftin eeprom_buff); 4598c5ad0daSSasha Neftin } else { 4608c5ad0daSSasha Neftin for (i = 0; i < last_word - first_word + 1; i++) { 4618c5ad0daSSasha Neftin ret_val = hw->nvm.ops.read(hw, first_word + i, 1, 4628c5ad0daSSasha Neftin &eeprom_buff[i]); 4638c5ad0daSSasha Neftin if (ret_val) 4648c5ad0daSSasha Neftin break; 4658c5ad0daSSasha Neftin } 4668c5ad0daSSasha Neftin } 4678c5ad0daSSasha Neftin 4688c5ad0daSSasha Neftin /* Device's eeprom is always little-endian, word addressable */ 4698c5ad0daSSasha Neftin for (i = 0; i < last_word - first_word + 1; i++) 4708c5ad0daSSasha Neftin le16_to_cpus(&eeprom_buff[i]); 4718c5ad0daSSasha Neftin 4728c5ad0daSSasha Neftin memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1), 4738c5ad0daSSasha Neftin eeprom->len); 4748c5ad0daSSasha Neftin kfree(eeprom_buff); 4758c5ad0daSSasha Neftin 4768c5ad0daSSasha Neftin return ret_val; 4778c5ad0daSSasha Neftin } 4788c5ad0daSSasha Neftin 4798c5ad0daSSasha Neftin static int igc_set_eeprom(struct net_device *netdev, 4808c5ad0daSSasha Neftin struct ethtool_eeprom *eeprom, u8 *bytes) 4818c5ad0daSSasha Neftin { 4828c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 4838c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 4848c5ad0daSSasha Neftin int max_len, first_word, last_word, ret_val = 0; 4858c5ad0daSSasha Neftin u16 *eeprom_buff; 4868c5ad0daSSasha Neftin void *ptr; 4878c5ad0daSSasha Neftin u16 i; 4888c5ad0daSSasha Neftin 4898c5ad0daSSasha Neftin if (eeprom->len == 0) 4908c5ad0daSSasha Neftin return -EOPNOTSUPP; 4918c5ad0daSSasha Neftin 4928c5ad0daSSasha Neftin if (hw->mac.type >= igc_i225 && 4938c5ad0daSSasha Neftin !igc_get_flash_presence_i225(hw)) { 4948c5ad0daSSasha Neftin return -EOPNOTSUPP; 4958c5ad0daSSasha Neftin } 4968c5ad0daSSasha Neftin 4978c5ad0daSSasha Neftin if (eeprom->magic != (hw->vendor_id | (hw->device_id << 16))) 4988c5ad0daSSasha Neftin return -EFAULT; 4998c5ad0daSSasha Neftin 5008c5ad0daSSasha Neftin max_len = hw->nvm.word_size * 2; 5018c5ad0daSSasha Neftin 5028c5ad0daSSasha Neftin first_word = eeprom->offset >> 1; 5038c5ad0daSSasha Neftin last_word = (eeprom->offset + eeprom->len - 1) >> 1; 5048c5ad0daSSasha Neftin eeprom_buff = kmalloc(max_len, GFP_KERNEL); 5058c5ad0daSSasha Neftin if (!eeprom_buff) 5068c5ad0daSSasha Neftin return -ENOMEM; 5078c5ad0daSSasha Neftin 5088c5ad0daSSasha Neftin ptr = (void *)eeprom_buff; 5098c5ad0daSSasha Neftin 5108c5ad0daSSasha Neftin if (eeprom->offset & 1) { 5118c5ad0daSSasha Neftin /* need read/modify/write of first changed EEPROM word 5128c5ad0daSSasha Neftin * only the second byte of the word is being modified 5138c5ad0daSSasha Neftin */ 5148c5ad0daSSasha Neftin ret_val = hw->nvm.ops.read(hw, first_word, 1, 5158c5ad0daSSasha Neftin &eeprom_buff[0]); 5168c5ad0daSSasha Neftin ptr++; 5178c5ad0daSSasha Neftin } 5188c5ad0daSSasha Neftin if (((eeprom->offset + eeprom->len) & 1) && ret_val == 0) { 5198c5ad0daSSasha Neftin /* need read/modify/write of last changed EEPROM word 5208c5ad0daSSasha Neftin * only the first byte of the word is being modified 5218c5ad0daSSasha Neftin */ 5228c5ad0daSSasha Neftin ret_val = hw->nvm.ops.read(hw, last_word, 1, 5238c5ad0daSSasha Neftin &eeprom_buff[last_word - first_word]); 5248c5ad0daSSasha Neftin } 5258c5ad0daSSasha Neftin 5268c5ad0daSSasha Neftin /* Device's eeprom is always little-endian, word addressable */ 5278c5ad0daSSasha Neftin for (i = 0; i < last_word - first_word + 1; i++) 5288c5ad0daSSasha Neftin le16_to_cpus(&eeprom_buff[i]); 5298c5ad0daSSasha Neftin 5308c5ad0daSSasha Neftin memcpy(ptr, bytes, eeprom->len); 5318c5ad0daSSasha Neftin 5328c5ad0daSSasha Neftin for (i = 0; i < last_word - first_word + 1; i++) 5338c5ad0daSSasha Neftin eeprom_buff[i] = cpu_to_le16(eeprom_buff[i]); 5348c5ad0daSSasha Neftin 5358c5ad0daSSasha Neftin ret_val = hw->nvm.ops.write(hw, first_word, 5368c5ad0daSSasha Neftin last_word - first_word + 1, eeprom_buff); 5378c5ad0daSSasha Neftin 5388c5ad0daSSasha Neftin /* Update the checksum if nvm write succeeded */ 5398c5ad0daSSasha Neftin if (ret_val == 0) 5408c5ad0daSSasha Neftin hw->nvm.ops.update(hw); 5418c5ad0daSSasha Neftin 5428c5ad0daSSasha Neftin /* check if need: igc_set_fw_version(adapter); */ 5438c5ad0daSSasha Neftin kfree(eeprom_buff); 5448c5ad0daSSasha Neftin return ret_val; 5458c5ad0daSSasha Neftin } 5468c5ad0daSSasha Neftin 5478c5ad0daSSasha Neftin static void igc_get_ringparam(struct net_device *netdev, 5488c5ad0daSSasha Neftin struct ethtool_ringparam *ring) 5498c5ad0daSSasha Neftin { 5508c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 5518c5ad0daSSasha Neftin 5528c5ad0daSSasha Neftin ring->rx_max_pending = IGC_MAX_RXD; 5538c5ad0daSSasha Neftin ring->tx_max_pending = IGC_MAX_TXD; 5548c5ad0daSSasha Neftin ring->rx_pending = adapter->rx_ring_count; 5558c5ad0daSSasha Neftin ring->tx_pending = adapter->tx_ring_count; 5568c5ad0daSSasha Neftin } 5578c5ad0daSSasha Neftin 5588c5ad0daSSasha Neftin static int igc_set_ringparam(struct net_device *netdev, 5598c5ad0daSSasha Neftin struct ethtool_ringparam *ring) 5608c5ad0daSSasha Neftin { 5618c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 5628c5ad0daSSasha Neftin struct igc_ring *temp_ring; 5638c5ad0daSSasha Neftin u16 new_rx_count, new_tx_count; 5648c5ad0daSSasha Neftin int i, err = 0; 5658c5ad0daSSasha Neftin 5668c5ad0daSSasha Neftin if (ring->rx_mini_pending || ring->rx_jumbo_pending) 5678c5ad0daSSasha Neftin return -EINVAL; 5688c5ad0daSSasha Neftin 5698c5ad0daSSasha Neftin new_rx_count = min_t(u32, ring->rx_pending, IGC_MAX_RXD); 5708c5ad0daSSasha Neftin new_rx_count = max_t(u16, new_rx_count, IGC_MIN_RXD); 5718c5ad0daSSasha Neftin new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE); 5728c5ad0daSSasha Neftin 5738c5ad0daSSasha Neftin new_tx_count = min_t(u32, ring->tx_pending, IGC_MAX_TXD); 5748c5ad0daSSasha Neftin new_tx_count = max_t(u16, new_tx_count, IGC_MIN_TXD); 5758c5ad0daSSasha Neftin new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE); 5768c5ad0daSSasha Neftin 5778c5ad0daSSasha Neftin if (new_tx_count == adapter->tx_ring_count && 5788c5ad0daSSasha Neftin new_rx_count == adapter->rx_ring_count) { 5798c5ad0daSSasha Neftin /* nothing to do */ 5808c5ad0daSSasha Neftin return 0; 5818c5ad0daSSasha Neftin } 5828c5ad0daSSasha Neftin 5838c5ad0daSSasha Neftin while (test_and_set_bit(__IGC_RESETTING, &adapter->state)) 5848c5ad0daSSasha Neftin usleep_range(1000, 2000); 5858c5ad0daSSasha Neftin 5868c5ad0daSSasha Neftin if (!netif_running(adapter->netdev)) { 5878c5ad0daSSasha Neftin for (i = 0; i < adapter->num_tx_queues; i++) 5888c5ad0daSSasha Neftin adapter->tx_ring[i]->count = new_tx_count; 5898c5ad0daSSasha Neftin for (i = 0; i < adapter->num_rx_queues; i++) 5908c5ad0daSSasha Neftin adapter->rx_ring[i]->count = new_rx_count; 5918c5ad0daSSasha Neftin adapter->tx_ring_count = new_tx_count; 5928c5ad0daSSasha Neftin adapter->rx_ring_count = new_rx_count; 5938c5ad0daSSasha Neftin goto clear_reset; 5948c5ad0daSSasha Neftin } 5958c5ad0daSSasha Neftin 5968c5ad0daSSasha Neftin if (adapter->num_tx_queues > adapter->num_rx_queues) 5978c5ad0daSSasha Neftin temp_ring = vmalloc(array_size(sizeof(struct igc_ring), 5988c5ad0daSSasha Neftin adapter->num_tx_queues)); 5998c5ad0daSSasha Neftin else 6008c5ad0daSSasha Neftin temp_ring = vmalloc(array_size(sizeof(struct igc_ring), 6018c5ad0daSSasha Neftin adapter->num_rx_queues)); 6028c5ad0daSSasha Neftin 6038c5ad0daSSasha Neftin if (!temp_ring) { 6048c5ad0daSSasha Neftin err = -ENOMEM; 6058c5ad0daSSasha Neftin goto clear_reset; 6068c5ad0daSSasha Neftin } 6078c5ad0daSSasha Neftin 6088c5ad0daSSasha Neftin igc_down(adapter); 6098c5ad0daSSasha Neftin 6108c5ad0daSSasha Neftin /* We can't just free everything and then setup again, 6118c5ad0daSSasha Neftin * because the ISRs in MSI-X mode get passed pointers 6128c5ad0daSSasha Neftin * to the Tx and Rx ring structs. 6138c5ad0daSSasha Neftin */ 6148c5ad0daSSasha Neftin if (new_tx_count != adapter->tx_ring_count) { 6158c5ad0daSSasha Neftin for (i = 0; i < adapter->num_tx_queues; i++) { 6168c5ad0daSSasha Neftin memcpy(&temp_ring[i], adapter->tx_ring[i], 6178c5ad0daSSasha Neftin sizeof(struct igc_ring)); 6188c5ad0daSSasha Neftin 6198c5ad0daSSasha Neftin temp_ring[i].count = new_tx_count; 6208c5ad0daSSasha Neftin err = igc_setup_tx_resources(&temp_ring[i]); 6218c5ad0daSSasha Neftin if (err) { 6228c5ad0daSSasha Neftin while (i) { 6238c5ad0daSSasha Neftin i--; 6248c5ad0daSSasha Neftin igc_free_tx_resources(&temp_ring[i]); 6258c5ad0daSSasha Neftin } 6268c5ad0daSSasha Neftin goto err_setup; 6278c5ad0daSSasha Neftin } 6288c5ad0daSSasha Neftin } 6298c5ad0daSSasha Neftin 6308c5ad0daSSasha Neftin for (i = 0; i < adapter->num_tx_queues; i++) { 6318c5ad0daSSasha Neftin igc_free_tx_resources(adapter->tx_ring[i]); 6328c5ad0daSSasha Neftin 6338c5ad0daSSasha Neftin memcpy(adapter->tx_ring[i], &temp_ring[i], 6348c5ad0daSSasha Neftin sizeof(struct igc_ring)); 6358c5ad0daSSasha Neftin } 6368c5ad0daSSasha Neftin 6378c5ad0daSSasha Neftin adapter->tx_ring_count = new_tx_count; 6388c5ad0daSSasha Neftin } 6398c5ad0daSSasha Neftin 6408c5ad0daSSasha Neftin if (new_rx_count != adapter->rx_ring_count) { 6418c5ad0daSSasha Neftin for (i = 0; i < adapter->num_rx_queues; i++) { 6428c5ad0daSSasha Neftin memcpy(&temp_ring[i], adapter->rx_ring[i], 6438c5ad0daSSasha Neftin sizeof(struct igc_ring)); 6448c5ad0daSSasha Neftin 6458c5ad0daSSasha Neftin temp_ring[i].count = new_rx_count; 6468c5ad0daSSasha Neftin err = igc_setup_rx_resources(&temp_ring[i]); 6478c5ad0daSSasha Neftin if (err) { 6488c5ad0daSSasha Neftin while (i) { 6498c5ad0daSSasha Neftin i--; 6508c5ad0daSSasha Neftin igc_free_rx_resources(&temp_ring[i]); 6518c5ad0daSSasha Neftin } 6528c5ad0daSSasha Neftin goto err_setup; 6538c5ad0daSSasha Neftin } 6548c5ad0daSSasha Neftin } 6558c5ad0daSSasha Neftin 6568c5ad0daSSasha Neftin for (i = 0; i < adapter->num_rx_queues; i++) { 6578c5ad0daSSasha Neftin igc_free_rx_resources(adapter->rx_ring[i]); 6588c5ad0daSSasha Neftin 6598c5ad0daSSasha Neftin memcpy(adapter->rx_ring[i], &temp_ring[i], 6608c5ad0daSSasha Neftin sizeof(struct igc_ring)); 6618c5ad0daSSasha Neftin } 6628c5ad0daSSasha Neftin 6638c5ad0daSSasha Neftin adapter->rx_ring_count = new_rx_count; 6648c5ad0daSSasha Neftin } 6658c5ad0daSSasha Neftin err_setup: 6668c5ad0daSSasha Neftin igc_up(adapter); 6678c5ad0daSSasha Neftin vfree(temp_ring); 6688c5ad0daSSasha Neftin clear_reset: 6698c5ad0daSSasha Neftin clear_bit(__IGC_RESETTING, &adapter->state); 6708c5ad0daSSasha Neftin return err; 6718c5ad0daSSasha Neftin } 6728c5ad0daSSasha Neftin 6738c5ad0daSSasha Neftin static void igc_get_pauseparam(struct net_device *netdev, 6748c5ad0daSSasha Neftin struct ethtool_pauseparam *pause) 6758c5ad0daSSasha Neftin { 6768c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 6778c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 6788c5ad0daSSasha Neftin 6798c5ad0daSSasha Neftin pause->autoneg = 6808c5ad0daSSasha Neftin (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE); 6818c5ad0daSSasha Neftin 6828c5ad0daSSasha Neftin if (hw->fc.current_mode == igc_fc_rx_pause) { 6838c5ad0daSSasha Neftin pause->rx_pause = 1; 6848c5ad0daSSasha Neftin } else if (hw->fc.current_mode == igc_fc_tx_pause) { 6858c5ad0daSSasha Neftin pause->tx_pause = 1; 6868c5ad0daSSasha Neftin } else if (hw->fc.current_mode == igc_fc_full) { 6878c5ad0daSSasha Neftin pause->rx_pause = 1; 6888c5ad0daSSasha Neftin pause->tx_pause = 1; 6898c5ad0daSSasha Neftin } 6908c5ad0daSSasha Neftin } 6918c5ad0daSSasha Neftin 6928c5ad0daSSasha Neftin static int igc_set_pauseparam(struct net_device *netdev, 6938c5ad0daSSasha Neftin struct ethtool_pauseparam *pause) 6948c5ad0daSSasha Neftin { 6958c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 6968c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 6978c5ad0daSSasha Neftin int retval = 0; 6988c5ad0daSSasha Neftin 6998c5ad0daSSasha Neftin adapter->fc_autoneg = pause->autoneg; 7008c5ad0daSSasha Neftin 7018c5ad0daSSasha Neftin while (test_and_set_bit(__IGC_RESETTING, &adapter->state)) 7028c5ad0daSSasha Neftin usleep_range(1000, 2000); 7038c5ad0daSSasha Neftin 7048c5ad0daSSasha Neftin if (adapter->fc_autoneg == AUTONEG_ENABLE) { 7058c5ad0daSSasha Neftin hw->fc.requested_mode = igc_fc_default; 7068c5ad0daSSasha Neftin if (netif_running(adapter->netdev)) { 7078c5ad0daSSasha Neftin igc_down(adapter); 7088c5ad0daSSasha Neftin igc_up(adapter); 7098c5ad0daSSasha Neftin } else { 7108c5ad0daSSasha Neftin igc_reset(adapter); 7118c5ad0daSSasha Neftin } 7128c5ad0daSSasha Neftin } else { 7138c5ad0daSSasha Neftin if (pause->rx_pause && pause->tx_pause) 7148c5ad0daSSasha Neftin hw->fc.requested_mode = igc_fc_full; 7158c5ad0daSSasha Neftin else if (pause->rx_pause && !pause->tx_pause) 7168c5ad0daSSasha Neftin hw->fc.requested_mode = igc_fc_rx_pause; 7178c5ad0daSSasha Neftin else if (!pause->rx_pause && pause->tx_pause) 7188c5ad0daSSasha Neftin hw->fc.requested_mode = igc_fc_tx_pause; 7198c5ad0daSSasha Neftin else if (!pause->rx_pause && !pause->tx_pause) 7208c5ad0daSSasha Neftin hw->fc.requested_mode = igc_fc_none; 7218c5ad0daSSasha Neftin 7228c5ad0daSSasha Neftin hw->fc.current_mode = hw->fc.requested_mode; 7238c5ad0daSSasha Neftin 7248c5ad0daSSasha Neftin retval = ((hw->phy.media_type == igc_media_type_copper) ? 7258c5ad0daSSasha Neftin igc_force_mac_fc(hw) : igc_setup_link(hw)); 7268c5ad0daSSasha Neftin } 7278c5ad0daSSasha Neftin 7288c5ad0daSSasha Neftin clear_bit(__IGC_RESETTING, &adapter->state); 7298c5ad0daSSasha Neftin return retval; 7308c5ad0daSSasha Neftin } 7318c5ad0daSSasha Neftin 73236b9fea6SSasha Neftin static void igc_get_strings(struct net_device *netdev, u32 stringset, u8 *data) 73336b9fea6SSasha Neftin { 73436b9fea6SSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 73536b9fea6SSasha Neftin u8 *p = data; 73636b9fea6SSasha Neftin int i; 73736b9fea6SSasha Neftin 73836b9fea6SSasha Neftin switch (stringset) { 73936b9fea6SSasha Neftin case ETH_SS_TEST: 74036b9fea6SSasha Neftin memcpy(data, *igc_gstrings_test, 74136b9fea6SSasha Neftin IGC_TEST_LEN * ETH_GSTRING_LEN); 74236b9fea6SSasha Neftin break; 74336b9fea6SSasha Neftin case ETH_SS_STATS: 74436b9fea6SSasha Neftin for (i = 0; i < IGC_GLOBAL_STATS_LEN; i++) { 74536b9fea6SSasha Neftin memcpy(p, igc_gstrings_stats[i].stat_string, 74636b9fea6SSasha Neftin ETH_GSTRING_LEN); 74736b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 74836b9fea6SSasha Neftin } 74936b9fea6SSasha Neftin for (i = 0; i < IGC_NETDEV_STATS_LEN; i++) { 75036b9fea6SSasha Neftin memcpy(p, igc_gstrings_net_stats[i].stat_string, 75136b9fea6SSasha Neftin ETH_GSTRING_LEN); 75236b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 75336b9fea6SSasha Neftin } 75436b9fea6SSasha Neftin for (i = 0; i < adapter->num_tx_queues; i++) { 75536b9fea6SSasha Neftin sprintf(p, "tx_queue_%u_packets", i); 75636b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 75736b9fea6SSasha Neftin sprintf(p, "tx_queue_%u_bytes", i); 75836b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 75936b9fea6SSasha Neftin sprintf(p, "tx_queue_%u_restart", i); 76036b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 76136b9fea6SSasha Neftin } 76236b9fea6SSasha Neftin for (i = 0; i < adapter->num_rx_queues; i++) { 76336b9fea6SSasha Neftin sprintf(p, "rx_queue_%u_packets", i); 76436b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 76536b9fea6SSasha Neftin sprintf(p, "rx_queue_%u_bytes", i); 76636b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 76736b9fea6SSasha Neftin sprintf(p, "rx_queue_%u_drops", i); 76836b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 76936b9fea6SSasha Neftin sprintf(p, "rx_queue_%u_csum_err", i); 77036b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 77136b9fea6SSasha Neftin sprintf(p, "rx_queue_%u_alloc_failed", i); 77236b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 77336b9fea6SSasha Neftin } 77436b9fea6SSasha Neftin /* BUG_ON(p - data != IGC_STATS_LEN * ETH_GSTRING_LEN); */ 77536b9fea6SSasha Neftin break; 77636b9fea6SSasha Neftin case ETH_SS_PRIV_FLAGS: 77736b9fea6SSasha Neftin memcpy(data, igc_priv_flags_strings, 77836b9fea6SSasha Neftin IGC_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN); 77936b9fea6SSasha Neftin break; 78036b9fea6SSasha Neftin } 78136b9fea6SSasha Neftin } 78236b9fea6SSasha Neftin 78336b9fea6SSasha Neftin static int igc_get_sset_count(struct net_device *netdev, int sset) 78436b9fea6SSasha Neftin { 78536b9fea6SSasha Neftin switch (sset) { 78636b9fea6SSasha Neftin case ETH_SS_STATS: 78736b9fea6SSasha Neftin return IGC_STATS_LEN; 78836b9fea6SSasha Neftin case ETH_SS_TEST: 78936b9fea6SSasha Neftin return IGC_TEST_LEN; 79036b9fea6SSasha Neftin case ETH_SS_PRIV_FLAGS: 79136b9fea6SSasha Neftin return IGC_PRIV_FLAGS_STR_LEN; 79236b9fea6SSasha Neftin default: 79336b9fea6SSasha Neftin return -ENOTSUPP; 79436b9fea6SSasha Neftin } 79536b9fea6SSasha Neftin } 79636b9fea6SSasha Neftin 79736b9fea6SSasha Neftin static void igc_get_ethtool_stats(struct net_device *netdev, 79836b9fea6SSasha Neftin struct ethtool_stats *stats, u64 *data) 79936b9fea6SSasha Neftin { 80036b9fea6SSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 80136b9fea6SSasha Neftin struct rtnl_link_stats64 *net_stats = &adapter->stats64; 80236b9fea6SSasha Neftin unsigned int start; 80336b9fea6SSasha Neftin struct igc_ring *ring; 80436b9fea6SSasha Neftin int i, j; 80536b9fea6SSasha Neftin char *p; 80636b9fea6SSasha Neftin 80736b9fea6SSasha Neftin spin_lock(&adapter->stats64_lock); 80836b9fea6SSasha Neftin igc_update_stats(adapter); 80936b9fea6SSasha Neftin 81036b9fea6SSasha Neftin for (i = 0; i < IGC_GLOBAL_STATS_LEN; i++) { 81136b9fea6SSasha Neftin p = (char *)adapter + igc_gstrings_stats[i].stat_offset; 81236b9fea6SSasha Neftin data[i] = (igc_gstrings_stats[i].sizeof_stat == 81336b9fea6SSasha Neftin sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 81436b9fea6SSasha Neftin } 81536b9fea6SSasha Neftin for (j = 0; j < IGC_NETDEV_STATS_LEN; j++, i++) { 81636b9fea6SSasha Neftin p = (char *)net_stats + igc_gstrings_net_stats[j].stat_offset; 81736b9fea6SSasha Neftin data[i] = (igc_gstrings_net_stats[j].sizeof_stat == 81836b9fea6SSasha Neftin sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 81936b9fea6SSasha Neftin } 82036b9fea6SSasha Neftin for (j = 0; j < adapter->num_tx_queues; j++) { 82136b9fea6SSasha Neftin u64 restart2; 82236b9fea6SSasha Neftin 82336b9fea6SSasha Neftin ring = adapter->tx_ring[j]; 82436b9fea6SSasha Neftin do { 82536b9fea6SSasha Neftin start = u64_stats_fetch_begin_irq(&ring->tx_syncp); 82636b9fea6SSasha Neftin data[i] = ring->tx_stats.packets; 82736b9fea6SSasha Neftin data[i + 1] = ring->tx_stats.bytes; 82836b9fea6SSasha Neftin data[i + 2] = ring->tx_stats.restart_queue; 82936b9fea6SSasha Neftin } while (u64_stats_fetch_retry_irq(&ring->tx_syncp, start)); 83036b9fea6SSasha Neftin do { 83136b9fea6SSasha Neftin start = u64_stats_fetch_begin_irq(&ring->tx_syncp2); 83236b9fea6SSasha Neftin restart2 = ring->tx_stats.restart_queue2; 83336b9fea6SSasha Neftin } while (u64_stats_fetch_retry_irq(&ring->tx_syncp2, start)); 83436b9fea6SSasha Neftin data[i + 2] += restart2; 83536b9fea6SSasha Neftin 83636b9fea6SSasha Neftin i += IGC_TX_QUEUE_STATS_LEN; 83736b9fea6SSasha Neftin } 83836b9fea6SSasha Neftin for (j = 0; j < adapter->num_rx_queues; j++) { 83936b9fea6SSasha Neftin ring = adapter->rx_ring[j]; 84036b9fea6SSasha Neftin do { 84136b9fea6SSasha Neftin start = u64_stats_fetch_begin_irq(&ring->rx_syncp); 84236b9fea6SSasha Neftin data[i] = ring->rx_stats.packets; 84336b9fea6SSasha Neftin data[i + 1] = ring->rx_stats.bytes; 84436b9fea6SSasha Neftin data[i + 2] = ring->rx_stats.drops; 84536b9fea6SSasha Neftin data[i + 3] = ring->rx_stats.csum_err; 84636b9fea6SSasha Neftin data[i + 4] = ring->rx_stats.alloc_failed; 84736b9fea6SSasha Neftin } while (u64_stats_fetch_retry_irq(&ring->rx_syncp, start)); 84836b9fea6SSasha Neftin i += IGC_RX_QUEUE_STATS_LEN; 84936b9fea6SSasha Neftin } 85036b9fea6SSasha Neftin spin_unlock(&adapter->stats64_lock); 85136b9fea6SSasha Neftin } 85236b9fea6SSasha Neftin 8538c5ad0daSSasha Neftin static int igc_get_coalesce(struct net_device *netdev, 8548c5ad0daSSasha Neftin struct ethtool_coalesce *ec) 8558c5ad0daSSasha Neftin { 8568c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 8578c5ad0daSSasha Neftin 8588c5ad0daSSasha Neftin if (adapter->rx_itr_setting <= 3) 8598c5ad0daSSasha Neftin ec->rx_coalesce_usecs = adapter->rx_itr_setting; 8608c5ad0daSSasha Neftin else 8618c5ad0daSSasha Neftin ec->rx_coalesce_usecs = adapter->rx_itr_setting >> 2; 8628c5ad0daSSasha Neftin 8638c5ad0daSSasha Neftin if (!(adapter->flags & IGC_FLAG_QUEUE_PAIRS)) { 8648c5ad0daSSasha Neftin if (adapter->tx_itr_setting <= 3) 8658c5ad0daSSasha Neftin ec->tx_coalesce_usecs = adapter->tx_itr_setting; 8668c5ad0daSSasha Neftin else 8678c5ad0daSSasha Neftin ec->tx_coalesce_usecs = adapter->tx_itr_setting >> 2; 8688c5ad0daSSasha Neftin } 8698c5ad0daSSasha Neftin 8708c5ad0daSSasha Neftin return 0; 8718c5ad0daSSasha Neftin } 8728c5ad0daSSasha Neftin 8738c5ad0daSSasha Neftin static int igc_set_coalesce(struct net_device *netdev, 8748c5ad0daSSasha Neftin struct ethtool_coalesce *ec) 8758c5ad0daSSasha Neftin { 8768c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 8778c5ad0daSSasha Neftin int i; 8788c5ad0daSSasha Neftin 8798c5ad0daSSasha Neftin if (ec->rx_coalesce_usecs > IGC_MAX_ITR_USECS || 8808c5ad0daSSasha Neftin (ec->rx_coalesce_usecs > 3 && 8818c5ad0daSSasha Neftin ec->rx_coalesce_usecs < IGC_MIN_ITR_USECS) || 8828c5ad0daSSasha Neftin ec->rx_coalesce_usecs == 2) 8838c5ad0daSSasha Neftin return -EINVAL; 8848c5ad0daSSasha Neftin 8858c5ad0daSSasha Neftin if (ec->tx_coalesce_usecs > IGC_MAX_ITR_USECS || 8868c5ad0daSSasha Neftin (ec->tx_coalesce_usecs > 3 && 8878c5ad0daSSasha Neftin ec->tx_coalesce_usecs < IGC_MIN_ITR_USECS) || 8888c5ad0daSSasha Neftin ec->tx_coalesce_usecs == 2) 8898c5ad0daSSasha Neftin return -EINVAL; 8908c5ad0daSSasha Neftin 8918c5ad0daSSasha Neftin if ((adapter->flags & IGC_FLAG_QUEUE_PAIRS) && ec->tx_coalesce_usecs) 8928c5ad0daSSasha Neftin return -EINVAL; 8938c5ad0daSSasha Neftin 8948c5ad0daSSasha Neftin /* If ITR is disabled, disable DMAC */ 8958c5ad0daSSasha Neftin if (ec->rx_coalesce_usecs == 0) { 8968c5ad0daSSasha Neftin if (adapter->flags & IGC_FLAG_DMAC) 8978c5ad0daSSasha Neftin adapter->flags &= ~IGC_FLAG_DMAC; 8988c5ad0daSSasha Neftin } 8998c5ad0daSSasha Neftin 9008c5ad0daSSasha Neftin /* convert to rate of irq's per second */ 9018c5ad0daSSasha Neftin if (ec->rx_coalesce_usecs && ec->rx_coalesce_usecs <= 3) 9028c5ad0daSSasha Neftin adapter->rx_itr_setting = ec->rx_coalesce_usecs; 9038c5ad0daSSasha Neftin else 9048c5ad0daSSasha Neftin adapter->rx_itr_setting = ec->rx_coalesce_usecs << 2; 9058c5ad0daSSasha Neftin 9068c5ad0daSSasha Neftin /* convert to rate of irq's per second */ 9078c5ad0daSSasha Neftin if (adapter->flags & IGC_FLAG_QUEUE_PAIRS) 9088c5ad0daSSasha Neftin adapter->tx_itr_setting = adapter->rx_itr_setting; 9098c5ad0daSSasha Neftin else if (ec->tx_coalesce_usecs && ec->tx_coalesce_usecs <= 3) 9108c5ad0daSSasha Neftin adapter->tx_itr_setting = ec->tx_coalesce_usecs; 9118c5ad0daSSasha Neftin else 9128c5ad0daSSasha Neftin adapter->tx_itr_setting = ec->tx_coalesce_usecs << 2; 9138c5ad0daSSasha Neftin 9148c5ad0daSSasha Neftin for (i = 0; i < adapter->num_q_vectors; i++) { 9158c5ad0daSSasha Neftin struct igc_q_vector *q_vector = adapter->q_vector[i]; 9168c5ad0daSSasha Neftin 9178c5ad0daSSasha Neftin q_vector->tx.work_limit = adapter->tx_work_limit; 9188c5ad0daSSasha Neftin if (q_vector->rx.ring) 9198c5ad0daSSasha Neftin q_vector->itr_val = adapter->rx_itr_setting; 9208c5ad0daSSasha Neftin else 9218c5ad0daSSasha Neftin q_vector->itr_val = adapter->tx_itr_setting; 9228c5ad0daSSasha Neftin if (q_vector->itr_val && q_vector->itr_val <= 3) 9238c5ad0daSSasha Neftin q_vector->itr_val = IGC_START_ITR; 9248c5ad0daSSasha Neftin q_vector->set_itr = 1; 9258c5ad0daSSasha Neftin } 9268c5ad0daSSasha Neftin 9278c5ad0daSSasha Neftin return 0; 9288c5ad0daSSasha Neftin } 9298c5ad0daSSasha Neftin 9306245c848SSasha Neftin #define ETHER_TYPE_FULL_MASK ((__force __be16)~0) 9316245c848SSasha Neftin static int igc_get_ethtool_nfc_entry(struct igc_adapter *adapter, 9326245c848SSasha Neftin struct ethtool_rxnfc *cmd) 9336245c848SSasha Neftin { 9346245c848SSasha Neftin struct ethtool_rx_flow_spec *fsp = &cmd->fs; 9356245c848SSasha Neftin struct igc_nfc_filter *rule = NULL; 9366245c848SSasha Neftin 9376245c848SSasha Neftin /* report total rule count */ 9386245c848SSasha Neftin cmd->data = IGC_MAX_RXNFC_FILTERS; 9396245c848SSasha Neftin 9406245c848SSasha Neftin hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) { 9416245c848SSasha Neftin if (fsp->location <= rule->sw_idx) 9426245c848SSasha Neftin break; 9436245c848SSasha Neftin } 9446245c848SSasha Neftin 9456245c848SSasha Neftin if (!rule || fsp->location != rule->sw_idx) 9466245c848SSasha Neftin return -EINVAL; 9476245c848SSasha Neftin 9486245c848SSasha Neftin if (rule->filter.match_flags) { 9496245c848SSasha Neftin fsp->flow_type = ETHER_FLOW; 9506245c848SSasha Neftin fsp->ring_cookie = rule->action; 9516245c848SSasha Neftin if (rule->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) { 9526245c848SSasha Neftin fsp->h_u.ether_spec.h_proto = rule->filter.etype; 9536245c848SSasha Neftin fsp->m_u.ether_spec.h_proto = ETHER_TYPE_FULL_MASK; 9546245c848SSasha Neftin } 9556245c848SSasha Neftin if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) { 9566245c848SSasha Neftin fsp->flow_type |= FLOW_EXT; 9576245c848SSasha Neftin fsp->h_ext.vlan_tci = rule->filter.vlan_tci; 9586245c848SSasha Neftin fsp->m_ext.vlan_tci = htons(VLAN_PRIO_MASK); 9596245c848SSasha Neftin } 9606245c848SSasha Neftin if (rule->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) { 9616245c848SSasha Neftin ether_addr_copy(fsp->h_u.ether_spec.h_dest, 9626245c848SSasha Neftin rule->filter.dst_addr); 9636245c848SSasha Neftin /* As we only support matching by the full 9646245c848SSasha Neftin * mask, return the mask to userspace 9656245c848SSasha Neftin */ 9666245c848SSasha Neftin eth_broadcast_addr(fsp->m_u.ether_spec.h_dest); 9676245c848SSasha Neftin } 9686245c848SSasha Neftin if (rule->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) { 9696245c848SSasha Neftin ether_addr_copy(fsp->h_u.ether_spec.h_source, 9706245c848SSasha Neftin rule->filter.src_addr); 9716245c848SSasha Neftin /* As we only support matching by the full 9726245c848SSasha Neftin * mask, return the mask to userspace 9736245c848SSasha Neftin */ 9746245c848SSasha Neftin eth_broadcast_addr(fsp->m_u.ether_spec.h_source); 9756245c848SSasha Neftin } 9766245c848SSasha Neftin 9776245c848SSasha Neftin return 0; 9786245c848SSasha Neftin } 9796245c848SSasha Neftin return -EINVAL; 9806245c848SSasha Neftin } 9816245c848SSasha Neftin 9826245c848SSasha Neftin static int igc_get_ethtool_nfc_all(struct igc_adapter *adapter, 9836245c848SSasha Neftin struct ethtool_rxnfc *cmd, 9846245c848SSasha Neftin u32 *rule_locs) 9856245c848SSasha Neftin { 9866245c848SSasha Neftin struct igc_nfc_filter *rule; 9876245c848SSasha Neftin int cnt = 0; 9886245c848SSasha Neftin 9896245c848SSasha Neftin /* report total rule count */ 9906245c848SSasha Neftin cmd->data = IGC_MAX_RXNFC_FILTERS; 9916245c848SSasha Neftin 9926245c848SSasha Neftin hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) { 9936245c848SSasha Neftin if (cnt == cmd->rule_cnt) 9946245c848SSasha Neftin return -EMSGSIZE; 9956245c848SSasha Neftin rule_locs[cnt] = rule->sw_idx; 9966245c848SSasha Neftin cnt++; 9976245c848SSasha Neftin } 9986245c848SSasha Neftin 9996245c848SSasha Neftin cmd->rule_cnt = cnt; 10006245c848SSasha Neftin 10016245c848SSasha Neftin return 0; 10026245c848SSasha Neftin } 10036245c848SSasha Neftin 10046245c848SSasha Neftin static int igc_get_rss_hash_opts(struct igc_adapter *adapter, 10056245c848SSasha Neftin struct ethtool_rxnfc *cmd) 10066245c848SSasha Neftin { 10076245c848SSasha Neftin cmd->data = 0; 10086245c848SSasha Neftin 10096245c848SSasha Neftin /* Report default options for RSS on igc */ 10106245c848SSasha Neftin switch (cmd->flow_type) { 10116245c848SSasha Neftin case TCP_V4_FLOW: 10126245c848SSasha Neftin cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 10136245c848SSasha Neftin /* Fall through */ 10146245c848SSasha Neftin case UDP_V4_FLOW: 10156245c848SSasha Neftin if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV4_UDP) 10166245c848SSasha Neftin cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 10176245c848SSasha Neftin /* Fall through */ 10186245c848SSasha Neftin case SCTP_V4_FLOW: 10196245c848SSasha Neftin /* Fall through */ 10206245c848SSasha Neftin case AH_ESP_V4_FLOW: 10216245c848SSasha Neftin /* Fall through */ 10226245c848SSasha Neftin case AH_V4_FLOW: 10236245c848SSasha Neftin /* Fall through */ 10246245c848SSasha Neftin case ESP_V4_FLOW: 10256245c848SSasha Neftin /* Fall through */ 10266245c848SSasha Neftin case IPV4_FLOW: 10276245c848SSasha Neftin cmd->data |= RXH_IP_SRC | RXH_IP_DST; 10286245c848SSasha Neftin break; 10296245c848SSasha Neftin case TCP_V6_FLOW: 10306245c848SSasha Neftin cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 10316245c848SSasha Neftin /* Fall through */ 10326245c848SSasha Neftin case UDP_V6_FLOW: 10336245c848SSasha Neftin if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV6_UDP) 10346245c848SSasha Neftin cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 10356245c848SSasha Neftin /* Fall through */ 10366245c848SSasha Neftin case SCTP_V6_FLOW: 10376245c848SSasha Neftin /* Fall through */ 10386245c848SSasha Neftin case AH_ESP_V6_FLOW: 10396245c848SSasha Neftin /* Fall through */ 10406245c848SSasha Neftin case AH_V6_FLOW: 10416245c848SSasha Neftin /* Fall through */ 10426245c848SSasha Neftin case ESP_V6_FLOW: 10436245c848SSasha Neftin /* Fall through */ 10446245c848SSasha Neftin case IPV6_FLOW: 10456245c848SSasha Neftin cmd->data |= RXH_IP_SRC | RXH_IP_DST; 10466245c848SSasha Neftin break; 10476245c848SSasha Neftin default: 10486245c848SSasha Neftin return -EINVAL; 10496245c848SSasha Neftin } 10506245c848SSasha Neftin 10516245c848SSasha Neftin return 0; 10526245c848SSasha Neftin } 10536245c848SSasha Neftin 10546245c848SSasha Neftin static int igc_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd, 10556245c848SSasha Neftin u32 *rule_locs) 10566245c848SSasha Neftin { 10576245c848SSasha Neftin struct igc_adapter *adapter = netdev_priv(dev); 10586245c848SSasha Neftin 10596245c848SSasha Neftin switch (cmd->cmd) { 10606245c848SSasha Neftin case ETHTOOL_GRXRINGS: 10616245c848SSasha Neftin cmd->data = adapter->num_rx_queues; 1062*8b9c23cdSAndre Guedes return 0; 10636245c848SSasha Neftin case ETHTOOL_GRXCLSRLCNT: 10646245c848SSasha Neftin cmd->rule_cnt = adapter->nfc_filter_count; 1065*8b9c23cdSAndre Guedes return 0; 10666245c848SSasha Neftin case ETHTOOL_GRXCLSRULE: 1067*8b9c23cdSAndre Guedes return igc_get_ethtool_nfc_entry(adapter, cmd); 10686245c848SSasha Neftin case ETHTOOL_GRXCLSRLALL: 1069*8b9c23cdSAndre Guedes return igc_get_ethtool_nfc_all(adapter, cmd, rule_locs); 10706245c848SSasha Neftin case ETHTOOL_GRXFH: 1071*8b9c23cdSAndre Guedes return igc_get_rss_hash_opts(adapter, cmd); 10726245c848SSasha Neftin default: 1073*8b9c23cdSAndre Guedes return -EOPNOTSUPP; 10746245c848SSasha Neftin } 10756245c848SSasha Neftin } 10766245c848SSasha Neftin 10776245c848SSasha Neftin #define UDP_RSS_FLAGS (IGC_FLAG_RSS_FIELD_IPV4_UDP | \ 10786245c848SSasha Neftin IGC_FLAG_RSS_FIELD_IPV6_UDP) 10796245c848SSasha Neftin static int igc_set_rss_hash_opt(struct igc_adapter *adapter, 10806245c848SSasha Neftin struct ethtool_rxnfc *nfc) 10816245c848SSasha Neftin { 10826245c848SSasha Neftin u32 flags = adapter->flags; 10836245c848SSasha Neftin 10846245c848SSasha Neftin /* RSS does not support anything other than hashing 10856245c848SSasha Neftin * to queues on src and dst IPs and ports 10866245c848SSasha Neftin */ 10876245c848SSasha Neftin if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST | 10886245c848SSasha Neftin RXH_L4_B_0_1 | RXH_L4_B_2_3)) 10896245c848SSasha Neftin return -EINVAL; 10906245c848SSasha Neftin 10916245c848SSasha Neftin switch (nfc->flow_type) { 10926245c848SSasha Neftin case TCP_V4_FLOW: 10936245c848SSasha Neftin case TCP_V6_FLOW: 10946245c848SSasha Neftin if (!(nfc->data & RXH_IP_SRC) || 10956245c848SSasha Neftin !(nfc->data & RXH_IP_DST) || 10966245c848SSasha Neftin !(nfc->data & RXH_L4_B_0_1) || 10976245c848SSasha Neftin !(nfc->data & RXH_L4_B_2_3)) 10986245c848SSasha Neftin return -EINVAL; 10996245c848SSasha Neftin break; 11006245c848SSasha Neftin case UDP_V4_FLOW: 11016245c848SSasha Neftin if (!(nfc->data & RXH_IP_SRC) || 11026245c848SSasha Neftin !(nfc->data & RXH_IP_DST)) 11036245c848SSasha Neftin return -EINVAL; 11046245c848SSasha Neftin switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 11056245c848SSasha Neftin case 0: 11066245c848SSasha Neftin flags &= ~IGC_FLAG_RSS_FIELD_IPV4_UDP; 11076245c848SSasha Neftin break; 11086245c848SSasha Neftin case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 11096245c848SSasha Neftin flags |= IGC_FLAG_RSS_FIELD_IPV4_UDP; 11106245c848SSasha Neftin break; 11116245c848SSasha Neftin default: 11126245c848SSasha Neftin return -EINVAL; 11136245c848SSasha Neftin } 11146245c848SSasha Neftin break; 11156245c848SSasha Neftin case UDP_V6_FLOW: 11166245c848SSasha Neftin if (!(nfc->data & RXH_IP_SRC) || 11176245c848SSasha Neftin !(nfc->data & RXH_IP_DST)) 11186245c848SSasha Neftin return -EINVAL; 11196245c848SSasha Neftin switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 11206245c848SSasha Neftin case 0: 11216245c848SSasha Neftin flags &= ~IGC_FLAG_RSS_FIELD_IPV6_UDP; 11226245c848SSasha Neftin break; 11236245c848SSasha Neftin case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 11246245c848SSasha Neftin flags |= IGC_FLAG_RSS_FIELD_IPV6_UDP; 11256245c848SSasha Neftin break; 11266245c848SSasha Neftin default: 11276245c848SSasha Neftin return -EINVAL; 11286245c848SSasha Neftin } 11296245c848SSasha Neftin break; 11306245c848SSasha Neftin case AH_ESP_V4_FLOW: 11316245c848SSasha Neftin case AH_V4_FLOW: 11326245c848SSasha Neftin case ESP_V4_FLOW: 11336245c848SSasha Neftin case SCTP_V4_FLOW: 11346245c848SSasha Neftin case AH_ESP_V6_FLOW: 11356245c848SSasha Neftin case AH_V6_FLOW: 11366245c848SSasha Neftin case ESP_V6_FLOW: 11376245c848SSasha Neftin case SCTP_V6_FLOW: 11386245c848SSasha Neftin if (!(nfc->data & RXH_IP_SRC) || 11396245c848SSasha Neftin !(nfc->data & RXH_IP_DST) || 11406245c848SSasha Neftin (nfc->data & RXH_L4_B_0_1) || 11416245c848SSasha Neftin (nfc->data & RXH_L4_B_2_3)) 11426245c848SSasha Neftin return -EINVAL; 11436245c848SSasha Neftin break; 11446245c848SSasha Neftin default: 11456245c848SSasha Neftin return -EINVAL; 11466245c848SSasha Neftin } 11476245c848SSasha Neftin 11486245c848SSasha Neftin /* if we changed something we need to update flags */ 11496245c848SSasha Neftin if (flags != adapter->flags) { 11506245c848SSasha Neftin struct igc_hw *hw = &adapter->hw; 11516245c848SSasha Neftin u32 mrqc = rd32(IGC_MRQC); 11526245c848SSasha Neftin 11536245c848SSasha Neftin if ((flags & UDP_RSS_FLAGS) && 11546245c848SSasha Neftin !(adapter->flags & UDP_RSS_FLAGS)) 115595f96a9fSAndre Guedes netdev_err(adapter->netdev, 115695f96a9fSAndre Guedes "Enabling UDP RSS: fragmented packets may arrive out of order to the stack above\n"); 11576245c848SSasha Neftin 11586245c848SSasha Neftin adapter->flags = flags; 11596245c848SSasha Neftin 11606245c848SSasha Neftin /* Perform hash on these packet types */ 11616245c848SSasha Neftin mrqc |= IGC_MRQC_RSS_FIELD_IPV4 | 11626245c848SSasha Neftin IGC_MRQC_RSS_FIELD_IPV4_TCP | 11636245c848SSasha Neftin IGC_MRQC_RSS_FIELD_IPV6 | 11646245c848SSasha Neftin IGC_MRQC_RSS_FIELD_IPV6_TCP; 11656245c848SSasha Neftin 11666245c848SSasha Neftin mrqc &= ~(IGC_MRQC_RSS_FIELD_IPV4_UDP | 11676245c848SSasha Neftin IGC_MRQC_RSS_FIELD_IPV6_UDP); 11686245c848SSasha Neftin 11696245c848SSasha Neftin if (flags & IGC_FLAG_RSS_FIELD_IPV4_UDP) 11706245c848SSasha Neftin mrqc |= IGC_MRQC_RSS_FIELD_IPV4_UDP; 11716245c848SSasha Neftin 11726245c848SSasha Neftin if (flags & IGC_FLAG_RSS_FIELD_IPV6_UDP) 11736245c848SSasha Neftin mrqc |= IGC_MRQC_RSS_FIELD_IPV6_UDP; 11746245c848SSasha Neftin 11756245c848SSasha Neftin wr32(IGC_MRQC, mrqc); 11766245c848SSasha Neftin } 11776245c848SSasha Neftin 11786245c848SSasha Neftin return 0; 11796245c848SSasha Neftin } 11806245c848SSasha Neftin 11816245c848SSasha Neftin int igc_add_filter(struct igc_adapter *adapter, struct igc_nfc_filter *input) 11826245c848SSasha Neftin { 11836245c848SSasha Neftin int err = -EINVAL; 11846245c848SSasha Neftin 11856245c848SSasha Neftin if (input->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) { 1186aa7ca726SAndre Guedes u16 etype = ntohs(input->filter.etype); 1187aa7ca726SAndre Guedes 1188aa7ca726SAndre Guedes err = igc_add_etype_filter(adapter, etype, input->action); 11896245c848SSasha Neftin if (err) 11906245c848SSasha Neftin return err; 11916245c848SSasha Neftin } 11926245c848SSasha Neftin 11938eb2449dSAndre Guedes if (input->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) { 11948eb2449dSAndre Guedes err = igc_add_mac_filter(adapter, IGC_MAC_FILTER_TYPE_SRC, 11958eb2449dSAndre Guedes input->filter.src_addr, 11968eb2449dSAndre Guedes input->action); 11978eb2449dSAndre Guedes if (err) 11988eb2449dSAndre Guedes return err; 11998eb2449dSAndre Guedes } 12008eb2449dSAndre Guedes 12016245c848SSasha Neftin if (input->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) { 1202750433d0SAndre Guedes err = igc_add_mac_filter(adapter, IGC_MAC_FILTER_TYPE_DST, 1203750433d0SAndre Guedes input->filter.dst_addr, 12041c3739cbSAndre Guedes input->action); 12056245c848SSasha Neftin if (err) 12066245c848SSasha Neftin return err; 12076245c848SSasha Neftin } 12086245c848SSasha Neftin 120912ddee68SAndre Guedes if (input->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) { 121012ddee68SAndre Guedes int prio = (ntohs(input->filter.vlan_tci) & VLAN_PRIO_MASK) >> 121112ddee68SAndre Guedes VLAN_PRIO_SHIFT; 121212ddee68SAndre Guedes err = igc_add_vlan_prio_filter(adapter, prio, input->action); 121312ddee68SAndre Guedes if (err) 12146245c848SSasha Neftin return err; 12156245c848SSasha Neftin } 12166245c848SSasha Neftin 121712ddee68SAndre Guedes return 0; 121812ddee68SAndre Guedes } 121912ddee68SAndre Guedes 12206245c848SSasha Neftin int igc_erase_filter(struct igc_adapter *adapter, struct igc_nfc_filter *input) 12216245c848SSasha Neftin { 1222aa7ca726SAndre Guedes if (input->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) { 1223aa7ca726SAndre Guedes u16 etype = ntohs(input->filter.etype); 1224aa7ca726SAndre Guedes 1225aa7ca726SAndre Guedes igc_del_etype_filter(adapter, etype); 1226aa7ca726SAndre Guedes } 12276245c848SSasha Neftin 122812ddee68SAndre Guedes if (input->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) { 122912ddee68SAndre Guedes int prio = (ntohs(input->filter.vlan_tci) & VLAN_PRIO_MASK) >> 123012ddee68SAndre Guedes VLAN_PRIO_SHIFT; 123112ddee68SAndre Guedes igc_del_vlan_prio_filter(adapter, prio); 123212ddee68SAndre Guedes } 12336245c848SSasha Neftin 12348eb2449dSAndre Guedes if (input->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) 12358eb2449dSAndre Guedes igc_del_mac_filter(adapter, IGC_MAC_FILTER_TYPE_SRC, 12368eb2449dSAndre Guedes input->filter.src_addr); 12378eb2449dSAndre Guedes 12386245c848SSasha Neftin if (input->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) 1239750433d0SAndre Guedes igc_del_mac_filter(adapter, IGC_MAC_FILTER_TYPE_DST, 1240750433d0SAndre Guedes input->filter.dst_addr); 12416245c848SSasha Neftin 12426245c848SSasha Neftin return 0; 12436245c848SSasha Neftin } 12446245c848SSasha Neftin 12456245c848SSasha Neftin static int igc_update_ethtool_nfc_entry(struct igc_adapter *adapter, 12466245c848SSasha Neftin struct igc_nfc_filter *input, 12476245c848SSasha Neftin u16 sw_idx) 12486245c848SSasha Neftin { 12496245c848SSasha Neftin struct igc_nfc_filter *rule, *parent; 12506245c848SSasha Neftin int err = -EINVAL; 12516245c848SSasha Neftin 12526245c848SSasha Neftin parent = NULL; 12536245c848SSasha Neftin rule = NULL; 12546245c848SSasha Neftin 12556245c848SSasha Neftin hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) { 12566245c848SSasha Neftin /* hash found, or no matching entry */ 12576245c848SSasha Neftin if (rule->sw_idx >= sw_idx) 12586245c848SSasha Neftin break; 12596245c848SSasha Neftin parent = rule; 12606245c848SSasha Neftin } 12616245c848SSasha Neftin 12626245c848SSasha Neftin /* if there is an old rule occupying our place remove it */ 12636245c848SSasha Neftin if (rule && rule->sw_idx == sw_idx) { 12646245c848SSasha Neftin if (!input) 12656245c848SSasha Neftin err = igc_erase_filter(adapter, rule); 12666245c848SSasha Neftin 12676245c848SSasha Neftin hlist_del(&rule->nfc_node); 12686245c848SSasha Neftin kfree(rule); 12696245c848SSasha Neftin adapter->nfc_filter_count--; 12706245c848SSasha Neftin } 12716245c848SSasha Neftin 12726245c848SSasha Neftin /* If no input this was a delete, err should be 0 if a rule was 12736245c848SSasha Neftin * successfully found and removed from the list else -EINVAL 12746245c848SSasha Neftin */ 12756245c848SSasha Neftin if (!input) 12766245c848SSasha Neftin return err; 12776245c848SSasha Neftin 12786245c848SSasha Neftin /* initialize node */ 12796245c848SSasha Neftin INIT_HLIST_NODE(&input->nfc_node); 12806245c848SSasha Neftin 12816245c848SSasha Neftin /* add filter to the list */ 12826245c848SSasha Neftin if (parent) 12836245c848SSasha Neftin hlist_add_behind(&input->nfc_node, &parent->nfc_node); 12846245c848SSasha Neftin else 12856245c848SSasha Neftin hlist_add_head(&input->nfc_node, &adapter->nfc_filter_list); 12866245c848SSasha Neftin 12876245c848SSasha Neftin /* update counts */ 12886245c848SSasha Neftin adapter->nfc_filter_count++; 12896245c848SSasha Neftin 12906245c848SSasha Neftin return 0; 12916245c848SSasha Neftin } 12926245c848SSasha Neftin 12936245c848SSasha Neftin static int igc_add_ethtool_nfc_entry(struct igc_adapter *adapter, 12946245c848SSasha Neftin struct ethtool_rxnfc *cmd) 12956245c848SSasha Neftin { 12966245c848SSasha Neftin struct net_device *netdev = adapter->netdev; 12976245c848SSasha Neftin struct ethtool_rx_flow_spec *fsp = 12986245c848SSasha Neftin (struct ethtool_rx_flow_spec *)&cmd->fs; 12996245c848SSasha Neftin struct igc_nfc_filter *input, *rule; 13006245c848SSasha Neftin int err = 0; 13016245c848SSasha Neftin 13026245c848SSasha Neftin if (!(netdev->hw_features & NETIF_F_NTUPLE)) 13036245c848SSasha Neftin return -EOPNOTSUPP; 13046245c848SSasha Neftin 13056245c848SSasha Neftin /* Don't allow programming if the action is a queue greater than 13066245c848SSasha Neftin * the number of online Rx queues. 13076245c848SSasha Neftin */ 13086245c848SSasha Neftin if (fsp->ring_cookie == RX_CLS_FLOW_DISC || 13096245c848SSasha Neftin fsp->ring_cookie >= adapter->num_rx_queues) { 131095f96a9fSAndre Guedes netdev_err(netdev, 131195f96a9fSAndre Guedes "ethtool -N: The specified action is invalid\n"); 13126245c848SSasha Neftin return -EINVAL; 13136245c848SSasha Neftin } 13146245c848SSasha Neftin 13156245c848SSasha Neftin /* Don't allow indexes to exist outside of available space */ 13166245c848SSasha Neftin if (fsp->location >= IGC_MAX_RXNFC_FILTERS) { 131795f96a9fSAndre Guedes netdev_err(netdev, "Location out of range\n"); 13186245c848SSasha Neftin return -EINVAL; 13196245c848SSasha Neftin } 13206245c848SSasha Neftin 13216245c848SSasha Neftin if ((fsp->flow_type & ~FLOW_EXT) != ETHER_FLOW) 13226245c848SSasha Neftin return -EINVAL; 13236245c848SSasha Neftin 13246245c848SSasha Neftin input = kzalloc(sizeof(*input), GFP_KERNEL); 13256245c848SSasha Neftin if (!input) 13266245c848SSasha Neftin return -ENOMEM; 13276245c848SSasha Neftin 13286245c848SSasha Neftin if (fsp->m_u.ether_spec.h_proto == ETHER_TYPE_FULL_MASK) { 13296245c848SSasha Neftin input->filter.etype = fsp->h_u.ether_spec.h_proto; 13306245c848SSasha Neftin input->filter.match_flags = IGC_FILTER_FLAG_ETHER_TYPE; 13316245c848SSasha Neftin } 13326245c848SSasha Neftin 13338eb2449dSAndre Guedes /* Both source and destination address filters only support the full 13348eb2449dSAndre Guedes * mask. 13358eb2449dSAndre Guedes */ 13366245c848SSasha Neftin if (is_broadcast_ether_addr(fsp->m_u.ether_spec.h_source)) { 13376245c848SSasha Neftin input->filter.match_flags |= IGC_FILTER_FLAG_SRC_MAC_ADDR; 13386245c848SSasha Neftin ether_addr_copy(input->filter.src_addr, 13396245c848SSasha Neftin fsp->h_u.ether_spec.h_source); 13406245c848SSasha Neftin } 13416245c848SSasha Neftin 13426245c848SSasha Neftin if (is_broadcast_ether_addr(fsp->m_u.ether_spec.h_dest)) { 13436245c848SSasha Neftin input->filter.match_flags |= IGC_FILTER_FLAG_DST_MAC_ADDR; 13446245c848SSasha Neftin ether_addr_copy(input->filter.dst_addr, 13456245c848SSasha Neftin fsp->h_u.ether_spec.h_dest); 13466245c848SSasha Neftin } 13476245c848SSasha Neftin 13488eb2449dSAndre Guedes if (input->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR && 13498eb2449dSAndre Guedes input->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) { 13508eb2449dSAndre Guedes netdev_dbg(netdev, "Filters with both dst and src are not supported\n"); 13518eb2449dSAndre Guedes err = -EOPNOTSUPP; 13528eb2449dSAndre Guedes goto err_out; 13538eb2449dSAndre Guedes } 13548eb2449dSAndre Guedes 13556245c848SSasha Neftin if ((fsp->flow_type & FLOW_EXT) && fsp->m_ext.vlan_tci) { 13566245c848SSasha Neftin if (fsp->m_ext.vlan_tci != htons(VLAN_PRIO_MASK)) { 13572e4f1716SAndre Guedes netdev_dbg(netdev, "VLAN mask not supported\n"); 13582e4f1716SAndre Guedes err = -EOPNOTSUPP; 13596245c848SSasha Neftin goto err_out; 13606245c848SSasha Neftin } 13616245c848SSasha Neftin input->filter.vlan_tci = fsp->h_ext.vlan_tci; 13626245c848SSasha Neftin input->filter.match_flags |= IGC_FILTER_FLAG_VLAN_TCI; 13636245c848SSasha Neftin } 13646245c848SSasha Neftin 13656245c848SSasha Neftin input->action = fsp->ring_cookie; 13666245c848SSasha Neftin input->sw_idx = fsp->location; 13676245c848SSasha Neftin 13686245c848SSasha Neftin spin_lock(&adapter->nfc_lock); 13696245c848SSasha Neftin 13706245c848SSasha Neftin hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) { 13716245c848SSasha Neftin if (!memcmp(&input->filter, &rule->filter, 13726245c848SSasha Neftin sizeof(input->filter))) { 13736245c848SSasha Neftin err = -EEXIST; 137495f96a9fSAndre Guedes netdev_err(netdev, 13756245c848SSasha Neftin "ethtool: this filter is already set\n"); 13766245c848SSasha Neftin goto err_out_w_lock; 13776245c848SSasha Neftin } 13786245c848SSasha Neftin } 13796245c848SSasha Neftin 13806245c848SSasha Neftin err = igc_add_filter(adapter, input); 13816245c848SSasha Neftin if (err) 13826245c848SSasha Neftin goto err_out_w_lock; 13836245c848SSasha Neftin 13846245c848SSasha Neftin igc_update_ethtool_nfc_entry(adapter, input, input->sw_idx); 13856245c848SSasha Neftin 13866245c848SSasha Neftin spin_unlock(&adapter->nfc_lock); 13876245c848SSasha Neftin return 0; 13886245c848SSasha Neftin 13896245c848SSasha Neftin err_out_w_lock: 13906245c848SSasha Neftin spin_unlock(&adapter->nfc_lock); 13916245c848SSasha Neftin err_out: 13926245c848SSasha Neftin kfree(input); 13936245c848SSasha Neftin return err; 13946245c848SSasha Neftin } 13956245c848SSasha Neftin 13966245c848SSasha Neftin static int igc_del_ethtool_nfc_entry(struct igc_adapter *adapter, 13976245c848SSasha Neftin struct ethtool_rxnfc *cmd) 13986245c848SSasha Neftin { 13996245c848SSasha Neftin struct ethtool_rx_flow_spec *fsp = 14006245c848SSasha Neftin (struct ethtool_rx_flow_spec *)&cmd->fs; 14016245c848SSasha Neftin int err; 14026245c848SSasha Neftin 14036245c848SSasha Neftin spin_lock(&adapter->nfc_lock); 14046245c848SSasha Neftin err = igc_update_ethtool_nfc_entry(adapter, NULL, fsp->location); 14056245c848SSasha Neftin spin_unlock(&adapter->nfc_lock); 14066245c848SSasha Neftin 14076245c848SSasha Neftin return err; 14086245c848SSasha Neftin } 14096245c848SSasha Neftin 14106245c848SSasha Neftin static int igc_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd) 14116245c848SSasha Neftin { 14126245c848SSasha Neftin struct igc_adapter *adapter = netdev_priv(dev); 14136245c848SSasha Neftin 14146245c848SSasha Neftin switch (cmd->cmd) { 14156245c848SSasha Neftin case ETHTOOL_SRXFH: 1416*8b9c23cdSAndre Guedes return igc_set_rss_hash_opt(adapter, cmd); 14176245c848SSasha Neftin case ETHTOOL_SRXCLSRLINS: 1418*8b9c23cdSAndre Guedes return igc_add_ethtool_nfc_entry(adapter, cmd); 14196245c848SSasha Neftin case ETHTOOL_SRXCLSRLDEL: 1420*8b9c23cdSAndre Guedes return igc_del_ethtool_nfc_entry(adapter, cmd); 14216245c848SSasha Neftin default: 1422*8b9c23cdSAndre Guedes return -EOPNOTSUPP; 14236245c848SSasha Neftin } 14246245c848SSasha Neftin } 14256245c848SSasha Neftin 14268c5ad0daSSasha Neftin void igc_write_rss_indir_tbl(struct igc_adapter *adapter) 14278c5ad0daSSasha Neftin { 14288c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 14298c5ad0daSSasha Neftin u32 reg = IGC_RETA(0); 14308c5ad0daSSasha Neftin u32 shift = 0; 14318c5ad0daSSasha Neftin int i = 0; 14328c5ad0daSSasha Neftin 14338c5ad0daSSasha Neftin while (i < IGC_RETA_SIZE) { 14348c5ad0daSSasha Neftin u32 val = 0; 14358c5ad0daSSasha Neftin int j; 14368c5ad0daSSasha Neftin 14378c5ad0daSSasha Neftin for (j = 3; j >= 0; j--) { 14388c5ad0daSSasha Neftin val <<= 8; 14398c5ad0daSSasha Neftin val |= adapter->rss_indir_tbl[i + j]; 14408c5ad0daSSasha Neftin } 14418c5ad0daSSasha Neftin 14428c5ad0daSSasha Neftin wr32(reg, val << shift); 14438c5ad0daSSasha Neftin reg += 4; 14448c5ad0daSSasha Neftin i += 4; 14458c5ad0daSSasha Neftin } 14468c5ad0daSSasha Neftin } 14478c5ad0daSSasha Neftin 14488c5ad0daSSasha Neftin static u32 igc_get_rxfh_indir_size(struct net_device *netdev) 14498c5ad0daSSasha Neftin { 14508c5ad0daSSasha Neftin return IGC_RETA_SIZE; 14518c5ad0daSSasha Neftin } 14528c5ad0daSSasha Neftin 14538c5ad0daSSasha Neftin static int igc_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key, 14548c5ad0daSSasha Neftin u8 *hfunc) 14558c5ad0daSSasha Neftin { 14568c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 14578c5ad0daSSasha Neftin int i; 14588c5ad0daSSasha Neftin 14598c5ad0daSSasha Neftin if (hfunc) 14608c5ad0daSSasha Neftin *hfunc = ETH_RSS_HASH_TOP; 14618c5ad0daSSasha Neftin if (!indir) 14628c5ad0daSSasha Neftin return 0; 14638c5ad0daSSasha Neftin for (i = 0; i < IGC_RETA_SIZE; i++) 14648c5ad0daSSasha Neftin indir[i] = adapter->rss_indir_tbl[i]; 14658c5ad0daSSasha Neftin 14668c5ad0daSSasha Neftin return 0; 14678c5ad0daSSasha Neftin } 14688c5ad0daSSasha Neftin 14698c5ad0daSSasha Neftin static int igc_set_rxfh(struct net_device *netdev, const u32 *indir, 14708c5ad0daSSasha Neftin const u8 *key, const u8 hfunc) 14718c5ad0daSSasha Neftin { 14728c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 14738c5ad0daSSasha Neftin u32 num_queues; 14748c5ad0daSSasha Neftin int i; 14758c5ad0daSSasha Neftin 14768c5ad0daSSasha Neftin /* We do not allow change in unsupported parameters */ 14778c5ad0daSSasha Neftin if (key || 14788c5ad0daSSasha Neftin (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)) 14798c5ad0daSSasha Neftin return -EOPNOTSUPP; 14808c5ad0daSSasha Neftin if (!indir) 14818c5ad0daSSasha Neftin return 0; 14828c5ad0daSSasha Neftin 14838c5ad0daSSasha Neftin num_queues = adapter->rss_queues; 14848c5ad0daSSasha Neftin 14858c5ad0daSSasha Neftin /* Verify user input. */ 14868c5ad0daSSasha Neftin for (i = 0; i < IGC_RETA_SIZE; i++) 14878c5ad0daSSasha Neftin if (indir[i] >= num_queues) 14888c5ad0daSSasha Neftin return -EINVAL; 14898c5ad0daSSasha Neftin 14908c5ad0daSSasha Neftin for (i = 0; i < IGC_RETA_SIZE; i++) 14918c5ad0daSSasha Neftin adapter->rss_indir_tbl[i] = indir[i]; 14928c5ad0daSSasha Neftin 14938c5ad0daSSasha Neftin igc_write_rss_indir_tbl(adapter); 14948c5ad0daSSasha Neftin 14958c5ad0daSSasha Neftin return 0; 14968c5ad0daSSasha Neftin } 14978c5ad0daSSasha Neftin 14988c5ad0daSSasha Neftin static void igc_get_channels(struct net_device *netdev, 14998c5ad0daSSasha Neftin struct ethtool_channels *ch) 15008c5ad0daSSasha Neftin { 15018c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 15028c5ad0daSSasha Neftin 15038c5ad0daSSasha Neftin /* Report maximum channels */ 15044d0710c2SAndre Guedes ch->max_combined = igc_get_max_rss_queues(adapter); 15058c5ad0daSSasha Neftin 15068c5ad0daSSasha Neftin /* Report info for other vector */ 15078c5ad0daSSasha Neftin if (adapter->flags & IGC_FLAG_HAS_MSIX) { 15088c5ad0daSSasha Neftin ch->max_other = NON_Q_VECTORS; 15098c5ad0daSSasha Neftin ch->other_count = NON_Q_VECTORS; 15108c5ad0daSSasha Neftin } 15118c5ad0daSSasha Neftin 15128c5ad0daSSasha Neftin ch->combined_count = adapter->rss_queues; 15138c5ad0daSSasha Neftin } 15148c5ad0daSSasha Neftin 15158c5ad0daSSasha Neftin static int igc_set_channels(struct net_device *netdev, 15168c5ad0daSSasha Neftin struct ethtool_channels *ch) 15178c5ad0daSSasha Neftin { 15188c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 15198c5ad0daSSasha Neftin unsigned int count = ch->combined_count; 15208c5ad0daSSasha Neftin unsigned int max_combined = 0; 15218c5ad0daSSasha Neftin 15228c5ad0daSSasha Neftin /* Verify they are not requesting separate vectors */ 15238c5ad0daSSasha Neftin if (!count || ch->rx_count || ch->tx_count) 15248c5ad0daSSasha Neftin return -EINVAL; 15258c5ad0daSSasha Neftin 15268c5ad0daSSasha Neftin /* Verify other_count is valid and has not been changed */ 15278c5ad0daSSasha Neftin if (ch->other_count != NON_Q_VECTORS) 15288c5ad0daSSasha Neftin return -EINVAL; 15298c5ad0daSSasha Neftin 15308c5ad0daSSasha Neftin /* Verify the number of channels doesn't exceed hw limits */ 15314d0710c2SAndre Guedes max_combined = igc_get_max_rss_queues(adapter); 15328c5ad0daSSasha Neftin if (count > max_combined) 15338c5ad0daSSasha Neftin return -EINVAL; 15348c5ad0daSSasha Neftin 15358c5ad0daSSasha Neftin if (count != adapter->rss_queues) { 15368c5ad0daSSasha Neftin adapter->rss_queues = count; 15378c5ad0daSSasha Neftin igc_set_flag_queue_pairs(adapter, max_combined); 15388c5ad0daSSasha Neftin 15398c5ad0daSSasha Neftin /* Hardware has to reinitialize queues and interrupts to 15408c5ad0daSSasha Neftin * match the new configuration. 15418c5ad0daSSasha Neftin */ 15428c5ad0daSSasha Neftin return igc_reinit_queues(adapter); 15438c5ad0daSSasha Neftin } 15448c5ad0daSSasha Neftin 15458c5ad0daSSasha Neftin return 0; 15468c5ad0daSSasha Neftin } 15478c5ad0daSSasha Neftin 154860dbede0SVinicius Costa Gomes static int igc_get_ts_info(struct net_device *dev, 154960dbede0SVinicius Costa Gomes struct ethtool_ts_info *info) 155060dbede0SVinicius Costa Gomes { 155160dbede0SVinicius Costa Gomes struct igc_adapter *adapter = netdev_priv(dev); 155260dbede0SVinicius Costa Gomes 155360dbede0SVinicius Costa Gomes if (adapter->ptp_clock) 155460dbede0SVinicius Costa Gomes info->phc_index = ptp_clock_index(adapter->ptp_clock); 155560dbede0SVinicius Costa Gomes else 155660dbede0SVinicius Costa Gomes info->phc_index = -1; 155760dbede0SVinicius Costa Gomes 155860dbede0SVinicius Costa Gomes switch (adapter->hw.mac.type) { 155960dbede0SVinicius Costa Gomes case igc_i225: 156060dbede0SVinicius Costa Gomes info->so_timestamping = 156160dbede0SVinicius Costa Gomes SOF_TIMESTAMPING_TX_SOFTWARE | 156260dbede0SVinicius Costa Gomes SOF_TIMESTAMPING_RX_SOFTWARE | 156360dbede0SVinicius Costa Gomes SOF_TIMESTAMPING_SOFTWARE | 156460dbede0SVinicius Costa Gomes SOF_TIMESTAMPING_TX_HARDWARE | 156560dbede0SVinicius Costa Gomes SOF_TIMESTAMPING_RX_HARDWARE | 156660dbede0SVinicius Costa Gomes SOF_TIMESTAMPING_RAW_HARDWARE; 156760dbede0SVinicius Costa Gomes 156860dbede0SVinicius Costa Gomes info->tx_types = 156960dbede0SVinicius Costa Gomes BIT(HWTSTAMP_TX_OFF) | 157060dbede0SVinicius Costa Gomes BIT(HWTSTAMP_TX_ON); 157160dbede0SVinicius Costa Gomes 157260dbede0SVinicius Costa Gomes info->rx_filters = BIT(HWTSTAMP_FILTER_NONE); 157360dbede0SVinicius Costa Gomes info->rx_filters |= BIT(HWTSTAMP_FILTER_ALL); 157460dbede0SVinicius Costa Gomes 157560dbede0SVinicius Costa Gomes return 0; 157660dbede0SVinicius Costa Gomes default: 157760dbede0SVinicius Costa Gomes return -EOPNOTSUPP; 157860dbede0SVinicius Costa Gomes } 157960dbede0SVinicius Costa Gomes } 158060dbede0SVinicius Costa Gomes 15818c5ad0daSSasha Neftin static u32 igc_get_priv_flags(struct net_device *netdev) 15828c5ad0daSSasha Neftin { 15838c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 15848c5ad0daSSasha Neftin u32 priv_flags = 0; 15858c5ad0daSSasha Neftin 15868c5ad0daSSasha Neftin if (adapter->flags & IGC_FLAG_RX_LEGACY) 15878c5ad0daSSasha Neftin priv_flags |= IGC_PRIV_FLAGS_LEGACY_RX; 15888c5ad0daSSasha Neftin 15898c5ad0daSSasha Neftin return priv_flags; 15908c5ad0daSSasha Neftin } 15918c5ad0daSSasha Neftin 15928c5ad0daSSasha Neftin static int igc_set_priv_flags(struct net_device *netdev, u32 priv_flags) 15938c5ad0daSSasha Neftin { 15948c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 15958c5ad0daSSasha Neftin unsigned int flags = adapter->flags; 15968c5ad0daSSasha Neftin 15978c5ad0daSSasha Neftin flags &= ~IGC_FLAG_RX_LEGACY; 15988c5ad0daSSasha Neftin if (priv_flags & IGC_PRIV_FLAGS_LEGACY_RX) 15998c5ad0daSSasha Neftin flags |= IGC_FLAG_RX_LEGACY; 16008c5ad0daSSasha Neftin 16018c5ad0daSSasha Neftin if (flags != adapter->flags) { 16028c5ad0daSSasha Neftin adapter->flags = flags; 16038c5ad0daSSasha Neftin 16048c5ad0daSSasha Neftin /* reset interface to repopulate queues */ 16058c5ad0daSSasha Neftin if (netif_running(netdev)) 16068c5ad0daSSasha Neftin igc_reinit_locked(adapter); 16078c5ad0daSSasha Neftin } 16088c5ad0daSSasha Neftin 16098c5ad0daSSasha Neftin return 0; 16108c5ad0daSSasha Neftin } 16118c5ad0daSSasha Neftin 16128c5ad0daSSasha Neftin static int igc_ethtool_begin(struct net_device *netdev) 16138c5ad0daSSasha Neftin { 16148c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 16158c5ad0daSSasha Neftin 16168c5ad0daSSasha Neftin pm_runtime_get_sync(&adapter->pdev->dev); 16178c5ad0daSSasha Neftin return 0; 16188c5ad0daSSasha Neftin } 16198c5ad0daSSasha Neftin 16208c5ad0daSSasha Neftin static void igc_ethtool_complete(struct net_device *netdev) 16218c5ad0daSSasha Neftin { 16228c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 16238c5ad0daSSasha Neftin 16248c5ad0daSSasha Neftin pm_runtime_put(&adapter->pdev->dev); 16258c5ad0daSSasha Neftin } 16268c5ad0daSSasha Neftin 16278c5ad0daSSasha Neftin static int igc_get_link_ksettings(struct net_device *netdev, 16288c5ad0daSSasha Neftin struct ethtool_link_ksettings *cmd) 16298c5ad0daSSasha Neftin { 16308c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 16318c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 16328c5ad0daSSasha Neftin u32 status; 16338c5ad0daSSasha Neftin u32 speed; 16348c5ad0daSSasha Neftin 16358c5ad0daSSasha Neftin ethtool_link_ksettings_zero_link_mode(cmd, supported); 16368c5ad0daSSasha Neftin ethtool_link_ksettings_zero_link_mode(cmd, advertising); 16378c5ad0daSSasha Neftin 16388c5ad0daSSasha Neftin /* supported link modes */ 16398c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Half); 16408c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Full); 16418c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Half); 16428c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Full); 16438c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, supported, 1000baseT_Full); 16448c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, supported, 2500baseT_Full); 16458c5ad0daSSasha Neftin 16468c5ad0daSSasha Neftin /* twisted pair */ 16478c5ad0daSSasha Neftin cmd->base.port = PORT_TP; 16488c5ad0daSSasha Neftin cmd->base.phy_address = hw->phy.addr; 16498c5ad0daSSasha Neftin 16508c5ad0daSSasha Neftin /* advertising link modes */ 16518c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 10baseT_Half); 16528c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 10baseT_Full); 16538c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 100baseT_Half); 16548c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 100baseT_Full); 16558c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 1000baseT_Full); 16568c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 2500baseT_Full); 16578c5ad0daSSasha Neftin 16588c5ad0daSSasha Neftin /* set autoneg settings */ 16598c5ad0daSSasha Neftin if (hw->mac.autoneg == 1) { 16608c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, supported, Autoneg); 16618c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 16628c5ad0daSSasha Neftin Autoneg); 16638c5ad0daSSasha Neftin } 16648c5ad0daSSasha Neftin 16658c5ad0daSSasha Neftin switch (hw->fc.requested_mode) { 16668c5ad0daSSasha Neftin case igc_fc_full: 16678c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause); 16688c5ad0daSSasha Neftin break; 16698c5ad0daSSasha Neftin case igc_fc_rx_pause: 16708c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause); 16718c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 16728c5ad0daSSasha Neftin Asym_Pause); 16738c5ad0daSSasha Neftin break; 16748c5ad0daSSasha Neftin case igc_fc_tx_pause: 16758c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 16768c5ad0daSSasha Neftin Asym_Pause); 16778c5ad0daSSasha Neftin break; 16788c5ad0daSSasha Neftin default: 16798c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause); 16808c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 16818c5ad0daSSasha Neftin Asym_Pause); 16828c5ad0daSSasha Neftin } 16838c5ad0daSSasha Neftin 16848c5ad0daSSasha Neftin status = rd32(IGC_STATUS); 16858c5ad0daSSasha Neftin 16868c5ad0daSSasha Neftin if (status & IGC_STATUS_LU) { 16878c5ad0daSSasha Neftin if (status & IGC_STATUS_SPEED_1000) { 16888c5ad0daSSasha Neftin /* For I225, STATUS will indicate 1G speed in both 16898c5ad0daSSasha Neftin * 1 Gbps and 2.5 Gbps link modes. 16908c5ad0daSSasha Neftin * An additional bit is used 16918c5ad0daSSasha Neftin * to differentiate between 1 Gbps and 2.5 Gbps. 16928c5ad0daSSasha Neftin */ 16938c5ad0daSSasha Neftin if (hw->mac.type == igc_i225 && 16948c5ad0daSSasha Neftin (status & IGC_STATUS_SPEED_2500)) { 16958c5ad0daSSasha Neftin speed = SPEED_2500; 16968c5ad0daSSasha Neftin } else { 16978c5ad0daSSasha Neftin speed = SPEED_1000; 16988c5ad0daSSasha Neftin } 16998c5ad0daSSasha Neftin } else if (status & IGC_STATUS_SPEED_100) { 17008c5ad0daSSasha Neftin speed = SPEED_100; 17018c5ad0daSSasha Neftin } else { 17028c5ad0daSSasha Neftin speed = SPEED_10; 17038c5ad0daSSasha Neftin } 17048c5ad0daSSasha Neftin if ((status & IGC_STATUS_FD) || 17058c5ad0daSSasha Neftin hw->phy.media_type != igc_media_type_copper) 17068c5ad0daSSasha Neftin cmd->base.duplex = DUPLEX_FULL; 17078c5ad0daSSasha Neftin else 17088c5ad0daSSasha Neftin cmd->base.duplex = DUPLEX_HALF; 17098c5ad0daSSasha Neftin } else { 17108c5ad0daSSasha Neftin speed = SPEED_UNKNOWN; 17118c5ad0daSSasha Neftin cmd->base.duplex = DUPLEX_UNKNOWN; 17128c5ad0daSSasha Neftin } 17138c5ad0daSSasha Neftin cmd->base.speed = speed; 17148c5ad0daSSasha Neftin if (hw->mac.autoneg) 17158c5ad0daSSasha Neftin cmd->base.autoneg = AUTONEG_ENABLE; 17168c5ad0daSSasha Neftin else 17178c5ad0daSSasha Neftin cmd->base.autoneg = AUTONEG_DISABLE; 17188c5ad0daSSasha Neftin 17198c5ad0daSSasha Neftin /* MDI-X => 2; MDI =>1; Invalid =>0 */ 17208c5ad0daSSasha Neftin if (hw->phy.media_type == igc_media_type_copper) 17218c5ad0daSSasha Neftin cmd->base.eth_tp_mdix = hw->phy.is_mdix ? ETH_TP_MDI_X : 17228c5ad0daSSasha Neftin ETH_TP_MDI; 17238c5ad0daSSasha Neftin else 17248c5ad0daSSasha Neftin cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID; 17258c5ad0daSSasha Neftin 17268c5ad0daSSasha Neftin if (hw->phy.mdix == AUTO_ALL_MODES) 17278c5ad0daSSasha Neftin cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO; 17288c5ad0daSSasha Neftin else 17298c5ad0daSSasha Neftin cmd->base.eth_tp_mdix_ctrl = hw->phy.mdix; 17308c5ad0daSSasha Neftin 17318c5ad0daSSasha Neftin return 0; 17328c5ad0daSSasha Neftin } 17338c5ad0daSSasha Neftin 17348c5ad0daSSasha Neftin static int igc_set_link_ksettings(struct net_device *netdev, 17358c5ad0daSSasha Neftin const struct ethtool_link_ksettings *cmd) 17368c5ad0daSSasha Neftin { 17378c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 173895f96a9fSAndre Guedes struct net_device *dev = adapter->netdev; 17398c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 17408c5ad0daSSasha Neftin u32 advertising; 17418c5ad0daSSasha Neftin 17428c5ad0daSSasha Neftin /* When adapter in resetting mode, autoneg/speed/duplex 17438c5ad0daSSasha Neftin * cannot be changed 17448c5ad0daSSasha Neftin */ 17458c5ad0daSSasha Neftin if (igc_check_reset_block(hw)) { 174695f96a9fSAndre Guedes netdev_err(dev, "Cannot change link characteristics when reset is active\n"); 17478c5ad0daSSasha Neftin return -EINVAL; 17488c5ad0daSSasha Neftin } 17498c5ad0daSSasha Neftin 17508c5ad0daSSasha Neftin /* MDI setting is only allowed when autoneg enabled because 17518c5ad0daSSasha Neftin * some hardware doesn't allow MDI setting when speed or 17528c5ad0daSSasha Neftin * duplex is forced. 17538c5ad0daSSasha Neftin */ 17548c5ad0daSSasha Neftin if (cmd->base.eth_tp_mdix_ctrl) { 17558c5ad0daSSasha Neftin if (cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO && 17568c5ad0daSSasha Neftin cmd->base.autoneg != AUTONEG_ENABLE) { 175795f96a9fSAndre Guedes netdev_err(dev, "Forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n"); 17588c5ad0daSSasha Neftin return -EINVAL; 17598c5ad0daSSasha Neftin } 17608c5ad0daSSasha Neftin } 17618c5ad0daSSasha Neftin 17628c5ad0daSSasha Neftin while (test_and_set_bit(__IGC_RESETTING, &adapter->state)) 17638c5ad0daSSasha Neftin usleep_range(1000, 2000); 17648c5ad0daSSasha Neftin 17658c5ad0daSSasha Neftin ethtool_convert_link_mode_to_legacy_u32(&advertising, 17668c5ad0daSSasha Neftin cmd->link_modes.advertising); 17678c5ad0daSSasha Neftin 17688c5ad0daSSasha Neftin if (cmd->base.autoneg == AUTONEG_ENABLE) { 17698c5ad0daSSasha Neftin hw->mac.autoneg = 1; 17708c5ad0daSSasha Neftin hw->phy.autoneg_advertised = advertising; 17718c5ad0daSSasha Neftin if (adapter->fc_autoneg) 17728c5ad0daSSasha Neftin hw->fc.requested_mode = igc_fc_default; 17738c5ad0daSSasha Neftin } else { 177495f96a9fSAndre Guedes netdev_info(dev, "Force mode currently not supported\n"); 17758c5ad0daSSasha Neftin } 17768c5ad0daSSasha Neftin 17778c5ad0daSSasha Neftin /* MDI-X => 2; MDI => 1; Auto => 3 */ 17788c5ad0daSSasha Neftin if (cmd->base.eth_tp_mdix_ctrl) { 17798c5ad0daSSasha Neftin /* fix up the value for auto (3 => 0) as zero is mapped 17808c5ad0daSSasha Neftin * internally to auto 17818c5ad0daSSasha Neftin */ 17828c5ad0daSSasha Neftin if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO) 17838c5ad0daSSasha Neftin hw->phy.mdix = AUTO_ALL_MODES; 17848c5ad0daSSasha Neftin else 17858c5ad0daSSasha Neftin hw->phy.mdix = cmd->base.eth_tp_mdix_ctrl; 17868c5ad0daSSasha Neftin } 17878c5ad0daSSasha Neftin 17888c5ad0daSSasha Neftin /* reset the link */ 17898c5ad0daSSasha Neftin if (netif_running(adapter->netdev)) { 17908c5ad0daSSasha Neftin igc_down(adapter); 17918c5ad0daSSasha Neftin igc_up(adapter); 17928c5ad0daSSasha Neftin } else { 17938c5ad0daSSasha Neftin igc_reset(adapter); 17948c5ad0daSSasha Neftin } 17958c5ad0daSSasha Neftin 17968c5ad0daSSasha Neftin clear_bit(__IGC_RESETTING, &adapter->state); 17978c5ad0daSSasha Neftin 17988c5ad0daSSasha Neftin return 0; 17998c5ad0daSSasha Neftin } 18008c5ad0daSSasha Neftin 1801f026d8caSVitaly Lifshits static void igc_diag_test(struct net_device *netdev, 1802f026d8caSVitaly Lifshits struct ethtool_test *eth_test, u64 *data) 1803f026d8caSVitaly Lifshits { 1804f026d8caSVitaly Lifshits struct igc_adapter *adapter = netdev_priv(netdev); 1805f026d8caSVitaly Lifshits bool if_running = netif_running(netdev); 1806f026d8caSVitaly Lifshits 1807f026d8caSVitaly Lifshits if (eth_test->flags == ETH_TEST_FL_OFFLINE) { 180895f96a9fSAndre Guedes netdev_info(adapter->netdev, "Offline testing starting"); 1809f026d8caSVitaly Lifshits set_bit(__IGC_TESTING, &adapter->state); 1810f026d8caSVitaly Lifshits 1811f026d8caSVitaly Lifshits /* Link test performed before hardware reset so autoneg doesn't 1812f026d8caSVitaly Lifshits * interfere with test result 1813f026d8caSVitaly Lifshits */ 1814f026d8caSVitaly Lifshits if (!igc_link_test(adapter, &data[TEST_LINK])) 1815f026d8caSVitaly Lifshits eth_test->flags |= ETH_TEST_FL_FAILED; 1816f026d8caSVitaly Lifshits 1817f026d8caSVitaly Lifshits if (if_running) 1818f026d8caSVitaly Lifshits igc_close(netdev); 1819f026d8caSVitaly Lifshits else 1820f026d8caSVitaly Lifshits igc_reset(adapter); 1821f026d8caSVitaly Lifshits 182295f96a9fSAndre Guedes netdev_info(adapter->netdev, "Register testing starting"); 1823f026d8caSVitaly Lifshits if (!igc_reg_test(adapter, &data[TEST_REG])) 1824f026d8caSVitaly Lifshits eth_test->flags |= ETH_TEST_FL_FAILED; 1825f026d8caSVitaly Lifshits 1826f026d8caSVitaly Lifshits igc_reset(adapter); 1827f026d8caSVitaly Lifshits 182895f96a9fSAndre Guedes netdev_info(adapter->netdev, "EEPROM testing starting"); 1829f026d8caSVitaly Lifshits if (!igc_eeprom_test(adapter, &data[TEST_EEP])) 1830f026d8caSVitaly Lifshits eth_test->flags |= ETH_TEST_FL_FAILED; 1831f026d8caSVitaly Lifshits 1832f026d8caSVitaly Lifshits igc_reset(adapter); 1833f026d8caSVitaly Lifshits 1834f026d8caSVitaly Lifshits /* loopback and interrupt tests 1835f026d8caSVitaly Lifshits * will be implemented in the future 1836f026d8caSVitaly Lifshits */ 1837f026d8caSVitaly Lifshits data[TEST_LOOP] = 0; 1838f026d8caSVitaly Lifshits data[TEST_IRQ] = 0; 1839f026d8caSVitaly Lifshits 1840f026d8caSVitaly Lifshits clear_bit(__IGC_TESTING, &adapter->state); 1841f026d8caSVitaly Lifshits if (if_running) 1842f026d8caSVitaly Lifshits igc_open(netdev); 1843f026d8caSVitaly Lifshits } else { 184495f96a9fSAndre Guedes netdev_info(adapter->netdev, "Online testing starting"); 1845f026d8caSVitaly Lifshits 1846f026d8caSVitaly Lifshits /* register, eeprom, intr and loopback tests not run online */ 1847f026d8caSVitaly Lifshits data[TEST_REG] = 0; 1848f026d8caSVitaly Lifshits data[TEST_EEP] = 0; 1849f026d8caSVitaly Lifshits data[TEST_IRQ] = 0; 1850f026d8caSVitaly Lifshits data[TEST_LOOP] = 0; 1851f026d8caSVitaly Lifshits 1852f026d8caSVitaly Lifshits if (!igc_link_test(adapter, &data[TEST_LINK])) 1853f026d8caSVitaly Lifshits eth_test->flags |= ETH_TEST_FL_FAILED; 1854f026d8caSVitaly Lifshits } 1855f026d8caSVitaly Lifshits 1856f026d8caSVitaly Lifshits msleep_interruptible(4 * 1000); 1857f026d8caSVitaly Lifshits } 1858f026d8caSVitaly Lifshits 18598c5ad0daSSasha Neftin static const struct ethtool_ops igc_ethtool_ops = { 1860dbfa497aSJakub Kicinski .supported_coalesce_params = ETHTOOL_COALESCE_USECS, 18618c5ad0daSSasha Neftin .get_drvinfo = igc_get_drvinfo, 18628c5ad0daSSasha Neftin .get_regs_len = igc_get_regs_len, 18638c5ad0daSSasha Neftin .get_regs = igc_get_regs, 1864e055600dSSasha Neftin .get_wol = igc_get_wol, 1865e055600dSSasha Neftin .set_wol = igc_set_wol, 18668c5ad0daSSasha Neftin .get_msglevel = igc_get_msglevel, 18678c5ad0daSSasha Neftin .set_msglevel = igc_set_msglevel, 18688c5ad0daSSasha Neftin .nway_reset = igc_nway_reset, 18698c5ad0daSSasha Neftin .get_link = igc_get_link, 18708c5ad0daSSasha Neftin .get_eeprom_len = igc_get_eeprom_len, 18718c5ad0daSSasha Neftin .get_eeprom = igc_get_eeprom, 18728c5ad0daSSasha Neftin .set_eeprom = igc_set_eeprom, 18738c5ad0daSSasha Neftin .get_ringparam = igc_get_ringparam, 18748c5ad0daSSasha Neftin .set_ringparam = igc_set_ringparam, 18758c5ad0daSSasha Neftin .get_pauseparam = igc_get_pauseparam, 18768c5ad0daSSasha Neftin .set_pauseparam = igc_set_pauseparam, 187736b9fea6SSasha Neftin .get_strings = igc_get_strings, 187836b9fea6SSasha Neftin .get_sset_count = igc_get_sset_count, 187936b9fea6SSasha Neftin .get_ethtool_stats = igc_get_ethtool_stats, 18808c5ad0daSSasha Neftin .get_coalesce = igc_get_coalesce, 18818c5ad0daSSasha Neftin .set_coalesce = igc_set_coalesce, 18826245c848SSasha Neftin .get_rxnfc = igc_get_rxnfc, 18836245c848SSasha Neftin .set_rxnfc = igc_set_rxnfc, 18848c5ad0daSSasha Neftin .get_rxfh_indir_size = igc_get_rxfh_indir_size, 18858c5ad0daSSasha Neftin .get_rxfh = igc_get_rxfh, 18868c5ad0daSSasha Neftin .set_rxfh = igc_set_rxfh, 188760dbede0SVinicius Costa Gomes .get_ts_info = igc_get_ts_info, 18888c5ad0daSSasha Neftin .get_channels = igc_get_channels, 18898c5ad0daSSasha Neftin .set_channels = igc_set_channels, 18908c5ad0daSSasha Neftin .get_priv_flags = igc_get_priv_flags, 18918c5ad0daSSasha Neftin .set_priv_flags = igc_set_priv_flags, 18928c5ad0daSSasha Neftin .begin = igc_ethtool_begin, 18938c5ad0daSSasha Neftin .complete = igc_ethtool_complete, 18948c5ad0daSSasha Neftin .get_link_ksettings = igc_get_link_ksettings, 18958c5ad0daSSasha Neftin .set_link_ksettings = igc_set_link_ksettings, 1896f026d8caSVitaly Lifshits .self_test = igc_diag_test, 18978c5ad0daSSasha Neftin }; 18988c5ad0daSSasha Neftin 18998c5ad0daSSasha Neftin void igc_set_ethtool_ops(struct net_device *netdev) 19008c5ad0daSSasha Neftin { 19018c5ad0daSSasha Neftin netdev->ethtool_ops = &igc_ethtool_ops; 19028c5ad0daSSasha Neftin } 1903