drivers/net/ipa/ipa_modem.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 /* Copyright (c) 2014-2018, The Linux Foundation. All rights reserved.
   4  * Copyright (C) 2018-2021 Linaro Ltd.
   5  */
   6
   7 #include <linux/errno.h>
   8 #include <linux/if_arp.h>
   9 #include <linux/netdevice.h>
  10 #include <linux/skbuff.h>
  11 #include <linux/if_rmnet.h>
  12 #include <linux/remoteproc/qcom_rproc.h>
  13
  14 #include "ipa.h"
  15 #include "ipa_data.h"
  16 #include "ipa_endpoint.h"
  17 #include "ipa_table.h"
  18 #include "ipa_mem.h"
  19 #include "ipa_modem.h"
  20 #include "ipa_smp2p.h"
  21 #include "ipa_qmi.h"
  22
  23 #define IPA_NETDEV_NAME         "rmnet_ipa%d"
  24 #define IPA_NETDEV_TAILROOM     0       /* for padding by mux layer */
  25 #define IPA_NETDEV_TIMEOUT      10      /* seconds */
  26
  27 enum ipa_modem_state {
  28         IPA_MODEM_STATE_STOPPED = 0,
  29         IPA_MODEM_STATE_STARTING,
  30         IPA_MODEM_STATE_RUNNING,
  31         IPA_MODEM_STATE_STOPPING,
  32 };
  33
  34 /** struct ipa_priv - IPA network device private data */
  35 struct ipa_priv {
  36         struct ipa *ipa;
  37 };
  38
  39 /** ipa_open() - Opens the modem network interface */
  40 static int ipa_open(struct net_device *netdev)
  41 {
  42         struct ipa_priv *priv = netdev_priv(netdev);
  43         struct ipa *ipa = priv->ipa;
  44         int ret;
  45
  46         ret = ipa_endpoint_enable_one(ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX]);
  47         if (ret)
  48                 return ret;
  49         ret = ipa_endpoint_enable_one(ipa->name_map[IPA_ENDPOINT_AP_MODEM_RX]);
  50         if (ret)
  51                 goto err_disable_tx;
  52
  53         netif_start_queue(netdev);
  54
  55         return 0;
  56
  57 err_disable_tx:
  58         ipa_endpoint_disable_one(ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX]);
  59
  60         return ret;
  61 }
  62
  63 /** ipa_stop() - Stops the modem network interface. */
  64 static int ipa_stop(struct net_device *netdev)
  65 {
  66         struct ipa_priv *priv = netdev_priv(netdev);
  67         struct ipa *ipa = priv->ipa;
  68
  69         netif_stop_queue(netdev);
  70
  71         ipa_endpoint_disable_one(ipa->name_map[IPA_ENDPOINT_AP_MODEM_RX]);
  72         ipa_endpoint_disable_one(ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX]);
  73
  74         return 0;
  75 }
  76
  77 /** ipa_start_xmit() - Transmits an skb.
  78  * @skb: skb to be transmitted
  79  * @dev: network device
  80  *
  81  * Return codes:
  82  * NETDEV_TX_OK: Success
  83  * NETDEV_TX_BUSY: Error while transmitting the skb. Try again later
  84  */
  85 static int ipa_start_xmit(struct sk_buff *skb, struct net_device *netdev)
  86 {
  87         struct net_device_stats *stats = &netdev->stats;
  88         struct ipa_priv *priv = netdev_priv(netdev);
  89         struct ipa_endpoint *endpoint;
  90         struct ipa *ipa = priv->ipa;
  91         u32 skb_len = skb->len;
  92         int ret;
  93
  94         if (!skb_len)
  95                 goto err_drop_skb;
  96
  97         endpoint = ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX];
  98         if (endpoint->data->qmap && skb->protocol != htons(ETH_P_MAP))
  99                 goto err_drop_skb;
 100
 101         ret = ipa_endpoint_skb_tx(endpoint, skb);
 102         if (ret) {
 103                 if (ret != -E2BIG)
 104                         return NETDEV_TX_BUSY;
 105                 goto err_drop_skb;
 106         }
 107
 108         stats->tx_packets++;
 109         stats->tx_bytes += skb_len;
 110
 111         return NETDEV_TX_OK;
 112
 113 err_drop_skb:
 114         dev_kfree_skb_any(skb);
 115         stats->tx_dropped++;
 116
 117         return NETDEV_TX_OK;
 118 }
 119
 120 void ipa_modem_skb_rx(struct net_device *netdev, struct sk_buff *skb)
 121 {
 122         struct net_device_stats *stats = &netdev->stats;
 123
 124         if (skb) {
 125                 skb->dev = netdev;
 126                 skb->protocol = htons(ETH_P_MAP);
 127                 stats->rx_packets++;
 128                 stats->rx_bytes += skb->len;
 129
 130                 (void)netif_receive_skb(skb);
 131         } else {
 132                 stats->rx_dropped++;
 133         }
 134 }
 135
 136 static const struct net_device_ops ipa_modem_ops = {
 137         .ndo_open       = ipa_open,
 138         .ndo_stop       = ipa_stop,
 139         .ndo_start_xmit = ipa_start_xmit,
 140 };
 141
 142 /** ipa_modem_netdev_setup() - netdev setup function for the modem */
 143 static void ipa_modem_netdev_setup(struct net_device *netdev)
 144 {
 145         netdev->netdev_ops = &ipa_modem_ops;
 146         ether_setup(netdev);
 147         /* No header ops (override value set by ether_setup()) */
 148         netdev->header_ops = NULL;
 149         netdev->type = ARPHRD_RAWIP;
 150         netdev->hard_header_len = 0;
 151         netdev->max_mtu = IPA_MTU;
 152         netdev->mtu = netdev->max_mtu;
 153         netdev->addr_len = 0;
 154         netdev->flags &= ~(IFF_BROADCAST | IFF_MULTICAST);
 155         /* The endpoint is configured for QMAP */
 156         netdev->needed_headroom = sizeof(struct rmnet_map_header);
 157         netdev->needed_tailroom = IPA_NETDEV_TAILROOM;
 158         netdev->watchdog_timeo = IPA_NETDEV_TIMEOUT * HZ;
 159         netdev->hw_features = NETIF_F_SG;
 160 }
 161
 162 /** ipa_modem_suspend() - suspend callback
 163  * @netdev:     Network device
 164  *
 165  * Suspend the modem's endpoints.
 166  */
 167 void ipa_modem_suspend(struct net_device *netdev)
 168 {
 169         struct ipa_priv *priv = netdev_priv(netdev);
 170         struct ipa *ipa = priv->ipa;
 171
 172         netif_stop_queue(netdev);
 173
 174         ipa_endpoint_suspend_one(ipa->name_map[IPA_ENDPOINT_AP_MODEM_RX]);
 175         ipa_endpoint_suspend_one(ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX]);
 176 }
 177
 178 /** ipa_modem_resume() - resume callback for runtime_pm
 179  * @dev: pointer to device
 180  *
 181  * Resume the modem's endpoints.
 182  */
 183 void ipa_modem_resume(struct net_device *netdev)
 184 {
 185         struct ipa_priv *priv = netdev_priv(netdev);
 186         struct ipa *ipa = priv->ipa;
 187
 188         ipa_endpoint_resume_one(ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX]);
 189         ipa_endpoint_resume_one(ipa->name_map[IPA_ENDPOINT_AP_MODEM_RX]);
 190
 191         netif_wake_queue(netdev);
 192 }
 193
 194 int ipa_modem_start(struct ipa *ipa)
 195 {
 196         enum ipa_modem_state state;
 197         struct net_device *netdev;
 198         struct ipa_priv *priv;
 199         int ret;
 200
 201         /* Only attempt to start the modem if it's stopped */
 202         state = atomic_cmpxchg(&ipa->modem_state, IPA_MODEM_STATE_STOPPED,
 203                                IPA_MODEM_STATE_STARTING);
 204
 205         /* Silently ignore attempts when running, or when changing state */
 206         if (state != IPA_MODEM_STATE_STOPPED)
 207                 return 0;
 208
 209         netdev = alloc_netdev(sizeof(struct ipa_priv), IPA_NETDEV_NAME,
 210                               NET_NAME_UNKNOWN, ipa_modem_netdev_setup);
 211         if (!netdev) {
 212                 ret = -ENOMEM;
 213                 goto out_set_state;
 214         }
 215
 216         SET_NETDEV_DEV(netdev, &ipa->pdev->dev);
 217         priv = netdev_priv(netdev);
 218         priv->ipa = ipa;
 219
 220         ret = register_netdev(netdev);
 221         if (!ret) {
 222                 ipa->modem_netdev = netdev;
 223                 ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX]->netdev = netdev;
 224                 ipa->name_map[IPA_ENDPOINT_AP_MODEM_RX]->netdev = netdev;
 225         } else {
 226                 free_netdev(netdev);
 227         }
 228
 229 out_set_state:
 230         if (ret)
 231                 atomic_set(&ipa->modem_state, IPA_MODEM_STATE_STOPPED);
 232         else
 233                 atomic_set(&ipa->modem_state, IPA_MODEM_STATE_RUNNING);
 234         smp_mb__after_atomic();
 235
 236         return ret;
 237 }
 238
 239 int ipa_modem_stop(struct ipa *ipa)
 240 {
 241         struct net_device *netdev = ipa->modem_netdev;
 242         enum ipa_modem_state state;
 243
 244         /* Only attempt to stop the modem if it's running */
 245         state = atomic_cmpxchg(&ipa->modem_state, IPA_MODEM_STATE_RUNNING,
 246                                IPA_MODEM_STATE_STOPPING);
 247
 248         /* Silently ignore attempts when already stopped */
 249         if (state == IPA_MODEM_STATE_STOPPED)
 250                 return 0;
 251
 252         /* If we're somewhere between stopped and starting, we're busy */
 253         if (state != IPA_MODEM_STATE_RUNNING)
 254                 return -EBUSY;
 255
 256         /* Prevent the modem from triggering a call to ipa_setup() */
 257         ipa_smp2p_disable(ipa);
 258
 259         /* Stop the queue and disable the endpoints if it's open */
 260         if (netdev) {
 261                 (void)ipa_stop(netdev);
 262                 ipa->name_map[IPA_ENDPOINT_AP_MODEM_RX]->netdev = NULL;
 263                 ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX]->netdev = NULL;
 264                 ipa->modem_netdev = NULL;
 265                 unregister_netdev(netdev);
 266                 free_netdev(netdev);
 267         }
 268
 269         atomic_set(&ipa->modem_state, IPA_MODEM_STATE_STOPPED);
 270         smp_mb__after_atomic();
 271
 272         return 0;
 273 }
 274
 275 /* Treat a "clean" modem stop the same as a crash */
 276 static void ipa_modem_crashed(struct ipa *ipa)
 277 {
 278         struct device *dev = &ipa->pdev->dev;
 279         int ret;
 280
 281         ipa_endpoint_modem_pause_all(ipa, true);
 282
 283         ipa_endpoint_modem_hol_block_clear_all(ipa);
 284
 285         ipa_table_reset(ipa, true);
 286
 287         ret = ipa_table_hash_flush(ipa);
 288         if (ret)
 289                 dev_err(dev, "error %d flushing hash caches\n", ret);
 290
 291         ret = ipa_endpoint_modem_exception_reset_all(ipa);
 292         if (ret)
 293                 dev_err(dev, "error %d resetting exception endpoint\n", ret);
 294
 295         ipa_endpoint_modem_pause_all(ipa, false);
 296
 297         ret = ipa_modem_stop(ipa);
 298         if (ret)
 299                 dev_err(dev, "error %d stopping modem\n", ret);
 300
 301         /* Now prepare for the next modem boot */
 302         ret = ipa_mem_zero_modem(ipa);
 303         if (ret)
 304                 dev_err(dev, "error %d zeroing modem memory regions\n", ret);
 305 }
 306
 307 static int ipa_modem_notify(struct notifier_block *nb, unsigned long action,
 308                             void *data)
 309 {
 310         struct ipa *ipa = container_of(nb, struct ipa, nb);
 311         struct qcom_ssr_notify_data *notify_data = data;
 312         struct device *dev = &ipa->pdev->dev;
 313
 314         switch (action) {
 315         case QCOM_SSR_BEFORE_POWERUP:
 316                 dev_info(dev, "received modem starting event\n");
 317                 ipa_smp2p_notify_reset(ipa);
 318                 break;
 319
 320         case QCOM_SSR_AFTER_POWERUP:
 321                 dev_info(dev, "received modem running event\n");
 322                 break;
 323
 324         case QCOM_SSR_BEFORE_SHUTDOWN:
 325                 dev_info(dev, "received modem %s event\n",
 326                          notify_data->crashed ? "crashed" : "stopping");
 327                 if (ipa->setup_complete)
 328                         ipa_modem_crashed(ipa);
 329                 break;
 330
 331         case QCOM_SSR_AFTER_SHUTDOWN:
 332                 dev_info(dev, "received modem offline event\n");
 333                 break;
 334
 335         default:
 336                 dev_err(dev, "received unrecognized event %lu\n", action);
 337                 break;
 338         }
 339
 340         return NOTIFY_OK;
 341 }
 342
 343 int ipa_modem_init(struct ipa *ipa, bool modem_init)
 344 {
 345         return ipa_smp2p_init(ipa, modem_init);
 346 }
 347
 348 void ipa_modem_exit(struct ipa *ipa)
 349 {
 350         ipa_smp2p_exit(ipa);
 351 }
 352
 353 int ipa_modem_config(struct ipa *ipa)
 354 {
 355         void *notifier;
 356
 357         ipa->nb.notifier_call = ipa_modem_notify;
 358
 359         notifier = qcom_register_ssr_notifier("mpss", &ipa->nb);
 360         if (IS_ERR(notifier))
 361                 return PTR_ERR(notifier);
 362
 363         ipa->notifier = notifier;
 364
 365         return 0;
 366 }
 367
 368 void ipa_modem_deconfig(struct ipa *ipa)
 369 {
 370         struct device *dev = &ipa->pdev->dev;
 371         int ret;
 372
 373         ret = qcom_unregister_ssr_notifier(ipa->notifier, &ipa->nb);
 374         if (ret)
 375                 dev_err(dev, "error %d unregistering notifier", ret);
 376
 377         ipa->notifier = NULL;
 378         memset(&ipa->nb, 0, sizeof(ipa->nb));
 379 }
 380
 381 int ipa_modem_setup(struct ipa *ipa)
 382 {
 383         return ipa_qmi_setup(ipa);
 384 }
 385
 386 void ipa_modem_teardown(struct ipa *ipa)
 387 {
 388         ipa_qmi_teardown(ipa);
 389 }