[people/ms/u-boot.git] / drivers / usb / gadget / epautoconf.c

/*
 * epautoconf.c -- endpoint autoconfiguration for usb gadget drivers
 *
 * Copyright (C) 2004 David Brownell
 *
 * SPDX-License-Identifier:	GPL-2.0+
 *
 * SPDX-License-Identifier:	GPL-2.0+
 *
 * Ported to U-boot by: Thomas Smits <ts.smits@gmail.com> and
 *                      Remy Bohmer <linux@bohmer.net>
 */

#include <common.h>
#include <linux/usb/ch9.h>
#include <asm/errno.h>
#include <linux/usb/gadget.h>
#include <asm/unaligned.h>
#include "gadget_chips.h"

#define isdigit(c)      ('0' <= (c) && (c) <= '9')

/* we must assign addresses for configurable endpoints (like net2280) */
static unsigned epnum;

/* #define MANY_ENDPOINTS */
#ifdef MANY_ENDPOINTS
/* more than 15 configurable endpoints */
static unsigned in_epnum;
#endif


/*
 * This should work with endpoints from controller drivers sharing the
 * same endpoint naming convention.  By example:
 *
 *	- ep1, ep2, ... address is fixed, not direction or type
 *	- ep1in, ep2out, ... address and direction are fixed, not type
 *	- ep1-bulk, ep2-bulk, ... address and type are fixed, not direction
 *	- ep1in-bulk, ep2out-iso, ... all three are fixed
 *	- ep-* ... no functionality restrictions
 *
 * Type suffixes are "-bulk", "-iso", or "-int".  Numbers are decimal.
 * Less common restrictions are implied by gadget_is_*().
 *
 * NOTE:  each endpoint is unidirectional, as specified by its USB
 * descriptor; and isn't specific to a configuration or altsetting.
 */
static int ep_matches(
	struct usb_gadget		*gadget,
	struct usb_ep			*ep,
	struct usb_endpoint_descriptor	*desc
)
{
	u8		type;
	const char	*tmp;
	u16		max;

	/* endpoint already claimed? */
	if (NULL != ep->driver_data)
		return 0;

	/* only support ep0 for portable CONTROL traffic */
	type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
	if (USB_ENDPOINT_XFER_CONTROL == type)
		return 0;

	/* some other naming convention */
	if ('e' != ep->name[0])
		return 0;

	/* type-restriction:  "-iso", "-bulk", or "-int".
	 * direction-restriction:  "in", "out".
	 */
	if ('-' != ep->name[2]) {
		tmp = strrchr(ep->name, '-');
		if (tmp) {
			switch (type) {
			case USB_ENDPOINT_XFER_INT:
				/* bulk endpoints handle interrupt transfers,
				 * except the toggle-quirky iso-synch kind
				 */
				if ('s' == tmp[2])	/* == "-iso" */
					return 0;
				/* for now, avoid PXA "interrupt-in";
				 * it's documented as never using DATA1.
				 */
				if (gadget_is_pxa(gadget)
						&& 'i' == tmp[1])
					return 0;
				break;
			case USB_ENDPOINT_XFER_BULK:
				if ('b' != tmp[1])	/* != "-bulk" */
					return 0;
				break;
			case USB_ENDPOINT_XFER_ISOC:
				if ('s' != tmp[2])	/* != "-iso" */
					return 0;
			}
		} else {
			tmp = ep->name + strlen(ep->name);
		}

		/* direction-restriction:  "..in-..", "out-.." */
		tmp--;
		if (!isdigit(*tmp)) {
			if (desc->bEndpointAddress & USB_DIR_IN) {
				if ('n' != *tmp)
					return 0;
			} else {
				if ('t' != *tmp)
					return 0;
			}
		}
	}

	/* endpoint maxpacket size is an input parameter, except for bulk
	 * where it's an output parameter representing the full speed limit.
	 * the usb spec fixes high speed bulk maxpacket at 512 bytes.
	 */
	max = 0x7ff & le16_to_cpu(get_unaligned(&desc->wMaxPacketSize));
	switch (type) {
	case USB_ENDPOINT_XFER_INT:
		/* INT:  limit 64 bytes full speed, 1024 high speed */
		if (!gadget->is_dualspeed && max > 64)
			return 0;
		/* FALLTHROUGH */

	case USB_ENDPOINT_XFER_ISOC:
		/* ISO:  limit 1023 bytes full speed, 1024 high speed */
		if (ep->maxpacket < max)
			return 0;
		if (!gadget->is_dualspeed && max > 1023)
			return 0;

		/* BOTH:  "high bandwidth" works only at high speed */
		if ((get_unaligned(&desc->wMaxPacketSize) &
					__constant_cpu_to_le16(3<<11))) {
			if (!gadget->is_dualspeed)
				return 0;
			/* configure your hardware with enough buffering!! */
		}
		break;
	}

	/* MATCH!! */

	/* report address */
	if (isdigit(ep->name[2])) {
		u8	num = simple_strtoul(&ep->name[2], NULL, 10);
		desc->bEndpointAddress |= num;
#ifdef	MANY_ENDPOINTS
	} else if (desc->bEndpointAddress & USB_DIR_IN) {
		if (++in_epnum > 15)
			return 0;
		desc->bEndpointAddress = USB_DIR_IN | in_epnum;
#endif
	} else {
		if (++epnum > 15)
			return 0;
		desc->bEndpointAddress |= epnum;
	}

	/* report (variable) full speed bulk maxpacket */
	if (USB_ENDPOINT_XFER_BULK == type) {
		int size = ep->maxpacket;

		/* min() doesn't work on bitfields with gcc-3.5 */
		if (size > 64)
			size = 64;
		put_unaligned(cpu_to_le16(size), &desc->wMaxPacketSize);
	}
	return 1;
}

static struct usb_ep *
find_ep(struct usb_gadget *gadget, const char *name)
{
	struct usb_ep	*ep;

	list_for_each_entry(ep, &gadget->ep_list, ep_list) {
		if (0 == strcmp(ep->name, name))
			return ep;
	}
	return NULL;
}

/**
 * usb_ep_autoconfig - choose an endpoint matching the descriptor
 * @gadget: The device to which the endpoint must belong.
 * @desc: Endpoint descriptor, with endpoint direction and transfer mode
 *	initialized.  For periodic transfers, the maximum packet
 *	size must also be initialized.  This is modified on success.
 *
 * By choosing an endpoint to use with the specified descriptor, this
 * routine simplifies writing gadget drivers that work with multiple
 * USB device controllers.  The endpoint would be passed later to
 * usb_ep_enable(), along with some descriptor.
 *
 * That second descriptor won't always be the same as the first one.
 * For example, isochronous endpoints can be autoconfigured for high
 * bandwidth, and then used in several lower bandwidth altsettings.
 * Also, high and full speed descriptors will be different.
 *
 * Be sure to examine and test the results of autoconfiguration on your
 * hardware.  This code may not make the best choices about how to use the
 * USB controller, and it can't know all the restrictions that may apply.
 * Some combinations of driver and hardware won't be able to autoconfigure.
 *
 * On success, this returns an un-claimed usb_ep, and modifies the endpoint
 * descriptor bEndpointAddress.  For bulk endpoints, the wMaxPacket value
 * is initialized as if the endpoint were used at full speed.  To prevent
 * the endpoint from being returned by a later autoconfig call, claim it
 * by assigning ep->driver_data to some non-null value.
 *
 * On failure, this returns a null endpoint descriptor.
 */
struct usb_ep *usb_ep_autoconfig(
	struct usb_gadget		*gadget,
	struct usb_endpoint_descriptor	*desc
)
{
	struct usb_ep	*ep;
	u8		type;

	type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;

	/* First, apply chip-specific "best usage" knowledge.
	 * This might make a good usb_gadget_ops hook ...
	 */
	if (gadget_is_net2280(gadget) && type == USB_ENDPOINT_XFER_INT) {
		/* ep-e, ep-f are PIO with only 64 byte fifos */
		ep = find_ep(gadget, "ep-e");
		if (ep && ep_matches(gadget, ep, desc))
			return ep;
		ep = find_ep(gadget, "ep-f");
		if (ep && ep_matches(gadget, ep, desc))
			return ep;

	} else if (gadget_is_goku(gadget)) {
		if (USB_ENDPOINT_XFER_INT == type) {
			/* single buffering is enough */
			ep = find_ep(gadget, "ep3-bulk");
			if (ep && ep_matches(gadget, ep, desc))
				return ep;
		} else if (USB_ENDPOINT_XFER_BULK == type
				&& (USB_DIR_IN & desc->bEndpointAddress)) {
			/* DMA may be available */
			ep = find_ep(gadget, "ep2-bulk");
			if (ep && ep_matches(gadget, ep, desc))
				return ep;
		}

	} else if (gadget_is_sh(gadget) && USB_ENDPOINT_XFER_INT == type) {
		/* single buffering is enough; maybe 8 byte fifo is too */
		ep = find_ep(gadget, "ep3in-bulk");
		if (ep && ep_matches(gadget, ep, desc))
			return ep;

	} else if (gadget_is_mq11xx(gadget) && USB_ENDPOINT_XFER_INT == type) {
		ep = find_ep(gadget, "ep1-bulk");
		if (ep && ep_matches(gadget, ep, desc))
			return ep;
	}

	/* Second, look at endpoints until an unclaimed one looks usable */
	list_for_each_entry(ep, &gadget->ep_list, ep_list) {
		if (ep_matches(gadget, ep, desc))
			return ep;
	}

	/* Fail */
	return NULL;
}

/**
 * usb_ep_autoconfig_reset - reset endpoint autoconfig state
 * @gadget: device for which autoconfig state will be reset
 *
 * Use this for devices where one configuration may need to assign
 * endpoint resources very differently from the next one.  It clears
 * state such as ep->driver_data and the record of assigned endpoints
 * used by usb_ep_autoconfig().
 */
void usb_ep_autoconfig_reset(struct usb_gadget *gadget)
{
	struct usb_ep	*ep;

	list_for_each_entry(ep, &gadget->ep_list, ep_list) {
		ep->driver_data = NULL;
	}
#ifdef	MANY_ENDPOINTS
	in_epnum = 0;
#endif
	epnum = 0;
}
Commit	Line	Data
23cd1385 RB	1	/*
	2	* epautoconf.c -- endpoint autoconfiguration for usb gadget drivers
	3	*
	4	* Copyright (C) 2004 David Brownell
	5	*
1a459660	6	* SPDX-License-Identifier: GPL-2.0+
23cd1385	7	*
1a459660	8	* SPDX-License-Identifier: GPL-2.0+
23cd1385 RB	9	*
	10	* Ported to U-boot by: Thomas Smits <ts.smits@gmail.com> and
	11	* Remy Bohmer <linux@bohmer.net>
	12	*/
	13
	14	#include <common.h>
	15	#include <linux/usb/ch9.h>
	16	#include <asm/errno.h>
	17	#include <linux/usb/gadget.h>
b2fb47f1	18	#include <asm/unaligned.h>
23cd1385 RB	19	#include "gadget_chips.h"
	20
	21	#define isdigit(c) ('0' <= (c) && (c) <= '9')
	22
	23	/* we must assign addresses for configurable endpoints (like net2280) */
	24	static unsigned epnum;
	25
6142e0ae	26	/* #define MANY_ENDPOINTS */
23cd1385 RB	27	#ifdef MANY_ENDPOINTS
	28	/* more than 15 configurable endpoints */
	29	static unsigned in_epnum;
	30	#endif
	31
	32
	33	/*
	34	* This should work with endpoints from controller drivers sharing the
	35	* same endpoint naming convention. By example:
	36	*
	37	* - ep1, ep2, ... address is fixed, not direction or type
	38	* - ep1in, ep2out, ... address and direction are fixed, not type
	39	* - ep1-bulk, ep2-bulk, ... address and type are fixed, not direction
	40	* - ep1in-bulk, ep2out-iso, ... all three are fixed
	41	* - ep-* ... no functionality restrictions
	42	*
	43	* Type suffixes are "-bulk", "-iso", or "-int". Numbers are decimal.
	44	* Less common restrictions are implied by gadget_is_*().
	45	*
	46	* NOTE: each endpoint is unidirectional, as specified by its USB
	47	* descriptor; and isn't specific to a configuration or altsetting.
	48	*/
6142e0ae	49	static int ep_matches(
23cd1385 RB	50	struct usb_gadget *gadget,
	51	struct usb_ep *ep,
	52	struct usb_endpoint_descriptor *desc
	53	)
	54	{
	55	u8 type;
	56	const char *tmp;
	57	u16 max;
	58
	59	/* endpoint already claimed? */
	60	if (NULL != ep->driver_data)
	61	return 0;
	62
	63	/* only support ep0 for portable CONTROL traffic */
	64	type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
	65	if (USB_ENDPOINT_XFER_CONTROL == type)
	66	return 0;
	67
	68	/* some other naming convention */
	69	if ('e' != ep->name[0])
	70	return 0;
	71
	72	/* type-restriction: "-iso", "-bulk", or "-int".
	73	* direction-restriction: "in", "out".
	74	*/
	75	if ('-' != ep->name[2]) {
6142e0ae	76	tmp = strrchr(ep->name, '-');
23cd1385 RB	77	if (tmp) {
	78	switch (type) {
	79	case USB_ENDPOINT_XFER_INT:
	80	/* bulk endpoints handle interrupt transfers,
	81	* except the toggle-quirky iso-synch kind
	82	*/
6142e0ae	83	if ('s' == tmp[2]) /* == "-iso" */
23cd1385 RB	84	return 0;
	85	/* for now, avoid PXA "interrupt-in";
	86	* it's documented as never using DATA1.
	87	*/
6142e0ae VK	88	if (gadget_is_pxa(gadget)
6142e0ae VK	89	&& 'i' == tmp[1])
23cd1385 RB	90	return 0;
	91	break;
	92	case USB_ENDPOINT_XFER_BULK:
6142e0ae	93	if ('b' != tmp[1]) /* != "-bulk" */
23cd1385 RB	94	return 0;
	95	break;
	96	case USB_ENDPOINT_XFER_ISOC:
6142e0ae	97	if ('s' != tmp[2]) /* != "-iso" */
23cd1385 RB	98	return 0;
	99	}
	100	} else {
6142e0ae	101	tmp = ep->name + strlen(ep->name);
23cd1385 RB	102	}
	103
	104	/* direction-restriction: "..in-..", "out-.." */
	105	tmp--;
6142e0ae	106	if (!isdigit(*tmp)) {
23cd1385 RB	107	if (desc->bEndpointAddress & USB_DIR_IN) {
	108	if ('n' != *tmp)
	109	return 0;
	110	} else {
	111	if ('t' != *tmp)
	112	return 0;
	113	}
	114	}
	115	}
	116
	117	/* endpoint maxpacket size is an input parameter, except for bulk
	118	* where it's an output parameter representing the full speed limit.
	119	* the usb spec fixes high speed bulk maxpacket at 512 bytes.
	120	*/
b2fb47f1	121	max = 0x7ff & le16_to_cpu(get_unaligned(&desc->wMaxPacketSize));
23cd1385 RB	122	switch (type) {
	123	case USB_ENDPOINT_XFER_INT:
	124	/* INT: limit 64 bytes full speed, 1024 high speed */
	125	if (!gadget->is_dualspeed && max > 64)
	126	return 0;
	127	/* FALLTHROUGH */
	128
	129	case USB_ENDPOINT_XFER_ISOC:
	130	/* ISO: limit 1023 bytes full speed, 1024 high speed */
	131	if (ep->maxpacket < max)
	132	return 0;
	133	if (!gadget->is_dualspeed && max > 1023)
	134	return 0;
	135
	136	/* BOTH: "high bandwidth" works only at high speed */
b2fb47f1 TR	137	if ((get_unaligned(&desc->wMaxPacketSize) &
b2fb47f1 TR	138	__constant_cpu_to_le16(3<<11))) {
23cd1385 RB	139	if (!gadget->is_dualspeed)
	140	return 0;
	141	/* configure your hardware with enough buffering!! */
	142	}
	143	break;
	144	}
	145
	146	/* MATCH!! */
	147
	148	/* report address */
6142e0ae VK	149	if (isdigit(ep->name[2])) {
6142e0ae VK	150	u8 num = simple_strtoul(&ep->name[2], NULL, 10);
23cd1385 RB	151	desc->bEndpointAddress \|= num;
	152	#ifdef MANY_ENDPOINTS
	153	} else if (desc->bEndpointAddress & USB_DIR_IN) {
	154	if (++in_epnum > 15)
	155	return 0;
	156	desc->bEndpointAddress = USB_DIR_IN \| in_epnum;
	157	#endif
	158	} else {
	159	if (++epnum > 15)
	160	return 0;
	161	desc->bEndpointAddress \|= epnum;
	162	}
	163
	164	/* report (variable) full speed bulk maxpacket */
	165	if (USB_ENDPOINT_XFER_BULK == type) {
	166	int size = ep->maxpacket;
	167
	168	/* min() doesn't work on bitfields with gcc-3.5 */
	169	if (size > 64)
	170	size = 64;
b2fb47f1	171	put_unaligned(cpu_to_le16(size), &desc->wMaxPacketSize);
23cd1385 RB	172	}
	173	return 1;
	174	}
	175
	176	static struct usb_ep *
6142e0ae	177	find_ep(struct usb_gadget gadget, const char name)
23cd1385 RB	178	{
	179	struct usb_ep *ep;
	180
6142e0ae VK	181	list_for_each_entry(ep, &gadget->ep_list, ep_list) {
6142e0ae VK	182	if (0 == strcmp(ep->name, name))
23cd1385 RB	183	return ep;
	184	}
	185	return NULL;
	186	}
	187
	188	/**
	189	* usb_ep_autoconfig - choose an endpoint matching the descriptor
	190	* @gadget: The device to which the endpoint must belong.
	191	* @desc: Endpoint descriptor, with endpoint direction and transfer mode
	192	* initialized. For periodic transfers, the maximum packet
	193	* size must also be initialized. This is modified on success.
	194	*
	195	* By choosing an endpoint to use with the specified descriptor, this
	196	* routine simplifies writing gadget drivers that work with multiple
	197	* USB device controllers. The endpoint would be passed later to
	198	* usb_ep_enable(), along with some descriptor.
	199	*
	200	* That second descriptor won't always be the same as the first one.
	201	* For example, isochronous endpoints can be autoconfigured for high
	202	* bandwidth, and then used in several lower bandwidth altsettings.
	203	* Also, high and full speed descriptors will be different.
	204	*
	205	* Be sure to examine and test the results of autoconfiguration on your
	206	* hardware. This code may not make the best choices about how to use the
	207	* USB controller, and it can't know all the restrictions that may apply.
	208	* Some combinations of driver and hardware won't be able to autoconfigure.
	209	*
	210	* On success, this returns an un-claimed usb_ep, and modifies the endpoint
	211	* descriptor bEndpointAddress. For bulk endpoints, the wMaxPacket value
	212	* is initialized as if the endpoint were used at full speed. To prevent
	213	* the endpoint from being returned by a later autoconfig call, claim it
	214	* by assigning ep->driver_data to some non-null value.
	215	*
	216	* On failure, this returns a null endpoint descriptor.
	217	*/
6142e0ae	218	struct usb_ep *usb_ep_autoconfig(
23cd1385 RB	219	struct usb_gadget *gadget,
	220	struct usb_endpoint_descriptor *desc
	221	)
	222	{
	223	struct usb_ep *ep;
	224	u8 type;
	225
	226	type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
	227
	228	/* First, apply chip-specific "best usage" knowledge.
	229	* This might make a good usb_gadget_ops hook ...
	230	*/
6142e0ae	231	if (gadget_is_net2280(gadget) && type == USB_ENDPOINT_XFER_INT) {
23cd1385	232	/* ep-e, ep-f are PIO with only 64 byte fifos */
6142e0ae VK	233	ep = find_ep(gadget, "ep-e");
6142e0ae VK	234	if (ep && ep_matches(gadget, ep, desc))
23cd1385	235	return ep;
6142e0ae VK	236	ep = find_ep(gadget, "ep-f");
6142e0ae VK	237	if (ep && ep_matches(gadget, ep, desc))
23cd1385 RB	238	return ep;
23cd1385 RB	239
6142e0ae	240	} else if (gadget_is_goku(gadget)) {
23cd1385 RB	241	if (USB_ENDPOINT_XFER_INT == type) {
23cd1385 RB	242	/* single buffering is enough */
6142e0ae VK	243	ep = find_ep(gadget, "ep3-bulk");
6142e0ae VK	244	if (ep && ep_matches(gadget, ep, desc))
23cd1385 RB	245	return ep;
	246	} else if (USB_ENDPOINT_XFER_BULK == type
	247	&& (USB_DIR_IN & desc->bEndpointAddress)) {
	248	/* DMA may be available */
6142e0ae VK	249	ep = find_ep(gadget, "ep2-bulk");
6142e0ae VK	250	if (ep && ep_matches(gadget, ep, desc))
23cd1385 RB	251	return ep;
	252	}
	253
6142e0ae	254	} else if (gadget_is_sh(gadget) && USB_ENDPOINT_XFER_INT == type) {
23cd1385	255	/* single buffering is enough; maybe 8 byte fifo is too */
6142e0ae VK	256	ep = find_ep(gadget, "ep3in-bulk");
6142e0ae VK	257	if (ep && ep_matches(gadget, ep, desc))
23cd1385 RB	258	return ep;
23cd1385 RB	259
6142e0ae VK	260	} else if (gadget_is_mq11xx(gadget) && USB_ENDPOINT_XFER_INT == type) {
	261	ep = find_ep(gadget, "ep1-bulk");
	262	if (ep && ep_matches(gadget, ep, desc))
23cd1385 RB	263	return ep;
	264	}
	265
	266	/* Second, look at endpoints until an unclaimed one looks usable */
6142e0ae VK	267	list_for_each_entry(ep, &gadget->ep_list, ep_list) {
6142e0ae VK	268	if (ep_matches(gadget, ep, desc))
23cd1385 RB	269	return ep;
	270	}
	271
	272	/* Fail */
	273	return NULL;
	274	}
	275
	276	/**
	277	* usb_ep_autoconfig_reset - reset endpoint autoconfig state
	278	* @gadget: device for which autoconfig state will be reset
	279	*
	280	* Use this for devices where one configuration may need to assign
	281	* endpoint resources very differently from the next one. It clears
	282	* state such as ep->driver_data and the record of assigned endpoints
	283	* used by usb_ep_autoconfig().
	284	*/
6142e0ae	285	void usb_ep_autoconfig_reset(struct usb_gadget *gadget)
23cd1385 RB	286	{
	287	struct usb_ep *ep;
	288
6142e0ae	289	list_for_each_entry(ep, &gadget->ep_list, ep_list) {
23cd1385 RB	290	ep->driver_data = NULL;
	291	}
	292	#ifdef MANY_ENDPOINTS
	293	in_epnum = 0;
	294	#endif
	295	epnum = 0;
	296	}