Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  drivers/net/ethernet/freescale/gianfar_ethtool.c
0004  *
0005  *  Gianfar Ethernet Driver
0006  *  Ethtool support for Gianfar Enet
0007  *  Based on e1000 ethtool support
0008  *
0009  *  Author: Andy Fleming
0010  *  Maintainer: Kumar Gala
0011  *  Modifier: Sandeep Gopalpet <sandeep.kumar@freescale.com>
0012  *
0013  *  Copyright 2003-2006, 2008-2009, 2011 Freescale Semiconductor, Inc.
0014  */
0015 
0016 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0017 
0018 #include <linux/kernel.h>
0019 #include <linux/string.h>
0020 #include <linux/errno.h>
0021 #include <linux/interrupt.h>
0022 #include <linux/delay.h>
0023 #include <linux/netdevice.h>
0024 #include <linux/etherdevice.h>
0025 #include <linux/net_tstamp.h>
0026 #include <linux/skbuff.h>
0027 #include <linux/spinlock.h>
0028 #include <linux/mm.h>
0029 
0030 #include <asm/io.h>
0031 #include <asm/irq.h>
0032 #include <linux/uaccess.h>
0033 #include <linux/module.h>
0034 #include <linux/crc32.h>
0035 #include <asm/types.h>
0036 #include <linux/ethtool.h>
0037 #include <linux/mii.h>
0038 #include <linux/phy.h>
0039 #include <linux/sort.h>
0040 #include <linux/if_vlan.h>
0041 #include <linux/of_platform.h>
0042 #include <linux/fsl/ptp_qoriq.h>
0043 
0044 #include "gianfar.h"
0045 
0046 #define GFAR_MAX_COAL_USECS 0xffff
0047 #define GFAR_MAX_COAL_FRAMES 0xff
0048 
0049 static const char stat_gstrings[][ETH_GSTRING_LEN] = {
0050     /* extra stats */
0051     "rx-allocation-errors",
0052     "rx-large-frame-errors",
0053     "rx-short-frame-errors",
0054     "rx-non-octet-errors",
0055     "rx-crc-errors",
0056     "rx-overrun-errors",
0057     "rx-busy-errors",
0058     "rx-babbling-errors",
0059     "rx-truncated-frames",
0060     "ethernet-bus-error",
0061     "tx-babbling-errors",
0062     "tx-underrun-errors",
0063     "tx-timeout-errors",
0064     /* rmon stats */
0065     "tx-rx-64-frames",
0066     "tx-rx-65-127-frames",
0067     "tx-rx-128-255-frames",
0068     "tx-rx-256-511-frames",
0069     "tx-rx-512-1023-frames",
0070     "tx-rx-1024-1518-frames",
0071     "tx-rx-1519-1522-good-vlan",
0072     "rx-bytes",
0073     "rx-packets",
0074     "rx-fcs-errors",
0075     "receive-multicast-packet",
0076     "receive-broadcast-packet",
0077     "rx-control-frame-packets",
0078     "rx-pause-frame-packets",
0079     "rx-unknown-op-code",
0080     "rx-alignment-error",
0081     "rx-frame-length-error",
0082     "rx-code-error",
0083     "rx-carrier-sense-error",
0084     "rx-undersize-packets",
0085     "rx-oversize-packets",
0086     "rx-fragmented-frames",
0087     "rx-jabber-frames",
0088     "rx-dropped-frames",
0089     "tx-byte-counter",
0090     "tx-packets",
0091     "tx-multicast-packets",
0092     "tx-broadcast-packets",
0093     "tx-pause-control-frames",
0094     "tx-deferral-packets",
0095     "tx-excessive-deferral-packets",
0096     "tx-single-collision-packets",
0097     "tx-multiple-collision-packets",
0098     "tx-late-collision-packets",
0099     "tx-excessive-collision-packets",
0100     "tx-total-collision",
0101     "reserved",
0102     "tx-dropped-frames",
0103     "tx-jabber-frames",
0104     "tx-fcs-errors",
0105     "tx-control-frames",
0106     "tx-oversize-frames",
0107     "tx-undersize-frames",
0108     "tx-fragmented-frames",
0109 };
0110 
0111 /* Fill in a buffer with the strings which correspond to the
0112  * stats */
0113 static void gfar_gstrings(struct net_device *dev, u32 stringset, u8 * buf)
0114 {
0115     struct gfar_private *priv = netdev_priv(dev);
0116 
0117     if (priv->device_flags & FSL_GIANFAR_DEV_HAS_RMON)
0118         memcpy(buf, stat_gstrings, GFAR_STATS_LEN * ETH_GSTRING_LEN);
0119     else
0120         memcpy(buf, stat_gstrings,
0121                GFAR_EXTRA_STATS_LEN * ETH_GSTRING_LEN);
0122 }
0123 
0124 /* Fill in an array of 64-bit statistics from various sources.
0125  * This array will be appended to the end of the ethtool_stats
0126  * structure, and returned to user space
0127  */
0128 static void gfar_fill_stats(struct net_device *dev, struct ethtool_stats *dummy,
0129                 u64 *buf)
0130 {
0131     int i;
0132     struct gfar_private *priv = netdev_priv(dev);
0133     struct gfar __iomem *regs = priv->gfargrp[0].regs;
0134     atomic64_t *extra = (atomic64_t *)&priv->extra_stats;
0135 
0136     for (i = 0; i < GFAR_EXTRA_STATS_LEN; i++)
0137         buf[i] = atomic64_read(&extra[i]);
0138 
0139     if (priv->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
0140         u32 __iomem *rmon = (u32 __iomem *) &regs->rmon;
0141 
0142         for (; i < GFAR_STATS_LEN; i++, rmon++)
0143             buf[i] = (u64) gfar_read(rmon);
0144     }
0145 }
0146 
0147 static int gfar_sset_count(struct net_device *dev, int sset)
0148 {
0149     struct gfar_private *priv = netdev_priv(dev);
0150 
0151     switch (sset) {
0152     case ETH_SS_STATS:
0153         if (priv->device_flags & FSL_GIANFAR_DEV_HAS_RMON)
0154             return GFAR_STATS_LEN;
0155         else
0156             return GFAR_EXTRA_STATS_LEN;
0157     default:
0158         return -EOPNOTSUPP;
0159     }
0160 }
0161 
0162 /* Fills in the drvinfo structure with some basic info */
0163 static void gfar_gdrvinfo(struct net_device *dev,
0164               struct ethtool_drvinfo *drvinfo)
0165 {
0166     strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
0167 }
0168 
0169 /* Return the length of the register structure */
0170 static int gfar_reglen(struct net_device *dev)
0171 {
0172     return sizeof (struct gfar);
0173 }
0174 
0175 /* Return a dump of the GFAR register space */
0176 static void gfar_get_regs(struct net_device *dev, struct ethtool_regs *regs,
0177               void *regbuf)
0178 {
0179     int i;
0180     struct gfar_private *priv = netdev_priv(dev);
0181     u32 __iomem *theregs = (u32 __iomem *) priv->gfargrp[0].regs;
0182     u32 *buf = (u32 *) regbuf;
0183 
0184     for (i = 0; i < sizeof (struct gfar) / sizeof (u32); i++)
0185         buf[i] = gfar_read(&theregs[i]);
0186 }
0187 
0188 /* Convert microseconds to ethernet clock ticks, which changes
0189  * depending on what speed the controller is running at */
0190 static unsigned int gfar_usecs2ticks(struct gfar_private *priv,
0191                      unsigned int usecs)
0192 {
0193     struct net_device *ndev = priv->ndev;
0194     struct phy_device *phydev = ndev->phydev;
0195     unsigned int count;
0196 
0197     /* The timer is different, depending on the interface speed */
0198     switch (phydev->speed) {
0199     case SPEED_1000:
0200         count = GFAR_GBIT_TIME;
0201         break;
0202     case SPEED_100:
0203         count = GFAR_100_TIME;
0204         break;
0205     case SPEED_10:
0206     default:
0207         count = GFAR_10_TIME;
0208         break;
0209     }
0210 
0211     /* Make sure we return a number greater than 0
0212      * if usecs > 0 */
0213     return DIV_ROUND_UP(usecs * 1000, count);
0214 }
0215 
0216 /* Convert ethernet clock ticks to microseconds */
0217 static unsigned int gfar_ticks2usecs(struct gfar_private *priv,
0218                      unsigned int ticks)
0219 {
0220     struct net_device *ndev = priv->ndev;
0221     struct phy_device *phydev = ndev->phydev;
0222     unsigned int count;
0223 
0224     /* The timer is different, depending on the interface speed */
0225     switch (phydev->speed) {
0226     case SPEED_1000:
0227         count = GFAR_GBIT_TIME;
0228         break;
0229     case SPEED_100:
0230         count = GFAR_100_TIME;
0231         break;
0232     case SPEED_10:
0233     default:
0234         count = GFAR_10_TIME;
0235         break;
0236     }
0237 
0238     /* Make sure we return a number greater than 0 */
0239     /* if ticks is > 0 */
0240     return (ticks * count) / 1000;
0241 }
0242 
0243 /* Get the coalescing parameters, and put them in the cvals
0244  * structure.  */
0245 static int gfar_gcoalesce(struct net_device *dev,
0246               struct ethtool_coalesce *cvals,
0247               struct kernel_ethtool_coalesce *kernel_coal,
0248               struct netlink_ext_ack *extack)
0249 {
0250     struct gfar_private *priv = netdev_priv(dev);
0251     struct gfar_priv_rx_q *rx_queue = NULL;
0252     struct gfar_priv_tx_q *tx_queue = NULL;
0253     unsigned long rxtime;
0254     unsigned long rxcount;
0255     unsigned long txtime;
0256     unsigned long txcount;
0257 
0258     if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE))
0259         return -EOPNOTSUPP;
0260 
0261     if (!dev->phydev)
0262         return -ENODEV;
0263 
0264     rx_queue = priv->rx_queue[0];
0265     tx_queue = priv->tx_queue[0];
0266 
0267     rxtime  = get_ictt_value(rx_queue->rxic);
0268     rxcount = get_icft_value(rx_queue->rxic);
0269     txtime  = get_ictt_value(tx_queue->txic);
0270     txcount = get_icft_value(tx_queue->txic);
0271     cvals->rx_coalesce_usecs = gfar_ticks2usecs(priv, rxtime);
0272     cvals->rx_max_coalesced_frames = rxcount;
0273 
0274     cvals->tx_coalesce_usecs = gfar_ticks2usecs(priv, txtime);
0275     cvals->tx_max_coalesced_frames = txcount;
0276 
0277     return 0;
0278 }
0279 
0280 /* Change the coalescing values.
0281  * Both cvals->*_usecs and cvals->*_frames have to be > 0
0282  * in order for coalescing to be active
0283  */
0284 static int gfar_scoalesce(struct net_device *dev,
0285               struct ethtool_coalesce *cvals,
0286               struct kernel_ethtool_coalesce *kernel_coal,
0287               struct netlink_ext_ack *extack)
0288 {
0289     struct gfar_private *priv = netdev_priv(dev);
0290     int i, err = 0;
0291 
0292     if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_COALESCE))
0293         return -EOPNOTSUPP;
0294 
0295     if (!dev->phydev)
0296         return -ENODEV;
0297 
0298     /* Check the bounds of the values */
0299     if (cvals->rx_coalesce_usecs > GFAR_MAX_COAL_USECS) {
0300         netdev_info(dev, "Coalescing is limited to %d microseconds\n",
0301                 GFAR_MAX_COAL_USECS);
0302         return -EINVAL;
0303     }
0304 
0305     if (cvals->rx_max_coalesced_frames > GFAR_MAX_COAL_FRAMES) {
0306         netdev_info(dev, "Coalescing is limited to %d frames\n",
0307                 GFAR_MAX_COAL_FRAMES);
0308         return -EINVAL;
0309     }
0310 
0311     /* Check the bounds of the values */
0312     if (cvals->tx_coalesce_usecs > GFAR_MAX_COAL_USECS) {
0313         netdev_info(dev, "Coalescing is limited to %d microseconds\n",
0314                 GFAR_MAX_COAL_USECS);
0315         return -EINVAL;
0316     }
0317 
0318     if (cvals->tx_max_coalesced_frames > GFAR_MAX_COAL_FRAMES) {
0319         netdev_info(dev, "Coalescing is limited to %d frames\n",
0320                 GFAR_MAX_COAL_FRAMES);
0321         return -EINVAL;
0322     }
0323 
0324     while (test_and_set_bit_lock(GFAR_RESETTING, &priv->state))
0325         cpu_relax();
0326 
0327     /* Set up rx coalescing */
0328     if ((cvals->rx_coalesce_usecs == 0) ||
0329         (cvals->rx_max_coalesced_frames == 0)) {
0330         for (i = 0; i < priv->num_rx_queues; i++)
0331             priv->rx_queue[i]->rxcoalescing = 0;
0332     } else {
0333         for (i = 0; i < priv->num_rx_queues; i++)
0334             priv->rx_queue[i]->rxcoalescing = 1;
0335     }
0336 
0337     for (i = 0; i < priv->num_rx_queues; i++) {
0338         priv->rx_queue[i]->rxic = mk_ic_value(
0339             cvals->rx_max_coalesced_frames,
0340             gfar_usecs2ticks(priv, cvals->rx_coalesce_usecs));
0341     }
0342 
0343     /* Set up tx coalescing */
0344     if ((cvals->tx_coalesce_usecs == 0) ||
0345         (cvals->tx_max_coalesced_frames == 0)) {
0346         for (i = 0; i < priv->num_tx_queues; i++)
0347             priv->tx_queue[i]->txcoalescing = 0;
0348     } else {
0349         for (i = 0; i < priv->num_tx_queues; i++)
0350             priv->tx_queue[i]->txcoalescing = 1;
0351     }
0352 
0353     for (i = 0; i < priv->num_tx_queues; i++) {
0354         priv->tx_queue[i]->txic = mk_ic_value(
0355             cvals->tx_max_coalesced_frames,
0356             gfar_usecs2ticks(priv, cvals->tx_coalesce_usecs));
0357     }
0358 
0359     if (dev->flags & IFF_UP) {
0360         stop_gfar(dev);
0361         err = startup_gfar(dev);
0362     } else {
0363         gfar_mac_reset(priv);
0364     }
0365 
0366     clear_bit_unlock(GFAR_RESETTING, &priv->state);
0367 
0368     return err;
0369 }
0370 
0371 /* Fills in rvals with the current ring parameters.  Currently,
0372  * rx, rx_mini, and rx_jumbo rings are the same size, as mini and
0373  * jumbo are ignored by the driver */
0374 static void gfar_gringparam(struct net_device *dev,
0375                 struct ethtool_ringparam *rvals,
0376                 struct kernel_ethtool_ringparam *kernel_rvals,
0377                 struct netlink_ext_ack *extack)
0378 {
0379     struct gfar_private *priv = netdev_priv(dev);
0380     struct gfar_priv_tx_q *tx_queue = NULL;
0381     struct gfar_priv_rx_q *rx_queue = NULL;
0382 
0383     tx_queue = priv->tx_queue[0];
0384     rx_queue = priv->rx_queue[0];
0385 
0386     rvals->rx_max_pending = GFAR_RX_MAX_RING_SIZE;
0387     rvals->rx_mini_max_pending = GFAR_RX_MAX_RING_SIZE;
0388     rvals->rx_jumbo_max_pending = GFAR_RX_MAX_RING_SIZE;
0389     rvals->tx_max_pending = GFAR_TX_MAX_RING_SIZE;
0390 
0391     /* Values changeable by the user.  The valid values are
0392      * in the range 1 to the "*_max_pending" counterpart above.
0393      */
0394     rvals->rx_pending = rx_queue->rx_ring_size;
0395     rvals->rx_mini_pending = rx_queue->rx_ring_size;
0396     rvals->rx_jumbo_pending = rx_queue->rx_ring_size;
0397     rvals->tx_pending = tx_queue->tx_ring_size;
0398 }
0399 
0400 /* Change the current ring parameters, stopping the controller if
0401  * necessary so that we don't mess things up while we're in motion.
0402  */
0403 static int gfar_sringparam(struct net_device *dev,
0404                struct ethtool_ringparam *rvals,
0405                struct kernel_ethtool_ringparam *kernel_rvals,
0406                struct netlink_ext_ack *extack)
0407 {
0408     struct gfar_private *priv = netdev_priv(dev);
0409     int err = 0, i;
0410 
0411     if (rvals->rx_pending > GFAR_RX_MAX_RING_SIZE)
0412         return -EINVAL;
0413 
0414     if (!is_power_of_2(rvals->rx_pending)) {
0415         netdev_err(dev, "Ring sizes must be a power of 2\n");
0416         return -EINVAL;
0417     }
0418 
0419     if (rvals->tx_pending > GFAR_TX_MAX_RING_SIZE)
0420         return -EINVAL;
0421 
0422     if (!is_power_of_2(rvals->tx_pending)) {
0423         netdev_err(dev, "Ring sizes must be a power of 2\n");
0424         return -EINVAL;
0425     }
0426 
0427     while (test_and_set_bit_lock(GFAR_RESETTING, &priv->state))
0428         cpu_relax();
0429 
0430     if (dev->flags & IFF_UP)
0431         stop_gfar(dev);
0432 
0433     /* Change the sizes */
0434     for (i = 0; i < priv->num_rx_queues; i++)
0435         priv->rx_queue[i]->rx_ring_size = rvals->rx_pending;
0436 
0437     for (i = 0; i < priv->num_tx_queues; i++)
0438         priv->tx_queue[i]->tx_ring_size = rvals->tx_pending;
0439 
0440     /* Rebuild the rings with the new size */
0441     if (dev->flags & IFF_UP)
0442         err = startup_gfar(dev);
0443 
0444     clear_bit_unlock(GFAR_RESETTING, &priv->state);
0445 
0446     return err;
0447 }
0448 
0449 static void gfar_gpauseparam(struct net_device *dev,
0450                  struct ethtool_pauseparam *epause)
0451 {
0452     struct gfar_private *priv = netdev_priv(dev);
0453 
0454     epause->autoneg = !!priv->pause_aneg_en;
0455     epause->rx_pause = !!priv->rx_pause_en;
0456     epause->tx_pause = !!priv->tx_pause_en;
0457 }
0458 
0459 static int gfar_spauseparam(struct net_device *dev,
0460                 struct ethtool_pauseparam *epause)
0461 {
0462     struct gfar_private *priv = netdev_priv(dev);
0463     struct phy_device *phydev = dev->phydev;
0464     struct gfar __iomem *regs = priv->gfargrp[0].regs;
0465 
0466     if (!phydev)
0467         return -ENODEV;
0468 
0469     if (!phy_validate_pause(phydev, epause))
0470         return -EINVAL;
0471 
0472     priv->rx_pause_en = priv->tx_pause_en = 0;
0473     phy_set_asym_pause(phydev, epause->rx_pause, epause->tx_pause);
0474     if (epause->rx_pause) {
0475         priv->rx_pause_en = 1;
0476 
0477         if (epause->tx_pause) {
0478             priv->tx_pause_en = 1;
0479         }
0480     } else if (epause->tx_pause) {
0481         priv->tx_pause_en = 1;
0482     }
0483 
0484     if (epause->autoneg)
0485         priv->pause_aneg_en = 1;
0486     else
0487         priv->pause_aneg_en = 0;
0488 
0489     if (!epause->autoneg) {
0490         u32 tempval = gfar_read(&regs->maccfg1);
0491 
0492         tempval &= ~(MACCFG1_TX_FLOW | MACCFG1_RX_FLOW);
0493 
0494         priv->tx_actual_en = 0;
0495         if (priv->tx_pause_en) {
0496             priv->tx_actual_en = 1;
0497             tempval |= MACCFG1_TX_FLOW;
0498         }
0499 
0500         if (priv->rx_pause_en)
0501             tempval |= MACCFG1_RX_FLOW;
0502         gfar_write(&regs->maccfg1, tempval);
0503     }
0504 
0505     return 0;
0506 }
0507 
0508 int gfar_set_features(struct net_device *dev, netdev_features_t features)
0509 {
0510     netdev_features_t changed = dev->features ^ features;
0511     struct gfar_private *priv = netdev_priv(dev);
0512     int err = 0;
0513 
0514     if (!(changed & (NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX |
0515              NETIF_F_RXCSUM)))
0516         return 0;
0517 
0518     while (test_and_set_bit_lock(GFAR_RESETTING, &priv->state))
0519         cpu_relax();
0520 
0521     dev->features = features;
0522 
0523     if (dev->flags & IFF_UP) {
0524         /* Now we take down the rings to rebuild them */
0525         stop_gfar(dev);
0526         err = startup_gfar(dev);
0527     } else {
0528         gfar_mac_reset(priv);
0529     }
0530 
0531     clear_bit_unlock(GFAR_RESETTING, &priv->state);
0532 
0533     return err;
0534 }
0535 
0536 static uint32_t gfar_get_msglevel(struct net_device *dev)
0537 {
0538     struct gfar_private *priv = netdev_priv(dev);
0539 
0540     return priv->msg_enable;
0541 }
0542 
0543 static void gfar_set_msglevel(struct net_device *dev, uint32_t data)
0544 {
0545     struct gfar_private *priv = netdev_priv(dev);
0546 
0547     priv->msg_enable = data;
0548 }
0549 
0550 #ifdef CONFIG_PM
0551 static void gfar_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
0552 {
0553     struct gfar_private *priv = netdev_priv(dev);
0554 
0555     wol->supported = 0;
0556     wol->wolopts = 0;
0557 
0558     if (priv->wol_supported & GFAR_WOL_MAGIC)
0559         wol->supported |= WAKE_MAGIC;
0560 
0561     if (priv->wol_supported & GFAR_WOL_FILER_UCAST)
0562         wol->supported |= WAKE_UCAST;
0563 
0564     if (priv->wol_opts & GFAR_WOL_MAGIC)
0565         wol->wolopts |= WAKE_MAGIC;
0566 
0567     if (priv->wol_opts & GFAR_WOL_FILER_UCAST)
0568         wol->wolopts |= WAKE_UCAST;
0569 }
0570 
0571 static int gfar_set_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
0572 {
0573     struct gfar_private *priv = netdev_priv(dev);
0574     u16 wol_opts = 0;
0575     int err;
0576 
0577     if (!priv->wol_supported && wol->wolopts)
0578         return -EINVAL;
0579 
0580     if (wol->wolopts & ~(WAKE_MAGIC | WAKE_UCAST))
0581         return -EINVAL;
0582 
0583     if (wol->wolopts & WAKE_MAGIC) {
0584         wol_opts |= GFAR_WOL_MAGIC;
0585     } else {
0586         if (wol->wolopts & WAKE_UCAST)
0587             wol_opts |= GFAR_WOL_FILER_UCAST;
0588     }
0589 
0590     wol_opts &= priv->wol_supported;
0591     priv->wol_opts = 0;
0592 
0593     err = device_set_wakeup_enable(priv->dev, wol_opts);
0594     if (err)
0595         return err;
0596 
0597     priv->wol_opts = wol_opts;
0598 
0599     return 0;
0600 }
0601 #endif
0602 
0603 static void ethflow_to_filer_rules (struct gfar_private *priv, u64 ethflow)
0604 {
0605     u32 fcr = 0x0, fpr = FPR_FILER_MASK;
0606 
0607     if (ethflow & RXH_L2DA) {
0608         fcr = RQFCR_PID_DAH | RQFCR_CMP_NOMATCH |
0609               RQFCR_HASH | RQFCR_AND | RQFCR_HASHTBL_0;
0610         priv->ftp_rqfpr[priv->cur_filer_idx] = fpr;
0611         priv->ftp_rqfcr[priv->cur_filer_idx] = fcr;
0612         gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
0613         priv->cur_filer_idx = priv->cur_filer_idx - 1;
0614 
0615         fcr = RQFCR_PID_DAL | RQFCR_CMP_NOMATCH |
0616               RQFCR_HASH | RQFCR_AND | RQFCR_HASHTBL_0;
0617         priv->ftp_rqfpr[priv->cur_filer_idx] = fpr;
0618         priv->ftp_rqfcr[priv->cur_filer_idx] = fcr;
0619         gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
0620         priv->cur_filer_idx = priv->cur_filer_idx - 1;
0621     }
0622 
0623     if (ethflow & RXH_VLAN) {
0624         fcr = RQFCR_PID_VID | RQFCR_CMP_NOMATCH | RQFCR_HASH |
0625               RQFCR_AND | RQFCR_HASHTBL_0;
0626         gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
0627         priv->ftp_rqfpr[priv->cur_filer_idx] = fpr;
0628         priv->ftp_rqfcr[priv->cur_filer_idx] = fcr;
0629         priv->cur_filer_idx = priv->cur_filer_idx - 1;
0630     }
0631 
0632     if (ethflow & RXH_IP_SRC) {
0633         fcr = RQFCR_PID_SIA | RQFCR_CMP_NOMATCH | RQFCR_HASH |
0634               RQFCR_AND | RQFCR_HASHTBL_0;
0635         priv->ftp_rqfpr[priv->cur_filer_idx] = fpr;
0636         priv->ftp_rqfcr[priv->cur_filer_idx] = fcr;
0637         gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
0638         priv->cur_filer_idx = priv->cur_filer_idx - 1;
0639     }
0640 
0641     if (ethflow & (RXH_IP_DST)) {
0642         fcr = RQFCR_PID_DIA | RQFCR_CMP_NOMATCH | RQFCR_HASH |
0643               RQFCR_AND | RQFCR_HASHTBL_0;
0644         priv->ftp_rqfpr[priv->cur_filer_idx] = fpr;
0645         priv->ftp_rqfcr[priv->cur_filer_idx] = fcr;
0646         gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
0647         priv->cur_filer_idx = priv->cur_filer_idx - 1;
0648     }
0649 
0650     if (ethflow & RXH_L3_PROTO) {
0651         fcr = RQFCR_PID_L4P | RQFCR_CMP_NOMATCH | RQFCR_HASH |
0652               RQFCR_AND | RQFCR_HASHTBL_0;
0653         priv->ftp_rqfpr[priv->cur_filer_idx] = fpr;
0654         priv->ftp_rqfcr[priv->cur_filer_idx] = fcr;
0655         gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
0656         priv->cur_filer_idx = priv->cur_filer_idx - 1;
0657     }
0658 
0659     if (ethflow & RXH_L4_B_0_1) {
0660         fcr = RQFCR_PID_SPT | RQFCR_CMP_NOMATCH | RQFCR_HASH |
0661               RQFCR_AND | RQFCR_HASHTBL_0;
0662         priv->ftp_rqfpr[priv->cur_filer_idx] = fpr;
0663         priv->ftp_rqfcr[priv->cur_filer_idx] = fcr;
0664         gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
0665         priv->cur_filer_idx = priv->cur_filer_idx - 1;
0666     }
0667 
0668     if (ethflow & RXH_L4_B_2_3) {
0669         fcr = RQFCR_PID_DPT | RQFCR_CMP_NOMATCH | RQFCR_HASH |
0670               RQFCR_AND | RQFCR_HASHTBL_0;
0671         priv->ftp_rqfpr[priv->cur_filer_idx] = fpr;
0672         priv->ftp_rqfcr[priv->cur_filer_idx] = fcr;
0673         gfar_write_filer(priv, priv->cur_filer_idx, fcr, fpr);
0674         priv->cur_filer_idx = priv->cur_filer_idx - 1;
0675     }
0676 }
0677 
0678 static int gfar_ethflow_to_filer_table(struct gfar_private *priv, u64 ethflow,
0679                        u64 class)
0680 {
0681     unsigned int cmp_rqfpr;
0682     unsigned int *local_rqfpr;
0683     unsigned int *local_rqfcr;
0684     int i = 0x0, k = 0x0;
0685     int j = MAX_FILER_IDX, l = 0x0;
0686     int ret = 1;
0687 
0688     local_rqfpr = kmalloc_array(MAX_FILER_IDX + 1, sizeof(unsigned int),
0689                     GFP_KERNEL);
0690     local_rqfcr = kmalloc_array(MAX_FILER_IDX + 1, sizeof(unsigned int),
0691                     GFP_KERNEL);
0692     if (!local_rqfpr || !local_rqfcr) {
0693         ret = 0;
0694         goto err;
0695     }
0696 
0697     switch (class) {
0698     case TCP_V4_FLOW:
0699         cmp_rqfpr = RQFPR_IPV4 |RQFPR_TCP;
0700         break;
0701     case UDP_V4_FLOW:
0702         cmp_rqfpr = RQFPR_IPV4 |RQFPR_UDP;
0703         break;
0704     case TCP_V6_FLOW:
0705         cmp_rqfpr = RQFPR_IPV6 |RQFPR_TCP;
0706         break;
0707     case UDP_V6_FLOW:
0708         cmp_rqfpr = RQFPR_IPV6 |RQFPR_UDP;
0709         break;
0710     default:
0711         netdev_err(priv->ndev,
0712                "Right now this class is not supported\n");
0713         ret = 0;
0714         goto err;
0715     }
0716 
0717     for (i = 0; i < MAX_FILER_IDX + 1; i++) {
0718         local_rqfpr[j] = priv->ftp_rqfpr[i];
0719         local_rqfcr[j] = priv->ftp_rqfcr[i];
0720         j--;
0721         if ((priv->ftp_rqfcr[i] ==
0722              (RQFCR_PID_PARSE | RQFCR_CLE | RQFCR_AND)) &&
0723             (priv->ftp_rqfpr[i] == cmp_rqfpr))
0724             break;
0725     }
0726 
0727     if (i == MAX_FILER_IDX + 1) {
0728         netdev_err(priv->ndev,
0729                "No parse rule found, can't create hash rules\n");
0730         ret = 0;
0731         goto err;
0732     }
0733 
0734     /* If a match was found, then it begins the starting of a cluster rule
0735      * if it was already programmed, we need to overwrite these rules
0736      */
0737     for (l = i+1; l < MAX_FILER_IDX; l++) {
0738         if ((priv->ftp_rqfcr[l] & RQFCR_CLE) &&
0739             !(priv->ftp_rqfcr[l] & RQFCR_AND)) {
0740             priv->ftp_rqfcr[l] = RQFCR_CLE | RQFCR_CMP_EXACT |
0741                          RQFCR_HASHTBL_0 | RQFCR_PID_MASK;
0742             priv->ftp_rqfpr[l] = FPR_FILER_MASK;
0743             gfar_write_filer(priv, l, priv->ftp_rqfcr[l],
0744                      priv->ftp_rqfpr[l]);
0745             break;
0746         }
0747 
0748         if (!(priv->ftp_rqfcr[l] & RQFCR_CLE) &&
0749             (priv->ftp_rqfcr[l] & RQFCR_AND))
0750             continue;
0751         else {
0752             local_rqfpr[j] = priv->ftp_rqfpr[l];
0753             local_rqfcr[j] = priv->ftp_rqfcr[l];
0754             j--;
0755         }
0756     }
0757 
0758     priv->cur_filer_idx = l - 1;
0759 
0760     /* hash rules */
0761     ethflow_to_filer_rules(priv, ethflow);
0762 
0763     /* Write back the popped out rules again */
0764     for (k = j+1; k < MAX_FILER_IDX; k++) {
0765         priv->ftp_rqfpr[priv->cur_filer_idx] = local_rqfpr[k];
0766         priv->ftp_rqfcr[priv->cur_filer_idx] = local_rqfcr[k];
0767         gfar_write_filer(priv, priv->cur_filer_idx,
0768                  local_rqfcr[k], local_rqfpr[k]);
0769         if (!priv->cur_filer_idx)
0770             break;
0771         priv->cur_filer_idx = priv->cur_filer_idx - 1;
0772     }
0773 
0774 err:
0775     kfree(local_rqfcr);
0776     kfree(local_rqfpr);
0777     return ret;
0778 }
0779 
0780 static int gfar_set_hash_opts(struct gfar_private *priv,
0781                   struct ethtool_rxnfc *cmd)
0782 {
0783     /* write the filer rules here */
0784     if (!gfar_ethflow_to_filer_table(priv, cmd->data, cmd->flow_type))
0785         return -EINVAL;
0786 
0787     return 0;
0788 }
0789 
0790 static int gfar_check_filer_hardware(struct gfar_private *priv)
0791 {
0792     struct gfar __iomem *regs = priv->gfargrp[0].regs;
0793     u32 i;
0794 
0795     /* Check if we are in FIFO mode */
0796     i = gfar_read(&regs->ecntrl);
0797     i &= ECNTRL_FIFM;
0798     if (i == ECNTRL_FIFM) {
0799         netdev_notice(priv->ndev, "Interface in FIFO mode\n");
0800         i = gfar_read(&regs->rctrl);
0801         i &= RCTRL_PRSDEP_MASK | RCTRL_PRSFM;
0802         if (i == (RCTRL_PRSDEP_MASK | RCTRL_PRSFM)) {
0803             netdev_info(priv->ndev,
0804                     "Receive Queue Filtering enabled\n");
0805         } else {
0806             netdev_warn(priv->ndev,
0807                     "Receive Queue Filtering disabled\n");
0808             return -EOPNOTSUPP;
0809         }
0810     }
0811     /* Or in standard mode */
0812     else {
0813         i = gfar_read(&regs->rctrl);
0814         i &= RCTRL_PRSDEP_MASK;
0815         if (i == RCTRL_PRSDEP_MASK) {
0816             netdev_info(priv->ndev,
0817                     "Receive Queue Filtering enabled\n");
0818         } else {
0819             netdev_warn(priv->ndev,
0820                     "Receive Queue Filtering disabled\n");
0821             return -EOPNOTSUPP;
0822         }
0823     }
0824 
0825     /* Sets the properties for arbitrary filer rule
0826      * to the first 4 Layer 4 Bytes
0827      */
0828     gfar_write(&regs->rbifx, 0xC0C1C2C3);
0829     return 0;
0830 }
0831 
0832 /* Write a mask to filer cache */
0833 static void gfar_set_mask(u32 mask, struct filer_table *tab)
0834 {
0835     tab->fe[tab->index].ctrl = RQFCR_AND | RQFCR_PID_MASK | RQFCR_CMP_EXACT;
0836     tab->fe[tab->index].prop = mask;
0837     tab->index++;
0838 }
0839 
0840 /* Sets parse bits (e.g. IP or TCP) */
0841 static void gfar_set_parse_bits(u32 value, u32 mask, struct filer_table *tab)
0842 {
0843     gfar_set_mask(mask, tab);
0844     tab->fe[tab->index].ctrl = RQFCR_CMP_EXACT | RQFCR_PID_PARSE |
0845                    RQFCR_AND;
0846     tab->fe[tab->index].prop = value;
0847     tab->index++;
0848 }
0849 
0850 static void gfar_set_general_attribute(u32 value, u32 mask, u32 flag,
0851                        struct filer_table *tab)
0852 {
0853     gfar_set_mask(mask, tab);
0854     tab->fe[tab->index].ctrl = RQFCR_CMP_EXACT | RQFCR_AND | flag;
0855     tab->fe[tab->index].prop = value;
0856     tab->index++;
0857 }
0858 
0859 /* For setting a tuple of value and mask of type flag
0860  * Example:
0861  * IP-Src = 10.0.0.0/255.0.0.0
0862  * value: 0x0A000000 mask: FF000000 flag: RQFPR_IPV4
0863  *
0864  * Ethtool gives us a value=0 and mask=~0 for don't care a tuple
0865  * For a don't care mask it gives us a 0
0866  *
0867  * The check if don't care and the mask adjustment if mask=0 is done for VLAN
0868  * and MAC stuff on an upper level (due to missing information on this level).
0869  * For these guys we can discard them if they are value=0 and mask=0.
0870  *
0871  * Further the all masks are one-padded for better hardware efficiency.
0872  */
0873 static void gfar_set_attribute(u32 value, u32 mask, u32 flag,
0874                    struct filer_table *tab)
0875 {
0876     switch (flag) {
0877         /* 3bit */
0878     case RQFCR_PID_PRI:
0879         if (!(value | mask))
0880             return;
0881         mask |= RQFCR_PID_PRI_MASK;
0882         break;
0883         /* 8bit */
0884     case RQFCR_PID_L4P:
0885     case RQFCR_PID_TOS:
0886         if (!~(mask | RQFCR_PID_L4P_MASK))
0887             return;
0888         if (!mask)
0889             mask = ~0;
0890         else
0891             mask |= RQFCR_PID_L4P_MASK;
0892         break;
0893         /* 12bit */
0894     case RQFCR_PID_VID:
0895         if (!(value | mask))
0896             return;
0897         mask |= RQFCR_PID_VID_MASK;
0898         break;
0899         /* 16bit */
0900     case RQFCR_PID_DPT:
0901     case RQFCR_PID_SPT:
0902     case RQFCR_PID_ETY:
0903         if (!~(mask | RQFCR_PID_PORT_MASK))
0904             return;
0905         if (!mask)
0906             mask = ~0;
0907         else
0908             mask |= RQFCR_PID_PORT_MASK;
0909         break;
0910         /* 24bit */
0911     case RQFCR_PID_DAH:
0912     case RQFCR_PID_DAL:
0913     case RQFCR_PID_SAH:
0914     case RQFCR_PID_SAL:
0915         if (!(value | mask))
0916             return;
0917         mask |= RQFCR_PID_MAC_MASK;
0918         break;
0919         /* for all real 32bit masks */
0920     default:
0921         if (!~mask)
0922             return;
0923         if (!mask)
0924             mask = ~0;
0925         break;
0926     }
0927     gfar_set_general_attribute(value, mask, flag, tab);
0928 }
0929 
0930 /* Translates value and mask for UDP, TCP or SCTP */
0931 static void gfar_set_basic_ip(struct ethtool_tcpip4_spec *value,
0932                   struct ethtool_tcpip4_spec *mask,
0933                   struct filer_table *tab)
0934 {
0935     gfar_set_attribute(be32_to_cpu(value->ip4src),
0936                be32_to_cpu(mask->ip4src),
0937                RQFCR_PID_SIA, tab);
0938     gfar_set_attribute(be32_to_cpu(value->ip4dst),
0939                be32_to_cpu(mask->ip4dst),
0940                RQFCR_PID_DIA, tab);
0941     gfar_set_attribute(be16_to_cpu(value->pdst),
0942                be16_to_cpu(mask->pdst),
0943                RQFCR_PID_DPT, tab);
0944     gfar_set_attribute(be16_to_cpu(value->psrc),
0945                be16_to_cpu(mask->psrc),
0946                RQFCR_PID_SPT, tab);
0947     gfar_set_attribute(value->tos, mask->tos, RQFCR_PID_TOS, tab);
0948 }
0949 
0950 /* Translates value and mask for RAW-IP4 */
0951 static void gfar_set_user_ip(struct ethtool_usrip4_spec *value,
0952                  struct ethtool_usrip4_spec *mask,
0953                  struct filer_table *tab)
0954 {
0955     gfar_set_attribute(be32_to_cpu(value->ip4src),
0956                be32_to_cpu(mask->ip4src),
0957                RQFCR_PID_SIA, tab);
0958     gfar_set_attribute(be32_to_cpu(value->ip4dst),
0959                be32_to_cpu(mask->ip4dst),
0960                RQFCR_PID_DIA, tab);
0961     gfar_set_attribute(value->tos, mask->tos, RQFCR_PID_TOS, tab);
0962     gfar_set_attribute(value->proto, mask->proto, RQFCR_PID_L4P, tab);
0963     gfar_set_attribute(be32_to_cpu(value->l4_4_bytes),
0964                be32_to_cpu(mask->l4_4_bytes),
0965                RQFCR_PID_ARB, tab);
0966 
0967 }
0968 
0969 /* Translates value and mask for ETHER spec */
0970 static void gfar_set_ether(struct ethhdr *value, struct ethhdr *mask,
0971                struct filer_table *tab)
0972 {
0973     u32 upper_temp_mask = 0;
0974     u32 lower_temp_mask = 0;
0975 
0976     /* Source address */
0977     if (!is_broadcast_ether_addr(mask->h_source)) {
0978         if (is_zero_ether_addr(mask->h_source)) {
0979             upper_temp_mask = 0xFFFFFFFF;
0980             lower_temp_mask = 0xFFFFFFFF;
0981         } else {
0982             upper_temp_mask = mask->h_source[0] << 16 |
0983                       mask->h_source[1] << 8  |
0984                       mask->h_source[2];
0985             lower_temp_mask = mask->h_source[3] << 16 |
0986                       mask->h_source[4] << 8  |
0987                       mask->h_source[5];
0988         }
0989         /* Upper 24bit */
0990         gfar_set_attribute(value->h_source[0] << 16 |
0991                    value->h_source[1] << 8  |
0992                    value->h_source[2],
0993                    upper_temp_mask, RQFCR_PID_SAH, tab);
0994         /* And the same for the lower part */
0995         gfar_set_attribute(value->h_source[3] << 16 |
0996                    value->h_source[4] << 8  |
0997                    value->h_source[5],
0998                    lower_temp_mask, RQFCR_PID_SAL, tab);
0999     }
1000     /* Destination address */
1001     if (!is_broadcast_ether_addr(mask->h_dest)) {
1002         /* Special for destination is limited broadcast */
1003         if ((is_broadcast_ether_addr(value->h_dest) &&
1004             is_zero_ether_addr(mask->h_dest))) {
1005             gfar_set_parse_bits(RQFPR_EBC, RQFPR_EBC, tab);
1006         } else {
1007             if (is_zero_ether_addr(mask->h_dest)) {
1008                 upper_temp_mask = 0xFFFFFFFF;
1009                 lower_temp_mask = 0xFFFFFFFF;
1010             } else {
1011                 upper_temp_mask = mask->h_dest[0] << 16 |
1012                           mask->h_dest[1] << 8  |
1013                           mask->h_dest[2];
1014                 lower_temp_mask = mask->h_dest[3] << 16 |
1015                           mask->h_dest[4] << 8  |
1016                           mask->h_dest[5];
1017             }
1018 
1019             /* Upper 24bit */
1020             gfar_set_attribute(value->h_dest[0] << 16 |
1021                        value->h_dest[1] << 8  |
1022                        value->h_dest[2],
1023                        upper_temp_mask, RQFCR_PID_DAH, tab);
1024             /* And the same for the lower part */
1025             gfar_set_attribute(value->h_dest[3] << 16 |
1026                        value->h_dest[4] << 8  |
1027                        value->h_dest[5],
1028                        lower_temp_mask, RQFCR_PID_DAL, tab);
1029         }
1030     }
1031 
1032     gfar_set_attribute(be16_to_cpu(value->h_proto),
1033                be16_to_cpu(mask->h_proto),
1034                RQFCR_PID_ETY, tab);
1035 }
1036 
1037 static inline u32 vlan_tci_vid(struct ethtool_rx_flow_spec *rule)
1038 {
1039     return be16_to_cpu(rule->h_ext.vlan_tci) & VLAN_VID_MASK;
1040 }
1041 
1042 static inline u32 vlan_tci_vidm(struct ethtool_rx_flow_spec *rule)
1043 {
1044     return be16_to_cpu(rule->m_ext.vlan_tci) & VLAN_VID_MASK;
1045 }
1046 
1047 static inline u32 vlan_tci_cfi(struct ethtool_rx_flow_spec *rule)
1048 {
1049     return be16_to_cpu(rule->h_ext.vlan_tci) & VLAN_CFI_MASK;
1050 }
1051 
1052 static inline u32 vlan_tci_cfim(struct ethtool_rx_flow_spec *rule)
1053 {
1054     return be16_to_cpu(rule->m_ext.vlan_tci) & VLAN_CFI_MASK;
1055 }
1056 
1057 static inline u32 vlan_tci_prio(struct ethtool_rx_flow_spec *rule)
1058 {
1059     return (be16_to_cpu(rule->h_ext.vlan_tci) & VLAN_PRIO_MASK) >>
1060         VLAN_PRIO_SHIFT;
1061 }
1062 
1063 static inline u32 vlan_tci_priom(struct ethtool_rx_flow_spec *rule)
1064 {
1065     return (be16_to_cpu(rule->m_ext.vlan_tci) & VLAN_PRIO_MASK) >>
1066         VLAN_PRIO_SHIFT;
1067 }
1068 
1069 /* Convert a rule to binary filter format of gianfar */
1070 static int gfar_convert_to_filer(struct ethtool_rx_flow_spec *rule,
1071                  struct filer_table *tab)
1072 {
1073     u32 vlan = 0, vlan_mask = 0;
1074     u32 id = 0, id_mask = 0;
1075     u32 cfi = 0, cfi_mask = 0;
1076     u32 prio = 0, prio_mask = 0;
1077     u32 old_index = tab->index;
1078 
1079     /* Check if vlan is wanted */
1080     if ((rule->flow_type & FLOW_EXT) &&
1081         (rule->m_ext.vlan_tci != cpu_to_be16(0xFFFF))) {
1082         if (!rule->m_ext.vlan_tci)
1083             rule->m_ext.vlan_tci = cpu_to_be16(0xFFFF);
1084 
1085         vlan = RQFPR_VLN;
1086         vlan_mask = RQFPR_VLN;
1087 
1088         /* Separate the fields */
1089         id = vlan_tci_vid(rule);
1090         id_mask = vlan_tci_vidm(rule);
1091         cfi = vlan_tci_cfi(rule);
1092         cfi_mask = vlan_tci_cfim(rule);
1093         prio = vlan_tci_prio(rule);
1094         prio_mask = vlan_tci_priom(rule);
1095 
1096         if (cfi_mask) {
1097             if (cfi)
1098                 vlan |= RQFPR_CFI;
1099             vlan_mask |= RQFPR_CFI;
1100         }
1101     }
1102 
1103     switch (rule->flow_type & ~FLOW_EXT) {
1104     case TCP_V4_FLOW:
1105         gfar_set_parse_bits(RQFPR_IPV4 | RQFPR_TCP | vlan,
1106                     RQFPR_IPV4 | RQFPR_TCP | vlan_mask, tab);
1107         gfar_set_basic_ip(&rule->h_u.tcp_ip4_spec,
1108                   &rule->m_u.tcp_ip4_spec, tab);
1109         break;
1110     case UDP_V4_FLOW:
1111         gfar_set_parse_bits(RQFPR_IPV4 | RQFPR_UDP | vlan,
1112                     RQFPR_IPV4 | RQFPR_UDP | vlan_mask, tab);
1113         gfar_set_basic_ip(&rule->h_u.udp_ip4_spec,
1114                   &rule->m_u.udp_ip4_spec, tab);
1115         break;
1116     case SCTP_V4_FLOW:
1117         gfar_set_parse_bits(RQFPR_IPV4 | vlan, RQFPR_IPV4 | vlan_mask,
1118                     tab);
1119         gfar_set_attribute(132, 0, RQFCR_PID_L4P, tab);
1120         gfar_set_basic_ip((struct ethtool_tcpip4_spec *)&rule->h_u,
1121                   (struct ethtool_tcpip4_spec *)&rule->m_u,
1122                   tab);
1123         break;
1124     case IP_USER_FLOW:
1125         gfar_set_parse_bits(RQFPR_IPV4 | vlan, RQFPR_IPV4 | vlan_mask,
1126                     tab);
1127         gfar_set_user_ip((struct ethtool_usrip4_spec *) &rule->h_u,
1128                  (struct ethtool_usrip4_spec *) &rule->m_u,
1129                  tab);
1130         break;
1131     case ETHER_FLOW:
1132         if (vlan)
1133             gfar_set_parse_bits(vlan, vlan_mask, tab);
1134         gfar_set_ether((struct ethhdr *) &rule->h_u,
1135                    (struct ethhdr *) &rule->m_u, tab);
1136         break;
1137     default:
1138         return -1;
1139     }
1140 
1141     /* Set the vlan attributes in the end */
1142     if (vlan) {
1143         gfar_set_attribute(id, id_mask, RQFCR_PID_VID, tab);
1144         gfar_set_attribute(prio, prio_mask, RQFCR_PID_PRI, tab);
1145     }
1146 
1147     /* If there has been nothing written till now, it must be a default */
1148     if (tab->index == old_index) {
1149         gfar_set_mask(0xFFFFFFFF, tab);
1150         tab->fe[tab->index].ctrl = 0x20;
1151         tab->fe[tab->index].prop = 0x0;
1152         tab->index++;
1153     }
1154 
1155     /* Remove last AND */
1156     tab->fe[tab->index - 1].ctrl &= (~RQFCR_AND);
1157 
1158     /* Specify which queue to use or to drop */
1159     if (rule->ring_cookie == RX_CLS_FLOW_DISC)
1160         tab->fe[tab->index - 1].ctrl |= RQFCR_RJE;
1161     else
1162         tab->fe[tab->index - 1].ctrl |= (rule->ring_cookie << 10);
1163 
1164     /* Only big enough entries can be clustered */
1165     if (tab->index > (old_index + 2)) {
1166         tab->fe[old_index + 1].ctrl |= RQFCR_CLE;
1167         tab->fe[tab->index - 1].ctrl |= RQFCR_CLE;
1168     }
1169 
1170     /* In rare cases the cache can be full while there is
1171      * free space in hw
1172      */
1173     if (tab->index > MAX_FILER_CACHE_IDX - 1)
1174         return -EBUSY;
1175 
1176     return 0;
1177 }
1178 
1179 /* Write the bit-pattern from software's buffer to hardware registers */
1180 static int gfar_write_filer_table(struct gfar_private *priv,
1181                   struct filer_table *tab)
1182 {
1183     u32 i = 0;
1184     if (tab->index > MAX_FILER_IDX - 1)
1185         return -EBUSY;
1186 
1187     /* Fill regular entries */
1188     for (; i < MAX_FILER_IDX && (tab->fe[i].ctrl | tab->fe[i].prop); i++)
1189         gfar_write_filer(priv, i, tab->fe[i].ctrl, tab->fe[i].prop);
1190     /* Fill the rest with fall-troughs */
1191     for (; i < MAX_FILER_IDX; i++)
1192         gfar_write_filer(priv, i, 0x60, 0xFFFFFFFF);
1193     /* Last entry must be default accept
1194      * because that's what people expect
1195      */
1196     gfar_write_filer(priv, i, 0x20, 0x0);
1197 
1198     return 0;
1199 }
1200 
1201 static int gfar_check_capability(struct ethtool_rx_flow_spec *flow,
1202                  struct gfar_private *priv)
1203 {
1204 
1205     if (flow->flow_type & FLOW_EXT) {
1206         if (~flow->m_ext.data[0] || ~flow->m_ext.data[1])
1207             netdev_warn(priv->ndev,
1208                     "User-specific data not supported!\n");
1209         if (~flow->m_ext.vlan_etype)
1210             netdev_warn(priv->ndev,
1211                     "VLAN-etype not supported!\n");
1212     }
1213     if (flow->flow_type == IP_USER_FLOW)
1214         if (flow->h_u.usr_ip4_spec.ip_ver != ETH_RX_NFC_IP4)
1215             netdev_warn(priv->ndev,
1216                     "IP-Version differing from IPv4 not supported!\n");
1217 
1218     return 0;
1219 }
1220 
1221 static int gfar_process_filer_changes(struct gfar_private *priv)
1222 {
1223     struct ethtool_flow_spec_container *j;
1224     struct filer_table *tab;
1225     s32 ret = 0;
1226 
1227     /* So index is set to zero, too! */
1228     tab = kzalloc(sizeof(*tab), GFP_KERNEL);
1229     if (tab == NULL)
1230         return -ENOMEM;
1231 
1232     /* Now convert the existing filer data from flow_spec into
1233      * filer tables binary format
1234      */
1235     list_for_each_entry(j, &priv->rx_list.list, list) {
1236         ret = gfar_convert_to_filer(&j->fs, tab);
1237         if (ret == -EBUSY) {
1238             netdev_err(priv->ndev,
1239                    "Rule not added: No free space!\n");
1240             goto end;
1241         }
1242         if (ret == -1) {
1243             netdev_err(priv->ndev,
1244                    "Rule not added: Unsupported Flow-type!\n");
1245             goto end;
1246         }
1247     }
1248 
1249     /* Write everything to hardware */
1250     ret = gfar_write_filer_table(priv, tab);
1251     if (ret == -EBUSY) {
1252         netdev_err(priv->ndev, "Rule not added: No free space!\n");
1253         goto end;
1254     }
1255 
1256 end:
1257     kfree(tab);
1258     return ret;
1259 }
1260 
1261 static void gfar_invert_masks(struct ethtool_rx_flow_spec *flow)
1262 {
1263     u32 i = 0;
1264 
1265     for (i = 0; i < sizeof(flow->m_u); i++)
1266         flow->m_u.hdata[i] ^= 0xFF;
1267 
1268     flow->m_ext.vlan_etype ^= cpu_to_be16(0xFFFF);
1269     flow->m_ext.vlan_tci ^= cpu_to_be16(0xFFFF);
1270     flow->m_ext.data[0] ^= cpu_to_be32(~0);
1271     flow->m_ext.data[1] ^= cpu_to_be32(~0);
1272 }
1273 
1274 static int gfar_add_cls(struct gfar_private *priv,
1275             struct ethtool_rx_flow_spec *flow)
1276 {
1277     struct ethtool_flow_spec_container *temp, *comp;
1278     int ret = 0;
1279 
1280     temp = kmalloc(sizeof(*temp), GFP_KERNEL);
1281     if (temp == NULL)
1282         return -ENOMEM;
1283     memcpy(&temp->fs, flow, sizeof(temp->fs));
1284 
1285     gfar_invert_masks(&temp->fs);
1286     ret = gfar_check_capability(&temp->fs, priv);
1287     if (ret)
1288         goto clean_mem;
1289     /* Link in the new element at the right @location */
1290     if (list_empty(&priv->rx_list.list)) {
1291         ret = gfar_check_filer_hardware(priv);
1292         if (ret != 0)
1293             goto clean_mem;
1294         list_add(&temp->list, &priv->rx_list.list);
1295         goto process;
1296     } else {
1297         list_for_each_entry(comp, &priv->rx_list.list, list) {
1298             if (comp->fs.location > flow->location) {
1299                 list_add_tail(&temp->list, &comp->list);
1300                 goto process;
1301             }
1302             if (comp->fs.location == flow->location) {
1303                 netdev_err(priv->ndev,
1304                        "Rule not added: ID %d not free!\n",
1305                        flow->location);
1306                 ret = -EBUSY;
1307                 goto clean_mem;
1308             }
1309         }
1310         list_add_tail(&temp->list, &priv->rx_list.list);
1311     }
1312 
1313 process:
1314     priv->rx_list.count++;
1315     ret = gfar_process_filer_changes(priv);
1316     if (ret)
1317         goto clean_list;
1318     return ret;
1319 
1320 clean_list:
1321     priv->rx_list.count--;
1322     list_del(&temp->list);
1323 clean_mem:
1324     kfree(temp);
1325     return ret;
1326 }
1327 
1328 static int gfar_del_cls(struct gfar_private *priv, u32 loc)
1329 {
1330     struct ethtool_flow_spec_container *comp;
1331     u32 ret = -EINVAL;
1332 
1333     if (list_empty(&priv->rx_list.list))
1334         return ret;
1335 
1336     list_for_each_entry(comp, &priv->rx_list.list, list) {
1337         if (comp->fs.location == loc) {
1338             list_del(&comp->list);
1339             kfree(comp);
1340             priv->rx_list.count--;
1341             gfar_process_filer_changes(priv);
1342             ret = 0;
1343             break;
1344         }
1345     }
1346 
1347     return ret;
1348 }
1349 
1350 static int gfar_get_cls(struct gfar_private *priv, struct ethtool_rxnfc *cmd)
1351 {
1352     struct ethtool_flow_spec_container *comp;
1353     u32 ret = -EINVAL;
1354 
1355     list_for_each_entry(comp, &priv->rx_list.list, list) {
1356         if (comp->fs.location == cmd->fs.location) {
1357             memcpy(&cmd->fs, &comp->fs, sizeof(cmd->fs));
1358             gfar_invert_masks(&cmd->fs);
1359             ret = 0;
1360             break;
1361         }
1362     }
1363 
1364     return ret;
1365 }
1366 
1367 static int gfar_get_cls_all(struct gfar_private *priv,
1368                 struct ethtool_rxnfc *cmd, u32 *rule_locs)
1369 {
1370     struct ethtool_flow_spec_container *comp;
1371     u32 i = 0;
1372 
1373     list_for_each_entry(comp, &priv->rx_list.list, list) {
1374         if (i == cmd->rule_cnt)
1375             return -EMSGSIZE;
1376         rule_locs[i] = comp->fs.location;
1377         i++;
1378     }
1379 
1380     cmd->data = MAX_FILER_IDX;
1381     cmd->rule_cnt = i;
1382 
1383     return 0;
1384 }
1385 
1386 static int gfar_set_nfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
1387 {
1388     struct gfar_private *priv = netdev_priv(dev);
1389     int ret = 0;
1390 
1391     if (test_bit(GFAR_RESETTING, &priv->state))
1392         return -EBUSY;
1393 
1394     mutex_lock(&priv->rx_queue_access);
1395 
1396     switch (cmd->cmd) {
1397     case ETHTOOL_SRXFH:
1398         ret = gfar_set_hash_opts(priv, cmd);
1399         break;
1400     case ETHTOOL_SRXCLSRLINS:
1401         if ((cmd->fs.ring_cookie != RX_CLS_FLOW_DISC &&
1402              cmd->fs.ring_cookie >= priv->num_rx_queues) ||
1403             cmd->fs.location >= MAX_FILER_IDX) {
1404             ret = -EINVAL;
1405             break;
1406         }
1407         ret = gfar_add_cls(priv, &cmd->fs);
1408         break;
1409     case ETHTOOL_SRXCLSRLDEL:
1410         ret = gfar_del_cls(priv, cmd->fs.location);
1411         break;
1412     default:
1413         ret = -EINVAL;
1414     }
1415 
1416     mutex_unlock(&priv->rx_queue_access);
1417 
1418     return ret;
1419 }
1420 
1421 static int gfar_get_nfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
1422             u32 *rule_locs)
1423 {
1424     struct gfar_private *priv = netdev_priv(dev);
1425     int ret = 0;
1426 
1427     switch (cmd->cmd) {
1428     case ETHTOOL_GRXRINGS:
1429         cmd->data = priv->num_rx_queues;
1430         break;
1431     case ETHTOOL_GRXCLSRLCNT:
1432         cmd->rule_cnt = priv->rx_list.count;
1433         break;
1434     case ETHTOOL_GRXCLSRULE:
1435         ret = gfar_get_cls(priv, cmd);
1436         break;
1437     case ETHTOOL_GRXCLSRLALL:
1438         ret = gfar_get_cls_all(priv, cmd, rule_locs);
1439         break;
1440     default:
1441         ret = -EINVAL;
1442         break;
1443     }
1444 
1445     return ret;
1446 }
1447 
1448 static int gfar_get_ts_info(struct net_device *dev,
1449                 struct ethtool_ts_info *info)
1450 {
1451     struct gfar_private *priv = netdev_priv(dev);
1452     struct platform_device *ptp_dev;
1453     struct device_node *ptp_node;
1454     struct ptp_qoriq *ptp = NULL;
1455 
1456     info->phc_index = -1;
1457 
1458     if (!(priv->device_flags & FSL_GIANFAR_DEV_HAS_TIMER)) {
1459         info->so_timestamping = SOF_TIMESTAMPING_RX_SOFTWARE |
1460                     SOF_TIMESTAMPING_TX_SOFTWARE |
1461                     SOF_TIMESTAMPING_SOFTWARE;
1462         return 0;
1463     }
1464 
1465     ptp_node = of_find_compatible_node(NULL, NULL, "fsl,etsec-ptp");
1466     if (ptp_node) {
1467         ptp_dev = of_find_device_by_node(ptp_node);
1468         of_node_put(ptp_node);
1469         if (ptp_dev)
1470             ptp = platform_get_drvdata(ptp_dev);
1471     }
1472 
1473     if (ptp)
1474         info->phc_index = ptp->phc_index;
1475 
1476     info->so_timestamping = SOF_TIMESTAMPING_TX_HARDWARE |
1477                 SOF_TIMESTAMPING_RX_HARDWARE |
1478                 SOF_TIMESTAMPING_RAW_HARDWARE |
1479                 SOF_TIMESTAMPING_RX_SOFTWARE |
1480                 SOF_TIMESTAMPING_TX_SOFTWARE |
1481                 SOF_TIMESTAMPING_SOFTWARE;
1482     info->tx_types = (1 << HWTSTAMP_TX_OFF) |
1483              (1 << HWTSTAMP_TX_ON);
1484     info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
1485                (1 << HWTSTAMP_FILTER_ALL);
1486     return 0;
1487 }
1488 
1489 const struct ethtool_ops gfar_ethtool_ops = {
1490     .supported_coalesce_params = ETHTOOL_COALESCE_USECS |
1491                      ETHTOOL_COALESCE_MAX_FRAMES,
1492     .get_drvinfo = gfar_gdrvinfo,
1493     .get_regs_len = gfar_reglen,
1494     .get_regs = gfar_get_regs,
1495     .get_link = ethtool_op_get_link,
1496     .get_coalesce = gfar_gcoalesce,
1497     .set_coalesce = gfar_scoalesce,
1498     .get_ringparam = gfar_gringparam,
1499     .set_ringparam = gfar_sringparam,
1500     .get_pauseparam = gfar_gpauseparam,
1501     .set_pauseparam = gfar_spauseparam,
1502     .get_strings = gfar_gstrings,
1503     .get_sset_count = gfar_sset_count,
1504     .get_ethtool_stats = gfar_fill_stats,
1505     .get_msglevel = gfar_get_msglevel,
1506     .set_msglevel = gfar_set_msglevel,
1507 #ifdef CONFIG_PM
1508     .get_wol = gfar_get_wol,
1509     .set_wol = gfar_set_wol,
1510 #endif
1511     .set_rxnfc = gfar_set_nfc,
1512     .get_rxnfc = gfar_get_nfc,
1513     .get_ts_info = gfar_get_ts_info,
1514     .get_link_ksettings = phy_ethtool_get_link_ksettings,
1515     .set_link_ksettings = phy_ethtool_set_link_ksettings,
1516 };
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!