i2400m/USB: TX and RX path backends

/*

 * Intel Wireless WiMAX Connection 2400m over USB

 * Notification handling

 *

 *

 * Copyright (C) 2007-2008 Intel Corporation. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 *   * Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 *   * Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in

 *     the documentation and/or other materials provided with the

 *     distribution.

 *   * Neither the name of Intel Corporation nor the names of its

 *     contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 *

 * Intel Corporation <linux-wimax@intel.com>

 * Yanir Lubetkin <yanirx.lubetkin@intel.com>

 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>

 *  - Initial implementation

 *

 *

 * The notification endpoint is active when the device is not in boot

 * mode; in here we just read and get notifications; based on those,

 * we act to either reinitialize the device after a reboot or to

 * submit a RX request.

 *

 * ROADMAP

 *

 * i2400mu_usb_notification_setup()

 *

 * i2400mu_usb_notification_release()

 *

 * i2400mu_usb_notification_cb()	Called when a URB is ready

 *   i2400mu_notif_grok()

 *     i2400m_dev_reset_handle()

 *     i2400mu_rx_kick()

 */

#include <linux/usb.h>

#include "i2400m-usb.h"

#define D_SUBMODULE notif

#include "usb-debug-levels.h"

static const

__le32 i2400m_ZERO_BARKER[4] = { 0, 0, 0, 0 };

/*

 * Process a received notification

 *

 * In normal operation mode, we can only receive two types of payloads

 * on the notification endpoint:

 *

 *   - a reboot barker, we do a bootstrap (the device has reseted).

 *

 *   - a block of zeroes: there is pending data in the IN endpoint

 */

static

int i2400mu_notification_grok(struct i2400mu *i2400mu, const void *buf,

				 size_t buf_len)

{

	int ret;

	struct device *dev = &i2400mu->usb_iface->dev;

	struct i2400m *i2400m = &i2400mu->i2400m;

	d_fnstart(4, dev, "(i2400m %p buf %p buf_len %zu)\n",

		  i2400mu, buf, buf_len);

	ret = -EIO;

	if (buf_len < sizeof(i2400m_NBOOT_BARKER))

		/* Not a bug, just ignore */

		goto error_bad_size;

	if (!memcmp(i2400m_NBOOT_BARKER, buf, sizeof(i2400m_NBOOT_BARKER))

	    || !memcmp(i2400m_SBOOT_BARKER, buf, sizeof(i2400m_SBOOT_BARKER)))

		ret = i2400m_dev_reset_handle(i2400m);

	else if (!memcmp(i2400m_ZERO_BARKER, buf, sizeof(i2400m_ZERO_BARKER))) {

		i2400mu_rx_kick(i2400mu);

		ret = 0;

	} else {	/* Unknown or unexpected data in the notif message */

		char prefix[64];

		ret = -EIO;

		dev_err(dev, "HW BUG? Unknown/unexpected data in notification "

			"message (%zu bytes)\n", buf_len);

		snprintf(prefix, sizeof(prefix), "%s %s: ",

			 dev_driver_string(dev) , dev->bus_id);

		if (buf_len > 64) {

			print_hex_dump(KERN_ERR, prefix, DUMP_PREFIX_OFFSET,

				       8, 4, buf, 64, 0);

			printk(KERN_ERR "%s... (only first 64 bytes "

			       "dumped)\n", prefix);

		} else

			print_hex_dump(KERN_ERR, prefix, DUMP_PREFIX_OFFSET,

				       8, 4, buf, buf_len, 0);

	}

error_bad_size:

	d_fnend(4, dev, "(i2400m %p buf %p buf_len %zu) = %d\n",

		i2400mu, buf, buf_len, ret);

	return ret;

}

/*

 * URB callback for the notification endpoint

 *

 * @urb: the urb received from the notification endpoint

 *

 * This function will just process the USB side of the transaction,

 * checking everything is fine, pass the processing to

 * i2400m_notification_grok() and resubmit the URB.

 */

static

void i2400mu_notification_cb(struct urb *urb)

{

	int ret;

	struct i2400mu *i2400mu = urb->context;

	struct device *dev = &i2400mu->usb_iface->dev;

	d_fnstart(4, dev, "(urb %p status %d actual_length %d)\n",

		  urb, urb->status, urb->actual_length);

	ret = urb->status;

	switch (ret) {

	case 0:

		ret = i2400mu_notification_grok(i2400mu, urb->transfer_buffer,

						urb->actual_length);

		if (ret == -EIO && edc_inc(&i2400mu->urb_edc, EDC_MAX_ERRORS,

					   EDC_ERROR_TIMEFRAME))

			goto error_exceeded;

		if (ret == -ENOMEM)	/* uff...power cycle? shutdown? */

			goto error_exceeded;

		break;

	case -EINVAL:			/* while removing driver */

	case -ENODEV:			/* dev disconnect ... */

	case -ENOENT:			/* ditto */

	case -ESHUTDOWN:		/* URB killed */

	case -ECONNRESET:		/* disconnection */

		goto out;		/* Notify around */

	default:			/* Some error? */

		if (edc_inc(&i2400mu->urb_edc,

			    EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME))

			goto error_exceeded;

		dev_err(dev, "notification: URB error %d, retrying\n",

			urb->status);

	}

	usb_mark_last_busy(i2400mu->usb_dev);

	ret = usb_submit_urb(i2400mu->notif_urb, GFP_ATOMIC);

	switch (ret) {

	case 0:

	case -EINVAL:			/* while removing driver */

	case -ENODEV:			/* dev disconnect ... */

	case -ENOENT:			/* ditto */

	case -ESHUTDOWN:		/* URB killed */

	case -ECONNRESET:		/* disconnection */

		break;			/* just ignore */

	default:			/* Some error? */

		dev_err(dev, "notification: cannot submit URB: %d\n", ret);

		goto error_submit;

	}

	d_fnend(4, dev, "(urb %p status %d actual_length %d) = void\n",

		urb, urb->status, urb->actual_length);

	return;

error_exceeded:

	dev_err(dev, "maximum errors in notification URB exceeded; "

		"resetting device\n");

error_submit:

	usb_queue_reset_device(i2400mu->usb_iface);

out:

	d_fnend(4, dev, "(urb %p status %d actual_length %d) = void\n",

		urb, urb->status, urb->actual_length);

	return;

}

/*

 * setup the notification endpoint

 *

 * @i2400m: device descriptor

 *

 * This procedure prepares the notification urb and handler for receiving

 * unsolicited barkers from the device.

 */

int i2400mu_notification_setup(struct i2400mu *i2400mu)

{

	struct device *dev = &i2400mu->usb_iface->dev;

	int usb_pipe, ret = 0;

	struct usb_endpoint_descriptor *epd;

	char *buf;

	d_fnstart(4, dev, "(i2400m %p)\n", i2400mu);

	buf = kmalloc(I2400MU_MAX_NOTIFICATION_LEN, GFP_KERNEL | GFP_DMA);

	if (buf == NULL) {

		dev_err(dev, "notification: buffer allocation failed\n");

		ret = -ENOMEM;

		goto error_buf_alloc;

	}

	i2400mu->notif_urb = usb_alloc_urb(0, GFP_KERNEL);

	if (!i2400mu->notif_urb) {

		ret = -ENOMEM;

		dev_err(dev, "notification: cannot allocate URB\n");

		goto error_alloc_urb;

	}

	epd = usb_get_epd(i2400mu->usb_iface, I2400MU_EP_NOTIFICATION);

	usb_pipe = usb_rcvintpipe(i2400mu->usb_dev, epd->bEndpointAddress);

	usb_fill_int_urb(i2400mu->notif_urb, i2400mu->usb_dev, usb_pipe,

			 buf, I2400MU_MAX_NOTIFICATION_LEN,

			 i2400mu_notification_cb, i2400mu, epd->bInterval);

	ret = usb_submit_urb(i2400mu->notif_urb, GFP_KERNEL);

	if (ret != 0) {

		dev_err(dev, "notification: cannot submit URB: %d\n", ret);

		goto error_submit;

	}

	d_fnend(4, dev, "(i2400m %p) = %d\n", i2400mu, ret);

	return ret;

error_submit:

	usb_free_urb(i2400mu->notif_urb);

error_alloc_urb:

	kfree(buf);

error_buf_alloc:

	d_fnend(4, dev, "(i2400m %p) = %d\n", i2400mu, ret);

	return ret;

}

/*

 * Tear down of the notification mechanism

 *

 * @i2400m: device descriptor

 *

 * Kill the interrupt endpoint urb, free any allocated resources.

 *

 * We need to check if we have done it before as for example,

 * _suspend() call this; if after a suspend() we get a _disconnect()

 * (as the case is when hibernating), nothing bad happens.

 */

void i2400mu_notification_release(struct i2400mu *i2400mu)

{

	struct device *dev = &i2400mu->usb_iface->dev;

	d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu);

	if (i2400mu->notif_urb != NULL) {

		usb_kill_urb(i2400mu->notif_urb);

		kfree(i2400mu->notif_urb->transfer_buffer);

		usb_free_urb(i2400mu->notif_urb);

		i2400mu->notif_urb = NULL;

	}

	d_fnend(4, dev, "(i2400mu %p)\n", i2400mu);

}

/*

 * Intel Wireless WiMAX Connection 2400m

 * USB RX handling

 *

 *

 * Copyright (C) 2007-2008 Intel Corporation. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 *   * Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 *   * Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in

 *     the documentation and/or other materials provided with the

 *     distribution.

 *   * Neither the name of Intel Corporation nor the names of its

 *     contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 *

 * Intel Corporation <linux-wimax@intel.com>

 * Yanir Lubetkin <yanirx.lubetkin@intel.com>

 *  - Initial implementation

 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>

 *  - Use skb_clone(), break up processing in chunks

 *  - Split transport/device specific

 *  - Make buffer size dynamic to exert less memory pressure

 *

 *

 * This handles the RX path on USB.

 *

 * When a notification is received that says 'there is RX data ready',

 * we call i2400mu_rx_kick(); that wakes up the RX kthread, which

 * reads a buffer from USB and passes it to i2400m_rx() in the generic

 * handling code. The RX buffer has an specific format that is

 * described in rx.c.

 *

 * We use a kernel thread in a loop because:

 *

 *  - we want to be able to call the USB power management get/put

 *    functions (blocking) before each transaction.

 *

 *  - We might get a lot of notifications and we don't want to submit

 *    a zillion reads; by serializing, we are throttling.

 *

 *  - RX data processing can get heavy enough so that it is not

 *    appropiate for doing it in the USB callback; thus we run it in a

 *    process context.

 *

 * We provide a read buffer of an arbitrary size (short of a page); if

 * the callback reports -EOVERFLOW, it means it was too small, so we

 * just double the size and retry (being careful to append, as

 * sometimes the device provided some data). Every now and then we

 * check if the average packet size is smaller than the current packet

 * size and if so, we halve it. At the end, the size of the

 * preallocated buffer should be following the average received

 * transaction size, adapting dynamically to it.

 *

 * ROADMAP

 *

 * i2400mu_rx_kick()		   Called from notif.c when we get a

 *   			           'data ready' notification

 * i2400mu_rxd()                   Kernel RX daemon

 *   i2400mu_rx()                  Receive USB data

 *   i2400m_rx()                   Send data to generic i2400m RX handling

 *

 * i2400mu_rx_setup()              called from i2400mu_bus_dev_start()

 *

 * i2400mu_rx_release()            called from i2400mu_bus_dev_stop()

 */

#include <linux/workqueue.h>

#include <linux/usb.h>

#include "i2400m-usb.h"

#define D_SUBMODULE rx

#include "usb-debug-levels.h"

/*

 * Dynamic RX size

 *

 * We can't let the rx_size be a multiple of 512 bytes (the RX

 * endpoint's max packet size). On some USB host controllers (we

 * haven't been able to fully characterize which), if the device is

 * about to send (for example) X bytes and we only post a buffer to

 * receive n*512, it will fail to mark that as babble (so that

 * i2400mu_rx() [case -EOVERFLOW] can resize the buffer and get the

 * rest).

 *

 * So on growing or shrinking, if it is a multiple of the

 * maxpacketsize, we remove some (instead of incresing some, so in a

 * buddy allocator we try to waste less space).

 *

 * Note we also need a hook for this on i2400mu_rx() -- when we do the

 * first read, we are sure we won't hit this spot because

 * i240mm->rx_size has been set properly. However, if we have to

 * double because of -EOVERFLOW, when we launch the read to get the

 * rest of the data, we *have* to make sure that also is not a

 * multiple of the max_pkt_size.

 */

static

size_t i2400mu_rx_size_grow(struct i2400mu *i2400mu)

{

	struct device *dev = &i2400mu->usb_iface->dev;

	size_t rx_size;

	const size_t max_pkt_size = 512;

	rx_size = 2 * i2400mu->rx_size;

	if (rx_size % max_pkt_size == 0) {

		rx_size -= 8;

		d_printf(1, dev,

			 "RX: expected size grew to %zu [adjusted -8] "

			 "from %zu\n",

			 rx_size, i2400mu->rx_size);

	} else

		d_printf(1, dev,

			 "RX: expected size grew to %zu from %zu\n",

			 rx_size, i2400mu->rx_size);

	return rx_size;

}

static

void i2400mu_rx_size_maybe_shrink(struct i2400mu *i2400mu)

{

	const size_t max_pkt_size = 512;

	struct device *dev = &i2400mu->usb_iface->dev;

	if (unlikely(i2400mu->rx_size_cnt >= 100

		     && i2400mu->rx_size_auto_shrink)) {

		size_t avg_rx_size =

			i2400mu->rx_size_acc / i2400mu->rx_size_cnt;

		size_t new_rx_size = i2400mu->rx_size / 2;

		if (avg_rx_size < new_rx_size) {

			if (new_rx_size % max_pkt_size == 0) {

				new_rx_size -= 8;

				d_printf(1, dev,

					 "RX: expected size shrank to %zu "

					 "[adjusted -8] from %zu\n",

					 new_rx_size, i2400mu->rx_size);

			} else

				d_printf(1, dev,

					 "RX: expected size shrank to %zu "

					 "from %zu\n",

					 new_rx_size, i2400mu->rx_size);

			i2400mu->rx_size = new_rx_size;

			i2400mu->rx_size_cnt = 0;

			i2400mu->rx_size_acc = i2400mu->rx_size;

		}

	}

}

/*

 * Receive a message with payloads from the USB bus into an skb

 *

 * @i2400mu: USB device descriptor

 * @rx_skb: skb where to place the received message

 *

 * Deals with all the USB-specifics of receiving, dynamically

 * increasing the buffer size if so needed. Returns the payload in the

 * skb, ready to process. On a zero-length packet, we retry.

 *

 * On soft USB errors, we retry (until they become too frequent and

 * then are promoted to hard); on hard USB errors, we reset the

 * device. On other errors (skb realloacation, we just drop it and

 * hope for the next invocation to solve it).

 *

 * Returns: pointer to the skb if ok, ERR_PTR on error.

 *   NOTE: this function might realloc the skb (if it is too small),

 *   so always update with the one returned.

 *   ERR_PTR() is < 0 on error.

 */

static

struct sk_buff *i2400mu_rx(struct i2400mu *i2400mu, struct sk_buff *rx_skb)

{

	int result = 0;

	struct device *dev = &i2400mu->usb_iface->dev;

	int usb_pipe, read_size, rx_size, do_autopm;

	struct usb_endpoint_descriptor *epd;

	const size_t max_pkt_size = 512;

	d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu);

	do_autopm = atomic_read(&i2400mu->do_autopm);

	result = do_autopm ?

		usb_autopm_get_interface(i2400mu->usb_iface) : 0;

	if (result < 0) {

		dev_err(dev, "RX: can't get autopm: %d\n", result);

		do_autopm = 0;

	}

	epd = usb_get_epd(i2400mu->usb_iface, I2400MU_EP_BULK_IN);

	usb_pipe = usb_rcvbulkpipe(i2400mu->usb_dev, epd->bEndpointAddress);

retry:

	rx_size = skb_end_pointer(rx_skb) - rx_skb->data - rx_skb->len;

	if (unlikely(rx_size % max_pkt_size == 0)) {

		rx_size -= 8;

		d_printf(1, dev, "RX: rx_size adapted to %d [-8]\n", rx_size);

	}

	result = usb_bulk_msg(

		i2400mu->usb_dev, usb_pipe, rx_skb->data + rx_skb->len,

		rx_size, &read_size, HZ);

	usb_mark_last_busy(i2400mu->usb_dev);

	switch (result) {

	case 0:

		if (read_size == 0)

			goto retry;	/* ZLP, just resubmit */

		skb_put(rx_skb, read_size);

		break;

	case -EINVAL:			/* while removing driver */

	case -ENODEV:			/* dev disconnect ... */

	case -ENOENT:			/* just ignore it */

	case -ESHUTDOWN:

	case -ECONNRESET:

		break;

	case -EOVERFLOW: {		/* too small, reallocate */

		struct sk_buff *new_skb;

		rx_size = i2400mu_rx_size_grow(i2400mu);

		if (rx_size <= (1 << 16))	/* cap it */

			i2400mu->rx_size = rx_size;

		else if (printk_ratelimit()) {

			dev_err(dev, "BUG? rx_size up to %d\n", rx_size);

			result = -EINVAL;

			goto out;

		}

		skb_put(rx_skb, read_size);

		new_skb = skb_copy_expand(rx_skb, 0, rx_size - rx_skb->len,

					  GFP_KERNEL);

		if (new_skb == NULL) {

			if (printk_ratelimit())

				dev_err(dev, "RX: Can't reallocate skb to %d; "

					"RX dropped\n", rx_size);

			kfree(rx_skb);

			result = 0;

			goto out;	/* drop it...*/

		}

		kfree_skb(rx_skb);

		rx_skb = new_skb;

		i2400mu->rx_size_cnt = 0;

		i2400mu->rx_size_acc = i2400mu->rx_size;

		d_printf(1, dev, "RX: size changed to %d, received %d, "

			 "copied %d, capacity %ld\n",

			 rx_size, read_size, rx_skb->len,

			 (long) (skb_end_pointer(new_skb) - new_skb->head));

		goto retry;

	}

		/* In most cases, it happens due to the hardware scheduling a

		 * read when there was no data - unfortunately, we have no way

		 * to tell this timeout from a USB timeout. So we just ignore

		 * it. */

	case -ETIMEDOUT:

		dev_err(dev, "RX: timeout: %d\n", result);

		result = 0;

		break;

	default:			/* Any error */

		if (edc_inc(&i2400mu->urb_edc,

			    EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME))

			goto error_reset;

		dev_err(dev, "RX: error receiving URB: %d, retrying\n", result);

		goto retry;

	}

out:

	if (do_autopm)

		usb_autopm_put_interface(i2400mu->usb_iface);

	d_fnend(4, dev, "(i2400mu %p) = %p\n", i2400mu, rx_skb);

	return rx_skb;

error_reset:

	dev_err(dev, "RX: maximum errors in URB exceeded; "

		"resetting device\n");

	usb_queue_reset_device(i2400mu->usb_iface);

	rx_skb = ERR_PTR(result);

	goto out;

}

/*

 * Kernel thread for USB reception of data

 *

 * This thread waits for a kick; once kicked, it will allocate an skb

 * and receive a single message to it from USB (using

 * i2400mu_rx()). Once received, it is passed to the generic i2400m RX

 * code for processing.

 *

 * When done processing, it runs some dirty statistics to verify if

 * the last 100 messages received were smaller than half of the

 * current RX buffer size. In that case, the RX buffer size is

 * halved. This will helps lowering the pressure on the memory

 * allocator.

 *

 * Hard errors force the thread to exit.

 */

static

int i2400mu_rxd(void *_i2400mu)

{

	int result = 0;

	struct i2400mu *i2400mu = _i2400mu;

	struct i2400m *i2400m = &i2400mu->i2400m;

	struct device *dev = &i2400mu->usb_iface->dev;

	struct net_device *net_dev = i2400m->wimax_dev.net_dev;

	size_t pending;

	int rx_size;

	struct sk_buff *rx_skb;

	d_fnstart(4, dev, "(i2400mu %p)\n", i2400mu);

	while (1) {

		d_printf(2, dev, "TX: waiting for messages\n");

		pending = 0;

		wait_event_interruptible(

			i2400mu->rx_wq,

			(kthread_should_stop()	/* check this first! */

			 || (pending = atomic_read(&i2400mu->rx_pending_count)))

			);

		if (kthread_should_stop())

			break;

		if (pending == 0)

			continue;

		rx_size = i2400mu->rx_size;

		d_printf(2, dev, "RX: reading up to %d bytes\n", rx_size);

		rx_skb = __netdev_alloc_skb(net_dev, rx_size, GFP_KERNEL);

		if (rx_skb == NULL) {

			dev_err(dev, "RX: can't allocate skb [%d bytes]\n",

				rx_size);

			msleep(50);	/* give it some time? */

			continue;

		}

		/* Receive the message with the payloads */

		rx_skb = i2400mu_rx(i2400mu, rx_skb);

		result = PTR_ERR(rx_skb);

		if (IS_ERR(rx_skb))

			goto out;

		atomic_dec(&i2400mu->rx_pending_count);

		if (rx_skb->len == 0) {	/* some ignorable condition */

			kfree_skb(rx_skb);

			continue;

		}

		/* Deliver the message to the generic i2400m code */

		i2400mu->rx_size_cnt++;

		i2400mu->rx_size_acc += rx_skb->len;

		result = i2400m_rx(i2400m, rx_skb);

		if (result == -EIO

		    && edc_inc(&i2400mu->urb_edc,

			       EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {

			goto error_reset;

		}

		/* Maybe adjust RX buffer size */

		i2400mu_rx_size_maybe_shrink(i2400mu);

	}

	result = 0;

out:

	d_fnend(4, dev, "(i2400mu %p) = %d\n", i2400mu, result);

	return result;

error_reset:

	dev_err(dev, "RX: maximum errors in received buffer exceeded; "

		"resetting device\n");

	usb_queue_reset_device(i2400mu->usb_iface);

	goto out;

}

/*

 * Start reading from the device

 *

 * @i2400m: device instance

 *

 * Notify the RX thread that there is data pending.

 */

void i2400mu_rx_kick(struct i2400mu *i2400mu)

{

	struct i2400m *i2400m = &i2400mu->i2400m;

	struct device *dev = &i2400mu->usb_iface->dev;

	d_fnstart(3, dev, "(i2400mu %p)\n", i2400m);

	atomic_inc(&i2400mu->rx_pending_count);

	wake_up_all(&i2400mu->rx_wq);

	d_fnend(3, dev, "(i2400m %p) = void\n", i2400m);

}

int i2400mu_rx_setup(struct i2400mu *i2400mu)

{

	int result = 0;

	struct i2400m *i2400m = &i2400mu->i2400m;

	struct device *dev = &i2400mu->usb_iface->dev;

	struct wimax_dev *wimax_dev = &i2400m->wimax_dev;

	i2400mu->rx_kthread = kthread_run(i2400mu_rxd, i2400mu, "%s-rx",

					  wimax_dev->name);

	if (IS_ERR(i2400mu->rx_kthread)) {

		result = PTR_ERR(i2400mu->rx_kthread);