/* * 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; }