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)); 319*fbee4760SAndre Guedes 320*fbee4760SAndre Guedes regs_buff[204] = rd32(IGC_VLANPQF); 3218c5ad0daSSasha Neftin } 3228c5ad0daSSasha Neftin 323e055600dSSasha Neftin static void igc_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol) 324e055600dSSasha Neftin { 325e055600dSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 326e055600dSSasha Neftin 327e055600dSSasha Neftin wol->wolopts = 0; 328e055600dSSasha Neftin 329e055600dSSasha Neftin if (!(adapter->flags & IGC_FLAG_WOL_SUPPORTED)) 330e055600dSSasha Neftin return; 331e055600dSSasha Neftin 332e055600dSSasha Neftin wol->supported = WAKE_UCAST | WAKE_MCAST | 333e055600dSSasha Neftin WAKE_BCAST | WAKE_MAGIC | 334e055600dSSasha Neftin WAKE_PHY; 335e055600dSSasha Neftin 336e055600dSSasha Neftin /* apply any specific unsupported masks here */ 337e055600dSSasha Neftin switch (adapter->hw.device_id) { 338e055600dSSasha Neftin default: 339e055600dSSasha Neftin break; 340e055600dSSasha Neftin } 341e055600dSSasha Neftin 342e055600dSSasha Neftin if (adapter->wol & IGC_WUFC_EX) 343e055600dSSasha Neftin wol->wolopts |= WAKE_UCAST; 344e055600dSSasha Neftin if (adapter->wol & IGC_WUFC_MC) 345e055600dSSasha Neftin wol->wolopts |= WAKE_MCAST; 346e055600dSSasha Neftin if (adapter->wol & IGC_WUFC_BC) 347e055600dSSasha Neftin wol->wolopts |= WAKE_BCAST; 348e055600dSSasha Neftin if (adapter->wol & IGC_WUFC_MAG) 349e055600dSSasha Neftin wol->wolopts |= WAKE_MAGIC; 350e055600dSSasha Neftin if (adapter->wol & IGC_WUFC_LNKC) 351e055600dSSasha Neftin wol->wolopts |= WAKE_PHY; 352e055600dSSasha Neftin } 353e055600dSSasha Neftin 354e055600dSSasha Neftin static int igc_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol) 355e055600dSSasha Neftin { 356e055600dSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 357e055600dSSasha Neftin 358e055600dSSasha Neftin if (wol->wolopts & (WAKE_ARP | WAKE_MAGICSECURE | WAKE_FILTER)) 359e055600dSSasha Neftin return -EOPNOTSUPP; 360e055600dSSasha Neftin 361e055600dSSasha Neftin if (!(adapter->flags & IGC_FLAG_WOL_SUPPORTED)) 362e055600dSSasha Neftin return wol->wolopts ? -EOPNOTSUPP : 0; 363e055600dSSasha Neftin 364e055600dSSasha Neftin /* these settings will always override what we currently have */ 365e055600dSSasha Neftin adapter->wol = 0; 366e055600dSSasha Neftin 367e055600dSSasha Neftin if (wol->wolopts & WAKE_UCAST) 368e055600dSSasha Neftin adapter->wol |= IGC_WUFC_EX; 369e055600dSSasha Neftin if (wol->wolopts & WAKE_MCAST) 370e055600dSSasha Neftin adapter->wol |= IGC_WUFC_MC; 371e055600dSSasha Neftin if (wol->wolopts & WAKE_BCAST) 372e055600dSSasha Neftin adapter->wol |= IGC_WUFC_BC; 373e055600dSSasha Neftin if (wol->wolopts & WAKE_MAGIC) 374e055600dSSasha Neftin adapter->wol |= IGC_WUFC_MAG; 375e055600dSSasha Neftin if (wol->wolopts & WAKE_PHY) 376e055600dSSasha Neftin adapter->wol |= IGC_WUFC_LNKC; 377e055600dSSasha Neftin device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol); 378e055600dSSasha Neftin 379e055600dSSasha Neftin return 0; 380e055600dSSasha Neftin } 381e055600dSSasha Neftin 3828c5ad0daSSasha Neftin static u32 igc_get_msglevel(struct net_device *netdev) 3838c5ad0daSSasha Neftin { 3848c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 3858c5ad0daSSasha Neftin 3868c5ad0daSSasha Neftin return adapter->msg_enable; 3878c5ad0daSSasha Neftin } 3888c5ad0daSSasha Neftin 3898c5ad0daSSasha Neftin static void igc_set_msglevel(struct net_device *netdev, u32 data) 3908c5ad0daSSasha Neftin { 3918c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 3928c5ad0daSSasha Neftin 3938c5ad0daSSasha Neftin adapter->msg_enable = data; 3948c5ad0daSSasha Neftin } 3958c5ad0daSSasha Neftin 3968c5ad0daSSasha Neftin static int igc_nway_reset(struct net_device *netdev) 3978c5ad0daSSasha Neftin { 3988c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 3998c5ad0daSSasha Neftin 4008c5ad0daSSasha Neftin if (netif_running(netdev)) 4018c5ad0daSSasha Neftin igc_reinit_locked(adapter); 4028c5ad0daSSasha Neftin return 0; 4038c5ad0daSSasha Neftin } 4048c5ad0daSSasha Neftin 4058c5ad0daSSasha Neftin static u32 igc_get_link(struct net_device *netdev) 4068c5ad0daSSasha Neftin { 4078c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 4088c5ad0daSSasha Neftin struct igc_mac_info *mac = &adapter->hw.mac; 4098c5ad0daSSasha Neftin 4108c5ad0daSSasha Neftin /* If the link is not reported up to netdev, interrupts are disabled, 4118c5ad0daSSasha Neftin * and so the physical link state may have changed since we last 4128c5ad0daSSasha Neftin * looked. Set get_link_status to make sure that the true link 4138c5ad0daSSasha Neftin * state is interrogated, rather than pulling a cached and possibly 4148c5ad0daSSasha Neftin * stale link state from the driver. 4158c5ad0daSSasha Neftin */ 4168c5ad0daSSasha Neftin if (!netif_carrier_ok(netdev)) 4178c5ad0daSSasha Neftin mac->get_link_status = 1; 4188c5ad0daSSasha Neftin 4198c5ad0daSSasha Neftin return igc_has_link(adapter); 4208c5ad0daSSasha Neftin } 4218c5ad0daSSasha Neftin 4228c5ad0daSSasha Neftin static int igc_get_eeprom_len(struct net_device *netdev) 4238c5ad0daSSasha Neftin { 4248c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 4258c5ad0daSSasha Neftin 4268c5ad0daSSasha Neftin return adapter->hw.nvm.word_size * 2; 4278c5ad0daSSasha Neftin } 4288c5ad0daSSasha Neftin 4298c5ad0daSSasha Neftin static int igc_get_eeprom(struct net_device *netdev, 4308c5ad0daSSasha Neftin struct ethtool_eeprom *eeprom, u8 *bytes) 4318c5ad0daSSasha Neftin { 4328c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 4338c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 4348c5ad0daSSasha Neftin int first_word, last_word; 4358c5ad0daSSasha Neftin u16 *eeprom_buff; 4368c5ad0daSSasha Neftin int ret_val = 0; 4378c5ad0daSSasha Neftin u16 i; 4388c5ad0daSSasha Neftin 4398c5ad0daSSasha Neftin if (eeprom->len == 0) 4408c5ad0daSSasha Neftin return -EINVAL; 4418c5ad0daSSasha Neftin 4428c5ad0daSSasha Neftin eeprom->magic = hw->vendor_id | (hw->device_id << 16); 4438c5ad0daSSasha Neftin 4448c5ad0daSSasha Neftin first_word = eeprom->offset >> 1; 4458c5ad0daSSasha Neftin last_word = (eeprom->offset + eeprom->len - 1) >> 1; 4468c5ad0daSSasha Neftin 4478c5ad0daSSasha Neftin eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16), 4488c5ad0daSSasha Neftin GFP_KERNEL); 4498c5ad0daSSasha Neftin if (!eeprom_buff) 4508c5ad0daSSasha Neftin return -ENOMEM; 4518c5ad0daSSasha Neftin 4528c5ad0daSSasha Neftin if (hw->nvm.type == igc_nvm_eeprom_spi) { 4538c5ad0daSSasha Neftin ret_val = hw->nvm.ops.read(hw, first_word, 4548c5ad0daSSasha Neftin last_word - first_word + 1, 4558c5ad0daSSasha Neftin eeprom_buff); 4568c5ad0daSSasha Neftin } else { 4578c5ad0daSSasha Neftin for (i = 0; i < last_word - first_word + 1; i++) { 4588c5ad0daSSasha Neftin ret_val = hw->nvm.ops.read(hw, first_word + i, 1, 4598c5ad0daSSasha Neftin &eeprom_buff[i]); 4608c5ad0daSSasha Neftin if (ret_val) 4618c5ad0daSSasha Neftin break; 4628c5ad0daSSasha Neftin } 4638c5ad0daSSasha Neftin } 4648c5ad0daSSasha Neftin 4658c5ad0daSSasha Neftin /* Device's eeprom is always little-endian, word addressable */ 4668c5ad0daSSasha Neftin for (i = 0; i < last_word - first_word + 1; i++) 4678c5ad0daSSasha Neftin le16_to_cpus(&eeprom_buff[i]); 4688c5ad0daSSasha Neftin 4698c5ad0daSSasha Neftin memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1), 4708c5ad0daSSasha Neftin eeprom->len); 4718c5ad0daSSasha Neftin kfree(eeprom_buff); 4728c5ad0daSSasha Neftin 4738c5ad0daSSasha Neftin return ret_val; 4748c5ad0daSSasha Neftin } 4758c5ad0daSSasha Neftin 4768c5ad0daSSasha Neftin static int igc_set_eeprom(struct net_device *netdev, 4778c5ad0daSSasha Neftin struct ethtool_eeprom *eeprom, u8 *bytes) 4788c5ad0daSSasha Neftin { 4798c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 4808c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 4818c5ad0daSSasha Neftin int max_len, first_word, last_word, ret_val = 0; 4828c5ad0daSSasha Neftin u16 *eeprom_buff; 4838c5ad0daSSasha Neftin void *ptr; 4848c5ad0daSSasha Neftin u16 i; 4858c5ad0daSSasha Neftin 4868c5ad0daSSasha Neftin if (eeprom->len == 0) 4878c5ad0daSSasha Neftin return -EOPNOTSUPP; 4888c5ad0daSSasha Neftin 4898c5ad0daSSasha Neftin if (hw->mac.type >= igc_i225 && 4908c5ad0daSSasha Neftin !igc_get_flash_presence_i225(hw)) { 4918c5ad0daSSasha Neftin return -EOPNOTSUPP; 4928c5ad0daSSasha Neftin } 4938c5ad0daSSasha Neftin 4948c5ad0daSSasha Neftin if (eeprom->magic != (hw->vendor_id | (hw->device_id << 16))) 4958c5ad0daSSasha Neftin return -EFAULT; 4968c5ad0daSSasha Neftin 4978c5ad0daSSasha Neftin max_len = hw->nvm.word_size * 2; 4988c5ad0daSSasha Neftin 4998c5ad0daSSasha Neftin first_word = eeprom->offset >> 1; 5008c5ad0daSSasha Neftin last_word = (eeprom->offset + eeprom->len - 1) >> 1; 5018c5ad0daSSasha Neftin eeprom_buff = kmalloc(max_len, GFP_KERNEL); 5028c5ad0daSSasha Neftin if (!eeprom_buff) 5038c5ad0daSSasha Neftin return -ENOMEM; 5048c5ad0daSSasha Neftin 5058c5ad0daSSasha Neftin ptr = (void *)eeprom_buff; 5068c5ad0daSSasha Neftin 5078c5ad0daSSasha Neftin if (eeprom->offset & 1) { 5088c5ad0daSSasha Neftin /* need read/modify/write of first changed EEPROM word 5098c5ad0daSSasha Neftin * only the second byte of the word is being modified 5108c5ad0daSSasha Neftin */ 5118c5ad0daSSasha Neftin ret_val = hw->nvm.ops.read(hw, first_word, 1, 5128c5ad0daSSasha Neftin &eeprom_buff[0]); 5138c5ad0daSSasha Neftin ptr++; 5148c5ad0daSSasha Neftin } 5158c5ad0daSSasha Neftin if (((eeprom->offset + eeprom->len) & 1) && ret_val == 0) { 5168c5ad0daSSasha Neftin /* need read/modify/write of last changed EEPROM word 5178c5ad0daSSasha Neftin * only the first byte of the word is being modified 5188c5ad0daSSasha Neftin */ 5198c5ad0daSSasha Neftin ret_val = hw->nvm.ops.read(hw, last_word, 1, 5208c5ad0daSSasha Neftin &eeprom_buff[last_word - first_word]); 5218c5ad0daSSasha Neftin } 5228c5ad0daSSasha Neftin 5238c5ad0daSSasha Neftin /* Device's eeprom is always little-endian, word addressable */ 5248c5ad0daSSasha Neftin for (i = 0; i < last_word - first_word + 1; i++) 5258c5ad0daSSasha Neftin le16_to_cpus(&eeprom_buff[i]); 5268c5ad0daSSasha Neftin 5278c5ad0daSSasha Neftin memcpy(ptr, bytes, eeprom->len); 5288c5ad0daSSasha Neftin 5298c5ad0daSSasha Neftin for (i = 0; i < last_word - first_word + 1; i++) 5308c5ad0daSSasha Neftin eeprom_buff[i] = cpu_to_le16(eeprom_buff[i]); 5318c5ad0daSSasha Neftin 5328c5ad0daSSasha Neftin ret_val = hw->nvm.ops.write(hw, first_word, 5338c5ad0daSSasha Neftin last_word - first_word + 1, eeprom_buff); 5348c5ad0daSSasha Neftin 5358c5ad0daSSasha Neftin /* Update the checksum if nvm write succeeded */ 5368c5ad0daSSasha Neftin if (ret_val == 0) 5378c5ad0daSSasha Neftin hw->nvm.ops.update(hw); 5388c5ad0daSSasha Neftin 5398c5ad0daSSasha Neftin /* check if need: igc_set_fw_version(adapter); */ 5408c5ad0daSSasha Neftin kfree(eeprom_buff); 5418c5ad0daSSasha Neftin return ret_val; 5428c5ad0daSSasha Neftin } 5438c5ad0daSSasha Neftin 5448c5ad0daSSasha Neftin static void igc_get_ringparam(struct net_device *netdev, 5458c5ad0daSSasha Neftin struct ethtool_ringparam *ring) 5468c5ad0daSSasha Neftin { 5478c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 5488c5ad0daSSasha Neftin 5498c5ad0daSSasha Neftin ring->rx_max_pending = IGC_MAX_RXD; 5508c5ad0daSSasha Neftin ring->tx_max_pending = IGC_MAX_TXD; 5518c5ad0daSSasha Neftin ring->rx_pending = adapter->rx_ring_count; 5528c5ad0daSSasha Neftin ring->tx_pending = adapter->tx_ring_count; 5538c5ad0daSSasha Neftin } 5548c5ad0daSSasha Neftin 5558c5ad0daSSasha Neftin static int igc_set_ringparam(struct net_device *netdev, 5568c5ad0daSSasha Neftin struct ethtool_ringparam *ring) 5578c5ad0daSSasha Neftin { 5588c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 5598c5ad0daSSasha Neftin struct igc_ring *temp_ring; 5608c5ad0daSSasha Neftin u16 new_rx_count, new_tx_count; 5618c5ad0daSSasha Neftin int i, err = 0; 5628c5ad0daSSasha Neftin 5638c5ad0daSSasha Neftin if (ring->rx_mini_pending || ring->rx_jumbo_pending) 5648c5ad0daSSasha Neftin return -EINVAL; 5658c5ad0daSSasha Neftin 5668c5ad0daSSasha Neftin new_rx_count = min_t(u32, ring->rx_pending, IGC_MAX_RXD); 5678c5ad0daSSasha Neftin new_rx_count = max_t(u16, new_rx_count, IGC_MIN_RXD); 5688c5ad0daSSasha Neftin new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE); 5698c5ad0daSSasha Neftin 5708c5ad0daSSasha Neftin new_tx_count = min_t(u32, ring->tx_pending, IGC_MAX_TXD); 5718c5ad0daSSasha Neftin new_tx_count = max_t(u16, new_tx_count, IGC_MIN_TXD); 5728c5ad0daSSasha Neftin new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE); 5738c5ad0daSSasha Neftin 5748c5ad0daSSasha Neftin if (new_tx_count == adapter->tx_ring_count && 5758c5ad0daSSasha Neftin new_rx_count == adapter->rx_ring_count) { 5768c5ad0daSSasha Neftin /* nothing to do */ 5778c5ad0daSSasha Neftin return 0; 5788c5ad0daSSasha Neftin } 5798c5ad0daSSasha Neftin 5808c5ad0daSSasha Neftin while (test_and_set_bit(__IGC_RESETTING, &adapter->state)) 5818c5ad0daSSasha Neftin usleep_range(1000, 2000); 5828c5ad0daSSasha Neftin 5838c5ad0daSSasha Neftin if (!netif_running(adapter->netdev)) { 5848c5ad0daSSasha Neftin for (i = 0; i < adapter->num_tx_queues; i++) 5858c5ad0daSSasha Neftin adapter->tx_ring[i]->count = new_tx_count; 5868c5ad0daSSasha Neftin for (i = 0; i < adapter->num_rx_queues; i++) 5878c5ad0daSSasha Neftin adapter->rx_ring[i]->count = new_rx_count; 5888c5ad0daSSasha Neftin adapter->tx_ring_count = new_tx_count; 5898c5ad0daSSasha Neftin adapter->rx_ring_count = new_rx_count; 5908c5ad0daSSasha Neftin goto clear_reset; 5918c5ad0daSSasha Neftin } 5928c5ad0daSSasha Neftin 5938c5ad0daSSasha Neftin if (adapter->num_tx_queues > adapter->num_rx_queues) 5948c5ad0daSSasha Neftin temp_ring = vmalloc(array_size(sizeof(struct igc_ring), 5958c5ad0daSSasha Neftin adapter->num_tx_queues)); 5968c5ad0daSSasha Neftin else 5978c5ad0daSSasha Neftin temp_ring = vmalloc(array_size(sizeof(struct igc_ring), 5988c5ad0daSSasha Neftin adapter->num_rx_queues)); 5998c5ad0daSSasha Neftin 6008c5ad0daSSasha Neftin if (!temp_ring) { 6018c5ad0daSSasha Neftin err = -ENOMEM; 6028c5ad0daSSasha Neftin goto clear_reset; 6038c5ad0daSSasha Neftin } 6048c5ad0daSSasha Neftin 6058c5ad0daSSasha Neftin igc_down(adapter); 6068c5ad0daSSasha Neftin 6078c5ad0daSSasha Neftin /* We can't just free everything and then setup again, 6088c5ad0daSSasha Neftin * because the ISRs in MSI-X mode get passed pointers 6098c5ad0daSSasha Neftin * to the Tx and Rx ring structs. 6108c5ad0daSSasha Neftin */ 6118c5ad0daSSasha Neftin if (new_tx_count != adapter->tx_ring_count) { 6128c5ad0daSSasha Neftin for (i = 0; i < adapter->num_tx_queues; i++) { 6138c5ad0daSSasha Neftin memcpy(&temp_ring[i], adapter->tx_ring[i], 6148c5ad0daSSasha Neftin sizeof(struct igc_ring)); 6158c5ad0daSSasha Neftin 6168c5ad0daSSasha Neftin temp_ring[i].count = new_tx_count; 6178c5ad0daSSasha Neftin err = igc_setup_tx_resources(&temp_ring[i]); 6188c5ad0daSSasha Neftin if (err) { 6198c5ad0daSSasha Neftin while (i) { 6208c5ad0daSSasha Neftin i--; 6218c5ad0daSSasha Neftin igc_free_tx_resources(&temp_ring[i]); 6228c5ad0daSSasha Neftin } 6238c5ad0daSSasha Neftin goto err_setup; 6248c5ad0daSSasha Neftin } 6258c5ad0daSSasha Neftin } 6268c5ad0daSSasha Neftin 6278c5ad0daSSasha Neftin for (i = 0; i < adapter->num_tx_queues; i++) { 6288c5ad0daSSasha Neftin igc_free_tx_resources(adapter->tx_ring[i]); 6298c5ad0daSSasha Neftin 6308c5ad0daSSasha Neftin memcpy(adapter->tx_ring[i], &temp_ring[i], 6318c5ad0daSSasha Neftin sizeof(struct igc_ring)); 6328c5ad0daSSasha Neftin } 6338c5ad0daSSasha Neftin 6348c5ad0daSSasha Neftin adapter->tx_ring_count = new_tx_count; 6358c5ad0daSSasha Neftin } 6368c5ad0daSSasha Neftin 6378c5ad0daSSasha Neftin if (new_rx_count != adapter->rx_ring_count) { 6388c5ad0daSSasha Neftin for (i = 0; i < adapter->num_rx_queues; i++) { 6398c5ad0daSSasha Neftin memcpy(&temp_ring[i], adapter->rx_ring[i], 6408c5ad0daSSasha Neftin sizeof(struct igc_ring)); 6418c5ad0daSSasha Neftin 6428c5ad0daSSasha Neftin temp_ring[i].count = new_rx_count; 6438c5ad0daSSasha Neftin err = igc_setup_rx_resources(&temp_ring[i]); 6448c5ad0daSSasha Neftin if (err) { 6458c5ad0daSSasha Neftin while (i) { 6468c5ad0daSSasha Neftin i--; 6478c5ad0daSSasha Neftin igc_free_rx_resources(&temp_ring[i]); 6488c5ad0daSSasha Neftin } 6498c5ad0daSSasha Neftin goto err_setup; 6508c5ad0daSSasha Neftin } 6518c5ad0daSSasha Neftin } 6528c5ad0daSSasha Neftin 6538c5ad0daSSasha Neftin for (i = 0; i < adapter->num_rx_queues; i++) { 6548c5ad0daSSasha Neftin igc_free_rx_resources(adapter->rx_ring[i]); 6558c5ad0daSSasha Neftin 6568c5ad0daSSasha Neftin memcpy(adapter->rx_ring[i], &temp_ring[i], 6578c5ad0daSSasha Neftin sizeof(struct igc_ring)); 6588c5ad0daSSasha Neftin } 6598c5ad0daSSasha Neftin 6608c5ad0daSSasha Neftin adapter->rx_ring_count = new_rx_count; 6618c5ad0daSSasha Neftin } 6628c5ad0daSSasha Neftin err_setup: 6638c5ad0daSSasha Neftin igc_up(adapter); 6648c5ad0daSSasha Neftin vfree(temp_ring); 6658c5ad0daSSasha Neftin clear_reset: 6668c5ad0daSSasha Neftin clear_bit(__IGC_RESETTING, &adapter->state); 6678c5ad0daSSasha Neftin return err; 6688c5ad0daSSasha Neftin } 6698c5ad0daSSasha Neftin 6708c5ad0daSSasha Neftin static void igc_get_pauseparam(struct net_device *netdev, 6718c5ad0daSSasha Neftin struct ethtool_pauseparam *pause) 6728c5ad0daSSasha Neftin { 6738c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 6748c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 6758c5ad0daSSasha Neftin 6768c5ad0daSSasha Neftin pause->autoneg = 6778c5ad0daSSasha Neftin (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE); 6788c5ad0daSSasha Neftin 6798c5ad0daSSasha Neftin if (hw->fc.current_mode == igc_fc_rx_pause) { 6808c5ad0daSSasha Neftin pause->rx_pause = 1; 6818c5ad0daSSasha Neftin } else if (hw->fc.current_mode == igc_fc_tx_pause) { 6828c5ad0daSSasha Neftin pause->tx_pause = 1; 6838c5ad0daSSasha Neftin } else if (hw->fc.current_mode == igc_fc_full) { 6848c5ad0daSSasha Neftin pause->rx_pause = 1; 6858c5ad0daSSasha Neftin pause->tx_pause = 1; 6868c5ad0daSSasha Neftin } 6878c5ad0daSSasha Neftin } 6888c5ad0daSSasha Neftin 6898c5ad0daSSasha Neftin static int igc_set_pauseparam(struct net_device *netdev, 6908c5ad0daSSasha Neftin struct ethtool_pauseparam *pause) 6918c5ad0daSSasha Neftin { 6928c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 6938c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 6948c5ad0daSSasha Neftin int retval = 0; 6958c5ad0daSSasha Neftin 6968c5ad0daSSasha Neftin adapter->fc_autoneg = pause->autoneg; 6978c5ad0daSSasha Neftin 6988c5ad0daSSasha Neftin while (test_and_set_bit(__IGC_RESETTING, &adapter->state)) 6998c5ad0daSSasha Neftin usleep_range(1000, 2000); 7008c5ad0daSSasha Neftin 7018c5ad0daSSasha Neftin if (adapter->fc_autoneg == AUTONEG_ENABLE) { 7028c5ad0daSSasha Neftin hw->fc.requested_mode = igc_fc_default; 7038c5ad0daSSasha Neftin if (netif_running(adapter->netdev)) { 7048c5ad0daSSasha Neftin igc_down(adapter); 7058c5ad0daSSasha Neftin igc_up(adapter); 7068c5ad0daSSasha Neftin } else { 7078c5ad0daSSasha Neftin igc_reset(adapter); 7088c5ad0daSSasha Neftin } 7098c5ad0daSSasha Neftin } else { 7108c5ad0daSSasha Neftin if (pause->rx_pause && pause->tx_pause) 7118c5ad0daSSasha Neftin hw->fc.requested_mode = igc_fc_full; 7128c5ad0daSSasha Neftin else if (pause->rx_pause && !pause->tx_pause) 7138c5ad0daSSasha Neftin hw->fc.requested_mode = igc_fc_rx_pause; 7148c5ad0daSSasha Neftin else if (!pause->rx_pause && pause->tx_pause) 7158c5ad0daSSasha Neftin hw->fc.requested_mode = igc_fc_tx_pause; 7168c5ad0daSSasha Neftin else if (!pause->rx_pause && !pause->tx_pause) 7178c5ad0daSSasha Neftin hw->fc.requested_mode = igc_fc_none; 7188c5ad0daSSasha Neftin 7198c5ad0daSSasha Neftin hw->fc.current_mode = hw->fc.requested_mode; 7208c5ad0daSSasha Neftin 7218c5ad0daSSasha Neftin retval = ((hw->phy.media_type == igc_media_type_copper) ? 7228c5ad0daSSasha Neftin igc_force_mac_fc(hw) : igc_setup_link(hw)); 7238c5ad0daSSasha Neftin } 7248c5ad0daSSasha Neftin 7258c5ad0daSSasha Neftin clear_bit(__IGC_RESETTING, &adapter->state); 7268c5ad0daSSasha Neftin return retval; 7278c5ad0daSSasha Neftin } 7288c5ad0daSSasha Neftin 72936b9fea6SSasha Neftin static void igc_get_strings(struct net_device *netdev, u32 stringset, u8 *data) 73036b9fea6SSasha Neftin { 73136b9fea6SSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 73236b9fea6SSasha Neftin u8 *p = data; 73336b9fea6SSasha Neftin int i; 73436b9fea6SSasha Neftin 73536b9fea6SSasha Neftin switch (stringset) { 73636b9fea6SSasha Neftin case ETH_SS_TEST: 73736b9fea6SSasha Neftin memcpy(data, *igc_gstrings_test, 73836b9fea6SSasha Neftin IGC_TEST_LEN * ETH_GSTRING_LEN); 73936b9fea6SSasha Neftin break; 74036b9fea6SSasha Neftin case ETH_SS_STATS: 74136b9fea6SSasha Neftin for (i = 0; i < IGC_GLOBAL_STATS_LEN; i++) { 74236b9fea6SSasha Neftin memcpy(p, igc_gstrings_stats[i].stat_string, 74336b9fea6SSasha Neftin ETH_GSTRING_LEN); 74436b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 74536b9fea6SSasha Neftin } 74636b9fea6SSasha Neftin for (i = 0; i < IGC_NETDEV_STATS_LEN; i++) { 74736b9fea6SSasha Neftin memcpy(p, igc_gstrings_net_stats[i].stat_string, 74836b9fea6SSasha Neftin ETH_GSTRING_LEN); 74936b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 75036b9fea6SSasha Neftin } 75136b9fea6SSasha Neftin for (i = 0; i < adapter->num_tx_queues; i++) { 75236b9fea6SSasha Neftin sprintf(p, "tx_queue_%u_packets", i); 75336b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 75436b9fea6SSasha Neftin sprintf(p, "tx_queue_%u_bytes", i); 75536b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 75636b9fea6SSasha Neftin sprintf(p, "tx_queue_%u_restart", i); 75736b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 75836b9fea6SSasha Neftin } 75936b9fea6SSasha Neftin for (i = 0; i < adapter->num_rx_queues; i++) { 76036b9fea6SSasha Neftin sprintf(p, "rx_queue_%u_packets", i); 76136b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 76236b9fea6SSasha Neftin sprintf(p, "rx_queue_%u_bytes", i); 76336b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 76436b9fea6SSasha Neftin sprintf(p, "rx_queue_%u_drops", i); 76536b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 76636b9fea6SSasha Neftin sprintf(p, "rx_queue_%u_csum_err", i); 76736b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 76836b9fea6SSasha Neftin sprintf(p, "rx_queue_%u_alloc_failed", i); 76936b9fea6SSasha Neftin p += ETH_GSTRING_LEN; 77036b9fea6SSasha Neftin } 77136b9fea6SSasha Neftin /* BUG_ON(p - data != IGC_STATS_LEN * ETH_GSTRING_LEN); */ 77236b9fea6SSasha Neftin break; 77336b9fea6SSasha Neftin case ETH_SS_PRIV_FLAGS: 77436b9fea6SSasha Neftin memcpy(data, igc_priv_flags_strings, 77536b9fea6SSasha Neftin IGC_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN); 77636b9fea6SSasha Neftin break; 77736b9fea6SSasha Neftin } 77836b9fea6SSasha Neftin } 77936b9fea6SSasha Neftin 78036b9fea6SSasha Neftin static int igc_get_sset_count(struct net_device *netdev, int sset) 78136b9fea6SSasha Neftin { 78236b9fea6SSasha Neftin switch (sset) { 78336b9fea6SSasha Neftin case ETH_SS_STATS: 78436b9fea6SSasha Neftin return IGC_STATS_LEN; 78536b9fea6SSasha Neftin case ETH_SS_TEST: 78636b9fea6SSasha Neftin return IGC_TEST_LEN; 78736b9fea6SSasha Neftin case ETH_SS_PRIV_FLAGS: 78836b9fea6SSasha Neftin return IGC_PRIV_FLAGS_STR_LEN; 78936b9fea6SSasha Neftin default: 79036b9fea6SSasha Neftin return -ENOTSUPP; 79136b9fea6SSasha Neftin } 79236b9fea6SSasha Neftin } 79336b9fea6SSasha Neftin 79436b9fea6SSasha Neftin static void igc_get_ethtool_stats(struct net_device *netdev, 79536b9fea6SSasha Neftin struct ethtool_stats *stats, u64 *data) 79636b9fea6SSasha Neftin { 79736b9fea6SSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 79836b9fea6SSasha Neftin struct rtnl_link_stats64 *net_stats = &adapter->stats64; 79936b9fea6SSasha Neftin unsigned int start; 80036b9fea6SSasha Neftin struct igc_ring *ring; 80136b9fea6SSasha Neftin int i, j; 80236b9fea6SSasha Neftin char *p; 80336b9fea6SSasha Neftin 80436b9fea6SSasha Neftin spin_lock(&adapter->stats64_lock); 80536b9fea6SSasha Neftin igc_update_stats(adapter); 80636b9fea6SSasha Neftin 80736b9fea6SSasha Neftin for (i = 0; i < IGC_GLOBAL_STATS_LEN; i++) { 80836b9fea6SSasha Neftin p = (char *)adapter + igc_gstrings_stats[i].stat_offset; 80936b9fea6SSasha Neftin data[i] = (igc_gstrings_stats[i].sizeof_stat == 81036b9fea6SSasha Neftin sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 81136b9fea6SSasha Neftin } 81236b9fea6SSasha Neftin for (j = 0; j < IGC_NETDEV_STATS_LEN; j++, i++) { 81336b9fea6SSasha Neftin p = (char *)net_stats + igc_gstrings_net_stats[j].stat_offset; 81436b9fea6SSasha Neftin data[i] = (igc_gstrings_net_stats[j].sizeof_stat == 81536b9fea6SSasha Neftin sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 81636b9fea6SSasha Neftin } 81736b9fea6SSasha Neftin for (j = 0; j < adapter->num_tx_queues; j++) { 81836b9fea6SSasha Neftin u64 restart2; 81936b9fea6SSasha Neftin 82036b9fea6SSasha Neftin ring = adapter->tx_ring[j]; 82136b9fea6SSasha Neftin do { 82236b9fea6SSasha Neftin start = u64_stats_fetch_begin_irq(&ring->tx_syncp); 82336b9fea6SSasha Neftin data[i] = ring->tx_stats.packets; 82436b9fea6SSasha Neftin data[i + 1] = ring->tx_stats.bytes; 82536b9fea6SSasha Neftin data[i + 2] = ring->tx_stats.restart_queue; 82636b9fea6SSasha Neftin } while (u64_stats_fetch_retry_irq(&ring->tx_syncp, start)); 82736b9fea6SSasha Neftin do { 82836b9fea6SSasha Neftin start = u64_stats_fetch_begin_irq(&ring->tx_syncp2); 82936b9fea6SSasha Neftin restart2 = ring->tx_stats.restart_queue2; 83036b9fea6SSasha Neftin } while (u64_stats_fetch_retry_irq(&ring->tx_syncp2, start)); 83136b9fea6SSasha Neftin data[i + 2] += restart2; 83236b9fea6SSasha Neftin 83336b9fea6SSasha Neftin i += IGC_TX_QUEUE_STATS_LEN; 83436b9fea6SSasha Neftin } 83536b9fea6SSasha Neftin for (j = 0; j < adapter->num_rx_queues; j++) { 83636b9fea6SSasha Neftin ring = adapter->rx_ring[j]; 83736b9fea6SSasha Neftin do { 83836b9fea6SSasha Neftin start = u64_stats_fetch_begin_irq(&ring->rx_syncp); 83936b9fea6SSasha Neftin data[i] = ring->rx_stats.packets; 84036b9fea6SSasha Neftin data[i + 1] = ring->rx_stats.bytes; 84136b9fea6SSasha Neftin data[i + 2] = ring->rx_stats.drops; 84236b9fea6SSasha Neftin data[i + 3] = ring->rx_stats.csum_err; 84336b9fea6SSasha Neftin data[i + 4] = ring->rx_stats.alloc_failed; 84436b9fea6SSasha Neftin } while (u64_stats_fetch_retry_irq(&ring->rx_syncp, start)); 84536b9fea6SSasha Neftin i += IGC_RX_QUEUE_STATS_LEN; 84636b9fea6SSasha Neftin } 84736b9fea6SSasha Neftin spin_unlock(&adapter->stats64_lock); 84836b9fea6SSasha Neftin } 84936b9fea6SSasha Neftin 8508c5ad0daSSasha Neftin static int igc_get_coalesce(struct net_device *netdev, 8518c5ad0daSSasha Neftin struct ethtool_coalesce *ec) 8528c5ad0daSSasha Neftin { 8538c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 8548c5ad0daSSasha Neftin 8558c5ad0daSSasha Neftin if (adapter->rx_itr_setting <= 3) 8568c5ad0daSSasha Neftin ec->rx_coalesce_usecs = adapter->rx_itr_setting; 8578c5ad0daSSasha Neftin else 8588c5ad0daSSasha Neftin ec->rx_coalesce_usecs = adapter->rx_itr_setting >> 2; 8598c5ad0daSSasha Neftin 8608c5ad0daSSasha Neftin if (!(adapter->flags & IGC_FLAG_QUEUE_PAIRS)) { 8618c5ad0daSSasha Neftin if (adapter->tx_itr_setting <= 3) 8628c5ad0daSSasha Neftin ec->tx_coalesce_usecs = adapter->tx_itr_setting; 8638c5ad0daSSasha Neftin else 8648c5ad0daSSasha Neftin ec->tx_coalesce_usecs = adapter->tx_itr_setting >> 2; 8658c5ad0daSSasha Neftin } 8668c5ad0daSSasha Neftin 8678c5ad0daSSasha Neftin return 0; 8688c5ad0daSSasha Neftin } 8698c5ad0daSSasha Neftin 8708c5ad0daSSasha Neftin static int igc_set_coalesce(struct net_device *netdev, 8718c5ad0daSSasha Neftin struct ethtool_coalesce *ec) 8728c5ad0daSSasha Neftin { 8738c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 8748c5ad0daSSasha Neftin int i; 8758c5ad0daSSasha Neftin 8768c5ad0daSSasha Neftin if (ec->rx_coalesce_usecs > IGC_MAX_ITR_USECS || 8778c5ad0daSSasha Neftin (ec->rx_coalesce_usecs > 3 && 8788c5ad0daSSasha Neftin ec->rx_coalesce_usecs < IGC_MIN_ITR_USECS) || 8798c5ad0daSSasha Neftin ec->rx_coalesce_usecs == 2) 8808c5ad0daSSasha Neftin return -EINVAL; 8818c5ad0daSSasha Neftin 8828c5ad0daSSasha Neftin if (ec->tx_coalesce_usecs > IGC_MAX_ITR_USECS || 8838c5ad0daSSasha Neftin (ec->tx_coalesce_usecs > 3 && 8848c5ad0daSSasha Neftin ec->tx_coalesce_usecs < IGC_MIN_ITR_USECS) || 8858c5ad0daSSasha Neftin ec->tx_coalesce_usecs == 2) 8868c5ad0daSSasha Neftin return -EINVAL; 8878c5ad0daSSasha Neftin 8888c5ad0daSSasha Neftin if ((adapter->flags & IGC_FLAG_QUEUE_PAIRS) && ec->tx_coalesce_usecs) 8898c5ad0daSSasha Neftin return -EINVAL; 8908c5ad0daSSasha Neftin 8918c5ad0daSSasha Neftin /* If ITR is disabled, disable DMAC */ 8928c5ad0daSSasha Neftin if (ec->rx_coalesce_usecs == 0) { 8938c5ad0daSSasha Neftin if (adapter->flags & IGC_FLAG_DMAC) 8948c5ad0daSSasha Neftin adapter->flags &= ~IGC_FLAG_DMAC; 8958c5ad0daSSasha Neftin } 8968c5ad0daSSasha Neftin 8978c5ad0daSSasha Neftin /* convert to rate of irq's per second */ 8988c5ad0daSSasha Neftin if (ec->rx_coalesce_usecs && ec->rx_coalesce_usecs <= 3) 8998c5ad0daSSasha Neftin adapter->rx_itr_setting = ec->rx_coalesce_usecs; 9008c5ad0daSSasha Neftin else 9018c5ad0daSSasha Neftin adapter->rx_itr_setting = ec->rx_coalesce_usecs << 2; 9028c5ad0daSSasha Neftin 9038c5ad0daSSasha Neftin /* convert to rate of irq's per second */ 9048c5ad0daSSasha Neftin if (adapter->flags & IGC_FLAG_QUEUE_PAIRS) 9058c5ad0daSSasha Neftin adapter->tx_itr_setting = adapter->rx_itr_setting; 9068c5ad0daSSasha Neftin else if (ec->tx_coalesce_usecs && ec->tx_coalesce_usecs <= 3) 9078c5ad0daSSasha Neftin adapter->tx_itr_setting = ec->tx_coalesce_usecs; 9088c5ad0daSSasha Neftin else 9098c5ad0daSSasha Neftin adapter->tx_itr_setting = ec->tx_coalesce_usecs << 2; 9108c5ad0daSSasha Neftin 9118c5ad0daSSasha Neftin for (i = 0; i < adapter->num_q_vectors; i++) { 9128c5ad0daSSasha Neftin struct igc_q_vector *q_vector = adapter->q_vector[i]; 9138c5ad0daSSasha Neftin 9148c5ad0daSSasha Neftin q_vector->tx.work_limit = adapter->tx_work_limit; 9158c5ad0daSSasha Neftin if (q_vector->rx.ring) 9168c5ad0daSSasha Neftin q_vector->itr_val = adapter->rx_itr_setting; 9178c5ad0daSSasha Neftin else 9188c5ad0daSSasha Neftin q_vector->itr_val = adapter->tx_itr_setting; 9198c5ad0daSSasha Neftin if (q_vector->itr_val && q_vector->itr_val <= 3) 9208c5ad0daSSasha Neftin q_vector->itr_val = IGC_START_ITR; 9218c5ad0daSSasha Neftin q_vector->set_itr = 1; 9228c5ad0daSSasha Neftin } 9238c5ad0daSSasha Neftin 9248c5ad0daSSasha Neftin return 0; 9258c5ad0daSSasha Neftin } 9268c5ad0daSSasha Neftin 9276245c848SSasha Neftin #define ETHER_TYPE_FULL_MASK ((__force __be16)~0) 9286245c848SSasha Neftin static int igc_get_ethtool_nfc_entry(struct igc_adapter *adapter, 9296245c848SSasha Neftin struct ethtool_rxnfc *cmd) 9306245c848SSasha Neftin { 9316245c848SSasha Neftin struct ethtool_rx_flow_spec *fsp = &cmd->fs; 9326245c848SSasha Neftin struct igc_nfc_filter *rule = NULL; 9336245c848SSasha Neftin 9346245c848SSasha Neftin /* report total rule count */ 9356245c848SSasha Neftin cmd->data = IGC_MAX_RXNFC_FILTERS; 9366245c848SSasha Neftin 9376245c848SSasha Neftin hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) { 9386245c848SSasha Neftin if (fsp->location <= rule->sw_idx) 9396245c848SSasha Neftin break; 9406245c848SSasha Neftin } 9416245c848SSasha Neftin 9426245c848SSasha Neftin if (!rule || fsp->location != rule->sw_idx) 9436245c848SSasha Neftin return -EINVAL; 9446245c848SSasha Neftin 9456245c848SSasha Neftin if (rule->filter.match_flags) { 9466245c848SSasha Neftin fsp->flow_type = ETHER_FLOW; 9476245c848SSasha Neftin fsp->ring_cookie = rule->action; 9486245c848SSasha Neftin if (rule->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) { 9496245c848SSasha Neftin fsp->h_u.ether_spec.h_proto = rule->filter.etype; 9506245c848SSasha Neftin fsp->m_u.ether_spec.h_proto = ETHER_TYPE_FULL_MASK; 9516245c848SSasha Neftin } 9526245c848SSasha Neftin if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) { 9536245c848SSasha Neftin fsp->flow_type |= FLOW_EXT; 9546245c848SSasha Neftin fsp->h_ext.vlan_tci = rule->filter.vlan_tci; 9556245c848SSasha Neftin fsp->m_ext.vlan_tci = htons(VLAN_PRIO_MASK); 9566245c848SSasha Neftin } 9576245c848SSasha Neftin if (rule->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) { 9586245c848SSasha Neftin ether_addr_copy(fsp->h_u.ether_spec.h_dest, 9596245c848SSasha Neftin rule->filter.dst_addr); 9606245c848SSasha Neftin /* As we only support matching by the full 9616245c848SSasha Neftin * mask, return the mask to userspace 9626245c848SSasha Neftin */ 9636245c848SSasha Neftin eth_broadcast_addr(fsp->m_u.ether_spec.h_dest); 9646245c848SSasha Neftin } 9656245c848SSasha Neftin if (rule->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) { 9666245c848SSasha Neftin ether_addr_copy(fsp->h_u.ether_spec.h_source, 9676245c848SSasha Neftin rule->filter.src_addr); 9686245c848SSasha Neftin /* As we only support matching by the full 9696245c848SSasha Neftin * mask, return the mask to userspace 9706245c848SSasha Neftin */ 9716245c848SSasha Neftin eth_broadcast_addr(fsp->m_u.ether_spec.h_source); 9726245c848SSasha Neftin } 9736245c848SSasha Neftin 9746245c848SSasha Neftin return 0; 9756245c848SSasha Neftin } 9766245c848SSasha Neftin return -EINVAL; 9776245c848SSasha Neftin } 9786245c848SSasha Neftin 9796245c848SSasha Neftin static int igc_get_ethtool_nfc_all(struct igc_adapter *adapter, 9806245c848SSasha Neftin struct ethtool_rxnfc *cmd, 9816245c848SSasha Neftin u32 *rule_locs) 9826245c848SSasha Neftin { 9836245c848SSasha Neftin struct igc_nfc_filter *rule; 9846245c848SSasha Neftin int cnt = 0; 9856245c848SSasha Neftin 9866245c848SSasha Neftin /* report total rule count */ 9876245c848SSasha Neftin cmd->data = IGC_MAX_RXNFC_FILTERS; 9886245c848SSasha Neftin 9896245c848SSasha Neftin hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) { 9906245c848SSasha Neftin if (cnt == cmd->rule_cnt) 9916245c848SSasha Neftin return -EMSGSIZE; 9926245c848SSasha Neftin rule_locs[cnt] = rule->sw_idx; 9936245c848SSasha Neftin cnt++; 9946245c848SSasha Neftin } 9956245c848SSasha Neftin 9966245c848SSasha Neftin cmd->rule_cnt = cnt; 9976245c848SSasha Neftin 9986245c848SSasha Neftin return 0; 9996245c848SSasha Neftin } 10006245c848SSasha Neftin 10016245c848SSasha Neftin static int igc_get_rss_hash_opts(struct igc_adapter *adapter, 10026245c848SSasha Neftin struct ethtool_rxnfc *cmd) 10036245c848SSasha Neftin { 10046245c848SSasha Neftin cmd->data = 0; 10056245c848SSasha Neftin 10066245c848SSasha Neftin /* Report default options for RSS on igc */ 10076245c848SSasha Neftin switch (cmd->flow_type) { 10086245c848SSasha Neftin case TCP_V4_FLOW: 10096245c848SSasha Neftin cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 10106245c848SSasha Neftin /* Fall through */ 10116245c848SSasha Neftin case UDP_V4_FLOW: 10126245c848SSasha Neftin if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV4_UDP) 10136245c848SSasha Neftin cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 10146245c848SSasha Neftin /* Fall through */ 10156245c848SSasha Neftin case SCTP_V4_FLOW: 10166245c848SSasha Neftin /* Fall through */ 10176245c848SSasha Neftin case AH_ESP_V4_FLOW: 10186245c848SSasha Neftin /* Fall through */ 10196245c848SSasha Neftin case AH_V4_FLOW: 10206245c848SSasha Neftin /* Fall through */ 10216245c848SSasha Neftin case ESP_V4_FLOW: 10226245c848SSasha Neftin /* Fall through */ 10236245c848SSasha Neftin case IPV4_FLOW: 10246245c848SSasha Neftin cmd->data |= RXH_IP_SRC | RXH_IP_DST; 10256245c848SSasha Neftin break; 10266245c848SSasha Neftin case TCP_V6_FLOW: 10276245c848SSasha Neftin cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 10286245c848SSasha Neftin /* Fall through */ 10296245c848SSasha Neftin case UDP_V6_FLOW: 10306245c848SSasha Neftin if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV6_UDP) 10316245c848SSasha Neftin cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 10326245c848SSasha Neftin /* Fall through */ 10336245c848SSasha Neftin case SCTP_V6_FLOW: 10346245c848SSasha Neftin /* Fall through */ 10356245c848SSasha Neftin case AH_ESP_V6_FLOW: 10366245c848SSasha Neftin /* Fall through */ 10376245c848SSasha Neftin case AH_V6_FLOW: 10386245c848SSasha Neftin /* Fall through */ 10396245c848SSasha Neftin case ESP_V6_FLOW: 10406245c848SSasha Neftin /* Fall through */ 10416245c848SSasha Neftin case IPV6_FLOW: 10426245c848SSasha Neftin cmd->data |= RXH_IP_SRC | RXH_IP_DST; 10436245c848SSasha Neftin break; 10446245c848SSasha Neftin default: 10456245c848SSasha Neftin return -EINVAL; 10466245c848SSasha Neftin } 10476245c848SSasha Neftin 10486245c848SSasha Neftin return 0; 10496245c848SSasha Neftin } 10506245c848SSasha Neftin 10516245c848SSasha Neftin static int igc_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd, 10526245c848SSasha Neftin u32 *rule_locs) 10536245c848SSasha Neftin { 10546245c848SSasha Neftin struct igc_adapter *adapter = netdev_priv(dev); 10556245c848SSasha Neftin int ret = -EOPNOTSUPP; 10566245c848SSasha Neftin 10576245c848SSasha Neftin switch (cmd->cmd) { 10586245c848SSasha Neftin case ETHTOOL_GRXRINGS: 10596245c848SSasha Neftin cmd->data = adapter->num_rx_queues; 10606245c848SSasha Neftin ret = 0; 10616245c848SSasha Neftin break; 10626245c848SSasha Neftin case ETHTOOL_GRXCLSRLCNT: 10636245c848SSasha Neftin cmd->rule_cnt = adapter->nfc_filter_count; 10646245c848SSasha Neftin ret = 0; 10656245c848SSasha Neftin break; 10666245c848SSasha Neftin case ETHTOOL_GRXCLSRULE: 10676245c848SSasha Neftin ret = igc_get_ethtool_nfc_entry(adapter, cmd); 10686245c848SSasha Neftin break; 10696245c848SSasha Neftin case ETHTOOL_GRXCLSRLALL: 10706245c848SSasha Neftin ret = igc_get_ethtool_nfc_all(adapter, cmd, rule_locs); 10716245c848SSasha Neftin break; 10726245c848SSasha Neftin case ETHTOOL_GRXFH: 10736245c848SSasha Neftin ret = igc_get_rss_hash_opts(adapter, cmd); 10746245c848SSasha Neftin break; 10756245c848SSasha Neftin default: 10766245c848SSasha Neftin break; 10776245c848SSasha Neftin } 10786245c848SSasha Neftin 10796245c848SSasha Neftin return ret; 10806245c848SSasha Neftin } 10816245c848SSasha Neftin 10826245c848SSasha Neftin #define UDP_RSS_FLAGS (IGC_FLAG_RSS_FIELD_IPV4_UDP | \ 10836245c848SSasha Neftin IGC_FLAG_RSS_FIELD_IPV6_UDP) 10846245c848SSasha Neftin static int igc_set_rss_hash_opt(struct igc_adapter *adapter, 10856245c848SSasha Neftin struct ethtool_rxnfc *nfc) 10866245c848SSasha Neftin { 10876245c848SSasha Neftin u32 flags = adapter->flags; 10886245c848SSasha Neftin 10896245c848SSasha Neftin /* RSS does not support anything other than hashing 10906245c848SSasha Neftin * to queues on src and dst IPs and ports 10916245c848SSasha Neftin */ 10926245c848SSasha Neftin if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST | 10936245c848SSasha Neftin RXH_L4_B_0_1 | RXH_L4_B_2_3)) 10946245c848SSasha Neftin return -EINVAL; 10956245c848SSasha Neftin 10966245c848SSasha Neftin switch (nfc->flow_type) { 10976245c848SSasha Neftin case TCP_V4_FLOW: 10986245c848SSasha Neftin case TCP_V6_FLOW: 10996245c848SSasha Neftin if (!(nfc->data & RXH_IP_SRC) || 11006245c848SSasha Neftin !(nfc->data & RXH_IP_DST) || 11016245c848SSasha Neftin !(nfc->data & RXH_L4_B_0_1) || 11026245c848SSasha Neftin !(nfc->data & RXH_L4_B_2_3)) 11036245c848SSasha Neftin return -EINVAL; 11046245c848SSasha Neftin break; 11056245c848SSasha Neftin case UDP_V4_FLOW: 11066245c848SSasha Neftin if (!(nfc->data & RXH_IP_SRC) || 11076245c848SSasha Neftin !(nfc->data & RXH_IP_DST)) 11086245c848SSasha Neftin return -EINVAL; 11096245c848SSasha Neftin switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 11106245c848SSasha Neftin case 0: 11116245c848SSasha Neftin flags &= ~IGC_FLAG_RSS_FIELD_IPV4_UDP; 11126245c848SSasha Neftin break; 11136245c848SSasha Neftin case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 11146245c848SSasha Neftin flags |= IGC_FLAG_RSS_FIELD_IPV4_UDP; 11156245c848SSasha Neftin break; 11166245c848SSasha Neftin default: 11176245c848SSasha Neftin return -EINVAL; 11186245c848SSasha Neftin } 11196245c848SSasha Neftin break; 11206245c848SSasha Neftin case UDP_V6_FLOW: 11216245c848SSasha Neftin if (!(nfc->data & RXH_IP_SRC) || 11226245c848SSasha Neftin !(nfc->data & RXH_IP_DST)) 11236245c848SSasha Neftin return -EINVAL; 11246245c848SSasha Neftin switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 11256245c848SSasha Neftin case 0: 11266245c848SSasha Neftin flags &= ~IGC_FLAG_RSS_FIELD_IPV6_UDP; 11276245c848SSasha Neftin break; 11286245c848SSasha Neftin case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 11296245c848SSasha Neftin flags |= IGC_FLAG_RSS_FIELD_IPV6_UDP; 11306245c848SSasha Neftin break; 11316245c848SSasha Neftin default: 11326245c848SSasha Neftin return -EINVAL; 11336245c848SSasha Neftin } 11346245c848SSasha Neftin break; 11356245c848SSasha Neftin case AH_ESP_V4_FLOW: 11366245c848SSasha Neftin case AH_V4_FLOW: 11376245c848SSasha Neftin case ESP_V4_FLOW: 11386245c848SSasha Neftin case SCTP_V4_FLOW: 11396245c848SSasha Neftin case AH_ESP_V6_FLOW: 11406245c848SSasha Neftin case AH_V6_FLOW: 11416245c848SSasha Neftin case ESP_V6_FLOW: 11426245c848SSasha Neftin case SCTP_V6_FLOW: 11436245c848SSasha Neftin if (!(nfc->data & RXH_IP_SRC) || 11446245c848SSasha Neftin !(nfc->data & RXH_IP_DST) || 11456245c848SSasha Neftin (nfc->data & RXH_L4_B_0_1) || 11466245c848SSasha Neftin (nfc->data & RXH_L4_B_2_3)) 11476245c848SSasha Neftin return -EINVAL; 11486245c848SSasha Neftin break; 11496245c848SSasha Neftin default: 11506245c848SSasha Neftin return -EINVAL; 11516245c848SSasha Neftin } 11526245c848SSasha Neftin 11536245c848SSasha Neftin /* if we changed something we need to update flags */ 11546245c848SSasha Neftin if (flags != adapter->flags) { 11556245c848SSasha Neftin struct igc_hw *hw = &adapter->hw; 11566245c848SSasha Neftin u32 mrqc = rd32(IGC_MRQC); 11576245c848SSasha Neftin 11586245c848SSasha Neftin if ((flags & UDP_RSS_FLAGS) && 11596245c848SSasha Neftin !(adapter->flags & UDP_RSS_FLAGS)) 116095f96a9fSAndre Guedes netdev_err(adapter->netdev, 116195f96a9fSAndre Guedes "Enabling UDP RSS: fragmented packets may arrive out of order to the stack above\n"); 11626245c848SSasha Neftin 11636245c848SSasha Neftin adapter->flags = flags; 11646245c848SSasha Neftin 11656245c848SSasha Neftin /* Perform hash on these packet types */ 11666245c848SSasha Neftin mrqc |= IGC_MRQC_RSS_FIELD_IPV4 | 11676245c848SSasha Neftin IGC_MRQC_RSS_FIELD_IPV4_TCP | 11686245c848SSasha Neftin IGC_MRQC_RSS_FIELD_IPV6 | 11696245c848SSasha Neftin IGC_MRQC_RSS_FIELD_IPV6_TCP; 11706245c848SSasha Neftin 11716245c848SSasha Neftin mrqc &= ~(IGC_MRQC_RSS_FIELD_IPV4_UDP | 11726245c848SSasha Neftin IGC_MRQC_RSS_FIELD_IPV6_UDP); 11736245c848SSasha Neftin 11746245c848SSasha Neftin if (flags & IGC_FLAG_RSS_FIELD_IPV4_UDP) 11756245c848SSasha Neftin mrqc |= IGC_MRQC_RSS_FIELD_IPV4_UDP; 11766245c848SSasha Neftin 11776245c848SSasha Neftin if (flags & IGC_FLAG_RSS_FIELD_IPV6_UDP) 11786245c848SSasha Neftin mrqc |= IGC_MRQC_RSS_FIELD_IPV6_UDP; 11796245c848SSasha Neftin 11806245c848SSasha Neftin wr32(IGC_MRQC, mrqc); 11816245c848SSasha Neftin } 11826245c848SSasha Neftin 11836245c848SSasha Neftin return 0; 11846245c848SSasha Neftin } 11856245c848SSasha Neftin 11866245c848SSasha Neftin static int igc_rxnfc_write_etype_filter(struct igc_adapter *adapter, 11876245c848SSasha Neftin struct igc_nfc_filter *input) 11886245c848SSasha Neftin { 11896245c848SSasha Neftin struct igc_hw *hw = &adapter->hw; 11906245c848SSasha Neftin u8 i; 11916245c848SSasha Neftin u32 etqf; 11926245c848SSasha Neftin u16 etype; 11936245c848SSasha Neftin 11946245c848SSasha Neftin /* find an empty etype filter register */ 11956245c848SSasha Neftin for (i = 0; i < MAX_ETYPE_FILTER; ++i) { 11966245c848SSasha Neftin if (!adapter->etype_bitmap[i]) 11976245c848SSasha Neftin break; 11986245c848SSasha Neftin } 11996245c848SSasha Neftin if (i == MAX_ETYPE_FILTER) { 120095f96a9fSAndre Guedes netdev_err(adapter->netdev, 120195f96a9fSAndre Guedes "ethtool -N: etype filters are all used\n"); 12026245c848SSasha Neftin return -EINVAL; 12036245c848SSasha Neftin } 12046245c848SSasha Neftin 12056245c848SSasha Neftin adapter->etype_bitmap[i] = true; 12066245c848SSasha Neftin 12076245c848SSasha Neftin etqf = rd32(IGC_ETQF(i)); 12086245c848SSasha Neftin etype = ntohs(input->filter.etype & ETHER_TYPE_FULL_MASK); 12096245c848SSasha Neftin 12106245c848SSasha Neftin etqf |= IGC_ETQF_FILTER_ENABLE; 12116245c848SSasha Neftin etqf &= ~IGC_ETQF_ETYPE_MASK; 12126245c848SSasha Neftin etqf |= (etype & IGC_ETQF_ETYPE_MASK); 12136245c848SSasha Neftin 12146245c848SSasha Neftin etqf &= ~IGC_ETQF_QUEUE_MASK; 12156245c848SSasha Neftin etqf |= ((input->action << IGC_ETQF_QUEUE_SHIFT) 12166245c848SSasha Neftin & IGC_ETQF_QUEUE_MASK); 12176245c848SSasha Neftin etqf |= IGC_ETQF_QUEUE_ENABLE; 12186245c848SSasha Neftin 12196245c848SSasha Neftin wr32(IGC_ETQF(i), etqf); 12206245c848SSasha Neftin 12216245c848SSasha Neftin input->etype_reg_index = i; 12226245c848SSasha Neftin 12236245c848SSasha Neftin return 0; 12246245c848SSasha Neftin } 12256245c848SSasha Neftin 12266245c848SSasha Neftin static int igc_rxnfc_write_vlan_prio_filter(struct igc_adapter *adapter, 12276245c848SSasha Neftin struct igc_nfc_filter *input) 12286245c848SSasha Neftin { 12296245c848SSasha Neftin struct igc_hw *hw = &adapter->hw; 12306245c848SSasha Neftin u8 vlan_priority; 12316245c848SSasha Neftin u16 queue_index; 12326245c848SSasha Neftin u32 vlapqf; 12336245c848SSasha Neftin 1234bbfaa141SAndre Guedes vlapqf = rd32(IGC_VLANPQF); 12356245c848SSasha Neftin vlan_priority = (ntohs(input->filter.vlan_tci) & VLAN_PRIO_MASK) 12366245c848SSasha Neftin >> VLAN_PRIO_SHIFT; 1237bbfaa141SAndre Guedes queue_index = (vlapqf >> (vlan_priority * 4)) & IGC_VLANPQF_QUEUE_MASK; 12386245c848SSasha Neftin 1239bbfaa141SAndre Guedes /* check whether this VLAN prio is already set */ 1240bbfaa141SAndre Guedes if (vlapqf & IGC_VLANPQF_VALID(vlan_priority) && 12416245c848SSasha Neftin queue_index != input->action) { 124295f96a9fSAndre Guedes netdev_err(adapter->netdev, 124395f96a9fSAndre Guedes "ethtool rxnfc set VLAN prio filter failed\n"); 12446245c848SSasha Neftin return -EEXIST; 12456245c848SSasha Neftin } 12466245c848SSasha Neftin 1247bbfaa141SAndre Guedes vlapqf |= IGC_VLANPQF_VALID(vlan_priority); 1248bbfaa141SAndre Guedes vlapqf |= IGC_VLANPQF_QSEL(vlan_priority, input->action); 12496245c848SSasha Neftin 1250bbfaa141SAndre Guedes wr32(IGC_VLANPQF, vlapqf); 12516245c848SSasha Neftin 12526245c848SSasha Neftin return 0; 12536245c848SSasha Neftin } 12546245c848SSasha Neftin 12556245c848SSasha Neftin int igc_add_filter(struct igc_adapter *adapter, struct igc_nfc_filter *input) 12566245c848SSasha Neftin { 12576245c848SSasha Neftin struct igc_hw *hw = &adapter->hw; 12586245c848SSasha Neftin int err = -EINVAL; 12596245c848SSasha Neftin 12606245c848SSasha Neftin if (hw->mac.type == igc_i225 && 12616245c848SSasha Neftin !(input->filter.match_flags & ~IGC_FILTER_FLAG_SRC_MAC_ADDR)) { 126295f96a9fSAndre Guedes netdev_err(adapter->netdev, 126395f96a9fSAndre Guedes "i225 doesn't support flow classification rules specifying only source addresses\n"); 12646245c848SSasha Neftin return -EOPNOTSUPP; 12656245c848SSasha Neftin } 12666245c848SSasha Neftin 12676245c848SSasha Neftin if (input->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) { 12686245c848SSasha Neftin err = igc_rxnfc_write_etype_filter(adapter, input); 12696245c848SSasha Neftin if (err) 12706245c848SSasha Neftin return err; 12716245c848SSasha Neftin } 12726245c848SSasha Neftin 12736245c848SSasha Neftin if (input->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) { 127483ba21b9SAndre Guedes err = igc_add_mac_filter(adapter, input->filter.dst_addr, 12756245c848SSasha Neftin input->action, 0); 12766245c848SSasha Neftin if (err) 12776245c848SSasha Neftin return err; 12786245c848SSasha Neftin } 12796245c848SSasha Neftin 12806245c848SSasha Neftin if (input->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) { 128183ba21b9SAndre Guedes err = igc_add_mac_filter(adapter, input->filter.src_addr, 12826245c848SSasha Neftin input->action, 12836245c848SSasha Neftin IGC_MAC_STATE_SRC_ADDR); 12846245c848SSasha Neftin if (err) 12856245c848SSasha Neftin return err; 12866245c848SSasha Neftin } 12876245c848SSasha Neftin 12886245c848SSasha Neftin if (input->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) 12896245c848SSasha Neftin err = igc_rxnfc_write_vlan_prio_filter(adapter, input); 12906245c848SSasha Neftin 12916245c848SSasha Neftin return err; 12926245c848SSasha Neftin } 12936245c848SSasha Neftin 12946245c848SSasha Neftin static void igc_clear_etype_filter_regs(struct igc_adapter *adapter, 12956245c848SSasha Neftin u16 reg_index) 12966245c848SSasha Neftin { 12976245c848SSasha Neftin struct igc_hw *hw = &adapter->hw; 12986245c848SSasha Neftin u32 etqf = rd32(IGC_ETQF(reg_index)); 12996245c848SSasha Neftin 13006245c848SSasha Neftin etqf &= ~IGC_ETQF_QUEUE_ENABLE; 13016245c848SSasha Neftin etqf &= ~IGC_ETQF_QUEUE_MASK; 13026245c848SSasha Neftin etqf &= ~IGC_ETQF_FILTER_ENABLE; 13036245c848SSasha Neftin 13046245c848SSasha Neftin wr32(IGC_ETQF(reg_index), etqf); 13056245c848SSasha Neftin 13066245c848SSasha Neftin adapter->etype_bitmap[reg_index] = false; 13076245c848SSasha Neftin } 13086245c848SSasha Neftin 13096245c848SSasha Neftin static void igc_clear_vlan_prio_filter(struct igc_adapter *adapter, 13106245c848SSasha Neftin u16 vlan_tci) 13116245c848SSasha Neftin { 13126245c848SSasha Neftin struct igc_hw *hw = &adapter->hw; 13136245c848SSasha Neftin u8 vlan_priority; 13146245c848SSasha Neftin u32 vlapqf; 13156245c848SSasha Neftin 13166245c848SSasha Neftin vlan_priority = (vlan_tci & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT; 13176245c848SSasha Neftin 1318bbfaa141SAndre Guedes vlapqf = rd32(IGC_VLANPQF); 1319bbfaa141SAndre Guedes vlapqf &= ~IGC_VLANPQF_VALID(vlan_priority); 1320bbfaa141SAndre Guedes vlapqf &= ~IGC_VLANPQF_QSEL(vlan_priority, IGC_VLANPQF_QUEUE_MASK); 13216245c848SSasha Neftin 1322bbfaa141SAndre Guedes wr32(IGC_VLANPQF, vlapqf); 13236245c848SSasha Neftin } 13246245c848SSasha Neftin 13256245c848SSasha Neftin int igc_erase_filter(struct igc_adapter *adapter, struct igc_nfc_filter *input) 13266245c848SSasha Neftin { 13276245c848SSasha Neftin if (input->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) 13286245c848SSasha Neftin igc_clear_etype_filter_regs(adapter, 13296245c848SSasha Neftin input->etype_reg_index); 13306245c848SSasha Neftin 13316245c848SSasha Neftin if (input->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) 13326245c848SSasha Neftin igc_clear_vlan_prio_filter(adapter, 13336245c848SSasha Neftin ntohs(input->filter.vlan_tci)); 13346245c848SSasha Neftin 13356245c848SSasha Neftin if (input->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) 133683ba21b9SAndre Guedes igc_del_mac_filter(adapter, input->filter.src_addr, 13376245c848SSasha Neftin IGC_MAC_STATE_SRC_ADDR); 13386245c848SSasha Neftin 13396245c848SSasha Neftin if (input->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) 134083ba21b9SAndre Guedes igc_del_mac_filter(adapter, input->filter.dst_addr, 0); 13416245c848SSasha Neftin 13426245c848SSasha Neftin return 0; 13436245c848SSasha Neftin } 13446245c848SSasha Neftin 13456245c848SSasha Neftin static int igc_update_ethtool_nfc_entry(struct igc_adapter *adapter, 13466245c848SSasha Neftin struct igc_nfc_filter *input, 13476245c848SSasha Neftin u16 sw_idx) 13486245c848SSasha Neftin { 13496245c848SSasha Neftin struct igc_nfc_filter *rule, *parent; 13506245c848SSasha Neftin int err = -EINVAL; 13516245c848SSasha Neftin 13526245c848SSasha Neftin parent = NULL; 13536245c848SSasha Neftin rule = NULL; 13546245c848SSasha Neftin 13556245c848SSasha Neftin hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) { 13566245c848SSasha Neftin /* hash found, or no matching entry */ 13576245c848SSasha Neftin if (rule->sw_idx >= sw_idx) 13586245c848SSasha Neftin break; 13596245c848SSasha Neftin parent = rule; 13606245c848SSasha Neftin } 13616245c848SSasha Neftin 13626245c848SSasha Neftin /* if there is an old rule occupying our place remove it */ 13636245c848SSasha Neftin if (rule && rule->sw_idx == sw_idx) { 13646245c848SSasha Neftin if (!input) 13656245c848SSasha Neftin err = igc_erase_filter(adapter, rule); 13666245c848SSasha Neftin 13676245c848SSasha Neftin hlist_del(&rule->nfc_node); 13686245c848SSasha Neftin kfree(rule); 13696245c848SSasha Neftin adapter->nfc_filter_count--; 13706245c848SSasha Neftin } 13716245c848SSasha Neftin 13726245c848SSasha Neftin /* If no input this was a delete, err should be 0 if a rule was 13736245c848SSasha Neftin * successfully found and removed from the list else -EINVAL 13746245c848SSasha Neftin */ 13756245c848SSasha Neftin if (!input) 13766245c848SSasha Neftin return err; 13776245c848SSasha Neftin 13786245c848SSasha Neftin /* initialize node */ 13796245c848SSasha Neftin INIT_HLIST_NODE(&input->nfc_node); 13806245c848SSasha Neftin 13816245c848SSasha Neftin /* add filter to the list */ 13826245c848SSasha Neftin if (parent) 13836245c848SSasha Neftin hlist_add_behind(&input->nfc_node, &parent->nfc_node); 13846245c848SSasha Neftin else 13856245c848SSasha Neftin hlist_add_head(&input->nfc_node, &adapter->nfc_filter_list); 13866245c848SSasha Neftin 13876245c848SSasha Neftin /* update counts */ 13886245c848SSasha Neftin adapter->nfc_filter_count++; 13896245c848SSasha Neftin 13906245c848SSasha Neftin return 0; 13916245c848SSasha Neftin } 13926245c848SSasha Neftin 13936245c848SSasha Neftin static int igc_add_ethtool_nfc_entry(struct igc_adapter *adapter, 13946245c848SSasha Neftin struct ethtool_rxnfc *cmd) 13956245c848SSasha Neftin { 13966245c848SSasha Neftin struct net_device *netdev = adapter->netdev; 13976245c848SSasha Neftin struct ethtool_rx_flow_spec *fsp = 13986245c848SSasha Neftin (struct ethtool_rx_flow_spec *)&cmd->fs; 13996245c848SSasha Neftin struct igc_nfc_filter *input, *rule; 14006245c848SSasha Neftin int err = 0; 14016245c848SSasha Neftin 14026245c848SSasha Neftin if (!(netdev->hw_features & NETIF_F_NTUPLE)) 14036245c848SSasha Neftin return -EOPNOTSUPP; 14046245c848SSasha Neftin 14056245c848SSasha Neftin /* Don't allow programming if the action is a queue greater than 14066245c848SSasha Neftin * the number of online Rx queues. 14076245c848SSasha Neftin */ 14086245c848SSasha Neftin if (fsp->ring_cookie == RX_CLS_FLOW_DISC || 14096245c848SSasha Neftin fsp->ring_cookie >= adapter->num_rx_queues) { 141095f96a9fSAndre Guedes netdev_err(netdev, 141195f96a9fSAndre Guedes "ethtool -N: The specified action is invalid\n"); 14126245c848SSasha Neftin return -EINVAL; 14136245c848SSasha Neftin } 14146245c848SSasha Neftin 14156245c848SSasha Neftin /* Don't allow indexes to exist outside of available space */ 14166245c848SSasha Neftin if (fsp->location >= IGC_MAX_RXNFC_FILTERS) { 141795f96a9fSAndre Guedes netdev_err(netdev, "Location out of range\n"); 14186245c848SSasha Neftin return -EINVAL; 14196245c848SSasha Neftin } 14206245c848SSasha Neftin 14216245c848SSasha Neftin if ((fsp->flow_type & ~FLOW_EXT) != ETHER_FLOW) 14226245c848SSasha Neftin return -EINVAL; 14236245c848SSasha Neftin 14246245c848SSasha Neftin input = kzalloc(sizeof(*input), GFP_KERNEL); 14256245c848SSasha Neftin if (!input) 14266245c848SSasha Neftin return -ENOMEM; 14276245c848SSasha Neftin 14286245c848SSasha Neftin if (fsp->m_u.ether_spec.h_proto == ETHER_TYPE_FULL_MASK) { 14296245c848SSasha Neftin input->filter.etype = fsp->h_u.ether_spec.h_proto; 14306245c848SSasha Neftin input->filter.match_flags = IGC_FILTER_FLAG_ETHER_TYPE; 14316245c848SSasha Neftin } 14326245c848SSasha Neftin 14336245c848SSasha Neftin /* Only support matching addresses by the full mask */ 14346245c848SSasha Neftin if (is_broadcast_ether_addr(fsp->m_u.ether_spec.h_source)) { 14356245c848SSasha Neftin input->filter.match_flags |= IGC_FILTER_FLAG_SRC_MAC_ADDR; 14366245c848SSasha Neftin ether_addr_copy(input->filter.src_addr, 14376245c848SSasha Neftin fsp->h_u.ether_spec.h_source); 14386245c848SSasha Neftin } 14396245c848SSasha Neftin 14406245c848SSasha Neftin /* Only support matching addresses by the full mask */ 14416245c848SSasha Neftin if (is_broadcast_ether_addr(fsp->m_u.ether_spec.h_dest)) { 14426245c848SSasha Neftin input->filter.match_flags |= IGC_FILTER_FLAG_DST_MAC_ADDR; 14436245c848SSasha Neftin ether_addr_copy(input->filter.dst_addr, 14446245c848SSasha Neftin fsp->h_u.ether_spec.h_dest); 14456245c848SSasha Neftin } 14466245c848SSasha Neftin 14476245c848SSasha Neftin if ((fsp->flow_type & FLOW_EXT) && fsp->m_ext.vlan_tci) { 14486245c848SSasha Neftin if (fsp->m_ext.vlan_tci != htons(VLAN_PRIO_MASK)) { 14496245c848SSasha Neftin err = -EINVAL; 14506245c848SSasha Neftin goto err_out; 14516245c848SSasha Neftin } 14526245c848SSasha Neftin input->filter.vlan_tci = fsp->h_ext.vlan_tci; 14536245c848SSasha Neftin input->filter.match_flags |= IGC_FILTER_FLAG_VLAN_TCI; 14546245c848SSasha Neftin } 14556245c848SSasha Neftin 14566245c848SSasha Neftin input->action = fsp->ring_cookie; 14576245c848SSasha Neftin input->sw_idx = fsp->location; 14586245c848SSasha Neftin 14596245c848SSasha Neftin spin_lock(&adapter->nfc_lock); 14606245c848SSasha Neftin 14616245c848SSasha Neftin hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) { 14626245c848SSasha Neftin if (!memcmp(&input->filter, &rule->filter, 14636245c848SSasha Neftin sizeof(input->filter))) { 14646245c848SSasha Neftin err = -EEXIST; 146595f96a9fSAndre Guedes netdev_err(netdev, 14666245c848SSasha Neftin "ethtool: this filter is already set\n"); 14676245c848SSasha Neftin goto err_out_w_lock; 14686245c848SSasha Neftin } 14696245c848SSasha Neftin } 14706245c848SSasha Neftin 14716245c848SSasha Neftin err = igc_add_filter(adapter, input); 14726245c848SSasha Neftin if (err) 14736245c848SSasha Neftin goto err_out_w_lock; 14746245c848SSasha Neftin 14756245c848SSasha Neftin igc_update_ethtool_nfc_entry(adapter, input, input->sw_idx); 14766245c848SSasha Neftin 14776245c848SSasha Neftin spin_unlock(&adapter->nfc_lock); 14786245c848SSasha Neftin return 0; 14796245c848SSasha Neftin 14806245c848SSasha Neftin err_out_w_lock: 14816245c848SSasha Neftin spin_unlock(&adapter->nfc_lock); 14826245c848SSasha Neftin err_out: 14836245c848SSasha Neftin kfree(input); 14846245c848SSasha Neftin return err; 14856245c848SSasha Neftin } 14866245c848SSasha Neftin 14876245c848SSasha Neftin static int igc_del_ethtool_nfc_entry(struct igc_adapter *adapter, 14886245c848SSasha Neftin struct ethtool_rxnfc *cmd) 14896245c848SSasha Neftin { 14906245c848SSasha Neftin struct ethtool_rx_flow_spec *fsp = 14916245c848SSasha Neftin (struct ethtool_rx_flow_spec *)&cmd->fs; 14926245c848SSasha Neftin int err; 14936245c848SSasha Neftin 14946245c848SSasha Neftin spin_lock(&adapter->nfc_lock); 14956245c848SSasha Neftin err = igc_update_ethtool_nfc_entry(adapter, NULL, fsp->location); 14966245c848SSasha Neftin spin_unlock(&adapter->nfc_lock); 14976245c848SSasha Neftin 14986245c848SSasha Neftin return err; 14996245c848SSasha Neftin } 15006245c848SSasha Neftin 15016245c848SSasha Neftin static int igc_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd) 15026245c848SSasha Neftin { 15036245c848SSasha Neftin struct igc_adapter *adapter = netdev_priv(dev); 15046245c848SSasha Neftin int ret = -EOPNOTSUPP; 15056245c848SSasha Neftin 15066245c848SSasha Neftin switch (cmd->cmd) { 15076245c848SSasha Neftin case ETHTOOL_SRXFH: 15086245c848SSasha Neftin ret = igc_set_rss_hash_opt(adapter, cmd); 15096245c848SSasha Neftin break; 15106245c848SSasha Neftin case ETHTOOL_SRXCLSRLINS: 15116245c848SSasha Neftin ret = igc_add_ethtool_nfc_entry(adapter, cmd); 15126245c848SSasha Neftin break; 15136245c848SSasha Neftin case ETHTOOL_SRXCLSRLDEL: 15146245c848SSasha Neftin ret = igc_del_ethtool_nfc_entry(adapter, cmd); 15156245c848SSasha Neftin default: 15166245c848SSasha Neftin break; 15176245c848SSasha Neftin } 15186245c848SSasha Neftin 15196245c848SSasha Neftin return ret; 15206245c848SSasha Neftin } 15216245c848SSasha Neftin 15228c5ad0daSSasha Neftin void igc_write_rss_indir_tbl(struct igc_adapter *adapter) 15238c5ad0daSSasha Neftin { 15248c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 15258c5ad0daSSasha Neftin u32 reg = IGC_RETA(0); 15268c5ad0daSSasha Neftin u32 shift = 0; 15278c5ad0daSSasha Neftin int i = 0; 15288c5ad0daSSasha Neftin 15298c5ad0daSSasha Neftin while (i < IGC_RETA_SIZE) { 15308c5ad0daSSasha Neftin u32 val = 0; 15318c5ad0daSSasha Neftin int j; 15328c5ad0daSSasha Neftin 15338c5ad0daSSasha Neftin for (j = 3; j >= 0; j--) { 15348c5ad0daSSasha Neftin val <<= 8; 15358c5ad0daSSasha Neftin val |= adapter->rss_indir_tbl[i + j]; 15368c5ad0daSSasha Neftin } 15378c5ad0daSSasha Neftin 15388c5ad0daSSasha Neftin wr32(reg, val << shift); 15398c5ad0daSSasha Neftin reg += 4; 15408c5ad0daSSasha Neftin i += 4; 15418c5ad0daSSasha Neftin } 15428c5ad0daSSasha Neftin } 15438c5ad0daSSasha Neftin 15448c5ad0daSSasha Neftin static u32 igc_get_rxfh_indir_size(struct net_device *netdev) 15458c5ad0daSSasha Neftin { 15468c5ad0daSSasha Neftin return IGC_RETA_SIZE; 15478c5ad0daSSasha Neftin } 15488c5ad0daSSasha Neftin 15498c5ad0daSSasha Neftin static int igc_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key, 15508c5ad0daSSasha Neftin u8 *hfunc) 15518c5ad0daSSasha Neftin { 15528c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 15538c5ad0daSSasha Neftin int i; 15548c5ad0daSSasha Neftin 15558c5ad0daSSasha Neftin if (hfunc) 15568c5ad0daSSasha Neftin *hfunc = ETH_RSS_HASH_TOP; 15578c5ad0daSSasha Neftin if (!indir) 15588c5ad0daSSasha Neftin return 0; 15598c5ad0daSSasha Neftin for (i = 0; i < IGC_RETA_SIZE; i++) 15608c5ad0daSSasha Neftin indir[i] = adapter->rss_indir_tbl[i]; 15618c5ad0daSSasha Neftin 15628c5ad0daSSasha Neftin return 0; 15638c5ad0daSSasha Neftin } 15648c5ad0daSSasha Neftin 15658c5ad0daSSasha Neftin static int igc_set_rxfh(struct net_device *netdev, const u32 *indir, 15668c5ad0daSSasha Neftin const u8 *key, const u8 hfunc) 15678c5ad0daSSasha Neftin { 15688c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 15698c5ad0daSSasha Neftin u32 num_queues; 15708c5ad0daSSasha Neftin int i; 15718c5ad0daSSasha Neftin 15728c5ad0daSSasha Neftin /* We do not allow change in unsupported parameters */ 15738c5ad0daSSasha Neftin if (key || 15748c5ad0daSSasha Neftin (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)) 15758c5ad0daSSasha Neftin return -EOPNOTSUPP; 15768c5ad0daSSasha Neftin if (!indir) 15778c5ad0daSSasha Neftin return 0; 15788c5ad0daSSasha Neftin 15798c5ad0daSSasha Neftin num_queues = adapter->rss_queues; 15808c5ad0daSSasha Neftin 15818c5ad0daSSasha Neftin /* Verify user input. */ 15828c5ad0daSSasha Neftin for (i = 0; i < IGC_RETA_SIZE; i++) 15838c5ad0daSSasha Neftin if (indir[i] >= num_queues) 15848c5ad0daSSasha Neftin return -EINVAL; 15858c5ad0daSSasha Neftin 15868c5ad0daSSasha Neftin for (i = 0; i < IGC_RETA_SIZE; i++) 15878c5ad0daSSasha Neftin adapter->rss_indir_tbl[i] = indir[i]; 15888c5ad0daSSasha Neftin 15898c5ad0daSSasha Neftin igc_write_rss_indir_tbl(adapter); 15908c5ad0daSSasha Neftin 15918c5ad0daSSasha Neftin return 0; 15928c5ad0daSSasha Neftin } 15938c5ad0daSSasha Neftin 15948c5ad0daSSasha Neftin static unsigned int igc_max_channels(struct igc_adapter *adapter) 15958c5ad0daSSasha Neftin { 15968c5ad0daSSasha Neftin return igc_get_max_rss_queues(adapter); 15978c5ad0daSSasha Neftin } 15988c5ad0daSSasha Neftin 15998c5ad0daSSasha Neftin static void igc_get_channels(struct net_device *netdev, 16008c5ad0daSSasha Neftin struct ethtool_channels *ch) 16018c5ad0daSSasha Neftin { 16028c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 16038c5ad0daSSasha Neftin 16048c5ad0daSSasha Neftin /* Report maximum channels */ 16058c5ad0daSSasha Neftin ch->max_combined = igc_max_channels(adapter); 16068c5ad0daSSasha Neftin 16078c5ad0daSSasha Neftin /* Report info for other vector */ 16088c5ad0daSSasha Neftin if (adapter->flags & IGC_FLAG_HAS_MSIX) { 16098c5ad0daSSasha Neftin ch->max_other = NON_Q_VECTORS; 16108c5ad0daSSasha Neftin ch->other_count = NON_Q_VECTORS; 16118c5ad0daSSasha Neftin } 16128c5ad0daSSasha Neftin 16138c5ad0daSSasha Neftin ch->combined_count = adapter->rss_queues; 16148c5ad0daSSasha Neftin } 16158c5ad0daSSasha Neftin 16168c5ad0daSSasha Neftin static int igc_set_channels(struct net_device *netdev, 16178c5ad0daSSasha Neftin struct ethtool_channels *ch) 16188c5ad0daSSasha Neftin { 16198c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 16208c5ad0daSSasha Neftin unsigned int count = ch->combined_count; 16218c5ad0daSSasha Neftin unsigned int max_combined = 0; 16228c5ad0daSSasha Neftin 16238c5ad0daSSasha Neftin /* Verify they are not requesting separate vectors */ 16248c5ad0daSSasha Neftin if (!count || ch->rx_count || ch->tx_count) 16258c5ad0daSSasha Neftin return -EINVAL; 16268c5ad0daSSasha Neftin 16278c5ad0daSSasha Neftin /* Verify other_count is valid and has not been changed */ 16288c5ad0daSSasha Neftin if (ch->other_count != NON_Q_VECTORS) 16298c5ad0daSSasha Neftin return -EINVAL; 16308c5ad0daSSasha Neftin 16318c5ad0daSSasha Neftin /* Verify the number of channels doesn't exceed hw limits */ 16328c5ad0daSSasha Neftin max_combined = igc_max_channels(adapter); 16338c5ad0daSSasha Neftin if (count > max_combined) 16348c5ad0daSSasha Neftin return -EINVAL; 16358c5ad0daSSasha Neftin 16368c5ad0daSSasha Neftin if (count != adapter->rss_queues) { 16378c5ad0daSSasha Neftin adapter->rss_queues = count; 16388c5ad0daSSasha Neftin igc_set_flag_queue_pairs(adapter, max_combined); 16398c5ad0daSSasha Neftin 16408c5ad0daSSasha Neftin /* Hardware has to reinitialize queues and interrupts to 16418c5ad0daSSasha Neftin * match the new configuration. 16428c5ad0daSSasha Neftin */ 16438c5ad0daSSasha Neftin return igc_reinit_queues(adapter); 16448c5ad0daSSasha Neftin } 16458c5ad0daSSasha Neftin 16468c5ad0daSSasha Neftin return 0; 16478c5ad0daSSasha Neftin } 16488c5ad0daSSasha Neftin 164960dbede0SVinicius Costa Gomes static int igc_get_ts_info(struct net_device *dev, 165060dbede0SVinicius Costa Gomes struct ethtool_ts_info *info) 165160dbede0SVinicius Costa Gomes { 165260dbede0SVinicius Costa Gomes struct igc_adapter *adapter = netdev_priv(dev); 165360dbede0SVinicius Costa Gomes 165460dbede0SVinicius Costa Gomes if (adapter->ptp_clock) 165560dbede0SVinicius Costa Gomes info->phc_index = ptp_clock_index(adapter->ptp_clock); 165660dbede0SVinicius Costa Gomes else 165760dbede0SVinicius Costa Gomes info->phc_index = -1; 165860dbede0SVinicius Costa Gomes 165960dbede0SVinicius Costa Gomes switch (adapter->hw.mac.type) { 166060dbede0SVinicius Costa Gomes case igc_i225: 166160dbede0SVinicius Costa Gomes info->so_timestamping = 166260dbede0SVinicius Costa Gomes SOF_TIMESTAMPING_TX_SOFTWARE | 166360dbede0SVinicius Costa Gomes SOF_TIMESTAMPING_RX_SOFTWARE | 166460dbede0SVinicius Costa Gomes SOF_TIMESTAMPING_SOFTWARE | 166560dbede0SVinicius Costa Gomes SOF_TIMESTAMPING_TX_HARDWARE | 166660dbede0SVinicius Costa Gomes SOF_TIMESTAMPING_RX_HARDWARE | 166760dbede0SVinicius Costa Gomes SOF_TIMESTAMPING_RAW_HARDWARE; 166860dbede0SVinicius Costa Gomes 166960dbede0SVinicius Costa Gomes info->tx_types = 167060dbede0SVinicius Costa Gomes BIT(HWTSTAMP_TX_OFF) | 167160dbede0SVinicius Costa Gomes BIT(HWTSTAMP_TX_ON); 167260dbede0SVinicius Costa Gomes 167360dbede0SVinicius Costa Gomes info->rx_filters = BIT(HWTSTAMP_FILTER_NONE); 167460dbede0SVinicius Costa Gomes info->rx_filters |= BIT(HWTSTAMP_FILTER_ALL); 167560dbede0SVinicius Costa Gomes 167660dbede0SVinicius Costa Gomes return 0; 167760dbede0SVinicius Costa Gomes default: 167860dbede0SVinicius Costa Gomes return -EOPNOTSUPP; 167960dbede0SVinicius Costa Gomes } 168060dbede0SVinicius Costa Gomes } 168160dbede0SVinicius Costa Gomes 16828c5ad0daSSasha Neftin static u32 igc_get_priv_flags(struct net_device *netdev) 16838c5ad0daSSasha Neftin { 16848c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 16858c5ad0daSSasha Neftin u32 priv_flags = 0; 16868c5ad0daSSasha Neftin 16878c5ad0daSSasha Neftin if (adapter->flags & IGC_FLAG_RX_LEGACY) 16888c5ad0daSSasha Neftin priv_flags |= IGC_PRIV_FLAGS_LEGACY_RX; 16898c5ad0daSSasha Neftin 16908c5ad0daSSasha Neftin return priv_flags; 16918c5ad0daSSasha Neftin } 16928c5ad0daSSasha Neftin 16938c5ad0daSSasha Neftin static int igc_set_priv_flags(struct net_device *netdev, u32 priv_flags) 16948c5ad0daSSasha Neftin { 16958c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 16968c5ad0daSSasha Neftin unsigned int flags = adapter->flags; 16978c5ad0daSSasha Neftin 16988c5ad0daSSasha Neftin flags &= ~IGC_FLAG_RX_LEGACY; 16998c5ad0daSSasha Neftin if (priv_flags & IGC_PRIV_FLAGS_LEGACY_RX) 17008c5ad0daSSasha Neftin flags |= IGC_FLAG_RX_LEGACY; 17018c5ad0daSSasha Neftin 17028c5ad0daSSasha Neftin if (flags != adapter->flags) { 17038c5ad0daSSasha Neftin adapter->flags = flags; 17048c5ad0daSSasha Neftin 17058c5ad0daSSasha Neftin /* reset interface to repopulate queues */ 17068c5ad0daSSasha Neftin if (netif_running(netdev)) 17078c5ad0daSSasha Neftin igc_reinit_locked(adapter); 17088c5ad0daSSasha Neftin } 17098c5ad0daSSasha Neftin 17108c5ad0daSSasha Neftin return 0; 17118c5ad0daSSasha Neftin } 17128c5ad0daSSasha Neftin 17138c5ad0daSSasha Neftin static int igc_ethtool_begin(struct net_device *netdev) 17148c5ad0daSSasha Neftin { 17158c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 17168c5ad0daSSasha Neftin 17178c5ad0daSSasha Neftin pm_runtime_get_sync(&adapter->pdev->dev); 17188c5ad0daSSasha Neftin return 0; 17198c5ad0daSSasha Neftin } 17208c5ad0daSSasha Neftin 17218c5ad0daSSasha Neftin static void igc_ethtool_complete(struct net_device *netdev) 17228c5ad0daSSasha Neftin { 17238c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 17248c5ad0daSSasha Neftin 17258c5ad0daSSasha Neftin pm_runtime_put(&adapter->pdev->dev); 17268c5ad0daSSasha Neftin } 17278c5ad0daSSasha Neftin 17288c5ad0daSSasha Neftin static int igc_get_link_ksettings(struct net_device *netdev, 17298c5ad0daSSasha Neftin struct ethtool_link_ksettings *cmd) 17308c5ad0daSSasha Neftin { 17318c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 17328c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 17338c5ad0daSSasha Neftin u32 status; 17348c5ad0daSSasha Neftin u32 speed; 17358c5ad0daSSasha Neftin 17368c5ad0daSSasha Neftin ethtool_link_ksettings_zero_link_mode(cmd, supported); 17378c5ad0daSSasha Neftin ethtool_link_ksettings_zero_link_mode(cmd, advertising); 17388c5ad0daSSasha Neftin 17398c5ad0daSSasha Neftin /* supported link modes */ 17408c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Half); 17418c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Full); 17428c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Half); 17438c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Full); 17448c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, supported, 1000baseT_Full); 17458c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, supported, 2500baseT_Full); 17468c5ad0daSSasha Neftin 17478c5ad0daSSasha Neftin /* twisted pair */ 17488c5ad0daSSasha Neftin cmd->base.port = PORT_TP; 17498c5ad0daSSasha Neftin cmd->base.phy_address = hw->phy.addr; 17508c5ad0daSSasha Neftin 17518c5ad0daSSasha Neftin /* advertising link modes */ 17528c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 10baseT_Half); 17538c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 10baseT_Full); 17548c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 100baseT_Half); 17558c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 100baseT_Full); 17568c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 1000baseT_Full); 17578c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 2500baseT_Full); 17588c5ad0daSSasha Neftin 17598c5ad0daSSasha Neftin /* set autoneg settings */ 17608c5ad0daSSasha Neftin if (hw->mac.autoneg == 1) { 17618c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, supported, Autoneg); 17628c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 17638c5ad0daSSasha Neftin Autoneg); 17648c5ad0daSSasha Neftin } 17658c5ad0daSSasha Neftin 17668c5ad0daSSasha Neftin switch (hw->fc.requested_mode) { 17678c5ad0daSSasha Neftin case igc_fc_full: 17688c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause); 17698c5ad0daSSasha Neftin break; 17708c5ad0daSSasha Neftin case igc_fc_rx_pause: 17718c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause); 17728c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 17738c5ad0daSSasha Neftin Asym_Pause); 17748c5ad0daSSasha Neftin break; 17758c5ad0daSSasha Neftin case igc_fc_tx_pause: 17768c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 17778c5ad0daSSasha Neftin Asym_Pause); 17788c5ad0daSSasha Neftin break; 17798c5ad0daSSasha Neftin default: 17808c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause); 17818c5ad0daSSasha Neftin ethtool_link_ksettings_add_link_mode(cmd, advertising, 17828c5ad0daSSasha Neftin Asym_Pause); 17838c5ad0daSSasha Neftin } 17848c5ad0daSSasha Neftin 17858c5ad0daSSasha Neftin status = rd32(IGC_STATUS); 17868c5ad0daSSasha Neftin 17878c5ad0daSSasha Neftin if (status & IGC_STATUS_LU) { 17888c5ad0daSSasha Neftin if (status & IGC_STATUS_SPEED_1000) { 17898c5ad0daSSasha Neftin /* For I225, STATUS will indicate 1G speed in both 17908c5ad0daSSasha Neftin * 1 Gbps and 2.5 Gbps link modes. 17918c5ad0daSSasha Neftin * An additional bit is used 17928c5ad0daSSasha Neftin * to differentiate between 1 Gbps and 2.5 Gbps. 17938c5ad0daSSasha Neftin */ 17948c5ad0daSSasha Neftin if (hw->mac.type == igc_i225 && 17958c5ad0daSSasha Neftin (status & IGC_STATUS_SPEED_2500)) { 17968c5ad0daSSasha Neftin speed = SPEED_2500; 17978c5ad0daSSasha Neftin } else { 17988c5ad0daSSasha Neftin speed = SPEED_1000; 17998c5ad0daSSasha Neftin } 18008c5ad0daSSasha Neftin } else if (status & IGC_STATUS_SPEED_100) { 18018c5ad0daSSasha Neftin speed = SPEED_100; 18028c5ad0daSSasha Neftin } else { 18038c5ad0daSSasha Neftin speed = SPEED_10; 18048c5ad0daSSasha Neftin } 18058c5ad0daSSasha Neftin if ((status & IGC_STATUS_FD) || 18068c5ad0daSSasha Neftin hw->phy.media_type != igc_media_type_copper) 18078c5ad0daSSasha Neftin cmd->base.duplex = DUPLEX_FULL; 18088c5ad0daSSasha Neftin else 18098c5ad0daSSasha Neftin cmd->base.duplex = DUPLEX_HALF; 18108c5ad0daSSasha Neftin } else { 18118c5ad0daSSasha Neftin speed = SPEED_UNKNOWN; 18128c5ad0daSSasha Neftin cmd->base.duplex = DUPLEX_UNKNOWN; 18138c5ad0daSSasha Neftin } 18148c5ad0daSSasha Neftin cmd->base.speed = speed; 18158c5ad0daSSasha Neftin if (hw->mac.autoneg) 18168c5ad0daSSasha Neftin cmd->base.autoneg = AUTONEG_ENABLE; 18178c5ad0daSSasha Neftin else 18188c5ad0daSSasha Neftin cmd->base.autoneg = AUTONEG_DISABLE; 18198c5ad0daSSasha Neftin 18208c5ad0daSSasha Neftin /* MDI-X => 2; MDI =>1; Invalid =>0 */ 18218c5ad0daSSasha Neftin if (hw->phy.media_type == igc_media_type_copper) 18228c5ad0daSSasha Neftin cmd->base.eth_tp_mdix = hw->phy.is_mdix ? ETH_TP_MDI_X : 18238c5ad0daSSasha Neftin ETH_TP_MDI; 18248c5ad0daSSasha Neftin else 18258c5ad0daSSasha Neftin cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID; 18268c5ad0daSSasha Neftin 18278c5ad0daSSasha Neftin if (hw->phy.mdix == AUTO_ALL_MODES) 18288c5ad0daSSasha Neftin cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO; 18298c5ad0daSSasha Neftin else 18308c5ad0daSSasha Neftin cmd->base.eth_tp_mdix_ctrl = hw->phy.mdix; 18318c5ad0daSSasha Neftin 18328c5ad0daSSasha Neftin return 0; 18338c5ad0daSSasha Neftin } 18348c5ad0daSSasha Neftin 18358c5ad0daSSasha Neftin static int igc_set_link_ksettings(struct net_device *netdev, 18368c5ad0daSSasha Neftin const struct ethtool_link_ksettings *cmd) 18378c5ad0daSSasha Neftin { 18388c5ad0daSSasha Neftin struct igc_adapter *adapter = netdev_priv(netdev); 183995f96a9fSAndre Guedes struct net_device *dev = adapter->netdev; 18408c5ad0daSSasha Neftin struct igc_hw *hw = &adapter->hw; 18418c5ad0daSSasha Neftin u32 advertising; 18428c5ad0daSSasha Neftin 18438c5ad0daSSasha Neftin /* When adapter in resetting mode, autoneg/speed/duplex 18448c5ad0daSSasha Neftin * cannot be changed 18458c5ad0daSSasha Neftin */ 18468c5ad0daSSasha Neftin if (igc_check_reset_block(hw)) { 184795f96a9fSAndre Guedes netdev_err(dev, "Cannot change link characteristics when reset is active\n"); 18488c5ad0daSSasha Neftin return -EINVAL; 18498c5ad0daSSasha Neftin } 18508c5ad0daSSasha Neftin 18518c5ad0daSSasha Neftin /* MDI setting is only allowed when autoneg enabled because 18528c5ad0daSSasha Neftin * some hardware doesn't allow MDI setting when speed or 18538c5ad0daSSasha Neftin * duplex is forced. 18548c5ad0daSSasha Neftin */ 18558c5ad0daSSasha Neftin if (cmd->base.eth_tp_mdix_ctrl) { 18568c5ad0daSSasha Neftin if (cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO && 18578c5ad0daSSasha Neftin cmd->base.autoneg != AUTONEG_ENABLE) { 185895f96a9fSAndre Guedes netdev_err(dev, "Forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n"); 18598c5ad0daSSasha Neftin return -EINVAL; 18608c5ad0daSSasha Neftin } 18618c5ad0daSSasha Neftin } 18628c5ad0daSSasha Neftin 18638c5ad0daSSasha Neftin while (test_and_set_bit(__IGC_RESETTING, &adapter->state)) 18648c5ad0daSSasha Neftin usleep_range(1000, 2000); 18658c5ad0daSSasha Neftin 18668c5ad0daSSasha Neftin ethtool_convert_link_mode_to_legacy_u32(&advertising, 18678c5ad0daSSasha Neftin cmd->link_modes.advertising); 18688c5ad0daSSasha Neftin 18698c5ad0daSSasha Neftin if (cmd->base.autoneg == AUTONEG_ENABLE) { 18708c5ad0daSSasha Neftin hw->mac.autoneg = 1; 18718c5ad0daSSasha Neftin hw->phy.autoneg_advertised = advertising; 18728c5ad0daSSasha Neftin if (adapter->fc_autoneg) 18738c5ad0daSSasha Neftin hw->fc.requested_mode = igc_fc_default; 18748c5ad0daSSasha Neftin } else { 187595f96a9fSAndre Guedes netdev_info(dev, "Force mode currently not supported\n"); 18768c5ad0daSSasha Neftin } 18778c5ad0daSSasha Neftin 18788c5ad0daSSasha Neftin /* MDI-X => 2; MDI => 1; Auto => 3 */ 18798c5ad0daSSasha Neftin if (cmd->base.eth_tp_mdix_ctrl) { 18808c5ad0daSSasha Neftin /* fix up the value for auto (3 => 0) as zero is mapped 18818c5ad0daSSasha Neftin * internally to auto 18828c5ad0daSSasha Neftin */ 18838c5ad0daSSasha Neftin if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO) 18848c5ad0daSSasha Neftin hw->phy.mdix = AUTO_ALL_MODES; 18858c5ad0daSSasha Neftin else 18868c5ad0daSSasha Neftin hw->phy.mdix = cmd->base.eth_tp_mdix_ctrl; 18878c5ad0daSSasha Neftin } 18888c5ad0daSSasha Neftin 18898c5ad0daSSasha Neftin /* reset the link */ 18908c5ad0daSSasha Neftin if (netif_running(adapter->netdev)) { 18918c5ad0daSSasha Neftin igc_down(adapter); 18928c5ad0daSSasha Neftin igc_up(adapter); 18938c5ad0daSSasha Neftin } else { 18948c5ad0daSSasha Neftin igc_reset(adapter); 18958c5ad0daSSasha Neftin } 18968c5ad0daSSasha Neftin 18978c5ad0daSSasha Neftin clear_bit(__IGC_RESETTING, &adapter->state); 18988c5ad0daSSasha Neftin 18998c5ad0daSSasha Neftin return 0; 19008c5ad0daSSasha Neftin } 19018c5ad0daSSasha Neftin 1902f026d8caSVitaly Lifshits static void igc_diag_test(struct net_device *netdev, 1903f026d8caSVitaly Lifshits struct ethtool_test *eth_test, u64 *data) 1904f026d8caSVitaly Lifshits { 1905f026d8caSVitaly Lifshits struct igc_adapter *adapter = netdev_priv(netdev); 1906f026d8caSVitaly Lifshits bool if_running = netif_running(netdev); 1907f026d8caSVitaly Lifshits 1908f026d8caSVitaly Lifshits if (eth_test->flags == ETH_TEST_FL_OFFLINE) { 190995f96a9fSAndre Guedes netdev_info(adapter->netdev, "Offline testing starting"); 1910f026d8caSVitaly Lifshits set_bit(__IGC_TESTING, &adapter->state); 1911f026d8caSVitaly Lifshits 1912f026d8caSVitaly Lifshits /* Link test performed before hardware reset so autoneg doesn't 1913f026d8caSVitaly Lifshits * interfere with test result 1914f026d8caSVitaly Lifshits */ 1915f026d8caSVitaly Lifshits if (!igc_link_test(adapter, &data[TEST_LINK])) 1916f026d8caSVitaly Lifshits eth_test->flags |= ETH_TEST_FL_FAILED; 1917f026d8caSVitaly Lifshits 1918f026d8caSVitaly Lifshits if (if_running) 1919f026d8caSVitaly Lifshits igc_close(netdev); 1920f026d8caSVitaly Lifshits else 1921f026d8caSVitaly Lifshits igc_reset(adapter); 1922f026d8caSVitaly Lifshits 192395f96a9fSAndre Guedes netdev_info(adapter->netdev, "Register testing starting"); 1924f026d8caSVitaly Lifshits if (!igc_reg_test(adapter, &data[TEST_REG])) 1925f026d8caSVitaly Lifshits eth_test->flags |= ETH_TEST_FL_FAILED; 1926f026d8caSVitaly Lifshits 1927f026d8caSVitaly Lifshits igc_reset(adapter); 1928f026d8caSVitaly Lifshits 192995f96a9fSAndre Guedes netdev_info(adapter->netdev, "EEPROM testing starting"); 1930f026d8caSVitaly Lifshits if (!igc_eeprom_test(adapter, &data[TEST_EEP])) 1931f026d8caSVitaly Lifshits eth_test->flags |= ETH_TEST_FL_FAILED; 1932f026d8caSVitaly Lifshits 1933f026d8caSVitaly Lifshits igc_reset(adapter); 1934f026d8caSVitaly Lifshits 1935f026d8caSVitaly Lifshits /* loopback and interrupt tests 1936f026d8caSVitaly Lifshits * will be implemented in the future 1937f026d8caSVitaly Lifshits */ 1938f026d8caSVitaly Lifshits data[TEST_LOOP] = 0; 1939f026d8caSVitaly Lifshits data[TEST_IRQ] = 0; 1940f026d8caSVitaly Lifshits 1941f026d8caSVitaly Lifshits clear_bit(__IGC_TESTING, &adapter->state); 1942f026d8caSVitaly Lifshits if (if_running) 1943f026d8caSVitaly Lifshits igc_open(netdev); 1944f026d8caSVitaly Lifshits } else { 194595f96a9fSAndre Guedes netdev_info(adapter->netdev, "Online testing starting"); 1946f026d8caSVitaly Lifshits 1947f026d8caSVitaly Lifshits /* register, eeprom, intr and loopback tests not run online */ 1948f026d8caSVitaly Lifshits data[TEST_REG] = 0; 1949f026d8caSVitaly Lifshits data[TEST_EEP] = 0; 1950f026d8caSVitaly Lifshits data[TEST_IRQ] = 0; 1951f026d8caSVitaly Lifshits data[TEST_LOOP] = 0; 1952f026d8caSVitaly Lifshits 1953f026d8caSVitaly Lifshits if (!igc_link_test(adapter, &data[TEST_LINK])) 1954f026d8caSVitaly Lifshits eth_test->flags |= ETH_TEST_FL_FAILED; 1955f026d8caSVitaly Lifshits } 1956f026d8caSVitaly Lifshits 1957f026d8caSVitaly Lifshits msleep_interruptible(4 * 1000); 1958f026d8caSVitaly Lifshits } 1959f026d8caSVitaly Lifshits 19608c5ad0daSSasha Neftin static const struct ethtool_ops igc_ethtool_ops = { 1961dbfa497aSJakub Kicinski .supported_coalesce_params = ETHTOOL_COALESCE_USECS, 19628c5ad0daSSasha Neftin .get_drvinfo = igc_get_drvinfo, 19638c5ad0daSSasha Neftin .get_regs_len = igc_get_regs_len, 19648c5ad0daSSasha Neftin .get_regs = igc_get_regs, 1965e055600dSSasha Neftin .get_wol = igc_get_wol, 1966e055600dSSasha Neftin .set_wol = igc_set_wol, 19678c5ad0daSSasha Neftin .get_msglevel = igc_get_msglevel, 19688c5ad0daSSasha Neftin .set_msglevel = igc_set_msglevel, 19698c5ad0daSSasha Neftin .nway_reset = igc_nway_reset, 19708c5ad0daSSasha Neftin .get_link = igc_get_link, 19718c5ad0daSSasha Neftin .get_eeprom_len = igc_get_eeprom_len, 19728c5ad0daSSasha Neftin .get_eeprom = igc_get_eeprom, 19738c5ad0daSSasha Neftin .set_eeprom = igc_set_eeprom, 19748c5ad0daSSasha Neftin .get_ringparam = igc_get_ringparam, 19758c5ad0daSSasha Neftin .set_ringparam = igc_set_ringparam, 19768c5ad0daSSasha Neftin .get_pauseparam = igc_get_pauseparam, 19778c5ad0daSSasha Neftin .set_pauseparam = igc_set_pauseparam, 197836b9fea6SSasha Neftin .get_strings = igc_get_strings, 197936b9fea6SSasha Neftin .get_sset_count = igc_get_sset_count, 198036b9fea6SSasha Neftin .get_ethtool_stats = igc_get_ethtool_stats, 19818c5ad0daSSasha Neftin .get_coalesce = igc_get_coalesce, 19828c5ad0daSSasha Neftin .set_coalesce = igc_set_coalesce, 19836245c848SSasha Neftin .get_rxnfc = igc_get_rxnfc, 19846245c848SSasha Neftin .set_rxnfc = igc_set_rxnfc, 19858c5ad0daSSasha Neftin .get_rxfh_indir_size = igc_get_rxfh_indir_size, 19868c5ad0daSSasha Neftin .get_rxfh = igc_get_rxfh, 19878c5ad0daSSasha Neftin .set_rxfh = igc_set_rxfh, 198860dbede0SVinicius Costa Gomes .get_ts_info = igc_get_ts_info, 19898c5ad0daSSasha Neftin .get_channels = igc_get_channels, 19908c5ad0daSSasha Neftin .set_channels = igc_set_channels, 19918c5ad0daSSasha Neftin .get_priv_flags = igc_get_priv_flags, 19928c5ad0daSSasha Neftin .set_priv_flags = igc_set_priv_flags, 19938c5ad0daSSasha Neftin .begin = igc_ethtool_begin, 19948c5ad0daSSasha Neftin .complete = igc_ethtool_complete, 19958c5ad0daSSasha Neftin .get_link_ksettings = igc_get_link_ksettings, 19968c5ad0daSSasha Neftin .set_link_ksettings = igc_set_link_ksettings, 1997f026d8caSVitaly Lifshits .self_test = igc_diag_test, 19988c5ad0daSSasha Neftin }; 19998c5ad0daSSasha Neftin 20008c5ad0daSSasha Neftin void igc_set_ethtool_ops(struct net_device *netdev) 20018c5ad0daSSasha Neftin { 20028c5ad0daSSasha Neftin netdev->ethtool_ops = &igc_ethtool_ops; 20038c5ad0daSSasha Neftin } 2004