[people/ms/u-boot.git] / drivers / usb / emul / usb-emul-uclass.c

/*
 * (C) Copyright 2015 Google, Inc
 * Written by Simon Glass <sjg@chromium.org>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <dm.h>
#include <usb.h>
#include <dm/device-internal.h>

DECLARE_GLOBAL_DATA_PTR;

static int copy_to_unicode(char *buff, int length, const char *str)
{
	int ptr;
	int i;

	if (length < 2)
		return 0;
	buff[1] = USB_DT_STRING;
	for (ptr = 2, i = 0; ptr + 1 < length && *str; i++, ptr += 2) {
		buff[ptr] = str[i];
		buff[ptr + 1] = 0;
	}
	buff[0] = ptr;

	return ptr;
}

static int usb_emul_get_string(struct usb_string *strings, int index,
			       char *buff, int length)
{
	if (index == 0) {
		char *desc = buff;

		desc[0] = 4;
		desc[1] = USB_DT_STRING;
		desc[2] = 0x09;
		desc[3] = 0x14;
		return 4;
	} else if (strings) {
		struct usb_string *ptr;

		for (ptr = strings; ptr->s; ptr++) {
			if (ptr->id == index)
				return copy_to_unicode(buff, length, ptr->s);
		}
	}

	return -EINVAL;
}

struct usb_generic_descriptor **usb_emul_find_descriptor(
		struct usb_generic_descriptor **ptr, int type, int index)
{
	debug("%s: type=%x, index=%d\n", __func__, type, index);
	for (; *ptr; ptr++) {
		if ((*ptr)->bDescriptorType != type)
			continue;
		switch (type) {
		case USB_DT_CONFIG: {
			struct usb_config_descriptor *cdesc;

			cdesc = (struct usb_config_descriptor *)*ptr;
			if (cdesc && cdesc->bConfigurationValue == index)
				return ptr;
			break;
		}
		default:
			return ptr;
		}
	}
	debug("%s: config ptr=%p\n", __func__, *ptr);

	return ptr;
}

static int usb_emul_get_descriptor(struct usb_dev_platdata *plat, int value,
				   void *buffer, int length)
{
	struct usb_generic_descriptor **ptr;
	int type = value >> 8;
	int index = value & 0xff;
	int upto, todo;

	debug("%s: type=%d, index=%d, plat=%p\n", __func__, type, index, plat);
	if (type == USB_DT_STRING) {
		return usb_emul_get_string(plat->strings, index, buffer,
					   length);
	}

	ptr = usb_emul_find_descriptor(plat->desc_list, type, index);
	if (!ptr) {
		debug("%s: Could not find descriptor type %d, index %d\n",
		      __func__, type, index);
		return -ENOENT;
	}
	for (upto = 0; *ptr && upto < length; ptr++, upto += todo) {
		todo = min(length - upto, (int)(*ptr)->bLength);

		memcpy(buffer + upto, *ptr, todo);
	}

	return upto ? upto : length ? -EIO : 0;
}

static int usb_emul_find_devnum(int devnum, int port1, struct udevice **emulp)
{
	struct udevice *dev;
	struct uclass *uc;
	int ret;

	*emulp = NULL;
	ret = uclass_get(UCLASS_USB_EMUL, &uc);
	if (ret)
		return ret;
	uclass_foreach_dev(dev, uc) {
		struct usb_dev_platdata *udev = dev_get_parent_platdata(dev);

		/*
		 * devnum is initialzied to zero at the beginning of the
		 * enumeration process in usb_setup_device(). At this
		 * point, udev->devnum has not been assigned to any valid
		 * USB address either, so we can't rely on the comparison
		 * result between udev->devnum and devnum to select an
		 * emulator device.
		 */
		if (!devnum) {
			struct usb_emul_platdata *plat;

			/*
			 * If the parent is sandbox USB controller, we are
			 * the root hub. And there is only one root hub
			 * in the system.
			 */
			if (device_get_uclass_id(dev->parent) == UCLASS_USB) {
				debug("%s: Found emulator '%s'\n",
				      __func__, dev->name);
				*emulp = dev;
				return 0;
			}

			plat = dev_get_uclass_platdata(dev);
			if (plat->port1 == port1) {
				debug("%s: Found emulator '%s', port %d\n",
				      __func__, dev->name, port1);
				*emulp = dev;
				return 0;
			}
		} else if (udev->devnum == devnum) {
			debug("%s: Found emulator '%s', addr %d\n", __func__,
			      dev->name, udev->devnum);
			*emulp = dev;
			return 0;
		}
	}

	debug("%s: No emulator found, addr %d\n", __func__, devnum);
	return -ENOENT;
}

int usb_emul_find(struct udevice *bus, ulong pipe, int port1,
		  struct udevice **emulp)
{
	int devnum = usb_pipedevice(pipe);

	return usb_emul_find_devnum(devnum, port1, emulp);
}

int usb_emul_find_for_dev(struct udevice *dev, struct udevice **emulp)
{
	struct usb_dev_platdata *udev = dev_get_parent_platdata(dev);

	return usb_emul_find_devnum(udev->devnum, 0, emulp);
}

int usb_emul_control(struct udevice *emul, struct usb_device *udev,
		     unsigned long pipe, void *buffer, int length,
		     struct devrequest *setup)
{
	struct dm_usb_ops *ops = usb_get_emul_ops(emul);
	struct usb_dev_platdata *plat;
	int ret;

	/* We permit getting the descriptor before we are probed */
	plat = dev_get_parent_platdata(emul);
	if (!ops->control)
		return -ENOSYS;
	debug("%s: dev=%s\n", __func__, emul->name);
	if (pipe == usb_rcvctrlpipe(udev, 0)) {
		switch (setup->request) {
		case USB_REQ_GET_DESCRIPTOR: {
			return usb_emul_get_descriptor(plat, setup->value,
						       buffer, length);
		}
		default:
			ret = device_probe(emul);
			if (ret)
				return ret;
			return ops->control(emul, udev, pipe, buffer, length,
					    setup);
		}
	} else if (pipe == usb_snddefctrl(udev)) {
		switch (setup->request) {
		case USB_REQ_SET_ADDRESS:
			debug("   ** set address %s %d\n", emul->name,
			      setup->value);
			plat->devnum = setup->value;
			return 0;
		default:
			debug("requestsend =%x\n", setup->request);
			break;
		}
	} else if (pipe == usb_sndctrlpipe(udev, 0)) {
		switch (setup->request) {
		case USB_REQ_SET_CONFIGURATION:
			plat->configno = setup->value;
			return 0;
		default:
			ret = device_probe(emul);
			if (ret)
				return ret;
			return ops->control(emul, udev, pipe, buffer, length,
					    setup);
		}
	}
	debug("pipe=%lx\n", pipe);

	return -EIO;
}

int usb_emul_bulk(struct udevice *emul, struct usb_device *udev,
		  unsigned long pipe, void *buffer, int length)
{
	struct dm_usb_ops *ops = usb_get_emul_ops(emul);
	int ret;

	/* We permit getting the descriptor before we are probed */
	if (!ops->bulk)
		return -ENOSYS;
	debug("%s: dev=%s\n", __func__, emul->name);
	ret = device_probe(emul);
	if (ret)
		return ret;
	return ops->bulk(emul, udev, pipe, buffer, length);
}

int usb_emul_int(struct udevice *emul, struct usb_device *udev,
		  unsigned long pipe, void *buffer, int length, int interval)
{
	struct dm_usb_ops *ops = usb_get_emul_ops(emul);

	if (!ops->interrupt)
		return -ENOSYS;
	debug("%s: dev=%s\n", __func__, emul->name);

	return ops->interrupt(emul, udev, pipe, buffer, length, interval);
}

int usb_emul_setup_device(struct udevice *dev, struct usb_string *strings,
			  void **desc_list)
{
	struct usb_dev_platdata *plat = dev_get_parent_platdata(dev);
	struct usb_generic_descriptor **ptr;
	struct usb_config_descriptor *cdesc;
	int upto;

	plat->strings = strings;
	plat->desc_list = (struct usb_generic_descriptor **)desc_list;

	/* Fill in wTotalLength for each configuration descriptor */
	ptr = plat->desc_list;
	for (cdesc = NULL, upto = 0; *ptr; upto += (*ptr)->bLength, ptr++) {
		debug("   - upto=%d, type=%d\n", upto, (*ptr)->bDescriptorType);
		if ((*ptr)->bDescriptorType == USB_DT_CONFIG) {
			if (cdesc) {
				cdesc->wTotalLength = upto;
				debug("%s: config %d length %d\n", __func__,
				      cdesc->bConfigurationValue,
				      cdesc->bLength);
			}
			cdesc = (struct usb_config_descriptor *)*ptr;
			upto = 0;
		}
	}
	if (cdesc) {
		cdesc->wTotalLength = upto;
		debug("%s: config %d length %d\n", __func__,
		      cdesc->bConfigurationValue, cdesc->wTotalLength);
	}

	return 0;
}

UCLASS_DRIVER(usb_emul) = {
	.id		= UCLASS_USB_EMUL,
	.name		= "usb_emul",
	.post_bind	= dm_scan_fdt_dev,
	.per_device_platdata_auto_alloc_size = sizeof(struct usb_emul_platdata),
	.per_child_auto_alloc_size = sizeof(struct usb_device),
	.per_child_platdata_auto_alloc_size = sizeof(struct usb_dev_platdata),
};
Commit	Line	Data
019808f9 SG	1	/*
	2	* (C) Copyright 2015 Google, Inc
	3	* Written by Simon Glass <sjg@chromium.org>
	4	*
	5	* SPDX-License-Identifier: GPL-2.0+
	6	*/
	7
	8	#include <common.h>
	9	#include <dm.h>
	10	#include <usb.h>
019808f9 SG	11	#include <dm/device-internal.h>
	12
	13	DECLARE_GLOBAL_DATA_PTR;
	14
	15	static int copy_to_unicode(char buff, int length, const char str)
	16	{
	17	int ptr;
	18	int i;
	19
	20	if (length < 2)
	21	return 0;
	22	buff[1] = USB_DT_STRING;
	23	for (ptr = 2, i = 0; ptr + 1 < length && *str; i++, ptr += 2) {
	24	buff[ptr] = str[i];
	25	buff[ptr + 1] = 0;
	26	}
	27	buff[0] = ptr;
	28
	29	return ptr;
	30	}
	31
	32	static int usb_emul_get_string(struct usb_string *strings, int index,
	33	char *buff, int length)
	34	{
	35	if (index == 0) {
	36	char *desc = buff;
	37
	38	desc[0] = 4;
	39	desc[1] = USB_DT_STRING;
	40	desc[2] = 0x09;
	41	desc[3] = 0x14;
	42	return 4;
	43	} else if (strings) {
	44	struct usb_string *ptr;
	45
	46	for (ptr = strings; ptr->s; ptr++) {
	47	if (ptr->id == index)
	48	return copy_to_unicode(buff, length, ptr->s);
	49	}
	50	}
	51
	52	return -EINVAL;
	53	}
	54
848436a4	55	struct usb_generic_descriptor **usb_emul_find_descriptor(
019808f9 SG	56	struct usb_generic_descriptor **ptr, int type, int index)
	57	{
	58	debug("%s: type=%x, index=%d\n", __func__, type, index);
	59	for (; *ptr; ptr++) {
	60	if ((*ptr)->bDescriptorType != type)
	61	continue;
	62	switch (type) {
	63	case USB_DT_CONFIG: {
	64	struct usb_config_descriptor *cdesc;
	65
	66	cdesc = (struct usb_config_descriptor )ptr;
	67	if (cdesc && cdesc->bConfigurationValue == index)
	68	return ptr;
	69	break;
	70	}
	71	default:
	72	return ptr;
	73	}
	74	}
	75	debug("%s: config ptr=%p\n", __func__, *ptr);
	76
	77	return ptr;
	78	}
	79
	80	static int usb_emul_get_descriptor(struct usb_dev_platdata *plat, int value,
	81	void *buffer, int length)
	82	{
	83	struct usb_generic_descriptor **ptr;
	84	int type = value >> 8;
	85	int index = value & 0xff;
	86	int upto, todo;
	87
	88	debug("%s: type=%d, index=%d, plat=%p\n", __func__, type, index, plat);
	89	if (type == USB_DT_STRING) {
	90	return usb_emul_get_string(plat->strings, index, buffer,
	91	length);
	92	}
	93
848436a4	94	ptr = usb_emul_find_descriptor(plat->desc_list, type, index);
019808f9 SG	95	if (!ptr) {
	96	debug("%s: Could not find descriptor type %d, index %d\n",
	97	__func__, type, index);
	98	return -ENOENT;
	99	}
	100	for (upto = 0; *ptr && upto < length; ptr++, upto += todo) {
	101	todo = min(length - upto, (int)(*ptr)->bLength);
	102
	103	memcpy(buffer + upto, *ptr, todo);
	104	}
	105
	106	return upto ? upto : length ? -EIO : 0;
	107	}
	108
84aa8536	109	static int usb_emul_find_devnum(int devnum, int port1, struct udevice **emulp)
019808f9	110	{
019808f9 SG	111	struct udevice *dev;
	112	struct uclass *uc;
	113	int ret;
	114
	115	*emulp = NULL;
	116	ret = uclass_get(UCLASS_USB_EMUL, &uc);
	117	if (ret)
	118	return ret;
	119	uclass_foreach_dev(dev, uc) {
	120	struct usb_dev_platdata *udev = dev_get_parent_platdata(dev);
	121
84aa8536 BM	122	/*
	123	* devnum is initialzied to zero at the beginning of the
	124	* enumeration process in usb_setup_device(). At this
	125	* point, udev->devnum has not been assigned to any valid
	126	* USB address either, so we can't rely on the comparison
	127	* result between udev->devnum and devnum to select an
	128	* emulator device.
	129	*/
	130	if (!devnum) {
	131	struct usb_emul_platdata *plat;
	132
	133	/*
	134	* If the parent is sandbox USB controller, we are
	135	* the root hub. And there is only one root hub
	136	* in the system.
	137	*/
	138	if (device_get_uclass_id(dev->parent) == UCLASS_USB) {
	139	debug("%s: Found emulator '%s'\n",
	140	__func__, dev->name);
	141	*emulp = dev;
	142	return 0;
	143	}
	144
	145	plat = dev_get_uclass_platdata(dev);
	146	if (plat->port1 == port1) {
	147	debug("%s: Found emulator '%s', port %d\n",
	148	__func__, dev->name, port1);
	149	*emulp = dev;
	150	return 0;
	151	}
	152	} else if (udev->devnum == devnum) {
019808f9 SG	153	debug("%s: Found emulator '%s', addr %d\n", __func__,
	154	dev->name, udev->devnum);
	155	*emulp = dev;
	156	return 0;
	157	}
	158	}
	159
	160	debug("%s: No emulator found, addr %d\n", __func__, devnum);
	161	return -ENOENT;
	162	}
	163
84aa8536 BM	164	int usb_emul_find(struct udevice *bus, ulong pipe, int port1,
84aa8536 BM	165	struct udevice **emulp)
af9c7c11 SG	166	{
	167	int devnum = usb_pipedevice(pipe);
	168
84aa8536	169	return usb_emul_find_devnum(devnum, port1, emulp);
af9c7c11 SG	170	}
	171
	172	int usb_emul_find_for_dev(struct udevice dev, struct udevice *emulp)
	173	{
	174	struct usb_dev_platdata *udev = dev_get_parent_platdata(dev);
	175
84aa8536	176	return usb_emul_find_devnum(udev->devnum, 0, emulp);
af9c7c11 SG	177	}
af9c7c11 SG	178
019808f9 SG	179	int usb_emul_control(struct udevice emul, struct usb_device udev,
	180	unsigned long pipe, void *buffer, int length,
	181	struct devrequest *setup)
	182	{
	183	struct dm_usb_ops *ops = usb_get_emul_ops(emul);
	184	struct usb_dev_platdata *plat;
	185	int ret;
	186
	187	/* We permit getting the descriptor before we are probed */
	188	plat = dev_get_parent_platdata(emul);
	189	if (!ops->control)
	190	return -ENOSYS;
	191	debug("%s: dev=%s\n", __func__, emul->name);
	192	if (pipe == usb_rcvctrlpipe(udev, 0)) {
	193	switch (setup->request) {
	194	case USB_REQ_GET_DESCRIPTOR: {
	195	return usb_emul_get_descriptor(plat, setup->value,
	196	buffer, length);
	197	}
	198	default:
	199	ret = device_probe(emul);
	200	if (ret)
	201	return ret;
	202	return ops->control(emul, udev, pipe, buffer, length,
	203	setup);
	204	}
	205	} else if (pipe == usb_snddefctrl(udev)) {
	206	switch (setup->request) {
	207	case USB_REQ_SET_ADDRESS:
	208	debug(" ** set address %s %d\n", emul->name,
	209	setup->value);
	210	plat->devnum = setup->value;
	211	return 0;
	212	default:
	213	debug("requestsend =%x\n", setup->request);
	214	break;
	215	}
	216	} else if (pipe == usb_sndctrlpipe(udev, 0)) {
	217	switch (setup->request) {
	218	case USB_REQ_SET_CONFIGURATION:
	219	plat->configno = setup->value;
	220	return 0;
	221	default:
	222	ret = device_probe(emul);
	223	if (ret)
	224	return ret;
	225	return ops->control(emul, udev, pipe, buffer, length,
	226	setup);
	227	}
	228	}
	229	debug("pipe=%lx\n", pipe);
	230
	231	return -EIO;
	232	}
	233
	234	int usb_emul_bulk(struct udevice emul, struct usb_device udev,
	235	unsigned long pipe, void *buffer, int length)
	236	{
	237	struct dm_usb_ops *ops = usb_get_emul_ops(emul);
	238	int ret;
	239
	240	/* We permit getting the descriptor before we are probed */
	241	if (!ops->bulk)
	242	return -ENOSYS;
243	debug("%s: dev=%s\n", __func__, emul->name);
244	ret = device_probe(emul);
245	if (ret)
246	return ret;
247	return ops->bulk(emul, udev, pipe, buffer, length);
248	}
249
b70a3fea SG	250	int usb_emul_int(struct udevice emul, struct usb_device udev,
	251	unsigned long pipe, void *buffer, int length, int interval)
	252	{
	253	struct dm_usb_ops *ops = usb_get_emul_ops(emul);
	254
	255	if (!ops->interrupt)
	256	return -ENOSYS;
	257	debug("%s: dev=%s\n", __func__, emul->name);
	258
	259	return ops->interrupt(emul, udev, pipe, buffer, length, interval);
	260	}
	261
98b639fc BM	262	int usb_emul_setup_device(struct udevice dev, struct usb_string strings,
98b639fc BM	263	void **desc_list)
019808f9 SG	264	{
	265	struct usb_dev_platdata *plat = dev_get_parent_platdata(dev);
	266	struct usb_generic_descriptor **ptr;
	267	struct usb_config_descriptor *cdesc;
	268	int upto;
	269
	270	plat->strings = strings;
	271	plat->desc_list = (struct usb_generic_descriptor **)desc_list;
	272
	273	/* Fill in wTotalLength for each configuration descriptor */
	274	ptr = plat->desc_list;
	275	for (cdesc = NULL, upto = 0; ptr; upto += (ptr)->bLength, ptr++) {
	276	debug(" - upto=%d, type=%d\n", upto, (*ptr)->bDescriptorType);
	277	if ((*ptr)->bDescriptorType == USB_DT_CONFIG) {
	278	if (cdesc) {
	279	cdesc->wTotalLength = upto;
	280	debug("%s: config %d length %d\n", __func__,
	281	cdesc->bConfigurationValue,
	282	cdesc->bLength);
	283	}
	284	cdesc = (struct usb_config_descriptor )ptr;
	285	upto = 0;
	286	}
	287	}
	288	if (cdesc) {
	289	cdesc->wTotalLength = upto;
	290	debug("%s: config %d length %d\n", __func__,
	291	cdesc->bConfigurationValue, cdesc->wTotalLength);
	292	}
	293
	294	return 0;
	295	}
	296
019808f9 SG	297	UCLASS_DRIVER(usb_emul) = {
	298	.id = UCLASS_USB_EMUL,
	299	.name = "usb_emul",
91195485	300	.post_bind = dm_scan_fdt_dev,
84aa8536	301	.per_device_platdata_auto_alloc_size = sizeof(struct usb_emul_platdata),
019808f9 SG	302	.per_child_auto_alloc_size = sizeof(struct usb_device),
	303	.per_child_platdata_auto_alloc_size = sizeof(struct usb_dev_platdata),
	304	};