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