drivers/net/ethernet/qualcomm/rmnet/rmnet_vnd.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Copyright (c) 2013-2018, The Linux Foundation. All rights reserved.
   3  *
   4  * RMNET Data virtual network driver
   5  */
   6
   7 #include <linux/etherdevice.h>
   8 #include <linux/if_arp.h>
   9 #include <net/pkt_sched.h>
  10 #include "rmnet_config.h"
  11 #include "rmnet_handlers.h"
  12 #include "rmnet_private.h"
  13 #include "rmnet_map.h"
  14 #include "rmnet_vnd.h"
  15
  16 /* RX/TX Fixup */
  17
  18 void rmnet_vnd_rx_fixup(struct sk_buff *skb, struct net_device *dev)
  19 {
  20         struct rmnet_priv *priv = netdev_priv(dev);
  21         struct rmnet_pcpu_stats *pcpu_ptr;
  22
  23         pcpu_ptr = this_cpu_ptr(priv->pcpu_stats);
  24
  25         u64_stats_update_begin(&pcpu_ptr->syncp);
  26         pcpu_ptr->stats.rx_pkts++;
  27         pcpu_ptr->stats.rx_bytes += skb->len;
  28         u64_stats_update_end(&pcpu_ptr->syncp);
  29 }
  30
  31 void rmnet_vnd_tx_fixup(struct sk_buff *skb, struct net_device *dev)
  32 {
  33         struct rmnet_priv *priv = netdev_priv(dev);
  34         struct rmnet_pcpu_stats *pcpu_ptr;
  35
  36         pcpu_ptr = this_cpu_ptr(priv->pcpu_stats);
  37
  38         u64_stats_update_begin(&pcpu_ptr->syncp);
  39         pcpu_ptr->stats.tx_pkts++;
  40         pcpu_ptr->stats.tx_bytes += skb->len;
  41         u64_stats_update_end(&pcpu_ptr->syncp);
  42 }
  43
  44 /* Network Device Operations */
  45
  46 static netdev_tx_t rmnet_vnd_start_xmit(struct sk_buff *skb,
  47                                         struct net_device *dev)
  48 {
  49         struct rmnet_priv *priv;
  50
  51         priv = netdev_priv(dev);
  52         if (priv->real_dev) {
  53                 rmnet_egress_handler(skb);
  54         } else {
  55                 this_cpu_inc(priv->pcpu_stats->stats.tx_drops);
  56                 kfree_skb(skb);
  57         }
  58         return NETDEV_TX_OK;
  59 }
  60
  61 static int rmnet_vnd_change_mtu(struct net_device *rmnet_dev, int new_mtu)
  62 {
  63         if (new_mtu < 0 || new_mtu > RMNET_MAX_PACKET_SIZE)
  64                 return -EINVAL;
  65
  66         rmnet_dev->mtu = new_mtu;
  67         return 0;
  68 }
  69
  70 static int rmnet_vnd_get_iflink(const struct net_device *dev)
  71 {
  72         struct rmnet_priv *priv = netdev_priv(dev);
  73
  74         return priv->real_dev->ifindex;
  75 }
  76
  77 static int rmnet_vnd_init(struct net_device *dev)
  78 {
  79         struct rmnet_priv *priv = netdev_priv(dev);
  80         int err;
  81
  82         priv->pcpu_stats = alloc_percpu(struct rmnet_pcpu_stats);
  83         if (!priv->pcpu_stats)
  84                 return -ENOMEM;
  85
  86         err = gro_cells_init(&priv->gro_cells, dev);
  87         if (err) {
  88                 free_percpu(priv->pcpu_stats);
  89                 return err;
  90         }
  91
  92         return 0;
  93 }
  94
  95 static void rmnet_vnd_uninit(struct net_device *dev)
  96 {
  97         struct rmnet_priv *priv = netdev_priv(dev);
  98
  99         gro_cells_destroy(&priv->gro_cells);
 100         free_percpu(priv->pcpu_stats);
 101 }
 102
 103 static void rmnet_get_stats64(struct net_device *dev,
 104                               struct rtnl_link_stats64 *s)
 105 {
 106         struct rmnet_priv *priv = netdev_priv(dev);
 107         struct rmnet_vnd_stats total_stats;
 108         struct rmnet_pcpu_stats *pcpu_ptr;
 109         unsigned int cpu, start;
 110
 111         memset(&total_stats, 0, sizeof(struct rmnet_vnd_stats));
 112
 113         for_each_possible_cpu(cpu) {
 114                 pcpu_ptr = per_cpu_ptr(priv->pcpu_stats, cpu);
 115
 116                 do {
 117                         start = u64_stats_fetch_begin_irq(&pcpu_ptr->syncp);
 118                         total_stats.rx_pkts += pcpu_ptr->stats.rx_pkts;
 119                         total_stats.rx_bytes += pcpu_ptr->stats.rx_bytes;
 120                         total_stats.tx_pkts += pcpu_ptr->stats.tx_pkts;
 121                         total_stats.tx_bytes += pcpu_ptr->stats.tx_bytes;
 122                 } while (u64_stats_fetch_retry_irq(&pcpu_ptr->syncp, start));
 123
 124                 total_stats.tx_drops += pcpu_ptr->stats.tx_drops;
 125         }
 126
 127         s->rx_packets = total_stats.rx_pkts;
 128         s->rx_bytes = total_stats.rx_bytes;
 129         s->tx_packets = total_stats.tx_pkts;
 130         s->tx_bytes = total_stats.tx_bytes;
 131         s->tx_dropped = total_stats.tx_drops;
 132 }
 133
 134 static const struct net_device_ops rmnet_vnd_ops = {
 135         .ndo_start_xmit = rmnet_vnd_start_xmit,
 136         .ndo_change_mtu = rmnet_vnd_change_mtu,
 137         .ndo_get_iflink = rmnet_vnd_get_iflink,
 138         .ndo_add_slave  = rmnet_add_bridge,
 139         .ndo_del_slave  = rmnet_del_bridge,
 140         .ndo_init       = rmnet_vnd_init,
 141         .ndo_uninit     = rmnet_vnd_uninit,
 142         .ndo_get_stats64 = rmnet_get_stats64,
 143 };
 144
 145 static const char rmnet_gstrings_stats[][ETH_GSTRING_LEN] = {
 146         "Checksum ok",
 147         "Checksum valid bit not set",
 148         "Checksum validation failed",
 149         "Checksum error bad buffer",
 150         "Checksum error bad ip version",
 151         "Checksum error bad transport",
 152         "Checksum skipped on ip fragment",
 153         "Checksum skipped",
 154         "Checksum computed in software",
 155 };
 156
 157 static void rmnet_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
 158 {
 159         switch (stringset) {
 160         case ETH_SS_STATS:
 161                 memcpy(buf, &rmnet_gstrings_stats,
 162                        sizeof(rmnet_gstrings_stats));
 163                 break;
 164         }
 165 }
 166
 167 static int rmnet_get_sset_count(struct net_device *dev, int sset)
 168 {
 169         switch (sset) {
 170         case ETH_SS_STATS:
 171                 return ARRAY_SIZE(rmnet_gstrings_stats);
 172         default:
 173                 return -EOPNOTSUPP;
 174         }
 175 }
 176
 177 static void rmnet_get_ethtool_stats(struct net_device *dev,
 178                                     struct ethtool_stats *stats, u64 *data)
 179 {
 180         struct rmnet_priv *priv = netdev_priv(dev);
 181         struct rmnet_priv_stats *st = &priv->stats;
 182
 183         if (!data)
 184                 return;
 185
 186         memcpy(data, st, ARRAY_SIZE(rmnet_gstrings_stats) * sizeof(u64));
 187 }
 188
 189 static const struct ethtool_ops rmnet_ethtool_ops = {
 190         .get_ethtool_stats = rmnet_get_ethtool_stats,
 191         .get_strings = rmnet_get_strings,
 192         .get_sset_count = rmnet_get_sset_count,
 193 };
 194
 195 /* Called by kernel whenever a new rmnet<n> device is created. Sets MTU,
 196  * flags, ARP type, needed headroom, etc...
 197  */
 198 void rmnet_vnd_setup(struct net_device *rmnet_dev)
 199 {
 200         rmnet_dev->netdev_ops = &rmnet_vnd_ops;
 201         rmnet_dev->mtu = RMNET_DFLT_PACKET_SIZE;
 202         rmnet_dev->needed_headroom = RMNET_NEEDED_HEADROOM;
 203         eth_random_addr(rmnet_dev->dev_addr);
 204         rmnet_dev->tx_queue_len = RMNET_TX_QUEUE_LEN;
 205
 206         /* Raw IP mode */
 207         rmnet_dev->header_ops = NULL;  /* No header */
 208         rmnet_dev->type = ARPHRD_RAWIP;
 209         rmnet_dev->hard_header_len = 0;
 210         rmnet_dev->flags &= ~(IFF_BROADCAST | IFF_MULTICAST);
 211
 212         rmnet_dev->needs_free_netdev = true;
 213         rmnet_dev->ethtool_ops = &rmnet_ethtool_ops;
 214
 215         /* This perm addr will be used as interface identifier by IPv6 */
 216         rmnet_dev->addr_assign_type = NET_ADDR_RANDOM;
 217         eth_random_addr(rmnet_dev->perm_addr);
 218 }
 219
 220 /* Exposed API */
 221
 222 int rmnet_vnd_newlink(u8 id, struct net_device *rmnet_dev,
 223                       struct rmnet_port *port,
 224                       struct net_device *real_dev,
 225                       struct rmnet_endpoint *ep)
 226 {
 227         struct rmnet_priv *priv = netdev_priv(rmnet_dev);
 228         int rc;
 229
 230         if (ep->egress_dev)
 231                 return -EINVAL;
 232
 233         if (rmnet_get_endpoint(port, id))
 234                 return -EBUSY;
 235
 236         rmnet_dev->hw_features = NETIF_F_RXCSUM;
 237         rmnet_dev->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
 238         rmnet_dev->hw_features |= NETIF_F_SG;
 239
 240         priv->real_dev = real_dev;
 241
 242         rc = register_netdevice(rmnet_dev);
 243         if (!rc) {
 244                 ep->egress_dev = rmnet_dev;
 245                 ep->mux_id = id;
 246                 port->nr_rmnet_devs++;
 247
 248                 rmnet_dev->rtnl_link_ops = &rmnet_link_ops;
 249
 250                 priv->mux_id = id;
 251
 252                 netdev_dbg(rmnet_dev, "rmnet dev created\n");
 253         }
 254
 255         return rc;
 256 }
 257
 258 int rmnet_vnd_dellink(u8 id, struct rmnet_port *port,
 259                       struct rmnet_endpoint *ep)
 260 {
 261         if (id >= RMNET_MAX_LOGICAL_EP || !ep->egress_dev)
 262                 return -EINVAL;
 263
 264         ep->egress_dev = NULL;
 265         port->nr_rmnet_devs--;
 266         return 0;
 267 }
 268
 269 u8 rmnet_vnd_get_mux(struct net_device *rmnet_dev)
 270 {
 271         struct rmnet_priv *priv;
 272
 273         priv = netdev_priv(rmnet_dev);
 274         return priv->mux_id;
 275 }
 276
 277 int rmnet_vnd_do_flow_control(struct net_device *rmnet_dev, int enable)
 278 {
 279         netdev_dbg(rmnet_dev, "Setting VND TX queue state to %d\n", enable);
 280         /* Although we expect similar number of enable/disable
 281          * commands, optimize for the disable. That is more
 282          * latency sensitive than enable
 283          */
 284         if (unlikely(enable))
 285                 netif_wake_queue(rmnet_dev);
 286         else
 287                 netif_stop_queue(rmnet_dev);
 288
 289         return 0;
 290 }