[people/ms/u-boot.git] / drivers / usb / host / usb-sandbox.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/root.h>

DECLARE_GLOBAL_DATA_PTR;

static void usbmon_trace(struct udevice *bus, ulong pipe,
			 struct devrequest *setup, struct udevice *emul)
{
	static const char types[] = "ZICB";
	int type;

	type = (pipe & USB_PIPE_TYPE_MASK) >> USB_PIPE_TYPE_SHIFT;
	debug("0 0 S %c%c:%d:%03ld:%ld", types[type],
	      pipe & USB_DIR_IN ? 'i' : 'o',
	      bus->seq,
	      (pipe & USB_PIPE_DEV_MASK) >> USB_PIPE_DEV_SHIFT,
	      (pipe & USB_PIPE_EP_MASK) >> USB_PIPE_EP_SHIFT);
	if (setup) {
		debug(" s %02x %02x %04x %04x %04x", setup->requesttype,
		      setup->request, setup->value, setup->index,
		      setup->length);
	}
	debug(" %s", emul ? emul->name : "(no emul found)");

	debug("\n");
}

static int sandbox_submit_control(struct udevice *bus,
				      struct usb_device *udev,
				      unsigned long pipe,
				      void *buffer, int length,
				      struct devrequest *setup)
{
	struct udevice *emul;
	int ret;

	/* Just use child of dev as emulator? */
	debug("%s: bus=%s\n", __func__, bus->name);
	ret = usb_emul_find(bus, pipe, &emul);
	usbmon_trace(bus, pipe, setup, emul);
	if (ret)
		return ret;
	ret = usb_emul_control(emul, udev, pipe, buffer, length, setup);
	if (ret < 0) {
		debug("ret=%d\n", ret);
		udev->status = ret;
		udev->act_len = 0;
	} else {
		udev->status = 0;
		udev->act_len = ret;
	}

	return ret;
}

static int sandbox_submit_bulk(struct udevice *bus, struct usb_device *udev,
			       unsigned long pipe, void *buffer, int length)
{
	struct udevice *emul;
	int ret;

	/* Just use child of dev as emulator? */
	debug("%s: bus=%s\n", __func__, bus->name);
	ret = usb_emul_find(bus, pipe, &emul);
	usbmon_trace(bus, pipe, NULL, emul);
	if (ret)
		return ret;
	ret = usb_emul_bulk(emul, udev, pipe, buffer, length);
	if (ret < 0) {
		debug("ret=%d\n", ret);
		udev->status = ret;
		udev->act_len = 0;
	} else {
		udev->status = 0;
		udev->act_len = ret;
	}

	return ret;
}

static int sandbox_submit_int(struct udevice *bus, struct usb_device *udev,
			      unsigned long pipe, void *buffer, int length,
			      int interval)
{
	struct udevice *emul;
	int ret;

	/* Just use child of dev as emulator? */
	debug("%s: bus=%s\n", __func__, bus->name);
	ret = usb_emul_find(bus, pipe, &emul);
	usbmon_trace(bus, pipe, NULL, emul);
	if (ret)
		return ret;
	ret = usb_emul_int(emul, udev, pipe, buffer, length, interval);

	return ret;
}

static int sandbox_alloc_device(struct udevice *dev, struct usb_device *udev)
{
	return 0;
}

static int sandbox_usb_probe(struct udevice *dev)
{
	return 0;
}

static const struct dm_usb_ops sandbox_usb_ops = {
	.control	= sandbox_submit_control,
	.bulk		= sandbox_submit_bulk,
	.interrupt	= sandbox_submit_int,
	.alloc_device	= sandbox_alloc_device,
};

static const struct udevice_id sandbox_usb_ids[] = {
	{ .compatible = "sandbox,usb" },
	{ }
};

U_BOOT_DRIVER(usb_sandbox) = {
	.name	= "usb_sandbox",
	.id	= UCLASS_USB,
	.of_match = sandbox_usb_ids,
	.probe = sandbox_usb_probe,
	.ops	= &sandbox_usb_ops,
};
Commit	Line	Data
dfd84001 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>
	11	#include <dm/root.h>
	12
	13	DECLARE_GLOBAL_DATA_PTR;
	14
	15	static void usbmon_trace(struct udevice *bus, ulong pipe,
	16	struct devrequest setup, struct udevice emul)
	17	{
	18	static const char types[] = "ZICB";
	19	int type;
	20
	21	type = (pipe & USB_PIPE_TYPE_MASK) >> USB_PIPE_TYPE_SHIFT;
	22	debug("0 0 S %c%c:%d:%03ld:%ld", types[type],
	23	pipe & USB_DIR_IN ? 'i' : 'o',
	24	bus->seq,
	25	(pipe & USB_PIPE_DEV_MASK) >> USB_PIPE_DEV_SHIFT,
	26	(pipe & USB_PIPE_EP_MASK) >> USB_PIPE_EP_SHIFT);
	27	if (setup) {
	28	debug(" s %02x %02x %04x %04x %04x", setup->requesttype,
	29	setup->request, setup->value, setup->index,
	30	setup->length);
	31	}
	32	debug(" %s", emul ? emul->name : "(no emul found)");
	33
	34	debug("\n");
	35	}
	36
	37	static int sandbox_submit_control(struct udevice *bus,
	38	struct usb_device *udev,
	39	unsigned long pipe,
	40	void *buffer, int length,
	41	struct devrequest *setup)
	42	{
	43	struct udevice *emul;
	44	int ret;
	45
	46	/* Just use child of dev as emulator? */
	47	debug("%s: bus=%s\n", __func__, bus->name);
	48	ret = usb_emul_find(bus, pipe, &emul);
	49	usbmon_trace(bus, pipe, setup, emul);
	50	if (ret)
	51	return ret;
	52	ret = usb_emul_control(emul, udev, pipe, buffer, length, setup);
	53	if (ret < 0) {
	54	debug("ret=%d\n", ret);
	55	udev->status = ret;
	56	udev->act_len = 0;
	57	} else {
	58	udev->status = 0;
	59	udev->act_len = ret;
	60	}
	61
	62	return ret;
	63	}
	64
65	static int sandbox_submit_bulk(struct udevice bus, struct usb_device udev,
66	unsigned long pipe, void *buffer, int length)
67	{
68	struct udevice *emul;
69	int ret;
70
71	/* Just use child of dev as emulator? */
72	debug("%s: bus=%s\n", __func__, bus->name);
73	ret = usb_emul_find(bus, pipe, &emul);
74	usbmon_trace(bus, pipe, NULL, emul);
75	if (ret)
76	return ret;
77	ret = usb_emul_bulk(emul, udev, pipe, buffer, length);
78	if (ret < 0) {
79	debug("ret=%d\n", ret);
80	udev->status = ret;
81	udev->act_len = 0;
82	} else {
83	udev->status = 0;
84	udev->act_len = ret;
85	}
86
87	return ret;
88	}
89
b70a3fea SG	90	static int sandbox_submit_int(struct udevice bus, struct usb_device udev,
	91	unsigned long pipe, void *buffer, int length,
	92	int interval)
	93	{
	94	struct udevice *emul;
	95	int ret;
	96
	97	/* Just use child of dev as emulator? */
	98	debug("%s: bus=%s\n", __func__, bus->name);
	99	ret = usb_emul_find(bus, pipe, &emul);
	100	usbmon_trace(bus, pipe, NULL, emul);
	101	if (ret)
	102	return ret;
	103	ret = usb_emul_int(emul, udev, pipe, buffer, length, interval);
	104
	105	return ret;
	106	}
	107
dfd84001 SG	108	static int sandbox_alloc_device(struct udevice dev, struct usb_device udev)
	109	{
	110	return 0;
	111	}
	112
	113	static int sandbox_usb_probe(struct udevice *dev)
	114	{
	115	return 0;
	116	}
	117
	118	static const struct dm_usb_ops sandbox_usb_ops = {
	119	.control = sandbox_submit_control,
	120	.bulk = sandbox_submit_bulk,
b70a3fea	121	.interrupt = sandbox_submit_int,
dfd84001 SG	122	.alloc_device = sandbox_alloc_device,
	123	};
	124
	125	static const struct udevice_id sandbox_usb_ids[] = {
	126	{ .compatible = "sandbox,usb" },
	127	{ }
	128	};
	129
	130	U_BOOT_DRIVER(usb_sandbox) = {
	131	.name = "usb_sandbox",
	132	.id = UCLASS_USB,
	133	.of_match = sandbox_usb_ids,
	134	.probe = sandbox_usb_probe,
	135	.ops = &sandbox_usb_ops,
	136	};