LXR linux/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe

   1/*
   2 * Copyright (C) 1999 - 2010 Intel Corporation.
   3 * Copyright (C) 2010 OKI SEMICONDUCTOR Co., LTD.
   4 *
   5 * This code was derived from the Intel e1000e Linux driver.
   6 *
   7 * This program is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; version 2 of the License.
  10 *
  11 * This program is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with this program; if not, write to the Free Software
  18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
  19 */
  20#include "pch_gbe.h"
  21#include "pch_gbe_api.h"
  22
  23/**
  24 * pch_gbe_stats - Stats item information
  25 */
  26struct pch_gbe_stats {
  27        char string[ETH_GSTRING_LEN];
  28        size_t size;
  29        size_t offset;
  30};
  31
  32#define PCH_GBE_STAT(m)                                         \
  33{                                                               \
  34        .string = #m,                                           \
  35        .size = FIELD_SIZEOF(struct pch_gbe_hw_stats, m),       \
  36        .offset = offsetof(struct pch_gbe_hw_stats, m),         \
  37}
  38
  39/**
  40 * pch_gbe_gstrings_stats - ethtool information status name list
  41 */
  42static const struct pch_gbe_stats pch_gbe_gstrings_stats[] = {
  43        PCH_GBE_STAT(rx_packets),
  44        PCH_GBE_STAT(tx_packets),
  45        PCH_GBE_STAT(rx_bytes),
  46        PCH_GBE_STAT(tx_bytes),
  47        PCH_GBE_STAT(rx_errors),
  48        PCH_GBE_STAT(tx_errors),
  49        PCH_GBE_STAT(rx_dropped),
  50        PCH_GBE_STAT(tx_dropped),
  51        PCH_GBE_STAT(multicast),
  52        PCH_GBE_STAT(collisions),
  53        PCH_GBE_STAT(rx_crc_errors),
  54        PCH_GBE_STAT(rx_frame_errors),
  55        PCH_GBE_STAT(rx_alloc_buff_failed),
  56        PCH_GBE_STAT(tx_length_errors),
  57        PCH_GBE_STAT(tx_aborted_errors),
  58        PCH_GBE_STAT(tx_carrier_errors),
  59        PCH_GBE_STAT(tx_timeout_count),
  60        PCH_GBE_STAT(tx_restart_count),
  61        PCH_GBE_STAT(intr_rx_dsc_empty_count),
  62        PCH_GBE_STAT(intr_rx_frame_err_count),
  63        PCH_GBE_STAT(intr_rx_fifo_err_count),
  64        PCH_GBE_STAT(intr_rx_dma_err_count),
  65        PCH_GBE_STAT(intr_tx_fifo_err_count),
  66        PCH_GBE_STAT(intr_tx_dma_err_count),
  67        PCH_GBE_STAT(intr_tcpip_err_count)
  68};
  69
  70#define PCH_GBE_QUEUE_STATS_LEN 0
  71#define PCH_GBE_GLOBAL_STATS_LEN        ARRAY_SIZE(pch_gbe_gstrings_stats)
  72#define PCH_GBE_STATS_LEN (PCH_GBE_GLOBAL_STATS_LEN + PCH_GBE_QUEUE_STATS_LEN)
  73
  74#define PCH_GBE_MAC_REGS_LEN    (sizeof(struct pch_gbe_regs) / 4)
  75#define PCH_GBE_REGS_LEN        (PCH_GBE_MAC_REGS_LEN + PCH_GBE_PHY_REGS_LEN)
  76/**
  77 * pch_gbe_get_settings - Get device-specific settings
  78 * @netdev: Network interface device structure
  79 * @ecmd:   Ethtool command
  80 * Returns:
  81 *      0:                      Successful.
  82 *      Negative value:         Failed.
  83 */
  84static int pch_gbe_get_settings(struct net_device *netdev,
  85                                 struct ethtool_cmd *ecmd)
  86{
  87        struct pch_gbe_adapter *adapter = netdev_priv(netdev);
  88        int ret;
  89
  90        ret = mii_ethtool_gset(&adapter->mii, ecmd);
  91        ecmd->supported &= ~(SUPPORTED_TP | SUPPORTED_1000baseT_Half);
  92        ecmd->advertising &= ~(ADVERTISED_TP | ADVERTISED_1000baseT_Half);
  93
  94        if (!netif_carrier_ok(adapter->netdev))
  95                ethtool_cmd_speed_set(ecmd, -1);
  96        return ret;
  97}
  98
  99/**
 100 * pch_gbe_set_settings - Set device-specific settings
 101 * @netdev: Network interface device structure
 102 * @ecmd:   Ethtool command
 103 * Returns:
 104 *      0:                      Successful.
 105 *      Negative value:         Failed.
 106 */
 107static int pch_gbe_set_settings(struct net_device *netdev,
 108                                 struct ethtool_cmd *ecmd)
 109{
 110        struct pch_gbe_adapter *adapter = netdev_priv(netdev);
 111        struct pch_gbe_hw *hw = &adapter->hw;
 112        u32 speed = ethtool_cmd_speed(ecmd);
 113        int ret;
 114
 115        pch_gbe_hal_write_phy_reg(hw, MII_BMCR, BMCR_RESET);
 116
 117        /* when set_settings() is called with a ethtool_cmd previously
 118         * filled by get_settings() on a down link, speed is -1: */
 119        if (speed == UINT_MAX) {
 120                speed = SPEED_1000;
 121                ecmd->duplex = DUPLEX_FULL;
 122        }
 123        ret = mii_ethtool_sset(&adapter->mii, ecmd);
 124        if (ret) {
 125                netdev_err(netdev, "Error: mii_ethtool_sset\n");
 126                return ret;
 127        }
 128        hw->mac.link_speed = speed;
 129        hw->mac.link_duplex = ecmd->duplex;
 130        hw->phy.autoneg_advertised = ecmd->advertising;
 131        hw->mac.autoneg = ecmd->autoneg;
 132
 133        /* reset the link */
 134        if (netif_running(adapter->netdev)) {
 135                pch_gbe_down(adapter);
 136                ret = pch_gbe_up(adapter);
 137        } else {
 138                pch_gbe_reset(adapter);
 139        }
 140        return ret;
 141}
 142
 143/**
 144 * pch_gbe_get_regs_len - Report the size of device registers
 145 * @netdev: Network interface device structure
 146 * Returns: the size of device registers.
 147 */
 148static int pch_gbe_get_regs_len(struct net_device *netdev)
 149{
 150        return PCH_GBE_REGS_LEN * (int)sizeof(u32);
 151}
 152
 153/**
 154 * pch_gbe_get_drvinfo - Report driver information
 155 * @netdev:  Network interface device structure
 156 * @drvinfo: Driver information structure
 157 */
 158static void pch_gbe_get_drvinfo(struct net_device *netdev,
 159                                 struct ethtool_drvinfo *drvinfo)
 160{
 161        struct pch_gbe_adapter *adapter = netdev_priv(netdev);
 162
 163        strlcpy(drvinfo->driver, KBUILD_MODNAME, sizeof(drvinfo->driver));
 164        strlcpy(drvinfo->version, pch_driver_version, sizeof(drvinfo->version));
 165        strlcpy(drvinfo->bus_info, pci_name(adapter->pdev),
 166                sizeof(drvinfo->bus_info));
 167        drvinfo->regdump_len = pch_gbe_get_regs_len(netdev);
 168}
 169
 170/**
 171 * pch_gbe_get_regs - Get device registers
 172 * @netdev: Network interface device structure
 173 * @regs:   Ethtool register structure
 174 * @p:      Buffer pointer of read device register date
 175 */
 176static void pch_gbe_get_regs(struct net_device *netdev,
 177                                struct ethtool_regs *regs, void *p)
 178{
 179        struct pch_gbe_adapter *adapter = netdev_priv(netdev);
 180        struct pch_gbe_hw *hw = &adapter->hw;
 181        struct pci_dev *pdev = adapter->pdev;
 182        u32 *regs_buff = p;
 183        u16 i, tmp;
 184
 185        regs->version = 0x1000000 | (__u32)pdev->revision << 16 | pdev->device;
 186        for (i = 0; i < PCH_GBE_MAC_REGS_LEN; i++)
 187                *regs_buff++ = ioread32(&hw->reg->INT_ST + i);
 188        /* PHY register */
 189        for (i = 0; i < PCH_GBE_PHY_REGS_LEN; i++) {
 190                pch_gbe_hal_read_phy_reg(&adapter->hw, i, &tmp);
 191                *regs_buff++ = tmp;
 192        }
 193}
 194
 195/**
 196 * pch_gbe_get_wol - Report whether Wake-on-Lan is enabled
 197 * @netdev: Network interface device structure
 198 * @wol:    Wake-on-Lan information
 199 */
 200static void pch_gbe_get_wol(struct net_device *netdev,
 201                                struct ethtool_wolinfo *wol)
 202{
 203        struct pch_gbe_adapter *adapter = netdev_priv(netdev);
 204
 205        wol->supported = WAKE_UCAST | WAKE_MCAST | WAKE_BCAST | WAKE_MAGIC;
 206        wol->wolopts = 0;
 207
 208        if ((adapter->wake_up_evt & PCH_GBE_WLC_IND))
 209                wol->wolopts |= WAKE_UCAST;
 210        if ((adapter->wake_up_evt & PCH_GBE_WLC_MLT))
 211                wol->wolopts |= WAKE_MCAST;
 212        if ((adapter->wake_up_evt & PCH_GBE_WLC_BR))
 213                wol->wolopts |= WAKE_BCAST;
 214        if ((adapter->wake_up_evt & PCH_GBE_WLC_MP))
 215                wol->wolopts |= WAKE_MAGIC;
 216}
 217
 218/**
 219 * pch_gbe_set_wol - Turn Wake-on-Lan on or off
 220 * @netdev: Network interface device structure
 221 * @wol:    Pointer of wake-on-Lan information straucture
 222 * Returns:
 223 *      0:                      Successful.
 224 *      Negative value:         Failed.
 225 */
 226static int pch_gbe_set_wol(struct net_device *netdev,
 227                                struct ethtool_wolinfo *wol)
 228{
 229        struct pch_gbe_adapter *adapter = netdev_priv(netdev);
 230
 231        if ((wol->wolopts & (WAKE_PHY | WAKE_ARP | WAKE_MAGICSECURE)))
 232                return -EOPNOTSUPP;
 233        /* these settings will always override what we currently have */
 234        adapter->wake_up_evt = 0;
 235
 236        if ((wol->wolopts & WAKE_UCAST))
 237                adapter->wake_up_evt |= PCH_GBE_WLC_IND;
 238        if ((wol->wolopts & WAKE_MCAST))
 239                adapter->wake_up_evt |= PCH_GBE_WLC_MLT;
 240        if ((wol->wolopts & WAKE_BCAST))
 241                adapter->wake_up_evt |= PCH_GBE_WLC_BR;
 242        if ((wol->wolopts & WAKE_MAGIC))
 243                adapter->wake_up_evt |= PCH_GBE_WLC_MP;
 244        return 0;
 245}
 246
 247/**
 248 * pch_gbe_nway_reset - Restart autonegotiation
 249 * @netdev: Network interface device structure
 250 * Returns:
 251 *      0:                      Successful.
 252 *      Negative value:         Failed.
 253 */
 254static int pch_gbe_nway_reset(struct net_device *netdev)
 255{
 256        struct pch_gbe_adapter *adapter = netdev_priv(netdev);
 257
 258        return mii_nway_restart(&adapter->mii);
 259}
 260
 261/**
 262 * pch_gbe_get_ringparam - Report ring sizes
 263 * @netdev:  Network interface device structure
 264 * @ring:    Ring param structure
 265 */
 266static void pch_gbe_get_ringparam(struct net_device *netdev,
 267                                        struct ethtool_ringparam *ring)
 268{
 269        struct pch_gbe_adapter *adapter = netdev_priv(netdev);
 270        struct pch_gbe_tx_ring *txdr = adapter->tx_ring;
 271        struct pch_gbe_rx_ring *rxdr = adapter->rx_ring;
 272
 273        ring->rx_max_pending = PCH_GBE_MAX_RXD;
 274        ring->tx_max_pending = PCH_GBE_MAX_TXD;
 275        ring->rx_pending = rxdr->count;
 276        ring->tx_pending = txdr->count;
 277}
 278
 279/**
 280 * pch_gbe_set_ringparam - Set ring sizes
 281 * @netdev:  Network interface device structure
 282 * @ring:    Ring param structure
 283 * Returns
 284 *      0:                      Successful.
 285 *      Negative value:         Failed.
 286 */
 287static int pch_gbe_set_ringparam(struct net_device *netdev,
 288                                        struct ethtool_ringparam *ring)
 289{
 290        struct pch_gbe_adapter *adapter = netdev_priv(netdev);
 291        struct pch_gbe_tx_ring *txdr, *tx_old;
 292        struct pch_gbe_rx_ring *rxdr, *rx_old;
 293        int tx_ring_size, rx_ring_size;
 294        int err = 0;
 295
 296        if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
 297                return -EINVAL;
 298        tx_ring_size = (int)sizeof(struct pch_gbe_tx_ring);
 299        rx_ring_size = (int)sizeof(struct pch_gbe_rx_ring);
 300
 301        if ((netif_running(adapter->netdev)))
 302                pch_gbe_down(adapter);
 303        tx_old = adapter->tx_ring;
 304        rx_old = adapter->rx_ring;
 305
 306        txdr = kzalloc(tx_ring_size, GFP_KERNEL);
 307        if (!txdr) {
 308                err = -ENOMEM;
 309                goto err_alloc_tx;
 310        }
 311        rxdr = kzalloc(rx_ring_size, GFP_KERNEL);
 312        if (!rxdr) {
 313                err = -ENOMEM;
 314                goto err_alloc_rx;
 315        }
 316        adapter->tx_ring = txdr;
 317        adapter->rx_ring = rxdr;
 318
 319        rxdr->count =
 320                clamp_val(ring->rx_pending, PCH_GBE_MIN_RXD, PCH_GBE_MAX_RXD);
 321        rxdr->count = roundup(rxdr->count, PCH_GBE_RX_DESC_MULTIPLE);
 322
 323        txdr->count =
 324                clamp_val(ring->tx_pending, PCH_GBE_MIN_RXD, PCH_GBE_MAX_RXD);
 325        txdr->count = roundup(txdr->count, PCH_GBE_TX_DESC_MULTIPLE);
 326
 327        if ((netif_running(adapter->netdev))) {
 328                /* Try to get new resources before deleting old */
 329                err = pch_gbe_setup_rx_resources(adapter, adapter->rx_ring);
 330                if (err)
 331                        goto err_setup_rx;
 332                err = pch_gbe_setup_tx_resources(adapter, adapter->tx_ring);
 333                if (err)
 334                        goto err_setup_tx;
 335                /* save the new, restore the old in order to free it,
 336                 * then restore the new back again */
 337#ifdef RINGFREE
 338                adapter->rx_ring = rx_old;
 339                adapter->tx_ring = tx_old;
 340                pch_gbe_free_rx_resources(adapter, adapter->rx_ring);
 341                pch_gbe_free_tx_resources(adapter, adapter->tx_ring);
 342                kfree(tx_old);
 343                kfree(rx_old);
 344                adapter->rx_ring = rxdr;
 345                adapter->tx_ring = txdr;
 346#else
 347                pch_gbe_free_rx_resources(adapter, rx_old);
 348                pch_gbe_free_tx_resources(adapter, tx_old);
 349                kfree(tx_old);
 350                kfree(rx_old);
 351                adapter->rx_ring = rxdr;
 352                adapter->tx_ring = txdr;
 353#endif
 354                err = pch_gbe_up(adapter);
 355        }
 356        return err;
 357
 358err_setup_tx:
 359        pch_gbe_free_rx_resources(adapter, adapter->rx_ring);
 360err_setup_rx:
 361        adapter->rx_ring = rx_old;
 362        adapter->tx_ring = tx_old;
 363        kfree(rxdr);
 364err_alloc_rx:
 365        kfree(txdr);
 366err_alloc_tx:
 367        if (netif_running(adapter->netdev))
 368                pch_gbe_up(adapter);
 369        return err;
 370}
 371
 372/**
 373 * pch_gbe_get_pauseparam - Report pause parameters
 374 * @netdev:  Network interface device structure
 375 * @pause:   Pause parameters structure
 376 */
 377static void pch_gbe_get_pauseparam(struct net_device *netdev,
 378                                       struct ethtool_pauseparam *pause)
 379{
 380        struct pch_gbe_adapter *adapter = netdev_priv(netdev);
 381        struct pch_gbe_hw *hw = &adapter->hw;
 382
 383        pause->autoneg =
 384            ((hw->mac.fc_autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE);
 385
 386        if (hw->mac.fc == PCH_GBE_FC_RX_PAUSE) {
 387                pause->rx_pause = 1;
 388        } else if (hw->mac.fc == PCH_GBE_FC_TX_PAUSE) {
 389                pause->tx_pause = 1;
 390        } else if (hw->mac.fc == PCH_GBE_FC_FULL) {
 391                pause->rx_pause = 1;
 392                pause->tx_pause = 1;
 393        }
 394}
 395
 396/**
 397 * pch_gbe_set_pauseparam - Set pause paramters
 398 * @netdev:  Network interface device structure
 399 * @pause:   Pause parameters structure
 400 * Returns:
 401 *      0:                      Successful.
 402 *      Negative value:         Failed.
 403 */
 404static int pch_gbe_set_pauseparam(struct net_device *netdev,
 405                                       struct ethtool_pauseparam *pause)
 406{
 407        struct pch_gbe_adapter *adapter = netdev_priv(netdev);
 408        struct pch_gbe_hw *hw = &adapter->hw;
 409        int ret = 0;
 410
 411        hw->mac.fc_autoneg = pause->autoneg;
 412        if ((pause->rx_pause) && (pause->tx_pause))
 413                hw->mac.fc = PCH_GBE_FC_FULL;
 414        else if ((pause->rx_pause) && (!pause->tx_pause))
 415                hw->mac.fc = PCH_GBE_FC_RX_PAUSE;
 416        else if ((!pause->rx_pause) && (pause->tx_pause))
 417                hw->mac.fc = PCH_GBE_FC_TX_PAUSE;
 418        else if ((!pause->rx_pause) && (!pause->tx_pause))
 419                hw->mac.fc = PCH_GBE_FC_NONE;
 420
 421        if (hw->mac.fc_autoneg == AUTONEG_ENABLE) {
 422                if ((netif_running(adapter->netdev))) {
 423                        pch_gbe_down(adapter);
 424                        ret = pch_gbe_up(adapter);
 425                } else {
 426                        pch_gbe_reset(adapter);
 427                }
 428        } else {
 429                ret = pch_gbe_mac_force_mac_fc(hw);
 430        }
 431        return ret;
 432}
 433
 434/**
 435 * pch_gbe_get_strings - Return a set of strings that describe the requested
 436 *                       objects
 437 * @netdev:    Network interface device structure
 438 * @stringset: Select the stringset. [ETH_SS_TEST] [ETH_SS_STATS]
 439 * @data:      Pointer of read string data.
 440 */
 441static void pch_gbe_get_strings(struct net_device *netdev, u32 stringset,
 442                                        u8 *data)
 443{
 444        u8 *p = data;
 445        int i;
 446
 447        switch (stringset) {
 448        case (u32) ETH_SS_STATS:
 449                for (i = 0; i < PCH_GBE_GLOBAL_STATS_LEN; i++) {
 450                        memcpy(p, pch_gbe_gstrings_stats[i].string,
 451                               ETH_GSTRING_LEN);
 452                        p += ETH_GSTRING_LEN;
 453                }
 454                break;
 455        }
 456}
 457
 458/**
 459 * pch_gbe_get_ethtool_stats - Return statistics about the device
 460 * @netdev: Network interface device structure
 461 * @stats:  Ethtool statue structure
 462 * @data:   Pointer of read status area
 463 */
 464static void pch_gbe_get_ethtool_stats(struct net_device *netdev,
 465                                  struct ethtool_stats *stats, u64 *data)
 466{
 467        struct pch_gbe_adapter *adapter = netdev_priv(netdev);
 468        int i;
 469        const struct pch_gbe_stats *gstats = pch_gbe_gstrings_stats;
 470        char *hw_stats = (char *)&adapter->stats;
 471
 472        pch_gbe_update_stats(adapter);
 473        for (i = 0; i < PCH_GBE_GLOBAL_STATS_LEN; i++) {
 474                char *p = hw_stats + gstats->offset;
 475                data[i] = gstats->size == sizeof(u64) ? *(u64 *)p:(*(u32 *)p);
 476                gstats++;
 477        }
 478}
 479
 480static int pch_gbe_get_sset_count(struct net_device *netdev, int sset)
 481{
 482        switch (sset) {
 483        case ETH_SS_STATS:
 484                return PCH_GBE_STATS_LEN;
 485        default:
 486                return -EOPNOTSUPP;
 487        }
 488}
 489
 490static const struct ethtool_ops pch_gbe_ethtool_ops = {
 491        .get_settings = pch_gbe_get_settings,
 492        .set_settings = pch_gbe_set_settings,
 493        .get_drvinfo = pch_gbe_get_drvinfo,
 494        .get_regs_len = pch_gbe_get_regs_len,
 495        .get_regs = pch_gbe_get_regs,
 496        .get_wol = pch_gbe_get_wol,
 497        .set_wol = pch_gbe_set_wol,
 498        .nway_reset = pch_gbe_nway_reset,
 499        .get_link = ethtool_op_get_link,
 500        .get_ringparam = pch_gbe_get_ringparam,
 501        .set_ringparam = pch_gbe_set_ringparam,
 502        .get_pauseparam = pch_gbe_get_pauseparam,
 503        .set_pauseparam = pch_gbe_set_pauseparam,
 504        .get_strings = pch_gbe_get_strings,
 505        .get_ethtool_stats = pch_gbe_get_ethtool_stats,
 506        .get_sset_count = pch_gbe_get_sset_count,
 507};
 508
 509void pch_gbe_set_ethtool_ops(struct net_device *netdev)
 510{
 511        SET_ETHTOOL_OPS(netdev, &pch_gbe_ethtool_ops);
 512}
 513