drivers/net/mhi_net.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* MHI Network driver - Network over MHI bus
   3  *
   4  * Copyright (C) 2020 Linaro Ltd <loic.poulain@linaro.org>
   5  */
   6
   7 #include <linux/if_arp.h>
   8 #include <linux/mhi.h>
   9 #include <linux/mod_devicetable.h>
  10 #include <linux/module.h>
  11 #include <linux/netdevice.h>
  12 #include <linux/skbuff.h>
  13 #include <linux/u64_stats_sync.h>
  14
  15 #define MHI_NET_MIN_MTU         ETH_MIN_MTU
  16 #define MHI_NET_MAX_MTU         0xffff
  17 #define MHI_NET_DEFAULT_MTU     0x4000
  18
  19 struct mhi_net_stats {
  20         u64_stats_t rx_packets;
  21         u64_stats_t rx_bytes;
  22         u64_stats_t rx_errors;
  23         u64_stats_t rx_dropped;
  24         u64_stats_t tx_packets;
  25         u64_stats_t tx_bytes;
  26         u64_stats_t tx_errors;
  27         u64_stats_t tx_dropped;
  28         atomic_t rx_queued;
  29         struct u64_stats_sync tx_syncp;
  30         struct u64_stats_sync rx_syncp;
  31 };
  32
  33 struct mhi_net_dev {
  34         struct mhi_device *mdev;
  35         struct net_device *ndev;
  36         struct delayed_work rx_refill;
  37         struct mhi_net_stats stats;
  38         u32 rx_queue_sz;
  39 };
  40
  41 static int mhi_ndo_open(struct net_device *ndev)
  42 {
  43         struct mhi_net_dev *mhi_netdev = netdev_priv(ndev);
  44
  45         /* Feed the rx buffer pool */
  46         schedule_delayed_work(&mhi_netdev->rx_refill, 0);
  47
  48         /* Carrier is established via out-of-band channel (e.g. qmi) */
  49         netif_carrier_on(ndev);
  50
  51         netif_start_queue(ndev);
  52
  53         return 0;
  54 }
  55
  56 static int mhi_ndo_stop(struct net_device *ndev)
  57 {
  58         struct mhi_net_dev *mhi_netdev = netdev_priv(ndev);
  59
  60         netif_stop_queue(ndev);
  61         netif_carrier_off(ndev);
  62         cancel_delayed_work_sync(&mhi_netdev->rx_refill);
  63
  64         return 0;
  65 }
  66
  67 static int mhi_ndo_xmit(struct sk_buff *skb, struct net_device *ndev)
  68 {
  69         struct mhi_net_dev *mhi_netdev = netdev_priv(ndev);
  70         struct mhi_device *mdev = mhi_netdev->mdev;
  71         int err;
  72
  73         err = mhi_queue_skb(mdev, DMA_TO_DEVICE, skb, skb->len, MHI_EOT);
  74         if (unlikely(err)) {
  75                 net_err_ratelimited("%s: Failed to queue TX buf (%d)\n",
  76                                     ndev->name, err);
  77
  78                 u64_stats_update_begin(&mhi_netdev->stats.tx_syncp);
  79                 u64_stats_inc(&mhi_netdev->stats.tx_dropped);
  80                 u64_stats_update_end(&mhi_netdev->stats.tx_syncp);
  81
  82                 /* drop the packet */
  83                 dev_kfree_skb_any(skb);
  84         }
  85
  86         if (mhi_queue_is_full(mdev, DMA_TO_DEVICE))
  87                 netif_stop_queue(ndev);
  88
  89         return NETDEV_TX_OK;
  90 }
  91
  92 static void mhi_ndo_get_stats64(struct net_device *ndev,
  93                                 struct rtnl_link_stats64 *stats)
  94 {
  95         struct mhi_net_dev *mhi_netdev = netdev_priv(ndev);
  96         unsigned int start;
  97
  98         do {
  99                 start = u64_stats_fetch_begin_irq(&mhi_netdev->stats.rx_syncp);
 100                 stats->rx_packets = u64_stats_read(&mhi_netdev->stats.rx_packets);
 101                 stats->rx_bytes = u64_stats_read(&mhi_netdev->stats.rx_bytes);
 102                 stats->rx_errors = u64_stats_read(&mhi_netdev->stats.rx_errors);
 103                 stats->rx_dropped = u64_stats_read(&mhi_netdev->stats.rx_dropped);
 104         } while (u64_stats_fetch_retry_irq(&mhi_netdev->stats.rx_syncp, start));
 105
 106         do {
 107                 start = u64_stats_fetch_begin_irq(&mhi_netdev->stats.tx_syncp);
 108                 stats->tx_packets = u64_stats_read(&mhi_netdev->stats.tx_packets);
 109                 stats->tx_bytes = u64_stats_read(&mhi_netdev->stats.tx_bytes);
 110                 stats->tx_errors = u64_stats_read(&mhi_netdev->stats.tx_errors);
 111                 stats->tx_dropped = u64_stats_read(&mhi_netdev->stats.tx_dropped);
 112         } while (u64_stats_fetch_retry_irq(&mhi_netdev->stats.tx_syncp, start));
 113 }
 114
 115 static const struct net_device_ops mhi_netdev_ops = {
 116         .ndo_open               = mhi_ndo_open,
 117         .ndo_stop               = mhi_ndo_stop,
 118         .ndo_start_xmit         = mhi_ndo_xmit,
 119         .ndo_get_stats64        = mhi_ndo_get_stats64,
 120 };
 121
 122 static void mhi_net_setup(struct net_device *ndev)
 123 {
 124         ndev->header_ops = NULL;  /* No header */
 125         ndev->type = ARPHRD_NONE; /* QMAP... */
 126         ndev->hard_header_len = 0;
 127         ndev->addr_len = 0;
 128         ndev->flags = IFF_POINTOPOINT | IFF_NOARP;
 129         ndev->netdev_ops = &mhi_netdev_ops;
 130         ndev->mtu = MHI_NET_DEFAULT_MTU;
 131         ndev->min_mtu = MHI_NET_MIN_MTU;
 132         ndev->max_mtu = MHI_NET_MAX_MTU;
 133         ndev->tx_queue_len = 1000;
 134 }
 135
 136 static void mhi_net_dl_callback(struct mhi_device *mhi_dev,
 137                                 struct mhi_result *mhi_res)
 138 {
 139         struct mhi_net_dev *mhi_netdev = dev_get_drvdata(&mhi_dev->dev);
 140         struct sk_buff *skb = mhi_res->buf_addr;
 141         int remaining;
 142
 143         remaining = atomic_dec_return(&mhi_netdev->stats.rx_queued);
 144
 145         if (unlikely(mhi_res->transaction_status)) {
 146                 dev_kfree_skb_any(skb);
 147
 148                 /* MHI layer stopping/resetting the DL channel */
 149                 if (mhi_res->transaction_status == -ENOTCONN)
 150                         return;
 151
 152                 u64_stats_update_begin(&mhi_netdev->stats.rx_syncp);
 153                 u64_stats_inc(&mhi_netdev->stats.rx_errors);
 154                 u64_stats_update_end(&mhi_netdev->stats.rx_syncp);
 155         } else {
 156                 u64_stats_update_begin(&mhi_netdev->stats.rx_syncp);
 157                 u64_stats_inc(&mhi_netdev->stats.rx_packets);
 158                 u64_stats_add(&mhi_netdev->stats.rx_bytes, mhi_res->bytes_xferd);
 159                 u64_stats_update_end(&mhi_netdev->stats.rx_syncp);
 160
 161                 skb->protocol = htons(ETH_P_MAP);
 162                 skb_put(skb, mhi_res->bytes_xferd);
 163                 netif_rx(skb);
 164         }
 165
 166         /* Refill if RX buffers queue becomes low */
 167         if (remaining <= mhi_netdev->rx_queue_sz / 2)
 168                 schedule_delayed_work(&mhi_netdev->rx_refill, 0);
 169 }
 170
 171 static void mhi_net_ul_callback(struct mhi_device *mhi_dev,
 172                                 struct mhi_result *mhi_res)
 173 {
 174         struct mhi_net_dev *mhi_netdev = dev_get_drvdata(&mhi_dev->dev);
 175         struct net_device *ndev = mhi_netdev->ndev;
 176         struct mhi_device *mdev = mhi_netdev->mdev;
 177         struct sk_buff *skb = mhi_res->buf_addr;
 178
 179         /* Hardware has consumed the buffer, so free the skb (which is not
 180          * freed by the MHI stack) and perform accounting.
 181          */
 182         dev_consume_skb_any(skb);
 183
 184         u64_stats_update_begin(&mhi_netdev->stats.tx_syncp);
 185         if (unlikely(mhi_res->transaction_status)) {
 186
 187                 /* MHI layer stopping/resetting the UL channel */
 188                 if (mhi_res->transaction_status == -ENOTCONN) {
 189                         u64_stats_update_end(&mhi_netdev->stats.tx_syncp);
 190                         return;
 191                 }
 192
 193                 u64_stats_inc(&mhi_netdev->stats.tx_errors);
 194         } else {
 195                 u64_stats_inc(&mhi_netdev->stats.tx_packets);
 196                 u64_stats_add(&mhi_netdev->stats.tx_bytes, mhi_res->bytes_xferd);
 197         }
 198         u64_stats_update_end(&mhi_netdev->stats.tx_syncp);
 199
 200         if (netif_queue_stopped(ndev) && !mhi_queue_is_full(mdev, DMA_TO_DEVICE))
 201                 netif_wake_queue(ndev);
 202 }
 203
 204 static void mhi_net_rx_refill_work(struct work_struct *work)
 205 {
 206         struct mhi_net_dev *mhi_netdev = container_of(work, struct mhi_net_dev,
 207                                                       rx_refill.work);
 208         struct net_device *ndev = mhi_netdev->ndev;
 209         struct mhi_device *mdev = mhi_netdev->mdev;
 210         int size = READ_ONCE(ndev->mtu);
 211         struct sk_buff *skb;
 212         int err;
 213
 214         while (atomic_read(&mhi_netdev->stats.rx_queued) < mhi_netdev->rx_queue_sz) {
 215                 skb = netdev_alloc_skb(ndev, size);
 216                 if (unlikely(!skb))
 217                         break;
 218
 219                 err = mhi_queue_skb(mdev, DMA_FROM_DEVICE, skb, size, MHI_EOT);
 220                 if (unlikely(err)) {
 221                         net_err_ratelimited("%s: Failed to queue RX buf (%d)\n",
 222                                             ndev->name, err);
 223                         kfree_skb(skb);
 224                         break;
 225                 }
 226
 227                 atomic_inc(&mhi_netdev->stats.rx_queued);
 228
 229                 /* Do not hog the CPU if rx buffers are consumed faster than
 230                  * queued (unlikely).
 231                  */
 232                 cond_resched();
 233         }
 234
 235         /* If we're still starved of rx buffers, reschedule later */
 236         if (unlikely(!atomic_read(&mhi_netdev->stats.rx_queued)))
 237                 schedule_delayed_work(&mhi_netdev->rx_refill, HZ / 2);
 238 }
 239
 240 static int mhi_net_probe(struct mhi_device *mhi_dev,
 241                          const struct mhi_device_id *id)
 242 {
 243         const char *netname = (char *)id->driver_data;
 244         struct device *dev = &mhi_dev->dev;
 245         struct mhi_net_dev *mhi_netdev;
 246         struct net_device *ndev;
 247         int err;
 248
 249         ndev = alloc_netdev(sizeof(*mhi_netdev), netname, NET_NAME_PREDICTABLE,
 250                             mhi_net_setup);
 251         if (!ndev)
 252                 return -ENOMEM;
 253
 254         mhi_netdev = netdev_priv(ndev);
 255         dev_set_drvdata(dev, mhi_netdev);
 256         mhi_netdev->ndev = ndev;
 257         mhi_netdev->mdev = mhi_dev;
 258         SET_NETDEV_DEV(ndev, &mhi_dev->dev);
 259
 260         /* All MHI net channels have 128 ring elements (at least for now) */
 261         mhi_netdev->rx_queue_sz = 128;
 262
 263         INIT_DELAYED_WORK(&mhi_netdev->rx_refill, mhi_net_rx_refill_work);
 264         u64_stats_init(&mhi_netdev->stats.rx_syncp);
 265         u64_stats_init(&mhi_netdev->stats.tx_syncp);
 266
 267         /* Start MHI channels */
 268         err = mhi_prepare_for_transfer(mhi_dev);
 269         if (err)
 270                 goto out_err;
 271
 272         err = register_netdev(ndev);
 273         if (err)
 274                 goto out_err;
 275
 276         return 0;
 277
 278 out_err:
 279         free_netdev(ndev);
 280         return err;
 281 }
 282
 283 static void mhi_net_remove(struct mhi_device *mhi_dev)
 284 {
 285         struct mhi_net_dev *mhi_netdev = dev_get_drvdata(&mhi_dev->dev);
 286
 287         unregister_netdev(mhi_netdev->ndev);
 288
 289         mhi_unprepare_from_transfer(mhi_netdev->mdev);
 290
 291         free_netdev(mhi_netdev->ndev);
 292 }
 293
 294 static const struct mhi_device_id mhi_net_id_table[] = {
 295         { .chan = "IP_HW0", .driver_data = (kernel_ulong_t)"mhi_hwip%d" },
 296         { .chan = "IP_SW0", .driver_data = (kernel_ulong_t)"mhi_swip%d" },
 297         {}
 298 };
 299 MODULE_DEVICE_TABLE(mhi, mhi_net_id_table);
 300
 301 static struct mhi_driver mhi_net_driver = {
 302         .probe = mhi_net_probe,
 303         .remove = mhi_net_remove,
 304         .dl_xfer_cb = mhi_net_dl_callback,
 305         .ul_xfer_cb = mhi_net_ul_callback,
 306         .id_table = mhi_net_id_table,
 307         .driver = {
 308                 .name = "mhi_net",
 309                 .owner = THIS_MODULE,
 310         },
 311 };
 312
 313 module_mhi_driver(mhi_net_driver);
 314
 315 MODULE_AUTHOR("Loic Poulain <loic.poulain@linaro.org>");
 316 MODULE_DESCRIPTION("Network over MHI");
 317 MODULE_LICENSE("GPL v2");