Loading...
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
32enum 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 */
46struct 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 */
54static 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
81err_disable_tx:
82 ipa_endpoint_disable_one(priv->tx);
83err_power_put:
84 pm_runtime_put_noidle(dev);
85
86 return ret;
87}
88
89/** ipa_stop() - Stops the modem network interface. */
90static 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);
106out_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 */
124static netdev_tx_t
125ipa_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
194err_drop_skb:
195 dev_kfree_skb_any(skb);
196 stats->tx_dropped++;
197
198 return NETDEV_TX_OK;
199}
200
201void 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
217static 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 */
224static 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 */
253void 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 */
276static 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 */
288void 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
303int 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
346out_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
356int 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 */
397static 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
436out_power_put:
437 pm_runtime_mark_last_busy(dev);
438 (void)pm_runtime_put_autosuspend(dev);
439}
440
441static 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
478int 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
493void 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}
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
30enum 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 */
44struct 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 */
52static 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
79err_disable_tx:
80 ipa_endpoint_disable_one(priv->tx);
81err_power_put:
82 pm_runtime_put_noidle(dev);
83
84 return ret;
85}
86
87/** ipa_stop() - Stops the modem network interface. */
88static 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);
104out_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 */
122static netdev_tx_t
123ipa_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
192err_drop_skb:
193 dev_kfree_skb_any(skb);
194 stats->tx_dropped++;
195
196 return NETDEV_TX_OK;
197}
198
199void 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
215static 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 */
222static 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 */
251void 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 */
274static 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 */
286void 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
301int 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
344out_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
354int 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 */
395static 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
434out_power_put:
435 pm_runtime_mark_last_busy(dev);
436 (void)pm_runtime_put_autosuspend(dev);
437}
438
439static 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
476int 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
491void 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}