1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Intel Wireless WiMAX Connection 2400m
4 * Glue with the networking stack
5 *
6 * Copyright (C) 2007 Intel Corporation <linux-wimax@intel.com>
7 * Yanir Lubetkin <yanirx.lubetkin@intel.com>
8 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
9 *
10 * This implements an ethernet device for the i2400m.
11 *
12 * We fake being an ethernet device to simplify the support from user
13 * space and from the other side. The world is (sadly) configured to
14 * take in only Ethernet devices...
15 *
16 * Because of this, when using firmwares <= v1.3, there is an
17 * copy-each-rxed-packet overhead on the RX path. Each IP packet has
18 * to be reallocated to add an ethernet header (as there is no space
19 * in what we get from the device). This is a known drawback and
20 * firmwares >= 1.4 add header space that can be used to insert the
21 * ethernet header without having to reallocate and copy.
22 *
23 * TX error handling is tricky; because we have to FIFO/queue the
24 * buffers for transmission (as the hardware likes it aggregated), we
25 * just give the skb to the TX subsystem and by the time it is
26 * transmitted, we have long forgotten about it. So we just don't care
27 * too much about it.
28 *
29 * Note that when the device is in idle mode with the basestation, we
30 * need to negotiate coming back up online. That involves negotiation
31 * and possible user space interaction. Thus, we defer to a workqueue
32 * to do all that. By default, we only queue a single packet and drop
33 * the rest, as potentially the time to go back from idle to normal is
34 * long.
35 *
36 * ROADMAP
37 *
38 * i2400m_open Called on ifconfig up
39 * i2400m_stop Called on ifconfig down
40 *
41 * i2400m_hard_start_xmit Called by the network stack to send a packet
42 * i2400m_net_wake_tx Wake up device from basestation-IDLE & TX
43 * i2400m_wake_tx_work
44 * i2400m_cmd_exit_idle
45 * i2400m_tx
46 * i2400m_net_tx TX a data frame
47 * i2400m_tx
48 *
49 * i2400m_change_mtu Called on ifconfig mtu XXX
50 *
51 * i2400m_tx_timeout Called when the device times out
52 *
53 * i2400m_net_rx Called by the RX code when a data frame is
54 * available (firmware <= 1.3)
55 * i2400m_net_erx Called by the RX code when a data frame is
56 * available (firmware >= 1.4).
57 * i2400m_netdev_setup Called to setup all the netdev stuff from
58 * alloc_netdev.
59 */
60 #include <linux/if_arp.h>
61 #include <linux/slab.h>
62 #include <linux/netdevice.h>
63 #include <linux/ethtool.h>
64 #include <linux/export.h>
65 #include "i2400m.h"
66
67
68 #define D_SUBMODULE netdev
69 #include "debug-levels.h"
70
71 enum {
72 /* netdev interface */
73 /* 20 secs? yep, this is the maximum timeout that the device
74 * might take to get out of IDLE / negotiate it with the base
75 * station. We add 1sec for good measure. */
76 I2400M_TX_TIMEOUT = 21 * HZ,
77 /*
78 * Experimentation has determined that, 20 to be a good value
79 * for minimizing the jitter in the throughput.
80 */
81 I2400M_TX_QLEN = 20,
82 };
83
84
85 static
86 int i2400m_open(struct net_device *net_dev)
87 {
88 int result;
89 struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
90 struct device *dev = i2400m_dev(i2400m);
91
92 d_fnstart(3, dev, "(net_dev %p [i2400m %p])\n", net_dev, i2400m);
93 /* Make sure we wait until init is complete... */
94 mutex_lock(&i2400m->init_mutex);
95 if (i2400m->updown)
96 result = 0;
97 else
98 result = -EBUSY;
99 mutex_unlock(&i2400m->init_mutex);
100 d_fnend(3, dev, "(net_dev %p [i2400m %p]) = %d\n",
101 net_dev, i2400m, result);
102 return result;
103 }
104
105
106 static
107 int i2400m_stop(struct net_device *net_dev)
108 {
109 struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
110 struct device *dev = i2400m_dev(i2400m);
111
112 d_fnstart(3, dev, "(net_dev %p [i2400m %p])\n", net_dev, i2400m);
113 i2400m_net_wake_stop(i2400m);
114 d_fnend(3, dev, "(net_dev %p [i2400m %p]) = 0\n", net_dev, i2400m);
115 return 0;
116 }
117
118
119 /*
120 * Wake up the device and transmit a held SKB, then restart the net queue
121 *
122 * When the device goes into basestation-idle mode, we need to tell it
123 * to exit that mode; it will negotiate with the base station, user
124 * space may have to intervene to rehandshake crypto and then tell us
125 * when it is ready to transmit the packet we have "queued". Still we
126 * need to give it sometime after it reports being ok.
127 *
128 * On error, there is not much we can do. If the error was on TX, we
129 * still wake the queue up to see if the next packet will be luckier.
130 *
131 * If _cmd_exit_idle() fails...well, it could be many things; most
132 * commonly it is that something else took the device out of IDLE mode
133 * (for example, the base station). In that case we get an -EILSEQ and
134 * we are just going to ignore that one. If the device is back to
135 * connected, then fine -- if it is someother state, the packet will
136 * be dropped anyway.
137 */
138 void i2400m_wake_tx_work(struct work_struct *ws)
139 {
140 int result;
141 struct i2400m *i2400m = container_of(ws, struct i2400m, wake_tx_ws);
142 struct net_device *net_dev = i2400m->wimax_dev.net_dev;
143 struct device *dev = i2400m_dev(i2400m);
144 struct sk_buff *skb;
145 unsigned long flags;
146
147 spin_lock_irqsave(&i2400m->tx_lock, flags);
148 skb = i2400m->wake_tx_skb;
149 i2400m->wake_tx_skb = NULL;
150 spin_unlock_irqrestore(&i2400m->tx_lock, flags);
151
152 d_fnstart(3, dev, "(ws %p i2400m %p skb %p)\n", ws, i2400m, skb);
153 result = -EINVAL;
154 if (skb == NULL) {
155 dev_err(dev, "WAKE&TX: skb disappeared!\n");
156 goto out_put;
157 }
158 /* If we have, somehow, lost the connection after this was
159 * queued, don't do anything; this might be the device got
160 * reset or just disconnected. */
161 if (unlikely(!netif_carrier_ok(net_dev)))
162 goto out_kfree;
163 result = i2400m_cmd_exit_idle(i2400m);
164 if (result == -EILSEQ)
165 result = 0;
166 if (result < 0) {
167 dev_err(dev, "WAKE&TX: device didn't get out of idle: "
168 "%d - resetting\n", result);
169 i2400m_reset(i2400m, I2400M_RT_BUS);
170 goto error;
171 }
172 result = wait_event_timeout(i2400m->state_wq,
173 i2400m->state != I2400M_SS_IDLE,
174 net_dev->watchdog_timeo - HZ/2);
175 if (result == 0)
176 result = -ETIMEDOUT;
177 if (result < 0) {
178 dev_err(dev, "WAKE&TX: error waiting for device to exit IDLE: "
179 "%d - resetting\n", result);
180 i2400m_reset(i2400m, I2400M_RT_BUS);
181 goto error;
182 }
183 msleep(20); /* device still needs some time or it drops it */
184 result = i2400m_tx(i2400m, skb->data, skb->len, I2400M_PT_DATA);
185 error:
186 netif_wake_queue(net_dev);
187 out_kfree:
188 kfree_skb(skb); /* refcount transferred by _hard_start_xmit() */
189 out_put:
190 i2400m_put(i2400m);
191 d_fnend(3, dev, "(ws %p i2400m %p skb %p) = void [%d]\n",
192 ws, i2400m, skb, result);
193 }
194
195
196 /*
197 * Prepare the data payload TX header
198 *
199 * The i2400m expects a 4 byte header in front of a data packet.
200 *
201 * Because we pretend to be an ethernet device, this packet comes with
202 * an ethernet header. Pull it and push our header.
203 */
204 static
205 void i2400m_tx_prep_header(struct sk_buff *skb)
206 {
207 struct i2400m_pl_data_hdr *pl_hdr;
208 skb_pull(skb, ETH_HLEN);
209 pl_hdr = skb_push(skb, sizeof(*pl_hdr));
210 pl_hdr->reserved = 0;
211 }
212
213
214
215 /*
216 * Cleanup resources acquired during i2400m_net_wake_tx()
217 *
218 * This is called by __i2400m_dev_stop and means we have to make sure
219 * the workqueue is flushed from any pending work.
220 */
221 void i2400m_net_wake_stop(struct i2400m *i2400m)
222 {
223 struct device *dev = i2400m_dev(i2400m);
224 struct sk_buff *wake_tx_skb;
225 unsigned long flags;
226
227 d_fnstart(3, dev, "(i2400m %p)\n", i2400m);
228 /*
229 * See i2400m_hard_start_xmit(), references are taken there and
230 * here we release them if the packet was still pending.
231 */
232 cancel_work_sync(&i2400m->wake_tx_ws);
233
234 spin_lock_irqsave(&i2400m->tx_lock, flags);
235 wake_tx_skb = i2400m->wake_tx_skb;
236 i2400m->wake_tx_skb = NULL;
237 spin_unlock_irqrestore(&i2400m->tx_lock, flags);
238
239 if (wake_tx_skb) {
240 i2400m_put(i2400m);
241 kfree_skb(wake_tx_skb);
242 }
243
244 d_fnend(3, dev, "(i2400m %p) = void\n", i2400m);
245 }
246
247
248 /*
249 * TX an skb to an idle device
250 *
251 * When the device is in basestation-idle mode, we need to wake it up
252 * and then TX. So we queue a work_struct for doing so.
253 *
254 * We need to get an extra ref for the skb (so it is not dropped), as
255 * well as be careful not to queue more than one request (won't help
256 * at all). If more than one request comes or there are errors, we
257 * just drop the packets (see i2400m_hard_start_xmit()).
258 */
259 static
260 int i2400m_net_wake_tx(struct i2400m *i2400m, struct net_device *net_dev,
261 struct sk_buff *skb)
262 {
263 int result;
264 struct device *dev = i2400m_dev(i2400m);
265 unsigned long flags;
266
267 d_fnstart(3, dev, "(skb %p net_dev %p)\n", skb, net_dev);
268 if (net_ratelimit()) {
269 d_printf(3, dev, "WAKE&NETTX: "
270 "skb %p sending %d bytes to radio\n",
271 skb, skb->len);
272 d_dump(4, dev, skb->data, skb->len);
273 }
274 /* We hold a ref count for i2400m and skb, so when
275 * stopping() the device, we need to cancel that work
276 * and if pending, release those resources. */
277 result = 0;
278 spin_lock_irqsave(&i2400m->tx_lock, flags);
279 if (!i2400m->wake_tx_skb) {
280 netif_stop_queue(net_dev);
281 i2400m_get(i2400m);
282 i2400m->wake_tx_skb = skb_get(skb); /* transfer ref count */
283 i2400m_tx_prep_header(skb);
284 result = schedule_work(&i2400m->wake_tx_ws);
285 WARN_ON(result == 0);
286 }
287 spin_unlock_irqrestore(&i2400m->tx_lock, flags);
288 if (result == 0) {
289 /* Yes, this happens even if we stopped the
290 * queue -- blame the queue disciplines that
291 * queue without looking -- I guess there is a reason
292 * for that. */
293 if (net_ratelimit())
294 d_printf(1, dev, "NETTX: device exiting idle, "
295 "dropping skb %p, queue running %d\n",
296 skb, netif_queue_stopped(net_dev));
297 result = -EBUSY;
298 }
299 d_fnend(3, dev, "(skb %p net_dev %p) = %d\n", skb, net_dev, result);
300 return result;
301 }
302
303
304 /*
305 * Transmit a packet to the base station on behalf of the network stack.
306 *
307 * Returns: 0 if ok, < 0 errno code on error.
308 *
309 * We need to pull the ethernet header and add the hardware header,
310 * which is currently set to all zeroes and reserved.
311 */
312 static
313 int i2400m_net_tx(struct i2400m *i2400m, struct net_device *net_dev,
314 struct sk_buff *skb)
315 {
316 int result;
317 struct device *dev = i2400m_dev(i2400m);
318
319 d_fnstart(3, dev, "(i2400m %p net_dev %p skb %p)\n",
320 i2400m, net_dev, skb);
321 /* FIXME: check eth hdr, only IPv4 is routed by the device as of now */
322 netif_trans_update(net_dev);
323 i2400m_tx_prep_header(skb);
324 d_printf(3, dev, "NETTX: skb %p sending %d bytes to radio\n",
325 skb, skb->len);
326 d_dump(4, dev, skb->data, skb->len);
327 result = i2400m_tx(i2400m, skb->data, skb->len, I2400M_PT_DATA);
328 d_fnend(3, dev, "(i2400m %p net_dev %p skb %p) = %d\n",
329 i2400m, net_dev, skb, result);
330 return result;
331 }
332
333
334 /*
335 * Transmit a packet to the base station on behalf of the network stack
336 *
337 *
338 * Returns: NETDEV_TX_OK (always, even in case of error)
339 *
340 * In case of error, we just drop it. Reasons:
341 *
342 * - we add a hw header to each skb, and if the network stack
343 * retries, we have no way to know if that skb has it or not.
344 *
345 * - network protocols have their own drop-recovery mechanisms
346 *
347 * - there is not much else we can do
348 *
349 * If the device is idle, we need to wake it up; that is an operation
350 * that will sleep. See i2400m_net_wake_tx() for details.
351 */
352 static
353 netdev_tx_t i2400m_hard_start_xmit(struct sk_buff *skb,
354 struct net_device *net_dev)
355 {
356 struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
357 struct device *dev = i2400m_dev(i2400m);
358 int result = -1;
359
360 d_fnstart(3, dev, "(skb %p net_dev %p)\n", skb, net_dev);
361
362 if (skb_cow_head(skb, 0))
363 goto drop;
364
365 if (i2400m->state == I2400M_SS_IDLE)
366 result = i2400m_net_wake_tx(i2400m, net_dev, skb);
367 else
368 result = i2400m_net_tx(i2400m, net_dev, skb);
369 if (result < 0) {
370 drop:
371 net_dev->stats.tx_dropped++;
372 } else {
373 net_dev->stats.tx_packets++;
374 net_dev->stats.tx_bytes += skb->len;
375 }
376 dev_kfree_skb(skb);
377 d_fnend(3, dev, "(skb %p net_dev %p) = %d\n", skb, net_dev, result);
378 return NETDEV_TX_OK;
379 }
380
381
382 static
383 void i2400m_tx_timeout(struct net_device *net_dev)
384 {
385 /*
386 * We might want to kick the device
387 *
388 * There is not much we can do though, as the device requires
389 * that we send the data aggregated. By the time we receive
390 * this, there might be data pending to be sent or not...
391 */
392 net_dev->stats.tx_errors++;
393 }
394
395
396 /*
397 * Create a fake ethernet header
398 *
399 * For emulating an ethernet device, every received IP header has to
400 * be prefixed with an ethernet header. Fake it with the given
401 * protocol.
402 */
403 static
404 void i2400m_rx_fake_eth_header(struct net_device *net_dev,
405 void *_eth_hdr, __be16 protocol)
406 {
407 struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
408 struct ethhdr *eth_hdr = _eth_hdr;
409
410 memcpy(eth_hdr->h_dest, net_dev->dev_addr, sizeof(eth_hdr->h_dest));
411 memcpy(eth_hdr->h_source, i2400m->src_mac_addr,
412 sizeof(eth_hdr->h_source));
413 eth_hdr->h_proto = protocol;
414 }
415
416
417 /*
418 * i2400m_net_rx - pass a network packet to the stack
419 *
420 * @i2400m: device instance
421 * @skb_rx: the skb where the buffer pointed to by @buf is
422 * @i: 1 if payload is the only one
423 * @buf: pointer to the buffer containing the data
424 * @len: buffer's length
425 *
426 * This is only used now for the v1.3 firmware. It will be deprecated
427 * in >= 2.6.31.
428 *
429 * Note that due to firmware limitations, we don't have space to add
430 * an ethernet header, so we need to copy each packet. Firmware
431 * versions >= v1.4 fix this [see i2400m_net_erx()].
432 *
433 * We just clone the skb and set it up so that it's skb->data pointer
434 * points to "buf" and it's length.
435 *
436 * Note that if the payload is the last (or the only one) in a
437 * multi-payload message, we don't clone the SKB but just reuse it.
438 *
439 * This function is normally run from a thread context. However, we
440 * still use netif_rx() instead of netif_receive_skb() as was
441 * recommended in the mailing list. Reason is in some stress tests
442 * when sending/receiving a lot of data we seem to hit a softlock in
443 * the kernel's TCP implementation [aroudn tcp_delay_timer()]. Using
444 * netif_rx() took care of the issue.
445 *
446 * This is, of course, still open to do more research on why running
447 * with netif_receive_skb() hits this softlock. FIXME.
448 *
449 * FIXME: currently we don't do any efforts at distinguishing if what
450 * we got was an IPv4 or IPv6 header, to setup the protocol field
451 * correctly.
452 */
453 void i2400m_net_rx(struct i2400m *i2400m, struct sk_buff *skb_rx,
454 unsigned i, const void *buf, int buf_len)
455 {
456 struct net_device *net_dev = i2400m->wimax_dev.net_dev;
457 struct device *dev = i2400m_dev(i2400m);
458 struct sk_buff *skb;
459
460 d_fnstart(2, dev, "(i2400m %p buf %p buf_len %d)\n",
461 i2400m, buf, buf_len);
462 if (i) {
463 skb = skb_get(skb_rx);
464 d_printf(2, dev, "RX: reusing first payload skb %p\n", skb);
465 skb_pull(skb, buf - (void *) skb->data);
466 skb_trim(skb, (void *) skb_end_pointer(skb) - buf);
467 } else {
468 /* Yes, this is bad -- a lot of overhead -- see
469 * comments at the top of the file */
470 skb = __netdev_alloc_skb(net_dev, buf_len, GFP_KERNEL);
471 if (skb == NULL) {
472 dev_err(dev, "NETRX: no memory to realloc skb\n");
473 net_dev->stats.rx_dropped++;
474 goto error_skb_realloc;
475 }
476 skb_put_data(skb, buf, buf_len);
477 }
478 i2400m_rx_fake_eth_header(i2400m->wimax_dev.net_dev,
479 skb->data - ETH_HLEN,
480 cpu_to_be16(ETH_P_IP));
481 skb_set_mac_header(skb, -ETH_HLEN);
482 skb->dev = i2400m->wimax_dev.net_dev;
483 skb->protocol = htons(ETH_P_IP);
484 net_dev->stats.rx_packets++;
485 net_dev->stats.rx_bytes += buf_len;
486 d_printf(3, dev, "NETRX: receiving %d bytes to network stack\n",
487 buf_len);
488 d_dump(4, dev, buf, buf_len);
489 netif_rx_ni(skb); /* see notes in function header */
490 error_skb_realloc:
491 d_fnend(2, dev, "(i2400m %p buf %p buf_len %d) = void\n",
492 i2400m, buf, buf_len);
493 }
494
495
496 /*
497 * i2400m_net_erx - pass a network packet to the stack (extended version)
498 *
499 * @i2400m: device descriptor
500 * @skb: the skb where the packet is - the skb should be set to point
501 * at the IP packet; this function will add ethernet headers if
502 * needed.
503 * @cs: packet type
504 *
505 * This is only used now for firmware >= v1.4. Note it is quite
506 * similar to i2400m_net_rx() (used only for v1.3 firmware).
507 *
508 * This function is normally run from a thread context. However, we
509 * still use netif_rx() instead of netif_receive_skb() as was
510 * recommended in the mailing list. Reason is in some stress tests
511 * when sending/receiving a lot of data we seem to hit a softlock in
512 * the kernel's TCP implementation [aroudn tcp_delay_timer()]. Using
513 * netif_rx() took care of the issue.
514 *
515 * This is, of course, still open to do more research on why running
516 * with netif_receive_skb() hits this softlock. FIXME.
517 */
518 void i2400m_net_erx(struct i2400m *i2400m, struct sk_buff *skb,
519 enum i2400m_cs cs)
520 {
521 struct net_device *net_dev = i2400m->wimax_dev.net_dev;
522 struct device *dev = i2400m_dev(i2400m);
523
524 d_fnstart(2, dev, "(i2400m %p skb %p [%u] cs %d)\n",
525 i2400m, skb, skb->len, cs);
526 switch(cs) {
527 case I2400M_CS_IPV4_0:
528 case I2400M_CS_IPV4:
529 i2400m_rx_fake_eth_header(i2400m->wimax_dev.net_dev,
530 skb->data - ETH_HLEN,
531 cpu_to_be16(ETH_P_IP));
532 skb_set_mac_header(skb, -ETH_HLEN);
533 skb->dev = i2400m->wimax_dev.net_dev;
534 skb->protocol = htons(ETH_P_IP);
535 net_dev->stats.rx_packets++;
536 net_dev->stats.rx_bytes += skb->len;
537 break;
538 default:
539 dev_err(dev, "ERX: BUG? CS type %u unsupported\n", cs);
540 goto error;
541
542 }
543 d_printf(3, dev, "ERX: receiving %d bytes to the network stack\n",
544 skb->len);
545 d_dump(4, dev, skb->data, skb->len);
546 netif_rx_ni(skb); /* see notes in function header */
547 error:
548 d_fnend(2, dev, "(i2400m %p skb %p [%u] cs %d) = void\n",
549 i2400m, skb, skb->len, cs);
550 }
551
552 static const struct net_device_ops i2400m_netdev_ops = {
553 .ndo_open = i2400m_open,
554 .ndo_stop = i2400m_stop,
555 .ndo_start_xmit = i2400m_hard_start_xmit,
556 .ndo_tx_timeout = i2400m_tx_timeout,
557 };
558
559 static void i2400m_get_drvinfo(struct net_device *net_dev,
560 struct ethtool_drvinfo *info)
561 {
562 struct i2400m *i2400m = net_dev_to_i2400m(net_dev);
563
564 strlcpy(info->driver, KBUILD_MODNAME, sizeof(info->driver));
565 strlcpy(info->fw_version, i2400m->fw_name ? : "",
566 sizeof(info->fw_version));
567 if (net_dev->dev.parent)
568 strlcpy(info->bus_info, dev_name(net_dev->dev.parent),
569 sizeof(info->bus_info));
570 }
571
572 static const struct ethtool_ops i2400m_ethtool_ops = {
573 .get_drvinfo = i2400m_get_drvinfo,
574 .get_link = ethtool_op_get_link,
575 };
576
577 /**
578 * i2400m_netdev_setup - Setup setup @net_dev's i2400m private data
579 *
580 * Called by alloc_netdev()
581 */
582 void i2400m_netdev_setup(struct net_device *net_dev)
583 {
584 d_fnstart(3, NULL, "(net_dev %p)\n", net_dev);
585 ether_setup(net_dev);
586 net_dev->mtu = I2400M_MAX_MTU;
587 net_dev->min_mtu = 0;
588 net_dev->max_mtu = I2400M_MAX_MTU;
589 net_dev->tx_queue_len = I2400M_TX_QLEN;
590 net_dev->features =
591 NETIF_F_VLAN_CHALLENGED
592 | NETIF_F_HIGHDMA;
593 net_dev->flags =
594 IFF_NOARP /* i2400m is apure IP device */
595 & (~IFF_BROADCAST /* i2400m is P2P */
596 & ~IFF_MULTICAST);
597 net_dev->watchdog_timeo = I2400M_TX_TIMEOUT;
598 net_dev->netdev_ops = &i2400m_netdev_ops;
599 net_dev->ethtool_ops = &i2400m_ethtool_ops;
600 d_fnend(3, NULL, "(net_dev %p) = void\n", net_dev);
601 }
602 EXPORT_SYMBOL_GPL(i2400m_netdev_setup);
603