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-2024 Linaro Ltd.
   5  */
   6
   7 #include <linux/errno.h>
   8 #include <linux/etherdevice.h>
   9 #include <linux/if_arp.h>
  10 #include <linux/if_rmnet.h>
  11 #include <linux/netdevice.h>
  12 #include <linux/pm_runtime.h>
  13 #include <linux/skbuff.h>
  14 #include <net/pkt_sched.h>
  15
  16 #include <linux/remoteproc/qcom_rproc.h>
  17
  18 #include "ipa.h"
  19 #include "ipa_endpoint.h"
  20 #include "ipa_mem.h"
  21 #include "ipa_modem.h"
  22 #include "ipa_smp2p.h"
  23 #include "ipa_table.h"
  24 #include "ipa_uc.h"
  25
  26 #define IPA_NETDEV_NAME         "rmnet_ipa%d"
  27 #define IPA_NETDEV_TAILROOM     0       /* for padding by mux layer */
  28 #define IPA_NETDEV_TIMEOUT      10      /* seconds */
  29
  30 enum ipa_modem_state {
  31         IPA_MODEM_STATE_STOPPED = 0,
  32         IPA_MODEM_STATE_STARTING,
  33         IPA_MODEM_STATE_RUNNING,
  34         IPA_MODEM_STATE_STOPPING,
  35 };
  36
  37 /**
  38  * struct ipa_priv - IPA network device private data
  39  * @ipa:        IPA pointer
  40  * @tx:         Transmit endpoint pointer
  41  * @rx:         Receive endpoint pointer
  42  * @work:       Work structure used to wake the modem netdev TX queue
  43  */
  44 struct ipa_priv {
  45         struct ipa *ipa;
  46         struct ipa_endpoint *tx;
  47         struct ipa_endpoint *rx;
  48         struct work_struct work;
  49 };
  50
  51 /** ipa_open() - Opens the modem network interface */
  52 static int ipa_open(struct net_device *netdev)
  53 {
  54         struct ipa_priv *priv = netdev_priv(netdev);
  55         struct ipa *ipa = priv->ipa;
  56         struct device *dev;
  57         int ret;
  58
  59         dev = ipa->dev;
  60         ret = pm_runtime_get_sync(dev);
  61         if (ret < 0)
  62                 goto err_power_put;
  63
  64         ret = ipa_endpoint_enable_one(priv->tx);
  65         if (ret)
  66                 goto err_power_put;
  67
  68         ret = ipa_endpoint_enable_one(priv->rx);
  69         if (ret)
  70                 goto err_disable_tx;
  71
  72         netif_start_queue(netdev);
  73
  74         pm_runtime_mark_last_busy(dev);
  75         (void)pm_runtime_put_autosuspend(dev);
  76
  77         return 0;
  78
  79 err_disable_tx:
  80         ipa_endpoint_disable_one(priv->tx);
  81 err_power_put:
  82         pm_runtime_put_noidle(dev);
  83
  84         return ret;
  85 }
  86
  87 /** ipa_stop() - Stops the modem network interface. */
  88 static int ipa_stop(struct net_device *netdev)
  89 {
  90         struct ipa_priv *priv = netdev_priv(netdev);
  91         struct ipa *ipa = priv->ipa;
  92         struct device *dev;
  93         int ret;
  94
  95         dev = ipa->dev;
  96         ret = pm_runtime_get_sync(dev);
  97         if (ret < 0)
  98                 goto out_power_put;
  99
 100         netif_stop_queue(netdev);
 101
 102         ipa_endpoint_disable_one(priv->rx);
 103         ipa_endpoint_disable_one(priv->tx);
 104 out_power_put:
 105         pm_runtime_mark_last_busy(dev);
 106         (void)pm_runtime_put_autosuspend(dev);
 107
 108         return 0;
 109 }
 110
 111 /** ipa_start_xmit() - Transmit an skb
 112  * @skb:        Socket buffer to be transmitted
 113  * @netdev:     Network device
 114  *
 115  * Return: NETDEV_TX_OK if successful (or dropped), NETDEV_TX_BUSY otherwise
 116
 117  * Normally NETDEV_TX_OK indicates the buffer was successfully transmitted.
 118  * If the buffer has an unexpected protocol or its size is out of range it
 119  * is quietly dropped, returning NETDEV_TX_OK.  NETDEV_TX_BUSY indicates
 120  * the buffer cannot be sent at this time and should retried later.
 121  */
 122 static netdev_tx_t
 123 ipa_start_xmit(struct sk_buff *skb, struct net_device *netdev)
 124 {
 125         struct net_device_stats *stats = &netdev->stats;
 126         struct ipa_priv *priv = netdev_priv(netdev);
 127         struct ipa_endpoint *endpoint;
 128         struct ipa *ipa = priv->ipa;
 129         u32 skb_len = skb->len;
 130         struct device *dev;
 131         int ret;
 132
 133         if (!skb_len)
 134                 goto err_drop_skb;
 135
 136         endpoint = ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX];
 137         if (endpoint->config.qmap && skb->protocol != htons(ETH_P_MAP))
 138                 goto err_drop_skb;
 139
 140         /* The hardware must be powered for us to transmit, so if we're not
 141          * ready we want the network stack to stop queueing until power is
 142          * ACTIVE.  Once runtime resume has completed, we inform the network
 143          * stack it's OK to try transmitting again.
 144          *
 145          * We learn from pm_runtime_get() whether the hardware is powered.
 146          * If it was not, powering up is either started or already underway.
 147          * And in that case we want to disable queueing, expecting it to be
 148          * re-enabled once power is ACTIVE.  But runtime PM and network
 149          * transmit run concurrently, and if we're not careful the requests
 150          * to stop and start queueing could occur in the wrong order.
 151          *
 152          * For that reason we *always* stop queueing here, *before* the call
 153          * to pm_runtime_get().  If we determine here that power is ACTIVE,
 154          * we restart queueing before transmitting the SKB.  Otherwise
 155          * queueing will eventually be enabled after resume completes.
 156          */
 157         netif_stop_queue(netdev);
 158
 159         dev = ipa->dev;
 160         ret = pm_runtime_get(dev);
 161         if (ret < 1) {
 162                 /* If a resume won't happen, just drop the packet */
 163                 if (ret < 0 && ret != -EINPROGRESS) {
 164                         netif_wake_queue(netdev);
 165                         pm_runtime_put_noidle(dev);
 166                         goto err_drop_skb;
 167                 }
 168
 169                 pm_runtime_put_noidle(dev);
 170
 171                 return NETDEV_TX_BUSY;
 172         }
 173
 174         netif_wake_queue(netdev);
 175
 176         ret = ipa_endpoint_skb_tx(endpoint, skb);
 177
 178         pm_runtime_mark_last_busy(dev);
 179         (void)pm_runtime_put_autosuspend(dev);
 180
 181         if (ret) {
 182                 if (ret != -E2BIG)
 183                         return NETDEV_TX_BUSY;
 184                 goto err_drop_skb;
 185         }
 186
 187         stats->tx_packets++;
 188         stats->tx_bytes += skb_len;
 189
 190         return NETDEV_TX_OK;
 191
 192 err_drop_skb:
 193         dev_kfree_skb_any(skb);
 194         stats->tx_dropped++;
 195
 196         return NETDEV_TX_OK;
 197 }
 198
 199 void ipa_modem_skb_rx(struct net_device *netdev, struct sk_buff *skb)
 200 {
 201         struct net_device_stats *stats = &netdev->stats;
 202
 203         if (skb) {
 204                 skb->dev = netdev;
 205                 skb->protocol = htons(ETH_P_MAP);
 206                 stats->rx_packets++;
 207                 stats->rx_bytes += skb->len;
 208
 209                 (void)netif_receive_skb(skb);
 210         } else {
 211                 stats->rx_dropped++;
 212         }
 213 }
 214
 215 static const struct net_device_ops ipa_modem_ops = {
 216         .ndo_open       = ipa_open,
 217         .ndo_stop       = ipa_stop,
 218         .ndo_start_xmit = ipa_start_xmit,
 219 };
 220
 221 /** ipa_modem_netdev_setup() - netdev setup function for the modem */
 222 static void ipa_modem_netdev_setup(struct net_device *netdev)
 223 {
 224         netdev->netdev_ops = &ipa_modem_ops;
 225
 226         netdev->header_ops = NULL;
 227         netdev->type = ARPHRD_RAWIP;
 228         netdev->hard_header_len = 0;
 229         netdev->min_header_len = ETH_HLEN;
 230         netdev->min_mtu = ETH_MIN_MTU;
 231         netdev->max_mtu = IPA_MTU;
 232         netdev->mtu = netdev->max_mtu;
 233         netdev->addr_len = 0;
 234         netdev->tx_queue_len = DEFAULT_TX_QUEUE_LEN;
 235         netdev->flags &= ~(IFF_BROADCAST | IFF_MULTICAST);
 236         netdev->priv_flags |= IFF_TX_SKB_SHARING;
 237         eth_broadcast_addr(netdev->broadcast);
 238
 239         /* The endpoint is configured for QMAP */
 240         netdev->needed_headroom = sizeof(struct rmnet_map_header);
 241         netdev->needed_tailroom = IPA_NETDEV_TAILROOM;
 242         netdev->watchdog_timeo = IPA_NETDEV_TIMEOUT * HZ;
 243         netdev->hw_features = NETIF_F_SG;
 244 }
 245
 246 /** ipa_modem_suspend() - suspend callback
 247  * @netdev:     Network device
 248  *
 249  * Suspend the modem's endpoints.
 250  */
 251 void ipa_modem_suspend(struct net_device *netdev)
 252 {
 253         struct ipa_priv *priv;
 254
 255         if (!(netdev->flags & IFF_UP))
 256                 return;
 257
 258         priv = netdev_priv(netdev);
 259         ipa_endpoint_suspend_one(priv->rx);
 260         ipa_endpoint_suspend_one(priv->tx);
 261 }
 262
 263 /**
 264  * ipa_modem_wake_queue_work() - enable modem netdev queue
 265  * @work:       Work structure
 266  *
 267  * Re-enable transmit on the modem network device.  This is called
 268  * in (power management) work queue context, scheduled when resuming
 269  * the modem.  We can't enable the queue directly in ipa_modem_resume()
 270  * because transmits restart the instant the queue is awakened; but the
 271  * device power state won't be ACTIVE until *after* ipa_modem_resume()
 272  * returns.
 273  */
 274 static void ipa_modem_wake_queue_work(struct work_struct *work)
 275 {
 276         struct ipa_priv *priv = container_of(work, struct ipa_priv, work);
 277
 278         netif_wake_queue(priv->tx->netdev);
 279 }
 280
 281 /** ipa_modem_resume() - resume callback for runtime_pm
 282  * @dev: pointer to device
 283  *
 284  * Resume the modem's endpoints.
 285  */
 286 void ipa_modem_resume(struct net_device *netdev)
 287 {
 288         struct ipa_priv *priv;
 289
 290         if (!(netdev->flags & IFF_UP))
 291                 return;
 292
 293         priv = netdev_priv(netdev);
 294         ipa_endpoint_resume_one(priv->tx);
 295         ipa_endpoint_resume_one(priv->rx);
 296
 297         /* Arrange for the TX queue to be restarted */
 298         (void)queue_pm_work(&priv->work);
 299 }
 300
 301 int ipa_modem_start(struct ipa *ipa)
 302 {
 303         enum ipa_modem_state state;
 304         struct net_device *netdev;
 305         struct ipa_priv *priv;
 306         int ret;
 307
 308         /* Only attempt to start the modem if it's stopped */
 309         state = atomic_cmpxchg(&ipa->modem_state, IPA_MODEM_STATE_STOPPED,
 310                                IPA_MODEM_STATE_STARTING);
 311
 312         /* Silently ignore attempts when running, or when changing state */
 313         if (state != IPA_MODEM_STATE_STOPPED)
 314                 return 0;
 315
 316         netdev = alloc_netdev(sizeof(struct ipa_priv), IPA_NETDEV_NAME,
 317                               NET_NAME_UNKNOWN, ipa_modem_netdev_setup);
 318         if (!netdev) {
 319                 ret = -ENOMEM;
 320                 goto out_set_state;
 321         }
 322
 323         SET_NETDEV_DEV(netdev, ipa->dev);
 324         priv = netdev_priv(netdev);
 325         priv->ipa = ipa;
 326         priv->tx = ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX];
 327         priv->rx = ipa->name_map[IPA_ENDPOINT_AP_MODEM_RX];
 328         INIT_WORK(&priv->work, ipa_modem_wake_queue_work);
 329
 330         priv->tx->netdev = netdev;
 331         priv->rx->netdev = netdev;
 332
 333         ipa->modem_netdev = netdev;
 334
 335         ret = register_netdev(netdev);
 336         if (ret) {
 337                 ipa->modem_netdev = NULL;
 338                 priv->rx->netdev = NULL;
 339                 priv->tx->netdev = NULL;
 340
 341                 free_netdev(netdev);
 342         }
 343
 344 out_set_state:
 345         if (ret)
 346                 atomic_set(&ipa->modem_state, IPA_MODEM_STATE_STOPPED);
 347         else
 348                 atomic_set(&ipa->modem_state, IPA_MODEM_STATE_RUNNING);
 349         smp_mb__after_atomic();
 350
 351         return ret;
 352 }
 353
 354 int ipa_modem_stop(struct ipa *ipa)
 355 {
 356         struct net_device *netdev = ipa->modem_netdev;
 357         enum ipa_modem_state state;
 358
 359         /* Only attempt to stop the modem if it's running */
 360         state = atomic_cmpxchg(&ipa->modem_state, IPA_MODEM_STATE_RUNNING,
 361                                IPA_MODEM_STATE_STOPPING);
 362
 363         /* Silently ignore attempts when already stopped */
 364         if (state == IPA_MODEM_STATE_STOPPED)
 365                 return 0;
 366
 367         /* If we're somewhere between stopped and starting, we're busy */
 368         if (state != IPA_MODEM_STATE_RUNNING)
 369                 return -EBUSY;
 370
 371         /* Clean up the netdev and endpoints if it was started */
 372         if (netdev) {
 373                 struct ipa_priv *priv = netdev_priv(netdev);
 374
 375                 cancel_work_sync(&priv->work);
 376                 /* If it was opened, stop it first */
 377                 if (netdev->flags & IFF_UP)
 378                         (void)ipa_stop(netdev);
 379                 unregister_netdev(netdev);
 380
 381                 ipa->modem_netdev = NULL;
 382                 priv->rx->netdev = NULL;
 383                 priv->tx->netdev = NULL;
 384
 385                 free_netdev(netdev);
 386         }
 387
 388         atomic_set(&ipa->modem_state, IPA_MODEM_STATE_STOPPED);
 389         smp_mb__after_atomic();
 390
 391         return 0;
 392 }
 393
 394 /* Treat a "clean" modem stop the same as a crash */
 395 static void ipa_modem_crashed(struct ipa *ipa)
 396 {
 397         struct device *dev = ipa->dev;
 398         int ret;
 399
 400         /* Prevent the modem from triggering a call to ipa_setup() */
 401         ipa_smp2p_irq_disable_setup(ipa);
 402
 403         ret = pm_runtime_get_sync(dev);
 404         if (ret < 0) {
 405                 dev_err(dev, "error %d getting power to handle crash\n", ret);
 406                 goto out_power_put;
 407         }
 408
 409         ipa_endpoint_modem_pause_all(ipa, true);
 410
 411         ipa_endpoint_modem_hol_block_clear_all(ipa);
 412
 413         ipa_table_reset(ipa, true);
 414
 415         ret = ipa_table_hash_flush(ipa);
 416         if (ret)
 417                 dev_err(dev, "error %d flushing hash caches\n", ret);
 418
 419         ret = ipa_endpoint_modem_exception_reset_all(ipa);
 420         if (ret)
 421                 dev_err(dev, "error %d resetting exception endpoint\n", ret);
 422
 423         ipa_endpoint_modem_pause_all(ipa, false);
 424
 425         ret = ipa_modem_stop(ipa);
 426         if (ret)
 427                 dev_err(dev, "error %d stopping modem\n", ret);
 428
 429         /* Now prepare for the next modem boot */
 430         ret = ipa_mem_zero_modem(ipa);
 431         if (ret)
 432                 dev_err(dev, "error %d zeroing modem memory regions\n", ret);
 433
 434 out_power_put:
 435         pm_runtime_mark_last_busy(dev);
 436         (void)pm_runtime_put_autosuspend(dev);
 437 }
 438
 439 static int ipa_modem_notify(struct notifier_block *nb, unsigned long action,
 440                             void *data)
 441 {
 442         struct ipa *ipa = container_of(nb, struct ipa, nb);
 443         struct qcom_ssr_notify_data *notify_data = data;
 444         struct device *dev = ipa->dev;
 445
 446         switch (action) {
 447         case QCOM_SSR_BEFORE_POWERUP:
 448                 dev_info(dev, "received modem starting event\n");
 449                 ipa_uc_power(ipa);
 450                 ipa_smp2p_notify_reset(ipa);
 451                 break;
 452
 453         case QCOM_SSR_AFTER_POWERUP:
 454                 dev_info(dev, "received modem running event\n");
 455                 break;
 456
 457         case QCOM_SSR_BEFORE_SHUTDOWN:
 458                 dev_info(dev, "received modem %s event\n",
 459                          notify_data->crashed ? "crashed" : "stopping");
 460                 if (ipa->setup_complete)
 461                         ipa_modem_crashed(ipa);
 462                 break;
 463
 464         case QCOM_SSR_AFTER_SHUTDOWN:
 465                 dev_info(dev, "received modem offline event\n");
 466                 break;
 467
 468         default:
 469                 dev_err(dev, "received unrecognized event %lu\n", action);
 470                 break;
 471         }
 472
 473         return NOTIFY_OK;
 474 }
 475
 476 int ipa_modem_config(struct ipa *ipa)
 477 {
 478         void *notifier;
 479
 480         ipa->nb.notifier_call = ipa_modem_notify;
 481
 482         notifier = qcom_register_ssr_notifier("mpss", &ipa->nb);
 483         if (IS_ERR(notifier))
 484                 return PTR_ERR(notifier);
 485
 486         ipa->notifier = notifier;
 487
 488         return 0;
 489 }
 490
 491 void ipa_modem_deconfig(struct ipa *ipa)
 492 {
 493         struct device *dev = ipa->dev;
 494         int ret;
 495
 496         ret = qcom_unregister_ssr_notifier(ipa->notifier, &ipa->nb);
 497         if (ret)
 498                 dev_err(dev, "error %d unregistering notifier", ret);
 499
 500         ipa->notifier = NULL;
 501         memset(&ipa->nb, 0, sizeof(ipa->nb));
 502 }