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