[deliverable/linux.git] / drivers / usb / wusbcore / wa-rpipe.c

/*
 * 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/init.h>
#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),
		1000 /* FIXME: arbitrary */);
	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),
		HZ / 10);
	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);
}

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

	spin_lock_irqsave(&wa->rpipe_bm_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_bm_lock, flags);

	return rpipe_idx;
}

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

	spin_lock_irqsave(&wa->rpipe_bm_lock, flags);
	clear_bit(rpipe_idx, wa->rpipe_bm);
	spin_unlock_irqrestore(&wa->rpipe_bm_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, 1000 /* FIXME: arbitrary */);
	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->bDescriptorType;
	}
out:
	return epcd;
}

/*
 * Aim an rpipe to its device & endpoint destination
 *
 * Make sure we change the address to unauthenticathed 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]) */
	rpipe->descr.wMaxPacketSize = cpu_to_le16(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;
	/* FIXME: bOverTheAirInterval */
	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 = 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)) {
		char buf[256];
		WARN_ON(1);
		bitmap_scnprintf(buf, sizeof(buf), wa->rpipe_bm, wa->rpipes);
		dev_err(dev, "BUG: pipes not released on exit: %s\n", buf);
	}
	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_rcvctrlpipe(wa->usb_dev, 0),
			USB_REQ_RPIPE_ABORT,
			USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
			0, index, NULL, 0, 1000 /* FIXME: arbitrary */);
		rpipe_put(rpipe);
	}
	mutex_unlock(&wa->rpipe_mutex);
}
EXPORT_SYMBOL_GPL(rpipe_ep_disable);
Commit	Line	Data
df365423 IPG	1	/*
	2	* WUSB Wire Adapter
	3	* rpipe management
	4	*
	5	* Copyright (C) 2005-2006 Intel Corporation
	6	* Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License version
	10	* 2 as published by the Free Software Foundation.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	20	* 02110-1301, USA.
	21	*
	22	*
	23	* FIXME: docs
	24	*
	25	* RPIPE
	26	*
25985edc	27	* Targeted at different downstream endpoints
df365423 IPG	28	*
	29	* Descriptor: use to config the remote pipe.
	30	*
	31	* The number of blocks could be dynamic (wBlocks in descriptor is
	32	* 0)--need to schedule them then.
	33	*
	34	* Each bit in wa->rpipe_bm represents if an rpipe is being used or
	35	* not. Rpipes are represented with a 'struct wa_rpipe' that is
	36	* attached to the hcpriv member of a 'struct usb_host_endpoint'.
	37	*
	38	* When you need to xfer data to an endpoint, you get an rpipe for it
	39	* with wa_ep_rpipe_get(), which gives you a reference to the rpipe
	40	* and keeps a single one (the first one) with the endpoint. When you
	41	* are done transferring, you drop that reference. At the end the
	42	* rpipe is always allocated and bound to the endpoint. There it might
	43	* be recycled when not used.
	44	*
	45	* Addresses:
	46	*
	47	* We use a 1:1 mapping mechanism between port address (0 based
	48	* index, actually) and the address. The USB stack knows about this.
	49	*
	50	* USB Stack port number 4 (1 based)
	51	* WUSB code port index 3 (0 based)
b595076a	52	* USB Address 5 (2 based -- 0 is for default, 1 for root hub)
df365423 IPG	53	*
	54	* Now, because we don't use the concept as default address exactly
	55	* like the (wired) USB code does, we need to kind of skip it. So we
	56	* never take addresses from the urb->pipe, but from the
	57	* urb->dev->devnum, to make sure that we always have the right
	58	* destination address.
	59	*/
	60	#include <linux/init.h>
60063497	61	#include <linux/atomic.h>
df365423	62	#include <linux/bitmap.h>
5a0e3ad6	63	#include <linux/slab.h>
f940fcd8	64	#include <linux/export.h>
bce83697	65
df365423 IPG	66	#include "wusbhc.h"
	67	#include "wa-hc.h"
	68
df365423 IPG	69	static int __rpipe_get_descr(struct wahc *wa,
	70	struct usb_rpipe_descriptor *descr, u16 index)
	71	{
	72	ssize_t result;
	73	struct device *dev = &wa->usb_iface->dev;
	74
	75	/* Get the RPIPE descriptor -- we cannot use the usb_get_descriptor()
	76	* function because the arguments are different.
	77	*/
df365423 IPG	78	result = usb_control_msg(
	79	wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
	80	USB_REQ_GET_DESCRIPTOR,
	81	USB_DIR_IN \| USB_TYPE_CLASS \| USB_RECIP_RPIPE,
	82	USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
	83	1000 /* FIXME: arbitrary */);
	84	if (result < 0) {
	85	dev_err(dev, "rpipe %u: get descriptor failed: %d\n",
	86	index, (int)result);
	87	goto error;
	88	}
	89	if (result < sizeof(*descr)) {
	90	dev_err(dev, "rpipe %u: got short descriptor "
	91	"(%zd vs %zd bytes needed)\n",
	92	index, result, sizeof(*descr));
	93	result = -EINVAL;
	94	goto error;
	95	}
	96	result = 0;
	97
	98	error:
	99	return result;
	100	}
	101
	102	/*
	103	*
	104	* The descriptor is assumed to be properly initialized (ie: you got
	105	* it through __rpipe_get_descr()).
	106	*/
	107	static int __rpipe_set_descr(struct wahc *wa,
	108	struct usb_rpipe_descriptor *descr, u16 index)
	109	{
	110	ssize_t result;
	111	struct device *dev = &wa->usb_iface->dev;
	112
	113	/* we cannot use the usb_get_descriptor() function because the
	114	* arguments are different.
	115	*/
df365423 IPG	116	result = usb_control_msg(
	117	wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
	118	USB_REQ_SET_DESCRIPTOR,
	119	USB_DIR_OUT \| USB_TYPE_CLASS \| USB_RECIP_RPIPE,
	120	USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
	121	HZ / 10);
	122	if (result < 0) {
	123	dev_err(dev, "rpipe %u: set descriptor failed: %d\n",
	124	index, (int)result);
	125	goto error;
	126	}
	127	if (result < sizeof(*descr)) {
	128	dev_err(dev, "rpipe %u: sent short descriptor "
	129	"(%zd vs %zd bytes required)\n",
	130	index, result, sizeof(*descr));
	131	result = -EINVAL;
	132	goto error;
	133	}
	134	result = 0;
	135
	136	error:
	137	return result;
	138
	139	}
	140
	141	static void rpipe_init(struct wa_rpipe *rpipe)
	142	{
	143	kref_init(&rpipe->refcnt);
	144	spin_lock_init(&rpipe->seg_lock);
	145	INIT_LIST_HEAD(&rpipe->seg_list);
	146	}
	147
	148	static unsigned rpipe_get_idx(struct wahc *wa, unsigned rpipe_idx)
	149	{
	150	unsigned long flags;
	151
	152	spin_lock_irqsave(&wa->rpipe_bm_lock, flags);
	153	rpipe_idx = find_next_zero_bit(wa->rpipe_bm, wa->rpipes, rpipe_idx);
	154	if (rpipe_idx < wa->rpipes)
	155	set_bit(rpipe_idx, wa->rpipe_bm);
	156	spin_unlock_irqrestore(&wa->rpipe_bm_lock, flags);
	157
	158	return rpipe_idx;
	159	}
	160
	161	static void rpipe_put_idx(struct wahc *wa, unsigned rpipe_idx)
	162	{
	163	unsigned long flags;
	164
	165	spin_lock_irqsave(&wa->rpipe_bm_lock, flags);
	166	clear_bit(rpipe_idx, wa->rpipe_bm);
	167	spin_unlock_irqrestore(&wa->rpipe_bm_lock, flags);
	168	}
	169
	170	void rpipe_destroy(struct kref *_rpipe)
	171	{
	172	struct wa_rpipe *rpipe = container_of(_rpipe, struct wa_rpipe, refcnt);
	173	u8 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
bce83697	174
df365423 IPG	175	if (rpipe->ep)
	176	rpipe->ep->hcpriv = NULL;
	177	rpipe_put_idx(rpipe->wa, index);
	178	wa_put(rpipe->wa);
	179	kfree(rpipe);
df365423 IPG	180	}
	181	EXPORT_SYMBOL_GPL(rpipe_destroy);
	182
	183	/*
	184	* Locate an idle rpipe, create an structure for it and return it
	185	*
	186	* @wa is referenced and unlocked
	187	* @crs enum rpipe_attr, required endpoint characteristics
	188	*
	189	* The rpipe can be used only sequentially (not in parallel).
	190	*
	191	* The rpipe is moved into the "ready" state.
	192	*/
	193	static int rpipe_get_idle(struct wa_rpipe *prpipe, struct wahc wa, u8 crs,
	194	gfp_t gfp)
	195	{
	196	int result;
	197	unsigned rpipe_idx;
	198	struct wa_rpipe *rpipe;
	199	struct device *dev = &wa->usb_iface->dev;
	200
df365423 IPG	201	rpipe = kzalloc(sizeof(*rpipe), gfp);
	202	if (rpipe == NULL)
	203	return -ENOMEM;
	204	rpipe_init(rpipe);
	205
	206	/* Look for an idle pipe */
	207	for (rpipe_idx = 0; rpipe_idx < wa->rpipes; rpipe_idx++) {
	208	rpipe_idx = rpipe_get_idx(wa, rpipe_idx);
	209	if (rpipe_idx >= wa->rpipes) /* no more pipes :( */
	210	break;
	211	result = __rpipe_get_descr(wa, &rpipe->descr, rpipe_idx);
	212	if (result < 0)
	213	dev_err(dev, "Can't get descriptor for rpipe %u: %d\n",
	214	rpipe_idx, result);
	215	else if ((rpipe->descr.bmCharacteristics & crs) != 0)
	216	goto found;
	217	rpipe_put_idx(wa, rpipe_idx);
	218	}
	219	*prpipe = NULL;
	220	kfree(rpipe);
df365423 IPG	221	return -ENXIO;
	222
	223	found:
	224	set_bit(rpipe_idx, wa->rpipe_bm);
	225	rpipe->wa = wa_get(wa);
	226	*prpipe = rpipe;
df365423 IPG	227	return 0;
	228	}
	229
	230	static int __rpipe_reset(struct wahc *wa, unsigned index)
	231	{
	232	int result;
	233	struct device *dev = &wa->usb_iface->dev;
	234
df365423 IPG	235	result = usb_control_msg(
	236	wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
	237	USB_REQ_RPIPE_RESET,
	238	USB_DIR_OUT \| USB_TYPE_CLASS \| USB_RECIP_RPIPE,
	239	0, index, NULL, 0, 1000 /* FIXME: arbitrary */);
	240	if (result < 0)
	241	dev_err(dev, "rpipe %u: reset failed: %d\n",
	242	index, result);
	243	return result;
	244	}
	245
	246	/*
	247	* Fake companion descriptor for ep0
	248	*
	249	* See WUSB1.0[7.4.4], most of this is zero for bulk/int/ctl
	250	*/
	251	static struct usb_wireless_ep_comp_descriptor epc0 = {
	252	.bLength = sizeof(epc0),
	253	.bDescriptorType = USB_DT_WIRELESS_ENDPOINT_COMP,
ee0218fa TP	254	.bMaxBurst = 1,
ee0218fa TP	255	.bMaxSequence = 2,
df365423 IPG	256	};
	257
	258	/*
	259	* Look for EP companion descriptor
	260	*
	261	* Get there, look for Inara in the endpoint's extra descriptors
	262	*/
	263	static struct usb_wireless_ep_comp_descriptor *rpipe_epc_find(
	264	struct device dev, struct usb_host_endpoint ep)
	265	{
	266	void *itr;
	267	size_t itr_size;
	268	struct usb_descriptor_header *hdr;
	269	struct usb_wireless_ep_comp_descriptor *epcd;
	270
df365423 IPG	271	if (ep->desc.bEndpointAddress == 0) {
	272	epcd = &epc0;
	273	goto out;
	274	}
	275	itr = ep->extra;
	276	itr_size = ep->extralen;
	277	epcd = NULL;
	278	while (itr_size > 0) {
	279	if (itr_size < sizeof(*hdr)) {
	280	dev_err(dev, "HW Bug? ep 0x%02x: extra descriptors "
	281	"at offset %zu: only %zu bytes left\n",
	282	ep->desc.bEndpointAddress,
	283	itr - (void *) ep->extra, itr_size);
	284	break;
	285	}
	286	hdr = itr;
	287	if (hdr->bDescriptorType == USB_DT_WIRELESS_ENDPOINT_COMP) {
	288	epcd = itr;
	289	break;
	290	}
	291	if (hdr->bLength > itr_size) {
	292	dev_err(dev, "HW Bug? ep 0x%02x: extra descriptor "
	293	"at offset %zu (type 0x%02x) "
	294	"length %d but only %zu bytes left\n",
	295	ep->desc.bEndpointAddress,
	296	itr - (void *) ep->extra, hdr->bDescriptorType,
	297	hdr->bLength, itr_size);
	298	break;
	299	}
	300	itr += hdr->bLength;
	301	itr_size -= hdr->bDescriptorType;
	302	}
	303	out:
df365423 IPG	304	return epcd;
	305	}
	306
	307	/*
	308	* Aim an rpipe to its device & endpoint destination
	309	*
	310	* Make sure we change the address to unauthenticathed if the device
	311	* is WUSB and it is not authenticated.
	312	*/
	313	static int rpipe_aim(struct wa_rpipe rpipe, struct wahc wa,
	314	struct usb_host_endpoint ep, struct urb urb, gfp_t gfp)
	315	{
	316	int result = -ENOMSG; /* better code for lack of companion? */
	317	struct device *dev = &wa->usb_iface->dev;
	318	struct usb_device *usb_dev = urb->dev;
	319	struct usb_wireless_ep_comp_descriptor *epcd;
ee0218fa	320	u32 ack_window, epcd_max_sequence;
df365423 IPG	321	u8 unauth;
df365423 IPG	322
df365423 IPG	323	epcd = rpipe_epc_find(dev, ep);
	324	if (epcd == NULL) {
	325	dev_err(dev, "ep 0x%02x: can't find companion descriptor\n",
	326	ep->desc.bEndpointAddress);
	327	goto error;
	328	}
	329	unauth = usb_dev->wusb && !usb_dev->authenticated ? 0x80 : 0;
	330	__rpipe_reset(wa, le16_to_cpu(rpipe->descr.wRPipeIndex));
	331	atomic_set(&rpipe->segs_available, le16_to_cpu(rpipe->descr.wRequests));
	332	/* FIXME: block allocation system; request with queuing and timeout */
	333	/* FIXME: compute so seg_size > ep->maxpktsize */
	334	rpipe->descr.wBlocks = cpu_to_le16(16); /* given */
	335	/* ep0 maxpktsize is 0x200 (WUSB1.0[4.8.1]) */
	336	rpipe->descr.wMaxPacketSize = cpu_to_le16(ep->desc.wMaxPacketSize);
ee0218fa TP	337
	338	rpipe->descr.hwa_bMaxBurst = max(min_t(unsigned int,
	339	epcd->bMaxBurst, 16U), 1U);
	340	rpipe->descr.hwa_bDeviceInfoIndex =
	341	wusb_port_no_to_idx(urb->dev->portnum);
df365423 IPG	342	/* FIXME: use maximum speed as supported or recommended by device */
	343	rpipe->descr.bSpeed = usb_pipeendpoint(urb->pipe) == 0 ?
	344	UWB_PHY_RATE_53 : UWB_PHY_RATE_200;
bce83697 DV	345
	346	dev_dbg(dev, "addr %u (0x%02x) rpipe #%u ep# %u speed %d\n",
	347	urb->dev->devnum, urb->dev->devnum \| unauth,
	348	le16_to_cpu(rpipe->descr.wRPipeIndex),
	349	usb_pipeendpoint(urb->pipe), rpipe->descr.bSpeed);
	350
ee0218fa TP	351	rpipe->descr.hwa_reserved = 0;
ee0218fa TP	352
df365423 IPG	353	rpipe->descr.bEndpointAddress = ep->desc.bEndpointAddress;
	354	/* FIXME: bDataSequence */
	355	rpipe->descr.bDataSequence = 0;
ee0218fa TP	356
	357	/* start with base window of hwa_bMaxBurst bits starting at 0. */
	358	ack_window = 0xFFFFFFFF >> (32 - rpipe->descr.hwa_bMaxBurst);
	359	rpipe->descr.dwCurrentWindow = cpu_to_le32(ack_window);
	360	epcd_max_sequence = max(min_t(unsigned int,
	361	epcd->bMaxSequence, 32U), 2U);
	362	rpipe->descr.bMaxDataSequence = epcd_max_sequence - 1;
df365423 IPG	363	rpipe->descr.bInterval = ep->desc.bInterval;
	364	/* FIXME: bOverTheAirInterval */
	365	rpipe->descr.bOverTheAirInterval = 0; /* 0 if not isoc */
	366	/* FIXME: xmit power & preamble blah blah */
ee0218fa TP	367	rpipe->descr.bmAttribute = (ep->desc.bmAttributes &
ee0218fa TP	368	USB_ENDPOINT_XFERTYPE_MASK);
df365423	369	/* rpipe->descr.bmCharacteristics RO */
f265d4d3	370	rpipe->descr.bmRetryOptions = (wa->wusb->retry_count & 0xF);
df365423 IPG	371	/* FIXME: use for assessing link quality? */
	372	rpipe->descr.wNumTransactionErrors = 0;
	373	result = __rpipe_set_descr(wa, &rpipe->descr,
	374	le16_to_cpu(rpipe->descr.wRPipeIndex));
	375	if (result < 0) {
	376	dev_err(dev, "Cannot aim rpipe: %d\n", result);
	377	goto error;
	378	}
	379	result = 0;
	380	error:
df365423 IPG	381	return result;
	382	}
	383
	384	/*
	385	* Check an aimed rpipe to make sure it points to where we want
	386	*
	387	* We use bit 19 of the Linux USB pipe bitmap for unauth vs auth
	388	* space; when it is like that, we or 0x80 to make an unauth address.
	389	*/
	390	static int rpipe_check_aim(const struct wa_rpipe rpipe, const struct wahc wa,
	391	const struct usb_host_endpoint *ep,
	392	const struct urb *urb, gfp_t gfp)
	393	{
ee0218fa	394	int result = 0;
df365423	395	struct device *dev = &wa->usb_iface->dev;
df365423 IPG	396	u8 portnum = wusb_port_no_to_idx(urb->dev->portnum);
df365423 IPG	397
df365423 IPG	398	#define AIM_CHECK(rdf, val, text) \
	399	do { \
	400	if (rpipe->descr.rdf != (val)) { \
	401	dev_err(dev, \
	402	"rpipe aim discrepancy: " #rdf " " text "\n", \
	403	rpipe->descr.rdf, (val)); \
	404	result = -EINVAL; \
	405	WARN_ON(1); \
	406	} \
	407	} while (0)
ee0218fa	408	AIM_CHECK(hwa_bDeviceInfoIndex, portnum, "(%u vs %u)");
df365423 IPG	409	AIM_CHECK(bSpeed, usb_pipeendpoint(urb->pipe) == 0 ?
	410	UWB_PHY_RATE_53 : UWB_PHY_RATE_200,
	411	"(%u vs %u)");
df365423 IPG	412	AIM_CHECK(bEndpointAddress, ep->desc.bEndpointAddress, "(%u vs %u)");
	413	AIM_CHECK(bInterval, ep->desc.bInterval, "(%u vs %u)");
	414	AIM_CHECK(bmAttribute, ep->desc.bmAttributes & 0x03, "(%u vs %u)");
	415	#undef AIM_CHECK
	416	return result;
	417	}
	418
	419	#ifndef CONFIG_BUG
	420	#define CONFIG_BUG 0
	421	#endif
	422
	423	/*
	424	* Make sure there is an rpipe allocated for an endpoint
	425	*
	426	* If already allocated, we just refcount it; if not, we get an
	427	* idle one, aim it to the right location and take it.
	428	*
	429	* Attaches to ep->hcpriv and rpipe->ep to ep.
	430	*/
	431	int rpipe_get_by_ep(struct wahc wa, struct usb_host_endpoint ep,
	432	struct urb *urb, gfp_t gfp)
	433	{
	434	int result = 0;
	435	struct device *dev = &wa->usb_iface->dev;
	436	struct wa_rpipe *rpipe;
	437	u8 eptype;
	438
df365423 IPG	439	mutex_lock(&wa->rpipe_mutex);
	440	rpipe = ep->hcpriv;
	441	if (rpipe != NULL) {
	442	if (CONFIG_BUG == 1) {
	443	result = rpipe_check_aim(rpipe, wa, ep, urb, gfp);
	444	if (result < 0)
	445	goto error;
	446	}
	447	__rpipe_get(rpipe);
bce83697 DV	448	dev_dbg(dev, "ep 0x%02x: reusing rpipe %u\n",
	449	ep->desc.bEndpointAddress,
	450	le16_to_cpu(rpipe->descr.wRPipeIndex));
df365423 IPG	451	} else {
	452	/* hmm, assign idle rpipe, aim it */
	453	result = -ENOBUFS;
	454	eptype = ep->desc.bmAttributes & 0x03;
	455	result = rpipe_get_idle(&rpipe, wa, 1 << eptype, gfp);
	456	if (result < 0)
	457	goto error;
	458	result = rpipe_aim(rpipe, wa, ep, urb, gfp);
	459	if (result < 0) {
	460	rpipe_put(rpipe);
	461	goto error;
	462	}
	463	ep->hcpriv = rpipe;
	464	rpipe->ep = ep;
	465	__rpipe_get(rpipe); /* for caching into ep->hcpriv */
bce83697 DV	466	dev_dbg(dev, "ep 0x%02x: using rpipe %u\n",
	467	ep->desc.bEndpointAddress,
	468	le16_to_cpu(rpipe->descr.wRPipeIndex));
df365423	469	}
df365423 IPG	470	error:
df365423 IPG	471	mutex_unlock(&wa->rpipe_mutex);
df365423 IPG	472	return result;
	473	}
	474
	475	/*
	476	* Allocate the bitmap for each rpipe.
	477	*/
	478	int wa_rpipes_create(struct wahc *wa)
	479	{
	480	wa->rpipes = wa->wa_descr->wNumRPipes;
	481	wa->rpipe_bm = kzalloc(BITS_TO_LONGS(wa->rpipes)*sizeof(unsigned long),
	482	GFP_KERNEL);
	483	if (wa->rpipe_bm == NULL)
	484	return -ENOMEM;
	485	return 0;
	486	}
	487
	488	void wa_rpipes_destroy(struct wahc *wa)
	489	{
	490	struct device *dev = &wa->usb_iface->dev;
bce83697	491
df365423 IPG	492	if (!bitmap_empty(wa->rpipe_bm, wa->rpipes)) {
	493	char buf[256];
	494	WARN_ON(1);
	495	bitmap_scnprintf(buf, sizeof(buf), wa->rpipe_bm, wa->rpipes);
	496	dev_err(dev, "BUG: pipes not released on exit: %s\n", buf);
	497	}
	498	kfree(wa->rpipe_bm);
df365423 IPG	499	}
	500
	501	/*
	502	* Release resources allocated for an endpoint
	503	*
	504	* If there is an associated rpipe to this endpoint, Abort any pending
	505	* transfers and put it. If the rpipe ends up being destroyed,
	506	* __rpipe_destroy() will cleanup ep->hcpriv.
	507	*
	508	* This is called before calling hcd->stop(), so you don't need to do
	509	* anything else in there.
	510	*/
	511	void rpipe_ep_disable(struct wahc wa, struct usb_host_endpoint ep)
	512	{
df365423	513	struct wa_rpipe *rpipe;
bce83697	514
df365423 IPG	515	mutex_lock(&wa->rpipe_mutex);
	516	rpipe = ep->hcpriv;
	517	if (rpipe != NULL) {
df365423 IPG	518	u16 index = le16_to_cpu(rpipe->descr.wRPipeIndex);
df365423 IPG	519
bce83697	520	usb_control_msg(
df365423 IPG	521	wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
df365423 IPG	522	USB_REQ_RPIPE_ABORT,
b0a81328	523	USB_DIR_OUT \| USB_TYPE_CLASS \| USB_RECIP_RPIPE,
df365423	524	0, index, NULL, 0, 1000 /* FIXME: arbitrary */);
df365423 IPG	525	rpipe_put(rpipe);
	526	}
	527	mutex_unlock(&wa->rpipe_mutex);
df365423 IPG	528	}
df365423 IPG	529	EXPORT_SYMBOL_GPL(rpipe_ep_disable);