1 // SPDX-License-Identifier: GPL-2.0 2 3 /* Copyright (c) 2014-2018, The Linux Foundation. All rights reserved. 4 * Copyright (C) 2018-2020 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 ipa->name_map[IPA_ENDPOINT_AP_MODEM_TX]->netdev = netdev; 217 ipa->name_map[IPA_ENDPOINT_AP_MODEM_RX]->netdev = netdev; 218 219 SET_NETDEV_DEV(netdev, &ipa->pdev->dev); 220 priv = netdev_priv(netdev); 221 priv->ipa = ipa; 222 223 ret = register_netdev(netdev); 224 if (ret) 225 free_netdev(netdev); 226 else 227 ipa->modem_netdev = netdev; 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 int ret; 244 245 /* Only attempt to stop the modem if it's running */ 246 state = atomic_cmpxchg(&ipa->modem_state, IPA_MODEM_STATE_RUNNING, 247 IPA_MODEM_STATE_STOPPING); 248 249 /* Silently ignore attempts when already stopped */ 250 if (state == IPA_MODEM_STATE_STOPPED) 251 return 0; 252 253 /* If we're somewhere between stopped and starting, we're busy */ 254 if (state != IPA_MODEM_STATE_RUNNING) 255 return -EBUSY; 256 257 /* Prevent the modem from triggering a call to ipa_setup() */ 258 ipa_smp2p_disable(ipa); 259 260 if (netdev) { 261 /* Stop the queue and disable the endpoints if it's open */ 262 ret = ipa_stop(netdev); 263 if (ret) 264 goto out_set_state; 265 266 ipa->modem_netdev = NULL; 267 unregister_netdev(netdev); 268 free_netdev(netdev); 269 } else { 270 ret = 0; 271 } 272 273 out_set_state: 274 if (ret) 275 atomic_set(&ipa->modem_state, IPA_MODEM_STATE_RUNNING); 276 else 277 atomic_set(&ipa->modem_state, IPA_MODEM_STATE_STOPPED); 278 smp_mb__after_atomic(); 279 280 return ret; 281 } 282 283 /* Treat a "clean" modem stop the same as a crash */ 284 static void ipa_modem_crashed(struct ipa *ipa) 285 { 286 struct device *dev = &ipa->pdev->dev; 287 int ret; 288 289 ipa_endpoint_modem_pause_all(ipa, true); 290 291 ipa_endpoint_modem_hol_block_clear_all(ipa); 292 293 ipa_table_reset(ipa, true); 294 295 ret = ipa_table_hash_flush(ipa); 296 if (ret) 297 dev_err(dev, "error %d flushing hash caches\n", ret); 298 299 ret = ipa_endpoint_modem_exception_reset_all(ipa); 300 if (ret) 301 dev_err(dev, "error %d resetting exception endpoint\n", ret); 302 303 ipa_endpoint_modem_pause_all(ipa, false); 304 305 ret = ipa_modem_stop(ipa); 306 if (ret) 307 dev_err(dev, "error %d stopping modem\n", ret); 308 309 /* Now prepare for the next modem boot */ 310 ret = ipa_mem_zero_modem(ipa); 311 if (ret) 312 dev_err(dev, "error %d zeroing modem memory regions\n", ret); 313 } 314 315 static int ipa_modem_notify(struct notifier_block *nb, unsigned long action, 316 void *data) 317 { 318 struct ipa *ipa = container_of(nb, struct ipa, nb); 319 struct qcom_ssr_notify_data *notify_data = data; 320 struct device *dev = &ipa->pdev->dev; 321 322 switch (action) { 323 case QCOM_SSR_BEFORE_POWERUP: 324 dev_info(dev, "received modem starting event\n"); 325 ipa_smp2p_notify_reset(ipa); 326 break; 327 328 case QCOM_SSR_AFTER_POWERUP: 329 dev_info(dev, "received modem running event\n"); 330 break; 331 332 case QCOM_SSR_BEFORE_SHUTDOWN: 333 dev_info(dev, "received modem %s event\n", 334 notify_data->crashed ? "crashed" : "stopping"); 335 if (ipa->setup_complete) 336 ipa_modem_crashed(ipa); 337 break; 338 339 case QCOM_SSR_AFTER_SHUTDOWN: 340 dev_info(dev, "received modem offline event\n"); 341 break; 342 343 default: 344 dev_err(dev, "received unrecognized event %lu\n", action); 345 break; 346 } 347 348 return NOTIFY_OK; 349 } 350 351 int ipa_modem_init(struct ipa *ipa, bool modem_init) 352 { 353 return ipa_smp2p_init(ipa, modem_init); 354 } 355 356 void ipa_modem_exit(struct ipa *ipa) 357 { 358 ipa_smp2p_exit(ipa); 359 } 360 361 int ipa_modem_config(struct ipa *ipa) 362 { 363 void *notifier; 364 365 ipa->nb.notifier_call = ipa_modem_notify; 366 367 notifier = qcom_register_ssr_notifier("mpss", &ipa->nb); 368 if (IS_ERR(notifier)) 369 return PTR_ERR(notifier); 370 371 ipa->notifier = notifier; 372 373 return 0; 374 } 375 376 void ipa_modem_deconfig(struct ipa *ipa) 377 { 378 struct device *dev = &ipa->pdev->dev; 379 int ret; 380 381 ret = qcom_unregister_ssr_notifier(ipa->notifier, &ipa->nb); 382 if (ret) 383 dev_err(dev, "error %d unregistering notifier", ret); 384 385 ipa->notifier = NULL; 386 memset(&ipa->nb, 0, sizeof(ipa->nb)); 387 } 388 389 int ipa_modem_setup(struct ipa *ipa) 390 { 391 return ipa_qmi_setup(ipa); 392 } 393 394 void ipa_modem_teardown(struct ipa *ipa) 395 { 396 ipa_qmi_teardown(ipa); 397 } 398