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 */
ipa_open(struct net_device * netdev)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. */
ipa_stop(struct net_device * netdev)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 */
ipa_start_xmit(struct sk_buff * skb,struct net_device * netdev)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
ipa_modem_skb_rx(struct net_device * netdev,struct sk_buff * skb)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 */
ipa_modem_netdev_setup(struct net_device * netdev)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 */
ipa_modem_suspend(struct net_device * netdev)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 */
ipa_modem_resume(struct net_device * netdev)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
ipa_modem_start(struct ipa * ipa)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
ipa_modem_stop(struct ipa * ipa)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 */
ipa_modem_crashed(struct ipa * ipa)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
ipa_modem_notify(struct notifier_block * nb,unsigned long action,void * data)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
ipa_modem_init(struct ipa * ipa,bool modem_init)351 int ipa_modem_init(struct ipa *ipa, bool modem_init)
352 {
353 return ipa_smp2p_init(ipa, modem_init);
354 }
355
ipa_modem_exit(struct ipa * ipa)356 void ipa_modem_exit(struct ipa *ipa)
357 {
358 ipa_smp2p_exit(ipa);
359 }
360
ipa_modem_config(struct ipa * ipa)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
ipa_modem_deconfig(struct ipa * ipa)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
ipa_modem_setup(struct ipa * ipa)389 int ipa_modem_setup(struct ipa *ipa)
390 {
391 return ipa_qmi_setup(ipa);
392 }
393
ipa_modem_teardown(struct ipa * ipa)394 void ipa_modem_teardown(struct ipa *ipa)
395 {
396 ipa_qmi_teardown(ipa);
397 }
398