// SPDX-License-Identifier: GPL-2.0 /* Copyright (c) 2014-2018, The Linux Foundation. All rights reserved. * Copyright (C) 2018-2024 Linaro Ltd. */ #include <linux/errno.h>#include <linux/etherdevice.h>#include <linux/if_arp.h>#include <linux/if_rmnet.h>#include <linux/netdevice.h>#include <linux/pm_runtime.h>#include <linux/skbuff.h>#include <net/pkt_sched.h> #include <linux/remoteproc/qcom_rproc.h> #include "ipa.h"#include "ipa_endpoint.h"#include "ipa_mem.h"#include "ipa_modem.h"#include "ipa_smp2p.h"#include "ipa_table.h"#include "ipa_uc.h" #define IPA_NETDEV_NAME "rmnet_ipa%d"#define IPA_NETDEV_TAILROOM 0 /* for padding by mux layer */#define IPA_NETDEV_TIMEOUT 10 /* seconds */ enum ipa_modem_state { IPA_MODEM_STATE_STOPPED = 0, IPA_MODEM_STATE_STARTING, IPA_MODEM_STATE_RUNNING, IPA_MODEM_STATE_STOPPING,}; /** * struct ipa_priv - IPA network device private data * @ipa: IPA pointer * @tx: Transmit endpoint pointer * @rx: Receive endpoint pointer * @work: Work structure used to wake the modem netdev TX queue */struct ipa_priv { struct ipa *ipa; struct ipa_endpoint *tx; struct ipa_endpoint *rx; struct work_struct work;}; /** ipa_open() - Opens the modem network interface */static int ipa_open(struct net_device *netdev){ struct ipa_priv *priv = netdev_priv(netdev); struct ipa *ipa = priv->ipa; struct device *dev; int ret; dev = ipa->dev; ret = pm_runtime_get_sync(dev); if (ret < 0) goto err_power_put; ret = ipa_endpoint_enable_one(priv->tx); if (ret) goto err_power_put; ret = ipa_endpoint_enable_one(priv->rx); if (ret) goto err_disable_tx; netif_start_queue(netdev); (void)pm_runtime_put_autosuspend(dev); return 0; err_disable_tx: ipa_endpoint_disable_one(priv->tx);err_power_put: pm_runtime_put_noidle(dev); return ret;} /** ipa_stop() - Stops the modem network interface. */static int ipa_stop(struct net_device *netdev){ struct ipa_priv *priv = netdev_priv(netdev); struct ipa *ipa = priv->ipa; struct device *dev; int ret; dev = ipa->dev; ret = pm_runtime_get_sync(dev); if (ret < 0) goto out_power_put; netif_stop_queue(netdev); ipa_endpoint_disable_one(priv->rx); ipa_endpoint_disable_one(priv->tx);out_power_put: (void)pm_runtime_put_autosuspend(dev); return 0;} /** ipa_start_xmit() - Transmit an skb * @skb: Socket buffer to be transmitted * @netdev: Network device * * Return: NETDEV_TX_OK if successful (or dropped), NETDEV_TX_BUSY otherwise * Normally NETDEV_TX_OK indicates the buffer was successfully transmitted. * If the buffer has an unexpected protocol or its size is out of range it * is quietly dropped, returning NETDEV_TX_OK. NETDEV_TX_BUSY indicates * the buffer cannot be sent at this time and should retried later. */static netdev_tx_tipa_start_xmit(struct sk_buff *skb, struct net_device *netdev){ struct net_device_stats *stats = &netdev->stats; struct ipa_priv *priv = netdev_priv(netdev); struct ipa_endpoint *endpoint; struct ipa *ipa = priv->ipa; u32 skb_len = skb->len; struct device *dev; int ret; if (!skb_len) goto err_drop_skb; endpoint = ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX]; if (endpoint->config.qmap && skb->protocol != htons(ETH_P_MAP)) goto err_drop_skb; /* The hardware must be powered for us to transmit, so if we're not * ready we want the network stack to stop queueing until power is * ACTIVE. Once runtime resume has completed, we inform the network * stack it's OK to try transmitting again. * * We learn from pm_runtime_get() whether the hardware is powered. * If it was not, powering up is either started or already underway. * And in that case we want to disable queueing, expecting it to be * re-enabled once power is ACTIVE. But runtime PM and network * transmit run concurrently, and if we're not careful the requests * to stop and start queueing could occur in the wrong order. * * For that reason we *always* stop queueing here, *before* the call * to pm_runtime_get(). If we determine here that power is ACTIVE, * we restart queueing before transmitting the SKB. Otherwise * queueing will eventually be enabled after resume completes. */ netif_stop_queue(netdev); dev = ipa->dev; ret = pm_runtime_get(dev); if (ret < 1) { /* If a resume won't happen, just drop the packet */ if (ret < 0 && ret != -EINPROGRESS) { netif_wake_queue(netdev); pm_runtime_put_noidle(dev); goto err_drop_skb; } pm_runtime_put_noidle(dev); return NETDEV_TX_BUSY; } netif_wake_queue(netdev); ret = ipa_endpoint_skb_tx(endpoint, skb); (void)pm_runtime_put_autosuspend(dev); if (ret) { if (ret != -E2BIG) return NETDEV_TX_BUSY; goto err_drop_skb; } stats->tx_packets++; stats->tx_bytes += skb_len; return NETDEV_TX_OK; err_drop_skb: dev_kfree_skb_any(skb); stats->tx_dropped++; return NETDEV_TX_OK;} void ipa_modem_skb_rx(struct net_device *netdev, struct sk_buff *skb){ struct net_device_stats *stats = &netdev->stats; if (skb) { skb->dev = netdev; skb->protocol = htons(ETH_P_MAP); stats->rx_packets++; stats->rx_bytes += skb->len; (void)netif_receive_skb(skb); } else { stats->rx_dropped++; }} static const struct net_device_ops ipa_modem_ops = { .ndo_open = ipa_open, .ndo_stop = ipa_stop, .ndo_start_xmit = ipa_start_xmit,}; /** ipa_modem_netdev_setup() - netdev setup function for the modem */static void ipa_modem_netdev_setup(struct net_device *netdev){ netdev->netdev_ops = &ipa_modem_ops; netdev->header_ops = NULL; netdev->type = ARPHRD_RAWIP; netdev->hard_header_len = 0; netdev->min_header_len = ETH_HLEN; netdev->min_mtu = ETH_MIN_MTU; netdev->max_mtu = IPA_MTU; netdev->mtu = netdev->max_mtu; netdev->addr_len = 0; netdev->tx_queue_len = DEFAULT_TX_QUEUE_LEN; netdev->flags &= ~(IFF_BROADCAST | IFF_MULTICAST); netdev->priv_flags |= IFF_TX_SKB_SHARING; eth_broadcast_addr(netdev->broadcast); /* The endpoint is configured for QMAP */ netdev->needed_headroom = sizeof(struct rmnet_map_header); netdev->needed_tailroom = IPA_NETDEV_TAILROOM; netdev->watchdog_timeo = IPA_NETDEV_TIMEOUT * HZ; netdev->hw_features = NETIF_F_SG;} /** ipa_modem_suspend() - suspend callback * @netdev: Network device * * Suspend the modem's endpoints. */void ipa_modem_suspend(struct net_device *netdev){ struct ipa_priv *priv; if (!(netdev->flags & IFF_UP)) return; priv = netdev_priv(netdev); ipa_endpoint_suspend_one(priv->rx); ipa_endpoint_suspend_one(priv->tx);} /** * ipa_modem_wake_queue_work() - enable modem netdev queue * @work: Work structure * * Re-enable transmit on the modem network device. This is called * in (power management) work queue context, scheduled when resuming * the modem. We can't enable the queue directly in ipa_modem_resume() * because transmits restart the instant the queue is awakened; but the * device power state won't be ACTIVE until *after* ipa_modem_resume() * returns. A transmit restarted before that would stop the queue * again and get -EINPROGRESS from pm_runtime_get(), and with this * work having already run, nothing would ever wake the queue again. * So wait for the resume to complete before waking the queue. */static void ipa_modem_wake_queue_work(struct work_struct *work){ struct ipa_priv *priv = container_of(work, struct ipa_priv, work); struct device *dev = priv->ipa->dev; int ret; ret = pm_runtime_get_sync(dev); /* Wake the queue even if the device could not be resumed, so * that pending packets are dropped by the transmit path rather * than stranded behind a stopped queue. */ netif_wake_queue(priv->tx->netdev); if (ret < 0) pm_runtime_put_noidle(dev); else (void)pm_runtime_put_autosuspend(dev);} /** ipa_modem_resume() - resume callback for runtime_pm * @dev: pointer to device * * Resume the modem's endpoints. */void ipa_modem_resume(struct net_device *netdev){ struct ipa_priv *priv; if (!(netdev->flags & IFF_UP)) return; priv = netdev_priv(netdev); ipa_endpoint_resume_one(priv->tx); ipa_endpoint_resume_one(priv->rx); /* Arrange for the TX queue to be restarted */ (void)queue_pm_work(&priv->work);} int ipa_modem_start(struct ipa *ipa){ enum ipa_modem_state state; struct net_device *netdev; struct ipa_priv *priv; int ret; /* Only attempt to start the modem if it's stopped */ state = atomic_cmpxchg(&ipa->modem_state, IPA_MODEM_STATE_STOPPED, IPA_MODEM_STATE_STARTING); /* Silently ignore attempts when running, or when changing state */ if (state != IPA_MODEM_STATE_STOPPED) return 0; netdev = alloc_netdev(sizeof(struct ipa_priv), IPA_NETDEV_NAME, NET_NAME_UNKNOWN, ipa_modem_netdev_setup); if (!netdev) { ret = -ENOMEM; goto out_set_state; } SET_NETDEV_DEV(netdev, ipa->dev); priv = netdev_priv(netdev); priv->ipa = ipa; priv->tx = ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX]; priv->rx = ipa->name_map[IPA_ENDPOINT_AP_MODEM_RX]; INIT_WORK(&priv->work, ipa_modem_wake_queue_work); priv->tx->netdev = netdev; priv->rx->netdev = netdev; ipa->modem_netdev = netdev; ret = register_netdev(netdev); if (ret) { ipa->modem_netdev = NULL; priv->rx->netdev = NULL; priv->tx->netdev = NULL; free_netdev(netdev); } out_set_state: if (ret) atomic_set(&ipa->modem_state, IPA_MODEM_STATE_STOPPED); else atomic_set(&ipa->modem_state, IPA_MODEM_STATE_RUNNING); smp_mb__after_atomic(); return ret;} int ipa_modem_stop(struct ipa *ipa){ struct net_device *netdev = ipa->modem_netdev; enum ipa_modem_state state; /* Only attempt to stop the modem if it's running */ state = atomic_cmpxchg(&ipa->modem_state, IPA_MODEM_STATE_RUNNING, IPA_MODEM_STATE_STOPPING); /* Silently ignore attempts when already stopped */ if (state == IPA_MODEM_STATE_STOPPED) return 0; /* If we're somewhere between stopped and starting, we're busy */ if (state != IPA_MODEM_STATE_RUNNING) return -EBUSY; /* Clean up the netdev and endpoints if it was started */ if (netdev) { struct ipa_priv *priv = netdev_priv(netdev); cancel_work_sync(&priv->work); /* If it was opened, stop it first */ if (netdev->flags & IFF_UP) (void)ipa_stop(netdev); unregister_netdev(netdev); ipa->modem_netdev = NULL; priv->rx->netdev = NULL; priv->tx->netdev = NULL; free_netdev(netdev); } atomic_set(&ipa->modem_state, IPA_MODEM_STATE_STOPPED); smp_mb__after_atomic(); return 0;} /* Treat a "clean" modem stop the same as a crash */static void ipa_modem_crashed(struct ipa *ipa){ struct device *dev = ipa->dev; int ret; /* Prevent the modem from triggering a call to ipa_setup() */ ipa_smp2p_irq_disable_setup(ipa); ret = pm_runtime_get_sync(dev); if (ret < 0) { dev_err(dev, "error %d getting power to handle crash\n", ret); goto out_power_put; } ipa_endpoint_modem_pause_all(ipa, true); ipa_endpoint_modem_hol_block_clear_all(ipa); ipa_table_reset(ipa, true); ret = ipa_table_hash_flush(ipa); if (ret) dev_err(dev, "error %d flushing hash caches\n", ret); ret = ipa_endpoint_modem_exception_reset_all(ipa); if (ret) dev_err(dev, "error %d resetting exception endpoint\n", ret); ipa_endpoint_modem_pause_all(ipa, false); ret = ipa_modem_stop(ipa); if (ret) dev_err(dev, "error %d stopping modem\n", ret); /* Now prepare for the next modem boot */ ret = ipa_mem_zero_modem(ipa); if (ret) dev_err(dev, "error %d zeroing modem memory regions\n", ret); out_power_put: (void)pm_runtime_put_autosuspend(dev);} static int ipa_modem_notify(struct notifier_block *nb, unsigned long action, void *data){ struct ipa *ipa = container_of(nb, struct ipa, nb); struct qcom_ssr_notify_data *notify_data = data; struct device *dev = ipa->dev; switch (action) { case QCOM_SSR_BEFORE_POWERUP: dev_info(dev, "received modem starting event\n"); ipa_uc_power(ipa); ipa_smp2p_notify_reset(ipa); break; case QCOM_SSR_AFTER_POWERUP: dev_info(dev, "received modem running event\n"); break; case QCOM_SSR_BEFORE_SHUTDOWN: dev_info(dev, "received modem %s event\n", notify_data->crashed ? "crashed" : "stopping"); if (ipa->setup_complete) ipa_modem_crashed(ipa); break; case QCOM_SSR_AFTER_SHUTDOWN: dev_info(dev, "received modem offline event\n"); break; default: dev_err(dev, "received unrecognized event %lu\n", action); break; } return NOTIFY_OK;} int ipa_modem_config(struct ipa *ipa){ void *notifier; ipa->nb.notifier_call = ipa_modem_notify; notifier = qcom_register_ssr_notifier("mpss", &ipa->nb); if (IS_ERR(notifier)) return PTR_ERR(notifier); ipa->notifier = notifier; return 0;Lines 1–500 of 514. Load more
// SPDX-License-Identifier: GPL-2.0 /* Copyright (c) 2014-2018, The Linux Foundation. All rights reserved. * Copyright (C) 2018-2024 Linaro Ltd. */ #include <linux/errno.h> #include <linux/etherdevice.h> #include <linux/if_arp.h> #include <linux/if_rmnet.h> #include <linux/netdevice.h> #include <linux/pm_runtime.h> #include <linux/skbuff.h> #include <net/pkt_sched.h> #include <linux/remoteproc/qcom_rproc.h> #include "ipa.h" #include "ipa_endpoint.h" #include "ipa_mem.h" #include "ipa_modem.h" #include "ipa_smp2p.h" #include "ipa_table.h" #include "ipa_uc.h" #define IPA_NETDEV_NAME "rmnet_ipa%d" #define IPA_NETDEV_TAILROOM 0 /* for padding by mux layer */ #define IPA_NETDEV_TIMEOUT 10 /* seconds */ enum ipa_modem_state { IPA_MODEM_STATE_STOPPED = 0, IPA_MODEM_STATE_STARTING, IPA_MODEM_STATE_RUNNING, IPA_MODEM_STATE_STOPPING, }; /** * struct ipa_priv - IPA network device private data * @ipa: IPA pointer * @tx: Transmit endpoint pointer * @rx: Receive endpoint pointer * @work: Work structure used to wake the modem netdev TX queue */ struct ipa_priv { struct ipa *ipa; struct ipa_endpoint *tx; struct ipa_endpoint *rx; struct work_struct work; }; /** ipa_open() - Opens the modem network interface */ static int ipa_open(struct net_device *netdev) { struct ipa_priv *priv = netdev_priv(netdev); struct ipa *ipa = priv->ipa; struct device *dev; int ret; dev = ipa->dev; ret = pm_runtime_get_sync(dev); if (ret < 0) goto err_power_put; ret = ipa_endpoint_enable_one(priv->tx); if (ret) goto err_power_put; ret = ipa_endpoint_enable_one(priv->rx); if (ret) goto err_disable_tx; netif_start_queue(netdev); (void)pm_runtime_put_autosuspend(dev); return 0; err_disable_tx: ipa_endpoint_disable_one(priv->tx); err_power_put: pm_runtime_put_noidle(dev); return ret; } /** ipa_stop() - Stops the modem network interface. */ static int ipa_stop(struct net_device *netdev) { struct ipa_priv *priv = netdev_priv(netdev); struct ipa *ipa = priv->ipa; struct device *dev; int ret; dev = ipa->dev; ret = pm_runtime_get_sync(dev); if (ret < 0) goto out_power_put; netif_stop_queue(netdev); ipa_endpoint_disable_one(priv->rx); ipa_endpoint_disable_one(priv->tx); out_power_put: (void)pm_runtime_put_autosuspend(dev); return 0; } /** ipa_start_xmit() - Transmit an skb * @skb: Socket buffer to be transmitted * @netdev: Network device * * Return: NETDEV_TX_OK if successful (or dropped), NETDEV_TX_BUSY otherwise * Normally NETDEV_TX_OK indicates the buffer was successfully transmitted. * If the buffer has an unexpected protocol or its size is out of range it * is quietly dropped, returning NETDEV_TX_OK. NETDEV_TX_BUSY indicates * the buffer cannot be sent at this time and should retried later. */ static netdev_tx_t ipa_start_xmit(struct sk_buff *skb, struct net_device *netdev) { struct net_device_stats *stats = &netdev->stats; struct ipa_priv *priv = netdev_priv(netdev); struct ipa_endpoint *endpoint; struct ipa *ipa = priv->ipa; u32 skb_len = skb->len; struct device *dev; int ret; if (!skb_len) goto err_drop_skb; endpoint = ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX]; if (endpoint->config.qmap && skb->protocol != htons(ETH_P_MAP)) goto err_drop_skb; /* The hardware must be powered for us to transmit, so if we're not * ready we want the network stack to stop queueing until power is * ACTIVE. Once runtime resume has completed, we inform the network * stack it's OK to try transmitting again. * * We learn from pm_runtime_get() whether the hardware is powered. * If it was not, powering up is either started or already underway. * And in that case we want to disable queueing, expecting it to be * re-enabled once power is ACTIVE. But runtime PM and network * transmit run concurrently, and if we're not careful the requests * to stop and start queueing could occur in the wrong order. * * For that reason we *always* stop queueing here, *before* the call * to pm_runtime_get(). If we determine here that power is ACTIVE, * we restart queueing before transmitting the SKB. Otherwise * queueing will eventually be enabled after resume completes. */ netif_stop_queue(netdev); dev = ipa->dev; ret = pm_runtime_get(dev); if (ret < 1) { /* If a resume won't happen, just drop the packet */ if (ret < 0 && ret != -EINPROGRESS) { netif_wake_queue(netdev); pm_runtime_put_noidle(dev); goto err_drop_skb; } pm_runtime_put_noidle(dev); return NETDEV_TX_BUSY; } netif_wake_queue(netdev); ret = ipa_endpoint_skb_tx(endpoint, skb); (void)pm_runtime_put_autosuspend(dev); if (ret) { if (ret != -E2BIG) return NETDEV_TX_BUSY; goto err_drop_skb; } stats->tx_packets++; stats->tx_bytes += skb_len; return NETDEV_TX_OK; err_drop_skb: dev_kfree_skb_any(skb); stats->tx_dropped++; return NETDEV_TX_OK; } void ipa_modem_skb_rx(struct net_device *netdev, struct sk_buff *skb) { struct net_device_stats *stats = &netdev->stats; if (skb) { skb->dev = netdev; skb->protocol = htons(ETH_P_MAP); stats->rx_packets++; stats->rx_bytes += skb->len; (void)netif_receive_skb(skb); } else { stats->rx_dropped++; } } static const struct net_device_ops ipa_modem_ops = { .ndo_open = ipa_open, .ndo_stop = ipa_stop, .ndo_start_xmit = ipa_start_xmit, }; /** ipa_modem_netdev_setup() - netdev setup function for the modem */ static void ipa_modem_netdev_setup(struct net_device *netdev) { netdev->netdev_ops = &ipa_modem_ops; netdev->header_ops = NULL; netdev->type = ARPHRD_RAWIP; netdev->hard_header_len = 0; netdev->min_header_len = ETH_HLEN; netdev->min_mtu = ETH_MIN_MTU; netdev->max_mtu = IPA_MTU; netdev->mtu = netdev->max_mtu; netdev->addr_len = 0; netdev->tx_queue_len = DEFAULT_TX_QUEUE_LEN; netdev->flags &= ~(IFF_BROADCAST | IFF_MULTICAST); netdev->priv_flags |= IFF_TX_SKB_SHARING; eth_broadcast_addr(netdev->broadcast); /* The endpoint is configured for QMAP */ netdev->needed_headroom = sizeof(struct rmnet_map_header); netdev->needed_tailroom = IPA_NETDEV_TAILROOM; netdev->watchdog_timeo = IPA_NETDEV_TIMEOUT * HZ; netdev->hw_features = NETIF_F_SG; } /** ipa_modem_suspend() - suspend callback * @netdev: Network device * * Suspend the modem's endpoints. */ void ipa_modem_suspend(struct net_device *netdev) { struct ipa_priv *priv; if (!(netdev->flags & IFF_UP)) return; priv = netdev_priv(netdev); ipa_endpoint_suspend_one(priv->rx); ipa_endpoint_suspend_one(priv->tx); } /** * ipa_modem_wake_queue_work() - enable modem netdev queue * @work: Work structure * * Re-enable transmit on the modem network device. This is called * in (power management) work queue context, scheduled when resuming * the modem. We can't enable the queue directly in ipa_modem_resume() * because transmits restart the instant the queue is awakened; but the * device power state won't be ACTIVE until *after* ipa_modem_resume() * returns. A transmit restarted before that would stop the queue * again and get -EINPROGRESS from pm_runtime_get(), and with this * work having already run, nothing would ever wake the queue again. * So wait for the resume to complete before waking the queue. */ static void ipa_modem_wake_queue_work(struct work_struct *work) { struct ipa_priv *priv = container_of(work, struct ipa_priv, work); struct device *dev = priv->ipa->dev; int ret; ret = pm_runtime_get_sync(dev); /* Wake the queue even if the device could not be resumed, so * that pending packets are dropped by the transmit path rather * than stranded behind a stopped queue. */ netif_wake_queue(priv->tx->netdev); if (ret < 0) pm_runtime_put_noidle(dev); else (void)pm_runtime_put_autosuspend(dev); } /** ipa_modem_resume() - resume callback for runtime_pm * @dev: pointer to device * * Resume the modem's endpoints. */ void ipa_modem_resume(struct net_device *netdev) { struct ipa_priv *priv; if (!(netdev->flags & IFF_UP)) return; priv = netdev_priv(netdev); ipa_endpoint_resume_one(priv->tx); ipa_endpoint_resume_one(priv->rx); /* Arrange for the TX queue to be restarted */ (void)queue_pm_work(&priv->work); } int ipa_modem_start(struct ipa *ipa) { enum ipa_modem_state state; struct net_device *netdev; struct ipa_priv *priv; int ret; /* Only attempt to start the modem if it's stopped */ state = atomic_cmpxchg(&ipa->modem_state, IPA_MODEM_STATE_STOPPED, IPA_MODEM_STATE_STARTING); /* Silently ignore attempts when running, or when changing state */ if (state != IPA_MODEM_STATE_STOPPED) return 0; netdev = alloc_netdev(sizeof(struct ipa_priv), IPA_NETDEV_NAME, NET_NAME_UNKNOWN, ipa_modem_netdev_setup); if (!netdev) { ret = -ENOMEM; goto out_set_state; } SET_NETDEV_DEV(netdev, ipa->dev); priv = netdev_priv(netdev); priv->ipa = ipa; priv->tx = ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX]; priv->rx = ipa->name_map[IPA_ENDPOINT_AP_MODEM_RX]; INIT_WORK(&priv->work, ipa_modem_wake_queue_work); priv->tx->netdev = netdev; priv->rx->netdev = netdev; ipa->modem_netdev = netdev; ret = register_netdev(netdev); if (ret) { ipa->modem_netdev = NULL; priv->rx->netdev = NULL; priv->tx->netdev = NULL; free_netdev(netdev); } out_set_state: if (ret) atomic_set(&ipa->modem_state, IPA_MODEM_STATE_STOPPED); else atomic_set(&ipa->modem_state, IPA_MODEM_STATE_RUNNING); smp_mb__after_atomic(); return ret; } int ipa_modem_stop(struct ipa *ipa) { struct net_device *netdev = ipa->modem_netdev; enum ipa_modem_state state; /* Only attempt to stop the modem if it's running */ state = atomic_cmpxchg(&ipa->modem_state, IPA_MODEM_STATE_RUNNING, IPA_MODEM_STATE_STOPPING); /* Silently ignore attempts when already stopped */ if (state == IPA_MODEM_STATE_STOPPED) return 0; /* If we're somewhere between stopped and starting, we're busy */ if (state != IPA_MODEM_STATE_RUNNING) return -EBUSY; /* Clean up the netdev and endpoints if it was started */ if (netdev) { struct ipa_priv *priv = netdev_priv(netdev); cancel_work_sync(&priv->work); /* If it was opened, stop it first */ if (netdev->flags & IFF_UP) (void)ipa_stop(netdev); unregister_netdev(netdev); ipa->modem_netdev = NULL; priv->rx->netdev = NULL; priv->tx->netdev = NULL; free_netdev(netdev); } atomic_set(&ipa->modem_state, IPA_MODEM_STATE_STOPPED); smp_mb__after_atomic(); return 0; } /* Treat a "clean" modem stop the same as a crash */ static void ipa_modem_crashed(struct ipa *ipa) { struct device *dev = ipa->dev; int ret; /* Prevent the modem from triggering a call to ipa_setup() */ ipa_smp2p_irq_disable_setup(ipa); ret = pm_runtime_get_sync(dev); if (ret < 0) { dev_err(dev, "error %d getting power to handle crash\n", ret); goto out_power_put; } ipa_endpoint_modem_pause_all(ipa, true); ipa_endpoint_modem_hol_block_clear_all(ipa); ipa_table_reset(ipa, true); ret = ipa_table_hash_flush(ipa); if (ret) dev_err(dev, "error %d flushing hash caches\n", ret); ret = ipa_endpoint_modem_exception_reset_all(ipa); if (ret) dev_err(dev, "error %d resetting exception endpoint\n", ret); ipa_endpoint_modem_pause_all(ipa, false); ret = ipa_modem_stop(ipa); if (ret) dev_err(dev, "error %d stopping modem\n", ret); /* Now prepare for the next modem boot */ ret = ipa_mem_zero_modem(ipa); if (ret) dev_err(dev, "error %d zeroing modem memory regions\n", ret); out_power_put: (void)pm_runtime_put_autosuspend(dev); } static int ipa_modem_notify(struct notifier_block *nb, unsigned long action, void *data) { struct ipa *ipa = container_of(nb, struct ipa, nb); struct qcom_ssr_notify_data *notify_data = data; struct device *dev = ipa->dev; switch (action) { case QCOM_SSR_BEFORE_POWERUP: dev_info(dev, "received modem starting event\n"); ipa_uc_power(ipa); ipa_smp2p_notify_reset(ipa); break; case QCOM_SSR_AFTER_POWERUP: dev_info(dev, "received modem running event\n"); break; case QCOM_SSR_BEFORE_SHUTDOWN: dev_info(dev, "received modem %s event\n", notify_data->crashed ? "crashed" : "stopping"); if (ipa->setup_complete) ipa_modem_crashed(ipa); break; case QCOM_SSR_AFTER_SHUTDOWN: dev_info(dev, "received modem offline event\n"); break; default: dev_err(dev, "received unrecognized event %lu\n", action); break; } return NOTIFY_OK; } int ipa_modem_config(struct ipa *ipa) { void *notifier; ipa->nb.notifier_call = ipa_modem_notify; notifier = qcom_register_ssr_notifier("mpss", &ipa->nb); if (IS_ERR(notifier)) return PTR_ERR(notifier); ipa->notifier = notifier; return 0;