2 * Intel Wireless WiMAX Connection 2400m
3 * Glue with the networking stack
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>
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License version
12 * 2 as published by the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
25 * This implements an ethernet device for the i2400m.
27 * We fake being an ethernet device to simplify the support from user
28 * space and from the other side. The world is (sadly) configured to
29 * take in only Ethernet devices...
31 * Because of this, when using firmwares <= v1.3, there is an
32 * copy-each-rxed-packet overhead on the RX path. Each IP packet has
33 * to be reallocated to add an ethernet header (as there is no space
34 * in what we get from the device). This is a known drawback and
35 * firmwares >= 1.4 add header space that can be used to insert the
36 * ethernet header without having to reallocate and copy.
38 * TX error handling is tricky; because we have to FIFO/queue the
39 * buffers for transmission (as the hardware likes it aggregated), we
40 * just give the skb to the TX subsystem and by the time it is
41 * transmitted, we have long forgotten about it. So we just don't care
44 * Note that when the device is in idle mode with the basestation, we
45 * need to negotiate coming back up online. That involves negotiation
46 * and possible user space interaction. Thus, we defer to a workqueue
47 * to do all that. By default, we only queue a single packet and drop
48 * the rest, as potentially the time to go back from idle to normal is
53 * i2400m_open Called on ifconfig up
54 * i2400m_stop Called on ifconfig down
56 * i2400m_hard_start_xmit Called by the network stack to send a packet
57 * i2400m_net_wake_tx Wake up device from basestation-IDLE & TX
59 * i2400m_cmd_exit_idle
61 * i2400m_net_tx TX a data frame
64 * i2400m_change_mtu Called on ifconfig mtu XXX
66 * i2400m_tx_timeout Called when the device times out
68 * i2400m_net_rx Called by the RX code when a data frame is
69 * available (firmware <= 1.3)
70 * i2400m_net_erx Called by the RX code when a data frame is
71 * available (firmware >= 1.4).
72 * i2400m_netdev_setup Called to setup all the netdev stuff from
75 #include <linux/if_arp.h>
76 #include <linux/slab.h>
77 #include <linux/netdevice.h>
78 #include <linux/ethtool.h>
82 #define D_SUBMODULE netdev
83 #include "debug-levels.h"
86 /* netdev interface */
88 * Out of NWG spec (R1_v1.2.2), 3.3.3 ASN Bearer Plane MTU Size
90 * The MTU is 1400 or less
92 I2400M_MAX_MTU
= 1400,
93 /* 20 secs? yep, this is the maximum timeout that the device
94 * might take to get out of IDLE / negotiate it with the base
95 * station. We add 1sec for good measure. */
96 I2400M_TX_TIMEOUT
= 21 * HZ
,
102 int i2400m_open(struct net_device
*net_dev
)
105 struct i2400m
*i2400m
= net_dev_to_i2400m(net_dev
);
106 struct device
*dev
= i2400m_dev(i2400m
);
108 d_fnstart(3, dev
, "(net_dev %p [i2400m %p])\n", net_dev
, i2400m
);
109 /* Make sure we wait until init is complete... */
110 mutex_lock(&i2400m
->init_mutex
);
115 mutex_unlock(&i2400m
->init_mutex
);
116 d_fnend(3, dev
, "(net_dev %p [i2400m %p]) = %d\n",
117 net_dev
, i2400m
, result
);
123 int i2400m_stop(struct net_device
*net_dev
)
125 struct i2400m
*i2400m
= net_dev_to_i2400m(net_dev
);
126 struct device
*dev
= i2400m_dev(i2400m
);
128 d_fnstart(3, dev
, "(net_dev %p [i2400m %p])\n", net_dev
, i2400m
);
129 i2400m_net_wake_stop(i2400m
);
130 d_fnend(3, dev
, "(net_dev %p [i2400m %p]) = 0\n", net_dev
, i2400m
);
136 * Wake up the device and transmit a held SKB, then restart the net queue
138 * When the device goes into basestation-idle mode, we need to tell it
139 * to exit that mode; it will negotiate with the base station, user
140 * space may have to intervene to rehandshake crypto and then tell us
141 * when it is ready to transmit the packet we have "queued". Still we
142 * need to give it sometime after it reports being ok.
144 * On error, there is not much we can do. If the error was on TX, we
145 * still wake the queue up to see if the next packet will be luckier.
147 * If _cmd_exit_idle() fails...well, it could be many things; most
148 * commonly it is that something else took the device out of IDLE mode
149 * (for example, the base station). In that case we get an -EILSEQ and
150 * we are just going to ignore that one. If the device is back to
151 * connected, then fine -- if it is someother state, the packet will
154 void i2400m_wake_tx_work(struct work_struct
*ws
)
157 struct i2400m
*i2400m
= container_of(ws
, struct i2400m
, wake_tx_ws
);
158 struct net_device
*net_dev
= i2400m
->wimax_dev
.net_dev
;
159 struct device
*dev
= i2400m_dev(i2400m
);
160 struct sk_buff
*skb
= i2400m
->wake_tx_skb
;
163 spin_lock_irqsave(&i2400m
->tx_lock
, flags
);
164 skb
= i2400m
->wake_tx_skb
;
165 i2400m
->wake_tx_skb
= NULL
;
166 spin_unlock_irqrestore(&i2400m
->tx_lock
, flags
);
168 d_fnstart(3, dev
, "(ws %p i2400m %p skb %p)\n", ws
, i2400m
, skb
);
171 dev_err(dev
, "WAKE&TX: skb dissapeared!\n");
174 /* If we have, somehow, lost the connection after this was
175 * queued, don't do anything; this might be the device got
176 * reset or just disconnected. */
177 if (unlikely(!netif_carrier_ok(net_dev
)))
179 result
= i2400m_cmd_exit_idle(i2400m
);
180 if (result
== -EILSEQ
)
183 dev_err(dev
, "WAKE&TX: device didn't get out of idle: "
184 "%d - resetting\n", result
);
185 i2400m_reset(i2400m
, I2400M_RT_BUS
);
188 result
= wait_event_timeout(i2400m
->state_wq
,
189 i2400m
->state
!= I2400M_SS_IDLE
,
190 net_dev
->watchdog_timeo
- HZ
/2);
194 dev_err(dev
, "WAKE&TX: error waiting for device to exit IDLE: "
195 "%d - resetting\n", result
);
196 i2400m_reset(i2400m
, I2400M_RT_BUS
);
199 msleep(20); /* device still needs some time or it drops it */
200 result
= i2400m_tx(i2400m
, skb
->data
, skb
->len
, I2400M_PT_DATA
);
202 netif_wake_queue(net_dev
);
204 kfree_skb(skb
); /* refcount transferred by _hard_start_xmit() */
207 d_fnend(3, dev
, "(ws %p i2400m %p skb %p) = void [%d]\n",
208 ws
, i2400m
, skb
, result
);
213 * Prepare the data payload TX header
215 * The i2400m expects a 4 byte header in front of a data packet.
217 * Because we pretend to be an ethernet device, this packet comes with
218 * an ethernet header. Pull it and push our header.
221 void i2400m_tx_prep_header(struct sk_buff
*skb
)
223 struct i2400m_pl_data_hdr
*pl_hdr
;
224 skb_pull(skb
, ETH_HLEN
);
225 pl_hdr
= (struct i2400m_pl_data_hdr
*) skb_push(skb
, sizeof(*pl_hdr
));
226 pl_hdr
->reserved
= 0;
232 * Cleanup resources acquired during i2400m_net_wake_tx()
234 * This is called by __i2400m_dev_stop and means we have to make sure
235 * the workqueue is flushed from any pending work.
237 void i2400m_net_wake_stop(struct i2400m
*i2400m
)
239 struct device
*dev
= i2400m_dev(i2400m
);
241 d_fnstart(3, dev
, "(i2400m %p)\n", i2400m
);
242 /* See i2400m_hard_start_xmit(), references are taken there
243 * and here we release them if the work was still
244 * pending. Note we can't differentiate work not pending vs
245 * never scheduled, so the NULL check does that. */
246 if (cancel_work_sync(&i2400m
->wake_tx_ws
) == 0
247 && i2400m
->wake_tx_skb
!= NULL
) {
249 struct sk_buff
*wake_tx_skb
;
250 spin_lock_irqsave(&i2400m
->tx_lock
, flags
);
251 wake_tx_skb
= i2400m
->wake_tx_skb
; /* compat help */
252 i2400m
->wake_tx_skb
= NULL
; /* compat help */
253 spin_unlock_irqrestore(&i2400m
->tx_lock
, flags
);
255 kfree_skb(wake_tx_skb
);
257 d_fnend(3, dev
, "(i2400m %p) = void\n", i2400m
);
263 * TX an skb to an idle device
265 * When the device is in basestation-idle mode, we need to wake it up
266 * and then TX. So we queue a work_struct for doing so.
268 * We need to get an extra ref for the skb (so it is not dropped), as
269 * well as be careful not to queue more than one request (won't help
270 * at all). If more than one request comes or there are errors, we
271 * just drop the packets (see i2400m_hard_start_xmit()).
274 int i2400m_net_wake_tx(struct i2400m
*i2400m
, struct net_device
*net_dev
,
278 struct device
*dev
= i2400m_dev(i2400m
);
281 d_fnstart(3, dev
, "(skb %p net_dev %p)\n", skb
, net_dev
);
282 if (net_ratelimit()) {
283 d_printf(3, dev
, "WAKE&NETTX: "
284 "skb %p sending %d bytes to radio\n",
286 d_dump(4, dev
, skb
->data
, skb
->len
);
288 /* We hold a ref count for i2400m and skb, so when
289 * stopping() the device, we need to cancel that work
290 * and if pending, release those resources. */
292 spin_lock_irqsave(&i2400m
->tx_lock
, flags
);
293 if (!work_pending(&i2400m
->wake_tx_ws
)) {
294 netif_stop_queue(net_dev
);
296 i2400m
->wake_tx_skb
= skb_get(skb
); /* transfer ref count */
297 i2400m_tx_prep_header(skb
);
298 result
= schedule_work(&i2400m
->wake_tx_ws
);
299 WARN_ON(result
== 0);
301 spin_unlock_irqrestore(&i2400m
->tx_lock
, flags
);
303 /* Yes, this happens even if we stopped the
304 * queue -- blame the queue disciplines that
305 * queue without looking -- I guess there is a reason
308 d_printf(1, dev
, "NETTX: device exiting idle, "
309 "dropping skb %p, queue running %d\n",
310 skb
, netif_queue_stopped(net_dev
));
313 d_fnend(3, dev
, "(skb %p net_dev %p) = %d\n", skb
, net_dev
, result
);
319 * Transmit a packet to the base station on behalf of the network stack.
321 * Returns: 0 if ok, < 0 errno code on error.
323 * We need to pull the ethernet header and add the hardware header,
324 * which is currently set to all zeroes and reserved.
327 int i2400m_net_tx(struct i2400m
*i2400m
, struct net_device
*net_dev
,
331 struct device
*dev
= i2400m_dev(i2400m
);
333 d_fnstart(3, dev
, "(i2400m %p net_dev %p skb %p)\n",
334 i2400m
, net_dev
, skb
);
335 /* FIXME: check eth hdr, only IPv4 is routed by the device as of now */
336 net_dev
->trans_start
= jiffies
;
337 i2400m_tx_prep_header(skb
);
338 d_printf(3, dev
, "NETTX: skb %p sending %d bytes to radio\n",
340 d_dump(4, dev
, skb
->data
, skb
->len
);
341 result
= i2400m_tx(i2400m
, skb
->data
, skb
->len
, I2400M_PT_DATA
);
342 d_fnend(3, dev
, "(i2400m %p net_dev %p skb %p) = %d\n",
343 i2400m
, net_dev
, skb
, result
);
349 * Transmit a packet to the base station on behalf of the network stack
352 * Returns: NETDEV_TX_OK (always, even in case of error)
354 * In case of error, we just drop it. Reasons:
356 * - we add a hw header to each skb, and if the network stack
357 * retries, we have no way to know if that skb has it or not.
359 * - network protocols have their own drop-recovery mechanisms
361 * - there is not much else we can do
363 * If the device is idle, we need to wake it up; that is an operation
364 * that will sleep. See i2400m_net_wake_tx() for details.
367 netdev_tx_t
i2400m_hard_start_xmit(struct sk_buff
*skb
,
368 struct net_device
*net_dev
)
370 struct i2400m
*i2400m
= net_dev_to_i2400m(net_dev
);
371 struct device
*dev
= i2400m_dev(i2400m
);
374 d_fnstart(3, dev
, "(skb %p net_dev %p)\n", skb
, net_dev
);
375 if (skb_header_cloned(skb
)) {
377 * Make tcpdump/wireshark happy -- if they are
378 * running, the skb is cloned and we will overwrite
379 * the mac fields in i2400m_tx_prep_header. Expand
380 * seems to fix this...
382 result
= pskb_expand_head(skb
, 0, 0, GFP_ATOMIC
);
384 result
= NETDEV_TX_BUSY
;
389 if (i2400m
->state
== I2400M_SS_IDLE
)
390 result
= i2400m_net_wake_tx(i2400m
, net_dev
, skb
);
392 result
= i2400m_net_tx(i2400m
, net_dev
, skb
);
394 net_dev
->stats
.tx_dropped
++;
396 net_dev
->stats
.tx_packets
++;
397 net_dev
->stats
.tx_bytes
+= skb
->len
;
399 result
= NETDEV_TX_OK
;
402 d_fnend(3, dev
, "(skb %p net_dev %p) = %d\n", skb
, net_dev
, result
);
408 int i2400m_change_mtu(struct net_device
*net_dev
, int new_mtu
)
411 struct i2400m
*i2400m
= net_dev_to_i2400m(net_dev
);
412 struct device
*dev
= i2400m_dev(i2400m
);
414 if (new_mtu
>= I2400M_MAX_MTU
) {
415 dev_err(dev
, "Cannot change MTU to %d (max is %d)\n",
416 new_mtu
, I2400M_MAX_MTU
);
419 net_dev
->mtu
= new_mtu
;
427 void i2400m_tx_timeout(struct net_device
*net_dev
)
430 * We might want to kick the device
432 * There is not much we can do though, as the device requires
433 * that we send the data aggregated. By the time we receive
434 * this, there might be data pending to be sent or not...
436 net_dev
->stats
.tx_errors
++;
442 * Create a fake ethernet header
444 * For emulating an ethernet device, every received IP header has to
445 * be prefixed with an ethernet header. Fake it with the given
449 void i2400m_rx_fake_eth_header(struct net_device
*net_dev
,
450 void *_eth_hdr
, __be16 protocol
)
452 struct i2400m
*i2400m
= net_dev_to_i2400m(net_dev
);
453 struct ethhdr
*eth_hdr
= _eth_hdr
;
455 memcpy(eth_hdr
->h_dest
, net_dev
->dev_addr
, sizeof(eth_hdr
->h_dest
));
456 memcpy(eth_hdr
->h_source
, i2400m
->src_mac_addr
,
457 sizeof(eth_hdr
->h_source
));
458 eth_hdr
->h_proto
= protocol
;
463 * i2400m_net_rx - pass a network packet to the stack
465 * @i2400m: device instance
466 * @skb_rx: the skb where the buffer pointed to by @buf is
467 * @i: 1 if payload is the only one
468 * @buf: pointer to the buffer containing the data
469 * @len: buffer's length
471 * This is only used now for the v1.3 firmware. It will be deprecated
474 * Note that due to firmware limitations, we don't have space to add
475 * an ethernet header, so we need to copy each packet. Firmware
476 * versions >= v1.4 fix this [see i2400m_net_erx()].
478 * We just clone the skb and set it up so that it's skb->data pointer
479 * points to "buf" and it's length.
481 * Note that if the payload is the last (or the only one) in a
482 * multi-payload message, we don't clone the SKB but just reuse it.
484 * This function is normally run from a thread context. However, we
485 * still use netif_rx() instead of netif_receive_skb() as was
486 * recommended in the mailing list. Reason is in some stress tests
487 * when sending/receiving a lot of data we seem to hit a softlock in
488 * the kernel's TCP implementation [aroudn tcp_delay_timer()]. Using
489 * netif_rx() took care of the issue.
491 * This is, of course, still open to do more research on why running
492 * with netif_receive_skb() hits this softlock. FIXME.
494 * FIXME: currently we don't do any efforts at distinguishing if what
495 * we got was an IPv4 or IPv6 header, to setup the protocol field
498 void i2400m_net_rx(struct i2400m
*i2400m
, struct sk_buff
*skb_rx
,
499 unsigned i
, const void *buf
, int buf_len
)
501 struct net_device
*net_dev
= i2400m
->wimax_dev
.net_dev
;
502 struct device
*dev
= i2400m_dev(i2400m
);
505 d_fnstart(2, dev
, "(i2400m %p buf %p buf_len %d)\n",
506 i2400m
, buf
, buf_len
);
508 skb
= skb_get(skb_rx
);
509 d_printf(2, dev
, "RX: reusing first payload skb %p\n", skb
);
510 skb_pull(skb
, buf
- (void *) skb
->data
);
511 skb_trim(skb
, (void *) skb_end_pointer(skb
) - buf
);
513 /* Yes, this is bad -- a lot of overhead -- see
514 * comments at the top of the file */
515 skb
= __netdev_alloc_skb(net_dev
, buf_len
, GFP_KERNEL
);
517 dev_err(dev
, "NETRX: no memory to realloc skb\n");
518 net_dev
->stats
.rx_dropped
++;
519 goto error_skb_realloc
;
521 memcpy(skb_put(skb
, buf_len
), buf
, buf_len
);
523 i2400m_rx_fake_eth_header(i2400m
->wimax_dev
.net_dev
,
524 skb
->data
- ETH_HLEN
,
525 cpu_to_be16(ETH_P_IP
));
526 skb_set_mac_header(skb
, -ETH_HLEN
);
527 skb
->dev
= i2400m
->wimax_dev
.net_dev
;
528 skb
->protocol
= htons(ETH_P_IP
);
529 net_dev
->stats
.rx_packets
++;
530 net_dev
->stats
.rx_bytes
+= buf_len
;
531 d_printf(3, dev
, "NETRX: receiving %d bytes to network stack\n",
533 d_dump(4, dev
, buf
, buf_len
);
534 netif_rx_ni(skb
); /* see notes in function header */
536 d_fnend(2, dev
, "(i2400m %p buf %p buf_len %d) = void\n",
537 i2400m
, buf
, buf_len
);
542 * i2400m_net_erx - pass a network packet to the stack (extended version)
544 * @i2400m: device descriptor
545 * @skb: the skb where the packet is - the skb should be set to point
546 * at the IP packet; this function will add ethernet headers if
550 * This is only used now for firmware >= v1.4. Note it is quite
551 * similar to i2400m_net_rx() (used only for v1.3 firmware).
553 * This function is normally run from a thread context. However, we
554 * still use netif_rx() instead of netif_receive_skb() as was
555 * recommended in the mailing list. Reason is in some stress tests
556 * when sending/receiving a lot of data we seem to hit a softlock in
557 * the kernel's TCP implementation [aroudn tcp_delay_timer()]. Using
558 * netif_rx() took care of the issue.
560 * This is, of course, still open to do more research on why running
561 * with netif_receive_skb() hits this softlock. FIXME.
563 void i2400m_net_erx(struct i2400m
*i2400m
, struct sk_buff
*skb
,
566 struct net_device
*net_dev
= i2400m
->wimax_dev
.net_dev
;
567 struct device
*dev
= i2400m_dev(i2400m
);
570 d_fnstart(2, dev
, "(i2400m %p skb %p [%u] cs %d)\n",
571 i2400m
, skb
, skb
->len
, cs
);
573 case I2400M_CS_IPV4_0
:
576 i2400m_rx_fake_eth_header(i2400m
->wimax_dev
.net_dev
,
577 skb
->data
- ETH_HLEN
,
578 cpu_to_be16(ETH_P_IP
));
579 skb_set_mac_header(skb
, -ETH_HLEN
);
580 skb
->dev
= i2400m
->wimax_dev
.net_dev
;
581 skb
->protocol
= htons(ETH_P_IP
);
582 net_dev
->stats
.rx_packets
++;
583 net_dev
->stats
.rx_bytes
+= skb
->len
;
586 dev_err(dev
, "ERX: BUG? CS type %u unsupported\n", cs
);
590 d_printf(3, dev
, "ERX: receiving %d bytes to the network stack\n",
592 d_dump(4, dev
, skb
->data
, skb
->len
);
593 netif_rx_ni(skb
); /* see notes in function header */
595 d_fnend(2, dev
, "(i2400m %p skb %p [%u] cs %d) = void\n",
596 i2400m
, skb
, skb
->len
, cs
);
599 static const struct net_device_ops i2400m_netdev_ops
= {
600 .ndo_open
= i2400m_open
,
601 .ndo_stop
= i2400m_stop
,
602 .ndo_start_xmit
= i2400m_hard_start_xmit
,
603 .ndo_tx_timeout
= i2400m_tx_timeout
,
604 .ndo_change_mtu
= i2400m_change_mtu
,
607 static void i2400m_get_drvinfo(struct net_device
*net_dev
,
608 struct ethtool_drvinfo
*info
)
610 struct i2400m
*i2400m
= net_dev_to_i2400m(net_dev
);
612 strncpy(info
->driver
, KBUILD_MODNAME
, sizeof(info
->driver
) - 1);
613 strncpy(info
->fw_version
, i2400m
->fw_name
, sizeof(info
->fw_version
) - 1);
614 if (net_dev
->dev
.parent
)
615 strncpy(info
->bus_info
, dev_name(net_dev
->dev
.parent
),
616 sizeof(info
->bus_info
) - 1);
619 static const struct ethtool_ops i2400m_ethtool_ops
= {
620 .get_drvinfo
= i2400m_get_drvinfo
,
621 .get_link
= ethtool_op_get_link
,
625 * i2400m_netdev_setup - Setup setup @net_dev's i2400m private data
627 * Called by alloc_netdev()
629 void i2400m_netdev_setup(struct net_device
*net_dev
)
631 d_fnstart(3, NULL
, "(net_dev %p)\n", net_dev
);
632 ether_setup(net_dev
);
633 net_dev
->mtu
= I2400M_MAX_MTU
;
634 net_dev
->tx_queue_len
= I2400M_TX_QLEN
;
636 NETIF_F_VLAN_CHALLENGED
639 IFF_NOARP
/* i2400m is apure IP device */
640 & (~IFF_BROADCAST
/* i2400m is P2P */
642 net_dev
->watchdog_timeo
= I2400M_TX_TIMEOUT
;
643 net_dev
->netdev_ops
= &i2400m_netdev_ops
;
644 net_dev
->ethtool_ops
= &i2400m_ethtool_ops
;
645 d_fnend(3, NULL
, "(net_dev %p) = void\n", net_dev
);
647 EXPORT_SYMBOL_GPL(i2400m_netdev_setup
);