2 * drivers/net/gianfar_ethtool.c
4 * Gianfar Ethernet Driver
5 * Ethtool support for Gianfar Enet
6 * Based on e1000 ethtool support
9 * Maintainer: Kumar Gala
11 * Copyright (c) 2003,2004 Freescale Semiconductor, Inc.
13 * This software may be used and distributed according to
14 * the terms of the GNU Public License, Version 2, incorporated herein
18 #include <linux/config.h>
19 #include <linux/kernel.h>
20 #include <linux/sched.h>
21 #include <linux/string.h>
22 #include <linux/errno.h>
23 #include <linux/slab.h>
24 #include <linux/interrupt.h>
25 #include <linux/init.h>
26 #include <linux/delay.h>
27 #include <linux/netdevice.h>
28 #include <linux/etherdevice.h>
29 #include <linux/skbuff.h>
30 #include <linux/spinlock.h>
35 #include <asm/uaccess.h>
36 #include <linux/module.h>
37 #include <linux/crc32.h>
38 #include <asm/types.h>
39 #include <asm/uaccess.h>
40 #include <linux/ethtool.h>
41 #include <linux/mii.h>
42 #include <linux/phy.h>
46 #define is_power_of_2(x) ((x) != 0 && (((x) & ((x) - 1)) == 0))
48 extern void gfar_start(struct net_device
*dev
);
49 extern int gfar_clean_rx_ring(struct net_device
*dev
, int rx_work_limit
);
51 #define GFAR_MAX_COAL_USECS 0xffff
52 #define GFAR_MAX_COAL_FRAMES 0xff
53 static void gfar_fill_stats(struct net_device
*dev
, struct ethtool_stats
*dummy
,
55 static void gfar_gstrings(struct net_device
*dev
, u32 stringset
, u8
* buf
);
56 static int gfar_gcoalesce(struct net_device
*dev
, struct ethtool_coalesce
*cvals
);
57 static int gfar_scoalesce(struct net_device
*dev
, struct ethtool_coalesce
*cvals
);
58 static void gfar_gringparam(struct net_device
*dev
, struct ethtool_ringparam
*rvals
);
59 static int gfar_sringparam(struct net_device
*dev
, struct ethtool_ringparam
*rvals
);
60 static void gfar_gdrvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*drvinfo
);
62 static char stat_gstrings
[][ETH_GSTRING_LEN
] = {
63 "rx-dropped-by-kernel",
64 "rx-large-frame-errors",
65 "rx-short-frame-errors",
66 "rx-non-octet-errors",
71 "rx-truncated-frames",
75 "rx-skb-missing-errors",
78 "tx-rx-65-127-frames",
79 "tx-rx-128-255-frames",
80 "tx-rx-256-511-frames",
81 "tx-rx-512-1023-frames",
82 "tx-rx-1024-1518-frames",
83 "tx-rx-1519-1522-good-vlan",
87 "receive-multicast-packet",
88 "receive-broadcast-packet",
89 "rx-control-frame-packets",
90 "rx-pause-frame-packets",
93 "rx-frame-length-error",
95 "rx-carrier-sense-error",
96 "rx-undersize-packets",
97 "rx-oversize-packets",
98 "rx-fragmented-frames",
103 "tx-multicast-packets",
104 "tx-broadcast-packets",
105 "tx-pause-control-frames",
106 "tx-deferral-packets",
107 "tx-excessive-deferral-packets",
108 "tx-single-collision-packets",
109 "tx-multiple-collision-packets",
110 "tx-late-collision-packets",
111 "tx-excessive-collision-packets",
112 "tx-total-collision",
118 "tx-oversize-frames",
119 "tx-undersize-frames",
120 "tx-fragmented-frames",
123 /* Fill in a buffer with the strings which correspond to the
125 static void gfar_gstrings(struct net_device
*dev
, u32 stringset
, u8
* buf
)
127 struct gfar_private
*priv
= netdev_priv(dev
);
129 if (priv
->einfo
->device_flags
& FSL_GIANFAR_DEV_HAS_RMON
)
130 memcpy(buf
, stat_gstrings
, GFAR_STATS_LEN
* ETH_GSTRING_LEN
);
132 memcpy(buf
, stat_gstrings
,
133 GFAR_EXTRA_STATS_LEN
* ETH_GSTRING_LEN
);
136 /* Fill in an array of 64-bit statistics from various sources.
137 * This array will be appended to the end of the ethtool_stats
138 * structure, and returned to user space
140 static void gfar_fill_stats(struct net_device
*dev
, struct ethtool_stats
*dummy
, u64
* buf
)
143 struct gfar_private
*priv
= netdev_priv(dev
);
144 u64
*extra
= (u64
*) & priv
->extra_stats
;
146 if (priv
->einfo
->device_flags
& FSL_GIANFAR_DEV_HAS_RMON
) {
147 u32
*rmon
= (u32
*) & priv
->regs
->rmon
;
148 struct gfar_stats
*stats
= (struct gfar_stats
*) buf
;
150 for (i
= 0; i
< GFAR_RMON_LEN
; i
++)
151 stats
->rmon
[i
] = (u64
) (rmon
[i
]);
153 for (i
= 0; i
< GFAR_EXTRA_STATS_LEN
; i
++)
154 stats
->extra
[i
] = extra
[i
];
156 for (i
= 0; i
< GFAR_EXTRA_STATS_LEN
; i
++)
160 /* Returns the number of stats (and their corresponding strings) */
161 static int gfar_stats_count(struct net_device
*dev
)
163 struct gfar_private
*priv
= netdev_priv(dev
);
165 if (priv
->einfo
->device_flags
& FSL_GIANFAR_DEV_HAS_RMON
)
166 return GFAR_STATS_LEN
;
168 return GFAR_EXTRA_STATS_LEN
;
171 /* Fills in the drvinfo structure with some basic info */
172 static void gfar_gdrvinfo(struct net_device
*dev
, struct
173 ethtool_drvinfo
*drvinfo
)
175 strncpy(drvinfo
->driver
, DRV_NAME
, GFAR_INFOSTR_LEN
);
176 strncpy(drvinfo
->version
, gfar_driver_version
, GFAR_INFOSTR_LEN
);
177 strncpy(drvinfo
->fw_version
, "N/A", GFAR_INFOSTR_LEN
);
178 strncpy(drvinfo
->bus_info
, "N/A", GFAR_INFOSTR_LEN
);
179 drvinfo
->n_stats
= GFAR_STATS_LEN
;
180 drvinfo
->testinfo_len
= 0;
181 drvinfo
->regdump_len
= 0;
182 drvinfo
->eedump_len
= 0;
186 static int gfar_ssettings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
188 struct gfar_private
*priv
= netdev_priv(dev
);
189 struct phy_device
*phydev
= priv
->phydev
;
194 return phy_ethtool_sset(phydev
, cmd
);
198 /* Return the current settings in the ethtool_cmd structure */
199 static int gfar_gsettings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
201 struct gfar_private
*priv
= netdev_priv(dev
);
202 struct phy_device
*phydev
= priv
->phydev
;
207 cmd
->maxtxpkt
= priv
->txcount
;
208 cmd
->maxrxpkt
= priv
->rxcount
;
210 return phy_ethtool_gset(phydev
, cmd
);
213 /* Return the length of the register structure */
214 static int gfar_reglen(struct net_device
*dev
)
216 return sizeof (struct gfar
);
219 /* Return a dump of the GFAR register space */
220 static void gfar_get_regs(struct net_device
*dev
, struct ethtool_regs
*regs
, void *regbuf
)
223 struct gfar_private
*priv
= netdev_priv(dev
);
224 u32
*theregs
= (u32
*) priv
->regs
;
225 u32
*buf
= (u32
*) regbuf
;
227 for (i
= 0; i
< sizeof (struct gfar
) / sizeof (u32
); i
++)
231 /* Convert microseconds to ethernet clock ticks, which changes
232 * depending on what speed the controller is running at */
233 static unsigned int gfar_usecs2ticks(struct gfar_private
*priv
, unsigned int usecs
)
237 /* The timer is different, depending on the interface speed */
238 switch (priv
->phydev
->speed
) {
240 count
= GFAR_GBIT_TIME
;
243 count
= GFAR_100_TIME
;
247 count
= GFAR_10_TIME
;
251 /* Make sure we return a number greater than 0
253 return ((usecs
* 1000 + count
- 1) / count
);
256 /* Convert ethernet clock ticks to microseconds */
257 static unsigned int gfar_ticks2usecs(struct gfar_private
*priv
, unsigned int ticks
)
261 /* The timer is different, depending on the interface speed */
262 switch (priv
->phydev
->speed
) {
264 count
= GFAR_GBIT_TIME
;
267 count
= GFAR_100_TIME
;
271 count
= GFAR_10_TIME
;
275 /* Make sure we return a number greater than 0 */
276 /* if ticks is > 0 */
277 return ((ticks
* count
) / 1000);
280 /* Get the coalescing parameters, and put them in the cvals
282 static int gfar_gcoalesce(struct net_device
*dev
, struct ethtool_coalesce
*cvals
)
284 struct gfar_private
*priv
= netdev_priv(dev
);
286 if (!(priv
->einfo
->device_flags
& FSL_GIANFAR_DEV_HAS_COALESCE
))
289 if (NULL
== priv
->phydev
)
292 cvals
->rx_coalesce_usecs
= gfar_ticks2usecs(priv
, priv
->rxtime
);
293 cvals
->rx_max_coalesced_frames
= priv
->rxcount
;
295 cvals
->tx_coalesce_usecs
= gfar_ticks2usecs(priv
, priv
->txtime
);
296 cvals
->tx_max_coalesced_frames
= priv
->txcount
;
298 cvals
->use_adaptive_rx_coalesce
= 0;
299 cvals
->use_adaptive_tx_coalesce
= 0;
301 cvals
->pkt_rate_low
= 0;
302 cvals
->rx_coalesce_usecs_low
= 0;
303 cvals
->rx_max_coalesced_frames_low
= 0;
304 cvals
->tx_coalesce_usecs_low
= 0;
305 cvals
->tx_max_coalesced_frames_low
= 0;
307 /* When the packet rate is below pkt_rate_high but above
308 * pkt_rate_low (both measured in packets per second) the
309 * normal {rx,tx}_* coalescing parameters are used.
312 /* When the packet rate is (measured in packets per second)
313 * is above pkt_rate_high, the {rx,tx}_*_high parameters are
316 cvals
->pkt_rate_high
= 0;
317 cvals
->rx_coalesce_usecs_high
= 0;
318 cvals
->rx_max_coalesced_frames_high
= 0;
319 cvals
->tx_coalesce_usecs_high
= 0;
320 cvals
->tx_max_coalesced_frames_high
= 0;
322 /* How often to do adaptive coalescing packet rate sampling,
323 * measured in seconds. Must not be zero.
325 cvals
->rate_sample_interval
= 0;
330 /* Change the coalescing values.
331 * Both cvals->*_usecs and cvals->*_frames have to be > 0
332 * in order for coalescing to be active
334 static int gfar_scoalesce(struct net_device
*dev
, struct ethtool_coalesce
*cvals
)
336 struct gfar_private
*priv
= netdev_priv(dev
);
338 if (!(priv
->einfo
->device_flags
& FSL_GIANFAR_DEV_HAS_COALESCE
))
341 /* Set up rx coalescing */
342 if ((cvals
->rx_coalesce_usecs
== 0) ||
343 (cvals
->rx_max_coalesced_frames
== 0))
344 priv
->rxcoalescing
= 0;
346 priv
->rxcoalescing
= 1;
348 if (NULL
== priv
->phydev
)
351 /* Check the bounds of the values */
352 if (cvals
->rx_coalesce_usecs
> GFAR_MAX_COAL_USECS
) {
353 pr_info("Coalescing is limited to %d microseconds\n",
354 GFAR_MAX_COAL_USECS
);
358 if (cvals
->rx_max_coalesced_frames
> GFAR_MAX_COAL_FRAMES
) {
359 pr_info("Coalescing is limited to %d frames\n",
360 GFAR_MAX_COAL_FRAMES
);
364 priv
->rxtime
= gfar_usecs2ticks(priv
, cvals
->rx_coalesce_usecs
);
365 priv
->rxcount
= cvals
->rx_max_coalesced_frames
;
367 /* Set up tx coalescing */
368 if ((cvals
->tx_coalesce_usecs
== 0) ||
369 (cvals
->tx_max_coalesced_frames
== 0))
370 priv
->txcoalescing
= 0;
372 priv
->txcoalescing
= 1;
374 /* Check the bounds of the values */
375 if (cvals
->tx_coalesce_usecs
> GFAR_MAX_COAL_USECS
) {
376 pr_info("Coalescing is limited to %d microseconds\n",
377 GFAR_MAX_COAL_USECS
);
381 if (cvals
->tx_max_coalesced_frames
> GFAR_MAX_COAL_FRAMES
) {
382 pr_info("Coalescing is limited to %d frames\n",
383 GFAR_MAX_COAL_FRAMES
);
387 priv
->txtime
= gfar_usecs2ticks(priv
, cvals
->tx_coalesce_usecs
);
388 priv
->txcount
= cvals
->tx_max_coalesced_frames
;
390 if (priv
->rxcoalescing
)
391 gfar_write(&priv
->regs
->rxic
,
392 mk_ic_value(priv
->rxcount
, priv
->rxtime
));
394 gfar_write(&priv
->regs
->rxic
, 0);
396 if (priv
->txcoalescing
)
397 gfar_write(&priv
->regs
->txic
,
398 mk_ic_value(priv
->txcount
, priv
->txtime
));
400 gfar_write(&priv
->regs
->txic
, 0);
405 /* Fills in rvals with the current ring parameters. Currently,
406 * rx, rx_mini, and rx_jumbo rings are the same size, as mini and
407 * jumbo are ignored by the driver */
408 static void gfar_gringparam(struct net_device
*dev
, struct ethtool_ringparam
*rvals
)
410 struct gfar_private
*priv
= netdev_priv(dev
);
412 rvals
->rx_max_pending
= GFAR_RX_MAX_RING_SIZE
;
413 rvals
->rx_mini_max_pending
= GFAR_RX_MAX_RING_SIZE
;
414 rvals
->rx_jumbo_max_pending
= GFAR_RX_MAX_RING_SIZE
;
415 rvals
->tx_max_pending
= GFAR_TX_MAX_RING_SIZE
;
417 /* Values changeable by the user. The valid values are
418 * in the range 1 to the "*_max_pending" counterpart above.
420 rvals
->rx_pending
= priv
->rx_ring_size
;
421 rvals
->rx_mini_pending
= priv
->rx_ring_size
;
422 rvals
->rx_jumbo_pending
= priv
->rx_ring_size
;
423 rvals
->tx_pending
= priv
->tx_ring_size
;
426 /* Change the current ring parameters, stopping the controller if
427 * necessary so that we don't mess things up while we're in
428 * motion. We wait for the ring to be clean before reallocating
430 static int gfar_sringparam(struct net_device
*dev
, struct ethtool_ringparam
*rvals
)
432 struct gfar_private
*priv
= netdev_priv(dev
);
435 if (rvals
->rx_pending
> GFAR_RX_MAX_RING_SIZE
)
438 if (!is_power_of_2(rvals
->rx_pending
)) {
439 printk("%s: Ring sizes must be a power of 2\n",
444 if (rvals
->tx_pending
> GFAR_TX_MAX_RING_SIZE
)
447 if (!is_power_of_2(rvals
->tx_pending
)) {
448 printk("%s: Ring sizes must be a power of 2\n",
453 if (dev
->flags
& IFF_UP
) {
456 /* Halt TX and RX, and process the frames which
457 * have already been received */
458 spin_lock_irqsave(&priv
->lock
, flags
);
460 gfar_clean_rx_ring(dev
, priv
->rx_ring_size
);
461 spin_unlock_irqrestore(&priv
->lock
, flags
);
463 /* Now we take down the rings to rebuild them */
467 /* Change the size */
468 priv
->rx_ring_size
= rvals
->rx_pending
;
469 priv
->tx_ring_size
= rvals
->tx_pending
;
471 /* Rebuild the rings with the new size */
472 if (dev
->flags
& IFF_UP
)
473 err
= startup_gfar(dev
);
478 static int gfar_set_rx_csum(struct net_device
*dev
, uint32_t data
)
480 struct gfar_private
*priv
= netdev_priv(dev
);
483 if (!(priv
->einfo
->device_flags
& FSL_GIANFAR_DEV_HAS_CSUM
))
486 if (dev
->flags
& IFF_UP
) {
489 /* Halt TX and RX, and process the frames which
490 * have already been received */
491 spin_lock_irqsave(&priv
->lock
, flags
);
493 gfar_clean_rx_ring(dev
, priv
->rx_ring_size
);
494 spin_unlock_irqrestore(&priv
->lock
, flags
);
496 /* Now we take down the rings to rebuild them */
500 priv
->rx_csum_enable
= data
;
502 if (dev
->flags
& IFF_UP
)
503 err
= startup_gfar(dev
);
508 static uint32_t gfar_get_rx_csum(struct net_device
*dev
)
510 struct gfar_private
*priv
= netdev_priv(dev
);
512 if (!(priv
->einfo
->device_flags
& FSL_GIANFAR_DEV_HAS_CSUM
))
515 return priv
->rx_csum_enable
;
518 static int gfar_set_tx_csum(struct net_device
*dev
, uint32_t data
)
521 struct gfar_private
*priv
= netdev_priv(dev
);
523 if (!(priv
->einfo
->device_flags
& FSL_GIANFAR_DEV_HAS_CSUM
))
526 spin_lock_irqsave(&priv
->lock
, flags
);
530 dev
->features
|= NETIF_F_IP_CSUM
;
532 dev
->features
&= ~NETIF_F_IP_CSUM
;
535 spin_unlock_irqrestore(&priv
->lock
, flags
);
540 static uint32_t gfar_get_tx_csum(struct net_device
*dev
)
542 struct gfar_private
*priv
= netdev_priv(dev
);
544 if (!(priv
->einfo
->device_flags
& FSL_GIANFAR_DEV_HAS_CSUM
))
547 return (dev
->features
& NETIF_F_IP_CSUM
) != 0;
550 static uint32_t gfar_get_msglevel(struct net_device
*dev
)
552 struct gfar_private
*priv
= netdev_priv(dev
);
553 return priv
->msg_enable
;
556 static void gfar_set_msglevel(struct net_device
*dev
, uint32_t data
)
558 struct gfar_private
*priv
= netdev_priv(dev
);
559 priv
->msg_enable
= data
;
563 struct ethtool_ops gfar_ethtool_ops
= {
564 .get_settings
= gfar_gsettings
,
565 .set_settings
= gfar_ssettings
,
566 .get_drvinfo
= gfar_gdrvinfo
,
567 .get_regs_len
= gfar_reglen
,
568 .get_regs
= gfar_get_regs
,
569 .get_link
= ethtool_op_get_link
,
570 .get_coalesce
= gfar_gcoalesce
,
571 .set_coalesce
= gfar_scoalesce
,
572 .get_ringparam
= gfar_gringparam
,
573 .set_ringparam
= gfar_sringparam
,
574 .get_strings
= gfar_gstrings
,
575 .get_stats_count
= gfar_stats_count
,
576 .get_ethtool_stats
= gfar_fill_stats
,
577 .get_rx_csum
= gfar_get_rx_csum
,
578 .get_tx_csum
= gfar_get_tx_csum
,
579 .set_rx_csum
= gfar_set_rx_csum
,
580 .set_tx_csum
= gfar_set_tx_csum
,
581 .get_msglevel
= gfar_get_msglevel
,
582 .set_msglevel
= gfar_set_msglevel
,