474 lines
15 KiB
C
474 lines
15 KiB
C
/*
|
|
* WUSB Wire Adapter: WLP interface
|
|
* Driver for the Linux Network stack.
|
|
*
|
|
* Copyright (C) 2005-2006 Intel Corporation
|
|
* Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License version
|
|
* 2 as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
* 02110-1301, USA.
|
|
*
|
|
*
|
|
* i1480u's RX handling is simple. i1480u will send the received
|
|
* network packets broken up in fragments; 1 to N fragments make a
|
|
* packet, we assemble them together and deliver the packet with netif_rx().
|
|
*
|
|
* Beacuse each USB transfer is a *single* fragment (except when the
|
|
* transfer contains a first fragment), each URB called thus
|
|
* back contains one or two fragments. So we queue N URBs, each with its own
|
|
* fragment buffer. When a URB is done, we process it (adding to the
|
|
* current skb from the fragment buffer until complete). Once
|
|
* processed, we requeue the URB. There is always a bunch of URBs
|
|
* ready to take data, so the intergap should be minimal.
|
|
*
|
|
* An URB's transfer buffer is the data field of a socket buffer. This
|
|
* reduces copying as data can be passed directly to network layer. If a
|
|
* complete packet or 1st fragment is received the URB's transfer buffer is
|
|
* taken away from it and used to send data to the network layer. In this
|
|
* case a new transfer buffer is allocated to the URB before being requeued.
|
|
* If a "NEXT" or "LAST" fragment is received, the fragment contents is
|
|
* appended to the RX packet under construction and the transfer buffer
|
|
* is reused. To be able to use this buffer to assemble complete packets
|
|
* we set each buffer's size to that of the MAX ethernet packet that can
|
|
* be received. There is thus room for improvement in memory usage.
|
|
*
|
|
* When the max tx fragment size increases, we should be able to read
|
|
* data into the skbs directly with very simple code.
|
|
*
|
|
* ROADMAP:
|
|
*
|
|
* ENTRY POINTS:
|
|
*
|
|
* i1480u_rx_setup(): setup RX context [from i1480u_open()]
|
|
*
|
|
* i1480u_rx_release(): release RX context [from i1480u_stop()]
|
|
*
|
|
* i1480u_rx_cb(): called when the RX USB URB receives a
|
|
* packet. It removes the header and pushes it up
|
|
* the Linux netdev stack with netif_rx().
|
|
*
|
|
* i1480u_rx_buffer()
|
|
* i1480u_drop() and i1480u_fix()
|
|
* i1480u_skb_deliver
|
|
*
|
|
*/
|
|
|
|
#include <linux/netdevice.h>
|
|
#include <linux/etherdevice.h>
|
|
#include "i1480u-wlp.h"
|
|
|
|
/*
|
|
* Setup the RX context
|
|
*
|
|
* Each URB is provided with a transfer_buffer that is the data field
|
|
* of a new socket buffer.
|
|
*/
|
|
int i1480u_rx_setup(struct i1480u *i1480u)
|
|
{
|
|
int result, cnt;
|
|
struct device *dev = &i1480u->usb_iface->dev;
|
|
struct net_device *net_dev = i1480u->net_dev;
|
|
struct usb_endpoint_descriptor *epd;
|
|
struct sk_buff *skb;
|
|
|
|
/* Alloc RX stuff */
|
|
i1480u->rx_skb = NULL; /* not in process of receiving packet */
|
|
result = -ENOMEM;
|
|
epd = &i1480u->usb_iface->cur_altsetting->endpoint[1].desc;
|
|
for (cnt = 0; cnt < i1480u_RX_BUFS; cnt++) {
|
|
struct i1480u_rx_buf *rx_buf = &i1480u->rx_buf[cnt];
|
|
rx_buf->i1480u = i1480u;
|
|
skb = dev_alloc_skb(i1480u_MAX_RX_PKT_SIZE);
|
|
if (!skb) {
|
|
dev_err(dev,
|
|
"RX: cannot allocate RX buffer %d\n", cnt);
|
|
result = -ENOMEM;
|
|
goto error;
|
|
}
|
|
skb->dev = net_dev;
|
|
skb->ip_summed = CHECKSUM_NONE;
|
|
skb_reserve(skb, 2);
|
|
rx_buf->data = skb;
|
|
rx_buf->urb = usb_alloc_urb(0, GFP_KERNEL);
|
|
if (unlikely(rx_buf->urb == NULL)) {
|
|
dev_err(dev, "RX: cannot allocate URB %d\n", cnt);
|
|
result = -ENOMEM;
|
|
goto error;
|
|
}
|
|
usb_fill_bulk_urb(rx_buf->urb, i1480u->usb_dev,
|
|
usb_rcvbulkpipe(i1480u->usb_dev, epd->bEndpointAddress),
|
|
rx_buf->data->data, i1480u_MAX_RX_PKT_SIZE - 2,
|
|
i1480u_rx_cb, rx_buf);
|
|
result = usb_submit_urb(rx_buf->urb, GFP_NOIO);
|
|
if (unlikely(result < 0)) {
|
|
dev_err(dev, "RX: cannot submit URB %d: %d\n",
|
|
cnt, result);
|
|
goto error;
|
|
}
|
|
}
|
|
return 0;
|
|
|
|
error:
|
|
i1480u_rx_release(i1480u);
|
|
return result;
|
|
}
|
|
|
|
|
|
/* Release resources associated to the rx context */
|
|
void i1480u_rx_release(struct i1480u *i1480u)
|
|
{
|
|
int cnt;
|
|
for (cnt = 0; cnt < i1480u_RX_BUFS; cnt++) {
|
|
if (i1480u->rx_buf[cnt].data)
|
|
dev_kfree_skb(i1480u->rx_buf[cnt].data);
|
|
if (i1480u->rx_buf[cnt].urb) {
|
|
usb_kill_urb(i1480u->rx_buf[cnt].urb);
|
|
usb_free_urb(i1480u->rx_buf[cnt].urb);
|
|
}
|
|
}
|
|
if (i1480u->rx_skb != NULL)
|
|
dev_kfree_skb(i1480u->rx_skb);
|
|
}
|
|
|
|
static
|
|
void i1480u_rx_unlink_urbs(struct i1480u *i1480u)
|
|
{
|
|
int cnt;
|
|
for (cnt = 0; cnt < i1480u_RX_BUFS; cnt++) {
|
|
if (i1480u->rx_buf[cnt].urb)
|
|
usb_unlink_urb(i1480u->rx_buf[cnt].urb);
|
|
}
|
|
}
|
|
|
|
/* Fix an out-of-sequence packet */
|
|
#define i1480u_fix(i1480u, msg...) \
|
|
do { \
|
|
if (printk_ratelimit()) \
|
|
dev_err(&i1480u->usb_iface->dev, msg); \
|
|
dev_kfree_skb_irq(i1480u->rx_skb); \
|
|
i1480u->rx_skb = NULL; \
|
|
i1480u->rx_untd_pkt_size = 0; \
|
|
} while (0)
|
|
|
|
|
|
/* Drop an out-of-sequence packet */
|
|
#define i1480u_drop(i1480u, msg...) \
|
|
do { \
|
|
if (printk_ratelimit()) \
|
|
dev_err(&i1480u->usb_iface->dev, msg); \
|
|
i1480u->net_dev->stats.rx_dropped++; \
|
|
} while (0)
|
|
|
|
|
|
|
|
|
|
/* Finalizes setting up the SKB and delivers it
|
|
*
|
|
* We first pass the incoming frame to WLP substack for verification. It
|
|
* may also be a WLP association frame in which case WLP will take over the
|
|
* processing. If WLP does not take it over it will still verify it, if the
|
|
* frame is invalid the skb will be freed by WLP and we will not continue
|
|
* parsing.
|
|
* */
|
|
static
|
|
void i1480u_skb_deliver(struct i1480u *i1480u)
|
|
{
|
|
int should_parse;
|
|
struct net_device *net_dev = i1480u->net_dev;
|
|
struct device *dev = &i1480u->usb_iface->dev;
|
|
|
|
should_parse = wlp_receive_frame(dev, &i1480u->wlp, i1480u->rx_skb,
|
|
&i1480u->rx_srcaddr);
|
|
if (!should_parse)
|
|
goto out;
|
|
i1480u->rx_skb->protocol = eth_type_trans(i1480u->rx_skb, net_dev);
|
|
net_dev->stats.rx_packets++;
|
|
net_dev->stats.rx_bytes += i1480u->rx_untd_pkt_size;
|
|
|
|
netif_rx(i1480u->rx_skb); /* deliver */
|
|
out:
|
|
i1480u->rx_skb = NULL;
|
|
i1480u->rx_untd_pkt_size = 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Process a buffer of data received from the USB RX endpoint
|
|
*
|
|
* First fragment arrives with next or last fragment. All other fragments
|
|
* arrive alone.
|
|
*
|
|
* /me hates long functions.
|
|
*/
|
|
static
|
|
void i1480u_rx_buffer(struct i1480u_rx_buf *rx_buf)
|
|
{
|
|
unsigned pkt_completed = 0; /* !0 when we got all pkt fragments */
|
|
size_t untd_hdr_size, untd_frg_size;
|
|
size_t i1480u_hdr_size;
|
|
struct wlp_rx_hdr *i1480u_hdr = NULL;
|
|
|
|
struct i1480u *i1480u = rx_buf->i1480u;
|
|
struct sk_buff *skb = rx_buf->data;
|
|
int size_left = rx_buf->urb->actual_length;
|
|
void *ptr = rx_buf->urb->transfer_buffer; /* also rx_buf->data->data */
|
|
struct untd_hdr *untd_hdr;
|
|
|
|
struct net_device *net_dev = i1480u->net_dev;
|
|
struct device *dev = &i1480u->usb_iface->dev;
|
|
struct sk_buff *new_skb;
|
|
|
|
#if 0
|
|
dev_fnstart(dev,
|
|
"(i1480u %p ptr %p size_left %zu)\n", i1480u, ptr, size_left);
|
|
dev_err(dev, "RX packet, %zu bytes\n", size_left);
|
|
dump_bytes(dev, ptr, size_left);
|
|
#endif
|
|
i1480u_hdr_size = sizeof(struct wlp_rx_hdr);
|
|
|
|
while (size_left > 0) {
|
|
if (pkt_completed) {
|
|
i1480u_drop(i1480u, "RX: fragment follows completed"
|
|
"packet in same buffer. Dropping\n");
|
|
break;
|
|
}
|
|
untd_hdr = ptr;
|
|
if (size_left < sizeof(*untd_hdr)) { /* Check the UNTD header */
|
|
i1480u_drop(i1480u, "RX: short UNTD header! Dropping\n");
|
|
goto out;
|
|
}
|
|
if (unlikely(untd_hdr_rx_tx(untd_hdr) == 0)) { /* Paranoia: TX set? */
|
|
i1480u_drop(i1480u, "RX: TX bit set! Dropping\n");
|
|
goto out;
|
|
}
|
|
switch (untd_hdr_type(untd_hdr)) { /* Check the UNTD header type */
|
|
case i1480u_PKT_FRAG_1ST: {
|
|
struct untd_hdr_1st *untd_hdr_1st = (void *) untd_hdr;
|
|
dev_dbg(dev, "1st fragment\n");
|
|
untd_hdr_size = sizeof(struct untd_hdr_1st);
|
|
if (i1480u->rx_skb != NULL)
|
|
i1480u_fix(i1480u, "RX: 1st fragment out of "
|
|
"sequence! Fixing\n");
|
|
if (size_left < untd_hdr_size + i1480u_hdr_size) {
|
|
i1480u_drop(i1480u, "RX: short 1st fragment! "
|
|
"Dropping\n");
|
|
goto out;
|
|
}
|
|
i1480u->rx_untd_pkt_size = le16_to_cpu(untd_hdr->len)
|
|
- i1480u_hdr_size;
|
|
untd_frg_size = le16_to_cpu(untd_hdr_1st->fragment_len);
|
|
if (size_left < untd_hdr_size + untd_frg_size) {
|
|
i1480u_drop(i1480u,
|
|
"RX: short payload! Dropping\n");
|
|
goto out;
|
|
}
|
|
i1480u->rx_skb = skb;
|
|
i1480u_hdr = (void *) untd_hdr_1st + untd_hdr_size;
|
|
i1480u->rx_srcaddr = i1480u_hdr->srcaddr;
|
|
skb_put(i1480u->rx_skb, untd_hdr_size + untd_frg_size);
|
|
skb_pull(i1480u->rx_skb, untd_hdr_size + i1480u_hdr_size);
|
|
stats_add_sample(&i1480u->lqe_stats, (s8) i1480u_hdr->LQI - 7);
|
|
stats_add_sample(&i1480u->rssi_stats, i1480u_hdr->RSSI + 18);
|
|
rx_buf->data = NULL; /* need to create new buffer */
|
|
break;
|
|
}
|
|
case i1480u_PKT_FRAG_NXT: {
|
|
dev_dbg(dev, "nxt fragment\n");
|
|
untd_hdr_size = sizeof(struct untd_hdr_rst);
|
|
if (i1480u->rx_skb == NULL) {
|
|
i1480u_drop(i1480u, "RX: next fragment out of "
|
|
"sequence! Dropping\n");
|
|
goto out;
|
|
}
|
|
if (size_left < untd_hdr_size) {
|
|
i1480u_drop(i1480u, "RX: short NXT fragment! "
|
|
"Dropping\n");
|
|
goto out;
|
|
}
|
|
untd_frg_size = le16_to_cpu(untd_hdr->len);
|
|
if (size_left < untd_hdr_size + untd_frg_size) {
|
|
i1480u_drop(i1480u,
|
|
"RX: short payload! Dropping\n");
|
|
goto out;
|
|
}
|
|
memmove(skb_put(i1480u->rx_skb, untd_frg_size),
|
|
ptr + untd_hdr_size, untd_frg_size);
|
|
break;
|
|
}
|
|
case i1480u_PKT_FRAG_LST: {
|
|
dev_dbg(dev, "Lst fragment\n");
|
|
untd_hdr_size = sizeof(struct untd_hdr_rst);
|
|
if (i1480u->rx_skb == NULL) {
|
|
i1480u_drop(i1480u, "RX: last fragment out of "
|
|
"sequence! Dropping\n");
|
|
goto out;
|
|
}
|
|
if (size_left < untd_hdr_size) {
|
|
i1480u_drop(i1480u, "RX: short LST fragment! "
|
|
"Dropping\n");
|
|
goto out;
|
|
}
|
|
untd_frg_size = le16_to_cpu(untd_hdr->len);
|
|
if (size_left < untd_frg_size + untd_hdr_size) {
|
|
i1480u_drop(i1480u,
|
|
"RX: short payload! Dropping\n");
|
|
goto out;
|
|
}
|
|
memmove(skb_put(i1480u->rx_skb, untd_frg_size),
|
|
ptr + untd_hdr_size, untd_frg_size);
|
|
pkt_completed = 1;
|
|
break;
|
|
}
|
|
case i1480u_PKT_FRAG_CMP: {
|
|
dev_dbg(dev, "cmp fragment\n");
|
|
untd_hdr_size = sizeof(struct untd_hdr_cmp);
|
|
if (i1480u->rx_skb != NULL)
|
|
i1480u_fix(i1480u, "RX: fix out-of-sequence CMP"
|
|
" fragment!\n");
|
|
if (size_left < untd_hdr_size + i1480u_hdr_size) {
|
|
i1480u_drop(i1480u, "RX: short CMP fragment! "
|
|
"Dropping\n");
|
|
goto out;
|
|
}
|
|
i1480u->rx_untd_pkt_size = le16_to_cpu(untd_hdr->len);
|
|
untd_frg_size = i1480u->rx_untd_pkt_size;
|
|
if (size_left < i1480u->rx_untd_pkt_size + untd_hdr_size) {
|
|
i1480u_drop(i1480u,
|
|
"RX: short payload! Dropping\n");
|
|
goto out;
|
|
}
|
|
i1480u->rx_skb = skb;
|
|
i1480u_hdr = (void *) untd_hdr + untd_hdr_size;
|
|
i1480u->rx_srcaddr = i1480u_hdr->srcaddr;
|
|
stats_add_sample(&i1480u->lqe_stats, (s8) i1480u_hdr->LQI - 7);
|
|
stats_add_sample(&i1480u->rssi_stats, i1480u_hdr->RSSI + 18);
|
|
skb_put(i1480u->rx_skb, untd_hdr_size + i1480u->rx_untd_pkt_size);
|
|
skb_pull(i1480u->rx_skb, untd_hdr_size + i1480u_hdr_size);
|
|
rx_buf->data = NULL; /* for hand off skb to network stack */
|
|
pkt_completed = 1;
|
|
i1480u->rx_untd_pkt_size -= i1480u_hdr_size; /* accurate stat */
|
|
break;
|
|
}
|
|
default:
|
|
i1480u_drop(i1480u, "RX: unknown packet type %u! "
|
|
"Dropping\n", untd_hdr_type(untd_hdr));
|
|
goto out;
|
|
}
|
|
size_left -= untd_hdr_size + untd_frg_size;
|
|
if (size_left > 0)
|
|
ptr += untd_hdr_size + untd_frg_size;
|
|
}
|
|
if (pkt_completed)
|
|
i1480u_skb_deliver(i1480u);
|
|
out:
|
|
/* recreate needed RX buffers*/
|
|
if (rx_buf->data == NULL) {
|
|
/* buffer is being used to receive packet, create new */
|
|
new_skb = dev_alloc_skb(i1480u_MAX_RX_PKT_SIZE);
|
|
if (!new_skb) {
|
|
if (printk_ratelimit())
|
|
dev_err(dev,
|
|
"RX: cannot allocate RX buffer\n");
|
|
} else {
|
|
new_skb->dev = net_dev;
|
|
new_skb->ip_summed = CHECKSUM_NONE;
|
|
skb_reserve(new_skb, 2);
|
|
rx_buf->data = new_skb;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* Called when an RX URB has finished receiving or has found some kind
|
|
* of error condition.
|
|
*
|
|
* LIMITATIONS:
|
|
*
|
|
* - We read USB-transfers, each transfer contains a SINGLE fragment
|
|
* (can contain a complete packet, or a 1st, next, or last fragment
|
|
* of a packet).
|
|
* Looks like a transfer can contain more than one fragment (07/18/06)
|
|
*
|
|
* - Each transfer buffer is the size of the maximum packet size (minus
|
|
* headroom), i1480u_MAX_PKT_SIZE - 2
|
|
*
|
|
* - We always read the full USB-transfer, no partials.
|
|
*
|
|
* - Each transfer is read directly into a skb. This skb will be used to
|
|
* send data to the upper layers if it is the first fragment or a complete
|
|
* packet. In the other cases the data will be copied from the skb to
|
|
* another skb that is being prepared for the upper layers from a prev
|
|
* first fragment.
|
|
*
|
|
* It is simply too much of a pain. Gosh, there should be a unified
|
|
* SG infrastructure for *everything* [so that I could declare a SG
|
|
* buffer, pass it to USB for receiving, append some space to it if
|
|
* I wish, receive more until I have the whole chunk, adapt
|
|
* pointers on each fragment to remove hardware headers and then
|
|
* attach that to an skbuff and netif_rx()].
|
|
*/
|
|
void i1480u_rx_cb(struct urb *urb)
|
|
{
|
|
int result;
|
|
int do_parse_buffer = 1;
|
|
struct i1480u_rx_buf *rx_buf = urb->context;
|
|
struct i1480u *i1480u = rx_buf->i1480u;
|
|
struct device *dev = &i1480u->usb_iface->dev;
|
|
unsigned long flags;
|
|
u8 rx_buf_idx = rx_buf - i1480u->rx_buf;
|
|
|
|
switch (urb->status) {
|
|
case 0:
|
|
break;
|
|
case -ECONNRESET: /* Not an error, but a controlled situation; */
|
|
case -ENOENT: /* (we killed the URB)...so, no broadcast */
|
|
case -ESHUTDOWN: /* going away! */
|
|
dev_err(dev, "RX URB[%u]: goind down %d\n",
|
|
rx_buf_idx, urb->status);
|
|
goto error;
|
|
default:
|
|
dev_err(dev, "RX URB[%u]: unknown status %d\n",
|
|
rx_buf_idx, urb->status);
|
|
if (edc_inc(&i1480u->rx_errors, EDC_MAX_ERRORS,
|
|
EDC_ERROR_TIMEFRAME)) {
|
|
dev_err(dev, "RX: max acceptable errors exceeded,"
|
|
" resetting device.\n");
|
|
i1480u_rx_unlink_urbs(i1480u);
|
|
wlp_reset_all(&i1480u->wlp);
|
|
goto error;
|
|
}
|
|
do_parse_buffer = 0;
|
|
break;
|
|
}
|
|
spin_lock_irqsave(&i1480u->lock, flags);
|
|
/* chew the data fragments, extract network packets */
|
|
if (do_parse_buffer) {
|
|
i1480u_rx_buffer(rx_buf);
|
|
if (rx_buf->data) {
|
|
rx_buf->urb->transfer_buffer = rx_buf->data->data;
|
|
result = usb_submit_urb(rx_buf->urb, GFP_ATOMIC);
|
|
if (result < 0) {
|
|
dev_err(dev, "RX URB[%u]: cannot submit %d\n",
|
|
rx_buf_idx, result);
|
|
}
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&i1480u->lock, flags);
|
|
error:
|
|
return;
|
|
}
|
|
|