[thirdparty/u-boot.git] / drivers / usb / emul / sandbox_keyb.c

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

#include <common.h>
#include <dm.h>
#include <os.h>
#include <scsi.h>
#include <usb.h>

/*
 * This driver emulates a USB keyboard using the USB HID specification (boot
 * protocol)
 */

enum {
	SANDBOX_KEYB_EP_IN		= 1,	/* endpoints */
};

enum cmd_phase {
	PHASE_START,
	PHASE_DATA,
	PHASE_STATUS,
};

enum {
	STRINGID_MANUFACTURER = 1,
	STRINGID_PRODUCT,
	STRINGID_SERIAL,

	STRINGID_COUNT,
};

/**
 * struct sandbox_keyb_priv - private state for this driver
 *
 */
struct sandbox_keyb_priv {
	struct membuff in;
};

struct sandbox_keyb_plat {
	struct usb_string keyb_strings[STRINGID_COUNT];
};

static struct usb_device_descriptor keyb_device_desc = {
	.bLength =		sizeof(keyb_device_desc),
	.bDescriptorType =	USB_DT_DEVICE,

	.bcdUSB =		__constant_cpu_to_le16(0x0100),

	.bDeviceClass =		0,
	.bDeviceSubClass =	0,
	.bDeviceProtocol =	0,

	.idVendor =		__constant_cpu_to_le16(0x1234),
	.idProduct =		__constant_cpu_to_le16(0x5679),
	.iManufacturer =	STRINGID_MANUFACTURER,
	.iProduct =		STRINGID_PRODUCT,
	.iSerialNumber =	STRINGID_SERIAL,
	.bNumConfigurations =	1,
};

static struct usb_config_descriptor keyb_config0 = {
	.bLength		= sizeof(keyb_config0),
	.bDescriptorType	= USB_DT_CONFIG,

	/* wTotalLength is set up by usb-emul-uclass */
	.bNumInterfaces		= 2,
	.bConfigurationValue	= 0,
	.iConfiguration		= 0,
	.bmAttributes		= 1 << 7 | 1 << 5,
	.bMaxPower		= 50,
};

static struct usb_interface_descriptor keyb_interface0 = {
	.bLength		= sizeof(keyb_interface0),
	.bDescriptorType	= USB_DT_INTERFACE,

	.bInterfaceNumber	= 0,
	.bAlternateSetting	= 0,
	.bNumEndpoints		= 1,
	.bInterfaceClass	= USB_CLASS_HID,
	.bInterfaceSubClass	= USB_SUB_HID_BOOT,
	.bInterfaceProtocol	= USB_PROT_HID_KEYBOARD,
	.iInterface		= 0,
};

static struct usb_class_hid_descriptor keyb_report0 = {
	.bLength		= sizeof(keyb_report0),
	.bDescriptorType	= USB_DT_HID,
	.bcdCDC			= 0x101,
	.bCountryCode		= 0,
	.bNumDescriptors	= 1,
	.bDescriptorType0	= USB_DT_HID_REPORT,
	.wDescriptorLength0	= 0x3f,
};

static struct usb_endpoint_descriptor keyb_endpoint0_in = {
	.bLength		= USB_DT_ENDPOINT_SIZE,
	.bDescriptorType	= USB_DT_ENDPOINT,

	.bEndpointAddress	= SANDBOX_KEYB_EP_IN | USB_ENDPOINT_DIR_MASK,
	.bmAttributes		= USB_ENDPOINT_XFER_BULK |
					USB_ENDPOINT_XFER_ISOC,
	.wMaxPacketSize		= __constant_cpu_to_le16(8),
	.bInterval		= 0xa,
};

static struct usb_interface_descriptor keyb_interface1 = {
	.bLength		= sizeof(keyb_interface1),
	.bDescriptorType	= USB_DT_INTERFACE,

	.bInterfaceNumber	= 1,
	.bAlternateSetting	= 0,
	.bNumEndpoints		= 1,
	.bInterfaceClass	= USB_CLASS_HID,
	.bInterfaceSubClass	= USB_SUB_HID_BOOT,
	.bInterfaceProtocol	= USB_PROT_HID_MOUSE,
	.iInterface		= 0,
};

static struct usb_class_hid_descriptor keyb_report1 = {
	.bLength		= sizeof(struct usb_class_hid_descriptor),
	.bDescriptorType	= USB_DT_HID,
	.bcdCDC			= 0x101,
	.bCountryCode		= 0,
	.bNumDescriptors	= 1,
	.bDescriptorType0	= USB_DT_HID_REPORT,
	.wDescriptorLength0	= 0x32,
};

static struct usb_endpoint_descriptor keyb_endpoint1_in = {
	.bLength		= USB_DT_ENDPOINT_SIZE,
	.bDescriptorType	= USB_DT_ENDPOINT,

	.bEndpointAddress	= SANDBOX_KEYB_EP_IN | USB_ENDPOINT_DIR_MASK,
	.bmAttributes		= USB_ENDPOINT_XFER_BULK |
					USB_ENDPOINT_XFER_ISOC,
	.wMaxPacketSize		= __constant_cpu_to_le16(8),
	.bInterval		= 0xa,
};

static void *keyb_desc_list[] = {
	&keyb_device_desc,
	&keyb_config0,
	&keyb_interface0,
	&keyb_report0,
	&keyb_endpoint0_in,
	&keyb_interface1,
	&keyb_report1,
	&keyb_endpoint1_in,
	NULL,
};

int sandbox_usb_keyb_add_string(struct udevice *dev, const char *str)
{
	struct sandbox_keyb_priv *priv = dev_get_priv(dev);
	int len, ret;

	len = strlen(str);
	ret = membuff_put(&priv->in, str, len);
	if (ret != len)
		return -ENOSPC;

	return 0;
}

static int sandbox_keyb_control(struct udevice *dev, struct usb_device *udev,
				unsigned long pipe, void *buff, int len,
				struct devrequest *setup)
{
	debug("pipe=%lx\n", pipe);

	return -EIO;
}

static int sandbox_keyb_interrupt(struct udevice *dev, struct usb_device *udev,
		unsigned long pipe, void *buffer, int length, int interval)
{
	struct sandbox_keyb_priv *priv = dev_get_priv(dev);
	uint8_t *data = buffer;
	int ch;

	memset(data, '\0', length);
	ch = membuff_getbyte(&priv->in);
	if (ch != -1)
		data[2] = 4 + ch - 'a';

	return 0;
}

static int sandbox_keyb_bind(struct udevice *dev)
{
	struct sandbox_keyb_plat *plat = dev_get_platdata(dev);
	struct usb_string *fs;

	fs = plat->keyb_strings;
	fs[0].id = STRINGID_MANUFACTURER;
	fs[0].s = "sandbox";
	fs[1].id = STRINGID_PRODUCT;
	fs[1].s = "keyboard";
	fs[2].id = STRINGID_SERIAL;
	fs[2].s = dev->name;

	return usb_emul_setup_device(dev, plat->keyb_strings, keyb_desc_list);
}

static int sandbox_keyb_probe(struct udevice *dev)
{
	struct sandbox_keyb_priv *priv = dev_get_priv(dev);

	return membuff_new(&priv->in, 256);
}

static const struct dm_usb_ops sandbox_usb_keyb_ops = {
	.control	= sandbox_keyb_control,
	.interrupt	= sandbox_keyb_interrupt,
};

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

U_BOOT_DRIVER(usb_sandbox_keyb) = {
	.name	= "usb_sandbox_keyb",
	.id	= UCLASS_USB_EMUL,
	.of_match = sandbox_usb_keyb_ids,
	.bind	= sandbox_keyb_bind,
	.probe	= sandbox_keyb_probe,
	.ops	= &sandbox_usb_keyb_ops,
	.priv_auto_alloc_size = sizeof(struct sandbox_keyb_priv),
	.platdata_auto_alloc_size = sizeof(struct sandbox_keyb_plat),
};
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
d8a26f03 SG	2	/*
	3	* (C) Copyright 2015 Google, Inc
	4	* Written by Simon Glass <sjg@chromium.org>
d8a26f03 SG	5	*/
	6
	7	#include <common.h>
	8	#include <dm.h>
	9	#include <os.h>
	10	#include <scsi.h>
	11	#include <usb.h>
	12
d8a26f03 SG	13	/*
	14	* This driver emulates a USB keyboard using the USB HID specification (boot
	15	* protocol)
	16	*/
	17
	18	enum {
	19	SANDBOX_KEYB_EP_IN = 1, /* endpoints */
	20	};
	21
	22	enum cmd_phase {
	23	PHASE_START,
	24	PHASE_DATA,
	25	PHASE_STATUS,
	26	};
	27
	28	enum {
	29	STRINGID_MANUFACTURER = 1,
	30	STRINGID_PRODUCT,
	31	STRINGID_SERIAL,
	32
	33	STRINGID_COUNT,
	34	};
	35
	36	/**
	37	* struct sandbox_keyb_priv - private state for this driver
	38	*
	39	*/
	40	struct sandbox_keyb_priv {
	41	struct membuff in;
	42	};
	43
	44	struct sandbox_keyb_plat {
	45	struct usb_string keyb_strings[STRINGID_COUNT];
	46	};
	47
	48	static struct usb_device_descriptor keyb_device_desc = {
	49	.bLength = sizeof(keyb_device_desc),
	50	.bDescriptorType = USB_DT_DEVICE,
	51
	52	.bcdUSB = __constant_cpu_to_le16(0x0100),
	53
	54	.bDeviceClass = 0,
	55	.bDeviceSubClass = 0,
	56	.bDeviceProtocol = 0,
	57
	58	.idVendor = __constant_cpu_to_le16(0x1234),
	59	.idProduct = __constant_cpu_to_le16(0x5679),
	60	.iManufacturer = STRINGID_MANUFACTURER,
	61	.iProduct = STRINGID_PRODUCT,
	62	.iSerialNumber = STRINGID_SERIAL,
	63	.bNumConfigurations = 1,
	64	};
	65
	66	static struct usb_config_descriptor keyb_config0 = {
	67	.bLength = sizeof(keyb_config0),
	68	.bDescriptorType = USB_DT_CONFIG,
	69
	70	/* wTotalLength is set up by usb-emul-uclass */
	71	.bNumInterfaces = 2,
	72	.bConfigurationValue = 0,
	73	.iConfiguration = 0,
	74	.bmAttributes = 1 << 7 \| 1 << 5,
	75	.bMaxPower = 50,
	76	};
77
78	static struct usb_interface_descriptor keyb_interface0 = {
79	.bLength = sizeof(keyb_interface0),
80	.bDescriptorType = USB_DT_INTERFACE,
81
82	.bInterfaceNumber = 0,
83	.bAlternateSetting = 0,
84	.bNumEndpoints = 1,
85	.bInterfaceClass = USB_CLASS_HID,
86	.bInterfaceSubClass = USB_SUB_HID_BOOT,
87	.bInterfaceProtocol = USB_PROT_HID_KEYBOARD,
88	.iInterface = 0,
89	};
90
91	static struct usb_class_hid_descriptor keyb_report0 = {
92	.bLength = sizeof(keyb_report0),
93	.bDescriptorType = USB_DT_HID,
94	.bcdCDC = 0x101,
95	.bCountryCode = 0,
96	.bNumDescriptors = 1,
97	.bDescriptorType0 = USB_DT_HID_REPORT,
98	.wDescriptorLength0 = 0x3f,
99	};
100
101	static struct usb_endpoint_descriptor keyb_endpoint0_in = {
102	.bLength = USB_DT_ENDPOINT_SIZE,
103	.bDescriptorType = USB_DT_ENDPOINT,
104
105	.bEndpointAddress = SANDBOX_KEYB_EP_IN \| USB_ENDPOINT_DIR_MASK,
106	.bmAttributes = USB_ENDPOINT_XFER_BULK \|
107	USB_ENDPOINT_XFER_ISOC,
108	.wMaxPacketSize = __constant_cpu_to_le16(8),
109	.bInterval = 0xa,
110	};
111
112	static struct usb_interface_descriptor keyb_interface1 = {
113	.bLength = sizeof(keyb_interface1),
114	.bDescriptorType = USB_DT_INTERFACE,
115
116	.bInterfaceNumber = 1,
117	.bAlternateSetting = 0,
118	.bNumEndpoints = 1,
119	.bInterfaceClass = USB_CLASS_HID,
120	.bInterfaceSubClass = USB_SUB_HID_BOOT,
121	.bInterfaceProtocol = USB_PROT_HID_MOUSE,
122	.iInterface = 0,
123	};
124
125	static struct usb_class_hid_descriptor keyb_report1 = {
126	.bLength = sizeof(struct usb_class_hid_descriptor),
127	.bDescriptorType = USB_DT_HID,
128	.bcdCDC = 0x101,
129	.bCountryCode = 0,
130	.bNumDescriptors = 1,
131	.bDescriptorType0 = USB_DT_HID_REPORT,
132	.wDescriptorLength0 = 0x32,
133	};
134
135	static struct usb_endpoint_descriptor keyb_endpoint1_in = {
136	.bLength = USB_DT_ENDPOINT_SIZE,
137	.bDescriptorType = USB_DT_ENDPOINT,
138
139	.bEndpointAddress = SANDBOX_KEYB_EP_IN \| USB_ENDPOINT_DIR_MASK,
140	.bmAttributes = USB_ENDPOINT_XFER_BULK \|
141	USB_ENDPOINT_XFER_ISOC,
142	.wMaxPacketSize = __constant_cpu_to_le16(8),
143	.bInterval = 0xa,
144	};
145
146	static void *keyb_desc_list[] = {
147	&keyb_device_desc,
148	&keyb_config0,
149	&keyb_interface0,
150	&keyb_report0,
151	&keyb_endpoint0_in,
152	&keyb_interface1,
153	&keyb_report1,
154	&keyb_endpoint1_in,
155	NULL,
156	};
157
158	int sandbox_usb_keyb_add_string(struct udevice dev, const char str)
159	{
160	struct sandbox_keyb_priv *priv = dev_get_priv(dev);
161	int len, ret;
162
163	len = strlen(str);
164	ret = membuff_put(&priv->in, str, len);
165	if (ret != len)
166	return -ENOSPC;
167
168	return 0;
169	}
170
171	static int sandbox_keyb_control(struct udevice dev, struct usb_device udev,
172	unsigned long pipe, void *buff, int len,
173	struct devrequest *setup)
174	{
175	debug("pipe=%lx\n", pipe);
176
177	return -EIO;
178	}
179
180	static int sandbox_keyb_interrupt(struct udevice dev, struct usb_device udev,
181	unsigned long pipe, void *buffer, int length, int interval)
182	{
183	struct sandbox_keyb_priv *priv = dev_get_priv(dev);
184	uint8_t *data = buffer;
185	int ch;
186
187	memset(data, '\0', length);
188	ch = membuff_getbyte(&priv->in);
189	if (ch != -1)
190	data[2] = 4 + ch - 'a';
191
192	return 0;
193	}
194
195	static int sandbox_keyb_bind(struct udevice *dev)
196	{
197	struct sandbox_keyb_plat *plat = dev_get_platdata(dev);
198	struct usb_string *fs;
199
200	fs = plat->keyb_strings;
201	fs[0].id = STRINGID_MANUFACTURER;
202	fs[0].s = "sandbox";
203	fs[1].id = STRINGID_PRODUCT;
204	fs[1].s = "keyboard";
205	fs[2].id = STRINGID_SERIAL;
206	fs[2].s = dev->name;
207
98b639fc	208	return usb_emul_setup_device(dev, plat->keyb_strings, keyb_desc_list);
d8a26f03 SG	209	}
	210
	211	static int sandbox_keyb_probe(struct udevice *dev)
	212	{
	213	struct sandbox_keyb_priv *priv = dev_get_priv(dev);
	214
	215	return membuff_new(&priv->in, 256);
	216	}
	217
	218	static const struct dm_usb_ops sandbox_usb_keyb_ops = {
	219	.control = sandbox_keyb_control,
	220	.interrupt = sandbox_keyb_interrupt,
	221	};
	222
	223	static const struct udevice_id sandbox_usb_keyb_ids[] = {
	224	{ .compatible = "sandbox,usb-keyb" },
	225	{ }
	226	};
	227
	228	U_BOOT_DRIVER(usb_sandbox_keyb) = {
	229	.name = "usb_sandbox_keyb",
	230	.id = UCLASS_USB_EMUL,
	231	.of_match = sandbox_usb_keyb_ids,
	232	.bind = sandbox_keyb_bind,
	233	.probe = sandbox_keyb_probe,
	234	.ops = &sandbox_usb_keyb_ops,
	235	.priv_auto_alloc_size = sizeof(struct sandbox_keyb_priv),
	236	.platdata_auto_alloc_size = sizeof(struct sandbox_keyb_plat),
	237	};