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}
505