ixgbe: correct typo in define name
[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/slab.h>
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;
50         int saved_reset_offset;
51 };
52
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)
57 static struct ixgbe_stats ixgbe_gstrings_stats[] = {
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)},
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_VFFRTIMER",
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_VFFRTIMER);
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 = 0;
334         u32 new_rx_count, new_tx_count;
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
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;
368         }
369
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;
375         }
376
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;
382         }
383
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;
400         }
401
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;
416         }
417
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
430         /* success! */
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);
444
445 clear_reset:
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;
474                 char *r = (char *)adapter +
475                         ixgbe_gstrings_stats[i].saved_reset_offset;
476                 data[i] = ((ixgbe_gstrings_stats[i].sizeof_stat ==
477                             sizeof(u64)) ? *(u64 *)p : *(u32 *)p) -
478                           ((ixgbe_gstrings_stats[i].sizeof_stat ==
479                             sizeof(u64)) ? *(u64 *)b : *(u32 *)b) +
480                           ((ixgbe_gstrings_stats[i].sizeof_stat ==
481                             sizeof(u64)) ? *(u64 *)r : *(u32 *)r);
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 */
547 static const struct ixgbevf_reg_test reg_test_vf[] = {
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
560 static const u32 register_test_patterns[] = {
561         0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF
562 };
563
564 #define REG_PATTERN_TEST(R, M, W)                                             \
565 {                                                                             \
566         u32 pat, val, before;                                                 \
567         for (pat = 0; pat < ARRAY_SIZE(register_test_patterns); pat++) {      \
568                 before = readl(adapter->hw.hw_addr + R);                      \
569                 writel((register_test_patterns[pat] & W),                     \
570                        (adapter->hw.hw_addr + R));                            \
571                 val = readl(adapter->hw.hw_addr + R);                         \
572                 if (val != (register_test_patterns[pat] & W & M)) {           \
573                         hw_dbg(&adapter->hw,                                  \
574                         "pattern test reg %04X failed: got "                  \
575                         "0x%08X expected 0x%08X\n",                           \
576                         R, val, (register_test_patterns[pat] & W & M));       \
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 {
603         const struct ixgbevf_reg_test *test;
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 }