drivers/usb/wusbcore/wa-rpipe.c - kernel/bruno - Git at Google

 /*
  * WUSB Wire Adapter
  * rpipe management
  *
  * 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.
  *
  *
  * FIXME: docs
  *
  * RPIPE
  *
  *   Targeted at different downstream endpoints
  *
  *   Descriptor: use to config the remote pipe.
  *
  *   The number of blocks could be dynamic (wBlocks in descriptor is
  *   0)--need to schedule them then.
  *
  * Each bit in wa->rpipe_bm represents if an rpipe is being used or
  * not. Rpipes are represented with a 'struct wa_rpipe' that is
  * attached to the hcpriv member of a 'struct usb_host_endpoint'.
  *
  * When you need to xfer data to an endpoint, you get an rpipe for it
  * with wa_ep_rpipe_get(), which gives you a reference to the rpipe
  * and keeps a single one (the first one) with the endpoint. When you
  * are done transferring, you drop that reference. At the end the
  * rpipe is always allocated and bound to the endpoint. There it might
  * be recycled when not used.
  *
  * Addresses:
  *
  *  We use a 1:1 mapping mechanism between port address (0 based
  *  index, actually) and the address. The USB stack knows about this.
  *
  *  USB Stack port number    4 (1 based)
  *  WUSB code port index     3 (0 based)
  *  USB Address             5 (2 based -- 0 is for default, 1 for root hub)
  *
  *  Now, because we don't use the concept as default address exactly
  *  like the (wired) USB code does, we need to kind of skip it. So we
  *  never take addresses from the urb->pipe, but from the
  *  urb->dev->devnum, to make sure that we always have the right
  *  destination address.
  */
 #include <linux/atomic.h>
 #include <linux/bitmap.h>
 #include <linux/slab.h>
 #include <linux/export.h>

 #include "wusbhc.h"
 #include "wa-hc.h"

 static int __rpipe_get_descr(struct wahc *wa,
 			     struct usb_rpipe_descriptor *descr, u16 index)
 {
 	ssize_t result;
 	struct device *dev = &wa->usb_iface->dev;

 	/* Get the RPIPE descriptor -- we cannot use the usb_get_descriptor()
 	 * function because the arguments are different.
 	 */
 	result = usb_control_msg(
 		wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
 		USB_REQ_GET_DESCRIPTOR,
 		USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_RPIPE,
 		USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
 		USB_CTRL_GET_TIMEOUT);
 	if (result < 0) {
 		dev_err(dev, "rpipe %u: get descriptor failed: %d\n",
 			index, (int)result);
 		goto error;
 	}
 	if (result < sizeof(*descr)) {
 		dev_err(dev, "rpipe %u: got short descriptor "
 			"(%zd vs %zd bytes needed)\n",
 			index, result, sizeof(*descr));
 		result = -EINVAL;
 		goto error;
 	}
 	result = 0;

 error:
 	return result;
 }

 /*
  *
  * The descriptor is assumed to be properly initialized (ie: you got
  * it through __rpipe_get_descr()).
  */
 static int __rpipe_set_descr(struct wahc *wa,
 			     struct usb_rpipe_descriptor *descr, u16 index)
 {
 	ssize_t result;
 	struct device *dev = &wa->usb_iface->dev;

 	/* we cannot use the usb_get_descriptor() function because the
 	 * arguments are different.
 	 */
 	result = usb_control_msg(
 		wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
 		USB_REQ_SET_DESCRIPTOR,
 		USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
 		USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
 		USB_CTRL_SET_TIMEOUT);
 	if (result < 0) {
 		dev_err(dev, "rpipe %u: set descriptor failed: %d\n",
 			index, (int)result);
 		goto error;
 	}
 	if (result < sizeof(*descr)) {
 		dev_err(dev, "rpipe %u: sent short descriptor "
 			"(%zd vs %zd bytes required)\n",
 			index, result, sizeof(*descr));
 		result = -EINVAL;
 		goto error;
 	}
 	result = 0;

 error:
 	return result;

 }

 static void rpipe_init(struct wa_rpipe *rpipe)
 {
 	kref_init(&rpipe->refcnt);
 	spin_lock_init(&rpipe->seg_lock);
 	INIT_LIST_HEAD(&rpipe->seg_list);
 	INIT_LIST_HEAD(&rpipe->list_node);
 }

 static unsigned rpipe_get_idx(struct wahc *wa, unsigned rpipe_idx)
 {
 	unsigned long flags;

 	spin_lock_irqsave(&wa->rpipe_lock, flags);
 	rpipe_idx = find_next_zero_bit(wa->rpipe_bm, wa->rpipes, rpipe_idx);
 	if (rpipe_idx < wa->rpipes)
 		set_bit(rpipe_idx, wa->rpipe_bm);
 	spin_unlock_irqrestore(&wa->rpipe_lock, flags);

 	return rpipe_idx;
 }

 static void rpipe_put_idx(struct wahc *wa, unsigned rpipe_idx)
 {
 	unsigned long flags;

 	spin_lock_irqsave(&wa->rpipe_lock, flags);
 	clear_bit(rpipe_idx, wa->rpipe_bm);
 	spin_unlock_irqrestore(&wa->rpipe_lock, flags);
 }

 void rpipe_destroy(struct kref *_rpipe)
 {
 	struct wa_rpipe *rpipe = container_of(_rpipe, struct wa_rpipe, refcnt);
 	u8 index = le16_to_cpu(rpipe->descr.wRPipeIndex);

 	if (rpipe->ep)
 		rpipe->ep->hcpriv = NULL;
 	rpipe_put_idx(rpipe->wa, index);
 	wa_put(rpipe->wa);
 	kfree(rpipe);
 }
 EXPORT_SYMBOL_GPL(rpipe_destroy);

 /*
  * Locate an idle rpipe, create an structure for it and return it
  *
  * @wa	  is referenced and unlocked
  * @crs   enum rpipe_attr, required endpoint characteristics
  *
  * The rpipe can be used only sequentially (not in parallel).
  *
  * The rpipe is moved into the "ready" state.
  */
 static int rpipe_get_idle(struct wa_rpipe **prpipe, struct wahc *wa, u8 crs,
 			  gfp_t gfp)
 {
 	int result;
 	unsigned rpipe_idx;
 	struct wa_rpipe *rpipe;
 	struct device *dev = &wa->usb_iface->dev;

 	rpipe = kzalloc(sizeof(*rpipe), gfp);
 	if (rpipe == NULL)
 		return -ENOMEM;
 	rpipe_init(rpipe);

 	/* Look for an idle pipe */
 	for (rpipe_idx = 0; rpipe_idx < wa->rpipes; rpipe_idx++) {
 		rpipe_idx = rpipe_get_idx(wa, rpipe_idx);
 		if (rpipe_idx >= wa->rpipes)	/* no more pipes :( */
 			break;
 		result =  __rpipe_get_descr(wa, &rpipe->descr, rpipe_idx);
 		if (result < 0)
 			dev_err(dev, "Can't get descriptor for rpipe %u: %d\n",
 				rpipe_idx, result);
 		else if ((rpipe->descr.bmCharacteristics & crs) != 0)
 			goto found;
 		rpipe_put_idx(wa, rpipe_idx);
 	}
 	*prpipe = NULL;
 	kfree(rpipe);
 	return -ENXIO;

 found:
 	set_bit(rpipe_idx, wa->rpipe_bm);
 	rpipe->wa = wa_get(wa);
 	*prpipe = rpipe;
 	return 0;
 }

 static int __rpipe_reset(struct wahc *wa, unsigned index)
 {
 	int result;
 	struct device *dev = &wa->usb_iface->dev;

 	result = usb_control_msg(
 		wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
 		USB_REQ_RPIPE_RESET,
 		USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
 		0, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
 	if (result < 0)
 		dev_err(dev, "rpipe %u: reset failed: %d\n",
 			index, result);
 	return result;
 }

 /*
  * Fake companion descriptor for ep0
  *
  * See WUSB1.0[7.4.4], most of this is zero for bulk/int/ctl
  */
 static struct usb_wireless_ep_comp_descriptor epc0 = {
 	.bLength = sizeof(epc0),
 	.bDescriptorType = USB_DT_WIRELESS_ENDPOINT_COMP,
 	.bMaxBurst = 1,
 	.bMaxSequence = 2,
 };

 /*
  * Look for EP companion descriptor
  *
  * Get there, look for Inara in the endpoint's extra descriptors
  */
 static struct usb_wireless_ep_comp_descriptor *rpipe_epc_find(
 		struct device *dev, struct usb_host_endpoint *ep)
 {
 	void *itr;
 	size_t itr_size;
 	struct usb_descriptor_header *hdr;
 	struct usb_wireless_ep_comp_descriptor *epcd;

 	if (ep->desc.bEndpointAddress == 0) {
 		epcd = &epc0;
 		goto out;
 	}
 	itr = ep->extra;
 	itr_size = ep->extralen;
 	epcd = NULL;
 	while (itr_size > 0) {
 		if (itr_size < sizeof(*hdr)) {
 			dev_err(dev, "HW Bug? ep 0x%02x: extra descriptors "
 				"at offset %zu: only %zu bytes left\n",
 				ep->desc.bEndpointAddress,
 				itr - (void *) ep->extra, itr_size);
 			break;
 		}
 		hdr = itr;
 		if (hdr->bDescriptorType == USB_DT_WIRELESS_ENDPOINT_COMP) {
 			epcd = itr;
 			break;
 		}
 		if (hdr->bLength > itr_size) {
 			dev_err(dev, "HW Bug? ep 0x%02x: extra descriptor "
 				"at offset %zu (type 0x%02x) "
 				"length %d but only %zu bytes left\n",
 				ep->desc.bEndpointAddress,
 				itr - (void *) ep->extra, hdr->bDescriptorType,
 				hdr->bLength, itr_size);
 			break;
 		}
 		itr += hdr->bLength;
 		itr_size -= hdr->bLength;
 	}
 out:
 	return epcd;
 }

 /*
  * Aim an rpipe to its device & endpoint destination
  *
  * Make sure we change the address to unauthenticated if the device
  * is WUSB and it is not authenticated.
  */
 static int rpipe_aim(struct wa_rpipe *rpipe, struct wahc *wa,
 		     struct usb_host_endpoint *ep, struct urb *urb, gfp_t gfp)
 {
 	int result = -ENOMSG;	/* better code for lack of companion? */
 	struct device *dev = &wa->usb_iface->dev;
 	struct usb_device *usb_dev = urb->dev;
 	struct usb_wireless_ep_comp_descriptor *epcd;
 	u32 ack_window, epcd_max_sequence;
 	u8 unauth;

 	epcd = rpipe_epc_find(dev, ep);
 	if (epcd == NULL) {
 		dev_err(dev, "ep 0x%02x: can't find companion descriptor\n",
 			ep->desc.bEndpointAddress);
 		goto error;
 	}
 	unauth = usb_dev->wusb && !usb_dev->authenticated ? 0x80 : 0;
 	__rpipe_reset(wa, le16_to_cpu(rpipe->descr.wRPipeIndex));
 	atomic_set(&rpipe->segs_available,
 		le16_to_cpu(rpipe->descr.wRequests));
 	/* FIXME: block allocation system; request with queuing and timeout */
 	/* FIXME: compute so seg_size > ep->maxpktsize */
 	rpipe->descr.wBlocks = cpu_to_le16(16);		/* given */
 	/* ep0 maxpktsize is 0x200 (WUSB1.0[4.8.1]) */
 	if (usb_endpoint_xfer_isoc(&ep->desc))
 		rpipe->descr.wMaxPacketSize = epcd->wOverTheAirPacketSize;
 	else
 		rpipe->descr.wMaxPacketSize = ep->desc.wMaxPacketSize;

 	rpipe->descr.hwa_bMaxBurst = max(min_t(unsigned int,
 				epcd->bMaxBurst, 16U), 1U);
 	rpipe->descr.hwa_bDeviceInfoIndex =
 			wusb_port_no_to_idx(urb->dev->portnum);
 	/* FIXME: use maximum speed as supported or recommended by device */
 	rpipe->descr.bSpeed = usb_pipeendpoint(urb->pipe) == 0 ?
 		UWB_PHY_RATE_53 : UWB_PHY_RATE_200;

 	dev_dbg(dev, "addr %u (0x%02x) rpipe #%u ep# %u speed %d\n",
 		urb->dev->devnum, urb->dev->devnum | unauth,
 		le16_to_cpu(rpipe->descr.wRPipeIndex),
 		usb_pipeendpoint(urb->pipe), rpipe->descr.bSpeed);

 	rpipe->descr.hwa_reserved = 0;

 	rpipe->descr.bEndpointAddress = ep->desc.bEndpointAddress;
 	/* FIXME: bDataSequence */
 	rpipe->descr.bDataSequence = 0;

 	/* start with base window of hwa_bMaxBurst bits starting at 0. */
 	ack_window = 0xFFFFFFFF >> (32 - rpipe->descr.hwa_bMaxBurst);
 	rpipe->descr.dwCurrentWindow = cpu_to_le32(ack_window);
 	epcd_max_sequence = max(min_t(unsigned int,
 			epcd->bMaxSequence, 32U), 2U);
 	rpipe->descr.bMaxDataSequence = epcd_max_sequence - 1;
 	rpipe->descr.bInterval = ep->desc.bInterval;
 	if (usb_endpoint_xfer_isoc(&ep->desc))
 		rpipe->descr.bOverTheAirInterval = epcd->bOverTheAirInterval;
 	else
 		rpipe->descr.bOverTheAirInterval = 0;	/* 0 if not isoc */
 	/* FIXME: xmit power & preamble blah blah */
 	rpipe->descr.bmAttribute = (ep->desc.bmAttributes &
 					USB_ENDPOINT_XFERTYPE_MASK);
 	/* rpipe->descr.bmCharacteristics RO */
 	rpipe->descr.bmRetryOptions = (wa->wusb->retry_count & 0xF);
 	/* FIXME: use for assessing link quality? */
 	rpipe->descr.wNumTransactionErrors = 0;
 	result = __rpipe_set_descr(wa, &rpipe->descr,
 				   le16_to_cpu(rpipe->descr.wRPipeIndex));
 	if (result < 0) {
 		dev_err(dev, "Cannot aim rpipe: %d\n", result);
 		goto error;
 	}
 	result = 0;
 error:
 	return result;
 }

 /*
  * Check an aimed rpipe to make sure it points to where we want
  *
  * We use bit 19 of the Linux USB pipe bitmap for unauth vs auth
  * space; when it is like that, we or 0x80 to make an unauth address.
  */
 static int rpipe_check_aim(const struct wa_rpipe *rpipe, const struct wahc *wa,
 			   const struct usb_host_endpoint *ep,
 			   const struct urb *urb, gfp_t gfp)
 {
 	int result = 0;
 	struct device *dev = &wa->usb_iface->dev;
 	u8 portnum = wusb_port_no_to_idx(urb->dev->portnum);

 #define AIM_CHECK(rdf, val, text)					\
 	do {								\
 		if (rpipe->descr.rdf != (val)) {			\
 			dev_err(dev,					\
 				"rpipe aim discrepancy: " #rdf " " text "\n", \
 				rpipe->descr.rdf, (val));		\
 			result = -EINVAL;				\
 			WARN_ON(1);					\
 		}							\
 	} while (0)
 	AIM_CHECK(hwa_bDeviceInfoIndex, portnum, "(%u vs %u)");
 	AIM_CHECK(bSpeed, usb_pipeendpoint(urb->pipe) == 0 ?
 			UWB_PHY_RATE_53 : UWB_PHY_RATE_200,
 		  "(%u vs %u)");
 	AIM_CHECK(bEndpointAddress, ep->desc.bEndpointAddress, "(%u vs %u)");
 	AIM_CHECK(bInterval, ep->desc.bInterval, "(%u vs %u)");
 	AIM_CHECK(bmAttribute, ep->desc.bmAttributes & 0x03, "(%u vs %u)");
 #undef AIM_CHECK
 	return result;
 }

 #ifndef CONFIG_BUG
 #define CONFIG_BUG 0
 #endif

 /*
  * Make sure there is an rpipe allocated for an endpoint
  *
  * If already allocated, we just refcount it; if not, we get an
  * idle one, aim it to the right location and take it.
  *
  * Attaches to ep->hcpriv and rpipe->ep to ep.
  */
 int rpipe_get_by_ep(struct wahc *wa, struct usb_host_endpoint *ep,
 		    struct urb *urb, gfp_t gfp)
 {
 	int result = 0;
 	struct device *dev = &wa->usb_iface->dev;
 	struct wa_rpipe *rpipe;
 	u8 eptype;

 	mutex_lock(&wa->rpipe_mutex);
 	rpipe = ep->hcpriv;
 	if (rpipe != NULL) {
 		if (CONFIG_BUG == 1) {
 			result = rpipe_check_aim(rpipe, wa, ep, urb, gfp);
 			if (result < 0)
 				goto error;
 		}
 		__rpipe_get(rpipe);
 		dev_dbg(dev, "ep 0x%02x: reusing rpipe %u\n",
 			ep->desc.bEndpointAddress,
 			le16_to_cpu(rpipe->descr.wRPipeIndex));
 	} else {
 		/* hmm, assign idle rpipe, aim it */
 		result = -ENOBUFS;
 		eptype = ep->desc.bmAttributes & 0x03;
 		result = rpipe_get_idle(&rpipe, wa, 1 << eptype, gfp);
 		if (result < 0)
 			goto error;
 		result = rpipe_aim(rpipe, wa, ep, urb, gfp);
 		if (result < 0) {
 			rpipe_put(rpipe);
 			goto error;
 		}
 		ep->hcpriv = rpipe;
 		rpipe->ep = ep;
 		__rpipe_get(rpipe);	/* for caching into ep->hcpriv */
 		dev_dbg(dev, "ep 0x%02x: using rpipe %u\n",
 			ep->desc.bEndpointAddress,
 			le16_to_cpu(rpipe->descr.wRPipeIndex));
 	}
 error:
 	mutex_unlock(&wa->rpipe_mutex);
 	return result;
 }

 /*
  * Allocate the bitmap for each rpipe.
  */
 int wa_rpipes_create(struct wahc *wa)
 {
 	wa->rpipes = le16_to_cpu(wa->wa_descr->wNumRPipes);
 	wa->rpipe_bm = kzalloc(BITS_TO_LONGS(wa->rpipes)*sizeof(unsigned long),
 			       GFP_KERNEL);
 	if (wa->rpipe_bm == NULL)
 		return -ENOMEM;
 	return 0;
 }

 void wa_rpipes_destroy(struct wahc *wa)
 {
 	struct device *dev = &wa->usb_iface->dev;

 	if (!bitmap_empty(wa->rpipe_bm, wa->rpipes)) {
 		WARN_ON(1);
 		dev_err(dev, "BUG: pipes not released on exit: %*pb\n",
 			wa->rpipes, wa->rpipe_bm);
 	}
 	kfree(wa->rpipe_bm);
 }

 /*
  * Release resources allocated for an endpoint
  *
  * If there is an associated rpipe to this endpoint, Abort any pending
  * transfers and put it. If the rpipe ends up being destroyed,
  * __rpipe_destroy() will cleanup ep->hcpriv.
  *
  * This is called before calling hcd->stop(), so you don't need to do
  * anything else in there.
  */
 void rpipe_ep_disable(struct wahc *wa, struct usb_host_endpoint *ep)
 {
 	struct wa_rpipe *rpipe;

 	mutex_lock(&wa->rpipe_mutex);
 	rpipe = ep->hcpriv;
 	if (rpipe != NULL) {
 		u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);

 		usb_control_msg(
 			wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
 			USB_REQ_RPIPE_ABORT,
 			USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
 			0, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
 		rpipe_put(rpipe);
 	}
 	mutex_unlock(&wa->rpipe_mutex);
 }
 EXPORT_SYMBOL_GPL(rpipe_ep_disable);

 /* Clear the stalled status of an RPIPE. */
 void rpipe_clear_feature_stalled(struct wahc *wa, struct usb_host_endpoint *ep)
 {
 	struct wa_rpipe *rpipe;

 	mutex_lock(&wa->rpipe_mutex);
 	rpipe = ep->hcpriv;
 	if (rpipe != NULL) {
 		u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);

 		usb_control_msg(
 			wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
 			USB_REQ_CLEAR_FEATURE,
 			USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
 			RPIPE_STALL, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
 	}
 	mutex_unlock(&wa->rpipe_mutex);
 }
 EXPORT_SYMBOL_GPL(rpipe_clear_feature_stalled);
	/*
	* WUSB Wire Adapter
	* rpipe management
	*
	* 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.
	*
	*
	* FIXME: docs
	*
	* RPIPE
	*
	* Targeted at different downstream endpoints
	*
	* Descriptor: use to config the remote pipe.
	*
	* The number of blocks could be dynamic (wBlocks in descriptor is
	* 0)--need to schedule them then.
	*
	* Each bit in wa->rpipe_bm represents if an rpipe is being used or
	* not. Rpipes are represented with a 'struct wa_rpipe' that is
	* attached to the hcpriv member of a 'struct usb_host_endpoint'.
	*
	* When you need to xfer data to an endpoint, you get an rpipe for it
	* with wa_ep_rpipe_get(), which gives you a reference to the rpipe
	* and keeps a single one (the first one) with the endpoint. When you
	* are done transferring, you drop that reference. At the end the
	* rpipe is always allocated and bound to the endpoint. There it might
	* be recycled when not used.
	*
	* Addresses:
	*
	* We use a 1:1 mapping mechanism between port address (0 based
	* index, actually) and the address. The USB stack knows about this.
	*
	* USB Stack port number 4 (1 based)
	* WUSB code port index 3 (0 based)
	* USB Address 5 (2 based -- 0 is for default, 1 for root hub)
	*
	* Now, because we don't use the concept as default address exactly
	* like the (wired) USB code does, we need to kind of skip it. So we
	* never take addresses from the urb->pipe, but from the
	* urb->dev->devnum, to make sure that we always have the right
	* destination address.
	*/
	#include <linux/atomic.h>
	#include <linux/bitmap.h>
	#include <linux/slab.h>
	#include <linux/export.h>

	#include "wusbhc.h"
	#include "wa-hc.h"

	static int __rpipe_get_descr(struct wahc *wa,
	struct usb_rpipe_descriptor *descr, u16 index)
	{
	ssize_t result;
	struct device *dev = &wa->usb_iface->dev;

	/* Get the RPIPE descriptor -- we cannot use the usb_get_descriptor()
	* function because the arguments are different.
	*/
	result = usb_control_msg(
	wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
	USB_REQ_GET_DESCRIPTOR,
	USB_DIR_IN \| USB_TYPE_CLASS \| USB_RECIP_RPIPE,
	USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
	USB_CTRL_GET_TIMEOUT);
	if (result < 0) {
	dev_err(dev, "rpipe %u: get descriptor failed: %d\n",
	index, (int)result);
	goto error;
	}
	if (result < sizeof(*descr)) {
	dev_err(dev, "rpipe %u: got short descriptor "
	"(%zd vs %zd bytes needed)\n",
	index, result, sizeof(*descr));
	result = -EINVAL;
	goto error;
	}
	result = 0;

	error:
	return result;
	}

	/*
	*
	* The descriptor is assumed to be properly initialized (ie: you got
	* it through __rpipe_get_descr()).
	*/
	static int __rpipe_set_descr(struct wahc *wa,
	struct usb_rpipe_descriptor *descr, u16 index)
	{
	ssize_t result;
	struct device *dev = &wa->usb_iface->dev;

	/* we cannot use the usb_get_descriptor() function because the
	* arguments are different.
	*/
	result = usb_control_msg(
	wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
	USB_REQ_SET_DESCRIPTOR,
	USB_DIR_OUT \| USB_TYPE_CLASS \| USB_RECIP_RPIPE,
	USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
	USB_CTRL_SET_TIMEOUT);
	if (result < 0) {
	dev_err(dev, "rpipe %u: set descriptor failed: %d\n",
	index, (int)result);
	goto error;
	}
	if (result < sizeof(*descr)) {
	dev_err(dev, "rpipe %u: sent short descriptor "
	"(%zd vs %zd bytes required)\n",
	index, result, sizeof(*descr));
	result = -EINVAL;
	goto error;
	}
	result = 0;

	error:
	return result;

	}

	static void rpipe_init(struct wa_rpipe *rpipe)
	{
	kref_init(&rpipe->refcnt);
	spin_lock_init(&rpipe->seg_lock);
	INIT_LIST_HEAD(&rpipe->seg_list);
	INIT_LIST_HEAD(&rpipe->list_node);
	}

	static unsigned rpipe_get_idx(struct wahc *wa, unsigned rpipe_idx)
	{
	unsigned long flags;

	spin_lock_irqsave(&wa->rpipe_lock, flags);
	rpipe_idx = find_next_zero_bit(wa->rpipe_bm, wa->rpipes, rpipe_idx);
	if (rpipe_idx < wa->rpipes)
	set_bit(rpipe_idx, wa->rpipe_bm);
	spin_unlock_irqrestore(&wa->rpipe_lock, flags);

	return rpipe_idx;
	}

	static void rpipe_put_idx(struct wahc *wa, unsigned rpipe_idx)
	{
	unsigned long flags;

	spin_lock_irqsave(&wa->rpipe_lock, flags);
	clear_bit(rpipe_idx, wa->rpipe_bm);
	spin_unlock_irqrestore(&wa->rpipe_lock, flags);
	}

	void rpipe_destroy(struct kref *_rpipe)
	{
	struct wa_rpipe *rpipe = container_of(_rpipe, struct wa_rpipe, refcnt);
	u8 index = le16_to_cpu(rpipe->descr.wRPipeIndex);

	if (rpipe->ep)
	rpipe->ep->hcpriv = NULL;
	rpipe_put_idx(rpipe->wa, index);
	wa_put(rpipe->wa);
	kfree(rpipe);
	}
	EXPORT_SYMBOL_GPL(rpipe_destroy);

	/*
	* Locate an idle rpipe, create an structure for it and return it
	*
	* @wa is referenced and unlocked
	* @crs enum rpipe_attr, required endpoint characteristics
	*
	* The rpipe can be used only sequentially (not in parallel).
	*
	* The rpipe is moved into the "ready" state.
	*/
	static int rpipe_get_idle(struct wa_rpipe *prpipe, struct wahc wa, u8 crs,
	gfp_t gfp)
	{
	int result;
	unsigned rpipe_idx;
	struct wa_rpipe *rpipe;
	struct device *dev = &wa->usb_iface->dev;

	rpipe = kzalloc(sizeof(*rpipe), gfp);
	if (rpipe == NULL)
	return -ENOMEM;
	rpipe_init(rpipe);

	/* Look for an idle pipe */
	for (rpipe_idx = 0; rpipe_idx < wa->rpipes; rpipe_idx++) {
	rpipe_idx = rpipe_get_idx(wa, rpipe_idx);
	if (rpipe_idx >= wa->rpipes) /* no more pipes :( */
	break;
	result = __rpipe_get_descr(wa, &rpipe->descr, rpipe_idx);
	if (result < 0)
	dev_err(dev, "Can't get descriptor for rpipe %u: %d\n",
	rpipe_idx, result);
	else if ((rpipe->descr.bmCharacteristics & crs) != 0)
	goto found;
	rpipe_put_idx(wa, rpipe_idx);
	}
	*prpipe = NULL;
	kfree(rpipe);
	return -ENXIO;

	found:
	set_bit(rpipe_idx, wa->rpipe_bm);
	rpipe->wa = wa_get(wa);
	*prpipe = rpipe;
	return 0;
	}

	static int __rpipe_reset(struct wahc *wa, unsigned index)
	{
	int result;
	struct device *dev = &wa->usb_iface->dev;

	result = usb_control_msg(
	wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
	USB_REQ_RPIPE_RESET,
	USB_DIR_OUT \| USB_TYPE_CLASS \| USB_RECIP_RPIPE,
	0, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
	if (result < 0)
	dev_err(dev, "rpipe %u: reset failed: %d\n",
	index, result);
	return result;
	}

	/*
	* Fake companion descriptor for ep0
	*
	* See WUSB1.0[7.4.4], most of this is zero for bulk/int/ctl
	*/
	static struct usb_wireless_ep_comp_descriptor epc0 = {
	.bLength = sizeof(epc0),
	.bDescriptorType = USB_DT_WIRELESS_ENDPOINT_COMP,
	.bMaxBurst = 1,
	.bMaxSequence = 2,
	};

	/*
	* Look for EP companion descriptor
	*
	* Get there, look for Inara in the endpoint's extra descriptors
	*/
	static struct usb_wireless_ep_comp_descriptor *rpipe_epc_find(
	struct device dev, struct usb_host_endpoint ep)
	{
	void *itr;
	size_t itr_size;
	struct usb_descriptor_header *hdr;
	struct usb_wireless_ep_comp_descriptor *epcd;

	if (ep->desc.bEndpointAddress == 0) {
	epcd = &epc0;
	goto out;
	}
	itr = ep->extra;
	itr_size = ep->extralen;
	epcd = NULL;
	while (itr_size > 0) {
	if (itr_size < sizeof(*hdr)) {
	dev_err(dev, "HW Bug? ep 0x%02x: extra descriptors "
	"at offset %zu: only %zu bytes left\n",
	ep->desc.bEndpointAddress,
	itr - (void *) ep->extra, itr_size);
	break;
	}
	hdr = itr;
	if (hdr->bDescriptorType == USB_DT_WIRELESS_ENDPOINT_COMP) {
	epcd = itr;
	break;
	}
	if (hdr->bLength > itr_size) {
	dev_err(dev, "HW Bug? ep 0x%02x: extra descriptor "
	"at offset %zu (type 0x%02x) "
	"length %d but only %zu bytes left\n",
	ep->desc.bEndpointAddress,
	itr - (void *) ep->extra, hdr->bDescriptorType,
	hdr->bLength, itr_size);
	break;
	}
	itr += hdr->bLength;
	itr_size -= hdr->bLength;
	}
	out:
	return epcd;
	}

	/*
	* Aim an rpipe to its device & endpoint destination
	*
	* Make sure we change the address to unauthenticated if the device
	* is WUSB and it is not authenticated.
	*/
	static int rpipe_aim(struct wa_rpipe rpipe, struct wahc wa,
	struct usb_host_endpoint ep, struct urb urb, gfp_t gfp)
	{
	int result = -ENOMSG; /* better code for lack of companion? */
	struct device *dev = &wa->usb_iface->dev;
	struct usb_device *usb_dev = urb->dev;
	struct usb_wireless_ep_comp_descriptor *epcd;
	u32 ack_window, epcd_max_sequence;
	u8 unauth;

	epcd = rpipe_epc_find(dev, ep);
	if (epcd == NULL) {
	dev_err(dev, "ep 0x%02x: can't find companion descriptor\n",
	ep->desc.bEndpointAddress);
	goto error;
	}
	unauth = usb_dev->wusb && !usb_dev->authenticated ? 0x80 : 0;
	__rpipe_reset(wa, le16_to_cpu(rpipe->descr.wRPipeIndex));
	atomic_set(&rpipe->segs_available,
	le16_to_cpu(rpipe->descr.wRequests));
	/* FIXME: block allocation system; request with queuing and timeout */
	/* FIXME: compute so seg_size > ep->maxpktsize */
	rpipe->descr.wBlocks = cpu_to_le16(16); /* given */
	/* ep0 maxpktsize is 0x200 (WUSB1.0[4.8.1]) */
	if (usb_endpoint_xfer_isoc(&ep->desc))
	rpipe->descr.wMaxPacketSize = epcd->wOverTheAirPacketSize;
	else
	rpipe->descr.wMaxPacketSize = ep->desc.wMaxPacketSize;

	rpipe->descr.hwa_bMaxBurst = max(min_t(unsigned int,
	epcd->bMaxBurst, 16U), 1U);
	rpipe->descr.hwa_bDeviceInfoIndex =
	wusb_port_no_to_idx(urb->dev->portnum);
	/* FIXME: use maximum speed as supported or recommended by device */
	rpipe->descr.bSpeed = usb_pipeendpoint(urb->pipe) == 0 ?
	UWB_PHY_RATE_53 : UWB_PHY_RATE_200;

	dev_dbg(dev, "addr %u (0x%02x) rpipe #%u ep# %u speed %d\n",
	urb->dev->devnum, urb->dev->devnum \| unauth,
	le16_to_cpu(rpipe->descr.wRPipeIndex),
	usb_pipeendpoint(urb->pipe), rpipe->descr.bSpeed);

	rpipe->descr.hwa_reserved = 0;

	rpipe->descr.bEndpointAddress = ep->desc.bEndpointAddress;
	/* FIXME: bDataSequence */
	rpipe->descr.bDataSequence = 0;

	/* start with base window of hwa_bMaxBurst bits starting at 0. */
	ack_window = 0xFFFFFFFF >> (32 - rpipe->descr.hwa_bMaxBurst);
	rpipe->descr.dwCurrentWindow = cpu_to_le32(ack_window);
	epcd_max_sequence = max(min_t(unsigned int,
	epcd->bMaxSequence, 32U), 2U);
	rpipe->descr.bMaxDataSequence = epcd_max_sequence - 1;
	rpipe->descr.bInterval = ep->desc.bInterval;
	if (usb_endpoint_xfer_isoc(&ep->desc))
	rpipe->descr.bOverTheAirInterval = epcd->bOverTheAirInterval;
	else
	rpipe->descr.bOverTheAirInterval = 0; /* 0 if not isoc */
	/* FIXME: xmit power & preamble blah blah */
	rpipe->descr.bmAttribute = (ep->desc.bmAttributes &
	USB_ENDPOINT_XFERTYPE_MASK);
	/* rpipe->descr.bmCharacteristics RO */
	rpipe->descr.bmRetryOptions = (wa->wusb->retry_count & 0xF);
	/* FIXME: use for assessing link quality? */
	rpipe->descr.wNumTransactionErrors = 0;
	result = __rpipe_set_descr(wa, &rpipe->descr,
	le16_to_cpu(rpipe->descr.wRPipeIndex));
	if (result < 0) {
	dev_err(dev, "Cannot aim rpipe: %d\n", result);
	goto error;
	}
	result = 0;
	error:
	return result;
	}

	/*
	* Check an aimed rpipe to make sure it points to where we want
	*
	* We use bit 19 of the Linux USB pipe bitmap for unauth vs auth
	* space; when it is like that, we or 0x80 to make an unauth address.
	*/
	static int rpipe_check_aim(const struct wa_rpipe rpipe, const struct wahc wa,
	const struct usb_host_endpoint *ep,
	const struct urb *urb, gfp_t gfp)
	{
	int result = 0;
	struct device *dev = &wa->usb_iface->dev;
	u8 portnum = wusb_port_no_to_idx(urb->dev->portnum);

	#define AIM_CHECK(rdf, val, text) \
	do { \
	if (rpipe->descr.rdf != (val)) { \
	dev_err(dev, \
	"rpipe aim discrepancy: " #rdf " " text "\n", \
	rpipe->descr.rdf, (val)); \
	result = -EINVAL; \
	WARN_ON(1); \
	} \
	} while (0)
	AIM_CHECK(hwa_bDeviceInfoIndex, portnum, "(%u vs %u)");
	AIM_CHECK(bSpeed, usb_pipeendpoint(urb->pipe) == 0 ?
	UWB_PHY_RATE_53 : UWB_PHY_RATE_200,
	"(%u vs %u)");
	AIM_CHECK(bEndpointAddress, ep->desc.bEndpointAddress, "(%u vs %u)");
	AIM_CHECK(bInterval, ep->desc.bInterval, "(%u vs %u)");
	AIM_CHECK(bmAttribute, ep->desc.bmAttributes & 0x03, "(%u vs %u)");
	#undef AIM_CHECK
	return result;
	}

	#ifndef CONFIG_BUG
	#define CONFIG_BUG 0
	#endif

	/*
	* Make sure there is an rpipe allocated for an endpoint
	*
	* If already allocated, we just refcount it; if not, we get an
	* idle one, aim it to the right location and take it.
	*
	* Attaches to ep->hcpriv and rpipe->ep to ep.
	*/
	int rpipe_get_by_ep(struct wahc wa, struct usb_host_endpoint ep,
	struct urb *urb, gfp_t gfp)
	{
	int result = 0;
	struct device *dev = &wa->usb_iface->dev;
	struct wa_rpipe *rpipe;
	u8 eptype;

	mutex_lock(&wa->rpipe_mutex);
	rpipe = ep->hcpriv;
	if (rpipe != NULL) {
	if (CONFIG_BUG == 1) {
	result = rpipe_check_aim(rpipe, wa, ep, urb, gfp);
	if (result < 0)
	goto error;
	}
	__rpipe_get(rpipe);
	dev_dbg(dev, "ep 0x%02x: reusing rpipe %u\n",
	ep->desc.bEndpointAddress,
	le16_to_cpu(rpipe->descr.wRPipeIndex));
	} else {
	/* hmm, assign idle rpipe, aim it */
	result = -ENOBUFS;
	eptype = ep->desc.bmAttributes & 0x03;
	result = rpipe_get_idle(&rpipe, wa, 1 << eptype, gfp);
	if (result < 0)
	goto error;
	result = rpipe_aim(rpipe, wa, ep, urb, gfp);
	if (result < 0) {
	rpipe_put(rpipe);
	goto error;
	}
	ep->hcpriv = rpipe;
	rpipe->ep = ep;
	__rpipe_get(rpipe); /* for caching into ep->hcpriv */
	dev_dbg(dev, "ep 0x%02x: using rpipe %u\n",
	ep->desc.bEndpointAddress,
	le16_to_cpu(rpipe->descr.wRPipeIndex));
	}
	error:
	mutex_unlock(&wa->rpipe_mutex);
	return result;
	}

	/*
	* Allocate the bitmap for each rpipe.
	*/
	int wa_rpipes_create(struct wahc *wa)
	{
	wa->rpipes = le16_to_cpu(wa->wa_descr->wNumRPipes);
	wa->rpipe_bm = kzalloc(BITS_TO_LONGS(wa->rpipes)*sizeof(unsigned long),
	GFP_KERNEL);
	if (wa->rpipe_bm == NULL)
	return -ENOMEM;
	return 0;
	}

	void wa_rpipes_destroy(struct wahc *wa)
	{
	struct device *dev = &wa->usb_iface->dev;

	if (!bitmap_empty(wa->rpipe_bm, wa->rpipes)) {
	WARN_ON(1);
	dev_err(dev, "BUG: pipes not released on exit: %*pb\n",
	wa->rpipes, wa->rpipe_bm);
	}
	kfree(wa->rpipe_bm);
	}

	/*
	* Release resources allocated for an endpoint
	*
	* If there is an associated rpipe to this endpoint, Abort any pending
	* transfers and put it. If the rpipe ends up being destroyed,
	* __rpipe_destroy() will cleanup ep->hcpriv.
	*
	* This is called before calling hcd->stop(), so you don't need to do
	* anything else in there.
	*/
	void rpipe_ep_disable(struct wahc wa, struct usb_host_endpoint ep)
	{
	struct wa_rpipe *rpipe;

	mutex_lock(&wa->rpipe_mutex);
	rpipe = ep->hcpriv;
	if (rpipe != NULL) {
	u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);

	usb_control_msg(
	wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
	USB_REQ_RPIPE_ABORT,
	USB_DIR_OUT \| USB_TYPE_CLASS \| USB_RECIP_RPIPE,
	0, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
	rpipe_put(rpipe);
	}
	mutex_unlock(&wa->rpipe_mutex);
	}
	EXPORT_SYMBOL_GPL(rpipe_ep_disable);

	/* Clear the stalled status of an RPIPE. */
	void rpipe_clear_feature_stalled(struct wahc wa, struct usb_host_endpoint ep)
	{
	struct wa_rpipe *rpipe;

	mutex_lock(&wa->rpipe_mutex);
	rpipe = ep->hcpriv;
	if (rpipe != NULL) {
	u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);

	usb_control_msg(
	wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
	USB_REQ_CLEAR_FEATURE,
	USB_DIR_OUT \| USB_TYPE_CLASS \| USB_RECIP_RPIPE,
	RPIPE_STALL, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
	}
	mutex_unlock(&wa->rpipe_mutex);
	}
	EXPORT_SYMBOL_GPL(rpipe_clear_feature_stalled);