Commit | Line | Data |
---|---|---|
92915f71 GR |
1 | /******************************************************************************* |
2 | ||
3 | Intel 82599 Virtual Function driver | |
4 | Copyright(c) 1999 - 2009 Intel Corporation. | |
5 | ||
6 | This program is free software; you can redistribute it and/or modify it | |
7 | under the terms and conditions of the GNU General Public License, | |
8 | version 2, as published by the Free Software Foundation. | |
9 | ||
10 | This program is distributed in the hope it will be useful, but WITHOUT | |
11 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
12 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
13 | more details. | |
14 | ||
15 | You should have received a copy of the GNU General Public License along with | |
16 | this program; if not, write to the Free Software Foundation, Inc., | |
17 | 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. | |
18 | ||
19 | The full GNU General Public License is included in this distribution in | |
20 | the file called "COPYING". | |
21 | ||
22 | Contact Information: | |
23 | e1000-devel Mailing List <e1000-devel@lists.sourceforge.net> | |
24 | Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 | |
25 | ||
26 | *******************************************************************************/ | |
27 | ||
28 | /* ethtool support for ixgbevf */ | |
29 | ||
30 | #include <linux/types.h> | |
31 | #include <linux/module.h> | |
5a0e3ad6 | 32 | #include <linux/slab.h> |
92915f71 GR |
33 | #include <linux/pci.h> |
34 | #include <linux/netdevice.h> | |
35 | #include <linux/ethtool.h> | |
36 | #include <linux/vmalloc.h> | |
37 | #include <linux/if_vlan.h> | |
38 | #include <linux/uaccess.h> | |
39 | ||
40 | #include "ixgbevf.h" | |
41 | ||
42 | #define IXGBE_ALL_RAR_ENTRIES 16 | |
43 | ||
44 | #ifdef ETHTOOL_GSTATS | |
45 | struct ixgbe_stats { | |
46 | char stat_string[ETH_GSTRING_LEN]; | |
47 | int sizeof_stat; | |
48 | int stat_offset; | |
49 | int base_stat_offset; | |
33bd9f60 | 50 | int saved_reset_offset; |
92915f71 GR |
51 | }; |
52 | ||
33bd9f60 GR |
53 | #define IXGBEVF_STAT(m, b, r) sizeof(((struct ixgbevf_adapter *)0)->m), \ |
54 | offsetof(struct ixgbevf_adapter, m), \ | |
55 | offsetof(struct ixgbevf_adapter, b), \ | |
56 | offsetof(struct ixgbevf_adapter, r) | |
92915f71 | 57 | static struct ixgbe_stats ixgbe_gstrings_stats[] = { |
33bd9f60 GR |
58 | {"rx_packets", IXGBEVF_STAT(stats.vfgprc, stats.base_vfgprc, |
59 | stats.saved_reset_vfgprc)}, | |
60 | {"tx_packets", IXGBEVF_STAT(stats.vfgptc, stats.base_vfgptc, | |
61 | stats.saved_reset_vfgptc)}, | |
62 | {"rx_bytes", IXGBEVF_STAT(stats.vfgorc, stats.base_vfgorc, | |
63 | stats.saved_reset_vfgorc)}, | |
64 | {"tx_bytes", IXGBEVF_STAT(stats.vfgotc, stats.base_vfgotc, | |
65 | stats.saved_reset_vfgotc)}, | |
66 | {"tx_busy", IXGBEVF_STAT(tx_busy, zero_base, zero_base)}, | |
67 | {"multicast", IXGBEVF_STAT(stats.vfmprc, stats.base_vfmprc, | |
68 | stats.saved_reset_vfmprc)}, | |
69 | {"rx_csum_offload_good", IXGBEVF_STAT(hw_csum_rx_good, zero_base, | |
70 | zero_base)}, | |
71 | {"rx_csum_offload_errors", IXGBEVF_STAT(hw_csum_rx_error, zero_base, | |
72 | zero_base)}, | |
73 | {"tx_csum_offload_ctxt", IXGBEVF_STAT(hw_csum_tx_good, zero_base, | |
74 | zero_base)}, | |
75 | {"rx_header_split", IXGBEVF_STAT(rx_hdr_split, zero_base, zero_base)}, | |
92915f71 GR |
76 | }; |
77 | ||
78 | #define IXGBE_QUEUE_STATS_LEN 0 | |
79 | #define IXGBE_GLOBAL_STATS_LEN ARRAY_SIZE(ixgbe_gstrings_stats) | |
80 | ||
81 | #define IXGBEVF_STATS_LEN (IXGBE_GLOBAL_STATS_LEN + IXGBE_QUEUE_STATS_LEN) | |
82 | #endif /* ETHTOOL_GSTATS */ | |
83 | #ifdef ETHTOOL_TEST | |
84 | static const char ixgbe_gstrings_test[][ETH_GSTRING_LEN] = { | |
85 | "Register test (offline)", | |
86 | "Link test (on/offline)" | |
87 | }; | |
88 | #define IXGBE_TEST_LEN (sizeof(ixgbe_gstrings_test) / ETH_GSTRING_LEN) | |
89 | #endif /* ETHTOOL_TEST */ | |
90 | ||
91 | static int ixgbevf_get_settings(struct net_device *netdev, | |
92 | struct ethtool_cmd *ecmd) | |
93 | { | |
94 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
95 | struct ixgbe_hw *hw = &adapter->hw; | |
96 | u32 link_speed = 0; | |
97 | bool link_up; | |
98 | ||
99 | ecmd->supported = SUPPORTED_10000baseT_Full; | |
100 | ecmd->autoneg = AUTONEG_DISABLE; | |
101 | ecmd->transceiver = XCVR_DUMMY1; | |
102 | ecmd->port = -1; | |
103 | ||
104 | hw->mac.ops.check_link(hw, &link_speed, &link_up, false); | |
105 | ||
106 | if (link_up) { | |
70739497 DD |
107 | ethtool_cmd_speed_set( |
108 | ecmd, | |
109 | (link_speed == IXGBE_LINK_SPEED_10GB_FULL) ? | |
110 | SPEED_10000 : SPEED_1000); | |
92915f71 GR |
111 | ecmd->duplex = DUPLEX_FULL; |
112 | } else { | |
70739497 | 113 | ethtool_cmd_speed_set(ecmd, -1); |
92915f71 GR |
114 | ecmd->duplex = -1; |
115 | } | |
116 | ||
117 | return 0; | |
118 | } | |
119 | ||
120 | static u32 ixgbevf_get_rx_csum(struct net_device *netdev) | |
121 | { | |
122 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
123 | return adapter->flags & IXGBE_FLAG_RX_CSUM_ENABLED; | |
124 | } | |
125 | ||
126 | static int ixgbevf_set_rx_csum(struct net_device *netdev, u32 data) | |
127 | { | |
128 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
129 | if (data) | |
130 | adapter->flags |= IXGBE_FLAG_RX_CSUM_ENABLED; | |
131 | else | |
132 | adapter->flags &= ~IXGBE_FLAG_RX_CSUM_ENABLED; | |
133 | ||
134 | if (netif_running(netdev)) { | |
135 | if (!adapter->dev_closed) | |
136 | ixgbevf_reinit_locked(adapter); | |
137 | } else { | |
138 | ixgbevf_reset(adapter); | |
139 | } | |
140 | ||
141 | return 0; | |
142 | } | |
143 | ||
144 | static int ixgbevf_set_tso(struct net_device *netdev, u32 data) | |
145 | { | |
146 | if (data) { | |
147 | netdev->features |= NETIF_F_TSO; | |
148 | netdev->features |= NETIF_F_TSO6; | |
149 | } else { | |
150 | netif_tx_stop_all_queues(netdev); | |
151 | netdev->features &= ~NETIF_F_TSO; | |
152 | netdev->features &= ~NETIF_F_TSO6; | |
153 | netif_tx_start_all_queues(netdev); | |
154 | } | |
155 | return 0; | |
156 | } | |
157 | ||
158 | static u32 ixgbevf_get_msglevel(struct net_device *netdev) | |
159 | { | |
160 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
161 | return adapter->msg_enable; | |
162 | } | |
163 | ||
164 | static void ixgbevf_set_msglevel(struct net_device *netdev, u32 data) | |
165 | { | |
166 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
167 | adapter->msg_enable = data; | |
168 | } | |
169 | ||
170 | #define IXGBE_GET_STAT(_A_, _R_) (_A_->stats._R_) | |
171 | ||
172 | static char *ixgbevf_reg_names[] = { | |
173 | "IXGBE_VFCTRL", | |
174 | "IXGBE_VFSTATUS", | |
175 | "IXGBE_VFLINKS", | |
176 | "IXGBE_VFRXMEMWRAP", | |
6fb456a0 | 177 | "IXGBE_VFFRTIMER", |
92915f71 GR |
178 | "IXGBE_VTEICR", |
179 | "IXGBE_VTEICS", | |
180 | "IXGBE_VTEIMS", | |
181 | "IXGBE_VTEIMC", | |
182 | "IXGBE_VTEIAC", | |
183 | "IXGBE_VTEIAM", | |
184 | "IXGBE_VTEITR", | |
185 | "IXGBE_VTIVAR", | |
186 | "IXGBE_VTIVAR_MISC", | |
187 | "IXGBE_VFRDBAL0", | |
188 | "IXGBE_VFRDBAL1", | |
189 | "IXGBE_VFRDBAH0", | |
190 | "IXGBE_VFRDBAH1", | |
191 | "IXGBE_VFRDLEN0", | |
192 | "IXGBE_VFRDLEN1", | |
193 | "IXGBE_VFRDH0", | |
194 | "IXGBE_VFRDH1", | |
195 | "IXGBE_VFRDT0", | |
196 | "IXGBE_VFRDT1", | |
197 | "IXGBE_VFRXDCTL0", | |
198 | "IXGBE_VFRXDCTL1", | |
199 | "IXGBE_VFSRRCTL0", | |
200 | "IXGBE_VFSRRCTL1", | |
201 | "IXGBE_VFPSRTYPE", | |
202 | "IXGBE_VFTDBAL0", | |
203 | "IXGBE_VFTDBAL1", | |
204 | "IXGBE_VFTDBAH0", | |
205 | "IXGBE_VFTDBAH1", | |
206 | "IXGBE_VFTDLEN0", | |
207 | "IXGBE_VFTDLEN1", | |
208 | "IXGBE_VFTDH0", | |
209 | "IXGBE_VFTDH1", | |
210 | "IXGBE_VFTDT0", | |
211 | "IXGBE_VFTDT1", | |
212 | "IXGBE_VFTXDCTL0", | |
213 | "IXGBE_VFTXDCTL1", | |
214 | "IXGBE_VFTDWBAL0", | |
215 | "IXGBE_VFTDWBAL1", | |
216 | "IXGBE_VFTDWBAH0", | |
217 | "IXGBE_VFTDWBAH1" | |
218 | }; | |
219 | ||
220 | ||
221 | static int ixgbevf_get_regs_len(struct net_device *netdev) | |
222 | { | |
223 | return (ARRAY_SIZE(ixgbevf_reg_names)) * sizeof(u32); | |
224 | } | |
225 | ||
226 | static void ixgbevf_get_regs(struct net_device *netdev, | |
227 | struct ethtool_regs *regs, | |
228 | void *p) | |
229 | { | |
230 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
231 | struct ixgbe_hw *hw = &adapter->hw; | |
232 | u32 *regs_buff = p; | |
233 | u32 regs_len = ixgbevf_get_regs_len(netdev); | |
234 | u8 i; | |
235 | ||
236 | memset(p, 0, regs_len); | |
237 | ||
238 | regs->version = (1 << 24) | hw->revision_id << 16 | hw->device_id; | |
239 | ||
240 | /* General Registers */ | |
241 | regs_buff[0] = IXGBE_READ_REG(hw, IXGBE_VFCTRL); | |
242 | regs_buff[1] = IXGBE_READ_REG(hw, IXGBE_VFSTATUS); | |
243 | regs_buff[2] = IXGBE_READ_REG(hw, IXGBE_VFLINKS); | |
244 | regs_buff[3] = IXGBE_READ_REG(hw, IXGBE_VFRXMEMWRAP); | |
6fb456a0 | 245 | regs_buff[4] = IXGBE_READ_REG(hw, IXGBE_VFFRTIMER); |
92915f71 GR |
246 | |
247 | /* Interrupt */ | |
248 | /* don't read EICR because it can clear interrupt causes, instead | |
249 | * read EICS which is a shadow but doesn't clear EICR */ | |
250 | regs_buff[5] = IXGBE_READ_REG(hw, IXGBE_VTEICS); | |
251 | regs_buff[6] = IXGBE_READ_REG(hw, IXGBE_VTEICS); | |
252 | regs_buff[7] = IXGBE_READ_REG(hw, IXGBE_VTEIMS); | |
253 | regs_buff[8] = IXGBE_READ_REG(hw, IXGBE_VTEIMC); | |
254 | regs_buff[9] = IXGBE_READ_REG(hw, IXGBE_VTEIAC); | |
255 | regs_buff[10] = IXGBE_READ_REG(hw, IXGBE_VTEIAM); | |
256 | regs_buff[11] = IXGBE_READ_REG(hw, IXGBE_VTEITR(0)); | |
257 | regs_buff[12] = IXGBE_READ_REG(hw, IXGBE_VTIVAR(0)); | |
258 | regs_buff[13] = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC); | |
259 | ||
260 | /* Receive DMA */ | |
261 | for (i = 0; i < 2; i++) | |
262 | regs_buff[14 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAL(i)); | |
263 | for (i = 0; i < 2; i++) | |
264 | regs_buff[16 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAH(i)); | |
265 | for (i = 0; i < 2; i++) | |
266 | regs_buff[18 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDLEN(i)); | |
267 | for (i = 0; i < 2; i++) | |
268 | regs_buff[20 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDH(i)); | |
269 | for (i = 0; i < 2; i++) | |
270 | regs_buff[22 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDT(i)); | |
271 | for (i = 0; i < 2; i++) | |
272 | regs_buff[24 + i] = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i)); | |
273 | for (i = 0; i < 2; i++) | |
274 | regs_buff[26 + i] = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(i)); | |
275 | ||
276 | /* Receive */ | |
277 | regs_buff[28] = IXGBE_READ_REG(hw, IXGBE_VFPSRTYPE); | |
278 | ||
279 | /* Transmit */ | |
280 | for (i = 0; i < 2; i++) | |
281 | regs_buff[29 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAL(i)); | |
282 | for (i = 0; i < 2; i++) | |
283 | regs_buff[31 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAH(i)); | |
284 | for (i = 0; i < 2; i++) | |
285 | regs_buff[33 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDLEN(i)); | |
286 | for (i = 0; i < 2; i++) | |
287 | regs_buff[35 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDH(i)); | |
288 | for (i = 0; i < 2; i++) | |
289 | regs_buff[37 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDT(i)); | |
290 | for (i = 0; i < 2; i++) | |
291 | regs_buff[39 + i] = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i)); | |
292 | for (i = 0; i < 2; i++) | |
293 | regs_buff[41 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAL(i)); | |
294 | for (i = 0; i < 2; i++) | |
295 | regs_buff[43 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAH(i)); | |
296 | ||
297 | for (i = 0; i < ARRAY_SIZE(ixgbevf_reg_names); i++) | |
298 | hw_dbg(hw, "%s\t%8.8x\n", ixgbevf_reg_names[i], regs_buff[i]); | |
299 | } | |
300 | ||
301 | static void ixgbevf_get_drvinfo(struct net_device *netdev, | |
302 | struct ethtool_drvinfo *drvinfo) | |
303 | { | |
304 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
305 | ||
306 | strlcpy(drvinfo->driver, ixgbevf_driver_name, 32); | |
307 | strlcpy(drvinfo->version, ixgbevf_driver_version, 32); | |
308 | ||
309 | strlcpy(drvinfo->fw_version, "N/A", 4); | |
310 | strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 32); | |
311 | } | |
312 | ||
313 | static void ixgbevf_get_ringparam(struct net_device *netdev, | |
314 | struct ethtool_ringparam *ring) | |
315 | { | |
316 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
317 | struct ixgbevf_ring *tx_ring = adapter->tx_ring; | |
318 | struct ixgbevf_ring *rx_ring = adapter->rx_ring; | |
319 | ||
320 | ring->rx_max_pending = IXGBEVF_MAX_RXD; | |
321 | ring->tx_max_pending = IXGBEVF_MAX_TXD; | |
322 | ring->rx_mini_max_pending = 0; | |
323 | ring->rx_jumbo_max_pending = 0; | |
324 | ring->rx_pending = rx_ring->count; | |
325 | ring->tx_pending = tx_ring->count; | |
326 | ring->rx_mini_pending = 0; | |
327 | ring->rx_jumbo_pending = 0; | |
328 | } | |
329 | ||
330 | static int ixgbevf_set_ringparam(struct net_device *netdev, | |
331 | struct ethtool_ringparam *ring) | |
332 | { | |
333 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
334 | struct ixgbevf_ring *tx_ring = NULL, *rx_ring = NULL; | |
bba50b99 | 335 | int i, err = 0; |
92915f71 | 336 | u32 new_rx_count, new_tx_count; |
92915f71 GR |
337 | |
338 | if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending)) | |
339 | return -EINVAL; | |
340 | ||
341 | new_rx_count = max(ring->rx_pending, (u32)IXGBEVF_MIN_RXD); | |
342 | new_rx_count = min(new_rx_count, (u32)IXGBEVF_MAX_RXD); | |
343 | new_rx_count = ALIGN(new_rx_count, IXGBE_REQ_RX_DESCRIPTOR_MULTIPLE); | |
344 | ||
345 | new_tx_count = max(ring->tx_pending, (u32)IXGBEVF_MIN_TXD); | |
346 | new_tx_count = min(new_tx_count, (u32)IXGBEVF_MAX_TXD); | |
347 | new_tx_count = ALIGN(new_tx_count, IXGBE_REQ_TX_DESCRIPTOR_MULTIPLE); | |
348 | ||
349 | if ((new_tx_count == adapter->tx_ring->count) && | |
350 | (new_rx_count == adapter->rx_ring->count)) { | |
351 | /* nothing to do */ | |
352 | return 0; | |
353 | } | |
354 | ||
355 | while (test_and_set_bit(__IXGBEVF_RESETTING, &adapter->state)) | |
356 | msleep(1); | |
357 | ||
bba50b99 GR |
358 | /* |
359 | * If the adapter isn't up and running then just set the | |
360 | * new parameters and scurry for the exits. | |
361 | */ | |
362 | if (!netif_running(adapter->netdev)) { | |
363 | for (i = 0; i < adapter->num_tx_queues; i++) | |
364 | adapter->tx_ring[i].count = new_tx_count; | |
365 | for (i = 0; i < adapter->num_rx_queues; i++) | |
366 | adapter->rx_ring[i].count = new_rx_count; | |
367 | adapter->tx_ring_count = new_tx_count; | |
368 | adapter->rx_ring_count = new_rx_count; | |
369 | goto clear_reset; | |
92915f71 GR |
370 | } |
371 | ||
bba50b99 GR |
372 | tx_ring = kcalloc(adapter->num_tx_queues, |
373 | sizeof(struct ixgbevf_ring), GFP_KERNEL); | |
374 | if (!tx_ring) { | |
375 | err = -ENOMEM; | |
376 | goto clear_reset; | |
92915f71 GR |
377 | } |
378 | ||
bba50b99 GR |
379 | rx_ring = kcalloc(adapter->num_rx_queues, |
380 | sizeof(struct ixgbevf_ring), GFP_KERNEL); | |
381 | if (!rx_ring) { | |
382 | err = -ENOMEM; | |
383 | goto err_rx_setup; | |
92915f71 GR |
384 | } |
385 | ||
bba50b99 GR |
386 | ixgbevf_down(adapter); |
387 | ||
388 | memcpy(tx_ring, adapter->tx_ring, | |
389 | adapter->num_tx_queues * sizeof(struct ixgbevf_ring)); | |
390 | for (i = 0; i < adapter->num_tx_queues; i++) { | |
391 | tx_ring[i].count = new_tx_count; | |
392 | err = ixgbevf_setup_tx_resources(adapter, &tx_ring[i]); | |
393 | if (err) { | |
394 | while (i) { | |
395 | i--; | |
396 | ixgbevf_free_tx_resources(adapter, | |
397 | &tx_ring[i]); | |
398 | } | |
399 | goto err_tx_ring_setup; | |
400 | } | |
401 | tx_ring[i].v_idx = adapter->tx_ring[i].v_idx; | |
92915f71 GR |
402 | } |
403 | ||
bba50b99 GR |
404 | memcpy(rx_ring, adapter->rx_ring, |
405 | adapter->num_rx_queues * sizeof(struct ixgbevf_ring)); | |
406 | for (i = 0; i < adapter->num_rx_queues; i++) { | |
407 | rx_ring[i].count = new_rx_count; | |
408 | err = ixgbevf_setup_rx_resources(adapter, &rx_ring[i]); | |
409 | if (err) { | |
410 | while (i) { | |
411 | i--; | |
412 | ixgbevf_free_rx_resources(adapter, | |
413 | &rx_ring[i]); | |
414 | } | |
415 | goto err_rx_ring_setup; | |
416 | } | |
417 | rx_ring[i].v_idx = adapter->rx_ring[i].v_idx; | |
92915f71 GR |
418 | } |
419 | ||
bba50b99 GR |
420 | /* |
421 | * Only switch to new rings if all the prior allocations | |
422 | * and ring setups have succeeded. | |
423 | */ | |
424 | kfree(adapter->tx_ring); | |
425 | adapter->tx_ring = tx_ring; | |
426 | adapter->tx_ring_count = new_tx_count; | |
427 | ||
428 | kfree(adapter->rx_ring); | |
429 | adapter->rx_ring = rx_ring; | |
430 | adapter->rx_ring_count = new_rx_count; | |
431 | ||
92915f71 | 432 | /* success! */ |
bba50b99 GR |
433 | ixgbevf_up(adapter); |
434 | ||
435 | goto clear_reset; | |
436 | ||
437 | err_rx_ring_setup: | |
438 | for(i = 0; i < adapter->num_tx_queues; i++) | |
439 | ixgbevf_free_tx_resources(adapter, &tx_ring[i]); | |
440 | ||
441 | err_tx_ring_setup: | |
442 | kfree(rx_ring); | |
443 | ||
444 | err_rx_setup: | |
445 | kfree(tx_ring); | |
92915f71 | 446 | |
bba50b99 | 447 | clear_reset: |
92915f71 GR |
448 | clear_bit(__IXGBEVF_RESETTING, &adapter->state); |
449 | return err; | |
450 | } | |
451 | ||
452 | static int ixgbevf_get_sset_count(struct net_device *dev, int stringset) | |
453 | { | |
454 | switch (stringset) { | |
455 | case ETH_SS_TEST: | |
456 | return IXGBE_TEST_LEN; | |
457 | case ETH_SS_STATS: | |
458 | return IXGBE_GLOBAL_STATS_LEN; | |
459 | default: | |
460 | return -EINVAL; | |
461 | } | |
462 | } | |
463 | ||
464 | static void ixgbevf_get_ethtool_stats(struct net_device *netdev, | |
465 | struct ethtool_stats *stats, u64 *data) | |
466 | { | |
467 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
468 | int i; | |
469 | ||
470 | ixgbevf_update_stats(adapter); | |
471 | for (i = 0; i < IXGBE_GLOBAL_STATS_LEN; i++) { | |
472 | char *p = (char *)adapter + | |
473 | ixgbe_gstrings_stats[i].stat_offset; | |
474 | char *b = (char *)adapter + | |
475 | ixgbe_gstrings_stats[i].base_stat_offset; | |
33bd9f60 GR |
476 | char *r = (char *)adapter + |
477 | ixgbe_gstrings_stats[i].saved_reset_offset; | |
92915f71 GR |
478 | data[i] = ((ixgbe_gstrings_stats[i].sizeof_stat == |
479 | sizeof(u64)) ? *(u64 *)p : *(u32 *)p) - | |
480 | ((ixgbe_gstrings_stats[i].sizeof_stat == | |
33bd9f60 GR |
481 | sizeof(u64)) ? *(u64 *)b : *(u32 *)b) + |
482 | ((ixgbe_gstrings_stats[i].sizeof_stat == | |
483 | sizeof(u64)) ? *(u64 *)r : *(u32 *)r); | |
92915f71 GR |
484 | } |
485 | } | |
486 | ||
487 | static void ixgbevf_get_strings(struct net_device *netdev, u32 stringset, | |
488 | u8 *data) | |
489 | { | |
490 | char *p = (char *)data; | |
491 | int i; | |
492 | ||
493 | switch (stringset) { | |
494 | case ETH_SS_TEST: | |
495 | memcpy(data, *ixgbe_gstrings_test, | |
496 | IXGBE_TEST_LEN * ETH_GSTRING_LEN); | |
497 | break; | |
498 | case ETH_SS_STATS: | |
499 | for (i = 0; i < IXGBE_GLOBAL_STATS_LEN; i++) { | |
500 | memcpy(p, ixgbe_gstrings_stats[i].stat_string, | |
501 | ETH_GSTRING_LEN); | |
502 | p += ETH_GSTRING_LEN; | |
503 | } | |
504 | break; | |
505 | } | |
506 | } | |
507 | ||
508 | static int ixgbevf_link_test(struct ixgbevf_adapter *adapter, u64 *data) | |
509 | { | |
510 | struct ixgbe_hw *hw = &adapter->hw; | |
511 | bool link_up; | |
512 | u32 link_speed = 0; | |
513 | *data = 0; | |
514 | ||
515 | hw->mac.ops.check_link(hw, &link_speed, &link_up, true); | |
516 | if (!link_up) | |
517 | *data = 1; | |
518 | ||
519 | return *data; | |
520 | } | |
521 | ||
522 | /* ethtool register test data */ | |
523 | struct ixgbevf_reg_test { | |
524 | u16 reg; | |
525 | u8 array_len; | |
526 | u8 test_type; | |
527 | u32 mask; | |
528 | u32 write; | |
529 | }; | |
530 | ||
531 | /* In the hardware, registers are laid out either singly, in arrays | |
532 | * spaced 0x40 bytes apart, or in contiguous tables. We assume | |
533 | * most tests take place on arrays or single registers (handled | |
534 | * as a single-element array) and special-case the tables. | |
535 | * Table tests are always pattern tests. | |
536 | * | |
537 | * We also make provision for some required setup steps by specifying | |
538 | * registers to be written without any read-back testing. | |
539 | */ | |
540 | ||
541 | #define PATTERN_TEST 1 | |
542 | #define SET_READ_TEST 2 | |
543 | #define WRITE_NO_TEST 3 | |
544 | #define TABLE32_TEST 4 | |
545 | #define TABLE64_TEST_LO 5 | |
546 | #define TABLE64_TEST_HI 6 | |
547 | ||
548 | /* default VF register test */ | |
66744500 | 549 | static const struct ixgbevf_reg_test reg_test_vf[] = { |
92915f71 GR |
550 | { IXGBE_VFRDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFF80 }, |
551 | { IXGBE_VFRDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF }, | |
552 | { IXGBE_VFRDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFFFF }, | |
553 | { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, IXGBE_RXDCTL_ENABLE }, | |
554 | { IXGBE_VFRDT(0), 2, PATTERN_TEST, 0x0000FFFF, 0x0000FFFF }, | |
555 | { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, 0 }, | |
556 | { IXGBE_VFTDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFFFF }, | |
557 | { IXGBE_VFTDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF }, | |
558 | { IXGBE_VFTDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFF80 }, | |
559 | { 0, 0, 0, 0 } | |
560 | }; | |
561 | ||
66744500 JK |
562 | static const u32 register_test_patterns[] = { |
563 | 0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF | |
564 | }; | |
565 | ||
92915f71 GR |
566 | #define REG_PATTERN_TEST(R, M, W) \ |
567 | { \ | |
568 | u32 pat, val, before; \ | |
66744500 | 569 | for (pat = 0; pat < ARRAY_SIZE(register_test_patterns); pat++) { \ |
92915f71 | 570 | before = readl(adapter->hw.hw_addr + R); \ |
66744500 JK |
571 | writel((register_test_patterns[pat] & W), \ |
572 | (adapter->hw.hw_addr + R)); \ | |
92915f71 | 573 | val = readl(adapter->hw.hw_addr + R); \ |
66744500 | 574 | if (val != (register_test_patterns[pat] & W & M)) { \ |
92915f71 GR |
575 | hw_dbg(&adapter->hw, \ |
576 | "pattern test reg %04X failed: got " \ | |
577 | "0x%08X expected 0x%08X\n", \ | |
66744500 | 578 | R, val, (register_test_patterns[pat] & W & M)); \ |
92915f71 GR |
579 | *data = R; \ |
580 | writel(before, adapter->hw.hw_addr + R); \ | |
581 | return 1; \ | |
582 | } \ | |
583 | writel(before, adapter->hw.hw_addr + R); \ | |
584 | } \ | |
585 | } | |
586 | ||
587 | #define REG_SET_AND_CHECK(R, M, W) \ | |
588 | { \ | |
589 | u32 val, before; \ | |
590 | before = readl(adapter->hw.hw_addr + R); \ | |
591 | writel((W & M), (adapter->hw.hw_addr + R)); \ | |
592 | val = readl(adapter->hw.hw_addr + R); \ | |
593 | if ((W & M) != (val & M)) { \ | |
594 | printk(KERN_ERR "set/check reg %04X test failed: got 0x%08X " \ | |
595 | "expected 0x%08X\n", R, (val & M), (W & M)); \ | |
596 | *data = R; \ | |
597 | writel(before, (adapter->hw.hw_addr + R)); \ | |
598 | return 1; \ | |
599 | } \ | |
600 | writel(before, (adapter->hw.hw_addr + R)); \ | |
601 | } | |
602 | ||
603 | static int ixgbevf_reg_test(struct ixgbevf_adapter *adapter, u64 *data) | |
604 | { | |
66744500 | 605 | const struct ixgbevf_reg_test *test; |
92915f71 GR |
606 | u32 i; |
607 | ||
608 | test = reg_test_vf; | |
609 | ||
610 | /* | |
611 | * Perform the register test, looping through the test table | |
612 | * until we either fail or reach the null entry. | |
613 | */ | |
614 | while (test->reg) { | |
615 | for (i = 0; i < test->array_len; i++) { | |
616 | switch (test->test_type) { | |
617 | case PATTERN_TEST: | |
618 | REG_PATTERN_TEST(test->reg + (i * 0x40), | |
619 | test->mask, | |
620 | test->write); | |
621 | break; | |
622 | case SET_READ_TEST: | |
623 | REG_SET_AND_CHECK(test->reg + (i * 0x40), | |
624 | test->mask, | |
625 | test->write); | |
626 | break; | |
627 | case WRITE_NO_TEST: | |
628 | writel(test->write, | |
629 | (adapter->hw.hw_addr + test->reg) | |
630 | + (i * 0x40)); | |
631 | break; | |
632 | case TABLE32_TEST: | |
633 | REG_PATTERN_TEST(test->reg + (i * 4), | |
634 | test->mask, | |
635 | test->write); | |
636 | break; | |
637 | case TABLE64_TEST_LO: | |
638 | REG_PATTERN_TEST(test->reg + (i * 8), | |
639 | test->mask, | |
640 | test->write); | |
641 | break; | |
642 | case TABLE64_TEST_HI: | |
643 | REG_PATTERN_TEST((test->reg + 4) + (i * 8), | |
644 | test->mask, | |
645 | test->write); | |
646 | break; | |
647 | } | |
648 | } | |
649 | test++; | |
650 | } | |
651 | ||
652 | *data = 0; | |
653 | return *data; | |
654 | } | |
655 | ||
656 | static void ixgbevf_diag_test(struct net_device *netdev, | |
657 | struct ethtool_test *eth_test, u64 *data) | |
658 | { | |
659 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
660 | bool if_running = netif_running(netdev); | |
661 | ||
662 | set_bit(__IXGBEVF_TESTING, &adapter->state); | |
663 | if (eth_test->flags == ETH_TEST_FL_OFFLINE) { | |
664 | /* Offline tests */ | |
665 | ||
666 | hw_dbg(&adapter->hw, "offline testing starting\n"); | |
667 | ||
668 | /* Link test performed before hardware reset so autoneg doesn't | |
669 | * interfere with test result */ | |
670 | if (ixgbevf_link_test(adapter, &data[1])) | |
671 | eth_test->flags |= ETH_TEST_FL_FAILED; | |
672 | ||
673 | if (if_running) | |
674 | /* indicate we're in test mode */ | |
675 | dev_close(netdev); | |
676 | else | |
677 | ixgbevf_reset(adapter); | |
678 | ||
679 | hw_dbg(&adapter->hw, "register testing starting\n"); | |
680 | if (ixgbevf_reg_test(adapter, &data[0])) | |
681 | eth_test->flags |= ETH_TEST_FL_FAILED; | |
682 | ||
683 | ixgbevf_reset(adapter); | |
684 | ||
685 | clear_bit(__IXGBEVF_TESTING, &adapter->state); | |
686 | if (if_running) | |
687 | dev_open(netdev); | |
688 | } else { | |
689 | hw_dbg(&adapter->hw, "online testing starting\n"); | |
690 | /* Online tests */ | |
691 | if (ixgbevf_link_test(adapter, &data[1])) | |
692 | eth_test->flags |= ETH_TEST_FL_FAILED; | |
693 | ||
694 | /* Online tests aren't run; pass by default */ | |
695 | data[0] = 0; | |
696 | ||
697 | clear_bit(__IXGBEVF_TESTING, &adapter->state); | |
698 | } | |
699 | msleep_interruptible(4 * 1000); | |
700 | } | |
701 | ||
702 | static int ixgbevf_nway_reset(struct net_device *netdev) | |
703 | { | |
704 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
705 | ||
706 | if (netif_running(netdev)) { | |
707 | if (!adapter->dev_closed) | |
708 | ixgbevf_reinit_locked(adapter); | |
709 | } | |
710 | ||
711 | return 0; | |
712 | } | |
713 | ||
714 | static struct ethtool_ops ixgbevf_ethtool_ops = { | |
715 | .get_settings = ixgbevf_get_settings, | |
716 | .get_drvinfo = ixgbevf_get_drvinfo, | |
717 | .get_regs_len = ixgbevf_get_regs_len, | |
718 | .get_regs = ixgbevf_get_regs, | |
719 | .nway_reset = ixgbevf_nway_reset, | |
720 | .get_link = ethtool_op_get_link, | |
721 | .get_ringparam = ixgbevf_get_ringparam, | |
722 | .set_ringparam = ixgbevf_set_ringparam, | |
723 | .get_rx_csum = ixgbevf_get_rx_csum, | |
724 | .set_rx_csum = ixgbevf_set_rx_csum, | |
725 | .get_tx_csum = ethtool_op_get_tx_csum, | |
726 | .set_tx_csum = ethtool_op_set_tx_ipv6_csum, | |
727 | .get_sg = ethtool_op_get_sg, | |
728 | .set_sg = ethtool_op_set_sg, | |
729 | .get_msglevel = ixgbevf_get_msglevel, | |
730 | .set_msglevel = ixgbevf_set_msglevel, | |
731 | .get_tso = ethtool_op_get_tso, | |
732 | .set_tso = ixgbevf_set_tso, | |
733 | .self_test = ixgbevf_diag_test, | |
734 | .get_sset_count = ixgbevf_get_sset_count, | |
735 | .get_strings = ixgbevf_get_strings, | |
736 | .get_ethtool_stats = ixgbevf_get_ethtool_stats, | |
737 | }; | |
738 | ||
739 | void ixgbevf_set_ethtool_ops(struct net_device *netdev) | |
740 | { | |
741 | SET_ETHTOOL_OPS(netdev, &ixgbevf_ethtool_ops); | |
742 | } |