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