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", | |
6fb456a0 | 175 | "IXGBE_VFFRTIMER", |
92915f71 GR |
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); | |
6fb456a0 | 243 | regs_buff[4] = IXGBE_READ_REG(hw, IXGBE_VFFRTIMER); |
92915f71 GR |
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; | |
bba50b99 | 333 | int i, err = 0; |
92915f71 | 334 | u32 new_rx_count, new_tx_count; |
92915f71 GR |
335 | |
336 | if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending)) | |
337 | return -EINVAL; | |
338 | ||
339 | new_rx_count = max(ring->rx_pending, (u32)IXGBEVF_MIN_RXD); | |
340 | new_rx_count = min(new_rx_count, (u32)IXGBEVF_MAX_RXD); | |
341 | new_rx_count = ALIGN(new_rx_count, IXGBE_REQ_RX_DESCRIPTOR_MULTIPLE); | |
342 | ||
343 | new_tx_count = max(ring->tx_pending, (u32)IXGBEVF_MIN_TXD); | |
344 | new_tx_count = min(new_tx_count, (u32)IXGBEVF_MAX_TXD); | |
345 | new_tx_count = ALIGN(new_tx_count, IXGBE_REQ_TX_DESCRIPTOR_MULTIPLE); | |
346 | ||
347 | if ((new_tx_count == adapter->tx_ring->count) && | |
348 | (new_rx_count == adapter->rx_ring->count)) { | |
349 | /* nothing to do */ | |
350 | return 0; | |
351 | } | |
352 | ||
353 | while (test_and_set_bit(__IXGBEVF_RESETTING, &adapter->state)) | |
354 | msleep(1); | |
355 | ||
bba50b99 GR |
356 | /* |
357 | * If the adapter isn't up and running then just set the | |
358 | * new parameters and scurry for the exits. | |
359 | */ | |
360 | if (!netif_running(adapter->netdev)) { | |
361 | for (i = 0; i < adapter->num_tx_queues; i++) | |
362 | adapter->tx_ring[i].count = new_tx_count; | |
363 | for (i = 0; i < adapter->num_rx_queues; i++) | |
364 | adapter->rx_ring[i].count = new_rx_count; | |
365 | adapter->tx_ring_count = new_tx_count; | |
366 | adapter->rx_ring_count = new_rx_count; | |
367 | goto clear_reset; | |
92915f71 GR |
368 | } |
369 | ||
bba50b99 GR |
370 | tx_ring = kcalloc(adapter->num_tx_queues, |
371 | sizeof(struct ixgbevf_ring), GFP_KERNEL); | |
372 | if (!tx_ring) { | |
373 | err = -ENOMEM; | |
374 | goto clear_reset; | |
92915f71 GR |
375 | } |
376 | ||
bba50b99 GR |
377 | rx_ring = kcalloc(adapter->num_rx_queues, |
378 | sizeof(struct ixgbevf_ring), GFP_KERNEL); | |
379 | if (!rx_ring) { | |
380 | err = -ENOMEM; | |
381 | goto err_rx_setup; | |
92915f71 GR |
382 | } |
383 | ||
bba50b99 GR |
384 | ixgbevf_down(adapter); |
385 | ||
386 | memcpy(tx_ring, adapter->tx_ring, | |
387 | adapter->num_tx_queues * sizeof(struct ixgbevf_ring)); | |
388 | for (i = 0; i < adapter->num_tx_queues; i++) { | |
389 | tx_ring[i].count = new_tx_count; | |
390 | err = ixgbevf_setup_tx_resources(adapter, &tx_ring[i]); | |
391 | if (err) { | |
392 | while (i) { | |
393 | i--; | |
394 | ixgbevf_free_tx_resources(adapter, | |
395 | &tx_ring[i]); | |
396 | } | |
397 | goto err_tx_ring_setup; | |
398 | } | |
399 | tx_ring[i].v_idx = adapter->tx_ring[i].v_idx; | |
92915f71 GR |
400 | } |
401 | ||
bba50b99 GR |
402 | memcpy(rx_ring, adapter->rx_ring, |
403 | adapter->num_rx_queues * sizeof(struct ixgbevf_ring)); | |
404 | for (i = 0; i < adapter->num_rx_queues; i++) { | |
405 | rx_ring[i].count = new_rx_count; | |
406 | err = ixgbevf_setup_rx_resources(adapter, &rx_ring[i]); | |
407 | if (err) { | |
408 | while (i) { | |
409 | i--; | |
410 | ixgbevf_free_rx_resources(adapter, | |
411 | &rx_ring[i]); | |
412 | } | |
413 | goto err_rx_ring_setup; | |
414 | } | |
415 | rx_ring[i].v_idx = adapter->rx_ring[i].v_idx; | |
92915f71 GR |
416 | } |
417 | ||
bba50b99 GR |
418 | /* |
419 | * Only switch to new rings if all the prior allocations | |
420 | * and ring setups have succeeded. | |
421 | */ | |
422 | kfree(adapter->tx_ring); | |
423 | adapter->tx_ring = tx_ring; | |
424 | adapter->tx_ring_count = new_tx_count; | |
425 | ||
426 | kfree(adapter->rx_ring); | |
427 | adapter->rx_ring = rx_ring; | |
428 | adapter->rx_ring_count = new_rx_count; | |
429 | ||
92915f71 | 430 | /* success! */ |
bba50b99 GR |
431 | ixgbevf_up(adapter); |
432 | ||
433 | goto clear_reset; | |
434 | ||
435 | err_rx_ring_setup: | |
436 | for(i = 0; i < adapter->num_tx_queues; i++) | |
437 | ixgbevf_free_tx_resources(adapter, &tx_ring[i]); | |
438 | ||
439 | err_tx_ring_setup: | |
440 | kfree(rx_ring); | |
441 | ||
442 | err_rx_setup: | |
443 | kfree(tx_ring); | |
92915f71 | 444 | |
bba50b99 | 445 | clear_reset: |
92915f71 GR |
446 | clear_bit(__IXGBEVF_RESETTING, &adapter->state); |
447 | return err; | |
448 | } | |
449 | ||
450 | static int ixgbevf_get_sset_count(struct net_device *dev, int stringset) | |
451 | { | |
452 | switch (stringset) { | |
453 | case ETH_SS_TEST: | |
454 | return IXGBE_TEST_LEN; | |
455 | case ETH_SS_STATS: | |
456 | return IXGBE_GLOBAL_STATS_LEN; | |
457 | default: | |
458 | return -EINVAL; | |
459 | } | |
460 | } | |
461 | ||
462 | static void ixgbevf_get_ethtool_stats(struct net_device *netdev, | |
463 | struct ethtool_stats *stats, u64 *data) | |
464 | { | |
465 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
466 | int i; | |
467 | ||
468 | ixgbevf_update_stats(adapter); | |
469 | for (i = 0; i < IXGBE_GLOBAL_STATS_LEN; i++) { | |
470 | char *p = (char *)adapter + | |
471 | ixgbe_gstrings_stats[i].stat_offset; | |
472 | char *b = (char *)adapter + | |
473 | ixgbe_gstrings_stats[i].base_stat_offset; | |
33bd9f60 GR |
474 | char *r = (char *)adapter + |
475 | ixgbe_gstrings_stats[i].saved_reset_offset; | |
92915f71 GR |
476 | data[i] = ((ixgbe_gstrings_stats[i].sizeof_stat == |
477 | sizeof(u64)) ? *(u64 *)p : *(u32 *)p) - | |
478 | ((ixgbe_gstrings_stats[i].sizeof_stat == | |
33bd9f60 GR |
479 | sizeof(u64)) ? *(u64 *)b : *(u32 *)b) + |
480 | ((ixgbe_gstrings_stats[i].sizeof_stat == | |
481 | sizeof(u64)) ? *(u64 *)r : *(u32 *)r); | |
92915f71 GR |
482 | } |
483 | } | |
484 | ||
485 | static void ixgbevf_get_strings(struct net_device *netdev, u32 stringset, | |
486 | u8 *data) | |
487 | { | |
488 | char *p = (char *)data; | |
489 | int i; | |
490 | ||
491 | switch (stringset) { | |
492 | case ETH_SS_TEST: | |
493 | memcpy(data, *ixgbe_gstrings_test, | |
494 | IXGBE_TEST_LEN * ETH_GSTRING_LEN); | |
495 | break; | |
496 | case ETH_SS_STATS: | |
497 | for (i = 0; i < IXGBE_GLOBAL_STATS_LEN; i++) { | |
498 | memcpy(p, ixgbe_gstrings_stats[i].stat_string, | |
499 | ETH_GSTRING_LEN); | |
500 | p += ETH_GSTRING_LEN; | |
501 | } | |
502 | break; | |
503 | } | |
504 | } | |
505 | ||
506 | static int ixgbevf_link_test(struct ixgbevf_adapter *adapter, u64 *data) | |
507 | { | |
508 | struct ixgbe_hw *hw = &adapter->hw; | |
509 | bool link_up; | |
510 | u32 link_speed = 0; | |
511 | *data = 0; | |
512 | ||
513 | hw->mac.ops.check_link(hw, &link_speed, &link_up, true); | |
514 | if (!link_up) | |
515 | *data = 1; | |
516 | ||
517 | return *data; | |
518 | } | |
519 | ||
520 | /* ethtool register test data */ | |
521 | struct ixgbevf_reg_test { | |
522 | u16 reg; | |
523 | u8 array_len; | |
524 | u8 test_type; | |
525 | u32 mask; | |
526 | u32 write; | |
527 | }; | |
528 | ||
529 | /* In the hardware, registers are laid out either singly, in arrays | |
530 | * spaced 0x40 bytes apart, or in contiguous tables. We assume | |
531 | * most tests take place on arrays or single registers (handled | |
532 | * as a single-element array) and special-case the tables. | |
533 | * Table tests are always pattern tests. | |
534 | * | |
535 | * We also make provision for some required setup steps by specifying | |
536 | * registers to be written without any read-back testing. | |
537 | */ | |
538 | ||
539 | #define PATTERN_TEST 1 | |
540 | #define SET_READ_TEST 2 | |
541 | #define WRITE_NO_TEST 3 | |
542 | #define TABLE32_TEST 4 | |
543 | #define TABLE64_TEST_LO 5 | |
544 | #define TABLE64_TEST_HI 6 | |
545 | ||
546 | /* default VF register test */ | |
66744500 | 547 | static const struct ixgbevf_reg_test reg_test_vf[] = { |
92915f71 GR |
548 | { IXGBE_VFRDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFF80 }, |
549 | { IXGBE_VFRDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF }, | |
550 | { IXGBE_VFRDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFFFF }, | |
551 | { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, IXGBE_RXDCTL_ENABLE }, | |
552 | { IXGBE_VFRDT(0), 2, PATTERN_TEST, 0x0000FFFF, 0x0000FFFF }, | |
553 | { IXGBE_VFRXDCTL(0), 2, WRITE_NO_TEST, 0, 0 }, | |
554 | { IXGBE_VFTDBAL(0), 2, PATTERN_TEST, 0xFFFFFF80, 0xFFFFFFFF }, | |
555 | { IXGBE_VFTDBAH(0), 2, PATTERN_TEST, 0xFFFFFFFF, 0xFFFFFFFF }, | |
556 | { IXGBE_VFTDLEN(0), 2, PATTERN_TEST, 0x000FFF80, 0x000FFF80 }, | |
557 | { 0, 0, 0, 0 } | |
558 | }; | |
559 | ||
66744500 JK |
560 | static const u32 register_test_patterns[] = { |
561 | 0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF | |
562 | }; | |
563 | ||
92915f71 GR |
564 | #define REG_PATTERN_TEST(R, M, W) \ |
565 | { \ | |
566 | u32 pat, val, before; \ | |
66744500 | 567 | for (pat = 0; pat < ARRAY_SIZE(register_test_patterns); pat++) { \ |
92915f71 | 568 | before = readl(adapter->hw.hw_addr + R); \ |
66744500 JK |
569 | writel((register_test_patterns[pat] & W), \ |
570 | (adapter->hw.hw_addr + R)); \ | |
92915f71 | 571 | val = readl(adapter->hw.hw_addr + R); \ |
66744500 | 572 | if (val != (register_test_patterns[pat] & W & M)) { \ |
92915f71 GR |
573 | hw_dbg(&adapter->hw, \ |
574 | "pattern test reg %04X failed: got " \ | |
575 | "0x%08X expected 0x%08X\n", \ | |
66744500 | 576 | R, val, (register_test_patterns[pat] & W & M)); \ |
92915f71 GR |
577 | *data = R; \ |
578 | writel(before, adapter->hw.hw_addr + R); \ | |
579 | return 1; \ | |
580 | } \ | |
581 | writel(before, adapter->hw.hw_addr + R); \ | |
582 | } \ | |
583 | } | |
584 | ||
585 | #define REG_SET_AND_CHECK(R, M, W) \ | |
586 | { \ | |
587 | u32 val, before; \ | |
588 | before = readl(adapter->hw.hw_addr + R); \ | |
589 | writel((W & M), (adapter->hw.hw_addr + R)); \ | |
590 | val = readl(adapter->hw.hw_addr + R); \ | |
591 | if ((W & M) != (val & M)) { \ | |
592 | printk(KERN_ERR "set/check reg %04X test failed: got 0x%08X " \ | |
593 | "expected 0x%08X\n", R, (val & M), (W & M)); \ | |
594 | *data = R; \ | |
595 | writel(before, (adapter->hw.hw_addr + R)); \ | |
596 | return 1; \ | |
597 | } \ | |
598 | writel(before, (adapter->hw.hw_addr + R)); \ | |
599 | } | |
600 | ||
601 | static int ixgbevf_reg_test(struct ixgbevf_adapter *adapter, u64 *data) | |
602 | { | |
66744500 | 603 | const struct ixgbevf_reg_test *test; |
92915f71 GR |
604 | u32 i; |
605 | ||
606 | test = reg_test_vf; | |
607 | ||
608 | /* | |
609 | * Perform the register test, looping through the test table | |
610 | * until we either fail or reach the null entry. | |
611 | */ | |
612 | while (test->reg) { | |
613 | for (i = 0; i < test->array_len; i++) { | |
614 | switch (test->test_type) { | |
615 | case PATTERN_TEST: | |
616 | REG_PATTERN_TEST(test->reg + (i * 0x40), | |
617 | test->mask, | |
618 | test->write); | |
619 | break; | |
620 | case SET_READ_TEST: | |
621 | REG_SET_AND_CHECK(test->reg + (i * 0x40), | |
622 | test->mask, | |
623 | test->write); | |
624 | break; | |
625 | case WRITE_NO_TEST: | |
626 | writel(test->write, | |
627 | (adapter->hw.hw_addr + test->reg) | |
628 | + (i * 0x40)); | |
629 | break; | |
630 | case TABLE32_TEST: | |
631 | REG_PATTERN_TEST(test->reg + (i * 4), | |
632 | test->mask, | |
633 | test->write); | |
634 | break; | |
635 | case TABLE64_TEST_LO: | |
636 | REG_PATTERN_TEST(test->reg + (i * 8), | |
637 | test->mask, | |
638 | test->write); | |
639 | break; | |
640 | case TABLE64_TEST_HI: | |
641 | REG_PATTERN_TEST((test->reg + 4) + (i * 8), | |
642 | test->mask, | |
643 | test->write); | |
644 | break; | |
645 | } | |
646 | } | |
647 | test++; | |
648 | } | |
649 | ||
650 | *data = 0; | |
651 | return *data; | |
652 | } | |
653 | ||
654 | static void ixgbevf_diag_test(struct net_device *netdev, | |
655 | struct ethtool_test *eth_test, u64 *data) | |
656 | { | |
657 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
658 | bool if_running = netif_running(netdev); | |
659 | ||
660 | set_bit(__IXGBEVF_TESTING, &adapter->state); | |
661 | if (eth_test->flags == ETH_TEST_FL_OFFLINE) { | |
662 | /* Offline tests */ | |
663 | ||
664 | hw_dbg(&adapter->hw, "offline testing starting\n"); | |
665 | ||
666 | /* Link test performed before hardware reset so autoneg doesn't | |
667 | * interfere with test result */ | |
668 | if (ixgbevf_link_test(adapter, &data[1])) | |
669 | eth_test->flags |= ETH_TEST_FL_FAILED; | |
670 | ||
671 | if (if_running) | |
672 | /* indicate we're in test mode */ | |
673 | dev_close(netdev); | |
674 | else | |
675 | ixgbevf_reset(adapter); | |
676 | ||
677 | hw_dbg(&adapter->hw, "register testing starting\n"); | |
678 | if (ixgbevf_reg_test(adapter, &data[0])) | |
679 | eth_test->flags |= ETH_TEST_FL_FAILED; | |
680 | ||
681 | ixgbevf_reset(adapter); | |
682 | ||
683 | clear_bit(__IXGBEVF_TESTING, &adapter->state); | |
684 | if (if_running) | |
685 | dev_open(netdev); | |
686 | } else { | |
687 | hw_dbg(&adapter->hw, "online testing starting\n"); | |
688 | /* Online tests */ | |
689 | if (ixgbevf_link_test(adapter, &data[1])) | |
690 | eth_test->flags |= ETH_TEST_FL_FAILED; | |
691 | ||
692 | /* Online tests aren't run; pass by default */ | |
693 | data[0] = 0; | |
694 | ||
695 | clear_bit(__IXGBEVF_TESTING, &adapter->state); | |
696 | } | |
697 | msleep_interruptible(4 * 1000); | |
698 | } | |
699 | ||
700 | static int ixgbevf_nway_reset(struct net_device *netdev) | |
701 | { | |
702 | struct ixgbevf_adapter *adapter = netdev_priv(netdev); | |
703 | ||
704 | if (netif_running(netdev)) { | |
705 | if (!adapter->dev_closed) | |
706 | ixgbevf_reinit_locked(adapter); | |
707 | } | |
708 | ||
709 | return 0; | |
710 | } | |
711 | ||
712 | static struct ethtool_ops ixgbevf_ethtool_ops = { | |
713 | .get_settings = ixgbevf_get_settings, | |
714 | .get_drvinfo = ixgbevf_get_drvinfo, | |
715 | .get_regs_len = ixgbevf_get_regs_len, | |
716 | .get_regs = ixgbevf_get_regs, | |
717 | .nway_reset = ixgbevf_nway_reset, | |
718 | .get_link = ethtool_op_get_link, | |
719 | .get_ringparam = ixgbevf_get_ringparam, | |
720 | .set_ringparam = ixgbevf_set_ringparam, | |
721 | .get_rx_csum = ixgbevf_get_rx_csum, | |
722 | .set_rx_csum = ixgbevf_set_rx_csum, | |
723 | .get_tx_csum = ethtool_op_get_tx_csum, | |
724 | .set_tx_csum = ethtool_op_set_tx_ipv6_csum, | |
725 | .get_sg = ethtool_op_get_sg, | |
726 | .set_sg = ethtool_op_set_sg, | |
727 | .get_msglevel = ixgbevf_get_msglevel, | |
728 | .set_msglevel = ixgbevf_set_msglevel, | |
729 | .get_tso = ethtool_op_get_tso, | |
730 | .set_tso = ixgbevf_set_tso, | |
731 | .self_test = ixgbevf_diag_test, | |
732 | .get_sset_count = ixgbevf_get_sset_count, | |
733 | .get_strings = ixgbevf_get_strings, | |
734 | .get_ethtool_stats = ixgbevf_get_ethtool_stats, | |
735 | }; | |
736 | ||
737 | void ixgbevf_set_ethtool_ops(struct net_device *netdev) | |
738 | { | |
739 | SET_ETHTOOL_OPS(netdev, &ixgbevf_ethtool_ops); | |
740 | } |