1/* 2 * drivers/net/gianfar_ethtool.c 3 * 4 * Gianfar Ethernet Driver 5 * Ethtool support for Gianfar Enet 6 * Based on e1000 ethtool support 7 * 8 * Author: Andy Fleming 9 * Maintainer: Kumar Gala 10 * 11 * Copyright (c) 2003,2004 Freescale Semiconductor, Inc. 12 * 13 * This software may be used and distributed according to 14 * the terms of the GNU Public License, Version 2, incorporated herein 15 * by reference. 16 */ 17 18#include <linux/kernel.h> 19#include <linux/string.h> 20#include <linux/errno.h> 21#include <linux/slab.h> 22#include <linux/interrupt.h> 23#include <linux/init.h> 24#include <linux/delay.h> 25#include <linux/netdevice.h> 26#include <linux/etherdevice.h> 27#include <linux/skbuff.h> 28#include <linux/spinlock.h> 29#include <linux/mm.h> 30 31#include <asm/io.h> 32#include <asm/irq.h> 33#include <asm/uaccess.h> 34#include <linux/module.h> 35#include <linux/crc32.h> 36#include <asm/types.h> 37#include <asm/uaccess.h> 38#include <linux/ethtool.h> 39#include <linux/mii.h> 40#include <linux/phy.h> 41 42#include "gianfar.h" 43 44extern void gfar_start(struct net_device *dev); 45extern int gfar_clean_rx_ring(struct net_device *dev, int rx_work_limit); 46 47#define GFAR_MAX_COAL_USECS 0xffff 48#define GFAR_MAX_COAL_FRAMES 0xff 49static void gfar_fill_stats(struct net_device *dev, struct ethtool_stats *dummy, 50 u64 * buf); 51static void gfar_gstrings(struct net_device *dev, u32 stringset, u8 * buf); 52static int gfar_gcoalesce(struct net_device *dev, struct ethtool_coalesce *cvals); 53static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals); 54static void gfar_gringparam(struct net_device *dev, struct ethtool_ringparam *rvals); 55static int gfar_sringparam(struct net_device *dev, struct ethtool_ringparam *rvals); 56static void gfar_gdrvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo); 57 58static char stat_gstrings[][ETH_GSTRING_LEN] = { 59 "rx-dropped-by-kernel", 60 "rx-large-frame-errors", 61 "rx-short-frame-errors", 62 "rx-non-octet-errors", 63 "rx-crc-errors", 64 "rx-overrun-errors", 65 "rx-busy-errors", 66 "rx-babbling-errors", 67 "rx-truncated-frames", 68 "ethernet-bus-error", 69 "tx-babbling-errors", 70 "tx-underrun-errors", 71 "rx-skb-missing-errors", 72 "tx-timeout-errors", 73 "tx-rx-64-frames", 74 "tx-rx-65-127-frames", 75 "tx-rx-128-255-frames", 76 "tx-rx-256-511-frames", 77 "tx-rx-512-1023-frames", 78 "tx-rx-1024-1518-frames", 79 "tx-rx-1519-1522-good-vlan", 80 "rx-bytes", 81 "rx-packets", 82 "rx-fcs-errors", 83 "receive-multicast-packet", 84 "receive-broadcast-packet", 85 "rx-control-frame-packets", 86 "rx-pause-frame-packets", 87 "rx-unknown-op-code", 88 "rx-alignment-error", 89 "rx-frame-length-error", 90 "rx-code-error", 91 "rx-carrier-sense-error", 92 "rx-undersize-packets", 93 "rx-oversize-packets", 94 "rx-fragmented-frames", 95 "rx-jabber-frames", 96 "rx-dropped-frames", 97 "tx-byte-counter", 98 "tx-packets", 99 "tx-multicast-packets", 100 "tx-broadcast-packets", 101 "tx-pause-control-frames", 102 "tx-deferral-packets", 103 "tx-excessive-deferral-packets", 104 "tx-single-collision-packets", 105 "tx-multiple-collision-packets", 106 "tx-late-collision-packets", 107 "tx-excessive-collision-packets", 108 "tx-total-collision", 109 "reserved", 110 "tx-dropped-frames", 111 "tx-jabber-frames", 112 "tx-fcs-errors", 113 "tx-control-frames", 114 "tx-oversize-frames", 115 "tx-undersize-frames", 116 "tx-fragmented-frames", 117}; 118 119/* Fill in a buffer with the strings which correspond to the 120 * stats */ 121static void gfar_gstrings(struct net_device *dev, u32 stringset, u8 * buf) 122{ 123 struct gfar_private *priv = netdev_priv(dev); 124 125 if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_RMON) 126 memcpy(buf, stat_gstrings, GFAR_STATS_LEN * ETH_GSTRING_LEN); 127 else 128 memcpy(buf, stat_gstrings, 129 GFAR_EXTRA_STATS_LEN * ETH_GSTRING_LEN); 130} 131 132/* Fill in an array of 64-bit statistics from various sources. 133 * This array will be appended to the end of the ethtool_stats 134 * structure, and returned to user space 135 */ 136static void gfar_fill_stats(struct net_device *dev, struct ethtool_stats *dummy, u64 * buf) 137{ 138 int i; 139 struct gfar_private *priv = netdev_priv(dev); 140 u64 *extra = (u64 *) & priv->extra_stats; 141 142 if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_RMON) { 143 u32 __iomem *rmon = (u32 __iomem *) & priv->regs->rmon; 144 struct gfar_stats *stats = (struct gfar_stats *) buf; 145 146 for (i = 0; i < GFAR_RMON_LEN; i++) 147 stats->rmon[i] = (u64) gfar_read(&rmon[i]); 148 149 for (i = 0; i < GFAR_EXTRA_STATS_LEN; i++) 150 stats->extra[i] = extra[i]; 151 } else 152 for (i = 0; i < GFAR_EXTRA_STATS_LEN; i++) 153 buf[i] = extra[i]; 154} 155 156/* Returns the number of stats (and their corresponding strings) */ 157static int gfar_stats_count(struct net_device *dev) 158{ 159 struct gfar_private *priv = netdev_priv(dev); 160 161 if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_RMON) 162 return GFAR_STATS_LEN; 163 else 164 return GFAR_EXTRA_STATS_LEN; 165} 166 167/* Fills in the drvinfo structure with some basic info */ 168static void gfar_gdrvinfo(struct net_device *dev, struct 169 ethtool_drvinfo *drvinfo) 170{ 171 strncpy(drvinfo->driver, DRV_NAME, GFAR_INFOSTR_LEN); 172 strncpy(drvinfo->version, gfar_driver_version, GFAR_INFOSTR_LEN); 173 strncpy(drvinfo->fw_version, "N/A", GFAR_INFOSTR_LEN); 174 strncpy(drvinfo->bus_info, "N/A", GFAR_INFOSTR_LEN); 175 drvinfo->n_stats = GFAR_STATS_LEN; 176 drvinfo->testinfo_len = 0; 177 drvinfo->regdump_len = 0; 178 drvinfo->eedump_len = 0; 179} 180 181 182static int gfar_ssettings(struct net_device *dev, struct ethtool_cmd *cmd) 183{ 184 struct gfar_private *priv = netdev_priv(dev); 185 struct phy_device *phydev = priv->phydev; 186 187 if (NULL == phydev) 188 return -ENODEV; 189 190 return phy_ethtool_sset(phydev, cmd); 191} 192 193 194/* Return the current settings in the ethtool_cmd structure */ 195static int gfar_gsettings(struct net_device *dev, struct ethtool_cmd *cmd) 196{ 197 struct gfar_private *priv = netdev_priv(dev); 198 struct phy_device *phydev = priv->phydev; 199 200 if (NULL == phydev) 201 return -ENODEV; 202 203 cmd->maxtxpkt = priv->txcount; 204 cmd->maxrxpkt = priv->rxcount; 205 206 return phy_ethtool_gset(phydev, cmd); 207} 208 209/* Return the length of the register structure */ 210static int gfar_reglen(struct net_device *dev) 211{ 212 return sizeof (struct gfar); 213} 214 215/* Return a dump of the GFAR register space */ 216static void gfar_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *regbuf) 217{ 218 int i; 219 struct gfar_private *priv = netdev_priv(dev); 220 u32 __iomem *theregs = (u32 __iomem *) priv->regs; 221 u32 *buf = (u32 *) regbuf; 222 223 for (i = 0; i < sizeof (struct gfar) / sizeof (u32); i++) 224 buf[i] = gfar_read(&theregs[i]); 225} 226 227/* Convert microseconds to ethernet clock ticks, which changes 228 * depending on what speed the controller is running at */ 229static unsigned int gfar_usecs2ticks(struct gfar_private *priv, unsigned int usecs) 230{ 231 unsigned int count; 232 233 /* The timer is different, depending on the interface speed */ 234 switch (priv->phydev->speed) { 235 case SPEED_1000: 236 count = GFAR_GBIT_TIME; 237 break; 238 case SPEED_100: 239 count = GFAR_100_TIME; 240 break; 241 case SPEED_10: 242 default: 243 count = GFAR_10_TIME; 244 break; 245 } 246 247 /* Make sure we return a number greater than 0 248 * if usecs > 0 */ 249 return ((usecs * 1000 + count - 1) / count); 250} 251 252/* Convert ethernet clock ticks to microseconds */ 253static unsigned int gfar_ticks2usecs(struct gfar_private *priv, unsigned int ticks) 254{ 255 unsigned int count; 256 257 /* The timer is different, depending on the interface speed */ 258 switch (priv->phydev->speed) { 259 case SPEED_1000: 260 count = GFAR_GBIT_TIME; 261 break; 262 case SPEED_100: 263 count = GFAR_100_TIME; 264 break; 265 case SPEED_10: 266 default: 267 count = GFAR_10_TIME; 268 break; 269 } 270 271 /* Make sure we return a number greater than 0 */ 272 /* if ticks is > 0 */ 273 return ((ticks * count) / 1000); 274} 275 276/* Get the coalescing parameters, and put them in the cvals 277 * structure. */ 278static int gfar_gcoalesce(struct net_device *dev, struct ethtool_coalesce *cvals) 279{ 280 struct gfar_private *priv = netdev_priv(dev); 281 282 if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE)) 283 return -EOPNOTSUPP; 284 285 if (NULL == priv->phydev) 286 return -ENODEV; 287 288 cvals->rx_coalesce_usecs = gfar_ticks2usecs(priv, priv->rxtime); 289 cvals->rx_max_coalesced_frames = priv->rxcount; 290 291 cvals->tx_coalesce_usecs = gfar_ticks2usecs(priv, priv->txtime); 292 cvals->tx_max_coalesced_frames = priv->txcount; 293 294 cvals->use_adaptive_rx_coalesce = 0; 295 cvals->use_adaptive_tx_coalesce = 0; 296 297 cvals->pkt_rate_low = 0; 298 cvals->rx_coalesce_usecs_low = 0; 299 cvals->rx_max_coalesced_frames_low = 0; 300 cvals->tx_coalesce_usecs_low = 0; 301 cvals->tx_max_coalesced_frames_low = 0; 302 303 /* When the packet rate is below pkt_rate_high but above 304 * pkt_rate_low (both measured in packets per second) the 305 * normal {rx,tx}_* coalescing parameters are used. 306 */ 307 308 /* When the packet rate is (measured in packets per second) 309 * is above pkt_rate_high, the {rx,tx}_*_high parameters are 310 * used. 311 */ 312 cvals->pkt_rate_high = 0; 313 cvals->rx_coalesce_usecs_high = 0; 314 cvals->rx_max_coalesced_frames_high = 0; 315 cvals->tx_coalesce_usecs_high = 0; 316 cvals->tx_max_coalesced_frames_high = 0; 317 318 /* How often to do adaptive coalescing packet rate sampling, 319 * measured in seconds. Must not be zero. 320 */ 321 cvals->rate_sample_interval = 0; 322 323 return 0; 324} 325 326/* Change the coalescing values. 327 * Both cvals->*_usecs and cvals->*_frames have to be > 0 328 * in order for coalescing to be active 329 */ 330static int gfar_scoalesce(struct net_device *dev, struct ethtool_coalesce *cvals) 331{ 332 struct gfar_private *priv = netdev_priv(dev); 333 334 if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE)) 335 return -EOPNOTSUPP; 336 337 /* Set up rx coalescing */ 338 if ((cvals->rx_coalesce_usecs == 0) || 339 (cvals->rx_max_coalesced_frames == 0)) 340 priv->rxcoalescing = 0; 341 else 342 priv->rxcoalescing = 1; 343 344 if (NULL == priv->phydev) 345 return -ENODEV; 346 347 /* Check the bounds of the values */ 348 if (cvals->rx_coalesce_usecs > GFAR_MAX_COAL_USECS) { 349 pr_info("Coalescing is limited to %d microseconds\n", 350 GFAR_MAX_COAL_USECS); 351 return -EINVAL; 352 } 353 354 if (cvals->rx_max_coalesced_frames > GFAR_MAX_COAL_FRAMES) { 355 pr_info("Coalescing is limited to %d frames\n", 356 GFAR_MAX_COAL_FRAMES); 357 return -EINVAL; 358 } 359 360 priv->rxtime = gfar_usecs2ticks(priv, cvals->rx_coalesce_usecs); 361 priv->rxcount = cvals->rx_max_coalesced_frames; 362 363 /* Set up tx coalescing */ 364 if ((cvals->tx_coalesce_usecs == 0) || 365 (cvals->tx_max_coalesced_frames == 0)) 366 priv->txcoalescing = 0; 367 else 368 priv->txcoalescing = 1; 369 370 /* Check the bounds of the values */ 371 if (cvals->tx_coalesce_usecs > GFAR_MAX_COAL_USECS) { 372 pr_info("Coalescing is limited to %d microseconds\n", 373 GFAR_MAX_COAL_USECS); 374 return -EINVAL; 375 } 376 377 if (cvals->tx_max_coalesced_frames > GFAR_MAX_COAL_FRAMES) { 378 pr_info("Coalescing is limited to %d frames\n", 379 GFAR_MAX_COAL_FRAMES); 380 return -EINVAL; 381 } 382 383 priv->txtime = gfar_usecs2ticks(priv, cvals->tx_coalesce_usecs); 384 priv->txcount = cvals->tx_max_coalesced_frames; 385 386 if (priv->rxcoalescing) 387 gfar_write(&priv->regs->rxic, 388 mk_ic_value(priv->rxcount, priv->rxtime)); 389 else 390 gfar_write(&priv->regs->rxic, 0); 391 392 if (priv->txcoalescing) 393 gfar_write(&priv->regs->txic, 394 mk_ic_value(priv->txcount, priv->txtime)); 395 else 396 gfar_write(&priv->regs->txic, 0); 397 398 return 0; 399} 400 401/* Fills in rvals with the current ring parameters. Currently, 402 * rx, rx_mini, and rx_jumbo rings are the same size, as mini and 403 * jumbo are ignored by the driver */ 404static void gfar_gringparam(struct net_device *dev, struct ethtool_ringparam *rvals) 405{ 406 struct gfar_private *priv = netdev_priv(dev); 407 408 rvals->rx_max_pending = GFAR_RX_MAX_RING_SIZE; 409 rvals->rx_mini_max_pending = GFAR_RX_MAX_RING_SIZE; 410 rvals->rx_jumbo_max_pending = GFAR_RX_MAX_RING_SIZE; 411 rvals->tx_max_pending = GFAR_TX_MAX_RING_SIZE; 412 413 /* Values changeable by the user. The valid values are 414 * in the range 1 to the "*_max_pending" counterpart above. 415 */ 416 rvals->rx_pending = priv->rx_ring_size; 417 rvals->rx_mini_pending = priv->rx_ring_size; 418 rvals->rx_jumbo_pending = priv->rx_ring_size; 419 rvals->tx_pending = priv->tx_ring_size; 420} 421 422/* Change the current ring parameters, stopping the controller if 423 * necessary so that we don't mess things up while we're in 424 * motion. We wait for the ring to be clean before reallocating 425 * the rings. */ 426static int gfar_sringparam(struct net_device *dev, struct ethtool_ringparam *rvals) 427{ 428 struct gfar_private *priv = netdev_priv(dev); 429 int err = 0; 430 431 if (rvals->rx_pending > GFAR_RX_MAX_RING_SIZE) 432 return -EINVAL; 433 434 if (!is_power_of_2(rvals->rx_pending)) { 435 printk("%s: Ring sizes must be a power of 2\n", 436 dev->name); 437 return -EINVAL; 438 } 439 440 if (rvals->tx_pending > GFAR_TX_MAX_RING_SIZE) 441 return -EINVAL; 442 443 if (!is_power_of_2(rvals->tx_pending)) { 444 printk("%s: Ring sizes must be a power of 2\n", 445 dev->name); 446 return -EINVAL; 447 } 448 449 if (dev->flags & IFF_UP) { 450 unsigned long flags; 451 452 /* Halt TX and RX, and process the frames which 453 * have already been received */ 454 spin_lock_irqsave(&priv->txlock, flags); 455 spin_lock(&priv->rxlock); 456 457 gfar_halt(dev); 458 gfar_clean_rx_ring(dev, priv->rx_ring_size); 459 460 spin_unlock(&priv->rxlock); 461 spin_unlock_irqrestore(&priv->txlock, flags); 462 463 /* Now we take down the rings to rebuild them */ 464 stop_gfar(dev); 465 } 466 467 /* Change the size */ 468 priv->rx_ring_size = rvals->rx_pending; 469 priv->tx_ring_size = rvals->tx_pending; 470 471 /* Rebuild the rings with the new size */ 472 if (dev->flags & IFF_UP) 473 err = startup_gfar(dev); 474 475 return err; 476} 477 478static int gfar_set_rx_csum(struct net_device *dev, uint32_t data) 479{ 480 struct gfar_private *priv = netdev_priv(dev); 481 int err = 0; 482 483 if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_CSUM)) 484 return -EOPNOTSUPP; 485 486 if (dev->flags & IFF_UP) { 487 unsigned long flags; 488 489 /* Halt TX and RX, and process the frames which 490 * have already been received */ 491 spin_lock_irqsave(&priv->txlock, flags); 492 spin_lock(&priv->rxlock); 493 494 gfar_halt(dev); 495 gfar_clean_rx_ring(dev, priv->rx_ring_size); 496 497 spin_unlock(&priv->rxlock); 498 spin_unlock_irqrestore(&priv->txlock, flags); 499 500 /* Now we take down the rings to rebuild them */ 501 stop_gfar(dev); 502 } 503 504 priv->rx_csum_enable = data; 505 506 if (dev->flags & IFF_UP) 507 err = startup_gfar(dev); 508 509 return err; 510} 511 512static uint32_t gfar_get_rx_csum(struct net_device *dev) 513{ 514 struct gfar_private *priv = netdev_priv(dev); 515 516 if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_CSUM)) 517 return 0; 518 519 return priv->rx_csum_enable; 520} 521 522static int gfar_set_tx_csum(struct net_device *dev, uint32_t data) 523{ 524 unsigned long flags; 525 struct gfar_private *priv = netdev_priv(dev); 526 527 if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_CSUM)) 528 return -EOPNOTSUPP; 529 530 spin_lock_irqsave(&priv->txlock, flags); 531 gfar_halt(dev); 532 533 if (data) 534 dev->features |= NETIF_F_IP_CSUM; 535 else 536 dev->features &= ~NETIF_F_IP_CSUM; 537 538 gfar_start(dev); 539 spin_unlock_irqrestore(&priv->txlock, flags); 540 541 return 0; 542} 543 544static uint32_t gfar_get_tx_csum(struct net_device *dev) 545{ 546 struct gfar_private *priv = netdev_priv(dev); 547 548 if (!(priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_CSUM)) 549 return 0; 550 551 return (dev->features & NETIF_F_IP_CSUM) != 0; 552} 553 554static uint32_t gfar_get_msglevel(struct net_device *dev) 555{ 556 struct gfar_private *priv = netdev_priv(dev); 557 return priv->msg_enable; 558} 559 560static void gfar_set_msglevel(struct net_device *dev, uint32_t data) 561{ 562 struct gfar_private *priv = netdev_priv(dev); 563 priv->msg_enable = data; 564} 565 566 567const struct ethtool_ops gfar_ethtool_ops = { 568 .get_settings = gfar_gsettings, 569 .set_settings = gfar_ssettings, 570 .get_drvinfo = gfar_gdrvinfo, 571 .get_regs_len = gfar_reglen, 572 .get_regs = gfar_get_regs, 573 .get_link = ethtool_op_get_link, 574 .get_coalesce = gfar_gcoalesce, 575 .set_coalesce = gfar_scoalesce, 576 .get_ringparam = gfar_gringparam, 577 .set_ringparam = gfar_sringparam, 578 .get_strings = gfar_gstrings, 579 .get_stats_count = gfar_stats_count, 580 .get_ethtool_stats = gfar_fill_stats, 581 .get_rx_csum = gfar_get_rx_csum, 582 .get_tx_csum = gfar_get_tx_csum, 583 .set_rx_csum = gfar_set_rx_csum, 584 .set_tx_csum = gfar_set_tx_csum, 585 .get_msglevel = gfar_get_msglevel, 586 .set_msglevel = gfar_set_msglevel, 587}; 588