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) { | |
107 | ecmd->speed = (link_speed == IXGBE_LINK_SPEED_10GB_FULL) ? | |
108 | SPEED_10000 : SPEED_1000; | |
109 | ecmd->duplex = DUPLEX_FULL; | |
110 | } else { | |
111 | ecmd->speed = -1; | |
112 | ecmd->duplex = -1; | |
113 | } | |
114 | ||
115 | return 0; | |
116 | } | |
117 | ||
118 | static u32 ixgbevf_get_rx_csum(struct net_device *netdev) | |
119 | { | |
120 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
121 | return adapter->flags & IXGBE_FLAG_RX_CSUM_ENABLED; | |
122 | } | |
123 | ||
124 | static int ixgbevf_set_rx_csum(struct net_device *netdev, u32 data) | |
125 | { | |
126 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
127 | if (data) | |
128 | adapter->flags |= IXGBE_FLAG_RX_CSUM_ENABLED; | |
129 | else | |
130 | adapter->flags &= ~IXGBE_FLAG_RX_CSUM_ENABLED; | |
131 | ||
132 | if (netif_running(netdev)) { | |
133 | if (!adapter->dev_closed) | |
134 | ixgbevf_reinit_locked(adapter); | |
135 | } else { | |
136 | ixgbevf_reset(adapter); | |
137 | } | |
138 | ||
139 | return 0; | |
140 | } | |
141 | ||
142 | static int ixgbevf_set_tso(struct net_device *netdev, u32 data) | |
143 | { | |
144 | if (data) { | |
145 | netdev->features |= NETIF_F_TSO; | |
146 | netdev->features |= NETIF_F_TSO6; | |
147 | } else { | |
148 | netif_tx_stop_all_queues(netdev); | |
149 | netdev->features &= ~NETIF_F_TSO; | |
150 | netdev->features &= ~NETIF_F_TSO6; | |
151 | netif_tx_start_all_queues(netdev); | |
152 | } | |
153 | return 0; | |
154 | } | |
155 | ||
156 | static u32 ixgbevf_get_msglevel(struct net_device *netdev) | |
157 | { | |
158 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
159 | return adapter->msg_enable; | |
160 | } | |
161 | ||
162 | static void ixgbevf_set_msglevel(struct net_device *netdev, u32 data) | |
163 | { | |
164 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
165 | adapter->msg_enable = data; | |
166 | } | |
167 | ||
168 | #define IXGBE_GET_STAT(_A_, _R_) (_A_->stats._R_) | |
169 | ||
170 | static char *ixgbevf_reg_names[] = { | |
171 | "IXGBE_VFCTRL", | |
172 | "IXGBE_VFSTATUS", | |
173 | "IXGBE_VFLINKS", | |
174 | "IXGBE_VFRXMEMWRAP", | |
175 | "IXGBE_VFRTIMER", | |
176 | "IXGBE_VTEICR", | |
177 | "IXGBE_VTEICS", | |
178 | "IXGBE_VTEIMS", | |
179 | "IXGBE_VTEIMC", | |
180 | "IXGBE_VTEIAC", | |
181 | "IXGBE_VTEIAM", | |
182 | "IXGBE_VTEITR", | |
183 | "IXGBE_VTIVAR", | |
184 | "IXGBE_VTIVAR_MISC", | |
185 | "IXGBE_VFRDBAL0", | |
186 | "IXGBE_VFRDBAL1", | |
187 | "IXGBE_VFRDBAH0", | |
188 | "IXGBE_VFRDBAH1", | |
189 | "IXGBE_VFRDLEN0", | |
190 | "IXGBE_VFRDLEN1", | |
191 | "IXGBE_VFRDH0", | |
192 | "IXGBE_VFRDH1", | |
193 | "IXGBE_VFRDT0", | |
194 | "IXGBE_VFRDT1", | |
195 | "IXGBE_VFRXDCTL0", | |
196 | "IXGBE_VFRXDCTL1", | |
197 | "IXGBE_VFSRRCTL0", | |
198 | "IXGBE_VFSRRCTL1", | |
199 | "IXGBE_VFPSRTYPE", | |
200 | "IXGBE_VFTDBAL0", | |
201 | "IXGBE_VFTDBAL1", | |
202 | "IXGBE_VFTDBAH0", | |
203 | "IXGBE_VFTDBAH1", | |
204 | "IXGBE_VFTDLEN0", | |
205 | "IXGBE_VFTDLEN1", | |
206 | "IXGBE_VFTDH0", | |
207 | "IXGBE_VFTDH1", | |
208 | "IXGBE_VFTDT0", | |
209 | "IXGBE_VFTDT1", | |
210 | "IXGBE_VFTXDCTL0", | |
211 | "IXGBE_VFTXDCTL1", | |
212 | "IXGBE_VFTDWBAL0", | |
213 | "IXGBE_VFTDWBAL1", | |
214 | "IXGBE_VFTDWBAH0", | |
215 | "IXGBE_VFTDWBAH1" | |
216 | }; | |
217 | ||
218 | ||
219 | static int ixgbevf_get_regs_len(struct net_device *netdev) | |
220 | { | |
221 | return (ARRAY_SIZE(ixgbevf_reg_names)) * sizeof(u32); | |
222 | } | |
223 | ||
224 | static void ixgbevf_get_regs(struct net_device *netdev, | |
225 | struct ethtool_regs *regs, | |
226 | void *p) | |
227 | { | |
228 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
229 | struct ixgbe_hw *hw = &adapter->hw; | |
230 | u32 *regs_buff = p; | |
231 | u32 regs_len = ixgbevf_get_regs_len(netdev); | |
232 | u8 i; | |
233 | ||
234 | memset(p, 0, regs_len); | |
235 | ||
236 | regs->version = (1 << 24) | hw->revision_id << 16 | hw->device_id; | |
237 | ||
238 | /* General Registers */ | |
239 | regs_buff[0] = IXGBE_READ_REG(hw, IXGBE_VFCTRL); | |
240 | regs_buff[1] = IXGBE_READ_REG(hw, IXGBE_VFSTATUS); | |
241 | regs_buff[2] = IXGBE_READ_REG(hw, IXGBE_VFLINKS); | |
242 | regs_buff[3] = IXGBE_READ_REG(hw, IXGBE_VFRXMEMWRAP); | |
243 | regs_buff[4] = IXGBE_READ_REG(hw, IXGBE_VFRTIMER); | |
244 | ||
245 | /* Interrupt */ | |
246 | /* don't read EICR because it can clear interrupt causes, instead | |
247 | * read EICS which is a shadow but doesn't clear EICR */ | |
248 | regs_buff[5] = IXGBE_READ_REG(hw, IXGBE_VTEICS); | |
249 | regs_buff[6] = IXGBE_READ_REG(hw, IXGBE_VTEICS); | |
250 | regs_buff[7] = IXGBE_READ_REG(hw, IXGBE_VTEIMS); | |
251 | regs_buff[8] = IXGBE_READ_REG(hw, IXGBE_VTEIMC); | |
252 | regs_buff[9] = IXGBE_READ_REG(hw, IXGBE_VTEIAC); | |
253 | regs_buff[10] = IXGBE_READ_REG(hw, IXGBE_VTEIAM); | |
254 | regs_buff[11] = IXGBE_READ_REG(hw, IXGBE_VTEITR(0)); | |
255 | regs_buff[12] = IXGBE_READ_REG(hw, IXGBE_VTIVAR(0)); | |
256 | regs_buff[13] = IXGBE_READ_REG(hw, IXGBE_VTIVAR_MISC); | |
257 | ||
258 | /* Receive DMA */ | |
259 | for (i = 0; i < 2; i++) | |
260 | regs_buff[14 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAL(i)); | |
261 | for (i = 0; i < 2; i++) | |
262 | regs_buff[16 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDBAH(i)); | |
263 | for (i = 0; i < 2; i++) | |
264 | regs_buff[18 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDLEN(i)); | |
265 | for (i = 0; i < 2; i++) | |
266 | regs_buff[20 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDH(i)); | |
267 | for (i = 0; i < 2; i++) | |
268 | regs_buff[22 + i] = IXGBE_READ_REG(hw, IXGBE_VFRDT(i)); | |
269 | for (i = 0; i < 2; i++) | |
270 | regs_buff[24 + i] = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i)); | |
271 | for (i = 0; i < 2; i++) | |
272 | regs_buff[26 + i] = IXGBE_READ_REG(hw, IXGBE_VFSRRCTL(i)); | |
273 | ||
274 | /* Receive */ | |
275 | regs_buff[28] = IXGBE_READ_REG(hw, IXGBE_VFPSRTYPE); | |
276 | ||
277 | /* Transmit */ | |
278 | for (i = 0; i < 2; i++) | |
279 | regs_buff[29 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAL(i)); | |
280 | for (i = 0; i < 2; i++) | |
281 | regs_buff[31 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDBAH(i)); | |
282 | for (i = 0; i < 2; i++) | |
283 | regs_buff[33 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDLEN(i)); | |
284 | for (i = 0; i < 2; i++) | |
285 | regs_buff[35 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDH(i)); | |
286 | for (i = 0; i < 2; i++) | |
287 | regs_buff[37 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDT(i)); | |
288 | for (i = 0; i < 2; i++) | |
289 | regs_buff[39 + i] = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i)); | |
290 | for (i = 0; i < 2; i++) | |
291 | regs_buff[41 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAL(i)); | |
292 | for (i = 0; i < 2; i++) | |
293 | regs_buff[43 + i] = IXGBE_READ_REG(hw, IXGBE_VFTDWBAH(i)); | |
294 | ||
295 | for (i = 0; i < ARRAY_SIZE(ixgbevf_reg_names); i++) | |
296 | hw_dbg(hw, "%s\t%8.8x\n", ixgbevf_reg_names[i], regs_buff[i]); | |
297 | } | |
298 | ||
299 | static void ixgbevf_get_drvinfo(struct net_device *netdev, | |
300 | struct ethtool_drvinfo *drvinfo) | |
301 | { | |
302 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
303 | ||
304 | strlcpy(drvinfo->driver, ixgbevf_driver_name, 32); | |
305 | strlcpy(drvinfo->version, ixgbevf_driver_version, 32); | |
306 | ||
307 | strlcpy(drvinfo->fw_version, "N/A", 4); | |
308 | strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 32); | |
309 | } | |
310 | ||
311 | static void ixgbevf_get_ringparam(struct net_device *netdev, | |
312 | struct ethtool_ringparam *ring) | |
313 | { | |
314 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
315 | struct ixgbevf_ring *tx_ring = adapter->tx_ring; | |
316 | struct ixgbevf_ring *rx_ring = adapter->rx_ring; | |
317 | ||
318 | ring->rx_max_pending = IXGBEVF_MAX_RXD; | |
319 | ring->tx_max_pending = IXGBEVF_MAX_TXD; | |
320 | ring->rx_mini_max_pending = 0; | |
321 | ring->rx_jumbo_max_pending = 0; | |
322 | ring->rx_pending = rx_ring->count; | |
323 | ring->tx_pending = tx_ring->count; | |
324 | ring->rx_mini_pending = 0; | |
325 | ring->rx_jumbo_pending = 0; | |
326 | } | |
327 | ||
328 | static int ixgbevf_set_ringparam(struct net_device *netdev, | |
329 | struct ethtool_ringparam *ring) | |
330 | { | |
331 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
332 | struct ixgbevf_ring *tx_ring = NULL, *rx_ring = NULL; | |
333 | int i, err; | |
334 | u32 new_rx_count, new_tx_count; | |
335 | bool need_tx_update = false; | |
336 | bool need_rx_update = false; | |
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 | ||
358 | if (new_tx_count != adapter->tx_ring_count) { | |
359 | tx_ring = kcalloc(adapter->num_tx_queues, | |
360 | sizeof(struct ixgbevf_ring), GFP_KERNEL); | |
361 | if (!tx_ring) { | |
362 | err = -ENOMEM; | |
363 | goto err_setup; | |
364 | } | |
365 | memcpy(tx_ring, adapter->tx_ring, | |
366 | adapter->num_tx_queues * sizeof(struct ixgbevf_ring)); | |
367 | for (i = 0; i < adapter->num_tx_queues; i++) { | |
368 | tx_ring[i].count = new_tx_count; | |
369 | err = ixgbevf_setup_tx_resources(adapter, | |
370 | &tx_ring[i]); | |
371 | if (err) { | |
372 | while (i) { | |
373 | i--; | |
374 | ixgbevf_free_tx_resources(adapter, | |
375 | &tx_ring[i]); | |
376 | } | |
377 | kfree(tx_ring); | |
378 | goto err_setup; | |
379 | } | |
380 | tx_ring[i].v_idx = adapter->tx_ring[i].v_idx; | |
381 | } | |
382 | need_tx_update = true; | |
383 | } | |
384 | ||
385 | if (new_rx_count != adapter->rx_ring_count) { | |
386 | rx_ring = kcalloc(adapter->num_rx_queues, | |
387 | sizeof(struct ixgbevf_ring), GFP_KERNEL); | |
388 | if ((!rx_ring) && (need_tx_update)) { | |
389 | err = -ENOMEM; | |
390 | goto err_rx_setup; | |
391 | } | |
392 | memcpy(rx_ring, adapter->rx_ring, | |
393 | adapter->num_rx_queues * sizeof(struct ixgbevf_ring)); | |
394 | for (i = 0; i < adapter->num_rx_queues; i++) { | |
395 | rx_ring[i].count = new_rx_count; | |
396 | err = ixgbevf_setup_rx_resources(adapter, | |
397 | &rx_ring[i]); | |
398 | if (err) { | |
399 | while (i) { | |
400 | i--; | |
401 | ixgbevf_free_rx_resources(adapter, | |
402 | &rx_ring[i]); | |
403 | } | |
404 | kfree(rx_ring); | |
405 | goto err_rx_setup; | |
406 | } | |
407 | rx_ring[i].v_idx = adapter->rx_ring[i].v_idx; | |
408 | } | |
409 | need_rx_update = true; | |
410 | } | |
411 | ||
412 | err_rx_setup: | |
413 | /* if rings need to be updated, here's the place to do it in one shot */ | |
414 | if (need_tx_update || need_rx_update) { | |
415 | if (netif_running(netdev)) | |
416 | ixgbevf_down(adapter); | |
417 | } | |
418 | ||
419 | /* tx */ | |
420 | if (need_tx_update) { | |
421 | kfree(adapter->tx_ring); | |
422 | adapter->tx_ring = tx_ring; | |
423 | tx_ring = NULL; | |
424 | adapter->tx_ring_count = new_tx_count; | |
425 | } | |
426 | ||
427 | /* rx */ | |
428 | if (need_rx_update) { | |
429 | kfree(adapter->rx_ring); | |
430 | adapter->rx_ring = rx_ring; | |
431 | rx_ring = NULL; | |
432 | adapter->rx_ring_count = new_rx_count; | |
433 | } | |
434 | ||
435 | /* success! */ | |
436 | err = 0; | |
437 | if (netif_running(netdev)) | |
438 | ixgbevf_up(adapter); | |
439 | ||
440 | err_setup: | |
441 | clear_bit(__IXGBEVF_RESETTING, &adapter->state); | |
442 | return err; | |
443 | } | |
444 | ||
445 | static int ixgbevf_get_sset_count(struct net_device *dev, int stringset) | |
446 | { | |
447 | switch (stringset) { | |
448 | case ETH_SS_TEST: | |
449 | return IXGBE_TEST_LEN; | |
450 | case ETH_SS_STATS: | |
451 | return IXGBE_GLOBAL_STATS_LEN; | |
452 | default: | |
453 | return -EINVAL; | |
454 | } | |
455 | } | |
456 | ||
457 | static void ixgbevf_get_ethtool_stats(struct net_device *netdev, | |
458 | struct ethtool_stats *stats, u64 *data) | |
459 | { | |
460 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
461 | int i; | |
462 | ||
463 | ixgbevf_update_stats(adapter); | |
464 | for (i = 0; i < IXGBE_GLOBAL_STATS_LEN; i++) { | |
465 | char *p = (char *)adapter + | |
466 | ixgbe_gstrings_stats[i].stat_offset; | |
467 | char *b = (char *)adapter + | |
468 | ixgbe_gstrings_stats[i].base_stat_offset; | |
33bd9f60 GR |
469 | char *r = (char *)adapter + |
470 | ixgbe_gstrings_stats[i].saved_reset_offset; | |
92915f71 GR |
471 | data[i] = ((ixgbe_gstrings_stats[i].sizeof_stat == |
472 | sizeof(u64)) ? *(u64 *)p : *(u32 *)p) - | |
473 | ((ixgbe_gstrings_stats[i].sizeof_stat == | |
33bd9f60 GR |
474 | sizeof(u64)) ? *(u64 *)b : *(u32 *)b) + |
475 | ((ixgbe_gstrings_stats[i].sizeof_stat == | |
476 | sizeof(u64)) ? *(u64 *)r : *(u32 *)r); | |
92915f71 GR |
477 | } |
478 | } | |
479 | ||
480 | static void ixgbevf_get_strings(struct net_device *netdev, u32 stringset, | |
481 | u8 *data) | |
482 | { | |
483 | char *p = (char *)data; | |
484 | int i; | |
485 | ||
486 | switch (stringset) { | |
487 | case ETH_SS_TEST: | |
488 | memcpy(data, *ixgbe_gstrings_test, | |
489 | IXGBE_TEST_LEN * ETH_GSTRING_LEN); | |
490 | break; | |
491 | case ETH_SS_STATS: | |
492 | for (i = 0; i < IXGBE_GLOBAL_STATS_LEN; i++) { | |
493 | memcpy(p, ixgbe_gstrings_stats[i].stat_string, | |
494 | ETH_GSTRING_LEN); | |
495 | p += ETH_GSTRING_LEN; | |
496 | } | |
497 | break; | |
498 | } | |
499 | } | |
500 | ||
501 | static int ixgbevf_link_test(struct ixgbevf_adapter *adapter, u64 *data) | |
502 | { | |
503 | struct ixgbe_hw *hw = &adapter->hw; | |
504 | bool link_up; | |
505 | u32 link_speed = 0; | |
506 | *data = 0; | |
507 | ||
508 | hw->mac.ops.check_link(hw, &link_speed, &link_up, true); | |
509 | if (!link_up) | |
510 | *data = 1; | |
511 | ||
512 | return *data; | |
513 | } | |
514 | ||
515 | /* ethtool register test data */ | |
516 | struct ixgbevf_reg_test { | |
517 | u16 reg; | |
518 | u8 array_len; | |
519 | u8 test_type; | |
520 | u32 mask; | |
521 | u32 write; | |
522 | }; | |
523 | ||
524 | /* In the hardware, registers are laid out either singly, in arrays | |
525 | * spaced 0x40 bytes apart, or in contiguous tables. We assume | |
526 | * most tests take place on arrays or single registers (handled | |
527 | * as a single-element array) and special-case the tables. | |
528 | * Table tests are always pattern tests. | |
529 | * | |
530 | * We also make provision for some required setup steps by specifying | |
531 | * registers to be written without any read-back testing. | |
532 | */ | |
533 | ||
534 | #define PATTERN_TEST 1 | |
535 | #define SET_READ_TEST 2 | |
536 | #define WRITE_NO_TEST 3 | |
537 | #define TABLE32_TEST 4 | |
538 | #define TABLE64_TEST_LO 5 | |
539 | #define TABLE64_TEST_HI 6 | |
540 | ||
541 | /* default VF register test */ | |
542 | static struct ixgbevf_reg_test reg_test_vf[] = { | |
543 | { IXGBE_VFRDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFF80 }, | |
544 | { IXGBE_VFRDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF }, | |
545 | { IXGBE_VFRDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFFFF }, | |
546 | { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, IXGBE_RXDCTL_ENABLE }, | |
547 | { IXGBE_VFRDT(0), 2, PATTERN_TEST, 0x0000FFFF, 0x0000FFFF }, | |
548 | { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, 0 }, | |
549 | { IXGBE_VFTDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFFFF }, | |
550 | { IXGBE_VFTDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF }, | |
551 | { IXGBE_VFTDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFF80 }, | |
552 | { 0, 0, 0, 0 } | |
553 | }; | |
554 | ||
555 | #define REG_PATTERN_TEST(R, M, W) \ | |
556 | { \ | |
557 | u32 pat, val, before; \ | |
558 | const u32 _test[] = {0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF}; \ | |
559 | for (pat = 0; pat < ARRAY_SIZE(_test); pat++) { \ | |
560 | before = readl(adapter->hw.hw_addr + R); \ | |
561 | writel((_test[pat] & W), (adapter->hw.hw_addr + R)); \ | |
562 | val = readl(adapter->hw.hw_addr + R); \ | |
563 | if (val != (_test[pat] & W & M)) { \ | |
564 | hw_dbg(&adapter->hw, \ | |
565 | "pattern test reg %04X failed: got " \ | |
566 | "0x%08X expected 0x%08X\n", \ | |
567 | R, val, (_test[pat] & W & M)); \ | |
568 | *data = R; \ | |
569 | writel(before, adapter->hw.hw_addr + R); \ | |
570 | return 1; \ | |
571 | } \ | |
572 | writel(before, adapter->hw.hw_addr + R); \ | |
573 | } \ | |
574 | } | |
575 | ||
576 | #define REG_SET_AND_CHECK(R, M, W) \ | |
577 | { \ | |
578 | u32 val, before; \ | |
579 | before = readl(adapter->hw.hw_addr + R); \ | |
580 | writel((W & M), (adapter->hw.hw_addr + R)); \ | |
581 | val = readl(adapter->hw.hw_addr + R); \ | |
582 | if ((W & M) != (val & M)) { \ | |
583 | printk(KERN_ERR "set/check reg %04X test failed: got 0x%08X " \ | |
584 | "expected 0x%08X\n", R, (val & M), (W & M)); \ | |
585 | *data = R; \ | |
586 | writel(before, (adapter->hw.hw_addr + R)); \ | |
587 | return 1; \ | |
588 | } \ | |
589 | writel(before, (adapter->hw.hw_addr + R)); \ | |
590 | } | |
591 | ||
592 | static int ixgbevf_reg_test(struct ixgbevf_adapter *adapter, u64 *data) | |
593 | { | |
594 | struct ixgbevf_reg_test *test; | |
595 | u32 i; | |
596 | ||
597 | test = reg_test_vf; | |
598 | ||
599 | /* | |
600 | * Perform the register test, looping through the test table | |
601 | * until we either fail or reach the null entry. | |
602 | */ | |
603 | while (test->reg) { | |
604 | for (i = 0; i < test->array_len; i++) { | |
605 | switch (test->test_type) { | |
606 | case PATTERN_TEST: | |
607 | REG_PATTERN_TEST(test->reg + (i * 0x40), | |
608 | test->mask, | |
609 | test->write); | |
610 | break; | |
611 | case SET_READ_TEST: | |
612 | REG_SET_AND_CHECK(test->reg + (i * 0x40), | |
613 | test->mask, | |
614 | test->write); | |
615 | break; | |
616 | case WRITE_NO_TEST: | |
617 | writel(test->write, | |
618 | (adapter->hw.hw_addr + test->reg) | |
619 | + (i * 0x40)); | |
620 | break; | |
621 | case TABLE32_TEST: | |
622 | REG_PATTERN_TEST(test->reg + (i * 4), | |
623 | test->mask, | |
624 | test->write); | |
625 | break; | |
626 | case TABLE64_TEST_LO: | |
627 | REG_PATTERN_TEST(test->reg + (i * 8), | |
628 | test->mask, | |
629 | test->write); | |
630 | break; | |
631 | case TABLE64_TEST_HI: | |
632 | REG_PATTERN_TEST((test->reg + 4) + (i * 8), | |
633 | test->mask, | |
634 | test->write); | |
635 | break; | |
636 | } | |
637 | } | |
638 | test++; | |
639 | } | |
640 | ||
641 | *data = 0; | |
642 | return *data; | |
643 | } | |
644 | ||
645 | static void ixgbevf_diag_test(struct net_device *netdev, | |
646 | struct ethtool_test *eth_test, u64 *data) | |
647 | { | |
648 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
649 | bool if_running = netif_running(netdev); | |
650 | ||
651 | set_bit(__IXGBEVF_TESTING, &adapter->state); | |
652 | if (eth_test->flags == ETH_TEST_FL_OFFLINE) { | |
653 | /* Offline tests */ | |
654 | ||
655 | hw_dbg(&adapter->hw, "offline testing starting\n"); | |
656 | ||
657 | /* Link test performed before hardware reset so autoneg doesn't | |
658 | * interfere with test result */ | |
659 | if (ixgbevf_link_test(adapter, &data[1])) | |
660 | eth_test->flags |= ETH_TEST_FL_FAILED; | |
661 | ||
662 | if (if_running) | |
663 | /* indicate we're in test mode */ | |
664 | dev_close(netdev); | |
665 | else | |
666 | ixgbevf_reset(adapter); | |
667 | ||
668 | hw_dbg(&adapter->hw, "register testing starting\n"); | |
669 | if (ixgbevf_reg_test(adapter, &data[0])) | |
670 | eth_test->flags |= ETH_TEST_FL_FAILED; | |
671 | ||
672 | ixgbevf_reset(adapter); | |
673 | ||
674 | clear_bit(__IXGBEVF_TESTING, &adapter->state); | |
675 | if (if_running) | |
676 | dev_open(netdev); | |
677 | } else { | |
678 | hw_dbg(&adapter->hw, "online testing starting\n"); | |
679 | /* Online tests */ | |
680 | if (ixgbevf_link_test(adapter, &data[1])) | |
681 | eth_test->flags |= ETH_TEST_FL_FAILED; | |
682 | ||
683 | /* Online tests aren't run; pass by default */ | |
684 | data[0] = 0; | |
685 | ||
686 | clear_bit(__IXGBEVF_TESTING, &adapter->state); | |
687 | } | |
688 | msleep_interruptible(4 * 1000); | |
689 | } | |
690 | ||
691 | static int ixgbevf_nway_reset(struct net_device *netdev) | |
692 | { | |
693 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
694 | ||
695 | if (netif_running(netdev)) { | |
696 | if (!adapter->dev_closed) | |
697 | ixgbevf_reinit_locked(adapter); | |
698 | } | |
699 | ||
700 | return 0; | |
701 | } | |
702 | ||
703 | static struct ethtool_ops ixgbevf_ethtool_ops = { | |
704 | .get_settings = ixgbevf_get_settings, | |
705 | .get_drvinfo = ixgbevf_get_drvinfo, | |
706 | .get_regs_len = ixgbevf_get_regs_len, | |
707 | .get_regs = ixgbevf_get_regs, | |
708 | .nway_reset = ixgbevf_nway_reset, | |
709 | .get_link = ethtool_op_get_link, | |
710 | .get_ringparam = ixgbevf_get_ringparam, | |
711 | .set_ringparam = ixgbevf_set_ringparam, | |
712 | .get_rx_csum = ixgbevf_get_rx_csum, | |
713 | .set_rx_csum = ixgbevf_set_rx_csum, | |
714 | .get_tx_csum = ethtool_op_get_tx_csum, | |
715 | .set_tx_csum = ethtool_op_set_tx_ipv6_csum, | |
716 | .get_sg = ethtool_op_get_sg, | |
717 | .set_sg = ethtool_op_set_sg, | |
718 | .get_msglevel = ixgbevf_get_msglevel, | |
719 | .set_msglevel = ixgbevf_set_msglevel, | |
720 | .get_tso = ethtool_op_get_tso, | |
721 | .set_tso = ixgbevf_set_tso, | |
722 | .self_test = ixgbevf_diag_test, | |
723 | .get_sset_count = ixgbevf_get_sset_count, | |
724 | .get_strings = ixgbevf_get_strings, | |
725 | .get_ethtool_stats = ixgbevf_get_ethtool_stats, | |
726 | }; | |
727 | ||
728 | void ixgbevf_set_ethtool_ops(struct net_device *netdev) | |
729 | { | |
730 | SET_ETHTOOL_OPS(netdev, &ixgbevf_ethtool_ops); | |
731 | } |